From f141046b6e2671124619ab8ee157cd01612f9926 Mon Sep 17 00:00:00 2001 From: agudys Date: Wed, 26 Jun 2024 22:56:10 +0200 Subject: [PATCH] Initial commit --- .gitignore | 162 + .gitmodules | 13 + 3rd_party/clusty | 1 + 3rd_party/kmer-db | 1 + 3rd_party/lz-ani | 1 + 3rd_party/ref-utils | 1 + LICENSE | 674 +++ README.md | 397 ++ example/fna/NC_002486.alt.fna | 762 +++ example/fna/NC_002486.ref.fna | 762 +++ example/fna/NC_005091.alt1.fna | 959 ++++ example/fna/NC_005091.alt2.fna | 1063 ++++ example/fna/NC_005091.ref.fna | 959 ++++ example/fna/NC_010807.alt1.fna | 648 +++ example/fna/NC_010807.alt2.fna | 677 +++ example/fna/NC_010807.alt3.fna | 666 +++ example/fna/NC_010807.ref.fna | 648 +++ example/fna/NC_025457.alt1.fna | 686 +++ example/fna/NC_025457.alt2.fna | 1071 ++++ example/fna/NC_025457.ref.fna | 712 +++ example/multifasta.fna | 9613 ++++++++++++++++++++++++++++++++ example/output/ani.ids.tsv | 13 + example/output/ani.tsv | 133 + example/output/clusters.tsv | 13 + example/output/fltr.txt | 13 + example/readme.txt | 11 + images/logo.png | Bin 0 -> 1452 bytes images/logo.svg | 285 + makefile | 34 + test.py | 298 + vclust.py | 1185 ++++ 31 files changed, 22461 insertions(+) create mode 100644 .gitignore create mode 100644 .gitmodules create mode 160000 3rd_party/clusty create mode 160000 3rd_party/kmer-db create mode 160000 3rd_party/lz-ani create mode 160000 3rd_party/ref-utils create mode 100644 LICENSE create mode 100644 README.md create mode 100644 example/fna/NC_002486.alt.fna create mode 100644 example/fna/NC_002486.ref.fna create mode 100644 example/fna/NC_005091.alt1.fna create mode 100644 example/fna/NC_005091.alt2.fna create mode 100644 example/fna/NC_005091.ref.fna create mode 100644 example/fna/NC_010807.alt1.fna create mode 100644 example/fna/NC_010807.alt2.fna create mode 100644 example/fna/NC_010807.alt3.fna create mode 100644 example/fna/NC_010807.ref.fna create mode 100644 example/fna/NC_025457.alt1.fna create mode 100644 example/fna/NC_025457.alt2.fna create mode 100644 example/fna/NC_025457.ref.fna create mode 100644 example/multifasta.fna create mode 100644 example/output/ani.ids.tsv create mode 100644 example/output/ani.tsv create mode 100644 example/output/clusters.tsv create mode 100644 example/output/fltr.txt create mode 100644 example/readme.txt create mode 100644 images/logo.png create mode 100755 images/logo.svg create mode 100644 makefile create mode 100755 test.py create mode 100755 vclust.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..060cb2c --- /dev/null +++ b/.gitignore @@ -0,0 +1,162 @@ +bin/ + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..569e037 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,13 @@ +[submodule "3rd_party/kmer-db"] + path = 3rd_party/kmer-db + url = https://github.com/refresh-bio/kmer-db-dev.git + branch = develop +[submodule "3rd_party/lz-ani"] + path = 3rd_party/lz-ani + url = https://github.com/refresh-bio/LZ-ANI.git +[submodule "3rd_party/ref-utils"] + path = 3rd_party/ref-utils + url = https://github.com/refresh-bio/ref-utils-dev.git +[submodule "3rd_party/clusty"] + path = 3rd_party/clusty + url = https://github.com/refresh-bio/clusty-dev.git diff --git a/3rd_party/clusty b/3rd_party/clusty new file mode 160000 index 0000000..96d3913 --- /dev/null +++ b/3rd_party/clusty @@ -0,0 +1 @@ +Subproject commit 96d391307ad442c6974f4f8719edf05311654f49 diff --git a/3rd_party/kmer-db b/3rd_party/kmer-db new file mode 160000 index 0000000..c842786 --- /dev/null +++ b/3rd_party/kmer-db @@ -0,0 +1 @@ +Subproject commit c8427863eb4faaa197b398d7c005b914a508cd44 diff --git a/3rd_party/lz-ani b/3rd_party/lz-ani new file mode 160000 index 0000000..4100c98 --- /dev/null +++ b/3rd_party/lz-ani @@ -0,0 +1 @@ +Subproject commit 4100c98e96bc906d51036daa0d2b81096c446a0b diff --git a/3rd_party/ref-utils b/3rd_party/ref-utils new file mode 160000 index 0000000..9dda46d --- /dev/null +++ b/3rd_party/ref-utils @@ -0,0 +1 @@ +Subproject commit 9dda46dfa6951887f87fe8c1d38268ff1bc56d13 diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..3877ae0 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/README.md b/README.md new file mode 100644 index 0000000..1070f7f --- /dev/null +++ b/README.md @@ -0,0 +1,397 @@ +# Vclust logo Vclust + +Vclust is an alignment-based tool for fast and accurate calculation of Average Nucleotide Identity (ANI) between complete or metagenomically-assembled viral genomes. The tool also performs ANI-based clustering of genomes according to standards recommended by international virus consortia, including *International Committee on Taxonomy of Viruses* (ICTV) and *Minimum Information about an Uncultivated Virus Genome* (MIUViG). + + +## Table of contents + +1. [Features](#1-features) +2. [Installation](#2-installation) +3. [Quick Start](#3-quick-start) +4. [Input data](#4-input-data) +5. [Usage](#5-usage) + 1. [Prefilter](#51-prefilter) + 2. [Align](#52-align) + * [Align output](#align-output) + * [Align output filtering](#align-output-filtering) + 3. [Cluster](#53-cluster) + * [Cluster output](#cluster-output) +6. [Examples](#examples) + 1. [Classify viruses into species and genera using the ICTV standards](#61-classify-viruses-into-species-and-genera-using-the-ictv-standards) + 2. [Assign viral contigs into vOTUs using the MIUViG standards](#62-assign-viral-contigs-into-votus-using-the-miuvig-standards) + 3. [Dereplicate genomes](#63-dereplicate-genomes) + 4. [Calculate pairwise similarities between all-versus-all genomes](#64-calculate-pairwise-similarities-between-all-versus-all-genomes) + 5. [Process large datasets](#65-process-large-datasets) +7. [Tests](#7-test) +8. [Cite](#8-cite) +9. [License](#9-license) + + +## 1. Features + +#### :gem: Accurate ANI calculations + +Vclust uses a Lempel-Ziv-based pairwise sequence aligner ([LZ-ANI](https://github.com/refresh-bio/LZ-ANI)) for ANI calculation. LZ-ANI achieves high sensitivity in detecting matched and mismatched nucleotides, ensuring accurate ANI determination. Its efficiency comes from a simplified indel handling model, making LZ-ANI magnitudes faster than alignment-based tools (e.g., BLASTn, MegaBLAST) while maintaining comparable accuracy to the most sensitive BLASTn searches. + +#### :triangular_ruler: Multiple similarity measures + +Vclust offers multiple similarity measures between two genome sequences, whereas other tools typically provide only one or two. +- **ANI**: The number of identical nucleotides across local alignments divided by the total length of the alignments. +- **Global ANI (gANI)**: The number of identical nucleotides across local alignments divided by the length of the query/target genome. +- **Total ANI (tANI)**: The number of identical nucleotides between query-target and target-query genomes divided by the sum length of both genomes. tANI is equivalent to the VIRIDIC's intergenomic similarity. +- **Coverage (alignment fraction)**: The proportion of the query sequence aligned with the target sequence. +- **Number of local alignments**: The count of individual alignments found between the sequences. +- **Ratio between query and target genome lengths**: A measure comparing the lengths of the two genomes. + +#### :star2: Multiple clustering algorithms + +Vclust provides six clustering algorithms tailored to various scenarios, including taxonomic classification and dereplication of viral genomes. +- Single-linkage +- Complete-linkage +- UCLUST +- CD-HIT (Greedy incremental) +- Greedy set cover (adopted from MMseqs2) +- Leiden algorithm + +#### :fire: Speed and efficiency + +Vclust uses three efficient C++ tools - [Kmer-db](https://github.com/refresh-bio/kmer-db), [LZ-ANI](https://github.com/refresh-bio/LZ-ANI), [Clusty](https://github.com/refresh-bio/clusty) - for prefiltering, aligning, calculating ANI, and clustering viral genomes. This combination enables the processing of millions of virus genomes within a few hours on a mid-range workstation. + +#### :earth_americas: Web service + +For datasets containing up to 1000 viral genomes, Vclust is available at [http://www.vclust.org](http://www.vclust.org). + + +## 2. Installation + +To install Vclust you can compile dependencies from source or download statically compiled binaries. + +### Option 1: Compile from source + +Clone this repository recursively with submodules and compile it. + +```bash +git clone --recurse-submodules https://github.com/refresh-bio/vclust-dev +cd vclust-dev +make -j +``` + +### Option 2: Download precompiled binaries + +TODO + +## 3. Quick start + +1. **Prefilter** similar genome sequence pairs before conducting pairwise alignments. + +```bash +./vclust.py prefilter -i example/multifasta.fna -o fltr.txt +``` + +2. **Align** similar genome sequence pairs and calculate pairwise ANI measures. + +```bash +./vclust.py align -i example/multifasta.fna -o ani.tsv --filter fltr.txt +``` + +3. **Cluster** genome sequences based on given ANI measure and minimum threshold. + +```bash +./vclust.py cluster -i ani.tsv -o clusters.tsv --ids ani.data.tsv --metric ani --ani 0.95 +``` + +## 4. Input data + +Vclust accepts a single FASTA file containing viral genomic sequences ([example](./example/multifasta.fna)) or a directory of FASTA files (one genome per file) ([example](./example/fna/)). The input file(s) can be gzipped. + +## 5. Usage + +Vclust provides three commands: `prefilter`, `align`, and `cluster`. Calls to these commands follow the structure: + +``` +./vclust.py command -i -o [options] +``` + + +### 5.1. Prefilter + +The `prefilter` command creates a pre-alignment filter, which eliminates dissimilar genome pairs before calculating pairwise alignments. This process reduces the number of potential genome pairs to only those with sufficient *k*-mer-based sequence similarity. The *k*-mer-based sequence similarity between two genomes is controlled by two options: minimum number of common *k*-mers (`--min-kmers`) and minimum sequence identity of the shorter sequence (`--min-ident`). Both *k*-mer-based similarities are computed using [Kmer-db 2](https://github.com/refresh-bio/kmer-db) which evaluates the entire set of *k*-mers, overcoming the sampling constraints typical of sketching methods like FastANI and Mash. In addittion, the use of sparse distance matrices enables memory-efficient processing of millions of genomes. + +```bash +# Create a pre-alignment filter with genome sequence pairs that have +# at least 30 common 25-mers and 70% of identity over the shorter sequence. +./vclust.py prefilter -i genomes.fna -o fltr.txt --k 25 --min-kmers 30 --min-ident 0.7 +``` + +To reduce memory consumption, large sets of genome sequences can be processed in smaller, equally-sized, batches of sequences. + +```bash +# Process genomes in batches of 5 million sequences each. +./vclust.py prefilter -i genomes.fna -o fltr.txt --batch-size 5000000 +``` + +### 5.2. Align + +The `align` command conducts pairwise sequence alignments among viral genomes and provides similarity measures like ANI and coverage (alignment fraction). For this purpose, Vclust uses the fast and efficient [LZ-ANI](https://github.com/refresh-bio/LZ-ANI) aligner. + +```bash +# Align genome pairs filtered by the prefiltering command. +./vclust.py align -i genomes.fna -o ani.tsv --filter fltr.txt +``` + +The `align` command allows for further filtering based on filter's minimum threshold. + +```bash +# Align only the genome pairs with sequence identity greater than or equal to 80%. +./vclust.py align -i genomes.fna -o ani.tsv --filter fltr.txt --filter-threshold 0.8 +``` + +Without `--filter` Vclust aligns all possible genome pairs. + +```bash +./vclust.py align -i genomes.fna -o ani.tsv +``` + +#### Align output + +The `align` command creates two TSV files: one with ANI values for genome pairs and another with genome identifiers sorted by decreasing sequence length. Both TSV files can be used as input for Vclust's clustering. + +The following command will create two TSV files: [ani.tsv](./example/output/ani.tsv) and [ani.ids.tsv](./example/output/ani.ids.tsv): + +```bash +./vclust.py align -i genomes.fna -o ani.tsv --filter fltr.txt +``` + +Sample output: + +``` +idx1 idx2 id1 id2 tani gani ani cov num_alns len_rat +8 9 NC_010807.alt2 NC_010807.alt3 0.969793 0.980939 0.986608 0.994255 51 1.0166 +9 8 NC_010807.alt3 NC_010807.alt2 0.969793 0.958462 0.985184 0.972876 48 0.9836 +8 10 NC_010807.alt2 NC_010807.alt1 0.986229 0.986266 0.986363 0.999901 29 1.0448 +10 8 NC_010807.alt1 NC_010807.alt2 0.986229 0.986191 0.986216 0.999974 28 0.9570 +8 11 NC_010807.alt2 NC_010807.ref 0.989467 0.989693 0.989693 1.000000 8 1.0448 +11 8 NC_010807.ref NC_010807.alt2 0.989467 0.989231 0.989231 1.000000 8 0.9570 +9 10 NC_010807.alt3 NC_010807.alt1 0.971502 0.958863 0.992810 0.965807 58 1.0277 +10 9 NC_010807.alt1 NC_010807.alt3 0.971502 0.984491 0.993113 0.991318 56 0.9730 +9 11 NC_010807.alt3 NC_010807.ref 0.982555 0.968865 0.995800 0.972951 44 1.0277 +11 9 NC_010807.ref NC_010807.alt3 0.982555 0.996625 0.996676 0.999948 44 0.9730 +10 11 NC_010807.alt1 NC_010807.ref 0.996664 0.996548 0.996548 1.000000 22 1.0000 +11 10 NC_010807.ref NC_010807.alt1 0.996664 0.996780 0.996780 1.000000 22 1.0000 +``` + +To manage the output TSV file size, Vclust offers three formats: `standard`, `lite`, `complete`. + +```bash +./vclust.py align -i genomes.fna -o ani.tsv --filter fltr.txt --outfmt lite +``` + +| Column | Standard | Lite | Complete | Description | +| --- | :---: |:---: | :---: | --- | +| idx1 | + | + | + | index of sequence 1 | +| idx2 | + | + | + | index of sequence 2 | +| id1 | + | - | + | identifier (name) of sequence 1 | +| id2 | + | - | + | identifier (name) of sequence 2 | +| tani | + | + | + | total ANI [0-1] | +| gani | + | + | + | global ANI [0-1] | +| ani | + | + | + | ANI [0-1] | +| cov | + | + | + | Coverage (alignment fraction) [0-1] | +| num_alns | + | + | + | Number of alignments | +| len_ratio | + | + | + | Length ratio between sequence 1 and sequence 2 | +| len1 | - | - | + | Length of sequence 1 | +| len2 | - | - | + | Length of sequence 2| +| nt_match | - | - | + | Number of matching nucleotides across alignments | +| nt_mismatch | - | - | + | Number of mismatching nucleotides across alignments | + +#### Align output filtering + +The `align` command enables filtering output by setting minimum thresholds for similarity measures. This ensures only genome pairs meeting the thresholds are reported, significantly reducing the output TSV file size. + +```bash +# Output only genome pairs with ANI ≥ 0.75 and coverage ≥ 0.75. +./vclust.py align -i genomes.fna -o ani.tsv --filter fltr.txt --out-ani 0.75 --out-cov 0.75 +``` + +### 5.3. Cluster + +The `cluster` command takes as input two TSV files (outputs of `vclust align`) and clusters viral genomes using a user-selected clustering algorithm and similarity measures. Internally, Vclust uses [Clusty](https://github.com/refresh-bio/clusty), enabling large-scale clustering of millions of genome sequences by leveraging sparse distance matrices. + +Vclust supports six clustering algorithms (`--algorithm`): + +1. `single`: Single-linkage clustering +2. `complete`: Complete-linkage clustering +3. `uclust`: UCLUST-like clustering +4. `cd-hit`: Greedy incremental clustering +5. `set-cover`: Set-Cover (greedy) +6. `leiden`: the Leiden algorithm + +Clustering uses one of three similarity measures (`--metric`): `tani`, `gani`, or `ani`. The user-provided threshold for the selected measure sets the minimum similarity required for connecting genomes. + +```bash +# Cluster genomes based on ANI and connect genomes if their ANI ≥ 95%. +./vclust cluster -i ani.tsv -o clusters.tsv --ids ani.ids.tsv --algorithm single \ +--metric ani --ani 0.95 +``` + +Additionally, Vclust may use extra threshold values for various combinations of similarity measures (`--ani`, `--gani`, `--tani`, `--cov`, `--num_alns`). If a genome pair fails to meet the specified thresholds, it is excluded from clustering. + +```bash +# Cluster genomes based on ANI similarity measure, but connect them only +# if ANI ≥ 95% and coverage ≥ 85%. +./vclust cluster -i ani.tsv -o clusters.tsv --ids ani.ids.tsv --algorithm single \ +--metric ani --ani 0.95 --cov 0.85 +``` + +#### Cluster output + +The cluster command generates a TSV file with genome identifiers followed by 0-based cluster identifiers. The file includes all input genomes, both clustered and singletons, listed in the same order as the IDs file (sorted by decreasing sequence length). The first genome in each cluster is the representative. For example, cluster `0` has `NC_005091.alt2` as its representative and includes `NC_005091.alt1` and `NC_005091.ref`. + +``` +object cluster +NC_025457.alt2 3 +NC_005091.alt2 0 +NC_005091.alt1 0 +NC_005091.ref 0 +NC_002486.alt 1 +NC_002486.ref 1 +NC_025457.ref 4 +NC_025457.alt1 5 +NC_010807.alt2 2 +NC_010807.alt3 2 +NC_010807.alt1 2 +NC_010807.ref 2 +``` + +Alternatively, instead of numerical cluster identifiers, Vclust can output a representative genome for each cluster using the `--out-repr` option. The representative genome within each cluster is determined as the one with the longest sequence. + +``` +object cluster +NC_025457.alt2 NC_025457.alt2 +NC_005091.alt2 NC_005091.alt2 +NC_005091.alt1 NC_005091.alt2 +NC_005091.ref NC_005091.alt2 +NC_002486.alt NC_002486.alt +NC_002486.ref NC_002486.alt +NC_025457.ref NC_025457.ref +NC_025457.alt1 NC_025457.alt1 +NC_010807.alt2 NC_010807.alt2 +NC_010807.alt3 NC_010807.alt2 +NC_010807.alt1 NC_010807.alt2 +NC_010807.ref NC_010807.alt2 +``` + +## 6. Examples + +### 6.1. Classify viruses into species and genera using the ICTV standards + +The following commands perform VIRIDIC-like analysis by calculating the total ANI (tANI) between complete virus genomes and classifying these viruses into species and genera based on 95% and 70% tANI, respectively. + +```bash +# Create a pre-alignment filter for genome pairs with a minimum of 10 common k-mers +# and a minimum sequence identity of 70% (relative to the shortest sequence). +./vclust prefilter -i genomes.fna -o fltr.txt --min_kmers 10 --min-ident 0.7 +``` + +```bash +# Calculate ANI measures for genome pairs specified in the filter. +./vclust align -i genomes -o ani.tsv --filter fltr.txt +``` + +```bash +# Assign viruses into putative species (tANI ≥ 95%). +./vclust cluster -i ani.tsv -o species.tsv --ids ani.ids.tsv --algorithm complete \ +--metric tani --tani 0.95 + +# Assign viruses into putative genera (tANI ≥ 70%). +./vclust cluster -i ani.tsv -o genus.tsv --ids ani.ids.tsv --algorithm complete \ +--metric tani --tani 0.70 +``` + +### 6.2. Assign viral contigs into vOTUs using the MIUViG standards + +The following commands assign contigs into viral operational taxonomic units (vOTUs) based on the MIUViG thresholds (ANI ≥ 95% and aligned fraction ≥ 85%). + +```bash +# Create a pre-alignment filter. +./vclust prefilter -i genomes.fna -o fltr.txt --min_kmers 30 --min_ident 0.9 +``` + +```bash +# Calculate ANI measures for genome pairs specified in the filter. +./vclust align -i genomes -o ani.tsv --filter fltr.txt +``` + +```bash +# Cluster contigs into vOTUs using the MIUVIG thresholds and the Leiden algorithm. +./vclust cluster -i ani.tsv -o clusters.tsv --ids ani.ids.tsv --algorithm leiden \ +--metric ani --ani 0.95 --cov 0.85 +``` + +### 6.3. Dereplicate genomes + +The following commands reduce the sequence dataset to representative genomes. + +```bash +# Create a pre-alignment filter. +./vclust prefilter -i genomes.fna -o fltr.txt --min_kmers 30 --min_ident 0.90 +``` + +```bash +# Calculate ANI measures for genome pairs specified in the filter. +./vclust align -i genomes.fna -o ani.tsv --filter fltr.txt --out-ani 0.9 +``` + +```bash +# Cluster contigs using the UCLUST algorithm and show representative genome. +./vclust cluster -i ani.tsv -o clusters.tsv --ids ani.ids.tsv --algorithm uclust \ +--metric ani --ani 0.95 --cov 0.85 --out-repr +``` + +### 6.4. Calculate pairwise similarities between all-versus-all genomes + +The following command calculates ANI measures between all genome pairs in the dataset. For small datasets, using `prefilter` is optional. However, note that without it, Vclust will perform all-versus-all pairwise sequence alignments. + +```bash +./vclust.py align -i genomes.fna -o ani.tsv --outfmt complete +``` + +### 6.5. Process large datasets + +The following commands reduce RAM usage and hard disk storage for processing metagenomic contigs from the [IMG/VR](https://genome.jgi.doe.gov/portal/IMG_VR/IMG_VR.home.html) database. + +```bash +# Create a pre-alignment filter by processing batches of 5 million genomes. +./vclust prefilter -i genomes.fna -o fltr.txt --min_kmers 30 --min_ident 0.90 \ +--batch-size 5000000 +``` + +```bash +# Calculate ANI measures for genome pairs specified in the filter. Keep the output TSV +# file relatively small-sized: use the lite output format and report only genome pairs +# with ANI ≥ 90% and coverage ≥ 80%. +./vclust align -i genomes -o ani.tsv --filter fltr.txt --outfmt lite \ +--out-ani 0.9 --out-cov 0.8 +``` + +```bash +# Cluster contigs into vOTUs using the MIUVIG thresholds and the Leiden algorithm. +./vclust cluster -i ani.tsv -o clusters.tsv --ids ani.ids.tsv --algorithm leiden \ +--metric ani --ani 0.95 --cov 0.85 +``` + + +## 7. Test + +To ensure that Vclust works as expected, you can run tests using [pytest](https://docs.pytest.org/). + +```bash +pytest test.py +``` + +## 8. Cite + +Zielezinski A, Gudyś A, Barylski J, Siminski K, Rozwalak P, Dutilh BE, Deorowicz S. *Ultrafast and accurate sequence alignment and clustering of viral genomes*. bioRxiv [[doi](https://google.pl)][[pubmed](https://google.pl)]. + +## 9. License + +[GNU General Public License, version 3](https://www.gnu.org/licenses/gpl-3.0.html) diff --git a/example/fna/NC_002486.alt.fna b/example/fna/NC_002486.alt.fna new file mode 100644 index 0000000..0c2b83e --- /dev/null +++ b/example/fna/NC_002486.alt.fna @@ -0,0 +1,762 @@ +>NC_002486.alt length=45636 tani=100.000 alt=splitted in three equal-sized fragments, shuffled fragments, one fragment reverse complement +ATATCGGTGGTATGGTAGACGCTGTTAAAAGAGGTCTTAATAAATTAATTGAAGGTTTAA +ACTGGGTCGGTGGTAAGTTGGGTATGGACAAAATACCGAAGTTACACACTGGTACTGAAC +ATACGCATACTACTACAAGATTAGTTAAGAACGGTAAGATTGCGCGGGATACGTTCGCTA +CGGTTGGGGATAAAGGACGTGGAAATGGTCCGAATGGTTTCAGAAATGAAATGATTGAAT +TCCCTAATGGCAAACGTGTACTTACGCCTAATACAGATACGACAGCGTACTTACCTAAAG +GTTCAAAAGTATATAACGGCGCACAAACTTATTCAATGTTAAATGGAACGCTTCCAAGAT +TTAGCATAGGTACTATGTGGAAAGATATTAAATCCGGTGCATCATCGGCATTTAACTGGA +CAAAAGATCAAATAGGTAAAGGTACAAAGTGGCTTGGCGATAAAGTTGGTGATGTCATGG +ACTTTATCGATAATCCAGGCAAACTTTTAAATTATGTACTTCAAGCGTTTGGAGTTGATT +TCAGTTCTCTAACTAAAGGTATGGGTATTGCTGGCGATATAACAAAAGCTGCATGGTCTA +AGATTAAGAAAAGTGCAATCAAGTGGCTTGAGGATGCTTTCGCAGAGTCGGGTGATGGCG +GTGTAGTAGATATGAGTAAATTACGTTATTTATACGGTCACACTGCTGCTTATACACGAG +AAACCGGACGCCCATTCCATGAAGGTCTGGATTTTGATTACATTTACGAACCTGTTCCAT +CAACCATTAATGGTAGAGCACAAGTTATGCCTTTTCATAATGGTGGTTATGGAAAATGGG +TAAAAATTGTAAAGGGCGCCTTAGAAGTTATTTATGCACATTTATCTAAATATAAAGTTA +AAACTGGTCACCAAGTTAGGGTCGGCCAGACTGTTGGTATATCGGGGAATACGGGGTTTA +GTACAGGACCTCACTTACATTATGAGATGCGTTGGAATGGAAGACATAGAGACCCGTTAC +CGTGGTTAAGAAAGAATAATGGGGCGGCAAAAGTGCACCCGGTGGTAATGGTGCAGCTAA +TGCTAGACGAGCTATTAAGGCTGCTCAAAATATTTTAGGAGGAAGGTATAAGGCGAGTTG +GATTACTAACGAGATGATGCGTGTTGCGAGTCGTGAATCCAATTATACAGCTAATGCAGT +CAATAATTGGGATAGCAACGCAAGAGCTGGTATACCTTCAAGAGGTATGTTCCAAATGAT +AGATCCTTCATTTAGAGCGTACGCAAAGTCGGGTTACAATAATCCTCTCAACCCAACTCA +TCAAGCTATATCGGCTATGAGATATATTGTGGGTAAATGGGTACCAAGAACAGGCTCATG +GAGAGCTGCGTTCAAACGCGCTGGTGATTACGCATATGCTACTGGTGGCAAAGTCTATAA +CGGATTGTATCACTTAGGGGAAGAAGGATATCCAGAGTGGATAATACCTACTGATCCAAG +TAGAGCGAACGAAGCACACAAATTATTAGCTTTAGCTGCTAACGATATTGATAACCGCTC +TAAAAATAAGCGACCAAACAACTTACCAAATCCAAGTATAAGTAATAGTGATAGAAACTA +TATTCATACATTGGAGAATAAACTAGATGCGGTTATTAATTGTTTGGTTAGTTTGGTTGA +GTCTAATCAAGTTATTGCAGATAAGGATTACGAACCAGTTATTAATAAGTATGTGTTTGA +AGATGAGGTAAATAATTCTATCGATAAACGAGAGCGTCACGAATCTACAAGAGTTAGATT +TAGAAGAGGAGGCACGATAATCTAATGCAAGATACAATTCAAATAGACAATAAAACAATT +GGATGGCTGGTTGTGCAAAGAGGGTTCGAGATACCCTCTTTTAATTTTGTTACTGAAAAA +GAAAACGTAAAAGGTAGAGCGGGATCTATTGTTAAGAATCGTTATTTAAATGATATCGAA +TTTGATTTACCATTAATTATTCGAAACGAAAAATTGTCACCAGGTGGAGAAAAAACACAC +GATGATATATTAGAAGCATTGGTCAAGTTCTTCAATATTAAAGATTTAACACCTAAAAAA +CTTAAATTCAAATCTCAAAACTGGTATTGGTTTGCATATTTTGATGGTCCATTAAAATTA +CCGAAAAACCCAAGAGGTTCAGTGAAGTTCACTATAAAAGTAGTGTTAACAGATCCTTAT +AAATACTCGGTAACTGGAAACAAAAACACCGCGATTTCAGACCAAGTTTCAGTTGTAAAT +AGTGGGACTGCTGACACTCCTTTAATTGTTGAAGCCCGAGCAATTAAACCATCTAGTTAC +TTTATGATCACTAAAAATGATGAAGATTATTTTATGGTTGGTGATGATGAGGTAACCAAA +GAAGTTAAGGATTACATGCCTCCTGTTTATCATAGTGAGTTTCGTGATTTCAAAGGTTGG +ACTAAGATGATTACTGAAGATATTCCAAGTAATGATTTAGGTGGTAAGGTCGGCGGTGAC +TTTGTGATATCCAATCTTGGCGAAGGATATAAAGCAACTAATTTTCCTGATGCAAAAGGT +TGGGTTGGTGCTGGCACGAAACGAGGGCTCCCTAAAGCGATGACAGATTTTCAAATTACC +TATAAATGTATTGTTGAACAAAAAGGTAAAGGTGCCGGAAGAACAGCACAACATATTTAT +GATAGTGATGGTAAGTTACTTGCTTCTATTGGTTATGAAAATAAATATCATGATAGAAAA +ATAGGCCATATTGTTGTTACGTTGTATAACCAAAAAGGAGACCCCAAAAAGATATACGAC +TATCAGAATAAACCGATAATGTATAACTTGGACAGAATCGTTGTTTATATGCGGCTCAGA +AGAGTAGGTAATAAATTTTCTATTAAAACTTGGAAATTTGATCACATTAAAGACCCAGAT +AGACGTAAACCTATTGATATGGATGAGAAAGAGTGGATGGATGGCGGTAAGTTTTATCAG +CGTCCAGCTTCTATCATAGCTATCTACAGTGCAAAATATACCGGCTATAAATGGATGGAG +ATGAATGGATTAGGCTCATTCAATACTGAGATTTTACCGAAACCGAAAGGGGCAAGGGAC +GTTATTATACAAAAAGGTGATTTAGTAAAAATAGATATGCAAGCGAAGAGTGTTGTCATT +AACGAAGAACCAATGTTATCAGAGAAATCGTTTGGGAGTAATTATTTCAATGTTGAATCT +GGATACAGTGAGTTAATCATACAACCTGAAAACGTCTTTGATACGATGGTTAAATGGCAA +GATAGATATTTATAGAGAGGAGATGAAAATGTGATACATGTTTTAGATTTTAACGACAAA +ATCATAGATTTCCTTTCTACTGATGACCCTGCTTTAGTTAGAGCGATTCATAAACGGAAT +GTTAATGACAATTCAGAGATGCTCGAGTTGCTTATATCCTCAGAGAGAGCTGGAAAGTTT +CGTGAACGACATCGTGTTATTATAAGAGATTCAAATAAACAATGGCGTGAGTTTATTATT +AATTGGGTTCAGGACGATATGGACGGCTACACAGAAATAGAATGTATAGCGTCTTATTTA +GCTGATATAACAACAGCTAAACCGTTCGCACCTGGAAAGTTTGAGAAAAAGACAACTTCA +GAAGCATTGAAAGATGTGTTGAGCGATACAGGTTGGGAAGTTTCTGAACAAACCGAATAC +GATGGCTTACGTACTACGTCATGGACTTCTTATCAAACTAGATATGAAGTTTTAAAGCAA +TTATGTACAACATATAAAATGGTATTGGATTTTTATATTGAGCTTAGTTCTAATACCGTC +AAAGGTAGATATGTGGTACTCAAAAAGAAAAACAGCTTATTCAAAGGTAAAGAAATTGAG +TATGGTAAAGATTTGGTTGGGTTAACTAGGAAGATTGATATGTCAGAAATCAAAACAGCA +TTAATTGCTGTGGGACCCGAAAATGACAAAGGAAAGCGTTTAGAGTTAGTTGTGACAGAT +GACGAAGCACAAAGTCAATTCAACTTACCTACCCGTTATATTTGGGGAATATACGAACCT +CAATCAGACGATCAAAATATGAATGAAACACGATTACGTTCTTTAGCCAAAACGGAGTTA +AATAAACGCAAGTCAGCAGTCATGTCATATGAGATTACCTCTACTGATTTAGAAGCTACG +TATCCGCATGAGATTATCTCAATCGGAGATACAGTCAGGGTGAAACACAGAGATTTTAAC +CCGCCATTGTATGTAGAGGCAGAAGTTATAGCAGAAGAATATAATATGATTTCAGAAAAT +AGCACATATACGTTTGGCCAACCTAAAGAGTTCAAAGAATCTGAATTAAGAGAAGAGTTT +AACAAGCGATTAAACTTAATACACCAAAAGTTAAACGATAATATTAGTAATATCAACACT +ATAGTAAAAGACGTTGTAGATGGTGAATTAGAATACTTTGAACGCAAAATACACAAAAGT +GATACACCGCCAGAAAATCCAGTCAATGATATACTTTGGTATGATACAAGTAACCCTGAT +GTTGCTGTCTTGCGTAGATATTGGAATGGTGGATGGATTGAAGCAACGCCAAATGATGTT +GAAAAATTAGGTGGTATAACAAGAGAAAAAGCGCTATTCAGTGAATTAAACAATACTTTT +ATTAATTTATCTATACAACACGCTAGGCTTTTTTCAGAAGCTACAGAATTACTGAATAGC +GAGTACTTAGTAGATAATGATTTGAAAGCGGACTTACAAGCAAGTTTAGACGCTGTGATT +GATGTTTATAATCAAATTAAAAATAATTTAGAATCTATGACACCCGAAACTGCAACGATT +GGTCGGTTGGTAGATACACAAGCTTTATTTCTTGAGTATAGAAAGAAATTACAAGATGTT +TATACAGATGTAGAAGATGTCAAAATCTCCATTTCAGATAGATTTAAATTATTACAGTCA +CAATACACTGACGAAAAATATAAAGAAGCGTTGGAAATAATAGCAACAAAATTTGGTTTA +ACGGTGAATGAAGATTTGCAGTTAGTTGGAGAACCTAATGTTGTTAAATCAGCTATTGAA +GCAGCTAGAGAATCCACAAAAGAACAATTACGTGACTATGTAAAAACATCGGACTATAAA +ACAGACAAAGACGGTATTGTTGAACGTTTAGATACTGCTGAAGCTGAGAGAACGACTTTA +AAAGGTGAAATCAAAGATAAAGTTACGTTAAACGAATATCGAAACGGATTGGAAGAACAA +AAACAATATACTGACGACCAGTTAAGTGATTTGTCCAATAATCCTGAGATTAAAGCAAGT +ATTGAACAAGCAAATCAAGAAGCGCAAGAAGCTTTAAAATCATACATTGATGCTCAAGAT +GATCTTAAAGAGAAAGAATCGCAAGCGTATATTGATGGTAAAATTTCGGAAGAAGAGCAA +CGCGCTATACAAGACGCTCAAGCTAAACTTGAAGAGGCAAAACAAAACGCAGAACTAAAG +GCTAGAAACGTTGAAAAGAAAGCTCATGCTTATACAGACAACAAGGTCAAAGAAAGCACA +GATGCACAGAGAAAAACATTGACTCGCTATGGTTCTCAAATTATACAAAATGGTAAAGAA +ATCAAATCAAGAACTACTAAAGAAGAGTTTAATGCAACCAATCGTACACTTTCAAATATT +TTAGCTGAGATTGTCCAAAACGTTACAGATGGAACAACAATCAGATATGATGATAATGGG +GTGGCTCAAGCTTTAAATATAGGACCACAGGGAATTAGATTAAATGCTGATAAAATTGAT +ATTAGCGGTAATAGAGAAATAAATCTTCTTATCCAAAATATGCGAGATAAAGTAGATAAA +ACCGATATTGTCAACAGTCTTAATTTATCAAGAGAGGGTCTTGATATCAATGTTAATAGA +ATTGGAATTAAAGGCGGTGACAATAACAGATATGTTCAAATACAGAATGATTCTATTGAA +CTAGGTGGTATTGTGCAACGTACTTGGAGAGGGAAACGTTCAACAGACGATATTTTTACG +CGACTGAAAGACGGTCACCTAAGATTTAGAAATAACACCGCTGGCGGTTCACTTTATATG +TCACATTTTGGTATTTCGACTTATATTGATGGTGAAGGTGAAGACGGTGGTTCATCTGGT +ACGATTCAATGGTGGGATAAAACTTACAGTGATAGTGGCATGAATGGTATAACAATCAAT +TCCTATGGTGGTGTCGTTGCACTAACGTCAGATAATAATCGGGTTGTTCTGGAGTCTTAC +GCTTCATCGAATATCAAAAGCAAACAGGCACCGGTGTATTTATATCCAAACACAGACAAA +GTGCCTGGATTAAACCGATTTGCATTCACGCTGTCTAATGCAGATAATGCTTATTCGAGT +GACGGTTATATTATGTTTGGTTCTGATGAGAACTATGATTACGGTGCGGGTATCAGGTTT +TCTAAAGAAAGAAATAAAGGTCTTGTTCAAATTGTTAATGGACGATATGCAACAGGTGGA +GATACAACAATCGAAGCAGGGTATGGCAAATTTAATATGCTGAAGCGACGTGATGGTAAT +AGGTATATTCATATACAGAGTACAGACCTACTGTCTGTAGGTTCAGATGATGCAGGAGAT +AGGATAGCTTCTAACTCAATTTATAGACGTACTTATTCGGCCGCAGCTAATTTGCATATC +ACTTCTGCTGGCACAATTGGGCGTTCGACATCAGCGCGTAAATACAAGTTATCTATCGAA +AATCAATATAACGATAGAGATGAACAACTGGAACATTCAAAAGCTATTCTTAACTTACCT +ATTAGAACGTGGTTTGACAAAGCTGAGTCTGAAATTTTAGCTAGAGAGCTGAGAGAGGAT +AGAAAATTATCAGAAGACACCTATAAACTGGATAGATACGTAGGTTTGATTGCTGAAGAG +GTGGAGAATTTAGGATTAAAAGAGTTTGTCACGTATGATGACAAAGGAGAAATTGAAGGT +ATAGCGTATGATCGTCTATGGATTCATCTTATCCCTGTTATCAAAGAACAACAACTAAGA +ATCAAGAAATTGGAGGAGTCAAAGAATGCAGGATAACAAACAAGGATTACAAGCTAATCC +TGAATATACAATTCATTATTTATCACAGGAAATTATGAGGTTAACACAAGAAAACGCGAT +GTTAAAAGCGTATATACAAGAAAATAAAGAAAATCAACAATGTGCTGAGGAAGAGTAATC +CTTAGCACTATTTTTATACAAAAATTTAAGGAGGTCATTTAATTATGGCAAAAGAAATTA +TCAACAATACAGAAAGGTTTATTTTAGTACAAATCGACAAAGAAGGTACAGAACGTGTAG +TATATCAAGATTTCACAGGAAGTTTTACAACTTCTGAAATGGTTAACCATGCTCAAGATT +TTAAATCTGAAGAAAACGCTAAGAAAATTGCGGAGACGTTAAATTTGTTATATCAATTAA +CTAACAAAAAACAACGTGTGAAAGTAGTTAAAGAAGTAGTTGAAAGATCAGATTTATCTC +CAGAGGTAACAGTTAACACTGAAACAGTATGAAAAGCTATGAGTTAGATACTCATAATCT +TTATTCTTTTAGAAAGCGGGTGTACTGAATTGGGGTGGTTCAAAAAACACGAACATGAAT +GGCGCATCAGAAGGTTAGAAGAGAATGATAAAACAATGCTCAGCACACTCAATGAAATTA +AATTAGGTCAAAAAACCCAAGAGCAAGTTAACATTAAATTAGATAAAACCTTAGATGCTA +TTCAAAAAGAAAGAGAAATAGATGAAAAGAATAAGAAAGAAAATGATAAGAATATTCGTG +ATATGAAAATGTGGGTGCTTGGTTTAGTTGGGACAATATTTGGGTCGCTAATTATAGCAT +TATTACGTATGCTTATGGGTATATAAGAGAGGTGTTTACTATGCTTAAAGGAATTTTAGG +TTACAGTTTCTGGACGTGTTTTTGGTTTGGTAAATGTAAGTAATTTTTAAAGGTCAGTGC +TTTGACACTGGCTTTTTATTATTGTTGTGATTATGGTAATATACAAAAGTGAGCAAGTTG +GATAGATGGTGGCTATCTGAGTATAAGGAGGTGGTGCCTATGGTGGCATTACTGAAATCT +TTAGAAAGGAGACGCCTTTGTGGTATCTGTTGTTGATGCACTAAATTTAATGTTTAGTTT +CGGTATGTTTATCGTTGCTTTACTTGGTTTAGTCATCGCAATCGTTAAATTAAACCATAA +AAAATAACCATCACAACTTTGGACGGTTAATGGTTATTTTATAATAATTTCAAAACTGAG +CCACCGTCTTTTTAACGGGCTCATTAGGGTAACATGTTTGCGCATGTTGCCTTTTTCTAT +ATATAAATTAACACACCATAATATAAATATCAAATAGACGGCTTATTAGTCGTCTTTTTA +TTTTGGATAAAAGGAGATAAGAATATGATTAATTGGAAAATTAGAATGAAACAAAAATCA +TTTTGGGTAGCGATATTGTCAGCTATCTTTTTATTTGCTCAAAACATCGCAAAAGCTATT +GGGTATGATATTCAAGTTTATACAGAGCAATTAACAGACGGTTTAAACGCTATATTAGGG +TTTTTAGTATTAACTGGTGTGATCCAAGACCCGACTACTAAAGGTATAGGTGATAGCCAC +CAAGCTTTAGAATATGAAGAACCAAGTAGAAAATACTAGGAGGTAAAATAATGAAAACAT +ACAGTGAAGCAAGAGCAAGGTTACGTTGGTATCAAGGTAGGTATATTGATTTTGACGGTT +GGTATGGTTACCAATGTGCAGATTTAGCAGTTGATTACATTTATTGGTTGTTAGAAATTA +GAATGTGGGGAAATGCAAAAGATGCAATCAATAATGATTTTAAAAACATGGCAACAGTAT +ATGAAAACACACCATCGTTTGTTCCACAAATAGGTGATGTGGCTGTATTTACCAAAGGAA +TATATAAACAATACGGTCATATTGGTTTAGTGTTTAATGGTGGTAATACAAATCAATTTT +TAATTTTGGAACAGAACTATGACGGTAACGCAAATACGCCTGCAAAGTTACGTTGGGATA +ATTATTACGGCTGTACTCACTTTATTAGACCTAAGTATAAAAGTGAGGGCTTAATGAATA +AGATCACAAATAAAGTTAAACCACCTGCTCAAAAAGCAGTCGGTAAATCTGCAAGTAAAA +TAACAGTTGGAAGTAAAGCGCCTTATAACCTTAAATGGTCAAAAGGTGCTTATTTTAATG +CGAAAATCGACGGCTTAGGTGCTACTTCAGCCACTAGATACGGTGATAATCGTACTAACT +ATAGATTCGATGTTGGACAGGCTATATATGCGCCTGGAACATTAATATATGTGTTTGAAA +TTATAGATGGTTGGTGCCGTATTTACTGGAACAACCATAATGAGTGGGTATGGCATGAAA +GATTGATTGTGAAAGAAGTTTATTGAAAACGCGCAGTTAATAAAAAGATAATAAATAGTT +AATTTTATGTAATTTTCTTGTTTAACAGAAAAATCAAATATTTTAATGTATATTGAATTT +AATATTCGTATAGGCTTTATAGTTAAAAAATTAACAAGCATTAACAATACAATGTTTTTC +AGGTATATTTCTATACAACTATAATGAACTTTTTTAATTATTGATCGTGTTTGAATGTTT +TTTGGGTGTAACAATACTATTTTAGAGATTTATTAACCTTATTGAATTTTTAATAAATTT +TTAATTATATAATTATGAATTATGTAATAGTATAAATTTGTATTAAAAATATAAAGAGAA +AGAAAGTGAAACTATGTTTAAGAGAAAATTATTAGTTACAACTTTGTCGCTAGGTCTAAT +TGTCCCTATAGCTACACCATTTCAAGGCTCTAAGGCTACTACTAATGCAGAAGATATTGG +CGACGATGCAGAAGTGATTAAACGTACGGAAGATGTAAGTAGTAGGAAATGGGGTGTAAC +ACAAAATGTCCAATTTGATTTCGTAAAAGATAAAAAATATAACAAAGACGCATTAATTAT +TAAGATGCAAGGTTTTATCAATTCTAGGACAACTTTCAATGATGTTAAACAAAATAGAGC +AAATAAAAGAATGGTTTGGCCATTTCAATATAATATCGGTCTTACATCAAAAGACCAAAA +TACGAGCTTAATCAATTATCTTCCTAAAAATAAAATAGAAACAGTTGATGTTGGTCAAAC +TTTAGGATATAACATTGGAGGTAAATTCCAGTCAGTACCATCTATAGGCGGAAATGGATC +ATTTAATTATTCTAAGAGTATTAAATATTCCCAAAAGAGTTATGTCAGCGAAGTTGAACA +ACAAAGCTCAAAAACTATTAAGTGGGGGGTTAAAGCAAATTCTTTTGTTATAGCAGGGCA +TCGATGGTCTGCTTACGATGAATTATTGTTTATAAGAAATACGACAAGAGGACCTAATGC +TAGAGACTATTTTGTAGACGATAATGAATTGCCCCCTTTAATAACAAGTGGATTTAATCC +GTCTTTTATCGCGACAGTATCTCACGAAAAAGATTCAGGCGATACGAGCGAATTTGAAAT +TACTTACGGTAGAAATATGGATGTTACCTATGCAACCTACCTTCCTAAACTTGGTCTTTA +TCCAGAAAGAAAACATAATGAATTTGTAAACAGAAACTTTGTGGTCAAATATGAAGTGAA +TTGGAAAACGTACGAAATTAAAGTAAAGGGGCACAACTAATATGAAATTTAAGAATATAG +TCAAATCATCAGTCGCTACATCAATTACATTAATCATGCTATCAAATACAGTTGATGCAG +CTCAACATATCACACCTGTCAGCGAGAAAAAAGTGGATGACAAAATCACTTTGTACAAAA +CGACTGCTACATCAGATTCTGACAAATTAAAAATTTCTCAAATTCTAACTTTTAATTTTA +TTAAAGACAAAAGTTATGATAAAGACACATTAATACTAAAAGCTGCCGGAAACATTTACT +CAGGCTATACCCAACCCACTTCTGATAGTAGTATAAATTCACAATTTTATTGGGGAGCTA +AGTATAATGTTTTTGTTAGCTCGGAGTCCAAAGATTCTGTAAATATTGTTGACTACGCGC +CTAAAAATCAAAATGAAGAATTTCAAGTTCAACAAACATTAGGTTATTCATATGGCGGAG +ATATTAATATAATAAATGGATTAACTGGTGGATTGAATGGGTCAAAATCATTTTCAGAAA +CGATTAATTATAAGCAAGAAAGCTACAGAACTACGATTGATAGGAAAACAAATCATAAAT +CAATCGGCTGGGGTGTCGAGGCACATAAAATCATGAATAATGGTTGGGGACCATATGGCA +GAGATAGTAGTGATTCATTATATGGAAACGAACTATTTTTAGGTGGCAGACAGAGTAGCT +CGAATGCTAATCAAAATTTCTTACCAACACATCAAATGCCCATATTAGCACGTGGTAATT +TCAATCCAGAATTTATAAGCGTACTTTCTCACAAACAAAAGGATGTTAAAAAATCTAAAA +TTAAAGTGACTTATCAAAGAGAAATGGATCGGTATGAAAATTTTTGGAACAACTTGCACT +GGATAGGTTATAATATTAAGAATCAAAAGAGAGCAACACACACATCAATTTATGAAATTG +ATTGGGAAAAACACACGGTTAAATTAGTAGCTTCGCAATCTAGCGAATAAACTACTTCCT +AGATACCGTTGATTTTATAATAGGCTATGATTCGAAAAGAAATCTAATTACTCAGATATT +AGGTGACTTATGGGTAGAAATCAGTTAATATAAAATTGTGGTGAGCCTTTTCTTGGCGAG +TGCATAATGCATTCGCCTTTTTTATTTACATTAAAAAACAATTGTGGTATTATTTCTACA +TACTTTATTTAACATTTCTCTCTCAAGTTGAAATTGCGAGTAGTAGGCAGGTACTTCGGT +ACTTGCCTATTTTTTATGTTATAATTACATGTGTATATAGTAGGAGTGAACTATATAGCC +CGGCAGAGGCCATATATCTGACTGTTGGTCTCACAGGAGACATCTTCCTTGTCATCACTC +ATATACATATATCTTGCTAACATAGAGTTGTTATAGTCGCTACGCCACCCATACTAGTTA +CTGGGTGGTTGTTTTTTATGTTCGTATTTACGTTCGTATGATTTTTATTATATCCTATAA +ATAATATTGTATTAAATGTAAGGTGAAAGGGGTATAATAATGTATGAATATGAATCAAAA +TATCCAAATCCTAATGATTTTCAATGTCCTCCAAAAGAAGCAAATTTCGCTGAAGGTATA +ACATTTTATAAATGTAGCGACACATATGAATTGCCAAGCCAGTACATGGAACCTATGATA +GAAAAAGGTTCAAGATTTCCTAAAAACAATGAAGAAAGATGTTTAATGTGTGGTCATTCT +GTCTTTGTGGATGATAAGGATATATTTGAATTGATTAACAAAAAAGGTAGAATAGCAAAA +GGAATAAAAGATAAATGGAGATTTGTCTTTTATTTTGAAGGAAGCCAATTTAGTAAATAT +AAATTTACACCTTCAAAAAGTAATAAAAAGCACTATACATATTGGCATTATGGGAGTAAC +GATATAATATATAGCTATAAGAGTGCTATAAACGAATGAAAGGAGTGGTGATATGACAAT +AGTATTCTCAAAATTAATTGACGTATTTGATGAATTCATGTATCCCACTTTCTTTTCATA +CGAAGCAAGAGTGGGTGAGAAAACTAAAATATTTATAACTTTATTCGCATATTATGATGA +AAATAGTAGGAAAGACTATTTTTTTAATGTGCCAGTAAATAAAAAGAAATATGAACAACT +TATAAATGGTGAAATTGAAATTAGGTCTTTGTTTGTAAACAATAAAGATGGTTTTTTTAC +AGAAGGTTCACCTGAAAGTGTAGCAATTATAGAACCTATACATTTAAACGTTAACACTGT +CGATTATTTACCAGAAAAAAATTTATTCATGGTATATGATGATGATGAATTTTTGATTGT +CGATATAGAAGAAATGAATTCCGAGTTAGATAATAGTGAAACTGTAGAGAAATTATTTGA +CTTAAACATTGGTAAACAAATAAATTCATCAGAATATAATAATAAAGAAGGTTTAATGAT +TGCTTTTAGTAATGATAATCAAATTATAAAAGCAGATTCGTTAGGAGTATTGATAACCAA +GACGAGTGAATTGTTTAATAAAATAAGTAATAATTTATTAAATTTAAATGTAGTTAAACC +TTTTGAAAGTAGTTTTGGTATTTCTTTGGAATTTGATTCATTAAATTTAGACATTAATGA +TAACGAAATATATATCAATAAGTTTTTAAACCTTCTAAACTTTGTTTCTAATGATAAAAA +AGAAGATTTTTTCAATGAATTTTTAGGGTTGTACTCTATCAAAGAAAAAGATGAGTTCTT +AAATATTCTTAATGAATTAAGTTCTAATGACATAGAAATGAAAAGTATGTATTATAACAA +TATAAATGGAATTTATAAAGGCAGTATATTGAAACCATCAGAAGCCAAAAAATTTATAAA +TAGAGTTTATAATACAACAGAAACAAAAGAAACTTTAAATATCAATAATGCAACTATATA +TAAAATAGATGTAAAAAATAACTCATTTGGAGTTATAATCGATAATGATATTTATACTGG +AAAATTAGGAGAAAGTTTACAAGACAAAGAAGAAACACAATTTACTGTTCCTTCAGAAAA +AAATGTTGTTTTAACACAGATATTTAAAAAAGACGAATTTACTAAAAAAGAAAGAAAGCA +TTACATATTAGAATCTATAAACTAATTCACACCCACCACACCCTAACCGGTGTGGTTATT +TTTATTCTCACACAACCAAAAAACCACACCACCTATTAATTTAGGAGTGTGGTTAATTTT +TATATGTGAAGCTAAAATAACTACAAATGATACCATTTTTGATACCACTTTGTTGTAAAA +CAGAAAAAAATAAGGAAAACAAAAAAGACAAAAAACGCATTAAATCAACGTTTATTGTCT +CATGAAATTTAAATGTATGTTGATTTGTCAATTTAAGTGCAACAGTTCATCACATAAAAC +TTCATAAGGAAACTTCCAATTTAAACACTTTCTTGGTCGATAATTAATTGAGTCTAATGC +ATAGTTAAGTTGCTCTTGATTTACTTTAGCTAAGTCTGTTTTCTTAGGGAAAAATTCTCT +TAGTAAACCATTGGTATTTTCATTTGTACCTCTTTGCCATGCGGAATATGGATCAGCGAA +GTAGACATTAATATTAAATTGGTTTTCAATATTTTGATAACAAGAGAACTCTTTCCCTCT +ATCGACAGTAATAGTTTTAACGGCACCTTTAGGTAGATGTTTGATAAGGTTATTAATTGC +CGTCTCCATAGAATTAGAGGAACGATCAGGCATAAGTACACAATAATAATAACGTGATTT +TCTTTCTGCGAAAGTAGCAATGCACCCTTTACTTTTGCCTCTGCTGGATACAATTGTGTC +AGCTTCCCAATGACCGAATGTATTACGTTTCTTTATTTCCTTAGGACGTTGTGAAATAGG +ACGGCCAATATTAAACTTACCTCTAGTTTCTTTAGGTTTCTGTCTTTTTCCTTTTTGACG +AAGGCATGAAATAAGTTCGAAATTAATCATATTAGAGTTAATCCATCGATAGATGGTTTT +AAAACAGATTTGGTTTTGTAATAGACGACCTACGATTTGTTCAGGAGACCAGTGGCATTT +TAAATAATATTTAATGATATTACCAAGTTCTGGAGTAAATCGAGTAGGACGACCACAAAG +TTTTCTTTTGGTTTCATAATTTTTTTGAGCTGTTTCAGCTTGATATGACTGATTTAAATT +ATTCCTACTAATTTCACGTGAGATAGTAGATACAGATCGTTTTAATTTACGTGCAATAGA +TCTTAAAGAATAATTTTCTTGACGTAAAACCTCTATACGTGCGCGTTCAGTTAGTGTAAG +ATGGTTATAGCTCATGTTGGCACTCCTTGTATGTGTTTTTTTGGTTATTAACATCTTACA +ACAAAGTGCCAATTATGGGCATTTTTTATGAATTTTTATAGGTGTTGCACTTAATATTAC +AATCCGTCGTATATAAATTTCACTTCCCATGGGATCTTTAATTTTACCAATGATAGATTT +TAAACCGTCACGCATGCTTCCAAAGATGTTACGCACTCTATTCCATAAGCGACCAGCTAT +ACCTACCGTGTTATCTTTAATAGAGTTCCAGATGTTTGACATCCAATTTCTTAATTTAGT +AAATACATCTTTCGTCGCATTCCATAAACTTGTGAATTTAGACCTTACACCTGTAAATAA +CGAATGAGCCTTGCCGACGGTATTGCTTTTGATATTATTCCACGTACTAGATAACCAGTT +TTTCATATTAGTGAAAATAGATTTAACACTATTGAATAAAAAACCAAAAATACTTTTCGT +CGCATTCCAAATTGCCGATAAAGATTTTGTAAAGATGCCTTTGATAACACTCCAGATACC +GGATATTAAACCTTTAAGTAATCCACCAAAGTATCTCACTACACCTAGAATTTTACCTAC +AAACCACAGTTGTATTAAATTCCAAATTAACTGCACAGTACCATTCAGTATCATTACAAT +GCCGTCCCAAACGCCTCGCCAGTTTCCTGTGAAAAGACTAGAGAATACTTTGATAATACC +CAAAATAATATTAATAGCCCCTTGTATTACACCTTTGATATTTTCCCAAGTGCTGACAAT +CAAAGCTTTAACCGCCGGCCAAATAAATTGCATCACTTGCCAAATCGCAAACATAATTGG +TTTAATAATAAAGTTAAAAATAAATTCAAAGGTTGCTTTAATGAAACCAGCTATATTTTG +CAAAGCTTGTGTTATTTCTGAGCCGTTCTCTTTCCAGAAAGAGGCTAATTGAGCGCCTAT +CTCTTTGGCGAAACCAACGATTGCATCAACTACTTTAAAGAAAGTTGTTCTAATCGTATT +AACTACATTTTGTATTCCTGCTACAGTTTCGGGTGGAAATATCTTCTCTAGGGTAACCGC +GCCTTTACTATCACCTTTGAATAAATCAAAGAAACCTTGTAATGCTAGTTTAGCTGCTTT +AAATGCGTTTGCTACACCAGAGATTGCCTGATTTACAATATTTCTAAAAGTTTCTGAACG +TTTATAAGCTTGATAGAAAGCTATGCCAATACCAACTAATACACCTACAATTAATGTTAT +AGGTAACGTTAAACTGGATATCGACACACCTAAAACCGGAAATAGTTTAACAAGGGATGC +GATTTTAGTTCTTAAAAACGCGAATATACCACCAGCTTTATTAACGTTTATTAACAAGGG +TCCTAAAACTGTCATTGCATTCCCCATCACGCTGATAAATAAACCGAACATAAAAACTAA +TGGACCTAAAACTGCTGCAAACAATCCAAACCCAATAACCGCTAATTGAATTGACGTTGG +TAATTTAGTAACCCATGTCACTACTTTGCTAAAAGCACTTACTATAATCTTTAGTGCTGG +TTCTATTCTGTCATAAATCGTTAAGGCTAGTTCTTCTAATTGCGACCTTAAAGTTCTTAA +TTTTCCACCTAAACCAGATTCCATTGTATCGGCCATTCTTTTAGATGCGCCGGTAGATGA +ATCTATAGATTTGGTTAACTTTTGATAGTCTTCATCAGAAGCATTTATAATCGCTAATGC +TCCTGACATCGCTTCTTTACCAAATATTGTAGCTGCAGAACTAGCTTGTTGGTCTTTTGA +AAGATGTTTAAATTTTTCCCTCAGTTGGTCTAAAAGCTTTCGCATAGGAATCATTTTCCC +ATTACTATCTGTAATAGATATTCCTAAGCGTTCCATTTCATTCCCCATAGCTCTAGTTGG +ACTTGAAAGATTGGTGAACATTGTTCGTAACGCTGTACCTGCTTTTTCACCTTTGATACC +AGCATTACTCATTAAACCTATTGCAATAGATGTATCTTCAATCGTGTAACCTAACGCACC +TGCTACAGGAGCGACATATTTAAAAGCTTCTCCGAGCCCTCTAACGTCCGTATTTGCCTT +CGAGCTAGTTTGTGCTAAAACGTCCGCAAAATGACCACTATCCTTTGCTTTTAAACCAAA +TGCCGTTAGTCCATCTGTAACAATGTCACTTACTGCTCCCAGTTCTTCGCCAGATGCTGC +CGCTAAATCCATAACTCCGCTTAAACCTTCCATCATTTGCTTAGAATCCCAACCAGCAAG +TGCCATGTAATTTAATGCTTCAGCCGAATCTGATGCACTAAATTTTGTTGTTGCACCCAT +TTCGCGAGCCTTTTTCTTCAAAGCTTCAAACTCTTCCCCAGTAGCACCTGAAGTTGCTTT +AACTTTTCTCATACTGTCATCGAATTCAATACCTTTTTTAGCTGCTACAGCAAACCCAGC +AACCACCGGCGCAGTTACATACATAGTCATGTTACGGCCTACATTTTTCATACTGTTACC +AATTTCTTGAAGCTTAGGACCAAAATTATTAAAGTTGGTCCCAAGTTTTCCCATTGCAGT +ATTTAATGCTTTCTGCTCTCTTTGCATGTCTTTTAATTCTTGTGTGGCTTGGTTTAACTC +TCGCTCATATTGGTTTAATTTAGCGTAAGCTTCATTGTATTTAGCAGCCGCAACTTGTGT +CTTTGCACTGTTTTCACCAGTTTCTTTACTAAGTTTGTCATAACTATCTTTCAGCTCTTT +AGTAATCTGGGCTTGAACTTTTTGTTTTTTACTCAAACCTTCGACTTTTATCTTCGACTT +TTCTAATGAATTATCATATCTAGAAAGTTGTGATAAATTAGCCGAAAGCTCACGCGAAAC +CATTTTCATTTGCCTATTTAAACCTGTCACACCTCTATTGAATCCAGAACCATCTAAATC +AACCTTTATGACCATATTACCTATAGGATTAGGCATTTAAAAACCTCCTTTCTTCCAAGA +TGTAAATAAAAAAATCAACCTTTAAAGGCTGATTAAAAAATATCTTTAAAACTTTTCGCA +GTTCGCTTTGTTTCAATCTTCGATTCTACAATGTCTAAAAAGAAGTGTATCGGCATGTTA +GCCACTTTTTCTGCATCCATGCCGTTTTCTATCAAATCTTTAGCTATTTTCCTGTAATTG +TTGTAGACAGCTTCAGGTGTTAAATCTTCTTTTCTTATTTCTGATTCTCTGTCACGAACT +TTTTTGTATCGCTAGGTTCCCCACCTGTAATTCGTCCAATTAACTGTCCAATCTTTTCAA +TACCTTCTTGACCATTTGGTAATCCTTTTTGAAGTTCTATACTAGTAAATTGATTATCAA +AAGCTTCAACGATGAAATCCAAAACTTCTTCTAATACTTCCATTTGTACAGCCATGTTGT +TTTCGTATTCTTCTTGCTTGTTTTTGTATTCTTCCTGTTCTGTCACACTTAAGTTATTAA +ATTCTTCTTCTGTTAGATCTTTAAAATCAGCCCCCTTAAAGGCTTTGTTAAGTTTCAAAC +CTAATTTTGAACCTTGAATTGTTTCAAACAAAGTAATAATCGGCTTTGCTAAATACTTTT +GATATTGCGGCTTTCCTGTTTTTGTAAATCCTGTAATTAATTCAATTGATGTACGTTCCA +TTATTAAATTCCTACTTTCTTTTTAATTTGGCCAAAATAAAAAGAGGGCGTTAAGCCCTC +AAAACTTACATTTCTAAATTAGATTGTACTGTAATTTGCACAGTATCAGTTTGCTTTCCT +GCAGTCGCTGTAACGGTCGCATTACCTTCCGCCAAACCTTTAACGAGGCCAGTTGATGTT +ACGCTAGCATACGTTTGCCCCTCAGTCACTGCAAAAGTTACTTTCTGTCCAGATGGTTCG +GTTGTGGCTGATAGTTGTTTAGTAGCATCAACTTTAACTGTAACTTGTTCATCAGTGACG +TTTACAGAAGTGACTTCAACTTTTTCTGTTTTTTTCATTTCTTTTTCTACAGGTTCCATA +TTTTGTTCTCCTCGACTAGACATGAATTCATCATAAGTTTTACCAAATGTTTCCATGAAT +ACATAATCGCGCCCTGTAGTGCTTCCTTTTTTATCATAGCCAGTAACATGCGAGCTCTCA +TCAAACAAACGATCAATAAAATTGCCTTCTACGTCGTCATTCTGGAATTCAACTTTATCT +TGTTTTGTTTGCCCTTTGATGCTTGAACGAGTGAATTTACCTTTGAACAAGCCAACCCAT +TCTGAAGACTCATCATGATTACCGTCGTTCAAATACAATCGCTACATCTGGCGGGATATC +CTTAGCTCCATATTTATAACCACCTACACCTTTTTTAGCGCCATTCAAGAACGCCTTATC +GTCAGCAGGAACAGTAACAAATGTTGTCTTAACACTTAGTTTGCCATTAGATACAGCAGT +TGCTGCGACCATATCATCTCCATAATCTTCCTCGGTATCTTGTGGACGGTCTACTTCAAT +TTCTTTTAAGAAACGAATACGTGTGCCAGCTCCAGTTTCCCATTCATTTTCTGTATCTTT +TAAAATAGGTGCATAATAAAAGTTTGATACCCCAATTGCGATACCCGAAACTCCTGTATC +TGCAAAATGTTGTAAGTTTAATTTTAAAAATCTTGGTGCTTGTTTCAATTTTTCAATCAT +TTAATTTTCCTCCAATTTCATTGATAAAATCGAGCCTTTTGCTCTTATAATATGTCTGAA +TGACATGACGTCACTCTCGTATAACGGTTCTCTGTAATAACATTGAAAATTTATCACTTT +GAGTAAATCAACAATTTTTTCTGCTTGCTCGTTCGGTTCATCTTGAGACCACCAAACATC +AATTTGGTAATGGTATTCTCTTGAAATCTCGTTATCATCAGCGTATGTGTCAGGATTGAA +CGGTAAGGGATATATACGAATAATAGGCTTGTCAGTTTTTTCGTGAAAATGGTCATCTAT +AGTGTAGTTAAACACATTCACTTCATCTGTAATGTTATTTGCAATAATAGCGTTTCTAAT +TAATTTGGTAACATTAATCATTTTTGCAACCTCTTAGCAGTATCAAGCATTGTTTTTAAA +ACTTTGTTTTTCCCTTGCTTTTCTGTTTTTGTTATAAACAATTGTGGTTTTTGGTACATT +GTTCCAAATTCTGTTGCATGAATACGATGTGAGACGCCTTTAGCGTAACCAATTGTAACG +ATTTTCTCACTTGTGTGTCTGTCTGTTTTCACATTAGAAACAGCTATGTGATCGCGAGCA +TGCTTTTTAGTATTCGCAAAAGGTGTATTACTTTTTAAAAGTGGGACTAATGACATAGCC +CCAGCTTTGACAATTACATTACTATTTAAATTCATTTTTAAAACTGCATTTTTCAAACCT +TGTTCAATATTATTACTTTCAATTCTTGCTCCCATTAAATGACCACCTCGCCATAGATAC +GCAAATAAGATTTATCTTGATAATCTGGCTTTACATATTTGATGTTAAACCTTTGCCCTT +CATGCAAGACGTAATGCTTATTTGTTGGTTTATAATCACCTCGTGTATCTCTGATAATAA +TAGTTTTAATGAATTTGCTACCTGTATTGAGATTCGTTTGAGTGTCGGATTCTTTAGATT +CTTGAATGCAAGCGAAACAAGAGTATAATATTTTCGTCTTCGGTTTCATCGGATTTCTGT +TCACTCTCTCGCTTACATCTTCACAAAAATCTATACGTTCGAGCTTGGGACATTAAGTTC +TTAGGCAATGTAAAAAAGCTGATTTCTATTAATTATTTGATAGAAATCAGCTTTTTTTAA +ATGTATTTGATAATATACAGCTCGTCGAGCTACTATTTTCCTTATATTAAGTGCCATTAA +TACAAAACCTAGCTCTCGTTTAACTTTATTTATTCCTCGAACTGACATTCGAGTGAAACC +CAAAATAGCCTTCATAAATCCAAAAACAGGCTCTACATCAATTTTTCTTTGACTATAGAT +TTTTTTCGTTTCTGGTTCAGAAAGCTTTTGATTAATTTGGGCTTTAAAGTATTCCCAATT +ATAATTCTTCATGATTTTCTTATTGGATTTCGAATTTGGCTTCATGCATTGTTGCCTCAA +AGAACATGCTGAACAGTCATCGCATTCATATAGTTTGAAGTCACGTTTAAAACCATATCT +ATTATTACGGTATGCATATCTTTTAAAACCTATTCTTTTGTTATTAGGACATATAAATTC +ATCATTAAGTTCGTCATATTTCCAGTTTTGAGTGTTAAAAATGTCACTTTTAAACTTTCT +CGTTTTATCTTTAATAAACATACCATACGTAATAAGTGGCGTTTTATTAAAATCATCTAT +AATAGCCATATAGTTTTGCTCACTACCATAACCTGCATCAGCCACAATATACTCCGGTAA +ATAACCGAAGGTATTTTGAATCATTGTTAAAAATGGAATTAAAGTTCTAGTATCTGTCGG +GTTTTGAAATAGGTCATAGGATAAAACAAATTGAGAATTTGTCGCTATTTGTAAATTGTA +TCCTGGCTTAAGTTGGCCATTTTTCATATGGTCTTCCTTCATTCTCATAAAAGTTGCATC +ATGATCAGTTTTAGAAAAGCTATTTCTATCTTTAAGAATCGATTTTTGTTCTTCATATTT +ACTTTTTCTTTCGGAATAATCATCAAATTTCTTTTTGAACTTCTTAATCTCAGTTCTTTT +TTTACGGGTCTGTTTTCTAATTTGAGTACAATCTTCGTTCTGAATAGAATGATTTAAATC +TTCGATTTCTTTATCTAAATGACTACCAATTAAATCTATTTCTTCTATTGTTAAATCGCT +ATCTCCATCTTCTTTTATCTCCGGTATTATTTTTTCTTCAACTAAGTCACGATATAATGC +TTTTGAATTTTCGTTCAATTTCGATTCGTGATTTTGAATACTTTTCTTCCACACAAATGT +ATACCTATTGGCATTAGCTTCTACTTTTGTACCATCAATAAAAATTGAACTATCATCAAT +AAGATTTTGCTTTAAACATTGACTATGAAACTGAATAAATAAAGATTCAATTAATGCATC +AGTATTAGGATTTACTCTAAAACGATTAATAGTTTTATAAGAAGGTGTTTGATTTTGAGC +TAACCACATCATTCGAATACTGTCATGAAGTAATTTCTCTATTCTACGACCAGAAAATAC +AGATTGAGTGTATGCATATAAGATAATTTTTAACATCATTTTTGGATGATAGGATGTTGC +GCCACGATGATGTCTGAATTCATCGAATTCGCTATCAGGTATCGTTTCAACAACTTCATT +AACATATCGTGAAATATCATTTTGAGGAATTCTAACAGAAGTTTCTATTGGTAGTGTAAG +TTGGGTCATGTTATAATTTTTATACATAAGGCACCTCGTTAATTTAGTTTAGTGGTATTT +ATTAAATTATACGAAAGTGTCTTATTTTTTTAAAGTATTTCAAAGTAAAATTACATGTTA +ATACGTAGTATTAATGGCGAGACTCCTGAGGGAGCAGTGCCAGTCGAAGACCAAGGCTGA +GACGGCACCCTAGGAAAGCGAAGCCATTCAATACGAAGTATTGTATAAATAGAGAACAGC +AGTAAGATATTTTCTAATTGAAAATTATCTTACTGCTGTTTTTTTAGGGATTTATGTCCC +AGACTCTTCATCATTTTCACTCTCCAAAAATTGCTCAAATGAACCTCTCAATTTATGCAC +CGTACTTAAAACCATATGTGGCGCAAGCGATAAATCCCTATCCAAATAAGCAATACGGTT +TTCAAAATAGTAACTTGCTAAAGGGTATATAGCACGAGCAAATAGAGGATGACTTTTAAA +CCAATCAATATATTTACTTGGTTCATCCGTAACAGCGCTAGCTATTTCATGGAATGCCCA +AGAGTAATATATTTCTAATAAGTCGTCCTCTGAATTGTGATCTATTTTGCAATGCTTTTT +TAATAACTTAAGTTCCTCAGCTGTTAATTGCATTCAATCACCTATTCTTCTTTTACTCTT +TCAAGTATTACTCCATGCTCTTTCAGCTTTTTGTTAACATATTCAGCACGTTTTACTGTC +ATTTCAACACGTTTACCTGACTTTAAATACTGGCCTTTTTCCAAGTCAGTATAAGATTTC +TTCACTTCATACATTGCCATAGTTTATCACCTCTTTATAAAGTATCGAGCGCTTATTATG +CTTCTAAGCCAAGATCGCCTTCACCGCGTTCACTATCATCATATTCAATCACAATTGCTG +ATTTATAATCTAGAATTCTACAGTCTTGACGTACAGCAATCATTAAACATTCTCCGAAAT +GCATGTAGTCAGTCCATGATGCTTGGTATTGAGAGCGGTCAAATAAAACAATCGCATCTT +TTAAGTTACCGATAATCAAAGTGTTATTACCTTTTTGCCCTAGTACTTCATCAGGTAAAA +TTTCGATTTTAGCTCCTAATAAACGCTGTTGCGTTTTTTCTTTAACATCTGGCTGGATTA +AATAGTTTCCTAGCTTATCTTTCATTTTGTCTAATTTTGCAAACATAGTTTGCGAAACAA +TCGCAACATTATGTTCGTAATTTGGCTTAACATTCAGGTTAATAGCATCTTTAATATCAT +CTAAAGATTTTGCTTTTTTAACTTCTAATTTCTTGCCTTCTTTTTCAAAACCTGAACTTG +TAGAACCCGTTGATCCTTTAGTGATAACATCAATAATTGCTTTGTTTCGTGTTGCTGCAA +TAGTTCGCGCCATCCATAGTTTCAATTCTTGCAAAACATTCACTTTTGCATCTTCGATTG +CTTCACGTGAAATTCGGAAGTAACCACGGTGTGTATTAATGTCATATGCTAATTGGAAGA +ATGGTTTAACTGCTAATTCAGGGTTTTCTTCTAATTCTTCAACTTTTTCAAGGGCTGCAA +CTTCTGATTGTCGTACTACCGGATATTTACCAGAACCATTTGTAACACGTTTGACCGTCA +CATACTTATCAAGATTAAACTCAACCTCTTTTAATTTTAAAATATCTGTAACAATTTCCT +CTGGAATAACTACAAATCCTGAGTCTGTTTTTAACGAACCACCTTGAATATCATTGCGTG +TTTCAAGATATTCAGTAAAATCTCTAACTTCTTGTGATGTTACCTTTGTGTTTTGAATCG +AAATACCTAAATCATTAATGTTTGCTTGGTTTCGATAAGTACGTGCTTCGTTTACTTCCA +CTGATTGTTGATTGTTTTCTGAAGTTCTATCTTTTTCTTTTAGCTTATCTAATTCTTCTT +GTTTTTCTTGGATTTGAGAACGTAAATCAGTAATTTCTTGTTCTAATTTTTCTGCTTTTT +CTAACTCATCGTTATTAAGTGCTCTCGTTGCATACTTCACCTTTAAATCAATTTGTCTTT +TAATGTCTGAAATCTCAGATTGTAACTCTTCTTTTGTTTTCATTTAATTTCCTCCTAAAA +TTGGCATAAAAAAATAGACATCGCTATATTCAGCATGTCCAATGGCTGTATTTGATAATG +GTGTTCAACTTCACCAAATATTATTTAATATAGAGTGTTTCTTTAGTCTTATTTCTAATT +CTTTTTTACGTTGTTCTTTTTTAACGGTTTCAATACTACGTAATGCTGGTTTAACATCAG +TGTCTTTGTAAGCCGGATAAGTCACTACAGAAACATCTGTAAGTTCACGAATTGCTGTTA +AAGTACGTTTGTAAATGTTTTCTTGTTCATCAAAACGCACTTCATCGCCTTTATCGTCAA +GCATAAAACCAAACGAACATTGATTGATGTTGCCTACACGCATGTTCTCATATAAATCAC +GTGCAAATGTTGTGTTTGGTAACTTACAACGATATTTAAGTCCAACATCATCAGTTTCGA +GCTCCAAAGTACCCGATTTTGTCCTACCAATTATTTGCGATGGGATATGATCTACTAAAC +AACGCACATCAGATAAATCAGTGTTTTCTAAAGCACGACGTGAAATCGTTTCTTTGAATC +CACCAAGATTTTCAGACCAAGTGTCAAACTTTAACGCATACCCCTCTATGACCATTTCGT +TGTTATCATTTGAGCGTACCTCAATAATGTTGCCAACTCTCGTTTCCTTACTCATTTTCC +TCACCACCTTTCAATTTTTTATCAGTAGCTCTCGATTTATTCATCTGATACTCATCTACA +AGTTCAATATTTACATGGTTTAAATCGACTCTGTGAATGCTACCATTACCGCCTGGTATT +GGCGCTAATCCATCACGTTGTCTAATTTCATCGATATTCATCTTTCCAGAATCAATGTTA +ATTTTGTCAATTTCAGCTTGTGTTTTTTCATCAACAACTCGTATTTCAGTGGTATCAAAT +TTAAATTCACGATTCACATATTCATCATTAAACTTAAAATTCAATTCTGCACAAACGCAT +GTAATATAAGGTTTTAAAGTTGATAAGTAATCTAAATTAGCATCCGTGATACTCATGTTC +GCTGTTTCTATGCCGAACTTATGCAATGGAATACCAAATACACCTGCTATTTCTCTTGTT +GATGATTTGTTTTCTCTGATAAGCTTTAAAACTTCTGTATCAACTTCTAATTGATCAAAC +GTCATTGATTCATCGAGTACGACAACTTTCCCAGCTTGTTTAGTTCCACTAAAACTTTTG +GGAATTCTTCTCTGGCACGGTCTCTTGCTTTTTTATTATCTAATACACCTTTCATTTTCA +AAATACCACCAGCATGTGTGCCATTTCGCAGGAAATTATTAAGGAAATCTTTTCCATTGT +TATCTGATTCTATCGTGCGACTTAATGTGTCTAACAGTGACAAACCATTTATACCGTCCA +ACGAATAAAATTTGATGTCTAGCATATCCTCGAACTTAACATTACGTTCTATATTATTTC +CGTTACTGTCTATCCTTTGATGAAAATAATACAGTCGACCTCTTGCGTCTGATTTCAATT +CTATTTCGGATGTCTTTCTGAACGTTAAATTCATAGGTTCTCCTGTTTTATCACGTGTAA +TTTCAATATAGCCGTGCGATGTTAGTAAGGCACTAACAAACACTACTAATTTGAATATAT +AGCCGTTATACATTGGGTTAGGACGTGTATTTAACAAATTAACAATCCTGTCACTATAAT +TAATTTGGCCGTTCACTGTCACCCTAATTGGCATGCGTGCCAAATCAGAAGCAATCATCA +TAACTGCAGTAAAGATGTCGCTATGCCTAATTGCTTCTATATCTTTATATTGTCGTAATT +TTGTTCCTTGAAAACTTGGCAAAGTTTGAACCATCATTTGCAAATCATCTTCGTTGTATT +GCAAGTCTCGTTTTTCATTTTTATAAAAAATCCCCACAACTACTAACTCCTTTCTTGATT +GCTTTCATGATTTAAAATCAACGAAATAACAATCAGTGTTATACCAATGCATAAAAGTCC +TATATTTTGACCGAATGCTTTATACACAGAAACATTAACCACAAACAAACCTAATAAAAA +AAGGATGCTAACCAAATTAGCAACCAAGAAATTAAAAAAGACATTTATTTTATTCAAGTC +CATTTTGTCACCACCTTTAAAACCCGAATTCTTCGCTTTCATATTTCTCCGTCCAATTTT +CTTGGAATTCGTGCATTCTAGCTTCAGTGAAAGCTGTGATAATCGAAATAATCGGATCTA +TTTTTTGACGATTCATTTTTTTATTTATTTTCACATTGTCTTCTCCGTCACGAATCAAAA +CGGCATTATTAACTGATGTTGTAAGTAACATATTATCGTTATGCTGTATTCTTTCATCTG +CAACCCACATTCTAAATTCTTTAATAGATTGTGATAACGCCTTAAAACTTTGTCCCACTT +CAATGAGTGGCCAATCTAAAGCCATTGATTCGATTGTTGTTATAAAACTTTGCGCATTCC +AAGGGTCATAGCAAACAGCCTGTACATTCAGGTCATGCGTCGTTATAAATTTCACTATAA +AATCGATAACTTGTTTATAATCAATCATGCCGCTATCTGATTGTGTAGTCTCAGCTTCGC +CACGTTCAATCGCTAATTCATAATTTATTTTGTCTCTCTTAGATTTTTGTTCTAAGTTTG +TTCTTAATCCAATGAAAGAATGACTATGTAAAAACACTTTTTTATCGTCGTTAGGGAAAA +TAAACCCTACAGATGTTAAGTCATCCAATCTCGATAAGTCGACACCTATATACACATCTT +TACCATTGATATTAGGCATAGGCGTTATTACTTGTTCCCAATCTGAAATATCTAGCAAGC +TATCTTCTCTTTGCGCTTGCCATAAATTGAAGTTTTTAATCAAAATCTTATGATATGATG +TCCCTTTTTCTAATTCGTCTTGTATATCAGCTTTTACATTTTGAAGTATAGTTTTTCTAT +GTTCTTTTGATTCTAAAAGCGGCATTGCTTTAATCCACTTTGTTTCATCTTGAACTTCTT +CTTGTGAATCCATTTCAGCACAATATACAAAGTAATTATCAGCTCTTACTTCTTCATTTA +AAATACGTTTAATATACTTATACTCTTGGTACATTTGACTATTTAAATTGTCTCCGGCCG +TTGAAACAAGTAGGGTTAAAGGATTTTTTTGTAATGTCATACCTGTTTTAAACCTTGAGT +ACATCTCATCATCAGGCATACTTGCCAATTCGTCCAAAATAGCAACTGTAGGATCTTTAC +CATCAACCGCATCTGGGTTATTGGAAAGAGGTGCAAACACTGAACTACTTAATACATCTT +CAATGTCTGTCTTTCTTACGTCTGTTTTTTCACGGATAAACTTGCTTTTACTTCGCATTA +GGTTTACTTGTTGGCTTGCCATCTTGAATATTGTTTGCGCTTGCTTATAAGTAGATGAAG +CTACATAAATTTGTCTATTAAATTTAGGGTATTGTCCAAACAACAGTTCGTTAACGGACA +TTCCCGATACGATTAGAGACTTACCTTGTTTTCTAGCCATACTTATATAAGCTTTAGTAA +ACATTCTGTATTGACCTCTACGCCAGCCGTATAAGCTCCCAACAATGAATTTCTGAAACT +CCATAAGAGGCATGGGCTGGTTTGTTTTAGGGTCTGGAAGCATTTCCACAAATTTAATTG +CTTTGTTAGACAAATGATTATCCCAATGGCAACCATTCGGCGGGTTCTCCATAAAAGATA +GGTGACGTTTACATACTTGAATATTCTTCAAACTTGCCAAAATTTCTCCTGAAACTACCT +TTTTTGCGTATTTAGTAACATAATCAGTCATTACTAATCACTCACAAATTCCATATATGG +ATCATCATCTTCTTTTTCATCAGGAACCATAATACGCAATCGGCTATCAATAGTTAATCC +TAAAGTATTAGCTGTTTGTTGCAATCGAATACCCGCTTTTTCCTTTATGTTGAACGCCGG +ATTAACCTTTTGATTTCCTTTGTCGTCTTCTAAAATCAAGTCTTCGCGCTCTAAAATCAA +ACTTGCTTTAACAAAGTCACTATAAAAACTACAATATTGTGCTAATTGTGCTTTATCTAA +GTTGGAAATTGGCAATTCTTGCATGTGCGGTAATATTCTTAAGTATTCTTGTTTCGCTAT +TTCATCTAAAAAGTGCGGTGGTTCAGTATCGATTTTAGAAAATTTATTTAATTGAGCTTC +TTGACGCTCTTTTTCAATAATTTCTTCTTTTGTATAATTCTTGTTCGAATTTGACAAAAG +CTTCTTAGGTCTACCCGCCATAAATTAGCACCTCCTACTAAAAAAACTTAAATAAAGGGA +ATTTTTTGAGAAGAAAACTCTGCTCCGTTCTCCAGAACCTTTCATTGACGCCCGTTTCAT +CTTTGGGGGGGCTTCCTATTTTTATCTTTTTTAATATTTCTTCAAATCTTCTTTTGTCTT +TTGGTTATGGCAAGCATCACACAAAGGCTGTAAATTACTTTTGTCTAATCTTCTTGCCCA +ATCAATTTTTGTTGGTACAATATGGTCAACCATAGTCGCTTGATTGCCACAAGAAACACA +AATAAAATCATGTTCTAACAATACAATTCGACGCATGTTTTGCCACGTTTTCGATTTATA +AAATCTTAAATACTCTGGATCGTTTCGACGTCTCAAATCATTGTAATTTTCATTTGCATA +TTGCTTGTGTTTATCACAATAACTTTCATTATGATTAATCAATACATTACATGTTGGATG +ACCACATCGCTTCATAATAGACAATGCACATCACTCCCTGTCGACTTTCTTAACATCTTG +CACAGTTACTTGTCTATCATCTTTATCATTGCTAATTAACAATAAGTTTCCTATCGATCC +ATCAACAAGATACTTACTACCTTGAAACAATACTTTGTCTCCTTGTTTTATACCATTGTC +TAAATTGATAGTCTGATTAGGTTTATTCATCAAGATAGTGGTAACACTATGACCAGCTAT +CTCATCCAAGTTAATACCTAACACGTTAGTAAGATTAGCTATATTCCACAATGCTTCGCT +AAGTTCATTTATCATAATTCCTTTATCTATCGGTACATTACAAAACATATGCTGTTTAAT +TAGATCTGTAACATTGCCTGTAGATTGAGTTAAACCTAAGCCGTAACAAGTAATAGATTC +ATTTAAATTCAATTCATCATTGTGTGTACGTGTAGCTATCTCTTGGTACTTTGATATCTC +CATTCTCCACCTCTTGTTTATAAAAATAAAAACCCTCACTTAATGTGAGAGTTCAAAAGA +AATATAAATGTTTTGCTACACAGCAATTATAATAAAAAACAATATGTAGCATCAAAATTA +GTACGATGTGTCCGAACTGTACGATGTGTCCGAACTGTACGATGTGTCCGAACTGTCGGT +TTCTTGTTGCAAGTTATAAAGTATATTTACTATATCTTTTACTCTAGAATAAAAATTGTC +TCTGCCTATATCAAGAATGCTCATGATCCTATTATGGCTTTCTCGTTGTTTTAACATTTG +TAAAATATGATAATCTTTTTCATTCGTGATGTATTCTTCATATTCATCAATGAACGCTAT +CTTCTTAATCAAGTAATCGTACTTTCTAAGCGCTTTGTTTTTGTTTATAACTTTCACTAA +CATTTTATTGCTAGTCGTGCCTTTAGCTTTTGGCATCGCAGATTGATAACCATATTGTGC +AATTGATGTACTTTCGTTATCGTAGACTTTACTGTCTATTATGTTCTTCATCCACTTGTA +GTTATCTATCATTTCACGTATTTCTTTCCTGTTATACATGCAATACCTCCGATAATATAA +ATTACTTTTTAATATCGTTATTCATTCGCTTTAATTCAATCCTGTATTCTTTTAACCCGT +TGTACTTCCCATGGATCGTTTTGAATTCTTATTTTAGGCTTGTTATTACGCATTTTATAA +ACTCCTTAATTGTTATTTGATACCAATATGATACCGTTTAATCAAATATGCTCATAGCTT +GATGTTTTTTATCAGTATATAAATGAGAGTACGTTTGAATTGTTTCTGTAATGTTAGAGT +GCCTCATTAATTCCATTAATAAATACATATCTACACCATTATTAATTAAATAGCTTGCGT +ACGAGTGTCTTAAATGGTGTATTTTTAGATTCGAGAATACAGATTTAAAATGATACGAAT +AAGTAATGTATCTAATAGGTTCTAAACCCCCGAATATAAAATAGTTTTCGTCAAAATATT +TATATCTTTTAGAAGATTCGTTATACATGTTTTCAAGCATCTCTCTAATTAAATTTGGCA +CAGGTATTATCCCTTTAGAGCTTTCTTTTTTAGATTATATTCAATTTTTCTATTACTTAA +ATTGATTTTCTTATTTACGTCAATTTCGCCTTTTATTTTATTGTAATCTTTCCACTGCAA +AGCTAAAGCTTCTCCTATTCTAAGACCAGAATAAAATAACAGTTTAGTTAGCTGACGAGA +AGTATCGTTTGTGATTTGTTCTACTTTTTCATCAAATTCTTCACGAGTGATAAATTTAGC +TTGTGGTTTTGTTCTGGGAATAGGAGTTACCGATAATGTGGGGTCGTATAAGAGCTTGTA +ATGCTTTTTGGCGTAATTGATAACTGCTTTAAAACCTGCCCACACAGATCGTGCATAGCC +AACAGAAAGACCTGCATCGTTTAACAAATAATTCCTGAAAGCAGTACATTGCGTAGTAGT +GATTTTGCCAATAGGGATATTTCCGAACCTTTCTTTTATGTGAGTATTGTATTCTGTAGT +TCGCTTTTCTATTGAGCGTGCAGAAAGATTTTCATTTTTTAAACGATCAAAAAATATATA +TTCAAAGGGTTGATTGTCCGAGTATCCATATTTAACATTTTGTATAAATTCGCTTTCAGC +TAGTTTGGCATCTTTCTTACGTTCAAACCCACGCTTCATTTTTCGTTTGTTATTACCGTA +TACATCTTTATATCTAATGGAAAAATACCATTTCCCCGTATTATCATCTTTATATACTGG +CATTTTGCTTCTCCCTCCTCAAAATTGGCAAAAAAATAATAAGGGTAGGCGGGCTACCCG +ATATTTAGTACTAGGTACTAAATATGTTATAATAAAATAAAAAGTAGGTGATAAGATGAC +TCAATTTCTAGGGGCGCTTCTTCTTACAGGAGTTTTAGGTTACATACCATATAAATATCT +AACAATGATAGGTTTAGTTAGTGAAAAAAACAAGATTATCAATACTCCTGTATTATTGAT +TTTTTCTATTGAAACATGTTTGATATGGTTTTATACTTTTATAATTTTTAATAATGTTGA +TTTAAAAAATTTGAGTTTACTTCAGTTGCTTACAGGTCTAAAAGCAAATATTTGGTTTCT +AATTATTTTTGTTTTAACAGTGCTTGTATTTAATCCTTTAATTGTTAAATTCATTATCTG +GTTAATTAATAAAACAAGAAAGTTTATGAATTTGGATTGTATAAGCTTATTAGACAAAAG +AGACAAGTTGTTTAATAACAACGGTAAACCAGTATTTATAGTTATTAAAGACTTTGAAAA +CAGAATCATTGAAGAGGGTGAACTTAAAACCTATAATTCAGCTGGTAGCGATTTCGATTT +ACTAGAGGTTGAGCGACAAGATTTCAAAGTATCTGATTTACCGTCAAACGATGAATTGTA +TATTAAACATACACTTGTAGACCTTAAACAACAAATTAAATTGGATTTATATTTAATGAA +TGAATATTAATCTTTTTTCTTAGCTTTTTCTGATAAAGTGCTTTTTAAGTTTTCGCTGGC +ACCCGGCTTTTCAAAACTTTTGTTTATTGGGTTACTACGAGTAGCTTCTTGTTTTTTGTT +TTTATCCGCCATAAAATTCTCACCACCATTCAACGTCTACACTTGTAGGCGTTTTTGAAT +TTTTTTAATCCTTTTTCTCGTCACGCTATATAGGTACTTTTAATCATAATTAAAGCCAAG +TTTATTTAAAATCTCTAAATAATCTGACGACTTTGCCCGTAATGTTTACGTCATTTATTT +TTGACATTGGGTAGCTTCTATCTTTAATGGTAACGTAATTAGATAATCGCTTTAGGGTAA +ATGTGTCATCTGAGTTAAATATAATTTCGCAAAAATATTCATCAGTTTCGGTTCCGTTCT +CTGGGAAGAAAACGGTTATTATATCTCTATCAAAGATAAAGTCGATTACATCATCATCTT +GATCTAAAATGTAGCAAACAGTCATATCGCCATTTTCAACTCTTCTTGTGCTATTTATAG +TAGTTATTGGTTGGGCAACTAATTTGCCTTTTGCCTCTGTGTATCTTTTTGGAAATTCCA +CATAATTCATTAAATCAATTGTTTTATTTGTTTCCATATTAGTTCTTTTTTCTATATCGT +TATATCTCCATAAGTATTGTTTCTCTTCCATCCCTCATCCTCCTCGCGCCACACAGGCGC +TGTTAATCACATTTTAGTTCTATCAGTGATTTTAGACTCCATAACTCTTTGACGTGACTC +TTTAGCTTCTCGAATCATATCTTTAAATTCTTGACTGTCTATAAAAGCTTTGGCTTCTTC +TATTTGTTCTTGAGTAAGCTCTTTGCCACCAGTATTGATGTGTAAGTGTTCAATTTCTTT +ATAAGAACTCATTTTTTCGACTCCTGTTCTTCAAGTTCACTTTTAGTTATAGGTAAACCA +TTATTCAACCTATAAGTCAGTTCTTCTTCTGTATAAAAGGGGATTTCAACCATTTCCCAC +TCTTCAATGTTAATGTCAACTTCTTTTAAATTCATTTTACTACCTCCTATAAAATAACTT +TTCCAACTAATCTCACACTTTCATTATCATAAAAATGTAAATCTTTATACTTTTTATTTA +AAGAAACCAACGTTAATCTGTTATCTTCTACATAAACCTTCTTTACGTAAGCATCTCCAT +TTATAATAAAGACGCCTATTTGTCCATCTTTGATAGTGTGAGATTTTTCAATGAATATAA +TTTGTCCATTTTTAAATAACGGCTCCATTGAGTCTCCATTTACTTTTAAAGCTATATCAT +GTGCGGGGACATAACCTCTTACGAATTCTTTTGAAATAGGTTCGTTATATAATCTTTCAC +CAATACCAGCAGACGCACAACCATATATATCCACTTCGGATTTTTCTTGAATGTAAGAAT +TGAAATCTACCAGATTATCATCACTGTCATTATTTTGCTCTTCTAATTGATTAGTCGCAT +ATTTTAGTACATTGCTTTGTCTTGGAGGCGTGAGTTGAGATGACACGTTATGAATTTCTT +CAATAATTTTCGAATCATCCATATCATGTATTAAATCTAAGGGTTTAACTCCAAAAACGT +TAGCTATTTCAGGTAATTTATCTAGTTTTGGACTTCTAATTCCCTTTCTCCATCTTGTGA +CTGTTGTTCTATTTACATCTACTAATTCTGCTAATTCACTATCACTCATATCTCTTTTGT +TCATCAGACGTTCTAGATTCGAAGAAAATGAACTCATATTTTTATCTCCTTTAAACATAT +TATCTAACTAATAACTTCATTATATGCCTACAGTTCCAAAAATGCAACAAAAAACATAAA +AATATGTGTAGAGGCAAAAAAATATGTAAAAAGCACTTGCAATTTTGGAACATCAGGTGT +AGTATTGTTTTCAGGAGGTGTTCCAAAAATGCACAAAGATTTATATAGCTTTAGAAAAGC +GGCGAAAAAGAACCAAGACTTTATGGGGAGTTTGATTGGTGTTTCGGGTCAACAATACGG +AAAAAGAGAACGCGGAGAGATTCCTATTAATTTAGATGAAGCGATGATTTTTTCTAAGGC +ACTCGAAACACCTATACAAGAACTATTTCCAGAATATTTTTTTATTGAGCGAGTTCCAAA +AATGCACAAAAACGAAATAACATCTTAAAAGGAGGACACAATGGAACAAATCACGTTAAC +CAAAGAAGAGTTGAAAGAAATTATAGCGAAAGAAGTTAGAAATGCTATAAAAGGCGAGAA +ACCAATCAGCTCAGGTGCAATTTTCAGTAAAGTAAGAATCAATAATGACGATTTAGAAGA +AATCAATAAAAAACTCAATTTCGCAAAAGATTTGTCACTAGGAAGATTGAGGAAGCTTAA +TCATCCGATTCCACTAAAAAAGTATCAGCATGGCTTCGAATCAATTCATCAAAAAGCTTA +TGTACAAGATGTTCATGATCATATTAGAAAATTAACATTATCAATTTTTGGAGTGACACT +TAATTCAGACTTGAGTGAAAGTGAATACAACCTAGCAGCAAAAGTTTATCGAGAAATCAA +AAACTATTATTTATACATCTATGAAAAGAGAGTTTCAGAATTAACTATCGATGATTTCGA +ATAAAGGAGGAACAACAAATGTTACAAAAATTTAGAATTGCGAAAGAAAAAAATAAATTA +AAACTCAAATTACTCAAGCATGCTAGTTACTGTTTAGAAAGAAACAACAACCCTGAACTG +TTGCGAGCAGTTGCAGAGTTGTTGAAAAAGGTTAGCTAAATTCAACGGTAAGGATTTGCC +CTGCCTCCACACTTAGAGTTTGAGATCCAACAAACACATAAGTTTTAGTAGGGTCTAGAA +AAAATGTTTCGATTTCCTCTTTTGTAACAGTTTCAATTCCTTCATATCCTGGAAAACAAT +TTTCTTTAAATCCGAAACATGTTTTTTTGAACCATCCTTTAAAGTAACTAGAAGTTTCAT +ACTTATCACCTCCTTAGGTTGATAACAACATTATACACGAAAGGAGCATAAACATTATGC +AAGCATTACAAACATTTAATTTTAAAGAGCTACCAGTAAGAACAGTGGAAATTGAAAACG +AACCTTATTTTGTAGGAAAAGATATTGCTGAGATTTTAGGATATGCAAGGACAGACAATG +CCATCAGAAATCATGTTGATAGTGAGGACAAGCTGACGCACCAATTTAGTGCATCAGGTC +AAAACAGAAATATGATCATTATCAACGAATCAGGATTATACAGTTTAATCTTTGACGCTT +CTAAACAAAGCAAAAACGAAAAAATCAGAGAAACCGCTCGAAAATTCAAACGATGGGTAA +CATCAGACGTCCTACCAGCCATTCGCAAACACGGTATCTACGCAACAGACAATGTAATTG +AACAAACATTAAAAGATCCAGACTACATTATTACAGTATTGACTGAGTATAAGAAAGAAA +AAGAGCAAAACTTAGTTTTACAACAGCAAGTAGAAGTTAACAAACCAAAAGTATTATTCG +CTGACTCGGTAGCTGGTAGTGATAATTCAATACTTGTTGGGGAACTAGCGAAAATACTTA +AACAAAACGGTGTTGATATAGGACAAAACAGGTTGTTCAAATGGTTAAGAAATAATGGAT +ATCTCATTAAAAAGAGTGGAGAAAGTTATAACTTACCAACTCAAAAGAGTATGGATCTAA +AAATCTTGGATATCAAAAAACGAATAATTAATAATCCAGATGGTTCAAGTAAAGTATCAC +GTACACCAAAAGTAACAGGCAAAGGACAACAATACTTTGTTAATAAGTTTTTGGGTGAAA +CACAAACAACTTAATAGGAGGAATTAAAAATGAACACACTATACAAAACAACCCTCCTCA +CCACAATGGCAGTTGTGACGTGGAAGGTTGTAAAGATTGAGAAAAACACAAGATTTAAAC +TTAGAAATTTTGATTATCCAAAAATTAGTAATGCTCAGAGCAAATCATTGTTGGATATTG +CTAGTCGCTATCTAAAAGATATTTAACTGTATTCAAAATTTTCATATCTTGTTGAGCTTT +TAAGCTTTCGTATAAAGCTATTGAATAAATAATTTCGTAAGATACGTTTTCAGGAGCATC +TTCTTTCAACTTATTTATTCTATCTCTAAAAAAGTCACTGTCACCACCGAATTCTTTTTC +GGCTTGATTACTAAGTTCACCAAAGAAATTTTGAAAATCATTAAATTCCATACTTATCCA +CCTCCTTTCACTAGGAGATAACTAAATTATACACAACACAAAAATAAAAAGGAGGAATAG +ATATGATAAAAAATAGTTTGCAAGCTAAAGAACTTGCGGTAATTTTATCTGTTTCTAAAT +CCAAAGCAGGACAAATAATAAGAGAACTGAATAAAGAGCTTGAAGACGAAGGATACATTG +CGATACGAGGAAAAATACCCGTCCAATTAGCTAGAAAAAAATTCCCTTATCACGACTTAT +CAGACGAGAGAATAATGGAGGAGTTAAAAAAAGAAAATGAGTAAAACTTATAAAAGCTAC +TTAATAGCAGTGCTATGTTTCACAGTCTTAGCGATTGTACTTATGCCGTTTCTATACTTC +ACTACAGCGTGGTCAATTGCAGGATTCGCAAGTATCGCAACTTTCATATTTTATAAAGAA +TACTTTTATGAGGTGGATGATTAAATGACTTGGTTCGAAGAACACGTTGAACCTAGTGTG +GAATGGGAAAGAAAAGCAGAACAAGCTGTGTTAAGTGATGATGAAGTTAAGACGATTACT +GAATACAGAGAGAAGTACAACAATCCATATATTTACATGTCGGTTCAAAACAAAAATTAT +CTTGTTGAATATGTAGACAGACATACCGGTGACATAGTATTACACAATTTAAAACTTAAG +AAATCATACAGAAGAAGAGCGCATCAATATTTTTTTGTCGGCCAAATAGTAGTACCAGGC +GAGCCAAAAGGCATAATTTATGAAACATCTTTGATAATAAGATAAAAAAACCGCTACTTG +CGCCAACAAGTAACAGTGACAAACATTTAAGAAATAAAATTCAAGTTAATTAAATCAAAA +TATACGGAGGTAGTCAAGATGTATTACGAAATAGGCGAAATCATACGCAAAAATATTCAT +GTTAACGGATTCGATTTTAAGCTATTCATTTTAAAAGGTCATATGGGCATATCAATACAA +GTTAAAGATATGAACAACGTACCAATTAAACATGCTTATGTCGTAGATGAGAATGACTTA +GATATGGCATCAGAATTATTCAACCAAGCAATAGATGAATGGATTGAAGAGAACACAGAC +GAGCAAGACAGACTAATTAACTTAGTCATGAAATGGTAGAGGGGGATTAACTAATGGCTA +ATCTATATGAGCTATCAGAAGCATTTAAAGAGATGTCTAATCAAGATGAATTAGATCCAA +CATTACTAAAAGATACATTAGATTCTATCAAAGCAGAAATGAACGTCAAAGTAGATAACA +TTGTCAATTGGAGACGTGAAACTTTAGGTGACATAGATGTCATAGATAAAGAAATTAAGA +GACTTCAAAATTTAAAAAAACAAAAACAAAATTTAACTGATCGTTTAAGAGATTACTTAA +AAGAGATGTTAGAAACACAGGAAGTAGATAGTTACCGCACAGCTACTAATCATATTTACA +AGCGCAAAAACGGGGCTAGTAAAAATATTATCGATGAAAAACTTATTCCAAAGGATTATT +GGCTATCACAAGCCCCGAAACTTAATTCTAAGCAACTAATCGATGATTTGAAAGATGGGA +AAGATATTCCTGGCGTTGAATTAAAGGTAACAGAAAGCCTGGTGATTAAGTGATGAATAA +ATCAGAAACAGTTGTAGAAATAAACAAAGCTATGGTTGCGTTTCGTAAAGAAGTAAAGCA +ACCGCTCAAAGATAAAAATAATCCATTTTTCAAATCAAAATACGTACCTCTTGAGAACGT +TGTAGAAGCCATTGACGAGGCGGCAACACCTCATGGACTGTCTTATACTCAATGGGCTTT +GAACGATGTAGACGGGCGCGTAGGAGTCGCTACAATGCTTATGCATGAAAGCGGTGAATA +TATCGAGTATGATCCCGTATTTATGAATGCAGAAAAGAATACGCCACAAGGAGCAGGCTC +GTTAATAAGTTATCTTAAACGTTATTCGCTATCTGCGATTTTCGGTATTACTAGTGACCA +AGACGATGACGGAAATGAAGCAAGTGGAAAAAATAATAATCCAAAACAGCAAACTAGAAC +GCAATGGGCAAGTAGCGAAACTATAGGGATTTTAAGGAAAGAGGTTATAAGTTTCACTAA +ATTGATAAAGGGCACGGATAAAGAAGCTCCACAAAATATAGTAGAACAAAAATTCGACAT +AAATAACTATAAATTAACGGAAAAACAAGCAGCAGAAGCTATTCAAAAAATACGAAACAA +CGCAAAAACAATTACTGGAGGAAAACAATAATGTTAAACAGAACGGTATTAGTAGGACGC +TTAACAAAAGATCCAGAATATAGAACAACGCCGAATGGTGTGAGTGTTACCACTTTCACT +ATCGCAGTTAACAGAACATTTACTAACGCTCAAGGAGAACGTGAGGCAGACTTTATTAAC +TGTGTAACTTTTAGAAAACAAGCAGAAAATGTAAATCATTATTTATCCAAAGGGTCATTG +GCTGGCGTTGATGGACGTTTACAATCACGCAGTTATGAAAACAAAGACGGGCAACGTGTG +TTTGTTACAGAAGTAGTAGCGGACAGTGTTCAATTCTTAGAACCGAAGAATAACAACCAA +CAACAAAACAACAATTATCATCAACAAAGACAAACTCAAACTGGTAATAATCCTTTTGAT +AATACCACTGCGATTACTGATGATGACCTCCCGTTCTGATTGGAATGATTAGATGCCAAT +AATTACTAGTTATATCACTCAAGACGACGGCACAACAACAGTTGTCATCTCGGGTGTTGA +ATTAGGCAATAAAGAAACATTACTACTTGATAACGGATTTGATGTGGAAGTAGATGTAAA +CGTTATAGATCCGTTTCAAATTACTGGACAACAACGTAAATTGATATTCGCATTGTGTAA +CGATATAGAAGCTCATACAGGACAGCCTCGAGATTATATGAGACAAATGTTCCAAGATTA +TGTGAAGTTTCTGTATGGCTATGAAGAACGCATATCTTTATCAAATTGTTCTCGAACTAT +AGCTAAGCAAATTATAGAAGCGATGTTTGAGTGGATTTTTACAAATGCGATTCCATTAAA +TTATAAAACAAGCAAATTGATGAAAGAAGATAAAAATTATCTTTATTGGGCAACTGTTAC +GCGTCATTGCATTATATGCGGAAAGCCTCACGCTGACCTAGCGCATTATGAAGCAGTCGG +CAGAGGCATGAACAGAAATAAGATGAATCACTATGACAAACATGTATTAGCGTTATGTCG +CGAACATCATAACCAGCAACACGCGATGGGCGTTAAGTCATTTGATGATAAATATCAATT +GCATGACTCGTGGATAAAAGTTGATGAGAGGCTCAACGAAATGCTGAAAGGAGAAAACAA +TGGGAGAAGTATCGTGGATAAAACTTAAAGTTGGCATGTTTGATGACAGCAAAATCAAAT +ATATCGAAGCTTTACCCGAAAGAGATACGATCATAACCATTTGGGTTAAGTTGCTAACTT +TATCAGGAAAGTACAACGAACAAGGTTACATTATGCTATCTGAAAATTTGCCGTACAACG +AAGAAATGTTAGCAAATGAGTTTAGCCGACCTATCAACTCAATAAGGTTAGCAATTCAAA +CTTTTGAGACATTGGGCATGATTGAAAAAGTTAATGGTGTCATAAAAGTGACAAACTGGG +AAAAGCACCAAAACATTGAAGGACTCGAGAAAATCAGGGCGCAGAACAGATTGAGGAAAC +AAAAGCAACGAGAAAACAACAGAAAATTGTTGAATGGTCACGTGACGTCACGTGACAGTC +ACGCAACAGAAGAAGATAAAGAATTAGATAAAGAATTAGAAAGAGATAAAGAAAAAGATA +TAGATAAGAATTTAAGTTCAAATAATAGCGCAACTGACGTTACGCATGAGCAATTTGAGG +AATGGTGGAAACTTTACAACAAGAAAAAAGATAAGAAGATGTCTTTCGCTAAATTCAAAT +CATGCTTAAAGAAACATACTTTTGAGCAAATCATGCAAGGTACTCGAGAATATTTAAAAA +CTATTACAGACAAACAATATCAAAAGTACCCTAAAACGTTTTTAACTAACGAAAGCTATA +TGAATGATTATAGCGAAGAGATTAAAGAAACTGGCATAGATCAATTGGAACGTATGAAGT +ACGACGAAAGTTATTGGGACTAGGAGGATCTTATGAAACCGTTATTCAACGAAAAAATAA +ACGAAAGTTTAAAAAAGTATCAACCAATCGAAGTAATACTAAGACAGAATTGCGATAAAT +GTGGGCGTCAATACGACTTATATAAGTTTGAAAATGGATATGAATACAAAGACGGTTGCG +AATGCGAAATTCAAAGATTGGCTTATGAAGAATACAAAAGGAATAAACAAAAGAAACTTG +ATTATATTTTCAATCAATCAAATGTCAATCCGTCATTAAGAGATGCAACAGTCAACAACT +ATAAGCCACAAAATGAAAAACAAGTACAAGCTAAACAAACAGCAATAGAGTACGTACAAG +GCTTCTCTACAAAAGAACCAAAATCATTAATATTGCAAGGTTCATATGGAACTGGTAAAA +GCCACCTAGCATACGCTATAGCAAAAGCAGTCAAAGCTAAAGGGCATACAGTTGCTTTTA +TGCATATCCAAATGTTGATGGATCGTATCAAAGCGGCATACAACAAAAATGCAGTTGAAA +CTACAGACGAGCTAGTCAGATTGCTAAGTGATATTGATTTACTTGTACTAGATGATATGG +GTGTAGAAAACACAGAACACACTTTAAATAAACTTTTTAGCATTGTTGATAACAGAGTAG +GTAAAAACAACATCTTTACAACTAACTTTAGTGATAAAGAACTAAATCAAAATATGAACT +GGCAACGTATCAATTCAAGAATGAAACACAATGCAAGGAAAGTTAGAGTAATCGGAGACG +ATTTCAGGGAGCGAGATGCATGGTAATAACAAAGCAAAATATAAAAGAAATATTACATTG +TAGAGATGTATATGCTCAAAAGATGATTGATTTCTGCAAACGGAGTCCAAGAGAAACTTA +AAAAACTTATTGATGATAAGTTGAAAGAAAAAGAAGAAAGATCCGCTATCGTCGAATATT +AAGGAGTGATTTAAAAATGCCGAAAAAAAATATTCTTATACCGAGAAGATGGCACGGAAG +ATATTAAGGTCATCAAGTATAAAGACAACGTAAATGAAGTTTACTCGCTCACAGGAGCCC +ATTTCAGCGACGAAAAGAAAATCATGACTGATAGTGACCTAAAACGATTCAAAGGCGCTC +ACGGGCTTCTATATGAGCAAGAGCTAGGTTTACAAGCAACGATATTTGATATTTAGAGGT +GGCACAATGAGTAAATACAACGCTAAGAAAGTTGAGTACAAAGGAATTGTATTTGATAGC +AAAGTAGAGTGCGAATATTACCAATATTTAGAAAGTAATATGAATGGCATTAATTATGAT +CATATCGAAATACAACCGAAATTTGAATTATTACCAAAATTAGATAAACAACGAAAGATT +GAATATATTGCAGACTTCGCGTTATATCTCGATGGCAAACTGATTGAAGTTATCGACATT +AAAGGTATGCCAACTGAAGTAGCAAAACTTAAAGCAAAGATTTTTAGACATAAATACAGA +AACATAAAACTCAATTGGATATGTAAAGCACCTAAGTATACAGGCAAAACATGGATTACG +TATGAGGAATTAATTAAAGCAAGACGAGAACGCAAAAGAGAAATGAAGTGATTTAATGCA +ACAACAAGCATATATAAACGCAACGATTGATATAAGAATACCTACAGAAGTTGAATATCA +GCATTTTGATGATGTGGATAACGAAAAAGATGCGCTGGCAAAGCGTTTAGATGACAATCT +GGATGAATTACTAAAGTATGACAACATAACAATAAGACGTGCATATATAGAGGTGGAATA +AATGAAGCTGAACGAAGTATTCGCAACTAATTTAAGAGTAATCATGGCTAGAGATAACGT +AAGTGTTCAAGATTTGCACAACGAAACTGGCGTATCAAGATCAACTATTAGTGGATATAA +AAACGGAAAAGCTGAGATGGTTAACTTAAATGTATTAGATAAATTGGCAGATGCTCTAGG +TGTTAATGTAAGTGAACTATTTACTAGAAATCACAACACACACAAATTAGAGGATTGGAT +TAAAACAGTAAATGTATAGAGGTGGAATAAATGGCGAAAACAGCAAGAATTGTAAGGATA +CATGATAAACCGTATAGGTTCAGTGAATTTGAAATGGAGTTAATTGAAAGTCACGGTATA +ACACCCGGGATGGTTTCTAAAAGAGTAAAAGACGGTTGGGAACTACATGAAGCAATGGAC +GCACCAGAAGGCATGCGTTTAAGCGAGTACAGAGAAAAGAAAACAATAGAAAGACTGGAA +CAAGCTAGACTCGAACGCAAATTGGAAAGACAGCGAAAGAAAGAGGCTGAGCTAAGAAGA +AAGAAGCCACATTTGTTTAATGTACCTCAAAAACATTCACGTGATCCGTACTGGTTCGAT +ATTACTTATAACCAAATGTTTAAGAAATGGCAGGAAGCATAAATGCCAAAAACTGATAGC +GCATGTAAAGAATACTTAAACCAATTTTTTGGATCTAAGAGATATCTGTATCAGGATAAC +GAACGAGTGGCACATATCCATGTAGTAAACGGTACTTATTACTTTCATGGGCATATCGTG +CCAGGTTGGCAAGGCGTGAAAAAGACATTTGATACAGCGGAAGAGCTCGAAATATATATA +AAGCAGCATGGTTTGGAATACGAGGAACAGAAGCAACTAACTTTATTTTAGAGGAGGTTA +TGAAAGTGAACTATGAAACAGGGTTCCAAATAGGTGTAATGGAAGCTAGGTTGAAGAAGA +TGAGAAAACAACGAGATGAGTATAAGAAGCAACAAGATGAGCTTATCGTGGATATAGCGA +AGTTACGAGAACGTAACAAAGAGTTGGAGAAGAAAGCAAGTGCATGGGATAGGTATTGCA +AGAGCGTTGAAAAAGATTTAATAAACGAATTTGGCAACGATGATGAAAGAGTTAAATTTG +GAATGGAATTAAACAATAAAATTTTTATGGAGGATGACACAAATGGATAACCGTGAACAA +ATAGAACAGTCCGTTATAAGTGCTAGTGCGTATAACGGTAATGACACAGAGGGATTGCTA +AAAGAGATTGAGGACGTGTATAAGAAAGCACAAGCGTTTGATGAAATACTTGATGGAATG +ACAAATGCTATTCAACATTCAGTTAAAGAAGGTATTGAACTTGATGAAGCAGTAGGGATT +ATGGCAGGTCAAGTTGTCTATAAATATGAGGAGGAACAGGAAAATGACTAACACATTAAC +AATTGATCAGTTACAAGAGTTATTACAAATACAAAAGAAGTTCGACGATAGAATACCGAC +TAGAAATTTAAATGACACAGTAGCTAGTATGATTATTGAATTTGCGGAGTGGGTTAACAC +ACTTGAGTTTTTTAAAAATTGGAAGAAACAACCAGGTAAGCCATTAGATACACAATTAGA +TGAGATTGCTGATTACTTAGCTTTCAGTTTGCAATTAACTTTGACTATTGTTGATGAAGA +AGATTTGGAAGAAACTACTGAGGTTATGGTTGATTTGATTGAAAATGAAGTTACTTTACC +TAAACTACATTCAGTTTATTTTGTTCATGTAATGCATACACTAACAGAACAATTTGTAAA +AGGTATTGATAATAGTATTGTACAAGTTTTAATAATGCCTTTTTTGTACGCCAATACTTA +CTATACAATCGACCAACTCATTGACGCATACAAAAAGAAAATGAAAAGGAACCACGAAAG +ACAAGATGGAACAGCAGACGCAGGAAAAGGATACGTGTAAAGACATCTTAGATCGAGTCA +AGGAGGTTTTGGGGAAGTGACACAATACTTAGTCACAACATTCAAAGATTCAACAGGACG +TAAACATACACACATAACTCGAGCTAAAAGCAATCAAAGGTTTACAGTTGTTGAGGCAGA +GAGTAAAGAAGAAGCGAAAGAGAAATATGAGTCACAAAATACACCTATTGTTTACTACAC +TAATAATTCTAAAGTGACCTTATTCGAAAGACCTAGTGAAGAAGTATTAGGTTCTTTGTT +CGAAAAGAAATAAAATCATTAAAGAGGGGAGATAATAATGTTTAATACACCTAAAATGAA +ATTACCAGAAAAGCACACCGAGGTATTTAAGACGTATAAAAATGGAACGCCAGAAGAAAA +AGCTGAGATTGAAGGCTGTTTTATTAAAACTGTTAAAGATGAAGATAGTGAATTTTACAG +CCCTATGTTAGCCAGTCTAAATGAACAACAGTTAAAGAGTATGTTGAGACAGGTACTTTT +TTTGATTGATACAGGAGATGACAATGATGATTAAAAAACTTAAAAATATGGATTGGTTCG +ATATCTTTATTGTTGGAATACTGCGATTATTCGGCGTAATCGCACTGATGCTTGTTGTCA +TATCGCCTATCTATACAGTGGCTAGTTACCAAAACAAAGAAGTACATCAAGGGACAATTA +CAGATAAATATAACAAGAGACAAGATAAAGAAGACAAGTTCTATATTGTGTTAGACAACA +AGCAAGTCATCGAAAACTCTGACTTACTATTCAAAAAGAAATTTGATAGCGCAGACATAC +AAGCTAGGTTAAAAGTAGGCGACAAAGTAGAAGTTAAAACGATTGGTTATAGAATACACT +TTTTAAATTTATATCCGGTCTTATACGAAGTAAAGAAGGTAGATAAATAATGATTAAACA +AATATTAAGACTATTATTCTTACTAGCGATGTATGAGCTAGGTAAGTATGTAACTGAGAA +AGTATATATTATGACGACGGCTAATGATGATGTAGAGGCGCCGAGTGATTACGTCTTTCG +AGCGGAGGTGAGTGAGTGATGTGGATTACTATGACTATTGTATTTGCTATATTGCTATTA +GTTTGTATCAGTATTAATAGTGATCGTGCAAGAGAGATACAAGCACTCAGATATATGAAT +GATTATCTACTTGATGAAGTAGTTAAAACTAAAGGA diff --git a/example/fna/NC_002486.ref.fna b/example/fna/NC_002486.ref.fna new file mode 100644 index 0000000..5b80902 --- /dev/null +++ b/example/fna/NC_002486.ref.fna @@ -0,0 +1,762 @@ +>NC_002486.ref length=45636 +CTTCCCATGGATCGTTTTGAATTCTTATTTTAGGCTTGTTATTACGCATTTTATAAACTC +CTTAATTGTTATTTGATACCAATATGATACCGTTTAATCAAATATGCTCATAGCTTGATG +TTTTTTATCAGTATATAAATGAGAGTACGTTTGAATTGTTTCTGTAATGTTAGAGTGCCT +CATTAATTCCATTAATAAATACATATCTACACCATTATTAATTAAATAGCTTGCGTACGA +GTGTCTTAAATGGTGTATTTTTAGATTCGAGAATACAGATTTAAAATGATACGAATAAGT +AATGTATCTAATAGGTTCTAAACCCCCGAATATAAAATAGTTTTCGTCAAAATATTTATA +TCTTTTAGAAGATTCGTTATACATGTTTTCAAGCATCTCTCTAATTAAATTTGGCACAGG +TATTATCCCTTTAGAGCTTTCTTTTTTAGATTATATTCAATTTTTCTATTACTTAAATTG +ATTTTCTTATTTACGTCAATTTCGCCTTTTATTTTATTGTAATCTTTCCACTGCAAAGCT +AAAGCTTCTCCTATTCTAAGACCAGAATAAAATAACAGTTTAGTTAGCTGACGAGAAGTA +TCGTTTGTGATTTGTTCTACTTTTTCATCAAATTCTTCACGAGTGATAAATTTAGCTTGT +GGTTTTGTTCTGGGAATAGGAGTTACCGATAATGTGGGGTCGTATAAGAGCTTGTAATGC +TTTTTGGCGTAATTGATAACTGCTTTAAAACCTGCCCACACAGATCGTGCATAGCCAACA +GAAAGACCTGCATCGTTTAACAAATAATTCCTGAAAGCAGTACATTGCGTAGTAGTGATT +TTGCCAATAGGGATATTTCCGAACCTTTCTTTTATGTGAGTATTGTATTCTGTAGTTCGC +TTTTCTATTGAGCGTGCAGAAAGATTTTCATTTTTTAAACGATCAAAAAATATATATTCA +AAGGGTTGATTGTCCGAGTATCCATATTTAACATTTTGTATAAATTCGCTTTCAGCTAGT +TTGGCATCTTTCTTACGTTCAAACCCACGCTTCATTTTTCGTTTGTTATTACCGTATACA +TCTTTATATCTAATGGAAAAATACCATTTCCCCGTATTATCATCTTTATATACTGGCATT +TTGCTTCTCCCTCCTCAAAATTGGCAAAAAAATAATAAGGGTAGGCGGGCTACCCGATAT +TTAGTACTAGGTACTAAATATGTTATAATAAAATAAAAAGTAGGTGATAAGATGACTCAA +TTTCTAGGGGCGCTTCTTCTTACAGGAGTTTTAGGTTACATACCATATAAATATCTAACA +ATGATAGGTTTAGTTAGTGAAAAAAACAAGATTATCAATACTCCTGTATTATTGATTTTT +TCTATTGAAACATGTTTGATATGGTTTTATACTTTTATAATTTTTAATAATGTTGATTTA +AAAAATTTGAGTTTACTTCAGTTGCTTACAGGTCTAAAAGCAAATATTTGGTTTCTAATT +ATTTTTGTTTTAACAGTGCTTGTATTTAATCCTTTAATTGTTAAATTCATTATCTGGTTA +ATTAATAAAACAAGAAAGTTTATGAATTTGGATTGTATAAGCTTATTAGACAAAAGAGAC +AAGTTGTTTAATAACAACGGTAAACCAGTATTTATAGTTATTAAAGACTTTGAAAACAGA +ATCATTGAAGAGGGTGAACTTAAAACCTATAATTCAGCTGGTAGCGATTTCGATTTACTA +GAGGTTGAGCGACAAGATTTCAAAGTATCTGATTTACCGTCAAACGATGAATTGTATATT +AAACATACACTTGTAGACCTTAAACAACAAATTAAATTGGATTTATATTTAATGAATGAA +TATTAATCTTTTTTCTTAGCTTTTTCTGATAAAGTGCTTTTTAAGTTTTCGCTGGCACCC +GGCTTTTCAAAACTTTTGTTTATTGGGTTACTACGAGTAGCTTCTTGTTTTTTGTTTTTA +TCCGCCATAAAATTCTCACCACCATTCAACGTCTACACTTGTAGGCGTTTTTGAATTTTT +TTAATCCTTTTTCTCGTCACGCTATATAGGTACTTTTAATCATAATTAAAGCCAAGTTTA +TTTAAAATCTCTAAATAATCTGACGACTTTGCCCGTAATGTTTACGTCATTTATTTTTGA +CATTGGGTAGCTTCTATCTTTAATGGTAACGTAATTAGATAATCGCTTTAGGGTAAATGT +GTCATCTGAGTTAAATATAATTTCGCAAAAATATTCATCAGTTTCGGTTCCGTTCTCTGG +GAAGAAAACGGTTATTATATCTCTATCAAAGATAAAGTCGATTACATCATCATCTTGATC +TAAAATGTAGCAAACAGTCATATCGCCATTTTCAACTCTTCTTGTGCTATTTATAGTAGT +TATTGGTTGGGCAACTAATTTGCCTTTTGCCTCTGTGTATCTTTTTGGAAATTCCACATA +ATTCATTAAATCAATTGTTTTATTTGTTTCCATATTAGTTCTTTTTTCTATATCGTTATA +TCTCCATAAGTATTGTTTCTCTTCCATCCCTCATCCTCCTCGCGCCACACAGGCGCTGTT +AATCACATTTTAGTTCTATCAGTGATTTTAGACTCCATAACTCTTTGACGTGACTCTTTA +GCTTCTCGAATCATATCTTTAAATTCTTGACTGTCTATAAAAGCTTTGGCTTCTTCTATT +TGTTCTTGAGTAAGCTCTTTGCCACCAGTATTGATGTGTAAGTGTTCAATTTCTTTATAA +GAACTCATTTTTTCGACTCCTGTTCTTCAAGTTCACTTTTAGTTATAGGTAAACCATTAT +TCAACCTATAAGTCAGTTCTTCTTCTGTATAAAAGGGGATTTCAACCATTTCCCACTCTT +CAATGTTAATGTCAACTTCTTTTAAATTCATTTTACTACCTCCTATAAAATAACTTTTCC +AACTAATCTCACACTTTCATTATCATAAAAATGTAAATCTTTATACTTTTTATTTAAAGA +AACCAACGTTAATCTGTTATCTTCTACATAAACCTTCTTTACGTAAGCATCTCCATTTAT +AATAAAGACGCCTATTTGTCCATCTTTGATAGTGTGAGATTTTTCAATGAATATAATTTG +TCCATTTTTAAATAACGGCTCCATTGAGTCTCCATTTACTTTTAAAGCTATATCATGTGC +GGGGACATAACCTCTTACGAATTCTTTTGAAATAGGTTCGTTATATAATCTTTCACCAAT +ACCAGCAGACGCACAACCATATATATCCACTTCGGATTTTTCTTGAATGTAAGAATTGAA +ATCTACCAGATTATCATCACTGTCATTATTTTGCTCTTCTAATTGATTAGTCGCATATTT +TAGTACATTGCTTTGTCTTGGAGGCGTGAGTTGAGATGACACGTTATGAATTTCTTCAAT +AATTTTCGAATCATCCATATCATGTATTAAATCTAAGGGTTTAACTCCAAAAACGTTAGC +TATTTCAGGTAATTTATCTAGTTTTGGACTTCTAATTCCCTTTCTCCATCTTGTGACTGT +TGTTCTATTTACATCTACTAATTCTGCTAATTCACTATCACTCATATCTCTTTTGTTCAT +CAGACGTTCTAGATTCGAAGAAAATGAACTCATATTTTTATCTCCTTTAAACATATTATC +TAACTAATAACTTCATTATATGCCTACAGTTCCAAAAATGCAACAAAAAACATAAAAATA +TGTGTAGAGGCAAAAAAATATGTAAAAAGCACTTGCAATTTTGGAACATCAGGTGTAGTA +TTGTTTTCAGGAGGTGTTCCAAAAATGCACAAAGATTTATATAGCTTTAGAAAAGCGGCG +AAAAAGAACCAAGACTTTATGGGGAGTTTGATTGGTGTTTCGGGTCAACAATACGGAAAA +AGAGAACGCGGAGAGATTCCTATTAATTTAGATGAAGCGATGATTTTTTCTAAGGCACTC +GAAACACCTATACAAGAACTATTTCCAGAATATTTTTTTATTGAGCGAGTTCCAAAAATG +CACAAAAACGAAATAACATCTTAAAAGGAGGACACAATGGAACAAATCACGTTAACCAAA +GAAGAGTTGAAAGAAATTATAGCGAAAGAAGTTAGAAATGCTATAAAAGGCGAGAAACCA +ATCAGCTCAGGTGCAATTTTCAGTAAAGTAAGAATCAATAATGACGATTTAGAAGAAATC +AATAAAAAACTCAATTTCGCAAAAGATTTGTCACTAGGAAGATTGAGGAAGCTTAATCAT +CCGATTCCACTAAAAAAGTATCAGCATGGCTTCGAATCAATTCATCAAAAAGCTTATGTA +CAAGATGTTCATGATCATATTAGAAAATTAACATTATCAATTTTTGGAGTGACACTTAAT +TCAGACTTGAGTGAAAGTGAATACAACCTAGCAGCAAAAGTTTATCGAGAAATCAAAAAC +TATTATTTATACATCTATGAAAAGAGAGTTTCAGAATTAACTATCGATGATTTCGAATAA +AGGAGGAACAACAAATGTTACAAAAATTTAGAATTGCGAAAGAAAAAAATAAATTAAAAC +TCAAATTACTCAAGCATGCTAGTTACTGTTTAGAAAGAAACAACAACCCTGAACTGTTGC +GAGCAGTTGCAGAGTTGTTGAAAAAGGTTAGCTAAATTCAACGGTAAGGATTTGCCCTGC +CTCCACACTTAGAGTTTGAGATCCAACAAACACATAAGTTTTAGTAGGGTCTAGAAAAAA +TGTTTCGATTTCCTCTTTTGTAACAGTTTCAATTCCTTCATATCCTGGAAAACAATTTTC +TTTAAATCCGAAACATGTTTTTTTGAACCATCCTTTAAAGTAACTAGAAGTTTCATACTT +ATCACCTCCTTAGGTTGATAACAACATTATACACGAAAGGAGCATAAACATTATGCAAGC +ATTACAAACATTTAATTTTAAAGAGCTACCAGTAAGAACAGTGGAAATTGAAAACGAACC +TTATTTTGTAGGAAAAGATATTGCTGAGATTTTAGGATATGCAAGGACAGACAATGCCAT +CAGAAATCATGTTGATAGTGAGGACAAGCTGACGCACCAATTTAGTGCATCAGGTCAAAA +CAGAAATATGATCATTATCAACGAATCAGGATTATACAGTTTAATCTTTGACGCTTCTAA +ACAAAGCAAAAACGAAAAAATCAGAGAAACCGCTCGAAAATTCAAACGATGGGTAACATC +AGACGTCCTACCAGCCATTCGCAAACACGGTATCTACGCAACAGACAATGTAATTGAACA +AACATTAAAAGATCCAGACTACATTATTACAGTATTGACTGAGTATAAGAAAGAAAAAGA +GCAAAACTTAGTTTTACAACAGCAAGTAGAAGTTAACAAACCAAAAGTATTATTCGCTGA +CTCGGTAGCTGGTAGTGATAATTCAATACTTGTTGGGGAACTAGCGAAAATACTTAAACA +AAACGGTGTTGATATAGGACAAAACAGGTTGTTCAAATGGTTAAGAAATAATGGATATCT +CATTAAAAAGAGTGGAGAAAGTTATAACTTACCAACTCAAAAGAGTATGGATCTAAAAAT +CTTGGATATCAAAAAACGAATAATTAATAATCCAGATGGTTCAAGTAAAGTATCACGTAC +ACCAAAAGTAACAGGCAAAGGACAACAATACTTTGTTAATAAGTTTTTGGGTGAAACACA +AACAACTTAATAGGAGGAATTAAAAATGAACACACTATACAAAACAACCCTCCTCACCAC +AATGGCAGTTGTGACGTGGAAGGTTGTAAAGATTGAGAAAAACACAAGATTTAAACTTAG +AAATTTTGATTATCCAAAAATTAGTAATGCTCAGAGCAAATCATTGTTGGATATTGCTAG +TCGCTATCTAAAAGATATTTAACTGTATTCAAAATTTTCATATCTTGTTGAGCTTTTAAG +CTTTCGTATAAAGCTATTGAATAAATAATTTCGTAAGATACGTTTTCAGGAGCATCTTCT +TTCAACTTATTTATTCTATCTCTAAAAAAGTCACTGTCACCACCGAATTCTTTTTCGGCT +TGATTACTAAGTTCACCAAAGAAATTTTGAAAATCATTAAATTCCATACTTATCCACCTC +CTTTCACTAGGAGATAACTAAATTATACACAACACAAAAATAAAAAGGAGGAATAGATAT +GATAAAAAATAGTTTGCAAGCTAAAGAACTTGCGGTAATTTTATCTGTTTCTAAATCCAA +AGCAGGACAAATAATAAGAGAACTGAATAAAGAGCTTGAAGACGAAGGATACATTGCGAT +ACGAGGAAAAATACCCGTCCAATTAGCTAGAAAAAAATTCCCTTATCACGACTTATCAGA +CGAGAGAATAATGGAGGAGTTAAAAAAAGAAAATGAGTAAAACTTATAAAAGCTACTTAA +TAGCAGTGCTATGTTTCACAGTCTTAGCGATTGTACTTATGCCGTTTCTATACTTCACTA +CAGCGTGGTCAATTGCAGGATTCGCAAGTATCGCAACTTTCATATTTTATAAAGAATACT +TTTATGAGGTGGATGATTAAATGACTTGGTTCGAAGAACACGTTGAACCTAGTGTGGAAT +GGGAAAGAAAAGCAGAACAAGCTGTGTTAAGTGATGATGAAGTTAAGACGATTACTGAAT +ACAGAGAGAAGTACAACAATCCATATATTTACATGTCGGTTCAAAACAAAAATTATCTTG +TTGAATATGTAGACAGACATACCGGTGACATAGTATTACACAATTTAAAACTTAAGAAAT +CATACAGAAGAAGAGCGCATCAATATTTTTTTGTCGGCCAAATAGTAGTACCAGGCGAGC +CAAAAGGCATAATTTATGAAACATCTTTGATAATAAGATAAAAAAACCGCTACTTGCGCC +AACAAGTAACAGTGACAAACATTTAAGAAATAAAATTCAAGTTAATTAAATCAAAATATA +CGGAGGTAGTCAAGATGTATTACGAAATAGGCGAAATCATACGCAAAAATATTCATGTTA +ACGGATTCGATTTTAAGCTATTCATTTTAAAAGGTCATATGGGCATATCAATACAAGTTA +AAGATATGAACAACGTACCAATTAAACATGCTTATGTCGTAGATGAGAATGACTTAGATA +TGGCATCAGAATTATTCAACCAAGCAATAGATGAATGGATTGAAGAGAACACAGACGAGC +AAGACAGACTAATTAACTTAGTCATGAAATGGTAGAGGGGGATTAACTAATGGCTAATCT +ATATGAGCTATCAGAAGCATTTAAAGAGATGTCTAATCAAGATGAATTAGATCCAACATT +ACTAAAAGATACATTAGATTCTATCAAAGCAGAAATGAACGTCAAAGTAGATAACATTGT +CAATTGGAGACGTGAAACTTTAGGTGACATAGATGTCATAGATAAAGAAATTAAGAGACT +TCAAAATTTAAAAAAACAAAAACAAAATTTAACTGATCGTTTAAGAGATTACTTAAAAGA +GATGTTAGAAACACAGGAAGTAGATAGTTACCGCACAGCTACTAATCATATTTACAAGCG +CAAAAACGGGGCTAGTAAAAATATTATCGATGAAAAACTTATTCCAAAGGATTATTGGCT +ATCACAAGCCCCGAAACTTAATTCTAAGCAACTAATCGATGATTTGAAAGATGGGAAAGA +TATTCCTGGCGTTGAATTAAAGGTAACAGAAAGCCTGGTGATTAAGTGATGAATAAATCA +GAAACAGTTGTAGAAATAAACAAAGCTATGGTTGCGTTTCGTAAAGAAGTAAAGCAACCG +CTCAAAGATAAAAATAATCCATTTTTCAAATCAAAATACGTACCTCTTGAGAACGTTGTA +GAAGCCATTGACGAGGCGGCAACACCTCATGGACTGTCTTATACTCAATGGGCTTTGAAC +GATGTAGACGGGCGCGTAGGAGTCGCTACAATGCTTATGCATGAAAGCGGTGAATATATC +GAGTATGATCCCGTATTTATGAATGCAGAAAAGAATACGCCACAAGGAGCAGGCTCGTTA +ATAAGTTATCTTAAACGTTATTCGCTATCTGCGATTTTCGGTATTACTAGTGACCAAGAC +GATGACGGAAATGAAGCAAGTGGAAAAAATAATAATCCAAAACAGCAAACTAGAACGCAA +TGGGCAAGTAGCGAAACTATAGGGATTTTAAGGAAAGAGGTTATAAGTTTCACTAAATTG +ATAAAGGGCACGGATAAAGAAGCTCCACAAAATATAGTAGAACAAAAATTCGACATAAAT +AACTATAAATTAACGGAAAAACAAGCAGCAGAAGCTATTCAAAAAATACGAAACAACGCA +AAAACAATTACTGGAGGAAAACAATAATGTTAAACAGAACGGTATTAGTAGGACGCTTAA +CAAAAGATCCAGAATATAGAACAACGCCGAATGGTGTGAGTGTTACCACTTTCACTATCG +CAGTTAACAGAACATTTACTAACGCTCAAGGAGAACGTGAGGCAGACTTTATTAACTGTG +TAACTTTTAGAAAACAAGCAGAAAATGTAAATCATTATTTATCCAAAGGGTCATTGGCTG +GCGTTGATGGACGTTTACAATCACGCAGTTATGAAAACAAAGACGGGCAACGTGTGTTTG +TTACAGAAGTAGTAGCGGACAGTGTTCAATTCTTAGAACCGAAGAATAACAACCAACAAC +AAAACAACAATTATCATCAACAAAGACAAACTCAAACTGGTAATAATCCTTTTGATAATA +CCACTGCGATTACTGATGATGACCTCCCGTTCTGATTGGAATGATTAGATGCCAATAATT +ACTAGTTATATCACTCAAGACGACGGCACAACAACAGTTGTCATCTCGGGTGTTGAATTA +GGCAATAAAGAAACATTACTACTTGATAACGGATTTGATGTGGAAGTAGATGTAAACGTT +ATAGATCCGTTTCAAATTACTGGACAACAACGTAAATTGATATTCGCATTGTGTAACGAT +ATAGAAGCTCATACAGGACAGCCTCGAGATTATATGAGACAAATGTTCCAAGATTATGTG +AAGTTTCTGTATGGCTATGAAGAACGCATATCTTTATCAAATTGTTCTCGAACTATAGCT +AAGCAAATTATAGAAGCGATGTTTGAGTGGATTTTTACAAATGCGATTCCATTAAATTAT +AAAACAAGCAAATTGATGAAAGAAGATAAAAATTATCTTTATTGGGCAACTGTTACGCGT +CATTGCATTATATGCGGAAAGCCTCACGCTGACCTAGCGCATTATGAAGCAGTCGGCAGA +GGCATGAACAGAAATAAGATGAATCACTATGACAAACATGTATTAGCGTTATGTCGCGAA +CATCATAACCAGCAACACGCGATGGGCGTTAAGTCATTTGATGATAAATATCAATTGCAT +GACTCGTGGATAAAAGTTGATGAGAGGCTCAACGAAATGCTGAAAGGAGAAAACAATGGG +AGAAGTATCGTGGATAAAACTTAAAGTTGGCATGTTTGATGACAGCAAAATCAAATATAT +CGAAGCTTTACCCGAAAGAGATACGATCATAACCATTTGGGTTAAGTTGCTAACTTTATC +AGGAAAGTACAACGAACAAGGTTACATTATGCTATCTGAAAATTTGCCGTACAACGAAGA +AATGTTAGCAAATGAGTTTAGCCGACCTATCAACTCAATAAGGTTAGCAATTCAAACTTT +TGAGACATTGGGCATGATTGAAAAAGTTAATGGTGTCATAAAAGTGACAAACTGGGAAAA +GCACCAAAACATTGAAGGACTCGAGAAAATCAGGGCGCAGAACAGATTGAGGAAACAAAA +GCAACGAGAAAACAACAGAAAATTGTTGAATGGTCACGTGACGTCACGTGACAGTCACGC +AACAGAAGAAGATAAAGAATTAGATAAAGAATTAGAAAGAGATAAAGAAAAAGATATAGA +TAAGAATTTAAGTTCAAATAATAGCGCAACTGACGTTACGCATGAGCAATTTGAGGAATG +GTGGAAACTTTACAACAAGAAAAAAGATAAGAAGATGTCTTTCGCTAAATTCAAATCATG +CTTAAAGAAACATACTTTTGAGCAAATCATGCAAGGTACTCGAGAATATTTAAAAACTAT +TACAGACAAACAATATCAAAAGTACCCTAAAACGTTTTTAACTAACGAAAGCTATATGAA +TGATTATAGCGAAGAGATTAAAGAAACTGGCATAGATCAATTGGAACGTATGAAGTACGA +CGAAAGTTATTGGGACTAGGAGGATCTTATGAAACCGTTATTCAACGAAAAAATAAACGA +AAGTTTAAAAAAGTATCAACCAATCGAAGTAATACTAAGACAGAATTGCGATAAATGTGG +GCGTCAATACGACTTATATAAGTTTGAAAATGGATATGAATACAAAGACGGTTGCGAATG +CGAAATTCAAAGATTGGCTTATGAAGAATACAAAAGGAATAAACAAAAGAAACTTGATTA +TATTTTCAATCAATCAAATGTCAATCCGTCATTAAGAGATGCAACAGTCAACAACTATAA +GCCACAAAATGAAAAACAAGTACAAGCTAAACAAACAGCAATAGAGTACGTACAAGGCTT +CTCTACAAAAGAACCAAAATCATTAATATTGCAAGGTTCATATGGAACTGGTAAAAGCCA +CCTAGCATACGCTATAGCAAAAGCAGTCAAAGCTAAAGGGCATACAGTTGCTTTTATGCA +TATCCAAATGTTGATGGATCGTATCAAAGCGGCATACAACAAAAATGCAGTTGAAACTAC +AGACGAGCTAGTCAGATTGCTAAGTGATATTGATTTACTTGTACTAGATGATATGGGTGT +AGAAAACACAGAACACACTTTAAATAAACTTTTTAGCATTGTTGATAACAGAGTAGGTAA +AAACAACATCTTTACAACTAACTTTAGTGATAAAGAACTAAATCAAAATATGAACTGGCA +ACGTATCAATTCAAGAATGAAACACAATGCAAGGAAAGTTAGAGTAATCGGAGACGATTT +CAGGGAGCGAGATGCATGGTAATAACAAAGCAAAATATAAAAGAAATATTACATTGTAGA +GATGTATATGCTCAAAAGATGATTGATTTCTGCAAACGGAGTCCAAGAGAAACTTAAAAA +ACTTATTGATGATAAGTTGAAAGAAAAAGAAGAAAGATCCGCTATCGTCGAATATTAAGG +AGTGATTTAAAAATGCCGAAAAAAAATATTCTTATACCGAGAAGATGGCACGGAAGATAT +TAAGGTCATCAAGTATAAAGACAACGTAAATGAAGTTTACTCGCTCACAGGAGCCCATTT +CAGCGACGAAAAGAAAATCATGACTGATAGTGACCTAAAACGATTCAAAGGCGCTCACGG +GCTTCTATATGAGCAAGAGCTAGGTTTACAAGCAACGATATTTGATATTTAGAGGTGGCA +CAATGAGTAAATACAACGCTAAGAAAGTTGAGTACAAAGGAATTGTATTTGATAGCAAAG +TAGAGTGCGAATATTACCAATATTTAGAAAGTAATATGAATGGCATTAATTATGATCATA +TCGAAATACAACCGAAATTTGAATTATTACCAAAATTAGATAAACAACGAAAGATTGAAT +ATATTGCAGACTTCGCGTTATATCTCGATGGCAAACTGATTGAAGTTATCGACATTAAAG +GTATGCCAACTGAAGTAGCAAAACTTAAAGCAAAGATTTTTAGACATAAATACAGAAACA +TAAAACTCAATTGGATATGTAAAGCACCTAAGTATACAGGCAAAACATGGATTACGTATG +AGGAATTAATTAAAGCAAGACGAGAACGCAAAAGAGAAATGAAGTGATTTAATGCAACAA +CAAGCATATATAAACGCAACGATTGATATAAGAATACCTACAGAAGTTGAATATCAGCAT +TTTGATGATGTGGATAACGAAAAAGATGCGCTGGCAAAGCGTTTAGATGACAATCTGGAT +GAATTACTAAAGTATGACAACATAACAATAAGACGTGCATATATAGAGGTGGAATAAATG +AAGCTGAACGAAGTATTCGCAACTAATTTAAGAGTAATCATGGCTAGAGATAACGTAAGT +GTTCAAGATTTGCACAACGAAACTGGCGTATCAAGATCAACTATTAGTGGATATAAAAAC +GGAAAAGCTGAGATGGTTAACTTAAATGTATTAGATAAATTGGCAGATGCTCTAGGTGTT +AATGTAAGTGAACTATTTACTAGAAATCACAACACACACAAATTAGAGGATTGGATTAAA +ACAGTAAATGTATAGAGGTGGAATAAATGGCGAAAACAGCAAGAATTGTAAGGATACATG +ATAAACCGTATAGGTTCAGTGAATTTGAAATGGAGTTAATTGAAAGTCACGGTATAACAC +CCGGGATGGTTTCTAAAAGAGTAAAAGACGGTTGGGAACTACATGAAGCAATGGACGCAC +CAGAAGGCATGCGTTTAAGCGAGTACAGAGAAAAGAAAACAATAGAAAGACTGGAACAAG +CTAGACTCGAACGCAAATTGGAAAGACAGCGAAAGAAAGAGGCTGAGCTAAGAAGAAAGA +AGCCACATTTGTTTAATGTACCTCAAAAACATTCACGTGATCCGTACTGGTTCGATATTA +CTTATAACCAAATGTTTAAGAAATGGCAGGAAGCATAAATGCCAAAAACTGATAGCGCAT +GTAAAGAATACTTAAACCAATTTTTTGGATCTAAGAGATATCTGTATCAGGATAACGAAC +GAGTGGCACATATCCATGTAGTAAACGGTACTTATTACTTTCATGGGCATATCGTGCCAG +GTTGGCAAGGCGTGAAAAAGACATTTGATACAGCGGAAGAGCTCGAAATATATATAAAGC +AGCATGGTTTGGAATACGAGGAACAGAAGCAACTAACTTTATTTTAGAGGAGGTTATGAA +AGTGAACTATGAAACAGGGTTCCAAATAGGTGTAATGGAAGCTAGGTTGAAGAAGATGAG +AAAACAACGAGATGAGTATAAGAAGCAACAAGATGAGCTTATCGTGGATATAGCGAAGTT +ACGAGAACGTAACAAAGAGTTGGAGAAGAAAGCAAGTGCATGGGATAGGTATTGCAAGAG +CGTTGAAAAAGATTTAATAAACGAATTTGGCAACGATGATGAAAGAGTTAAATTTGGAAT +GGAATTAAACAATAAAATTTTTATGGAGGATGACACAAATGGATAACCGTGAACAAATAG +AACAGTCCGTTATAAGTGCTAGTGCGTATAACGGTAATGACACAGAGGGATTGCTAAAAG +AGATTGAGGACGTGTATAAGAAAGCACAAGCGTTTGATGAAATACTTGATGGAATGACAA +ATGCTATTCAACATTCAGTTAAAGAAGGTATTGAACTTGATGAAGCAGTAGGGATTATGG +CAGGTCAAGTTGTCTATAAATATGAGGAGGAACAGGAAAATGACTAACACATTAACAATT +GATCAGTTACAAGAGTTATTACAAATACAAAAGAAGTTCGACGATAGAATACCGACTAGA +AATTTAAATGACACAGTAGCTAGTATGATTATTGAATTTGCGGAGTGGGTTAACACACTT +GAGTTTTTTAAAAATTGGAAGAAACAACCAGGTAAGCCATTAGATACACAATTAGATGAG +ATTGCTGATTACTTAGCTTTCAGTTTGCAATTAACTTTGACTATTGTTGATGAAGAAGAT +TTGGAAGAAACTACTGAGGTTATGGTTGATTTGATTGAAAATGAAGTTACTTTACCTAAA +CTACATTCAGTTTATTTTGTTCATGTAATGCATACACTAACAGAACAATTTGTAAAAGGT +ATTGATAATAGTATTGTACAAGTTTTAATAATGCCTTTTTTGTACGCCAATACTTACTAT +ACAATCGACCAACTCATTGACGCATACAAAAAGAAAATGAAAAGGAACCACGAAAGACAA +GATGGAACAGCAGACGCAGGAAAAGGATACGTGTAAAGACATCTTAGATCGAGTCAAGGA +GGTTTTGGGGAAGTGACACAATACTTAGTCACAACATTCAAAGATTCAACAGGACGTAAA +CATACACACATAACTCGAGCTAAAAGCAATCAAAGGTTTACAGTTGTTGAGGCAGAGAGT +AAAGAAGAAGCGAAAGAGAAATATGAGTCACAAAATACACCTATTGTTTACTACACTAAT +AATTCTAAAGTGACCTTATTCGAAAGACCTAGTGAAGAAGTATTAGGTTCTTTGTTCGAA +AAGAAATAAAATCATTAAAGAGGGGAGATAATAATGTTTAATACACCTAAAATGAAATTA +CCAGAAAAGCACACCGAGGTATTTAAGACGTATAAAAATGGAACGCCAGAAGAAAAAGCT +GAGATTGAAGGCTGTTTTATTAAAACTGTTAAAGATGAAGATAGTGAATTTTACAGCCCT +ATGTTAGCCAGTCTAAATGAACAACAGTTAAAGAGTATGTTGAGACAGGTACTTTTTTTG +ATTGATACAGGAGATGACAATGATGATTAAAAAACTTAAAAATATGGATTGGTTCGATAT +CTTTATTGTTGGAATACTGCGATTATTCGGCGTAATCGCACTGATGCTTGTTGTCATATC +GCCTATCTATACAGTGGCTAGTTACCAAAACAAAGAAGTACATCAAGGGACAATTACAGA +TAAATATAACAAGAGACAAGATAAAGAAGACAAGTTCTATATTGTGTTAGACAACAAGCA +AGTCATCGAAAACTCTGACTTACTATTCAAAAAGAAATTTGATAGCGCAGACATACAAGC +TAGGTTAAAAGTAGGCGACAAAGTAGAAGTTAAAACGATTGGTTATAGAATACACTTTTT +AAATTTATATCCGGTCTTATACGAAGTAAAGAAGGTAGATAAATAATGATTAAACAAATA +TTAAGACTATTATTCTTACTAGCGATGTATGAGCTAGGTAAGTATGTAACTGAGAAAGTA +TATATTATGACGACGGCTAATGATGATGTAGAGGCGCCGAGTGATTACGTCTTTCGAGCG +GAGGTGAGTGAGTGATGTGGATTACTATGACTATTGTATTTGCTATATTGCTATTAGTTT +GTATCAGTATTAATAGTGATCGTGCAAGAGAGATACAAGCACTCAGATATATGAATGATT +ATCTACTTGATGAAGTAGTTAAAACTAAAGGATACAACGGGTTAAAAGAATACAGGATTG +AATTAAAGCGAATGAATAACGATATTAAAAAGTAATTTATATTATCGGAGGTATTGCATG +TATAACAGGAAAGAAATACGTGAAATGATAGATAACTACAAGTGGATGAAGAACATAATA +GACAGTAAAGTCTACGATAACGAAAGTACATCAATTGCACAATATGGTTATCAATCTGCG +ATGCCAAAAGCTAAAGGCACGACTAGCAATAAAATGTTAGTGAAAGTTATAAACAAAAAC +AAAGCGCTTAGAAAGTACGATTACTTGATTAAGAAGATAGCGTTCATTGATGAATATGAA +GAATACATCACGAATGAAAAAGATTATCATATTTTACAAATGTTAAAACAACGAGAAAGC +CATAATAGGATCATGAGCATTCTTGATATAGGCAGAGACAATTTTTATTCTAGAGTAAAA +GATATAGTAAATATACTTTATAACTTGCAACAAGAAACCGACAGTTCGGACACATCGTAC +AGTTCGGACACATCGTACAGTTCGGACACATCGTACTAATTTTGATGCTACATATTGTTT +TTTATTATAATTGCTGTGTAGCAAAACATTTATATTTCTTTTGAACTCTCACATTAAGTG +AGGGTTTTTATTTTTATAAACAAGAGGTGGAGAATGGAGATATCAAAGTACCAAGAGATA +GCTACACGTACACACAATGATGAATTGAATTTAAATGAATCTATTACTTGTTACGGCTTA +GGTTTAACTCAATCTACAGGCAATGTTACAGATCTAATTAAACAGCATATGTTTTGTAAT +GTACCGATAGATAAAGGAATTATGATAAATGAACTTAGCGAAGCATTGTGGAATATAGCT +AATCTTACTAACGTGTTAGGTATTAACTTGGATGAGATAGCTGGTCATAGTGTTACCACT +ATCTTGATGAATAAACCTAATCAGACTATCAATTTAGACAATGGTATAAAACAAGGAGAC +AAAGTATTGTTTCAAGGTAGTAAGTATCTTGTTGATGGATCGATAGGAAACTTATTGTTA +ATTAGCAATGATAAAGATGATAGACAAGTAACTGTGCAAGATGTTAAGAAAGTCGACAGG +GAGTGATGTGCATTGTCTATTATGAAGCGATGTGGTCATCCAACATGTAATGTATTGATT +AATCATAATGAAAGTTATTGTGATAAACACAAGCAATATGCAAATGAAAATTACAATGAT +TTGAGACGTCGAAACGATCCAGAGTATTTAAGATTTTATAAATCGAAAACGTGGCAAAAC +ATGCGTCGAATTGTATTGTTAGAACATGATTTTATTTGTGTTTCTTGTGGCAATCAAGCG +ACTATGGTTGACCATATTGTACCAACAAAAATTGATTGGGCAAGAAGATTAGACAAAAGT +AATTTACAGCCTTTGTGTGATGCTTGCCATAACCAAAAGACAAAAGAAGATTTGAAGAAA +TATTAAAAAAGATAAAAATAGGAAGCCCCCCCAAAGATGAAACGGGCGTCAATGAAAGGT +TCTGGAGAACGGAGCAGAGTTTTCTTCTCAAAAAATTCCCTTTATTTAAGTTTTTTTAGT +AGGAGGTGCTAATTTATGGCGGGTAGACCTAAGAAGCTTTTGTCAAATTCGAACAAGAAT +TATACAAAAGAAGAAATTATTGAAAAAGAGCGTCAAGAAGCTCAATTAAATAAATTTTCT +AAAATCGATACTGAACCACCGCACTTTTTAGATGAAATAGCGAAACAAGAATACTTAAGA +ATATTACCGCACATGCAAGAATTGCCAATTTCCAACTTAGATAAAGCACAATTAGCACAA +TATTGTAGTTTTTATAGTGACTTTGTTAAAGCAAGTTTGATTTTAGAGCGCGAAGACTTG +ATTTTAGAAGACGACAAAGGAAATCAAAAGGTTAATCCGGCGTTCAACATAAAGGAAAAA +GCGGGTATTCGATTGCAACAAACAGCTAATACTTTAGGATTAACTATTGATAGCCGATTG +CGTATTATGGTTCCTGATGAAAAAGAAGATGATGATCCATATATGGAATTTGTGAGTGAT +TAGTAATGACTGATTATGTTACTAAATACGCAAAAAAGGTAGTTTCAGGAGAAATTTTGG +CAAGTTTGAAGAATATTCAAGTATGTAAACGTCACCTATCTTTTATGGAGAACCCGCCGA +ATGGTTGCCATTGGGATAATCATTTGTCTAACAAAGCAATTAAATTTGTGGAAATGCTTC +CAGACCCTAAAACAAACCAGCCCATGCCTCTTATGGAGTTTCAGAAATTCATTGTTGGGA +GCTTATACGGCTGGCGTAGAGGTCAATACAGAATGTTTACTAAAGCTTATATAAGTATGG +CTAGAAAACAAGGTAAGTCTCTAATCGTATCGGGAATGTCCGTTAACGAACTGTTGTTTG +GACAATACCCTAAATTTAATAGACAAATTTATGTAGCTTCATCTACTTATAAGCAAGCGC +AAACAATATTCAAGATGGCAAGCCAACAAGTAAACCTAATGCGAAGTAAAAGCAAGTTTA +TCCGTGAAAAAACAGACGTAAGAAAGACAGACATTGAAGATGTATTAAGTAGTTCAGTGT +TTGCACCTCTTTCCAATAACCCAGATGCGGTTGATGGTAAAGATCCTACAGTTGCTATTT +TGGACGAATTGGCAAGTATGCCTGATGATGAGATGTACTCAAGGTTTAAAACAGGTATGA +CATTACAAAAAAATCCTTTAACCCTACTTGTTTCAACGGCCGGAGACAATTTAAATAGTC +AAATGTACCAAGAGTATAAGTATATTAAACGTATTTTAAATGAAGAAGTAAGAGCTGATA +ATTACTTTGTATATTGTGCTGAAATGGATTCACAAGAAGAAGTTCAAGATGAAACAAAGT +GGATTAAAGCAATGCCGCTTTTAGAATCAAAAGAACATAGAAAAACTATACTTCAAAATG +TAAAAGCTGATATACAAGACGAATTAGAAAAAGGGACATCATATCATAAGATTTTGATTA +AAAACTTCAATTTATGGCAAGCGCAAAGAGAAGATAGCTTGCTAGATATTTCAGATTGGG +AACAAGTAATAACGCCTATGCCTAATATCAATGGTAAAGATGTGTATATAGGTGTCGACT +TATCGAGATTGGATGACTTAACATCTGTAGGGTTTATTTTCCCTAACGACGATAAAAAAG +TGTTTTTACATAGTCATTCTTTCATTGGATTAAGAACAAACTTAGAACAAAAATCTAAGA +GAGACAAAATAAATTATGAATTAGCGATTGAACGTGGCGAAGCTGAGACTACACAATCAG +ATAGCGGCATGATTGATTATAAACAAGTTATCGATTTTATAGTGAAATTTATAACGACGC +ATGACCTGAATGTACAGGCTGTTTGCTATGACCCTTGGAATGCGCAAAGTTTTATAACAA +CAATCGAATCAATGGCTTTAGATTGGCCACTCATTGAAGTGGGACAAAGTTTTAAGGCGT +TATCACAATCTATTAAAGAATTTAGAATGTGGGTTGCAGATGAAAGAATACAGCATAACG +ATAATATGTTACTTACAACATCAGTTAATAATGCCGTTTTGATTCGTGACGGAGAAGACA +ATGTGAAAATAAATAAAAAAATGAATCGTCAAAAAATAGATCCGATTATTTCGATTATCA +CAGCTTTCACTGAAGCTAGAATGCACGAATTCCAAGAAAATTGGACGGAGAAATATGAAA +GCGAAGAATTCGGGTTTTAAAGGTGGTGACAAAATGGACTTGAATAAAATAAATGTCTTT +TTTAATTTCTTGGTTGCTAATTTGGTTAGCATCCTTTTTTTATTAGGTTTGTTTGTGGTT +AATGTTTCTGTGTATAAAGCATTCGGTCAAAATATAGGACTTTTATGCATTGGTATAACA +CTGATTGTTATTTCGTTGATTTTAAATCATGAAAGCAATCAAGAAAGGAGTTAGTAGTTG +TGGGGATTTTTTATAAAAATGAAAAACGAGACTTGCAATACAACGAAGATGATTTGCAAA +TGATGGTTCAAACTTTGCCAAGTTTTCAAGGAACAAAATTACGACAATATAAAGATATAG +AAGCAATTAGGCATAGCGACATCTTTACTGCAGTTATGATGATTGCTTCTGATTTGGCAC +GCATGCCAATTAGGGTGACAGTGAACGGCCAAATTAATTATAGTGACAGGATTGTTAATT +TGTTAAATACACGTCCTAACCCAATGTATAACGGCTATATATTCAAATTAGTAGTGTTTG +TTAGTGCCTTACTAACATCGCACGGCTATATTGAAATTACACGTGATAAAACAGGAGAAC +CTATGAATTTAACGTTCAGAAAGACATCCGAAATAGAATTGAAATCAGACGCAAGAGGTC +GACTGTATTATTTTCATCAAAGGATAGACAGTAACGGAAATAATATAGAACGTAATGTTA +AGTTCGAGGATATGCTAGACATCAAATTTTATTCGTTGGACGGTATAAATGGTTTGTCAC +TGTTAGACACATTAAGTCGCACGATAGAATCAGATAACAATGGAAAAGATTTCCTTAATA +ATTTCCTGCGAAATGGCACACATGCTGGTGGTATTTTGAAAATGAAAGGTGTATTAGATA +ATAAAAAAGCAAGAGACCGTGCCAGAGAAGAATTCCCAAAAGTTTTAGTGGAACTAAACA +AGCTGGGAAAGTTGTCGTACTCGATGAATCAATGACGTTTGATCAATTAGAAGTTGATAC +AGAAGTTTTAAAGCTTATCAGAGAAAACAAATCATCAACAAGAGAAATAGCAGGTGTATT +TGGTATTCCATTGCATAAGTTCGGCATAGAAACAGCGAACATGAGTATCACGGATGCTAA +TTTAGATTACTTATCAACTTTAAAACCTTATATTACATGCGTTTGTGCAGAATTGAATTT +TAAGTTTAATGATGAATATGTGAATCGTGAATTTAAATTTGATACCACTGAAATACGAGT +TGTTGATGAAAAAACACAAGCTGAAATTGACAAAATTAACATTGATTCTGGAAAGATGAA +TATCGATGAAATTAGACAACGTGATGGATTAGCGCCAATACCAGGCGGTAATGGTAGCAT +TCACAGAGTCGATTTAAACCATGTAAATATTGAACTTGTAGATGAGTATCAGATGAATAA +ATCGAGAGCTACTGATAAAAAATTGAAAGGTGGTGAGGAAAATGAGTAAGGAAACGAGAG +TTGGCAACATTATTGAGGTACGCTCAAATGATAACAACGAAATGGTCATAGAGGGGTATG +CGTTAAAGTTTGACACTTGGTCTGAAAATCTTGGTGGATTCAAAGAAACGATTTCACGTC +GTGCTTTAGAAAACACTGATTTATCTGATGTGCGTTGTTTAGTAGATCATATCCCATCGC +AAATAATTGGTAGGACAAAATCGGGTACTTTGGAGCTCGAAACTGATGATGTTGGACTTA +AATATCGTTGTAAGTTACCAAACACAACATTTGCACGTGATTTATATGAGAACATGCGTG +TAGGCAACATCAATCAATGTTCGTTTGGTTTTATGCTTGACGATAAAGGCGATGAAGTGC +GTTTTGATGAACAAGAAAACATTTACAAACGTACTTTAACAGCAATTCGTGAACTTACAG +ATGTTTCTGTAGTGACTTATCCGGCTTACAAAGACACTGATGTTAAACCAGCATTACGTA +GTATTGAAACCGTTAAAAAAGAACAACGTAAAAAAGAATTAGAAATAAGACTAAAGAAAC +ACTCTATATTAAATAATATTTGGTGAAGTTGAACACCATTATCAAATACAGCCATTGGAC +ATGCTGAATATAGCGATGTCTATTTTTTTATGCCAATTTTAGGAGGAAATTAAATGAAAA +CAAAAGAAGAGTTACAATCTGAGATTTCAGACATTAAAAGACAAATTGATTTAAAGGTGA +AGTATGCAACGAGAGCACTTAATAACGATGAGTTAGAAAAAGCAGAAAAATTAGAACAAG +AAATTACTGATTTACGTTCTCAAATCCAAGAAAAACAAGAAGAATTAGATAAGCTAAAAG +AAAAAGATAGAACTTCAGAAAACAATCAACAATCAGTGGAAGTAAACGAAGCACGTACTT +ATCGAAACCAAGCAAACATTAATGATTTAGGTATTTCGATTCAAAACACAAAGGTAACAT +CACAAGAAGTTAGAGATTTTACTGAATATCTTGAAACACGCAATGATATTCAAGGTGGTT +CGTTAAAAACAGACTCAGGATTTGTAGTTATTCCAGAGGAAATTGTTACAGATATTTTAA +AATTAAAAGAGGTTGAGTTTAATCTTGATAAGTATGTGACGGTCAAACGTGTTACAAATG +GTTCTGGTAAATATCCGGTAGTACGACAATCAGAAGTTGCAGCCCTTGAAAAAGTTGAAG +AATTAGAAGAAAACCCTGAATTAGCAGTTAAACCATTCTTCCAATTAGCATATGACATTA +ATACACACCGTGGTTACTTCCGAATTTCACGTGAAGCAATCGAAGATGCAAAAGTGAATG +TTTTGCAAGAATTGAAACTATGGATGGCGCGAACTATTGCAGCAACACGAAACAAAGCAA +TTATTGATGTTATCACTAAAGGATCAACGGGTTCTACAAGTTCAGGTTTTGAAAAAGAAG +GCAAGAAATTAGAAGTTAAAAAAGCAAAATCTTTAGATGATATTAAAGATGCTATTAACC +TGAATGTTAAGCCAAATTACGAACATAATGTTGCGATTGTTTCGCAAACTATGTTTGCAA +AATTAGACAAAATGAAAGATAAGCTAGGAAACTATTTAATCCAGCCAGATGTTAAAGAAA +AAACGCAACAGCGTTTATTAGGAGCTAAAATCGAAATTTTACCTGATGAAGTACTAGGGC +AAAAAGGTAATAACACTTTGATTATCGGTAACTTAAAAGATGCGATTGTTTTATTTGACC +GCTCTCAATACCAAGCATCATGGACTGACTACATGCATTTCGGAGAATGTTTAATGATTG +CTGTACGTCAAGACTGTAGAATTCTAGATTATAAATCAGCAATTGTGATTGAATATGATG +ATAGTGAACGCGGTGAAGGCGATCTTGGCTTAGAAGCATAATAAGCGCTCGATACTTTAT +AAAGAGGTGATAAACTATGGCAATGTATGAAGTGAAGAAATCTTATACTGACTTGGAAAA +AGGCCAGTATTTAAAGTCAGGTAAACGTGTTGAAATGACAGTAAAACGTGCTGAATATGT +TAACAAAAAGCTGAAAGAGCATGGAGTAATACTTGAAAGAGTAAAAGAAGAATAGGTGAT +TGAATGCAATTAACAGCTGAGGAACTTAAGTTATTAAAAAAGCATTGCAAAATAGATCAC +AATTCAGAGGACGACTTATTAGAAATATATTACTCTTGGGCATTCCATGAAATAGCTAGC +GCTGTTACGGATGAACCAAGTAAATATATTGATTGGTTTAAAAGTCATCCTCTATTTGCT +CGTGCTATATACCCTTTAGCAAGTTACTATTTTGAAAACCGTATTGCTTATTTGGATAGG +GATTTATCGCTTGCGCCACATATGGTTTTAAGTACGGTGCATAAATTGAGAGGTTCATTT +GAGCAATTTTTGGAGAGTGAAAATGATGAAGAGTCTGGGACATAAATCCCTAAAAAAACA +GCAGTAAGATAATTTTCAATTAGAAAATATCTTACTGCTGTTCTCTATTTATACAATACT +TCGTATTGAATGGCTTCGCTTTCCTAGGGTGCCGTCTCAGCCTTGGTCTTCGACTGGCAC +TGCTCCCTCAGGAGTCTCGCCATTAATACTACGTATTAACATGTAATTTTACTTTGAAAT +ACTTTAAAAAAATAAGACACTTTCGTATAATTTAATAAATACCACTAAACTAAATTAACG +AGGTGCCTTATGTATAAAAATTATAACATGACCCAACTTACACTACCAATAGAAACTTCT +GTTAGAATTCCTCAAAATGATATTTCACGATATGTTAATGAAGTTGTTGAAACGATACCT +GATAGCGAATTCGATGAATTCAGACATCATCGTGGCGCAACATCCTATCATCCAAAAATG +ATGTTAAAAATTATCTTATATGCATACACTCAATCTGTATTTTCTGGTCGTAGAATAGAG +AAATTACTTCATGACAGTATTCGAATGATGTGGTTAGCTCAAAATCAAACACCTTCTTAT +AAAACTATTAATCGTTTTAGAGTAAATCCTAATACTGATGCATTAATTGAATCTTTATTT +ATTCAGTTTCATAGTCAATGTTTAAAGCAAAATCTTATTGATGATAGTTCAATTTTTATT +GATGGTACAAAAGTAGAAGCTAATGCCAATAGGTATACATTTGTGTGGAAGAAAAGTATT +CAAAATCACGAATCGAAATTGAACGAAAATTCAAAAGCATTATATCGTGACTTAGTTGAA +GAAAAAATAATACCGGAGATAAAAGAAGATGGAGATAGCGATTTAACAATAGAAGAAATA +GATTTAATTGGTAGTCATTTAGATAAAGAAATCGAAGATTTAAATCATTCTATTCAGAAC +GAAGATTGTACTCAAATTAGAAAACAGACCCGTAAAAAAAGAACTGAGATTAAGAAGTTC +AAAAAGAAATTTGATGATTATTCCGAAAGAAAAAGTAAATATGAAGAACAAAAATCGATT +CTTAAAGATAGAAATAGCTTTTCTAAAACTGATCATGATGCAACTTTTATGAGAATGAAG +GAAGACCATATGAAAAATGGCCAACTTAAGCCAGGATACAATTTACAAATAGCGACAAAT +TCTCAATTTGTTTTATCCTATGACCTATTTCAAAACCCGACAGATACTAGAACTTTAATT +CCATTTTTAACAATGATTCAAAATACCTTCGGTTATTTACCGGAGTATATTGTGGCTGAT +GCAGGTTATGGTAGTGAGCAAAACTATATGGCTATTATAGATGATTTTAATAAAACGCCA +CTTATTACGTATGGTATGTTTATTAAAGATAAAACGAGAAAGTTTAAAAGTGACATTTTT +AACACTCAAAACTGGAAATATGACGAACTTAATGATGAATTTATATGTCCTAATAACAAA +AGAATAGGTTTTAAAAGATATGCATACCGTAATAATAGATATGGTTTTAAACGTGACTTC +AAACTATATGAATGCGATGACTGTTCAGCATGTTCTTTGAGGCAACAATGCATGAAGCCA +AATTCGAAATCCAATAAGAAAATCATGAAGAATTATAATTGGGAATACTTTAAAGCCCAA +ATTAATCAAAAGCTTTCTGAACCAGAAACGAAAAAAATCTATAGTCAAAGAAAAATTGAT +GTAGAGCCTGTTTTTGGATTTATGAAGGCTATTTTGGGTTTCACTCGAATGTCAGTTCGA +GGAATAAATAAAGTTAAACGAGAGCTAGGTTTTGTATTAATGGCACTTAATATAAGGAAA +ATAGTAGCTCGACGAGCTGTATATTATCAAATACATTTAAAAAAAGCTGATTTCTATCAA +ATAATTAATAGAAATCAGCTTTTTTACATTGCCTAAGAACTTAATGTCCCAAGCTCGAAC +GTATAGATTTTTGTGAAGATGTAAGCGAGAGAGTGAACAGAAATCCGATGAAACCGAAGA +CGAAAATATTATACTCTTGTTTCGCTTGCATTCAAGAATCTAAAGAATCCGACACTCAAA +CGAATCTCAATACAGGTAGCAAATTCATTAAAACTATTATTATCAGAGATACACGAGGTG +ATTATAAACCAACAAATAAGCATTACGTCTTGCATGAAGGGCAAAGGTTTAACATCAAAT +ATGTAAAGCCAGATTATCAAGATAAATCTTATTTGCGTATCTATGGCGAGGTGGTCATTT +AATGGGAGCAAGAATTGAAAGTAATAATATTGAACAAGGTTTGAAAAATGCAGTTTTAAA +AATGAATTTAAATAGTAATGTAATTGTCAAAGCTGGGGCTATGTCATTAGTCCCACTTTT +AAAAAGTAATACACCTTTTGCGAATACTAAAAAGCATGCTCGCGATCACATAGCTGTTTC +TAATGTGAAAACAGACAGACACACAAGTGAGAAAATCGTTACAATTGGTTACGCTAAAGG +CGTCTCACATCGTATTCATGCAACAGAATTTGGAACAATGTACCAAAAACCACAATTGTT +TATAACAAAAACAGAAAAGCAAGGGAAAAACAAAGTTTTAAAAACAATGCTTGATACTGC +TAAGAGGTTGCAAAAATGATTAATGTTACCAAATTAATTAGAAACGCTATTATTGCAAAT +AACATTACAGATGAAGTGAATGTGTTTAACTACACTATAGATGACCATTTTCACGAAAAA +ACTGACAAGCCTATTATTCGTATATATCCCTTACCGTTCAATCCTGACACATACGCTGAT +GATAACGAGATTTCAAGAGAATACCATTACCAAATTGATGTTTGGTGGTCTCAAGATGAA +CCGAACGAGCAAGCAGAAAAAATTGTTGATTTACTCAAAGTGATAAATTTTCAATGTTAT +TACAGAGAACCGTTATACGAGAGTGACGTCATGTCATTCAGACATATTATAAGAGCAAAA +GGCTCGATTTTATCAATGAAATTGGAGGAAAATTAAATGATTGAAAAATTGAAACAAGCA +CCAAGATTTTTAAAATTAAACTTACAACATTTTGCAGATACAGGAGTTTCGGGTATCGCA +ATTGGGGTATCAAACTTTTATTATGCACCTATTTTAAAAGATACAGAAAATGAATGGGAA +ACTGGAGCTGGCACACGTATTCGTTTCTTAAAAGAAATTGAAGTAGACCGTCCACAAGAT +ACCGAGGAAGATTATGGAGATGATATGGTCGCAGCAACTGCTGTATCTAATGGCAAACTA +AGTGTTAAGACAACATTTGTTACTGTTCCTGCTGACGATAAGGCGTTCTTGAATGGCGCT +AAAAAAGGTGTAGGTGGTTATAAATATGGAGCTAAGGATATCCCGCCAGATGTAGCGATT +GTATTTGAACGACGGTAATCATGATGAGTCTTCAGAATGGGTTGGCTTGTTCAAAGGTAA +ATTCACTCGTTCAAGCATCAAAGGGCAAACAAAACAAGATAAAGTTGAATTCCAGAATGA +CGACGTAGAAGGCAATTTTATTGATCGTTTGTTTGATGAGAGCTCGCATGTTACTGGCTA +TGATAAAAAAGGAAGCACTACAGGGCGCGATTATGTATTCATGGAAACATTTGGTAAAAC +TTATGATGAATTCATGTCTAGTCGAGGAGAACAAAATATGGAACCTGTAGAAAAAGAAAT +GAAAAAAACAGAAAAAGTTGAAGTCACTTCTGTAAACGTCACTGATGAACAAGTTACAGT +TAAAGTTGATGCTACTAAACAACTATCAGCCACAACCGAACCATCTGGACAGAAAGTAAC +TTTTGCAGTGACTGAGGGGCAAACGTATGCTAGCGTAACATCAACTGGCCTCGTTAAAGG +TTTGGCGGAAGGTAATGCGACCGTTACAGCGACTGCAGGAAAGCAAACTGATACTGTGCA +AATTACAGTACAATCTAATTTAGAAATGTAAGTTTTGAGGGCTTAACGCCCTCTTTTTAT +TTTGGCCAAATTAAAAAGAAAGTAGGAATTTAATAATGGAACGTACATCAATTGAATTAA +TTACAGGATTTACAAAAACAGGAAAGCCGCAATATCAAAAGTATTTAGCAAAGCCGATTA +TTACTTTGTTTGAAACAATTCAAGGTTCAAAATTAGGTTTGAAACTTAACAAAGCCTTTA +AGGGGGCTGATTTTAAAGATCTAACAGAAGAAGAATTTAATAACTTAAGTGTGACAGAAC +AGGAAGAATACAAAAACAAGCAAGAAGAATACGAAAACAACATGGCTGTACAAATGGAAG +TATTAGAAGAAGTTTTGGATTTCATCGTTGAAGCTTTTGATAATCAATTTACTAGTATAG +AACTTCAAAAAGGATTACCAAATGGTCAAGAAGGTATTGAAAAGATTGGACAGTTAATTG +GACGAATTACAGGTGGGGAACCTAGCGATACAAAAAAGTTCGTGACAGAGAATCAGAAAT +AAGAAAAGAAGATTTAACACCTGAAGCTGTCTACAACAATTACAGGAAAATAGCTAAAGA +TTTGATAGAAAACGGCATGGATGCAGAAAAAGTGGCTAACATGCCGATACACTTCTTTTT +AGACATTGTAGAATCGAAGATTGAAACAAAGCGAACTGCGAAAAGTTTTAAAGATATTTT +TTAATCAGCCTTTAAAGGTTGATTTTTTTATTTACATCTTGGAAGAAAGGAGGTTTTTAA +ATGCCTAATCCTATAGGTAATATGGTCATAAAGGTTGATTTAGATGGTTCTGGATTCAAT +AGAGGTGTGACAGGTTTAAATAGGCAAATGAAAATGGTTTCGCGTGAGCTTTCGGCTAAT +TTATCACAACTTTCTAGATATGATAATTCATTAGAAAAGTCGAAGATAAAAGTCGAAGGT +TTGAGTAAAAAACAAAAAGTTCAAGCCCAGATTACTAAAGAGCTGAAAGATAGTTATGAC +AAACTTAGTAAAGAAACTGGTGAAAACAGTGCAAAGACACAAGTTGCGGCTGCTAAATAC +AATGAAGCTTACGCTAAATTAAACCAATATGAGCGAGAGTTAAACCAAGCCACACAAGAA +TTAAAAGACATGCAAAGAGAGCAGAAAGCATTAAATACTGCAATGGGAAAACTTGGGACC +AACTTTAATAATTTTGGTCCTAAGCTTCAAGAAATTGGTAACAGTATGAAAAATGTAGGC +CGTAACATGACTATGTATGTAACTGCGCCGGTGGTTGCTGGGTTTGCTGTAGCAGCTAAA +AAAGGTATTGAATTCGATGACAGTATGAGAAAAGTTAAAGCAACTTCAGGTGCTACTGGG +GAAGAGTTTGAAGCTTTGAAGAAAAAGGCTCGCGAAATGGGTGCAACAACAAAATTTAGT +GCATCAGATTCGGCTGAAGCATTAAATTACATGGCACTTGCTGGTTGGGATTCTAAGCAA +ATGATGGAAGGTTTAAGCGGAGTTATGGATTTAGCGGCAGCATCTGGCGAAGAACTGGGA +GCAGTAAGTGACATTGTTACAGATGGACTAACGGCATTTGGTTTAAAAGCAAAGGATAGT +GGTCATTTTGCGGACGTTTTAGCACAAACTAGCTCGAAGGCAAATACGGACGTTAGAGGG +CTCGGAGAAGCTTTTAAATATGTCGCTCCTGTAGCAGGTGCGTTAGGTTACACGATTGAA +GATACATCTATTGCAATAGGTTTAATGAGTAATGCTGGTATCAAAGGTGAAAAAGCAGGT +ACAGCGTTACGAACAATGTTCACCAATCTTTCAAGTCCAACTAGAGCTATGGGGAATGAA +ATGGAACGCTTAGGAATATCTATTACAGATAGTAATGGGAAAATGATTCCTATGCGAAAG +CTTTTAGACCAACTGAGGGAAAAATTTAAACATCTTTCAAAAGACCAACAAGCTAGTTCT +GCAGCTACAATATTTGGTAAAGAAGCGATGTCAGGAGCATTAGCGATTATAAATGCTTCT +GATGAAGACTATCAAAAGTTAACCAAATCTATAGATTCATCTACCGGCGCATCTAAAAGA +ATGGCCGATACAATGGAATCTGGTTTAGGTGGAAAATTAAGAACTTTAAGGTCGCAATTA +GAAGAACTAGCCTTAACGATTTATGACAGAATAGAACCAGCACTAAAGATTATAGTAAGT +GCTTTTAGCAAAGTAGTGACATGGGTTACTAAATTACCAACGTCAATTCAATTAGCGGTT +ATTGGGTTTGGATTGTTTGCAGCAGTTTTAGGTCCATTAGTTTTTATGTTCGGTTTATTT +ATCAGCGTGATGGGGAATGCAATGACAGTTTTAGGACCCTTGTTAATAAACGTTAATAAA +GCTGGTGGTATATTCGCGTTTTTAAGAACTAAAATCGCATCCCTTGTTAAACTATTTCCG +GTTTTAGGTGTGTCGATATCCAGTTTAACGTTACCTATAACATTAATTGTAGGTGTATTA +GTTGGTATTGGCATAGCTTTCTATCAAGCTTATAAACGTTCAGAAACTTTTAGAAATATT +GTAAATCAGGCAATCTCTGGTGTAGCAAACGCATTTAAAGCAGCTAAACTAGCATTACAA +GGTTTCTTTGATTTATTCAAAGGTGATAGTAAAGGCGCGGTTACCCTAGAGAAGATATTT +CCACCCGAAACTGTAGCAGGAATACAAAATGTAGTTAATACGATTAGAACAACTTTCTTT +AAAGTAGTTGATGCAATCGTTGGTTTCGCCAAAGAGATAGGCGCTCAATTAGCCTCTTTC +TGGAAAGAGAACGGCTCAGAAATAACACAAGCTTTGCAAAATATAGCTGGTTTCATTAAA +GCAACCTTTGAATTTATTTTTAACTTTATTATTAAACCAATTATGTTTGCGATTTGGCAA +GTGATGCAATTTATTTGGCCGGCGGTTAAAGCTTTGATTGTCAGCACTTGGGAAAATATC +AAAGGTGTAATACAAGGGGCTATTAATATTATTTTGGGTATTATCAAAGTATTCTCTAGT +CTTTTCACAGGAAACTGGCGAGGCGTTTGGGACGGCATTGTAATGATACTGAATGGTACT +GTGCAGTTAATTTGGAATTTAATACAACTGTGGTTTGTAGGTAAAATTCTAGGTGTAGTG +AGATACTTTGGTGGATTACTTAAAGGTTTAATATCCGGTATCTGGAGTGTTATCAAAGGC +ATCTTTACAAAATCTTTATCGGCAATTTGGAATGCGACGAAAAGTATTTTTGGTTTTTTA +TTCAATAGTGTTAAATCTATTTTCACTAATATGAAAAACTGGTTATCTAGTACGTGGAAT +AATATCAAAAGCAATACCGTCGGCAAGGCTCATTCGTTATTTACAGGTGTAAGGTCTAAA +TTCACAAGTTTATGGAATGCGACGAAAGATGTATTTACTAAATTAAGAAATTGGATGTCA +AACATCTGGAACTCTATTAAAGATAACACGGTAGGTATAGCTGGTCGCTTATGGAATAGA +GTGCGTAACATCTTTGGAAGCATGCGTGACGGTTTAAAATCTATCATTGGTAAAATTAAA +GATCATATCGGTGGTATGGTAGACGCTGTTAAAAGAGGTCTTAATAAATTAATTGAAGGT +TTAAACTGGGTCGGTGGTAAGTTGGGTATGGACAAAATACCGAAGTTACACACTGGTACT +GAACATACGCATACTACTACAAGATTAGTTAAGAACGGTAAGATTGCGCGGGATACGTTC +GCTACGGTTGGGGATAAAGGACGTGGAAATGGTCCGAATGGTTTCAGAAATGAAATGATT +GAATTCCCTAATGGCAAACGTGTACTTACGCCTAATACAGATACGACAGCGTACTTACCT +AAAGGTTCAAAAGTATATAACGGCGCACAAACTTATTCAATGTTAAATGGAACGCTTCCA +AGATTTAGCATAGGTACTATGTGGAAAGATATTAAATCCGGTGCATCATCGGCATTTAAC +TGGACAAAAGATCAAATAGGTAAAGGTACAAAGTGGCTTGGCGATAAAGTTGGTGATGTC +ATGGACTTTATCGATAATCCAGGCAAACTTTTAAATTATGTACTTCAAGCGTTTGGAGTT +GATTTCAGTTCTCTAACTAAAGGTATGGGTATTGCTGGCGATATAACAAAAGCTGCATGG +TCTAAGATTAAGAAAAGTGCAATCAAGTGGCTTGAGGATGCTTTCGCAGAGTCGGGTGAT +GGCGGTGTAGTAGATATGAGTAAATTACGTTATTTATACGGTCACACTGCTGCTTATACA +CGAGAAACCGGACGCCCATTCCATGAAGGTCTGGATTTTGATTACATTTACGAACCTGTT +CCATCAACCATTAATGGTAGAGCACAAGTTATGCCTTTTCATAATGGTGGTTATGGAAAA +TGGGTAAAAATTGTAAAGGGCGCCTTAGAAGTTATTTATGCACATTTATCTAAATATAAA +GTTAAAACTGGTCACCAAGTTAGGGTCGGCCAGACTGTTGGTATATCGGGGAATACGGGG +TTTAGTACAGGACCTCACTTACATTATGAGATGCGTTGGAATGGAAGACATAGAGACCCG +TTACCGTGGTTAAGAAAGAATAATGGGGCGGCAAAAGTGCACCCGGTGGTAATGGTGCAG +CTAATGCTAGACGAGCTATTAAGGCTGCTCAAAATATTTTAGGAGGAAGGTATAAGGCGA +GTTGGATTACTAACGAGATGATGCGTGTTGCGAGTCGTGAATCCAATTATACAGCTAATG +CAGTCAATAATTGGGATAGCAACGCAAGAGCTGGTATACCTTCAAGAGGTATGTTCCAAA +TGATAGATCCTTCATTTAGAGCGTACGCAAAGTCGGGTTACAATAATCCTCTCAACCCAA +CTCATCAAGCTATATCGGCTATGAGATATATTGTGGGTAAATGGGTACCAAGAACAGGCT +CATGGAGAGCTGCGTTCAAACGCGCTGGTGATTACGCATATGCTACTGGTGGCAAAGTCT +ATAACGGATTGTATCACTTAGGGGAAGAAGGATATCCAGAGTGGATAATACCTACTGATC +CAAGTAGAGCGAACGAAGCACACAAATTATTAGCTTTAGCTGCTAACGATATTGATAACC +GCTCTAAAAATAAGCGACCAAACAACTTACCAAATCCAAGTATAAGTAATAGTGATAGAA +ACTATATTCATACATTGGAGAATAAACTAGATGCGGTTATTAATTGTTTGGTTAGTTTGG +TTGAGTCTAATCAAGTTATTGCAGATAAGGATTACGAACCAGTTATTAATAAGTATGTGT +TTGAAGATGAGGTAAATAATTCTATCGATAAACGAGAGCGTCACGAATCTACAAGAGTTA +GATTTAGAAGAGGAGGCACGATAATCTAATGCAAGATACAATTCAAATAGACAATAAAAC +AATTGGATGGCTGGTTGTGCAAAGAGGGTTCGAGATACCCTCTTTTAATTTTGTTACTGA +AAAAGAAAACGTAAAAGGTAGAGCGGGATCTATTGTTAAGAATCGTTATTTAAATGATAT +CGAATTTGATTTACCATTAATTATTCGAAACGAAAAATTGTCACCAGGTGGAGAAAAAAC +ACACGATGATATATTAGAAGCATTGGTCAAGTTCTTCAATATTAAAGATTTAACACCTAA +AAAACTTAAATTCAAATCTCAAAACTGGTATTGGTTTGCATATTTTGATGGTCCATTAAA +ATTACCGAAAAACCCAAGAGGTTCAGTGAAGTTCACTATAAAAGTAGTGTTAACAGATCC +TTATAAATACTCGGTAACTGGAAACAAAAACACCGCGATTTCAGACCAAGTTTCAGTTGT +AAATAGTGGGACTGCTGACACTCCTTTAATTGTTGAAGCCCGAGCAATTAAACCATCTAG +TTACTTTATGATCACTAAAAATGATGAAGATTATTTTATGGTTGGTGATGATGAGGTAAC +CAAAGAAGTTAAGGATTACATGCCTCCTGTTTATCATAGTGAGTTTCGTGATTTCAAAGG +TTGGACTAAGATGATTACTGAAGATATTCCAAGTAATGATTTAGGTGGTAAGGTCGGCGG +TGACTTTGTGATATCCAATCTTGGCGAAGGATATAAAGCAACTAATTTTCCTGATGCAAA +AGGTTGGGTTGGTGCTGGCACGAAACGAGGGCTCCCTAAAGCGATGACAGATTTTCAAAT +TACCTATAAATGTATTGTTGAACAAAAAGGTAAAGGTGCCGGAAGAACAGCACAACATAT +TTATGATAGTGATGGTAAGTTACTTGCTTCTATTGGTTATGAAAATAAATATCATGATAG +AAAAATAGGCCATATTGTTGTTACGTTGTATAACCAAAAAGGAGACCCCAAAAAGATATA +CGACTATCAGAATAAACCGATAATGTATAACTTGGACAGAATCGTTGTTTATATGCGGCT +CAGAAGAGTAGGTAATAAATTTTCTATTAAAACTTGGAAATTTGATCACATTAAAGACCC +AGATAGACGTAAACCTATTGATATGGATGAGAAAGAGTGGATGGATGGCGGTAAGTTTTA +TCAGCGTCCAGCTTCTATCATAGCTATCTACAGTGCAAAATATACCGGCTATAAATGGAT +GGAGATGAATGGATTAGGCTCATTCAATACTGAGATTTTACCGAAACCGAAAGGGGCAAG +GGACGTTATTATACAAAAAGGTGATTTAGTAAAAATAGATATGCAAGCGAAGAGTGTTGT +CATTAACGAAGAACCAATGTTATCAGAGAAATCGTTTGGGAGTAATTATTTCAATGTTGA +ATCTGGATACAGTGAGTTAATCATACAACCTGAAAACGTCTTTGATACGATGGTTAAATG +GCAAGATAGATATTTATAGAGAGGAGATGAAAATGTGATACATGTTTTAGATTTTAACGA +CAAAATCATAGATTTCCTTTCTACTGATGACCCTGCTTTAGTTAGAGCGATTCATAAACG +GAATGTTAATGACAATTCAGAGATGCTCGAGTTGCTTATATCCTCAGAGAGAGCTGGAAA +GTTTCGTGAACGACATCGTGTTATTATAAGAGATTCAAATAAACAATGGCGTGAGTTTAT +TATTAATTGGGTTCAGGACGATATGGACGGCTACACAGAAATAGAATGTATAGCGTCTTA +TTTAGCTGATATAACAACAGCTAAACCGTTCGCACCTGGAAAGTTTGAGAAAAAGACAAC +TTCAGAAGCATTGAAAGATGTGTTGAGCGATACAGGTTGGGAAGTTTCTGAACAAACCGA +ATACGATGGCTTACGTACTACGTCATGGACTTCTTATCAAACTAGATATGAAGTTTTAAA +GCAATTATGTACAACATATAAAATGGTATTGGATTTTTATATTGAGCTTAGTTCTAATAC +CGTCAAAGGTAGATATGTGGTACTCAAAAAGAAAAACAGCTTATTCAAAGGTAAAGAAAT +TGAGTATGGTAAAGATTTGGTTGGGTTAACTAGGAAGATTGATATGTCAGAAATCAAAAC +AGCATTAATTGCTGTGGGACCCGAAAATGACAAAGGAAAGCGTTTAGAGTTAGTTGTGAC +AGATGACGAAGCACAAAGTCAATTCAACTTACCTACCCGTTATATTTGGGGAATATACGA +ACCTCAATCAGACGATCAAAATATGAATGAAACACGATTACGTTCTTTAGCCAAAACGGA +GTTAAATAAACGCAAGTCAGCAGTCATGTCATATGAGATTACCTCTACTGATTTAGAAGC +TACGTATCCGCATGAGATTATCTCAATCGGAGATACAGTCAGGGTGAAACACAGAGATTT +TAACCCGCCATTGTATGTAGAGGCAGAAGTTATAGCAGAAGAATATAATATGATTTCAGA +AAATAGCACATATACGTTTGGCCAACCTAAAGAGTTCAAAGAATCTGAATTAAGAGAAGA +GTTTAACAAGCGATTAAACTTAATACACCAAAAGTTAAACGATAATATTAGTAATATCAA +CACTATAGTAAAAGACGTTGTAGATGGTGAATTAGAATACTTTGAACGCAAAATACACAA +AAGTGATACACCGCCAGAAAATCCAGTCAATGATATACTTTGGTATGATACAAGTAACCC +TGATGTTGCTGTCTTGCGTAGATATTGGAATGGTGGATGGATTGAAGCAACGCCAAATGA +TGTTGAAAAATTAGGTGGTATAACAAGAGAAAAAGCGCTATTCAGTGAATTAAACAATAC +TTTTATTAATTTATCTATACAACACGCTAGGCTTTTTTCAGAAGCTACAGAATTACTGAA +TAGCGAGTACTTAGTAGATAATGATTTGAAAGCGGACTTACAAGCAAGTTTAGACGCTGT +GATTGATGTTTATAATCAAATTAAAAATAATTTAGAATCTATGACACCCGAAACTGCAAC +GATTGGTCGGTTGGTAGATACACAAGCTTTATTTCTTGAGTATAGAAAGAAATTACAAGA +TGTTTATACAGATGTAGAAGATGTCAAAATCTCCATTTCAGATAGATTTAAATTATTACA +GTCACAATACACTGACGAAAAATATAAAGAAGCGTTGGAAATAATAGCAACAAAATTTGG +TTTAACGGTGAATGAAGATTTGCAGTTAGTTGGAGAACCTAATGTTGTTAAATCAGCTAT +TGAAGCAGCTAGAGAATCCACAAAAGAACAATTACGTGACTATGTAAAAACATCGGACTA +TAAAACAGACAAAGACGGTATTGTTGAACGTTTAGATACTGCTGAAGCTGAGAGAACGAC +TTTAAAAGGTGAAATCAAAGATAAAGTTACGTTAAACGAATATCGAAACGGATTGGAAGA +ACAAAAACAATATACTGACGACCAGTTAAGTGATTTGTCCAATAATCCTGAGATTAAAGC +AAGTATTGAACAAGCAAATCAAGAAGCGCAAGAAGCTTTAAAATCATACATTGATGCTCA +AGATGATCTTAAAGAGAAAGAATCGCAAGCGTATATTGATGGTAAAATTTCGGAAGAAGA +GCAACGCGCTATACAAGACGCTCAAGCTAAACTTGAAGAGGCAAAACAAAACGCAGAACT +AAAGGCTAGAAACGTTGAAAAGAAAGCTCATGCTTATACAGACAACAAGGTCAAAGAAAG +CACAGATGCACAGAGAAAAACATTGACTCGCTATGGTTCTCAAATTATACAAAATGGTAA +AGAAATCAAATCAAGAACTACTAAAGAAGAGTTTAATGCAACCAATCGTACACTTTCAAA +TATTTTAGCTGAGATTGTCCAAAACGTTACAGATGGAACAACAATCAGATATGATGATAA +TGGGGTGGCTCAAGCTTTAAATATAGGACCACAGGGAATTAGATTAAATGCTGATAAAAT +TGATATTAGCGGTAATAGAGAAATAAATCTTCTTATCCAAAATATGCGAGATAAAGTAGA +TAAAACCGATATTGTCAACAGTCTTAATTTATCAAGAGAGGGTCTTGATATCAATGTTAA +TAGAATTGGAATTAAAGGCGGTGACAATAACAGATATGTTCAAATACAGAATGATTCTAT +TGAACTAGGTGGTATTGTGCAACGTACTTGGAGAGGGAAACGTTCAACAGACGATATTTT +TACGCGACTGAAAGACGGTCACCTAAGATTTAGAAATAACACCGCTGGCGGTTCACTTTA +TATGTCACATTTTGGTATTTCGACTTATATTGATGGTGAAGGTGAAGACGGTGGTTCATC +TGGTACGATTCAATGGTGGGATAAAACTTACAGTGATAGTGGCATGAATGGTATAACAAT +CAATTCCTATGGTGGTGTCGTTGCACTAACGTCAGATAATAATCGGGTTGTTCTGGAGTC +TTACGCTTCATCGAATATCAAAAGCAAACAGGCACCGGTGTATTTATATCCAAACACAGA +CAAAGTGCCTGGATTAAACCGATTTGCATTCACGCTGTCTAATGCAGATAATGCTTATTC +GAGTGACGGTTATATTATGTTTGGTTCTGATGAGAACTATGATTACGGTGCGGGTATCAG +GTTTTCTAAAGAAAGAAATAAAGGTCTTGTTCAAATTGTTAATGGACGATATGCAACAGG +TGGAGATACAACAATCGAAGCAGGGTATGGCAAATTTAATATGCTGAAGCGACGTGATGG +TAATAGGTATATTCATATACAGAGTACAGACCTACTGTCTGTAGGTTCAGATGATGCAGG +AGATAGGATAGCTTCTAACTCAATTTATAGACGTACTTATTCGGCCGCAGCTAATTTGCA +TATCACTTCTGCTGGCACAATTGGGCGTTCGACATCAGCGCGTAAATACAAGTTATCTAT +CGAAAATCAATATAACGATAGAGATGAACAACTGGAACATTCAAAAGCTATTCTTAACTT +ACCTATTAGAACGTGGTTTGACAAAGCTGAGTCTGAAATTTTAGCTAGAGAGCTGAGAGA +GGATAGAAAATTATCAGAAGACACCTATAAACTGGATAGATACGTAGGTTTGATTGCTGA +AGAGGTGGAGAATTTAGGATTAAAAGAGTTTGTCACGTATGATGACAAAGGAGAAATTGA +AGGTATAGCGTATGATCGTCTATGGATTCATCTTATCCCTGTTATCAAAGAACAACAACT +AAGAATCAAGAAATTGGAGGAGTCAAAGAATGCAGGATAACAAACAAGGATTACAAGCTA +ATCCTGAATATACAATTCATTATTTATCACAGGAAATTATGAGGTTAACACAAGAAAACG +CGATGTTAAAAGCGTATATACAAGAAAATAAAGAAAATCAACAATGTGCTGAGGAAGAGT +AATCCTTAGCACTATTTTTATACAAAAATTTAAGGAGGTCATTTAATTATGGCAAAAGAA +ATTATCAACAATACAGAAAGGTTTATTTTAGTACAAATCGACAAAGAAGGTACAGAACGT +GTAGTATATCAAGATTTCACAGGAAGTTTTACAACTTCTGAAATGGTTAACCATGCTCAA +GATTTTAAATCTGAAGAAAACGCTAAGAAAATTGCGGAGACGTTAAATTTGTTATATCAA +TTAACTAACAAAAAACAACGTGTGAAAGTAGTTAAAGAAGTAGTTGAAAGATCAGATTTA +TCTCCAGAGGTAACAGTTAACACTGAAACAGTATGAAAAGCTATGAGTTAGATACTCATA +ATCTTTATTCTTTTAGAAAGCGGGTGTACTGAATTGGGGTGGTTCAAAAAACACGAACAT +GAATGGCGCATCAGAAGGTTAGAAGAGAATGATAAAACAATGCTCAGCACACTCAATGAA +ATTAAATTAGGTCAAAAAACCCAAGAGCAAGTTAACATTAAATTAGATAAAACCTTAGAT +GCTATTCAAAAAGAAAGAGAAATAGATGAAAAGAATAAGAAAGAAAATGATAAGAATATT +CGTGATATGAAAATGTGGGTGCTTGGTTTAGTTGGGACAATATTTGGGTCGCTAATTATA +GCATTATTACGTATGCTTATGGGTATATAAGAGAGGTGTTTACTATGCTTAAAGGAATTT +TAGGTTACAGTTTCTGGACGTGTTTTTGGTTTGGTAAATGTAAGTAATTTTTAAAGGTCA +GTGCTTTGACACTGGCTTTTTATTATTGTTGTGATTATGGTAATATACAAAAGTGAGCAA +GTTGGATAGATGGTGGCTATCTGAGTATAAGGAGGTGGTGCCTATGGTGGCATTACTGAA +ATCTTTAGAAAGGAGACGCCTTTGTGGTATCTGTTGTTGATGCACTAAATTTAATGTTTA +GTTTCGGTATGTTTATCGTTGCTTTACTTGGTTTAGTCATCGCAATCGTTAAATTAAACC +ATAAAAAATAACCATCACAACTTTGGACGGTTAATGGTTATTTTATAATAATTTCAAAAC +TGAGCCACCGTCTTTTTAACGGGCTCATTAGGGTAACATGTTTGCGCATGTTGCCTTTTT +CTATATATAAATTAACACACCATAATATAAATATCAAATAGACGGCTTATTAGTCGTCTT +TTTATTTTGGATAAAAGGAGATAAGAATATGATTAATTGGAAAATTAGAATGAAACAAAA +ATCATTTTGGGTAGCGATATTGTCAGCTATCTTTTTATTTGCTCAAAACATCGCAAAAGC +TATTGGGTATGATATTCAAGTTTATACAGAGCAATTAACAGACGGTTTAAACGCTATATT +AGGGTTTTTAGTATTAACTGGTGTGATCCAAGACCCGACTACTAAAGGTATAGGTGATAG +CCACCAAGCTTTAGAATATGAAGAACCAAGTAGAAAATACTAGGAGGTAAAATAATGAAA +ACATACAGTGAAGCAAGAGCAAGGTTACGTTGGTATCAAGGTAGGTATATTGATTTTGAC +GGTTGGTATGGTTACCAATGTGCAGATTTAGCAGTTGATTACATTTATTGGTTGTTAGAA +ATTAGAATGTGGGGAAATGCAAAAGATGCAATCAATAATGATTTTAAAAACATGGCAACA +GTATATGAAAACACACCATCGTTTGTTCCACAAATAGGTGATGTGGCTGTATTTACCAAA +GGAATATATAAACAATACGGTCATATTGGTTTAGTGTTTAATGGTGGTAATACAAATCAA +TTTTTAATTTTGGAACAGAACTATGACGGTAACGCAAATACGCCTGCAAAGTTACGTTGG +GATAATTATTACGGCTGTACTCACTTTATTAGACCTAAGTATAAAAGTGAGGGCTTAATG +AATAAGATCACAAATAAAGTTAAACCACCTGCTCAAAAAGCAGTCGGTAAATCTGCAAGT +AAAATAACAGTTGGAAGTAAAGCGCCTTATAACCTTAAATGGTCAAAAGGTGCTTATTTT +AATGCGAAAATCGACGGCTTAGGTGCTACTTCAGCCACTAGATACGGTGATAATCGTACT +AACTATAGATTCGATGTTGGACAGGCTATATATGCGCCTGGAACATTAATATATGTGTTT +GAAATTATAGATGGTTGGTGCCGTATTTACTGGAACAACCATAATGAGTGGGTATGGCAT +GAAAGATTGATTGTGAAAGAAGTTTATTGAAAACGCGCAGTTAATAAAAAGATAATAAAT +AGTTAATTTTATGTAATTTTCTTGTTTAACAGAAAAATCAAATATTTTAATGTATATTGA +ATTTAATATTCGTATAGGCTTTATAGTTAAAAAATTAACAAGCATTAACAATACAATGTT +TTTCAGGTATATTTCTATACAACTATAATGAACTTTTTTAATTATTGATCGTGTTTGAAT +GTTTTTTGGGTGTAACAATACTATTTTAGAGATTTATTAACCTTATTGAATTTTTAATAA +ATTTTTAATTATATAATTATGAATTATGTAATAGTATAAATTTGTATTAAAAATATAAAG +AGAAAGAAAGTGAAACTATGTTTAAGAGAAAATTATTAGTTACAACTTTGTCGCTAGGTC +TAATTGTCCCTATAGCTACACCATTTCAAGGCTCTAAGGCTACTACTAATGCAGAAGATA +TTGGCGACGATGCAGAAGTGATTAAACGTACGGAAGATGTAAGTAGTAGGAAATGGGGTG +TAACACAAAATGTCCAATTTGATTTCGTAAAAGATAAAAAATATAACAAAGACGCATTAA +TTATTAAGATGCAAGGTTTTATCAATTCTAGGACAACTTTCAATGATGTTAAACAAAATA +GAGCAAATAAAAGAATGGTTTGGCCATTTCAATATAATATCGGTCTTACATCAAAAGACC +AAAATACGAGCTTAATCAATTATCTTCCTAAAAATAAAATAGAAACAGTTGATGTTGGTC +AAACTTTAGGATATAACATTGGAGGTAAATTCCAGTCAGTACCATCTATAGGCGGAAATG +GATCATTTAATTATTCTAAGAGTATTAAATATTCCCAAAAGAGTTATGTCAGCGAAGTTG +AACAACAAAGCTCAAAAACTATTAAGTGGGGGGTTAAAGCAAATTCTTTTGTTATAGCAG +GGCATCGATGGTCTGCTTACGATGAATTATTGTTTATAAGAAATACGACAAGAGGACCTA +ATGCTAGAGACTATTTTGTAGACGATAATGAATTGCCCCCTTTAATAACAAGTGGATTTA +ATCCGTCTTTTATCGCGACAGTATCTCACGAAAAAGATTCAGGCGATACGAGCGAATTTG +AAATTACTTACGGTAGAAATATGGATGTTACCTATGCAACCTACCTTCCTAAACTTGGTC +TTTATCCAGAAAGAAAACATAATGAATTTGTAAACAGAAACTTTGTGGTCAAATATGAAG +TGAATTGGAAAACGTACGAAATTAAAGTAAAGGGGCACAACTAATATGAAATTTAAGAAT +ATAGTCAAATCATCAGTCGCTACATCAATTACATTAATCATGCTATCAAATACAGTTGAT +GCAGCTCAACATATCACACCTGTCAGCGAGAAAAAAGTGGATGACAAAATCACTTTGTAC +AAAACGACTGCTACATCAGATTCTGACAAATTAAAAATTTCTCAAATTCTAACTTTTAAT +TTTATTAAAGACAAAAGTTATGATAAAGACACATTAATACTAAAAGCTGCCGGAAACATT +TACTCAGGCTATACCCAACCCACTTCTGATAGTAGTATAAATTCACAATTTTATTGGGGA +GCTAAGTATAATGTTTTTGTTAGCTCGGAGTCCAAAGATTCTGTAAATATTGTTGACTAC +GCGCCTAAAAATCAAAATGAAGAATTTCAAGTTCAACAAACATTAGGTTATTCATATGGC +GGAGATATTAATATAATAAATGGATTAACTGGTGGATTGAATGGGTCAAAATCATTTTCA +GAAACGATTAATTATAAGCAAGAAAGCTACAGAACTACGATTGATAGGAAAACAAATCAT +AAATCAATCGGCTGGGGTGTCGAGGCACATAAAATCATGAATAATGGTTGGGGACCATAT +GGCAGAGATAGTAGTGATTCATTATATGGAAACGAACTATTTTTAGGTGGCAGACAGAGT +AGCTCGAATGCTAATCAAAATTTCTTACCAACACATCAAATGCCCATATTAGCACGTGGT +AATTTCAATCCAGAATTTATAAGCGTACTTTCTCACAAACAAAAGGATGTTAAAAAATCT +AAAATTAAAGTGACTTATCAAAGAGAAATGGATCGGTATGAAAATTTTTGGAACAACTTG +CACTGGATAGGTTATAATATTAAGAATCAAAAGAGAGCAACACACACATCAATTTATGAA +ATTGATTGGGAAAAACACACGGTTAAATTAGTAGCTTCGCAATCTAGCGAATAAACTACT +TCCTAGATACCGTTGATTTTATAATAGGCTATGATTCGAAAAGAAATCTAATTACTCAGA +TATTAGGTGACTTATGGGTAGAAATCAGTTAATATAAAATTGTGGTGAGCCTTTTCTTGG +CGAGTGCATAATGCATTCGCCTTTTTTATTTACATTAAAAAACAATTGTGGTATTATTTC +TACATACTTTATTTAACATTTCTCTCTCAAGTTGAAATTGCGAGTAGTAGGCAGGTACTT +CGGTACTTGCCTATTTTTTATGTTATAATTACATGTGTATATAGTAGGAGTGAACTATAT +AGCCCGGCAGAGGCCATATATCTGACTGTTGGTCTCACAGGAGACATCTTCCTTGTCATC +ACTCATATACATATATCTTGCTAACATAGAGTTGTTATAGTCGCTACGCCACCCATACTA +GTTACTGGGTGGTTGTTTTTTATGTTCGTATTTACGTTCGTATGATTTTTATTATATCCT +ATAAATAATATTGTATTAAATGTAAGGTGAAAGGGGTATAATAATGTATGAATATGAATC +AAAATATCCAAATCCTAATGATTTTCAATGTCCTCCAAAAGAAGCAAATTTCGCTGAAGG +TATAACATTTTATAAATGTAGCGACACATATGAATTGCCAAGCCAGTACATGGAACCTAT +GATAGAAAAAGGTTCAAGATTTCCTAAAAACAATGAAGAAAGATGTTTAATGTGTGGTCA +TTCTGTCTTTGTGGATGATAAGGATATATTTGAATTGATTAACAAAAAAGGTAGAATAGC +AAAAGGAATAAAAGATAAATGGAGATTTGTCTTTTATTTTGAAGGAAGCCAATTTAGTAA +ATATAAATTTACACCTTCAAAAAGTAATAAAAAGCACTATACATATTGGCATTATGGGAG +TAACGATATAATATATAGCTATAAGAGTGCTATAAACGAATGAAAGGAGTGGTGATATGA +CAATAGTATTCTCAAAATTAATTGACGTATTTGATGAATTCATGTATCCCACTTTCTTTT +CATACGAAGCAAGAGTGGGTGAGAAAACTAAAATATTTATAACTTTATTCGCATATTATG +ATGAAAATAGTAGGAAAGACTATTTTTTTAATGTGCCAGTAAATAAAAAGAAATATGAAC +AACTTATAAATGGTGAAATTGAAATTAGGTCTTTGTTTGTAAACAATAAAGATGGTTTTT +TTACAGAAGGTTCACCTGAAAGTGTAGCAATTATAGAACCTATACATTTAAACGTTAACA +CTGTCGATTATTTACCAGAAAAAAATTTATTCATGGTATATGATGATGATGAATTTTTGA +TTGTCGATATAGAAGAAATGAATTCCGAGTTAGATAATAGTGAAACTGTAGAGAAATTAT +TTGACTTAAACATTGGTAAACAAATAAATTCATCAGAATATAATAATAAAGAAGGTTTAA +TGATTGCTTTTAGTAATGATAATCAAATTATAAAAGCAGATTCGTTAGGAGTATTGATAA +CCAAGACGAGTGAATTGTTTAATAAAATAAGTAATAATTTATTAAATTTAAATGTAGTTA +AACCTTTTGAAAGTAGTTTTGGTATTTCTTTGGAATTTGATTCATTAAATTTAGACATTA +ATGATAACGAAATATATATCAATAAGTTTTTAAACCTTCTAAACTTTGTTTCTAATGATA +AAAAAGAAGATTTTTTCAATGAATTTTTAGGGTTGTACTCTATCAAAGAAAAAGATGAGT +TCTTAAATATTCTTAATGAATTAAGTTCTAATGACATAGAAATGAAAAGTATGTATTATA +ACAATATAAATGGAATTTATAAAGGCAGTATATTGAAACCATCAGAAGCCAAAAAATTTA +TAAATAGAGTTTATAATACAACAGAAACAAAAGAAACTTTAAATATCAATAATGCAACTA +TATATAAAATAGATGTAAAAAATAACTCATTTGGAGTTATAATCGATAATGATATTTATA +CTGGAAAATTAGGAGAAAGTTTACAAGACAAAGAAGAAACACAATTTACTGTTCCTTCAG +AAAAAAATGTTGTTTTAACACAGATATTTAAAAAAGACGAATTTACTAAAAAAGAAAGAA +AGCATTACATATTAGAATCTATAAACTAATTCACACCCACCACACCCTAACCGGTGTGGT +TATTTTTATTCTCACACAACCAAAAAACCACACCACCTATTAATTTAGGAGTGTGGTTAA +TTTTTATATGTGAAGCTAAAATAACTACAAATGATACCATTTTTGATACCACTTTGTTGT +AAAACAGAAAAAAATAAGGAAAACAAAAAAGACAAAAAACGCATTAAATCAACGTTTATT +GTCTCATGAAATTTAAATGTATGTTGATTTGTCAATTTAAGTGCAACAGTTCATCACATA +AAACTTCATAAGGAAACTTCCAATTTAAACACTTTCTTGGTCGATAATTAATTGAGTCTA +ATGCATAGTTAAGTTGCTCTTGATTTACTTTAGCTAAGTCTGTTTTCTTAGGGAAAAATT +CTCTTAGTAAACCATTGGTATTTTCATTTGTACCTCTTTGCCATGCGGAATATGGATCAG +CGAAGTAGACATTAATATTAAATTGGTTTTCAATATTTTGATAACAAGAGAACTCTTTCC +CTCTATCGACAGTAATAGTTTTAACGGCACCTTTAGGTAGATGTTTGATAAGGTTATTAA +TTGCCGTCTCCATAGAATTAGAGGAACGATCAGGCATAAGTACACAATAATAATAACGTG +ATTTTCTTTCTGCGAAAGTAGCAATGCACCCTTTACTTTTGCCTCTGCTGGATACAATTG +TGTCAGCTTCCCAATGACCGAATGTATTACGTTTCTTTATTTCCTTAGGACGTTGTGAAA +TAGGACGGCCAATATTAAACTTACCTCTAGTTTCTTTAGGTTTCTGTCTTTTTCCTTTTT +GACGAAGGCATGAAATAAGTTCGAAATTAATCATATTAGAGTTAATCCATCGATAGATGG +TTTTAAAACAGATTTGGTTTTGTAATAGACGACCTACGATTTGTTCAGGAGACCAGTGGC +ATTTTAAATAATATTTAATGATATTACCAAGTTCTGGAGTAAATCGAGTAGGACGACCAC +AAAGTTTTCTTTTGGTTTCATAATTTTTTTGAGCTGTTTCAGCTTGATATGACTGATTTA +AATTATTCCTACTAATTTCACGTGAGATAGTAGATACAGATCGTTTTAATTTACGTGCAA +TAGATCTTAAAGAATAATTTTCTTGACGTAAAACCTCTATACGTGCGCGTTCAGTTAGTG +TAAGATGGTTATAGCTCATGTTGGCACTCCTTGTATGTGTTTTTTTGGTTATTAACATCT +TACAACAAAGTGCCAATTATGGGCATTTTTTATGAATTTTTATAGGTGTTGCACTTAATA +TTACAATCCGTCGTATATAAATTTCACTTCCCATGG diff --git a/example/fna/NC_005091.alt1.fna b/example/fna/NC_005091.alt1.fna new file mode 100644 index 0000000..bd70bb3 --- /dev/null +++ b/example/fna/NC_005091.alt1.fna @@ -0,0 +1,959 @@ +>NC_005091.alt1 length=57455 tani=97.161 alt=sn;inv;tl +GTTCTGCCCCCTCCCGCCATTCGCGCCTCGCCGGATGGGACCCCAACGGCCGCCCCGAGC +GATCCTCATCGGGCCTGCGTGCCAGCCAGTGGCACGGAGGCACGATCAAACGAATTGTCT +AGAGACGCGGCGAGACCACCACGCAGCAGCCCGCCGCGTAGCCTGTATGACCGTGATACA +GGTATGCCGTCATGCGTGCGCACGGCCGGCCAATGCGGCACTGTACGAGCGACACGGACA +TACGGCCATGCGTTGCGGGCACGCCACACGCGGCAGGCCGTGACACGGGCAATCGGGGAT +TCGGACCTAGCTGTGAGACGCGCTGCGCCGTACGGCTGATGACATGCGGCCTAGCTGGAT +CGTGTGTATTCGGACCCATGACCACGAGTCGCGCGCTATGCGATTGGGACATTTAGCGCG +CCCGCCAAGCCCCAATCCTGCCCCGCCTCAAACCGTCGCACGCACAAGCGTAGCGGAAAT +CCCGCCCAGCTAGACCCGGCCGTTGCGTACCTGGGCTAAAATCGGACATTCTGACGTGCG +GTGCTGCGGGCGCGCTGCTGGGCACCGTGTGCGGGCGAGGCGATGGGCGTCAAAAAGCCC +GACACGATGGCCGGGCGAAGGGGGCTACTGGATGGTGTGGGCTAACCGTCCCGTGTGTGA +CGCCGGCGTTTTAGGGCGAGTTGATACCAGTACCCACCGATGCGGATGACGTGCGGGTTC +TCCCCCGTCAGCACGCGATGGGCTGCTTTGGCAATCCACCAATTTGGGTCGTGCAGCCAC +ACGAGGCGCAGTTCGTCGGGCGTGCGCCGTACGTCGAACGCGTCGATAGCGCTCGTGCCG +TCCGCATCATCGGGGTCGTCAACCGCTACCACGATTTGCACCATCGTGCCAGGGCTCGCG +CTGAACACGCGCGGCACTCTTAGCAATCTCGATCCGGGCATGACTGCATCCTTAGACGTT +GAACGCGTAGCGCACGAGCGCGACGAGCAGGCCAATTGCGAACCCGACGAGCGGCAGACA +GCACGCGCCAGCCACGGAACCGACAATGTAGACGGCCGCGTCGGGGGCGTCTTCGTACCG +CCTGCGCGGTTTGAACCGCAGGATCGCCGGGACGATCAACGCACCGATGACGAGCGATGC +CAATCCGATCGATGCGGCCGTGTGATTCGATATTCCGCCGTCGTCGGGTATCGGGTAGAG +CCGGTCGACGCATTGCGCGTAGCTCTGCATGCGGGGCACGTCGGCCGTGCCTGAGTCGTA +CGAGACAATCACGGCTTGTCATGCAGCACGCTCAGCTCGATCGGCTTCTGCCGATGCGAT +CGCCGCGTTCGTGGCGGCTTGCGCGTTGAGCGCGGCACTTAAGGCAACGGTATCAGTTGG +CATCGTCGTCCCCTGCGGTGCGTGTGCCGATATGCGGGCCGACGTTAGCTCGATTCCGCG +TATAGCGGATGATTGCAACCTGTTCGACGGTCAGGCCGGCACGCGTTGCGCTCGATCCGT +CGACTATCACACAGGCCGTGAGAACGAGTTCGTTGAGCTGAACAAGCGCCGCGCCGTACG +GCAACGATTCGTATTCTTCCAGCTCGCGCAACGAGTCGAACAAACAAGACTCGTCGTTCC +AGACTTGCGCGCCGACTACAGGGGCGCACTGGATCCGGCCGACCTTCATCATCACGCGGC +CGAATTTGGTCGGAATATCGGACGGATGCACCTTGCGCGTGTCGCGACGCCAGATAGAGC +CAATCTGACGTACGGGCAGGTCGATTTTCGCGACCGGCATTGCGGCGATCGTCTCAGCCA +TCGTCGGCTCGAAGTTTTCACGGTCGCTGTATCGTTCGATCTTGACAGCATCGCGCGACG +CTTGGCGGCCCGCGCGTTCGAAAGCAAGACGGGAAAATCGACCCTCGTGAATGGCGATAT +CACCTGCCGGGTGATCGGCCGCGCCGTTCGCACGGCGCGAGCAGCTCTTCGTGATTGTGT +ACTTCGCCATTGTCTTTCTCCTTCGTGTTGGGTTATGCCAAACGGCCGTAATTGCGTTCG +TGAGATTCGACGTAATCGCCAACCGTCGTAAGGCGGATGTTGCCAGCGGGGTAGTAGCAC +ATCCGGAGCGGTACAAGCATGGCGACGCTCAATCGCCTCATCGAGGGTCACGGCGTCGAA +TATCTGCGGCACGAGCGGAACGACGAACCGGCCGCCGCGTACGTCAACACAGGCGACGTC +TATAACGCGACGCTGTTAGCCGTGCGCACGACGGCCACACGCTTGATATCGAGCCGCAGT +TCGCGGGCCAGCCTGGAATCGCTCGGCGGGCGTTGCACTGGTGCATTGTTGGTCGTCATG +GTTACCTCCCTTCGTACATAATCCGGGCAATGCGAAATGCAATCGCCCATGCTTCGCGCG +GGCTATAGCCACACGCTCGATGAATGTAAGACCTGTCGTTTGCCGCGTCAGCGACCGCGA +GCGCGGTGGGCACGGGCAAATCGGCAAGCGATCGATAGTCGTGCATGGTGGTGGTAAGGC +TGGCATTAATCGACCAATCTACGCCGTTCAGATAGAACGAACGCCAGCGCGCCGCTTCGA +TCAACGCCTCGTGGAAACGGTAAACCGGCATAACTGCACCGTGCCGGCCAGCAACATACA +TCGTTGCTTCCCACAGTGCCGCGCGGCGATTGACGGCCGTTCCATCAATGAAAAACGCCC +ACGGGCGAGACGGCGACGATTTAGGGTCGTACATGAGTCGAGCCGTACCGCCCCAGCTAC +GAAAGGTTTGTTGATCGCGCCCCATGGTTAGGCCCCCTTCCGAACAGGCGCGTAGAAAGC +CGGCGTTACGCGCTTGATACCGTACAGTGCGCGGAACGCTTTGCGCGGGCTCGTGATTTG +CGCCCGGTCTTCGCGCAGATACATCGCGAGTTCGTCTACGGCAGCTTGAATCGCGACTGC +ACGCGCAGCGTCGACAGCCCCGGTCGTCGCTTCCGCCCACTTGGCGATGCCGCGCGGATC +GCATGCACGGGCCAGTTCTATCGGATCGCGAGCCGTAGAACCGCCCCCGCGCAGTATCTG +ATACGCGGCCATGCGCAGTGTGTCGTATGACGCGATGATCGCTCGCCCGAATGGCCGCGA +ACTGGAAAGCCGCTTCATTCGGCATATCATGCCGAATCGCGCCCGTGCCGCGCTTCTGCG +CGCCCGTCACGCGACGCACGCGCTCGTATCGTAACGCGGCTTTTCCGTCATCGGAACAGA +AACCATCATCGTGCCATGCTTCAGCACTTCGCGCGACTCGCGCAGCATCGCATCCGCGAT +CTTCCCGGCGTCCGGGCGTGCGGCTTGCGCGCGAGTGTGTACGGCCACGGCGACGATGAT +TTGCTCACCATTCAGGATCCCGAGCGCATCGGCAAACGACGGCTCGTCGTAACCCATCAG +GCGCGGCACGAAGGAAAACACCAACACGCCGTGACGCCAGTAGCCGAGTGCGCTACGGCC +TCCGATATGCGTCCGGTAGTTCGCGATGGTCGGCGCCACGGCGTCGCATTTCGGGGCGAG +CGTGACTTCATCAATCGCGAGATACGCGCCGCGAGCTTCGAGATATTCCGCCGCATTGGC +GCGGCCGTATGCCGCGAAAAGGCGGCAGTCGCCGGCGCGGGGCGCGTTGCGGACGATGTA +ATCGAACGACCAGCGGCCATTTACCACCGGGGGCGTCCCGATGACTCCCAAATGGCCGAC +ACGTACCCGGTAGTGCGGGGGGGCTTTGACGGCGGCTTGAACATTTGCCAGGGTGATTAT +GGCAAGCCCCTTAGTGTGCGTTGCGGATCGATTCGACAGCGGCCAGTCCTGCGTCGCATG +CGACGATGAGCCGACGAGCGAGCAGGACGGAATCGAGATGACGACAAGCGCGGATGTTCG +CGAGACGGCGGCGGAAGGAAAACAGAAAAGCAAGCATGGTTAGCTCCAGTGGAATCAGGG +CGCGCCGGGCGGCGACCCCATGCATGAGACTCTAGGCAATAAAGTTAGACCTTGCCAAGC +TGTTCTGGGCTGTTCTCATGCTTCGTCCGGCTGTTCGTTACCGCGTGCGTCGCGCCGATC +CCGTGTGCGCCATTCCTTCATCACATTCACGACACCGAATTCTAGGAATCCCATAAGCCG +AGAGCCGCTCAAGCGATCCCCGAACCGAGGATGAGGTACAACACGACCCGACGGGCGCGC +ACGCCGGCCAGTGCGACGGCTTTGCGCTGGGAAAGGCGCGGATGTTGAACGGCAACGCGG +TTTTTTATGACGGGGGTTCCAATCATCAGGATCAGGGACGCGGCGGCGATCAGGCCTCAC +GCGGCAGCAGCATCAAGCCATTCATTCGCCATCGTTCGGCGCTCCGACGATTTGTTTGTA +GCCGGCCGCGATCTGGTACAACCAGCCACGGTGAAACTCGCAATCGACGTGCCACATGCG +CCAGTCGCGGCGAACGAACGCGAGCAGCCGTTCGCCATGCTCGCCGCGATCAGCGAACCC +CGCACCATGACCGGCCCACGTCAGATAGATGCCTTGACCCAGCGCGGCAGCCGGATCAAA +TCCGCAATCAGGATGCGCCCCGTGACCGTTGGTCGCGAGCATTGCGGCGACCGTTTGCGG +ATAGCGCTCAGCGAACGCATAGACGAACCGGCGCGTTGTCTCGCGTGATCCCGCTGTAGC +GCGCGGGCGCGAGCCTTCCGGTGCATCCGCCCAAAGTGCGGGGGTGAGGAAATGGCGGGC +GGCGGTTTGGATTTGTTCGGGTGTCATGGTGATACCTCCGTAAATGGCGGAAAGGCGAAC +TAGTTCAATTGAAAGGCTTGGGTTCATTCGGCGTGTTTCTGCAACGCTCGGCTACGAGCG +GGTCCATTGTGGTCGCCGCCTGAGCAGCAAAAATCTCGTTAATGTAAATGCAGTCGTAGG +TGATCTCGCTGGCCGTGCATTCGCCCTTAGACCATCCCGCCTTGCGCTGGCAATGGTGCG +ACGAGGTAGAAGGCGCGTGCATCAACCATACTGGATGGTTCGCCGATGAACACGGCGATG +GCGACACGATACGCGGTGTCGTCTTCCGCTTGCCGCACGGGCGCGGCTTTCTCCCCGGCG +CGACGTCCGATTCCAAATAGAACCCCTTGCCCGTGCTGTTGGATTTCGGCGCATGGTAAT +ACTCGCCGCACGGGTACACGTTGCGCTCGGCAATGCTGGCAAACCGTTTCGGCATGCGTG +CGATGTAGCGCGGGAAATGGAAGCCGACAAACGTGAATTCCGGCGTGAGATGCGAGAGAC +GATTCATGGTTATATCTCCGTGGGTATCGGAAAGGTAAAACGGATTCAGTTCGAAAGCGT +ACCGCCGTTCGCGCACTTGATCTCGTAATCGAACGGGAATTTGCTGACAACGTCGAGCAG +CAAGGAAACCGCTTCGTCGGACAGCGGATTGCGCCAGTCGAAACAATGCCTGCCCGTGTG +AGCGTAGAAAATCCAGTCATCAATCAGGTTCGGCACATGCGCCATGATCCAGCTGCCGGC +GTCTCGCTTTTCCAGCGCGACGGCGCACGTTTTCACGTATTTCGCTTCGATCCGGTCTTT +CTCTTTCTCGATTCGCGCCTTGTCGCGTTCGGTCGCGCCGTGCAATTGCGCTTGCACATA +GCGCGGCATCAATGCCTCGCGTTCCGCCTTGCTCAGTGTCGGGCGCTTCGCTTTAGACGA +CACGGGCAAAAGGCGAGTGTGATACAAATCGTCCGGCTACAAATACTGCGATCCGTAGCA +CGACGGGCAAAACGCGTTGCCGATCGCGCGGTCTTCCTGATGGCCACAGTAGCCGCACTT +AACCGCATGGTCGAGCACTTCGCGCATGTCGTCCGTCACGAGAGACCAATAACCCTCTTT +GATCCGCTTGTTCGGATACTCGTACTCCGACCGAGGGAACAGACGGTTTCCGCGCAGGGT +TTCGCCGCCTTCCGTGTCGGCCATGTTCCATTGGTCGGAGAAAAGATGAGTCGTATCAAA +AACAATCGTCTGACCGTGGCCCGCTTTCATGTCGCCCATGAATGACTGTTGCTGCGCTTT +CGTGCGGTCGTACTGAAGACCGACCGACACGGACCATTTGCTTTCGCCGCGCGATTCCAG +CATGGCGCACATGTCCGCGTAGGCTTGCGCCTCTTCAGGCTTCTCAATGTTGAAGTAGTA +GTGATTCAGAGTGGAAGCCAGGCGCTTCATTGTGCAATCTCCGGTGAAGGAAGGGGCCGG +ACCAAAGCGGCACGGCATGACTGAGATTCTAGGCGACAAAGTTAAACCTTGCCTAGCCGC +TTTCCGCGTTTTCTTTCGACCGGAAGTAACTTCCGACCCGTCCGGGCGGCGCCATCAGTC +CAAAATCCCCGCAAATCCTTGCCTCGTAAGGCTCTTAGGCCCCGCGCGGCCGGTCGTCTA +GGGGTAAACCCTATGATGCGCCGCAGCAACGCGCTCGCCAAGCGCCGCGCGGCTGTCCCG +TTTTCTGCGCCCCTCGTCCGGCCGGGCGGCCCGCCGGTATCCCGTGCTGACGACCCCTCG +TGCTTACTTTGGGGGCCTCGCCCGTTCCCAATTCTTCTAGACCAATCTAGAAACGACCCA +CCGCATCGGCCTTTTGCTTACTTCGGGAACCGAGCCGGACCCCCACGCACGGGCCGCGTC +GAACGACCCGACCGGGGGTAACTTCACAACCCTAGCCGGACCCCCGGTCGCCGCCGCTGA +CAAAGTTGATCCCATCCCCGACAATCCGTGCATCGAACCGATCAACATTTTCACGGAGGA +TCACCATGGACACCGCCGAAACTGTCAACAACCAGATCGACAGCTTTGCCGCCCGCGTGC +TCGCGCTCGAAGTGGGCGAGACCGAATCGAAGACGTGCCGACTGGATGGCAACGAGGCGA +CCAAGGAACTCATGGTGGCCACGCTCACGAAGCTTCGCAATAGCGTCGCGGCCGCCGTCA +GCCGGGCGTCCTCGAAAACCGGACACGTCTTCGTCACCGAGACCGGGGACATTCGTACGA +AGAGCTACGACTTCCTGATGACGGTCGCCGTCACGTGGAAGGCCTGATGAACGCCGTCGA +ATTCAGCGCGGTCCTCGCGCTCGTGCAGGCGGCGAACGGCGAAGTGATGCGGCAAGCCGG +GATGATGACGTGCAACGTGTCCCGTGCGAAAATGGAAGAGTGGCATCAGTCGCGCACGAT +CGAAACCGCGTACGACCTGAGCAGCGGATGGACCGTGACGCTGACGGCCCGCGCCCCAGA +AAGCGAAAACGGAGGACCCAAACGTGAAGACGACTGATTGCAACTGCGGCTGCGCCGACT +GCTCGGGCAAGTACGCGACGAAGAGCGGCGCCGCCGGTCACCAACTGGCGCACGAGCTGC +ACGGCCTGACCATCGATCCCGGTCGCTCGATGGCGCAGCCATGTCGAGCGTCTTGCGCAG +CAAACGGCTCACCGGGTCTTGTTTCATCTGCGCCGCCTGCGCACGCAGTTGGTCGGCCTG +TTTTGCCGAAGTAATCCTGCGCGCCGGCCGACCTCCCGCCCGCGCTGGAATCCGGACCTT +CCTGAGCAAGATGCCGTTCGGCGCGTCCTACTTCGTCGCGGGCGACACCATGGAGAGCTA +CAACGGGAAGACTTTCCGCGAGGCTAGCGTCGACCTCGGGCTGCCGATTCGCAGTGTGGT +GCATCACAAGCATCCGACCCACGGCATGTCCGGCATCGAGATCATCCGCCTGACGGTCGG +GAAGTCCGAGCGGCGCATCTTCTGAATCCCCACGACGCCGGCCGAATAATCGGACTCCCG +CTGTAACTCCGGGCGGCCAAGCGGCTCGGATGACCTACCCCGCTACTACCCCCGCGAGAT +TTCCTGCCGTCCCGCCAGAAGCCCCATACGCCAGCCGCAGACATATATCCTTGTCTGGCA +AGGCTCATCGCCCGGCTCCCCCATACGAAGTAACCTCCGATTTCCTGTTATTTTTGTTGC +ACCGTTCAAAGGAATGTTCTACATTTATCGGAGGCCGTGCCGGTCAATCGCATCCCGTAG +GATGGTGACGTTCTTCTCCTGTGTAAATTTGACTGTCATTGTTGTTTCGTTCAAAGGGTT +GATGGGTTTGCGCCAAGGCGCAAGTGGGCCACATCACCCCGGATCAGGGAATGTTCAAGT +TTGGGGAACCCAACAACCCGACCGTCTACTACTTCCCGAAGCGCAACCGCTACAAGATCG +CCGGGCAGCTGAACGACGTGCACATGAATGCGGCTCACTTCGCGTGCTGGTATATCGGCG +AGCATCTCGGTCGGTTGGTCGCGGGCAACGCGATGGCGTGGCTGCACCGCGCAGCCAGCG +ACGGCAATTGCCGATCGTGCAGAGAAGATAAGTGCACGGCCGGCCCGTTCTGCGTCGCAT +TCGAGCATCACCGCGAACGCCCTCTTTCCAGCGTCACCGTAGAAGCCCTTCGTGAAGAGA +AACGCTAATTGCAAAACGACGACCAAGGAGCAGCGCCATGTTCAAGCAACTGATTGCCCG +GATGAAAAGCGACAAGAAACGCGAAAAGGTCGCTGAGTATTCCCAAGAGCTGAAGGACCG +GCAGCACGAACTCGACCGGCAAGAAGACAACATTGCGGCCGAGCGGCTGTATATCGAACG +CCAGCTTCCGCGACTCGCCGCCCGACTGGCTGAGATGGAATGGAGCGGCGAAGACGCTGT +TCAACGTTCGGCCATGGTAGGCATCTGCAACGTCATCATGGCCGGCCACCAACCGGACAA +GCCGATCATCCGGCAACCCGGCGTCGGCAAGAGGACCACGGCATGAGAAATTACTTCGTA +CCGAAGCTGCGCGTCAAGAAGCCATCGAACGGGGAAGTACGCGTAACGGTCGATGTGAAG +ATGCTCGAAGCGGGCGGCCATGAAATCCTCTGGAATTGCGCGGTCATGCAGCGCATGCGC +GAGTCGGGCGTTCCTATCATAGGGCTGATTTCCATTCAAGGCGCGCGCCACGGCTGCCTC +GTTCAGACCTACGACGAGTGCTTCATGGAGCACGTCTACGAATGGACGCCCGGCCCGGAT +TCGCCGAAATAAGTTGACCCGGCAGCCGGTTTCTGACCAACACAATATGGGAGTAACCAT +GAGCAAGATCGAGAAGGGCAGTGTCACGGTCAGTTTCAAGACCGACAGCGGCTACGATTC +GATATTTGGCGCGCAGAACAAGCCGGGGATCGACGCACTGAAAGATGGCCTGCACGAGAT +CGTCCGCGTGCTGACCATCAACGGCAATGTCGCTACCGTCGACGCCGTCGTGAAGGCGGC +CAAGCGGCGGGGAGAGCGCGCGGTTCTCATGCACGCGACGGCGTAGGTCGAGCAGCAATC +GGCGGTCGATCAGCGCGTAGGCGACAAACCGCCGTCCGATGACCTACTAAAGGCGCTCAA +CGCAGGCACGCGGCCGGGAATCCTGAACGTCTACCGCCATATCCTCCGCCAGCATTCGAC +CGCAACCGGTACGTGGTGTATCCGTCTCGCGAAAGAGATGTGGGGCCATCTGCCGCTCAT +CGCGCTGAACGCGGAGAATCGACCGGGCATCGCGGAAATCTACGTGGACCTGCGCCGCGC +GAATCCGCAGTGGTCGATGTCCGGGCTACTGCGTGAGGTCGAGCTCCAGTGGAAGGAATC +GCTGGAATCGGAGACGGAACTATTAAGACCTTTCAACTGAAGGCCGGTCTCGTGCGCTGC +GCTGCCGCGTGGGTGTACGGTGGCGATCCTGCGGCCAGGAAATACCCGGCGCTCAATCGC +ATCCGCATCGAACCACACCATTCCGGCGCGATCATCATTGCGACCTGCTCGCACGCCATG +TTCGTCGCGTACGACCCGGAAGCCGTCGTGCCGGAACCCGCGCTGATCTCCGTCCCGCAG +GACCTGCTCGACGCGGGCGCGCTGCTCAGCGTCAATACGACGGAACGCGAGATTCGCTTC +GGGGATGACGGAGTTGCCGTCTATGCGCGCGGCAAGCTGAAGCATAAGTCCGGGCTCGCG +ATCGCCACGCATCTCCTGCCTGGCGCGAAGGCGCATTACGCTAACTGGCGTGCAGCCATC +CCGGCGAAGATGGATATCCTGAAGGCGAACCCGGCCATCCCGACCATGATGAACATGGTC +TTCCCCGGCCGGCTGGGCGGGATGCCGGAAGGCTGGGGCGAATATCGGCAGGTGTTCTTC +GCGACGTGCGGCAAGCGGTCGATCACGCCGGGTGACGGGCAGCGCACCGACTACCGGAAC +TTCTTCGCGTTCTTCCCGTGGAAGCGCGACGTGTTCCCCCTGTTCGCGCCGATGGGCGGC +ATGCCGAGCGCCAAGGATTTCGGATACCTCCTTCGTGGAAAAGTGAAACCGATTATCGTG +ACAACGTTAAGCCTTGTCAACGATAATCGGTCGGAAGTTACTTCAGAGGCCGGCCGCCGG +ATCGTCCGGCTTGTCTTCGAGCCATTCGGGTTCGAAATGAACGGACCGAAAAACGATGGC +GTCGACCAGCGCGCCTACGCATATGTGCCGGCTTCCGTGCTGCTCGAAATGAAGCAGTAC +ATGGACAAAGTGTCGAAGCTCTCGAAGGTCCCGGCATCGGCTATCGGCCCGAAGGAGCGC +GTCAAAGGGTTACTTGCCGAAGCGAAGGAGCACGTCGCGACGGTCGACCTCATCGAATAC +GAAGTAGGGCAACTGGTCGGGAAGTATTTCGAGAAGATCAATTTCGAACTTATCGGCGAT +GTCGTCGTGAAGAAGACCGGGGAGTTCAAGGGCGACCTCGGCCCGTTCCAAGACGAACCT +TGCCGCATGATGCGACATATCGCGTTGAGGGTCCTCGGCGAGAAGATCGAACGCGACGAT +GCGGCCGCAGTGTCGAAGCTAGAACGGCTGTACACGCACATCGACGCTGTCGCGGCCATG +CTGGAGAACGACGAATATGGTGAGCCGCAGGGGACTGGCGACGAGAAGTTCGACGCACTG +GTCGAACAGATTGCCCGTCTGCACAGCGATCTCAACGAGTCCGCGCAACTGATGGTGCCG +GTAAGCGCGTCCGACGAAGCGGAACTAGCGAGGATCACTGAGCAACTCGACGAAGCGTGC +GACGACATCGAGAAGGGACGCGGCCTGACGCCCGACGTGGAAGACGCCAAGCCCGTACAT +CGGTTCAAGCAGATGTACGCGAAACGGTTCATCCAGTGGCAAGGAGCCACGACGCATCGC +GACGACGCCGAAGGTCGCCTGAATGCCATCAAGACGGTCGTGCGACAGATGCGGAGGGAT +GTCAACGGTGCTTCCCGTAGCCGAACGCCTTGCTCATCATCACAGCGTGCGCCAAGCCAC +GAATCTCGTTCAGGAGATTGTCATCGTAGACTACGCCCGTTGCGAGCGCACCGTCTCGGA +GCGCGGCACCAGATCGGCGTGTTTCACAATCACGTTTTGCCGCGCGTGCGTAACCCGAAC +TACGTGGGCGACCCCGAACTGATCGACCAAATTCTCGAGGGCATCGCATTGGTTGGCTCC +GGTTCTGCGGATGCGGTCGATACGGCTCCGACTATCGGGGAAGACCCGTTGTCGCAGGTG +CCGCTCAACGTGTTCCAGATCAAAGCGCGTGTTGCGGCTGTCGCTGACAGCTTCGAAAAT +CACAGTGCACGTCTGCACGACGATTTTGGGACGAAGTGGCGGCTCATCGAAGTAAAAGAA +GCGCTCGGGCTGCCGTTCGCGAGAGATATCGCCCAGGTCATCGGCGAAGCTGACGACTTG +GCTTCCGTTCCGCACGATCGTGTACGGGCCGTTAGCGTGGTGTGCGAATATGTCCTTGCG +GCCGTCCGGGGGTTTGATGACAATGCGCTGGGCACTGCACGCACGTACGATGAAAGCGCC +GGGACTGTTACAACGCTAGAACCGGACGAATTGCAGGGCGACGCGTTGCCTCTCTATAGC +CCGCAGAGCCAGAACGCGATTCGCGTGCTGACGAAGCAGCTCCGAAAAAGGAATAGGCTT +CTCGGCAACTTCGTAGGCATCCATCCGGTCGTCGAAGAGCTTCAGGACGCGGTGCAAGAC +ATCCTGTTGGAACATAAGTCGAGGGGCCCGGACGTACTGCAAAACGCATGGTTTGCGGAT +GTGCTGAAGTCCAACCTCGCCGCCGGCGGCTCGATCGATGACTTCCACCCGCGCATGATC +GGCTTGCACACCGGCCCTCCGTGCAAAGAACTCGGCGGGAAGCTGCGCGCGATTGTCGAA +GGCACGGTTGCTTCCGGCGTGTCCCTTTTCGAAGGCATGCCGCTCGTGTCGCTCTGAAAT +CAGTTGAAGTGGGTCGGCGAACTATTCAAGCAGGGTGCATTCGACAACGCTATCGACCGT +GCTGACCCGGTCGAACTGGCAGACGGCGACATCGACCTGATGGTCGTCTCGTTCGGCTCG +CTTCGTTCGCAAGGTGTCTCGCTGTTCCCGATCCTGCACGCCGTGACTGATGCGAACGTG +CGCAAGATGGTCAACGGCAAACTGCTGCTCGACAACAACGGGAAAATCGTCAAGCCCGAT +GGCTGGAAACCGGCCGACCTGCTGCCGTGCCTGCACAAGACTATACAACAGGCCGAACTG +CACATGGGTCCGTCCGACGAAGCCGGGAGCATCTGACATGAGAGTGAACGTCTATAGTCA +CGAACTCACGTCGGAAGTAAACCCGGTGTACAAGGAGTCGGATACCGGCGTAATTTACAG +CGCGGTGCAGTTTGTTTTGCATTCGAGCGACGGACTCCATCGTCCCGACCCGGATGGGGA +CGCCGATCGGAGCGCCGTAACTTTTTGGCTACCGAAATCGAGAGATCGGCGCGAGGCATT +CGCGCTTGCTCTCGAAGCGGCCGCCACGATGGTGAGAAACTCCCCACCTGAATCCGGCTT +GGACTCTTAATCGTTTCGCCGCCCTTCGGGGCGGCTTTCCTTCGAGAACACCATGTACAC +GAACAATCGCGACACCCACGAACTCGCCAACGAGATCGAAACGGAGATCAAACTCAACGT +CAAGCTCGACAACTGCTGGCCCGGCACGCCGCACTTCATCCTCTGCCACAGCCGTCAGGT +CGGCTGGGAGATGGCCGTGCGGATGTCCAAGGTCCTGTCGTTGCCCGGCGGCGGGCCCGT +CTCCCTCCCGCACGTCAGCACGATCCCGCATGCCATTCAGCTCCTGAAAGGGCTGACGAC +TCATCACGTGGTCGTGTTCGAGCCGGCCGTCGTCTTCCTTTTTCCCGGCTGGGCGTGCCC +GCTCGACCTGCCTACCAAGCTGCATGCCACCTTCCCGATGCACGACGAAGAAACCGCGCA +GTTCATGGGCCGCTTCAACCGCTTGAACCTCCGCACCGGAAACATCGGCGATAACCTCAG +TGTTGGGAAAATCGTACGTTTCACCGATATCGCCTGTTGATAAGGTTATTCATTGCCGTG +ACAATCCGTCGTATCAAACCACGGGGAAAGAAAAATGACGAACAAGAATTGCGACTGCCG +ATCCGCCGACGAAGGGAGTCTCATGCAGCGCCGAAAGTGGAACTGGCCGGATTACGAAGA +CAGCATCGCGCAGCTCCGCGCGTCGTTTTGGGCCGGAGCTGTCGCTGGTAGCTCCCCGGA +CACGAAGTTACTTCAGGGCAATGAGTACGTGATCCCGAATCCCGAGCGGATCGCCACGTC +ACTGCACGCGCAAAACGTCGGCAAGACATCGGTCGTGGATTCTCTGTTCGCGCTCGGCGC +GGCGGCAACGGTCAAGCGGGCAAAGCCGTATGTGCTGGCGGACGGGTTCATTACCCGATC +ACCGTTATCGCCGCTCCAGCTACTGACGCGATTCGGCTACGCGGAATACTGCATTGACGA +TTTCGCGCGCGGGAAGCTGTCTCGGATTCTCTTCGACTCGTGGAAGCGCCAAGCATTCGA +TCGCGTCCTGCGCCGCAACGCGCGTCAATCTAAGACGCTCACCTGTCTGTCATGCGGCCG +TACCGGGCTCGGGGTTGGCTGCCCCTGCGGGGCGTGACATGGGCGCGCGAATGCGCACCT +TCCCCTGCCCTTTCTGCACGCTGAAATTGACGACCTGATGGCCGGTATATTGCGAGCCGT +CACGGAAGAAGTACGGGCCACGGTGCAAGGAGTGTAACGGCCGCCCCGGATCACATCACT +GGCCGCACGGCCGATGCGGTGCGTGCAAGGGAACCGGAATCAACGCGTCGTACTCGTGGG +TGTCGGTCAATTCGGCCGAACGCCTGAACGAATTGAACGCCTCGAAGCACCGCAAACACA +TGGCGCTGTCCGCGCTCGCGTTGCTGATGGTTAAACGCGATTTCCGTCAGTTCCTGCCGA +AGCGCGACCGGTTGCTTACGGACATGCAGACGTTCGCGCCGAAGTCGGAGAATCTGCAAT +GGCTGCTCGCCAAGGTCAACCAAGGAACTATTCTCACCCCCACCGAGATCAGGCAGGCCC +TGGCGCTCGTCAATACCGTTAGGAGTCAATTCTATGTCGCCGCAAGCTGCGCTCGCTAAG +GAGATCGCTGGGATGATCCGGCGCAATGTCAACCATACGGACCCCAGCATGCTCGTCCGC +AACGTGATACCGCTCGACCGAAACGAGGCATTGATGCTCGTCGGGATACTCGAAGCGGTT +GCATCGGCGGAATCGTTCACCGAGCAGAAGGTATATGAGGCCCTGAATCCTGACAGCGAT +CCAGCCAAGCCTATTCGCGATTTCCTCAGCGTCTACGCAGCACGGCTCGAAGGGGTCCGC +GGCGTGCGCATGAGGAACGATGAAACCGCCTTCGACTACAGGACTCGCTCGGACTCCGAC +GGACGCTTGATATTGACCAACGGTCAGGTGCGTGCATTCATCGATTCCTTTGACCGTCAA +TCCGGGAGACGGCAATGAAGACGATCTACATCGGATGTGCGGCGTCTATGTACGAGGGCG +GCGCGGAGGTTCGGGCGTTCGAGGACGACGGAGACGCCAGAAAGTTCGCGTCCGACTGTC +GCGCCGCTTCGGCTCGTCGCCCGCAAGCCCCCGCGCTAGGAGCCAGTCAAGTGAAGTGGG +CGGCCTATTACAGGGCAGAAGCCAAGTGGGAGAAACAGCACCCGGCCAGCCCGCACCACC +ACCACGAGTATTTCGACGTAATCTGCCTCGATCTGTACCCGAACCAGAAGTAACTTCGTT +TCATTCCTGCAACATCGCGTGACAAAGTTTAACAGGGTTATTACGGCACGAATTGTCTTG +ACAGTGTTTATCTGTCCGATATACTTCTGCATGTAGTAACGCACTCAACAACCGAAAGGT +GGTTGTCATGGCAAAAATCCAAATTCCGGGCGAACTCAAACTCGACGCCCCCGAGGGCAC +CGTGCGCGCTGCGCTGAAGGAAGCAGGCGCGACGGATGGCCAACGCATCCGCATGGTGCC +GCCCGACTCGATCCACATCGTGCCTGGCCGCAATCCGCGCTTTTGAGGCAGCCCGAAATC +GAAGGCCCACATCGAAGACATCGCGAAGTCAATGATCGCTCGCGCGGCGTCCGGGCTGCC +GGCGTTCATGCCCGAGCGAGCGCTCGTCTGCTTCGCTCGCAAGATAGTCGGCGTAGACCG +CCTCCTCCTAAAGGCCGGCCAACACCGCTTGGCTGCGGTCGCCGTCGCCAACAAGAAGCA +GCCCGGCACGGTCGCGGAAGTCCCGGTGTTCATGGACGAAAATCCGATGACCGACCCGCA +GCTGGCGCTCTACTACATCACGGAAAACCGCAGCGAAGAGCTGGGGCCGTACAAGATGGC +TGTCTCCGTCGCACGCGCAGCGGAAGCGGGCGCGACGAAGAAAGAGATCATGGCGGAACT +GAACATCTCCGACCGCTATCTGTACGATCTGGGGCTGCTCTACATCGGCAACCCGCGCGT +CATCGAACTGCTGGCGGAAGTCAAGGTGAGCGGCACGACCGTCATCGAAGAGATCAAGGA +GTACGGTCAGGAGAAGGCCGCCAAGCGACTCCTGAAGGGCATCGAGACGGCCGCCGCTGC +CGGCAATAGGAAGGTAACGCGCCGCCATCTGCCGGCCGAGGACGCCCCGGCCAAGGAAAA +GAAGACCCGCGCCGAGACGAGCAAGACGGATGGCGGCGAGCAGCGAGCGGCCGACATTCC +GGTCTTCAACGCCACGCTCTCCGTGCTCGAAGTCGTCAACGGGTTCCACGAGCAGTTTGG +CGAATCGGACGGTCGTCATACGAAGATCATGTTCGAGATCATCAAGCAGTGCGGCCGCGA +CGAACTTGTGCAGTACGCGGCTGACACCGGCAAGTACGAAGCGACTGGTCTGGTGCGCCT +CAGCTTGGTCGAGCTGCCCGAAGAACCGACTGCCGCTGAACAAGTCCCGGCGATCAAGGC +GCAGGCCGAGAAGACGAAGAGCACGCGATCGCGTAAGTCGAAGAAGACGGAAGAACCCGT +CGAATCGCCGATCGGCACGGCGGAAGGGCTGTAAATCGGAAGTAACTTCAGGGCCGCTTC +GACCGCCTTTTTCACGATTATTCACAGGCGAAATTATGCAATCCAATCTCGTGCTTCTCC +CGGTCATCCACGGCCGGGACATCTCCATTTCGCCGCTCGGTATCTGCGAAGTCGAGATCA +GCGACCAATTCAGCGTGACGGTGACCATGCAGAGCGGCAACAAGTACCTGTACAAGATCG +AGAACATCTAGCGACGACTGGCCTACTACATGGGCCCACCCATCGAACCGTCGCGAGGCT +ACTACAAGCCGATGAAGGCGATGACCACGAAGCAGGCCCATGAGTACCTGAAGTTTCAGG +AACGCCGACGCCTGGCCGGGTACGTCAGGGAGGCCGAGGAAACCCACTACTGGCTTCTGC +GCCGTTACGAGGACTGACATGTAAGTGGCTCCTACATCGGCCGCTACGTGCAGCCCCGTG +ATGAACTCCGGTCGGTCGAACGACAGGTAATGCAGGCCGACCTCGATCCCCTCGCGCACA +CGTTCGTACGGCACGAGCCCGCTTGCGATGACGGCCGACGTGCATGCGACCCAGTGGGCG +AACGAGCACGGCATCGAGATTACGCGCTACTGGCAGTCATATAGCGGGGACCCGTACGAA +GCTGCCAAAGACCGCAACTACTTCATGCTGAAGGAAGCGGACGTGCTGATAGCGGTACTG +GGCGGCGTCGGCAATTGCAGCGGAATCATTCAGATGGCCCGGCAGATGAATATGCCGGTC +TACGTACATGCGAAAGATCATGGCCTGTAGTTGACACAGTTCATCTTTCTCAGGATAATC +ATCTCACCAGCTACGGCGGGATCAAAATGAGTAAGGAGCCGGAAGACGCAGCAGGAATCA +TCACCTTGAGCATCCAAGTCTCTCGCCAGTTGTGCGAAGACACAATGGATGCAGCCGCGC +ACGGAGTTGAGTATTGGGCGCACGCGTTCGAGCATCCGGGCTGCGGCCCAGAGACCCTAA +ATTGTGCGATTGAAGAAGACGAACCGAGCAGTGGCGAGACGCCAAAGAATTTCGTCATCA +GCCCCGAAGCCATCGTGAAGGGGATTCAGGCGGTCATGCACCCGGCATTCTCGGTACGCG +CAGACCTCCCGGCCACGCTGTCCAGTGCACTCGTAGAAGACGACGCCAGCAACATCGACA +TCGAGATCGCCGATATCATTGTGCAGGCTGCGATGTTCGGCGAAATCATCTATGGCTGAC +CGGAAGTTATTTCCGACCAAGGAGAAGAAAAATGGCGAGGAAACCGTTGAAGATCACATT +CGGTGTTGACGCTGCTGCGCTGGCGATGAACGTCGTACGCCGTGCAATCAAGCGGAACAC +CGAAGACCCGTACGAAGCTGCGGCCGAGCACCTGAAAAAGACGCTCGAAGAACGCAAACG +GCCGATACTTCCCGGCGAGCGCGTCGTACAGAAAAGCCCGCTGTTCGAAGCTCCTTACGC +CGTGTGGGAAATCGACCGGGGCGATGCGGTCACGGTGGACACGAAGTTCGATCGACCGTG +GGTCGGCGTCGTGCTGAAGCGCAACCCCGGTGTGCCGAGAATGTATGTCGTCCAGATGGC +GATGTCGCACGCCGAAATCAACGTCCACGAACGTATGATGAGCCTGCGTCGCCGTGCAGC +CGGCGACCCGAATCGCGCGGTGTTTCCGGCGGTGCGGCCCTGCGAAGGGCGACCGGCCGG +CGAAAGGTCGACTGCTCGCCGCTGGCCGCCGGCCGCCTGGCCGTGCGAATGGTTCCCGCC +GGGAAAATCCGACGCCTACGCGACCGTAAGCCAGTTTCGACGGGACTATCCGGAGCCCGT +TAACACGGAGAAGGAGCAAGCAGAACTCGACATCGCGGCTGCCGGCCTCGCGATGTGCCA +CGACCCTTGTTACGTCGTCCAGTACGGCGATCAGACCGTATGCAAAACCTGCGGAACGAC +GTGGGATACGAATGATCAGTTTCCGCCGTCGTGCCCGCACCCGTGACGAGGCGGCCGTGT +CGGCAGCCATCAACGGCGCTACCATTCTGATGCTCAATATCCTTTACCCCCGGAGAAAGT +AAACGCGCATTTCGAACCCGCAGACTCGTCTCTGGCAGGCTCTCGTGTCTCGGCTGGGCC +AGCGACTCATCGACCGGGCCTTCAGCCGTCCAGCGGACCCGGTAACGCTTCCTGACTTGG +CGAACCACATGCACCGTCGCTGGCTCGTGAAATACTCTCGCTGGACCCTCGGCCGCTGCG +CGCGAATTCCCCACATCCTGCGCTCGGATTCGGATCGCGATTTCCACGACCATCGGTGGC +CGTACGTGACGATCATCCTCGATGGCGGCTACACCGAAGTAACCCCCGTCTACACGAAGG +CGAATCTGTACAAGGGCGAGCACCGGCAGTGTTACGGCCCCGGCTCGATCCTCGTCCGGT +CAGCCAAGCACCTGCACCGCCTCGAACTGGCACCCGGCACGACGGTGACCACGTTATTCA +TCGCCGGGCGCTGAGAGCAGGAGTGGGGCTTTATCACGAACCCCACCTTCAAGATGTACT +GGAAGAACTACCTCGCGCGCGAGACGGACGTTACGCCGGCACGCGCCGAGCGCCGCACGT +TCCTGATGTGCGCGTGTACTGCCTGCGCGAAAGTCACATACTTGGCCCGCTACCGTACGG +ACGACGACAAGCGCCGAGCGGGGGCCGATCTCATCGAACTGATGGAGGCCGGAAGAAACC +CGTTCACGAAAAAGCTGGAAATCGGCGCGAGCGGTCGTACGATTTTCCCGAAAGAGTACT +GCTGTCGGAGTTCTCGTGGTAGAACCACATGCGGCCGCTCACGGTCAGCCCCTGTCTTCC +GTGTCCGCTTCGTCGCCGAAGGCGGTATCCGCGCCGTCCTCGATGTCGGGCGCGCGACAC +GCGCCACGTCAACCTCACGTGGGAAGAGGCGGCCGCGCTCCCGGAAACTCTCTACGAGGT +GGACGAGCTGTTGGTTCCGGCCGCAGTACAGGAGAGTGAAATGGCGTATCTCGGTCTGAA +TCAGCTCCCGTTCTTCCTTTTCACGGACGACATGCCCCCGGACCCGGTCTCCGACGCATG +CCGGCTTCTCGGGATCGGCCCGTGGGCGACCAGTGAGTTCCGGGGAAACATGGACTTCGC +TACGGCGCTCGAACGCAAGCACCCGATGAAGGAGTGGCGGGAGGCGATCAAGAAGGACAT +GGAGATCGAGAAGCGGCAGCAGAGTGCGCGAACGATCGCGACCAAGGCGCGCCTTTGGCC +CCGACGGGTTTCCGCCGGGGCTTCTTTTTGCCTACAGGCCGGCCGCCGGGTCGAGCTGTT +TCCCGAGGTCGATCATCAACTGCATGACACGCAGCGCGTACGGGTCGTCGCTGCCGAGTG +CAATGGCGATGCCTTACGGCATACTCCCCATCTGATCGCAGCAAAACCATTCTACTCTGA +TGCCGGCTTCGCTGGGGTCGCTTTGCCGGGCGGCTTCCATCCACACTTCTTTGCCCCCAT +TGCGTTATGTTCGACCATTTGTTTCAGGACGGGAGTCGGGCTCGCTTTTGCTTGGTCGAG +GGTGTAGGTGAAGGGTTTCGTCCAGTTGCAGCCGGTGTCGATGAACTTGGTTTCAACTAC +GATCTTTGGTTCCTGCGGCATCGGGACTCCCGCTTTCGGGGGAGGCCCATTTCTGCACGA +GACCATCAAAAGAAGCGCCGTCAACGCCAGATACTTGTTGTTCAACATAACAGGGGCAGG +CCGAAGCGCAGCGTGACGCGGCCGACGCCCGGACTCAAACAGCGGAGGTCCGTGACGCAC +ATGCGCAGTCGAACGCGGCAGCCGCTCAACAAGGCGTTGAAGCCGCGAAGGAGCGAAGCG +TCGCGGCGGCCACGTCGGCCGACGCTTTCGCCTTGTCGATCCGGTTGTAGCCGAATGCGC +AGAGGATCGCTACGATAGCAGCCCCGATCGCCGCGATGATCGTGTTCAATGGCAAGTACC +CCCGTTAAGGATGTAGGTTGCACGCAGGGCATCGAGGTGGCGCTTCGGCTGTTCGTACGT +GTTCTTCGTGCCGGGGATAGACACCCAAAGGTTCGAGACCCGATCGCATGCCGTCAGGAA +GTCGCCGGCCTTCAGCGGCTCGATGGCGCGGCACTCTTTCAGCTGTTGAAGGCACGTCAG +GTCTTGCGCGATCTCCGCGAAGTCCGTCAGCCGAAGGAGCGTCTTGTAGTGCGGCCAGTC +CTTCAGCATCTGTTGGTATCGGCGGCTCGCCGTCGAGTAGAGGCCCTTCGAGTTGACCTT +GAACGGCTTAGGGCCGAATTGCGGCATGAACGGATGGTCGCTGAAATCCGTGAAGCGGTT +GTGCTGCAGGTTCCCCTGCGCGTCGATCGAGTTCACGAGGATGTCGTAGCCGTCGTCTTG +CGTGACGGGTGTCTTGCTCGTGCCTTCGGCGTATGCGGTCGTATCCATGAACGCGCAGAC +GTTCAGAGGGCCGGCCAGTTCAGGAATGATCCGGGGCGTTCGGGGTCTCCGGTCGAGGTT +GCGTACGCGCGAGCCGGGCCTGCTTGATGATGCGGAACGGCACGGCGAGCACGATGATGG +CGATCGGGACGAAGCGCGCGTACTGCGGCGGGATCAGCGCCTTCATGTTGTGCGGCATCA +GGACCCTCACATGGAGCAGGGTATCGGGTGCCACCTCGATCCAGCTCTGCAACTCGACGC +CAACTGGGATGAACCACGTCGAGCTGAACTTCACGGGGGTGCGCCAGTCATCCACGAACT +GCACGCGCTGCTTCAGGAAGACGCGGACAATGCTTCTGTCCGAAAGTGGGCGAAATGAAC +AACCTCTTCGAATTGGCGGCCGTAGTCGCCGCCGTCGCACTGGCCGCGCTCGTCGCGGTC +TTTTTGTATAGCCGCTTTAGGGTCGTTGATCGCACGGTCGAGCTTGTCCTCGATGCGTCG +CAAGTCCTCTCGTACGTCCTGTTACACCTTCGTTTGGTTGGTATCGATGCGCTTGATGTC +CTCCTTCATGAATTGAATCTGCGTGGCCGAGTCGCGCGCCCGATCTCGGATGTCGCCAGC +GTAATTCGCGACCCAGCCGATTGCCGATCCACACGCAACCAAGACCGTGATTGCCATCTT +GATGTCGATGCGGCTTTTGTCAGTGATGTGTGCCGTCTCATCCGTGTTGTTCGTCGTCGC +GTTCATTCGCTGGCCCCGTGCGAAAAGGTTGAGGATTCGCGGGATTCTAGCAGAACCGGA +AGCAGTCGAAGGGCGATACGAAGTAACTTCAAAGCGGGCGGCCGTCATAAGTTTCACCAT +GTGAAAAAGAAAGGGATGGGCAATGCTGCCGCGAATTCTAGTACCCGAGCGCCTGAATGA +CAAACGGCCCCGGAAGGCCGTCTGCGCTACATCAGGTTGTGGGCCACGGGTCGTCCGGGC +CGAGCGGCGTATTGCCTGCCGCCAGCCACGGCTCGTAGATGTCGATCCAGACCGAGCTAT +CTATGGGGACCAGCCATATGGCCTCGTCAGCATCGCGGTGCTGGACAACATCGTCGCGAA +CGTCCGGGGACGACCCGTTGAACTGCCTGAACGCTATTTCCATGACAACTTCTGTTAAGG +GCGTGCATCGCCGAGAACGTATCCGTTCGAACCGCTATCGAGCGAACCACTCCCCGTAGT +AGACCATTGCGCCGCGATCCGCGAAACGAACTTGTTGGCCGCATCGACAAACGACGTGTT +GACGACTCCGGAAGTACCGACCCACGTACCACGGATCGAGGTCGTAGGCGAACGCGCTTT +TTCCGAACTCCACACAATCGTCATGAGCCCGTGGTTGCCGCTGACGTTGTGCGCGTAATA +CTTGATGTTTCCTCCCGTGCCGTCGAGCCGTTCGATATACCGTTTCACCCGAGTCGTTTC +GAGCGCTAGGCCGCGATACTCGAATGGCGACGGTGGGCCGCCGAGACCGTTCACGTCGCT +GCTCGATGCCGGGTCGCTTTCCTCGATCTGTAACTGGCTGAAGTCGAGCGTGAATGGGAT +TCCGGTCGCCAGAACGAACGCGACCTGAAGCTTATCGTCCCCGTTCGTCCCGAGTTGCTT +ACCGGCGATCGACGGGATATCGACACGGACGCTGAAACGGCTCTCCGTCGTGCCGACCGA +CCACGTGACGCTTTTCAACGTGACCACGGAAGACGCAGGCGAACCCCCCGAGACGAAGTT +CTGCACGACTTGAATCGCAGTCACCAGATTGGCCGCTGCTGCCGCAACGGGCGTCGTGCT +GACCGTAACACTGCGACCGCTGAACGTGTTGACGCCTTCGATGTTCTGGTAAAGCTGCGG +CGCCGAAGATGCAGCCGTCGTTTGGTTGAACCGCAGCTTGTACCGGCGCGACGAGTCGAT +CCACTTCGGTGCGGACTCGGGGGTCGCAGGGATACGCGATACCGTCGTCGCACCGCCCGT +TCCGGAGATCGCGCGCCACATATCCGCCGTGTACTGGTCGGTCGCAGCCGCGAGGTTGTA +CGACGTGCCGATCTGCCACGAATCGACGTTGCCGTCCACGAAGCGGTTCCGGCCGGTAGT +AGCCGGGAGGTCGCCGGGCTGAATGGTCGAGTTCGTCCAGTTTGCGCCGTTGTTGCGGAG +GTACTGGCCGCTCGCCGACGACACCGCGAAGCCGATACGCATCGTGACGGACACGGTCGA +GCCGCCTTGCGTGTCGTACGCCGACCCGTTGACCGGAGGACTGACGTTCACGCGTGCCTG +CGTTCCCATCGTAGAGAACGAGTTCGACGGCCACGTGCCAGACCCCGGCGAATCGATAGG +CGTCGCGTAGTTGCCCGCCCGACCCGCACAGCCGACGAGGAACGCGTACTGCGTACCTGC +GGTGAGAGCGACCGGCGTCGGGAAGTTGAAAGTCAAGTCCAGCGACCCCGCCGTAGCGAT +CGTGACAGGGCTGCTGAACGTCGGTGCGCCGGTAAGCGTGCCGCTCGATGCCGGGGCGAC +GGCTGCTTGCAACTGGACGCCGACCATTCCTGCCGTTTGAAGGTGCGTCGTCAACGAAGT +GACTACGCAGTTCCGCGTGACCGTCAGCAAGTTACCGTTCCAGTTGTACGCGCCGTTGTT +GTAGCTCGTCGTATCGGCCGGGCCGACAACCGCACTGACAGGAACGCTAACATCCGAGAG +GCCGCTTGCGAGCGCCGTAGCACCCGGAGTCGTAGCCCGTGTCCAGTCTTCACGGAGGAA +CCGCGTAGTGCCAGCGACGATACCCGGATCGGGGACAAGACCCGCCGCATGCGAACCACC +GGATGCGCCCATGACAGGCGGAAGCGGTGTAGTCGCCCATGTTGCATCCTCGCGCAGGAA +CCGCGTAGTGCCAGCGACGATACCCGGATCGGGGACAAGACCCGCCGCTTGCGGACCACC +GGATGCGCCCAGGACAGCCGGGAGTGGTGTAGTCGCCCATGTGGCCTCCTCGCGCAGGAA +CCGCGAAGTGCCAGCGACGATACCCGGATCGGGGACGAGACCCGCCGCATGTGAACACGC +GGCCGGTCTCGTCCCCGATCCGGGCGCAACGGCAGGAACGACGAAGTATCTCCGTGAAGA +TGCAACATGGGCGACTACACCGCTCCCGCCTGTCATGGGCGCATCCGGTGGCGTTGACCC +GCTCTTCACAAACGCACCGAGTGTTTGCCACGTAGCCGTCCCGCTGCCGCCGCCCGTGTA +CCGTTGGCCGTCCGTGGGCGCTTCACCGAGAACAGACGCATTGACAAACTTCCCCTGCGT +CGCGTCTCCGGACGTTACCACCACGAGCGACGATCAGCTTCGCTGGCTGGGCGATGTCAA +ACTCACCTCATTGACTGACGGGCAGGCGATCACATGGTCGGCATAATCGATGAACACCTG +ATCGGTGTACGGTCCCGCACCCGTGACAGTCCATGCCGTAGTCCATGCACTGCCGTCGTC +TGAATACTGGACGGTGAAATTCGACGGGCCGCCGCTCAGATTGTCAGTCACCGCAATCTG +CACACGCGCAACGGACTTCGCAGCGGGCCACTGGTACCCGAGGAAAATCTCAGCACCGGC +AAGCGGAGCGCTGTTGGAGCGGTAGTAGGATGCGGTGTTACCGTCGAACGCGTTGTCCGG +ACCAAACGTCGTGTTTTGAGCCGAACCGGATGCCATGCCCCCGGTTGTTGTGATCTGCGC +GCCATTCGTATCGCTGAACCGCAGCTCGGCAAGACGCACGCCGACGCCCCCGGTTTGCGC +GGCCGAACAGTTGGTGCGCCAGTACTTGTGATCCCCGTACGGATTGGTCTTCGTGAAGAA +GCTGGCCCATGTGCCATTCTGACGCATGGATTTGGTCCCATCGCTCAGCGCGTCCGCGAT +ACCTGCCGTAACCTTCTGGTTCGTCCACTTGGCGCTCGCGGCGTTCCACGCGATGACCTG +CTTGTCGCTCTGCGATGCCACGGCTACATCGGTCAGGCCGACAAGCGTCGTGCTGCCGCC +GGCCGGCGGCACAACCCACGTTCCATCTTCCCTGAAATACTTCGTAGTGCCGGCCGTTGC +ACCCGGATCGGGGACGAGGCCAGCCGCATGAGATGCACCCGATCCGACCATGGTCGACGG +GTAGGGTGGCACAGCCCATTGCGCATCTTCACGGAGGTACTTCGTCGCGCCCGCCGTCGC +GCCCGGATCAGGGACGAGGCCGCCGACATGCGAAGCGCCGCTCGCGACGAACGCGCCGAG +CACGTTCCACGTCGCTTGGCCGCGCGTGTACTGGTTGGCGTTGTTCGGTGCGTCCGGAAT +CCCGCCGCCCCCGCCGATCGTCTTGTTGATCCACTTTCCGGATGCGGCGTCCCACGAAAC +GACCTGCTGGTCCTGTGGGTTCGAAATGTTGGCGTCCGACAGCGTCGCCATGCTCGAAGC +CGGGATTTGGACCTCGGCCCAGCCGGAATTCTTCCGCGCGTACTGCTTGCCGTCTGCCGT +CGCTTCGGGGATACACGTGCCGGTCGCAACAGGAGTCCAGCCCCCGGCTTTCCGTGCGTA +CCCCACGCCGTCGCTCGTTGCGTCGGGAATGCCGCACTGCGCCGCCTGCCAAGCCGTGCC +ATTCCACTCTACGCAGCCCGTGGAGCCGCTGAAAGCGGTCCACCCGAGCTTCGGAGTGTA +GAAGGCCCACGCGCCGCCTAGGAAGGGCGCGACGTCGTCCCCGTGATTGGCCCACGCTCC +GGTAGGGGCGGGGGACTTACCGACGATATAGCGATCGCCCTCGGCCGGTGACGACGGAGG +GACTGTCAGCGTATTGTCGATCACGCCAAGCTGCACGATCGTATCGAGAAGCTGCAGCGA +GCCGTTCGTGGTCGTCCCCCAGCCCGACGCTCCGTCCGCCCAGCCCCACCAGACGCCGAG +ATTTTTACCTTGTGCTTCTGCCATCATTGGCCTCCAAAGTCCTTACCCCAATTCTAGCCC +CAGTCGCTATCTGCCGTGAGCCAGTGGGTGAAGGTGAAGTCGTACTTCTGGTAACACGTA +ATGCCGCTGCGCGTGCTCTCTATCTCGGCGCGATGTGTAGCACCCTGACCATGGCCGACT +GCGGCTTCCGGGAAGGTGTACGTATCGGCCTTAATGCCGGTCTGCTGCACGATCAGCGTG +TTTGCTGAATCGTAGATGCGGATGTTGTAGGTCACGCCGGTTTCCGGCCCGACGCTCTCA +TCTTCGTGGGCGACGAGTTTGTCTTGCTGCGGGATGCGGTCTCGATGCGCCCATGTGAAG +ATCAGGTCCCCACGGACGGACGAGACTTCCGCGTAGTGCTGGCCGTTCAGCTTCAGAGTC +TGCGTGCGGAACTGCACGGCGATCTGCATTCCTTCGCTGAACTCGGACGGATCAGCGCCG +AAGTTATCGTCGTAGACCCATACGATATCGTTGCGAAGATGCGCGGCCAGGAGCGTGTCG +ACACAACCCCGTCGAATCGTTACCAGCTTTGTGCCCATATCGTAGCTGACCACCTCGATG +ATCTCGTCGCCGATAATCGCGGCCATGCCCGGCTCGATGAGGTCGGTAGCCTCGTTGTCA +TCGAAGCGCAATGTCGTATCGAACTGACCGAGAGGCTGCGACAAAACGACCAGTGGCATG +AAGGCCGCCGTGTTGACCTTGCGATACGTGTTCGTGATGCCGGGATCGTCCCATACCTGA +TACGACAGCGAGAAGATATTCGGCTTGCGCGCCACGGCGACCAACGTTCCGCTATCGGCC +GGGACCTGTGCGAGATCGGCTGGCGACAACTGGCGAACGAGATCACGATACGTCGCCTCA +GTCGTGCGGTAGACGGCCGGCGCGACGGGTGTGCGGTTCGGCGGGACGTACTGACCCGGC +TTCGCTTCAACGTACGTCGTGGACGGCAGACCGAAAATATCCTGCACGGCCGTGATCTGG +AAAGACCCTTCCTCGTAGCGACCCGCCTGAATCTTGCCGGCGCGCAGGATCATGTTCTCG +ATGCCGAGCTGCGGCACGCTGATCGAGAACACGTCGGTCGGCGCGAGCTGCGCGGCCCGG +CGGTCGAGCGTGAGCGTGAACCGCTTCAACGGCGTGCCGTTCGACTTCAGGTCGCGCATC +GCCACGCGCATCGCGAGGTCGGCAGTCGGGATTGCCGGGTACGCAGTTGTGGCGCTATAC +ATCGCACCCACGGCCCGCATGTTTCCGACGTTCTGCGCGCGGACCTGCTTGTCCTCGTCG +GTGATTGGATCGTGGTACATGACGATCTGCTCGTTGCGGCTCGTGTCGCTCGAATTGCCG +TCTTGTGAGATGTTCAGCAGGCCGGACGTCTAGTCGAGATGCGGAATTGTCGCCGGGTCG +TAGTCCGAGCGGATCAGACGCAGCGTCAGATTCTCGGTCTTGCGGTCGAAGTAGATGGCC +CCGCCGATGTGATTGAGAACCTCTTCACCGACGCAGCCAACAAGCTCTGCTCGGAGTGTT +TCGGCCTCTGCATTCGGTGGAACCGACAGGACGACCTCGATGCGTTCGTGCAGCGACTGT +TCGTCAATCAGCTCACGCGGTAACCCCCTGCCCCATTCGCGGTTCGTCGCGCATTCATAG +ATGATGTGCGCCGGGTTCATCGCCTCGATGGTCTGGTTCGCCATCTGGTTCGTCGCCTTC +TCCGGATAGAAAACCGGGCCGTCCCATCCTTGAATCGATCGACGCACGCGGAATTTCCAC +GCCTTCCGACACGGGTTCATCCCGCAGATCAGGCTGTCGAAAAACACCGTGAAGACGCCC +CGGAACGCCGGCGCGATTCCGCCGAGCATCGCGGCCAGTCGCGGATTCACTTGCTGGGTC +GCCTCACCCATCATGATGTCCGCGTTGCCTCGAATGCCGCCCTCCTACTTGTCCCCGCCG +AACAGCCCGGGCGAGTTGATGTAAATCTGACCGCTAGTCGAGACGCTGCCTGCCCACTCA +GTAAGATCGCCCACGGTGATCGCGACCAGTTCCTCGACGGGGCCACGGTAAAGCGCCGCA +TAAATCCCGAAGCAGTAACGATACCCGATGACGGTATCTCCGCTTTTACCCCCGCCGCCC +ATTGCCGTTCTCCTTGTAGACTTCTTCCTTCGCTCGTCCGAGCAGCGCGCAAGTGATGTG +CTGCGTGTCACTGATCTTCAGGCCGTTGCGCAGCATGTCGCGAAACGAAAGCCCGTGCGA +CTTGAACCACTCCCGAGCGCCGCGCTCGCACATGCCGGCTTTGAAGATGTGCCGGATGTA +GATCGTCGGTTCGTTGACTTATTCCCTCCCCCGGACATGATCGACGTCGTGCGGAAATTG +CCGAGACCTACGACCGTCCCATCGCTGCACCAGCAATCGCCGAACATGACAGCCTGCGGC +GTGCCCTCCGGGGCCTGCGGGAAGTTGAAATCCGCGAACTTCGCGGGGTCCGGTTGCTGC +GCTCTCGGGCCGAGCGCCGCCGACAGAAAGTACGACGCGACCATGAGCACGAGCCACACG +ACGAATTGCATTTTTGTTCTCCTTAGAAGACAGGATTTCCGTCGAACGGGCTACGGCCGG +GTATCCCGTTATACCCGCCGTAGTTAAGGTCGTTCCCGAACTTGTTCTTACAGACGGATG +ATAGGCGAGCACAACCCGGATAGATCACGACATTCATTCCGATCGCCAGTCTATCCGCAG +CGCCCATGGGCGTGATGCGATTGCCGACGTGCGTTTCGATGCCGTACTGATCCCACGATC +CCGGCTCGCGCTCGAACTTCATGAAGCCGCCACTGAACCACGGTGCGGCCTTCGAACCCG +CCTCGGCGCACTCGAACCAATCGCAGCCCACGGCAGTGATGACGCTGTTCGTGGCGAAGT +TGTCCGGGTTGAGTTTGCAGTTCACGTCGTACACGAAGTACGGGCAGCCCTTCGTGTATG +CGAGGCGCAGACCGCCGCGCTTGAATGTCATCGACATCTGTTGCCCGACGATCTGCGCGT +TCATCAGAGACGTGTGACGCACATCGGACACCGTGCCCATCCACGCCACGTCCGCTTCGT +TGTCCGGGTCGTTGTAGTGGTGTTCCCGGATCGTCAGGTAGATCTAACCGATTGGCGGCG +TTCCGCGCTACTGCTTCACGATGTCCAGTGAAGTCGCGCAGTCGAGCGTGATCGAATCGG +CCCACGCGTTGCGGCTCTGCGAGTAGCCGTCGTGCGCGATGTTCGTCGCAACGTACGTAT +TGTTGTTCGACGGGATATCGCGATCAGCGTTCGTGTAGTAGTAGAACTTGCTGCCGTACA +GGAACTCAACGAGCAGGAGCGGTCGCCCGTTGAAGTTGCTCATGTCGATGTTATCGAAGC +TCATTCGAACACCCCTCCCCCGTTATATGGCTCTTGGTTGACTACGTGCGTGGGAACAGA +GATGTCCGCGTTAGGGTCTGCCGCTAGAAAATCGAAGACGAAGTTTCCGGCGTTTTTGAA +CACGAACCATTCTGTCTGCTTTGGATTCGGATGATACGATGGAACTCCGGTCCCCGGATT +TGGGTTCCATCGAAACGTCATATAGGGATATGCGCGCAGGTTATTCAGATAAATGCCGGT +GTTCGGGATCGCAATGTTATAGCAGGCGAAGACCAGCCCCTGAACAATCGACCCGTTCAC +ATCATGTTGTCGCATCTTCACCTTAGCCGGCTATTGAACGGTATCGCGAAACGCGGCGGT +AAAAAGGTTGCCCGAAACGTTCGCCCCCCTTACGTCGCCTGCCGGGTAATGTCCGCCTTG +GACCGCAGTCGGATTCAGCACGTCGTTTGCTTGCGTCTTCAGCTCGGAGATTTGAAGCGG +GACTGCACCGCCACCTGCTCGGATATAAGAGCCCGCTTTTCCACCAAGCAAAACGTCGAT +AGAGTTGATAGCAGCTTGCATCAGGCCGCTTGCGATTGAGTTGTCGAATGCGGGAGCGGT +GCTCTGCATCCAGCTTCCATTCGGGTCAGCTTCGATGGCTCCTGCATCCACTATACTCGC +AGGCGCGCCGCGCATACCTGCGACCATGGGCGGGTTGCAACCCACCAACCAGTGAATCGA +ACCGGTCGAGCTGGTCGTCTGCGCTTGAACGTTGGACGCACTCGTGATCGATTCTAGAAT +TGCAGCGCAGGCGGTTGCGGGCAGTGTTTCTGACGCGCTATCGTCCTGCGCGCATTCAGT +TATGTCAGGGGTGGATCACCACGGATCGGTACGCGTACTACGCTTCGCTTGATGACGCAA +CGTTGCACGCGGCGTTTCGCGTTTTTCTGGCGTACAACATCTATTCTCTTCTGTATTCCC +TCCTGACGGGCGGCCTCGCGTACGCGGCGGCGAAGTCGCTCATGGGGTACCTTGAATAAC +CTCAACGCAACGTACGACATCATGGTCGCCAGCGGCTACACCCCGGACCAAGCCGAGGCG +ACGCGGCAGAGCACGCTTGCGGCGATGAACGATTCGAACAATTACACGCGGGACTATATG +CTCCTGACGCGCTGCGTTCGCCCCGAGGCAGTAGTAGAGCAAGTCCCACGACTCATTACG +CTTGACCGACGTGGCGACCCATCCCTTGTCCGTACGCCGCTCGGAGACGAGCTGGACGTA +GTAGCTGTCAGGCAGCCATTCGGGGAAGTGAACCATGGACTCAGGTTTTGGATACTCCCC +CGCAAGCGGATCGACCGGCGGGCGGCCATTCGTTCGAACGCCGCCCCATGCGCCGCATTC +GCTGCCGCAAATACACGGGTCGGGTGTTTGCGTAGTCTGCGTATAGCGCGTGATGTCGTA +ATTCGTGGCTACTCGATTTGCAGGCGTGCTCTGGAACGTGACAACTGCCGAGCTGACGCC +CTTCGTGTCGGTCATGTGGTTGATCACTACGCGGTCTTGATTAAGCCGCGCGAGCGTCAT +GAACGAGACGCGCTTCAGGTCGGTCGACAGTGCCGGCAATGTATCGTCGCGTATTGGGGG +TAACGCTCGACCAGACTACGGGCAACGAGATCGTTACCGTGGACGCGGCGTTCACGCAAG +CCGTATTCGCCTCGGACGCGGGTCGAGAATGATGTCCTGCTGCCCGTCGCCGATATGCAG +CTCGCGAAACCGATCCAGTCAGGTGATACGACGATCACCATCAAGCGCAGCGGCTTGGCT +GACTTCTTCTCGACCCTTCCTCGCATGGGACGGCAGCCAAAAAGGCGTGACGCGCCCGCG +CAGTGCGTACAGCAATCCGCGCAGGTCGGCACTTTGCTGGCGGCCGTGCGCGAAGAAAGC +AAACTGCTGCACGTAGAGCTGGATACCTGCGGTATCTCCGCGCTTCGGAATGCCGGATCC +GGAATCGAGCACGACCACTAGCCGGGAATACTGAACCATCAGGTCGCCCGTCTCGTCCGG +GCGAAGACGAAACACCGGATAGCCGCGGTAGATGTCAGTCCATGCGGCTTCCGGGTAATC +GTTCGTTTCCGTGACCTGCCAGTTGATCGCGTAGACGGCAGCGCGATCCGCCTTTCGGGT +CATCTGCGGCTGGTCGGTCAGCATGGCTTCCTGAATCGGAAGTAACTTCGTGCCTTTCGG +CCATGCCTGCACGAGGCCCTGATCGACCGTGATATTCGTAGCAGTCATATCGGCTATCAG +CCGAACCTCGTAGTCCAATGAAGTCCGACCACGGAAAAAGACGAGGCCGCCCCTCTTCAG +TTCGGACGTGGTCGTATCCTCGACGTACACGACGGTATCTCCGACTTTCGCAGAGGGCGT +CAGCGGGTTCAAATCCCACGGAAGAGGGACATTCCAGCTCGTTCCGCCGCCGGCCGTCAG +CGCGGCGTTCAGGCGCGTGCGCTCGGCATCGATCACGAGCACGGACGATTCGAAGAACCG +GCGCGGCGAGATCCGCAGCGAATGCCGCTGCTCGGCCGCCATATTCGATTGCTGCACACT +CGTCGCCCGTTCGAGCGCTTCGAGTACGCCGCCGGACCATTCGGTCGCGGAAGACCCGAC +GGGAAGATTGATGTTCAGCATTACTTGATCCCCAATGCTTGGCGTGCGGTTACGGCGTTC +TGCCGCAGGTAGGTTGTGATGACGATATCGCCTGCCGCCGACGCCATCGCATCGGGCACG +AAGTTCGGATCGGAGATCAGCGTGTTCCGGATCGTCATCGACTGGTTGGCGGCCTGCGCT +GCATTCTTCGCGGTCTGGTTCAGGATGTTGCGCGGATTGTCCTTCGCGAGTACTTCCTCG +CCCTTCTGAAGGATCGCCGCCTGTTCATCTGCCTGCAGGCCGACTACCGTGCCACTGTGG +TAGCGCGGCGCGTTCGCAACCCAGCTCGCCGACGCACTGCGCGACATGCCGCCCGGCTGA +CCGACGACTGCACCGGAGTGCGCAATGGCAGCAGGTACGGAATCGACAAGGCCCCACGTC +CCGGGGCCGGTTCCGATGCGCTGTCGCCGGAAGAGCAGGAAACCGAGCGCACGAAACTGG +TCCTGAAGCTCGCCGCGATCTACGCTTCCCGCGAGCAAACTGTTCAACGTTTGTCCGAGC +TGGTGGGCTACTCGTCCAATACGCTCGGCGCTCTGTCGTCTACCGGCCGCGCGTTGCGCC +CGGAACTCTGCATCGAGATCGAGAAGGCGGTCGGGCACGAGTATTTGCCGCGACGCTTGC +TCAACCCGCATATCTTCGAAGTGTACGGCAGCCGGGGCGGTCGACGCAGCGCCGCCGAAC +AGCCCGGGCAGCGCACGCATTCAAGAACGTCGGGCAATCGGTCGCACAGTTCGCTGCGCA +GTTCCTGCGCCAGATGGCGAGCGTCATCATGCAGATCATGGCGACGCGCGCGGCGATGCC +GACCATTACTGCGTGCCATTGGCGGCAGCGAGAAGCTGGTCAACGACGTTCGTCATCGTG +CTGTCGCTCCCCTGCGCGAAACCGGACGTGAACGTGTCGCGAATCTTCGCCATGTCCTTG +TCGCACGTACTGCGCCTGCGTGCTGATTTCCTTCGGCTTCGCATTGTGCGCATCGAGCTT +GGAACCGGAGATGTCGCCGAGCTTCGGCCATCGTATCGAGCAGCTTCTGCATCTCAGCGA +CCATGCCCTGTATCTGCGGGCCGCTCTCCGTGTACGCGGCCTTGATTTTCTGGTTCGCCT +CTTCCTGCGTAATCGCGCCGAGCTGCACGAGGCTGTAGTACATCGTGACGGCCGAGTTCC +GCTCATTGAGCAGGTTGTTCGTCTCGGTCACCTGTTGGTTGAATACGTCGAGACCGCCCT +TCGCCGCCGCAGATGCCGGGTCAGTGGCTGGATCGTTGCGGACGCGCTTCATCTTCTGCA +CGAAGGCGTCGATCTTCGCGTCCGGGATGCCCGTGCCTCGCACGCTGTTTGCAAACGCCG +CTGCGTCTTTCGCCATCTGCGCAAGTTTCGGTTGCGATCGTTCGGTCTGCTTGGCGATCT +GTTTGAACCCATCCACTGCCGACAGCGTGCCGGCTTTGACTTGTTCGAGCACGTCTTTCT +AAAAATCCGCTCGCTCTTTCAGCACGTCGTTGACTTGTTCCTCTTTCTTCTTCAGTTGCT +CAGTGTTGAACTTAAGCGTTTCTTGCTGGATAGCTTGTTTCTAGATTTCCTTGATCCGCG +CCTTGATCGCGGCGATAGGCTGGCCGTCGACCGTCGTGCCGCCGATCTTCTGGTAGTTCT +CGATCGTGTCGGAAATGTCCTTGAACGTGCGCTCGACAGCCTTCAAACGCAGGTCAAGGT +TGTCCTTGTACTGCGACTCGACTTGCTTTCAGAGCGAATTCAGTTTCCCCGACAGAGACA +CTTCCATGTTGTCCCGCTTGCCGGCGTTCTTGGCCTTCTTGTTCGGGTCCGCGATGTCGT +ACAAGCCGCCGGACGTATCGGTCAGCGGTGCCCATCGGGGCGGCGTCGTTGCAAGGCGCG +AGCCCTGTCGACGGAGGTCATTCTGATACAGCACGTTGAACGCCGCCTTGTTGTCGGACA +GTGCTTTATCGCGCTCCGCGCGAATCGAAGCGAGGTAGCGCTGCGCGAGTGTTTAGGCCT +GCTACATCCCGGTCTTAGCGCCGTCAAAATCCAGACGCTGAAGAACGGCTTCCTCGGCGG +CCTGCGCAGCACGGCGGAATTCCTCGGCCTCGATAACGTCGCAGAACAGCTCGGCAGGGC +ATCACGCTTCAACGCCTTGTCGAAGAAGTCCACGACAGAATCGCTCATCTGCGAAGCAAG +CACGAGAATGCCGTACTTGACGTTGATCCATGCCTCGTAGATCGATTCGGCCGCCGCAGT +GCCGACCAGTCTCGCAGTCTCGAACTTCTCGCCGATAATCTTCCCGATCTGCCATCCCGT +GAACACAGCGGTCAGGACGAGGAAGATTTTGTAGATTGCCGAAAGCGCGGCGTTCTACCG +ATCGGCGGCCATGGAGGCGGTCGCCATCGACGCGCCGGCTGCATCGACGCCCGGTGCAGC +GGCCGCCCCGGACGCACCGACCGCGGCCATAGCGAAGGCCGCTTGTGTGAGCTGGATCGT +GAAAGCCCCGATCGACGCCATCACCTTCACGCCGAGCACGAGCCCGATCACGTCGCCCAT +GGCGTTGATATTCTTGATGACTGCTTCGAGGATGTTCAAGACGACCGTGAACGCGTCGGA +AAAGTTTCTCGCGAAATGCGTGCCGTCGTCACTACGAAGCAACTTCGTGATGTCGACGGC +GAACTTGGTCCACGCGTCCGCGAAGCCCATATCGGCGATCGCCTTCCGGAACTCGTAGAA +CGCGTTGTACATGCGAGCCTCGGCGGCCTGCATATTATTGACGGCCATTGGGAGCTGCTT +TCCGTACTCATCGCCGAGCTGTTGCGCGAAGCCGAGGAGCTCCTTCACCGAAACGCTGCC +CCCTTTGAGCCGGCCAGCTCGGCGATCGGCTGCCCGCCGCATTCGCGCTTTTCGCGAAGG +GCATGAACATCAGTCTGCCGGAATTGAACAAGCGCGCAGTTCTTCCGTCTGCACCTGCCC +TTTCGACATCATCTTTTCGACCGCGAGGAACGTGCCCTGCATGTCATCCGCGCACATGTG +CAGTACACGGGCGGTCTCGGCCACTTTCTCGAAGATAAACCGCGTCTGGTTTGTCGTTGC +GCCGGCTGCCTTAGCGGACACGGCGAACTTGCCGTACGACGCGGCGAGATCATCAATCCG +GATGCCGAGGCGTTCAGCTTGCGCCTGCACGTATTGGTATTCCGGCGCAACGACTTTCGG +GTCGTTCGTTCCAGCGGCCACGGCGAATACGGATTGGTTCGAGTTGAACTTCCGAATTGC +ATCGAGTGCCCCCGCCGCAAGGTTAATCGCGCCCTGCACGCGGACGTACGCCGTGGCGCG +CGCGATCAGCTCGCCGCGCACGCGCTGATTCCACGACAGCGATTCGCGGTTCCCCGTCGT +GAGGCGGTCGAGTAGCGAAACAGTCTTCGCCGCTTCCGCATGCTGCCGCTCAGGCCGAAG +CTGCCGCCGCGTCGAAAGATCTCACAGCGCAGTCTCAGCAGGCGAACGGCATTCGAGCAA +CGACCGCTGCGATGCAAGGACACACCGAATACGAGCGAGGCGAGCATCAAAAGCCTTGGC +GTTCGCATCGTTCACCGCAGCCTGCGCAGCAGCCTCTCTGGCGGCCTGCTCGCGCCCGGC +CGCTACGATGGCAGCCCCGGCGGCCCGCGCGCGGTCCTGAAGGGCAGTCAGGCGGTCTGC +TGCGGCAGCCGCAGCCTGCGTTGCCTGCGCCTGTAGATTCATCGCCTTGGCGACCTGCTC +TGCCTGCTCGGCGACTTGCGCTTCAAGGCCACTGAGTTCGGCCATGGACTTCGTCAGGCT +GGCCGTGCGGGCATTGGCCGCCTGCACATCCTGACTCGCCTTCGCGACGCGCTGGGTAAG +TCGTTCGAAGTCCCGGCCGCCGCCGGCCGCCGCAGCAGCCAGCTTGTCGAGTTCACGGGC +GGTCGATCGAGTCGGCGGCCCGGCGGTGAGTGCATCACGCGCGAACATCTGGTACGCGAT +GGCCGCGCCCTCGACGGACCGCTTATGGCGATCGAGGTTTTCGTTTGCGGTATTGAATGC +CTGCGACGCCGCACCAGCTCGCTTCTTCGCCTGATCGAGCGCATCAGCAGCGCTTGACAT +GGCTTTTTGTACGGCGTCAGCAGCCTTGGAGAGATTCTTCTGCTGATCGGAGAGGGAGGC +GGCCGCTTTGCCGAGACTGTCCGTCCCTCCGGTTGCGGCCTTCGCCTGTTTGACTTGGTC +GGCGAGAGACGAAGTAACTTCGTCAATCGCCTTCTTCGCGTCCTTCATCGCCTGCGCAGA +CATGTCCTTGGCGCGGATGATGAGGTCGACTACCTTCTGGTTATTCGTTGCCATCTCGGA +GGCTCCTAACTTTCTCGTTCAGGGCTTTCACGTCCCCGGACCAGACGGCGAAGGTTGCCG +CGTAAGTTAGAAGCGCTTCGGTAGCAATCAGGCCGTTGATCCGTTGACGCGAGATTCTAC +TCTCATTCTATAGTACGGCGAGGGGGTAGTCCCACGCGTCCGGGTGTCCTTCGGCCATCA +AGAGGCTGGCGTTGTGCAGCAGTCCGATATACCACTTCTCGAACCGCGACGGTTCGCCGT +CCGTCAACAGGGTCTCTTCGGGATCAAGCCTTTCGTGATCCCCCGGAGCGCCCCCAGGCG +ATTGAAAAACTCTTTTGGGCCGCCTGCGTCCTCGAACGTGGGCTTCCGGTTAGCCGTCAA +TGCTTCTATCTGCACCGAGAAAGACAGCTCCGCTGCAAACACATCGGCCAGTGCTTCGAG +CTGTTCCTCGTAGTCGTCGGCTTTCCGATCTGCCTCGTCGCACGCGAGCGCGATCATCTT +CCTGACCAGTTCGGGGACCTCACGCGTCAGCATCTGGATGAGAATGTCTCCCGACTGGTT +CATGTATACGTCGGTCGTGTGGGCGGAATATGCTTCCATAAGCGAATCGCTATCTTTCTG +ATGTATGTCCACGAGCTGCGCCACTTCGGTCAACGCGAGACCCCGCACGCGCAGGGTCTT +TTCGCCGACCGGGATCGTGGTGCGCCGTGCTTTGTAGTCACGGAATCCCATTTCCCGGTT +CTCCTTACATCGGCCGGCCGTTGATGTACACGCGCTCCGTCGCCGAGCCCTTCTTCAGGA +CTTCGAGCTTGAACTGGAGCTGCTGCCATGCGTCGCCCTTCAACTGAAAGTTGCCGTCAG +CGGTGATCTTCGTGTACGGCATGATGTAGTTGCGCGACGGGCCGTACGCGTTGTGCGAGA +TGAAGCGGACCGCACCCATGATCTGATCGCCGGCCGACACGACCAGATCGTAGGTATCCG +CCGCCAGCTTGGACGTCCCCGAGATGGGCTTCGTGTCGGTGATGTCGGCTGCATCCGACT +TGACTTGGAAGCGCCCGTTCTTCAGGTCGACGTTGAAGTTCGTGAGCGGGATTTCGGCCG +GCGTGGCGTCCGTCGTCTTCGCGTCTAAATCGGTGACAGCGCCGGCGCCCGCGATTTTCG +TCGTCGAGACGCCGAGTTGATACCATGCGCCCGGCGTGACGATGATGGTTTCCGGTGCAA +CCGGCGACGCGCTGCCGGCTTGCGTGACGTTCGCCTTGCTGCCGGTGAACCGGAGCGCAA +GGTTGTCCGTCGAGATGTTGTCGACCTGAAGCGTCGACGTCACGTCCTGTTACAACGTGA +TGGTGATGTCCTTCACCTTCATCCCCTCGTCGGAGTCGGAGTGGTCGAGCATCGTGCTGG +CGACGGCCAGTTCGAGCGACGGCGAGTAGCCGAAGTACAGTTCGCCGGTCGTGTTGAACG +TGCCCGGAGCGAACTTATGGAAATAGCACCTACCCCGGCCAAGGATTTGATCTTGCGGCA +TGGTGAAACTCCCGTGGTGGATGAAAAGTTACGGCCGATACGGCAAAAGGTCGTACGGGT +CCGTGGTGTTTTTCGCGATCTTCAGGTTCAACGGCAGGTAGAAGTACGAACGTCCCGAAT +CACCTTCTGCGGGCGTACGACACACGCCGGGGCCTGCGCGCATGCCAGCAATGAGGTTTT +CGAGCATGTAGTCGGACGGATATTGAGGGTTCCCCGACGAGCTGTCAAGGGCGATCAGTT +CGCCGAGGCGCACCTGCACGTCCGCCATAAGGCGATACGCTTCATCGGTCGGGTTCTTGT +CCCCTTCAGCATGGTTGACCCAGCCCTGCACCAGAAGCAGCCAGTCTTCCGATTGCGCCT +GCCCATTCTCGTCGGCATCGTGGCCGTGATCGGGTCGTTGCGCTTCGAGGATCAACACGG +CAGGGGCAGGCGTCTCCGCGCCGAACTGCACTCGGTTTCGATAGATGCCCGACGAAAGAT +CGAACTGAAAACCGATCGTCGGCGTGACGCCTTCCAGATGGGCGGTGAGCTTTTTCAGGA +TCACCAGTTTTTTAGGATCGCGCTGCATGCCTTACTCCGAAAGACGCGTGAAATGGCGCA +GGAATTCATCGGCTAGTGCGTCAAGCACTTCGGTTGTGATGTCGTCCGCGACAGTCCGGA +AGACCTGATCGACGGCCGGCCCGTATAGCAGGTAGACGTTGTTCGACAGCTTCGTCGCGC +CATCCGTCGCGTGAAGCGTTTCGCCGGGGCTGAGACGTACAGCAAGCCCGAGGTTGTACT +TGTCCTCGGTCAGGGTCTTGCCGGCTCGCAGACGCACCAGAAGGCCGCGCTTGAACTGCT +TGGTGCGTCCGGGCTTGACCACGACCGAGACGCCGCCCTTGCGCGTCGATTTAGTCGTCT +GTCCCGGTTCGGCGAACCGGGCGAGCGACGTAGGACGCTGGCGCGCGCCGATCACAGCTT +CGAGGTCGTTGCGCGTCGCCATCTTGATAACGCCAAGCCGGCTATCATCTTTCAGGTAGT +TGTCAGGGAAATTGGCTTGCTCGCCGCTCTCGGTGCGGGCGAGCGGAAGGGCCGCACGCT +GCGCGGTCTGATTGGTCGCGATCATCGCGGCTTGTTGCGGAATGTCGGGAAGGCGGTCCA +CGTAGTCCCGAAACTCCCCGAGTCCTTCAGCGACGATTTTGATGCTCATTCTGGTCCTCG +TCAGGGCCGGACGCGCTCAACCGACCACTTGATGTCTACGAAATTGTCCGTGTCGTCCTC +GACATCGAGGCGGAACGTGAAACCGTAATCCGGAAACGTCACCGAGCCGTCGCGCGGCAA +TGTGGTGCCGAGTGAAGTTACTTCCGGTTTGTTGAAGACCAGATAGTTGATGACCTCGAC +CATGCGTGCGAACCCTTCGCGGTCGAGATCACCGACGAGCCCCATCTTCGTGTGGAAGCG +AGCGGCCAGCGGCGTCTGCGCACCCGTGACGGGGTCAGCATAAAGCGCTGATACCGCCAG +AGTGTCATGGACAGTCTGACGGACCAGGGCTTTAAGGGCGGCGAAGTCGCCGACCATGGC +TTACAGGCCCGAGGCCGACGCTTTCGCGCGGGGCTTCGCCGGCCTCGACGCCCCGGCCTT +GTCGCCGTCTTCGCCTTCGTCGCCGGCCGGGGCGTCTTCGACCTCGAAAACGTGGCGTTG +CAGGAATTCCTTCCCGTGGCGCTCGTGCAGATGCTCGATCTCCTCGTCGGTGAAATCGAA +CGGCTTGCCCGGTGCGGCGTTAACGATCTTCCGGTCGCGGGTGGCGATGACGGTGTGCTT +CGGAACGCGCTTCGGCATGATATTGCTCCAGTTGATTCAGATGAGAAGCCAGCCCTGAAG +GGCCGGCCGATGACCTACGCTACGCGGGTCGCGTTGTGCTTACTTGACCGTCATGCGGAA +GGAAGCGTTCGGCTGGGCCGGGACCATAAGCGGCTCGCTCTGCGTCATGAGCATCGCCAC +GGACGGGTCTTCTCCCTCCCACATCTTCGGGAACATCCGGGTCAGCACGAGTCCGTACTT +GAACTCCATGATCGCGCCGAAGCACTGCGTGCCTTGGAGACCCGGACTCGTCCCGACCAC +GTCGTACGAGCCGAGGGTTTCCTGCTCGGTGTTGTCGTCGCCGGTATAGGTGTCGTGGTA +CGTGTAGAGTTCCAGCGTACCCATGCCGTTATAGCCGCCGATCGTCCCTTGATACTGAAG +CGGCCAACCGTCGTCCAGTCGCGAGCGGTTGAAGTCGGACGTGCTGCCCTTGTAGAACAG +GTTCAGCAGCTCGACCACGGCGGGTTCCTGCGAGAACAGCGACCAGGCGTCGAGGCCCAT +CGTCATTCGCGTGATCGTGCTGGTCGACTTCTTCCACACCGTCCTGCGCATCGTTTGGAT +GTTCCCCAGCGGATCGGACGTGGCCTGGTCCCACGCTGCGCCGCCCGTCAGTTGCACGGT +GAGCGCCGGATCGCGGCCGAAGGCCACGCGTTGCTTCGGGAACGCTTCGCCCACCACGTC +CACGTAGCCGTAGATCGTCGCCATTGCGCACATCCATTCGATCCGGTTCTCGATGCGCTG +GCGCTGTTCGAGCTGCGAATTCGCGACGACCGCTTGGAAGCGCTCCTGCAACGACATGCC +GCCGATAATCGGCTGCTCGCCGGCACGACGCCTGAGCCTACGGTTCGGGTTGATAACGTC +CTTCGGCTTCACATAGGCCGGACGGAACGTCTTCGTCGTGTATCCACGAGCAGCGATCAC +GCGGCCTTGCACGTTCGGCGCGACGAACGGGGCGAGCTTCTTGTCCGTGAAGACGAGGTC +GAACAGAATCTCGTCCGTGTCGAACGTGATCTCGTTCGGGTTGAAGCCCTGCCAGTACAT +CGACAGCGCCGGGCCGCACTAAATCACGCCAGCAAGGGTGACGGCATCGAAAATTTCCAT +CTTTGTTCTCCGAGTTGTACAGGGTTTTCTTGCTGGCGCTCGTTACGGCGACGAGTGTGC +GGTATCGACCAAACGATCGATGAACACCGGCGTGCCCGCGAAGGCTGTTTGGCGTTCTTC +GAACGTATCGGCGGCGACGCCCCACACCAGTACGGCATGGTTGAAAAAACCGCCGTCGAA +GACCGGGTGCGATATCGTAGCCGCGCCGGCCGCCTCCGGCTGCGCCGCAATGCCGTACCC +CTTCTGCGAGCCGTCCGAGGCGGCCGGGCTCCACGGCACGAGCATGCCGCCGACGAGCGC +GACGACACGGTACTTTTCGAGGACCGTGGCAGCAGCCACGTTCGCCCGCGTCGTCACGAT +ATCGGCATCGTCGGCATAGAGCTGTTCGGGGATGTACGACCCTTCGGTGCCGTTGCCGGC +GAGATCACGATCGATCATTTTCTTCTCCTAGCTAGGTTGGAGGATTGTTGCTGTATTCCG +GCCGGAATACCGATTACTTCTTCTGCTGGATCAGATCCTTGCGGCACGTCTCCTTGCCGA +GCGACGCGAGCAGCACGTTGCCGACCTTCTTGCCTTCAGCTTCGTTGCCCTTGCCGCCGG +CCGGGTCCGCGTCGACTTCTGGGTTGTTGCTGGAGTCCATCGCCTTGTGGAACGCCGTGG +CGTTCTTGCTCGTATCGGCCGGATCGGCAGTAACTTCCGGTGCGGCCGCAGCGAGCATCA +CCTTCGCGTCGTCAACGGACATCTCGGTGTTCAGTGCGATGTGGTTTGCCAGTTTCGGCT +TACCCTTCGCTTCTTCGCAGTTCAGGATGCCTGCTTGGCGCTCTCGGTCGGCCTTGACAG +CAGCGCGGCTTTCGGCGGCCAGTTGTTCTTCGGTCAGTTCCATCTTCGTACTCTCCATGT +GGACTTCGGTTTCGGATGTCGAGCCGGAAAGCTCGTTGAAAAACGCAGCGACTGCATCTA +CCAGAAAGTTCGCGATACGCAGGCTCAGACGTACCGGGCAGACGATGCGCTGAACCTCGG +GCTGATTGACGCGGTGGCAAAACCGGCTGTCCATCCCACGGTTGCGTGCAACCAGTGAGA +CGAATTCGTCGTACGAGGCGTTCACGTCGGCCTGAATACTGGCCTTCACTTCTTTGGTCA +ACGCCTCGTAGGGATTGTCGTCGACCTTGTGGTCACCGGCATGAATGAAAGTGATTTTGA +TGCCCCTGTTATCGAGCATCTCGGACATATCGACGTGCATCGCGACTACCCCGTTGCTGC +CCGCCCATCCCGAGGGCGTCGAGACCACCTTCGTTGCGGCGGAAGCGATGGCGTAGGCGG +GCGAGTAGCAGTTCGAGTCGATGACGGCCATGATGCGCTTTCCGTCCCGCGCTGCGTAGA +TGTCGTCGGCCAACTCGAAGCAACCCGCTGCTTCACCGCCGTGGGAATTGACATCGACGG +TAATGCCTTCGACATCATCATCCGCGAGAGCGGCGTTGTGTTGCGCCCGTACGGAGTTGT +ATCCCGTGACAGAGCCGAAGCTGTAGTTGAACCGGTTAATCATTGTTCCTTGGAGCGGGA +TGATAGCAAGCCCGTTGGAAAAAGCAAACGGTTTGTTGTCGGCCGCACTCTGAAAGCCAC +ACGCCAGTGCGAGTTGCGTGCGCTGGACCTTCAGGAAGTCGTCATGTTCGAGCGCGTTAT +CGGCCGCCGCGAGCTGCTTCATGTCCTGTACGAGGCCGGCGTGATGCGCGGAGACCATCT +GCCCGCGCAGGTTGAACCGAGTGATTGCGATGTCTGCGTCGCGTCGTACCATCTTTATTC +TCCTTGTTAACTGGTTTGCACAGCAGCAGGGTCTTCGGCAATGCCGGTTGCTGCGTCGCG +TCCGTCGCCGAGCGAGCGCTTCGCGCTCAGATTGAAAGTGAGACCGTACTTCTTCAGCAG +GGCGTCCTCGCGAGCGCGCTGCGCGAAGATCTTTCCGAAGTCTCCGCCGAGGCGCGCGAT +TTCGCGCTCATAGGTCGAGAGGCCGGCATCGATCCGCATCACGGCTGCCTCCGTTTCCTT +CAGTTGATCGGTCTGGCCTTGCGACGCGCCGATCCACTCGCATTTCGACAGCGGTTCGTT +CATCAGCGGCTGATAGGACAAGTTCCGCGTCTGGCTCGGCGGCATCGAGACTTCACCAGC +CGCGATAGCCTCTTCCAGCCACAGCGTGAAGAACTCGGTCGCGAGGTGATCGGCGCACAT +CTTCTTGCACCCTTCGAGGAAGCGCCGCGTCATCGCGATGCCGGCTTGGATGCTCGAATA +GTTCGCCATGCTAAAGTCCCGCGTGAACTCTTCGTAGCTCATCCCGACCGCCGACGCCAG +ATGCCGGTTGAGCGACGCCTCGAATTCGCTACCGACGCCGCCCGGCGTACCCATCGGCTT +CAGGTTCAGCTTCGTGCCGGGAAACAGATGCGGAATCTTCGCGCCGTCGATCTGGATGTT +GTTCGCACCGCCGACGTACGCCTTCAGCGCGTCCACGTACCTCCCGAAGATGCCAACCAT +GTCCGCATTCGGCGAACCGCCGGACATCTGCGAATGGATGAACTCGGGCGGTAGCTCGGA +CTCGATAGCGGCCGCGTACGACGCGTTGATGACGGCGTTTTGAAGCGACATTTCCTTGAA +ACGCTTCGCCATGCTCATGCCCATCAGGCCGGACACGATATCGGCAATGCCACGCGACTG +ATCCGGTTCGCGCAGTTCGAGGATGTGGATGACCTGACCACGGCCCCACGGGTTCGATAG +CTGTACGAACTTCCATTTGTACATGTCCGGGGCCATCTGGTACAGGTCGCCGGGGTGCGC +GACCTGAATCCAGTAGCCCTGCGGCCGGTCGCGCTTGTCGTACTGCACGCCGCGTCGAAG +CGTGGGCGTGTCGAGTTGCTGGTACGGGATCGACAGGCGGTCGGTCGATATCATCTGGAG +GCAGGTCGCGTACGGCCGGTTCGCCGCGCGGTCCCACTCGGCAGTCGCCAGCACTCCGCC +GGTTTTCACGTAGCCTACCACGCCAAGGCGGATCAGACCGGTGAAGGTCGAGATCGCAGC +ATTGTCGATGTAGCAGGCGAGGGATTCCGCGTACAGCTCGAACTTCGCTTCAACGATAGT +CTGGTATTGCTCGGCCCATTCCTCGGTCGCGCCGGGGAGGACGTTGATGTCCGGCATCGA +GTCGAGCCGGTACTGCGCGCCCACGATGCTGTCACGCTGATAGCCGACCGCGCCGTTCGT +GAAGCGGTCGCTGTCGCCCATGTCCCGGCCGCGCGCGTCGGCGATCCGCTTCAGCGGGTT +GATGAGGGCACCCGGCGAGCGAAGGCTGGGGTTCCACGACACGGTCTCTCGCGAGAGCCG +CGACGCGCCTTCAAGTCCGCCGCAGCCAAGCGAAGCCGACTGTTCCGGGCGACCGGAAGT +CACTTCGGACAGTTTGCGTACGGTAACTTTGGTCATTGTCAGAAGGTGAACTGAAGGGGG +CCATTGGAACAACCGCCGCCGCACGGGCCGCAGTCACCGCATTGCGCTCCGAGCTGGCGG +ATGTAGGTCGCGAGGGCCTGCTGACTAGCCGTCGTGAATTCTACGCGTTCGCCATTCTGG +TCCTCGATCATGCGGGCCAAGGGGCCGGTCAGCAGCTTGTGGTACGCGTCGCGGCGCCGC +CGCGAGGTACTGCCGGCAGGTTACATCATCGAGCCAGGGCATTCGGTTTCTCCGGTAGTG +GATCACGCCAGCGCGGCGGCGATTTTCGCGAGATCATACTCTTCGCTTGACTTTTCCGCA +AATCTCTTTTCGCTGGCATCCGCAACGAGGGTGTTCTTGTCCCACTCTTCGGCCCAGCTC +GGGGGCGACGACCAGTCGAACGTCACGGTTAGCAGGAGCATCGATCCGCTACCGGGCGTC +ACCACTTCAAGCCGGCCAAGCGCAGTGTCTTTCAAGAAGTTCGAGCTCGGGAACAGGACC +GGTACGTCTCCGCGCGCAGCAGACGATTTGGCCTTGTGGTTAGCGTCCGGGTAGCCGACT +CGCGTGCGCGGATGCCCCGGCTTAGGCTCGCCCTTGATGAGATGGAGACGGCCGTGCAGG +CCTTCTTCGCGAAGCTGCCGGTAGAAGTTGTACGCCATCCCCGCGACACCTTCCCGACAG +CCGGAATCGCAGAAGGTCATTTTGAGCTGCATCACCCGACCGCTGTCATCGTCAAGCTGA +TACATTTTCTCCACGAGCTGCGTACGCACTTCCTGCCTGTCTTCGAGATACGCATGCGGC +TTCACCCACTCTCGGTCTCCGTCGTGATCGACGCGCTGCGACTTGATGACGTTGAAACGG +TCCACGACATAGATGTCGTACGGATCGCCCGGCGCAACGCCGAACACGTTGCAGACCCAC +ATGTTCTTCTGCAGGTCGCAGATACCGATCAGGAAGCGGACAGCCTTCGGAACATGTTTA +TCGCGCAGGACTTCGGCGCGCGCCTTCAGCGTCTCCGCGTACCGGGTCGCAGGAATCGTT +GAAGAAGTTCTACAACACCGACCTCGGGGAACCGTATTTCCATCGCGGCAACGAAACGGT +CCTGCTCCCTCGTAGTCTTCTTCGTCCGTGATGTAGTTGGCGACGAGTTTGCGCCACGAG +ATAAACGCCGCCACGACGCCATTCATCCAGACAGACGCAATGCGCGAGCGTCGCGGCGTG +CCGACCCGCTTGTCCTCCGCCGTCATCGACTCGCCGTCCTTCAGCCAGACGCCCCACAGG +CCGAGATCGTTGCGCTGATCCGCTTAGATCCGGCCGCCGCAGCACGGCGCTTCCATGCGC +ACAGTATCGGCTCACGATACGGCGTCGCCGCAGTCATCCCACTTCAACAGCTTGAAAGTC +GGTTCGAACCAGTCGCCGCAGTGCGGGCACTTCCAGTATCGACGGCGACGGTCACCCCGG +TTGTACAGGCCGAGAATCCCCTTCCATGGGGGCGCTTCGTGCGGCGATGAAGCCAGCCAC +TTTCGGCCGTCTTCTTCGATCTGACGGGACGGGCTGGACTCGGCCAGCGTCATCGCGAAC +GAACCGAACGTCGTGGTCCGCTTCGACGCGAGGTCGAACGGCTCGCCGTCGCCATCAACG +TCGTCCGGCATGCGGTCGTAGTCGGTCAGGCATACGCGGCCGATCGGACGGCCAGCGAAC +TCGGTCACCGACGGCCACGACAGTGTCAAGATCGCGCCGTCCTTGTAGTGCTGGTCGAAC +TTGTTGTCGGTGTAGCGCGAGCGCGTCATCATCGCGCCGATCTTAGGAGAATGACGGTGC +GTACGATCGACCGGTCGCACGGAGAAATCGCGGGCTGCTTAGTTCGTCGGGCAGTACAGG +AACATGTCCATCGGGTCGACATTGACCGTGTACCCGATGAAGTTCAGTAACAGGCGATCA +GTTTTCCCGAACTGCGCCGGGCCGACGAAGACTTCCGCGTCGAAGTCACGGCACGTGAGC +GTGTTCATTGGTTCGACCATGTACGGCACGGTCTCGTTGAACCAATCGCCCATGTACGCG +CCCGGCGTGTTCAGCTTTCGGTACTTGGCGGCGGCCTGCGATACGGTCAGTCGTTCCGGC +GGACGGAAGATGTCGGCGAGGTCGATGAGTACGAGGACTTCAAGATCGCGACAGCGCGGG +AAGCGTTTTTGAAGGAACTGACGACGACCCAGCAGCAGGTCTATAAGTCGCTCGGGGCGA +TGGTCCGTCCCCGCCGTCGCCACTTCATCGGCTGTCACCCGTTGATTCGATTCGTTCGGC +TACATGGTCTCGTTCCGGTTCGTGTTTAAATTGTTCGATAAGAGAGTTGCGCAAGCTCTT +CGACAGTGAGTCGGTCTTCTTGCGAATGATGGCGCGCTGCTCGTCACTCAGTTCGGCTTG +GCGGTCCACCGAGTCGACCATGAGAAGAATCTCAGTTCGCAGCGTCTTAAACGACTCGGC +GTAGTGTTGAAGTACCTTCTCGGTTCGCCAGAGATCGCCCTGTTCTTCCTCGAATTTCAG +GCGCGCATTCTGCCCGCTCCAAAATTCCTTCAGCAACATCGGCGGCAGGTCTCGATGGTG +CATCTTCTTGATGTGTGCCTCGATGTCGCCAACCGGATCAACGAGGTATCGGGCCGCCTC +GGCCACTTTGTAGATCGGGTGTCCGTGGCGCTTCCCGCACGCGGGCAGCCCTTGAATCCG +TTTCGTCACGGTGCGGTTGTCCATGGTGAACAACTGCCCGAGTTGTGAGATAGACGCGCC +ATCGAACAGGATTGCCTTCGATGCGCTATCCGCTCCACTCTTTCCTTCTGCCTTGCCGTC +CTCCGTTTTTGTCAGGGTTGAACATTATCACAAGCCCGCAGCCGTGGCAAGGTTGTCACT +GTTCACGGCTCGCTTCTTCTTGAACGCTGCTCGCAGACGGCGAAGACGCACGAAGAGATC +GTCCTGCGCGTTGTGTTTGCGAGTCAGGCTCGATACCGCAACGTCGTCTACCGTGCCAAT +CATCGTCGCATGGTGGACGTGCGCGATATGGCGCTGGCCCTGCCGGGCGAGACGACCGAT +GAGCTGAAGATATAGTTCGAGCCAGTAGACGATGTCGTAGATATAAAGGTGATGGCCTCC +CTTCTGCATGTTCAAGCCGTGTGCCACGGACGCCGGATGAACGAACGAGATTTGGATCTC +GCCTTTGTTCCAGTCGCCGACAAGTTTCCGCTCGGCGTCCATTACGCGCGCTCTCGGGAA +CGCCTTCTTCAGTCGTTCGAGGCTGGATTTGAACCAGTACGCTACGAGCAGCGGCTCGCC +GTTCAGCTCTTCGACAAGTTGCGTCAGGTCTTCGATCTTGTGATCGTGTACCCAATGCGT +CTTTTTCTCCGCGTCGTACACACATCCGGACGCGAGCTGAAGTAACTTCTGATTCAGCGC +GACTGCGGTTTCTTCTTCGATCTCGGTTCCGTCAGGAAGGTCGAGGATTAAATCCCGCTC +GAGCTTCTTGTACATAGACGACTGTTCATCGGTCATCTTGATGGCGCGCTTCAACAGGAG +TGGCTTATCGACCTTCAGGTAGTCCTCTGCCTTCATCACTAGGCAGATGTCAGCGATCTT +CGACAGGTTTTCGTTCTCGCATCCCGGCCGCAGCTTGTACGTTCGCGCGTAATGGTTATA +TGTGAAGTACCGGTTGCGGTAGTACGTGATGTTGTTGCCGCGACGTTCTCCCTTGTCGAG +AAGTCACATCTGCGCGAACAGGTGTTCATAGGTCTCGGCAACCGGCGTCGCGGTGAGAAG +ATGCAAGCGCATGATATACGGGCGAACGGCCTTCAGCTGCTTGAAACGGATCGAATTGTG +ATCCTTGGACGACGACGATTCATCGGTAAACACGACATCGAAAGGCCACATTTCCCCAAA +CAGGTCGATGAGCCATTGAAGCTGTTCCCGGTTGATGATGTGAAGGCTCGCTGGGGTGCG +CGCGAGGCGCTGAAGGATCTTTTCCTTCCTCACGGCTTTCGCTCGAGCCACGTCTCGTTC +AAGCTCGGGATTCCGTTGCTCGCGGCTGTCGTCGCCTCGTGTTGTGAAGGCCCGATAGTC +GGAGCGAGCGCGTTGTTTCCTACCTGCCTCAGCGATCAGTTCAACTGACTTCTCGTCTTC +CGCGCGGATCGGGACATGGGACATGTACGCCGTGTGCTGTCAGAGCGGAATCTCGTTCGG +CCATGCCTCCGTAGCTACACGCAGCGGCGCGATCACGTGACAGTGCTTGTATGCGACGCG +CGAGTGTAGCCGATCGGGCAGCGTGAGGCAGATGACCGTCTTCCCCATGCCAAGGTGGAT +GAACAGTGCGCTGAACGGATTCTCTTCGAGAAAGTCCACGCATTTGTCCTGATACGCATG +CAGCTCGATCGGCTCGTACGGCACTCCGTGGAACATCTCAGAGATGGTACGACGCAAGGA +TTCGGGTTGCATCTTCATGATTGTCAGCCCAATGAAGGTACGCGCCGTGTCGACGCATCT +CGTCGTGCTTGTTGTACTGGTGTCGCTTCGGGTCTGCATCCTTCCGCTTGAACTCGGTGA +AAACGACGATGCCCGACCGGATATACATTCGATCGGGTACACCACGCTGACCGGGAGGGA +CAAACTTCGCAACAAATCATCCGTTTGCCTTCGCCCAATCGTTCGTTTGGTCTTCTATGC +GCGTCTCCCGTACGGGAGGATCGGAAGTTACTTCCGATTTTTTTGGGATCGGGAGTAACT +TCAGGTCAGTCCTTGCGATAGAACGCGGCCGACCATCCGGCTGCGCCAACAGGCATCTTT +TCGTACCACTTGCGCTTCGCGGTCATGCACTCCTTCAGGACATGCAGCCCCTTCGACGCG +TCGCCGATCCTGCGCAGGGTGACGATTTCATCGTGAACGCGCCACATCTTCGGTATTGCA +GGCGAACGCAGCGCCGACGAGCACAATCGAGATCGTCGCGCGGCAGAACATGCCATATCC +GCCGGGCAAAGAACGATATTGATGGCCTTCTTATGCGCGTTGAATAGGCCGTACTTCAGG +ATTTCCCGTGCGATAGCTTGCACGAGGTTTGCGGTCATCTTACCGCCGTGCGAGTCCTGT +CGCAGCCACTTCTTGACGTCCTGATTGAAGCTCATGTACGAGAAACGGATCTTCTCGTAC +GTCTGCGGAGAGCCGTCTTCGTTCCAGAGTAACTCGCCTGTCTTCCAGTTCTTCTTCTGG +AATTTTTTCTTCTCGATGCGCGGTCGATGGTAGGACATCCGGCGACCGCTCGGCAGGATC +GCCACGAGGAATTCACCGACGATTGCAAACGACACATAACGGACGCACGTGACCGCCTTC +GTCTTGATAGTGCGGATGATAGCGGCTTCGAGGTCCTTCCAGAGCTGCGGGACCTCGGGG +TACGCCTCGCGGTACATCTTCACCGAATCGTGCGCCTCTTGGCCGGACATGTCGATACCC +ATGTTCTCGGCGTAGCCCGACAGACCGGTTCGCTGGCCCTCATGGCTTAGGTCGCCGCCG +CCGAGTCGGTATCCCGCGCCGAGCACGGCCGGTTTCGACATCTTTCGCATCTGCGAAGTT +ACTTCCGGGTACTCGACGCCGTACAGCCGCGTCACGAATACTCGGTACGCGCAGCGCCCT +TCACGGAACACGTTCAGCAGCGGCTGGCAATCCGCCAGCCATGCGATCACGACGGTTTCA +ATCGAGGACAGGTCGCATGTGACGAACTCATACCCCTCCGGAGCGTAGATCACGCAGCGC +AGGCATCCGGCGAGACCGTCCACGGGTTCCTTCATCATCAGGCCGAGCAGGGCGTAATCC +CCCGCTCGGATGGCGTTCGTGACCGTGCAGAGCGCTCAGTCGTTGTCGCCGTCCGGTTCG +AGCGCTTTCGGCGTACGGCCGAGGTTGTGAACCTGAACACCGCGTCCCGCCCAGTGCTGC +GTGCGCTGCGCGCCTCCGAACTGAAGGCGAAAACGGAGGCGCCGACCGGGGCCGACGAGG +GAGACGAACTTCTTGTACTTGCCGACCGACGTGCGTGCAGACTGCATACGCATCTTCAGC +ACTTCGTCCCATCGCCCCGTCATCACCGGTTCGTCGTTGTGTTCGGAGAGGACCTTCTTG +ACGGTATCCTTGCCGAGGTCATCGAAACGATACCCGCGTGCCTTCACCCACGGTTTGAGC +TGCTGCGGACTGCTCGGGTTTTCAAGGCCGGTGATCGCGCGCATCTGGCTAACGAGTTCC +AGCTTGCGGCGATCTGCCATCGCGGTAGCGCTGTTACAGAAGTTGAGGTCGACCGGCACA +CCGCGATCGTAGATGAGCTGATCCAGCTCGTACAGCTCCCATTCTTCATCGAGCGTCGGA +TACGGAGCGAGCCATTCGTCAATGGCGGCTTCGGCGATCACGTCCTGTTGGTTATAGATC +AGGAAGTCGTCCCATTCGAACAGGTTAGTCTGCCAGTCGAGCCACTTGTGGGGGTTCTTC +TTCGTGATGCGTTGCGGGTACGAGAACTGGTTGATTAGCTTCTTCCCGGTCGCCAGTTTG +ACCTTGTCCTGCGGTAATCCGAGCTGCCCGCCGACCATTTCGAGGTTTCCAGCGAACGAC +AGCATGTACGCACGCGCCATCGTGCAGCACCAGTTTTTATACGGCGTGTTGATCTTCAGC +ACACGACGCGTCATCACGCGCTCGAACTGCGCATTCCACGCCCGCTCGATGACGTTCGGG +TCTTCGAGCGCCTCGCGGACTTCCGCCGGGAACTTTCCGTCTCGGATTTCCCATTGCTGC +ACGCGGCCGCCGTTGAACGACCAAGAAGCAATCAGGATTTCAGTGGACTCGTTCGCCGAG +TAAGTGTCGAGGCCGCACATCGGCAGGTCCTCTTCGCTGCGCGATTCGTAGTCCAGTCGA +ATCTCGTCTTGCATATCAGTTCTCCGGATTCGCGAGGTCGAGCAGCACATCGCCGTGGCA +CGCTTCAGGTGCGCAGAAGCAGACGAGATGCCGACCACGGATTGTAGGCAAGAACGACAT +CAGCGAAGGGGAGTTGAGGACGTGCTCTCGGTACTTCGCAATAACCTCTTCGCGCGTTCC +GTCTCGGCCGATCACAAACCGGTAGCCCCACACCGGAGGGCGGCCGATGTAAATGCGGTT +GTCCGGATAGTCGCCTGCGTTCTTGTTGAATACCTGCGGCAATTCAGCACCTCAGAAGAA +AAAGACCCCGGCACGTCGGGGAATAACCGTGCCGGGGCGAACAACCTACGCGGAGGAATC +GGAACCGCGCAGACAGGCGAAAGGAATTACAGGCCGCCGTTGTCGTCGTAGCCCTCGGCG +AGCGCTTCCTCGCCGTCCGACACGTCGTCAAACGAATCGTCAATTTCGTCTTCGCTGACG +CGGCCTTCGCCGATCTGCTCGTCGTCACGAACGAACTGGACCGCAAGCAGGTTCGCGTTG +ATACGCTTGCCGAACTTGTTGTCCTGCCACCACGGGGTGATGAGAATGTTCACGCGGCAA +CCGGCGTAGATGGTGTTTTCGATCTCGCGCTCGCCGAGAAGACGCTTGTCCGCGCCGCGC +AGGCTCGGACGCTTCGTTTCCGATGCATTGATCGTGTAGCAGCCTTCGTATTCGTCCTTG +CCCGACGCGTCGCCGTCGCGGAAGAAAAACTTGTCGGTCGGAATCTTCTTGCCGTCGTTC +TTCTCGCGCAGCATCTCGTCGCGCATTTTCTTCATCACTTCGAGAACGGACTTAGCGAGG +TCCTTTTCGATGAAGCCGACGAGCGAATACTTCTCCTGCCCTTCCTGATCGTCGCCCTTG +TAGGGCTTCGCCAGATGGGGGTAGCACGCCCGCACATTCTCGATACGCAAGGTGCCGTCC +GTGAAGACGACAACGTTCTTGCCTTTGAACTTGATTTCGCGTGCGATTTTGCGACTCCTT +CAGGTCTACCGTTTTACCGGTCTAGGGTTTCACGGTCTACAGGTCTACGGGTCTACAGGC +CGTCGTCCGCAGTAAGGTCGTCAAAGCAGTCAGCGGCCACTTGCCCCAGCTTCTCCCGCG +TCTCTGCGACAGGAGCCAAGGTCGCCTTGCCCTGCGCTTTCGCGACGCGCGGGGCGATAA +TTTTCTCGGCCGCTTTCTTTCGCATGCCACTCGCGACGAGCGGTGCTTCTGCTTTCGCGG +GGCTGACGAAATCGGTCGAGAATAATGCGTTTTCCTTCACGCCAAGGAATGTGAGCGTTT +AAACGGTTTTCGCCTGTTGCACGTTCCATCGGCGATTCGATCTGGATGCTACCAGTTTCA +TGCCGGGGATGTCCTCCCCGTTGTGCACGCGTCGCTCCAACTCGGAGTCCTTTTCGCTGA +ACCAGCGCTCGACTACCTTCCGGTACGGAAGTAACTTCGCCATTTGTTGAGTCGAAAGGT +CGGAAACCGGACGTAACTTCGTGCTCAATTCGTCGCGCATCAGGACTCCCTCACTGCTCG +GCATCAGTTCAGCGGTTACTTCGGCTGTCAGGTCGTCAAAACAGTCGTCAGAAAACCTGT +GCGCCATCGCGAGAAGCGCCGGATAGGTCTTCTGCACCTTGCAAAAACGGCATCCTTTGT +CGGACGGCGTGAGCGGCACACCTTTCTGCCAAGCGAGAAATGCCCGGACCTTCTCGAAAT +CGGTGAAGCGAAGCAGCTCTTCCCGTGTGGTTTCCCACATCTGGAAGTGTGCTAGGCGCG +GCTGCGAGATGTAGATGACGTTCTTACGGAATCCGTAAATCCAGTCGTACTCGTAGTGCG +CGCCGGGCGCATAGAGCATGGCTTGAGAATTGCCGTTGATAATCGTCTTGCCGTTCTCAA +CGATGATCGGACGCGGATCGTCCAGTCGCAACGCCGCGAAGACCTGAACACCACGGCCGA +ACTTGTGGTCGAAGATGTGCAGCACACCGGGTTCGAAGCCGCCCACGTCCATCGTGCCTC +CTTGGCGCGGAATCGGGGTGAGCTGGGAGAAGTAGACGCGCTTCTCGATATGCAGGTCGC +CGGAAAGCGACTGCGCCCATTCGACAGACTGCGCGACGTACTCCATCATCTCCGCGTCGA +TCGTGATATCGAAAACGGTCTTCCCTTCGGCGACCTGCTCAACCGTGCCGAGCAGATGAA +CGGGGCGTATGCCGGTCTTCAACCACGTCTCGGATACGCCGTGCGCGACAGTGCCTTATG +CGGCGTCTTCGCCTGCGTTGTCTTCTGCTGCGAGATTGGCGAGAAGGGACCCGGCGCATG +TGAGCCACATGGCAGACGCACTCGGGGAAAATACCGAGTGGCCGCCTTGCTCGCTGTTGA +ACTTCAGCGCATCGAGATTGATCGCGTGTTCGCTAACGTAGAGGCCCCGGAAAAGTTGTT +CATTTTGAGCGGCACTGACATTGTGTGGTGCACCGTAGAGGCCGGGAACGTTTGGCGGTG +CACCCGCCAGTGCCGCCCAAAATGAAGCCCGGACGAACCGGGCTTCTTCGCTGCACGTCG +AGACGATATTACAGGCCGTCGCTGCCGTCGCCTTCGTCGCCGCCCGCGTCTCCTTCGAGC +GACTTCTCGGCCGCGTCGTACGCGGCGTCGAAGTGTTCCGGCTTGATCGAGGCCGAGGTC +TTCGGCCTTGCCGTACTTCTTGATGATCGCATTCGCGTCGTCCATCGACTTTTCGTCCTT +GACGCGGATCAGGATCCCCTTGACCTCGTCGGCCGAGTGCTTCGGCTTCGTTGCTGCCTT +GCCGCCGCCCTTGCCGGCCGCCGTGGTCGTTGCCTTCTTGCCTTCGGCCGCCTTGCCGCC +GCCCGTACCGCCTACTTCCGCGATTGCCTCCGTGACTGCCGACTTGATGAATCCCTTCAG +GGCGTTTTCCAAGCTCATTTTTCCGACTCCTAGTGATCCGTAGATGGGTTGTTTGTGTCG +TGGCGTTCACCACGGAACGAATCATGCCGGGGCCGGTTTTGTCTGTCAACACCTCTTCGA +AAATATTTCAAAGACAAATGGGAATCTGGCATACTCCGCGCTGTATTAACCTTCATCTAC +CTACATAGGTGGACTAGAAACATGGTGATCCCTATGCCGGCATGGTTCCCGACCGCAGGA +GAGTAACGAGATGGCCGACCAGACCACGGCCACCTATGTTGCGGATCACGGGGATGTACT +GATCGCGTACGGGTACAACATTGTCTCCATCACACCCGGCGAAAAATTCTCACCACACGA +CGGCTGGCAGCAGACAGTGGCAACGCAGGCCAAGTTGAAGACGTGGCTCGCCACGGGTTT +GAAGTACACGAAGAACGGCGAAGATCGGGTCGCCGATGTTAAGTTGGCCGGCGTCGGCTT +CCTGACGAAGAACACGCCGGGCGTCGATATCGACATCTCGGACGAAGGCTTCGCGAAGCA +CCTGGAGAATTTCGTCCATGAGAACTTCGGGATGGTTCCTGTACGCGTCGGCCGCGCGCC +GCGCCCGCTACTGCTCATTCGATGCACCGAGCCGTTTTCGAAGGTCAATTCGAGCGTCTA +TCTGGACGCGTGGGGCGAAGCGCAGAAGGTCGAAATCCTCGCGAACGGCCAGCAGTTCGT +CGCGTTCCACATCCATCCGGACACGAAGAGGCCGTACGAGTGGCTCTACAAGCAGTCGCC +GCTCGACATCGAAGCATCCGAGTTGCCGGTGTTGCGCCGCGTCGATGCGCAGGCCATCGT +GGACGAGATCGAGAAGTAGGCCAAGCTTCGAGGCTGGACGCTGAAGAAGCGCTCGCGCAC +CGCGCCGGAACGCAGCGAGAGCGGCGGGGAAATCGATTACGACGACCCGTTCGGCACCGA +CGTGGCGAAGACCGATATCGGCGAAGACGAGCTGCACGCCAAACTCATGCTCGTGCCGGA +CGCCGATGATTACGAGACGTGGGTCAACGTCTGCATGGCGCTGTTTCACCAGTACGACGG +CCACGAGCGCGGCCTCGAACTCTGGCACGAGTGGTCGGAGACGGCCGACAACTACGACGC +GAAGGAGCTGGACGCGAAGTGGAAGTCATTCGCCATCAGCAACAAGTCGTGTACGCCAAT +TACCGCCCGGTACATCATCAAGCTGGCGAAGCAAGCCGCCGAAAAAACCGCCGAAGAAAC +GATGGTCGCGCTGCAAAAGCTGCTGCTCGAAGCCACGTCGATGAACATGCTGAACTCGGC +ATGCAAGGCGATCAAGAAGGGGACGCTCGACAAGCCGTCGCGTGAGCTGATGGTCACATT +CTTACGGCATGCGTACAAGTGAATCAACGACGGCTCGCCCCGTCCGCTCAACGCTGCTCG +GCAGATGATTCGGTTCGCGAACCCGGAATCGAAGCACATGCCGAAATGGTTGATGGGCTG +GACGTATCTCACGCTCGATGACAAGTTCTACAACGTAAACACGCAGGAGTACATGACGCG +AAGCGCCTTTAATTCGGCGTTCGAACGTTTCCTGCTCACGCCACAGGACGTGTTGGAAGG +CCGCGTCGTCCCGGACACGACCGCCGAGAAGCTGGCGCTCAACCGTCATCAGATTCCGGT +ATGCCGCACGCGGCTATACCTGCCCGAACAGGACAAGACGTTCATCCTCAACGGAGCGCG +CTACGCGAAACTTTACACGGACAAGTCGGTCCCGGAGTGTCCGTCAAAGCTGACGAGCGA +AGCCAAGCTGAACGTGAAGCGCATCCTCGATCACTTCAACATGATGGTCCCCGCTGACCG +CGAGCGCGGCATCTTCCTCGACTGGCTGGCATGGATTATCCAGACGCAGAAGCGGCCGAA +TTGGTCGATCGTGTTGCAGGGTACGGTGTCGGACGGCAAGACGTTCTTCAGCGACATGAT +GGGCGTCATCCTTGGTCCGGAGAATGTCAAGACACTGAACGCCGAGAAGCTCGAAGGGGC +GTTCAACGGCTGGGCTGAAGCATCGCTCCTGAACTGCGTCGAGGAAATCAAGCTGCACGG +CCACGATCGCTTCGACGTGGTCAACCAAATCAAGCCGCTCATCACGAACACGGCCATTGA +AATCCACCGCAAGGGGGTAGACCCGTACAACACGATAAACACCGCCGCATACCTGCTGCT +GACGAACTTCAAAGACGCGCTGCCGCTCGGGAGGAACGACACGCGCTACTTCGTCATGTT +CGGCCGCATGCAAAACCGCGAAGATGTCGAGAAGTTCAAGGATGAGAACCCGCACTACAA +CGGCAACCTGTTTCAAGCTCTCAACGAGTCCGCCGGGGCACTGTGGAAATTTTTACTTGA +ACACGAGGTGAGTGACACCTTCGACCCGATGAACCGTGAGCCGGATTCCACGGCACGCCG +CTATTTGATCGCCATGAACCGCTCAAACGATCTGGAAGCCATCGAGACACTGATCTCAGA +ATCGATGGAGATCGACGTTTCCTCGACGCTCCTGAACGCCACCAAGCTGGCGGACCTGAT +GGTTGGCATGGATTGCGAACTCCCGGAAACGAAGGGCTTGCAACGCGTCCTAAGCGACCC +CGGATTTACCTTCCTCGGACGCATTCGAATCAAGGGGGAGTACTCCCGATACTGGTCCAA +ATCGCCCCAATACCTCATGGTGGACGGGTCGTCCGAGATCGATTTCGACGCTGTTCGGCA +GTACGCCGGGTGCAGTTTGTAGCCGAGGTCCAGATCCGAATCATTTTTGACTTATTCAGA +CCTTGGCCGGTTTCAGCCCCTTCGGGGGCTTTTTTGCGACGGTTGACCTTAGCAGAAACG +GGGTTCTAATGGTCGTGGTCCGAATCGAAGGTCCGAATGTTTTTGGCGTCATTCGGACCG +CGTTTTTTACCGCATTATGAAAAATGACCCTGCTCCGTCTTGTCCTATAAGACTTCCCTT +CCTTCTCTTCTTCTACTATTCTATAGATAAGGTCCAAATAAAGAAGAAAGTAGAATGACC +GTATAGACATAAATCCAAAAAAATTTTCGTACAGAAATAGAATAAAGAAAATGATTCGGT +TCGCCCCTTCGGACCTGCACTTGGCCGGCCATTCTCGTCCTCCCGACCACTCAAGGTCCG +CATGAGTGTTTGTCCGAAGTTACTTCCGATTTCGAGTTGCGCAACGCAGATATCCCGAAC +GAGATCGGAACCGAATCGCGGGATAGGGGATTTGGACCTTGGCGGGGCGGAGGGGAAACC +CGGTGTCGCGCAAATCTTTTCGCGAGAACTTCGGGGAAGGGCAGCGGCGCTATGACGGAA +AAACGAAAAAACGGGAAATCGGGGCTCTGCGCCCT diff --git a/example/fna/NC_005091.alt2.fna b/example/fna/NC_005091.alt2.fna new file mode 100644 index 0000000..6b6c8f4 --- /dev/null +++ b/example/fna/NC_005091.alt2.fna @@ -0,0 +1,1063 @@ +>NC_005091.alt2 length=63696 tani=96.707 alt=sn;du;tl +GCTCTGCGCCCTCCCGCCATTCGCGCCTCGCCGGATGGGACCCCGTCGGCCGCCCCGAGC +GATCCCCATCGGGCCTGCGCGCCAGCCAGTGACACGGAGACACGATCAGACGAATCGTCT +AGTGACGCGGCGACACCAACACGCAGCAGCCCGCCGCGTAGCCTGTATGACCGAGATACA +GGCATGCCGTCATGCGTGCGCACGGCCGGCCAATGCGGCACTGCACGAGCGACACGGAGA +TACGGCCATGCGTTGCGGTCACGCCACACGCGGCAGGCCGTGAAACGGGCAATCGGGGAC +TCGGACCTAGCTGTGAGACGCGCTGCGCCGTACGGCCGATGACATGCGGCCTAACTGGAT +CGTGTGGATTCGGACCCATGATCACGAGTCGCACGCTATGTGATTGGCCGGGTCTTGCTG +GGTGGGATTTCCGTTACGCTTGTGCGTGCGATGGTTTGAGGCGGGGCAGGTTTGGGGCTT +GGCGGGCGCGCTAAATGTCCCGTTGCGTACCTGGGCTAAAAGCGGACATTCTGACGTGCG +GTGCTGCGGGCGCGCTGCTGCGCACCGTGTGCGGGCGGGGCGATGGGCGTAAAAAGGGGC +TTGGCGGGCGCGCTAAATGTCCCGTTGCGTACCTGGGCTAAAAGCGGACATTCTGACGTG +CGGTGCTGCGGGCGCGCTGCTGCGCACCGTGTGCGGGCGGGGCGATGGGCGTAAAAAAGC +CCGACACGATGGCCGGGCGAGGGGTGCTACTGGATGGTGTGGGTTAGCCGTCCCGTGTGT +GACGCCCGCCTTTTAGGACGATTTGATACCAGTACCCACCGGTGCGGAGGACGTGCGGCT +TGTCCCCCGTCAGCACGCGATGGGCTGCCTTAGCAATCCACCATTTCGGGTCGTGCAGCT +ACTCGAGGCGCAGTTCGGCGGGCGTTCGCCGTACGTCGAACGCGTCAATAGCGCTCGTGC +CGTCCGCATCATCGGGGTCGTCAACCGCTATCACGTTTTTCACCATCCTGCCGGGACTCG +CGCTGAACACGCGCGGCACTCTTAGCTATCTCGATCCGAGCATGCCTGCATCCTTAGACG +TTGAACACGTAGCGCACGAGCGCGACGAGCAGGCCAATTGCGAACACCACGAGCAGCAGG +CATAACGCGCCAGCCACGGAACCGACAATGTAGACGGCCGCGTCGGGGGCGTCTTCGTAC +CGCCTGCGCGGTTTGAACCGCAGGATCTCCGGGACGATCAACGCACCGATGACGAGCGAT +GCCAATCCGATCGATGCTGCCGTGTGATTCGATATTCCGCCGTCATCGGGTATCGGGTAG +AGCCGGTCGACGCATTGCACGTAGCTCTGCATGCGGGGCACGTCGGCCGTGCGTGAGTCG +TACGAGTCAATCACGGCTTGGCATGCAGCACACTCAGCTCGATCGGCTTCTGCCGATGTG +ATCGCCGCGTTCGTGGCGGCTTGCCCGTTGAGCGCGGCACTCAGGGCAACGGTATCAGTT +GGCATTGTCGGCCCCTGCGGTGCGTGTGCCGATATGCAGGCCGACGGTCGCGCGGTTCCG +CGTATTGCGGATGAGTGGAACCTGTTCGACGGTCAGGCCGGCACGCGTTGCGCTCGATTC +GTCGGCTGTCACACTGGCCGTGAGACCGAATTCGTTGAGCTGAACTAGTGCCGCGCCGTA +TGGCGACGATTCGTATTCTTCCAGCTCGCGCAACCAGTCGAACGAACACGATTCGTCGTT +CCAAACTTGCGCGCCGACTACAGGGGTGCACTGAAATCGGCCGCCCTTCATCATCACGCG +GCCGAATTTGGTCGGGATATCGGACGGATGCACCTTGCGCATGTCGCGACGCCAGATAGA +GCCAATCTGACGTACGGGCAGGTCCATTTTCGCGACCGGCATTGCGGCGATCATCTCAGC +CATCGTCGGCTCGCGGCCGATCACCCGGCAAGTGATATCGCCATTCACGAGGGTCGATTT +TCCCGTCTTGCTTTCGAACGCGCGGGCCGCCAAGCGTCGCGCGATGCTGTCAAGATCGTA +CTATACAGCGACCGTGAAAACTTCGCCGTTCGCACGGTGCGAGTAGCTCTTCGTAATTGT +GTACTTCGCCACTGTCTTTCTCCTTCGTGTTGCGTTATGCCAAACGGCCGTAATTGCGTT +CGTGAGATTCGACGTAATCGCCAACCGTCGTAAGGCGGATGTTGCCGGTTCGGTAGTCGC +GCAACAGCGTCGCGTTATAGACGTCGCCTGTGTTGACCTACGCGGCGGCCGGTTCGTCGT +TCCGCTCGTGCCGCAGATATTCGACGCCGTGAACCTTGATGAGGCGATTGAGCGTCGCCA +TGCTTGTCCCGCTCCGGATAGCCGCGCGCACCACGGCCGCGCGCTTGATATCGAGCCGCA +GTTCGCGGGCCAGCTTGGCAACGCTCGGCGCGCGTTGCACTGGTGCATTGTTGGTCGTCA +TGGTTACTTCCCTTCGTACATAATCGTTCGCGGGCCAGCTTGGCAACGCTCGGCGCGCGT +TGCACTGGTGCATTGTTGGTCGTCATGGTTACTTCCCTTCGTACATAATCCGGGCAGTGT +GAAATGAAATCGCCCATGCTTCGCGCGCGCTATAGCCACACGCTCGATGAATGTGATACC +CGCCGTTTGTCGCGTCAGCGACCGCAAGCGCGGTGCGCACGGACAAATCGTCAAGCGACC +GATGGTCGTGCATGGAGGCGGTAAGGCTGGCATTAATCGACCAATCTACGCCGTTCAGAT +AGAACGAACGCCAGCGCGCCGCTCCGACCGACGCCTCGCGGAAACGGTAAACCGGCAAAA +CTGCACCGTGCCGGGCAGCGACATACATAGTGGCTTCCCCCAGCGACGCGCGGCGATTGA +CGGCCGTTCCATCAATGACAATCGCCCACGGGCGCGATGGCGACGATTTAGGGTCGTACG +TGAGTCGAGCCGTACCGGCCCAGCTACGAAAGGTTTGTTGATCGCGCCACACGGTTAGCC +CCCCTTCCGAACAGCCGCATAGAAAGCCGGCGTTACGCGGTCGATAAAGACGCGTGAACT +GGCGCAGGAATTCATCGGCCAGTGCGTCAAGCACTTCAGTTGTGATGTCGTCCGCGACAG +TCCGGAAGACCTGATCGACGGACGGCCCGTATAGCAGGTAGACGTTGTTCGACAGCTTCG +TCGCGCCATCCGTCGCGTGCAGCGTTTCGCCGGGGCTGAGACGTACAGCAAGCCCGAGGA +CCGTAGAGTTCGCGGAACGCCTTGCGCGGGTTCGTGATTTACGCCCGGTCTTCGGGCAGA +TACATCGCGAGTTCGTCTACGGCAGCTTGAATCGCGACTGCACGCGCAGCGTCGACAGCA +CCGGTCGTCGCTTCCGCCCACTTGGCGATGCCGCGCGGATCGCATGCAGGGGCCAGGTCT +ATCGGATCGCGAGCCGTAGAACCGCGCCCGCGCAGTATCTGCTACGCGGCCATGCGCATT +GTGTCGTGCGTCGCGTGACGGGCGCGCAGAAGCGCTGCACGGGCGTGATTCGGCATGATA +TGCGGAATGCAGCGGCTTTCCAGTTGGCGGCCATTCGGGCGAGCGATCATCACGTCATAC +GCGCTCGTATCGTAACGCAGCTTTTCCGTCATCGGAACACAAACCATCGTCGTGCCAAGC +TTCAGCACTTCGCGCGAGTCGCGCAGCATCGCATGCGCGATCTTCCCGGCGTCCGGGCGT +GCGGCTTGCGGGCGATTGTGTACGGCCATGGCGACGATGATTTGCTCACTACTCAGGATC +GCGAGAGTATCGGCTAACAACGGCTCGTTGTAACCCATCAGGCGCGGCACGAAGGAAACC +AGCAACACGCCGTGACGTGATTAGTCGAGTGCTCTACGGCCTTCGATCTGCGTCCGGTAG +CTCGCGATGGTCGGCGCTACGGCGTCGCATTTCGGGGCGAGCGCGACTTCCTCAATCGCG +AGATACGCGCCGCGCGTTTCGAGATATTCCGCCGGATTGGCGCGGCCGTATGCCCTGCAG +AGGCGGCCGTCGCTGGGGCGGGGGGCGTTGCGGACGATGTAATCGAACGACCAGCGGCCA +TTTACCGCCGGGGGCGTCCCGATGACTTCCAAATGGCCGACACGGACCCGGTAGTGTGGG +GCGGCTTTGACAGCGGCTTGAACCTTTGCGAGCGTGATCATGGCAAGCCCCTTAGGGTGC +GTTGCGGATCGATTCGACAGCGGCCAGTGCTGCGTCGCATGCGACGTTGAGTCGACGGGC +GAGCAGGACGGAATCGAGATGACGACAAGCGCGGATATTCGCGAGAAGGCGGCGGAAGGA +AAACAGGAAAGCAAGCATGGTTAGCTCCAGTGGAATCAGGGCGCGCGGGGCCGCGATCCC +GTGAATGAGATTCTAGGCGATAAAGTTAAACCTTGCCAAGCTGTTTTTAGAGTTCGGTGT +CGTGATTGTGATGAGGGAATGGCGCACACGGGATCGGCGCGACTCGCGGGATAACGAACA +GCCGGACGAAGCATGAGAACAGCCCGGAATCCCACAAGCCGACAGCCGCCCAAGCGATGC +CCGAACCGAGGATGAGGTACGACACGACCAGACGGGCGCGCACGCCGGCCAGTGCGACGG +CTTTGCGCTGGGAAGGACGAAGCATGAGAACAGCCCGGAATCCCACAAGCCGACAGCCGC +CCAAGCGATGCCCGAACCGAGGATGAGGTACGACACGACCAGACGGGCGCGCACGCCGGC +CAGTGCGACGGCTTTGCGCTGGGAAACGCGTGGATGTTAAACAGCAACGCGGTTTTTCAT +GACGCGAGTTCCAATCATCAGGATCAGGGACGCGCCGGCGATCAGGCTGCACGCGGCAGC +AGCATCAAGCCCTTCAATCGCCATCGTACGGCGCTCCGACGATTTGTTTGCAGCCGGCCG +CGATCAGGTACAACCAGCCACGGTAAAACTCGCTATCGACGTGCCACATGTGCCAGTCAC +GGCGAACGAACGCGAGCGGCCGATCGACATGCTCGCCGCGATCAACGAACCCCGCACCAT +GACCGACGCACGTCAGATAGATGTCCTGACCCAGCGTGGCAGCCGGATCAAATCCGCAGT +CAGGGTGCGCCCCGTAACCGTTGGTCGCGAGCATTGCGGCGACCGTTTGCGGGTAGCGCT +CAGCGAACGCATAGACGAACCGGCGCGCTGTCTCGCATGAGGTGCTACACTTCGCGCCGA +GGTCGAGAGCACGCGCAGCGGCATTACGTGTTACCAGAAGTACGACTTCACCTTCACCCA +CTGGCTCACGGCAGATAGCGGCTGGGGCTTGAATTGGGGTAATGACTTTGGAGGCCAATG +ATGGCAGAAGCACAAGGTAAAAATCTCGGCGTCTGGTGGGGCTGGGCGGACGGAGCGTCG +GGCTGGGGGACGACCACGAACGGCTCGCTGCAGCTTCTCGATACGATCGTGCAGCTTGGC +GTTTCCGCTGTAGCGCGCGGGCGCGAGCCTTCCGGTGCATCCGCCCAAAGAGCGGTGATG +ATGAAATGGCGGGTGGCGGTTTGGATATGTTCGTGCGGCAAGCGGAAGACGACATCGCGT +ATCGTGTCGCCATCGCCGTGTTCATCGGCGAACCATCCAGTATGGTTGATGCACGCGCCT +TCTACCTCGTCGCACCATTGCCAGCGCAACCCCGGCGCGCCGTCCGATTCCAAATAGAAC +CCCTTGCCTGTGCTGTCCGGTTTCGGCGCATGGTAATACTCGCCGCACGGGTACGCGTTG +CGCTCGGCAATGCTCGCAAACTGTTTCGGCATGCGTGCGATGTAGCGCGGGAAATTGAAG +CCGGCAAACGTGAATTCCGGTGTGAGAGGCGAGAGACGATTCATGGTGATATCTCCGTGG +GTATCGGAAAGGTGAAACGGATTCAGTTCGAAAGCGTACCGCCGTTCGCGCACTTGATCT +CGTAATGAGGCGAGAGACGATTCATGGTGATATCTCCGTGGGTATCGGAAAGGTGAAACG +GATTCAGTTCGAAAGCGTACCGCCGTTCGCGCACTTGATCTCGTAATTGAACGGGAATTC +GCTGATAACGTCGAGCAGCAAGGAAACCGCTTCGTCGGACAGCGGATTGCGCCAGCCGAA +ACAATGCCTGCCCGTGTGAGCGTAGAACATCCAGTTATCAATCAGGTTCGGGACATGCGC +CAAGATCCAGCGGCCGGCGTCTCGCTTTTCCAGCGCGACGGCGCACTTTTTCACGTATTT +CGCTTCACTCCGGTCTTTCTCTTTCTCGATTCGAGCCTTGTCGCGTTCGGTCGCGCCGTG +CAATTGTGCTTGCTCACAGAGCGGCATCAATGCCACGCGTTCCGCCTTGCTCAGTGTCGG +GCGCTTCGCTTTAGACGACACGGGTAAAAGGCGAGTGAGATACAAATCGTCCGGCTTCAA +ATACTGCGTTCCGTGGCACGACGGACACAACGCGTCGCCGACCGCGCGGTCTTCCTGATG +GCCGCAGGAGCCGAACTTAACCGCATGGTCGAGCGCGTCGCGAATGTCGTCCGTCACGAG +AAACCAATAACCCTCCTTGATCCGCTTGTTCGGATACTCGTACTCCGACCAAGGGAACAG +ACTTTTTGCGCACAGGGTTTCGCCGCCTTCCGTGTCGGACGTGTTCCATTGGTCGGAGAA +AAGATGAGTCGTATCAAAAACAATCGTCTGACCGTCGCCCGCTTTAATGTCGCCCATGAA +TGACTGTTGCTGCACTTCCGTGCGGTCGTACTGAAGACCGCCCGACACGAATCATTTGCT +TTCGCCGCGCGATTCCAGCATGGCGCACATGTCCGCGTAGGCTTGCGGCTCGTCAGGCTT +CTCAATGTTGAAGCAGTAATGGTTCAGAGTGGAAGTCAGGCGCTTCATTGTGCAATATCC +GTTGAAGGAAGGGGCCGGGCCAAAGCGGCACGGCATGACTGAGATTCTAGGCGACAAAGT +TAAACCTTGCCTAGCCCCTTTCCGCATTTTCTTGCGACCGGAAGAAACTTCCGACCCGTC +AGGGCGGCGCCATCAGCCCAAAATCCCTGCAAACCCTTGCCCCGTAAGGCTCTTAGGCCC +CGCGCCTCCGGTCGTCTAGGGGTAAACCCTGTGATGCGCCGCCGCAACGCGCCCGCCAAG +CGCGGCGCGGCTGTCCCGTTTTCTGCGCCACTCGTCCGGCCGGGCGGCCCGCCGATATCC +CGTACTGACGACCCCTCGTGCTTACTTTGGCGGCCTCGCCCGTTCACAATTCTTTTAGCC +CAATCGAGAAACGACCCACCCCATCGGCCTTTTGCTTACTTCGGGAACCGAGCCGGACCC +CCGCGCACGGGCCGCGTCGAACGAGCCGACCGGGGGTTACTTCAAAACCCTAGCCGGACC +CCCGGTCTCCGCCGTTGACAAAGTTAAACCCATCCCCGAGAATCCGCGCGTCGAACCGAT +CAACATTTTCGCGGAGGATCACCATGGACACCGCCGAGACCCTCAACAACCAGCTCGACA +GCTTTGCCTCCCGCGTGCTAGCGCTCGAAGTGGGCGAGACCGAATCGAAGACGTGCCGAC +TGGATGGCAACGCGGCGACCAAGGAAGTCATGGCGGCCACGCTCACGAAGCTTCGCAATA +GCGTCGCGGCCGCCGTCAGCCGGGCGTCTTCGAAAACCGGACACGTCTTCATCACCGAGA +CCGGCGACATTCGCACGAAGAGCTACGACTTCCTGATGACGGTCGCCGTCACGCGGAAGG +CCTGAGGAACGCCGTGGACTTCAGCGCGGACCACGCGCTCGTGCAGGCGGCGATCTGGGA +AATGATGCGGCAAGCCGGGATGACGACGTGCAACGTGTCCCGTGCGAAGATGAAAGAGTT +GCATCAGTCGCACACGATCGAAACAGCGTACGACCTGAGCAGCGGATGGACCGTGGCGCT +GACGGCCCGCGCCCCTGAAACCGAAAACGGAGGACCCAAACGTGAAGACGAATGATTGCA +ACTGCGGTTCCGCCGACTGCTCGGGCAAGTACGCGATGAAGGGCGGCGCAACCGGTCAGC +AACTGGCGCACGAGCTTCACGGCTTAACCATCGATCCCGGTCGCACGATAGCGCAGCAGG +CCGACTAACTGCGTGCGCAGGCGGCGCAGATGAAACAAGACCAGGCGAGCCGTTTGCTGC +GCAAGACGCTCGACATGGTTTGGCCGAAGTAATCATGCGCGCCGTCCGACCTCCAGCCCG +CGCCGGAATCCGGACCTTCCTGAGCAAGATGCCGGTCGGCGCGCCATACGTCATCGCGGG +CGACACCATGGACAGTTACAACGCGAAGACTTTCCGCAAGGCTAACGTCGAACTCGGGCT +GCCGATTCGCAGTGTGGTGCATCACAAGCATCCGACCCCCGGCATGTCCGGCATCGAGAG +CATCCGCCTGCCGGTCGAGAAGTCCGAGCGGCGTATCGTCTGAATCCCCACGACGGCGGC +CGAATAATCGGTCTCCCGCTGCAAATCCGGGCCGCCATGCTGCTCGGATGACCTACCCCG +CTACTACCCCCGCCAGATTTCCTGCCGTCCCGCCTGAAGCCCCATACGCCTGCCGCAGAC +AAATATCCTTGTCTGGCAAGGCTCAACGCTCGGCTCCCCCACACGAAGTAACTTCCGATT +TCCTGTTATTTTTGTTGCACCGTTCGAAGGAGTGTTGTACAGTTCCACTTGCGCCTGGCC +GCAAACCCATCAACCCTTTGAACAAAACAACAATGACAGTCAGATTTACACAGGAGAAGA +ACGTCACCATCCTATGGGATGCGATTGACCGGCATGGCCTCCGATGCCACATCTCCCCGG +ATCAGGGGATGTTCAAGTTTAGGGAACGCAGCAACCCGACAGTCTACTACTTCCCGCAGC +GCATCCGCTACAAGATCGCCGGGCAGCCGAAAGATGTTCACATGAATACGGCTGACTTCG +CGTGCTGGTATATCGGCGAGCATCTCGGTCGGTTGATCGCGGGCAAGGCGATGCCGTGGC +TGCACCGCGCAGCCAGCGACGGCAATTGCCGATGGTGCAGAGAAGATAAGAGCACGGCCG +GCCCGCTCTGCGTCGCATTCGAGCATCACCGCGAACGCCATCGTTCCAGCGTCACCGTAG +AAGCCCTTCGTGAAGAGCAACTCCAACTGCAAAACGACGACCAAGGAGCAGCGCCATGTT +CAAGCAACTGATTGCCCGAATGAAAAGCGACAATAAACCCGAAAAGGTCGCTAATTATTT +CCAAGAGCTGAAGGACCGGCAGCACGAACTCGAGCCGCAAGAAGACAACATTGCGGCCGA +GCGGCTGTATATCGAACGCGAACTTCCGCGACTCGCCGCCCGACTGGCGGAGATGGAATG +GGGCGGCGAAGACGCTGTTCAACGTTCGGCCATGGTAGGCATCCGCAACGTCATCATAGC +CGGCCACCAACCGGACAAACCGATCATCGCGCAACCCGGCGTCGGCAGGAGGACCACGGC +ATGAGCATTCACTTCGTCCCGAAGCTGCGCGTCAAGAAACAATCGAACGGGGCAGTACAC +GTAACGGTCGATATGAAGATGCTCGAAGCGGGCGGCCATGAAATCCTCTGGAATTGCGCG +GTCATGCAGCGCATGCGCGAGTCGGGCGTTCCTATTATGGGGCTGATTTCCATTCAAGGC +GTCCGCCACGGCTGCCTCGTTCAGACCTACGACGAGTGCTTCATGGAGCACGTCTACGAA +TGGAAGCCCGGCCCAGATTCGCCCAAAGAAGTTGACCCGGCAGCCGGTTTCTGACCAACA +CACTATGGGAGTACCCATGAGCAAGATCGAGAAGGCCAGTGTCACGGTCAGTTTCAAGAC +CGACAGCGGCTACGAATCGGTATTTGGCGCGCAGAACAAGCCGGGCATCGACGCACTGAA +AGATGGCCTGCACGAGATCGTCCGCGTGCTGACCATCAACGGCAATGTCGCTACCGTCGA +CGCCGTCGTGAAGGCGGCCAAGCGGCGGGGAGAGCGCGCGGTTCTCACGCGTGTCACGGT +CAGTTTCAAGACCGACAGCGGCTACGAATCGGTATTTGGCGCGCAGAACAAGCCGGGCAT +CGACGCACTGAAAGATGGCCTGCACGAGATCGTCCGCGTGCTGACCATCAACGGCAATGT +CGCTACCGTCGACGCCGTCGTGAAGGCGGCCAAGCGGCGGGGAGAGCGCGCGGTTCTCAC +GCACGCGACGGCGCAGGTCGAGCAGCAATCCGAGGTCGATCAGCGCGCAGGCTACAAGCC +GCCTTCCGATGACCTACTGAAAGCGTTTAACGCAGGCACGCGGCGGGGAATCATGAACGT +CTACCGCCATATCCTCCGCGAGCATCCGACCGCAACCGGTACGTGGTGTATCCGTCGCGC +GAAAGAGATATGGGGCCATCTGCCGCTCATCGCGCTGAACGCGGAGAATCGACCGGGCAT +CGCGGAAATCTACGTGGACCTGCGCCGCGCGAATCCGCAGTGGTCGATATCCGGGCTGCT +ACGTGAGGTCGAGCGCCAGTGGAAGGAATCGCAGGAATCGGAGGCGGAACTGTGAAGACC +TTTCAACTGAATGCCGATCTCGTGCGCTGCGCTGCCGCGTGGGTGTACGGCGGCGATCCT +GCGGCCATGAAATACCCGGCGCTCAATCGCATCCGCATCGAACCACACCATCTGGAAGGA +ATCGCAGGAATCGGAGGCGGAACTGTGAAGACCTTTCAACTGAATGCCGATCTCGTGCGC +TGCGCTGCCGCGTGGGTGTACGGCGGCGATCCTGCGGCCATGAAATACCCGGCGCTCAAT +CGCATCCGCATCGAACCACACCATCCCGGCGCGATGATCATTGCGACCTGCTCGCACGCC +ATGTTCGTCGCGAACGACCCGGAAACCGTCGTGCCGGAACCCGCGCTGATCTCCGGCCCG +CAGGACCTGCTCGACGCGGGCGCGCTTCTCGGCGTCAATACGACGGGACGCGAGATTCGC +TTCTGGGGTGCCGGAGTTGCCGTCCATGCGCGCGGCAAGCTGAAGCATTAGTCCCGGCTC +GTGATCGACACGCAGCTCCTGCGTGGCGTGATGGCGCATTACGCTAACTGGCGTGCAGCC +ATCCCGGCGAAGATGGATTTCATGAAGGCGAACCCGGCCATCCCGACCATGATGGACATG +GACTTCCTCGGCCGTCTGGGCCGGATGTTGGAAGGCTTGGGCGAATACCGGCAGGTGTTT +TTCGCGACGTGCGGCTAGCAGTCGATCACGCCGGGTGACGGGCAGCGCACCGACTACCGG +AACTTCTTCGCGTTCTTCCCGTGGAAGCGCCACGTGTTCCTCCTGTTCGCGCCGATGGGC +GGCATGCCGAGCGCCAAGGATTACGGATACCCAGAATGGCTCGAAGACAAGCCGGACGAA +CCGGCTGCCGGCCTCTGAAGTAACTTCCGACCGATTATCGTTGACAAGGCTTAAAGTTAT +CACGATACTCGGTTTCACTTTTCCACGAAGGAGTTTGAAATGAACGAACCGAAAAACGAT +GGCGTCGATCAGCGCGCCTACGCATATGTACCGGCTTCCGTGCTGCTCGAAATGAAGCAG +TACATGGACAAAGTGTCGAAGCTCTCGAAGGTTCCGGCATCGGCTATCGGCCTGAAGGAG +CGCGTCAAAGGGTTAGTTGCCGAAGCGAAGGAGCACGTCGCGACGGTCGACCTCATCGAA +TACGAAGTAGGGCAACTGGTCGGGAAGTATTTCGAGAGGATCAATTTCGAACTTACCGGC +GATGTCGTCGTGAGGAAGACCCGGGAGTTCAGGGGCGACCTCGGCCCGTTCAAAGACGAA +CTTTGCCGCATGATGCGACATATCGCGTTTAAGGTCCTCGGCGAGAAGATCGAACGCGAC +GATGCGGCCGCCGTGTCGAAGCTAGAACGCCTGTACACGCACATCGACGCTGTCGCGGCC +ATGCTAGCGAACGACGAATATGGTGAGCCGCAGGGGACTGGCGACGAGAAGTTCGACGCA +CTGGTCGAACAGATTACCCGTCTGCACAGCGATCTCAACGAGTCCGCGCAACTGATGGTG +GAATATGGTGAGCCGCAGGGGACTGGCGACGAGAAGTTCGACGCACTGGTCGAACAGATT +ACCCGTCTGCACAGCGATCTCAACGAGTCCGCGCAACTGATGGTGCCGCTAAGCGCGTCG +GCCGAAGCGGAACTGGCGAGGATCACTGAGCAACTCGAAGAAGCGTGAGACGACATCGAG +AAGGGACGCGGCGTGACGCTCGACGTGGAAGATGCCAAGCCCATACATCGGTTCAAGCAG +TTGTACGCGAAACTGTTCATCCAGTGGCAAGAAGCCACGACGCATCGCGACGACGCCGAA +GGTCGCCTGAATGCCATCAACACGGTCGTGGGCCAGATGCGGAAGGATGTCAAAGGTGAC +GGCGCGCTCGCAACGGGCGTAGTCTACGATTACAACCTACTGAACGAGATCCGTGGCTTG +GCGCACACTGTAATGATGAGCAAGGCGTTCGGCTACGGAAAGCTCGGAGTGCGGCACGAG +ATCGGCATGTTTCACAATCACGTTCTGCCGCGCGTGCGCAGCCCGAACTACGTGGGCGAC +CCCGAACTGATCGACCAAATTCTCGATGGCATCGCACTGGTTGGCTCCGGTTCTGCGGAT +GCGTTCGATACGGCGCAGACTAGCGGGGAAGACCCGCTGTCGCAGGTGCCGCTCGACGTG +TTCCAGCTCAAAGCGCGCGTTGTGGCTGTCGCTGACAGCTTCGAAAAACACAGTGCACGT +CTGCACGACCATCTTGGGATGAAGTGGCGGCTCATCGAAGTAAAAGAAGCGCTCGGGCTG +CCGTTCGCGAGAGATATGGTCCGGGTCATCGGCGAAGCTGACGACTTAGCTTCCGTTCCG +CACGATCGTGTACGGGCCGTTTGCGTGGTGTGCGAAAATGTCCTTGCAGCCGTCCGGGGG +TTTGATGACAAAGCGCTGGGCGCTGCCCGCACGTGCGATGAAAGCGCGGGGACTGTTACA +ACGCTAGAACCGGACGAATTGCAGGGCGACGCGCTACCTCTCGATAGTCCGAAGAGCGGG +AACGCGATTCGCGTGCTGACGGAGCAGCTCCGAAAAAGGAATAGGCTTCTCGGCAACTTC +GTAGACATCCATACGATCCTCGAAGAGCTTCAGGACGCGATGCACGACATCCTGTTGGAA +CATGAGCCGAAGCGCCCGGACGCACTGCAAAACGCATGGTTTGCGGATGTGCTGAAGTTC +AATCTCGCCGCCGGCCGCACGATCGATGACTTCAACCCGCGCATGATCGGCTTGCTCACC +GGACTTCAGTGCGAAGAATTCGGCGAGAAGCTGCGCCCGATTGTCGATGGCACGGTTGCT +TCCTGCCTGTCCATTTTCGAAGGCATGCCGCTCGTGTCGCTCTGCAATCAGTTGAAGTGG +GTCTGCGACCTGTTCAAGCAGGATGCATTCGACAACGCTATTGATCGTGCTGTCCCGGTC +GAACTGGCAGACGGCGACATCGACCAGATGGTCGTCTCGTTCGGCTCGCTTCATTCGCAA +GGCGTCTCGCTGTACCCGATCCCGCCCGCCGTGTCGGACGCGAACCTGCGCAAGATGGTC +AACGGCAAACTGCTGTTCGACAACAACGGGAAAATCGTCAAGCCCGATTGCTGGAAACCG +GCCGACCTGCTGCCGTTCTTGCAGAAGACTAAACAACCTGCCGAACTGCACATGGGTCCG +TCCGACGAAGCCGGGAGCCTCTGACACGAGAGTGAACGTCTATAGTCAGGAACTCACGTC +GGGATTAAACCCGGTGTACAAGGAGTCAAATACCGGCGTAATTTACAGCGCGGTGCAGTT +TGTTTTGCATTCGAACGACAGACTCCATCATCCCGACCCGGATGGCGACGACGATCGGAG +CGCCGTAACTTTTTGGCTTCCGAAATCGAGAGATCGGCGCGAGGCATTCGCGCTTGCTCC +GGATGGCGACGACGATCGGAGCGCCGTAACTTTTTGGCTTCCGAAATCGAGAGATCGGCG +CGAGGCATTCGCGCTTGCTCTCGAAGCGGCCGCCACGATGGTGAGAAACGCCGCGTCTGA +ATCCGGCTTGGACTCTTAATCGTTTCGCCTCCCTTCGGGGCGGCTTTCCTTCGAGAACAC +CATGTACGCGAACAATCGCGACAACCACGGACTCGCCAACGAGATCGAAACGGAGATCAA +ACTCAACGTCGAGCTCGACAACTGCTGGCCCGGCACGCCGCACTTCATCCTCTGCCACAG +CCGTCAGGCCGGCTGGGAGATGGCCGAGCGGATGTCCAAGGTCCTGTCGTTGCCCGGCGG +CGCGCCCGTCACCGTGCCGTACGTCAGCACGATCCCGGAAGCCATTCAGCTCCTGCAAGG +GCTGACGACTCATCCCGTGGTCGTGTTCGCGCCGGCCGTCGTCTTCCTGTTTCCCGGCTG +CGGCGGCGCGCCCGTCACCGTGCCGTACGTCAGCACGATCCCGGAAGCCATTCAGCTCCT +GCAAGGGCTGACGACTCATCCCGTGGTCGTGTTCGCGCCGGCCGTCGTCTTCCTGTTTCC +CGGCTGGGCGTGCCCGCTCGACCAGCCTACCAAGCTGCATGCCACATTCCCGATGCACGA +CGCAGAAACGTCGCAGTTCATGAGCCGCTTCAACGGGTTGAACTCCCGCGCCGGAAACAC +GAAGAGAGTCTCATGGAGCGCCGAAAGTCGAACTGGCCGGATTACGAAGACAGCATCGCG +CAGCTCTGCGCGTCGTTTTGGGCCGGGGCCGTCGCTGGTAGCTCCCCGGGCACGAAGTTA +CTTCAGGCCAATGAGTACGTGATCCCGAATCCCGAGCGGATCGCCACGTCACTGCACGCG +CAAAACGTCGGCAAGACATCGGTCGTGCATTCTATGTTCGCGCTCGGCGCGGCGGCAACA +GTCAAGCGGGCGAAGCCGTATGTGCTGCCGGAGGGGTTCAATACCCGAGCACCGTTATCG +CCGTTCCAGCAACTGATGCGTTTCGGCTACGCGGAATACTGCATTGACGATTTCGCGCGC +GAGAAGCTCTCTCGGGTTCTCTTCGACTCGAGGAGGCGCGAAGCATTCGATCGCGTCCTG +CGCCGCAACGCGTGTCAATCTACGACGCTCACCGGTCTGTCATGCGGCCTTACCGGCCTC +GAGGTTGGCTGCGCCTGCGGGGCGTGACATGGGCGGCCCGCACTTCTTCCGTGACGGCTC +GCAATTTACCGGCCATCAGGTCGTCAATTTCAGCGAGCAGAAAGAGCAGGGGAAGGTGCG +CATTCGCGCGCGGTGCAAGGAGTGCAACGGCCGCCCCGGATCACATCACTGGCCGCACGG +CCGTGGCGGTGCGTGCAAGGGAACCGGAATCAACGCGTCGTACTCGTGGGTGTCGGTCTA +TTCGGCCGAACACCAGAACGAATTGAACGCCTCGAAGCACCGCAAACACATGGCGCTGTC +CGCGCTCGCGTTGCTGATGGTTAAACGCGATTTCCGTCAGTTCCTGCGGCAGCGCGACCG +GTTGCTTACGGACATGCAGACGTTCGCGCCGAAGTCGGAGAACCTGCAATTGCTGCTCGC +CAAGGTCAATTGAACGCCTCGAAGCACCGCAAACACATGGCGCTGTCCGCGCTCGCGTTG +CTGATGGTTAAACGCGATTTCCGTCAGTTCCTGCGGCAGCGCGACCGGTTGCTTACGGAC +ATGCAGACGTTCGCGCCGAAGTCGGAGAACCTGCAATTGCTGCTCGCCAAGGTCAACCAA +GGAACTATACTCACCCACACCGTGATCAGGCAGGCCCTGACGCTCGTAAATACCGTTAGG +CGTCAATTCTATGTCGCCGCAAGCTGCGCTCGCTAAGAAGATCGCCGAGATGATCCGGCG +CAATGTCGACAATACGGACCCCATCACGCTCGTCCGCAACGTGATACCGCTCGACCGAAA +CAAGGCGTTGACGCTCGTCGGGATACTCGAAGCTGTTGCATCGGCGGAATCGTTCACCGA +GCAGAAGGTATATGAGGCCCTGTATCCCGACAGCGATCCAGCCAAGCCTATCCGCGATTC +CCCCAGCGTTTACACAGCACGGCTCGAAGCGGTGCGCGGCGTGCGCATGAGAAACCACGA +AACCGCCTTTGACTACAGGATTCGCTAGGACTCCGACGGACGCTTGAAATTGACCAACTG +TCAGGTGCGCGCATTCATCGATTCCTTTGACCGTCAATCCGGGAGACGGCAATGAAGACG +ATCTACATCGTATGAGCGTCGTCTATGTACGCGGGCGGGGCGGACGTTCGGGCGTTCGAG +GACGACGGAGACGCCAGAAAGTTCGCGTCCGACTGTCGCGCCGCTTCGGCTCGTCGCGCT +CAAGCCCCCGCGCTAGGAGCCAGTCAAGCGAAGTTGGCGGCCTATTACAGGGCAGAAGCC +AAGTGGGAGAAACAGCACCCGGCCAACCCGCACCACCACCTCGAGTATTACGACGTAATC +GGCCTCGATCTGTACCCGAAGCAGAAGTAACTTCGTTTCAATCCTGCAACATCGCGTGAC +AAAGTTGAACAGGGTTATTACGGCACGAGTTGTGTTGACAGTGTTTATCTGCCCGATATA +CTTCTGCATGTAGTAACCCACTCAACAACCGAAAGGTGATTGTCATGGCAAAAATCCAAA +TTCCGGGCGAACTCAAACTCGACGCTCCCGAGGGCAGCGTGAGCGCTGAGCTGAAGGGAG +CAGGCGCTACGGATGGCAAACGCATCCGCATCGTGCCGCCCGATTCGAGCCACATCGTGC +CTGGCCTCAATCCGCGCTTTTGGGGCAGCCCGAATTCGAAGGCCCACATCGAAGACATAG +CGAAGTCGATGATCGCTCGCGCGGCGTCCGGCCTGCCGGCGTTCATGCCCGAGCGCGCGC +ACGCCTGCTTCGCTCTCAAGATCGATGGCGTGGAGCGCCTTGTTCTTAAGGCCGGCCAAC +ACAGCTTGGCTGAGGTCGCCGTCGCCAACAAGAAGCAGCCCGGCACGGTCGCGGAAGTCC +CGGTGTTCGTGGACGAAAATCCGATGACCGACGCGCAGCTCGCGCTCTACTACATCACGG +AAAACCGCAGCGAAAAGCGGGGGCCGTACGAGATGGCTGTCTCCGTCGGACGCGCAGCGG +AAGCGGGCGCGACGAAGAAAGATATCATGGCGGAACTGAACACCTCCGACCGCTATCTGT +ACGATCTCGGGCTGCTCTACAACGCCGACCCGCGCGTCATCGAGCTGCTGGCGGAAGGTA +AGGTGAGCGGCACGACCGTCACCGAAGAGATCAAGGAGTACGGGCAGGAGAAGGCCGCCA +AGCGACTCCTGAAGGGCATCGAGACGGCCGCCGCTGCCGGCACGACGAATGTCACGCGCC +GCCATCTGCCGGCCGGGGACGCCCCGGCCAAGGAAAAGAAGACCCGCGCCGACACGAGCA +AGACGGATGGAGTCGAGCAGCGAGCAGCCGACGTTCCGGTGTTCAACGCCACGCTCTCCG +TGCTCGAAGTCGTCAACGGGTTCCACGAGCAGTTTGGCGAATCGGGCGATCGTCATACGA +AGATCATGTTCGAAATCATCAAGCAGTGCGGCGGAGACGAACTCGTCCAGTACGCGGCTC +ATACCGGCAAGTACGAAGCGACTAGTCTGGTACGCTTCGGCTTGGTCGGGCTGCCCGTAG +AACCGGTTGCCGGTGAAGAAGACTCGGTGATCAAGGCGCAGGCCGAGAAGACGAAGAACA +CGCGCTCGCGTAAGTCGAAGAAGACGGAAGGACCTGTCGAGTCGCCGGTCGGAACGGCGG +AAGGGCTGTAAATCGGAAGTAACTCCAGGTCCGCTTCGGCGGCCGTTTTCAGGATTACTC +ACAGGCGAGCTTATGCAACCCAATCTCGGGCTTCTCCCGGTCATCGACGGCCGGGACATC +TGCATTTCGCCGCTCGGGATCTGCGAAGTCGAAATCAGCGACCAATTCATCGTGACGCTG +GCCATGCAGAGCGACAACGAGTACCAGTACAAGATCAAGAACATCGAGCGACAACTGGCC +TACTATAGGGACCCAACCATCGAACCGTCGCGAGGCTACGATAAGCCGATGAAGGCGATG +ACCTCGAAGCAGGCCCATAAGTGCCTGAAGTTTCAGGGGCGCCGACGCCTGACCGGGTAT +GTCAAGGAGGCCGAGGAAACCCACTACTGGCATCTGCACCGTTACGAGGACTGATAAGGA +AGTCGCCATCGCAAGCGGGCTCGTGCCGTACGAACGTATGCGCGAGGGGATCGAGGTCGG +CCTGCATTACCTGTCGTTCGACCGACCGGAGTTCATCACGGGGCTGCACGTAGCGGCCGA +TGTAGGAACTGCCGACGTGCATGCGACCCAGTGGGCGAAGGAGCACGGCATCGAGATTAC +GCGCTACTGGCCGTCATATCGCGGGGACCCGAACGAAGCTGCCAAAGACCGCAACTACTT +CATGCTGTAGGAAGCGGACGTGCTGATCTCGGTAATGGGCGGCGTCGGCGATTGCAGCGG +AATCATTAAGATGGCCCGGAAGATGAATATGCCGGTCTACGTACATGCGAAAGATCATGG +TCTGTAGTTGACACAGTTCATCTTTGTCAGGATCATCATCTCACCAGCTACGGAGGGATC +AAAATGAGTAATGAGCCGAAAGACGCAGCAGGAATCATCACCTTGAGCATCCAAGTCTCT +CGCCAGTTGTACGAAAACACAATGGATGCAGCCGCGCACGGAGTTGAGTATTGGGCGCAC +GCGTTCGAGCATCCGGGCTGCGGCCCGGAGACCCTAAATTATACGATCGAAGAAGACGAA +CCGAGCAGTGGCGAAACGCCAAAGAATTTCGTCACCAGCACGCAAGCCATCGTGAACGGG +ATTCAGGCGATCATGCACCCGGCATTCTCGGTGCGCGCAGACATCCGGGGCACGCTGTTC +AGTGCACTCGTAGAAGACGACGCCAGCAATATCGACATCGAGATCGCCGATATCATTGTG +CAGGCTGCGATGTTCGGCGAAATCATCTATGGCTGACCGGAAGTTATTTCCGACCAAGGA +GAAGAAAAATGGCGAGGAAACCGTTGAAGATCACATTCGGTGTTGGCGCAGACATCCGGG +GCACGCTGTTCAGTGCACTCGTAGAAGACGACGCCAGCAATATCGACATCGAGATCGCCG +ATATCATTGTGCAGGCTGCGATGTTCGGCGAAATCATCTATGGCTGACCGGAAGTTATTT +CCGACCAAGGAGAAGAAAAATGGCGAGGAAACCGTTGAAGATCACATTCGGTGTTGGCGC +TGCTGCGCTGGCGATGAACGTCGTACGCCGTGCAATCAAGCGGATCACCGAAGACCCGTA +CGAAGCTGCGGCCGAGCACCTGAAAAAGACGCTCGAAGAACGCAAACGGCCGTTACTGCT +GCGCTGGCGATGAACGTCGTACGCCGTGCAATCAAGCGGATCACCGAAGACCCGTACGAA +GCTGCGGCCGAGCACCTGAAAAAGACGCTCGAAGAACGCAAACGGCCGTTACTTCCCGGC +GAGCGCATCGTACAGGAAAGCCCGCTGTTCGAAGCTCCCGACGGCGTGTGGAAATCCGAC +CGGGGCGACGAGGTCACGGTGGACACGACGTTCGATCGACCGCGGGTCGGCGTCGTGCTG +AAGCGCAACCCCGATGTGCCGAGATTGTATGTCGTCCAGATGGCGACGTCGCACGCCGAA +ATCAACGTCCACGAACGTATGATGAGCCTGCGTCGCCGTGCAGCCGGCGACACGAATCGC +GCGGTGTTTCCGGCGGTGCGCCCCTGCGAAGGGCGACCGGCCGGCGAATGGTCGACTGCT +CGCCGCTGGCCGCCGACCGGCTGGCCGTGCGAATGGTACCCGCCGGGAAATTCCGACGCC +TACGCGACCGTAAGCTACTTTGGACGGGACTATCCGCAGGCCGTTGACACGGAGAAGGAA +CAAGCAGAACTCGCCATCGCGGCTGCCGGCCTCTCGATGTGCCACGACCCGTGTTACGTC +GGCCAGTACGGCGATCAGACCGTATGCAAAACCTGCGAAACGACGTGGGTTGCGAATGAT +CAGTTCCCGCCGTCGTGCCCGCACCCGTGACGAGGCTGCCGTGTCGGCAGCCATCAACGG +CGCTACCATCCTGATTCTCAATATCCTTTACCCCCGGAGAAAGTAAATGCGCATTGCGAA +CCCGCAGAATCGCCTCTGGCAGGCTCTCGTGTCCCGGCTGGGCCAGCGACTCATCGACCG +GGCCTTCAGCCGCTGATCAGTTCCCGCCGTCGTGCCCGCACCCGTGACGAGGCTGCCGTG +TCGGCAGCCATCAACGGCGCTACCATCCTGATTCTCAATATCCTTTACCCCCGGAGAAAG +TAAATGCGCATTGCGAACCCGCAGAATCGCCTCTGGCAGGCTCTCGTGTCCCGGCTGGGC +CAGCGACTCATCGACCGGGCCTTCAGCCGCCCAGCGGACCCGGTAACGCTTCCTGACTTG +GCGAACTAAACGCATCGTCGCTGGCTAGTGAAATACTCTCGCTGGACCCTCGGCCGCTGC +GCGCGAATTCACCACATCCTGCGCTCGGATTCGGTTCGCGATTTCCACGACCATCCGTGG +CCGTACGTGACGATCATCCTCGACGCCGGCTACACCGAAGTAACCCCCGTCTACACGAAG +GCGAATCTGGACAAGGGCGAGCACGGGCAGTATTATGGCCCCGCCTCGATCCTCGTCCGG +CCAGCCACGCACCTGCACCACCTCTAACTGGAACCCGGCACGACGGCGACCACGATGTTC +ATCGCTGGGCGCTGGGAGCAGGAGTGGGGCTTCATCACGAACCCCAACTTCAAGATGTAC +TGGAAGGACTACCTCGCGCGCGAGACGGACGTTACGCCGGCACGCGCCGAGCGCCGCACG +TTCGGGCTTCATCACGAACCCCAACTTCAAGATGTACTGGAAGGACTACCTCGCGCGCGA +GACGGACGTTACGCCGGCACGCGCCGAGCGCCGCACGTTCCTGATTTGCGCGTGTCCTGC +CGGCGCGAAACTCAGATACCTAGCCCGCCACCATACGGACGACGACAAGCGCCGAGCGGG +GGCCGATCTCATCGAACTGATGGAGGCCGGAAGAAACCCGTTCCCGAAAGAGCTGGAAAT +CGGCGCGAGCGGTCGTACGATTTTCCCTGAAGAGTGCTGCGCGTGTCGCGCGCCCGACAT +CGAGGACGGCGCGGATACCGCCTTCGGCGACGAAGCGGACACGGAAGCCAGGCGCTGACC +GTGAGCGGCCGCATGAGGTTCTACCACGAGAATTCCGACAGCCACGTCTACCTCATATGG +GAAGAGGCGGCCGCGCTGCCGGAAGCTCTCTACGAGGTTGACGAGCTGTTGGTTCCGGCC +GCAGTACAGGAGAGTGAAATGGCGTATCTCGGTCTGAATCAGCTCCCGTTCTTCCTATAC +ACCGACGACATGCCCCCGGACCCGGTCTACGACGCATGCCGGCTTCTCGGGATCGGCTCG +TGGGCGACCAGTGAGTTCCGGGGAAACATGGACTTCAAGCTCTCTACGAGGTTGACGAGC +TGTTGGTTCCGGCCGCAGTACAGGAGAGTGAAATGGCGTATCTCGGTCTGAATCAGCTCC +CGTTCTTCCTATACACCGACGACATGCCCCCGGACCCGGTCTACGACGCATGCCGGCTTC +TCGGGATCGGCTCGTGGGCGACCAGTGAGTTCCGGGGAAACATGGACTTCGCTACGGCGC +TCGAACGCAAGCACCCGATGAAGGAGTGGCGGGAGGCGATCAAGAAGGCCATGGAGATCG +AGAAGCGGCAGCAGAGTGCGCGAACGATCGCGGCCAAGGCGCGCATTGCACTCGGCAGCG +ACGACCCGTACGCGCTGCGTGTCATGCAGTTGATGATCGACCTCGGGAAACAGCTCGACC +CGGCGGCCGGCACGGCGCTCGAACGCAAGCACCCGATGAAGGAGTGGCGGGAGGCGATCA +AGAAGGCCATGGAGATCGAGAAGCGGCAGCAGAGTGCGCGAACGATCGCGGCCAAGGCGC +GCATTGCACTCGGCAGCGACGACCCGTACGCGCTGCGTGTCATGCAGTTGATGATCGACC +TCGGGAAACAGCTCGACCCGGCGGCCGGCCTGTAGGCAATAAGAAGCCCCGGCTGAAACC +CGTCAGGGCCAAAGGGCGATGCCTTACGGCACACTCCCCATCTGATCGCAGCAAAACCAT +TCTACTCTGATGCCCGCTTCGCCGGGGTCGCTTTGCCGGGCGGCTTCCATCCACACTTCT +TTGCACCCATTTCGTTATGTTCGACCATTTGTTTCAGGACGGGAGTCGGGATCGCTTTTG +CTTGGTCGAGGGTGTAGGTGAATGGTTTCGTCCAGTTGCAGCCGGTGTCGATGAACTTGG +TTTCAACTACGATCTTTGGTTATGTTCGACCATTTGTTTCAGGACGGGAGTCGGGATCGC +TTTTGCTTGGTCGAGGGTGTAGGTGAATGGTTTCGTCCAGTTGCAGCCGGTGTCGATGAA +CTTGGTTTCAACTACGATCTTTGGTTCCTGCGACATCGGGACTTCAGCTTTCGGGGGAGG +CCCAGTTTTGCACGAGACCATCAAACGTAGCGCCGTCAGTGCCAGCTACTTGTTGTTCAA +CATCGCTTCGTTCCTTCGCGGCTTCAATGCCTTGTTGAGCGGCTGCTGCGTTCGAATGAG +CATGTGCGTCACGGACCTCCGCTGTGTGAGTCCGGGCGTCGGTCGCGTCACGCTGCGCTT +CGGCCTGCCTCTGTTTCGCGGCGGCCACGTCGGCCGACGCTTTCGCCTTGACGATCCGGC +TGTTGCCGAATACGCCGAGGATCGCTACTATAGCAGCCCCGATAGCCGCGATGATCGTGT +TCATTGGCAATTACCTCCGTGAAGGATGTAGGTTGCACGCAGGGCATCGAGCTGGCGCTT +TGGCTGTCCGTACGTGTTCTTCGTGCCGGGGATAGACGCCCAAATGTTCGAGAGCCGATC +GCATGCCGTCAGGAAGTCGCCGTCCTTCAGCGGCTCGTTGGCGCGGCTCTCTTTCAGGTG +TTGAAGGCCCGTCAGGTCTTGCGCGATCTCCGCGAAGTCCGTCAGCCGATGGAGCGTCTT +GTAGTGCGGCCAGTCCTTCAGCATCTGTTGGTATCGGCAGCTCGCCGTCGAGTAGAGGCC +CTTCGAGTTGACCTTGAACGGCTTGCGGCCGAATTGCGGCATGAACGGATGGGCCCTGAA +ATCCGTGAAGCGGTTGTGCTGCACGTTCCCCTGCGCGTTGATTGAGTTCACGAGGATGTC +GTAGACGTCGTCCTGCGTGACGGGTGACGTGCTCGCGCCTTCGGCGGATGCGATCGTATC +CATGAACGTGCAGACGTTCAGGTGGCCGGCAAGTTCAGGAGGGATCCGGGGCATTCGGGG +TCTCCGGTCGAGGTTGCGTACGCGCGAGCCGGGCCTGCTCGATGATGCGGAACGGCACAG +CGAACACGATGATGGCGATCGCTGCTTCAGAAGGAAGCGGCTATACAAAAAGACCGCGTC +GAGCGCGACCAGTGCGACGGCGGCGACTTCGGCCGCCAATTCGAAGAGGTTGTTCATTTC +GCCCACTTTCGGACAGAAGCATTGTACGCGTTACGGTCGTCGATCGCACGGTCGTGCTTG +TCCTCGACGCGTAGCAAGTCCTCTCGTACGTCCTGTTGCACCTTCGTTTGGTTGGTATCA +ATGGGCTTGATGTCATCCTTCCTGAATGGAATCTGCGTGGCCGATTCGCGCGCCCGGTCT +CGGATGTCGCCATCGTAATTCGCGACCCAGCCGATTGTCGATCCACACGCAACCAAGACC +GTGATTGCCATCTTGTTGTTGATGCGGCTCTTGTCTGCGATGTGCGCCGTCTGATCCGTG +TTGTTCGTCGTCGCGTTCGTTCGCTGACCCCGTGCGAAAAGGTTGTGGATGCGCGGGATT +CTAGTAGAACCGGAAGCAGTCGAGGGGCAATACGAAGTAACTTCAAAGCGGTCGGCCGTC +ATAAGTTTCACCATATGAGAATGAAAGGGATGGGCAGTGCTGCCGCGAATTCTAGTACCC +GAGCGCCAGAATAACAAACGGCCCCGAAGGGCCGTCTGCGCTACATGAGGTTGTGGGCCA +CGGGTCGTCCGGGCCGGGCGGCGTATTGCCTGCCGCCAGCCACTGCTCGTAGATGTCCAA +CCAGACCGAGCTATCTTTGGGGACCAGCCATACGGCCCCGTCAGCATCGCGGTACTGGAC +AACATCGTCCCGAACGTCCGGGGACGACCCTTTGAACTGCCTGAACGCTATTTCCATGAA +CCGAGCTATCTTTGGGGACCAGCCATACGGCCCCGTCAGCATCGCGGTACTGGACAACAT +CGTCCCGAACGTCCGGGGACGACCCTTTGAACTGCCTGAACGCTATTTCCATGACAACTC +CTGTTAAGGGCGTGCATCGCCGAGAACGGATCCGGTCGAACCGCTATCGAACGAACCACT +CCCCGTAGTAAACCACTGCGCCGCGATCCGCGCAATGAACTTGTTGGCCGCATCGACAAA +TGGCGTGTTGACGACTCCGGAAGTACCGACCCTCGTACTACCGATAGAGGTCGTAGGCGA +ACGCGCTTTTTCCGGACGCTTACCGGCGATCGACGGGATATCGACACGGACGCTGAAACG +GCTCTCCGTCGTGCCGACCGACCACGTGACGTTTTTCAACGTGACCACGGAAGACGCAGG +CGAACCGCCCGAGCCGAAGTTCTGCACGACTTGAATCGCAGTCACCAGATTGTCCATACA +ATCGACAAAAGCCCTTTGTTGCCGCTGATGTTGTACGCGTAATACTTGATGTTTCCTCCC +GAGCCGTCGAGCCGGTCGATATACCGTTTCACCCGAGCCGTTTCGAGCGCTAGACCGCGA +TACTCGAATGGCGACGGTGCGCCGCCGAGACCGTTCACGTCGCTGCTCGACGCCGCGTCA +CTTTCCTCGATCTGTAACTGGCTGAGGTCGAGGGTGAATGTGATTCCGGTCGCCAAAACG +AACGCGATCTGAAGCTTATCGTCCCTGTACGTCCCGAGTTGCCGCTGCTGCCGCAACGAG +CGTCGTGCTGACCGTCACGCTGCGCCCGCTGAACGCGTTGACGCCTTCGATGTTCTGGTA +AAGCTGCGGCGCCGACGATGCAGCCGTCGTCCGGTTGAACCGTAGCTTGTACCGGCGCGA +CGAGTCGATACACTTCGGTGCGGGCTCGGGGGTCGGAGTAACACGCGATACCGTGGTCGA +ACCGACCGTTCCGGAGATCGCGCGCCACATACCCGCCGTGTACTGGTCGGTCGCAGCCGC +GAGGTCGAACGGCGTGTCGACCTGCCACCAGTCGACGTTGCCGTCCACGAAGCGGTTCAG +GCCGGTAGTAGCCGGGAGGTAGCCGGGCTGAATGGTCGAGTTCGTCCAGTTTGCGCCGTT +GTTGCGGGGGTGCTGGCCGCTCGCCGACGACACCGCGAAGCCGATACGCATCGTGACGGG +CACGGTCGAGCCGCCTTGCGTGTCGTACGCCGACCCGTTGACCGGAGGACTGACGTTCAC +GCGGGTCCGCGTTCCCATCGAAGAGAGCGAGTTCGGCGTCCGCGCGCCAGACCCCGGCGA +GTCGATAGGCGTCGCGTAGTTGCACGCCTGCCCCGGACAGCCGACGAGGAACGCGTACAG +CGTGCCTGCGGTGAGGGCGACCGGCGTCGGTAAGTTGAAAGTGAAGTCCAGCGACCCCGC +CGTAGCGATCGTGACAGGGCTGCCGAACGTCGGTGCGCCGGTAAGCGTGCCGCTCGATGC +CGGGGCGACGGCTGCGTGCAACTGGACGCCGACCCTTCCTGCCGTTTGAAGCTGCGTCGT +CAACGAAGTGACTACGCAGTTCTGCGGGACCGTCAGCAGGTTGCCGTTCCAATTGTACGC +GCCGTTGTTGTAGCTCGTCGTATCGGCCGGGCCGACGACCGGACTGACAGGAACGCTAAC +ATCCGAGAGGCTGCTTGCGAGCGCCGGAGCCCCCGGAGCCGTAGTCCATGTCCGGTCTTC +ACGGAGGAACCGCGTAATGCCAGCGACGATCCCCGGATCGGGGACGAGACCCGCCGCATG +CGAACCACCGGGTGCGCCCATGACAGGCGGGAGCGGTGTGGTCGCCCATGTTTCATCCTC +GCACAGGAACCGGGTAGTGCCAGCGACGATACCCGGATCGGGGACGAGACCCGCCGCATG +CGAGCCACCGGATGCGCCCATGACTGGCGGGAGCGGTGTAGTCGCCCAGGTTGCATCCTC +GCGCAGGAACCGCGTAGTGCCAGCGACGATACCCGGATCGTGGACGAGACCCGCCGCATG +CGAACCACCGGATGCGCCCATGACAGGCGGGAGCGGTGTAGTCGCCCATGTTGCATCTTC +ACGGAGATACTTCGTCGTTCCTGCCGTTGCGCCCGGATCGGGGACGAGACCGGCCGCGTG +CGTTGACCCGCTCTTCACAAACGCACCGAGTGTTTGCCACGTAGCCGTCCCGCTGCCGCC +GCGCGTGCCGCCGCATGCGAACCACCGGATGCGCCCATGACAGGCGGGAGCGGTGTAGTC +GCCCATGTTGCATCTTCACGGAGATACTTCGTCGTTCCTGCCGTTGCGCCCGGATCGGGG +ACGAGACCGGCCGCGTGCGTTGACCCGCTCTTCACAAACGCACCGAGTGTTTGCCACGTA +GCCGTCCCGCTGCCGCCGCGCGTGTACCGTTGGCCGTCCTTGGGCGCTTCACCGACAACA +GACGCATTGACAAACTTCCCCTGCGATGCCAACCATGTGATCGCCTGCCCGTCAGTCAAT +GAGGTGAGTTTGACATCGCCCAGCCAGCGAAGCTGATCGTCGCTCGTGGGGGTAACGTCC +GGAGACGCGAAATCGATGAACACCTGGTCGGTGTACGGCCCCGCACCCGTGACAGTCAAT +GCCGTAGTCCGTGCACTGCCGTCGTCTGAATACTGGACGGTGAAATTCGACGGGCCGCCG +CTCAGATTGTCAGTCACCGCAGTCTGCCCACGCGCAACGGACTTCGCAGCGGGCAACTGG +TACCCGAGGAAAAGCTCAGCACCGGCAAGCGGAGCGCTGTTGGGGCGGTAGTAGGTTGCG +GTGTTACCGTCGAACGCGTTGTCCGGACCAAACGTCGTGTTTTGAGCCGAACCGGATGCC +GTGCCCCCGGTTGTTGCGATCTGCGCGCCATTCGTATCGATGAACCGCAGCTCGGCAACA +CGCATGCCGACGCCCCCGGTTTGCGCGGCCGAACAGTTGATGCGAACGCGTTGTCCGGAC +CAAACGTCGTGTTTTGAGCCGAACCGGATGCCGTGCCCCCGGTTGTTGCGATCTGCGCGC +CATTCGTATCGATGAACCGCAGCTCGGCAACACGCATGCCGACGCCCCCGGTTTGCGCGG +CCGAACAGTTGATGCGCCTGTACTTGTGAACCCTGTACGGATTGGTCTTCGTGAAGAAGC +TGGCCCATGTGCCATTCTGACGCATGTATTTGGTCCCATCGCTCGGCGCGTCCGCGATAA +CGGCCGTAATCGTCTGGCTCGTTCACTTGGCGCTCGCGGCGTTCCACGCGATGACCTGCT +TGTCGCTCTGCGATGCGACGGCTACATCGCTCAGGCCGACAAGCGTCGCGCTGCCGCCGG +CCGACGGCACAACCCACGTTCCATCTTCCCGGAGATACTTCGTAGTGCCGGCCGTTGCAC +CCGGATCGGGGACGAGGCCAGCCGCATGAGATGCACCCGATCCGACCATAGTCGACGGGT +AGGGTGGCACAGCCCATTACGCATCTTCACAGAGGTACTTCGTCGCGCCCGCCGCCGTGC +CCGGATCAGGGACGAGGCCGCCGGCATGCGATGAGCCGCTCGCGTCGAACGCGCCGAGCA +CGTTCCACGTCGCTTGGCCGCGCTTGTACTGGTCGGCGTTGTTCGATGCGTCCGGAATCC +CGCCGCCCCCGCTGATTGTCTTGTTGATCCACTTTCCGGATGCGGCGTCCCACGAAACGA +CCTGCTGGTCCAGTGGGTGGTCGCAACAGGAGTCCAACCCCCGTCTATCCGTGCGTACCC +GACGCCGTCCCTCGGTGCGTCGGGAACGCCTCCCTGCGCTGCCTGCCAAGCCGTGCCATT +CCACTGTACGCGGCCCGTGGAGCTGCTGAAAGCGGTCCCCCCGAGCTTCGGAGTGTAGAA +GGCCCACGCGCCGCCTAGGAAGGCCGCTACGTCGTCCCCGTGATTGGCCCAAGCTTCGGT +AGGCGCGGGGGACTTACCGACGATATAGCGATCGCCCTCGGTCGGTGACGACGGAGAGAC +CGTCAGCGTACTGTCGATCCTGACCATGGCCGACTGCGGGTTCCGGGAAGGTGTACGTAT +CGGCCGTAATGCCGGTCTGCTGCACGATCAGCGTGTTTTCTGAATCGTAGATGCGGATGT +TGTAGGTCACGCCGGTTTCCGGCCCGACGCGCACGTCTTCGTGGGCGACCAGTTTGTCTT +GCTGCTCGATGCGGTCTCGATGCGCCGATGTGAAGATCAGGTCCCGAAGGACGGCCGAGA +CTTCCGCGTAGCGCTGGCCGTTCAGCTTCAGATTGCCCGGCGGATATGGCAAGTTCTGCC +GCGCGACGATCTCGATTCTGCTCGTCGGAGCCGCGTTCGCCTGTAATACCGGAGATGTGG +TCTGCGTGCGGAACTGCACGGCGATTTGCATTCCTACGCTAAACTCGGACGGGTCTGCGC +CGAAGTAATCGTCGTAGACCCATACGGTATCGTTGCGAAGATGCGCGGCCGGGAGCGTGT +CGACGCAACCCCGTCGAATCGTTACCAGCTTCGTCCAGATGTCGTAGCTGACTACCTCGA +TGATCACGTCGACGGTAATCGCGGCCTTGCCCGGCTCGATGAAGTCGGTATCCTCGTTGT +CATCGAAGCGCAAAGTCGTATCGAACTGACCGAGAGGCTGCGACAAACCGACCAGCGGCG +TGAAGGCCGCCGTGTTGACCGTGCGATACGTGTTCGTGATGCCGGGATCGTCCCATACCT +GATACGACAGCGAGAAGATATTCGGCTTGTGCGCCACGGTGACAAACGTTCCGCTATCGG +CCGGGACCTGTGCCAGATCAGCTGGCGACAACTGGCGAACGAGTTCACGATACGTCGCCT +CGGTCGTGCGGTAGACGGCCGGGGCGACGGGTGTGCGGTTCGGCGGGACGTACTGATCCG +GCTCCGCTCCAACGTACGCCGTGGACAGCAGACCGAAGATATCCTGCACGGCCGTGATCT +GGAAAGACCCTTCCTCGTAGCGACCCGCCTGAATCTTGCCGGCGCGCAGGATCATGTTCT +CGATGCCGAGCTGCGGCACGCTGATCGAGAACACGTCGGTCGGCGCGAGCTTCGCGGCCC +GGCGATCCCGAAGATATCCTGCACGGCCGTGATCTGGAAAGACCCTTCCTCGTAGCGACC +CGCCTGAATCTTGCCGGCGCGCAGGATCATGTTCTCGATGCCGAGCTGCGGCACGCTGAT +CGAGAACACGTCGGTCGGCGCGAGCTTCGCGGCCCGGCGATCGAGCGTGAGCGTGAACCG +CTTCAACGGCGTGCCGTTCGACTTCAGGTCGCGCATCGCCACGCGCATCGCGAGGTCGGC +AGTCGGGATTGCCGGGTACGCCGTTGTGACGCTATACATCGCACCCACGGCTCGCATGTT +TCCGACGTTCTGCGCGCGGACCTGCTTGTCCTCGTCGGTGATTGGATCGTGGTACGTGAC +GATCTGCTCGTTGCGGCTCGTGTCGCCGACTTCAGGTCGCGCATCGCCACGCGCATCGCG +AGGTCGGCAGTCGGGATTGCCGGGTACGCCGTTGTGACGCTATACATCGCACCCACGGCT +CGCATGTTTCCGACGTTCTGCGCGCGGACCTGCTTGTCCTCGTCGGTGATTGGATCGTGG +TACGTGACGATCTGCTCGTTGCGGCTCGTGTCGCTCGAATTGCCGTCTTGCGAGATGCTC +AGCAGGCCGGACGTGTAGTCGAAATGCGGAATTGTCGCCGGGTCGTAGTCCGAGCGAATC +GGACGCAGCGTCCGCTTCGCGGTCTTGCGGTCGAAGTAGATGGCCCCGCCGATGTGATTG +AGAACCTGCTGCACGAACGCATCGAGGTCGTCTTGTGGGTTCCACCGAATGCAGAGGCCG +AAACACTCCGGGCAGAGCATGTTGGCTGCGTTGGGGAAGGACTGTTCGTCAATCAGCTCA +CGCGGAAATCCCCTGCCCCATTCGCGGTTCGTCGCGCATTCATAGATGATGTGCGCCGGG +TTCATCGCCTTGATGGTCTGGTTCGCCATCTGGATCCTCGCCTTCTCCGGATAGAAGACC +GGGCCGTCCCATCCTTGAATCGATCGACGCACGCGGGACTTCCACGCCTTCGGATACGGG +TTCATCTCGCACATGAGGCCGTCAACAAACACCGTGAAGACGCCCCGGAACGCCGGCACG +ATTCCGCCGAGCATCGCGGCCAGTCGCGGATTCGCTTGCTGGGTCGCCTCACCCTTCATG +ATGTCCGCGTTGCCTTGAACGCCGCCTTCCTTCTTGTCCCCGACGAACAGCTCGGGCGAG +TTGACGTAAATCTGACCGCTAGTCGAGACGCTGCCCGCCCACGCAGTAAGATCGCCCACG +GTGATCGCGACCAGTTCATCGACGGGGCCACGGCAAAGCGCCGCATGAATCCCGAAGTAG +TAGCGATACCCGATGACGGTATCTCCGCTTTTACCCCCGCCGCCCATTGCCGTTCTCCTT +GTAGACACGCAGTAAGATCGCCCACGGTGATCGCGACCAGTTCATCGACGGGGCCACGGC +AAAGCGCCGCATGAATCCCGAAGTAGTAGCGATACCCGATGACGGTATCTCCGCTTTTAC +CCCCGCCGCCCATTGCCGTTCTCCTTGTAGACTTCTTCCTTCACTCGTTCGAGCAGCGCG +CAAGTGATGTGCTGCGTGTGGCTGATCTTCAGGCCGTCGCGCAGCATGTCGCGAAACGAA +AGCCCTTGCGACTTGAACCACTCCCGAGCGCCGCGCTCGCACATGCCGGCTTTGAAGATG +TCCCGGATATAGATCGTCGGTTCGTTCACTTCTTCGCTCCCGCGGACTTGATCGGCGTCG +TGCGGAAATTGCCGAGACCTACGACCGTCCAATCGCTGCACCGGCAATCGCCGTACACGA +CGGCCTGCGGCGTGCCCTCCGTGGCCTGCGGGAAGTTGAAATACCCGAACCTCGCCGGGT +CCGGTTGCTGCGCTTTCGGGCCGAGCGCCGCCGACAGAAAGTACGACGCGACCATGAGCA +CGAGCCACGCGACAAACTGCATTTTTGTTCTCCTTAGAAGACAGGGTTTCCGTCGAACGG +GCTACGGCTGGGCATCCCGTTATACCCGCCGTTGTTAAGGTCGTTCCCGAACTTGTTCAT +ACAGACGGATGATACGCGAGCACAACCCGGATACATCACGACATTCATACCGATCGCCAG +TCGATCCGCAGTGCCCATGAGCGTAATGCGATTACCTACGTGCGTTTCGATGCCGTACTG +ATCCCACGACCCCGGCTCGCGCTCGAACTTCATGAGGCCGCCACTGAACCCCGGTGTGGC +CTTCGAACCCGCCTCGGCGCACTCGAACCAATCACCGCCCACGGCAGTGATAACGCCCTT +CGTGGCGAAGTTGTACCGATTGAGTTTGCAGTTCACGTCGTACACGAAATACGGGCAGCC +TTTCGTGTATGCGAGGCGCAGACCGCCGCGCTTGAACGTCATCGACAACTGCCGCCCGAC +GATCTGCGCGTTGATCAGAGACGTGCGACGCACATCGGACGCCGTGCCCGTCCACGCCAC +ATCCGCTTCGTTCTCCGGGTCGTTCTAGTGGTGTTCCCGGATCGTCAGGTAGATCGAATC +GGTTGGCGGCGTTCCGCGCCACTGCTTCACGATGTCCAGTGAAACCGCGCGGTCGAGCGT +GATCGAATCGGCCTACGCGTCGCCGCTTTGCGAGTAGCCGCCGTGCGCGATGATCGTCGC +AACGTACGTCCTGTTGTTCCACGGGATATCGCGATCAGCGTTCGTGTAGTAGTAGAACTT +GCTGCCGTACAGGAACTCAACGAGCAGAAGCGGTCGCCCGTTGAAGTTGCTCATGCCGAT +GTTATCGCAGATCATTCGAAAAGCCCTCCCCCGTTATATGGCTCTTGGTTGACTACGTGC +TTGGGAACAGAGATGTCCGCGTTAGGGGGGCGCGGCTTTCTGGCGGGATGGTCTAAGGGC +GAATGCACGGCCAGCGAGATCACCTACGACTGCATTTACATCAACGAGATTTTTGCTGCT +CAGGCGGCGGCCACAATGGCCCGGCTCGTAGCCGAGCGTTGTAGAGACACGCCGAATGAA +CCCGAGCCTTTCAACTGAACTAGTTCGCCTTTCCGCCATTTACGGAGGTATCACCATGAC +ACCCTCTGCCGCGAGAAAATCGAAGACGAAGTTTCCGGTGTTTTTGAACACGAACCATTC +TGTCTGCTTTGGATTCGGATAATACGATGGAACTCCGGTCCCCGGAAAATCGAAGACGAA +GTTTCCGGTGTTTTTGAACACGAACCATTCTGTCTGCTTTGGATTCGGATAATACGATGG +AACTCCGGTCCCCGGATTTGGGTTCCATCGATACGTCATATAGGGATACGCGCGCAGGCT +ATTCAGATAAATGCCGGTGTTCGGGATCGCAAGGTTATAGCAGGCGAAGACCAGCTCCTG +AACAATCGTCCCGTTCACATCACGTTGTCGCATCTGCACCTTAGCCGGTCATTGAACGGT +ATCGAGCAACGCGGCGGTAAAAAGGTGGCCACAAACGTTCGCCCACATTACGTCGCCTGC +CGGGTAATGTCCGCCTTCGACGGCAGTCGGATTCAGCACGTCGTTTGCTTGCGCCTTCAG +CTCGAAAATTTGAAGCGGGACTGCGCCGCAACGTGCATCGATATAAGAGCCCGCTTTTCC +ACCAAGCAACACGTCGATAGAGTTGATATCAGCTTGTATCAGGCCGCTTGCGATTGAGTT +GTCGAATGTGCGAACGATGCTCTGCATCCAGCTCCCATTTGGGTCAGCTTGGATGGCTGC +TGCATTCATGATACTCGCAGTCACGCCGAGCATACCTGCGACCATGGGCGGGTTGCAGTC +CACCCACCAGTGAATCGAACCGGTTGAGCTGGTCGTCTGCGCTTGTACGCTCGATGCGCT +CGTGATCGATTCTAGAATTGCAGCGCAGGCGGTTGCGAGCAGTGTTTCTGACGCGCTATC +GTCCTGCGCGCATTCAGTTAGGTCAGAGGTGAGCGACTTCGCCGCCGCGTACACGAGGCC +GCCCGTCAGGAGGGAATACAGAAGAGAAAAGATGTTGTACGCCAGAAAAACGCGAATCGC +CGCGTGCAACGTTGCGTCATCAAGCGGAGCCTAGTACGCGTACCGATCCGTGGTGATCCA +AGGGTCGGCGGATCGGCAGTCGCAATTCTTGTTCGTCATTTTTCTTTCCCCGTGGTTTGA +TACGACGGATTGTCACGGCAATGAATAACCTTGTCAACAGGCGATATCGCTGAAACGTAC +GATTTTCCCAACACTGAGGTTATCGCCGAGTTCCTTGAATCGTCAAGAGCATATATTCCC +GCGTTTAATTGTTCGAATCGTTTATCGCCCCAAGCGTGCTCTGCCGCGCCGCCTCGGCTT +GGTCCGGCGGGTACCCGTTGGCGACCATGATGTCGTACGTTGCGTTGAGGTTCGCTGGCT +CAGTTTTTGGATACTCCCCTGCAAGCGGATCGACCGGCGGGCGGCCGTTCGTTCGTACGT +CGCCCCATGCGCCGCATTCGCTGCCGCATATACACGCGACGGGCGTTTGCGTCGTATGCG +TATAGCGCGTGATGTCGTAATTCGTCGCTACACGATTTTCAGGCGTGCTCTGGAACGTGA +CAACTGCCGAGCTGACGCCCTTCGTGTCGGTCATGTGGTTGATCTCTACGCGGTCTTGAT +TAAGTCGCGCGAACGTCATGAACGTGACGCGCTTCAGGTCCGAGGCGAATACGACTTGCT +TGAAAGCCGCGTCCACGGTGACGATCTCGTAGCCCGTAGTCTGGTCGAGCGTTACCCCCA +ATACGCGACGATATATTGCCGGCACTGTAGACCGACGCGGGTCGAGAATGATCTCCTGCT +GCCCGTCGGGAAGGGTCGAGAAGAAGTCAGCCAAACCGCTGCGCTTGATGGTGATCGTCG +TATGACCTGACTAGATCGGTTTGGCGAGCTGCATATCGGCCGCATGGGACGGGAGCCAAA +AAGGCGTGACGCGCCCGCGCAGTGCGTACAGCAATTCGCGCAGGTCGTCATTTTGCTGGC +GGCCGTGCGTGATGAAAGCAAACTGATGCGCGAAGAGCTGGATACCTGCGGTATCTCCGC +GCTTCGAAATGCCGTATCCGGAATCGAGCACGTCCAGTAGCCGGGAAGACTGAACCGTCA +GGTCGCTCGTGTCGTCCGGGCGAAGACGAAACACCGGATAGCCGCGATAGATGTCAGTCC +ATGCGGCTTCCGGGTAATCGTTCGTTTCCGTGACCTGCCAGTTGGGTCGCTCGTGTCGTC +CGGGCGAAGACGAAACACCGGATAGCCGCGATAGATGTCAGTCCATGCGGCTTCCGGGTA +ATCGTTCGTTTCCGTGACCTGCCAGTTGATCGCGTAGACGGCAGCGCGACCCGCCTTTCG +GGTCATCTGCGGATGGTCGGTCAGCATGGCTACCTGAATCGGAAGTAACTTCGTGCCTTT +CGGCCATGCCTGCACGAGGCCCTGATCGAGGGTGATAGTCGTAGCGGTCATATCGGTTAT +CAGCCGAACCTCGTAGTCGAATGAAGTCTGACCACGTAAAAAGACGAGGCCGCCCTTCTT +CAGTTCGGACGTGGTCGTATCCTCGACGGACACGACGGTATCTCCGGCCTGCGCAGAAGC +CGTCAGCGGGTTCAAATCCCACGGAAGAGGGACATTCCAGCTCGTTCCGCCGCCGGCCGT +CAGCGCGGCGTTCAGGCGCGTGCGCTCGGCATCGATCACGAGCACGGACGTTTCAAAGAA +CCGGCGCGGCGATATCCGGAGCGAACGCCGCTGCTCGGCCGTCATATCCGATTGCTGCAC +GCTCGTCGGCCATTCGAGCGCTTCGAGTACGCCGTCGGACCATTCGGTCGCGGAAGACCA +GACGGGAAGATTGATGTTCGGCATTACTTGATTCCCGATGCTTGGCGTGCGGCTACGGCG +TTCTGCCGCAGGTAGGTTGTGATGACGGTATCGCCTGCCGCCGACGCCATCGCATCGGGC +ACGAAGTTCGGATCGGAGATCAGCATGTTCCGGATCGTCATCGGCTGCTTGGCGGCCTGC +GCTGCATTCTTCGCGGTCACGGCGTTCTGCCGCAGGTAGGTTGTGATGACGGTATCGCCT +GCCGCCGACGCCATCGCATCGGGCACGAAGTTCGGATCGGAGATCAGCATGTTCCGGATC +GTCATCGGCTGCTTGGCGGCCTGCGCTGCATTCTTCGCGGTCTGGTTCAGGATGTTGCGC +GGATTGTCCTTCGCGAGTACTTCCTCGCCCTTCTGAAGGATCGCCGCCTGTTCATCAGCC +TTCAGGCCGACAACTGTGCCGCTGCGGTAGCGCTGCGCGTTCGCAACCCAGCTCGCCGAC +GCACTGCGCGACATGCCGCCCGGCTGACCGACGACTGCACCGGAGTGCGCAATGGCAGTA +GGCAAGGATGCGCCAAGGCCCCACGTCCCGAGGCCGGTTCCTACGGCAGCCGGGGCAGCC +GACGCAGCGCCGCCGAACCGATCGAGCAGCGCCATCGCCGCGCACGTCGCCATGATCTGC +ATGATGACGCTCGCCATCGGGCGCAGGAAGTGCGCAGCGAACTGTGAGACCGATTGCCCG +ACGTTCTTGAATGCGTCTGACCATTTCTGCGTGCCGTTGGCGGCAGCGAGAAGCTGGTCA +ACGACGTTCGTCATCATGCTGTCAATCCTCGGCGCGAAACCGGACGTGAACGTATCGCGA +ATCTTCGCCATGTCCTTGTCGCACGTACTGCGTCTGCGTGCTGATTTCCTTCAGCTTTGC +ATTGAGCGCATCGAGCTTGGAACCGGAGATGTCGCTGGGCTTCGGCCTTCGTAACGAGCA +GCTTCTGCAGCTCAGAGACCATGCGCTGAATCTGCGGGCCGCTCTCCGTGTACGGGGCCT +TCATTTTTTGGTTCGCCTCTTCCTGCGTAATCGCGCCGAGCTGCACGAGGTTGTTGTTCA +TCGTGACGGCCGAGTTCCGCTCGTTGAGCGGCTTGTTCGTCTCGGTCATCTGTTGGTTGA +ATACGTCGAGACCGCCCTTCGCCGCCGCAGATGCGGAGCCAGTGGCTGAACCTTTGCCGA +CGCGTGTCATATTCTGCACGAAGGCGTCGATCTTCGCGTCCGGGATGCCCGTGCCTCGCA +CGCTGTTTGCAAACGCCGCTGCATCTTTCGCCATCTGTGCAAGTTTCGGTTGCGATCGTT +GGGTCTGCGTGGCGATCTGTTTGAACCCATCCACTGCCGACAGTGTGCGGGCTTTGACTT +GTTCGAGCACGTCTTTCTGAAAGTCCGCTCGCGCCTTCAGCACGTCGTTGACTTGTTCCT +CTTTCTTCTTCAGTTGCACAGTGTTGAACGTAAGCGTTTCTTGCTGGATAGCTTGTTTCT +TGATTTCCTTGATCTGCGCCTGGATCGCGGCGATAGGCTGGCCGTCGACCGTCGTGCCGC +CGATCTTCTGGTACTTCGCGATCGTGTCGTAAATGTCCTTGAACGTGCGCTCGACAGCCT +TCAAACGCAGGTCAAGGTTGTCCTTGTACTGCGACTCGACTTGCTTCCAGAGCGAATTCA +GTTTCTCCGACCGAGACACTTCCATGTTGTACCGCCTGTCGGAGTTCCTGTCCGTCTTGT +TCGGGTACGCGATGTCGTACAAGTCGCCGGACGTATCGGTCAGCGGTGTCGATCGGGGCA +GCGTCGTTGCAAGGCTCGCGCCCTGTCTACGGAGGTCATTCTGATACAGCACGTCGAACG +CAGCCTCGTTGTCGGCCAGTGCTTTATCGCGCTCCGCGCGAATCGAAGCGAGGTTGCTCT +GCGCGAGTGTTTTGGCTTGCTCCATCCCGGTCATAGCGCCGTCCGTGTTGCCCTGCGGAG +CTGTTCTGCGACGTTATCGAGGCCGAGGAATTTCGCCATGCTGCGCAGGCCGCCGAGGAA +GCCGTTCTTCAGAGTCTGGACTTTCTTCAACGCCTTATCGAAGAAGTCGACGACAAAATC +GCTCAACTGCGCAGCAAGCACGAGAATGCCGTACTTGAGGTTGATCCATGCCTCGTAGAT +CGATTCGGCCGCCGTAGTGCCGACCAGTCTCGCAGTCGCGAAATTCTCGCCAACGTGCAG +CTCGTGGATGACTGGCGCAACCTCGTGAAGTTCAGCTCGACGTGGTTCATCGCAGTTGGC +GTCGTGTTGCAGAGCTGGATCGAGGTCGCACCGGATACCCTGCTCCATGTGTGGGTCCTG +ATGCCGGACGACATGAAGGCGCTGATCCCGCCGCAGTACGCGCGCTTCGTCCCGGAATCT +TCCCGATCTGCCATCCCGTGAACGCAGCGGTCAGGACGAGGAAGATTTTGTTGATTGCCG +CAAGCGCGGCGTTCAACCGATCGGCGTCTTCCCGATCTGCCATCCCGTGAACGCAGCGGT +CAGGACGAGGAAGATTTTGTTGATTGCCGCAAGCGCGGCGTTCAACCGATCGGCGGCCAC +GGAGCCGGTCCCCATGGACGCGCCGGCTGCATCGCCGCCCGGTGCAGCGGCCGCCCCGGA +CGCACCGACCGCCGCCATAGCGAAGGCCGCTTGTGTGAGCTGGATCGTGAAAGCCCCGAT +CAACGCCATCACCTTCACGCCGAGCACGAGGCCGATCACGTCGCCCACGGCGTTGATATT +CTTGATGACTGCTTCGAGGATGTTCAGGACGACCCATCACCTTCACGCCGAGCACGAGGC +CGATCACGTCGCCCACGGCGTTGATATTCTTGATGACTGCTTCGAGGATGTTCAGGACGA +CCGGGAACGCGTCGGAAAAGTTTCTCGCGAACTGCTTGCCGTCGTCACTACGAAGTAACT +TCGTCATGTCGACGGCGAACTTGGTCCACGCGTCCGCTAAGCCCATATCGGCGATCGTCT +TCCGGAACTCGTAGAACGCGTTGTACATGCGAGCCTCGGCGGCCTGCATATTATTGACGG +CCATTGGAAGCTGCTTTCCATACTCATCGCCGAGCTGTTGCGCGAAGCCGAGAAGCTCCT +TCACCGAAACGCTGCCCTCTTTGAGCCGCTTGTTCAATTCCGGCAGACTGATGTTCATGC +CCTTCGCGAAAAGCGCGAATGCGGCGGGCAGCCGATCGCCGAGCTGGCCGCGCAGTTCTT +CCGCCTGCACCTGCCCTTTCGACATCATCTGTTCGATCGCGCGAAGCCGAGAAGCTCCTT +CACCGAAACGCTGCCCTCTTTGAGCCGCTTGTTCAATTCCGGCAGACTGATGTTCATGCC +CTTCGCGAAAAGCGCGAATGCGGCGGGCAGCCGATCGCCGAGCTGGCCGCGCAGTTCTTC +CGCCTGCACCTGCCCTTTCGACATCATCTGTTCGATCGCGAGTAACGTGCCCTGCATATC +ATCCGCGCTCATGAGCAGTACACGGACGGTCTCGGCCACTTTCTCGAAGACAAACCGCGT +CTGGTTCGTCGTTGCGCCGGCTGCCTTGGCCGACACGGCGAACTTGCCGTACGACGCGGC +GAGATCATCAATCCGGATGCCGAGGCGTTCGGCTTGCGCCTGCACGTATTGGTATTCCCG +CGTCTGGTTCGTCGTTGCGCCGGCTGCCTTGGCCGACACGGCGAACTTGCCGTACGACGC +GGCGAGATCATCAATCCGGATGCCGAGGCGTTCGGCTTGCGCCTGCACGTATTGGTATTC +CTGCGCAACGACTTTCGGGTCGTTCGTTCCAGCGACCACGGCGAGTACGGATTCGTTCAA +GTTGAACTTCCGCATTGGATCGAGTGCGCCTGCCGCAAGGTTGATCGCGCCCTCCGCGCC +GACGTACGCGGTGGCGAGCGCGATCAGCTGGCCGCGCACGCGCTGATATCACGACAGCGA +TTCGCGCTTCCCCGTCGTGATGCGGTCAAGCAGCGAAACGGTCTTCGCCGCTTCCGCATC +GTGTCTTTGCATCGCGGCGGTCGTTGCTCGAATGCCGTTCGCCTGCTGAGACTGCGCTGC +GAGATCCTTCGACGCGGCGGCAGCTTCGGCCTGAGCGGCAGCCCGAATACGAGCGAGGCG +AGCATCAAAAGCCTTGGCGTTCGCATCGTTCGCCGCAGCCTGCGCAGCAGCCTCTCTGGC +GTCCTGGTCGCGCCCGGCCGCTACGATGGCAGCCCAGGGGGCCCGCGCGCGTTCCTGTCG +ACGCGCTGGGTGAGTCGTTCGAAGTCCCGGCCACCGCCGGCCGCCGCAGCAGTAAGCTTG +TCGAGTTCACTGGCGGTCGATCGAGTCGGCGGCCCGGCGTTGAGCGCATCACGCGCGAAC +ATCTGGTACGCGATGGCCGCGCCCTCGACGGACCTCTTATGGCGATCGAGGTTTTCGTTT +GCGGTATTGAACGCCTGCGACGCCGCCCCGGCTCGCGTCTTCGTCTGATCGAGCGCATCA +GCAGCGCCTGACATGGCTTTTTGTACGGCGTCAGCAGCCTTGGAGAGATGCTTCTGCTGA +TCGGAGATGGAGGCGGCCTCTTTGCCGAGACTGTCCGTCCCTGCGGTTGCGGCCTTCGCC +TGTTTGACTTGGTCGGCGAGAGACGAAGTAGCTTCGTCAATCGCCTTCTTAGCGTCCTTC +ATCGCCTGCGGCGACATGTCCTTGGCCCGGATGATGAGGTCGACTTCCTTCTGGTTATTC +GTTGCCCTCTCGGAGGCTCCTAACTCTCTCGTTCAGGGCTTTCACGTCCCCGGACCAGAC +GGCGAAGATTGCCGCGTAAGTTAGAAGCGCTTCGGTAGCAATCAGGCCGTTGATCCGTTG +ACGCGAGATTCTACTCTCATTCCATAGTACGCTCGTTCAGGGCTTTCACGTCCCCGGACC +AGACGGCGAAGATTGCCGCGTAAGTTAGAAGCGCTTCGGTAGCAATCAGGCCGTTGATCC +GTTGACGCGAGATTCTACTCTCATTCCATAGTACGGCGAGGGGGTAGTCCCACGTGTCCG +GGTGTCCTTCGGCCATCAAGAGGCTGGCGTCGCGACACAGTCCGAGATACCACTTATCGA +ACCGCGACGGTTTGCAATCCGTCAACGGGTTCTCTTCGGGATCAAGCCTTTCGTGATGCC +CCGGAGCGCCCCCAGCCGATTAAAGAACTCTTTTAGGCCGCCTGCGTCCTCGAACGTGTT +CTTCCGGAGAGCCGTCAATGCTTCGATCTGCACCGAGAAGGACAGATTCGTTGCAAACAC +ATCTGCCAGTGCTTCGAGCTGCTCCTCGTAGTCCTCGGCTTTCCGGTCTGCCTCGTCGCA +CGCGAGCGCGCTCATCTTCCCGACCAGTTCCGGGGCGTCACGCGTCAGCATCTGGATGAG +AATGTATCCCGACTGGTTCGTGAATACATCGGTCGTGTGGGCGGAATACGCTTCCATAAG +CGTATCGATATCTTTCAGATGTTTGTCCACGAGCTGCGCCACATCGGTCAACGAGAGACC +CAGCACGCGCAGGGTCTCTTCGCCGACGGGGATCGTGGTGCGCCGTGCTTTGTAGTTACG +GCATCCCATTTCCCGGTTCTCCTTACATCGGCCGGCCGTCGAGGTACACGCGCTCCGTCG +CCGAGCCCTTCTCCAGTACTTCGAGCTTGAACTGGAGCTGCTGCCATGCGTCGCCCTTCA +ACTGGAAGTTGCCGTCAGCGGTGACCTTCGTGTACGGTATGAAGTAGTTGAGCGACGGGC +CGTACGCGTTGTGCTAGATGAAGCGGAACGCACCCATGATCTGGTCGCCGGCCGACACGA +CCTGATCGTAGGTATCCGCCGCCAGCTTGTACGTCACCGAGATGGGCTTCGTGTCGGTGA +AGTCGGCTGCATCCGGCTTGACTTGGAAGCGGCCGCTCTTTAGGACGATGTTGAAGTTCG +TGAGCGGGATTTCGGCCGACGTGGCGTCCGTCGTCTTTGCGTCGAAATCGGTGACAGCGC +CGACGCCCGCGATATTCGCCGGCGAGACGCCGAGTTGATACCATGCGCCCGGCGTGACGA +TGATGGTTTCCGGTGCAAACGGCGACGCGCTGGCGGCTTGCGTGACCCTCGCCTTGCTGC +CGGTGAACCAGAGCGCGAGGTTGTCCGTCGGGATGTTGTCGACCTGAAACGTCATCGTCA +CGTCCTATTGCAACGTGATGGTGATGTCCTTCACCTTCATCCCCTCGTCGGAGTCGAAGT +GGTCGAGCATCGTGCTAGCGACGGCCAGTTGGAGCGACGGCGAGTAGCCGAAGTACAGTT +CGCCGGTCGTGTTGAACGTGCCAGGAGCGAACTTATCGAAATGGCACTTACCCCGGCCAA +GGCTTTGATCTTGCGGCATCGTGAATCTCCTGTGGTGGATGAAAAGTTAAGGCCGATACG +GCAAAAGGTCGTACGGGTCCGTGGTGTTGTTCGCGATCTTCAGGTTCAACGGCAGGTAGA +AGTACGAACGTCCCGAAGCACCTTCTGCGGGCGCACGAAACACGCCGGGGCCTTCGCGCA +TGCCATCAATGAGGTTTTCGAGCATGTAGACGGACGGATATTGAGGGTTCCCCGACGAGC +TGTCAATGGCGATCAGTTCGCCGAGGCGCACCTGCACGTCCGCCATAAGGCGATACGCTT +CATCGGTCGGGTTCTTGTCCCCTTCAGCATAATGAGGTTTTCGAGCATGTAGACGGACGG +ATATTGAGGGTTCCCCGACGAGCTGTCAATGGCGATCAGTTCGCCGAGGCGCACCTGCAC +GTCCGCCATAAGGCGATACGCTTCATCGGTCGGGTTCTTGTCCCCTTCAGCATGGTTGAC +CCAGCCCTGTACCAGAAGCAGCCAGTCATCCGATTGCGCCTGCCCGTTCTCGTCGGCATC +GAGGCCGTAATCGGGTCGTTGCGCTTCGAGGATCGACTCGGCAGGGGCAGTCGTCTCCGC +GCCGAATTGCACTCGGTTTCGATAGATGCCCGAAGAAAGGCCGAACTGAAAACCGTTCGT +CGGCGTGACGCCTTCCAGATGGGCGGTGAGCTTTTTCAGGATCACCAGTTTTTTAGGATC +GCGCTGCATGCTTTACTCCGTTCTACCTGTCCTCGGTCAGGGTCTCGCCGGCTCGCAGAC +GCACCACAAAGCCGTGCTTGAACTGCGTGGTGCAGCAGCCTTCGCGGGCACGCCGGTGTT +CATCGATCGTTTGGTCGATACCGCACGCTCGTCGCTGTAACGAGCGCCAGCAAGAAAACC +CTGTCCGGGCTTGACCACGACCGAGACGCCGCCCTTGCGCGTCGATTTAGTCGTCTGTCC +CGGTTCGGCCAACCGGGCGAGCGACGTAGGACGCTGGTGCGCGCTGACCACAGCTTCGAG +GTCGTTGCGCGTCGCCTTCTTGGTAACGCCAAGCCGGCTATCATCTTTCAGGTAGTTGTC +AGGGAAATTGACTTGCTCGCCGATCTCGGTGCGGGCGAGCGGGAGGGCCGTACGCTGCGC +GGTCTGATTGATCGCGATCATCGCGGCTTGTTGCGCGTCGCCTTCTTGGTAACGCCAAGC +CGGCTATCATCTTTCAGGTAGTTGTCAGGGAAATTGACTTGCTCGCCGATCTCGGTGCGG +GCGAGCGGGAGGGCCGTACGCTGCGCGGTCTGATTGATCGCGATCATCGCGGCTTGTTGC +GAAATGTCGGGAAGGCGGTTCACGTAGTCCCGGAACTCCCCGAGTCCTTCAGCGACGATT +TGGATGCTCATTCTGGCCCTCGTCAGGGCCGGACGCGCTCAACCGACCACTTGATGTCTA +CGAAATTGTCCGTGTCGTCCTCGGCATCGGGGCGAAACGTTAAACCGTAATCCGGTAACC +TCACCGAGCCGTCGCGCTGCAATGTGATGCCGAGTGAAGTTACTTCCGGTGTGTTGAACA +CCAGATAGTTGATGCCCTCGACCATGCGTGCGTACCCTTCGCGGTCGAGATCACCAACGA +GCGCCATCGCCGGGGCGTCTTGGACCTCGACGACGTGGCGTTGCAGGAATTCCTTCCCGT +GACGCTCGTGCAGATGCTCGATCTCGTCGTCGGTGAAATCGGACGGCTTGCCCGGCGCGG +CGTGAACGATCTGCCCGTCGCGGGTGGTGATGACGGTGTGCTTCGGAACGCGCTTCGGCA +CGATATTGCTCCTGGTGATTCAGATGAGAAGCCAGCCCCGAAGGGCCGGCCGATGACCTA +CGCTACACGGGTCGCGTTGTGCTTACGTGACCATCATGCGGAAGGAAGCGTTCGGCTGGG +CCGGGACCATCAGCGGCGCTCTCTCCGTCAGGAGCATCGCCACGGACCGGTCTTGTTCTT +CCCACATCTTCGGGAACATCCGGGTCGGCACGAGACCGTTCTTGAAGTCCATGATCGCGC +CGAAGCACTGTGTGCCTTGGAGACCCGGACCCGTCCCGACCACGTAGTACGAGCCGAGGA +TTTCCGGTTCGGTGTAGTCGTCGCCGGTATAAGTGTCGTGGTACGTGTAGAGTTCCAGCG +TACCCATGCCGTTGTAGCCGTCGATGGTGCCTTGATTCTGAACCGGCGAACCGTCGTCCA +GTCGCGAGCGGCTGAAGTCGGACGAGCTGCCCTTATAGAACAGGTTCAGCAGCTCGACGA +CGGCGGGTTTCTGCGAGAACAGCGACCAGGCGTCGAGGCCCATCGTCAGTCGTGTGATCG +TGCTGTTCGACTTCTTCCACGTCGTCGTGCGCATCGTTTGGATGTTCCCCAGCGGATCGG +ACGCGGCCTGATCCCACGCTGCGCCGCCCGTCAGTTGCACGGTGAGCGCCGGATCGCGGC +CGAAGTCCACGCGTGGCATCGGGAACGCTTCGCCCACCACGTCCGCGTAGCCGTAGATCG +TCGCCATTGCGCACATCCATTTGGTCCGGTTCTCGATGCGCTGGCGCTGTTCGAGCTGCG +AATCCGCGACGACCGCTTGGAAGCGCTCCTTCAACGACATGCCGCCGATAATCGGCTGCT +CGCCGGCACGACGCTTGAACGTACGGTTCGGGTTGATAACGTCCTTGGGCTTCACATGGG +CCGGACTGAACGTCTTCGTCGTGTATCCACGAGCAGCGATCACGCGGCCTTGCACGTTCG +GCCCGACGAACGGGGCGAGCTTCTTGTCCTTGAAGACGAGGTCGAACAGAATCTCGTCCG +TGTCGAACGTGATCTCGTTCGGGTAGAAACCCTGCCAGTACATCGACCGCACCGGGCCGG +ACTGAATCACGTCAGCAAGGGTGAGGGTATCTAAAATTTCCATCTTTGTTCTCCGAGTTG +TACTGGCGTTCTTCGAACGTATCGGCGGCGGCGTCCCACACCAGTACGGCATGGTTGAAA +ACACCTCCGACGAAGACCAGGTGCAAAACCGTAGCCGCGCCGGCCGCCTTCGGCTGCGCC +GAAATGCCGTACGCCTTCTGCGAGCCGTCCGAGGCGGCCGGGTTCCACGGCACGAGCAGG +CCGCAGACGAGCGCGACGACACTGTACTTTTCGAGGACCGTGACAGCAGCCACGTTCGCC +CGCGTCGTCACGATATCGGCTTCGCCCGCATAGAGCTGTTCCGGGATGTACGACCCTTCG +GTGTCGTTGCCGGCGAGATCACGAGCGATCCTTTTCTTCTCCTAGCTAGGTTGGAGGATT +GTTGCTGTATTCCGGCCGGAATACCGATTACTTCTTCTGCTGGATCAGGTCCTTGCGGCC +CGTCGGCTTCGCGAACGACCCGAGCAGCACGTTGCCGCCCTTGTTGCCTTCAGCATCGTT +GCCCTTGCCGCCGGCCGGGTCTGCGCCGACTTCCGTGTTGCTGCTGGAGTCCATCGCCTT +GTGGAACGCCATGGCGTTCTTGCTCGTATCGGCCGGATCGGAAGTAACTTCCAGTGCGGC +GGCAGCGAGCATCACCCTCGCGTCGTCAGCGGACATCTCGGTGATCAGTGCGATGTGGTG +TGCCAGTTTCGGTTTAACCTTCGCTTCTTCACAGTTCAGGATGCCTGCGTGGCGCACGCG +GTCGGCCTTGATAGCAGCACGGCGTTTGGCGGCCAGTTGTTCTTCGGTCAGTTCCATCTT +CATACTCTCCATGTGGACTTCGGTTTCGGATGTCGAACCGGAAAGCTCGTTGAAAAACGC +AGCGACAGCATCTATCGGTTTTGCCACCGCATCAATCAGCCCGAGGTTCAGCTCATCGTC +TGCCCGGTACGTCTGAGCCTGCGTATCGCGAACTTTCTGGCTGTCCATCCCACGGTTGCG +TGCAACCAGTGAGGCGAATTCGTCGTACGTGGCGTTCACGTCGGCCTGAATGGTGTCCTT +CACTTCTTTGCTCAACGCCTCGTAGGGATTGCCGTCGACCTTGTGGTCGCCGGCATGGAT +GAAAGTGATCTTGATGCCCATGTCATCGAGCATCTCGGACATATCGTCGTGCAGCGGGAC +TACCCCGATGCTGCCCGCCCCTCCCGAGGGCGTCGAGACCACCTTCGTTGCGGCGGAAGC +GATGGCGTAGGCGGCCGAGTAGCAGTTCGAATCGATGACGGCCATTATGGGCTTTTCCTT +CCGCGCTGCGTAGATGTCGTCGGCCAACTCGACGCAACCCGCTGCTTCACCGCCGTAGGA +ATTGACATTGAGAACGATGCCTTCGACATCATCATCCGCGAAAGCGGCGTTCAGTCGTGC +CCGTACGAAGTTGTATCCCGTGAGATAGCCGAAGCTGTAGTTGAACCGGTTAATCATTGT +TCCTTGTAGCGGGATGATAGCAAGCCCGTTGGAAAAAGCAAACGGTTTGTTGTCGGCCGC +GCGCTGAAAGCCATATGCCTTTGCGAGTTGCGTGCGCTGGACCTTCATGAAGTCGCCGTA +TTCGAGCGCGTTATCGACCGCCGCGAGCTGCTTCATGTCCTGTACGAGGCCGGCGTAATG +CGCGGCGACCATCTGCCGGCGCAGGTTGAACCGGTTGATTGTGATGTGTGCGTCGCGTCG +TGCCATCTTCGTTCCCCTTGTTGACTGGTTTGCGCAACAGCCGGGTCTTCGGCAATGCCG +GTTGCTGCGTCGCGTCCGTCGCCGAGCGAGCGCTTCGTGCTCAGATTGAAAGTGAGACAG +TACTTCTTCAGCAGGGCATCCTCGCGGGCGCGCTGCGCGAAGCTCTTTCGTAAGTCTCCG +CCGGGGCGCGAGATTGCGCTCTTAAAGGTCGAGAGGCCGGCATCGATCTGCATCGCGGCT +GCCTGCGTTTCCTCCAGTTGATTGATCTGGCCTTGCGACGCGCCGATCTACTCGCATTTC +GACAGCGCTTCCTTCATCAGCGGCCGATAGAACAGGTCCCGCGTCTGGCCCGGCGGCATC +GGGACGTCACCAGCCGCGATAGCCTCTTCGAGCCAAAGCGTGAAGAACTCGGTCGCGAGG +TGGTCGGCGCACATCTTCTTGCGCGCTTCGAGGAAGCGCCGCGTCATCGCGATGCCGGCT +TGGATGCTCGAATAGTTCGCCTTGCTAAAGTCCCGCGTGAACCCTTCGTAGCTCATCCCG +AACGCCGACGCCAGATGCCGGTTGAGCGACGCCTCGAATTCGCTACCGACGCCGCCCGGC +GTACCCATCGGCTTCAGGTTCAGCTTCGTGCCGGGAAACAGATGCGGAATCTTCGCGCCG +TCGATCTGGATGTTGTTCGCACCCCCGACGTACGCCTTCAGCGCGTCCATGTACTTCCCG +AAGATGCCAACCATGTCGGCATTCGACGAACAGCCGGACATCTGCGAATGGATGAACTCG +GGCGGCAGCTCGGACTCGATAGCGGCCGCGTACGACGCGTTGATGACGGCGTTTTGAAGC +GACATTTCCTTGAAACGCTTCGCCATGTGCATGCCCTTCAGGCCGGACACGGTATCGGCA +ATGCCGCGCGACTGATCTGGTTCGCGCGGTTCGAGGATGTGGATGACCTGACGACGGCCC +CACGGCGTCGATTGCTGTACCAACTTCCATTTGTACATGTCCGCGGCTATCTGGCACAGG +TCGCCGGGGTGCGCGACCTGAATCCAGTAGCCCTGCGGCCGGCCGCGCTTGTCGTACTGC +ACGCCACGTCGAAGCGTGGGCGTATCGACTTGCTGGTACGGGTTCGACAGGCGGTCGGTC +GATACCATCTGGAAGCAGGTCGCGTACGGCCGGTTCGCCGCGCGGTCCCCCTCGGCTGTC +GCCAGCACCTCGCCTGTTTTCACATAGCCGACTACGCCAAGACGGATCAGACCGGTGAAG +GTAGAGATCGCAGCATTGTCGATGTAGCAGGCGAGGGATTCCGCGTACAGCTCGAACTTC +GCTTCAATGATGGTCTGGTATTCCTCGGTCCATTCCTCTGTCGAGACGGGGATGACCTTG +ATGTCGGGCATCGAGTTGAGCCGGTGCTGCGCGCCCGCGATGCTGTCGCGCAGTTAGCCG +ACCGCTCCGTTCGTGAAGCCGTCGTTGTCGGCCATGTCCCGGCCGCGCGCGTCGGCGATC +CGCTTCAGCGGGTTGATGAGGGCATCCGGCGAGCGAAGGCTGGGGTTCCACGACACGGTC +TCTCGGGAGAGCCGCGACGCGCCTTCAAGTCCGCTCGAGATGTTGGCGTCCGACAGCGTC +GCCATGCTCGACGCCGGGATTTGGACCTCGGCCCAGCCGGAATTCTTCCGCGCGTACTGC +TTGCCGTCTGCCGGCGCTTCGGGGATACCCGAGCCCGCCGCCAAGCGAAGCCGACTGTTC +CGGGCGACCGGAAGTAACTTCGGACAGTTTGCGTACGGTAACTTTGTTCATGGTCGGAAG +GTGAACTGCAGGGGGCCATTGGAACGACCGCCGCCGCACGGGCCGCAGTCATCGCACTGC +GCTTCGAGCTGGCGGAGGTAGGTCACGAGGGCCTGCTGATCCGCCGACATGAATTCTACG +CATTCGCCATTCTGGTCCATGATCACGCGGGCCGAGCGGCCGGTCAGCAGCTTGTGGTAC +GCGTCGCGGCGCCGCCGCGAGGTACTGCCGGCAGGTTGCATCATCGAGACAGAGCATTCG +GTTTCTCCGGTAGTGGGTCACACCAGCGCGGCGGCGATTTTCGCGAGATCATACTCTTCG +CTTGGCTTTTCCGCAAATCTCTGTTCGCTGGCATCGGCAACGAGGGTGTTCTTGTCCCAC +TCTTCGGCCCAGCTCGGGGGCGACGACCAGTCGAACTTCTCGGTCAGCAGGAGCACCGAT +GCGTTCGCCCCGAGGCAGTAGTAGAGCAAGTCCCACGACCCATTACGCTTGGCCGACGTG +GCGACCCATCCCTTGTCCGTGCGCCGCTCGGAGACGAGCTGGACGTAGTAGCTGTCAGGC +AGGCATTCGGGGAAGTGAACCATGCCGCTATCGGGCGTCACCACTTCAAGCCGGCCGAGC +GCAGTGTCTTCCAATAGGTTCGAGTTCAGGAACAGAGCCGGTACGTCTCCGCGCGCAGCA +GACCATTTGTCCTTGTGGTTAGCGTCCGGGTAGGCGACTCGCGTGCGCGGATGCACCGGC +TTAGGCTCGCCCTTGATGAGATGGAAACGGCCGTGCAGACCTTCTTCGCGAAGCTGCCGG +TAGAAGTTGTACGCCATCCCCGTAACACCTTCCCGGCCTCCGTAATCGCAGAAGGTCATT +TTGAGCTGCATCACCCGGCCGCTGTCATCGTCAAGCGGATACATTTTCTCCATGACCTGC +GAACGCACTTCCTGCCAGTCTTCGAAATACGCATGCGGCTTTACCCACTCCCGGTCTCCG +TCGTGATCGACGCGCTGCGGCTTGACGACGTTGAAGTGGTTCACGGCATAGATGTCGTAC +GGATTGCCCGGCGCAATGCCGAACCCGTTGCAGACCCACATGTTCTTCTGCACGTCGCAG +ATACCGATCAGGAAGCGGAGAGCCTTCGGAACATGTTTCTCGCGCAGGACTTCGGCGCGC +TCCTTCAGCGGCTCCGGGAGCAGGACCGTTTCGATGCGGCGATGGAAATACGGTTCCCCG +AGGTCGGTGTTGTAGAACTTCTTCAACGATTCCTGCGACCCGGTACGCTCGTAGTCTTCT +TCGGCCGTGATGTAGTTGGCGACGAGTTTGCGCCACGAGATGAACGCCGCCACGATGCCA +TTCATCCAGATAGACGCAATGCGCGAGCGTCGCGGCGTGCCGAGCCGGTTGTCATCCGCC +GTCATCGACACGCCGTCCTTCAGCCAGACGCCCCACAGGTCGAGAGCGTTGTGCTGATCC +GCTTCGATCCGGCCGCCGCAGCACGGCGCTTCCATGCGCACGGTATCGGCGCACGATACA +GCGTCGCCGCAGTCATCGATCCGCTTCGATCCGGCCGCCGCAGCACGGCGCTTCCATGCG +CACGGTATCGGCGCACGATACAGCGTCGCCGCAGTCATCCCACTTCAACAGCTTGAAAGT +CGGTTCGAACCAGTCGCCGCAGTGCGGGCACTTCCAGTATCGACGGCGACGGTCGCCCCG +GTTGTACAGGCCGAGAATCCCCTTGCATGGGGGCGCTTCGTGCGGCGATGAAGCCAGCCA +CTTTCGGCCGTCTTCTTCGATCTCACGGGACGGGCTGGACTCGGCCAGCGTCATCGCGAA +CGAACCGAACCGGTTCGAACCAGTCGCCGCAGTGCGGGCACTTCCAGTATCGACGGCGAC +GGTCGCCCCGGTTGTACAGGCCGAGAATCCCCTTGCATGGGGGCGCTTCGTGCGGCGATG +AAGCCAGCCACTTTCGGCCGTCTTCTTCGATCTCACGGGACGGGCTGGACTCGGCCAGCG +TCATCGCGAACGAACCGAACGTCGTGGTCCGCTTCGACGCGAGGTCGAACGGCACGCCGG +CGCCATCAACGTCGTCCGGCATGCGGTCGTAGTCGGTCAGGCATACGCGGCCGATCGGAC +GGCCAGCGCATTCGGTCACGGACGGCCACGACAGCGTCAAGATCGTGCCATCCTTGTAGT +GCTTGTCTAACTTGTTGTCGGGGTCGCGCAAGCGCGCCGTCATCGCGCCGATCTCAGGAG +AATGACGGTGCATACGATCGATCCGTCGCACGGAGAAGTCGCGGGCTGCTGAGTTCGTCG +GGCAGTACAGGATCATGTCCATCGGGTCGACCTTGACCGTGTACCCGACGAAGTGCAGTA +GCAGGCCATCAGTCTTCCCGCACTGCGCCGGGCCGACGAAGACTTCCGCGTCGAAGTCAC +GGGACGTCAGCGTGTTCATTAGTTCGACCATGTACGGCACTGTCTCGTTGAACCAATCGC +CAACGTACGCGCCCGGCGTGTTCAGCTTTCGGTACTTGGCGGCGGCCTGCGATATGGTCA +GGAGTTCCGACGGCCGGAAGATGTCGGCGAGGGCGATGACCATCGTCTCGAGCGACTTAT +AGACCTGCTACTGGGTCGTCTTCAGTTCCTTCAAAAACGCTTCCCGCGCTGTCGCGATCT +TGACGTCCTCGTACTCTGTCCTCGCCGTCGCCACTTCCTCCGCTGCCGCCCGTTGATTCG +ATTCGTTCGGCTTCAAGGTCTCGTTCCGGTTCGTGTTTGAATTGTACGATAAGAGCGTTG +CGCAAGCTCTTCATCAGTGAGTCGTTCATCTTGGGAATGATGACGCGCTGCTTGTCGCTC +AGTTCGGCTTGGCGGTCCACCGAAGCCACCATGAGAAGTATCTCAGTTCGCAGCGTCTTG +AACGACTCGGCGTAGTGTTGAAGTACCTTCTCGGTTCGCCAGAGATCGCCCTGTTCTTCC +TCGAATTTCAGGCGCGCATTCTGCCCGCTCCAAAATTCCTTCAGCAACATCGGCGGCAGG +TCTCGATGGACTCGGCGTAGTGTTGAAGTACCTTCTCGGTTCGCCAGAGATCGCCCTGTT +CTTCCTCGAATTTCAGGCGCGCATTCTGCCCGCTCCAAAATTCCTTCAGCAACATCGGCG +GCAGGTCTCGATGGTGCGTCTTCTTGATGTGTGCCTCGAGGTCGCCAACCGGAGCAACGA +GGTATCGGGCCGCCTCGGCCACTTTGTAGATCGGGTGTCCTTGGCGCTTCCCGCACGCGC +GCAGCCCTTCAATCCGTTTCGTCACGGTGCGGTTGTCGATGATGAACAACTGCCCGAGTT +GTGAGATGGACGCGCCATCGAACAGGATTGTCTTCGATGCGCTATCCGCTCCGCTCTTTT +CTTCTGCCATGCCGGCCTCCGTTTTTGTCAGGGTTGAACGTTATCACAAGCCCGCAGCGC +GCTATCCGCTCCGCTCTTTTCTTCTGCCATGCCGGCCTCCGTTTTTGTCAGGGTTGAACG +TTATCACAAGCCCGCAGCCGTGGCAAAATTTTTACTGTACGCTGCTCGCTTCTTCATGAA +CGCAGCTCGCAGACGGCGAAGACGCACGAAGAGATCTTCCGGCGCGATGCGCTTGCGAGT +CAGGATCGATACCGCAAGGTCGTCCAACGTGCTAATCATCGTCGCATGGTGGACCCGCAC +TACATGGCACTGGCCCTGCTGGGCGAGACGACCGATGGGCTGAAGATATAGTTCGAGCGA +GTAGAAGATGTCGTAGCTATAAAGGTGATGGCCTCCCTTCTGCATGCTCAAGCCGTGTGC +CACGGACGCCGGATGAACGAGCAAGATTTTGATCTTGCCTTTGTTCCAGTCGCCGACAAG +TTTCCCCTCAGCGTCCATTACGCGCGCTCTCGGGAACGCCTTCTTCAGTCGTCCGAGGCA +GGATTTGAACCAGTACGCTACGAGCATCGGCTCGCCGTTCAGCTCTTCGACAAGTTGCGT +CAGGCCTTCGATCTTGTTACCGTGTACCCAATGCGTCTTTTTCTCCGCGTCATACACAGA +TCCGGACGCGAGCTGAAGTAACTTCCGATTCAGCGCGGCTGCGGTTTCTGCTTCGATCTC +GGGTCCGTCAGGAAGGTCGAGGATGAAATCCCGCTCGAACTTCTTGTACATGGCCGACTG +CTCATCGGTCATCTTGATGGCGCGCTTCAACAGGAGCGGCTTATCGACCTTCAGGTAGTC +CTCTGCCTTCATCACTAGGCAGATGTCAGCGATCTTCGACAGGATTTCGTTCTCGCATCC +CGGCCGCAGCTTGTACGTCCACAAGTAAAGGTTATACGTGAAGTACCGGTTGGGGTAGTA +CGTGATGTTGTTGCCGAGACATTCTCCCTTGTCGAGATGCCAAATCTGCGCGAACAGGTG +TTCCTAGGTCTCGGCAGCCGGCGTCGCGGTGAGAAGTTGCAGGCGCTTGATATACGGGCG +AACGGTATTCAGCTTCTTGAAGCGGATCGAATTGTGATCCTTAAACGACGACGATTCATC +GATAAACACGACATCGAAAGGCCACATTTCCCCAAACAGGACGATGAGCCATTCAAGCTG +TTCCCGGTTAATGATGTGAAGGCTCGCCGGGGTGCGCGCGAGGCGTTGAAGGATCTCTTC +CTTCATTTCGGCTTTCACTCGCGCCACGTCTCGCTCAAGCTCGGGATCCGGTTGCTTGCG +GCCGTCGTCGCCTCGTGTTGTGAAGGCCCGATAGTCGGAGCGAGCGCGTTGTTTACTGCC +TGCCTCAGCGATCAGTTCAACCGACTTCTCGTCTTCCGCGCGGATCACGACATGGGACAT +GTACGCCGTGTGCTGCCAGAGCGGAATCTCGTTCGGCCAAGTCTGCGTAGCGACACGCAG +CGGCGCGATCACGAGACAGTGCTTGTATGCGAAGCGCGAGAGTAGCGGATCGAGCAGCGT +GAGGCAGATGACCGTCTTCCCCATGCCACGGTCGATGAACAGTGCGCTCAACGGATTCTC +TTCGAGAAAGTCCACGCATTTGTCCTGATCCGCATGCTGCTCGATCGGATCGTACTGCAC +TCTGTGGAACATCTCAGAGATGGTACGACGCAAGGATTCGGATTGCATCTTCATGATTGT +CAGCCCAATGAACGTACCCGCCGTGTCGACACATCTCGTCGTGCTTGTTGTACTGGTGTC +GCTTCGGTTCTGCATCCTTCCGCTTGAACTCGATGAAAACGACGATGCCCGACCGGATAT +ACATCCGATCGGGCACACCACGCTGACCGGGAGAGGCAAACTTCGCAACAAACCGTCCAT +TTGCCTTCGCCCAATCGTTTGTTTGGTCCTCTATGCGCGTCTCCCGTACGGGAGGATCGG +AAGTTGCTTCCGATTTTTTTGGAACCGGGAGTAATTTCACGTCTGTCCTTGCAATAGAAC +GAGGCCGGCCATCCGGCTGCGCCAACAGGCATCTCTTCGTACCACTTGCGCTTCGCGGTC +TTGCACTCCTTCAGGACATGCAGCCCCTTCGACGCGTCGCCGATCTTGCGCAGGGTGACG +ATTTCATCGTGAATGTGCAGAACGATATTGAGGCCCTACTTATGCGCGTTGAATAGGCCG +TACTTCAGGATTTCCCGTGCGATAGCTTGCACGAGGTTTTCAGTCATCTTACCGCCGTGC +GAGTCCTGCCGCAGCCACTTCTTGATGTCCTGATTGAAGCCCATGTACGAGAAACATGCG +CGTTGAATAGGCCGTACTTCAGGATTTCCCGTGCGATAGCTTGCACGAGGTTTTCAGTCA +TCTTACCGCCGTGCGAGTCCTGCCGCAGCCACTTCTTGATGTCCTGATTGAAGCCCATGT +ACGAGAAACCGATCTTCTCGTATGTCTGCGGCGAGCCGTCTTCGTTCCAGAGTAACTCGC +CTGTCTTCCAGTTCTTCTTCTGGAATTTTTTCTCCTCGATGCGCGGTCGATGGTAGTACA +TCCGGCGACCGCTAGGCAGGATCGCCACGAGGAATTCACCGACGATTTCAAACGACACAT +AACGGACGCGCGTGACCGCCTTCGTCTTGATAGTGCGGATGATAGCGGCTTCGAGGTCCT +TCCAGAGCTGCGGGACCTCGGGGTACGCCTCGCGGTACATCTTCACCGAGTCGTGCGCCT +CTTGGCGGGACATGTCGATACCCATGTTCTCCGCGTAGCCCCACAGACCGGTTCGCTTGC +CCTCATGGCTTGCGGCTTCGAGGTCCTTCCAGAGCTGCGGGACCTCGGGGTACGCCTCGC +GGTACATCTTCACCGAGTCGTGCGCCTCTTGGCGGGACATGTCGATACCCATGTTCTCCG +CGTAGCCCCACAGACCGGTTCGCTTGCCCTCATGGCTTAGGTCGCCGCCGCCGAGTCGGT +ATCCCGCACCGAGCACGACCGGTTTCGACATCGTGCGCATCTGCGAAGTTACTTCCGGGT +ACTCGACGCCGTACAGCCGAGTCGCGAATTCTCGGTACGCGCAGCGCCCTTCACGGAACA +CGTTCAGCAGCGGCTGTCAATCCACGAGCCATGCGATCACGACGGTGTCAATCGAGGACA +GGTCGCATGTAACGAACTCGTACCCCTCCGGAGCGTAGATCGCGCTACGCACGCATCCGG +CGAGACCGTCCAAGGGTTCCTTCATCATCAGGCCGAGCAAGTCGTAATCCCCCGCTTGGA +TGGCGTTAGTGTCCGTGCAGAGCGCCCAGTCGATGTCGCCGTCCGGTGCGAGCGCTTTCG +GCGTACGGCCGAGGTTTTGCACTTGAACACCGCGTCCCGCCCAGCGATGCGTGCGCTGCG +CGCCTCCGAACTGAAGGGGAACACGGAGACGCCGGCCGGGGCCGACGAGGGAAACGCACT +TCTTGTACTTGCCGACCGACGTGCGTGGAGACTGCATACGCATCTTCAGCACTTCGTCGC +ACTGCCCCGTCAGCACCGGTTCGTCCTTGTGTTCGGCGAGGCCCTTCTTGACGGTATCCT +TGCCGAGGTCATCGAAACGATACCCGCGTGCCTCCACCCATGGTTTGAGCTGCTGCGGAC +TGTTCGGATTTTCTAGGCCGGTGATCGCGCGCATCTGACGAACGAGTTCCAGCTTGCGGC +GATCTGCCATCGCGGTAGCGCTGTTACAGAAGTCGAGATCGACCGACACGCCGCGATCGT +TGATGAGCTGATCCAGCTCGTACAGCTCGCAATCTTCATAGAGCGTGGGGTACGGAGCGA +GCCATTCGTCAATAGCGGCTTCGGCGATCACGTCCTCTTGGTTATAGATCAGGAAGTCGT +CCCATTCGAACGGGTTGGTCTGCCAGTCGAGCCACTTGTGGGGGTTCTTCTTCGTGATGC +GCTGCGGCTTCGAGAACAGGTTGATTAGCTTCTTCCCGGTCGCCAGTTTGACCTTGTCCT +GCGGCAATCCGAGCTGCCCGCCAACCATTTCGAGGTTTCCAGCGAACGACAGCATGTACG +CACGCACCATCGCGCAGCGCCAGTTTTTATACGGCGTGTTGATCTTCAGCACACGACTCG +TCATCACGCTCTCGAACTGCGCATTCCGCGCCCGCTTGATGGCGTTCGGGTCTTCGAGCG +CCTCGCGAACTTCCGCCGGGAACCTGCCGTCTCGGATTCCCCATTGCTGCACGCGGCCGC +CGTTGAACGACCAAGAAGGCATTCAGGCGGTCTGCTGCGGCAGCCGCAGCCTGCGTTGCC +TGCGCCTGTTGATTCATCGCCTTGGCGACCTGCTCTGCCTGCTCGGCGACTTGCGCTTCA +AGGCCACTGAGTTCGGCCATGGACTTCGTCAGGCTGGCCGTGCGGGCATTGGCCGCCTGC +ACATCCTGACCCGCCTTCGCGGCCATCAGGATTTCAGTGGACTCGTGCGCCGAGTAAATG +TCGAGGCCGCACGTCGGAAGGTCCTCTTCGCTACGTGATTCGTAGTCTAGTCGAATATCG +TCTTGCATATCAGTTCTCCGGTTTCACGAGGTCGAGTAGCACGTAGCCGTGGCACGCTTC +AGGTGCGCAGAAGCAGACGAGATTCCGACCACGCATCGTCGGCAAGAACGACATCAGCGA +AGGGGAGTTGAGGACCTGCTCTCGGTACTTCGCGATGACCTCTTCGCGCATTCCGTCTCG +GCCGATCACAAATGGGTTGCCCTACCCCGAAGGGCGGCCGATGTAAATGCAGCCGTCCGG +ATAGTCGCCTGCGTTCTTGTTGAATACCTTCGGCATTTCAGCACCCCAGAAGAAAAAAAC +CCCGGCACGGCGGGGAATAACCGTGCCGGGGCGAACAACCTGCGCGGAGGAATCGGACCC +GCGCACGCATGCGAAAGGAATTACAGGCCGCCGTTGTCGTCGTAGCCCTCGGCGAGCGCT +TCCTCGCCGTCCGACACGTCGTCAAACGAATCGTCAATTTCGTCTTCGCTGATGCGGCCT +TCGCCGATTTACAGGCCGCCGTTGTCGTCGTAGCCCTCGGCGAGCGCTTCCTCGCCGTCC +GACACGTCGTCAAACGAATCGTCAATTTCGTCTTCGCTGATGCGGCCTTCGCCGATCGAC +TCGTCGTCACGAACGAACTGGACCGCAAGCAGGTTCGCGTTGATACGCTTGCCGAACTTG +TTGTCCTACCACCACGGGTTGATGAGAATGTTCACGCGGTAACCGGAGTAGATGGCGTTT +TCGATCTCACGCTCGCCGAGTAGACGCTTGTCCGCGCCGCTCACGCTCGGACGCTTCGTT +TCCGATGCATTTATAGTGTAGCAGCCTTCGTATTCGTTCTTGCCCGGCGCGTCGCCGTCG +CGGAGGAAAAACTTGTCGGTCGGAATATTCTTGCCGTCGTTCTTCTCGCGCAGAATCGCG +TCGCGCATTTTCTTCATCACTTCGAGAACGGACTTAGCGAAGTCCTTTTCGATGAAGCCG +ACAAGCGAATACTTTTCCTGCCCTTCCAGATCGTCGCGCTTGTAGGGCTTCGCCAGATGG +GGGTACGACGCCCGCACATTCTCGATACGCGTGGTGCCGTCTGTGAAGGCGACAACGTTC +TTCCCTTTGAACTTGATTTCGCGTGCCATTTTGCGACTCCTTCAGGTCTACCGTTTTACC +GGTCTAGGGTTTCAGGCTCTACAGGTCTACGGGTCTACAGGCCGTCGTCCGGAGTGAGTT +CGTCAAAGCAGTCATCGGCCACTTTCCCCAGCTTCTCCCGCGTGTCTGCGACTGGAGCCA +AGGTCGCCTTGCCAGGCGCTTTCGCGACGAGCGGGGCGATAATTTTCTCGGCCGCTTTCT +TTCGCATGCCACTCGCGACGAGCAGTTCTTCTGCTTTCGCGGGGCTGACGAAATCGGTCG +ATAATAATGCGTTTTCCTTCACGCCAAGGAATGTGAGCGTTTCACCGGCTTTCGCCTGTT +GCACGTTCCAGCGGCGATTCGATCTGGATGCCACCCGTTTCATGCCGGGGATGTCCACCC +CGTTGTGCGCGCGTCGCTCCAACTCGGAGTCCATTTCGCTGAACCAGCGCTCGTATACCT +TCCGGTACGGAAGTAACATCGCCATTTGTTCAGTCGAAAGCTCGGAAACCGGAAGTAACC +TCGTGCTCAATTCGCCGCGCATCAGGACTTCCTTACAGCTCGACATCTGTTCAACGGTTA +CTTCGGCTGTCAGGTCGTCAAAGCAGTCGTCAGAAAGCCTGTGCGCCATCGCGAGAAGCG +CCAGACAGGTCTTCTGCACCTTGCAAATACGGCATCCTTTGTCGGACGGCGTGAGCGGCG +CACCTTTCTGCCAAGCGAGAAATGCCCGGACCTTCACGAAATCGGCGAAGCGAAGCATCT +CTTCCCGAGTGGTTTCCCACGTCTGGAAGTGTGCTAGGCGCGGTTGCGAGATGTGGACGA +CGACCTTACGGAATCCGTAAATTCAGTCGTACTCGTAGAGCGCGCCGAGCGCATAGAGCA +TGGCTTGACAATTGCCGTTGATGATCGTCTTGCCGTTCTCAACGATGATCGAAAGCGGAT +CGTCCAGTCGCAACGCCGCGAAGACCTGAACACCGCGGCCGAACTTGTGGTCGAGGATGT +GCATCACACCGGGTTCGAAGCCGCCCACGTCCATCGTGACTCCTTGACGCGGAATCGGGG +TGAGCTGGGAGAAGTACACGCGCTTCTCGATAGGCAGGTCGCGGGGAAGCGAGTGCGCCC +ATTCGACAGACGGCGCGACGTACTCCATCATCTCCGTGTCGGTCGTGATATCGAAAACGG +TCTTCCCTTCGACGACCTGCTCGACCGTGCCAAGCAGATGATCGAGGCGTATGCCGGTCT +TCAACCACGTCTCGTTCGTGTGGAAGCGAGCGGTCAGCGGCGTCTGCGCACCCGTGACGG +GGTCAGCATAAAGCGCTGATACCGCCAGAGTGTCATGGACAGTCTGACGGACCAGCGCTT +TAAGGGCGGCGAAGTCGCCGACCATGGCTTACAGGCCCGAGGCCGACGCTTTCGCGCGGG +GCTTCGCCGGCTTCGACGCCCCGGCCTTGTCGCCGTCTTCGCCTTCGTCGCCGGACACGC +CGTGCGCGCCAGCGCCGTATGCAGCGTCTTCGCTTGCGTTGTCTTCTGCTGCGAGATTGT +CGTGAAGGGACCCGGCGCGTGTGAGCCACAAGGCAGACGCACTCGGGGAAAATACCGAGT +GGCCGCCTTGCTCGATGTTGAACTTCAGCGCATCGAGATTGATCGCGTGTTCGCTCACGT +AGAGGCCCCGGAAAAGTTGTTCATTTTGAGCGGCACTGACATTGTGTGGTGCACCGTAGA +GGCCGGGAACGCTTGCCGGTGCACCGGAAAATACCGAGTGGCCGCCTTGCTCGATGTTGA +ACTTCAGCGCATCGAGATTGATCGCGTGTTCGCTCACGTAGAGGCCCCGGAAAAGTTGTT +CATTTTGAGCGGCACTGACATTGTGTGGTGCACCGTAGAGGCCGGGAACGCTTGCCGGTG +CACCCGCCAGTGCCGCTCAAAATGAAGCCCGGACGAACCGGGCTTCTTCGCTGCACGTCG +AGACAATATTACAGGCCGTCGCTGCCGTCGCCTTCGTCGCCGCCCGCGTCTTCTTCGAGC +GCCTTCTCGGCCGCGTCGTACGTGGCGCCGAAGTGTTCCGGCTTGATCGAGGCCGAGGTC +TTCGGCCTTGCCGTACTTCTTGATGATCGCCTTCGCGTAGTCCATCAACTTTTCGTCCTT +GACGCGGATCCGGATCGCCTTGACCTCGTCGGCCGAGTGCTTCGGCTTCGTTGCTGCCTT +GCCGTCGCCCTTGCCGGCCGCCGTGGTCGTTGCCTTCGTGCCTTCAGCCGCCTTGCCGCC +GCCCGTACCGCCTGCTTCCGCGATTGCCTCCGTGACTGCCGACTTGATGAATTCCTTCAG +GGCGTTTTCGAAGCTCATTTTTCCGACTCCTAGTGATCCGTAGATGGGTTGTTTGTGTCG +TGGCGTTCACCACGGAACGAATCATGCCGGGGCCGGTTTTGTCCCTTGCCGCCGCCCGTA +CCGCCTGCTTCCGCGATTGCCTCCGTGACTGCCGACTTGATGAATTCCTTCAGGGCGTTT +TCGAAGCTCATTTTTCCGACTCCTAGTGATCCGTAGATGGGTTGTTTGTGTCGTGGCGTT +CACCACGGAACGAATCATGCCGGGGCCGGTTTTGTCTCTCAACAACTTTTCGAAAATATT +TCAAAGACAAATGGGAATCTGGCATACTCCGCGCTGTATCAACCTTCATCTACCTACATA +AGAGGACTAGAAACATGGTAATCCCTATGCCCGCATGGTTCGATGCGCTGTCGCCGGAAG +AGCAGGAAACCGAGCGCACGAAACTGGTCCTGAAGCTCGCCGCGATCTACGCTTCCCGCG +GGAATCTGGCATACTCCGCGCTGTATCAACCTTCATCTACCTACATAAGAGGACTAGAAA +CATGGTAATCCCTATGCCCGCATGGTTCGATGCGCTGTCGCCGGAAGAGCAGGAAACCGA +GCGCACGAAACTGGTCCTGAAGCTCGCCGCGATCTACGCTTCCCGCGAGCAAACTGCTCA +TCGTTTGTCCGAGCTGGTGGGCTACTCGTCCAATACGCTCGGCGCTCTGTCGTCTACCGG +CCGCGCGTTGCGCCCGGAACTCTGCATCGATATCGAGAAGGAGGTCGGGCACGAGTACTT +GCCGCGACGCTTGCTCAAACCGCATATCTTCGAAGTGCCGACCGCAGGAGAGTAACGAGA +TGGCCGACCAGACCACGGCCACCTATCTTGCGGATCACGGGGATGCACTGATCGCGAACG +GGTACAACATTGTCCCCATCACACCCGGCGAAAAATTCCCACCGCACGACGGCTGGCAGC +AGACAGTAGCAACGCAGGCGAAGTTGAAGACGTGGCTCGCCACGGGTAACGAGATGGCCG +ACCAGACCACGGCCACCTATCTTGCGGATCACGGGGATGCACTGATCGCGAACGGGTACA +ACATTGTCCCCATCACACCCGGCGAAAAATTCCCACCGCACGACGGCTGGCAGCAGACAG +TAGCAACGCAGGCGAAGTTGAAGACGTGGCTCGCCACGGGTTTGAAGTACATGGACAACG +GCGAAGATCGGGTCGCCGGTGTGAAGCTGGCCGGTGTCGGCTTCCTGACAAAGAACACGC +CGGGCGTCGATATCGACATCTCGGACGAAGACTTCGCGAAGCACATGGAGAATTTCGTCC +CTGAGAACTTCGGGATGGCTCCTGTACGCCTCGGCCGCGCGCCGCGCCGGCTACTTCTCT +TCCGATGCACCGAGCCGTTTTCGAAGGTCAATTCGGGCGTCTATGTGGACGAGTGGGGCG +AAGCGCGGAAGGTCGATATCCTCGCGAACGGCCAGCAGTTCGTCGCGTTCCGCATCCATC +CGGACACGAAGCGGTCGTACGAATGGCTATACAGGCAGTCGCCGCTCGACATCCAAGCAT +CCGAGTTGCCGGTGTTGCGCCGCGTCGATGCGCAGGCCATCGTGGACGAGTTCGAGAAGC +AGGCCAAACATCAAGGCTGGACGCCGAAGAAGCGCTCGCGCACCGCGCTGGAACGCTGCG +AGAGCGGCGGGGACATCGATTACGACGACCCGTTCGCCGCCGACGTAGCGAAGACCGATA +TCGGCGAAGACGAGCTGCACGCCAAACTCCTGCTCGTGCCGGACGCTGATGATTACGAGA +CGTGGGTCAACGTCGGCATGGCGCTGTTTCACCAGTTCGACGGCCACGAGCGCGGCCTCG +AACTCTGGCACAAGTGGTCGGAGACTGCCGACAACTACGACGCGAAGAAGCTGGACGCGA +AGTAGAAGTCCTTTGACATCAGCAACAAGTCGCGTACGCCAATTAACACCCGGTACATCA +TCAAGCTGGCGAAGGAATCCGCCGAAAAAACCGCCGAAGAAACGATGGTCGCGCTGCAAA +AGCTGCTCCTCGAAGCCACGTCGATGAACATGCTGAACTCGGCATGCAAGGCGATCAAGA +AGGCGACACTCGACACGCCGTCGCGCGAGCTGATGGTCACATGCGTACGGCAGGCGATCA +AGCGAATCAACGACGGCTCGCCCCTTCCGCTCAGCGCTGCTCGGCAGATGATTCGGTTCG +AGAACCCGGAATCGAAGCACATGCCGAAATGGCTGATGGGCTGGACGTACCTGACGCTCG +ATGACAAGTTCTACAACGTGAACCCGCAGGAGTACATGACGCGAAGCGCCTTTAATTCGG +CGTTCGTACGTTTCCTGCTCACGCCACAGGACGTGTTGGAAGGCCGCGTCGTCCCGGACA +CGACCGCCGAGAAGATGGCGCTCAACCGTCATCAGATTCCAGTATTCCGCACGTGGCTAT +ACCTGCCCGAACACGAAGAGACGTACATCATGAACGGAGCGCGCTACGCGAATCTGTACA +CGGACAAGTCGGTCCCGGAGTGTCCGTCAAAGCTGACGAGCGAAGACAAGCTGAACGTGA +AGCGCATCCTCGACCACTTCAACATGATGATCCCCGCTGACCGCGTCATGAACGGAGCGC +GCTACGCGAATCTGTACACGGACAAGTCGGTCCCGGAGTGTCCGTCAAAGCTGACGAGCG +AAGACAAGCTGAACGTGAAGCGCATCCTCGACCACTTCAACATGATGATCCCCGCTGACC +GCGAGCGCGGCATCATCATCGACCGGCTGGCATGGATCATCCAGACGCAGAAGCGGCCGA +ATTGGGCGATCGTGTTGCAGGGTACGGAGTCGGACGGCAAGACGCTCTTCAGCGACATGA +AGGGCGTCATCCTCGGACCGGAGAATGTCAAGACACTGAACGCCAAGACGCTCGAAGGGG +CGTTCAACGGCTGGGCTGAAGGATCGCTCCTGAACCGCGTCGAGGAAAACAAGCTGCACG +GCCACAACCGCTTGGACGTGCTCAACCAAATCAAGCCGCTCATCACGAACACGGCCATTG +AAATTCACCGCAAGGGAGTAGACCCGTACAACGCGATAAACACCGCCGTATACCCGATGC +TGACGAACTTCACAGACGCGCTGCCGTTCGTGCGGAACGACACGCGCTACTACGTCATGT +TCGGCCGCATGCAAAACCGCGAAGATGTCGCGAAGTTCAAGGATGAGAACCCGAACTACT +ACGGCAACCTGTTTCAGGCTCTAAACGAGTCCGCCGGGGCGCTGCGGAAATTTTTCTTCG +AACACGAGGTGAGTTACACTTTCGACCCGATGAACCGTGGGCCGGATTCCACGGCACGCC +GCTATATGATCGCCATGAACCGCTCAAACGACCTGGAAGCCATCGAGACACTGATCTCGG +AATCGATGAAGATCGACGTTTCCTCGGCGCTCCTGAACGCCAGCAAGCTGCCGGACCTGA +TGGTTGGCATGGATTGCGAACTCCCGCAAACGAAGGTCTTGCAACGCGTCCTAAGCGACA +CCGGATTTACCTTCCTCGGACTCATTCGAATCAACGGGGAGTCCTCCCAATACTGGGCCA +AATCGCCGCAATACTTCACGGTGGACGGGTCGTCCGAGATCGATTTCGACGCTGTTCGGT +AGTACGCCGGGTGCGGTTTGTAGCCGAGGTCCAGATCTGAATCATTTTTAACTTATTCGG +ACCTTGGCCGTTTTCAGGCCCTTCGGGGGCGTATCTGCGACTGTTGACCTTATCAGAAAA +GCGTCATTTTTCATAATGCAGTAAAAAACGCGGACCGAATCACGCCAAAAACCTCCGGAC +CTTCGATTCGGACCAGGACCATTAGAACCCCGGCTCCGCCTTGTCCTATAAGGCTTCCCT +TCCTTCTCTTCTTCTACTATTCTATAGATAAGGTCCAAATAAAGAAGAAAGTAGAATAAC +CGTATAGACATAAATCCAAAAAAATTTTCGTACAGATATAGAATAGAGAAAACGATACGG +TTCGACCCTTCGGACCTGCACCTGGCCGGCCATTCTCGTCCTCCTGACCACTCAAGGTCC +GAATGGGTGGTTTGCCCTCCACTCCGCCAAGGTCCAAATCCCCTATCCCGCGATTCGGTT +CCAATCACGTTCAGGATATCTGCGTTGCGCATCTCAAAATCGGTAGTAACTTCGGACAAA +CCGTTGTCGCTCAAATCTTTTCGCGAGAACTTCGGGGGAGGGCAGCGGCGCTATGACGTA +GAAACGAAGAAACGGGAGATCGGGGCTCTGCGCCCT diff --git a/example/fna/NC_005091.ref.fna b/example/fna/NC_005091.ref.fna new file mode 100644 index 0000000..ba36db9 --- /dev/null +++ b/example/fna/NC_005091.ref.fna @@ -0,0 +1,959 @@ +>NC_005091.ref length=57455 +GCTCTGCGCCCTCCCGCCATTCGCGCCTCGCCGGATGGGACCCCGACGGCCGCCCCGAGC +GATCCTCATCGGGCCTGCGCGCCAGCCAGTGACACGGAGACACGATCAAACGAATCGTCT +AGTGACGCGGCGACACCAACACGCAGCAGCCCGCCGCGTAGCCTGTATGACCGTGATACA +GGCATGCCGTCATGCGTGCGCACGGCCGGCCAATGCGGCACTGCACGAGCGACACGGAGA +TACGGCCATGCGTTGCGGGCACGCCACACGCGGCAGGCCGTGACACGGGCAATCGGGGAT +TCGGACCTAGCTGTGAGACGCGCTGCGCCGTACGGCCGATGACATGCGGCCTAGCTGGAT +CGTGTGGATTCGGACCCATGACCACGAGTCGCACGCTATGCGATTGGCCGGGTCTAGCTG +GGCGGGATTTCCGCTACGCTTGTGCGTGCGACGGTTTGAGGCGGGGCAGGATTGGGGCTT +GGCGGGCGCGCTAAATGTCCCGTTGCGTACCTGGGCTAAAAGCGGACATTCTGACGTGCG +GTGCTGCGGGCGCGCTGCTGCGCACCGTGTGCGGGCGGGGCGATGGGCGTAAAAAAGCCC +GACACGATGGCCGGGCGAAGGGTGCTACTGGATGGTGTGGGTTAGCCGTCCCGTGTGTGA +CGCCAGCCTTTTAGGGCGAGTTGATACCAGTACCCACCGATGCGGATGACGTGCGGCTTC +TCCCCCGTCAGCACGCGATGGGCTGCTTTGGCAATCCACCATTTCGGGTCGTGCAGCCAC +ACGAGGCGCAGTTCGTCGGGCGTGCGCCGTACGTCGAACGCGTCGATAGCGCTCGTGCCG +TCCGCATCATCGGGGTCGTCAACCGCTACCACGATTTTCACCATCCTGCCGGGGCTCGCG +CTGAACACGCGCGGCACTCTTAGCAATTTCGATCCGGGCATGACTGCATCCTTAGACGTT +GAACACGTAGCGCACGAGCGCGACGAGCAGGCCAATTGCGAACACGACGAGCGGCAGGCA +GAACGCGCCAGCCACGGAACCGACAATGTAGACGGCCGCGTCGGGGGCGTCTTCGTACCG +CCTGCGCGGTTTGAACCGCAGGATCGCCGGGACGATCAACGCACCGATGACGAGCGATGC +CAATCCGATCGATGCGGCCGTGTGATTCGATATTCCGCCGTCATCGGGTATCGGGTAGAG +CCGGTCGACGCATTGCGCGTAGCTCTGCATGCGGGGCACGTCGGCCGTGCGTGAGTCGTA +CGAGACAATCACGGCTTGGCATGCAGCACGCTCGGCTCGATCGGCTTCTGCCGATGCGAT +CGCCGCGTTCGTGGCGGCTTGCGCGTTGAGCGCGGCACTCAGGGCAACGGTATCAGTTGG +CATCGTCGGCCCCTGCGGTGCGTGTGCCGATATGCAGGCCGACGGTAGCGCGGTTCCGCG +TATTGCGGATGAGTGCAACCTGTTCGACGGTCAGGCCGGCACGCGTTGCGCTCGATTCGT +CGGCTATCACACAGGCCGTGAGAACGAATTCGTTGAGCTGAACTAGCGCCGCGCCGTACG +GCAACGATTCGTATTCTTCCAGCTCGCGCAACGAGTCGAACGAACACGATTCGTCGTTCC +AGACTTGCGCGCCGACTACAGGGGCGCACTGGAACCGGCCGCCCTTCATCATCACGCGGC +CGAATTTGGTCGGGATATCGGACGGATGCACCTTGCGCGTGTCGCGACGCCAGATAGAGC +CAATCTGACGTACGGGCAGGTCGATTTTCGCGACCGGCATTGCGGCGATCGTCTCAGCCA +TCGTCGGCTCGCGGCCGATCACCCGGCAGGTGATATCGCCATTCACGAGGGTCGATTTTC +CCGTCTTGCTTTCGAACGCGCGGGCCGCCAAGCGTCGCGCGATGCTGTCAAGATCGAACG +ATACAGCGACCGTGAAAACTTCGCCGTTCGCACGGTGCGAGTAGCTCTTCGTGATTGTGT +ACTTCGCCATTGTCTTTCTCCTTCGTGTTGCGTTATGCCAAACGGCCGTAATTGCGTTCG +TGAGATTCGACGTAATCGCCAACCGTCGTAAGGCGGATGTTGCCGGTGCGGTAGTCGCGC +AACAGCGTCGCGTTATAGACGTCGCCTGTGTTGACGTACGCGGCGGCCGGTTCGTCGTTC +CGCTCGTGCCGCAGATATTCGACGCCGTGACCCTCGATGAGGCGATTGAGCGTCGCCATG +CTTGTACCGCTCCGGATAGCCGCGCGCACGACGGCCGCACGCTTGATATCGAGCCGCAGT +TCGCGGGCCAGCTTGGCAACGCTCGGCGCGCGTTGCACTGGTGCATTGTTGGTCGTCATG +GTTACTTCCCTTCGTACATAATCCGGGCAGTGCGAAATGCAATCGCCCATGCTTCGCGCG +GGCTATAGCCACACGCTCGATGAATGTGATACCCGCCGTTTGCCGCGTCAGCGACCGCAA +GCGCGGTGCGCACGGGCAAATCGGCAAGCGATCGATAGTCGTGCATGGCGGCGGTAAGGC +TGGCATTAATCGACCAATCTACGCCGTTCAGATAGAACGAACGCCAGCGCGCCGCTTCGA +TCAACGCCTCGCGGAAACGGTAAACCGGCATAACTGCACCGTGCCGGGCAGCAACATACA +TCGTTGCTTCCCACAGCGACGCGCGGCGATTGACGGCCGTTCCATCAATGAAAATCGCCC +ACGGGCGCGACGGCGACGATTTAGGGTCGTACGTGAGTCGAGCCGTACCGCCCCAGCTAC +GAAAGGTTTGTTGATCGCGCCACATGGTTAGGCCCCCTTCCGAACAGCCGCGTAGAAAGC +CGGCGTTACGCGGTTGATACCGTACAGTGCGCGGAACGCCTTGCGCGGGTTCGTGATTTG +CGCCCGGTCTTCGCGCAGATACATCGCGAGTTCGTCTACGGCAGCTTGAATCGCGACTGC +ACGCGCAGCGTCGACAGCCCCGGTCGTCGCTTCCGCCCACTTGGCGATGCCGCGCGGATC +GCATGCACGGGCCAGTTCTATCGCATCGCGAGCCGTAGAACCGCCCCCGCGCAGTATCTG +ATACGCGGCCATGCGCATTGTGTCGTGCGTCGCGTGACGGGCGCGCAGAAGCGCGGCACG +GGCGCGATTCGGCATGATATGCCGAATGAAGCGGCTTTCCAGTTCGCGGCCATTCGGGCG +AGCGATCATCGCGTCATACGCGCTCGTATCGTAACGCGGCTTTTCCGTCATCGGAACAGA +AACCATCGTCGTGCCAAGCTTCAGCACTTCGCGCGACTCGCGCAGCATCGCATCCGCGAT +CTTCCCGGCGTCCGGGCGTGCGGCTTGCGCGCGATTGTGTACGGCCATGGCGACGATGAT +TTGCTCACCATTCAGGATCGCGAGCGCATCGGCAAACGACGGCTCGTCGTAACCCATCAG +GCGCGGCACGAAGGAAAACAGCAACACGCCGTGACGCGAGTAGCCGAGTGCGCTACGGCC +TTCGATATGCGTCCGGTAGCTCGCGATGGTCGGCGCTACGGCGTCGCATTTCGGGGCGAG +CGTGACTTCCTCAATCGCGAGATACGCGCCGCGCGCTTCGAGATATTCCGCCGCATTGGC +GCGGCCGTATGCCGTGAAAAGGCGGCCGTCGCCGGCGCGGGGCGCGTTGCGGACGATGTA +ATCGAACGACCAGCGGCCATTTACCGCCGGGGGCGTCCCGATGACTTCCAAATGGCCGAC +ACGGACCCGGTAGTGCGGGGCGGCTTTGACAGCGGCTTGAACCTTTGCGAGCGTGATCAT +GGCAAGCCCCTTAGTGTGCGTTGCGGATCGATTCGACAGCGGCCAGTGCTGCGTCGCATG +CGACGTTGAGGCGACGGGCGAGCAGGACGGAATCGAGATGACGACAAGCGCGGATGTTCG +CGAGACGGCGGCGGAAGGAAAACAGGAAAGCAAGCATGGTTAGCTCCAGTGGAATCAGGG +CGCGCCGGGCGGCGACCCCATGAATGAGATTCTAGGCGATAAAGTTAAACCTTGCCAAGC +TGTTTTTAGAATTCGGTGTCGTGAATGTGATGAAGGAATGGCGCACACGGGATCGGCGCG +ACGCACGCGGTAACGAACAGCCGGACGAAGCATGAGAACAGCCCGGAATCCCACAAGCCG +ACAGCCGCCCAAGCGATGCCCGAACCGAGGATGAGGTACGACACGACCAGACGGGCGCGC +ACGCCGGCCAGTGCGACGGCTTTGCGCTGGGAAAGGCGCGGATGTTGAACGGCAACGCGG +TTTTTCATGACGGGAGTTCCAATCATCAGGATCAGGGACGCGGCGGCGATCAGGCCGCAC +GCGGCAGCAGCATCAAGCCATTCATTCGCCATCGTTCGGCGCTCCGACGATTTGTTTGCA +GCCGGCCGCGATCAGGTACAACCAGCCACGGTAAAACTCGCAATCGACGTGCCACATGCG +CCAGTCACGGCGAACGAACGCGAGCAGCCGTTCGCCATGCTCGCCGCGATCAGCGAACCC +CGCACCATGACCGGCGCACGTCAGATAGATGTCTTGACCCAGCGCGGCAGCCGGATCAAA +TCCGCAATCAGGATGCGCCCCGTAACCGTTGGTCGCGAGCATTGCGGCGACCGTTTGCGG +GTAGCGCTCAGCGAACGCATAGACGAACCGGCGCGCTGTCTCGCGTGATTCCGCTGTAGC +GCGCGGGCGCGAGCCTTCCGGTGCATCCGCCCAAAGTGCGGCGATGATGAAATGGCGGGC +GGCGGTTTGGATTTGTTCGGGTGTCATGGTGATACCTCCGTAAATGGCGGAAAGGCGAAC +TAGTTCAGTTGAAAGGCTCGGGTTCATTCGGCGTGTCTCTACAACGCTCGGCTACGAGCC +GGGCCATTGTGGCCGCCGCCTGAGCAGCAAAAATCTCGTTGATGTAAATGCAGTCGTAGG +TGATCTCGCTGGCCGTGCATTCGCCCTTAGACCATCCCGCCAGAAAGCCGCGCCCGTGCG +GCAAGCGGAAGACGACACCGCGTATCGTGTCGCCATCGCCGTGTTCATCGGCGAACCATC +CAGTATGGTTGATGCACGCGCCTTCTACCTCGTCGCACCATTGCCAGCGCAACCCCGGCG +CGCCGTCCGATTCCAAATAGAACCCCTTGCCCGTGCTGTTCGGTTTCGGCGCATGGTAAT +ACTCGCCGCACGGGTACGCGTTGCGCTCGGCAATGCTCGCAAACCGTTTCGGCATGCGTG +CGATGTAGCGCGGGAAATTGAAGCCGGCAAACGTGAATTCCGGCGTGAGAGGCGAGAGAC +GATTCATGGTGATATCTCCGTGGGTATCGGAAAGGTGAAACGGATTCAGTTCGAAAGCGT +ACCGCCGTTCGCGCACTTGATCTCGTAATTGAACGGGAATTCGCTGATAACGTCGAGCAG +CAAGGAAACCGCTTCGTCGGACAGCGGATTGCGCCAGCCGAAACAATGCCTGCCCGTGTG +AGCGTAGAAAATCCAGTTATCAATCAGGTTCGGCACATGCGCCATGATCCAGCGGCCGGC +GTCTCGCTTTTCCAGCGCGACGGCGCACGTTTTCACGTATTTCGCTTCAATCCGGTCTTT +CTCTTTCTCGATTCGCGCCTTGTCGCGTTCGGTCGCGCCGTGCAATTGCGCTTGCACATA +GCGCGGCATCAATGCCTCGCGTTCCGCCTTGCTCAGTGTCGGGCGCTTCGCTTTAGACGA +CACGGGCAAAAGGCGAGTGAGATACAAATCGTCCGGCTTCAAATACTGCGATCCGTAGCA +CGACGGGCAAAACGCGTTGCCGATCGCGCGGTCTTCCTGATGGCCGCAGTAGCCGCACTT +AACCGCATGGTCGAGCGCTTCGCGCATGTCGTCCGTCACGAGAAACCAATAACCCTCTTT +GATCCGCTTGTTCGGATACTCGTACTCCGACCAAGGGAACAGACGTTTTCCGCGCAGGGT +TTCGCCGCCTTCCGTGTCGGACGTGTTCCATTGGTCGGAGAAAAGATGAGTCGTATCAAA +AACAATCGTCTGACCGTCGCCCGCTTTCATGTCGCCCATGAATGACTGTTGCTGCGCTTT +CGTGCGGTCGTACTGAAGACCGACCGACACGGACCATTTGCTTTCGCCGCGCGATTCCAG +CATGGCGCACATGTCCGCGTAGGCTTGCGCCTCTTCAGGCTTCTCAATGTTGAAGTAGTA +ATGATTCAGAGTGGAAGTCAGGCGCTTCATTGTGCAATCTCCGTTGAAGGAAGGGGCCGG +GCCAAAGCGGCACGGCATGACTGAGATTCTAGGCGACAAAGTTAAACCTTGCCTAGCCCC +TTTCCGCATTTTCTTTCGACCGGAAGTAACTTCCGACCCGTCCGGGCGGCGCCATCAGCC +CAAAATCCCCGCAAACCCTTGCCCCGTAAGGCTCTTAGGCCCCGCGCCGCCGGTCGTCTA +GGGGTAAACCCTATGATGCGCCGCCGCAACGCGCTCGCCAAGCGCCGCGCGGCTGTCCCG +TTTTCTGCGCCCCTCGTCCGGCCGGGCGGCCCGCCGGTATCCCGTGCTGACGACCCCTCG +TGCTTACTTTGGGGGCCTCGCCCGTTCCCAATTTTTCTAGACCAATCGAGAAACGACCCA +CCCCATCGGCCTTTTGCTTACTTCGGGAACCGAGCCGGACCCCCGCGCACGGGCCGCGTC +GAACGAGCCGACCGGGGGTTACTTCACAACCCTAGCCGGACCCCCGGTCGCCGCCGTTGA +CAAAGTTAATCCCATCCCCGACAATCCGCGCATCGAACCGATCAACATTTTCACGGAGGA +TCACCATGGACACCGCCGAAACCGTCAACAACCAGATCGACAGCTTTGCCGCCCGCGTGC +TCGCGCTCGAAGTGGGCGAGACCGAATCGAAGACGTGCCGACTGGATGGCAACGAGGCGA +CCAAGGAAGTCATGGCGGCCACGCTCACGAAGCTTCGCAATAGCGTCGCGGCCGCCGTCA +GCCGGGCGTCCTCGAAAACCGGACACGTCTTCATCACCGAGACCGGGGACATTCGCACGA +AGAGCTACGACTTCCTGATGACGGTCGCCGTCACGCGGAAGGCCTGATGAACGCCGTCGA +ATTCAGCGCGGTCCACGCGCTCGTGCAGGCGGCGATCGGCGAAGTGATGCGGCAAGCCGG +GATGACGACGTGCAACGTGTCCCGTGCGAAGATGGAAGAGTTGCATCAGTCGCACACGAT +CGAAACCGCGTACGACCTGAGCAGCGGATGGACCGTGACGCTGACGGCCCGCGCCCCTGA +AACCGAAAACGGAGGACCCAAACGTGAAGACGAATGATTGCAACTGCGGCTGCGCCGACT +GCTCGGGCAAGTACGCGACGAAGAGCGGCGCAGCCGGTCAGCAACTGGCGCACGAGCTGC +ACGGCCTGACCATCGATCCCGGTCGCACGATGGCGCAGCAGGCCGACCAACTGCGTGCGC +AGGCGGCGCAGATGAAACAAGACCCGGTGAGCCGTTTGCTGCGCAAGACGCTCGACATGG +TTTTGCCGAAGTAATCATGCGCGCCGGCCGACCTCCCGCCCGCGCTGGAATCCGGACCTT +CCTGAGCAAGATGCCGGTCGGCGCGTCCTACTTCATCGCGGGCGACACCATGGACAGCTA +CAACGCGAAGACTTTCCGCAAGGCTAGCGTCGAACTCGGGCTGCCGATTCGCAGTGTGGT +GCATCACAAGCATCCGACCCACGGCATGTCCGGCATCGAGATCATCCGCCTGCCGGTCGA +GAAGTCCGAGCGGCGTATCATCTGAATCCCCACGACGCCGGCCGAATAATCGGTCTCCCG +CTGTAAATCCGGGCCGCCAAGCGGCTCGGATGACCTACCCCGCTACTACCCCCGCCAGAT +TTCCTGCCGTCCCGCCAGAAGCCCCATACGCCAGCCGCAGACATATATCCTTGTCTGGCA +AGGCTCAACGCTCGGCTCCCCCATACGAAGTAACCTCCGATTTCCTGTTATTTTTGTTGC +ACCGTTCAAAGGAATGTTCTACATTTCCACTTGCGCCTTGGCGCAAACCCATCAACCCTT +TGAACGAAACAACAATGACAGTCAAATTTACACAGGAGAAGAACGTCACCATCCTACGGG +ATGCGATTGACCGGCACGGCCTCCGATGCCACATCACCCCGGATCAGGGGATGTTCAAGT +TTCGGGAACGCAACAACCCGACCGTCTACTACTTCCCGAAGCGCAACCGCTACAAGATCG +CCGGGCAGCCGAAAGATGTTCACATGAATGCGGCTGACTTCGCGTGCTGGTATATCGGCG +AGCATCTCGGTCGGTTGATCGCGGGCAACGCGATGGCGTGGCTGCACCGCGCAGCCAGCG +ACGGCAATTGCCGATCGTGCAGAGAAGATAAGTGCACGGCCGGCCCGCTCTGCGTCGCAT +TCGAGCATCACCGCGAACGCCCTCTTTCCAGCGTCACCGTAGAAGCCCTTCGTGAAGAGC +AACTCCAACTGCAAAACGACGACCAAGGAGCAGCGCCATGTTCAAGCAACTGATTGCCCG +GATGAAAAGCGACAAGAAACGCGAAAAGGTCGCTGAGTATTTCCAAGAGCTGAAGGACCG +GCAGCACGAACTCGACCGGCAAGAAGACAACATTGCGGCCGAGCGGCTGTATATCGAACG +CCAGCTTCCGCGACTCGCCGCCCGACTGGCTGAGATGGAATGGGGCGGCGAAGACGCTGT +TCAACGTTCGGCCATGGTAGGCATCCGCAACGTCATCATGGCCGGCCACCAACCGGACAA +GCCGATCATCCCGCAACCCGGCGTCGGCAGGAGGACCACGGCATGAGCAATCACTTCGTA +CCGAAGCTGCGCGTCAAGAAGCAATCGAACGGGGCAGTACGCGTAACGGTCGATGTGAAG +ATGCTCGAAGCGGGCGGCCATGAAATCCTCTGGAATTGCGCGGTCATGCAGCGCATGCGC +GAGTCGGGCGTTCCTATCATGGGGCTGATTTCCATTCAAGGCGTGCGCCACGGCTGCCTC +GTTCAGACCTACGACGAGTGCTTCATGGAGCACGTCTACGAATGGACGCCCGGCCCGGAT +TCGCCGAAAGAAGTTGACCCGGCAGCCGGTCTCTGACCAACACAATATGGGAGTAACCAT +GAGCAAGATCGAGAAGGCCAGTGTCACGGTCAGTTTCAAGACCGACAGCGGCTACGAATC +GGTATTTGGCGCGCAGAACAAGCCGGGCATCGACGCACTGAAAGATGGCCTGCACGAGAT +CGTCCGCGTGCTGACCATCAACGGCAATGTCGCTACCGTCGACGCCGTCGTGAAGGCGGC +CAAGCGGCGGGGAGAGCGCGCGGTTCTCACGCACGCGACGGCGCAGGTCGAGCAGCAATC +GGCGGTCGATCAGCGCGCAGGCGACAAGCCGCCGTCCGATGACCTACTGAAAGCGCTCAA +CGCAGGCACGCGGCCGGGAATCCTGAACGTCTACCGCCATATCCTCCGCGAGCATCCGAC +CGCAACCGGTACGTGGTGTATCCGTCGCGCGAAAGAGATGTGGGGCCATCTGCCGCTCAT +CGCGCTGAACGCGGAGAATCGACCGGGCATCGCGGAAATCTACGCGGACCTGCGCCGCGC +GAATCCGCAGTGGTCGATGTCCGGGCTGCTGCGTGAGGTCGAGCGCCAGTGGAAGGAATC +GCAGGAATCGGAGGCGGAACTGTGAAGACCTTTCAACTGAATGCCGATCTCGTGCGCTGC +GCTGCCGCGTGGGTGTACGGCGGCGATCCTGCGGCCATGAAATACCCGGCGCTCAATCGC +ATCCGCATCGAACCACACCATCCCGGCGCGATCATCATTGCGACCTGCTCGCACGCCATG +TTCGTCGCGTACGACCCGGAAGCCGTCGTGCCGGAACCCGCGCTGATCTCCGTCCCGCAG +GACCTGCTCGACGCGGGCGCGCTGCTCGGCGTCAATACGACGGAACGCGAGATTCGCTTC +GGGGATGACGGAGTTGCCGTCTATGCGCGCGGCAAGCTGAAGCATAAGTCCCGGCTCGCG +ATCGACACGCATCTCCTGCGTGGCGTGAAGGCGCATTACGCTAACTGGCGTGCAGCCATC +CCGGCGAAGATGGATTTCCTGAAGGCGAACCCGGCCATCCCGACCATGATGAACATGGAC +TTCCTCGGCCGGCTGGGCCGGATGTCGGAAGGCTGGGGCGAATACCGGCAGGTGTTCTTC +GCGACGTGCGGCAAGCAGTCGATCACGCCGGGTGACGGGCAGCGCACCGACTACCGGAAC +TTCTTCGCGTTCTTCCCGTGGAAGCGCGACGTGTTCCTCCTGTTCGCGCCGATGGGCGGC +ATGCCGAGCGCCAAGGATTTCGGATACCCCGAATGGCTCGAAGACAAGCCGGACGATCCG +GCGGCCGGCCTCTGAAGTAACTTCCGACCGATTATCGTTGACAAGGCTTAACGTTGTCAC +GATAATCGGTTTCACTTTTCCACGAAGGAGTTTGAAATGAACGAACCGAAAAACGATGGC +GTCGATCAGCGCGCCTACGCATATGTGCCGGCTTCCGTGCTGCTCGAAATGAAGCAGTAC +ATGGACAAAGTGTCGAAGCTCTCGAAGGTTCCGGCATCGGCTATCGGCCTGAAGGAGCGC +GTCAAAGGGTTACTTGCCGAAGCGAAGGAGCACGTCGCGACGGTCGACCTCATCGAATAC +GAAGTAGGGCAACTGGTCGGGAAGTATTTCGAGAAGATCAATTTCGAACTTATCGGCGAT +GTCGTCGTGAAGAAGACCGGGGAGTTCAAGGGCGACCTCGGCCCGTTCCAAGACGAACTT +TGCCGCATGATGCGACATATCGCGTTGAAGGTCCTCGGCGAGAAGATCGAACGCGACGAT +GCGGCCGCCGTGTCGAAGCTAGAACGGCTGTACACGCACATCGACGCTGTCGCGGCCATG +CTGGCGAACGACGAATATGGTGAGCCGCAGGGGACTGGCGACGAGAAGTTCGACGCACTG +GTCGAACAGATTACCCGTCTGCACAGCGATCTCAACGAGTCCGCGCAACTGATGGTGCCG +GTAAGCGCGTCGGCCGAAGCGGAACTGGCGAGGATCACTGAGCAACTCGAAGAAGCGTGC +GACGACATCGAGAAGGGACGCGGCCTGACGCTCGACGTGGAAGACGCCAAGCCCGTACAT +CGGTTCAAGCAGTTGTACGCGAAACTGTTCATCCAGTGGCAAGAAGCCACGACGCATCGC +GACGACGCCGAAGGTCGCCTGAATGCCATCAAGACGGTCGTGCGCCAGATGCGGAGGGAT +GTCAAAGGTGACGGTGCGCTCGCAACGGGCGTAGTCTACGATGACAATCTCCTGAACGAG +ATTCGTGGCTTGGCGCACGCTGTGATGATGAGCAAGGCGTTCGGCTACGGGAAGCTCGGA +GTGCGGCACGAGATCGGCGTGTTTCTCAATCACGTTCTGCCGCGCGTGCGCAACCCGAAC +TACGTGGGCGACCCCGAACTGATCGACCAAATTCTCGATGGCATCGCACTGGTTGGCTCC +GGTTCTGCGGATGCGTTCGATACGGCGCAGACTATCGGGGAAGACCCGTTGTCGCAGGTG +CCGCTCAACGTGTTCCAGTTCAAAGCGCGTGTTGCGGCTGTCGCTGACAGCTTCGAAAAA +CACAGTGCACGTCTGCACGACCATCTTGGGATGAAGTGGCGGCTCATCGAAGTAAAAGAA +GCGCTCGGGCTGCCGTTCGCGAGAGATATCGTCCGGGTCATCGGCGAAGCTGACGACTTG +GCTTCCGTTCCGCACGATCGTGTACGGGCCGTTTGCGTGGTGTGCGAATATGTCCTTGCG +GCCGTCCGGGGGTTTGATGACAATGCGCTGGGCGCTGCCCGCACGTACGATGAAAGCGCC +GGGACTGTTACAACGCAAGAACCGGACGAATTGCAGGGCGACGCGTTGCCTCTCGATAGC +CCGCAGAGCGAGAACGCGATTCGCGTGCTGACGGAGCAGCTCCGAAAAAGGAATAGGCTT +CTCGGCAACTTCGTAGGCATCCATCCGGTCCTCGAAGAGCTTCAGGACGCGGTGCACGAC +ATCCTGTTGGAACATAAGTCGAAGCGCCCGGACGTACTGCAAAACGCATGGTTTGCGGAT +GTGCTGAAGTTCAACCTCGCCGCCGGCCGCTCGATCGATGACTTCAACCCGCGCATGATC +GGCTTGCACACCGGCCTTCAGTGCGAAGAACTCGGCGAGAAGCTGCGCGCGATTGTCGAA +GGCACGGTTGCTTCCGGCGTGTCCCTTTTCGAAGGCATGCCGCTCGTGTCGCTCTGCAAT +CAGTTGAAGTGGGTCGGCGACCTGTTCAAGCAGGGTGCATTCGACAACGCTATCGACCGT +GCTGACCCGGTCGAACTGGCAGACGGCGACATCGACCAGATGGTCGTCTCGTTCGGCTCG +CTTCATTCGCAAGGCGTCTCGCTGTTCCCGATCCTGCACGCCGTGACGGACGCGAACCTG +CGCAAGATGGTCAACGGCAAACTGCTGCTCGACAACAACGGGAAAATCGTCAAGCCCGAT +GGCTGGAAACCGGCCGACCTGCTGCCGTTCCTGCACAAGACTAAACAACCGGCCGAACTG +CACATGGGTCCGTCCGACGAAGCCGGGAGCATCTGACATGAGAGTGAACGTCTATAGTCA +GGAACTCACGTCGGAAGTAAACCCGGTGTACAAGGAGTCGAATACCGGCGTAATTTACAG +CGCGGTGCAGTTTGTTTTGCATTCGAGCGACCGACTCCATCATCCCGACCCGGATGGCGA +CGACGATCGGAGCGCCGTAACTTTTTGGCTTCCGAAATCGAGAGATCGGCGCGAGGCATT +CGCGCTTGCTCTCGAAGCGGCCGCCACGATGGTGAGAAACGCCCCGCCTGAATCCGGCTT +GGACTCTTAATCGTTTCGCCGCCCTTCGGGGCGGCTTTCCTTCGAGAACACCATGTACAC +GAACAATCGCGACACCCACGAACTCGCCAACGAGATCGAAACGGAGATCAAACTCAACGT +CAAGCTCGACAACTGCTGGCCCGGCACGCCGCACTTCATCCTCTGCCACAGCCGTCAGGT +CGGCTGGGAGATGGCCGAGCGGATGTCCAAGGTCCTGTCGTTGCCCGGCGGCGCGCCCGT +CACCGTGCCGTACGTCAGCACGATCCCGGAAGCCATTCAGCTCCTGCAAGGGCTGACGAC +TCATCCCGTGGTCGTGTTCGCGCCGGCCGTCGTCTTCCTGTTTCCCGGCTGGGCGTGCCC +GCTCGACCTGCCTACCAAGCTGCATGCCACCTTCCCGATGCACGACGAAGAAACGGCGCA +GTTCATGGGCCGCTTCAACCGGTTGAACCCCCGCACCGGAAACATCGGCGATAACCTCAG +TGTTGGGAAAATCGTACGTTTCAGCGATATCGCCTGTTGACAAGGTTATTCATTGCCGTG +ACAATCCGTCGTATCAAACCACGGGGAAAGAAAAATGACGAACAAGAATTGCGACTGCCG +ATCCGCCGACGAAGAGAGTCTCATGGAGCGCCGAAAGTCGAACTGGCCGGATTACGAAGA +CAGCATCGCGCAGCTCCGCGCGTCGTTTTGGGCCGGGGCCGTCGCTGGTAGCTCCCCGGA +CACGAAGTTACTTCAGGGCAATGAGTACGTGATCCCGAATCCCGAGCGGATCGCCACGTC +ACTGCACGCGCAAAACGTCGGCAAGACATCGGTCGTGGATTCTCTGTTCGCGCTCGGCGC +GGCGGCAACGGTCAAGCGGGCGAAGCCGTATGTGCTGCCGGACGGGTTCAATACCCGAGC +ACCGTTATCGCCGTTCCAGCAACTGATGCGATTCGGCTACGCGGAATACTGCATTGACGA +TTTCGCGCGCGAGAAGCTGTCTCGGGTTCTCTTCGACTCGTGGAAGCGCGAAGCATTCGA +TCGCGTCCTGCGCCGCAACGCGTGTCAATCTAAGACGCTCACCTGTCTGTCATGCGGCCG +TACCGGCCTCGGGGTTGGCTGCCCCTGCGGGGCGTGACATGGGCGGCCCGTACTTCTTCC +GTGACGGCTCGCAATATACCGGCCATCAGGTCGTCAATTTCAGCGTGCAGAAAGGGCAGG +GGAAGGTGCGCATTCGCGCACGGTGCAAGGAGTGCAACGGCCGCCCCGGATCACATCACT +GGCCGCACGGCCGTTGCGGTGCGTGCAAGGGAACCGGAATCAACGCGTCGTACTCGTGGG +TGTCGGTCTATTCGGCCGAACGCCTGAACGAATTGAACGCCTCGAAGCACCGCAAACACA +TGGCGCTGTCCGCGCTCGCGTTGCTGATGGTTAAACGCGATTTCCGTCAGTTCCTGCGGC +AGCGCGACCGGTTGCTTACGGACATGCAGACGTTCGCGCCGAAGTCGGAGAACCTGCAAT +TGCTGCTCGCCAAGGTCAACCAAGGAACTATTCTCACCCCCACCGAGATCAGGCAGGCCC +TGACGCTCGTCAATACCGTTAGGAGTCAATTCTATGTCGCCGCAAGCTGCGCTCGCTAAG +GAGATCGCCGGGATGATCCGGCGCAATGTCGACAATACGGACCCCAGCATGCTCGTCCGC +AACGTGATACCGCTCGACCGAAACGAGGCGTTGATGCTCGTCGGGATACTCGAAGCGGTT +GCATCGGCGGAATCGTTCACCGAGCAGAAGGTATATGAGGCCCTGTATCCCGACAGCGAT +CCAGCCAAGCCTATCCGCGATTTCCTCAGCGTCTACGCAGCACGGCTCGAAGCGGTGCGC +GGCGTGCGCATGAGGAACGATGAAACCGCCTTCGACTACAGGACTCGCTCGGACTCCGAC +GGACGCTTGAAATTGACCAACGGTCAGGTGCGCGCATTCATCGATTCCTTTGACCGTCAA +TCCGGGAGACGGCAATGAAGACGATCTACATCGTATGTGCGTCGTCTATGTACGAGGGCG +GCGCGGACGTTCGGGCGTTCGAGGACGACGGAGACGCCAGAAAGTTCGCGTCCGACTGTC +GCGCCGCTTCGGCTCGTCGCCCGCAAGCCCCCGCGCTAGGAGCCAGTCAAGCGAAGTGGG +CGGCCTATTACAGGGCAGAAGCCAAGTGGGAGAAACAGCACCCGGCCAACCCGCACCACC +ACCACGAGTATTTCGACGTAATCGGCCTCGATCTGTACCCGAAGCAGAAGTAACTTCGTT +TCAGTCCTGCAACATCGCGTGACAAAGTTGAACAGGGTTATTACGGCACGAATTGTCTTG +ACAGTGTTTATCTGTCCGATATACTTCTGCATGTAGTAACCCACTCAACAACCGAAAGGT +GATTGTCATGGCAAAAATCCAAATTCCGGGCGAACTCAAACTCGACGCTCCCGAGGGCAG +CGTGCGCGCTGCGCTGAAGGAAGCAGGCGCGACGGATGGCGAACGCATCCGCATGGTGCC +GCCCGACTCGATCCACATCGTGCCTGGCCTCAATCCGCGCTTTTGGGGCAGCCCGAAATC +GAAGGCCCACATCGAAGACATCGCGAAGTCGATGATCGCTCGCGCGGCGTCCGGGCTGCC +GGCGTTCATGCCCGAGCGCGCGCTCGTCTGCTTCGCTCGCAAGATCGACGGCGTGGACCG +CCTCGTCCTTAAGGCCGGCCAACACCGCTTGGCTGCGGTCGCCGTCGCCAACAAGAAGCA +GCCCGGCACGGTCGCGGAAGTCCCGGTGTTCGTGGACGAAAATCCGATGACCGACGCGCA +GCTCGCGCTCTACTACATCACGGAAAACCGCAGCGAAAAGCTGGGGCCGTACGAGATGGC +TGTCTCCGTCGCACGCGCAGCGGAAGCGGGCGCGACGAAGAAAGAGATCATGGCGGAACT +GAACATCTCCGACCGCTATCTGTACGATCTCGGGCTGCTCTACAACGCCGACCCGCGCGT +CATCGAGCTGCTGGCGGAAGGCAAGGTGAGCGGCACGACCGTCATCGAAGAGATCAAGGA +GTACGGGCAGGAGAAGGCCGCCAAGCGACTCCTGAAGGGCATCGAGACGGCCGCCGCTGC +CGGCAAGACGAAGGTAACGCGCCGCCATCTGCCGGCCGAGGACGCCCCGGCCAAGGAAAA +GAAGACCCGCGCCGACACGAGCAAGACGGATGGCGGCGAGCAGCGAGCGGCCGACGTTCC +GGTCTTCAACGCCACGCTCTCCGTGCTCGAAGTCGTCAACGGGTTCCACGAGCAGTTTGG +CGAATCGGACGATCGTCATACGAAGATCATGTTCGAGATCATCAAGCAGTGCGGCGGCGA +CGAACTTGTCCAGTACGCGGCTGACACCGGCAAGTACGAAGCGACTGGTCTGGTGCGCCT +CGGCTTGGTCGAGCTGCCCGAAGAACCGGCTGCCGCTGAAGAAGACCCGGCGATCAAGGC +GCAGGCCGAGAAGACGAAGAGCACGCGCTCGCGTAAGTCGAAGAAGACGGAAGAACCTGT +CGAATCGCCGGTCGGCACGGCGGAAGGGCTGTAAATCGGAAGTAACTTCAGGGCCGCTTC +GGCGGCCTTTTTCACGATTACTCACAGGCGAACTTATGCAATCCAATCTCGTGCTTCTCC +CGGTCATCGACGGCCGGGACATCTCCATTTCGCCGCTCGGTATCTGCGAAGTCGAGATCA +GCGACCAATTCATCGTGACGCTGACCATGCAGAGCGGCAACAAGTACCAGTACAAGATCG +AGAACATCGAGCGACGACTGGCCTACTACATGGACCCACCCATCGAACCGTCGCGAGGCT +ACGACAAGCCGATGAAGGCGATGACCTCGAAGCAGGCCCATGAGTACCTGAAGTTTCAGG +AGCGCCGACGCCTGACCGGGTACGTCAAGGAGGCCGAGGAAACCCACTACTGGCATCTGC +GCCGTTACGAGGACTGACATGGAAGTCGCCATCGCAAGCGGGCTCGTGCCGTACGAACGT +GTGCGCGAGGGGATCGAGGTCGGCCTGCATTACCTGTCGTTCGACCGACCGGAGTTCATC +ACGGGGCTGCACGTAGCGGCCGATGTAGGAACGGCCGACGTGCATGCGACCCAGTGGGCG +AAGGAGCACGGCATCGAGATTACGCGCTACTGGCCGTCATATCGCGGGGACCCGTACGAA +GCTGCCAAAGACCGCAACTACTTCATGCTGAAGGAAGCGGACGTGCTGATCGCGGTACTG +GGCGGCGTCGGCAATTGCAGCGGAATCATTCAGATGGCCCGGCAGATGAATATGCCGGTC +TACGTACATGCGAAAGATCATGGCCTGTAGTTGACACAGTTCATCTTTGTCAGGATAATC +ATCTCACCAGCTACGGAGGGATCAAAATGAGTAATGAGCCGAAAGACGCAGCAGGAATCA +TCACCTTGAGCATCCAAGTCTCTCGCCAGTTGTGCGAAGACACAATGGATGCAGCCGCGC +ACGGAGTTGAGTATTGGGCGCACGCGTTCGAGCATCCGGGCTGCGGCCCGGAGACCCTAA +ATTATGCGATCGAAGAAGACGAACCGAGCAGTGGCGAAACGCCAAAGAATTTCGTCATCA +GCCCGGAAGCCATCGTGAAGGGGATTCAGGCGATCATGCACCCGGCATTCTCGGTGCGCG +CAGACATCCGGGGCACGCTGTTCAGTGCACTCGTAGAAGACGACGCCAGCAATATCGACA +TCGAGATCGCCGATATCATTGTGCAGGCTGCGATGTTCGGCGAAATCATCTATGGCTGAC +CGGAAGTTATTTCCGACCAAGGAGAAGAAAAATGGCGAGGAAACCGTTGAAGATCACATT +CGGTGTTGGCGCTGCTGCGCTGGCGATGAACGTCGTACGCCGTGCAATCAAGCGGATCAC +CGAAGACCCGTACGAAGCTGCGGCCGAGCACCTGAAAAAGACGCTCGAAGAACGCAAACG +GCCGTTACTTCCCGGCGAGCGCGTCGTACAGAAAAGCCCGCTGTTCGAAGCTCCCTACGG +CGTGTGGGAATTCGACCGGGGCGATGAGGTCACGGTGGACACGAAGTTCGATCGACCGTG +GGTCGGCGTCGTGCTGAAGCGCAACCCCGATGTGCCGAGAATGTATGTCGTCCAGATGGC +GATGTCGCACGCCGAAATCAACGTCCACGAACGTATGATGAGCCTGCGTCGCCGTGCAGC +CGGCGACCCGAATCGCGCGGTGTTTCCGGCGGTGCGGCCCTGCGAAGGGCGACCGGCCGG +CGAATGGTCGACTGCTCGCCGCTGGCCGCCGACCGGCTGGCCGTGCGAATGGTTCCCGCC +GGGAAAATCCGACGCCTACGCGACCGTAAGCCAGTTTCGACGGGACTATCCGGAGGCCGT +TGACACGGAGAAGGAGCAAGCAGAACTCGCCATCGCGGCTGCCGGCCTCGCGATGTGCCA +CGACCCGTGTTACGTCGTCCAGTACGGCGATCAGACCGTATGCAAAACCTGCGGAACGAC +GTGGGATACGAATGATCAGTTCCCGCCGTCGTGCCCGCACCCGTGACGAGGCTGCCGTGT +CGGCAGCCATCAACGGCGCTACCATCCTGATTCTCAATATCCTTTACCCCCGGAGAAAGT +AAATGCGCATTGCGAACCCGCAGAATCGCCTCTGGCAGGCTCTCGTGTCCCGGCTGGGCC +AGCGACTCATCGACCGGGCCTTCAGCCGCCCAGCGGACCCGGTAACGCTTCCTGACTTGG +CGAACTACATGCACCGTCGCTGGCTCGTGAAATACTCTCGCTGGACCCTCGGCCGCTGCG +CGCGAATTCACCACATCCTGCGCTCGGATTCGGATCGCGATTTCCACGACCATCCGTGGC +CGTACGTGACGATCATCCTCGACGGCGGCTACACCGAAGTAACCCCCGTCTACACGAAGG +CGAATCTGTACAAGGGCGAGCACCGGCAGTATTACGGCCCCGGCTCGATCCTCGTCCGGT +CAGCCAAGCACCTGCACCGCCTCGAACTGGAACCCGGCACGACGGCGACCACGTTGTTCA +TCGCCGGGCGCTGGGAGCAGGAGTGGGGCTTCATCACGAACCCCAACTTCAAGATGTACT +GGAAGGACTACCTCGCGCGCGAGACGGACGTTACGCCGGCACGCGCCGAGCGCCGCACGT +TCCTGATGTGCGCGTGTCCTGCCTGCGCGAAACTCACATACTTGGCCCGCTACCATACGG +ACGACGACAAGCGCCGAGCGGGGGCCGATCTCATCGAACTGATGGAGGCCGGAAGAAACC +CGTTCACGAAAGAGCTGGAAATCGGCGCGAGCGGTCGTACGATTTTCCCGGAAGAGTACT +GCGCGTGTCGCGCGCCCGACATCGAGGACGGCGCGGATACCGCCTTCGGCGACGAAGCGG +ACACGGAAGACAGGGGCTGACCGTGAGCGGCCGCATGTGGTTCTACCACGAGAACTCCGA +CAGCCACGTCTACCTCACATGGGAAGAGGCGGCCGCGCTGCCGGAAGCTCTCTACGAGGT +TGACGAGCTGTTGGTTCCGGCCGCAGTACAGGAGAGTGAAATGGCGTATCTCGGTCTGAA +TCAGCTCCCGTTCTTCCTATACACCGACGACATGCCCCCGGACCCGGTCTACGACGCATG +CCGGCTTCTCGGGATCGGCTCGTGGGCGACCAGTGAGTTCCGGGGAAACATGGACTTCGC +TACGGCGCTCGAACGCAAGCACCCGATGAAGGAGTGGCGGGAGGCGATCAAGAAGGCCAT +GGAGATCGAGAAGCGGCAGCAGAGTGCGCGAACGATCGCGGCCAAGGCGCGCATTGCACT +CGGCAGCGACGACCCGTACGCGCTGCGTGTCATGCAGTTGATGATCGACCTCGGGAAACA +GCTCGACCCGGCGGCCGGCCTGTAGGCAAAAAGAAGCCCCGGCGGAAACCCGTCGGGGCC +AAAGGGCGATGCCTTACGGCACACTCCCCATCTGATCGCAGCAAAACCATTCTACTCTGA +TGCCGGCTTCGCCGGGGTCGCTTTGCCGGGCGGCTTCCATCCACACTTCTTTGCCCCCAT +TTCGTTATGTTCGACCATTTGTTTCAGGACGGGAGTCGGGATCGCTTTTGCTTGGTCGAG +GGTGTAGGTGAATGGTTTCGTCCAGTTGCAGCCGGTGTCGATGAACTTGGTTTCAACTAC +GATCTTTGGTTCCTGCGGCATCGGGACTTCCGCTTTCGGGGGAGGCCCACTTTTGCACGA +GACCATCAAAAGTAGCGCCGTCAGCGCCAGATACTTGTTGTTCAACATCGCTTCGCTCCT +TCGCGGCTTCAACGCCTTGTTGAGCGGCTGCCGCGTTCGACTGCGCATGTGCGTCACGGA +CCTCCGCTGTTTGAGTCCGGGCGTCGGCCGCGTCACGCTGCGCTTCGGCCTGCCCCTGTT +TCGCGGCGGCCACGTCGGCCGACGCTTTCGCCTTGACGATCCGGCTGTAGCCGAATGCGC +CGAGGATCGCTACGATAGCAGCCCCGATAGCCGCGATGATCGTGTTCATTGGCAAGTACC +TCCGTTAAGGATGTAGGTTGCACGCAGGGCATCGAGCTGGCGCTTCGGCTGTCCGTACGT +GTTCTTCGTGCCGGGGATAGACGCCCAAATGTTCGAGACCCGATCGCATGCCGTCAGGAA +GTCGCCGGCCTTCAGCGGCTCGATGGCGCGGCTCTCTTTCAGGTGTTGAAGGCACGTCAG +GTCTTGCGCGATCTCCGCGAAGTCCGTCAGCCGAAGGAGCGTCTTGTAGTGCGGCCAGTC +CTTCAGCATCTGTTGGTATCGGCCGCTCGCCGTCGAGTAGAGGCCCTTCGAGTTGACCTT +GAACGGCTTACGGCCGAATTGCGGCATGAACGGATGGTCGCTGAAATCCGTGAAGCGGTT +GTGCTGCACGTTCCCCTGCGCGTCGATCGAGTTCACGAGGATGTCGTAGCCGTCGTCCTG +CGTGACGGGTGACGTGCTCGTGCCTTCGGCGTATGCGATCGTATCCATGAACGCGCAGAC +GTTCAGATGGCCGGCCAGTTCAGGAGTGATCCGGGGCATTCGGGGTCTCCGGTCGAGGTT +GCGTACGCGCGAGCCGGGCCTGCTTGATGATGCGGAACGGCACGGCGAGCACGATGATGG +CGATCGGGACGAAGCGCGCGTACTGCGGCGGGATCAGCGCCTTCATGTCGTCCGGCATCA +GGACCCACACATGGAGCAGGGTATCCGGTGCGACCTCGATCCAGCTCTGCAACACGACGC +CAACTGCGATGAACCACGTCGAGCTGAACTTCACGAGGTTGCGCCAGTCATCCACGAGCT +GCACGCGCTGCTTCAGGAAGAAGCGGCTATACAAAAAGACCGCGACGAGCGCGGCCAGTG +CGACGGCGGCGACTACGGCCGCCAATTCGAAGAGGTTGTTCATTTCGCCCACTTTCGGAC +AGAAGCATTGTCCGCGTTACGGTCGTTGATCGCACGGTCGAGCTTGTCCTCGATGCGTCG +CAAGTCCTCTCGTACGTCCTGTTGCACCTTCGTTTGGTTGGTATCGATGCGCTTGATGTC +CTCCTTCATGAATTGAATCTGCGTGGCCGATTCGCGCGCCCGGTCTCGGATGTCGCCAAC +GTAATTCGCGACCCAGCCGATTGTCGATCCACACGCAACCAAGACCGTGATTGCCATCTT +GATGTCGATGCGGCTCTTGTCCGTGATGTGTGCCGTCTGATCCGTGTTGTTCGTCGTCGC +GTTCATTCGCTGGCCCCGTGCGAAAAGGTTGAGGATGCGCGGGATTCTAGCAGAACCGGA +AGCAGTCGAGGGGCGATACGAAGTAACTTCAAAGCGGGCGGCCGTCATAAGTTTCACCAT +GTGAAAATGAAAGGGAAGGGCAGTGCTGCCGCGAATTCTAGTACCCGAGCGCCAGAATGA +CAAACGGCCCCGAAGGGCCGTCTGCGCTACATCAGGTTGTGGGCCACGGGTCGTCCGGGC +CGAGCGGCGTATTGCCTGCCGCCAGCCACGGCTCGTAGATGTCGATCCAGACCGAGCTAT +CTTTGGGGACCAGCCATACGGCCCCGTCAGCATCGCGGTACTGGACAACATCGTCCCGAA +CGTCCGGGGACGACCCTTTGAACTGCCTGAACGCTATTTCCATGACAACTCCTGTTAAGG +GCGTGCATCGCCGAGAACGTATCCGTTCGAACCGCTATCGAACGAACCACTCCCCGTAGT +AGACCATTGCGCCGCGATCCGCGCAACGAACTTGTTGGCCGCATCGACAAACGGCGTGTT +GACGACTCCGGAAGTACCGACCCACGTACCACCGATCGAGGTCGTAGGCGAACGCGCTTT +TTCCGAACTCCATACAATCGTCATAAGCCCGTAGTTGCCGCTGATGTTGTACGCGTAATA +CTTGATGTTTCCTCCCGAGCCGTCGAGCCGTTCGATATACCGTTTCACCCGAGCCGTTTC +GAGCGCTAGGCCGCGATACTCGAATGGCGACGGTGCGCCGCCGAGACCGTTCACGTCGCT +GCTCGACGCCGGGTCGCTTTCCTCGATCTGTAACTGGCTGAAGTCGAGCGTGAATGTGAT +TCCGGTCGCCAGAACGAACGCGACCTGAAGCTTATCGTCCCCGTTCGTCCCGAGTTGCTT +ACCGGCGATCGACGGGATATCGACACGGACGCTGAAACGGCTCTCCGTCGTGCCGACCGA +CCACGTGACGTTTTTCAACGTGACCACGGAAGACGCAGGCGAACCGCCCGAGCCGAAGTT +CTGCACGACTTGAATCGCAGTCACCAGATTGGCCGCTGCTGCCGCAACGAGCGTCGTGCT +GACCGTCACGCTGCGCCCGCTGAACGTGTTGACGCCTTCGATGTTCTGGTAAAGCTGCGG +CGCCGACGATGCAGCCGTCGTCTGGTTGAACCGCAGCTTGTACCGGCGCGACGAGTCGAT +CCACTTCGGTGCGGACTCGGGGGTCGCAGTGATACGCGATACCGTCGTCGCACCGCCCGT +TCCGGAGATCGCGCGCCACATATCCGCCGTGTACTGGTCGGTCGCAGCCGCGAGGTTGAA +CGACGTGCCGATCTGCCACGAATCGACGTTGCCGTCCACGAAGCGGTTCCGGCCGGTAGT +AGCCGGGAGGTCGCCGGGCTGAATGGTCGAGTTCGTCCAGTTTGCGCCGTTGTTGCGGAG +GTACTGGCCGCTCGCCGACGACACCGCGAAGCCGATACGCATCGTGACGGGCACGGTCGA +GCCGCCTTGCGTGTCGTACGCCGACCCGTTGACCGGAGGACTGACGTTCACGCGTGCCCG +CGTTCCCATCGTAGAGAACGAGTTCGACGGCCACGTGCCAGACCCCGGCGAATCGATAGG +CGTCGCGTAGTTGCCCGCCTGACCCGGACAGCCGACGAGGAACGCGTACTGCGTGCCTGC +GGTGAGAGCGACCGGCGTCGGGAAGTTGAACGTGAAGTCCAGCGACCCCGCCGTAGCGAT +CGTGACAGGGCTGCTGAACGTCGGTGCGCCGGTAAGCGTGCCGCTCGATGCCGGGGCGAC +GGCTGCTTGCAACTGGACGCCGACCATTCCTGCCGTTTGAAGGTGCGTCGTCAACGAAGT +GACTACGCAGTTCTGCGTGACCGTCAGCAGGTTGCCGTTCCAGTTGTACGCGCCGTTGTT +GTAGCTCGTCGTATCGGCCGGGCCGACAACCGCACTGACAGGAACGCTAACATCCGAGAG +GCCGCTTGCGAGCGCCGTAGCACCCGGAGTCGTAGCCCATGTCCCGTCTTCACGGAGGAA +CCGCGTAGTGCCAGCGACGATACCCGGATCGGGGACGAGACCCGCCGCATGCGAACCACC +GGATGCGCCCATGACAGGCGGGAGCGGTGTAGTCGCCCATGTTGCATCCTCGCGCAGGAA +CCGCGTAGTGCCAGCGACGATACCCGGATCGGGGACGAGACCCGCCGCATGCGAACCACC +GGATGCGCCCATGACAGGCGGGAGCGGTGTAGTCGCCCATGTTGCATCCTCGCGCAGGAA +CCGCGTAGTGCCAGCGACGATACCCGGATCGGGGACGAGACCCGCCGCATGCGAACCACC +GGATGCGCCCATGACAGGCGGGAGCGGTGTAGTCGCCCATGTTGCATCTTCACGGAGATA +CTTCGTCGTTCCTGCCGTTGCGCCCGGATCGGGGACGAGACCGGCCGCGTGCGTTGACCC +GCTCTTCACAAACGCACCGAGTGTTTGCCACGTAGCCGTCCCGCTGCCGCCGCGCGTGTA +CCGTTGGCCGTCCGTGGGCGCTTCACCGACAACAGACGCATTGACAAACTTCCCCTGCGA +TGCCGACCATGTGATCGCCTGCCCGTCAGTCAATGAGGTGAGTTTGACATCGCCCAGCCA +GCGAAGCTGATCGTCGCTCGTGGTGGTAACGTCCGGAGACGCGAAATCGATGAACACCTG +ATCGGTGTACGGCCCCGCACCCGTGACAGTCCATGCCGTAGTCCATGCACTGCCGTCGTC +TGAATACTGGACGGTGAAATTCGACGGGCCGCCGCTCAGATTGTCAGTCACCGCAATCTG +CACACGCGCAACGGACTTCGCAGCGGGCCACTGGTACCCGAGGAAAATCTCAGCACCGGC +AAGCGGAGCGCTGTTGGAGCGGTAGTAGGTTGCGGTGTTACCGTCGAACGCGTTGTCCGG +ACCAAACGTCGTGTTTTGAGCCGAACCGGATGCCGTGCCCCCGGTTGTTGCGATCTGCGC +GCCATTCGTATCGATGAACCGCAGCTCGGCAACACGCATGCCGACGCCCCCGGTTTGCGC +GGCCGAACAGTTGATGCGCCAGTACTTGTGAGCCCCGTACGGATTGGTCTTCGTGAAGAA +GCTGGCCCATGTGCCATTCTGACGCATGTATTTGGTCCCATCGCTCGGCGCGTCCGCGAT +ACCGGCCGTAACCGTCTGGTTCGTCCACTTGGCGCTCGCGGCGTTCCACGCGATGACCTG +CTTGTCGCTCTGCGATGCGACGGCTACATCGGTCAGGCCGACAAGCGTCGTGCTGCCGCC +GGCCGGCGGCACAACCCACGTTCCATCTTCCCGGAGATACTTCGTAGTGCCGGCCGTTGC +ACCCGGATCGGGGACGAGGCCAGCCGCATGAGATGCACCCGATCCGACCATGGTCGACGG +GTAGGGTGGCACAGCCCATTGCGCATCTTCACGGAGGTACTTCGTCGCGCCCGCCGTCGC +GCCCGGATCAGGGACGAGGCCGCCGGCATGCGATGCGCCGCTCGCGACGAACGCGCCGAG +CACGTTCCACGTCGCTTGGCCGCGCGTGTACTGGTTGGCGTTGTTCGGTGCGTCCGGAAT +CCCGCCGCCCCCGCTGATCGTCTTGTTGATCCACTTTCCGGATGCGGCGTCCCACGAAAC +GACCTGCTGGTCCTGTGGGTTCGAGATGTTGGCGTCCGACAGCGTCGCCATGCTCGACGC +CGGGATTTGGACCTCGGCCCAGCCGGAATTCTTCCGCGCGTACTGCTTGCCGTCTGCCGG +CGCTTCGGGGATACCCGAGCCGGTCGCAACAGGAGTCCAGCCCCCGTCTTTCCGTGCGTA +CCCCACGCCGTCGCTCGGTGCGTCGGGAATGCCTCCCTGCGCCGCCTGCCAAGCCGTGCC +ATTCCACTCTACGCGGCCCGTGGAGCCGCTGAAAGCGGTCCACCCGAGCTTCGGAGTGTA +GAAGGCCCACGCGCCGCCTAGGAAGGCCGCTACGTCGTCCCCGTGATTGGCCCACGCTCC +GGTAGGCGCGGGGGACTTACCGACGATATAGCGATCGCCCTCGGCCGGTGACGACGGAGG +GACCGTCAGCGTATTGTCGATCACGCCAAGCTGCACGATCGTATCGAGAAGCTGCAGCGA +GCCGTTCGTGGTCGTCCCCCAGCCCGACGCTCCGTCCGCCCAGCCCCACCAGACGCCGAG +ATTTTTACCTTGTGCTTCTGCCATCATTGGCCTCCAAAGTCATTACCCCAATTCAAGCCC +CAGCCGCTATCTGCCGTGAGCCAGTGGGTGAAGGTGAAGTCGTACTTCTGGTAACACGTA +ATGCCGCTGCGCGTGCTCTCGACCTCGGCGCGAAGTGTAGCACCCTGACCATGGCCGACT +GCGGCTTCCGGGAAGGTGTACGTATCGGCCGTAATGCCGGTCTGCTGCACGATCAGCGTG +TTTGCTGAATCGTAGATGCGGATGTTGTAGGTCACGCCGGTTTCCGGCCCGACGCTCACG +TCTTCGTGGGCGACCAGTTTGTCTTGCTGCGCGATGCGGTCTCGATGCGCCCATGTGAAG +ATCAGGTCCCCACGGACGGACGAGACTTCCGCGTAGCGCTGGCCGTTCAGCTTCAGATTG +CCCGGCGGATATGGCATGTTCTGCCGCGCGACGATCTCGATTGTGCTCGTCGGCGCTGCG +TTCGCCTGCAATACCGAAGATGTGGTCTGCGTGCGGAACTGCACGGCGATTTGCATTCCT +TCGCTGAACTCGGACGGGTCTGCGCCGAAGTAATCGTCGTAGACCCATACGATATCGTTG +CGAAGATGCGCGGCCGGGAGCGTGTCGACGCAACCCCGTCGAATCGTTACCAGCTTCGTG +CCGATGTCGTAGCTGACCACCTCGATGATCTCGTCGCCGATAATCGCGGCCATGCCCGGC +TCGATGAGGTCGGTATCCTCGTTGTCATCGAAGCGCAATGTCGTATCGAACTGACCGAGA +GGCTGCGACAAAACGACCAGTGGCGTGAAGGCCGCCGTGTTGACCTTGCGATACGTGTTC +GTGATGCCGGGATCGTCCCATACCTGATACGACAGCGAGAAGATATTCGGCTTGCGCGCC +ACGGCGACAAACGTTCCGCTATCGGCCGGGACCTGTGCGAGATCGGCCGGCGACAACTGG +CGAACGAGATCACGATACGTCGCCTCGGTCGTGCGGTAGACGGCCGGCGCGACGGGTGTG +CGGTTCGGCGGGACGTACTGACCCGGCTCCGCTTCAACGTACGTCGTGGACGGCAGACCG +AAGATATCCTGCACGGCCGTGATCTGGAAAGACCCTTCCTCGTAGCGACCCGCCTGAATC +TTGCCGGCGCGCAGGATCATGTTCTCGATGCCGAGCTGCGGCACGCTGATCGAGAACACG +TCGGTCGGCGCGAGCTTCGCGGCCCGGCGATCGAGCGTGAGCGTGAACCGCTTCAACGGC +GTGCCGTTCGACTTCAGGTCGCGCATCGCCACGCGCATCGCGAGGTCGGCAGTCGGGATT +GCCGGGTACGCCGTTGTGACGCTATACATCGCACCCACGGCTCGCATGTTTCCGACGTTC +TGCGCGCGGACCTGCTTGTCCTCGTCGGTGATTGGATCGTGGTACGTGACGATCTGCTCG +TTGCGGCTCGTGTCGCTCGAATTGCCGTCTTGCGAGATGTTCAGCAGGCCGGACGTGTAG +TCGAAATGCGGAATTGTCGCCGGGTCGTAGTCCGAGCGGATCAGACGCAGCGTCAGCTTC +GCGGTCTTGCGGTCGAAGTAGATGGCCCCGCCGATGTGATTGAGAACCTGCTGCACGAAC +GCATCGAGGTCGTCCTGTCGGTTCCACCGAATGCAGAGGCCGAAACACTCCGAGCAGAGC +TTGTTGGCTGCGTCGGTGAAGGACTGTTCGTCAATCAGCTCACGCGGAAACCCCCTGCCC +CATTCGCGGTTCGTCGCGCATTCATAGATGATGTGCGCCGGGTTCATCGCCTTGATGGTC +TGGTTCGCCATCTGGATCGTCGCCTTCTCCGGATAGAAGACCGGGCCGTCCCATCCTTGA +ATCGATCGACGCACGCGGAACTTCCACGCCTTCGGATACGGGTTCATCGCGCAGATGAGG +CCGTCGAAAAACACCGTGAAGACGCCCCGGAACGCCGGCACGATTCCGCCGAGCATCGCG +GCCAGTCGCGGATTCACTTGCTGGGTCGCCTCACCCATCATGATGTCCGCGTTGCCTTGA +ATGCCGCCCTCCTTCTTGTCCCCGCCGAACAGCTCGGGCGAGTTGATGTAAATCTGACCG +CTAGTCGAGACGCTGCCCGCCCACGCAGTAAGATCGCCCACGGTGATCGCGACCAGTTCA +TCGACGGGGCCACGGCAAAGCGCCGCATGAATCCCGAAGTAGTAGCGATACCCGATGACG +GTATCTCCGCTTTTACCCCCGCCGCCCATTGCCGTTCTCCTTGTAGACTTCTTCCTTCAC +TCGTTCGAGCAGCGCGCAAGTGATGTGCTGCGTGTCGCTGATCTTCAGGCCGTTGCGCAG +CATGTCGCGAAACGAAAGCCCGTGCGACTTGAACCACTCCCGAGCGCCGCGCTCGCACAT +GCCGGCTTTGAAGATGTGCCGGATGTAGATCGTCGGTTCGTTCACTTCTTCCCTCCCCCG +GACTTGATCGGCGTCGTGCGGAAATTGCCGAGACCTACGACCGTCCAATCGCTGCACCAG +CAATCGCCGAACACGACGGCCTGCGGCGTGCCCTCCGTGGCCTGCGGGAAGTTGAAATCC +CCGAACTTCGCGGGGTCCGGTTGCTGCGCTTTCGGGCCGAGCGCCGCCGACAGAAAGTAC +GACGCGACCATGAGCACGAGCCACACGACGAATTGCATTTTTGTTCTCCTTAGAAGACAG +GGTTTCCGTCGAACGGGCTACGGCCGGGCATCCCGTTATACCCGCCGTAGTTAAGGTCGT +TCCCGAACTTGTTCTTACAGACGGATGATACGCGAGCACAACCCGGATACATCACGACAT +TCATTCCGATCGCCAGTCGATCCGCAGCGCCCATGAGCGTGATGCGATTGCCGACGTGCG +TTTCGATGCCGTACTGATCCCACGATCCCGGCTCGCGCTCGAACTTCATGAAGCCGCCAC +TGAACCACGGTGCGGCCTTCGAACCCGCCTCGGCGCACTCGAACCAATCGCCGCCCACGG +CAGTGATAACGCCGTTCGTGGCGAAGTTGTCCGGATTGAGTTTGCAGTTCACGTCGTACA +CGAAGTACGGGCAGCCTTTCGTGTATGCGAGGCGCAGACCGCCGCGCTTGAACGTCATCG +ACATCTGCTGCCCGACGATCTGCGCGTTCATCAGAGACGTGCGACGCACATCGGACACCG +TGCCCATCCACGCCACGTCCGCTTCGTTGTCCGGGTCGTTGTAGTGGTGTTCCCGGATCG +TCAGGTAGATCGAATCGGTTGGCGGCGTTCCGCGCCACTGCTTCACGATGTCCAGTGAAG +CCGCGCAGTCGAGCGTGATCGAATCGGCCGACGCGTCGCCGCTTTGCGAGTAGCCGCCGT +GCGCGATGTTCGTCGCAACGTACGTACTGTTGTTCCACGGGATATCGCGATCAGCGTTCG +TGTAGTAGTAGAACTTGCTGCCGTACAGGAACTCAACGAGCAGGAGCGGTCGCCCGTTGA +AGTTGCTCATGTCGATGTTATCGAAGCTCATTCGAAAACCCCTCCCCCGTTATATGGCTC +TTGGTTGACTACGTGCGTGGGAACAGAGATGTCCGCGTTAGGGTCTGCCGCGAGAAAATC +GAAGACGAAGTTTCCGGTGTTTTTGAACACGAACCATTCTGTCTGCTTTGGATTCGGATA +ATACGATGGAACTCCGGTCCCCGGATTTGGGTTCCATCGATACGTCATATAGGGATACGC +GCGCAGGATATTCAGATAAATGCCGGTGTTCGGGATCGCAATGTTATAGCAGGCGAAGAC +CAGCTCCTGAACAATCGTCCCGTTCACATCACGTTGTCGCATCTTCACCTTAGCCGGCCA +TTGAACGGTATCGAGAAACGCGGCGGTAAAAAGGTTGCCCCAAACGTTCGCCCCCATTAC +GTCGCCTGCCGGGTAATGTCCGCCTTCGACGGCAGTCGGATTCAGCACGTCGTTTGCTTG +CGTCTTCAGCTCGGAAATTTGAAGCGGGACTGCGCCGCAACCTGCTTGGATATAAGAGCC +CGCTTTTCCACCAAGCAACACGTCGATAGAGTTGATAGCAGCTTGCATCAGGCCGCTTGC +GATTGAGTTGTCGAATGCGGGAACGATGCTCTGCATCCAGCTTCCATTCGGGTCAGCTTC +GATGGCTGCTGCATTCACGATACTCGCAGTCGCGCCGCGCATACCTGCGACCATGGGCGG +GTTGCAATCCACCCACCAGTGAATCGAACCGGTTGAGCTGGTCGTCTGCGCTTGAACGCT +CGACGCGCTCGTGATCGATTCTAGAATTGCAGCGCAGGCGGTTGCGAGCAGTGTTTCTGA +CGCGCTATCGTCCTGCGCGCATTCAGTTATGTCAGTGGTGAGCGACTTCGCCGCCGCGTA +CGCGAGGCCGCCCGTCAGGAGGGAATACAGAAGAGAATAGATGTTGTACGCCAGAAAAAC +GCGAAACGCCGCGTGCAACGTTGCGTCATCAAGCGAAGCGTAGTACGCGTACCGATCCGT +GGTGATCCATGGGGTTCCTTGAATCGTCAGGAGCATATAGTCCCGCGTGTAATTGTTCGA +ATCGTTCATCGCCGCAAGCGTGCTCTGCCGCGTCGCCTCGGCTTGGTCCGGGGTGTAGCC +GCTGGCGACCATGATGTCGTACGTTGCGTTGAGGTTCGCTGACTCAGTTTTTGGATACTC +CCCCGCAAGCGGATCGACCGGCGGGCGGCCGTTCGTTCGAACGTCGCCCCATGCGCCGCA +TTCGCTGCCGCAAATACACGGGTCGGGCGTTTGCGTCGTCTGCGTATAGCGCGTGATGTC +GTAATTCGTCGCTACTCGATTTTCAGGCGTGCTCTGGAACGTGACAACTGCCGAGCTGAC +GCCCTTCGTGTCGGTCATGTGGTTGATCTCTACGCGGTCTTGATTAAGCCGCGCGAGCGT +CATGAACGAGACGCGCTTCAGGTCCGAGGCGAATACGGCTTGCGTGAACGCCGCGTCCAC +GGTAACGATCTCGTTGCCCGTAGTCTGGTCGAGCGTTACCCCCAATACGCGACGATACAT +TGCCGGCACTGTCGACCGACGCGGGTCGAGAATGATGTCCTGCTGCCCGTCAGGAAGGGT +CGAGAAGAAGTCAGCCAAGCCGCTGCGCTTGATGGTGATCGTCGTATCACCTGACTGGAT +CGGTTTCGCGAGCTGCATATCGGCCGCATGGGACGGCAGCCAAAAAGGCGTGACGCGCCC +GCGCAGTGCGTACAGCAATCCGCGCAGGTCGGCATTTTGCTGGCGGCCGTGCGCGAAGAA +AGCAAACTGCTGCGCGTAGAGCTGGATACCTGCGGTATCTCCGCGCTTCGGAATGCCGTA +TCCGGAATCGAGCACGTCCAGTAGCCGGGAATACTGAACCGTCAGGTCGCTCGTGTCGTC +CGGGCGAAGACGAAACACCGGATAGCCGCGATAGATGTCAGTCCATGCGGCTTCCGGGTA +ATCGTTCGTTTCCGTGACCTGCCAGTTGATCGCGTAGACGGCAGCGCGATCCGCCTTTCG +GGTCATCTGCGGCTGGTCGGTCAGCATGGCTTCCTGAATCGGAAGTAACTTCGTGCCTTT +CGGCCATGCCTGCACGAGGCCCTGATCGAGCGTGATAGTCGTAGCGGTCATATCGGCTAT +CAGCCGAACCTCGTAGTCGAATGAAGTCCGACCACGGAAAAAGACGAGGCCGCCCTTCTT +CAGTTCGGACGTGGTCGTATCCTCGACGTACACGACGGTATCTCCGACCTGCGCAGAGGC +CGTCAGCGGGTTCAAATCCCACGGAAGAGGGACATTCCAGCTCGTTCCGCCGCCGGCCGT +CAGCGCGGCGTTCAGGCGCGTGCGCTCGGCATCGATCACGAGCACGGACGTTTCGAAGAA +CCGGCGCGGCGATATCCGGAGCGAACGCCGCTGCTCGGCCGCCATATTCGATTGCTGCAC +GCTCGTCGCCCATTCGAGCGCTTCGAGTACGCCGCCGGACCATTCGGTCGCGGAAGACCA +GACGGGAAGATTGATGTTCGGCATTACTTGATCCCCAATGCTTGGCGTGCGGTTACGGCG +TTCTGCCGCAGGTAGGTTGTGATGACGGTATCGCCTGCCGCCGACGCCATCGCATCGGGC +ACGAAGTTCGGATCGGAGATCAGCATGTTCCGGATCGTCATCGGCTGCTTGGCGGCCTGC +GCTGCATTCTTCGCGGTCTGGTTCAGGATGTTGCGCGGATTGTCCTTCGCGAGTACTTCC +TCGCCCTTCTGAAGGATCGCCGCCTGTTCATCAGCCTTCAGGCCGACTACCGTGCCGCTG +TGGTAGCGCGGCGCGTTCGCAAACCAGCTCGCCGACGCACTGCGCGACATGCCGCCCGGC +TGACCGACGACTGCACCGGAGTGCGCAATGGCAGCAGGCACGGAAGCGCCAAGGCCCCAC +GTCCCGAGGCCGGTTCCTACGGCAGCCGGGGCAGCCGACGCAGCGCCGCCGAACAGACCG +AGCAGCGCCATCGCCGCGCGCGTCGCCATGATCTGCATGATGACGCTCGCCATCTGGCGC +AGGAACTGCGCAGCGAACTGTGCGACCGATTGCCCGACGTTCTTGAATGCGTCCGACCAT +TTCTGCGTGCCATCGGCGGCAGCGAGAAGCTGGTCAACGACGTTCGTCATCGTGCTGTCG +ATCCCCTGCGCGAAACCGGACGTGAACGTATCGCGAATCTTCGCCATGTCCTTGTCGCAC +GTACTGCGTCTGCGTGCTGATTTCCTTCAGCTTCGCATTGAGCGCATCGAGCTTGGAACC +GGAGATGTCGCCGGGCTTCGGCCATCGTATCGAGCAGCTTCTGCATCTCAGCGACCATGC +GCTGAATCTGCGGGCCGCTCTCCGTGTACGCGGCCTTGATTTTCTGGTTCGCCTCTTCCT +GCGTAATCGCGCCGAGCTGCACGAGGTTGTTGTACATCGTGACGGCCGAGTTCCGCTCAT +TGAGCAGGTTGTTCGTCTCGGTCATCTGTTGGTTGAATACGTCGAGACCGCCCTTCGCCG +CCGCAGATGCCGGGCCAGTGGCTGAATCGTTGCCGACGCGCGTCATCTTCTGCACGAAGG +CGTCGATCTTCGCGTCCGGGATGCCCGTGCCTCGCACGCTGTTTGCAAACGCCGCTGCAT +CTTTCGCCATCTGCGCAAGTTTCGGTTGCGATCGTTCGGTCTGCGTGGCGATCTGTTTGA +ACCCATCCACTGCCGACAGCGTGCCGGCTTTGACTTGTTCGAGCACGTCTTTCTGAAAAT +CCGCTCGCTCTTTCAGCACGTCGTTGACTTGTTCCTCTTTCTTCTTCAGTTGCTCAGTGT +TGAACTTAAGCGTTTCTTGCTGGATAGCTTGTTTCTTGATTTCCTCGATCTGCGCCTTGA +TCGCGGCGATAGGCTGGCCGTCGACCGTCGTGCCGCCGATCTTCTGGTACTTCGCGATCG +TGTCGTAAATGTCCTTGAACGTGCGCTCGACAGCCTTCAAACGCAGGTCAAGGTTGTCCT +TGTACTGCGACTCGACTTGCTTCCAGAGCGAATTCAGTTTCTCCGACAGAGACACTTCCA +TGTTGTACCGCTTGTCGGCGTTCTTGTCCTTCTTGTTCGGGTCCGCGATGTCGTACAAGC +CGCCGGACGTATCGGTCAGCGGTGTCGATCGGGGCGGCGTCGTTGCAAGGCGCGCGCCCT +GTCGACGGAGGTCATTCTGATACAGCACGTCGAACGCCGCCTTGTTGTCGGCCAGTGCTT +TATCGCGCTCCGCGCGAATCGAAGCGAGGTTGCGCTGCGCGAGTGTTTTGGCCTGCTCCA +TCCCGGTCTTAGCGCCGTCCGTGATGCCCTGCCGAGCTGTTCTGCGACGTTATCGAGGCC +GAGGAATTCCGCCGTGCTGCGCAGGCCGCCGAGGAAGCCGTTCTTCAGCGTCTGGATTTT +CTTCAACGCCTTGTCGAAGAAGTCCACGACAGAATCGCTCATCTGCGCAGCAAGCACGAG +AATGCCGTACTTGACGTTGATCCATGCCTCGTAGATCGATTCGGCCGCCGCAGTGCCGAC +CAGTCTCGCAGTCTCGAACTTCTCGCCGAGAATCTTCCCGATCTGCCATCCCGTGAACGC +AGCGGTCAGGACGAGGAAGATTTTGTTGATTGCCGCAAGCGCGGCGTTCAACCGATCGGC +GGCCACGGAGGCGGTCGCCATCGACGCGCCGGCTGCATCGACGCCCGGTGCAGCGGCCGC +CCCGGACGCACCGACCGCCGCCATAGCGAAGGCCGCTTGTGTGAGCTGGATCGTGAAAGC +CCCGATCGACGCCATCACCTTCACGCCGAGCACGAGGCCGATCACGTCGCCCACGGCGTT +GATATTCTTGATGACTGCTTCGAGGATGTTCAGGACGACCGTGAACGCGTCGGAAAAGTT +TCTCGCGAACTGCTTGCCGTCGTCACTACGAAGTAACTTCGTCATGTCGACGGCGAACTT +GGTCCACGCGTCCGCGAAGCCCATATCGGCGATCGCCTTCCGGAACTCGTAGAACGCGTT +GTACATGCGAGCCTCGGCGGCCTGCATATTATTGACGGCCATTGGGAGCTGCTTTCCGTA +CTCATCGCCGAGCTGTTGCGCGAAGCCGAGAAGCTCCTTCACCGAAACGCTGCCCTCTTT +GAGCCGCTTGTTCAATTCCGGCAGACTGATGTTCATGCCCTTCGCGAAAAGCGCGAATGC +GGCGGGCAGCCGATCGCCGAGCTGGCCGCGCAGTTCTTCCGCCTGCACCTGCCCTTTCGA +CATCATCTGTTCGATCGCGAGGAACGTGCCCTGCATGTCATCCGCGCTCATGTGCAGTAC +ACGGGCGGTCTCGGCCACTTTCTCGAAGATAAACCGCGTCTGGTTCGTCGTTGCGCCGGC +TGCCTTGGCCGACACGGCGAACTTGCCGTACGACGCGGCGAGATCATCAATCCGGATGCC +GAGGCGTTCGGCTTGCGCCTGCACGTATTGGTATTCCTGCGCAACGACTTTCGGGTCGTT +CGTTCCAGCGGCCACGGCGAGTACGGATTCGTTCGAGTTGAACTTCCGCATTGCATCGAG +TGCGCCCGCCGCAAGGTTAATCGCGCCCTGCACGCCGACGTACGCCGTGGCGAGCGCGAT +CAGCTCGCCGCGCACGCGCTGATACCACGACAGCGATTCGCGGTTCCCCGTCGTGATGCG +GTCGAGCAGCGAAACGGTCTTCGCCGCTTCCGCATTGTGTCCTTGCATCGCAGCGGTCGT +TGCTCGAATGCCGTTCGCCTGCTGAGACTGCGCTGTGAGATCTTTCGACGCGGCGGCAGC +TTCGGCCTGAGCGGCAGCCCGAATACGAGCGAGGCGAGCATCAAAAGCCTTGGCGTTCGC +ATCGTTCACCGCAGCCTGCGCAGCAGCCTCTCTGGCGGCCTGCTCGCGCCCGGCCGCTAC +GATGGCAGCCCCGGCGGCCCGCGCGCGGTCCTGACGGGCATTCAGGCGGTCTGCTGCGGC +AGCCGCAGCCTGCGTTGCCTGCGCCTGTTGATTCATCGCCTTGGCGACCTGCTCTGCCTG +CTCGGCGACTTGCGCTTCAAGGCCACTGAGTTCGGCCATGGACTTCGTCAGGCTGGCCGT +GCGGGCATTGGCCGCCTGCACATCCTGACCCGCCTTCGCGACGCGCTGGGTGAGTCGTTC +GAAGTCCCGGCCGCCGCCGGCCGCCGCAGCAGCAAGCTTGTCGAGTTCACGGGCGGTCGA +TCGAGTCGGCGGCCCGGCGTTGAGCGCATCACGCGCGAACATCTGGTACGCGATGGCCGC +GCCCTCGACGGACCGCTTATGGCGATCGAGGTTTTCGTTTGCGGTATTGAACGCCTGCGA +CGCCGCACCGGCTCGCGTCTTCGCCTGATCGAGCGCATCAGCAGCGCCTGACATGGCTTT +TTGTACGGCGTCAGCAGCCTTGGAGAGATTCTTCTGCTGATCGGAGAGGGAGGCGGCCGC +TTTGCCGAGACTGTCCGTCCCTGCGGTTGCGGCCTTCGCCTGTTTGACTTGGTCGGCGAG +AGACGAAGTAACTTCGTCAATCGCCTTCTTCGCGTCCTTCATCGCCTGCGCCGACATGTC +CTTGGCGCGGATGATGAGGTCGACTTCCTTCTGGTTATTCGTTGCCATCTCGGAGGCTCC +TAACTTTCTCGTTCAGGGCTTTCACGTCCCCGGACCAGACGGCGAAGATTGCCGCGTAAG +TTAGAAGCGCTTCGGTAGCAATCAGGCCGTTGATCCGTTGACGCGAGATTCTACTCTCAT +TCCATAGTACGGCGAGGGGGTAGTCCCACGCGTCCGGGTGTCCTTCGGCCATCAAGAGGC +TGGCGTCGCGCCGCAGTCCGAGATACCACTTCTCGAACCGCGACGGTTCGCCATCCGTCA +ACCGGTTCTCTTCGGGATCAAGCCTTTCGTGATCCCCCGGAGCGCCCCCAGCCGATTGAA +GAACTCTTTTGGGCCGCCTGCGTCCTCGAACGTGTGCTTCCCGATAGCCGTCAATGCTTC +GATCTGCACCGAGAAAGACAGCTCCGTTGCAAACACATCGGCCAGTGCTTCGAGCTGTTC +CTCGTAGTCGTCGGCTTTCCGGTCTGCCTCGTCGCACGCGAGCGCGATCATCTTCCCGAC +CAGTTCGGGGGCGTCACGCGTCAGCATCTGGATGAGAATGTCTCCCGACTGGTTCATGAA +TACGTCGGTCGTGTGGGCGGAATACGCTTCCATAAGCGTATCGATATCTTTCAGATGTTT +GTCCACGAGCTGCGCCACATCGGTCAACGAGAGACCCCGCACGCGCAGGGTCTCTTCGCC +GACCGGGATCGTGGTGCGCCGTGCTTTGTAGTCACGGAATCCCATTTCCCGGTTCTCCTT +ACATCGGCCGGCCGTCGAGGTACACGCGCTCCGTCGCCGAGTCCTTCTTCAGGACTTCGA +GCTTGAACTGGAGCTGCTGCCATGCGTCGCCCTTCAACTGGAAGTTGCCGTCAGCGGTGA +TCTTCGTGTACGGCATGAAGTAGTTGCGCGACGGGCCGTACGCGTTGTGCGAGATGAAGC +GGAACGCACCCATGATCTGATCGCCGGCCGACACGACCTGATCGTAGGTATCCGCCGCCA +GCTTGTACGTCACCGAGATGGGCTTCGTGTCGGTGATGTCGGCTGCATCCGGCTTGACTT +GGAAGCGGCCGTTCTTCAGGTCGATGTTGAAGTTCGTGAGCGGGATTTCGGCCGGCGTGG +CGTCCGTCGTCTTCGCGTCGAAATCGGTGACAGCGCCGACGCCCGCGATATTCGTCGGCG +AGACGCCGAGTTGATACCATGCGCCCGGCGTGACGATGATGGTTTCCGGTGCAACCGGCG +ACGCGCTGGCGGCTTGCGTGACCTTCGCCTTGCTGCCGGTGAACCAGAGCGCGAGGTTGT +CCGTCGAGATGTTGTCGACCTGAAGCGTCGTCGTCACGTCCTGTTGCAACGTGATGGTGA +TGTCCTTCACCTTCATCCCCTCGTCGGAGTCGAAGTGGTCGAGCATCGTGCTGGCGACGG +CCAGTTCGAGCGACGGCGAGTTGCCGAAGTACAGTTCGCCGGTCGTGTTGAACGTGCCCG +GAGCGAACTTATCGAAATAGCACTTACCCCGGCCAAGGATTTGATCTTGCGGCATGGTGA +ATCTCCTGTGGTGGATGAAAAGTTACGGCCGATACGGCAAAAGGTCGTACGGGTCCGTGG +TGTTGTTCGCGATCTTCAGGTTCAACGGCAGGTAGAAGTACGAACGTCCCGAAGCACCTT +CTGCGGGCGCACGACACACGCCGGGGCCTGCGCGCATGCCAGCAATGAGGTTTTCGAGCA +TGTAGACGGACGGATATTGAGGGTTCCCCGACGAGCTGTCAATGGCGATCAGTTCGCCGA +GGCGCACCTGCACGTCCGCCATAAGGCGATACGCTTCATCGGTCGGGTTCTTGTCCCCTT +CAGCATGGTTGACCCAGCCCTGCACCAGAAGCAGCCAGTCTTCCGATTGCGCCTGCCCGT +TCTCGTCGGCATCGAGGCCGTGATCGGGTCGTTGCGCTTCGAGGATCGACACGGCAGGGG +CAGGCGTCTCCGCGCCGAACTGCACTCGGTTTCGATAGATGCCCGACGAAAGGTCGAACT +GAAAACCGTTCGTCGGCGTGACGCCTTCCAGATGGGCGGTGAGCTTTTTCAGGATCACCA +GTTTTTTAGGATCGCGCTGCATGCTTTACTCCGAAAGACGCGTGAACTGGCGCAGGAATT +CATCGGCCAGTGCGTCAAGCACTTCAGTTGTGATGTCGTCCGCGACAGTCCGGAAGACCT +GATCGACGGACGGCCCGTATAGCAGGTAGACGTTGTTCGACAGCTTCGTCGCGCCATCCG +TCGCGTGCAGCGTTTCGCCGGGGCTGAGACGTACAGCAAGCCCGAGGTTGTACTTGTCCT +CGGTCAGGGTCTTGCCGGCTCGCAGACGCACCAGAAAGCCGCGCTTGAACTGCTTGGTGC +GTCCGGGCTTGACCACGACCGAGACGCCGCCCTTGCGCGTCGATTTAGTCGTCTGTCCCG +GTTCGGCGAACCGGGCGAGCGACGTAGGACGCTGGCGCGCGCCGATCACAGCTTCGAGGT +CGTTGCGCGTCGCCTTCTTGGTAACGCCAAGCCGGCTATCATCTTTCAGGTAGTTGTCAG +GGAAATTGACTTGCTCGCCGATCTCGGTGCGGGCGAGCGGGAGGGCCGTACGCTGCGCGG +TCTGATTGATCGCGATCATCGCGGCTTGTTGCGAAATGTCGGGAAGGCGGTCCACGTAGT +CCCGAAACTCCCCGAGTCCTTCAGCGACGATTTCGATGCTCATTCTGGTCCTCGTCAGGG +CCGGACGCGCTCAACCGACCACTTGATGTCTACGAAATTGTCCGTGTCGTCCTCGACATC +GAGGCGGAACGTGAAACCGTAATCCGGAAACGTCACCGAGCCGTCGCGCTGCAATGTGAT +GCCGAGTGAAGTTACTTCCGGTTTGTTGAAGACCAGATAGTTGATGCCCTCGACCATGCG +TGCGTACCCTTCGCGGTCGAGATCACCGACGAGCGCCATCTTCGTGTGGAAGCGAGCGGT +CAGCGGCGTCTGCGCACCCGTGACGGGGTCAGCATAAAGCGCTGATACCGCCAGAGTGTC +ATGGACAGTCTGACGGACCAGCGCTTTAAGGGCGGCGAAGTCGCCGACCATGGCTTACAG +GCCCGAGGCCGACGCTTTCGCGCGGGGCTTCGCCGGCTTCGACGCCCCGGCCTTGTCGCC +GTCTTCGCCTTCGTCGCCGGCCGGGGCGTCTTCGACCTCGACAACGTGGCGTTGCAGGAA +TTCCTTCCCGTGGCGCTCGTGCAGATGCTCGATCTCGTCGTCGGTGAAATCGAACGGCTT +GCCCGGTGCGGCGTGAACGATCTTCCCGTCGCGGGTGGTGATGACGGTGTGCTTCGGAAC +GCGCTTCGGCATGATATTGCTCCTGTTGATTCAGATGAGAAGCCAGCCCCGAAGGGCCGG +CCGATGACCTACGCTACGCGGGTCGCGTTGTGCTTACTTGACCGTCATGCGGAAGGAAGC +GTTCGGCTGGGCCGGGACCATCAGCGGCGCGCTCTGCGTCATGAGCATCGCCACGGACGG +GTCTTCTTCTTCCCACATCTTCGGGAACATCCGGGTCGGCACGAGACCGTTCTTGAAGTC +CATGATCGCGCCGAAGCACTGCGTGCCTTGGAGACCCGGACCCGTCCCGACCACGTCGTA +CGAGCCGAGGATTTCCTGCTCGGTGTTGTCGTCGCCGGTATAGGTGTCGTGGTACGTGTA +GAGTTCCAGCGTACCCATGCCGTTATAGCCGCCGATGGTGCCTTGATACTGAACCGGCGA +ACCGTCGTCCAGTCGCGAGCGGTTGAAGTCGGACGTGCTGCCCTTGTAGAACAGGTTCAG +CAGCTCGACCACGGCGGGTTTCTGCGAGAACAGCGACCAGGCGTCGAGGCCCATCGTCAG +TCGCGTGATCGTGCTGTTCGACTTCTTCCACGCCGTCGTGCGCATCGTTTGGATGTTCCC +CAGCGGATCGGACGTGGCCTGATCCCACGCTGCGCCGCCCGTCAGTTGCACGGTGAGCGC +CGGATCGCGGCCGAAGTCCACGCGTTGCATCGGGAACGCTTCGCCCACCACGTCCACGTA +GCCGTAGATCGTCGCCATTGCGCACATCCATTCGATCCGGTTCTCGATGCGCTGGCGCTG +TTCGAGCTGCGAATCCGCGACGACCGCTTGGAAGCGCTCCTGCAACGACATGCCGCCGAT +GATCGGCTGCTCGCCGGCACGACGCTTGAGCGTACGGTTCGGGTTGATAACGTCCTTCGG +CTTCACATAGGCCGGACGGAACGTCTTCGTCGTGTATCCACGAGCAGCGATCACGCGGCC +TTGCACGTTCGGCGCGACGAACGGGGCGAGCTTCTTGTCCTTGAAGACGAGGTCGAACAG +AATCTCGTCCGTGTCGAACGTGATCTCGTTCGGGTAGAAGCCCTGCCAGTACATCGACAG +CGCCGGGCCGGACTGAATCACGCCAGCAAGGGTGAGGGTATCGAAAATTTCCATCTTTGT +TCTCCGAGTTGTACAGGGTTTTCTTGCTGGCGCTCGTTACAGCGACGAGCGTGCGGTATC +GACCAAACGATCGATGAACACCGGCGTGCCCGCGAAGGCTGCTTGGCGTTCTTCGAACGT +ATCGGCGGCGGCGTCCCACACCAGTACGGCATGGTTGAAAACACCGCCGACGAAGACCGG +GTGCGATACCGTAGCCGCGCCGGCCGCCTTCGGCTGCGCCGAAATGCCGTACGCCTTCTG +CGAGCCGTCCGAGGCGGCCGGGTTCCACGGCACGAGCAGGCCGCCGACGAGCGCGACGAC +ACGGTACTTTTCGAGGACCGTGGCAGCAGCCACGTTCGCCCGCGTCGTCACGATATCGGC +TTCGCCCGCATAGAGCTGTTCCGGGATGTACGACCCTTCGGTGCCGTTGCCGGCGAGATC +ACGATCGATCATTTTCTTCTCCTAGCTAGGTTGGAGGATTGTTGCTGTATTCCGGCCGGA +ATACCGATTACTTCTTCTGCTGGATCAGGTCCTTGCGGCCCGTCGCCTTGGCGAGCGACG +CGAGCAGCACGTTGCCGCCCTTCTTGCCTTCAGCTTCGTTGCCCTTGCCGCCGGCCGGGT +CCGCGCCGACTTCCGGGTTGCTGCTGGAGTCCATCGCCTTGTGGAACGCCGTGGCGTTCT +TGCTCGTATCGGCCGGATCGGAAGTAACTTCCGGTGCGGCGGCAGCGAGCATCACCTTCG +CGTCGTCAACGGACATCTCGGTGTTCAGTGCGATGTGGTTTGCCAGTTTCGGCTTACCCT +TCGCTTCTTCGCAGTTCAGGATGCCTGCTTGGCGCTCGCGGTCGGCCTTGATAGCAGCAC +GGCGTTCGGCGGCCAGTTGTTCTTCGGTCAGTTCCATCTTCGTACTCTCCATGTGGACTT +CGGTTTCGGATGTCGAGCCGGAAAGCTCGTTGAAAAACGCAGCGACAGCATCTACCGGTT +TTGCCACCGCGTCAATCAGCCCGAGGTTCAGCGCATCGTCTGCCCGGTACGTCTGAGCCT +GCGTATCGCGAACTTTCTGGCTGTCCATCCCACGGTTGCGTGCAACCAGTGAGACGAATT +CGTCGTACGAGGCGTTCACGTCGGCCTGAATGCTGGCCTTCACTTCTTTGCTCAACGCCT +CGTAGGGATTGCCGTCGACCTTGTGGTCGCCGGCATGGATGAAAGTGATTTTGATGCCCA +TGTCATCGAGCATCTCGGACATATCGACGTGCATCGCGACTACCCCGATGCTGCCCGCCC +CTCCCGAGGGCGTCGAGACCACCTTCGTTGCGGCGGAAGCGATGGCGTAGGCGGCCGAGT +AGCAGTTCGAGTCGATGACGGCCATGATGGGCTTTTCGTCCCGCGCTGCGTAGATGTCGT +CGGCCAACTCGAAGCAACCCGCTGCTTCACCGCCGTAGGAATTGACATCGAGGATGATGC +CTTCGACATCATCATCCGCGAGAGCGGCGTTGAGTTGCGCCCGTACGAAGTTGTATCCCG +TGACATAGCCGAAGCTGTAGTTGAACCGGTTAATCATTGTTCCTTGGAGCGGGATGATAG +CAAGCCCGTTGGAAAAAGCAAACGGTTTGTTGTCGGCCGCGCTCTGAAAGCCATACGCCT +GTGCGAGTTGCGTGCGCTGGACCTTCATGAAGTCGTCGTGTTCGAGCGCGTTATCGGCCG +CCGCGAGCTGCTTCATGTCCTGTACGAGGCCGGCGTAATGCGCGGCGACCATCTGCCCGC +GCAGGTTGAACCGGGTGATTGCGATGTGTGCGTCGCGTCGTGCCATCTTCATTCTCCTTG +TTGACTGGTTTGCGCAGCAGCCGGGTCTTCGGCAATGCCGGTTGCTGCGTCGCGTCCGTC +GCCGAGCGAGCGCTTCGCGCTCAGATTGAAAGTGAGACCGTACTTCTTCAGCAGGGCGTC +CTCGCGAGCGCGCTGCGCGAAGCTCTTTCGGAAGTCTCCGCCGAGGCGCGCGATTTCGCG +CTCATAGGTCGAGAGGCCGGCATCGATCCGCATCACGGCTGCCTGCGTTTCCTTCAGTTG +ATCGATCTGGCCTTGCGACGCGCCGATCCACTCGCATTTCGACAGCGCTTCCTTCATCAG +CGGCTGATAGAACAGGTCCCGCGTCTGGCCCGGCGGCATCGGGACTTCACCAGCCGCGAT +AGCCTCTTCCAGCCACAGCGTGAAGAACTCGGTCGCGAGGCGATCGGCGCACATCTTCTT +GCGCCCTTCGAGGAAGCGCCGCGTCATCGCGATGCCGGCTTGGATGCTCGAATAGTTCGC +CTTGCTAAAGTCCCGCGTGAACTCTTCGTAGCTCATCCCGAACGCCGACGCCAGATGCCG +GTTGAGCGACGCCTCGAATTCGCTACCGACGCCGCCCGGCGTACCCATCGGCTTCAGGTT +CAGCTTCGTGCCGGGAAACAGATGCGGAATCTTCGCGCCGTCGATCTGGATGTTGTTCGC +ACCGCCGACGTACGCCTTCAGCGCGTCCATGTACTTCCCGAAGATGCCAACCATGTCGGC +ATTCGGCGAACCGCCGGACATCTGCGAATGGATGAACTCGGGCGGCAGCTCGGACTCGAT +AGCGGCCGCGTACGACGCGTTGATGACGGCGTTTTGAAGCGACATTTCCTTGAAACGCTT +CGCCATGCGCATGTCCTTCAGGCCGGACACGATATCGGCAATGCCGCGCGACTGATCCGG +TTCGCGCGGTTCGAGGATGTGGATGACCTGACGACGGCCCCACGGCTTCGATTGCTGTAC +GAACTTCCATTTGTACATGTCCGGGGCCATCTGGTACAGGTCGCCGGGGTGCGCGACCTG +AATCCAGTAGCCCTGCGGCCGGCCGCGCTTGTCGTACTGCACGCCGCGTCGAAGCGTGGG +CGTGTCGAGTTGCTGGTACGGGTTCGACAGGCGGTCGGTCGATACCATCTGGAAGCAGGT +CGCGTACGGCCGGTTCGCCGCGCGGTCCCACTCGGCAGTCGCCAGCACTTCGCCGGTTTT +CACGTAGCCGACCACGCCAAGGCGGATCAGACCGGTGAAGGTCGAGATCGCAGCATTGTC +GATGTAGCAGGCGAGGGATTCCGCGTACAGCTCGAACTTCGCTTCAACGATGGTCTGGTA +TTCCTCGGCCCATTCCTCGGTCGCGCCGGGGATGACGTTGATGTCGGGCATCGAGTTGAG +CCGGTACTGCGCGCCCACGATGCTGTCGCGCTGATAGCCGACCGCGCCGTTCGTGAAGCC +GTCGTTGTCGGCCATGTCCCGGCCGCGCGCGTCGGCGATCCGCTTCAGCGGGTTGATGAG +GGCATCCGGCGAGCGAAGGCTGGGGTTCCACGACACGGTCTCTCGCGAGAGCCGCGACGC +GCCTTCAAGTCCGCCGCCGCCAAGCGAAGCCGACTGTTCCGGGCGACCGGAAGTAACTTC +GGACAGTTTGCGTACGGTAACTTTGGTCATGGTCAGAAGGTGAACTGAAGGGGGCCATTG +GAACGACCGCCGCCGCACGGGCCGCAGTCACCGCATTGCGCTTCGAGCTGGCGGATGTAG +GTCACGAGGGCCTGCTGATTCGCCGCCGTGAATTCTACGCGTTCGCCATTCTGGTCCACG +ATCACGCGGGCCGAGCGGCCGGTCAGCAGCTTGTGGTACGCGTCGCGGCGCCGCCGCGAG +GTACTGCCGGCAGGTTGCATCATCGAGACAGGGCATTCGGTTTCTCCGGTAGTGGGTCAC +GCCAGCGCGGCGGCGATTTTCGCGAGATCATACTCTTCGCTTGACTTTTCCGCAAATCTC +TGTTCGCTGGCATCCGCAACGAGGGTGTTCTTGTCCCACTCTTCGGCCCAGCTCGGGGGC +GACGACCAGTCGAACTTCTCGGTCAGCAGGAGCACCGATGCGTTCGCCCCGAGGCAGTAG +TAGAGCAAGTCCCACGACTCATTACGCTTGACCGACGTGGCGACCCATCCCTTGTCCGTA +CGCCGCTCGGAGACGAGCTGGACGTAGTAGCTGTCAGGCAGCCATTCGGGGAAGTGAACC +ATGCCGCTACCGGGCGTCACCACTTCAAGCCGGCCGAGCGCAGTGTCTTTCAATAGGTTC +GAGTTCAGGAACAGAACCGGTACGTCTCCGCGCGCAGCAGACCATTTGTCCTTGTGGTTA +GCGTCCGGGTAGCCGACTCGCGTGCGCGGATGCCCCGGCTTAGGCTCGCCCTTGATGAGA +TGGAAACGGCCGTGCAGACCTTCTTCGCGAAGCTGCCGGTAGAAGTTGTACGCCATCCCC +GTGACACCTTCCCGGCCGCCGGAATCGCAGAAGGTCATTTTGAGCTGCATCACCCGGCCG +CTGTCATCGTCAAGCGGATACATTTTCTCCATGACCTGCGTACGCACTTCCTGCCAGTCT +TCGAGATACGCATGCGGCTTCACCCACTCTCGGTCTCCGTCGTGATCGACGCGCTGCGAC +TTGATGACGTTGAAGCGGTCCACGACATAGATGTCGTACGGATTGCCCGGCGCAATGCCG +AACACGTTGCAGACCCACATGTTCTTCTGCACGTCGCAGATACCGATCAGGAAGCGGACA +GCCTTCGGAACATGTTTCTCGCGCAGGACTTCGGCGCGCGCCTTCAGCGTCTCCGGGAGC +AGGACCGTTTCGTTGCCGCGATGGAAATACGGTTCCCCGAGGTCGGTGTTGTAGAACTTC +TTCAACGATTCCTGCGACCCGGTACGCTCGTAGTCTTCTTCGGCCGTGATGTAGTTGGCG +ACGAGTTTGCGCCACGAGATGAACGCCGCCACGACGCCATTCATCCAGAAAGACGCAATG +CGCGAGCGTCGCGGCGTGCCGACCCGCTTGTCATCCGCCGTCATCGACTCGCCGTCCTTC +AGCCAGACGCCCCACAGGTCGAGATCGTTGCGCTGATCCGCTTCGATCCGGCCGCCGCAG +CACGGCGCTTCCATGCGCACGGTATCGGCGCACGATACAGCGTCGCCGCAGTCATCCCAC +TTCAACAGCTTGAAAGTCGGTTCGAACCAGTCGCCGCAGTGCGGGCACTTCCAGTATCGA +CGGCGACGGTCGCCCCGGTTGTACAGGCCGAGAATCCCCTTGCATGGGGGCGCTTCGTGC +GGCGATGAAGCCAGCCACTTTCGGCCGTCTTCTTCGATCTCACGGGACGGGCTGGACTCG +GCCAGCGTCATCGCGAACGAACCGAACGTCGTGGTCCGCTTCGACGCGAGGTCGAACGGC +TCGCCGTCGCCATCAACGTCGTCCGGCATGCGGTCGTAGTCGGTCAGGCATACGCGGCCG +ATCGGACGGCCAGCGAACTCGGTCACGGACGGCCACGACAGCGTCAAGATCGTGCCGTCC +TTGTAGTGCTTGTCGAACTTGTTGTCGGTGTCGCGCGAGCGCGCCATCATCGCGCCGATC +TCAGGAGAATGACGGTGCATACGATCGATCCGTCGCACGGAGAAGTCGCGGGCTGCTGAG +TTCGTCGGGCAGTACAGGATCATGTCCATCGGGTCGACCTTGACCGTGTACCCGACGAAG +TTCAGTAGCAGGCCATCAGTCTTCCCGCACTGCGCCGGGCCGACGAAGACTTCCGCGTCG +AAGTCACGGGACGTGAGCGTGTTCATTGGTTCGACCATGTACGGCACGGTCTCGTTGAAC +CAATCGCCCACGTACGCGCCCGGCGTGTTCAGCTTTCGGTACTTGGCGGCGGCCTGCGAT +ACGGTCAGGCGTTCCGGCGGCCGGAAGATGTCGGCGAGGTCGATGACCATCGCCCCGAGC +GACTTATAGACCTGCTGCTGGGTCGTCGTCAGTTCCTTCAAAAACGCTTCCCGCGCTGTC +GCGATCTTGAAGTCCTCGTACTCCGTCCTCGCCGTCGCCACTTCCTCCGCTGTCACCCGT +TGATTCGATTCGTTCGGCTTCATGGTCTCGTTCCGGTTCGTGTTTGAATTGTTCGATAAG +AGAGTTGCGCAAGCTCTTCAACAGTGAGTCGGTCATCTTGCGAATGATGGCGCGCTGCTT +GTCGCTCAGTTCGGCTTGGCGGTCCACCGAATCGACCATGAGAAGAATCTCAGTTCGCAG +CGTCTTGAACGACTCGGCGTAGTGTTGAAGTACCTTCTCGGTTCGCCAGAGATCGCCCTG +TTCTTCCTCGAATTTCAGGCGCGCATTCTGCCCGCTCCAAAATTCCTTCAGCAACATCGG +CGGCAGGTCTCGATGGTGCATCTTCTTGATGTGTGCCTCGATGTCGCCAACCGGATCAAC +GAGGTATCGGGCCGCCTCGGCCACTTTGTAGATCGGGTGTCCTTGGCGCTTCCCGCACGC +GCGCAGCCCTTGAATCCGTTTCGTCACGGTGCGGTTGTCCATGGTGAACAACTGCCCGAG +TTGTGAGATAGACGCGCCATCGAACAGGATTGCCTTCGATGCGCTATCCGCTCCGCTCTT +TTCTTCTGCCATGCCGGCCTCCGTTTTTGTCAGGGTTGAACGTTATCACAAGCCCGCAGC +CGTGGCAAAGTTGTCACTGTTCGCTGCTCGCTTCTTCTTGAACGCTGCTCGCAGACGGCG +AAGACGCACGAAGAGATCGTCCTGCGCGTTGCGCTTGCGAGTCAGGCTCGATACCGCAAC +GTCGTCTACCGTGCCAATCATCGTCGCATGGTGGACGCGCACTACATGGCGCTGGCCCTG +CCGGGCGAGACGACCGATGAGCTGAAGATATAGTTCGAGCGAGTAGAAGATGTCGTAGAT +ATAAAGGTGATGGCCTCCCTTCTGCATGTTCAAGCCGTGTGCCACGGACGCCGGATGAAC +GAGCAAGATTTTGATCTTGCCTTTGTTCCAGTCGCCGACAAGTTTCCCCTCGGCGTCCAT +TACGCGCGCTCTCGGGAACGCCTTCTTCAGTCGTTCGAGGCTGGATTTGAACCAGTACGC +TACGAGCAGCGGCTCGCCGTTCAGCTCTTCGACAAGTTGCGTCAGGTCTTCGATCTTGTG +ATCGTGTACCCAATGCGTCTTTTTCTCCGCGTCATACACACATCCGGACGCGAGCTGAAG +TAACTTCTGATTCAGCGCGGCTGCGGTTTCTGCTTCGATCTCGGTTCCGTCAGGAAGGTC +GAGGATGAAATCCCGCTCGAACTTCTTGTACATAGCCGACTGCTCATCGGTCATCTTGAT +GGCGCGCTTCAACAGGAGCGGCTTATCGACCTTCAGGTAGTCCTCTGCCTTCATCACTAG +GCAGATGTCAGCGATCTTCGACAGGATTTCGTTCTCGCATCCCGGCCGCAGCTTGTACGT +TCGCGAGTAATGGTTATACGTGAAGTACCGGTTGCGGTAGTACGTGATGTTGTTGCCGAG +ACGTTCTCCCTTGTCGAGAAGCCACATCTGCGCGAACAGGTGTTCATAGGTCTCGGCAGC +CGGCGTCGCGGTGAGAAGATGCAGGCGCTTGATATACGGGCGAACGGTCTTCAGCTTCTT +GAAACGGATCGAATTGTGATCCTTGAACGACGACGATTCATCGATAAACACGACATCGAA +AGGCCACATTTCCCCAAACAGGTCGATGAGCCATTCAAGCTGTTCCCGGTTGATGATGTG +AAGGCTCGCCGGGGTGCGCGCGAGGCGTTGAAGGATCTTTTCCTTCATCTCGGCTTTCGC +TCGCGCCACGTCTCGTTCAAGCTCGGGATTCCGTTGCTTGCGGCCGTCGTCGCCTCGTGT +TGTGAAGGCCCGATAGTCGGAGCGAGCGCGTTGTTTCCTGCCTGCCTCAGCGATCAGTTC +AACCGACTTCTCGTCTTCCGCGCGGATCAGGACATGGGACATGTACGCCGTGTGCTGCCA +GAGCGGAATCTCGTTCGGCCAAGTCTGCGTAGCGACACGCAGCGGCGCGATCACGAGACA +GTGCTTGTATGCGAAGCGCGAGAGTAGCCGATCGAGCAGCGTGAGGCAGATGACCGTCTT +CCCCATGCCAAGGTCGATGAACAGTGCGCTGAACGGATTCTCTTCGAGAAAGTCCACGCA +TTTGTCCTGATACGCATGCAGCTCGATCGGATCGTACTGCACTCCGTGGAACATCTCAGA +GATGGTACGACGCAAGGATTCGGATTGCATCTTCATGATTGTCAGCCCAATGAACGTACG +CGCCGTGTCGACGCATCTCGTCGTGCTTGTTGTACTGGTGTCGCTTCGGTTCTGCATCCT +TCCGCTTGAACTCGATGAAAACGACGATGCCCGACCGGATATACATTCGATCGGGCACAC +CACGCTGACCGGGAGAGACAAACTTCGCAACAAACCATCCGTTTGCCTTCGCCCAATCGT +TCGTTTGGTCCTCTATGCGCGTCTCCCGTACGGGAGGATCGGAAGTTACTTCCGATTTTT +TTGGGATCGGGAGTAACTTCACGTCAGTCCTTGCGATAGAACGCGGCCGACCATCCGGCT +GCGCCAACAGGCATCTCTTCGTACCACTTGCGCTTCGCGGTCATGCACTCCTTCAGGACA +TGCAGCCCCTTCGACGCGTCGCCGATCTTGCGCAGGGTGACGATTTCATCGTGAACGTGC +AGAACGATATTGAGGCCCTTCTTATGCGCGTTGAATAGGCCGTACTTCAGGATTTCCCGT +GCGATAGCTTGCACGAGGTTTTCAGTCATCTTACCGCCGTGCGAGTCCTGCCGCAGCCAC +TTCTTGATGTCCTGATTGAAGCCCATGTACGAGAAACCGATCTTCTCGTACGTCTGCGGC +GAGCCGTCTTCGTTCCAGAGTAACTCGCCTGTCTTCCAGTTCTTCTTCTGGAATTTTTTC +TTCTCGATGCGCGGTCGATGGTAGTACATCCGGCGACCGCTCGGCAGGATCGCCACGAGG +AATTCACCGACGATTTCAAACGACACATAACGGACGCGCGTGACCGCCTTCGTCTTGATA +GTGCGGATGATAGCGGCTTCGAGGTCCTTCCAGAGCTGCGGGACCTCGGGGTACGCCTCG +CGGTACATCTTCACCGAGTCGTGCGCCTCTTGGCGGGACATGTCGATACCCATGTTCTCC +GCGTAGCCCCACAGACCGGTTCGCTTGCCCTCATGGCTTAGGTCGCCGCCGCCGAGTCGG +TATCCCGCGCCGAGCACGGCCGGTTTCGACATCGTGCGCATCTGCGAAGTTACTTCCGGG +TACTCGACGCCGTACAGCCGCGTCGCGAATTCTCGGTACGCGCAGCGCCCTTCACGGAAC +ACGTTCAGCAGCGGCTGGCAATCCGCCAGCCATGCGATCACGACGGTTTCAATCGAGGAC +AGGTCGCATGTGACGAACTCGTACCCCTCCGGAGCGTAGATCGCGCTGCGCACGCATCCG +GCGAGACCGTCCATGGGTTCCTTCATCATCAGGCCGAGCAGGTCGTAATCCCCCGCTCGG +ATGGCGTTCGTGACCGTGCAGAGCGCCCAGTCGTTGTCGCCGTCCGGTTCGAGCGCTTTC +GGCGTACGGCCGAGGTTGTGAACCTGAACACCGCGTCCCGCCCAGCGCTGCGTGCGCTGC +GCGCCTCCGAACTGAAGGGGAAAACGGAGACGCCGGCCGGGGCCGACGAGGGAGACGAAC +TTCTTGTACTTGCCGACCGACGTGCGTGCAGACTGCATACGCATCTTCAGCACTTCGTCG +CACCGCCCCGTCAGCACCGGTTCGTCCTTGTGTTCGGCGAGGACCTTCTTGACGGTATCC +TTGCCGAGGTCATCGAAACGATACCCGCGTGCCTTCACCCATGGTTTGAGCTGCTGCGGA +CTGTTCGGGTTTTCAAGGCCGGTGATCGCGCGCATCTGCCGAACGAGTTCCAGCTTGCGG +CGATCTGCCATCGCGGTAGCGCTGTTACAGAAGTCGAGATCGACCGGCACGCCGCGATCG +TTGATGAGCTGATCCAGCTCGTACAGCTCCCATTCTTCATCGAGCGTCGGATACGGAGCG +AGCCATTCGTCAATGGCGGCTTCGGCGATCACGTCCTGTTGGTTATAGATCAGGAAGTCG +TCCCATTCGAACGGGTTGGTCTGCCAGTCGAGCCACTTGTGGGGGTTCTTCTTCGTGATG +CGTTGCGGCTTCGAGAACAGGTTGATTAGCTTCTTCCCGGTCGCCAGTTTGACCTTGTCC +TGCGGTAATCCGAGCTGCCCGCCGACCATTTCGAGGTTTCCAGCGAACGACAGCATGTAC +GCACGCGCCATCGTGCAGCGCCAGTTTTTATACGGCGTGTTGATCTTCAGCACACGACGC +GTCATCACGCGCTCGAACTGCGCATTCCACGCCCGCTTGATGACGTTCGGGTCTTCGAGC +GCCTCGCGAACTTCCGCCGGGAACTTGCCGTCTCGGATTTCCCATTGCTGCACGCGGCCG +CCGTTGAACGACCAAGAAGCCATCAGGATTTCAGTGGACTCGTGCGCCGAGTAAATGTCG +AGGCCGCACGTCGGCAGGTCCTCTTCGCTACGCGATTCGTAGTCCAGTCGAATCTCGTCT +TGCATATCAGTTCTCCGGATTCGCGAGGTCGAGCAGCACGTCGCCGTGGCACGCTTCAGG +TGCGCAGAAGCAGACGAGATTCCGACCACGGATCGTAGGCAAGAACGACATCAGCGAAGG +GGAGTTGAGGACGTGCTCTCGGTACTTCGCGATAACCTCTTCGCGCGTTCCGTCTCGGCC +GATCACAAACGGGTTGCCCCACACCGAAGGGCGGCCGATGTAAATGCAGTCGTCCGGATA +GTCGCCTGCGTTCTTGTTGAATACCTGCGGCATTTCAGCACCTCAGAAGAAAAAGACCCC +GGCACGTCGGGGAATAACCGTGCCGGGGCGAACAACCTACGCGGAGGAATCGGAACCGCG +CAGGCAGGCGAAAGGAATTACAGGCCGCCGTTGTCGTCGTAGCCCTCGGCGAGCGCTTCC +TCGCCGTCCGACACGTCGTCAAACGAATCGTCAATTTCGTCTTCGCTGATGCGGCCTTCG +CCGATCGGCTCGTCGTCACGAACGAACTGGACCGCAAGCAGGTTCGCGTTGATACGCTTG +CCGAACTTGTTGTCCTGCCACCACGGGTTGATGAGAATGTTCACGCGGCAACCGGCGTAG +ATGGTGTTTTCGATCTCGCGCTCGCCGAGAAGACGCTTGTCCGCGCCGCGCACGCTCGGA +CGCTTCGTTTCCGATGCATTGATCGTGTAGCAGCCTTCGTATTCGTCCTTGCCCGACGCG +TCGCCGTCGCGGAAGAAAAACTTGTCGGTCGGAATCTTCTTGCCGTCGTTCTTCTCGCGC +AGCATCTCGTCGCGCATTTTCTTCATCACTTCGAGAACGGACTTAGCGAGGTCCTTTTCG +ATGAAGCCGACGAGCGAATACTTCTCCTGCCCTTCCTGATCGTCGCCCTTGTAGGGCTTC +GCCAGATGGGGGTAGGACGCCCGCACATTCTCGATACGCATGGTGCCGTCCGTGAAGACG +ACAACGTTCTTGCCTTTGAACTTGATTTCGCGTGCCATTTTGCTACTCCTTCAGGTCTAC +CGTTTTACCGGTCTAGGGTTTCAGGGTCTACAGGTCTACGGGTCTACAGGCCGTCGTCCG +CAGTGAGGTCGTCAAAGCAGTCATCGGCCACTTGCCCCAGCTTCTCCCGCGTGTCTGCGA +CAGGAGCCAAGGTCGCCTTGCCCGGCGCTTTCGCGACGAGCGGGGCGATAATTTTCTCGG +CCGCTTTCTTTCGCATGCCACTCGCGACGAGCAGTTCTTCTGCTTTCGCGGGGCTGACGA +AATCGGTCGAGAATAATGCGTTTTCCTTCACGCCAAGGAATGTGAGCGTTTCAACGGCTT +TCGCCTGTTGCACGTTCCAGCGGCGATTCGATCTGGATGCTACCAGTTTCATGCCGGGGA +TGTCCTCCCCGTTGTGCGCGCGTCGCTCCAACTCGGAGTCCATTTCGCTGAACCAGCGCT +CGAATACCTTCCGGTACGGAAGTAACTTCGCCATTTGTTCAGTCGAAAGCTCGGAAACCG +GAAGTAACTTCGTGCTCAATTCGCCGCGCATCAGGACTTCCTTACTGCTCGACATCTGTT +CAGCGGTTACTTCGGCTGTCAGGTCGTCAAAGCAGTCGTCAGAAAGCCTGTGCGCCATCG +CGAGAAGCGCCGGACAGGTCTTCTGCACCTTGCAAAAACGGCATCCTTTGTCGGACGGCG +TGAGCGGCGCACCTTTCTGCCAAGCGAGAAATGCCCGGACCTTCACGAAATCGGCGAAGC +GAAGCAGCTCTTCCCGTGTGGTTTCCCACGTCTGGAAGTGTGCTAGGCGCGGTTGCGAGA +TGTAGATGACGATCTTACGGAATCCGTAAATCCAGTCGTACTCGTAGAGCGCGCCGAGCG +CATAGAGCATGGCTTGAGAATTGCCGTTGATAATCGTCTTGCCGTTCTCAACGATGATCG +AACGCGGATCGTCCAGTCGCAACGCCGCGAAGACCTGAACACCACGGCCGAACTTGTGGT +CGAAGATGTGCATCACACCGGGTTCGAAGCCGCCCACGTCCATCGTGCCTCCTTGGCGCG +GAATCGGGGTGAGCTGGGAGAAGTAGACGCGCTTCTCGATATGCAGGTCGCCGGGAAGCG +ACTGCGCCCATTCGACAGACTGCGCGACGTACTCCATCATCTCCGCGTCGATCGTGATAT +CGAAAACGGTCTTCCCTTCGGCGACCTGCTCGACCGTGCCGAGCAGATGATCGGGGCGTA +TGCCGGTCTTCAACCACGTCTCGGATACGCCGTGCGCGACAGTGCCGTATGCGGCGTCTT +CGCCTGCGTTGTCTTCTGCTGCGAGATTGGCGAGAAGGGACCCGGCGCATGTGAGCCACA +TGGCAGACGCACTCGGGGAAAATACCGAGTGGCCGCCTTGCTCGATGTTGAACTTCAGCG +CATCGAGATTGATCGCGTGTTCGCTCACGTAGAGGCCCCGGAAAAGTTGTTCATTTTGAG +CGGCACTGACATTGTGTGGTGCACCGTAGAGGCCGGGAACGCTTGCCGGTGCACCCGCCA +GTGCCGCTCAAAATGAAGCCCGGACGAACCGGGCTTCTTCGCTGCACGTCGAGACGATAT +TACAGGCCGTCGCTGCCGTCGCCTTCGTCGCCGCCCGCGTCTTCTTCGAGCGCCTTCTCG +GCCGCGTCGTACGTGGCGTCGAAGTGTTCCGGCTTGATCGAGGCCGAGGTCTTCGGCCTT +GCCGTACTTCTTGATGATCGCCTTCGCGTCGTCCATCGACTTTTCGTCCTTGACGCGGAT +CAGGATCGCCTTGACCTCGTCGGCCGAGTGCTTCGGCTTCGTTGCTGCCTTGCCGCCGCC +CTTGCCGGCCGCCGTGGTCGTTGCCTTCGTGCCTTCGGCCGCCTTGCCGCCGCCCGTACC +GCCTGCTTCCGCGATTGCCTCCGTGACTGCCGACTTGATGAATTCCTTCAGGGCGTTTTC +GAAGCTCATTTTTCCGACTCCTAGTGATCCGTAGATGGGTTGTTTGTGTCGTGGCGTTCA +CCACGGAACGAATCATGCCGGGGCCGGTTTTGTCTGTCAACACCTTTTCGAAAATATTTC +AAAGACAAATGGGAATCTGGCATACTCCGCGCTGTATCAACCTTCATCTACCTACATAAG +AGGACTAGAAACATGGTAATCCCTATGCCCGCATGGTTCGATGCGCTGTCGCCGGAAGAG +CAGGAAACCGAGCGCACGAAACTGGTCCTGAAGCTCGCCGCGATCTACGCTTCCCGCGAG +CAAACTGTTCAACGTTTGTCCGAGCTGGTGGGCTACTCGTCCAATACGCTCGGCGCTCTG +TCGTCTACCGGCCGCGCGTTGCGCCCGGAACTCTGCATCGAGATCGAGAAGGCGGTCGGG +CACGAGTATTTGCCGCGACGCTTGCTCAACCCGCATATCTTCGAAGTGCCGACCGCAGGA +GAGTAACGAGATGGCCGACCAGACCACGGCCACCTATCTTGCGGATCACGGGGATGCACT +GATCGCGAACGGGTACAACATTGTCCCCATCACACCCGGCGAAAAATTCCCACCGCACGA +CGGCTGGCAGCAGACAGTAGCAACGCAGGCGAAGTTGAAGACGTGGCTCGCCACGGGTTT +GAAGTACACGAAGAACGGCGAAGATCGGGTCGCCGATGTGAAGCTGGCCGGCGTCGGCTT +CCTGACGAAGAACACGCCGGGCGTCGATATCGACATCTCGGACGAAGGCTTCGCGAAGCA +CATGGAGAATTTCGTCCATGAGAACTTCGGGATGGCTCCTGTACGCGTCGGCCGCGCGCC +GCGCCGGCTACTGCTCTTCCGATGCACCGAGCCGTTTTCGAAGGTCAATTCGAGCGTCTA +TCTGGACGAGTGGGGCGAAGCGCAGAAGGTCGAAATCCTCGCGAACGGCCAGCAGTTCGT +CGCGTTCCACATCCATCCGGACACGAAGCGGCCGTACGAGTGGCTCTACAAGCAGTCGCC +GCTCGACATCGAAGCATCCGAGTTGCCGGTGTTGCGCCGCGTCGATGCGCAGGCCATCGT +GGACGAGTTCGAGAAGCAGGCCAAGCTTCGAGGCTGGACGCTGAAGAAGCGCTCGCGCAC +CGCGCCGGAACGCAGCGAGAGCGGCGGGGAGATCGATTACGACGACCCGTTCGCCGCCGA +CGTAGCGAAGACCGATATCGGCGAAGACGAGCTGCACGCCAAACTCCTGCTCGTGCCGGA +CGCCGATGATTACGAGACGTGGGTCAACGTCGGCATGGCGCTGTTTCACCAGTACGACGG +CCACGAGCGCGGCCTCGAACTCTGGCACGAGTGGTCGGAGACGGCCGACAACTACGACGC +GAAGGAGCTGGACGCGAAGTGGAAGTCATTCGACATCAGCAACAAGTCGCGTACGCCAAT +TACCGCCCGGTACATCATCAAGCTGGCGAAGGAAGCCGCCGAAAAAACCGCCGAAGAAAC +GATGGTCGCGCTGCAAAAGCTGCTGCTCGAAGCCACGTCGATGAACATGCTGAACTCGGC +ATGCAAGGCGATCAAGAAGGCGACGCTCGACAAGCCGTCGCGCGAGCTGATGGTCACATT +CGTACGGCAGGCGTTCAAGCGAATCAACGACGGCTCGCCCCTTCCGCTCAACGCTGCTCG +GCAGATGATTCGGTTCGAGAACCCGGAATCGAAGCACATGCCGAAATGGTTGATGGGCTG +GACGTACCTGACGCTCGATGACAAGTTCTACAACGTGAACACGCAGGAGTACATGACGCG +AAGCGCCTTTAATTCGGCGTTCGAACGTTTCCTGCTCACGCCACAGGACGTGTTGGAAGG +CCGCGTCGTCCCGGACACGACCGCCGAGAAGCTGGCGCTCAACCGTCATCAGATTCCGGT +ATGCCGCACGCGGCTATACCTGCCCGAACAGGACGAGACGTTCATCATGAACGGAGCGCG +CTACGCGAATCTGTACACGGACAAGTCGGTCCCGGAGTGTCCGTCAAAGCTGACGAGCGA +AGACAAGCTGAACGTGAAGCGCATCCTCGACCACTTCAACATGATGATCCCCGCTGACCG +CGAGCGCGGCATCTTCATCGACTGGCTGGCATGGATCATCCAGACGCAGAAGCGGCCGAA +TTGGGCGATCGTGTTGCAGGGTACGGAGTCGGACGGCAAGACGTTCTTCAGCGACATGAT +GGGCGTCATCCTCGGTCCGGAGAATGTCAAGACACTGAACGCCAAGACGCTCGAAGGGGC +GTTCAACGGCTGGGCTGAAGGATCGCTCCTGAACTGCGTCGAGGAAATCAAGCTGCACGG +CCACAATCGCTTCGACGTGCTCAACCAAATCAAGCCGCTCATCACGAACACGGCCATTGA +AATCCACCGCAAGGGGGTAGACCCGTACAACACGATAAACACCGCCGCATACCTGCTGCT +GACGAACTTCAAAGACGCGCTGCCGCTCGTGCGGAACGACACGCGCTACTTCGTCATGTT +CGGCCGCATGCAAAACCGCGAAGATGTCGAGAAGTTCAAGGATGAGAACCCGCACTACTA +CGGCAACCTGTTTCAGGCTCTCAACGAGTCCGCCGGGGCACTGCGGAAATTTTTCCTTGA +ACACGAGGTGAGTGACACCTTCGACCCGATGAACCGTGCGCCGGATTCCACGGCACGCCG +CTATATGATCGCCATGAACCGCTCAAACGAACTGGAAGCCATCGAGACACTGATCTCGGA +ATCGATGGAGATCGACGTTTCCTCGACGCTCCTGAACGCCAGCAAGCTGCCGGACCTGAT +GGTTGGCATGGATTGCGAACTCCCGCAAACGAAGGGCTTGCAACGCGTCCTAAGCGACGC +CGGATTTACCTTCCTCGGACGCATTCGAATCAACGGGGAGTACTCCCGATACTGGTCCAA +ATCGCCGCAATACTTCATGGTGGACGGGTCGTCCGAGATCGATTTCGACGCTGTTCGGCA +GTACGCCGGGTGCGGTTTGTAGCCGAGGTCCAGATCCGAATCATTTTTGACTTATTCGGA +CCTTGGCCGTTTTCAGCCCCTTCGGGGGCTTTTTTGCGACTGTTGACCTTATCAGAAAAG +GGTCATTTTTCATAATGCGGTAAAAAACGCGGTCCGAATGACGCCAAAAACATTCGGACC +TTCGATTCGGACCACGACCATTAGAACCCCGGCTCCGCCTTGTCCTATAAGGCTTCCCTT +CCTTCTCTTCTTCTACTATTCTATAGATAAGGTCCAAATAAAGAAGAAAGTAGAATGACC +GTATAGACATAAATCCAAAAAAATTTTCGTACAGAAATAGAATAGAGAAAACGATTCGGT +TCGGCCCTTCGGACCTGCACTTGGCCGGCCATTCTCGTCCTCCCGACCACTCAAGGTCCG +AATGGGTGGTTTCCCCTCCGCCCCGCCAAGGTCCAAATCCCCTATCCCGCGATTCGGTTC +CGATCTCGTTCGGGATATCTGCGTTGCGCAACTCGAAATCGGAAGTAACTTCGGACAAAC +CGTTGTCGCGCAAATCTTTTCGCGAGAACTTCGGGGAAGGGCAGCGGCGCTATGACGGAA +AAACGAAAAAACGGGAAATCGGGGCTCTGCGCCCT diff --git a/example/fna/NC_010807.alt1.fna b/example/fna/NC_010807.alt1.fna new file mode 100644 index 0000000..e89c8a0 --- /dev/null +++ b/example/fna/NC_010807.alt1.fna @@ -0,0 +1,648 @@ +>NC_010807.alt1 length=38815 tani=99.753 alt=sn;inv;tl +TCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAACCCACCTAAAGCCAG +CCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAACACTAAAGGGAA +TAAGGGATACTTAAAGGGGGGAATTAGGGATTTAATAAAAGATTAAAATTAATGGTTGAC +TTTAAGTAACCCTTAAGGCTATTATTCATCACGTCAACGGGACAACGGCCTTAAAGCCAC +TCCCTGAGATACCGGAGTCAACCGGATAAGTAGACAGCCTGATAAGTCATACGAAAAACA +GGCATTGACAACGCAAGGTAACAAGTAGTAAGATGCACAACATAGCGTCAACCACCAAAT +CGGTGTCTTCTAGGTGACTTAAGCGCACCACGGCACATAAAGCTAAACAAAATGGTTGAC +AACATGAAGTAAACACGGTACGATGTACCACGAAATGACGGAACAGTGAGGCGGGACACT +GAAAGCCGCTAGGGTCTAACGAAACCAGACCGACACGCAAATCATAGTAGGTTTAATAAG +CGGTAAGTGTATTACTTCCCTTGTGTGCCGCCGAATACACGAACTAACATGAGGTAACAC +CAAATGATTTTCACTAAAGAGCCTGCTAACGTCTTCTATGTACTGGTGTCAGCTTTCCGT +TCTAACCTTGATGATGAGGTGAACATGAGCCGCCACCGCCACATGGTAAGCACTTTACGT +GCCGCACCGGGTCTTTATGGCTCCGTTGAGTCAACCGATTTGACCGGGTGCTATCGTGAG +GAAATCGCAAGCGCACCGACTGAGGAAAAAACGGTTCTTGTACGCTGCAAGGACAAGGCG +CAGGCGCTGAATGTTGCACGCTTAGCTTGCAATGAGTGGGAGCAAGATTGCGTACTGGTA +TACAAATCACAGACTCACACTGCTGGTCTGGTGTACGCTAAAGGAATCGACGGTTACAAG +GCTGAACGTCTGCCGGGTAGCTTCCAAGAAGTACCCAAAGGCGCACCGCTGCAAGGCTGC +TTTACGATTGACGAGTTCGGTCGCCGCTGGCAGGTGGCCTAACATGAATCGTTATTACAT +CAACGTACCGGGCTGGGGTGGGTCTCTGACCTGCTACGGATACAACGAACGGGACGCACG +GAAACGCTTTAGAGAACAACACGGCTTCGGAAGGCTTGCTAATGGGACGCGCCTATGGCT +GGACGCCCGTGATTGGTAAGTGATAGACTCAAGGTCGCACTGTATGTGTGGCCTTTATGA +TTATCACTTATAGGACTAACACCATGAGTAAACTTCTGGCAACATCTAAAATAGAAGGCC +AATGCACCGTAACACTGCGTGAGTATTACCACGGGTCAATGGGAAGCACCTATGTTGTGC +GATACGGTAAACAGGTCACACATCGGGTAAACCCGATTTTAGCACAAGAGGATTATCAAG +CCTGTGTGATACACCAAGCAACATGTGCGGGCTGGAATGATTGACATTACAGGAGGATTA +GGAATGGTTATCTTTATCGCTGTCGCATTCTTTGCGGTCGCTGGCTGGTACTCTGAGTCA +CGCAAGGCCGCTCGCTATCATCGCAAGATGGTTAAACTCATGGAACACTTGGACGCAGAA +GGGCGAGGCCGCGAGGCTATCGAACTGGTGAAACACGCATGATGATTCTCTCTATCGCAC +TGGTCTATCTGTGCATCGCAATGTACTTTATGCGAGACTTTAAGCGCGGTCTGGCAATAC +ACAAGGCAACGCTGAGTTACTTTAAGCGCGGTCTGGCAATACACAAGGCAACGCTGAGTT +ACTTTAAGTGGGGATTCATCCCACGGTTTACGGTTCGTGAACGCAACGGACGCTTTAAGG +CCAACAAGGTAGGAGTATTCTACATTGCTACGCACTAACTCAAAGCACGTAAAGACCGCA +CTGTATGCGATGGGGTATGGTGCATCGAAACGCAAGGTCAAACGCATCTTAACGAGACAC +CGCAAGATGACCGCACGACAGGCTGCAAGCGCTGTCAAATGGGCTGAATTTACTCTTTAC +TCTTCTTACAGATAACAGGACACTGAACGATGACTTTCACCGAAGCACAAGCCGCACTCG +ATGCTATCCGCAACCTACCGATTGAGCGCCTGAACGAACGCCAGCCCATGCTGGTGGCTC +TTGCGGCTGCTATCGTGAACGCTGAGACCCAAGACGGCGAACTGACGCAGGCCAAGGGTA +ATTGGGGTCTGGAGTCTATGGACTACTGGCAGACACTGGCTGAGCGTATGCGTGATGTTG +GATTTGTACGCTTGGGCAACGGTCACTTTAGCGCAGCATATGAGCACGCATTGTTACCGG +GCAAGGTTATCAAGGTAGGCTTTAAGAAAGAGGATTCAGGCGCTGCCTATGCCGCATTCT +GCCGTATGAATCAGGGTCGTGAGGGCATCCCTACGGTGTACGACATTCAGCGTCATACAG +GCTGCTACACGGTGGTCTTGGACTATCTGACACCGCTTAATGACTGGTGCTACGGTGAAA +GTGATAAGATTCGTCACCACTTTCAGGCTGCACAGGAAATCATTCAGGAGGATTGCTTCG +ATACCGCCGAAGAGTACCCGATAAGCGAGGGCTTCATTGAGACCTGCATGAGAGCGCAGG +AAGCGATTGACCGCTGTAAGGCACGCAAGGCACGCCGTGACCCTAAAGGAGACTTTCAGG +TAGCACGTAAAGCCCGTGCCAAGTGGCGCAGAAAGGCCTCTAAGCGCGAGAAGCGCAACG +CTAAGGTGCTCGCTAAGATGCGCATGGATGCTAATCAGAATCGCAGGGATGAGCCTAGGG +CGCGTATGGTGTGGGGCGATAAGCACTGGCGCAACGCTTGGATGCACCACAATAACCTAA +ACTTTGCAGAACTGGAGCGCCGCGCTGCTGCGGCAATGATGATGCATGACGAGGTGCGCA +TTCAGTGGGGCAAACCGTTACACATAGACGCATACCTTGACAAGCGTCTACAAGGCTGAT +AGAGTCTTATCTTACAGGTCATCAATCGGTGGCCTGAATAGGTACGATTTATTCACAATG +AGGTAAGCAATGAACATCATCGAAAACATCGAAAAGAATGACTTCTCCGAAATCGAACTG +GCTGCTATCCCGTTCAACACACTGGCAGACCACTACGGCAGCGCATTGGCTCGTGAACAA +CTGGCTTTAGAGCATGAGTCTTATGAGCTAGGCGAGCGCCGCTTCCTCAAGATGCTTGAG +CGTCAAGCGAAAGCTGGTGAGATTGCAGACAACGCAGCCGCTAAGCCATTACTCGCTACG +CTTCTCCCTAAGTTAACCGCACGCATCGTTGAGTGGCTCGAAGAGTACGCCTCGAAGAAA +GGCCGCAAGCCAGTAGCCTATGCACCGCTCCAGTTACTCAAGCCGGAAGCCTCCGCGTTT +ATCACACTCAAGGTCATCCTTGCGTCACTGACCAGCACGAACATGACAACCATTCAGGCC +GCTGCTGGTATGCTGGGGAAGGCCATTGAGGATGAGGCACGTTTCGGTCGCATCCGTGAC +CTCGAAGCGAAGCACTTCAAGAAGCACGTTGAGGAACAGCTTAACAAGCGCCACGGGCAA +GTCTACAAGAAAGCCTTTATGCAGGTGGTCGAGGCCGATATGATTGGTCGCGGGCTGCTG +GGAGGTGAGGCGTGGTCTAGCTGGGATAAAGAAACCACGATGCACGTAGGGATTCGCCTG +ATTGAAATGCTGATTGAATCCACAGGTCTGGTGGAATTACAGCGCCACAACGCAGGTAAC +GCAGGCTCTGACCATGAGGCACTGCATCTGGCCCAAGAGTACGTGGACGTATTAGCGAAG +CGTGCAGGCGCTCTGGCGGGTATCTCTCCGATGTTCCAGCCGTGTGTCGTACCGCCGAAA +CCTTGGGTAGCAATCACCGGGGGCGGCTATTGGGCTAACGGTCGCAGACCTTTGGCACTC +GTCCGCACTCACTCTAAGAAGGGACTGATGCGCTATGAGGATGTTTACATGCCAGAAGTT +TACAAGGCGGTCAACATCGCACAGAACACCGCATGGAAAATCAACAAGAAAGTTCTTGCG +GTTGTCAATGAAATTGTTAACTGGAAGAATTGCCCGGTCGCAGACATTCCATCGCTGGAG +CGCCAAGAGTTACCGCCTAAGCCGGACGACATTGACACCAACGAGGCAGCACTCAAGGAG +TGGAAGAAGGCCGCCGCTGGTGTCTACCGCTTGGACAAGGCACGAGTGTCTCGCCGTATC +AGCTTAGAGTTCATGCTGGAGCAGGCCAACAAGTTCGCAAGCAAGAAAGCAATCTGGTTC +CCTTACAACATGGACTGGCGTGGTCGTGTGTACGCTGTGCCGATGTTCAACCCGCAAGGA +AACGACATGACCAAGGGGCTGCTGACCCTCGCTAAAGGCAAGCCAATCGGTGAGGAAGGT +TTCTACTGGCTGAAAATCCACGGTGCGAACTGTGCGGGTGTCGATAAGGTTCCTTTCCCT +GAGCGCATCGCGTTCATTGAGAAGCACGTAGACGACATTCTGGCTTGCGCTAAAGACCCA +ATCAATAACACTTGGTGGGCTGAGCAGGATTCACCGTTCTGTTTCCTCGCGTTTTGCTTC +GAGTATGCAGGCGTTGCGCACCACGGTCTGAGCTACAATTGCTCTCTGCCGCTGGCGTTC +GATGGGTCTTGCTCCGGTATCCAGCACTTCTCCGCGATGCTCCGCGATGAGGTAGGCGGT +CGTGCGGTTAACCTGCTGCCAAGCGAAACCGTGCAGGACATTTACGGCATCGTTGCACAG +AAAGTAAACGAGATTCTCAAACAGGATGCAATAAACGGCACACCTAATGAGATGATTACC +GTGACCGACAAGGACACCGGGGAAATCTCTGAGAAGCTCAAGCTGGGAACCTCAACGCTG +GCGTAACAGTGGCTGGCATATGGTGTAACCCGTAGCGTAACTAAACGTTCGGTCACGACG +CTGGCTTTCGGTTCCAAGGAGTTCGGCTTTCGTCAACAGGTACTGGACGACACCATTGAG +CCTGCGATTGACAGCGGTAAGGGCTTGATGTTCACCCAACCTAACCAAGCGGCTGGTTAT +ATGGCTAAGCTGATTTGGGACGCGGTGAGCGTGACCGTAGTCGCAGCGGTTGAGGCGATG +AACTGGCTCAAGTCTGCCGCTAAGCTGCTAGCTGCTGAGGTAATCATATCGAGACGCTTC +TGGAGTGGCTTGCGGTATTCCTGCCAGACCGGGAATCCGTCCGGCGTAGTCCAGTGAACC +GCACAACGGTGGCGAAGAATCTCCTTGGTCTTCTTGTCCTTGTTCTTAGGGCAATTCCGT +CTGCAACCGACGATTAATACCCTCAAGGATTCAGGCATTGACGCACACAAGCAGGAGTCT +GGCATCGCTCCTAACTTTGTTCACTCACAGGATGGTAGCCACCTCCGCATGACGGTCGTT +TATGCTCACGAGAAGTATGGCATTGAGTCCTTTGCGCTAATCCATGACAGCTTTGGGACT +ATTCCGGCAGACGCTGGTAAGCTCTTTAAGGCTGTGCGTGAAACGATGGTTCTCACCTAC +GAGAACAACGATGTGTTGGCAGACTTCTACGACCAGTTTGCAGACCAGCTTCATGAGACC +CAACTGGACAAGATGCCACCACTTCCGAAGAAAGGTAAGCTGAACCTACAAGACATTCTC +AAGTCCGACTTTGCCTTTGCATAACAAGCACTTAGCATTAACCCTCACTAACGGGAGACT +ACTTAAGGTCTCCCTTAAGGTACTAAGAGATTTTAATTTAAGATAACTAAGAGGTTTACT +TTATGATTACTTTATGTGTCGCAATCGTTCTTATCGCTACACTCTCAATCGTCATCGCTA +AGCAGCGCTCTGAGTTAATCAAGCTGGATGCCCGATATGATAGTGCGAACCACCACCGGA +AAGAACTGGATGCAGCACTTGGGCGGTCAACCGATGAGGTTAAGACCCTTAAGCGCCAGC +TACAGCACGCCGAGCAAGACGATAAGAACCGCTGCGAAACAATCCGAGGTCTACGTGAAG +AACTCCGGGAGTTGCGCCAGACGATTAAAGAGCGCCACGCTATCCACGGCATCAAGTTCG +TAGCGAACGTTCCGATGAAGGGCTGGACGCCCACCGAGTTTAAGCTGGGTCTTGGTAAGT +GCGGTCTGGAAGTGGCGAGTCTAGTGTGGGAAGAGAAGTCTGACCGCTATGTGTTGACTC +AACGCCGCACCGACGGAAGCCGAAAGTTCTTTGAGTACAAGAAGGAAGACGTGCAAGGAA +GAATCGAAGTGTTCTACCCTGCCGTTAAATAACCCTCACTAACGGGAGAGTTAGCCTCAA +GGTCATCACCGACGGTGGCCTTTGTGATTAACTTTCAATACACATCAACATGAGGTAAGA +TACTATGCGTACCAACTTTGAGGAATTTACCAAGCGCGATTCTGTGGTCAACGAGCATGG +CGAACAGTGGCAAGAGCGCCGTGACCGCATGAAGAAACGCCACAAGCAACAGCGCGGTAA +CTCACAGAAACGGGAGTGGAACTAATGATGATGGGACGTATCTATAGCGGCAACCTGAAC +GATTACAAAGATGCGGTAGCGCGTCTACAGGAAGACCATGACGTGACCGTGAAGGTGGAG +TCATTCAGCTATGAAAACCCAGCGAAGATGTGCAGGTCATCCTGTGAGGTTCTCCGTGTG +TTCACACGCTCCGGGCATCCGGTGGCATCCAGAACCTTCGAGCACAGCGACAGTGATGTA +CAAATTAACGCGAAAGGCCACCAATTAAGATGACCTTGAGGATTCTCCTGTTAGTGAGGG +TTATTACTTCCAGTGTTTCAAATCGCTGTGAACCTTACGGAGCCATGCAGTCTGGTGATT +CGAACTGATTAACTTTCAACCAATGAGGAACAACCGTATGAACATCTTCAAGACCAACCC +ATTCAAAGCTGTGTCATTCGTAGAGTCTGCCGTTAAGAAAGCGCTGGAGACCTCCGGCTA +CCTGATTGCGGACATTAAGTATGATGGCGTGCGTGGTAACATTGTGGTTGACAACGTGGC +TGAGGCCGCATGGCTGTCCCGTGTGTCCAAGTTCATCCCGGCGCTGGAACATCTGAACGG +TTTCGATAAGCGCTGGCAACAACTGATGAATGATGACCGCTGTATTTTCCCTGATGGCTT +CATGCTGGATGGCGAACTGATGGTTAAGGGCGTAGACTTCAACACACGGTCTGGCCTACT +GAGAACCAAGTGGCTCAAGAAGAACAACTTCGTGTGTGACCGTGGTGGTGTTGAGCCACT +GAAAGGTTCCAAAGTAGCCTTTGAGTTAGACCCCAAGCTACTCAGTGTTCGCCTGTATGC +TGTCCTTCCGATTCACATTGCGGAGTCTGGCGAGGACTACGATGTACAGAAGCTACTGAT +GCCATATCATGTGGAAGCCATGCGCTCTCTTCTGGTTGAATACTTCCCGGAAATCGAGTG +GCTTATCGCTGAGACCTACGAGGTCTACGATATGGATTCGCTGACTGAACTGTACGAAGA +GAAGCGTGCCGAAGGTCACGAGGGTCTCATTGTGAAAGACCCACAGGGCATCTACAAGCG +AGGCAAGAAGTCTGGCTGGTGGAAGCTCAAGCCTGAGTGTGAGGCTGATGGTATCATTCA +GGGTGTCAATTGGGGAACCGAAGGTTTAGCCAACGAGGGCAAAGTGATAGGCTTTAGTGT +GCTTCTTGAGACTGGTCGTTTAGTAGACGCCAACAACATCTCTCGCGCACTGATGGACGA +GTTCACAGCCAACGTTAAGGCACACGGTGAAGACTTCTACAACGGGTGGGCCAGTCAGGT +CAACTACATGGAAGAGACCCCGGACGGCTCCCTGCGTCACCCTAGCTTCGAAAAGTTCCG +AGGCACTGAGGACAACCCTCAAGAGAAAATGTAACCAACTCACTGGCTCACCTTCACGGG +TGGGCCTTTCTTCGTTCTAGGGAATTAACCCTCACTAACAGGAGACACACCATGTGGCTT +ATCCTATTCGCTATCGTCGCAACGCTGGGATTAATGGTTGCCGACGACGACATTTGGCCT +GATTGTTAAGGAGACAACATCATGCGTTTACACTTCAACACATCAAATGGTATCTTTTCG +GTTCGCCGTGAAGACCGCTCTACAGCAGTGGCCTTTGAGCGCAACGCTAAGCTGCCGCTG +ATTGGCTCGGTCGTCCCATTGTCGCCTCGTGTTCACCTACTGATCACTCGTGGAGATTTC +ATTAAGGCGATGAACAAAGAGCGCCCGCATCTGGAAGCCGTGGTCACTTACTGGCCTCGC +ATCCGTCTGTTCGTTAAGTGGATTAAGGAGGTTCTGTAATGTTACAACATCATTGGAACA +AACCAGATTTAGAGGCTCGCTTCCCGGTTAACTCTGCTGTGCGATACTCCGGCGACTTCC +TCAAGCGCTTCTTAGGTATGAGCGGAGTGGTCACTGGTCACTCGAACACAGGTCGCGTTA +AGGTTCGCTTCGGTAATCTGCACGCTGAGTTTCTTCCGAACAACCTGATTCCGCTGCCTA +AAGATGACGTTAAGACTCCGAACGTGGAAGCACCGAAGTCAGAAGTCAAGTCTGACGTAA +CCCACCCTAACCACTACATGCTGTTCGACAACGTGGAAGCCATTGAGGTTATAGCCCGGT +CAATGACCGTCGAGGCGTTCCGTGGGTACTGCCTTGAGAACATCCTGAAATACCGTCTTC +GTGCTGGTAAGAAATCCGAACTGGCAACTATGGAGAAAGACCTCAATAAAGCTGCATTCA +ATCAGGAACTCTTTGACAAACATAAGGGGCTGTGCTATGACGCTTCGTGAATGCTGCGAT +TGGTGTGCCGCTAAGTGGAACCAAGCTATTGAGGATGGTGACAAGGCGGCTGCTGACGCT +TACCAACAACTGTACGCGCTGTGGGAGCGGCGCCTTAAGGAGGCTCAAAGTGGAGCAACG +TGAACAGAAATACCTTCTGACGATAGAAGGCAACACCGAGTCCTTTGAGGTTCCGGTATT +CGCCCGGTCTCTCGAAGAGGCAACGCTACAGGCTGAACATTATGAGGACGCTGGGTTCGT +AGTGACTCGCATCCGTCCAGAAGTGAAAGCCTAATTACCCTCACTAAAGGGAACAACCAA +ATCATTAACCACAAAGGAGAAACATTATGGCTGGTTTCAAGAAGAAAATCTACACCTCTG +GTCTTGGCACTGCTGAGCCTTATGCTTACCTGAGTAAGCCGGATTATGGCAACGAAGAGC +GTGGCTTCGGCAACCCTCGTGGTGTCTATAAGGTAGACCTGACTCTTTCCAATAAAGACC +CGCGCTGTCAAGCGATGGTCGATGAAATCGTGAAGACTCACGAAGAGGCTTATGCTGCTG +CCGTGGAAGAGTTCGAAGCTAACCCGCCGCAGGTACAGCGTGGTAAGAAACCACTGAAAC +CTTACGAGGGCGACATGCCGTTCTTCGATAACGGTGACGGTACGACTACCTTCAAGTTCA +AATGCTATGCGTCTTTCCAAGATAAGAAGACCAAAGAGACCAAGCACATCAATCTGGTCG +TGGTCGATAGCAAAGGTAAGAAGATTCAGGAAGTGCCGATTATCGGTGGCGGCTCCAAGC +TGAAAGTGAAATACTCTCTGGTTCCTTACAAGTGGAACACCGCTGTGGGCGCAAGCGTCA +AGCTGCAACTGGAGTCCGTGATGCTGGACGAACTGGCTACCTTCGGCGGTGGCGGTGAAG +ATGAGTGGGCTGATGAAGTCGAAGATGGTGGTTACACTGCGAGTGAATCCCGTCAGTCCC +GCGATGAGCAGTAGTGGCAGGAAGACGAGCACGGAGAAACCCCGGATGATAACGAGGACT +TCTAATGGCTGGCGCATACGCTGCGCGAGGTGTACGCAAGGTCGGGGCTTTCCGCTCCGG +CCTAGAAGATAAAGTCTCAAAGCAGCTTGAGAGTAAGGGAATTAAGTTCGACTATGAGCT +TTGGCGTATCCCTTACGTCATCCCGGCGAGTGACCACTTATACACTCCAGACTTCCTGCT +ACCTAATGGCATATTGATTGAGACCAAAGGGCTGTGGGATTCCGATGACCGCAAGAAACA +CCTTTTGATTCGTGAGCAACACCCTGAACTGGATATTCGCTTGGTCTTCTCAAGCAGCCG +CTCAAAGCTCTACAAAGGTAGCCCAAAAAGGAGTAAAGAAAAATGTCTAAAGTTCAATTC +AAACCACGAGAAACCACGGAGGCAATCTTTGTACATTGCTCAGCAACCAAGCCAAGCCAG +AACATTGGCGTTCGTGAGATTCGTCAGTGGCACAAAGAGCAGGGCTGGTTAGACGTAGGA +TATCACTTCATCATCAAGCGTGATGGCACTGTGGAAGCAGGCCGCGATGAACTGGCTGTA +GGTTCCCACGTGAAAGGTTACAACCACAACTCCGTAGGCGTATGCCTCGTGGGTGGGATT +GATGATAAAGGCAAGTTCGACGCCAACTTTACACCTGCGCAAATGCAAGCGCTGCGTAGT +CTGCTGGTCACGCTGCTGGCGAAGTATGAGGGTTCAGTCCTTCGTGCTCACCATGACGTT +GCATCCAAAGCCTGCCCGTCCTTCGACTTGAAGCGCTGGTGGGAGAAGAACGAACTGGTT +ACATCTGACCGAGGGTGATACCATGAGGATGATTTGTATTCGCTGTGATAAGCCGTTGAA +GAGTCGTGTACCGTCACGTCAGTGTCAGTGCAAAGACCCAATCAAGGCGGAGGAACACAC +CGAGGAATAATTAACACTCACTAAAGGGAGACTTAACGGTTTCCCTTTGTTCGCACTATT +GATTAAGGAATGTACAATGGAACGAGAAGACGATAGTATCTTTCTGTTTCATGCTCCATG +TGAAAACTGTGGGTCTTCTGATGGTAACTCTGTGTACTCTGACGGGCATGAATGGTGCTT +CGTGTGTGAACATCGAGTACCCGCAAACGAAGAGCGTGAAGCAAAGTTATCAACGAGAAG +ACGTACAGGAGGCAGCAAGCCTATGAGCTATGACGTATGGAATTTCGGTGACAGCAACGG +TCGATACTCTGACCTGACTGCCCGTGGCATCTCGAAGGAGACATGCCAAAAGGCTGGCTA +CTGGCTGGCGAAAGTGGACAACCGAATGTATCAGGTTGCCTACTACCGAGACCAGAACGG +CTCCATCGTGTCGCAGAAGATGCGCGATAAGGACAAGAACTTTAAGACCACCGGAAGCCA +CAAGAGCGATGCGCTGTTCTTGAAGCACCTCTGGTCTGGCGGTAAGAAAATTGTGGTCAC +TGAGGGCGAAATTGATGCGCTCACTGTGATAGGATATCCGCAAGTTCTTCTTAGGCATCG +CATCGTTCGATTGTCACAGCGGGAACATGATGAAAGACCAGATGGGACGCCTGATTATCA +CAGACCCGGTATCATTCAGCGCAGACGACAAGTTAAAGCCGGGTGAGTTCCACTGTGACC +CGGATGAACTCATCGCTGAGATTGAGGCGCGGAACTCCAAGACTGTAAGTACCCGGTCGT +ATCATTAGGTCACGGTGCCTCTGCTGCTAAGAAGACATGCGCCGCTAACTATGAATACTT +TGACCAGTTCGAGCAGATTATCTTGATGTTCGACATGGATGACGCAGGCCGTAAGGCAGT +CGAAGAGGCCGCACAGGTTCTCCCGGCTGGTAAGGTTCGTGTTGCCGTGTTGCCGTGTAA +GGACGCCAACGAGTGTCACATCATGGGTGAAGACAAAGCAATCTTGGAGCAAATCTGGAA +CGCGAACCCTTGGGTGCCTGACGGTGTTGTTTCTGCGTTGTCACTCAAAGACCGCGTTAA +GGAAGCTATGACCTCCGAGGACGCTGTAGGTTTATTATTCGATGGCTGTCAAGGCCTGAA +CGATAGAACCTTGGGTGCTCGTGGTGGCGAAGTCGTTATGGTCACTTCCGGTTCCGGTAT +GGGTAAGTCAACGTTCGTTCGTCAACAGGCTCTGGCTTGGGGCAAGCGAATGGGTAAACG +TGTGGGCCTAGCGATGTTGGAGGAATCCGTTGAGGATACCATTCAGGACATGATGGGCTT +GAACAATAAGGTTCGTCTGCGTCAGTCTGATGAAGTCAAGAAGGCTATCGCAGAGGACGG +ACGTTTCGATGAATGGTATGATGAACTATTTGGAGACGATACGTTCCACCTTTATGACTC +CTTTGCGGAGGCCGAAGCTGACAGGCTGTTAGCGAAGCTGGCCTACATGCGAACAGGCTT +AGGGTGTGATGTTATAGTGCTCGACCACATATCAATCGTCGTGTCTGCCTCTGAGGAATC +GGATGAGCGTAAGATGATTGACCGCCTCATGACGAAGCTCAAAGGGTTCGCTAAGTCAAC +TGGTGTTGTGCTCGTAGTGATTTGTCACTTGAAGAACCCGGAGAAGGGAAAACCACATGA +AGAAGGACGCGCTGTTTCTATTACTGACCTACGTGGTAGCGGTGCCTTGCGTCAGTTATC +TGATACTATCAACGCCTTGGAGCGTAACCAGCAAGGTGATATGCCTAACTTGGTGTTGGT +TCGCCTGCTTAAGTGTCGTTTCACTGGCGACACTGGAATTGCTGGGTACATGGAATACAA +CAGAGAAACCGGGTGGCTTGAACCGTCTAGCTACACTGGCGAAGAAGGAGAAGGAGATAC +TGGCTGGACTGAACAAGACGGACAATCAGACTTCTAAAGGATGCCCGTGTGGGCATTCCG +ATTGCGATGGAATCATGTACCACTAATTAACCCTCACTAACGGGAACAACCATTAAACCA +TAGGAGACACATCATGTTTAAATTCATTAACGCTTTAGGTAAGCTGGTAGTTAAACTGTA +CTTCATCGAAGCCAAGAAGCTGGACAAGAAGGCCAAAGCTGATTCACAGCGAGCCATTGA +GTTGGCGAAACAGTCCCGTGAGAAATCCGATGCGGCTGTTAGTGGCATCCACAAGTCGGC +AGCGATTGCAGCCAAAGCACAATCCATGAGCAAATTCTTTGAGTAAGGAGCGCACACTAT +GAGCAAGTCAATCACCCACGCAAACACCATCCGTCTGCCAGACACCGCTGACCAGTTCTC +CCGCCGAGTACACATCAATGTGCGTGGTGAGAAGGTCACGATGGTCTACCGCTGGAAAGA +CCACAAGTCTCCGAAAGCACACACTCAACGAATGACCTTGGTTGACAAGCAGGTCGGTCG +CTTGATGGGTGCCCTGACTATGGCTGCTGACAAGGTGGTCGGTGATAACCGTGAGCGTCT +GGTAGAGTTCGGCGCTGGTATGCAAGAGATTATCGAGAAGTGATAAACTCAAGGTCGCCC +AAGGGTGGCCTTTATGATTACCATTTAGCACGAAACCAAAGGAGGGCATTATGCTCGTAA +GTGACATTGAGGCCAACAACCTCTTAGAGAAAGTCACCAAGTTTCACTGTGGCGTTATCT +ATGACTACCGTGATGGTGAGTATCATAGCTATCGTCCGGGCGACTTCGGGGCGTATCTGG +ATGCGCTGGAAGCCGAGGTGAAGCGAGGTGGGCTTATTGTTTTCCATAACGGTCACAAGT +ATGACGTTCCGGCTTTAGAGAAACTCGCAAAGCTGCAACTCAATCGTGACTTCAAGTTAC +CCCGTGAGAACTGTATTGATACATTGGTACTCTCGCGTTTACTTCATGCGAACCTTAAAG +ACACAGACATGGGGCTTCTTCGCTCCGGGAAACTACCCGGTCGTCGCTTCGGGTCTCACG +CTCTGGAGGCATGGGGCTATCGCTTGGGTGAGATGAAAGGTGAATACAAGGACGACTTCA +AGGCTATGCTGGAAGAGCAGGGCGAAGAATATGTTGATGGTGCTGAGTGGGTTTCGTTCA +ACGAGCCGATGATGGCGTATAACGTTCAAGACGTTGTGGTCACTGTCAAACTCTTAGAGA +AATTCCTTACAGACCTCCACTACTTCCCTGCGGGTATGGACTTCACGAAGTACGATGCGG +ATCTATTCTGGCGAGAAGCTGGCGAGTCTGTGGATATTGAACATCGTGCAGCGGGGCTTT +TAGCGAAGCAGGAGCGTAACGGCTTCCCGTTCAACACCAAGGCAATTGAGGAACTTTATG +TAGAACTGGCAGCGAAACGCGCCGAACTTCTGCAAAAGCTAACCGAAACGTTTGGCTCAT +GGTATCAACCGAAAGGCGGTAAGGAACTCTTCAAGCACCCACGGACAGGCAAGCCGCTGC +CGAGCTATCCTCGCGTGGTCTATAGGGTTAATGAAATGACTACAGATAACTACAGGGCAT +CACTACAGGTTAACAATGGGTCTATCGGTCTGGTTGTCTTTAAGATAGCGTCGCTCTTTA +GGTGATGGCTTTAGGTCTGGTCTTTAGGTAGTGGCTTTAGGGTTTACTTTATGAGGCTAA +CAGATAGGGACACATAGAGATGTACTATCGAACTGGTACACTAGGACACTCTTTAAGGCC +TCCTTAAGCCACCCAATCACTTTAGGTATTGACTTTAGGCAACACTTTAGGCTATCCTAT +AGGCCACCCGAAACAGGGTGGCGTGTACAAGAAGCCTCGTAATAAGGCACAGCGCGAAGG +TCTTGAACCTTGCGACTTGGACACGAGGGATTACATGGAGGGTGCTCCATATACTCCGGT +AGAGTTCGTTACGTTCAAGCCAAGTAGCCGTGACCACATTCAGAAGAAACTACAGGAGGC +CGGATGGGTTCCTGAGAAGTTCACCGAGAAGGGTGCGCCTGTGGTGGACGATGAGGTCTT +GGAGCATGTACGAGTGGATGACCCTGAGAAGCAGGCGTGCATTGACTTGATTAAAGAGTA +CCTGATGATTCAGAAGCGAATCGGTCAGGCGGCAGAGGGTGACAAAGCGTGGTTACGTTA +TGTTCAAGATGATGGTAAGATTCATGGAGCCGTTAACCCTAACGGTGCAGTTACTGGTCG +TGCTACTCATAGTTTCCCAAACCTTGCACAAGTACCCGGCGTTCGTTCTCCTTACGGGGA +GCAGTGTCGTAGCGCTTTTGGTGCTGAACATCATTTGGATGGGATTACTGGCAAGCCGTG +GGTGCAAGCGGGGATAGACGCCAGTGGCTTAGAGTTGCGCTGTCTGGCACACTTCATGGC +TCGTTTCGATAACGGAGAGTATGCGAATGAGATTCTCAACGGTGACATTCACACCAAGAA +CCAGAACGCTGCGGAACTCCCAACGCGAGACAACGCCAAGACCTTCATTTACGGGTTCCT +TTACGGAGCAGGAGATGAGAAGATTGGTCAGATTGTTGGGGCAGGGAAGGAGCGCGGGAA +GGAACTCAAGAAGAAATTCTTAGAGAACACCCCGGCGATTGCAGCGCTACGAGAAGCTAT +CCAACAGTCTCTCGTTAAGTCTTCCGCTTGGATTGGCGCTGAGCAGAAAGTACAGTGGAA +GCGCCGTTGGATTAAAGGTCTGGATGGTCGCAAGGGGCATCAGTACACACGACAGGCAGT +ACGGAAAGTGACACGATGCAGTGCTGCCATGATTTGATCGCTCTTTAACAATCTGGATAA +TAGCTCTTGAGTGTACCGATGTATAAGCGAATAACTCAAGGTCGCACTGAAAGCGTGGCC +TTTATGATATTCACTTATTCACGTCAGGTCTCCACACGCAGCGCTCAACACATTGTTGCA +GTCTGCTGGTGCTCTGATTTGTAAGTTGTGGATCATCAAGACCGAAGAGATGCTCATTGA +GAAAGGCTTGAAGCATGGCTGGGATGGTGACTTTGCGTACATGGCTTGGGTTCACGATGA +GATTCAGGTGGCCTGCCGTACAGAGCACATCGCTCAGATTGTTATTGACACCGCGCAGGA +AGCTATGCGTTGGGTCGGAGAGCATTGGGCTTTCCGTTGTCGTTTAGATACCGAGGGTAA +GATGGGGCCGAATAGGGCTGTCTGCCACTAACAATAGGAGAAACATTATGGCAATGACCA +AACACTTTAAAGTAACCTTCGACGTTACCGCTGTGATTGACAGTGAATCCGAGAAGAATC +TGAACGAGTTGCTGGTAGACCTAGCTAAGAAGGCCGGGGCTGGCGAGAAGCTGAATCCGT +TCAAACAAGAACTGCTTATTCAAGGCCTGACACACGGGCCGGAAGGTGCTGCTGCGTTCT +GTATCAAGCAAGGTCTCCGTGAGTTTATCCGCGATGGTCACAGTGAGTTAAGCTCTACCG +AGCAGAAGCTGATGAGATTCTCACCTGCAACTGTGCGAGAGGTATTCAAATGAGTGAATA +CCTGAAAGTTCTGGCAGCTATCAAAGGTTGCCCTAAGTCCTTTCAGTCGAACTATGTGCG +AAACAATGCGGCTCTCGTAGCTGAGGCCGCTTCTCGTGGACACATTAGCTGTTTGACTGT +GGGCGGTCGCAATGGTGGAGCATGGGAGGTCACAGCCTCTGGTGTGCGCTTCCTGAAACG +AATGGGAGGTTGCGTATGATTATGCCTAAGAGTGACACCGTAACGATGACCCGTGATGCG +TGGAACGATGTTAGCGCGTACATTGATAAGCTGGAGAAAGGCCTAGAGTTCCTGAATGCG +CTTAAGGCGTGTGGTGTGGATAATTGGGACGGATACTCTGATGCAGTCGAAATGGTTTAC +GGGGAGGATGACGAATGAGCCTAATCACATTGAAAGACTTCGCGGAGATGCGTGAAGGTA +ATCCTATGGAGAAGGGAGTGCTGGTCATGGATGGTGACTAGTTGGTATATCAGTCAATGG +CTGCTGCCGAAGTTGAGACGGATTGGGGAGACGACATTTGGACTCTTGAGTGTGACCACG +CCAAGGCACGGAGCATTCTCGATTCTGCAATCGAATCGTACCGAACCCGTAAGAAGGCTT +GGAGTGACGCTATGGTTGTTCTGGCGTATACCGACGATGTGAACTGGCGTAAGGTACTGG +TTGATGAGACCTATAAGGAGAACCGTAAGGCGACCCGTAAGCCTGTGGGCTACCGTGACT +TCCTGTCGAAGCTGTGGGAGCGCGATGAGTTCATTCACATCAAAGAGGACATGCTGGAAG +GTGATGACGTTATGGGTATCATTGGGTCTGGTCACGAGGTCTTCGGCTTCAAGAAAGCTG +TGTTGGTCTCCTGTGATAAGGACTTCAAGACTATACCGGACGTTGACTTCCTGTGGTGTA +CCACTGGTAACATATTGACGCAGACCAAAGAGACCGCTGATTGGTGGCATCTCTTCCAGA +CTATCAAGGGCGATATGACTGATGGCTACTCCGGGATTCCCGGTTGGGGTGACACGGCAG +AAGGTTTCCTGAATGACCCGTTCATTGTGGAGCCTGTAGAGTCCGTGTTGAAGTCCGGTA +AGAACAAAGGGCAGACTGTCACTAAGTGGGTGAAACGCGCTCCTGATGCGACTGAGAGCC +TGTGGGACTGCATCGTATCCATTGGTGCCAAAGCTGAGATGACCGAACATGAAATCATTA +AGCAAGGCCAGATGGCACGCATTCTTCGCTTCGAGGAATACAATTACATTGACAAGGAGA +TTTACTTATGGACGCCGCGAAGCTGATTACCATCGCTGTGCTGGTAGGTATGCTGGCGCG +AGGTCTCTGGATGTTCGCTCTCATAGTCCGAGACGTGAAGCGAGACTCCGAGATTAAGTG +ATACACTCAAGGCTCTCTGTATTAACCCTCACTAAAGGGAAGAGGGAGCCTTTATGATTA +TTACTTTAAGACTTGTAGATACTCTTTAGCTGCACGCGGCATACTAGGAATATCATCGGG +ATGAGTTAAAACATGATTAATTGGTTGTAACATAAATTCACCTCTTAAGGTTAGGTGCGC +TTCAATCAGGCTTATGTGATGGAGTCCGGGGAGTACCGTGCGCTCCGCGCTGCTGGTTAC +TCTGAGTCTTTCATTGCGGGTGTGATGCATGGTCTGTACCTTGCCTCTCGAACACTTGAT +GAGATTGAGGTGCGTAAAGAGCAACTGAGACAGGAGTAACGATATGTGGTGGAAACCGAA +GGTGAAAGTCCCTAAGATGGACACTAACCAGATTCGCGCTGCTGAACCAGCACCTTTGAC +TGAACCTCCGAAGTCTGTGGTATGGGGAGGCGATGATGACGAGGACACCAGTGTGTCTTC +CTCTGAGGTGCCAACCACACCGAGCAGCGGTAAGAGCAGTCTCAAGGTAAAGCTGGATGA +CAGCGCAGCCAAGAACAAGAGTAAATCCTCCATTCGCTCCAAGGCGTTTGGGTAACTGAG +TCATAGCATAGGGAGAAACATCATGGGATTCTTCAAGAAAATCAAGAAGGCCGTTAAGAA +AGTTGTGAAAGAAGTTAGTAGACCAGTCGAGAAGGCCGGTAAGGAAGTGGGCAAGGTGGT +TGGAGGCGCGCTGGGTGCAGGTAAGCAGGAGATTATCCAACAAGAGGCTCCTGTACCAGT +AGTCGCTGCACCGCCACCAGCACAGGTTGTAGATGTACCGGAACAGGATAAGGCTGAGGG +TGAGGATGAGGCGCAAACCGAAAGCGCACGTAAGAAAGCACGCGCTGGCGGTAAGAAGTC +TCTGAGTGTAGCCCGTAGCTCCGGCGGTGGCATCAACATCTAAGGAGGACTGAATGGCTG +ATTCAAAACGTACAGGATTGGGCGAAGACGGTGCTAAAGCTACCTATGACCGCCTAACGA +ACGACCGTAGAGCCTACGAGACTCGTGCGGAAAACTGTGCGCAATACACCATTCCGTCCT +TGTTCCCGAAGGAGTCCGATAACGAATCTACCGACTACACGACTCCGTGGCAGGCTGTAG +GTGCGCGGGGTCTTAACAATCTGGCCTCTAAATTAATGCTGGCACTATTCCCGATGCAGT +CGTGGATGAAGCTGACCATTAGTGAATATGAGGCGAAGCAGCTTGTTGGAGACCCTGATG +GACTCGCTAAGGTGGACGAAGGTCTGTCTATGGTTGAGCGTATTATCATGAATTACATCG +AATCCAACAGCTACCGTGTGACACTCTTTGAGTGCCTCAAGCAGTTGATCGTGGCAGGTA +ATGCACTGCTTTACTTACCGGAACCAGAAGGCAGCTACAATCCGATGAAGCTGTACCGAT +TGTCTTCTTATGTTGTCCAAAGAGACACTTACGGCAATGTGTTACAGATTGTCACTCGTG +ACCAGATAGCCTTTGGTGCTCTCCTTAGTCTTAAATTTATCGAACGGAACCTCCTTCTTG +GGTTCTTTGAGCCACTCCACCGGAATTAGCTTGTCAGCAAACAGAATGCCATGCTTCTCA +CACCACTCGGCGTAGCTTGCCGGAAGACGTTCGGTCTGCGGTAGAGAAAGCTGGTGGTGA +GAAGAAGATGGACGAAATGGTCGATGTGTACACCCATGTGTATCTCGATGAAGAGTCCGG +CGATTACCTCAAGTACGAGGAAGTAGAGGACGTTGAGATTGATGGCTCCGATGCCACCTA +TCCTACTGACGCTATGCCCTACATTCCGGTTCGCATGGTTCGCATTGATGGCGAGTCTTA +CGGTCGCTCCTACTGTGAAGAATACTTAGGTGACTTAAGGTCGCTTGAGAATCTCCAAGA +GGCTATCGTTAAGATGAGCATGATTAGCGCGAAGGTCATCGGTCTGGTGAACCCGGCTGG +CATTACGCAGCCACGTAGATTAACCAAAGCTCAGACTGGCGACTTCGTTCCGGGTCGTCG +AGAAGACATTGACTTCCTTCAACTGGAGAAGCAAGCTGACTTTACCGTAGCGAAAGCTGT +GAGTGACCAGATAGAAGCACGCTTATCGTATGCCTTTATGTTGAACTTTGCGGTGCAACG +AACAGGTGAACGTGTGACCGCCGAAGAGATTCGATACGTTGCGTCAGAACTGGAAGATAC +ACTTGGTGGCGTCTATTCGATTCTGTCTCAACAACTGCAATTGCCTCTGGTTCGTGTGCT +CTTGAAGCAGCTCCAAGCAACCTCGCAGATTCCTGAGCTACCGAAAGAAGCCGGTGAGCC +GACTATCAGTACAGGTCTGGAAGCAATCGGTCGTGGTCAAGACCTCGATAAGCTGGAGCG +CTGTAACTCCGCTTGGGCTGCTCTGGCCCCTATGCAGGGAGACCCGGACATTAACCTTGC +TGTCATTAAGCTGCGCATTGCTAACGCCATTGGTATTGATACTTCTGGTATCCTACTGAC +TGACGAGCAGAAGCAAGCACTGATGATGCAGGATGCGGCCCAAACAGGTATCGAGAACGC +TGCCGCCACTGGTGGGGCTGGTGTGGGTGCTCTAGCGACCTCAAGTCCAGAAGCTATGCA +GGGTGCAGCAGCACAGGCTGGCCTAGACGCCACCTAATAACCCTCACTAAAGGGAGACCT +CATCTTTGAAATGAGCGATGACTAAAGGTTGGAGTCCTTTGGTTTCCCTTTATCTTTAAC +AACTTAGGAGATTTAACAATGGCTGAATCTAATGCAGACGTTTATGCGTCCTTCGGTGTG +AACAACGCGGTAATGACCGGAAGCACACCTACTGAACACGAACAGAATATGCTGAGTCTC +GATGTTGCTGCCCGTGATGGCGATGATGCAATCGTACTTAGCGAGGAACCGAGTTCCCAT +AACGATGACCCATATGCATCCGGTGTAGACCCGTTCGCTGATGGTGAAGACGATGAGGGC +CGCATTCAGGTTCGTATCAGTGAAGATGGTAATGAAGCCGAGTTCGACACCGGTAGCGAT +AACGCTGAGGTGGAGACCGAAGGTGAGGCCGCTGAGTTTGAACCGCTGGGTGACACTCCA +GAAGAACTGAGCCAAATGACTGAGCAGTTGGGACAGCACGAAGAAGGCTTTCAGGCGATG +GTCGAGCAGGCCGTTGAGCGTGGACTGAGCGCAGAGTCTGTGACTCGCATCTACGAAGAG +TACGAAGCCGATGGCATCTCTGAGAAATCCTACGCGGAACTCGAAGCTGCTGGCTATAGT +CGTGCCTTTGTGGACTCCTACATCTCCGGTCAGGAAGCCCTTGTAGACCAGTACGTCAAT +CAGGTAGTTGCCTTTGCTGGTGGTAAGGAGCGCTTTAGCGCAATCCATACGCACCTTGAA +GCAACCAACCCGGCTGCGGCTGAGTCCCTTGAGACTGCCATGATGAACCGAGACTTGGCG +ACTGTCAAAGCAATTATCAATCTGGCTGGTGAGAGCTACACGAAGAAATTCGGTAAGCCT +GCCAACCGTAGTGTTACCAAGCGTGCTACTCCGGTTAAACCTGTAGCTCGTCAGAAAGAT +GGCTTTACGAATCAGGCTGAGATGATTAAAGCTATGAGTGACCCGCGTTACCGTAGTGAT +TCTGCCTACCGTCAAATGGTAGAACAGAAGGTTATCGACTCCAGTTTCTAATTAACGCTC +ACTAAAGGGAGAGACCATAGATGACTACAATGGTTGAATCACCTGAGCACAGAACTTTGT +GGTCACTCCCGTAGGTGAAACATTGAGAACCAACTCGATTCAAGTAGTAACCAAACTTTT +CTTTAAATTAACATAAGGAGATTCAACATGGCTAACAATCAAGGCGGACAGCAAATTGGT +ACTAATCAGGGTAAGGGTCAGTCCGCAGCGGACAAATTGGCGCTGTTCCTGAAAGTGTTC +GGCGGTGAAGTCCTGACGGCTTTCGCTCGCACCTCCGTGACCATGCCTCGTCACATGCTG +CGCTCTATTGCTTCTGGTAAGTCCGCACAGTTCCCTGTGATTGGTCGCACCAAAGCTGCT +TACCTGAAACCGGGTGAGAACCTCGATGACAAACGTAAGGATATCAAACACACCGAGAAG +GTAATCCACATTGATGGACTGCTGACTGCGGACGTTCTGATTTACGACATTGAGGACGCG +ATGAACCACTACGACGTTCGCGCTGAGTACACCGCACAGTTGGGTGAATCTCTGGCGATG +GCGGCTGACGGTGCTGTACTGGCTGAACTGGCTGGTCTGGTTAACCTGCCGGACGCCTCC +AATGAGAACATCGAGGGTCTCGGTAAGCCTACCGTACTGACTCTGGTTAAGCCGACCACT +GGCGACCTGACTGACCCGGTTGAGCTGGGTAAAGCGATTATCGCTCAGTTGACTATTGCT +CGTGCGTCTCTGACCAAGAACTACGTTCCGGCTGCTGACCGTACCTTCTACACCACTCCT +GATAACTACTCTGCGATTCTGGCCGCTCTGATGCCGAACGCTGCAAACTATCAGGCACTG +ATTGACCCTGAGCGCGGTACTATCCGTAACGTGATGGCCTTCGAAGTGGTTGAGGTTCCG +CACCTGACCGCTGGTGGCGCTGGTGATACCCGTGAGGATGCCCCGGCTGACCAGAAGCAC +GCTTTCCCGGCGACTTCCAGCGCTACCGTTAAGGTTGCTCTGGATAACGTTGTGGGCCTG +TTCCAGCACCGCTCTGCGGTTGGTACGGTCAAGCTGAAAGACTTGGCTCTGGAGCGCGCT +CGTCGTGCGAACTATCAGGCTGACCAGATTATCGCTAAGTACGCGATGGGTCACGGCGGT +CTGCGTCCAGAAGCTGCTGGCGCTATCGTGCTGCCAAAGACTTCGGGGGCTTAAGGGTAG +CGTCTTTGAGTATGAACGCGGAGAGTGAAGTGGAGCCGACCCAAGAGGTAGCCGCCGAAG +TAGCTCTCACGCCTCAACAGAAGGCCGCCATTACTCGTGCTCGTAACAAGGCACTTAAGT +CTCAATAACAACAAGCAAACCCCTTGGGTTCCCTCTTTGGGAGTCTGAGGGGTTTTTTGC +TTTAACCCTCACTAACAGGAGGTAACATCATGCGCTCTTATGAGATGAACATTGAGACCG +CAGAAGAGCTATCAGCCGTCAACGACATTCTGGCTTCCATCGGTGAGCCACCAGTATCGA +CCCTTGAGGGTGATGCAAATGCTGATGTTGCAAATGCTCGACGTGTGCTCAACAAGATTA +ACCGACAGATTCAGTCACGAGGATGGACATTCAATATTGAGGAAGGTGTGACTCTTCTAC +CGGATGCGTTCTCTGGTATGATTCCATTTAGCTCTGATTATCTGTCCGTAATGGCAACCA +GCGGTCAGACCCAATATGTCAACCGTGGTGGCTATCTCTATGACCGCTCTGCGAAGACTG +ACCGATTCCCATCTGGTGTTCAGGTCAACCTGATTCGTCTGAGAGAGTTCGATGAGATGC +CTGAGTGCTTCCGAAACTACATCGTTACCAAGGCTTCCCGTCAGTTTAACAACCGCTTCT +TCGGTGCGCCGGAGGTAGACGGAGTGTTGCAGGAAGAGGAACAGGAAGCGTGGCGTGCGT +GCTTCGAGTACGAACTAGACTACGGCAACTACAACATGCTGGACGGTGACGCATTCACCT +CTGGTCTACTTAACCGCTAATAACAAGGAGGCTCTATGGCTCTCATTAGTCAATCAATCA +AGAACCTCAAGGGTGGTATCAGTCAACAGCCAGATATTCTCCGGTTCGCTGAACAAGGTA +GCGTACAGATTAACGGTTGGTCTTCTGAGTCCGAGGGTCTCCAGAAGCGCCCACCGATGA +TTCACCTTAAGACCCTTGGTGCTGCTGGGTATGTGGGTGCGCAACCTTACGTTCACCTCA +TCAACCGTGATGAGTTCGAGCAGTATTTCGTGGTGTTCACTGGTGAAGACATTAAGGTAT +TCGACCTCGACGGTAAGGAGTACCAAGTACGTGGAGACCGCTCATATGTTCGTACAGCTA +ACCCACGAGAAGACCTTGGGATGGTAACTGTGGCTGATTATACCTTTGTGACTAACCGCA +AGGTGGTTGTACAGAGTAACGACCAATCGGTCAACCTTCCGGGCTTTAAAGACCAAGGCG +ATGCGCTGATTAATGTTCGCGGTGGACAATATGGGCGTAGACTCTCAATCGAGTTCAACG +GGGCTGAGCGTGCTGCTGTACAACTACCGGATGGTTCACAACCAGCACACGTTAACGAGG +TTGACGGTCAGGCTATCGCTGAGAAGCTGGCTGTGCAGTTGAGGAACAACCTTGGGAATC +CAAACAACGAGCAAGACCCGAATAAGTGGCGCTTCAACGTTGGCCCCGGATTCATCCATA +TCCTTGCGCCAAATAACGATAACGTTTGGGGACTACAGACTAAGGATGGTTACGCAGACC +AGCTAATCAACCCTGTAACCCATTACACTCAGTCGTTCCAGAAGCTGCCTATTAACGCGC +CAGATGGGTACATCGTGAAGATTGTTGGTGATACCTCAAAGACTGCCGACCAGTATTACG +TTAGGTTCGACCTCAACCGTAAGGTGTGGGTAGAAACAATTGGATGGAACACAAGGACTC +ACCTACATTACCACACGATGCCTTGGGCACTTGTTCGCGCTTCTGACGGGAACTTTGACT +TCAAGTACCTTGAGTGGGGTGCTCGTACTGTGGGGGACGATACAACCAACCCATACCCAT +CCTTTACCGGACAGACAATCAACGATATTTTCTTCTTTCGTAACCGTTTGGGATTCCTTA +GTGGGGAGAACATCATCTTGTCTCGCACCTCGAAATACTTAAACTTCTTCCCGGCATCCG +TGTCAAACTACTCCGACGATGACCCAATCGACGTTGCGGTTAGTCATAACCGGGTGTCAA +CCTTGAAGTATGCCGTTCCGTTCTCAGAAGAGTTACTCCTGTGGTCTGACCAAGCGCAGT +TCGTTCTGACAGCCTCTGGAATCCTTTCGAGTCGCTCCGTAGAGTATCGGTTAATGGATG +TGAAGGAAGCGCGAGGTGACGCAAAGTATACATTACGTCCTACACCATGTGGGCGTGCCC +TGTCTTGCACGTCGAACTGCGTCGTAAGGTTCAACTATGCGGTACAGGATGTAAGCTCTG +TGAAGAACGCAAAGGACATGACGGCTCACGTTCCGAACTACATACCGAATGGAGTATTCA +GTATATCGGGGACAACCGCTGAGAACTTCGCGGCTATCCTTACGAGCGGAGCACCGAACC +GAGTGTATATCTACAAGTTCCTCTATATTGATGAGGAAATCAGGCAGCAGTCGTGGTCTC +ATTGGGACTTTGGGGACAACGTTACGGTGTTTGCAGCACAGGTGATAAACTCAACAATGA +CTGTATTGATGAGCAATGAACATGCTGTGTGGATGGGACGCTTACACTTCACGAAGAACT +CCATAGACATTCCGGGAGAGCCTTACAGATTATACATCGACGCTAAGAGGAAATACACCA +CCCCTGCCGGGACGTATAATGATGATACCTACCAGACGTCCATAAGCCTCGCAACAATTT +ATGGGATGAACTTCACTAGGGGTAGAGTGTCTGTGGTCTTACCTGATGGGAAGATTGTAG +AGATAGACCAACCAATCAACGGGTGGAGTAGCGACCCAATACTGAGACTTGATGGAAACC +AAGAGGGACAAGTAGTCTACATTGGGTTCAACATCCCGTTCACTTATACGTTCTCGAAGT +TCCTCATCAAGAAGACTGCTGAGGACGGCTCGACGGCTACCGAGGATATTGGTCGTTTAC +AGCTTCGGCGTGCGTGGGTAAACTATGCGGACTCTGGAGCGTTCACCATCCGTGTGAACA +ACCTGTCCCGTGAGTTCATCTACACAATGGCTGGTGCTCGCTTGGGTTCTGACAATCTGC +GTGTTGGCAGGTCGAACATTGGCACAGGGCAGTACCGCTTCCCGGTTGTTGGAAACGCTC +AGACGAACATAGTAACTATCGAGTCAGATGCATCAACACCACTGAACATCATTGGGTGCG +GCTGGGAGGGGAACTACCTTCGTCGTTCTTCTGGCATTTAACTTAAAGTCTCCCTGTGGT +GAATTAACCCTCACTAAAGGGAGACACTAATAGATACGAGGGGTTAAAGCATTATGTACA +TTACAAAGTGTTTACAAATCCATGCCGACAACTTTCAGCCGTCCATAGAGGACATTCTGG +AAGCTGAGGCACTAGGTGTTGAACCAAAGGTAATTCCTGATGAGAACACTGTGGCAATGC +TTAGCGATAACGCTGTGTTGGCAATCGGTGGCAATCAGGGAGACCGAGTGTGGTTCCTTA +CCTCTAAGTACGTCCCACTGTTTACCTTGAAGGAGCGCTTAGAGTTTCGTAGACTTATCA +TTGAATATCGTGATATGATGCTGAGCCAGTACGAGTCCATTTGGAATTTCGTTTGGGTAG +GCAATAAGTCACACATTCGTTTCCTAAAGACCATAGGCGCGGTATTCCATAATGAGTTTA +CCGCTGATGGTCAATTCCAATTATTCACTATCAGTAGGAGGTAACTATGTGCTGGATGGA +AGCGATTCCTATTGCCATGATGGGTGCCCAAGCTCTAAGTAGCCAGAACAGTGCTGACAA +GGCGCGAGTGGCACAGACCGAAGCTGGACGCAGACAGGCAATGGAGATGGTCAAAGAGAT +GAATATCCAAAATGCCAACGCCTCGCTGGAACAACGGGACGCCCTTGAAGCTGCATCCTC +TGAGTTGACTACACGTAACATGCAGAAGGTACAGGCTATGGGAACCATCCGTGCAGCTAT +TGGCGAGGGTATGCTCGAAGGTGAGTCCATGAAGCGCATCAAGCGTATCGAAGAGGGCAA +CTACATTAGGGAGGCAAATAGTGTCACCGAGAATTACCGCCGAGACTACGCGAGTATCTT +TGCGCAACAGTTGGGACGCACTCAGTCCACAGCGAGTCAAGTCGATGCAATGTACAAGAG +CGAGGCCAAAGGTAAGTCTGGTCTGATGCGTGTACTAGACCCTCTGTCCATTATGGGTCA +GGAAGCTGCAAGTCAATATGCGGCTGGTGGATTTGACAAGAAGGGTGGAAACCAAGCAGC +ACCTATCAGTGCCGCCAAAGGAACCAAGACCGGGAGGTGATAATGGCTAGTAAACTAAAT +AGTGTTTTAGGCAACATGGCGACTCCCGGTATGGAACGACTCCGGGGCGTCAAAGGTATG +GACTACCGGGCAGCAACCATTCAGGCTGAACAACCAAGAGCGAGTCTTCTGGACTCCATT +GGTCGATTCGCTAAGGCTGGTGCCGATATGTACATGGCGAAAGATGAACGTGATAAGCAA +CGAGCCGATGAGCGCTCCAACGAGATTATCCGTAAGCTGACCCCTGAGCAGCGCCGACAG +GCTATCCAGAATGGTACACTGCTGTGTCAGGATGACCCATACGCAATGCAAGCCTTGAAG +TTCAATACCGGGCGTAACGCTGCGTTCCTCGTTGACGAAGAGGTTCAACAGGCCATCAAA +GAGGGTCGCTTCCGTACTCGTGAAGAGATGGAGCAGTATCGTCACTCACGCCTACAGGAG +CACTCGAAGTCGTTCGCTGAGCAGTTCGGTATCAATGAGATGGACGAGGAATACCAGAAG +GGTTTCAACGCGAATATCACCGAGCGTAACATTGCTCTGTATGGGGCACATGATACCTTC +CTGAGTGACCAAGCGCAGAAGGGTGCAATCCTGAACTCGAAGGTTGAACTCAACGGTGTC +CTATCTGACCCTGACCTACTGTCTCGTCCTGAGTCCGGTGAGTTCTTCCAGAACTACATT +GACAACTCCTTGGTGACGGGGATGACCGACAATCAGGCTCAACAGGTTATCTCTTCGTCC +CTGAATGACGTGCTACAGCGTCCGGGTGGTGCCGCCTTCTTGCAGAACATTGAGAACCGC +AAGGTGACTCTTAATGGCGCTACGACTACCTATCGTGAACTGATGGGTGATGAGCAGTGG +CAGGCAATGATGATTAAGGCACAGCACACTCAATTCCAGAACAACGCGAAGTTAACCGAG +AAGTTCCGACTGGATATTAACTCAGCGCTTAACCAAGCAGACACTGGTAAAGGCTGGGAG +ACTCTTCAAGGTATCAAGGCCGAACTCGATAAGATTCAGCCGGGTGAAGAGATGACTCCT +GAGCGCGAGTGGTTGATTTCCGCACAGGAACAGATGCGCACACGCTTCAAGCAGGAACAG +GCTGAGACAGCCAAGCTGATGGACAAGCAACAGAAGACCTTGAATAAATCTTTGGTCATC +GACAAGCAGTTCCAGAAGCGCCTCAACGGTGAATACGTCTCGACAAACTATAAGGACATG +CCGACCAACGAGAACACTGGTGAGTTTACACATAGCGATATGGTCAACTACGCGAACCAG +AAGTTAGCGGAAATCGAAGCGATGGACTTAACGCCAGAACAGAAAGACAAACTGAAATTG +GACTACCTACGGGCAGACTCCAAGGAGGGTGCTTTCCGTGCAGCGTTTGGTGAGATGATT +ACTGATGCTGGAAACGAATGGCAGGCTGCGGTGATTAACGGTAAGATGCCTGAGAGCGCA +CCAGCGATGGACAACCTTCGTCGCATCCGCAACACTGACCCTGACCTGATTGCCTCTCTG +TATCCTGACAAGGCCGAGTTGTTCCTGACTATGGACATGTTGGATAACCAAGGTATCGAC +ACGCAGGTTCTTATCGACGCTGATAAGTCCCGCGCACAGAAGACCAAGGAGATGCAGTTT +GAGGATGACCGAGCGTGGGCTGCTATGATGAACGATTCAACGGATCCTCAAATCAAGTAC +ATGCCTTCGAGTGTCCAAGGTTACGCGCGGAAGATTTATGATTCCGTGAAGTACCGGACA +GGGAACCCTGACATGGCAACAGAACAGGTCGCAAAGTTCCTCTCTGATTCAACGACTACG +TTCTCCAGTAGTGATGTTGATGGCGATACCTATGGTGTCCTGCCGAAGAACATCCTGACT +GTTTCGGATGACCCTAAGTCGTGGGAGCAAGGGAAGAACATTCTGGACGAAGCCATTAAG +GGAATCACAGCGGCGAACCCTTGGATTACCAACAAGCAACTGACGGTGTACCAGCAAGGT +GATTCAATATACCTGATGGACACAACCGGACAGGTTCGCATTCGGTATGACCAAGAGTTG +CTCCGGCGTGAGTACCAGCGTACCGCACAGATGCAAGCTGAGGCAGCACGAGAGAAAGCC +CTCAAAGAGGCCAACAAGCGTGCCCCAATCAGCCGTGTACCACAGGCGCGTGAAGAAGCG +CGTAAACGTGTCCAAGAGAAACGGAAGAAGACTCCGAAGTACATCTATGGACGTAAAGAA +GACTAACAGTGATAAGGAGGCTCCATGAGCTACGATAAGAACCAACCTAGCGAGTTCGAT +GGGTTATTTCAAAAAGCGGCAGACAAACATGGGGTCTCCTATGACCTGCTTCGTAAATTA +GCATTCAATGAGTCCAGTTTCAATCCAAAGGCCAAATCACCAACTGGCCCGAAGGGTCTC +ATGCAGTTCACCAAGGGTACAGCCACTGCGCTGGGACTCAAAGTCACTGATGCAGACGAT +GATGACCGTTACAACCCGGAGTTGGCTGTGGATGCAGCCGCTCGTCACCTGAGTGACCTC +ATTCGTAAATACGATGGGGATGAGCTTAAGGCAGCCCTAGCGTACAACCAAGGCGAGGGA +AGAAATGGTGCCCCTCAGATGCAGGCCTACGACAAAGGTGATTGGGCCTCAATCTCTGAG +GAAGGTCGTAACTATATGCGTAACCTGATGGACGTAGCTAATAGTCCTCGCAAGGGGGAC +TTGGAGGCGTTCGGCGGTATCACCCCAAAGGCTAAGGGCATTCCATCGGGGGATGCATTT +GCTGGAATCGGGAAGAAGCAGACGGTAGGCACTGACCTGCCGGAGTCAACGGGATTCAAA +GTGGAGGGTAAAGAGCAGCAAGCGCCTAACGTTCCTTATGCTAAGGACTTTTGGGAAAAG +ACTGGAACAACACTGGACGAGTTTAACTCACGCTCTACCTTCTTCGGAATTGGCGATGCA +ACAAGTGCGGAGCTTCATAACTCTGTACTTGGAGTTGCTTTCCGTGCAGCCCGTAGCGAC +GATGGTTTTGATTTGTTCAAGGACACCATTACGCCTACCCGTTGGAATAGCCATACGTGG +ACTCCAGAAGAGCTAGAGCGAATCCGTAAGGAAGTGAAGAACCCCGCGTACATCAACGTA +GTCACTGGAGGCTCTCCTGAGAATCTGGACGCCCTCATTAAGATGGCGAATGACAACTAT +GAGATGGATGCGCGGTCTGCCGATGCTGGTGTTGGTGCCAAACGTACTGCTGGTATCATC +GGCGCTGGTGTAGACCCGCTGAGTTATGTACCGCTAGTAGGCGTAGCCGGGAAGGGTCTC +AAGGTGGTTAACAAGGCTTTCATTGTGGGTACTCAAAGTGCTGGCCTCGCGGTTGCCTCT +GAGGGTCTCCGTACATCAACCGCTGGTGGAGAAGCCCACTATGCTGATGCTGCTTTAGGT +GGTCTCTTGTTTGGTGCTGGTATGAGCGCAATCAGTGATGCTATCGCTGCTGGTGTTCGC +CGTTCCCGTGGGACTGAGGTAGTTAATGACTTCGCTCCTATGGCACACCGCTTGGAAGCC +CGTGAGACCGCTCTGAACACTGGTGGGGAAGACCTGACCCGTATGCCTAGCGAGAACCGT +GTGTTCGACCGTGAGCACGCTGGCGTTGAGTATTCACCTCTGGAGACCGAGCCGGGTGCC +GTTGTGTTGCCTCAAGGTCAAATCCTGAGCGACACCAACCCACTGAACCCTCAGACTCTT +AGCGAGTTCGAGGCGGTCAACCCTGAGCGTGCCGCTCGTGGTATCTCTTTGGGTGGTTTC +ACTGAGATTGGCTTGAAGACTCTCCGCTCTGAGAACCCGACTGTTCGCTCCATTGCGAGT +GACCTTGTGCGTTCTCCGACAGGGATGGAATCAGGCTCTAATGGTAAGTTCGGTGCGACT +GCTTCTGACATTAAGGAGCGGCTCCACGCGAACAATCAGCGCACCTACAATCAGCTTTAT +GATGCTGTGCGTACTGCAATGAAAGACCCTGAGTTCTCCACAGGTGGTGCCACAATGAGC +CGTAAGGAAATCCGACAGGAAATCTACAAGCGTGCAGCCTTGGCGATTGAGCGACCTGAG +CTTCAAGCAAACCTGACAAAGGGTGAGCGGAACGTGATGAACATCCTCAAGCAGCACTTT +GACCTCAAACGTGAAATCATGGAGAACCCGTCAATCTTCGGCAACACCAAGGCGGTCAGT +ATCTTCCCCGGCTCACGCCACAAGGGAACCTACGTGCCAAACGTGTACGACCGCGCTATC +AAGATTGAGATGGTTAAACGTTACGATAATGATGGCTTGCAGCGAGCAATCGCGGAGTCA +TGGTTGACGTCTTATCGTGCTCGTCCAGAAGTCAAGGCGAGGGTCGATGAGTACCTGATG +GAACTTAACGGTCTCAAATCCGTGCAGGAAGTTACGCCTGAGATGGTGCAGAAGCACGCG +ATGGATAAGGCGTATGGTATTTCACACACTGACCAGTTCTCTGCCTCCTCTGTCATTGAG +GATAACATTGAGGGTCTGGTGGGTATCGAGAACAACAACTTCTTGGAAGCCCGTAACATG +TTCGACAGTGACATGGCGGTGACTCTCCCTGATGGTAACACGTTCTCTGTGAATGACCTG +CGTACCTATGACATGGCTGAAATTCTGCCTGCATACGACCGACGAGTAGATGGTGATGTT +GCAATCATGGGCGGTTCCGGTAAGACTACCAAAGACCTGAAAGATGAAATCATGGCGCTG +GATAAGCAGTCAGAGGGTAACGGCACACTGAAAGGTGAAGTGGAAGCTCTCAAGGACACC +GTGAAGATTCTGACTGGTCGTGCTCGTAGGAACCCGGAAGGCGCTTGGGGTACAGCCCTG +CGCTCCGTAAATGACCTCACGTTCTTTGCTAAGAACGCCTATATGGGCGCACAGAACGTT +ACTGAAATCGCTGGTATGCTGGCGAAGGGTAACGTCTCTGCGATAACTCATGGCATCCCT +ATGATTAACGATTGGGTCAACCGTGGTAAACCGCTTCGTGCCTCTGAGATTAAGGAGATA +CACGGGATGGTGTTCGGTAAGGAACTAGACCAACTAATCCGTCCGGGACGTGAAGACCAC +GTGCGCCGACTCCGGGAGTCTACGGACACCAGCGCTGCGGTTGCCAATGTGGTCGGTACG +ATTCGTTTCGGCACTCAAGAGTTGGCTGCACGCTCTCCTTGGACAATGCTCCTAAACGGA +ACATCAAACTACATTCTTGATGCTGCCCGTCAGGGTGTGCTTGGGGATGTGGCTGGAGCG +GCCCTTGCTGGGAAAGCCTCTAAGTTCGGTAAGGCAAACTACCTTAAGTCTGCCTCTATC +AGCCCTGAGCAGTGGAATGGAATCAAGCAGTTGTTCAGAGACCATGCGACTCGTAGAGAA +GACGGTAAGTTCACCATTCGTGACAAACAGGCTTTCTTTGGAGTCCTGTGAGGAAACCTT +GTGAGGTCGCAGTATAGTCTCATCCGCCACCTTGTCAGCCAGTCGCCACAAGTCCATTGA +ACGTGGGTCGTTAGCGCGTTCGGTGCAGGGGTGAAGATGGTGATGCAGTTTAAGAACTTC +GTCATCAAGTCCCTTAATTCCCGGTTCGTCCGTAGCTTCTGCGAGGCAACTAAGAACAAC +CGTGCGTTAGACCAAGCGTTGACTCATATCATCTCCTTGGGTCTAGCTGGTGGTTACTAC +GTTGCGCAGGCGCACCTTAAGGCCGCAAGCCTACAGGAGCACAAGCGTAAGGAGTACCTT +AAGAACGCACTTGACCCTAAGATGATTGCTCATGCGTCAATCTCTCGTAGTTGACACTTA +GGCTCACCATTGAGTATCTACGACATGTTCGCTGGGATGGTTGGTAGCGATACCTATAAG +TACACCCGCTCTACTGTGCTCCCTAAAGAGTCCGAGAAGCGTGACCCTAACAAGGCAATG +ACAGGTAGACAGGTGGCTTCAACTATCGCGGGTGCAGTTGGTGAGCAGGTTCCGGGGTTA +GGTTTTGTGGATTCTGTGGGTGCAACAGCAATTAACGCAGCTTCCCTGCTATCTTCTCCC +AACAAGGCAACCGCTCTGGAGTTCCGTACAGGCCTCTTCAACACCTCTCGTGAGTTGATT +CCTAATGACCCGCTATCGCAGCAACTCATTATGAAAATCTACGAGGCCAACGGTATCCGC +ATAAAGGAGACGCCGAAGAAACAATAAACCCTCACTAAAGGGAGAGAGGTCACATTCTGG +CCTCTTCTCTCTTAATGCTAATTTACAAAGGAGGTCACATGGCTACAACTATTAAGACCG +TGATGACTTACCCGCTGGATGGCTCCACTACGGACTTTAATATTCCGTTCGAGTATCTAG +CGCGTAAGTTCGTCAGAGTGACCCTTATCGGTGTTGACCGAAAGGAACTCATCTTGAATC +AGGACTACCGTTTTGCGACTAAGCCCACAATCTCCACAACGAGAGCATTGGGGCCAGATG +ACGGTTATAACATGATTGAAATCCGTCGATTTACCTCCGCTACCGATAGGCTGGTTGACT +TCACCGATGGTTCAATCCTTCGGGCATACGACCTGAACATCTCTCAGGTCCAAACCCTTC +ACGTTGCTGAGGAAGCACGTGACCTTACCGCTGATACTATTGGCGTTAACAATGATGGGA +ATTTGGATGCTCGTGGTCGCCGTATCGTTAACGTAGCTGACGGAGTTACTGATGGTGACG +CCATCTCTGTAGGTCAGGTTAAACGTATGAACCAGAACTCGTGGCAAGCACGTAATGAGT +CCTTGCAGTTCCGTAATGAAGCAGAAGGTTTCCGCAATCAGGCCTCTACGAGTAAACAGG +CTGCTGCTACCTCTGAGTCGCAATCATGGAATCATTCTGAGCGCTCTCGGACATTCGCTG +AGGCAGCTCAAGGTTCTGCTAACTCTGCGGGACAGTCAGCTACCAATGCGAACAACGCTA +TGCAGTCTGCTGGTCAATCAGCCACGGATGCTAGTAACTCTGCTGCTCAGGCTAAGGCCT +CTGAGGTTAACGCAAAGGCCTCTGAGGTTAACGCTAAGCGTGATGCTGACGCGGCCCTGC +TGGCTCTGCAATCCACTGGTAACGTACCTGTGGGTACAGTCGCCATGATTACCCACACCA +AGATTCCTACTGGTTGGGTGCGTGCTGGTGAGGACTTCGACGTTAATACTTACCCGCCGT +TAGCTGAACTGTTCCCTAGTGGTCGTACTCCTAGCTTCGATGACCGCTATCCTATTGGTA +ACTCTACCGTATTGACTCCGGGTCAGCTTATTGACCAATCAGTACCCGCCCACAGTCACA +CCTTCGACGTGCCTGTCAACGTGTCAGGTGCTACGGCTGCTGGTGGCGAATATCGCGCCA +GAACGTCACACGAAGGGGATCACAGTCATGGGTTCTCATTGCCTATCCAGAACAACACAG +GTGCTTATACTGGTCGTCTGGTTGGCGGTGGCAACAACCCTAACTACCCGCAAGACCTGC +GCTTTAACACTGGTGGCGGTGGTGCTCACAGTCATGAGTTCTATGTTCCTTCACACAGTC +ACACGTTGAATGCATCTGGGCGTGCTGCTGGCTCCGTCTCTTCGTCAGGTATTGGAAACT +CACCGTATGTCCGTCCGTATTCCACTGTGGTCATCTTCATCATCAAGGCCGCTCAAGGTG +TTGACGATAAGGACGCAGTAATGCAGGTGGTGGGCACTGTGGTTGAACGAGTGGACGCTC +TGGAGAACTGGCAGAAAAACTTCAAGTCCGTTGTTGAGAACGGTTCACCAACCTCTGGAA +ACGGCGGGCCTTGGGAACGTACTGTGTACACTGCCCAGACTGACTTCGGTCTCAACCGCT +GGCGCACGCTGAGTGGTTCGTCATGGGGAGAAGTAGTCAACTTACTTAATAGCTCCGGCG +TACTTAAAGGGTATCCGCAACGTCTTGTTGTTGACTTCACGGTTGAGGTAATCGATAGCT +CTGACCTAATCGCCAAGGCTGGTATATATAGTCCAATGATTATGGCCAGAATCGTGTATC +ACAACGGCACCAACTCTGGTGATATACTTCCCGCTGCCACCTCAAGCTCTGCGCACGCGA +CAAACGGGTGGAACATTAAGATGGCTACACGATTGTTGTATGGTACTGATGGCGGTCAAC +CAGTAGTTGAGATTGGTGCCTTCAAGGATGGTTCTGACCAGCAGACGGCAAACGTGCCAG +TTAAAGTAGGCTTGCGCCTCGTTCACGTGTTCTAAGGAGGACATAATGTTATCACTTGAT +TTCAACAACGAGGCCATTAAGGCTGCACCCATTGCGGGTGTGGCTGGTGCTGATGGTGTG +GCCCGCCTGTTCTGGGGGCTTTCTCTCAACGAATGGTTCTACGTTGCAGCTATCGCCTAC +ACAGTGGTTCAGATTGGTGCCAAGGTGGTCGATAAGATTATTGATTGGAAGAAAGCAAAT +AAGGAGTAACCTATGAGCGACAAGACTTTAATCAAGCTGCTGGAGATGCTGGACACGGAG +ATGGCACAGCGTATGCTTGCTGACCTCCAGAGCGAGGAACGCCGAACTCCGCAGCTTTAC +AACGCAATCGGCAAACTGTTAGACCGCCATAAGTTCCAAATCAGTAAGCTGACCCCGGAT +GAGAACATCCTTGGCGGTCTGGCGGCTGGTCTGGAAGACTACAACAAAGTGGTCGGCCCT +AATGGTCTGACTGATGATGAAACAATCACGCTACAGCAAGTGACATACTCAAGGTTCTCC +ACGCGGGGAGCCTTTATGGATGTTATTTGGTGCATCTATGTAAAATCTGAAAATTGATGG +GAGGTGTTATGCTAAAACTTTTACGCAGCGCACTCCCTTGGGTACTCGCCGGGACACTCT +TTATGGGTGGCTGGCACTTAGGGTCAACCCATGAGAGAGCAAACTGGAAGGAGGTAATCC +AAAATGAATACATTGCGAAAACAAAAGCAACCGCAGCAACTCAGGCAGAGGTCAGTCGGG +TATCCCGTGAGTACCAAGAAGAGATTGCAGCCATTGAAGGCAGCACTGATAGGATGCTTA +ATGACCTGCGTAGTAATAATATGCGGCTGTCAGTCCGCATCAAGACCCTTACCGGACTAC +CAGAAGATAACGGTAGATGCGAGTTTAATGGTCGAGCCGAACTACACGAGTCAGATGCTA +AGCGTATTATCGGAATAACCCAAGCTGCTGATGCTCACGTAAGGGCGCTCCAGCGTACTA +TTAAGGAGATGCAGAATGAGCGACACCCAAGCAAACCGTAATGCGCTAATCATCGCGCAG +CTTAAGGGCGACTTTGTTGCCTTCCTGTTCGTATTGTGGAAGGCTTTGGCTCTCCCGCCA +CCGACTAAGTGTCAGATTGATATGGCCCGGTGTCTGGCTAACGGAGACAACAAGAAGTTT +ATCCTACAGGCTTTCCGTGGTATCGGTAAGTCATTCATCACCTGTGCGTTCGTTGTGTGG +ACGTTATGGCGTGACCCTCAGTTGAAGATACTGATTGTCTCTGCATCCAAAGAACGTGCG +GACGCTAACTCCATCTTCATCAAGAACATCATTGACCTGCTGCCATTCTTGGCTGAGCTA +TAGCCTCGCCCCGGTCAGCGTGACTCTGTGATTAGTTTCGATGTTGGCCCTGCCAAGCCT +GACCACTCTCCGTCTGTGAAGTCGGTGGGTATCACTGGTCAGTTGACTGGTAGTCGTGCT +GATATCATCATAGCGGATGACGTTGTGATTCCGTCTAACTCCGCAACTCAAGGTGCCCGT +GAGAAGCTGTGGACTCTGGTGCAGGAATTTGCTGCGCTTCTGAAACCGCTGCCGACTTCT +CGCGTTATCTACCTTGGTACACCTCAAACCGAAATGACCTTGTACAAGGAACTCGAAGAT +AACCGTGGGTACACCACAATCATCTGGCCTGCGCTCTATCCGCGTAGCCGTGAGGAAGAC +TTGTACTATGGCGACCGTCTGGCCCCGATGCTCCGCGAAGAGTTCAACGATGGGTTCGAG +ATGCTCCAAGGTCAACCGACTGACCCCGTGCGCTTCGATATGGAAGACCTGCGTGAGCGT +GAGTTGGAATACGGTAAGGCTGGCTTCACTTTGCAGTTCATGCTCAACCCGAACCTGAGT +GATGCCGAGAAGTACCCCTTACGCCTCCGTGACGCTATCGTGTGCGGTCTGGACTTCGAG +AAAGCCCCAATGCATTACCAGTGGCTTCCGAACCGTCAGAATCGCAATGAAGAGCTTCCT +AACGTGGGACTTAAGGGTGATGATATTCATAGCTATCATTCGTGCAGCCAGAACACTGGA +CAGTACCAGCAACGCATCCTCGTGATTGACCCAAGTGGTCGCGGTAGGGATGAGACAGGT +TACGCAGTGTTGTTCACCCTGAATGGCTACATCTATCTGATGGAAGCTGGCGGGTTCCGC +GATGGTTACTCCGACAAGACCCTTGAGTCCCTCGCTAAGAAAGCGAAGCAGTGGAAGGTT +CAGACAGTGGTCTTCGAGAGTAACTTCGGGGATGGTATGTTTGGTAAGGTATTCAGCCCT +GTGCTCCTGAAACACCATGCAGCGCAACTTGAAGAGATTCGTGCTCGCGGTATGAAGGAA +CGACGCATTTGTGATACGCTGGAACCTGTACTCTCTACGCACCGCCTTGTGATTCGTGAC +GAGGTGATTCGTGAGGACTACCAGACTGCACGTGACGCTGATGGCAAGCATGACGTTCGC +TATTCGCTGTTCTACCAGTTGACCCGTATGGCTCGTGAGAAGGGCGCTGTGGCCCACGAT +GACCGACTTGATGCGTTAGCATTGGGTGTGGAGTTCTTACGCTCTACGATGGAACTGGAC +GCCGTGAAGGTGGAGGCTGAGGTGCTTGAGGCGTTCTTAGAGGAACACATGGAGCACCCA +ATCCATTCGGCTTGTCACGTAGTCACCTCTATGGTTGACGGTATGGAACTCTATTGGGAG +GATGACGATGTGAATAGCAATAGGTTCATTGACTGGTAGTTATGCATATTGAGTGCATAA +GGAATCATTGAGACCACGGATGGTCACTTTAAGAAACTCCTTAAGAATCAATGAGTTTGA +ATTAACCCTCACTAAAGGGAGAGAGGGGACTTAAAGCTACTATATAGGTTAGTCATTCAG +GTTATGCAATGACCCTTTATGCACTTTAAGTCGCCTCTATGATTGGTGATATTATCATTG +TATAATCACCCTACCTTAGAGCAACTGAAAGGAGGTGGCTCAATGTTACGCTTGCTGATT +GCCCTGCTGCGTCATAGAGTCACTTGGCGATTTCTTCTGGTACTTGCTGCTACCCTTGGG +TACGCAGGTCTTACTGACCACCTCGGTCAACTGGAAGTGGCCTTTTGCTCTATACTCTCT +TGTGGGGATTAAATTCTTGTTGATGAACGACAAGCGGCTCTGAGGGATTCGTAGGTATAG +TTTCACTACACCAACTCATCCCTGTAGAGTCAACCCTAAAGGTTATACCTAAAGATGCCC +TGTAGTTCGTAATGGTCTTACAGGGTCTTTAAGTGTCTCCTATGGTCTCACCTATGGTGT +GGCCTTACCTAAAGTGGTTGCCTAAAGAGACCTTTAAGAATTTACCACAAAAATCTGAAT +GGGTATCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAA +GCCAGCCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCT +ATAGGATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGA +GGCCTTAAAGAGTGTCCTAGTGTACCAGTTCGATAGTACATCTCTATGTGTCCCT diff --git a/example/fna/NC_010807.alt2.fna b/example/fna/NC_010807.alt2.fna new file mode 100644 index 0000000..f812b03 --- /dev/null +++ b/example/fna/NC_010807.alt2.fna @@ -0,0 +1,677 @@ +>NC_010807.alt2 length=40555 tani=98.985 alt=sn;du +TCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAAGCCAG +CCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCTATAGG +ATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGAGGCCT +TAATTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCTATAGGATAGCCTAAAG +TGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGAGGCCTTAAAGAGTGTC +CTAGTGTACCAGTTCGATAGTACATCGCTATGTGTCCCTATCTGTTAGCCTCATAAAGTA +AACCCTAAAGCCACTACCTAAAGACCAGACCTAAAGCCATCACCTAAAGGGCGACGCTAT +CTTAAAGACAACCAGACCGATAGACCCATTGTTAACCTGTAGTGATGCCCTGTAGTTATC +TGTAGTCATTTCATTAACCCTCACTAAAGGGAATAAGGGATACTTAAAGGGGGGAATTAG +GGATTTAATAAAAGATTAAAATTAATGGTTGACTTTAAGTAATCCTTAAGGCTATTATTC +ATCACGTCAACGGGACAACGGCCTTAAAGCCACTCCCTGAGATACCGGAGTCAACCGGAT +AAGTAGACAGCCTGATAAGTCATACGAAAAACAGGCATTGACAACGCAAGGTAACAAGTA +GTAAGATGCACAACATAGCGTCAACCACCAAGTCGGTGTCTTCTAGGTGACTTAAGCGCA +CCACGGCACATAAAGCTAAACAAAATGGTTGGCAACATGAAGTAAACACGGTACGATGTA +CCACGAAATGACAGAACAGTGAGGCGGGACACTGAAAGCCGCTAGGGTCTAACGAAACCA +GACCGACACGCAAATCATAGTAGGTTTAATAAGCGGTAAGTGTATTACTTCCCTTGTGTG +CCGCCGAATGGCATCAGTACACACGACAGGCAGTACGGAAAGTGACACGATGCAGTGCTG +CCATGATTTGATCGCTCTTTAACAATCTGGATAATAGCTCTTGAGTGTACCGATGTATAA +GCGAATAACTCAAGGTCGCACTGAAAGCGTGGCCTTTATGATATTCACTTAACACCAACT +AACATGAGGTAACACCAAATGATTTTCACTAAAGAGCCTGCTAACGTCTTCAATGTACTG +GTGTCAGCTTTCCGTTCTAACCTTGATGATGAGGTGAACATGAGCCGCCACCGCCACATG +GTAAGCACTTTACGTGCCGCACCGGGTCTTTATCGCTCCGTTGAGTCAGCCGATTTGACC +GGGTGCTAGCGTGAGAAAATCGCAAGCGCACCGACTGAGGAAAAAACGGTTCGTGTACGC +TGCAAGGACAAGGCGCAGGCGCTGAATGTTGCACGCTTAGCTTGCAATGAGTGGGAGCAA +GATTGCGTACTGGTATACAAATCACAGACTCACACTGCTGGTCTCGTGTACGCTAAAGGA +ATCGACGGTTACAAGGCTGAACGTCTGTCGGGTAGCTTCCAAGGAGTACCCAAAGGCGCA +CCGCTGCAAGGCTGCTTTACGATTGACGAGTTCGGTCGCCGCTGGCAGGTGGCCTAACAT +GAATCGTTATTACATCAACGTACCGGGCTGGGGTGGGTCTCTGACCTGCTACGGATACAA +CGAACGGGACGCACGGAAACGCTTTAGAGAACAACACGGCTTCGGAAGGCTTCCTAATGG +GACGCACCTATGGCTGGACTCCCGTGATTGGTAAGTGATAGACTCAAGGTCGCACTGTAT +GTGTGGCCTTTATGATTATCACCTATAGGACTAACACCATGAGTAAACTTCTGGCAACAT +CTAAAATAGAAGGCCAATGCACCGTAACACTGCGTGAGTATTACCACGGGTCAATGGGAA +GCACCTATGTTGTGCGATACGGTAAACAGGTCACACATTGGGTAAACCCGATTTTAGCAC +AAGAGGATTATCAAGCCTGTGTGATACACCAAGCAACATGTGCGGGCTGGAATGATTGAT +ATTACAGGAGGATTAGGAATGGTTATCTTTATCGCTGTCGCACTCTTTGCGGACGCTGGC +TGGTACTCTGAGTCACGCAAGGCCGCTCGCTATCATCGCAAGATGGTTAAACTCATGGAA +CACTTGGACGCAGAAGGGCGAGGCCGCGAGGCTATCGAACTGGCGAAACACGCATGATGA +TTCTCTCTATCGCACTGGTCTATCTGTGCATCGCAATGTACTTTATGCGAGACTTTAAGC +GCGGTCTGGCAATACACAAGGCAACGCTGAGTTACTTTAAGCGCGGTCTGGCAATACACA +AGGCAACGCTGAGTTACTTTAAGTGGGGATTCATCCCACGGTTTACGGTTCCTGAACGCA +ACGGACGCTTTAAGGCCAACAAGGTAGGAGTATTCTACATTGCTACGCACTAACTCAAAG +CACGTAAAGACCGCACTGTATGCGATGGCGTATGGTGCATCGAAACGCAAGGTCAAACGC +ATCTTAACGAGACACCGCAAGATGACCGGACGATAGGCTGCAAGCGCTGTCAAATGGGCT +GAATTTACTCTTTACTCTTCTTACAGATAACAGGACACTGAACGATGACTTTCACCGAAG +CACAAGCCGGACTCGAAGCTATCCGCAACCTACCGATTGAGCGCCTGAACGAACGCCAGC +CCATGCTGGTGGCTCTTGCGGCTGCTATCGTGAACGCTGAGACCCAAGACGGCGAACTGA +CGCAGGCCAAGGGTAACTGGGGTCTGGAGTCTATGGACTACTGGCAGACACTGGCTGAGC +GTATGCGTGATGTTGGATTTGTACGCTTGGGCAACGGTCACTTTAGCGCAGCATATGAGC +ACGCATTGTTACCGGGCAAGGTTATCAAGGTAGGCTTTAAGAAAGAGGATTCAGGCGCTG +CCTATGCCGCATTCTGCCTCTATGGACTACTGGCAGACACTGGCTGAGCGTATGCGTGAT +GTTGGATTTGTACGCTTGGGCAACGGTCACTTTAGCGCAGCATATGAGCACGCATTGTTA +CCGGGCAAGGTTATCAAGGTAGGCTTTAAGAAAGAGGATTCAGGCGCTGCCTATGCCGCA +TTCTGCCGTATGAATCAGGGTCGTGAGGGCATCCCTACGGTGTTCGACATTCAGCGTCAT +ACAGGCTGCTACACGGTGGTCTTGGACTATCTGACACCGCTTAATGAGTGGTGCTACGGT +GAAAGTGATAAGATTCGTCACCACTTTCAGGCTGCACAGGAAATCATTCAGGAGGATTGC +TTCGATACCGCCGAAGAGTACCCGATAAGCGAGGGCTTCATTGAGACCTGCAAGGATATC +CGCAAGTTCTTCTTAGGCATCGCATCGTTCTATTGTCACAGCGGGAACATGATGAAAGAC +CAGATGGGACGCCGGATAATCACAGACCCGGTATCATTCAGCGCAGACGACAAGTTAAAG +CCGGGTGAGTTCCACTGTGACCCGGATGAACTCATCGCTGAGATTGAGGCGCTGAGAGCG +CAGGAAGCGTTTGACCGCTGTAAGGCAGGCAAGGCACGCCGTGACCCTAAAGGAGACTTT +CAGGTAGCACGTAAAGCCCGTGCCAAGTGGCGCAGAAAGGCCTCTAAGCGCGAGTAGCGC +AACGCTAAGGTGATCGATAAGATGCGCATGGATGCTAATCAGAATCGCAGGGATGCGCCT +AGGGCGCGTATGGTGTGGGGCGATAAGCACTAGCGTAACGCTTGGATGCACCACAATAAC +CTAAACTTTGCAGAACTGGAGCGCCGCGCTTCTGCGGCAATGATGATGCATGACGAGGTG +CGCATTCAGTGAGGCAAACCGTTACACATAGACGCATACCTTGACAAGCGTCTACAAGGC +TGATAGAGTCCTATCTTACAGGTCATCAATCGGTGGCCTGAATAGGTACGATTTATTCAC +AATGAGGTAAGCAATGAACATCATCGAAAACATCGAAAAGAATGACTTCTCCGAAATCGA +ACTGGCTGCTATCCCGTTCAACACACTGGCAGACCACTACGGCAGCGCATTGGCTCGTGA +ATAACTGGCTTTAGAGCATGAGTCTTATGAGCTAGGCGAGCGCCGCTTCCTCAAGATGCT +TGAGCGTCAAGCGAAAGCTGGTGAGATTGCAGACAACGCAGCCGCTAAGCCATTACTCGC +TACGCTTCTCCCTAAGTTAACCGCACGCATCGTTGAGTGGCTCGAAGAGTACGCCTCGAA +GAAAGGCCGCAAGCCAGTAGCCTATGCACCGCTCCAGTTACTCAAGCCGGAAGCCTCCGC +GTTTATCACACTCAAGGTCATCCTTGCGTCACTGACCAGCACGAATATGACAACTATTCA +GGCCGCTGCTGGTATGCTGGGGAAGGCCATTGAGGATGAGGCACGTTTCGGTCGCATCCG +TGACCTCGAAGCGAAGCACGTCAAGAAGCACGTTGAGGAACAGCTTAACAAGCGCCACGG +GCAAGTCTACAAGAAAGGCTTTATGCCGGTGGTCGAGGCCGATATGATTGGTCGCGGGCT +GCTGGGAGGTGAGGCGTGGTCTAGCTGGGATAAAGAAACCACGATGCACGTAGGGATTCG +CCTGATTGAAATGCTGATTGAATCCACAGGTCTGGTGGAATTACAGCGCCACAACGCAGG +TAACGCAGGCTCTGACCATGAGGCATTGCAACTGGCCCAAGAGTACGTGGACGTATTAGC +GAAGCGTGCAGGCGCTCTGGCGGGTATCTCTCCGATGTTCCAGCCGTGTGTTGTACCGCC +GAAACCTTGGGTAGCAATCACCGAGGGCGGCTATTGGGCTAACGGTCGCAGACCTTTGGC +ACTCGTCCGCACGCCCTCTAAGAAGGGACTGATGCGCTATGAGGATGTTTACATGCCAGA +AGTTTACAAGGCGGTCAACATCGCACAGAACACCGCATGGAAAATCAACAAGAAAGTTCT +TGCGGTTGTCAATGAAATTGTTAACTGGAAGAATTGCCCGGTCGCAGACATTCCATCGCT +GGAGCGCCAAGAGTTACCGCCTAAGCCGGACGACATTGACACCAACGAGGCAGCACTCAA +GGAGTGGAAGAAAGCCGCCGCTGGTGTCTACCGCTTGGACAAGGCACGAGTGTCTCGCCG +TATCAGCTTAGAGTTCATGCTGGAGCAGGCCAACAAGTTCGCAAGCAAGAAAGCAATCTG +GTTCCCTTACAACATGGACTGGCGTGGTCGTGTGTACGCTGTGCCAATGTTCAACCCGCA +AGGAAACGACATGACCAAGGGGCTGCTGACCCTCGCTAAAGGCAAGCCAATCGGTGAGGA +AGGTTTCTACTGGCTGAAAAACCAGGGTGCGAACTGTGCGGGTGTCGATAAGGTACCTTT +CCCTGAGCACATCGCGTTCATTGAGAAGCACGTAGACTACATTCTGGCTTGCGCTAAAGA +CCCAATCAATAACACTTGGTGGGCTGAGCAGGATTCACCGTTCTGTTTCCTCGCGTTTTG +CTTCGAGTATGCAGGCGTTGAGCACCACGGTCTAAGCTACAATTGCTCTCTGCCGCTGAC +GTGCGATGGGTCTTGCTCCGGTATCCAGCACTTCTCCGCGATGCTCCGCGATGAGGTAGG +CGGTCGTGCGGTTAACCTGCTGCAAAGCGAAACCGTGCAGGACATTTACGGCATCGTTGC +ACAGAAAGTAAACGAGATTCTCAAACAGGATGCAATAAACGGCACACCTAATGAGATGAT +TACCGTGACCGACTAGGACACCGGGGAAATCTCTGAGAAGCTCAAGCTGGGAACCTCAAC +GCTGGCGCAACAGTGGCTGGCATATGGTGTAACCCGTAGCGTAACTAAACGTTCGGTCAT +GACGCTGGCTTACGGTTCCAAGGAGTTCGGCTTTCGTCAACAGGTTCTGGACGACACCAT +TCAGCCTGCGATTGACAGCGGTAAGGGCTTGATGTTCACCCAACCTAACCAAGCGGCTGG +TTATATGGCTAAGCTGATTTGGGACGCGGTGAGCGTGACCGTAGTCGCAGCGGTTGAGGC +GATGAACTGGCTCAAGTCTGCCGCTAAGCTGCTAGCTGCTGAGGTCAAGGATTGACAGCG +GTAAGGGCTTGATGTTCACCCAACCTAACCAAGCGGCTGGTTATATGGCTAAGCTGATTT +GGGACGCGGTGAGCGTGACCGTAGTCGCAGCGGTTGAGGCGATGAACTGGCTCAAGTCTG +CCGCTAAGCTGCTAGCTGCTGAGGTCAAGGACAAAAAGACCAAGGAGATTCTTCGCCACC +GTTGTTCGGTTCACTGGACTACGCCGGACGGATTCCCGGTCTGGCAGGAATACCGCAAGC +CACTCCAGAAGCGTCTCGATATGATTTTCTTAGGGCAATTCCGTCTGCAACCGACGATTA +ATACCCTCAAGGATTCAGGCATTGACGCACAAAAGCAGGAGTCTGGCATCGCTCCTAACT +TTGTTCACTCACAGGATGGTAGCCACCTCCGCATGACGGTCGTTTATGCTCACGAGAAGT +ATGCCATTGAGTCCTTTGCGCTAATCCATGACAGCTTTGGGACTATTCCGGCAGACGCTG +GTAAGCTCTTTAAGGCTGTGCGTGAAACGATGGTTCTCACCTACGAGAACAACGATGTGT +TGGCAGACTTCTACGACCAGTTTGCAGACCTGCTTCATGAGACCCAACTGGACAAGATGC +CACCACTTCCGAAGAAAGGTAAGCTGAACCTACAAGACATTCTCAAGTCCGACTTTGCCT +TTGCATAACAAGCACTTAGCATTAACCCTCACTAACGGGAGACTACTTAAGGTCTCCCTT +AAGGTACTAAGAGATTTTAATTTAAGATAACTAAGAGGTTTACTTTATGATTACTTTATG +TGTCGCAATCGTTCTTATCGCTACACTCTTGCATAACAAGCACTTAGCATTAACCCTCAC +TAACGGGAGACTACTTAAGGTCTCCCTTAAGGTACTAAGAGATTTTAATTTAAGATAACT +AAGAGGTTTACTTTATGATTACTTTATGTGTCGCAATCGTTCTTATCGCTACACTCTCAA +TCGTCATCGCTAAGCAGCGCTCTGAGTTAATCAAGCTGGATGCCCGATATGATAGTGCGA +ACCACCACCGGAAAGAACTGGATGCAGCACTTGGGCGGTCAACCGATGAGGTTAAGACCC +TTAAGCGCCAGCTACAGCACGCCGAGCAAGACGATAAGAACCGCTGCGAAACAATCCGAG +GTCTACGTGAAGAACTCCGGGAGTTGCGCCAGACGATTAAAGAGCGCCACGCTATCCACG +GCATCAAGTTCGTAGCGAACGTTCCGATGAAGGGCTGGACGCCCACCGAGTTTAAGCTGG +GTCTTGGTAAATGCGGTCTGGAAGTGGCGAGTCTAGTGTGGGAAGAGAAGTCTGACCGCT +ATGTGTTGACTCAACGCCACACCGACGGAAGCCGAAAGGTCTTTGAGTACAAGAAGGAAG +ACGTGCAAGGAAGAATCGAAGTGTTCTACCCTGCCGTTAAATAACCCTCACTAACGGGAG +AGTTAGCCTCAAGGTCATCACCGACGGTGGCCTTTGTGATTAACTTTCAATACACATCAA +CATGAGGTAAGATACTATGCGTACCAACTTTGAGAAATTTACCAAGCGCGATTCAGTGGT +CAACGAGCATGGCGAACAGTGGCAAGAGCGCCGTGACCGCATGAAGAAACGCCACAAGCA +ACAGCGCGGTAACTCACAGAAACGGGAGTAGAACTAATGATGATGGGACGTGTCTATAGC +GGCAACCTGAACGATTACAAAGATGCCGTAGCGCGTCTACGGGAAGACCATGACGTGCCC +GTGAAGGTGGAGTCATTCAGCTATGAAAACCCAGCGAAGATGTGCAGGTCATCCGGTGAG +GTTCTCCGTGTGTTCACACGCTCCGGGCATCCGGTCGCATCCAGAACCTTCGAGCACAGC +GACAGTGATGTACAAATCAACGCGCAGACTGCATGGCTCCGTAAGGTTCACAGCGATTTG +AAACACTGGAAGTAATAACCCTCACTAACAGGAGAATCCTCAAGGTCATTTTAATTGGTG +GCCTTTGTGATTCGAACTGATTAACTTTCAACCAATGAGGAACAACCGTATGAACATCTT +CAAGACCAACCCATTCAAAGCTGTGTCATTCGTAGAGTCTGCCGTTAAGAAAGCGCTGGA +GACCTCCGGCTACCTGATTGCGGACATTAAGTATGATGGCGTGCGTGGTAACATTGTGGT +TGACAACGTGGCTGAGGCCGCATGGCTGTCCCGTGTGTCCAAGTTCATCCCGGCGCTGGA +ACATCTGAACGGTTTCGATAAGCGCTGGCAACAACTGATGAATGATGACCGCTGTATTTT +CCCTGATGGCTTCATGCTGGATGGCGAACTGATGGTTAAGGGCGTAGACTTCAACACAGG +GTCTGGCCTACTGAGAACCAAGTGGCTCAAGAAGAACAACTTCATGTTTGACCGTGGTGC +TTCATGCTGGATGGCGAACTGATGGTTAAGGGCGTAGACTTCAACACAGGGTCTGGCCTA +CTGAGAACCAAGTGGCTCAAGAAGAACAACTTCATGTTTGACCGTGGTGGTGTTGAGCCA +CTGAAAGGTTCCAAAGTAGCCTTTGAGTTAGACCCCAAGCTACTCAGTGTTCGCCTGTAT +GCTGTCCTTCCGATTCACATTGCGGCGTCTGGCGAGGACTACGATGTACAGAACCTACTG +ATGCCATATCATGTGGAGGCCATGCGCTCTCTTCTGGTTGGATACTTCCCGGAAATCGAG +TGGCTTATCGCTGAGACCTACGAGGTCTACGATATGGATTCGCTGAATGAACTGTACGAA +GAGAAGCGTGCCGAAGGTCACGAGGGTCTCATTGTGATAGACCCACAGGGCATCTACAAG +CGAGGCAAGAAGTCTGGCTGGTGGAAGCTCAAGCCTGAGTGTGAGGCTGATGGTATCATT +CAGGGTGTCAATTGGGGAACCGAAGGTTTAGCCAACGAGGGCAAAGTGATAGGCTTTAGT +GTGCTTCTTGAGACTGGTCGTTTAGTAGACGCCAACAACATCTCTCGCGCACTGATGGAC +GAGTTCACAGCCAACCTTAAGGCACACGGCGAAGACTTCTACAACGGGTGGGCCTGTCAG +GTCAACTAAATGGAAGAGACCCCGGACGGCTCCCTGCGTCACCCTAGCTTCGAAAAGTTC +CGAGGCACTGAGGACAACCCTCAAGAGAAAACGTAACCAACTCACTGGCTCACCTTCACG +GGTGGGCCTTTCTTCGTTCTAGGGAATTAACCCTCACTAACAGGAGACACACCATGTGAC +TTATCCTATTCGCTATCGTCGCAACGCTGGGATTAATGGTTGCCGACGACGACATTTGGC +CTGATTCTTAAGGAGACAACATCATGCGTTTACACTTCAACACATCAAATGGTATCTTTT +CGGTTCGCCGTGAAGACCGCTCTACAGCAGTGGCCTCTGAGCGCAACGCTAAGCTGCCGC +TGATTGGCTCGGTCGTCCCATTGTCGCCTCGTGTTCACCTACTGATCACTCGTGGAGAGT +TCATTAAGGCGATGAACAAAGAGCGCCCGCATCTGGAAGCCGTTGTCACTTGCTGGCCTC +GCATCCGTCTGTTCGTTAAGTGGATTAAGGAGGTTCTGTAATGTTACAACATCATTGGAA +CAAACCAGATTTAGAGGCTCGCTTCCCGGTTAACTCTGCTGTGCGATACTCCGGCGACTT +CCTCAAGCGCTTCTTAGGTATGAGCGGAGTGGTCACCGGTCACTCGAACACAGGTCGCGT +TAAGGTTCGCTTCGGTAATCAGCACGCTGAGTTTCTTCCGAACAACCTGATTCCGCTGCC +TAAAGATGACGTTAAGACTCCGAACATGGAGGCACCGAAGTCAGAAGTCAAGTCTGACGT +AACCCACCCTAACCACTACATGCTGTTCGACAACGTGGAAGCCATTGAGGTTATAGCCCG +GTCAATGACCGTCGAGGCGTTCCGTGGGTACTGCCTTGGGAACATCCTGAAATACCGTCT +TCGTGCTGGTAAGAAATCCGAACTGGCAACTATGGAGAAAAACCTCAATAAAGCTGCATT +CTATCAGGAACTCTTTGACAAACATAAGGGGCTGTGCTATGACGCTTCGTGAATGCTGCG +ATTGGTGTGCCGCTAAGTGGAACCAAGGTATTGAGGATGGTGACAAGGCGGCTGCTGACG +CTTACCAACAACTGTACGCGCTGTGGGAGCGGCGCTTTAAGGAGGCTCAAAGTGGAGCAA +CGTGAACAGAAATACCTTGTGACGATAGAAGGCAACACCGAGTCCTTTGAGGTTCCGGTA +TTCGCCCGGTCTCTCGAAGAGGCAACGCTACAGGCTGAACATTATAAGGACGCTGGGTTC +GTAGTGACTCGCATCCGTCCAGAAGTGAAAGCCTAATTACCCTCACTAAAGGGAACAACC +AAATCATTAACCACAAAGGAGAAACATTATGGCTGGTTTCAAGAAGAAAATCTACCCCTC +TGGTCTTGGCACTGCTGAGCCTTATGCTTACCTGAGTAAGCCGGATTATGGCAACGCAGA +GCGTGGCTTCGGCAACCCTCGTGGTGTCTATAGGGTAGACCTGACTCTTTCCAATAAAGA +CCTGCGCTGTCAGGCGGTGGTCGACGAAATCGTGAAGACTCACGAAGAGGCTTATGCTGC +TGCCGTGGAAGAGTTCGAAGCTAACCCGCCGCAGGTACAGCGTGGTAAGAAACCACTGAA +ACCTTACGAGGGCGACATGCCGTTCTTCGATAACGGTGACGGTACGACTACCTTCAAGTT +CAAATGCTATGCGTCTTTCCAAGATAAGAAGACCAAAGAGACCTAGCACATCAATCTGGT +CGTGGTCGATAGCAAAGGTAAGAAGATTCAGGAAGTGCCGATTATCGGTGGCGGCTCCAA +GCTGAAAGTGAAATTCTCTCTGGTTCCGTACAAGTGGAACACCGCTGCGGGCGCAAGCGT +CAAGCTGCAACTGGAGTCCGTGATGCTGGTCGAACTGGCTACCTTCGGCGGTGGCGGTGA +AGATGAGTGGGCTGATGAAGTCGAAGATGGTGGTTACACTGCGAGTGAATCCCGTCAGTC +CCGCGATGAGCAGGAGTGGCAGGAAGACGAGCACGAAGAAACCCCGGATGATAACGAGGA +CTTCTAATGGCTGGCGCATACGCTGCGCGAGGTGTACGCAAGGTCGGGGCTTTCCGCTCC +GGCCTAGAAGATAAAGTCTCAAAGCAGCTTGAGAGTAAGGGAATTAAGTTCGACTATGAG +CTTTGGCGTATCCCTTACGTCATCCCTGCGAGTGACCACTTATACACTCCAGACTTCCTG +CTACCTAATGGCATATTCATTGAGACCAAAGGGCTGTGAGATTCCGATGACCGCAAGAAA +CACCTTTTGATTCGTGAGCAACACCCTGAACTGGATATTCGCTTGGTCTTCTCAAGCAGC +CGCTCAAAGCTCTACAAAGGCAGCCCAACAAGCTACGCCGAGTGGTGTGCGAAGCATGGC +ATTCTGTCTGCTGACAAGCTAATTCCGGTGGAGTGGCTCAAAGAACCCAAGAAGGAGGTT +CTGTTCGATAAATGTAAGACTAAGAAAGGAGTAAAGAAAAATGGCTAAAGTTCAATTCAA +ACCACGAGAAACCACGGAGGCAATCTTTGTACATTGCTCAGCAACCAAGCCAAGCCAGAA +CATTGGCGTTCGTGAGATTCGTCAGTGACACAAAGAGCAGGGCTGGTTAGACGTAGGATA +TCACTTCATCATCAAGCGTGATGGCACTGTGGAAGCAGGCCGCGATGAACGGGCTGTAGG +TTCCCACGTGAAAGGTTACAACCACAACTCCGTAGGCGTATGCCTCGTGGGTGGGATTGA +TGATAAAGGCAAGTTCGACGCCAACTTTACACCTGCGCAAATGCAAGCGCTGCGTAGTCT +GCTGGTCACGCTGCTGGCGAAGTATGAGGGTTAAGTCCTTCGTGCTCACCATGACGTTGC +ATCCAAAGCCTGCCCGTCCTTCGACTTGAAGCGCTGTTGGGAGAAGAACGAACTGGTTAC +ATCTGACCGAGGGTGATACCATGAGGATAATTTGTATTCGCTGTGATAAGCCGTTGAAGA +GTCGTGTACCGTCAGGTCAGTGTCAGTGCAAAGACCCAATCAAGGCGGAGGAACGCACCG +AGGAATAATTAACACTCACTAAAGGGAGACTTAACGGTTTCCCTTTGTTCGCACTATTGA +TTAAGGAATGTACAATGGAACGAGAAGACGATAGTATCTTTCTGTTTCATGCTCCATGTG +AAAGCTGTGGGTCTTCTGATGGTAACTCTGTGTACTCTGACGGGCATGAATGGTGCTTCG +TGTGTGAACATCGAGTACCCGCAAACGAAGAGCGTGACGCAAAGTTATCAATGAGAAGAC +GTACAGGAGGCAGCAAGCCTATGAGCTATGACGTATGGAATTTCGGTGACAGCAACGGCC +GATACTCTGACCTGACTGCCCGTGGCATCTCGAAGGAGACATGCCAAAAGGCTGGCTACT +GGCTGGCGAAAGTGGACAACCGAATGTATCAGGGTGCCTACTACCGAGACCAGAACGGCT +CCATCGTGTCGCAGAAGGTGCGCGATAAGGACAAGAACTTTAAGACCACCGGAAGCCACA +AGAGCGATGCGCTGTTCTTGAAGCACCTCTGGTCTGGCAGTAAGAAAATTGTGGTCACTG +AGGGCGAAATTGATGCGCTCACTGTGATGGAACTCCAAGACTGTAAGTACCCGGTCGTAT +CATTAGGTCACGGTGCCTCTGCTGCTAAGAAGACATGCGCCGCTTACTATGAATACTTTG +ACCAGTTCGAGCAGATTATCTTGATGTTCGACATGGATGACGCAGGCCGTAAGGCAGTCG +AAGAGGCGGCACAGGGTCTCCCGGCTGGTAAGGTTCGTGTTGCCGTGTTGCCGTGTAAGG +ACGCCAACGAGTGTCACATCATGGGTGAAGACAAAGCAATCTTGGAGCAAATCTGGAACG +CGAACCCTTGGGTGCCTGACGGTTTTGTTTCTGCGTTGTCACTCAAAGACCGCATTAAGG +AAGCTATGACCTCCGAGCACGCTGTAGGTTTATTATTCGATGGCTATCAAGGCCTGAACG +ATAGAACCTTGGGTGCTCGTGGTGGCGAAGTCGTTATGGTCACTTCCGGTTCCGGTATGG +GTAAGTCAACGTTCGTTCGTTAACAGGCTCTGGCTTGGGGCAAGCGAATGGGTAAACTTG +TGGGCCTAGCGATGTTGGAGGAATCCGTTGAGGATACCATTCAGGACATGATGGGCTTGA +ACAATAAGGTTCGTCTGCGTCAGTCTGATGAAGTCAAGAAGGCTATCGCAGAGGACGGAC +GTTTCGATGAATGGTATGATGAACTATTTGGAGACGATACGTTCCACCTCTATGACTCCT +TTGCGGAGGCCGAAGCTGACAGGCTGTTAGCGAAGCTGGCCTACATGCGAACAGGCTTAG +GGTGTGATGTTATAGTGCTCGACCGCATATCGATCGTCGTGTCTGCCTCTGAGGAATCGG +ATGTGAGTAAGATGATTGACCGCCTCATGACGAAGCTCAAAGGGTTCGCTAAGTCAACTG +GTGTTGTGCTCGTAGTGATTTGTCACTTGAAGAACCCGGAGAAGGGAAAACCACATGAAG +AAGGACGCGCTGTTTCTATTACTGACCTACGTGGTACCGGTGCCTTGCGTCAGTTATCTG +ATACTATCATCGCCTTGGAGCGTAACCAGCAAGGTGATATGCCTAACTTGGTGTTGGTTC +GCCTGCTTAAGTGTCGTTTCACTGGCGACACTGGAATTGCTGGGTACATGGAATACAACA +GAGAAACCGGGTGGCTTGAACCGTCTAGCTACACTGGCGAAGAAGGAGAAGGAGATACTG +GCTGGTCTGAACAAGACGGACAATCAGACTTCTAAAGGATGCCCGTGTGGGCATTCAGAT +TGCGATGGAACCATGTACCACTAATTAAACCTCACTAACGGGAACAACCATTAAACCATA +GGAGACACATCATGTTTAAATTCATTAACGCTTTAGGTAAGCTGGTAGTTAAACTGTACT +TCATCGAAGCCAAGAAGCTGGACAAGAAGGCCAAAGCTGATTCACAGCGAGCCATTGAGT +TGGCGAAACAGTCCCGTGAGAAATCCGATGCGGCTGTTAGTGGCATCCACAAGTCGGCAG +CGATTGCAGCCAAAGCACAATCCATGAGCAAATTCTTTGAGTAAGGAGCACACACTATGA +GCAAGTCAATCACCCACGCAAACACCATCCGTCTGCCAGACACCGCTGACCAGTTCTCCC +GCCGAGTACACATAAATGTGCGTGGTGAGAAGGTCACGATGGTCTACCGCTGGAAAGACC +ACAAGTCTCCGAAAGCACACACTCAACGAATGACCTTGGATGACAAGCAGGTCGGTCGCT +TGATGGGTGCCCTGACTATGGCTGCTGACAAGGTGGTCGGTGATAACCGTGAGCGTCTGG +TAGAGTTCGGCGCTGGTATGCAAGAGATTATCGAGAAGTGATAAACTCAAGATCGCCCAA +GGGTGGCCTTTATGATTATCATTTAGCACGAAACCAAAGGAGGGCATTATGCTCGTAAGT +GACATTGAGGCCAGCAACCTCTTAGAGAAAGTCACCAAGTTTCACTGTGGCGTTATCTAT +GACTACCGTGATGGTGAGTATCATAGCTATCGTCCGGGCGACTTCGGGGCGTATCTGGAT +GCGCTGGAAGCCGAGGTGAAGCGAGGTGGGCTTATTGTTTTCCATAACGGTCACAAGTAT +GACGTTCCGGCTTTAGAGAAACTCGCAAAGCTGCAACTCAATCGTGACTTCAAGTTACCC +CGTGAGAACTGTATTGATACATTGGTACTCTCGCGTTTACTTCATGCGAACCTTAAAGAC +ACAGACATGGGGCTTCTTCGCTCCGGGAAACTACCCGGTCGTCGCTTCGGGTCTCACGCT +CTCTCGCGTTTACTTCATGCGAACCTTAAAGACACAGACATGGGGCTTCTTCGCTCCGGG +AAACTACCCGGTCGTCGCTTCGGGTCTCACGCTCTGGGGGCATGGGGCCATCGCTTGGGT +GAGATGAAAGGTGAATACAAGGACGACTTCAAGGCTATGCTGGAAGAGCAGGGCGAAGAA +TATGTTGATGGTGCTGAGTGGGTTTCGTTCAACGAGCCGATGATGGCGTATAACGTTCAA +GACGTTGTGGTCACTGTCAAACTCTTAGAGAAATTCCTTACAGACCTCCAATACTTCCCT +GCGGGTATGGACTTCACGAAGTACGATGCGGATTTATTCTGGCGAGAAGCTGGCGAGCCT +GTGGATATTGAACATCGTGTAGCGTGGCTTTTAGCGAAGCAGGAGCGTAACGGCTTCCCG +TTCAACACCAAGGCAATTGAGGAACTTTATGTAGAACTGGCAGCGAAACGCGCCGAACTT +CTGCAAAAGCTAACCGAAACGTTTGGCTCATGGTATCAACCGAAAGGCGGTAAGGAACTC +TTCAAGCACCCACGGACAGGCAAGCCGCTGCCGAGCTATCCTCGCGTGGTCTATCCGAAA +CAGGGTGGCGTGTACAAGAAGCCTCGTAATAAGGCACAGCGCGAAGGTCTTGAACCTTGC +GACTTGGACACGAGGGATTACATGGAGGGTGCTCCATATACTCCGGTAGAGTTCGTTACG +TTCAAGCCAAGTAGCCGTGACCACATTCAGAAGAAACTACAAGAGGCCGGATGGGTTCCT +GAGAAGTTCACCGAGAAGGGTGCGCCTGTGGTGGACGATGAGGTCTTGGAGCATGTAAGA +GTGGATGACCCTGAGAAGCAGGCGTGCATTGACTTGATTAAAGAGTACCTGATGATTCAG +AAGCGAATCGGTCAGGCGGCAGAGGGTGACAAAGCGTGGTTACGTTATGTTCAAGATGAT +GGTAAGATTCATGGAGCCGTTAACCCTAACGGTGCAGTTACTAGTCGTGCTACTCATAGT +TTCCCAAACCTTGCACAAGTACCCGGCGTTCGTTCTCCTTACGGGGAGCAGTGTCGTAGC +GCTTTTGGTGCTGAACATCATTTGGATGGGATTACTGGCAAGCCGTGGGTGCAAGCGGGG +ATAGACGCCAGTGGCTTAGAGTTGCGCTGTCTGGCACACCTCATGGCTCGTTTCGATAAC +GGAGAGTATGCGAATGAGATTCTCAACGGTGACATTCACACCAAGAACCAGAACGCTGCG +GAACTCCCAACGCGTGACAACGCCAAGACCTTCATTTACGGGTTCCTTTACGGAGCAGGA +GATGAGAAGATTGGTCAGATTGTTGGGGCAGGGAAGGAGCGCGGGAAGGAACTAAAGAAG +AAATTCTTAGAGAACACCCCGGCGATTGCAGCGCTACGAGAAGCTATCCAACAGTCTCTC +GTTAAGTCTTCCGCTTGGATTGGCGCTGAGCAGAAAGTACAGTGGAAGCGCCGTTGGATT +AAAGGTCTGGATGGTCGCAAGGTTCACGTCAGGTCTCCACACGCAGCGCTCAACACATTG +TTGCAGTCTGCTGGTGCTCTGATTTGTAAGTTGTGGATCATCAGGACCGAAGAGATGCTC +ATTGAGAAAGGCTTGAAGCATGGCTGGGATGGTGACTTTGCGTAAATGGCTTGGGTTCAC +GTTGAGATTCAGGTGGCCTGCCGTACAGAGCACATCGCTCAGATTGTTATTGACACCGCG +CAGGAAGCTATGCGTTGGGTCGGAGAGCATTGGGCTTTCCGTTGTCGTTTAGATACCGAT +GGTAAGATGGGGCCGAATTGGGCTGTCTGCCACTAACAATAGGAGAAACATTATGGCAAT +GACCAAACACTTTAAAGTAACCTTCGACGTTACCGCTGTGATTGACAGTGAATCCGAGAA +GAATCTGAACGAGTTGCTGGTAGACCTAGCTAAGAAGGCCGGGGCTGGCGAGAAGCTGAA +TCCGTTCAAACAAGAACTGCTTATTCAAGGCCTGACACACGGGCCGGAAGGTGCTGCTGC +GTTCTGTATCAAGCAAGGTCTCCGTGAGTTTATCCGCGATGGTCACAGTGAGTTAAGCTC +TACCGAGCGAAGGCCGGGGCTGGCGAGAAGCTGAATCCGTTCAAACAAGAACTGCTTATT +CAAGGCCTGACACACGGGCCGGAAGGTGCTGCTGCGTTCTGTATCAAGCAAGGTCTCCGT +GAGTTTATCCGCGATGGTCACAGTGAGTTAAGCTCTACCGAGCAGAAGCTGATGAGATTC +TCACCTGCAACTGTGCGAGAGGTGTTCAAAGGAGTGAATACCTGAAAGTTCTGGCAGCTA +TCAAAGGTTGCCCTAAGTCCTTTCAGTCGAACTATGTGCGAAACAATGCGGCTCTCGTAG +CTGAGGCCGCTTCTCGTGGACACATTAGCTGTTTGACTGTGGGCGGTCACAATGGTGGAG +CATGGGAGGTAACAGCCTCTGGTGTGCGCTTCTTGAAACGAATGGGAGGTTGCGTATGAT +TATGCCTAAGAGTGACACCGTAACGATGACCCGTGATGCGTGGAACGATGTTAGCGCGTA +CATTGATAAGATGGAGAAAGGCCTAGAGTTCCTGAATGCGCTTAAGGCGTGTGGTGTGGA +TAATTGGGACGGATACTCTGATGCAGTCGAAATGGTTTACGGGGAGGATGACGAATGAGC +CTAATCATATTGAAAGACTTCGCGGAGATGCGTGAAGGTAATCCTATGGAGAAGGGAGTG +CTGGTCATGGATGGTGACTGGTTGGTATATCAGTCAATGGCTGCTGCCGAAGTTGAGACG +GATTGGGGAGACGACATTTGGACTCTTGAGTGTGACCACGCCAAGGCACGGAGCATTCTC +GATTCTGCAATCGAATCGTACCGAACCCGTAAGAAGGCTTGGAGTGACGCTATGGTTGTT +CTGGCATATACCGACGATGTGAACTGGCGTAAGGTACTGGTTGATGAGACCTATAAGGAG +AACCGTAAGGCGACCCGTAAGCCTGTGGGCTACCGTGACTTCCTGTCGAAGCTGTGGGAG +CGCGATGAGTTCATTCACATTAAAGAGGACATGCTAGAAGGTGATGACGTTATGGGTATC +ATTGGGTCTGGTCACGAGGTCTTCGGCTTCAAGAAAGCTGTGTTGGTTTCCTGTGATAAG +GACTTCAAGACTATACCGGACGTTGACTTCCTGTGGTGTACCACTGGTAACATCTTGACG +CAGACCAAAGAGACCGCTGATTGGTGGCATCTCTTCCAGACTATCAAGGGCGATATGACT +GATGGCTACTCCGGGATTCCCGGTTGGGGTGACACGGCAGAAGGTTTCCTGAATGACCCG +TTCATTGTGGAGCCTGTAGAGTCCGTGCTGAAGTCCGGTAAGAACAAAGGGCAGACTGTC +ACTAAGTGGGTGAAACGCGCTCCTGATGCGACTGAGAGCCTGTGGGACTGCATCGTATCC +ATCGGTGCCAAAGCTGGGATGACTGAACAGGAAATCATTAAGCAAGGCCAGATGGCACGC +ATACTTCGCTTCGAGGAATACAATTACATTGACAAGGAGATTTACTTATGGACGCCGCGA +AGCTGATTACCATCGCTGTGCTGGTAGGTATGCTGGCGCGAGGTCTCTGGATGTTCGCTC +TCATAGTCCGAGACGCGAAGCGAGACTCCGAGATTAAGTGATACACTCATGGCTCTCTGT +ATTAACCGTCATTAAAGGGAAGAGGGAGCCTTTATGATTATTACTTTAAGACTTAACCTT +AAGAGGTGAATTTATGTTACAACCAATTAATCATGTTTTAACTCATCCCGATGATATTCC +TAGTATGCCGCGTGCAGCAAGAGAGTATCTACAGGTGCGCTTCAATCAGGCTTATGTGAC +GGAGTCCGGGGAGTACCGTGCGCTGCGCGCTGCTGGTTACTCTGAGTCTTTCATTGCGGG +TGTGATGCATGGTCTGTACCTTGCCTCTCGAACACTTGATGAGATTCAGGTGCGTAAAGA +GCAACTGAGACAGGAGCAACGATATGTGCTGGAAACCGAAGGTGAAAGTCCCTAAGATGG +ACACTAACCAGATTCGCGCTGCTGAACCAGCACCTTTGACTGAACCTCCGAAGTCTGTGG +TATGGGGAGGCGATGATGACGAGGGCACCAGTGTGTCTTCCTCTGAGGTGCCAACCACAC +CGAGCAGCGGTAAGAGCAGTCTCAAGGTAAAGCTGGATGACAGCGCAGCCAAGAACAAGA +GTAAATCCTCCATTCGCTCCAAGGCGTTTGGGTAACTGAGTCGTAGCATAGGGAGAAACA +TCATGGGATTCTTCAAGAAAATCAAGAAGGCCGTTAAGAAAGTTGTGAAAGAAGTTAGTA +GACCAGTCGAGAAGGCCGGTAAGGAAGTGGGCAAGGTGGTTGGAGGCGCGCTGGGTGCAA +GTAAGCAGGAGATTATCCAACAAGAGCCTCCTGTACCAGTAGTCGCTGCACCGCCACCAT +CACAGGTTGTAGATGTACCGGAACAGGATAAGGCTGAGGGTGAGGATGAGGCGCAAACCG +AACGCGCACGTAAGAAAGCACGCGCTGGCGGTAAGAAGTCTCTGAGTGTAGCCCGTAGCT +CCGGCGGTGGCATCAACATCTAAGGAGGACTGAATGGCTTATTCAAAACGTACAGGATTG +GGCGAAGACGGTGCTAAAGCTACCTATGACCGCCTAACGAACGACCGTAGAGCCTACGAG +ACTCGTGCGGAAAACTGTGCGCAATACACCATTCCGTCCTGGTTCCCGAAGGAGTCCGAT +AACGAATCTACCGACTACACGACTCCGTGGCAGGCTGTAGGTGCGCGGGGTCTTAACTAT +CTGGCCTCTAAATTAATGCTGGCACTATTCCCGATGCAGTCGTGGATGAAGCTGACCATT +AGTGAATAAGAGGCGAAGCAGCTTGTTGGAGACCCTGATGGACTCGCTAAGGTGGACGAA +GGTCTGTCTATGGATGAGCGTACTATCATGAATTATATCGAATCCAGCAGCTACCGTCTG +ACACTCTTTGAGTGCCTCAAGCAGTTGATCGTGGCAGGTAATGCACTGCTTTACTTACCG +GAACCAGAAGGCAGCTACAATCCGATGAAGCTGTACCGATTGTCTTCTTATGTTGTCCAA +AGAGACGCATACGGCAATGTGTTACAGATTGTCACTCGTGACCAGATAGCCTTTGGTGCT +CTCCCGGTAGACGCTCGGTCTGCGGTAGAGAAAGCTGGTGGTGAGAAGAAGATGGACGGA +ATGGTCGATGTGTACACCCATGTGTATCTCGATGAAGAGTCCGGCGATTACCTCAAGTAC +GAGGAAGTAGAGGACGTTGAGATTGATGGCTCCGATGCCACCTATCCTACTGACGCTATG +CCCTACATTCCGGTTCGCATGGTTCGCATTGATGGCGAGTCTTACGGTCGCTCCTACTGT +GAAGAATACTTAGGTGACTTAAGGTCGCTTGAGAATCTCCAAGAGGCTATCGTTAAGATG +AGCATGATTAGCGCGAAGGTCATCGGTCTGGTGAACCCGGCTGGCATTACGCAGCCACGT +AGATTAACCAAAGCTCAGACTGGTGACTTCGTTCCGAGTCGTCGAGAAGACATTGACTTC +CTTCAACTGGAGAAGCAAGCTGACTTTACCGTAGCGAAAGCTGTGAGTGACCAGATAGAA +GCACGCTTATCGTATGCCTTTATGTTGAACTTTGCGGTGCAACGAACAGGTGAACGTGTG +ACCGCCGAAGAGATTCGATACGTTGCGTCAGAACTGGAAGATACGCTTGGTGGCGTCTAT +TCGATTCTGTCTCAAGAACTGTAATTGCCTCTGGTTCGTGTGCTCTTGAAGCAGCTCCAA +GCAACCTCGCAGATTCCTGAGCTTCCGAAAGAAGCCGGTGAGCCGACTATCAGTACAGGT +CTGGAAGCAATCGGTCGTGGTCAAGACCTCGATAAGCTGGAGCGCCGTATCTCCACTTGG +GCTGCTCTGGCCCCTATGCAGGGAGACCCGGACATTAACCTTGCTGTCATTAAGCTGCGC +ATTGCTAACGCCATTGGTATTGATACTTCTGGTATCCTACTGACTGACGAGCAGAAGCAA +GCACTGATGATGCAGGATGCGGCCCAAACAGGTATCGAGAACGCTGCCGCCACTGGTGGG +GCTGGTGTGGGTGCTCTAGCGACATCAAGTCCAGAAGCTATGCAGGGTGCAGCAGCACAG +GCTGGCCTAGACGCCACCTAATAACCCTCACTAAAGGGAGACCCCATCTTTGAATTGAGC +GATGACTAAAGGTTGGAGTCCTTTGGTTTCCCTTTATCTTTAACAACTTAGGAGATTTAA +CAATGGCTGAATCTAATCCAGACGTTTATGCGTCTTTCAGTGTGAACAACGCGGTAATGA +CCGGAAGCACACCTACTGAACACTAACAGAATATGCTGAGTCTCGATGTTGCTGCCCGTG +ATGGCGATGATGCAATCGTACTTAGCGAGGAACCGAGTTCCCATAACGATGACCCATATG +CATCCGGTGTAGACCCGTTCGCTGATGGTGAAGACGATGAGGGCCGCATTCAGGTTCGTA +TCAGTGAAGATGGTAATGAAGCCGAGTTCGACACCGGTAGCGATAACGCTGAGGTGGAGA +CCGAAGGTGAGGCCGCTGAGTTTGAACCGCTGTGTGACACTCCAGAAGAACTGAGCCAAG +TGACTGAGCAGTTGGGACAGCACGAAGAAGGCTTTCAGGCGATGGTCGAGCAGCCCGTTG +AGCGTGGACTGAGCGCAGAGTCTGTGACTCGCATCTACGAAGAGTACGAAGCCGATGGCA +TCTCTGAGAAATCCTACGCGGAACTCGAAGCTGCTGGCTATAGTCGTGCCTTTGTGGACT +CCTACATCTCCGGTCAGGAAGCCCTTGTAGACCAGTACGTTAATCAGGTAGTTGCCTTTG +CCGGTGGTAAGGAGCGCTTTAGCGCAATCCATACGCACCTTGAAGCAACCAACCCGGCTG +CGGCTGAGTCCCTTGAGACTGCCATGATGAACCGAGACTTGGCGACTGTCAAAGCAATTA +TCAATCTGGCTGGTGAGAGCTACACGAAGAAATTCGGTAAGCCTGCCAACCGTAGTGTTA +CCAAGCGTGCTACTCCGGTTAAACCTGTAGCTCGTCAGAAAGATGGCTTTACGAATCAGG +CTGAGATGATTAAAGCTATGAGTGACCCGCGTTACAGTAGTGATGCTGCCTACCGTCAAA +TGGTAGAACAGAAGGTTATCGACTCCAGTTTCTAATTAACCCTCACTAAAGGGAGAGACC +ATAGATGACTACAATGGTTGAATCACCTGAGCACAGAACTTTGTGGTCACTCCCGTAGGT +GAAACATTGAGAACCAACTCGATTCAAGTAGTAACCAAACTTTTCTTTAAATTAACATAA +GGAGATTCAACATGGCTAACAATCAAGGCGGACAGCAAATTGGTACTAAACAGGGTAAGG +GTCAGTCCGCAGCGGACAAATTGGCGCTGTTCCTGAAAGTGTTCGGCGGTGAAGTACTGA +CGGCTTTCGCTCGCACCTCCGTGACCATGCCTCGTCACATGCTGCGCTCTATTGCTTCTG +GTAAGTCCGCACAGTTCCCTGTGATTGGTCGCACCAAAGCTGCTTACCGGAAACCGGGTG +AGAACCTCGATGACAAACGTAAGGATATCAAACACGCCGAGAAGGTAATCCACATTGATG +GACTGTTGACTGCGGACGTTCTGATTTACGACATTGAGGACGCGATGAACCACTACGACG +TTCGCGCTGAGTACACCGCACAGTTGGGTGAATCTCTGGCGATGGCGGCTGACGGTGCTG +TACTGGCTGAACTGGCTGATCTGGTTAACCTGCCGGACGCCTCCAATGAGAACATCGAGG +GTCTCGGTAAGCCTACCGTACTGACTCTGGTTAAGCCGACCACTGGCGACCTGACTGACC +CGGTTGAGCTGGGTAAAGCGATTATCGCTCAGTTGACTATCGCTCGTGCGTCTCTGACCA +AGAACTACGATCCGGCTGCTGACCGTACCTTCTACACCACTCCTGATAACTACTCTGCGA +TTCTGGCCGCTCTGATGCCGAATGCTGCAAACTATCAGGCACTGATTGACCCTGAGCGTG +GTACTATCCGTAACGTGATGGGCTTCGAAGTGGTTGAGGTTCCGCACCTGACCGCTGGTG +GCGCTGGTGATACCCGTGAGGATGCCCCGGCTGACCGGAAGCACGCTTTCCCGGCGACTT +CCAGCGCTACCGTTAAGGTTGCTCTGGATAACGTTGTGGGCCTGTTCCAGCACCGCTCTG +CGGTTGGTACGGTCAAGCTGAAAGACTTGGCTCTGGAGCGCGCTCATCGTGCGAACTATC +AGGCTGACCAGATTATCGCTAAGTACGCGATGGGTCACGGCGGTCTGCGTCCAGAAGCTG +CTGGCGCTATCGTGCTGCCAAAGACTTCGGGGGCTTAAGGGTAGCGCCTTTGAATATGAA +CGCGGAGAGTGAAGTGGAGCCGACCCAAGAGGTAGCCGCCGAAGTAGCTCTCACGCCTCA +ACAGAAGGCCGCCATTTCTCGTGCTCGTAACAAGGCACTTAAGTCTCAATAACAACAAGC +AAACCCCTTGGGTTCCCTCTTTGGGAGTCTGAGAGGTTTTTTGCTTTAACCCTCACTAAC +AGGAGGTAACATCATGCGCTTTTATAAGATGAACATTGAGACCGCAGAAGAGCTATCAGC +GGTCAACGACATTCTGGCTTCCATCGGTGAGCCACCAGTATCGACCCTTGAGGGTGACGC +AAATGCTGATGTTGCAAATGCTCGACGTGTGCTCAACAAGATTAACCGACATATTCAGTC +ACGAGGATGGACATTCAATATTGAGGAAGGTGTGACTCTTCTACCGGATGCGTTCTCTGG +TATGGTTCCATTTAGCTCTGATTATCTGTCCGTAATGGCAACCAGCGGTCAGACCCAATA +TGTCAACCGTGGTGGCTATCTCTATGACCGCTCTGCGAAGACTGACCGATTCCCATCTGG +TGTTCAGGTCAACCTGATTCGTCTGAGAGAGTTCGATGAGATGCCTGAGTGCTTCCGAAA +CTACATCGTTACCAAGGCTTCCCGTCAGTTTAACAACCGAACCTGATTCGTCTGAGAGAG +TTCGATGAGATGCCTGAGTGCTTCCGAAACTACATCGTTACCAAGGCTTCCCGTCAGTTT +AACAACCGCTGCTTCGGTGCGCCGGAGGTAGACGGAGTGTTGCAGGAAGAGGAACAGGAA +GCGTGGCGTGCGTGCTTCGAGTACGAACTAGACTACGGCAACTATAACATGCTGGACGGT +GACGCATTCACCTCTGGTCTACTTAACCGCTAATAACAAGGAGGCTCTATGGCTCTCATT +AGTCAATCAATCAAGAACCTCAAGGGTGGTATCAGTCAACAGCCAGATATTCTCCGGTTC +GCTGAACAAGGTAGCGTACAGATTAACGATTGGTCTTCTGAGTCCGAGGGTCTCCAGAAG +CGCCCACCGATGATTCACCTTAAGACCCTTGGTGCTGCTGGGTATGTGGGTGCGCAACCT +TACCTTCACCTCATCAACCGTGATGAGTTCGAGCAGTATTTCGTGGTGTTCACTGGTGAA +GACATTAAGGTATTCGACCTCGACGGTAAGGAATACCAAGTACGTGGAAACCGCTCATAT +GTTCGTACAGCTAACCCACGAGAAGACCTTCGGATGGTAACTGTGGCTGATTATACCTTT +GTGACTAACCGCAAGGTCGTTGTACAGAGTAACGACCAATCGGTCAACCTTCCGGGCTTT +AAAGACCAAGGCGATGCGCTGATTAATGTTCGCGGTGGACAATATGGGCGTAGACTCTCA +ATCGAGTTCAACGGGGCTGAGCGTGCTGCTGAACAACTACCGGATGGTTCACAACCAGCA +CACGTTAACGAGGTTGACGGTCAGGCTATCGCTGAGAAGCTGGCTGTGCAGTTGAGGAAC +AACCTTGGGAATCCAAACAACGAGCAAGACCCGAATAAGTGGCGCTTCAACGTTGGCCCC +GGATTCATCCATATCCTTGCGCCAAATAACGATAACGTTTGGGGACTACAGACTAAGGAT +GGTTACGCAGACCATCTAATCAACCCTGTAACCCATTACACTCAGTCGTTCCAGAAGCTG +CCTATTAACGCGCCAGATGGGTACATCGTGAAGATTGTTGGTGATACCTCAAAGACTGCC +GACCAGTATTACGTTTGGTTCGACCTAAACCGTAAGGTGTGGGTAGAAACAAATGGATGG +AACACAAGGACTCACCTACATTACCACACGATTCCTTGGGCACTTGTTCGCGCTTCTGAC +GGGAACTTTGACTTCAAGTACCTTGAGTGGGGTGCTCGTACTGTGGGGGACGATACAGCC +AACCCATACCCATCCTTTACCGGACAGACAATCAACGATATTTTCTTCTTTCGTAAACGC +TTGGGATTCCTTAGTGGGGAGAACATCATCTTGTCTCGCACCTCGAAATACTTCAACTTC +TTCCCGGCATCCGTGTCAAACTACTCCGACGATGACCCAATCGACGTTGCGGTTAGTCAT +AACCGGGTGTCAACCTTGAAGTATGCCGTTCCGTTCTCAGAAGAGATACTCCTGTGGTCT +GACCAAGCGCAGTTCGTTCTGACAGCCTCTGGAATCCTCTCGAGTCGCTCCGTATAGTTG +AACCTTACGACGCAGTTCGACGTGCAAGACAGGGCACGCCTACATGCTGTAGGACGTAAT +GTATACTTTGCGTCACCTCGCGCTTCCTTCACATCCATTAACCGATACTATGCGGTACAG +GATGTAAGCTCTGTGAAGAACGCAAAGGACATGACGGCTCACGTTCCGAACTACATACCG +AATGGAGTATTCAGTATATCGGGGACAACCGCTGAGAACTTCGCGGCTATCCTTACGAGC +GGAGCACCGAACCGAGTGTATATCTACAAGTTCCTCTATATTGATGAGGAAATCAGGCAG +CAGTCGTGGTCTCATTGGGACTTTGGGGACAACGTTACGGTGTTTGCAGCACAGGTGATA +AACTCAACAATGACTGTATTGATGAGCAATGAACATGATGTGTGGATGGGACGCTTACAC +TTCACGAAGAACTCCAGAGACATTCCGGGAGAGCCTTACAGATTATACATCGACGCTAAG +AGGAAATACACCAGCCCTGCCGGGACGTATAATGATGATACCTACCAGACGTCCATAAGC +CTCGCAACAATTTATGGGATGAACTTCACTAGGGGTAGAGTGTCTGTGGTCTTTCCTGAT +GGGAAGATTGTAGAGATAGACCAACCAATCAACGGGTGGAGTAGCGACCCAATACTGAGA +CTTGATGGAAACCAAGAGGGACAAGTAGTCTACATTGGGTTCAACATCCCGTTCACTTAT +ACGTTCTCGAAGTTCCTCATCAAGAAGACTGCTGAGGACGGCTCGACGGCTACCGAGGAT +ATTGGTCGTTTACAGCTTCGGCGTGCGTGGGTAAACTATGAGGACTCTGGAGCGTTCACC +ATCCGTGTGAACAACCTGTCCCGTGAGTTCATCTACGCAATGGCTGGTGCTCGCTTGGGT +TCTGACAATCTGCGTGTTGGCAGGTCGAACATTGGCACAGGGCAGTACCGCTTCCCGGTT +GTTGGAAACGCTCAGACGAACATAGTAACTATCGAGTCAGATGCATCAACACCACTGAAC +ATCATTGGGTGCGGCTGGGAGGGGAACTATCTTCGACGTTCTTCTGGCATTTAACTTAAA +GTCTCCCTGTGGTGAATTAACCCTCACTAAAGGGAGACACTAATAGATACGAGGGGTTAA +AGCATTATGTACATTACAAAGTGTTTACAAATCCATGCCGACAACTTTCAGCCGTCCATA +GAGGTCATTCTGGAAGCTGAGGCACTAGGTGTTGAACCAAAGGTAATTCCTGATGAGAAC +ACTGTGGCAATGCTTAGCGATAACGCTGTGTTGGCAATCGGTGGCAATCAGGGAGACCGA +GTGTGGTTCCATACCTCTAAGTACGTCCCACTGTTTACCTTGAAGGAGCGCTTAGAGTTT +CGTAGACTTATCATTGAATATCGTGATATGATGCTGAGCCAGTACGAGTCCATTTGGAAT +TTCGTTTGGGTAGGCAATAAGTCACACATTCGTTTCCTAAAGACCATAGGCGCGGTATTC +CATAATGAGTTTACCGCTGATGGTCAATTCCAATTATTCACTATCAGTAGGAGGTAACTA +TGTGCTGGATGGAATCGATTCCTATTGCCATGATGGGTGCCCAAGCTCTAAGTAGCCAGA +ACAGTGCTGACAAGGCGCGAGTGGCACAGACCGAAGCTGGACGCAGACAGGCAATGGAGA +TGGTCAAAGAGATGAATATCCAAAATGCCAACGCCTCGCTGGAACAACGGGACGCCCTTG +AAGCTGCATCCTCTGAGTTGACTACACGTAACATGCAGAAGGTACAGGCTAAGGGAACCA +TCCGTGCAGCTATTGGCGAGGGTATGCTCGAAGCTGAGTCCATGAAGCGCATCAAGCGTA +TCGAAGAGGGCAACTACATTAGGGAGGCAAATAGTGTCACCGAGAATTACCGCCGAGACT +ACGCGAGTATCTTTGCGCAACAGTTGGGACGCACTCAGTCCACAGCGAGTCAAGTCGATG +CAATGTACAAGAGCGAGGCCAAAGGTAAGTCTAGTCTGATGCGTGTACTAGACCCTCTGT +CCATTATTGGTCAGGAAGCTGCAAGTTAATATGCGGCTGGTGGATTTGACAAGAAGGGTG +GAAACCAAGCAGCACCTATCAGTGCCGCCAAAGGAACCAAGACCGGGAGGTAATAATGGC +TAGTAAACTAAATAGTGTTTTAGGCAACATGGCGACTCCCGGTATGGAACGACCCCGGGG +CGTCAAAGGTATGGACTACCGGGCAGCAACCATTCAGGCTGAACAACCAAGAGCGAGTCT +TCTGGACTCCATTGGTCGATTCGCTAAGGCTGGTGCCGATATGTACATGGCGAAAGATGA +TCGTGATAAGCAACGAGCCGATGAGCGCTCAAACGAGATTATCCGTAAGCTGACCCCTGA +GCAGCGCCGACAGGCTATCCAGAATGGTACACTGCTGTATCAGGATGACCCATACGCAAT +GCAAGCCTTGAAGTTCAATACCGGGCGTAACGCTGCGTCCCTCGTTGACGATGAGGTTCA +ACAGGCCATCAAAGAGGGTCGCTTCCGTACTCGTGAAGAGATGAAGCAGTATCGTCACTC +ACGCCTACAGGAGCACCCGAAGTCGTACGCTGAGCAGTTCGGTATCAATGAGATGAACGA +GGAATACCAGAAGGGTTTCAACGCGAATATCACCGAGCGTAACATTGCTCTGTATGTGGC +ACATGATACCTTCCTGAGTGACCAAGCGCATAAGGGTGCAATCCTGAACTCGAAGGTTGA +ACTCAACGGTGTCCTATCTGACCCTGACCTACTGTCTCGTCCTGAGTCCGGTGAGTTTTT +CCAGAACCACATTGACAACTCCTTGGTGACGGGGATGACCGACAATCAGGCTCAACAGGT +TATCTCTTCGTCCCTGAATGACGTGCTACAGCGTCCGGGTGGTGCCGCATTCTTGCAGAA +CATTCAGAACCGCAAGGTGACTCTTAATGGCGCTACGACTAGCTATCGTGAACTGATGGG +TGATGAGCAGTGGCAGGCAATGATGATTAAGGCACAGCACACTCAATTCCAGAACAACGC +GAAGTTAACCGAGAAGTTCCGACTGGATATTAACTCAGCGCTTAATCAGGCAGACACTGG +TAAAGGGTGGGAGACTCTTCAAGGTATCAAGGCCGAACTCGATAAGATTCAGCCGGGTGA +AGAGATGACTCCTGAGCGCGAATGGTTGATTTCCGCACAGGAACAGATGCGTACACGCTT +CAAGCAGGAACAGGCTGAGACAGCCAAGCTGATGGACAAGCAACAGACGACCTTGAATAA +ATCTTTGGTCATCGACAAGCAGTTCCAGAAGCGCCTCAACGGTGAATACGTCTCGACAAA +CTATAAGGACATGCCGACCAACGAGAACACTGGTGAGTTTACACATAGCGATATGGTCAA +CTACGCGAACCAGCAGTTAGCGGAAATCGAAGCGATGGACTTAACGCAAGAACAGAAAAA +CAAACTGAAATTGGACTACCTACGGGCAGACTCCAAGGAGGGTGCTTTCCGTGCAGCGTT +TGGTGAGATGATTACTGATGCTGGAAACGAATGGCAGGCTGCGGTGATTAACGGTAAGAA +GCCTGAGAGCACACTAGCGAAGGACAACCTTCGTCGCATCCGCGACACTGACCCTGACCT +GATTGCCTCTCTGTATCCTGACAAGGCCGAGTTGTTCCTGACTATGGACATGTTGGATAA +CCGAGGTATCGACACGCAGGTTCTTATAGACGCTGATAAGTCCCGTGCACAGAAGACCAA +GGAGATGCAGTTTGAGGATGACCGAGCGTGGGCTGCTATGATGAACGATTCAACGAATCC +TCTAATCAAGTACATACCTTCGAGTGTCCAAGGTTACGCGCGGAAGATTTATGATTCCGT +GAAGTACCGGACAGGGAACCCTGACATGGCAACAGAACAGGTCGCAAAGTTCCTTTCTGA +TTCAACGACTACGTTCTCCAGTAGTGATGTTGATGGCGATACCTATGGTGTCCTGCCGAA +GAACATCCGGACTGTTTCGGACGACCCTAAGTCGTGGGAGCAAGGGAAGAACATTCTGGA +CGAAGCCATTAAGGGAATGACAGCGGCGAACCCTTGGATTACCAACAAGCAACTGACGGT +GTACCAGCAAGGTGATTCAATATACCTGATGGACACAACCGGACAGGTTCGCGTTCGGTA +TGACCAAGAGTTGCTCCAGCGTGAGTACCAGCGTACCGCACAGATGCAAGCTGAGGCAGC +ACGAGAGAAAGCCCTCAAAGAGGCCAACAAGCGTGCCCCAAGTTGCTCCAGCGTGAGTAC +CAGCGTACCGCACAGATGCAAGCTGAGGCAGCACGAGAGAAAGCCCTCAAAGAGGCCAAC +AAGCGTGCCCCAATCAGCCGTGCACCACAGGCGCGTGAAGAAGCGCGTAAACGTGTCCAA +GAAAAACGGAAGAAGACTCCGAAGTACATCTATGGACGTAAAGAAGACTAACAGTGATAA +GGAGGCTCCATGAGCTACGATAAGAACAAACCTAGCGAGTTCGATGGGTTATTTCAAAAA +GCGGCAGACAAACATGGGGTCTCCTATGACCTGCTTCGTAAATTAGCATTCAATGAGTCC +AGTTTCAATCCAAAGGCCAAATCTCCAACTGGCCCGAAGGGTCTCACGCAGTTCACCAAG +GGTACAGCCACTGCGCTGGGACTAAAAGTCACTGATGCAGACGAAGATGACCGTTACAAC +CCGGAGTTGGCTGTGGATGCAGCCGCTCGTCACCTGAGTGACCTCATTCGTAAATACGAT +GGGGATGAACTTAAGGCAGCCCTAGCGTACAACCAAGGCGAGGGAAGAAATGGTGCCCCT +CAGATGCAGGCCTACGACAAAGGTGATTGGGCCTCAATCTCTGAGGAAGGTCGTAACTAT +ATGCGTAACCTGATGGACGTAGCTAATAGTCCTCGCAAGGGGGACTTGGAGGCGTTCGGC +GGTATCACCCCAAAGGCTAAGGGCATTCCATCGGGGGATGCATTTGCTGGAATCGGGAAG +AAGCAAACGGTAGGCACTGACCTGCCGGAGTCAACGGGATTCAAAGTGGAGGGTAAAGAG +CAGTAAGCGCCTAACGTTCCTTATGCTAAGGACTTTTGGGAAAAGACTGGAACAACACTG +GACGAGTTTAACTCACGCTCTACCTTCTTCGGAATTGGCGATGCAACAAGTGCGGAGCTT +CATAACTCTGTACTTGGAGTTGCTTTCCGTGCAGCCCGTAGCGACGATGGTTTTGATTTG +TTCAAGGACACCATTACGCCTACCCGTTGGAATAGCCATACGTGGACTCCAGCTGGAACA +ACACTGGACGAGTTTAACTCACGCTCTACCTTCTTCGGAATTGGCGATGCAACAAGTGCG +GAGCTTCATAACTCTGTACTTGGAGTTGCTTTCCGTGCAGCCCGTAGCGACGATGGTTTT +GATTTGTTCAAGGACACCATTACGCCTACCCGTTGGAATAGCCATACGTGGACTCCAGAA +GAGCTAGAGCGAATCCGTAAGGAAGTGAAGAACCCCGCGTACATCAACGTAGTCACTGGA +GGCTCTCCTGAGAATCTGGACGCCCTCATTAAGATGGCGAATGACAACTATGAGATGGAT +GCGCGGTCTGCCGATGCTGGTGTTGGTGCCAAACTTACTGCTGGTATCATCGGCGCTGGT +GTAGACCCGCTGAGTTATGTACCGCTAGTAGGCGTAGCCGGGAAGGGTCTCAAGGTGGTT +AACAAGGCTTTCATTGTGGGTACTCAAAGTGCTGGCCTCGCGGTTGCCTCTGAGGGTCTC +CGTACATCAATCGCTGGTGGAGAAGTCCACTATGCTGATGCTGCTTTAGGTGGTCTCTTG +TTTGGTGCTGGTATGAGCGCAATCAGTGATGCTATCGCTGCTGGTGTTCGCCGTTCCCGT +GGGACTGAGGTAGTTAATGACTTCGCTCCTATGGCACACCGCTTGGAAGCCCGTGAGACC +GCTCTGAACACTGGTGGGGAAGACCTGACCCGTATGCCTAGCGAGAACCGTGTGTTCGAC +CGTGAGCACGCTGGCGTTGAGTAGTCACCTCTGGAGACCGAGCCGGGTGCCGTTGTGTTG +CCTCAAGGTCAAATCCTGAGCGACACCAACCCACTAAACCCTCAGACTCTGAGCGAGTTC +GAGGCGGTCAACCCTGAGCGTGCCGCTCGTGGTATCTCTTTGGGTGGTTTCACTGAGATT +GGCTTGAAGACTCTCCGCTCTGAGAACCCGACTGTTCGCTCCATTGCGAGTGACCTTGTG +CGTTCTCCGACAGGGATGGAATCAGGCTCTAATGGTAAGTTCGGTGCGACTGCTTCTGAC +ATTAAGGAGCGGCTCCACGCGAACAATCAGCGCACCTACAATCAGCTTTATGATGCTTTG +CGTACTGCAATGAAAGACCCTGAGTTCTCCACAGGTGGTGCCACAATGAGCTGTAAGGAA +ATCCGACAGGAAATCTACAAGCGTGCAGCCTTGGCGATTGAGCGACCTGAGCTTCAAGCA +AACCTGACAAAGGGTGAGCGGAACGTGATGAACCTCCTCAAGCAGCGCTTTGACCTCAAA +CGTGAAATCATGGAGAACCCGTCAATCTTCGGCAACACCAAGGCGGTCAGTATCTTCCCC +GGCTCACGCCACAGGGGAACCTACGTGCCAAACGTGTACGACCGCGCTATCAAGATTGAG +ATGGTTAAACGTTACGATAATGATGGCTTGCAGCGAGAAATCGCGGAGTCATGGTTGACG +TCTTATCGTGCTCGTCCAGAAGTCAAGGCGAGGGTCGATGAGTACCTGATGGAACTTAAC +GGTCTCAAATCCGTGCAGGAAGTTACGCCTGAGATGGTGCAGTAGCACGCGATGGATAAG +GCGTATGGTATTTCACACACTGACCAGTTCTCTGCCTCCTCTGCCATTGAGGATAACATT +GAGGGTCTGGTGGGTATCGAGAACAACAACTTCTTGGAAGCCCGTAACATGTTCGACAGT +GACATGGCGGTGACTCTCCCTGATGGTAACACGTTCTCTGTGAATGACCTGCGTACCTAT +GACATTGCTGAAATTCTGCCTGCATACGACCGACGAGTAGATGGTGATGTTGCAATCATG +GGCGGTTCCGGTAAGACTACCAAAGACCTGAAAGATGAAATCATGGCGCTGGATAAGCAG +TCAGAGGGTAACGGCACACTGAAAGGTGAAGTGGAAGCTCTCAAGGACACCGTGAAGATT +CTGACTGGTCGTGCTCGTAGGAACCCGGAAGGCGCTTGGGGTACAGCCCTACGCTCCGTA +AATGACCTCACGTTCTTTGCTAAGAACGCCTATATGGGCGCACAGAACGTTACTGAAATC +GCTGGTATGCTGGCGAAGGGTAACGTCTCTGCGATAACTCATGGCATCCCTATGGTTAAC +GATTGGGTCTACCGTGGTAAACCGCTTCGTGCCTCTGAGATTAAGGAGATACACGGGATG +GTGTTCGGTAAGGAACTAGACCACCTAATCCGTCCGGGACGTGAAGACCACGTGCGCCGA +CTCCGGGAGTCTACGGACACCAGCGCTGCGGTTGCCAATGTGGTCGGTACGATTCGTTTC +GGCACTCAAGAGTTGGCTGCACGCTCTCCTTGGACAATGCTCCTAAACGGAACATCAAAC +TACATTCTTGAAGCTGCCCGTCAGGGTGTGCTTGGGGATGTGGCTGGAGCGGCCCTTGCT +GGGAAAGCCTCTAAGTTCGGTAAGGCAAACTACCTTAAGTCTGCCTCTATCAGCCCTGAG +CAGTGGAATGGAATCAAGCAGTTGTTCAGAGACCATGCGACTCGTAGAGAAGACGGTAAG +TTCACCATTCGTGACAAACAGGCTTTCGCTCACGACGCACGTTCAATGGACTTGTGGCGA +CTGGCTGACAAGGTGGCGGATGAGACTATACTGCGACCTCACAAGGCTTCCTCACAGGAT +TCCAAAGCGTTCGGTGCAGGGGTGAAGATGGTGATGCAGTTTAAGAACTTCGTCATCAAG +TCCCTTAACTCCCGGTTCGTCCGTAGCTTCTACGGGGCAACTAAGAACAACCGTGCGTTA +GACCAAACGTTGACTCATATCATCTCCTTGGGTCTAGCTGGTGGTTACTACGTTGCGCAG +GCGCACCTTAAGGCCGCAAGCCTACAGGAGCACAAGCGTAAGGAGTACCTTAAGAACGCA +CTTGACCCTAAGATGATTGCTCATGCGTCAATCTCTCGTAGTTCACACTTAGGGTCTAGC +TGGTGGTTACTACGTTGCGCAGGCGCACCTTAAGGCCGCAAGCCTACAGGAGCACAAGCG +TAAGGAGTACCTTAAGAACGCACTTGACCCTAAGATGATTGCTCATGCGTCAATCTCTCG +TAGTTCACACTTAGGCTCACCATTGAGTATCTACAACATGTTCGCTGGGATGGTTGGTAG +CGATACCTGTAAGTACACCCGCTCTACTGTGCTCCCTAAAGAGTCCGAGAAGCGTGACCC +TAACAAGGCAATGACAGGTAGACAGGTGGCTTCAACTATCGCGGGTGCAGTTGGTGAGCA +GGTTCCGGGGTTAGGTTTTGTGGGTTCTGTGGGTGCAACAGCAATTAACGCAGCTTCCCT +GCTATCTTCTCCCAACAAGGCAACCGCTCTGGAGTTCCGTACAGGCCTCTTCAACACCTC +TCGTGAGTTGATTCCTAATGACCCGCTATCGCAGCAACTCATTATGAAAACCCTGCTATC +TTCTCCCAACAAGGCAACCGCTCTGGAGTTCCGTACAGGCCTCTTCAACACCTCTCGTGA +GTTGATTCCTAATGACCCGCTATCGCAGCAACTCATTATGAAAATCTACGAGGCCAACGG +TATCCGCATAAAGGAGACGCCGAAGAAACAATAAACCCTCACTAAAGGGAGAGAGGTCAC +ATTCTGTCCTCTTCTCTCTTAATGCTAATTTACAAAGGAGGTCACATGGCTACAACTATT +AAGACCGTGATGACTTACCCGCTGGATGGCTCCACTACGGACTTTAATATTCCGTTCGAG +TATCTAGCGCGTAAGTTCGTCAGAGTGACCCTTATCGGTGTTGACCGAAAGGAACTCATC +TTGAATCAGGACTACCGTTTTGCGACTAAGACCACAATCTCCACAACGAGAGCATTGGGG +CCAGATGACGGTTATAACATGATTGAAATCCGTCGATTTACCTCCGCTACCGATAGGCTG +GTTGACTTCACCGATGGTTCAATCCTTCGGGCATACGACCTGAACATCTCTCAGGTCCAA +ACCCTTCACGTTGCTGAGGAAGCACGTGACCTTACCGCTGATACTATTGGCGTTAACAAT +TATGGGAATTTGGATGCTCGTGGTCGCCGTATCGCTAACGTAGCTGACGGAGTTACTGAT +GGTGACGCCATCTCTGTAGGTCAGGTTAAACGTATGAACCAGAACTCGTGGCAAGCACGT +AATGAGTCCTTGCAGTTCCGTAATGAAGCAGAAAGTTTCCGCAATCAGGCCTCTACGAGT +AAACAGGCTGCTGCTACCTCTGAGTCGCAATCATGGAATCATACTGGGCGCTCTCGGACA +TTCGCTGAGGCAGCTCAAGGTTCTACTAACTCTGCGGGACAGTCAGCTACCAATGCGAAC +AACGCTATGCAGTCTGCTGGTCAATCAGCCACGGATGCTAGTAACTCTGCTGCTCAGGCT +AAGGCCTCTGAGGTTAACGCAAAGGCCTCTGAGGTTAACGCTAAGCGTGATGCTGACGCG +GCCCTGCTGGCTCTGCAATCCACTGGTAACGTACCTGTGGGTACAGTCGCCATGATTACC +CACACCAAGATTCCTACTGGTTGGGTGCGTGCTGGTGTGGACTTCGACGTTAATACTTAC +CCGGCGTTAGCTGAACTGTTCCCTAGTGGTCGTACTCCTAGCTTCGATGACCGCTATCCT +ATTGGTAACTCTACCGTATTGACTCCGGGTCAGCTTATTGAACAATCAGTACCCGCCCAC +AGTCACACCTTCGACGTGCCTGTCAACGTGTCAGGTGCTACGGCTGCTGGTGGCGAATAT +CGCGCCAGAACGTCACACGAAGGGGATCACAGTCATGGGTTCTCATTGCCTATCCAGAAC +AACACTGGTGCTTATACTGGTCGTCTGGTTGGCGGTGGCAACAACCCTAATTACCCGCAA +GACCTGCGCTTTAACACTGGTGGCGGTGGTGCTCACAGTCATGAGTTCTATGTTCCTTCA +CACAGTCACACGTTGAATGCATCTGGGCGTGCTGCTGGCTCCGTCTCTTCGTCAGGTATT +GGAAACTCACCGTATGTCCGACCGTATTCCACTGTGGTCATCTTCATCATCAAGGCCGCT +CAAGGTGTTGACAATAAGGACGCAGCAATGCAGGTGGTGGGCACTGTGGTTGGACGAGTG +GACGCTCTGGAGAACTGGCAGAAAAACTTCAAGTACGTTGTTGAGAACGGTTCACCAACC +TCTGCAAACGGCGGGCCTTGGGAACGTACTGTGTACACTGCCCAGACTGACTTCGGTCGC +AACCGCTGGCGCACACTGAGTGGTTCGTCATGGGGAGAAGTAGTCAACTTACTTAATAGC +TCCGGCGTACTTAAAGGGTATCCGCAACGTCTTGTTGTTGACTTCACGGTTGAGGTAATC +GATAGCTCTGACCTCATCGCCAAGGCTGGTATATATAGTCCAATTATTATGGCCAGAATC +GTGTATCACAACGGCACCAACTCTGGTGATATACTTCCCGCTGCCACCTCAAGCTCTGCG +CACGCGACAAACGGGTGGAACATTAAGATGGCTACACGATTGTTGTATGGTACTGATGGC +GGTCAACCAGTAGTTGAGATTGGTGCCTTCAAGGATGGTTCTGACCAGCAGACGGCAAAC +GTGCCAGTTAAAGTAGGCTTGTGCCTCGTTCACGTGTTCTAAGGAGGACATAATGTTATC +ACTTGATTTCAACAACGAGGCCATTAAGGCTGCACCCATTGCGGGTGTGGCTGGTGCTGA +TGGTGTGGCCCGCCTGTTCTGGGGGCTTTCTCTCAACGAATGGTTCTACGTTGCAGCTAT +CGCCTACACAGTAGTTCAGATTGGTGCCAAGGTGGTCGATAAGATTATTGATTGGAAAAA +AGCAAATAAGGAGTAACCTATGAGCGACAAGACTTTAATCAAGCTGCTGGAGATGCTGGA +GACGGAGATGGCACAGCGTATGCTTGCTGACCTCCAGAGCGAGGAACGCCGAACTCCGCA +GCTTTACAACGCAATCGGCAAACTGTTAGACCGCCATAAGTTCCAAATCAGTAAGCTGAC +CCCGGACGAGAACATCCTTGGCGGTCTGGCTGCTGGTCTGGAAGACTACAACAAAGTGGT +CGGCCCTAATGGTCTGACTGATGATGAAACAATCACGCTACAGTAAGTGACATACTCAAG +GTTCTCCACGCGGGGAGCCTTTATGGATGTTATCTGGTGCATCTATGTAAAATCTGAAAA +TTGATGGGAGGTGTTATGCTAAAACTTTTACGCAGCGCACTCCCTTGGGTACTCGCCGGG +ACACTCTTTATGGGTTGCTGGCACTTAGGGTCAACCCATGAGAGAGCAAACTGGAAGGAG +GTAATCCAAAATGAATACATTGCGAAAACAAAAGCAACCGCAGCAACTCAGGCAGCGGTC +AGTCGGGTATCCCGTGAGTACCAAGAAGAGATTGCAGCCATTGAAGGCAGCACTGATAGG +ATGCTTAATGACCTGCGTAGTAATATTAAGCGGCTGTCAGTCCGCATCAAGACCCTTACC +GGACTACCAGAAGATAACGGTAGATGCGAGTTTAATGGTCGAGCCGAACTACACGAGTCA +GATGCTAAGCGTATTATCGGAATAACCCAAGCTGCTGATGCTCACGTAAGGGCGCTCCAG +CGTACTATTAAGGAGATGCAGAATGAGCGACACCCAAGCAAACCGTATTGCGCTAATCAT +CGCGCAGCTTAAGGGCGACTTTGTGGCCTTCCTGTTCGTATTGTGGAAGGCTTTGGCTCT +CCCGCCACCGACTAAGTGTCAGATTGATATGGCCCGGTGTCTGGCTAACGGAGACAACAA +GAAGTTTATCCTACAGGCTTTCCGTGGTATCGGTAAGTCATTCATCACCTGTGCGTTCGT +TGTGTGGACGTTATGGCGTGATTCCTGTTCGTATTGTGGAAGGCTTTGGCTCTCCCGCCA +CCGACTAAGTGTCAGATTGATATGGCCCGGTGTCTGGCTAACGGAGACAACAAGAAGTTT +ATCCTACAGGCTTTCCGTGGTATCGGTAAGTCATTCATCACCTGTGCGTTCGTTGTGTGG +ACGTTATGGCGTGACCCTCAGTTGAAGATACTGATTGTCTCTGCATCCAAAGAACGTGCG +GACGCTAACTCCATCTTCATCAAGAACATCATTGACCTGCTGCCATTCTTGGCTGAGCTA +AAGCTTCGCCCCGGTCAGCGTGACTCTGTGATTAGTTTCGATGTTGGCCCTGCCAAGCCT +GACCACTCTCCGTCTGTGAAGTCGGTGGGTATCACTGGTCAGTTGACTGGTAGTCGTGCT +GATATCATCATAGCGGATGACGCTGAGATTCCGTCTAACTCCGCAACTCAAGGTGCCCGT +GAGAAGCTGTGGACTCTGGTGCAGGAATTTGCTGCGCTTCCGAAACCGCTGCCTACTTCT +CGCGTTATCTACCTTGGTACATCTCAAACCGAAATGACCTTGTACAAGGAACTCGAAGAT +AACCGTGGGTACACCACTATCATCTGGCCTGCGCTCTATCCACGTAGCCGTGAGGAAGAC +TTGTACTATGGCGACCGTCTGGCCCCGATGCTCCGCGAAGAGTTCAACGATGGGTTCGAG +ATGCTCCAAGGTCAACCGACTGACCCCGTGCGCTTCGATATGGAAGACCTGCGTGAGCGT +GAGTTGGAATACGTTAAGGCTGGCTTCACTTTGCAGTTCATGCTCAACCCGAACCTGAGT +GATGCCGAGAAGTACCCCTTACGCCTCCGTGACGCTATCGTGTGCGGTCTGGACTTCGAG +AAAGCCCCAATGCATTACCAGTGGCTTCCGAACCGTCAGAATCGCAATGAAGAGCTTCCT +AACGTGGGACTTAAGGGTGATGATATTCATAGCTATCATTCGTGCAGCCAGAACACTGGA +CAGTATCAGCAACGCATCCTCGTGATTGACCCAAGTGGTCGCGGTAAGGATGAGACAGGT +TACGCAGTGCTGTTCACCCTGAATGGCTACATCTATCTGATGGAAGCTGGCGGGTTCCGC +GATGGTTACTCCGACAAGACCCTTGAGTCCCTCGCTAAGAAAGCGAAGCAGTGGAAGGTT +CAGACAGTGGTCTTCGAGAGTAACTTCGGGGATGGTATGTTTGGTAAGGTATTCAGCCCT +GTGCTCCTGAAACACCATGCAGCGCAACTTGAAGAGATTCGTGCTCGCGGTATGAAGGAA +CTACGCATTTGTGATACGCTGGAACCTGTACTCTCTACGCACCGCCTTGTGATTCGTGAC +GAGGTGATTCGTGAGGACTACCAGACTGCCCGTGACGCTGATGGCAAGCATGACGTTCGC +TATTCGCTGTTCTACCAGTTGACCCGTATGGCTCGTGAGAAGGGCGCTGTGGCCCACGAT +GACCGACTTGATGCGTTAGCATTGGGTGTGGAGTTCTTACGCTCTACGATGGAACTGGAC +GCCGTGAAGGTGGAAGCTGAGGTGCTGGAGGCGTTCTTAGAGGAACACATGGAGCACCCA +ATCCATTCGGCTGGTCACGTAGTCACCTCTATGGTTGACGGTATGGAACTCTATTGGGAG +GAAGACGATGTGAATAGCAATAGGTTCATTGACTGGTAGTTATGCATATTGAGTGCATAA +GGAATCATTGAGACCACGGATGGTCACTTTAAGAAACTCCTTAAGAATCAATGAGTTTGA +ATTAATCCTCTCTAAAGGGAGAGAGGGGACTTAAAGCTACTATATAGGTTAGTCATTCAG +GTTATGCAATGACCCTTTATGCACTTTAAGTCGCCTCTATGATTGGTGATATTATCATTG +TATAATCACCCTACCTTAGAGCAACTGAAAGGAGGTGGCTCAATGTTACGCTTGCTGACT +GCCCTGCTGCGTCATAGAGTCACTTGGCGATTTCTTCTGGTACTTGCTGCTACCCTTGGG +TACGCAGGTCTTACTGACCACCTCGGTCAACTGGAAGTGGCCTTTTGCTCTATACTCTCT +TGTGGGGATTAAATTATTGTTGATGAACGACAAGCGGCTCTGAGGGATTCTTAGGTATAG +TTTCACTACACCAACTCATCCCTGTACAGTCAACCCTAAAGGTTATACCTAAAGATGCCC +TGTAGTTCGTAATGGTCTTACAGGGTCTTTAAGTGTCTCCTATGGTCTCACCTATGGTGT +GGCCTTACCTAAAGTGGTTGCCTAAAGAGACCTTTGAGAATTTACCACAAAAATCTGAAT +GGATATCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAA +GCCAGCCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCT +ATAGGATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGA +GGCCTTAACGAGTGTCCTAGTGTACCAGTTCGATGGTACATCTCTATGTGTCCCT diff --git a/example/fna/NC_010807.alt3.fna b/example/fna/NC_010807.alt3.fna new file mode 100644 index 0000000..cd29b62 --- /dev/null +++ b/example/fna/NC_010807.alt3.fna @@ -0,0 +1,666 @@ +>NC_010807.alt3 length=39891 tani=98.414 alt=sn;ins;tl +TCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAAGCCAG +CCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAGGTGGCCTATAGG +ATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGAGGCCT +TAAAGAGTGTCCTAGTGTACCAGTTCAGCTAACCATAATTACGATCCCATCCATGCCAGG +TTCCAGTTGGGGCTTCGAGAAAATTGCACGGCCATTGACCTCTCCAGGGGTGCGAATATG +AGACCCAGCACTATCCCCGTGAGTCCTCGTCGTAGATCAAGAGGATGTTTCCTCGTGTCC +ACTGCCATAGATTATACATGATAAGATGGGACCCCGGCACCGGGCGACCATACACTTCCA +CAGATAGTACATCTGTATGTGTCCCTATCTGTTAGCCTCATAAAGTAAACCCTAAAGCCA +CTACCTAAAGACCAGACCTAAAGCCATCACCTAGAGAGCGACGCTATCTTAAAGACAACC +AGACCGATAGACCCATTGTTAACCTGTAGTGATGCCCTGTAGTTATCTGTAGTCATTTCA +TTAACCCTCACTAAAGGGAATAAGGGATACTTAAAGGGGGGAATTAGGGATTTAATAAAA +GATTAAAATTAATGGTTGACTTTAAGTAACCCTTAAGGCTATTATTCATCACGTCAACGG +GACAACGGCCTTAAAGCCACTCCCTGAGATACCGGAGTCAACCGGATAAGTAGACAGCCT +GATAAGTCATACGAAAAACAGGCATTGACAACGCAAGGTAACAAGTAGTAAGATGCACAA +CATAGCGTCAACCACCAAATCGGTGTCTTCTAGGTGACTTAAGCGCACCACGGCACATAA +AGCTAAACAAAATGGTTGACAACATGAAGTAAACACGGTACGATGTACCACGAAATGACG +GAACAGTGAGGCGGGACACTGAAAGCCGCTAGGGTCTAACGAAACCAGACCGACACGCAA +ATCATAGTAGGTTTAATAAGCGGTAAGTGTATTACTTCCCTTGTGTGCCGCCGAATGGCA +TCAGTACACACGACAGGCAGTACGGAAAGTGACACGATGCAGTGCTGCCATGATTTGATC +GCTCTTTAACAATCTGGATAATAGCTCTTGAGTGCACCGATGTATAAGCGAACTGCTCGG +TTAGAGCTACGAGGCGTGACTTAACGGGTAATCATGCACCGGACGAGGAAACTGGGGACC +GCATGCGTTGCGAACCCATCCAAATGCAAAAGACTTATCGAAACACCGAATGGGTAGGGG +TGTGCCTAAGATCCTCTGCATGGGGCGTCCGCCAATGATGTTGTTCATATCAAAGGAGGG +CGCGGAATCACGCATAACTCAAGGTCGCACTGAAAGCGTGGCCTTTATGATATTCACTAA +ACACGAACTAACATGAGGTAACACCCAATGATTTTCACTAAAGAGCCTGCTAACGTCTTC +TATGTACTGGTGTCAGCTTTCCGTTCTAACCTTGATGATGAGGTGAACATGAGCCGCCAC +CGCCACATGGTAAGCACTTTACGTGCCGCACCGGGTCTTTATGGCTCCGTTGAGTCAACC +GATTTGACCGGGTGCTATCGTGAGGAAATCGCAAGCGCACCGACTGAGGAAAAAACGGTT +CGTGTACGCTGCAAGGACAAGGCGCAGGCGCTGAATGTTGCACGCTTAGCTTGCAATGAG +TGGGAGCAAGATTGCGTACTGGTATACAAATCACAGACTCACACTGCTGGTCTGGTGTAC +GCTAAAGGAATCGACGGTTACAAGGCTGAACGTCTGCCGGGTAGCTTCCAAGAAGTACCC +AAAGGCGCACCGCTGCAAGGCTGCTTTACGATTGACGAGTTCGGTCGCCGCTGGCAGGTG +GCCTAACATGAATCGTTATTACATCAACGTACCGGGCTGGGGTGGGTCTCTGACCTGCTA +CGGATACAACGAACGGGACGCACGGAAACGCTTTAGAGAACAACACGGCTTCGGAAGGCT +TCCTAATGGGACGCGCATATGGCTGGACGCCCGTGATTGGTAAGTGATAGACTCAAGGTC +GCACTGTATGTGTGGCCTTTATGATTATCACTTATAGGACTAACACCATGAGTAAACTTC +TGGCAACATCTAAAATAGAAGGCCAATGCACCGTAACACTGCGTGAGTATTACCACGGGT +CAATGGGAAGCACCTATGTTGTGCGATACGGTAAACAGGTCACACATTGGGTAAACCCGA +TTTTAGCACAAGAGGATTATCAAGCCTGTGTGATACACCAAGCAACATGTGCGGGCTGGA +ATGATTGACATTACAGGAGGATTAGGAATGGTTATCTTTATCGCTGTCGCACTCTTTGCG +GTCGCTGGCTGGTACTCTGAGTCACGCAAGGCCGCTCGCTATCATCGCAAGATGGTTAAA +CTCATGGAACACTTGGACGCAGAAGGGCGAGGCCGCGAGGCTATCGAACTGGTGAAACAC +GCATGATGATTCTCTCTATCGCACTGGTCTATCTGTGCATCGCAATGTACTTTATGCGAG +ACTTTAAGCGCGGTCTGGCAATACACAAGGCAACGCTGAGTTACTTTAAGCGCGGTCTGG +CAATACACAAGGCAACGCTGAGTTACTTTAAGTGGGGATTCATCCCACGGTTTACGGTTC +GTGAACGCAACGGACGCTTTAAGGCCAACAAGGTAGGAGTATTCTACATTGCTACGCACT +AACTCAAAGCACGTAAAGACCGCACTGTATGCGATGGCGTATGGTGCATCGAAACGCAAG +GTCAAACGCATCTTAACGAGACACCGCAAGATGACCGCACGACAGGCTGCAAGCGCTGTC +AAATGGGCTGAATTTACTCTTTACTCTTCTTACAGATAACAGGACACTGAACGATGACTT +TCACCGAAGCACAAGCCGCACTCGAAGCTATCCGCAACCTACCGATTGAGCGCCTGAACG +AACGCTTAACGCCAGAACAGAAAGACAAACTGAAATTGGACTACCTACGGGCAGACTCCA +AGGAGGGTGCTTTCCGTGCAGCGTTTGGTGAGATGATTACTGATGCTGGAAACGAATGGC +AGGCTGCGGTGATTAACGGTAAGATGCCTGAGAGCACACCAGCGATCCAGCCCATGCTGG +TGGCTCTTGCGGCTGCTATCGTGAACGCTGAGACCCAAGACGGCGAACTGACGCAGGCCA +AGGGTAATTGGGGTCTGGAGTCTATGGACTACTGGCAGACACTGGCTGAGCGTATGCGTG +ATGTTGGATTTGTACGCTTGGGCAACGGTCACTTTAGCGCAACACCGTAACGTTGTCCCC +AAAGTCCCAATGAGACCACGACTGCTGCCTGATTTCCTCATCAATATAGAGGAACTTGTA +GATATACACTCGGTTCGGTGCTCCGCTCGTAAGGATAGCCGCGAAGTTCTCAGCGGTTGT +CCCCGATATACTGAATACTCCATTCGGTATGTAGTTCGGAACGTGAGCCGTCATGTCCTT +TGCGTTCTTCACAGAGCTTACATCCTGTACCGCATAGTATCGGTTAATGGATGTGAAGGA +AGCGCGAGGTGACGCAAAGCATATGAGCACGCATTGTTACCGGGCAAGGTTATCAAGGTA +GGCTTTAAGAAAGAGGATTCAGGCGCTGCCTATGCCGCATTCTGCCGTATGAATCAGGGT +CGTGAGGGCATCCCTACGGTCTTAGGCATCGCATCGTTCGATTGTCACAGCGGGAACATG +ATGAAAGACCAGATGGGACGCCTGATTATCACAGACCCGGTATCATTCAGCGCAGACGAC +AAGTTAAAGCCGGGTGAGTTCCACTGTGACCCGGATGAACTCATCGCTGAGATTGAGGCG +CTGAGAGCGCAGGAAGCGATTGACCGCTGTAAGGCACGCAAGGCACGCCGTGACCCTAAA +GGAGACTTTCAGGTAGCACGTAAAGCCCGTGCCAAGTGGCGCAGAAAGGCCTCTAAGCGC +GAGAAGCGCAACGCTAAGGTGCTCGCTAAGATGCGCATGGATGCTAATCAGAATCGCAGG +GATGAGCCTAGGGCGCGTATGGTGTGGGGCGATAAGCACTGGCGCAACGCTTGGATGCAC +CACAATAACCTAAACTTTGCAGAACTGGAGCGCCGCGCTGCTGCGGCAATGATGATGCAT +GACGAGGTGCGCATTCAGTGGGGCAAACCGTTACACATAGACGCATACCTTGACAAGCGT +CTACAAGGCTGATAGAGTCTTATCTTACAGGTCATCAATCGGTGGCCTGAATAGGTACGA +TTTATTCACAATGAGGTAAGCAATGAGCATCATCGAAAACATCGAAAAGAATGACTTCTC +CGAAATCGAACTGGCTGCTATCCCGTTCCACACACTGGCAGACCACTACGGCAGCGCATT +GGCTCGTGAACAACTGGCTTTAGAGCATGAGTCTTATGAGCTAGGCGAGCGCCGCTTCCT +CAAGATGCTTGAGCGTCAAGCGAAAGCTGGTGAGATTGCAGACAACGCAGCCGCTAAGCC +ATTACTCGCTACGCTTCTCCCTAAGTTAACCGCACGCATCGTTGAGTGGCTCGAAGAGTA +CGCCTCGAAGAAAGGCCGCAAGCCAGTAGCCTATGCACCGCTCCAGTTACTCAAGCCGGA +AGCCTCCGCGTTTATCACACTCAAGGTCATCCTTGCGTCACTGACCAGCACGAACATGAC +AACCATTCAGGCCGCTGCTGGTATGCTGGGGAAGGCCATTGAGGATGAGGCACGTTTCGG +TCGCATCCGTGACCTCGAAGCGAAGCACTTCAAGAAGCACGTTGAGGAACAGCTTAACAA +GCGCCACGGGCAAGTCTACAAGAAAGCCTTTATGCAGGTGGTCGAGGCCGATATGATTGG +TCGCGGGCTGCTGGGAGGTGAGGCGTGGTCTAGCTGGGATAAAGAAACCACGATGCACGC +CGGGGGCGGCTATTGGGCTAACGGTCGCAGACCTTTGGCACTCGTCCGCACTCACTCTAA +GAAGGGACTGATGCGCTATGAGGATGTTTACATGCCAGAAGTTTACAAGGCGGTCAACAT +CGCACAGAACACCGCATGGAAAATCAACAAGAAAGTTCTTGCGGTTGTCAATGAAATTGT +TAACTGGAAGAATTGCCCGGTCGCAGACATTCCATCGCTGGAGCGCCAAGAGTTACCGCC +TAAGCCGGACGACATTGACACCAACGAGGCAGCACTCAAGGAGTGGAAGAAAGCCGCCGC +TGGTGTCTACCGCTTGGACAAGGCACGAGTGTCTCGCCGTATCAGCTTAGAGTTCATGCT +GGAGCAGGCCAACAAGTTCGCAAGCAAGAAAGCAATCTGGTTCCCTTACAACATGGACTG +GCGTGGTCGTGTGTACGCTGTGCCGATGTTCAACCCGCAAGGAAACGACATGACCAAGGG +GCTGCTGACCCTCGCTAAAGGCAAGCCAATCGGTGAGGAAGGTTTCTACTGGCTGAAAAT +CCACGGTGCGAACTGTGCGGGTGTCGATAAGGTTCCTTTCCCTGAGCGCATCGCGTTCAT +TGAGAAGCACGTAGACGACATTCTGGCTTGCGCTAAAGACCCAATCAATAACACTTGGTG +GGCTGAGCAGGATTCACCGTTCTGTTTCCTCGCGTTTTGCTTCGAGTATGCAGGCGTTGC +GCACCACGGTCTGAGCTACAATTGCTCTCTGCCGCTGGCGTTCGATGGGTCTTGCTCCGG +TATCCAGCACTTCTCCGCGATGCTCCGCGATGAGGTAGGCGGTCGTGCGGTTAACCTGCT +GCCAAGCGAAACCGTGCAGGACATTTACGGCATCGTTGCACAGAAAGTAAACGAGATTCT +CAAACAGGATGCAATAAACGGCACACCTAATGAGATGATTACCGTGACCGACAAGGACAC +CGGGGAAATCTCTGAGAAGCTCAAGCTGGGAACCTCAACGCTGGCGCAACAGTGGCTGGC +ATATGGTGTAACCCGTAGCGTAACTAAACGTTCGGTCATGACGCTGGCTTACGGTTCCAA +GGAGTTCGGCTTTCGTCAACAGGTACTGGACGACACCATTCAGCCTGCGATTGACAGCGG +TAAGCTGCTAAGCTGCTAGCTGCTGAGGTCAAGGACAAGAAGACCAAGGAGATTCTTCGC +CACCGTTGTGCGGTTCACTGGACTACGCCGGACGGATTCCCGGTCTGGCAGGAATACCGC +AAGCCACTCCAGAAGCGTCTCGATATGATTTTCTTAGGGCAATTCCGTCTGCAACCGACG +ATTAATACCCTCAAGGATTCAGGCATTGACGCACACAAGCAGGAGTCTGGCATCGCTCCT +AACTTTGTTCACTCACAGGATGGTAGCCACCTCCGCATGACGGTCGTTTATGCTCACGAG +AAGTATGGCATTGAGTCCTTTGCGCTAATCCATGACAGCTTTGGGACTATTCCGGCAGAC +GCTGGTAAGCTCTTTAAGGCTGTGCGTGAAACGATGGTTCTCACCTACGAGAACAACGAT +GTGTTGGCAGACCCTCACTAACGGGAGACTACTTAAGGTCTCCCTTAAGGTACTAAGAGA +TTTTAATTTAAGATAACTAAGAGGTTTACTTTATGATTACTTTATGTGCCGCAATCGTTC +TTATCGCTACACTCTCAATCGTCATCGCTAAGCAGCGCTCTGAGTTAATCAAGCTGGATG +CCCGATATGATAGTGCGAACCACCACCGGAAAGAACTGGATGCAGCACTTGGGCGGTCAA +CCGATGAGGTTAAGACCCTTAAGCGCCAGCTACAGCACGCCGAGCAAGACGATAAGAACC +GCTGCGAAACAATCCGAGGTCTACGTGAAGAACTCCGGGAGTTGCGCCAGACGATTAAAG +AGCGCCACGCTATCCACGGCATCAAGTTCGTAGCGAACGTTCCGATGAAGGGATGATTAT +GGCCAGAATCGTGTATCACAACGGCACCAACTCTGGTGATATACTTCCCGCTGCCACCTC +AAGCTCTGCGCACGCGACAAACGGGTGGAACATTAAGACTGGACGCCCACCGAGTTTAAG +CTGGGTCTTGGTAAGTGCGGTCTGGAAGTGGCGAGTCTAGTGTGGGAAGAGAAGTCTGAC +CGCTATGTGTTGACTCAACGCCACACCGACGGAAGCCGAAAGGTCTTTGAGTACAAGAAG +GAAGACGTGCAAGGAAGAATCGAAGTGTTCTACCCTGCCGTTAAATAACCCTCACTAACG +GGAGAGTTAGCCTCAAGGTCATCACCGACGGTGGCCTTTGTGATTAACTTTCAATACACA +TCAACATGAGGTAAGATACTATGCGTACCAACTTTGAGAAATTTACCAAGCGCGATTCAG +TGGTCAACGAGCATGGCGAACAGTGGCAAGAGCGCCGTGACCGCATGAAGAAACGCCACA +AGCAACAGCGCGGTAACTCACAGAAACGGGAGTGGAACTAATGATGATGGGACGTATCTA +TAGCGGCAACCTGAACGATTACAAAGATGCGGTAGCGCGTCCACAGGAAGACCATGACGT +GACCGTGAAGGTGGAGTCATTCAGCTATGAAAACCCAGCGAAGATGTGCAGGTCATCCGG +TGAGGTTCTCCGTGTGTTCACACGCTCCGGTTCAAGACCAACCCATTCAAAGCTGTGTCA +TTCGTAGAGTCTGCCGTTAAGAAAGCGCTGGAGACCTCCGGCTACCTGATTGCGGACATT +AAGTATGATGGCGTGCGTGGTAACATTGTGGTTGACAACGTGGCTGAGGCCGCATGGCTG +TCCCGTGTGTCCAAGTTCATCCCGGCGCTGGAACATCTGAACGGTTTCGATAAGCGCTGG +CAACAACTGATGAATGATGACCGCTGTATTTTCCCTGATGGCTTCATGCTGGATGGCGAA +CTGATGGTTAAGGGCGTAGACTTCAACACAGGGTCTGGCCTACTGAGAACCAAGTGGCTC +AAGAAGAACAACTTCATGTTTGACCGTGGTGGTGTTGAGCCACTGAAAGGTTCCAAAGTA +GCCTTTGAGTTAGACCCCAAGCTACTCAGTGTTCGCCTGTATGCTGTCCTTCCGATTCAC +ATTGCGGAGTCTGGCGAGGACTACGATGTACAGAACCTACTGATGCCATATCATGTGGAA +GCCATGCGCTCTCTTCTGGTTGAATACTTCCCGGAAATCGAGTGGCTTATCGCTGAGACC +TACGAGGTCTACGATATGGATTCGCTGACTGAACTGTACGAAGAGAAGCGTGCCGAAGGT +CACGAGGGTCTCATTGTGAAAGACCCACAGGGCATCTACAAGCGAGGCAAGAAGTCTGGC +TGGTGGAAGCTCAAGCCTGAGTGTGAGGCTGATGGTATCATTCAGGGTGTCAATTGGGGA +ACCGAAGGTTTAGCCAACGAGGGCAAAGTGATAGGCTTTAGTGTGCTTCTTGAGACTGGT +CGTTTAGTAGACGCCAACAACATCTCTCGCGCACTGATGGACGAGTTCACAGCCAACGTT +AAGGCACACGGTGAAGACTTCTACAACGGGTGGGCCTGTCAGGTCAACTACATGGAAGAG +ACCCCGGACGGCTCCCTGCGTCACCCTAGCTTCGAAAAGTTCCGAGGCACTGAGGACAAC +CCTCAAGAGAAAATGTAACCAACTCACTGGCTCACCTTCACGGGTGGGCCTTTCTTCGTT +CGTTAATGCTAAGTGCTTGTTATGCAAAGGCAAAGTCGGACTTGAGAATGTCTTGTAGGT +TCAGCTTACCTTTCTTCGGAAGTGGTGGCATCTTGTCCAGTTGGGTCTCATGAAGCTGGT +CTGCAAACTGGTCGTAGAATAGGGAATTAACCCTCACTAACAGGAGACACACCATGTGGC +TTATCCTATTCGCTATCGTCGCAACGCTGGGATTAATGGTTGCCGACGACGACATTTGGC +CTGATTGTTAAGGAGACAACATCATGCGTTTACACTTCAACACATCAAATGGTACCTTTT +CGGTTCGCCGTGAAGACCGCTCTACAGCAGTGGCCTCTGAGCGCAACGCTAAGCTGCCGC +TGATTGGCTCGGTCGTCCCATTGTCGCCTCGTGTTCACCTACTGATCACTCGTGGAGAGT +TCATTAAGGCGATGAACAAAGAGCGCCCGCATCTGGAAGCCGTGGTCACTTGTTGGCCTC +GCATCCGTCTGTTCGTTAAGTGGATTAAGGAGGTTCTGTAATGTTACAACATCATTGGAA +CAAACCAGATTTAGAGGCTCGCTTCCCGGTTAACTCTGCTGTGCGATACTCCGGCGAATT +CCTCAAGCGCTTCTTAGGTATGAGCGGAGTGGTCACTGGTCACTCGAACACAGGTCGCGT +TAAGGTTCGCTTCGGTAATCAGCACGCTGAGTTTCTTCCGAACAACCTGATTCCGCTGCC +TAAAGATGACGTTAAGACTCCGAACGTGGAAGCACCGAAGTCAGAAGTCAAGTCTGACGT +AACCCACCCTAACCACTACATGCTGTTCGACAACGTGGAAGCCATTGAGGTTATAGCCCG +GTCAATGACCGTCGAGGCGTTCCGTGGGTACTGCCTTGGGAACATCCTGAAATACCGTCT +TCGTGCTGGTAAGAAATCCGAACTGGCAACTATGGAGAAAGACCTCAATAAAGCTGCATT +CTATCAGGAACTCTTTGACAAACATAAGGGGCTGTGCTATGACGCTTCGTGAATGCTGCG +ATTGGTGTGCCGCTAAGTGGAACCAAGCTATTGAGGATGGTGACAAGGCGGCTGCTGACG +CTTACCAACAACTGTACGCGCTGTGGGAGCGGCGCTTTAAGGAGGCTCAAAGTGGAGCAA +CGTGAACAGAAATACCTTCTGACGATAGAAGGCAACACCGAGTCCTTTGAGGTTCCGGTA +TTCGCCCGGTCTCTCGAAGAGGCAACGCTACAGGCTGAACATTATGAGGACGCTGGGTTC +GTAGTGACTCGCATCCGTCCAGAAGTGAAAGCCTAATTACCCTCACTAAAGGGAACAACC +AAATCATTAACCACAAAGGAGAAACATTATGGCTGGTTTCAAGAAGAAAATCTACACCTC +TGGTCTTGGCACTGCTGAGCCTTATGCTTACCTGAGTAAGCCGGATTATGGCAACGAAGA +GCGTGGCTTCGGCAACCCTCGTGGTGTCTATAAGGTAGACCTGACTCTTTCCAATAAAGA +CCCGCGCTGTCAGGCGATGGTCGATGAAATCGTGAAGACTCACGAAGAGGCTTATGCTGC +TGCCGTGGAAGAGTTCGAAGCTAACCCGCCGCAGGTACAGCGTGGTAAGAAACCACTGAA +ACCTTACGAGGGCGACATGCCGTTCTTCGATAACGGTGACGGTACGACTACCTTCAAGTT +CAAATGCTATGCGTCTTTCCAAGATAAGAAGACCAAAGAGACCAAGCACATCAATCTGGT +CGTGGTCGATAGCAAAGGTAAGAAGATTCAGGAAGTGCCGATTATCGGTGGCGGCTCCAA +GCTGAAAGTGAAATACTCTCTGGTTCCTTACAAGTGGAACACCGCTGTGGGCGCAAGCGT +CAAGCTGCAACTGGAGTCCGTGATGCTGGTCGAACTGGCTACCTTCGGCGGTGGCGGTGA +ATATGAGTGGGCTGATGTAGTCGAAGATGGTGGTTACACTGCGAGTGAATCCCGTGAGTC +CCGCGATGAGCAGGAGTGGCAGGAAGACGAGCACGAAGAAACCCCGGATGATAACGAGGA +CTTCTAATGGCTGGCGCATACGCTGCGCGAGGTGTACGCAAGGTTGGGGCTTTCCGCTCC +GGCCTAGAAGATAAAGTCTCAAAGCAGCTTGAGAGTAAGGGAATTAAGTTCGACTATGAG +CTTTGGCGTATCCCTTACGTCATCCCTGCGAGTGACCACTTATACACTCCAGACTTCCTG +CTACCTAATGGCATATTCATTGAGACCAAAGGGCTGTGGGATTCCGATGACCGCAAGAAA +CACCTTTTGATTCGTGAGCAACACCCTGAACTGGATATTCGCTTGGTCTTCTCAAGCAGC +CGCTCAAAGCTCTACAAAGGTAGCCCAACAAGCTACGCCGAGTGGTGTGAGAAGCATGGC +ATTCTGTTTGCTGACAAGCTAATTCCGGTGGAGTGGCTCAAAGAACCCAAGAAGGAGGTT +CCGTTCGATAAATTTAAGACTAAGAAAGGAGTAAAGAAAAATGGCTAAAGTTCAATTCAA +ACCACGAGAAACCACGGAGGCAATCTTTGTACATTGCTCAGCAACCAAGCCAAGCCAGAA +CATTGGCGTTCGTGAGATTCGTCAGTGGCACAAAGAGCAGGGCTGGTTAGACGTAGGATA +TCACTTCATCATCAAGCGTGATGGCACTGTGGAAGCAGGCCGCGATGAACTGGCTGTAGG +TTCCCACGTGAAAGGTTACAACCACAACTCCGTAGGGGTATGCCTCGTGGGTGGGATTGA +TGATAAAGGCAAGTTCGACGCCAACTTTACACCTGCGCAAATGCAAGCGCTGCGTAGTCT +GCTGGTCACGCTGCTGGCGAAGTATGAGGGTTCAGTCCTTCGTGCTCACCATGACGTTGC +ATCCAAAGCCTGCCCGTCCTTCGACTTGAAGCGCTGGTGGGAGAAGAACGAACTGGTTAC +ATCTGACCGAGGGTGATACCATGAGGATGATTTGTATTCGCTGTGATAAGCCGTTGAAGA +GTCGTGTACCGTCACGTCAGTGTCAGTGCAAAGACCCAATCAAGGCGGAGGAACACACCG +AGGAATAATTAACACTCACTAAAGGGAGACTTAACGGTTTCCCTTTGTTCGCACTATTGA +TTAAGGAATGTACAATGGAACGAGAAGACGTTAGTATCTTTCTGTTTCATGCTCCATGTG +AAAACTGTGGGTCTTCTGATGGTAACTCTGTGTACTCTGACGGGCATGAATGGTGCTTCG +TGTGTGAACATCGAGTACCCGCAAACGAAGAGCGTGAAGCAAAGTTATCAACGAGAAGAC +GTACAGGAGGCAGCAAGCCTATGAGCTATGACGTATGGAATTTCGGTGACAGCAACGGTC +GATACTCTGACCTAACTGCCCGTGGCATCTCGAAGGAGACATGCCAAAAGGCTGGCTACT +GGCTGGCGAAAGTGGACAACCGAATGTATCAGGTTGCCTACTACCGAGACCAGAACGGCT +CCATCGTGTCGCAGAAGGTGCGCGATAAGGACAAGAACTTTAAGACCACCGGAAGCCACA +AGAGCGATGCGCTGTTCTTGAAGCACCTCTGGTCTGGCGGTAAGAAAATTGTGGTCACTG +AGGGCGAAATTGATGCGCTCACTGTGATGGAACTCCAAGACTATCTTGATGCTCGACATG +GATGACGCAGGCCGTAAGGCAGTCGAAGAGGCCGCACAGGTTCTCCCGGCTGGTAAGGTT +CGTGTTGCCGTGTTGCCGTGTAAGGACGCCAACGAGTGTCACATCATGGGTGAAGACAAA +GCAATCTTGGAGCAAATCTGGAACGCGAACCCTTGGGTGCCTGACGGTGTTGTTTCTGCG +TTGTCACTCAAAGACCGCGTTAAGGAAGCTATGACCTCCGAGGACGCTGTAGGTTTATTA +TTCGATGGCTGTCAAGGCCTGAACGATAGAACCTTGGGGGCTCGTGGTGGCGAAGTCGTT +ATGGTCACTTCCGGTTCCGGTATGGGTAAGTCAACGTTCGTTCGTCAACAGGCTCTGGCT +TGGGGCAAGCGAATGGGTAAACGTGTGGGCCTAGCGATGTTGGAGGAATCCGTTGAGGAT +ACCATTCAGGACATGATGGGCTTGAACAATAAGGTTCGTCTGCGTCAGTCTGATGAAGTC +AAGAAGGCTATCGCAGAGGACGGACGTTTCGATGAATGGTATGATGAACTATTTGGAGAC +GATACGTTCCACCTTTATGACTCCTTTGCGGAGGCCGAAGCTGACAGGCTGTTAGCGAAG +CTGGCCTACATGCGAACAGGCTTAGGGTGTGATGTTATAGTGCTCGACCACATATCAATC +GTCGTGTCTGCCTCTGAGGAGTCGGATGAGCGTAAGATGATTGACCGCCTCATGACGAAG +CTCAAAGGGTTCGCTAAGTCAACTGGTGTTGTGCTCGTAGTGATTTGTCACTTGAAGAAC +CCGGAGAAGGGAAAACCACATGAAGAAGGACGCGCTGTTTCTATTACTGACCTACGTGGT +AGCGGTGCCTTGCGTCAGTTATCTGATACTATCATCGCCTTGGAGCGTAACCAGCAAGGT +GATATGCCTAACTTGGTGTTGGTTCGCCTGCTTAAGTGTCGTTTCACTGGCGACACTGGA +ATTGCTGGGTACATGGAATTCAACAGAGAAACCGTGCGATGGAATCATGTACCACTAATT +AACCCTCACTAACGGGAACAACCATTAAACCATAGGAGACACATCATGTTTAAATTCATT +AACGCTTTAGGTAAGCTGGTAGTTAAACTGTACTTCATCGAAGCCAAGAAGCTGGACAAG +AAGGCCAAAGCTGATTCACAGCGAGCCATTGAGTTGGCGAAACAGTCCCGTGAGAAATCC +GATGCGGCTGTTAGTGGCATCCACAAGTCGGCAGCGATTGCAGCCAAAGCACAATCCATG +AGCAAATTCTTTGAGTAAGGAGCGCACACTATGAGCAAGTCAATCACCCACGCAAACACC +ATGCGTCTGCCAGACACCGCTGACCAGTTCTCCCGCCGAGTACACATCAATGTGCGTGGT +GAGAAGGTCACGATGGTCTACCGCTGGAAAGACCACAAGTCTCCGAAAGCACACACTCAA +CGAATGACCTTGGATGACAAGCAGGTCGTGTATGATTTAGAGCTGGCCGGTGGTAATTGG +CACTCAAACCGGTCGCTTGATGGGTGCCCTGACTATGGCTGCTGACAAGGTGGTCGGTGA +TAACCGTGAGCGTCTGGTAGAGTTCGGCGCTGGTATGCAAGAGATTATCGAGAAGTGATA +AACTCAAGGTCGCCCAAGGGTGGCCTTTATGATTATCATTTAGCACGAAACCAAAGGAGG +GCATTATGCTCGTAAGTGACATTGCGGCCAACAACCTCTTAGAGAAAGTCACCAAGTTTC +ACTGTGGCGTTATCTATGACTACCGTGATGGTGAGTATCATAGCTATCGTCCGGGCGACT +TCGGGGCGTATCTGGATGCGCTGGAAGCCGAGGTGAAGCGAGGTGGGCTTATTGTTTTCC +ATAACGGTCACAAGTATGACGTTCCGGCTTTAGAGAAACTCGCAAAGCTGCAACTCAATC +GTGACTTCAAGTTACCCCGTGAGAACTGTATTGATACATTGGTACTCTCGCGTTTACTTC +ATGCGAACCTTAAAGACACAGACATGGGGCTTCTTCGCTCCGGGAAACTACCCGGTCGTC +GCTTCGGGTCTCACGCTCTGGAGGCATGGGGCTATCGCTTGGGTGAGATGAAAGGTGAAT +ACAAGGACGACTTCAAGGCTATGCTGGAAGAGCAGGGCGAAGAATATGTTGATGGTGCTG +AGTGGGTTTCGTTCAACGAGCCGATGATGGCGTATAACGTTCAAGACGTTGTGGTCACTG +TCAAACTCTTAGAGAAATTCCTTACAGACCTCCACTACTTCCCTGCGGGTATGGACTTCA +CGAAGTACGATGCGGATTGATTCTGGCGAGAAGCTGGCGAGTCTGTGGATATTGAACATC +GTGCAGCGTGGCTTTGAGCGAAGCAGGAGCGTAACGGCTTCCCGTTCAACACCAAGGCAA +TTGAGGAACTTTATGTAGAACTGGCAGCGAAACGCGCCGAACTTCTGCAAAAGCTAACCG +AAACGTTTGGCTCATGGTATCAACCGAAAGGCGGTAAGGAACTCTTCAAGCACCCACGGA +CAGGCAAGCCGCTGCCGAGCTATCCTCGCGTGGTCTATCCGAAACAGGGTGGCGTGTACA +AGAAGCCTCGTAATAAGGCACAGCGCGAAGGTCTTGAACCTTGCGACTTGGACACGAGGG +ATTACATGGAGGGTGCTCCATATACTCCGGTAGAGTTCGTTACGTTCAAGCCAAGTAGCC +GTGACCACATTCAGAAGAAACTACAGGAGGCCGGATGGGTTCCTGAGAAGTTCACCGAGA +AGGGTGCGCCTGTGGTGGACGATGAGGTCTTGGAGCATGTACGAGTAGATGACCCTGAGG +ACAGCGAAATAGCGGAGGCCGCATTCGTCGACACAGGTTGTTAAGGGCCGGTATGCCTGA +GAAGAGGTACGAACAATGGCTTGGCGATAATTCTAAGAGCATCTTATCATGCCGTAAAGC +CACGAAATAGTTTCCTGTGTATCAGATCATTGGCGTCGACACCTCCGCGCGAACGCCTAG +ATCAGTTAATAATAACCAGAAGCAGGCGTGCATTGACTTGATTAAAGAGTACCTGATGAT +TCAGAAGCGAATCGGTCAGGCGGCAGAGGGTGACAAAGCGTGGTTACGTTATGTTCAAGA +TGATGGTAAGATTCATGGAGCCGTTAACCCTAACGGTGCAGCTACTGGTCGTGCTACTCA +TAGTTTCCCAAACCTTGCACAAGTACCCGGCGTTCGTTCTCCTTACGGGGAGCAGTGTCG +TAGCGCTTTTGGTGCTGAACATCATTTGGATGGGATTACTGGCAAGCCGTGGGTGCAAGC +GGGGATAGACGCCAGTGGCTTAGAGTTGCGCTGTCTGGCACACTTCATGGCTCGTTTCGA +TAACGGAGAGTATGCGAATGAGATTCTCAACGGTGACATTCACACCAAGAACCAGAACGC +TGCGGAACTCCCAACGCGAGACAACGCCAAGACCTTCATTTACGGGTTCCTTTACGGAGC +AGGAGATGAGAAGATTGGTCAGATTGTTGGGGCGGGGAAGGAGCGCGGGAAGGAACTCAA +GAAGAAATTCTTAGAGAACACCCCGGCGATTGCAGCGCTACGAGAAGCTATCCAACAGTC +TCTCGTTAAGTCTTCCGCTTGGATTGGCGCTGAGCAGAAAGTACAGTGGAAGCGCCGTTG +GATTAAAGGTCTGGATGGTCGCAAGGTTCACGTCAGGTCTCCACACGCAGCGCTCAACAC +ATTGTTGCAGTCTGCTGGTGCTCTGATTTGTAAGTTGTGGATCATCAAGACCGAAGAGAT +GCTCATTGAGAAAGGCTTGAAGCATGGCTGGGATGGTGACTTTGCGTACATGGCTTGGGT +TCACGATGAGATTCAGGTGGACTGCCGTACAGAGCACATCGCTCAGATTGTTATTGACAC +CGCGCAGGAAGCTATGCGTTGGGTCGGAGAGCATTGGGCTTTCCGTTGTCGTTTAGATAC +CGAGGGTAAGATGGGGCCGAATTGGGCTGTCTGCCACTAACAATAGGAGAAACATTATGG +CAATGACCAAACACTTTAAAGTAACCTTCGACGTTACCGCTGTGATTGACAGTGAATCCG +AGAAGAATCTGAACGAGTTACTGGTAGACCTAGCTAAGAAGGCCGGGGCTGGCGAGAAGC +TGAATCCGTTCAAACAAGAACTGCTTATTCAAGGCCTGACACACGGGCCGGAAGGTGCTG +CTGCGTTCTGTATCAAGCAAGGTCTCCGTGAGTTTATCCGCGATGGTCACAGTGAGTTAA +GCTCTACCGAGCAGAAGCTGATGAGATTCTCACCTGCAACTGTGCGAGAGGTGTTCAAAT +GAGTGAATACCTGAAAGTTCTGGCAGCTATCAAAGGTTGCCCTAAGTCCTTTCAGTCGAA +CTATGTGCGAAACAATGCGGCTCTCGTAGCTGAGGCCGCTTCTCGTGGACACATTAGCTG +TTTGACTGTGGGCGGTCGCAATGGTGGAGCATGGGAGGTCACAGCCTCTGGTGTGCGCTT +CCTGAAACGAATGGGAGGTTGCGTATGATTATGCCTAAGAGTGACACCGTAACGATGACC +CGTGATGCGTGGAACGATGTTAGCGCGTACATTGATAAGCTGGAGAAAGGCCTAGAGTTC +CTGAATGCGCTTAAGGCGTGTGGTGTGGATAATTGGGACGGAGACTCTGATGCAGTCGAA +ATGGTTTACGGGGAGGATGACGAATGAGCCTAATCACATTGAAAGACTTCGCGGAGATGC +GTGAAGGTAATCCTATGGAGAAGGGAGTGCTGGTCATGGATGGTGACTGGTTGGTATATC +AGTCAATGGCTGCTGCCGATACCAATCGTGTATTGCCAGTATTCGTGGATTCGCTGGTTG +TAAATAAGGTGCTATTAGTCGCGTATGACGGATGATTCCCTCACTCAGTATGGCCCAGCG +CTTAGGCACGGCATTTGGGTGTCCACTTAATCGATTCAGCCCTGTTGCGCGACCATTTTC +TTGAACAGTGACCCAGTAAGTGAAGTTGAGACGGATTGGGGAGACGACATTTGGACTCTT +GAGTGTGACCACGCCAAGGCACGGAGCATTCTCGATTCTGCAATCGAATCGTACCGAACC +CGTAAGAAGGCTTGGAGTGACGCTATGGTTGTTCTGGCGTATACCGACGATGTGAACTGG +CGTAAGGTACTGGTTGATGAGACCTATAAGGAGAACCGTAAGGCGACCCGTAAGCCTGTG +GGCTACCGTGACTTCCTGTCGAAGCTGTGGGAGCGCGATGAGTTCATTCACATCAAAGAG +GACATGCTGGAAGGTGATGACGTTATGGGTATCATTGGGTCTGGTCACGAGGTCTTCGGC +TTCAAGAAAGCTGTGTTGGTCTCCTGTGATAAGGACTTCAAGACTATACCGGACGTTGAC +TTCCTGTGGTGTACCACTGGTAACATCTTGACGCAGACCAAAGAGACCGCTGATTGGTGG +CATCTCTTCCAGACTATCAAGGGCGATATGACTGATGGCTACTCCGGGATTCCCGGTTGG +GGTGACACGGCAGAAGGTTTCCTGAATGACCCGTTCATTGTGGAGCCTGTAGAGTCCGTG +TTGAAGTCCGGTAAGAACAAAGGGCAGACTGTCACTAAGTGGGTGAAACGCGCTCCTGAT +GCGACTGAGAGCCTGTGGGACTGCATCGTATCCATTGGTGCCAAAGCTGGGATGACCGAA +CATGAAATCATTAAGCAAGGCCAGATGGCACGCATTCTTCGCTTCGAGGAATACAATTAC +ATTGACAAGGAGATTTACTTATGGACGCCGCGAAGCTGATTACCACCGTTGTGCTGGTAG +GTATGCTGGCGCGAGGTCTCTGGATGTTCGCTCTCATAGTCCGAGACGTGAAGCGAGACT +CCGAGATTAAGTGATACACTCAAGGCTCTCTGTATTAACCCTCACTAAAGGGAAGAGGGA +GCCTTTATGATTATTACTTTAAGACTTAACCTTAAGAGGTGAATTTATGTTACAACCAAT +TAATCATGTTTTAACTCATCCCGATGATATTCCTAGTATGCCGCGTGCAGCTAAAGAGTA +TCTACAGGTGAGCTTCAATCAGGCTTATGTGATGGAGTCCGGGGAGTACCGTGCGCTCCG +CGCTGCTGGTTACTCTGAGTCTTTCATTGCGGGTGTGATGCATGGTCTGTACCTTGCCTC +TCGAACACTTGATGAGATTGAGGTGCGTAAAGAGCAACTGAGACAGGAGTAACGATATGT +GCTGGAAACCGAAGGTGAAAGTCCCTAAGATGGACACTAACCAGATTCGCGCTGCTGAAC +CAGCACCTTTGACTGAACCTCCGAAGTCTGTGGTATGGGGAGGCGATGATGACGAGGACA +CCAGTGTGTCTTCCTCTGAGGTGCCAACCACACCGAGCAGCGGTAAGAGCAGTCTCAAGG +TAAAGCTGGATGACAGCGCAGCCAAGAACAAGAGAGAACTTGCGGATATCCTTGCAGGTC +TCAATGAAGCCCTCGCTTATCGGGTACTCTTCGGCGGTATCGAAGCAATCCTCCTGAATG +ATTTCCTGTGCAGCCTGAAAGTGGTGACGAATCTTATCACTTTCACCGTAGCACCAGTCA +TTAAGCGGTGTCAGATAGTCCAAGACCACCGTGTAGCAGCCTGTATGACGCTGAATGTCG +TACATAAATCCTCCATTCGCTCCAAGGCGTTTGGGTAACTGAGTCATAGCATAGGGAGAA +ACATCATGGGATTCTTCAAGAAAATCAAGAAGGCCGTTAAGAAAGTTGTGAAAGAAGTTA +GTAGACCAGTCGAGAAGGCCGGTAAGGAAGTGGGCAAGGTGGTTGGAGGCGCGCTGGGTG +CAGGTAAGCAGGAGATTATCCAACAAGAGGCTCCTGTACCAGTAGTCGCTGCACCGCCAC +CAGCACAGGTTGTAGATGTACCGGAACAGGATAAGGCTGAGGGTGAGGATGAGGCGCAAA +CCGAAAGCGCACGTAAGAAAGCACGCGCTGGCGGTAAGAAGTCTCTGAGTGTAGCCCGTA +GCTCCGGCGGTGGCATCAACATCTAAGGAGGACTGAATGGCTGATTCAAAACGTACAGGA +TTGGGCGAAGACGGTGCTAAAGCTACCTATGACCGCCTAACGAACGACCGTAGAGCCTAC +GAGACTCGTGCGGAAAACTGTGCGCAATACACCATTCCGTCCTTGTTCCCGAAGGAGTCC +GATAACGAATCTACCGACTACACGACTCCGTGGCAGGCTGTAGGTGCGCGGGGTCTTAAC +AATCTGGCCTCTAAATTAATGCTGGCACTATTCCCGATGCAGTCGTGGATGAAGCTGACC +ATTAGTGAATATGAGGCGAAGCAGCTTGTTGGAGACCCTGATGGACTCGCTAAGGTGGAC +GAAGGTCTGTCTATGGTTGAGCGTATTATCATGAATTATATCGAATCCAACAGCTACCGT +GTGACACTCTTTGAGTGCCTCAAGCAGTTGATCGTGGCAGGTCATGCACTGCTTTACTTA +CCGGAACCAGAAGGCAGCTACAATCCGATGAAGTTGTACCGATTGTATTCTTATGTTGTC +CCTACTGACGCTATGCCCTACATTCCGGTTCGCATGGTTCGCATTGATGGCGAGTCTTAC +GGTCGCTCCTACTGTGAAGAATACTTAGGTGACTTAAGGTCGCTTGAGAATCTCCAAGAG +GCTATCGTTAAGATGAGCATGATTAGCGCGAAGGTCATCGGTCTGGTGAACCCAAGCTGA +CTTTACCGTAGCGAAAGCTGTGAGTGACCAGATAGAAGCACGCTTATCGTATGCCTTTAT +GTTGAACTTTGCGGTGCAACGAACAGGTGAACGTGTGACCGCCGAAGAGATTCGATACGT +TGCGTCAGAACTGGAAGATACGCTTGGTGGCGTCTATTCGATTCTGTCTCAAGAACTGCA +ATTGCCTCTGGTTCGTGTGCTCTTGAAGCAGCTCCAAGCAACCTCGCAGATTCCTGAGCT +ACCGAAAGAAGCCGGTGAGCCGACTATCAGTACAGGTCTGGAAGCAATCGGTCGTGGTCA +AGACCTCGATAAGCTGGAGCGCTGTATCTCCGCTTGGGCTGCTCTGGCCCCTATGCAGGG +AGACCCGGACATTAACCTTGCTGTCATTAAGCTGCGCATTGCTAACGCCATTGGTATTGA +TACTTCTGGTATCCTACTGACTGACGAGCAGAAGCAAGCACTGATGATGCAGGATGCGGC +CCAAACAGGTATCGAGAACGCTGCCGCCACTGGTGGGGCTGGTGTGGGTGCTCTAGCGAC +CTCAAGTCCAGAAGCTATGCAGGGTGCAGCAGCACAGGCTGGCCTAGACGCCACCTAATA +ACCCTCACTAAAGGGAGACCTCATCTTTGAAATGAGCGATGACTAAAGGTTGGAGTCCTT +TGGTTTCCCTTTATCTTTAACAACTTAGGAGATTTAACAATGGCTGAATCTAATGCAGAC +GTTTATGCGTCCTTCGGTGTGAACAACGCGGTAATGACCGGAAGCACACCTACTGAACAC +GAACAGAATATGCTGAGTCTCGATGTTGCTGCCCGTGATGGCGATGATGCAATCGTACTT +AGCGAGGAACCGAGTTCCCATAACGATGACCCATATGCATCCGGTGTAGACCCGTTCGCT +GATGGTGAAGACGATGAGGGCCGCATTCAGGTTCGTATCAGTGAAGATGGTAATGAAGCC +GAGTTCGACACCGGTAGCGATAACGCTGAGGTGGAGACCGAAGGTGAGGCCGCTGAGTTT +GAACCGCTGGGTGACACTCCAGAAGAACTGAGCCAAGTGACTGAGCAGTTGGGACAGCAC +GAAGAAGGCCTTCAGGCGATGGTCGAGCAGGCCGTTGAGCGTGGACTGAGCGCAGAGTCT +GTGACTCGCATCTACGAAGAGTACGGAGCCGATGGCATCTCTGAGAAATCCTACGCGGAA +CTCGAAGCTGCTGGCTATAGTCGTGCCTTTGTGGACTCCTACATCTCCGGTCAGGAAGCC +CTTGTAGACCAGTACGTCAATCAGGTAGTTGCCTTTGCTGGTGGTAAGGAGCGCTTTAGC +GCAATCCATACGCACCTTGAAGCAACCAACCCGGCTGCGGCTGAGTCCCTTGAGACTGCC +ATGATGAACCGAGACTTGGCGACTGTCAAAGCAATTATCAATCTGGCTGGTGAGAGCTAC +ACGAAGAAATTCGGTAAGCCTGCCAACCGTAGTGTTACCAAGCGTGCTACTCCGGTTAAA +CCTGTAGCTCGTCAGAAAGATGGCTTTACGAATCAGGCTGAGATGATTAAAGCTATGAGT +GACCCGCGTTACCGTAGTGATGCTGCCTACCGTCAAATGGTAGAACAGAAGGTTATCGAC +TCCAGTTTCTAATTAACCCTCACTAAAGGGAGAGACCATAGATGACTACAATGGTTGAAT +CACCTGAGCACAGAACTTTGTGGTCACTCCCGTAGGTGAAACATTGAGAACCAACTCGAT +TCAAGTAGTAACCAAACTTTTCTTTAAATTAACATAAGGAGATTCAACATGGCTAACAAT +CAAGGCGGACAGCAAATTGGTACTAATCAGGGTAAGGGTCAGTCCGCAGCGGACAAATTG +GCGCTGTTCCTGAAAGTGTTCGGCGGTGAAGTCCTGACGGCTTTCGCTCGCACCTCCGTG +ACCATGCCTCGTCACATGCTGCGCTCTATTGCTTCTGGTAAGTCCGCACAGTTCCCTGTG +ATTGGTCGCACCAAAGCTGCTTACCTGAAACCGGGTGAGAACCTCGATGACAGTTGATGC +ATCTGACTCGATAGTTACTATGTTCGTCTGAGCGTTTCCAACAACCGGGAAGCGGTACTG +CCCTGTGCCAATGTTCGACCTGCCAACACGCAGATTGTCAGAACGTAAGGATATCAAACA +CACCGAGAAGGTAGTCCACATTGATGGACTGCTGACTGCGGACGTTCTGATTTACGACAT +TGAGGACGCGATGAACCACTACGACGTTCGCGCTGAGTACACCGCACAGTTGGGTGAATC +TCTGGCGATGGCGGCTGACGGTGCTGTACTGGCTGAACTGGCTGGTCTGGTTAACCTGCC +GGACGCCTCCAATGAGAACATCGAGGGTGTCGGTAAGCCTAGCGTACTGACTCTGGTTAA +GCCGACCACTGGCGACCTGACTGACCCGGTTGAGCTGGGTAAAGCGATTATCGCTCAGTT +GACTATCGCTCGTGCGTCTCTGACCAAGAACTACGTTCCGGTTGCTGACCGTACCTTCTA +CACCACTCCTGATAACTACTCTGCGATTCTGGCCGCTCTGATGCCGAACGCTGCAAACTA +TCAGGCACTGATTGACCCTGAGCGCGGTACTATCCGTAACGTGATGGGCTTCGAAGTGGT +TGAGGTTCCGCACCTGACCGCTGGTGGCGCTGGTGATACCCGTGAGGATGCCCCGGCTGA +CCAGAAGCACTCTTTCCCGGCGACTTCCAGCGCTACCGTTAAGGTTGCTCTGGATAACGT +TGTGGGCCTGTTCCAGCACCGCTCTGCGGTTGGTACGGTCAAGCTGAAAGACTTGGCTCT +GGAGCGCGCTCGTCGTGCGAACTATCAGGCTGACCAGATTATCGCTAAGTACGCGATGGG +TCACGGCGGTCTGCGTCCAGAAGCTGCTGGCGCTATCGTGCTGCCAAAGACTTCGGGGGC +TTAAGGGTAGCGCCTTTGAGTATGAACGCGGAGAGTGAAGTGGAGCCGACCCAAGAGGTA +GCCGCCGAAGTAGCTCTCACGCCTCAACAGAAGGCCGCCATTACTCGTGCTCGTAACAAG +GCACTTAAGTCTCAATAACAACAAGCAAACCCCTTGGGTTCCCTCTTTGGGAGTCTGAGG +GGTTTTTTGCTTTAACCCTCACTAACAGGAGGTAACATCATGCGCTCTTATGAGATGAAC +ATTGAGACCGCAGAAGAGTTATCAGCCGTCAACGACATTCTGGCTTCCATCGGTGAGCCA +CCAGTATCGACCCTTGAGGGTGATGCAAATGCTGATGTTGCAAATGCTCGACGTGTGCTC +AACAAGATTAACCGACAGATTCAGTCACGAGGATGGACATTCAATATTGAGGAAGGTGTG +ACTCTTCTACCGGATGCGTTCTCTGGTATGATTCCATTTAGCTCTGATTATCTGTCCGTA +ATGGCAACCAGCGGTCAGACCCAATATGTCAACCGTGGTGGCTATCTCTATGACCGCTCT +GCGAAGACTGACCGATTCCCATCTGGTGTTCAGGTCAACCTGATTCGTCTGAGAGAGTTC +GATGAGATGCCTGAGTGCTTCCGAAACTACATCGTTACCAAGGCTTCCCGTCAGTTTAAC +AACCGCTTCTTCGGTGCGCCGGAGGTAGACGGAGTGTTGCAGGAAGAGGAACAGGAAGCG +TGGCGTGCGTGCTTCGAGTACGAACTAGACTACGGCAACTACAACATGCTGGACGGTGAC +GCATTCACCTCTGGTCTACTTAACCGCTAATATGTAAGTACCCGGTCGTATCATTAGGTC +ACGGTGCCTCTGCTGCTAAGAAGACATGCGCCGCTAACTATGAATACTTTGACCAGTTCG +AGCAGATACAAGGAGGCTCTATGGCTCTCATTAGTCAATCAATCAAGAACCTCAAGGGTG +GTATCAGTCAACAGCCAGATATTCTCCGGTTCGCTGAACAAGGTAGCGTACAGATTAACG +GTTGGTCTTCTGAGTCCGAGGGTCTCCAGAAGCGCCCACCGATGATTCACGGCTGGCATT +ACGCAGCCACGTAGATTAACCAAAGCTCAGACTGGTGACTTCGTTCCGGGTCGTCGAGAA +GACATTGACTTCCTTCAACTGGAGAAGCCTTAAGACCCTTGGTGCTGCTGGGTATGTGGG +TGCGCAACCTTACGTTCACCTCATCAACCGTGATGAGTTCGAGCAGTATGTCGTGGTGTT +CACTGGTGAAGACATTAAGGTATTCGACCTCGACGGTAAGGAGTACCAAGTACGTGGAGA +CCGCTCATATGTTCGTACAGCTAACCCACGAGAAGACCTTCGGATGGTAACTGTGGCTGA +TTATACCTTTGTGACTAACCGCAAGGTGGTTGTACAGAGTAACGACCAATCGGTCAACCT +TCCGGGCTTTAAAGACCAAGGCGATGCGTTGATTAATGTTCGCGGTGGACAATATGGGCG +TAGACTCTCAATCGAGTTCAACGGGGCTGAGCGTGCTGCTGTACAACTACCGGATGGTTC +ACAACCAGCACACGTTAACGAGGTTGACGGTCAGGCTATCGCTGAGAAGCTGGCTGTGCA +GTTGAGGAACAACCTTGGGAATCCAAACAACGAGCAAGACCCGAATAAGTGGCGCTTCAA +CGTTGGCCCCGGATTCATCCATATCCTTGCGCCAAATAACGATAACGTTTGGGGACTACA +GACTAAGGATGGTTACGCAGACCAGCTAATCAACCCTGTAACCCATTACACTCAGTCGTT +CCAGAAGCTGCCTATTAACGCGCCAGATGGGTACATCGTGAAGATTGTTGGTGATACCTC +AAAGACTGCCGACCAGTATTACGTTAGGTTCGACCTCAACCGTAAGGTGTGGGTAGAAAC +AATTGGATGGAACACAAGGACTCACCTACATTACCACACGATGCCTTGGGCACTTGTTCG +CGCTTCTGACGGGAACTTTGACTTCAAGTACCTTGAGTGGGGTGCTCGTACTGTGGGGGA +CGATACAACCAACCCATACCCATCCTTTACCGGACAGACAATCAACGATATTTTCTTCTT +TCGTAACCGTTTGGGATTCCTTAGTGGGGAGAACATCATCTTGTCTCGCACCTCGAAATA +CTTCAACTTCTTCCCGGCATCCATGTCAAACTACTCCGACGATGACCCAATCGACGTTGC +GGTTAGTCATAACCGGGTGTCAACCTTGAAGTATGCCGTTCCGTTCTCAGAAGAGTTACT +CCTGTGGTCTGACCAAGCGCAGTTCGTTCTGACAGCCTCTGGAATCCTTTCGAGTCGCTC +CGTAGAGTTGAACCTTACGACGCAGTTCGACGTGCAAGACAGGGCACGCCCACATGGTGT +AGGACGTAATGTATACTTGCAGCACAGGTGATAAACTCAACAATGACTGTATTGATGAGC +AATGAACATGCTGTGTGGATGGGACGCTTACACTTCACGAAGAACTCCATAGACATTCCG +GGAGAGCCTTACAGATTATACATCGACGCTAAGAGGAAATACACCATCCCTGCCGGGACG +TATAATGATGATACCTACCAGACGTCCATAAGCCTCGCAACAATTTATGGGATGAACTTC +ACTAGGGGTAGAGTGTCTGTGGTCTTTCCTGATGGGAAGATTGTAGAGATAGACCAACCA +ATCAACGGGTGGAGTAGCGACCCAATACTGAGACTTGATGGAAACCAAGAGGGACAAGTA +GTCTACATTGGGTTCAACATCCCGTTCACTTATACGTTCTCGAAGTTCCTCATCAAGAAG +ACTGCTCAGGACGGCTCGACGGCTACCGAGGATATTGGTCGTTTACAGCTTCGGCGTGCG +TGGGTAAACTATGAGGACTCTGGAGCGTTCACCATCCGTGTGAACAACCTGTCCCGTGAG +TTCATCTACACAATGGCTGGTGCTCGCTTGGGTTACCACTGAACATCATTGGGTGCGGCT +GGGAGGGGAACTACCTTCGTCGTTCTTCTGGCATTTAACTTAAAGTCTCCCTGTGGTGAA +TTAACCCTCACTAAAGGGAGACACTAATAGATACGAGGGGTTAAAGCATTATGTACATTA +CAAAGTGTTTACAAATCCATGCCGACAACTTTCAGCCGTCCATAGAGGACATTCTGGAAG +CTGAGGCACTAGGTGTTGAACCAAAGGTAATTCCTGATGAGAACACTGTGGCAATGCTTA +GCGATAACGCTGTGTTGGCAATCGGTGGCAATCAGGGAGACCGAGTGTGGTTCCTTACCT +CTAAGTACGTCCCACTGTTTACCTTGAAGGAGCGCTTAGAGTTTCGTAGACTTATCATTG +AATATCGTGATATGATGCTGAGCCAGTACGAGTCCATTTGGAATTTCGTTTGGGTACGCA +ATAAGTCACACATTCGTTTCCTAAAGACCATAGGCGCGGTATTCCATAAAGCTCTAAGTA +GCCAGAACAGTGCTGACAAGGCGCGAGTGGCACAGACCGAAGCTGGACGCAGACAGGCAA +TGGAGATGGTCAAAGAGATGAATATCCAAAATGCCAACGCCTCGCTGGAACAACGGGACG +CCCTTGAAGCTGCATCCTCTGAGTTGACTACACGTAACATGCAGAAGGTACAGGCTATGG +GAACCATCCGTGCAGCTATTGGCGAGGGTATGCTCGAAGGTGAGTCCATGAAGCGCATCA +AGCGTATCGAAGAGGGCAACTACATTAGGGAGGCAATTAGTGTCACCGAGAATTACCGCC +GAGACTACGCGAGTATCTTTGCGCAACAGTTGGGACGCACTCAGTCCACAGCGAGTCAAG +TCGATGCAATGTACAAGAGCGAGGCCAAAGGTAAGTCTGGTCTGATGCGTGTACTAGACC +CTCTGTCCATTATGGGTCAGGAAGCTGCAAGTCAATATGCGGCTGGTGGATTTGACAAGA +AGGGTGGAAACCAAGCAGCACCTATCAGTGCCGCCAAAGGAACCAAGACCGGGAGGTAAT +AATGGCTAGTAAACTAAATAGTATTTTAGGCAACATGGCGACTCCCGGTATGGAACGACT +CCGGGGCGTCAAAGGTATGGACTACCGGGCAGCAACCATTCAGGCTGAACAACCAAGAGC +GAGTCTTCTGGACTCCATTGGTCGATTCGCTAAGGCTGGTGCCGATATGTACATGGCGAA +AGATGAACGTGATAAGCAACGAGCCGATGAGCGCTCCAACGAGATTATCCGTAAGCTGAC +CCCTGAGCAGCGCCGACAGGCTATCCAGAATGGTACACTGCTGTATCAGGATGACCCATA +CGCAATGCAAGCCTTGAAGTTCAATACCGGGCGTAACGCTGCGTTCCTCGTTGACGATGA +GGTTCAACAGGCCATCAAAGAGGGTCGCTTCCGTACTCGTGAAGAGATGGAGCAGTATCG +TCACTCACGCCTACAGGAGCACTCGAAGTCGTTCGCTGAGCAGTTCGGTATCAATGAGAT +GGACGAGGAATACCAGAAGGGTTTCAACGCGAATATCACCGAGCGTAACATTGCTCTGTA +TGGGGCACATGATACCTTCCTGAGTGACCAAGCGCAGAAGGGTGCAATCCTGAACTCGAA +GGTTGAACTCAACGGTGTCCTATCTGACCCTGACCTACTGTCTCGTCCTGAGTCCGGTGA +GTTCTTCCAGAACTACATTGACAACTCCTTGGTGACGGGGATGACCGACAATCAGGCTCA +ACAGGTTATCTCTTCGTCCCTGAATGACGTGCTACAGCGTCCGGGTGGTGCCGCCTTCTT +GCAGAACATTGAGAACCGCAAGGTGACTCTTAATGGCGCTACGACTACCTATCGTGAACT +GATGGGTGGTGAGCAGTGGCAGGCAATGATGATTAAGGCACAGCACACTCAATTCCAGAA +CAACGCGAAGTTAACCGAGAAGTTCCGACTGGATATTAACTCAGCGCTTAACCAAGCAGA +CACTGGTAAAGGCTGGGAGACTCTTCAAGGTATCAAGGCCGAACTCGATATGATTCAGCC +GGGTGAAGAGATGACTCCTGAGCGCGAGTGGTTGATTTCCGCACAGGAACAGATGCGCAC +ACGCTTCAAGCAGGAACAGGCTGAGACAGCCAAGCTGATGGACAAGCAACAGAAGACCTT +GAATAAATCTTTGGTCATCGACAAGCAGTTCCAGAAGCGCCTCAACGGTGAATACGTCTC +GACAAACTATAAGGACATGCCGACCAACGAGAACACTGGTGAGTTTACACATAGCGATAT +GGTCAACTACGCGAACCAGAAGTTAGCGGAAATCGAAGCGATGGAGGACAACCTTCGTCG +CATCCGCAACACTGACCATGACCTGATTGCCTCTCTGTATCCTGACAAGGCCGAGTTGTT +CCTGACTATGGACATGTTGGATAACCAAGGTATCGACACGCAGGTACTTATCGACGCTGA +TAAGTCCCGCGCACAGAAGACCAAGGAGATGCAGTTTGAGGATGACCGAGCGTGGGCTGC +TATGATGAACGATTCAACGAATCCTCAAATCAAGTACATGCCTTCGAGTGTCCAAGGTTA +CGCGCGGAAGATTTATGATTCCGTGAAGTACCGGACAGGGAACCCTGACATGGCAACAGA +ACAGGTCGCAAAGTTCCTCTCTGATTCAACGACTACGTTCTCCAGTAGTGATGTTGATGG +CGATACCTATGGTGTCCTGCCGAAGAACATCCTGACTGTTTCGGATGACCCTAAGTCGTG +GGAGCAAGGGAAGAACATTCTGGACGAAGCCATTAAGGGAATCACAGCGGCGAACCCTTG +GATTACCAACAAGCAACTGACGGTGTACCAGCAAGGTGATTCAATATACCTGATGGACAC +AACCGGACAGGTTCGCATTCGGTATGACCAAGAGTTGCTCCAGCGTGAGTACCAGCGTAC +CGCACAGATGCAAGCTGAGGCAGCACGAGAGAAAGCCCTCAAAGAGGCCAACAAGCGTGC +CCCAATCAGCCGTGTACCACAGGCGCGTGAAGAAGCGCGTAAACGTGTCCAAGAGAAACG +GAAGAAGACTCCGAAGTACATCTATGGACGTAAAGAAGACTAACAGTGATAAGGAGGCTC +CATGAGCTACGATAAGAACAAACCTAGCGAGTTCGATGGGTTATTTCAAAAAGCGGCAGA +CAAACATGGGGTCTCCTATGACCTGCTTCGTAAATTAGCATTCAATGAGTCCAGTTTCAA +TCCAAAGGCCAAATCACCAACTGGCCCGAAGGGTCTCATGCAGTTCACCAAGGGTACAGC +CACTGCGCTGGGACTCAAAGTCACTGATGCAGACGATGATGACCGTTACAACCCGGAGTT +GGCTGTGGATGCAGCCGCTCGTCACCTGAGTGACCTCATTCGTAAATACGATAGGGATGA +GCTTAAGGCAGCCCTAGCGTACAACCAAGGCGAGGGAAGAAATGGTGCCCCTCAGATGCA +GGCCTACGACAAAGGTGATTGGGCCTCAATCTCTGAGGAAGGTCGTAACTATATGCGTAA +CCTGATGGACGTAGCTAATAGTCCTCGCAAGGGGGACTTGGAGGCGTTCGGCGGTATCAC +CCCAAAGGCTAAGGGCAAGCTATGAATATCATCACCCTTAAGTCCCACGTTAGGAAGCTC +TTCATTGCGATTCTGACGGTTCGGAAGCCACTGGTAATGCATTGGGGCTTTCTCGAAGTC +CAGACCGCACACGATAGCGTCACGGAGGCGTAAGGGGTACTTCTCGGCATCACTCAGGTT +CGGGTTGAGCATGAACTGCAAAGTGAAGCCAGCCTTACCGTATTCCAACTCACGCTCACG +CAGGTCTTCCATATCGAAGCGCACGGGGTCAGTCGGTTGACCTTGGAGCATCTTCCATCG +GGGGATGCATTTGCTGGAATCGGGAAGAAGCAGACGGTAGGCACTGACCTGCCGGAGTCA +ACGGGATTCAAAGTGGAGGGTAAAGAGCAGCAAGCGCCTAACGTTCCTTATGCTAAGGAC +TTTTGGGAAAAGACTGGAACAACACTGGACGAGTTTAACTCACGCTCTACCTTCTTCGGA +ATTGGCGATGCAACAAGTGCGGAGCTTCATAACTCTGTACTTGGAGTTGCTTTCCGTGCA +GCCCGTAGCGACGATGGTTTTGATTTGTTCAAGGACACCATTACGCCTACCCGTTGGAAT +AGCCATACGTGGACTCCAGAAGAGCTAGAGCGAATCCGTAAGGAAGTGAAGAACCCCGCG +TACATCAACGTAGTCACTGGAGGCTCTCCTGAGAATCTGGACGCCCTCATTAAGATGGCG +AATGACAACTATGAGATGGATGCGCGGTCTGCCGGTGCTGGTGTTGGCGCCAAACTTACT +GCTGGTATCATCGGCGCTGGTGTAGACCCGCTGAGTTATGTACCGCTAGTAGGCGTAGCC +GGGAAGGGTCTCAAGGTGGTTAACAAGGCTTTCATTGTGGGTACTCAAAGTGCTGGCCTC +GCGGTTGCCTCTGAGGGTCTCCGTACATCAATCGCTGGTGGAGAAGCCCACTATGCTGAT +GCTGCTTTAGGTGGTCTCTTGTTTGGTGCTGGTATGAGCGCAATCAGTGATGCTATCGCT +GCTGGTGTTCGCCGTTCCCGTGGGACTGAGGTAGTTAATGACTTCGCTCCTATGGCACAC +CGCTTGGAAGCCCGTGAGACCGCTCTGAACACTGGTGGGGAAGACCTGACCCGTATGCCT +AGCGAGAACCGTGTGTTCGACCGTGAGCACGCTGGCGTTGAGTATTCACCTCTGGAGACC +GAGCCGGGTGCCGTTGTGTTGCCTCAAGGTCAAATCCTGAGCGACACCAACCCACTGAAC +CCTCAGACTCTTAGCGAGTTCGAGGCGGTCAACCCTGAGCGTGCCGCTCGTGGTATCTCT +TTGGGTGGTTTCACTGAGATTGGCTTGAAGACTCTCCGCTCTGAGAACCCGACTGTTCGC +TCCATTGCGAGTGACCTTGTGCGTTCTCCGACAGGGATGGAATCAGGCTCTAATGGTAAG +TTCGGTGCGACTGCTTCTGACATTAAGGAGCGGCTCCACGCGAACAATCAGCGCACCTAC +AATCAGCTTTATGATGCTGTGCGTACTGCAATGAAAGACCCTGAGTTCTCCACAGGTGGT +GCCACAATGAGCCGTAAGGAAATCCGACAGGAAATCTTCAAGCGTGCAGCCTTGGCGATT +GAGCGACCTGAGCTTCAGGCAAACCTGACAAAGGGTGAGCGGAACGTGATGAACATCCTC +AAGCAGCACTTTGACCTCAAACGTGAAATCATGGAGAACCCGTCAATCTTCGGCAACACC +AAGGCGGTCAGTATCTTCCCCGGCTCACGCCACAAGGGAACCTACGTGCCAAACGTGTAC +GACCACGCTATCAAGATTGAGATGGTTAAACGTTACGATAATGATGGCTTGCAGCGAGCA +ATCGCGGAGTCATGGTTGACGTCTTATCGTGCTCGTCCAGAAGTCAAGGCGAGGGTCGAT +GAGTACCTGGTGGAACTTAACGGTCTCAAATCCGTGCAGGAAGTTACGCCTGAGATGGTG +CAGAAGCACGCGATGGATAAGGCGTATGGTATTTCACACACTGACCAGTTCTCTGCCTCC +TCTGTCATTGAGGATAACATTGAGGGTCTGGTGGGTATCGAGAACAACAACTTCTTGGAA +GCCCGTAACATGTTCGACAGTGACATGGCGGTGACTCTCCCTGATGGTAACACGTTCTCT +GTGAATGACCTGCGTACCTATGACATGGCTGAAATTCTGCCTGCATACAACCGACGAGTA +GATGGTGATGTTGCAATCATGGGCGGTTCCGGTAAGACTACCAAAGACCTGAAAGATGAA +ATCATGGCGCTGGATAAGCAGTCAGAGGGTAACGGCACACTGAAAGGTGAAGTGGAAGCT +CTCAAGGACACCGTGAAGATTCTGACTGGTCGTGCTCGTAGGAACCCGGAAGGCGCTTGG +GGTACAGCCCTGCGCTCCGTAAATGACCTCACGTTCTTTGCTAAGAACGCCTATATGGGC +GCACAGAACGTTACTGAAATCGCTGGTATGCTGGCGAAGGGTAACGTCTCTGCGATAACT +CATGGCATCCCTATGATTAACGATTGGGTCAACCGTGGTAAACCGCTTCGTGCCTCTGAG +ATTAAGGAGATACACGGGATGGTGTTCGGTAAGGAACTAGACAAACTAATCCGTCCGGGA +CGTGAAGACCACGTGCGCCGACTCCGGGAGTCTACGGACACCAGCGCTGCGGTTGCCAAT +GTGGTCGGTACGATTCGTTTCGGCACTCAAGAGTTGGCTGCACGCTCTCCTTGGACAATG +CTCCTAAACGGAACATCAAACTACATTCTTGATGCTGCCCGTCAGGGTGTGCTTGGGGAT +GTGGCTGGAGCGGCCCTTGCTGGGAAAGCCTCTAAGTTCGGTAAGGCAAACTACCTTAAG +TCTGCCTCTATCAGCCCTGAGCAGTGGAATGGAATCAAGAAGTTGTTCAGAGACCATGCG +ACTCGTAGAGAAGACGGTAAGTTCACCATTCGTGACAAACAGGCTTTCGCTAACGACCCA +CGTTCAATGGACTTGTGGCGACTGGCTGACAAGGTGGCGGATGAGACTATACTGCGACCT +CACAAGGTTTCCTCACAGGACTCCAAAGCGTTCGGTGCAGGGGTGAAGATGGTGATGCAG +TTTAAGAACTTCGTCATCAAGTCCCTTAACTCCCGGTTCGTCCGTAGCTTCTACGAGGCA +ACTAAGAACAACCGTGCGTTAGACCAAGCGTTGACTCATATCATCTCCTTGGGTCTAGCT +GGTGGTTACTACGTTGCGCAGGCGCACCTTAAGGCCGCAAGCCTACAGGAGCACAAGCGT +AGAGGCGGGTAACCCGATTAAACGCAAGGGAGGCTGGCGAGGATTTGGATTACTCTTAGT +CTTGCATGATATTCAACGACGCAGGCAAAATTCACGCGCTGAAGTACTCCGAAGCGGCAG +GCCGTCGCTGTTGACAGAGTAACTGTTCACAAAAACGATCATTGCACTCCTAGTGTTATG +GGAATGCCTTCTGTAAAGAGCATGGACTACCTTCTCAGCATGACCTAAGGTGAGGAGTAC +CTTAAGAACGCACTTGACCCTAAGATGATTGCTCATGCGTCAATCTCTCGTAGTTCACAC +TTAGGCTCACCATTGAGTATCTACGACATGTTCGCTGGGATGGTTGGTAGCGATACCTAT +AAGTACACCCGCTCTACTGTGCTCCCTAAAGAGTCCGAGAAGCGTGACCCTAACAAGGCA +ATGACAGGTAGACAGGTGGCTTCAACTATCGCGGGTGCAGTTGGTGAGCAGGTTCCGGGG +TTAGGTTTTGTGGGTTCTGTGGGTGCAACAGCAATTAACGCAGCTTCCCTGCTATCTTCT +CCCAACAAGGCAACCGCTCTGGAGTTCCGTACAGGCCTCTTCAACACCTCTCGTGAGTTG +ATTCCTAATGACCCGCTATCGCAGCAACTCATTATGAAAATCTACGAGGCCAACGGTATC +CGCATAAAGGAGACGCCGAAGAAAGAATAAACCCTCACTAAAGGGAGAGAGGTCACATTC +TGGCCTCTTCTCTCTTAATGCCAATTTACAAAGGAGGTCACATGGCTACAACTATTAAGA +CCGTGATGACTTACCCGCTGGATGGCTCCACTACGGACTTTAATATTCCGTTCGAGTATC +TAGCGCGTAAGTTCGTCAGAGTGACCCTTATCGGTGTTGACCGAAAGGAACTCATCTTGA +ATCAGGACTACCGTTTTGCGACTAAGACCACAATCTCCACAACGAGAGCATTGGGGCCAG +ATGACGGTTATAACATGATTGAAATCCGTCGATTTACCTCCGCTACCGATAGGCTGGTTG +ACTTCACCGATGGTTCAATCCTTCGGGCATACGTCCTGAACATCTCTCAGGTCCAAGCCC +TTCACGTTGCTGAGGAAGCACGTGACCTTACCGCTGATACTATTGGCGTTAACAATGATG +GGAATTTGGATGCTCGTGGTCGCCGTATCGTTAACGTAGCTGACGGAGTTACTGATGGTG +ACGCCATCTCTGTAGGTCAGGTTAAACGTATGAACCAGAACTCGTGGCAAGCACGTAATG +AGTCCTTGCAGTTCCGTAATGAAGCAGAAGGTTTCCGCAATCAGGCCTCTACGAGTAAAC +AGGCTGCTGCTACCTCTGAGTCGCAATCATGGAATCATTCTGAGCGCTCTCGGACATTCG +CTGAGGCAGCTCAAGGTTCTGCTAACTCTGCGGGACAGTCAGCTACCAATGCGAACAACG +CTATGCAGTCTGCTGGTCAATCAGCCACGAATGCTAGTAACTCTGCTGCTCAGGCTAAGG +CCTCTGAGGTTAACGCAAAGGCCTCTGAGGTTAACGCTAAGCGTGATGCTGACGCGGCCC +TGCTGGCTCTGCAATCCACTGGTAACGTACCTGTGGGTACAGTCGCCATGATTACCCACA +CCAAGATTCCTACTGGTTGGGTGCGTGCTGATGAGGACTTCGACGTTAATACTTACCCGG +CGTTAGCTGAACTGTTCCCTAGTGGTCGTACTCCTAGCTTCGATGACCGCTATCCTATTG +GTAACTCTACCGTATTGACTCCGGGTCAGCTTATTGACCAATCAGTACCCGCCCACAGTC +ACACCTTCGACGTGCCTGTCAACGTGTCAGGTGCTACGGCTGCTGGTGGCGAATATCGCG +CCAGAACGTCATGAGTTTACCGCTGATGGTCAATTCCAATTATTCACTATCAGTAGGAGG +TAACTATGTGCTGGATGGAAGCGATTCCTATTGCCATGATGGGTGCCCACACGAAGGGGA +TCACAGTCATGGGTTCTCATTGCCTATCCAGAACAACACTGCTGCTTATACTGGTCGTCT +GGTTGGCGGTGGCAACAACCCTAACTACCCGCAAGACCTGCGCTTTAACACTGGTGGCGG +TGGTGCTCACAGTCATGAGTTCTATGTTCCTTCACACAGTCACACGTTGAATGCATCTGG +GCGTGCTGCTGGCTCCGTCTCTTCGTCAGGTATTGGAAACTCACCGTATGTCCGTCCGTA +TTCCACTGTGGTCATCTTCATCATCAAGGCCGCTCAAGGTGTTGACGATAAGGACGCAGC +AATGCAGGTGATGGGCACTGTGGTTGGACGAGTGGACGCTCTGGAGAACTGGCAGAAAAA +CTTCAAGTCCGTTGTTGAGAACGGTTCACCAACCTCTGGAAACGGCGGGCCTTGGGAACG +TACTGTGTACACTGCCCAGACTGGTGGCTTGAACCGTCTAGCTACACTGGCGAAGAAGGA +GAAGGAGATACTGGCTGGACTGAACAAGACGGACAATCAGACTTCTAAAGGATGCCCGTG +TGGGCATTCCGATGACTTCGGTCTCAACCGCTGGCGCACGCTGAGTGGTTCGTCATGGGG +AGAAGTAGTCAACTTACTTAATAGCTCCGGCGTACTTAAAGGGTATCCGCAACGACTTGT +TGTTGACTTCACGGTTGAGGTAATCGATAGCTCTGACCTAATCGCCAAGGCTGGTATATA +TAGTCCATGGCTACACGATTGTTGTATGGTACTGATGGCGGTCAACCAGTAGTTGAGATT +GGTGCCTTCAAGGATGGTTCTGACCAGCAGACGGCAAACGTGCCAGTTAAAGTAGGCTTG +CGCCTCGTTCACGTGTTCTAAGGAGGACATAATGTTATCACTTGATTTCAACAACGAGGC +CATTAAGGCTGCACCCATTGCGGGTGTGGCTGGTGCTGATGGTGTGGCCCGCCTGTTCTG +GGGGCTTTCTCTCAACGAATGGTTCTACGTTGCAGCTATCGCCTACACAGTGGTTCAGAT +TGGTGCCAAGGTGGTCGATAAGATTATTGATTGGAAGAAAGCAAATAAGGAGTAACCTAT +GAGCGACAAGACTTTAATCAAGCTGCTGGAGATGCTGGACACGGAGATGGCACAGCGTAT +GCTTGCTGACCTCCAGAGCGAGGAACGCCGAACTCCGCAGCTTTACAACGCAATCGGCAA +ACTGTTAGACCGCCATAAGTTCCAAATCAGTAAGCTGACCCCGGATGGATGTTCATACGG +TTGTTCCTCATTGGTTGAAAGTTAATCAGTTCGAATCACAAAGGCCACCAATTAAGATGA +CCTTGAGGATTCTCCTGTTAGTGAGGGTTATTACTTCCAGTGTTTCAAATCGCTGTGAAC +CTTACGGAGCCATGCAGTCTGCGCGTTGATTTGTACATCACTGTCGCTGTGCTCGAAGGT +TCTGGATGCCACCGGATGCAGAACATCCTTGGCGGTCTGGCGGCTGGTCTGGAAGACTAC +AACAAAGTGGTCGGCCCTAATGGTCTGACTGATGATGAAACAATCACGCTACAGTAAGTG +ACATACTCAAGGTTCTCCACGCGGGGAGCCTTTATGGATGTTATTTGGTGCATCTATGTA +AAATCTGAAAATTGATGGGAGGTGTTATGCTAAAACTTTTACGCAGCGCACTCCCTTGGG +TACTCGCCGGGACACTCTCTATGAGTGGCTGGCACTTAGGGTCAACCCATGAGAGAGCAA +ACTGGAAGGAGGTAATCCAAAATGAATACATTGCGAAAACAAAAGCAACCGCAGCAACTC +AGGCAGAGGTCAGTCGGGTATCCCGTGAGTACCAAGAAGAGATTGCAGCCATTGAAGGCA +GCACTGATAGGATGCTTAATGACCTGCGTAGTAATAATAAGCGGCTGTCAGTCCGCATCA +AGACCCTTACCGGACTACCAGAAGATAACGGTAGATGCGAGTTTAATGGTCGAGCCGAAC +TACACGAGTCAGATGCTAAGCGTATTATCGGAATAACCCAAGCTGCTGATGCTCACGTAA +GGGCGCTCCAGCGTACTATTAAGGAGATGCAGAATGAGCGACACCCAAGCAAACCGTAAT +GCGCTAATCATCGCGCAGCTTAAGGGCGACTTTGTGGCCTTCCTGTTCGTATTGTGGAAG +GCTGATTGCTACCCAAGGTTTCGGCGGTACGACACACGGCTGGAACATCGGAGAGATACC +CGCCAGAGCGCCTGCACGCTTCGCTAATACGTCCACGTACTCTTGGGCCAGTTGCAGTGC +CTCATGGTCAGAGCCTGCGTTACCTGCGTTGTGGCGCTGTAATTCCACCAGACCTGTGGA +TTCAATCAGCATTTCAATCAGGCGAATCCCTATTTGGCTCTCCCGCCACCGACTAAGTGT +CAGATTGATATGGCCCGGTGTCTGGCTAACGGAGACAACAAGAAGTTTATCCTACAGGCT +TTCCGTGGTATCGGTAAGTCATTCATCACCTGTGCGTTCGTTGTGTGGACGTTATGGCGT +GACCCTCAGTTGAAGATACTGATTGTCTCTGCATCCAAAGAACGTGCGGACGCTAACTCC +ATCTTCATCAAGAACATCATTGACCTGCAAAGAGACGCATACGGCAATGTGTTACAGATT +GTCACTCGTGACCAGATAGCCTTTGGTGCTCTCCCGGAAGACGTTCGGTCTGCGGTAGAG +AAAGCTGGTGGTGAGAAGAAGATGGACGAAATGGTCGATGTGTACACCCATGTGTATCTC +GATGAAGAGTCCGGCGATTACCTCAAGTACGAGGAAGTAGAGGACGTTGAGATTGATGGC +TCCGATGCCACCTATCTGCCATTCTTGGCTGAGCTAAAGCCTCGCCCCGGTCAGCGTGAC +TCTGTGATTAGTTTCGATGTTGGCCCTGCCAAGCCTGACCACTCTCCGTCTGTGAAGTCG +GTGGGTATCACTGGTCAGTTGACTGGTAGTCGTGCTGATATCATCATAGCGGATGACGTT +GAGATTCCGTCTAACTCCGCAACTCAAGGTGCCCGTGTGAAGCTGTGGACTCTGGTGCAG +GAATTTGCTGCGCTTCTGAAACCGCTGCCGACTTCTCGCGTTATCTACCTTGGTACACCT +CAAACCGAAATGACCTTGTACAAGGAACTCGAAGATAACCGTGGGTACACCACAATCATC +TGGCCTGCGCTCTATCCGCGTAGCCAGACTTGAGCCAGTTCATCGCCTCAACCGCTGCGA +CTACGGTCACGCTCACCGCGTCCCAAATCAGCTTAGCCATATAACCAGCCGCTTGGTTAG +GTTGGGTGAACATCAAGCCCGTGAGGAAGACTTGTACTATGGCGACCGTCTGGCCCCGAT +GCTCCGCGAAGAGTTCAACGATGGGTTCGAATCATTCGTGCAGCCAGAACACTGGACAGT +ACCAGCAACGCATCCTCGTGATTGACCCAAGTGGTCGCGGTAAGGATGAGACAGGTTACG +CAGTGTTGTTCACCCTGAATGGCTACATCTATCTGATGGAAGCTGGCGGGTTCCGCGATG +GTTACTCCGACAAGACCCTTGAGTCCCTCGCTAAGAAAGCGAAGCAGTGGAAGGTTCAGA +CAGTGGTCTTCGAGAGTAACTTCGGGGATGGTATGTTTGGTAAGGTATTCAGCCCTGTGC +TCCTGAAACACCATGCAGCGCAACTTGAAGAGATTCGTGCTCGCGGTATGAAGGAACTAC +GCATTTGTGATACGCTGGAACCTGTACTCTCTACGCACCGCCTTGTGATTCGTGACGAGG +TGATTCGTGAGGACTACCAGACTGCTCGTAACGCTGATGGCAAGCATGACGTTCGCTATT +CGCTGTTCTACCAGTTGACCCGTATGGCTCGTGAGAAGGGCGCTGTGGCCCACGATGACC +GACTTGATGCGTTAGCATTGGGTGTGGAGTTCTTACGCTCTACGATGGAACTGGACGCCG +TGAAGGTGGAGGCTGAGGTGCTTGAGGCGTTCTTAGAGGAACACATGGAGCACCCAATCC +ATTCGGCTGGTCACGTAGTCACCTCTATGGTTGACGGTATGGAACTCTATTGGGAGGATG +ACGATGTGAATAGCCATAGGTTCATTGACTGGTAGTTATGCATATTGAGTGCATAAGGAA +TCATTGAGACCACGGATGGTCACTTTAAGAAACTCCTTAAGAATCAATGAGTTTGAATTA +ACCCTCACTAAAGGGAGAGAGGGGACTTAAAGCTACTATATAGGTTAGTCATTCAGGTTA +TGCAATGACCCTTTATGCACTTTAAGTCGCCTCTATGATTGGTGATATTATCATTGTATA +ATCACCCTACCTTAGAGCAACTGAAAGGAGGTGGCTCAATGTTACGCTTGCTGATTGCCC +TGCTGCGTCATAGAGTCACTTGGCGATTTCTTCTGGTACTTGCTGCTACCCTTGGGTACG +CAGGTCTTACTGACCACCTCGGTCAACTGGAAGTGGCCTTTTGCTCTATACTCTCTTGTG +GGGATTAAATTATTGTTGATGAACGACAAGCGGCTCTGAGGGATTCGTAGGTATAGTTTC +ACTACACCAACTCATCCCTGTAGAGTCAACCCTAAAGGTTATACCTAAAGATGCCCTGTA +GTTCGTAATGGTCTTACAGGGTCTTTAAGTGTCTCCTATGGTCTCACCTATGGTGTGGCC +TTACCTAAAGTGGTTGCCTAAAGAGACCTTTAAGAATTTACCACAAAAATCTGAATGGGT +ATCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAAGCCA +GCCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCTATAG +GATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGAGGCC +TTAAAGAGTGTCCTAGTGTACCAGTTCGATAGTACATCTCTATGTGTCCCT diff --git a/example/fna/NC_010807.ref.fna b/example/fna/NC_010807.ref.fna new file mode 100644 index 0000000..7924cfa --- /dev/null +++ b/example/fna/NC_010807.ref.fna @@ -0,0 +1,648 @@ +>NC_010807.ref length=38815 +TCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAAGCCAG +CCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCTATAGG +ATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGAGGCCT +TAAAGAGTGTCCTAGTGTACCAGTTCGATAGTACATCTCTATGTGTCCCTATCTGTTAGC +CTCATAAAGTAAACCCTAAAGCCACTACCTAAAGACCAGACCTAAAGCCATCACCTAAAG +AGCGACGCTATCTTAAAGACAACCAGACCGATAGACCCATTGTTAACCTGTAGTGATGCC +CTGTAGTTATCTGTAGTCATTTCATTAACCCTCACTAAAGGGAATAAGGGATACTTAAAG +GGGGGAATTAGGGATTTAATAAAAGATTAAAATTAATGGTTGACTTTAAGTAACCCTTAA +GGCTATTATTCATCACGTCAACGGGACAACGGCCTTAAAGCCACTCCCTGAGATACCGGA +GTCAACCGGATAAGTAGACAGCCTGATAAGTCATACGAAAAACAGGCATTGACAACGCAA +GGTAACAAGTAGTAAGATGCACAACATAGCGTCAACCACCAAATCGGTGTCTTCTAGGTG +ACTTAAGCGCACCACGGCACATAAAGCTAAACAAAATGGTTGACAACATGAAGTAAACAC +GGTACGATGTACCACGAAATGACGGAACAGTGAGGCGGGACACTGAAAGCCGCTAGGGTC +TAACGAAACCAGACCGACACGCAAATCATAGTAGGTTTAATAAGCGGTAAGTGTATTACT +TCCCTTGTGTGCCGCCGAATGGCATCAGTACACACGACAGGCAGTACGGAAAGTGACACG +ATGCAGTGCTGCCATGATTTGATCGCTCTTTAACAATCTGGATAATAGCTCTTGAGTGTA +CCGATGTATAAGCGAATAACTCAAGGTCGCACTGAAAGCGTGGCCTTTATGATATTCACT +TAACACGAACTAACATGAGGTAACACCAAATGATTTTCACTAAAGAGCCTGCTAACGTCT +TCTATGTACTGGTGTCAGCTTTCCGTTCTAACCTTGATGATGAGGTGAACATGAGCCGCC +ACCGCCACATGGTAAGCACTTTACGTGCCGCACCGGGTCTTTATGGCTCCGTTGAGTCAA +CCGATTTGACCGGGTGCTATCGTGAGGAAATCGCAAGCGCACCGACTGAGGAAAAAACGG +TTCGTGTACGCTGCAAGGACAAGGCGCAGGCGCTGAATGTTGCACGCTTAGCTTGCAATG +AGTGGGAGCAAGATTGCGTACTGGTATACAAATCACAGACTCACACTGCTGGTCTGGTGT +ACGCTAAAGGAATCGACGGTTACAAGGCTGAACGTCTGCCGGGTAGCTTCCAAGAAGTAC +CCAAAGGCGCACCGCTGCAAGGCTGCTTTACGATTGACGAGTTCGGTCGCCGCTGGCAGG +TGGCCTAACATGAATCGTTATTACATCAACGTACCGGGCTGGGGTGGGTCTCTGACCTGC +TACGGATACAACGAACGGGACGCACGGAAACGCTTTAGAGAACAACACGGCTTCGGAAGG +CTTCCTAATGGGACGCGCCTATGGCTGGACGCCCGTGATTGGTAAGTGATAGACTCAAGG +TCGCACTGTATGTGTGGCCTTTATGATTATCACTTATAGGACTAACACCATGAGTAAACT +TCTGGCAACATCTAAAATAGAAGGCCAATGCACCGTAACACTGCGTGAGTATTACCACGG +GTCAATGGGAAGCACCTATGTTGTGCGATACGGTAAACAGGTCACACATTGGGTAAACCC +GATTTTAGCACAAGAGGATTATCAAGCCTGTGTGATACACCAAGCAACATGTGCGGGCTG +GAATGATTGACATTACAGGAGGATTAGGAATGGTTATCTTTATCGCTGTCGCACTCTTTG +CGGTCGCTGGCTGGTACTCTGAGTCACGCAAGGCCGCTCGCTATCATCGCAAGATGGTTA +AACTCATGGAACACTTGGACGCAGAAGGGCGAGGCCGCGAGGCTATCGAACTGGTGAAAC +ACGCATGATGATTCTCTCTATCGCACTGGTCTATCTGTGCATCGCAATGTACTTTATGCG +AGACTTTAAGCGCGGTCTGGCAATACACAAGGCAACGCTGAGTTACTTTAAGCGCGGTCT +GGCAATACACAAGGCAACGCTGAGTTACTTTAAGTGGGGATTCATCCCACGGTTTACGGT +TCGTGAACGCAACGGACGCTTTAAGGCCAACAAGGTAGGAGTATTCTACATTGCTACGCA +CTAACTCAAAGCACGTAAAGACCGCACTGTATGCGATGGCGTATGGTGCATCGAAACGCA +AGGTCAAACGCATCTTAACGAGACACCGCAAGATGACCGCACGACAGGCTGCAAGCGCTG +TCAAATGGGCTGAATTTACTCTTTACTCTTCTTACAGATAACAGGACACTGAACGATGAC +TTTCACCGAAGCACAAGCCGCACTCGAAGCTATCCGCAACCTACCGATTGAGCGCCTGAA +CGAACGCCAGCCCATGCTGGTGGCTCTTGCGGCTGCTATCGTGAACGCTGAGACCCAAGA +CGGCGAACTGACGCAGGCCAAGGGTAATTGGGGTCTGGAGTCTATGGACTACTGGCAGAC +ACTGGCTGAGCGTATGCGTGATGTTGGATTTGTACGCTTGGGCAACGGTCACTTTAGCGC +AGCATATGAGCACGCATTGTTACCGGGCAAGGTTATCAAGGTAGGCTTTAAGAAAGAGGA +TTCAGGCGCTGCCTATGCCGCATTCTGCCGTATGAATCAGGGTCGTGAGGGCATCCCTAC +GGTGTACGACATTCAGCGTCATACAGGCTGCTACACGGTGGTCTTGGACTATCTGACACC +GCTTAATGACTGGTGCTACGGTGAAAGTGATAAGATTCGTCACCACTTTCAGGCTGCACA +GGAAATCATTCAGGAGGATTGCTTCGATACCGCCGAAGAGTACCCGATAAGCGAGGGCTT +CATTGAGACCTGCAAGGATATCCGCAAGTTCTTCTTAGGCATCGCATCGTTCGATTGTCA +CAGCGGGAACATGATGAAAGACCAGATGGGACGCCTGATTATCACAGACCCGGTATCATT +CAGCGCAGACGACAAGTTAAAGCCGGGTGAGTTCCACTGTGACCCGGATGAACTCATCGC +TGAGATTGAGGCGCTGAGAGCGCAGGAAGCGATTGACCGCTGTAAGGCACGCAAGGCACG +CCGTGACCCTAAAGGAGACTTTCAGGTAGCACGTAAAGCCCGTGCCAAGTGGCGCAGAAA +GGCCTCTAAGCGCGAGAAGCGCAACGCTAAGGTGCTCGCTAAGATGCGCATGGATGCTAA +TCAGAATCGCAGGGATGAGCCTAGGGCGCGTATGGTGTGGGGCGATAAGCACTGGCGCAA +CGCTTGGATGCACCACAATAACCTAAACTTTGCAGAACTGGAGCGCCGCGCTGCTGCGGC +AATGATGATGCATGACGAGGTGCGCATTCAGTGGGGCAAACCGTTACACATAGACGCATA +CCTTGACAAGCGTCTACAAGGCTGATAGAGTCTTATCTTACAGGTCATCAATCGGTGGCC +TGAATAGGTACGATTTATTCACAATGAGGTAAGCAATGAACATCATCGAAAACATCGAAA +AGAATGACTTCTCCGAAATCGAACTGGCTGCTATCCCGTTCAACACACTGGCAGACCACT +ACGGCAGCGCATTGGCTCGTGAACAACTGGCTTTAGAGCATGAGTCTTATGAGCTAGGCG +AGCGCCGCTTCCTCAAGATGCTTGAGCGTCAAGCGAAAGCTGGTGAGATTGCAGACAACG +CAGCCGCTAAGCCATTACTCGCTACGCTTCTCCCTAAGTTAACCGCACGCATCGTTGAGT +GGCTCGAAGAGTACGCCTCGAAGAAAGGCCGCAAGCCAGTAGCCTATGCACCGCTCCAGT +TACTCAAGCCGGAAGCCTCCGCGTTTATCACACTCAAGGTCATCCTTGCGTCACTGACCA +GCACGAACATGACAACCATTCAGGCCGCTGCTGGTATGCTGGGGAAGGCCATTGAGGATG +AGGCACGTTTCGGTCGCATCCGTGACCTCGAAGCGAAGCACTTCAAGAAGCACGTTGAGG +AACAGCTTAACAAGCGCCACGGGCAAGTCTACAAGAAAGCCTTTATGCAGGTGGTCGAGG +CCGATATGATTGGTCGCGGGCTGCTGGGAGGTGAGGCGTGGTCTAGCTGGGATAAAGAAA +CCACGATGCACGTAGGGATTCGCCTGATTGAAATGCTGATTGAATCCACAGGTCTGGTGG +AATTACAGCGCCACAACGCAGGTAACGCAGGCTCTGACCATGAGGCACTGCAACTGGCCC +AAGAGTACGTGGACGTATTAGCGAAGCGTGCAGGCGCTCTGGCGGGTATCTCTCCGATGT +TCCAGCCGTGTGTCGTACCGCCGAAACCTTGGGTAGCAATCACCGGGGGCGGCTATTGGG +CTAACGGTCGCAGACCTTTGGCACTCGTCCGCACTCACTCTAAGAAGGGACTGATGCGCT +ATGAGGATGTTTACATGCCAGAAGTTTACAAGGCGGTCAACATCGCACAGAACACCGCAT +GGAAAATCAACAAGAAAGTTCTTGCGGTTGTCAATGAAATTGTTAACTGGAAGAATTGCC +CGGTCGCAGACATTCCATCGCTGGAGCGCCAAGAGTTACCGCCTAAGCCGGACGACATTG +ACACCAACGAGGCAGCACTCAAGGAGTGGAAGAAAGCCGCCGCTGGTGTCTACCGCTTGG +ACAAGGCACGAGTGTCTCGCCGTATCAGCTTAGAGTTCATGCTGGAGCAGGCCAACAAGT +TCGCAAGCAAGAAAGCAATCTGGTTCCCTTACAACATGGACTGGCGTGGTCGTGTGTACG +CTGTGCCGATGTTCAACCCGCAAGGAAACGACATGACCAAGGGGCTGCTGACCCTCGCTA +AAGGCAAGCCAATCGGTGAGGAAGGTTTCTACTGGCTGAAAATCCACGGTGCGAACTGTG +CGGGTGTCGATAAGGTTCCTTTCCCTGAGCGCATCGCGTTCATTGAGAAGCACGTAGACG +ACATTCTGGCTTGCGCTAAAGACCCAATCAATAACACTTGGTGGGCTGAGCAGGATTCAC +CGTTCTGTTTCCTCGCGTTTTGCTTCGAGTATGCAGGCGTTGCGCACCACGGTCTGAGCT +ACAATTGCTCTCTGCCGCTGGCGTTCGATGGGTCTTGCTCCGGTATCCAGCACTTCTCCG +CGATGCTCCGCGATGAGGTAGGCGGTCGTGCGGTTAACCTGCTGCCAAGCGAAACCGTGC +AGGACATTTACGGCATCGTTGCACAGAAAGTAAACGAGATTCTCAAACAGGATGCAATAA +ACGGCACACCTAATGAGATGATTACCGTGACCGACAAGGACACCGGGGAAATCTCTGAGA +AGCTCAAGCTGGGAACCTCAACGCTGGCGCAACAGTGGCTGGCATATGGTGTAACCCGTA +GCGTAACTAAACGTTCGGTCATGACGCTGGCTTACGGTTCCAAGGAGTTCGGCTTTCGTC +AACAGGTACTGGACGACACCATTCAGCCTGCGATTGACAGCGGTAAGGGCTTGATGTTCA +CCCAACCTAACCAAGCGGCTGGTTATATGGCTAAGCTGATTTGGGACGCGGTGAGCGTGA +CCGTAGTCGCAGCGGTTGAGGCGATGAACTGGCTCAAGTCTGCCGCTAAGCTGCTAGCTG +CTGAGGTCAAGGACAAGAAGACCAAGGAGATTCTTCGCCACCGTTGTGCGGTTCACTGGA +CTACGCCGGACGGATTCCCGGTCTGGCAGGAATACCGCAAGCCACTCCAGAAGCGTCTCG +ATATGATTTTCTTAGGGCAATTCCGTCTGCAACCGACGATTAATACCCTCAAGGATTCAG +GCATTGACGCACACAAGCAGGAGTCTGGCATCGCTCCTAACTTTGTTCACTCACAGGATG +GTAGCCACCTCCGCATGACGGTCGTTTATGCTCACGAGAAGTATGGCATTGAGTCCTTTG +CGCTAATCCATGACAGCTTTGGGACTATTCCGGCAGACGCTGGTAAGCTCTTTAAGGCTG +TGCGTGAAACGATGGTTCTCACCTACGAGAACAACGATGTGTTGGCAGACTTCTACGACC +AGTTTGCAGACCAGCTTCATGAGACCCAACTGGACAAGATGCCACCACTTCCGAAGAAAG +GTAAGCTGAACCTACAAGACATTCTCAAGTCCGACTTTGCCTTTGCATAACAAGCACTTA +GCATTAACCCTCACTAACGGGAGACTACTTAAGGTCTCCCTTAAGGTACTAAGAGATTTT +AATTTAAGATAACTAAGAGGTTTACTTTATGATTACTTTATGTGTCGCAATCGTTCTTAT +CGCTACACTCTCAATCGTCATCGCTAAGCAGCGCTCTGAGTTAATCAAGCTGGATGCCCG +ATATGATAGTGCGAACCACCACCGGAAAGAACTGGATGCAGCACTTGGGCGGTCAACCGA +TGAGGTTAAGACCCTTAAGCGCCAGCTACAGCACGCCGAGCAAGACGATAAGAACCGCTG +CGAAACAATCCGAGGTCTACGTGAAGAACTCCGGGAGTTGCGCCAGACGATTAAAGAGCG +CCACGCTATCCACGGCATCAAGTTCGTAGCGAACGTTCCGATGAAGGGCTGGACGCCCAC +CGAGTTTAAGCTGGGTCTTGGTAAGTGCGGTCTGGAAGTGGCGAGTCTAGTGTGGGAAGA +GAAGTCTGACCGCTATGTGTTGACTCAACGCCACACCGACGGAAGCCGAAAGGTCTTTGA +GTACAAGAAGGAAGACGTGCAAGGAAGAATCGAAGTGTTCTACCCTGCCGTTAAATAACC +CTCACTAACGGGAGAGTTAGCCTCAAGGTCATCACCGACGGTGGCCTTTGTGATTAACTT +TCAATACACATCAACATGAGGTAAGATACTATGCGTACCAACTTTGAGAAATTTACCAAG +CGCGATTCAGTGGTCAACGAGCATGGCGAACAGTGGCAAGAGCGCCGTGACCGCATGAAG +AAACGCCACAAGCAACAGCGCGGTAACTCACAGAAACGGGAGTGGAACTAATGATGATGG +GACGTATCTATAGCGGCAACCTGAACGATTACAAAGATGCGGTAGCGCGTCTACAGGAAG +ACCATGACGTGACCGTGAAGGTGGAGTCATTCAGCTATGAAAACCCAGCGAAGATGTGCA +GGTCATCCGGTGAGGTTCTCCGTGTGTTCACACGCTCCGGGCATCCGGTGGCATCCAGAA +CCTTCGAGCACAGCGACAGTGATGTACAAATCAACGCGCAGACTGCATGGCTCCGTAAGG +TTCACAGCGATTTGAAACACTGGAAGTAATAACCCTCACTAACAGGAGAATCCTCAAGGT +CATCTTAATTGGTGGCCTTTGTGATTCGAACTGATTAACTTTCAACCAATGAGGAACAAC +CGTATGAACATCTTCAAGACCAACCCATTCAAAGCTGTGTCATTCGTAGAGTCTGCCGTT +AAGAAAGCGCTGGAGACCTCCGGCTACCTGATTGCGGACATTAAGTATGATGGCGTGCGT +GGTAACATTGTGGTTGACAACGTGGCTGAGGCCGCATGGCTGTCCCGTGTGTCCAAGTTC +ATCCCGGCGCTGGAACATCTGAACGGTTTCGATAAGCGCTGGCAACAACTGATGAATGAT +GACCGCTGTATTTTCCCTGATGGCTTCATGCTGGATGGCGAACTGATGGTTAAGGGCGTA +GACTTCAACACAGGGTCTGGCCTACTGAGAACCAAGTGGCTCAAGAAGAACAACTTCATG +TTTGACCGTGGTGGTGTTGAGCCACTGAAAGGTTCCAAAGTAGCCTTTGAGTTAGACCCC +AAGCTACTCAGTGTTCGCCTGTATGCTGTCCTTCCGATTCACATTGCGGAGTCTGGCGAG +GACTACGATGTACAGAACCTACTGATGCCATATCATGTGGAAGCCATGCGCTCTCTTCTG +GTTGAATACTTCCCGGAAATCGAGTGGCTTATCGCTGAGACCTACGAGGTCTACGATATG +GATTCGCTGACTGAACTGTACGAAGAGAAGCGTGCCGAAGGTCACGAGGGTCTCATTGTG +AAAGACCCACAGGGCATCTACAAGCGAGGCAAGAAGTCTGGCTGGTGGAAGCTCAAGCCT +GAGTGTGAGGCTGATGGTATCATTCAGGGTGTCAATTGGGGAACCGAAGGTTTAGCCAAC +GAGGGCAAAGTGATAGGCTTTAGTGTGCTTCTTGAGACTGGTCGTTTAGTAGACGCCAAC +AACATCTCTCGCGCACTGATGGACGAGTTCACAGCCAACGTTAAGGCACACGGTGAAGAC +TTCTACAACGGGTGGGCCTGTCAGGTCAACTACATGGAAGAGACCCCGGACGGCTCCCTG +CGTCACCCTAGCTTCGAAAAGTTCCGAGGCACTGAGGACAACCCTCAAGAGAAAATGTAA +CCAACTCACTGGCTCACCTTCACGGGTGGGCCTTTCTTCGTTCTAGGGAATTAACCCTCA +CTAACAGGAGACACACCATGTGGCTTATCCTATTCGCTATCGTCGCAACGCTGGGATTAA +TGGTTGCCGACGACGACATTTGGCCTGATTGTTAAGGAGACAACATCATGCGTTTACACT +TCAACACATCAAATGGTATCTTTTCGGTTCGCCGTGAAGACCGCTCTACAGCAGTGGCCT +CTGAGCGCAACGCTAAGCTGCCGCTGATTGGCTCGGTCGTCCCATTGTCGCCTCGTGTTC +ACCTACTGATCACTCGTGGAGAGTTCATTAAGGCGATGAACAAAGAGCGCCCGCATCTGG +AAGCCGTGGTCACTTGCTGGCCTCGCATCCGTCTGTTCGTTAAGTGGATTAAGGAGGTTC +TGTAATGTTACAACATCATTGGAACAAACCAGATTTAGAGGCTCGCTTCCCGGTTAACTC +TGCTGTGCGATACTCCGGCGACTTCCTCAAGCGCTTCTTAGGTATGAGCGGAGTGGTCAC +TGGTCACTCGAACACAGGTCGCGTTAAGGTTCGCTTCGGTAATCAGCACGCTGAGTTTCT +TCCGAACAACCTGATTCCGCTGCCTAAAGATGACGTTAAGACTCCGAACGTGGAAGCACC +GAAGTCAGAAGTCAAGTCTGACGTAACCCACCCTAACCACTACATGCTGTTCGACAACGT +GGAAGCCATTGAGGTTATAGCCCGGTCAATGACCGTCGAGGCGTTCCGTGGGTACTGCCT +TGGGAACATCCTGAAATACCGTCTTCGTGCTGGTAAGAAATCCGAACTGGCAACTATGGA +GAAAGACCTCAATAAAGCTGCATTCTATCAGGAACTCTTTGACAAACATAAGGGGCTGTG +CTATGACGCTTCGTGAATGCTGCGATTGGTGTGCCGCTAAGTGGAACCAAGCTATTGAGG +ATGGTGACAAGGCGGCTGCTGACGCTTACCAACAACTGTACGCGCTGTGGGAGCGGCGCT +TTAAGGAGGCTCAAAGTGGAGCAACGTGAACAGAAATACCTTCTGACGATAGAAGGCAAC +ACCGAGTCCTTTGAGGTTCCGGTATTCGCCCGGTCTCTCGAAGAGGCAACGCTACAGGCT +GAACATTATGAGGACGCTGGGTTCGTAGTGACTCGCATCCGTCCAGAAGTGAAAGCCTAA +TTACCCTCACTAAAGGGAACAACCAAATCATTAACCACAAAGGAGAAACATTATGGCTGG +TTTCAAGAAGAAAATCTACACCTCTGGTCTTGGCACTGCTGAGCCTTATGCTTACCTGAG +TAAGCCGGATTATGGCAACGAAGAGCGTGGCTTCGGCAACCCTCGTGGTGTCTATAAGGT +AGACCTGACTCTTTCCAATAAAGACCCGCGCTGTCAGGCGATGGTCGATGAAATCGTGAA +GACTCACGAAGAGGCTTATGCTGCTGCCGTGGAAGAGTTCGAAGCTAACCCGCCGCAGGT +ACAGCGTGGTAAGAAACCACTGAAACCTTACGAGGGCGACATGCCGTTCTTCGATAACGG +TGACGGTACGACTACCTTCAAGTTCAAATGCTATGCGTCTTTCCAAGATAAGAAGACCAA +AGAGACCAAGCACATCAATCTGGTCGTGGTCGATAGCAAAGGTAAGAAGATTCAGGAAGT +GCCGATTATCGGTGGCGGCTCCAAGCTGAAAGTGAAATACTCTCTGGTTCCTTACAAGTG +GAACACCGCTGTGGGCGCAAGCGTCAAGCTGCAACTGGAGTCCGTGATGCTGGTCGAACT +GGCTACCTTCGGCGGTGGCGGTGAAGATGAGTGGGCTGATGAAGTCGAAGATGGTGGTTA +CACTGCGAGTGAATCCCGTCAGTCCCGCGATGAGCAGGAGTGGCAGGAAGACGAGCACGA +AGAAACCCCGGATGATAACGAGGACTTCTAATGGCTGGCGCATACGCTGCGCGAGGTGTA +CGCAAGGTCGGGGCTTTCCGCTCCGGCCTAGAAGATAAAGTCTCAAAGCAGCTTGAGAGT +AAGGGAATTAAGTTCGACTATGAGCTTTGGCGTATCCCTTACGTCATCCCTGCGAGTGAC +CACTTATACACTCCAGACTTCCTGCTACCTAATGGCATATTCATTGAGACCAAAGGGCTG +TGGGATTCCGATGACCGCAAGAAACACCTTTTGATTCGTGAGCAACACCCTGAACTGGAT +ATTCGCTTGGTCTTCTCAAGCAGCCGCTCAAAGCTCTACAAAGGTAGCCCAACAAGCTAC +GCCGAGTGGTGTGAGAAGCATGGCATTCTGTTTGCTGACAAGCTAATTCCGGTGGAGTGG +CTCAAAGAACCCAAGAAGGAGGTTCCGTTCGATAAATTTAAGACTAAGAAAGGAGTAAAG +AAAAATGGCTAAAGTTCAATTCAAACCACGAGAAACCACGGAGGCAATCTTTGTACATTG +CTCAGCAACCAAGCCAAGCCAGAACATTGGCGTTCGTGAGATTCGTCAGTGGCACAAAGA +GCAGGGCTGGTTAGACGTAGGATATCACTTCATCATCAAGCGTGATGGCACTGTGGAAGC +AGGCCGCGATGAACTGGCTGTAGGTTCCCACGTGAAAGGTTACAACCACAACTCCGTAGG +CGTATGCCTCGTGGGTGGGATTGATGATAAAGGCAAGTTCGACGCCAACTTTACACCTGC +GCAAATGCAAGCGCTGCGTAGTCTGCTGGTCACGCTGCTGGCGAAGTATGAGGGTTCAGT +CCTTCGTGCTCACCATGACGTTGCATCCAAAGCCTGCCCGTCCTTCGACTTGAAGCGCTG +GTGGGAGAAGAACGAACTGGTTACATCTGACCGAGGGTGATACCATGAGGATGATTTGTA +TTCGCTGTGATAAGCCGTTGAAGAGTCGTGTACCGTCACGTCAGTGTCAGTGCAAAGACC +CAATCAAGGCGGAGGAACACACCGAGGAATAATTAACACTCACTAAAGGGAGACTTAACG +GTTTCCCTTTGTTCGCACTATTGATTAAGGAATGTACAATGGAACGAGAAGACGATAGTA +TCTTTCTGTTTCATGCTCCATGTGAAAACTGTGGGTCTTCTGATGGTAACTCTGTGTACT +CTGACGGGCATGAATGGTGCTTCGTGTGTGAACATCGAGTACCCGCAAACGAAGAGCGTG +AAGCAAAGTTATCAACGAGAAGACGTACAGGAGGCAGCAAGCCTATGAGCTATGACGTAT +GGAATTTCGGTGACAGCAACGGTCGATACTCTGACCTGACTGCCCGTGGCATCTCGAAGG +AGACATGCCAAAAGGCTGGCTACTGGCTGGCGAAAGTGGACAACCGAATGTATCAGGTTG +CCTACTACCGAGACCAGAACGGCTCCATCGTGTCGCAGAAGGTGCGCGATAAGGACAAGA +ACTTTAAGACCACCGGAAGCCACAAGAGCGATGCGCTGTTCTTGAAGCACCTCTGGTCTG +GCGGTAAGAAAATTGTGGTCACTGAGGGCGAAATTGATGCGCTCACTGTGATGGAACTCC +AAGACTGTAAGTACCCGGTCGTATCATTAGGTCACGGTGCCTCTGCTGCTAAGAAGACAT +GCGCCGCTAACTATGAATACTTTGACCAGTTCGAGCAGATTATCTTGATGTTCGACATGG +ATGACGCAGGCCGTAAGGCAGTCGAAGAGGCCGCACAGGTTCTCCCGGCTGGTAAGGTTC +GTGTTGCCGTGTTGCCGTGTAAGGACGCCAACGAGTGTCACATCATGGGTGAAGACAAAG +CAATCTTGGAGCAAATCTGGAACGCGAACCCTTGGGTGCCTGACGGTGTTGTTTCTGCGT +TGTCACTCAAAGACCGCGTTAAGGAAGCTATGACCTCCGAGGACGCTGTAGGTTTATTAT +TCGATGGCTGTCAAGGCCTGAACGATAGAACCTTGGGTGCTCGTGGTGGCGAAGTCGTTA +TGGTCACTTCCGGTTCCGGTATGGGTAAGTCAACGTTCGTTCGTCAACAGGCTCTGGCTT +GGGGCAAGCGAATGGGTAAACGTGTGGGCCTAGCGATGTTGGAGGAATCCGTTGAGGATA +CCATTCAGGACATGATGGGCTTGAACAATAAGGTTCGTCTGCGTCAGTCTGATGAAGTCA +AGAAGGCTATCGCAGAGGACGGACGTTTCGATGAATGGTATGATGAACTATTTGGAGACG +ATACGTTCCACCTTTATGACTCCTTTGCGGAGGCCGAAGCTGACAGGCTGTTAGCGAAGC +TGGCCTACATGCGAACAGGCTTAGGGTGTGATGTTATAGTGCTCGACCACATATCAATCG +TCGTGTCTGCCTCTGAGGAATCGGATGAGCGTAAGATGATTGACCGCCTCATGACGAAGC +TCAAAGGGTTCGCTAAGTCAACTGGTGTTGTGCTCGTAGTGATTTGTCACTTGAAGAACC +CGGAGAAGGGAAAACCACATGAAGAAGGACGCGCTGTTTCTATTACTGACCTACGTGGTA +GCGGTGCCTTGCGTCAGTTATCTGATACTATCATCGCCTTGGAGCGTAACCAGCAAGGTG +ATATGCCTAACTTGGTGTTGGTTCGCCTGCTTAAGTGTCGTTTCACTGGCGACACTGGAA +TTGCTGGGTACATGGAATACAACAGAGAAACCGGGTGGCTTGAACCGTCTAGCTACACTG +GCGAAGAAGGAGAAGGAGATACTGGCTGGACTGAACAAGACGGACAATCAGACTTCTAAA +GGATGCCCGTGTGGGCATTCCGATTGCGATGGAATCATGTACCACTAATTAACCCTCACT +AACGGGAACAACCATTAAACCATAGGAGACACATCATGTTTAAATTCATTAACGCTTTAG +GTAAGCTGGTAGTTAAACTGTACTTCATCGAAGCCAAGAAGCTGGACAAGAAGGCCAAAG +CTGATTCACAGCGAGCCATTGAGTTGGCGAAACAGTCCCGTGAGAAATCCGATGCGGCTG +TTAGTGGCATCCACAAGTCGGCAGCGATTGCAGCCAAAGCACAATCCATGAGCAAATTCT +TTGAGTAAGGAGCGCACACTATGAGCAAGTCAATCACCCACGCAAACACCATCCGTCTGC +CAGACACCGCTGACCAGTTCTCCCGCCGAGTACACATCAATGTGCGTGGTGAGAAGGTCA +CGATGGTCTACCGCTGGAAAGACCACAAGTCTCCGAAAGCACACACTCAACGAATGACCT +TGGATGACAAGCAGGTCGGTCGCTTGATGGGTGCCCTGACTATGGCTGCTGACAAGGTGG +TCGGTGATAACCGTGAGCGTCTGGTAGAGTTCGGCGCTGGTATGCAAGAGATTATCGAGA +AGTGATAAACTCAAGGTCGCCCAAGGGTGGCCTTTATGATTATCATTTAGCACGAAACCA +AAGGAGGGCATTATGCTCGTAAGTGACATTGAGGCCAACAACCTCTTAGAGAAAGTCACC +AAGTTTCACTGTGGCGTTATCTATGACTACCGTGATGGTGAGTATCATAGCTATCGTCCG +GGCGACTTCGGGGCGTATCTGGATGCGCTGGAAGCCGAGGTGAAGCGAGGTGGGCTTATT +GTTTTCCATAACGGTCACAAGTATGACGTTCCGGCTTTAGAGAAACTCGCAAAGCTGCAA +CTCAATCGTGACTTCAAGTTACCCCGTGAGAACTGTATTGATACATTGGTACTCTCGCGT +TTACTTCATGCGAACCTTAAAGACACAGACATGGGGCTTCTTCGCTCCGGGAAACTACCC +GGTCGTCGCTTCGGGTCTCACGCTCTGGAGGCATGGGGCTATCGCTTGGGTGAGATGAAA +GGTGAATACAAGGACGACTTCAAGGCTATGCTGGAAGAGCAGGGCGAAGAATATGTTGAT +GGTGCTGAGTGGGTTTCGTTCAACGAGCCGATGATGGCGTATAACGTTCAAGACGTTGTG +GTCACTGTCAAACTCTTAGAGAAATTCCTTACAGACCTCCACTACTTCCCTGCGGGTATG +GACTTCACGAAGTACGATGCGGATTTATTCTGGCGAGAAGCTGGCGAGTCTGTGGATATT +GAACATCGTGCAGCGTGGCTTTTAGCGAAGCAGGAGCGTAACGGCTTCCCGTTCAACACC +AAGGCAATTGAGGAACTTTATGTAGAACTGGCAGCGAAACGCGCCGAACTTCTGCAAAAG +CTAACCGAAACGTTTGGCTCATGGTATCAACCGAAAGGCGGTAAGGAACTCTTCAAGCAC +CCACGGACAGGCAAGCCGCTGCCGAGCTATCCTCGCGTGGTCTATCCGAAACAGGGTGGC +GTGTACAAGAAGCCTCGTAATAAGGCACAGCGCGAAGGTCTTGAACCTTGCGACTTGGAC +ACGAGGGATTACATGGAGGGTGCTCCATATACTCCGGTAGAGTTCGTTACGTTCAAGCCA +AGTAGCCGTGACCACATTCAGAAGAAACTACAGGAGGCCGGATGGGTTCCTGAGAAGTTC +ACCGAGAAGGGTGCGCCTGTGGTGGACGATGAGGTCTTGGAGCATGTACGAGTGGATGAC +CCTGAGAAGCAGGCGTGCATTGACTTGATTAAAGAGTACCTGATGATTCAGAAGCGAATC +GGTCAGGCGGCAGAGGGTGACAAAGCGTGGTTACGTTATGTTCAAGATGATGGTAAGATT +CATGGAGCCGTTAACCCTAACGGTGCAGTTACTGGTCGTGCTACTCATAGTTTCCCAAAC +CTTGCACAAGTACCCGGCGTTCGTTCTCCTTACGGGGAGCAGTGTCGTAGCGCTTTTGGT +GCTGAACATCATTTGGATGGGATTACTGGCAAGCCGTGGGTGCAAGCGGGGATAGACGCC +AGTGGCTTAGAGTTGCGCTGTCTGGCACACTTCATGGCTCGTTTCGATAACGGAGAGTAT +GCGAATGAGATTCTCAACGGTGACATTCACACCAAGAACCAGAACGCTGCGGAACTCCCA +ACGCGAGACAACGCCAAGACCTTCATTTACGGGTTCCTTTACGGAGCAGGAGATGAGAAG +ATTGGTCAGATTGTTGGGGCAGGGAAGGAGCGCGGGAAGGAACTCAAGAAGAAATTCTTA +GAGAACACCCCGGCGATTGCAGCGCTACGAGAAGCTATCCAACAGTCTCTCGTTAAGTCT +TCCGCTTGGATTGGCGCTGAGCAGAAAGTACAGTGGAAGCGCCGTTGGATTAAAGGTCTG +GATGGTCGCAAGGTTCACGTCAGGTCTCCACACGCAGCGCTCAACACATTGTTGCAGTCT +GCTGGTGCTCTGATTTGTAAGTTGTGGATCATCAAGACCGAAGAGATGCTCATTGAGAAA +GGCTTGAAGCATGGCTGGGATGGTGACTTTGCGTACATGGCTTGGGTTCACGATGAGATT +CAGGTGGCCTGCCGTACAGAGCACATCGCTCAGATTGTTATTGACACCGCGCAGGAAGCT +ATGCGTTGGGTCGGAGAGCATTGGGCTTTCCGTTGTCGTTTAGATACCGAGGGTAAGATG +GGGCCGAATTGGGCTGTCTGCCACTAACAATAGGAGAAACATTATGGCAATGACCAAACA +CTTTAAAGTAACCTTCGACGTTACCGCTGTGATTGACAGTGAATCCGAGAAGAATCTGAA +CGAGTTGCTGGTAGACCTAGCTAAGAAGGCCGGGGCTGGCGAGAAGCTGAATCCGTTCAA +ACAAGAACTGCTTATTCAAGGCCTGACACACGGGCCGGAAGGTGCTGCTGCGTTCTGTAT +CAAGCAAGGTCTCCGTGAGTTTATCCGCGATGGTCACAGTGAGTTAAGCTCTACCGAGCA +GAAGCTGATGAGATTCTCACCTGCAACTGTGCGAGAGGTGTTCAAATGAGTGAATACCTG +AAAGTTCTGGCAGCTATCAAAGGTTGCCCTAAGTCCTTTCAGTCGAACTATGTGCGAAAC +AATGCGGCTCTCGTAGCTGAGGCCGCTTCTCGTGGACACATTAGCTGTTTGACTGTGGGC +GGTCGCAATGGTGGAGCATGGGAGGTCACAGCCTCTGGTGTGCGCTTCCTGAAACGAATG +GGAGGTTGCGTATGATTATGCCTAAGAGTGACACCGTAACGATGACCCGTGATGCGTGGA +ACGATGTTAGCGCGTACATTGATAAGCTGGAGAAAGGCCTAGAGTTCCTGAATGCGCTTA +AGGCGTGTGGTGTGGATAATTGGGACGGATACTCTGATGCAGTCGAAATGGTTTACGGGG +AGGATGACGAATGAGCCTAATCACATTGAAAGACTTCGCGGAGATGCGTGAAGGTAATCC +TATGGAGAAGGGAGTGCTGGTCATGGATGGTGACTGGTTGGTATATCAGTCAATGGCTGC +TGCCGAAGTTGAGACGGATTGGGGAGACGACATTTGGACTCTTGAGTGTGACCACGCCAA +GGCACGGAGCATTCTCGATTCTGCAATCGAATCGTACCGAACCCGTAAGAAGGCTTGGAG +TGACGCTATGGTTGTTCTGGCGTATACCGACGATGTGAACTGGCGTAAGGTACTGGTTGA +TGAGACCTATAAGGAGAACCGTAAGGCGACCCGTAAGCCTGTGGGCTACCGTGACTTCCT +GTCGAAGCTGTGGGAGCGCGATGAGTTCATTCACATCAAAGAGGACATGCTGGAAGGTGA +TGACGTTATGGGTATCATTGGGTCTGGTCACGAGGTCTTCGGCTTCAAGAAAGCTGTGTT +GGTCTCCTGTGATAAGGACTTCAAGACTATACCGGACGTTGACTTCCTGTGGTGTACCAC +TGGTAACATCTTGACGCAGACCAAAGAGACCGCTGATTGGTGGCATCTCTTCCAGACTAT +CAAGGGCGATATGACTGATGGCTACTCCGGGATTCCCGGTTGGGGTGACACGGCAGAAGG +TTTCCTGAATGACCCGTTCATTGTGGAGCCTGTAGAGTCCGTGTTGAAGTCCGGTAAGAA +CAAAGGGCAGACTGTCACTAAGTGGGTGAAACGCGCTCCTGATGCGACTGAGAGCCTGTG +GGACTGCATCGTATCCATTGGTGCCAAAGCTGGGATGACCGAACATGAAATCATTAAGCA +AGGCCAGATGGCACGCATTCTTCGCTTCGAGGAATACAATTACATTGACAAGGAGATTTA +CTTATGGACGCCGCGAAGCTGATTACCATCGCTGTGCTGGTAGGTATGCTGGCGCGAGGT +CTCTGGATGTTCGCTCTCATAGTCCGAGACGTGAAGCGAGACTCCGAGATTAAGTGATAC +ACTCAAGGCTCTCTGTATTAACCCTCACTAAAGGGAAGAGGGAGCCTTTATGATTATTAC +TTTAAGACTTAACCTTAAGAGGTGAATTTATGTTACAACCAATTAATCATGTTTTAACTC +ATCCCGATGATATTCCTAGTATGCCGCGTGCAGCTAAAGAGTATCTACAGGTGCGCTTCA +ATCAGGCTTATGTGATGGAGTCCGGGGAGTACCGTGCGCTCCGCGCTGCTGGTTACTCTG +AGTCTTTCATTGCGGGTGTGATGCATGGTCTGTACCTTGCCTCTCGAACACTTGATGAGA +TTGAGGTGCGTAAAGAGCAACTGAGACAGGAGTAACGATATGTGCTGGAAACCGAAGGTG +AAAGTCCCTAAGATGGACACTAACCAGATTCGCGCTGCTGAACCAGCACCTTTGACTGAA +CCTCCGAAGTCTGTGGTATGGGGAGGCGATGATGACGAGGACACCAGTGTGTCTTCCTCT +GAGGTGCCAACCACACCGAGCAGCGGTAAGAGCAGTCTCAAGGTAAAGCTGGATGACAGC +GCAGCCAAGAACAAGAGTAAATCCTCCATTCGCTCCAAGGCGTTTGGGTAACTGAGTCAT +AGCATAGGGAGAAACATCATGGGATTCTTCAAGAAAATCAAGAAGGCCGTTAAGAAAGTT +GTGAAAGAAGTTAGTAGACCAGTCGAGAAGGCCGGTAAGGAAGTGGGCAAGGTGGTTGGA +GGCGCGCTGGGTGCAGGTAAGCAGGAGATTATCCAACAAGAGGCTCCTGTACCAGTAGTC +GCTGCACCGCCACCAGCACAGGTTGTAGATGTACCGGAACAGGATAAGGCTGAGGGTGAG +GATGAGGCGCAAACCGAAAGCGCACGTAAGAAAGCACGCGCTGGCGGTAAGAAGTCTCTG +AGTGTAGCCCGTAGCTCCGGCGGTGGCATCAACATCTAAGGAGGACTGAATGGCTGATTC +AAAACGTACAGGATTGGGCGAAGACGGTGCTAAAGCTACCTATGACCGCCTAACGAACGA +CCGTAGAGCCTACGAGACTCGTGCGGAAAACTGTGCGCAATACACCATTCCGTCCTTGTT +CCCGAAGGAGTCCGATAACGAATCTACCGACTACACGACTCCGTGGCAGGCTGTAGGTGC +GCGGGGTCTTAACAATCTGGCCTCTAAATTAATGCTGGCACTATTCCCGATGCAGTCGTG +GATGAAGCTGACCATTAGTGAATATGAGGCGAAGCAGCTTGTTGGAGACCCTGATGGACT +CGCTAAGGTGGACGAAGGTCTGTCTATGGTTGAGCGTATTATCATGAATTATATCGAATC +CAACAGCTACCGTGTGACACTCTTTGAGTGCCTCAAGCAGTTGATCGTGGCAGGTAATGC +ACTGCTTTACTTACCGGAACCAGAAGGCAGCTACAATCCGATGAAGCTGTACCGATTGTC +TTCTTATGTTGTCCAAAGAGACGCATACGGCAATGTGTTACAGATTGTCACTCGTGACCA +GATAGCCTTTGGTGCTCTCCCGGAAGACGTTCGGTCTGCGGTAGAGAAAGCTGGTGGTGA +GAAGAAGATGGACGAAATGGTCGATGTGTACACCCATGTGTATCTCGATGAAGAGTCCGG +CGATTACCTCAAGTACGAGGAAGTAGAGGACGTTGAGATTGATGGCTCCGATGCCACCTA +TCCTACTGACGCTATGCCCTACATTCCGGTTCGCATGGTTCGCATTGATGGCGAGTCTTA +CGGTCGCTCCTACTGTGAAGAATACTTAGGTGACTTAAGGTCGCTTGAGAATCTCCAAGA +GGCTATCGTTAAGATGAGCATGATTAGCGCGAAGGTCATCGGTCTGGTGAACCCGGCTGG +CATTACGCAGCCACGTAGATTAACCAAAGCTCAGACTGGTGACTTCGTTCCGGGTCGTCG +AGAAGACATTGACTTCCTTCAACTGGAGAAGCAAGCTGACTTTACCGTAGCGAAAGCTGT +GAGTGACCAGATAGAAGCACGCTTATCGTATGCCTTTATGTTGAACTTTGCGGTGCAACG +AACAGGTGAACGTGTGACCGCCGAAGAGATTCGATACGTTGCGTCAGAACTGGAAGATAC +GCTTGGTGGCGTCTATTCGATTCTGTCTCAAGAACTGCAATTGCCTCTGGTTCGTGTGCT +CTTGAAGCAGCTCCAAGCAACCTCGCAGATTCCTGAGCTACCGAAAGAAGCCGGTGAGCC +GACTATCAGTACAGGTCTGGAAGCAATCGGTCGTGGTCAAGACCTCGATAAGCTGGAGCG +CTGTATCTCCGCTTGGGCTGCTCTGGCCCCTATGCAGGGAGACCCGGACATTAACCTTGC +TGTCATTAAGCTGCGCATTGCTAACGCCATTGGTATTGATACTTCTGGTATCCTACTGAC +TGACGAGCAGAAGCAAGCACTGATGATGCAGGATGCGGCCCAAACAGGTATCGAGAACGC +TGCCGCCACTGGTGGGGCTGGTGTGGGTGCTCTAGCGACCTCAAGTCCAGAAGCTATGCA +GGGTGCAGCAGCACAGGCTGGCCTAGACGCCACCTAATAACCCTCACTAAAGGGAGACCT +CATCTTTGAAATGAGCGATGACTAAAGGTTGGAGTCCTTTGGTTTCCCTTTATCTTTAAC +AACTTAGGAGATTTAACAATGGCTGAATCTAATGCAGACGTTTATGCGTCCTTCGGTGTG +AACAACGCGGTAATGACCGGAAGCACACCTACTGAACACGAACAGAATATGCTGAGTCTC +GATGTTGCTGCCCGTGATGGCGATGATGCAATCGTACTTAGCGAGGAACCGAGTTCCCAT +AACGATGACCCATATGCATCCGGTGTAGACCCGTTCGCTGATGGTGAAGACGATGAGGGC +CGCATTCAGGTTCGTATCAGTGAAGATGGTAATGAAGCCGAGTTCGACACCGGTAGCGAT +AACGCTGAGGTGGAGACCGAAGGTGAGGCCGCTGAGTTTGAACCGCTGGGTGACACTCCA +GAAGAACTGAGCCAAGTGACTGAGCAGTTGGGACAGCACGAAGAAGGCTTTCAGGCGATG +GTCGAGCAGGCCGTTGAGCGTGGACTGAGCGCAGAGTCTGTGACTCGCATCTACGAAGAG +TACGAAGCCGATGGCATCTCTGAGAAATCCTACGCGGAACTCGAAGCTGCTGGCTATAGT +CGTGCCTTTGTGGACTCCTACATCTCCGGTCAGGAAGCCCTTGTAGACCAGTACGTCAAT +CAGGTAGTTGCCTTTGCTGGTGGTAAGGAGCGCTTTAGCGCAATCCATACGCACCTTGAA +GCAACCAACCCGGCTGCGGCTGAGTCCCTTGAGACTGCCATGATGAACCGAGACTTGGCG +ACTGTCAAAGCAATTATCAATCTGGCTGGTGAGAGCTACACGAAGAAATTCGGTAAGCCT +GCCAACCGTAGTGTTACCAAGCGTGCTACTCCGGTTAAACCTGTAGCTCGTCAGAAAGAT +GGCTTTACGAATCAGGCTGAGATGATTAAAGCTATGAGTGACCCGCGTTACCGTAGTGAT +GCTGCCTACCGTCAAATGGTAGAACAGAAGGTTATCGACTCCAGTTTCTAATTAACCCTC +ACTAAAGGGAGAGACCATAGATGACTACAATGGTTGAATCACCTGAGCACAGAACTTTGT +GGTCACTCCCGTAGGTGAAACATTGAGAACCAACTCGATTCAAGTAGTAACCAAACTTTT +CTTTAAATTAACATAAGGAGATTCAACATGGCTAACAATCAAGGCGGACAGCAAATTGGT +ACTAATCAGGGTAAGGGTCAGTCCGCAGCGGACAAATTGGCGCTGTTCCTGAAAGTGTTC +GGCGGTGAAGTCCTGACGGCTTTCGCTCGCACCTCCGTGACCATGCCTCGTCACATGCTG +CGCTCTATTGCTTCTGGTAAGTCCGCACAGTTCCCTGTGATTGGTCGCACCAAAGCTGCT +TACCTGAAACCGGGTGAGAACCTCGATGACAAACGTAAGGATATCAAACACACCGAGAAG +GTAATCCACATTGATGGACTGCTGACTGCGGACGTTCTGATTTACGACATTGAGGACGCG +ATGAACCACTACGACGTTCGCGCTGAGTACACCGCACAGTTGGGTGAATCTCTGGCGATG +GCGGCTGACGGTGCTGTACTGGCTGAACTGGCTGGTCTGGTTAACCTGCCGGACGCCTCC +AATGAGAACATCGAGGGTCTCGGTAAGCCTACCGTACTGACTCTGGTTAAGCCGACCACT +GGCGACCTGACTGACCCGGTTGAGCTGGGTAAAGCGATTATCGCTCAGTTGACTATCGCT +CGTGCGTCTCTGACCAAGAACTACGTTCCGGCTGCTGACCGTACCTTCTACACCACTCCT +GATAACTACTCTGCGATTCTGGCCGCTCTGATGCCGAACGCTGCAAACTATCAGGCACTG +ATTGACCCTGAGCGCGGTACTATCCGTAACGTGATGGGCTTCGAAGTGGTTGAGGTTCCG +CACCTGACCGCTGGTGGCGCTGGTGATACCCGTGAGGATGCCCCGGCTGACCAGAAGCAC +GCTTTCCCGGCGACTTCCAGCGCTACCGTTAAGGTTGCTCTGGATAACGTTGTGGGCCTG +TTCCAGCACCGCTCTGCGGTTGGTACGGTCAAGCTGAAAGACTTGGCTCTGGAGCGCGCT +CGTCGTGCGAACTATCAGGCTGACCAGATTATCGCTAAGTACGCGATGGGTCACGGCGGT +CTGCGTCCAGAAGCTGCTGGCGCTATCGTGCTGCCAAAGACTTCGGGGGCTTAAGGGTAG +CGCCTTTGAGTATGAACGCGGAGAGTGAAGTGGAGCCGACCCAAGAGGTAGCCGCCGAAG +TAGCTCTCACGCCTCAACAGAAGGCCGCCATTACTCGTGCTCGTAACAAGGCACTTAAGT +CTCAATAACAACAAGCAAACCCCTTGGGTTCCCTCTTTGGGAGTCTGAGGGGTTTTTTGC +TTTAACCCTCACTAACAGGAGGTAACATCATGCGCTCTTATGAGATGAACATTGAGACCG +CAGAAGAGCTATCAGCCGTCAACGACATTCTGGCTTCCATCGGTGAGCCACCAGTATCGA +CCCTTGAGGGTGATGCAAATGCTGATGTTGCAAATGCTCGACGTGTGCTCAACAAGATTA +ACCGACAGATTCAGTCACGAGGATGGACATTCAATATTGAGGAAGGTGTGACTCTTCTAC +CGGATGCGTTCTCTGGTATGATTCCATTTAGCTCTGATTATCTGTCCGTAATGGCAACCA +GCGGTCAGACCCAATATGTCAACCGTGGTGGCTATCTCTATGACCGCTCTGCGAAGACTG +ACCGATTCCCATCTGGTGTTCAGGTCAACCTGATTCGTCTGAGAGAGTTCGATGAGATGC +CTGAGTGCTTCCGAAACTACATCGTTACCAAGGCTTCCCGTCAGTTTAACAACCGCTTCT +TCGGTGCGCCGGAGGTAGACGGAGTGTTGCAGGAAGAGGAACAGGAAGCGTGGCGTGCGT +GCTTCGAGTACGAACTAGACTACGGCAACTACAACATGCTGGACGGTGACGCATTCACCT +CTGGTCTACTTAACCGCTAATAACAAGGAGGCTCTATGGCTCTCATTAGTCAATCAATCA +AGAACCTCAAGGGTGGTATCAGTCAACAGCCAGATATTCTCCGGTTCGCTGAACAAGGTA +GCGTACAGATTAACGGTTGGTCTTCTGAGTCCGAGGGTCTCCAGAAGCGCCCACCGATGA +TTCACCTTAAGACCCTTGGTGCTGCTGGGTATGTGGGTGCGCAACCTTACGTTCACCTCA +TCAACCGTGATGAGTTCGAGCAGTATTTCGTGGTGTTCACTGGTGAAGACATTAAGGTAT +TCGACCTCGACGGTAAGGAGTACCAAGTACGTGGAGACCGCTCATATGTTCGTACAGCTA +ACCCACGAGAAGACCTTCGGATGGTAACTGTGGCTGATTATACCTTTGTGACTAACCGCA +AGGTGGTTGTACAGAGTAACGACCAATCGGTCAACCTTCCGGGCTTTAAAGACCAAGGCG +ATGCGCTGATTAATGTTCGCGGTGGACAATATGGGCGTAGACTCTCAATCGAGTTCAACG +GGGCTGAGCGTGCTGCTGTACAACTACCGGATGGTTCACAACCAGCACACGTTAACGAGG +TTGACGGTCAGGCTATCGCTGAGAAGCTGGCTGTGCAGTTGAGGAACAACCTTGGGAATC +CAAACAACGAGCAAGACCCGAATAAGTGGCGCTTCAACGTTGGCCCCGGATTCATCCATA +TCCTTGCGCCAAATAACGATAACGTTTGGGGACTACAGACTAAGGATGGTTACGCAGACC +AGCTAATCAACCCTGTAACCCATTACACTCAGTCGTTCCAGAAGCTGCCTATTAACGCGC +CAGATGGGTACATCGTGAAGATTGTTGGTGATACCTCAAAGACTGCCGACCAGTATTACG +TTAGGTTCGACCTCAACCGTAAGGTGTGGGTAGAAACAATTGGATGGAACACAAGGACTC +ACCTACATTACCACACGATGCCTTGGGCACTTGTTCGCGCTTCTGACGGGAACTTTGACT +TCAAGTACCTTGAGTGGGGTGCTCGTACTGTGGGGGACGATACAACCAACCCATACCCAT +CCTTTACCGGACAGACAATCAACGATATTTTCTTCTTTCGTAACCGTTTGGGATTCCTTA +GTGGGGAGAACATCATCTTGTCTCGCACCTCGAAATACTTCAACTTCTTCCCGGCATCCG +TGTCAAACTACTCCGACGATGACCCAATCGACGTTGCGGTTAGTCATAACCGGGTGTCAA +CCTTGAAGTATGCCGTTCCGTTCTCAGAAGAGTTACTCCTGTGGTCTGACCAAGCGCAGT +TCGTTCTGACAGCCTCTGGAATCCTTTCGAGTCGCTCCGTAGAGTTGAACCTTACGACGC +AGTTCGACGTGCAAGACAGGGCACGCCCACATGGTGTAGGACGTAATGTATACTTTGCGT +CACCTCGCGCTTCCTTCACATCCATTAACCGATACTATGCGGTACAGGATGTAAGCTCTG +TGAAGAACGCAAAGGACATGACGGCTCACGTTCCGAACTACATACCGAATGGAGTATTCA +GTATATCGGGGACAACCGCTGAGAACTTCGCGGCTATCCTTACGAGCGGAGCACCGAACC +GAGTGTATATCTACAAGTTCCTCTATATTGATGAGGAAATCAGGCAGCAGTCGTGGTCTC +ATTGGGACTTTGGGGACAACGTTACGGTGTTTGCAGCACAGGTGATAAACTCAACAATGA +CTGTATTGATGAGCAATGAACATGCTGTGTGGATGGGACGCTTACACTTCACGAAGAACT +CCATAGACATTCCGGGAGAGCCTTACAGATTATACATCGACGCTAAGAGGAAATACACCA +TCCCTGCCGGGACGTATAATGATGATACCTACCAGACGTCCATAAGCCTCGCAACAATTT +ATGGGATGAACTTCACTAGGGGTAGAGTGTCTGTGGTCTTTCCTGATGGGAAGATTGTAG +AGATAGACCAACCAATCAACGGGTGGAGTAGCGACCCAATACTGAGACTTGATGGAAACC +AAGAGGGACAAGTAGTCTACATTGGGTTCAACATCCCGTTCACTTATACGTTCTCGAAGT +TCCTCATCAAGAAGACTGCTGAGGACGGCTCGACGGCTACCGAGGATATTGGTCGTTTAC +AGCTTCGGCGTGCGTGGGTAAACTATGAGGACTCTGGAGCGTTCACCATCCGTGTGAACA +ACCTGTCCCGTGAGTTCATCTACACAATGGCTGGTGCTCGCTTGGGTTCTGACAATCTGC +GTGTTGGCAGGTCGAACATTGGCACAGGGCAGTACCGCTTCCCGGTTGTTGGAAACGCTC +AGACGAACATAGTAACTATCGAGTCAGATGCATCAACACCACTGAACATCATTGGGTGCG +GCTGGGAGGGGAACTACCTTCGTCGTTCTTCTGGCATTTAACTTAAAGTCTCCCTGTGGT +GAATTAACCCTCACTAAAGGGAGACACTAATAGATACGAGGGGTTAAAGCATTATGTACA +TTACAAAGTGTTTACAAATCCATGCCGACAACTTTCAGCCGTCCATAGAGGACATTCTGG +AAGCTGAGGCACTAGGTGTTGAACCAAAGGTAATTCCTGATGAGAACACTGTGGCAATGC +TTAGCGATAACGCTGTGTTGGCAATCGGTGGCAATCAGGGAGACCGAGTGTGGTTCCTTA +CCTCTAAGTACGTCCCACTGTTTACCTTGAAGGAGCGCTTAGAGTTTCGTAGACTTATCA +TTGAATATCGTGATATGATGCTGAGCCAGTACGAGTCCATTTGGAATTTCGTTTGGGTAG +GCAATAAGTCACACATTCGTTTCCTAAAGACCATAGGCGCGGTATTCCATAATGAGTTTA +CCGCTGATGGTCAATTCCAATTATTCACTATCAGTAGGAGGTAACTATGTGCTGGATGGA +AGCGATTCCTATTGCCATGATGGGTGCCCAAGCTCTAAGTAGCCAGAACAGTGCTGACAA +GGCGCGAGTGGCACAGACCGAAGCTGGACGCAGACAGGCAATGGAGATGGTCAAAGAGAT +GAATATCCAAAATGCCAACGCCTCGCTGGAACAACGGGACGCCCTTGAAGCTGCATCCTC +TGAGTTGACTACACGTAACATGCAGAAGGTACAGGCTATGGGAACCATCCGTGCAGCTAT +TGGCGAGGGTATGCTCGAAGGTGAGTCCATGAAGCGCATCAAGCGTATCGAAGAGGGCAA +CTACATTAGGGAGGCAAATAGTGTCACCGAGAATTACCGCCGAGACTACGCGAGTATCTT +TGCGCAACAGTTGGGACGCACTCAGTCCACAGCGAGTCAAGTCGATGCAATGTACAAGAG +CGAGGCCAAAGGTAAGTCTGGTCTGATGCGTGTACTAGACCCTCTGTCCATTATGGGTCA +GGAAGCTGCAAGTCAATATGCGGCTGGTGGATTTGACAAGAAGGGTGGAAACCAAGCAGC +ACCTATCAGTGCCGCCAAAGGAACCAAGACCGGGAGGTAATAATGGCTAGTAAACTAAAT +AGTGTTTTAGGCAACATGGCGACTCCCGGTATGGAACGACTCCGGGGCGTCAAAGGTATG +GACTACCGGGCAGCAACCATTCAGGCTGAACAACCAAGAGCGAGTCTTCTGGACTCCATT +GGTCGATTCGCTAAGGCTGGTGCCGATATGTACATGGCGAAAGATGAACGTGATAAGCAA +CGAGCCGATGAGCGCTCCAACGAGATTATCCGTAAGCTGACCCCTGAGCAGCGCCGACAG +GCTATCCAGAATGGTACACTGCTGTATCAGGATGACCCATACGCAATGCAAGCCTTGAAG +TTCAATACCGGGCGTAACGCTGCGTTCCTCGTTGACGATGAGGTTCAACAGGCCATCAAA +GAGGGTCGCTTCCGTACTCGTGAAGAGATGGAGCAGTATCGTCACTCACGCCTACAGGAG +CACTCGAAGTCGTTCGCTGAGCAGTTCGGTATCAATGAGATGGACGAGGAATACCAGAAG +GGTTTCAACGCGAATATCACCGAGCGTAACATTGCTCTGTATGGGGCACATGATACCTTC +CTGAGTGACCAAGCGCAGAAGGGTGCAATCCTGAACTCGAAGGTTGAACTCAACGGTGTC +CTATCTGACCCTGACCTACTGTCTCGTCCTGAGTCCGGTGAGTTCTTCCAGAACTACATT +GACAACTCCTTGGTGACGGGGATGACCGACAATCAGGCTCAACAGGTTATCTCTTCGTCC +CTGAATGACGTGCTACAGCGTCCGGGTGGTGCCGCCTTCTTGCAGAACATTGAGAACCGC +AAGGTGACTCTTAATGGCGCTACGACTACCTATCGTGAACTGATGGGTGATGAGCAGTGG +CAGGCAATGATGATTAAGGCACAGCACACTCAATTCCAGAACAACGCGAAGTTAACCGAG +AAGTTCCGACTGGATATTAACTCAGCGCTTAACCAAGCAGACACTGGTAAAGGCTGGGAG +ACTCTTCAAGGTATCAAGGCCGAACTCGATAAGATTCAGCCGGGTGAAGAGATGACTCCT +GAGCGCGAGTGGTTGATTTCCGCACAGGAACAGATGCGCACACGCTTCAAGCAGGAACAG +GCTGAGACAGCCAAGCTGATGGACAAGCAACAGAAGACCTTGAATAAATCTTTGGTCATC +GACAAGCAGTTCCAGAAGCGCCTCAACGGTGAATACGTCTCGACAAACTATAAGGACATG +CCGACCAACGAGAACACTGGTGAGTTTACACATAGCGATATGGTCAACTACGCGAACCAG +AAGTTAGCGGAAATCGAAGCGATGGACTTAACGCCAGAACAGAAAGACAAACTGAAATTG +GACTACCTACGGGCAGACTCCAAGGAGGGTGCTTTCCGTGCAGCGTTTGGTGAGATGATT +ACTGATGCTGGAAACGAATGGCAGGCTGCGGTGATTAACGGTAAGATGCCTGAGAGCACA +CCAGCGATGGACAACCTTCGTCGCATCCGCAACACTGACCCTGACCTGATTGCCTCTCTG +TATCCTGACAAGGCCGAGTTGTTCCTGACTATGGACATGTTGGATAACCAAGGTATCGAC +ACGCAGGTTCTTATCGACGCTGATAAGTCCCGCGCACAGAAGACCAAGGAGATGCAGTTT +GAGGATGACCGAGCGTGGGCTGCTATGATGAACGATTCAACGAATCCTCAAATCAAGTAC +ATGCCTTCGAGTGTCCAAGGTTACGCGCGGAAGATTTATGATTCCGTGAAGTACCGGACA +GGGAACCCTGACATGGCAACAGAACAGGTCGCAAAGTTCCTCTCTGATTCAACGACTACG +TTCTCCAGTAGTGATGTTGATGGCGATACCTATGGTGTCCTGCCGAAGAACATCCTGACT +GTTTCGGATGACCCTAAGTCGTGGGAGCAAGGGAAGAACATTCTGGACGAAGCCATTAAG +GGAATCACAGCGGCGAACCCTTGGATTACCAACAAGCAACTGACGGTGTACCAGCAAGGT +GATTCAATATACCTGATGGACACAACCGGACAGGTTCGCATTCGGTATGACCAAGAGTTG +CTCCAGCGTGAGTACCAGCGTACCGCACAGATGCAAGCTGAGGCAGCACGAGAGAAAGCC +CTCAAAGAGGCCAACAAGCGTGCCCCAATCAGCCGTGTACCACAGGCGCGTGAAGAAGCG +CGTAAACGTGTCCAAGAGAAACGGAAGAAGACTCCGAAGTACATCTATGGACGTAAAGAA +GACTAACAGTGATAAGGAGGCTCCATGAGCTACGATAAGAACAAACCTAGCGAGTTCGAT +GGGTTATTTCAAAAAGCGGCAGACAAACATGGGGTCTCCTATGACCTGCTTCGTAAATTA +GCATTCAATGAGTCCAGTTTCAATCCAAAGGCCAAATCACCAACTGGCCCGAAGGGTCTC +ATGCAGTTCACCAAGGGTACAGCCACTGCGCTGGGACTCAAAGTCACTGATGCAGACGAT +GATGACCGTTACAACCCGGAGTTGGCTGTGGATGCAGCCGCTCGTCACCTGAGTGACCTC +ATTCGTAAATACGATGGGGATGAGCTTAAGGCAGCCCTAGCGTACAACCAAGGCGAGGGA +AGAAATGGTGCCCCTCAGATGCAGGCCTACGACAAAGGTGATTGGGCCTCAATCTCTGAG +GAAGGTCGTAACTATATGCGTAACCTGATGGACGTAGCTAATAGTCCTCGCAAGGGGGAC +TTGGAGGCGTTCGGCGGTATCACCCCAAAGGCTAAGGGCATTCCATCGGGGGATGCATTT +GCTGGAATCGGGAAGAAGCAGACGGTAGGCACTGACCTGCCGGAGTCAACGGGATTCAAA +GTGGAGGGTAAAGAGCAGCAAGCGCCTAACGTTCCTTATGCTAAGGACTTTTGGGAAAAG +ACTGGAACAACACTGGACGAGTTTAACTCACGCTCTACCTTCTTCGGAATTGGCGATGCA +ACAAGTGCGGAGCTTCATAACTCTGTACTTGGAGTTGCTTTCCGTGCAGCCCGTAGCGAC +GATGGTTTTGATTTGTTCAAGGACACCATTACGCCTACCCGTTGGAATAGCCATACGTGG +ACTCCAGAAGAGCTAGAGCGAATCCGTAAGGAAGTGAAGAACCCCGCGTACATCAACGTA +GTCACTGGAGGCTCTCCTGAGAATCTGGACGCCCTCATTAAGATGGCGAATGACAACTAT +GAGATGGATGCGCGGTCTGCCGATGCTGGTGTTGGTGCCAAACTTACTGCTGGTATCATC +GGCGCTGGTGTAGACCCGCTGAGTTATGTACCGCTAGTAGGCGTAGCCGGGAAGGGTCTC +AAGGTGGTTAACAAGGCTTTCATTGTGGGTACTCAAAGTGCTGGCCTCGCGGTTGCCTCT +GAGGGTCTCCGTACATCAATCGCTGGTGGAGAAGCCCACTATGCTGATGCTGCTTTAGGT +GGTCTCTTGTTTGGTGCTGGTATGAGCGCAATCAGTGATGCTATCGCTGCTGGTGTTCGC +CGTTCCCGTGGGACTGAGGTAGTTAATGACTTCGCTCCTATGGCACACCGCTTGGAAGCC +CGTGAGACCGCTCTGAACACTGGTGGGGAAGACCTGACCCGTATGCCTAGCGAGAACCGT +GTGTTCGACCGTGAGCACGCTGGCGTTGAGTATTCACCTCTGGAGACCGAGCCGGGTGCC +GTTGTGTTGCCTCAAGGTCAAATCCTGAGCGACACCAACCCACTGAACCCTCAGACTCTT +AGCGAGTTCGAGGCGGTCAACCCTGAGCGTGCCGCTCGTGGTATCTCTTTGGGTGGTTTC +ACTGAGATTGGCTTGAAGACTCTCCGCTCTGAGAACCCGACTGTTCGCTCCATTGCGAGT +GACCTTGTGCGTTCTCCGACAGGGATGGAATCAGGCTCTAATGGTAAGTTCGGTGCGACT +GCTTCTGACATTAAGGAGCGGCTCCACGCGAACAATCAGCGCACCTACAATCAGCTTTAT +GATGCTGTGCGTACTGCAATGAAAGACCCTGAGTTCTCCACAGGTGGTGCCACAATGAGC +CGTAAGGAAATCCGACAGGAAATCTACAAGCGTGCAGCCTTGGCGATTGAGCGACCTGAG +CTTCAAGCAAACCTGACAAAGGGTGAGCGGAACGTGATGAACATCCTCAAGCAGCACTTT +GACCTCAAACGTGAAATCATGGAGAACCCGTCAATCTTCGGCAACACCAAGGCGGTCAGT +ATCTTCCCCGGCTCACGCCACAAGGGAACCTACGTGCCAAACGTGTACGACCGCGCTATC +AAGATTGAGATGGTTAAACGTTACGATAATGATGGCTTGCAGCGAGCAATCGCGGAGTCA +TGGTTGACGTCTTATCGTGCTCGTCCAGAAGTCAAGGCGAGGGTCGATGAGTACCTGATG +GAACTTAACGGTCTCAAATCCGTGCAGGAAGTTACGCCTGAGATGGTGCAGAAGCACGCG +ATGGATAAGGCGTATGGTATTTCACACACTGACCAGTTCTCTGCCTCCTCTGTCATTGAG +GATAACATTGAGGGTCTGGTGGGTATCGAGAACAACAACTTCTTGGAAGCCCGTAACATG +TTCGACAGTGACATGGCGGTGACTCTCCCTGATGGTAACACGTTCTCTGTGAATGACCTG +CGTACCTATGACATGGCTGAAATTCTGCCTGCATACGACCGACGAGTAGATGGTGATGTT +GCAATCATGGGCGGTTCCGGTAAGACTACCAAAGACCTGAAAGATGAAATCATGGCGCTG +GATAAGCAGTCAGAGGGTAACGGCACACTGAAAGGTGAAGTGGAAGCTCTCAAGGACACC +GTGAAGATTCTGACTGGTCGTGCTCGTAGGAACCCGGAAGGCGCTTGGGGTACAGCCCTG +CGCTCCGTAAATGACCTCACGTTCTTTGCTAAGAACGCCTATATGGGCGCACAGAACGTT +ACTGAAATCGCTGGTATGCTGGCGAAGGGTAACGTCTCTGCGATAACTCATGGCATCCCT +ATGATTAACGATTGGGTCAACCGTGGTAAACCGCTTCGTGCCTCTGAGATTAAGGAGATA +CACGGGATGGTGTTCGGTAAGGAACTAGACCAACTAATCCGTCCGGGACGTGAAGACCAC +GTGCGCCGACTCCGGGAGTCTACGGACACCAGCGCTGCGGTTGCCAATGTGGTCGGTACG +ATTCGTTTCGGCACTCAAGAGTTGGCTGCACGCTCTCCTTGGACAATGCTCCTAAACGGA +ACATCAAACTACATTCTTGATGCTGCCCGTCAGGGTGTGCTTGGGGATGTGGCTGGAGCG +GCCCTTGCTGGGAAAGCCTCTAAGTTCGGTAAGGCAAACTACCTTAAGTCTGCCTCTATC +AGCCCTGAGCAGTGGAATGGAATCAAGCAGTTGTTCAGAGACCATGCGACTCGTAGAGAA +GACGGTAAGTTCACCATTCGTGACAAACAGGCTTTCGCTAACGACCCACGTTCAATGGAC +TTGTGGCGACTGGCTGACAAGGTGGCGGATGAGACTATACTGCGACCTCACAAGGTTTCC +TCACAGGACTCCAAAGCGTTCGGTGCAGGGGTGAAGATGGTGATGCAGTTTAAGAACTTC +GTCATCAAGTCCCTTAACTCCCGGTTCGTCCGTAGCTTCTACGAGGCAACTAAGAACAAC +CGTGCGTTAGACCAAGCGTTGACTCATATCATCTCCTTGGGTCTAGCTGGTGGTTACTAC +GTTGCGCAGGCGCACCTTAAGGCCGCAAGCCTACAGGAGCACAAGCGTAAGGAGTACCTT +AAGAACGCACTTGACCCTAAGATGATTGCTCATGCGTCAATCTCTCGTAGTTCACACTTA +GGCTCACCATTGAGTATCTACGACATGTTCGCTGGGATGGTTGGTAGCGATACCTATAAG +TACACCCGCTCTACTGTGCTCCCTAAAGAGTCCGAGAAGCGTGACCCTAACAAGGCAATG +ACAGGTAGACAGGTGGCTTCAACTATCGCGGGTGCAGTTGGTGAGCAGGTTCCGGGGTTA +GGTTTTGTGGGTTCTGTGGGTGCAACAGCAATTAACGCAGCTTCCCTGCTATCTTCTCCC +AACAAGGCAACCGCTCTGGAGTTCCGTACAGGCCTCTTCAACACCTCTCGTGAGTTGATT +CCTAATGACCCGCTATCGCAGCAACTCATTATGAAAATCTACGAGGCCAACGGTATCCGC +ATAAAGGAGACGCCGAAGAAACAATAAACCCTCACTAAAGGGAGAGAGGTCACATTCTGG +CCTCTTCTCTCTTAATGCTAATTTACAAAGGAGGTCACATGGCTACAACTATTAAGACCG +TGATGACTTACCCGCTGGATGGCTCCACTACGGACTTTAATATTCCGTTCGAGTATCTAG +CGCGTAAGTTCGTCAGAGTGACCCTTATCGGTGTTGACCGAAAGGAACTCATCTTGAATC +AGGACTACCGTTTTGCGACTAAGACCACAATCTCCACAACGAGAGCATTGGGGCCAGATG +ACGGTTATAACATGATTGAAATCCGTCGATTTACCTCCGCTACCGATAGGCTGGTTGACT +TCACCGATGGTTCAATCCTTCGGGCATACGACCTGAACATCTCTCAGGTCCAAACCCTTC +ACGTTGCTGAGGAAGCACGTGACCTTACCGCTGATACTATTGGCGTTAACAATGATGGGA +ATTTGGATGCTCGTGGTCGCCGTATCGTTAACGTAGCTGACGGAGTTACTGATGGTGACG +CCATCTCTGTAGGTCAGGTTAAACGTATGAACCAGAACTCGTGGCAAGCACGTAATGAGT +CCTTGCAGTTCCGTAATGAAGCAGAAGGTTTCCGCAATCAGGCCTCTACGAGTAAACAGG +CTGCTGCTACCTCTGAGTCGCAATCATGGAATCATTCTGAGCGCTCTCGGACATTCGCTG +AGGCAGCTCAAGGTTCTGCTAACTCTGCGGGACAGTCAGCTACCAATGCGAACAACGCTA +TGCAGTCTGCTGGTCAATCAGCCACGGATGCTAGTAACTCTGCTGCTCAGGCTAAGGCCT +CTGAGGTTAACGCAAAGGCCTCTGAGGTTAACGCTAAGCGTGATGCTGACGCGGCCCTGC +TGGCTCTGCAATCCACTGGTAACGTACCTGTGGGTACAGTCGCCATGATTACCCACACCA +AGATTCCTACTGGTTGGGTGCGTGCTGGTGAGGACTTCGACGTTAATACTTACCCGGCGT +TAGCTGAACTGTTCCCTAGTGGTCGTACTCCTAGCTTCGATGACCGCTATCCTATTGGTA +ACTCTACCGTATTGACTCCGGGTCAGCTTATTGACCAATCAGTACCCGCCCACAGTCACA +CCTTCGACGTGCCTGTCAACGTGTCAGGTGCTACGGCTGCTGGTGGCGAATATCGCGCCA +GAACGTCACACGAAGGGGATCACAGTCATGGGTTCTCATTGCCTATCCAGAACAACACTG +GTGCTTATACTGGTCGTCTGGTTGGCGGTGGCAACAACCCTAACTACCCGCAAGACCTGC +GCTTTAACACTGGTGGCGGTGGTGCTCACAGTCATGAGTTCTATGTTCCTTCACACAGTC +ACACGTTGAATGCATCTGGGCGTGCTGCTGGCTCCGTCTCTTCGTCAGGTATTGGAAACT +CACCGTATGTCCGTCCGTATTCCACTGTGGTCATCTTCATCATCAAGGCCGCTCAAGGTG +TTGACGATAAGGACGCAGCAATGCAGGTGGTGGGCACTGTGGTTGGACGAGTGGACGCTC +TGGAGAACTGGCAGAAAAACTTCAAGTCCGTTGTTGAGAACGGTTCACCAACCTCTGGAA +ACGGCGGGCCTTGGGAACGTACTGTGTACACTGCCCAGACTGACTTCGGTCTCAACCGCT +GGCGCACGCTGAGTGGTTCGTCATGGGGAGAAGTAGTCAACTTACTTAATAGCTCCGGCG +TACTTAAAGGGTATCCGCAACGTCTTGTTGTTGACTTCACGGTTGAGGTAATCGATAGCT +CTGACCTAATCGCCAAGGCTGGTATATATAGTCCAATGATTATGGCCAGAATCGTGTATC +ACAACGGCACCAACTCTGGTGATATACTTCCCGCTGCCACCTCAAGCTCTGCGCACGCGA +CAAACGGGTGGAACATTAAGATGGCTACACGATTGTTGTATGGTACTGATGGCGGTCAAC +CAGTAGTTGAGATTGGTGCCTTCAAGGATGGTTCTGACCAGCAGACGGCAAACGTGCCAG +TTAAAGTAGGCTTGCGCCTCGTTCACGTGTTCTAAGGAGGACATAATGTTATCACTTGAT +TTCAACAACGAGGCCATTAAGGCTGCACCCATTGCGGGTGTGGCTGGTGCTGATGGTGTG +GCCCGCCTGTTCTGGGGGCTTTCTCTCAACGAATGGTTCTACGTTGCAGCTATCGCCTAC +ACAGTGGTTCAGATTGGTGCCAAGGTGGTCGATAAGATTATTGATTGGAAGAAAGCAAAT +AAGGAGTAACCTATGAGCGACAAGACTTTAATCAAGCTGCTGGAGATGCTGGACACGGAG +ATGGCACAGCGTATGCTTGCTGACCTCCAGAGCGAGGAACGCCGAACTCCGCAGCTTTAC +AACGCAATCGGCAAACTGTTAGACCGCCATAAGTTCCAAATCAGTAAGCTGACCCCGGAT +GAGAACATCCTTGGCGGTCTGGCGGCTGGTCTGGAAGACTACAACAAAGTGGTCGGCCCT +AATGGTCTGACTGATGATGAAACAATCACGCTACAGTAAGTGACATACTCAAGGTTCTCC +ACGCGGGGAGCCTTTATGGATGTTATTTGGTGCATCTATGTAAAATCTGAAAATTGATGG +GAGGTGTTATGCTAAAACTTTTACGCAGCGCACTCCCTTGGGTACTCGCCGGGACACTCT +TTATGGGTGGCTGGCACTTAGGGTCAACCCATGAGAGAGCAAACTGGAAGGAGGTAATCC +AAAATGAATACATTGCGAAAACAAAAGCAACCGCAGCAACTCAGGCAGAGGTCAGTCGGG +TATCCCGTGAGTACCAAGAAGAGATTGCAGCCATTGAAGGCAGCACTGATAGGATGCTTA +ATGACCTGCGTAGTAATAATAAGCGGCTGTCAGTCCGCATCAAGACCCTTACCGGACTAC +CAGAAGATAACGGTAGATGCGAGTTTAATGGTCGAGCCGAACTACACGAGTCAGATGCTA +AGCGTATTATCGGAATAACCCAAGCTGCTGATGCTCACGTAAGGGCGCTCCAGCGTACTA +TTAAGGAGATGCAGAATGAGCGACACCCAAGCAAACCGTAATGCGCTAATCATCGCGCAG +CTTAAGGGCGACTTTGTGGCCTTCCTGTTCGTATTGTGGAAGGCTTTGGCTCTCCCGCCA +CCGACTAAGTGTCAGATTGATATGGCCCGGTGTCTGGCTAACGGAGACAACAAGAAGTTT +ATCCTACAGGCTTTCCGTGGTATCGGTAAGTCATTCATCACCTGTGCGTTCGTTGTGTGG +ACGTTATGGCGTGACCCTCAGTTGAAGATACTGATTGTCTCTGCATCCAAAGAACGTGCG +GACGCTAACTCCATCTTCATCAAGAACATCATTGACCTGCTGCCATTCTTGGCTGAGCTA +AAGCCTCGCCCCGGTCAGCGTGACTCTGTGATTAGTTTCGATGTTGGCCCTGCCAAGCCT +GACCACTCTCCGTCTGTGAAGTCGGTGGGTATCACTGGTCAGTTGACTGGTAGTCGTGCT +GATATCATCATAGCGGATGACGTTGAGATTCCGTCTAACTCCGCAACTCAAGGTGCCCGT +GAGAAGCTGTGGACTCTGGTGCAGGAATTTGCTGCGCTTCTGAAACCGCTGCCGACTTCT +CGCGTTATCTACCTTGGTACACCTCAAACCGAAATGACCTTGTACAAGGAACTCGAAGAT +AACCGTGGGTACACCACAATCATCTGGCCTGCGCTCTATCCGCGTAGCCGTGAGGAAGAC +TTGTACTATGGCGACCGTCTGGCCCCGATGCTCCGCGAAGAGTTCAACGATGGGTTCGAG +ATGCTCCAAGGTCAACCGACTGACCCCGTGCGCTTCGATATGGAAGACCTGCGTGAGCGT +GAGTTGGAATACGGTAAGGCTGGCTTCACTTTGCAGTTCATGCTCAACCCGAACCTGAGT +GATGCCGAGAAGTACCCCTTACGCCTCCGTGACGCTATCGTGTGCGGTCTGGACTTCGAG +AAAGCCCCAATGCATTACCAGTGGCTTCCGAACCGTCAGAATCGCAATGAAGAGCTTCCT +AACGTGGGACTTAAGGGTGATGATATTCATAGCTATCATTCGTGCAGCCAGAACACTGGA +CAGTACCAGCAACGCATCCTCGTGATTGACCCAAGTGGTCGCGGTAAGGATGAGACAGGT +TACGCAGTGTTGTTCACCCTGAATGGCTACATCTATCTGATGGAAGCTGGCGGGTTCCGC +GATGGTTACTCCGACAAGACCCTTGAGTCCCTCGCTAAGAAAGCGAAGCAGTGGAAGGTT +CAGACAGTGGTCTTCGAGAGTAACTTCGGGGATGGTATGTTTGGTAAGGTATTCAGCCCT +GTGCTCCTGAAACACCATGCAGCGCAACTTGAAGAGATTCGTGCTCGCGGTATGAAGGAA +CTACGCATTTGTGATACGCTGGAACCTGTACTCTCTACGCACCGCCTTGTGATTCGTGAC +GAGGTGATTCGTGAGGACTACCAGACTGCCCGTGACGCTGATGGCAAGCATGACGTTCGC +TATTCGCTGTTCTACCAGTTGACCCGTATGGCTCGTGAGAAGGGCGCTGTGGCCCACGAT +GACCGACTTGATGCGTTAGCATTGGGTGTGGAGTTCTTACGCTCTACGATGGAACTGGAC +GCCGTGAAGGTGGAGGCTGAGGTGCTTGAGGCGTTCTTAGAGGAACACATGGAGCACCCA +ATCCATTCGGCTGGTCACGTAGTCACCTCTATGGTTGACGGTATGGAACTCTATTGGGAG +GATGACGATGTGAATAGCAATAGGTTCATTGACTGGTAGTTATGCATATTGAGTGCATAA +GGAATCATTGAGACCACGGATGGTCACTTTAAGAAACTCCTTAAGAATCAATGAGTTTGA +ATTAACCCTCACTAAAGGGAGAGAGGGGACTTAAAGCTACTATATAGGTTAGTCATTCAG +GTTATGCAATGACCCTTTATGCACTTTAAGTCGCCTCTATGATTGGTGATATTATCATTG +TATAATCACCCTACCTTAGAGCAACTGAAAGGAGGTGGCTCAATGTTACGCTTGCTGATT +GCCCTGCTGCGTCATAGAGTCACTTGGCGATTTCTTCTGGTACTTGCTGCTACCCTTGGG +TACGCAGGTCTTACTGACCACCTCGGTCAACTGGAAGTGGCCTTTTGCTCTATACTCTCT +TGTGGGGATTAAATTATTGTTGATGAACGACAAGCGGCTCTGAGGGATTCGTAGGTATAG +TTTCACTACACCAACTCATCCCTGTAGAGTCAACCCTAAAGGTTATACCTAAAGATGCCC +TGTAGTTCGTAATGGTCTTACAGGGTCTTTAAGTGTCTCCTATGGTCTCACCTATGGTGT +GGCCTTACCTAAAGTGGTTGCCTAAAGAGACCTTTAAGAATTTACCACAAAAATCTGAAT +GGGTATCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAA +GCCAGCCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCT +ATAGGATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGA +GGCCTTAAAGAGTGTCCTAGTGTACCAGTTCGATAGTACATCTCTATGTGTCCCT diff --git a/example/fna/NC_025457.alt1.fna b/example/fna/NC_025457.alt1.fna new file mode 100644 index 0000000..c8b16a3 --- /dev/null +++ b/example/fna/NC_025457.alt1.fna @@ -0,0 +1,686 @@ +>NC_025457.alt1 length=41066 tani=80.607 alt=sn;de;ins;du;inv +GATTGAGATATGATTGGAAGTGATTGGAGTATCTGATTGGTGAGTATAATGTCAAAAGCT +AATTTTGTCTAATATTTCTGAGAGGGTGTCTCCCACTTCCTCGCCCTCGACTTCCCCATA +GCACTCATACGTAATCATTTCTTATGGATTGGACTATCTGAGTGCTTATACCTTATCTTA +TACTGAGTCTTTGAGTCTTCGACTCGTATCATTCATTGATACTCTTTGGTATGTCGCTCA +TTGTATAGATAGTTTGATAGAGTGTCAACATACTTATTCAACTATTCATCTATTCATTGA +TTCGATTCTTATATCCTTGTATAGATTAGAGTGCTTGCCTTTTATGTCTTAACTCTTATG +CCTTTTTATGTGTTCATAGGTATATGCCTAGATATACAGATAGTTTTATTGATAGGGATG +TAGATAGCTATAAGATAGTTATTAGATAGAGATACTTATAGATATAGATAGTATTTATTT +TATCTATTTATACTCTTTGGTCTTCTCTTTATTCTTTATTCTTATACGTCTATCTTCTGA +TTTTCCTTAAACTGTATATTATGACAACCATACCAAGCAAACAACGCAAGGTACTAGATA +GGGATGACCTACTAGATATTCATTAACTTAATTAGATTGATTGCTTAGTTTAAAGACTAT +GAAATGTATAGGATAGAGATAACAAGCCTACGGGTAGCCACTCTATACGGTCTTCGAAAG +GTGTACCGTGGTATAAACAGCCTCCGATCAATCGAACAAGATAATGAATAATTATTTAAA +AGAATGGTTGACAACTTAAATCAATAGGTTTAAAGTTAACACTATCAAGGCATTGAGCTA +GAGTTAGATCACATTAGTTGATTGATACAAAGCGATAAAATAAATTGAAATAAAGTGTTG +ACAACAAAATCAGATATGATTAAGATGCCAATCATAGCGAGTTAGCTAGACAGTAGTTGA +GATGTGATGCTTTAATCGGTTGGCGTGGGATGTTTGCAGGTGACCTCCAAGCACCATATA +TCAAGACTCTGAAAGGTTACTCACTACCATGTAGACGATACATGGGTATTCATTAACAGA +TTACTAATTAATTCCTTATAGGTGAAGCCTAGACCACAATACTTTTGTATGTGTGCAATG +TGGTAGGTAATAGGATAAGCCATTGAGGTTGAAGTGTTATAGGTAGGCTGTGAGGCTGTA +CTCACAGTTAATTCCAATACATAACACGTAAAGCTATGATAAGGTTAATGAGTTTATATT +TAGCTAGGTTGGGTTGAATGCTATGCACATCGACCTAGCACTAATATAATCTTGAAGACT +GACACAAGGTATTAGCAACAAGGCATGGGATGATGACAGCCATTGAGGTTGAAGTGTTAT +AGGTAGGCTGTGAGGCTGTACTCACAGTTAATTCCAATACATAACACGTAAAGCTATGAT +AAGGTTAATGAGTTTATATTTAGCTAGGTTGGGTTGAATGCTATGCACATCGACCTAGCA +CTAATATAATCTTGAAGACTGACACAAGGTATTAGCAACAAGGCATGGGATGATGACAGC +ACTCGTAAGGTTCCCATATTGTTGTTAACGATCCGAACAATTCACGCAGTTAGGTCTGTT +TCCTAGCTAACGGATAATCTGATACCGCATGAGGTGATACCTTGTGTCAATGTTCAACCA +ACCAACTAACATAGGTGTATTATGAAACTGTTTTTAACTACAACTGAAATCAACAAAGCA +ATCGAATCTATCGAACGTCGTGGTAAACAATTGGATACTGATATCCATGTGGCAGGTGTG +TCAGTGTTAAAGCATGTCGCTGAACATGGCGATACAACTTTGCTTGATAAGCTTATAGGC +GCTATGCCTAAAGGTAGCCGTAAGTCTGCGTTCTGTGAGTGGGCTTTGGCTTATGGTAAT +GTCCGTATGCCTGACCGTGCTAACGACGCTTGTTTGCTATCGTGTACCTCCACGTGCGTA +GTGGGACAGAGGTGATCAAGCAAGTAGCCGCTGACTAAAGCCAACTGGGTACGCCTGTGG +CCGATGACAACAAGTACTGCCTAGGTGCAGCGATTCGATGTATAACAAGGATAAGTCTAA +AGAGTTCAATGAGGTTGAAGCTATTGCTAACAAGTGGTATGACTTCAAGCCTGAAGCTGA +TTTGTTGATTACCTTTGATGCTGCTGCTATGGTTGCATCCATGATGAAGCGTTTATCTAA +AGCACAAAAGCAAGGTGCTGAAGTAACTGGGCATGGTGATGCACTTAAACAATTACGTGC +TTTGATGCAACAACTTGAAACTCAAACTGAAGAACTTTAATCTGTAGGTGTATGCTGGGT +AGTGTCATTGTTATATATCTTTCTAAATAAATAGGTGAAGTATGTTAAACGTACCTAAAA +CAAATCCGAATGTAACTGTAACTTTAAACATCGGCTTAGCTGCGTCGCTGAACTGGGGTC +GTGACATCATTGGTCAGGTGTTTGCACTTGCTGAGAAATATAAACAAGACTGTATCGCTG +TATGGATTCACAATGATGTGAACGGTGGTATCGGTCAATTAATTGGACGTTATAACTATG +GTGGTTACTTCAATCCCGAATACTTCATTCACTTGGAGCGTTAAATGCCTTACGTCATAC +CTGTAATTATTATATTCCAAGTGGGTTACTGGCTTGGATTCTACTGTGCAAAATTCCTTT +AATAAGTGAGAAATAATATGTTTGGTTTATCTATCGTTAAAACTGCTGACCTTAACAACT +TAAAAGCACGTGTAGCTGATCTCGAAGCCGATGTAGACGGTGCATCGGATAAGGTGGCTG +CTTTAGACCGGAAGTATAATGGTTTGATTGATCAAGTACAACGTAACGATAAGGCTGTAC +GTGTTCAACTGGATGCACTTGCAAAGCCTACAGTATGTCCGTTGTTAACTGCTGTACCTA +AGAATGTAACCGACCCTGTAGGTGCATGGGAAAGTAAACAACGTGTGTTGGAAGCCCATT +TGAAAAGTGCGGAGTCTGACGTGTCTGTATTCCAAAAGCAAATGGGCTTTTGGGTAGGTG +CAGACATCACGCAATTACTATTGAAAGGGCTTAACATTACTGTCCTGAGCACTAACTAAC +CGACAGACGTCCATAGTACGAGGTAACCTGCTAGATGTAGGTGACGTAAGGACGAGGCCG +GTGTCGGTAAAAACCTATGATCTAAATGCCCCACCTGCTGTAGTCCATAAGTTTTGGAAT +ATTGAACTACGTGACTCGGTGAAGTTAAGTGTTTGATCTTTTCCATGAGTGAGATCATCC +ACGAACCTGTGTACCTATGTAATGACTGTGGTGAGGAATCTCCACATTCTGAACTATTCC +ATATCTGTTGTTCTGAGTGTGATGCACTCTGCCCATATTGTGAGTCTGATGACTTGGAGG +AATTATAATGGCTAAAAGGACTTACATAGCTCCGGGCTGTATCATTCTCGTGTGTAAACA +ACTGCATATATAGCACTAGGTCGCTACGAGTCGAGGTCCGATGACGTACACCAGAGTTTG +CACCCAGATGCCCGGCTCCAACCCGTTTAACAAAGATTACACTGTACACTGCTGCATACT +ATTCGATTGGTGCTGTAGCTTGGCTGTGTGACCATGAAGCCAGTAAAGAGGAACATCACT +TATGAAACCATATCAACCAATATTAGGTAGCCTATGTAAGAAAGTTTATACCTCTTGTCG +TTGTCTTTGGTAGTATGTTTATAGCTACATTCTAAGGGATGTAGCCGTTAAGCATGTTGC +TTAGGTCGTGAGTCTGTACTCACAATTATATTTCGCATTTAATAAATGTAGGTGACTTAT +GAAAGTCCTATACTAATGGTTTGGGTTACTACTGGGAAGAAGATGAAGTAGCTATGGAAT +ACCTTGGTTCAGGTTGTTTCTCAAGTGTCTTCAAACATCCTAATCGTACTGATCGAGCTA +TCAAATTATTCCGTAACTACCGTGAAGATAGTACCTGTTATCAGTACCTACGTTTGTGTG +CAAACAAGACTATTGATTACGAAAGGTGTCCTATATGTCAATACTTACCGTGTAACGAGT +GGATTCAGCACGCCGAATAGCGTCCATCTCAACCCTTGGACCTCGAGTCACTTCATGGAT +ACATAATAACATGACGCTGATCCTTGCTCAAAATATCACTGACCCAATATGGAACTCTGA +GCCTGAGCACTACGAACCCATCCCTGAACCATTAAAGGAACTGTATGTGTATCCTAAAAC +GAATGGGGCTTACGTTCTGTGCATGACTTAGGTGACGCTGTGTACTTTGAGTCTGATGTT +AACGCTACACATCGTCAGCTTTGACTTCATCAGGAGTCATGCGAGTATCATTGCTAGTAG +GGCGTTTAATTTCAGAGTAAGGTGCAATTAACTGCAACGTTGACATAGTAGCCAAACCTT +TAAGCTATCATTGCTGTATGTGCTAACCCTATTTCTTCAACTGTTCAATCATAAGGAGAC +TATTATGTCTAACTCTATCCGTATCGGTCGCTTAACACTTAACATGGGTAATGTAACTGT +AGGTGTTACCCGTCACCAATTATCATTGTTCATGCAGTACTCAACTGTTCAATCATAAGG +AGACTATTATGTCTAACTCTATCCGTATCGGTCGCTTAACACTTAACATGGGTAATGTAA +CTGTAGGTGTTACCCGTCACCAATTATCATTGTTCATGCAGTACAGTGCATAATTATTTA +AGGATAGACGTACTAGGGCAAGATGTCGAGCACCGACTCTTGAGCACCGTGACTCAGACC +CGTAGTGCTGGTCAGGCCCTCGGAACTAAGCAGCTGCTTACGGGGAAATAGCCGGAACAT +TCTCTTACTCTGGCTGAGATCGGGTCGACCGAGGAAGAAATTTCACTGAGGTATACCTTC +TGGATAGCTGGGTGAATAACTGAAGACCTATGGTTTGTTCGTTTTGGGCTTATCAATCTA +AGTTCTAAGGCTTAAATATAGCAGCACTTCGATGAGGTGCTGTTAGTATTTAATCACAGA +GCGTAAGGAGTTCTATCATGACTAAACTTAAACAACAATTCGAAGTAGCAGGTATCGTAG +GTCGCCCTGAACGTAAAGGTTGGAACTTCAAAGCTCAGAAGTCTTACCAACGTGGTCGCT +TTGATAACTTAAAACCTCGTATCGGTTTCGTGTGTAACCATAAGGTAGAGCAGGTTGCTC +GTGCTATTGCATTCGGTTTAGAACAACAGTTAACTTACTGTCAACTTGATGACATGCACA +ACCAACCACCTGAAGTACCTGTATGTATTGGTAAGCTTAAAGGTAATGGTGCTACGTTGT +TCCCTGATGCTAACACACGCCTCGCTATGATGGGTTTAAATGGTACTGCTGTATTACACT +AGTTAGGTGCAATGCGTGTAGTAGACGAGCTATCAGGGCAACGTGGTGAGGTTATTGTAA +ACGATAGTACTTACATTTTCACCTCTGTTGGTGTACTGCTTAACTTGGCTCAGGATTGTG +TTAAGTCTCCTGAAGCTATCCTTAACAACTACAAAGGAAGTCAACGTGTCCGTAAAGCAA +AACAAATCTGATATGTTTAGTATGGGTATGCGAGTCATCGTAACCAAGCCCATACAGGCT +GGGAATTACAAGCAACATCTAAACGCTTTTATTAAGACACACTCACCTCAACAAGTCCGT +GCTGTAGTTGATGAAGCTCAACGCTTAGGGTATACACCATACTATAAACCTAACTACAAA +TATGCCCGGGATTTTTCAGTTACATATGGCGCCAGCATTTGTGCTCGATAATGAGTCTAA +ATTGGCCAGCTGCGTGAGTCCTAGGAAGAGTAAGTTAAGCCGGTCCTGCCATGCTTGGAC +AGAGGGATAAGCAGTACGATGGGCGCGAACCCCCGCAAGACAGATCTGAGAGTCTTCAAC +TCGGGCGAGCTTTAAACAGTAGGCGTGGAGCGTTCGCCTCGGCAAAATACCGTAGAGGCT +CCAATTATTAATTGGTTCGCTTCAAATAAGGAGCTGTACCGTGGCTAAGCGTAAAGAAAT +TGTTAAGGGACTTACACTTCAAGAAGAACGCAAACTCTTGCAGTTAGAACGTCGTGAGGC +TGATATGGAACGTCAGCAAGATCGTCGCTCTAAGCGTCAGGATAAGCGTAAGCAGTTCTA +CTAATGGGAAGTTCTTACAAGATCAAGATTAAGTCCATACAGCATTACCGTCGCTGTGTG +GATAGCTTGAAAGAGGTAGGTGTACAATTCTGCTGTAATGATGAAGATGAGTTGAAGATG +CTACGCTGTAAAGATTACCGACGTAAGGCGTGGTTGTATATAGGAAGCAACAAGGTTGCA +TGGGTATTCGGAGCATACAGCGTGGTTAAGTACGCTAAGACGGTTAAGCGTAAGGAAGCA +ATGGAGCTAATTGGAGATGCACCATAGCGAATGGTTAGACCTAGCCAAGAAAGTTCCAGT +AGGTCAGAAGGAACGCCCTGCTTCAAGCCCTAATAATAATTCAATAAAGAAATTTGTATT +GTCACGCAGACATTATCATGGGGCCGAGTTAACTAAGGCACTAGATGTATGGAACAATGA +GGACTCATGGAGTGCTTACTGTCATCGGTGTCATACCTCAGCCAAGGTACGTAGTTAACT +AAGGCACTAGATGTATGGAACAATGAGGACTCATGGAGTGCTTACTGTCATCGGTGTCAT +ACCTCAGCCAAGGTACGTAAACAGTTTGTCGAACGTGTAGATGTAACCCAACCAATATAC +AGGCGATATCTTGATAAGGATTGTCTGATTACTTTGGAGCAGTTACATGATAAACACTTG +TTCAAATTCAAGACGTTGGTCAGGCTGTTACATGATAAGGGTATGAGTACAGTCACTATC +AATGATCTTAGTCCAATGTATAATACAAAGGATGATCGTCTAGTGTTCCGCTTTAAAGGT +GTGGATATTGGTAGAGACTGTTCTTCGCATTATTATGGTAGTTTCGCATTAACGGACCTC +TACGCAATGTTAGCTTGCGGCTTCTGGGGTACAGGGTTGTCACCTGCTAAATGGCTGATT +TATGATAACCCTGATCGGGAGGGTTTCGTGTACTTGCAAGGTAAAAATATCTACGTAGAA +GCTGACTTAGTTGCGTAACGTGTTCTAACAGACACCATCCCACCTGTTACCCCCTATTGA +TATCGGTACCCTGGAGAAGGTATCCAGGTCTTTTAGTTGCGACCTCGAGGCCCATATTTC +CATACTGTACACGAGAATTTTCGCGATGTGACGTGAGGGAGCTTAAAACTCGAATCGTTC +TGCCGAGTTTTTAGTCGTAGGTGTCGGATCCCGTCCCGTCAAGCCCCTCTCAGATTGCGC +CCGCGTCTCGAGAGCGGAGTCGTGCTGCGATTTAGTGAAGTTATGCGCGCAACCCCGAAT +CGAACCTGTAATAACGACAAGCCGTTACTGCCACCGACGGAGATTCCGCAGGGTGGAAAG +CACGTCGGCTTATTAATAGTCGTTGTGAGCTTTTTGGTATCCCTTGCTCTAGTGCATATA +TTCCCGACGGGTTAGACCCAAAGGATATGTCACCTGAAGCATTAATTGAAACATTCAAAT +TCTTGGAGAATTAATATGCGTGCTGTATTCGTACTACCAAAAACACATGCGGAACTTAAT +CAGTGTATCCCTACTTCGATCAACAAACTTCAGTGATGCTACGGGAGATAAATGTGGGCA +GCTTGGTAAACGTGTAACTGTTTGGTTAAATACAAAGACTTACCACCTACATACCTATCT +TGTGTTTCCACACACACAAGTAACACCAAATCAATTAGCAGGTCTACTACAGGGGTTATA +AAAATGTCAGACTTAAACCTACTCCGATGTATGATGGAGCGTAAGTCTTATCAATCGGCA +TTTGCATCCATCCCACAAGAAATGTATGACTTAACTACTCGTGCATTCCTTGCTTGGTTC +AAACTGTATTACAAGCATTATGAAGATCATGAGCGTGTTGATGTAGACACCTTTAGAATT +CTCAGGGGAACTGGTGCCTTACACTTGTCGACCGCTGGGGTCCAACTGTAATTCCCGACT +AATGGACCTAGCGGGTCCTGACTCAACCTTCTAGTGTAGGGACGAGTAGCTTCGTACGTT +TGAAAGGTAATCAATCTCAGGAACAGCTAAAGCTGACTGACCGATTACTCAAGCAGTTAC +GTGAGCAATTGGATGATGCAGTCCGTGCCACAACATTAAACGCTTTGGAAGAACGTCGTC +TATCAGGTGAGGCTGAGATGTTAGTCAAGCGCTATAATGATGGTGAGGAAATTGACATCA +TCCATGAGATGCGTAAGCTCGTACAAGCCTCGGAAGTTGCATTAGATGTACAACATGCAT +CATGGTGTGATACCGACGTAGGTGAGCTTATTGACGCTGATGCTGATGACTCAGGATATG +TAATGGACTTCTTACCTTAGTTTGAACGTCGTAAGGCAGGTACAAACTTCATTCATGTAG +GTACAGCACAGATCAGTGCCGAGGGTTTTGATAACCTGTACCCACCAGTGTCAGCATTAC +AGAACAGTAAGACAGGTATTCAAACCACATTGGATTTAGCATTGTGGATCGGTGCTTATG +CTAACCCTGTACCTGATCATGAATTGATGCGTGGATTAGGTACACCTAAAAACAAATTAG +CAAAGAGTGGTTGTAAAGGTGGTAACCAAGTTATGACATTCTTCGAACCTGAAACAAATA +ATTGGGATGCGGTGACTAACTCATGAAAACAGGTGATGATGTTCTTGTAGAGGACGAAGG +ACGTTTTGATTAAAGTAGATATAACCCAAAGAATGAATCTAAAATGTATTAATAACTTTG +GTATTTGGACGCTACGTGAGGGGCATGTATATCGTGTCCTTGATGTACGTAATACAGTAA +TCCAAGTCCAAGGTAAACACGGTTGCACTAACTGGTACAAGAAAGATCGTTTCGTTAAAA +TTAAAGAGGGTAATCACATGGGTACATTAACTAAATCTGAAGTTAAAGTAGGCGATAAAG +TAGTACGTATCAGTGGTACTGGGTTACGAGTAGGTGCGGAGTTCACAGTCATTGGTGTGC +GTCCTGATGGTGCTGCTGTACGTTTACAGGGTCAAGGTAGTGGTTGGTTCTGCATGAGTA +CATTCTCATACTACGGAACCGTCGCCGCCGTGGTGAATAGTTGGAGTCCTATGTTATAAT +TGTCCGGGGGCGGCTCGCACGACGCCTCTTTTAATGTTACGCCTCTCCTTCACTATCGTG +CCCGAGGACTACACATGGGGCGAGAACTCAATGATGTTGCCGGTTTCTGCTCTATTGTAG +AGCGTGTGCCATGGTGCCCAGTCACATGTCTCATATGATATTCAGGAAAGGATCATTCCC +TACTGGAACTGCCGGGACTAGGTATTGCTCGAACTTAAAAACGAATTAGCCTGTCTTAAG +TGTCCATTGCGCAAAGAGAAGGTTCTATCCATCAATAGCATTACCGAGAAGCCTCAACCG +AACGTACTCACAGATGATCATTCATTCAAACTACACAGTCCCGTAAGAAGCGTGAGTTAA +TGGAAGTGAATGGTACTGAAGTACCTAAAGGTAGTATGCGTGCAGTTCTCTTTGATGAGA +AAGGTATCGGTTACGGGGTATCTTTTAATAAACGTGAAGTGTACAAAGCACCTCTTAAAC +AATTGGGACTCTGTGGTACTATGTATTGGACTGACCCTCAAGAAGCTCAAGAGGTATTGG +AAGCATTACTCAAACCATTTGGTATGCATGCTAAACCTTTGAAATCAAACCTATTGGGGT +CTTAATATGGACTTAGCATTTGTCGCTGATTACTTGGCTAATCGCAAGAACCCTGTACAA +CTTGTCAAACATTTTGATGAAGTTAATGAAAAGAACATCAAATACCCACTGATCGGACAG +CTTAAATATGACGGCAGGATGGTCAGCTTTGCAATCTTGCTGATGGTGTGTATATCGGGG +AACTATGTACTAATGAGTTATCTTTAGAGGTGCTTAGTGGTTATGTATCACCTAACCGTA +AGAAGCCGTGGGATGACGTAGGGACGCATAAGATCGGTGAACTAGGTTACATAGCATTCC +ATGATTACTTAACGGGTGCTTAGTGGTTATGTATCACCTAACCGTAAGAAGCCGTGGGAT +GACGTAGGGACGCATAAGATCGGTGAACTAGGTTACATAGCATTCCATGATTACTTAACG +GTAGATGAGCTGTTAGACGGTCACAGCGATACATCCTATCGTAACCGTTACTCAAACTTA +GAAAACCGTTTGCAGAATGCAGCTATCGTTGGGTACACGGTGAAGTCTACACTGATCTAT +GATCGTGAACAGGCTGATGCTTACGCTGAAGACTTAATTAAACGTGGGCATGAGGGTGCT +GTCTTTAAAGACCCTAATGCAGATTGGGAAGCAGGTCATAAAGGTTATCGTGCAATGAAG +ATTGTACGTGGTATCCCTCCTCTTGATCTTCTATGTGTAGGTGTTGTCTATGGTAAGGGT +AAACGAGCAGGTCAAATTGCTGCTCTACGCTTCACCATGCACGGTAATGAGTTCAATGCT +GATCGAAGAAATGCGTAACCCTGTAGGTAAGATTTGGGAACTCAAAGCATTGCAGTATAG +CTCAACTGGTAAGGCATTACCGTGAAGATAAGGAGACTCCAGATATAGGTAAGCCTGATT +ATATCATACGTCCTAGTAATTAGTTTCATAAGGTAACGTGTCCATAATGTAAAGCTATGT +AACTAACAGTCTGAAAATAACGTGTTTGAGGTTTTACAAGTATATGATTTCAAACACGAA +TATTAGAAGATAGACGTATAAGATAGATAGAATCCACATAAGGAAACTGTATGTTTAAAC +ATAATTTCTTTATCCATGACTATGAAAACCAAAACCATCCTTACAAGATTGTAAGAAAAG +GGCTTCCCTCACGGAGAGGCCACCGATGCCACCAACCGCCACTCACTGTCTCATTATTGA +AGCCAACATTCACCTGAGTTAAAGGGCGATAGGGGAGCAAACATGACACCGATAGTGAAT +CAGTTCAAAAGCGGTACACAGGATTGAGTGGCGCGCATGAGCGAGTTGGTTGCACTTAAA +CATGATACGTGTATGTAGCACATAACGCTACGTTTGAAATCCAATGGATGTTACGAACTT +ATCCTACTCAATTCTTAGATTGGATGAAGAAAGGTGGTAAGGTATTCTGTACACAATATG +CAGAGTATATGTTAACCCATCAACTTGAGATGCATCCTAAGCTTGAAGACTGTGCTATTA +AGTATGGTGGTTCTAAGAAGATTGATGAAGTCAAATTACTTTGGGAACAAGGTGTATTAT +CAAGTGGTCCATCAGGTTTTGCCATATTTTCTCGTTACCGGTGATCTTCAACTGCTGACA +TTGACAAAGCTCTACTGATGAAATACTTAGCAGACCCTAAACTTGGTGACGTAGCGAATA +CTCGTCGTGTATGCTTCAGTCAAGTAGCTTTGTTACGTAAACACGGTATGTGGGATATGT +TCATGGAACGTATTTACCTGCTGATCTTCCTGACGACTTTGAGTTCTCATTCACATCCGC +ATACCACTTGTCGGCATTCTTGTTCGGAGGTACGATTCAGTACAAAGCGAAAGTAAGTTA +TGACCCTATCAAGTATGTGAAGAAAGACTGCTATCAATTTGGTGATAAGTTTTGTGTCTG +AAGCTTATGTAGGTAAGCGTGCTGAGTTCCGTGGTAAACGAGAGCTTGTAGATGGTACGC +CAATCTACAGTACAGGTAAGGATAGTCTCGATGTACTTGCAGCTCATACGGATGTTGCAA +AGCCATTGAAGGACTTAGCTGCACTTATCAAAGACACCACTACTTATTACCTTGTCGTTG +ATGACAAAGGTAAAGAGTCGGGTATGCTTCAATTCGTAGAGCCTAACGGTATCATTCATC +TAGAAATACGCTATGGACACTTCCCCTTGTAGTGACACAGTGTCGATTGTGCCGTCCAAG +ATCTACTCGACACATATCGAAAGTGACGTACTGGACTCCACGGGATTGCCAAAGGATAAG +CGATGTTGTCCCATCAACTTAACAACTGTGCAACTATTACAGGTCGCTTGTCAGGTAGTA +AGCCTAACATGCAGAATATTCCTCGTGATGGTACATCTAAAGTTAAGGAGATGTTTAGCT +CACGCTTTGGTGTTAATGGACGTATCGTTGAGGTCGATTATTCTGCTCTTGAAGTTGTAG +CCCTAGCCAGTATCTCAGGTGATAAGAACTTGATGCGGATGCTGATTGAGGGTATCGACA +TGCACTGTTATCGTCTAGCTGCAAAGCTTGGTGAAGACTATGAAAGTGTATTCGAGAAAT +GCCACAACAAAAAACACCCTGAGCATAAGCAATACAAGCAATGGCGTACAGATATTAAAC +CTCGTGCCTTTGCTCACCAATATGGTGCATCTGCTGAGGGTATCGCATATAGTATAGGTT +GTACCTTAGAGGATCCAGCTAAGACCCGTCTTTATTTATTGCTCCCACGGAGTCGGTCAT +CCCACATCAGGATCTAGGGAGTGCATGCGGGTATATTTGTACGACCGATGGTAGAGGAAA +CAGGAAATGCTGCACAACCCATTCGTGAGTTTGATGAAGAAAGTGGTCGTTATAATGTGT +ATCGTCGGGGTTACTTTCAAGCGAAGTCAGGTACTTGCTACTCATTCCGTCAATATGATA +AATGGGATAAAGAGCTTCGTATTACCGTCAAAGACTACAAAGACACGCAGATTGCAAACT +ACTGGTGTCAAGGTGAAGCATCCTTTATCGTTCAAGCTGCTTGTGGGCGAGTCATCCGTG +AACTCATTAAACGACATTTTGCAGATGGATTGGTCGTGCCGATCAATACCGTACACGATG +CAATCTACTTGGATTGTGCAACGGAAGCACTTGCTAAAGAATACGGGGCGTTGGTAAGGG +ATATTATGGAGGCTACTCCTAAGTACCTTGCTGAAGTTATCCCTGCACTTAAAGATTGGA +ACTAGTGCCGATCAATACCGTACACGATGCAATCTACTTGGATTGTGCAACGGAAGCACT +TGCTAAAGAATACGGGGCGTTGGTAAGGGATATTATGGAGGCTACTCCTAAGTACCTTGC +TGAAGTTATCCCTGCACTTAAAGATTGGAACTATCACTTAACACCATTCCCTGCTGCTGC +TGAATGTGGGGTTAACATGACAGATGTCGGCTAGATATATTATTACCTCACTAATCTATT +ATTTCAGTATATATGGTGGGTGGGTGGTTGTGTGGTGCCTGACGCACAAGTCGTTCGGAG +GCGGTTCTTGAAATTGACGCCTAGTGCCGTTTTACCGTGATTCTCATAATGATGTGAACA +AAGAGGATATTTAATGCATATTGCATCCACTATGCCACAGGGTATATTCTGCCCGTTACC +TGCTGTCAGTAACTTAGAATTCTGTAACTTCACTTACATGTGTGTTCGTGACCCTCTTGC +ATTTGAGGGTGCATTACGAGTACCTGAGAACTTACAGGATATAGTTATCCCACTGTTATC +TTTGATACTGGATAAGGTAGACACGGATGATTACATTTATGTCACAGTTAGTCGTAAACA +CCTACAACCTAACACATGCGGTAATCGAGCAGGTTGGCATGTGGATGGAGAAACGCGTAT +AGCCGGACCCCGAGTAGTCTGTATATTCCCCACGGAGGACTTTCCTAAGTGATGATCAAT +CATTTATTTGGTTCGATAAGTTACCTACTCAAATTGCATTGGGTGGCTTTGAGGTTAGCC +CTGATCATGAACAATCATTAGAGCAGTTTGATGCCCAAGTAGATTACGGGAATATACACG +AATTAAAAGATTGTGTACATCGACCAGTCTTCAACCACACTAATGACGTTCAGTTGCGTA +CCTTCAGCGTGGTGAGTCTCGTAACCACACTGTAGTTTAACCTGTACTCACAACTCAATT +CTTAAATTTATATCGGGGATTATTTCATGTACGACGGACATTTATGCCCAACAAACTAGC +AGTTGTGCCTTAATCTCCTGCCCCGGGGCTTACGAACTCAATCAGCTATCAACTTCTTAG +ACCTTGCACACGGTATCGACGTAACTACTCTTGACGACATGACTGATGTTTCATCAGGTG +GTGGTGCTAAACGTGGTTTATTACCCGCAGGTGTAGCTTTTGTAGTATTCAGTTCATACA +TTGAGTATGGTAACCAACCACAAACTTTTGAGGGTAAAGCTAAAGACCCGCTACCTGAGT +TCCGTTTAGGCTTCCACGTTGTAGGTGGCGTAGGTACTAACAAAGAGGGTGAGCTTGAAG +ATTATGTGCAAGATGGTTTGTGCCCTACAATCAACGCATTCGATTGTAAGTTGAGTACGA +ATGAGAAAGCCCGTGCTGTTGCGTACTTCAATGCGATTAACATTGCACCTAAAGGTACAC +ACTTCATTCAGAAGTTAGGCACATTATACACAGTGGAAATTAAGATCGGTAAGAATAAGA +AGACTGGTAAAGATCGTAAGAAGTCTAAAAACTTCTTCCAAGAGAAATGCTTATCTGCTC +TGAACTTTGCAGGTTCAAGCCGAGAGCAGTTATTATCAGGAGGTGTTATGCAACCTCTTG +ACGCTGATGAAGCTGAGCCTGCTGATACACAAGCTAAACAGGAAGCTGTTAAGGCTGAGG +TTGTTGAAGAACCTGAATCTGAAAATGAAGTTGCATTGGATGTTCCTGACCTCTAATGTG +ACCGAGTGAAATGTCTACCCGTATTACCATTAAATCCTACAGTACATGGTCGTCATCGGG +TATAGGTAAACGTCCTGATTATTTCTTTGATCACCACTGTTTTTATGACCAGTACCTACG +GGAATATGTAGAACAGGAGTACACAAAATATGACGTTTGATCTAAGTCAATTTGGTTTAG +ATGCTAAGGCGTTACAATCTCAGGATACATACAAAACCTCAACGGCAGGTAGTGTTCTAT +TACTGGATGGTGATGGGAATGCTTACGAAGCTGCTGCGGGTATTGTCGCTGCCCGTGGAC +TACGTCCGCCAGCCATATACTTAGTACGACGCCTAATTGCCCACTATAAAACATGGGGGA +AATCTGGAATTCGATCATGTGTACCAATGTGCCAAAGCCTAGTTACTTGCGTAAGGCGCT +AAAGCCAAACCTGAGACCGCCTTACGTCACTTTGAACGTAGTATTTTTGAAGCTATGTTC +CTAGCAGGTTGTGAGAAAGCACGAGTACATTTAACCCCTCGTGGATGCTTCAAGAATGGT +CGTCATTTGCCGTTAGGTGTTAAGCCTTACCAACTACAGCGCAGTAACAATAAAAAGCCA +CCACTGGTCGCTGTGTTTGAAGATCAGTGAGTGGGCTACAAGCCCTATGTCGATTCAGGA +TAACGTATGGCCCCGATGCTGAGCTCTGTCTGCTCTGTCAGTCCTGCAGACAGACAAAGA +AACGTCAGACTTGAGCGAACATTCCGGGCGTGATAGTATATTGTTTAACGACAAAATTGG +AAGACACTTCTTCGTTTTAGAGTTAAGTGTGTATTATTTAACTTTCTCCGACGATGCTTT +GAAAGTCATACAGTATGGATGATGGTAAACATATAGTGCTACCTGATAGCTTTATAATAC +CTTTGACGTTATCAGCAGTATCACCCATGAGCATCTGAGATAAGAAGAACTTAGTACCTT +TACCGATCATCTTAGATGCAGGTTTAAGACTTGGTGTTAACCAGTGCTTACGATCAATCC +AACCAAACGTATCACCCAATGGTAAAGCGTGCGGTGAGGCAGGTGCTTATGAAGCCCTAG +ACCCTATCAAGGATAAACATGAAGCTGTGAACTTCGTTATTGAAGCTTACAAGAAGATTG +ATCAAAACATTATCCCTGAAGCTGAAGCTATGTGGTTATTGCGTAATGCACAAGATAACT +CATTAAAGTTCTTTATGGAACATGACCTAACTGATAGTAACTTAAATTTCTTAAACGAAT +GCTACCATGACCGTAAATGGAAAATGGAAGCTGATGATTATGAGGGTGACCTAAATGAAA +TATAATATTCCTGAAGCTGTACAGCACGTTATTGATCAACTTAAATTGGTTGGTATTGAA +GCTACGTTGGTAGGTGGTGCGTTACGTGCTGCTGCTCTTGGTGGTATATCCAATGATTAT +GATTTAGTTATATTTGGAGAACGTGAGGACTTCTTCCACACTGATAAGGAGATCGAGTAT +TTAGGTTTCCGTAACCAACACCATGACGAATACTGTAACAACGAGGGTTATGTAGCAGAT +TGGCGTAAAGATGATGTGAATATCATCATGTATGATTCTTGCAAAGTAGCTGACTGGTAT +GCCTTGATTGAAGTGTTTGATTTAAACATCAACCAATGGTATATCAACGAAGCAGGTGAG +CTTGAGAATGATTACTATGACCCTGAAACTAAGCTCGTAAGTATTAACCCATTCCGTGAT +GGTCTAGATCATGCTGAACGTCTCACCCAACGTATGGAACGCTTCCGTACTATGTTTCCC +GATCTTGATTGGTCTGAGATTGAGAAGCGTCGTAAGGTTAACGATTACATAAGACAGGTG +AGATTCGTGGTGTACTTCATCGTTCCTGTAATGCTGCTGAGGGTAAGGTAGCCAATGCAG +CAGGGGCGTGGGGTGCTAAGTCTATGGCGTATGAGGATATTGTCCCATTCGTTGAGGGTT +TAGTTACATACTGGAAGAACGCTGAGAAGTATGGTACTGGTATGATGTACCCTGAGCACA +AAACTGATGAGCAAAAGAAAGCTGCTGCGTCATTGAAACGTCGTAAAGCTTACGCTGCAA +ACAAAGCTAAACAAAAGGTAAAAGATAATGCAAGTAAACGATAAGATTACATGTGCCTAT +GCAGGGCAGTATCAAGGCACATATCTTACAACATTTAAAACTTATACAGCCCTCAGTACC +ATGCACGATCATGGACGGGACTATGTAAATCTAGTTGATGATTCAGGTGCAGAACGCACA +TATACCGCTAACCGATTCGTAGTACAGGAGAACTCTTAATGTCACAAGCCCACTTCAATA +AACTGAAACCGTGGAAACAAACTGCACTACGTCTACACATGCAAGGTATGACTGCTGCTG +AAATCTCTCGTGAATTTAATAATGAAATCTCAGATCGCACTATCCGAGATAACATTCAGA +AACTTGCACCTCAATTTGAACGTAGTGTTGTACTTGCAGATCGTAAACCAACTAGATTCG +TGATTGGTGATACACAGTGTAAGCAAGGTATTGACCTCGATTATATGCATTGGATTGGGT +CTTATATCGCATACAAGAAACCTGACATTATTGTGCATATCGGTGATCACTATGATATGG +CTTCATTATCAAGTTATGATAAGGGTCAGTTAAAGGCTGAGGGTCGTCGTGTTGTAGAAG +ATATTGAGGCGGGTGATAAAGGTATCGAGATCATCGAATCTTATATTGCTAAGGTCAAAG +GTTATAAACCACGTAAGGTTGCGATGTTAGGTAATCATGAGCATCCTATTGATCGTTACG +TTAATGATAATCCTGAGCTTGAGGGTTTCATGGGTACAGATCAATTAGCCTTTGCTAAAC +ACGGTTGGGAAGTCTTTCCGTTCTTAACACCCGCCACTATCTGTGGTATCAACTTCGTAC +ACTTTGTACAGAACGGTATGACGGGTAAACCGCTAGGTGGTACGATCATAACTCGACTGA +AGAACGTGGGTGAGTCTTTCGTAATGGGGCATCAACAAACATTTGATCATTGTATCCGCT +ATCTACCCCTAAGTGGTCGAGCGCAGATTGGTGTTATCATTGGTGCATGTTATGAACACA +TGGAAGACTATAAAGGCGTACAAGGTAATCATCACTTCCGAGGTTGTGTTATGCTATATG +AATGTAATGATGGTTTTGATTTGGTTAAGCCTGTATCACTTCAACACATGAAAGATCAAT +TCTTAGGAGCTTAATTATGAAAATCGGTTTAATTGGTTTAGCAGGTGCAGGTAAGGACAC +AGCAGCATTATTGATTCAAAAGATTCTTACAGATAATGGTAAAGCATACAAGATTGATCG +CTTTGCTAAGCCTCTTAAAGATGCAGCTCGTGAGGTCTTCGGTGCTACATTCGATGATCG +TGATGTTAAGGAAGTACCTGTTAAGGTAGATCAAGATACCATGATTGAAGCCTCATTTAA +AGCGTTACGTAAGTGCCGACTTACTGAAGCTGAAATGGATAAAGCATCTGAGTTGTTCTT +TGAACACTTAGGATTTTGGAATTACCTATCCCCTCGTAAATACCAACAGTTGCTCGGTAC +AGAGGTTGGACGAGCTGCACGATGCTTCTGAGGTACTCGCTACAGAGATGCAGCTAGGTC +TTAATGAATCTTATGATGCTATGTTCACGAACACTGGAAGAAGAATACTCAACAGCAAGT +TTAGTTGCAGGCCAACAACAGATCATGGATGCTTTCAAACAAGGACGAGCTTTCAATGGG +TGTGCTAACCCTGAACCTATAGCAATGCAGAGCTTCTTACGTCAACTAGGTCGGATTATT +GAATCTGAATCTATGTTGGTATGTATGGAGCAAGTATCTGATGTTTATACAAATCGTACA +GTAGAGTATCTTGATTCAGCAGGTACTAAATCCACTACACACCGCTACCGTACACTCCTT +AAAGGCGCACAGAACATGGGTCTTAATTGGGAACAATGGACTGTAGAGGAACGTATAGGT +ACTGCCCGTTTACTATTGACTTGTCTTTATGAAAGTACGGGTTTATTCAAGTGGGTAGCT +AACCGTGGCACTACAGATTCTATGTATTACCTTGTGCCAAGCGAGACTTTAGAGAAACAC +TTTGGAGAAGTACAGAGTGCTGCTAAGGCTGTAGTTAAATATCCACCTATGTTAGTACCG +CCAATGGATTGGACTGGACAATACGACGGGGGTTATATGACAGAGTGGTTTCGTTTACAC +TCTCCTATGTGTGGTATCCGTTTCATTAAACCTGAACATAAGAAATGGATTATTCAGAAC +TTAAACAGCGAGCAATCGCTCCCTGTACGTACTGCAATGAACAAAGCACAGTCTGTACCT +TACCGTGTGAGTCAGCGTGTATTGACGATTCTACGTACTGCTACGGCTATGCGTGTCGTA +AAGGTGGTCATATGGGTATCCTGTCACGTATCAATGAACTTGTGACATATCAAGAGGAAT +CACGCTTATACATTGAACTATGCAATTCCCATGCCAAACTAAACTGCTGCTCCCAATTTC +ATACTGACATAATGCCAGTCTTATTAGCTTATCGAGCCTTTCAATTGGAATCTTCATATC +TATCTGACACAACTATAACACTTGGGTCGCGCACCCGTGAACAGCCACTTACTAGCGATC +CTAAGACGTTAACTAAAGGGCCTACGCTTTTCCCGACATTCATTGACCGTACAACAGGTT +AGAGGCCAGCCCCAGTGAGCGCCATCTGACCAGCCACGCGCCGACGATCTTTCACAAAAC +GTGTCTCGGCTCTCTTCCATTGTACATCTAAGCTGGCGTGGTCGTTTATCACTCTCTCCA +CTGTTAGGAGAGACCAGCAATAGCCTTTTCTTAGGTTCAGTATTTCCGGCTTATACACTC +AAAATGATAATCGCTCAGCGATTAATAACGTACTATACCGGGCTAGTACTTCCGAGAACT +GGTCGCAAATTGAATATTTTATCAATAACCCCCTTGATGTTGATGCCCCTGAACCTGACA +CAGCATTTATATTATTGCAAGCTGCTATCGCCTTACAAGACGCACTCGCACTGCCTAATC +CCGAACTTTATGTATGTCACGTACCTGTCGATATGGATGCTACATGCTCAGGCTTACAGC +ACCTGTCTGCACTCACTCGTGACCCCGTAGGTAGTTATTACACAAACCTTGTAGATAACA +AAGACAATAAAAAGTCTGACATTTACATGCGGGTTGCTGAAGTTGCTAAGAGCATGTTAC +CTAAGCTAATTGACGATGTGACAGTAGATCACTTTTGGAAAGTGAATGAGATCACACGTT +CTATGGCTAAGAATCCTGTAATGACTTATGTGTACGGTGGAACGCTACTACGTTGTATTG +ATACCATTGGTTTAGCCCTATCTGAATCAGGTGTTGAACCTATTAAGAACGATGCAGGTA +AAGTTGTATATAGTATGACTGCACTTGCTACACCTGTAGGGAAAGCTTTACGTAAAGGTG +TTGAAGAAACTGTACCTGAATCTGCTAAGATGATGAAGTTCTTACAGACTGTGGTACGTA +AACATAAAGAGCATTGTCTGCGTTGGGTTACCCCTGCGGGTGTTCCTGTAGTTAACTGGG +CAGAGGGTTCTATCATCAAAACGCTTAACATCCGTTCTATGGGCGTCACCTCAGTAACTA +TGAAAGTAGGTACTAAGCAATATAATACTCGTTCAGCAGCAAACGGTATTGTACCCAACT +TTGTACATAGTATGGACGGTTCACATCTATGCTTAACTATTAACGAGTTCAATGGGCAGG +TTCTACCTATCCACAACTCATTCGCTACCCATCCTAGTGACGTAGGTGCTATGCATGAAG +CTTTACGTAAGACATTTGCTGATATGTATAAAGCTTATGATATTAACGACTTCTTAACTT +TCAATGAAGTCGATACAGAAGAATACGAAGCACCACCTCAAGGTAATCTTGACTTGGTCT +TGTTGTTCTTTCTTACATGTCAGTTAAATTATATGCTTGGGACTTGAAAAACTAACCGCA +CTTATCAAAGTACATAAACGTAAGTAATCAGAAGCCCTTGAGCCTAACCGCTTGAGGGCT +TTTTTTTTTGTTTATCAATAACTTAACGAGTTACACAATGTTACGCAGTGGTAGACAGAT +TTTACCTACCTCTCCCAGATCCTTACCGCCAGTTGTGATTCCCCATGACCCGTCCACATG +TTGAATAACGTCTGTTCAATAGTGCTACGTAAGTGTATGAATTTAAATAAGTAATTAGAA +GATAGACGTATAAGATAGGAAAGGAGATTCAATCGTATGAATATTCCAAAGTTTACAGAT +GATCAGATTGATTATTTAAATAGAGTATTTTCAGAGAATACAGTTATGACCTTAGACCCT +AATGAGTTGTATAGACGATTAGGTAATAGACAGGTTATCCAACATATTATTCAGTAAGAT +AGGAAAGGAGATTCAATCGTATGAATATTCCAAAGTTTACAGATGATCAGATTGATTATT +TAAATAGAGTATTTTCAGAGAATACAGTTATGACCTTAGACCCTAATGAGTTGTATAGAC +GATTAGGTAATAGACAGGTTATCCAACATATTATTCAGTGCAATGAGAATGCTAAACGTA +AGATCACATCTTAGGAGGTAGTTATGGGTTTAGGTTCATTCCTGAAGAAATCCGTTAAAA +ATGCTTTCCGTGGTGGTAGTATGTGGAAATTCGCTTCTAAGGCTGCTAAGCCTGTTGAAG +ATCAGGTGCGTAGTATGTTAGGTCTTGATGCACTCAAAGACTTAGCAGGCGCACAGGAAG +CACAACTACGGCAACAACAGGAAGCTAATAAATTGGATGCTGCAGTGGAGTCTCAGAACG +TGGCGCAGTTTGATGATACGTCAGACACAGGGTTTACAGGTACGGATTCCCGTCGCAAGA +AGAAACAATCAGGTGCTTATTCACAGGCACTAGGTCTTCAGTTGTAAGGAGGTATTATGG +CTAAGTATCCTGAGATCACTTATTCACTCAAGGCATTGTATAATCAGTATCGGGATACTT +CACTACTTTCACGTATTGAAGACTATGCTTTTTGGACTATCCCTAGTGTGTTTCCAAAAG +GTGATCAAGATTTTCGACAACAACAAAACCGTGCTATCGAATATGATTATCAAGCTGTCG +GTGCAATGTTAGTAAACCGACTGGCTACTAAGTTGGCACGTACATTATTCCCCGCTAATC +AATCGTTCTTTCGTATCGACGTGTTATCGAATATGAAAACCAAGCATGTGAACAATTGTA +CATGAATGCATCTTATGCTCAACTTGTACAAGCAATGCGATTATTGGTTATTACTGGTGA +GTGTTTACTGTATCGTTATAATAACGCATTACGTGTATTCTCATTAAAGGATTACGTCCT +TAAACGTAACAACGTTTGAATGCATCTTATGCTCAACTTGTACAAGCAATGCGATTATTG +GTTATTACTGGTGAGTGTTTACTGTATCGTTATAATAACGCATTACGTGTATTCTCATTA +AAGGATTACGTCCTTAAACGTAACAACGTTGGTGAGGTTATGGATATTGTTATCTGTGAG +CATAAGTACCGTGAGGAACTTACACCTGATCAACGTGTCAAACTTCAGATTACAGAGTCT +CAGACCCGTGTTAAACTCTATACCCGTGTTAAGCGTAAAGAGGTTTCACGACCATAAGAA +TCACCATTAACGAGATTCCATGCGACAGGGATGAATGGGCATAGCTTATCACGATACACA +GTATTAGTACCAATGTCGATACCATTAATCTCCTGTGTTACATGCCAAGACACAATACCA +TGTTATGTAGAGGATTATGCTGCTGACTTTGCTAAGTTATCAGATATGTCTCGTGAGCTT +ATGTCTTATGAGATGGAGTCTTTACGTCTTCTACATATGGTTTGCCCTCAAGGGGCTGTT +AACTAAGGACGTCCATATAACGACGACCATAGGCGTCTCGGTGGAGGTCGACGGGACAGG +ATGGGCACGTGTTGCTGACGCAACCCGGGAGAAACGCGCTTGGCCGATTCAAATCTCAAA +TTCCCTGAAACACAGTGTAGTATAAGGTGTGATTTTCCACCTCGTCGCAAGGCAAATCGG +CACCAAAGGGCTACCAATCGGACCGCCAGGATGTAGAGTCTGCTGCGAATGCCCCTAATG +GTGAGTTTATTCAGGGTGACCCTAGTATGATCAAGCCTTATGAGGCAGGTTCGTACCAGA +AGATTGCTGAGATTCGCAATGATCTTGAAGCTATTGAACAACGTTTAAATATCGCTTTTA +TGTATACAGGTAATATGCGTGAGGGTGAACGTGTCACTGCTTATGAAATCCGTCAGAATG +CTGAGGAAGCTGAGCAGGTCTTGGGAGGTGTGTACATTTGCGTATTTATTACTATACGAA +GTAAAACCAAACATCATGGAGGCGATTGACTCTCAGGAGATTAAACTAAATATCTTAACT +GGTATTCAGGCATTATCTCGTTCATCTGAGAACCAAGGTCTAGTAATTGCTTGTTCTGAG +TTGAACGCTATTATCCCTACAATTGCACAGCTTGGTAAACGTTTTAATATTGATGCTATT +GCAGATAAAGTCTTTGCATCTAATGGAGATTTAAAATGACTCAAGAAGTAATTACACCTG +GAGTAACCTCTGCTGCACCTGCACCTGCTGCTGTACAACCAGTGGTAGAACCTGATGCAC +TTACCGCAGGTCTTAAACCTGAGCACGCTGCTCAAGCTAAAGCATCGGCTCAAGCTGCAT +ATCAGGAAACACGGGCTGCAATTCAACGTGATCTATTGCTACGGCTGAACGCCTAGCAGG +TGGTTCTGAACAATGGAAAAATATCGGTTCTACATTTAATACTAAAGCACCTGCTCATTT +GAAAGCAGTAGTGTCACAGATGTTAGATGCAGGTGACGTACAGAATGCTGTACAGTTCGT +TATTGATACAGCAAATGGAGAAGGCGGTGTTGGCGGTAATGGTGCTGCATCTTCAGGTAT +CTCAGAAACAGAATATTTTGCACAATTAGCAACCCTAGAACGTGGAGCGGGTAACCGTTC +GGCGCAGCTGAATCCCTCATGAAATGACCTGGGGATGGCATGACGGTCCTTCATCCCGCA +CAAATCATTTGAGCAGGGCGAGTGCGCACACAAGTTAACTTTACTTCGTGATGCACGTAA +ACTAGGTCGTAATAACGGTCTTTAATATTAGGAGAATTTAATCATGGCTCAAGGTACTAC +TTATCAACCGAATACAACTCGCTCAGGTTTGTCTGCTCAGCGTTCTACTGAATCACGTTC +TAATACTATCCGTCTTGACCGTTTGAACGGTTCAAAGGTTAAGGGTCGTAAAGCGGGTGA +GGCAATCGAGTCTCAGCGTGTGACTTCAGATAAAATGAACATCACAGTCGAGTGTATGAT +GTACACTCGTAACCCTATCGATTGGATGGACGATTGGACTGCACCTGACTTCTTGACCGA +TATTGGTCGTGACAACGGTACTGAGTTTGGTCTAGCATACGATGAGGCGCACTTAATCCG +TCTGATCAAAGCCCGTAACTGGGTAGCACCTGCACACTTAGCAGTGTCGTTTAAAGATGG +TATGCATGTAGAGGTTGCTTTGAAAGCTGCGACTACTACTGCTGATCTTGAAGCTAACGC +TGAAGCTCTTGTATATGCTCACGGTGTGCTTGTAGAGGAACTTACTAACCGTCATGTACC +TTTAATGGACATGATCACTGCGGTAACTCCTAAAGTGTTTGGTGAGCTTTTACATCACCC +TAAATTGATCAACAAAGACTACGTAGCTTCTAACGGTGACTTCGCAGGTCGTCGTATCGT +TGAGGTTAACGGTCTACCTATCGTACAGATGACTGCGTTTCCTAAGACTGTGGGTACTAA +CCATATCTTGTCTACGGAGACCAACGGTAACGCGTTTGATGTGACTGCGGATGATGTGAA +AGGTGAGATGATCATTTTCTCTAAAGCGCTGTCTCTAGTCACTGTAACTGCACAGGCTTT +CGTATCTGACTTTTGGAAAGATAAAGCTGAGATGTGAGATGACTGCGTTTCCTAAGACTG +TGGGTACTAACCATATCTTGTCTACGGAGACCAACGGTAACGCGTTTGATGTGACTGCGG +ATGATGTGAAAGGTGAGATGATCATTTTCTCTAAAGCGCTGTCTCTAGTCACTGTAACTG +CACAGGCTTTCGTATCTGACTTTTGGAAAGATAAAGCTGAGATGTGTAACGTGTTGGACT +GCTTCACTATGTTCACCGTTGATATTCGTCGTGCTGATACTGTTGGTGTTGCGTTGATCA +CTCGTACACCTTAATCATAACACGGAGGGCTTCGGCTCTCCATTCAATTTTAGGAGTAAA +ATAACATGGCTAAACTAGGCGAGACAATTGTATCCAGTGCTATCTCAGGTAAACCTTTAA +CTTTATCAGATAAAGCTTTTTCTTTGGTAGGACAAGCAAATGATAAGGTAGCTGCGTTAG +AGGGTCAGGTTCAAGCATTACTAGCTCTTGTAGCTGCACAAGGTATTGCCCCTACACCAG +TAGAAGCACCGGTAGCAAAACCTGTGCATTAGATCCGCCGTTCGAACCATCCCTTTTATA +CTTTAGCGCCAATCTTGTATAAATGGCTACCCTAGTAAACCGATCCGCAGAGGCCACGGG +CGAGACATCAGGAACATATCTCTGCTAAGGCTAAGACGGGAGAGTAATCATGGCGTTAAT +CAAAACGATTAATGCTGCTGATCTTCAAGGTACTAATGAGGTGAGTGTTGACTTCACCTC +TGTACTTACCGCTATCAGTGGCGTTAAAACAGATACCACTGCTATACAGGCAGACGTTAC +CGCTGTTAAGGCTGACTAACACTACACCAACACCGCAAACTCGAAAGGGTCTACTTTAAG +ATATAATCCAAGCAACGTAAATCCCAAGTGGTCGTATTGTGGTGATTATATCTTAAAGTG +AATCAACCATAGGAGGTATAATATGGATATGTTAGAAGCTGTAAATACTGTATTACCTTA +TATGGGTGAACACGTAGTTACACGTATTGAGGGTGCAAAGCATCCGTCGTATTGTGGTGA +TTATATCTTAAAGTGAATCAACCATAGGAGGTATAATATGGATATGTTAGAAGCTGTAAA +TACTGTATTACCTTATATGGGTGAACACGTAGTTACACGTATTGAGGGTGCAAAGCATCC +ATCTGTAGATTTAATCCAAGCTGCTATCAAGCGTCGCTGGGTTTTGTATGCGAGGATGAC +CTCAAACAGCGCAAGCGTCGATAAGGGGTTGGGAAGGAACCCGGTTACGACTCACGATGC +GCACGACGCAATCCCTACGTTACTCAGGCTACTGCGGGGTGCCCCGGATAGTCTGTCTGA +TCTAGGGACTCATAAGTGACCGGCTGGTGGAAACGCGATTGTCCATGTAGCAAGTAACAT +TGTTGACTACTGGTTGGTGGTTTAATGAACTACATGGTGAGCGTTTCTTCAATCTTGATG +AGGGTTCACGATATTTCTCTAAACCGTTAGAAGTTAAGATTGTACGTAATGTACCTTTTG +AGAAGTTACCCGAAACTGCTGCATTATATGTAACATATAAAGCTGCTATTGAGGTAAGTG +ATTTAAGGTGCGTGAATGATTTGTACACCCCAAGCTGTACTACTGGTGTGTATCTGGGGG +TATAGGCTGCTCCAGGCGGGCTGCCAACATTCAAGATCTTCATCTACGTGGATGGCCGTA +GAAGCAGGAATATAAGATAAATAGTATCTAGCCTAAAAGGTGTCTTTGTGCACGTCAGGA +TACGTACCTGTTCAAACTCGTATCATATACTGCTGATCTTGGTGCTGAGGATGTACTTCA +GATTCTAAACAATTATACAAACGATAACTTGATTTCTTTTAAGGAACTCAATTTACGTCA +ACGGAAGTATAACAGTAAACGGACGGCTTAAATGGTTATTTTAAAGCTCGTAGTAAATCT +AGTATTCGTACTACAGTATCTAAGGATAATTTCTTCATTCTAAATACTGAGTTAATCCCT +ACCAAACAGCTCGAAGCTGAGGCGGGTAAGAATCGTAAGCACTACGGGTACTTCAGCATT +GTGTCTACAGCGTTTAGTAAAGTATTTACTATATCTGTAACTCACCCCTCTATTGGTACT +ATAACTAAGACGGTTACTGCATCTAGCGACAATGCTGCTGAGGCAAGTCAGGAAAATATC +GCTCGTGGTCTTGCGGATTTATTCTCTCAAGATACTACTTTTGCAGCGGTGTTTAATGTA +CACCGTACAGGTATCACTGTAGCGTTTGAGGTAAAGGATAAGACGTAAACTGGTACTACA +GTTGTGGACTCCACCCCCGGCCCATACTACTGGTGTTCCTTATGTTGTTAAGTCAGGTGC +ATCCCGTGTTGTGAATAAGGCTATTCGATCATGGTGCATTACGTTGGGCTGAGACTGGTG +TTTATGAGCCTAACTATAAACTTATCAATGAGCCTATGTATTGGTATCTTGATGCTGCTG +ATACTGTGAAGCTTGTACCGTTAGGTATTAAACCTCGTGAGGCAGGTGATGACGATAATA +ACCCTGACCCTAAATTCATTGGGTACGGTTTGACAGGTATTGGTAGCTACCAATCCCGTC +TAGTATTATTGAGTGGTTCATACGTCAATATGAGTCAGACGCGTTACTTCAACCAATTCA +TGCGTACTACGGTTACTGAACTGTTAGATGATGATGCTATTGAGGTTTCTAGTTCTGCAC +TTAGCTCTGCACAGTTTGAATACTGGGTGCCTTATAATAAGGACTTGGTGTTAATTGCAC +AGACACAGCAAGCAGTGATCCCTGCTAACTCGACTGTACTCACACGCTGCATCTACTACT +AACAACATGGTAGTGATGAGTTCAGACTCCCGTGATGTATTGGTTAATCAGTTCTTATGG +GTTGGTGATGATCGCCCTCTGATGAGCTTCCATAAATGGGAGTACCCATTACCTGTTGTA +TACGCTCAGTTCATTCAAGAATACTTAATCGTGTTCATGGATGATGGGCAGGGTAACTTA +GTCATCGGTACTCAGAACGTACAGTTAAACCAATTAGATGATAAACCTATGCCATTCCTT +GACTTGTATGGTTATGTGACCATTGAGAACGGTGTTGGTGTTTTACCTGAGTATTTACTT +GAGATGAAACCTGATGATATGGAGTTAGCTGCACCTATATATAATGACCGTTATCTGCGC +CACCAAGTGGATGAGCGCCCACTGAGGAGGGATCTGCGAAACTCAGTTCTTGAAATACAC +CCAACTTTAAGCGCTACACTAGTGACCTCCTCAGGAACATAGGATGTCGAGACTTTAGAT +TGAGTTCTCGTATGATGATGAGGGTAATGTTACATGTCCTTATGATGGTGTTATCTATGT +TGGTGTACGCTTCACAAGTGAGTTTACTTTGACACCTCCTTTTATTAAGGTATCTATCCC +GTGTCGTACTCGTTTAACGTCTACACAGTGTTCTGTAGGTGATCGGTGGTATCGGTGGCT +TCGCTCTAGGTTATAATACACCTGACTACGAGAAGATTGCCCGTGAGAAATATAATAACG +AGGTAGTTAAAAATGCTATCTCGTCTTTGTGAGGAATACCAACGAAAGCCTAGTTCCGCG +CAAGGTAGCTTCAGACCCGCTTTGGGATTGGGTTGACTGAGTGCACCATATAAACGTGAT +TGCACTGGAGCGGCCGAAGTCCACCGACTGGAGCACCAACCCAGCACGGGAATTCCATCA +ACCGCTGTGACTATGGTTATAAATCATCCGGGGCGTGTAACCTAGAGGGGTTCCCATAAC +TCGATATGCGTCGTGTACAGAATGTAGAGAACATGACCACTGATGTGGACTCTATGGACG +TTGGGAACACTGTATTAACCCTCTCCAGTCTTGGGGATAAAAGACTCACAAGTGACTCCT +CTATAATCGGTTCCCAGGATTTCTCCAGCGCACAGCACAGGCTCTCGCGGCTTATCGAGA +TCAACAGACAGTTACTACAAGTTCATATAACGCCCAATATGGCGCTAATGATGTGGTGGG +TGCTTCTGCGGATGCTCTAAAGAATACATTAGCCTTTCAAACAGATCAGGCTATTGCACA +AACATGGTTTAACTATGAAACAGGTATTGATAACTACAACATTGGTGTTGAGGGTACAGT +GAACTCTGCATTAGCAGGCTTACGTCGAACCAAAGGTGATCAGCGTACTATGGACTTAGG +CGCACTCACTAAATCAGGTTTAGATATGTACAAGCAATACGGTGGTAGTTTCAATAACGC +AATGGGTAACTTGTGGGGTGGTGGTTCTACAACAACTCAAGGCGTGTCAGGTGGTGGCTT +AGGCGGTCTATCTGATTTTGGTTCGTTTGGTAAAGGTGGCTCAGCCAGTGGTTTAACTGG +TGGTAGTTCATTAGCTTAATATAGGAGTTTATACATGCCTACTATGGTTCAACAACCCGA +CTTAATTACACCCGGAGTATCTCGACTTCAAGCGATTGATCGTCCTGTAGAACGTAGTGG +GCTTAGCTCATTCCTAACAGATTTAGTGATACTGTAACTCAAATGGCTCGTGATGGTAAG +TTTGCCTTTTAGACGTAAAACACCGTTATAAGGCTATAATAAGAAGGCAGCGCTTCTGGT +CCCTCTCGAGAAGCTCTGGAGCGTCCCCCAGAGCGATTCAAGTCCTTCTGAGGAAATCTT +CGATGCATGTAAACAGTATCTCACTGGTTATACTAACGCTGTCCATGATAGTCAGCTACA +ATCAGATTTAAAAGAGGCGTTGTATAATGCAGGTCTCAAAGAGAACACTGCATATCAAAC +TCTTAGTTCCAAAACAATTAATGAAGTGGCTTTACAACGTGAACAGTTTGATTCTCAGAC +TCGTACTGCAAACACGTATAAGTTACTGACTGAGCAGAATCATACACCTGCACAGATTAC +GGAATTACTTGAGGCTCATGTACAGCAAGCATTTGCTGCTAAGATTGCTAGTAACGTGGG +TATTGACCCTAAAGAAGCTATGCAAGCTGCACAGTCTCTTGATTTGGAATGGACAGCTCT +CATCTTGAAGTACAGACTATGTTCAAGTATTGGGCAGGTCAGATCGACCCGTCTGGTCCT +GATGCTGCTGCATTCGTAAACACTTTGAATAACACATTAGATGTAGCTGAGAGGGCACCA +CTTTCGGACCACAAATTTATCGGGGAGCGCCTCGATTTTTCAACGAGCGTGAGCATTTTT +CCGGCGCGGGGAACGTCGACATATACCCAGAGTCCGTTATGAGATTCCCATGAGCGGGGG +TAATGTTTCCGCCGAGCTAACGAACGAGAGCGCTCCGGAGTTCAAGTACAGACAGTAGTG +CGTGGCACTCGTCATGAAACGAAATTCAAGGTGGTATCGTGAGTATGTCCACTGTTGTCG +ATTTACAAAGTAATGCTAATGGTATCCGTTCACAGACTCTTGAGAACAACGGTATCCAAT +TAGAGAACTCTATGAAAGAGGGTATGTGGAATATTCAACGTGGTAATGCAGAGTACAGTC +ACGACTTCGTACAATCACAGTTAACAGAGATTAACCGTAAAGAAGCCCAAGGTTTACTTA +CACCTGCTAAGGCTGCACAACTACGATATAACTTATTCTCCTTTGGGGAAACTCAATACA +ATAAGTTATTACAGGCTGAACTAGACCCTGCACAGCTAGTTAAGGGCGGTGTCTCTATGA +TGGAGTATGCTGCACTAGGTAAAGGTGGTGAGGATAGCTATAGTGGTCATATCAGTAATT +ACTATGATGGCATTAACAATGGTGACCCTGTTGCTGCGGGTTCTGCTAAGGTTGCCCACG +CTTTACGTGGTGACCCCAAGCTGCTAAACAACCACATTATCAGAATGCTGTTAAAGCGTA +TGATAGTCTGAAAGCTACTTACATGCAATTGAAAGCTCAAGGTTCTCCTTTGGCTGAGCA +ATTACTTGCAGGTGTACCTGAAGATTACCGAAAGCTACTTACATGCAATTGAAAGCTCAA +GGTTCTCCTTTGGCTGAGCAATTACTTGCAGGTGTACCTGAAGATTACCGTGGTACTGTT +ATGGAGATGTTCGCAGGTAATGCTAATATGAACGCTAGTGCTGAAGCTCTACGTAACCCT +GTTCAAACTAACCAACGTCAAAAGAACGTGTCTGAGGCTATTCAGGCTATGAACTGGGAT +AACGTAGGTGGTAACAAATGGTTTGGTCGTGGTGTAGGTGGTGGTTCACGTTTACTTAGT +GGTATCTCTGAGGATGTACGTGGTTCATATATGAAGAATATGGAGATGGTCTATTCAGAC +TCTAAACATGCTCTTGCTAATGGTTCTATATCTGCTAATCCCGAACTACTTGTAGCTAAT +GCTACGGCTTTAGGTATGCACGTTAAATTCGTCGTACTGTGGCTAAGTCTGCAAATAGTT +CTCCTGATAACGTGTTGATTCATACAGATCGTACAGGTCGCTATGTAATTGTCCAACCGT +TCGATAAGAATGGTAAGTTATTAAAGGATAAGCAAGGTGATGCATTCCAAGGTGAGGTTT +ATAATGAGAGCCAATTCGTTAACTTAATGAAGAAAGCTTATGATGCTGACCAGGCTAAAT +ACAAGAAGCACACTAGCACATTTGAAACTATCGGTACTGCATTCAGTAGTAAAGGTGTTA +GTGATACACTTGGTAGTACAGCTAACTACAAAGAGGATATGGCTAAGTGGCGTAAAGAGT +CTAAGTCGTACACATTGAACACAGCAGGCTCACTAGGTCAGACTGTTATCTCATTACCTA +ATGGTACTAAGACACAGGCTAAAATCCCTACGTTAGCATCTGTACCGTTTAATGGTAACG +TACAGCTAGCTACAGCATGGCAGGGTTTCCTCAATAACTATGAGGGGTTCAAACCTACTA +TAGGTGTTGTTAAAGGTACTGGTACAGAAAATGACGGTTTGATCATCGGTAACGGTGTTA +ACCTATATGCACATCCTAAATGGAAAGCACGTTTCCAAGCTGCACAGGGTAACCCACAAG +CTTTGCTTAATCTACAGGCTGAGTTCATGTCTAATAATATGAAAGATCAGCAGTTAGAGG +CTAAGCGTTTAGGTATCCCAGTAGCTACCAATAAACCGTACAATCCACAATTCATTTCAG +CACAGCTACTACTTGCGGATTACAAATGGCACAACGGTAACTATAATACCATCCGTGATA +TTATGTCAGCACCTACGTATAACCAAGCACTAGCTAAAATGCGTAAGTCGTCTGCATAGC +TACCAATAAACCGTACAATCCACAATTCATTTCAGCACAGCTACTACTTGCGGATTACAA +ATGGCACAACGGTAACTATAATACCATCCGTGATATTATGTCAGCACCTACGTATAACCA +AGCACTAGCTAAAATGCGTAAGTCGTCTGCATACACACACGCGGGTGATGGTCACCGTCG +TAACGTTGCGCGTCGTAACATGCTTCGTGATTACTACTTAGCAATGTTTAGCAGTGACGG +GTGAGGAACTCCAAGATGAGGTACTGCCTGAACAACCTGCATTATAGATTTTAGCTGCAC +ATCCGATTGCAGGTACTATTGCATCCGTAGTGGATGTTGATTTACCTTTAGCATATGCGG +TGGGGCCATTTGTTGTATGGATCGATGGGTGGCACAACTCTATGATCCGTTGATCCGTAC +AAGTATGTGACTTCCGAAGTCGCCCAAGTTAACTCCGTTCAAGACCGCTACCGGTCGCAC +CTGCTGTGGGGCAGATTGGAGGCGCTGCTAAGTTAGGTCGCTTGACTCAACGTGGTATGC +AAGCTGCTGCTCTAGGTGGTGGTGCTTACGGTCCTAACCAATTATTAGAAGATAGGTCTA +CACGTACTCAATCAGAACGTAACTTAGATAGTTTGATATTCGGTTTAGTGGGTTTATTCT +CATTAGCAGTACCTGATTGGGCTGTTCAGAACAAGGTTGTAGCTGCTCTACAGTCGTCGG +GAGACTACATGTGGTATCTAAAGATCATACAGTTGCCCAGTACCAAGTTACTGAACAATT +CGGTCAAGCAATGCAACGCTTAGATCAGGACATACTGTGGAAAATGAACTCAGGACAACC +TGTAGATAAGAAAATGATTCATCAAATGATTGATGAGTCTAATGTTGCAGATGAGATCAA +AGCTATTCAAAAGGCGTATGTAGATTCAGGCTTTGCTGAGACTGCATTGAGCCGAGCTAA +ACAAGCAGGGTAGCGTAAGTTCCAATTGACTGCTAAACAGTTAGGTCAGAACTTCTTTGG +GACTCAACAGAAACTAGCACTAAGTTTATCTGAAGTACAAACAGCAGGTCTTACCAAAGA +TCAGATGATTACGTTACTTCGTAAATCAGGTGTTGATGATGAGAACTTAAATAAGATCGC +TGATACTATCTATAAAGGTACTCAGGATGCAGGTACGGGTGTTGCTAAGCAATTCCGTAA +ACGTCTATCTTGGGACTGGAATATGAAGTTCGTAGGTAAAGATGGTGGTGAGTATAGCTT +AGGTGATCCTGTAGAGGGTAACGCCTACATGAACCTTGCTCAGTATGGTATTAAGACCAC +TGCTGACCTTGACAATATACTTCAAGGTATCATGAAAGATTTACCCGCAGACGTTGACAT +TGCAACCGCTAAGCGTTTCTTACAGAACGTCCGAGCGCAGGCTTTAGGTCATCCTATGGG +TGAGGCTGTTCCTGAGACTATCCGTTCATTGAACACTGTGGCAGGTGCTACATTCCTATC +TAATTCAGGTTTATATAACGTGGTAGATATGGCGACTCAGGTTGCTAAGATGGGATTAGT +ACGTACATTGCCTGAGATTATGAAAGGTCTGTAGAACATTGTGAATCCTATGAAGAAACT +ATCTAAAAATGAAGCTAACGATTTATATGATGTATTGACTGGTCTATTAAGTACCGATGG +TCGATGGAGAAACATCACGACTCGTTATGCTGATGACTTTGAGGTTACTACTGGTATTTC +ACTAAACGCCGATACCTACCAGGTAATAAGTAACATGAGTTAGACTTGGTCCCCCAGCAC +GACGTATAAAGCGGACGTGACCTGGGGAAATCCTCTGTTGGGAGCGAGAATGGCACGAGC +GGTTAGTAAGAACGTGGACAAGTCAACAATACGGAGTTACGACTCATGAGGCTACAGCTT +ATTACGGTCAGGCTACTCGATTCATGAACTTGTCTGAGTACGTTAAACGTATGCAGATTA +GTATGATCGGTGGTGTTGTCACTACTGCATTTAAGAGCTAAAGATATTAAGTACATGAAA +GAAACCTTGAAAATGTCTGATGAATTAACGGAGGCTGTAATGAAGGAACACAAAGCTCAT +GGTACTAATATTGATATGTGGTCGAATGATGTACGTATGGCTATGGTCCCCACTTCGCTA +AAAACTTAATCGGAGTCTTTTCTAGAACACGCGCATGTTCTTGCAACAGAAAGTGTTTTA +TGAGGCTGATAACTTAGCGCATACTATTCGTTCAGGTGAAATCCCTGCATTCATGGAACA +TAGTTCTGTGGGTAAGATCATCTTCCCGTTCATGTCCTTTGCTTTCGCTATGCAACAAAA +GGTACTTCGTAATACTTATCAACGTGATGGTGCTGCGGGTGTGGCTTTATTAGCTGCTGT +ACAGTTCCCAACTGCTGCATTGATTGGTATGGCTAAGAACATTAAGAATGGTAAAGAGCC +TGAAGAAGACTTGGCTAAGGCTTCGGTTAACGCTTTGAGTATGCTAGATACTTTCTCGTA +GCCGTTAGAGATCATCATGAATGGCGGTTTAAACAGTAACAGTGCTGCGTTAGCACCTGT +ATCTAATGCAATGACATTAGGGCAGAAAGCTATGTCAGGTGACCCTGATTTACGGTCAAT +TAAGAATGCTACACCTTTGGGTAGTTTAACAGGTTTGGATTTATTCATTTCAGCTATAGA +GGATTAATTATGTCGTTTAATGAGAAACTATCATATACGGAGCATGTGGTCGAGCCCCCA +ACTACAGACTTCGCAATTGGCTTCAAGGATTACGGGGAACAATCAGATACAATTAACGTA +CTTGTAAATGATGTAATAGCTACGGAGGCGGGTTACACCGTCTTCCGTAAGAATGCTCTA +GTCATTGCACTTGAACCTGCTGTCACATCAGGCATTGTACGTCTACAACGTGAAACTAAT +ATTAATAAGTCCTTTCATATCTTTAGTGCGGGTGCTAAGTTTGTCGGTGCTAATATGGAC +GCAAACTTTGAGCAGATTTTACACTCTCAACAAGAAACCCGTGATGGTTTTGATAAGCTG +TATTCCGATGTTATGCCATTGGTTAAAGGTCTTGAAGATGCTTTAGCACAGGCTGATGCA +GCGTCTCAAGAAACCCGTGATGGTTTTGATAAGCTGTATTCCGATGTTATGCCATTGGTT +AAAGGTCTTGAAGATGCTTTAGCACAGGCTGATGCAGCGTCTCAAGCTGCTAAGGAGGCT +GCTGAAGCTGCGGAGGAAGCTGCGTCCCAATCTCGAAGTGCTAGTAATGTTATTGATCGT +ACAGGTTTAACCCAACAAGATATTAACGATGTGTTAGGTGTTACTACCAAGCTACCCGCT +GTTTGGGGTCGCGGTACTATCCTGTCTATACTAGATCGCATTAATATCAAAGACTACGGT +GCTATCGGAGATGGTACTCTGCATACCTTACAGGAGTGGGTTACATCGGGACGTTTTAGT +AATCTATTAGCTATCCAAATGGTATTCCCAAATGCAACAGCTTTAACTGATAGTATTGAT +TGGTTAGTTACAGATTACTGCTTAGGTTTACGTAAGTGTATCTACGCACCGCGTGGTACT +TATGTATTTAACCGCCCTGCGCGTACACCTCACAGTGGTAGTCCTAACCGAGTGGATTCG +GGTTGCAGTTTAATCGGAGATGGTACACACACTGTATTCACACGTTCGAATAAACGTTTA +GCCACACGTATATTTAAGGTTGATGGTTCAGAGGATTATGAAGCCTATGATGATGTTAAC +CGTGACGAAGCTGTATTTAACGTACATGGCTGTTATCAGATTTTCCATAATTTCTGTATC +TCTAGGAGTACCATCGGTTTCTACTTAGGGCAATCAGCATCTAGTGCGGAGAACTCTGCG +GTTTATATGTCGCAGTGGTCTGAGCTTCAGTTTAAAGGTGTTGGTACGGGTATGTTGTTC +GCTGCTGCATACGGTAACCATTATAACCGTGTAAATAATATCCACTTTATTGAGTGTGGT +ATTGATGTGGAGATGCGTGGTGGTAAGTATGACAGTTCGCCCACTCAGGCTAATAACAAC +CGTAACACGTTCTCTTACGGTAACCATTATAACCGTGTAAATAATATCCACTTTATTGAG +TGTGGTATTGATGTGGAGATGCGTGGTGGTAAGTATGACAGTTCGCCCACTCAGGCTAAT +AACAACCGTAACACGTTCTCTAATATTCGATCTAACCGTCGTAAGGTTGGTCTGTGGTGT +AAGTCGGGAGATACTAACCGCTTTACAACGTGGGATGGTGAGGGTTGTGGTGCTACACCG +ACTAACAACACTTTTGGTGCTATTCTAGGGTTACCCATAGTTTAGTGAACCTAAACACAT +GGGCTTTCCCAACAGTTACCAGTTTAGGGTTTACTGTTAAGTCGTTAAGTTTCACCAACG +CTACAGGTGTTACACGTACTTCACGGGATAATTCATCATGTTATATTGATGAGCGATTAG +TAGATTTAGGCTCTGTGGTTGCTAGCGGTATCATTGAGTACATTTTATGGGCAGATTCAG +ATGCTAGCTCGACTGCTAATATTGAGGTAACTATCAGTGCTGATAGTGCAGCATCTAACT +TGGGCAAGTGCTAAGACGCTGACACGTTATAGTTTACATACAATGTACTCTTTACGTGCG +ACTGGTCAAGGTACAGGGGACTCGGGCGGTGTCTTCGGGATCTTATATTGGTCACGGATC +TTTTTACTGCTACCGTTGTTCATGGGGGTAGTTCGGGTTAGGTGAGCCCTTGTCACCTCT +CTCGCAACCGCATCTTAACATATCCTGTTATGAAATTGTGCGCCTCTGGAACACGCGGCG +CCCCAGGGCGTATGCTCGCATGGGAGTAAACCTCTCTAAAGGCGCCGCGTAGATACGATG +GTCTAGAACGCGACAGTCTAATATACCAGATAGTACGGCGGGTTGTTGATGAGCTACGAA +AGGGAGTATAGGCTCCTCCATGAACTGAGGGAGTATTGAATCGTGATTTGATACTACGTA +TTCAAGCACCTGCGTATGCTTTATCAAATGTGACTGCTACAGTACGTCGGCAGGTTACAG +GTTAATAGGAGATACTACGTATTCAAGCACCTGCGTATGCTTTATCAAATGTGACTGCTA +CAGTACGTCGGCAGGTTACAGGTTAATAGGAGGAATAATATGAACATTGTAGATCAGGTC +TACATGGCACTGATCTACATTTGGTCAGAGCTAGATAAAATGGTAGTCGGTATGGGTTTA +TAAATTGGGAGATAGTAAAGATGATTCTAACTCGGAATAGTTTTGACTACTTACGCAGTA +TCTACGGTAAATTAAGTCAGTCTCAGGTGTCTTATCAGTTTCAACATATACAGTAGCCAA +ACCGTAGGCAGCTTCAGGATAGGTAAAACCCGCTTGCTTCATTTTTGAAACAAGGAAGTT +TAAACCATCAATTCCAACCTATCGCAGAGCGGGGTTCGGATAAATACTTATGTAAACTAG +CAGTACGTTTGGGTAATACACCTGAAGCCGATGGTGATGGTCAACTGTATAAAGGGCGTG +GTTATGTTCAGATCACTGGTCGAGCTAACTATAAGTTCTTCAGTACGATTACTGGTAAAG +ACTTAATTAAGAATCCTGACTTAGCACTAGATGCTGAGGTGTCTACTAAGATCATGACAC +ATGGTATGCTTAATGGTTCATTCACTGGTGTAGGTTTCCGTCGTAAGCGTCCTGTGAGTC +GTTATAACTTAGCGCAATACATTGCTGCTCGTAACATCATCAATGGTACAGATCGTGCTG +CTGAGATCGCACAAGCAGTTACAGGCTATGCGGGATGGTGATGACATACCTCAAGGTATT +ATCCGTAAGGCTATCCAACATGCACGTATGCGTAAGGCTAATGGATTACCATACTTCGCA +ACCGAGGATCCCTGATGAGGATGCTGAACCGCAATACGACGAGGAAACTGGTGATGAGAT +TCCTACACTCTTTATTCCTTTGGCTGCATCTGAGCTTCAGGTATTCGTATCGTTCTTGGA +TAAGAACAACATCACAGCTACACCTGACGTAGAACACATGGCTGAACAGGCTAATGAGTT +CACTGAAGACTTACGTTTAGCTCGTGAACAGAAAGCTAAATCAATTGTTAAGGTCAATGA +AAACGATGCAGCACTTGCTGCGTACCTAAGTTAAGGAGTTCAATATGTCGTGTATCCAAC +AGCAAACGCCAAGCTATTCCTTTAGAGGAACGTGAGGAAATATCAATGATGTTCGCTGCC +ACATTCAAGAACTTTAAAGAGTTCGCTGAGTTGGGTATGCGATACCTTGGCTTTAAGCTA +TCTATGATTCAAGAAGACATTGCAGAGTTCATGCTGCTTCTCACCACCTGACACAATAAG +TGTACGGGCAGTCGGGTTTATGATAAGAAGCCAAATACAGTACAAAGCAGCTAGGGTCGA +TTTAGCTTGACCACGCTGAGCTTGAATCATACGCTTAGCTTGCCCATGCTGGCATCTGAT +GTTGCATTGCTTATTATCCGAATTATTAATAACTGGTCTATCCTCTGTTGGTTACGCCCT +GATGCGTCCAAAGGTGATAGAACTTCGGCTAGTGCGTTCGACGTACACTACAGCCTAAAA +GGTATTGATGAGTCTGCGCCTGTATCTTGTGTTGGTATTACAGCTAACTTACAGGGTATG +CGTGCAGACTTTATTCTAGCCGATGATATTGAGACTCAACGTAACACTCTGTGTATCGCT +CTCTCCCTGCTCGTGGTTACGACGTTCGTGTTTGGTGTGGTCGTTACCCTACCGATGAAG +AACTCGAACGCTATGGAGCAGGTGTGACGATCGCACCTATGATTCATCGTGCATTAATCG +AAAACCCTGACTTACAAGTAGGTGGTGGTGTAACTGGTCAACGTGGTAAGCCTACTGACC +CTGCACATATCAATGAGGAAATCTTACAAGAGAAAGAACTTGAGTCAAACCTCGTACACG +ACCCTGCAAATTCGTCGGGCTCCACGCCCTCAGTTGTCAGGGTCGTCCTACATGCCTCAG +GCACTAACTGCTGACACAGGGAGAAGGGCCCTTTGAATTAGGTTGCGTACCCTGAGTCAG +CCGAAAACAAATTGCGATATGATCTCAATGAAACGATTGTGAGTTGTGTCACTAAGGGGA +CGTTATGGGCTAGGTTAGGTTGTTGTGTTTATGGGACAACGAGGTGGCTGCCCTATGGTG +ATGAGGGTTTCTCATTACAGTACATGCTCGATACAACGCTCTCAGATGCCCTCAGAACGC +AATAGGGACCGATTTGACCCATGTAGTGATTCTTACCTCAGCCGCTTGGGAAGCGGGGCA +AGGATAAGAGTCTCGCACCACATGCGGATATTGGATGTCGTGCTATTAAGGACAGATGCA +CGTCGACAGCGCTGATACCGACGTCTGAAGATTAAACTTTCTGATATGATTGTACTAGGC +GTAGGTAAAGACGAAGTGCCTGAGTCACTACAGTACGTCGCAGACCCTAATAAGTTATTC +AAGGAAAATACTGAAGCTACGATGTATTCGTACCATTTCTACATAAGGTGATGACACTTG +ACCCTGCGGGTTCAGGTGGTGATGAATTGTCTTATGCTATTGGTGGTGCTACTACATCGT +ATATCTATTTACTTTCAGTAGGTGGGTTCGCAGGTGGTATGACTGAAAAGAATATGAACT +CCGTGTTGCAGAAGCTGATTGAGCATAACGTTAAGTTACTCGACATTGAGAAGAACATGG +GTCATGGCACTGTTGCTATGTTATTCCTAGCACAGTTAGATAAGCTGAAGCTTCACGCTT +TAACTTCAAACCCTGCAATTGATGAGTTTAAGAATCAGCTAGGTATGAGTTACAAAGAAG +TACACACTGCCCTTAGTGGTATTGGTATCACCGAGTATTATGTGGTAGGTCAAAAGGAAC +GTCGAATCATTGATACGATCTCACCTTTGACTCGTCGCCATAAACTTGTAGTATCTACTC +AAGCTATTCAAGACGATTGGAATCATTGCTTACAACATCCATCTGAGAAGCGTATGCAAT +TCTCTGCTTTCTATCAATTAGGGAACATTACGTATGATCGCAATAGTTTAGTCCATGATG +ACCGAGCTGCCTGTGTACAACGTGTGGTGGAAGTTCTAAAGGCGTTTCTAGCTAAAGATG +AAGAAAAGGCTGCTGTATTGCGTCAGGAGGCTGCTCATCAAGAGTTCTTGCGTAACCCTA +TGGGGTATAATCCTAGCGTTGATAGTTTCTAACTTCTTAGTAACTGCTTCTTTATCGATC +ATCGTTTGAACCTCCCATGATAACGCTTACGAGACCCTTTAGAGTTATCCCAACCATCGT +GGGTAAAGATGCACAATCTATCCTAGCATTACTAAAAGCACTAAAGGAGAAATCAAATGT +CAAGTATTAAAGTTATTGCCGCGACGGTATAGAAGTGCTGGTCACTGAAGACTGATACCC +ATGAATGTCAAGGAGGGGAATAATACCGAGTCTGTTCACGGATCAGGCATGAATCGTGCA +TCGTGTGAAAGCTTCAACCTGGGAGATTTTGCTAATGTAGATGTACCTAAGTTAGCGAGC +GGTGTGTTGTACACTAGCGGTTGTTCCCCCTAGTTTTCAGACCTTTTACTAAAGCGTACG +AGAATAACTCTAAGGCTCTAAGCGTCGCTAAGGCGGTTAGTAGCACTAAGGTATACAAAG +GTAAGGATAAGGTTGAGAAAGCCCTAGATCGAGCTACTGTGGCTCTTGATGTAGGTGTAA +GTATCTATCGTCTGTTCAAGCGTTAA diff --git a/example/fna/NC_025457.alt2.fna b/example/fna/NC_025457.alt2.fna new file mode 100644 index 0000000..ae2e098 --- /dev/null +++ b/example/fna/NC_025457.alt2.fna @@ -0,0 +1,1071 @@ +>NC_025457.alt2 length=64164 tani=75.921 alt=sn;de;ins;du;inv;tl +GATTGAGATTTGGTTGGTAGGGATTGGAGTATCTGATTGGTGAATATACTGTCAAAAGCT +AAATTTGTCTAGTATTTCTGAGATGGTGTCTTCCACTGCCTCGCCCTCGACTTCCCCAGA +GCACTCATACGCAACCGTTTAGTCAGCGCGATCCACTCGCACAGAAGAACTATTTATATA +AATGTCGCTGGGTTTCCATCCAAACCATAGTGGAGTTTGAAGGCCTCAAGTATTCCGAGG +CTGCCGCAGCATATGCAAACCCCGGTCAAGTGTGATATCATGTCTTCCATCTTATGGATA +GGAATATTTGAGTGCTTTTACCTGATCTTATACTGAGTCTTTGAGTCTGCGACACTTATC +ATTCATTGATCCTCCTTGGTATGTCGCTCATTGTATAGACAGTTTGATATAGTGTCAACA +TACTTATTCAACGATGTATCTATTCATTGATACGATTCTTATATCCTTGTATGGATTATA +GTGTTCGCCTTTTATCTCATAACACTTATGCCTTTTTATGTGTTCATGGGTCTTTGCCCG +GAGTTAATGCGACGAGAAAATTGAATAAGCTATCCCGCTCTAGATATATAGATAGTTTTG +TTGATAGCGATGTAGATAGCTATAAGATAGTCATTAGTTAAAGATACTTATAAATATAGA +TAGTATTCATTTTATCTATTTCTACTGTTTGGTCTTCTCTTTATTCTTTATTCTTATATG +GCTACCTTCTCATTTTCCTTAATAAATACAATAACTTAGCTGCTTAGAAAAACGAATAAA +TTGATACTTGATTAACAATAGATAACATGAGCATAAGTATAGAAATCAATAACTTAATAG +AACTACCGTAAAGCTATGGAATAATTGTAAGATTTTATAAGTAAAGTGTTGGCATAGTTT +TTAAACTGTATATTATGCCAACCATACCAAGCAACCTACGCAAGCTACTATATAGAGATT +AACTACTAGATCTTAATTAACCTAATTAGATTGATTGCTTAGGTTGAACCAAGCGAGAGA +GATTGAAGACTCGACGTCGAATCACGTCCAAAGCATAGCAGAACTATCACCTAAACTTGT +AACAGGCAAGAGGGCCAAGGACCAGGAAATGTATAGGAGAGAGATAACAAGCCTCCGGGT +AGACGCTCCATACGGTCTTCGTAAGCTGTGCCGCGGTATAGACAGCCTTCGATCAATCGA +CCCAGATAATGAATAATTATCTAAAAATAAACAGCCCTCTTTCTCTTTCCTAAAGCATTT +TAAGCCCTATGTACTAAAAATGCCGCTATCGCGAGCCGCCGAGTTAGGTTACCTCTGCTA +GGTGGCAATCCCTCAGGACCGTTATACTACGAAAATATAGGAATCAAGCTAACTAAGATT +GGCACGTTTAAGCTGCCTGGCAAACTCTTTATCAGGTTCAGTCCGGGGATTGGTTGATAA +CTTAAATCAATAGGTTTAAAGCTCACATTATCAAGGCATTGGGCTAGAGTTAGTTTACGT +TAGTTGACTGATACCAAGCGAAAAAATAACTTAAACTAAAGTGTTGACAACATAATCAGA +TATGATAAAGATTCCGACCATAGTGAGTTATCCAAACAGTAGTTGAGATGTGAGGCTTTA +ATCAGTTGAGTATCACGACTCTGAAGGGCTACTCCCTACCATGTAGACGAAACATGGGCA +TACAGTAACAGATTACTAGTTAAATCCTTATAGGTGAAGTCGAACATGTGGTAGAGTGTA +GTCTTCGGAACAGCCTCGTTGGTGACAGAGCCAGCCCGCTTATAGAGGGTTGCCTATTTG +CTGAGTGAGTGCGTACATGGTTCCCAGGGTGTTTGCCGGTCACTGCTTGATAGAGCCGTA +AAAAAACGTGGGTGATAAAGATCAGTGGCTTGTCACAGTCAAGCGACCTAGCAACCCTGC +ACCTACAGACTATATCACAATTCTTTAGTATGTGTGCAATGTAGTAGGTAATAGGATAAG +CAATTGAGGTTGAAGTGTTATAGGTAGGCTGTGAGGCTGTACTCACAGTTAATTCCAATA +CATAACACGTAAAGCTATGATAAGGTTAATGAGTTTATATTTGAGGTTGAAGTGTTATAG +GTAGGCTGTGAGGCTGTACTCACAGTTAATTCCAATACATAACACGTAAAGCTATGATAA +GGTTAATGAGTTTATATTTAGCTAAGTTGGGTTGAATGCTACGCACATCGACCTAGCACT +GATATAATCTTGAAGTCTGACACAAAGGTAAGTTGTGTTGTGCACTACAGTTGGTATTAG +CAACGACGCACGCGATGATGACCGCACTCGTAAGGTATTTCCTAGCTAACGGATAATCTG +ATACCGAATGAGGTGATACTTGGCGTCAATGTTCAACCAACGAACTAACATACGTGTATT +ATGGAACTTTTATTGACTACAACTGAAAGCAACAAAGCACTCGAATCTATCAAACGTCGT +GGTAAACGATTCGGATTCATAAGGCTCCGTTGTCTATAGGTACCCCAACGATTATTTCCG +GGCTCTACCTTAAGTATACAAATCGATCACGGGGGTGTGCCAGTAGAGCGCCTACTAGAA +CGGCGCGGTTTGATACTGATATCCATGTGGCAGGTGTGTCAGTCTTTAAGCATGTCGCTA +AACATGGCGACACAATTTTGCTTCATATGCTCGTAGGTGCTATGCCTAAAGGTAGCCGTA +ATTCTGCGTTCTGTGAATGGGCTTTGGCTTATTAGGGATTGCGACCCAGTGAGATTAAGA +CCTAAAATGCTGACGCCAGTGGGTGGGCCATTAAAGGTAATGTCCGTATGCCTGACCGTG +CTAACAACGCTGATGAATCTGCTATCGAACCAGGTCTCTTGTTCGCTAAGGATAAGTCTA +AAGGGTTTAATGAGGTTGAAGCTCTTGCTTACAAGTTGTGTGACTTCAAGCCTGAGGCTG +TTTTGTTGATTACCTTTGATGCTGCTGCTATGGTTGCATCCAGGATAAAGCGTTGTAGGG +AGTACATGAAGACATACGCCTTGCGACGATCCGTGATCGTTGACCGTTAGCTGGTGCGAA +CGTTGGTTACCATCGTACCAAATGGTCTAATTTTTATCCCGGGTCACCAGGGTCTCGAAC +ATGGGCTCTCCCTGGGTATCTGAAGCACAACAGCAGGGTACTGAAGTAACTGGACATGGT +AATGCACTTAAACAATTCCCTGCCTTGATGGAACAACATTAAACTCAAAATAAAGGACTT +TAATCTGTAGGGGTATTCCATGATTACTATAACTGTGAATTACTGCGTTAAGCATGATGT +GAAAGGTCTTATGGAATATGCACCGTGTCGTGTCACTGGTCGCTCCAGGAACGCAGTACC +ACACTCATCCTACTTTGTCAAGGATGGCATGGCATATACTGAATTGAAGCGTTCTTCTAT +ACTCACAACTGCTATTGCAGTAGCTATCTGTGTAAGTTCATGGATAGTATCATTGTTATA +TATCTTTCTAAAAAAATAGGTGAAGTATGTTACACGAACCTATAACAAATCCGATTATAA +CTGTAACTTTAAACGTCGGCTTAGCTCCGTCGTTGAAGTGGTGTAGATACAAAGCTCAAG +CGGCTAACTTGCTACCTCAGGACAGTACAGACGCTTGTAGATGTAATCGATGCACCTCAT +CCTAGCGATCGGATCGTTAAAGATGTACGTGATCTTGCGTATAACCCTAACGGTCAGGCG +TTCTATCAGCAATGTCAGCCGTATGGTATTGATTACGGACACGATAACCGTGAAGTAAAG +TACAAGGTGGTACAGTCGGGAACTGAAGCGACGTTGGTTGTACAATTTGAGGCTACAGCC +CGTGACATCATTGGTCCGGTGTTTGCACTCGCTGGGAAATATAAAAAAGACTGTGTCTCT +GTATGGATCCACAACGATGTAAACGGTGGTATCGGTCAATTAAGTGGACGTTATAAGTGT +ATGTGGTCAGGTGGTCACTTCAATACCGAATCCTTCATTCACTTGGAGCGTTAAATCCCT +TACATCGTTCCTGTAATTATTATATTCCAAGTGGGTTTCAGGCTTGGGTTCCACTGTGCG +AAATTCCTTTAATAAGTCAGAAATAATAGGCTTGGTTAATCTATCGTTAAAAATACTGAC +CCTAACAACTTAAAAGCACGTGTAGCTCATCTTGGAACCGTTGTCGATGGCGCATTGGTG +CATGAGAAAGTAAACAACGTGTGTTGGATGCCCATTTGAAAAGTGCGGAGTCTCAAGCCG +GATCCTCCTAATATGGCAGGCCGAGCCAATAACTCCAAACCTCCCATATAATCGATCACG +CGAGCTGCGGCCGTACTGCCGACAGGAATTCTCGCTTACATGAGTCGTTCGATGTAGAAG +ACATCCGGGTCCAATTGCAAACCGCCACTAGTCCTTTGTAACAAACGCTTCTTGTGTTCG +GACACAGAAGTTTAGTCCAAGGAATGTCTCTTGTAAAACGGCGACTTAATGCGTGATGAC +GTGTCTGTATTCCAGAAGCACAACAGTAATCAACCGCAATACTTACATGTTGCAACCTCG +TGGGTGTGGAGGTAAAGCCATTGGGCTTTTAGGTAGGTGCAGACGTAACGTAATTAAAGT +TCTACCTAGAGTCAGTGCGTAAAGCTAAGGCTGATGTTGAGCGTAATAAACAAGAGTTGT +ATGAACATTTAACACGTAAAACAATCAATGTGCGGTTAGCACCACCTAGTGAAACGGCGG +TATTTGTTCGTAATCTAAGAAGTACGGTCCTTTAGGACTATTGAAAGGGCATAAGATTAC +TCTGAGTGCGATGCACTTTGCCCGTATTGTAAGTCTGATGACTTGGAGGAATTATAATGG +CTAAATCCGAATTAGCTCGAAGTGTCCGTAAAATTCGTAACTTAAAGGGTACGGCGTACC +GTGTACCTGTAGTAAATAAACTACACTGTGAAGCATTATTAAAAGCTTTTAAAGTAGCCC +GTAGTAAATTAGATCGTAGCAAATATTGGCTTACTTGGCGAAGTGATAAAGAGTTTATCT +TAGTACATAACTCGTCTGTAGACAATGTTAGTGTATATAATCAGAATGGAAGTGCTTCGG +CCTGTCACTCGTCGCATTGCAGCCACTATCCGGGCGGAAAAGGGCATTTACTTATGTTTA +CTCCCACTCCTTAAATTCGTTCCCTCTAAATAAATACAGCCAAAAATCACCGGTACGGAG +TATACTTAGAGGCCCAAGTCAGTATTTAGACCGGAGGGCGGTATTATACCTTGACGTTCG +ATCCTCGTGCAATCACACAACAGGTAAAAAACGTACGTTCCCGTGAGTGAAGCTGTAACC +GGTTTAACAAAGCTTCCATTGTACACTACGGCATACTTTTCTAATGGTGCTGTAGCATCG +CTGTGTGACCAGGAGGCCAGTAAAGAGGAATATCCCTTATCAAACCATACCAACCAATAA +TCGGTAGCCTAATACCTTGCCCTAACTGTAAGAAAGTTCATACCTCTTGTTGTTGACTTT +GGTAGTATGTTTGTAGCTACATTCAAAGGGATGTAGTCGTTAGGCATGTAGCTTATGTTG +TGAATGTGTACTCGCAGTTATATTTCGCATTTAATTAAGGTAGATGACTTATGAAAGTGT +CACATCCATCTTTGAATACATATACAACTCTTAACGTTGATAGCCCTTGGTCCCGTAAAT +CTACGAAGTTCCGAGTACCACCGGAATTTAGCATTACTAAATTATTGCCAACGAACGAGT +ATATTAAGACAGTGGCTAGAATGGATCGAATTACGGAACCGAACACTATCTCGATCTCAA +TAGTCCCTATTTGTAACAACACTGCGTGAAACCAAATATCTTTGGGTGCTACGCTTACTT +CCGCTAGTAGTTGCGGTTCTTAAAGGTTTTACACCCTATACTATTGGTTTGGGTTACTAC +TGGGACGTAGATGAAGTAGCTATGGAATACCTTGGTTCAGGTTGTTTCTCAAGTGTCTTC +AAACATCCTAATCGTACTGATCGAGCTATCAAATTATTCCGTAACTACCGTGAAGATAGT +ACCTGTTATCAGTACCTACGTTTGTGTGCAAACAAGACTATTGATTACGAATGGATGAAG +TAGCTATGGAATACCTTGGTTCAGGTTGTTTCTCAAGTGTCTTCAAACATCCTAATCGTA +CTGATCGAGCTATCAAATTATTCCGTAACTACCGTGAAGATAGTACCTGTTATCAGTACC +TACGTTTGTGTGCAAACAAGACTATTGATTACGAATGGTGCCCTACTGTGCATAGTTTAG +TGTGTATCAAGGTGATCAGCTCTAACTCCAAGCAAGGTTATCGGGAAACCCGTGATTTTG +CCTACGCTGAAGTGTACTTACTACCTTACAACTGTAATGATAGTGCTGTTTATATGGACG +ATTGGTATGCTGAGTTCCGTGATGACGTTAAGGATGTATACTTCCCGTTTGGCGATATGG +ATTTGAAACCCGATAATGTTCTAGGTAAGGTCAACGATGAGGGTATATGTCAATACTTTA +TCACTGACCCAATATGGAACTCTGGCTGTTTATATGGACGATTGGTATGCTGAGTTCCGT +GATGACGTTAAGGATGTATACTTCCCGTTTGGCGATATGGATTTGAAACCCGATAATGTT +CTAGGTAAGGTCAACGATGAGGGTATATGTCAATACTTTATCACTGACCCAATATGGAAC +TCTGAGCCTGAACACTACGAACCAATCCCTGAAGCATTAGAGGAATTGTCTGTGTATCCT +ACAACGAACTGGTAAGGGACTTCCCACATGTGGGGTTTATGGATCGTAGAGTATAGACGT +GATGGCCGGGTAGTACGTAATCCTTCTTCCGCCTCAAGATAGCGATCCGCCCGGTGAGCT +TAACCGATATTACGTCGAGCGTGTGATCATCTCATCTGATCCGACATCGTTGTCCCTGGT +GGCCCGGCTGTAAAGGGTTATTTTAACGCTAACGCATCGAATGGTACTTTCATAAACAAC +CTATGGGAGAGTATTAAACACGGTCGTGTATGGTAATATTATAAAAAGTAGTGCTACCGT +TCTACGGTCTAATGTCCCCACACCGTGGGTGCGCCCTGCTAGAACCGAATGGTGATGATG +GCACCGCGGTGTACGAGGTAACAAATGGGGCTTGAAGTAGCAGCTTTAGTAGGTACTGGC +TAGGCATCAATTTCCAGGTTAGACGGCCGCCTGTGATTTGGTAGCTTCTAGGAACCTCCG +TACACGCCGATAGTATCTGCCGTGGTATGAGCGCTATGTTTGTGCATGGCTTACGTTCTG +TGCATGACTTAGGTGACGCTGTGTACTTTGAGTCTGATGCTAGCTCTAGATATCGACAGC +GTAGAGATTTGTCAACTATGTCAACTTTACAGTTAATTGCACCTTACTCTCAAATTAAAC +GACCTACTAGCAAAGATACTCGCATGACTCATGATGAAGTCAAATCTATCATTGCTGTAT +GGGTTAATCCTATTTCCTCAACTGTGCAATCATAAGGACATTAGTATGTCTGACTGTATC +CCTATTGGTCCCTTACCACTTAACATGGGTAATGTAACTATCGGTGTTACCCGCCACCAA +TTATTATTTTTCATGCAGTACAGTGCATATCAACCTAAGTTCTAAGGCTTAAATATAGCA +GCACCTCGATGAGGTGCTGTTGGTATTTCATCACGGGACGTAAGGAGTTTTATTAGGATT +AAACCTAAACACCTATTCGAAGTAGCAGGTATCGTAGGTAGCCCTGAACGTAAAGGTTGG +AACTTCAAAGCCCCGAATTCTTGCGAATGTTGTCGCTCTGATAACTGAAAACCTCGTATC +GGCTTCGGGTATAAACATAAGGTAGGGCAGGTCGCTCCTGCTATTGCATTCGGTTTAGAA +CAACAGTTAACTTCCTGTCAACTTCATAACATGCACAACCCACCACCTGACGTTTAGGTG +TGCTTCGAAAGTGCGGAGAGCTGCCATCGCACTCCATTAACGAGCCTACCAATGGTGTAC +ACCAAGCTCGCCAGTGAGTTTGAACAGAACAGTGGTATTATACACGCACGAGCTAATGAC +GGAGCTACATTGGAGTTTTCCGAACTAGTGCCTAGCAACGAATACGCGCACTAAGTCCGT +GCTATCTTAATGTTCGCTAATCCCCAGCTCAGGTTCAGTAGTACCTGTATATGTTGGTAA +GCCTCAAGGTAATGGTGCTAAGTTGTTCCCTGGTGCGAACACATGACTCGCGATGAGGCT +ATCTATGAGTTTAAATGGTACTGCTGTGTTACAGGTAAACAGTATCTCACTGGTTATACT +AACGCTGTCCATGATAGTCAGCTACAATCAGATTTAAAAGAGGTGTTGTATAATGCAGGT +CTCAAAGAGAACACTGCATATCAAACTCTTATTTCCAAAACAATTAATGAAGTGGCTTTA +CAACGTGAACAGTTTGATTCTCAGACTCGTACTGCAAACCACTGGTTAGGCGCAATGCGT +GTACTAGACGAGCTATCAGGGCAACATAGTGGGGTTATTGCAAACGATGGTACTTACATT +TACACCTCTGTTGGTGTACTACTTATCTTGGTTCAGGATTGCGCTAGGTCTCCTAAAGCT +ATCCTTCGATGACGCGTATATCTCGTGCTATCCGCTATCCTAACACTCTATCTCGTGCAG +AACAGGTGGTGCTATCGTCTTACTACTGTCGTAGGAAAAAGGTCTTGTCGCAGTGCTCTG +GGTATGTTTAAAGTAGGTCCATAACGTGCTAAGCCACGCTGTCTTCACCGGCTGAGTAAT +GCCGCCCTAGGCGTCCCAAAATCGTCCCTACCGCCCTTTAACATCACTAACGTCTCCAGC +TAACAACTACAAAGGAAGTCCACGTGTCCGGAAAACAAAACAAATCTGCTATGTCTAGTA +TGGGTATGAGAGTCATCGTGACCAAGCCCACACAGGCGGATATGAAAGAGGGTATCAAAA +GCGAAATGATTGGTCATGTTGAGCAAGTCACAGCCTCGTTCATTCATGCAGCGTTTGACT +CTAGTAATGCGCGACGTTACGATTACCCTTTCTTACCACATCAAATCCGTCCATTCTAAG +GGGAATTACTTGCAAGAACTATACGCTTTTATTAACACACATTCACCTCAACAAATCCGT +GCTATAGGTGATGAAGCTCAACGTTTAGAGTATACACCATCCTATAAACCTAACCACAAA +TATGTAGAGGCTGTATTATCCCAGAGTGATGGTCGTTTGTTCCCAGAGGTGTATCATACT +GAAAAACACTTTGAATAGTCCTGGGGCGCAGGACGTACAAGGACTTTAATGATCTTCTGG +GGACTTGCCCGTACCTGGCCGTACGACCGAGAACGGAACCTAGTGATTTGGTCAGCCGTT +GTTGTCGCAACATCAAGCAGACTCGTCAAAACCGCCGTGATTTATGTGGTGAGACCTCCT +CACAGTATAGTTAAGCTGTTCTCGATGTTGTAAATAAGAGATATGTACTTAAGACCCTTA +ACGTACAGCCGTACAAATGGATTAAACCTACAGCTTATAATCCAATTATTAATTGGTTCG +CTGAGAAGTTTATCAGTGCTTATGCTGTAGTGCGTAAGGTAGCTGTTGCATTCATTAACC +ACATGCCGTACAAATGGATTAAACCTACAGCTTATAATCCAATTATTAATTGGTTCGCTG +AGAAGTTTATCAGTGCTTATGCTGTAGTGCGTAAGGTAGCTGTTGCATTCATTAACCACA +TCAAATAAGGAGCAGTGCCGTGGATAAGCGTAAAGAAATCGTTAAGGGAGTGACTCCTTA +AGCAGAACGCAAAATCGTGCAGTTAAAACGTCGTGAAGCTAATACGGAAGGTCAGCAAGA +TCGTTGCTCTAAGCGTCGGAATAAGCGTATGCAGTTCTATTAATGGGTAGGTCTTACGAG +ATCACGATAAAGTCCATACAGCATTACCGTCGCTGTGTGGATAGCTTGAAAGAGGTAGGT +GTACAATTCTGCTCTAATGATGAAGATGAGTTGAAGATGCTACGCTGTAAAGATTACCGA +CGTAAGGCGTGGTTGTATATAGGAAGCAACAAGGTTGCATGGGTATTCGGAGCATACAGC +GTGGTTAACCATACAGCATTACCGTCGCTGTGTGGATAGCTTGAAAGAGGTAGGTGTACA +ATTCTGCTCTAATGATGAAGATGAGTTGAAGATGCTACGCTGTAAAGATTACCGACGTAA +GGCGTGGTTGTATATAGGAAGCAACAAGGTTGCATGGGTATTCGGAGCATACAGCGTGGT +TAAGTATGCTAAGACGGTTCAGCGTAAGGAAGCACTGGAGTTAATTGGAGATGCTCTATA +CCGAGTGGTTAAACCTAGCCAAGAAATTTCCGGTAGGTCAGAAGCCCGGACATTATCATG +CGGACGAGTTAACTTAGGCACTAGATGTATGGAACAATGAGAACTCATGGAATGCTTACT +GACATCTGTGTCATACCCCAGCCAAGGTACGTAAGCAGTTTGTCGAACGTGTAGATGTAA +CCGAAACAATAAACGGGCGTTATCGTGATAAGCATTGTCTGATTACTTTGTAGCAGTTAC +ATGATAAACGCTTGTTCAAATTTATGACGTTGGTCAAGCTGCAATGTCTAGCTATGCACT +CCAGGTTTAACTCTTCCTTGACGGAGTTACAAGAGCATGATACTTGGAGCAAAGTCTCCT +TCTATTGGGTGTACCTGAGTTCCACCAAGATCGCTACTCGATTGACTTACATGATAAGGG +TATGACTACAGTCACAAAGCACCAAACCATAATGCTCTAACGATGTATGCATCACTGACT +TCAGCTCACCCGTATGTTCATGTAAGTTTGCCATACAGGCACGGACTATCAGTTATCTAA +GTCCAATGTATAATAAAAAGGATGATAGTCTACTGTTCCGCTTTAAAGGTGTTGATATTG +GTAGAGACTGTACAGGGTTGTCACCTGCTAAATGGCTGATTCATGATAACACTGATCGGG +AGGGTTTCGTGTATTTGAAGGGTAAAAATCCACACTGTACACTAGAACCTGCAATATTAA +CTGAAGATTTATTCTTTGCACAGAGGGTCAAATACTGTACTAGCTACTCGACTATGTGCC +TATTAGGAACTAAATTTACACATGAAACCGTACAGTTCTTACTCGAACGACTAGCCCTTA +GTGCCACCGACCGAGATTTCGCAGGGTGGAAAGCACGTCGGTTTATTAATAGTCGTTCTC +AGCTTTTTGGTATCCCTTGCCCTAGTGCATATATTCCCAACGGATTAGACCCAAAGGATA +CGTCACCTGATGCATGAAATGAAACATCCCAATTCTTGGAGAATTAATATGCGTTCTGTA +TTCGTACTACCTAAAACACATGCGGAACTTAATCAGGGTATCCCTACTTCGATGATTATG +AGTTAACCGAAGGTGTCGTTCAACAAACTTCAGTGATGCTACTGGAGACAAATGTAGGCA +GCTTGGTAAACGCGTAACTGTTTGGTTAAATACAAAGACTTACTATCTACATATCTATCT +TGTATTTCTACACGCACAAGTAACACCACATCAATTAGCAGGTCTACTCCAGGGGATATC +AAGATGTCAGCCTTAAATCTACTCTGATGTAGGATGGAGCGTAAGTCTTATCAATCGTCA +TATGCGTCCATCCCACCACAAATGTATGATTTAACTGCTCGTCCATTCCCTACTTGGGTC +AAACTGTATTACTAGCATTATGAAGAGCATGAGCGTGTTGATGTAGACACCTTGAGTAGC +TTCATTCGTTTCAAAGGTAATTAATCCCAGAAACAACCAAGGCTGACTGACCGATTACTC +AAGCAGCTACGTGAGCCATTGCATGATGCGGCCCGTGCCACAACATTAAACGCTTTGGAA +GAACGTCGTCTACCAGGTTATGCTGAGATGTTAGACAAGCGTTATCATAATGGTGAGGAA +ATTGACATCAACCATGAGAGGCGTAAGCTCGTACAAGCCTGTGCAGCTTGGAAACGTGCT +TTCCATTTAGGATGTGCATATAGGTTAACACCGTTACCGATGATCAAACCGTCATTGTCT +GTACCAGTACCTTTAACAACACCTATAGTAGGTTTGAACCCCTCATAGTTATTGAGGAAA +CCCTGCCATGCTGTAGCTAGCTGTACGTTACCATTAAACGGTACAGATGCTAACGTAGGG +ATTTTAGCCTGTGTCTTAGTACCATTAGGTAATGAGATAACAGTCTCGGAAGTCGCATTA +GATGAACAACATGCATCATGGTGTGATACCGACGTAGGTGAGCTTATCGACGCTGATGTT +GATGACTCAGGATATGTGTTGGACTTCTTACCTGAAGGACTTTATATCTGTATCAAGGGT +ATCAATGAGGGTAATAACTTAGGCATGGCAGCCCCTAGAGATAAAGGTAAAACTTCGTTC +TTAGTGAACCTTGCTGCATCGTTTGCTATTGAACGACGTAACTTTACGAAGCAATGGACG +ATTGATCTTGAAGACCCTGAGAAGCGGTCAGAGCGATTGCAAGAGAGGATTCGCTTTAGA +CCTATATTATTCCCTGTGAACGCGGATACGGCTGAAGTAATCACACCACGTGTATATCAG +ACAGGATTGAAAGTAACCCGTTAGCAAATGTATGGACGTCGTAAGGCGGGTCCAATCACT +ACAGAGTTGAACAAGGAGAGCGCGGACTACATTGGTGCTGTAGGTCGTCGTGATGCTATT +CGAGTGAAGAACACCCACGGTAAGTCTGTAGCGCAGGTAGCTAAGATCATTGAGGCACAT +GATCCGTTCTTAGTCATTACTGATATGTCTGAACGTATACGTGCAACTGGTGGCGGTGCT +GGAGCTAACTATCTTACACTGCTTGATGAAGTCGCGTAGCGGTAAAAGCATTCAGCTGTA +ATTCAATCAGCGCAAATCGCAGTAGGGGCGCGACGGTACGCGCCTACTGGTGCCGTTGCT +ATAACGAAAATTCTAGGAAGTCCTCTGGAGTGAGCGGTAATTACCTTGGATTTATATGCA +TAGGCATGCTGCCATGATGGACTTCATGCATGTAGGTGCAGCACAGATCAGTACCGAGAG +TTTTGATAGCCTGTACCTACCAGTGTCAGCATTACAGAACAGTAAGTCAGGTATTCAAAC +CAAAGAACGGGCCAAATCTGGTTTCCCTCTAACAAGCTCTAATTATGTTAACAGCCTATT +TACCAAAGATGGGAGGCGCGTGGGCTAACACGGGCACTAGACAGTGGCTATGGACGTGTG +ACTATGCGCGTGCAATGGATTTAGCATTGTGGGTCGGTACTTATGGTAACCCTGTACCGG +TTAATGGATTGAGGCGTGGATGAGGTACACCTAAAAACAAATTAGCATTATCAAAGAACT +ATTGGCACATTTTAGGTCCGATTAAAACTCAGACTAAGATTCAAAGAGAGGTTGTAAAGG +TGGTAGCCAAATTATGACAATCTTCGGACCTGGACCCTGCTTCAATGGCTCTAAATTTCA +ACCTCGCTTGTGGTACACTATAAATACTGCGGAACTACTGGGTTCAAAAGGCGTGATTCT +TAGGGCTCATAATAGGCCCGACAGCCGGGTGTTATCGGAAGATGCTGCCCCACAAATAAC +TGGGATCCGGTGACTAACTCATGAAAACAGGTGCGGCGTACATTACCCCTTCTCCCGTCA +TGATGTAAAATATATTAATAGCTTTGGGATTTGGACGCTATGTGAGGCGCGGGTTAGCTA +TCCCCTTCTAGACCTTTGCGCGGTCCCGCTCCACAAACTCCCTGTGCAAATTTTTCATCG +ACCTGTTGGTTCTTCACTAGCTTCCAACGAAAGATGCACTATACAAGAACGAACTACATT +ATACGTGCAAGCAATAGTACACAGGGTTAATTTTGGTGGCTTGTAATGGCTGGCCAAGTA +TATCGTGCCCTGGGTGTACGTAATGCAGTAATCCAGGTCCAAGATAACCACGGTTACAGT +AACTGGTGCAAGATGCTCTAGGCTTGAACCTGCAAAGTTCAGAGCGGATAAGCATTTCTC +TTGGATGAAGTTTTTAGACTTCTTACCAGTTACTTTACCATCAGCATCCTTAACTTCATA +CTCACCTTTAATTTCAATACTATCCCACATAGCTTGATACTGTTCGCTAGTAACCGATGG +TGGTTTATTCCATAAGAAAAGATCGTTTCGTTACACTTAAAGAGGGCAATCAGACTCGCA +TCTCTGTGGTCTTAGATGCGGAAATTGATAGCAATGCTCTATTGGATAGACTAGTCGAGG +CCGAGGTGGAGCGCCTTTCATCCATAATGCGGACGCGTCGCTGCTAATAGCCGGGGCCTA +AACTCGTAAGCGGTCTAGGGCAGTGCTGACCACTCTTAGCATTAAAATTCGGGAAGAAGC +GGTGATCGGAGTCAATGCGTATTAACTATCTCTAAATCGTGCATAGGGCTAACGGGCGAA +TCTGAGATAGATTTTGTCTGGGCTTATGGTTATCGAACGATACGCATCTCCGAAGGAAGG +TAGGTATATGGCGGGTACAGTAACTAAATCTGACGTCAAAATAGACGATACAGTATTACG +GATCAGTGGTCCTGGGTTACGAGTAGGTGCAGATTTCGCAGTCGTTGGTGCGCGTCCTGA +TGGTGCTGCTGTAAGTTTACACGATCAAGCTACTGGCTGGCTCTGCGTGAGTACAATCTC +TATTGTAGAGTGTATCAAGACTCAACCTATCGTACTCACAAATGATCAAGTGTTTAAGTA +CTTAGCTGACGATGTCGACCTTGAATACTTTTTCGATGATGTTTGGCACAAGATCGATAA +CCAGAAAAGTGTTAATATCCGATCCAATCAAATTTCATAGTTCCGTAAGAAGCGTGAGTT +AATGGAACTTAATGGTATTGAATTTCCTAAAGCTAGTATCCGTGCGGTTCCCTTTGATGA +GATATGTATCGGTTACGGGGTATCTTTTAACAATCTTCAATCCGTGTTCACTCTCCGTGT +GGTTTTCGAGTGCCCGCGCGTATCCCTATCGCCTGCCTCCCGAAAGGAGTTCATCTGCGA +AAAGGAAGAATACGAGAGGTGTACAACGCACCCCTTAAACAATTGGGACTCTGTGGTATT +ATGTATTGGACTGACCCTCAGGAAGCTCAAGAAGTATCGGAACCATTACTCAAACCATTT +GGTAAGTCTGCTAAACCTTTGAAATCAGACCTATAGGGGTCCTAACATACCTCAGACTGC +ACACAGATACCCCTTGACGGCGGTAGCGTCCATCTCATCGCACCCCTCCCCGGAAAAATG +GGATCTATTTAGGGAACGCGGAATCGCACGTAATGTGCACCGGAAAAGGAAAAGGTGATT +TGCGCCTGAATTCTACTGTTCGTATGTATCCCTTCATAGGACGTAGCATTTATCGCTAAT +TACATGGCTTATTGCAAGAACCCTGTACATCTTGTCCTATGTAGTCCATACCGGGCCAGT +TTTGGCATGCCTTTAGCACCGTTGGTCGCTTGACTTCACTCTCGTAGCCGACAGCATCCA +CTTGACGATTTACACGGTGAAGAAGATGTATGAAACATTTTCATGAAGTTAGTGGAAAGA +ACATCAAATCCCCACTGATCGGACAGGTTAATTATGGCGGAATTTATTGTTTACTTGTCT +ACATTGGCTCTGAACCTCAGTCGTTCAGTCGTGTGGGCAAACATCTCTACAGGGAGAACC +TCAATGGTTTTATGGGTGGACAGCTTTGCAATCTTGCTGACGGTGTGCATATTGGGGGAT +TGTGTACTGATGAGTTATCTTTAGAGATGCTTAGTGGTTATCTATCACCTCACCGTCAGA +AACAGTATTGACGGTGCCATGCTGATACCCCAGACTGATGGTGGTAGGGTGTCGAATTAG +ATGGAGTTGTCTCTCGCGCTACGACACCGAGTTAGCTGCCGTGAGAGGTATCATGTCTAG +GGGATCTCAGCTATGCTCCAAGTAGAGGGCAGTTTACGAGACACCCCACGGAAAGGAACC +GGGAGGCACTCGACTTAGGTTCGTCCAAGTTTATATGGAGACAGAAGGTGGCGGGAAAAC +CTTAACGTGGGATGACGTAGGGACGCATAAGATTGGTGAAATACACCCGGAACCGAATTA +TGATCCGGACGTGCTTAGGATGCTTAGTAATATGGACGCAGCAGGGCTGGAATCGACGGT +ATCGTATGCAAAGAGCTACTCAGTGGTATGTTCAACCCCAAGGTTACATAGCATTCCGTG +ATTACTTAAAGGTCGGTGGGCTGTTAGACGGTCTCACGAGCGGTACGCGGGTGAGCGTAA +GTACGCTACTCGTCAGACCGAACGATCAAACGCTGGCCCTCCTTTCAGTAACACATTGGT +GTAGGTCAGCCGCGGAAGAATATCCCAGATCTCGCAAGGTGTGCAGTCACGTAGACCTTT +ATCTAAGACTTGGGTTTCGAGGTTAGTGTGGGGACTGGGCGACGCAACGGCGATACATCA +TATCGAATCCGATACTCAAACTTAGAAAACGGTTTGCAGAAAGCAGCTATCGATAGGTAT +ACGGTGACGCCTAAACTGATCTATGACCGGGAACAGGCTGATCCTTACGCTGAACACTTT +ATTAAACGTGGGTATGCGGGCGCTGTCTTTAAAGACCCTAATGGAATGGCGGTCATGATG +TAGCCTGGAAGCTCCCCAGTTGACAATTAGTTGGACTGGTGCAACAAAGTACCGCCAGTT +GAAAGGATCTACGAATAAAGTCGCGTGTAGCTTTATTTTTATAGCAGCTTGGGAATCAGG +TAATCAAGGTTATCGTACAATGAAGATGGTAGGTGGTATCCGTCCTCGTGATCTTCCATG +CGTGGGTGTTGTCTATGGTAAGGATGAACGAGCAGGGCAAACTGCTGCACTACGCTTCAC +CATGAAAGGTCATGGGTGCAATGCTGGTCTCGGTAAGGTTTGCAGACCGTCATACCGGCA +GTCTGACAATCAGACTTCCACCCGTTTAACCAGTCGGAGTTGGCGGCCAAGGGCCCGGTC +CCACCTCGTCTGGTATCGTCCCAGAAATCATGCTTCGGCGGGCTCGATAGTCCGTGAGTC +AGACCGTATCAGTCGGGGCGCTCACGTGGCAAGAGACTCTTCCTCGAGTGACTTCCGGTT +TACAAAAGCAGTTCACTGCTGCTGGTCAGTCGGCCCGCGCCGCCTAATACGACGAAACCA +TAATGATGAATGTTCTAGAAGATGAACGTCGTGATCTACTAACACTCGCTTAGCACGAGG +ATCGTGGTGAGTGTTGGGATTGAAAGGGGTATAGCGATACACTTAGCGAAGAAATGCGTA +ACCCTGTAGGAAAGATTTGGGAACTGAAAGCATTGCAGTATAGCGCAACTGGTAAGGCAT +TACGTCTACGAAAGATGGTACAAGTACGTGAAGATAGGGGGGCTTCTGATGTTTAATGTG +GATGCTGTTGGTAATGAGGTAAAACACGGGCACGTATAGCACAACAGGCACGTAGATTTG +GGCACACAATCCCACAATGTCGACAGTTGCATAGATAGGGCTATGAACCTCTCAATCGCG +TTTCGAAAGTCATGTTACAGACGACCAGGTGCAAGGGGAGAGTGGTCTCAACCAGGTCGC +AGTTTGACGAAGTCGATTTCATCTCTTTGATCCGTAACGAGGGTGATCCTTTGGTTTGTG +TGGTGGATGAGCGTTGTGGTTAAACACGGAATATACTTGGAGCGGGTAGCTTTCTTCAAC +TTAGCAGACGTACTCCGACGATAGATATAGGTTAGCATGATTACATCATACGTCCTAGTG +TTTAGGTCCATAATGTCACGTTCAAACTAACCAACGTCAAAAGAACGTGTCTGAGGCTAT +TCAGGCTATGAACTGGGATAACGTAGGTGGTAACAAATGGTTTGGTCGTGGTGTAGGTGG +TGGTTCACGTTTACTTAGTGGGTCCATAATGTACAGTTATGCAACTAACAGTCTGATAAC +AACGTGCTTAAGTTTTTATAAGTATATGACTTCAAACACGAGTATTAATCGAGGTTAGAC +GACGTTACCGATTGTAGAATGGCCTGCAAATGCTACCCGAATCTCCCTGGCCAGCTACTT +GAATCATAGTTGGAAAACGTGGTTGTGCGTCGACTTACTTTGTTTCGGCCGAGTGAAAGC +CCAGAGGACCCAAAACCGCACCGGGAAATGCTTTAGGGTCGGTAGTTGACAACCATACTG +AGATTTAGATTAGGCCCGCCCACGAGCTTGAAGATAGACGTTTCAGATAGGTAGATTCCA +CACAAAGAAACTGTATGTTTAAACATAATTTCATTATCCATGACTAAGACAACCAAAACC +GTTCTTGGTATGGTCCAATGGGATGACCACATTGACCTGCTAACTATATTGTTGCTACTG +GACATTCTAATGTTGGGGGTGACAAACAAGGACATCACTTTGATAGCGCTGAAGAAGCTC +AGTCACATAAATGGATTGCCAAGTTACAAGGTTGTAAGATGTATGTAGCACATAACACTA +CGTTTGAAACCCAATGGACGTTACGAACTTATCCAATTCAATTTTCAGATAGGATTAAGA +TAGATGGTATGGTATTGTGTGCACAATATGCAGACTATATGTTAACCCATCATCTAGAAA +TGTATCCTAAGCTTGAGGACTGTGCTGTTAAGCATGGTTGTTCTTAGAAGATTGCTCACG +TTAAATTACTTTGGAAACAAGGTGTCTCAACTGCAGACATTGACAAAGCTTGGACGCACA +TGCATAGCCATTATGGACTGCACTTGGTCTGCTTCCATCGTAAATCAATGGATTCCTACG +TTTTTCCTCTATGCCGGCCAATGATCAACACTTAATGGATTACCTGTAACAGTCATGCCA +CGCATGTTGTTGTTTGACAAGCCGTCAACCTCCTCATGAAATACGTAACAGTCTCTAAAC +TTGGTGACGTAGCGAATGCTTGTCGTGTATGCTTCAGGCAAGGTACTAAGCGAAAGTAAG +CTGTGCCCCTATTAGGGATGTGAAGAAAGACTGCGATCAATTTGGTGATAAGTTTCTACC +TGTCATTGACGATTAATTTATTCTTTTAAAGTATGAGCTTGTGTATGGTCAGCCTTTACG +CATTCTACGCGGTAAGAACGCAGGGAAGTTCAAGATATTTATAGTAGAGACTGTGGTAGC +TGAGGAATTTCTGAAGTGGGGTGATAGACGAAACCGCTTCAAATGTTTGCTTGATTTCAA +TACACTACCTAAGATTGTGTCTGAAGCTTATGTAGGTAAGCGTGCTGAGTTGCGCGGGAT +GCATTCCCAGACATTCCAAAGTGAGTGGAATTGAAGTAAGACCATAACATTCCTACGCCT +ATCATCGACAAGGTGTTGCCGGTGTTGCGTGGACACCTGAAGCTGTAGTAATTGGTAGTT +CGGACAAGAGGTAATGCGAGACCGTGGACTCCAGAGCCTTAATGTACCCGGCAAACACAG +CGCCATCGATATTAGGTGAGAATAGTCACAAGTTCGGTACTCGAGTCTGGTAACGAGAGC +TGGTAGATGGTGCGCCAGTCTACGGTACAGGTAAGGTTAGTCTCGCTGTACTTACAGCTC +ACACGGATGTTGCAAAGCCATTGAAGAACTTAGCTGCACTTATCAAAGACACCACTACTT +ATTACCTTGTCGTTGATGACAAAGGTAAAGAGTCGGGTATGCTTCAATTCGTAGAGCCTA +ACGGTATCATTCATCATCAACTTAACAACTGTGCAACTATTACAGGTCGCTTGTCAGGTA +GTAAGCCTAACATGCAGAATATTCCTCGTGATGGTACATCAGCTGCACTTATCAAAGACA +CCACTACTTATTACCTTGTCGTTGATGACAAAGGTAAAGAGTCGGGTATGCTTCAATTCG +TAGAGCCTAACGGTATCATTCATCATCAACTTAACAACTGTGCAACTATTACAGGTCGCT +TGTCAGGTAGTAAGCCTAACATGCAGAATATTCCTCGTGATGGTACATCTAAAGTTAAAG +AGATGTTTAGCTCATGGTGCATATGCGGATTGTCAATCCTAAGCATAATCGTGGGTAGAC +TTACCTGACAAAAAAGCAACTCGCATTCCGCTTGACACCGCACCGTGTCTTTGGTGTTAA +TGGACGTATCGTTGAGGTCGATTATTCTGCTCTTGAAGTTGTAGCCCTAGCCAGTATCTC +AGGTGATAAGAACTTGATGCGGATGCTGATTGAGGGTATCGACATGCACTGTTATCGTCT +AGCTGCAAAGCTTGGTGAAGACTATGAAAGTGTATTCGAGAAATGCCACAACAAAGAACA +CCCTGAGCATAAGCAATACAAGCAATGGCGTACAGATATTAAACCTCGTGCCTTTGCTCA +CCAATATTGTGAATCTACTGAGGGTATTATCGTTATCCCGGCAAGAGAATTACGCAATGA +TAGCGGGAGCGAGCTGTCGACCGGCCGTTTGCCAGCCGATCCGCTCATGCGGAGCTCTAC +GCATTTAGTACAGGTGGTACCATAGAGGATGCACAGGAGCTCAAGAACGTTGAATTTGCA +CTGTTCCCTGAATCTAACGTATTCCCTGTTAAGTCTGTACGACCAACGGCAGAGGAAACA +GAAAATGCTCCACAACCCATTCGTGAGGTTGATAAAGAAAGTGGTCGTTATGATGTGTAT +CCTCATACGCTTCTTGCCTCACTGGCGTCCGTTAAGGGGTGACAAGATAATGTAGTTCCG +CCTGACCGGTGAGCACAGTTCAATCATGGACTACTCGTGGTTACTAGCTTCGCGATGGTA +GCAGGGGGCTTTAGTCGGGGTTACTTTCAAGCGATGTCAGGTACTTGCTGCTCATCCCGT +CAATATGATATACGGGATAACGAGCTTCTTATTACCCTCCAAGACTACAAAGACACACCT +GAGAAAACATGCACGTGGGATCACTACCTGATATCAAGGGATCAGGACGTACAGATTGCC +AACTATTGGTGTCAAGGTGAGGCATCCTTTATAGTTCAAGCTGCTCGTGGGCGAATCAGC +CGTGAACTCATTAAACGAGATTTCGCAGATGGATTCGTCGTACCGAACAATACCGTACAC +GATGCAATCCACTTGGATTGTTCAACGGAAGCACTTGCGAAAGAATACGGGGCGTTTGTA +AGGGATATTATCGAGGTTACTCCTAAATAACTAGCGGAAGTTACCCTTCCAATAGCAGTT +AGCCCGCAGCATTTAAAGAGTGGAACCATCGCTTAACACCATTCCCTGCCGCTGCTGCAT +ATGGGGTTAACAAGCCGGTCCTCCGGTAGTTATCAGATAAGACCTAAGACGCCTGTGGAG +GCATTGATGCGCTACTTTACTCCCCGGGATATAACCTGTGCACCAATGTTCGCATTGTAA +CTCACGTCCTCTTATAATGCACCAAGAGCATATTTAATGGATATTGCATCCATTGTGCCA +CAGGGTATATTTCAAGGCAAAGACCAGGAGATTATACAAAAGTGTGGATGTGGGTGGCTG +AGAACTTCCCATGTGAATAATGGCGGCGCAGAGAAGCAGGTCGGCCGTCGGGTGACTGCC +CGTTACCTGCTATCAGTAACTTAGAGTTCTGTAAATTCACTTACATGTGTGCTCGTGACC +CTCTGGCATTTGAGGGTACATTACAAGGACCTGAGAACTTGCAGGATATAGTTATCCCAC +TGTCAGCATTGATGCTGGATAGGGTAGACATGAATGACTACATTTATGTCACAGATAGTC +ATAAACACCTACAACCTAACACACGCGGTAACCGAGCGGGTTGGTATGTGGATGGTTTCT +TAAGTGATGATCAATCACTTATTTGATTCGACACGCGTAAGTGACTCCATCGAGATCCAG +TAGCGATTCTAAGTCGGAGGCTTGATTTTCACCTATCCAATTTTATAAAAAATGTCGGCG +GAAATTACGATCCTGGATCTGGAACCGGCCGGCAGCCGGCTGCGGGACGGTAAACTCTAA +TGCAACGCAGTTACCGAGGCATCGCCAACCTCGCCGTCTCGATAAGTTGCCTACTCCAAA +TGCGTTGGGTGGCTTTGAGGTTTGCCCTGATCATGAACATTCATTAGAGCAGTTTGAAGT +CCAACTAGCTTCCGGGAATTTACAGTACACTGAACCTACTATCTTGTGCGAATTAAAAGA +TTGTGTACATCGACCAGTCTTCAACCACACTAATGACGTACGGTTACGCACCTCTGTTAT +GATCGTAATTAGTAAAGGACGTTTCAATGGTACAGGTGATCCTTGGAACTACCTCCTACC +ACACATCAAACCTACTAAACAACATGGTGAGCCTCGTGACCATACTGTGGTTAAACCTGC +ACTCACACCTCAAATCTTAAATTTAGATCGGAGATTATGTCATGACTCTATCAGCTATCA +ACTTCTTAGATACGTCCCACACCTTGCACACGGTATCGACGTAACCACTTTTGACGACAT +GACTGACGCTTCATCGGTTGGCGGTGCTAAACGTGGTTTATTACCCGTAGCTGAAGATCT +TGTACTATTCAATTCATACATTGAGTATGGTAACCATCCACAAACTTTGAGACCGGGTAG +CCGAATCAGTAGTCCTATCTGGGGGTAAAGCTGAAGACCCGCTACCTGAGTTCCGCTTAG +TCTTCCACGTTGTAGGTGGCGTAGGTACTAACAAAGAGGGTGAGCTTGAAGATTATGTGC +AAGATGGTTTCTGCCCTACAATCAACGCATTCGATTGTAAGTTGAGTACGAATGAGAAAG +CCCGTGCTGTTGCGTACTTCAATGCGATTAACATTGCACCTAAAGGTACACACTTCATTC +AGAAGTTAGGTACATTATACACAGTGGAAATTAAGATCGGTAAGAATAAGAAGACTGGTA +AAGATCAGAACGAAATTGACTCCCGTAACTTACAACCCGCAGTGGATGCCGCAACACGTA +AAGCATATACCAGATCCTGTAATGTTGCTGATGAAGTAGTCCCCATGGGGGTAGTTAAAC +CTAAGGATGTTAAAGTCGTTATTATCGGGAGGTGTTATGCCACTTCCTGACGCTGATGAA +GCTGAGGCTGCTGATACACAAGCTAAACAGGAAGCTGTTAAGGCTGAGGTTGTTGAAGAA +CCTGAATCTGAAAATGAAGTTGCATTGGATGTTCCTGACCTCTAATGTGACCGAGTGAAC +CCTACGGGGTTCATTCAGCTGAGGCTGCTGATACACAAGCTAAACAGGAAGCTGTTAAGG +CTGAGGTTGTTGAAGAACCTGAATCTGAAAATGAAGTTGCATTGGATGTTCCTGACCTCT +AATGTGACCGAGTGAACCCTACGGGGTTCATTCACACAAGCGATTATTTGTCAGGCGGGA +TAAGCGATTATTTCAAACCACTGACCTCCATCACAGCAAGTTTACCCCCCGTCTGTTGGA +ACCATGATCGTAGATCACGGCGCGTGTCTTCCTAATTTCTGCCCTTCAGCAATTATATCG +GCAGTCTTCATGGTGATCGATACACAATCGCCGCTAGTAAGAAATAGGACGTAACACCAG +GTGCGGGAGTCCTAGTTAAGTGGAAAATTAGACAATTCGCTGAAATCTCTGAATGGATCA +TAGGAGACTTATATGACTGATACTAAACGTGCTACTAGGCGAACTATCCGTATGATAGTC +AAGGTTGGAGAGTTTCTAGCTACTAACGATTGGTTAGCGGGGAATAATGTACGTGCCAAC +TTAGTAGCCAGTCGGTTTACTAACATTGCACCTACAGCTTGATAATCATATTCGATAGCA +CGGTTTTGTTGTTGTCGAAAAACTCTGATGAGACGGCTACCATTATCAGTCACTGCCAAT +CGTAGGGTTGAATGCGTAACATGGTTAATAGTGTGATCTCGTCGAATATGTCTACCCGTG +TTACCGTTAACTTCTACAGTACCTGGTCGTCATCGGGTATAGGATACTAACGATTTAGAG +TGGGCAATGAGTAGGACGCTCAAAAGCTCATCCTGCGGCAACAGGGCATGATTAGAACTA +GGGCCAATGGACTATCTTGCCTAAACATCCTAAGTATGTATTCGATCGCCACTGTTTTTA +CGCCTTCGCACGTCGCTCGATACATATATGTGGCCGAAGATCTGTGCAGCGAGTTGGGGT +TAACAAGTAGAAAGATGAACAGCTTCAATAGGCGTTTATGACAAGGACCTACGGGCTAAA +GCTATACTGGAATATGAAGAACAGGAGTAAACAAGGCCCGTGAGTTCTTGCCTCCCCGAT +AATCAACAGTCAGCCATGACGCGGTTGGAGAATGGAAAGGTCCGTCCCTCTTCAATCAGC +CTCAGAGGATACGAGTCTGGTGACCCGTATGAATATGACGCTTGATATTAGTCAGTTTCG +TGTAGATGCTAAAGCGTTATAGTCTCAGGATACAGACGAAGCCTCAACGTCTGGTCGTGG +TCTATCACTTGATGCTGAGGGGTATGCTTACGAAGCTGCTGCGGGTAAGGCGAAACCTGA +TACCGCCTTACGTCATTTTGAACGTAGTATTTATGAAACTATGTTCATAGTAGGTTGTGA +GAAAACACGAGTATATTTAACCCCCCGTGGAGGCTTCAAGAATGGTCGTCACTTTCTGTT +CGGTTTTTAGCCATATCAACTACAACGCGCGCACACATTTCGCCGCCCGTACGGTTGGAG +ACGTAGGCTAGAAACATTTTATCGACGAAAATATCTGGGACTAATTTTATCCTATGTCGC +AGTAACAATGAAAAGTCACTACTGGTCGCTGTGTTGCGATCTGAACGTGCAATAGACTGG +TGCGCTAACAATGGTGATATGGAGATCATCCTGAACAATCAGATTGAAGCCGACGATGCT +TTGATGATCGACCATTACCGCATGACTACTGGGATCGTATTGAGTGCGGATTAGGAATTA +AACTTAAGTCCTTAAAAGTCATGCAGCATGGATGATGGTAAACCATGAGCCAAAGAGGTG +ATAAGACGTGGGCGTAACATCCCGCGTTGTGTGCAGGCGATGCATGGCCTGATTAGAAAT +GCTGTTATATAGTGCGACCGGGTGGTGATATGTTTGGTTGGATTAATCGTAAGAAGTGGT +TAACACCAAATCTTAAACCAATCGATTGGATTCTTTGGCCCACCTTGCCATAGTAAGTAT +AGTCCAACACAACAAAATGTCCTCTGTTAAGATCCGCTCCTCTCCTAGCCGGCGATGGAG +AAGGTCCATGCATTTAAAATGATCGGTAAAGGCACTCAGTTCGTCTTAACACAAATGGTC +AAACGACCGGCTCGTAAACGCAGAGTTGATAATAAGCCGTTGGCACTGTGGCAGGGCCTC +TGTCCTATGCTATACTCCTATGTTCTGGAGCCTCATGCCGACTCATAGCTAGGCGTACTA +TTTGCATACGAGGTCTAACGGTTCTGTATTGACGCTGTAGCCTACAAGGATGTGTGATAC +TGCTGATCACGTTAAAGGTATTATACAGATCAATGATAAAGTGTGCGGTGAGGCAGGTGC +TTACGAAGCCCTAGATCCTCTCAAGGATATACATGAAGTTGTGAAATTCGTGATTGAAGC +TTCCAAGAAGATTGATGAAAATATTATTCCTGAAGCTGAAGCTATGTGGTTATTGCGTAA +TTCACAAGATAACTCATTAAAATTCTTTATGGAACATGACCTAACTAATAGTAACTTAAA +TTTCTTAAACGAATGCTACCATGACCGTAAATGGAAAATGGAAGCTGATGATTATGAGGG +TGACCTAAATGAAATATAATATTCCTGAAGCTGTACAGCACGTTATTGATCAACTTAAAT +TGGTTGGTATTGAAGCTACGTTGGTAGGTGGTGCGTTACGTGCTGCTTAGTAACTTAAAT +TTCTTAAACGAATGCTACCATGACCGTAAATGGAAAATGGAAGCTGATGATTATGAGGGT +GACCTAAATGAAATATAATATTCCTGAAGCTGTACAGCACGTTATTGATCAACTTAAATT +GGTTGGTATTGAAGCTACGTTGGTAGGTGGTGCGTTACGTGCTGCTGCTCTTAGTGGTAC +ATCCAATGATTATGATTGAGTTATAGTTGGTGAACGTGAGGACTTCTGCCACAATTGAGA +AGGTGCCTCCTAATCCCCATTAAAACCTTTCCGTGTCCCACGATTACGAAATCTCAGAGA +TAACATCGCGTTGATACGGAGCTTTTTTTGGACTCTTATCTGATAAGGTGCTCGAGCACT +AACGTTTCGGTAACCAATACAATGACAAATATTATAACAACGAGAGTTATGTAGCAGATT +TGCGTAAAGCTGATGTGAGTATCATCATGTTTGATGCGTGCGAAGTAGCTGACTGGTATA +CTTTGATTAAAGTGTATGATTTAAATATCAACGAATGGTAAATCAACGAAGCCGCTGAGC +TTGCGACTGATTACTATGACCCTGAAACTAAGCTTGTAACTATTAGCCCATTCCGTGGTG +GTCTAGGTAATGCTGAACGCCTTACCCAACGCATTGAACTCTTCCGTACTATGCTTCCCG +ATCTCGATTGGTCAGAAATTGCGCAGCGGCGTAAGGTCAACGATTGCCTTGGCACGGGGA +TCGTAAGTTAAGACTAAACCTTTACAACGTATCCCACTTAATCAGTCACTAGTTATCACA +ATGTCCATCCTAGCCAATTGATTTTTAACAAACTGTAGGGTATAGAATGATGGCGTTTTT +CCAGATAAAAACCATGGCGGACCAGCCGGCTTCGAGTTTTCTCCTTAGCGAAAGAAAAAA +TAAGGCTGAAAGGATGCAGTAACCTGAATGGTCTCGTGGGTAACTACAGAGGATGGTGCA +GTCGGACCTTAGCGCCGAGTTACTAAACAAGGCAGTAAATGTCCTATCTGCTGACGTATA +ATTAACACTAAGGATGCAGGTCGATCTTGCCCCACGTAGTATCGGGCCACGTGGTCTAGC +TGAAGCGGTCTCGACACTCGACAGGACAGCTGCAGTGCTGGTCGGGTTCCCCGGCGATTG +TCCGTAAGATCGTCGTGTGCGAGGCGCACCTGCCAATCGGCATGGTACAGACTGCGTAGC +CGATCACGTTCATAAGACAGGTGGGATGCGTGGTGTACCTCATCGTTCGTGTAAAGTTGC +TGAGGGTAAGGTGGCCAATGCAGCAGAGTCGTGGGGTGCTAAGTCTATGGCGTATGAGGA +TATTGTCCCATTCGTTGAGGGTTTAGTTACATACTGGAAGAACGCTGAGAAGTATGGTAC +TGGTATGATGTACCCTGAGCACAAAACTGATGAGCAAAAGAAAGCTGCTGCGTCATTGAA +ACGTCTGCTAAGTCTATGGCGTATGAGGATATTGTCCCATTCGTTGAGGGTTTAGTTACA +TACTGGAAGAACGCTGAGAAGTATGGTACTGGTATGATGTACCCTGAGCACAAAACTGAT +GAGCAAAAGAAAGCTGCTGCGTCATTGAAACGTCGTAAAGCTTACGCTGCAAACAAAGCT +AAACAAAAGATAAAAGATAATGCATGCAAACGATAAGCTTACATGTGCCTATGTAGGGAA +GTACCAAGGCACATATCTTACAACATTTAAAACTTATACAGCCCTCAGTACCATGCACGA +TCATGGACGGGACTATGTAAATCTAGTTGATGATTCAGGTGCAGAACGCACATATACCGC +TAACCGACTAGTAGTAAAGGAGAACTCTCAATCTCAGAAACCCACGTTAATAAACCGAGA +CGCAGGCGCCCTACATGGCGTACTCCCTATCGATCGGCACTGGTAGACCTCGTGCGCAAA +GGGGTAACCTATCCGCTAAGATTACTGCAAATAATAAAAAGCGGACTGTACGGAGAGGGC +CAGAATAGACTCTGTAAGCGTGGACACAAAGTGCACTACGTCTACCCATGCAAGGTATGA +CTCCTCCTGATATCTCTCGTGAATTTAATTATGAAGTCTCGGATCGTACTAGCGGAGAGA +ACAGTCAGAAACTTGCACCTGAATTTGAGCGTAGTGTTGCACTTGCAGATCGTAAACCAA +TTATTTTCGTAATTGGTGATACACATTGTAAGCAAGGTATTGACCCCGATTCTATGCATT +GGATTGGGTCTTATATCGTATACAAGAAACGTGGCCTGATTATGCTTATCGGTGATCACC +ATGGTATGGCTTCATTATCAAGTTATGATAAGGGTCAGTTAAAGGCTGAGGGTCGTCGTG +TTGTAGAAGATATTGAGGCGGGTGATAAAGGTATCGAGATCATCGAATCTTATATTGCTA +AGGTCAAAGGTTATAAACCACGTAAGGTTGCGACGTTAGGTAATCATGAGCATCGTATTG +ATTCATTATCAAGTTATGATAAGGGTCAGTTAAAGGCTGAGGGTCGTCGTGTTGTAGAAG +ATATTGAGGCGGGTGATAAAGGTATCGAGATCATCGAATCTTATATTGCTAAGGTCAAAG +GTTATAAACCACGTAAGGTTGCGACGTTAGGTAATCATGAGCATCGTATTGATCGTTACA +TTAATGACAATTCTGAGCTTGAGGGTTTCATGGGTACAGATCAATTAGCCTTTGCTAAAC +ACGATTGGGAAGTCTTTCCGTTTTTATTGCGGAGCCCCCGCTGTCGATGCTCCCACATAG +GATGAGTCAGAGGAGAGCGTGGCTGGGAAGGTGTCAGGGTGAAGGACAGCTCTTTCGTGA +TTATATACGATTGAACACCCGCCACTAGCAGTGGTATTAATTTCGTTCACTTTGTACAGA +TCGGAATAACGGGTAAACCGCTAAGTGGTAGGATCTTAACTCGGCTGAAGAACGTGGGTC +ACTATTTCGTAAAAACACTAATAGCATGTAGAATCGAGACAGAGAGACTGATGACTCTTA +GCTTCAACTCCGTGTGCCATCTACAGACGGCATGCATTAAACGAGGAGCTGCAGGTGCTC +TAGTCGGCCAGGGCGAGTCAAGAGTTCAGTATTGTTGTTGGGAAACACTCGAGGGGCCAT +GAGGCGTTCGGTATTATATCAGCGTATATCGGTGGGGTTCTTAACCGATAATGTATAGGT +AGATAGCTGGTGCATAAACAAATACTTCATCATTGTACCCGCTATCTACCCCTAAGTGGC +CGGGTGCAGACTGGCGCTATCATTGGTGCATGTCATGAACGCATGTAAGACTACAAAGGG +GGACAAGATAATCATCACTTCCGAAGTTGTGTTATGCTATATTTGTTTGGCTGATACAGG +TAAGGACACAGCAGCATTATTGATTCAAAAGGTTTTTACGGATAAAGGTATAGCATACAA +CAATGAGTGCAGAACACACCAACCTCCAAGCGATGAGCGCTGCTTATGAGGACTAACCTA +GGTTGGCGTGGCAGCTTTCTCAGTACTATCGAGGTGGTGCGTAGGAGCTAGAGCGGCAAC +GTAGCGGTCCTTCCCCGACACTAGGATATGAGCGAACGTTGGATTAGGGCCAGAGGAAAC +ATCTCTTCTATACGTGGACGCATCCCAGCGAGCCTACCTTCCCGATTGATCGCTTTGCTA +AGCCTGTTAAAGATTCAGCTCGTGAGCTCGTCGGTGCTACATTCGATGATCGTGATGTTA +AGGATGAACCTGTTAGGGTAGCTTAAGATACCACGATTGAAACCTCATTTGAAGCGGTAC +GTAAGTGTCGACTTCCTGAAGATGAAACGGATCAAGAACCTGAGATGTTCGGCCCCTCTC +CATTTTTGAACACTTAGGATTTTGGAATTATCGATCGCGTCGTGAATCCCAACAATTGCT +CGGTACCGAGATTGGACGATCTGCGCGTAGTATCGTATGGCCTGATCGATTAACGAAGTG +TATAGCTAATCTGATCGTACCTGACGTACGGATTGATGGGCAGGTAGTTGATTTCAATGT +TCAAATCAGCCTTCATCCGGTAGGGGTCGGTAGTGTACATGCTTCTGAGATACTCGCAAT +AGAGATGCAGCCAGGTCTTAATGAATTTTATGACGCGATGATAACGAACACTGGTACTAT +TGATGAGCTTGAGTCTAAGCTCCGTACCTACATTGAAGTCGTTAAATGCCACATTCCGTA +TACGACACGCGCACCCCACGATAAGAGGCAAGTTTAATTGCAGGCTAACAACAGATCATG +GATGCTTTCAAACAAGGACGTAAGTATAAGAAGTTATTAAAGGTTGCTTAAATCCGGAGA +CCCGTCGAACTGCTCTATTCCTACCTTAGGGCGTCATCTAATACTACTATGATCTATTCC +CAAAGCCCGAGGTATGAGCTATCGCGGGGATCCGCGAGGTTATCACTGGCTGTGCTAACA +CTCACCCTAAAGTAATGCAAAGCTTCTTCCGTCAACTAGGACGGATTATGGAATCTGAAT +CTATATTGGTATGTGTTGAGCAAGAATCTTATGTTTATACAAATCGTACAGTAGCGTATC +TTCATTCAGCAGGTACTAAATCCACTACACACCGCTACCGCACGTTCCTAAAAGGCGCAC +AGAACATGGGTCTTAACTGGGAACAATGGTCTTTAGAGGAACGCATAGGTCCGGCCCGTT +TACTATTGACTTGCCTTTAAGAAATAGCTACCGGCCGAGAACGGTTTTATTTAAGTGGGT +AGCTAGCCGTGGTACTACAGATTCTATGTACTACCTTGTGCCAGGCGACACTTTAGAGAA +ACACTCTGGAGAAGTACAGAGTGCTGCTAAGGCTGTAGTTAAATATCCACCTACGTAAGT +CCCGCCACTGCATTGGACTGGACAATACGACGGGGGTTATATGACAGTGTGGTTTCGTTT +ATACTCTCCTATGGGTGTTATCCGTTTCATTAAAACTGTACATAAGAAATGAATTCTTGA +GAACTTAAACAGCGAGCAATCGCTCCCTGTACGTACTGCAATGAACAAAGCACAGTCTGT +ACCTTACCGTGTGAATCAGCGTGTATTGACGATTCTACGTACTGCTACGGCTATGCGTGT +GGGTATCCTTGGATTACCTAGTTTCGTTGAAACACCTAAAACTTAAACAGCGAGCAATCG +CTCCCTGTACGTACTGCAATGAACAAAGCACAGTCTGTACCTTACCGTGTGAATCAGCGT +GTATTGACGATTCTACGTACTGCTACGGCTATGCGTGTGGGTATCCTTGGATTACCTAGT +TTCGTTGAAACACCTAAACCTGAGGTCGCATTGCCGCAAGGTTGGAAAAGGGATACAACT +ACATAAGCCGAGCTTGAACAATTCCAATTTTGGGAAACTTAAATGCCTACTTACTACACT +AATGAGGTTAAACGTAAGGGTCGTCCCGTGGGGATTCTGTCTCGCATCAACGCACTTGTG +TAATATCGAGAGGAATCACGCTTATTCGTCCCGACAGTCATGGACCGGCGTGGTCGTTTA +TACTGCCGGTCTAACCCTAACCCGCAATCATATTATGCATTAAAAGGCTGCTTGGAGTTC +GCTGAGGGTAAAGTGTTAGGTAAAGATGGACAGCGTTGGTTAAAGGCGGATATCGCAAAC +CGTAGTGGTTTTGATAAACGCGACTTATTACCGCGCGATACAAAGGTAGCTTGGACAGAC +GAGAACCGGTCGCAATAATCCTGCGAAGGCCTACGTCGCAAATTTCGAACCCCTACACTA +AAATAACTATAAACGAGTCAGGAGATAAACTGCGGATAGTAAGGTATATAGAGAGTTACT +GACGTGTTTTATCTCCATGAATACCTCCCAGGGCTGGGGCCAGTTTATGTCATGTGGGTG +AAGCCTGGGGAATCTTACTCGAAACTCTCTTATTACTTTCGGGATTGAAGAATTTATAAG +TAACCGCCTTTATGCTGATCCCCCTGAACCTGACACAGAATTTCCATTATTGCAAGCTGC +TATCGCCTTACAAGAAGCACTCGCACTGCCTGATCCCGAACTTTATTTATGTCACGTACC +TGTCGCTGTGAATGCTACATCCCCAGGCCTACAGCACCTCTCTGCAGTTACTCGCGACGC +CGTAGGTAGTTATTACACAAACCTTGGAGATAACAAAGACAATAAAAAGTCTGACATCTA +CATGCGGGATGCTGAAGTTGCTAAGAGCATGATGCCCAGGCTAATTGACGATGTGACAGT +AGATTACCTTGGTTTTAAACCTCTCCGGGCTAATAGTTTCTGCTTCACGGCAGCATATAC +ATTTCAACACCAACTGCAGAACGAGGATACCGTGGGAAATTTCACTTATTGGCGCCTCCA +CAGGAGCTCAGAGGGTGGGCCAGTGGAACCCGCTCCGGCCAATAATAACAACCATTTCTG +GGTACGGACGATCCTGACTTCTGTGAAAAGTGAATGAGATCACACGTTCTAAGGCTAGGA +ATCCTGTAATGACTCATATGTACGGTGCAACGCTACTACGTTGCATTGATACAATTGGTT +TAGCCCCACCTGAATCAGGTGTTGAACCTACTAAGAACTATGCAGGTGAAGTTTTATATA +GTATTCTGGGATTTATTCATAGCTTTTCAGCGGCTTTCCCGCTTGTTATGCGTTGGAAAC +TGGAATAACTTCTTGAGGCGACGCTTCAGGTTGATTTACGACTCGGTGAAGCCCCGGCTC +ATCCTAGTTCTGTAACGGACCTCCAAGGTGGCTCCGCTTTCATGAAGGTGGAGGGGTCGC +CAATGGTCTGAACGGAAGAGCTTTGTCCCAATGTCCACCCTGCATCCACTGTGCGAATGT +GATTGCACTTGCTACACCTGTAGTGAAAGCTTTAGGTTAGGGTGTTGTAAAAACTGTACA +TGCATGTGTTAAGATGGTAAAGTTGTTACAGACTGTAGTATGTATACATAAAGAGCGTTT +TATGCGTTGGGGTACCCTTGCGGGTGTTCCTGTAGTTAACTGGGCAGAGCGTTCTTTCAC +CCAAACCCTTAACATCCGTTATATAGATGTCACCCCTGTAACTATCAAGGTAGGTACTAA +GTAATATCATACTCGTTCAGCAGCAAGCGGTATTGTCCCCCCCGATTTTTTCTTAATCAG +TTGAGCCGCTGTAGGCATAATGTGGGTGTCAGTGAGTGACAGTGCATCTACGGCAGGGGT +CGCGCGAGACCCACGCCCAAATGTTGGTTATGCTCGATTTCGCCAGTAGAGGAACTTTGT +ACATTGTATGGACGGTTCACATCTGTGCTGATCTATTAACGAGTGCAATGGGCATGTTCT +CCCTATCTACGACTTATTGATGGTATTATAGTTACCGTTGTGCCATTTGTAATCCGCAAG +TAGTAGCTGTGCTGAAATGAATTGTGGATTGTACGGTTTATCGTTACCCATCCTAGTGAA +GTAGGTGCTATGCAAGAAGCTTTACGTAGGACATTTGCGGATATGTATAAAGCTTATGAT +ATTAACGACTTCTTAACTTTCAATGAAGTCGATACAGAAGAATACGAAGCACCACCTCAA +GGTAATCTTGACTTGGACTCTGTACTCACAGCTCAATTTGATATTAACGACTTCTTAACT +TTCAATGAAGTCGATACAGAAGAATACGAAGCACCACCTCAAGGTAATCTTGACTTGGAC +TCTGTACTCACAGCTCAATTTATGTTTTGTTAATCAAAGCTTCCTTCCTCACGACCATGC +CCGTGGTGCATTGCTTATACGTCGAGTTCAACCGACGGCCTACTCATACTTAGCTCATTC +CTCTATGATCAACTCTAATCTAGGAGATTACTACTATGTTATTCACTATTGTCTCTCTTG +ATTTTCTTTCTTACACGTCGGTTAGATTATATGCTTTGGAATTGGAAAATGAGTTCATGG +GCTATAGTGACTTCCTCAAAGCTTGGGTAGGTTGCTTCTGTAAAGCAGGGCGGGGCCATC +TAAACAGCCTAATCGCTTGACCTGGGCCAGTCATAATTACAGGTCGCCCGGACAGTTCTA +AAGCCGAGCTTGATCAAGAATTTAAACTGTGTGGTTATGAGTTGGTATAAGCGTTCGAAG +CGTCCCTACCGCCTATCATGACACTAGGTACTATTGGATTGGTCGTGTTCTGACCTATCC +TACTAGTCGTAGTTAATATTCTAACGGCACTTGTCACAGTACACAATCGTAAGTAATCAG +AAGCCCTCGAGCCCAACCGCTTGAGGGCTTTTTTTTTTGTTTATCACTATCTCAACGAGT +TACTCAATGTTACACATATTGAATAACGTCTGTTCAATAGTGCGACGTAATTATATGGTT +TTAAATAAGCAAATAGAAGATAGACGTATAAAATAGGCAAGGAGCTTTAATCGTATGAAT +ATACCGAAGTTTACAGATGATCTGGTTGAGTGTTTAAAAAGAGTTTTTTCAGAGAATACA +GGTATGACCTTAGTCCCTAATGAGTTGAATAGACGATTAGGCAGTAGACATGTTATCCAT +CATAATGTTCAGTGCATTGAGAATCCCGAATTTCCACATACTACCACCACGGAAAGCATT +TTTAACGGATTTCTTCAGGAATGAACCTAAACCCATAACTACCTCCTAAGATGTGATCTT +ACGTTTACTGCTAAGGCTTCTAAGCAATAACGTGCAACGCAACTGGTGATAAAGCTCGAA +TAACACTGCCCGCGCGTGCGAGGAAAACCCGGACAAAGGACCATTACTTAGGTTGGAAGA +GTCAAGTGAGCAAAGTGCCCGTGTTCCATGGAAGCACTTGAAGACTGGGTGGAAGGCGGA +CCCGAGTTGTTGATGCCCCCGGTGACGATCAGGTGCATAGTGTGTTAGGTCTTGATGCAA +TCTAAGACTTGGCAGGCGCACACGAAGCACAAATGCAGCAACAACAGGAAACTAGTAAAT +TGGATGCTTCAGCGGAGTCACAGAACGTGGCGCGGTCTGATGGTACGCCAGACACAGGGT +TTACAGGTACGCATTCACGTCGCAAGGAGAAACAATCAGGTGCTTAGTAACAGGCACTAG +GTCTTCAGCTGCAGGGGGGTACTATAGTTAAGTATCCTCAGATCACTTATTCACTCAAGG +CATTGGAAAGTCAGTATCAGGTTACTGCACTACTTACACGAATTGAAGACTATGCTTATT +GGACTAACCCTAGTGTGTTTCCAAAAGGTGATAAAGATCTTTCGAATCCAGGTTAGCGTT +GACTTAAAACAACAGCACCTGGCGGCGGTGTGAGGAATCTAGGTCATTTTGTTTCAGGTA +ATCCATCTTACCGGCATCGCGGATATAGTCCAGATTTTAGTGAACTGTTTTCCTGTTTGA +GCAAAGGAATTTAGACAGTATTATCGAATATGAAAACCAAGCATGTGAACAATTGTACAT +GAATGCATCTTATGCTCTACTTGTACAAGCAATACGATTAATGGTTATTACTGGCGAGTG +TTTACTGTATCGTCATAATAGCGCACTACGTGTATTCACATTAAAGGATTACGTCCTTAA +ACGTTACAACGTCGGTGAGGTTATGGATATTGTTAGCTGTGAGCATACGTACCGTGAGGA +ACTTCCATCTGATCAACGTGTCAAACTTCAGATTTAGAGTCGACGCGCACAGACGGACCT +CCATGGACCTGTGCAATTGCGGATGGCCCTCTACGCTGGGCCAGAGCCGGAACATACTGT +TAGTCAACTTTTTTCTACCGTGACAATGCTTCCTAGGCCGTGTTGTATTGTGCAACTGAA +ACCAACGCTTTGAGGTTGTTGCTCACGCGTAACGTTTAACCGCCGGATATAATACAAAGT +CTCATACCCGTGTAAAAGTCTATACCCGTGTTGAGCGCAACGAGGTTTATGGTAGTGAGT +CTCGGCAAGTAACACACGAGATTAATGATATCGACCTTTGTACTTATACTGTGTATCGTG +ATAAGCTATTCCCACTCGTCCCTGACGCTTGCAATCTCGTTGATGGTGATTCTTATGTTC +GTCGCTATGTAGAGGATTATGCTGCTTAGATTTGGCTCATACCACAGCCAATCGGGATAT +GACAATCGGCATGACACGATGTGGGCTTATCTCACAACCGGTGTTCCTGCCTGCATTCCG +CCTCACTTTGCTTAGTTATCAGATATGTCTCGTGAGCTTACGTCTTACACCATGTCTCAT +ATACTGAAAACTCGACCACAACCCAGGAGTCTTGAGTCCCCGTAGGTAAGTTTCACGCCA +AGTACACTGTCTCAGATACGCGGTTGCCATTGATAGGCTACTATGCTGTGAGAAGGAGCC +TTTACGTCTTCTACATATAGTTTGCCCTCAAGGGGCTGTGGATGTAGAATCTGCTGTGAA +TGGCCCTAATGGTGAGTTTATGCAAGGTGACCCTAGTACGATCAAGCCTTATGAGGCAGG +TTCGTACCACAAGATTGCTGAAATTCGCAAAGCTCTTGAGGCAATTGAACAACGTTTCAA +TATCGTTTTTATGTATACAGCTAATATGCGTGAAGGTGAACGTGTCACCGCCTATGAAAT +TCGTCAGAATTCTGAGGAAGTTGAGCAGGTCTTGGGTGGTGTGTGCTTACAACTTTCTCA +AAGTGTGCTTCTACCATTAGCGTATTTGTTACTGTACGAAGTAAATCCAACCATCCTGGA +GGCTATTGACAAGCAATTACTAGACCTTGGTTCTCAGATGAACGAGATAATGCCTGAATA +CCAGTTAAGATATTTAGTTTAATCTCCTGAGAGTTCGGAGTTGAACGCTATTATCCCTAC +AATTGCACAGCTTGGGAAAGGTTTTAATATTGGTGCTATCGCTGCTAAAGCCATTGAATG +TTATAACGTGAACATCACAGATATTGCATACACTGAGGCATAGGTACAGGCTAAGGCTCA +TGCTGAACCAGAATCTATGGCTCGACAGCAGGCACAGATGAGTCAAGGCATGCCACAACA +ACTGGCAGTGCAAGGGTCTGCTATCCACGCACTTCAACAAGTCCAACTATTTTAATAGGG +ATTTAAAATGACTCAGGAAGTAATTTCATCTGAAGTAACCTCTGCTGCACCTCCACCTGC +TGCTGTACAACCAGTGGTAGAATCTGCTGTAAAACCCGGCAGGTTACGGTCCTAGTTTTT +TTCTGTTGCAATGGCAGAGACGGACTTCTGGTACGTCCTCCGACGTAAAAGGTGCAATAA +GAGCAACTAACCGTCGCTCATCCAGGGAGCGATTATCCCTCTACTTGAGCGACCCCAGGT +CTATTTCCGGGTGTTGAATCCACCAGCGACTTTATCAACGTTTAGCACTTTTTGCACGGT +TGTAGGCGACAGTACACTAACGGTGTCTTTACCCAAGGACAGTCCTTCTGGGTCCGATTC +CGAGCGGAAATGGGGTGTGAGGTCACCGTTAGGCACGCAAGAATAGTGCCAGACAAGGCG +GGGTATAAGAGAAGTAGTTGTATCTCAGTAGGTTCCAATCTTCATAGGTTAATCTGAACT +TGAAACTTCTAGTAATATCTTCTCAAGTGGCGCGGGTATTGACGCTGTATGTTTTGGAGA +TGCAATTGAAAATGGAATCAAATACAATTACCCTACTATAATTAATGTGCATGCACTTAC +CGCAGGTCCTCAACCAGAGCCCGCTGCTCAAGCTAGAGCATTGGCTCAAGCTGCATAACA +GAAGTAGGAATGAGATCTTGCGAAGGGCGTTGTAAGTACCTCACTACTCAAACTCGCTCT +TAGTAACGGCAGGCGCGCAAAAGCTTTAGACCGAGATACGTGTCATGTTCAAGTCGGGGG +CTTACCATGGATTTGGTCCCTGAAACTTATAGTGGTTGAGTCTTCAATGCATTGACAGCG +GCCAGCCCATACATTCCTGGAACAATCTATGCACTTATTCGTGCAAGTTGACTTTAGGTC +CCTAACACAGGCTGCAATTCAACCAACAAGCCAACGTTATTCTCTTACTACTGGCTCCCC +TAGTGCTTTTCCGGGGCCACATTCAGCGGTACCTTCTGAATCGCCACGTTGTGACCACAC +GTGCCTCACAAGAATCTATTGCGACGGCTGAACGTCTAGCAGGTGGCTCTAAACAATGGA +AAAATATCAGTTCTACATTTTATACTAGAGCACCTGCTCATTTGAAAGCAGTAGTGTCAC +GGATTTTAGATGCAGGTGCCGAACAGGATGCTGTTCAGTTCGTTTTTGACACAGGAAATG +GAGTAGGTCTAGTGAACAGTGGAAATGATTCGATGCAAGGCGGTGTCGGCGGCAATGGTG +CCGGATCTTTAGGTATCTCAAAAACAGATTATTTTGCACAATAAGTAAGCCTAGAACATC +AAGCGGGGTGTCGGAGGTCTCAGCCTCCAGCATAACTGTTCATTTGAGCAGGGCGAGTAC +GCACATAGGTTAACTTCACTTCGTAATGCACGTAGACTAGGTGGTAACAACGGTCCTTAA +TATTAGGAGAATTTAATCATGGCTCAAGCTAGTATTTAGCACCCGAATACAACTTGCTTA +CATTGGAGTTGTGCAAACTCAGATAAAGACGATCACTTAGCATTATCTACAGGCATTGTA +GATTCACGATTCCAATACTCTCAGATCCTCCACGGTTTCTCTGTTCAGCGTTCTACTAAA +TCAGGTTCCAATACTATCCGTCTCGCCGGTTTGAACAGTACATAAGTTAAGGGTCGTAAA +TCGGGTGAGGGAATCCAGTCTCAGCGGGAGACTTCAGGTAAAATGAAAATCACAGCCGAT +TGTGTGATGTACATTCGTGACCCGACCACCCCTATCGTTCGATGGTTGTTGGGCCTCTAG +TACCAATAGCGGCCCCGTTCTAGCAATAGGATGGACGATTGGACTGCACCTGACTTGTTG +ACCGATATTGGTCGTGACAACGGTACTGCGTTTGGTCTGGCGTACGATGAGGTGCACTTA +ATCTGTCTAATCAAAGTCCGTAATTGGGTGGCATCTGCACACTTAGCAGTGTCGTGTAAA +GATGGTACGCATATAGGGGTTGCCTTGACAGCTGCGACTATTACTGCCGATCTTGAAGCT +AACGTCTCAGCTAAACAGGCACGCGTTAGGCTACGCAGCATGGGTGCGCTTCGCATGAAC +CTATTAGGGAAGGACTTTTCGATTTTCTCCAGCACCATAGACGCAGCATCTGAAATGCTC +ACCTATAACATCTTACCTAGCGGGAGAACGGTCTTCAGATCTTCCAGTAGAGTGAAAATC +GTCAGGCTTACGCTGATGCTCTAGCATATGCTTACTGTGTGCTTGCAGAGGTATTTTCTA +ACCCTCAAGTACCTTTAATGGACATGGTCACTGGGGTAACTCCGAAAGTGTTTGGTTAAC +TTTTACATCACCCGACATTGATCTACAGAGGCTACGGAGCGTTGGTCTCCGTAGACAAGA +TATGGTTAGTACCCACAGTCTTAGGAAACGCAGTCATCTGTACGATAGGTAGACCGTTAA +CCTCAACGATACGACGACCTGCGAAGTCACCGTTAGAAGGTTACGCGTTTGATGCGTCTG +CGCATGATGTGAAAGGTGTGATGAGCATTTTCTCTAAAACGCTGTCTCTAGTCACTGTAA +CTACACAGGCATTCGTTTGATATATAATTGTCAATTCGGCTAGCATCCATGAAGTTTCTG +ACTTTTGAAAAGATAAAACTGAGATGTGAAACGTGTTGGACTGGTTCACTATGTTAACCG +TTGGTAGTCGTCGTGCTGATACTGTTGGTGTTGCGATGATCACTAGTACACCTCAACCAT +AACATGGAGGGCTCCGGCTCTCCATTCAATTTTAGGAGTAAAATAACATGGCTAACCTAG +GCGAGTCAATTGTATCCAATGCTATCTCAGGTAAACCTTTAACTTTATCAGATAAAGCTT +GTTCTTTGGTAGGACGAGCAAGTGATAGGGTCGCTGCGTTAGAGGTTCAGGTTCAAGCTT +TGCTAACTTTTGCAGGTGCACCAGCCTCGTGACTGATGGCTTCAAAAGCATAGCCCACTG +ACGTGCGACTGCTGCGTCAACCGTGTAGCGAACTTTTGGAGAGAACAAGTTAAAGTCTAC +CCAGCCAGGCCGTACCTACTGGGTCTATTGTCACCCAGATTTTAAGAAAATTGTGTAGAG +CTAACTCAATGCTTTCTCTATGTCATATAGACTGACTGTTCGTGTACACAAGGAGATGGG +TATAGCCTCTACACCAGTAGAAGCACCTGTAGCAAAACTTGTTGCTAAGGCTAAGACGGG +AGAGTCATCAAGGCGTTAATCAAAACGATTAATGCTGCTGATCTTCGAGGTACTAATGAG +GTGAGTATTGACTTCACCTCTATACTAACCACTATCAGTGGCGTGAAAACAGATACGACT +GTTAGACAGGCAGGCGTTAACGCTGTTTTTACGTTGCTTGGATTATATCTTAAAGTAAAC +CCTTTCGAGTTTACGGTGTTGGTGTAGTGTTAGTTTTGATAACAGCTACGTCAGCCTTTC +CCAAGTGGACGTATTGTGATGATTAGCCAGACCGCCGTACGGGGCAGCAACGCTCCTCGT +CTGGCCTCGAGTCCACGGAACGCAGTGCACTCTTATCATAGCCGGGCCCTGCAAGTCAGG +TCATCCCAGCATCAGAACGGGTGGTGTTGCCGAGCTGTAGCACATCTGCCACCCGGTGAA +ACCCGTCTTTCATTCTAAAAGAAGCTAACCTGCTACGTGGTACAGACGTTTAATTCTTAG +AATCTCTTTGGCCACTACGACTAGCTTTATCTTAAAGGGAATCAACCATCGGAGGTATGA +TATGGATATGTTATAAGCTATACATACTGGATTACCTTATATTGGTGAAAACGTAGGTAC +ACGTATTGAGGGTGCAAAGCATCCATCTGAAGATTTAATCAAAGCTCCTATCAAGCGCCG +GTAATTAAAATTGTTGACTACTGGTGGGAGGTTTAATGACCTACATCTAAAGTTACTCCC +TAACCAACAAGGATTCATTGATGTGCCTGTAGACACGTTAGAAGCGTATTGTCACAATAT +CAGTGTTACGTTAGATGGTGAGCTCTCAGGCCGTGAACCTTGGGAACCCCATAAGTGGAA +TGAAGAGACGTGGCCTACTTACCGGTTAAATAGACATCGGTCGAGTTTCTTCAATCCTGA +TGAGGGTTCTCGACATTTCTCTAAACCGTTAGAAGTTAAGATTGTACGTAATGTACCTTT +TGAGAAGTTACCTGAAACTGCTGCATTATATGTAACATATAAAGCTGCTATTGAGGTATA +TACTGCTGATCTTGGTGCTGAGGATGTACTTCAGATTCTAAACAATTATGCAAACGATAA +CTTGATTTCTTTTAAGGAACTCAATTTACGTCAACGGAAGTATAACAGTAAACGGACGGC +GCGACAGTTCAGTTCGTGTAATCGGTTACGACACCGCTAGGAGGTGAGCAATGGCAGTAC +GTGAGGGTACGTATAAATACCTTTGACAAGGGGTATCGCAACAGACCTCACAAGAACGTA +CAGATGGACAATTAGGTTCAGAGCTTAACATGTTTTCTGACCCTGTGACTGCATCAGGTC +GTCGTTGTGGTACTAAATTGACCATCGAACCCTCACGAGAGAAGATCTGTCACGGGTACA +AGAGCCTCTCGGATGTGATCAGCACTAGCTTTGGCCCCTTCGCATGAAATGAAATCATTA +CACGCTGTATTAGAAGACGTTGACATGGGGAGTAATATTCGCATGACCGAGATTCGAGGT +GCTATTTATACTACCATTACTGGTACAGCTAATGGTTCCTTAAGAGTATACACTTTTTAT +GGTCGACTAAAGTCAACTATTTAAAATGATTCTTTTAAAGCTCGTAGTGAATCTAGTGTT +CGAACTACGGTACCTAAGGGTTATTTCTTCATTCTAAGTACTGAGCTAATCCCTATCGAA +CAGCCCGAAGCTTAAGCGGGGAAGAACCCTCATCACTACAGGGACTCCAGCACTGTATCT +ACAGCGTTTAGTAAAGTATTTACTATATCTGTAACTCACCCCTCTATTGGTACTATAACT +AAGACGGTTACTGCATCTAGCGACAATGCTGCTGAGGCAAGTCAGGAAAATATCGCTCGT +GGTCTTGCGGATTTATTCTCTCAAGATACTACTTTTGCAGCGGTGTTTAATGTACACCGT +ACAGGTATAACTGTAGCGTTTGAGGTAAAGGATAAGACGCAAACTGGTCCTACGGTTGTT +GACTCTACTACTGGTGCTACTTATGTTGTTATGTCAGGTGCATCCCGTGTTGTGAATAAA +GCCGAGTCACTGGGTACACTACCATCGGTACTTGATGGTTATATGATGGCCGTAGGTTAC +GAAGGTAACTCCGCATACAACAAATTCGATCATGGGGGATAACGTTGGGCTTAGACTGGA +GTTCATGAACCTGACTATAAACTTATCACTAAGCCTATGTCTTGGTATCTTGATGTTGCT +GGTACTGTGAAGTCATTGATCTCTAACTTACACGGAGATGCGGTACTTAAGGCTGCGCGG +CTATGCGGGGGCGTCCGATTTAAATACGCAACCCAGAAAGTTAGTGCGATCTGGGGATCG +AAGCCCAGTCGCGTCCATCGCCTGTACCGTTAGATTTTAAAGCTCGTGAGGCAGGAGATG +AAGACAATAACACTGACCCTATATTCATTGGGTACGGTTTGACAGGTATTGGTAGCTACC +AATCCCGTCTAGTATTATTGAGTGGTTCATACGTCAATATGAGTCAGACGCGTTACTTCA +ACCAATTCATGCGTACTACGGTTACTGAACTGTTAGATGATGATGCTATTGAGGTTTCTA +GTCATTGGGTACGGTTTGACAGGTATTGGTAGCTACCAATCCCGTCTAGTATTATTGAGT +GGTTCATACGTCAATATGAGTCAGACGCGTTACTTCAACCAATTCATGCGTACTACGGTT +ACTGAACTGTTAGATGATGATGCTATTGAGGTTTCTAGTTCTGCAATTAGATCTGCACAG +TTCGAATACCGTCTGCCTTCTGATAAGGACTTGGTGATAACTGCACAGACACAGCAAGCA +GTAATCAGCGGGAATGCGGAGCCGTAAACTTACGTTATCTAAGGGCAGCGACGATTGTAT +GGAGCTTGCAGATGTCGGGGTCCAACCCCCCAACTAGTACTAAGGGCACGAGTACTGTTT +GTAGGGAAGGCCAGGCCACTGTTGGCTGCTTAATAAGGGTCATAGTGGTCATCTTCCTGA +AGAAAACAACAGGGAGAGTAATTAGCTGGTGCCCCTGCTGAGTCGACTTTGCTCACACCT +AAATCTGCGGTGATCCATTCGAGTACAAAGGTGGATCTGTCACTAGCTGCTGAAGCCCAA +GCTGTAGCTGGAAGTTTGTATTACACGTATCACCATGGGGCAGATTATTATCAAGTAGGA +GAGTTCATTCCCAACACATATACCTACGCACAGTATTACAATCAGAACTTAACTGATCAT +GTACCACTGTATGCTACTGGTGTTTGTACATGTATGAGCGTAGCGGCCTAGAAGCGCGGG +CTCGCTCATTCCAAGGACACATATGATGAGCACCTAAGCACGCTAACTTCTTCGGGTGTT +AGTAGAATCATGGGAGACCTCACCGTTGCTGAGGATGCTGCATCTACTACTAACAACATG +GTAGTGATGAGTTCAGACTCCCGTGATGTATTGGTTAATCAGTTCTTATGGGTTGGTGAA +GATCGCCCTCTGATGAGCTTCCATAAATGGGATGAGTTCAGACTCCCGTGATGTATTGGT +TAATCAGTTCTTATGGGTTGGTGAAGATCGCCCTCTGATGAGCTTCCATAAATGGGAGTA +CCCATTACCTGTTGTGTACGCTCAGTTCATTCAAGATGAGTGACCAGTACGGAAATACTT +GATCGTGTTCGTGGATCATGGGGAGGGTAACTTAGTCGTCGTTACGCAGAACGAATATTT +AATCCTATAAGATGATAAACGTGCCATCCATTATTAGACTGGCCCTAAAACTACCTAATC +AGGCTGGACCCACAGTAATCCGTCAACTGCAATTCCGGACGTTAACGCGTTCATGTGCGC +TTATCATTCACCTATCCCATTCCTAGACTCGTTTGGTTATGTGACCATTAACCCACCATT +AATGGGAAGTTTACGGCATTGCGGAGAACGGTGTTGGTGTCTTGCCAGAGTATTTACTTG +AGATGAAAACTGGTCATATGGAGTTAGCTGCATCTATATATAGTAACCATTATCTGCGCC +ACCAAGAGATTGAGTTCTCGTGTGATGATGCGGCTAATGTTACATGTCCTTATGGTGGCA +CAACTATTTTTTTAACCATTAGCGATTAAACACTGCTGCCTGTTATCTATGTTGGTGGAC +GCTTCACAAGTGAGTCTACTTTGACACCTCCTTTTATCAATGACGAGAACGGCAAGGACG +TGGCAGGGACTAAGAGTAAAGCAGTATCAAGCTCATTGTAGTATGAGTCACCCATAGTAT +CCTTTACGGACACTTTAAACGTACCTGTGTTCTTAAATTCCATGTCTAGGCGTACTACCG +TAACGCGGTCAGGGGCTGACTCAGGACATAGATGGGTTAATAGTAGCGGTCGAACTGGCA +GTCAGTGGACAGTATGGCTCATTCCTTTCTAGCGCTGCCGGAACAGAACTGTGCGTGTTT +GGGGTACGGAACGGTCTCGGTCAGGTATGTAGCTCCGGTAGAAGCGCTGCCCCTCTGCTA +TTGAGGGTAACGGTGCGTCCGCTTTTGATCTTAATAATCTTTGGATCTATTCCATGTCGT +ACTCGTTTCATGTCTACACAGTATTCTGTAGTGACTGTAGGTACAACAGATTGAAAACCT +ACTAACTGAAGCCATTTCTTAACGTTGAATGACAAGCATCGTAGGATTCAATATGGCAGG +CAATATTCAGCCAGGTTTATCTACAGGTATGCATGGCACACAGGGGATGGGTGGTCAAGT +TGGTGGTATGAGGGGTGCGGTCATCGATGATATCGGTGTCTTAGCTCTAGGTTATAATAC +ACCTAAGTACGAGAAGATTGCCCTTGAGAAATATAATACCGAGGTATTTGAAAATGCTAT +CTTGTGGAAGTTGTTTCATGCCGGGACCCAGCTTGAATGCTTGTATAATACACATTCAGC +ACATGAACCACAAACAAAGCGGGGGCGGTAAGACTCCCCGCGCACGGCGAAGTCGCTGCT +CTATGTCGGTCTGTCCTTATTCGATATGCGTCGTGTACAGATTGTACAGAACATGCGCAC +AGCACAGGCACTCGGAGCTCATCGAGATCAACAGACAGTTACTATAAGCTCATATTACGC +CAAATATGGCGCTCATGATGTGGTGGGAGCTTCTGCGGATGTTCGAAAGAGTACATTAGC +CTCTCATATAGCTCAGGCTATTGCACAAACATGGTCTAACGATGAAACAGGTATTGTTAA +CTATAATAGCTTTGTTACGTAAACACGGTATGTGGGATATGTTCATGGAACGTATGAACT +CACTACTGTTTAACGCTATTGCTAGTTACCACGGCTTATATGTGGATATGGAAGTAGCTA +AGCGTAACCAACAAGCTCAGGAAATTGAAATTGAAAATATTAAAGCGTCCATCTTGGATA +TGTTACCTGCTGATCTTCCTGACGACTTTGAGTTCTCATTCACATCCGCATACCACTTGT +CGGCATTCTTGTTCGGAGGTACGATTCACATTGGTGTTGCGGGTACAGTGAAGTCTGAAT +CAGCAGCCTTGCGTCGAACCAAAGGTGTTCAGCGTACTATGGGCTTAGGCGCGCTCACTA +ACTCGGATATACATATGTACAAGCAATACGGTGGTAGTTTCAATAACGCAATGGGTAACT +TGTGGGGTGGTGGTTCTACAACAACTCAAGGCGTGTCAGGTGGTGGCTTAGGCGGTCTAT +CTGATTTTGGTTCGTTTGGTAAAGGTGGCTCAGCCAGTGGTTTAACTGGTGGTAGTTCAT +TAGCTTAATATAGGAGTTTATACATGCCTACTATGGTTCAACAACCCGACTTAATTACAC +CCGTACTCTCTCGCAAAGGAAACGTTTAGTTTTAGACGGAAGCAACGTACCGGCACAAGC +AAAAGGATAGATAGCGGAAACAGTCCACCTAGCACATATACCTTGCAGCTAAGCGCACAG +CGGACTCTCCTCTTAGAAAACAACGGCCGACATAACGTACACCGATCTGTCGTGACGGCC +CAACAGTTCATTACGAGCTCCTTAAGCGCAAGGCGCCCGTACATTTTATGCCTGACCGCC +CCGGATTCCCCCTCGGCAGCGGACTTCAAGCGAGTGATCGTCCTGCAGAACATAGTGGGC +TTGGCTCATTCCTTATAGAATTACTCCCGCAAGTTAGAGCGGGATTAGACGAGCATCAGA +AAGAAAACCGAGACCATTGTGTTGCGTTAGGTCGTAATGATTAGTTAGACGGTGTACAAT +GCGGTCTGTGTATTATTGACTCCCGCAACTATAGCCAAGGCAAAGAGTTCCAAAAGGTTA +CATCTACAAAGGCTGAACACCAACAGTAATTCCGTGATACTGTAACTCAAGTGGCTCGTG +ATGCTAAGTCAGCTGAGGAAATCTTCGATGACGTATAAGTTACTGATTAAGCAGGATCAT +ACTCCTGCACAGCTTACCGAAATAACAATTTCACTTATACTGGTGAGTTCTTTGCCCTGA +CCTATCCTGAACCCTCAACTGGATTGGTGGTCACACCTTAGTCCGCCTCTGGCCCGTCGT +TGAGCTTTTACTTTTAATACGAGTGTCTGATTACTTGAGGCTGATGTACAGAATGCATTT +GCTGCTAAGGTCGCTAGTACCGACAGCCACGCGATTAGAGATCTGGCACTGTCTGAGTCG +CCTAATGTGTTAGGGCAGCCCTAGCGGGGATTGCGGCCGTAGATCAGTCCTCTGGTGCCT +ACAATACACCTATTTTAAGCTGCTCTTTCCTAACCCAGCCTGTGGACTAGGGAGCCCAAT +ATGGGAATTCACCATAATGAGGCTATGCAAGCTGCACAGTCTGAAGTACAGACTATGTTC +ACGTATGGGGCGGGTCAGAACGACCCGTCTAGTCCTGAAGCTGCTGCAGTCGTCACAGTG +ACAACAAGGGCGAAGTGGGAAATTGATATTTATTCGTTTTTAGCCAATTCTACTCTAATA +GATCGAAAGACAAAGCTCACGTCACGGCAAAACCTCGGGTAAACATTTAGAATAATACAT +TAGTTGTAGCTGTTCAGGGTGGTATCGTGAGTATGTCCACTGTTGTCGATTTACCAAGTA +ATACTAACGGTATCCGTTCAAAGATTCTTGAGAGCAACGGTAAAACACGGATTGGGTGAC +GTTCGTTCGATCTTATACTATCCAATTAGAGACCTCTATGTAAGAGCGTATATGGAATAA +TCAACGTGGTAATGCAGATTAAACTGTCTGAACCAGGGCGAAAAGTCACGACTTCGTAAA +ATCACAGTTAACAGAGATTAACCGGATAGAAGCCCAAGGGTCACTTTCACCTGCAAACGC +TTCACAACTATGAGCTAACTTATTCTCTTTTGGGGGTCGTGATTTGATACTACGTATTCA +AGCACCTGCGTATGCTTTATCAAATGTGACTGCTACAGTACGTCGGCAGGTTACAGGTTA +ATAGGAGGAATAATATGAACATTGTAGATCAGGTCTACATGGCACTGATCTACATTTGGT +CAGAGCTAGATAAAATGGTAGTCGGTATGGGTTTAACAGCCTATATCGTCGCTGTATTAA +AAGGTGAACGTAAACATCGTGAGGCAATATTATGCGGTGTATTCGCTATGATTGCAGGTA +CTGCCTTATGATACTCAATACAATAGGTTATTACCGGGCGCCTCACGTGCGGGGAAATTG +GGTGTTAGGCCTGTGACTGCGATATGCGGTGACCGAGATTGCACAGCTGACGTCGATCGC +GACTCACCATTAGCAGCCTGAACTAGATCATGCACAGCTAGTTAAGGTCGGTGTCTCTAT +GCTGGAGTATGCTGTACTTGGTAAAGGAGATGAGGCTAGCCATGGGGGTCGTATAAGAAG +TTATTATGATGGTATTAACAATGGTGACCCTGTTGCTGCGGGTTCTGCTAAGGTTGCCCA +CGCTTTACGTGGTGACCCTAATGGTGAGAACTTACCGTCGCTTATGCGTAACGGTACACA +GCAACTATCAAGTCAATATGGTATTAACAATGGTGACCCTGTTGCTGCGGGTTCTGCTAA +GGTTGCCCACGCTTTACGTGGTGACCCTAATGGTGAGAACTTACCGTCGCTTATGCGTAA +CGGTACACAGCAACTATCAAGTCAATTTGTTAGTTTCTTATCACTACCTCAAGACGAAGC +TGCTCAACAACAACATTATTAGAACGCAGTTGAAGCGTATGATAGTCTGAAAGCTACTTA +CATGCAATTGAAAGCTCAAGGTTCTCCTTTGGCGGACCAACTGCTTGCAAGCGTAGCTGA +AGATTACCGTGGTACTGTTATGGAGATGTTCGCAGGTAATGCTGACATGAACTCTAGTGC +TGAAGCTCTACGTAACCCTGTTATATGTGAGGATGTACGTGGTTCCTATATGAAGAATAT +GCAGATGGTCTATTCGGACTTTCATTTTAAACGGATCATGCTAAACACGCTCTTGCTAAC +GGTTCTACAGCTTCTAATCACAAACAACTTGTATCTGATGCTACCGCTTTAAGTATGCAC +GATAAATGTTATAACTCCCCTGGTATCGAAAAAGCATCCCGCCCCTGCAGGTTACAACGA +TGCTTTATTCACAGCGGGTGCGTCTAAGGTTTACTATACCATAACAGCTCGCTTTTGCTA +GAAGATGAGTTGTTTTACGGTATAGCGTAAATTCGCCCTGTTCCGAGAAACCCACGATGC +GCGCTTAACAGGAGAGCTTTGGTCCAAAGGACGAAGACAACCGCGGTCACTGTATAGGCC +GATCATAAGGGTGTTAAGTAGTCGGCTGCTTACATTTGCCATGCAATTCATGAGCGTCTT +CGTACTGTGCCTAAATCTGTAAATAGTTCTCCTTATAACGTGTTGATTCATGCAGATCGT +ACGGGTCGCTACGTAATTGTCCAACCGATCGATATGAGTGGTAAGCTGTTCAAGGATAAG +TAAGGTCACGCAGTCCAAGGTGAGGTTAACAATCAAAGCCAATTCGTTAACTGAATGAAG +AACGCCTATGATGCTGACCAAGTTAAGTACAATAAGCACCCTAGCACATTTAAAACTATC +GATGCTGCTTTCAGTAATAAAGGTGTTAGTGATTCACTTGGTAGTATAGCCAACGACAAA +GAGGATATGGCTAAGTGGCGTCAAGAGTCTAAGTCGTACACATTGAACACAGCAGGCTCA +CTGGGTCAGGGTCACCCACAATCCTTGCTTAATCCATAAGCTGAGTTCATGTCTAATAAC +ATGAAAGATCAGCAGTTATAGGATAAGCGTTTACGTATCCCACTAGCTACAACGTGATAT +TACGTCAGCGCCTAGGACCCCATTCAATAACTTGGCGCTGGGACAAGAAGACCTCGTTTG +ATTTGCTACACTGACTTGATGGGTGAGCTCCTGCTGGGATGGATTTCAAGCCTGACGCAT +TGCAGCTATGGGCGACGAAGGGACAGCAAGGTTGATCCCATTGCGTTGATCGGGCCGAGT +ACGACTCGTGGGCGGACGTATAGCCAAGCACTAGCTAAAACGCGTAAGTCGTCGTCCTTA +TTAATACCTACTTGATTAGCCATTTATACAACCTCCTAATAATTAAAGTTTACCCATTGC +TAAGTAGTAATCACGAAGCATGTTACGACGCGCAACGTTACGACGGTGACCATCACCCGC +GTGTGTGTATGCAATTCAAGCTCTTCCATCCGTACAACCTGCTATCCCTGACCACGCAGC +ACCGACTGCGGGTGAGGGTATTCGTCCTAGTACCTATCAACAATTAGGACAGGCAACTGA +ACAAGATTTAGCAGTGACGGGTGAGGAACTCCAAGATGAGGTACTACCTGAACAACCACC +TGCTATCCCTGACCACGCAGCACCGACTGCGGGTGAGGGTATTCGTCCTAGTACCTATCA +ACAATTAGGACAGGCAACTGAACAAGATTTAGCAGTGACGGGTGAGGAACTCCAAGATGA +GGTACTACCTGAACAACCTGCACTACGGAAAGTCCCACGAGTAGTTGCACCTACTGCTAG +AGACTAGGGTAATACTATTTACGAAGGCATAAAAGTTGAACGTGTTATTTATTCTAATCC +GGATGCGGATGCATATGAGCTGTTTTAAGCTCATGCTGAACGTAACCGAGAGGAACTAAC +TTATATTCATGGCGCACGTAGCTGTGAGGATATGCAATTCCGTCAACGACGTATTTTAGA +TCGGCGTGTTGACAACGAGATTTTAGCTGCCCATCCGATTGAAGGTACCATTGCATCTGT +CGTGGAGCACTGTTAGACAAATTGGTGTAACCTCTTCAATTAAGAGATTTGCTAAAAGCC +GGGCTCGAGTAATTCCGACGGCCGGCAACGACTATTTCAACGTACAGCAGTTTAATTAAA +GTGAGGAAAATCGGCCCGGAGCCGAACGAGTGACCCAGACTTTGAAAGAGTGTGTAGAGT +TCCGGGACGCCGATGTTGATTTACCTTTAGCATTCGCACCTGGTCTGGGGCAGACTGGAC +GCGCTGCTAAGATACGTCGCTTGACTCGACGCACATCTACTTGGTATGCAAACCGCTGCT +CTAGGTGGTGGTGCTTTCCGTCTTAACCAATTATTATAAGATGGGTTTACACGTGCTCAT +TCCGATCGTAACTTAGCTAGTTTGACATTCTGCTTAGTGGATTTGTTCGCCCCTATCAGA +GATGAAGCCCGTATTACTGGTACATAGTGAAGTAGAATCGGGCGCCGACCATTCCTGATG +TGGATTCAGTATCGAGTTGAAAGACCGTGGGGGCAAACTCGACCCCGCTATCCCAGGTCT +CCTACGTCATCAGTCACGCATAAAGAATCGAGGCCGATGGTGAATTCAGCTCAATAGATA +TCTCCTGGTGGTGGGCGACCTGGGGAGGTATGTAAGTGCGCGTAGCGCGCAGTGGCAGCT +TTAAATCAAATGGTAGATACTGAGTTAGAAACTATTTCTCACGAGAGAACTGATCCTGCT +AACCATCTAGGTACTGCAGATACAACTAACGTACTAGGGCATGATATTAAAACGCCTATC +TCAGAACCGATTGGTACCTACTCTAAATTAGCAGTACCTGATCGGGCTGTTCCGAACAAG +GTTGTAGTTGCTCGACAGTCATCGAGTCACTTATATCCTATTGACCTGCGGCCTATGAAT +AGAATTAGGCACCCAGTGTCAGCGGAAACTACATGTGGTGTCTCATTAAGGGCGATGCAA +ATCACCTCGCTAATAAGATTATAGCATCTCCTGGAACGCAAGGTAATAATGCGCCTTATG +CTACTGCACCACTACAAGCAACCCCTGAAGTTAGATTGGTTGGTGCGGTATCAAAGGCCC +CCAACCTAAGCGTGGCGTGACATTCCTATGACGAGCAGTCGCCGCATCTGTTTGACCAGT +TAATCAAGTACCACTATCTTACCTCTCAGCATCCCTCTTTCCGGGCTGTTTTCAATAGCC +CTTCCGGCCGGCACTGAACACCAAATCCTTTAGTTACATTCTTTCAAGACGCTATCAATG +ATGCAGTTGTGATGATGTCTGGTACAAGTCCTAACCGCTTCTCTGGTCTTATAGGTCATA +CAGTTGCCCAGTACCAAGTTACTGAACAATTCGGTCAAGCAATGCAACGCTTAGATCAGG +ACATACTGTGGAAAATGAACTCAGGACAACCTGTAGATAAGAAAATGATTCATCTGCCCA +GTACCAAGTTACTGAACAATTCGGTCAAGCAATGCAACGCTTAGATCAGGACATACTGTG +GAAAATGAACTCAGGACAACCTGTAGATAAGAAAATGATTCATCAAATGATTGATCAGGC +TAATGTTGCAGATGAGATCAAAGCTATTCAAAAGGCGATGCAGCAGCATCATCTAAGTTC +TCTAGCAACCCTGCTTGTTTAGCTCGGCTCAATGCAGTCTCAGCAAAGCCTGAATCTACA +TATACATTCCTGTGGTACTTACATGCCTGTTAAACAGAGTTATGAGCCTATGAACAACTT +GATTAAAGCAGGTCGAGTTTGCGAGGTTCAGTTATATAACTTCTTAGGTAAAAAGAGCAT +TCGTATGTACCCCGAAACGCGGCAAGCTATGAAGTTCGTAACTAAGGCGGGAACTAAGAC +CGCCGAACGTAAGTTCCAATTGACTGCTAAAGAGTTAGGTCAGAACTTCTTTGAGAATCA +ACGGCATCAAGGTCCGTCTTTAGCCACGTCCGGCGGGACTAAACGCGAAACGCTGGTAGT +CGCCTAACATGTGTACCCCTCCCCGTCACCTTTTTTCTGTTCCTTAGATAAACTAGCACT +AGGTTTATCTGAAGAACAAACAGCAGGTCTGACCAAAGGGTTATTAGATGATTATGTTAC +TTCGTAGATCCGGTGTTGATCATGAGAACTTAAATAAGATCGCTGATGCTATCTATAAAG +GTACTCTGAATGTAGGTACGGGTGGTGCTAAGCAATTGCGTAAACATCTATTTAGGGATT +CGAATATGAAGTTCGTAGGTAAAGATGGTGGTCAGTATAGCTTAGGTGATATTGTGGACC +GTAACACTTGCATGAACTTAATTGATTATACACGTACTACGTCTACACGTATAGGGCTTG +CTCCGTTTGGTATTAAGACCACTGCTGACCTTGACAATATACGTCAAGGTATCATGAAAG +ATTTACCCGCAGACGTTGACATGGCAAAAATCCTCCCTATAGTTTCATGCAATCCCGTTA +TGACAACGGAGAGGAATTTTCTCAACATTCACTCCATATCAGCTGGTGCAACGTTGTGTT +TACCGCTAAGCGTTTCGTACAGATCGTCCGAGTGCAGGCTTCAGGTCCTACTATGGGTGA +GGCCGTTCCTGAGACTATCCGTTCATTGAACGCTGTGGCAGGTGATACTTTCCTATCTGA +TTCAGGTTTAGATAACGTGGTGGATATGGCGACTCAGGTTGCTAAGATGGGATTAATACG +TACATCGCCTGAGATCATGAAAGGTCTGGAGAGCATTTTGAATCCCATGAAGAAAGTGTC +TAGGAGTGAAGCAAACGATTTGTACGATCTACTGACTGGTCTATTGAGGACCTAAGATTG +ATGGTGAAACACCACGACTCGTTATGCTGATCACTTTGTGGTTACTACCGGTTTTCATGA +GGATACAGCTTATTACGGTCAAGCTAATCGATTCATAAACTTGCCTGAGTACGTTCAACA +CATGCTGGGTCCCAACTAAGCATAGGTAGAGACGCTTAAGCCTACCGAAACAGACAACGA +AGGTGGTTAGGTTGGAGCTGACCATGCGCACTATACACAGAGGTGCACGGACGAACACAT +GGACCGTATCCGCGTTCCCCGCCGGTATCAATCGACACCCAGAGCTGACCCTCCCCAGTT +ATGAGCTGTGATGGCAGCAGGTGTTATTCATCTGCTGAGCCCGGCGGCGTCGTAGTGTGC +AGATTGGTATGATAGGTGGTGTTGGCACCACTGCATTTAAGAGCGCAGCTAAAGGCTCAG +CTAACGGTATTAAGTAAATGAAAGAGACCTTGAAAATGTCTGATGAATTAACGGAGGCTG +TAATCAAGGAACACAAAGCTCATGGTACTAATATTGATATGTGGTCGAATGATGTACGTA +TGGCTATGGAACAGAAAGTGTTTTATGAGGCTGATAACTTAGCGCATGCGATTCGTCCAG +GTGAAGTCCCTGCATTCATGGAGCATAGTTCTGTGGGTAGGACCATCTTCCCTTGTTCAC +GTTCTCTGCTTCCGCTGTGCAACAAAAGGTACTTCGTAGTACTTATCAACGTGATGGTCC +TGTGGGTGTGGCTTTATTAGCTGCTGCACAGTTCCCATCTGCTATTAAACCGATTTTCAT +AATTAAGCTCCTAAGAATTGATCTTTCATGTGTTGAAGTGATACAGGCTTAACCAAACCA +AAACCATCATTACATTCGCATTGATTGGTATGGCTAAGAATATTAAGAAGGGTAAGGAAC +CTGAAGAAGATTTGGCTAAGACTTCGGTTCACACTGTGAGTATGCTAGGTACTGTCTTGT +ACCTGTCAGAGATCATCATGAATAGCAGTTTAGACAGTAACAGTGCTGCGGTAGCACCCG +TACCTAGTGCAATGACATTAGGGCAGATATCTATGTCGGGTCAGCTTGATTAACGGACAA +TTAAGAATGCTACACATTTGGGTTGTTTAACATGTTTCGATCTATTCACTTCAGCTATAG +ATGATTAATTATGTCGCTTAATGAGAAACTATCTTATTCGGAGCTTGTAGTCGAGTCCCC +ACCTACAGGCTTCGCAATTGGCTTCAAGGATTACGGGGAACAATCAGATACAATTAACGT +ACTTGTAAATGATGTAATAGCTACGGAGGCGGGTTACACCGTCTTCCGTAAGAATGCTCT +AGTCATTGCACTTGAACCTGCTGTCACATCAGGCATTTTCGCAATTGGCTTCAAGGATTA +CGGGGAACAATCAGATACAATTAACGTACTTGTAAATGATGTAATAGCTACGGAGGCGGG +TTACACCGTCTTCCGTAAGAATGCTCTAGTCATTGCACTTGAACCTGCTGTCACATCAGG +CATTGTACGGCTACAACGTGAAACTAATATTGATAAGTCCTTTCATATCTTTAGTGCGGG +TGCTAAGTTTGTCGGTGCTAATATGGACGCAAACTTTGAGCAGATTTTACACTCTCAACA +AGAAACCCGTGATGGTTTTGATAAGCTGTATTCCGATGTTATGCCATTGGTGAAACTAAT +ATTGATAAGTCCTTTCATATCTTTAGTGCGGGTGCTAAGTTTGTCGGTGCTAATATGGAC +GCAAACTTTGAGCAGATTTTACACTCTCAACAAGAAACCCGTGATGGTTTTGATAAGCTG +TATTCCGATGTTATGCCATTGGTTAAAGGTCATGCAGATGCTTTAGCACAGGCTCATGCA +CCGTCTCAAGTTGCTGAGGAGGCTGCTGAAGCTGCGGAGGAAGCTACGTTCCGATTTCGA +AGTGCTAGCAATGTTATTGATCGTACAGGTTTAACCCAACAAGATATTAACGATGTGTTA +GGTGTTACTACCAAGCTACCCGCTGTTTGGGGTCGCGGTACTGTTATTGATCGTACAGGT +TTAACCCAACAAGATATTAACGATGTGTTAGGTGTTACTACCAAGCTACCCGCTGTTTGG +GGTCGCGGTACTATCCCGTCTATACTGGATCACATTAATACCAACGACTAGGGTGCTATC +TGAGATGGTTCTCTGCATTCCTTCCATGAGTGTGTTACATCGGAACGTTGTAGTAGTCTA +TTAGCTATCCAAATGGGATTCCCAAATGCAACAGCTTTAACTGATAGTATTGATTGGTTA +GTTACAGATTACTGCTTAGGTTTACGTAAGTGTATCTACGCACCGCGTGGTACTTATGTA +TTTAACCGCCCTGCGCGTACACCTCACAGTGGTAGTCCTAACCGAGTGGATTCGTTCCCA +AATGCAACAGCTTTAACTGATAGTATTGATTGGTTAGTTACAGATTACTGCTTAGGTTTA +CGTAAGTGTATCTACGCACCGCGTGGTACTTATGTATTTAACCGCCCTGCGCGTACACCT +CACAGTGGTAGTCCTAACCGAGTGGATTCGGATTGCAGTATAATCGGAGATGGTACACAC +ACTGTATTCACACGTTCGGTTAAACGTTTTCTGGTTAGATGAATGATGACACCAAGTTGA +ATTAGTGCAGAGCTTTAAACCCTCTATTTCGCTCTTCTAATTGGAGTGAGGTTGTTCCTA +CAAGTCATTTCTTAGTAGTGATCGAGCATGACGCGTATGAGGACGATATATGCTACCTAT +CACCTTCAACAGGCACACGTATATTTAAGGTAGCCACGTCTATTTCTGCCCGTGAGGTCG +GAGTATGACGCTTGCTCTGCCAGGTGGCCAATTCATTGAGGAGTTTGAGCTAATATCGTT +CATTGACCTCTTACTTAGATCGCTAAATTTTCAGCCGTCATGTTGGTTCTGATGATTATG +AAGCCTATGATAATGCTAACCGTGACGAAGCTATATTTAACGTACATGACTGTTATCTGA +TTTTTCGTAATCTCAGTATGCAATCCACGGGTATCTACAGTCAGGGGTTAGACCCTTAGC +TGTGAATATCGTACCGCCGGACGACGCGTGCCAATCTACCCCGGCGTATCTTGTAGCTAA +GCTACCACCAAAAGCATAGTCGTATCGCATTTCCTTACGTTTACGCCTACGCCTCTTGTA +GCACCATCGGTTTCTACTTAGAGCAATCCGCATCTAGTGCGGAGAACTCGGCGGTTCATA +TGTCCCATTTGTCTGGGCTTCAGATTAAAGGTGCTGGTACGGTTATGTTGCTCGCTGCTG +CATAGGGTAACCATTATAACTGTGTAAATAATATCTACTTTACTGAGTGTGGTAAGCTTC +TGACGTTGGTTCAGGGCGCTTGTTACTTGCTAAAGCATTCCAAGCTTCTATGGAAGACTT +TGAATCATTCTTAGCTAAACCACTATCAGGTATTGGTGGTTGATGTGGAGAAGCGTGGTG +GTAAGCATGACAGTTCGCCCATTCAGGTTAATAACAACCGTAACACGTTCCCTGATATAC +GATCTAACGGTACTAAGGTTGGTCTGTGGGGTAAGTCGGGAGATAATAACCGCGTTATAA +TGTGGGATCGTGAGGGTCGTGGTGCTGCGCCGACTTACAACAGTTTTGGTGCTATTCTAG +GGTTAACCCTGCATCCTGACAATGTAGCAGTTACTAATGGTGTATTTATATGATCAAATC +ATCAAAACAATGCTACATACTGGTGTAATTGACAAAGTTGAGGGTTCCCGCCGTTCTCAC +ATTATGGGATTGAGGTCCCAATATCTGGCAGGGGTAGAGGGTACTTACACGGTAAAGGGC +AACTTAACCGCCTTATGAACTGTGTGACTGAAGCGTGTGATGTGGAGTTATACAACGACC +ATTATCGTAATAGCTTCACAGGTGTAGGTTTTAAGGAGAACGTTTACTTAGGTAAGACTG +TTATCAATAAACAAGTACCTGCATACTATCAGTCACCGCATACACTCACGGTAAAGGGCA +ACTTAACCGCCTTATGAACTGTGTGACTGAAGCGTGTGATGTGGAGTTATACAACGACCA +TTATCGTAATAGCTTCACAGGTGTAGGTTTTAAGGAGAACGTTTACTTAGGTAAGACTGT +TATCAATAAACAAGTACCTGCATACTATCAGTCACCGCATACACTATTTTCACCCAACTC +TCTGCGGTGAGGACGTGGGATAGTCCGCGAACGTCTGGACAACCAAACCGGCAGCATGTA +AACCCTGGCAATCAGCCCCCGAGGCGTCGGGGCACGCTGAGCCTTCTGGCTACAACTTCG +GCACGAGGAGTCCCGAGTAACCAGCTTATGCTGGACAATCCATAGTTCACTGAACCTAAA +CACGTGGGCCTTCCCCACTGTTACCAGTTTAGCGTTTACTGTTAAGTCGTTAAGTTTCAC +ATTGGTCATATGTAAGCGTTGCGCCTAGTCGCACCAATTGCGTGCTAGTTGGAGTTCCCC +AACCCTATAAGTGTTACACGTACTTCACGGGATAATTCATCACGTTATATTGATGAGCGA +TTAGTAGACTGAGGCTGTGTGGTTGCCATTGGTTGACGCGTGGCCTTGGAGGCAATGCGG +ACACGCCCGCGCAGATTCGGATTACCGCGGACGTTCTACAAGTATGCCACCTGGCAGGAG +TCGAAGAGGACTGCGACTCTCAAATCAGTTCCATCACCCGGTTACTTGTCCCCATGACGA +ACAAGAACTAGTTGATCGGCCGCTTATTTAATCAGCGGTATAATTAAGTACATTTTATAG +GCAGATTCAGATGCTAACGCGACTGCTTATATTAAGGTAAATATCAGTGCTGATAGTGCA +GCATCTAACTTGGGCTTTGCTTCTAAGTTTGCTGTAGCAGCACACCGTACAAGTGCTAAG +ACGCTGACACAGTGCTGATAGTGCAGCATCTAACTTGGGCTTTGCTTCTAAGTTTGCTGT +AGCAGCACACCGTACAAGTGCTAAGACGCTGACACGTTATAGTTTACATATAGTTTACTC +TTTACGAGCGTCTGGTCAAGGAACAGGGGACTCGGGCGTTGTTACTGCTGCCCTTGTTCC +TGTGGGTAGTTCGCATTGGTAGCCACGCGATCACCGATGACCGAATTTACGTCACGCTTA +AAACGGCGAGCATGGGACGAATAAAATTGCCTTAATCGTAAGTATGCAGGTATTCAACTC +ATAGGGTCACAGTCGCTCATGTCCGACTTCATGTCAACATTTCTTTGGTACTGCCCCTGA +TAACTGCACAGTTTCTGGTGGTGGTAGTTCAGTAGCGGGTGCTATTGGGTGGTACGCGAC +CCTGAGACTGACTTAATTTACCGTAGATACTGCGTAAGTAGTCAAAACTATTCCGAGTTA +GAATCATCTTTACTACCTCCCAATTTATTCTCAATCTTATCGACTGTACGTACATTGATG +GTATAAACTTCCGTGTTTCAGAAATGAAGCAAGCGGATTCTACCTATCCTGAATCTGACT +AGGGTTTGGCTACTGTATATGTTGAAACTGATAAGACCTTCCAACCTATCGCAGAGCGAG +GTTCGGTTAAATACTTATCAAAGTAAGATACTGATAAATTAGCAGTACGTTTGGGTAATA +CACCTGAAGCCGATGGTGATGGTCAACTGTATAAAGGGCGTGGTTATGTTCAGATCACTG +GTCGAGCTAACTATAAGTTCTTCAGTACGATTACTGGTAAAGACTTAACGTTTGGGTAAT +ACACCTGAAGCCGATGGTGATGGTCAACTGTATAAAGGGCGTGGTTATGTTCAGATCACT +GGTCGAGCTAACTATAAGTTCTTCAGTACGATTACTGGTAAAGACTTAATGATGACTCCT +GACTTAGAACTAGAAGTTGAGGTGTCTACTAAGATCAAGACACATAGTATGCTTAATGGT +TCATTCACTGGTGCAGGTTTCCGTCGTATGCATCTTGTGTGTCGTTATGAGTTAGCGCAA +TACATGGCAGGCCAGCCTATGTCAAGGTGCAGTACTGGGCTCCGATACTCGCTAACACGG +GACCAGTCTAATGACTACTTCGAACGTGAGAGTTGATCGACCGCGTTTTTTAAATGCGGC +TTCTCATTGAAGACTTCGGTAACAAGTGTCCCATGCTGCTCGTAACATCGTCAGTAGTAC +AGATCGTGCTGGTGAGATCACACAAAATACTATTGTATTCGAGACAGCATAACGGAGTTG +GTATGGATTACGGGTTACATCATGATGGTACACCTAGAGGACGTGGCTTCTTAGGTGAAA +TTAGTAAAACTTATGGTAGTGTGATGATTGAGAATAGTATTGGTGGATAGGTTGACGGGG +AAGAAGTAGATATACCTACTATTACACCAATGTTAGAACTCTCGGAGATTAAGCAGTTAC +AGGCTATGCGGGATGGTGATGACATACCTTAGATATACCTACTATTACACCAATGTTAGA +ACTCTCGGAGATTAAGCAGTTACAGGCTATGCGGGATGGTGATGACATACCTCAAGGTAT +TACCCGGAGGGCTATCCAACATGCACGTAAGCGTAAGGATCATCGATCACCATACTTCGC +AACAGAGTACGACTACCTACTGAGTGAAGATATGCGTCGCATCATAGGAGTAGATCAATA +ACTAAGAAAGTAGAGAGTGCAAGCGTAAGCACGTTAAAAGCGCTACATGAAGCGGTTGTT +CGTTATATGCTTATGTGCAATCAGTCTGCACTCACTGATGAGGATGCTGAACCGCAATAC +CACGAGGCAACTGGTGATGTGATTCCTACAGTCTATATTCCCTTGGTTGCATCTGAGCTT +GAGGTGTTCGTATCGTTCGTGAAAAAGAACAACATCACAGCTAAACCTGATGTAGAACAC +TTCTCATCGGCTTGCGCACTCAGCCTCGCAACGAAGCCCCGATCTTCGGTTGCACATTGC +TCTTTCAGTTCGGCTGGACTGACTAATGAGTTAACCGGATACTTAGGTGTAGCTCTTGAA +CAGGAAGTTCAATCAATTGTTATGGTCAATGAAAACGATGCAGCACTTGCTGCGTACCTA +AGTTAAGGAGTTCAATATGTCGTGTATCCAACAGCAAACGCTTCGACGTTTAGACTTACT +GATGCCTAAATGTAAGAAGTACAACGATAACCCTCAAGCTATTCCTTTAGAGGAACGTGA +GGAATTATCAATGATGTTCGCTGCCACATTCAAGAACTTTAAAGAGTTCGCTGAGTTGGG +TATGCGATACCTTGGCTTTAAGCTATCTATGGTTCCAGAAGACATTGCAGAGTTCATCCT +GCCTGTAATTCACATAGTCTTCTAGGAAAATTGATCTTCGATTCCACTAAGACGGACGGC +TCATTGGGTGGTGGATTGAATGGTGGTCACAATAGTCGTGACTGCGACGTCCTCGATGGC +AGTGAGTAATATGGACGGGACATTTAACGTGTGTTAGCGAAGGCTTTTCACGGTCAAAAA +TTAAGAAGCTGCAGCATGGGCAAGTTAGGACGCCGGTGCCGTGGCAAGGGCGTGCGTGTA +TCGGTTGATTAAAACGCTGACTACTGGTCTGCAGTTCTACATACGAGTTCCTTGCTAAGG +TGCGCCGTGGCCATCTCTGCCTAATTACTGAGTCACAGGCTAGCTAAATGAAAGTTTGTC +GGATATAGGACCCTTTGCATGGTGTGAACCCGTCCACTTGTGAGCGACCTCAAGTCTAGC +CTATGATTCACGGGTCTACGGGTACTGTTCTTATATTCTCTCGATGGTCTACCGTTATGG +ATTAGCTACCTGACAACGTCCTGAGGCGCCATATCCGTGAATGTGTATGAATGGAGATTC +TTGACTTCCGGAGAAATGTGGTTGCGGCTAAGGCTTGAAATTTTTGCCGCACACACCTAG +CTCACCATGGTCAAGCTAAATCGACCCTAGCTGCTTTGTACTGTATTTGGCTTCTTATCA +TAAACCCGACTGCCCGTACACTTATTGTGTCAGGTGGTGAGAAGCAGGCATCTGATGTTG +CATTGCATATGATTCGGATTATCATTAACTGTTCTATCCTTTGTTGTTTATGCCCAGATG +CGTCCAAAGGCGGTAGAACTTCGGCTAGTGCGTTCGACGTACACTACAGCCTAAAAGGTA +TTGCTGAGTCTGCGTCTGTATCTTGTATTGGTATTACGGCCATGGCAGTGGTGACTGCGC +ACGCTCGCTCCTACAACTGACAGGGTATGGGTGCTGACTTTATGCTAGCCGATGATATGG +AGACTCAACGTAACTCTATGACCCAAACTGAGCGTGGGACGCTGTTGCTAATTACTAAAG +AGTTCGCTGCTATCTGTATCTCCGGTGAGAATATGTATTTACGCACACCGCACACTAAAG +CCTCTGTGTACAATTGCGGCATTAGCCTAGCATCAGACCTGGTATCGATGCAATCTCACT +GTGTCCTTTCTTGGTCAGGAACCAACGATGCAAGTTGGTGCGCACGTAGGAATGGTAGCT +AGTACGCAAGCTCCGGCCGTCGAGTCTTAAACGGTATCAAAGTTTGTACACCTGCCCCCA +TGCTTCCATCTAACCACACCCGTCATCGAGATTTGGGATTCTTGATTGTACGCTCAATCG +CTCTCTACCTGTTCGTGGTTACGGCGTTCGTGTTTTGTATGGTCATTACCCTATCGATAA +CTAAGGCAGAAGTTAGCCTGGAAGAGCGCGTCAAGCACCCTTACGGCTAGTCTCGGCCGC +CGCCTAGAATGTAAGGGCGCTATGGTCCAGTTCTGTCGGGGGCTTTTAGCACACAGAGGA +TACATAAGGCTAATTGCCCTAACGTGATCTGAACTATACGCCGCCCATCACCAGTTAGAA +CTCTAACACTATGGTGCAGGTGTGACAATTGCACCTATGAAATACACGCTTACTTCTTGC +CCGTGGGGTGCCGGTTTAGGCTGTTAAAAGACGATCCATAGTTGCTGAGGGAAGCTTCCT +TCCGACGAACAATGGGAGCACATCACCGGCTATATACATGAGCTCACGGTCCATCTTACG +GCGCCTCATATGTTTAATCGTGCATTAATCGGAAACGCTCACTTACAAGCAGGTGGTCGT +GTTGCTGGTCAACGTGGTAAGCCGACTCACCCTGCACATTCGCTGGTCGAACTCACGAAT +GTAAGAACCTTGAATTAAATGCTAGAAAGGTCGCGCCAACAGATTTAAGCGATCAATGAG +GAAATCTTACAAGAGAAAGAATTCGAGTATGGTGATGAGGGTTTCTCATTACAGTACATG +CTCGATACAACGCTCTGAGATGCCTTCGGAACGAAGATTAAACTTTCTGATATGATTGTA +CTAAGCGTAGGTAAAGACGAAGTGCCTGAGTCAGTACAGGACGTCGCAGAGCCTCATAGG +TTATTCAAGGATACTGCTGAAGCTATTAACGATTTGCGAATGCACCATGCTCCCGCGGTA +CCCGATGTTTTTGTACCATTTCTACATGAAGTGATGACACTTGATCCTGCGGGTTCATGT +GCTGGTGAATTTTCTTATGCCATTGGTGGTACTAGTACATCTTGTATCTATTTTCGTTCC +GTAAGTGGGTTCGCAGGTGGTATGACTGAAAAGAATATGAACTCCGTGTTGCAGAAGATG +ATTGAGCATAACGTTAAGTTACTCGACATTGAGAAGAACATGGGTCATGGTACTGTTGCT +ATGTTATTCCTAGCACAGTTAGATAAGCTGAAGCTTCACGCTTTAACTTCAAACCCTGCA +ATTGATGAGTTTAAGAATCAGCTAGGTATGAGTTACAAAGAAGTACACACTGCCCTTAGT +GGTATTGGTATCACCGAGTATTATGTGGTAGGTCAAAAGGACCGTCGGAGCATTGATAGG +ATCTCACCTTCGACTCGTCGCCAAAACTAATTTGGAGTATCTACTCGAGCTATACAAGAC +GTTCGGAATCATTGCTCACCACATCCATCTGGGAAGCGTATGCAATTCTCTGGTTTCTGT +CAATTAGGGAACATTACGTATGATTGCAATAGTTTAGTCCATGAGGACCGAGCTGACTGT +GTAAAACGTGTGGTGGAAGTTCTAAAGACGTTTGTCGCTAAACATGAATAAGAGACTGCG +GTGTTGAGTCAGGAGGCTGCTCATCGAAAGTTCTTACGTAACCCTATGGGGTATGCCCAC +GATGATCCTTGGCATAACTCTAAAGCGTATCGTAAGCGTTATCATGGGTGTTACAAACAA +CGATCTACAAAGAAGCAGTTACTAAGAAGTGGATAAGGTGGCTGCTTTAGACCGCAAGTA +TAATGGTTTGATTGATCAAGTACAACGTAACGATAAGGCTGTACGTGTTCAACTGGATGC +ACTTGCAAAGCCTACAGTATGTCCGTTGTTAACTGCTGTACCTAAGCATGTAACCGACCC +TGTATAGAAACTATCATCGCTCGGATTAAAGATGCACGATTTATCCTAGCATTGCTAAAA +GCATTAAAGAAGAAGTCAAATATCAAGTACTAAAGTTATCGTTGCTAATGTAGATGTACC +TAAGTTAGCAAGGGGTGTATCTAATGCACTAAGCGTCGCTAAAGCGGTTAGGACCACTAA +GTTATAGAAAGGTATGAATAACGTTGAGAAAGCCCTATATCGAGCTACTGTGGTCGCGAG +GCCCAAGCAGGCTACCCCAGGTTTGTAAGTGTATCCTATGCTCATAGAACCGGATGAAGC +CGTAAAAATAGCCCAGTTTCGTATCCACTTGCCCGGAGGTCTCTTGATGTAGGTGTAAGT +ATCTAACGTTTGTTCAAGCGTTAA diff --git a/example/fna/NC_025457.ref.fna b/example/fna/NC_025457.ref.fna new file mode 100644 index 0000000..f4e3712 --- /dev/null +++ b/example/fna/NC_025457.ref.fna @@ -0,0 +1,712 @@ +>NC_025457.ref length=42654 +GATTGAGATATGATTGGAAGTGATTGGAGTATCTGATTGGTGAGTATAATGTCAAAAGCT +AATTTTGTCTAATATTTCTGAGAGGGTGTCTCCCACTTCCTCGCCCTCGACTTCCCCATA +GCACTCATACGTAATCATTTCTTATGGATTGGAATATCTGAGTGCTTATACCTTATCTTA +TACTGAGTCTTTGAGTCTTCGACTCGTATCATTCATTGATACTCTTTGGTATGTCGCTCA +TTGTATAGATAGTTTGATAGAGTGTCAACATACTTATTCAACTATTTATCTATTCATTGA +TTCGATTCTTATATCCTTGTATAGATTAGAGTGCTTGCCTTTTATGTCTTAACTCTTATG +CCTTTTTATGTGTTCATAGGTATATGCCTAGATATACAGATAGTTTTATTGATAGCGATG +TAGATAGCTATAAGATAGTTATTAGATAGAGATACTTATAGATATAGATAGTATTTATTT +TATCTATTTATACTCTTTGGTCTTCTCTTTATTCTTTATTCTTATACGTCTATCTTCTGA +TTTTCCTTAATGAATACAATAACTTATCTGATTAGAAACACGAATAAATTGATACTTTAT +TAACAATAGATAACATAAGCATAAGTATATAAATCAATAACTTAATAGAATTACTGTAAA +GTTATGTAATAATTATAAGATTCTTTAAATAGAGTGTTGACATAGTTTTTAAACTGTATA +TTATGACAACCATACCAAGCAAACAACGCAAGGTACTAGATAGGGATGACCTACTAGATA +TTCATTAACTTAATTAGATTGATTGCTTAGTTTAAAGACTATGAAATGTATAGGATAGAG +ATAACAAGCCTACGGGTAGCCACTCTATACGGTCTTCGAAAGGTGTACCGTGGTATAAAC +AGCCTCCGATCAATCGAACAAGATAATGAATAATTATTTAAAAGAATGGTTGACAACTTA +AATCAATAGGTTTAAAGTTCACACTATCAAGGCATTGAGCTAGAGTTAGATCACATTAGT +TGATTGATACCAAGCGATAAAATAAATTGAAATAAAGTGTTGACAACAAAATCAGATATG +ATTAAGATGCCAACCATAGCGAGTTAGCTAGACAGTAGTTGAGATGTGATGCTTTAATCG +GTTGACTATCAAGACTCTGAAAGGTTACTCACTACCATGTAGACGATACATGGGTATTCA +TTAACAGATTACTAATTAAATCCTTATAGGTGAAGCCTAGACCACAATACTTTTGTATGT +GTGCAATGTGGTAGGTAATAGGATAAGCCATTGAGGTTGAAGTGTTATAGGTAGGCTGTG +AGGCTGTACTCACAGTTAATTCCAATACATAACACGTAAAGCTATGATAAGGTTAATGAG +TTTATATTTAGCTAGGTTGGGTTGAATGCTATGCACATCGACCTAGCACTAATATAATCT +TGAAGACTGACACAAGGTATTAGCAACAAGGCATGGGATGATGACAGCACTCGTAAGGTG +TTTCCTAGCTAACGGATAATCTGATACCGCATGAGGTGATACCTTGTGTCAATGTTCAAC +CAACCAACTAACATAGGTGTATTATGAAACTGTTATTAACTACAACTGAAATCAACAAAG +CAATCGAATCTATCGAACGTCGTGGTAAACAATTGGATACTGATATCCATGTGGCAGGTG +TGTCAGTGTTAAAGCATGTCGCTGAACATGGCGATACAACTTTGCTTGATAAGCTTGTAG +GTGCTATGCCTAAAGGTAGCCGTAAGTCTGCGTTCTGTGAGTGGGCTTTGGCTTATGGTA +ATGTCCGTATGCTTGACCGTGCTAACGACGCTGATAAACCTGCTATCGAACAAGGTCGCT +TGTTTGCTAAGGATAAGTCTAAAGAGTTCAATGAGGTTGAAGCTATTGCTAACAAGTGGT +ATGACTTCAAGCCTGAAGCTGATTTGTTGATTACCTTTGATGCTGCTGCTATGGTTGCAT +CCATGATGAAGCGTTTATCTAAAGCACAAAAGCAAGGTGCTGAAGTAACTGGGCATGGTG +ATGCACTTAAACAATTACGTGCTTTGATGCAACAACTTGAAACTCAAACTGAAGAACTTT +AATCTGTAGGTGTATGCCATGATTACTATAACTGAGAATTACCGTGTTAAGCATGATGTG +AATGGTGTTATTGAATATGCACAGTGTCGTGTTACTGGTCGCTTTGTTAAGCATGTCGTG +GCATACACTGAATTGAAGTGTTCTTCTGTACTCACAACTGCTATTGCACTTGCTATCTGT +GTCAGTGCATGGGTAGTGTCATTGTTATATATCTTTCTAAATAAATAGGTGAAGTATGTT +AAACGTACCTAAAACAAATCCGAATGTAACTGTAACTTTAAACATCGGCTTAGCTGCGTC +GCTGAACTGGGGTGGATATAAAGCTCAAGAGGCTAACCACGGTACAGTACAGACGCTTGT +AGATGTACTCGATGCACCTCATCGTATCGCTCGTATCATTGAAGATGTACGTGATCTTGC +GTATAACCCTAACGGTCAGGCGTTCTATCAGCAATGTCAGCCGTATGGTATTGATTACGG +ACACGATAACCGTGAAGTAAAGTACAAGGTGGTACAGTCGGGAACTGAAGCGACGTTGGT +TGTACAATTTGAGGCTACAGCCCGTGACATCATTGGTCAGGTGTTTGCACTTGCTGAGAA +ATATAAACAAGACTGTATCGCTGTATGGATTCACAATGATGTGAACGGTGGTATCGGTCA +ATTAATTGGACGTTATAACTATGTGTGGTCAGGTGGTTACTTCAATCCCGAATACTTCAT +TCACTTGGAGCGTTAAATGCCTTACGTCATACCTGTAATTATTATATTCCAAGTGGGTTA +CTGGCTTGGATTCTACTGTGCAAAATTCCTTTAATAAGTGAGAAATAATATGTTTGGTTT +ATCTATCGTTAAAACTGCTGACCTTAACAACTTAAAAGCACGTGTAGCTGATCTTGAAAC +CGATGTAGACGGTGCATTGGATAAGGTGGCTGCTTTAGACCGCAAGTATAATGGTTTGAT +TGATCAAGTACAACGTAACGATAAGGCTGTACGTGTTCAACTGGATGCACTTGCAAAGCC +TACAGTATGTCCGTTGTTAACTGCTGTACCTAAGCATGTAACCGACCCTGTAGGTGCATG +GGAAAGTAAACAACGTGTGTTGGAAGCCCATTTGAAAAGTGCGGAGTCTGACGTGTCTGT +ATTCCAAAAGCAAATGGGCTTTTGGGTAGGTGCAGACATCACGCAATTAAAGTTCTACCA +AGAGTTAGTGCGTAAAGCTAAGGCTAATGTTGAGCGTATTAAACAAGAGTTGTATGAACA +TCTAACACGTAAACCAATCATTGTGCAGTTAGCACCACCTAGTGAAACGGCTGTATTTGT +ACGTCATAAGAAGTACGGTACTTTAGGTCTATTGAAAGGGCATAACATTACTATCCTGAG +CACAGGTAACCTGCTAGATGTAGGTGACGTAATAAATGCCCCACCTGCTGTAGTCCATAA +GTTTTGGAATATTGAACTACGTGACTCGGTGAAGTTAAGTGTTTGATCGTTTCCATGAGG +ATGGTGAGATCATCCACGAACCTGTGTACCTATGTAATGACTGTGGTGAGGAATCTCCAC +ATTCTGAACTATTCCATATCTGTTGTTCTGAGTGTGATGCACTCTGCCCATATTGTGAGT +CTGATGACTTGGAGGAATTATAATGGCTAAATCCAAATTAGCTCGACGTGTCCGTAAGAT +TCGTAACTTAAAAGGTAAGGCGTACTGTGTACCTGTAGTAAATAAACTACACTGTGAAGC +ATTATTAAAAGCTTTTAAAGTAGCCCGTAGTAAATTAGATCGTAGCAAATATTGGCTTAC +TTGGCGAAGTGATAAAGAGTTTATCTTAGTACATAACTCGTCTGTAGACAGTGTTGGTGT +ATATAATCATAATGGAGGTTTCCCATGCGTGAAGCTATAACCCGTTTAACAAAGATTACA +CTGTACACTGCTGCATACTATTCGATTGGTGCTGTAGCTTGGCTGTGTGACCATGAAGCC +AGTAAAGAGGAACATCACTTATGAAACCATATCAACCAATATTAGGTAGCCTAATACGTT +GCCCTAACTGTAAGAAAGTTTATACCTCTTGTCGTTGTCTTTGGTAGTATGTTTATAGCT +ACATTCTAAGGGATGTAGCCGTTAAGCATGTTGCTTAGGTCGTGAGTCTGTACTCACAAT +TATATTTCGCATTTAATAAATGTAGGTGACTTATGAAAGTGTTACATCCATCTTTGAATA +CATATACAACTCTTAAAGTTGATAGCCCTTTGTCTCGTAAATCTACGAAGTTTCTAGTAT +CACCTGAATTTGGCAGTACTGAATTACTTCCGCTAGTAGCTGAGGTTCTTAAAGGTTTCA +CACCCTATACTAATGGTTTGGGTTACTACTGGGAAGAAGATGAAGTAGCTATGGAATACC +TTGGTTCAGGTTGTTTCTCAAGTGTCTTCAAACATCCTAATCGTACTGATCGAGCTATCA +AATTATTCCGTAACTACCGTGAAGATAGTACCTGTTATCAGTACCTACGTTTGTGTGCAA +ACAAGACTATTGATTACGAATGGTGTCCTACTGTGCATAGTTTAGGGCGTATCAAGGTGA +TCAGTTATAACTCGAAGCAAGGTCATTGGGAAACCCGTGATTGTGCTTACGCTGAATTGG +ACTTACTACCTTACAACTGTAATGATAGTGCTGTTTATATGGACGATTGGTATGCTGAGT +TCCGTGATGACGTTAAGGATGTATACTTCCCGTTTGGCGATATGGATTTGAAACCCGATA +ATGTTCTAGGTAAGGTCAACGATGAGGGTATATGTCAATACTTTATCACTGACCCAATAT +GGAACTCTGAGCCTGAGCACTACGAACCCATCCCTGAACCATTAAAGGAACTGTATGTGT +ATCCTAAAACGAATGGTACTTTCATAAACAACCTACGGGAGAGCATTAAACATGGTCGTG +TATGGTAATATTGTAAAAGGTGGTGCTACTGTTCAAGATAGTATCTACCGTGGTATGAGT +GCTATGTTTGTGCATGGCTTACGTTCTGTGCATGACTTAGGTGACGCTGTGTACTTTGAG +TCTGATGTTAACGCTACACATCGTCAGCTTAAAGGTTTGGCTACTATGTCAACGTTGCAG +TTAATTGCACCTTACTCTGAAATTAAACGCCCTACTAGCAATGATACTCGCATGACTCCT +GATGAAGTCAAAGCTATCATTGCTGTATGTGCTAACCCTATTTCTTCAACTGTTCAATCA +TAAGGAGACTATTATGTCTAACTCTATCCGTATCGGTCGCTTAACACTTAACATGGGTAA +TGTAACTGTAGGTGTTACCCGTCACCAATTATCATTGTTCATGCAGTACAGTGCATATCA +ATCTAAGTTCTAAGGCTTAAATATAGCAGCACTTCGATGAGGTGCTGTTAGTATTTAATC +ACAGAACGTAAGGAGTTCTATCATGACTAAACTTAAACAACAATTCGAAGTAGCAGGTAT +CGTAGGTCGCCCTGAACGTAAAGGTTGGAACTTCAAAGCTCAGAAGTCTTACCAACGTGG +TCGCTTTGATAACTTAAAACCTCGTATCGGTTTCGTGTATAACCATAAGGTAGAGCAGGT +TGCTCGTGCTATTGCATTCGGTTTAGAACAACAGTTAACTTACTGTCAACTTGATAACAT +GCACAACCAACCACCTGAAGTACCTGTATGTATTGGTAAGCTTAAAGGTAATGGTGCTAC +GTTGTTCCCTGATGCTAACACACGCCTCGCTATGATGGGTTTAAATGGTACTGCTGTATT +ACACTGGTTAGGTGCAATGCGTGTAGTAGACGAGCTATCAGGGCAACGTGGTGAGGTTAT +TGTAAACGATGGTACTTACATTTACACCTCTGTTGGTGTACTGCTTAACTTGGCTCAGGA +TTGTGTTAAGTCTCCTGAAGCTATCCTTAACAACTACAAAGGAAGTCAACGTGTCCGTAA +AGCAAAACAAATCTGATATGTTTAGTATGGGTATGCGAGTCATCGTAACCAAGCCCACAC +AGGCTGATATCAAAGAGGGTATCAAAGGCGACATGATTGGTCATGTTGATCAAGTCACAC +CCTCGTTCATTCATGTAGCGTTTGAATCTAGTAATGGGCGACGTTATGTTTATCCTTTCT +TTCCACATCAAATCCGTCCATTCTAAGGGGAATTACATGCAACATCTAAACGCTTTTATT +AAGACACACTCACCTCAACAAGTCCGTGCTGTAGTTGATGAAGCTCAACGCTTAGGGTAT +ACACCATACTATAAACCTAACTACAAATATGTAGAGGCTGTACTGTTCCATAGTGATGGT +GGTTTATCCCTAAAGGTGTATCACACTGAAGAACACTCTGAATGGTTAGTTAGTCGTGGT +TATCGCCACATCAAACAGACTCGTCAAATCCGTCGTGATCTATGTGGTGGGACTTACTCA +CAGGATGGTCAGGCTGTACTCGACGTTGTAAATAAGGGTTATGTACCTAAGACCATTAAC +GTACAGCCGTACAAATGGATTAAACCTACAGCTTATAATCCAATTATTAATTGGTTCGCT +GAGAAGTTTATCAGTGCTTATGCTGTAGTGCGTAAGGTAGCTGTTGCATTCATTAACCAC +ATCAAATAAGGAGCTGTACCGTGGCTAAGCGTAAAGAAATTGTTAAGGGACTTACACCTC +AAGAAGAACGCAAACTCTTGCAGTTAGAACGTCGTGAGGCTGATATGGAACGTCAGCAAG +ATCGTCGCTCTAAGCGTCAGGATAAGCGTAAGCAGTTCTACTAATGGGTAGGTCTTACAA +GATCAAGATTAAGTCCATACAGCATTACCGTCGCTGTGTGGATAGCTTGAAAGAGGTAGG +TGTACAATTCTGCTCTAATGATGAAGATGAGTTGAAGATGCTACGCTGTAAAGATTACCG +ACGTAAGGCGTGGTTGTATATAGGAAGCAACAAGGTTGCATGGGTATTCGGAGCATACAG +CGTGGTTAAGTACGCTAAGACGGTTAAGCGTAAGGAAGCAATGGAGCTAATTGGAGATGC +ACCATAGCGAATGGTTAGACCTAGCCAAGAAAGTTCCAGTAGGTCAGAAGCGCAGACATT +ATCATGGGGCCGAGTTAACTAAGGCACTAGATGTATGGAACAATGAGGACTCATGGAGTG +CTTACTGTCATCGGTGTCATACCTCAGCCAAGGTACGTAAACAGTTTGTCGAACGTGTAG +ATGTAACCCAACCAATATACAGGCGATATCTTGATAAGGATTGTCTGATTACTTTGGAGC +AGTTACATGATAAACACTTGTTCAAATTCAAGACGTTGGTCAAGCTGTTACATGATAAGG +GTATGAGTACAGTCACTATCAATGATCTTAGTCCAATGTATAATACAAAGGATGATCGTC +TAGTGTTCCGCTTTAAAGGTGTGGATATTGGTAGAGACTGTACAGGGTTGTCACCTGCTA +AATGGCTGATTTATGATAACCCTGATCGGGAGGGTTTCGTGTACTTGCAAGGTAAAAATC +CATACTGTACACGAGAACCTGTAATATTAACTGAGGATTTATTCTCTGCACAGAAGATCA +GATACTATACTGGTTACTCGACTATGTGCTTATTAGGAACTAAATTTCCAAATGAAACAG +TACAGTTCTTACTCGAACGACAAGCCGTTACTGCCACCGACGGAGATTCCGCAGGGTGGA +AAGCACGTCGGCTTATTAATAGTCGTTGTGAGCTTTTTGGTATCCCTTGCTCTAGTGCAT +ATATTCCCGACGGGTTAGACCCAAAGGATATGTCACCTGAAGCATTAATTGAAACATTCA +AATTCTTGGAGAATTAATATGCGTGCTGTATTCGTACTACCTAAAACACATGCGGAACTT +AATCAGTGTATCCCTACTTCGATCAACAAACTTCAGTGATGCTACGGGAGATAAATGTGG +GCAGCTTGGTAAACGTGTAACTGTTTGGTTAAATACAAAGACTTACCACCTACATACCTA +TCTTGTGTTTCCACACACACAAGTAACACCAAATCAATTAGCAGGTCTACTACAGGGGTT +ATAAAAATGTCAGACTTAAACCTACTCCGATGTATGATGGAGCGTAAGTCTTATCAATCG +GCATTTGCATCCATCCCACAAGAAATGTATGACTTAACTACTCGTGCATTCCTTGCTTGG +TTCAAACTGTATTACAAGCATTATGAAGATCATGAGCGTGTTGATGTAGACACCTTGAGT +AGCTTCATTCGTTTGAAAGGTAATCAATCTCAGGAACAGCTAAAGCTGACTGACCGATTA +CTCAAGCAGTTACGTGAGCCATTGGATGATGCAGTCCGTGCCACAACATTAAACGCTTTG +GAAGAACGTCGTCTATCAGGTGAGGCTGAGATGTTAGTCAAGCGCTATAATGATGGTGAG +GAAATTGACATCATCCATGAGATGCGTAAGCTCGTACAAGCCTCGGAAGTTGCATTAGAT +GTACAACATGCATCATGGTGTGATACCGACGTAGGTGAGCTTATTGACGCTGATGCTGAT +GACTCAGGATATGTATTGGACTTCTTACCTGAAGAACTATATACCTGTATCAAAGGTATC +AATGAGGGTAATAACGTAGGCGTAGCAGCACCTACAGATAAAGGTAAGACTTCGTTCTTA +GTTAACCTTGCTGTATCGTTTGCTATTCAACGTCGTAACTTCATGAAGCAATGGACGATT +GATCTTGAAGACCCTGAGAAGTGGTCACAGCGATTGCAAGAGAAGAATCGCTTTAGACCT +GTATTATACCTTGTGAATGAGGGTACGGCTGAAGTAATCACACCGCGTGTATATCAGACA +GCATTGAAAGTAACCCGTAAGGAAATGTATGAACGTCGTAAGGCAGGTACAATTACTTCA +GACTTCATTGATGCTGTAGGTCGTCGTGATGCTATTCGATTGAAGAACATCCACGGTAAG +TCTGTAGCGCAGGTAGCTAAGATCATTGAGGCACATGATCCGTTCTTAGTCATTACTGAT +ATGACTGGACGTATCCGTGCTAATGGTGGCGGTGGTGGAGCTAACGATATTACACAGCTT +GAAGAAGTTTGGAATGATATGCGTATGCTTGCTGCAATGATGGACTTCATTCATGTAGGT +ACAGCACAGATCAGTGCCGAGGGTTTTGATAACCTGTACCCACCAGTGTCAGCATTACAG +AACAGTAAGACAGGTATTCAAACCACATTGGATTTAGCATTGTGGATCGGTGCTTATGCT +AACCCTGTACCTGATAATGAATTGATGCGTGGATTAGGTACACCTAAAAACAAATTAGCA +AAGAGTGGTTGTAAAGGTGGTAACCAAGTTATGACATTCTTCGAACCTGAAACAAATAAT +TGGGATGCGGTGACTAACTCATGAAAACAGGTGATGATGTAAAATGTATTAATAACTTTG +GTATTTGGACGCTACGTGAGGGGCATGTATATCGTGTCCTTGATGTACGTAATACAGTAA +TCCAAGTCCAAGGTAAACACGGTTGCACTAACTGGTACAAGAAAGATCGTTTCGTTAAAA +TTAAAGAGGGTAATCACATGGGTACATTAACTAAATCTGAAGTTAAAGTAGGCGATAAAG +TAGTACGTATCAGTGGTACTGGGTTACGAGTAGGTGCGGAGTTCACAGTCATTGGTGTGC +GTCCTGATGGTGCTGCTGTACGTTTACAGGGTCAAGGTAGTGGTTGGTTCTGCATGAGTA +CATTCTCTATTGTAGAGCGTGTGAAGCCTCAACCGAACGTACTCACAGATGATCAAGTGT +TTAAGTATTTAGCTGACGGTGTTGAACTTGAATACTTCTTCGATGATGTTTGGCACAAGA +TCGATAACCCGAAAGGTGTTAGTATCCAATTCATTCAAACTACACAGTTCCGTAAGAAGC +GTGAGTTAATGGAAGTGAATGGTATTGAAGTACCTAAAGGTAGTATGCGTGCAGTTCTCT +TTGATGAGAAAGGTATCGGTTACGGGGTATCTTTTAATAAACGTGAAGTGTACAAAGCAC +CTCTTAAACAATTGGGACTCTGTGGTACTATGTATTGGACTGACCCTCAAGAAGCTCAAG +AGGTATTGGAAGCATTACTCAAACCATTTGGTATGTATGCTAAACCTTTGAAATCAAACC +TATTGGGGTCTTAATATGGACTTAGCATTTGTCGCTGATTACTTGGCTAATCGCAAGAAC +CCTGTACAACTTGTCAAACATTTTGATGAAGTTAATGAAAAGAACATCAAATACCCACTG +ATCGGACAGCTTAAATATGACGGCATTTATTGTTTACTTGTGTGCATTGGCTCTGAACTT +CAGTTGTTTAGTCGTGTGGGCAAACCTCTCTACATGGAGAACCTCAACGGTTTTATGGAT +GGTCAGCTTTGCAATCTTGCTGATGGTGTGTATATCGGGGAACTATGTACTAATGAGTTA +TCTTTAGAGGTGCTTAGTGGTTATGTATCACCTAACCGTAAGAAGCCGTGGGATGACGTA +GGGACGCATAAGATCGGTGAACTAGGTTACATAGCATTCCATGATTACTTAACGGTAGAT +GAGCTGTTAGACGGTCACAGCGATACATCCTATCGTAACCGTTACTCAAACTTAGAAAAC +CGTTTGCAGAATGCAGCTATCGTTGGGTACACGGTGAAGTCTACACTGATCTATGATCGT +GAACAGGCTGATGCTTACGCTGAAGACTTAATTAAACGTGGGCATGAGGGTGCTGTCTTT +AAAGACCCTAATGCAGATTGGGAAGCAGGTCATAAAGGTTATCGTGCAATGAAGATTGTA +CGTGGTATCCCTCCTCTTGATCTTCTATGTGTAGGTGTTGTCTATGGTAAGGGTAAACGA +GCAGGTCAAATTGCTGCTCTACGCTTCACCATGCACGGTAATGAGTTCAATGCTGATCTT +GGTAAGGGTTGGACAGATGAACGTCGTGATCTACTAACACTCGCTTACCAAGAGGATCGT +GGTGAGGGTTGGGATTGCAAGGTGTATAGCGGTACGCTTAACGAAGAAATGCGTAACCCT +GTAGGTAAGATTTGGGAACTCAAAGCATTGCAGTATAGCTCAACTGGTAAGGCATTACGT +CTACCAAAGGTTGTACGAGTACGTGAAGATAAGGAGACTCCTGATGCTTAATGTGGATGC +TTTTGGTAATGAGGTAAATGAGGGTGATTCTGTGGTGTGTGTGGTGCATGAGCGTTATGG +TTCAACACGGAATATACTTGTAGCAGGTAGCATTGTTAAACTTAACAAACGTACTGCTAC +TATAGATATAGGTAAGCCTGATTATATCATACGTCCTAGTGATTAGTTTCATAAGGTAAC +GTGTCCATAATGTAAAGTTATGTAACTAACAGTCTGAAAATAACGTGTTTGAGGTTTTAT +AAGTATATGATTTCAAACACGAATATTAGAAGATAGACGTATAAGATAGATAGAATCCAC +ATAAGGAAACTGTATGTTTAAACATAATTTCTTTATCCATGACTATGAAAACCAAAACCA +TCCTTGGTACGGTTCAATAGCATCACCACATTGTCCTGATAACTATATTGTAGCTACTGG +ATATTGTATTGATGGGGGTGACATACAAGCACATTACTTTGATAGTGATGAAGAAGCTAA +GTCACATAAATGGATTGACAAGTTACAAGATTGTAAGATGTATGTAGCACATAACGCTAC +GTTTGAAATCCAATGGATGTTACGAACTTATCCTACTCAATTCTTAGATTGGATTAAGAA +AGGTGGTAAGGTATTCTGTACACAATATGCAGAGTATATGTTAACCCATCAACTTGAGAT +GTATCCTAAGCTTGAAGACTGTGCTATTAAGTATGGTGGTTCTAAGAAGATTGATGAAGT +TAAATTACTTTGGGAACAAGGTGTATTAACTGCTGACATTGACAAAGCTCTACTGATGAA +ATACTTAGCAGACCCTAAACTTGGTGACGTAGCGAATACTCGTCGTGTATGCTTCAGTCA +AGTAGCTTTGTTACGTAAACACGGTATGTGGGATATGTTCATGGAACGTATGAACTCACT +ACTGTTTAACGCTATTGCTAGTTACCACGGCTTATATGTGGATATGGAAGTAGCTAAGCG +TAACCAACAAGCTCAGGAAATTGAAATTGAAAATATTAAAGCGTCCATCTTGGATATGTT +ACCTGCTGATCTTCCTGACGACTTTGAGTTCTCATTCACATCCGCATACCACTTGTCGGC +ATTCTTGTTCGGAGGTACGATTCAGTACAAAGCGAAAGTAAGTTATGACCCTATCAAGTA +TGTGAAGAAAGACTGCTATCAATTTGGTGATAAGTTTGTACCTGTCACTGATGATGAATC +TATACTTGTACAGTATGAGCTTGTGTATGGTGAGGCTTTACGCTTTCTACGTGGTAAGAA +TGCAGGGCAGTTAAAGATAGTTAAAGTAGAGACTGCTGAGGAACTTCTGAAGTGGGGTGA +TAAACAATACCGCTTCAAAGGTTTACTTGATTTCGATACACTACCTAAGATTGTGTCTGA +AGCTTATGTAGGTAAGCGTGCTGAGTTCCGTGGTAAACGAGAGCTTGTAGATGGTACGCC +AATCTACAGTACAGGTAAGGATAGTCTCGATGTACTTGCAGCTCATACGGATGTTGCAAA +GCCATTGAAGAACTTAGCTGCACTTATCAAAGACACCACTACTTATTACCTTGTCGTTGA +TGACAAAGGTAAAGAGTCGGGTATGCTTCAATTCGTAGAGCCTAACGGTATCATTCATCA +TCAACTTAACAACTGTGCAACTATTACAGGTCGCTTGTCAGGTAGTAAGCCTAACATGCA +GAATATTCCTCGTGATGGTACATCTAAAGTTAAGGAGATGTTTAGCTCACGCTTTGGTGT +TAATGGACGTATCGTTGAGGTCGATTATTCTGCTCTTGAAGTTGTAGCCCTAGCCAGTAT +CTCAGGTGATAAGAACTTGATGCGGATGCTGATTGAGGGTATCGACATGCACTGTTATCG +TCTAGCTGCAAAGCTTGGTGAAGACTATGAAAGTGTATTCGAGAAATGCCACAACAAAGA +ACACCCTGAGCATAAGCAATACAAGCAATGGCGTACAGATATTAAACCTCGTGCCTTTGC +TCACCAATATGGTGCATCTGCTGAGGGTATCGCATTTAGTACAGGTTGTACCTTAGAGGA +TGCACAAGAGTTCAAGAACATTGAGTTTGAATTGTTCCCTGAATCTAACGCATTCCCTGC +TAAGTTTGTACGACCGATGGTAGAGGAAACAGGAAATGCTGCACAACCCATTCGTGAGTT +TGATGAAGAAAGTGGTCGTTATAATGTGTATCGTCGGGGTTACTTTCAAGCGAAGTCAGG +TACTTGCTACTCATTCCGTCAATATGATAAATGGGATAAAGAGCTTCGTATTACCGTCAA +AGACTACAAAGACACACAGATTGCAAACTACTGGTGTCAAGGTGAAGCATCCTTTATTGT +TCAAGCTGCTTGTGGGCGAGTCATCCGTGAACTCATTAAACGAGATTTTGCAGATGGATT +GGTCGTGCCGATCAATACCGTACACGATGCAATCTACTTGGATTGTGCAACGGAAGCACT +TGCTAAAGAATACGGGGCGTTGGTAAGGGATATTATGGAGGCTACTCCTAAGTACCTTGC +TGAAGTTATCCCTGCACTTAAAGATTGGAACTATCACTTAACACCATTCCCTGCTGCTGC +TGAATGTGGGGTTAACATGATGAACAAAGAGGATATTTAATGCATATTGCATCCACTATG +CCACAGGGTATATTCTGCCCGTTACCTGCTGTCAGTAACTTAGAGTTCTGTAACTTCACT +TACATGTGTGTTCGTGACCCTCTTGCATTTGAGGGTGCATTACGAGTACCTGAGAACTTA +CAGGATATAGTTATCCCACTGTTATCTTTGATACTGGATAAGGTAGACACGGATGATTAC +ATTTATGTCACAGTTAGTCGTAAACACCTACAACCTAACACATGCGGTAATCGAGCAGGT +TGGCATGTGGATGGTTTCCTAAGTGATGATCAATCATTTATTTGGTTCGATAAGTTACCT +ACTCAAATTGCATTGGGTGGCTTTGAGGTTAGCCCTGATCATGAACAATCATTAGAGCAG +TTTGATGCCCAAGTAGATTACGGGAATATACAGTACACTGAACCTGCTATGTTGTACGAA +TTAAAAGATTGTGTACATCGACCAGTCTTCAACCACACTAATGACGTTCAGTTGCGTACC +TTTGTTAAGATCGTAATTAGTAAAGAACGTTTCAATGGTATAGGTAATGCTTGGAATTAC +CTACTACCACACATCAAACCTACTAAACAGCGTGGTGAGTCTCGTAACCACACTGTAGTT +TAACCTGTACTCACAACTCAATTCTTAAATTTATATCGGAGATTATTTCATGACTCAATC +AGCTATCAACTTCTTAGACCTTGCACACGGTATCGACGTAACTACTCTTGACGACATGAC +TGATGTTTCATCAGGTGGTGGTGCTAAACGTGGTTTATTACCCGCAGGTGTAGCTTTTGT +AGTATTCAGTTCATACATTGAGTATGGTAACCAACCACAAACTTTTGAGGGTAAAGCTAA +AGACCCGCTACCTGAGTTCCGTTTAGGCTTCCACGTTGTAGGTGGCGTAGGTACTAACAA +AGAGGGTGAGCTTGAAGATTATGTGCAAGATGGTTTCTGCCCTACAATCAACGCATTCGA +TTGTAAGTTGAGTACGAATGAGAAAGCCCGTGCTGTTGCGTACTTCAATGCGATTAACAT +TGCACCTAAAGGTACACACTTCATTCAGAAGTTAGGTACATTATACACAGTGGAAATTAA +GATCGGTAAGAATAAGAAGACTGGTAAAGATCAGAACGAAATTGACTTCCGTAACTTACA +ACCCGCTGTGGATGCTGCAACACGTAAACCATATACCACATACTGTAATGCTGCTGATGA +AGTAGTACCTATGGGCGTAGTTAAACCTGAAGATGTTAAAGTCTTCTTATGGAATAAACC +ACCATCGGTTACTAGCGAACAGTATCAAGCTATGTGGGATAGTATTGAAATTAAAGGTGA +GTATGAAGTTAAGGATGCTGATGGTAAAGTAACTGGTAAGAAGTCTAAAAACTTCATCCA +AGAGAAATGCTTATCCGCTCTGAACTTTGCAGGTTCAAGCCTAGAGCAGTTATTATCAGG +AGGTGTTATGCCACCTCTTGACGCTGATGAAGCTGAGGCTGCTGATACACAAGCTAAACA +GGAAGCTGTTAAGGCTGAGGTTGTTGAAGAACCTGAATCTGAAAATGAAGTTGCATTGGA +TGTTCCTGACCTCTAATGTGACCGAGTGAACCCTACGGGGTTCATTCACAGAAGCGATCA +TTTGTGATTGTTTCTCTGAATGAATCATAGGAGACTTAAATGACTGATACTAAACGTGCT +ACTGGGCGTACTACCCGTATGATATTCAAGGTTGGTGAGTTTCTAGCTGCTAACCCTGAT +GAGACAGCTACCATTATAATTCACTCCCAATCGTGGGGTTGGATGCGTAACATGGTTAAT +AGTCTGCTCTCGTCGGATATGTCTACCCGTATTACCATTAAATCCTACAGTACATGGTCG +TCATCGGGTATAGGTAAACGTCCTGATTATTTCTTTGATCACCACTGTTTTTATGACCAG +TACCTACGGGCTAAAGCTACACTGGAATATGTAGAACAGGAGTACACAAAATATGACGTT +TGATCTAAGTCAATTTGGTTTAGATGCTAAGGCGTTACAATCTCAGGATACATACAAAAC +CTCAACGGCAGGTAGTGTTCTATTACTGGATGGTGATGGGAATGCTTACGAAGCTGCTGC +GGGTAAAGCCAAACCTGAGACCGCCTTACGTCACTTTGAACGTAGTATTTATGAAGCTAT +GTTCCTAGCAGGTTGTGAGAAAGCACGAGTACATTTAACCCCTCGTGGATGCTTCAAGAA +TGGTCGTCATTTGCTGTTAGGTGTTAAGCCTTACCAACTACAGCGCAGTAACAATAAAAA +GCCACCACTGGTCGCTGTGTTGCGTTCTGAACGTGCTATAGACTGGTTCGCTAACAATGA +TGATATTGAGATCATCCTGAACTATCAGATTGAAGCCGACGATGCTTTGATGATCGACCA +TTACCGCATGACTAATGGAATCCTACTGAGTGCGGATAAGGATTTAAACTTGAGTCCTTA +TAAGTCATACAGTATGGATGATGGTAAACATATAGTGCTACCTGATGGTGATACGTTTGG +TTGGATTGATCGTAAGCACTGGTTAACACCAAGTCTTAAACCTGCATCTAAGATGATCGG +TAAAGGTACTAAGTTCTTCTTATCTCAGATGCTCATGGGTGATACTGCTGATAACGTCAA +AGGTATTATAAAGCTCAATGGTAAAGCGTGCGGTGAGGCAGGTGCTTATGAAGCCCTAGA +CCCTATCAAGGATAAACATGAAGCTGTGAACTTCGTTATTGAAGCTTACAAGAAGATTGA +TCAAAACATTATCCCTGAAGCTGAAGCTATGTGGTTATTGCGTAATGCACAAGATAACTC +ATTAAAGTTCTTTATGGAACATGACCTAACTGATAGTAACTTAAATTTCTTAAACGAATG +CTACCATGACCGTAAATGGAAAATGGAAGCTGATGATTATGAGGGTGACCTAAATGAAAT +ATAATATTCCTGAAGCTGTACAGCACGTTATTGATCAACTTAAATTGGTTGGTATTGAAG +CTACGTTGGTAGGTGGTGCGTTACGTGCTGCTGCTCTTGGTGGTACATCCAATGATTATG +ATTTAGTTATATTTGGTGAACGTGAGGACTTCTTCCACACTGATAAGGAGATCGAGTATT +TAGGTTTCCGTAACCAACACCATGACGAATACTGTAACAACGAGGGTTATGTAGCAGATT +GGCGTAAAGATGATGTGAATATCATCATGTATGATTCTTGCAAAGTAGCTGACTGGTATG +CCTTGATTGAAGTGTTTGATTTAAACATCAACCAATGGTATATCAACGAAGCAGGTGAGC +TTGAGAATGATTACTATGACCCTGAAACTAAGCTCGTAAGTATTAACCCATTCCGTGATG +GTCTAGGTCATGCTGAACGTCTCACCCAACGTATTGAACGCTTCCGTACTATGCTTCCCG +ATCTTGATTGGTCTGAGATTGAGAAGCGTCGTAAGGTTAACGATTACCTTGGTACGGAGA +TCGTAAGTTATGTCTAAACCTTTACAACGTATCCCACGTAGTCAGTTATTAGCTGTCACT +ATGTCCATCCTAGCCAAGCAAGGCGGGAAGTGTCCTATCTGCTGTCGTATGATTAACACT +AAGGTTGCAGGTCGATCTTCAGACTACGTAGCCGATCATGATCATAAGACAGGTGAGATT +CGTGGTGTACTTCATCGTTCCTGTAATGCTGCTGAGGGTAAGGTAGCCAATGCAGCAGGG +GCGTGGGGTGCTAAGTCTATGGCGTATGAGGATATTGTCCCATTCGTTGAGGGTTTAGTT +ACATACTGGAAGAACGCTGAGAAGTATGGTACTGGTATGATGTACCCTGAGCACAAAACT +GATGAGCAAAAGAAAGCTGCTGCGTCATTGAAACGTCGTAAAGCTTACGCTGCAAACAAA +GCTAAACAAAAGGTAAAAGATAATGCAAGTAAACGATAAGATTACATGTGCCTATGCAGG +GCAGTATCAAGGCACATATCTTACAACATTTAAAACTTATACAGCCCTCAGTACCATGCA +CGATCATGGACGGGACTATGTAAATCTAGTTGATGATTCAGGTGCAGAACGCACATATAC +CGCTAACCGATTCGTAGTACAGGAGAACTCTTAATGTCACAAGCCCACTTCAATAAACTG +AAACCGTGGAAACAAACTGCACTACGTCTACACATGCAAGGTATGACTGCTGCTGAAATC +TCTCGTGAATTTAATAATGAAATCTCAGATCGCACTATCCGAGATAACATTCAGAAACTT +GCACCTCAATTTGAACGTAGTGTTGTACTTGCAGATCGTAAACCAACTATATTCGTGATT +GGTGATACACAGTGTAAGCAAGGTATTGACCTCGATTATATGCATTGGATTGGGTCTTAT +ATCGCATACAAGAAACCTGACATTATTGTGCATATCGGTGATCACTATGATATGGCTTCA +TTATCAAGTTATGATAAGGGTCAGTTAAAGGCTGAGGGTCGTCGTGTTGTAGAAGATATT +GAGGCGGGTGATAAAGGTATCGAGATCATCGAATCTTATATTGCTAAGGTCAAAGGTTAT +AAACCACGTAAGGTTGCGACGTTAGGTAATCATGAGCATCGTATTGATCGTTACGTTAAT +GATAATCCTGAGCTTGAGGGTTTCATGGGTACAGATCAATTAGCCTTTGCTAAACACGGT +TGGGAAGTCTTTCCGTTCTTAACACCCGCCACTATCTGTGGTATCAACTTCGTACACTTT +GTACAGAACGGTATGACGGGTAAACCGCTAGGTGGTACGATCTTAACTCGACTGAAGAAC +GTGGGTGAGTCTTTCGTAATGGGGCATCAACAAACACTTGATCATTGTATCCGCTATCTA +CCCCTAAGTGGTCGAGCGCAGATTGGTGTTATCATTGGTGCATGTTATGAACACATGGAA +GACTATAAAGGCGTACAAGGTAATCATCACTTCCGAGGTTGTGTTATGCTATATGAATGT +AATGATGGTTTTGGTTTGGTTAAGCCTGTATCACTTCAACACATGAAAGATCAATTCTTA +GGAGCTTAATTATGAAAATCGGTTTAATTGGTTTAGCAGGTGCAGGTAAGGACACAGCAG +CATTATTGATTCAAAAGATTCTTACAGATAATGGTAAAGCATACAAGATTGATCGCTTTG +CTAAGCCTCTTAAAGATGCAGCTCGTGAGGTCTTCGGTGCTACATTCGATGATCGTGATG +TTAAGGAAGTACCTGTTAAGGTAGATCAAGATACCATGATTGAAGCCTCATTTAAAGCGT +TACGTAAGTGCCGACTTACTGAAGCTGAAATGGATAAAGCATCTGAGTTGTTCTTTGAAC +ACTTAGGATTTTGGAATTACCTATCCCCTCGTAAATACCAACAGTTGCTCGGTACAGAGG +TTGGACGAGCTGCACGTAGTACCGTATGGTCTGATCGAATTACGAAGTCTACAGCTAATC +TGATCGTACCTGATGTACGGTTTGATGGGGAGGTTGTAGATTACAATATTCTAATCACCC +GTCACCCTGTAGGGGTCGGTAGTGTACATGCTTCTGAGGTACTCGCTACAGAGATGCAGC +TAGGTCTTAATGAATCTTATGATGCTATGTTCACGAACACTGGTACTATTGATGAGCTTG +AGTCTAAGCTACGTACCCACATTGAAAACTTAATTAAGCAAGAGGTTATCTAATCGTATG +GATTTACTACAACGTCAGATTGATTTGGAAGAAGAATACTCAACAGCAAGTTTAGTTGCA +GGCCAACAACAGATCATGGATGCTTTCAAACAAGGACGAGCTTCTGACGTTGGTTCAGGG +CGCTTGTTACTTGCTAAAGCATTCCAAGCTTCTATGGAAGACTTTGAATCATTCTTAGCT +AAACCACTATCAGGTATTGGTGGTAAGTATAAGAAGTTATTAAAGATTGCAAAGCCTGAA +GTATTAGTTATGGCGGGTATCCGCGAGGTTATCAATGGCTGTGCTAACCCTGAACCTATA +GTAATGCAGAGCTTCTTACGTCAACTAGGTCGGATTATTGAATCTGAATCTATGTTGGTA +TGTATGGAGCAAGTATCTGATGTTTATACAAATCGTACAGTAGAGTATCTTGATTCAGCA +GGTACTAAATCCACTACACACCGCTACCGTACATTCCTTAAAGGCGCACAGAACATGGGT +CTTAACTGGGAACAATGGACTGTAGAGGAACGTATAGGTACTGCCCGTTTACTATTGACT +TGTCTTTATGAAAGTACGGGTTTATTCAAGTGGGTAGCTAACCGTGGCACTACAGATTCT +ATGTATTACCTTGTGCCAAGCGAGACTTTAGAGAAACACTTTGGAGAAGTACAGAGTGCT +GCTAAGGCTGTAGTTAAATATCCACCTATGTTAGTACCGCCAATGGATTGGACTGGACAA +TACGACGGGGGTTATATGACAGAGTGGTTTCGTTTACACTCTCCTATGTGTGGTATCCGT +TTCATTAAACCTGAACATAAGAAATGGATTATTCAGAACTTAAACAGCGAGCAATCGCTC +CCTGTACGTACTGCAATGAACAAAGCACAGTCTGTACCTTACCGTGTGAATCAGCGTGTA +TTGACGATTCTACGTACTGCTACGGCTATGCGTGTGGGTATCCTTGGATTACCTAGTTTC +GTTGAAACACCTAAACCTGAGTTCCCATTACCGCAAGGTTGGGAAAAGGATGCAGCTACA +CAAGCCGAGCTTGAACAATTCCAATTTTGGAAAACTCAAATGGCTACTTACTACACTAAT +GAGGCTAAACGTAAAGGTCGTCACATGGGTATCCTGTCACGTATCAATGAACTTGTGAAA +TATCAAGAGGAATCACGCTTATACTTCCCGACATTCATTGACTGGCGTGGTCGTTTATAC +TTCCGTTCTAATCTTAACCCGCAATCATCTGATGCAGTTAAAGGCTGCTTAGAGTTCGCT +GAGGGTAAAGTGTTAGGTAAAGATGGACTGCGTTGGTTAAAGGCGCATGTCGCTAACTGT +TGTGGTTTTGATAAACACGACTTAGATACAAAGGTAGCTTGGACAGATGAGAACTGGTCG +CAAATTGAAGATTTTATCAATAACCCCCTTGATGTTGATGCCCCTGAACCTGACACAGCA +TTTACATTATTGCAAGCTGCTATCGCCTTACAAGAAGCACTCGCACTGCCTAATCCCGAA +CTTTATGTATGTCACGTACCTGTCGCTATGGATGCTACATGCTCAGGCTTACAGCACCTG +TCTGCACTCACTCGTGACCCCGTAGGTAGTTATTACACAAACCTTGTAGATAACAAAGAC +AATAAAAAGTCTGACATTTACATGCGGGTTGCTGAAGTTGCTAAGAGCATGTTACCTAAG +CTAATTGACGATGTGACAGTAGATCACTTTTGGAAAGTGAATGAGATCACACGTTCTATG +GCTAAGAATCCTGTAATGACTTATGTGTACGGTGCAACGCTACTACGTTGTATTGATACC +ATTGGTTTAGCCCTATCTGAATCAGGTGTTGAACCTATTAAGAACGATGCAGGTAAAGTT +GTATATAGTATGACTGCACTTGCTACACCTGTAGGGAAAGCTTTACGTAAAGGTGTTGAA +GAAACTGTACCTGAATCTGCTAAGATGATGAAGTTCTTACAGACTGTGGTACGTAAACAT +AAAGAGCATTGTATGCGTTGGGTTACCCCTGCGGGTGTTCCTGTAGTTAACTGGGCAGAG +GGTTCTATCATCAAAACGCTTAACATCCGTTCTATGGGTGTCACCTCAGTAACTATGAAA +GTAGGTACTAAGCAATATGATACTCGTTCAGCAGCAAACGGTATTGTACCCAACTTTGTA +CATAGTATGGACGGTTCACATCTATGCTTAACTATTAACGAGTTCAATGGGCAGGTTCTA +CCTATCCACGACTCATTCGCTACCCATCCTAGTGACGTAGGTGCTATGCATGAAGCTTTA +CGTAAGACATTTGCTGATATGTATAAAGCTTATGATATTAACGACTTCTTAACTTTCAAT +GAAGTCGATACAGAAGAATACGAAGCACCACCTCAAGGTAATCTTGACTTGGACTCTGTA +CTCACAGCTCAATTTATGTTTTGTTAATCAAGGAGATTACTACTATGTTATTCACTATTA +TCGCTCTTGTTGTTCTTTCTTACATGTCAGTTAAATTATATGCTTGGGACTTGAAAAATG +AGTTCACGGGTTTTGGTGACTTCCTTAAAGATTGGGTAGGTTGCTTCTCTAAAGCGGAGC +TTGGTCAAGAATTTAAACTGTTTGGTTATGAGTTGGTAGAAGCGTTCAAAGCGTTCCTAC +TGCCTATCAAGACACTAGGTACTATTGCACTGGTCGTGTTCTCACCTATCCTACTATTTG +TAGTTAATATCCTAACCGCACTTATCAAAGTACATAAACGTAAGTAATCAGAAGCCCTTG +AGCCTAACCGCTTGAGGGCTTTTTTTTTTGTTTATCAATAACTTAACGAGTTACACAATG +TTACACATGTTGAATAACGTCTGTTCAATAGTGCTACGTAAGTGTATGATTTTAAATAAG +TAATTAGAAGATAGACGTATAAGATAGGAAAGGAGATTCAATCGTATGAATATTCCAAAG +TTTACAGATGATCAGATTGATTATTTAAATAGAGTATTTTCAGAGAATACAGTTATGACC +TTAGACCCTAATGAGTTGTATAGACGATTAGGTAATAGACAGGTTATCCAACATATTATT +CAGTGCAATGAGAATGCTAAACGTAAGATCACATCTTAGGAGGTAGTTATGGGTTTAGGT +TCATTCCTGAAGAAATCCGTTAAAAATGCTTTCCGTGGTGGTAGTATGTGGAAATTCGCT +TCTAAGGCTGCTAAGCCTGTTGAAGATCAGGTGCGTAGTATGTTAGGTCTTGATGCACTC +AAAGACTTAGCAGGCGCACAGGAAGCACAACTACGGCAACAACAGGAAGCTAATAAATTG +GATGCTTCAGTGGAGTCTCAGAACGTGGCGCAGTTTGATGATACGTCAGACACAGGGTTT +ACAGGTACGGATTCCCGTCGCAAGAAGAAACAATCAGGTGCTTATTCACAGGCACTAGGT +CTTCAGTTGTAAGGAGGTATTATGGCTAAGTATCCTGAGATCACTTATTCACTCAAGGCA +TTGTATAATCAGTATCGGGATACTTCACTACTTTCACGTATTGAAGACTATGCTTTTTGG +ACTATCCCTAGTGTGTTTCCAAAAGGTGATCAAGATTTTCGACAACAACAAAACCGTGCT +ATCGAATATGATTATCAAGCTGTAGGTGCAATGTTAGTAAACCGACTGGCTACTAAGTTG +GCACGTACATTATTCCCCGCTAACCAATCGTTCTTTCGTATCGACGTTAGTGATGATTTA +AAACAACTGTTTGAGCAAACGAAATTAGACAGTGTTATCGAATATGAAAACCAAGCATGT +GAACAATTGTACATGAATGCATCTTATGCTCAACTTGTACAAGCAATGCGATTATTGGTT +ATTACTGGTGAGTGTTTACTGTATCGTTATAATAACGCATTACGTGTATTCTCATTAAAG +GATTACGTCCTTAAACGTAACAACGTTGGTGAGGTTATGGATATTGTTATCTGTGAGCAT +AAGTACCGTGAGGAACTTACACCTGATCAACGTGTCAAACTTCAGATTACAGAGTCTCAG +ACCCGTGTTAAACTCTATACCCGTGTTAAGCGTAAAGAGGTTTATGGTATTGTGTCTTGG +CATGTAACACAGGAGATTAATGGTATCGACATTGGTACTAATACTGTGTATCGTGATAAG +CTATGCCCATTCATCCCTGTCGCATGGAATCTCGTTAATGGTGATTCTTATGGTCGTGGT +TATGTAGAGGATTATGCTGCTGACTTTGCTAAGTTATCAGATATGTCTCGTGAGCTTATG +TCTTATGAGATGGAGTCTTTACGTCTTCTACATATGGTTTCCCCTCAAGGGGCTGTGGAT +GTAGAGTCTGCTGCGAATGCCCCTAATGGTGAGTTTATTCAGGGTGACCCTAGTATGATC +AAGCCTTATGAGGCAGGTTCGTACCAGAAGATTGCTGAGATTCGCAATGATCTTGAAGCT +ATTGAACAACGTTTAAATATCGCTTTTATGTATACAGGTAATATGCGTGAGGGTGAACGT +GTCACTGCTTATGAAATCCGTCAGAATGCTGAGGAAGCTGAGCAGGTCTTGGGAGGTGTG +TACTCACAACTATCTCAAAGTATGCATTTACCATTAGCGTATTTATTACTATACGAAGTA +AAACCAAACATCATGGAGGCGATTGACTCTCAGGAGATTAAACTAAATATCTTAACTGGT +ATTCAGGCATTATCTCGTTCATCTGAGAACCAAGGTCTAGTAATTGCTTGTTCTGAGTTG +AACGCTATTATCCCTACAATTGCACAGCTTGGTAAACGTTTTAATATTGATGCTATTGCA +GATAAAGTCTTTGCATCTAATAACGTGAACATCAAAGATATTACATACACTGAGGAACAG +CTACAGGCTAATGCTCGTGCTGAACAAGAAGCTATGGCTCAACAGCAGGCACAGATGACT +CAAGGTATGCCACAACAACTTGCAGGGCAAGAGTCTGCTATCCAAGCAGTTCAACAAGCC +CAACAATTTTAATGGAGATTTAAAATGACTCAAGAAGTAATTACACCTGAAGTAACCTCT +GCTGCACCTGCACCTGCTGCTGTACAACCAGTGGTAGAACCTGCTGTACAACCTGCTCAA +GAAGTAGTATATCAGCAAGCTCCAAACTTCACAGGTGAATCTGTACTTGAAACTTCTATT +AATATCTTCTCAAGTGGCGCAGGTATTGACGCTGTACGTTTTGAAGATGCAATTGAAAAT +GCAATCAAATACAATGACCCTAATTTAATTAATGTGGATGCACTTACCGCAGGTCTTAAA +CCTGAGCACGCTGCTCAAGCTAAAGCATTGGCTCAAGCTGCATATCAGGAAACACAGGCT +GCAATTCAACGTGCCTCACAAGAATCTATTGCTACGGCTGAACGTCTAGCAGGTGGTTCT +GAACAATGGAAAAATATCAGTTCTACATTTAATACTAAAGCACCTGCTCATTTGAAAGCA +GTAGTGTCACAGATGTTAGATGCAGGTGACGTACAGAATGCTGTACAGTTCGTTATTGAT +ACAGCAAATGGAGTAGGTCTAGTGAACAGTGGAAATGATCCGATGCAAGGCGGTGTTGGC +GGTAATGGTGCTGCATCTTCAGGTATCTCACAAACAGAATATTTTGCACAATTAGCAACC +CTAGAACGTGAAGCGGGTAACCGTTCATTTGAGCAGGGCGAGTACGCACACAAGTTAACT +TTACTTCGTGATGCACGTAAACTAGGTCGTAATAACGGTCTTTAATATTAGGAGAATTTA +ATCATGGCTCAAGGTACTACTTATCAACCGAATACAACTCGCTCACATTGGAGTGGTGCG +AACTCAGATAAAGACGATCACTTAGAACTTTATACAGGTATTGTAGATTCACGTTTCCAA +TACACTCAAATCTTCCAAGGTTTGTCTGCTCAGCGTTCTACTGAATCACGTTCTAATACT +ATCCGTCTTGACCGTTTGAACGGTTCAAAGGTTAAGGGTCGTAAAGCGGGTGAGGCAATC +GAGTCTCAGCGTGTGACTTCAGATAAAATGAACATCACAGTCGAGTGTATGATGTACATT +CGTAACCCTATCGATTGGATGGACGATTGGACTGCACCTGACTTCTTGACCGATATTGGT +CGTGACAACGGTACTGAGTTTGGTCTAGCATACGATGAGGCGCACTTAATCCGTCTGATC +AAAGCCCGTAACTGGGTAGCACCTGCACACTTAGCAGTGTCGTTTAAAGATGGTATGCAT +GTAGAGGTTGCTTTGAAAGCTGCGACTACTACTGCTGATCTTGAAGCTAACGCTGAAGCT +CTTGTATATGCTCACGGTGTGCTTGTAGAGGAACTTACTAACCGTCATGTACCTTTAATG +GACATGATCACTGCGGTAACTCCTAAAGTGTTTGGTGAGCTTTTACATCACCCTAAATTG +ATCAACAAAGACTACGTAGCTTCTAACGGTGACTTCGCAGGTCGTCGTATCGTTGAGGTT +AACGGTCTACCTATCGTACAGATGACTGCGTTTCCTAAGACTGTGGGTACTAACCATATC +TTGTCTACGGAGACCAACGGTAACGCGTTTGATGTGACTGCGGATGATGTGAAAGGTGAG +ATGATCATTTTCTCTAAAGCGCTGTCTCTAGTCACTGTAACTGCACAGGCTTTCGTATCT +GACTTTTGGAAAGATAAAGCTGAGATGTGTAACGTGTTGGACTGCTTCACTATGTTCACC +GTTGATATTCGTCGTGCTGATACTGTTGGTGTTGCGTTGATCACTCGTACACCTTAATCA +TAACACGGAGGGCTTCGGCTCTCCATTCAATTTTAGGAGTAAAATAACATGGCTAAACTA +GGCGAGACAATTGTATCCAGTGCTATCTCAGGTAAACCTTTAACTTTATCAGATAAAGCT +TTTTCTTTGGTAGGACAAGCAAATGATAAGGTAGCTGCGTTAGAGGGTCAGGTTCAAGCA +TTACTAGCTCTTGTAGCTGCACAAGGTATTGCCCCTACACCAGTAGAAGCACCTGTAGCA +AAACCTGTTGCTAAGGCTAAGACGGGAGAGTAATCATGGCGTTAATCAAAACGATTAATG +CTGCTGATCTTCAAGGTACTAATGAGGTGAGTGTTGACTTCACCTCTGTACTTACCGCTA +TCAGTGGCGTTAAAACAGATACCACTGCTATACAGGCAGACGTTACCGCTGTTAAGGCTG +ACGTAGCTGTTATCAAAACTAACACTACACCAACACCGTAAACTCGAAAGGGTTTACTTT +AAGATATAATCCAAGCAACGTAAATCCCAAGTGGTCGTATTGTGGTGATTATATCTTAAA +GTGAATCAACCATAGGAGGTATAATATGGATATGTTAGAAGCTGTAAATACTGTATTACC +TTATATGGGTGAACACGTAGTTACACGTATTGAGGGTGCAAAGCATCCATCTGTAGATTT +AATCCAAGCTGCTATCAAGCGTCAGCAAGTAACATTGTTGACTACTGGTTGGTGGTTTAA +TGAACTACATCTAAAGTTACTCCCTAACCAACAAGGTTTCATTGATGTGCCTGAAGATAC +GTTAGAAGCGTATGGTAAGAATATCAGTGTTACGTTAGATGGTGAGCGTTTCTTCAATCT +TGATGAGGGTTCACGATATTTCTCTAAACCGTTAGAAGTTAAGATTGTACGTAATGTACC +TTTTGAGAAGTTACCTGAAACTGCTGCATTATATGTAACATATAAAGCTGCTATTGAGGT +ATATACTGCTGATCTTGGTGCTGAGGATGTACTTCAGATTCTAAACAATTATGCAAACGA +TAACTTGATTTCTTTTAAGGAACTCAATTTACGTCAACGGAAGTATAACAGTAAACGGAC +GGCGCGACAGTTCAGTTCGTATAATCGGTTACGACACCGCTAGGAGGTGAGCAATGGCAG +TACGTGAGGGTACGTATAAATCCTTATTACAAGGTGTATCGCAACAGACCCCACAAGAAC +GTGCAGACGGACAATTAGGTTCACAGCTTAATATGCTGTCTGACCCTGTTACTGCATTAC +GTCGTCGTGGTGGTATTAAATTACATGCTGTATTAGAAGACTTGGACAAGAGTAGTTATA +TTCGCATGACCGAGATTCTAGGTGATACTTATATTACCGTTATTGATACAGCTAAAGGTT +CATTAAGTGTATACACTTTTGATGGTGGACTAAAGTCAACTATTCAAAATGATTATTTTA +AAGCTCGTAGTAAATCTAGTATTCGTACTACAGTATCTAAGGATAATTTCTTCATTCTAA +ATACTGAGTTAATCCCTACCAAACAGCTCGAAGCTGAGGCGGGTAAGAATCCTAAGCACT +ACGGGTACTTCAGCATTGTGTCTACAGCGTTTAGTAAAGTATTTACTATATCTGTAACTC +ACCCCTCTATTGGTACTATAACTAAGACGGTTACTGCATCTAGCGACAATGCTGCTGAGG +CAAGTCAGGAAAATATCGCTCGTGGTCTTGCGGATTTATTCTCTCAAGATACTACTTTTG +CAGCGGTGTTTAATGTACACCGTACAGGTATAACTGTAGCGTTTGAGGTAAAGGATAAGA +CGCAAACTGGTACTACAGTTGTGGACTCTACTACTGGTGTTACTTATGTTGTTAAGTCAG +GTGCATCCCGTGTTGTGAATAAGGCTGAGTTACTGGGTACACTACCATCGGTACTTGATG +GTTATATCATGGCTGTAGGTAACGTAGGTAACTCTGCATACTACAAATTCGATCATGGTG +CATTACGTTGGGCTGAGACTGGTGTTTATGAGCCTAACTATAAACTTATCAATGAGCCTA +TGTATTGGTATCTTGATGCTGCTGATACTGTGAAGCTTGTACCGTTAGGTATTAAACCTC +GTGAGGCAGGTGATGACGATAATAACCCTGACCCTAAATTCATTGGGTACGGTTTGACAG +GTATTGGTAGCTACCAATCCCGTCTAGTATTATTGAGTGGTTCATACGTCAATATGAGTC +AGACGCGTTACTTCAACCAATTCATGCGTACTACGGTTACTGAACTGTTAGATGATGATG +CTATTGAGGTTTCTAGTTCTGCACTTAGCTCTGCACAGTTTGAATACTGTGTGCCTTATA +ATAAGGACTTGGTGTTAATTGCACAGACACAGCAAGCAGTGATCCCTGCTAACTCGACTG +TACTCACACCTAAATCTGCGGTGATCTATCCGAGTACAAAAGTAGATTTGTCACTAGCTG +CTGAACCCCAAGTTGTAGCTAGAAGTTTGTATTACACGTATCAACGTGGGGCAGATTATT +ATCAAGTAGGTGAGTTTATTCCCAACACATATACCGACGCACAGTATTACAATCAGAATT +TAACTGATCATGTACCACTGTACGCTACAGGTGTTTGTACATGTATTGCTGCATCTACTA +CTAACAACATGGTAGTGATGAGTTCAGACTCCCGTGATGTATTGGTTAATCAGTTCTTAT +GGGTTGGTGAAGATCGCCCTCTGATGAGCTTCCATAAATGGGAGTACCCATTACCTGTTG +TATACGCTCAGTTCATTCAAGAATACTTAATCGTGTTCATGGATGATGGGCAGGGTAACT +TAGTCATCGGTACTCAGAACGTACAGTTAAACCAATTAGATGATAAACCTATCCCATTCC +TTGACTTGTATGGTTATGTGACCATTGAGAACGGTGTTGGTGTTTTACCTGAGTATTTAC +TTGAGATGAAACCTGATGATATGGAGTTAGCTGCATCTATATATAATGACCGTTATCTGC +GCCACCAAGAGATTGAGTTCTCGTATGATGATGAGGGTAATGTTACATGTCCTTATGATG +GTGTTATCTATGTTGGTGTACGCTTCACAAGTGAGTTTACTTTGACACCTCCTTTTATTA +AGGATGAGAACGGTAAGGTCGTGGCAGGGGCTAAGAGTACGGTAGTACGCCTAGACATGG +AATTTAAGAACACAGGTACGTTTAAAGTGTCCGTAAAGGATACTATGGGTGACTCATACT +ACAATGAGCTTGATACTGCTTTAACGTGGTCTGAGGCTGATTTAGGATATACATGGGTTA +ATAGTATCGGTCAGGTATCTATCCCGTGTCGTACTCGTTTAACGTCTACACAGTGTTCTG +TAGAGACTGTAGGTACAACAGATTTAAACCTTACTAACTGCAACTACTTATTAAGGTTGA +ATCAGAAGCATCGGAGGATTTAACATGGCAGGCAATATGCAGGCAGGTTTATCTACTGGT +ATGCAAGGCACACAGGGGATGGGTGGTCAAGTTGGTGGTATGTGGGGTGCGGTCATCGGT +GGTATCGGTGGCTTCGCTCTAGGTTATAATACACCTGACTACGAGAAGATTGCCCGTGAG +AAATATAATAACGAGGTAGTTAAAAATGCTATCTCGTCTTTGTTCGATATGCGTCGTGTA +CAGAATGTAGAGAACATGCGCACAGCACAGGCTCTCGCAGCTTATCGAGATCAACAGACA +GTTACTACAAGTTCATATAACGCCCAATATGGCGCTAATGATGTGGTGGGTGCTTCTGCG +GATGCTCTAAAGAATACATTAGCCTTTCAAACAGATCAGGCTATTGCACAAACATGGTTT +AACTATGAAACAGGTATTGATAACTACAACATTGGTGTTGAGGGTACAGTGAACTCTGCA +TTAGCAGGCTTACGTCGAACCAAAGGTGATCAGCGTACTATGGACTTAGGCGCACTCACT +AAATCAGGTTTAGATATGTACAAGCAATACGGTGGTAGTTTCAATAACGCAATGGGTAAC +TTGTGGGGTGGTGGTTCTACAACAACTCAAGGCGTGTCAGGTGGTGGCTTAGGCGGTCTA +TCTGATTTTGGTTCGTTTGGTAAAGGTGGCTCAGCCAGTGGTTTAACTGGTGGTAGTTCA +TTAGCTTAATATAGGAGTTTATACATGCCTACTATGGTTCAACAACCCGACTTAATTACA +CCCGAAGTATCTCGACTTCAAGCGATTGATCGTCCTGTAGAACGTAGTGGGCTTAGCTCA +TTCCTAACAGAATTACTCCCGCAAGTTAAAGCGGGATTCGACGAGTATCAGAAAGAAAAC +CGAGACCATTATATTGCGTTAGGTCGTAATGATGAGTTAAACGGTGTACAACGTGATGTG +TCTATTATTGACTCTCACAACTATAACCAAGGTAAAGAGTTCCAAAAGGTTACATCTACA +CAGGCTGAACAACAACAGTTATTCCGTGATACTGTAACTCAAATGGCTCGTGATGGTAAG +TCTGCTGAGGAAATCTTCGATGCAGGTAAACAGTATCTCACTGGTTATACTAACGCTGTC +CATGATAGTCAGCTACAATCAGATTTAAAAGAGGTGTTGTATAATGCAGGTCTCAAAGAG +AACACTGCATATCAAACTCTTATTTCCAAAACAATTAATGAAGTGGCTTTACAACGTGAA +CAGTTTGATTCTCAGACTCGTACTGCAAACACGTATAAGTTACTGACTGAGCAGAATCAT +ACACCTGCACAGATTACGGAATTACTTGAGGCTCATGTACAGAAAGCATTTGCTGCTAAG +ATTGCTAGTAACGTGGGTATTGACCCTAAAGAAGCTATGCAAGCTGCACAGTCTGAAGTA +CAGACTATGTTCAAGTATTGGGCAGGTCAGATCGACCCGTCTAGTCCTGATGCTGCTGCA +TTCGTAAACACTTTGAATAACACATTAGATGTAGCTGTTCAAGGTGGTATCGTGAGTATG +TCCACTGTTGTCGATTTACAAAGTAATGCTAATGGTATCCGTTCACAGATTCTTGAGAAC +AACGGTATCCAATTAGAGAACTCTATGAAAGAGGGTATGTGGAATATTCAACGTGGTAAT +GCAGAGTACAGTCACGACTTCGTACAATCACAGTTAACAGAGATTAACCGTAAAGAAGCC +CAAGGTTTACTTACACCTGCTAAGGCTGCACAACTACGAGATAACTTATTCTCCTTTGGG +GAAACTCAATACAATAAGTTATTACAGGCTGAACTAGACCCTGCACAGCTAGTTAAGGGC +GGTGTCTCTATGATGGAGTATGCTGCACTTGGTAAAGGTGGTGAGGATAGCTATAGTGGT +CATATCAGTAATTACTATGATGGTATTAACAATGGTGACCCTGTTGCTGCGGGTTCTGCT +AAGGTTGCCCACGCTTTACGTGGTGACCCTAATGGTGAGAACTTACCGTCGCTTATGCGT +AACGGTACACAGCAACTATCAAGTCAATTCGTGAGTTTCTTATCGCTACCTCAAGACCAA +GCTGCTAAACAACCACATTATCAGAATGCTGTTAAAGCGTATGATAGTCTGAAAGCTACT +TACATGCAATTGAAAGCTCAAGGTTCTCCTTTGGCTGAGCAATTACTTGCAGGTGTACCT +GAAGATTACCGTGGTACTGTTATGGAGATGTTCGCAGGTAATGCTAATATGAACGCTAGT +GCTGAAGCTCTACGTAACCCTGTTCAAACTAACCAACGTCAAAAGAACGTGTCTGAGGCT +ATTCAGGCTATGAACTGGGATAACGTAGGTGGTAACAAATGGTTTGGTCGTGGTGTAGGT +GGTGGTTCACGTTTACTTAGTGGTATCTCTGAGGATGTACGTGGTTCATATATGAAGAAT +ATGGAGATGGTCTATTCAGACTCTAAACATGCTCTTGCTAATGGTTCTACATCTGCTAAT +CCCGAACTACTTGTAGCTAATGCTACGGCTTTAGGTATGCACGTTAAATCCCCTGCGGGT +TACAACGATGCTTTATTTACAGCAGGTGCGTCTAAGGTTTACCATAACATCACTCATAAG +GGTGTTAAGTTGTCGGCTGATTATATTGGTCATGCAACTGATGAGCTTCGTCGTACTGTG +GCTAAGTCTGCAAATAGTTCTCCTGATAACGTGTTGATTCATACAGATCGTACAGGTCGC +TATGTAATTGTCCAACCGTTCGATAAGAATGGTAAGTTATTAAAGGATAAGCAAGGTGAT +GCATTCCAAGGTGAGGTTTATAATCAGAGCCAATTCGTTAACTTAATGAAGAAAGCTTAT +GATGCTGACCAAGCTAAATACAAGAAGCACACTAGCACATTTGAAACTATCGGTACTGCA +TTCAGTAGTAAAGGTGTTAGTGATACACTTGGTAGTACAGCTAACTACAAAGAGGATATG +GCTAAGTGGCGTAAAGAGTCTAAGTCGTACACATTGAACACAGCAGGCTCACTAGGTCAG +ACTGTTATCTCATTACCTAATGGTACTAAGACACAGGCTAAAATCCCTACGTTAGCATCT +GTACCGTTTAATGGTAACGTACAGCTAGCTACAGCATGGCAGGGTTTCCTCAATAACTAT +GAGGGGTTCAAACCTACTATAGGTGTTGTTAAAGGTACTGGTACAGACAATGACGGTTTG +ATCATCGGTAACGGTGTTAACCTATATGCACATCCTAAATGGAAAGCACGTTTCCAAGCT +GCACAGGGTAACCCACAAGCTTTGCTTAATCTACAGGCTGAGTTCATGTCTAATAATATG +AAAGATCAGCAGTTAGAGGCTAAGCGTTTAGGTATCCCAGTAGCTACCAATAAACCGTAC +AATCCACAATTCATTTCAGCACAGCTACTACTTGCGGATTACAAATGGCACAACGGTAAC +TATAATACCATCCGTGATATTATGTCAGCACCTACGTATAACCAAGCACTAGCTAAAATG +CGTAAGTCGTCTGCATACACACACGCGGGTGATGGTCACCGTCGTAACGTTGCGCGTCGT +AACATGCTTCGTGATTACTACTTAGCAATGGGTAAACTTTAATTATTAGGAGGTTGTATA +AATGGCTAATCAAGTAGGTATTAATAAGGACATTCAAGTTCTTCCATCTGTACAACCTGC +TATCCCTGACCACGCAGCACCGACTGCGGGTGAGGGTATTCGTCCTAGTACCTATCAACA +ATTAGGACAGGCAACTGAACAAGATTTAGCAGTGACGGGTGAGGAACTCCAAGATGAGGT +ACTACCTGAACAACCTGCATTATGGAAAGTCGCACAAGTAGTTGCACCTACAGCAAGAGA +CTGGGGTAATGCTATTTATGAAGACTTTAAATTTGAACGTGATATTTATTATAATTCGGA +TGCGGATGCACAAGAGTTCTTTGAAGCTCATGGTGAACGTAACCGAGATGAAGTAGCTTA +TATTCATGGCGCACGTAGCTATGAGGATATGCAATTCCGTCAACAACGTATTTTAGATCG +TCGTGATGACAACGAGATTTTAGCTGCCCATCCGATTGCAGGTACTATTGCATCCGTAGT +GGATGTTGATTTACCTTTAGCATTCGCACCTGCTGTGGGGCAGATTGGAGGCGCTGCTAA +GTTAGGTCGCTTGACTCAACGTGGTATGCAAGCTGCTGCTCTAGGTGGTGGTGCTTACGG +TCTTAACCAATTATTAGAAGATGGGTCTACACGTACTCAATCAGAACGTAACTTAGATAG +TTTGACATTCGGTTTAGTGGGTTTATTCTCACCTATCAAATATGAAGCCCGTACTACTGG +TACAGCTTTAGATCAAATGGTAGATACTGAGTTAAAAGCTATTGCTCAAGAGACAACTGA +TACTGCTAACCGTGTAGGTAGTGCAGGTACAACTAACGTACTAGGGCATGATATTAAAAT +GCCTATCTCACAACCGATTGATACCTCTAAATTAGCAGTACCTGATTGGGCTGTTCAGAA +CAAGGTTGTAGCTGCTCTACAGTCGTCGGGAGACTACATGTGGTATCTTACTAAGGGGGA +TGCAAATCATCCCGCTAATAAGATTCTAGCAGCTCCTAGAACGCAAGGTGATAATGCTCC +TTATGCTACTGCACCAGTACAAGCAACACTTGAAGCTAAATTGGTTGGTGTTGAGGACGC +TATCAATGATGCAGCTATGAAGATGTATGGTACAAGTCCTAACCGCTTCTTTGGTCGTAA +AGATCATACAGTTGCCCAGTACCAAGTTACTGAACAATTCGGTCAAGCAATGCAACGCTT +AGATCAGGACATACTGTGGAAAATGAACTCAGGACAACCTGTAGATAAGAAAATGATTCA +TCAAATGATTGATGAGTCTAATGTTGCAGATGAGATCAAAGCTATTCAAAAGGCGTATGT +AGATTCAGGCTTTGCTGAGACTGCATTGAGCCGAGCTAAACAAGCAGGGTTGCTAGAGAA +CTTAGATGATGCTGCTGCATTACATTCCCGTGCTACTTACATGCCTGTTAAACACAGTTA +TGAGCGTATGAACAACTTAATTAAAGCAGGTCAAGTTTCCGAAGATCAGTTATATAACTT +CTTAGGTAAACAGATCATGCGTATGTACCCTGAAATGCAGCAAGCTATGAAGATCGTAAC +TAAGGCAGGTACTAAGACTGTCGAGCGTAAGTTCCAATTGACTGCTAAACAGTTAGGTCA +GAACTTCTTTGAGAATCAACAGAAACTAGCACTAGGTTTATCTGAAGTACAAACAGCAGG +TCTTACCAAAGATCAGATGATTACGTTACTTCGTAAATCAGGTGTTGATGATGAGAACTT +AAATAAGATCGCTGATACTATCTATAAAGGTACTCAGGATGCAGGTACGGGTGTTGCTAA +GCAATTCCGTAAACGTCTATCTTGGGATTGGAATATGAAGTTCGTAGGTAAAGATGGTGG +TGAGTATAGCTTAGGTGATCTTGTAGACGGTAACGCCTACATGAACTTAACTGATTACAC +ACGTACTATGTCTAAACGTATTGGGCTTGCTCAGTATGGTATTAAGACCACTGCTGACCT +TGACAATATACTTCAAGGTATCATGAAAGATTTACCCGCAGACGTTGACATTGCAACCGC +TAAGCGTTTCTTACAGAACGTCCGAGCGCAGGCTTTAGGTCATCCTATGGGTGAGGCTGT +TCCTGAGACTATCCGTTCATTGAACACTGTGGCAGGTGCTACATTCCTATCTAATTCAGG +TTTATATAACGTGGTAGATATGGCGACTCAGGTTGCTAAGATGGGATTAGTACGTACATT +GCCTGAGATCATGAAAGGTCTGAAGAACATTGTGAATCCTATGAAGAAACTATCTAAGAA +TGAAGCTAACGATTTATATGATGTATTGACTGGTCTATTAAGTACCGATGGTCGATGGAG +AAACATCACGACTCGTTATGCTGATGACTTTGAGGTTACTACTGGTATTCATGAGGCTAC +AGCTTATTACGGTCAGGCTACTCGATTCATGAACTTGTCTGAGTACGTTAAACGTATGCA +GATTGGTATGATCGGTGGTGTTGTCACTACTGCATTTAAGAACGCAGCTAAAGGCTCAGC +TAAAGATATTAAGTACATGAAAGAAACCTTGAAAATGTCTGATGAATTAACGGAGGCTGT +AATCAAGGAACACAAAGCTCATGGTACTAATATTGATATGTGGTCGAATGATGTACGTAT +GGCTATGGAACAGAAAGTGTTTTATGAGGCTGATAACTTAGCGCATACTATTCGTTCAGG +TGAAATCCCTGCATTCATGGAACATAGTTCTGTGGGTAAGATCATCTTCCCGTTCATGTC +CTTTGCTTTCGCTATGCAACAAAAGGTACTTCGTAATACTTATCAACGTGATGGTGCTGC +GGGTGTGGCTTTATTAGCTGCTGTACAGTTCCCAACTGCTGCATTGATTGGTATGGCTAA +GAACATTAAGAATGGTAAAGAGCCTGAAGAAGACTTGGCTAAGACTTCGGTTAACGCTTT +GAGTATGCTAGGTACTTTCTCGTACCCGTTAGAGATCATCATGAATGGCGGTTTAAACAG +TAACAGTGCTGCGTTAGCACCTGTATCTAATGCAATGACATTAGGGCAGAAAGCTATGTC +AGGTGACCTTGATTTACGGTCAATTAAGAATGCTACACCTTTGGGTAGTTTAACAGGTTT +GGATTTATTCATTTCAGCTATAGAGGATTAATTATGTCGTTTAATGAGAAACTATCATAT +ACGGAGCATGTGGTCGAGTCCCCAACTACAGACTTCGCAATTGGCTTCAAGGATTACGGG +GAACAATCAGATACAATTAACGTACTTGTAAATGATGTAATAGCTACGGAGGCGGGTTAC +ACCGTCTTCCGTAAGAATGCTCTAGTCATTGCACTTGAACCTGCTGTCACATCAGGCATT +GTACGTCTACAACGTGAAACTAATATTGATAAGTCCTTTCATATCTTTAGTGCGGGTGCT +AAGTTTGTCGGTGCTAATATGGACGCAAACTTTGAGCAGATTTTACACTCTCAACAAGAA +ACCCGTGATGGTTTTGATAAGCTGTATTCCGATGTTATGCCATTGGTTAAAGGTCTTGAA +GATGCTTTAGCACAGGCTGATGCAGCGTCTCAAGCTGCTAAGGAGGCTGCTGAAGCTGCG +GAGGAAGCTGCGTCCCAATCTCGAAGTGCTAGTAATGTTATTGATCGTACAGGTTTAACC +CAACAAGATATTAACGATGTGTTAGGTGTTACTACCAAGCTACCCGCTGTTTGGGGTCGC +GGTACTATCCCGTCTATACTAGATCGCATTAATATCAAAGACTACGGTGCTATCGGAGAT +GGTACTCTGCATACCTTACAGGAGTGGGTTACATCGGGACGTTTTAGTAATCTATTAGCT +ATCCAAATGGTATTCCCAAATGCAACAGCTTTAACTGATAGTATTGATTGGTTAGTTACA +GATTACTGCTTAGGTTTACGTAAGTGTATCTACGCACCGCGTGGTACTTATGTATTTAAC +CGCCCTGCGCGTACACCTCACAGTGGTAGTCCTAACCGAGTGGATTCGGGTTGCAGTTTA +ATCGGAGATGGTACACACACTGTATTCACACGTTCGGATAAACGTTTAGCCACACGTATA +TTTAAGGTTGATGGTTCAGAGGATTATGAAGCCTATGATGATGTTAACCGTGACGAAGCT +GTATTTAACGTACATGGCTGTTATCAGATTTTCCGTAATTTCTGTATCTCTAGTAGTACC +ATCGGTTTCTACTTAGGGCAATCAGCATCTAGTGCGGAGAACTCTGCGGTTTATATGTCG +CAGTGGTCTGAGCTTCAGTTTAAAGGTGTTGGTACGGGTATGTTGTTCGCTGCTGCATAC +GGTAACCATTATAACCGTGTAAATAATATCCACTTTATTGAGTGTGGTATTGATGTGGAG +ATGCGTGGTGGTAAGTATGACAGTTCGCCCACTCAGGCTAATAACAACCGTAACACGTTC +TCTAATATTCGATCTAACCGTAGTAAGGTTGGTCTGTGGTGTAAGTCGGGAGATACTAAC +CGCTTTACAACGTGGGATGGTGAGGGTTGTGGTGCTACACCGACTAACAACACTTTTGGT +GCTATTCTAGGGTTACCCCTGAATCCTGACAATGTAGCACTTACTAATGGTGTATTTATC +TTACACGGTAAAGGGCAACTTAACCGCCTTATGAACTGTGTGACTGAAGCGTGTGATGTG +GAGTTATACAACGACCATTATCGTAATAGCTTCACAGGTGTAGGTTTTAAGGAGAACGTT +TACTTAGGTAAGACTGTTATCAATAAACAAGTACCTGCATACTATCAGTCACCGCATACA +CTATTTACACCTAACTTCCATAGTTTAGTGAACCTAAACACATGGGCTTTCCCAACAGTT +ACCAGTTTAGGGTTTACTGTTAAGTCGTTAAGTTTCACCAACGCTACAGGTGTTACACGT +ACTTCACGGGATAATTCATCATGTTATATTGATGAGCGATTAGTAGATTTAGGCTCTGTG +GTTGCTAGCGGTATCATTGAGTACATTTTATGGGCAGATTCAGATGCTAGCTCGACTGCT +AATATTGAGGTAACTATCAGTGCTGATAGTGCAGCATCTAACTTGGGCTTTGCTTCTAAG +TTTGCTGTAGCAGCACACCGTACAAGTGCTAAGACGCTGACACGTTATAGTTTACATACA +ATGTACTCTTTACGTGCGACTGGTCAAGGTACAGGGGACTCGGGCGGTGTTACTGCTACC +GTTGTTCATGGGGGTAGTTCGGGTCGTGATTTGATACTACGTATTCAAGCACCTGCGTAT +GCTTTATCAAATGTGACTGCTACAGTACGTCGGCAGGTTACAGGTTAATAGGAGGAATAA +TATGAACATTGTAGATCAGGTCTACATGGCACTGATCTACATTTGGTCAGAGCTAGATAA +AATGGTAGTCGGTATGGGTTTAACAGCCTATATCGTCGCTGTATTAAAAGGTGAACGTAA +ACATCGTGAGGCAATATTATGCGGTGTATTCGCTATGATTGCAGGTACTGCCTTATCATT +GGTAGCTACGTTCTTTGGTATTGCCCCTGATAACTTCGCAGTATCAGGTGGCGGTAGTTT +AGTAGCGGGTGCTATTGGGTGGTACGGGACTGTACGTACAGTCGATAAGATTGAGAATAA +ATTGGGAGGTAGTAAAGATGATTCTAACTCGGAATAGTTTTGACTACTTACGCAGTATCT +ACGGTAAATTAAGTCAGTCTCAGGTTGATGGTTTAAACTTCCTTGTTTCAAAAATGAAGC +AAGCGGGTTTTACCTATCCTGAAGCTGCCTACGGTTTGGCTACTGTATATGTTGAAACTG +ATAAGACATTCCAACCTATCGCAGAGCGGGGTTCGGATAAATACTTATCAAAATATGATA +CTGGTAAACTAGCAGTACGTTTGGGTAATACACCTGAAGCCGATGGTGATGGTCAACTGT +ATAAAGGGCGTGGTTATGTTCAGATCACTGGTCGAGCTAACTATAAGTTCTTCAGTACGA +TTACTGGTAAAGACTTAATTAAGAATCCTGACTTAGCACTAGATGCTGAGGTGTCTACTA +AGATCATGACACATGGTATGCTTAATGGTTCATTCACTGGTGTAGGTTTCCGTCGTAAGC +GTCCTGTGAGTCGTTATAACTTAGCGCAATACATTGCTGCTCGTAACATCATCAATGGTA +CAGATCGTGCTGCTGAGATCGCACAACATGCTATTGTATTCGAGAAAGCATTACGGAGTT +AGTATGGATTACGGTTTACGTCATGATGGTACACCTAAAGGACGTGGTTTCTTAGGTGAG +ATTAGTAATACTGATGGTAGTGTTATGACTGAGTATAGTATTGGTGTAGAGTTTGACGGG +GTAGAGGTAGATATACCTACTATTACACCAATGTTAGAACTCTCGGAGATTAAGCAGTTA +CAGGCTATGCGGGATGGTGATGACATACCTCAAGGTATTATCCGTAAGGCTATCCAACAT +GCACGTATGCGTAAGGATAATGGATTACCATACTTCGCAACCGAGGACGACTACCCACTG +ATTGAAGATATGCGTCGTATCATAGGAGTAGATTAATGACTAAGAAAGTACAGAGTGCAA +GCGTAAGCACGTTAAATGCGCTACATGAAGCTGTTGCTCGTTATATGCTTATGCGTATTC +AGTCTGCATTCCCTGATGAGGATGCTGAACCGCAATACGACGAGGAAACTGGTGATGAGA +TTCCTACATTCTTTATTCCTTTGGCTGCATCTGAGCTTCAGGTATTCGTATCGTTCTTGG +ATAAGAACAACATCACAGCTACACCTGACGTAGAACACATGGCTGAACTGGCTAATGAGT +TCACTGAAGACTTACGTTTAGCTCGTGAACAGAAAGCTAAATCAATTGTTAAGGTCAATG +AAAACGATGCAGCACTTGCTGCGTACCTAAGTTAAGGAGTTCAATATGTCGTGTATCCAA +CAGCAAACGCTTCGACGTTTAGACTTACTGATGCCTAAATGTAAGAAGTACAACGATAAC +CCTCAAGCTATTCCTTTAGAGGAACGTGAGGAATTATCAATGATGTTCGCTGCCACATTC +AAGAACTTTAAAGAGTTCGCTGAGTTGGGTATGCGATACCTTGGCTTTAAGCTATCTATG +ATTCAAGAAGACATTGCAGAGTTCATGCAGCATGGGCAAGCTAAGCGTATGATTCAAGCT +CAGCGTGGTCAAGCTAAATCGACCCTAGCTGCTTTGTACTGTATTTGGCTTCTTATCATA +AACCCGACTGCCCGTACACTTATTGTGTCAGGTGGTGAGAAGCAGGCATCTGATGTTGCA +TTGCTTATTATCCGAATTATTAATAACTGGTCTATCCTCTGTTGGTTACGCCCTGATGCG +TCCAAAGGTGATAGAACTTCGGCTAGTGCGTTCGACGTACACTACAGCCTAAAAGGTATT +GATAAGTCTGCGTCTGTATCTTGTGTTGGTATTACAGCTAACTTACAGGGTATGCGTGCA +GACTTTATTCTAGCCGATGATATTGAGACTCAACGTAACTCTATGACTCAGACTGAGCGT +GAGAAGCTATTGCTACTTACTAAAGAGTTCGCTGCTATCTGTATCTCAGGTGAGATTATG +TATTTAGGTACACCGCAGACTAAAGACTCTGTGTATCGCTCTCTCCCTGCTCGTGGTTAC +GACGTTCGTGTTTGGTGTGGTCGTTACCCTACCGATGAAGAACTCGAACGCTATGGAGCA +GGTGTGACGATTGCACCTATGATTCATCGTGCATTAATCGAAAACCCTGACTTACAAGTA +GGTGGTGGTGTTACTGGTCAACGTGGTAAGCCTACTGACCCTGCACATATCAATGAGGAA +ATCTTACAAGAGAAAGAACTTGAGTATGGTGATGAGGGTTTCTCATTACAGTACATGCTC +GATACAACGCTCTCAGATGCCCTCAGAACGAAGATTAAACTTTCTGATATGATTGTACTA +GGCGTAGGTAAAGACGAAGTGCCTGAGTCACTACAGTACGTCGCAGACCCTAATAAGTTA +TTCAAGGAAAATACTGAAGCTACTAAAGACTTCCGTATGTACCATGCTGCTGCTGTATCC +GATGTATTCGTACCATTTCTACATAAGGTGATGACACTTGACCCTGCGGGTTCAGGTGGT +GATGAATTGTCTTATGCTATTGGTGGTGCTACTACATCGTATATCTATTTACTTTCAGTA +GGTGGGTTCGCAGGTGGTATGACTGAAAAGAATATGAACTCCGTGTTGCAGAAGATGATT +GAGCATAACGTTAAGTTACTCGACATTGAGAAGAACATGGGTCATGGTACTGTTGCTATG +TTATTCCTAGCACAGTTAGATAAGCTGAAGCTTCACGCTTTAACTTCAAACCCTGCAATT +GATGAGTTTAAGAATCAGCTAGGTATGAGTTACAAAGAAGTACACACTGCCCTTAGTGGT +ATTGGTATCACCGAGTATTATGTGGTAGGTCAAAAGGAACGTCGAATCATTGATACGATC +TCACCTTTGACTCGTCGCCATAAACTTGTAGTATCTACTCAAGCTATTCAAGACGATTGG +AATCATTGCTTACAACATCCATCTGAGAAGCGTATGCAATTCTCTGCTTTCTATCAATTA +GGGAACATTACGTATGATCGCAATAGTTTAGTCCATGATGACCGAGCTGACTGTGTACAA +CGTGTGGTGGAAGTTCTAAAGGCGTTTCTAGCTAAAGATGAAGAAAAGGCTGCTGTATTG +CGTCAGGAGGCTGCTCATCAAGAGTTCTTGCGTAACCCTATGGGGTATACCCACGATGGT +TGGGATAACTCTAAAGGGTCTCGTAAGCGTTATCATGGGAGGTTCAAACGATGATCGATA +AAGAAGCAGTTACTAAGAAGTTAGAAACTATCAACGCTAGGATTAAAGATGCACAATCTA +TCCTAGCATTACTAAAAGCACTAAAGGAGAAATCAAATGTCAAGTATTAAAGTTATTGTT +GCTAATGTAGATGTACCTAAGTTAGCGAGCGGTGTGTCTAAGGCTCTAAGCGTCGCTAAG +GCGGTTAGTAGCACTAAGGTATACAAAGGTAAGGATAAGGTTGAGAAAGCCCTAGATCGA +GCTACTGTGGCTCTTGATGTAGGTGTAAGTATCTATCGTCTGTTCAAGCGTTAA diff --git a/example/multifasta.fna b/example/multifasta.fna new file mode 100644 index 0000000..4e1e36f --- /dev/null +++ b/example/multifasta.fna @@ -0,0 +1,9613 @@ +>NC_010807.ref length=38815 +TCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAAGCCAG +CCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCTATAGG +ATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGAGGCCT +TAAAGAGTGTCCTAGTGTACCAGTTCGATAGTACATCTCTATGTGTCCCTATCTGTTAGC +CTCATAAAGTAAACCCTAAAGCCACTACCTAAAGACCAGACCTAAAGCCATCACCTAAAG +AGCGACGCTATCTTAAAGACAACCAGACCGATAGACCCATTGTTAACCTGTAGTGATGCC +CTGTAGTTATCTGTAGTCATTTCATTAACCCTCACTAAAGGGAATAAGGGATACTTAAAG +GGGGGAATTAGGGATTTAATAAAAGATTAAAATTAATGGTTGACTTTAAGTAACCCTTAA +GGCTATTATTCATCACGTCAACGGGACAACGGCCTTAAAGCCACTCCCTGAGATACCGGA +GTCAACCGGATAAGTAGACAGCCTGATAAGTCATACGAAAAACAGGCATTGACAACGCAA +GGTAACAAGTAGTAAGATGCACAACATAGCGTCAACCACCAAATCGGTGTCTTCTAGGTG +ACTTAAGCGCACCACGGCACATAAAGCTAAACAAAATGGTTGACAACATGAAGTAAACAC +GGTACGATGTACCACGAAATGACGGAACAGTGAGGCGGGACACTGAAAGCCGCTAGGGTC +TAACGAAACCAGACCGACACGCAAATCATAGTAGGTTTAATAAGCGGTAAGTGTATTACT +TCCCTTGTGTGCCGCCGAATGGCATCAGTACACACGACAGGCAGTACGGAAAGTGACACG +ATGCAGTGCTGCCATGATTTGATCGCTCTTTAACAATCTGGATAATAGCTCTTGAGTGTA +CCGATGTATAAGCGAATAACTCAAGGTCGCACTGAAAGCGTGGCCTTTATGATATTCACT +TAACACGAACTAACATGAGGTAACACCAAATGATTTTCACTAAAGAGCCTGCTAACGTCT +TCTATGTACTGGTGTCAGCTTTCCGTTCTAACCTTGATGATGAGGTGAACATGAGCCGCC +ACCGCCACATGGTAAGCACTTTACGTGCCGCACCGGGTCTTTATGGCTCCGTTGAGTCAA +CCGATTTGACCGGGTGCTATCGTGAGGAAATCGCAAGCGCACCGACTGAGGAAAAAACGG +TTCGTGTACGCTGCAAGGACAAGGCGCAGGCGCTGAATGTTGCACGCTTAGCTTGCAATG +AGTGGGAGCAAGATTGCGTACTGGTATACAAATCACAGACTCACACTGCTGGTCTGGTGT +ACGCTAAAGGAATCGACGGTTACAAGGCTGAACGTCTGCCGGGTAGCTTCCAAGAAGTAC +CCAAAGGCGCACCGCTGCAAGGCTGCTTTACGATTGACGAGTTCGGTCGCCGCTGGCAGG +TGGCCTAACATGAATCGTTATTACATCAACGTACCGGGCTGGGGTGGGTCTCTGACCTGC +TACGGATACAACGAACGGGACGCACGGAAACGCTTTAGAGAACAACACGGCTTCGGAAGG +CTTCCTAATGGGACGCGCCTATGGCTGGACGCCCGTGATTGGTAAGTGATAGACTCAAGG +TCGCACTGTATGTGTGGCCTTTATGATTATCACTTATAGGACTAACACCATGAGTAAACT +TCTGGCAACATCTAAAATAGAAGGCCAATGCACCGTAACACTGCGTGAGTATTACCACGG +GTCAATGGGAAGCACCTATGTTGTGCGATACGGTAAACAGGTCACACATTGGGTAAACCC +GATTTTAGCACAAGAGGATTATCAAGCCTGTGTGATACACCAAGCAACATGTGCGGGCTG +GAATGATTGACATTACAGGAGGATTAGGAATGGTTATCTTTATCGCTGTCGCACTCTTTG +CGGTCGCTGGCTGGTACTCTGAGTCACGCAAGGCCGCTCGCTATCATCGCAAGATGGTTA +AACTCATGGAACACTTGGACGCAGAAGGGCGAGGCCGCGAGGCTATCGAACTGGTGAAAC +ACGCATGATGATTCTCTCTATCGCACTGGTCTATCTGTGCATCGCAATGTACTTTATGCG +AGACTTTAAGCGCGGTCTGGCAATACACAAGGCAACGCTGAGTTACTTTAAGCGCGGTCT +GGCAATACACAAGGCAACGCTGAGTTACTTTAAGTGGGGATTCATCCCACGGTTTACGGT +TCGTGAACGCAACGGACGCTTTAAGGCCAACAAGGTAGGAGTATTCTACATTGCTACGCA +CTAACTCAAAGCACGTAAAGACCGCACTGTATGCGATGGCGTATGGTGCATCGAAACGCA +AGGTCAAACGCATCTTAACGAGACACCGCAAGATGACCGCACGACAGGCTGCAAGCGCTG +TCAAATGGGCTGAATTTACTCTTTACTCTTCTTACAGATAACAGGACACTGAACGATGAC +TTTCACCGAAGCACAAGCCGCACTCGAAGCTATCCGCAACCTACCGATTGAGCGCCTGAA +CGAACGCCAGCCCATGCTGGTGGCTCTTGCGGCTGCTATCGTGAACGCTGAGACCCAAGA +CGGCGAACTGACGCAGGCCAAGGGTAATTGGGGTCTGGAGTCTATGGACTACTGGCAGAC +ACTGGCTGAGCGTATGCGTGATGTTGGATTTGTACGCTTGGGCAACGGTCACTTTAGCGC +AGCATATGAGCACGCATTGTTACCGGGCAAGGTTATCAAGGTAGGCTTTAAGAAAGAGGA +TTCAGGCGCTGCCTATGCCGCATTCTGCCGTATGAATCAGGGTCGTGAGGGCATCCCTAC +GGTGTACGACATTCAGCGTCATACAGGCTGCTACACGGTGGTCTTGGACTATCTGACACC +GCTTAATGACTGGTGCTACGGTGAAAGTGATAAGATTCGTCACCACTTTCAGGCTGCACA +GGAAATCATTCAGGAGGATTGCTTCGATACCGCCGAAGAGTACCCGATAAGCGAGGGCTT +CATTGAGACCTGCAAGGATATCCGCAAGTTCTTCTTAGGCATCGCATCGTTCGATTGTCA +CAGCGGGAACATGATGAAAGACCAGATGGGACGCCTGATTATCACAGACCCGGTATCATT +CAGCGCAGACGACAAGTTAAAGCCGGGTGAGTTCCACTGTGACCCGGATGAACTCATCGC +TGAGATTGAGGCGCTGAGAGCGCAGGAAGCGATTGACCGCTGTAAGGCACGCAAGGCACG +CCGTGACCCTAAAGGAGACTTTCAGGTAGCACGTAAAGCCCGTGCCAAGTGGCGCAGAAA +GGCCTCTAAGCGCGAGAAGCGCAACGCTAAGGTGCTCGCTAAGATGCGCATGGATGCTAA +TCAGAATCGCAGGGATGAGCCTAGGGCGCGTATGGTGTGGGGCGATAAGCACTGGCGCAA +CGCTTGGATGCACCACAATAACCTAAACTTTGCAGAACTGGAGCGCCGCGCTGCTGCGGC +AATGATGATGCATGACGAGGTGCGCATTCAGTGGGGCAAACCGTTACACATAGACGCATA +CCTTGACAAGCGTCTACAAGGCTGATAGAGTCTTATCTTACAGGTCATCAATCGGTGGCC +TGAATAGGTACGATTTATTCACAATGAGGTAAGCAATGAACATCATCGAAAACATCGAAA +AGAATGACTTCTCCGAAATCGAACTGGCTGCTATCCCGTTCAACACACTGGCAGACCACT +ACGGCAGCGCATTGGCTCGTGAACAACTGGCTTTAGAGCATGAGTCTTATGAGCTAGGCG +AGCGCCGCTTCCTCAAGATGCTTGAGCGTCAAGCGAAAGCTGGTGAGATTGCAGACAACG +CAGCCGCTAAGCCATTACTCGCTACGCTTCTCCCTAAGTTAACCGCACGCATCGTTGAGT +GGCTCGAAGAGTACGCCTCGAAGAAAGGCCGCAAGCCAGTAGCCTATGCACCGCTCCAGT +TACTCAAGCCGGAAGCCTCCGCGTTTATCACACTCAAGGTCATCCTTGCGTCACTGACCA +GCACGAACATGACAACCATTCAGGCCGCTGCTGGTATGCTGGGGAAGGCCATTGAGGATG +AGGCACGTTTCGGTCGCATCCGTGACCTCGAAGCGAAGCACTTCAAGAAGCACGTTGAGG +AACAGCTTAACAAGCGCCACGGGCAAGTCTACAAGAAAGCCTTTATGCAGGTGGTCGAGG +CCGATATGATTGGTCGCGGGCTGCTGGGAGGTGAGGCGTGGTCTAGCTGGGATAAAGAAA +CCACGATGCACGTAGGGATTCGCCTGATTGAAATGCTGATTGAATCCACAGGTCTGGTGG +AATTACAGCGCCACAACGCAGGTAACGCAGGCTCTGACCATGAGGCACTGCAACTGGCCC +AAGAGTACGTGGACGTATTAGCGAAGCGTGCAGGCGCTCTGGCGGGTATCTCTCCGATGT +TCCAGCCGTGTGTCGTACCGCCGAAACCTTGGGTAGCAATCACCGGGGGCGGCTATTGGG +CTAACGGTCGCAGACCTTTGGCACTCGTCCGCACTCACTCTAAGAAGGGACTGATGCGCT +ATGAGGATGTTTACATGCCAGAAGTTTACAAGGCGGTCAACATCGCACAGAACACCGCAT +GGAAAATCAACAAGAAAGTTCTTGCGGTTGTCAATGAAATTGTTAACTGGAAGAATTGCC +CGGTCGCAGACATTCCATCGCTGGAGCGCCAAGAGTTACCGCCTAAGCCGGACGACATTG +ACACCAACGAGGCAGCACTCAAGGAGTGGAAGAAAGCCGCCGCTGGTGTCTACCGCTTGG +ACAAGGCACGAGTGTCTCGCCGTATCAGCTTAGAGTTCATGCTGGAGCAGGCCAACAAGT +TCGCAAGCAAGAAAGCAATCTGGTTCCCTTACAACATGGACTGGCGTGGTCGTGTGTACG +CTGTGCCGATGTTCAACCCGCAAGGAAACGACATGACCAAGGGGCTGCTGACCCTCGCTA +AAGGCAAGCCAATCGGTGAGGAAGGTTTCTACTGGCTGAAAATCCACGGTGCGAACTGTG +CGGGTGTCGATAAGGTTCCTTTCCCTGAGCGCATCGCGTTCATTGAGAAGCACGTAGACG +ACATTCTGGCTTGCGCTAAAGACCCAATCAATAACACTTGGTGGGCTGAGCAGGATTCAC +CGTTCTGTTTCCTCGCGTTTTGCTTCGAGTATGCAGGCGTTGCGCACCACGGTCTGAGCT +ACAATTGCTCTCTGCCGCTGGCGTTCGATGGGTCTTGCTCCGGTATCCAGCACTTCTCCG +CGATGCTCCGCGATGAGGTAGGCGGTCGTGCGGTTAACCTGCTGCCAAGCGAAACCGTGC +AGGACATTTACGGCATCGTTGCACAGAAAGTAAACGAGATTCTCAAACAGGATGCAATAA +ACGGCACACCTAATGAGATGATTACCGTGACCGACAAGGACACCGGGGAAATCTCTGAGA +AGCTCAAGCTGGGAACCTCAACGCTGGCGCAACAGTGGCTGGCATATGGTGTAACCCGTA +GCGTAACTAAACGTTCGGTCATGACGCTGGCTTACGGTTCCAAGGAGTTCGGCTTTCGTC +AACAGGTACTGGACGACACCATTCAGCCTGCGATTGACAGCGGTAAGGGCTTGATGTTCA +CCCAACCTAACCAAGCGGCTGGTTATATGGCTAAGCTGATTTGGGACGCGGTGAGCGTGA +CCGTAGTCGCAGCGGTTGAGGCGATGAACTGGCTCAAGTCTGCCGCTAAGCTGCTAGCTG +CTGAGGTCAAGGACAAGAAGACCAAGGAGATTCTTCGCCACCGTTGTGCGGTTCACTGGA +CTACGCCGGACGGATTCCCGGTCTGGCAGGAATACCGCAAGCCACTCCAGAAGCGTCTCG +ATATGATTTTCTTAGGGCAATTCCGTCTGCAACCGACGATTAATACCCTCAAGGATTCAG +GCATTGACGCACACAAGCAGGAGTCTGGCATCGCTCCTAACTTTGTTCACTCACAGGATG +GTAGCCACCTCCGCATGACGGTCGTTTATGCTCACGAGAAGTATGGCATTGAGTCCTTTG +CGCTAATCCATGACAGCTTTGGGACTATTCCGGCAGACGCTGGTAAGCTCTTTAAGGCTG +TGCGTGAAACGATGGTTCTCACCTACGAGAACAACGATGTGTTGGCAGACTTCTACGACC +AGTTTGCAGACCAGCTTCATGAGACCCAACTGGACAAGATGCCACCACTTCCGAAGAAAG +GTAAGCTGAACCTACAAGACATTCTCAAGTCCGACTTTGCCTTTGCATAACAAGCACTTA +GCATTAACCCTCACTAACGGGAGACTACTTAAGGTCTCCCTTAAGGTACTAAGAGATTTT +AATTTAAGATAACTAAGAGGTTTACTTTATGATTACTTTATGTGTCGCAATCGTTCTTAT +CGCTACACTCTCAATCGTCATCGCTAAGCAGCGCTCTGAGTTAATCAAGCTGGATGCCCG +ATATGATAGTGCGAACCACCACCGGAAAGAACTGGATGCAGCACTTGGGCGGTCAACCGA +TGAGGTTAAGACCCTTAAGCGCCAGCTACAGCACGCCGAGCAAGACGATAAGAACCGCTG +CGAAACAATCCGAGGTCTACGTGAAGAACTCCGGGAGTTGCGCCAGACGATTAAAGAGCG +CCACGCTATCCACGGCATCAAGTTCGTAGCGAACGTTCCGATGAAGGGCTGGACGCCCAC +CGAGTTTAAGCTGGGTCTTGGTAAGTGCGGTCTGGAAGTGGCGAGTCTAGTGTGGGAAGA +GAAGTCTGACCGCTATGTGTTGACTCAACGCCACACCGACGGAAGCCGAAAGGTCTTTGA +GTACAAGAAGGAAGACGTGCAAGGAAGAATCGAAGTGTTCTACCCTGCCGTTAAATAACC +CTCACTAACGGGAGAGTTAGCCTCAAGGTCATCACCGACGGTGGCCTTTGTGATTAACTT +TCAATACACATCAACATGAGGTAAGATACTATGCGTACCAACTTTGAGAAATTTACCAAG +CGCGATTCAGTGGTCAACGAGCATGGCGAACAGTGGCAAGAGCGCCGTGACCGCATGAAG +AAACGCCACAAGCAACAGCGCGGTAACTCACAGAAACGGGAGTGGAACTAATGATGATGG +GACGTATCTATAGCGGCAACCTGAACGATTACAAAGATGCGGTAGCGCGTCTACAGGAAG +ACCATGACGTGACCGTGAAGGTGGAGTCATTCAGCTATGAAAACCCAGCGAAGATGTGCA +GGTCATCCGGTGAGGTTCTCCGTGTGTTCACACGCTCCGGGCATCCGGTGGCATCCAGAA +CCTTCGAGCACAGCGACAGTGATGTACAAATCAACGCGCAGACTGCATGGCTCCGTAAGG +TTCACAGCGATTTGAAACACTGGAAGTAATAACCCTCACTAACAGGAGAATCCTCAAGGT +CATCTTAATTGGTGGCCTTTGTGATTCGAACTGATTAACTTTCAACCAATGAGGAACAAC +CGTATGAACATCTTCAAGACCAACCCATTCAAAGCTGTGTCATTCGTAGAGTCTGCCGTT +AAGAAAGCGCTGGAGACCTCCGGCTACCTGATTGCGGACATTAAGTATGATGGCGTGCGT +GGTAACATTGTGGTTGACAACGTGGCTGAGGCCGCATGGCTGTCCCGTGTGTCCAAGTTC +ATCCCGGCGCTGGAACATCTGAACGGTTTCGATAAGCGCTGGCAACAACTGATGAATGAT +GACCGCTGTATTTTCCCTGATGGCTTCATGCTGGATGGCGAACTGATGGTTAAGGGCGTA +GACTTCAACACAGGGTCTGGCCTACTGAGAACCAAGTGGCTCAAGAAGAACAACTTCATG +TTTGACCGTGGTGGTGTTGAGCCACTGAAAGGTTCCAAAGTAGCCTTTGAGTTAGACCCC +AAGCTACTCAGTGTTCGCCTGTATGCTGTCCTTCCGATTCACATTGCGGAGTCTGGCGAG +GACTACGATGTACAGAACCTACTGATGCCATATCATGTGGAAGCCATGCGCTCTCTTCTG +GTTGAATACTTCCCGGAAATCGAGTGGCTTATCGCTGAGACCTACGAGGTCTACGATATG +GATTCGCTGACTGAACTGTACGAAGAGAAGCGTGCCGAAGGTCACGAGGGTCTCATTGTG +AAAGACCCACAGGGCATCTACAAGCGAGGCAAGAAGTCTGGCTGGTGGAAGCTCAAGCCT +GAGTGTGAGGCTGATGGTATCATTCAGGGTGTCAATTGGGGAACCGAAGGTTTAGCCAAC +GAGGGCAAAGTGATAGGCTTTAGTGTGCTTCTTGAGACTGGTCGTTTAGTAGACGCCAAC +AACATCTCTCGCGCACTGATGGACGAGTTCACAGCCAACGTTAAGGCACACGGTGAAGAC +TTCTACAACGGGTGGGCCTGTCAGGTCAACTACATGGAAGAGACCCCGGACGGCTCCCTG +CGTCACCCTAGCTTCGAAAAGTTCCGAGGCACTGAGGACAACCCTCAAGAGAAAATGTAA +CCAACTCACTGGCTCACCTTCACGGGTGGGCCTTTCTTCGTTCTAGGGAATTAACCCTCA +CTAACAGGAGACACACCATGTGGCTTATCCTATTCGCTATCGTCGCAACGCTGGGATTAA +TGGTTGCCGACGACGACATTTGGCCTGATTGTTAAGGAGACAACATCATGCGTTTACACT +TCAACACATCAAATGGTATCTTTTCGGTTCGCCGTGAAGACCGCTCTACAGCAGTGGCCT +CTGAGCGCAACGCTAAGCTGCCGCTGATTGGCTCGGTCGTCCCATTGTCGCCTCGTGTTC +ACCTACTGATCACTCGTGGAGAGTTCATTAAGGCGATGAACAAAGAGCGCCCGCATCTGG +AAGCCGTGGTCACTTGCTGGCCTCGCATCCGTCTGTTCGTTAAGTGGATTAAGGAGGTTC +TGTAATGTTACAACATCATTGGAACAAACCAGATTTAGAGGCTCGCTTCCCGGTTAACTC +TGCTGTGCGATACTCCGGCGACTTCCTCAAGCGCTTCTTAGGTATGAGCGGAGTGGTCAC +TGGTCACTCGAACACAGGTCGCGTTAAGGTTCGCTTCGGTAATCAGCACGCTGAGTTTCT +TCCGAACAACCTGATTCCGCTGCCTAAAGATGACGTTAAGACTCCGAACGTGGAAGCACC +GAAGTCAGAAGTCAAGTCTGACGTAACCCACCCTAACCACTACATGCTGTTCGACAACGT +GGAAGCCATTGAGGTTATAGCCCGGTCAATGACCGTCGAGGCGTTCCGTGGGTACTGCCT +TGGGAACATCCTGAAATACCGTCTTCGTGCTGGTAAGAAATCCGAACTGGCAACTATGGA +GAAAGACCTCAATAAAGCTGCATTCTATCAGGAACTCTTTGACAAACATAAGGGGCTGTG +CTATGACGCTTCGTGAATGCTGCGATTGGTGTGCCGCTAAGTGGAACCAAGCTATTGAGG +ATGGTGACAAGGCGGCTGCTGACGCTTACCAACAACTGTACGCGCTGTGGGAGCGGCGCT +TTAAGGAGGCTCAAAGTGGAGCAACGTGAACAGAAATACCTTCTGACGATAGAAGGCAAC +ACCGAGTCCTTTGAGGTTCCGGTATTCGCCCGGTCTCTCGAAGAGGCAACGCTACAGGCT +GAACATTATGAGGACGCTGGGTTCGTAGTGACTCGCATCCGTCCAGAAGTGAAAGCCTAA +TTACCCTCACTAAAGGGAACAACCAAATCATTAACCACAAAGGAGAAACATTATGGCTGG +TTTCAAGAAGAAAATCTACACCTCTGGTCTTGGCACTGCTGAGCCTTATGCTTACCTGAG +TAAGCCGGATTATGGCAACGAAGAGCGTGGCTTCGGCAACCCTCGTGGTGTCTATAAGGT +AGACCTGACTCTTTCCAATAAAGACCCGCGCTGTCAGGCGATGGTCGATGAAATCGTGAA +GACTCACGAAGAGGCTTATGCTGCTGCCGTGGAAGAGTTCGAAGCTAACCCGCCGCAGGT +ACAGCGTGGTAAGAAACCACTGAAACCTTACGAGGGCGACATGCCGTTCTTCGATAACGG +TGACGGTACGACTACCTTCAAGTTCAAATGCTATGCGTCTTTCCAAGATAAGAAGACCAA +AGAGACCAAGCACATCAATCTGGTCGTGGTCGATAGCAAAGGTAAGAAGATTCAGGAAGT +GCCGATTATCGGTGGCGGCTCCAAGCTGAAAGTGAAATACTCTCTGGTTCCTTACAAGTG +GAACACCGCTGTGGGCGCAAGCGTCAAGCTGCAACTGGAGTCCGTGATGCTGGTCGAACT +GGCTACCTTCGGCGGTGGCGGTGAAGATGAGTGGGCTGATGAAGTCGAAGATGGTGGTTA +CACTGCGAGTGAATCCCGTCAGTCCCGCGATGAGCAGGAGTGGCAGGAAGACGAGCACGA +AGAAACCCCGGATGATAACGAGGACTTCTAATGGCTGGCGCATACGCTGCGCGAGGTGTA +CGCAAGGTCGGGGCTTTCCGCTCCGGCCTAGAAGATAAAGTCTCAAAGCAGCTTGAGAGT +AAGGGAATTAAGTTCGACTATGAGCTTTGGCGTATCCCTTACGTCATCCCTGCGAGTGAC +CACTTATACACTCCAGACTTCCTGCTACCTAATGGCATATTCATTGAGACCAAAGGGCTG +TGGGATTCCGATGACCGCAAGAAACACCTTTTGATTCGTGAGCAACACCCTGAACTGGAT +ATTCGCTTGGTCTTCTCAAGCAGCCGCTCAAAGCTCTACAAAGGTAGCCCAACAAGCTAC +GCCGAGTGGTGTGAGAAGCATGGCATTCTGTTTGCTGACAAGCTAATTCCGGTGGAGTGG +CTCAAAGAACCCAAGAAGGAGGTTCCGTTCGATAAATTTAAGACTAAGAAAGGAGTAAAG +AAAAATGGCTAAAGTTCAATTCAAACCACGAGAAACCACGGAGGCAATCTTTGTACATTG +CTCAGCAACCAAGCCAAGCCAGAACATTGGCGTTCGTGAGATTCGTCAGTGGCACAAAGA +GCAGGGCTGGTTAGACGTAGGATATCACTTCATCATCAAGCGTGATGGCACTGTGGAAGC +AGGCCGCGATGAACTGGCTGTAGGTTCCCACGTGAAAGGTTACAACCACAACTCCGTAGG +CGTATGCCTCGTGGGTGGGATTGATGATAAAGGCAAGTTCGACGCCAACTTTACACCTGC +GCAAATGCAAGCGCTGCGTAGTCTGCTGGTCACGCTGCTGGCGAAGTATGAGGGTTCAGT +CCTTCGTGCTCACCATGACGTTGCATCCAAAGCCTGCCCGTCCTTCGACTTGAAGCGCTG +GTGGGAGAAGAACGAACTGGTTACATCTGACCGAGGGTGATACCATGAGGATGATTTGTA +TTCGCTGTGATAAGCCGTTGAAGAGTCGTGTACCGTCACGTCAGTGTCAGTGCAAAGACC +CAATCAAGGCGGAGGAACACACCGAGGAATAATTAACACTCACTAAAGGGAGACTTAACG +GTTTCCCTTTGTTCGCACTATTGATTAAGGAATGTACAATGGAACGAGAAGACGATAGTA +TCTTTCTGTTTCATGCTCCATGTGAAAACTGTGGGTCTTCTGATGGTAACTCTGTGTACT +CTGACGGGCATGAATGGTGCTTCGTGTGTGAACATCGAGTACCCGCAAACGAAGAGCGTG +AAGCAAAGTTATCAACGAGAAGACGTACAGGAGGCAGCAAGCCTATGAGCTATGACGTAT +GGAATTTCGGTGACAGCAACGGTCGATACTCTGACCTGACTGCCCGTGGCATCTCGAAGG +AGACATGCCAAAAGGCTGGCTACTGGCTGGCGAAAGTGGACAACCGAATGTATCAGGTTG +CCTACTACCGAGACCAGAACGGCTCCATCGTGTCGCAGAAGGTGCGCGATAAGGACAAGA +ACTTTAAGACCACCGGAAGCCACAAGAGCGATGCGCTGTTCTTGAAGCACCTCTGGTCTG +GCGGTAAGAAAATTGTGGTCACTGAGGGCGAAATTGATGCGCTCACTGTGATGGAACTCC +AAGACTGTAAGTACCCGGTCGTATCATTAGGTCACGGTGCCTCTGCTGCTAAGAAGACAT +GCGCCGCTAACTATGAATACTTTGACCAGTTCGAGCAGATTATCTTGATGTTCGACATGG +ATGACGCAGGCCGTAAGGCAGTCGAAGAGGCCGCACAGGTTCTCCCGGCTGGTAAGGTTC +GTGTTGCCGTGTTGCCGTGTAAGGACGCCAACGAGTGTCACATCATGGGTGAAGACAAAG +CAATCTTGGAGCAAATCTGGAACGCGAACCCTTGGGTGCCTGACGGTGTTGTTTCTGCGT +TGTCACTCAAAGACCGCGTTAAGGAAGCTATGACCTCCGAGGACGCTGTAGGTTTATTAT +TCGATGGCTGTCAAGGCCTGAACGATAGAACCTTGGGTGCTCGTGGTGGCGAAGTCGTTA +TGGTCACTTCCGGTTCCGGTATGGGTAAGTCAACGTTCGTTCGTCAACAGGCTCTGGCTT +GGGGCAAGCGAATGGGTAAACGTGTGGGCCTAGCGATGTTGGAGGAATCCGTTGAGGATA +CCATTCAGGACATGATGGGCTTGAACAATAAGGTTCGTCTGCGTCAGTCTGATGAAGTCA +AGAAGGCTATCGCAGAGGACGGACGTTTCGATGAATGGTATGATGAACTATTTGGAGACG +ATACGTTCCACCTTTATGACTCCTTTGCGGAGGCCGAAGCTGACAGGCTGTTAGCGAAGC +TGGCCTACATGCGAACAGGCTTAGGGTGTGATGTTATAGTGCTCGACCACATATCAATCG +TCGTGTCTGCCTCTGAGGAATCGGATGAGCGTAAGATGATTGACCGCCTCATGACGAAGC +TCAAAGGGTTCGCTAAGTCAACTGGTGTTGTGCTCGTAGTGATTTGTCACTTGAAGAACC +CGGAGAAGGGAAAACCACATGAAGAAGGACGCGCTGTTTCTATTACTGACCTACGTGGTA +GCGGTGCCTTGCGTCAGTTATCTGATACTATCATCGCCTTGGAGCGTAACCAGCAAGGTG +ATATGCCTAACTTGGTGTTGGTTCGCCTGCTTAAGTGTCGTTTCACTGGCGACACTGGAA +TTGCTGGGTACATGGAATACAACAGAGAAACCGGGTGGCTTGAACCGTCTAGCTACACTG +GCGAAGAAGGAGAAGGAGATACTGGCTGGACTGAACAAGACGGACAATCAGACTTCTAAA +GGATGCCCGTGTGGGCATTCCGATTGCGATGGAATCATGTACCACTAATTAACCCTCACT +AACGGGAACAACCATTAAACCATAGGAGACACATCATGTTTAAATTCATTAACGCTTTAG +GTAAGCTGGTAGTTAAACTGTACTTCATCGAAGCCAAGAAGCTGGACAAGAAGGCCAAAG +CTGATTCACAGCGAGCCATTGAGTTGGCGAAACAGTCCCGTGAGAAATCCGATGCGGCTG +TTAGTGGCATCCACAAGTCGGCAGCGATTGCAGCCAAAGCACAATCCATGAGCAAATTCT +TTGAGTAAGGAGCGCACACTATGAGCAAGTCAATCACCCACGCAAACACCATCCGTCTGC +CAGACACCGCTGACCAGTTCTCCCGCCGAGTACACATCAATGTGCGTGGTGAGAAGGTCA +CGATGGTCTACCGCTGGAAAGACCACAAGTCTCCGAAAGCACACACTCAACGAATGACCT +TGGATGACAAGCAGGTCGGTCGCTTGATGGGTGCCCTGACTATGGCTGCTGACAAGGTGG +TCGGTGATAACCGTGAGCGTCTGGTAGAGTTCGGCGCTGGTATGCAAGAGATTATCGAGA +AGTGATAAACTCAAGGTCGCCCAAGGGTGGCCTTTATGATTATCATTTAGCACGAAACCA +AAGGAGGGCATTATGCTCGTAAGTGACATTGAGGCCAACAACCTCTTAGAGAAAGTCACC +AAGTTTCACTGTGGCGTTATCTATGACTACCGTGATGGTGAGTATCATAGCTATCGTCCG +GGCGACTTCGGGGCGTATCTGGATGCGCTGGAAGCCGAGGTGAAGCGAGGTGGGCTTATT +GTTTTCCATAACGGTCACAAGTATGACGTTCCGGCTTTAGAGAAACTCGCAAAGCTGCAA +CTCAATCGTGACTTCAAGTTACCCCGTGAGAACTGTATTGATACATTGGTACTCTCGCGT +TTACTTCATGCGAACCTTAAAGACACAGACATGGGGCTTCTTCGCTCCGGGAAACTACCC +GGTCGTCGCTTCGGGTCTCACGCTCTGGAGGCATGGGGCTATCGCTTGGGTGAGATGAAA +GGTGAATACAAGGACGACTTCAAGGCTATGCTGGAAGAGCAGGGCGAAGAATATGTTGAT +GGTGCTGAGTGGGTTTCGTTCAACGAGCCGATGATGGCGTATAACGTTCAAGACGTTGTG +GTCACTGTCAAACTCTTAGAGAAATTCCTTACAGACCTCCACTACTTCCCTGCGGGTATG +GACTTCACGAAGTACGATGCGGATTTATTCTGGCGAGAAGCTGGCGAGTCTGTGGATATT +GAACATCGTGCAGCGTGGCTTTTAGCGAAGCAGGAGCGTAACGGCTTCCCGTTCAACACC +AAGGCAATTGAGGAACTTTATGTAGAACTGGCAGCGAAACGCGCCGAACTTCTGCAAAAG +CTAACCGAAACGTTTGGCTCATGGTATCAACCGAAAGGCGGTAAGGAACTCTTCAAGCAC +CCACGGACAGGCAAGCCGCTGCCGAGCTATCCTCGCGTGGTCTATCCGAAACAGGGTGGC +GTGTACAAGAAGCCTCGTAATAAGGCACAGCGCGAAGGTCTTGAACCTTGCGACTTGGAC +ACGAGGGATTACATGGAGGGTGCTCCATATACTCCGGTAGAGTTCGTTACGTTCAAGCCA +AGTAGCCGTGACCACATTCAGAAGAAACTACAGGAGGCCGGATGGGTTCCTGAGAAGTTC +ACCGAGAAGGGTGCGCCTGTGGTGGACGATGAGGTCTTGGAGCATGTACGAGTGGATGAC +CCTGAGAAGCAGGCGTGCATTGACTTGATTAAAGAGTACCTGATGATTCAGAAGCGAATC +GGTCAGGCGGCAGAGGGTGACAAAGCGTGGTTACGTTATGTTCAAGATGATGGTAAGATT +CATGGAGCCGTTAACCCTAACGGTGCAGTTACTGGTCGTGCTACTCATAGTTTCCCAAAC +CTTGCACAAGTACCCGGCGTTCGTTCTCCTTACGGGGAGCAGTGTCGTAGCGCTTTTGGT +GCTGAACATCATTTGGATGGGATTACTGGCAAGCCGTGGGTGCAAGCGGGGATAGACGCC +AGTGGCTTAGAGTTGCGCTGTCTGGCACACTTCATGGCTCGTTTCGATAACGGAGAGTAT +GCGAATGAGATTCTCAACGGTGACATTCACACCAAGAACCAGAACGCTGCGGAACTCCCA +ACGCGAGACAACGCCAAGACCTTCATTTACGGGTTCCTTTACGGAGCAGGAGATGAGAAG +ATTGGTCAGATTGTTGGGGCAGGGAAGGAGCGCGGGAAGGAACTCAAGAAGAAATTCTTA +GAGAACACCCCGGCGATTGCAGCGCTACGAGAAGCTATCCAACAGTCTCTCGTTAAGTCT +TCCGCTTGGATTGGCGCTGAGCAGAAAGTACAGTGGAAGCGCCGTTGGATTAAAGGTCTG +GATGGTCGCAAGGTTCACGTCAGGTCTCCACACGCAGCGCTCAACACATTGTTGCAGTCT +GCTGGTGCTCTGATTTGTAAGTTGTGGATCATCAAGACCGAAGAGATGCTCATTGAGAAA +GGCTTGAAGCATGGCTGGGATGGTGACTTTGCGTACATGGCTTGGGTTCACGATGAGATT +CAGGTGGCCTGCCGTACAGAGCACATCGCTCAGATTGTTATTGACACCGCGCAGGAAGCT +ATGCGTTGGGTCGGAGAGCATTGGGCTTTCCGTTGTCGTTTAGATACCGAGGGTAAGATG +GGGCCGAATTGGGCTGTCTGCCACTAACAATAGGAGAAACATTATGGCAATGACCAAACA +CTTTAAAGTAACCTTCGACGTTACCGCTGTGATTGACAGTGAATCCGAGAAGAATCTGAA +CGAGTTGCTGGTAGACCTAGCTAAGAAGGCCGGGGCTGGCGAGAAGCTGAATCCGTTCAA +ACAAGAACTGCTTATTCAAGGCCTGACACACGGGCCGGAAGGTGCTGCTGCGTTCTGTAT +CAAGCAAGGTCTCCGTGAGTTTATCCGCGATGGTCACAGTGAGTTAAGCTCTACCGAGCA +GAAGCTGATGAGATTCTCACCTGCAACTGTGCGAGAGGTGTTCAAATGAGTGAATACCTG +AAAGTTCTGGCAGCTATCAAAGGTTGCCCTAAGTCCTTTCAGTCGAACTATGTGCGAAAC +AATGCGGCTCTCGTAGCTGAGGCCGCTTCTCGTGGACACATTAGCTGTTTGACTGTGGGC +GGTCGCAATGGTGGAGCATGGGAGGTCACAGCCTCTGGTGTGCGCTTCCTGAAACGAATG +GGAGGTTGCGTATGATTATGCCTAAGAGTGACACCGTAACGATGACCCGTGATGCGTGGA +ACGATGTTAGCGCGTACATTGATAAGCTGGAGAAAGGCCTAGAGTTCCTGAATGCGCTTA +AGGCGTGTGGTGTGGATAATTGGGACGGATACTCTGATGCAGTCGAAATGGTTTACGGGG +AGGATGACGAATGAGCCTAATCACATTGAAAGACTTCGCGGAGATGCGTGAAGGTAATCC +TATGGAGAAGGGAGTGCTGGTCATGGATGGTGACTGGTTGGTATATCAGTCAATGGCTGC +TGCCGAAGTTGAGACGGATTGGGGAGACGACATTTGGACTCTTGAGTGTGACCACGCCAA +GGCACGGAGCATTCTCGATTCTGCAATCGAATCGTACCGAACCCGTAAGAAGGCTTGGAG +TGACGCTATGGTTGTTCTGGCGTATACCGACGATGTGAACTGGCGTAAGGTACTGGTTGA +TGAGACCTATAAGGAGAACCGTAAGGCGACCCGTAAGCCTGTGGGCTACCGTGACTTCCT +GTCGAAGCTGTGGGAGCGCGATGAGTTCATTCACATCAAAGAGGACATGCTGGAAGGTGA +TGACGTTATGGGTATCATTGGGTCTGGTCACGAGGTCTTCGGCTTCAAGAAAGCTGTGTT +GGTCTCCTGTGATAAGGACTTCAAGACTATACCGGACGTTGACTTCCTGTGGTGTACCAC +TGGTAACATCTTGACGCAGACCAAAGAGACCGCTGATTGGTGGCATCTCTTCCAGACTAT +CAAGGGCGATATGACTGATGGCTACTCCGGGATTCCCGGTTGGGGTGACACGGCAGAAGG +TTTCCTGAATGACCCGTTCATTGTGGAGCCTGTAGAGTCCGTGTTGAAGTCCGGTAAGAA +CAAAGGGCAGACTGTCACTAAGTGGGTGAAACGCGCTCCTGATGCGACTGAGAGCCTGTG +GGACTGCATCGTATCCATTGGTGCCAAAGCTGGGATGACCGAACATGAAATCATTAAGCA +AGGCCAGATGGCACGCATTCTTCGCTTCGAGGAATACAATTACATTGACAAGGAGATTTA +CTTATGGACGCCGCGAAGCTGATTACCATCGCTGTGCTGGTAGGTATGCTGGCGCGAGGT +CTCTGGATGTTCGCTCTCATAGTCCGAGACGTGAAGCGAGACTCCGAGATTAAGTGATAC +ACTCAAGGCTCTCTGTATTAACCCTCACTAAAGGGAAGAGGGAGCCTTTATGATTATTAC +TTTAAGACTTAACCTTAAGAGGTGAATTTATGTTACAACCAATTAATCATGTTTTAACTC +ATCCCGATGATATTCCTAGTATGCCGCGTGCAGCTAAAGAGTATCTACAGGTGCGCTTCA +ATCAGGCTTATGTGATGGAGTCCGGGGAGTACCGTGCGCTCCGCGCTGCTGGTTACTCTG +AGTCTTTCATTGCGGGTGTGATGCATGGTCTGTACCTTGCCTCTCGAACACTTGATGAGA +TTGAGGTGCGTAAAGAGCAACTGAGACAGGAGTAACGATATGTGCTGGAAACCGAAGGTG +AAAGTCCCTAAGATGGACACTAACCAGATTCGCGCTGCTGAACCAGCACCTTTGACTGAA +CCTCCGAAGTCTGTGGTATGGGGAGGCGATGATGACGAGGACACCAGTGTGTCTTCCTCT +GAGGTGCCAACCACACCGAGCAGCGGTAAGAGCAGTCTCAAGGTAAAGCTGGATGACAGC +GCAGCCAAGAACAAGAGTAAATCCTCCATTCGCTCCAAGGCGTTTGGGTAACTGAGTCAT +AGCATAGGGAGAAACATCATGGGATTCTTCAAGAAAATCAAGAAGGCCGTTAAGAAAGTT +GTGAAAGAAGTTAGTAGACCAGTCGAGAAGGCCGGTAAGGAAGTGGGCAAGGTGGTTGGA +GGCGCGCTGGGTGCAGGTAAGCAGGAGATTATCCAACAAGAGGCTCCTGTACCAGTAGTC +GCTGCACCGCCACCAGCACAGGTTGTAGATGTACCGGAACAGGATAAGGCTGAGGGTGAG +GATGAGGCGCAAACCGAAAGCGCACGTAAGAAAGCACGCGCTGGCGGTAAGAAGTCTCTG +AGTGTAGCCCGTAGCTCCGGCGGTGGCATCAACATCTAAGGAGGACTGAATGGCTGATTC +AAAACGTACAGGATTGGGCGAAGACGGTGCTAAAGCTACCTATGACCGCCTAACGAACGA +CCGTAGAGCCTACGAGACTCGTGCGGAAAACTGTGCGCAATACACCATTCCGTCCTTGTT +CCCGAAGGAGTCCGATAACGAATCTACCGACTACACGACTCCGTGGCAGGCTGTAGGTGC +GCGGGGTCTTAACAATCTGGCCTCTAAATTAATGCTGGCACTATTCCCGATGCAGTCGTG +GATGAAGCTGACCATTAGTGAATATGAGGCGAAGCAGCTTGTTGGAGACCCTGATGGACT +CGCTAAGGTGGACGAAGGTCTGTCTATGGTTGAGCGTATTATCATGAATTATATCGAATC +CAACAGCTACCGTGTGACACTCTTTGAGTGCCTCAAGCAGTTGATCGTGGCAGGTAATGC +ACTGCTTTACTTACCGGAACCAGAAGGCAGCTACAATCCGATGAAGCTGTACCGATTGTC +TTCTTATGTTGTCCAAAGAGACGCATACGGCAATGTGTTACAGATTGTCACTCGTGACCA +GATAGCCTTTGGTGCTCTCCCGGAAGACGTTCGGTCTGCGGTAGAGAAAGCTGGTGGTGA +GAAGAAGATGGACGAAATGGTCGATGTGTACACCCATGTGTATCTCGATGAAGAGTCCGG +CGATTACCTCAAGTACGAGGAAGTAGAGGACGTTGAGATTGATGGCTCCGATGCCACCTA +TCCTACTGACGCTATGCCCTACATTCCGGTTCGCATGGTTCGCATTGATGGCGAGTCTTA +CGGTCGCTCCTACTGTGAAGAATACTTAGGTGACTTAAGGTCGCTTGAGAATCTCCAAGA +GGCTATCGTTAAGATGAGCATGATTAGCGCGAAGGTCATCGGTCTGGTGAACCCGGCTGG +CATTACGCAGCCACGTAGATTAACCAAAGCTCAGACTGGTGACTTCGTTCCGGGTCGTCG +AGAAGACATTGACTTCCTTCAACTGGAGAAGCAAGCTGACTTTACCGTAGCGAAAGCTGT +GAGTGACCAGATAGAAGCACGCTTATCGTATGCCTTTATGTTGAACTTTGCGGTGCAACG +AACAGGTGAACGTGTGACCGCCGAAGAGATTCGATACGTTGCGTCAGAACTGGAAGATAC +GCTTGGTGGCGTCTATTCGATTCTGTCTCAAGAACTGCAATTGCCTCTGGTTCGTGTGCT +CTTGAAGCAGCTCCAAGCAACCTCGCAGATTCCTGAGCTACCGAAAGAAGCCGGTGAGCC +GACTATCAGTACAGGTCTGGAAGCAATCGGTCGTGGTCAAGACCTCGATAAGCTGGAGCG +CTGTATCTCCGCTTGGGCTGCTCTGGCCCCTATGCAGGGAGACCCGGACATTAACCTTGC +TGTCATTAAGCTGCGCATTGCTAACGCCATTGGTATTGATACTTCTGGTATCCTACTGAC +TGACGAGCAGAAGCAAGCACTGATGATGCAGGATGCGGCCCAAACAGGTATCGAGAACGC +TGCCGCCACTGGTGGGGCTGGTGTGGGTGCTCTAGCGACCTCAAGTCCAGAAGCTATGCA +GGGTGCAGCAGCACAGGCTGGCCTAGACGCCACCTAATAACCCTCACTAAAGGGAGACCT +CATCTTTGAAATGAGCGATGACTAAAGGTTGGAGTCCTTTGGTTTCCCTTTATCTTTAAC +AACTTAGGAGATTTAACAATGGCTGAATCTAATGCAGACGTTTATGCGTCCTTCGGTGTG +AACAACGCGGTAATGACCGGAAGCACACCTACTGAACACGAACAGAATATGCTGAGTCTC +GATGTTGCTGCCCGTGATGGCGATGATGCAATCGTACTTAGCGAGGAACCGAGTTCCCAT +AACGATGACCCATATGCATCCGGTGTAGACCCGTTCGCTGATGGTGAAGACGATGAGGGC +CGCATTCAGGTTCGTATCAGTGAAGATGGTAATGAAGCCGAGTTCGACACCGGTAGCGAT +AACGCTGAGGTGGAGACCGAAGGTGAGGCCGCTGAGTTTGAACCGCTGGGTGACACTCCA +GAAGAACTGAGCCAAGTGACTGAGCAGTTGGGACAGCACGAAGAAGGCTTTCAGGCGATG +GTCGAGCAGGCCGTTGAGCGTGGACTGAGCGCAGAGTCTGTGACTCGCATCTACGAAGAG +TACGAAGCCGATGGCATCTCTGAGAAATCCTACGCGGAACTCGAAGCTGCTGGCTATAGT +CGTGCCTTTGTGGACTCCTACATCTCCGGTCAGGAAGCCCTTGTAGACCAGTACGTCAAT +CAGGTAGTTGCCTTTGCTGGTGGTAAGGAGCGCTTTAGCGCAATCCATACGCACCTTGAA +GCAACCAACCCGGCTGCGGCTGAGTCCCTTGAGACTGCCATGATGAACCGAGACTTGGCG +ACTGTCAAAGCAATTATCAATCTGGCTGGTGAGAGCTACACGAAGAAATTCGGTAAGCCT +GCCAACCGTAGTGTTACCAAGCGTGCTACTCCGGTTAAACCTGTAGCTCGTCAGAAAGAT +GGCTTTACGAATCAGGCTGAGATGATTAAAGCTATGAGTGACCCGCGTTACCGTAGTGAT +GCTGCCTACCGTCAAATGGTAGAACAGAAGGTTATCGACTCCAGTTTCTAATTAACCCTC +ACTAAAGGGAGAGACCATAGATGACTACAATGGTTGAATCACCTGAGCACAGAACTTTGT +GGTCACTCCCGTAGGTGAAACATTGAGAACCAACTCGATTCAAGTAGTAACCAAACTTTT +CTTTAAATTAACATAAGGAGATTCAACATGGCTAACAATCAAGGCGGACAGCAAATTGGT +ACTAATCAGGGTAAGGGTCAGTCCGCAGCGGACAAATTGGCGCTGTTCCTGAAAGTGTTC +GGCGGTGAAGTCCTGACGGCTTTCGCTCGCACCTCCGTGACCATGCCTCGTCACATGCTG +CGCTCTATTGCTTCTGGTAAGTCCGCACAGTTCCCTGTGATTGGTCGCACCAAAGCTGCT +TACCTGAAACCGGGTGAGAACCTCGATGACAAACGTAAGGATATCAAACACACCGAGAAG +GTAATCCACATTGATGGACTGCTGACTGCGGACGTTCTGATTTACGACATTGAGGACGCG +ATGAACCACTACGACGTTCGCGCTGAGTACACCGCACAGTTGGGTGAATCTCTGGCGATG +GCGGCTGACGGTGCTGTACTGGCTGAACTGGCTGGTCTGGTTAACCTGCCGGACGCCTCC +AATGAGAACATCGAGGGTCTCGGTAAGCCTACCGTACTGACTCTGGTTAAGCCGACCACT +GGCGACCTGACTGACCCGGTTGAGCTGGGTAAAGCGATTATCGCTCAGTTGACTATCGCT +CGTGCGTCTCTGACCAAGAACTACGTTCCGGCTGCTGACCGTACCTTCTACACCACTCCT +GATAACTACTCTGCGATTCTGGCCGCTCTGATGCCGAACGCTGCAAACTATCAGGCACTG +ATTGACCCTGAGCGCGGTACTATCCGTAACGTGATGGGCTTCGAAGTGGTTGAGGTTCCG +CACCTGACCGCTGGTGGCGCTGGTGATACCCGTGAGGATGCCCCGGCTGACCAGAAGCAC +GCTTTCCCGGCGACTTCCAGCGCTACCGTTAAGGTTGCTCTGGATAACGTTGTGGGCCTG +TTCCAGCACCGCTCTGCGGTTGGTACGGTCAAGCTGAAAGACTTGGCTCTGGAGCGCGCT +CGTCGTGCGAACTATCAGGCTGACCAGATTATCGCTAAGTACGCGATGGGTCACGGCGGT +CTGCGTCCAGAAGCTGCTGGCGCTATCGTGCTGCCAAAGACTTCGGGGGCTTAAGGGTAG +CGCCTTTGAGTATGAACGCGGAGAGTGAAGTGGAGCCGACCCAAGAGGTAGCCGCCGAAG +TAGCTCTCACGCCTCAACAGAAGGCCGCCATTACTCGTGCTCGTAACAAGGCACTTAAGT +CTCAATAACAACAAGCAAACCCCTTGGGTTCCCTCTTTGGGAGTCTGAGGGGTTTTTTGC +TTTAACCCTCACTAACAGGAGGTAACATCATGCGCTCTTATGAGATGAACATTGAGACCG +CAGAAGAGCTATCAGCCGTCAACGACATTCTGGCTTCCATCGGTGAGCCACCAGTATCGA +CCCTTGAGGGTGATGCAAATGCTGATGTTGCAAATGCTCGACGTGTGCTCAACAAGATTA +ACCGACAGATTCAGTCACGAGGATGGACATTCAATATTGAGGAAGGTGTGACTCTTCTAC +CGGATGCGTTCTCTGGTATGATTCCATTTAGCTCTGATTATCTGTCCGTAATGGCAACCA +GCGGTCAGACCCAATATGTCAACCGTGGTGGCTATCTCTATGACCGCTCTGCGAAGACTG +ACCGATTCCCATCTGGTGTTCAGGTCAACCTGATTCGTCTGAGAGAGTTCGATGAGATGC +CTGAGTGCTTCCGAAACTACATCGTTACCAAGGCTTCCCGTCAGTTTAACAACCGCTTCT +TCGGTGCGCCGGAGGTAGACGGAGTGTTGCAGGAAGAGGAACAGGAAGCGTGGCGTGCGT +GCTTCGAGTACGAACTAGACTACGGCAACTACAACATGCTGGACGGTGACGCATTCACCT +CTGGTCTACTTAACCGCTAATAACAAGGAGGCTCTATGGCTCTCATTAGTCAATCAATCA +AGAACCTCAAGGGTGGTATCAGTCAACAGCCAGATATTCTCCGGTTCGCTGAACAAGGTA +GCGTACAGATTAACGGTTGGTCTTCTGAGTCCGAGGGTCTCCAGAAGCGCCCACCGATGA +TTCACCTTAAGACCCTTGGTGCTGCTGGGTATGTGGGTGCGCAACCTTACGTTCACCTCA +TCAACCGTGATGAGTTCGAGCAGTATTTCGTGGTGTTCACTGGTGAAGACATTAAGGTAT +TCGACCTCGACGGTAAGGAGTACCAAGTACGTGGAGACCGCTCATATGTTCGTACAGCTA +ACCCACGAGAAGACCTTCGGATGGTAACTGTGGCTGATTATACCTTTGTGACTAACCGCA +AGGTGGTTGTACAGAGTAACGACCAATCGGTCAACCTTCCGGGCTTTAAAGACCAAGGCG +ATGCGCTGATTAATGTTCGCGGTGGACAATATGGGCGTAGACTCTCAATCGAGTTCAACG +GGGCTGAGCGTGCTGCTGTACAACTACCGGATGGTTCACAACCAGCACACGTTAACGAGG +TTGACGGTCAGGCTATCGCTGAGAAGCTGGCTGTGCAGTTGAGGAACAACCTTGGGAATC +CAAACAACGAGCAAGACCCGAATAAGTGGCGCTTCAACGTTGGCCCCGGATTCATCCATA +TCCTTGCGCCAAATAACGATAACGTTTGGGGACTACAGACTAAGGATGGTTACGCAGACC +AGCTAATCAACCCTGTAACCCATTACACTCAGTCGTTCCAGAAGCTGCCTATTAACGCGC +CAGATGGGTACATCGTGAAGATTGTTGGTGATACCTCAAAGACTGCCGACCAGTATTACG +TTAGGTTCGACCTCAACCGTAAGGTGTGGGTAGAAACAATTGGATGGAACACAAGGACTC +ACCTACATTACCACACGATGCCTTGGGCACTTGTTCGCGCTTCTGACGGGAACTTTGACT +TCAAGTACCTTGAGTGGGGTGCTCGTACTGTGGGGGACGATACAACCAACCCATACCCAT +CCTTTACCGGACAGACAATCAACGATATTTTCTTCTTTCGTAACCGTTTGGGATTCCTTA +GTGGGGAGAACATCATCTTGTCTCGCACCTCGAAATACTTCAACTTCTTCCCGGCATCCG +TGTCAAACTACTCCGACGATGACCCAATCGACGTTGCGGTTAGTCATAACCGGGTGTCAA +CCTTGAAGTATGCCGTTCCGTTCTCAGAAGAGTTACTCCTGTGGTCTGACCAAGCGCAGT +TCGTTCTGACAGCCTCTGGAATCCTTTCGAGTCGCTCCGTAGAGTTGAACCTTACGACGC +AGTTCGACGTGCAAGACAGGGCACGCCCACATGGTGTAGGACGTAATGTATACTTTGCGT +CACCTCGCGCTTCCTTCACATCCATTAACCGATACTATGCGGTACAGGATGTAAGCTCTG +TGAAGAACGCAAAGGACATGACGGCTCACGTTCCGAACTACATACCGAATGGAGTATTCA +GTATATCGGGGACAACCGCTGAGAACTTCGCGGCTATCCTTACGAGCGGAGCACCGAACC +GAGTGTATATCTACAAGTTCCTCTATATTGATGAGGAAATCAGGCAGCAGTCGTGGTCTC +ATTGGGACTTTGGGGACAACGTTACGGTGTTTGCAGCACAGGTGATAAACTCAACAATGA +CTGTATTGATGAGCAATGAACATGCTGTGTGGATGGGACGCTTACACTTCACGAAGAACT +CCATAGACATTCCGGGAGAGCCTTACAGATTATACATCGACGCTAAGAGGAAATACACCA +TCCCTGCCGGGACGTATAATGATGATACCTACCAGACGTCCATAAGCCTCGCAACAATTT +ATGGGATGAACTTCACTAGGGGTAGAGTGTCTGTGGTCTTTCCTGATGGGAAGATTGTAG +AGATAGACCAACCAATCAACGGGTGGAGTAGCGACCCAATACTGAGACTTGATGGAAACC +AAGAGGGACAAGTAGTCTACATTGGGTTCAACATCCCGTTCACTTATACGTTCTCGAAGT +TCCTCATCAAGAAGACTGCTGAGGACGGCTCGACGGCTACCGAGGATATTGGTCGTTTAC +AGCTTCGGCGTGCGTGGGTAAACTATGAGGACTCTGGAGCGTTCACCATCCGTGTGAACA +ACCTGTCCCGTGAGTTCATCTACACAATGGCTGGTGCTCGCTTGGGTTCTGACAATCTGC +GTGTTGGCAGGTCGAACATTGGCACAGGGCAGTACCGCTTCCCGGTTGTTGGAAACGCTC +AGACGAACATAGTAACTATCGAGTCAGATGCATCAACACCACTGAACATCATTGGGTGCG +GCTGGGAGGGGAACTACCTTCGTCGTTCTTCTGGCATTTAACTTAAAGTCTCCCTGTGGT +GAATTAACCCTCACTAAAGGGAGACACTAATAGATACGAGGGGTTAAAGCATTATGTACA +TTACAAAGTGTTTACAAATCCATGCCGACAACTTTCAGCCGTCCATAGAGGACATTCTGG +AAGCTGAGGCACTAGGTGTTGAACCAAAGGTAATTCCTGATGAGAACACTGTGGCAATGC +TTAGCGATAACGCTGTGTTGGCAATCGGTGGCAATCAGGGAGACCGAGTGTGGTTCCTTA +CCTCTAAGTACGTCCCACTGTTTACCTTGAAGGAGCGCTTAGAGTTTCGTAGACTTATCA +TTGAATATCGTGATATGATGCTGAGCCAGTACGAGTCCATTTGGAATTTCGTTTGGGTAG +GCAATAAGTCACACATTCGTTTCCTAAAGACCATAGGCGCGGTATTCCATAATGAGTTTA +CCGCTGATGGTCAATTCCAATTATTCACTATCAGTAGGAGGTAACTATGTGCTGGATGGA +AGCGATTCCTATTGCCATGATGGGTGCCCAAGCTCTAAGTAGCCAGAACAGTGCTGACAA +GGCGCGAGTGGCACAGACCGAAGCTGGACGCAGACAGGCAATGGAGATGGTCAAAGAGAT +GAATATCCAAAATGCCAACGCCTCGCTGGAACAACGGGACGCCCTTGAAGCTGCATCCTC +TGAGTTGACTACACGTAACATGCAGAAGGTACAGGCTATGGGAACCATCCGTGCAGCTAT +TGGCGAGGGTATGCTCGAAGGTGAGTCCATGAAGCGCATCAAGCGTATCGAAGAGGGCAA +CTACATTAGGGAGGCAAATAGTGTCACCGAGAATTACCGCCGAGACTACGCGAGTATCTT +TGCGCAACAGTTGGGACGCACTCAGTCCACAGCGAGTCAAGTCGATGCAATGTACAAGAG +CGAGGCCAAAGGTAAGTCTGGTCTGATGCGTGTACTAGACCCTCTGTCCATTATGGGTCA +GGAAGCTGCAAGTCAATATGCGGCTGGTGGATTTGACAAGAAGGGTGGAAACCAAGCAGC +ACCTATCAGTGCCGCCAAAGGAACCAAGACCGGGAGGTAATAATGGCTAGTAAACTAAAT +AGTGTTTTAGGCAACATGGCGACTCCCGGTATGGAACGACTCCGGGGCGTCAAAGGTATG +GACTACCGGGCAGCAACCATTCAGGCTGAACAACCAAGAGCGAGTCTTCTGGACTCCATT +GGTCGATTCGCTAAGGCTGGTGCCGATATGTACATGGCGAAAGATGAACGTGATAAGCAA +CGAGCCGATGAGCGCTCCAACGAGATTATCCGTAAGCTGACCCCTGAGCAGCGCCGACAG +GCTATCCAGAATGGTACACTGCTGTATCAGGATGACCCATACGCAATGCAAGCCTTGAAG +TTCAATACCGGGCGTAACGCTGCGTTCCTCGTTGACGATGAGGTTCAACAGGCCATCAAA +GAGGGTCGCTTCCGTACTCGTGAAGAGATGGAGCAGTATCGTCACTCACGCCTACAGGAG +CACTCGAAGTCGTTCGCTGAGCAGTTCGGTATCAATGAGATGGACGAGGAATACCAGAAG +GGTTTCAACGCGAATATCACCGAGCGTAACATTGCTCTGTATGGGGCACATGATACCTTC +CTGAGTGACCAAGCGCAGAAGGGTGCAATCCTGAACTCGAAGGTTGAACTCAACGGTGTC +CTATCTGACCCTGACCTACTGTCTCGTCCTGAGTCCGGTGAGTTCTTCCAGAACTACATT +GACAACTCCTTGGTGACGGGGATGACCGACAATCAGGCTCAACAGGTTATCTCTTCGTCC +CTGAATGACGTGCTACAGCGTCCGGGTGGTGCCGCCTTCTTGCAGAACATTGAGAACCGC +AAGGTGACTCTTAATGGCGCTACGACTACCTATCGTGAACTGATGGGTGATGAGCAGTGG +CAGGCAATGATGATTAAGGCACAGCACACTCAATTCCAGAACAACGCGAAGTTAACCGAG +AAGTTCCGACTGGATATTAACTCAGCGCTTAACCAAGCAGACACTGGTAAAGGCTGGGAG +ACTCTTCAAGGTATCAAGGCCGAACTCGATAAGATTCAGCCGGGTGAAGAGATGACTCCT +GAGCGCGAGTGGTTGATTTCCGCACAGGAACAGATGCGCACACGCTTCAAGCAGGAACAG +GCTGAGACAGCCAAGCTGATGGACAAGCAACAGAAGACCTTGAATAAATCTTTGGTCATC +GACAAGCAGTTCCAGAAGCGCCTCAACGGTGAATACGTCTCGACAAACTATAAGGACATG +CCGACCAACGAGAACACTGGTGAGTTTACACATAGCGATATGGTCAACTACGCGAACCAG +AAGTTAGCGGAAATCGAAGCGATGGACTTAACGCCAGAACAGAAAGACAAACTGAAATTG +GACTACCTACGGGCAGACTCCAAGGAGGGTGCTTTCCGTGCAGCGTTTGGTGAGATGATT +ACTGATGCTGGAAACGAATGGCAGGCTGCGGTGATTAACGGTAAGATGCCTGAGAGCACA +CCAGCGATGGACAACCTTCGTCGCATCCGCAACACTGACCCTGACCTGATTGCCTCTCTG +TATCCTGACAAGGCCGAGTTGTTCCTGACTATGGACATGTTGGATAACCAAGGTATCGAC +ACGCAGGTTCTTATCGACGCTGATAAGTCCCGCGCACAGAAGACCAAGGAGATGCAGTTT +GAGGATGACCGAGCGTGGGCTGCTATGATGAACGATTCAACGAATCCTCAAATCAAGTAC +ATGCCTTCGAGTGTCCAAGGTTACGCGCGGAAGATTTATGATTCCGTGAAGTACCGGACA +GGGAACCCTGACATGGCAACAGAACAGGTCGCAAAGTTCCTCTCTGATTCAACGACTACG +TTCTCCAGTAGTGATGTTGATGGCGATACCTATGGTGTCCTGCCGAAGAACATCCTGACT +GTTTCGGATGACCCTAAGTCGTGGGAGCAAGGGAAGAACATTCTGGACGAAGCCATTAAG +GGAATCACAGCGGCGAACCCTTGGATTACCAACAAGCAACTGACGGTGTACCAGCAAGGT +GATTCAATATACCTGATGGACACAACCGGACAGGTTCGCATTCGGTATGACCAAGAGTTG +CTCCAGCGTGAGTACCAGCGTACCGCACAGATGCAAGCTGAGGCAGCACGAGAGAAAGCC +CTCAAAGAGGCCAACAAGCGTGCCCCAATCAGCCGTGTACCACAGGCGCGTGAAGAAGCG +CGTAAACGTGTCCAAGAGAAACGGAAGAAGACTCCGAAGTACATCTATGGACGTAAAGAA +GACTAACAGTGATAAGGAGGCTCCATGAGCTACGATAAGAACAAACCTAGCGAGTTCGAT +GGGTTATTTCAAAAAGCGGCAGACAAACATGGGGTCTCCTATGACCTGCTTCGTAAATTA +GCATTCAATGAGTCCAGTTTCAATCCAAAGGCCAAATCACCAACTGGCCCGAAGGGTCTC +ATGCAGTTCACCAAGGGTACAGCCACTGCGCTGGGACTCAAAGTCACTGATGCAGACGAT +GATGACCGTTACAACCCGGAGTTGGCTGTGGATGCAGCCGCTCGTCACCTGAGTGACCTC +ATTCGTAAATACGATGGGGATGAGCTTAAGGCAGCCCTAGCGTACAACCAAGGCGAGGGA +AGAAATGGTGCCCCTCAGATGCAGGCCTACGACAAAGGTGATTGGGCCTCAATCTCTGAG +GAAGGTCGTAACTATATGCGTAACCTGATGGACGTAGCTAATAGTCCTCGCAAGGGGGAC +TTGGAGGCGTTCGGCGGTATCACCCCAAAGGCTAAGGGCATTCCATCGGGGGATGCATTT +GCTGGAATCGGGAAGAAGCAGACGGTAGGCACTGACCTGCCGGAGTCAACGGGATTCAAA +GTGGAGGGTAAAGAGCAGCAAGCGCCTAACGTTCCTTATGCTAAGGACTTTTGGGAAAAG +ACTGGAACAACACTGGACGAGTTTAACTCACGCTCTACCTTCTTCGGAATTGGCGATGCA +ACAAGTGCGGAGCTTCATAACTCTGTACTTGGAGTTGCTTTCCGTGCAGCCCGTAGCGAC +GATGGTTTTGATTTGTTCAAGGACACCATTACGCCTACCCGTTGGAATAGCCATACGTGG +ACTCCAGAAGAGCTAGAGCGAATCCGTAAGGAAGTGAAGAACCCCGCGTACATCAACGTA +GTCACTGGAGGCTCTCCTGAGAATCTGGACGCCCTCATTAAGATGGCGAATGACAACTAT +GAGATGGATGCGCGGTCTGCCGATGCTGGTGTTGGTGCCAAACTTACTGCTGGTATCATC +GGCGCTGGTGTAGACCCGCTGAGTTATGTACCGCTAGTAGGCGTAGCCGGGAAGGGTCTC +AAGGTGGTTAACAAGGCTTTCATTGTGGGTACTCAAAGTGCTGGCCTCGCGGTTGCCTCT +GAGGGTCTCCGTACATCAATCGCTGGTGGAGAAGCCCACTATGCTGATGCTGCTTTAGGT +GGTCTCTTGTTTGGTGCTGGTATGAGCGCAATCAGTGATGCTATCGCTGCTGGTGTTCGC +CGTTCCCGTGGGACTGAGGTAGTTAATGACTTCGCTCCTATGGCACACCGCTTGGAAGCC +CGTGAGACCGCTCTGAACACTGGTGGGGAAGACCTGACCCGTATGCCTAGCGAGAACCGT +GTGTTCGACCGTGAGCACGCTGGCGTTGAGTATTCACCTCTGGAGACCGAGCCGGGTGCC +GTTGTGTTGCCTCAAGGTCAAATCCTGAGCGACACCAACCCACTGAACCCTCAGACTCTT +AGCGAGTTCGAGGCGGTCAACCCTGAGCGTGCCGCTCGTGGTATCTCTTTGGGTGGTTTC +ACTGAGATTGGCTTGAAGACTCTCCGCTCTGAGAACCCGACTGTTCGCTCCATTGCGAGT +GACCTTGTGCGTTCTCCGACAGGGATGGAATCAGGCTCTAATGGTAAGTTCGGTGCGACT +GCTTCTGACATTAAGGAGCGGCTCCACGCGAACAATCAGCGCACCTACAATCAGCTTTAT +GATGCTGTGCGTACTGCAATGAAAGACCCTGAGTTCTCCACAGGTGGTGCCACAATGAGC +CGTAAGGAAATCCGACAGGAAATCTACAAGCGTGCAGCCTTGGCGATTGAGCGACCTGAG +CTTCAAGCAAACCTGACAAAGGGTGAGCGGAACGTGATGAACATCCTCAAGCAGCACTTT +GACCTCAAACGTGAAATCATGGAGAACCCGTCAATCTTCGGCAACACCAAGGCGGTCAGT +ATCTTCCCCGGCTCACGCCACAAGGGAACCTACGTGCCAAACGTGTACGACCGCGCTATC +AAGATTGAGATGGTTAAACGTTACGATAATGATGGCTTGCAGCGAGCAATCGCGGAGTCA +TGGTTGACGTCTTATCGTGCTCGTCCAGAAGTCAAGGCGAGGGTCGATGAGTACCTGATG +GAACTTAACGGTCTCAAATCCGTGCAGGAAGTTACGCCTGAGATGGTGCAGAAGCACGCG +ATGGATAAGGCGTATGGTATTTCACACACTGACCAGTTCTCTGCCTCCTCTGTCATTGAG +GATAACATTGAGGGTCTGGTGGGTATCGAGAACAACAACTTCTTGGAAGCCCGTAACATG +TTCGACAGTGACATGGCGGTGACTCTCCCTGATGGTAACACGTTCTCTGTGAATGACCTG +CGTACCTATGACATGGCTGAAATTCTGCCTGCATACGACCGACGAGTAGATGGTGATGTT +GCAATCATGGGCGGTTCCGGTAAGACTACCAAAGACCTGAAAGATGAAATCATGGCGCTG +GATAAGCAGTCAGAGGGTAACGGCACACTGAAAGGTGAAGTGGAAGCTCTCAAGGACACC +GTGAAGATTCTGACTGGTCGTGCTCGTAGGAACCCGGAAGGCGCTTGGGGTACAGCCCTG +CGCTCCGTAAATGACCTCACGTTCTTTGCTAAGAACGCCTATATGGGCGCACAGAACGTT +ACTGAAATCGCTGGTATGCTGGCGAAGGGTAACGTCTCTGCGATAACTCATGGCATCCCT +ATGATTAACGATTGGGTCAACCGTGGTAAACCGCTTCGTGCCTCTGAGATTAAGGAGATA +CACGGGATGGTGTTCGGTAAGGAACTAGACCAACTAATCCGTCCGGGACGTGAAGACCAC +GTGCGCCGACTCCGGGAGTCTACGGACACCAGCGCTGCGGTTGCCAATGTGGTCGGTACG +ATTCGTTTCGGCACTCAAGAGTTGGCTGCACGCTCTCCTTGGACAATGCTCCTAAACGGA +ACATCAAACTACATTCTTGATGCTGCCCGTCAGGGTGTGCTTGGGGATGTGGCTGGAGCG +GCCCTTGCTGGGAAAGCCTCTAAGTTCGGTAAGGCAAACTACCTTAAGTCTGCCTCTATC +AGCCCTGAGCAGTGGAATGGAATCAAGCAGTTGTTCAGAGACCATGCGACTCGTAGAGAA +GACGGTAAGTTCACCATTCGTGACAAACAGGCTTTCGCTAACGACCCACGTTCAATGGAC +TTGTGGCGACTGGCTGACAAGGTGGCGGATGAGACTATACTGCGACCTCACAAGGTTTCC +TCACAGGACTCCAAAGCGTTCGGTGCAGGGGTGAAGATGGTGATGCAGTTTAAGAACTTC +GTCATCAAGTCCCTTAACTCCCGGTTCGTCCGTAGCTTCTACGAGGCAACTAAGAACAAC +CGTGCGTTAGACCAAGCGTTGACTCATATCATCTCCTTGGGTCTAGCTGGTGGTTACTAC +GTTGCGCAGGCGCACCTTAAGGCCGCAAGCCTACAGGAGCACAAGCGTAAGGAGTACCTT +AAGAACGCACTTGACCCTAAGATGATTGCTCATGCGTCAATCTCTCGTAGTTCACACTTA +GGCTCACCATTGAGTATCTACGACATGTTCGCTGGGATGGTTGGTAGCGATACCTATAAG +TACACCCGCTCTACTGTGCTCCCTAAAGAGTCCGAGAAGCGTGACCCTAACAAGGCAATG +ACAGGTAGACAGGTGGCTTCAACTATCGCGGGTGCAGTTGGTGAGCAGGTTCCGGGGTTA +GGTTTTGTGGGTTCTGTGGGTGCAACAGCAATTAACGCAGCTTCCCTGCTATCTTCTCCC +AACAAGGCAACCGCTCTGGAGTTCCGTACAGGCCTCTTCAACACCTCTCGTGAGTTGATT +CCTAATGACCCGCTATCGCAGCAACTCATTATGAAAATCTACGAGGCCAACGGTATCCGC +ATAAAGGAGACGCCGAAGAAACAATAAACCCTCACTAAAGGGAGAGAGGTCACATTCTGG +CCTCTTCTCTCTTAATGCTAATTTACAAAGGAGGTCACATGGCTACAACTATTAAGACCG +TGATGACTTACCCGCTGGATGGCTCCACTACGGACTTTAATATTCCGTTCGAGTATCTAG +CGCGTAAGTTCGTCAGAGTGACCCTTATCGGTGTTGACCGAAAGGAACTCATCTTGAATC +AGGACTACCGTTTTGCGACTAAGACCACAATCTCCACAACGAGAGCATTGGGGCCAGATG +ACGGTTATAACATGATTGAAATCCGTCGATTTACCTCCGCTACCGATAGGCTGGTTGACT +TCACCGATGGTTCAATCCTTCGGGCATACGACCTGAACATCTCTCAGGTCCAAACCCTTC +ACGTTGCTGAGGAAGCACGTGACCTTACCGCTGATACTATTGGCGTTAACAATGATGGGA +ATTTGGATGCTCGTGGTCGCCGTATCGTTAACGTAGCTGACGGAGTTACTGATGGTGACG +CCATCTCTGTAGGTCAGGTTAAACGTATGAACCAGAACTCGTGGCAAGCACGTAATGAGT +CCTTGCAGTTCCGTAATGAAGCAGAAGGTTTCCGCAATCAGGCCTCTACGAGTAAACAGG +CTGCTGCTACCTCTGAGTCGCAATCATGGAATCATTCTGAGCGCTCTCGGACATTCGCTG +AGGCAGCTCAAGGTTCTGCTAACTCTGCGGGACAGTCAGCTACCAATGCGAACAACGCTA +TGCAGTCTGCTGGTCAATCAGCCACGGATGCTAGTAACTCTGCTGCTCAGGCTAAGGCCT +CTGAGGTTAACGCAAAGGCCTCTGAGGTTAACGCTAAGCGTGATGCTGACGCGGCCCTGC +TGGCTCTGCAATCCACTGGTAACGTACCTGTGGGTACAGTCGCCATGATTACCCACACCA +AGATTCCTACTGGTTGGGTGCGTGCTGGTGAGGACTTCGACGTTAATACTTACCCGGCGT +TAGCTGAACTGTTCCCTAGTGGTCGTACTCCTAGCTTCGATGACCGCTATCCTATTGGTA +ACTCTACCGTATTGACTCCGGGTCAGCTTATTGACCAATCAGTACCCGCCCACAGTCACA +CCTTCGACGTGCCTGTCAACGTGTCAGGTGCTACGGCTGCTGGTGGCGAATATCGCGCCA +GAACGTCACACGAAGGGGATCACAGTCATGGGTTCTCATTGCCTATCCAGAACAACACTG +GTGCTTATACTGGTCGTCTGGTTGGCGGTGGCAACAACCCTAACTACCCGCAAGACCTGC +GCTTTAACACTGGTGGCGGTGGTGCTCACAGTCATGAGTTCTATGTTCCTTCACACAGTC +ACACGTTGAATGCATCTGGGCGTGCTGCTGGCTCCGTCTCTTCGTCAGGTATTGGAAACT +CACCGTATGTCCGTCCGTATTCCACTGTGGTCATCTTCATCATCAAGGCCGCTCAAGGTG +TTGACGATAAGGACGCAGCAATGCAGGTGGTGGGCACTGTGGTTGGACGAGTGGACGCTC +TGGAGAACTGGCAGAAAAACTTCAAGTCCGTTGTTGAGAACGGTTCACCAACCTCTGGAA +ACGGCGGGCCTTGGGAACGTACTGTGTACACTGCCCAGACTGACTTCGGTCTCAACCGCT +GGCGCACGCTGAGTGGTTCGTCATGGGGAGAAGTAGTCAACTTACTTAATAGCTCCGGCG +TACTTAAAGGGTATCCGCAACGTCTTGTTGTTGACTTCACGGTTGAGGTAATCGATAGCT +CTGACCTAATCGCCAAGGCTGGTATATATAGTCCAATGATTATGGCCAGAATCGTGTATC +ACAACGGCACCAACTCTGGTGATATACTTCCCGCTGCCACCTCAAGCTCTGCGCACGCGA +CAAACGGGTGGAACATTAAGATGGCTACACGATTGTTGTATGGTACTGATGGCGGTCAAC +CAGTAGTTGAGATTGGTGCCTTCAAGGATGGTTCTGACCAGCAGACGGCAAACGTGCCAG +TTAAAGTAGGCTTGCGCCTCGTTCACGTGTTCTAAGGAGGACATAATGTTATCACTTGAT +TTCAACAACGAGGCCATTAAGGCTGCACCCATTGCGGGTGTGGCTGGTGCTGATGGTGTG +GCCCGCCTGTTCTGGGGGCTTTCTCTCAACGAATGGTTCTACGTTGCAGCTATCGCCTAC +ACAGTGGTTCAGATTGGTGCCAAGGTGGTCGATAAGATTATTGATTGGAAGAAAGCAAAT +AAGGAGTAACCTATGAGCGACAAGACTTTAATCAAGCTGCTGGAGATGCTGGACACGGAG +ATGGCACAGCGTATGCTTGCTGACCTCCAGAGCGAGGAACGCCGAACTCCGCAGCTTTAC +AACGCAATCGGCAAACTGTTAGACCGCCATAAGTTCCAAATCAGTAAGCTGACCCCGGAT +GAGAACATCCTTGGCGGTCTGGCGGCTGGTCTGGAAGACTACAACAAAGTGGTCGGCCCT +AATGGTCTGACTGATGATGAAACAATCACGCTACAGTAAGTGACATACTCAAGGTTCTCC +ACGCGGGGAGCCTTTATGGATGTTATTTGGTGCATCTATGTAAAATCTGAAAATTGATGG +GAGGTGTTATGCTAAAACTTTTACGCAGCGCACTCCCTTGGGTACTCGCCGGGACACTCT +TTATGGGTGGCTGGCACTTAGGGTCAACCCATGAGAGAGCAAACTGGAAGGAGGTAATCC +AAAATGAATACATTGCGAAAACAAAAGCAACCGCAGCAACTCAGGCAGAGGTCAGTCGGG +TATCCCGTGAGTACCAAGAAGAGATTGCAGCCATTGAAGGCAGCACTGATAGGATGCTTA +ATGACCTGCGTAGTAATAATAAGCGGCTGTCAGTCCGCATCAAGACCCTTACCGGACTAC +CAGAAGATAACGGTAGATGCGAGTTTAATGGTCGAGCCGAACTACACGAGTCAGATGCTA +AGCGTATTATCGGAATAACCCAAGCTGCTGATGCTCACGTAAGGGCGCTCCAGCGTACTA +TTAAGGAGATGCAGAATGAGCGACACCCAAGCAAACCGTAATGCGCTAATCATCGCGCAG +CTTAAGGGCGACTTTGTGGCCTTCCTGTTCGTATTGTGGAAGGCTTTGGCTCTCCCGCCA +CCGACTAAGTGTCAGATTGATATGGCCCGGTGTCTGGCTAACGGAGACAACAAGAAGTTT +ATCCTACAGGCTTTCCGTGGTATCGGTAAGTCATTCATCACCTGTGCGTTCGTTGTGTGG +ACGTTATGGCGTGACCCTCAGTTGAAGATACTGATTGTCTCTGCATCCAAAGAACGTGCG +GACGCTAACTCCATCTTCATCAAGAACATCATTGACCTGCTGCCATTCTTGGCTGAGCTA +AAGCCTCGCCCCGGTCAGCGTGACTCTGTGATTAGTTTCGATGTTGGCCCTGCCAAGCCT +GACCACTCTCCGTCTGTGAAGTCGGTGGGTATCACTGGTCAGTTGACTGGTAGTCGTGCT +GATATCATCATAGCGGATGACGTTGAGATTCCGTCTAACTCCGCAACTCAAGGTGCCCGT +GAGAAGCTGTGGACTCTGGTGCAGGAATTTGCTGCGCTTCTGAAACCGCTGCCGACTTCT +CGCGTTATCTACCTTGGTACACCTCAAACCGAAATGACCTTGTACAAGGAACTCGAAGAT +AACCGTGGGTACACCACAATCATCTGGCCTGCGCTCTATCCGCGTAGCCGTGAGGAAGAC +TTGTACTATGGCGACCGTCTGGCCCCGATGCTCCGCGAAGAGTTCAACGATGGGTTCGAG +ATGCTCCAAGGTCAACCGACTGACCCCGTGCGCTTCGATATGGAAGACCTGCGTGAGCGT +GAGTTGGAATACGGTAAGGCTGGCTTCACTTTGCAGTTCATGCTCAACCCGAACCTGAGT +GATGCCGAGAAGTACCCCTTACGCCTCCGTGACGCTATCGTGTGCGGTCTGGACTTCGAG +AAAGCCCCAATGCATTACCAGTGGCTTCCGAACCGTCAGAATCGCAATGAAGAGCTTCCT +AACGTGGGACTTAAGGGTGATGATATTCATAGCTATCATTCGTGCAGCCAGAACACTGGA +CAGTACCAGCAACGCATCCTCGTGATTGACCCAAGTGGTCGCGGTAAGGATGAGACAGGT +TACGCAGTGTTGTTCACCCTGAATGGCTACATCTATCTGATGGAAGCTGGCGGGTTCCGC +GATGGTTACTCCGACAAGACCCTTGAGTCCCTCGCTAAGAAAGCGAAGCAGTGGAAGGTT +CAGACAGTGGTCTTCGAGAGTAACTTCGGGGATGGTATGTTTGGTAAGGTATTCAGCCCT +GTGCTCCTGAAACACCATGCAGCGCAACTTGAAGAGATTCGTGCTCGCGGTATGAAGGAA +CTACGCATTTGTGATACGCTGGAACCTGTACTCTCTACGCACCGCCTTGTGATTCGTGAC +GAGGTGATTCGTGAGGACTACCAGACTGCCCGTGACGCTGATGGCAAGCATGACGTTCGC +TATTCGCTGTTCTACCAGTTGACCCGTATGGCTCGTGAGAAGGGCGCTGTGGCCCACGAT +GACCGACTTGATGCGTTAGCATTGGGTGTGGAGTTCTTACGCTCTACGATGGAACTGGAC +GCCGTGAAGGTGGAGGCTGAGGTGCTTGAGGCGTTCTTAGAGGAACACATGGAGCACCCA +ATCCATTCGGCTGGTCACGTAGTCACCTCTATGGTTGACGGTATGGAACTCTATTGGGAG +GATGACGATGTGAATAGCAATAGGTTCATTGACTGGTAGTTATGCATATTGAGTGCATAA +GGAATCATTGAGACCACGGATGGTCACTTTAAGAAACTCCTTAAGAATCAATGAGTTTGA +ATTAACCCTCACTAAAGGGAGAGAGGGGACTTAAAGCTACTATATAGGTTAGTCATTCAG +GTTATGCAATGACCCTTTATGCACTTTAAGTCGCCTCTATGATTGGTGATATTATCATTG +TATAATCACCCTACCTTAGAGCAACTGAAAGGAGGTGGCTCAATGTTACGCTTGCTGATT +GCCCTGCTGCGTCATAGAGTCACTTGGCGATTTCTTCTGGTACTTGCTGCTACCCTTGGG +TACGCAGGTCTTACTGACCACCTCGGTCAACTGGAAGTGGCCTTTTGCTCTATACTCTCT +TGTGGGGATTAAATTATTGTTGATGAACGACAAGCGGCTCTGAGGGATTCGTAGGTATAG +TTTCACTACACCAACTCATCCCTGTAGAGTCAACCCTAAAGGTTATACCTAAAGATGCCC +TGTAGTTCGTAATGGTCTTACAGGGTCTTTAAGTGTCTCCTATGGTCTCACCTATGGTGT +GGCCTTACCTAAAGTGGTTGCCTAAAGAGACCTTTAAGAATTTACCACAAAAATCTGAAT +GGGTATCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAA +GCCAGCCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCT +ATAGGATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGA +GGCCTTAAAGAGTGTCCTAGTGTACCAGTTCGATAGTACATCTCTATGTGTCCCT +>NC_010807.alt1 length=38815 tani=99.753 alt=sn;inv;tl +TCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAACCCACCTAAAGCCAG +CCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAACACTAAAGGGAA +TAAGGGATACTTAAAGGGGGGAATTAGGGATTTAATAAAAGATTAAAATTAATGGTTGAC +TTTAAGTAACCCTTAAGGCTATTATTCATCACGTCAACGGGACAACGGCCTTAAAGCCAC +TCCCTGAGATACCGGAGTCAACCGGATAAGTAGACAGCCTGATAAGTCATACGAAAAACA +GGCATTGACAACGCAAGGTAACAAGTAGTAAGATGCACAACATAGCGTCAACCACCAAAT +CGGTGTCTTCTAGGTGACTTAAGCGCACCACGGCACATAAAGCTAAACAAAATGGTTGAC +AACATGAAGTAAACACGGTACGATGTACCACGAAATGACGGAACAGTGAGGCGGGACACT +GAAAGCCGCTAGGGTCTAACGAAACCAGACCGACACGCAAATCATAGTAGGTTTAATAAG +CGGTAAGTGTATTACTTCCCTTGTGTGCCGCCGAATACACGAACTAACATGAGGTAACAC +CAAATGATTTTCACTAAAGAGCCTGCTAACGTCTTCTATGTACTGGTGTCAGCTTTCCGT +TCTAACCTTGATGATGAGGTGAACATGAGCCGCCACCGCCACATGGTAAGCACTTTACGT +GCCGCACCGGGTCTTTATGGCTCCGTTGAGTCAACCGATTTGACCGGGTGCTATCGTGAG +GAAATCGCAAGCGCACCGACTGAGGAAAAAACGGTTCTTGTACGCTGCAAGGACAAGGCG +CAGGCGCTGAATGTTGCACGCTTAGCTTGCAATGAGTGGGAGCAAGATTGCGTACTGGTA +TACAAATCACAGACTCACACTGCTGGTCTGGTGTACGCTAAAGGAATCGACGGTTACAAG +GCTGAACGTCTGCCGGGTAGCTTCCAAGAAGTACCCAAAGGCGCACCGCTGCAAGGCTGC +TTTACGATTGACGAGTTCGGTCGCCGCTGGCAGGTGGCCTAACATGAATCGTTATTACAT +CAACGTACCGGGCTGGGGTGGGTCTCTGACCTGCTACGGATACAACGAACGGGACGCACG +GAAACGCTTTAGAGAACAACACGGCTTCGGAAGGCTTGCTAATGGGACGCGCCTATGGCT +GGACGCCCGTGATTGGTAAGTGATAGACTCAAGGTCGCACTGTATGTGTGGCCTTTATGA +TTATCACTTATAGGACTAACACCATGAGTAAACTTCTGGCAACATCTAAAATAGAAGGCC +AATGCACCGTAACACTGCGTGAGTATTACCACGGGTCAATGGGAAGCACCTATGTTGTGC +GATACGGTAAACAGGTCACACATCGGGTAAACCCGATTTTAGCACAAGAGGATTATCAAG +CCTGTGTGATACACCAAGCAACATGTGCGGGCTGGAATGATTGACATTACAGGAGGATTA +GGAATGGTTATCTTTATCGCTGTCGCATTCTTTGCGGTCGCTGGCTGGTACTCTGAGTCA +CGCAAGGCCGCTCGCTATCATCGCAAGATGGTTAAACTCATGGAACACTTGGACGCAGAA +GGGCGAGGCCGCGAGGCTATCGAACTGGTGAAACACGCATGATGATTCTCTCTATCGCAC +TGGTCTATCTGTGCATCGCAATGTACTTTATGCGAGACTTTAAGCGCGGTCTGGCAATAC +ACAAGGCAACGCTGAGTTACTTTAAGCGCGGTCTGGCAATACACAAGGCAACGCTGAGTT +ACTTTAAGTGGGGATTCATCCCACGGTTTACGGTTCGTGAACGCAACGGACGCTTTAAGG +CCAACAAGGTAGGAGTATTCTACATTGCTACGCACTAACTCAAAGCACGTAAAGACCGCA +CTGTATGCGATGGGGTATGGTGCATCGAAACGCAAGGTCAAACGCATCTTAACGAGACAC +CGCAAGATGACCGCACGACAGGCTGCAAGCGCTGTCAAATGGGCTGAATTTACTCTTTAC +TCTTCTTACAGATAACAGGACACTGAACGATGACTTTCACCGAAGCACAAGCCGCACTCG +ATGCTATCCGCAACCTACCGATTGAGCGCCTGAACGAACGCCAGCCCATGCTGGTGGCTC +TTGCGGCTGCTATCGTGAACGCTGAGACCCAAGACGGCGAACTGACGCAGGCCAAGGGTA +ATTGGGGTCTGGAGTCTATGGACTACTGGCAGACACTGGCTGAGCGTATGCGTGATGTTG +GATTTGTACGCTTGGGCAACGGTCACTTTAGCGCAGCATATGAGCACGCATTGTTACCGG +GCAAGGTTATCAAGGTAGGCTTTAAGAAAGAGGATTCAGGCGCTGCCTATGCCGCATTCT +GCCGTATGAATCAGGGTCGTGAGGGCATCCCTACGGTGTACGACATTCAGCGTCATACAG +GCTGCTACACGGTGGTCTTGGACTATCTGACACCGCTTAATGACTGGTGCTACGGTGAAA +GTGATAAGATTCGTCACCACTTTCAGGCTGCACAGGAAATCATTCAGGAGGATTGCTTCG +ATACCGCCGAAGAGTACCCGATAAGCGAGGGCTTCATTGAGACCTGCATGAGAGCGCAGG +AAGCGATTGACCGCTGTAAGGCACGCAAGGCACGCCGTGACCCTAAAGGAGACTTTCAGG +TAGCACGTAAAGCCCGTGCCAAGTGGCGCAGAAAGGCCTCTAAGCGCGAGAAGCGCAACG +CTAAGGTGCTCGCTAAGATGCGCATGGATGCTAATCAGAATCGCAGGGATGAGCCTAGGG +CGCGTATGGTGTGGGGCGATAAGCACTGGCGCAACGCTTGGATGCACCACAATAACCTAA +ACTTTGCAGAACTGGAGCGCCGCGCTGCTGCGGCAATGATGATGCATGACGAGGTGCGCA +TTCAGTGGGGCAAACCGTTACACATAGACGCATACCTTGACAAGCGTCTACAAGGCTGAT +AGAGTCTTATCTTACAGGTCATCAATCGGTGGCCTGAATAGGTACGATTTATTCACAATG +AGGTAAGCAATGAACATCATCGAAAACATCGAAAAGAATGACTTCTCCGAAATCGAACTG +GCTGCTATCCCGTTCAACACACTGGCAGACCACTACGGCAGCGCATTGGCTCGTGAACAA +CTGGCTTTAGAGCATGAGTCTTATGAGCTAGGCGAGCGCCGCTTCCTCAAGATGCTTGAG +CGTCAAGCGAAAGCTGGTGAGATTGCAGACAACGCAGCCGCTAAGCCATTACTCGCTACG +CTTCTCCCTAAGTTAACCGCACGCATCGTTGAGTGGCTCGAAGAGTACGCCTCGAAGAAA +GGCCGCAAGCCAGTAGCCTATGCACCGCTCCAGTTACTCAAGCCGGAAGCCTCCGCGTTT +ATCACACTCAAGGTCATCCTTGCGTCACTGACCAGCACGAACATGACAACCATTCAGGCC +GCTGCTGGTATGCTGGGGAAGGCCATTGAGGATGAGGCACGTTTCGGTCGCATCCGTGAC +CTCGAAGCGAAGCACTTCAAGAAGCACGTTGAGGAACAGCTTAACAAGCGCCACGGGCAA +GTCTACAAGAAAGCCTTTATGCAGGTGGTCGAGGCCGATATGATTGGTCGCGGGCTGCTG +GGAGGTGAGGCGTGGTCTAGCTGGGATAAAGAAACCACGATGCACGTAGGGATTCGCCTG +ATTGAAATGCTGATTGAATCCACAGGTCTGGTGGAATTACAGCGCCACAACGCAGGTAAC +GCAGGCTCTGACCATGAGGCACTGCATCTGGCCCAAGAGTACGTGGACGTATTAGCGAAG +CGTGCAGGCGCTCTGGCGGGTATCTCTCCGATGTTCCAGCCGTGTGTCGTACCGCCGAAA +CCTTGGGTAGCAATCACCGGGGGCGGCTATTGGGCTAACGGTCGCAGACCTTTGGCACTC +GTCCGCACTCACTCTAAGAAGGGACTGATGCGCTATGAGGATGTTTACATGCCAGAAGTT +TACAAGGCGGTCAACATCGCACAGAACACCGCATGGAAAATCAACAAGAAAGTTCTTGCG +GTTGTCAATGAAATTGTTAACTGGAAGAATTGCCCGGTCGCAGACATTCCATCGCTGGAG +CGCCAAGAGTTACCGCCTAAGCCGGACGACATTGACACCAACGAGGCAGCACTCAAGGAG +TGGAAGAAGGCCGCCGCTGGTGTCTACCGCTTGGACAAGGCACGAGTGTCTCGCCGTATC +AGCTTAGAGTTCATGCTGGAGCAGGCCAACAAGTTCGCAAGCAAGAAAGCAATCTGGTTC +CCTTACAACATGGACTGGCGTGGTCGTGTGTACGCTGTGCCGATGTTCAACCCGCAAGGA +AACGACATGACCAAGGGGCTGCTGACCCTCGCTAAAGGCAAGCCAATCGGTGAGGAAGGT +TTCTACTGGCTGAAAATCCACGGTGCGAACTGTGCGGGTGTCGATAAGGTTCCTTTCCCT +GAGCGCATCGCGTTCATTGAGAAGCACGTAGACGACATTCTGGCTTGCGCTAAAGACCCA +ATCAATAACACTTGGTGGGCTGAGCAGGATTCACCGTTCTGTTTCCTCGCGTTTTGCTTC +GAGTATGCAGGCGTTGCGCACCACGGTCTGAGCTACAATTGCTCTCTGCCGCTGGCGTTC +GATGGGTCTTGCTCCGGTATCCAGCACTTCTCCGCGATGCTCCGCGATGAGGTAGGCGGT +CGTGCGGTTAACCTGCTGCCAAGCGAAACCGTGCAGGACATTTACGGCATCGTTGCACAG +AAAGTAAACGAGATTCTCAAACAGGATGCAATAAACGGCACACCTAATGAGATGATTACC +GTGACCGACAAGGACACCGGGGAAATCTCTGAGAAGCTCAAGCTGGGAACCTCAACGCTG +GCGTAACAGTGGCTGGCATATGGTGTAACCCGTAGCGTAACTAAACGTTCGGTCACGACG +CTGGCTTTCGGTTCCAAGGAGTTCGGCTTTCGTCAACAGGTACTGGACGACACCATTGAG +CCTGCGATTGACAGCGGTAAGGGCTTGATGTTCACCCAACCTAACCAAGCGGCTGGTTAT +ATGGCTAAGCTGATTTGGGACGCGGTGAGCGTGACCGTAGTCGCAGCGGTTGAGGCGATG +AACTGGCTCAAGTCTGCCGCTAAGCTGCTAGCTGCTGAGGTAATCATATCGAGACGCTTC +TGGAGTGGCTTGCGGTATTCCTGCCAGACCGGGAATCCGTCCGGCGTAGTCCAGTGAACC +GCACAACGGTGGCGAAGAATCTCCTTGGTCTTCTTGTCCTTGTTCTTAGGGCAATTCCGT +CTGCAACCGACGATTAATACCCTCAAGGATTCAGGCATTGACGCACACAAGCAGGAGTCT +GGCATCGCTCCTAACTTTGTTCACTCACAGGATGGTAGCCACCTCCGCATGACGGTCGTT +TATGCTCACGAGAAGTATGGCATTGAGTCCTTTGCGCTAATCCATGACAGCTTTGGGACT +ATTCCGGCAGACGCTGGTAAGCTCTTTAAGGCTGTGCGTGAAACGATGGTTCTCACCTAC +GAGAACAACGATGTGTTGGCAGACTTCTACGACCAGTTTGCAGACCAGCTTCATGAGACC +CAACTGGACAAGATGCCACCACTTCCGAAGAAAGGTAAGCTGAACCTACAAGACATTCTC +AAGTCCGACTTTGCCTTTGCATAACAAGCACTTAGCATTAACCCTCACTAACGGGAGACT +ACTTAAGGTCTCCCTTAAGGTACTAAGAGATTTTAATTTAAGATAACTAAGAGGTTTACT +TTATGATTACTTTATGTGTCGCAATCGTTCTTATCGCTACACTCTCAATCGTCATCGCTA +AGCAGCGCTCTGAGTTAATCAAGCTGGATGCCCGATATGATAGTGCGAACCACCACCGGA +AAGAACTGGATGCAGCACTTGGGCGGTCAACCGATGAGGTTAAGACCCTTAAGCGCCAGC +TACAGCACGCCGAGCAAGACGATAAGAACCGCTGCGAAACAATCCGAGGTCTACGTGAAG +AACTCCGGGAGTTGCGCCAGACGATTAAAGAGCGCCACGCTATCCACGGCATCAAGTTCG +TAGCGAACGTTCCGATGAAGGGCTGGACGCCCACCGAGTTTAAGCTGGGTCTTGGTAAGT +GCGGTCTGGAAGTGGCGAGTCTAGTGTGGGAAGAGAAGTCTGACCGCTATGTGTTGACTC +AACGCCGCACCGACGGAAGCCGAAAGTTCTTTGAGTACAAGAAGGAAGACGTGCAAGGAA +GAATCGAAGTGTTCTACCCTGCCGTTAAATAACCCTCACTAACGGGAGAGTTAGCCTCAA +GGTCATCACCGACGGTGGCCTTTGTGATTAACTTTCAATACACATCAACATGAGGTAAGA +TACTATGCGTACCAACTTTGAGGAATTTACCAAGCGCGATTCTGTGGTCAACGAGCATGG +CGAACAGTGGCAAGAGCGCCGTGACCGCATGAAGAAACGCCACAAGCAACAGCGCGGTAA +CTCACAGAAACGGGAGTGGAACTAATGATGATGGGACGTATCTATAGCGGCAACCTGAAC +GATTACAAAGATGCGGTAGCGCGTCTACAGGAAGACCATGACGTGACCGTGAAGGTGGAG +TCATTCAGCTATGAAAACCCAGCGAAGATGTGCAGGTCATCCTGTGAGGTTCTCCGTGTG +TTCACACGCTCCGGGCATCCGGTGGCATCCAGAACCTTCGAGCACAGCGACAGTGATGTA +CAAATTAACGCGAAAGGCCACCAATTAAGATGACCTTGAGGATTCTCCTGTTAGTGAGGG +TTATTACTTCCAGTGTTTCAAATCGCTGTGAACCTTACGGAGCCATGCAGTCTGGTGATT +CGAACTGATTAACTTTCAACCAATGAGGAACAACCGTATGAACATCTTCAAGACCAACCC +ATTCAAAGCTGTGTCATTCGTAGAGTCTGCCGTTAAGAAAGCGCTGGAGACCTCCGGCTA +CCTGATTGCGGACATTAAGTATGATGGCGTGCGTGGTAACATTGTGGTTGACAACGTGGC +TGAGGCCGCATGGCTGTCCCGTGTGTCCAAGTTCATCCCGGCGCTGGAACATCTGAACGG +TTTCGATAAGCGCTGGCAACAACTGATGAATGATGACCGCTGTATTTTCCCTGATGGCTT +CATGCTGGATGGCGAACTGATGGTTAAGGGCGTAGACTTCAACACACGGTCTGGCCTACT +GAGAACCAAGTGGCTCAAGAAGAACAACTTCGTGTGTGACCGTGGTGGTGTTGAGCCACT +GAAAGGTTCCAAAGTAGCCTTTGAGTTAGACCCCAAGCTACTCAGTGTTCGCCTGTATGC +TGTCCTTCCGATTCACATTGCGGAGTCTGGCGAGGACTACGATGTACAGAAGCTACTGAT +GCCATATCATGTGGAAGCCATGCGCTCTCTTCTGGTTGAATACTTCCCGGAAATCGAGTG +GCTTATCGCTGAGACCTACGAGGTCTACGATATGGATTCGCTGACTGAACTGTACGAAGA +GAAGCGTGCCGAAGGTCACGAGGGTCTCATTGTGAAAGACCCACAGGGCATCTACAAGCG +AGGCAAGAAGTCTGGCTGGTGGAAGCTCAAGCCTGAGTGTGAGGCTGATGGTATCATTCA +GGGTGTCAATTGGGGAACCGAAGGTTTAGCCAACGAGGGCAAAGTGATAGGCTTTAGTGT +GCTTCTTGAGACTGGTCGTTTAGTAGACGCCAACAACATCTCTCGCGCACTGATGGACGA +GTTCACAGCCAACGTTAAGGCACACGGTGAAGACTTCTACAACGGGTGGGCCAGTCAGGT +CAACTACATGGAAGAGACCCCGGACGGCTCCCTGCGTCACCCTAGCTTCGAAAAGTTCCG +AGGCACTGAGGACAACCCTCAAGAGAAAATGTAACCAACTCACTGGCTCACCTTCACGGG +TGGGCCTTTCTTCGTTCTAGGGAATTAACCCTCACTAACAGGAGACACACCATGTGGCTT +ATCCTATTCGCTATCGTCGCAACGCTGGGATTAATGGTTGCCGACGACGACATTTGGCCT +GATTGTTAAGGAGACAACATCATGCGTTTACACTTCAACACATCAAATGGTATCTTTTCG +GTTCGCCGTGAAGACCGCTCTACAGCAGTGGCCTTTGAGCGCAACGCTAAGCTGCCGCTG +ATTGGCTCGGTCGTCCCATTGTCGCCTCGTGTTCACCTACTGATCACTCGTGGAGATTTC +ATTAAGGCGATGAACAAAGAGCGCCCGCATCTGGAAGCCGTGGTCACTTACTGGCCTCGC +ATCCGTCTGTTCGTTAAGTGGATTAAGGAGGTTCTGTAATGTTACAACATCATTGGAACA +AACCAGATTTAGAGGCTCGCTTCCCGGTTAACTCTGCTGTGCGATACTCCGGCGACTTCC +TCAAGCGCTTCTTAGGTATGAGCGGAGTGGTCACTGGTCACTCGAACACAGGTCGCGTTA +AGGTTCGCTTCGGTAATCTGCACGCTGAGTTTCTTCCGAACAACCTGATTCCGCTGCCTA +AAGATGACGTTAAGACTCCGAACGTGGAAGCACCGAAGTCAGAAGTCAAGTCTGACGTAA +CCCACCCTAACCACTACATGCTGTTCGACAACGTGGAAGCCATTGAGGTTATAGCCCGGT +CAATGACCGTCGAGGCGTTCCGTGGGTACTGCCTTGAGAACATCCTGAAATACCGTCTTC +GTGCTGGTAAGAAATCCGAACTGGCAACTATGGAGAAAGACCTCAATAAAGCTGCATTCA +ATCAGGAACTCTTTGACAAACATAAGGGGCTGTGCTATGACGCTTCGTGAATGCTGCGAT +TGGTGTGCCGCTAAGTGGAACCAAGCTATTGAGGATGGTGACAAGGCGGCTGCTGACGCT +TACCAACAACTGTACGCGCTGTGGGAGCGGCGCCTTAAGGAGGCTCAAAGTGGAGCAACG +TGAACAGAAATACCTTCTGACGATAGAAGGCAACACCGAGTCCTTTGAGGTTCCGGTATT +CGCCCGGTCTCTCGAAGAGGCAACGCTACAGGCTGAACATTATGAGGACGCTGGGTTCGT +AGTGACTCGCATCCGTCCAGAAGTGAAAGCCTAATTACCCTCACTAAAGGGAACAACCAA +ATCATTAACCACAAAGGAGAAACATTATGGCTGGTTTCAAGAAGAAAATCTACACCTCTG +GTCTTGGCACTGCTGAGCCTTATGCTTACCTGAGTAAGCCGGATTATGGCAACGAAGAGC +GTGGCTTCGGCAACCCTCGTGGTGTCTATAAGGTAGACCTGACTCTTTCCAATAAAGACC +CGCGCTGTCAAGCGATGGTCGATGAAATCGTGAAGACTCACGAAGAGGCTTATGCTGCTG +CCGTGGAAGAGTTCGAAGCTAACCCGCCGCAGGTACAGCGTGGTAAGAAACCACTGAAAC +CTTACGAGGGCGACATGCCGTTCTTCGATAACGGTGACGGTACGACTACCTTCAAGTTCA +AATGCTATGCGTCTTTCCAAGATAAGAAGACCAAAGAGACCAAGCACATCAATCTGGTCG +TGGTCGATAGCAAAGGTAAGAAGATTCAGGAAGTGCCGATTATCGGTGGCGGCTCCAAGC +TGAAAGTGAAATACTCTCTGGTTCCTTACAAGTGGAACACCGCTGTGGGCGCAAGCGTCA +AGCTGCAACTGGAGTCCGTGATGCTGGACGAACTGGCTACCTTCGGCGGTGGCGGTGAAG +ATGAGTGGGCTGATGAAGTCGAAGATGGTGGTTACACTGCGAGTGAATCCCGTCAGTCCC +GCGATGAGCAGTAGTGGCAGGAAGACGAGCACGGAGAAACCCCGGATGATAACGAGGACT +TCTAATGGCTGGCGCATACGCTGCGCGAGGTGTACGCAAGGTCGGGGCTTTCCGCTCCGG +CCTAGAAGATAAAGTCTCAAAGCAGCTTGAGAGTAAGGGAATTAAGTTCGACTATGAGCT +TTGGCGTATCCCTTACGTCATCCCGGCGAGTGACCACTTATACACTCCAGACTTCCTGCT +ACCTAATGGCATATTGATTGAGACCAAAGGGCTGTGGGATTCCGATGACCGCAAGAAACA +CCTTTTGATTCGTGAGCAACACCCTGAACTGGATATTCGCTTGGTCTTCTCAAGCAGCCG +CTCAAAGCTCTACAAAGGTAGCCCAAAAAGGAGTAAAGAAAAATGTCTAAAGTTCAATTC +AAACCACGAGAAACCACGGAGGCAATCTTTGTACATTGCTCAGCAACCAAGCCAAGCCAG +AACATTGGCGTTCGTGAGATTCGTCAGTGGCACAAAGAGCAGGGCTGGTTAGACGTAGGA +TATCACTTCATCATCAAGCGTGATGGCACTGTGGAAGCAGGCCGCGATGAACTGGCTGTA +GGTTCCCACGTGAAAGGTTACAACCACAACTCCGTAGGCGTATGCCTCGTGGGTGGGATT +GATGATAAAGGCAAGTTCGACGCCAACTTTACACCTGCGCAAATGCAAGCGCTGCGTAGT +CTGCTGGTCACGCTGCTGGCGAAGTATGAGGGTTCAGTCCTTCGTGCTCACCATGACGTT +GCATCCAAAGCCTGCCCGTCCTTCGACTTGAAGCGCTGGTGGGAGAAGAACGAACTGGTT +ACATCTGACCGAGGGTGATACCATGAGGATGATTTGTATTCGCTGTGATAAGCCGTTGAA +GAGTCGTGTACCGTCACGTCAGTGTCAGTGCAAAGACCCAATCAAGGCGGAGGAACACAC +CGAGGAATAATTAACACTCACTAAAGGGAGACTTAACGGTTTCCCTTTGTTCGCACTATT +GATTAAGGAATGTACAATGGAACGAGAAGACGATAGTATCTTTCTGTTTCATGCTCCATG +TGAAAACTGTGGGTCTTCTGATGGTAACTCTGTGTACTCTGACGGGCATGAATGGTGCTT +CGTGTGTGAACATCGAGTACCCGCAAACGAAGAGCGTGAAGCAAAGTTATCAACGAGAAG +ACGTACAGGAGGCAGCAAGCCTATGAGCTATGACGTATGGAATTTCGGTGACAGCAACGG +TCGATACTCTGACCTGACTGCCCGTGGCATCTCGAAGGAGACATGCCAAAAGGCTGGCTA +CTGGCTGGCGAAAGTGGACAACCGAATGTATCAGGTTGCCTACTACCGAGACCAGAACGG +CTCCATCGTGTCGCAGAAGATGCGCGATAAGGACAAGAACTTTAAGACCACCGGAAGCCA +CAAGAGCGATGCGCTGTTCTTGAAGCACCTCTGGTCTGGCGGTAAGAAAATTGTGGTCAC +TGAGGGCGAAATTGATGCGCTCACTGTGATAGGATATCCGCAAGTTCTTCTTAGGCATCG +CATCGTTCGATTGTCACAGCGGGAACATGATGAAAGACCAGATGGGACGCCTGATTATCA +CAGACCCGGTATCATTCAGCGCAGACGACAAGTTAAAGCCGGGTGAGTTCCACTGTGACC +CGGATGAACTCATCGCTGAGATTGAGGCGCGGAACTCCAAGACTGTAAGTACCCGGTCGT +ATCATTAGGTCACGGTGCCTCTGCTGCTAAGAAGACATGCGCCGCTAACTATGAATACTT +TGACCAGTTCGAGCAGATTATCTTGATGTTCGACATGGATGACGCAGGCCGTAAGGCAGT +CGAAGAGGCCGCACAGGTTCTCCCGGCTGGTAAGGTTCGTGTTGCCGTGTTGCCGTGTAA +GGACGCCAACGAGTGTCACATCATGGGTGAAGACAAAGCAATCTTGGAGCAAATCTGGAA +CGCGAACCCTTGGGTGCCTGACGGTGTTGTTTCTGCGTTGTCACTCAAAGACCGCGTTAA +GGAAGCTATGACCTCCGAGGACGCTGTAGGTTTATTATTCGATGGCTGTCAAGGCCTGAA +CGATAGAACCTTGGGTGCTCGTGGTGGCGAAGTCGTTATGGTCACTTCCGGTTCCGGTAT +GGGTAAGTCAACGTTCGTTCGTCAACAGGCTCTGGCTTGGGGCAAGCGAATGGGTAAACG +TGTGGGCCTAGCGATGTTGGAGGAATCCGTTGAGGATACCATTCAGGACATGATGGGCTT +GAACAATAAGGTTCGTCTGCGTCAGTCTGATGAAGTCAAGAAGGCTATCGCAGAGGACGG +ACGTTTCGATGAATGGTATGATGAACTATTTGGAGACGATACGTTCCACCTTTATGACTC +CTTTGCGGAGGCCGAAGCTGACAGGCTGTTAGCGAAGCTGGCCTACATGCGAACAGGCTT +AGGGTGTGATGTTATAGTGCTCGACCACATATCAATCGTCGTGTCTGCCTCTGAGGAATC +GGATGAGCGTAAGATGATTGACCGCCTCATGACGAAGCTCAAAGGGTTCGCTAAGTCAAC +TGGTGTTGTGCTCGTAGTGATTTGTCACTTGAAGAACCCGGAGAAGGGAAAACCACATGA +AGAAGGACGCGCTGTTTCTATTACTGACCTACGTGGTAGCGGTGCCTTGCGTCAGTTATC +TGATACTATCAACGCCTTGGAGCGTAACCAGCAAGGTGATATGCCTAACTTGGTGTTGGT +TCGCCTGCTTAAGTGTCGTTTCACTGGCGACACTGGAATTGCTGGGTACATGGAATACAA +CAGAGAAACCGGGTGGCTTGAACCGTCTAGCTACACTGGCGAAGAAGGAGAAGGAGATAC +TGGCTGGACTGAACAAGACGGACAATCAGACTTCTAAAGGATGCCCGTGTGGGCATTCCG +ATTGCGATGGAATCATGTACCACTAATTAACCCTCACTAACGGGAACAACCATTAAACCA +TAGGAGACACATCATGTTTAAATTCATTAACGCTTTAGGTAAGCTGGTAGTTAAACTGTA +CTTCATCGAAGCCAAGAAGCTGGACAAGAAGGCCAAAGCTGATTCACAGCGAGCCATTGA +GTTGGCGAAACAGTCCCGTGAGAAATCCGATGCGGCTGTTAGTGGCATCCACAAGTCGGC +AGCGATTGCAGCCAAAGCACAATCCATGAGCAAATTCTTTGAGTAAGGAGCGCACACTAT +GAGCAAGTCAATCACCCACGCAAACACCATCCGTCTGCCAGACACCGCTGACCAGTTCTC +CCGCCGAGTACACATCAATGTGCGTGGTGAGAAGGTCACGATGGTCTACCGCTGGAAAGA +CCACAAGTCTCCGAAAGCACACACTCAACGAATGACCTTGGTTGACAAGCAGGTCGGTCG +CTTGATGGGTGCCCTGACTATGGCTGCTGACAAGGTGGTCGGTGATAACCGTGAGCGTCT +GGTAGAGTTCGGCGCTGGTATGCAAGAGATTATCGAGAAGTGATAAACTCAAGGTCGCCC +AAGGGTGGCCTTTATGATTACCATTTAGCACGAAACCAAAGGAGGGCATTATGCTCGTAA +GTGACATTGAGGCCAACAACCTCTTAGAGAAAGTCACCAAGTTTCACTGTGGCGTTATCT +ATGACTACCGTGATGGTGAGTATCATAGCTATCGTCCGGGCGACTTCGGGGCGTATCTGG +ATGCGCTGGAAGCCGAGGTGAAGCGAGGTGGGCTTATTGTTTTCCATAACGGTCACAAGT +ATGACGTTCCGGCTTTAGAGAAACTCGCAAAGCTGCAACTCAATCGTGACTTCAAGTTAC +CCCGTGAGAACTGTATTGATACATTGGTACTCTCGCGTTTACTTCATGCGAACCTTAAAG +ACACAGACATGGGGCTTCTTCGCTCCGGGAAACTACCCGGTCGTCGCTTCGGGTCTCACG +CTCTGGAGGCATGGGGCTATCGCTTGGGTGAGATGAAAGGTGAATACAAGGACGACTTCA +AGGCTATGCTGGAAGAGCAGGGCGAAGAATATGTTGATGGTGCTGAGTGGGTTTCGTTCA +ACGAGCCGATGATGGCGTATAACGTTCAAGACGTTGTGGTCACTGTCAAACTCTTAGAGA +AATTCCTTACAGACCTCCACTACTTCCCTGCGGGTATGGACTTCACGAAGTACGATGCGG +ATCTATTCTGGCGAGAAGCTGGCGAGTCTGTGGATATTGAACATCGTGCAGCGGGGCTTT +TAGCGAAGCAGGAGCGTAACGGCTTCCCGTTCAACACCAAGGCAATTGAGGAACTTTATG +TAGAACTGGCAGCGAAACGCGCCGAACTTCTGCAAAAGCTAACCGAAACGTTTGGCTCAT +GGTATCAACCGAAAGGCGGTAAGGAACTCTTCAAGCACCCACGGACAGGCAAGCCGCTGC +CGAGCTATCCTCGCGTGGTCTATAGGGTTAATGAAATGACTACAGATAACTACAGGGCAT +CACTACAGGTTAACAATGGGTCTATCGGTCTGGTTGTCTTTAAGATAGCGTCGCTCTTTA +GGTGATGGCTTTAGGTCTGGTCTTTAGGTAGTGGCTTTAGGGTTTACTTTATGAGGCTAA +CAGATAGGGACACATAGAGATGTACTATCGAACTGGTACACTAGGACACTCTTTAAGGCC +TCCTTAAGCCACCCAATCACTTTAGGTATTGACTTTAGGCAACACTTTAGGCTATCCTAT +AGGCCACCCGAAACAGGGTGGCGTGTACAAGAAGCCTCGTAATAAGGCACAGCGCGAAGG +TCTTGAACCTTGCGACTTGGACACGAGGGATTACATGGAGGGTGCTCCATATACTCCGGT +AGAGTTCGTTACGTTCAAGCCAAGTAGCCGTGACCACATTCAGAAGAAACTACAGGAGGC +CGGATGGGTTCCTGAGAAGTTCACCGAGAAGGGTGCGCCTGTGGTGGACGATGAGGTCTT +GGAGCATGTACGAGTGGATGACCCTGAGAAGCAGGCGTGCATTGACTTGATTAAAGAGTA +CCTGATGATTCAGAAGCGAATCGGTCAGGCGGCAGAGGGTGACAAAGCGTGGTTACGTTA +TGTTCAAGATGATGGTAAGATTCATGGAGCCGTTAACCCTAACGGTGCAGTTACTGGTCG +TGCTACTCATAGTTTCCCAAACCTTGCACAAGTACCCGGCGTTCGTTCTCCTTACGGGGA +GCAGTGTCGTAGCGCTTTTGGTGCTGAACATCATTTGGATGGGATTACTGGCAAGCCGTG +GGTGCAAGCGGGGATAGACGCCAGTGGCTTAGAGTTGCGCTGTCTGGCACACTTCATGGC +TCGTTTCGATAACGGAGAGTATGCGAATGAGATTCTCAACGGTGACATTCACACCAAGAA +CCAGAACGCTGCGGAACTCCCAACGCGAGACAACGCCAAGACCTTCATTTACGGGTTCCT +TTACGGAGCAGGAGATGAGAAGATTGGTCAGATTGTTGGGGCAGGGAAGGAGCGCGGGAA +GGAACTCAAGAAGAAATTCTTAGAGAACACCCCGGCGATTGCAGCGCTACGAGAAGCTAT +CCAACAGTCTCTCGTTAAGTCTTCCGCTTGGATTGGCGCTGAGCAGAAAGTACAGTGGAA +GCGCCGTTGGATTAAAGGTCTGGATGGTCGCAAGGGGCATCAGTACACACGACAGGCAGT +ACGGAAAGTGACACGATGCAGTGCTGCCATGATTTGATCGCTCTTTAACAATCTGGATAA +TAGCTCTTGAGTGTACCGATGTATAAGCGAATAACTCAAGGTCGCACTGAAAGCGTGGCC +TTTATGATATTCACTTATTCACGTCAGGTCTCCACACGCAGCGCTCAACACATTGTTGCA +GTCTGCTGGTGCTCTGATTTGTAAGTTGTGGATCATCAAGACCGAAGAGATGCTCATTGA +GAAAGGCTTGAAGCATGGCTGGGATGGTGACTTTGCGTACATGGCTTGGGTTCACGATGA +GATTCAGGTGGCCTGCCGTACAGAGCACATCGCTCAGATTGTTATTGACACCGCGCAGGA +AGCTATGCGTTGGGTCGGAGAGCATTGGGCTTTCCGTTGTCGTTTAGATACCGAGGGTAA +GATGGGGCCGAATAGGGCTGTCTGCCACTAACAATAGGAGAAACATTATGGCAATGACCA +AACACTTTAAAGTAACCTTCGACGTTACCGCTGTGATTGACAGTGAATCCGAGAAGAATC +TGAACGAGTTGCTGGTAGACCTAGCTAAGAAGGCCGGGGCTGGCGAGAAGCTGAATCCGT +TCAAACAAGAACTGCTTATTCAAGGCCTGACACACGGGCCGGAAGGTGCTGCTGCGTTCT +GTATCAAGCAAGGTCTCCGTGAGTTTATCCGCGATGGTCACAGTGAGTTAAGCTCTACCG +AGCAGAAGCTGATGAGATTCTCACCTGCAACTGTGCGAGAGGTATTCAAATGAGTGAATA +CCTGAAAGTTCTGGCAGCTATCAAAGGTTGCCCTAAGTCCTTTCAGTCGAACTATGTGCG +AAACAATGCGGCTCTCGTAGCTGAGGCCGCTTCTCGTGGACACATTAGCTGTTTGACTGT +GGGCGGTCGCAATGGTGGAGCATGGGAGGTCACAGCCTCTGGTGTGCGCTTCCTGAAACG +AATGGGAGGTTGCGTATGATTATGCCTAAGAGTGACACCGTAACGATGACCCGTGATGCG +TGGAACGATGTTAGCGCGTACATTGATAAGCTGGAGAAAGGCCTAGAGTTCCTGAATGCG +CTTAAGGCGTGTGGTGTGGATAATTGGGACGGATACTCTGATGCAGTCGAAATGGTTTAC +GGGGAGGATGACGAATGAGCCTAATCACATTGAAAGACTTCGCGGAGATGCGTGAAGGTA +ATCCTATGGAGAAGGGAGTGCTGGTCATGGATGGTGACTAGTTGGTATATCAGTCAATGG +CTGCTGCCGAAGTTGAGACGGATTGGGGAGACGACATTTGGACTCTTGAGTGTGACCACG +CCAAGGCACGGAGCATTCTCGATTCTGCAATCGAATCGTACCGAACCCGTAAGAAGGCTT +GGAGTGACGCTATGGTTGTTCTGGCGTATACCGACGATGTGAACTGGCGTAAGGTACTGG +TTGATGAGACCTATAAGGAGAACCGTAAGGCGACCCGTAAGCCTGTGGGCTACCGTGACT +TCCTGTCGAAGCTGTGGGAGCGCGATGAGTTCATTCACATCAAAGAGGACATGCTGGAAG +GTGATGACGTTATGGGTATCATTGGGTCTGGTCACGAGGTCTTCGGCTTCAAGAAAGCTG +TGTTGGTCTCCTGTGATAAGGACTTCAAGACTATACCGGACGTTGACTTCCTGTGGTGTA +CCACTGGTAACATATTGACGCAGACCAAAGAGACCGCTGATTGGTGGCATCTCTTCCAGA +CTATCAAGGGCGATATGACTGATGGCTACTCCGGGATTCCCGGTTGGGGTGACACGGCAG +AAGGTTTCCTGAATGACCCGTTCATTGTGGAGCCTGTAGAGTCCGTGTTGAAGTCCGGTA +AGAACAAAGGGCAGACTGTCACTAAGTGGGTGAAACGCGCTCCTGATGCGACTGAGAGCC +TGTGGGACTGCATCGTATCCATTGGTGCCAAAGCTGAGATGACCGAACATGAAATCATTA +AGCAAGGCCAGATGGCACGCATTCTTCGCTTCGAGGAATACAATTACATTGACAAGGAGA +TTTACTTATGGACGCCGCGAAGCTGATTACCATCGCTGTGCTGGTAGGTATGCTGGCGCG +AGGTCTCTGGATGTTCGCTCTCATAGTCCGAGACGTGAAGCGAGACTCCGAGATTAAGTG +ATACACTCAAGGCTCTCTGTATTAACCCTCACTAAAGGGAAGAGGGAGCCTTTATGATTA +TTACTTTAAGACTTGTAGATACTCTTTAGCTGCACGCGGCATACTAGGAATATCATCGGG +ATGAGTTAAAACATGATTAATTGGTTGTAACATAAATTCACCTCTTAAGGTTAGGTGCGC +TTCAATCAGGCTTATGTGATGGAGTCCGGGGAGTACCGTGCGCTCCGCGCTGCTGGTTAC +TCTGAGTCTTTCATTGCGGGTGTGATGCATGGTCTGTACCTTGCCTCTCGAACACTTGAT +GAGATTGAGGTGCGTAAAGAGCAACTGAGACAGGAGTAACGATATGTGGTGGAAACCGAA +GGTGAAAGTCCCTAAGATGGACACTAACCAGATTCGCGCTGCTGAACCAGCACCTTTGAC +TGAACCTCCGAAGTCTGTGGTATGGGGAGGCGATGATGACGAGGACACCAGTGTGTCTTC +CTCTGAGGTGCCAACCACACCGAGCAGCGGTAAGAGCAGTCTCAAGGTAAAGCTGGATGA +CAGCGCAGCCAAGAACAAGAGTAAATCCTCCATTCGCTCCAAGGCGTTTGGGTAACTGAG +TCATAGCATAGGGAGAAACATCATGGGATTCTTCAAGAAAATCAAGAAGGCCGTTAAGAA +AGTTGTGAAAGAAGTTAGTAGACCAGTCGAGAAGGCCGGTAAGGAAGTGGGCAAGGTGGT +TGGAGGCGCGCTGGGTGCAGGTAAGCAGGAGATTATCCAACAAGAGGCTCCTGTACCAGT +AGTCGCTGCACCGCCACCAGCACAGGTTGTAGATGTACCGGAACAGGATAAGGCTGAGGG +TGAGGATGAGGCGCAAACCGAAAGCGCACGTAAGAAAGCACGCGCTGGCGGTAAGAAGTC +TCTGAGTGTAGCCCGTAGCTCCGGCGGTGGCATCAACATCTAAGGAGGACTGAATGGCTG +ATTCAAAACGTACAGGATTGGGCGAAGACGGTGCTAAAGCTACCTATGACCGCCTAACGA +ACGACCGTAGAGCCTACGAGACTCGTGCGGAAAACTGTGCGCAATACACCATTCCGTCCT +TGTTCCCGAAGGAGTCCGATAACGAATCTACCGACTACACGACTCCGTGGCAGGCTGTAG +GTGCGCGGGGTCTTAACAATCTGGCCTCTAAATTAATGCTGGCACTATTCCCGATGCAGT +CGTGGATGAAGCTGACCATTAGTGAATATGAGGCGAAGCAGCTTGTTGGAGACCCTGATG +GACTCGCTAAGGTGGACGAAGGTCTGTCTATGGTTGAGCGTATTATCATGAATTACATCG +AATCCAACAGCTACCGTGTGACACTCTTTGAGTGCCTCAAGCAGTTGATCGTGGCAGGTA +ATGCACTGCTTTACTTACCGGAACCAGAAGGCAGCTACAATCCGATGAAGCTGTACCGAT +TGTCTTCTTATGTTGTCCAAAGAGACACTTACGGCAATGTGTTACAGATTGTCACTCGTG +ACCAGATAGCCTTTGGTGCTCTCCTTAGTCTTAAATTTATCGAACGGAACCTCCTTCTTG +GGTTCTTTGAGCCACTCCACCGGAATTAGCTTGTCAGCAAACAGAATGCCATGCTTCTCA +CACCACTCGGCGTAGCTTGCCGGAAGACGTTCGGTCTGCGGTAGAGAAAGCTGGTGGTGA +GAAGAAGATGGACGAAATGGTCGATGTGTACACCCATGTGTATCTCGATGAAGAGTCCGG +CGATTACCTCAAGTACGAGGAAGTAGAGGACGTTGAGATTGATGGCTCCGATGCCACCTA +TCCTACTGACGCTATGCCCTACATTCCGGTTCGCATGGTTCGCATTGATGGCGAGTCTTA +CGGTCGCTCCTACTGTGAAGAATACTTAGGTGACTTAAGGTCGCTTGAGAATCTCCAAGA +GGCTATCGTTAAGATGAGCATGATTAGCGCGAAGGTCATCGGTCTGGTGAACCCGGCTGG +CATTACGCAGCCACGTAGATTAACCAAAGCTCAGACTGGCGACTTCGTTCCGGGTCGTCG +AGAAGACATTGACTTCCTTCAACTGGAGAAGCAAGCTGACTTTACCGTAGCGAAAGCTGT +GAGTGACCAGATAGAAGCACGCTTATCGTATGCCTTTATGTTGAACTTTGCGGTGCAACG +AACAGGTGAACGTGTGACCGCCGAAGAGATTCGATACGTTGCGTCAGAACTGGAAGATAC +ACTTGGTGGCGTCTATTCGATTCTGTCTCAACAACTGCAATTGCCTCTGGTTCGTGTGCT +CTTGAAGCAGCTCCAAGCAACCTCGCAGATTCCTGAGCTACCGAAAGAAGCCGGTGAGCC +GACTATCAGTACAGGTCTGGAAGCAATCGGTCGTGGTCAAGACCTCGATAAGCTGGAGCG +CTGTAACTCCGCTTGGGCTGCTCTGGCCCCTATGCAGGGAGACCCGGACATTAACCTTGC +TGTCATTAAGCTGCGCATTGCTAACGCCATTGGTATTGATACTTCTGGTATCCTACTGAC +TGACGAGCAGAAGCAAGCACTGATGATGCAGGATGCGGCCCAAACAGGTATCGAGAACGC +TGCCGCCACTGGTGGGGCTGGTGTGGGTGCTCTAGCGACCTCAAGTCCAGAAGCTATGCA +GGGTGCAGCAGCACAGGCTGGCCTAGACGCCACCTAATAACCCTCACTAAAGGGAGACCT +CATCTTTGAAATGAGCGATGACTAAAGGTTGGAGTCCTTTGGTTTCCCTTTATCTTTAAC +AACTTAGGAGATTTAACAATGGCTGAATCTAATGCAGACGTTTATGCGTCCTTCGGTGTG +AACAACGCGGTAATGACCGGAAGCACACCTACTGAACACGAACAGAATATGCTGAGTCTC +GATGTTGCTGCCCGTGATGGCGATGATGCAATCGTACTTAGCGAGGAACCGAGTTCCCAT +AACGATGACCCATATGCATCCGGTGTAGACCCGTTCGCTGATGGTGAAGACGATGAGGGC +CGCATTCAGGTTCGTATCAGTGAAGATGGTAATGAAGCCGAGTTCGACACCGGTAGCGAT +AACGCTGAGGTGGAGACCGAAGGTGAGGCCGCTGAGTTTGAACCGCTGGGTGACACTCCA +GAAGAACTGAGCCAAATGACTGAGCAGTTGGGACAGCACGAAGAAGGCTTTCAGGCGATG +GTCGAGCAGGCCGTTGAGCGTGGACTGAGCGCAGAGTCTGTGACTCGCATCTACGAAGAG +TACGAAGCCGATGGCATCTCTGAGAAATCCTACGCGGAACTCGAAGCTGCTGGCTATAGT +CGTGCCTTTGTGGACTCCTACATCTCCGGTCAGGAAGCCCTTGTAGACCAGTACGTCAAT +CAGGTAGTTGCCTTTGCTGGTGGTAAGGAGCGCTTTAGCGCAATCCATACGCACCTTGAA +GCAACCAACCCGGCTGCGGCTGAGTCCCTTGAGACTGCCATGATGAACCGAGACTTGGCG +ACTGTCAAAGCAATTATCAATCTGGCTGGTGAGAGCTACACGAAGAAATTCGGTAAGCCT +GCCAACCGTAGTGTTACCAAGCGTGCTACTCCGGTTAAACCTGTAGCTCGTCAGAAAGAT +GGCTTTACGAATCAGGCTGAGATGATTAAAGCTATGAGTGACCCGCGTTACCGTAGTGAT +TCTGCCTACCGTCAAATGGTAGAACAGAAGGTTATCGACTCCAGTTTCTAATTAACGCTC +ACTAAAGGGAGAGACCATAGATGACTACAATGGTTGAATCACCTGAGCACAGAACTTTGT +GGTCACTCCCGTAGGTGAAACATTGAGAACCAACTCGATTCAAGTAGTAACCAAACTTTT +CTTTAAATTAACATAAGGAGATTCAACATGGCTAACAATCAAGGCGGACAGCAAATTGGT +ACTAATCAGGGTAAGGGTCAGTCCGCAGCGGACAAATTGGCGCTGTTCCTGAAAGTGTTC +GGCGGTGAAGTCCTGACGGCTTTCGCTCGCACCTCCGTGACCATGCCTCGTCACATGCTG +CGCTCTATTGCTTCTGGTAAGTCCGCACAGTTCCCTGTGATTGGTCGCACCAAAGCTGCT +TACCTGAAACCGGGTGAGAACCTCGATGACAAACGTAAGGATATCAAACACACCGAGAAG +GTAATCCACATTGATGGACTGCTGACTGCGGACGTTCTGATTTACGACATTGAGGACGCG +ATGAACCACTACGACGTTCGCGCTGAGTACACCGCACAGTTGGGTGAATCTCTGGCGATG +GCGGCTGACGGTGCTGTACTGGCTGAACTGGCTGGTCTGGTTAACCTGCCGGACGCCTCC +AATGAGAACATCGAGGGTCTCGGTAAGCCTACCGTACTGACTCTGGTTAAGCCGACCACT +GGCGACCTGACTGACCCGGTTGAGCTGGGTAAAGCGATTATCGCTCAGTTGACTATTGCT +CGTGCGTCTCTGACCAAGAACTACGTTCCGGCTGCTGACCGTACCTTCTACACCACTCCT +GATAACTACTCTGCGATTCTGGCCGCTCTGATGCCGAACGCTGCAAACTATCAGGCACTG +ATTGACCCTGAGCGCGGTACTATCCGTAACGTGATGGCCTTCGAAGTGGTTGAGGTTCCG +CACCTGACCGCTGGTGGCGCTGGTGATACCCGTGAGGATGCCCCGGCTGACCAGAAGCAC +GCTTTCCCGGCGACTTCCAGCGCTACCGTTAAGGTTGCTCTGGATAACGTTGTGGGCCTG +TTCCAGCACCGCTCTGCGGTTGGTACGGTCAAGCTGAAAGACTTGGCTCTGGAGCGCGCT +CGTCGTGCGAACTATCAGGCTGACCAGATTATCGCTAAGTACGCGATGGGTCACGGCGGT +CTGCGTCCAGAAGCTGCTGGCGCTATCGTGCTGCCAAAGACTTCGGGGGCTTAAGGGTAG +CGTCTTTGAGTATGAACGCGGAGAGTGAAGTGGAGCCGACCCAAGAGGTAGCCGCCGAAG +TAGCTCTCACGCCTCAACAGAAGGCCGCCATTACTCGTGCTCGTAACAAGGCACTTAAGT +CTCAATAACAACAAGCAAACCCCTTGGGTTCCCTCTTTGGGAGTCTGAGGGGTTTTTTGC +TTTAACCCTCACTAACAGGAGGTAACATCATGCGCTCTTATGAGATGAACATTGAGACCG +CAGAAGAGCTATCAGCCGTCAACGACATTCTGGCTTCCATCGGTGAGCCACCAGTATCGA +CCCTTGAGGGTGATGCAAATGCTGATGTTGCAAATGCTCGACGTGTGCTCAACAAGATTA +ACCGACAGATTCAGTCACGAGGATGGACATTCAATATTGAGGAAGGTGTGACTCTTCTAC +CGGATGCGTTCTCTGGTATGATTCCATTTAGCTCTGATTATCTGTCCGTAATGGCAACCA +GCGGTCAGACCCAATATGTCAACCGTGGTGGCTATCTCTATGACCGCTCTGCGAAGACTG +ACCGATTCCCATCTGGTGTTCAGGTCAACCTGATTCGTCTGAGAGAGTTCGATGAGATGC +CTGAGTGCTTCCGAAACTACATCGTTACCAAGGCTTCCCGTCAGTTTAACAACCGCTTCT +TCGGTGCGCCGGAGGTAGACGGAGTGTTGCAGGAAGAGGAACAGGAAGCGTGGCGTGCGT +GCTTCGAGTACGAACTAGACTACGGCAACTACAACATGCTGGACGGTGACGCATTCACCT +CTGGTCTACTTAACCGCTAATAACAAGGAGGCTCTATGGCTCTCATTAGTCAATCAATCA +AGAACCTCAAGGGTGGTATCAGTCAACAGCCAGATATTCTCCGGTTCGCTGAACAAGGTA +GCGTACAGATTAACGGTTGGTCTTCTGAGTCCGAGGGTCTCCAGAAGCGCCCACCGATGA +TTCACCTTAAGACCCTTGGTGCTGCTGGGTATGTGGGTGCGCAACCTTACGTTCACCTCA +TCAACCGTGATGAGTTCGAGCAGTATTTCGTGGTGTTCACTGGTGAAGACATTAAGGTAT +TCGACCTCGACGGTAAGGAGTACCAAGTACGTGGAGACCGCTCATATGTTCGTACAGCTA +ACCCACGAGAAGACCTTGGGATGGTAACTGTGGCTGATTATACCTTTGTGACTAACCGCA +AGGTGGTTGTACAGAGTAACGACCAATCGGTCAACCTTCCGGGCTTTAAAGACCAAGGCG +ATGCGCTGATTAATGTTCGCGGTGGACAATATGGGCGTAGACTCTCAATCGAGTTCAACG +GGGCTGAGCGTGCTGCTGTACAACTACCGGATGGTTCACAACCAGCACACGTTAACGAGG +TTGACGGTCAGGCTATCGCTGAGAAGCTGGCTGTGCAGTTGAGGAACAACCTTGGGAATC +CAAACAACGAGCAAGACCCGAATAAGTGGCGCTTCAACGTTGGCCCCGGATTCATCCATA +TCCTTGCGCCAAATAACGATAACGTTTGGGGACTACAGACTAAGGATGGTTACGCAGACC +AGCTAATCAACCCTGTAACCCATTACACTCAGTCGTTCCAGAAGCTGCCTATTAACGCGC +CAGATGGGTACATCGTGAAGATTGTTGGTGATACCTCAAAGACTGCCGACCAGTATTACG +TTAGGTTCGACCTCAACCGTAAGGTGTGGGTAGAAACAATTGGATGGAACACAAGGACTC +ACCTACATTACCACACGATGCCTTGGGCACTTGTTCGCGCTTCTGACGGGAACTTTGACT +TCAAGTACCTTGAGTGGGGTGCTCGTACTGTGGGGGACGATACAACCAACCCATACCCAT +CCTTTACCGGACAGACAATCAACGATATTTTCTTCTTTCGTAACCGTTTGGGATTCCTTA +GTGGGGAGAACATCATCTTGTCTCGCACCTCGAAATACTTAAACTTCTTCCCGGCATCCG +TGTCAAACTACTCCGACGATGACCCAATCGACGTTGCGGTTAGTCATAACCGGGTGTCAA +CCTTGAAGTATGCCGTTCCGTTCTCAGAAGAGTTACTCCTGTGGTCTGACCAAGCGCAGT +TCGTTCTGACAGCCTCTGGAATCCTTTCGAGTCGCTCCGTAGAGTATCGGTTAATGGATG +TGAAGGAAGCGCGAGGTGACGCAAAGTATACATTACGTCCTACACCATGTGGGCGTGCCC +TGTCTTGCACGTCGAACTGCGTCGTAAGGTTCAACTATGCGGTACAGGATGTAAGCTCTG +TGAAGAACGCAAAGGACATGACGGCTCACGTTCCGAACTACATACCGAATGGAGTATTCA +GTATATCGGGGACAACCGCTGAGAACTTCGCGGCTATCCTTACGAGCGGAGCACCGAACC +GAGTGTATATCTACAAGTTCCTCTATATTGATGAGGAAATCAGGCAGCAGTCGTGGTCTC +ATTGGGACTTTGGGGACAACGTTACGGTGTTTGCAGCACAGGTGATAAACTCAACAATGA +CTGTATTGATGAGCAATGAACATGCTGTGTGGATGGGACGCTTACACTTCACGAAGAACT +CCATAGACATTCCGGGAGAGCCTTACAGATTATACATCGACGCTAAGAGGAAATACACCA +CCCCTGCCGGGACGTATAATGATGATACCTACCAGACGTCCATAAGCCTCGCAACAATTT +ATGGGATGAACTTCACTAGGGGTAGAGTGTCTGTGGTCTTACCTGATGGGAAGATTGTAG +AGATAGACCAACCAATCAACGGGTGGAGTAGCGACCCAATACTGAGACTTGATGGAAACC +AAGAGGGACAAGTAGTCTACATTGGGTTCAACATCCCGTTCACTTATACGTTCTCGAAGT +TCCTCATCAAGAAGACTGCTGAGGACGGCTCGACGGCTACCGAGGATATTGGTCGTTTAC +AGCTTCGGCGTGCGTGGGTAAACTATGCGGACTCTGGAGCGTTCACCATCCGTGTGAACA +ACCTGTCCCGTGAGTTCATCTACACAATGGCTGGTGCTCGCTTGGGTTCTGACAATCTGC +GTGTTGGCAGGTCGAACATTGGCACAGGGCAGTACCGCTTCCCGGTTGTTGGAAACGCTC +AGACGAACATAGTAACTATCGAGTCAGATGCATCAACACCACTGAACATCATTGGGTGCG +GCTGGGAGGGGAACTACCTTCGTCGTTCTTCTGGCATTTAACTTAAAGTCTCCCTGTGGT +GAATTAACCCTCACTAAAGGGAGACACTAATAGATACGAGGGGTTAAAGCATTATGTACA +TTACAAAGTGTTTACAAATCCATGCCGACAACTTTCAGCCGTCCATAGAGGACATTCTGG +AAGCTGAGGCACTAGGTGTTGAACCAAAGGTAATTCCTGATGAGAACACTGTGGCAATGC +TTAGCGATAACGCTGTGTTGGCAATCGGTGGCAATCAGGGAGACCGAGTGTGGTTCCTTA +CCTCTAAGTACGTCCCACTGTTTACCTTGAAGGAGCGCTTAGAGTTTCGTAGACTTATCA +TTGAATATCGTGATATGATGCTGAGCCAGTACGAGTCCATTTGGAATTTCGTTTGGGTAG +GCAATAAGTCACACATTCGTTTCCTAAAGACCATAGGCGCGGTATTCCATAATGAGTTTA +CCGCTGATGGTCAATTCCAATTATTCACTATCAGTAGGAGGTAACTATGTGCTGGATGGA +AGCGATTCCTATTGCCATGATGGGTGCCCAAGCTCTAAGTAGCCAGAACAGTGCTGACAA +GGCGCGAGTGGCACAGACCGAAGCTGGACGCAGACAGGCAATGGAGATGGTCAAAGAGAT +GAATATCCAAAATGCCAACGCCTCGCTGGAACAACGGGACGCCCTTGAAGCTGCATCCTC +TGAGTTGACTACACGTAACATGCAGAAGGTACAGGCTATGGGAACCATCCGTGCAGCTAT +TGGCGAGGGTATGCTCGAAGGTGAGTCCATGAAGCGCATCAAGCGTATCGAAGAGGGCAA +CTACATTAGGGAGGCAAATAGTGTCACCGAGAATTACCGCCGAGACTACGCGAGTATCTT +TGCGCAACAGTTGGGACGCACTCAGTCCACAGCGAGTCAAGTCGATGCAATGTACAAGAG +CGAGGCCAAAGGTAAGTCTGGTCTGATGCGTGTACTAGACCCTCTGTCCATTATGGGTCA +GGAAGCTGCAAGTCAATATGCGGCTGGTGGATTTGACAAGAAGGGTGGAAACCAAGCAGC +ACCTATCAGTGCCGCCAAAGGAACCAAGACCGGGAGGTGATAATGGCTAGTAAACTAAAT +AGTGTTTTAGGCAACATGGCGACTCCCGGTATGGAACGACTCCGGGGCGTCAAAGGTATG +GACTACCGGGCAGCAACCATTCAGGCTGAACAACCAAGAGCGAGTCTTCTGGACTCCATT +GGTCGATTCGCTAAGGCTGGTGCCGATATGTACATGGCGAAAGATGAACGTGATAAGCAA +CGAGCCGATGAGCGCTCCAACGAGATTATCCGTAAGCTGACCCCTGAGCAGCGCCGACAG +GCTATCCAGAATGGTACACTGCTGTGTCAGGATGACCCATACGCAATGCAAGCCTTGAAG +TTCAATACCGGGCGTAACGCTGCGTTCCTCGTTGACGAAGAGGTTCAACAGGCCATCAAA +GAGGGTCGCTTCCGTACTCGTGAAGAGATGGAGCAGTATCGTCACTCACGCCTACAGGAG +CACTCGAAGTCGTTCGCTGAGCAGTTCGGTATCAATGAGATGGACGAGGAATACCAGAAG +GGTTTCAACGCGAATATCACCGAGCGTAACATTGCTCTGTATGGGGCACATGATACCTTC +CTGAGTGACCAAGCGCAGAAGGGTGCAATCCTGAACTCGAAGGTTGAACTCAACGGTGTC +CTATCTGACCCTGACCTACTGTCTCGTCCTGAGTCCGGTGAGTTCTTCCAGAACTACATT +GACAACTCCTTGGTGACGGGGATGACCGACAATCAGGCTCAACAGGTTATCTCTTCGTCC +CTGAATGACGTGCTACAGCGTCCGGGTGGTGCCGCCTTCTTGCAGAACATTGAGAACCGC +AAGGTGACTCTTAATGGCGCTACGACTACCTATCGTGAACTGATGGGTGATGAGCAGTGG +CAGGCAATGATGATTAAGGCACAGCACACTCAATTCCAGAACAACGCGAAGTTAACCGAG +AAGTTCCGACTGGATATTAACTCAGCGCTTAACCAAGCAGACACTGGTAAAGGCTGGGAG +ACTCTTCAAGGTATCAAGGCCGAACTCGATAAGATTCAGCCGGGTGAAGAGATGACTCCT +GAGCGCGAGTGGTTGATTTCCGCACAGGAACAGATGCGCACACGCTTCAAGCAGGAACAG +GCTGAGACAGCCAAGCTGATGGACAAGCAACAGAAGACCTTGAATAAATCTTTGGTCATC +GACAAGCAGTTCCAGAAGCGCCTCAACGGTGAATACGTCTCGACAAACTATAAGGACATG +CCGACCAACGAGAACACTGGTGAGTTTACACATAGCGATATGGTCAACTACGCGAACCAG +AAGTTAGCGGAAATCGAAGCGATGGACTTAACGCCAGAACAGAAAGACAAACTGAAATTG +GACTACCTACGGGCAGACTCCAAGGAGGGTGCTTTCCGTGCAGCGTTTGGTGAGATGATT +ACTGATGCTGGAAACGAATGGCAGGCTGCGGTGATTAACGGTAAGATGCCTGAGAGCGCA +CCAGCGATGGACAACCTTCGTCGCATCCGCAACACTGACCCTGACCTGATTGCCTCTCTG +TATCCTGACAAGGCCGAGTTGTTCCTGACTATGGACATGTTGGATAACCAAGGTATCGAC +ACGCAGGTTCTTATCGACGCTGATAAGTCCCGCGCACAGAAGACCAAGGAGATGCAGTTT +GAGGATGACCGAGCGTGGGCTGCTATGATGAACGATTCAACGGATCCTCAAATCAAGTAC +ATGCCTTCGAGTGTCCAAGGTTACGCGCGGAAGATTTATGATTCCGTGAAGTACCGGACA +GGGAACCCTGACATGGCAACAGAACAGGTCGCAAAGTTCCTCTCTGATTCAACGACTACG +TTCTCCAGTAGTGATGTTGATGGCGATACCTATGGTGTCCTGCCGAAGAACATCCTGACT +GTTTCGGATGACCCTAAGTCGTGGGAGCAAGGGAAGAACATTCTGGACGAAGCCATTAAG +GGAATCACAGCGGCGAACCCTTGGATTACCAACAAGCAACTGACGGTGTACCAGCAAGGT +GATTCAATATACCTGATGGACACAACCGGACAGGTTCGCATTCGGTATGACCAAGAGTTG +CTCCGGCGTGAGTACCAGCGTACCGCACAGATGCAAGCTGAGGCAGCACGAGAGAAAGCC +CTCAAAGAGGCCAACAAGCGTGCCCCAATCAGCCGTGTACCACAGGCGCGTGAAGAAGCG +CGTAAACGTGTCCAAGAGAAACGGAAGAAGACTCCGAAGTACATCTATGGACGTAAAGAA +GACTAACAGTGATAAGGAGGCTCCATGAGCTACGATAAGAACCAACCTAGCGAGTTCGAT +GGGTTATTTCAAAAAGCGGCAGACAAACATGGGGTCTCCTATGACCTGCTTCGTAAATTA +GCATTCAATGAGTCCAGTTTCAATCCAAAGGCCAAATCACCAACTGGCCCGAAGGGTCTC +ATGCAGTTCACCAAGGGTACAGCCACTGCGCTGGGACTCAAAGTCACTGATGCAGACGAT +GATGACCGTTACAACCCGGAGTTGGCTGTGGATGCAGCCGCTCGTCACCTGAGTGACCTC +ATTCGTAAATACGATGGGGATGAGCTTAAGGCAGCCCTAGCGTACAACCAAGGCGAGGGA +AGAAATGGTGCCCCTCAGATGCAGGCCTACGACAAAGGTGATTGGGCCTCAATCTCTGAG +GAAGGTCGTAACTATATGCGTAACCTGATGGACGTAGCTAATAGTCCTCGCAAGGGGGAC +TTGGAGGCGTTCGGCGGTATCACCCCAAAGGCTAAGGGCATTCCATCGGGGGATGCATTT +GCTGGAATCGGGAAGAAGCAGACGGTAGGCACTGACCTGCCGGAGTCAACGGGATTCAAA +GTGGAGGGTAAAGAGCAGCAAGCGCCTAACGTTCCTTATGCTAAGGACTTTTGGGAAAAG +ACTGGAACAACACTGGACGAGTTTAACTCACGCTCTACCTTCTTCGGAATTGGCGATGCA +ACAAGTGCGGAGCTTCATAACTCTGTACTTGGAGTTGCTTTCCGTGCAGCCCGTAGCGAC +GATGGTTTTGATTTGTTCAAGGACACCATTACGCCTACCCGTTGGAATAGCCATACGTGG +ACTCCAGAAGAGCTAGAGCGAATCCGTAAGGAAGTGAAGAACCCCGCGTACATCAACGTA +GTCACTGGAGGCTCTCCTGAGAATCTGGACGCCCTCATTAAGATGGCGAATGACAACTAT +GAGATGGATGCGCGGTCTGCCGATGCTGGTGTTGGTGCCAAACGTACTGCTGGTATCATC +GGCGCTGGTGTAGACCCGCTGAGTTATGTACCGCTAGTAGGCGTAGCCGGGAAGGGTCTC +AAGGTGGTTAACAAGGCTTTCATTGTGGGTACTCAAAGTGCTGGCCTCGCGGTTGCCTCT +GAGGGTCTCCGTACATCAACCGCTGGTGGAGAAGCCCACTATGCTGATGCTGCTTTAGGT +GGTCTCTTGTTTGGTGCTGGTATGAGCGCAATCAGTGATGCTATCGCTGCTGGTGTTCGC +CGTTCCCGTGGGACTGAGGTAGTTAATGACTTCGCTCCTATGGCACACCGCTTGGAAGCC +CGTGAGACCGCTCTGAACACTGGTGGGGAAGACCTGACCCGTATGCCTAGCGAGAACCGT +GTGTTCGACCGTGAGCACGCTGGCGTTGAGTATTCACCTCTGGAGACCGAGCCGGGTGCC +GTTGTGTTGCCTCAAGGTCAAATCCTGAGCGACACCAACCCACTGAACCCTCAGACTCTT +AGCGAGTTCGAGGCGGTCAACCCTGAGCGTGCCGCTCGTGGTATCTCTTTGGGTGGTTTC +ACTGAGATTGGCTTGAAGACTCTCCGCTCTGAGAACCCGACTGTTCGCTCCATTGCGAGT +GACCTTGTGCGTTCTCCGACAGGGATGGAATCAGGCTCTAATGGTAAGTTCGGTGCGACT +GCTTCTGACATTAAGGAGCGGCTCCACGCGAACAATCAGCGCACCTACAATCAGCTTTAT +GATGCTGTGCGTACTGCAATGAAAGACCCTGAGTTCTCCACAGGTGGTGCCACAATGAGC +CGTAAGGAAATCCGACAGGAAATCTACAAGCGTGCAGCCTTGGCGATTGAGCGACCTGAG +CTTCAAGCAAACCTGACAAAGGGTGAGCGGAACGTGATGAACATCCTCAAGCAGCACTTT +GACCTCAAACGTGAAATCATGGAGAACCCGTCAATCTTCGGCAACACCAAGGCGGTCAGT +ATCTTCCCCGGCTCACGCCACAAGGGAACCTACGTGCCAAACGTGTACGACCGCGCTATC +AAGATTGAGATGGTTAAACGTTACGATAATGATGGCTTGCAGCGAGCAATCGCGGAGTCA +TGGTTGACGTCTTATCGTGCTCGTCCAGAAGTCAAGGCGAGGGTCGATGAGTACCTGATG +GAACTTAACGGTCTCAAATCCGTGCAGGAAGTTACGCCTGAGATGGTGCAGAAGCACGCG +ATGGATAAGGCGTATGGTATTTCACACACTGACCAGTTCTCTGCCTCCTCTGTCATTGAG +GATAACATTGAGGGTCTGGTGGGTATCGAGAACAACAACTTCTTGGAAGCCCGTAACATG +TTCGACAGTGACATGGCGGTGACTCTCCCTGATGGTAACACGTTCTCTGTGAATGACCTG +CGTACCTATGACATGGCTGAAATTCTGCCTGCATACGACCGACGAGTAGATGGTGATGTT +GCAATCATGGGCGGTTCCGGTAAGACTACCAAAGACCTGAAAGATGAAATCATGGCGCTG +GATAAGCAGTCAGAGGGTAACGGCACACTGAAAGGTGAAGTGGAAGCTCTCAAGGACACC +GTGAAGATTCTGACTGGTCGTGCTCGTAGGAACCCGGAAGGCGCTTGGGGTACAGCCCTG +CGCTCCGTAAATGACCTCACGTTCTTTGCTAAGAACGCCTATATGGGCGCACAGAACGTT +ACTGAAATCGCTGGTATGCTGGCGAAGGGTAACGTCTCTGCGATAACTCATGGCATCCCT +ATGATTAACGATTGGGTCAACCGTGGTAAACCGCTTCGTGCCTCTGAGATTAAGGAGATA +CACGGGATGGTGTTCGGTAAGGAACTAGACCAACTAATCCGTCCGGGACGTGAAGACCAC +GTGCGCCGACTCCGGGAGTCTACGGACACCAGCGCTGCGGTTGCCAATGTGGTCGGTACG +ATTCGTTTCGGCACTCAAGAGTTGGCTGCACGCTCTCCTTGGACAATGCTCCTAAACGGA +ACATCAAACTACATTCTTGATGCTGCCCGTCAGGGTGTGCTTGGGGATGTGGCTGGAGCG +GCCCTTGCTGGGAAAGCCTCTAAGTTCGGTAAGGCAAACTACCTTAAGTCTGCCTCTATC +AGCCCTGAGCAGTGGAATGGAATCAAGCAGTTGTTCAGAGACCATGCGACTCGTAGAGAA +GACGGTAAGTTCACCATTCGTGACAAACAGGCTTTCTTTGGAGTCCTGTGAGGAAACCTT +GTGAGGTCGCAGTATAGTCTCATCCGCCACCTTGTCAGCCAGTCGCCACAAGTCCATTGA +ACGTGGGTCGTTAGCGCGTTCGGTGCAGGGGTGAAGATGGTGATGCAGTTTAAGAACTTC +GTCATCAAGTCCCTTAATTCCCGGTTCGTCCGTAGCTTCTGCGAGGCAACTAAGAACAAC +CGTGCGTTAGACCAAGCGTTGACTCATATCATCTCCTTGGGTCTAGCTGGTGGTTACTAC +GTTGCGCAGGCGCACCTTAAGGCCGCAAGCCTACAGGAGCACAAGCGTAAGGAGTACCTT +AAGAACGCACTTGACCCTAAGATGATTGCTCATGCGTCAATCTCTCGTAGTTGACACTTA +GGCTCACCATTGAGTATCTACGACATGTTCGCTGGGATGGTTGGTAGCGATACCTATAAG +TACACCCGCTCTACTGTGCTCCCTAAAGAGTCCGAGAAGCGTGACCCTAACAAGGCAATG +ACAGGTAGACAGGTGGCTTCAACTATCGCGGGTGCAGTTGGTGAGCAGGTTCCGGGGTTA +GGTTTTGTGGATTCTGTGGGTGCAACAGCAATTAACGCAGCTTCCCTGCTATCTTCTCCC +AACAAGGCAACCGCTCTGGAGTTCCGTACAGGCCTCTTCAACACCTCTCGTGAGTTGATT +CCTAATGACCCGCTATCGCAGCAACTCATTATGAAAATCTACGAGGCCAACGGTATCCGC +ATAAAGGAGACGCCGAAGAAACAATAAACCCTCACTAAAGGGAGAGAGGTCACATTCTGG +CCTCTTCTCTCTTAATGCTAATTTACAAAGGAGGTCACATGGCTACAACTATTAAGACCG +TGATGACTTACCCGCTGGATGGCTCCACTACGGACTTTAATATTCCGTTCGAGTATCTAG +CGCGTAAGTTCGTCAGAGTGACCCTTATCGGTGTTGACCGAAAGGAACTCATCTTGAATC +AGGACTACCGTTTTGCGACTAAGCCCACAATCTCCACAACGAGAGCATTGGGGCCAGATG +ACGGTTATAACATGATTGAAATCCGTCGATTTACCTCCGCTACCGATAGGCTGGTTGACT +TCACCGATGGTTCAATCCTTCGGGCATACGACCTGAACATCTCTCAGGTCCAAACCCTTC +ACGTTGCTGAGGAAGCACGTGACCTTACCGCTGATACTATTGGCGTTAACAATGATGGGA +ATTTGGATGCTCGTGGTCGCCGTATCGTTAACGTAGCTGACGGAGTTACTGATGGTGACG +CCATCTCTGTAGGTCAGGTTAAACGTATGAACCAGAACTCGTGGCAAGCACGTAATGAGT +CCTTGCAGTTCCGTAATGAAGCAGAAGGTTTCCGCAATCAGGCCTCTACGAGTAAACAGG +CTGCTGCTACCTCTGAGTCGCAATCATGGAATCATTCTGAGCGCTCTCGGACATTCGCTG +AGGCAGCTCAAGGTTCTGCTAACTCTGCGGGACAGTCAGCTACCAATGCGAACAACGCTA +TGCAGTCTGCTGGTCAATCAGCCACGGATGCTAGTAACTCTGCTGCTCAGGCTAAGGCCT +CTGAGGTTAACGCAAAGGCCTCTGAGGTTAACGCTAAGCGTGATGCTGACGCGGCCCTGC +TGGCTCTGCAATCCACTGGTAACGTACCTGTGGGTACAGTCGCCATGATTACCCACACCA +AGATTCCTACTGGTTGGGTGCGTGCTGGTGAGGACTTCGACGTTAATACTTACCCGCCGT +TAGCTGAACTGTTCCCTAGTGGTCGTACTCCTAGCTTCGATGACCGCTATCCTATTGGTA +ACTCTACCGTATTGACTCCGGGTCAGCTTATTGACCAATCAGTACCCGCCCACAGTCACA +CCTTCGACGTGCCTGTCAACGTGTCAGGTGCTACGGCTGCTGGTGGCGAATATCGCGCCA +GAACGTCACACGAAGGGGATCACAGTCATGGGTTCTCATTGCCTATCCAGAACAACACAG +GTGCTTATACTGGTCGTCTGGTTGGCGGTGGCAACAACCCTAACTACCCGCAAGACCTGC +GCTTTAACACTGGTGGCGGTGGTGCTCACAGTCATGAGTTCTATGTTCCTTCACACAGTC +ACACGTTGAATGCATCTGGGCGTGCTGCTGGCTCCGTCTCTTCGTCAGGTATTGGAAACT +CACCGTATGTCCGTCCGTATTCCACTGTGGTCATCTTCATCATCAAGGCCGCTCAAGGTG +TTGACGATAAGGACGCAGTAATGCAGGTGGTGGGCACTGTGGTTGAACGAGTGGACGCTC +TGGAGAACTGGCAGAAAAACTTCAAGTCCGTTGTTGAGAACGGTTCACCAACCTCTGGAA +ACGGCGGGCCTTGGGAACGTACTGTGTACACTGCCCAGACTGACTTCGGTCTCAACCGCT +GGCGCACGCTGAGTGGTTCGTCATGGGGAGAAGTAGTCAACTTACTTAATAGCTCCGGCG +TACTTAAAGGGTATCCGCAACGTCTTGTTGTTGACTTCACGGTTGAGGTAATCGATAGCT +CTGACCTAATCGCCAAGGCTGGTATATATAGTCCAATGATTATGGCCAGAATCGTGTATC +ACAACGGCACCAACTCTGGTGATATACTTCCCGCTGCCACCTCAAGCTCTGCGCACGCGA +CAAACGGGTGGAACATTAAGATGGCTACACGATTGTTGTATGGTACTGATGGCGGTCAAC +CAGTAGTTGAGATTGGTGCCTTCAAGGATGGTTCTGACCAGCAGACGGCAAACGTGCCAG +TTAAAGTAGGCTTGCGCCTCGTTCACGTGTTCTAAGGAGGACATAATGTTATCACTTGAT +TTCAACAACGAGGCCATTAAGGCTGCACCCATTGCGGGTGTGGCTGGTGCTGATGGTGTG +GCCCGCCTGTTCTGGGGGCTTTCTCTCAACGAATGGTTCTACGTTGCAGCTATCGCCTAC +ACAGTGGTTCAGATTGGTGCCAAGGTGGTCGATAAGATTATTGATTGGAAGAAAGCAAAT +AAGGAGTAACCTATGAGCGACAAGACTTTAATCAAGCTGCTGGAGATGCTGGACACGGAG +ATGGCACAGCGTATGCTTGCTGACCTCCAGAGCGAGGAACGCCGAACTCCGCAGCTTTAC +AACGCAATCGGCAAACTGTTAGACCGCCATAAGTTCCAAATCAGTAAGCTGACCCCGGAT +GAGAACATCCTTGGCGGTCTGGCGGCTGGTCTGGAAGACTACAACAAAGTGGTCGGCCCT +AATGGTCTGACTGATGATGAAACAATCACGCTACAGCAAGTGACATACTCAAGGTTCTCC +ACGCGGGGAGCCTTTATGGATGTTATTTGGTGCATCTATGTAAAATCTGAAAATTGATGG +GAGGTGTTATGCTAAAACTTTTACGCAGCGCACTCCCTTGGGTACTCGCCGGGACACTCT +TTATGGGTGGCTGGCACTTAGGGTCAACCCATGAGAGAGCAAACTGGAAGGAGGTAATCC +AAAATGAATACATTGCGAAAACAAAAGCAACCGCAGCAACTCAGGCAGAGGTCAGTCGGG +TATCCCGTGAGTACCAAGAAGAGATTGCAGCCATTGAAGGCAGCACTGATAGGATGCTTA +ATGACCTGCGTAGTAATAATATGCGGCTGTCAGTCCGCATCAAGACCCTTACCGGACTAC +CAGAAGATAACGGTAGATGCGAGTTTAATGGTCGAGCCGAACTACACGAGTCAGATGCTA +AGCGTATTATCGGAATAACCCAAGCTGCTGATGCTCACGTAAGGGCGCTCCAGCGTACTA +TTAAGGAGATGCAGAATGAGCGACACCCAAGCAAACCGTAATGCGCTAATCATCGCGCAG +CTTAAGGGCGACTTTGTTGCCTTCCTGTTCGTATTGTGGAAGGCTTTGGCTCTCCCGCCA +CCGACTAAGTGTCAGATTGATATGGCCCGGTGTCTGGCTAACGGAGACAACAAGAAGTTT +ATCCTACAGGCTTTCCGTGGTATCGGTAAGTCATTCATCACCTGTGCGTTCGTTGTGTGG +ACGTTATGGCGTGACCCTCAGTTGAAGATACTGATTGTCTCTGCATCCAAAGAACGTGCG +GACGCTAACTCCATCTTCATCAAGAACATCATTGACCTGCTGCCATTCTTGGCTGAGCTA +TAGCCTCGCCCCGGTCAGCGTGACTCTGTGATTAGTTTCGATGTTGGCCCTGCCAAGCCT +GACCACTCTCCGTCTGTGAAGTCGGTGGGTATCACTGGTCAGTTGACTGGTAGTCGTGCT +GATATCATCATAGCGGATGACGTTGTGATTCCGTCTAACTCCGCAACTCAAGGTGCCCGT +GAGAAGCTGTGGACTCTGGTGCAGGAATTTGCTGCGCTTCTGAAACCGCTGCCGACTTCT +CGCGTTATCTACCTTGGTACACCTCAAACCGAAATGACCTTGTACAAGGAACTCGAAGAT +AACCGTGGGTACACCACAATCATCTGGCCTGCGCTCTATCCGCGTAGCCGTGAGGAAGAC +TTGTACTATGGCGACCGTCTGGCCCCGATGCTCCGCGAAGAGTTCAACGATGGGTTCGAG +ATGCTCCAAGGTCAACCGACTGACCCCGTGCGCTTCGATATGGAAGACCTGCGTGAGCGT +GAGTTGGAATACGGTAAGGCTGGCTTCACTTTGCAGTTCATGCTCAACCCGAACCTGAGT +GATGCCGAGAAGTACCCCTTACGCCTCCGTGACGCTATCGTGTGCGGTCTGGACTTCGAG +AAAGCCCCAATGCATTACCAGTGGCTTCCGAACCGTCAGAATCGCAATGAAGAGCTTCCT +AACGTGGGACTTAAGGGTGATGATATTCATAGCTATCATTCGTGCAGCCAGAACACTGGA +CAGTACCAGCAACGCATCCTCGTGATTGACCCAAGTGGTCGCGGTAGGGATGAGACAGGT +TACGCAGTGTTGTTCACCCTGAATGGCTACATCTATCTGATGGAAGCTGGCGGGTTCCGC +GATGGTTACTCCGACAAGACCCTTGAGTCCCTCGCTAAGAAAGCGAAGCAGTGGAAGGTT +CAGACAGTGGTCTTCGAGAGTAACTTCGGGGATGGTATGTTTGGTAAGGTATTCAGCCCT +GTGCTCCTGAAACACCATGCAGCGCAACTTGAAGAGATTCGTGCTCGCGGTATGAAGGAA +CGACGCATTTGTGATACGCTGGAACCTGTACTCTCTACGCACCGCCTTGTGATTCGTGAC +GAGGTGATTCGTGAGGACTACCAGACTGCACGTGACGCTGATGGCAAGCATGACGTTCGC +TATTCGCTGTTCTACCAGTTGACCCGTATGGCTCGTGAGAAGGGCGCTGTGGCCCACGAT +GACCGACTTGATGCGTTAGCATTGGGTGTGGAGTTCTTACGCTCTACGATGGAACTGGAC +GCCGTGAAGGTGGAGGCTGAGGTGCTTGAGGCGTTCTTAGAGGAACACATGGAGCACCCA +ATCCATTCGGCTTGTCACGTAGTCACCTCTATGGTTGACGGTATGGAACTCTATTGGGAG +GATGACGATGTGAATAGCAATAGGTTCATTGACTGGTAGTTATGCATATTGAGTGCATAA +GGAATCATTGAGACCACGGATGGTCACTTTAAGAAACTCCTTAAGAATCAATGAGTTTGA +ATTAACCCTCACTAAAGGGAGAGAGGGGACTTAAAGCTACTATATAGGTTAGTCATTCAG +GTTATGCAATGACCCTTTATGCACTTTAAGTCGCCTCTATGATTGGTGATATTATCATTG +TATAATCACCCTACCTTAGAGCAACTGAAAGGAGGTGGCTCAATGTTACGCTTGCTGATT +GCCCTGCTGCGTCATAGAGTCACTTGGCGATTTCTTCTGGTACTTGCTGCTACCCTTGGG +TACGCAGGTCTTACTGACCACCTCGGTCAACTGGAAGTGGCCTTTTGCTCTATACTCTCT +TGTGGGGATTAAATTCTTGTTGATGAACGACAAGCGGCTCTGAGGGATTCGTAGGTATAG +TTTCACTACACCAACTCATCCCTGTAGAGTCAACCCTAAAGGTTATACCTAAAGATGCCC +TGTAGTTCGTAATGGTCTTACAGGGTCTTTAAGTGTCTCCTATGGTCTCACCTATGGTGT +GGCCTTACCTAAAGTGGTTGCCTAAAGAGACCTTTAAGAATTTACCACAAAAATCTGAAT +GGGTATCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAA +GCCAGCCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCT +ATAGGATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGA +GGCCTTAAAGAGTGTCCTAGTGTACCAGTTCGATAGTACATCTCTATGTGTCCCT +>NC_010807.alt2 length=40555 tani=98.985 alt=sn;du +TCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAAGCCAG +CCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCTATAGG +ATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGAGGCCT +TAATTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCTATAGGATAGCCTAAAG +TGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGAGGCCTTAAAGAGTGTC +CTAGTGTACCAGTTCGATAGTACATCGCTATGTGTCCCTATCTGTTAGCCTCATAAAGTA +AACCCTAAAGCCACTACCTAAAGACCAGACCTAAAGCCATCACCTAAAGGGCGACGCTAT +CTTAAAGACAACCAGACCGATAGACCCATTGTTAACCTGTAGTGATGCCCTGTAGTTATC +TGTAGTCATTTCATTAACCCTCACTAAAGGGAATAAGGGATACTTAAAGGGGGGAATTAG +GGATTTAATAAAAGATTAAAATTAATGGTTGACTTTAAGTAATCCTTAAGGCTATTATTC +ATCACGTCAACGGGACAACGGCCTTAAAGCCACTCCCTGAGATACCGGAGTCAACCGGAT +AAGTAGACAGCCTGATAAGTCATACGAAAAACAGGCATTGACAACGCAAGGTAACAAGTA +GTAAGATGCACAACATAGCGTCAACCACCAAGTCGGTGTCTTCTAGGTGACTTAAGCGCA +CCACGGCACATAAAGCTAAACAAAATGGTTGGCAACATGAAGTAAACACGGTACGATGTA +CCACGAAATGACAGAACAGTGAGGCGGGACACTGAAAGCCGCTAGGGTCTAACGAAACCA +GACCGACACGCAAATCATAGTAGGTTTAATAAGCGGTAAGTGTATTACTTCCCTTGTGTG +CCGCCGAATGGCATCAGTACACACGACAGGCAGTACGGAAAGTGACACGATGCAGTGCTG +CCATGATTTGATCGCTCTTTAACAATCTGGATAATAGCTCTTGAGTGTACCGATGTATAA +GCGAATAACTCAAGGTCGCACTGAAAGCGTGGCCTTTATGATATTCACTTAACACCAACT +AACATGAGGTAACACCAAATGATTTTCACTAAAGAGCCTGCTAACGTCTTCAATGTACTG +GTGTCAGCTTTCCGTTCTAACCTTGATGATGAGGTGAACATGAGCCGCCACCGCCACATG +GTAAGCACTTTACGTGCCGCACCGGGTCTTTATCGCTCCGTTGAGTCAGCCGATTTGACC +GGGTGCTAGCGTGAGAAAATCGCAAGCGCACCGACTGAGGAAAAAACGGTTCGTGTACGC +TGCAAGGACAAGGCGCAGGCGCTGAATGTTGCACGCTTAGCTTGCAATGAGTGGGAGCAA +GATTGCGTACTGGTATACAAATCACAGACTCACACTGCTGGTCTCGTGTACGCTAAAGGA +ATCGACGGTTACAAGGCTGAACGTCTGTCGGGTAGCTTCCAAGGAGTACCCAAAGGCGCA +CCGCTGCAAGGCTGCTTTACGATTGACGAGTTCGGTCGCCGCTGGCAGGTGGCCTAACAT +GAATCGTTATTACATCAACGTACCGGGCTGGGGTGGGTCTCTGACCTGCTACGGATACAA +CGAACGGGACGCACGGAAACGCTTTAGAGAACAACACGGCTTCGGAAGGCTTCCTAATGG +GACGCACCTATGGCTGGACTCCCGTGATTGGTAAGTGATAGACTCAAGGTCGCACTGTAT +GTGTGGCCTTTATGATTATCACCTATAGGACTAACACCATGAGTAAACTTCTGGCAACAT +CTAAAATAGAAGGCCAATGCACCGTAACACTGCGTGAGTATTACCACGGGTCAATGGGAA +GCACCTATGTTGTGCGATACGGTAAACAGGTCACACATTGGGTAAACCCGATTTTAGCAC +AAGAGGATTATCAAGCCTGTGTGATACACCAAGCAACATGTGCGGGCTGGAATGATTGAT +ATTACAGGAGGATTAGGAATGGTTATCTTTATCGCTGTCGCACTCTTTGCGGACGCTGGC +TGGTACTCTGAGTCACGCAAGGCCGCTCGCTATCATCGCAAGATGGTTAAACTCATGGAA +CACTTGGACGCAGAAGGGCGAGGCCGCGAGGCTATCGAACTGGCGAAACACGCATGATGA +TTCTCTCTATCGCACTGGTCTATCTGTGCATCGCAATGTACTTTATGCGAGACTTTAAGC +GCGGTCTGGCAATACACAAGGCAACGCTGAGTTACTTTAAGCGCGGTCTGGCAATACACA +AGGCAACGCTGAGTTACTTTAAGTGGGGATTCATCCCACGGTTTACGGTTCCTGAACGCA +ACGGACGCTTTAAGGCCAACAAGGTAGGAGTATTCTACATTGCTACGCACTAACTCAAAG +CACGTAAAGACCGCACTGTATGCGATGGCGTATGGTGCATCGAAACGCAAGGTCAAACGC +ATCTTAACGAGACACCGCAAGATGACCGGACGATAGGCTGCAAGCGCTGTCAAATGGGCT +GAATTTACTCTTTACTCTTCTTACAGATAACAGGACACTGAACGATGACTTTCACCGAAG +CACAAGCCGGACTCGAAGCTATCCGCAACCTACCGATTGAGCGCCTGAACGAACGCCAGC +CCATGCTGGTGGCTCTTGCGGCTGCTATCGTGAACGCTGAGACCCAAGACGGCGAACTGA +CGCAGGCCAAGGGTAACTGGGGTCTGGAGTCTATGGACTACTGGCAGACACTGGCTGAGC +GTATGCGTGATGTTGGATTTGTACGCTTGGGCAACGGTCACTTTAGCGCAGCATATGAGC +ACGCATTGTTACCGGGCAAGGTTATCAAGGTAGGCTTTAAGAAAGAGGATTCAGGCGCTG +CCTATGCCGCATTCTGCCTCTATGGACTACTGGCAGACACTGGCTGAGCGTATGCGTGAT +GTTGGATTTGTACGCTTGGGCAACGGTCACTTTAGCGCAGCATATGAGCACGCATTGTTA +CCGGGCAAGGTTATCAAGGTAGGCTTTAAGAAAGAGGATTCAGGCGCTGCCTATGCCGCA +TTCTGCCGTATGAATCAGGGTCGTGAGGGCATCCCTACGGTGTTCGACATTCAGCGTCAT +ACAGGCTGCTACACGGTGGTCTTGGACTATCTGACACCGCTTAATGAGTGGTGCTACGGT +GAAAGTGATAAGATTCGTCACCACTTTCAGGCTGCACAGGAAATCATTCAGGAGGATTGC +TTCGATACCGCCGAAGAGTACCCGATAAGCGAGGGCTTCATTGAGACCTGCAAGGATATC +CGCAAGTTCTTCTTAGGCATCGCATCGTTCTATTGTCACAGCGGGAACATGATGAAAGAC +CAGATGGGACGCCGGATAATCACAGACCCGGTATCATTCAGCGCAGACGACAAGTTAAAG +CCGGGTGAGTTCCACTGTGACCCGGATGAACTCATCGCTGAGATTGAGGCGCTGAGAGCG +CAGGAAGCGTTTGACCGCTGTAAGGCAGGCAAGGCACGCCGTGACCCTAAAGGAGACTTT +CAGGTAGCACGTAAAGCCCGTGCCAAGTGGCGCAGAAAGGCCTCTAAGCGCGAGTAGCGC +AACGCTAAGGTGATCGATAAGATGCGCATGGATGCTAATCAGAATCGCAGGGATGCGCCT +AGGGCGCGTATGGTGTGGGGCGATAAGCACTAGCGTAACGCTTGGATGCACCACAATAAC +CTAAACTTTGCAGAACTGGAGCGCCGCGCTTCTGCGGCAATGATGATGCATGACGAGGTG +CGCATTCAGTGAGGCAAACCGTTACACATAGACGCATACCTTGACAAGCGTCTACAAGGC +TGATAGAGTCCTATCTTACAGGTCATCAATCGGTGGCCTGAATAGGTACGATTTATTCAC +AATGAGGTAAGCAATGAACATCATCGAAAACATCGAAAAGAATGACTTCTCCGAAATCGA +ACTGGCTGCTATCCCGTTCAACACACTGGCAGACCACTACGGCAGCGCATTGGCTCGTGA +ATAACTGGCTTTAGAGCATGAGTCTTATGAGCTAGGCGAGCGCCGCTTCCTCAAGATGCT +TGAGCGTCAAGCGAAAGCTGGTGAGATTGCAGACAACGCAGCCGCTAAGCCATTACTCGC +TACGCTTCTCCCTAAGTTAACCGCACGCATCGTTGAGTGGCTCGAAGAGTACGCCTCGAA +GAAAGGCCGCAAGCCAGTAGCCTATGCACCGCTCCAGTTACTCAAGCCGGAAGCCTCCGC +GTTTATCACACTCAAGGTCATCCTTGCGTCACTGACCAGCACGAATATGACAACTATTCA +GGCCGCTGCTGGTATGCTGGGGAAGGCCATTGAGGATGAGGCACGTTTCGGTCGCATCCG +TGACCTCGAAGCGAAGCACGTCAAGAAGCACGTTGAGGAACAGCTTAACAAGCGCCACGG +GCAAGTCTACAAGAAAGGCTTTATGCCGGTGGTCGAGGCCGATATGATTGGTCGCGGGCT +GCTGGGAGGTGAGGCGTGGTCTAGCTGGGATAAAGAAACCACGATGCACGTAGGGATTCG +CCTGATTGAAATGCTGATTGAATCCACAGGTCTGGTGGAATTACAGCGCCACAACGCAGG +TAACGCAGGCTCTGACCATGAGGCATTGCAACTGGCCCAAGAGTACGTGGACGTATTAGC +GAAGCGTGCAGGCGCTCTGGCGGGTATCTCTCCGATGTTCCAGCCGTGTGTTGTACCGCC +GAAACCTTGGGTAGCAATCACCGAGGGCGGCTATTGGGCTAACGGTCGCAGACCTTTGGC +ACTCGTCCGCACGCCCTCTAAGAAGGGACTGATGCGCTATGAGGATGTTTACATGCCAGA +AGTTTACAAGGCGGTCAACATCGCACAGAACACCGCATGGAAAATCAACAAGAAAGTTCT +TGCGGTTGTCAATGAAATTGTTAACTGGAAGAATTGCCCGGTCGCAGACATTCCATCGCT +GGAGCGCCAAGAGTTACCGCCTAAGCCGGACGACATTGACACCAACGAGGCAGCACTCAA +GGAGTGGAAGAAAGCCGCCGCTGGTGTCTACCGCTTGGACAAGGCACGAGTGTCTCGCCG +TATCAGCTTAGAGTTCATGCTGGAGCAGGCCAACAAGTTCGCAAGCAAGAAAGCAATCTG +GTTCCCTTACAACATGGACTGGCGTGGTCGTGTGTACGCTGTGCCAATGTTCAACCCGCA +AGGAAACGACATGACCAAGGGGCTGCTGACCCTCGCTAAAGGCAAGCCAATCGGTGAGGA +AGGTTTCTACTGGCTGAAAAACCAGGGTGCGAACTGTGCGGGTGTCGATAAGGTACCTTT +CCCTGAGCACATCGCGTTCATTGAGAAGCACGTAGACTACATTCTGGCTTGCGCTAAAGA +CCCAATCAATAACACTTGGTGGGCTGAGCAGGATTCACCGTTCTGTTTCCTCGCGTTTTG +CTTCGAGTATGCAGGCGTTGAGCACCACGGTCTAAGCTACAATTGCTCTCTGCCGCTGAC +GTGCGATGGGTCTTGCTCCGGTATCCAGCACTTCTCCGCGATGCTCCGCGATGAGGTAGG +CGGTCGTGCGGTTAACCTGCTGCAAAGCGAAACCGTGCAGGACATTTACGGCATCGTTGC +ACAGAAAGTAAACGAGATTCTCAAACAGGATGCAATAAACGGCACACCTAATGAGATGAT +TACCGTGACCGACTAGGACACCGGGGAAATCTCTGAGAAGCTCAAGCTGGGAACCTCAAC +GCTGGCGCAACAGTGGCTGGCATATGGTGTAACCCGTAGCGTAACTAAACGTTCGGTCAT +GACGCTGGCTTACGGTTCCAAGGAGTTCGGCTTTCGTCAACAGGTTCTGGACGACACCAT +TCAGCCTGCGATTGACAGCGGTAAGGGCTTGATGTTCACCCAACCTAACCAAGCGGCTGG +TTATATGGCTAAGCTGATTTGGGACGCGGTGAGCGTGACCGTAGTCGCAGCGGTTGAGGC +GATGAACTGGCTCAAGTCTGCCGCTAAGCTGCTAGCTGCTGAGGTCAAGGATTGACAGCG +GTAAGGGCTTGATGTTCACCCAACCTAACCAAGCGGCTGGTTATATGGCTAAGCTGATTT +GGGACGCGGTGAGCGTGACCGTAGTCGCAGCGGTTGAGGCGATGAACTGGCTCAAGTCTG +CCGCTAAGCTGCTAGCTGCTGAGGTCAAGGACAAAAAGACCAAGGAGATTCTTCGCCACC +GTTGTTCGGTTCACTGGACTACGCCGGACGGATTCCCGGTCTGGCAGGAATACCGCAAGC +CACTCCAGAAGCGTCTCGATATGATTTTCTTAGGGCAATTCCGTCTGCAACCGACGATTA +ATACCCTCAAGGATTCAGGCATTGACGCACAAAAGCAGGAGTCTGGCATCGCTCCTAACT +TTGTTCACTCACAGGATGGTAGCCACCTCCGCATGACGGTCGTTTATGCTCACGAGAAGT +ATGCCATTGAGTCCTTTGCGCTAATCCATGACAGCTTTGGGACTATTCCGGCAGACGCTG +GTAAGCTCTTTAAGGCTGTGCGTGAAACGATGGTTCTCACCTACGAGAACAACGATGTGT +TGGCAGACTTCTACGACCAGTTTGCAGACCTGCTTCATGAGACCCAACTGGACAAGATGC +CACCACTTCCGAAGAAAGGTAAGCTGAACCTACAAGACATTCTCAAGTCCGACTTTGCCT +TTGCATAACAAGCACTTAGCATTAACCCTCACTAACGGGAGACTACTTAAGGTCTCCCTT +AAGGTACTAAGAGATTTTAATTTAAGATAACTAAGAGGTTTACTTTATGATTACTTTATG +TGTCGCAATCGTTCTTATCGCTACACTCTTGCATAACAAGCACTTAGCATTAACCCTCAC +TAACGGGAGACTACTTAAGGTCTCCCTTAAGGTACTAAGAGATTTTAATTTAAGATAACT +AAGAGGTTTACTTTATGATTACTTTATGTGTCGCAATCGTTCTTATCGCTACACTCTCAA +TCGTCATCGCTAAGCAGCGCTCTGAGTTAATCAAGCTGGATGCCCGATATGATAGTGCGA +ACCACCACCGGAAAGAACTGGATGCAGCACTTGGGCGGTCAACCGATGAGGTTAAGACCC +TTAAGCGCCAGCTACAGCACGCCGAGCAAGACGATAAGAACCGCTGCGAAACAATCCGAG +GTCTACGTGAAGAACTCCGGGAGTTGCGCCAGACGATTAAAGAGCGCCACGCTATCCACG +GCATCAAGTTCGTAGCGAACGTTCCGATGAAGGGCTGGACGCCCACCGAGTTTAAGCTGG +GTCTTGGTAAATGCGGTCTGGAAGTGGCGAGTCTAGTGTGGGAAGAGAAGTCTGACCGCT +ATGTGTTGACTCAACGCCACACCGACGGAAGCCGAAAGGTCTTTGAGTACAAGAAGGAAG +ACGTGCAAGGAAGAATCGAAGTGTTCTACCCTGCCGTTAAATAACCCTCACTAACGGGAG +AGTTAGCCTCAAGGTCATCACCGACGGTGGCCTTTGTGATTAACTTTCAATACACATCAA +CATGAGGTAAGATACTATGCGTACCAACTTTGAGAAATTTACCAAGCGCGATTCAGTGGT +CAACGAGCATGGCGAACAGTGGCAAGAGCGCCGTGACCGCATGAAGAAACGCCACAAGCA +ACAGCGCGGTAACTCACAGAAACGGGAGTAGAACTAATGATGATGGGACGTGTCTATAGC +GGCAACCTGAACGATTACAAAGATGCCGTAGCGCGTCTACGGGAAGACCATGACGTGCCC +GTGAAGGTGGAGTCATTCAGCTATGAAAACCCAGCGAAGATGTGCAGGTCATCCGGTGAG +GTTCTCCGTGTGTTCACACGCTCCGGGCATCCGGTCGCATCCAGAACCTTCGAGCACAGC +GACAGTGATGTACAAATCAACGCGCAGACTGCATGGCTCCGTAAGGTTCACAGCGATTTG +AAACACTGGAAGTAATAACCCTCACTAACAGGAGAATCCTCAAGGTCATTTTAATTGGTG +GCCTTTGTGATTCGAACTGATTAACTTTCAACCAATGAGGAACAACCGTATGAACATCTT +CAAGACCAACCCATTCAAAGCTGTGTCATTCGTAGAGTCTGCCGTTAAGAAAGCGCTGGA +GACCTCCGGCTACCTGATTGCGGACATTAAGTATGATGGCGTGCGTGGTAACATTGTGGT +TGACAACGTGGCTGAGGCCGCATGGCTGTCCCGTGTGTCCAAGTTCATCCCGGCGCTGGA +ACATCTGAACGGTTTCGATAAGCGCTGGCAACAACTGATGAATGATGACCGCTGTATTTT +CCCTGATGGCTTCATGCTGGATGGCGAACTGATGGTTAAGGGCGTAGACTTCAACACAGG +GTCTGGCCTACTGAGAACCAAGTGGCTCAAGAAGAACAACTTCATGTTTGACCGTGGTGC +TTCATGCTGGATGGCGAACTGATGGTTAAGGGCGTAGACTTCAACACAGGGTCTGGCCTA +CTGAGAACCAAGTGGCTCAAGAAGAACAACTTCATGTTTGACCGTGGTGGTGTTGAGCCA +CTGAAAGGTTCCAAAGTAGCCTTTGAGTTAGACCCCAAGCTACTCAGTGTTCGCCTGTAT +GCTGTCCTTCCGATTCACATTGCGGCGTCTGGCGAGGACTACGATGTACAGAACCTACTG +ATGCCATATCATGTGGAGGCCATGCGCTCTCTTCTGGTTGGATACTTCCCGGAAATCGAG +TGGCTTATCGCTGAGACCTACGAGGTCTACGATATGGATTCGCTGAATGAACTGTACGAA +GAGAAGCGTGCCGAAGGTCACGAGGGTCTCATTGTGATAGACCCACAGGGCATCTACAAG +CGAGGCAAGAAGTCTGGCTGGTGGAAGCTCAAGCCTGAGTGTGAGGCTGATGGTATCATT +CAGGGTGTCAATTGGGGAACCGAAGGTTTAGCCAACGAGGGCAAAGTGATAGGCTTTAGT +GTGCTTCTTGAGACTGGTCGTTTAGTAGACGCCAACAACATCTCTCGCGCACTGATGGAC +GAGTTCACAGCCAACCTTAAGGCACACGGCGAAGACTTCTACAACGGGTGGGCCTGTCAG +GTCAACTAAATGGAAGAGACCCCGGACGGCTCCCTGCGTCACCCTAGCTTCGAAAAGTTC +CGAGGCACTGAGGACAACCCTCAAGAGAAAACGTAACCAACTCACTGGCTCACCTTCACG +GGTGGGCCTTTCTTCGTTCTAGGGAATTAACCCTCACTAACAGGAGACACACCATGTGAC +TTATCCTATTCGCTATCGTCGCAACGCTGGGATTAATGGTTGCCGACGACGACATTTGGC +CTGATTCTTAAGGAGACAACATCATGCGTTTACACTTCAACACATCAAATGGTATCTTTT +CGGTTCGCCGTGAAGACCGCTCTACAGCAGTGGCCTCTGAGCGCAACGCTAAGCTGCCGC +TGATTGGCTCGGTCGTCCCATTGTCGCCTCGTGTTCACCTACTGATCACTCGTGGAGAGT +TCATTAAGGCGATGAACAAAGAGCGCCCGCATCTGGAAGCCGTTGTCACTTGCTGGCCTC +GCATCCGTCTGTTCGTTAAGTGGATTAAGGAGGTTCTGTAATGTTACAACATCATTGGAA +CAAACCAGATTTAGAGGCTCGCTTCCCGGTTAACTCTGCTGTGCGATACTCCGGCGACTT +CCTCAAGCGCTTCTTAGGTATGAGCGGAGTGGTCACCGGTCACTCGAACACAGGTCGCGT +TAAGGTTCGCTTCGGTAATCAGCACGCTGAGTTTCTTCCGAACAACCTGATTCCGCTGCC +TAAAGATGACGTTAAGACTCCGAACATGGAGGCACCGAAGTCAGAAGTCAAGTCTGACGT +AACCCACCCTAACCACTACATGCTGTTCGACAACGTGGAAGCCATTGAGGTTATAGCCCG +GTCAATGACCGTCGAGGCGTTCCGTGGGTACTGCCTTGGGAACATCCTGAAATACCGTCT +TCGTGCTGGTAAGAAATCCGAACTGGCAACTATGGAGAAAAACCTCAATAAAGCTGCATT +CTATCAGGAACTCTTTGACAAACATAAGGGGCTGTGCTATGACGCTTCGTGAATGCTGCG +ATTGGTGTGCCGCTAAGTGGAACCAAGGTATTGAGGATGGTGACAAGGCGGCTGCTGACG +CTTACCAACAACTGTACGCGCTGTGGGAGCGGCGCTTTAAGGAGGCTCAAAGTGGAGCAA +CGTGAACAGAAATACCTTGTGACGATAGAAGGCAACACCGAGTCCTTTGAGGTTCCGGTA +TTCGCCCGGTCTCTCGAAGAGGCAACGCTACAGGCTGAACATTATAAGGACGCTGGGTTC +GTAGTGACTCGCATCCGTCCAGAAGTGAAAGCCTAATTACCCTCACTAAAGGGAACAACC +AAATCATTAACCACAAAGGAGAAACATTATGGCTGGTTTCAAGAAGAAAATCTACCCCTC +TGGTCTTGGCACTGCTGAGCCTTATGCTTACCTGAGTAAGCCGGATTATGGCAACGCAGA +GCGTGGCTTCGGCAACCCTCGTGGTGTCTATAGGGTAGACCTGACTCTTTCCAATAAAGA +CCTGCGCTGTCAGGCGGTGGTCGACGAAATCGTGAAGACTCACGAAGAGGCTTATGCTGC +TGCCGTGGAAGAGTTCGAAGCTAACCCGCCGCAGGTACAGCGTGGTAAGAAACCACTGAA +ACCTTACGAGGGCGACATGCCGTTCTTCGATAACGGTGACGGTACGACTACCTTCAAGTT +CAAATGCTATGCGTCTTTCCAAGATAAGAAGACCAAAGAGACCTAGCACATCAATCTGGT +CGTGGTCGATAGCAAAGGTAAGAAGATTCAGGAAGTGCCGATTATCGGTGGCGGCTCCAA +GCTGAAAGTGAAATTCTCTCTGGTTCCGTACAAGTGGAACACCGCTGCGGGCGCAAGCGT +CAAGCTGCAACTGGAGTCCGTGATGCTGGTCGAACTGGCTACCTTCGGCGGTGGCGGTGA +AGATGAGTGGGCTGATGAAGTCGAAGATGGTGGTTACACTGCGAGTGAATCCCGTCAGTC +CCGCGATGAGCAGGAGTGGCAGGAAGACGAGCACGAAGAAACCCCGGATGATAACGAGGA +CTTCTAATGGCTGGCGCATACGCTGCGCGAGGTGTACGCAAGGTCGGGGCTTTCCGCTCC +GGCCTAGAAGATAAAGTCTCAAAGCAGCTTGAGAGTAAGGGAATTAAGTTCGACTATGAG +CTTTGGCGTATCCCTTACGTCATCCCTGCGAGTGACCACTTATACACTCCAGACTTCCTG +CTACCTAATGGCATATTCATTGAGACCAAAGGGCTGTGAGATTCCGATGACCGCAAGAAA +CACCTTTTGATTCGTGAGCAACACCCTGAACTGGATATTCGCTTGGTCTTCTCAAGCAGC +CGCTCAAAGCTCTACAAAGGCAGCCCAACAAGCTACGCCGAGTGGTGTGCGAAGCATGGC +ATTCTGTCTGCTGACAAGCTAATTCCGGTGGAGTGGCTCAAAGAACCCAAGAAGGAGGTT +CTGTTCGATAAATGTAAGACTAAGAAAGGAGTAAAGAAAAATGGCTAAAGTTCAATTCAA +ACCACGAGAAACCACGGAGGCAATCTTTGTACATTGCTCAGCAACCAAGCCAAGCCAGAA +CATTGGCGTTCGTGAGATTCGTCAGTGACACAAAGAGCAGGGCTGGTTAGACGTAGGATA +TCACTTCATCATCAAGCGTGATGGCACTGTGGAAGCAGGCCGCGATGAACGGGCTGTAGG +TTCCCACGTGAAAGGTTACAACCACAACTCCGTAGGCGTATGCCTCGTGGGTGGGATTGA +TGATAAAGGCAAGTTCGACGCCAACTTTACACCTGCGCAAATGCAAGCGCTGCGTAGTCT +GCTGGTCACGCTGCTGGCGAAGTATGAGGGTTAAGTCCTTCGTGCTCACCATGACGTTGC +ATCCAAAGCCTGCCCGTCCTTCGACTTGAAGCGCTGTTGGGAGAAGAACGAACTGGTTAC +ATCTGACCGAGGGTGATACCATGAGGATAATTTGTATTCGCTGTGATAAGCCGTTGAAGA +GTCGTGTACCGTCAGGTCAGTGTCAGTGCAAAGACCCAATCAAGGCGGAGGAACGCACCG +AGGAATAATTAACACTCACTAAAGGGAGACTTAACGGTTTCCCTTTGTTCGCACTATTGA +TTAAGGAATGTACAATGGAACGAGAAGACGATAGTATCTTTCTGTTTCATGCTCCATGTG +AAAGCTGTGGGTCTTCTGATGGTAACTCTGTGTACTCTGACGGGCATGAATGGTGCTTCG +TGTGTGAACATCGAGTACCCGCAAACGAAGAGCGTGACGCAAAGTTATCAATGAGAAGAC +GTACAGGAGGCAGCAAGCCTATGAGCTATGACGTATGGAATTTCGGTGACAGCAACGGCC +GATACTCTGACCTGACTGCCCGTGGCATCTCGAAGGAGACATGCCAAAAGGCTGGCTACT +GGCTGGCGAAAGTGGACAACCGAATGTATCAGGGTGCCTACTACCGAGACCAGAACGGCT +CCATCGTGTCGCAGAAGGTGCGCGATAAGGACAAGAACTTTAAGACCACCGGAAGCCACA +AGAGCGATGCGCTGTTCTTGAAGCACCTCTGGTCTGGCAGTAAGAAAATTGTGGTCACTG +AGGGCGAAATTGATGCGCTCACTGTGATGGAACTCCAAGACTGTAAGTACCCGGTCGTAT +CATTAGGTCACGGTGCCTCTGCTGCTAAGAAGACATGCGCCGCTTACTATGAATACTTTG +ACCAGTTCGAGCAGATTATCTTGATGTTCGACATGGATGACGCAGGCCGTAAGGCAGTCG +AAGAGGCGGCACAGGGTCTCCCGGCTGGTAAGGTTCGTGTTGCCGTGTTGCCGTGTAAGG +ACGCCAACGAGTGTCACATCATGGGTGAAGACAAAGCAATCTTGGAGCAAATCTGGAACG +CGAACCCTTGGGTGCCTGACGGTTTTGTTTCTGCGTTGTCACTCAAAGACCGCATTAAGG +AAGCTATGACCTCCGAGCACGCTGTAGGTTTATTATTCGATGGCTATCAAGGCCTGAACG +ATAGAACCTTGGGTGCTCGTGGTGGCGAAGTCGTTATGGTCACTTCCGGTTCCGGTATGG +GTAAGTCAACGTTCGTTCGTTAACAGGCTCTGGCTTGGGGCAAGCGAATGGGTAAACTTG +TGGGCCTAGCGATGTTGGAGGAATCCGTTGAGGATACCATTCAGGACATGATGGGCTTGA +ACAATAAGGTTCGTCTGCGTCAGTCTGATGAAGTCAAGAAGGCTATCGCAGAGGACGGAC +GTTTCGATGAATGGTATGATGAACTATTTGGAGACGATACGTTCCACCTCTATGACTCCT +TTGCGGAGGCCGAAGCTGACAGGCTGTTAGCGAAGCTGGCCTACATGCGAACAGGCTTAG +GGTGTGATGTTATAGTGCTCGACCGCATATCGATCGTCGTGTCTGCCTCTGAGGAATCGG +ATGTGAGTAAGATGATTGACCGCCTCATGACGAAGCTCAAAGGGTTCGCTAAGTCAACTG +GTGTTGTGCTCGTAGTGATTTGTCACTTGAAGAACCCGGAGAAGGGAAAACCACATGAAG +AAGGACGCGCTGTTTCTATTACTGACCTACGTGGTACCGGTGCCTTGCGTCAGTTATCTG +ATACTATCATCGCCTTGGAGCGTAACCAGCAAGGTGATATGCCTAACTTGGTGTTGGTTC +GCCTGCTTAAGTGTCGTTTCACTGGCGACACTGGAATTGCTGGGTACATGGAATACAACA +GAGAAACCGGGTGGCTTGAACCGTCTAGCTACACTGGCGAAGAAGGAGAAGGAGATACTG +GCTGGTCTGAACAAGACGGACAATCAGACTTCTAAAGGATGCCCGTGTGGGCATTCAGAT +TGCGATGGAACCATGTACCACTAATTAAACCTCACTAACGGGAACAACCATTAAACCATA +GGAGACACATCATGTTTAAATTCATTAACGCTTTAGGTAAGCTGGTAGTTAAACTGTACT +TCATCGAAGCCAAGAAGCTGGACAAGAAGGCCAAAGCTGATTCACAGCGAGCCATTGAGT +TGGCGAAACAGTCCCGTGAGAAATCCGATGCGGCTGTTAGTGGCATCCACAAGTCGGCAG +CGATTGCAGCCAAAGCACAATCCATGAGCAAATTCTTTGAGTAAGGAGCACACACTATGA +GCAAGTCAATCACCCACGCAAACACCATCCGTCTGCCAGACACCGCTGACCAGTTCTCCC +GCCGAGTACACATAAATGTGCGTGGTGAGAAGGTCACGATGGTCTACCGCTGGAAAGACC +ACAAGTCTCCGAAAGCACACACTCAACGAATGACCTTGGATGACAAGCAGGTCGGTCGCT +TGATGGGTGCCCTGACTATGGCTGCTGACAAGGTGGTCGGTGATAACCGTGAGCGTCTGG +TAGAGTTCGGCGCTGGTATGCAAGAGATTATCGAGAAGTGATAAACTCAAGATCGCCCAA +GGGTGGCCTTTATGATTATCATTTAGCACGAAACCAAAGGAGGGCATTATGCTCGTAAGT +GACATTGAGGCCAGCAACCTCTTAGAGAAAGTCACCAAGTTTCACTGTGGCGTTATCTAT +GACTACCGTGATGGTGAGTATCATAGCTATCGTCCGGGCGACTTCGGGGCGTATCTGGAT +GCGCTGGAAGCCGAGGTGAAGCGAGGTGGGCTTATTGTTTTCCATAACGGTCACAAGTAT +GACGTTCCGGCTTTAGAGAAACTCGCAAAGCTGCAACTCAATCGTGACTTCAAGTTACCC +CGTGAGAACTGTATTGATACATTGGTACTCTCGCGTTTACTTCATGCGAACCTTAAAGAC +ACAGACATGGGGCTTCTTCGCTCCGGGAAACTACCCGGTCGTCGCTTCGGGTCTCACGCT +CTCTCGCGTTTACTTCATGCGAACCTTAAAGACACAGACATGGGGCTTCTTCGCTCCGGG +AAACTACCCGGTCGTCGCTTCGGGTCTCACGCTCTGGGGGCATGGGGCCATCGCTTGGGT +GAGATGAAAGGTGAATACAAGGACGACTTCAAGGCTATGCTGGAAGAGCAGGGCGAAGAA +TATGTTGATGGTGCTGAGTGGGTTTCGTTCAACGAGCCGATGATGGCGTATAACGTTCAA +GACGTTGTGGTCACTGTCAAACTCTTAGAGAAATTCCTTACAGACCTCCAATACTTCCCT +GCGGGTATGGACTTCACGAAGTACGATGCGGATTTATTCTGGCGAGAAGCTGGCGAGCCT +GTGGATATTGAACATCGTGTAGCGTGGCTTTTAGCGAAGCAGGAGCGTAACGGCTTCCCG +TTCAACACCAAGGCAATTGAGGAACTTTATGTAGAACTGGCAGCGAAACGCGCCGAACTT +CTGCAAAAGCTAACCGAAACGTTTGGCTCATGGTATCAACCGAAAGGCGGTAAGGAACTC +TTCAAGCACCCACGGACAGGCAAGCCGCTGCCGAGCTATCCTCGCGTGGTCTATCCGAAA +CAGGGTGGCGTGTACAAGAAGCCTCGTAATAAGGCACAGCGCGAAGGTCTTGAACCTTGC +GACTTGGACACGAGGGATTACATGGAGGGTGCTCCATATACTCCGGTAGAGTTCGTTACG +TTCAAGCCAAGTAGCCGTGACCACATTCAGAAGAAACTACAAGAGGCCGGATGGGTTCCT +GAGAAGTTCACCGAGAAGGGTGCGCCTGTGGTGGACGATGAGGTCTTGGAGCATGTAAGA +GTGGATGACCCTGAGAAGCAGGCGTGCATTGACTTGATTAAAGAGTACCTGATGATTCAG +AAGCGAATCGGTCAGGCGGCAGAGGGTGACAAAGCGTGGTTACGTTATGTTCAAGATGAT +GGTAAGATTCATGGAGCCGTTAACCCTAACGGTGCAGTTACTAGTCGTGCTACTCATAGT +TTCCCAAACCTTGCACAAGTACCCGGCGTTCGTTCTCCTTACGGGGAGCAGTGTCGTAGC +GCTTTTGGTGCTGAACATCATTTGGATGGGATTACTGGCAAGCCGTGGGTGCAAGCGGGG +ATAGACGCCAGTGGCTTAGAGTTGCGCTGTCTGGCACACCTCATGGCTCGTTTCGATAAC +GGAGAGTATGCGAATGAGATTCTCAACGGTGACATTCACACCAAGAACCAGAACGCTGCG +GAACTCCCAACGCGTGACAACGCCAAGACCTTCATTTACGGGTTCCTTTACGGAGCAGGA +GATGAGAAGATTGGTCAGATTGTTGGGGCAGGGAAGGAGCGCGGGAAGGAACTAAAGAAG +AAATTCTTAGAGAACACCCCGGCGATTGCAGCGCTACGAGAAGCTATCCAACAGTCTCTC +GTTAAGTCTTCCGCTTGGATTGGCGCTGAGCAGAAAGTACAGTGGAAGCGCCGTTGGATT +AAAGGTCTGGATGGTCGCAAGGTTCACGTCAGGTCTCCACACGCAGCGCTCAACACATTG +TTGCAGTCTGCTGGTGCTCTGATTTGTAAGTTGTGGATCATCAGGACCGAAGAGATGCTC +ATTGAGAAAGGCTTGAAGCATGGCTGGGATGGTGACTTTGCGTAAATGGCTTGGGTTCAC +GTTGAGATTCAGGTGGCCTGCCGTACAGAGCACATCGCTCAGATTGTTATTGACACCGCG +CAGGAAGCTATGCGTTGGGTCGGAGAGCATTGGGCTTTCCGTTGTCGTTTAGATACCGAT +GGTAAGATGGGGCCGAATTGGGCTGTCTGCCACTAACAATAGGAGAAACATTATGGCAAT +GACCAAACACTTTAAAGTAACCTTCGACGTTACCGCTGTGATTGACAGTGAATCCGAGAA +GAATCTGAACGAGTTGCTGGTAGACCTAGCTAAGAAGGCCGGGGCTGGCGAGAAGCTGAA +TCCGTTCAAACAAGAACTGCTTATTCAAGGCCTGACACACGGGCCGGAAGGTGCTGCTGC +GTTCTGTATCAAGCAAGGTCTCCGTGAGTTTATCCGCGATGGTCACAGTGAGTTAAGCTC +TACCGAGCGAAGGCCGGGGCTGGCGAGAAGCTGAATCCGTTCAAACAAGAACTGCTTATT +CAAGGCCTGACACACGGGCCGGAAGGTGCTGCTGCGTTCTGTATCAAGCAAGGTCTCCGT +GAGTTTATCCGCGATGGTCACAGTGAGTTAAGCTCTACCGAGCAGAAGCTGATGAGATTC +TCACCTGCAACTGTGCGAGAGGTGTTCAAAGGAGTGAATACCTGAAAGTTCTGGCAGCTA +TCAAAGGTTGCCCTAAGTCCTTTCAGTCGAACTATGTGCGAAACAATGCGGCTCTCGTAG +CTGAGGCCGCTTCTCGTGGACACATTAGCTGTTTGACTGTGGGCGGTCACAATGGTGGAG +CATGGGAGGTAACAGCCTCTGGTGTGCGCTTCTTGAAACGAATGGGAGGTTGCGTATGAT +TATGCCTAAGAGTGACACCGTAACGATGACCCGTGATGCGTGGAACGATGTTAGCGCGTA +CATTGATAAGATGGAGAAAGGCCTAGAGTTCCTGAATGCGCTTAAGGCGTGTGGTGTGGA +TAATTGGGACGGATACTCTGATGCAGTCGAAATGGTTTACGGGGAGGATGACGAATGAGC +CTAATCATATTGAAAGACTTCGCGGAGATGCGTGAAGGTAATCCTATGGAGAAGGGAGTG +CTGGTCATGGATGGTGACTGGTTGGTATATCAGTCAATGGCTGCTGCCGAAGTTGAGACG +GATTGGGGAGACGACATTTGGACTCTTGAGTGTGACCACGCCAAGGCACGGAGCATTCTC +GATTCTGCAATCGAATCGTACCGAACCCGTAAGAAGGCTTGGAGTGACGCTATGGTTGTT +CTGGCATATACCGACGATGTGAACTGGCGTAAGGTACTGGTTGATGAGACCTATAAGGAG +AACCGTAAGGCGACCCGTAAGCCTGTGGGCTACCGTGACTTCCTGTCGAAGCTGTGGGAG +CGCGATGAGTTCATTCACATTAAAGAGGACATGCTAGAAGGTGATGACGTTATGGGTATC +ATTGGGTCTGGTCACGAGGTCTTCGGCTTCAAGAAAGCTGTGTTGGTTTCCTGTGATAAG +GACTTCAAGACTATACCGGACGTTGACTTCCTGTGGTGTACCACTGGTAACATCTTGACG +CAGACCAAAGAGACCGCTGATTGGTGGCATCTCTTCCAGACTATCAAGGGCGATATGACT +GATGGCTACTCCGGGATTCCCGGTTGGGGTGACACGGCAGAAGGTTTCCTGAATGACCCG +TTCATTGTGGAGCCTGTAGAGTCCGTGCTGAAGTCCGGTAAGAACAAAGGGCAGACTGTC +ACTAAGTGGGTGAAACGCGCTCCTGATGCGACTGAGAGCCTGTGGGACTGCATCGTATCC +ATCGGTGCCAAAGCTGGGATGACTGAACAGGAAATCATTAAGCAAGGCCAGATGGCACGC +ATACTTCGCTTCGAGGAATACAATTACATTGACAAGGAGATTTACTTATGGACGCCGCGA +AGCTGATTACCATCGCTGTGCTGGTAGGTATGCTGGCGCGAGGTCTCTGGATGTTCGCTC +TCATAGTCCGAGACGCGAAGCGAGACTCCGAGATTAAGTGATACACTCATGGCTCTCTGT +ATTAACCGTCATTAAAGGGAAGAGGGAGCCTTTATGATTATTACTTTAAGACTTAACCTT +AAGAGGTGAATTTATGTTACAACCAATTAATCATGTTTTAACTCATCCCGATGATATTCC +TAGTATGCCGCGTGCAGCAAGAGAGTATCTACAGGTGCGCTTCAATCAGGCTTATGTGAC +GGAGTCCGGGGAGTACCGTGCGCTGCGCGCTGCTGGTTACTCTGAGTCTTTCATTGCGGG +TGTGATGCATGGTCTGTACCTTGCCTCTCGAACACTTGATGAGATTCAGGTGCGTAAAGA +GCAACTGAGACAGGAGCAACGATATGTGCTGGAAACCGAAGGTGAAAGTCCCTAAGATGG +ACACTAACCAGATTCGCGCTGCTGAACCAGCACCTTTGACTGAACCTCCGAAGTCTGTGG +TATGGGGAGGCGATGATGACGAGGGCACCAGTGTGTCTTCCTCTGAGGTGCCAACCACAC +CGAGCAGCGGTAAGAGCAGTCTCAAGGTAAAGCTGGATGACAGCGCAGCCAAGAACAAGA +GTAAATCCTCCATTCGCTCCAAGGCGTTTGGGTAACTGAGTCGTAGCATAGGGAGAAACA +TCATGGGATTCTTCAAGAAAATCAAGAAGGCCGTTAAGAAAGTTGTGAAAGAAGTTAGTA +GACCAGTCGAGAAGGCCGGTAAGGAAGTGGGCAAGGTGGTTGGAGGCGCGCTGGGTGCAA +GTAAGCAGGAGATTATCCAACAAGAGCCTCCTGTACCAGTAGTCGCTGCACCGCCACCAT +CACAGGTTGTAGATGTACCGGAACAGGATAAGGCTGAGGGTGAGGATGAGGCGCAAACCG +AACGCGCACGTAAGAAAGCACGCGCTGGCGGTAAGAAGTCTCTGAGTGTAGCCCGTAGCT +CCGGCGGTGGCATCAACATCTAAGGAGGACTGAATGGCTTATTCAAAACGTACAGGATTG +GGCGAAGACGGTGCTAAAGCTACCTATGACCGCCTAACGAACGACCGTAGAGCCTACGAG +ACTCGTGCGGAAAACTGTGCGCAATACACCATTCCGTCCTGGTTCCCGAAGGAGTCCGAT +AACGAATCTACCGACTACACGACTCCGTGGCAGGCTGTAGGTGCGCGGGGTCTTAACTAT +CTGGCCTCTAAATTAATGCTGGCACTATTCCCGATGCAGTCGTGGATGAAGCTGACCATT +AGTGAATAAGAGGCGAAGCAGCTTGTTGGAGACCCTGATGGACTCGCTAAGGTGGACGAA +GGTCTGTCTATGGATGAGCGTACTATCATGAATTATATCGAATCCAGCAGCTACCGTCTG +ACACTCTTTGAGTGCCTCAAGCAGTTGATCGTGGCAGGTAATGCACTGCTTTACTTACCG +GAACCAGAAGGCAGCTACAATCCGATGAAGCTGTACCGATTGTCTTCTTATGTTGTCCAA +AGAGACGCATACGGCAATGTGTTACAGATTGTCACTCGTGACCAGATAGCCTTTGGTGCT +CTCCCGGTAGACGCTCGGTCTGCGGTAGAGAAAGCTGGTGGTGAGAAGAAGATGGACGGA +ATGGTCGATGTGTACACCCATGTGTATCTCGATGAAGAGTCCGGCGATTACCTCAAGTAC +GAGGAAGTAGAGGACGTTGAGATTGATGGCTCCGATGCCACCTATCCTACTGACGCTATG +CCCTACATTCCGGTTCGCATGGTTCGCATTGATGGCGAGTCTTACGGTCGCTCCTACTGT +GAAGAATACTTAGGTGACTTAAGGTCGCTTGAGAATCTCCAAGAGGCTATCGTTAAGATG +AGCATGATTAGCGCGAAGGTCATCGGTCTGGTGAACCCGGCTGGCATTACGCAGCCACGT +AGATTAACCAAAGCTCAGACTGGTGACTTCGTTCCGAGTCGTCGAGAAGACATTGACTTC +CTTCAACTGGAGAAGCAAGCTGACTTTACCGTAGCGAAAGCTGTGAGTGACCAGATAGAA +GCACGCTTATCGTATGCCTTTATGTTGAACTTTGCGGTGCAACGAACAGGTGAACGTGTG +ACCGCCGAAGAGATTCGATACGTTGCGTCAGAACTGGAAGATACGCTTGGTGGCGTCTAT +TCGATTCTGTCTCAAGAACTGTAATTGCCTCTGGTTCGTGTGCTCTTGAAGCAGCTCCAA +GCAACCTCGCAGATTCCTGAGCTTCCGAAAGAAGCCGGTGAGCCGACTATCAGTACAGGT +CTGGAAGCAATCGGTCGTGGTCAAGACCTCGATAAGCTGGAGCGCCGTATCTCCACTTGG +GCTGCTCTGGCCCCTATGCAGGGAGACCCGGACATTAACCTTGCTGTCATTAAGCTGCGC +ATTGCTAACGCCATTGGTATTGATACTTCTGGTATCCTACTGACTGACGAGCAGAAGCAA +GCACTGATGATGCAGGATGCGGCCCAAACAGGTATCGAGAACGCTGCCGCCACTGGTGGG +GCTGGTGTGGGTGCTCTAGCGACATCAAGTCCAGAAGCTATGCAGGGTGCAGCAGCACAG +GCTGGCCTAGACGCCACCTAATAACCCTCACTAAAGGGAGACCCCATCTTTGAATTGAGC +GATGACTAAAGGTTGGAGTCCTTTGGTTTCCCTTTATCTTTAACAACTTAGGAGATTTAA +CAATGGCTGAATCTAATCCAGACGTTTATGCGTCTTTCAGTGTGAACAACGCGGTAATGA +CCGGAAGCACACCTACTGAACACTAACAGAATATGCTGAGTCTCGATGTTGCTGCCCGTG +ATGGCGATGATGCAATCGTACTTAGCGAGGAACCGAGTTCCCATAACGATGACCCATATG +CATCCGGTGTAGACCCGTTCGCTGATGGTGAAGACGATGAGGGCCGCATTCAGGTTCGTA +TCAGTGAAGATGGTAATGAAGCCGAGTTCGACACCGGTAGCGATAACGCTGAGGTGGAGA +CCGAAGGTGAGGCCGCTGAGTTTGAACCGCTGTGTGACACTCCAGAAGAACTGAGCCAAG +TGACTGAGCAGTTGGGACAGCACGAAGAAGGCTTTCAGGCGATGGTCGAGCAGCCCGTTG +AGCGTGGACTGAGCGCAGAGTCTGTGACTCGCATCTACGAAGAGTACGAAGCCGATGGCA +TCTCTGAGAAATCCTACGCGGAACTCGAAGCTGCTGGCTATAGTCGTGCCTTTGTGGACT +CCTACATCTCCGGTCAGGAAGCCCTTGTAGACCAGTACGTTAATCAGGTAGTTGCCTTTG +CCGGTGGTAAGGAGCGCTTTAGCGCAATCCATACGCACCTTGAAGCAACCAACCCGGCTG +CGGCTGAGTCCCTTGAGACTGCCATGATGAACCGAGACTTGGCGACTGTCAAAGCAATTA +TCAATCTGGCTGGTGAGAGCTACACGAAGAAATTCGGTAAGCCTGCCAACCGTAGTGTTA +CCAAGCGTGCTACTCCGGTTAAACCTGTAGCTCGTCAGAAAGATGGCTTTACGAATCAGG +CTGAGATGATTAAAGCTATGAGTGACCCGCGTTACAGTAGTGATGCTGCCTACCGTCAAA +TGGTAGAACAGAAGGTTATCGACTCCAGTTTCTAATTAACCCTCACTAAAGGGAGAGACC +ATAGATGACTACAATGGTTGAATCACCTGAGCACAGAACTTTGTGGTCACTCCCGTAGGT +GAAACATTGAGAACCAACTCGATTCAAGTAGTAACCAAACTTTTCTTTAAATTAACATAA +GGAGATTCAACATGGCTAACAATCAAGGCGGACAGCAAATTGGTACTAAACAGGGTAAGG +GTCAGTCCGCAGCGGACAAATTGGCGCTGTTCCTGAAAGTGTTCGGCGGTGAAGTACTGA +CGGCTTTCGCTCGCACCTCCGTGACCATGCCTCGTCACATGCTGCGCTCTATTGCTTCTG +GTAAGTCCGCACAGTTCCCTGTGATTGGTCGCACCAAAGCTGCTTACCGGAAACCGGGTG +AGAACCTCGATGACAAACGTAAGGATATCAAACACGCCGAGAAGGTAATCCACATTGATG +GACTGTTGACTGCGGACGTTCTGATTTACGACATTGAGGACGCGATGAACCACTACGACG +TTCGCGCTGAGTACACCGCACAGTTGGGTGAATCTCTGGCGATGGCGGCTGACGGTGCTG +TACTGGCTGAACTGGCTGATCTGGTTAACCTGCCGGACGCCTCCAATGAGAACATCGAGG +GTCTCGGTAAGCCTACCGTACTGACTCTGGTTAAGCCGACCACTGGCGACCTGACTGACC +CGGTTGAGCTGGGTAAAGCGATTATCGCTCAGTTGACTATCGCTCGTGCGTCTCTGACCA +AGAACTACGATCCGGCTGCTGACCGTACCTTCTACACCACTCCTGATAACTACTCTGCGA +TTCTGGCCGCTCTGATGCCGAATGCTGCAAACTATCAGGCACTGATTGACCCTGAGCGTG +GTACTATCCGTAACGTGATGGGCTTCGAAGTGGTTGAGGTTCCGCACCTGACCGCTGGTG +GCGCTGGTGATACCCGTGAGGATGCCCCGGCTGACCGGAAGCACGCTTTCCCGGCGACTT +CCAGCGCTACCGTTAAGGTTGCTCTGGATAACGTTGTGGGCCTGTTCCAGCACCGCTCTG +CGGTTGGTACGGTCAAGCTGAAAGACTTGGCTCTGGAGCGCGCTCATCGTGCGAACTATC +AGGCTGACCAGATTATCGCTAAGTACGCGATGGGTCACGGCGGTCTGCGTCCAGAAGCTG +CTGGCGCTATCGTGCTGCCAAAGACTTCGGGGGCTTAAGGGTAGCGCCTTTGAATATGAA +CGCGGAGAGTGAAGTGGAGCCGACCCAAGAGGTAGCCGCCGAAGTAGCTCTCACGCCTCA +ACAGAAGGCCGCCATTTCTCGTGCTCGTAACAAGGCACTTAAGTCTCAATAACAACAAGC +AAACCCCTTGGGTTCCCTCTTTGGGAGTCTGAGAGGTTTTTTGCTTTAACCCTCACTAAC +AGGAGGTAACATCATGCGCTTTTATAAGATGAACATTGAGACCGCAGAAGAGCTATCAGC +GGTCAACGACATTCTGGCTTCCATCGGTGAGCCACCAGTATCGACCCTTGAGGGTGACGC +AAATGCTGATGTTGCAAATGCTCGACGTGTGCTCAACAAGATTAACCGACATATTCAGTC +ACGAGGATGGACATTCAATATTGAGGAAGGTGTGACTCTTCTACCGGATGCGTTCTCTGG +TATGGTTCCATTTAGCTCTGATTATCTGTCCGTAATGGCAACCAGCGGTCAGACCCAATA +TGTCAACCGTGGTGGCTATCTCTATGACCGCTCTGCGAAGACTGACCGATTCCCATCTGG +TGTTCAGGTCAACCTGATTCGTCTGAGAGAGTTCGATGAGATGCCTGAGTGCTTCCGAAA +CTACATCGTTACCAAGGCTTCCCGTCAGTTTAACAACCGAACCTGATTCGTCTGAGAGAG +TTCGATGAGATGCCTGAGTGCTTCCGAAACTACATCGTTACCAAGGCTTCCCGTCAGTTT +AACAACCGCTGCTTCGGTGCGCCGGAGGTAGACGGAGTGTTGCAGGAAGAGGAACAGGAA +GCGTGGCGTGCGTGCTTCGAGTACGAACTAGACTACGGCAACTATAACATGCTGGACGGT +GACGCATTCACCTCTGGTCTACTTAACCGCTAATAACAAGGAGGCTCTATGGCTCTCATT +AGTCAATCAATCAAGAACCTCAAGGGTGGTATCAGTCAACAGCCAGATATTCTCCGGTTC +GCTGAACAAGGTAGCGTACAGATTAACGATTGGTCTTCTGAGTCCGAGGGTCTCCAGAAG +CGCCCACCGATGATTCACCTTAAGACCCTTGGTGCTGCTGGGTATGTGGGTGCGCAACCT +TACCTTCACCTCATCAACCGTGATGAGTTCGAGCAGTATTTCGTGGTGTTCACTGGTGAA +GACATTAAGGTATTCGACCTCGACGGTAAGGAATACCAAGTACGTGGAAACCGCTCATAT +GTTCGTACAGCTAACCCACGAGAAGACCTTCGGATGGTAACTGTGGCTGATTATACCTTT +GTGACTAACCGCAAGGTCGTTGTACAGAGTAACGACCAATCGGTCAACCTTCCGGGCTTT +AAAGACCAAGGCGATGCGCTGATTAATGTTCGCGGTGGACAATATGGGCGTAGACTCTCA +ATCGAGTTCAACGGGGCTGAGCGTGCTGCTGAACAACTACCGGATGGTTCACAACCAGCA +CACGTTAACGAGGTTGACGGTCAGGCTATCGCTGAGAAGCTGGCTGTGCAGTTGAGGAAC +AACCTTGGGAATCCAAACAACGAGCAAGACCCGAATAAGTGGCGCTTCAACGTTGGCCCC +GGATTCATCCATATCCTTGCGCCAAATAACGATAACGTTTGGGGACTACAGACTAAGGAT +GGTTACGCAGACCATCTAATCAACCCTGTAACCCATTACACTCAGTCGTTCCAGAAGCTG +CCTATTAACGCGCCAGATGGGTACATCGTGAAGATTGTTGGTGATACCTCAAAGACTGCC +GACCAGTATTACGTTTGGTTCGACCTAAACCGTAAGGTGTGGGTAGAAACAAATGGATGG +AACACAAGGACTCACCTACATTACCACACGATTCCTTGGGCACTTGTTCGCGCTTCTGAC +GGGAACTTTGACTTCAAGTACCTTGAGTGGGGTGCTCGTACTGTGGGGGACGATACAGCC +AACCCATACCCATCCTTTACCGGACAGACAATCAACGATATTTTCTTCTTTCGTAAACGC +TTGGGATTCCTTAGTGGGGAGAACATCATCTTGTCTCGCACCTCGAAATACTTCAACTTC +TTCCCGGCATCCGTGTCAAACTACTCCGACGATGACCCAATCGACGTTGCGGTTAGTCAT +AACCGGGTGTCAACCTTGAAGTATGCCGTTCCGTTCTCAGAAGAGATACTCCTGTGGTCT +GACCAAGCGCAGTTCGTTCTGACAGCCTCTGGAATCCTCTCGAGTCGCTCCGTATAGTTG +AACCTTACGACGCAGTTCGACGTGCAAGACAGGGCACGCCTACATGCTGTAGGACGTAAT +GTATACTTTGCGTCACCTCGCGCTTCCTTCACATCCATTAACCGATACTATGCGGTACAG +GATGTAAGCTCTGTGAAGAACGCAAAGGACATGACGGCTCACGTTCCGAACTACATACCG +AATGGAGTATTCAGTATATCGGGGACAACCGCTGAGAACTTCGCGGCTATCCTTACGAGC +GGAGCACCGAACCGAGTGTATATCTACAAGTTCCTCTATATTGATGAGGAAATCAGGCAG +CAGTCGTGGTCTCATTGGGACTTTGGGGACAACGTTACGGTGTTTGCAGCACAGGTGATA +AACTCAACAATGACTGTATTGATGAGCAATGAACATGATGTGTGGATGGGACGCTTACAC +TTCACGAAGAACTCCAGAGACATTCCGGGAGAGCCTTACAGATTATACATCGACGCTAAG +AGGAAATACACCAGCCCTGCCGGGACGTATAATGATGATACCTACCAGACGTCCATAAGC +CTCGCAACAATTTATGGGATGAACTTCACTAGGGGTAGAGTGTCTGTGGTCTTTCCTGAT +GGGAAGATTGTAGAGATAGACCAACCAATCAACGGGTGGAGTAGCGACCCAATACTGAGA +CTTGATGGAAACCAAGAGGGACAAGTAGTCTACATTGGGTTCAACATCCCGTTCACTTAT +ACGTTCTCGAAGTTCCTCATCAAGAAGACTGCTGAGGACGGCTCGACGGCTACCGAGGAT +ATTGGTCGTTTACAGCTTCGGCGTGCGTGGGTAAACTATGAGGACTCTGGAGCGTTCACC +ATCCGTGTGAACAACCTGTCCCGTGAGTTCATCTACGCAATGGCTGGTGCTCGCTTGGGT +TCTGACAATCTGCGTGTTGGCAGGTCGAACATTGGCACAGGGCAGTACCGCTTCCCGGTT +GTTGGAAACGCTCAGACGAACATAGTAACTATCGAGTCAGATGCATCAACACCACTGAAC +ATCATTGGGTGCGGCTGGGAGGGGAACTATCTTCGACGTTCTTCTGGCATTTAACTTAAA +GTCTCCCTGTGGTGAATTAACCCTCACTAAAGGGAGACACTAATAGATACGAGGGGTTAA +AGCATTATGTACATTACAAAGTGTTTACAAATCCATGCCGACAACTTTCAGCCGTCCATA +GAGGTCATTCTGGAAGCTGAGGCACTAGGTGTTGAACCAAAGGTAATTCCTGATGAGAAC +ACTGTGGCAATGCTTAGCGATAACGCTGTGTTGGCAATCGGTGGCAATCAGGGAGACCGA +GTGTGGTTCCATACCTCTAAGTACGTCCCACTGTTTACCTTGAAGGAGCGCTTAGAGTTT +CGTAGACTTATCATTGAATATCGTGATATGATGCTGAGCCAGTACGAGTCCATTTGGAAT +TTCGTTTGGGTAGGCAATAAGTCACACATTCGTTTCCTAAAGACCATAGGCGCGGTATTC +CATAATGAGTTTACCGCTGATGGTCAATTCCAATTATTCACTATCAGTAGGAGGTAACTA +TGTGCTGGATGGAATCGATTCCTATTGCCATGATGGGTGCCCAAGCTCTAAGTAGCCAGA +ACAGTGCTGACAAGGCGCGAGTGGCACAGACCGAAGCTGGACGCAGACAGGCAATGGAGA +TGGTCAAAGAGATGAATATCCAAAATGCCAACGCCTCGCTGGAACAACGGGACGCCCTTG +AAGCTGCATCCTCTGAGTTGACTACACGTAACATGCAGAAGGTACAGGCTAAGGGAACCA +TCCGTGCAGCTATTGGCGAGGGTATGCTCGAAGCTGAGTCCATGAAGCGCATCAAGCGTA +TCGAAGAGGGCAACTACATTAGGGAGGCAAATAGTGTCACCGAGAATTACCGCCGAGACT +ACGCGAGTATCTTTGCGCAACAGTTGGGACGCACTCAGTCCACAGCGAGTCAAGTCGATG +CAATGTACAAGAGCGAGGCCAAAGGTAAGTCTAGTCTGATGCGTGTACTAGACCCTCTGT +CCATTATTGGTCAGGAAGCTGCAAGTTAATATGCGGCTGGTGGATTTGACAAGAAGGGTG +GAAACCAAGCAGCACCTATCAGTGCCGCCAAAGGAACCAAGACCGGGAGGTAATAATGGC +TAGTAAACTAAATAGTGTTTTAGGCAACATGGCGACTCCCGGTATGGAACGACCCCGGGG +CGTCAAAGGTATGGACTACCGGGCAGCAACCATTCAGGCTGAACAACCAAGAGCGAGTCT +TCTGGACTCCATTGGTCGATTCGCTAAGGCTGGTGCCGATATGTACATGGCGAAAGATGA +TCGTGATAAGCAACGAGCCGATGAGCGCTCAAACGAGATTATCCGTAAGCTGACCCCTGA +GCAGCGCCGACAGGCTATCCAGAATGGTACACTGCTGTATCAGGATGACCCATACGCAAT +GCAAGCCTTGAAGTTCAATACCGGGCGTAACGCTGCGTCCCTCGTTGACGATGAGGTTCA +ACAGGCCATCAAAGAGGGTCGCTTCCGTACTCGTGAAGAGATGAAGCAGTATCGTCACTC +ACGCCTACAGGAGCACCCGAAGTCGTACGCTGAGCAGTTCGGTATCAATGAGATGAACGA +GGAATACCAGAAGGGTTTCAACGCGAATATCACCGAGCGTAACATTGCTCTGTATGTGGC +ACATGATACCTTCCTGAGTGACCAAGCGCATAAGGGTGCAATCCTGAACTCGAAGGTTGA +ACTCAACGGTGTCCTATCTGACCCTGACCTACTGTCTCGTCCTGAGTCCGGTGAGTTTTT +CCAGAACCACATTGACAACTCCTTGGTGACGGGGATGACCGACAATCAGGCTCAACAGGT +TATCTCTTCGTCCCTGAATGACGTGCTACAGCGTCCGGGTGGTGCCGCATTCTTGCAGAA +CATTCAGAACCGCAAGGTGACTCTTAATGGCGCTACGACTAGCTATCGTGAACTGATGGG +TGATGAGCAGTGGCAGGCAATGATGATTAAGGCACAGCACACTCAATTCCAGAACAACGC +GAAGTTAACCGAGAAGTTCCGACTGGATATTAACTCAGCGCTTAATCAGGCAGACACTGG +TAAAGGGTGGGAGACTCTTCAAGGTATCAAGGCCGAACTCGATAAGATTCAGCCGGGTGA +AGAGATGACTCCTGAGCGCGAATGGTTGATTTCCGCACAGGAACAGATGCGTACACGCTT +CAAGCAGGAACAGGCTGAGACAGCCAAGCTGATGGACAAGCAACAGACGACCTTGAATAA +ATCTTTGGTCATCGACAAGCAGTTCCAGAAGCGCCTCAACGGTGAATACGTCTCGACAAA +CTATAAGGACATGCCGACCAACGAGAACACTGGTGAGTTTACACATAGCGATATGGTCAA +CTACGCGAACCAGCAGTTAGCGGAAATCGAAGCGATGGACTTAACGCAAGAACAGAAAAA +CAAACTGAAATTGGACTACCTACGGGCAGACTCCAAGGAGGGTGCTTTCCGTGCAGCGTT +TGGTGAGATGATTACTGATGCTGGAAACGAATGGCAGGCTGCGGTGATTAACGGTAAGAA +GCCTGAGAGCACACTAGCGAAGGACAACCTTCGTCGCATCCGCGACACTGACCCTGACCT +GATTGCCTCTCTGTATCCTGACAAGGCCGAGTTGTTCCTGACTATGGACATGTTGGATAA +CCGAGGTATCGACACGCAGGTTCTTATAGACGCTGATAAGTCCCGTGCACAGAAGACCAA +GGAGATGCAGTTTGAGGATGACCGAGCGTGGGCTGCTATGATGAACGATTCAACGAATCC +TCTAATCAAGTACATACCTTCGAGTGTCCAAGGTTACGCGCGGAAGATTTATGATTCCGT +GAAGTACCGGACAGGGAACCCTGACATGGCAACAGAACAGGTCGCAAAGTTCCTTTCTGA +TTCAACGACTACGTTCTCCAGTAGTGATGTTGATGGCGATACCTATGGTGTCCTGCCGAA +GAACATCCGGACTGTTTCGGACGACCCTAAGTCGTGGGAGCAAGGGAAGAACATTCTGGA +CGAAGCCATTAAGGGAATGACAGCGGCGAACCCTTGGATTACCAACAAGCAACTGACGGT +GTACCAGCAAGGTGATTCAATATACCTGATGGACACAACCGGACAGGTTCGCGTTCGGTA +TGACCAAGAGTTGCTCCAGCGTGAGTACCAGCGTACCGCACAGATGCAAGCTGAGGCAGC +ACGAGAGAAAGCCCTCAAAGAGGCCAACAAGCGTGCCCCAAGTTGCTCCAGCGTGAGTAC +CAGCGTACCGCACAGATGCAAGCTGAGGCAGCACGAGAGAAAGCCCTCAAAGAGGCCAAC +AAGCGTGCCCCAATCAGCCGTGCACCACAGGCGCGTGAAGAAGCGCGTAAACGTGTCCAA +GAAAAACGGAAGAAGACTCCGAAGTACATCTATGGACGTAAAGAAGACTAACAGTGATAA +GGAGGCTCCATGAGCTACGATAAGAACAAACCTAGCGAGTTCGATGGGTTATTTCAAAAA +GCGGCAGACAAACATGGGGTCTCCTATGACCTGCTTCGTAAATTAGCATTCAATGAGTCC +AGTTTCAATCCAAAGGCCAAATCTCCAACTGGCCCGAAGGGTCTCACGCAGTTCACCAAG +GGTACAGCCACTGCGCTGGGACTAAAAGTCACTGATGCAGACGAAGATGACCGTTACAAC +CCGGAGTTGGCTGTGGATGCAGCCGCTCGTCACCTGAGTGACCTCATTCGTAAATACGAT +GGGGATGAACTTAAGGCAGCCCTAGCGTACAACCAAGGCGAGGGAAGAAATGGTGCCCCT +CAGATGCAGGCCTACGACAAAGGTGATTGGGCCTCAATCTCTGAGGAAGGTCGTAACTAT +ATGCGTAACCTGATGGACGTAGCTAATAGTCCTCGCAAGGGGGACTTGGAGGCGTTCGGC +GGTATCACCCCAAAGGCTAAGGGCATTCCATCGGGGGATGCATTTGCTGGAATCGGGAAG +AAGCAAACGGTAGGCACTGACCTGCCGGAGTCAACGGGATTCAAAGTGGAGGGTAAAGAG +CAGTAAGCGCCTAACGTTCCTTATGCTAAGGACTTTTGGGAAAAGACTGGAACAACACTG +GACGAGTTTAACTCACGCTCTACCTTCTTCGGAATTGGCGATGCAACAAGTGCGGAGCTT +CATAACTCTGTACTTGGAGTTGCTTTCCGTGCAGCCCGTAGCGACGATGGTTTTGATTTG +TTCAAGGACACCATTACGCCTACCCGTTGGAATAGCCATACGTGGACTCCAGCTGGAACA +ACACTGGACGAGTTTAACTCACGCTCTACCTTCTTCGGAATTGGCGATGCAACAAGTGCG +GAGCTTCATAACTCTGTACTTGGAGTTGCTTTCCGTGCAGCCCGTAGCGACGATGGTTTT +GATTTGTTCAAGGACACCATTACGCCTACCCGTTGGAATAGCCATACGTGGACTCCAGAA +GAGCTAGAGCGAATCCGTAAGGAAGTGAAGAACCCCGCGTACATCAACGTAGTCACTGGA +GGCTCTCCTGAGAATCTGGACGCCCTCATTAAGATGGCGAATGACAACTATGAGATGGAT +GCGCGGTCTGCCGATGCTGGTGTTGGTGCCAAACTTACTGCTGGTATCATCGGCGCTGGT +GTAGACCCGCTGAGTTATGTACCGCTAGTAGGCGTAGCCGGGAAGGGTCTCAAGGTGGTT +AACAAGGCTTTCATTGTGGGTACTCAAAGTGCTGGCCTCGCGGTTGCCTCTGAGGGTCTC +CGTACATCAATCGCTGGTGGAGAAGTCCACTATGCTGATGCTGCTTTAGGTGGTCTCTTG +TTTGGTGCTGGTATGAGCGCAATCAGTGATGCTATCGCTGCTGGTGTTCGCCGTTCCCGT +GGGACTGAGGTAGTTAATGACTTCGCTCCTATGGCACACCGCTTGGAAGCCCGTGAGACC +GCTCTGAACACTGGTGGGGAAGACCTGACCCGTATGCCTAGCGAGAACCGTGTGTTCGAC +CGTGAGCACGCTGGCGTTGAGTAGTCACCTCTGGAGACCGAGCCGGGTGCCGTTGTGTTG +CCTCAAGGTCAAATCCTGAGCGACACCAACCCACTAAACCCTCAGACTCTGAGCGAGTTC +GAGGCGGTCAACCCTGAGCGTGCCGCTCGTGGTATCTCTTTGGGTGGTTTCACTGAGATT +GGCTTGAAGACTCTCCGCTCTGAGAACCCGACTGTTCGCTCCATTGCGAGTGACCTTGTG +CGTTCTCCGACAGGGATGGAATCAGGCTCTAATGGTAAGTTCGGTGCGACTGCTTCTGAC +ATTAAGGAGCGGCTCCACGCGAACAATCAGCGCACCTACAATCAGCTTTATGATGCTTTG +CGTACTGCAATGAAAGACCCTGAGTTCTCCACAGGTGGTGCCACAATGAGCTGTAAGGAA +ATCCGACAGGAAATCTACAAGCGTGCAGCCTTGGCGATTGAGCGACCTGAGCTTCAAGCA +AACCTGACAAAGGGTGAGCGGAACGTGATGAACCTCCTCAAGCAGCGCTTTGACCTCAAA +CGTGAAATCATGGAGAACCCGTCAATCTTCGGCAACACCAAGGCGGTCAGTATCTTCCCC +GGCTCACGCCACAGGGGAACCTACGTGCCAAACGTGTACGACCGCGCTATCAAGATTGAG +ATGGTTAAACGTTACGATAATGATGGCTTGCAGCGAGAAATCGCGGAGTCATGGTTGACG +TCTTATCGTGCTCGTCCAGAAGTCAAGGCGAGGGTCGATGAGTACCTGATGGAACTTAAC +GGTCTCAAATCCGTGCAGGAAGTTACGCCTGAGATGGTGCAGTAGCACGCGATGGATAAG +GCGTATGGTATTTCACACACTGACCAGTTCTCTGCCTCCTCTGCCATTGAGGATAACATT +GAGGGTCTGGTGGGTATCGAGAACAACAACTTCTTGGAAGCCCGTAACATGTTCGACAGT +GACATGGCGGTGACTCTCCCTGATGGTAACACGTTCTCTGTGAATGACCTGCGTACCTAT +GACATTGCTGAAATTCTGCCTGCATACGACCGACGAGTAGATGGTGATGTTGCAATCATG +GGCGGTTCCGGTAAGACTACCAAAGACCTGAAAGATGAAATCATGGCGCTGGATAAGCAG +TCAGAGGGTAACGGCACACTGAAAGGTGAAGTGGAAGCTCTCAAGGACACCGTGAAGATT +CTGACTGGTCGTGCTCGTAGGAACCCGGAAGGCGCTTGGGGTACAGCCCTACGCTCCGTA +AATGACCTCACGTTCTTTGCTAAGAACGCCTATATGGGCGCACAGAACGTTACTGAAATC +GCTGGTATGCTGGCGAAGGGTAACGTCTCTGCGATAACTCATGGCATCCCTATGGTTAAC +GATTGGGTCTACCGTGGTAAACCGCTTCGTGCCTCTGAGATTAAGGAGATACACGGGATG +GTGTTCGGTAAGGAACTAGACCACCTAATCCGTCCGGGACGTGAAGACCACGTGCGCCGA +CTCCGGGAGTCTACGGACACCAGCGCTGCGGTTGCCAATGTGGTCGGTACGATTCGTTTC +GGCACTCAAGAGTTGGCTGCACGCTCTCCTTGGACAATGCTCCTAAACGGAACATCAAAC +TACATTCTTGAAGCTGCCCGTCAGGGTGTGCTTGGGGATGTGGCTGGAGCGGCCCTTGCT +GGGAAAGCCTCTAAGTTCGGTAAGGCAAACTACCTTAAGTCTGCCTCTATCAGCCCTGAG +CAGTGGAATGGAATCAAGCAGTTGTTCAGAGACCATGCGACTCGTAGAGAAGACGGTAAG +TTCACCATTCGTGACAAACAGGCTTTCGCTCACGACGCACGTTCAATGGACTTGTGGCGA +CTGGCTGACAAGGTGGCGGATGAGACTATACTGCGACCTCACAAGGCTTCCTCACAGGAT +TCCAAAGCGTTCGGTGCAGGGGTGAAGATGGTGATGCAGTTTAAGAACTTCGTCATCAAG +TCCCTTAACTCCCGGTTCGTCCGTAGCTTCTACGGGGCAACTAAGAACAACCGTGCGTTA +GACCAAACGTTGACTCATATCATCTCCTTGGGTCTAGCTGGTGGTTACTACGTTGCGCAG +GCGCACCTTAAGGCCGCAAGCCTACAGGAGCACAAGCGTAAGGAGTACCTTAAGAACGCA +CTTGACCCTAAGATGATTGCTCATGCGTCAATCTCTCGTAGTTCACACTTAGGGTCTAGC +TGGTGGTTACTACGTTGCGCAGGCGCACCTTAAGGCCGCAAGCCTACAGGAGCACAAGCG +TAAGGAGTACCTTAAGAACGCACTTGACCCTAAGATGATTGCTCATGCGTCAATCTCTCG +TAGTTCACACTTAGGCTCACCATTGAGTATCTACAACATGTTCGCTGGGATGGTTGGTAG +CGATACCTGTAAGTACACCCGCTCTACTGTGCTCCCTAAAGAGTCCGAGAAGCGTGACCC +TAACAAGGCAATGACAGGTAGACAGGTGGCTTCAACTATCGCGGGTGCAGTTGGTGAGCA +GGTTCCGGGGTTAGGTTTTGTGGGTTCTGTGGGTGCAACAGCAATTAACGCAGCTTCCCT +GCTATCTTCTCCCAACAAGGCAACCGCTCTGGAGTTCCGTACAGGCCTCTTCAACACCTC +TCGTGAGTTGATTCCTAATGACCCGCTATCGCAGCAACTCATTATGAAAACCCTGCTATC +TTCTCCCAACAAGGCAACCGCTCTGGAGTTCCGTACAGGCCTCTTCAACACCTCTCGTGA +GTTGATTCCTAATGACCCGCTATCGCAGCAACTCATTATGAAAATCTACGAGGCCAACGG +TATCCGCATAAAGGAGACGCCGAAGAAACAATAAACCCTCACTAAAGGGAGAGAGGTCAC +ATTCTGTCCTCTTCTCTCTTAATGCTAATTTACAAAGGAGGTCACATGGCTACAACTATT +AAGACCGTGATGACTTACCCGCTGGATGGCTCCACTACGGACTTTAATATTCCGTTCGAG +TATCTAGCGCGTAAGTTCGTCAGAGTGACCCTTATCGGTGTTGACCGAAAGGAACTCATC +TTGAATCAGGACTACCGTTTTGCGACTAAGACCACAATCTCCACAACGAGAGCATTGGGG +CCAGATGACGGTTATAACATGATTGAAATCCGTCGATTTACCTCCGCTACCGATAGGCTG +GTTGACTTCACCGATGGTTCAATCCTTCGGGCATACGACCTGAACATCTCTCAGGTCCAA +ACCCTTCACGTTGCTGAGGAAGCACGTGACCTTACCGCTGATACTATTGGCGTTAACAAT +TATGGGAATTTGGATGCTCGTGGTCGCCGTATCGCTAACGTAGCTGACGGAGTTACTGAT +GGTGACGCCATCTCTGTAGGTCAGGTTAAACGTATGAACCAGAACTCGTGGCAAGCACGT +AATGAGTCCTTGCAGTTCCGTAATGAAGCAGAAAGTTTCCGCAATCAGGCCTCTACGAGT +AAACAGGCTGCTGCTACCTCTGAGTCGCAATCATGGAATCATACTGGGCGCTCTCGGACA +TTCGCTGAGGCAGCTCAAGGTTCTACTAACTCTGCGGGACAGTCAGCTACCAATGCGAAC +AACGCTATGCAGTCTGCTGGTCAATCAGCCACGGATGCTAGTAACTCTGCTGCTCAGGCT +AAGGCCTCTGAGGTTAACGCAAAGGCCTCTGAGGTTAACGCTAAGCGTGATGCTGACGCG +GCCCTGCTGGCTCTGCAATCCACTGGTAACGTACCTGTGGGTACAGTCGCCATGATTACC +CACACCAAGATTCCTACTGGTTGGGTGCGTGCTGGTGTGGACTTCGACGTTAATACTTAC +CCGGCGTTAGCTGAACTGTTCCCTAGTGGTCGTACTCCTAGCTTCGATGACCGCTATCCT +ATTGGTAACTCTACCGTATTGACTCCGGGTCAGCTTATTGAACAATCAGTACCCGCCCAC +AGTCACACCTTCGACGTGCCTGTCAACGTGTCAGGTGCTACGGCTGCTGGTGGCGAATAT +CGCGCCAGAACGTCACACGAAGGGGATCACAGTCATGGGTTCTCATTGCCTATCCAGAAC +AACACTGGTGCTTATACTGGTCGTCTGGTTGGCGGTGGCAACAACCCTAATTACCCGCAA +GACCTGCGCTTTAACACTGGTGGCGGTGGTGCTCACAGTCATGAGTTCTATGTTCCTTCA +CACAGTCACACGTTGAATGCATCTGGGCGTGCTGCTGGCTCCGTCTCTTCGTCAGGTATT +GGAAACTCACCGTATGTCCGACCGTATTCCACTGTGGTCATCTTCATCATCAAGGCCGCT +CAAGGTGTTGACAATAAGGACGCAGCAATGCAGGTGGTGGGCACTGTGGTTGGACGAGTG +GACGCTCTGGAGAACTGGCAGAAAAACTTCAAGTACGTTGTTGAGAACGGTTCACCAACC +TCTGCAAACGGCGGGCCTTGGGAACGTACTGTGTACACTGCCCAGACTGACTTCGGTCGC +AACCGCTGGCGCACACTGAGTGGTTCGTCATGGGGAGAAGTAGTCAACTTACTTAATAGC +TCCGGCGTACTTAAAGGGTATCCGCAACGTCTTGTTGTTGACTTCACGGTTGAGGTAATC +GATAGCTCTGACCTCATCGCCAAGGCTGGTATATATAGTCCAATTATTATGGCCAGAATC +GTGTATCACAACGGCACCAACTCTGGTGATATACTTCCCGCTGCCACCTCAAGCTCTGCG +CACGCGACAAACGGGTGGAACATTAAGATGGCTACACGATTGTTGTATGGTACTGATGGC +GGTCAACCAGTAGTTGAGATTGGTGCCTTCAAGGATGGTTCTGACCAGCAGACGGCAAAC +GTGCCAGTTAAAGTAGGCTTGTGCCTCGTTCACGTGTTCTAAGGAGGACATAATGTTATC +ACTTGATTTCAACAACGAGGCCATTAAGGCTGCACCCATTGCGGGTGTGGCTGGTGCTGA +TGGTGTGGCCCGCCTGTTCTGGGGGCTTTCTCTCAACGAATGGTTCTACGTTGCAGCTAT +CGCCTACACAGTAGTTCAGATTGGTGCCAAGGTGGTCGATAAGATTATTGATTGGAAAAA +AGCAAATAAGGAGTAACCTATGAGCGACAAGACTTTAATCAAGCTGCTGGAGATGCTGGA +GACGGAGATGGCACAGCGTATGCTTGCTGACCTCCAGAGCGAGGAACGCCGAACTCCGCA +GCTTTACAACGCAATCGGCAAACTGTTAGACCGCCATAAGTTCCAAATCAGTAAGCTGAC +CCCGGACGAGAACATCCTTGGCGGTCTGGCTGCTGGTCTGGAAGACTACAACAAAGTGGT +CGGCCCTAATGGTCTGACTGATGATGAAACAATCACGCTACAGTAAGTGACATACTCAAG +GTTCTCCACGCGGGGAGCCTTTATGGATGTTATCTGGTGCATCTATGTAAAATCTGAAAA +TTGATGGGAGGTGTTATGCTAAAACTTTTACGCAGCGCACTCCCTTGGGTACTCGCCGGG +ACACTCTTTATGGGTTGCTGGCACTTAGGGTCAACCCATGAGAGAGCAAACTGGAAGGAG +GTAATCCAAAATGAATACATTGCGAAAACAAAAGCAACCGCAGCAACTCAGGCAGCGGTC +AGTCGGGTATCCCGTGAGTACCAAGAAGAGATTGCAGCCATTGAAGGCAGCACTGATAGG +ATGCTTAATGACCTGCGTAGTAATATTAAGCGGCTGTCAGTCCGCATCAAGACCCTTACC +GGACTACCAGAAGATAACGGTAGATGCGAGTTTAATGGTCGAGCCGAACTACACGAGTCA +GATGCTAAGCGTATTATCGGAATAACCCAAGCTGCTGATGCTCACGTAAGGGCGCTCCAG +CGTACTATTAAGGAGATGCAGAATGAGCGACACCCAAGCAAACCGTATTGCGCTAATCAT +CGCGCAGCTTAAGGGCGACTTTGTGGCCTTCCTGTTCGTATTGTGGAAGGCTTTGGCTCT +CCCGCCACCGACTAAGTGTCAGATTGATATGGCCCGGTGTCTGGCTAACGGAGACAACAA +GAAGTTTATCCTACAGGCTTTCCGTGGTATCGGTAAGTCATTCATCACCTGTGCGTTCGT +TGTGTGGACGTTATGGCGTGATTCCTGTTCGTATTGTGGAAGGCTTTGGCTCTCCCGCCA +CCGACTAAGTGTCAGATTGATATGGCCCGGTGTCTGGCTAACGGAGACAACAAGAAGTTT +ATCCTACAGGCTTTCCGTGGTATCGGTAAGTCATTCATCACCTGTGCGTTCGTTGTGTGG +ACGTTATGGCGTGACCCTCAGTTGAAGATACTGATTGTCTCTGCATCCAAAGAACGTGCG +GACGCTAACTCCATCTTCATCAAGAACATCATTGACCTGCTGCCATTCTTGGCTGAGCTA +AAGCTTCGCCCCGGTCAGCGTGACTCTGTGATTAGTTTCGATGTTGGCCCTGCCAAGCCT +GACCACTCTCCGTCTGTGAAGTCGGTGGGTATCACTGGTCAGTTGACTGGTAGTCGTGCT +GATATCATCATAGCGGATGACGCTGAGATTCCGTCTAACTCCGCAACTCAAGGTGCCCGT +GAGAAGCTGTGGACTCTGGTGCAGGAATTTGCTGCGCTTCCGAAACCGCTGCCTACTTCT +CGCGTTATCTACCTTGGTACATCTCAAACCGAAATGACCTTGTACAAGGAACTCGAAGAT +AACCGTGGGTACACCACTATCATCTGGCCTGCGCTCTATCCACGTAGCCGTGAGGAAGAC +TTGTACTATGGCGACCGTCTGGCCCCGATGCTCCGCGAAGAGTTCAACGATGGGTTCGAG +ATGCTCCAAGGTCAACCGACTGACCCCGTGCGCTTCGATATGGAAGACCTGCGTGAGCGT +GAGTTGGAATACGTTAAGGCTGGCTTCACTTTGCAGTTCATGCTCAACCCGAACCTGAGT +GATGCCGAGAAGTACCCCTTACGCCTCCGTGACGCTATCGTGTGCGGTCTGGACTTCGAG +AAAGCCCCAATGCATTACCAGTGGCTTCCGAACCGTCAGAATCGCAATGAAGAGCTTCCT +AACGTGGGACTTAAGGGTGATGATATTCATAGCTATCATTCGTGCAGCCAGAACACTGGA +CAGTATCAGCAACGCATCCTCGTGATTGACCCAAGTGGTCGCGGTAAGGATGAGACAGGT +TACGCAGTGCTGTTCACCCTGAATGGCTACATCTATCTGATGGAAGCTGGCGGGTTCCGC +GATGGTTACTCCGACAAGACCCTTGAGTCCCTCGCTAAGAAAGCGAAGCAGTGGAAGGTT +CAGACAGTGGTCTTCGAGAGTAACTTCGGGGATGGTATGTTTGGTAAGGTATTCAGCCCT +GTGCTCCTGAAACACCATGCAGCGCAACTTGAAGAGATTCGTGCTCGCGGTATGAAGGAA +CTACGCATTTGTGATACGCTGGAACCTGTACTCTCTACGCACCGCCTTGTGATTCGTGAC +GAGGTGATTCGTGAGGACTACCAGACTGCCCGTGACGCTGATGGCAAGCATGACGTTCGC +TATTCGCTGTTCTACCAGTTGACCCGTATGGCTCGTGAGAAGGGCGCTGTGGCCCACGAT +GACCGACTTGATGCGTTAGCATTGGGTGTGGAGTTCTTACGCTCTACGATGGAACTGGAC +GCCGTGAAGGTGGAAGCTGAGGTGCTGGAGGCGTTCTTAGAGGAACACATGGAGCACCCA +ATCCATTCGGCTGGTCACGTAGTCACCTCTATGGTTGACGGTATGGAACTCTATTGGGAG +GAAGACGATGTGAATAGCAATAGGTTCATTGACTGGTAGTTATGCATATTGAGTGCATAA +GGAATCATTGAGACCACGGATGGTCACTTTAAGAAACTCCTTAAGAATCAATGAGTTTGA +ATTAATCCTCTCTAAAGGGAGAGAGGGGACTTAAAGCTACTATATAGGTTAGTCATTCAG +GTTATGCAATGACCCTTTATGCACTTTAAGTCGCCTCTATGATTGGTGATATTATCATTG +TATAATCACCCTACCTTAGAGCAACTGAAAGGAGGTGGCTCAATGTTACGCTTGCTGACT +GCCCTGCTGCGTCATAGAGTCACTTGGCGATTTCTTCTGGTACTTGCTGCTACCCTTGGG +TACGCAGGTCTTACTGACCACCTCGGTCAACTGGAAGTGGCCTTTTGCTCTATACTCTCT +TGTGGGGATTAAATTATTGTTGATGAACGACAAGCGGCTCTGAGGGATTCTTAGGTATAG +TTTCACTACACCAACTCATCCCTGTACAGTCAACCCTAAAGGTTATACCTAAAGATGCCC +TGTAGTTCGTAATGGTCTTACAGGGTCTTTAAGTGTCTCCTATGGTCTCACCTATGGTGT +GGCCTTACCTAAAGTGGTTGCCTAAAGAGACCTTTGAGAATTTACCACAAAAATCTGAAT +GGATATCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAA +GCCAGCCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCT +ATAGGATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGA +GGCCTTAACGAGTGTCCTAGTGTACCAGTTCGATGGTACATCTCTATGTGTCCCT +>NC_010807.alt3 length=39891 tani=98.414 alt=sn;ins;tl +TCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAAGCCAG +CCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAGGTGGCCTATAGG +ATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGAGGCCT +TAAAGAGTGTCCTAGTGTACCAGTTCAGCTAACCATAATTACGATCCCATCCATGCCAGG +TTCCAGTTGGGGCTTCGAGAAAATTGCACGGCCATTGACCTCTCCAGGGGTGCGAATATG +AGACCCAGCACTATCCCCGTGAGTCCTCGTCGTAGATCAAGAGGATGTTTCCTCGTGTCC +ACTGCCATAGATTATACATGATAAGATGGGACCCCGGCACCGGGCGACCATACACTTCCA +CAGATAGTACATCTGTATGTGTCCCTATCTGTTAGCCTCATAAAGTAAACCCTAAAGCCA +CTACCTAAAGACCAGACCTAAAGCCATCACCTAGAGAGCGACGCTATCTTAAAGACAACC +AGACCGATAGACCCATTGTTAACCTGTAGTGATGCCCTGTAGTTATCTGTAGTCATTTCA +TTAACCCTCACTAAAGGGAATAAGGGATACTTAAAGGGGGGAATTAGGGATTTAATAAAA +GATTAAAATTAATGGTTGACTTTAAGTAACCCTTAAGGCTATTATTCATCACGTCAACGG +GACAACGGCCTTAAAGCCACTCCCTGAGATACCGGAGTCAACCGGATAAGTAGACAGCCT +GATAAGTCATACGAAAAACAGGCATTGACAACGCAAGGTAACAAGTAGTAAGATGCACAA +CATAGCGTCAACCACCAAATCGGTGTCTTCTAGGTGACTTAAGCGCACCACGGCACATAA +AGCTAAACAAAATGGTTGACAACATGAAGTAAACACGGTACGATGTACCACGAAATGACG +GAACAGTGAGGCGGGACACTGAAAGCCGCTAGGGTCTAACGAAACCAGACCGACACGCAA +ATCATAGTAGGTTTAATAAGCGGTAAGTGTATTACTTCCCTTGTGTGCCGCCGAATGGCA +TCAGTACACACGACAGGCAGTACGGAAAGTGACACGATGCAGTGCTGCCATGATTTGATC +GCTCTTTAACAATCTGGATAATAGCTCTTGAGTGCACCGATGTATAAGCGAACTGCTCGG +TTAGAGCTACGAGGCGTGACTTAACGGGTAATCATGCACCGGACGAGGAAACTGGGGACC +GCATGCGTTGCGAACCCATCCAAATGCAAAAGACTTATCGAAACACCGAATGGGTAGGGG +TGTGCCTAAGATCCTCTGCATGGGGCGTCCGCCAATGATGTTGTTCATATCAAAGGAGGG +CGCGGAATCACGCATAACTCAAGGTCGCACTGAAAGCGTGGCCTTTATGATATTCACTAA +ACACGAACTAACATGAGGTAACACCCAATGATTTTCACTAAAGAGCCTGCTAACGTCTTC +TATGTACTGGTGTCAGCTTTCCGTTCTAACCTTGATGATGAGGTGAACATGAGCCGCCAC +CGCCACATGGTAAGCACTTTACGTGCCGCACCGGGTCTTTATGGCTCCGTTGAGTCAACC +GATTTGACCGGGTGCTATCGTGAGGAAATCGCAAGCGCACCGACTGAGGAAAAAACGGTT +CGTGTACGCTGCAAGGACAAGGCGCAGGCGCTGAATGTTGCACGCTTAGCTTGCAATGAG +TGGGAGCAAGATTGCGTACTGGTATACAAATCACAGACTCACACTGCTGGTCTGGTGTAC +GCTAAAGGAATCGACGGTTACAAGGCTGAACGTCTGCCGGGTAGCTTCCAAGAAGTACCC +AAAGGCGCACCGCTGCAAGGCTGCTTTACGATTGACGAGTTCGGTCGCCGCTGGCAGGTG +GCCTAACATGAATCGTTATTACATCAACGTACCGGGCTGGGGTGGGTCTCTGACCTGCTA +CGGATACAACGAACGGGACGCACGGAAACGCTTTAGAGAACAACACGGCTTCGGAAGGCT +TCCTAATGGGACGCGCATATGGCTGGACGCCCGTGATTGGTAAGTGATAGACTCAAGGTC +GCACTGTATGTGTGGCCTTTATGATTATCACTTATAGGACTAACACCATGAGTAAACTTC +TGGCAACATCTAAAATAGAAGGCCAATGCACCGTAACACTGCGTGAGTATTACCACGGGT +CAATGGGAAGCACCTATGTTGTGCGATACGGTAAACAGGTCACACATTGGGTAAACCCGA +TTTTAGCACAAGAGGATTATCAAGCCTGTGTGATACACCAAGCAACATGTGCGGGCTGGA +ATGATTGACATTACAGGAGGATTAGGAATGGTTATCTTTATCGCTGTCGCACTCTTTGCG +GTCGCTGGCTGGTACTCTGAGTCACGCAAGGCCGCTCGCTATCATCGCAAGATGGTTAAA +CTCATGGAACACTTGGACGCAGAAGGGCGAGGCCGCGAGGCTATCGAACTGGTGAAACAC +GCATGATGATTCTCTCTATCGCACTGGTCTATCTGTGCATCGCAATGTACTTTATGCGAG +ACTTTAAGCGCGGTCTGGCAATACACAAGGCAACGCTGAGTTACTTTAAGCGCGGTCTGG +CAATACACAAGGCAACGCTGAGTTACTTTAAGTGGGGATTCATCCCACGGTTTACGGTTC +GTGAACGCAACGGACGCTTTAAGGCCAACAAGGTAGGAGTATTCTACATTGCTACGCACT +AACTCAAAGCACGTAAAGACCGCACTGTATGCGATGGCGTATGGTGCATCGAAACGCAAG +GTCAAACGCATCTTAACGAGACACCGCAAGATGACCGCACGACAGGCTGCAAGCGCTGTC +AAATGGGCTGAATTTACTCTTTACTCTTCTTACAGATAACAGGACACTGAACGATGACTT +TCACCGAAGCACAAGCCGCACTCGAAGCTATCCGCAACCTACCGATTGAGCGCCTGAACG +AACGCTTAACGCCAGAACAGAAAGACAAACTGAAATTGGACTACCTACGGGCAGACTCCA +AGGAGGGTGCTTTCCGTGCAGCGTTTGGTGAGATGATTACTGATGCTGGAAACGAATGGC +AGGCTGCGGTGATTAACGGTAAGATGCCTGAGAGCACACCAGCGATCCAGCCCATGCTGG +TGGCTCTTGCGGCTGCTATCGTGAACGCTGAGACCCAAGACGGCGAACTGACGCAGGCCA +AGGGTAATTGGGGTCTGGAGTCTATGGACTACTGGCAGACACTGGCTGAGCGTATGCGTG +ATGTTGGATTTGTACGCTTGGGCAACGGTCACTTTAGCGCAACACCGTAACGTTGTCCCC +AAAGTCCCAATGAGACCACGACTGCTGCCTGATTTCCTCATCAATATAGAGGAACTTGTA +GATATACACTCGGTTCGGTGCTCCGCTCGTAAGGATAGCCGCGAAGTTCTCAGCGGTTGT +CCCCGATATACTGAATACTCCATTCGGTATGTAGTTCGGAACGTGAGCCGTCATGTCCTT +TGCGTTCTTCACAGAGCTTACATCCTGTACCGCATAGTATCGGTTAATGGATGTGAAGGA +AGCGCGAGGTGACGCAAAGCATATGAGCACGCATTGTTACCGGGCAAGGTTATCAAGGTA +GGCTTTAAGAAAGAGGATTCAGGCGCTGCCTATGCCGCATTCTGCCGTATGAATCAGGGT +CGTGAGGGCATCCCTACGGTCTTAGGCATCGCATCGTTCGATTGTCACAGCGGGAACATG +ATGAAAGACCAGATGGGACGCCTGATTATCACAGACCCGGTATCATTCAGCGCAGACGAC +AAGTTAAAGCCGGGTGAGTTCCACTGTGACCCGGATGAACTCATCGCTGAGATTGAGGCG +CTGAGAGCGCAGGAAGCGATTGACCGCTGTAAGGCACGCAAGGCACGCCGTGACCCTAAA +GGAGACTTTCAGGTAGCACGTAAAGCCCGTGCCAAGTGGCGCAGAAAGGCCTCTAAGCGC +GAGAAGCGCAACGCTAAGGTGCTCGCTAAGATGCGCATGGATGCTAATCAGAATCGCAGG +GATGAGCCTAGGGCGCGTATGGTGTGGGGCGATAAGCACTGGCGCAACGCTTGGATGCAC +CACAATAACCTAAACTTTGCAGAACTGGAGCGCCGCGCTGCTGCGGCAATGATGATGCAT +GACGAGGTGCGCATTCAGTGGGGCAAACCGTTACACATAGACGCATACCTTGACAAGCGT +CTACAAGGCTGATAGAGTCTTATCTTACAGGTCATCAATCGGTGGCCTGAATAGGTACGA +TTTATTCACAATGAGGTAAGCAATGAGCATCATCGAAAACATCGAAAAGAATGACTTCTC +CGAAATCGAACTGGCTGCTATCCCGTTCCACACACTGGCAGACCACTACGGCAGCGCATT +GGCTCGTGAACAACTGGCTTTAGAGCATGAGTCTTATGAGCTAGGCGAGCGCCGCTTCCT +CAAGATGCTTGAGCGTCAAGCGAAAGCTGGTGAGATTGCAGACAACGCAGCCGCTAAGCC +ATTACTCGCTACGCTTCTCCCTAAGTTAACCGCACGCATCGTTGAGTGGCTCGAAGAGTA +CGCCTCGAAGAAAGGCCGCAAGCCAGTAGCCTATGCACCGCTCCAGTTACTCAAGCCGGA +AGCCTCCGCGTTTATCACACTCAAGGTCATCCTTGCGTCACTGACCAGCACGAACATGAC +AACCATTCAGGCCGCTGCTGGTATGCTGGGGAAGGCCATTGAGGATGAGGCACGTTTCGG +TCGCATCCGTGACCTCGAAGCGAAGCACTTCAAGAAGCACGTTGAGGAACAGCTTAACAA +GCGCCACGGGCAAGTCTACAAGAAAGCCTTTATGCAGGTGGTCGAGGCCGATATGATTGG +TCGCGGGCTGCTGGGAGGTGAGGCGTGGTCTAGCTGGGATAAAGAAACCACGATGCACGC +CGGGGGCGGCTATTGGGCTAACGGTCGCAGACCTTTGGCACTCGTCCGCACTCACTCTAA +GAAGGGACTGATGCGCTATGAGGATGTTTACATGCCAGAAGTTTACAAGGCGGTCAACAT +CGCACAGAACACCGCATGGAAAATCAACAAGAAAGTTCTTGCGGTTGTCAATGAAATTGT +TAACTGGAAGAATTGCCCGGTCGCAGACATTCCATCGCTGGAGCGCCAAGAGTTACCGCC +TAAGCCGGACGACATTGACACCAACGAGGCAGCACTCAAGGAGTGGAAGAAAGCCGCCGC +TGGTGTCTACCGCTTGGACAAGGCACGAGTGTCTCGCCGTATCAGCTTAGAGTTCATGCT +GGAGCAGGCCAACAAGTTCGCAAGCAAGAAAGCAATCTGGTTCCCTTACAACATGGACTG +GCGTGGTCGTGTGTACGCTGTGCCGATGTTCAACCCGCAAGGAAACGACATGACCAAGGG +GCTGCTGACCCTCGCTAAAGGCAAGCCAATCGGTGAGGAAGGTTTCTACTGGCTGAAAAT +CCACGGTGCGAACTGTGCGGGTGTCGATAAGGTTCCTTTCCCTGAGCGCATCGCGTTCAT +TGAGAAGCACGTAGACGACATTCTGGCTTGCGCTAAAGACCCAATCAATAACACTTGGTG +GGCTGAGCAGGATTCACCGTTCTGTTTCCTCGCGTTTTGCTTCGAGTATGCAGGCGTTGC +GCACCACGGTCTGAGCTACAATTGCTCTCTGCCGCTGGCGTTCGATGGGTCTTGCTCCGG +TATCCAGCACTTCTCCGCGATGCTCCGCGATGAGGTAGGCGGTCGTGCGGTTAACCTGCT +GCCAAGCGAAACCGTGCAGGACATTTACGGCATCGTTGCACAGAAAGTAAACGAGATTCT +CAAACAGGATGCAATAAACGGCACACCTAATGAGATGATTACCGTGACCGACAAGGACAC +CGGGGAAATCTCTGAGAAGCTCAAGCTGGGAACCTCAACGCTGGCGCAACAGTGGCTGGC +ATATGGTGTAACCCGTAGCGTAACTAAACGTTCGGTCATGACGCTGGCTTACGGTTCCAA +GGAGTTCGGCTTTCGTCAACAGGTACTGGACGACACCATTCAGCCTGCGATTGACAGCGG +TAAGCTGCTAAGCTGCTAGCTGCTGAGGTCAAGGACAAGAAGACCAAGGAGATTCTTCGC +CACCGTTGTGCGGTTCACTGGACTACGCCGGACGGATTCCCGGTCTGGCAGGAATACCGC +AAGCCACTCCAGAAGCGTCTCGATATGATTTTCTTAGGGCAATTCCGTCTGCAACCGACG +ATTAATACCCTCAAGGATTCAGGCATTGACGCACACAAGCAGGAGTCTGGCATCGCTCCT +AACTTTGTTCACTCACAGGATGGTAGCCACCTCCGCATGACGGTCGTTTATGCTCACGAG +AAGTATGGCATTGAGTCCTTTGCGCTAATCCATGACAGCTTTGGGACTATTCCGGCAGAC +GCTGGTAAGCTCTTTAAGGCTGTGCGTGAAACGATGGTTCTCACCTACGAGAACAACGAT +GTGTTGGCAGACCCTCACTAACGGGAGACTACTTAAGGTCTCCCTTAAGGTACTAAGAGA +TTTTAATTTAAGATAACTAAGAGGTTTACTTTATGATTACTTTATGTGCCGCAATCGTTC +TTATCGCTACACTCTCAATCGTCATCGCTAAGCAGCGCTCTGAGTTAATCAAGCTGGATG +CCCGATATGATAGTGCGAACCACCACCGGAAAGAACTGGATGCAGCACTTGGGCGGTCAA +CCGATGAGGTTAAGACCCTTAAGCGCCAGCTACAGCACGCCGAGCAAGACGATAAGAACC +GCTGCGAAACAATCCGAGGTCTACGTGAAGAACTCCGGGAGTTGCGCCAGACGATTAAAG +AGCGCCACGCTATCCACGGCATCAAGTTCGTAGCGAACGTTCCGATGAAGGGATGATTAT +GGCCAGAATCGTGTATCACAACGGCACCAACTCTGGTGATATACTTCCCGCTGCCACCTC +AAGCTCTGCGCACGCGACAAACGGGTGGAACATTAAGACTGGACGCCCACCGAGTTTAAG +CTGGGTCTTGGTAAGTGCGGTCTGGAAGTGGCGAGTCTAGTGTGGGAAGAGAAGTCTGAC +CGCTATGTGTTGACTCAACGCCACACCGACGGAAGCCGAAAGGTCTTTGAGTACAAGAAG +GAAGACGTGCAAGGAAGAATCGAAGTGTTCTACCCTGCCGTTAAATAACCCTCACTAACG +GGAGAGTTAGCCTCAAGGTCATCACCGACGGTGGCCTTTGTGATTAACTTTCAATACACA +TCAACATGAGGTAAGATACTATGCGTACCAACTTTGAGAAATTTACCAAGCGCGATTCAG +TGGTCAACGAGCATGGCGAACAGTGGCAAGAGCGCCGTGACCGCATGAAGAAACGCCACA +AGCAACAGCGCGGTAACTCACAGAAACGGGAGTGGAACTAATGATGATGGGACGTATCTA +TAGCGGCAACCTGAACGATTACAAAGATGCGGTAGCGCGTCCACAGGAAGACCATGACGT +GACCGTGAAGGTGGAGTCATTCAGCTATGAAAACCCAGCGAAGATGTGCAGGTCATCCGG +TGAGGTTCTCCGTGTGTTCACACGCTCCGGTTCAAGACCAACCCATTCAAAGCTGTGTCA +TTCGTAGAGTCTGCCGTTAAGAAAGCGCTGGAGACCTCCGGCTACCTGATTGCGGACATT +AAGTATGATGGCGTGCGTGGTAACATTGTGGTTGACAACGTGGCTGAGGCCGCATGGCTG +TCCCGTGTGTCCAAGTTCATCCCGGCGCTGGAACATCTGAACGGTTTCGATAAGCGCTGG +CAACAACTGATGAATGATGACCGCTGTATTTTCCCTGATGGCTTCATGCTGGATGGCGAA +CTGATGGTTAAGGGCGTAGACTTCAACACAGGGTCTGGCCTACTGAGAACCAAGTGGCTC +AAGAAGAACAACTTCATGTTTGACCGTGGTGGTGTTGAGCCACTGAAAGGTTCCAAAGTA +GCCTTTGAGTTAGACCCCAAGCTACTCAGTGTTCGCCTGTATGCTGTCCTTCCGATTCAC +ATTGCGGAGTCTGGCGAGGACTACGATGTACAGAACCTACTGATGCCATATCATGTGGAA +GCCATGCGCTCTCTTCTGGTTGAATACTTCCCGGAAATCGAGTGGCTTATCGCTGAGACC +TACGAGGTCTACGATATGGATTCGCTGACTGAACTGTACGAAGAGAAGCGTGCCGAAGGT +CACGAGGGTCTCATTGTGAAAGACCCACAGGGCATCTACAAGCGAGGCAAGAAGTCTGGC +TGGTGGAAGCTCAAGCCTGAGTGTGAGGCTGATGGTATCATTCAGGGTGTCAATTGGGGA +ACCGAAGGTTTAGCCAACGAGGGCAAAGTGATAGGCTTTAGTGTGCTTCTTGAGACTGGT +CGTTTAGTAGACGCCAACAACATCTCTCGCGCACTGATGGACGAGTTCACAGCCAACGTT +AAGGCACACGGTGAAGACTTCTACAACGGGTGGGCCTGTCAGGTCAACTACATGGAAGAG +ACCCCGGACGGCTCCCTGCGTCACCCTAGCTTCGAAAAGTTCCGAGGCACTGAGGACAAC +CCTCAAGAGAAAATGTAACCAACTCACTGGCTCACCTTCACGGGTGGGCCTTTCTTCGTT +CGTTAATGCTAAGTGCTTGTTATGCAAAGGCAAAGTCGGACTTGAGAATGTCTTGTAGGT +TCAGCTTACCTTTCTTCGGAAGTGGTGGCATCTTGTCCAGTTGGGTCTCATGAAGCTGGT +CTGCAAACTGGTCGTAGAATAGGGAATTAACCCTCACTAACAGGAGACACACCATGTGGC +TTATCCTATTCGCTATCGTCGCAACGCTGGGATTAATGGTTGCCGACGACGACATTTGGC +CTGATTGTTAAGGAGACAACATCATGCGTTTACACTTCAACACATCAAATGGTACCTTTT +CGGTTCGCCGTGAAGACCGCTCTACAGCAGTGGCCTCTGAGCGCAACGCTAAGCTGCCGC +TGATTGGCTCGGTCGTCCCATTGTCGCCTCGTGTTCACCTACTGATCACTCGTGGAGAGT +TCATTAAGGCGATGAACAAAGAGCGCCCGCATCTGGAAGCCGTGGTCACTTGTTGGCCTC +GCATCCGTCTGTTCGTTAAGTGGATTAAGGAGGTTCTGTAATGTTACAACATCATTGGAA +CAAACCAGATTTAGAGGCTCGCTTCCCGGTTAACTCTGCTGTGCGATACTCCGGCGAATT +CCTCAAGCGCTTCTTAGGTATGAGCGGAGTGGTCACTGGTCACTCGAACACAGGTCGCGT +TAAGGTTCGCTTCGGTAATCAGCACGCTGAGTTTCTTCCGAACAACCTGATTCCGCTGCC +TAAAGATGACGTTAAGACTCCGAACGTGGAAGCACCGAAGTCAGAAGTCAAGTCTGACGT +AACCCACCCTAACCACTACATGCTGTTCGACAACGTGGAAGCCATTGAGGTTATAGCCCG +GTCAATGACCGTCGAGGCGTTCCGTGGGTACTGCCTTGGGAACATCCTGAAATACCGTCT +TCGTGCTGGTAAGAAATCCGAACTGGCAACTATGGAGAAAGACCTCAATAAAGCTGCATT +CTATCAGGAACTCTTTGACAAACATAAGGGGCTGTGCTATGACGCTTCGTGAATGCTGCG +ATTGGTGTGCCGCTAAGTGGAACCAAGCTATTGAGGATGGTGACAAGGCGGCTGCTGACG +CTTACCAACAACTGTACGCGCTGTGGGAGCGGCGCTTTAAGGAGGCTCAAAGTGGAGCAA +CGTGAACAGAAATACCTTCTGACGATAGAAGGCAACACCGAGTCCTTTGAGGTTCCGGTA +TTCGCCCGGTCTCTCGAAGAGGCAACGCTACAGGCTGAACATTATGAGGACGCTGGGTTC +GTAGTGACTCGCATCCGTCCAGAAGTGAAAGCCTAATTACCCTCACTAAAGGGAACAACC +AAATCATTAACCACAAAGGAGAAACATTATGGCTGGTTTCAAGAAGAAAATCTACACCTC +TGGTCTTGGCACTGCTGAGCCTTATGCTTACCTGAGTAAGCCGGATTATGGCAACGAAGA +GCGTGGCTTCGGCAACCCTCGTGGTGTCTATAAGGTAGACCTGACTCTTTCCAATAAAGA +CCCGCGCTGTCAGGCGATGGTCGATGAAATCGTGAAGACTCACGAAGAGGCTTATGCTGC +TGCCGTGGAAGAGTTCGAAGCTAACCCGCCGCAGGTACAGCGTGGTAAGAAACCACTGAA +ACCTTACGAGGGCGACATGCCGTTCTTCGATAACGGTGACGGTACGACTACCTTCAAGTT +CAAATGCTATGCGTCTTTCCAAGATAAGAAGACCAAAGAGACCAAGCACATCAATCTGGT +CGTGGTCGATAGCAAAGGTAAGAAGATTCAGGAAGTGCCGATTATCGGTGGCGGCTCCAA +GCTGAAAGTGAAATACTCTCTGGTTCCTTACAAGTGGAACACCGCTGTGGGCGCAAGCGT +CAAGCTGCAACTGGAGTCCGTGATGCTGGTCGAACTGGCTACCTTCGGCGGTGGCGGTGA +ATATGAGTGGGCTGATGTAGTCGAAGATGGTGGTTACACTGCGAGTGAATCCCGTGAGTC +CCGCGATGAGCAGGAGTGGCAGGAAGACGAGCACGAAGAAACCCCGGATGATAACGAGGA +CTTCTAATGGCTGGCGCATACGCTGCGCGAGGTGTACGCAAGGTTGGGGCTTTCCGCTCC +GGCCTAGAAGATAAAGTCTCAAAGCAGCTTGAGAGTAAGGGAATTAAGTTCGACTATGAG +CTTTGGCGTATCCCTTACGTCATCCCTGCGAGTGACCACTTATACACTCCAGACTTCCTG +CTACCTAATGGCATATTCATTGAGACCAAAGGGCTGTGGGATTCCGATGACCGCAAGAAA +CACCTTTTGATTCGTGAGCAACACCCTGAACTGGATATTCGCTTGGTCTTCTCAAGCAGC +CGCTCAAAGCTCTACAAAGGTAGCCCAACAAGCTACGCCGAGTGGTGTGAGAAGCATGGC +ATTCTGTTTGCTGACAAGCTAATTCCGGTGGAGTGGCTCAAAGAACCCAAGAAGGAGGTT +CCGTTCGATAAATTTAAGACTAAGAAAGGAGTAAAGAAAAATGGCTAAAGTTCAATTCAA +ACCACGAGAAACCACGGAGGCAATCTTTGTACATTGCTCAGCAACCAAGCCAAGCCAGAA +CATTGGCGTTCGTGAGATTCGTCAGTGGCACAAAGAGCAGGGCTGGTTAGACGTAGGATA +TCACTTCATCATCAAGCGTGATGGCACTGTGGAAGCAGGCCGCGATGAACTGGCTGTAGG +TTCCCACGTGAAAGGTTACAACCACAACTCCGTAGGGGTATGCCTCGTGGGTGGGATTGA +TGATAAAGGCAAGTTCGACGCCAACTTTACACCTGCGCAAATGCAAGCGCTGCGTAGTCT +GCTGGTCACGCTGCTGGCGAAGTATGAGGGTTCAGTCCTTCGTGCTCACCATGACGTTGC +ATCCAAAGCCTGCCCGTCCTTCGACTTGAAGCGCTGGTGGGAGAAGAACGAACTGGTTAC +ATCTGACCGAGGGTGATACCATGAGGATGATTTGTATTCGCTGTGATAAGCCGTTGAAGA +GTCGTGTACCGTCACGTCAGTGTCAGTGCAAAGACCCAATCAAGGCGGAGGAACACACCG +AGGAATAATTAACACTCACTAAAGGGAGACTTAACGGTTTCCCTTTGTTCGCACTATTGA +TTAAGGAATGTACAATGGAACGAGAAGACGTTAGTATCTTTCTGTTTCATGCTCCATGTG +AAAACTGTGGGTCTTCTGATGGTAACTCTGTGTACTCTGACGGGCATGAATGGTGCTTCG +TGTGTGAACATCGAGTACCCGCAAACGAAGAGCGTGAAGCAAAGTTATCAACGAGAAGAC +GTACAGGAGGCAGCAAGCCTATGAGCTATGACGTATGGAATTTCGGTGACAGCAACGGTC +GATACTCTGACCTAACTGCCCGTGGCATCTCGAAGGAGACATGCCAAAAGGCTGGCTACT +GGCTGGCGAAAGTGGACAACCGAATGTATCAGGTTGCCTACTACCGAGACCAGAACGGCT +CCATCGTGTCGCAGAAGGTGCGCGATAAGGACAAGAACTTTAAGACCACCGGAAGCCACA +AGAGCGATGCGCTGTTCTTGAAGCACCTCTGGTCTGGCGGTAAGAAAATTGTGGTCACTG +AGGGCGAAATTGATGCGCTCACTGTGATGGAACTCCAAGACTATCTTGATGCTCGACATG +GATGACGCAGGCCGTAAGGCAGTCGAAGAGGCCGCACAGGTTCTCCCGGCTGGTAAGGTT +CGTGTTGCCGTGTTGCCGTGTAAGGACGCCAACGAGTGTCACATCATGGGTGAAGACAAA +GCAATCTTGGAGCAAATCTGGAACGCGAACCCTTGGGTGCCTGACGGTGTTGTTTCTGCG +TTGTCACTCAAAGACCGCGTTAAGGAAGCTATGACCTCCGAGGACGCTGTAGGTTTATTA +TTCGATGGCTGTCAAGGCCTGAACGATAGAACCTTGGGGGCTCGTGGTGGCGAAGTCGTT +ATGGTCACTTCCGGTTCCGGTATGGGTAAGTCAACGTTCGTTCGTCAACAGGCTCTGGCT +TGGGGCAAGCGAATGGGTAAACGTGTGGGCCTAGCGATGTTGGAGGAATCCGTTGAGGAT +ACCATTCAGGACATGATGGGCTTGAACAATAAGGTTCGTCTGCGTCAGTCTGATGAAGTC +AAGAAGGCTATCGCAGAGGACGGACGTTTCGATGAATGGTATGATGAACTATTTGGAGAC +GATACGTTCCACCTTTATGACTCCTTTGCGGAGGCCGAAGCTGACAGGCTGTTAGCGAAG +CTGGCCTACATGCGAACAGGCTTAGGGTGTGATGTTATAGTGCTCGACCACATATCAATC +GTCGTGTCTGCCTCTGAGGAGTCGGATGAGCGTAAGATGATTGACCGCCTCATGACGAAG +CTCAAAGGGTTCGCTAAGTCAACTGGTGTTGTGCTCGTAGTGATTTGTCACTTGAAGAAC +CCGGAGAAGGGAAAACCACATGAAGAAGGACGCGCTGTTTCTATTACTGACCTACGTGGT +AGCGGTGCCTTGCGTCAGTTATCTGATACTATCATCGCCTTGGAGCGTAACCAGCAAGGT +GATATGCCTAACTTGGTGTTGGTTCGCCTGCTTAAGTGTCGTTTCACTGGCGACACTGGA +ATTGCTGGGTACATGGAATTCAACAGAGAAACCGTGCGATGGAATCATGTACCACTAATT +AACCCTCACTAACGGGAACAACCATTAAACCATAGGAGACACATCATGTTTAAATTCATT +AACGCTTTAGGTAAGCTGGTAGTTAAACTGTACTTCATCGAAGCCAAGAAGCTGGACAAG +AAGGCCAAAGCTGATTCACAGCGAGCCATTGAGTTGGCGAAACAGTCCCGTGAGAAATCC +GATGCGGCTGTTAGTGGCATCCACAAGTCGGCAGCGATTGCAGCCAAAGCACAATCCATG +AGCAAATTCTTTGAGTAAGGAGCGCACACTATGAGCAAGTCAATCACCCACGCAAACACC +ATGCGTCTGCCAGACACCGCTGACCAGTTCTCCCGCCGAGTACACATCAATGTGCGTGGT +GAGAAGGTCACGATGGTCTACCGCTGGAAAGACCACAAGTCTCCGAAAGCACACACTCAA +CGAATGACCTTGGATGACAAGCAGGTCGTGTATGATTTAGAGCTGGCCGGTGGTAATTGG +CACTCAAACCGGTCGCTTGATGGGTGCCCTGACTATGGCTGCTGACAAGGTGGTCGGTGA +TAACCGTGAGCGTCTGGTAGAGTTCGGCGCTGGTATGCAAGAGATTATCGAGAAGTGATA +AACTCAAGGTCGCCCAAGGGTGGCCTTTATGATTATCATTTAGCACGAAACCAAAGGAGG +GCATTATGCTCGTAAGTGACATTGCGGCCAACAACCTCTTAGAGAAAGTCACCAAGTTTC +ACTGTGGCGTTATCTATGACTACCGTGATGGTGAGTATCATAGCTATCGTCCGGGCGACT +TCGGGGCGTATCTGGATGCGCTGGAAGCCGAGGTGAAGCGAGGTGGGCTTATTGTTTTCC +ATAACGGTCACAAGTATGACGTTCCGGCTTTAGAGAAACTCGCAAAGCTGCAACTCAATC +GTGACTTCAAGTTACCCCGTGAGAACTGTATTGATACATTGGTACTCTCGCGTTTACTTC +ATGCGAACCTTAAAGACACAGACATGGGGCTTCTTCGCTCCGGGAAACTACCCGGTCGTC +GCTTCGGGTCTCACGCTCTGGAGGCATGGGGCTATCGCTTGGGTGAGATGAAAGGTGAAT +ACAAGGACGACTTCAAGGCTATGCTGGAAGAGCAGGGCGAAGAATATGTTGATGGTGCTG +AGTGGGTTTCGTTCAACGAGCCGATGATGGCGTATAACGTTCAAGACGTTGTGGTCACTG +TCAAACTCTTAGAGAAATTCCTTACAGACCTCCACTACTTCCCTGCGGGTATGGACTTCA +CGAAGTACGATGCGGATTGATTCTGGCGAGAAGCTGGCGAGTCTGTGGATATTGAACATC +GTGCAGCGTGGCTTTGAGCGAAGCAGGAGCGTAACGGCTTCCCGTTCAACACCAAGGCAA +TTGAGGAACTTTATGTAGAACTGGCAGCGAAACGCGCCGAACTTCTGCAAAAGCTAACCG +AAACGTTTGGCTCATGGTATCAACCGAAAGGCGGTAAGGAACTCTTCAAGCACCCACGGA +CAGGCAAGCCGCTGCCGAGCTATCCTCGCGTGGTCTATCCGAAACAGGGTGGCGTGTACA +AGAAGCCTCGTAATAAGGCACAGCGCGAAGGTCTTGAACCTTGCGACTTGGACACGAGGG +ATTACATGGAGGGTGCTCCATATACTCCGGTAGAGTTCGTTACGTTCAAGCCAAGTAGCC +GTGACCACATTCAGAAGAAACTACAGGAGGCCGGATGGGTTCCTGAGAAGTTCACCGAGA +AGGGTGCGCCTGTGGTGGACGATGAGGTCTTGGAGCATGTACGAGTAGATGACCCTGAGG +ACAGCGAAATAGCGGAGGCCGCATTCGTCGACACAGGTTGTTAAGGGCCGGTATGCCTGA +GAAGAGGTACGAACAATGGCTTGGCGATAATTCTAAGAGCATCTTATCATGCCGTAAAGC +CACGAAATAGTTTCCTGTGTATCAGATCATTGGCGTCGACACCTCCGCGCGAACGCCTAG +ATCAGTTAATAATAACCAGAAGCAGGCGTGCATTGACTTGATTAAAGAGTACCTGATGAT +TCAGAAGCGAATCGGTCAGGCGGCAGAGGGTGACAAAGCGTGGTTACGTTATGTTCAAGA +TGATGGTAAGATTCATGGAGCCGTTAACCCTAACGGTGCAGCTACTGGTCGTGCTACTCA +TAGTTTCCCAAACCTTGCACAAGTACCCGGCGTTCGTTCTCCTTACGGGGAGCAGTGTCG +TAGCGCTTTTGGTGCTGAACATCATTTGGATGGGATTACTGGCAAGCCGTGGGTGCAAGC +GGGGATAGACGCCAGTGGCTTAGAGTTGCGCTGTCTGGCACACTTCATGGCTCGTTTCGA +TAACGGAGAGTATGCGAATGAGATTCTCAACGGTGACATTCACACCAAGAACCAGAACGC +TGCGGAACTCCCAACGCGAGACAACGCCAAGACCTTCATTTACGGGTTCCTTTACGGAGC +AGGAGATGAGAAGATTGGTCAGATTGTTGGGGCGGGGAAGGAGCGCGGGAAGGAACTCAA +GAAGAAATTCTTAGAGAACACCCCGGCGATTGCAGCGCTACGAGAAGCTATCCAACAGTC +TCTCGTTAAGTCTTCCGCTTGGATTGGCGCTGAGCAGAAAGTACAGTGGAAGCGCCGTTG +GATTAAAGGTCTGGATGGTCGCAAGGTTCACGTCAGGTCTCCACACGCAGCGCTCAACAC +ATTGTTGCAGTCTGCTGGTGCTCTGATTTGTAAGTTGTGGATCATCAAGACCGAAGAGAT +GCTCATTGAGAAAGGCTTGAAGCATGGCTGGGATGGTGACTTTGCGTACATGGCTTGGGT +TCACGATGAGATTCAGGTGGACTGCCGTACAGAGCACATCGCTCAGATTGTTATTGACAC +CGCGCAGGAAGCTATGCGTTGGGTCGGAGAGCATTGGGCTTTCCGTTGTCGTTTAGATAC +CGAGGGTAAGATGGGGCCGAATTGGGCTGTCTGCCACTAACAATAGGAGAAACATTATGG +CAATGACCAAACACTTTAAAGTAACCTTCGACGTTACCGCTGTGATTGACAGTGAATCCG +AGAAGAATCTGAACGAGTTACTGGTAGACCTAGCTAAGAAGGCCGGGGCTGGCGAGAAGC +TGAATCCGTTCAAACAAGAACTGCTTATTCAAGGCCTGACACACGGGCCGGAAGGTGCTG +CTGCGTTCTGTATCAAGCAAGGTCTCCGTGAGTTTATCCGCGATGGTCACAGTGAGTTAA +GCTCTACCGAGCAGAAGCTGATGAGATTCTCACCTGCAACTGTGCGAGAGGTGTTCAAAT +GAGTGAATACCTGAAAGTTCTGGCAGCTATCAAAGGTTGCCCTAAGTCCTTTCAGTCGAA +CTATGTGCGAAACAATGCGGCTCTCGTAGCTGAGGCCGCTTCTCGTGGACACATTAGCTG +TTTGACTGTGGGCGGTCGCAATGGTGGAGCATGGGAGGTCACAGCCTCTGGTGTGCGCTT +CCTGAAACGAATGGGAGGTTGCGTATGATTATGCCTAAGAGTGACACCGTAACGATGACC +CGTGATGCGTGGAACGATGTTAGCGCGTACATTGATAAGCTGGAGAAAGGCCTAGAGTTC +CTGAATGCGCTTAAGGCGTGTGGTGTGGATAATTGGGACGGAGACTCTGATGCAGTCGAA +ATGGTTTACGGGGAGGATGACGAATGAGCCTAATCACATTGAAAGACTTCGCGGAGATGC +GTGAAGGTAATCCTATGGAGAAGGGAGTGCTGGTCATGGATGGTGACTGGTTGGTATATC +AGTCAATGGCTGCTGCCGATACCAATCGTGTATTGCCAGTATTCGTGGATTCGCTGGTTG +TAAATAAGGTGCTATTAGTCGCGTATGACGGATGATTCCCTCACTCAGTATGGCCCAGCG +CTTAGGCACGGCATTTGGGTGTCCACTTAATCGATTCAGCCCTGTTGCGCGACCATTTTC +TTGAACAGTGACCCAGTAAGTGAAGTTGAGACGGATTGGGGAGACGACATTTGGACTCTT +GAGTGTGACCACGCCAAGGCACGGAGCATTCTCGATTCTGCAATCGAATCGTACCGAACC +CGTAAGAAGGCTTGGAGTGACGCTATGGTTGTTCTGGCGTATACCGACGATGTGAACTGG +CGTAAGGTACTGGTTGATGAGACCTATAAGGAGAACCGTAAGGCGACCCGTAAGCCTGTG +GGCTACCGTGACTTCCTGTCGAAGCTGTGGGAGCGCGATGAGTTCATTCACATCAAAGAG +GACATGCTGGAAGGTGATGACGTTATGGGTATCATTGGGTCTGGTCACGAGGTCTTCGGC +TTCAAGAAAGCTGTGTTGGTCTCCTGTGATAAGGACTTCAAGACTATACCGGACGTTGAC +TTCCTGTGGTGTACCACTGGTAACATCTTGACGCAGACCAAAGAGACCGCTGATTGGTGG +CATCTCTTCCAGACTATCAAGGGCGATATGACTGATGGCTACTCCGGGATTCCCGGTTGG +GGTGACACGGCAGAAGGTTTCCTGAATGACCCGTTCATTGTGGAGCCTGTAGAGTCCGTG +TTGAAGTCCGGTAAGAACAAAGGGCAGACTGTCACTAAGTGGGTGAAACGCGCTCCTGAT +GCGACTGAGAGCCTGTGGGACTGCATCGTATCCATTGGTGCCAAAGCTGGGATGACCGAA +CATGAAATCATTAAGCAAGGCCAGATGGCACGCATTCTTCGCTTCGAGGAATACAATTAC +ATTGACAAGGAGATTTACTTATGGACGCCGCGAAGCTGATTACCACCGTTGTGCTGGTAG +GTATGCTGGCGCGAGGTCTCTGGATGTTCGCTCTCATAGTCCGAGACGTGAAGCGAGACT +CCGAGATTAAGTGATACACTCAAGGCTCTCTGTATTAACCCTCACTAAAGGGAAGAGGGA +GCCTTTATGATTATTACTTTAAGACTTAACCTTAAGAGGTGAATTTATGTTACAACCAAT +TAATCATGTTTTAACTCATCCCGATGATATTCCTAGTATGCCGCGTGCAGCTAAAGAGTA +TCTACAGGTGAGCTTCAATCAGGCTTATGTGATGGAGTCCGGGGAGTACCGTGCGCTCCG +CGCTGCTGGTTACTCTGAGTCTTTCATTGCGGGTGTGATGCATGGTCTGTACCTTGCCTC +TCGAACACTTGATGAGATTGAGGTGCGTAAAGAGCAACTGAGACAGGAGTAACGATATGT +GCTGGAAACCGAAGGTGAAAGTCCCTAAGATGGACACTAACCAGATTCGCGCTGCTGAAC +CAGCACCTTTGACTGAACCTCCGAAGTCTGTGGTATGGGGAGGCGATGATGACGAGGACA +CCAGTGTGTCTTCCTCTGAGGTGCCAACCACACCGAGCAGCGGTAAGAGCAGTCTCAAGG +TAAAGCTGGATGACAGCGCAGCCAAGAACAAGAGAGAACTTGCGGATATCCTTGCAGGTC +TCAATGAAGCCCTCGCTTATCGGGTACTCTTCGGCGGTATCGAAGCAATCCTCCTGAATG +ATTTCCTGTGCAGCCTGAAAGTGGTGACGAATCTTATCACTTTCACCGTAGCACCAGTCA +TTAAGCGGTGTCAGATAGTCCAAGACCACCGTGTAGCAGCCTGTATGACGCTGAATGTCG +TACATAAATCCTCCATTCGCTCCAAGGCGTTTGGGTAACTGAGTCATAGCATAGGGAGAA +ACATCATGGGATTCTTCAAGAAAATCAAGAAGGCCGTTAAGAAAGTTGTGAAAGAAGTTA +GTAGACCAGTCGAGAAGGCCGGTAAGGAAGTGGGCAAGGTGGTTGGAGGCGCGCTGGGTG +CAGGTAAGCAGGAGATTATCCAACAAGAGGCTCCTGTACCAGTAGTCGCTGCACCGCCAC +CAGCACAGGTTGTAGATGTACCGGAACAGGATAAGGCTGAGGGTGAGGATGAGGCGCAAA +CCGAAAGCGCACGTAAGAAAGCACGCGCTGGCGGTAAGAAGTCTCTGAGTGTAGCCCGTA +GCTCCGGCGGTGGCATCAACATCTAAGGAGGACTGAATGGCTGATTCAAAACGTACAGGA +TTGGGCGAAGACGGTGCTAAAGCTACCTATGACCGCCTAACGAACGACCGTAGAGCCTAC +GAGACTCGTGCGGAAAACTGTGCGCAATACACCATTCCGTCCTTGTTCCCGAAGGAGTCC +GATAACGAATCTACCGACTACACGACTCCGTGGCAGGCTGTAGGTGCGCGGGGTCTTAAC +AATCTGGCCTCTAAATTAATGCTGGCACTATTCCCGATGCAGTCGTGGATGAAGCTGACC +ATTAGTGAATATGAGGCGAAGCAGCTTGTTGGAGACCCTGATGGACTCGCTAAGGTGGAC +GAAGGTCTGTCTATGGTTGAGCGTATTATCATGAATTATATCGAATCCAACAGCTACCGT +GTGACACTCTTTGAGTGCCTCAAGCAGTTGATCGTGGCAGGTCATGCACTGCTTTACTTA +CCGGAACCAGAAGGCAGCTACAATCCGATGAAGTTGTACCGATTGTATTCTTATGTTGTC +CCTACTGACGCTATGCCCTACATTCCGGTTCGCATGGTTCGCATTGATGGCGAGTCTTAC +GGTCGCTCCTACTGTGAAGAATACTTAGGTGACTTAAGGTCGCTTGAGAATCTCCAAGAG +GCTATCGTTAAGATGAGCATGATTAGCGCGAAGGTCATCGGTCTGGTGAACCCAAGCTGA +CTTTACCGTAGCGAAAGCTGTGAGTGACCAGATAGAAGCACGCTTATCGTATGCCTTTAT +GTTGAACTTTGCGGTGCAACGAACAGGTGAACGTGTGACCGCCGAAGAGATTCGATACGT +TGCGTCAGAACTGGAAGATACGCTTGGTGGCGTCTATTCGATTCTGTCTCAAGAACTGCA +ATTGCCTCTGGTTCGTGTGCTCTTGAAGCAGCTCCAAGCAACCTCGCAGATTCCTGAGCT +ACCGAAAGAAGCCGGTGAGCCGACTATCAGTACAGGTCTGGAAGCAATCGGTCGTGGTCA +AGACCTCGATAAGCTGGAGCGCTGTATCTCCGCTTGGGCTGCTCTGGCCCCTATGCAGGG +AGACCCGGACATTAACCTTGCTGTCATTAAGCTGCGCATTGCTAACGCCATTGGTATTGA +TACTTCTGGTATCCTACTGACTGACGAGCAGAAGCAAGCACTGATGATGCAGGATGCGGC +CCAAACAGGTATCGAGAACGCTGCCGCCACTGGTGGGGCTGGTGTGGGTGCTCTAGCGAC +CTCAAGTCCAGAAGCTATGCAGGGTGCAGCAGCACAGGCTGGCCTAGACGCCACCTAATA +ACCCTCACTAAAGGGAGACCTCATCTTTGAAATGAGCGATGACTAAAGGTTGGAGTCCTT +TGGTTTCCCTTTATCTTTAACAACTTAGGAGATTTAACAATGGCTGAATCTAATGCAGAC +GTTTATGCGTCCTTCGGTGTGAACAACGCGGTAATGACCGGAAGCACACCTACTGAACAC +GAACAGAATATGCTGAGTCTCGATGTTGCTGCCCGTGATGGCGATGATGCAATCGTACTT +AGCGAGGAACCGAGTTCCCATAACGATGACCCATATGCATCCGGTGTAGACCCGTTCGCT +GATGGTGAAGACGATGAGGGCCGCATTCAGGTTCGTATCAGTGAAGATGGTAATGAAGCC +GAGTTCGACACCGGTAGCGATAACGCTGAGGTGGAGACCGAAGGTGAGGCCGCTGAGTTT +GAACCGCTGGGTGACACTCCAGAAGAACTGAGCCAAGTGACTGAGCAGTTGGGACAGCAC +GAAGAAGGCCTTCAGGCGATGGTCGAGCAGGCCGTTGAGCGTGGACTGAGCGCAGAGTCT +GTGACTCGCATCTACGAAGAGTACGGAGCCGATGGCATCTCTGAGAAATCCTACGCGGAA +CTCGAAGCTGCTGGCTATAGTCGTGCCTTTGTGGACTCCTACATCTCCGGTCAGGAAGCC +CTTGTAGACCAGTACGTCAATCAGGTAGTTGCCTTTGCTGGTGGTAAGGAGCGCTTTAGC +GCAATCCATACGCACCTTGAAGCAACCAACCCGGCTGCGGCTGAGTCCCTTGAGACTGCC +ATGATGAACCGAGACTTGGCGACTGTCAAAGCAATTATCAATCTGGCTGGTGAGAGCTAC +ACGAAGAAATTCGGTAAGCCTGCCAACCGTAGTGTTACCAAGCGTGCTACTCCGGTTAAA +CCTGTAGCTCGTCAGAAAGATGGCTTTACGAATCAGGCTGAGATGATTAAAGCTATGAGT +GACCCGCGTTACCGTAGTGATGCTGCCTACCGTCAAATGGTAGAACAGAAGGTTATCGAC +TCCAGTTTCTAATTAACCCTCACTAAAGGGAGAGACCATAGATGACTACAATGGTTGAAT +CACCTGAGCACAGAACTTTGTGGTCACTCCCGTAGGTGAAACATTGAGAACCAACTCGAT +TCAAGTAGTAACCAAACTTTTCTTTAAATTAACATAAGGAGATTCAACATGGCTAACAAT +CAAGGCGGACAGCAAATTGGTACTAATCAGGGTAAGGGTCAGTCCGCAGCGGACAAATTG +GCGCTGTTCCTGAAAGTGTTCGGCGGTGAAGTCCTGACGGCTTTCGCTCGCACCTCCGTG +ACCATGCCTCGTCACATGCTGCGCTCTATTGCTTCTGGTAAGTCCGCACAGTTCCCTGTG +ATTGGTCGCACCAAAGCTGCTTACCTGAAACCGGGTGAGAACCTCGATGACAGTTGATGC +ATCTGACTCGATAGTTACTATGTTCGTCTGAGCGTTTCCAACAACCGGGAAGCGGTACTG +CCCTGTGCCAATGTTCGACCTGCCAACACGCAGATTGTCAGAACGTAAGGATATCAAACA +CACCGAGAAGGTAGTCCACATTGATGGACTGCTGACTGCGGACGTTCTGATTTACGACAT +TGAGGACGCGATGAACCACTACGACGTTCGCGCTGAGTACACCGCACAGTTGGGTGAATC +TCTGGCGATGGCGGCTGACGGTGCTGTACTGGCTGAACTGGCTGGTCTGGTTAACCTGCC +GGACGCCTCCAATGAGAACATCGAGGGTGTCGGTAAGCCTAGCGTACTGACTCTGGTTAA +GCCGACCACTGGCGACCTGACTGACCCGGTTGAGCTGGGTAAAGCGATTATCGCTCAGTT +GACTATCGCTCGTGCGTCTCTGACCAAGAACTACGTTCCGGTTGCTGACCGTACCTTCTA +CACCACTCCTGATAACTACTCTGCGATTCTGGCCGCTCTGATGCCGAACGCTGCAAACTA +TCAGGCACTGATTGACCCTGAGCGCGGTACTATCCGTAACGTGATGGGCTTCGAAGTGGT +TGAGGTTCCGCACCTGACCGCTGGTGGCGCTGGTGATACCCGTGAGGATGCCCCGGCTGA +CCAGAAGCACTCTTTCCCGGCGACTTCCAGCGCTACCGTTAAGGTTGCTCTGGATAACGT +TGTGGGCCTGTTCCAGCACCGCTCTGCGGTTGGTACGGTCAAGCTGAAAGACTTGGCTCT +GGAGCGCGCTCGTCGTGCGAACTATCAGGCTGACCAGATTATCGCTAAGTACGCGATGGG +TCACGGCGGTCTGCGTCCAGAAGCTGCTGGCGCTATCGTGCTGCCAAAGACTTCGGGGGC +TTAAGGGTAGCGCCTTTGAGTATGAACGCGGAGAGTGAAGTGGAGCCGACCCAAGAGGTA +GCCGCCGAAGTAGCTCTCACGCCTCAACAGAAGGCCGCCATTACTCGTGCTCGTAACAAG +GCACTTAAGTCTCAATAACAACAAGCAAACCCCTTGGGTTCCCTCTTTGGGAGTCTGAGG +GGTTTTTTGCTTTAACCCTCACTAACAGGAGGTAACATCATGCGCTCTTATGAGATGAAC +ATTGAGACCGCAGAAGAGTTATCAGCCGTCAACGACATTCTGGCTTCCATCGGTGAGCCA +CCAGTATCGACCCTTGAGGGTGATGCAAATGCTGATGTTGCAAATGCTCGACGTGTGCTC +AACAAGATTAACCGACAGATTCAGTCACGAGGATGGACATTCAATATTGAGGAAGGTGTG +ACTCTTCTACCGGATGCGTTCTCTGGTATGATTCCATTTAGCTCTGATTATCTGTCCGTA +ATGGCAACCAGCGGTCAGACCCAATATGTCAACCGTGGTGGCTATCTCTATGACCGCTCT +GCGAAGACTGACCGATTCCCATCTGGTGTTCAGGTCAACCTGATTCGTCTGAGAGAGTTC +GATGAGATGCCTGAGTGCTTCCGAAACTACATCGTTACCAAGGCTTCCCGTCAGTTTAAC +AACCGCTTCTTCGGTGCGCCGGAGGTAGACGGAGTGTTGCAGGAAGAGGAACAGGAAGCG +TGGCGTGCGTGCTTCGAGTACGAACTAGACTACGGCAACTACAACATGCTGGACGGTGAC +GCATTCACCTCTGGTCTACTTAACCGCTAATATGTAAGTACCCGGTCGTATCATTAGGTC +ACGGTGCCTCTGCTGCTAAGAAGACATGCGCCGCTAACTATGAATACTTTGACCAGTTCG +AGCAGATACAAGGAGGCTCTATGGCTCTCATTAGTCAATCAATCAAGAACCTCAAGGGTG +GTATCAGTCAACAGCCAGATATTCTCCGGTTCGCTGAACAAGGTAGCGTACAGATTAACG +GTTGGTCTTCTGAGTCCGAGGGTCTCCAGAAGCGCCCACCGATGATTCACGGCTGGCATT +ACGCAGCCACGTAGATTAACCAAAGCTCAGACTGGTGACTTCGTTCCGGGTCGTCGAGAA +GACATTGACTTCCTTCAACTGGAGAAGCCTTAAGACCCTTGGTGCTGCTGGGTATGTGGG +TGCGCAACCTTACGTTCACCTCATCAACCGTGATGAGTTCGAGCAGTATGTCGTGGTGTT +CACTGGTGAAGACATTAAGGTATTCGACCTCGACGGTAAGGAGTACCAAGTACGTGGAGA +CCGCTCATATGTTCGTACAGCTAACCCACGAGAAGACCTTCGGATGGTAACTGTGGCTGA +TTATACCTTTGTGACTAACCGCAAGGTGGTTGTACAGAGTAACGACCAATCGGTCAACCT +TCCGGGCTTTAAAGACCAAGGCGATGCGTTGATTAATGTTCGCGGTGGACAATATGGGCG +TAGACTCTCAATCGAGTTCAACGGGGCTGAGCGTGCTGCTGTACAACTACCGGATGGTTC +ACAACCAGCACACGTTAACGAGGTTGACGGTCAGGCTATCGCTGAGAAGCTGGCTGTGCA +GTTGAGGAACAACCTTGGGAATCCAAACAACGAGCAAGACCCGAATAAGTGGCGCTTCAA +CGTTGGCCCCGGATTCATCCATATCCTTGCGCCAAATAACGATAACGTTTGGGGACTACA +GACTAAGGATGGTTACGCAGACCAGCTAATCAACCCTGTAACCCATTACACTCAGTCGTT +CCAGAAGCTGCCTATTAACGCGCCAGATGGGTACATCGTGAAGATTGTTGGTGATACCTC +AAAGACTGCCGACCAGTATTACGTTAGGTTCGACCTCAACCGTAAGGTGTGGGTAGAAAC +AATTGGATGGAACACAAGGACTCACCTACATTACCACACGATGCCTTGGGCACTTGTTCG +CGCTTCTGACGGGAACTTTGACTTCAAGTACCTTGAGTGGGGTGCTCGTACTGTGGGGGA +CGATACAACCAACCCATACCCATCCTTTACCGGACAGACAATCAACGATATTTTCTTCTT +TCGTAACCGTTTGGGATTCCTTAGTGGGGAGAACATCATCTTGTCTCGCACCTCGAAATA +CTTCAACTTCTTCCCGGCATCCATGTCAAACTACTCCGACGATGACCCAATCGACGTTGC +GGTTAGTCATAACCGGGTGTCAACCTTGAAGTATGCCGTTCCGTTCTCAGAAGAGTTACT +CCTGTGGTCTGACCAAGCGCAGTTCGTTCTGACAGCCTCTGGAATCCTTTCGAGTCGCTC +CGTAGAGTTGAACCTTACGACGCAGTTCGACGTGCAAGACAGGGCACGCCCACATGGTGT +AGGACGTAATGTATACTTGCAGCACAGGTGATAAACTCAACAATGACTGTATTGATGAGC +AATGAACATGCTGTGTGGATGGGACGCTTACACTTCACGAAGAACTCCATAGACATTCCG +GGAGAGCCTTACAGATTATACATCGACGCTAAGAGGAAATACACCATCCCTGCCGGGACG +TATAATGATGATACCTACCAGACGTCCATAAGCCTCGCAACAATTTATGGGATGAACTTC +ACTAGGGGTAGAGTGTCTGTGGTCTTTCCTGATGGGAAGATTGTAGAGATAGACCAACCA +ATCAACGGGTGGAGTAGCGACCCAATACTGAGACTTGATGGAAACCAAGAGGGACAAGTA +GTCTACATTGGGTTCAACATCCCGTTCACTTATACGTTCTCGAAGTTCCTCATCAAGAAG +ACTGCTCAGGACGGCTCGACGGCTACCGAGGATATTGGTCGTTTACAGCTTCGGCGTGCG +TGGGTAAACTATGAGGACTCTGGAGCGTTCACCATCCGTGTGAACAACCTGTCCCGTGAG +TTCATCTACACAATGGCTGGTGCTCGCTTGGGTTACCACTGAACATCATTGGGTGCGGCT +GGGAGGGGAACTACCTTCGTCGTTCTTCTGGCATTTAACTTAAAGTCTCCCTGTGGTGAA +TTAACCCTCACTAAAGGGAGACACTAATAGATACGAGGGGTTAAAGCATTATGTACATTA +CAAAGTGTTTACAAATCCATGCCGACAACTTTCAGCCGTCCATAGAGGACATTCTGGAAG +CTGAGGCACTAGGTGTTGAACCAAAGGTAATTCCTGATGAGAACACTGTGGCAATGCTTA +GCGATAACGCTGTGTTGGCAATCGGTGGCAATCAGGGAGACCGAGTGTGGTTCCTTACCT +CTAAGTACGTCCCACTGTTTACCTTGAAGGAGCGCTTAGAGTTTCGTAGACTTATCATTG +AATATCGTGATATGATGCTGAGCCAGTACGAGTCCATTTGGAATTTCGTTTGGGTACGCA +ATAAGTCACACATTCGTTTCCTAAAGACCATAGGCGCGGTATTCCATAAAGCTCTAAGTA +GCCAGAACAGTGCTGACAAGGCGCGAGTGGCACAGACCGAAGCTGGACGCAGACAGGCAA +TGGAGATGGTCAAAGAGATGAATATCCAAAATGCCAACGCCTCGCTGGAACAACGGGACG +CCCTTGAAGCTGCATCCTCTGAGTTGACTACACGTAACATGCAGAAGGTACAGGCTATGG +GAACCATCCGTGCAGCTATTGGCGAGGGTATGCTCGAAGGTGAGTCCATGAAGCGCATCA +AGCGTATCGAAGAGGGCAACTACATTAGGGAGGCAATTAGTGTCACCGAGAATTACCGCC +GAGACTACGCGAGTATCTTTGCGCAACAGTTGGGACGCACTCAGTCCACAGCGAGTCAAG +TCGATGCAATGTACAAGAGCGAGGCCAAAGGTAAGTCTGGTCTGATGCGTGTACTAGACC +CTCTGTCCATTATGGGTCAGGAAGCTGCAAGTCAATATGCGGCTGGTGGATTTGACAAGA +AGGGTGGAAACCAAGCAGCACCTATCAGTGCCGCCAAAGGAACCAAGACCGGGAGGTAAT +AATGGCTAGTAAACTAAATAGTATTTTAGGCAACATGGCGACTCCCGGTATGGAACGACT +CCGGGGCGTCAAAGGTATGGACTACCGGGCAGCAACCATTCAGGCTGAACAACCAAGAGC +GAGTCTTCTGGACTCCATTGGTCGATTCGCTAAGGCTGGTGCCGATATGTACATGGCGAA +AGATGAACGTGATAAGCAACGAGCCGATGAGCGCTCCAACGAGATTATCCGTAAGCTGAC +CCCTGAGCAGCGCCGACAGGCTATCCAGAATGGTACACTGCTGTATCAGGATGACCCATA +CGCAATGCAAGCCTTGAAGTTCAATACCGGGCGTAACGCTGCGTTCCTCGTTGACGATGA +GGTTCAACAGGCCATCAAAGAGGGTCGCTTCCGTACTCGTGAAGAGATGGAGCAGTATCG +TCACTCACGCCTACAGGAGCACTCGAAGTCGTTCGCTGAGCAGTTCGGTATCAATGAGAT +GGACGAGGAATACCAGAAGGGTTTCAACGCGAATATCACCGAGCGTAACATTGCTCTGTA +TGGGGCACATGATACCTTCCTGAGTGACCAAGCGCAGAAGGGTGCAATCCTGAACTCGAA +GGTTGAACTCAACGGTGTCCTATCTGACCCTGACCTACTGTCTCGTCCTGAGTCCGGTGA +GTTCTTCCAGAACTACATTGACAACTCCTTGGTGACGGGGATGACCGACAATCAGGCTCA +ACAGGTTATCTCTTCGTCCCTGAATGACGTGCTACAGCGTCCGGGTGGTGCCGCCTTCTT +GCAGAACATTGAGAACCGCAAGGTGACTCTTAATGGCGCTACGACTACCTATCGTGAACT +GATGGGTGGTGAGCAGTGGCAGGCAATGATGATTAAGGCACAGCACACTCAATTCCAGAA +CAACGCGAAGTTAACCGAGAAGTTCCGACTGGATATTAACTCAGCGCTTAACCAAGCAGA +CACTGGTAAAGGCTGGGAGACTCTTCAAGGTATCAAGGCCGAACTCGATATGATTCAGCC +GGGTGAAGAGATGACTCCTGAGCGCGAGTGGTTGATTTCCGCACAGGAACAGATGCGCAC +ACGCTTCAAGCAGGAACAGGCTGAGACAGCCAAGCTGATGGACAAGCAACAGAAGACCTT +GAATAAATCTTTGGTCATCGACAAGCAGTTCCAGAAGCGCCTCAACGGTGAATACGTCTC +GACAAACTATAAGGACATGCCGACCAACGAGAACACTGGTGAGTTTACACATAGCGATAT +GGTCAACTACGCGAACCAGAAGTTAGCGGAAATCGAAGCGATGGAGGACAACCTTCGTCG +CATCCGCAACACTGACCATGACCTGATTGCCTCTCTGTATCCTGACAAGGCCGAGTTGTT +CCTGACTATGGACATGTTGGATAACCAAGGTATCGACACGCAGGTACTTATCGACGCTGA +TAAGTCCCGCGCACAGAAGACCAAGGAGATGCAGTTTGAGGATGACCGAGCGTGGGCTGC +TATGATGAACGATTCAACGAATCCTCAAATCAAGTACATGCCTTCGAGTGTCCAAGGTTA +CGCGCGGAAGATTTATGATTCCGTGAAGTACCGGACAGGGAACCCTGACATGGCAACAGA +ACAGGTCGCAAAGTTCCTCTCTGATTCAACGACTACGTTCTCCAGTAGTGATGTTGATGG +CGATACCTATGGTGTCCTGCCGAAGAACATCCTGACTGTTTCGGATGACCCTAAGTCGTG +GGAGCAAGGGAAGAACATTCTGGACGAAGCCATTAAGGGAATCACAGCGGCGAACCCTTG +GATTACCAACAAGCAACTGACGGTGTACCAGCAAGGTGATTCAATATACCTGATGGACAC +AACCGGACAGGTTCGCATTCGGTATGACCAAGAGTTGCTCCAGCGTGAGTACCAGCGTAC +CGCACAGATGCAAGCTGAGGCAGCACGAGAGAAAGCCCTCAAAGAGGCCAACAAGCGTGC +CCCAATCAGCCGTGTACCACAGGCGCGTGAAGAAGCGCGTAAACGTGTCCAAGAGAAACG +GAAGAAGACTCCGAAGTACATCTATGGACGTAAAGAAGACTAACAGTGATAAGGAGGCTC +CATGAGCTACGATAAGAACAAACCTAGCGAGTTCGATGGGTTATTTCAAAAAGCGGCAGA +CAAACATGGGGTCTCCTATGACCTGCTTCGTAAATTAGCATTCAATGAGTCCAGTTTCAA +TCCAAAGGCCAAATCACCAACTGGCCCGAAGGGTCTCATGCAGTTCACCAAGGGTACAGC +CACTGCGCTGGGACTCAAAGTCACTGATGCAGACGATGATGACCGTTACAACCCGGAGTT +GGCTGTGGATGCAGCCGCTCGTCACCTGAGTGACCTCATTCGTAAATACGATAGGGATGA +GCTTAAGGCAGCCCTAGCGTACAACCAAGGCGAGGGAAGAAATGGTGCCCCTCAGATGCA +GGCCTACGACAAAGGTGATTGGGCCTCAATCTCTGAGGAAGGTCGTAACTATATGCGTAA +CCTGATGGACGTAGCTAATAGTCCTCGCAAGGGGGACTTGGAGGCGTTCGGCGGTATCAC +CCCAAAGGCTAAGGGCAAGCTATGAATATCATCACCCTTAAGTCCCACGTTAGGAAGCTC +TTCATTGCGATTCTGACGGTTCGGAAGCCACTGGTAATGCATTGGGGCTTTCTCGAAGTC +CAGACCGCACACGATAGCGTCACGGAGGCGTAAGGGGTACTTCTCGGCATCACTCAGGTT +CGGGTTGAGCATGAACTGCAAAGTGAAGCCAGCCTTACCGTATTCCAACTCACGCTCACG +CAGGTCTTCCATATCGAAGCGCACGGGGTCAGTCGGTTGACCTTGGAGCATCTTCCATCG +GGGGATGCATTTGCTGGAATCGGGAAGAAGCAGACGGTAGGCACTGACCTGCCGGAGTCA +ACGGGATTCAAAGTGGAGGGTAAAGAGCAGCAAGCGCCTAACGTTCCTTATGCTAAGGAC +TTTTGGGAAAAGACTGGAACAACACTGGACGAGTTTAACTCACGCTCTACCTTCTTCGGA +ATTGGCGATGCAACAAGTGCGGAGCTTCATAACTCTGTACTTGGAGTTGCTTTCCGTGCA +GCCCGTAGCGACGATGGTTTTGATTTGTTCAAGGACACCATTACGCCTACCCGTTGGAAT +AGCCATACGTGGACTCCAGAAGAGCTAGAGCGAATCCGTAAGGAAGTGAAGAACCCCGCG +TACATCAACGTAGTCACTGGAGGCTCTCCTGAGAATCTGGACGCCCTCATTAAGATGGCG +AATGACAACTATGAGATGGATGCGCGGTCTGCCGGTGCTGGTGTTGGCGCCAAACTTACT +GCTGGTATCATCGGCGCTGGTGTAGACCCGCTGAGTTATGTACCGCTAGTAGGCGTAGCC +GGGAAGGGTCTCAAGGTGGTTAACAAGGCTTTCATTGTGGGTACTCAAAGTGCTGGCCTC +GCGGTTGCCTCTGAGGGTCTCCGTACATCAATCGCTGGTGGAGAAGCCCACTATGCTGAT +GCTGCTTTAGGTGGTCTCTTGTTTGGTGCTGGTATGAGCGCAATCAGTGATGCTATCGCT +GCTGGTGTTCGCCGTTCCCGTGGGACTGAGGTAGTTAATGACTTCGCTCCTATGGCACAC +CGCTTGGAAGCCCGTGAGACCGCTCTGAACACTGGTGGGGAAGACCTGACCCGTATGCCT +AGCGAGAACCGTGTGTTCGACCGTGAGCACGCTGGCGTTGAGTATTCACCTCTGGAGACC +GAGCCGGGTGCCGTTGTGTTGCCTCAAGGTCAAATCCTGAGCGACACCAACCCACTGAAC +CCTCAGACTCTTAGCGAGTTCGAGGCGGTCAACCCTGAGCGTGCCGCTCGTGGTATCTCT +TTGGGTGGTTTCACTGAGATTGGCTTGAAGACTCTCCGCTCTGAGAACCCGACTGTTCGC +TCCATTGCGAGTGACCTTGTGCGTTCTCCGACAGGGATGGAATCAGGCTCTAATGGTAAG +TTCGGTGCGACTGCTTCTGACATTAAGGAGCGGCTCCACGCGAACAATCAGCGCACCTAC +AATCAGCTTTATGATGCTGTGCGTACTGCAATGAAAGACCCTGAGTTCTCCACAGGTGGT +GCCACAATGAGCCGTAAGGAAATCCGACAGGAAATCTTCAAGCGTGCAGCCTTGGCGATT +GAGCGACCTGAGCTTCAGGCAAACCTGACAAAGGGTGAGCGGAACGTGATGAACATCCTC +AAGCAGCACTTTGACCTCAAACGTGAAATCATGGAGAACCCGTCAATCTTCGGCAACACC +AAGGCGGTCAGTATCTTCCCCGGCTCACGCCACAAGGGAACCTACGTGCCAAACGTGTAC +GACCACGCTATCAAGATTGAGATGGTTAAACGTTACGATAATGATGGCTTGCAGCGAGCA +ATCGCGGAGTCATGGTTGACGTCTTATCGTGCTCGTCCAGAAGTCAAGGCGAGGGTCGAT +GAGTACCTGGTGGAACTTAACGGTCTCAAATCCGTGCAGGAAGTTACGCCTGAGATGGTG +CAGAAGCACGCGATGGATAAGGCGTATGGTATTTCACACACTGACCAGTTCTCTGCCTCC +TCTGTCATTGAGGATAACATTGAGGGTCTGGTGGGTATCGAGAACAACAACTTCTTGGAA +GCCCGTAACATGTTCGACAGTGACATGGCGGTGACTCTCCCTGATGGTAACACGTTCTCT +GTGAATGACCTGCGTACCTATGACATGGCTGAAATTCTGCCTGCATACAACCGACGAGTA +GATGGTGATGTTGCAATCATGGGCGGTTCCGGTAAGACTACCAAAGACCTGAAAGATGAA +ATCATGGCGCTGGATAAGCAGTCAGAGGGTAACGGCACACTGAAAGGTGAAGTGGAAGCT +CTCAAGGACACCGTGAAGATTCTGACTGGTCGTGCTCGTAGGAACCCGGAAGGCGCTTGG +GGTACAGCCCTGCGCTCCGTAAATGACCTCACGTTCTTTGCTAAGAACGCCTATATGGGC +GCACAGAACGTTACTGAAATCGCTGGTATGCTGGCGAAGGGTAACGTCTCTGCGATAACT +CATGGCATCCCTATGATTAACGATTGGGTCAACCGTGGTAAACCGCTTCGTGCCTCTGAG +ATTAAGGAGATACACGGGATGGTGTTCGGTAAGGAACTAGACAAACTAATCCGTCCGGGA +CGTGAAGACCACGTGCGCCGACTCCGGGAGTCTACGGACACCAGCGCTGCGGTTGCCAAT +GTGGTCGGTACGATTCGTTTCGGCACTCAAGAGTTGGCTGCACGCTCTCCTTGGACAATG +CTCCTAAACGGAACATCAAACTACATTCTTGATGCTGCCCGTCAGGGTGTGCTTGGGGAT +GTGGCTGGAGCGGCCCTTGCTGGGAAAGCCTCTAAGTTCGGTAAGGCAAACTACCTTAAG +TCTGCCTCTATCAGCCCTGAGCAGTGGAATGGAATCAAGAAGTTGTTCAGAGACCATGCG +ACTCGTAGAGAAGACGGTAAGTTCACCATTCGTGACAAACAGGCTTTCGCTAACGACCCA +CGTTCAATGGACTTGTGGCGACTGGCTGACAAGGTGGCGGATGAGACTATACTGCGACCT +CACAAGGTTTCCTCACAGGACTCCAAAGCGTTCGGTGCAGGGGTGAAGATGGTGATGCAG +TTTAAGAACTTCGTCATCAAGTCCCTTAACTCCCGGTTCGTCCGTAGCTTCTACGAGGCA +ACTAAGAACAACCGTGCGTTAGACCAAGCGTTGACTCATATCATCTCCTTGGGTCTAGCT +GGTGGTTACTACGTTGCGCAGGCGCACCTTAAGGCCGCAAGCCTACAGGAGCACAAGCGT +AGAGGCGGGTAACCCGATTAAACGCAAGGGAGGCTGGCGAGGATTTGGATTACTCTTAGT +CTTGCATGATATTCAACGACGCAGGCAAAATTCACGCGCTGAAGTACTCCGAAGCGGCAG +GCCGTCGCTGTTGACAGAGTAACTGTTCACAAAAACGATCATTGCACTCCTAGTGTTATG +GGAATGCCTTCTGTAAAGAGCATGGACTACCTTCTCAGCATGACCTAAGGTGAGGAGTAC +CTTAAGAACGCACTTGACCCTAAGATGATTGCTCATGCGTCAATCTCTCGTAGTTCACAC +TTAGGCTCACCATTGAGTATCTACGACATGTTCGCTGGGATGGTTGGTAGCGATACCTAT +AAGTACACCCGCTCTACTGTGCTCCCTAAAGAGTCCGAGAAGCGTGACCCTAACAAGGCA +ATGACAGGTAGACAGGTGGCTTCAACTATCGCGGGTGCAGTTGGTGAGCAGGTTCCGGGG +TTAGGTTTTGTGGGTTCTGTGGGTGCAACAGCAATTAACGCAGCTTCCCTGCTATCTTCT +CCCAACAAGGCAACCGCTCTGGAGTTCCGTACAGGCCTCTTCAACACCTCTCGTGAGTTG +ATTCCTAATGACCCGCTATCGCAGCAACTCATTATGAAAATCTACGAGGCCAACGGTATC +CGCATAAAGGAGACGCCGAAGAAAGAATAAACCCTCACTAAAGGGAGAGAGGTCACATTC +TGGCCTCTTCTCTCTTAATGCCAATTTACAAAGGAGGTCACATGGCTACAACTATTAAGA +CCGTGATGACTTACCCGCTGGATGGCTCCACTACGGACTTTAATATTCCGTTCGAGTATC +TAGCGCGTAAGTTCGTCAGAGTGACCCTTATCGGTGTTGACCGAAAGGAACTCATCTTGA +ATCAGGACTACCGTTTTGCGACTAAGACCACAATCTCCACAACGAGAGCATTGGGGCCAG +ATGACGGTTATAACATGATTGAAATCCGTCGATTTACCTCCGCTACCGATAGGCTGGTTG +ACTTCACCGATGGTTCAATCCTTCGGGCATACGTCCTGAACATCTCTCAGGTCCAAGCCC +TTCACGTTGCTGAGGAAGCACGTGACCTTACCGCTGATACTATTGGCGTTAACAATGATG +GGAATTTGGATGCTCGTGGTCGCCGTATCGTTAACGTAGCTGACGGAGTTACTGATGGTG +ACGCCATCTCTGTAGGTCAGGTTAAACGTATGAACCAGAACTCGTGGCAAGCACGTAATG +AGTCCTTGCAGTTCCGTAATGAAGCAGAAGGTTTCCGCAATCAGGCCTCTACGAGTAAAC +AGGCTGCTGCTACCTCTGAGTCGCAATCATGGAATCATTCTGAGCGCTCTCGGACATTCG +CTGAGGCAGCTCAAGGTTCTGCTAACTCTGCGGGACAGTCAGCTACCAATGCGAACAACG +CTATGCAGTCTGCTGGTCAATCAGCCACGAATGCTAGTAACTCTGCTGCTCAGGCTAAGG +CCTCTGAGGTTAACGCAAAGGCCTCTGAGGTTAACGCTAAGCGTGATGCTGACGCGGCCC +TGCTGGCTCTGCAATCCACTGGTAACGTACCTGTGGGTACAGTCGCCATGATTACCCACA +CCAAGATTCCTACTGGTTGGGTGCGTGCTGATGAGGACTTCGACGTTAATACTTACCCGG +CGTTAGCTGAACTGTTCCCTAGTGGTCGTACTCCTAGCTTCGATGACCGCTATCCTATTG +GTAACTCTACCGTATTGACTCCGGGTCAGCTTATTGACCAATCAGTACCCGCCCACAGTC +ACACCTTCGACGTGCCTGTCAACGTGTCAGGTGCTACGGCTGCTGGTGGCGAATATCGCG +CCAGAACGTCATGAGTTTACCGCTGATGGTCAATTCCAATTATTCACTATCAGTAGGAGG +TAACTATGTGCTGGATGGAAGCGATTCCTATTGCCATGATGGGTGCCCACACGAAGGGGA +TCACAGTCATGGGTTCTCATTGCCTATCCAGAACAACACTGCTGCTTATACTGGTCGTCT +GGTTGGCGGTGGCAACAACCCTAACTACCCGCAAGACCTGCGCTTTAACACTGGTGGCGG +TGGTGCTCACAGTCATGAGTTCTATGTTCCTTCACACAGTCACACGTTGAATGCATCTGG +GCGTGCTGCTGGCTCCGTCTCTTCGTCAGGTATTGGAAACTCACCGTATGTCCGTCCGTA +TTCCACTGTGGTCATCTTCATCATCAAGGCCGCTCAAGGTGTTGACGATAAGGACGCAGC +AATGCAGGTGATGGGCACTGTGGTTGGACGAGTGGACGCTCTGGAGAACTGGCAGAAAAA +CTTCAAGTCCGTTGTTGAGAACGGTTCACCAACCTCTGGAAACGGCGGGCCTTGGGAACG +TACTGTGTACACTGCCCAGACTGGTGGCTTGAACCGTCTAGCTACACTGGCGAAGAAGGA +GAAGGAGATACTGGCTGGACTGAACAAGACGGACAATCAGACTTCTAAAGGATGCCCGTG +TGGGCATTCCGATGACTTCGGTCTCAACCGCTGGCGCACGCTGAGTGGTTCGTCATGGGG +AGAAGTAGTCAACTTACTTAATAGCTCCGGCGTACTTAAAGGGTATCCGCAACGACTTGT +TGTTGACTTCACGGTTGAGGTAATCGATAGCTCTGACCTAATCGCCAAGGCTGGTATATA +TAGTCCATGGCTACACGATTGTTGTATGGTACTGATGGCGGTCAACCAGTAGTTGAGATT +GGTGCCTTCAAGGATGGTTCTGACCAGCAGACGGCAAACGTGCCAGTTAAAGTAGGCTTG +CGCCTCGTTCACGTGTTCTAAGGAGGACATAATGTTATCACTTGATTTCAACAACGAGGC +CATTAAGGCTGCACCCATTGCGGGTGTGGCTGGTGCTGATGGTGTGGCCCGCCTGTTCTG +GGGGCTTTCTCTCAACGAATGGTTCTACGTTGCAGCTATCGCCTACACAGTGGTTCAGAT +TGGTGCCAAGGTGGTCGATAAGATTATTGATTGGAAGAAAGCAAATAAGGAGTAACCTAT +GAGCGACAAGACTTTAATCAAGCTGCTGGAGATGCTGGACACGGAGATGGCACAGCGTAT +GCTTGCTGACCTCCAGAGCGAGGAACGCCGAACTCCGCAGCTTTACAACGCAATCGGCAA +ACTGTTAGACCGCCATAAGTTCCAAATCAGTAAGCTGACCCCGGATGGATGTTCATACGG +TTGTTCCTCATTGGTTGAAAGTTAATCAGTTCGAATCACAAAGGCCACCAATTAAGATGA +CCTTGAGGATTCTCCTGTTAGTGAGGGTTATTACTTCCAGTGTTTCAAATCGCTGTGAAC +CTTACGGAGCCATGCAGTCTGCGCGTTGATTTGTACATCACTGTCGCTGTGCTCGAAGGT +TCTGGATGCCACCGGATGCAGAACATCCTTGGCGGTCTGGCGGCTGGTCTGGAAGACTAC +AACAAAGTGGTCGGCCCTAATGGTCTGACTGATGATGAAACAATCACGCTACAGTAAGTG +ACATACTCAAGGTTCTCCACGCGGGGAGCCTTTATGGATGTTATTTGGTGCATCTATGTA +AAATCTGAAAATTGATGGGAGGTGTTATGCTAAAACTTTTACGCAGCGCACTCCCTTGGG +TACTCGCCGGGACACTCTCTATGAGTGGCTGGCACTTAGGGTCAACCCATGAGAGAGCAA +ACTGGAAGGAGGTAATCCAAAATGAATACATTGCGAAAACAAAAGCAACCGCAGCAACTC +AGGCAGAGGTCAGTCGGGTATCCCGTGAGTACCAAGAAGAGATTGCAGCCATTGAAGGCA +GCACTGATAGGATGCTTAATGACCTGCGTAGTAATAATAAGCGGCTGTCAGTCCGCATCA +AGACCCTTACCGGACTACCAGAAGATAACGGTAGATGCGAGTTTAATGGTCGAGCCGAAC +TACACGAGTCAGATGCTAAGCGTATTATCGGAATAACCCAAGCTGCTGATGCTCACGTAA +GGGCGCTCCAGCGTACTATTAAGGAGATGCAGAATGAGCGACACCCAAGCAAACCGTAAT +GCGCTAATCATCGCGCAGCTTAAGGGCGACTTTGTGGCCTTCCTGTTCGTATTGTGGAAG +GCTGATTGCTACCCAAGGTTTCGGCGGTACGACACACGGCTGGAACATCGGAGAGATACC +CGCCAGAGCGCCTGCACGCTTCGCTAATACGTCCACGTACTCTTGGGCCAGTTGCAGTGC +CTCATGGTCAGAGCCTGCGTTACCTGCGTTGTGGCGCTGTAATTCCACCAGACCTGTGGA +TTCAATCAGCATTTCAATCAGGCGAATCCCTATTTGGCTCTCCCGCCACCGACTAAGTGT +CAGATTGATATGGCCCGGTGTCTGGCTAACGGAGACAACAAGAAGTTTATCCTACAGGCT +TTCCGTGGTATCGGTAAGTCATTCATCACCTGTGCGTTCGTTGTGTGGACGTTATGGCGT +GACCCTCAGTTGAAGATACTGATTGTCTCTGCATCCAAAGAACGTGCGGACGCTAACTCC +ATCTTCATCAAGAACATCATTGACCTGCAAAGAGACGCATACGGCAATGTGTTACAGATT +GTCACTCGTGACCAGATAGCCTTTGGTGCTCTCCCGGAAGACGTTCGGTCTGCGGTAGAG +AAAGCTGGTGGTGAGAAGAAGATGGACGAAATGGTCGATGTGTACACCCATGTGTATCTC +GATGAAGAGTCCGGCGATTACCTCAAGTACGAGGAAGTAGAGGACGTTGAGATTGATGGC +TCCGATGCCACCTATCTGCCATTCTTGGCTGAGCTAAAGCCTCGCCCCGGTCAGCGTGAC +TCTGTGATTAGTTTCGATGTTGGCCCTGCCAAGCCTGACCACTCTCCGTCTGTGAAGTCG +GTGGGTATCACTGGTCAGTTGACTGGTAGTCGTGCTGATATCATCATAGCGGATGACGTT +GAGATTCCGTCTAACTCCGCAACTCAAGGTGCCCGTGTGAAGCTGTGGACTCTGGTGCAG +GAATTTGCTGCGCTTCTGAAACCGCTGCCGACTTCTCGCGTTATCTACCTTGGTACACCT +CAAACCGAAATGACCTTGTACAAGGAACTCGAAGATAACCGTGGGTACACCACAATCATC +TGGCCTGCGCTCTATCCGCGTAGCCAGACTTGAGCCAGTTCATCGCCTCAACCGCTGCGA +CTACGGTCACGCTCACCGCGTCCCAAATCAGCTTAGCCATATAACCAGCCGCTTGGTTAG +GTTGGGTGAACATCAAGCCCGTGAGGAAGACTTGTACTATGGCGACCGTCTGGCCCCGAT +GCTCCGCGAAGAGTTCAACGATGGGTTCGAATCATTCGTGCAGCCAGAACACTGGACAGT +ACCAGCAACGCATCCTCGTGATTGACCCAAGTGGTCGCGGTAAGGATGAGACAGGTTACG +CAGTGTTGTTCACCCTGAATGGCTACATCTATCTGATGGAAGCTGGCGGGTTCCGCGATG +GTTACTCCGACAAGACCCTTGAGTCCCTCGCTAAGAAAGCGAAGCAGTGGAAGGTTCAGA +CAGTGGTCTTCGAGAGTAACTTCGGGGATGGTATGTTTGGTAAGGTATTCAGCCCTGTGC +TCCTGAAACACCATGCAGCGCAACTTGAAGAGATTCGTGCTCGCGGTATGAAGGAACTAC +GCATTTGTGATACGCTGGAACCTGTACTCTCTACGCACCGCCTTGTGATTCGTGACGAGG +TGATTCGTGAGGACTACCAGACTGCTCGTAACGCTGATGGCAAGCATGACGTTCGCTATT +CGCTGTTCTACCAGTTGACCCGTATGGCTCGTGAGAAGGGCGCTGTGGCCCACGATGACC +GACTTGATGCGTTAGCATTGGGTGTGGAGTTCTTACGCTCTACGATGGAACTGGACGCCG +TGAAGGTGGAGGCTGAGGTGCTTGAGGCGTTCTTAGAGGAACACATGGAGCACCCAATCC +ATTCGGCTGGTCACGTAGTCACCTCTATGGTTGACGGTATGGAACTCTATTGGGAGGATG +ACGATGTGAATAGCCATAGGTTCATTGACTGGTAGTTATGCATATTGAGTGCATAAGGAA +TCATTGAGACCACGGATGGTCACTTTAAGAAACTCCTTAAGAATCAATGAGTTTGAATTA +ACCCTCACTAAAGGGAGAGAGGGGACTTAAAGCTACTATATAGGTTAGTCATTCAGGTTA +TGCAATGACCCTTTATGCACTTTAAGTCGCCTCTATGATTGGTGATATTATCATTGTATA +ATCACCCTACCTTAGAGCAACTGAAAGGAGGTGGCTCAATGTTACGCTTGCTGATTGCCC +TGCTGCGTCATAGAGTCACTTGGCGATTTCTTCTGGTACTTGCTGCTACCCTTGGGTACG +CAGGTCTTACTGACCACCTCGGTCAACTGGAAGTGGCCTTTTGCTCTATACTCTCTTGTG +GGGATTAAATTATTGTTGATGAACGACAAGCGGCTCTGAGGGATTCGTAGGTATAGTTTC +ACTACACCAACTCATCCCTGTAGAGTCAACCCTAAAGGTTATACCTAAAGATGCCCTGTA +GTTCGTAATGGTCTTACAGGGTCTTTAAGTGTCTCCTATGGTCTCACCTATGGTGTGGCC +TTACCTAAAGTGGTTGCCTAAAGAGACCTTTAAGAATTTACCACAAAAATCTGAATGGGT +ATCTCACAGTTCAAGAACCCAAAGTACCCCCCATAGCCCTCCTAAAGCCACCTAAAGCCA +GCCCTACCCCTAGGGTTTAACCTTCGGTTAACCTTGGGTATCTCCTCAAGTGGCCTATAG +GATAGCCTAAAGTGTTGCCTAAAGTCAATACCTAAAGTGATTGGGTGGCTTAAGGAGGCC +TTAAAGAGTGTCCTAGTGTACCAGTTCGATAGTACATCTCTATGTGTCCCT +>NC_005091.ref length=57455 +GCTCTGCGCCCTCCCGCCATTCGCGCCTCGCCGGATGGGACCCCGACGGCCGCCCCGAGC +GATCCTCATCGGGCCTGCGCGCCAGCCAGTGACACGGAGACACGATCAAACGAATCGTCT +AGTGACGCGGCGACACCAACACGCAGCAGCCCGCCGCGTAGCCTGTATGACCGTGATACA +GGCATGCCGTCATGCGTGCGCACGGCCGGCCAATGCGGCACTGCACGAGCGACACGGAGA +TACGGCCATGCGTTGCGGGCACGCCACACGCGGCAGGCCGTGACACGGGCAATCGGGGAT +TCGGACCTAGCTGTGAGACGCGCTGCGCCGTACGGCCGATGACATGCGGCCTAGCTGGAT +CGTGTGGATTCGGACCCATGACCACGAGTCGCACGCTATGCGATTGGCCGGGTCTAGCTG +GGCGGGATTTCCGCTACGCTTGTGCGTGCGACGGTTTGAGGCGGGGCAGGATTGGGGCTT +GGCGGGCGCGCTAAATGTCCCGTTGCGTACCTGGGCTAAAAGCGGACATTCTGACGTGCG +GTGCTGCGGGCGCGCTGCTGCGCACCGTGTGCGGGCGGGGCGATGGGCGTAAAAAAGCCC +GACACGATGGCCGGGCGAAGGGTGCTACTGGATGGTGTGGGTTAGCCGTCCCGTGTGTGA +CGCCAGCCTTTTAGGGCGAGTTGATACCAGTACCCACCGATGCGGATGACGTGCGGCTTC +TCCCCCGTCAGCACGCGATGGGCTGCTTTGGCAATCCACCATTTCGGGTCGTGCAGCCAC +ACGAGGCGCAGTTCGTCGGGCGTGCGCCGTACGTCGAACGCGTCGATAGCGCTCGTGCCG +TCCGCATCATCGGGGTCGTCAACCGCTACCACGATTTTCACCATCCTGCCGGGGCTCGCG +CTGAACACGCGCGGCACTCTTAGCAATTTCGATCCGGGCATGACTGCATCCTTAGACGTT +GAACACGTAGCGCACGAGCGCGACGAGCAGGCCAATTGCGAACACGACGAGCGGCAGGCA +GAACGCGCCAGCCACGGAACCGACAATGTAGACGGCCGCGTCGGGGGCGTCTTCGTACCG +CCTGCGCGGTTTGAACCGCAGGATCGCCGGGACGATCAACGCACCGATGACGAGCGATGC +CAATCCGATCGATGCGGCCGTGTGATTCGATATTCCGCCGTCATCGGGTATCGGGTAGAG +CCGGTCGACGCATTGCGCGTAGCTCTGCATGCGGGGCACGTCGGCCGTGCGTGAGTCGTA +CGAGACAATCACGGCTTGGCATGCAGCACGCTCGGCTCGATCGGCTTCTGCCGATGCGAT +CGCCGCGTTCGTGGCGGCTTGCGCGTTGAGCGCGGCACTCAGGGCAACGGTATCAGTTGG +CATCGTCGGCCCCTGCGGTGCGTGTGCCGATATGCAGGCCGACGGTAGCGCGGTTCCGCG +TATTGCGGATGAGTGCAACCTGTTCGACGGTCAGGCCGGCACGCGTTGCGCTCGATTCGT +CGGCTATCACACAGGCCGTGAGAACGAATTCGTTGAGCTGAACTAGCGCCGCGCCGTACG +GCAACGATTCGTATTCTTCCAGCTCGCGCAACGAGTCGAACGAACACGATTCGTCGTTCC +AGACTTGCGCGCCGACTACAGGGGCGCACTGGAACCGGCCGCCCTTCATCATCACGCGGC +CGAATTTGGTCGGGATATCGGACGGATGCACCTTGCGCGTGTCGCGACGCCAGATAGAGC +CAATCTGACGTACGGGCAGGTCGATTTTCGCGACCGGCATTGCGGCGATCGTCTCAGCCA +TCGTCGGCTCGCGGCCGATCACCCGGCAGGTGATATCGCCATTCACGAGGGTCGATTTTC +CCGTCTTGCTTTCGAACGCGCGGGCCGCCAAGCGTCGCGCGATGCTGTCAAGATCGAACG +ATACAGCGACCGTGAAAACTTCGCCGTTCGCACGGTGCGAGTAGCTCTTCGTGATTGTGT +ACTTCGCCATTGTCTTTCTCCTTCGTGTTGCGTTATGCCAAACGGCCGTAATTGCGTTCG +TGAGATTCGACGTAATCGCCAACCGTCGTAAGGCGGATGTTGCCGGTGCGGTAGTCGCGC +AACAGCGTCGCGTTATAGACGTCGCCTGTGTTGACGTACGCGGCGGCCGGTTCGTCGTTC +CGCTCGTGCCGCAGATATTCGACGCCGTGACCCTCGATGAGGCGATTGAGCGTCGCCATG +CTTGTACCGCTCCGGATAGCCGCGCGCACGACGGCCGCACGCTTGATATCGAGCCGCAGT +TCGCGGGCCAGCTTGGCAACGCTCGGCGCGCGTTGCACTGGTGCATTGTTGGTCGTCATG +GTTACTTCCCTTCGTACATAATCCGGGCAGTGCGAAATGCAATCGCCCATGCTTCGCGCG +GGCTATAGCCACACGCTCGATGAATGTGATACCCGCCGTTTGCCGCGTCAGCGACCGCAA +GCGCGGTGCGCACGGGCAAATCGGCAAGCGATCGATAGTCGTGCATGGCGGCGGTAAGGC +TGGCATTAATCGACCAATCTACGCCGTTCAGATAGAACGAACGCCAGCGCGCCGCTTCGA +TCAACGCCTCGCGGAAACGGTAAACCGGCATAACTGCACCGTGCCGGGCAGCAACATACA +TCGTTGCTTCCCACAGCGACGCGCGGCGATTGACGGCCGTTCCATCAATGAAAATCGCCC +ACGGGCGCGACGGCGACGATTTAGGGTCGTACGTGAGTCGAGCCGTACCGCCCCAGCTAC +GAAAGGTTTGTTGATCGCGCCACATGGTTAGGCCCCCTTCCGAACAGCCGCGTAGAAAGC +CGGCGTTACGCGGTTGATACCGTACAGTGCGCGGAACGCCTTGCGCGGGTTCGTGATTTG +CGCCCGGTCTTCGCGCAGATACATCGCGAGTTCGTCTACGGCAGCTTGAATCGCGACTGC +ACGCGCAGCGTCGACAGCCCCGGTCGTCGCTTCCGCCCACTTGGCGATGCCGCGCGGATC +GCATGCACGGGCCAGTTCTATCGCATCGCGAGCCGTAGAACCGCCCCCGCGCAGTATCTG +ATACGCGGCCATGCGCATTGTGTCGTGCGTCGCGTGACGGGCGCGCAGAAGCGCGGCACG +GGCGCGATTCGGCATGATATGCCGAATGAAGCGGCTTTCCAGTTCGCGGCCATTCGGGCG +AGCGATCATCGCGTCATACGCGCTCGTATCGTAACGCGGCTTTTCCGTCATCGGAACAGA +AACCATCGTCGTGCCAAGCTTCAGCACTTCGCGCGACTCGCGCAGCATCGCATCCGCGAT +CTTCCCGGCGTCCGGGCGTGCGGCTTGCGCGCGATTGTGTACGGCCATGGCGACGATGAT +TTGCTCACCATTCAGGATCGCGAGCGCATCGGCAAACGACGGCTCGTCGTAACCCATCAG +GCGCGGCACGAAGGAAAACAGCAACACGCCGTGACGCGAGTAGCCGAGTGCGCTACGGCC +TTCGATATGCGTCCGGTAGCTCGCGATGGTCGGCGCTACGGCGTCGCATTTCGGGGCGAG +CGTGACTTCCTCAATCGCGAGATACGCGCCGCGCGCTTCGAGATATTCCGCCGCATTGGC +GCGGCCGTATGCCGTGAAAAGGCGGCCGTCGCCGGCGCGGGGCGCGTTGCGGACGATGTA +ATCGAACGACCAGCGGCCATTTACCGCCGGGGGCGTCCCGATGACTTCCAAATGGCCGAC +ACGGACCCGGTAGTGCGGGGCGGCTTTGACAGCGGCTTGAACCTTTGCGAGCGTGATCAT +GGCAAGCCCCTTAGTGTGCGTTGCGGATCGATTCGACAGCGGCCAGTGCTGCGTCGCATG +CGACGTTGAGGCGACGGGCGAGCAGGACGGAATCGAGATGACGACAAGCGCGGATGTTCG +CGAGACGGCGGCGGAAGGAAAACAGGAAAGCAAGCATGGTTAGCTCCAGTGGAATCAGGG +CGCGCCGGGCGGCGACCCCATGAATGAGATTCTAGGCGATAAAGTTAAACCTTGCCAAGC +TGTTTTTAGAATTCGGTGTCGTGAATGTGATGAAGGAATGGCGCACACGGGATCGGCGCG +ACGCACGCGGTAACGAACAGCCGGACGAAGCATGAGAACAGCCCGGAATCCCACAAGCCG +ACAGCCGCCCAAGCGATGCCCGAACCGAGGATGAGGTACGACACGACCAGACGGGCGCGC +ACGCCGGCCAGTGCGACGGCTTTGCGCTGGGAAAGGCGCGGATGTTGAACGGCAACGCGG +TTTTTCATGACGGGAGTTCCAATCATCAGGATCAGGGACGCGGCGGCGATCAGGCCGCAC +GCGGCAGCAGCATCAAGCCATTCATTCGCCATCGTTCGGCGCTCCGACGATTTGTTTGCA +GCCGGCCGCGATCAGGTACAACCAGCCACGGTAAAACTCGCAATCGACGTGCCACATGCG +CCAGTCACGGCGAACGAACGCGAGCAGCCGTTCGCCATGCTCGCCGCGATCAGCGAACCC +CGCACCATGACCGGCGCACGTCAGATAGATGTCTTGACCCAGCGCGGCAGCCGGATCAAA +TCCGCAATCAGGATGCGCCCCGTAACCGTTGGTCGCGAGCATTGCGGCGACCGTTTGCGG +GTAGCGCTCAGCGAACGCATAGACGAACCGGCGCGCTGTCTCGCGTGATTCCGCTGTAGC +GCGCGGGCGCGAGCCTTCCGGTGCATCCGCCCAAAGTGCGGCGATGATGAAATGGCGGGC +GGCGGTTTGGATTTGTTCGGGTGTCATGGTGATACCTCCGTAAATGGCGGAAAGGCGAAC +TAGTTCAGTTGAAAGGCTCGGGTTCATTCGGCGTGTCTCTACAACGCTCGGCTACGAGCC +GGGCCATTGTGGCCGCCGCCTGAGCAGCAAAAATCTCGTTGATGTAAATGCAGTCGTAGG +TGATCTCGCTGGCCGTGCATTCGCCCTTAGACCATCCCGCCAGAAAGCCGCGCCCGTGCG +GCAAGCGGAAGACGACACCGCGTATCGTGTCGCCATCGCCGTGTTCATCGGCGAACCATC +CAGTATGGTTGATGCACGCGCCTTCTACCTCGTCGCACCATTGCCAGCGCAACCCCGGCG +CGCCGTCCGATTCCAAATAGAACCCCTTGCCCGTGCTGTTCGGTTTCGGCGCATGGTAAT +ACTCGCCGCACGGGTACGCGTTGCGCTCGGCAATGCTCGCAAACCGTTTCGGCATGCGTG +CGATGTAGCGCGGGAAATTGAAGCCGGCAAACGTGAATTCCGGCGTGAGAGGCGAGAGAC +GATTCATGGTGATATCTCCGTGGGTATCGGAAAGGTGAAACGGATTCAGTTCGAAAGCGT +ACCGCCGTTCGCGCACTTGATCTCGTAATTGAACGGGAATTCGCTGATAACGTCGAGCAG +CAAGGAAACCGCTTCGTCGGACAGCGGATTGCGCCAGCCGAAACAATGCCTGCCCGTGTG +AGCGTAGAAAATCCAGTTATCAATCAGGTTCGGCACATGCGCCATGATCCAGCGGCCGGC +GTCTCGCTTTTCCAGCGCGACGGCGCACGTTTTCACGTATTTCGCTTCAATCCGGTCTTT +CTCTTTCTCGATTCGCGCCTTGTCGCGTTCGGTCGCGCCGTGCAATTGCGCTTGCACATA +GCGCGGCATCAATGCCTCGCGTTCCGCCTTGCTCAGTGTCGGGCGCTTCGCTTTAGACGA +CACGGGCAAAAGGCGAGTGAGATACAAATCGTCCGGCTTCAAATACTGCGATCCGTAGCA +CGACGGGCAAAACGCGTTGCCGATCGCGCGGTCTTCCTGATGGCCGCAGTAGCCGCACTT +AACCGCATGGTCGAGCGCTTCGCGCATGTCGTCCGTCACGAGAAACCAATAACCCTCTTT +GATCCGCTTGTTCGGATACTCGTACTCCGACCAAGGGAACAGACGTTTTCCGCGCAGGGT +TTCGCCGCCTTCCGTGTCGGACGTGTTCCATTGGTCGGAGAAAAGATGAGTCGTATCAAA +AACAATCGTCTGACCGTCGCCCGCTTTCATGTCGCCCATGAATGACTGTTGCTGCGCTTT +CGTGCGGTCGTACTGAAGACCGACCGACACGGACCATTTGCTTTCGCCGCGCGATTCCAG +CATGGCGCACATGTCCGCGTAGGCTTGCGCCTCTTCAGGCTTCTCAATGTTGAAGTAGTA +ATGATTCAGAGTGGAAGTCAGGCGCTTCATTGTGCAATCTCCGTTGAAGGAAGGGGCCGG +GCCAAAGCGGCACGGCATGACTGAGATTCTAGGCGACAAAGTTAAACCTTGCCTAGCCCC +TTTCCGCATTTTCTTTCGACCGGAAGTAACTTCCGACCCGTCCGGGCGGCGCCATCAGCC +CAAAATCCCCGCAAACCCTTGCCCCGTAAGGCTCTTAGGCCCCGCGCCGCCGGTCGTCTA +GGGGTAAACCCTATGATGCGCCGCCGCAACGCGCTCGCCAAGCGCCGCGCGGCTGTCCCG +TTTTCTGCGCCCCTCGTCCGGCCGGGCGGCCCGCCGGTATCCCGTGCTGACGACCCCTCG +TGCTTACTTTGGGGGCCTCGCCCGTTCCCAATTTTTCTAGACCAATCGAGAAACGACCCA +CCCCATCGGCCTTTTGCTTACTTCGGGAACCGAGCCGGACCCCCGCGCACGGGCCGCGTC +GAACGAGCCGACCGGGGGTTACTTCACAACCCTAGCCGGACCCCCGGTCGCCGCCGTTGA +CAAAGTTAATCCCATCCCCGACAATCCGCGCATCGAACCGATCAACATTTTCACGGAGGA +TCACCATGGACACCGCCGAAACCGTCAACAACCAGATCGACAGCTTTGCCGCCCGCGTGC +TCGCGCTCGAAGTGGGCGAGACCGAATCGAAGACGTGCCGACTGGATGGCAACGAGGCGA +CCAAGGAAGTCATGGCGGCCACGCTCACGAAGCTTCGCAATAGCGTCGCGGCCGCCGTCA +GCCGGGCGTCCTCGAAAACCGGACACGTCTTCATCACCGAGACCGGGGACATTCGCACGA +AGAGCTACGACTTCCTGATGACGGTCGCCGTCACGCGGAAGGCCTGATGAACGCCGTCGA +ATTCAGCGCGGTCCACGCGCTCGTGCAGGCGGCGATCGGCGAAGTGATGCGGCAAGCCGG +GATGACGACGTGCAACGTGTCCCGTGCGAAGATGGAAGAGTTGCATCAGTCGCACACGAT +CGAAACCGCGTACGACCTGAGCAGCGGATGGACCGTGACGCTGACGGCCCGCGCCCCTGA +AACCGAAAACGGAGGACCCAAACGTGAAGACGAATGATTGCAACTGCGGCTGCGCCGACT +GCTCGGGCAAGTACGCGACGAAGAGCGGCGCAGCCGGTCAGCAACTGGCGCACGAGCTGC +ACGGCCTGACCATCGATCCCGGTCGCACGATGGCGCAGCAGGCCGACCAACTGCGTGCGC +AGGCGGCGCAGATGAAACAAGACCCGGTGAGCCGTTTGCTGCGCAAGACGCTCGACATGG +TTTTGCCGAAGTAATCATGCGCGCCGGCCGACCTCCCGCCCGCGCTGGAATCCGGACCTT +CCTGAGCAAGATGCCGGTCGGCGCGTCCTACTTCATCGCGGGCGACACCATGGACAGCTA +CAACGCGAAGACTTTCCGCAAGGCTAGCGTCGAACTCGGGCTGCCGATTCGCAGTGTGGT +GCATCACAAGCATCCGACCCACGGCATGTCCGGCATCGAGATCATCCGCCTGCCGGTCGA +GAAGTCCGAGCGGCGTATCATCTGAATCCCCACGACGCCGGCCGAATAATCGGTCTCCCG +CTGTAAATCCGGGCCGCCAAGCGGCTCGGATGACCTACCCCGCTACTACCCCCGCCAGAT +TTCCTGCCGTCCCGCCAGAAGCCCCATACGCCAGCCGCAGACATATATCCTTGTCTGGCA +AGGCTCAACGCTCGGCTCCCCCATACGAAGTAACCTCCGATTTCCTGTTATTTTTGTTGC +ACCGTTCAAAGGAATGTTCTACATTTCCACTTGCGCCTTGGCGCAAACCCATCAACCCTT +TGAACGAAACAACAATGACAGTCAAATTTACACAGGAGAAGAACGTCACCATCCTACGGG +ATGCGATTGACCGGCACGGCCTCCGATGCCACATCACCCCGGATCAGGGGATGTTCAAGT +TTCGGGAACGCAACAACCCGACCGTCTACTACTTCCCGAAGCGCAACCGCTACAAGATCG +CCGGGCAGCCGAAAGATGTTCACATGAATGCGGCTGACTTCGCGTGCTGGTATATCGGCG +AGCATCTCGGTCGGTTGATCGCGGGCAACGCGATGGCGTGGCTGCACCGCGCAGCCAGCG +ACGGCAATTGCCGATCGTGCAGAGAAGATAAGTGCACGGCCGGCCCGCTCTGCGTCGCAT +TCGAGCATCACCGCGAACGCCCTCTTTCCAGCGTCACCGTAGAAGCCCTTCGTGAAGAGC +AACTCCAACTGCAAAACGACGACCAAGGAGCAGCGCCATGTTCAAGCAACTGATTGCCCG +GATGAAAAGCGACAAGAAACGCGAAAAGGTCGCTGAGTATTTCCAAGAGCTGAAGGACCG +GCAGCACGAACTCGACCGGCAAGAAGACAACATTGCGGCCGAGCGGCTGTATATCGAACG +CCAGCTTCCGCGACTCGCCGCCCGACTGGCTGAGATGGAATGGGGCGGCGAAGACGCTGT +TCAACGTTCGGCCATGGTAGGCATCCGCAACGTCATCATGGCCGGCCACCAACCGGACAA +GCCGATCATCCCGCAACCCGGCGTCGGCAGGAGGACCACGGCATGAGCAATCACTTCGTA +CCGAAGCTGCGCGTCAAGAAGCAATCGAACGGGGCAGTACGCGTAACGGTCGATGTGAAG +ATGCTCGAAGCGGGCGGCCATGAAATCCTCTGGAATTGCGCGGTCATGCAGCGCATGCGC +GAGTCGGGCGTTCCTATCATGGGGCTGATTTCCATTCAAGGCGTGCGCCACGGCTGCCTC +GTTCAGACCTACGACGAGTGCTTCATGGAGCACGTCTACGAATGGACGCCCGGCCCGGAT +TCGCCGAAAGAAGTTGACCCGGCAGCCGGTCTCTGACCAACACAATATGGGAGTAACCAT +GAGCAAGATCGAGAAGGCCAGTGTCACGGTCAGTTTCAAGACCGACAGCGGCTACGAATC +GGTATTTGGCGCGCAGAACAAGCCGGGCATCGACGCACTGAAAGATGGCCTGCACGAGAT +CGTCCGCGTGCTGACCATCAACGGCAATGTCGCTACCGTCGACGCCGTCGTGAAGGCGGC +CAAGCGGCGGGGAGAGCGCGCGGTTCTCACGCACGCGACGGCGCAGGTCGAGCAGCAATC +GGCGGTCGATCAGCGCGCAGGCGACAAGCCGCCGTCCGATGACCTACTGAAAGCGCTCAA +CGCAGGCACGCGGCCGGGAATCCTGAACGTCTACCGCCATATCCTCCGCGAGCATCCGAC +CGCAACCGGTACGTGGTGTATCCGTCGCGCGAAAGAGATGTGGGGCCATCTGCCGCTCAT +CGCGCTGAACGCGGAGAATCGACCGGGCATCGCGGAAATCTACGCGGACCTGCGCCGCGC +GAATCCGCAGTGGTCGATGTCCGGGCTGCTGCGTGAGGTCGAGCGCCAGTGGAAGGAATC +GCAGGAATCGGAGGCGGAACTGTGAAGACCTTTCAACTGAATGCCGATCTCGTGCGCTGC +GCTGCCGCGTGGGTGTACGGCGGCGATCCTGCGGCCATGAAATACCCGGCGCTCAATCGC +ATCCGCATCGAACCACACCATCCCGGCGCGATCATCATTGCGACCTGCTCGCACGCCATG +TTCGTCGCGTACGACCCGGAAGCCGTCGTGCCGGAACCCGCGCTGATCTCCGTCCCGCAG +GACCTGCTCGACGCGGGCGCGCTGCTCGGCGTCAATACGACGGAACGCGAGATTCGCTTC +GGGGATGACGGAGTTGCCGTCTATGCGCGCGGCAAGCTGAAGCATAAGTCCCGGCTCGCG +ATCGACACGCATCTCCTGCGTGGCGTGAAGGCGCATTACGCTAACTGGCGTGCAGCCATC +CCGGCGAAGATGGATTTCCTGAAGGCGAACCCGGCCATCCCGACCATGATGAACATGGAC +TTCCTCGGCCGGCTGGGCCGGATGTCGGAAGGCTGGGGCGAATACCGGCAGGTGTTCTTC +GCGACGTGCGGCAAGCAGTCGATCACGCCGGGTGACGGGCAGCGCACCGACTACCGGAAC +TTCTTCGCGTTCTTCCCGTGGAAGCGCGACGTGTTCCTCCTGTTCGCGCCGATGGGCGGC +ATGCCGAGCGCCAAGGATTTCGGATACCCCGAATGGCTCGAAGACAAGCCGGACGATCCG +GCGGCCGGCCTCTGAAGTAACTTCCGACCGATTATCGTTGACAAGGCTTAACGTTGTCAC +GATAATCGGTTTCACTTTTCCACGAAGGAGTTTGAAATGAACGAACCGAAAAACGATGGC +GTCGATCAGCGCGCCTACGCATATGTGCCGGCTTCCGTGCTGCTCGAAATGAAGCAGTAC +ATGGACAAAGTGTCGAAGCTCTCGAAGGTTCCGGCATCGGCTATCGGCCTGAAGGAGCGC +GTCAAAGGGTTACTTGCCGAAGCGAAGGAGCACGTCGCGACGGTCGACCTCATCGAATAC +GAAGTAGGGCAACTGGTCGGGAAGTATTTCGAGAAGATCAATTTCGAACTTATCGGCGAT +GTCGTCGTGAAGAAGACCGGGGAGTTCAAGGGCGACCTCGGCCCGTTCCAAGACGAACTT +TGCCGCATGATGCGACATATCGCGTTGAAGGTCCTCGGCGAGAAGATCGAACGCGACGAT +GCGGCCGCCGTGTCGAAGCTAGAACGGCTGTACACGCACATCGACGCTGTCGCGGCCATG +CTGGCGAACGACGAATATGGTGAGCCGCAGGGGACTGGCGACGAGAAGTTCGACGCACTG +GTCGAACAGATTACCCGTCTGCACAGCGATCTCAACGAGTCCGCGCAACTGATGGTGCCG +GTAAGCGCGTCGGCCGAAGCGGAACTGGCGAGGATCACTGAGCAACTCGAAGAAGCGTGC +GACGACATCGAGAAGGGACGCGGCCTGACGCTCGACGTGGAAGACGCCAAGCCCGTACAT +CGGTTCAAGCAGTTGTACGCGAAACTGTTCATCCAGTGGCAAGAAGCCACGACGCATCGC +GACGACGCCGAAGGTCGCCTGAATGCCATCAAGACGGTCGTGCGCCAGATGCGGAGGGAT +GTCAAAGGTGACGGTGCGCTCGCAACGGGCGTAGTCTACGATGACAATCTCCTGAACGAG +ATTCGTGGCTTGGCGCACGCTGTGATGATGAGCAAGGCGTTCGGCTACGGGAAGCTCGGA +GTGCGGCACGAGATCGGCGTGTTTCTCAATCACGTTCTGCCGCGCGTGCGCAACCCGAAC +TACGTGGGCGACCCCGAACTGATCGACCAAATTCTCGATGGCATCGCACTGGTTGGCTCC +GGTTCTGCGGATGCGTTCGATACGGCGCAGACTATCGGGGAAGACCCGTTGTCGCAGGTG +CCGCTCAACGTGTTCCAGTTCAAAGCGCGTGTTGCGGCTGTCGCTGACAGCTTCGAAAAA +CACAGTGCACGTCTGCACGACCATCTTGGGATGAAGTGGCGGCTCATCGAAGTAAAAGAA +GCGCTCGGGCTGCCGTTCGCGAGAGATATCGTCCGGGTCATCGGCGAAGCTGACGACTTG +GCTTCCGTTCCGCACGATCGTGTACGGGCCGTTTGCGTGGTGTGCGAATATGTCCTTGCG +GCCGTCCGGGGGTTTGATGACAATGCGCTGGGCGCTGCCCGCACGTACGATGAAAGCGCC +GGGACTGTTACAACGCAAGAACCGGACGAATTGCAGGGCGACGCGTTGCCTCTCGATAGC +CCGCAGAGCGAGAACGCGATTCGCGTGCTGACGGAGCAGCTCCGAAAAAGGAATAGGCTT +CTCGGCAACTTCGTAGGCATCCATCCGGTCCTCGAAGAGCTTCAGGACGCGGTGCACGAC +ATCCTGTTGGAACATAAGTCGAAGCGCCCGGACGTACTGCAAAACGCATGGTTTGCGGAT +GTGCTGAAGTTCAACCTCGCCGCCGGCCGCTCGATCGATGACTTCAACCCGCGCATGATC +GGCTTGCACACCGGCCTTCAGTGCGAAGAACTCGGCGAGAAGCTGCGCGCGATTGTCGAA +GGCACGGTTGCTTCCGGCGTGTCCCTTTTCGAAGGCATGCCGCTCGTGTCGCTCTGCAAT +CAGTTGAAGTGGGTCGGCGACCTGTTCAAGCAGGGTGCATTCGACAACGCTATCGACCGT +GCTGACCCGGTCGAACTGGCAGACGGCGACATCGACCAGATGGTCGTCTCGTTCGGCTCG +CTTCATTCGCAAGGCGTCTCGCTGTTCCCGATCCTGCACGCCGTGACGGACGCGAACCTG +CGCAAGATGGTCAACGGCAAACTGCTGCTCGACAACAACGGGAAAATCGTCAAGCCCGAT +GGCTGGAAACCGGCCGACCTGCTGCCGTTCCTGCACAAGACTAAACAACCGGCCGAACTG +CACATGGGTCCGTCCGACGAAGCCGGGAGCATCTGACATGAGAGTGAACGTCTATAGTCA +GGAACTCACGTCGGAAGTAAACCCGGTGTACAAGGAGTCGAATACCGGCGTAATTTACAG +CGCGGTGCAGTTTGTTTTGCATTCGAGCGACCGACTCCATCATCCCGACCCGGATGGCGA +CGACGATCGGAGCGCCGTAACTTTTTGGCTTCCGAAATCGAGAGATCGGCGCGAGGCATT +CGCGCTTGCTCTCGAAGCGGCCGCCACGATGGTGAGAAACGCCCCGCCTGAATCCGGCTT +GGACTCTTAATCGTTTCGCCGCCCTTCGGGGCGGCTTTCCTTCGAGAACACCATGTACAC +GAACAATCGCGACACCCACGAACTCGCCAACGAGATCGAAACGGAGATCAAACTCAACGT +CAAGCTCGACAACTGCTGGCCCGGCACGCCGCACTTCATCCTCTGCCACAGCCGTCAGGT +CGGCTGGGAGATGGCCGAGCGGATGTCCAAGGTCCTGTCGTTGCCCGGCGGCGCGCCCGT +CACCGTGCCGTACGTCAGCACGATCCCGGAAGCCATTCAGCTCCTGCAAGGGCTGACGAC +TCATCCCGTGGTCGTGTTCGCGCCGGCCGTCGTCTTCCTGTTTCCCGGCTGGGCGTGCCC +GCTCGACCTGCCTACCAAGCTGCATGCCACCTTCCCGATGCACGACGAAGAAACGGCGCA +GTTCATGGGCCGCTTCAACCGGTTGAACCCCCGCACCGGAAACATCGGCGATAACCTCAG +TGTTGGGAAAATCGTACGTTTCAGCGATATCGCCTGTTGACAAGGTTATTCATTGCCGTG +ACAATCCGTCGTATCAAACCACGGGGAAAGAAAAATGACGAACAAGAATTGCGACTGCCG +ATCCGCCGACGAAGAGAGTCTCATGGAGCGCCGAAAGTCGAACTGGCCGGATTACGAAGA +CAGCATCGCGCAGCTCCGCGCGTCGTTTTGGGCCGGGGCCGTCGCTGGTAGCTCCCCGGA +CACGAAGTTACTTCAGGGCAATGAGTACGTGATCCCGAATCCCGAGCGGATCGCCACGTC +ACTGCACGCGCAAAACGTCGGCAAGACATCGGTCGTGGATTCTCTGTTCGCGCTCGGCGC +GGCGGCAACGGTCAAGCGGGCGAAGCCGTATGTGCTGCCGGACGGGTTCAATACCCGAGC +ACCGTTATCGCCGTTCCAGCAACTGATGCGATTCGGCTACGCGGAATACTGCATTGACGA +TTTCGCGCGCGAGAAGCTGTCTCGGGTTCTCTTCGACTCGTGGAAGCGCGAAGCATTCGA +TCGCGTCCTGCGCCGCAACGCGTGTCAATCTAAGACGCTCACCTGTCTGTCATGCGGCCG +TACCGGCCTCGGGGTTGGCTGCCCCTGCGGGGCGTGACATGGGCGGCCCGTACTTCTTCC +GTGACGGCTCGCAATATACCGGCCATCAGGTCGTCAATTTCAGCGTGCAGAAAGGGCAGG +GGAAGGTGCGCATTCGCGCACGGTGCAAGGAGTGCAACGGCCGCCCCGGATCACATCACT +GGCCGCACGGCCGTTGCGGTGCGTGCAAGGGAACCGGAATCAACGCGTCGTACTCGTGGG +TGTCGGTCTATTCGGCCGAACGCCTGAACGAATTGAACGCCTCGAAGCACCGCAAACACA +TGGCGCTGTCCGCGCTCGCGTTGCTGATGGTTAAACGCGATTTCCGTCAGTTCCTGCGGC +AGCGCGACCGGTTGCTTACGGACATGCAGACGTTCGCGCCGAAGTCGGAGAACCTGCAAT +TGCTGCTCGCCAAGGTCAACCAAGGAACTATTCTCACCCCCACCGAGATCAGGCAGGCCC +TGACGCTCGTCAATACCGTTAGGAGTCAATTCTATGTCGCCGCAAGCTGCGCTCGCTAAG +GAGATCGCCGGGATGATCCGGCGCAATGTCGACAATACGGACCCCAGCATGCTCGTCCGC +AACGTGATACCGCTCGACCGAAACGAGGCGTTGATGCTCGTCGGGATACTCGAAGCGGTT +GCATCGGCGGAATCGTTCACCGAGCAGAAGGTATATGAGGCCCTGTATCCCGACAGCGAT +CCAGCCAAGCCTATCCGCGATTTCCTCAGCGTCTACGCAGCACGGCTCGAAGCGGTGCGC +GGCGTGCGCATGAGGAACGATGAAACCGCCTTCGACTACAGGACTCGCTCGGACTCCGAC +GGACGCTTGAAATTGACCAACGGTCAGGTGCGCGCATTCATCGATTCCTTTGACCGTCAA +TCCGGGAGACGGCAATGAAGACGATCTACATCGTATGTGCGTCGTCTATGTACGAGGGCG +GCGCGGACGTTCGGGCGTTCGAGGACGACGGAGACGCCAGAAAGTTCGCGTCCGACTGTC +GCGCCGCTTCGGCTCGTCGCCCGCAAGCCCCCGCGCTAGGAGCCAGTCAAGCGAAGTGGG +CGGCCTATTACAGGGCAGAAGCCAAGTGGGAGAAACAGCACCCGGCCAACCCGCACCACC +ACCACGAGTATTTCGACGTAATCGGCCTCGATCTGTACCCGAAGCAGAAGTAACTTCGTT +TCAGTCCTGCAACATCGCGTGACAAAGTTGAACAGGGTTATTACGGCACGAATTGTCTTG +ACAGTGTTTATCTGTCCGATATACTTCTGCATGTAGTAACCCACTCAACAACCGAAAGGT +GATTGTCATGGCAAAAATCCAAATTCCGGGCGAACTCAAACTCGACGCTCCCGAGGGCAG +CGTGCGCGCTGCGCTGAAGGAAGCAGGCGCGACGGATGGCGAACGCATCCGCATGGTGCC +GCCCGACTCGATCCACATCGTGCCTGGCCTCAATCCGCGCTTTTGGGGCAGCCCGAAATC +GAAGGCCCACATCGAAGACATCGCGAAGTCGATGATCGCTCGCGCGGCGTCCGGGCTGCC +GGCGTTCATGCCCGAGCGCGCGCTCGTCTGCTTCGCTCGCAAGATCGACGGCGTGGACCG +CCTCGTCCTTAAGGCCGGCCAACACCGCTTGGCTGCGGTCGCCGTCGCCAACAAGAAGCA +GCCCGGCACGGTCGCGGAAGTCCCGGTGTTCGTGGACGAAAATCCGATGACCGACGCGCA +GCTCGCGCTCTACTACATCACGGAAAACCGCAGCGAAAAGCTGGGGCCGTACGAGATGGC +TGTCTCCGTCGCACGCGCAGCGGAAGCGGGCGCGACGAAGAAAGAGATCATGGCGGAACT +GAACATCTCCGACCGCTATCTGTACGATCTCGGGCTGCTCTACAACGCCGACCCGCGCGT +CATCGAGCTGCTGGCGGAAGGCAAGGTGAGCGGCACGACCGTCATCGAAGAGATCAAGGA +GTACGGGCAGGAGAAGGCCGCCAAGCGACTCCTGAAGGGCATCGAGACGGCCGCCGCTGC +CGGCAAGACGAAGGTAACGCGCCGCCATCTGCCGGCCGAGGACGCCCCGGCCAAGGAAAA +GAAGACCCGCGCCGACACGAGCAAGACGGATGGCGGCGAGCAGCGAGCGGCCGACGTTCC +GGTCTTCAACGCCACGCTCTCCGTGCTCGAAGTCGTCAACGGGTTCCACGAGCAGTTTGG +CGAATCGGACGATCGTCATACGAAGATCATGTTCGAGATCATCAAGCAGTGCGGCGGCGA +CGAACTTGTCCAGTACGCGGCTGACACCGGCAAGTACGAAGCGACTGGTCTGGTGCGCCT +CGGCTTGGTCGAGCTGCCCGAAGAACCGGCTGCCGCTGAAGAAGACCCGGCGATCAAGGC +GCAGGCCGAGAAGACGAAGAGCACGCGCTCGCGTAAGTCGAAGAAGACGGAAGAACCTGT +CGAATCGCCGGTCGGCACGGCGGAAGGGCTGTAAATCGGAAGTAACTTCAGGGCCGCTTC +GGCGGCCTTTTTCACGATTACTCACAGGCGAACTTATGCAATCCAATCTCGTGCTTCTCC +CGGTCATCGACGGCCGGGACATCTCCATTTCGCCGCTCGGTATCTGCGAAGTCGAGATCA +GCGACCAATTCATCGTGACGCTGACCATGCAGAGCGGCAACAAGTACCAGTACAAGATCG +AGAACATCGAGCGACGACTGGCCTACTACATGGACCCACCCATCGAACCGTCGCGAGGCT +ACGACAAGCCGATGAAGGCGATGACCTCGAAGCAGGCCCATGAGTACCTGAAGTTTCAGG +AGCGCCGACGCCTGACCGGGTACGTCAAGGAGGCCGAGGAAACCCACTACTGGCATCTGC +GCCGTTACGAGGACTGACATGGAAGTCGCCATCGCAAGCGGGCTCGTGCCGTACGAACGT +GTGCGCGAGGGGATCGAGGTCGGCCTGCATTACCTGTCGTTCGACCGACCGGAGTTCATC +ACGGGGCTGCACGTAGCGGCCGATGTAGGAACGGCCGACGTGCATGCGACCCAGTGGGCG +AAGGAGCACGGCATCGAGATTACGCGCTACTGGCCGTCATATCGCGGGGACCCGTACGAA +GCTGCCAAAGACCGCAACTACTTCATGCTGAAGGAAGCGGACGTGCTGATCGCGGTACTG +GGCGGCGTCGGCAATTGCAGCGGAATCATTCAGATGGCCCGGCAGATGAATATGCCGGTC +TACGTACATGCGAAAGATCATGGCCTGTAGTTGACACAGTTCATCTTTGTCAGGATAATC +ATCTCACCAGCTACGGAGGGATCAAAATGAGTAATGAGCCGAAAGACGCAGCAGGAATCA +TCACCTTGAGCATCCAAGTCTCTCGCCAGTTGTGCGAAGACACAATGGATGCAGCCGCGC +ACGGAGTTGAGTATTGGGCGCACGCGTTCGAGCATCCGGGCTGCGGCCCGGAGACCCTAA +ATTATGCGATCGAAGAAGACGAACCGAGCAGTGGCGAAACGCCAAAGAATTTCGTCATCA +GCCCGGAAGCCATCGTGAAGGGGATTCAGGCGATCATGCACCCGGCATTCTCGGTGCGCG +CAGACATCCGGGGCACGCTGTTCAGTGCACTCGTAGAAGACGACGCCAGCAATATCGACA +TCGAGATCGCCGATATCATTGTGCAGGCTGCGATGTTCGGCGAAATCATCTATGGCTGAC +CGGAAGTTATTTCCGACCAAGGAGAAGAAAAATGGCGAGGAAACCGTTGAAGATCACATT +CGGTGTTGGCGCTGCTGCGCTGGCGATGAACGTCGTACGCCGTGCAATCAAGCGGATCAC +CGAAGACCCGTACGAAGCTGCGGCCGAGCACCTGAAAAAGACGCTCGAAGAACGCAAACG +GCCGTTACTTCCCGGCGAGCGCGTCGTACAGAAAAGCCCGCTGTTCGAAGCTCCCTACGG +CGTGTGGGAATTCGACCGGGGCGATGAGGTCACGGTGGACACGAAGTTCGATCGACCGTG +GGTCGGCGTCGTGCTGAAGCGCAACCCCGATGTGCCGAGAATGTATGTCGTCCAGATGGC +GATGTCGCACGCCGAAATCAACGTCCACGAACGTATGATGAGCCTGCGTCGCCGTGCAGC +CGGCGACCCGAATCGCGCGGTGTTTCCGGCGGTGCGGCCCTGCGAAGGGCGACCGGCCGG +CGAATGGTCGACTGCTCGCCGCTGGCCGCCGACCGGCTGGCCGTGCGAATGGTTCCCGCC +GGGAAAATCCGACGCCTACGCGACCGTAAGCCAGTTTCGACGGGACTATCCGGAGGCCGT +TGACACGGAGAAGGAGCAAGCAGAACTCGCCATCGCGGCTGCCGGCCTCGCGATGTGCCA +CGACCCGTGTTACGTCGTCCAGTACGGCGATCAGACCGTATGCAAAACCTGCGGAACGAC +GTGGGATACGAATGATCAGTTCCCGCCGTCGTGCCCGCACCCGTGACGAGGCTGCCGTGT +CGGCAGCCATCAACGGCGCTACCATCCTGATTCTCAATATCCTTTACCCCCGGAGAAAGT +AAATGCGCATTGCGAACCCGCAGAATCGCCTCTGGCAGGCTCTCGTGTCCCGGCTGGGCC +AGCGACTCATCGACCGGGCCTTCAGCCGCCCAGCGGACCCGGTAACGCTTCCTGACTTGG +CGAACTACATGCACCGTCGCTGGCTCGTGAAATACTCTCGCTGGACCCTCGGCCGCTGCG +CGCGAATTCACCACATCCTGCGCTCGGATTCGGATCGCGATTTCCACGACCATCCGTGGC +CGTACGTGACGATCATCCTCGACGGCGGCTACACCGAAGTAACCCCCGTCTACACGAAGG +CGAATCTGTACAAGGGCGAGCACCGGCAGTATTACGGCCCCGGCTCGATCCTCGTCCGGT +CAGCCAAGCACCTGCACCGCCTCGAACTGGAACCCGGCACGACGGCGACCACGTTGTTCA +TCGCCGGGCGCTGGGAGCAGGAGTGGGGCTTCATCACGAACCCCAACTTCAAGATGTACT +GGAAGGACTACCTCGCGCGCGAGACGGACGTTACGCCGGCACGCGCCGAGCGCCGCACGT +TCCTGATGTGCGCGTGTCCTGCCTGCGCGAAACTCACATACTTGGCCCGCTACCATACGG +ACGACGACAAGCGCCGAGCGGGGGCCGATCTCATCGAACTGATGGAGGCCGGAAGAAACC +CGTTCACGAAAGAGCTGGAAATCGGCGCGAGCGGTCGTACGATTTTCCCGGAAGAGTACT +GCGCGTGTCGCGCGCCCGACATCGAGGACGGCGCGGATACCGCCTTCGGCGACGAAGCGG +ACACGGAAGACAGGGGCTGACCGTGAGCGGCCGCATGTGGTTCTACCACGAGAACTCCGA +CAGCCACGTCTACCTCACATGGGAAGAGGCGGCCGCGCTGCCGGAAGCTCTCTACGAGGT +TGACGAGCTGTTGGTTCCGGCCGCAGTACAGGAGAGTGAAATGGCGTATCTCGGTCTGAA +TCAGCTCCCGTTCTTCCTATACACCGACGACATGCCCCCGGACCCGGTCTACGACGCATG +CCGGCTTCTCGGGATCGGCTCGTGGGCGACCAGTGAGTTCCGGGGAAACATGGACTTCGC +TACGGCGCTCGAACGCAAGCACCCGATGAAGGAGTGGCGGGAGGCGATCAAGAAGGCCAT +GGAGATCGAGAAGCGGCAGCAGAGTGCGCGAACGATCGCGGCCAAGGCGCGCATTGCACT +CGGCAGCGACGACCCGTACGCGCTGCGTGTCATGCAGTTGATGATCGACCTCGGGAAACA +GCTCGACCCGGCGGCCGGCCTGTAGGCAAAAAGAAGCCCCGGCGGAAACCCGTCGGGGCC +AAAGGGCGATGCCTTACGGCACACTCCCCATCTGATCGCAGCAAAACCATTCTACTCTGA +TGCCGGCTTCGCCGGGGTCGCTTTGCCGGGCGGCTTCCATCCACACTTCTTTGCCCCCAT +TTCGTTATGTTCGACCATTTGTTTCAGGACGGGAGTCGGGATCGCTTTTGCTTGGTCGAG +GGTGTAGGTGAATGGTTTCGTCCAGTTGCAGCCGGTGTCGATGAACTTGGTTTCAACTAC +GATCTTTGGTTCCTGCGGCATCGGGACTTCCGCTTTCGGGGGAGGCCCACTTTTGCACGA +GACCATCAAAAGTAGCGCCGTCAGCGCCAGATACTTGTTGTTCAACATCGCTTCGCTCCT +TCGCGGCTTCAACGCCTTGTTGAGCGGCTGCCGCGTTCGACTGCGCATGTGCGTCACGGA +CCTCCGCTGTTTGAGTCCGGGCGTCGGCCGCGTCACGCTGCGCTTCGGCCTGCCCCTGTT +TCGCGGCGGCCACGTCGGCCGACGCTTTCGCCTTGACGATCCGGCTGTAGCCGAATGCGC +CGAGGATCGCTACGATAGCAGCCCCGATAGCCGCGATGATCGTGTTCATTGGCAAGTACC +TCCGTTAAGGATGTAGGTTGCACGCAGGGCATCGAGCTGGCGCTTCGGCTGTCCGTACGT +GTTCTTCGTGCCGGGGATAGACGCCCAAATGTTCGAGACCCGATCGCATGCCGTCAGGAA +GTCGCCGGCCTTCAGCGGCTCGATGGCGCGGCTCTCTTTCAGGTGTTGAAGGCACGTCAG +GTCTTGCGCGATCTCCGCGAAGTCCGTCAGCCGAAGGAGCGTCTTGTAGTGCGGCCAGTC +CTTCAGCATCTGTTGGTATCGGCCGCTCGCCGTCGAGTAGAGGCCCTTCGAGTTGACCTT +GAACGGCTTACGGCCGAATTGCGGCATGAACGGATGGTCGCTGAAATCCGTGAAGCGGTT +GTGCTGCACGTTCCCCTGCGCGTCGATCGAGTTCACGAGGATGTCGTAGCCGTCGTCCTG +CGTGACGGGTGACGTGCTCGTGCCTTCGGCGTATGCGATCGTATCCATGAACGCGCAGAC +GTTCAGATGGCCGGCCAGTTCAGGAGTGATCCGGGGCATTCGGGGTCTCCGGTCGAGGTT +GCGTACGCGCGAGCCGGGCCTGCTTGATGATGCGGAACGGCACGGCGAGCACGATGATGG +CGATCGGGACGAAGCGCGCGTACTGCGGCGGGATCAGCGCCTTCATGTCGTCCGGCATCA +GGACCCACACATGGAGCAGGGTATCCGGTGCGACCTCGATCCAGCTCTGCAACACGACGC +CAACTGCGATGAACCACGTCGAGCTGAACTTCACGAGGTTGCGCCAGTCATCCACGAGCT +GCACGCGCTGCTTCAGGAAGAAGCGGCTATACAAAAAGACCGCGACGAGCGCGGCCAGTG +CGACGGCGGCGACTACGGCCGCCAATTCGAAGAGGTTGTTCATTTCGCCCACTTTCGGAC +AGAAGCATTGTCCGCGTTACGGTCGTTGATCGCACGGTCGAGCTTGTCCTCGATGCGTCG +CAAGTCCTCTCGTACGTCCTGTTGCACCTTCGTTTGGTTGGTATCGATGCGCTTGATGTC +CTCCTTCATGAATTGAATCTGCGTGGCCGATTCGCGCGCCCGGTCTCGGATGTCGCCAAC +GTAATTCGCGACCCAGCCGATTGTCGATCCACACGCAACCAAGACCGTGATTGCCATCTT +GATGTCGATGCGGCTCTTGTCCGTGATGTGTGCCGTCTGATCCGTGTTGTTCGTCGTCGC +GTTCATTCGCTGGCCCCGTGCGAAAAGGTTGAGGATGCGCGGGATTCTAGCAGAACCGGA +AGCAGTCGAGGGGCGATACGAAGTAACTTCAAAGCGGGCGGCCGTCATAAGTTTCACCAT +GTGAAAATGAAAGGGAAGGGCAGTGCTGCCGCGAATTCTAGTACCCGAGCGCCAGAATGA +CAAACGGCCCCGAAGGGCCGTCTGCGCTACATCAGGTTGTGGGCCACGGGTCGTCCGGGC +CGAGCGGCGTATTGCCTGCCGCCAGCCACGGCTCGTAGATGTCGATCCAGACCGAGCTAT +CTTTGGGGACCAGCCATACGGCCCCGTCAGCATCGCGGTACTGGACAACATCGTCCCGAA +CGTCCGGGGACGACCCTTTGAACTGCCTGAACGCTATTTCCATGACAACTCCTGTTAAGG +GCGTGCATCGCCGAGAACGTATCCGTTCGAACCGCTATCGAACGAACCACTCCCCGTAGT +AGACCATTGCGCCGCGATCCGCGCAACGAACTTGTTGGCCGCATCGACAAACGGCGTGTT +GACGACTCCGGAAGTACCGACCCACGTACCACCGATCGAGGTCGTAGGCGAACGCGCTTT +TTCCGAACTCCATACAATCGTCATAAGCCCGTAGTTGCCGCTGATGTTGTACGCGTAATA +CTTGATGTTTCCTCCCGAGCCGTCGAGCCGTTCGATATACCGTTTCACCCGAGCCGTTTC +GAGCGCTAGGCCGCGATACTCGAATGGCGACGGTGCGCCGCCGAGACCGTTCACGTCGCT +GCTCGACGCCGGGTCGCTTTCCTCGATCTGTAACTGGCTGAAGTCGAGCGTGAATGTGAT +TCCGGTCGCCAGAACGAACGCGACCTGAAGCTTATCGTCCCCGTTCGTCCCGAGTTGCTT +ACCGGCGATCGACGGGATATCGACACGGACGCTGAAACGGCTCTCCGTCGTGCCGACCGA +CCACGTGACGTTTTTCAACGTGACCACGGAAGACGCAGGCGAACCGCCCGAGCCGAAGTT +CTGCACGACTTGAATCGCAGTCACCAGATTGGCCGCTGCTGCCGCAACGAGCGTCGTGCT +GACCGTCACGCTGCGCCCGCTGAACGTGTTGACGCCTTCGATGTTCTGGTAAAGCTGCGG +CGCCGACGATGCAGCCGTCGTCTGGTTGAACCGCAGCTTGTACCGGCGCGACGAGTCGAT +CCACTTCGGTGCGGACTCGGGGGTCGCAGTGATACGCGATACCGTCGTCGCACCGCCCGT +TCCGGAGATCGCGCGCCACATATCCGCCGTGTACTGGTCGGTCGCAGCCGCGAGGTTGAA +CGACGTGCCGATCTGCCACGAATCGACGTTGCCGTCCACGAAGCGGTTCCGGCCGGTAGT +AGCCGGGAGGTCGCCGGGCTGAATGGTCGAGTTCGTCCAGTTTGCGCCGTTGTTGCGGAG +GTACTGGCCGCTCGCCGACGACACCGCGAAGCCGATACGCATCGTGACGGGCACGGTCGA +GCCGCCTTGCGTGTCGTACGCCGACCCGTTGACCGGAGGACTGACGTTCACGCGTGCCCG +CGTTCCCATCGTAGAGAACGAGTTCGACGGCCACGTGCCAGACCCCGGCGAATCGATAGG +CGTCGCGTAGTTGCCCGCCTGACCCGGACAGCCGACGAGGAACGCGTACTGCGTGCCTGC +GGTGAGAGCGACCGGCGTCGGGAAGTTGAACGTGAAGTCCAGCGACCCCGCCGTAGCGAT +CGTGACAGGGCTGCTGAACGTCGGTGCGCCGGTAAGCGTGCCGCTCGATGCCGGGGCGAC +GGCTGCTTGCAACTGGACGCCGACCATTCCTGCCGTTTGAAGGTGCGTCGTCAACGAAGT +GACTACGCAGTTCTGCGTGACCGTCAGCAGGTTGCCGTTCCAGTTGTACGCGCCGTTGTT +GTAGCTCGTCGTATCGGCCGGGCCGACAACCGCACTGACAGGAACGCTAACATCCGAGAG +GCCGCTTGCGAGCGCCGTAGCACCCGGAGTCGTAGCCCATGTCCCGTCTTCACGGAGGAA +CCGCGTAGTGCCAGCGACGATACCCGGATCGGGGACGAGACCCGCCGCATGCGAACCACC +GGATGCGCCCATGACAGGCGGGAGCGGTGTAGTCGCCCATGTTGCATCCTCGCGCAGGAA +CCGCGTAGTGCCAGCGACGATACCCGGATCGGGGACGAGACCCGCCGCATGCGAACCACC +GGATGCGCCCATGACAGGCGGGAGCGGTGTAGTCGCCCATGTTGCATCCTCGCGCAGGAA +CCGCGTAGTGCCAGCGACGATACCCGGATCGGGGACGAGACCCGCCGCATGCGAACCACC +GGATGCGCCCATGACAGGCGGGAGCGGTGTAGTCGCCCATGTTGCATCTTCACGGAGATA +CTTCGTCGTTCCTGCCGTTGCGCCCGGATCGGGGACGAGACCGGCCGCGTGCGTTGACCC +GCTCTTCACAAACGCACCGAGTGTTTGCCACGTAGCCGTCCCGCTGCCGCCGCGCGTGTA +CCGTTGGCCGTCCGTGGGCGCTTCACCGACAACAGACGCATTGACAAACTTCCCCTGCGA +TGCCGACCATGTGATCGCCTGCCCGTCAGTCAATGAGGTGAGTTTGACATCGCCCAGCCA +GCGAAGCTGATCGTCGCTCGTGGTGGTAACGTCCGGAGACGCGAAATCGATGAACACCTG +ATCGGTGTACGGCCCCGCACCCGTGACAGTCCATGCCGTAGTCCATGCACTGCCGTCGTC +TGAATACTGGACGGTGAAATTCGACGGGCCGCCGCTCAGATTGTCAGTCACCGCAATCTG +CACACGCGCAACGGACTTCGCAGCGGGCCACTGGTACCCGAGGAAAATCTCAGCACCGGC +AAGCGGAGCGCTGTTGGAGCGGTAGTAGGTTGCGGTGTTACCGTCGAACGCGTTGTCCGG +ACCAAACGTCGTGTTTTGAGCCGAACCGGATGCCGTGCCCCCGGTTGTTGCGATCTGCGC +GCCATTCGTATCGATGAACCGCAGCTCGGCAACACGCATGCCGACGCCCCCGGTTTGCGC +GGCCGAACAGTTGATGCGCCAGTACTTGTGAGCCCCGTACGGATTGGTCTTCGTGAAGAA +GCTGGCCCATGTGCCATTCTGACGCATGTATTTGGTCCCATCGCTCGGCGCGTCCGCGAT +ACCGGCCGTAACCGTCTGGTTCGTCCACTTGGCGCTCGCGGCGTTCCACGCGATGACCTG +CTTGTCGCTCTGCGATGCGACGGCTACATCGGTCAGGCCGACAAGCGTCGTGCTGCCGCC +GGCCGGCGGCACAACCCACGTTCCATCTTCCCGGAGATACTTCGTAGTGCCGGCCGTTGC +ACCCGGATCGGGGACGAGGCCAGCCGCATGAGATGCACCCGATCCGACCATGGTCGACGG +GTAGGGTGGCACAGCCCATTGCGCATCTTCACGGAGGTACTTCGTCGCGCCCGCCGTCGC +GCCCGGATCAGGGACGAGGCCGCCGGCATGCGATGCGCCGCTCGCGACGAACGCGCCGAG +CACGTTCCACGTCGCTTGGCCGCGCGTGTACTGGTTGGCGTTGTTCGGTGCGTCCGGAAT +CCCGCCGCCCCCGCTGATCGTCTTGTTGATCCACTTTCCGGATGCGGCGTCCCACGAAAC +GACCTGCTGGTCCTGTGGGTTCGAGATGTTGGCGTCCGACAGCGTCGCCATGCTCGACGC +CGGGATTTGGACCTCGGCCCAGCCGGAATTCTTCCGCGCGTACTGCTTGCCGTCTGCCGG +CGCTTCGGGGATACCCGAGCCGGTCGCAACAGGAGTCCAGCCCCCGTCTTTCCGTGCGTA +CCCCACGCCGTCGCTCGGTGCGTCGGGAATGCCTCCCTGCGCCGCCTGCCAAGCCGTGCC +ATTCCACTCTACGCGGCCCGTGGAGCCGCTGAAAGCGGTCCACCCGAGCTTCGGAGTGTA +GAAGGCCCACGCGCCGCCTAGGAAGGCCGCTACGTCGTCCCCGTGATTGGCCCACGCTCC +GGTAGGCGCGGGGGACTTACCGACGATATAGCGATCGCCCTCGGCCGGTGACGACGGAGG +GACCGTCAGCGTATTGTCGATCACGCCAAGCTGCACGATCGTATCGAGAAGCTGCAGCGA +GCCGTTCGTGGTCGTCCCCCAGCCCGACGCTCCGTCCGCCCAGCCCCACCAGACGCCGAG +ATTTTTACCTTGTGCTTCTGCCATCATTGGCCTCCAAAGTCATTACCCCAATTCAAGCCC +CAGCCGCTATCTGCCGTGAGCCAGTGGGTGAAGGTGAAGTCGTACTTCTGGTAACACGTA +ATGCCGCTGCGCGTGCTCTCGACCTCGGCGCGAAGTGTAGCACCCTGACCATGGCCGACT +GCGGCTTCCGGGAAGGTGTACGTATCGGCCGTAATGCCGGTCTGCTGCACGATCAGCGTG +TTTGCTGAATCGTAGATGCGGATGTTGTAGGTCACGCCGGTTTCCGGCCCGACGCTCACG +TCTTCGTGGGCGACCAGTTTGTCTTGCTGCGCGATGCGGTCTCGATGCGCCCATGTGAAG +ATCAGGTCCCCACGGACGGACGAGACTTCCGCGTAGCGCTGGCCGTTCAGCTTCAGATTG +CCCGGCGGATATGGCATGTTCTGCCGCGCGACGATCTCGATTGTGCTCGTCGGCGCTGCG +TTCGCCTGCAATACCGAAGATGTGGTCTGCGTGCGGAACTGCACGGCGATTTGCATTCCT +TCGCTGAACTCGGACGGGTCTGCGCCGAAGTAATCGTCGTAGACCCATACGATATCGTTG +CGAAGATGCGCGGCCGGGAGCGTGTCGACGCAACCCCGTCGAATCGTTACCAGCTTCGTG +CCGATGTCGTAGCTGACCACCTCGATGATCTCGTCGCCGATAATCGCGGCCATGCCCGGC +TCGATGAGGTCGGTATCCTCGTTGTCATCGAAGCGCAATGTCGTATCGAACTGACCGAGA +GGCTGCGACAAAACGACCAGTGGCGTGAAGGCCGCCGTGTTGACCTTGCGATACGTGTTC +GTGATGCCGGGATCGTCCCATACCTGATACGACAGCGAGAAGATATTCGGCTTGCGCGCC +ACGGCGACAAACGTTCCGCTATCGGCCGGGACCTGTGCGAGATCGGCCGGCGACAACTGG +CGAACGAGATCACGATACGTCGCCTCGGTCGTGCGGTAGACGGCCGGCGCGACGGGTGTG +CGGTTCGGCGGGACGTACTGACCCGGCTCCGCTTCAACGTACGTCGTGGACGGCAGACCG +AAGATATCCTGCACGGCCGTGATCTGGAAAGACCCTTCCTCGTAGCGACCCGCCTGAATC +TTGCCGGCGCGCAGGATCATGTTCTCGATGCCGAGCTGCGGCACGCTGATCGAGAACACG +TCGGTCGGCGCGAGCTTCGCGGCCCGGCGATCGAGCGTGAGCGTGAACCGCTTCAACGGC +GTGCCGTTCGACTTCAGGTCGCGCATCGCCACGCGCATCGCGAGGTCGGCAGTCGGGATT +GCCGGGTACGCCGTTGTGACGCTATACATCGCACCCACGGCTCGCATGTTTCCGACGTTC +TGCGCGCGGACCTGCTTGTCCTCGTCGGTGATTGGATCGTGGTACGTGACGATCTGCTCG +TTGCGGCTCGTGTCGCTCGAATTGCCGTCTTGCGAGATGTTCAGCAGGCCGGACGTGTAG +TCGAAATGCGGAATTGTCGCCGGGTCGTAGTCCGAGCGGATCAGACGCAGCGTCAGCTTC +GCGGTCTTGCGGTCGAAGTAGATGGCCCCGCCGATGTGATTGAGAACCTGCTGCACGAAC +GCATCGAGGTCGTCCTGTCGGTTCCACCGAATGCAGAGGCCGAAACACTCCGAGCAGAGC +TTGTTGGCTGCGTCGGTGAAGGACTGTTCGTCAATCAGCTCACGCGGAAACCCCCTGCCC +CATTCGCGGTTCGTCGCGCATTCATAGATGATGTGCGCCGGGTTCATCGCCTTGATGGTC +TGGTTCGCCATCTGGATCGTCGCCTTCTCCGGATAGAAGACCGGGCCGTCCCATCCTTGA +ATCGATCGACGCACGCGGAACTTCCACGCCTTCGGATACGGGTTCATCGCGCAGATGAGG +CCGTCGAAAAACACCGTGAAGACGCCCCGGAACGCCGGCACGATTCCGCCGAGCATCGCG +GCCAGTCGCGGATTCACTTGCTGGGTCGCCTCACCCATCATGATGTCCGCGTTGCCTTGA +ATGCCGCCCTCCTTCTTGTCCCCGCCGAACAGCTCGGGCGAGTTGATGTAAATCTGACCG +CTAGTCGAGACGCTGCCCGCCCACGCAGTAAGATCGCCCACGGTGATCGCGACCAGTTCA +TCGACGGGGCCACGGCAAAGCGCCGCATGAATCCCGAAGTAGTAGCGATACCCGATGACG +GTATCTCCGCTTTTACCCCCGCCGCCCATTGCCGTTCTCCTTGTAGACTTCTTCCTTCAC +TCGTTCGAGCAGCGCGCAAGTGATGTGCTGCGTGTCGCTGATCTTCAGGCCGTTGCGCAG +CATGTCGCGAAACGAAAGCCCGTGCGACTTGAACCACTCCCGAGCGCCGCGCTCGCACAT +GCCGGCTTTGAAGATGTGCCGGATGTAGATCGTCGGTTCGTTCACTTCTTCCCTCCCCCG +GACTTGATCGGCGTCGTGCGGAAATTGCCGAGACCTACGACCGTCCAATCGCTGCACCAG +CAATCGCCGAACACGACGGCCTGCGGCGTGCCCTCCGTGGCCTGCGGGAAGTTGAAATCC +CCGAACTTCGCGGGGTCCGGTTGCTGCGCTTTCGGGCCGAGCGCCGCCGACAGAAAGTAC +GACGCGACCATGAGCACGAGCCACACGACGAATTGCATTTTTGTTCTCCTTAGAAGACAG +GGTTTCCGTCGAACGGGCTACGGCCGGGCATCCCGTTATACCCGCCGTAGTTAAGGTCGT +TCCCGAACTTGTTCTTACAGACGGATGATACGCGAGCACAACCCGGATACATCACGACAT +TCATTCCGATCGCCAGTCGATCCGCAGCGCCCATGAGCGTGATGCGATTGCCGACGTGCG +TTTCGATGCCGTACTGATCCCACGATCCCGGCTCGCGCTCGAACTTCATGAAGCCGCCAC +TGAACCACGGTGCGGCCTTCGAACCCGCCTCGGCGCACTCGAACCAATCGCCGCCCACGG +CAGTGATAACGCCGTTCGTGGCGAAGTTGTCCGGATTGAGTTTGCAGTTCACGTCGTACA +CGAAGTACGGGCAGCCTTTCGTGTATGCGAGGCGCAGACCGCCGCGCTTGAACGTCATCG +ACATCTGCTGCCCGACGATCTGCGCGTTCATCAGAGACGTGCGACGCACATCGGACACCG +TGCCCATCCACGCCACGTCCGCTTCGTTGTCCGGGTCGTTGTAGTGGTGTTCCCGGATCG +TCAGGTAGATCGAATCGGTTGGCGGCGTTCCGCGCCACTGCTTCACGATGTCCAGTGAAG +CCGCGCAGTCGAGCGTGATCGAATCGGCCGACGCGTCGCCGCTTTGCGAGTAGCCGCCGT +GCGCGATGTTCGTCGCAACGTACGTACTGTTGTTCCACGGGATATCGCGATCAGCGTTCG +TGTAGTAGTAGAACTTGCTGCCGTACAGGAACTCAACGAGCAGGAGCGGTCGCCCGTTGA +AGTTGCTCATGTCGATGTTATCGAAGCTCATTCGAAAACCCCTCCCCCGTTATATGGCTC +TTGGTTGACTACGTGCGTGGGAACAGAGATGTCCGCGTTAGGGTCTGCCGCGAGAAAATC +GAAGACGAAGTTTCCGGTGTTTTTGAACACGAACCATTCTGTCTGCTTTGGATTCGGATA +ATACGATGGAACTCCGGTCCCCGGATTTGGGTTCCATCGATACGTCATATAGGGATACGC +GCGCAGGATATTCAGATAAATGCCGGTGTTCGGGATCGCAATGTTATAGCAGGCGAAGAC +CAGCTCCTGAACAATCGTCCCGTTCACATCACGTTGTCGCATCTTCACCTTAGCCGGCCA +TTGAACGGTATCGAGAAACGCGGCGGTAAAAAGGTTGCCCCAAACGTTCGCCCCCATTAC +GTCGCCTGCCGGGTAATGTCCGCCTTCGACGGCAGTCGGATTCAGCACGTCGTTTGCTTG +CGTCTTCAGCTCGGAAATTTGAAGCGGGACTGCGCCGCAACCTGCTTGGATATAAGAGCC +CGCTTTTCCACCAAGCAACACGTCGATAGAGTTGATAGCAGCTTGCATCAGGCCGCTTGC +GATTGAGTTGTCGAATGCGGGAACGATGCTCTGCATCCAGCTTCCATTCGGGTCAGCTTC +GATGGCTGCTGCATTCACGATACTCGCAGTCGCGCCGCGCATACCTGCGACCATGGGCGG +GTTGCAATCCACCCACCAGTGAATCGAACCGGTTGAGCTGGTCGTCTGCGCTTGAACGCT +CGACGCGCTCGTGATCGATTCTAGAATTGCAGCGCAGGCGGTTGCGAGCAGTGTTTCTGA +CGCGCTATCGTCCTGCGCGCATTCAGTTATGTCAGTGGTGAGCGACTTCGCCGCCGCGTA +CGCGAGGCCGCCCGTCAGGAGGGAATACAGAAGAGAATAGATGTTGTACGCCAGAAAAAC +GCGAAACGCCGCGTGCAACGTTGCGTCATCAAGCGAAGCGTAGTACGCGTACCGATCCGT +GGTGATCCATGGGGTTCCTTGAATCGTCAGGAGCATATAGTCCCGCGTGTAATTGTTCGA +ATCGTTCATCGCCGCAAGCGTGCTCTGCCGCGTCGCCTCGGCTTGGTCCGGGGTGTAGCC +GCTGGCGACCATGATGTCGTACGTTGCGTTGAGGTTCGCTGACTCAGTTTTTGGATACTC +CCCCGCAAGCGGATCGACCGGCGGGCGGCCGTTCGTTCGAACGTCGCCCCATGCGCCGCA +TTCGCTGCCGCAAATACACGGGTCGGGCGTTTGCGTCGTCTGCGTATAGCGCGTGATGTC +GTAATTCGTCGCTACTCGATTTTCAGGCGTGCTCTGGAACGTGACAACTGCCGAGCTGAC +GCCCTTCGTGTCGGTCATGTGGTTGATCTCTACGCGGTCTTGATTAAGCCGCGCGAGCGT +CATGAACGAGACGCGCTTCAGGTCCGAGGCGAATACGGCTTGCGTGAACGCCGCGTCCAC +GGTAACGATCTCGTTGCCCGTAGTCTGGTCGAGCGTTACCCCCAATACGCGACGATACAT +TGCCGGCACTGTCGACCGACGCGGGTCGAGAATGATGTCCTGCTGCCCGTCAGGAAGGGT +CGAGAAGAAGTCAGCCAAGCCGCTGCGCTTGATGGTGATCGTCGTATCACCTGACTGGAT +CGGTTTCGCGAGCTGCATATCGGCCGCATGGGACGGCAGCCAAAAAGGCGTGACGCGCCC +GCGCAGTGCGTACAGCAATCCGCGCAGGTCGGCATTTTGCTGGCGGCCGTGCGCGAAGAA +AGCAAACTGCTGCGCGTAGAGCTGGATACCTGCGGTATCTCCGCGCTTCGGAATGCCGTA +TCCGGAATCGAGCACGTCCAGTAGCCGGGAATACTGAACCGTCAGGTCGCTCGTGTCGTC +CGGGCGAAGACGAAACACCGGATAGCCGCGATAGATGTCAGTCCATGCGGCTTCCGGGTA +ATCGTTCGTTTCCGTGACCTGCCAGTTGATCGCGTAGACGGCAGCGCGATCCGCCTTTCG +GGTCATCTGCGGCTGGTCGGTCAGCATGGCTTCCTGAATCGGAAGTAACTTCGTGCCTTT +CGGCCATGCCTGCACGAGGCCCTGATCGAGCGTGATAGTCGTAGCGGTCATATCGGCTAT +CAGCCGAACCTCGTAGTCGAATGAAGTCCGACCACGGAAAAAGACGAGGCCGCCCTTCTT +CAGTTCGGACGTGGTCGTATCCTCGACGTACACGACGGTATCTCCGACCTGCGCAGAGGC +CGTCAGCGGGTTCAAATCCCACGGAAGAGGGACATTCCAGCTCGTTCCGCCGCCGGCCGT +CAGCGCGGCGTTCAGGCGCGTGCGCTCGGCATCGATCACGAGCACGGACGTTTCGAAGAA +CCGGCGCGGCGATATCCGGAGCGAACGCCGCTGCTCGGCCGCCATATTCGATTGCTGCAC +GCTCGTCGCCCATTCGAGCGCTTCGAGTACGCCGCCGGACCATTCGGTCGCGGAAGACCA +GACGGGAAGATTGATGTTCGGCATTACTTGATCCCCAATGCTTGGCGTGCGGTTACGGCG +TTCTGCCGCAGGTAGGTTGTGATGACGGTATCGCCTGCCGCCGACGCCATCGCATCGGGC +ACGAAGTTCGGATCGGAGATCAGCATGTTCCGGATCGTCATCGGCTGCTTGGCGGCCTGC +GCTGCATTCTTCGCGGTCTGGTTCAGGATGTTGCGCGGATTGTCCTTCGCGAGTACTTCC +TCGCCCTTCTGAAGGATCGCCGCCTGTTCATCAGCCTTCAGGCCGACTACCGTGCCGCTG +TGGTAGCGCGGCGCGTTCGCAAACCAGCTCGCCGACGCACTGCGCGACATGCCGCCCGGC +TGACCGACGACTGCACCGGAGTGCGCAATGGCAGCAGGCACGGAAGCGCCAAGGCCCCAC +GTCCCGAGGCCGGTTCCTACGGCAGCCGGGGCAGCCGACGCAGCGCCGCCGAACAGACCG +AGCAGCGCCATCGCCGCGCGCGTCGCCATGATCTGCATGATGACGCTCGCCATCTGGCGC +AGGAACTGCGCAGCGAACTGTGCGACCGATTGCCCGACGTTCTTGAATGCGTCCGACCAT +TTCTGCGTGCCATCGGCGGCAGCGAGAAGCTGGTCAACGACGTTCGTCATCGTGCTGTCG +ATCCCCTGCGCGAAACCGGACGTGAACGTATCGCGAATCTTCGCCATGTCCTTGTCGCAC +GTACTGCGTCTGCGTGCTGATTTCCTTCAGCTTCGCATTGAGCGCATCGAGCTTGGAACC +GGAGATGTCGCCGGGCTTCGGCCATCGTATCGAGCAGCTTCTGCATCTCAGCGACCATGC +GCTGAATCTGCGGGCCGCTCTCCGTGTACGCGGCCTTGATTTTCTGGTTCGCCTCTTCCT +GCGTAATCGCGCCGAGCTGCACGAGGTTGTTGTACATCGTGACGGCCGAGTTCCGCTCAT +TGAGCAGGTTGTTCGTCTCGGTCATCTGTTGGTTGAATACGTCGAGACCGCCCTTCGCCG +CCGCAGATGCCGGGCCAGTGGCTGAATCGTTGCCGACGCGCGTCATCTTCTGCACGAAGG +CGTCGATCTTCGCGTCCGGGATGCCCGTGCCTCGCACGCTGTTTGCAAACGCCGCTGCAT +CTTTCGCCATCTGCGCAAGTTTCGGTTGCGATCGTTCGGTCTGCGTGGCGATCTGTTTGA +ACCCATCCACTGCCGACAGCGTGCCGGCTTTGACTTGTTCGAGCACGTCTTTCTGAAAAT +CCGCTCGCTCTTTCAGCACGTCGTTGACTTGTTCCTCTTTCTTCTTCAGTTGCTCAGTGT +TGAACTTAAGCGTTTCTTGCTGGATAGCTTGTTTCTTGATTTCCTCGATCTGCGCCTTGA +TCGCGGCGATAGGCTGGCCGTCGACCGTCGTGCCGCCGATCTTCTGGTACTTCGCGATCG +TGTCGTAAATGTCCTTGAACGTGCGCTCGACAGCCTTCAAACGCAGGTCAAGGTTGTCCT +TGTACTGCGACTCGACTTGCTTCCAGAGCGAATTCAGTTTCTCCGACAGAGACACTTCCA +TGTTGTACCGCTTGTCGGCGTTCTTGTCCTTCTTGTTCGGGTCCGCGATGTCGTACAAGC +CGCCGGACGTATCGGTCAGCGGTGTCGATCGGGGCGGCGTCGTTGCAAGGCGCGCGCCCT +GTCGACGGAGGTCATTCTGATACAGCACGTCGAACGCCGCCTTGTTGTCGGCCAGTGCTT +TATCGCGCTCCGCGCGAATCGAAGCGAGGTTGCGCTGCGCGAGTGTTTTGGCCTGCTCCA +TCCCGGTCTTAGCGCCGTCCGTGATGCCCTGCCGAGCTGTTCTGCGACGTTATCGAGGCC +GAGGAATTCCGCCGTGCTGCGCAGGCCGCCGAGGAAGCCGTTCTTCAGCGTCTGGATTTT +CTTCAACGCCTTGTCGAAGAAGTCCACGACAGAATCGCTCATCTGCGCAGCAAGCACGAG +AATGCCGTACTTGACGTTGATCCATGCCTCGTAGATCGATTCGGCCGCCGCAGTGCCGAC +CAGTCTCGCAGTCTCGAACTTCTCGCCGAGAATCTTCCCGATCTGCCATCCCGTGAACGC +AGCGGTCAGGACGAGGAAGATTTTGTTGATTGCCGCAAGCGCGGCGTTCAACCGATCGGC +GGCCACGGAGGCGGTCGCCATCGACGCGCCGGCTGCATCGACGCCCGGTGCAGCGGCCGC +CCCGGACGCACCGACCGCCGCCATAGCGAAGGCCGCTTGTGTGAGCTGGATCGTGAAAGC +CCCGATCGACGCCATCACCTTCACGCCGAGCACGAGGCCGATCACGTCGCCCACGGCGTT +GATATTCTTGATGACTGCTTCGAGGATGTTCAGGACGACCGTGAACGCGTCGGAAAAGTT +TCTCGCGAACTGCTTGCCGTCGTCACTACGAAGTAACTTCGTCATGTCGACGGCGAACTT +GGTCCACGCGTCCGCGAAGCCCATATCGGCGATCGCCTTCCGGAACTCGTAGAACGCGTT +GTACATGCGAGCCTCGGCGGCCTGCATATTATTGACGGCCATTGGGAGCTGCTTTCCGTA +CTCATCGCCGAGCTGTTGCGCGAAGCCGAGAAGCTCCTTCACCGAAACGCTGCCCTCTTT +GAGCCGCTTGTTCAATTCCGGCAGACTGATGTTCATGCCCTTCGCGAAAAGCGCGAATGC +GGCGGGCAGCCGATCGCCGAGCTGGCCGCGCAGTTCTTCCGCCTGCACCTGCCCTTTCGA +CATCATCTGTTCGATCGCGAGGAACGTGCCCTGCATGTCATCCGCGCTCATGTGCAGTAC +ACGGGCGGTCTCGGCCACTTTCTCGAAGATAAACCGCGTCTGGTTCGTCGTTGCGCCGGC +TGCCTTGGCCGACACGGCGAACTTGCCGTACGACGCGGCGAGATCATCAATCCGGATGCC +GAGGCGTTCGGCTTGCGCCTGCACGTATTGGTATTCCTGCGCAACGACTTTCGGGTCGTT +CGTTCCAGCGGCCACGGCGAGTACGGATTCGTTCGAGTTGAACTTCCGCATTGCATCGAG +TGCGCCCGCCGCAAGGTTAATCGCGCCCTGCACGCCGACGTACGCCGTGGCGAGCGCGAT +CAGCTCGCCGCGCACGCGCTGATACCACGACAGCGATTCGCGGTTCCCCGTCGTGATGCG +GTCGAGCAGCGAAACGGTCTTCGCCGCTTCCGCATTGTGTCCTTGCATCGCAGCGGTCGT +TGCTCGAATGCCGTTCGCCTGCTGAGACTGCGCTGTGAGATCTTTCGACGCGGCGGCAGC +TTCGGCCTGAGCGGCAGCCCGAATACGAGCGAGGCGAGCATCAAAAGCCTTGGCGTTCGC +ATCGTTCACCGCAGCCTGCGCAGCAGCCTCTCTGGCGGCCTGCTCGCGCCCGGCCGCTAC +GATGGCAGCCCCGGCGGCCCGCGCGCGGTCCTGACGGGCATTCAGGCGGTCTGCTGCGGC +AGCCGCAGCCTGCGTTGCCTGCGCCTGTTGATTCATCGCCTTGGCGACCTGCTCTGCCTG +CTCGGCGACTTGCGCTTCAAGGCCACTGAGTTCGGCCATGGACTTCGTCAGGCTGGCCGT +GCGGGCATTGGCCGCCTGCACATCCTGACCCGCCTTCGCGACGCGCTGGGTGAGTCGTTC +GAAGTCCCGGCCGCCGCCGGCCGCCGCAGCAGCAAGCTTGTCGAGTTCACGGGCGGTCGA +TCGAGTCGGCGGCCCGGCGTTGAGCGCATCACGCGCGAACATCTGGTACGCGATGGCCGC +GCCCTCGACGGACCGCTTATGGCGATCGAGGTTTTCGTTTGCGGTATTGAACGCCTGCGA +CGCCGCACCGGCTCGCGTCTTCGCCTGATCGAGCGCATCAGCAGCGCCTGACATGGCTTT +TTGTACGGCGTCAGCAGCCTTGGAGAGATTCTTCTGCTGATCGGAGAGGGAGGCGGCCGC +TTTGCCGAGACTGTCCGTCCCTGCGGTTGCGGCCTTCGCCTGTTTGACTTGGTCGGCGAG +AGACGAAGTAACTTCGTCAATCGCCTTCTTCGCGTCCTTCATCGCCTGCGCCGACATGTC +CTTGGCGCGGATGATGAGGTCGACTTCCTTCTGGTTATTCGTTGCCATCTCGGAGGCTCC +TAACTTTCTCGTTCAGGGCTTTCACGTCCCCGGACCAGACGGCGAAGATTGCCGCGTAAG +TTAGAAGCGCTTCGGTAGCAATCAGGCCGTTGATCCGTTGACGCGAGATTCTACTCTCAT +TCCATAGTACGGCGAGGGGGTAGTCCCACGCGTCCGGGTGTCCTTCGGCCATCAAGAGGC +TGGCGTCGCGCCGCAGTCCGAGATACCACTTCTCGAACCGCGACGGTTCGCCATCCGTCA +ACCGGTTCTCTTCGGGATCAAGCCTTTCGTGATCCCCCGGAGCGCCCCCAGCCGATTGAA +GAACTCTTTTGGGCCGCCTGCGTCCTCGAACGTGTGCTTCCCGATAGCCGTCAATGCTTC +GATCTGCACCGAGAAAGACAGCTCCGTTGCAAACACATCGGCCAGTGCTTCGAGCTGTTC +CTCGTAGTCGTCGGCTTTCCGGTCTGCCTCGTCGCACGCGAGCGCGATCATCTTCCCGAC +CAGTTCGGGGGCGTCACGCGTCAGCATCTGGATGAGAATGTCTCCCGACTGGTTCATGAA +TACGTCGGTCGTGTGGGCGGAATACGCTTCCATAAGCGTATCGATATCTTTCAGATGTTT +GTCCACGAGCTGCGCCACATCGGTCAACGAGAGACCCCGCACGCGCAGGGTCTCTTCGCC +GACCGGGATCGTGGTGCGCCGTGCTTTGTAGTCACGGAATCCCATTTCCCGGTTCTCCTT +ACATCGGCCGGCCGTCGAGGTACACGCGCTCCGTCGCCGAGTCCTTCTTCAGGACTTCGA +GCTTGAACTGGAGCTGCTGCCATGCGTCGCCCTTCAACTGGAAGTTGCCGTCAGCGGTGA +TCTTCGTGTACGGCATGAAGTAGTTGCGCGACGGGCCGTACGCGTTGTGCGAGATGAAGC +GGAACGCACCCATGATCTGATCGCCGGCCGACACGACCTGATCGTAGGTATCCGCCGCCA +GCTTGTACGTCACCGAGATGGGCTTCGTGTCGGTGATGTCGGCTGCATCCGGCTTGACTT +GGAAGCGGCCGTTCTTCAGGTCGATGTTGAAGTTCGTGAGCGGGATTTCGGCCGGCGTGG +CGTCCGTCGTCTTCGCGTCGAAATCGGTGACAGCGCCGACGCCCGCGATATTCGTCGGCG +AGACGCCGAGTTGATACCATGCGCCCGGCGTGACGATGATGGTTTCCGGTGCAACCGGCG +ACGCGCTGGCGGCTTGCGTGACCTTCGCCTTGCTGCCGGTGAACCAGAGCGCGAGGTTGT +CCGTCGAGATGTTGTCGACCTGAAGCGTCGTCGTCACGTCCTGTTGCAACGTGATGGTGA +TGTCCTTCACCTTCATCCCCTCGTCGGAGTCGAAGTGGTCGAGCATCGTGCTGGCGACGG +CCAGTTCGAGCGACGGCGAGTTGCCGAAGTACAGTTCGCCGGTCGTGTTGAACGTGCCCG +GAGCGAACTTATCGAAATAGCACTTACCCCGGCCAAGGATTTGATCTTGCGGCATGGTGA +ATCTCCTGTGGTGGATGAAAAGTTACGGCCGATACGGCAAAAGGTCGTACGGGTCCGTGG +TGTTGTTCGCGATCTTCAGGTTCAACGGCAGGTAGAAGTACGAACGTCCCGAAGCACCTT +CTGCGGGCGCACGACACACGCCGGGGCCTGCGCGCATGCCAGCAATGAGGTTTTCGAGCA +TGTAGACGGACGGATATTGAGGGTTCCCCGACGAGCTGTCAATGGCGATCAGTTCGCCGA +GGCGCACCTGCACGTCCGCCATAAGGCGATACGCTTCATCGGTCGGGTTCTTGTCCCCTT +CAGCATGGTTGACCCAGCCCTGCACCAGAAGCAGCCAGTCTTCCGATTGCGCCTGCCCGT +TCTCGTCGGCATCGAGGCCGTGATCGGGTCGTTGCGCTTCGAGGATCGACACGGCAGGGG +CAGGCGTCTCCGCGCCGAACTGCACTCGGTTTCGATAGATGCCCGACGAAAGGTCGAACT +GAAAACCGTTCGTCGGCGTGACGCCTTCCAGATGGGCGGTGAGCTTTTTCAGGATCACCA +GTTTTTTAGGATCGCGCTGCATGCTTTACTCCGAAAGACGCGTGAACTGGCGCAGGAATT +CATCGGCCAGTGCGTCAAGCACTTCAGTTGTGATGTCGTCCGCGACAGTCCGGAAGACCT +GATCGACGGACGGCCCGTATAGCAGGTAGACGTTGTTCGACAGCTTCGTCGCGCCATCCG +TCGCGTGCAGCGTTTCGCCGGGGCTGAGACGTACAGCAAGCCCGAGGTTGTACTTGTCCT +CGGTCAGGGTCTTGCCGGCTCGCAGACGCACCAGAAAGCCGCGCTTGAACTGCTTGGTGC +GTCCGGGCTTGACCACGACCGAGACGCCGCCCTTGCGCGTCGATTTAGTCGTCTGTCCCG +GTTCGGCGAACCGGGCGAGCGACGTAGGACGCTGGCGCGCGCCGATCACAGCTTCGAGGT +CGTTGCGCGTCGCCTTCTTGGTAACGCCAAGCCGGCTATCATCTTTCAGGTAGTTGTCAG +GGAAATTGACTTGCTCGCCGATCTCGGTGCGGGCGAGCGGGAGGGCCGTACGCTGCGCGG +TCTGATTGATCGCGATCATCGCGGCTTGTTGCGAAATGTCGGGAAGGCGGTCCACGTAGT +CCCGAAACTCCCCGAGTCCTTCAGCGACGATTTCGATGCTCATTCTGGTCCTCGTCAGGG +CCGGACGCGCTCAACCGACCACTTGATGTCTACGAAATTGTCCGTGTCGTCCTCGACATC +GAGGCGGAACGTGAAACCGTAATCCGGAAACGTCACCGAGCCGTCGCGCTGCAATGTGAT +GCCGAGTGAAGTTACTTCCGGTTTGTTGAAGACCAGATAGTTGATGCCCTCGACCATGCG +TGCGTACCCTTCGCGGTCGAGATCACCGACGAGCGCCATCTTCGTGTGGAAGCGAGCGGT +CAGCGGCGTCTGCGCACCCGTGACGGGGTCAGCATAAAGCGCTGATACCGCCAGAGTGTC +ATGGACAGTCTGACGGACCAGCGCTTTAAGGGCGGCGAAGTCGCCGACCATGGCTTACAG +GCCCGAGGCCGACGCTTTCGCGCGGGGCTTCGCCGGCTTCGACGCCCCGGCCTTGTCGCC +GTCTTCGCCTTCGTCGCCGGCCGGGGCGTCTTCGACCTCGACAACGTGGCGTTGCAGGAA +TTCCTTCCCGTGGCGCTCGTGCAGATGCTCGATCTCGTCGTCGGTGAAATCGAACGGCTT +GCCCGGTGCGGCGTGAACGATCTTCCCGTCGCGGGTGGTGATGACGGTGTGCTTCGGAAC +GCGCTTCGGCATGATATTGCTCCTGTTGATTCAGATGAGAAGCCAGCCCCGAAGGGCCGG +CCGATGACCTACGCTACGCGGGTCGCGTTGTGCTTACTTGACCGTCATGCGGAAGGAAGC +GTTCGGCTGGGCCGGGACCATCAGCGGCGCGCTCTGCGTCATGAGCATCGCCACGGACGG +GTCTTCTTCTTCCCACATCTTCGGGAACATCCGGGTCGGCACGAGACCGTTCTTGAAGTC +CATGATCGCGCCGAAGCACTGCGTGCCTTGGAGACCCGGACCCGTCCCGACCACGTCGTA +CGAGCCGAGGATTTCCTGCTCGGTGTTGTCGTCGCCGGTATAGGTGTCGTGGTACGTGTA +GAGTTCCAGCGTACCCATGCCGTTATAGCCGCCGATGGTGCCTTGATACTGAACCGGCGA +ACCGTCGTCCAGTCGCGAGCGGTTGAAGTCGGACGTGCTGCCCTTGTAGAACAGGTTCAG +CAGCTCGACCACGGCGGGTTTCTGCGAGAACAGCGACCAGGCGTCGAGGCCCATCGTCAG +TCGCGTGATCGTGCTGTTCGACTTCTTCCACGCCGTCGTGCGCATCGTTTGGATGTTCCC +CAGCGGATCGGACGTGGCCTGATCCCACGCTGCGCCGCCCGTCAGTTGCACGGTGAGCGC +CGGATCGCGGCCGAAGTCCACGCGTTGCATCGGGAACGCTTCGCCCACCACGTCCACGTA +GCCGTAGATCGTCGCCATTGCGCACATCCATTCGATCCGGTTCTCGATGCGCTGGCGCTG +TTCGAGCTGCGAATCCGCGACGACCGCTTGGAAGCGCTCCTGCAACGACATGCCGCCGAT +GATCGGCTGCTCGCCGGCACGACGCTTGAGCGTACGGTTCGGGTTGATAACGTCCTTCGG +CTTCACATAGGCCGGACGGAACGTCTTCGTCGTGTATCCACGAGCAGCGATCACGCGGCC +TTGCACGTTCGGCGCGACGAACGGGGCGAGCTTCTTGTCCTTGAAGACGAGGTCGAACAG +AATCTCGTCCGTGTCGAACGTGATCTCGTTCGGGTAGAAGCCCTGCCAGTACATCGACAG +CGCCGGGCCGGACTGAATCACGCCAGCAAGGGTGAGGGTATCGAAAATTTCCATCTTTGT +TCTCCGAGTTGTACAGGGTTTTCTTGCTGGCGCTCGTTACAGCGACGAGCGTGCGGTATC +GACCAAACGATCGATGAACACCGGCGTGCCCGCGAAGGCTGCTTGGCGTTCTTCGAACGT +ATCGGCGGCGGCGTCCCACACCAGTACGGCATGGTTGAAAACACCGCCGACGAAGACCGG +GTGCGATACCGTAGCCGCGCCGGCCGCCTTCGGCTGCGCCGAAATGCCGTACGCCTTCTG +CGAGCCGTCCGAGGCGGCCGGGTTCCACGGCACGAGCAGGCCGCCGACGAGCGCGACGAC +ACGGTACTTTTCGAGGACCGTGGCAGCAGCCACGTTCGCCCGCGTCGTCACGATATCGGC +TTCGCCCGCATAGAGCTGTTCCGGGATGTACGACCCTTCGGTGCCGTTGCCGGCGAGATC +ACGATCGATCATTTTCTTCTCCTAGCTAGGTTGGAGGATTGTTGCTGTATTCCGGCCGGA +ATACCGATTACTTCTTCTGCTGGATCAGGTCCTTGCGGCCCGTCGCCTTGGCGAGCGACG +CGAGCAGCACGTTGCCGCCCTTCTTGCCTTCAGCTTCGTTGCCCTTGCCGCCGGCCGGGT +CCGCGCCGACTTCCGGGTTGCTGCTGGAGTCCATCGCCTTGTGGAACGCCGTGGCGTTCT +TGCTCGTATCGGCCGGATCGGAAGTAACTTCCGGTGCGGCGGCAGCGAGCATCACCTTCG +CGTCGTCAACGGACATCTCGGTGTTCAGTGCGATGTGGTTTGCCAGTTTCGGCTTACCCT +TCGCTTCTTCGCAGTTCAGGATGCCTGCTTGGCGCTCGCGGTCGGCCTTGATAGCAGCAC +GGCGTTCGGCGGCCAGTTGTTCTTCGGTCAGTTCCATCTTCGTACTCTCCATGTGGACTT +CGGTTTCGGATGTCGAGCCGGAAAGCTCGTTGAAAAACGCAGCGACAGCATCTACCGGTT +TTGCCACCGCGTCAATCAGCCCGAGGTTCAGCGCATCGTCTGCCCGGTACGTCTGAGCCT +GCGTATCGCGAACTTTCTGGCTGTCCATCCCACGGTTGCGTGCAACCAGTGAGACGAATT +CGTCGTACGAGGCGTTCACGTCGGCCTGAATGCTGGCCTTCACTTCTTTGCTCAACGCCT +CGTAGGGATTGCCGTCGACCTTGTGGTCGCCGGCATGGATGAAAGTGATTTTGATGCCCA +TGTCATCGAGCATCTCGGACATATCGACGTGCATCGCGACTACCCCGATGCTGCCCGCCC +CTCCCGAGGGCGTCGAGACCACCTTCGTTGCGGCGGAAGCGATGGCGTAGGCGGCCGAGT +AGCAGTTCGAGTCGATGACGGCCATGATGGGCTTTTCGTCCCGCGCTGCGTAGATGTCGT +CGGCCAACTCGAAGCAACCCGCTGCTTCACCGCCGTAGGAATTGACATCGAGGATGATGC +CTTCGACATCATCATCCGCGAGAGCGGCGTTGAGTTGCGCCCGTACGAAGTTGTATCCCG +TGACATAGCCGAAGCTGTAGTTGAACCGGTTAATCATTGTTCCTTGGAGCGGGATGATAG +CAAGCCCGTTGGAAAAAGCAAACGGTTTGTTGTCGGCCGCGCTCTGAAAGCCATACGCCT +GTGCGAGTTGCGTGCGCTGGACCTTCATGAAGTCGTCGTGTTCGAGCGCGTTATCGGCCG +CCGCGAGCTGCTTCATGTCCTGTACGAGGCCGGCGTAATGCGCGGCGACCATCTGCCCGC +GCAGGTTGAACCGGGTGATTGCGATGTGTGCGTCGCGTCGTGCCATCTTCATTCTCCTTG +TTGACTGGTTTGCGCAGCAGCCGGGTCTTCGGCAATGCCGGTTGCTGCGTCGCGTCCGTC +GCCGAGCGAGCGCTTCGCGCTCAGATTGAAAGTGAGACCGTACTTCTTCAGCAGGGCGTC +CTCGCGAGCGCGCTGCGCGAAGCTCTTTCGGAAGTCTCCGCCGAGGCGCGCGATTTCGCG +CTCATAGGTCGAGAGGCCGGCATCGATCCGCATCACGGCTGCCTGCGTTTCCTTCAGTTG +ATCGATCTGGCCTTGCGACGCGCCGATCCACTCGCATTTCGACAGCGCTTCCTTCATCAG +CGGCTGATAGAACAGGTCCCGCGTCTGGCCCGGCGGCATCGGGACTTCACCAGCCGCGAT +AGCCTCTTCCAGCCACAGCGTGAAGAACTCGGTCGCGAGGCGATCGGCGCACATCTTCTT +GCGCCCTTCGAGGAAGCGCCGCGTCATCGCGATGCCGGCTTGGATGCTCGAATAGTTCGC +CTTGCTAAAGTCCCGCGTGAACTCTTCGTAGCTCATCCCGAACGCCGACGCCAGATGCCG +GTTGAGCGACGCCTCGAATTCGCTACCGACGCCGCCCGGCGTACCCATCGGCTTCAGGTT +CAGCTTCGTGCCGGGAAACAGATGCGGAATCTTCGCGCCGTCGATCTGGATGTTGTTCGC +ACCGCCGACGTACGCCTTCAGCGCGTCCATGTACTTCCCGAAGATGCCAACCATGTCGGC +ATTCGGCGAACCGCCGGACATCTGCGAATGGATGAACTCGGGCGGCAGCTCGGACTCGAT +AGCGGCCGCGTACGACGCGTTGATGACGGCGTTTTGAAGCGACATTTCCTTGAAACGCTT +CGCCATGCGCATGTCCTTCAGGCCGGACACGATATCGGCAATGCCGCGCGACTGATCCGG +TTCGCGCGGTTCGAGGATGTGGATGACCTGACGACGGCCCCACGGCTTCGATTGCTGTAC +GAACTTCCATTTGTACATGTCCGGGGCCATCTGGTACAGGTCGCCGGGGTGCGCGACCTG +AATCCAGTAGCCCTGCGGCCGGCCGCGCTTGTCGTACTGCACGCCGCGTCGAAGCGTGGG +CGTGTCGAGTTGCTGGTACGGGTTCGACAGGCGGTCGGTCGATACCATCTGGAAGCAGGT +CGCGTACGGCCGGTTCGCCGCGCGGTCCCACTCGGCAGTCGCCAGCACTTCGCCGGTTTT +CACGTAGCCGACCACGCCAAGGCGGATCAGACCGGTGAAGGTCGAGATCGCAGCATTGTC +GATGTAGCAGGCGAGGGATTCCGCGTACAGCTCGAACTTCGCTTCAACGATGGTCTGGTA +TTCCTCGGCCCATTCCTCGGTCGCGCCGGGGATGACGTTGATGTCGGGCATCGAGTTGAG +CCGGTACTGCGCGCCCACGATGCTGTCGCGCTGATAGCCGACCGCGCCGTTCGTGAAGCC +GTCGTTGTCGGCCATGTCCCGGCCGCGCGCGTCGGCGATCCGCTTCAGCGGGTTGATGAG +GGCATCCGGCGAGCGAAGGCTGGGGTTCCACGACACGGTCTCTCGCGAGAGCCGCGACGC +GCCTTCAAGTCCGCCGCCGCCAAGCGAAGCCGACTGTTCCGGGCGACCGGAAGTAACTTC +GGACAGTTTGCGTACGGTAACTTTGGTCATGGTCAGAAGGTGAACTGAAGGGGGCCATTG +GAACGACCGCCGCCGCACGGGCCGCAGTCACCGCATTGCGCTTCGAGCTGGCGGATGTAG +GTCACGAGGGCCTGCTGATTCGCCGCCGTGAATTCTACGCGTTCGCCATTCTGGTCCACG +ATCACGCGGGCCGAGCGGCCGGTCAGCAGCTTGTGGTACGCGTCGCGGCGCCGCCGCGAG +GTACTGCCGGCAGGTTGCATCATCGAGACAGGGCATTCGGTTTCTCCGGTAGTGGGTCAC +GCCAGCGCGGCGGCGATTTTCGCGAGATCATACTCTTCGCTTGACTTTTCCGCAAATCTC +TGTTCGCTGGCATCCGCAACGAGGGTGTTCTTGTCCCACTCTTCGGCCCAGCTCGGGGGC +GACGACCAGTCGAACTTCTCGGTCAGCAGGAGCACCGATGCGTTCGCCCCGAGGCAGTAG +TAGAGCAAGTCCCACGACTCATTACGCTTGACCGACGTGGCGACCCATCCCTTGTCCGTA +CGCCGCTCGGAGACGAGCTGGACGTAGTAGCTGTCAGGCAGCCATTCGGGGAAGTGAACC +ATGCCGCTACCGGGCGTCACCACTTCAAGCCGGCCGAGCGCAGTGTCTTTCAATAGGTTC +GAGTTCAGGAACAGAACCGGTACGTCTCCGCGCGCAGCAGACCATTTGTCCTTGTGGTTA +GCGTCCGGGTAGCCGACTCGCGTGCGCGGATGCCCCGGCTTAGGCTCGCCCTTGATGAGA +TGGAAACGGCCGTGCAGACCTTCTTCGCGAAGCTGCCGGTAGAAGTTGTACGCCATCCCC +GTGACACCTTCCCGGCCGCCGGAATCGCAGAAGGTCATTTTGAGCTGCATCACCCGGCCG +CTGTCATCGTCAAGCGGATACATTTTCTCCATGACCTGCGTACGCACTTCCTGCCAGTCT +TCGAGATACGCATGCGGCTTCACCCACTCTCGGTCTCCGTCGTGATCGACGCGCTGCGAC +TTGATGACGTTGAAGCGGTCCACGACATAGATGTCGTACGGATTGCCCGGCGCAATGCCG +AACACGTTGCAGACCCACATGTTCTTCTGCACGTCGCAGATACCGATCAGGAAGCGGACA +GCCTTCGGAACATGTTTCTCGCGCAGGACTTCGGCGCGCGCCTTCAGCGTCTCCGGGAGC +AGGACCGTTTCGTTGCCGCGATGGAAATACGGTTCCCCGAGGTCGGTGTTGTAGAACTTC +TTCAACGATTCCTGCGACCCGGTACGCTCGTAGTCTTCTTCGGCCGTGATGTAGTTGGCG +ACGAGTTTGCGCCACGAGATGAACGCCGCCACGACGCCATTCATCCAGAAAGACGCAATG +CGCGAGCGTCGCGGCGTGCCGACCCGCTTGTCATCCGCCGTCATCGACTCGCCGTCCTTC +AGCCAGACGCCCCACAGGTCGAGATCGTTGCGCTGATCCGCTTCGATCCGGCCGCCGCAG +CACGGCGCTTCCATGCGCACGGTATCGGCGCACGATACAGCGTCGCCGCAGTCATCCCAC +TTCAACAGCTTGAAAGTCGGTTCGAACCAGTCGCCGCAGTGCGGGCACTTCCAGTATCGA +CGGCGACGGTCGCCCCGGTTGTACAGGCCGAGAATCCCCTTGCATGGGGGCGCTTCGTGC +GGCGATGAAGCCAGCCACTTTCGGCCGTCTTCTTCGATCTCACGGGACGGGCTGGACTCG +GCCAGCGTCATCGCGAACGAACCGAACGTCGTGGTCCGCTTCGACGCGAGGTCGAACGGC +TCGCCGTCGCCATCAACGTCGTCCGGCATGCGGTCGTAGTCGGTCAGGCATACGCGGCCG +ATCGGACGGCCAGCGAACTCGGTCACGGACGGCCACGACAGCGTCAAGATCGTGCCGTCC +TTGTAGTGCTTGTCGAACTTGTTGTCGGTGTCGCGCGAGCGCGCCATCATCGCGCCGATC +TCAGGAGAATGACGGTGCATACGATCGATCCGTCGCACGGAGAAGTCGCGGGCTGCTGAG +TTCGTCGGGCAGTACAGGATCATGTCCATCGGGTCGACCTTGACCGTGTACCCGACGAAG +TTCAGTAGCAGGCCATCAGTCTTCCCGCACTGCGCCGGGCCGACGAAGACTTCCGCGTCG +AAGTCACGGGACGTGAGCGTGTTCATTGGTTCGACCATGTACGGCACGGTCTCGTTGAAC +CAATCGCCCACGTACGCGCCCGGCGTGTTCAGCTTTCGGTACTTGGCGGCGGCCTGCGAT +ACGGTCAGGCGTTCCGGCGGCCGGAAGATGTCGGCGAGGTCGATGACCATCGCCCCGAGC +GACTTATAGACCTGCTGCTGGGTCGTCGTCAGTTCCTTCAAAAACGCTTCCCGCGCTGTC +GCGATCTTGAAGTCCTCGTACTCCGTCCTCGCCGTCGCCACTTCCTCCGCTGTCACCCGT +TGATTCGATTCGTTCGGCTTCATGGTCTCGTTCCGGTTCGTGTTTGAATTGTTCGATAAG +AGAGTTGCGCAAGCTCTTCAACAGTGAGTCGGTCATCTTGCGAATGATGGCGCGCTGCTT +GTCGCTCAGTTCGGCTTGGCGGTCCACCGAATCGACCATGAGAAGAATCTCAGTTCGCAG +CGTCTTGAACGACTCGGCGTAGTGTTGAAGTACCTTCTCGGTTCGCCAGAGATCGCCCTG +TTCTTCCTCGAATTTCAGGCGCGCATTCTGCCCGCTCCAAAATTCCTTCAGCAACATCGG +CGGCAGGTCTCGATGGTGCATCTTCTTGATGTGTGCCTCGATGTCGCCAACCGGATCAAC +GAGGTATCGGGCCGCCTCGGCCACTTTGTAGATCGGGTGTCCTTGGCGCTTCCCGCACGC +GCGCAGCCCTTGAATCCGTTTCGTCACGGTGCGGTTGTCCATGGTGAACAACTGCCCGAG +TTGTGAGATAGACGCGCCATCGAACAGGATTGCCTTCGATGCGCTATCCGCTCCGCTCTT +TTCTTCTGCCATGCCGGCCTCCGTTTTTGTCAGGGTTGAACGTTATCACAAGCCCGCAGC +CGTGGCAAAGTTGTCACTGTTCGCTGCTCGCTTCTTCTTGAACGCTGCTCGCAGACGGCG +AAGACGCACGAAGAGATCGTCCTGCGCGTTGCGCTTGCGAGTCAGGCTCGATACCGCAAC +GTCGTCTACCGTGCCAATCATCGTCGCATGGTGGACGCGCACTACATGGCGCTGGCCCTG +CCGGGCGAGACGACCGATGAGCTGAAGATATAGTTCGAGCGAGTAGAAGATGTCGTAGAT +ATAAAGGTGATGGCCTCCCTTCTGCATGTTCAAGCCGTGTGCCACGGACGCCGGATGAAC +GAGCAAGATTTTGATCTTGCCTTTGTTCCAGTCGCCGACAAGTTTCCCCTCGGCGTCCAT +TACGCGCGCTCTCGGGAACGCCTTCTTCAGTCGTTCGAGGCTGGATTTGAACCAGTACGC +TACGAGCAGCGGCTCGCCGTTCAGCTCTTCGACAAGTTGCGTCAGGTCTTCGATCTTGTG +ATCGTGTACCCAATGCGTCTTTTTCTCCGCGTCATACACACATCCGGACGCGAGCTGAAG +TAACTTCTGATTCAGCGCGGCTGCGGTTTCTGCTTCGATCTCGGTTCCGTCAGGAAGGTC +GAGGATGAAATCCCGCTCGAACTTCTTGTACATAGCCGACTGCTCATCGGTCATCTTGAT +GGCGCGCTTCAACAGGAGCGGCTTATCGACCTTCAGGTAGTCCTCTGCCTTCATCACTAG +GCAGATGTCAGCGATCTTCGACAGGATTTCGTTCTCGCATCCCGGCCGCAGCTTGTACGT +TCGCGAGTAATGGTTATACGTGAAGTACCGGTTGCGGTAGTACGTGATGTTGTTGCCGAG +ACGTTCTCCCTTGTCGAGAAGCCACATCTGCGCGAACAGGTGTTCATAGGTCTCGGCAGC +CGGCGTCGCGGTGAGAAGATGCAGGCGCTTGATATACGGGCGAACGGTCTTCAGCTTCTT +GAAACGGATCGAATTGTGATCCTTGAACGACGACGATTCATCGATAAACACGACATCGAA +AGGCCACATTTCCCCAAACAGGTCGATGAGCCATTCAAGCTGTTCCCGGTTGATGATGTG +AAGGCTCGCCGGGGTGCGCGCGAGGCGTTGAAGGATCTTTTCCTTCATCTCGGCTTTCGC +TCGCGCCACGTCTCGTTCAAGCTCGGGATTCCGTTGCTTGCGGCCGTCGTCGCCTCGTGT +TGTGAAGGCCCGATAGTCGGAGCGAGCGCGTTGTTTCCTGCCTGCCTCAGCGATCAGTTC +AACCGACTTCTCGTCTTCCGCGCGGATCAGGACATGGGACATGTACGCCGTGTGCTGCCA +GAGCGGAATCTCGTTCGGCCAAGTCTGCGTAGCGACACGCAGCGGCGCGATCACGAGACA +GTGCTTGTATGCGAAGCGCGAGAGTAGCCGATCGAGCAGCGTGAGGCAGATGACCGTCTT +CCCCATGCCAAGGTCGATGAACAGTGCGCTGAACGGATTCTCTTCGAGAAAGTCCACGCA +TTTGTCCTGATACGCATGCAGCTCGATCGGATCGTACTGCACTCCGTGGAACATCTCAGA +GATGGTACGACGCAAGGATTCGGATTGCATCTTCATGATTGTCAGCCCAATGAACGTACG +CGCCGTGTCGACGCATCTCGTCGTGCTTGTTGTACTGGTGTCGCTTCGGTTCTGCATCCT +TCCGCTTGAACTCGATGAAAACGACGATGCCCGACCGGATATACATTCGATCGGGCACAC +CACGCTGACCGGGAGAGACAAACTTCGCAACAAACCATCCGTTTGCCTTCGCCCAATCGT +TCGTTTGGTCCTCTATGCGCGTCTCCCGTACGGGAGGATCGGAAGTTACTTCCGATTTTT +TTGGGATCGGGAGTAACTTCACGTCAGTCCTTGCGATAGAACGCGGCCGACCATCCGGCT +GCGCCAACAGGCATCTCTTCGTACCACTTGCGCTTCGCGGTCATGCACTCCTTCAGGACA +TGCAGCCCCTTCGACGCGTCGCCGATCTTGCGCAGGGTGACGATTTCATCGTGAACGTGC +AGAACGATATTGAGGCCCTTCTTATGCGCGTTGAATAGGCCGTACTTCAGGATTTCCCGT +GCGATAGCTTGCACGAGGTTTTCAGTCATCTTACCGCCGTGCGAGTCCTGCCGCAGCCAC +TTCTTGATGTCCTGATTGAAGCCCATGTACGAGAAACCGATCTTCTCGTACGTCTGCGGC +GAGCCGTCTTCGTTCCAGAGTAACTCGCCTGTCTTCCAGTTCTTCTTCTGGAATTTTTTC +TTCTCGATGCGCGGTCGATGGTAGTACATCCGGCGACCGCTCGGCAGGATCGCCACGAGG +AATTCACCGACGATTTCAAACGACACATAACGGACGCGCGTGACCGCCTTCGTCTTGATA +GTGCGGATGATAGCGGCTTCGAGGTCCTTCCAGAGCTGCGGGACCTCGGGGTACGCCTCG +CGGTACATCTTCACCGAGTCGTGCGCCTCTTGGCGGGACATGTCGATACCCATGTTCTCC +GCGTAGCCCCACAGACCGGTTCGCTTGCCCTCATGGCTTAGGTCGCCGCCGCCGAGTCGG +TATCCCGCGCCGAGCACGGCCGGTTTCGACATCGTGCGCATCTGCGAAGTTACTTCCGGG +TACTCGACGCCGTACAGCCGCGTCGCGAATTCTCGGTACGCGCAGCGCCCTTCACGGAAC +ACGTTCAGCAGCGGCTGGCAATCCGCCAGCCATGCGATCACGACGGTTTCAATCGAGGAC +AGGTCGCATGTGACGAACTCGTACCCCTCCGGAGCGTAGATCGCGCTGCGCACGCATCCG +GCGAGACCGTCCATGGGTTCCTTCATCATCAGGCCGAGCAGGTCGTAATCCCCCGCTCGG +ATGGCGTTCGTGACCGTGCAGAGCGCCCAGTCGTTGTCGCCGTCCGGTTCGAGCGCTTTC +GGCGTACGGCCGAGGTTGTGAACCTGAACACCGCGTCCCGCCCAGCGCTGCGTGCGCTGC +GCGCCTCCGAACTGAAGGGGAAAACGGAGACGCCGGCCGGGGCCGACGAGGGAGACGAAC +TTCTTGTACTTGCCGACCGACGTGCGTGCAGACTGCATACGCATCTTCAGCACTTCGTCG +CACCGCCCCGTCAGCACCGGTTCGTCCTTGTGTTCGGCGAGGACCTTCTTGACGGTATCC +TTGCCGAGGTCATCGAAACGATACCCGCGTGCCTTCACCCATGGTTTGAGCTGCTGCGGA +CTGTTCGGGTTTTCAAGGCCGGTGATCGCGCGCATCTGCCGAACGAGTTCCAGCTTGCGG +CGATCTGCCATCGCGGTAGCGCTGTTACAGAAGTCGAGATCGACCGGCACGCCGCGATCG +TTGATGAGCTGATCCAGCTCGTACAGCTCCCATTCTTCATCGAGCGTCGGATACGGAGCG +AGCCATTCGTCAATGGCGGCTTCGGCGATCACGTCCTGTTGGTTATAGATCAGGAAGTCG +TCCCATTCGAACGGGTTGGTCTGCCAGTCGAGCCACTTGTGGGGGTTCTTCTTCGTGATG +CGTTGCGGCTTCGAGAACAGGTTGATTAGCTTCTTCCCGGTCGCCAGTTTGACCTTGTCC +TGCGGTAATCCGAGCTGCCCGCCGACCATTTCGAGGTTTCCAGCGAACGACAGCATGTAC +GCACGCGCCATCGTGCAGCGCCAGTTTTTATACGGCGTGTTGATCTTCAGCACACGACGC +GTCATCACGCGCTCGAACTGCGCATTCCACGCCCGCTTGATGACGTTCGGGTCTTCGAGC +GCCTCGCGAACTTCCGCCGGGAACTTGCCGTCTCGGATTTCCCATTGCTGCACGCGGCCG +CCGTTGAACGACCAAGAAGCCATCAGGATTTCAGTGGACTCGTGCGCCGAGTAAATGTCG +AGGCCGCACGTCGGCAGGTCCTCTTCGCTACGCGATTCGTAGTCCAGTCGAATCTCGTCT +TGCATATCAGTTCTCCGGATTCGCGAGGTCGAGCAGCACGTCGCCGTGGCACGCTTCAGG +TGCGCAGAAGCAGACGAGATTCCGACCACGGATCGTAGGCAAGAACGACATCAGCGAAGG +GGAGTTGAGGACGTGCTCTCGGTACTTCGCGATAACCTCTTCGCGCGTTCCGTCTCGGCC +GATCACAAACGGGTTGCCCCACACCGAAGGGCGGCCGATGTAAATGCAGTCGTCCGGATA +GTCGCCTGCGTTCTTGTTGAATACCTGCGGCATTTCAGCACCTCAGAAGAAAAAGACCCC +GGCACGTCGGGGAATAACCGTGCCGGGGCGAACAACCTACGCGGAGGAATCGGAACCGCG +CAGGCAGGCGAAAGGAATTACAGGCCGCCGTTGTCGTCGTAGCCCTCGGCGAGCGCTTCC +TCGCCGTCCGACACGTCGTCAAACGAATCGTCAATTTCGTCTTCGCTGATGCGGCCTTCG +CCGATCGGCTCGTCGTCACGAACGAACTGGACCGCAAGCAGGTTCGCGTTGATACGCTTG +CCGAACTTGTTGTCCTGCCACCACGGGTTGATGAGAATGTTCACGCGGCAACCGGCGTAG +ATGGTGTTTTCGATCTCGCGCTCGCCGAGAAGACGCTTGTCCGCGCCGCGCACGCTCGGA +CGCTTCGTTTCCGATGCATTGATCGTGTAGCAGCCTTCGTATTCGTCCTTGCCCGACGCG +TCGCCGTCGCGGAAGAAAAACTTGTCGGTCGGAATCTTCTTGCCGTCGTTCTTCTCGCGC +AGCATCTCGTCGCGCATTTTCTTCATCACTTCGAGAACGGACTTAGCGAGGTCCTTTTCG +ATGAAGCCGACGAGCGAATACTTCTCCTGCCCTTCCTGATCGTCGCCCTTGTAGGGCTTC +GCCAGATGGGGGTAGGACGCCCGCACATTCTCGATACGCATGGTGCCGTCCGTGAAGACG +ACAACGTTCTTGCCTTTGAACTTGATTTCGCGTGCCATTTTGCTACTCCTTCAGGTCTAC +CGTTTTACCGGTCTAGGGTTTCAGGGTCTACAGGTCTACGGGTCTACAGGCCGTCGTCCG +CAGTGAGGTCGTCAAAGCAGTCATCGGCCACTTGCCCCAGCTTCTCCCGCGTGTCTGCGA +CAGGAGCCAAGGTCGCCTTGCCCGGCGCTTTCGCGACGAGCGGGGCGATAATTTTCTCGG +CCGCTTTCTTTCGCATGCCACTCGCGACGAGCAGTTCTTCTGCTTTCGCGGGGCTGACGA +AATCGGTCGAGAATAATGCGTTTTCCTTCACGCCAAGGAATGTGAGCGTTTCAACGGCTT +TCGCCTGTTGCACGTTCCAGCGGCGATTCGATCTGGATGCTACCAGTTTCATGCCGGGGA +TGTCCTCCCCGTTGTGCGCGCGTCGCTCCAACTCGGAGTCCATTTCGCTGAACCAGCGCT +CGAATACCTTCCGGTACGGAAGTAACTTCGCCATTTGTTCAGTCGAAAGCTCGGAAACCG +GAAGTAACTTCGTGCTCAATTCGCCGCGCATCAGGACTTCCTTACTGCTCGACATCTGTT +CAGCGGTTACTTCGGCTGTCAGGTCGTCAAAGCAGTCGTCAGAAAGCCTGTGCGCCATCG +CGAGAAGCGCCGGACAGGTCTTCTGCACCTTGCAAAAACGGCATCCTTTGTCGGACGGCG +TGAGCGGCGCACCTTTCTGCCAAGCGAGAAATGCCCGGACCTTCACGAAATCGGCGAAGC +GAAGCAGCTCTTCCCGTGTGGTTTCCCACGTCTGGAAGTGTGCTAGGCGCGGTTGCGAGA +TGTAGATGACGATCTTACGGAATCCGTAAATCCAGTCGTACTCGTAGAGCGCGCCGAGCG +CATAGAGCATGGCTTGAGAATTGCCGTTGATAATCGTCTTGCCGTTCTCAACGATGATCG +AACGCGGATCGTCCAGTCGCAACGCCGCGAAGACCTGAACACCACGGCCGAACTTGTGGT +CGAAGATGTGCATCACACCGGGTTCGAAGCCGCCCACGTCCATCGTGCCTCCTTGGCGCG +GAATCGGGGTGAGCTGGGAGAAGTAGACGCGCTTCTCGATATGCAGGTCGCCGGGAAGCG +ACTGCGCCCATTCGACAGACTGCGCGACGTACTCCATCATCTCCGCGTCGATCGTGATAT +CGAAAACGGTCTTCCCTTCGGCGACCTGCTCGACCGTGCCGAGCAGATGATCGGGGCGTA +TGCCGGTCTTCAACCACGTCTCGGATACGCCGTGCGCGACAGTGCCGTATGCGGCGTCTT +CGCCTGCGTTGTCTTCTGCTGCGAGATTGGCGAGAAGGGACCCGGCGCATGTGAGCCACA +TGGCAGACGCACTCGGGGAAAATACCGAGTGGCCGCCTTGCTCGATGTTGAACTTCAGCG +CATCGAGATTGATCGCGTGTTCGCTCACGTAGAGGCCCCGGAAAAGTTGTTCATTTTGAG +CGGCACTGACATTGTGTGGTGCACCGTAGAGGCCGGGAACGCTTGCCGGTGCACCCGCCA +GTGCCGCTCAAAATGAAGCCCGGACGAACCGGGCTTCTTCGCTGCACGTCGAGACGATAT +TACAGGCCGTCGCTGCCGTCGCCTTCGTCGCCGCCCGCGTCTTCTTCGAGCGCCTTCTCG +GCCGCGTCGTACGTGGCGTCGAAGTGTTCCGGCTTGATCGAGGCCGAGGTCTTCGGCCTT +GCCGTACTTCTTGATGATCGCCTTCGCGTCGTCCATCGACTTTTCGTCCTTGACGCGGAT +CAGGATCGCCTTGACCTCGTCGGCCGAGTGCTTCGGCTTCGTTGCTGCCTTGCCGCCGCC +CTTGCCGGCCGCCGTGGTCGTTGCCTTCGTGCCTTCGGCCGCCTTGCCGCCGCCCGTACC +GCCTGCTTCCGCGATTGCCTCCGTGACTGCCGACTTGATGAATTCCTTCAGGGCGTTTTC +GAAGCTCATTTTTCCGACTCCTAGTGATCCGTAGATGGGTTGTTTGTGTCGTGGCGTTCA +CCACGGAACGAATCATGCCGGGGCCGGTTTTGTCTGTCAACACCTTTTCGAAAATATTTC +AAAGACAAATGGGAATCTGGCATACTCCGCGCTGTATCAACCTTCATCTACCTACATAAG +AGGACTAGAAACATGGTAATCCCTATGCCCGCATGGTTCGATGCGCTGTCGCCGGAAGAG +CAGGAAACCGAGCGCACGAAACTGGTCCTGAAGCTCGCCGCGATCTACGCTTCCCGCGAG +CAAACTGTTCAACGTTTGTCCGAGCTGGTGGGCTACTCGTCCAATACGCTCGGCGCTCTG +TCGTCTACCGGCCGCGCGTTGCGCCCGGAACTCTGCATCGAGATCGAGAAGGCGGTCGGG +CACGAGTATTTGCCGCGACGCTTGCTCAACCCGCATATCTTCGAAGTGCCGACCGCAGGA +GAGTAACGAGATGGCCGACCAGACCACGGCCACCTATCTTGCGGATCACGGGGATGCACT +GATCGCGAACGGGTACAACATTGTCCCCATCACACCCGGCGAAAAATTCCCACCGCACGA +CGGCTGGCAGCAGACAGTAGCAACGCAGGCGAAGTTGAAGACGTGGCTCGCCACGGGTTT +GAAGTACACGAAGAACGGCGAAGATCGGGTCGCCGATGTGAAGCTGGCCGGCGTCGGCTT +CCTGACGAAGAACACGCCGGGCGTCGATATCGACATCTCGGACGAAGGCTTCGCGAAGCA +CATGGAGAATTTCGTCCATGAGAACTTCGGGATGGCTCCTGTACGCGTCGGCCGCGCGCC +GCGCCGGCTACTGCTCTTCCGATGCACCGAGCCGTTTTCGAAGGTCAATTCGAGCGTCTA +TCTGGACGAGTGGGGCGAAGCGCAGAAGGTCGAAATCCTCGCGAACGGCCAGCAGTTCGT +CGCGTTCCACATCCATCCGGACACGAAGCGGCCGTACGAGTGGCTCTACAAGCAGTCGCC +GCTCGACATCGAAGCATCCGAGTTGCCGGTGTTGCGCCGCGTCGATGCGCAGGCCATCGT +GGACGAGTTCGAGAAGCAGGCCAAGCTTCGAGGCTGGACGCTGAAGAAGCGCTCGCGCAC +CGCGCCGGAACGCAGCGAGAGCGGCGGGGAGATCGATTACGACGACCCGTTCGCCGCCGA +CGTAGCGAAGACCGATATCGGCGAAGACGAGCTGCACGCCAAACTCCTGCTCGTGCCGGA +CGCCGATGATTACGAGACGTGGGTCAACGTCGGCATGGCGCTGTTTCACCAGTACGACGG +CCACGAGCGCGGCCTCGAACTCTGGCACGAGTGGTCGGAGACGGCCGACAACTACGACGC +GAAGGAGCTGGACGCGAAGTGGAAGTCATTCGACATCAGCAACAAGTCGCGTACGCCAAT +TACCGCCCGGTACATCATCAAGCTGGCGAAGGAAGCCGCCGAAAAAACCGCCGAAGAAAC +GATGGTCGCGCTGCAAAAGCTGCTGCTCGAAGCCACGTCGATGAACATGCTGAACTCGGC +ATGCAAGGCGATCAAGAAGGCGACGCTCGACAAGCCGTCGCGCGAGCTGATGGTCACATT +CGTACGGCAGGCGTTCAAGCGAATCAACGACGGCTCGCCCCTTCCGCTCAACGCTGCTCG +GCAGATGATTCGGTTCGAGAACCCGGAATCGAAGCACATGCCGAAATGGTTGATGGGCTG +GACGTACCTGACGCTCGATGACAAGTTCTACAACGTGAACACGCAGGAGTACATGACGCG +AAGCGCCTTTAATTCGGCGTTCGAACGTTTCCTGCTCACGCCACAGGACGTGTTGGAAGG +CCGCGTCGTCCCGGACACGACCGCCGAGAAGCTGGCGCTCAACCGTCATCAGATTCCGGT +ATGCCGCACGCGGCTATACCTGCCCGAACAGGACGAGACGTTCATCATGAACGGAGCGCG +CTACGCGAATCTGTACACGGACAAGTCGGTCCCGGAGTGTCCGTCAAAGCTGACGAGCGA +AGACAAGCTGAACGTGAAGCGCATCCTCGACCACTTCAACATGATGATCCCCGCTGACCG +CGAGCGCGGCATCTTCATCGACTGGCTGGCATGGATCATCCAGACGCAGAAGCGGCCGAA +TTGGGCGATCGTGTTGCAGGGTACGGAGTCGGACGGCAAGACGTTCTTCAGCGACATGAT +GGGCGTCATCCTCGGTCCGGAGAATGTCAAGACACTGAACGCCAAGACGCTCGAAGGGGC +GTTCAACGGCTGGGCTGAAGGATCGCTCCTGAACTGCGTCGAGGAAATCAAGCTGCACGG +CCACAATCGCTTCGACGTGCTCAACCAAATCAAGCCGCTCATCACGAACACGGCCATTGA +AATCCACCGCAAGGGGGTAGACCCGTACAACACGATAAACACCGCCGCATACCTGCTGCT +GACGAACTTCAAAGACGCGCTGCCGCTCGTGCGGAACGACACGCGCTACTTCGTCATGTT +CGGCCGCATGCAAAACCGCGAAGATGTCGAGAAGTTCAAGGATGAGAACCCGCACTACTA +CGGCAACCTGTTTCAGGCTCTCAACGAGTCCGCCGGGGCACTGCGGAAATTTTTCCTTGA +ACACGAGGTGAGTGACACCTTCGACCCGATGAACCGTGCGCCGGATTCCACGGCACGCCG +CTATATGATCGCCATGAACCGCTCAAACGAACTGGAAGCCATCGAGACACTGATCTCGGA +ATCGATGGAGATCGACGTTTCCTCGACGCTCCTGAACGCCAGCAAGCTGCCGGACCTGAT +GGTTGGCATGGATTGCGAACTCCCGCAAACGAAGGGCTTGCAACGCGTCCTAAGCGACGC +CGGATTTACCTTCCTCGGACGCATTCGAATCAACGGGGAGTACTCCCGATACTGGTCCAA +ATCGCCGCAATACTTCATGGTGGACGGGTCGTCCGAGATCGATTTCGACGCTGTTCGGCA +GTACGCCGGGTGCGGTTTGTAGCCGAGGTCCAGATCCGAATCATTTTTGACTTATTCGGA +CCTTGGCCGTTTTCAGCCCCTTCGGGGGCTTTTTTGCGACTGTTGACCTTATCAGAAAAG +GGTCATTTTTCATAATGCGGTAAAAAACGCGGTCCGAATGACGCCAAAAACATTCGGACC +TTCGATTCGGACCACGACCATTAGAACCCCGGCTCCGCCTTGTCCTATAAGGCTTCCCTT +CCTTCTCTTCTTCTACTATTCTATAGATAAGGTCCAAATAAAGAAGAAAGTAGAATGACC +GTATAGACATAAATCCAAAAAAATTTTCGTACAGAAATAGAATAGAGAAAACGATTCGGT +TCGGCCCTTCGGACCTGCACTTGGCCGGCCATTCTCGTCCTCCCGACCACTCAAGGTCCG +AATGGGTGGTTTCCCCTCCGCCCCGCCAAGGTCCAAATCCCCTATCCCGCGATTCGGTTC +CGATCTCGTTCGGGATATCTGCGTTGCGCAACTCGAAATCGGAAGTAACTTCGGACAAAC +CGTTGTCGCGCAAATCTTTTCGCGAGAACTTCGGGGAAGGGCAGCGGCGCTATGACGGAA +AAACGAAAAAACGGGAAATCGGGGCTCTGCGCCCT +>NC_005091.alt1 length=57455 tani=97.161 alt=sn;inv;tl +GTTCTGCCCCCTCCCGCCATTCGCGCCTCGCCGGATGGGACCCCAACGGCCGCCCCGAGC +GATCCTCATCGGGCCTGCGTGCCAGCCAGTGGCACGGAGGCACGATCAAACGAATTGTCT +AGAGACGCGGCGAGACCACCACGCAGCAGCCCGCCGCGTAGCCTGTATGACCGTGATACA +GGTATGCCGTCATGCGTGCGCACGGCCGGCCAATGCGGCACTGTACGAGCGACACGGACA +TACGGCCATGCGTTGCGGGCACGCCACACGCGGCAGGCCGTGACACGGGCAATCGGGGAT +TCGGACCTAGCTGTGAGACGCGCTGCGCCGTACGGCTGATGACATGCGGCCTAGCTGGAT +CGTGTGTATTCGGACCCATGACCACGAGTCGCGCGCTATGCGATTGGGACATTTAGCGCG +CCCGCCAAGCCCCAATCCTGCCCCGCCTCAAACCGTCGCACGCACAAGCGTAGCGGAAAT +CCCGCCCAGCTAGACCCGGCCGTTGCGTACCTGGGCTAAAATCGGACATTCTGACGTGCG +GTGCTGCGGGCGCGCTGCTGGGCACCGTGTGCGGGCGAGGCGATGGGCGTCAAAAAGCCC +GACACGATGGCCGGGCGAAGGGGGCTACTGGATGGTGTGGGCTAACCGTCCCGTGTGTGA +CGCCGGCGTTTTAGGGCGAGTTGATACCAGTACCCACCGATGCGGATGACGTGCGGGTTC +TCCCCCGTCAGCACGCGATGGGCTGCTTTGGCAATCCACCAATTTGGGTCGTGCAGCCAC +ACGAGGCGCAGTTCGTCGGGCGTGCGCCGTACGTCGAACGCGTCGATAGCGCTCGTGCCG +TCCGCATCATCGGGGTCGTCAACCGCTACCACGATTTGCACCATCGTGCCAGGGCTCGCG +CTGAACACGCGCGGCACTCTTAGCAATCTCGATCCGGGCATGACTGCATCCTTAGACGTT +GAACGCGTAGCGCACGAGCGCGACGAGCAGGCCAATTGCGAACCCGACGAGCGGCAGACA +GCACGCGCCAGCCACGGAACCGACAATGTAGACGGCCGCGTCGGGGGCGTCTTCGTACCG +CCTGCGCGGTTTGAACCGCAGGATCGCCGGGACGATCAACGCACCGATGACGAGCGATGC +CAATCCGATCGATGCGGCCGTGTGATTCGATATTCCGCCGTCGTCGGGTATCGGGTAGAG +CCGGTCGACGCATTGCGCGTAGCTCTGCATGCGGGGCACGTCGGCCGTGCCTGAGTCGTA +CGAGACAATCACGGCTTGTCATGCAGCACGCTCAGCTCGATCGGCTTCTGCCGATGCGAT +CGCCGCGTTCGTGGCGGCTTGCGCGTTGAGCGCGGCACTTAAGGCAACGGTATCAGTTGG +CATCGTCGTCCCCTGCGGTGCGTGTGCCGATATGCGGGCCGACGTTAGCTCGATTCCGCG +TATAGCGGATGATTGCAACCTGTTCGACGGTCAGGCCGGCACGCGTTGCGCTCGATCCGT +CGACTATCACACAGGCCGTGAGAACGAGTTCGTTGAGCTGAACAAGCGCCGCGCCGTACG +GCAACGATTCGTATTCTTCCAGCTCGCGCAACGAGTCGAACAAACAAGACTCGTCGTTCC +AGACTTGCGCGCCGACTACAGGGGCGCACTGGATCCGGCCGACCTTCATCATCACGCGGC +CGAATTTGGTCGGAATATCGGACGGATGCACCTTGCGCGTGTCGCGACGCCAGATAGAGC +CAATCTGACGTACGGGCAGGTCGATTTTCGCGACCGGCATTGCGGCGATCGTCTCAGCCA +TCGTCGGCTCGAAGTTTTCACGGTCGCTGTATCGTTCGATCTTGACAGCATCGCGCGACG +CTTGGCGGCCCGCGCGTTCGAAAGCAAGACGGGAAAATCGACCCTCGTGAATGGCGATAT +CACCTGCCGGGTGATCGGCCGCGCCGTTCGCACGGCGCGAGCAGCTCTTCGTGATTGTGT +ACTTCGCCATTGTCTTTCTCCTTCGTGTTGGGTTATGCCAAACGGCCGTAATTGCGTTCG +TGAGATTCGACGTAATCGCCAACCGTCGTAAGGCGGATGTTGCCAGCGGGGTAGTAGCAC +ATCCGGAGCGGTACAAGCATGGCGACGCTCAATCGCCTCATCGAGGGTCACGGCGTCGAA +TATCTGCGGCACGAGCGGAACGACGAACCGGCCGCCGCGTACGTCAACACAGGCGACGTC +TATAACGCGACGCTGTTAGCCGTGCGCACGACGGCCACACGCTTGATATCGAGCCGCAGT +TCGCGGGCCAGCCTGGAATCGCTCGGCGGGCGTTGCACTGGTGCATTGTTGGTCGTCATG +GTTACCTCCCTTCGTACATAATCCGGGCAATGCGAAATGCAATCGCCCATGCTTCGCGCG +GGCTATAGCCACACGCTCGATGAATGTAAGACCTGTCGTTTGCCGCGTCAGCGACCGCGA +GCGCGGTGGGCACGGGCAAATCGGCAAGCGATCGATAGTCGTGCATGGTGGTGGTAAGGC +TGGCATTAATCGACCAATCTACGCCGTTCAGATAGAACGAACGCCAGCGCGCCGCTTCGA +TCAACGCCTCGTGGAAACGGTAAACCGGCATAACTGCACCGTGCCGGCCAGCAACATACA +TCGTTGCTTCCCACAGTGCCGCGCGGCGATTGACGGCCGTTCCATCAATGAAAAACGCCC +ACGGGCGAGACGGCGACGATTTAGGGTCGTACATGAGTCGAGCCGTACCGCCCCAGCTAC +GAAAGGTTTGTTGATCGCGCCCCATGGTTAGGCCCCCTTCCGAACAGGCGCGTAGAAAGC +CGGCGTTACGCGCTTGATACCGTACAGTGCGCGGAACGCTTTGCGCGGGCTCGTGATTTG +CGCCCGGTCTTCGCGCAGATACATCGCGAGTTCGTCTACGGCAGCTTGAATCGCGACTGC +ACGCGCAGCGTCGACAGCCCCGGTCGTCGCTTCCGCCCACTTGGCGATGCCGCGCGGATC +GCATGCACGGGCCAGTTCTATCGGATCGCGAGCCGTAGAACCGCCCCCGCGCAGTATCTG +ATACGCGGCCATGCGCAGTGTGTCGTATGACGCGATGATCGCTCGCCCGAATGGCCGCGA +ACTGGAAAGCCGCTTCATTCGGCATATCATGCCGAATCGCGCCCGTGCCGCGCTTCTGCG +CGCCCGTCACGCGACGCACGCGCTCGTATCGTAACGCGGCTTTTCCGTCATCGGAACAGA +AACCATCATCGTGCCATGCTTCAGCACTTCGCGCGACTCGCGCAGCATCGCATCCGCGAT +CTTCCCGGCGTCCGGGCGTGCGGCTTGCGCGCGAGTGTGTACGGCCACGGCGACGATGAT +TTGCTCACCATTCAGGATCCCGAGCGCATCGGCAAACGACGGCTCGTCGTAACCCATCAG +GCGCGGCACGAAGGAAAACACCAACACGCCGTGACGCCAGTAGCCGAGTGCGCTACGGCC +TCCGATATGCGTCCGGTAGTTCGCGATGGTCGGCGCCACGGCGTCGCATTTCGGGGCGAG +CGTGACTTCATCAATCGCGAGATACGCGCCGCGAGCTTCGAGATATTCCGCCGCATTGGC +GCGGCCGTATGCCGCGAAAAGGCGGCAGTCGCCGGCGCGGGGCGCGTTGCGGACGATGTA +ATCGAACGACCAGCGGCCATTTACCACCGGGGGCGTCCCGATGACTCCCAAATGGCCGAC +ACGTACCCGGTAGTGCGGGGGGGCTTTGACGGCGGCTTGAACATTTGCCAGGGTGATTAT +GGCAAGCCCCTTAGTGTGCGTTGCGGATCGATTCGACAGCGGCCAGTCCTGCGTCGCATG +CGACGATGAGCCGACGAGCGAGCAGGACGGAATCGAGATGACGACAAGCGCGGATGTTCG +CGAGACGGCGGCGGAAGGAAAACAGAAAAGCAAGCATGGTTAGCTCCAGTGGAATCAGGG +CGCGCCGGGCGGCGACCCCATGCATGAGACTCTAGGCAATAAAGTTAGACCTTGCCAAGC +TGTTCTGGGCTGTTCTCATGCTTCGTCCGGCTGTTCGTTACCGCGTGCGTCGCGCCGATC +CCGTGTGCGCCATTCCTTCATCACATTCACGACACCGAATTCTAGGAATCCCATAAGCCG +AGAGCCGCTCAAGCGATCCCCGAACCGAGGATGAGGTACAACACGACCCGACGGGCGCGC +ACGCCGGCCAGTGCGACGGCTTTGCGCTGGGAAAGGCGCGGATGTTGAACGGCAACGCGG +TTTTTTATGACGGGGGTTCCAATCATCAGGATCAGGGACGCGGCGGCGATCAGGCCTCAC +GCGGCAGCAGCATCAAGCCATTCATTCGCCATCGTTCGGCGCTCCGACGATTTGTTTGTA +GCCGGCCGCGATCTGGTACAACCAGCCACGGTGAAACTCGCAATCGACGTGCCACATGCG +CCAGTCGCGGCGAACGAACGCGAGCAGCCGTTCGCCATGCTCGCCGCGATCAGCGAACCC +CGCACCATGACCGGCCCACGTCAGATAGATGCCTTGACCCAGCGCGGCAGCCGGATCAAA +TCCGCAATCAGGATGCGCCCCGTGACCGTTGGTCGCGAGCATTGCGGCGACCGTTTGCGG +ATAGCGCTCAGCGAACGCATAGACGAACCGGCGCGTTGTCTCGCGTGATCCCGCTGTAGC +GCGCGGGCGCGAGCCTTCCGGTGCATCCGCCCAAAGTGCGGGGGTGAGGAAATGGCGGGC +GGCGGTTTGGATTTGTTCGGGTGTCATGGTGATACCTCCGTAAATGGCGGAAAGGCGAAC +TAGTTCAATTGAAAGGCTTGGGTTCATTCGGCGTGTTTCTGCAACGCTCGGCTACGAGCG +GGTCCATTGTGGTCGCCGCCTGAGCAGCAAAAATCTCGTTAATGTAAATGCAGTCGTAGG +TGATCTCGCTGGCCGTGCATTCGCCCTTAGACCATCCCGCCTTGCGCTGGCAATGGTGCG +ACGAGGTAGAAGGCGCGTGCATCAACCATACTGGATGGTTCGCCGATGAACACGGCGATG +GCGACACGATACGCGGTGTCGTCTTCCGCTTGCCGCACGGGCGCGGCTTTCTCCCCGGCG +CGACGTCCGATTCCAAATAGAACCCCTTGCCCGTGCTGTTGGATTTCGGCGCATGGTAAT +ACTCGCCGCACGGGTACACGTTGCGCTCGGCAATGCTGGCAAACCGTTTCGGCATGCGTG +CGATGTAGCGCGGGAAATGGAAGCCGACAAACGTGAATTCCGGCGTGAGATGCGAGAGAC +GATTCATGGTTATATCTCCGTGGGTATCGGAAAGGTAAAACGGATTCAGTTCGAAAGCGT +ACCGCCGTTCGCGCACTTGATCTCGTAATCGAACGGGAATTTGCTGACAACGTCGAGCAG +CAAGGAAACCGCTTCGTCGGACAGCGGATTGCGCCAGTCGAAACAATGCCTGCCCGTGTG +AGCGTAGAAAATCCAGTCATCAATCAGGTTCGGCACATGCGCCATGATCCAGCTGCCGGC +GTCTCGCTTTTCCAGCGCGACGGCGCACGTTTTCACGTATTTCGCTTCGATCCGGTCTTT +CTCTTTCTCGATTCGCGCCTTGTCGCGTTCGGTCGCGCCGTGCAATTGCGCTTGCACATA +GCGCGGCATCAATGCCTCGCGTTCCGCCTTGCTCAGTGTCGGGCGCTTCGCTTTAGACGA +CACGGGCAAAAGGCGAGTGTGATACAAATCGTCCGGCTACAAATACTGCGATCCGTAGCA +CGACGGGCAAAACGCGTTGCCGATCGCGCGGTCTTCCTGATGGCCACAGTAGCCGCACTT +AACCGCATGGTCGAGCACTTCGCGCATGTCGTCCGTCACGAGAGACCAATAACCCTCTTT +GATCCGCTTGTTCGGATACTCGTACTCCGACCGAGGGAACAGACGGTTTCCGCGCAGGGT +TTCGCCGCCTTCCGTGTCGGCCATGTTCCATTGGTCGGAGAAAAGATGAGTCGTATCAAA +AACAATCGTCTGACCGTGGCCCGCTTTCATGTCGCCCATGAATGACTGTTGCTGCGCTTT +CGTGCGGTCGTACTGAAGACCGACCGACACGGACCATTTGCTTTCGCCGCGCGATTCCAG +CATGGCGCACATGTCCGCGTAGGCTTGCGCCTCTTCAGGCTTCTCAATGTTGAAGTAGTA +GTGATTCAGAGTGGAAGCCAGGCGCTTCATTGTGCAATCTCCGGTGAAGGAAGGGGCCGG +ACCAAAGCGGCACGGCATGACTGAGATTCTAGGCGACAAAGTTAAACCTTGCCTAGCCGC +TTTCCGCGTTTTCTTTCGACCGGAAGTAACTTCCGACCCGTCCGGGCGGCGCCATCAGTC +CAAAATCCCCGCAAATCCTTGCCTCGTAAGGCTCTTAGGCCCCGCGCGGCCGGTCGTCTA +GGGGTAAACCCTATGATGCGCCGCAGCAACGCGCTCGCCAAGCGCCGCGCGGCTGTCCCG +TTTTCTGCGCCCCTCGTCCGGCCGGGCGGCCCGCCGGTATCCCGTGCTGACGACCCCTCG +TGCTTACTTTGGGGGCCTCGCCCGTTCCCAATTCTTCTAGACCAATCTAGAAACGACCCA +CCGCATCGGCCTTTTGCTTACTTCGGGAACCGAGCCGGACCCCCACGCACGGGCCGCGTC +GAACGACCCGACCGGGGGTAACTTCACAACCCTAGCCGGACCCCCGGTCGCCGCCGCTGA +CAAAGTTGATCCCATCCCCGACAATCCGTGCATCGAACCGATCAACATTTTCACGGAGGA +TCACCATGGACACCGCCGAAACTGTCAACAACCAGATCGACAGCTTTGCCGCCCGCGTGC +TCGCGCTCGAAGTGGGCGAGACCGAATCGAAGACGTGCCGACTGGATGGCAACGAGGCGA +CCAAGGAACTCATGGTGGCCACGCTCACGAAGCTTCGCAATAGCGTCGCGGCCGCCGTCA +GCCGGGCGTCCTCGAAAACCGGACACGTCTTCGTCACCGAGACCGGGGACATTCGTACGA +AGAGCTACGACTTCCTGATGACGGTCGCCGTCACGTGGAAGGCCTGATGAACGCCGTCGA +ATTCAGCGCGGTCCTCGCGCTCGTGCAGGCGGCGAACGGCGAAGTGATGCGGCAAGCCGG +GATGATGACGTGCAACGTGTCCCGTGCGAAAATGGAAGAGTGGCATCAGTCGCGCACGAT +CGAAACCGCGTACGACCTGAGCAGCGGATGGACCGTGACGCTGACGGCCCGCGCCCCAGA +AAGCGAAAACGGAGGACCCAAACGTGAAGACGACTGATTGCAACTGCGGCTGCGCCGACT +GCTCGGGCAAGTACGCGACGAAGAGCGGCGCCGCCGGTCACCAACTGGCGCACGAGCTGC +ACGGCCTGACCATCGATCCCGGTCGCTCGATGGCGCAGCCATGTCGAGCGTCTTGCGCAG +CAAACGGCTCACCGGGTCTTGTTTCATCTGCGCCGCCTGCGCACGCAGTTGGTCGGCCTG +TTTTGCCGAAGTAATCCTGCGCGCCGGCCGACCTCCCGCCCGCGCTGGAATCCGGACCTT +CCTGAGCAAGATGCCGTTCGGCGCGTCCTACTTCGTCGCGGGCGACACCATGGAGAGCTA +CAACGGGAAGACTTTCCGCGAGGCTAGCGTCGACCTCGGGCTGCCGATTCGCAGTGTGGT +GCATCACAAGCATCCGACCCACGGCATGTCCGGCATCGAGATCATCCGCCTGACGGTCGG +GAAGTCCGAGCGGCGCATCTTCTGAATCCCCACGACGCCGGCCGAATAATCGGACTCCCG +CTGTAACTCCGGGCGGCCAAGCGGCTCGGATGACCTACCCCGCTACTACCCCCGCGAGAT +TTCCTGCCGTCCCGCCAGAAGCCCCATACGCCAGCCGCAGACATATATCCTTGTCTGGCA +AGGCTCATCGCCCGGCTCCCCCATACGAAGTAACCTCCGATTTCCTGTTATTTTTGTTGC +ACCGTTCAAAGGAATGTTCTACATTTATCGGAGGCCGTGCCGGTCAATCGCATCCCGTAG +GATGGTGACGTTCTTCTCCTGTGTAAATTTGACTGTCATTGTTGTTTCGTTCAAAGGGTT +GATGGGTTTGCGCCAAGGCGCAAGTGGGCCACATCACCCCGGATCAGGGAATGTTCAAGT +TTGGGGAACCCAACAACCCGACCGTCTACTACTTCCCGAAGCGCAACCGCTACAAGATCG +CCGGGCAGCTGAACGACGTGCACATGAATGCGGCTCACTTCGCGTGCTGGTATATCGGCG +AGCATCTCGGTCGGTTGGTCGCGGGCAACGCGATGGCGTGGCTGCACCGCGCAGCCAGCG +ACGGCAATTGCCGATCGTGCAGAGAAGATAAGTGCACGGCCGGCCCGTTCTGCGTCGCAT +TCGAGCATCACCGCGAACGCCCTCTTTCCAGCGTCACCGTAGAAGCCCTTCGTGAAGAGA +AACGCTAATTGCAAAACGACGACCAAGGAGCAGCGCCATGTTCAAGCAACTGATTGCCCG +GATGAAAAGCGACAAGAAACGCGAAAAGGTCGCTGAGTATTCCCAAGAGCTGAAGGACCG +GCAGCACGAACTCGACCGGCAAGAAGACAACATTGCGGCCGAGCGGCTGTATATCGAACG +CCAGCTTCCGCGACTCGCCGCCCGACTGGCTGAGATGGAATGGAGCGGCGAAGACGCTGT +TCAACGTTCGGCCATGGTAGGCATCTGCAACGTCATCATGGCCGGCCACCAACCGGACAA +GCCGATCATCCGGCAACCCGGCGTCGGCAAGAGGACCACGGCATGAGAAATTACTTCGTA +CCGAAGCTGCGCGTCAAGAAGCCATCGAACGGGGAAGTACGCGTAACGGTCGATGTGAAG +ATGCTCGAAGCGGGCGGCCATGAAATCCTCTGGAATTGCGCGGTCATGCAGCGCATGCGC +GAGTCGGGCGTTCCTATCATAGGGCTGATTTCCATTCAAGGCGCGCGCCACGGCTGCCTC +GTTCAGACCTACGACGAGTGCTTCATGGAGCACGTCTACGAATGGACGCCCGGCCCGGAT +TCGCCGAAATAAGTTGACCCGGCAGCCGGTTTCTGACCAACACAATATGGGAGTAACCAT +GAGCAAGATCGAGAAGGGCAGTGTCACGGTCAGTTTCAAGACCGACAGCGGCTACGATTC +GATATTTGGCGCGCAGAACAAGCCGGGGATCGACGCACTGAAAGATGGCCTGCACGAGAT +CGTCCGCGTGCTGACCATCAACGGCAATGTCGCTACCGTCGACGCCGTCGTGAAGGCGGC +CAAGCGGCGGGGAGAGCGCGCGGTTCTCATGCACGCGACGGCGTAGGTCGAGCAGCAATC +GGCGGTCGATCAGCGCGTAGGCGACAAACCGCCGTCCGATGACCTACTAAAGGCGCTCAA +CGCAGGCACGCGGCCGGGAATCCTGAACGTCTACCGCCATATCCTCCGCCAGCATTCGAC +CGCAACCGGTACGTGGTGTATCCGTCTCGCGAAAGAGATGTGGGGCCATCTGCCGCTCAT +CGCGCTGAACGCGGAGAATCGACCGGGCATCGCGGAAATCTACGTGGACCTGCGCCGCGC +GAATCCGCAGTGGTCGATGTCCGGGCTACTGCGTGAGGTCGAGCTCCAGTGGAAGGAATC +GCTGGAATCGGAGACGGAACTATTAAGACCTTTCAACTGAAGGCCGGTCTCGTGCGCTGC +GCTGCCGCGTGGGTGTACGGTGGCGATCCTGCGGCCAGGAAATACCCGGCGCTCAATCGC +ATCCGCATCGAACCACACCATTCCGGCGCGATCATCATTGCGACCTGCTCGCACGCCATG +TTCGTCGCGTACGACCCGGAAGCCGTCGTGCCGGAACCCGCGCTGATCTCCGTCCCGCAG +GACCTGCTCGACGCGGGCGCGCTGCTCAGCGTCAATACGACGGAACGCGAGATTCGCTTC +GGGGATGACGGAGTTGCCGTCTATGCGCGCGGCAAGCTGAAGCATAAGTCCGGGCTCGCG +ATCGCCACGCATCTCCTGCCTGGCGCGAAGGCGCATTACGCTAACTGGCGTGCAGCCATC +CCGGCGAAGATGGATATCCTGAAGGCGAACCCGGCCATCCCGACCATGATGAACATGGTC +TTCCCCGGCCGGCTGGGCGGGATGCCGGAAGGCTGGGGCGAATATCGGCAGGTGTTCTTC +GCGACGTGCGGCAAGCGGTCGATCACGCCGGGTGACGGGCAGCGCACCGACTACCGGAAC +TTCTTCGCGTTCTTCCCGTGGAAGCGCGACGTGTTCCCCCTGTTCGCGCCGATGGGCGGC +ATGCCGAGCGCCAAGGATTTCGGATACCTCCTTCGTGGAAAAGTGAAACCGATTATCGTG +ACAACGTTAAGCCTTGTCAACGATAATCGGTCGGAAGTTACTTCAGAGGCCGGCCGCCGG +ATCGTCCGGCTTGTCTTCGAGCCATTCGGGTTCGAAATGAACGGACCGAAAAACGATGGC +GTCGACCAGCGCGCCTACGCATATGTGCCGGCTTCCGTGCTGCTCGAAATGAAGCAGTAC +ATGGACAAAGTGTCGAAGCTCTCGAAGGTCCCGGCATCGGCTATCGGCCCGAAGGAGCGC +GTCAAAGGGTTACTTGCCGAAGCGAAGGAGCACGTCGCGACGGTCGACCTCATCGAATAC +GAAGTAGGGCAACTGGTCGGGAAGTATTTCGAGAAGATCAATTTCGAACTTATCGGCGAT +GTCGTCGTGAAGAAGACCGGGGAGTTCAAGGGCGACCTCGGCCCGTTCCAAGACGAACCT +TGCCGCATGATGCGACATATCGCGTTGAGGGTCCTCGGCGAGAAGATCGAACGCGACGAT +GCGGCCGCAGTGTCGAAGCTAGAACGGCTGTACACGCACATCGACGCTGTCGCGGCCATG +CTGGAGAACGACGAATATGGTGAGCCGCAGGGGACTGGCGACGAGAAGTTCGACGCACTG +GTCGAACAGATTGCCCGTCTGCACAGCGATCTCAACGAGTCCGCGCAACTGATGGTGCCG +GTAAGCGCGTCCGACGAAGCGGAACTAGCGAGGATCACTGAGCAACTCGACGAAGCGTGC +GACGACATCGAGAAGGGACGCGGCCTGACGCCCGACGTGGAAGACGCCAAGCCCGTACAT +CGGTTCAAGCAGATGTACGCGAAACGGTTCATCCAGTGGCAAGGAGCCACGACGCATCGC +GACGACGCCGAAGGTCGCCTGAATGCCATCAAGACGGTCGTGCGACAGATGCGGAGGGAT +GTCAACGGTGCTTCCCGTAGCCGAACGCCTTGCTCATCATCACAGCGTGCGCCAAGCCAC +GAATCTCGTTCAGGAGATTGTCATCGTAGACTACGCCCGTTGCGAGCGCACCGTCTCGGA +GCGCGGCACCAGATCGGCGTGTTTCACAATCACGTTTTGCCGCGCGTGCGTAACCCGAAC +TACGTGGGCGACCCCGAACTGATCGACCAAATTCTCGAGGGCATCGCATTGGTTGGCTCC +GGTTCTGCGGATGCGGTCGATACGGCTCCGACTATCGGGGAAGACCCGTTGTCGCAGGTG +CCGCTCAACGTGTTCCAGATCAAAGCGCGTGTTGCGGCTGTCGCTGACAGCTTCGAAAAT +CACAGTGCACGTCTGCACGACGATTTTGGGACGAAGTGGCGGCTCATCGAAGTAAAAGAA +GCGCTCGGGCTGCCGTTCGCGAGAGATATCGCCCAGGTCATCGGCGAAGCTGACGACTTG +GCTTCCGTTCCGCACGATCGTGTACGGGCCGTTAGCGTGGTGTGCGAATATGTCCTTGCG +GCCGTCCGGGGGTTTGATGACAATGCGCTGGGCACTGCACGCACGTACGATGAAAGCGCC +GGGACTGTTACAACGCTAGAACCGGACGAATTGCAGGGCGACGCGTTGCCTCTCTATAGC +CCGCAGAGCCAGAACGCGATTCGCGTGCTGACGAAGCAGCTCCGAAAAAGGAATAGGCTT +CTCGGCAACTTCGTAGGCATCCATCCGGTCGTCGAAGAGCTTCAGGACGCGGTGCAAGAC +ATCCTGTTGGAACATAAGTCGAGGGGCCCGGACGTACTGCAAAACGCATGGTTTGCGGAT +GTGCTGAAGTCCAACCTCGCCGCCGGCGGCTCGATCGATGACTTCCACCCGCGCATGATC +GGCTTGCACACCGGCCCTCCGTGCAAAGAACTCGGCGGGAAGCTGCGCGCGATTGTCGAA +GGCACGGTTGCTTCCGGCGTGTCCCTTTTCGAAGGCATGCCGCTCGTGTCGCTCTGAAAT +CAGTTGAAGTGGGTCGGCGAACTATTCAAGCAGGGTGCATTCGACAACGCTATCGACCGT +GCTGACCCGGTCGAACTGGCAGACGGCGACATCGACCTGATGGTCGTCTCGTTCGGCTCG +CTTCGTTCGCAAGGTGTCTCGCTGTTCCCGATCCTGCACGCCGTGACTGATGCGAACGTG +CGCAAGATGGTCAACGGCAAACTGCTGCTCGACAACAACGGGAAAATCGTCAAGCCCGAT +GGCTGGAAACCGGCCGACCTGCTGCCGTGCCTGCACAAGACTATACAACAGGCCGAACTG +CACATGGGTCCGTCCGACGAAGCCGGGAGCATCTGACATGAGAGTGAACGTCTATAGTCA +CGAACTCACGTCGGAAGTAAACCCGGTGTACAAGGAGTCGGATACCGGCGTAATTTACAG +CGCGGTGCAGTTTGTTTTGCATTCGAGCGACGGACTCCATCGTCCCGACCCGGATGGGGA +CGCCGATCGGAGCGCCGTAACTTTTTGGCTACCGAAATCGAGAGATCGGCGCGAGGCATT +CGCGCTTGCTCTCGAAGCGGCCGCCACGATGGTGAGAAACTCCCCACCTGAATCCGGCTT +GGACTCTTAATCGTTTCGCCGCCCTTCGGGGCGGCTTTCCTTCGAGAACACCATGTACAC +GAACAATCGCGACACCCACGAACTCGCCAACGAGATCGAAACGGAGATCAAACTCAACGT +CAAGCTCGACAACTGCTGGCCCGGCACGCCGCACTTCATCCTCTGCCACAGCCGTCAGGT +CGGCTGGGAGATGGCCGTGCGGATGTCCAAGGTCCTGTCGTTGCCCGGCGGCGGGCCCGT +CTCCCTCCCGCACGTCAGCACGATCCCGCATGCCATTCAGCTCCTGAAAGGGCTGACGAC +TCATCACGTGGTCGTGTTCGAGCCGGCCGTCGTCTTCCTTTTTCCCGGCTGGGCGTGCCC +GCTCGACCTGCCTACCAAGCTGCATGCCACCTTCCCGATGCACGACGAAGAAACCGCGCA +GTTCATGGGCCGCTTCAACCGCTTGAACCTCCGCACCGGAAACATCGGCGATAACCTCAG +TGTTGGGAAAATCGTACGTTTCACCGATATCGCCTGTTGATAAGGTTATTCATTGCCGTG +ACAATCCGTCGTATCAAACCACGGGGAAAGAAAAATGACGAACAAGAATTGCGACTGCCG +ATCCGCCGACGAAGGGAGTCTCATGCAGCGCCGAAAGTGGAACTGGCCGGATTACGAAGA +CAGCATCGCGCAGCTCCGCGCGTCGTTTTGGGCCGGAGCTGTCGCTGGTAGCTCCCCGGA +CACGAAGTTACTTCAGGGCAATGAGTACGTGATCCCGAATCCCGAGCGGATCGCCACGTC +ACTGCACGCGCAAAACGTCGGCAAGACATCGGTCGTGGATTCTCTGTTCGCGCTCGGCGC +GGCGGCAACGGTCAAGCGGGCAAAGCCGTATGTGCTGGCGGACGGGTTCATTACCCGATC +ACCGTTATCGCCGCTCCAGCTACTGACGCGATTCGGCTACGCGGAATACTGCATTGACGA +TTTCGCGCGCGGGAAGCTGTCTCGGATTCTCTTCGACTCGTGGAAGCGCCAAGCATTCGA +TCGCGTCCTGCGCCGCAACGCGCGTCAATCTAAGACGCTCACCTGTCTGTCATGCGGCCG +TACCGGGCTCGGGGTTGGCTGCCCCTGCGGGGCGTGACATGGGCGCGCGAATGCGCACCT +TCCCCTGCCCTTTCTGCACGCTGAAATTGACGACCTGATGGCCGGTATATTGCGAGCCGT +CACGGAAGAAGTACGGGCCACGGTGCAAGGAGTGTAACGGCCGCCCCGGATCACATCACT +GGCCGCACGGCCGATGCGGTGCGTGCAAGGGAACCGGAATCAACGCGTCGTACTCGTGGG +TGTCGGTCAATTCGGCCGAACGCCTGAACGAATTGAACGCCTCGAAGCACCGCAAACACA +TGGCGCTGTCCGCGCTCGCGTTGCTGATGGTTAAACGCGATTTCCGTCAGTTCCTGCCGA +AGCGCGACCGGTTGCTTACGGACATGCAGACGTTCGCGCCGAAGTCGGAGAATCTGCAAT +GGCTGCTCGCCAAGGTCAACCAAGGAACTATTCTCACCCCCACCGAGATCAGGCAGGCCC +TGGCGCTCGTCAATACCGTTAGGAGTCAATTCTATGTCGCCGCAAGCTGCGCTCGCTAAG +GAGATCGCTGGGATGATCCGGCGCAATGTCAACCATACGGACCCCAGCATGCTCGTCCGC +AACGTGATACCGCTCGACCGAAACGAGGCATTGATGCTCGTCGGGATACTCGAAGCGGTT +GCATCGGCGGAATCGTTCACCGAGCAGAAGGTATATGAGGCCCTGAATCCTGACAGCGAT +CCAGCCAAGCCTATTCGCGATTTCCTCAGCGTCTACGCAGCACGGCTCGAAGGGGTCCGC +GGCGTGCGCATGAGGAACGATGAAACCGCCTTCGACTACAGGACTCGCTCGGACTCCGAC +GGACGCTTGATATTGACCAACGGTCAGGTGCGTGCATTCATCGATTCCTTTGACCGTCAA +TCCGGGAGACGGCAATGAAGACGATCTACATCGGATGTGCGGCGTCTATGTACGAGGGCG +GCGCGGAGGTTCGGGCGTTCGAGGACGACGGAGACGCCAGAAAGTTCGCGTCCGACTGTC +GCGCCGCTTCGGCTCGTCGCCCGCAAGCCCCCGCGCTAGGAGCCAGTCAAGTGAAGTGGG +CGGCCTATTACAGGGCAGAAGCCAAGTGGGAGAAACAGCACCCGGCCAGCCCGCACCACC +ACCACGAGTATTTCGACGTAATCTGCCTCGATCTGTACCCGAACCAGAAGTAACTTCGTT +TCATTCCTGCAACATCGCGTGACAAAGTTTAACAGGGTTATTACGGCACGAATTGTCTTG +ACAGTGTTTATCTGTCCGATATACTTCTGCATGTAGTAACGCACTCAACAACCGAAAGGT +GGTTGTCATGGCAAAAATCCAAATTCCGGGCGAACTCAAACTCGACGCCCCCGAGGGCAC +CGTGCGCGCTGCGCTGAAGGAAGCAGGCGCGACGGATGGCCAACGCATCCGCATGGTGCC +GCCCGACTCGATCCACATCGTGCCTGGCCGCAATCCGCGCTTTTGAGGCAGCCCGAAATC +GAAGGCCCACATCGAAGACATCGCGAAGTCAATGATCGCTCGCGCGGCGTCCGGGCTGCC +GGCGTTCATGCCCGAGCGAGCGCTCGTCTGCTTCGCTCGCAAGATAGTCGGCGTAGACCG +CCTCCTCCTAAAGGCCGGCCAACACCGCTTGGCTGCGGTCGCCGTCGCCAACAAGAAGCA +GCCCGGCACGGTCGCGGAAGTCCCGGTGTTCATGGACGAAAATCCGATGACCGACCCGCA +GCTGGCGCTCTACTACATCACGGAAAACCGCAGCGAAGAGCTGGGGCCGTACAAGATGGC +TGTCTCCGTCGCACGCGCAGCGGAAGCGGGCGCGACGAAGAAAGAGATCATGGCGGAACT +GAACATCTCCGACCGCTATCTGTACGATCTGGGGCTGCTCTACATCGGCAACCCGCGCGT +CATCGAACTGCTGGCGGAAGTCAAGGTGAGCGGCACGACCGTCATCGAAGAGATCAAGGA +GTACGGTCAGGAGAAGGCCGCCAAGCGACTCCTGAAGGGCATCGAGACGGCCGCCGCTGC +CGGCAATAGGAAGGTAACGCGCCGCCATCTGCCGGCCGAGGACGCCCCGGCCAAGGAAAA +GAAGACCCGCGCCGAGACGAGCAAGACGGATGGCGGCGAGCAGCGAGCGGCCGACATTCC +GGTCTTCAACGCCACGCTCTCCGTGCTCGAAGTCGTCAACGGGTTCCACGAGCAGTTTGG +CGAATCGGACGGTCGTCATACGAAGATCATGTTCGAGATCATCAAGCAGTGCGGCCGCGA +CGAACTTGTGCAGTACGCGGCTGACACCGGCAAGTACGAAGCGACTGGTCTGGTGCGCCT +CAGCTTGGTCGAGCTGCCCGAAGAACCGACTGCCGCTGAACAAGTCCCGGCGATCAAGGC +GCAGGCCGAGAAGACGAAGAGCACGCGATCGCGTAAGTCGAAGAAGACGGAAGAACCCGT +CGAATCGCCGATCGGCACGGCGGAAGGGCTGTAAATCGGAAGTAACTTCAGGGCCGCTTC +GACCGCCTTTTTCACGATTATTCACAGGCGAAATTATGCAATCCAATCTCGTGCTTCTCC +CGGTCATCCACGGCCGGGACATCTCCATTTCGCCGCTCGGTATCTGCGAAGTCGAGATCA +GCGACCAATTCAGCGTGACGGTGACCATGCAGAGCGGCAACAAGTACCTGTACAAGATCG +AGAACATCTAGCGACGACTGGCCTACTACATGGGCCCACCCATCGAACCGTCGCGAGGCT +ACTACAAGCCGATGAAGGCGATGACCACGAAGCAGGCCCATGAGTACCTGAAGTTTCAGG +AACGCCGACGCCTGGCCGGGTACGTCAGGGAGGCCGAGGAAACCCACTACTGGCTTCTGC +GCCGTTACGAGGACTGACATGTAAGTGGCTCCTACATCGGCCGCTACGTGCAGCCCCGTG +ATGAACTCCGGTCGGTCGAACGACAGGTAATGCAGGCCGACCTCGATCCCCTCGCGCACA +CGTTCGTACGGCACGAGCCCGCTTGCGATGACGGCCGACGTGCATGCGACCCAGTGGGCG +AACGAGCACGGCATCGAGATTACGCGCTACTGGCAGTCATATAGCGGGGACCCGTACGAA +GCTGCCAAAGACCGCAACTACTTCATGCTGAAGGAAGCGGACGTGCTGATAGCGGTACTG +GGCGGCGTCGGCAATTGCAGCGGAATCATTCAGATGGCCCGGCAGATGAATATGCCGGTC +TACGTACATGCGAAAGATCATGGCCTGTAGTTGACACAGTTCATCTTTCTCAGGATAATC +ATCTCACCAGCTACGGCGGGATCAAAATGAGTAAGGAGCCGGAAGACGCAGCAGGAATCA +TCACCTTGAGCATCCAAGTCTCTCGCCAGTTGTGCGAAGACACAATGGATGCAGCCGCGC +ACGGAGTTGAGTATTGGGCGCACGCGTTCGAGCATCCGGGCTGCGGCCCAGAGACCCTAA +ATTGTGCGATTGAAGAAGACGAACCGAGCAGTGGCGAGACGCCAAAGAATTTCGTCATCA +GCCCCGAAGCCATCGTGAAGGGGATTCAGGCGGTCATGCACCCGGCATTCTCGGTACGCG +CAGACCTCCCGGCCACGCTGTCCAGTGCACTCGTAGAAGACGACGCCAGCAACATCGACA +TCGAGATCGCCGATATCATTGTGCAGGCTGCGATGTTCGGCGAAATCATCTATGGCTGAC +CGGAAGTTATTTCCGACCAAGGAGAAGAAAAATGGCGAGGAAACCGTTGAAGATCACATT +CGGTGTTGACGCTGCTGCGCTGGCGATGAACGTCGTACGCCGTGCAATCAAGCGGAACAC +CGAAGACCCGTACGAAGCTGCGGCCGAGCACCTGAAAAAGACGCTCGAAGAACGCAAACG +GCCGATACTTCCCGGCGAGCGCGTCGTACAGAAAAGCCCGCTGTTCGAAGCTCCTTACGC +CGTGTGGGAAATCGACCGGGGCGATGCGGTCACGGTGGACACGAAGTTCGATCGACCGTG +GGTCGGCGTCGTGCTGAAGCGCAACCCCGGTGTGCCGAGAATGTATGTCGTCCAGATGGC +GATGTCGCACGCCGAAATCAACGTCCACGAACGTATGATGAGCCTGCGTCGCCGTGCAGC +CGGCGACCCGAATCGCGCGGTGTTTCCGGCGGTGCGGCCCTGCGAAGGGCGACCGGCCGG +CGAAAGGTCGACTGCTCGCCGCTGGCCGCCGGCCGCCTGGCCGTGCGAATGGTTCCCGCC +GGGAAAATCCGACGCCTACGCGACCGTAAGCCAGTTTCGACGGGACTATCCGGAGCCCGT +TAACACGGAGAAGGAGCAAGCAGAACTCGACATCGCGGCTGCCGGCCTCGCGATGTGCCA +CGACCCTTGTTACGTCGTCCAGTACGGCGATCAGACCGTATGCAAAACCTGCGGAACGAC +GTGGGATACGAATGATCAGTTTCCGCCGTCGTGCCCGCACCCGTGACGAGGCGGCCGTGT +CGGCAGCCATCAACGGCGCTACCATTCTGATGCTCAATATCCTTTACCCCCGGAGAAAGT +AAACGCGCATTTCGAACCCGCAGACTCGTCTCTGGCAGGCTCTCGTGTCTCGGCTGGGCC +AGCGACTCATCGACCGGGCCTTCAGCCGTCCAGCGGACCCGGTAACGCTTCCTGACTTGG +CGAACCACATGCACCGTCGCTGGCTCGTGAAATACTCTCGCTGGACCCTCGGCCGCTGCG +CGCGAATTCCCCACATCCTGCGCTCGGATTCGGATCGCGATTTCCACGACCATCGGTGGC +CGTACGTGACGATCATCCTCGATGGCGGCTACACCGAAGTAACCCCCGTCTACACGAAGG +CGAATCTGTACAAGGGCGAGCACCGGCAGTGTTACGGCCCCGGCTCGATCCTCGTCCGGT +CAGCCAAGCACCTGCACCGCCTCGAACTGGCACCCGGCACGACGGTGACCACGTTATTCA +TCGCCGGGCGCTGAGAGCAGGAGTGGGGCTTTATCACGAACCCCACCTTCAAGATGTACT +GGAAGAACTACCTCGCGCGCGAGACGGACGTTACGCCGGCACGCGCCGAGCGCCGCACGT +TCCTGATGTGCGCGTGTACTGCCTGCGCGAAAGTCACATACTTGGCCCGCTACCGTACGG +ACGACGACAAGCGCCGAGCGGGGGCCGATCTCATCGAACTGATGGAGGCCGGAAGAAACC +CGTTCACGAAAAAGCTGGAAATCGGCGCGAGCGGTCGTACGATTTTCCCGAAAGAGTACT +GCTGTCGGAGTTCTCGTGGTAGAACCACATGCGGCCGCTCACGGTCAGCCCCTGTCTTCC +GTGTCCGCTTCGTCGCCGAAGGCGGTATCCGCGCCGTCCTCGATGTCGGGCGCGCGACAC +GCGCCACGTCAACCTCACGTGGGAAGAGGCGGCCGCGCTCCCGGAAACTCTCTACGAGGT +GGACGAGCTGTTGGTTCCGGCCGCAGTACAGGAGAGTGAAATGGCGTATCTCGGTCTGAA +TCAGCTCCCGTTCTTCCTTTTCACGGACGACATGCCCCCGGACCCGGTCTCCGACGCATG +CCGGCTTCTCGGGATCGGCCCGTGGGCGACCAGTGAGTTCCGGGGAAACATGGACTTCGC +TACGGCGCTCGAACGCAAGCACCCGATGAAGGAGTGGCGGGAGGCGATCAAGAAGGACAT +GGAGATCGAGAAGCGGCAGCAGAGTGCGCGAACGATCGCGACCAAGGCGCGCCTTTGGCC +CCGACGGGTTTCCGCCGGGGCTTCTTTTTGCCTACAGGCCGGCCGCCGGGTCGAGCTGTT +TCCCGAGGTCGATCATCAACTGCATGACACGCAGCGCGTACGGGTCGTCGCTGCCGAGTG +CAATGGCGATGCCTTACGGCATACTCCCCATCTGATCGCAGCAAAACCATTCTACTCTGA +TGCCGGCTTCGCTGGGGTCGCTTTGCCGGGCGGCTTCCATCCACACTTCTTTGCCCCCAT +TGCGTTATGTTCGACCATTTGTTTCAGGACGGGAGTCGGGCTCGCTTTTGCTTGGTCGAG +GGTGTAGGTGAAGGGTTTCGTCCAGTTGCAGCCGGTGTCGATGAACTTGGTTTCAACTAC +GATCTTTGGTTCCTGCGGCATCGGGACTCCCGCTTTCGGGGGAGGCCCATTTCTGCACGA +GACCATCAAAAGAAGCGCCGTCAACGCCAGATACTTGTTGTTCAACATAACAGGGGCAGG +CCGAAGCGCAGCGTGACGCGGCCGACGCCCGGACTCAAACAGCGGAGGTCCGTGACGCAC +ATGCGCAGTCGAACGCGGCAGCCGCTCAACAAGGCGTTGAAGCCGCGAAGGAGCGAAGCG +TCGCGGCGGCCACGTCGGCCGACGCTTTCGCCTTGTCGATCCGGTTGTAGCCGAATGCGC +AGAGGATCGCTACGATAGCAGCCCCGATCGCCGCGATGATCGTGTTCAATGGCAAGTACC +CCCGTTAAGGATGTAGGTTGCACGCAGGGCATCGAGGTGGCGCTTCGGCTGTTCGTACGT +GTTCTTCGTGCCGGGGATAGACACCCAAAGGTTCGAGACCCGATCGCATGCCGTCAGGAA +GTCGCCGGCCTTCAGCGGCTCGATGGCGCGGCACTCTTTCAGCTGTTGAAGGCACGTCAG +GTCTTGCGCGATCTCCGCGAAGTCCGTCAGCCGAAGGAGCGTCTTGTAGTGCGGCCAGTC +CTTCAGCATCTGTTGGTATCGGCGGCTCGCCGTCGAGTAGAGGCCCTTCGAGTTGACCTT +GAACGGCTTAGGGCCGAATTGCGGCATGAACGGATGGTCGCTGAAATCCGTGAAGCGGTT +GTGCTGCAGGTTCCCCTGCGCGTCGATCGAGTTCACGAGGATGTCGTAGCCGTCGTCTTG +CGTGACGGGTGTCTTGCTCGTGCCTTCGGCGTATGCGGTCGTATCCATGAACGCGCAGAC +GTTCAGAGGGCCGGCCAGTTCAGGAATGATCCGGGGCGTTCGGGGTCTCCGGTCGAGGTT +GCGTACGCGCGAGCCGGGCCTGCTTGATGATGCGGAACGGCACGGCGAGCACGATGATGG +CGATCGGGACGAAGCGCGCGTACTGCGGCGGGATCAGCGCCTTCATGTTGTGCGGCATCA +GGACCCTCACATGGAGCAGGGTATCGGGTGCCACCTCGATCCAGCTCTGCAACTCGACGC +CAACTGGGATGAACCACGTCGAGCTGAACTTCACGGGGGTGCGCCAGTCATCCACGAACT +GCACGCGCTGCTTCAGGAAGACGCGGACAATGCTTCTGTCCGAAAGTGGGCGAAATGAAC +AACCTCTTCGAATTGGCGGCCGTAGTCGCCGCCGTCGCACTGGCCGCGCTCGTCGCGGTC +TTTTTGTATAGCCGCTTTAGGGTCGTTGATCGCACGGTCGAGCTTGTCCTCGATGCGTCG +CAAGTCCTCTCGTACGTCCTGTTACACCTTCGTTTGGTTGGTATCGATGCGCTTGATGTC +CTCCTTCATGAATTGAATCTGCGTGGCCGAGTCGCGCGCCCGATCTCGGATGTCGCCAGC +GTAATTCGCGACCCAGCCGATTGCCGATCCACACGCAACCAAGACCGTGATTGCCATCTT +GATGTCGATGCGGCTTTTGTCAGTGATGTGTGCCGTCTCATCCGTGTTGTTCGTCGTCGC +GTTCATTCGCTGGCCCCGTGCGAAAAGGTTGAGGATTCGCGGGATTCTAGCAGAACCGGA +AGCAGTCGAAGGGCGATACGAAGTAACTTCAAAGCGGGCGGCCGTCATAAGTTTCACCAT +GTGAAAAAGAAAGGGATGGGCAATGCTGCCGCGAATTCTAGTACCCGAGCGCCTGAATGA +CAAACGGCCCCGGAAGGCCGTCTGCGCTACATCAGGTTGTGGGCCACGGGTCGTCCGGGC +CGAGCGGCGTATTGCCTGCCGCCAGCCACGGCTCGTAGATGTCGATCCAGACCGAGCTAT +CTATGGGGACCAGCCATATGGCCTCGTCAGCATCGCGGTGCTGGACAACATCGTCGCGAA +CGTCCGGGGACGACCCGTTGAACTGCCTGAACGCTATTTCCATGACAACTTCTGTTAAGG +GCGTGCATCGCCGAGAACGTATCCGTTCGAACCGCTATCGAGCGAACCACTCCCCGTAGT +AGACCATTGCGCCGCGATCCGCGAAACGAACTTGTTGGCCGCATCGACAAACGACGTGTT +GACGACTCCGGAAGTACCGACCCACGTACCACGGATCGAGGTCGTAGGCGAACGCGCTTT +TTCCGAACTCCACACAATCGTCATGAGCCCGTGGTTGCCGCTGACGTTGTGCGCGTAATA +CTTGATGTTTCCTCCCGTGCCGTCGAGCCGTTCGATATACCGTTTCACCCGAGTCGTTTC +GAGCGCTAGGCCGCGATACTCGAATGGCGACGGTGGGCCGCCGAGACCGTTCACGTCGCT +GCTCGATGCCGGGTCGCTTTCCTCGATCTGTAACTGGCTGAAGTCGAGCGTGAATGGGAT +TCCGGTCGCCAGAACGAACGCGACCTGAAGCTTATCGTCCCCGTTCGTCCCGAGTTGCTT +ACCGGCGATCGACGGGATATCGACACGGACGCTGAAACGGCTCTCCGTCGTGCCGACCGA +CCACGTGACGCTTTTCAACGTGACCACGGAAGACGCAGGCGAACCCCCCGAGACGAAGTT +CTGCACGACTTGAATCGCAGTCACCAGATTGGCCGCTGCTGCCGCAACGGGCGTCGTGCT +GACCGTAACACTGCGACCGCTGAACGTGTTGACGCCTTCGATGTTCTGGTAAAGCTGCGG +CGCCGAAGATGCAGCCGTCGTTTGGTTGAACCGCAGCTTGTACCGGCGCGACGAGTCGAT +CCACTTCGGTGCGGACTCGGGGGTCGCAGGGATACGCGATACCGTCGTCGCACCGCCCGT +TCCGGAGATCGCGCGCCACATATCCGCCGTGTACTGGTCGGTCGCAGCCGCGAGGTTGTA +CGACGTGCCGATCTGCCACGAATCGACGTTGCCGTCCACGAAGCGGTTCCGGCCGGTAGT +AGCCGGGAGGTCGCCGGGCTGAATGGTCGAGTTCGTCCAGTTTGCGCCGTTGTTGCGGAG +GTACTGGCCGCTCGCCGACGACACCGCGAAGCCGATACGCATCGTGACGGACACGGTCGA +GCCGCCTTGCGTGTCGTACGCCGACCCGTTGACCGGAGGACTGACGTTCACGCGTGCCTG +CGTTCCCATCGTAGAGAACGAGTTCGACGGCCACGTGCCAGACCCCGGCGAATCGATAGG +CGTCGCGTAGTTGCCCGCCCGACCCGCACAGCCGACGAGGAACGCGTACTGCGTACCTGC +GGTGAGAGCGACCGGCGTCGGGAAGTTGAAAGTCAAGTCCAGCGACCCCGCCGTAGCGAT +CGTGACAGGGCTGCTGAACGTCGGTGCGCCGGTAAGCGTGCCGCTCGATGCCGGGGCGAC +GGCTGCTTGCAACTGGACGCCGACCATTCCTGCCGTTTGAAGGTGCGTCGTCAACGAAGT +GACTACGCAGTTCCGCGTGACCGTCAGCAAGTTACCGTTCCAGTTGTACGCGCCGTTGTT +GTAGCTCGTCGTATCGGCCGGGCCGACAACCGCACTGACAGGAACGCTAACATCCGAGAG +GCCGCTTGCGAGCGCCGTAGCACCCGGAGTCGTAGCCCGTGTCCAGTCTTCACGGAGGAA +CCGCGTAGTGCCAGCGACGATACCCGGATCGGGGACAAGACCCGCCGCATGCGAACCACC +GGATGCGCCCATGACAGGCGGAAGCGGTGTAGTCGCCCATGTTGCATCCTCGCGCAGGAA +CCGCGTAGTGCCAGCGACGATACCCGGATCGGGGACAAGACCCGCCGCTTGCGGACCACC +GGATGCGCCCAGGACAGCCGGGAGTGGTGTAGTCGCCCATGTGGCCTCCTCGCGCAGGAA +CCGCGAAGTGCCAGCGACGATACCCGGATCGGGGACGAGACCCGCCGCATGTGAACACGC +GGCCGGTCTCGTCCCCGATCCGGGCGCAACGGCAGGAACGACGAAGTATCTCCGTGAAGA +TGCAACATGGGCGACTACACCGCTCCCGCCTGTCATGGGCGCATCCGGTGGCGTTGACCC +GCTCTTCACAAACGCACCGAGTGTTTGCCACGTAGCCGTCCCGCTGCCGCCGCCCGTGTA +CCGTTGGCCGTCCGTGGGCGCTTCACCGAGAACAGACGCATTGACAAACTTCCCCTGCGT +CGCGTCTCCGGACGTTACCACCACGAGCGACGATCAGCTTCGCTGGCTGGGCGATGTCAA +ACTCACCTCATTGACTGACGGGCAGGCGATCACATGGTCGGCATAATCGATGAACACCTG +ATCGGTGTACGGTCCCGCACCCGTGACAGTCCATGCCGTAGTCCATGCACTGCCGTCGTC +TGAATACTGGACGGTGAAATTCGACGGGCCGCCGCTCAGATTGTCAGTCACCGCAATCTG +CACACGCGCAACGGACTTCGCAGCGGGCCACTGGTACCCGAGGAAAATCTCAGCACCGGC +AAGCGGAGCGCTGTTGGAGCGGTAGTAGGATGCGGTGTTACCGTCGAACGCGTTGTCCGG +ACCAAACGTCGTGTTTTGAGCCGAACCGGATGCCATGCCCCCGGTTGTTGTGATCTGCGC +GCCATTCGTATCGCTGAACCGCAGCTCGGCAAGACGCACGCCGACGCCCCCGGTTTGCGC +GGCCGAACAGTTGGTGCGCCAGTACTTGTGATCCCCGTACGGATTGGTCTTCGTGAAGAA +GCTGGCCCATGTGCCATTCTGACGCATGGATTTGGTCCCATCGCTCAGCGCGTCCGCGAT +ACCTGCCGTAACCTTCTGGTTCGTCCACTTGGCGCTCGCGGCGTTCCACGCGATGACCTG +CTTGTCGCTCTGCGATGCCACGGCTACATCGGTCAGGCCGACAAGCGTCGTGCTGCCGCC +GGCCGGCGGCACAACCCACGTTCCATCTTCCCTGAAATACTTCGTAGTGCCGGCCGTTGC +ACCCGGATCGGGGACGAGGCCAGCCGCATGAGATGCACCCGATCCGACCATGGTCGACGG +GTAGGGTGGCACAGCCCATTGCGCATCTTCACGGAGGTACTTCGTCGCGCCCGCCGTCGC +GCCCGGATCAGGGACGAGGCCGCCGACATGCGAAGCGCCGCTCGCGACGAACGCGCCGAG +CACGTTCCACGTCGCTTGGCCGCGCGTGTACTGGTTGGCGTTGTTCGGTGCGTCCGGAAT +CCCGCCGCCCCCGCCGATCGTCTTGTTGATCCACTTTCCGGATGCGGCGTCCCACGAAAC +GACCTGCTGGTCCTGTGGGTTCGAAATGTTGGCGTCCGACAGCGTCGCCATGCTCGAAGC +CGGGATTTGGACCTCGGCCCAGCCGGAATTCTTCCGCGCGTACTGCTTGCCGTCTGCCGT +CGCTTCGGGGATACACGTGCCGGTCGCAACAGGAGTCCAGCCCCCGGCTTTCCGTGCGTA +CCCCACGCCGTCGCTCGTTGCGTCGGGAATGCCGCACTGCGCCGCCTGCCAAGCCGTGCC +ATTCCACTCTACGCAGCCCGTGGAGCCGCTGAAAGCGGTCCACCCGAGCTTCGGAGTGTA +GAAGGCCCACGCGCCGCCTAGGAAGGGCGCGACGTCGTCCCCGTGATTGGCCCACGCTCC +GGTAGGGGCGGGGGACTTACCGACGATATAGCGATCGCCCTCGGCCGGTGACGACGGAGG +GACTGTCAGCGTATTGTCGATCACGCCAAGCTGCACGATCGTATCGAGAAGCTGCAGCGA +GCCGTTCGTGGTCGTCCCCCAGCCCGACGCTCCGTCCGCCCAGCCCCACCAGACGCCGAG +ATTTTTACCTTGTGCTTCTGCCATCATTGGCCTCCAAAGTCCTTACCCCAATTCTAGCCC +CAGTCGCTATCTGCCGTGAGCCAGTGGGTGAAGGTGAAGTCGTACTTCTGGTAACACGTA +ATGCCGCTGCGCGTGCTCTCTATCTCGGCGCGATGTGTAGCACCCTGACCATGGCCGACT +GCGGCTTCCGGGAAGGTGTACGTATCGGCCTTAATGCCGGTCTGCTGCACGATCAGCGTG +TTTGCTGAATCGTAGATGCGGATGTTGTAGGTCACGCCGGTTTCCGGCCCGACGCTCTCA +TCTTCGTGGGCGACGAGTTTGTCTTGCTGCGGGATGCGGTCTCGATGCGCCCATGTGAAG +ATCAGGTCCCCACGGACGGACGAGACTTCCGCGTAGTGCTGGCCGTTCAGCTTCAGAGTC +TGCGTGCGGAACTGCACGGCGATCTGCATTCCTTCGCTGAACTCGGACGGATCAGCGCCG +AAGTTATCGTCGTAGACCCATACGATATCGTTGCGAAGATGCGCGGCCAGGAGCGTGTCG +ACACAACCCCGTCGAATCGTTACCAGCTTTGTGCCCATATCGTAGCTGACCACCTCGATG +ATCTCGTCGCCGATAATCGCGGCCATGCCCGGCTCGATGAGGTCGGTAGCCTCGTTGTCA +TCGAAGCGCAATGTCGTATCGAACTGACCGAGAGGCTGCGACAAAACGACCAGTGGCATG +AAGGCCGCCGTGTTGACCTTGCGATACGTGTTCGTGATGCCGGGATCGTCCCATACCTGA +TACGACAGCGAGAAGATATTCGGCTTGCGCGCCACGGCGACCAACGTTCCGCTATCGGCC +GGGACCTGTGCGAGATCGGCTGGCGACAACTGGCGAACGAGATCACGATACGTCGCCTCA +GTCGTGCGGTAGACGGCCGGCGCGACGGGTGTGCGGTTCGGCGGGACGTACTGACCCGGC +TTCGCTTCAACGTACGTCGTGGACGGCAGACCGAAAATATCCTGCACGGCCGTGATCTGG +AAAGACCCTTCCTCGTAGCGACCCGCCTGAATCTTGCCGGCGCGCAGGATCATGTTCTCG +ATGCCGAGCTGCGGCACGCTGATCGAGAACACGTCGGTCGGCGCGAGCTGCGCGGCCCGG +CGGTCGAGCGTGAGCGTGAACCGCTTCAACGGCGTGCCGTTCGACTTCAGGTCGCGCATC +GCCACGCGCATCGCGAGGTCGGCAGTCGGGATTGCCGGGTACGCAGTTGTGGCGCTATAC +ATCGCACCCACGGCCCGCATGTTTCCGACGTTCTGCGCGCGGACCTGCTTGTCCTCGTCG +GTGATTGGATCGTGGTACATGACGATCTGCTCGTTGCGGCTCGTGTCGCTCGAATTGCCG +TCTTGTGAGATGTTCAGCAGGCCGGACGTCTAGTCGAGATGCGGAATTGTCGCCGGGTCG +TAGTCCGAGCGGATCAGACGCAGCGTCAGATTCTCGGTCTTGCGGTCGAAGTAGATGGCC +CCGCCGATGTGATTGAGAACCTCTTCACCGACGCAGCCAACAAGCTCTGCTCGGAGTGTT +TCGGCCTCTGCATTCGGTGGAACCGACAGGACGACCTCGATGCGTTCGTGCAGCGACTGT +TCGTCAATCAGCTCACGCGGTAACCCCCTGCCCCATTCGCGGTTCGTCGCGCATTCATAG +ATGATGTGCGCCGGGTTCATCGCCTCGATGGTCTGGTTCGCCATCTGGTTCGTCGCCTTC +TCCGGATAGAAAACCGGGCCGTCCCATCCTTGAATCGATCGACGCACGCGGAATTTCCAC +GCCTTCCGACACGGGTTCATCCCGCAGATCAGGCTGTCGAAAAACACCGTGAAGACGCCC +CGGAACGCCGGCGCGATTCCGCCGAGCATCGCGGCCAGTCGCGGATTCACTTGCTGGGTC +GCCTCACCCATCATGATGTCCGCGTTGCCTCGAATGCCGCCCTCCTACTTGTCCCCGCCG +AACAGCCCGGGCGAGTTGATGTAAATCTGACCGCTAGTCGAGACGCTGCCTGCCCACTCA +GTAAGATCGCCCACGGTGATCGCGACCAGTTCCTCGACGGGGCCACGGTAAAGCGCCGCA +TAAATCCCGAAGCAGTAACGATACCCGATGACGGTATCTCCGCTTTTACCCCCGCCGCCC +ATTGCCGTTCTCCTTGTAGACTTCTTCCTTCGCTCGTCCGAGCAGCGCGCAAGTGATGTG +CTGCGTGTCACTGATCTTCAGGCCGTTGCGCAGCATGTCGCGAAACGAAAGCCCGTGCGA +CTTGAACCACTCCCGAGCGCCGCGCTCGCACATGCCGGCTTTGAAGATGTGCCGGATGTA +GATCGTCGGTTCGTTGACTTATTCCCTCCCCCGGACATGATCGACGTCGTGCGGAAATTG +CCGAGACCTACGACCGTCCCATCGCTGCACCAGCAATCGCCGAACATGACAGCCTGCGGC +GTGCCCTCCGGGGCCTGCGGGAAGTTGAAATCCGCGAACTTCGCGGGGTCCGGTTGCTGC +GCTCTCGGGCCGAGCGCCGCCGACAGAAAGTACGACGCGACCATGAGCACGAGCCACACG +ACGAATTGCATTTTTGTTCTCCTTAGAAGACAGGATTTCCGTCGAACGGGCTACGGCCGG +GTATCCCGTTATACCCGCCGTAGTTAAGGTCGTTCCCGAACTTGTTCTTACAGACGGATG +ATAGGCGAGCACAACCCGGATAGATCACGACATTCATTCCGATCGCCAGTCTATCCGCAG +CGCCCATGGGCGTGATGCGATTGCCGACGTGCGTTTCGATGCCGTACTGATCCCACGATC +CCGGCTCGCGCTCGAACTTCATGAAGCCGCCACTGAACCACGGTGCGGCCTTCGAACCCG +CCTCGGCGCACTCGAACCAATCGCAGCCCACGGCAGTGATGACGCTGTTCGTGGCGAAGT +TGTCCGGGTTGAGTTTGCAGTTCACGTCGTACACGAAGTACGGGCAGCCCTTCGTGTATG +CGAGGCGCAGACCGCCGCGCTTGAATGTCATCGACATCTGTTGCCCGACGATCTGCGCGT +TCATCAGAGACGTGTGACGCACATCGGACACCGTGCCCATCCACGCCACGTCCGCTTCGT +TGTCCGGGTCGTTGTAGTGGTGTTCCCGGATCGTCAGGTAGATCTAACCGATTGGCGGCG +TTCCGCGCTACTGCTTCACGATGTCCAGTGAAGTCGCGCAGTCGAGCGTGATCGAATCGG +CCCACGCGTTGCGGCTCTGCGAGTAGCCGTCGTGCGCGATGTTCGTCGCAACGTACGTAT +TGTTGTTCGACGGGATATCGCGATCAGCGTTCGTGTAGTAGTAGAACTTGCTGCCGTACA +GGAACTCAACGAGCAGGAGCGGTCGCCCGTTGAAGTTGCTCATGTCGATGTTATCGAAGC +TCATTCGAACACCCCTCCCCCGTTATATGGCTCTTGGTTGACTACGTGCGTGGGAACAGA +GATGTCCGCGTTAGGGTCTGCCGCTAGAAAATCGAAGACGAAGTTTCCGGCGTTTTTGAA +CACGAACCATTCTGTCTGCTTTGGATTCGGATGATACGATGGAACTCCGGTCCCCGGATT +TGGGTTCCATCGAAACGTCATATAGGGATATGCGCGCAGGTTATTCAGATAAATGCCGGT +GTTCGGGATCGCAATGTTATAGCAGGCGAAGACCAGCCCCTGAACAATCGACCCGTTCAC +ATCATGTTGTCGCATCTTCACCTTAGCCGGCTATTGAACGGTATCGCGAAACGCGGCGGT +AAAAAGGTTGCCCGAAACGTTCGCCCCCCTTACGTCGCCTGCCGGGTAATGTCCGCCTTG +GACCGCAGTCGGATTCAGCACGTCGTTTGCTTGCGTCTTCAGCTCGGAGATTTGAAGCGG +GACTGCACCGCCACCTGCTCGGATATAAGAGCCCGCTTTTCCACCAAGCAAAACGTCGAT +AGAGTTGATAGCAGCTTGCATCAGGCCGCTTGCGATTGAGTTGTCGAATGCGGGAGCGGT +GCTCTGCATCCAGCTTCCATTCGGGTCAGCTTCGATGGCTCCTGCATCCACTATACTCGC +AGGCGCGCCGCGCATACCTGCGACCATGGGCGGGTTGCAACCCACCAACCAGTGAATCGA +ACCGGTCGAGCTGGTCGTCTGCGCTTGAACGTTGGACGCACTCGTGATCGATTCTAGAAT +TGCAGCGCAGGCGGTTGCGGGCAGTGTTTCTGACGCGCTATCGTCCTGCGCGCATTCAGT +TATGTCAGGGGTGGATCACCACGGATCGGTACGCGTACTACGCTTCGCTTGATGACGCAA +CGTTGCACGCGGCGTTTCGCGTTTTTCTGGCGTACAACATCTATTCTCTTCTGTATTCCC +TCCTGACGGGCGGCCTCGCGTACGCGGCGGCGAAGTCGCTCATGGGGTACCTTGAATAAC +CTCAACGCAACGTACGACATCATGGTCGCCAGCGGCTACACCCCGGACCAAGCCGAGGCG +ACGCGGCAGAGCACGCTTGCGGCGATGAACGATTCGAACAATTACACGCGGGACTATATG +CTCCTGACGCGCTGCGTTCGCCCCGAGGCAGTAGTAGAGCAAGTCCCACGACTCATTACG +CTTGACCGACGTGGCGACCCATCCCTTGTCCGTACGCCGCTCGGAGACGAGCTGGACGTA +GTAGCTGTCAGGCAGCCATTCGGGGAAGTGAACCATGGACTCAGGTTTTGGATACTCCCC +CGCAAGCGGATCGACCGGCGGGCGGCCATTCGTTCGAACGCCGCCCCATGCGCCGCATTC +GCTGCCGCAAATACACGGGTCGGGTGTTTGCGTAGTCTGCGTATAGCGCGTGATGTCGTA +ATTCGTGGCTACTCGATTTGCAGGCGTGCTCTGGAACGTGACAACTGCCGAGCTGACGCC +CTTCGTGTCGGTCATGTGGTTGATCACTACGCGGTCTTGATTAAGCCGCGCGAGCGTCAT +GAACGAGACGCGCTTCAGGTCGGTCGACAGTGCCGGCAATGTATCGTCGCGTATTGGGGG +TAACGCTCGACCAGACTACGGGCAACGAGATCGTTACCGTGGACGCGGCGTTCACGCAAG +CCGTATTCGCCTCGGACGCGGGTCGAGAATGATGTCCTGCTGCCCGTCGCCGATATGCAG +CTCGCGAAACCGATCCAGTCAGGTGATACGACGATCACCATCAAGCGCAGCGGCTTGGCT +GACTTCTTCTCGACCCTTCCTCGCATGGGACGGCAGCCAAAAAGGCGTGACGCGCCCGCG +CAGTGCGTACAGCAATCCGCGCAGGTCGGCACTTTGCTGGCGGCCGTGCGCGAAGAAAGC +AAACTGCTGCACGTAGAGCTGGATACCTGCGGTATCTCCGCGCTTCGGAATGCCGGATCC +GGAATCGAGCACGACCACTAGCCGGGAATACTGAACCATCAGGTCGCCCGTCTCGTCCGG +GCGAAGACGAAACACCGGATAGCCGCGGTAGATGTCAGTCCATGCGGCTTCCGGGTAATC +GTTCGTTTCCGTGACCTGCCAGTTGATCGCGTAGACGGCAGCGCGATCCGCCTTTCGGGT +CATCTGCGGCTGGTCGGTCAGCATGGCTTCCTGAATCGGAAGTAACTTCGTGCCTTTCGG +CCATGCCTGCACGAGGCCCTGATCGACCGTGATATTCGTAGCAGTCATATCGGCTATCAG +CCGAACCTCGTAGTCCAATGAAGTCCGACCACGGAAAAAGACGAGGCCGCCCCTCTTCAG +TTCGGACGTGGTCGTATCCTCGACGTACACGACGGTATCTCCGACTTTCGCAGAGGGCGT +CAGCGGGTTCAAATCCCACGGAAGAGGGACATTCCAGCTCGTTCCGCCGCCGGCCGTCAG +CGCGGCGTTCAGGCGCGTGCGCTCGGCATCGATCACGAGCACGGACGATTCGAAGAACCG +GCGCGGCGAGATCCGCAGCGAATGCCGCTGCTCGGCCGCCATATTCGATTGCTGCACACT +CGTCGCCCGTTCGAGCGCTTCGAGTACGCCGCCGGACCATTCGGTCGCGGAAGACCCGAC +GGGAAGATTGATGTTCAGCATTACTTGATCCCCAATGCTTGGCGTGCGGTTACGGCGTTC +TGCCGCAGGTAGGTTGTGATGACGATATCGCCTGCCGCCGACGCCATCGCATCGGGCACG +AAGTTCGGATCGGAGATCAGCGTGTTCCGGATCGTCATCGACTGGTTGGCGGCCTGCGCT +GCATTCTTCGCGGTCTGGTTCAGGATGTTGCGCGGATTGTCCTTCGCGAGTACTTCCTCG +CCCTTCTGAAGGATCGCCGCCTGTTCATCTGCCTGCAGGCCGACTACCGTGCCACTGTGG +TAGCGCGGCGCGTTCGCAACCCAGCTCGCCGACGCACTGCGCGACATGCCGCCCGGCTGA +CCGACGACTGCACCGGAGTGCGCAATGGCAGCAGGTACGGAATCGACAAGGCCCCACGTC +CCGGGGCCGGTTCCGATGCGCTGTCGCCGGAAGAGCAGGAAACCGAGCGCACGAAACTGG +TCCTGAAGCTCGCCGCGATCTACGCTTCCCGCGAGCAAACTGTTCAACGTTTGTCCGAGC +TGGTGGGCTACTCGTCCAATACGCTCGGCGCTCTGTCGTCTACCGGCCGCGCGTTGCGCC +CGGAACTCTGCATCGAGATCGAGAAGGCGGTCGGGCACGAGTATTTGCCGCGACGCTTGC +TCAACCCGCATATCTTCGAAGTGTACGGCAGCCGGGGCGGTCGACGCAGCGCCGCCGAAC +AGCCCGGGCAGCGCACGCATTCAAGAACGTCGGGCAATCGGTCGCACAGTTCGCTGCGCA +GTTCCTGCGCCAGATGGCGAGCGTCATCATGCAGATCATGGCGACGCGCGCGGCGATGCC +GACCATTACTGCGTGCCATTGGCGGCAGCGAGAAGCTGGTCAACGACGTTCGTCATCGTG +CTGTCGCTCCCCTGCGCGAAACCGGACGTGAACGTGTCGCGAATCTTCGCCATGTCCTTG +TCGCACGTACTGCGCCTGCGTGCTGATTTCCTTCGGCTTCGCATTGTGCGCATCGAGCTT +GGAACCGGAGATGTCGCCGAGCTTCGGCCATCGTATCGAGCAGCTTCTGCATCTCAGCGA +CCATGCCCTGTATCTGCGGGCCGCTCTCCGTGTACGCGGCCTTGATTTTCTGGTTCGCCT +CTTCCTGCGTAATCGCGCCGAGCTGCACGAGGCTGTAGTACATCGTGACGGCCGAGTTCC +GCTCATTGAGCAGGTTGTTCGTCTCGGTCACCTGTTGGTTGAATACGTCGAGACCGCCCT +TCGCCGCCGCAGATGCCGGGTCAGTGGCTGGATCGTTGCGGACGCGCTTCATCTTCTGCA +CGAAGGCGTCGATCTTCGCGTCCGGGATGCCCGTGCCTCGCACGCTGTTTGCAAACGCCG +CTGCGTCTTTCGCCATCTGCGCAAGTTTCGGTTGCGATCGTTCGGTCTGCTTGGCGATCT +GTTTGAACCCATCCACTGCCGACAGCGTGCCGGCTTTGACTTGTTCGAGCACGTCTTTCT +AAAAATCCGCTCGCTCTTTCAGCACGTCGTTGACTTGTTCCTCTTTCTTCTTCAGTTGCT +CAGTGTTGAACTTAAGCGTTTCTTGCTGGATAGCTTGTTTCTAGATTTCCTTGATCCGCG +CCTTGATCGCGGCGATAGGCTGGCCGTCGACCGTCGTGCCGCCGATCTTCTGGTAGTTCT +CGATCGTGTCGGAAATGTCCTTGAACGTGCGCTCGACAGCCTTCAAACGCAGGTCAAGGT +TGTCCTTGTACTGCGACTCGACTTGCTTTCAGAGCGAATTCAGTTTCCCCGACAGAGACA +CTTCCATGTTGTCCCGCTTGCCGGCGTTCTTGGCCTTCTTGTTCGGGTCCGCGATGTCGT +ACAAGCCGCCGGACGTATCGGTCAGCGGTGCCCATCGGGGCGGCGTCGTTGCAAGGCGCG +AGCCCTGTCGACGGAGGTCATTCTGATACAGCACGTTGAACGCCGCCTTGTTGTCGGACA +GTGCTTTATCGCGCTCCGCGCGAATCGAAGCGAGGTAGCGCTGCGCGAGTGTTTAGGCCT +GCTACATCCCGGTCTTAGCGCCGTCAAAATCCAGACGCTGAAGAACGGCTTCCTCGGCGG +CCTGCGCAGCACGGCGGAATTCCTCGGCCTCGATAACGTCGCAGAACAGCTCGGCAGGGC +ATCACGCTTCAACGCCTTGTCGAAGAAGTCCACGACAGAATCGCTCATCTGCGAAGCAAG +CACGAGAATGCCGTACTTGACGTTGATCCATGCCTCGTAGATCGATTCGGCCGCCGCAGT +GCCGACCAGTCTCGCAGTCTCGAACTTCTCGCCGATAATCTTCCCGATCTGCCATCCCGT +GAACACAGCGGTCAGGACGAGGAAGATTTTGTAGATTGCCGAAAGCGCGGCGTTCTACCG +ATCGGCGGCCATGGAGGCGGTCGCCATCGACGCGCCGGCTGCATCGACGCCCGGTGCAGC +GGCCGCCCCGGACGCACCGACCGCGGCCATAGCGAAGGCCGCTTGTGTGAGCTGGATCGT +GAAAGCCCCGATCGACGCCATCACCTTCACGCCGAGCACGAGCCCGATCACGTCGCCCAT +GGCGTTGATATTCTTGATGACTGCTTCGAGGATGTTCAAGACGACCGTGAACGCGTCGGA +AAAGTTTCTCGCGAAATGCGTGCCGTCGTCACTACGAAGCAACTTCGTGATGTCGACGGC +GAACTTGGTCCACGCGTCCGCGAAGCCCATATCGGCGATCGCCTTCCGGAACTCGTAGAA +CGCGTTGTACATGCGAGCCTCGGCGGCCTGCATATTATTGACGGCCATTGGGAGCTGCTT +TCCGTACTCATCGCCGAGCTGTTGCGCGAAGCCGAGGAGCTCCTTCACCGAAACGCTGCC +CCCTTTGAGCCGGCCAGCTCGGCGATCGGCTGCCCGCCGCATTCGCGCTTTTCGCGAAGG +GCATGAACATCAGTCTGCCGGAATTGAACAAGCGCGCAGTTCTTCCGTCTGCACCTGCCC +TTTCGACATCATCTTTTCGACCGCGAGGAACGTGCCCTGCATGTCATCCGCGCACATGTG +CAGTACACGGGCGGTCTCGGCCACTTTCTCGAAGATAAACCGCGTCTGGTTTGTCGTTGC +GCCGGCTGCCTTAGCGGACACGGCGAACTTGCCGTACGACGCGGCGAGATCATCAATCCG +GATGCCGAGGCGTTCAGCTTGCGCCTGCACGTATTGGTATTCCGGCGCAACGACTTTCGG +GTCGTTCGTTCCAGCGGCCACGGCGAATACGGATTGGTTCGAGTTGAACTTCCGAATTGC +ATCGAGTGCCCCCGCCGCAAGGTTAATCGCGCCCTGCACGCGGACGTACGCCGTGGCGCG +CGCGATCAGCTCGCCGCGCACGCGCTGATTCCACGACAGCGATTCGCGGTTCCCCGTCGT +GAGGCGGTCGAGTAGCGAAACAGTCTTCGCCGCTTCCGCATGCTGCCGCTCAGGCCGAAG +CTGCCGCCGCGTCGAAAGATCTCACAGCGCAGTCTCAGCAGGCGAACGGCATTCGAGCAA +CGACCGCTGCGATGCAAGGACACACCGAATACGAGCGAGGCGAGCATCAAAAGCCTTGGC +GTTCGCATCGTTCACCGCAGCCTGCGCAGCAGCCTCTCTGGCGGCCTGCTCGCGCCCGGC +CGCTACGATGGCAGCCCCGGCGGCCCGCGCGCGGTCCTGAAGGGCAGTCAGGCGGTCTGC +TGCGGCAGCCGCAGCCTGCGTTGCCTGCGCCTGTAGATTCATCGCCTTGGCGACCTGCTC +TGCCTGCTCGGCGACTTGCGCTTCAAGGCCACTGAGTTCGGCCATGGACTTCGTCAGGCT +GGCCGTGCGGGCATTGGCCGCCTGCACATCCTGACTCGCCTTCGCGACGCGCTGGGTAAG +TCGTTCGAAGTCCCGGCCGCCGCCGGCCGCCGCAGCAGCCAGCTTGTCGAGTTCACGGGC +GGTCGATCGAGTCGGCGGCCCGGCGGTGAGTGCATCACGCGCGAACATCTGGTACGCGAT +GGCCGCGCCCTCGACGGACCGCTTATGGCGATCGAGGTTTTCGTTTGCGGTATTGAATGC +CTGCGACGCCGCACCAGCTCGCTTCTTCGCCTGATCGAGCGCATCAGCAGCGCTTGACAT +GGCTTTTTGTACGGCGTCAGCAGCCTTGGAGAGATTCTTCTGCTGATCGGAGAGGGAGGC +GGCCGCTTTGCCGAGACTGTCCGTCCCTCCGGTTGCGGCCTTCGCCTGTTTGACTTGGTC +GGCGAGAGACGAAGTAACTTCGTCAATCGCCTTCTTCGCGTCCTTCATCGCCTGCGCAGA +CATGTCCTTGGCGCGGATGATGAGGTCGACTACCTTCTGGTTATTCGTTGCCATCTCGGA +GGCTCCTAACTTTCTCGTTCAGGGCTTTCACGTCCCCGGACCAGACGGCGAAGGTTGCCG +CGTAAGTTAGAAGCGCTTCGGTAGCAATCAGGCCGTTGATCCGTTGACGCGAGATTCTAC +TCTCATTCTATAGTACGGCGAGGGGGTAGTCCCACGCGTCCGGGTGTCCTTCGGCCATCA +AGAGGCTGGCGTTGTGCAGCAGTCCGATATACCACTTCTCGAACCGCGACGGTTCGCCGT +CCGTCAACAGGGTCTCTTCGGGATCAAGCCTTTCGTGATCCCCCGGAGCGCCCCCAGGCG +ATTGAAAAACTCTTTTGGGCCGCCTGCGTCCTCGAACGTGGGCTTCCGGTTAGCCGTCAA +TGCTTCTATCTGCACCGAGAAAGACAGCTCCGCTGCAAACACATCGGCCAGTGCTTCGAG +CTGTTCCTCGTAGTCGTCGGCTTTCCGATCTGCCTCGTCGCACGCGAGCGCGATCATCTT +CCTGACCAGTTCGGGGACCTCACGCGTCAGCATCTGGATGAGAATGTCTCCCGACTGGTT +CATGTATACGTCGGTCGTGTGGGCGGAATATGCTTCCATAAGCGAATCGCTATCTTTCTG +ATGTATGTCCACGAGCTGCGCCACTTCGGTCAACGCGAGACCCCGCACGCGCAGGGTCTT +TTCGCCGACCGGGATCGTGGTGCGCCGTGCTTTGTAGTCACGGAATCCCATTTCCCGGTT +CTCCTTACATCGGCCGGCCGTTGATGTACACGCGCTCCGTCGCCGAGCCCTTCTTCAGGA +CTTCGAGCTTGAACTGGAGCTGCTGCCATGCGTCGCCCTTCAACTGAAAGTTGCCGTCAG +CGGTGATCTTCGTGTACGGCATGATGTAGTTGCGCGACGGGCCGTACGCGTTGTGCGAGA +TGAAGCGGACCGCACCCATGATCTGATCGCCGGCCGACACGACCAGATCGTAGGTATCCG +CCGCCAGCTTGGACGTCCCCGAGATGGGCTTCGTGTCGGTGATGTCGGCTGCATCCGACT +TGACTTGGAAGCGCCCGTTCTTCAGGTCGACGTTGAAGTTCGTGAGCGGGATTTCGGCCG +GCGTGGCGTCCGTCGTCTTCGCGTCTAAATCGGTGACAGCGCCGGCGCCCGCGATTTTCG +TCGTCGAGACGCCGAGTTGATACCATGCGCCCGGCGTGACGATGATGGTTTCCGGTGCAA +CCGGCGACGCGCTGCCGGCTTGCGTGACGTTCGCCTTGCTGCCGGTGAACCGGAGCGCAA +GGTTGTCCGTCGAGATGTTGTCGACCTGAAGCGTCGACGTCACGTCCTGTTACAACGTGA +TGGTGATGTCCTTCACCTTCATCCCCTCGTCGGAGTCGGAGTGGTCGAGCATCGTGCTGG +CGACGGCCAGTTCGAGCGACGGCGAGTAGCCGAAGTACAGTTCGCCGGTCGTGTTGAACG +TGCCCGGAGCGAACTTATGGAAATAGCACCTACCCCGGCCAAGGATTTGATCTTGCGGCA +TGGTGAAACTCCCGTGGTGGATGAAAAGTTACGGCCGATACGGCAAAAGGTCGTACGGGT +CCGTGGTGTTTTTCGCGATCTTCAGGTTCAACGGCAGGTAGAAGTACGAACGTCCCGAAT +CACCTTCTGCGGGCGTACGACACACGCCGGGGCCTGCGCGCATGCCAGCAATGAGGTTTT +CGAGCATGTAGTCGGACGGATATTGAGGGTTCCCCGACGAGCTGTCAAGGGCGATCAGTT +CGCCGAGGCGCACCTGCACGTCCGCCATAAGGCGATACGCTTCATCGGTCGGGTTCTTGT +CCCCTTCAGCATGGTTGACCCAGCCCTGCACCAGAAGCAGCCAGTCTTCCGATTGCGCCT +GCCCATTCTCGTCGGCATCGTGGCCGTGATCGGGTCGTTGCGCTTCGAGGATCAACACGG +CAGGGGCAGGCGTCTCCGCGCCGAACTGCACTCGGTTTCGATAGATGCCCGACGAAAGAT +CGAACTGAAAACCGATCGTCGGCGTGACGCCTTCCAGATGGGCGGTGAGCTTTTTCAGGA +TCACCAGTTTTTTAGGATCGCGCTGCATGCCTTACTCCGAAAGACGCGTGAAATGGCGCA +GGAATTCATCGGCTAGTGCGTCAAGCACTTCGGTTGTGATGTCGTCCGCGACAGTCCGGA +AGACCTGATCGACGGCCGGCCCGTATAGCAGGTAGACGTTGTTCGACAGCTTCGTCGCGC +CATCCGTCGCGTGAAGCGTTTCGCCGGGGCTGAGACGTACAGCAAGCCCGAGGTTGTACT +TGTCCTCGGTCAGGGTCTTGCCGGCTCGCAGACGCACCAGAAGGCCGCGCTTGAACTGCT +TGGTGCGTCCGGGCTTGACCACGACCGAGACGCCGCCCTTGCGCGTCGATTTAGTCGTCT +GTCCCGGTTCGGCGAACCGGGCGAGCGACGTAGGACGCTGGCGCGCGCCGATCACAGCTT +CGAGGTCGTTGCGCGTCGCCATCTTGATAACGCCAAGCCGGCTATCATCTTTCAGGTAGT +TGTCAGGGAAATTGGCTTGCTCGCCGCTCTCGGTGCGGGCGAGCGGAAGGGCCGCACGCT +GCGCGGTCTGATTGGTCGCGATCATCGCGGCTTGTTGCGGAATGTCGGGAAGGCGGTCCA +CGTAGTCCCGAAACTCCCCGAGTCCTTCAGCGACGATTTTGATGCTCATTCTGGTCCTCG +TCAGGGCCGGACGCGCTCAACCGACCACTTGATGTCTACGAAATTGTCCGTGTCGTCCTC +GACATCGAGGCGGAACGTGAAACCGTAATCCGGAAACGTCACCGAGCCGTCGCGCGGCAA +TGTGGTGCCGAGTGAAGTTACTTCCGGTTTGTTGAAGACCAGATAGTTGATGACCTCGAC +CATGCGTGCGAACCCTTCGCGGTCGAGATCACCGACGAGCCCCATCTTCGTGTGGAAGCG +AGCGGCCAGCGGCGTCTGCGCACCCGTGACGGGGTCAGCATAAAGCGCTGATACCGCCAG +AGTGTCATGGACAGTCTGACGGACCAGGGCTTTAAGGGCGGCGAAGTCGCCGACCATGGC +TTACAGGCCCGAGGCCGACGCTTTCGCGCGGGGCTTCGCCGGCCTCGACGCCCCGGCCTT +GTCGCCGTCTTCGCCTTCGTCGCCGGCCGGGGCGTCTTCGACCTCGAAAACGTGGCGTTG +CAGGAATTCCTTCCCGTGGCGCTCGTGCAGATGCTCGATCTCCTCGTCGGTGAAATCGAA +CGGCTTGCCCGGTGCGGCGTTAACGATCTTCCGGTCGCGGGTGGCGATGACGGTGTGCTT +CGGAACGCGCTTCGGCATGATATTGCTCCAGTTGATTCAGATGAGAAGCCAGCCCTGAAG +GGCCGGCCGATGACCTACGCTACGCGGGTCGCGTTGTGCTTACTTGACCGTCATGCGGAA +GGAAGCGTTCGGCTGGGCCGGGACCATAAGCGGCTCGCTCTGCGTCATGAGCATCGCCAC +GGACGGGTCTTCTCCCTCCCACATCTTCGGGAACATCCGGGTCAGCACGAGTCCGTACTT +GAACTCCATGATCGCGCCGAAGCACTGCGTGCCTTGGAGACCCGGACTCGTCCCGACCAC +GTCGTACGAGCCGAGGGTTTCCTGCTCGGTGTTGTCGTCGCCGGTATAGGTGTCGTGGTA +CGTGTAGAGTTCCAGCGTACCCATGCCGTTATAGCCGCCGATCGTCCCTTGATACTGAAG +CGGCCAACCGTCGTCCAGTCGCGAGCGGTTGAAGTCGGACGTGCTGCCCTTGTAGAACAG +GTTCAGCAGCTCGACCACGGCGGGTTCCTGCGAGAACAGCGACCAGGCGTCGAGGCCCAT +CGTCATTCGCGTGATCGTGCTGGTCGACTTCTTCCACACCGTCCTGCGCATCGTTTGGAT +GTTCCCCAGCGGATCGGACGTGGCCTGGTCCCACGCTGCGCCGCCCGTCAGTTGCACGGT +GAGCGCCGGATCGCGGCCGAAGGCCACGCGTTGCTTCGGGAACGCTTCGCCCACCACGTC +CACGTAGCCGTAGATCGTCGCCATTGCGCACATCCATTCGATCCGGTTCTCGATGCGCTG +GCGCTGTTCGAGCTGCGAATTCGCGACGACCGCTTGGAAGCGCTCCTGCAACGACATGCC +GCCGATAATCGGCTGCTCGCCGGCACGACGCCTGAGCCTACGGTTCGGGTTGATAACGTC +CTTCGGCTTCACATAGGCCGGACGGAACGTCTTCGTCGTGTATCCACGAGCAGCGATCAC +GCGGCCTTGCACGTTCGGCGCGACGAACGGGGCGAGCTTCTTGTCCGTGAAGACGAGGTC +GAACAGAATCTCGTCCGTGTCGAACGTGATCTCGTTCGGGTTGAAGCCCTGCCAGTACAT +CGACAGCGCCGGGCCGCACTAAATCACGCCAGCAAGGGTGACGGCATCGAAAATTTCCAT +CTTTGTTCTCCGAGTTGTACAGGGTTTTCTTGCTGGCGCTCGTTACGGCGACGAGTGTGC +GGTATCGACCAAACGATCGATGAACACCGGCGTGCCCGCGAAGGCTGTTTGGCGTTCTTC +GAACGTATCGGCGGCGACGCCCCACACCAGTACGGCATGGTTGAAAAAACCGCCGTCGAA +GACCGGGTGCGATATCGTAGCCGCGCCGGCCGCCTCCGGCTGCGCCGCAATGCCGTACCC +CTTCTGCGAGCCGTCCGAGGCGGCCGGGCTCCACGGCACGAGCATGCCGCCGACGAGCGC +GACGACACGGTACTTTTCGAGGACCGTGGCAGCAGCCACGTTCGCCCGCGTCGTCACGAT +ATCGGCATCGTCGGCATAGAGCTGTTCGGGGATGTACGACCCTTCGGTGCCGTTGCCGGC +GAGATCACGATCGATCATTTTCTTCTCCTAGCTAGGTTGGAGGATTGTTGCTGTATTCCG +GCCGGAATACCGATTACTTCTTCTGCTGGATCAGATCCTTGCGGCACGTCTCCTTGCCGA +GCGACGCGAGCAGCACGTTGCCGACCTTCTTGCCTTCAGCTTCGTTGCCCTTGCCGCCGG +CCGGGTCCGCGTCGACTTCTGGGTTGTTGCTGGAGTCCATCGCCTTGTGGAACGCCGTGG +CGTTCTTGCTCGTATCGGCCGGATCGGCAGTAACTTCCGGTGCGGCCGCAGCGAGCATCA +CCTTCGCGTCGTCAACGGACATCTCGGTGTTCAGTGCGATGTGGTTTGCCAGTTTCGGCT +TACCCTTCGCTTCTTCGCAGTTCAGGATGCCTGCTTGGCGCTCTCGGTCGGCCTTGACAG +CAGCGCGGCTTTCGGCGGCCAGTTGTTCTTCGGTCAGTTCCATCTTCGTACTCTCCATGT +GGACTTCGGTTTCGGATGTCGAGCCGGAAAGCTCGTTGAAAAACGCAGCGACTGCATCTA +CCAGAAAGTTCGCGATACGCAGGCTCAGACGTACCGGGCAGACGATGCGCTGAACCTCGG +GCTGATTGACGCGGTGGCAAAACCGGCTGTCCATCCCACGGTTGCGTGCAACCAGTGAGA +CGAATTCGTCGTACGAGGCGTTCACGTCGGCCTGAATACTGGCCTTCACTTCTTTGGTCA +ACGCCTCGTAGGGATTGTCGTCGACCTTGTGGTCACCGGCATGAATGAAAGTGATTTTGA +TGCCCCTGTTATCGAGCATCTCGGACATATCGACGTGCATCGCGACTACCCCGTTGCTGC +CCGCCCATCCCGAGGGCGTCGAGACCACCTTCGTTGCGGCGGAAGCGATGGCGTAGGCGG +GCGAGTAGCAGTTCGAGTCGATGACGGCCATGATGCGCTTTCCGTCCCGCGCTGCGTAGA +TGTCGTCGGCCAACTCGAAGCAACCCGCTGCTTCACCGCCGTGGGAATTGACATCGACGG +TAATGCCTTCGACATCATCATCCGCGAGAGCGGCGTTGTGTTGCGCCCGTACGGAGTTGT +ATCCCGTGACAGAGCCGAAGCTGTAGTTGAACCGGTTAATCATTGTTCCTTGGAGCGGGA +TGATAGCAAGCCCGTTGGAAAAAGCAAACGGTTTGTTGTCGGCCGCACTCTGAAAGCCAC +ACGCCAGTGCGAGTTGCGTGCGCTGGACCTTCAGGAAGTCGTCATGTTCGAGCGCGTTAT +CGGCCGCCGCGAGCTGCTTCATGTCCTGTACGAGGCCGGCGTGATGCGCGGAGACCATCT +GCCCGCGCAGGTTGAACCGAGTGATTGCGATGTCTGCGTCGCGTCGTACCATCTTTATTC +TCCTTGTTAACTGGTTTGCACAGCAGCAGGGTCTTCGGCAATGCCGGTTGCTGCGTCGCG +TCCGTCGCCGAGCGAGCGCTTCGCGCTCAGATTGAAAGTGAGACCGTACTTCTTCAGCAG +GGCGTCCTCGCGAGCGCGCTGCGCGAAGATCTTTCCGAAGTCTCCGCCGAGGCGCGCGAT +TTCGCGCTCATAGGTCGAGAGGCCGGCATCGATCCGCATCACGGCTGCCTCCGTTTCCTT +CAGTTGATCGGTCTGGCCTTGCGACGCGCCGATCCACTCGCATTTCGACAGCGGTTCGTT +CATCAGCGGCTGATAGGACAAGTTCCGCGTCTGGCTCGGCGGCATCGAGACTTCACCAGC +CGCGATAGCCTCTTCCAGCCACAGCGTGAAGAACTCGGTCGCGAGGTGATCGGCGCACAT +CTTCTTGCACCCTTCGAGGAAGCGCCGCGTCATCGCGATGCCGGCTTGGATGCTCGAATA +GTTCGCCATGCTAAAGTCCCGCGTGAACTCTTCGTAGCTCATCCCGACCGCCGACGCCAG +ATGCCGGTTGAGCGACGCCTCGAATTCGCTACCGACGCCGCCCGGCGTACCCATCGGCTT +CAGGTTCAGCTTCGTGCCGGGAAACAGATGCGGAATCTTCGCGCCGTCGATCTGGATGTT +GTTCGCACCGCCGACGTACGCCTTCAGCGCGTCCACGTACCTCCCGAAGATGCCAACCAT +GTCCGCATTCGGCGAACCGCCGGACATCTGCGAATGGATGAACTCGGGCGGTAGCTCGGA +CTCGATAGCGGCCGCGTACGACGCGTTGATGACGGCGTTTTGAAGCGACATTTCCTTGAA +ACGCTTCGCCATGCTCATGCCCATCAGGCCGGACACGATATCGGCAATGCCACGCGACTG +ATCCGGTTCGCGCAGTTCGAGGATGTGGATGACCTGACCACGGCCCCACGGGTTCGATAG +CTGTACGAACTTCCATTTGTACATGTCCGGGGCCATCTGGTACAGGTCGCCGGGGTGCGC +GACCTGAATCCAGTAGCCCTGCGGCCGGTCGCGCTTGTCGTACTGCACGCCGCGTCGAAG +CGTGGGCGTGTCGAGTTGCTGGTACGGGATCGACAGGCGGTCGGTCGATATCATCTGGAG +GCAGGTCGCGTACGGCCGGTTCGCCGCGCGGTCCCACTCGGCAGTCGCCAGCACTCCGCC +GGTTTTCACGTAGCCTACCACGCCAAGGCGGATCAGACCGGTGAAGGTCGAGATCGCAGC +ATTGTCGATGTAGCAGGCGAGGGATTCCGCGTACAGCTCGAACTTCGCTTCAACGATAGT +CTGGTATTGCTCGGCCCATTCCTCGGTCGCGCCGGGGAGGACGTTGATGTCCGGCATCGA +GTCGAGCCGGTACTGCGCGCCCACGATGCTGTCACGCTGATAGCCGACCGCGCCGTTCGT +GAAGCGGTCGCTGTCGCCCATGTCCCGGCCGCGCGCGTCGGCGATCCGCTTCAGCGGGTT +GATGAGGGCACCCGGCGAGCGAAGGCTGGGGTTCCACGACACGGTCTCTCGCGAGAGCCG +CGACGCGCCTTCAAGTCCGCCGCAGCCAAGCGAAGCCGACTGTTCCGGGCGACCGGAAGT +CACTTCGGACAGTTTGCGTACGGTAACTTTGGTCATTGTCAGAAGGTGAACTGAAGGGGG +CCATTGGAACAACCGCCGCCGCACGGGCCGCAGTCACCGCATTGCGCTCCGAGCTGGCGG +ATGTAGGTCGCGAGGGCCTGCTGACTAGCCGTCGTGAATTCTACGCGTTCGCCATTCTGG +TCCTCGATCATGCGGGCCAAGGGGCCGGTCAGCAGCTTGTGGTACGCGTCGCGGCGCCGC +CGCGAGGTACTGCCGGCAGGTTACATCATCGAGCCAGGGCATTCGGTTTCTCCGGTAGTG +GATCACGCCAGCGCGGCGGCGATTTTCGCGAGATCATACTCTTCGCTTGACTTTTCCGCA +AATCTCTTTTCGCTGGCATCCGCAACGAGGGTGTTCTTGTCCCACTCTTCGGCCCAGCTC +GGGGGCGACGACCAGTCGAACGTCACGGTTAGCAGGAGCATCGATCCGCTACCGGGCGTC +ACCACTTCAAGCCGGCCAAGCGCAGTGTCTTTCAAGAAGTTCGAGCTCGGGAACAGGACC +GGTACGTCTCCGCGCGCAGCAGACGATTTGGCCTTGTGGTTAGCGTCCGGGTAGCCGACT +CGCGTGCGCGGATGCCCCGGCTTAGGCTCGCCCTTGATGAGATGGAGACGGCCGTGCAGG +CCTTCTTCGCGAAGCTGCCGGTAGAAGTTGTACGCCATCCCCGCGACACCTTCCCGACAG +CCGGAATCGCAGAAGGTCATTTTGAGCTGCATCACCCGACCGCTGTCATCGTCAAGCTGA +TACATTTTCTCCACGAGCTGCGTACGCACTTCCTGCCTGTCTTCGAGATACGCATGCGGC +TTCACCCACTCTCGGTCTCCGTCGTGATCGACGCGCTGCGACTTGATGACGTTGAAACGG +TCCACGACATAGATGTCGTACGGATCGCCCGGCGCAACGCCGAACACGTTGCAGACCCAC +ATGTTCTTCTGCAGGTCGCAGATACCGATCAGGAAGCGGACAGCCTTCGGAACATGTTTA +TCGCGCAGGACTTCGGCGCGCGCCTTCAGCGTCTCCGCGTACCGGGTCGCAGGAATCGTT +GAAGAAGTTCTACAACACCGACCTCGGGGAACCGTATTTCCATCGCGGCAACGAAACGGT +CCTGCTCCCTCGTAGTCTTCTTCGTCCGTGATGTAGTTGGCGACGAGTTTGCGCCACGAG +ATAAACGCCGCCACGACGCCATTCATCCAGACAGACGCAATGCGCGAGCGTCGCGGCGTG +CCGACCCGCTTGTCCTCCGCCGTCATCGACTCGCCGTCCTTCAGCCAGACGCCCCACAGG +CCGAGATCGTTGCGCTGATCCGCTTAGATCCGGCCGCCGCAGCACGGCGCTTCCATGCGC +ACAGTATCGGCTCACGATACGGCGTCGCCGCAGTCATCCCACTTCAACAGCTTGAAAGTC +GGTTCGAACCAGTCGCCGCAGTGCGGGCACTTCCAGTATCGACGGCGACGGTCACCCCGG +TTGTACAGGCCGAGAATCCCCTTCCATGGGGGCGCTTCGTGCGGCGATGAAGCCAGCCAC +TTTCGGCCGTCTTCTTCGATCTGACGGGACGGGCTGGACTCGGCCAGCGTCATCGCGAAC +GAACCGAACGTCGTGGTCCGCTTCGACGCGAGGTCGAACGGCTCGCCGTCGCCATCAACG +TCGTCCGGCATGCGGTCGTAGTCGGTCAGGCATACGCGGCCGATCGGACGGCCAGCGAAC +TCGGTCACCGACGGCCACGACAGTGTCAAGATCGCGCCGTCCTTGTAGTGCTGGTCGAAC +TTGTTGTCGGTGTAGCGCGAGCGCGTCATCATCGCGCCGATCTTAGGAGAATGACGGTGC +GTACGATCGACCGGTCGCACGGAGAAATCGCGGGCTGCTTAGTTCGTCGGGCAGTACAGG +AACATGTCCATCGGGTCGACATTGACCGTGTACCCGATGAAGTTCAGTAACAGGCGATCA +GTTTTCCCGAACTGCGCCGGGCCGACGAAGACTTCCGCGTCGAAGTCACGGCACGTGAGC +GTGTTCATTGGTTCGACCATGTACGGCACGGTCTCGTTGAACCAATCGCCCATGTACGCG +CCCGGCGTGTTCAGCTTTCGGTACTTGGCGGCGGCCTGCGATACGGTCAGTCGTTCCGGC +GGACGGAAGATGTCGGCGAGGTCGATGAGTACGAGGACTTCAAGATCGCGACAGCGCGGG +AAGCGTTTTTGAAGGAACTGACGACGACCCAGCAGCAGGTCTATAAGTCGCTCGGGGCGA +TGGTCCGTCCCCGCCGTCGCCACTTCATCGGCTGTCACCCGTTGATTCGATTCGTTCGGC +TACATGGTCTCGTTCCGGTTCGTGTTTAAATTGTTCGATAAGAGAGTTGCGCAAGCTCTT +CGACAGTGAGTCGGTCTTCTTGCGAATGATGGCGCGCTGCTCGTCACTCAGTTCGGCTTG +GCGGTCCACCGAGTCGACCATGAGAAGAATCTCAGTTCGCAGCGTCTTAAACGACTCGGC +GTAGTGTTGAAGTACCTTCTCGGTTCGCCAGAGATCGCCCTGTTCTTCCTCGAATTTCAG +GCGCGCATTCTGCCCGCTCCAAAATTCCTTCAGCAACATCGGCGGCAGGTCTCGATGGTG +CATCTTCTTGATGTGTGCCTCGATGTCGCCAACCGGATCAACGAGGTATCGGGCCGCCTC +GGCCACTTTGTAGATCGGGTGTCCGTGGCGCTTCCCGCACGCGGGCAGCCCTTGAATCCG +TTTCGTCACGGTGCGGTTGTCCATGGTGAACAACTGCCCGAGTTGTGAGATAGACGCGCC +ATCGAACAGGATTGCCTTCGATGCGCTATCCGCTCCACTCTTTCCTTCTGCCTTGCCGTC +CTCCGTTTTTGTCAGGGTTGAACATTATCACAAGCCCGCAGCCGTGGCAAGGTTGTCACT +GTTCACGGCTCGCTTCTTCTTGAACGCTGCTCGCAGACGGCGAAGACGCACGAAGAGATC +GTCCTGCGCGTTGTGTTTGCGAGTCAGGCTCGATACCGCAACGTCGTCTACCGTGCCAAT +CATCGTCGCATGGTGGACGTGCGCGATATGGCGCTGGCCCTGCCGGGCGAGACGACCGAT +GAGCTGAAGATATAGTTCGAGCCAGTAGACGATGTCGTAGATATAAAGGTGATGGCCTCC +CTTCTGCATGTTCAAGCCGTGTGCCACGGACGCCGGATGAACGAACGAGATTTGGATCTC +GCCTTTGTTCCAGTCGCCGACAAGTTTCCGCTCGGCGTCCATTACGCGCGCTCTCGGGAA +CGCCTTCTTCAGTCGTTCGAGGCTGGATTTGAACCAGTACGCTACGAGCAGCGGCTCGCC +GTTCAGCTCTTCGACAAGTTGCGTCAGGTCTTCGATCTTGTGATCGTGTACCCAATGCGT +CTTTTTCTCCGCGTCGTACACACATCCGGACGCGAGCTGAAGTAACTTCTGATTCAGCGC +GACTGCGGTTTCTTCTTCGATCTCGGTTCCGTCAGGAAGGTCGAGGATTAAATCCCGCTC +GAGCTTCTTGTACATAGACGACTGTTCATCGGTCATCTTGATGGCGCGCTTCAACAGGAG +TGGCTTATCGACCTTCAGGTAGTCCTCTGCCTTCATCACTAGGCAGATGTCAGCGATCTT +CGACAGGTTTTCGTTCTCGCATCCCGGCCGCAGCTTGTACGTTCGCGCGTAATGGTTATA +TGTGAAGTACCGGTTGCGGTAGTACGTGATGTTGTTGCCGCGACGTTCTCCCTTGTCGAG +AAGTCACATCTGCGCGAACAGGTGTTCATAGGTCTCGGCAACCGGCGTCGCGGTGAGAAG +ATGCAAGCGCATGATATACGGGCGAACGGCCTTCAGCTGCTTGAAACGGATCGAATTGTG +ATCCTTGGACGACGACGATTCATCGGTAAACACGACATCGAAAGGCCACATTTCCCCAAA +CAGGTCGATGAGCCATTGAAGCTGTTCCCGGTTGATGATGTGAAGGCTCGCTGGGGTGCG +CGCGAGGCGCTGAAGGATCTTTTCCTTCCTCACGGCTTTCGCTCGAGCCACGTCTCGTTC +AAGCTCGGGATTCCGTTGCTCGCGGCTGTCGTCGCCTCGTGTTGTGAAGGCCCGATAGTC +GGAGCGAGCGCGTTGTTTCCTACCTGCCTCAGCGATCAGTTCAACTGACTTCTCGTCTTC +CGCGCGGATCGGGACATGGGACATGTACGCCGTGTGCTGTCAGAGCGGAATCTCGTTCGG +CCATGCCTCCGTAGCTACACGCAGCGGCGCGATCACGTGACAGTGCTTGTATGCGACGCG +CGAGTGTAGCCGATCGGGCAGCGTGAGGCAGATGACCGTCTTCCCCATGCCAAGGTGGAT +GAACAGTGCGCTGAACGGATTCTCTTCGAGAAAGTCCACGCATTTGTCCTGATACGCATG +CAGCTCGATCGGCTCGTACGGCACTCCGTGGAACATCTCAGAGATGGTACGACGCAAGGA +TTCGGGTTGCATCTTCATGATTGTCAGCCCAATGAAGGTACGCGCCGTGTCGACGCATCT +CGTCGTGCTTGTTGTACTGGTGTCGCTTCGGGTCTGCATCCTTCCGCTTGAACTCGGTGA +AAACGACGATGCCCGACCGGATATACATTCGATCGGGTACACCACGCTGACCGGGAGGGA +CAAACTTCGCAACAAATCATCCGTTTGCCTTCGCCCAATCGTTCGTTTGGTCTTCTATGC +GCGTCTCCCGTACGGGAGGATCGGAAGTTACTTCCGATTTTTTTGGGATCGGGAGTAACT +TCAGGTCAGTCCTTGCGATAGAACGCGGCCGACCATCCGGCTGCGCCAACAGGCATCTTT +TCGTACCACTTGCGCTTCGCGGTCATGCACTCCTTCAGGACATGCAGCCCCTTCGACGCG +TCGCCGATCCTGCGCAGGGTGACGATTTCATCGTGAACGCGCCACATCTTCGGTATTGCA +GGCGAACGCAGCGCCGACGAGCACAATCGAGATCGTCGCGCGGCAGAACATGCCATATCC +GCCGGGCAAAGAACGATATTGATGGCCTTCTTATGCGCGTTGAATAGGCCGTACTTCAGG +ATTTCCCGTGCGATAGCTTGCACGAGGTTTGCGGTCATCTTACCGCCGTGCGAGTCCTGT +CGCAGCCACTTCTTGACGTCCTGATTGAAGCTCATGTACGAGAAACGGATCTTCTCGTAC +GTCTGCGGAGAGCCGTCTTCGTTCCAGAGTAACTCGCCTGTCTTCCAGTTCTTCTTCTGG +AATTTTTTCTTCTCGATGCGCGGTCGATGGTAGGACATCCGGCGACCGCTCGGCAGGATC +GCCACGAGGAATTCACCGACGATTGCAAACGACACATAACGGACGCACGTGACCGCCTTC +GTCTTGATAGTGCGGATGATAGCGGCTTCGAGGTCCTTCCAGAGCTGCGGGACCTCGGGG +TACGCCTCGCGGTACATCTTCACCGAATCGTGCGCCTCTTGGCCGGACATGTCGATACCC +ATGTTCTCGGCGTAGCCCGACAGACCGGTTCGCTGGCCCTCATGGCTTAGGTCGCCGCCG +CCGAGTCGGTATCCCGCGCCGAGCACGGCCGGTTTCGACATCTTTCGCATCTGCGAAGTT +ACTTCCGGGTACTCGACGCCGTACAGCCGCGTCACGAATACTCGGTACGCGCAGCGCCCT +TCACGGAACACGTTCAGCAGCGGCTGGCAATCCGCCAGCCATGCGATCACGACGGTTTCA +ATCGAGGACAGGTCGCATGTGACGAACTCATACCCCTCCGGAGCGTAGATCACGCAGCGC +AGGCATCCGGCGAGACCGTCCACGGGTTCCTTCATCATCAGGCCGAGCAGGGCGTAATCC +CCCGCTCGGATGGCGTTCGTGACCGTGCAGAGCGCTCAGTCGTTGTCGCCGTCCGGTTCG +AGCGCTTTCGGCGTACGGCCGAGGTTGTGAACCTGAACACCGCGTCCCGCCCAGTGCTGC +GTGCGCTGCGCGCCTCCGAACTGAAGGCGAAAACGGAGGCGCCGACCGGGGCCGACGAGG +GAGACGAACTTCTTGTACTTGCCGACCGACGTGCGTGCAGACTGCATACGCATCTTCAGC +ACTTCGTCCCATCGCCCCGTCATCACCGGTTCGTCGTTGTGTTCGGAGAGGACCTTCTTG +ACGGTATCCTTGCCGAGGTCATCGAAACGATACCCGCGTGCCTTCACCCACGGTTTGAGC +TGCTGCGGACTGCTCGGGTTTTCAAGGCCGGTGATCGCGCGCATCTGGCTAACGAGTTCC +AGCTTGCGGCGATCTGCCATCGCGGTAGCGCTGTTACAGAAGTTGAGGTCGACCGGCACA +CCGCGATCGTAGATGAGCTGATCCAGCTCGTACAGCTCCCATTCTTCATCGAGCGTCGGA +TACGGAGCGAGCCATTCGTCAATGGCGGCTTCGGCGATCACGTCCTGTTGGTTATAGATC +AGGAAGTCGTCCCATTCGAACAGGTTAGTCTGCCAGTCGAGCCACTTGTGGGGGTTCTTC +TTCGTGATGCGTTGCGGGTACGAGAACTGGTTGATTAGCTTCTTCCCGGTCGCCAGTTTG +ACCTTGTCCTGCGGTAATCCGAGCTGCCCGCCGACCATTTCGAGGTTTCCAGCGAACGAC +AGCATGTACGCACGCGCCATCGTGCAGCACCAGTTTTTATACGGCGTGTTGATCTTCAGC +ACACGACGCGTCATCACGCGCTCGAACTGCGCATTCCACGCCCGCTCGATGACGTTCGGG +TCTTCGAGCGCCTCGCGGACTTCCGCCGGGAACTTTCCGTCTCGGATTTCCCATTGCTGC +ACGCGGCCGCCGTTGAACGACCAAGAAGCAATCAGGATTTCAGTGGACTCGTTCGCCGAG +TAAGTGTCGAGGCCGCACATCGGCAGGTCCTCTTCGCTGCGCGATTCGTAGTCCAGTCGA +ATCTCGTCTTGCATATCAGTTCTCCGGATTCGCGAGGTCGAGCAGCACATCGCCGTGGCA +CGCTTCAGGTGCGCAGAAGCAGACGAGATGCCGACCACGGATTGTAGGCAAGAACGACAT +CAGCGAAGGGGAGTTGAGGACGTGCTCTCGGTACTTCGCAATAACCTCTTCGCGCGTTCC +GTCTCGGCCGATCACAAACCGGTAGCCCCACACCGGAGGGCGGCCGATGTAAATGCGGTT +GTCCGGATAGTCGCCTGCGTTCTTGTTGAATACCTGCGGCAATTCAGCACCTCAGAAGAA +AAAGACCCCGGCACGTCGGGGAATAACCGTGCCGGGGCGAACAACCTACGCGGAGGAATC +GGAACCGCGCAGACAGGCGAAAGGAATTACAGGCCGCCGTTGTCGTCGTAGCCCTCGGCG +AGCGCTTCCTCGCCGTCCGACACGTCGTCAAACGAATCGTCAATTTCGTCTTCGCTGACG +CGGCCTTCGCCGATCTGCTCGTCGTCACGAACGAACTGGACCGCAAGCAGGTTCGCGTTG +ATACGCTTGCCGAACTTGTTGTCCTGCCACCACGGGGTGATGAGAATGTTCACGCGGCAA +CCGGCGTAGATGGTGTTTTCGATCTCGCGCTCGCCGAGAAGACGCTTGTCCGCGCCGCGC +AGGCTCGGACGCTTCGTTTCCGATGCATTGATCGTGTAGCAGCCTTCGTATTCGTCCTTG +CCCGACGCGTCGCCGTCGCGGAAGAAAAACTTGTCGGTCGGAATCTTCTTGCCGTCGTTC +TTCTCGCGCAGCATCTCGTCGCGCATTTTCTTCATCACTTCGAGAACGGACTTAGCGAGG +TCCTTTTCGATGAAGCCGACGAGCGAATACTTCTCCTGCCCTTCCTGATCGTCGCCCTTG +TAGGGCTTCGCCAGATGGGGGTAGCACGCCCGCACATTCTCGATACGCAAGGTGCCGTCC +GTGAAGACGACAACGTTCTTGCCTTTGAACTTGATTTCGCGTGCGATTTTGCGACTCCTT +CAGGTCTACCGTTTTACCGGTCTAGGGTTTCACGGTCTACAGGTCTACGGGTCTACAGGC +CGTCGTCCGCAGTAAGGTCGTCAAAGCAGTCAGCGGCCACTTGCCCCAGCTTCTCCCGCG +TCTCTGCGACAGGAGCCAAGGTCGCCTTGCCCTGCGCTTTCGCGACGCGCGGGGCGATAA +TTTTCTCGGCCGCTTTCTTTCGCATGCCACTCGCGACGAGCGGTGCTTCTGCTTTCGCGG +GGCTGACGAAATCGGTCGAGAATAATGCGTTTTCCTTCACGCCAAGGAATGTGAGCGTTT +AAACGGTTTTCGCCTGTTGCACGTTCCATCGGCGATTCGATCTGGATGCTACCAGTTTCA +TGCCGGGGATGTCCTCCCCGTTGTGCACGCGTCGCTCCAACTCGGAGTCCTTTTCGCTGA +ACCAGCGCTCGACTACCTTCCGGTACGGAAGTAACTTCGCCATTTGTTGAGTCGAAAGGT +CGGAAACCGGACGTAACTTCGTGCTCAATTCGTCGCGCATCAGGACTCCCTCACTGCTCG +GCATCAGTTCAGCGGTTACTTCGGCTGTCAGGTCGTCAAAACAGTCGTCAGAAAACCTGT +GCGCCATCGCGAGAAGCGCCGGATAGGTCTTCTGCACCTTGCAAAAACGGCATCCTTTGT +CGGACGGCGTGAGCGGCACACCTTTCTGCCAAGCGAGAAATGCCCGGACCTTCTCGAAAT +CGGTGAAGCGAAGCAGCTCTTCCCGTGTGGTTTCCCACATCTGGAAGTGTGCTAGGCGCG +GCTGCGAGATGTAGATGACGTTCTTACGGAATCCGTAAATCCAGTCGTACTCGTAGTGCG +CGCCGGGCGCATAGAGCATGGCTTGAGAATTGCCGTTGATAATCGTCTTGCCGTTCTCAA +CGATGATCGGACGCGGATCGTCCAGTCGCAACGCCGCGAAGACCTGAACACCACGGCCGA +ACTTGTGGTCGAAGATGTGCAGCACACCGGGTTCGAAGCCGCCCACGTCCATCGTGCCTC +CTTGGCGCGGAATCGGGGTGAGCTGGGAGAAGTAGACGCGCTTCTCGATATGCAGGTCGC +CGGAAAGCGACTGCGCCCATTCGACAGACTGCGCGACGTACTCCATCATCTCCGCGTCGA +TCGTGATATCGAAAACGGTCTTCCCTTCGGCGACCTGCTCAACCGTGCCGAGCAGATGAA +CGGGGCGTATGCCGGTCTTCAACCACGTCTCGGATACGCCGTGCGCGACAGTGCCTTATG +CGGCGTCTTCGCCTGCGTTGTCTTCTGCTGCGAGATTGGCGAGAAGGGACCCGGCGCATG +TGAGCCACATGGCAGACGCACTCGGGGAAAATACCGAGTGGCCGCCTTGCTCGCTGTTGA +ACTTCAGCGCATCGAGATTGATCGCGTGTTCGCTAACGTAGAGGCCCCGGAAAAGTTGTT +CATTTTGAGCGGCACTGACATTGTGTGGTGCACCGTAGAGGCCGGGAACGTTTGGCGGTG +CACCCGCCAGTGCCGCCCAAAATGAAGCCCGGACGAACCGGGCTTCTTCGCTGCACGTCG +AGACGATATTACAGGCCGTCGCTGCCGTCGCCTTCGTCGCCGCCCGCGTCTCCTTCGAGC +GACTTCTCGGCCGCGTCGTACGCGGCGTCGAAGTGTTCCGGCTTGATCGAGGCCGAGGTC +TTCGGCCTTGCCGTACTTCTTGATGATCGCATTCGCGTCGTCCATCGACTTTTCGTCCTT +GACGCGGATCAGGATCCCCTTGACCTCGTCGGCCGAGTGCTTCGGCTTCGTTGCTGCCTT +GCCGCCGCCCTTGCCGGCCGCCGTGGTCGTTGCCTTCTTGCCTTCGGCCGCCTTGCCGCC +GCCCGTACCGCCTACTTCCGCGATTGCCTCCGTGACTGCCGACTTGATGAATCCCTTCAG +GGCGTTTTCCAAGCTCATTTTTCCGACTCCTAGTGATCCGTAGATGGGTTGTTTGTGTCG +TGGCGTTCACCACGGAACGAATCATGCCGGGGCCGGTTTTGTCTGTCAACACCTCTTCGA +AAATATTTCAAAGACAAATGGGAATCTGGCATACTCCGCGCTGTATTAACCTTCATCTAC +CTACATAGGTGGACTAGAAACATGGTGATCCCTATGCCGGCATGGTTCCCGACCGCAGGA +GAGTAACGAGATGGCCGACCAGACCACGGCCACCTATGTTGCGGATCACGGGGATGTACT +GATCGCGTACGGGTACAACATTGTCTCCATCACACCCGGCGAAAAATTCTCACCACACGA +CGGCTGGCAGCAGACAGTGGCAACGCAGGCCAAGTTGAAGACGTGGCTCGCCACGGGTTT +GAAGTACACGAAGAACGGCGAAGATCGGGTCGCCGATGTTAAGTTGGCCGGCGTCGGCTT +CCTGACGAAGAACACGCCGGGCGTCGATATCGACATCTCGGACGAAGGCTTCGCGAAGCA +CCTGGAGAATTTCGTCCATGAGAACTTCGGGATGGTTCCTGTACGCGTCGGCCGCGCGCC +GCGCCCGCTACTGCTCATTCGATGCACCGAGCCGTTTTCGAAGGTCAATTCGAGCGTCTA +TCTGGACGCGTGGGGCGAAGCGCAGAAGGTCGAAATCCTCGCGAACGGCCAGCAGTTCGT +CGCGTTCCACATCCATCCGGACACGAAGAGGCCGTACGAGTGGCTCTACAAGCAGTCGCC +GCTCGACATCGAAGCATCCGAGTTGCCGGTGTTGCGCCGCGTCGATGCGCAGGCCATCGT +GGACGAGATCGAGAAGTAGGCCAAGCTTCGAGGCTGGACGCTGAAGAAGCGCTCGCGCAC +CGCGCCGGAACGCAGCGAGAGCGGCGGGGAAATCGATTACGACGACCCGTTCGGCACCGA +CGTGGCGAAGACCGATATCGGCGAAGACGAGCTGCACGCCAAACTCATGCTCGTGCCGGA +CGCCGATGATTACGAGACGTGGGTCAACGTCTGCATGGCGCTGTTTCACCAGTACGACGG +CCACGAGCGCGGCCTCGAACTCTGGCACGAGTGGTCGGAGACGGCCGACAACTACGACGC +GAAGGAGCTGGACGCGAAGTGGAAGTCATTCGCCATCAGCAACAAGTCGTGTACGCCAAT +TACCGCCCGGTACATCATCAAGCTGGCGAAGCAAGCCGCCGAAAAAACCGCCGAAGAAAC +GATGGTCGCGCTGCAAAAGCTGCTGCTCGAAGCCACGTCGATGAACATGCTGAACTCGGC +ATGCAAGGCGATCAAGAAGGGGACGCTCGACAAGCCGTCGCGTGAGCTGATGGTCACATT +CTTACGGCATGCGTACAAGTGAATCAACGACGGCTCGCCCCGTCCGCTCAACGCTGCTCG +GCAGATGATTCGGTTCGCGAACCCGGAATCGAAGCACATGCCGAAATGGTTGATGGGCTG +GACGTATCTCACGCTCGATGACAAGTTCTACAACGTAAACACGCAGGAGTACATGACGCG +AAGCGCCTTTAATTCGGCGTTCGAACGTTTCCTGCTCACGCCACAGGACGTGTTGGAAGG +CCGCGTCGTCCCGGACACGACCGCCGAGAAGCTGGCGCTCAACCGTCATCAGATTCCGGT +ATGCCGCACGCGGCTATACCTGCCCGAACAGGACAAGACGTTCATCCTCAACGGAGCGCG +CTACGCGAAACTTTACACGGACAAGTCGGTCCCGGAGTGTCCGTCAAAGCTGACGAGCGA +AGCCAAGCTGAACGTGAAGCGCATCCTCGATCACTTCAACATGATGGTCCCCGCTGACCG +CGAGCGCGGCATCTTCCTCGACTGGCTGGCATGGATTATCCAGACGCAGAAGCGGCCGAA +TTGGTCGATCGTGTTGCAGGGTACGGTGTCGGACGGCAAGACGTTCTTCAGCGACATGAT +GGGCGTCATCCTTGGTCCGGAGAATGTCAAGACACTGAACGCCGAGAAGCTCGAAGGGGC +GTTCAACGGCTGGGCTGAAGCATCGCTCCTGAACTGCGTCGAGGAAATCAAGCTGCACGG +CCACGATCGCTTCGACGTGGTCAACCAAATCAAGCCGCTCATCACGAACACGGCCATTGA +AATCCACCGCAAGGGGGTAGACCCGTACAACACGATAAACACCGCCGCATACCTGCTGCT +GACGAACTTCAAAGACGCGCTGCCGCTCGGGAGGAACGACACGCGCTACTTCGTCATGTT +CGGCCGCATGCAAAACCGCGAAGATGTCGAGAAGTTCAAGGATGAGAACCCGCACTACAA +CGGCAACCTGTTTCAAGCTCTCAACGAGTCCGCCGGGGCACTGTGGAAATTTTTACTTGA +ACACGAGGTGAGTGACACCTTCGACCCGATGAACCGTGAGCCGGATTCCACGGCACGCCG +CTATTTGATCGCCATGAACCGCTCAAACGATCTGGAAGCCATCGAGACACTGATCTCAGA +ATCGATGGAGATCGACGTTTCCTCGACGCTCCTGAACGCCACCAAGCTGGCGGACCTGAT +GGTTGGCATGGATTGCGAACTCCCGGAAACGAAGGGCTTGCAACGCGTCCTAAGCGACCC +CGGATTTACCTTCCTCGGACGCATTCGAATCAAGGGGGAGTACTCCCGATACTGGTCCAA +ATCGCCCCAATACCTCATGGTGGACGGGTCGTCCGAGATCGATTTCGACGCTGTTCGGCA +GTACGCCGGGTGCAGTTTGTAGCCGAGGTCCAGATCCGAATCATTTTTGACTTATTCAGA +CCTTGGCCGGTTTCAGCCCCTTCGGGGGCTTTTTTGCGACGGTTGACCTTAGCAGAAACG +GGGTTCTAATGGTCGTGGTCCGAATCGAAGGTCCGAATGTTTTTGGCGTCATTCGGACCG +CGTTTTTTACCGCATTATGAAAAATGACCCTGCTCCGTCTTGTCCTATAAGACTTCCCTT +CCTTCTCTTCTTCTACTATTCTATAGATAAGGTCCAAATAAAGAAGAAAGTAGAATGACC +GTATAGACATAAATCCAAAAAAATTTTCGTACAGAAATAGAATAAAGAAAATGATTCGGT +TCGCCCCTTCGGACCTGCACTTGGCCGGCCATTCTCGTCCTCCCGACCACTCAAGGTCCG +CATGAGTGTTTGTCCGAAGTTACTTCCGATTTCGAGTTGCGCAACGCAGATATCCCGAAC +GAGATCGGAACCGAATCGCGGGATAGGGGATTTGGACCTTGGCGGGGCGGAGGGGAAACC +CGGTGTCGCGCAAATCTTTTCGCGAGAACTTCGGGGAAGGGCAGCGGCGCTATGACGGAA +AAACGAAAAAACGGGAAATCGGGGCTCTGCGCCCT +>NC_005091.alt2 length=63696 tani=96.707 alt=sn;du;tl +GCTCTGCGCCCTCCCGCCATTCGCGCCTCGCCGGATGGGACCCCGTCGGCCGCCCCGAGC +GATCCCCATCGGGCCTGCGCGCCAGCCAGTGACACGGAGACACGATCAGACGAATCGTCT +AGTGACGCGGCGACACCAACACGCAGCAGCCCGCCGCGTAGCCTGTATGACCGAGATACA +GGCATGCCGTCATGCGTGCGCACGGCCGGCCAATGCGGCACTGCACGAGCGACACGGAGA +TACGGCCATGCGTTGCGGTCACGCCACACGCGGCAGGCCGTGAAACGGGCAATCGGGGAC +TCGGACCTAGCTGTGAGACGCGCTGCGCCGTACGGCCGATGACATGCGGCCTAACTGGAT +CGTGTGGATTCGGACCCATGATCACGAGTCGCACGCTATGTGATTGGCCGGGTCTTGCTG +GGTGGGATTTCCGTTACGCTTGTGCGTGCGATGGTTTGAGGCGGGGCAGGTTTGGGGCTT +GGCGGGCGCGCTAAATGTCCCGTTGCGTACCTGGGCTAAAAGCGGACATTCTGACGTGCG +GTGCTGCGGGCGCGCTGCTGCGCACCGTGTGCGGGCGGGGCGATGGGCGTAAAAAGGGGC +TTGGCGGGCGCGCTAAATGTCCCGTTGCGTACCTGGGCTAAAAGCGGACATTCTGACGTG +CGGTGCTGCGGGCGCGCTGCTGCGCACCGTGTGCGGGCGGGGCGATGGGCGTAAAAAAGC +CCGACACGATGGCCGGGCGAGGGGTGCTACTGGATGGTGTGGGTTAGCCGTCCCGTGTGT +GACGCCCGCCTTTTAGGACGATTTGATACCAGTACCCACCGGTGCGGAGGACGTGCGGCT +TGTCCCCCGTCAGCACGCGATGGGCTGCCTTAGCAATCCACCATTTCGGGTCGTGCAGCT +ACTCGAGGCGCAGTTCGGCGGGCGTTCGCCGTACGTCGAACGCGTCAATAGCGCTCGTGC +CGTCCGCATCATCGGGGTCGTCAACCGCTATCACGTTTTTCACCATCCTGCCGGGACTCG +CGCTGAACACGCGCGGCACTCTTAGCTATCTCGATCCGAGCATGCCTGCATCCTTAGACG +TTGAACACGTAGCGCACGAGCGCGACGAGCAGGCCAATTGCGAACACCACGAGCAGCAGG +CATAACGCGCCAGCCACGGAACCGACAATGTAGACGGCCGCGTCGGGGGCGTCTTCGTAC +CGCCTGCGCGGTTTGAACCGCAGGATCTCCGGGACGATCAACGCACCGATGACGAGCGAT +GCCAATCCGATCGATGCTGCCGTGTGATTCGATATTCCGCCGTCATCGGGTATCGGGTAG +AGCCGGTCGACGCATTGCACGTAGCTCTGCATGCGGGGCACGTCGGCCGTGCGTGAGTCG +TACGAGTCAATCACGGCTTGGCATGCAGCACACTCAGCTCGATCGGCTTCTGCCGATGTG +ATCGCCGCGTTCGTGGCGGCTTGCCCGTTGAGCGCGGCACTCAGGGCAACGGTATCAGTT +GGCATTGTCGGCCCCTGCGGTGCGTGTGCCGATATGCAGGCCGACGGTCGCGCGGTTCCG +CGTATTGCGGATGAGTGGAACCTGTTCGACGGTCAGGCCGGCACGCGTTGCGCTCGATTC +GTCGGCTGTCACACTGGCCGTGAGACCGAATTCGTTGAGCTGAACTAGTGCCGCGCCGTA +TGGCGACGATTCGTATTCTTCCAGCTCGCGCAACCAGTCGAACGAACACGATTCGTCGTT +CCAAACTTGCGCGCCGACTACAGGGGTGCACTGAAATCGGCCGCCCTTCATCATCACGCG +GCCGAATTTGGTCGGGATATCGGACGGATGCACCTTGCGCATGTCGCGACGCCAGATAGA +GCCAATCTGACGTACGGGCAGGTCCATTTTCGCGACCGGCATTGCGGCGATCATCTCAGC +CATCGTCGGCTCGCGGCCGATCACCCGGCAAGTGATATCGCCATTCACGAGGGTCGATTT +TCCCGTCTTGCTTTCGAACGCGCGGGCCGCCAAGCGTCGCGCGATGCTGTCAAGATCGTA +CTATACAGCGACCGTGAAAACTTCGCCGTTCGCACGGTGCGAGTAGCTCTTCGTAATTGT +GTACTTCGCCACTGTCTTTCTCCTTCGTGTTGCGTTATGCCAAACGGCCGTAATTGCGTT +CGTGAGATTCGACGTAATCGCCAACCGTCGTAAGGCGGATGTTGCCGGTTCGGTAGTCGC +GCAACAGCGTCGCGTTATAGACGTCGCCTGTGTTGACCTACGCGGCGGCCGGTTCGTCGT +TCCGCTCGTGCCGCAGATATTCGACGCCGTGAACCTTGATGAGGCGATTGAGCGTCGCCA +TGCTTGTCCCGCTCCGGATAGCCGCGCGCACCACGGCCGCGCGCTTGATATCGAGCCGCA +GTTCGCGGGCCAGCTTGGCAACGCTCGGCGCGCGTTGCACTGGTGCATTGTTGGTCGTCA +TGGTTACTTCCCTTCGTACATAATCGTTCGCGGGCCAGCTTGGCAACGCTCGGCGCGCGT +TGCACTGGTGCATTGTTGGTCGTCATGGTTACTTCCCTTCGTACATAATCCGGGCAGTGT +GAAATGAAATCGCCCATGCTTCGCGCGCGCTATAGCCACACGCTCGATGAATGTGATACC +CGCCGTTTGTCGCGTCAGCGACCGCAAGCGCGGTGCGCACGGACAAATCGTCAAGCGACC +GATGGTCGTGCATGGAGGCGGTAAGGCTGGCATTAATCGACCAATCTACGCCGTTCAGAT +AGAACGAACGCCAGCGCGCCGCTCCGACCGACGCCTCGCGGAAACGGTAAACCGGCAAAA +CTGCACCGTGCCGGGCAGCGACATACATAGTGGCTTCCCCCAGCGACGCGCGGCGATTGA +CGGCCGTTCCATCAATGACAATCGCCCACGGGCGCGATGGCGACGATTTAGGGTCGTACG +TGAGTCGAGCCGTACCGGCCCAGCTACGAAAGGTTTGTTGATCGCGCCACACGGTTAGCC +CCCCTTCCGAACAGCCGCATAGAAAGCCGGCGTTACGCGGTCGATAAAGACGCGTGAACT +GGCGCAGGAATTCATCGGCCAGTGCGTCAAGCACTTCAGTTGTGATGTCGTCCGCGACAG +TCCGGAAGACCTGATCGACGGACGGCCCGTATAGCAGGTAGACGTTGTTCGACAGCTTCG +TCGCGCCATCCGTCGCGTGCAGCGTTTCGCCGGGGCTGAGACGTACAGCAAGCCCGAGGA +CCGTAGAGTTCGCGGAACGCCTTGCGCGGGTTCGTGATTTACGCCCGGTCTTCGGGCAGA +TACATCGCGAGTTCGTCTACGGCAGCTTGAATCGCGACTGCACGCGCAGCGTCGACAGCA +CCGGTCGTCGCTTCCGCCCACTTGGCGATGCCGCGCGGATCGCATGCAGGGGCCAGGTCT +ATCGGATCGCGAGCCGTAGAACCGCGCCCGCGCAGTATCTGCTACGCGGCCATGCGCATT +GTGTCGTGCGTCGCGTGACGGGCGCGCAGAAGCGCTGCACGGGCGTGATTCGGCATGATA +TGCGGAATGCAGCGGCTTTCCAGTTGGCGGCCATTCGGGCGAGCGATCATCACGTCATAC +GCGCTCGTATCGTAACGCAGCTTTTCCGTCATCGGAACACAAACCATCGTCGTGCCAAGC +TTCAGCACTTCGCGCGAGTCGCGCAGCATCGCATGCGCGATCTTCCCGGCGTCCGGGCGT +GCGGCTTGCGGGCGATTGTGTACGGCCATGGCGACGATGATTTGCTCACTACTCAGGATC +GCGAGAGTATCGGCTAACAACGGCTCGTTGTAACCCATCAGGCGCGGCACGAAGGAAACC +AGCAACACGCCGTGACGTGATTAGTCGAGTGCTCTACGGCCTTCGATCTGCGTCCGGTAG +CTCGCGATGGTCGGCGCTACGGCGTCGCATTTCGGGGCGAGCGCGACTTCCTCAATCGCG +AGATACGCGCCGCGCGTTTCGAGATATTCCGCCGGATTGGCGCGGCCGTATGCCCTGCAG +AGGCGGCCGTCGCTGGGGCGGGGGGCGTTGCGGACGATGTAATCGAACGACCAGCGGCCA +TTTACCGCCGGGGGCGTCCCGATGACTTCCAAATGGCCGACACGGACCCGGTAGTGTGGG +GCGGCTTTGACAGCGGCTTGAACCTTTGCGAGCGTGATCATGGCAAGCCCCTTAGGGTGC +GTTGCGGATCGATTCGACAGCGGCCAGTGCTGCGTCGCATGCGACGTTGAGTCGACGGGC +GAGCAGGACGGAATCGAGATGACGACAAGCGCGGATATTCGCGAGAAGGCGGCGGAAGGA +AAACAGGAAAGCAAGCATGGTTAGCTCCAGTGGAATCAGGGCGCGCGGGGCCGCGATCCC +GTGAATGAGATTCTAGGCGATAAAGTTAAACCTTGCCAAGCTGTTTTTAGAGTTCGGTGT +CGTGATTGTGATGAGGGAATGGCGCACACGGGATCGGCGCGACTCGCGGGATAACGAACA +GCCGGACGAAGCATGAGAACAGCCCGGAATCCCACAAGCCGACAGCCGCCCAAGCGATGC +CCGAACCGAGGATGAGGTACGACACGACCAGACGGGCGCGCACGCCGGCCAGTGCGACGG +CTTTGCGCTGGGAAGGACGAAGCATGAGAACAGCCCGGAATCCCACAAGCCGACAGCCGC +CCAAGCGATGCCCGAACCGAGGATGAGGTACGACACGACCAGACGGGCGCGCACGCCGGC +CAGTGCGACGGCTTTGCGCTGGGAAACGCGTGGATGTTAAACAGCAACGCGGTTTTTCAT +GACGCGAGTTCCAATCATCAGGATCAGGGACGCGCCGGCGATCAGGCTGCACGCGGCAGC +AGCATCAAGCCCTTCAATCGCCATCGTACGGCGCTCCGACGATTTGTTTGCAGCCGGCCG +CGATCAGGTACAACCAGCCACGGTAAAACTCGCTATCGACGTGCCACATGTGCCAGTCAC +GGCGAACGAACGCGAGCGGCCGATCGACATGCTCGCCGCGATCAACGAACCCCGCACCAT +GACCGACGCACGTCAGATAGATGTCCTGACCCAGCGTGGCAGCCGGATCAAATCCGCAGT +CAGGGTGCGCCCCGTAACCGTTGGTCGCGAGCATTGCGGCGACCGTTTGCGGGTAGCGCT +CAGCGAACGCATAGACGAACCGGCGCGCTGTCTCGCATGAGGTGCTACACTTCGCGCCGA +GGTCGAGAGCACGCGCAGCGGCATTACGTGTTACCAGAAGTACGACTTCACCTTCACCCA +CTGGCTCACGGCAGATAGCGGCTGGGGCTTGAATTGGGGTAATGACTTTGGAGGCCAATG +ATGGCAGAAGCACAAGGTAAAAATCTCGGCGTCTGGTGGGGCTGGGCGGACGGAGCGTCG +GGCTGGGGGACGACCACGAACGGCTCGCTGCAGCTTCTCGATACGATCGTGCAGCTTGGC +GTTTCCGCTGTAGCGCGCGGGCGCGAGCCTTCCGGTGCATCCGCCCAAAGAGCGGTGATG +ATGAAATGGCGGGTGGCGGTTTGGATATGTTCGTGCGGCAAGCGGAAGACGACATCGCGT +ATCGTGTCGCCATCGCCGTGTTCATCGGCGAACCATCCAGTATGGTTGATGCACGCGCCT +TCTACCTCGTCGCACCATTGCCAGCGCAACCCCGGCGCGCCGTCCGATTCCAAATAGAAC +CCCTTGCCTGTGCTGTCCGGTTTCGGCGCATGGTAATACTCGCCGCACGGGTACGCGTTG +CGCTCGGCAATGCTCGCAAACTGTTTCGGCATGCGTGCGATGTAGCGCGGGAAATTGAAG +CCGGCAAACGTGAATTCCGGTGTGAGAGGCGAGAGACGATTCATGGTGATATCTCCGTGG +GTATCGGAAAGGTGAAACGGATTCAGTTCGAAAGCGTACCGCCGTTCGCGCACTTGATCT +CGTAATGAGGCGAGAGACGATTCATGGTGATATCTCCGTGGGTATCGGAAAGGTGAAACG +GATTCAGTTCGAAAGCGTACCGCCGTTCGCGCACTTGATCTCGTAATTGAACGGGAATTC +GCTGATAACGTCGAGCAGCAAGGAAACCGCTTCGTCGGACAGCGGATTGCGCCAGCCGAA +ACAATGCCTGCCCGTGTGAGCGTAGAACATCCAGTTATCAATCAGGTTCGGGACATGCGC +CAAGATCCAGCGGCCGGCGTCTCGCTTTTCCAGCGCGACGGCGCACTTTTTCACGTATTT +CGCTTCACTCCGGTCTTTCTCTTTCTCGATTCGAGCCTTGTCGCGTTCGGTCGCGCCGTG +CAATTGTGCTTGCTCACAGAGCGGCATCAATGCCACGCGTTCCGCCTTGCTCAGTGTCGG +GCGCTTCGCTTTAGACGACACGGGTAAAAGGCGAGTGAGATACAAATCGTCCGGCTTCAA +ATACTGCGTTCCGTGGCACGACGGACACAACGCGTCGCCGACCGCGCGGTCTTCCTGATG +GCCGCAGGAGCCGAACTTAACCGCATGGTCGAGCGCGTCGCGAATGTCGTCCGTCACGAG +AAACCAATAACCCTCCTTGATCCGCTTGTTCGGATACTCGTACTCCGACCAAGGGAACAG +ACTTTTTGCGCACAGGGTTTCGCCGCCTTCCGTGTCGGACGTGTTCCATTGGTCGGAGAA +AAGATGAGTCGTATCAAAAACAATCGTCTGACCGTCGCCCGCTTTAATGTCGCCCATGAA +TGACTGTTGCTGCACTTCCGTGCGGTCGTACTGAAGACCGCCCGACACGAATCATTTGCT +TTCGCCGCGCGATTCCAGCATGGCGCACATGTCCGCGTAGGCTTGCGGCTCGTCAGGCTT +CTCAATGTTGAAGCAGTAATGGTTCAGAGTGGAAGTCAGGCGCTTCATTGTGCAATATCC +GTTGAAGGAAGGGGCCGGGCCAAAGCGGCACGGCATGACTGAGATTCTAGGCGACAAAGT +TAAACCTTGCCTAGCCCCTTTCCGCATTTTCTTGCGACCGGAAGAAACTTCCGACCCGTC +AGGGCGGCGCCATCAGCCCAAAATCCCTGCAAACCCTTGCCCCGTAAGGCTCTTAGGCCC +CGCGCCTCCGGTCGTCTAGGGGTAAACCCTGTGATGCGCCGCCGCAACGCGCCCGCCAAG +CGCGGCGCGGCTGTCCCGTTTTCTGCGCCACTCGTCCGGCCGGGCGGCCCGCCGATATCC +CGTACTGACGACCCCTCGTGCTTACTTTGGCGGCCTCGCCCGTTCACAATTCTTTTAGCC +CAATCGAGAAACGACCCACCCCATCGGCCTTTTGCTTACTTCGGGAACCGAGCCGGACCC +CCGCGCACGGGCCGCGTCGAACGAGCCGACCGGGGGTTACTTCAAAACCCTAGCCGGACC +CCCGGTCTCCGCCGTTGACAAAGTTAAACCCATCCCCGAGAATCCGCGCGTCGAACCGAT +CAACATTTTCGCGGAGGATCACCATGGACACCGCCGAGACCCTCAACAACCAGCTCGACA +GCTTTGCCTCCCGCGTGCTAGCGCTCGAAGTGGGCGAGACCGAATCGAAGACGTGCCGAC +TGGATGGCAACGCGGCGACCAAGGAAGTCATGGCGGCCACGCTCACGAAGCTTCGCAATA +GCGTCGCGGCCGCCGTCAGCCGGGCGTCTTCGAAAACCGGACACGTCTTCATCACCGAGA +CCGGCGACATTCGCACGAAGAGCTACGACTTCCTGATGACGGTCGCCGTCACGCGGAAGG +CCTGAGGAACGCCGTGGACTTCAGCGCGGACCACGCGCTCGTGCAGGCGGCGATCTGGGA +AATGATGCGGCAAGCCGGGATGACGACGTGCAACGTGTCCCGTGCGAAGATGAAAGAGTT +GCATCAGTCGCACACGATCGAAACAGCGTACGACCTGAGCAGCGGATGGACCGTGGCGCT +GACGGCCCGCGCCCCTGAAACCGAAAACGGAGGACCCAAACGTGAAGACGAATGATTGCA +ACTGCGGTTCCGCCGACTGCTCGGGCAAGTACGCGATGAAGGGCGGCGCAACCGGTCAGC +AACTGGCGCACGAGCTTCACGGCTTAACCATCGATCCCGGTCGCACGATAGCGCAGCAGG +CCGACTAACTGCGTGCGCAGGCGGCGCAGATGAAACAAGACCAGGCGAGCCGTTTGCTGC +GCAAGACGCTCGACATGGTTTGGCCGAAGTAATCATGCGCGCCGTCCGACCTCCAGCCCG +CGCCGGAATCCGGACCTTCCTGAGCAAGATGCCGGTCGGCGCGCCATACGTCATCGCGGG +CGACACCATGGACAGTTACAACGCGAAGACTTTCCGCAAGGCTAACGTCGAACTCGGGCT +GCCGATTCGCAGTGTGGTGCATCACAAGCATCCGACCCCCGGCATGTCCGGCATCGAGAG +CATCCGCCTGCCGGTCGAGAAGTCCGAGCGGCGTATCGTCTGAATCCCCACGACGGCGGC +CGAATAATCGGTCTCCCGCTGCAAATCCGGGCCGCCATGCTGCTCGGATGACCTACCCCG +CTACTACCCCCGCCAGATTTCCTGCCGTCCCGCCTGAAGCCCCATACGCCTGCCGCAGAC +AAATATCCTTGTCTGGCAAGGCTCAACGCTCGGCTCCCCCACACGAAGTAACTTCCGATT +TCCTGTTATTTTTGTTGCACCGTTCGAAGGAGTGTTGTACAGTTCCACTTGCGCCTGGCC +GCAAACCCATCAACCCTTTGAACAAAACAACAATGACAGTCAGATTTACACAGGAGAAGA +ACGTCACCATCCTATGGGATGCGATTGACCGGCATGGCCTCCGATGCCACATCTCCCCGG +ATCAGGGGATGTTCAAGTTTAGGGAACGCAGCAACCCGACAGTCTACTACTTCCCGCAGC +GCATCCGCTACAAGATCGCCGGGCAGCCGAAAGATGTTCACATGAATACGGCTGACTTCG +CGTGCTGGTATATCGGCGAGCATCTCGGTCGGTTGATCGCGGGCAAGGCGATGCCGTGGC +TGCACCGCGCAGCCAGCGACGGCAATTGCCGATGGTGCAGAGAAGATAAGAGCACGGCCG +GCCCGCTCTGCGTCGCATTCGAGCATCACCGCGAACGCCATCGTTCCAGCGTCACCGTAG +AAGCCCTTCGTGAAGAGCAACTCCAACTGCAAAACGACGACCAAGGAGCAGCGCCATGTT +CAAGCAACTGATTGCCCGAATGAAAAGCGACAATAAACCCGAAAAGGTCGCTAATTATTT +CCAAGAGCTGAAGGACCGGCAGCACGAACTCGAGCCGCAAGAAGACAACATTGCGGCCGA +GCGGCTGTATATCGAACGCGAACTTCCGCGACTCGCCGCCCGACTGGCGGAGATGGAATG +GGGCGGCGAAGACGCTGTTCAACGTTCGGCCATGGTAGGCATCCGCAACGTCATCATAGC +CGGCCACCAACCGGACAAACCGATCATCGCGCAACCCGGCGTCGGCAGGAGGACCACGGC +ATGAGCATTCACTTCGTCCCGAAGCTGCGCGTCAAGAAACAATCGAACGGGGCAGTACAC +GTAACGGTCGATATGAAGATGCTCGAAGCGGGCGGCCATGAAATCCTCTGGAATTGCGCG +GTCATGCAGCGCATGCGCGAGTCGGGCGTTCCTATTATGGGGCTGATTTCCATTCAAGGC +GTCCGCCACGGCTGCCTCGTTCAGACCTACGACGAGTGCTTCATGGAGCACGTCTACGAA +TGGAAGCCCGGCCCAGATTCGCCCAAAGAAGTTGACCCGGCAGCCGGTTTCTGACCAACA +CACTATGGGAGTACCCATGAGCAAGATCGAGAAGGCCAGTGTCACGGTCAGTTTCAAGAC +CGACAGCGGCTACGAATCGGTATTTGGCGCGCAGAACAAGCCGGGCATCGACGCACTGAA +AGATGGCCTGCACGAGATCGTCCGCGTGCTGACCATCAACGGCAATGTCGCTACCGTCGA +CGCCGTCGTGAAGGCGGCCAAGCGGCGGGGAGAGCGCGCGGTTCTCACGCGTGTCACGGT +CAGTTTCAAGACCGACAGCGGCTACGAATCGGTATTTGGCGCGCAGAACAAGCCGGGCAT +CGACGCACTGAAAGATGGCCTGCACGAGATCGTCCGCGTGCTGACCATCAACGGCAATGT +CGCTACCGTCGACGCCGTCGTGAAGGCGGCCAAGCGGCGGGGAGAGCGCGCGGTTCTCAC +GCACGCGACGGCGCAGGTCGAGCAGCAATCCGAGGTCGATCAGCGCGCAGGCTACAAGCC +GCCTTCCGATGACCTACTGAAAGCGTTTAACGCAGGCACGCGGCGGGGAATCATGAACGT +CTACCGCCATATCCTCCGCGAGCATCCGACCGCAACCGGTACGTGGTGTATCCGTCGCGC +GAAAGAGATATGGGGCCATCTGCCGCTCATCGCGCTGAACGCGGAGAATCGACCGGGCAT +CGCGGAAATCTACGTGGACCTGCGCCGCGCGAATCCGCAGTGGTCGATATCCGGGCTGCT +ACGTGAGGTCGAGCGCCAGTGGAAGGAATCGCAGGAATCGGAGGCGGAACTGTGAAGACC +TTTCAACTGAATGCCGATCTCGTGCGCTGCGCTGCCGCGTGGGTGTACGGCGGCGATCCT +GCGGCCATGAAATACCCGGCGCTCAATCGCATCCGCATCGAACCACACCATCTGGAAGGA +ATCGCAGGAATCGGAGGCGGAACTGTGAAGACCTTTCAACTGAATGCCGATCTCGTGCGC +TGCGCTGCCGCGTGGGTGTACGGCGGCGATCCTGCGGCCATGAAATACCCGGCGCTCAAT +CGCATCCGCATCGAACCACACCATCCCGGCGCGATGATCATTGCGACCTGCTCGCACGCC +ATGTTCGTCGCGAACGACCCGGAAACCGTCGTGCCGGAACCCGCGCTGATCTCCGGCCCG +CAGGACCTGCTCGACGCGGGCGCGCTTCTCGGCGTCAATACGACGGGACGCGAGATTCGC +TTCTGGGGTGCCGGAGTTGCCGTCCATGCGCGCGGCAAGCTGAAGCATTAGTCCCGGCTC +GTGATCGACACGCAGCTCCTGCGTGGCGTGATGGCGCATTACGCTAACTGGCGTGCAGCC +ATCCCGGCGAAGATGGATTTCATGAAGGCGAACCCGGCCATCCCGACCATGATGGACATG +GACTTCCTCGGCCGTCTGGGCCGGATGTTGGAAGGCTTGGGCGAATACCGGCAGGTGTTT +TTCGCGACGTGCGGCTAGCAGTCGATCACGCCGGGTGACGGGCAGCGCACCGACTACCGG +AACTTCTTCGCGTTCTTCCCGTGGAAGCGCCACGTGTTCCTCCTGTTCGCGCCGATGGGC +GGCATGCCGAGCGCCAAGGATTACGGATACCCAGAATGGCTCGAAGACAAGCCGGACGAA +CCGGCTGCCGGCCTCTGAAGTAACTTCCGACCGATTATCGTTGACAAGGCTTAAAGTTAT +CACGATACTCGGTTTCACTTTTCCACGAAGGAGTTTGAAATGAACGAACCGAAAAACGAT +GGCGTCGATCAGCGCGCCTACGCATATGTACCGGCTTCCGTGCTGCTCGAAATGAAGCAG +TACATGGACAAAGTGTCGAAGCTCTCGAAGGTTCCGGCATCGGCTATCGGCCTGAAGGAG +CGCGTCAAAGGGTTAGTTGCCGAAGCGAAGGAGCACGTCGCGACGGTCGACCTCATCGAA +TACGAAGTAGGGCAACTGGTCGGGAAGTATTTCGAGAGGATCAATTTCGAACTTACCGGC +GATGTCGTCGTGAGGAAGACCCGGGAGTTCAGGGGCGACCTCGGCCCGTTCAAAGACGAA +CTTTGCCGCATGATGCGACATATCGCGTTTAAGGTCCTCGGCGAGAAGATCGAACGCGAC +GATGCGGCCGCCGTGTCGAAGCTAGAACGCCTGTACACGCACATCGACGCTGTCGCGGCC +ATGCTAGCGAACGACGAATATGGTGAGCCGCAGGGGACTGGCGACGAGAAGTTCGACGCA +CTGGTCGAACAGATTACCCGTCTGCACAGCGATCTCAACGAGTCCGCGCAACTGATGGTG +GAATATGGTGAGCCGCAGGGGACTGGCGACGAGAAGTTCGACGCACTGGTCGAACAGATT +ACCCGTCTGCACAGCGATCTCAACGAGTCCGCGCAACTGATGGTGCCGCTAAGCGCGTCG +GCCGAAGCGGAACTGGCGAGGATCACTGAGCAACTCGAAGAAGCGTGAGACGACATCGAG +AAGGGACGCGGCGTGACGCTCGACGTGGAAGATGCCAAGCCCATACATCGGTTCAAGCAG +TTGTACGCGAAACTGTTCATCCAGTGGCAAGAAGCCACGACGCATCGCGACGACGCCGAA +GGTCGCCTGAATGCCATCAACACGGTCGTGGGCCAGATGCGGAAGGATGTCAAAGGTGAC +GGCGCGCTCGCAACGGGCGTAGTCTACGATTACAACCTACTGAACGAGATCCGTGGCTTG +GCGCACACTGTAATGATGAGCAAGGCGTTCGGCTACGGAAAGCTCGGAGTGCGGCACGAG +ATCGGCATGTTTCACAATCACGTTCTGCCGCGCGTGCGCAGCCCGAACTACGTGGGCGAC +CCCGAACTGATCGACCAAATTCTCGATGGCATCGCACTGGTTGGCTCCGGTTCTGCGGAT +GCGTTCGATACGGCGCAGACTAGCGGGGAAGACCCGCTGTCGCAGGTGCCGCTCGACGTG +TTCCAGCTCAAAGCGCGCGTTGTGGCTGTCGCTGACAGCTTCGAAAAACACAGTGCACGT +CTGCACGACCATCTTGGGATGAAGTGGCGGCTCATCGAAGTAAAAGAAGCGCTCGGGCTG +CCGTTCGCGAGAGATATGGTCCGGGTCATCGGCGAAGCTGACGACTTAGCTTCCGTTCCG +CACGATCGTGTACGGGCCGTTTGCGTGGTGTGCGAAAATGTCCTTGCAGCCGTCCGGGGG +TTTGATGACAAAGCGCTGGGCGCTGCCCGCACGTGCGATGAAAGCGCGGGGACTGTTACA +ACGCTAGAACCGGACGAATTGCAGGGCGACGCGCTACCTCTCGATAGTCCGAAGAGCGGG +AACGCGATTCGCGTGCTGACGGAGCAGCTCCGAAAAAGGAATAGGCTTCTCGGCAACTTC +GTAGACATCCATACGATCCTCGAAGAGCTTCAGGACGCGATGCACGACATCCTGTTGGAA +CATGAGCCGAAGCGCCCGGACGCACTGCAAAACGCATGGTTTGCGGATGTGCTGAAGTTC +AATCTCGCCGCCGGCCGCACGATCGATGACTTCAACCCGCGCATGATCGGCTTGCTCACC +GGACTTCAGTGCGAAGAATTCGGCGAGAAGCTGCGCCCGATTGTCGATGGCACGGTTGCT +TCCTGCCTGTCCATTTTCGAAGGCATGCCGCTCGTGTCGCTCTGCAATCAGTTGAAGTGG +GTCTGCGACCTGTTCAAGCAGGATGCATTCGACAACGCTATTGATCGTGCTGTCCCGGTC +GAACTGGCAGACGGCGACATCGACCAGATGGTCGTCTCGTTCGGCTCGCTTCATTCGCAA +GGCGTCTCGCTGTACCCGATCCCGCCCGCCGTGTCGGACGCGAACCTGCGCAAGATGGTC +AACGGCAAACTGCTGTTCGACAACAACGGGAAAATCGTCAAGCCCGATTGCTGGAAACCG +GCCGACCTGCTGCCGTTCTTGCAGAAGACTAAACAACCTGCCGAACTGCACATGGGTCCG +TCCGACGAAGCCGGGAGCCTCTGACACGAGAGTGAACGTCTATAGTCAGGAACTCACGTC +GGGATTAAACCCGGTGTACAAGGAGTCAAATACCGGCGTAATTTACAGCGCGGTGCAGTT +TGTTTTGCATTCGAACGACAGACTCCATCATCCCGACCCGGATGGCGACGACGATCGGAG +CGCCGTAACTTTTTGGCTTCCGAAATCGAGAGATCGGCGCGAGGCATTCGCGCTTGCTCC +GGATGGCGACGACGATCGGAGCGCCGTAACTTTTTGGCTTCCGAAATCGAGAGATCGGCG +CGAGGCATTCGCGCTTGCTCTCGAAGCGGCCGCCACGATGGTGAGAAACGCCGCGTCTGA +ATCCGGCTTGGACTCTTAATCGTTTCGCCTCCCTTCGGGGCGGCTTTCCTTCGAGAACAC +CATGTACGCGAACAATCGCGACAACCACGGACTCGCCAACGAGATCGAAACGGAGATCAA +ACTCAACGTCGAGCTCGACAACTGCTGGCCCGGCACGCCGCACTTCATCCTCTGCCACAG +CCGTCAGGCCGGCTGGGAGATGGCCGAGCGGATGTCCAAGGTCCTGTCGTTGCCCGGCGG +CGCGCCCGTCACCGTGCCGTACGTCAGCACGATCCCGGAAGCCATTCAGCTCCTGCAAGG +GCTGACGACTCATCCCGTGGTCGTGTTCGCGCCGGCCGTCGTCTTCCTGTTTCCCGGCTG +CGGCGGCGCGCCCGTCACCGTGCCGTACGTCAGCACGATCCCGGAAGCCATTCAGCTCCT +GCAAGGGCTGACGACTCATCCCGTGGTCGTGTTCGCGCCGGCCGTCGTCTTCCTGTTTCC +CGGCTGGGCGTGCCCGCTCGACCAGCCTACCAAGCTGCATGCCACATTCCCGATGCACGA +CGCAGAAACGTCGCAGTTCATGAGCCGCTTCAACGGGTTGAACTCCCGCGCCGGAAACAC +GAAGAGAGTCTCATGGAGCGCCGAAAGTCGAACTGGCCGGATTACGAAGACAGCATCGCG +CAGCTCTGCGCGTCGTTTTGGGCCGGGGCCGTCGCTGGTAGCTCCCCGGGCACGAAGTTA +CTTCAGGCCAATGAGTACGTGATCCCGAATCCCGAGCGGATCGCCACGTCACTGCACGCG +CAAAACGTCGGCAAGACATCGGTCGTGCATTCTATGTTCGCGCTCGGCGCGGCGGCAACA +GTCAAGCGGGCGAAGCCGTATGTGCTGCCGGAGGGGTTCAATACCCGAGCACCGTTATCG +CCGTTCCAGCAACTGATGCGTTTCGGCTACGCGGAATACTGCATTGACGATTTCGCGCGC +GAGAAGCTCTCTCGGGTTCTCTTCGACTCGAGGAGGCGCGAAGCATTCGATCGCGTCCTG +CGCCGCAACGCGTGTCAATCTACGACGCTCACCGGTCTGTCATGCGGCCTTACCGGCCTC +GAGGTTGGCTGCGCCTGCGGGGCGTGACATGGGCGGCCCGCACTTCTTCCGTGACGGCTC +GCAATTTACCGGCCATCAGGTCGTCAATTTCAGCGAGCAGAAAGAGCAGGGGAAGGTGCG +CATTCGCGCGCGGTGCAAGGAGTGCAACGGCCGCCCCGGATCACATCACTGGCCGCACGG +CCGTGGCGGTGCGTGCAAGGGAACCGGAATCAACGCGTCGTACTCGTGGGTGTCGGTCTA +TTCGGCCGAACACCAGAACGAATTGAACGCCTCGAAGCACCGCAAACACATGGCGCTGTC +CGCGCTCGCGTTGCTGATGGTTAAACGCGATTTCCGTCAGTTCCTGCGGCAGCGCGACCG +GTTGCTTACGGACATGCAGACGTTCGCGCCGAAGTCGGAGAACCTGCAATTGCTGCTCGC +CAAGGTCAATTGAACGCCTCGAAGCACCGCAAACACATGGCGCTGTCCGCGCTCGCGTTG +CTGATGGTTAAACGCGATTTCCGTCAGTTCCTGCGGCAGCGCGACCGGTTGCTTACGGAC +ATGCAGACGTTCGCGCCGAAGTCGGAGAACCTGCAATTGCTGCTCGCCAAGGTCAACCAA +GGAACTATACTCACCCACACCGTGATCAGGCAGGCCCTGACGCTCGTAAATACCGTTAGG +CGTCAATTCTATGTCGCCGCAAGCTGCGCTCGCTAAGAAGATCGCCGAGATGATCCGGCG +CAATGTCGACAATACGGACCCCATCACGCTCGTCCGCAACGTGATACCGCTCGACCGAAA +CAAGGCGTTGACGCTCGTCGGGATACTCGAAGCTGTTGCATCGGCGGAATCGTTCACCGA +GCAGAAGGTATATGAGGCCCTGTATCCCGACAGCGATCCAGCCAAGCCTATCCGCGATTC +CCCCAGCGTTTACACAGCACGGCTCGAAGCGGTGCGCGGCGTGCGCATGAGAAACCACGA +AACCGCCTTTGACTACAGGATTCGCTAGGACTCCGACGGACGCTTGAAATTGACCAACTG +TCAGGTGCGCGCATTCATCGATTCCTTTGACCGTCAATCCGGGAGACGGCAATGAAGACG +ATCTACATCGTATGAGCGTCGTCTATGTACGCGGGCGGGGCGGACGTTCGGGCGTTCGAG +GACGACGGAGACGCCAGAAAGTTCGCGTCCGACTGTCGCGCCGCTTCGGCTCGTCGCGCT +CAAGCCCCCGCGCTAGGAGCCAGTCAAGCGAAGTTGGCGGCCTATTACAGGGCAGAAGCC +AAGTGGGAGAAACAGCACCCGGCCAACCCGCACCACCACCTCGAGTATTACGACGTAATC +GGCCTCGATCTGTACCCGAAGCAGAAGTAACTTCGTTTCAATCCTGCAACATCGCGTGAC +AAAGTTGAACAGGGTTATTACGGCACGAGTTGTGTTGACAGTGTTTATCTGCCCGATATA +CTTCTGCATGTAGTAACCCACTCAACAACCGAAAGGTGATTGTCATGGCAAAAATCCAAA +TTCCGGGCGAACTCAAACTCGACGCTCCCGAGGGCAGCGTGAGCGCTGAGCTGAAGGGAG +CAGGCGCTACGGATGGCAAACGCATCCGCATCGTGCCGCCCGATTCGAGCCACATCGTGC +CTGGCCTCAATCCGCGCTTTTGGGGCAGCCCGAATTCGAAGGCCCACATCGAAGACATAG +CGAAGTCGATGATCGCTCGCGCGGCGTCCGGCCTGCCGGCGTTCATGCCCGAGCGCGCGC +ACGCCTGCTTCGCTCTCAAGATCGATGGCGTGGAGCGCCTTGTTCTTAAGGCCGGCCAAC +ACAGCTTGGCTGAGGTCGCCGTCGCCAACAAGAAGCAGCCCGGCACGGTCGCGGAAGTCC +CGGTGTTCGTGGACGAAAATCCGATGACCGACGCGCAGCTCGCGCTCTACTACATCACGG +AAAACCGCAGCGAAAAGCGGGGGCCGTACGAGATGGCTGTCTCCGTCGGACGCGCAGCGG +AAGCGGGCGCGACGAAGAAAGATATCATGGCGGAACTGAACACCTCCGACCGCTATCTGT +ACGATCTCGGGCTGCTCTACAACGCCGACCCGCGCGTCATCGAGCTGCTGGCGGAAGGTA +AGGTGAGCGGCACGACCGTCACCGAAGAGATCAAGGAGTACGGGCAGGAGAAGGCCGCCA +AGCGACTCCTGAAGGGCATCGAGACGGCCGCCGCTGCCGGCACGACGAATGTCACGCGCC +GCCATCTGCCGGCCGGGGACGCCCCGGCCAAGGAAAAGAAGACCCGCGCCGACACGAGCA +AGACGGATGGAGTCGAGCAGCGAGCAGCCGACGTTCCGGTGTTCAACGCCACGCTCTCCG +TGCTCGAAGTCGTCAACGGGTTCCACGAGCAGTTTGGCGAATCGGGCGATCGTCATACGA +AGATCATGTTCGAAATCATCAAGCAGTGCGGCGGAGACGAACTCGTCCAGTACGCGGCTC +ATACCGGCAAGTACGAAGCGACTAGTCTGGTACGCTTCGGCTTGGTCGGGCTGCCCGTAG +AACCGGTTGCCGGTGAAGAAGACTCGGTGATCAAGGCGCAGGCCGAGAAGACGAAGAACA +CGCGCTCGCGTAAGTCGAAGAAGACGGAAGGACCTGTCGAGTCGCCGGTCGGAACGGCGG +AAGGGCTGTAAATCGGAAGTAACTCCAGGTCCGCTTCGGCGGCCGTTTTCAGGATTACTC +ACAGGCGAGCTTATGCAACCCAATCTCGGGCTTCTCCCGGTCATCGACGGCCGGGACATC +TGCATTTCGCCGCTCGGGATCTGCGAAGTCGAAATCAGCGACCAATTCATCGTGACGCTG +GCCATGCAGAGCGACAACGAGTACCAGTACAAGATCAAGAACATCGAGCGACAACTGGCC +TACTATAGGGACCCAACCATCGAACCGTCGCGAGGCTACGATAAGCCGATGAAGGCGATG +ACCTCGAAGCAGGCCCATAAGTGCCTGAAGTTTCAGGGGCGCCGACGCCTGACCGGGTAT +GTCAAGGAGGCCGAGGAAACCCACTACTGGCATCTGCACCGTTACGAGGACTGATAAGGA +AGTCGCCATCGCAAGCGGGCTCGTGCCGTACGAACGTATGCGCGAGGGGATCGAGGTCGG +CCTGCATTACCTGTCGTTCGACCGACCGGAGTTCATCACGGGGCTGCACGTAGCGGCCGA +TGTAGGAACTGCCGACGTGCATGCGACCCAGTGGGCGAAGGAGCACGGCATCGAGATTAC +GCGCTACTGGCCGTCATATCGCGGGGACCCGAACGAAGCTGCCAAAGACCGCAACTACTT +CATGCTGTAGGAAGCGGACGTGCTGATCTCGGTAATGGGCGGCGTCGGCGATTGCAGCGG +AATCATTAAGATGGCCCGGAAGATGAATATGCCGGTCTACGTACATGCGAAAGATCATGG +TCTGTAGTTGACACAGTTCATCTTTGTCAGGATCATCATCTCACCAGCTACGGAGGGATC +AAAATGAGTAATGAGCCGAAAGACGCAGCAGGAATCATCACCTTGAGCATCCAAGTCTCT +CGCCAGTTGTACGAAAACACAATGGATGCAGCCGCGCACGGAGTTGAGTATTGGGCGCAC +GCGTTCGAGCATCCGGGCTGCGGCCCGGAGACCCTAAATTATACGATCGAAGAAGACGAA +CCGAGCAGTGGCGAAACGCCAAAGAATTTCGTCACCAGCACGCAAGCCATCGTGAACGGG +ATTCAGGCGATCATGCACCCGGCATTCTCGGTGCGCGCAGACATCCGGGGCACGCTGTTC +AGTGCACTCGTAGAAGACGACGCCAGCAATATCGACATCGAGATCGCCGATATCATTGTG +CAGGCTGCGATGTTCGGCGAAATCATCTATGGCTGACCGGAAGTTATTTCCGACCAAGGA +GAAGAAAAATGGCGAGGAAACCGTTGAAGATCACATTCGGTGTTGGCGCAGACATCCGGG +GCACGCTGTTCAGTGCACTCGTAGAAGACGACGCCAGCAATATCGACATCGAGATCGCCG +ATATCATTGTGCAGGCTGCGATGTTCGGCGAAATCATCTATGGCTGACCGGAAGTTATTT +CCGACCAAGGAGAAGAAAAATGGCGAGGAAACCGTTGAAGATCACATTCGGTGTTGGCGC +TGCTGCGCTGGCGATGAACGTCGTACGCCGTGCAATCAAGCGGATCACCGAAGACCCGTA +CGAAGCTGCGGCCGAGCACCTGAAAAAGACGCTCGAAGAACGCAAACGGCCGTTACTGCT +GCGCTGGCGATGAACGTCGTACGCCGTGCAATCAAGCGGATCACCGAAGACCCGTACGAA +GCTGCGGCCGAGCACCTGAAAAAGACGCTCGAAGAACGCAAACGGCCGTTACTTCCCGGC +GAGCGCATCGTACAGGAAAGCCCGCTGTTCGAAGCTCCCGACGGCGTGTGGAAATCCGAC +CGGGGCGACGAGGTCACGGTGGACACGACGTTCGATCGACCGCGGGTCGGCGTCGTGCTG +AAGCGCAACCCCGATGTGCCGAGATTGTATGTCGTCCAGATGGCGACGTCGCACGCCGAA +ATCAACGTCCACGAACGTATGATGAGCCTGCGTCGCCGTGCAGCCGGCGACACGAATCGC +GCGGTGTTTCCGGCGGTGCGCCCCTGCGAAGGGCGACCGGCCGGCGAATGGTCGACTGCT +CGCCGCTGGCCGCCGACCGGCTGGCCGTGCGAATGGTACCCGCCGGGAAATTCCGACGCC +TACGCGACCGTAAGCTACTTTGGACGGGACTATCCGCAGGCCGTTGACACGGAGAAGGAA +CAAGCAGAACTCGCCATCGCGGCTGCCGGCCTCTCGATGTGCCACGACCCGTGTTACGTC +GGCCAGTACGGCGATCAGACCGTATGCAAAACCTGCGAAACGACGTGGGTTGCGAATGAT +CAGTTCCCGCCGTCGTGCCCGCACCCGTGACGAGGCTGCCGTGTCGGCAGCCATCAACGG +CGCTACCATCCTGATTCTCAATATCCTTTACCCCCGGAGAAAGTAAATGCGCATTGCGAA +CCCGCAGAATCGCCTCTGGCAGGCTCTCGTGTCCCGGCTGGGCCAGCGACTCATCGACCG +GGCCTTCAGCCGCTGATCAGTTCCCGCCGTCGTGCCCGCACCCGTGACGAGGCTGCCGTG +TCGGCAGCCATCAACGGCGCTACCATCCTGATTCTCAATATCCTTTACCCCCGGAGAAAG +TAAATGCGCATTGCGAACCCGCAGAATCGCCTCTGGCAGGCTCTCGTGTCCCGGCTGGGC +CAGCGACTCATCGACCGGGCCTTCAGCCGCCCAGCGGACCCGGTAACGCTTCCTGACTTG +GCGAACTAAACGCATCGTCGCTGGCTAGTGAAATACTCTCGCTGGACCCTCGGCCGCTGC +GCGCGAATTCACCACATCCTGCGCTCGGATTCGGTTCGCGATTTCCACGACCATCCGTGG +CCGTACGTGACGATCATCCTCGACGCCGGCTACACCGAAGTAACCCCCGTCTACACGAAG +GCGAATCTGGACAAGGGCGAGCACGGGCAGTATTATGGCCCCGCCTCGATCCTCGTCCGG +CCAGCCACGCACCTGCACCACCTCTAACTGGAACCCGGCACGACGGCGACCACGATGTTC +ATCGCTGGGCGCTGGGAGCAGGAGTGGGGCTTCATCACGAACCCCAACTTCAAGATGTAC +TGGAAGGACTACCTCGCGCGCGAGACGGACGTTACGCCGGCACGCGCCGAGCGCCGCACG +TTCGGGCTTCATCACGAACCCCAACTTCAAGATGTACTGGAAGGACTACCTCGCGCGCGA +GACGGACGTTACGCCGGCACGCGCCGAGCGCCGCACGTTCCTGATTTGCGCGTGTCCTGC +CGGCGCGAAACTCAGATACCTAGCCCGCCACCATACGGACGACGACAAGCGCCGAGCGGG +GGCCGATCTCATCGAACTGATGGAGGCCGGAAGAAACCCGTTCCCGAAAGAGCTGGAAAT +CGGCGCGAGCGGTCGTACGATTTTCCCTGAAGAGTGCTGCGCGTGTCGCGCGCCCGACAT +CGAGGACGGCGCGGATACCGCCTTCGGCGACGAAGCGGACACGGAAGCCAGGCGCTGACC +GTGAGCGGCCGCATGAGGTTCTACCACGAGAATTCCGACAGCCACGTCTACCTCATATGG +GAAGAGGCGGCCGCGCTGCCGGAAGCTCTCTACGAGGTTGACGAGCTGTTGGTTCCGGCC +GCAGTACAGGAGAGTGAAATGGCGTATCTCGGTCTGAATCAGCTCCCGTTCTTCCTATAC +ACCGACGACATGCCCCCGGACCCGGTCTACGACGCATGCCGGCTTCTCGGGATCGGCTCG +TGGGCGACCAGTGAGTTCCGGGGAAACATGGACTTCAAGCTCTCTACGAGGTTGACGAGC +TGTTGGTTCCGGCCGCAGTACAGGAGAGTGAAATGGCGTATCTCGGTCTGAATCAGCTCC +CGTTCTTCCTATACACCGACGACATGCCCCCGGACCCGGTCTACGACGCATGCCGGCTTC +TCGGGATCGGCTCGTGGGCGACCAGTGAGTTCCGGGGAAACATGGACTTCGCTACGGCGC +TCGAACGCAAGCACCCGATGAAGGAGTGGCGGGAGGCGATCAAGAAGGCCATGGAGATCG +AGAAGCGGCAGCAGAGTGCGCGAACGATCGCGGCCAAGGCGCGCATTGCACTCGGCAGCG +ACGACCCGTACGCGCTGCGTGTCATGCAGTTGATGATCGACCTCGGGAAACAGCTCGACC +CGGCGGCCGGCACGGCGCTCGAACGCAAGCACCCGATGAAGGAGTGGCGGGAGGCGATCA +AGAAGGCCATGGAGATCGAGAAGCGGCAGCAGAGTGCGCGAACGATCGCGGCCAAGGCGC +GCATTGCACTCGGCAGCGACGACCCGTACGCGCTGCGTGTCATGCAGTTGATGATCGACC +TCGGGAAACAGCTCGACCCGGCGGCCGGCCTGTAGGCAATAAGAAGCCCCGGCTGAAACC +CGTCAGGGCCAAAGGGCGATGCCTTACGGCACACTCCCCATCTGATCGCAGCAAAACCAT +TCTACTCTGATGCCCGCTTCGCCGGGGTCGCTTTGCCGGGCGGCTTCCATCCACACTTCT +TTGCACCCATTTCGTTATGTTCGACCATTTGTTTCAGGACGGGAGTCGGGATCGCTTTTG +CTTGGTCGAGGGTGTAGGTGAATGGTTTCGTCCAGTTGCAGCCGGTGTCGATGAACTTGG +TTTCAACTACGATCTTTGGTTATGTTCGACCATTTGTTTCAGGACGGGAGTCGGGATCGC +TTTTGCTTGGTCGAGGGTGTAGGTGAATGGTTTCGTCCAGTTGCAGCCGGTGTCGATGAA +CTTGGTTTCAACTACGATCTTTGGTTCCTGCGACATCGGGACTTCAGCTTTCGGGGGAGG +CCCAGTTTTGCACGAGACCATCAAACGTAGCGCCGTCAGTGCCAGCTACTTGTTGTTCAA +CATCGCTTCGTTCCTTCGCGGCTTCAATGCCTTGTTGAGCGGCTGCTGCGTTCGAATGAG +CATGTGCGTCACGGACCTCCGCTGTGTGAGTCCGGGCGTCGGTCGCGTCACGCTGCGCTT +CGGCCTGCCTCTGTTTCGCGGCGGCCACGTCGGCCGACGCTTTCGCCTTGACGATCCGGC +TGTTGCCGAATACGCCGAGGATCGCTACTATAGCAGCCCCGATAGCCGCGATGATCGTGT +TCATTGGCAATTACCTCCGTGAAGGATGTAGGTTGCACGCAGGGCATCGAGCTGGCGCTT +TGGCTGTCCGTACGTGTTCTTCGTGCCGGGGATAGACGCCCAAATGTTCGAGAGCCGATC +GCATGCCGTCAGGAAGTCGCCGTCCTTCAGCGGCTCGTTGGCGCGGCTCTCTTTCAGGTG +TTGAAGGCCCGTCAGGTCTTGCGCGATCTCCGCGAAGTCCGTCAGCCGATGGAGCGTCTT +GTAGTGCGGCCAGTCCTTCAGCATCTGTTGGTATCGGCAGCTCGCCGTCGAGTAGAGGCC +CTTCGAGTTGACCTTGAACGGCTTGCGGCCGAATTGCGGCATGAACGGATGGGCCCTGAA +ATCCGTGAAGCGGTTGTGCTGCACGTTCCCCTGCGCGTTGATTGAGTTCACGAGGATGTC +GTAGACGTCGTCCTGCGTGACGGGTGACGTGCTCGCGCCTTCGGCGGATGCGATCGTATC +CATGAACGTGCAGACGTTCAGGTGGCCGGCAAGTTCAGGAGGGATCCGGGGCATTCGGGG +TCTCCGGTCGAGGTTGCGTACGCGCGAGCCGGGCCTGCTCGATGATGCGGAACGGCACAG +CGAACACGATGATGGCGATCGCTGCTTCAGAAGGAAGCGGCTATACAAAAAGACCGCGTC +GAGCGCGACCAGTGCGACGGCGGCGACTTCGGCCGCCAATTCGAAGAGGTTGTTCATTTC +GCCCACTTTCGGACAGAAGCATTGTACGCGTTACGGTCGTCGATCGCACGGTCGTGCTTG +TCCTCGACGCGTAGCAAGTCCTCTCGTACGTCCTGTTGCACCTTCGTTTGGTTGGTATCA +ATGGGCTTGATGTCATCCTTCCTGAATGGAATCTGCGTGGCCGATTCGCGCGCCCGGTCT +CGGATGTCGCCATCGTAATTCGCGACCCAGCCGATTGTCGATCCACACGCAACCAAGACC +GTGATTGCCATCTTGTTGTTGATGCGGCTCTTGTCTGCGATGTGCGCCGTCTGATCCGTG +TTGTTCGTCGTCGCGTTCGTTCGCTGACCCCGTGCGAAAAGGTTGTGGATGCGCGGGATT +CTAGTAGAACCGGAAGCAGTCGAGGGGCAATACGAAGTAACTTCAAAGCGGTCGGCCGTC +ATAAGTTTCACCATATGAGAATGAAAGGGATGGGCAGTGCTGCCGCGAATTCTAGTACCC +GAGCGCCAGAATAACAAACGGCCCCGAAGGGCCGTCTGCGCTACATGAGGTTGTGGGCCA +CGGGTCGTCCGGGCCGGGCGGCGTATTGCCTGCCGCCAGCCACTGCTCGTAGATGTCCAA +CCAGACCGAGCTATCTTTGGGGACCAGCCATACGGCCCCGTCAGCATCGCGGTACTGGAC +AACATCGTCCCGAACGTCCGGGGACGACCCTTTGAACTGCCTGAACGCTATTTCCATGAA +CCGAGCTATCTTTGGGGACCAGCCATACGGCCCCGTCAGCATCGCGGTACTGGACAACAT +CGTCCCGAACGTCCGGGGACGACCCTTTGAACTGCCTGAACGCTATTTCCATGACAACTC +CTGTTAAGGGCGTGCATCGCCGAGAACGGATCCGGTCGAACCGCTATCGAACGAACCACT +CCCCGTAGTAAACCACTGCGCCGCGATCCGCGCAATGAACTTGTTGGCCGCATCGACAAA +TGGCGTGTTGACGACTCCGGAAGTACCGACCCTCGTACTACCGATAGAGGTCGTAGGCGA +ACGCGCTTTTTCCGGACGCTTACCGGCGATCGACGGGATATCGACACGGACGCTGAAACG +GCTCTCCGTCGTGCCGACCGACCACGTGACGTTTTTCAACGTGACCACGGAAGACGCAGG +CGAACCGCCCGAGCCGAAGTTCTGCACGACTTGAATCGCAGTCACCAGATTGTCCATACA +ATCGACAAAAGCCCTTTGTTGCCGCTGATGTTGTACGCGTAATACTTGATGTTTCCTCCC +GAGCCGTCGAGCCGGTCGATATACCGTTTCACCCGAGCCGTTTCGAGCGCTAGACCGCGA +TACTCGAATGGCGACGGTGCGCCGCCGAGACCGTTCACGTCGCTGCTCGACGCCGCGTCA +CTTTCCTCGATCTGTAACTGGCTGAGGTCGAGGGTGAATGTGATTCCGGTCGCCAAAACG +AACGCGATCTGAAGCTTATCGTCCCTGTACGTCCCGAGTTGCCGCTGCTGCCGCAACGAG +CGTCGTGCTGACCGTCACGCTGCGCCCGCTGAACGCGTTGACGCCTTCGATGTTCTGGTA +AAGCTGCGGCGCCGACGATGCAGCCGTCGTCCGGTTGAACCGTAGCTTGTACCGGCGCGA +CGAGTCGATACACTTCGGTGCGGGCTCGGGGGTCGGAGTAACACGCGATACCGTGGTCGA +ACCGACCGTTCCGGAGATCGCGCGCCACATACCCGCCGTGTACTGGTCGGTCGCAGCCGC +GAGGTCGAACGGCGTGTCGACCTGCCACCAGTCGACGTTGCCGTCCACGAAGCGGTTCAG +GCCGGTAGTAGCCGGGAGGTAGCCGGGCTGAATGGTCGAGTTCGTCCAGTTTGCGCCGTT +GTTGCGGGGGTGCTGGCCGCTCGCCGACGACACCGCGAAGCCGATACGCATCGTGACGGG +CACGGTCGAGCCGCCTTGCGTGTCGTACGCCGACCCGTTGACCGGAGGACTGACGTTCAC +GCGGGTCCGCGTTCCCATCGAAGAGAGCGAGTTCGGCGTCCGCGCGCCAGACCCCGGCGA +GTCGATAGGCGTCGCGTAGTTGCACGCCTGCCCCGGACAGCCGACGAGGAACGCGTACAG +CGTGCCTGCGGTGAGGGCGACCGGCGTCGGTAAGTTGAAAGTGAAGTCCAGCGACCCCGC +CGTAGCGATCGTGACAGGGCTGCCGAACGTCGGTGCGCCGGTAAGCGTGCCGCTCGATGC +CGGGGCGACGGCTGCGTGCAACTGGACGCCGACCCTTCCTGCCGTTTGAAGCTGCGTCGT +CAACGAAGTGACTACGCAGTTCTGCGGGACCGTCAGCAGGTTGCCGTTCCAATTGTACGC +GCCGTTGTTGTAGCTCGTCGTATCGGCCGGGCCGACGACCGGACTGACAGGAACGCTAAC +ATCCGAGAGGCTGCTTGCGAGCGCCGGAGCCCCCGGAGCCGTAGTCCATGTCCGGTCTTC +ACGGAGGAACCGCGTAATGCCAGCGACGATCCCCGGATCGGGGACGAGACCCGCCGCATG +CGAACCACCGGGTGCGCCCATGACAGGCGGGAGCGGTGTGGTCGCCCATGTTTCATCCTC +GCACAGGAACCGGGTAGTGCCAGCGACGATACCCGGATCGGGGACGAGACCCGCCGCATG +CGAGCCACCGGATGCGCCCATGACTGGCGGGAGCGGTGTAGTCGCCCAGGTTGCATCCTC +GCGCAGGAACCGCGTAGTGCCAGCGACGATACCCGGATCGTGGACGAGACCCGCCGCATG +CGAACCACCGGATGCGCCCATGACAGGCGGGAGCGGTGTAGTCGCCCATGTTGCATCTTC +ACGGAGATACTTCGTCGTTCCTGCCGTTGCGCCCGGATCGGGGACGAGACCGGCCGCGTG +CGTTGACCCGCTCTTCACAAACGCACCGAGTGTTTGCCACGTAGCCGTCCCGCTGCCGCC +GCGCGTGCCGCCGCATGCGAACCACCGGATGCGCCCATGACAGGCGGGAGCGGTGTAGTC +GCCCATGTTGCATCTTCACGGAGATACTTCGTCGTTCCTGCCGTTGCGCCCGGATCGGGG +ACGAGACCGGCCGCGTGCGTTGACCCGCTCTTCACAAACGCACCGAGTGTTTGCCACGTA +GCCGTCCCGCTGCCGCCGCGCGTGTACCGTTGGCCGTCCTTGGGCGCTTCACCGACAACA +GACGCATTGACAAACTTCCCCTGCGATGCCAACCATGTGATCGCCTGCCCGTCAGTCAAT +GAGGTGAGTTTGACATCGCCCAGCCAGCGAAGCTGATCGTCGCTCGTGGGGGTAACGTCC +GGAGACGCGAAATCGATGAACACCTGGTCGGTGTACGGCCCCGCACCCGTGACAGTCAAT +GCCGTAGTCCGTGCACTGCCGTCGTCTGAATACTGGACGGTGAAATTCGACGGGCCGCCG +CTCAGATTGTCAGTCACCGCAGTCTGCCCACGCGCAACGGACTTCGCAGCGGGCAACTGG +TACCCGAGGAAAAGCTCAGCACCGGCAAGCGGAGCGCTGTTGGGGCGGTAGTAGGTTGCG +GTGTTACCGTCGAACGCGTTGTCCGGACCAAACGTCGTGTTTTGAGCCGAACCGGATGCC +GTGCCCCCGGTTGTTGCGATCTGCGCGCCATTCGTATCGATGAACCGCAGCTCGGCAACA +CGCATGCCGACGCCCCCGGTTTGCGCGGCCGAACAGTTGATGCGAACGCGTTGTCCGGAC +CAAACGTCGTGTTTTGAGCCGAACCGGATGCCGTGCCCCCGGTTGTTGCGATCTGCGCGC +CATTCGTATCGATGAACCGCAGCTCGGCAACACGCATGCCGACGCCCCCGGTTTGCGCGG +CCGAACAGTTGATGCGCCTGTACTTGTGAACCCTGTACGGATTGGTCTTCGTGAAGAAGC +TGGCCCATGTGCCATTCTGACGCATGTATTTGGTCCCATCGCTCGGCGCGTCCGCGATAA +CGGCCGTAATCGTCTGGCTCGTTCACTTGGCGCTCGCGGCGTTCCACGCGATGACCTGCT +TGTCGCTCTGCGATGCGACGGCTACATCGCTCAGGCCGACAAGCGTCGCGCTGCCGCCGG +CCGACGGCACAACCCACGTTCCATCTTCCCGGAGATACTTCGTAGTGCCGGCCGTTGCAC +CCGGATCGGGGACGAGGCCAGCCGCATGAGATGCACCCGATCCGACCATAGTCGACGGGT +AGGGTGGCACAGCCCATTACGCATCTTCACAGAGGTACTTCGTCGCGCCCGCCGCCGTGC +CCGGATCAGGGACGAGGCCGCCGGCATGCGATGAGCCGCTCGCGTCGAACGCGCCGAGCA +CGTTCCACGTCGCTTGGCCGCGCTTGTACTGGTCGGCGTTGTTCGATGCGTCCGGAATCC +CGCCGCCCCCGCTGATTGTCTTGTTGATCCACTTTCCGGATGCGGCGTCCCACGAAACGA +CCTGCTGGTCCAGTGGGTGGTCGCAACAGGAGTCCAACCCCCGTCTATCCGTGCGTACCC +GACGCCGTCCCTCGGTGCGTCGGGAACGCCTCCCTGCGCTGCCTGCCAAGCCGTGCCATT +CCACTGTACGCGGCCCGTGGAGCTGCTGAAAGCGGTCCCCCCGAGCTTCGGAGTGTAGAA +GGCCCACGCGCCGCCTAGGAAGGCCGCTACGTCGTCCCCGTGATTGGCCCAAGCTTCGGT +AGGCGCGGGGGACTTACCGACGATATAGCGATCGCCCTCGGTCGGTGACGACGGAGAGAC +CGTCAGCGTACTGTCGATCCTGACCATGGCCGACTGCGGGTTCCGGGAAGGTGTACGTAT +CGGCCGTAATGCCGGTCTGCTGCACGATCAGCGTGTTTTCTGAATCGTAGATGCGGATGT +TGTAGGTCACGCCGGTTTCCGGCCCGACGCGCACGTCTTCGTGGGCGACCAGTTTGTCTT +GCTGCTCGATGCGGTCTCGATGCGCCGATGTGAAGATCAGGTCCCGAAGGACGGCCGAGA +CTTCCGCGTAGCGCTGGCCGTTCAGCTTCAGATTGCCCGGCGGATATGGCAAGTTCTGCC +GCGCGACGATCTCGATTCTGCTCGTCGGAGCCGCGTTCGCCTGTAATACCGGAGATGTGG +TCTGCGTGCGGAACTGCACGGCGATTTGCATTCCTACGCTAAACTCGGACGGGTCTGCGC +CGAAGTAATCGTCGTAGACCCATACGGTATCGTTGCGAAGATGCGCGGCCGGGAGCGTGT +CGACGCAACCCCGTCGAATCGTTACCAGCTTCGTCCAGATGTCGTAGCTGACTACCTCGA +TGATCACGTCGACGGTAATCGCGGCCTTGCCCGGCTCGATGAAGTCGGTATCCTCGTTGT +CATCGAAGCGCAAAGTCGTATCGAACTGACCGAGAGGCTGCGACAAACCGACCAGCGGCG +TGAAGGCCGCCGTGTTGACCGTGCGATACGTGTTCGTGATGCCGGGATCGTCCCATACCT +GATACGACAGCGAGAAGATATTCGGCTTGTGCGCCACGGTGACAAACGTTCCGCTATCGG +CCGGGACCTGTGCCAGATCAGCTGGCGACAACTGGCGAACGAGTTCACGATACGTCGCCT +CGGTCGTGCGGTAGACGGCCGGGGCGACGGGTGTGCGGTTCGGCGGGACGTACTGATCCG +GCTCCGCTCCAACGTACGCCGTGGACAGCAGACCGAAGATATCCTGCACGGCCGTGATCT +GGAAAGACCCTTCCTCGTAGCGACCCGCCTGAATCTTGCCGGCGCGCAGGATCATGTTCT +CGATGCCGAGCTGCGGCACGCTGATCGAGAACACGTCGGTCGGCGCGAGCTTCGCGGCCC +GGCGATCCCGAAGATATCCTGCACGGCCGTGATCTGGAAAGACCCTTCCTCGTAGCGACC +CGCCTGAATCTTGCCGGCGCGCAGGATCATGTTCTCGATGCCGAGCTGCGGCACGCTGAT +CGAGAACACGTCGGTCGGCGCGAGCTTCGCGGCCCGGCGATCGAGCGTGAGCGTGAACCG +CTTCAACGGCGTGCCGTTCGACTTCAGGTCGCGCATCGCCACGCGCATCGCGAGGTCGGC +AGTCGGGATTGCCGGGTACGCCGTTGTGACGCTATACATCGCACCCACGGCTCGCATGTT +TCCGACGTTCTGCGCGCGGACCTGCTTGTCCTCGTCGGTGATTGGATCGTGGTACGTGAC +GATCTGCTCGTTGCGGCTCGTGTCGCCGACTTCAGGTCGCGCATCGCCACGCGCATCGCG +AGGTCGGCAGTCGGGATTGCCGGGTACGCCGTTGTGACGCTATACATCGCACCCACGGCT +CGCATGTTTCCGACGTTCTGCGCGCGGACCTGCTTGTCCTCGTCGGTGATTGGATCGTGG +TACGTGACGATCTGCTCGTTGCGGCTCGTGTCGCTCGAATTGCCGTCTTGCGAGATGCTC +AGCAGGCCGGACGTGTAGTCGAAATGCGGAATTGTCGCCGGGTCGTAGTCCGAGCGAATC +GGACGCAGCGTCCGCTTCGCGGTCTTGCGGTCGAAGTAGATGGCCCCGCCGATGTGATTG +AGAACCTGCTGCACGAACGCATCGAGGTCGTCTTGTGGGTTCCACCGAATGCAGAGGCCG +AAACACTCCGGGCAGAGCATGTTGGCTGCGTTGGGGAAGGACTGTTCGTCAATCAGCTCA +CGCGGAAATCCCCTGCCCCATTCGCGGTTCGTCGCGCATTCATAGATGATGTGCGCCGGG +TTCATCGCCTTGATGGTCTGGTTCGCCATCTGGATCCTCGCCTTCTCCGGATAGAAGACC +GGGCCGTCCCATCCTTGAATCGATCGACGCACGCGGGACTTCCACGCCTTCGGATACGGG +TTCATCTCGCACATGAGGCCGTCAACAAACACCGTGAAGACGCCCCGGAACGCCGGCACG +ATTCCGCCGAGCATCGCGGCCAGTCGCGGATTCGCTTGCTGGGTCGCCTCACCCTTCATG +ATGTCCGCGTTGCCTTGAACGCCGCCTTCCTTCTTGTCCCCGACGAACAGCTCGGGCGAG +TTGACGTAAATCTGACCGCTAGTCGAGACGCTGCCCGCCCACGCAGTAAGATCGCCCACG +GTGATCGCGACCAGTTCATCGACGGGGCCACGGCAAAGCGCCGCATGAATCCCGAAGTAG +TAGCGATACCCGATGACGGTATCTCCGCTTTTACCCCCGCCGCCCATTGCCGTTCTCCTT +GTAGACACGCAGTAAGATCGCCCACGGTGATCGCGACCAGTTCATCGACGGGGCCACGGC +AAAGCGCCGCATGAATCCCGAAGTAGTAGCGATACCCGATGACGGTATCTCCGCTTTTAC +CCCCGCCGCCCATTGCCGTTCTCCTTGTAGACTTCTTCCTTCACTCGTTCGAGCAGCGCG +CAAGTGATGTGCTGCGTGTGGCTGATCTTCAGGCCGTCGCGCAGCATGTCGCGAAACGAA +AGCCCTTGCGACTTGAACCACTCCCGAGCGCCGCGCTCGCACATGCCGGCTTTGAAGATG +TCCCGGATATAGATCGTCGGTTCGTTCACTTCTTCGCTCCCGCGGACTTGATCGGCGTCG +TGCGGAAATTGCCGAGACCTACGACCGTCCAATCGCTGCACCGGCAATCGCCGTACACGA +CGGCCTGCGGCGTGCCCTCCGTGGCCTGCGGGAAGTTGAAATACCCGAACCTCGCCGGGT +CCGGTTGCTGCGCTTTCGGGCCGAGCGCCGCCGACAGAAAGTACGACGCGACCATGAGCA +CGAGCCACGCGACAAACTGCATTTTTGTTCTCCTTAGAAGACAGGGTTTCCGTCGAACGG +GCTACGGCTGGGCATCCCGTTATACCCGCCGTTGTTAAGGTCGTTCCCGAACTTGTTCAT +ACAGACGGATGATACGCGAGCACAACCCGGATACATCACGACATTCATACCGATCGCCAG +TCGATCCGCAGTGCCCATGAGCGTAATGCGATTACCTACGTGCGTTTCGATGCCGTACTG +ATCCCACGACCCCGGCTCGCGCTCGAACTTCATGAGGCCGCCACTGAACCCCGGTGTGGC +CTTCGAACCCGCCTCGGCGCACTCGAACCAATCACCGCCCACGGCAGTGATAACGCCCTT +CGTGGCGAAGTTGTACCGATTGAGTTTGCAGTTCACGTCGTACACGAAATACGGGCAGCC +TTTCGTGTATGCGAGGCGCAGACCGCCGCGCTTGAACGTCATCGACAACTGCCGCCCGAC +GATCTGCGCGTTGATCAGAGACGTGCGACGCACATCGGACGCCGTGCCCGTCCACGCCAC +ATCCGCTTCGTTCTCCGGGTCGTTCTAGTGGTGTTCCCGGATCGTCAGGTAGATCGAATC +GGTTGGCGGCGTTCCGCGCCACTGCTTCACGATGTCCAGTGAAACCGCGCGGTCGAGCGT +GATCGAATCGGCCTACGCGTCGCCGCTTTGCGAGTAGCCGCCGTGCGCGATGATCGTCGC +AACGTACGTCCTGTTGTTCCACGGGATATCGCGATCAGCGTTCGTGTAGTAGTAGAACTT +GCTGCCGTACAGGAACTCAACGAGCAGAAGCGGTCGCCCGTTGAAGTTGCTCATGCCGAT +GTTATCGCAGATCATTCGAAAAGCCCTCCCCCGTTATATGGCTCTTGGTTGACTACGTGC +TTGGGAACAGAGATGTCCGCGTTAGGGGGGCGCGGCTTTCTGGCGGGATGGTCTAAGGGC +GAATGCACGGCCAGCGAGATCACCTACGACTGCATTTACATCAACGAGATTTTTGCTGCT +CAGGCGGCGGCCACAATGGCCCGGCTCGTAGCCGAGCGTTGTAGAGACACGCCGAATGAA +CCCGAGCCTTTCAACTGAACTAGTTCGCCTTTCCGCCATTTACGGAGGTATCACCATGAC +ACCCTCTGCCGCGAGAAAATCGAAGACGAAGTTTCCGGTGTTTTTGAACACGAACCATTC +TGTCTGCTTTGGATTCGGATAATACGATGGAACTCCGGTCCCCGGAAAATCGAAGACGAA +GTTTCCGGTGTTTTTGAACACGAACCATTCTGTCTGCTTTGGATTCGGATAATACGATGG +AACTCCGGTCCCCGGATTTGGGTTCCATCGATACGTCATATAGGGATACGCGCGCAGGCT +ATTCAGATAAATGCCGGTGTTCGGGATCGCAAGGTTATAGCAGGCGAAGACCAGCTCCTG +AACAATCGTCCCGTTCACATCACGTTGTCGCATCTGCACCTTAGCCGGTCATTGAACGGT +ATCGAGCAACGCGGCGGTAAAAAGGTGGCCACAAACGTTCGCCCACATTACGTCGCCTGC +CGGGTAATGTCCGCCTTCGACGGCAGTCGGATTCAGCACGTCGTTTGCTTGCGCCTTCAG +CTCGAAAATTTGAAGCGGGACTGCGCCGCAACGTGCATCGATATAAGAGCCCGCTTTTCC +ACCAAGCAACACGTCGATAGAGTTGATATCAGCTTGTATCAGGCCGCTTGCGATTGAGTT +GTCGAATGTGCGAACGATGCTCTGCATCCAGCTCCCATTTGGGTCAGCTTGGATGGCTGC +TGCATTCATGATACTCGCAGTCACGCCGAGCATACCTGCGACCATGGGCGGGTTGCAGTC +CACCCACCAGTGAATCGAACCGGTTGAGCTGGTCGTCTGCGCTTGTACGCTCGATGCGCT +CGTGATCGATTCTAGAATTGCAGCGCAGGCGGTTGCGAGCAGTGTTTCTGACGCGCTATC +GTCCTGCGCGCATTCAGTTAGGTCAGAGGTGAGCGACTTCGCCGCCGCGTACACGAGGCC +GCCCGTCAGGAGGGAATACAGAAGAGAAAAGATGTTGTACGCCAGAAAAACGCGAATCGC +CGCGTGCAACGTTGCGTCATCAAGCGGAGCCTAGTACGCGTACCGATCCGTGGTGATCCA +AGGGTCGGCGGATCGGCAGTCGCAATTCTTGTTCGTCATTTTTCTTTCCCCGTGGTTTGA +TACGACGGATTGTCACGGCAATGAATAACCTTGTCAACAGGCGATATCGCTGAAACGTAC +GATTTTCCCAACACTGAGGTTATCGCCGAGTTCCTTGAATCGTCAAGAGCATATATTCCC +GCGTTTAATTGTTCGAATCGTTTATCGCCCCAAGCGTGCTCTGCCGCGCCGCCTCGGCTT +GGTCCGGCGGGTACCCGTTGGCGACCATGATGTCGTACGTTGCGTTGAGGTTCGCTGGCT +CAGTTTTTGGATACTCCCCTGCAAGCGGATCGACCGGCGGGCGGCCGTTCGTTCGTACGT +CGCCCCATGCGCCGCATTCGCTGCCGCATATACACGCGACGGGCGTTTGCGTCGTATGCG +TATAGCGCGTGATGTCGTAATTCGTCGCTACACGATTTTCAGGCGTGCTCTGGAACGTGA +CAACTGCCGAGCTGACGCCCTTCGTGTCGGTCATGTGGTTGATCTCTACGCGGTCTTGAT +TAAGTCGCGCGAACGTCATGAACGTGACGCGCTTCAGGTCCGAGGCGAATACGACTTGCT +TGAAAGCCGCGTCCACGGTGACGATCTCGTAGCCCGTAGTCTGGTCGAGCGTTACCCCCA +ATACGCGACGATATATTGCCGGCACTGTAGACCGACGCGGGTCGAGAATGATCTCCTGCT +GCCCGTCGGGAAGGGTCGAGAAGAAGTCAGCCAAACCGCTGCGCTTGATGGTGATCGTCG +TATGACCTGACTAGATCGGTTTGGCGAGCTGCATATCGGCCGCATGGGACGGGAGCCAAA +AAGGCGTGACGCGCCCGCGCAGTGCGTACAGCAATTCGCGCAGGTCGTCATTTTGCTGGC +GGCCGTGCGTGATGAAAGCAAACTGATGCGCGAAGAGCTGGATACCTGCGGTATCTCCGC +GCTTCGAAATGCCGTATCCGGAATCGAGCACGTCCAGTAGCCGGGAAGACTGAACCGTCA +GGTCGCTCGTGTCGTCCGGGCGAAGACGAAACACCGGATAGCCGCGATAGATGTCAGTCC +ATGCGGCTTCCGGGTAATCGTTCGTTTCCGTGACCTGCCAGTTGGGTCGCTCGTGTCGTC +CGGGCGAAGACGAAACACCGGATAGCCGCGATAGATGTCAGTCCATGCGGCTTCCGGGTA +ATCGTTCGTTTCCGTGACCTGCCAGTTGATCGCGTAGACGGCAGCGCGACCCGCCTTTCG +GGTCATCTGCGGATGGTCGGTCAGCATGGCTACCTGAATCGGAAGTAACTTCGTGCCTTT +CGGCCATGCCTGCACGAGGCCCTGATCGAGGGTGATAGTCGTAGCGGTCATATCGGTTAT +CAGCCGAACCTCGTAGTCGAATGAAGTCTGACCACGTAAAAAGACGAGGCCGCCCTTCTT +CAGTTCGGACGTGGTCGTATCCTCGACGGACACGACGGTATCTCCGGCCTGCGCAGAAGC +CGTCAGCGGGTTCAAATCCCACGGAAGAGGGACATTCCAGCTCGTTCCGCCGCCGGCCGT +CAGCGCGGCGTTCAGGCGCGTGCGCTCGGCATCGATCACGAGCACGGACGTTTCAAAGAA +CCGGCGCGGCGATATCCGGAGCGAACGCCGCTGCTCGGCCGTCATATCCGATTGCTGCAC +GCTCGTCGGCCATTCGAGCGCTTCGAGTACGCCGTCGGACCATTCGGTCGCGGAAGACCA +GACGGGAAGATTGATGTTCGGCATTACTTGATTCCCGATGCTTGGCGTGCGGCTACGGCG +TTCTGCCGCAGGTAGGTTGTGATGACGGTATCGCCTGCCGCCGACGCCATCGCATCGGGC +ACGAAGTTCGGATCGGAGATCAGCATGTTCCGGATCGTCATCGGCTGCTTGGCGGCCTGC +GCTGCATTCTTCGCGGTCACGGCGTTCTGCCGCAGGTAGGTTGTGATGACGGTATCGCCT +GCCGCCGACGCCATCGCATCGGGCACGAAGTTCGGATCGGAGATCAGCATGTTCCGGATC +GTCATCGGCTGCTTGGCGGCCTGCGCTGCATTCTTCGCGGTCTGGTTCAGGATGTTGCGC +GGATTGTCCTTCGCGAGTACTTCCTCGCCCTTCTGAAGGATCGCCGCCTGTTCATCAGCC +TTCAGGCCGACAACTGTGCCGCTGCGGTAGCGCTGCGCGTTCGCAACCCAGCTCGCCGAC +GCACTGCGCGACATGCCGCCCGGCTGACCGACGACTGCACCGGAGTGCGCAATGGCAGTA +GGCAAGGATGCGCCAAGGCCCCACGTCCCGAGGCCGGTTCCTACGGCAGCCGGGGCAGCC +GACGCAGCGCCGCCGAACCGATCGAGCAGCGCCATCGCCGCGCACGTCGCCATGATCTGC +ATGATGACGCTCGCCATCGGGCGCAGGAAGTGCGCAGCGAACTGTGAGACCGATTGCCCG +ACGTTCTTGAATGCGTCTGACCATTTCTGCGTGCCGTTGGCGGCAGCGAGAAGCTGGTCA +ACGACGTTCGTCATCATGCTGTCAATCCTCGGCGCGAAACCGGACGTGAACGTATCGCGA +ATCTTCGCCATGTCCTTGTCGCACGTACTGCGTCTGCGTGCTGATTTCCTTCAGCTTTGC +ATTGAGCGCATCGAGCTTGGAACCGGAGATGTCGCTGGGCTTCGGCCTTCGTAACGAGCA +GCTTCTGCAGCTCAGAGACCATGCGCTGAATCTGCGGGCCGCTCTCCGTGTACGGGGCCT +TCATTTTTTGGTTCGCCTCTTCCTGCGTAATCGCGCCGAGCTGCACGAGGTTGTTGTTCA +TCGTGACGGCCGAGTTCCGCTCGTTGAGCGGCTTGTTCGTCTCGGTCATCTGTTGGTTGA +ATACGTCGAGACCGCCCTTCGCCGCCGCAGATGCGGAGCCAGTGGCTGAACCTTTGCCGA +CGCGTGTCATATTCTGCACGAAGGCGTCGATCTTCGCGTCCGGGATGCCCGTGCCTCGCA +CGCTGTTTGCAAACGCCGCTGCATCTTTCGCCATCTGTGCAAGTTTCGGTTGCGATCGTT +GGGTCTGCGTGGCGATCTGTTTGAACCCATCCACTGCCGACAGTGTGCGGGCTTTGACTT +GTTCGAGCACGTCTTTCTGAAAGTCCGCTCGCGCCTTCAGCACGTCGTTGACTTGTTCCT +CTTTCTTCTTCAGTTGCACAGTGTTGAACGTAAGCGTTTCTTGCTGGATAGCTTGTTTCT +TGATTTCCTTGATCTGCGCCTGGATCGCGGCGATAGGCTGGCCGTCGACCGTCGTGCCGC +CGATCTTCTGGTACTTCGCGATCGTGTCGTAAATGTCCTTGAACGTGCGCTCGACAGCCT +TCAAACGCAGGTCAAGGTTGTCCTTGTACTGCGACTCGACTTGCTTCCAGAGCGAATTCA +GTTTCTCCGACCGAGACACTTCCATGTTGTACCGCCTGTCGGAGTTCCTGTCCGTCTTGT +TCGGGTACGCGATGTCGTACAAGTCGCCGGACGTATCGGTCAGCGGTGTCGATCGGGGCA +GCGTCGTTGCAAGGCTCGCGCCCTGTCTACGGAGGTCATTCTGATACAGCACGTCGAACG +CAGCCTCGTTGTCGGCCAGTGCTTTATCGCGCTCCGCGCGAATCGAAGCGAGGTTGCTCT +GCGCGAGTGTTTTGGCTTGCTCCATCCCGGTCATAGCGCCGTCCGTGTTGCCCTGCGGAG +CTGTTCTGCGACGTTATCGAGGCCGAGGAATTTCGCCATGCTGCGCAGGCCGCCGAGGAA +GCCGTTCTTCAGAGTCTGGACTTTCTTCAACGCCTTATCGAAGAAGTCGACGACAAAATC +GCTCAACTGCGCAGCAAGCACGAGAATGCCGTACTTGAGGTTGATCCATGCCTCGTAGAT +CGATTCGGCCGCCGTAGTGCCGACCAGTCTCGCAGTCGCGAAATTCTCGCCAACGTGCAG +CTCGTGGATGACTGGCGCAACCTCGTGAAGTTCAGCTCGACGTGGTTCATCGCAGTTGGC +GTCGTGTTGCAGAGCTGGATCGAGGTCGCACCGGATACCCTGCTCCATGTGTGGGTCCTG +ATGCCGGACGACATGAAGGCGCTGATCCCGCCGCAGTACGCGCGCTTCGTCCCGGAATCT +TCCCGATCTGCCATCCCGTGAACGCAGCGGTCAGGACGAGGAAGATTTTGTTGATTGCCG +CAAGCGCGGCGTTCAACCGATCGGCGTCTTCCCGATCTGCCATCCCGTGAACGCAGCGGT +CAGGACGAGGAAGATTTTGTTGATTGCCGCAAGCGCGGCGTTCAACCGATCGGCGGCCAC +GGAGCCGGTCCCCATGGACGCGCCGGCTGCATCGCCGCCCGGTGCAGCGGCCGCCCCGGA +CGCACCGACCGCCGCCATAGCGAAGGCCGCTTGTGTGAGCTGGATCGTGAAAGCCCCGAT +CAACGCCATCACCTTCACGCCGAGCACGAGGCCGATCACGTCGCCCACGGCGTTGATATT +CTTGATGACTGCTTCGAGGATGTTCAGGACGACCCATCACCTTCACGCCGAGCACGAGGC +CGATCACGTCGCCCACGGCGTTGATATTCTTGATGACTGCTTCGAGGATGTTCAGGACGA +CCGGGAACGCGTCGGAAAAGTTTCTCGCGAACTGCTTGCCGTCGTCACTACGAAGTAACT +TCGTCATGTCGACGGCGAACTTGGTCCACGCGTCCGCTAAGCCCATATCGGCGATCGTCT +TCCGGAACTCGTAGAACGCGTTGTACATGCGAGCCTCGGCGGCCTGCATATTATTGACGG +CCATTGGAAGCTGCTTTCCATACTCATCGCCGAGCTGTTGCGCGAAGCCGAGAAGCTCCT +TCACCGAAACGCTGCCCTCTTTGAGCCGCTTGTTCAATTCCGGCAGACTGATGTTCATGC +CCTTCGCGAAAAGCGCGAATGCGGCGGGCAGCCGATCGCCGAGCTGGCCGCGCAGTTCTT +CCGCCTGCACCTGCCCTTTCGACATCATCTGTTCGATCGCGCGAAGCCGAGAAGCTCCTT +CACCGAAACGCTGCCCTCTTTGAGCCGCTTGTTCAATTCCGGCAGACTGATGTTCATGCC +CTTCGCGAAAAGCGCGAATGCGGCGGGCAGCCGATCGCCGAGCTGGCCGCGCAGTTCTTC +CGCCTGCACCTGCCCTTTCGACATCATCTGTTCGATCGCGAGTAACGTGCCCTGCATATC +ATCCGCGCTCATGAGCAGTACACGGACGGTCTCGGCCACTTTCTCGAAGACAAACCGCGT +CTGGTTCGTCGTTGCGCCGGCTGCCTTGGCCGACACGGCGAACTTGCCGTACGACGCGGC +GAGATCATCAATCCGGATGCCGAGGCGTTCGGCTTGCGCCTGCACGTATTGGTATTCCCG +CGTCTGGTTCGTCGTTGCGCCGGCTGCCTTGGCCGACACGGCGAACTTGCCGTACGACGC +GGCGAGATCATCAATCCGGATGCCGAGGCGTTCGGCTTGCGCCTGCACGTATTGGTATTC +CTGCGCAACGACTTTCGGGTCGTTCGTTCCAGCGACCACGGCGAGTACGGATTCGTTCAA +GTTGAACTTCCGCATTGGATCGAGTGCGCCTGCCGCAAGGTTGATCGCGCCCTCCGCGCC +GACGTACGCGGTGGCGAGCGCGATCAGCTGGCCGCGCACGCGCTGATATCACGACAGCGA +TTCGCGCTTCCCCGTCGTGATGCGGTCAAGCAGCGAAACGGTCTTCGCCGCTTCCGCATC +GTGTCTTTGCATCGCGGCGGTCGTTGCTCGAATGCCGTTCGCCTGCTGAGACTGCGCTGC +GAGATCCTTCGACGCGGCGGCAGCTTCGGCCTGAGCGGCAGCCCGAATACGAGCGAGGCG +AGCATCAAAAGCCTTGGCGTTCGCATCGTTCGCCGCAGCCTGCGCAGCAGCCTCTCTGGC +GTCCTGGTCGCGCCCGGCCGCTACGATGGCAGCCCAGGGGGCCCGCGCGCGTTCCTGTCG +ACGCGCTGGGTGAGTCGTTCGAAGTCCCGGCCACCGCCGGCCGCCGCAGCAGTAAGCTTG +TCGAGTTCACTGGCGGTCGATCGAGTCGGCGGCCCGGCGTTGAGCGCATCACGCGCGAAC +ATCTGGTACGCGATGGCCGCGCCCTCGACGGACCTCTTATGGCGATCGAGGTTTTCGTTT +GCGGTATTGAACGCCTGCGACGCCGCCCCGGCTCGCGTCTTCGTCTGATCGAGCGCATCA +GCAGCGCCTGACATGGCTTTTTGTACGGCGTCAGCAGCCTTGGAGAGATGCTTCTGCTGA +TCGGAGATGGAGGCGGCCTCTTTGCCGAGACTGTCCGTCCCTGCGGTTGCGGCCTTCGCC +TGTTTGACTTGGTCGGCGAGAGACGAAGTAGCTTCGTCAATCGCCTTCTTAGCGTCCTTC +ATCGCCTGCGGCGACATGTCCTTGGCCCGGATGATGAGGTCGACTTCCTTCTGGTTATTC +GTTGCCCTCTCGGAGGCTCCTAACTCTCTCGTTCAGGGCTTTCACGTCCCCGGACCAGAC +GGCGAAGATTGCCGCGTAAGTTAGAAGCGCTTCGGTAGCAATCAGGCCGTTGATCCGTTG +ACGCGAGATTCTACTCTCATTCCATAGTACGCTCGTTCAGGGCTTTCACGTCCCCGGACC +AGACGGCGAAGATTGCCGCGTAAGTTAGAAGCGCTTCGGTAGCAATCAGGCCGTTGATCC +GTTGACGCGAGATTCTACTCTCATTCCATAGTACGGCGAGGGGGTAGTCCCACGTGTCCG +GGTGTCCTTCGGCCATCAAGAGGCTGGCGTCGCGACACAGTCCGAGATACCACTTATCGA +ACCGCGACGGTTTGCAATCCGTCAACGGGTTCTCTTCGGGATCAAGCCTTTCGTGATGCC +CCGGAGCGCCCCCAGCCGATTAAAGAACTCTTTTAGGCCGCCTGCGTCCTCGAACGTGTT +CTTCCGGAGAGCCGTCAATGCTTCGATCTGCACCGAGAAGGACAGATTCGTTGCAAACAC +ATCTGCCAGTGCTTCGAGCTGCTCCTCGTAGTCCTCGGCTTTCCGGTCTGCCTCGTCGCA +CGCGAGCGCGCTCATCTTCCCGACCAGTTCCGGGGCGTCACGCGTCAGCATCTGGATGAG +AATGTATCCCGACTGGTTCGTGAATACATCGGTCGTGTGGGCGGAATACGCTTCCATAAG +CGTATCGATATCTTTCAGATGTTTGTCCACGAGCTGCGCCACATCGGTCAACGAGAGACC +CAGCACGCGCAGGGTCTCTTCGCCGACGGGGATCGTGGTGCGCCGTGCTTTGTAGTTACG +GCATCCCATTTCCCGGTTCTCCTTACATCGGCCGGCCGTCGAGGTACACGCGCTCCGTCG +CCGAGCCCTTCTCCAGTACTTCGAGCTTGAACTGGAGCTGCTGCCATGCGTCGCCCTTCA +ACTGGAAGTTGCCGTCAGCGGTGACCTTCGTGTACGGTATGAAGTAGTTGAGCGACGGGC +CGTACGCGTTGTGCTAGATGAAGCGGAACGCACCCATGATCTGGTCGCCGGCCGACACGA +CCTGATCGTAGGTATCCGCCGCCAGCTTGTACGTCACCGAGATGGGCTTCGTGTCGGTGA +AGTCGGCTGCATCCGGCTTGACTTGGAAGCGGCCGCTCTTTAGGACGATGTTGAAGTTCG +TGAGCGGGATTTCGGCCGACGTGGCGTCCGTCGTCTTTGCGTCGAAATCGGTGACAGCGC +CGACGCCCGCGATATTCGCCGGCGAGACGCCGAGTTGATACCATGCGCCCGGCGTGACGA +TGATGGTTTCCGGTGCAAACGGCGACGCGCTGGCGGCTTGCGTGACCCTCGCCTTGCTGC +CGGTGAACCAGAGCGCGAGGTTGTCCGTCGGGATGTTGTCGACCTGAAACGTCATCGTCA +CGTCCTATTGCAACGTGATGGTGATGTCCTTCACCTTCATCCCCTCGTCGGAGTCGAAGT +GGTCGAGCATCGTGCTAGCGACGGCCAGTTGGAGCGACGGCGAGTAGCCGAAGTACAGTT +CGCCGGTCGTGTTGAACGTGCCAGGAGCGAACTTATCGAAATGGCACTTACCCCGGCCAA +GGCTTTGATCTTGCGGCATCGTGAATCTCCTGTGGTGGATGAAAAGTTAAGGCCGATACG +GCAAAAGGTCGTACGGGTCCGTGGTGTTGTTCGCGATCTTCAGGTTCAACGGCAGGTAGA +AGTACGAACGTCCCGAAGCACCTTCTGCGGGCGCACGAAACACGCCGGGGCCTTCGCGCA +TGCCATCAATGAGGTTTTCGAGCATGTAGACGGACGGATATTGAGGGTTCCCCGACGAGC +TGTCAATGGCGATCAGTTCGCCGAGGCGCACCTGCACGTCCGCCATAAGGCGATACGCTT +CATCGGTCGGGTTCTTGTCCCCTTCAGCATAATGAGGTTTTCGAGCATGTAGACGGACGG +ATATTGAGGGTTCCCCGACGAGCTGTCAATGGCGATCAGTTCGCCGAGGCGCACCTGCAC +GTCCGCCATAAGGCGATACGCTTCATCGGTCGGGTTCTTGTCCCCTTCAGCATGGTTGAC +CCAGCCCTGTACCAGAAGCAGCCAGTCATCCGATTGCGCCTGCCCGTTCTCGTCGGCATC +GAGGCCGTAATCGGGTCGTTGCGCTTCGAGGATCGACTCGGCAGGGGCAGTCGTCTCCGC +GCCGAATTGCACTCGGTTTCGATAGATGCCCGAAGAAAGGCCGAACTGAAAACCGTTCGT +CGGCGTGACGCCTTCCAGATGGGCGGTGAGCTTTTTCAGGATCACCAGTTTTTTAGGATC +GCGCTGCATGCTTTACTCCGTTCTACCTGTCCTCGGTCAGGGTCTCGCCGGCTCGCAGAC +GCACCACAAAGCCGTGCTTGAACTGCGTGGTGCAGCAGCCTTCGCGGGCACGCCGGTGTT +CATCGATCGTTTGGTCGATACCGCACGCTCGTCGCTGTAACGAGCGCCAGCAAGAAAACC +CTGTCCGGGCTTGACCACGACCGAGACGCCGCCCTTGCGCGTCGATTTAGTCGTCTGTCC +CGGTTCGGCCAACCGGGCGAGCGACGTAGGACGCTGGTGCGCGCTGACCACAGCTTCGAG +GTCGTTGCGCGTCGCCTTCTTGGTAACGCCAAGCCGGCTATCATCTTTCAGGTAGTTGTC +AGGGAAATTGACTTGCTCGCCGATCTCGGTGCGGGCGAGCGGGAGGGCCGTACGCTGCGC +GGTCTGATTGATCGCGATCATCGCGGCTTGTTGCGCGTCGCCTTCTTGGTAACGCCAAGC +CGGCTATCATCTTTCAGGTAGTTGTCAGGGAAATTGACTTGCTCGCCGATCTCGGTGCGG +GCGAGCGGGAGGGCCGTACGCTGCGCGGTCTGATTGATCGCGATCATCGCGGCTTGTTGC +GAAATGTCGGGAAGGCGGTTCACGTAGTCCCGGAACTCCCCGAGTCCTTCAGCGACGATT +TGGATGCTCATTCTGGCCCTCGTCAGGGCCGGACGCGCTCAACCGACCACTTGATGTCTA +CGAAATTGTCCGTGTCGTCCTCGGCATCGGGGCGAAACGTTAAACCGTAATCCGGTAACC +TCACCGAGCCGTCGCGCTGCAATGTGATGCCGAGTGAAGTTACTTCCGGTGTGTTGAACA +CCAGATAGTTGATGCCCTCGACCATGCGTGCGTACCCTTCGCGGTCGAGATCACCAACGA +GCGCCATCGCCGGGGCGTCTTGGACCTCGACGACGTGGCGTTGCAGGAATTCCTTCCCGT +GACGCTCGTGCAGATGCTCGATCTCGTCGTCGGTGAAATCGGACGGCTTGCCCGGCGCGG +CGTGAACGATCTGCCCGTCGCGGGTGGTGATGACGGTGTGCTTCGGAACGCGCTTCGGCA +CGATATTGCTCCTGGTGATTCAGATGAGAAGCCAGCCCCGAAGGGCCGGCCGATGACCTA +CGCTACACGGGTCGCGTTGTGCTTACGTGACCATCATGCGGAAGGAAGCGTTCGGCTGGG +CCGGGACCATCAGCGGCGCTCTCTCCGTCAGGAGCATCGCCACGGACCGGTCTTGTTCTT +CCCACATCTTCGGGAACATCCGGGTCGGCACGAGACCGTTCTTGAAGTCCATGATCGCGC +CGAAGCACTGTGTGCCTTGGAGACCCGGACCCGTCCCGACCACGTAGTACGAGCCGAGGA +TTTCCGGTTCGGTGTAGTCGTCGCCGGTATAAGTGTCGTGGTACGTGTAGAGTTCCAGCG +TACCCATGCCGTTGTAGCCGTCGATGGTGCCTTGATTCTGAACCGGCGAACCGTCGTCCA +GTCGCGAGCGGCTGAAGTCGGACGAGCTGCCCTTATAGAACAGGTTCAGCAGCTCGACGA +CGGCGGGTTTCTGCGAGAACAGCGACCAGGCGTCGAGGCCCATCGTCAGTCGTGTGATCG +TGCTGTTCGACTTCTTCCACGTCGTCGTGCGCATCGTTTGGATGTTCCCCAGCGGATCGG +ACGCGGCCTGATCCCACGCTGCGCCGCCCGTCAGTTGCACGGTGAGCGCCGGATCGCGGC +CGAAGTCCACGCGTGGCATCGGGAACGCTTCGCCCACCACGTCCGCGTAGCCGTAGATCG +TCGCCATTGCGCACATCCATTTGGTCCGGTTCTCGATGCGCTGGCGCTGTTCGAGCTGCG +AATCCGCGACGACCGCTTGGAAGCGCTCCTTCAACGACATGCCGCCGATAATCGGCTGCT +CGCCGGCACGACGCTTGAACGTACGGTTCGGGTTGATAACGTCCTTGGGCTTCACATGGG +CCGGACTGAACGTCTTCGTCGTGTATCCACGAGCAGCGATCACGCGGCCTTGCACGTTCG +GCCCGACGAACGGGGCGAGCTTCTTGTCCTTGAAGACGAGGTCGAACAGAATCTCGTCCG +TGTCGAACGTGATCTCGTTCGGGTAGAAACCCTGCCAGTACATCGACCGCACCGGGCCGG +ACTGAATCACGTCAGCAAGGGTGAGGGTATCTAAAATTTCCATCTTTGTTCTCCGAGTTG +TACTGGCGTTCTTCGAACGTATCGGCGGCGGCGTCCCACACCAGTACGGCATGGTTGAAA +ACACCTCCGACGAAGACCAGGTGCAAAACCGTAGCCGCGCCGGCCGCCTTCGGCTGCGCC +GAAATGCCGTACGCCTTCTGCGAGCCGTCCGAGGCGGCCGGGTTCCACGGCACGAGCAGG +CCGCAGACGAGCGCGACGACACTGTACTTTTCGAGGACCGTGACAGCAGCCACGTTCGCC +CGCGTCGTCACGATATCGGCTTCGCCCGCATAGAGCTGTTCCGGGATGTACGACCCTTCG +GTGTCGTTGCCGGCGAGATCACGAGCGATCCTTTTCTTCTCCTAGCTAGGTTGGAGGATT +GTTGCTGTATTCCGGCCGGAATACCGATTACTTCTTCTGCTGGATCAGGTCCTTGCGGCC +CGTCGGCTTCGCGAACGACCCGAGCAGCACGTTGCCGCCCTTGTTGCCTTCAGCATCGTT +GCCCTTGCCGCCGGCCGGGTCTGCGCCGACTTCCGTGTTGCTGCTGGAGTCCATCGCCTT +GTGGAACGCCATGGCGTTCTTGCTCGTATCGGCCGGATCGGAAGTAACTTCCAGTGCGGC +GGCAGCGAGCATCACCCTCGCGTCGTCAGCGGACATCTCGGTGATCAGTGCGATGTGGTG +TGCCAGTTTCGGTTTAACCTTCGCTTCTTCACAGTTCAGGATGCCTGCGTGGCGCACGCG +GTCGGCCTTGATAGCAGCACGGCGTTTGGCGGCCAGTTGTTCTTCGGTCAGTTCCATCTT +CATACTCTCCATGTGGACTTCGGTTTCGGATGTCGAACCGGAAAGCTCGTTGAAAAACGC +AGCGACAGCATCTATCGGTTTTGCCACCGCATCAATCAGCCCGAGGTTCAGCTCATCGTC +TGCCCGGTACGTCTGAGCCTGCGTATCGCGAACTTTCTGGCTGTCCATCCCACGGTTGCG +TGCAACCAGTGAGGCGAATTCGTCGTACGTGGCGTTCACGTCGGCCTGAATGGTGTCCTT +CACTTCTTTGCTCAACGCCTCGTAGGGATTGCCGTCGACCTTGTGGTCGCCGGCATGGAT +GAAAGTGATCTTGATGCCCATGTCATCGAGCATCTCGGACATATCGTCGTGCAGCGGGAC +TACCCCGATGCTGCCCGCCCCTCCCGAGGGCGTCGAGACCACCTTCGTTGCGGCGGAAGC +GATGGCGTAGGCGGCCGAGTAGCAGTTCGAATCGATGACGGCCATTATGGGCTTTTCCTT +CCGCGCTGCGTAGATGTCGTCGGCCAACTCGACGCAACCCGCTGCTTCACCGCCGTAGGA +ATTGACATTGAGAACGATGCCTTCGACATCATCATCCGCGAAAGCGGCGTTCAGTCGTGC +CCGTACGAAGTTGTATCCCGTGAGATAGCCGAAGCTGTAGTTGAACCGGTTAATCATTGT +TCCTTGTAGCGGGATGATAGCAAGCCCGTTGGAAAAAGCAAACGGTTTGTTGTCGGCCGC +GCGCTGAAAGCCATATGCCTTTGCGAGTTGCGTGCGCTGGACCTTCATGAAGTCGCCGTA +TTCGAGCGCGTTATCGACCGCCGCGAGCTGCTTCATGTCCTGTACGAGGCCGGCGTAATG +CGCGGCGACCATCTGCCGGCGCAGGTTGAACCGGTTGATTGTGATGTGTGCGTCGCGTCG +TGCCATCTTCGTTCCCCTTGTTGACTGGTTTGCGCAACAGCCGGGTCTTCGGCAATGCCG +GTTGCTGCGTCGCGTCCGTCGCCGAGCGAGCGCTTCGTGCTCAGATTGAAAGTGAGACAG +TACTTCTTCAGCAGGGCATCCTCGCGGGCGCGCTGCGCGAAGCTCTTTCGTAAGTCTCCG +CCGGGGCGCGAGATTGCGCTCTTAAAGGTCGAGAGGCCGGCATCGATCTGCATCGCGGCT +GCCTGCGTTTCCTCCAGTTGATTGATCTGGCCTTGCGACGCGCCGATCTACTCGCATTTC +GACAGCGCTTCCTTCATCAGCGGCCGATAGAACAGGTCCCGCGTCTGGCCCGGCGGCATC +GGGACGTCACCAGCCGCGATAGCCTCTTCGAGCCAAAGCGTGAAGAACTCGGTCGCGAGG +TGGTCGGCGCACATCTTCTTGCGCGCTTCGAGGAAGCGCCGCGTCATCGCGATGCCGGCT +TGGATGCTCGAATAGTTCGCCTTGCTAAAGTCCCGCGTGAACCCTTCGTAGCTCATCCCG +AACGCCGACGCCAGATGCCGGTTGAGCGACGCCTCGAATTCGCTACCGACGCCGCCCGGC +GTACCCATCGGCTTCAGGTTCAGCTTCGTGCCGGGAAACAGATGCGGAATCTTCGCGCCG +TCGATCTGGATGTTGTTCGCACCCCCGACGTACGCCTTCAGCGCGTCCATGTACTTCCCG +AAGATGCCAACCATGTCGGCATTCGACGAACAGCCGGACATCTGCGAATGGATGAACTCG +GGCGGCAGCTCGGACTCGATAGCGGCCGCGTACGACGCGTTGATGACGGCGTTTTGAAGC +GACATTTCCTTGAAACGCTTCGCCATGTGCATGCCCTTCAGGCCGGACACGGTATCGGCA +ATGCCGCGCGACTGATCTGGTTCGCGCGGTTCGAGGATGTGGATGACCTGACGACGGCCC +CACGGCGTCGATTGCTGTACCAACTTCCATTTGTACATGTCCGCGGCTATCTGGCACAGG +TCGCCGGGGTGCGCGACCTGAATCCAGTAGCCCTGCGGCCGGCCGCGCTTGTCGTACTGC +ACGCCACGTCGAAGCGTGGGCGTATCGACTTGCTGGTACGGGTTCGACAGGCGGTCGGTC +GATACCATCTGGAAGCAGGTCGCGTACGGCCGGTTCGCCGCGCGGTCCCCCTCGGCTGTC +GCCAGCACCTCGCCTGTTTTCACATAGCCGACTACGCCAAGACGGATCAGACCGGTGAAG +GTAGAGATCGCAGCATTGTCGATGTAGCAGGCGAGGGATTCCGCGTACAGCTCGAACTTC +GCTTCAATGATGGTCTGGTATTCCTCGGTCCATTCCTCTGTCGAGACGGGGATGACCTTG +ATGTCGGGCATCGAGTTGAGCCGGTGCTGCGCGCCCGCGATGCTGTCGCGCAGTTAGCCG +ACCGCTCCGTTCGTGAAGCCGTCGTTGTCGGCCATGTCCCGGCCGCGCGCGTCGGCGATC +CGCTTCAGCGGGTTGATGAGGGCATCCGGCGAGCGAAGGCTGGGGTTCCACGACACGGTC +TCTCGGGAGAGCCGCGACGCGCCTTCAAGTCCGCTCGAGATGTTGGCGTCCGACAGCGTC +GCCATGCTCGACGCCGGGATTTGGACCTCGGCCCAGCCGGAATTCTTCCGCGCGTACTGC +TTGCCGTCTGCCGGCGCTTCGGGGATACCCGAGCCCGCCGCCAAGCGAAGCCGACTGTTC +CGGGCGACCGGAAGTAACTTCGGACAGTTTGCGTACGGTAACTTTGTTCATGGTCGGAAG +GTGAACTGCAGGGGGCCATTGGAACGACCGCCGCCGCACGGGCCGCAGTCATCGCACTGC +GCTTCGAGCTGGCGGAGGTAGGTCACGAGGGCCTGCTGATCCGCCGACATGAATTCTACG +CATTCGCCATTCTGGTCCATGATCACGCGGGCCGAGCGGCCGGTCAGCAGCTTGTGGTAC +GCGTCGCGGCGCCGCCGCGAGGTACTGCCGGCAGGTTGCATCATCGAGACAGAGCATTCG +GTTTCTCCGGTAGTGGGTCACACCAGCGCGGCGGCGATTTTCGCGAGATCATACTCTTCG +CTTGGCTTTTCCGCAAATCTCTGTTCGCTGGCATCGGCAACGAGGGTGTTCTTGTCCCAC +TCTTCGGCCCAGCTCGGGGGCGACGACCAGTCGAACTTCTCGGTCAGCAGGAGCACCGAT +GCGTTCGCCCCGAGGCAGTAGTAGAGCAAGTCCCACGACCCATTACGCTTGGCCGACGTG +GCGACCCATCCCTTGTCCGTGCGCCGCTCGGAGACGAGCTGGACGTAGTAGCTGTCAGGC +AGGCATTCGGGGAAGTGAACCATGCCGCTATCGGGCGTCACCACTTCAAGCCGGCCGAGC +GCAGTGTCTTCCAATAGGTTCGAGTTCAGGAACAGAGCCGGTACGTCTCCGCGCGCAGCA +GACCATTTGTCCTTGTGGTTAGCGTCCGGGTAGGCGACTCGCGTGCGCGGATGCACCGGC +TTAGGCTCGCCCTTGATGAGATGGAAACGGCCGTGCAGACCTTCTTCGCGAAGCTGCCGG +TAGAAGTTGTACGCCATCCCCGTAACACCTTCCCGGCCTCCGTAATCGCAGAAGGTCATT +TTGAGCTGCATCACCCGGCCGCTGTCATCGTCAAGCGGATACATTTTCTCCATGACCTGC +GAACGCACTTCCTGCCAGTCTTCGAAATACGCATGCGGCTTTACCCACTCCCGGTCTCCG +TCGTGATCGACGCGCTGCGGCTTGACGACGTTGAAGTGGTTCACGGCATAGATGTCGTAC +GGATTGCCCGGCGCAATGCCGAACCCGTTGCAGACCCACATGTTCTTCTGCACGTCGCAG +ATACCGATCAGGAAGCGGAGAGCCTTCGGAACATGTTTCTCGCGCAGGACTTCGGCGCGC +TCCTTCAGCGGCTCCGGGAGCAGGACCGTTTCGATGCGGCGATGGAAATACGGTTCCCCG +AGGTCGGTGTTGTAGAACTTCTTCAACGATTCCTGCGACCCGGTACGCTCGTAGTCTTCT +TCGGCCGTGATGTAGTTGGCGACGAGTTTGCGCCACGAGATGAACGCCGCCACGATGCCA +TTCATCCAGATAGACGCAATGCGCGAGCGTCGCGGCGTGCCGAGCCGGTTGTCATCCGCC +GTCATCGACACGCCGTCCTTCAGCCAGACGCCCCACAGGTCGAGAGCGTTGTGCTGATCC +GCTTCGATCCGGCCGCCGCAGCACGGCGCTTCCATGCGCACGGTATCGGCGCACGATACA +GCGTCGCCGCAGTCATCGATCCGCTTCGATCCGGCCGCCGCAGCACGGCGCTTCCATGCG +CACGGTATCGGCGCACGATACAGCGTCGCCGCAGTCATCCCACTTCAACAGCTTGAAAGT +CGGTTCGAACCAGTCGCCGCAGTGCGGGCACTTCCAGTATCGACGGCGACGGTCGCCCCG +GTTGTACAGGCCGAGAATCCCCTTGCATGGGGGCGCTTCGTGCGGCGATGAAGCCAGCCA +CTTTCGGCCGTCTTCTTCGATCTCACGGGACGGGCTGGACTCGGCCAGCGTCATCGCGAA +CGAACCGAACCGGTTCGAACCAGTCGCCGCAGTGCGGGCACTTCCAGTATCGACGGCGAC +GGTCGCCCCGGTTGTACAGGCCGAGAATCCCCTTGCATGGGGGCGCTTCGTGCGGCGATG +AAGCCAGCCACTTTCGGCCGTCTTCTTCGATCTCACGGGACGGGCTGGACTCGGCCAGCG +TCATCGCGAACGAACCGAACGTCGTGGTCCGCTTCGACGCGAGGTCGAACGGCACGCCGG +CGCCATCAACGTCGTCCGGCATGCGGTCGTAGTCGGTCAGGCATACGCGGCCGATCGGAC +GGCCAGCGCATTCGGTCACGGACGGCCACGACAGCGTCAAGATCGTGCCATCCTTGTAGT +GCTTGTCTAACTTGTTGTCGGGGTCGCGCAAGCGCGCCGTCATCGCGCCGATCTCAGGAG +AATGACGGTGCATACGATCGATCCGTCGCACGGAGAAGTCGCGGGCTGCTGAGTTCGTCG +GGCAGTACAGGATCATGTCCATCGGGTCGACCTTGACCGTGTACCCGACGAAGTGCAGTA +GCAGGCCATCAGTCTTCCCGCACTGCGCCGGGCCGACGAAGACTTCCGCGTCGAAGTCAC +GGGACGTCAGCGTGTTCATTAGTTCGACCATGTACGGCACTGTCTCGTTGAACCAATCGC +CAACGTACGCGCCCGGCGTGTTCAGCTTTCGGTACTTGGCGGCGGCCTGCGATATGGTCA +GGAGTTCCGACGGCCGGAAGATGTCGGCGAGGGCGATGACCATCGTCTCGAGCGACTTAT +AGACCTGCTACTGGGTCGTCTTCAGTTCCTTCAAAAACGCTTCCCGCGCTGTCGCGATCT +TGACGTCCTCGTACTCTGTCCTCGCCGTCGCCACTTCCTCCGCTGCCGCCCGTTGATTCG +ATTCGTTCGGCTTCAAGGTCTCGTTCCGGTTCGTGTTTGAATTGTACGATAAGAGCGTTG +CGCAAGCTCTTCATCAGTGAGTCGTTCATCTTGGGAATGATGACGCGCTGCTTGTCGCTC +AGTTCGGCTTGGCGGTCCACCGAAGCCACCATGAGAAGTATCTCAGTTCGCAGCGTCTTG +AACGACTCGGCGTAGTGTTGAAGTACCTTCTCGGTTCGCCAGAGATCGCCCTGTTCTTCC +TCGAATTTCAGGCGCGCATTCTGCCCGCTCCAAAATTCCTTCAGCAACATCGGCGGCAGG +TCTCGATGGACTCGGCGTAGTGTTGAAGTACCTTCTCGGTTCGCCAGAGATCGCCCTGTT +CTTCCTCGAATTTCAGGCGCGCATTCTGCCCGCTCCAAAATTCCTTCAGCAACATCGGCG +GCAGGTCTCGATGGTGCGTCTTCTTGATGTGTGCCTCGAGGTCGCCAACCGGAGCAACGA +GGTATCGGGCCGCCTCGGCCACTTTGTAGATCGGGTGTCCTTGGCGCTTCCCGCACGCGC +GCAGCCCTTCAATCCGTTTCGTCACGGTGCGGTTGTCGATGATGAACAACTGCCCGAGTT +GTGAGATGGACGCGCCATCGAACAGGATTGTCTTCGATGCGCTATCCGCTCCGCTCTTTT +CTTCTGCCATGCCGGCCTCCGTTTTTGTCAGGGTTGAACGTTATCACAAGCCCGCAGCGC +GCTATCCGCTCCGCTCTTTTCTTCTGCCATGCCGGCCTCCGTTTTTGTCAGGGTTGAACG +TTATCACAAGCCCGCAGCCGTGGCAAAATTTTTACTGTACGCTGCTCGCTTCTTCATGAA +CGCAGCTCGCAGACGGCGAAGACGCACGAAGAGATCTTCCGGCGCGATGCGCTTGCGAGT +CAGGATCGATACCGCAAGGTCGTCCAACGTGCTAATCATCGTCGCATGGTGGACCCGCAC +TACATGGCACTGGCCCTGCTGGGCGAGACGACCGATGGGCTGAAGATATAGTTCGAGCGA +GTAGAAGATGTCGTAGCTATAAAGGTGATGGCCTCCCTTCTGCATGCTCAAGCCGTGTGC +CACGGACGCCGGATGAACGAGCAAGATTTTGATCTTGCCTTTGTTCCAGTCGCCGACAAG +TTTCCCCTCAGCGTCCATTACGCGCGCTCTCGGGAACGCCTTCTTCAGTCGTCCGAGGCA +GGATTTGAACCAGTACGCTACGAGCATCGGCTCGCCGTTCAGCTCTTCGACAAGTTGCGT +CAGGCCTTCGATCTTGTTACCGTGTACCCAATGCGTCTTTTTCTCCGCGTCATACACAGA +TCCGGACGCGAGCTGAAGTAACTTCCGATTCAGCGCGGCTGCGGTTTCTGCTTCGATCTC +GGGTCCGTCAGGAAGGTCGAGGATGAAATCCCGCTCGAACTTCTTGTACATGGCCGACTG +CTCATCGGTCATCTTGATGGCGCGCTTCAACAGGAGCGGCTTATCGACCTTCAGGTAGTC +CTCTGCCTTCATCACTAGGCAGATGTCAGCGATCTTCGACAGGATTTCGTTCTCGCATCC +CGGCCGCAGCTTGTACGTCCACAAGTAAAGGTTATACGTGAAGTACCGGTTGGGGTAGTA +CGTGATGTTGTTGCCGAGACATTCTCCCTTGTCGAGATGCCAAATCTGCGCGAACAGGTG +TTCCTAGGTCTCGGCAGCCGGCGTCGCGGTGAGAAGTTGCAGGCGCTTGATATACGGGCG +AACGGTATTCAGCTTCTTGAAGCGGATCGAATTGTGATCCTTAAACGACGACGATTCATC +GATAAACACGACATCGAAAGGCCACATTTCCCCAAACAGGACGATGAGCCATTCAAGCTG +TTCCCGGTTAATGATGTGAAGGCTCGCCGGGGTGCGCGCGAGGCGTTGAAGGATCTCTTC +CTTCATTTCGGCTTTCACTCGCGCCACGTCTCGCTCAAGCTCGGGATCCGGTTGCTTGCG +GCCGTCGTCGCCTCGTGTTGTGAAGGCCCGATAGTCGGAGCGAGCGCGTTGTTTACTGCC +TGCCTCAGCGATCAGTTCAACCGACTTCTCGTCTTCCGCGCGGATCACGACATGGGACAT +GTACGCCGTGTGCTGCCAGAGCGGAATCTCGTTCGGCCAAGTCTGCGTAGCGACACGCAG +CGGCGCGATCACGAGACAGTGCTTGTATGCGAAGCGCGAGAGTAGCGGATCGAGCAGCGT +GAGGCAGATGACCGTCTTCCCCATGCCACGGTCGATGAACAGTGCGCTCAACGGATTCTC +TTCGAGAAAGTCCACGCATTTGTCCTGATCCGCATGCTGCTCGATCGGATCGTACTGCAC +TCTGTGGAACATCTCAGAGATGGTACGACGCAAGGATTCGGATTGCATCTTCATGATTGT +CAGCCCAATGAACGTACCCGCCGTGTCGACACATCTCGTCGTGCTTGTTGTACTGGTGTC +GCTTCGGTTCTGCATCCTTCCGCTTGAACTCGATGAAAACGACGATGCCCGACCGGATAT +ACATCCGATCGGGCACACCACGCTGACCGGGAGAGGCAAACTTCGCAACAAACCGTCCAT +TTGCCTTCGCCCAATCGTTTGTTTGGTCCTCTATGCGCGTCTCCCGTACGGGAGGATCGG +AAGTTGCTTCCGATTTTTTTGGAACCGGGAGTAATTTCACGTCTGTCCTTGCAATAGAAC +GAGGCCGGCCATCCGGCTGCGCCAACAGGCATCTCTTCGTACCACTTGCGCTTCGCGGTC +TTGCACTCCTTCAGGACATGCAGCCCCTTCGACGCGTCGCCGATCTTGCGCAGGGTGACG +ATTTCATCGTGAATGTGCAGAACGATATTGAGGCCCTACTTATGCGCGTTGAATAGGCCG +TACTTCAGGATTTCCCGTGCGATAGCTTGCACGAGGTTTTCAGTCATCTTACCGCCGTGC +GAGTCCTGCCGCAGCCACTTCTTGATGTCCTGATTGAAGCCCATGTACGAGAAACATGCG +CGTTGAATAGGCCGTACTTCAGGATTTCCCGTGCGATAGCTTGCACGAGGTTTTCAGTCA +TCTTACCGCCGTGCGAGTCCTGCCGCAGCCACTTCTTGATGTCCTGATTGAAGCCCATGT +ACGAGAAACCGATCTTCTCGTATGTCTGCGGCGAGCCGTCTTCGTTCCAGAGTAACTCGC +CTGTCTTCCAGTTCTTCTTCTGGAATTTTTTCTCCTCGATGCGCGGTCGATGGTAGTACA +TCCGGCGACCGCTAGGCAGGATCGCCACGAGGAATTCACCGACGATTTCAAACGACACAT +AACGGACGCGCGTGACCGCCTTCGTCTTGATAGTGCGGATGATAGCGGCTTCGAGGTCCT +TCCAGAGCTGCGGGACCTCGGGGTACGCCTCGCGGTACATCTTCACCGAGTCGTGCGCCT +CTTGGCGGGACATGTCGATACCCATGTTCTCCGCGTAGCCCCACAGACCGGTTCGCTTGC +CCTCATGGCTTGCGGCTTCGAGGTCCTTCCAGAGCTGCGGGACCTCGGGGTACGCCTCGC +GGTACATCTTCACCGAGTCGTGCGCCTCTTGGCGGGACATGTCGATACCCATGTTCTCCG +CGTAGCCCCACAGACCGGTTCGCTTGCCCTCATGGCTTAGGTCGCCGCCGCCGAGTCGGT +ATCCCGCACCGAGCACGACCGGTTTCGACATCGTGCGCATCTGCGAAGTTACTTCCGGGT +ACTCGACGCCGTACAGCCGAGTCGCGAATTCTCGGTACGCGCAGCGCCCTTCACGGAACA +CGTTCAGCAGCGGCTGTCAATCCACGAGCCATGCGATCACGACGGTGTCAATCGAGGACA +GGTCGCATGTAACGAACTCGTACCCCTCCGGAGCGTAGATCGCGCTACGCACGCATCCGG +CGAGACCGTCCAAGGGTTCCTTCATCATCAGGCCGAGCAAGTCGTAATCCCCCGCTTGGA +TGGCGTTAGTGTCCGTGCAGAGCGCCCAGTCGATGTCGCCGTCCGGTGCGAGCGCTTTCG +GCGTACGGCCGAGGTTTTGCACTTGAACACCGCGTCCCGCCCAGCGATGCGTGCGCTGCG +CGCCTCCGAACTGAAGGGGAACACGGAGACGCCGGCCGGGGCCGACGAGGGAAACGCACT +TCTTGTACTTGCCGACCGACGTGCGTGGAGACTGCATACGCATCTTCAGCACTTCGTCGC +ACTGCCCCGTCAGCACCGGTTCGTCCTTGTGTTCGGCGAGGCCCTTCTTGACGGTATCCT +TGCCGAGGTCATCGAAACGATACCCGCGTGCCTCCACCCATGGTTTGAGCTGCTGCGGAC +TGTTCGGATTTTCTAGGCCGGTGATCGCGCGCATCTGACGAACGAGTTCCAGCTTGCGGC +GATCTGCCATCGCGGTAGCGCTGTTACAGAAGTCGAGATCGACCGACACGCCGCGATCGT +TGATGAGCTGATCCAGCTCGTACAGCTCGCAATCTTCATAGAGCGTGGGGTACGGAGCGA +GCCATTCGTCAATAGCGGCTTCGGCGATCACGTCCTCTTGGTTATAGATCAGGAAGTCGT +CCCATTCGAACGGGTTGGTCTGCCAGTCGAGCCACTTGTGGGGGTTCTTCTTCGTGATGC +GCTGCGGCTTCGAGAACAGGTTGATTAGCTTCTTCCCGGTCGCCAGTTTGACCTTGTCCT +GCGGCAATCCGAGCTGCCCGCCAACCATTTCGAGGTTTCCAGCGAACGACAGCATGTACG +CACGCACCATCGCGCAGCGCCAGTTTTTATACGGCGTGTTGATCTTCAGCACACGACTCG +TCATCACGCTCTCGAACTGCGCATTCCGCGCCCGCTTGATGGCGTTCGGGTCTTCGAGCG +CCTCGCGAACTTCCGCCGGGAACCTGCCGTCTCGGATTCCCCATTGCTGCACGCGGCCGC +CGTTGAACGACCAAGAAGGCATTCAGGCGGTCTGCTGCGGCAGCCGCAGCCTGCGTTGCC +TGCGCCTGTTGATTCATCGCCTTGGCGACCTGCTCTGCCTGCTCGGCGACTTGCGCTTCA +AGGCCACTGAGTTCGGCCATGGACTTCGTCAGGCTGGCCGTGCGGGCATTGGCCGCCTGC +ACATCCTGACCCGCCTTCGCGGCCATCAGGATTTCAGTGGACTCGTGCGCCGAGTAAATG +TCGAGGCCGCACGTCGGAAGGTCCTCTTCGCTACGTGATTCGTAGTCTAGTCGAATATCG +TCTTGCATATCAGTTCTCCGGTTTCACGAGGTCGAGTAGCACGTAGCCGTGGCACGCTTC +AGGTGCGCAGAAGCAGACGAGATTCCGACCACGCATCGTCGGCAAGAACGACATCAGCGA +AGGGGAGTTGAGGACCTGCTCTCGGTACTTCGCGATGACCTCTTCGCGCATTCCGTCTCG +GCCGATCACAAATGGGTTGCCCTACCCCGAAGGGCGGCCGATGTAAATGCAGCCGTCCGG +ATAGTCGCCTGCGTTCTTGTTGAATACCTTCGGCATTTCAGCACCCCAGAAGAAAAAAAC +CCCGGCACGGCGGGGAATAACCGTGCCGGGGCGAACAACCTGCGCGGAGGAATCGGACCC +GCGCACGCATGCGAAAGGAATTACAGGCCGCCGTTGTCGTCGTAGCCCTCGGCGAGCGCT +TCCTCGCCGTCCGACACGTCGTCAAACGAATCGTCAATTTCGTCTTCGCTGATGCGGCCT +TCGCCGATTTACAGGCCGCCGTTGTCGTCGTAGCCCTCGGCGAGCGCTTCCTCGCCGTCC +GACACGTCGTCAAACGAATCGTCAATTTCGTCTTCGCTGATGCGGCCTTCGCCGATCGAC +TCGTCGTCACGAACGAACTGGACCGCAAGCAGGTTCGCGTTGATACGCTTGCCGAACTTG +TTGTCCTACCACCACGGGTTGATGAGAATGTTCACGCGGTAACCGGAGTAGATGGCGTTT +TCGATCTCACGCTCGCCGAGTAGACGCTTGTCCGCGCCGCTCACGCTCGGACGCTTCGTT +TCCGATGCATTTATAGTGTAGCAGCCTTCGTATTCGTTCTTGCCCGGCGCGTCGCCGTCG +CGGAGGAAAAACTTGTCGGTCGGAATATTCTTGCCGTCGTTCTTCTCGCGCAGAATCGCG +TCGCGCATTTTCTTCATCACTTCGAGAACGGACTTAGCGAAGTCCTTTTCGATGAAGCCG +ACAAGCGAATACTTTTCCTGCCCTTCCAGATCGTCGCGCTTGTAGGGCTTCGCCAGATGG +GGGTACGACGCCCGCACATTCTCGATACGCGTGGTGCCGTCTGTGAAGGCGACAACGTTC +TTCCCTTTGAACTTGATTTCGCGTGCCATTTTGCGACTCCTTCAGGTCTACCGTTTTACC +GGTCTAGGGTTTCAGGCTCTACAGGTCTACGGGTCTACAGGCCGTCGTCCGGAGTGAGTT +CGTCAAAGCAGTCATCGGCCACTTTCCCCAGCTTCTCCCGCGTGTCTGCGACTGGAGCCA +AGGTCGCCTTGCCAGGCGCTTTCGCGACGAGCGGGGCGATAATTTTCTCGGCCGCTTTCT +TTCGCATGCCACTCGCGACGAGCAGTTCTTCTGCTTTCGCGGGGCTGACGAAATCGGTCG +ATAATAATGCGTTTTCCTTCACGCCAAGGAATGTGAGCGTTTCACCGGCTTTCGCCTGTT +GCACGTTCCAGCGGCGATTCGATCTGGATGCCACCCGTTTCATGCCGGGGATGTCCACCC +CGTTGTGCGCGCGTCGCTCCAACTCGGAGTCCATTTCGCTGAACCAGCGCTCGTATACCT +TCCGGTACGGAAGTAACATCGCCATTTGTTCAGTCGAAAGCTCGGAAACCGGAAGTAACC +TCGTGCTCAATTCGCCGCGCATCAGGACTTCCTTACAGCTCGACATCTGTTCAACGGTTA +CTTCGGCTGTCAGGTCGTCAAAGCAGTCGTCAGAAAGCCTGTGCGCCATCGCGAGAAGCG +CCAGACAGGTCTTCTGCACCTTGCAAATACGGCATCCTTTGTCGGACGGCGTGAGCGGCG +CACCTTTCTGCCAAGCGAGAAATGCCCGGACCTTCACGAAATCGGCGAAGCGAAGCATCT +CTTCCCGAGTGGTTTCCCACGTCTGGAAGTGTGCTAGGCGCGGTTGCGAGATGTGGACGA +CGACCTTACGGAATCCGTAAATTCAGTCGTACTCGTAGAGCGCGCCGAGCGCATAGAGCA +TGGCTTGACAATTGCCGTTGATGATCGTCTTGCCGTTCTCAACGATGATCGAAAGCGGAT +CGTCCAGTCGCAACGCCGCGAAGACCTGAACACCGCGGCCGAACTTGTGGTCGAGGATGT +GCATCACACCGGGTTCGAAGCCGCCCACGTCCATCGTGACTCCTTGACGCGGAATCGGGG +TGAGCTGGGAGAAGTACACGCGCTTCTCGATAGGCAGGTCGCGGGGAAGCGAGTGCGCCC +ATTCGACAGACGGCGCGACGTACTCCATCATCTCCGTGTCGGTCGTGATATCGAAAACGG +TCTTCCCTTCGACGACCTGCTCGACCGTGCCAAGCAGATGATCGAGGCGTATGCCGGTCT +TCAACCACGTCTCGTTCGTGTGGAAGCGAGCGGTCAGCGGCGTCTGCGCACCCGTGACGG +GGTCAGCATAAAGCGCTGATACCGCCAGAGTGTCATGGACAGTCTGACGGACCAGCGCTT +TAAGGGCGGCGAAGTCGCCGACCATGGCTTACAGGCCCGAGGCCGACGCTTTCGCGCGGG +GCTTCGCCGGCTTCGACGCCCCGGCCTTGTCGCCGTCTTCGCCTTCGTCGCCGGACACGC +CGTGCGCGCCAGCGCCGTATGCAGCGTCTTCGCTTGCGTTGTCTTCTGCTGCGAGATTGT +CGTGAAGGGACCCGGCGCGTGTGAGCCACAAGGCAGACGCACTCGGGGAAAATACCGAGT +GGCCGCCTTGCTCGATGTTGAACTTCAGCGCATCGAGATTGATCGCGTGTTCGCTCACGT +AGAGGCCCCGGAAAAGTTGTTCATTTTGAGCGGCACTGACATTGTGTGGTGCACCGTAGA +GGCCGGGAACGCTTGCCGGTGCACCGGAAAATACCGAGTGGCCGCCTTGCTCGATGTTGA +ACTTCAGCGCATCGAGATTGATCGCGTGTTCGCTCACGTAGAGGCCCCGGAAAAGTTGTT +CATTTTGAGCGGCACTGACATTGTGTGGTGCACCGTAGAGGCCGGGAACGCTTGCCGGTG +CACCCGCCAGTGCCGCTCAAAATGAAGCCCGGACGAACCGGGCTTCTTCGCTGCACGTCG +AGACAATATTACAGGCCGTCGCTGCCGTCGCCTTCGTCGCCGCCCGCGTCTTCTTCGAGC +GCCTTCTCGGCCGCGTCGTACGTGGCGCCGAAGTGTTCCGGCTTGATCGAGGCCGAGGTC +TTCGGCCTTGCCGTACTTCTTGATGATCGCCTTCGCGTAGTCCATCAACTTTTCGTCCTT +GACGCGGATCCGGATCGCCTTGACCTCGTCGGCCGAGTGCTTCGGCTTCGTTGCTGCCTT +GCCGTCGCCCTTGCCGGCCGCCGTGGTCGTTGCCTTCGTGCCTTCAGCCGCCTTGCCGCC +GCCCGTACCGCCTGCTTCCGCGATTGCCTCCGTGACTGCCGACTTGATGAATTCCTTCAG +GGCGTTTTCGAAGCTCATTTTTCCGACTCCTAGTGATCCGTAGATGGGTTGTTTGTGTCG +TGGCGTTCACCACGGAACGAATCATGCCGGGGCCGGTTTTGTCCCTTGCCGCCGCCCGTA +CCGCCTGCTTCCGCGATTGCCTCCGTGACTGCCGACTTGATGAATTCCTTCAGGGCGTTT +TCGAAGCTCATTTTTCCGACTCCTAGTGATCCGTAGATGGGTTGTTTGTGTCGTGGCGTT +CACCACGGAACGAATCATGCCGGGGCCGGTTTTGTCTCTCAACAACTTTTCGAAAATATT +TCAAAGACAAATGGGAATCTGGCATACTCCGCGCTGTATCAACCTTCATCTACCTACATA +AGAGGACTAGAAACATGGTAATCCCTATGCCCGCATGGTTCGATGCGCTGTCGCCGGAAG +AGCAGGAAACCGAGCGCACGAAACTGGTCCTGAAGCTCGCCGCGATCTACGCTTCCCGCG +GGAATCTGGCATACTCCGCGCTGTATCAACCTTCATCTACCTACATAAGAGGACTAGAAA +CATGGTAATCCCTATGCCCGCATGGTTCGATGCGCTGTCGCCGGAAGAGCAGGAAACCGA +GCGCACGAAACTGGTCCTGAAGCTCGCCGCGATCTACGCTTCCCGCGAGCAAACTGCTCA +TCGTTTGTCCGAGCTGGTGGGCTACTCGTCCAATACGCTCGGCGCTCTGTCGTCTACCGG +CCGCGCGTTGCGCCCGGAACTCTGCATCGATATCGAGAAGGAGGTCGGGCACGAGTACTT +GCCGCGACGCTTGCTCAAACCGCATATCTTCGAAGTGCCGACCGCAGGAGAGTAACGAGA +TGGCCGACCAGACCACGGCCACCTATCTTGCGGATCACGGGGATGCACTGATCGCGAACG +GGTACAACATTGTCCCCATCACACCCGGCGAAAAATTCCCACCGCACGACGGCTGGCAGC +AGACAGTAGCAACGCAGGCGAAGTTGAAGACGTGGCTCGCCACGGGTAACGAGATGGCCG +ACCAGACCACGGCCACCTATCTTGCGGATCACGGGGATGCACTGATCGCGAACGGGTACA +ACATTGTCCCCATCACACCCGGCGAAAAATTCCCACCGCACGACGGCTGGCAGCAGACAG +TAGCAACGCAGGCGAAGTTGAAGACGTGGCTCGCCACGGGTTTGAAGTACATGGACAACG +GCGAAGATCGGGTCGCCGGTGTGAAGCTGGCCGGTGTCGGCTTCCTGACAAAGAACACGC +CGGGCGTCGATATCGACATCTCGGACGAAGACTTCGCGAAGCACATGGAGAATTTCGTCC +CTGAGAACTTCGGGATGGCTCCTGTACGCCTCGGCCGCGCGCCGCGCCGGCTACTTCTCT +TCCGATGCACCGAGCCGTTTTCGAAGGTCAATTCGGGCGTCTATGTGGACGAGTGGGGCG +AAGCGCGGAAGGTCGATATCCTCGCGAACGGCCAGCAGTTCGTCGCGTTCCGCATCCATC +CGGACACGAAGCGGTCGTACGAATGGCTATACAGGCAGTCGCCGCTCGACATCCAAGCAT +CCGAGTTGCCGGTGTTGCGCCGCGTCGATGCGCAGGCCATCGTGGACGAGTTCGAGAAGC +AGGCCAAACATCAAGGCTGGACGCCGAAGAAGCGCTCGCGCACCGCGCTGGAACGCTGCG +AGAGCGGCGGGGACATCGATTACGACGACCCGTTCGCCGCCGACGTAGCGAAGACCGATA +TCGGCGAAGACGAGCTGCACGCCAAACTCCTGCTCGTGCCGGACGCTGATGATTACGAGA +CGTGGGTCAACGTCGGCATGGCGCTGTTTCACCAGTTCGACGGCCACGAGCGCGGCCTCG +AACTCTGGCACAAGTGGTCGGAGACTGCCGACAACTACGACGCGAAGAAGCTGGACGCGA +AGTAGAAGTCCTTTGACATCAGCAACAAGTCGCGTACGCCAATTAACACCCGGTACATCA +TCAAGCTGGCGAAGGAATCCGCCGAAAAAACCGCCGAAGAAACGATGGTCGCGCTGCAAA +AGCTGCTCCTCGAAGCCACGTCGATGAACATGCTGAACTCGGCATGCAAGGCGATCAAGA +AGGCGACACTCGACACGCCGTCGCGCGAGCTGATGGTCACATGCGTACGGCAGGCGATCA +AGCGAATCAACGACGGCTCGCCCCTTCCGCTCAGCGCTGCTCGGCAGATGATTCGGTTCG +AGAACCCGGAATCGAAGCACATGCCGAAATGGCTGATGGGCTGGACGTACCTGACGCTCG +ATGACAAGTTCTACAACGTGAACCCGCAGGAGTACATGACGCGAAGCGCCTTTAATTCGG +CGTTCGTACGTTTCCTGCTCACGCCACAGGACGTGTTGGAAGGCCGCGTCGTCCCGGACA +CGACCGCCGAGAAGATGGCGCTCAACCGTCATCAGATTCCAGTATTCCGCACGTGGCTAT +ACCTGCCCGAACACGAAGAGACGTACATCATGAACGGAGCGCGCTACGCGAATCTGTACA +CGGACAAGTCGGTCCCGGAGTGTCCGTCAAAGCTGACGAGCGAAGACAAGCTGAACGTGA +AGCGCATCCTCGACCACTTCAACATGATGATCCCCGCTGACCGCGTCATGAACGGAGCGC +GCTACGCGAATCTGTACACGGACAAGTCGGTCCCGGAGTGTCCGTCAAAGCTGACGAGCG +AAGACAAGCTGAACGTGAAGCGCATCCTCGACCACTTCAACATGATGATCCCCGCTGACC +GCGAGCGCGGCATCATCATCGACCGGCTGGCATGGATCATCCAGACGCAGAAGCGGCCGA +ATTGGGCGATCGTGTTGCAGGGTACGGAGTCGGACGGCAAGACGCTCTTCAGCGACATGA +AGGGCGTCATCCTCGGACCGGAGAATGTCAAGACACTGAACGCCAAGACGCTCGAAGGGG +CGTTCAACGGCTGGGCTGAAGGATCGCTCCTGAACCGCGTCGAGGAAAACAAGCTGCACG +GCCACAACCGCTTGGACGTGCTCAACCAAATCAAGCCGCTCATCACGAACACGGCCATTG +AAATTCACCGCAAGGGAGTAGACCCGTACAACGCGATAAACACCGCCGTATACCCGATGC +TGACGAACTTCACAGACGCGCTGCCGTTCGTGCGGAACGACACGCGCTACTACGTCATGT +TCGGCCGCATGCAAAACCGCGAAGATGTCGCGAAGTTCAAGGATGAGAACCCGAACTACT +ACGGCAACCTGTTTCAGGCTCTAAACGAGTCCGCCGGGGCGCTGCGGAAATTTTTCTTCG +AACACGAGGTGAGTTACACTTTCGACCCGATGAACCGTGGGCCGGATTCCACGGCACGCC +GCTATATGATCGCCATGAACCGCTCAAACGACCTGGAAGCCATCGAGACACTGATCTCGG +AATCGATGAAGATCGACGTTTCCTCGGCGCTCCTGAACGCCAGCAAGCTGCCGGACCTGA +TGGTTGGCATGGATTGCGAACTCCCGCAAACGAAGGTCTTGCAACGCGTCCTAAGCGACA +CCGGATTTACCTTCCTCGGACTCATTCGAATCAACGGGGAGTCCTCCCAATACTGGGCCA +AATCGCCGCAATACTTCACGGTGGACGGGTCGTCCGAGATCGATTTCGACGCTGTTCGGT +AGTACGCCGGGTGCGGTTTGTAGCCGAGGTCCAGATCTGAATCATTTTTAACTTATTCGG +ACCTTGGCCGTTTTCAGGCCCTTCGGGGGCGTATCTGCGACTGTTGACCTTATCAGAAAA +GCGTCATTTTTCATAATGCAGTAAAAAACGCGGACCGAATCACGCCAAAAACCTCCGGAC +CTTCGATTCGGACCAGGACCATTAGAACCCCGGCTCCGCCTTGTCCTATAAGGCTTCCCT +TCCTTCTCTTCTTCTACTATTCTATAGATAAGGTCCAAATAAAGAAGAAAGTAGAATAAC +CGTATAGACATAAATCCAAAAAAATTTTCGTACAGATATAGAATAGAGAAAACGATACGG +TTCGACCCTTCGGACCTGCACCTGGCCGGCCATTCTCGTCCTCCTGACCACTCAAGGTCC +GAATGGGTGGTTTGCCCTCCACTCCGCCAAGGTCCAAATCCCCTATCCCGCGATTCGGTT +CCAATCACGTTCAGGATATCTGCGTTGCGCATCTCAAAATCGGTAGTAACTTCGGACAAA +CCGTTGTCGCTCAAATCTTTTCGCGAGAACTTCGGGGGAGGGCAGCGGCGCTATGACGTA +GAAACGAAGAAACGGGAGATCGGGGCTCTGCGCCCT +>NC_025457.ref length=42654 +GATTGAGATATGATTGGAAGTGATTGGAGTATCTGATTGGTGAGTATAATGTCAAAAGCT +AATTTTGTCTAATATTTCTGAGAGGGTGTCTCCCACTTCCTCGCCCTCGACTTCCCCATA +GCACTCATACGTAATCATTTCTTATGGATTGGAATATCTGAGTGCTTATACCTTATCTTA +TACTGAGTCTTTGAGTCTTCGACTCGTATCATTCATTGATACTCTTTGGTATGTCGCTCA +TTGTATAGATAGTTTGATAGAGTGTCAACATACTTATTCAACTATTTATCTATTCATTGA +TTCGATTCTTATATCCTTGTATAGATTAGAGTGCTTGCCTTTTATGTCTTAACTCTTATG +CCTTTTTATGTGTTCATAGGTATATGCCTAGATATACAGATAGTTTTATTGATAGCGATG +TAGATAGCTATAAGATAGTTATTAGATAGAGATACTTATAGATATAGATAGTATTTATTT +TATCTATTTATACTCTTTGGTCTTCTCTTTATTCTTTATTCTTATACGTCTATCTTCTGA +TTTTCCTTAATGAATACAATAACTTATCTGATTAGAAACACGAATAAATTGATACTTTAT +TAACAATAGATAACATAAGCATAAGTATATAAATCAATAACTTAATAGAATTACTGTAAA +GTTATGTAATAATTATAAGATTCTTTAAATAGAGTGTTGACATAGTTTTTAAACTGTATA +TTATGACAACCATACCAAGCAAACAACGCAAGGTACTAGATAGGGATGACCTACTAGATA +TTCATTAACTTAATTAGATTGATTGCTTAGTTTAAAGACTATGAAATGTATAGGATAGAG +ATAACAAGCCTACGGGTAGCCACTCTATACGGTCTTCGAAAGGTGTACCGTGGTATAAAC +AGCCTCCGATCAATCGAACAAGATAATGAATAATTATTTAAAAGAATGGTTGACAACTTA +AATCAATAGGTTTAAAGTTCACACTATCAAGGCATTGAGCTAGAGTTAGATCACATTAGT +TGATTGATACCAAGCGATAAAATAAATTGAAATAAAGTGTTGACAACAAAATCAGATATG +ATTAAGATGCCAACCATAGCGAGTTAGCTAGACAGTAGTTGAGATGTGATGCTTTAATCG +GTTGACTATCAAGACTCTGAAAGGTTACTCACTACCATGTAGACGATACATGGGTATTCA +TTAACAGATTACTAATTAAATCCTTATAGGTGAAGCCTAGACCACAATACTTTTGTATGT +GTGCAATGTGGTAGGTAATAGGATAAGCCATTGAGGTTGAAGTGTTATAGGTAGGCTGTG +AGGCTGTACTCACAGTTAATTCCAATACATAACACGTAAAGCTATGATAAGGTTAATGAG +TTTATATTTAGCTAGGTTGGGTTGAATGCTATGCACATCGACCTAGCACTAATATAATCT +TGAAGACTGACACAAGGTATTAGCAACAAGGCATGGGATGATGACAGCACTCGTAAGGTG +TTTCCTAGCTAACGGATAATCTGATACCGCATGAGGTGATACCTTGTGTCAATGTTCAAC +CAACCAACTAACATAGGTGTATTATGAAACTGTTATTAACTACAACTGAAATCAACAAAG +CAATCGAATCTATCGAACGTCGTGGTAAACAATTGGATACTGATATCCATGTGGCAGGTG +TGTCAGTGTTAAAGCATGTCGCTGAACATGGCGATACAACTTTGCTTGATAAGCTTGTAG +GTGCTATGCCTAAAGGTAGCCGTAAGTCTGCGTTCTGTGAGTGGGCTTTGGCTTATGGTA +ATGTCCGTATGCTTGACCGTGCTAACGACGCTGATAAACCTGCTATCGAACAAGGTCGCT +TGTTTGCTAAGGATAAGTCTAAAGAGTTCAATGAGGTTGAAGCTATTGCTAACAAGTGGT +ATGACTTCAAGCCTGAAGCTGATTTGTTGATTACCTTTGATGCTGCTGCTATGGTTGCAT +CCATGATGAAGCGTTTATCTAAAGCACAAAAGCAAGGTGCTGAAGTAACTGGGCATGGTG +ATGCACTTAAACAATTACGTGCTTTGATGCAACAACTTGAAACTCAAACTGAAGAACTTT +AATCTGTAGGTGTATGCCATGATTACTATAACTGAGAATTACCGTGTTAAGCATGATGTG +AATGGTGTTATTGAATATGCACAGTGTCGTGTTACTGGTCGCTTTGTTAAGCATGTCGTG +GCATACACTGAATTGAAGTGTTCTTCTGTACTCACAACTGCTATTGCACTTGCTATCTGT +GTCAGTGCATGGGTAGTGTCATTGTTATATATCTTTCTAAATAAATAGGTGAAGTATGTT +AAACGTACCTAAAACAAATCCGAATGTAACTGTAACTTTAAACATCGGCTTAGCTGCGTC +GCTGAACTGGGGTGGATATAAAGCTCAAGAGGCTAACCACGGTACAGTACAGACGCTTGT +AGATGTACTCGATGCACCTCATCGTATCGCTCGTATCATTGAAGATGTACGTGATCTTGC +GTATAACCCTAACGGTCAGGCGTTCTATCAGCAATGTCAGCCGTATGGTATTGATTACGG +ACACGATAACCGTGAAGTAAAGTACAAGGTGGTACAGTCGGGAACTGAAGCGACGTTGGT +TGTACAATTTGAGGCTACAGCCCGTGACATCATTGGTCAGGTGTTTGCACTTGCTGAGAA +ATATAAACAAGACTGTATCGCTGTATGGATTCACAATGATGTGAACGGTGGTATCGGTCA +ATTAATTGGACGTTATAACTATGTGTGGTCAGGTGGTTACTTCAATCCCGAATACTTCAT +TCACTTGGAGCGTTAAATGCCTTACGTCATACCTGTAATTATTATATTCCAAGTGGGTTA +CTGGCTTGGATTCTACTGTGCAAAATTCCTTTAATAAGTGAGAAATAATATGTTTGGTTT +ATCTATCGTTAAAACTGCTGACCTTAACAACTTAAAAGCACGTGTAGCTGATCTTGAAAC +CGATGTAGACGGTGCATTGGATAAGGTGGCTGCTTTAGACCGCAAGTATAATGGTTTGAT +TGATCAAGTACAACGTAACGATAAGGCTGTACGTGTTCAACTGGATGCACTTGCAAAGCC +TACAGTATGTCCGTTGTTAACTGCTGTACCTAAGCATGTAACCGACCCTGTAGGTGCATG +GGAAAGTAAACAACGTGTGTTGGAAGCCCATTTGAAAAGTGCGGAGTCTGACGTGTCTGT +ATTCCAAAAGCAAATGGGCTTTTGGGTAGGTGCAGACATCACGCAATTAAAGTTCTACCA +AGAGTTAGTGCGTAAAGCTAAGGCTAATGTTGAGCGTATTAAACAAGAGTTGTATGAACA +TCTAACACGTAAACCAATCATTGTGCAGTTAGCACCACCTAGTGAAACGGCTGTATTTGT +ACGTCATAAGAAGTACGGTACTTTAGGTCTATTGAAAGGGCATAACATTACTATCCTGAG +CACAGGTAACCTGCTAGATGTAGGTGACGTAATAAATGCCCCACCTGCTGTAGTCCATAA +GTTTTGGAATATTGAACTACGTGACTCGGTGAAGTTAAGTGTTTGATCGTTTCCATGAGG +ATGGTGAGATCATCCACGAACCTGTGTACCTATGTAATGACTGTGGTGAGGAATCTCCAC +ATTCTGAACTATTCCATATCTGTTGTTCTGAGTGTGATGCACTCTGCCCATATTGTGAGT +CTGATGACTTGGAGGAATTATAATGGCTAAATCCAAATTAGCTCGACGTGTCCGTAAGAT +TCGTAACTTAAAAGGTAAGGCGTACTGTGTACCTGTAGTAAATAAACTACACTGTGAAGC +ATTATTAAAAGCTTTTAAAGTAGCCCGTAGTAAATTAGATCGTAGCAAATATTGGCTTAC +TTGGCGAAGTGATAAAGAGTTTATCTTAGTACATAACTCGTCTGTAGACAGTGTTGGTGT +ATATAATCATAATGGAGGTTTCCCATGCGTGAAGCTATAACCCGTTTAACAAAGATTACA +CTGTACACTGCTGCATACTATTCGATTGGTGCTGTAGCTTGGCTGTGTGACCATGAAGCC +AGTAAAGAGGAACATCACTTATGAAACCATATCAACCAATATTAGGTAGCCTAATACGTT +GCCCTAACTGTAAGAAAGTTTATACCTCTTGTCGTTGTCTTTGGTAGTATGTTTATAGCT +ACATTCTAAGGGATGTAGCCGTTAAGCATGTTGCTTAGGTCGTGAGTCTGTACTCACAAT +TATATTTCGCATTTAATAAATGTAGGTGACTTATGAAAGTGTTACATCCATCTTTGAATA +CATATACAACTCTTAAAGTTGATAGCCCTTTGTCTCGTAAATCTACGAAGTTTCTAGTAT +CACCTGAATTTGGCAGTACTGAATTACTTCCGCTAGTAGCTGAGGTTCTTAAAGGTTTCA +CACCCTATACTAATGGTTTGGGTTACTACTGGGAAGAAGATGAAGTAGCTATGGAATACC +TTGGTTCAGGTTGTTTCTCAAGTGTCTTCAAACATCCTAATCGTACTGATCGAGCTATCA +AATTATTCCGTAACTACCGTGAAGATAGTACCTGTTATCAGTACCTACGTTTGTGTGCAA +ACAAGACTATTGATTACGAATGGTGTCCTACTGTGCATAGTTTAGGGCGTATCAAGGTGA +TCAGTTATAACTCGAAGCAAGGTCATTGGGAAACCCGTGATTGTGCTTACGCTGAATTGG +ACTTACTACCTTACAACTGTAATGATAGTGCTGTTTATATGGACGATTGGTATGCTGAGT +TCCGTGATGACGTTAAGGATGTATACTTCCCGTTTGGCGATATGGATTTGAAACCCGATA +ATGTTCTAGGTAAGGTCAACGATGAGGGTATATGTCAATACTTTATCACTGACCCAATAT +GGAACTCTGAGCCTGAGCACTACGAACCCATCCCTGAACCATTAAAGGAACTGTATGTGT +ATCCTAAAACGAATGGTACTTTCATAAACAACCTACGGGAGAGCATTAAACATGGTCGTG +TATGGTAATATTGTAAAAGGTGGTGCTACTGTTCAAGATAGTATCTACCGTGGTATGAGT +GCTATGTTTGTGCATGGCTTACGTTCTGTGCATGACTTAGGTGACGCTGTGTACTTTGAG +TCTGATGTTAACGCTACACATCGTCAGCTTAAAGGTTTGGCTACTATGTCAACGTTGCAG +TTAATTGCACCTTACTCTGAAATTAAACGCCCTACTAGCAATGATACTCGCATGACTCCT +GATGAAGTCAAAGCTATCATTGCTGTATGTGCTAACCCTATTTCTTCAACTGTTCAATCA +TAAGGAGACTATTATGTCTAACTCTATCCGTATCGGTCGCTTAACACTTAACATGGGTAA +TGTAACTGTAGGTGTTACCCGTCACCAATTATCATTGTTCATGCAGTACAGTGCATATCA +ATCTAAGTTCTAAGGCTTAAATATAGCAGCACTTCGATGAGGTGCTGTTAGTATTTAATC +ACAGAACGTAAGGAGTTCTATCATGACTAAACTTAAACAACAATTCGAAGTAGCAGGTAT +CGTAGGTCGCCCTGAACGTAAAGGTTGGAACTTCAAAGCTCAGAAGTCTTACCAACGTGG +TCGCTTTGATAACTTAAAACCTCGTATCGGTTTCGTGTATAACCATAAGGTAGAGCAGGT +TGCTCGTGCTATTGCATTCGGTTTAGAACAACAGTTAACTTACTGTCAACTTGATAACAT +GCACAACCAACCACCTGAAGTACCTGTATGTATTGGTAAGCTTAAAGGTAATGGTGCTAC +GTTGTTCCCTGATGCTAACACACGCCTCGCTATGATGGGTTTAAATGGTACTGCTGTATT +ACACTGGTTAGGTGCAATGCGTGTAGTAGACGAGCTATCAGGGCAACGTGGTGAGGTTAT +TGTAAACGATGGTACTTACATTTACACCTCTGTTGGTGTACTGCTTAACTTGGCTCAGGA +TTGTGTTAAGTCTCCTGAAGCTATCCTTAACAACTACAAAGGAAGTCAACGTGTCCGTAA +AGCAAAACAAATCTGATATGTTTAGTATGGGTATGCGAGTCATCGTAACCAAGCCCACAC +AGGCTGATATCAAAGAGGGTATCAAAGGCGACATGATTGGTCATGTTGATCAAGTCACAC +CCTCGTTCATTCATGTAGCGTTTGAATCTAGTAATGGGCGACGTTATGTTTATCCTTTCT +TTCCACATCAAATCCGTCCATTCTAAGGGGAATTACATGCAACATCTAAACGCTTTTATT +AAGACACACTCACCTCAACAAGTCCGTGCTGTAGTTGATGAAGCTCAACGCTTAGGGTAT +ACACCATACTATAAACCTAACTACAAATATGTAGAGGCTGTACTGTTCCATAGTGATGGT +GGTTTATCCCTAAAGGTGTATCACACTGAAGAACACTCTGAATGGTTAGTTAGTCGTGGT +TATCGCCACATCAAACAGACTCGTCAAATCCGTCGTGATCTATGTGGTGGGACTTACTCA +CAGGATGGTCAGGCTGTACTCGACGTTGTAAATAAGGGTTATGTACCTAAGACCATTAAC +GTACAGCCGTACAAATGGATTAAACCTACAGCTTATAATCCAATTATTAATTGGTTCGCT +GAGAAGTTTATCAGTGCTTATGCTGTAGTGCGTAAGGTAGCTGTTGCATTCATTAACCAC +ATCAAATAAGGAGCTGTACCGTGGCTAAGCGTAAAGAAATTGTTAAGGGACTTACACCTC +AAGAAGAACGCAAACTCTTGCAGTTAGAACGTCGTGAGGCTGATATGGAACGTCAGCAAG +ATCGTCGCTCTAAGCGTCAGGATAAGCGTAAGCAGTTCTACTAATGGGTAGGTCTTACAA +GATCAAGATTAAGTCCATACAGCATTACCGTCGCTGTGTGGATAGCTTGAAAGAGGTAGG +TGTACAATTCTGCTCTAATGATGAAGATGAGTTGAAGATGCTACGCTGTAAAGATTACCG +ACGTAAGGCGTGGTTGTATATAGGAAGCAACAAGGTTGCATGGGTATTCGGAGCATACAG +CGTGGTTAAGTACGCTAAGACGGTTAAGCGTAAGGAAGCAATGGAGCTAATTGGAGATGC +ACCATAGCGAATGGTTAGACCTAGCCAAGAAAGTTCCAGTAGGTCAGAAGCGCAGACATT +ATCATGGGGCCGAGTTAACTAAGGCACTAGATGTATGGAACAATGAGGACTCATGGAGTG +CTTACTGTCATCGGTGTCATACCTCAGCCAAGGTACGTAAACAGTTTGTCGAACGTGTAG +ATGTAACCCAACCAATATACAGGCGATATCTTGATAAGGATTGTCTGATTACTTTGGAGC +AGTTACATGATAAACACTTGTTCAAATTCAAGACGTTGGTCAAGCTGTTACATGATAAGG +GTATGAGTACAGTCACTATCAATGATCTTAGTCCAATGTATAATACAAAGGATGATCGTC +TAGTGTTCCGCTTTAAAGGTGTGGATATTGGTAGAGACTGTACAGGGTTGTCACCTGCTA +AATGGCTGATTTATGATAACCCTGATCGGGAGGGTTTCGTGTACTTGCAAGGTAAAAATC +CATACTGTACACGAGAACCTGTAATATTAACTGAGGATTTATTCTCTGCACAGAAGATCA +GATACTATACTGGTTACTCGACTATGTGCTTATTAGGAACTAAATTTCCAAATGAAACAG +TACAGTTCTTACTCGAACGACAAGCCGTTACTGCCACCGACGGAGATTCCGCAGGGTGGA +AAGCACGTCGGCTTATTAATAGTCGTTGTGAGCTTTTTGGTATCCCTTGCTCTAGTGCAT +ATATTCCCGACGGGTTAGACCCAAAGGATATGTCACCTGAAGCATTAATTGAAACATTCA +AATTCTTGGAGAATTAATATGCGTGCTGTATTCGTACTACCTAAAACACATGCGGAACTT +AATCAGTGTATCCCTACTTCGATCAACAAACTTCAGTGATGCTACGGGAGATAAATGTGG +GCAGCTTGGTAAACGTGTAACTGTTTGGTTAAATACAAAGACTTACCACCTACATACCTA +TCTTGTGTTTCCACACACACAAGTAACACCAAATCAATTAGCAGGTCTACTACAGGGGTT +ATAAAAATGTCAGACTTAAACCTACTCCGATGTATGATGGAGCGTAAGTCTTATCAATCG +GCATTTGCATCCATCCCACAAGAAATGTATGACTTAACTACTCGTGCATTCCTTGCTTGG +TTCAAACTGTATTACAAGCATTATGAAGATCATGAGCGTGTTGATGTAGACACCTTGAGT +AGCTTCATTCGTTTGAAAGGTAATCAATCTCAGGAACAGCTAAAGCTGACTGACCGATTA +CTCAAGCAGTTACGTGAGCCATTGGATGATGCAGTCCGTGCCACAACATTAAACGCTTTG +GAAGAACGTCGTCTATCAGGTGAGGCTGAGATGTTAGTCAAGCGCTATAATGATGGTGAG +GAAATTGACATCATCCATGAGATGCGTAAGCTCGTACAAGCCTCGGAAGTTGCATTAGAT +GTACAACATGCATCATGGTGTGATACCGACGTAGGTGAGCTTATTGACGCTGATGCTGAT +GACTCAGGATATGTATTGGACTTCTTACCTGAAGAACTATATACCTGTATCAAAGGTATC +AATGAGGGTAATAACGTAGGCGTAGCAGCACCTACAGATAAAGGTAAGACTTCGTTCTTA +GTTAACCTTGCTGTATCGTTTGCTATTCAACGTCGTAACTTCATGAAGCAATGGACGATT +GATCTTGAAGACCCTGAGAAGTGGTCACAGCGATTGCAAGAGAAGAATCGCTTTAGACCT +GTATTATACCTTGTGAATGAGGGTACGGCTGAAGTAATCACACCGCGTGTATATCAGACA +GCATTGAAAGTAACCCGTAAGGAAATGTATGAACGTCGTAAGGCAGGTACAATTACTTCA +GACTTCATTGATGCTGTAGGTCGTCGTGATGCTATTCGATTGAAGAACATCCACGGTAAG +TCTGTAGCGCAGGTAGCTAAGATCATTGAGGCACATGATCCGTTCTTAGTCATTACTGAT +ATGACTGGACGTATCCGTGCTAATGGTGGCGGTGGTGGAGCTAACGATATTACACAGCTT +GAAGAAGTTTGGAATGATATGCGTATGCTTGCTGCAATGATGGACTTCATTCATGTAGGT +ACAGCACAGATCAGTGCCGAGGGTTTTGATAACCTGTACCCACCAGTGTCAGCATTACAG +AACAGTAAGACAGGTATTCAAACCACATTGGATTTAGCATTGTGGATCGGTGCTTATGCT +AACCCTGTACCTGATAATGAATTGATGCGTGGATTAGGTACACCTAAAAACAAATTAGCA +AAGAGTGGTTGTAAAGGTGGTAACCAAGTTATGACATTCTTCGAACCTGAAACAAATAAT +TGGGATGCGGTGACTAACTCATGAAAACAGGTGATGATGTAAAATGTATTAATAACTTTG +GTATTTGGACGCTACGTGAGGGGCATGTATATCGTGTCCTTGATGTACGTAATACAGTAA +TCCAAGTCCAAGGTAAACACGGTTGCACTAACTGGTACAAGAAAGATCGTTTCGTTAAAA +TTAAAGAGGGTAATCACATGGGTACATTAACTAAATCTGAAGTTAAAGTAGGCGATAAAG +TAGTACGTATCAGTGGTACTGGGTTACGAGTAGGTGCGGAGTTCACAGTCATTGGTGTGC +GTCCTGATGGTGCTGCTGTACGTTTACAGGGTCAAGGTAGTGGTTGGTTCTGCATGAGTA +CATTCTCTATTGTAGAGCGTGTGAAGCCTCAACCGAACGTACTCACAGATGATCAAGTGT +TTAAGTATTTAGCTGACGGTGTTGAACTTGAATACTTCTTCGATGATGTTTGGCACAAGA +TCGATAACCCGAAAGGTGTTAGTATCCAATTCATTCAAACTACACAGTTCCGTAAGAAGC +GTGAGTTAATGGAAGTGAATGGTATTGAAGTACCTAAAGGTAGTATGCGTGCAGTTCTCT +TTGATGAGAAAGGTATCGGTTACGGGGTATCTTTTAATAAACGTGAAGTGTACAAAGCAC +CTCTTAAACAATTGGGACTCTGTGGTACTATGTATTGGACTGACCCTCAAGAAGCTCAAG +AGGTATTGGAAGCATTACTCAAACCATTTGGTATGTATGCTAAACCTTTGAAATCAAACC +TATTGGGGTCTTAATATGGACTTAGCATTTGTCGCTGATTACTTGGCTAATCGCAAGAAC +CCTGTACAACTTGTCAAACATTTTGATGAAGTTAATGAAAAGAACATCAAATACCCACTG +ATCGGACAGCTTAAATATGACGGCATTTATTGTTTACTTGTGTGCATTGGCTCTGAACTT +CAGTTGTTTAGTCGTGTGGGCAAACCTCTCTACATGGAGAACCTCAACGGTTTTATGGAT +GGTCAGCTTTGCAATCTTGCTGATGGTGTGTATATCGGGGAACTATGTACTAATGAGTTA +TCTTTAGAGGTGCTTAGTGGTTATGTATCACCTAACCGTAAGAAGCCGTGGGATGACGTA +GGGACGCATAAGATCGGTGAACTAGGTTACATAGCATTCCATGATTACTTAACGGTAGAT +GAGCTGTTAGACGGTCACAGCGATACATCCTATCGTAACCGTTACTCAAACTTAGAAAAC +CGTTTGCAGAATGCAGCTATCGTTGGGTACACGGTGAAGTCTACACTGATCTATGATCGT +GAACAGGCTGATGCTTACGCTGAAGACTTAATTAAACGTGGGCATGAGGGTGCTGTCTTT +AAAGACCCTAATGCAGATTGGGAAGCAGGTCATAAAGGTTATCGTGCAATGAAGATTGTA +CGTGGTATCCCTCCTCTTGATCTTCTATGTGTAGGTGTTGTCTATGGTAAGGGTAAACGA +GCAGGTCAAATTGCTGCTCTACGCTTCACCATGCACGGTAATGAGTTCAATGCTGATCTT +GGTAAGGGTTGGACAGATGAACGTCGTGATCTACTAACACTCGCTTACCAAGAGGATCGT +GGTGAGGGTTGGGATTGCAAGGTGTATAGCGGTACGCTTAACGAAGAAATGCGTAACCCT +GTAGGTAAGATTTGGGAACTCAAAGCATTGCAGTATAGCTCAACTGGTAAGGCATTACGT +CTACCAAAGGTTGTACGAGTACGTGAAGATAAGGAGACTCCTGATGCTTAATGTGGATGC +TTTTGGTAATGAGGTAAATGAGGGTGATTCTGTGGTGTGTGTGGTGCATGAGCGTTATGG +TTCAACACGGAATATACTTGTAGCAGGTAGCATTGTTAAACTTAACAAACGTACTGCTAC +TATAGATATAGGTAAGCCTGATTATATCATACGTCCTAGTGATTAGTTTCATAAGGTAAC +GTGTCCATAATGTAAAGTTATGTAACTAACAGTCTGAAAATAACGTGTTTGAGGTTTTAT +AAGTATATGATTTCAAACACGAATATTAGAAGATAGACGTATAAGATAGATAGAATCCAC +ATAAGGAAACTGTATGTTTAAACATAATTTCTTTATCCATGACTATGAAAACCAAAACCA +TCCTTGGTACGGTTCAATAGCATCACCACATTGTCCTGATAACTATATTGTAGCTACTGG +ATATTGTATTGATGGGGGTGACATACAAGCACATTACTTTGATAGTGATGAAGAAGCTAA +GTCACATAAATGGATTGACAAGTTACAAGATTGTAAGATGTATGTAGCACATAACGCTAC +GTTTGAAATCCAATGGATGTTACGAACTTATCCTACTCAATTCTTAGATTGGATTAAGAA +AGGTGGTAAGGTATTCTGTACACAATATGCAGAGTATATGTTAACCCATCAACTTGAGAT +GTATCCTAAGCTTGAAGACTGTGCTATTAAGTATGGTGGTTCTAAGAAGATTGATGAAGT +TAAATTACTTTGGGAACAAGGTGTATTAACTGCTGACATTGACAAAGCTCTACTGATGAA +ATACTTAGCAGACCCTAAACTTGGTGACGTAGCGAATACTCGTCGTGTATGCTTCAGTCA +AGTAGCTTTGTTACGTAAACACGGTATGTGGGATATGTTCATGGAACGTATGAACTCACT +ACTGTTTAACGCTATTGCTAGTTACCACGGCTTATATGTGGATATGGAAGTAGCTAAGCG +TAACCAACAAGCTCAGGAAATTGAAATTGAAAATATTAAAGCGTCCATCTTGGATATGTT +ACCTGCTGATCTTCCTGACGACTTTGAGTTCTCATTCACATCCGCATACCACTTGTCGGC +ATTCTTGTTCGGAGGTACGATTCAGTACAAAGCGAAAGTAAGTTATGACCCTATCAAGTA +TGTGAAGAAAGACTGCTATCAATTTGGTGATAAGTTTGTACCTGTCACTGATGATGAATC +TATACTTGTACAGTATGAGCTTGTGTATGGTGAGGCTTTACGCTTTCTACGTGGTAAGAA +TGCAGGGCAGTTAAAGATAGTTAAAGTAGAGACTGCTGAGGAACTTCTGAAGTGGGGTGA +TAAACAATACCGCTTCAAAGGTTTACTTGATTTCGATACACTACCTAAGATTGTGTCTGA +AGCTTATGTAGGTAAGCGTGCTGAGTTCCGTGGTAAACGAGAGCTTGTAGATGGTACGCC +AATCTACAGTACAGGTAAGGATAGTCTCGATGTACTTGCAGCTCATACGGATGTTGCAAA +GCCATTGAAGAACTTAGCTGCACTTATCAAAGACACCACTACTTATTACCTTGTCGTTGA +TGACAAAGGTAAAGAGTCGGGTATGCTTCAATTCGTAGAGCCTAACGGTATCATTCATCA +TCAACTTAACAACTGTGCAACTATTACAGGTCGCTTGTCAGGTAGTAAGCCTAACATGCA +GAATATTCCTCGTGATGGTACATCTAAAGTTAAGGAGATGTTTAGCTCACGCTTTGGTGT +TAATGGACGTATCGTTGAGGTCGATTATTCTGCTCTTGAAGTTGTAGCCCTAGCCAGTAT +CTCAGGTGATAAGAACTTGATGCGGATGCTGATTGAGGGTATCGACATGCACTGTTATCG +TCTAGCTGCAAAGCTTGGTGAAGACTATGAAAGTGTATTCGAGAAATGCCACAACAAAGA +ACACCCTGAGCATAAGCAATACAAGCAATGGCGTACAGATATTAAACCTCGTGCCTTTGC +TCACCAATATGGTGCATCTGCTGAGGGTATCGCATTTAGTACAGGTTGTACCTTAGAGGA +TGCACAAGAGTTCAAGAACATTGAGTTTGAATTGTTCCCTGAATCTAACGCATTCCCTGC +TAAGTTTGTACGACCGATGGTAGAGGAAACAGGAAATGCTGCACAACCCATTCGTGAGTT +TGATGAAGAAAGTGGTCGTTATAATGTGTATCGTCGGGGTTACTTTCAAGCGAAGTCAGG +TACTTGCTACTCATTCCGTCAATATGATAAATGGGATAAAGAGCTTCGTATTACCGTCAA +AGACTACAAAGACACACAGATTGCAAACTACTGGTGTCAAGGTGAAGCATCCTTTATTGT +TCAAGCTGCTTGTGGGCGAGTCATCCGTGAACTCATTAAACGAGATTTTGCAGATGGATT +GGTCGTGCCGATCAATACCGTACACGATGCAATCTACTTGGATTGTGCAACGGAAGCACT +TGCTAAAGAATACGGGGCGTTGGTAAGGGATATTATGGAGGCTACTCCTAAGTACCTTGC +TGAAGTTATCCCTGCACTTAAAGATTGGAACTATCACTTAACACCATTCCCTGCTGCTGC +TGAATGTGGGGTTAACATGATGAACAAAGAGGATATTTAATGCATATTGCATCCACTATG +CCACAGGGTATATTCTGCCCGTTACCTGCTGTCAGTAACTTAGAGTTCTGTAACTTCACT +TACATGTGTGTTCGTGACCCTCTTGCATTTGAGGGTGCATTACGAGTACCTGAGAACTTA +CAGGATATAGTTATCCCACTGTTATCTTTGATACTGGATAAGGTAGACACGGATGATTAC +ATTTATGTCACAGTTAGTCGTAAACACCTACAACCTAACACATGCGGTAATCGAGCAGGT +TGGCATGTGGATGGTTTCCTAAGTGATGATCAATCATTTATTTGGTTCGATAAGTTACCT +ACTCAAATTGCATTGGGTGGCTTTGAGGTTAGCCCTGATCATGAACAATCATTAGAGCAG +TTTGATGCCCAAGTAGATTACGGGAATATACAGTACACTGAACCTGCTATGTTGTACGAA +TTAAAAGATTGTGTACATCGACCAGTCTTCAACCACACTAATGACGTTCAGTTGCGTACC +TTTGTTAAGATCGTAATTAGTAAAGAACGTTTCAATGGTATAGGTAATGCTTGGAATTAC +CTACTACCACACATCAAACCTACTAAACAGCGTGGTGAGTCTCGTAACCACACTGTAGTT +TAACCTGTACTCACAACTCAATTCTTAAATTTATATCGGAGATTATTTCATGACTCAATC +AGCTATCAACTTCTTAGACCTTGCACACGGTATCGACGTAACTACTCTTGACGACATGAC +TGATGTTTCATCAGGTGGTGGTGCTAAACGTGGTTTATTACCCGCAGGTGTAGCTTTTGT +AGTATTCAGTTCATACATTGAGTATGGTAACCAACCACAAACTTTTGAGGGTAAAGCTAA +AGACCCGCTACCTGAGTTCCGTTTAGGCTTCCACGTTGTAGGTGGCGTAGGTACTAACAA +AGAGGGTGAGCTTGAAGATTATGTGCAAGATGGTTTCTGCCCTACAATCAACGCATTCGA +TTGTAAGTTGAGTACGAATGAGAAAGCCCGTGCTGTTGCGTACTTCAATGCGATTAACAT +TGCACCTAAAGGTACACACTTCATTCAGAAGTTAGGTACATTATACACAGTGGAAATTAA +GATCGGTAAGAATAAGAAGACTGGTAAAGATCAGAACGAAATTGACTTCCGTAACTTACA +ACCCGCTGTGGATGCTGCAACACGTAAACCATATACCACATACTGTAATGCTGCTGATGA +AGTAGTACCTATGGGCGTAGTTAAACCTGAAGATGTTAAAGTCTTCTTATGGAATAAACC +ACCATCGGTTACTAGCGAACAGTATCAAGCTATGTGGGATAGTATTGAAATTAAAGGTGA +GTATGAAGTTAAGGATGCTGATGGTAAAGTAACTGGTAAGAAGTCTAAAAACTTCATCCA +AGAGAAATGCTTATCCGCTCTGAACTTTGCAGGTTCAAGCCTAGAGCAGTTATTATCAGG +AGGTGTTATGCCACCTCTTGACGCTGATGAAGCTGAGGCTGCTGATACACAAGCTAAACA +GGAAGCTGTTAAGGCTGAGGTTGTTGAAGAACCTGAATCTGAAAATGAAGTTGCATTGGA +TGTTCCTGACCTCTAATGTGACCGAGTGAACCCTACGGGGTTCATTCACAGAAGCGATCA +TTTGTGATTGTTTCTCTGAATGAATCATAGGAGACTTAAATGACTGATACTAAACGTGCT +ACTGGGCGTACTACCCGTATGATATTCAAGGTTGGTGAGTTTCTAGCTGCTAACCCTGAT +GAGACAGCTACCATTATAATTCACTCCCAATCGTGGGGTTGGATGCGTAACATGGTTAAT +AGTCTGCTCTCGTCGGATATGTCTACCCGTATTACCATTAAATCCTACAGTACATGGTCG +TCATCGGGTATAGGTAAACGTCCTGATTATTTCTTTGATCACCACTGTTTTTATGACCAG +TACCTACGGGCTAAAGCTACACTGGAATATGTAGAACAGGAGTACACAAAATATGACGTT +TGATCTAAGTCAATTTGGTTTAGATGCTAAGGCGTTACAATCTCAGGATACATACAAAAC +CTCAACGGCAGGTAGTGTTCTATTACTGGATGGTGATGGGAATGCTTACGAAGCTGCTGC +GGGTAAAGCCAAACCTGAGACCGCCTTACGTCACTTTGAACGTAGTATTTATGAAGCTAT +GTTCCTAGCAGGTTGTGAGAAAGCACGAGTACATTTAACCCCTCGTGGATGCTTCAAGAA +TGGTCGTCATTTGCTGTTAGGTGTTAAGCCTTACCAACTACAGCGCAGTAACAATAAAAA +GCCACCACTGGTCGCTGTGTTGCGTTCTGAACGTGCTATAGACTGGTTCGCTAACAATGA +TGATATTGAGATCATCCTGAACTATCAGATTGAAGCCGACGATGCTTTGATGATCGACCA +TTACCGCATGACTAATGGAATCCTACTGAGTGCGGATAAGGATTTAAACTTGAGTCCTTA +TAAGTCATACAGTATGGATGATGGTAAACATATAGTGCTACCTGATGGTGATACGTTTGG +TTGGATTGATCGTAAGCACTGGTTAACACCAAGTCTTAAACCTGCATCTAAGATGATCGG +TAAAGGTACTAAGTTCTTCTTATCTCAGATGCTCATGGGTGATACTGCTGATAACGTCAA +AGGTATTATAAAGCTCAATGGTAAAGCGTGCGGTGAGGCAGGTGCTTATGAAGCCCTAGA +CCCTATCAAGGATAAACATGAAGCTGTGAACTTCGTTATTGAAGCTTACAAGAAGATTGA +TCAAAACATTATCCCTGAAGCTGAAGCTATGTGGTTATTGCGTAATGCACAAGATAACTC +ATTAAAGTTCTTTATGGAACATGACCTAACTGATAGTAACTTAAATTTCTTAAACGAATG +CTACCATGACCGTAAATGGAAAATGGAAGCTGATGATTATGAGGGTGACCTAAATGAAAT +ATAATATTCCTGAAGCTGTACAGCACGTTATTGATCAACTTAAATTGGTTGGTATTGAAG +CTACGTTGGTAGGTGGTGCGTTACGTGCTGCTGCTCTTGGTGGTACATCCAATGATTATG +ATTTAGTTATATTTGGTGAACGTGAGGACTTCTTCCACACTGATAAGGAGATCGAGTATT +TAGGTTTCCGTAACCAACACCATGACGAATACTGTAACAACGAGGGTTATGTAGCAGATT +GGCGTAAAGATGATGTGAATATCATCATGTATGATTCTTGCAAAGTAGCTGACTGGTATG +CCTTGATTGAAGTGTTTGATTTAAACATCAACCAATGGTATATCAACGAAGCAGGTGAGC +TTGAGAATGATTACTATGACCCTGAAACTAAGCTCGTAAGTATTAACCCATTCCGTGATG +GTCTAGGTCATGCTGAACGTCTCACCCAACGTATTGAACGCTTCCGTACTATGCTTCCCG +ATCTTGATTGGTCTGAGATTGAGAAGCGTCGTAAGGTTAACGATTACCTTGGTACGGAGA +TCGTAAGTTATGTCTAAACCTTTACAACGTATCCCACGTAGTCAGTTATTAGCTGTCACT +ATGTCCATCCTAGCCAAGCAAGGCGGGAAGTGTCCTATCTGCTGTCGTATGATTAACACT +AAGGTTGCAGGTCGATCTTCAGACTACGTAGCCGATCATGATCATAAGACAGGTGAGATT +CGTGGTGTACTTCATCGTTCCTGTAATGCTGCTGAGGGTAAGGTAGCCAATGCAGCAGGG +GCGTGGGGTGCTAAGTCTATGGCGTATGAGGATATTGTCCCATTCGTTGAGGGTTTAGTT +ACATACTGGAAGAACGCTGAGAAGTATGGTACTGGTATGATGTACCCTGAGCACAAAACT +GATGAGCAAAAGAAAGCTGCTGCGTCATTGAAACGTCGTAAAGCTTACGCTGCAAACAAA +GCTAAACAAAAGGTAAAAGATAATGCAAGTAAACGATAAGATTACATGTGCCTATGCAGG +GCAGTATCAAGGCACATATCTTACAACATTTAAAACTTATACAGCCCTCAGTACCATGCA +CGATCATGGACGGGACTATGTAAATCTAGTTGATGATTCAGGTGCAGAACGCACATATAC +CGCTAACCGATTCGTAGTACAGGAGAACTCTTAATGTCACAAGCCCACTTCAATAAACTG +AAACCGTGGAAACAAACTGCACTACGTCTACACATGCAAGGTATGACTGCTGCTGAAATC +TCTCGTGAATTTAATAATGAAATCTCAGATCGCACTATCCGAGATAACATTCAGAAACTT +GCACCTCAATTTGAACGTAGTGTTGTACTTGCAGATCGTAAACCAACTATATTCGTGATT +GGTGATACACAGTGTAAGCAAGGTATTGACCTCGATTATATGCATTGGATTGGGTCTTAT +ATCGCATACAAGAAACCTGACATTATTGTGCATATCGGTGATCACTATGATATGGCTTCA +TTATCAAGTTATGATAAGGGTCAGTTAAAGGCTGAGGGTCGTCGTGTTGTAGAAGATATT +GAGGCGGGTGATAAAGGTATCGAGATCATCGAATCTTATATTGCTAAGGTCAAAGGTTAT +AAACCACGTAAGGTTGCGACGTTAGGTAATCATGAGCATCGTATTGATCGTTACGTTAAT +GATAATCCTGAGCTTGAGGGTTTCATGGGTACAGATCAATTAGCCTTTGCTAAACACGGT +TGGGAAGTCTTTCCGTTCTTAACACCCGCCACTATCTGTGGTATCAACTTCGTACACTTT +GTACAGAACGGTATGACGGGTAAACCGCTAGGTGGTACGATCTTAACTCGACTGAAGAAC +GTGGGTGAGTCTTTCGTAATGGGGCATCAACAAACACTTGATCATTGTATCCGCTATCTA +CCCCTAAGTGGTCGAGCGCAGATTGGTGTTATCATTGGTGCATGTTATGAACACATGGAA +GACTATAAAGGCGTACAAGGTAATCATCACTTCCGAGGTTGTGTTATGCTATATGAATGT +AATGATGGTTTTGGTTTGGTTAAGCCTGTATCACTTCAACACATGAAAGATCAATTCTTA +GGAGCTTAATTATGAAAATCGGTTTAATTGGTTTAGCAGGTGCAGGTAAGGACACAGCAG +CATTATTGATTCAAAAGATTCTTACAGATAATGGTAAAGCATACAAGATTGATCGCTTTG +CTAAGCCTCTTAAAGATGCAGCTCGTGAGGTCTTCGGTGCTACATTCGATGATCGTGATG +TTAAGGAAGTACCTGTTAAGGTAGATCAAGATACCATGATTGAAGCCTCATTTAAAGCGT +TACGTAAGTGCCGACTTACTGAAGCTGAAATGGATAAAGCATCTGAGTTGTTCTTTGAAC +ACTTAGGATTTTGGAATTACCTATCCCCTCGTAAATACCAACAGTTGCTCGGTACAGAGG +TTGGACGAGCTGCACGTAGTACCGTATGGTCTGATCGAATTACGAAGTCTACAGCTAATC +TGATCGTACCTGATGTACGGTTTGATGGGGAGGTTGTAGATTACAATATTCTAATCACCC +GTCACCCTGTAGGGGTCGGTAGTGTACATGCTTCTGAGGTACTCGCTACAGAGATGCAGC +TAGGTCTTAATGAATCTTATGATGCTATGTTCACGAACACTGGTACTATTGATGAGCTTG +AGTCTAAGCTACGTACCCACATTGAAAACTTAATTAAGCAAGAGGTTATCTAATCGTATG +GATTTACTACAACGTCAGATTGATTTGGAAGAAGAATACTCAACAGCAAGTTTAGTTGCA +GGCCAACAACAGATCATGGATGCTTTCAAACAAGGACGAGCTTCTGACGTTGGTTCAGGG +CGCTTGTTACTTGCTAAAGCATTCCAAGCTTCTATGGAAGACTTTGAATCATTCTTAGCT +AAACCACTATCAGGTATTGGTGGTAAGTATAAGAAGTTATTAAAGATTGCAAAGCCTGAA +GTATTAGTTATGGCGGGTATCCGCGAGGTTATCAATGGCTGTGCTAACCCTGAACCTATA +GTAATGCAGAGCTTCTTACGTCAACTAGGTCGGATTATTGAATCTGAATCTATGTTGGTA +TGTATGGAGCAAGTATCTGATGTTTATACAAATCGTACAGTAGAGTATCTTGATTCAGCA +GGTACTAAATCCACTACACACCGCTACCGTACATTCCTTAAAGGCGCACAGAACATGGGT +CTTAACTGGGAACAATGGACTGTAGAGGAACGTATAGGTACTGCCCGTTTACTATTGACT +TGTCTTTATGAAAGTACGGGTTTATTCAAGTGGGTAGCTAACCGTGGCACTACAGATTCT +ATGTATTACCTTGTGCCAAGCGAGACTTTAGAGAAACACTTTGGAGAAGTACAGAGTGCT +GCTAAGGCTGTAGTTAAATATCCACCTATGTTAGTACCGCCAATGGATTGGACTGGACAA +TACGACGGGGGTTATATGACAGAGTGGTTTCGTTTACACTCTCCTATGTGTGGTATCCGT +TTCATTAAACCTGAACATAAGAAATGGATTATTCAGAACTTAAACAGCGAGCAATCGCTC +CCTGTACGTACTGCAATGAACAAAGCACAGTCTGTACCTTACCGTGTGAATCAGCGTGTA +TTGACGATTCTACGTACTGCTACGGCTATGCGTGTGGGTATCCTTGGATTACCTAGTTTC +GTTGAAACACCTAAACCTGAGTTCCCATTACCGCAAGGTTGGGAAAAGGATGCAGCTACA +CAAGCCGAGCTTGAACAATTCCAATTTTGGAAAACTCAAATGGCTACTTACTACACTAAT +GAGGCTAAACGTAAAGGTCGTCACATGGGTATCCTGTCACGTATCAATGAACTTGTGAAA +TATCAAGAGGAATCACGCTTATACTTCCCGACATTCATTGACTGGCGTGGTCGTTTATAC +TTCCGTTCTAATCTTAACCCGCAATCATCTGATGCAGTTAAAGGCTGCTTAGAGTTCGCT +GAGGGTAAAGTGTTAGGTAAAGATGGACTGCGTTGGTTAAAGGCGCATGTCGCTAACTGT +TGTGGTTTTGATAAACACGACTTAGATACAAAGGTAGCTTGGACAGATGAGAACTGGTCG +CAAATTGAAGATTTTATCAATAACCCCCTTGATGTTGATGCCCCTGAACCTGACACAGCA +TTTACATTATTGCAAGCTGCTATCGCCTTACAAGAAGCACTCGCACTGCCTAATCCCGAA +CTTTATGTATGTCACGTACCTGTCGCTATGGATGCTACATGCTCAGGCTTACAGCACCTG +TCTGCACTCACTCGTGACCCCGTAGGTAGTTATTACACAAACCTTGTAGATAACAAAGAC +AATAAAAAGTCTGACATTTACATGCGGGTTGCTGAAGTTGCTAAGAGCATGTTACCTAAG +CTAATTGACGATGTGACAGTAGATCACTTTTGGAAAGTGAATGAGATCACACGTTCTATG +GCTAAGAATCCTGTAATGACTTATGTGTACGGTGCAACGCTACTACGTTGTATTGATACC +ATTGGTTTAGCCCTATCTGAATCAGGTGTTGAACCTATTAAGAACGATGCAGGTAAAGTT +GTATATAGTATGACTGCACTTGCTACACCTGTAGGGAAAGCTTTACGTAAAGGTGTTGAA +GAAACTGTACCTGAATCTGCTAAGATGATGAAGTTCTTACAGACTGTGGTACGTAAACAT +AAAGAGCATTGTATGCGTTGGGTTACCCCTGCGGGTGTTCCTGTAGTTAACTGGGCAGAG +GGTTCTATCATCAAAACGCTTAACATCCGTTCTATGGGTGTCACCTCAGTAACTATGAAA +GTAGGTACTAAGCAATATGATACTCGTTCAGCAGCAAACGGTATTGTACCCAACTTTGTA +CATAGTATGGACGGTTCACATCTATGCTTAACTATTAACGAGTTCAATGGGCAGGTTCTA +CCTATCCACGACTCATTCGCTACCCATCCTAGTGACGTAGGTGCTATGCATGAAGCTTTA +CGTAAGACATTTGCTGATATGTATAAAGCTTATGATATTAACGACTTCTTAACTTTCAAT +GAAGTCGATACAGAAGAATACGAAGCACCACCTCAAGGTAATCTTGACTTGGACTCTGTA +CTCACAGCTCAATTTATGTTTTGTTAATCAAGGAGATTACTACTATGTTATTCACTATTA +TCGCTCTTGTTGTTCTTTCTTACATGTCAGTTAAATTATATGCTTGGGACTTGAAAAATG +AGTTCACGGGTTTTGGTGACTTCCTTAAAGATTGGGTAGGTTGCTTCTCTAAAGCGGAGC +TTGGTCAAGAATTTAAACTGTTTGGTTATGAGTTGGTAGAAGCGTTCAAAGCGTTCCTAC +TGCCTATCAAGACACTAGGTACTATTGCACTGGTCGTGTTCTCACCTATCCTACTATTTG +TAGTTAATATCCTAACCGCACTTATCAAAGTACATAAACGTAAGTAATCAGAAGCCCTTG +AGCCTAACCGCTTGAGGGCTTTTTTTTTTGTTTATCAATAACTTAACGAGTTACACAATG +TTACACATGTTGAATAACGTCTGTTCAATAGTGCTACGTAAGTGTATGATTTTAAATAAG +TAATTAGAAGATAGACGTATAAGATAGGAAAGGAGATTCAATCGTATGAATATTCCAAAG +TTTACAGATGATCAGATTGATTATTTAAATAGAGTATTTTCAGAGAATACAGTTATGACC +TTAGACCCTAATGAGTTGTATAGACGATTAGGTAATAGACAGGTTATCCAACATATTATT +CAGTGCAATGAGAATGCTAAACGTAAGATCACATCTTAGGAGGTAGTTATGGGTTTAGGT +TCATTCCTGAAGAAATCCGTTAAAAATGCTTTCCGTGGTGGTAGTATGTGGAAATTCGCT +TCTAAGGCTGCTAAGCCTGTTGAAGATCAGGTGCGTAGTATGTTAGGTCTTGATGCACTC +AAAGACTTAGCAGGCGCACAGGAAGCACAACTACGGCAACAACAGGAAGCTAATAAATTG +GATGCTTCAGTGGAGTCTCAGAACGTGGCGCAGTTTGATGATACGTCAGACACAGGGTTT +ACAGGTACGGATTCCCGTCGCAAGAAGAAACAATCAGGTGCTTATTCACAGGCACTAGGT +CTTCAGTTGTAAGGAGGTATTATGGCTAAGTATCCTGAGATCACTTATTCACTCAAGGCA +TTGTATAATCAGTATCGGGATACTTCACTACTTTCACGTATTGAAGACTATGCTTTTTGG +ACTATCCCTAGTGTGTTTCCAAAAGGTGATCAAGATTTTCGACAACAACAAAACCGTGCT +ATCGAATATGATTATCAAGCTGTAGGTGCAATGTTAGTAAACCGACTGGCTACTAAGTTG +GCACGTACATTATTCCCCGCTAACCAATCGTTCTTTCGTATCGACGTTAGTGATGATTTA +AAACAACTGTTTGAGCAAACGAAATTAGACAGTGTTATCGAATATGAAAACCAAGCATGT +GAACAATTGTACATGAATGCATCTTATGCTCAACTTGTACAAGCAATGCGATTATTGGTT +ATTACTGGTGAGTGTTTACTGTATCGTTATAATAACGCATTACGTGTATTCTCATTAAAG +GATTACGTCCTTAAACGTAACAACGTTGGTGAGGTTATGGATATTGTTATCTGTGAGCAT +AAGTACCGTGAGGAACTTACACCTGATCAACGTGTCAAACTTCAGATTACAGAGTCTCAG +ACCCGTGTTAAACTCTATACCCGTGTTAAGCGTAAAGAGGTTTATGGTATTGTGTCTTGG +CATGTAACACAGGAGATTAATGGTATCGACATTGGTACTAATACTGTGTATCGTGATAAG +CTATGCCCATTCATCCCTGTCGCATGGAATCTCGTTAATGGTGATTCTTATGGTCGTGGT +TATGTAGAGGATTATGCTGCTGACTTTGCTAAGTTATCAGATATGTCTCGTGAGCTTATG +TCTTATGAGATGGAGTCTTTACGTCTTCTACATATGGTTTCCCCTCAAGGGGCTGTGGAT +GTAGAGTCTGCTGCGAATGCCCCTAATGGTGAGTTTATTCAGGGTGACCCTAGTATGATC +AAGCCTTATGAGGCAGGTTCGTACCAGAAGATTGCTGAGATTCGCAATGATCTTGAAGCT +ATTGAACAACGTTTAAATATCGCTTTTATGTATACAGGTAATATGCGTGAGGGTGAACGT +GTCACTGCTTATGAAATCCGTCAGAATGCTGAGGAAGCTGAGCAGGTCTTGGGAGGTGTG +TACTCACAACTATCTCAAAGTATGCATTTACCATTAGCGTATTTATTACTATACGAAGTA +AAACCAAACATCATGGAGGCGATTGACTCTCAGGAGATTAAACTAAATATCTTAACTGGT +ATTCAGGCATTATCTCGTTCATCTGAGAACCAAGGTCTAGTAATTGCTTGTTCTGAGTTG +AACGCTATTATCCCTACAATTGCACAGCTTGGTAAACGTTTTAATATTGATGCTATTGCA +GATAAAGTCTTTGCATCTAATAACGTGAACATCAAAGATATTACATACACTGAGGAACAG +CTACAGGCTAATGCTCGTGCTGAACAAGAAGCTATGGCTCAACAGCAGGCACAGATGACT +CAAGGTATGCCACAACAACTTGCAGGGCAAGAGTCTGCTATCCAAGCAGTTCAACAAGCC +CAACAATTTTAATGGAGATTTAAAATGACTCAAGAAGTAATTACACCTGAAGTAACCTCT +GCTGCACCTGCACCTGCTGCTGTACAACCAGTGGTAGAACCTGCTGTACAACCTGCTCAA +GAAGTAGTATATCAGCAAGCTCCAAACTTCACAGGTGAATCTGTACTTGAAACTTCTATT +AATATCTTCTCAAGTGGCGCAGGTATTGACGCTGTACGTTTTGAAGATGCAATTGAAAAT +GCAATCAAATACAATGACCCTAATTTAATTAATGTGGATGCACTTACCGCAGGTCTTAAA +CCTGAGCACGCTGCTCAAGCTAAAGCATTGGCTCAAGCTGCATATCAGGAAACACAGGCT +GCAATTCAACGTGCCTCACAAGAATCTATTGCTACGGCTGAACGTCTAGCAGGTGGTTCT +GAACAATGGAAAAATATCAGTTCTACATTTAATACTAAAGCACCTGCTCATTTGAAAGCA +GTAGTGTCACAGATGTTAGATGCAGGTGACGTACAGAATGCTGTACAGTTCGTTATTGAT +ACAGCAAATGGAGTAGGTCTAGTGAACAGTGGAAATGATCCGATGCAAGGCGGTGTTGGC +GGTAATGGTGCTGCATCTTCAGGTATCTCACAAACAGAATATTTTGCACAATTAGCAACC +CTAGAACGTGAAGCGGGTAACCGTTCATTTGAGCAGGGCGAGTACGCACACAAGTTAACT +TTACTTCGTGATGCACGTAAACTAGGTCGTAATAACGGTCTTTAATATTAGGAGAATTTA +ATCATGGCTCAAGGTACTACTTATCAACCGAATACAACTCGCTCACATTGGAGTGGTGCG +AACTCAGATAAAGACGATCACTTAGAACTTTATACAGGTATTGTAGATTCACGTTTCCAA +TACACTCAAATCTTCCAAGGTTTGTCTGCTCAGCGTTCTACTGAATCACGTTCTAATACT +ATCCGTCTTGACCGTTTGAACGGTTCAAAGGTTAAGGGTCGTAAAGCGGGTGAGGCAATC +GAGTCTCAGCGTGTGACTTCAGATAAAATGAACATCACAGTCGAGTGTATGATGTACATT +CGTAACCCTATCGATTGGATGGACGATTGGACTGCACCTGACTTCTTGACCGATATTGGT +CGTGACAACGGTACTGAGTTTGGTCTAGCATACGATGAGGCGCACTTAATCCGTCTGATC +AAAGCCCGTAACTGGGTAGCACCTGCACACTTAGCAGTGTCGTTTAAAGATGGTATGCAT +GTAGAGGTTGCTTTGAAAGCTGCGACTACTACTGCTGATCTTGAAGCTAACGCTGAAGCT +CTTGTATATGCTCACGGTGTGCTTGTAGAGGAACTTACTAACCGTCATGTACCTTTAATG +GACATGATCACTGCGGTAACTCCTAAAGTGTTTGGTGAGCTTTTACATCACCCTAAATTG +ATCAACAAAGACTACGTAGCTTCTAACGGTGACTTCGCAGGTCGTCGTATCGTTGAGGTT +AACGGTCTACCTATCGTACAGATGACTGCGTTTCCTAAGACTGTGGGTACTAACCATATC +TTGTCTACGGAGACCAACGGTAACGCGTTTGATGTGACTGCGGATGATGTGAAAGGTGAG +ATGATCATTTTCTCTAAAGCGCTGTCTCTAGTCACTGTAACTGCACAGGCTTTCGTATCT +GACTTTTGGAAAGATAAAGCTGAGATGTGTAACGTGTTGGACTGCTTCACTATGTTCACC +GTTGATATTCGTCGTGCTGATACTGTTGGTGTTGCGTTGATCACTCGTACACCTTAATCA +TAACACGGAGGGCTTCGGCTCTCCATTCAATTTTAGGAGTAAAATAACATGGCTAAACTA +GGCGAGACAATTGTATCCAGTGCTATCTCAGGTAAACCTTTAACTTTATCAGATAAAGCT +TTTTCTTTGGTAGGACAAGCAAATGATAAGGTAGCTGCGTTAGAGGGTCAGGTTCAAGCA +TTACTAGCTCTTGTAGCTGCACAAGGTATTGCCCCTACACCAGTAGAAGCACCTGTAGCA +AAACCTGTTGCTAAGGCTAAGACGGGAGAGTAATCATGGCGTTAATCAAAACGATTAATG +CTGCTGATCTTCAAGGTACTAATGAGGTGAGTGTTGACTTCACCTCTGTACTTACCGCTA +TCAGTGGCGTTAAAACAGATACCACTGCTATACAGGCAGACGTTACCGCTGTTAAGGCTG +ACGTAGCTGTTATCAAAACTAACACTACACCAACACCGTAAACTCGAAAGGGTTTACTTT +AAGATATAATCCAAGCAACGTAAATCCCAAGTGGTCGTATTGTGGTGATTATATCTTAAA +GTGAATCAACCATAGGAGGTATAATATGGATATGTTAGAAGCTGTAAATACTGTATTACC +TTATATGGGTGAACACGTAGTTACACGTATTGAGGGTGCAAAGCATCCATCTGTAGATTT +AATCCAAGCTGCTATCAAGCGTCAGCAAGTAACATTGTTGACTACTGGTTGGTGGTTTAA +TGAACTACATCTAAAGTTACTCCCTAACCAACAAGGTTTCATTGATGTGCCTGAAGATAC +GTTAGAAGCGTATGGTAAGAATATCAGTGTTACGTTAGATGGTGAGCGTTTCTTCAATCT +TGATGAGGGTTCACGATATTTCTCTAAACCGTTAGAAGTTAAGATTGTACGTAATGTACC +TTTTGAGAAGTTACCTGAAACTGCTGCATTATATGTAACATATAAAGCTGCTATTGAGGT +ATATACTGCTGATCTTGGTGCTGAGGATGTACTTCAGATTCTAAACAATTATGCAAACGA +TAACTTGATTTCTTTTAAGGAACTCAATTTACGTCAACGGAAGTATAACAGTAAACGGAC +GGCGCGACAGTTCAGTTCGTATAATCGGTTACGACACCGCTAGGAGGTGAGCAATGGCAG +TACGTGAGGGTACGTATAAATCCTTATTACAAGGTGTATCGCAACAGACCCCACAAGAAC +GTGCAGACGGACAATTAGGTTCACAGCTTAATATGCTGTCTGACCCTGTTACTGCATTAC +GTCGTCGTGGTGGTATTAAATTACATGCTGTATTAGAAGACTTGGACAAGAGTAGTTATA +TTCGCATGACCGAGATTCTAGGTGATACTTATATTACCGTTATTGATACAGCTAAAGGTT +CATTAAGTGTATACACTTTTGATGGTGGACTAAAGTCAACTATTCAAAATGATTATTTTA +AAGCTCGTAGTAAATCTAGTATTCGTACTACAGTATCTAAGGATAATTTCTTCATTCTAA +ATACTGAGTTAATCCCTACCAAACAGCTCGAAGCTGAGGCGGGTAAGAATCCTAAGCACT +ACGGGTACTTCAGCATTGTGTCTACAGCGTTTAGTAAAGTATTTACTATATCTGTAACTC +ACCCCTCTATTGGTACTATAACTAAGACGGTTACTGCATCTAGCGACAATGCTGCTGAGG +CAAGTCAGGAAAATATCGCTCGTGGTCTTGCGGATTTATTCTCTCAAGATACTACTTTTG +CAGCGGTGTTTAATGTACACCGTACAGGTATAACTGTAGCGTTTGAGGTAAAGGATAAGA +CGCAAACTGGTACTACAGTTGTGGACTCTACTACTGGTGTTACTTATGTTGTTAAGTCAG +GTGCATCCCGTGTTGTGAATAAGGCTGAGTTACTGGGTACACTACCATCGGTACTTGATG +GTTATATCATGGCTGTAGGTAACGTAGGTAACTCTGCATACTACAAATTCGATCATGGTG +CATTACGTTGGGCTGAGACTGGTGTTTATGAGCCTAACTATAAACTTATCAATGAGCCTA +TGTATTGGTATCTTGATGCTGCTGATACTGTGAAGCTTGTACCGTTAGGTATTAAACCTC +GTGAGGCAGGTGATGACGATAATAACCCTGACCCTAAATTCATTGGGTACGGTTTGACAG +GTATTGGTAGCTACCAATCCCGTCTAGTATTATTGAGTGGTTCATACGTCAATATGAGTC +AGACGCGTTACTTCAACCAATTCATGCGTACTACGGTTACTGAACTGTTAGATGATGATG +CTATTGAGGTTTCTAGTTCTGCACTTAGCTCTGCACAGTTTGAATACTGTGTGCCTTATA +ATAAGGACTTGGTGTTAATTGCACAGACACAGCAAGCAGTGATCCCTGCTAACTCGACTG +TACTCACACCTAAATCTGCGGTGATCTATCCGAGTACAAAAGTAGATTTGTCACTAGCTG +CTGAACCCCAAGTTGTAGCTAGAAGTTTGTATTACACGTATCAACGTGGGGCAGATTATT +ATCAAGTAGGTGAGTTTATTCCCAACACATATACCGACGCACAGTATTACAATCAGAATT +TAACTGATCATGTACCACTGTACGCTACAGGTGTTTGTACATGTATTGCTGCATCTACTA +CTAACAACATGGTAGTGATGAGTTCAGACTCCCGTGATGTATTGGTTAATCAGTTCTTAT +GGGTTGGTGAAGATCGCCCTCTGATGAGCTTCCATAAATGGGAGTACCCATTACCTGTTG +TATACGCTCAGTTCATTCAAGAATACTTAATCGTGTTCATGGATGATGGGCAGGGTAACT +TAGTCATCGGTACTCAGAACGTACAGTTAAACCAATTAGATGATAAACCTATCCCATTCC +TTGACTTGTATGGTTATGTGACCATTGAGAACGGTGTTGGTGTTTTACCTGAGTATTTAC +TTGAGATGAAACCTGATGATATGGAGTTAGCTGCATCTATATATAATGACCGTTATCTGC +GCCACCAAGAGATTGAGTTCTCGTATGATGATGAGGGTAATGTTACATGTCCTTATGATG +GTGTTATCTATGTTGGTGTACGCTTCACAAGTGAGTTTACTTTGACACCTCCTTTTATTA +AGGATGAGAACGGTAAGGTCGTGGCAGGGGCTAAGAGTACGGTAGTACGCCTAGACATGG +AATTTAAGAACACAGGTACGTTTAAAGTGTCCGTAAAGGATACTATGGGTGACTCATACT +ACAATGAGCTTGATACTGCTTTAACGTGGTCTGAGGCTGATTTAGGATATACATGGGTTA +ATAGTATCGGTCAGGTATCTATCCCGTGTCGTACTCGTTTAACGTCTACACAGTGTTCTG +TAGAGACTGTAGGTACAACAGATTTAAACCTTACTAACTGCAACTACTTATTAAGGTTGA +ATCAGAAGCATCGGAGGATTTAACATGGCAGGCAATATGCAGGCAGGTTTATCTACTGGT +ATGCAAGGCACACAGGGGATGGGTGGTCAAGTTGGTGGTATGTGGGGTGCGGTCATCGGT +GGTATCGGTGGCTTCGCTCTAGGTTATAATACACCTGACTACGAGAAGATTGCCCGTGAG +AAATATAATAACGAGGTAGTTAAAAATGCTATCTCGTCTTTGTTCGATATGCGTCGTGTA +CAGAATGTAGAGAACATGCGCACAGCACAGGCTCTCGCAGCTTATCGAGATCAACAGACA +GTTACTACAAGTTCATATAACGCCCAATATGGCGCTAATGATGTGGTGGGTGCTTCTGCG +GATGCTCTAAAGAATACATTAGCCTTTCAAACAGATCAGGCTATTGCACAAACATGGTTT +AACTATGAAACAGGTATTGATAACTACAACATTGGTGTTGAGGGTACAGTGAACTCTGCA +TTAGCAGGCTTACGTCGAACCAAAGGTGATCAGCGTACTATGGACTTAGGCGCACTCACT +AAATCAGGTTTAGATATGTACAAGCAATACGGTGGTAGTTTCAATAACGCAATGGGTAAC +TTGTGGGGTGGTGGTTCTACAACAACTCAAGGCGTGTCAGGTGGTGGCTTAGGCGGTCTA +TCTGATTTTGGTTCGTTTGGTAAAGGTGGCTCAGCCAGTGGTTTAACTGGTGGTAGTTCA +TTAGCTTAATATAGGAGTTTATACATGCCTACTATGGTTCAACAACCCGACTTAATTACA +CCCGAAGTATCTCGACTTCAAGCGATTGATCGTCCTGTAGAACGTAGTGGGCTTAGCTCA +TTCCTAACAGAATTACTCCCGCAAGTTAAAGCGGGATTCGACGAGTATCAGAAAGAAAAC +CGAGACCATTATATTGCGTTAGGTCGTAATGATGAGTTAAACGGTGTACAACGTGATGTG +TCTATTATTGACTCTCACAACTATAACCAAGGTAAAGAGTTCCAAAAGGTTACATCTACA +CAGGCTGAACAACAACAGTTATTCCGTGATACTGTAACTCAAATGGCTCGTGATGGTAAG +TCTGCTGAGGAAATCTTCGATGCAGGTAAACAGTATCTCACTGGTTATACTAACGCTGTC +CATGATAGTCAGCTACAATCAGATTTAAAAGAGGTGTTGTATAATGCAGGTCTCAAAGAG +AACACTGCATATCAAACTCTTATTTCCAAAACAATTAATGAAGTGGCTTTACAACGTGAA +CAGTTTGATTCTCAGACTCGTACTGCAAACACGTATAAGTTACTGACTGAGCAGAATCAT +ACACCTGCACAGATTACGGAATTACTTGAGGCTCATGTACAGAAAGCATTTGCTGCTAAG +ATTGCTAGTAACGTGGGTATTGACCCTAAAGAAGCTATGCAAGCTGCACAGTCTGAAGTA +CAGACTATGTTCAAGTATTGGGCAGGTCAGATCGACCCGTCTAGTCCTGATGCTGCTGCA +TTCGTAAACACTTTGAATAACACATTAGATGTAGCTGTTCAAGGTGGTATCGTGAGTATG +TCCACTGTTGTCGATTTACAAAGTAATGCTAATGGTATCCGTTCACAGATTCTTGAGAAC +AACGGTATCCAATTAGAGAACTCTATGAAAGAGGGTATGTGGAATATTCAACGTGGTAAT +GCAGAGTACAGTCACGACTTCGTACAATCACAGTTAACAGAGATTAACCGTAAAGAAGCC +CAAGGTTTACTTACACCTGCTAAGGCTGCACAACTACGAGATAACTTATTCTCCTTTGGG +GAAACTCAATACAATAAGTTATTACAGGCTGAACTAGACCCTGCACAGCTAGTTAAGGGC +GGTGTCTCTATGATGGAGTATGCTGCACTTGGTAAAGGTGGTGAGGATAGCTATAGTGGT +CATATCAGTAATTACTATGATGGTATTAACAATGGTGACCCTGTTGCTGCGGGTTCTGCT +AAGGTTGCCCACGCTTTACGTGGTGACCCTAATGGTGAGAACTTACCGTCGCTTATGCGT +AACGGTACACAGCAACTATCAAGTCAATTCGTGAGTTTCTTATCGCTACCTCAAGACCAA +GCTGCTAAACAACCACATTATCAGAATGCTGTTAAAGCGTATGATAGTCTGAAAGCTACT +TACATGCAATTGAAAGCTCAAGGTTCTCCTTTGGCTGAGCAATTACTTGCAGGTGTACCT +GAAGATTACCGTGGTACTGTTATGGAGATGTTCGCAGGTAATGCTAATATGAACGCTAGT +GCTGAAGCTCTACGTAACCCTGTTCAAACTAACCAACGTCAAAAGAACGTGTCTGAGGCT +ATTCAGGCTATGAACTGGGATAACGTAGGTGGTAACAAATGGTTTGGTCGTGGTGTAGGT +GGTGGTTCACGTTTACTTAGTGGTATCTCTGAGGATGTACGTGGTTCATATATGAAGAAT +ATGGAGATGGTCTATTCAGACTCTAAACATGCTCTTGCTAATGGTTCTACATCTGCTAAT +CCCGAACTACTTGTAGCTAATGCTACGGCTTTAGGTATGCACGTTAAATCCCCTGCGGGT +TACAACGATGCTTTATTTACAGCAGGTGCGTCTAAGGTTTACCATAACATCACTCATAAG +GGTGTTAAGTTGTCGGCTGATTATATTGGTCATGCAACTGATGAGCTTCGTCGTACTGTG +GCTAAGTCTGCAAATAGTTCTCCTGATAACGTGTTGATTCATACAGATCGTACAGGTCGC +TATGTAATTGTCCAACCGTTCGATAAGAATGGTAAGTTATTAAAGGATAAGCAAGGTGAT +GCATTCCAAGGTGAGGTTTATAATCAGAGCCAATTCGTTAACTTAATGAAGAAAGCTTAT +GATGCTGACCAAGCTAAATACAAGAAGCACACTAGCACATTTGAAACTATCGGTACTGCA +TTCAGTAGTAAAGGTGTTAGTGATACACTTGGTAGTACAGCTAACTACAAAGAGGATATG +GCTAAGTGGCGTAAAGAGTCTAAGTCGTACACATTGAACACAGCAGGCTCACTAGGTCAG +ACTGTTATCTCATTACCTAATGGTACTAAGACACAGGCTAAAATCCCTACGTTAGCATCT +GTACCGTTTAATGGTAACGTACAGCTAGCTACAGCATGGCAGGGTTTCCTCAATAACTAT +GAGGGGTTCAAACCTACTATAGGTGTTGTTAAAGGTACTGGTACAGACAATGACGGTTTG +ATCATCGGTAACGGTGTTAACCTATATGCACATCCTAAATGGAAAGCACGTTTCCAAGCT +GCACAGGGTAACCCACAAGCTTTGCTTAATCTACAGGCTGAGTTCATGTCTAATAATATG +AAAGATCAGCAGTTAGAGGCTAAGCGTTTAGGTATCCCAGTAGCTACCAATAAACCGTAC +AATCCACAATTCATTTCAGCACAGCTACTACTTGCGGATTACAAATGGCACAACGGTAAC +TATAATACCATCCGTGATATTATGTCAGCACCTACGTATAACCAAGCACTAGCTAAAATG +CGTAAGTCGTCTGCATACACACACGCGGGTGATGGTCACCGTCGTAACGTTGCGCGTCGT +AACATGCTTCGTGATTACTACTTAGCAATGGGTAAACTTTAATTATTAGGAGGTTGTATA +AATGGCTAATCAAGTAGGTATTAATAAGGACATTCAAGTTCTTCCATCTGTACAACCTGC +TATCCCTGACCACGCAGCACCGACTGCGGGTGAGGGTATTCGTCCTAGTACCTATCAACA +ATTAGGACAGGCAACTGAACAAGATTTAGCAGTGACGGGTGAGGAACTCCAAGATGAGGT +ACTACCTGAACAACCTGCATTATGGAAAGTCGCACAAGTAGTTGCACCTACAGCAAGAGA +CTGGGGTAATGCTATTTATGAAGACTTTAAATTTGAACGTGATATTTATTATAATTCGGA +TGCGGATGCACAAGAGTTCTTTGAAGCTCATGGTGAACGTAACCGAGATGAAGTAGCTTA +TATTCATGGCGCACGTAGCTATGAGGATATGCAATTCCGTCAACAACGTATTTTAGATCG +TCGTGATGACAACGAGATTTTAGCTGCCCATCCGATTGCAGGTACTATTGCATCCGTAGT +GGATGTTGATTTACCTTTAGCATTCGCACCTGCTGTGGGGCAGATTGGAGGCGCTGCTAA +GTTAGGTCGCTTGACTCAACGTGGTATGCAAGCTGCTGCTCTAGGTGGTGGTGCTTACGG +TCTTAACCAATTATTAGAAGATGGGTCTACACGTACTCAATCAGAACGTAACTTAGATAG +TTTGACATTCGGTTTAGTGGGTTTATTCTCACCTATCAAATATGAAGCCCGTACTACTGG +TACAGCTTTAGATCAAATGGTAGATACTGAGTTAAAAGCTATTGCTCAAGAGACAACTGA +TACTGCTAACCGTGTAGGTAGTGCAGGTACAACTAACGTACTAGGGCATGATATTAAAAT +GCCTATCTCACAACCGATTGATACCTCTAAATTAGCAGTACCTGATTGGGCTGTTCAGAA +CAAGGTTGTAGCTGCTCTACAGTCGTCGGGAGACTACATGTGGTATCTTACTAAGGGGGA +TGCAAATCATCCCGCTAATAAGATTCTAGCAGCTCCTAGAACGCAAGGTGATAATGCTCC +TTATGCTACTGCACCAGTACAAGCAACACTTGAAGCTAAATTGGTTGGTGTTGAGGACGC +TATCAATGATGCAGCTATGAAGATGTATGGTACAAGTCCTAACCGCTTCTTTGGTCGTAA +AGATCATACAGTTGCCCAGTACCAAGTTACTGAACAATTCGGTCAAGCAATGCAACGCTT +AGATCAGGACATACTGTGGAAAATGAACTCAGGACAACCTGTAGATAAGAAAATGATTCA +TCAAATGATTGATGAGTCTAATGTTGCAGATGAGATCAAAGCTATTCAAAAGGCGTATGT +AGATTCAGGCTTTGCTGAGACTGCATTGAGCCGAGCTAAACAAGCAGGGTTGCTAGAGAA +CTTAGATGATGCTGCTGCATTACATTCCCGTGCTACTTACATGCCTGTTAAACACAGTTA +TGAGCGTATGAACAACTTAATTAAAGCAGGTCAAGTTTCCGAAGATCAGTTATATAACTT +CTTAGGTAAACAGATCATGCGTATGTACCCTGAAATGCAGCAAGCTATGAAGATCGTAAC +TAAGGCAGGTACTAAGACTGTCGAGCGTAAGTTCCAATTGACTGCTAAACAGTTAGGTCA +GAACTTCTTTGAGAATCAACAGAAACTAGCACTAGGTTTATCTGAAGTACAAACAGCAGG +TCTTACCAAAGATCAGATGATTACGTTACTTCGTAAATCAGGTGTTGATGATGAGAACTT +AAATAAGATCGCTGATACTATCTATAAAGGTACTCAGGATGCAGGTACGGGTGTTGCTAA +GCAATTCCGTAAACGTCTATCTTGGGATTGGAATATGAAGTTCGTAGGTAAAGATGGTGG +TGAGTATAGCTTAGGTGATCTTGTAGACGGTAACGCCTACATGAACTTAACTGATTACAC +ACGTACTATGTCTAAACGTATTGGGCTTGCTCAGTATGGTATTAAGACCACTGCTGACCT +TGACAATATACTTCAAGGTATCATGAAAGATTTACCCGCAGACGTTGACATTGCAACCGC +TAAGCGTTTCTTACAGAACGTCCGAGCGCAGGCTTTAGGTCATCCTATGGGTGAGGCTGT +TCCTGAGACTATCCGTTCATTGAACACTGTGGCAGGTGCTACATTCCTATCTAATTCAGG +TTTATATAACGTGGTAGATATGGCGACTCAGGTTGCTAAGATGGGATTAGTACGTACATT +GCCTGAGATCATGAAAGGTCTGAAGAACATTGTGAATCCTATGAAGAAACTATCTAAGAA +TGAAGCTAACGATTTATATGATGTATTGACTGGTCTATTAAGTACCGATGGTCGATGGAG +AAACATCACGACTCGTTATGCTGATGACTTTGAGGTTACTACTGGTATTCATGAGGCTAC +AGCTTATTACGGTCAGGCTACTCGATTCATGAACTTGTCTGAGTACGTTAAACGTATGCA +GATTGGTATGATCGGTGGTGTTGTCACTACTGCATTTAAGAACGCAGCTAAAGGCTCAGC +TAAAGATATTAAGTACATGAAAGAAACCTTGAAAATGTCTGATGAATTAACGGAGGCTGT +AATCAAGGAACACAAAGCTCATGGTACTAATATTGATATGTGGTCGAATGATGTACGTAT +GGCTATGGAACAGAAAGTGTTTTATGAGGCTGATAACTTAGCGCATACTATTCGTTCAGG +TGAAATCCCTGCATTCATGGAACATAGTTCTGTGGGTAAGATCATCTTCCCGTTCATGTC +CTTTGCTTTCGCTATGCAACAAAAGGTACTTCGTAATACTTATCAACGTGATGGTGCTGC +GGGTGTGGCTTTATTAGCTGCTGTACAGTTCCCAACTGCTGCATTGATTGGTATGGCTAA +GAACATTAAGAATGGTAAAGAGCCTGAAGAAGACTTGGCTAAGACTTCGGTTAACGCTTT +GAGTATGCTAGGTACTTTCTCGTACCCGTTAGAGATCATCATGAATGGCGGTTTAAACAG +TAACAGTGCTGCGTTAGCACCTGTATCTAATGCAATGACATTAGGGCAGAAAGCTATGTC +AGGTGACCTTGATTTACGGTCAATTAAGAATGCTACACCTTTGGGTAGTTTAACAGGTTT +GGATTTATTCATTTCAGCTATAGAGGATTAATTATGTCGTTTAATGAGAAACTATCATAT +ACGGAGCATGTGGTCGAGTCCCCAACTACAGACTTCGCAATTGGCTTCAAGGATTACGGG +GAACAATCAGATACAATTAACGTACTTGTAAATGATGTAATAGCTACGGAGGCGGGTTAC +ACCGTCTTCCGTAAGAATGCTCTAGTCATTGCACTTGAACCTGCTGTCACATCAGGCATT +GTACGTCTACAACGTGAAACTAATATTGATAAGTCCTTTCATATCTTTAGTGCGGGTGCT +AAGTTTGTCGGTGCTAATATGGACGCAAACTTTGAGCAGATTTTACACTCTCAACAAGAA +ACCCGTGATGGTTTTGATAAGCTGTATTCCGATGTTATGCCATTGGTTAAAGGTCTTGAA +GATGCTTTAGCACAGGCTGATGCAGCGTCTCAAGCTGCTAAGGAGGCTGCTGAAGCTGCG +GAGGAAGCTGCGTCCCAATCTCGAAGTGCTAGTAATGTTATTGATCGTACAGGTTTAACC +CAACAAGATATTAACGATGTGTTAGGTGTTACTACCAAGCTACCCGCTGTTTGGGGTCGC +GGTACTATCCCGTCTATACTAGATCGCATTAATATCAAAGACTACGGTGCTATCGGAGAT +GGTACTCTGCATACCTTACAGGAGTGGGTTACATCGGGACGTTTTAGTAATCTATTAGCT +ATCCAAATGGTATTCCCAAATGCAACAGCTTTAACTGATAGTATTGATTGGTTAGTTACA +GATTACTGCTTAGGTTTACGTAAGTGTATCTACGCACCGCGTGGTACTTATGTATTTAAC +CGCCCTGCGCGTACACCTCACAGTGGTAGTCCTAACCGAGTGGATTCGGGTTGCAGTTTA +ATCGGAGATGGTACACACACTGTATTCACACGTTCGGATAAACGTTTAGCCACACGTATA +TTTAAGGTTGATGGTTCAGAGGATTATGAAGCCTATGATGATGTTAACCGTGACGAAGCT +GTATTTAACGTACATGGCTGTTATCAGATTTTCCGTAATTTCTGTATCTCTAGTAGTACC +ATCGGTTTCTACTTAGGGCAATCAGCATCTAGTGCGGAGAACTCTGCGGTTTATATGTCG +CAGTGGTCTGAGCTTCAGTTTAAAGGTGTTGGTACGGGTATGTTGTTCGCTGCTGCATAC +GGTAACCATTATAACCGTGTAAATAATATCCACTTTATTGAGTGTGGTATTGATGTGGAG +ATGCGTGGTGGTAAGTATGACAGTTCGCCCACTCAGGCTAATAACAACCGTAACACGTTC +TCTAATATTCGATCTAACCGTAGTAAGGTTGGTCTGTGGTGTAAGTCGGGAGATACTAAC +CGCTTTACAACGTGGGATGGTGAGGGTTGTGGTGCTACACCGACTAACAACACTTTTGGT +GCTATTCTAGGGTTACCCCTGAATCCTGACAATGTAGCACTTACTAATGGTGTATTTATC +TTACACGGTAAAGGGCAACTTAACCGCCTTATGAACTGTGTGACTGAAGCGTGTGATGTG +GAGTTATACAACGACCATTATCGTAATAGCTTCACAGGTGTAGGTTTTAAGGAGAACGTT +TACTTAGGTAAGACTGTTATCAATAAACAAGTACCTGCATACTATCAGTCACCGCATACA +CTATTTACACCTAACTTCCATAGTTTAGTGAACCTAAACACATGGGCTTTCCCAACAGTT +ACCAGTTTAGGGTTTACTGTTAAGTCGTTAAGTTTCACCAACGCTACAGGTGTTACACGT +ACTTCACGGGATAATTCATCATGTTATATTGATGAGCGATTAGTAGATTTAGGCTCTGTG +GTTGCTAGCGGTATCATTGAGTACATTTTATGGGCAGATTCAGATGCTAGCTCGACTGCT +AATATTGAGGTAACTATCAGTGCTGATAGTGCAGCATCTAACTTGGGCTTTGCTTCTAAG +TTTGCTGTAGCAGCACACCGTACAAGTGCTAAGACGCTGACACGTTATAGTTTACATACA +ATGTACTCTTTACGTGCGACTGGTCAAGGTACAGGGGACTCGGGCGGTGTTACTGCTACC +GTTGTTCATGGGGGTAGTTCGGGTCGTGATTTGATACTACGTATTCAAGCACCTGCGTAT +GCTTTATCAAATGTGACTGCTACAGTACGTCGGCAGGTTACAGGTTAATAGGAGGAATAA +TATGAACATTGTAGATCAGGTCTACATGGCACTGATCTACATTTGGTCAGAGCTAGATAA +AATGGTAGTCGGTATGGGTTTAACAGCCTATATCGTCGCTGTATTAAAAGGTGAACGTAA +ACATCGTGAGGCAATATTATGCGGTGTATTCGCTATGATTGCAGGTACTGCCTTATCATT +GGTAGCTACGTTCTTTGGTATTGCCCCTGATAACTTCGCAGTATCAGGTGGCGGTAGTTT +AGTAGCGGGTGCTATTGGGTGGTACGGGACTGTACGTACAGTCGATAAGATTGAGAATAA +ATTGGGAGGTAGTAAAGATGATTCTAACTCGGAATAGTTTTGACTACTTACGCAGTATCT +ACGGTAAATTAAGTCAGTCTCAGGTTGATGGTTTAAACTTCCTTGTTTCAAAAATGAAGC +AAGCGGGTTTTACCTATCCTGAAGCTGCCTACGGTTTGGCTACTGTATATGTTGAAACTG +ATAAGACATTCCAACCTATCGCAGAGCGGGGTTCGGATAAATACTTATCAAAATATGATA +CTGGTAAACTAGCAGTACGTTTGGGTAATACACCTGAAGCCGATGGTGATGGTCAACTGT +ATAAAGGGCGTGGTTATGTTCAGATCACTGGTCGAGCTAACTATAAGTTCTTCAGTACGA +TTACTGGTAAAGACTTAATTAAGAATCCTGACTTAGCACTAGATGCTGAGGTGTCTACTA +AGATCATGACACATGGTATGCTTAATGGTTCATTCACTGGTGTAGGTTTCCGTCGTAAGC +GTCCTGTGAGTCGTTATAACTTAGCGCAATACATTGCTGCTCGTAACATCATCAATGGTA +CAGATCGTGCTGCTGAGATCGCACAACATGCTATTGTATTCGAGAAAGCATTACGGAGTT +AGTATGGATTACGGTTTACGTCATGATGGTACACCTAAAGGACGTGGTTTCTTAGGTGAG +ATTAGTAATACTGATGGTAGTGTTATGACTGAGTATAGTATTGGTGTAGAGTTTGACGGG +GTAGAGGTAGATATACCTACTATTACACCAATGTTAGAACTCTCGGAGATTAAGCAGTTA +CAGGCTATGCGGGATGGTGATGACATACCTCAAGGTATTATCCGTAAGGCTATCCAACAT +GCACGTATGCGTAAGGATAATGGATTACCATACTTCGCAACCGAGGACGACTACCCACTG +ATTGAAGATATGCGTCGTATCATAGGAGTAGATTAATGACTAAGAAAGTACAGAGTGCAA +GCGTAAGCACGTTAAATGCGCTACATGAAGCTGTTGCTCGTTATATGCTTATGCGTATTC +AGTCTGCATTCCCTGATGAGGATGCTGAACCGCAATACGACGAGGAAACTGGTGATGAGA +TTCCTACATTCTTTATTCCTTTGGCTGCATCTGAGCTTCAGGTATTCGTATCGTTCTTGG +ATAAGAACAACATCACAGCTACACCTGACGTAGAACACATGGCTGAACTGGCTAATGAGT +TCACTGAAGACTTACGTTTAGCTCGTGAACAGAAAGCTAAATCAATTGTTAAGGTCAATG +AAAACGATGCAGCACTTGCTGCGTACCTAAGTTAAGGAGTTCAATATGTCGTGTATCCAA +CAGCAAACGCTTCGACGTTTAGACTTACTGATGCCTAAATGTAAGAAGTACAACGATAAC +CCTCAAGCTATTCCTTTAGAGGAACGTGAGGAATTATCAATGATGTTCGCTGCCACATTC +AAGAACTTTAAAGAGTTCGCTGAGTTGGGTATGCGATACCTTGGCTTTAAGCTATCTATG +ATTCAAGAAGACATTGCAGAGTTCATGCAGCATGGGCAAGCTAAGCGTATGATTCAAGCT +CAGCGTGGTCAAGCTAAATCGACCCTAGCTGCTTTGTACTGTATTTGGCTTCTTATCATA +AACCCGACTGCCCGTACACTTATTGTGTCAGGTGGTGAGAAGCAGGCATCTGATGTTGCA +TTGCTTATTATCCGAATTATTAATAACTGGTCTATCCTCTGTTGGTTACGCCCTGATGCG +TCCAAAGGTGATAGAACTTCGGCTAGTGCGTTCGACGTACACTACAGCCTAAAAGGTATT +GATAAGTCTGCGTCTGTATCTTGTGTTGGTATTACAGCTAACTTACAGGGTATGCGTGCA +GACTTTATTCTAGCCGATGATATTGAGACTCAACGTAACTCTATGACTCAGACTGAGCGT +GAGAAGCTATTGCTACTTACTAAAGAGTTCGCTGCTATCTGTATCTCAGGTGAGATTATG +TATTTAGGTACACCGCAGACTAAAGACTCTGTGTATCGCTCTCTCCCTGCTCGTGGTTAC +GACGTTCGTGTTTGGTGTGGTCGTTACCCTACCGATGAAGAACTCGAACGCTATGGAGCA +GGTGTGACGATTGCACCTATGATTCATCGTGCATTAATCGAAAACCCTGACTTACAAGTA +GGTGGTGGTGTTACTGGTCAACGTGGTAAGCCTACTGACCCTGCACATATCAATGAGGAA +ATCTTACAAGAGAAAGAACTTGAGTATGGTGATGAGGGTTTCTCATTACAGTACATGCTC +GATACAACGCTCTCAGATGCCCTCAGAACGAAGATTAAACTTTCTGATATGATTGTACTA +GGCGTAGGTAAAGACGAAGTGCCTGAGTCACTACAGTACGTCGCAGACCCTAATAAGTTA +TTCAAGGAAAATACTGAAGCTACTAAAGACTTCCGTATGTACCATGCTGCTGCTGTATCC +GATGTATTCGTACCATTTCTACATAAGGTGATGACACTTGACCCTGCGGGTTCAGGTGGT +GATGAATTGTCTTATGCTATTGGTGGTGCTACTACATCGTATATCTATTTACTTTCAGTA +GGTGGGTTCGCAGGTGGTATGACTGAAAAGAATATGAACTCCGTGTTGCAGAAGATGATT +GAGCATAACGTTAAGTTACTCGACATTGAGAAGAACATGGGTCATGGTACTGTTGCTATG +TTATTCCTAGCACAGTTAGATAAGCTGAAGCTTCACGCTTTAACTTCAAACCCTGCAATT +GATGAGTTTAAGAATCAGCTAGGTATGAGTTACAAAGAAGTACACACTGCCCTTAGTGGT +ATTGGTATCACCGAGTATTATGTGGTAGGTCAAAAGGAACGTCGAATCATTGATACGATC +TCACCTTTGACTCGTCGCCATAAACTTGTAGTATCTACTCAAGCTATTCAAGACGATTGG +AATCATTGCTTACAACATCCATCTGAGAAGCGTATGCAATTCTCTGCTTTCTATCAATTA +GGGAACATTACGTATGATCGCAATAGTTTAGTCCATGATGACCGAGCTGACTGTGTACAA +CGTGTGGTGGAAGTTCTAAAGGCGTTTCTAGCTAAAGATGAAGAAAAGGCTGCTGTATTG +CGTCAGGAGGCTGCTCATCAAGAGTTCTTGCGTAACCCTATGGGGTATACCCACGATGGT +TGGGATAACTCTAAAGGGTCTCGTAAGCGTTATCATGGGAGGTTCAAACGATGATCGATA +AAGAAGCAGTTACTAAGAAGTTAGAAACTATCAACGCTAGGATTAAAGATGCACAATCTA +TCCTAGCATTACTAAAAGCACTAAAGGAGAAATCAAATGTCAAGTATTAAAGTTATTGTT +GCTAATGTAGATGTACCTAAGTTAGCGAGCGGTGTGTCTAAGGCTCTAAGCGTCGCTAAG +GCGGTTAGTAGCACTAAGGTATACAAAGGTAAGGATAAGGTTGAGAAAGCCCTAGATCGA +GCTACTGTGGCTCTTGATGTAGGTGTAAGTATCTATCGTCTGTTCAAGCGTTAA +>NC_025457.alt1 length=41066 tani=80.607 alt=sn;de;ins;du;inv +GATTGAGATATGATTGGAAGTGATTGGAGTATCTGATTGGTGAGTATAATGTCAAAAGCT +AATTTTGTCTAATATTTCTGAGAGGGTGTCTCCCACTTCCTCGCCCTCGACTTCCCCATA +GCACTCATACGTAATCATTTCTTATGGATTGGACTATCTGAGTGCTTATACCTTATCTTA +TACTGAGTCTTTGAGTCTTCGACTCGTATCATTCATTGATACTCTTTGGTATGTCGCTCA +TTGTATAGATAGTTTGATAGAGTGTCAACATACTTATTCAACTATTCATCTATTCATTGA +TTCGATTCTTATATCCTTGTATAGATTAGAGTGCTTGCCTTTTATGTCTTAACTCTTATG +CCTTTTTATGTGTTCATAGGTATATGCCTAGATATACAGATAGTTTTATTGATAGGGATG +TAGATAGCTATAAGATAGTTATTAGATAGAGATACTTATAGATATAGATAGTATTTATTT +TATCTATTTATACTCTTTGGTCTTCTCTTTATTCTTTATTCTTATACGTCTATCTTCTGA +TTTTCCTTAAACTGTATATTATGACAACCATACCAAGCAAACAACGCAAGGTACTAGATA +GGGATGACCTACTAGATATTCATTAACTTAATTAGATTGATTGCTTAGTTTAAAGACTAT +GAAATGTATAGGATAGAGATAACAAGCCTACGGGTAGCCACTCTATACGGTCTTCGAAAG +GTGTACCGTGGTATAAACAGCCTCCGATCAATCGAACAAGATAATGAATAATTATTTAAA +AGAATGGTTGACAACTTAAATCAATAGGTTTAAAGTTAACACTATCAAGGCATTGAGCTA +GAGTTAGATCACATTAGTTGATTGATACAAAGCGATAAAATAAATTGAAATAAAGTGTTG +ACAACAAAATCAGATATGATTAAGATGCCAATCATAGCGAGTTAGCTAGACAGTAGTTGA +GATGTGATGCTTTAATCGGTTGGCGTGGGATGTTTGCAGGTGACCTCCAAGCACCATATA +TCAAGACTCTGAAAGGTTACTCACTACCATGTAGACGATACATGGGTATTCATTAACAGA +TTACTAATTAATTCCTTATAGGTGAAGCCTAGACCACAATACTTTTGTATGTGTGCAATG +TGGTAGGTAATAGGATAAGCCATTGAGGTTGAAGTGTTATAGGTAGGCTGTGAGGCTGTA +CTCACAGTTAATTCCAATACATAACACGTAAAGCTATGATAAGGTTAATGAGTTTATATT +TAGCTAGGTTGGGTTGAATGCTATGCACATCGACCTAGCACTAATATAATCTTGAAGACT +GACACAAGGTATTAGCAACAAGGCATGGGATGATGACAGCCATTGAGGTTGAAGTGTTAT +AGGTAGGCTGTGAGGCTGTACTCACAGTTAATTCCAATACATAACACGTAAAGCTATGAT +AAGGTTAATGAGTTTATATTTAGCTAGGTTGGGTTGAATGCTATGCACATCGACCTAGCA +CTAATATAATCTTGAAGACTGACACAAGGTATTAGCAACAAGGCATGGGATGATGACAGC +ACTCGTAAGGTTCCCATATTGTTGTTAACGATCCGAACAATTCACGCAGTTAGGTCTGTT +TCCTAGCTAACGGATAATCTGATACCGCATGAGGTGATACCTTGTGTCAATGTTCAACCA +ACCAACTAACATAGGTGTATTATGAAACTGTTTTTAACTACAACTGAAATCAACAAAGCA +ATCGAATCTATCGAACGTCGTGGTAAACAATTGGATACTGATATCCATGTGGCAGGTGTG +TCAGTGTTAAAGCATGTCGCTGAACATGGCGATACAACTTTGCTTGATAAGCTTATAGGC +GCTATGCCTAAAGGTAGCCGTAAGTCTGCGTTCTGTGAGTGGGCTTTGGCTTATGGTAAT +GTCCGTATGCCTGACCGTGCTAACGACGCTTGTTTGCTATCGTGTACCTCCACGTGCGTA +GTGGGACAGAGGTGATCAAGCAAGTAGCCGCTGACTAAAGCCAACTGGGTACGCCTGTGG +CCGATGACAACAAGTACTGCCTAGGTGCAGCGATTCGATGTATAACAAGGATAAGTCTAA +AGAGTTCAATGAGGTTGAAGCTATTGCTAACAAGTGGTATGACTTCAAGCCTGAAGCTGA +TTTGTTGATTACCTTTGATGCTGCTGCTATGGTTGCATCCATGATGAAGCGTTTATCTAA +AGCACAAAAGCAAGGTGCTGAAGTAACTGGGCATGGTGATGCACTTAAACAATTACGTGC +TTTGATGCAACAACTTGAAACTCAAACTGAAGAACTTTAATCTGTAGGTGTATGCTGGGT +AGTGTCATTGTTATATATCTTTCTAAATAAATAGGTGAAGTATGTTAAACGTACCTAAAA +CAAATCCGAATGTAACTGTAACTTTAAACATCGGCTTAGCTGCGTCGCTGAACTGGGGTC +GTGACATCATTGGTCAGGTGTTTGCACTTGCTGAGAAATATAAACAAGACTGTATCGCTG +TATGGATTCACAATGATGTGAACGGTGGTATCGGTCAATTAATTGGACGTTATAACTATG +GTGGTTACTTCAATCCCGAATACTTCATTCACTTGGAGCGTTAAATGCCTTACGTCATAC +CTGTAATTATTATATTCCAAGTGGGTTACTGGCTTGGATTCTACTGTGCAAAATTCCTTT +AATAAGTGAGAAATAATATGTTTGGTTTATCTATCGTTAAAACTGCTGACCTTAACAACT +TAAAAGCACGTGTAGCTGATCTCGAAGCCGATGTAGACGGTGCATCGGATAAGGTGGCTG +CTTTAGACCGGAAGTATAATGGTTTGATTGATCAAGTACAACGTAACGATAAGGCTGTAC +GTGTTCAACTGGATGCACTTGCAAAGCCTACAGTATGTCCGTTGTTAACTGCTGTACCTA +AGAATGTAACCGACCCTGTAGGTGCATGGGAAAGTAAACAACGTGTGTTGGAAGCCCATT +TGAAAAGTGCGGAGTCTGACGTGTCTGTATTCCAAAAGCAAATGGGCTTTTGGGTAGGTG +CAGACATCACGCAATTACTATTGAAAGGGCTTAACATTACTGTCCTGAGCACTAACTAAC +CGACAGACGTCCATAGTACGAGGTAACCTGCTAGATGTAGGTGACGTAAGGACGAGGCCG +GTGTCGGTAAAAACCTATGATCTAAATGCCCCACCTGCTGTAGTCCATAAGTTTTGGAAT +ATTGAACTACGTGACTCGGTGAAGTTAAGTGTTTGATCTTTTCCATGAGTGAGATCATCC +ACGAACCTGTGTACCTATGTAATGACTGTGGTGAGGAATCTCCACATTCTGAACTATTCC +ATATCTGTTGTTCTGAGTGTGATGCACTCTGCCCATATTGTGAGTCTGATGACTTGGAGG +AATTATAATGGCTAAAAGGACTTACATAGCTCCGGGCTGTATCATTCTCGTGTGTAAACA +ACTGCATATATAGCACTAGGTCGCTACGAGTCGAGGTCCGATGACGTACACCAGAGTTTG +CACCCAGATGCCCGGCTCCAACCCGTTTAACAAAGATTACACTGTACACTGCTGCATACT +ATTCGATTGGTGCTGTAGCTTGGCTGTGTGACCATGAAGCCAGTAAAGAGGAACATCACT +TATGAAACCATATCAACCAATATTAGGTAGCCTATGTAAGAAAGTTTATACCTCTTGTCG +TTGTCTTTGGTAGTATGTTTATAGCTACATTCTAAGGGATGTAGCCGTTAAGCATGTTGC +TTAGGTCGTGAGTCTGTACTCACAATTATATTTCGCATTTAATAAATGTAGGTGACTTAT +GAAAGTCCTATACTAATGGTTTGGGTTACTACTGGGAAGAAGATGAAGTAGCTATGGAAT +ACCTTGGTTCAGGTTGTTTCTCAAGTGTCTTCAAACATCCTAATCGTACTGATCGAGCTA +TCAAATTATTCCGTAACTACCGTGAAGATAGTACCTGTTATCAGTACCTACGTTTGTGTG +CAAACAAGACTATTGATTACGAAAGGTGTCCTATATGTCAATACTTACCGTGTAACGAGT +GGATTCAGCACGCCGAATAGCGTCCATCTCAACCCTTGGACCTCGAGTCACTTCATGGAT +ACATAATAACATGACGCTGATCCTTGCTCAAAATATCACTGACCCAATATGGAACTCTGA +GCCTGAGCACTACGAACCCATCCCTGAACCATTAAAGGAACTGTATGTGTATCCTAAAAC +GAATGGGGCTTACGTTCTGTGCATGACTTAGGTGACGCTGTGTACTTTGAGTCTGATGTT +AACGCTACACATCGTCAGCTTTGACTTCATCAGGAGTCATGCGAGTATCATTGCTAGTAG +GGCGTTTAATTTCAGAGTAAGGTGCAATTAACTGCAACGTTGACATAGTAGCCAAACCTT +TAAGCTATCATTGCTGTATGTGCTAACCCTATTTCTTCAACTGTTCAATCATAAGGAGAC +TATTATGTCTAACTCTATCCGTATCGGTCGCTTAACACTTAACATGGGTAATGTAACTGT +AGGTGTTACCCGTCACCAATTATCATTGTTCATGCAGTACTCAACTGTTCAATCATAAGG +AGACTATTATGTCTAACTCTATCCGTATCGGTCGCTTAACACTTAACATGGGTAATGTAA +CTGTAGGTGTTACCCGTCACCAATTATCATTGTTCATGCAGTACAGTGCATAATTATTTA +AGGATAGACGTACTAGGGCAAGATGTCGAGCACCGACTCTTGAGCACCGTGACTCAGACC +CGTAGTGCTGGTCAGGCCCTCGGAACTAAGCAGCTGCTTACGGGGAAATAGCCGGAACAT +TCTCTTACTCTGGCTGAGATCGGGTCGACCGAGGAAGAAATTTCACTGAGGTATACCTTC +TGGATAGCTGGGTGAATAACTGAAGACCTATGGTTTGTTCGTTTTGGGCTTATCAATCTA +AGTTCTAAGGCTTAAATATAGCAGCACTTCGATGAGGTGCTGTTAGTATTTAATCACAGA +GCGTAAGGAGTTCTATCATGACTAAACTTAAACAACAATTCGAAGTAGCAGGTATCGTAG +GTCGCCCTGAACGTAAAGGTTGGAACTTCAAAGCTCAGAAGTCTTACCAACGTGGTCGCT +TTGATAACTTAAAACCTCGTATCGGTTTCGTGTGTAACCATAAGGTAGAGCAGGTTGCTC +GTGCTATTGCATTCGGTTTAGAACAACAGTTAACTTACTGTCAACTTGATGACATGCACA +ACCAACCACCTGAAGTACCTGTATGTATTGGTAAGCTTAAAGGTAATGGTGCTACGTTGT +TCCCTGATGCTAACACACGCCTCGCTATGATGGGTTTAAATGGTACTGCTGTATTACACT +AGTTAGGTGCAATGCGTGTAGTAGACGAGCTATCAGGGCAACGTGGTGAGGTTATTGTAA +ACGATAGTACTTACATTTTCACCTCTGTTGGTGTACTGCTTAACTTGGCTCAGGATTGTG +TTAAGTCTCCTGAAGCTATCCTTAACAACTACAAAGGAAGTCAACGTGTCCGTAAAGCAA +AACAAATCTGATATGTTTAGTATGGGTATGCGAGTCATCGTAACCAAGCCCATACAGGCT +GGGAATTACAAGCAACATCTAAACGCTTTTATTAAGACACACTCACCTCAACAAGTCCGT +GCTGTAGTTGATGAAGCTCAACGCTTAGGGTATACACCATACTATAAACCTAACTACAAA +TATGCCCGGGATTTTTCAGTTACATATGGCGCCAGCATTTGTGCTCGATAATGAGTCTAA +ATTGGCCAGCTGCGTGAGTCCTAGGAAGAGTAAGTTAAGCCGGTCCTGCCATGCTTGGAC +AGAGGGATAAGCAGTACGATGGGCGCGAACCCCCGCAAGACAGATCTGAGAGTCTTCAAC +TCGGGCGAGCTTTAAACAGTAGGCGTGGAGCGTTCGCCTCGGCAAAATACCGTAGAGGCT +CCAATTATTAATTGGTTCGCTTCAAATAAGGAGCTGTACCGTGGCTAAGCGTAAAGAAAT +TGTTAAGGGACTTACACTTCAAGAAGAACGCAAACTCTTGCAGTTAGAACGTCGTGAGGC +TGATATGGAACGTCAGCAAGATCGTCGCTCTAAGCGTCAGGATAAGCGTAAGCAGTTCTA +CTAATGGGAAGTTCTTACAAGATCAAGATTAAGTCCATACAGCATTACCGTCGCTGTGTG +GATAGCTTGAAAGAGGTAGGTGTACAATTCTGCTGTAATGATGAAGATGAGTTGAAGATG +CTACGCTGTAAAGATTACCGACGTAAGGCGTGGTTGTATATAGGAAGCAACAAGGTTGCA +TGGGTATTCGGAGCATACAGCGTGGTTAAGTACGCTAAGACGGTTAAGCGTAAGGAAGCA +ATGGAGCTAATTGGAGATGCACCATAGCGAATGGTTAGACCTAGCCAAGAAAGTTCCAGT +AGGTCAGAAGGAACGCCCTGCTTCAAGCCCTAATAATAATTCAATAAAGAAATTTGTATT +GTCACGCAGACATTATCATGGGGCCGAGTTAACTAAGGCACTAGATGTATGGAACAATGA +GGACTCATGGAGTGCTTACTGTCATCGGTGTCATACCTCAGCCAAGGTACGTAGTTAACT +AAGGCACTAGATGTATGGAACAATGAGGACTCATGGAGTGCTTACTGTCATCGGTGTCAT +ACCTCAGCCAAGGTACGTAAACAGTTTGTCGAACGTGTAGATGTAACCCAACCAATATAC +AGGCGATATCTTGATAAGGATTGTCTGATTACTTTGGAGCAGTTACATGATAAACACTTG +TTCAAATTCAAGACGTTGGTCAGGCTGTTACATGATAAGGGTATGAGTACAGTCACTATC +AATGATCTTAGTCCAATGTATAATACAAAGGATGATCGTCTAGTGTTCCGCTTTAAAGGT +GTGGATATTGGTAGAGACTGTTCTTCGCATTATTATGGTAGTTTCGCATTAACGGACCTC +TACGCAATGTTAGCTTGCGGCTTCTGGGGTACAGGGTTGTCACCTGCTAAATGGCTGATT +TATGATAACCCTGATCGGGAGGGTTTCGTGTACTTGCAAGGTAAAAATATCTACGTAGAA +GCTGACTTAGTTGCGTAACGTGTTCTAACAGACACCATCCCACCTGTTACCCCCTATTGA +TATCGGTACCCTGGAGAAGGTATCCAGGTCTTTTAGTTGCGACCTCGAGGCCCATATTTC +CATACTGTACACGAGAATTTTCGCGATGTGACGTGAGGGAGCTTAAAACTCGAATCGTTC +TGCCGAGTTTTTAGTCGTAGGTGTCGGATCCCGTCCCGTCAAGCCCCTCTCAGATTGCGC +CCGCGTCTCGAGAGCGGAGTCGTGCTGCGATTTAGTGAAGTTATGCGCGCAACCCCGAAT +CGAACCTGTAATAACGACAAGCCGTTACTGCCACCGACGGAGATTCCGCAGGGTGGAAAG +CACGTCGGCTTATTAATAGTCGTTGTGAGCTTTTTGGTATCCCTTGCTCTAGTGCATATA +TTCCCGACGGGTTAGACCCAAAGGATATGTCACCTGAAGCATTAATTGAAACATTCAAAT +TCTTGGAGAATTAATATGCGTGCTGTATTCGTACTACCAAAAACACATGCGGAACTTAAT +CAGTGTATCCCTACTTCGATCAACAAACTTCAGTGATGCTACGGGAGATAAATGTGGGCA +GCTTGGTAAACGTGTAACTGTTTGGTTAAATACAAAGACTTACCACCTACATACCTATCT +TGTGTTTCCACACACACAAGTAACACCAAATCAATTAGCAGGTCTACTACAGGGGTTATA +AAAATGTCAGACTTAAACCTACTCCGATGTATGATGGAGCGTAAGTCTTATCAATCGGCA +TTTGCATCCATCCCACAAGAAATGTATGACTTAACTACTCGTGCATTCCTTGCTTGGTTC +AAACTGTATTACAAGCATTATGAAGATCATGAGCGTGTTGATGTAGACACCTTTAGAATT +CTCAGGGGAACTGGTGCCTTACACTTGTCGACCGCTGGGGTCCAACTGTAATTCCCGACT +AATGGACCTAGCGGGTCCTGACTCAACCTTCTAGTGTAGGGACGAGTAGCTTCGTACGTT +TGAAAGGTAATCAATCTCAGGAACAGCTAAAGCTGACTGACCGATTACTCAAGCAGTTAC +GTGAGCAATTGGATGATGCAGTCCGTGCCACAACATTAAACGCTTTGGAAGAACGTCGTC +TATCAGGTGAGGCTGAGATGTTAGTCAAGCGCTATAATGATGGTGAGGAAATTGACATCA +TCCATGAGATGCGTAAGCTCGTACAAGCCTCGGAAGTTGCATTAGATGTACAACATGCAT +CATGGTGTGATACCGACGTAGGTGAGCTTATTGACGCTGATGCTGATGACTCAGGATATG +TAATGGACTTCTTACCTTAGTTTGAACGTCGTAAGGCAGGTACAAACTTCATTCATGTAG +GTACAGCACAGATCAGTGCCGAGGGTTTTGATAACCTGTACCCACCAGTGTCAGCATTAC +AGAACAGTAAGACAGGTATTCAAACCACATTGGATTTAGCATTGTGGATCGGTGCTTATG +CTAACCCTGTACCTGATCATGAATTGATGCGTGGATTAGGTACACCTAAAAACAAATTAG +CAAAGAGTGGTTGTAAAGGTGGTAACCAAGTTATGACATTCTTCGAACCTGAAACAAATA +ATTGGGATGCGGTGACTAACTCATGAAAACAGGTGATGATGTTCTTGTAGAGGACGAAGG +ACGTTTTGATTAAAGTAGATATAACCCAAAGAATGAATCTAAAATGTATTAATAACTTTG +GTATTTGGACGCTACGTGAGGGGCATGTATATCGTGTCCTTGATGTACGTAATACAGTAA +TCCAAGTCCAAGGTAAACACGGTTGCACTAACTGGTACAAGAAAGATCGTTTCGTTAAAA +TTAAAGAGGGTAATCACATGGGTACATTAACTAAATCTGAAGTTAAAGTAGGCGATAAAG +TAGTACGTATCAGTGGTACTGGGTTACGAGTAGGTGCGGAGTTCACAGTCATTGGTGTGC +GTCCTGATGGTGCTGCTGTACGTTTACAGGGTCAAGGTAGTGGTTGGTTCTGCATGAGTA +CATTCTCATACTACGGAACCGTCGCCGCCGTGGTGAATAGTTGGAGTCCTATGTTATAAT +TGTCCGGGGGCGGCTCGCACGACGCCTCTTTTAATGTTACGCCTCTCCTTCACTATCGTG +CCCGAGGACTACACATGGGGCGAGAACTCAATGATGTTGCCGGTTTCTGCTCTATTGTAG +AGCGTGTGCCATGGTGCCCAGTCACATGTCTCATATGATATTCAGGAAAGGATCATTCCC +TACTGGAACTGCCGGGACTAGGTATTGCTCGAACTTAAAAACGAATTAGCCTGTCTTAAG +TGTCCATTGCGCAAAGAGAAGGTTCTATCCATCAATAGCATTACCGAGAAGCCTCAACCG +AACGTACTCACAGATGATCATTCATTCAAACTACACAGTCCCGTAAGAAGCGTGAGTTAA +TGGAAGTGAATGGTACTGAAGTACCTAAAGGTAGTATGCGTGCAGTTCTCTTTGATGAGA +AAGGTATCGGTTACGGGGTATCTTTTAATAAACGTGAAGTGTACAAAGCACCTCTTAAAC +AATTGGGACTCTGTGGTACTATGTATTGGACTGACCCTCAAGAAGCTCAAGAGGTATTGG +AAGCATTACTCAAACCATTTGGTATGCATGCTAAACCTTTGAAATCAAACCTATTGGGGT +CTTAATATGGACTTAGCATTTGTCGCTGATTACTTGGCTAATCGCAAGAACCCTGTACAA +CTTGTCAAACATTTTGATGAAGTTAATGAAAAGAACATCAAATACCCACTGATCGGACAG +CTTAAATATGACGGCAGGATGGTCAGCTTTGCAATCTTGCTGATGGTGTGTATATCGGGG +AACTATGTACTAATGAGTTATCTTTAGAGGTGCTTAGTGGTTATGTATCACCTAACCGTA +AGAAGCCGTGGGATGACGTAGGGACGCATAAGATCGGTGAACTAGGTTACATAGCATTCC +ATGATTACTTAACGGGTGCTTAGTGGTTATGTATCACCTAACCGTAAGAAGCCGTGGGAT +GACGTAGGGACGCATAAGATCGGTGAACTAGGTTACATAGCATTCCATGATTACTTAACG +GTAGATGAGCTGTTAGACGGTCACAGCGATACATCCTATCGTAACCGTTACTCAAACTTA +GAAAACCGTTTGCAGAATGCAGCTATCGTTGGGTACACGGTGAAGTCTACACTGATCTAT +GATCGTGAACAGGCTGATGCTTACGCTGAAGACTTAATTAAACGTGGGCATGAGGGTGCT +GTCTTTAAAGACCCTAATGCAGATTGGGAAGCAGGTCATAAAGGTTATCGTGCAATGAAG +ATTGTACGTGGTATCCCTCCTCTTGATCTTCTATGTGTAGGTGTTGTCTATGGTAAGGGT +AAACGAGCAGGTCAAATTGCTGCTCTACGCTTCACCATGCACGGTAATGAGTTCAATGCT +GATCGAAGAAATGCGTAACCCTGTAGGTAAGATTTGGGAACTCAAAGCATTGCAGTATAG +CTCAACTGGTAAGGCATTACCGTGAAGATAAGGAGACTCCAGATATAGGTAAGCCTGATT +ATATCATACGTCCTAGTAATTAGTTTCATAAGGTAACGTGTCCATAATGTAAAGCTATGT +AACTAACAGTCTGAAAATAACGTGTTTGAGGTTTTACAAGTATATGATTTCAAACACGAA +TATTAGAAGATAGACGTATAAGATAGATAGAATCCACATAAGGAAACTGTATGTTTAAAC +ATAATTTCTTTATCCATGACTATGAAAACCAAAACCATCCTTACAAGATTGTAAGAAAAG +GGCTTCCCTCACGGAGAGGCCACCGATGCCACCAACCGCCACTCACTGTCTCATTATTGA +AGCCAACATTCACCTGAGTTAAAGGGCGATAGGGGAGCAAACATGACACCGATAGTGAAT +CAGTTCAAAAGCGGTACACAGGATTGAGTGGCGCGCATGAGCGAGTTGGTTGCACTTAAA +CATGATACGTGTATGTAGCACATAACGCTACGTTTGAAATCCAATGGATGTTACGAACTT +ATCCTACTCAATTCTTAGATTGGATGAAGAAAGGTGGTAAGGTATTCTGTACACAATATG +CAGAGTATATGTTAACCCATCAACTTGAGATGCATCCTAAGCTTGAAGACTGTGCTATTA +AGTATGGTGGTTCTAAGAAGATTGATGAAGTCAAATTACTTTGGGAACAAGGTGTATTAT +CAAGTGGTCCATCAGGTTTTGCCATATTTTCTCGTTACCGGTGATCTTCAACTGCTGACA +TTGACAAAGCTCTACTGATGAAATACTTAGCAGACCCTAAACTTGGTGACGTAGCGAATA +CTCGTCGTGTATGCTTCAGTCAAGTAGCTTTGTTACGTAAACACGGTATGTGGGATATGT +TCATGGAACGTATTTACCTGCTGATCTTCCTGACGACTTTGAGTTCTCATTCACATCCGC +ATACCACTTGTCGGCATTCTTGTTCGGAGGTACGATTCAGTACAAAGCGAAAGTAAGTTA +TGACCCTATCAAGTATGTGAAGAAAGACTGCTATCAATTTGGTGATAAGTTTTGTGTCTG +AAGCTTATGTAGGTAAGCGTGCTGAGTTCCGTGGTAAACGAGAGCTTGTAGATGGTACGC +CAATCTACAGTACAGGTAAGGATAGTCTCGATGTACTTGCAGCTCATACGGATGTTGCAA +AGCCATTGAAGGACTTAGCTGCACTTATCAAAGACACCACTACTTATTACCTTGTCGTTG +ATGACAAAGGTAAAGAGTCGGGTATGCTTCAATTCGTAGAGCCTAACGGTATCATTCATC +TAGAAATACGCTATGGACACTTCCCCTTGTAGTGACACAGTGTCGATTGTGCCGTCCAAG +ATCTACTCGACACATATCGAAAGTGACGTACTGGACTCCACGGGATTGCCAAAGGATAAG +CGATGTTGTCCCATCAACTTAACAACTGTGCAACTATTACAGGTCGCTTGTCAGGTAGTA +AGCCTAACATGCAGAATATTCCTCGTGATGGTACATCTAAAGTTAAGGAGATGTTTAGCT +CACGCTTTGGTGTTAATGGACGTATCGTTGAGGTCGATTATTCTGCTCTTGAAGTTGTAG +CCCTAGCCAGTATCTCAGGTGATAAGAACTTGATGCGGATGCTGATTGAGGGTATCGACA +TGCACTGTTATCGTCTAGCTGCAAAGCTTGGTGAAGACTATGAAAGTGTATTCGAGAAAT +GCCACAACAAAAAACACCCTGAGCATAAGCAATACAAGCAATGGCGTACAGATATTAAAC +CTCGTGCCTTTGCTCACCAATATGGTGCATCTGCTGAGGGTATCGCATATAGTATAGGTT +GTACCTTAGAGGATCCAGCTAAGACCCGTCTTTATTTATTGCTCCCACGGAGTCGGTCAT +CCCACATCAGGATCTAGGGAGTGCATGCGGGTATATTTGTACGACCGATGGTAGAGGAAA +CAGGAAATGCTGCACAACCCATTCGTGAGTTTGATGAAGAAAGTGGTCGTTATAATGTGT +ATCGTCGGGGTTACTTTCAAGCGAAGTCAGGTACTTGCTACTCATTCCGTCAATATGATA +AATGGGATAAAGAGCTTCGTATTACCGTCAAAGACTACAAAGACACGCAGATTGCAAACT +ACTGGTGTCAAGGTGAAGCATCCTTTATCGTTCAAGCTGCTTGTGGGCGAGTCATCCGTG +AACTCATTAAACGACATTTTGCAGATGGATTGGTCGTGCCGATCAATACCGTACACGATG +CAATCTACTTGGATTGTGCAACGGAAGCACTTGCTAAAGAATACGGGGCGTTGGTAAGGG +ATATTATGGAGGCTACTCCTAAGTACCTTGCTGAAGTTATCCCTGCACTTAAAGATTGGA +ACTAGTGCCGATCAATACCGTACACGATGCAATCTACTTGGATTGTGCAACGGAAGCACT +TGCTAAAGAATACGGGGCGTTGGTAAGGGATATTATGGAGGCTACTCCTAAGTACCTTGC +TGAAGTTATCCCTGCACTTAAAGATTGGAACTATCACTTAACACCATTCCCTGCTGCTGC +TGAATGTGGGGTTAACATGACAGATGTCGGCTAGATATATTATTACCTCACTAATCTATT +ATTTCAGTATATATGGTGGGTGGGTGGTTGTGTGGTGCCTGACGCACAAGTCGTTCGGAG +GCGGTTCTTGAAATTGACGCCTAGTGCCGTTTTACCGTGATTCTCATAATGATGTGAACA +AAGAGGATATTTAATGCATATTGCATCCACTATGCCACAGGGTATATTCTGCCCGTTACC +TGCTGTCAGTAACTTAGAATTCTGTAACTTCACTTACATGTGTGTTCGTGACCCTCTTGC +ATTTGAGGGTGCATTACGAGTACCTGAGAACTTACAGGATATAGTTATCCCACTGTTATC +TTTGATACTGGATAAGGTAGACACGGATGATTACATTTATGTCACAGTTAGTCGTAAACA +CCTACAACCTAACACATGCGGTAATCGAGCAGGTTGGCATGTGGATGGAGAAACGCGTAT +AGCCGGACCCCGAGTAGTCTGTATATTCCCCACGGAGGACTTTCCTAAGTGATGATCAAT +CATTTATTTGGTTCGATAAGTTACCTACTCAAATTGCATTGGGTGGCTTTGAGGTTAGCC +CTGATCATGAACAATCATTAGAGCAGTTTGATGCCCAAGTAGATTACGGGAATATACACG +AATTAAAAGATTGTGTACATCGACCAGTCTTCAACCACACTAATGACGTTCAGTTGCGTA +CCTTCAGCGTGGTGAGTCTCGTAACCACACTGTAGTTTAACCTGTACTCACAACTCAATT +CTTAAATTTATATCGGGGATTATTTCATGTACGACGGACATTTATGCCCAACAAACTAGC +AGTTGTGCCTTAATCTCCTGCCCCGGGGCTTACGAACTCAATCAGCTATCAACTTCTTAG +ACCTTGCACACGGTATCGACGTAACTACTCTTGACGACATGACTGATGTTTCATCAGGTG +GTGGTGCTAAACGTGGTTTATTACCCGCAGGTGTAGCTTTTGTAGTATTCAGTTCATACA +TTGAGTATGGTAACCAACCACAAACTTTTGAGGGTAAAGCTAAAGACCCGCTACCTGAGT +TCCGTTTAGGCTTCCACGTTGTAGGTGGCGTAGGTACTAACAAAGAGGGTGAGCTTGAAG +ATTATGTGCAAGATGGTTTGTGCCCTACAATCAACGCATTCGATTGTAAGTTGAGTACGA +ATGAGAAAGCCCGTGCTGTTGCGTACTTCAATGCGATTAACATTGCACCTAAAGGTACAC +ACTTCATTCAGAAGTTAGGCACATTATACACAGTGGAAATTAAGATCGGTAAGAATAAGA +AGACTGGTAAAGATCGTAAGAAGTCTAAAAACTTCTTCCAAGAGAAATGCTTATCTGCTC +TGAACTTTGCAGGTTCAAGCCGAGAGCAGTTATTATCAGGAGGTGTTATGCAACCTCTTG +ACGCTGATGAAGCTGAGCCTGCTGATACACAAGCTAAACAGGAAGCTGTTAAGGCTGAGG +TTGTTGAAGAACCTGAATCTGAAAATGAAGTTGCATTGGATGTTCCTGACCTCTAATGTG +ACCGAGTGAAATGTCTACCCGTATTACCATTAAATCCTACAGTACATGGTCGTCATCGGG +TATAGGTAAACGTCCTGATTATTTCTTTGATCACCACTGTTTTTATGACCAGTACCTACG +GGAATATGTAGAACAGGAGTACACAAAATATGACGTTTGATCTAAGTCAATTTGGTTTAG +ATGCTAAGGCGTTACAATCTCAGGATACATACAAAACCTCAACGGCAGGTAGTGTTCTAT +TACTGGATGGTGATGGGAATGCTTACGAAGCTGCTGCGGGTATTGTCGCTGCCCGTGGAC +TACGTCCGCCAGCCATATACTTAGTACGACGCCTAATTGCCCACTATAAAACATGGGGGA +AATCTGGAATTCGATCATGTGTACCAATGTGCCAAAGCCTAGTTACTTGCGTAAGGCGCT +AAAGCCAAACCTGAGACCGCCTTACGTCACTTTGAACGTAGTATTTTTGAAGCTATGTTC +CTAGCAGGTTGTGAGAAAGCACGAGTACATTTAACCCCTCGTGGATGCTTCAAGAATGGT +CGTCATTTGCCGTTAGGTGTTAAGCCTTACCAACTACAGCGCAGTAACAATAAAAAGCCA +CCACTGGTCGCTGTGTTTGAAGATCAGTGAGTGGGCTACAAGCCCTATGTCGATTCAGGA +TAACGTATGGCCCCGATGCTGAGCTCTGTCTGCTCTGTCAGTCCTGCAGACAGACAAAGA +AACGTCAGACTTGAGCGAACATTCCGGGCGTGATAGTATATTGTTTAACGACAAAATTGG +AAGACACTTCTTCGTTTTAGAGTTAAGTGTGTATTATTTAACTTTCTCCGACGATGCTTT +GAAAGTCATACAGTATGGATGATGGTAAACATATAGTGCTACCTGATAGCTTTATAATAC +CTTTGACGTTATCAGCAGTATCACCCATGAGCATCTGAGATAAGAAGAACTTAGTACCTT +TACCGATCATCTTAGATGCAGGTTTAAGACTTGGTGTTAACCAGTGCTTACGATCAATCC +AACCAAACGTATCACCCAATGGTAAAGCGTGCGGTGAGGCAGGTGCTTATGAAGCCCTAG +ACCCTATCAAGGATAAACATGAAGCTGTGAACTTCGTTATTGAAGCTTACAAGAAGATTG +ATCAAAACATTATCCCTGAAGCTGAAGCTATGTGGTTATTGCGTAATGCACAAGATAACT +CATTAAAGTTCTTTATGGAACATGACCTAACTGATAGTAACTTAAATTTCTTAAACGAAT +GCTACCATGACCGTAAATGGAAAATGGAAGCTGATGATTATGAGGGTGACCTAAATGAAA +TATAATATTCCTGAAGCTGTACAGCACGTTATTGATCAACTTAAATTGGTTGGTATTGAA +GCTACGTTGGTAGGTGGTGCGTTACGTGCTGCTGCTCTTGGTGGTATATCCAATGATTAT +GATTTAGTTATATTTGGAGAACGTGAGGACTTCTTCCACACTGATAAGGAGATCGAGTAT +TTAGGTTTCCGTAACCAACACCATGACGAATACTGTAACAACGAGGGTTATGTAGCAGAT +TGGCGTAAAGATGATGTGAATATCATCATGTATGATTCTTGCAAAGTAGCTGACTGGTAT +GCCTTGATTGAAGTGTTTGATTTAAACATCAACCAATGGTATATCAACGAAGCAGGTGAG +CTTGAGAATGATTACTATGACCCTGAAACTAAGCTCGTAAGTATTAACCCATTCCGTGAT +GGTCTAGATCATGCTGAACGTCTCACCCAACGTATGGAACGCTTCCGTACTATGTTTCCC +GATCTTGATTGGTCTGAGATTGAGAAGCGTCGTAAGGTTAACGATTACATAAGACAGGTG +AGATTCGTGGTGTACTTCATCGTTCCTGTAATGCTGCTGAGGGTAAGGTAGCCAATGCAG +CAGGGGCGTGGGGTGCTAAGTCTATGGCGTATGAGGATATTGTCCCATTCGTTGAGGGTT +TAGTTACATACTGGAAGAACGCTGAGAAGTATGGTACTGGTATGATGTACCCTGAGCACA +AAACTGATGAGCAAAAGAAAGCTGCTGCGTCATTGAAACGTCGTAAAGCTTACGCTGCAA +ACAAAGCTAAACAAAAGGTAAAAGATAATGCAAGTAAACGATAAGATTACATGTGCCTAT +GCAGGGCAGTATCAAGGCACATATCTTACAACATTTAAAACTTATACAGCCCTCAGTACC +ATGCACGATCATGGACGGGACTATGTAAATCTAGTTGATGATTCAGGTGCAGAACGCACA +TATACCGCTAACCGATTCGTAGTACAGGAGAACTCTTAATGTCACAAGCCCACTTCAATA +AACTGAAACCGTGGAAACAAACTGCACTACGTCTACACATGCAAGGTATGACTGCTGCTG +AAATCTCTCGTGAATTTAATAATGAAATCTCAGATCGCACTATCCGAGATAACATTCAGA +AACTTGCACCTCAATTTGAACGTAGTGTTGTACTTGCAGATCGTAAACCAACTAGATTCG +TGATTGGTGATACACAGTGTAAGCAAGGTATTGACCTCGATTATATGCATTGGATTGGGT +CTTATATCGCATACAAGAAACCTGACATTATTGTGCATATCGGTGATCACTATGATATGG +CTTCATTATCAAGTTATGATAAGGGTCAGTTAAAGGCTGAGGGTCGTCGTGTTGTAGAAG +ATATTGAGGCGGGTGATAAAGGTATCGAGATCATCGAATCTTATATTGCTAAGGTCAAAG +GTTATAAACCACGTAAGGTTGCGATGTTAGGTAATCATGAGCATCCTATTGATCGTTACG +TTAATGATAATCCTGAGCTTGAGGGTTTCATGGGTACAGATCAATTAGCCTTTGCTAAAC +ACGGTTGGGAAGTCTTTCCGTTCTTAACACCCGCCACTATCTGTGGTATCAACTTCGTAC +ACTTTGTACAGAACGGTATGACGGGTAAACCGCTAGGTGGTACGATCATAACTCGACTGA +AGAACGTGGGTGAGTCTTTCGTAATGGGGCATCAACAAACATTTGATCATTGTATCCGCT +ATCTACCCCTAAGTGGTCGAGCGCAGATTGGTGTTATCATTGGTGCATGTTATGAACACA +TGGAAGACTATAAAGGCGTACAAGGTAATCATCACTTCCGAGGTTGTGTTATGCTATATG +AATGTAATGATGGTTTTGATTTGGTTAAGCCTGTATCACTTCAACACATGAAAGATCAAT +TCTTAGGAGCTTAATTATGAAAATCGGTTTAATTGGTTTAGCAGGTGCAGGTAAGGACAC +AGCAGCATTATTGATTCAAAAGATTCTTACAGATAATGGTAAAGCATACAAGATTGATCG +CTTTGCTAAGCCTCTTAAAGATGCAGCTCGTGAGGTCTTCGGTGCTACATTCGATGATCG +TGATGTTAAGGAAGTACCTGTTAAGGTAGATCAAGATACCATGATTGAAGCCTCATTTAA +AGCGTTACGTAAGTGCCGACTTACTGAAGCTGAAATGGATAAAGCATCTGAGTTGTTCTT +TGAACACTTAGGATTTTGGAATTACCTATCCCCTCGTAAATACCAACAGTTGCTCGGTAC +AGAGGTTGGACGAGCTGCACGATGCTTCTGAGGTACTCGCTACAGAGATGCAGCTAGGTC +TTAATGAATCTTATGATGCTATGTTCACGAACACTGGAAGAAGAATACTCAACAGCAAGT +TTAGTTGCAGGCCAACAACAGATCATGGATGCTTTCAAACAAGGACGAGCTTTCAATGGG +TGTGCTAACCCTGAACCTATAGCAATGCAGAGCTTCTTACGTCAACTAGGTCGGATTATT +GAATCTGAATCTATGTTGGTATGTATGGAGCAAGTATCTGATGTTTATACAAATCGTACA +GTAGAGTATCTTGATTCAGCAGGTACTAAATCCACTACACACCGCTACCGTACACTCCTT +AAAGGCGCACAGAACATGGGTCTTAATTGGGAACAATGGACTGTAGAGGAACGTATAGGT +ACTGCCCGTTTACTATTGACTTGTCTTTATGAAAGTACGGGTTTATTCAAGTGGGTAGCT +AACCGTGGCACTACAGATTCTATGTATTACCTTGTGCCAAGCGAGACTTTAGAGAAACAC +TTTGGAGAAGTACAGAGTGCTGCTAAGGCTGTAGTTAAATATCCACCTATGTTAGTACCG +CCAATGGATTGGACTGGACAATACGACGGGGGTTATATGACAGAGTGGTTTCGTTTACAC +TCTCCTATGTGTGGTATCCGTTTCATTAAACCTGAACATAAGAAATGGATTATTCAGAAC +TTAAACAGCGAGCAATCGCTCCCTGTACGTACTGCAATGAACAAAGCACAGTCTGTACCT +TACCGTGTGAGTCAGCGTGTATTGACGATTCTACGTACTGCTACGGCTATGCGTGTCGTA +AAGGTGGTCATATGGGTATCCTGTCACGTATCAATGAACTTGTGACATATCAAGAGGAAT +CACGCTTATACATTGAACTATGCAATTCCCATGCCAAACTAAACTGCTGCTCCCAATTTC +ATACTGACATAATGCCAGTCTTATTAGCTTATCGAGCCTTTCAATTGGAATCTTCATATC +TATCTGACACAACTATAACACTTGGGTCGCGCACCCGTGAACAGCCACTTACTAGCGATC +CTAAGACGTTAACTAAAGGGCCTACGCTTTTCCCGACATTCATTGACCGTACAACAGGTT +AGAGGCCAGCCCCAGTGAGCGCCATCTGACCAGCCACGCGCCGACGATCTTTCACAAAAC +GTGTCTCGGCTCTCTTCCATTGTACATCTAAGCTGGCGTGGTCGTTTATCACTCTCTCCA +CTGTTAGGAGAGACCAGCAATAGCCTTTTCTTAGGTTCAGTATTTCCGGCTTATACACTC +AAAATGATAATCGCTCAGCGATTAATAACGTACTATACCGGGCTAGTACTTCCGAGAACT +GGTCGCAAATTGAATATTTTATCAATAACCCCCTTGATGTTGATGCCCCTGAACCTGACA +CAGCATTTATATTATTGCAAGCTGCTATCGCCTTACAAGACGCACTCGCACTGCCTAATC +CCGAACTTTATGTATGTCACGTACCTGTCGATATGGATGCTACATGCTCAGGCTTACAGC +ACCTGTCTGCACTCACTCGTGACCCCGTAGGTAGTTATTACACAAACCTTGTAGATAACA +AAGACAATAAAAAGTCTGACATTTACATGCGGGTTGCTGAAGTTGCTAAGAGCATGTTAC +CTAAGCTAATTGACGATGTGACAGTAGATCACTTTTGGAAAGTGAATGAGATCACACGTT +CTATGGCTAAGAATCCTGTAATGACTTATGTGTACGGTGGAACGCTACTACGTTGTATTG +ATACCATTGGTTTAGCCCTATCTGAATCAGGTGTTGAACCTATTAAGAACGATGCAGGTA +AAGTTGTATATAGTATGACTGCACTTGCTACACCTGTAGGGAAAGCTTTACGTAAAGGTG +TTGAAGAAACTGTACCTGAATCTGCTAAGATGATGAAGTTCTTACAGACTGTGGTACGTA +AACATAAAGAGCATTGTCTGCGTTGGGTTACCCCTGCGGGTGTTCCTGTAGTTAACTGGG +CAGAGGGTTCTATCATCAAAACGCTTAACATCCGTTCTATGGGCGTCACCTCAGTAACTA +TGAAAGTAGGTACTAAGCAATATAATACTCGTTCAGCAGCAAACGGTATTGTACCCAACT +TTGTACATAGTATGGACGGTTCACATCTATGCTTAACTATTAACGAGTTCAATGGGCAGG +TTCTACCTATCCACAACTCATTCGCTACCCATCCTAGTGACGTAGGTGCTATGCATGAAG +CTTTACGTAAGACATTTGCTGATATGTATAAAGCTTATGATATTAACGACTTCTTAACTT +TCAATGAAGTCGATACAGAAGAATACGAAGCACCACCTCAAGGTAATCTTGACTTGGTCT +TGTTGTTCTTTCTTACATGTCAGTTAAATTATATGCTTGGGACTTGAAAAACTAACCGCA +CTTATCAAAGTACATAAACGTAAGTAATCAGAAGCCCTTGAGCCTAACCGCTTGAGGGCT +TTTTTTTTTGTTTATCAATAACTTAACGAGTTACACAATGTTACGCAGTGGTAGACAGAT +TTTACCTACCTCTCCCAGATCCTTACCGCCAGTTGTGATTCCCCATGACCCGTCCACATG +TTGAATAACGTCTGTTCAATAGTGCTACGTAAGTGTATGAATTTAAATAAGTAATTAGAA +GATAGACGTATAAGATAGGAAAGGAGATTCAATCGTATGAATATTCCAAAGTTTACAGAT +GATCAGATTGATTATTTAAATAGAGTATTTTCAGAGAATACAGTTATGACCTTAGACCCT +AATGAGTTGTATAGACGATTAGGTAATAGACAGGTTATCCAACATATTATTCAGTAAGAT +AGGAAAGGAGATTCAATCGTATGAATATTCCAAAGTTTACAGATGATCAGATTGATTATT +TAAATAGAGTATTTTCAGAGAATACAGTTATGACCTTAGACCCTAATGAGTTGTATAGAC +GATTAGGTAATAGACAGGTTATCCAACATATTATTCAGTGCAATGAGAATGCTAAACGTA +AGATCACATCTTAGGAGGTAGTTATGGGTTTAGGTTCATTCCTGAAGAAATCCGTTAAAA +ATGCTTTCCGTGGTGGTAGTATGTGGAAATTCGCTTCTAAGGCTGCTAAGCCTGTTGAAG +ATCAGGTGCGTAGTATGTTAGGTCTTGATGCACTCAAAGACTTAGCAGGCGCACAGGAAG +CACAACTACGGCAACAACAGGAAGCTAATAAATTGGATGCTGCAGTGGAGTCTCAGAACG +TGGCGCAGTTTGATGATACGTCAGACACAGGGTTTACAGGTACGGATTCCCGTCGCAAGA +AGAAACAATCAGGTGCTTATTCACAGGCACTAGGTCTTCAGTTGTAAGGAGGTATTATGG +CTAAGTATCCTGAGATCACTTATTCACTCAAGGCATTGTATAATCAGTATCGGGATACTT +CACTACTTTCACGTATTGAAGACTATGCTTTTTGGACTATCCCTAGTGTGTTTCCAAAAG +GTGATCAAGATTTTCGACAACAACAAAACCGTGCTATCGAATATGATTATCAAGCTGTCG +GTGCAATGTTAGTAAACCGACTGGCTACTAAGTTGGCACGTACATTATTCCCCGCTAATC +AATCGTTCTTTCGTATCGACGTGTTATCGAATATGAAAACCAAGCATGTGAACAATTGTA +CATGAATGCATCTTATGCTCAACTTGTACAAGCAATGCGATTATTGGTTATTACTGGTGA +GTGTTTACTGTATCGTTATAATAACGCATTACGTGTATTCTCATTAAAGGATTACGTCCT +TAAACGTAACAACGTTTGAATGCATCTTATGCTCAACTTGTACAAGCAATGCGATTATTG +GTTATTACTGGTGAGTGTTTACTGTATCGTTATAATAACGCATTACGTGTATTCTCATTA +AAGGATTACGTCCTTAAACGTAACAACGTTGGTGAGGTTATGGATATTGTTATCTGTGAG +CATAAGTACCGTGAGGAACTTACACCTGATCAACGTGTCAAACTTCAGATTACAGAGTCT +CAGACCCGTGTTAAACTCTATACCCGTGTTAAGCGTAAAGAGGTTTCACGACCATAAGAA +TCACCATTAACGAGATTCCATGCGACAGGGATGAATGGGCATAGCTTATCACGATACACA +GTATTAGTACCAATGTCGATACCATTAATCTCCTGTGTTACATGCCAAGACACAATACCA +TGTTATGTAGAGGATTATGCTGCTGACTTTGCTAAGTTATCAGATATGTCTCGTGAGCTT +ATGTCTTATGAGATGGAGTCTTTACGTCTTCTACATATGGTTTGCCCTCAAGGGGCTGTT +AACTAAGGACGTCCATATAACGACGACCATAGGCGTCTCGGTGGAGGTCGACGGGACAGG +ATGGGCACGTGTTGCTGACGCAACCCGGGAGAAACGCGCTTGGCCGATTCAAATCTCAAA +TTCCCTGAAACACAGTGTAGTATAAGGTGTGATTTTCCACCTCGTCGCAAGGCAAATCGG +CACCAAAGGGCTACCAATCGGACCGCCAGGATGTAGAGTCTGCTGCGAATGCCCCTAATG +GTGAGTTTATTCAGGGTGACCCTAGTATGATCAAGCCTTATGAGGCAGGTTCGTACCAGA +AGATTGCTGAGATTCGCAATGATCTTGAAGCTATTGAACAACGTTTAAATATCGCTTTTA +TGTATACAGGTAATATGCGTGAGGGTGAACGTGTCACTGCTTATGAAATCCGTCAGAATG +CTGAGGAAGCTGAGCAGGTCTTGGGAGGTGTGTACATTTGCGTATTTATTACTATACGAA +GTAAAACCAAACATCATGGAGGCGATTGACTCTCAGGAGATTAAACTAAATATCTTAACT +GGTATTCAGGCATTATCTCGTTCATCTGAGAACCAAGGTCTAGTAATTGCTTGTTCTGAG +TTGAACGCTATTATCCCTACAATTGCACAGCTTGGTAAACGTTTTAATATTGATGCTATT +GCAGATAAAGTCTTTGCATCTAATGGAGATTTAAAATGACTCAAGAAGTAATTACACCTG +GAGTAACCTCTGCTGCACCTGCACCTGCTGCTGTACAACCAGTGGTAGAACCTGATGCAC +TTACCGCAGGTCTTAAACCTGAGCACGCTGCTCAAGCTAAAGCATCGGCTCAAGCTGCAT +ATCAGGAAACACGGGCTGCAATTCAACGTGATCTATTGCTACGGCTGAACGCCTAGCAGG +TGGTTCTGAACAATGGAAAAATATCGGTTCTACATTTAATACTAAAGCACCTGCTCATTT +GAAAGCAGTAGTGTCACAGATGTTAGATGCAGGTGACGTACAGAATGCTGTACAGTTCGT +TATTGATACAGCAAATGGAGAAGGCGGTGTTGGCGGTAATGGTGCTGCATCTTCAGGTAT +CTCAGAAACAGAATATTTTGCACAATTAGCAACCCTAGAACGTGGAGCGGGTAACCGTTC +GGCGCAGCTGAATCCCTCATGAAATGACCTGGGGATGGCATGACGGTCCTTCATCCCGCA +CAAATCATTTGAGCAGGGCGAGTGCGCACACAAGTTAACTTTACTTCGTGATGCACGTAA +ACTAGGTCGTAATAACGGTCTTTAATATTAGGAGAATTTAATCATGGCTCAAGGTACTAC +TTATCAACCGAATACAACTCGCTCAGGTTTGTCTGCTCAGCGTTCTACTGAATCACGTTC +TAATACTATCCGTCTTGACCGTTTGAACGGTTCAAAGGTTAAGGGTCGTAAAGCGGGTGA +GGCAATCGAGTCTCAGCGTGTGACTTCAGATAAAATGAACATCACAGTCGAGTGTATGAT +GTACACTCGTAACCCTATCGATTGGATGGACGATTGGACTGCACCTGACTTCTTGACCGA +TATTGGTCGTGACAACGGTACTGAGTTTGGTCTAGCATACGATGAGGCGCACTTAATCCG +TCTGATCAAAGCCCGTAACTGGGTAGCACCTGCACACTTAGCAGTGTCGTTTAAAGATGG +TATGCATGTAGAGGTTGCTTTGAAAGCTGCGACTACTACTGCTGATCTTGAAGCTAACGC +TGAAGCTCTTGTATATGCTCACGGTGTGCTTGTAGAGGAACTTACTAACCGTCATGTACC +TTTAATGGACATGATCACTGCGGTAACTCCTAAAGTGTTTGGTGAGCTTTTACATCACCC +TAAATTGATCAACAAAGACTACGTAGCTTCTAACGGTGACTTCGCAGGTCGTCGTATCGT +TGAGGTTAACGGTCTACCTATCGTACAGATGACTGCGTTTCCTAAGACTGTGGGTACTAA +CCATATCTTGTCTACGGAGACCAACGGTAACGCGTTTGATGTGACTGCGGATGATGTGAA +AGGTGAGATGATCATTTTCTCTAAAGCGCTGTCTCTAGTCACTGTAACTGCACAGGCTTT +CGTATCTGACTTTTGGAAAGATAAAGCTGAGATGTGAGATGACTGCGTTTCCTAAGACTG +TGGGTACTAACCATATCTTGTCTACGGAGACCAACGGTAACGCGTTTGATGTGACTGCGG +ATGATGTGAAAGGTGAGATGATCATTTTCTCTAAAGCGCTGTCTCTAGTCACTGTAACTG +CACAGGCTTTCGTATCTGACTTTTGGAAAGATAAAGCTGAGATGTGTAACGTGTTGGACT +GCTTCACTATGTTCACCGTTGATATTCGTCGTGCTGATACTGTTGGTGTTGCGTTGATCA +CTCGTACACCTTAATCATAACACGGAGGGCTTCGGCTCTCCATTCAATTTTAGGAGTAAA +ATAACATGGCTAAACTAGGCGAGACAATTGTATCCAGTGCTATCTCAGGTAAACCTTTAA +CTTTATCAGATAAAGCTTTTTCTTTGGTAGGACAAGCAAATGATAAGGTAGCTGCGTTAG +AGGGTCAGGTTCAAGCATTACTAGCTCTTGTAGCTGCACAAGGTATTGCCCCTACACCAG +TAGAAGCACCGGTAGCAAAACCTGTGCATTAGATCCGCCGTTCGAACCATCCCTTTTATA +CTTTAGCGCCAATCTTGTATAAATGGCTACCCTAGTAAACCGATCCGCAGAGGCCACGGG +CGAGACATCAGGAACATATCTCTGCTAAGGCTAAGACGGGAGAGTAATCATGGCGTTAAT +CAAAACGATTAATGCTGCTGATCTTCAAGGTACTAATGAGGTGAGTGTTGACTTCACCTC +TGTACTTACCGCTATCAGTGGCGTTAAAACAGATACCACTGCTATACAGGCAGACGTTAC +CGCTGTTAAGGCTGACTAACACTACACCAACACCGCAAACTCGAAAGGGTCTACTTTAAG +ATATAATCCAAGCAACGTAAATCCCAAGTGGTCGTATTGTGGTGATTATATCTTAAAGTG +AATCAACCATAGGAGGTATAATATGGATATGTTAGAAGCTGTAAATACTGTATTACCTTA +TATGGGTGAACACGTAGTTACACGTATTGAGGGTGCAAAGCATCCGTCGTATTGTGGTGA +TTATATCTTAAAGTGAATCAACCATAGGAGGTATAATATGGATATGTTAGAAGCTGTAAA +TACTGTATTACCTTATATGGGTGAACACGTAGTTACACGTATTGAGGGTGCAAAGCATCC +ATCTGTAGATTTAATCCAAGCTGCTATCAAGCGTCGCTGGGTTTTGTATGCGAGGATGAC +CTCAAACAGCGCAAGCGTCGATAAGGGGTTGGGAAGGAACCCGGTTACGACTCACGATGC +GCACGACGCAATCCCTACGTTACTCAGGCTACTGCGGGGTGCCCCGGATAGTCTGTCTGA +TCTAGGGACTCATAAGTGACCGGCTGGTGGAAACGCGATTGTCCATGTAGCAAGTAACAT +TGTTGACTACTGGTTGGTGGTTTAATGAACTACATGGTGAGCGTTTCTTCAATCTTGATG +AGGGTTCACGATATTTCTCTAAACCGTTAGAAGTTAAGATTGTACGTAATGTACCTTTTG +AGAAGTTACCCGAAACTGCTGCATTATATGTAACATATAAAGCTGCTATTGAGGTAAGTG +ATTTAAGGTGCGTGAATGATTTGTACACCCCAAGCTGTACTACTGGTGTGTATCTGGGGG +TATAGGCTGCTCCAGGCGGGCTGCCAACATTCAAGATCTTCATCTACGTGGATGGCCGTA +GAAGCAGGAATATAAGATAAATAGTATCTAGCCTAAAAGGTGTCTTTGTGCACGTCAGGA +TACGTACCTGTTCAAACTCGTATCATATACTGCTGATCTTGGTGCTGAGGATGTACTTCA +GATTCTAAACAATTATACAAACGATAACTTGATTTCTTTTAAGGAACTCAATTTACGTCA +ACGGAAGTATAACAGTAAACGGACGGCTTAAATGGTTATTTTAAAGCTCGTAGTAAATCT +AGTATTCGTACTACAGTATCTAAGGATAATTTCTTCATTCTAAATACTGAGTTAATCCCT +ACCAAACAGCTCGAAGCTGAGGCGGGTAAGAATCGTAAGCACTACGGGTACTTCAGCATT +GTGTCTACAGCGTTTAGTAAAGTATTTACTATATCTGTAACTCACCCCTCTATTGGTACT +ATAACTAAGACGGTTACTGCATCTAGCGACAATGCTGCTGAGGCAAGTCAGGAAAATATC +GCTCGTGGTCTTGCGGATTTATTCTCTCAAGATACTACTTTTGCAGCGGTGTTTAATGTA +CACCGTACAGGTATCACTGTAGCGTTTGAGGTAAAGGATAAGACGTAAACTGGTACTACA +GTTGTGGACTCCACCCCCGGCCCATACTACTGGTGTTCCTTATGTTGTTAAGTCAGGTGC +ATCCCGTGTTGTGAATAAGGCTATTCGATCATGGTGCATTACGTTGGGCTGAGACTGGTG +TTTATGAGCCTAACTATAAACTTATCAATGAGCCTATGTATTGGTATCTTGATGCTGCTG +ATACTGTGAAGCTTGTACCGTTAGGTATTAAACCTCGTGAGGCAGGTGATGACGATAATA +ACCCTGACCCTAAATTCATTGGGTACGGTTTGACAGGTATTGGTAGCTACCAATCCCGTC +TAGTATTATTGAGTGGTTCATACGTCAATATGAGTCAGACGCGTTACTTCAACCAATTCA +TGCGTACTACGGTTACTGAACTGTTAGATGATGATGCTATTGAGGTTTCTAGTTCTGCAC +TTAGCTCTGCACAGTTTGAATACTGGGTGCCTTATAATAAGGACTTGGTGTTAATTGCAC +AGACACAGCAAGCAGTGATCCCTGCTAACTCGACTGTACTCACACGCTGCATCTACTACT +AACAACATGGTAGTGATGAGTTCAGACTCCCGTGATGTATTGGTTAATCAGTTCTTATGG +GTTGGTGATGATCGCCCTCTGATGAGCTTCCATAAATGGGAGTACCCATTACCTGTTGTA +TACGCTCAGTTCATTCAAGAATACTTAATCGTGTTCATGGATGATGGGCAGGGTAACTTA +GTCATCGGTACTCAGAACGTACAGTTAAACCAATTAGATGATAAACCTATGCCATTCCTT +GACTTGTATGGTTATGTGACCATTGAGAACGGTGTTGGTGTTTTACCTGAGTATTTACTT +GAGATGAAACCTGATGATATGGAGTTAGCTGCACCTATATATAATGACCGTTATCTGCGC +CACCAAGTGGATGAGCGCCCACTGAGGAGGGATCTGCGAAACTCAGTTCTTGAAATACAC +CCAACTTTAAGCGCTACACTAGTGACCTCCTCAGGAACATAGGATGTCGAGACTTTAGAT +TGAGTTCTCGTATGATGATGAGGGTAATGTTACATGTCCTTATGATGGTGTTATCTATGT +TGGTGTACGCTTCACAAGTGAGTTTACTTTGACACCTCCTTTTATTAAGGTATCTATCCC +GTGTCGTACTCGTTTAACGTCTACACAGTGTTCTGTAGGTGATCGGTGGTATCGGTGGCT +TCGCTCTAGGTTATAATACACCTGACTACGAGAAGATTGCCCGTGAGAAATATAATAACG +AGGTAGTTAAAAATGCTATCTCGTCTTTGTGAGGAATACCAACGAAAGCCTAGTTCCGCG +CAAGGTAGCTTCAGACCCGCTTTGGGATTGGGTTGACTGAGTGCACCATATAAACGTGAT +TGCACTGGAGCGGCCGAAGTCCACCGACTGGAGCACCAACCCAGCACGGGAATTCCATCA +ACCGCTGTGACTATGGTTATAAATCATCCGGGGCGTGTAACCTAGAGGGGTTCCCATAAC +TCGATATGCGTCGTGTACAGAATGTAGAGAACATGACCACTGATGTGGACTCTATGGACG +TTGGGAACACTGTATTAACCCTCTCCAGTCTTGGGGATAAAAGACTCACAAGTGACTCCT +CTATAATCGGTTCCCAGGATTTCTCCAGCGCACAGCACAGGCTCTCGCGGCTTATCGAGA +TCAACAGACAGTTACTACAAGTTCATATAACGCCCAATATGGCGCTAATGATGTGGTGGG +TGCTTCTGCGGATGCTCTAAAGAATACATTAGCCTTTCAAACAGATCAGGCTATTGCACA +AACATGGTTTAACTATGAAACAGGTATTGATAACTACAACATTGGTGTTGAGGGTACAGT +GAACTCTGCATTAGCAGGCTTACGTCGAACCAAAGGTGATCAGCGTACTATGGACTTAGG +CGCACTCACTAAATCAGGTTTAGATATGTACAAGCAATACGGTGGTAGTTTCAATAACGC +AATGGGTAACTTGTGGGGTGGTGGTTCTACAACAACTCAAGGCGTGTCAGGTGGTGGCTT +AGGCGGTCTATCTGATTTTGGTTCGTTTGGTAAAGGTGGCTCAGCCAGTGGTTTAACTGG +TGGTAGTTCATTAGCTTAATATAGGAGTTTATACATGCCTACTATGGTTCAACAACCCGA +CTTAATTACACCCGGAGTATCTCGACTTCAAGCGATTGATCGTCCTGTAGAACGTAGTGG +GCTTAGCTCATTCCTAACAGATTTAGTGATACTGTAACTCAAATGGCTCGTGATGGTAAG +TTTGCCTTTTAGACGTAAAACACCGTTATAAGGCTATAATAAGAAGGCAGCGCTTCTGGT +CCCTCTCGAGAAGCTCTGGAGCGTCCCCCAGAGCGATTCAAGTCCTTCTGAGGAAATCTT +CGATGCATGTAAACAGTATCTCACTGGTTATACTAACGCTGTCCATGATAGTCAGCTACA +ATCAGATTTAAAAGAGGCGTTGTATAATGCAGGTCTCAAAGAGAACACTGCATATCAAAC +TCTTAGTTCCAAAACAATTAATGAAGTGGCTTTACAACGTGAACAGTTTGATTCTCAGAC +TCGTACTGCAAACACGTATAAGTTACTGACTGAGCAGAATCATACACCTGCACAGATTAC +GGAATTACTTGAGGCTCATGTACAGCAAGCATTTGCTGCTAAGATTGCTAGTAACGTGGG +TATTGACCCTAAAGAAGCTATGCAAGCTGCACAGTCTCTTGATTTGGAATGGACAGCTCT +CATCTTGAAGTACAGACTATGTTCAAGTATTGGGCAGGTCAGATCGACCCGTCTGGTCCT +GATGCTGCTGCATTCGTAAACACTTTGAATAACACATTAGATGTAGCTGAGAGGGCACCA +CTTTCGGACCACAAATTTATCGGGGAGCGCCTCGATTTTTCAACGAGCGTGAGCATTTTT +CCGGCGCGGGGAACGTCGACATATACCCAGAGTCCGTTATGAGATTCCCATGAGCGGGGG +TAATGTTTCCGCCGAGCTAACGAACGAGAGCGCTCCGGAGTTCAAGTACAGACAGTAGTG +CGTGGCACTCGTCATGAAACGAAATTCAAGGTGGTATCGTGAGTATGTCCACTGTTGTCG +ATTTACAAAGTAATGCTAATGGTATCCGTTCACAGACTCTTGAGAACAACGGTATCCAAT +TAGAGAACTCTATGAAAGAGGGTATGTGGAATATTCAACGTGGTAATGCAGAGTACAGTC +ACGACTTCGTACAATCACAGTTAACAGAGATTAACCGTAAAGAAGCCCAAGGTTTACTTA +CACCTGCTAAGGCTGCACAACTACGATATAACTTATTCTCCTTTGGGGAAACTCAATACA +ATAAGTTATTACAGGCTGAACTAGACCCTGCACAGCTAGTTAAGGGCGGTGTCTCTATGA +TGGAGTATGCTGCACTAGGTAAAGGTGGTGAGGATAGCTATAGTGGTCATATCAGTAATT +ACTATGATGGCATTAACAATGGTGACCCTGTTGCTGCGGGTTCTGCTAAGGTTGCCCACG +CTTTACGTGGTGACCCCAAGCTGCTAAACAACCACATTATCAGAATGCTGTTAAAGCGTA +TGATAGTCTGAAAGCTACTTACATGCAATTGAAAGCTCAAGGTTCTCCTTTGGCTGAGCA +ATTACTTGCAGGTGTACCTGAAGATTACCGAAAGCTACTTACATGCAATTGAAAGCTCAA +GGTTCTCCTTTGGCTGAGCAATTACTTGCAGGTGTACCTGAAGATTACCGTGGTACTGTT +ATGGAGATGTTCGCAGGTAATGCTAATATGAACGCTAGTGCTGAAGCTCTACGTAACCCT +GTTCAAACTAACCAACGTCAAAAGAACGTGTCTGAGGCTATTCAGGCTATGAACTGGGAT +AACGTAGGTGGTAACAAATGGTTTGGTCGTGGTGTAGGTGGTGGTTCACGTTTACTTAGT +GGTATCTCTGAGGATGTACGTGGTTCATATATGAAGAATATGGAGATGGTCTATTCAGAC +TCTAAACATGCTCTTGCTAATGGTTCTATATCTGCTAATCCCGAACTACTTGTAGCTAAT +GCTACGGCTTTAGGTATGCACGTTAAATTCGTCGTACTGTGGCTAAGTCTGCAAATAGTT +CTCCTGATAACGTGTTGATTCATACAGATCGTACAGGTCGCTATGTAATTGTCCAACCGT +TCGATAAGAATGGTAAGTTATTAAAGGATAAGCAAGGTGATGCATTCCAAGGTGAGGTTT +ATAATGAGAGCCAATTCGTTAACTTAATGAAGAAAGCTTATGATGCTGACCAGGCTAAAT +ACAAGAAGCACACTAGCACATTTGAAACTATCGGTACTGCATTCAGTAGTAAAGGTGTTA +GTGATACACTTGGTAGTACAGCTAACTACAAAGAGGATATGGCTAAGTGGCGTAAAGAGT +CTAAGTCGTACACATTGAACACAGCAGGCTCACTAGGTCAGACTGTTATCTCATTACCTA +ATGGTACTAAGACACAGGCTAAAATCCCTACGTTAGCATCTGTACCGTTTAATGGTAACG +TACAGCTAGCTACAGCATGGCAGGGTTTCCTCAATAACTATGAGGGGTTCAAACCTACTA +TAGGTGTTGTTAAAGGTACTGGTACAGAAAATGACGGTTTGATCATCGGTAACGGTGTTA +ACCTATATGCACATCCTAAATGGAAAGCACGTTTCCAAGCTGCACAGGGTAACCCACAAG +CTTTGCTTAATCTACAGGCTGAGTTCATGTCTAATAATATGAAAGATCAGCAGTTAGAGG +CTAAGCGTTTAGGTATCCCAGTAGCTACCAATAAACCGTACAATCCACAATTCATTTCAG +CACAGCTACTACTTGCGGATTACAAATGGCACAACGGTAACTATAATACCATCCGTGATA +TTATGTCAGCACCTACGTATAACCAAGCACTAGCTAAAATGCGTAAGTCGTCTGCATAGC +TACCAATAAACCGTACAATCCACAATTCATTTCAGCACAGCTACTACTTGCGGATTACAA +ATGGCACAACGGTAACTATAATACCATCCGTGATATTATGTCAGCACCTACGTATAACCA +AGCACTAGCTAAAATGCGTAAGTCGTCTGCATACACACACGCGGGTGATGGTCACCGTCG +TAACGTTGCGCGTCGTAACATGCTTCGTGATTACTACTTAGCAATGTTTAGCAGTGACGG +GTGAGGAACTCCAAGATGAGGTACTGCCTGAACAACCTGCATTATAGATTTTAGCTGCAC +ATCCGATTGCAGGTACTATTGCATCCGTAGTGGATGTTGATTTACCTTTAGCATATGCGG +TGGGGCCATTTGTTGTATGGATCGATGGGTGGCACAACTCTATGATCCGTTGATCCGTAC +AAGTATGTGACTTCCGAAGTCGCCCAAGTTAACTCCGTTCAAGACCGCTACCGGTCGCAC +CTGCTGTGGGGCAGATTGGAGGCGCTGCTAAGTTAGGTCGCTTGACTCAACGTGGTATGC +AAGCTGCTGCTCTAGGTGGTGGTGCTTACGGTCCTAACCAATTATTAGAAGATAGGTCTA +CACGTACTCAATCAGAACGTAACTTAGATAGTTTGATATTCGGTTTAGTGGGTTTATTCT +CATTAGCAGTACCTGATTGGGCTGTTCAGAACAAGGTTGTAGCTGCTCTACAGTCGTCGG +GAGACTACATGTGGTATCTAAAGATCATACAGTTGCCCAGTACCAAGTTACTGAACAATT +CGGTCAAGCAATGCAACGCTTAGATCAGGACATACTGTGGAAAATGAACTCAGGACAACC +TGTAGATAAGAAAATGATTCATCAAATGATTGATGAGTCTAATGTTGCAGATGAGATCAA +AGCTATTCAAAAGGCGTATGTAGATTCAGGCTTTGCTGAGACTGCATTGAGCCGAGCTAA +ACAAGCAGGGTAGCGTAAGTTCCAATTGACTGCTAAACAGTTAGGTCAGAACTTCTTTGG +GACTCAACAGAAACTAGCACTAAGTTTATCTGAAGTACAAACAGCAGGTCTTACCAAAGA +TCAGATGATTACGTTACTTCGTAAATCAGGTGTTGATGATGAGAACTTAAATAAGATCGC +TGATACTATCTATAAAGGTACTCAGGATGCAGGTACGGGTGTTGCTAAGCAATTCCGTAA +ACGTCTATCTTGGGACTGGAATATGAAGTTCGTAGGTAAAGATGGTGGTGAGTATAGCTT +AGGTGATCCTGTAGAGGGTAACGCCTACATGAACCTTGCTCAGTATGGTATTAAGACCAC +TGCTGACCTTGACAATATACTTCAAGGTATCATGAAAGATTTACCCGCAGACGTTGACAT +TGCAACCGCTAAGCGTTTCTTACAGAACGTCCGAGCGCAGGCTTTAGGTCATCCTATGGG +TGAGGCTGTTCCTGAGACTATCCGTTCATTGAACACTGTGGCAGGTGCTACATTCCTATC +TAATTCAGGTTTATATAACGTGGTAGATATGGCGACTCAGGTTGCTAAGATGGGATTAGT +ACGTACATTGCCTGAGATTATGAAAGGTCTGTAGAACATTGTGAATCCTATGAAGAAACT +ATCTAAAAATGAAGCTAACGATTTATATGATGTATTGACTGGTCTATTAAGTACCGATGG +TCGATGGAGAAACATCACGACTCGTTATGCTGATGACTTTGAGGTTACTACTGGTATTTC +ACTAAACGCCGATACCTACCAGGTAATAAGTAACATGAGTTAGACTTGGTCCCCCAGCAC +GACGTATAAAGCGGACGTGACCTGGGGAAATCCTCTGTTGGGAGCGAGAATGGCACGAGC +GGTTAGTAAGAACGTGGACAAGTCAACAATACGGAGTTACGACTCATGAGGCTACAGCTT +ATTACGGTCAGGCTACTCGATTCATGAACTTGTCTGAGTACGTTAAACGTATGCAGATTA +GTATGATCGGTGGTGTTGTCACTACTGCATTTAAGAGCTAAAGATATTAAGTACATGAAA +GAAACCTTGAAAATGTCTGATGAATTAACGGAGGCTGTAATGAAGGAACACAAAGCTCAT +GGTACTAATATTGATATGTGGTCGAATGATGTACGTATGGCTATGGTCCCCACTTCGCTA +AAAACTTAATCGGAGTCTTTTCTAGAACACGCGCATGTTCTTGCAACAGAAAGTGTTTTA +TGAGGCTGATAACTTAGCGCATACTATTCGTTCAGGTGAAATCCCTGCATTCATGGAACA +TAGTTCTGTGGGTAAGATCATCTTCCCGTTCATGTCCTTTGCTTTCGCTATGCAACAAAA +GGTACTTCGTAATACTTATCAACGTGATGGTGCTGCGGGTGTGGCTTTATTAGCTGCTGT +ACAGTTCCCAACTGCTGCATTGATTGGTATGGCTAAGAACATTAAGAATGGTAAAGAGCC +TGAAGAAGACTTGGCTAAGGCTTCGGTTAACGCTTTGAGTATGCTAGATACTTTCTCGTA +GCCGTTAGAGATCATCATGAATGGCGGTTTAAACAGTAACAGTGCTGCGTTAGCACCTGT +ATCTAATGCAATGACATTAGGGCAGAAAGCTATGTCAGGTGACCCTGATTTACGGTCAAT +TAAGAATGCTACACCTTTGGGTAGTTTAACAGGTTTGGATTTATTCATTTCAGCTATAGA +GGATTAATTATGTCGTTTAATGAGAAACTATCATATACGGAGCATGTGGTCGAGCCCCCA +ACTACAGACTTCGCAATTGGCTTCAAGGATTACGGGGAACAATCAGATACAATTAACGTA +CTTGTAAATGATGTAATAGCTACGGAGGCGGGTTACACCGTCTTCCGTAAGAATGCTCTA +GTCATTGCACTTGAACCTGCTGTCACATCAGGCATTGTACGTCTACAACGTGAAACTAAT +ATTAATAAGTCCTTTCATATCTTTAGTGCGGGTGCTAAGTTTGTCGGTGCTAATATGGAC +GCAAACTTTGAGCAGATTTTACACTCTCAACAAGAAACCCGTGATGGTTTTGATAAGCTG +TATTCCGATGTTATGCCATTGGTTAAAGGTCTTGAAGATGCTTTAGCACAGGCTGATGCA +GCGTCTCAAGAAACCCGTGATGGTTTTGATAAGCTGTATTCCGATGTTATGCCATTGGTT +AAAGGTCTTGAAGATGCTTTAGCACAGGCTGATGCAGCGTCTCAAGCTGCTAAGGAGGCT +GCTGAAGCTGCGGAGGAAGCTGCGTCCCAATCTCGAAGTGCTAGTAATGTTATTGATCGT +ACAGGTTTAACCCAACAAGATATTAACGATGTGTTAGGTGTTACTACCAAGCTACCCGCT +GTTTGGGGTCGCGGTACTATCCTGTCTATACTAGATCGCATTAATATCAAAGACTACGGT +GCTATCGGAGATGGTACTCTGCATACCTTACAGGAGTGGGTTACATCGGGACGTTTTAGT +AATCTATTAGCTATCCAAATGGTATTCCCAAATGCAACAGCTTTAACTGATAGTATTGAT +TGGTTAGTTACAGATTACTGCTTAGGTTTACGTAAGTGTATCTACGCACCGCGTGGTACT +TATGTATTTAACCGCCCTGCGCGTACACCTCACAGTGGTAGTCCTAACCGAGTGGATTCG +GGTTGCAGTTTAATCGGAGATGGTACACACACTGTATTCACACGTTCGAATAAACGTTTA +GCCACACGTATATTTAAGGTTGATGGTTCAGAGGATTATGAAGCCTATGATGATGTTAAC +CGTGACGAAGCTGTATTTAACGTACATGGCTGTTATCAGATTTTCCATAATTTCTGTATC +TCTAGGAGTACCATCGGTTTCTACTTAGGGCAATCAGCATCTAGTGCGGAGAACTCTGCG +GTTTATATGTCGCAGTGGTCTGAGCTTCAGTTTAAAGGTGTTGGTACGGGTATGTTGTTC +GCTGCTGCATACGGTAACCATTATAACCGTGTAAATAATATCCACTTTATTGAGTGTGGT +ATTGATGTGGAGATGCGTGGTGGTAAGTATGACAGTTCGCCCACTCAGGCTAATAACAAC +CGTAACACGTTCTCTTACGGTAACCATTATAACCGTGTAAATAATATCCACTTTATTGAG +TGTGGTATTGATGTGGAGATGCGTGGTGGTAAGTATGACAGTTCGCCCACTCAGGCTAAT +AACAACCGTAACACGTTCTCTAATATTCGATCTAACCGTCGTAAGGTTGGTCTGTGGTGT +AAGTCGGGAGATACTAACCGCTTTACAACGTGGGATGGTGAGGGTTGTGGTGCTACACCG +ACTAACAACACTTTTGGTGCTATTCTAGGGTTACCCATAGTTTAGTGAACCTAAACACAT +GGGCTTTCCCAACAGTTACCAGTTTAGGGTTTACTGTTAAGTCGTTAAGTTTCACCAACG +CTACAGGTGTTACACGTACTTCACGGGATAATTCATCATGTTATATTGATGAGCGATTAG +TAGATTTAGGCTCTGTGGTTGCTAGCGGTATCATTGAGTACATTTTATGGGCAGATTCAG +ATGCTAGCTCGACTGCTAATATTGAGGTAACTATCAGTGCTGATAGTGCAGCATCTAACT +TGGGCAAGTGCTAAGACGCTGACACGTTATAGTTTACATACAATGTACTCTTTACGTGCG +ACTGGTCAAGGTACAGGGGACTCGGGCGGTGTCTTCGGGATCTTATATTGGTCACGGATC +TTTTTACTGCTACCGTTGTTCATGGGGGTAGTTCGGGTTAGGTGAGCCCTTGTCACCTCT +CTCGCAACCGCATCTTAACATATCCTGTTATGAAATTGTGCGCCTCTGGAACACGCGGCG +CCCCAGGGCGTATGCTCGCATGGGAGTAAACCTCTCTAAAGGCGCCGCGTAGATACGATG +GTCTAGAACGCGACAGTCTAATATACCAGATAGTACGGCGGGTTGTTGATGAGCTACGAA +AGGGAGTATAGGCTCCTCCATGAACTGAGGGAGTATTGAATCGTGATTTGATACTACGTA +TTCAAGCACCTGCGTATGCTTTATCAAATGTGACTGCTACAGTACGTCGGCAGGTTACAG +GTTAATAGGAGATACTACGTATTCAAGCACCTGCGTATGCTTTATCAAATGTGACTGCTA +CAGTACGTCGGCAGGTTACAGGTTAATAGGAGGAATAATATGAACATTGTAGATCAGGTC +TACATGGCACTGATCTACATTTGGTCAGAGCTAGATAAAATGGTAGTCGGTATGGGTTTA +TAAATTGGGAGATAGTAAAGATGATTCTAACTCGGAATAGTTTTGACTACTTACGCAGTA +TCTACGGTAAATTAAGTCAGTCTCAGGTGTCTTATCAGTTTCAACATATACAGTAGCCAA +ACCGTAGGCAGCTTCAGGATAGGTAAAACCCGCTTGCTTCATTTTTGAAACAAGGAAGTT +TAAACCATCAATTCCAACCTATCGCAGAGCGGGGTTCGGATAAATACTTATGTAAACTAG +CAGTACGTTTGGGTAATACACCTGAAGCCGATGGTGATGGTCAACTGTATAAAGGGCGTG +GTTATGTTCAGATCACTGGTCGAGCTAACTATAAGTTCTTCAGTACGATTACTGGTAAAG +ACTTAATTAAGAATCCTGACTTAGCACTAGATGCTGAGGTGTCTACTAAGATCATGACAC +ATGGTATGCTTAATGGTTCATTCACTGGTGTAGGTTTCCGTCGTAAGCGTCCTGTGAGTC +GTTATAACTTAGCGCAATACATTGCTGCTCGTAACATCATCAATGGTACAGATCGTGCTG +CTGAGATCGCACAAGCAGTTACAGGCTATGCGGGATGGTGATGACATACCTCAAGGTATT +ATCCGTAAGGCTATCCAACATGCACGTATGCGTAAGGCTAATGGATTACCATACTTCGCA +ACCGAGGATCCCTGATGAGGATGCTGAACCGCAATACGACGAGGAAACTGGTGATGAGAT +TCCTACACTCTTTATTCCTTTGGCTGCATCTGAGCTTCAGGTATTCGTATCGTTCTTGGA +TAAGAACAACATCACAGCTACACCTGACGTAGAACACATGGCTGAACAGGCTAATGAGTT +CACTGAAGACTTACGTTTAGCTCGTGAACAGAAAGCTAAATCAATTGTTAAGGTCAATGA +AAACGATGCAGCACTTGCTGCGTACCTAAGTTAAGGAGTTCAATATGTCGTGTATCCAAC +AGCAAACGCCAAGCTATTCCTTTAGAGGAACGTGAGGAAATATCAATGATGTTCGCTGCC +ACATTCAAGAACTTTAAAGAGTTCGCTGAGTTGGGTATGCGATACCTTGGCTTTAAGCTA +TCTATGATTCAAGAAGACATTGCAGAGTTCATGCTGCTTCTCACCACCTGACACAATAAG +TGTACGGGCAGTCGGGTTTATGATAAGAAGCCAAATACAGTACAAAGCAGCTAGGGTCGA +TTTAGCTTGACCACGCTGAGCTTGAATCATACGCTTAGCTTGCCCATGCTGGCATCTGAT +GTTGCATTGCTTATTATCCGAATTATTAATAACTGGTCTATCCTCTGTTGGTTACGCCCT +GATGCGTCCAAAGGTGATAGAACTTCGGCTAGTGCGTTCGACGTACACTACAGCCTAAAA +GGTATTGATGAGTCTGCGCCTGTATCTTGTGTTGGTATTACAGCTAACTTACAGGGTATG +CGTGCAGACTTTATTCTAGCCGATGATATTGAGACTCAACGTAACACTCTGTGTATCGCT +CTCTCCCTGCTCGTGGTTACGACGTTCGTGTTTGGTGTGGTCGTTACCCTACCGATGAAG +AACTCGAACGCTATGGAGCAGGTGTGACGATCGCACCTATGATTCATCGTGCATTAATCG +AAAACCCTGACTTACAAGTAGGTGGTGGTGTAACTGGTCAACGTGGTAAGCCTACTGACC +CTGCACATATCAATGAGGAAATCTTACAAGAGAAAGAACTTGAGTCAAACCTCGTACACG +ACCCTGCAAATTCGTCGGGCTCCACGCCCTCAGTTGTCAGGGTCGTCCTACATGCCTCAG +GCACTAACTGCTGACACAGGGAGAAGGGCCCTTTGAATTAGGTTGCGTACCCTGAGTCAG +CCGAAAACAAATTGCGATATGATCTCAATGAAACGATTGTGAGTTGTGTCACTAAGGGGA +CGTTATGGGCTAGGTTAGGTTGTTGTGTTTATGGGACAACGAGGTGGCTGCCCTATGGTG +ATGAGGGTTTCTCATTACAGTACATGCTCGATACAACGCTCTCAGATGCCCTCAGAACGC +AATAGGGACCGATTTGACCCATGTAGTGATTCTTACCTCAGCCGCTTGGGAAGCGGGGCA +AGGATAAGAGTCTCGCACCACATGCGGATATTGGATGTCGTGCTATTAAGGACAGATGCA +CGTCGACAGCGCTGATACCGACGTCTGAAGATTAAACTTTCTGATATGATTGTACTAGGC +GTAGGTAAAGACGAAGTGCCTGAGTCACTACAGTACGTCGCAGACCCTAATAAGTTATTC +AAGGAAAATACTGAAGCTACGATGTATTCGTACCATTTCTACATAAGGTGATGACACTTG +ACCCTGCGGGTTCAGGTGGTGATGAATTGTCTTATGCTATTGGTGGTGCTACTACATCGT +ATATCTATTTACTTTCAGTAGGTGGGTTCGCAGGTGGTATGACTGAAAAGAATATGAACT +CCGTGTTGCAGAAGCTGATTGAGCATAACGTTAAGTTACTCGACATTGAGAAGAACATGG +GTCATGGCACTGTTGCTATGTTATTCCTAGCACAGTTAGATAAGCTGAAGCTTCACGCTT +TAACTTCAAACCCTGCAATTGATGAGTTTAAGAATCAGCTAGGTATGAGTTACAAAGAAG +TACACACTGCCCTTAGTGGTATTGGTATCACCGAGTATTATGTGGTAGGTCAAAAGGAAC +GTCGAATCATTGATACGATCTCACCTTTGACTCGTCGCCATAAACTTGTAGTATCTACTC +AAGCTATTCAAGACGATTGGAATCATTGCTTACAACATCCATCTGAGAAGCGTATGCAAT +TCTCTGCTTTCTATCAATTAGGGAACATTACGTATGATCGCAATAGTTTAGTCCATGATG +ACCGAGCTGCCTGTGTACAACGTGTGGTGGAAGTTCTAAAGGCGTTTCTAGCTAAAGATG +AAGAAAAGGCTGCTGTATTGCGTCAGGAGGCTGCTCATCAAGAGTTCTTGCGTAACCCTA +TGGGGTATAATCCTAGCGTTGATAGTTTCTAACTTCTTAGTAACTGCTTCTTTATCGATC +ATCGTTTGAACCTCCCATGATAACGCTTACGAGACCCTTTAGAGTTATCCCAACCATCGT +GGGTAAAGATGCACAATCTATCCTAGCATTACTAAAAGCACTAAAGGAGAAATCAAATGT +CAAGTATTAAAGTTATTGCCGCGACGGTATAGAAGTGCTGGTCACTGAAGACTGATACCC +ATGAATGTCAAGGAGGGGAATAATACCGAGTCTGTTCACGGATCAGGCATGAATCGTGCA +TCGTGTGAAAGCTTCAACCTGGGAGATTTTGCTAATGTAGATGTACCTAAGTTAGCGAGC +GGTGTGTTGTACACTAGCGGTTGTTCCCCCTAGTTTTCAGACCTTTTACTAAAGCGTACG +AGAATAACTCTAAGGCTCTAAGCGTCGCTAAGGCGGTTAGTAGCACTAAGGTATACAAAG +GTAAGGATAAGGTTGAGAAAGCCCTAGATCGAGCTACTGTGGCTCTTGATGTAGGTGTAA +GTATCTATCGTCTGTTCAAGCGTTAA +>NC_025457.alt2 length=64164 tani=75.921 alt=sn;de;ins;du;inv;tl +GATTGAGATTTGGTTGGTAGGGATTGGAGTATCTGATTGGTGAATATACTGTCAAAAGCT +AAATTTGTCTAGTATTTCTGAGATGGTGTCTTCCACTGCCTCGCCCTCGACTTCCCCAGA +GCACTCATACGCAACCGTTTAGTCAGCGCGATCCACTCGCACAGAAGAACTATTTATATA +AATGTCGCTGGGTTTCCATCCAAACCATAGTGGAGTTTGAAGGCCTCAAGTATTCCGAGG +CTGCCGCAGCATATGCAAACCCCGGTCAAGTGTGATATCATGTCTTCCATCTTATGGATA +GGAATATTTGAGTGCTTTTACCTGATCTTATACTGAGTCTTTGAGTCTGCGACACTTATC +ATTCATTGATCCTCCTTGGTATGTCGCTCATTGTATAGACAGTTTGATATAGTGTCAACA +TACTTATTCAACGATGTATCTATTCATTGATACGATTCTTATATCCTTGTATGGATTATA +GTGTTCGCCTTTTATCTCATAACACTTATGCCTTTTTATGTGTTCATGGGTCTTTGCCCG +GAGTTAATGCGACGAGAAAATTGAATAAGCTATCCCGCTCTAGATATATAGATAGTTTTG +TTGATAGCGATGTAGATAGCTATAAGATAGTCATTAGTTAAAGATACTTATAAATATAGA +TAGTATTCATTTTATCTATTTCTACTGTTTGGTCTTCTCTTTATTCTTTATTCTTATATG +GCTACCTTCTCATTTTCCTTAATAAATACAATAACTTAGCTGCTTAGAAAAACGAATAAA +TTGATACTTGATTAACAATAGATAACATGAGCATAAGTATAGAAATCAATAACTTAATAG +AACTACCGTAAAGCTATGGAATAATTGTAAGATTTTATAAGTAAAGTGTTGGCATAGTTT +TTAAACTGTATATTATGCCAACCATACCAAGCAACCTACGCAAGCTACTATATAGAGATT +AACTACTAGATCTTAATTAACCTAATTAGATTGATTGCTTAGGTTGAACCAAGCGAGAGA +GATTGAAGACTCGACGTCGAATCACGTCCAAAGCATAGCAGAACTATCACCTAAACTTGT +AACAGGCAAGAGGGCCAAGGACCAGGAAATGTATAGGAGAGAGATAACAAGCCTCCGGGT +AGACGCTCCATACGGTCTTCGTAAGCTGTGCCGCGGTATAGACAGCCTTCGATCAATCGA +CCCAGATAATGAATAATTATCTAAAAATAAACAGCCCTCTTTCTCTTTCCTAAAGCATTT +TAAGCCCTATGTACTAAAAATGCCGCTATCGCGAGCCGCCGAGTTAGGTTACCTCTGCTA +GGTGGCAATCCCTCAGGACCGTTATACTACGAAAATATAGGAATCAAGCTAACTAAGATT +GGCACGTTTAAGCTGCCTGGCAAACTCTTTATCAGGTTCAGTCCGGGGATTGGTTGATAA +CTTAAATCAATAGGTTTAAAGCTCACATTATCAAGGCATTGGGCTAGAGTTAGTTTACGT +TAGTTGACTGATACCAAGCGAAAAAATAACTTAAACTAAAGTGTTGACAACATAATCAGA +TATGATAAAGATTCCGACCATAGTGAGTTATCCAAACAGTAGTTGAGATGTGAGGCTTTA +ATCAGTTGAGTATCACGACTCTGAAGGGCTACTCCCTACCATGTAGACGAAACATGGGCA +TACAGTAACAGATTACTAGTTAAATCCTTATAGGTGAAGTCGAACATGTGGTAGAGTGTA +GTCTTCGGAACAGCCTCGTTGGTGACAGAGCCAGCCCGCTTATAGAGGGTTGCCTATTTG +CTGAGTGAGTGCGTACATGGTTCCCAGGGTGTTTGCCGGTCACTGCTTGATAGAGCCGTA +AAAAAACGTGGGTGATAAAGATCAGTGGCTTGTCACAGTCAAGCGACCTAGCAACCCTGC +ACCTACAGACTATATCACAATTCTTTAGTATGTGTGCAATGTAGTAGGTAATAGGATAAG +CAATTGAGGTTGAAGTGTTATAGGTAGGCTGTGAGGCTGTACTCACAGTTAATTCCAATA +CATAACACGTAAAGCTATGATAAGGTTAATGAGTTTATATTTGAGGTTGAAGTGTTATAG +GTAGGCTGTGAGGCTGTACTCACAGTTAATTCCAATACATAACACGTAAAGCTATGATAA +GGTTAATGAGTTTATATTTAGCTAAGTTGGGTTGAATGCTACGCACATCGACCTAGCACT +GATATAATCTTGAAGTCTGACACAAAGGTAAGTTGTGTTGTGCACTACAGTTGGTATTAG +CAACGACGCACGCGATGATGACCGCACTCGTAAGGTATTTCCTAGCTAACGGATAATCTG +ATACCGAATGAGGTGATACTTGGCGTCAATGTTCAACCAACGAACTAACATACGTGTATT +ATGGAACTTTTATTGACTACAACTGAAAGCAACAAAGCACTCGAATCTATCAAACGTCGT +GGTAAACGATTCGGATTCATAAGGCTCCGTTGTCTATAGGTACCCCAACGATTATTTCCG +GGCTCTACCTTAAGTATACAAATCGATCACGGGGGTGTGCCAGTAGAGCGCCTACTAGAA +CGGCGCGGTTTGATACTGATATCCATGTGGCAGGTGTGTCAGTCTTTAAGCATGTCGCTA +AACATGGCGACACAATTTTGCTTCATATGCTCGTAGGTGCTATGCCTAAAGGTAGCCGTA +ATTCTGCGTTCTGTGAATGGGCTTTGGCTTATTAGGGATTGCGACCCAGTGAGATTAAGA +CCTAAAATGCTGACGCCAGTGGGTGGGCCATTAAAGGTAATGTCCGTATGCCTGACCGTG +CTAACAACGCTGATGAATCTGCTATCGAACCAGGTCTCTTGTTCGCTAAGGATAAGTCTA +AAGGGTTTAATGAGGTTGAAGCTCTTGCTTACAAGTTGTGTGACTTCAAGCCTGAGGCTG +TTTTGTTGATTACCTTTGATGCTGCTGCTATGGTTGCATCCAGGATAAAGCGTTGTAGGG +AGTACATGAAGACATACGCCTTGCGACGATCCGTGATCGTTGACCGTTAGCTGGTGCGAA +CGTTGGTTACCATCGTACCAAATGGTCTAATTTTTATCCCGGGTCACCAGGGTCTCGAAC +ATGGGCTCTCCCTGGGTATCTGAAGCACAACAGCAGGGTACTGAAGTAACTGGACATGGT +AATGCACTTAAACAATTCCCTGCCTTGATGGAACAACATTAAACTCAAAATAAAGGACTT +TAATCTGTAGGGGTATTCCATGATTACTATAACTGTGAATTACTGCGTTAAGCATGATGT +GAAAGGTCTTATGGAATATGCACCGTGTCGTGTCACTGGTCGCTCCAGGAACGCAGTACC +ACACTCATCCTACTTTGTCAAGGATGGCATGGCATATACTGAATTGAAGCGTTCTTCTAT +ACTCACAACTGCTATTGCAGTAGCTATCTGTGTAAGTTCATGGATAGTATCATTGTTATA +TATCTTTCTAAAAAAATAGGTGAAGTATGTTACACGAACCTATAACAAATCCGATTATAA +CTGTAACTTTAAACGTCGGCTTAGCTCCGTCGTTGAAGTGGTGTAGATACAAAGCTCAAG +CGGCTAACTTGCTACCTCAGGACAGTACAGACGCTTGTAGATGTAATCGATGCACCTCAT +CCTAGCGATCGGATCGTTAAAGATGTACGTGATCTTGCGTATAACCCTAACGGTCAGGCG +TTCTATCAGCAATGTCAGCCGTATGGTATTGATTACGGACACGATAACCGTGAAGTAAAG +TACAAGGTGGTACAGTCGGGAACTGAAGCGACGTTGGTTGTACAATTTGAGGCTACAGCC +CGTGACATCATTGGTCCGGTGTTTGCACTCGCTGGGAAATATAAAAAAGACTGTGTCTCT +GTATGGATCCACAACGATGTAAACGGTGGTATCGGTCAATTAAGTGGACGTTATAAGTGT +ATGTGGTCAGGTGGTCACTTCAATACCGAATCCTTCATTCACTTGGAGCGTTAAATCCCT +TACATCGTTCCTGTAATTATTATATTCCAAGTGGGTTTCAGGCTTGGGTTCCACTGTGCG +AAATTCCTTTAATAAGTCAGAAATAATAGGCTTGGTTAATCTATCGTTAAAAATACTGAC +CCTAACAACTTAAAAGCACGTGTAGCTCATCTTGGAACCGTTGTCGATGGCGCATTGGTG +CATGAGAAAGTAAACAACGTGTGTTGGATGCCCATTTGAAAAGTGCGGAGTCTCAAGCCG +GATCCTCCTAATATGGCAGGCCGAGCCAATAACTCCAAACCTCCCATATAATCGATCACG +CGAGCTGCGGCCGTACTGCCGACAGGAATTCTCGCTTACATGAGTCGTTCGATGTAGAAG +ACATCCGGGTCCAATTGCAAACCGCCACTAGTCCTTTGTAACAAACGCTTCTTGTGTTCG +GACACAGAAGTTTAGTCCAAGGAATGTCTCTTGTAAAACGGCGACTTAATGCGTGATGAC +GTGTCTGTATTCCAGAAGCACAACAGTAATCAACCGCAATACTTACATGTTGCAACCTCG +TGGGTGTGGAGGTAAAGCCATTGGGCTTTTAGGTAGGTGCAGACGTAACGTAATTAAAGT +TCTACCTAGAGTCAGTGCGTAAAGCTAAGGCTGATGTTGAGCGTAATAAACAAGAGTTGT +ATGAACATTTAACACGTAAAACAATCAATGTGCGGTTAGCACCACCTAGTGAAACGGCGG +TATTTGTTCGTAATCTAAGAAGTACGGTCCTTTAGGACTATTGAAAGGGCATAAGATTAC +TCTGAGTGCGATGCACTTTGCCCGTATTGTAAGTCTGATGACTTGGAGGAATTATAATGG +CTAAATCCGAATTAGCTCGAAGTGTCCGTAAAATTCGTAACTTAAAGGGTACGGCGTACC +GTGTACCTGTAGTAAATAAACTACACTGTGAAGCATTATTAAAAGCTTTTAAAGTAGCCC +GTAGTAAATTAGATCGTAGCAAATATTGGCTTACTTGGCGAAGTGATAAAGAGTTTATCT +TAGTACATAACTCGTCTGTAGACAATGTTAGTGTATATAATCAGAATGGAAGTGCTTCGG +CCTGTCACTCGTCGCATTGCAGCCACTATCCGGGCGGAAAAGGGCATTTACTTATGTTTA +CTCCCACTCCTTAAATTCGTTCCCTCTAAATAAATACAGCCAAAAATCACCGGTACGGAG +TATACTTAGAGGCCCAAGTCAGTATTTAGACCGGAGGGCGGTATTATACCTTGACGTTCG +ATCCTCGTGCAATCACACAACAGGTAAAAAACGTACGTTCCCGTGAGTGAAGCTGTAACC +GGTTTAACAAAGCTTCCATTGTACACTACGGCATACTTTTCTAATGGTGCTGTAGCATCG +CTGTGTGACCAGGAGGCCAGTAAAGAGGAATATCCCTTATCAAACCATACCAACCAATAA +TCGGTAGCCTAATACCTTGCCCTAACTGTAAGAAAGTTCATACCTCTTGTTGTTGACTTT +GGTAGTATGTTTGTAGCTACATTCAAAGGGATGTAGTCGTTAGGCATGTAGCTTATGTTG +TGAATGTGTACTCGCAGTTATATTTCGCATTTAATTAAGGTAGATGACTTATGAAAGTGT +CACATCCATCTTTGAATACATATACAACTCTTAACGTTGATAGCCCTTGGTCCCGTAAAT +CTACGAAGTTCCGAGTACCACCGGAATTTAGCATTACTAAATTATTGCCAACGAACGAGT +ATATTAAGACAGTGGCTAGAATGGATCGAATTACGGAACCGAACACTATCTCGATCTCAA +TAGTCCCTATTTGTAACAACACTGCGTGAAACCAAATATCTTTGGGTGCTACGCTTACTT +CCGCTAGTAGTTGCGGTTCTTAAAGGTTTTACACCCTATACTATTGGTTTGGGTTACTAC +TGGGACGTAGATGAAGTAGCTATGGAATACCTTGGTTCAGGTTGTTTCTCAAGTGTCTTC +AAACATCCTAATCGTACTGATCGAGCTATCAAATTATTCCGTAACTACCGTGAAGATAGT +ACCTGTTATCAGTACCTACGTTTGTGTGCAAACAAGACTATTGATTACGAATGGATGAAG +TAGCTATGGAATACCTTGGTTCAGGTTGTTTCTCAAGTGTCTTCAAACATCCTAATCGTA +CTGATCGAGCTATCAAATTATTCCGTAACTACCGTGAAGATAGTACCTGTTATCAGTACC +TACGTTTGTGTGCAAACAAGACTATTGATTACGAATGGTGCCCTACTGTGCATAGTTTAG +TGTGTATCAAGGTGATCAGCTCTAACTCCAAGCAAGGTTATCGGGAAACCCGTGATTTTG +CCTACGCTGAAGTGTACTTACTACCTTACAACTGTAATGATAGTGCTGTTTATATGGACG +ATTGGTATGCTGAGTTCCGTGATGACGTTAAGGATGTATACTTCCCGTTTGGCGATATGG +ATTTGAAACCCGATAATGTTCTAGGTAAGGTCAACGATGAGGGTATATGTCAATACTTTA +TCACTGACCCAATATGGAACTCTGGCTGTTTATATGGACGATTGGTATGCTGAGTTCCGT +GATGACGTTAAGGATGTATACTTCCCGTTTGGCGATATGGATTTGAAACCCGATAATGTT +CTAGGTAAGGTCAACGATGAGGGTATATGTCAATACTTTATCACTGACCCAATATGGAAC +TCTGAGCCTGAACACTACGAACCAATCCCTGAAGCATTAGAGGAATTGTCTGTGTATCCT +ACAACGAACTGGTAAGGGACTTCCCACATGTGGGGTTTATGGATCGTAGAGTATAGACGT +GATGGCCGGGTAGTACGTAATCCTTCTTCCGCCTCAAGATAGCGATCCGCCCGGTGAGCT +TAACCGATATTACGTCGAGCGTGTGATCATCTCATCTGATCCGACATCGTTGTCCCTGGT +GGCCCGGCTGTAAAGGGTTATTTTAACGCTAACGCATCGAATGGTACTTTCATAAACAAC +CTATGGGAGAGTATTAAACACGGTCGTGTATGGTAATATTATAAAAAGTAGTGCTACCGT +TCTACGGTCTAATGTCCCCACACCGTGGGTGCGCCCTGCTAGAACCGAATGGTGATGATG +GCACCGCGGTGTACGAGGTAACAAATGGGGCTTGAAGTAGCAGCTTTAGTAGGTACTGGC +TAGGCATCAATTTCCAGGTTAGACGGCCGCCTGTGATTTGGTAGCTTCTAGGAACCTCCG +TACACGCCGATAGTATCTGCCGTGGTATGAGCGCTATGTTTGTGCATGGCTTACGTTCTG +TGCATGACTTAGGTGACGCTGTGTACTTTGAGTCTGATGCTAGCTCTAGATATCGACAGC +GTAGAGATTTGTCAACTATGTCAACTTTACAGTTAATTGCACCTTACTCTCAAATTAAAC +GACCTACTAGCAAAGATACTCGCATGACTCATGATGAAGTCAAATCTATCATTGCTGTAT +GGGTTAATCCTATTTCCTCAACTGTGCAATCATAAGGACATTAGTATGTCTGACTGTATC +CCTATTGGTCCCTTACCACTTAACATGGGTAATGTAACTATCGGTGTTACCCGCCACCAA +TTATTATTTTTCATGCAGTACAGTGCATATCAACCTAAGTTCTAAGGCTTAAATATAGCA +GCACCTCGATGAGGTGCTGTTGGTATTTCATCACGGGACGTAAGGAGTTTTATTAGGATT +AAACCTAAACACCTATTCGAAGTAGCAGGTATCGTAGGTAGCCCTGAACGTAAAGGTTGG +AACTTCAAAGCCCCGAATTCTTGCGAATGTTGTCGCTCTGATAACTGAAAACCTCGTATC +GGCTTCGGGTATAAACATAAGGTAGGGCAGGTCGCTCCTGCTATTGCATTCGGTTTAGAA +CAACAGTTAACTTCCTGTCAACTTCATAACATGCACAACCCACCACCTGACGTTTAGGTG +TGCTTCGAAAGTGCGGAGAGCTGCCATCGCACTCCATTAACGAGCCTACCAATGGTGTAC +ACCAAGCTCGCCAGTGAGTTTGAACAGAACAGTGGTATTATACACGCACGAGCTAATGAC +GGAGCTACATTGGAGTTTTCCGAACTAGTGCCTAGCAACGAATACGCGCACTAAGTCCGT +GCTATCTTAATGTTCGCTAATCCCCAGCTCAGGTTCAGTAGTACCTGTATATGTTGGTAA +GCCTCAAGGTAATGGTGCTAAGTTGTTCCCTGGTGCGAACACATGACTCGCGATGAGGCT +ATCTATGAGTTTAAATGGTACTGCTGTGTTACAGGTAAACAGTATCTCACTGGTTATACT +AACGCTGTCCATGATAGTCAGCTACAATCAGATTTAAAAGAGGTGTTGTATAATGCAGGT +CTCAAAGAGAACACTGCATATCAAACTCTTATTTCCAAAACAATTAATGAAGTGGCTTTA +CAACGTGAACAGTTTGATTCTCAGACTCGTACTGCAAACCACTGGTTAGGCGCAATGCGT +GTACTAGACGAGCTATCAGGGCAACATAGTGGGGTTATTGCAAACGATGGTACTTACATT +TACACCTCTGTTGGTGTACTACTTATCTTGGTTCAGGATTGCGCTAGGTCTCCTAAAGCT +ATCCTTCGATGACGCGTATATCTCGTGCTATCCGCTATCCTAACACTCTATCTCGTGCAG +AACAGGTGGTGCTATCGTCTTACTACTGTCGTAGGAAAAAGGTCTTGTCGCAGTGCTCTG +GGTATGTTTAAAGTAGGTCCATAACGTGCTAAGCCACGCTGTCTTCACCGGCTGAGTAAT +GCCGCCCTAGGCGTCCCAAAATCGTCCCTACCGCCCTTTAACATCACTAACGTCTCCAGC +TAACAACTACAAAGGAAGTCCACGTGTCCGGAAAACAAAACAAATCTGCTATGTCTAGTA +TGGGTATGAGAGTCATCGTGACCAAGCCCACACAGGCGGATATGAAAGAGGGTATCAAAA +GCGAAATGATTGGTCATGTTGAGCAAGTCACAGCCTCGTTCATTCATGCAGCGTTTGACT +CTAGTAATGCGCGACGTTACGATTACCCTTTCTTACCACATCAAATCCGTCCATTCTAAG +GGGAATTACTTGCAAGAACTATACGCTTTTATTAACACACATTCACCTCAACAAATCCGT +GCTATAGGTGATGAAGCTCAACGTTTAGAGTATACACCATCCTATAAACCTAACCACAAA +TATGTAGAGGCTGTATTATCCCAGAGTGATGGTCGTTTGTTCCCAGAGGTGTATCATACT +GAAAAACACTTTGAATAGTCCTGGGGCGCAGGACGTACAAGGACTTTAATGATCTTCTGG +GGACTTGCCCGTACCTGGCCGTACGACCGAGAACGGAACCTAGTGATTTGGTCAGCCGTT +GTTGTCGCAACATCAAGCAGACTCGTCAAAACCGCCGTGATTTATGTGGTGAGACCTCCT +CACAGTATAGTTAAGCTGTTCTCGATGTTGTAAATAAGAGATATGTACTTAAGACCCTTA +ACGTACAGCCGTACAAATGGATTAAACCTACAGCTTATAATCCAATTATTAATTGGTTCG +CTGAGAAGTTTATCAGTGCTTATGCTGTAGTGCGTAAGGTAGCTGTTGCATTCATTAACC +ACATGCCGTACAAATGGATTAAACCTACAGCTTATAATCCAATTATTAATTGGTTCGCTG +AGAAGTTTATCAGTGCTTATGCTGTAGTGCGTAAGGTAGCTGTTGCATTCATTAACCACA +TCAAATAAGGAGCAGTGCCGTGGATAAGCGTAAAGAAATCGTTAAGGGAGTGACTCCTTA +AGCAGAACGCAAAATCGTGCAGTTAAAACGTCGTGAAGCTAATACGGAAGGTCAGCAAGA +TCGTTGCTCTAAGCGTCGGAATAAGCGTATGCAGTTCTATTAATGGGTAGGTCTTACGAG +ATCACGATAAAGTCCATACAGCATTACCGTCGCTGTGTGGATAGCTTGAAAGAGGTAGGT +GTACAATTCTGCTCTAATGATGAAGATGAGTTGAAGATGCTACGCTGTAAAGATTACCGA +CGTAAGGCGTGGTTGTATATAGGAAGCAACAAGGTTGCATGGGTATTCGGAGCATACAGC +GTGGTTAACCATACAGCATTACCGTCGCTGTGTGGATAGCTTGAAAGAGGTAGGTGTACA +ATTCTGCTCTAATGATGAAGATGAGTTGAAGATGCTACGCTGTAAAGATTACCGACGTAA +GGCGTGGTTGTATATAGGAAGCAACAAGGTTGCATGGGTATTCGGAGCATACAGCGTGGT +TAAGTATGCTAAGACGGTTCAGCGTAAGGAAGCACTGGAGTTAATTGGAGATGCTCTATA +CCGAGTGGTTAAACCTAGCCAAGAAATTTCCGGTAGGTCAGAAGCCCGGACATTATCATG +CGGACGAGTTAACTTAGGCACTAGATGTATGGAACAATGAGAACTCATGGAATGCTTACT +GACATCTGTGTCATACCCCAGCCAAGGTACGTAAGCAGTTTGTCGAACGTGTAGATGTAA +CCGAAACAATAAACGGGCGTTATCGTGATAAGCATTGTCTGATTACTTTGTAGCAGTTAC +ATGATAAACGCTTGTTCAAATTTATGACGTTGGTCAAGCTGCAATGTCTAGCTATGCACT +CCAGGTTTAACTCTTCCTTGACGGAGTTACAAGAGCATGATACTTGGAGCAAAGTCTCCT +TCTATTGGGTGTACCTGAGTTCCACCAAGATCGCTACTCGATTGACTTACATGATAAGGG +TATGACTACAGTCACAAAGCACCAAACCATAATGCTCTAACGATGTATGCATCACTGACT +TCAGCTCACCCGTATGTTCATGTAAGTTTGCCATACAGGCACGGACTATCAGTTATCTAA +GTCCAATGTATAATAAAAAGGATGATAGTCTACTGTTCCGCTTTAAAGGTGTTGATATTG +GTAGAGACTGTACAGGGTTGTCACCTGCTAAATGGCTGATTCATGATAACACTGATCGGG +AGGGTTTCGTGTATTTGAAGGGTAAAAATCCACACTGTACACTAGAACCTGCAATATTAA +CTGAAGATTTATTCTTTGCACAGAGGGTCAAATACTGTACTAGCTACTCGACTATGTGCC +TATTAGGAACTAAATTTACACATGAAACCGTACAGTTCTTACTCGAACGACTAGCCCTTA +GTGCCACCGACCGAGATTTCGCAGGGTGGAAAGCACGTCGGTTTATTAATAGTCGTTCTC +AGCTTTTTGGTATCCCTTGCCCTAGTGCATATATTCCCAACGGATTAGACCCAAAGGATA +CGTCACCTGATGCATGAAATGAAACATCCCAATTCTTGGAGAATTAATATGCGTTCTGTA +TTCGTACTACCTAAAACACATGCGGAACTTAATCAGGGTATCCCTACTTCGATGATTATG +AGTTAACCGAAGGTGTCGTTCAACAAACTTCAGTGATGCTACTGGAGACAAATGTAGGCA +GCTTGGTAAACGCGTAACTGTTTGGTTAAATACAAAGACTTACTATCTACATATCTATCT +TGTATTTCTACACGCACAAGTAACACCACATCAATTAGCAGGTCTACTCCAGGGGATATC +AAGATGTCAGCCTTAAATCTACTCTGATGTAGGATGGAGCGTAAGTCTTATCAATCGTCA +TATGCGTCCATCCCACCACAAATGTATGATTTAACTGCTCGTCCATTCCCTACTTGGGTC +AAACTGTATTACTAGCATTATGAAGAGCATGAGCGTGTTGATGTAGACACCTTGAGTAGC +TTCATTCGTTTCAAAGGTAATTAATCCCAGAAACAACCAAGGCTGACTGACCGATTACTC +AAGCAGCTACGTGAGCCATTGCATGATGCGGCCCGTGCCACAACATTAAACGCTTTGGAA +GAACGTCGTCTACCAGGTTATGCTGAGATGTTAGACAAGCGTTATCATAATGGTGAGGAA +ATTGACATCAACCATGAGAGGCGTAAGCTCGTACAAGCCTGTGCAGCTTGGAAACGTGCT +TTCCATTTAGGATGTGCATATAGGTTAACACCGTTACCGATGATCAAACCGTCATTGTCT +GTACCAGTACCTTTAACAACACCTATAGTAGGTTTGAACCCCTCATAGTTATTGAGGAAA +CCCTGCCATGCTGTAGCTAGCTGTACGTTACCATTAAACGGTACAGATGCTAACGTAGGG +ATTTTAGCCTGTGTCTTAGTACCATTAGGTAATGAGATAACAGTCTCGGAAGTCGCATTA +GATGAACAACATGCATCATGGTGTGATACCGACGTAGGTGAGCTTATCGACGCTGATGTT +GATGACTCAGGATATGTGTTGGACTTCTTACCTGAAGGACTTTATATCTGTATCAAGGGT +ATCAATGAGGGTAATAACTTAGGCATGGCAGCCCCTAGAGATAAAGGTAAAACTTCGTTC +TTAGTGAACCTTGCTGCATCGTTTGCTATTGAACGACGTAACTTTACGAAGCAATGGACG +ATTGATCTTGAAGACCCTGAGAAGCGGTCAGAGCGATTGCAAGAGAGGATTCGCTTTAGA +CCTATATTATTCCCTGTGAACGCGGATACGGCTGAAGTAATCACACCACGTGTATATCAG +ACAGGATTGAAAGTAACCCGTTAGCAAATGTATGGACGTCGTAAGGCGGGTCCAATCACT +ACAGAGTTGAACAAGGAGAGCGCGGACTACATTGGTGCTGTAGGTCGTCGTGATGCTATT +CGAGTGAAGAACACCCACGGTAAGTCTGTAGCGCAGGTAGCTAAGATCATTGAGGCACAT +GATCCGTTCTTAGTCATTACTGATATGTCTGAACGTATACGTGCAACTGGTGGCGGTGCT +GGAGCTAACTATCTTACACTGCTTGATGAAGTCGCGTAGCGGTAAAAGCATTCAGCTGTA +ATTCAATCAGCGCAAATCGCAGTAGGGGCGCGACGGTACGCGCCTACTGGTGCCGTTGCT +ATAACGAAAATTCTAGGAAGTCCTCTGGAGTGAGCGGTAATTACCTTGGATTTATATGCA +TAGGCATGCTGCCATGATGGACTTCATGCATGTAGGTGCAGCACAGATCAGTACCGAGAG +TTTTGATAGCCTGTACCTACCAGTGTCAGCATTACAGAACAGTAAGTCAGGTATTCAAAC +CAAAGAACGGGCCAAATCTGGTTTCCCTCTAACAAGCTCTAATTATGTTAACAGCCTATT +TACCAAAGATGGGAGGCGCGTGGGCTAACACGGGCACTAGACAGTGGCTATGGACGTGTG +ACTATGCGCGTGCAATGGATTTAGCATTGTGGGTCGGTACTTATGGTAACCCTGTACCGG +TTAATGGATTGAGGCGTGGATGAGGTACACCTAAAAACAAATTAGCATTATCAAAGAACT +ATTGGCACATTTTAGGTCCGATTAAAACTCAGACTAAGATTCAAAGAGAGGTTGTAAAGG +TGGTAGCCAAATTATGACAATCTTCGGACCTGGACCCTGCTTCAATGGCTCTAAATTTCA +ACCTCGCTTGTGGTACACTATAAATACTGCGGAACTACTGGGTTCAAAAGGCGTGATTCT +TAGGGCTCATAATAGGCCCGACAGCCGGGTGTTATCGGAAGATGCTGCCCCACAAATAAC +TGGGATCCGGTGACTAACTCATGAAAACAGGTGCGGCGTACATTACCCCTTCTCCCGTCA +TGATGTAAAATATATTAATAGCTTTGGGATTTGGACGCTATGTGAGGCGCGGGTTAGCTA +TCCCCTTCTAGACCTTTGCGCGGTCCCGCTCCACAAACTCCCTGTGCAAATTTTTCATCG +ACCTGTTGGTTCTTCACTAGCTTCCAACGAAAGATGCACTATACAAGAACGAACTACATT +ATACGTGCAAGCAATAGTACACAGGGTTAATTTTGGTGGCTTGTAATGGCTGGCCAAGTA +TATCGTGCCCTGGGTGTACGTAATGCAGTAATCCAGGTCCAAGATAACCACGGTTACAGT +AACTGGTGCAAGATGCTCTAGGCTTGAACCTGCAAAGTTCAGAGCGGATAAGCATTTCTC +TTGGATGAAGTTTTTAGACTTCTTACCAGTTACTTTACCATCAGCATCCTTAACTTCATA +CTCACCTTTAATTTCAATACTATCCCACATAGCTTGATACTGTTCGCTAGTAACCGATGG +TGGTTTATTCCATAAGAAAAGATCGTTTCGTTACACTTAAAGAGGGCAATCAGACTCGCA +TCTCTGTGGTCTTAGATGCGGAAATTGATAGCAATGCTCTATTGGATAGACTAGTCGAGG +CCGAGGTGGAGCGCCTTTCATCCATAATGCGGACGCGTCGCTGCTAATAGCCGGGGCCTA +AACTCGTAAGCGGTCTAGGGCAGTGCTGACCACTCTTAGCATTAAAATTCGGGAAGAAGC +GGTGATCGGAGTCAATGCGTATTAACTATCTCTAAATCGTGCATAGGGCTAACGGGCGAA +TCTGAGATAGATTTTGTCTGGGCTTATGGTTATCGAACGATACGCATCTCCGAAGGAAGG +TAGGTATATGGCGGGTACAGTAACTAAATCTGACGTCAAAATAGACGATACAGTATTACG +GATCAGTGGTCCTGGGTTACGAGTAGGTGCAGATTTCGCAGTCGTTGGTGCGCGTCCTGA +TGGTGCTGCTGTAAGTTTACACGATCAAGCTACTGGCTGGCTCTGCGTGAGTACAATCTC +TATTGTAGAGTGTATCAAGACTCAACCTATCGTACTCACAAATGATCAAGTGTTTAAGTA +CTTAGCTGACGATGTCGACCTTGAATACTTTTTCGATGATGTTTGGCACAAGATCGATAA +CCAGAAAAGTGTTAATATCCGATCCAATCAAATTTCATAGTTCCGTAAGAAGCGTGAGTT +AATGGAACTTAATGGTATTGAATTTCCTAAAGCTAGTATCCGTGCGGTTCCCTTTGATGA +GATATGTATCGGTTACGGGGTATCTTTTAACAATCTTCAATCCGTGTTCACTCTCCGTGT +GGTTTTCGAGTGCCCGCGCGTATCCCTATCGCCTGCCTCCCGAAAGGAGTTCATCTGCGA +AAAGGAAGAATACGAGAGGTGTACAACGCACCCCTTAAACAATTGGGACTCTGTGGTATT +ATGTATTGGACTGACCCTCAGGAAGCTCAAGAAGTATCGGAACCATTACTCAAACCATTT +GGTAAGTCTGCTAAACCTTTGAAATCAGACCTATAGGGGTCCTAACATACCTCAGACTGC +ACACAGATACCCCTTGACGGCGGTAGCGTCCATCTCATCGCACCCCTCCCCGGAAAAATG +GGATCTATTTAGGGAACGCGGAATCGCACGTAATGTGCACCGGAAAAGGAAAAGGTGATT +TGCGCCTGAATTCTACTGTTCGTATGTATCCCTTCATAGGACGTAGCATTTATCGCTAAT +TACATGGCTTATTGCAAGAACCCTGTACATCTTGTCCTATGTAGTCCATACCGGGCCAGT +TTTGGCATGCCTTTAGCACCGTTGGTCGCTTGACTTCACTCTCGTAGCCGACAGCATCCA +CTTGACGATTTACACGGTGAAGAAGATGTATGAAACATTTTCATGAAGTTAGTGGAAAGA +ACATCAAATCCCCACTGATCGGACAGGTTAATTATGGCGGAATTTATTGTTTACTTGTCT +ACATTGGCTCTGAACCTCAGTCGTTCAGTCGTGTGGGCAAACATCTCTACAGGGAGAACC +TCAATGGTTTTATGGGTGGACAGCTTTGCAATCTTGCTGACGGTGTGCATATTGGGGGAT +TGTGTACTGATGAGTTATCTTTAGAGATGCTTAGTGGTTATCTATCACCTCACCGTCAGA +AACAGTATTGACGGTGCCATGCTGATACCCCAGACTGATGGTGGTAGGGTGTCGAATTAG +ATGGAGTTGTCTCTCGCGCTACGACACCGAGTTAGCTGCCGTGAGAGGTATCATGTCTAG +GGGATCTCAGCTATGCTCCAAGTAGAGGGCAGTTTACGAGACACCCCACGGAAAGGAACC +GGGAGGCACTCGACTTAGGTTCGTCCAAGTTTATATGGAGACAGAAGGTGGCGGGAAAAC +CTTAACGTGGGATGACGTAGGGACGCATAAGATTGGTGAAATACACCCGGAACCGAATTA +TGATCCGGACGTGCTTAGGATGCTTAGTAATATGGACGCAGCAGGGCTGGAATCGACGGT +ATCGTATGCAAAGAGCTACTCAGTGGTATGTTCAACCCCAAGGTTACATAGCATTCCGTG +ATTACTTAAAGGTCGGTGGGCTGTTAGACGGTCTCACGAGCGGTACGCGGGTGAGCGTAA +GTACGCTACTCGTCAGACCGAACGATCAAACGCTGGCCCTCCTTTCAGTAACACATTGGT +GTAGGTCAGCCGCGGAAGAATATCCCAGATCTCGCAAGGTGTGCAGTCACGTAGACCTTT +ATCTAAGACTTGGGTTTCGAGGTTAGTGTGGGGACTGGGCGACGCAACGGCGATACATCA +TATCGAATCCGATACTCAAACTTAGAAAACGGTTTGCAGAAAGCAGCTATCGATAGGTAT +ACGGTGACGCCTAAACTGATCTATGACCGGGAACAGGCTGATCCTTACGCTGAACACTTT +ATTAAACGTGGGTATGCGGGCGCTGTCTTTAAAGACCCTAATGGAATGGCGGTCATGATG +TAGCCTGGAAGCTCCCCAGTTGACAATTAGTTGGACTGGTGCAACAAAGTACCGCCAGTT +GAAAGGATCTACGAATAAAGTCGCGTGTAGCTTTATTTTTATAGCAGCTTGGGAATCAGG +TAATCAAGGTTATCGTACAATGAAGATGGTAGGTGGTATCCGTCCTCGTGATCTTCCATG +CGTGGGTGTTGTCTATGGTAAGGATGAACGAGCAGGGCAAACTGCTGCACTACGCTTCAC +CATGAAAGGTCATGGGTGCAATGCTGGTCTCGGTAAGGTTTGCAGACCGTCATACCGGCA +GTCTGACAATCAGACTTCCACCCGTTTAACCAGTCGGAGTTGGCGGCCAAGGGCCCGGTC +CCACCTCGTCTGGTATCGTCCCAGAAATCATGCTTCGGCGGGCTCGATAGTCCGTGAGTC +AGACCGTATCAGTCGGGGCGCTCACGTGGCAAGAGACTCTTCCTCGAGTGACTTCCGGTT +TACAAAAGCAGTTCACTGCTGCTGGTCAGTCGGCCCGCGCCGCCTAATACGACGAAACCA +TAATGATGAATGTTCTAGAAGATGAACGTCGTGATCTACTAACACTCGCTTAGCACGAGG +ATCGTGGTGAGTGTTGGGATTGAAAGGGGTATAGCGATACACTTAGCGAAGAAATGCGTA +ACCCTGTAGGAAAGATTTGGGAACTGAAAGCATTGCAGTATAGCGCAACTGGTAAGGCAT +TACGTCTACGAAAGATGGTACAAGTACGTGAAGATAGGGGGGCTTCTGATGTTTAATGTG +GATGCTGTTGGTAATGAGGTAAAACACGGGCACGTATAGCACAACAGGCACGTAGATTTG +GGCACACAATCCCACAATGTCGACAGTTGCATAGATAGGGCTATGAACCTCTCAATCGCG +TTTCGAAAGTCATGTTACAGACGACCAGGTGCAAGGGGAGAGTGGTCTCAACCAGGTCGC +AGTTTGACGAAGTCGATTTCATCTCTTTGATCCGTAACGAGGGTGATCCTTTGGTTTGTG +TGGTGGATGAGCGTTGTGGTTAAACACGGAATATACTTGGAGCGGGTAGCTTTCTTCAAC +TTAGCAGACGTACTCCGACGATAGATATAGGTTAGCATGATTACATCATACGTCCTAGTG +TTTAGGTCCATAATGTCACGTTCAAACTAACCAACGTCAAAAGAACGTGTCTGAGGCTAT +TCAGGCTATGAACTGGGATAACGTAGGTGGTAACAAATGGTTTGGTCGTGGTGTAGGTGG +TGGTTCACGTTTACTTAGTGGGTCCATAATGTACAGTTATGCAACTAACAGTCTGATAAC +AACGTGCTTAAGTTTTTATAAGTATATGACTTCAAACACGAGTATTAATCGAGGTTAGAC +GACGTTACCGATTGTAGAATGGCCTGCAAATGCTACCCGAATCTCCCTGGCCAGCTACTT +GAATCATAGTTGGAAAACGTGGTTGTGCGTCGACTTACTTTGTTTCGGCCGAGTGAAAGC +CCAGAGGACCCAAAACCGCACCGGGAAATGCTTTAGGGTCGGTAGTTGACAACCATACTG +AGATTTAGATTAGGCCCGCCCACGAGCTTGAAGATAGACGTTTCAGATAGGTAGATTCCA +CACAAAGAAACTGTATGTTTAAACATAATTTCATTATCCATGACTAAGACAACCAAAACC +GTTCTTGGTATGGTCCAATGGGATGACCACATTGACCTGCTAACTATATTGTTGCTACTG +GACATTCTAATGTTGGGGGTGACAAACAAGGACATCACTTTGATAGCGCTGAAGAAGCTC +AGTCACATAAATGGATTGCCAAGTTACAAGGTTGTAAGATGTATGTAGCACATAACACTA +CGTTTGAAACCCAATGGACGTTACGAACTTATCCAATTCAATTTTCAGATAGGATTAAGA +TAGATGGTATGGTATTGTGTGCACAATATGCAGACTATATGTTAACCCATCATCTAGAAA +TGTATCCTAAGCTTGAGGACTGTGCTGTTAAGCATGGTTGTTCTTAGAAGATTGCTCACG +TTAAATTACTTTGGAAACAAGGTGTCTCAACTGCAGACATTGACAAAGCTTGGACGCACA +TGCATAGCCATTATGGACTGCACTTGGTCTGCTTCCATCGTAAATCAATGGATTCCTACG +TTTTTCCTCTATGCCGGCCAATGATCAACACTTAATGGATTACCTGTAACAGTCATGCCA +CGCATGTTGTTGTTTGACAAGCCGTCAACCTCCTCATGAAATACGTAACAGTCTCTAAAC +TTGGTGACGTAGCGAATGCTTGTCGTGTATGCTTCAGGCAAGGTACTAAGCGAAAGTAAG +CTGTGCCCCTATTAGGGATGTGAAGAAAGACTGCGATCAATTTGGTGATAAGTTTCTACC +TGTCATTGACGATTAATTTATTCTTTTAAAGTATGAGCTTGTGTATGGTCAGCCTTTACG +CATTCTACGCGGTAAGAACGCAGGGAAGTTCAAGATATTTATAGTAGAGACTGTGGTAGC +TGAGGAATTTCTGAAGTGGGGTGATAGACGAAACCGCTTCAAATGTTTGCTTGATTTCAA +TACACTACCTAAGATTGTGTCTGAAGCTTATGTAGGTAAGCGTGCTGAGTTGCGCGGGAT +GCATTCCCAGACATTCCAAAGTGAGTGGAATTGAAGTAAGACCATAACATTCCTACGCCT +ATCATCGACAAGGTGTTGCCGGTGTTGCGTGGACACCTGAAGCTGTAGTAATTGGTAGTT +CGGACAAGAGGTAATGCGAGACCGTGGACTCCAGAGCCTTAATGTACCCGGCAAACACAG +CGCCATCGATATTAGGTGAGAATAGTCACAAGTTCGGTACTCGAGTCTGGTAACGAGAGC +TGGTAGATGGTGCGCCAGTCTACGGTACAGGTAAGGTTAGTCTCGCTGTACTTACAGCTC +ACACGGATGTTGCAAAGCCATTGAAGAACTTAGCTGCACTTATCAAAGACACCACTACTT +ATTACCTTGTCGTTGATGACAAAGGTAAAGAGTCGGGTATGCTTCAATTCGTAGAGCCTA +ACGGTATCATTCATCATCAACTTAACAACTGTGCAACTATTACAGGTCGCTTGTCAGGTA +GTAAGCCTAACATGCAGAATATTCCTCGTGATGGTACATCAGCTGCACTTATCAAAGACA +CCACTACTTATTACCTTGTCGTTGATGACAAAGGTAAAGAGTCGGGTATGCTTCAATTCG +TAGAGCCTAACGGTATCATTCATCATCAACTTAACAACTGTGCAACTATTACAGGTCGCT +TGTCAGGTAGTAAGCCTAACATGCAGAATATTCCTCGTGATGGTACATCTAAAGTTAAAG +AGATGTTTAGCTCATGGTGCATATGCGGATTGTCAATCCTAAGCATAATCGTGGGTAGAC +TTACCTGACAAAAAAGCAACTCGCATTCCGCTTGACACCGCACCGTGTCTTTGGTGTTAA +TGGACGTATCGTTGAGGTCGATTATTCTGCTCTTGAAGTTGTAGCCCTAGCCAGTATCTC +AGGTGATAAGAACTTGATGCGGATGCTGATTGAGGGTATCGACATGCACTGTTATCGTCT +AGCTGCAAAGCTTGGTGAAGACTATGAAAGTGTATTCGAGAAATGCCACAACAAAGAACA +CCCTGAGCATAAGCAATACAAGCAATGGCGTACAGATATTAAACCTCGTGCCTTTGCTCA +CCAATATTGTGAATCTACTGAGGGTATTATCGTTATCCCGGCAAGAGAATTACGCAATGA +TAGCGGGAGCGAGCTGTCGACCGGCCGTTTGCCAGCCGATCCGCTCATGCGGAGCTCTAC +GCATTTAGTACAGGTGGTACCATAGAGGATGCACAGGAGCTCAAGAACGTTGAATTTGCA +CTGTTCCCTGAATCTAACGTATTCCCTGTTAAGTCTGTACGACCAACGGCAGAGGAAACA +GAAAATGCTCCACAACCCATTCGTGAGGTTGATAAAGAAAGTGGTCGTTATGATGTGTAT +CCTCATACGCTTCTTGCCTCACTGGCGTCCGTTAAGGGGTGACAAGATAATGTAGTTCCG +CCTGACCGGTGAGCACAGTTCAATCATGGACTACTCGTGGTTACTAGCTTCGCGATGGTA +GCAGGGGGCTTTAGTCGGGGTTACTTTCAAGCGATGTCAGGTACTTGCTGCTCATCCCGT +CAATATGATATACGGGATAACGAGCTTCTTATTACCCTCCAAGACTACAAAGACACACCT +GAGAAAACATGCACGTGGGATCACTACCTGATATCAAGGGATCAGGACGTACAGATTGCC +AACTATTGGTGTCAAGGTGAGGCATCCTTTATAGTTCAAGCTGCTCGTGGGCGAATCAGC +CGTGAACTCATTAAACGAGATTTCGCAGATGGATTCGTCGTACCGAACAATACCGTACAC +GATGCAATCCACTTGGATTGTTCAACGGAAGCACTTGCGAAAGAATACGGGGCGTTTGTA +AGGGATATTATCGAGGTTACTCCTAAATAACTAGCGGAAGTTACCCTTCCAATAGCAGTT +AGCCCGCAGCATTTAAAGAGTGGAACCATCGCTTAACACCATTCCCTGCCGCTGCTGCAT +ATGGGGTTAACAAGCCGGTCCTCCGGTAGTTATCAGATAAGACCTAAGACGCCTGTGGAG +GCATTGATGCGCTACTTTACTCCCCGGGATATAACCTGTGCACCAATGTTCGCATTGTAA +CTCACGTCCTCTTATAATGCACCAAGAGCATATTTAATGGATATTGCATCCATTGTGCCA +CAGGGTATATTTCAAGGCAAAGACCAGGAGATTATACAAAAGTGTGGATGTGGGTGGCTG +AGAACTTCCCATGTGAATAATGGCGGCGCAGAGAAGCAGGTCGGCCGTCGGGTGACTGCC +CGTTACCTGCTATCAGTAACTTAGAGTTCTGTAAATTCACTTACATGTGTGCTCGTGACC +CTCTGGCATTTGAGGGTACATTACAAGGACCTGAGAACTTGCAGGATATAGTTATCCCAC +TGTCAGCATTGATGCTGGATAGGGTAGACATGAATGACTACATTTATGTCACAGATAGTC +ATAAACACCTACAACCTAACACACGCGGTAACCGAGCGGGTTGGTATGTGGATGGTTTCT +TAAGTGATGATCAATCACTTATTTGATTCGACACGCGTAAGTGACTCCATCGAGATCCAG +TAGCGATTCTAAGTCGGAGGCTTGATTTTCACCTATCCAATTTTATAAAAAATGTCGGCG +GAAATTACGATCCTGGATCTGGAACCGGCCGGCAGCCGGCTGCGGGACGGTAAACTCTAA +TGCAACGCAGTTACCGAGGCATCGCCAACCTCGCCGTCTCGATAAGTTGCCTACTCCAAA +TGCGTTGGGTGGCTTTGAGGTTTGCCCTGATCATGAACATTCATTAGAGCAGTTTGAAGT +CCAACTAGCTTCCGGGAATTTACAGTACACTGAACCTACTATCTTGTGCGAATTAAAAGA +TTGTGTACATCGACCAGTCTTCAACCACACTAATGACGTACGGTTACGCACCTCTGTTAT +GATCGTAATTAGTAAAGGACGTTTCAATGGTACAGGTGATCCTTGGAACTACCTCCTACC +ACACATCAAACCTACTAAACAACATGGTGAGCCTCGTGACCATACTGTGGTTAAACCTGC +ACTCACACCTCAAATCTTAAATTTAGATCGGAGATTATGTCATGACTCTATCAGCTATCA +ACTTCTTAGATACGTCCCACACCTTGCACACGGTATCGACGTAACCACTTTTGACGACAT +GACTGACGCTTCATCGGTTGGCGGTGCTAAACGTGGTTTATTACCCGTAGCTGAAGATCT +TGTACTATTCAATTCATACATTGAGTATGGTAACCATCCACAAACTTTGAGACCGGGTAG +CCGAATCAGTAGTCCTATCTGGGGGTAAAGCTGAAGACCCGCTACCTGAGTTCCGCTTAG +TCTTCCACGTTGTAGGTGGCGTAGGTACTAACAAAGAGGGTGAGCTTGAAGATTATGTGC +AAGATGGTTTCTGCCCTACAATCAACGCATTCGATTGTAAGTTGAGTACGAATGAGAAAG +CCCGTGCTGTTGCGTACTTCAATGCGATTAACATTGCACCTAAAGGTACACACTTCATTC +AGAAGTTAGGTACATTATACACAGTGGAAATTAAGATCGGTAAGAATAAGAAGACTGGTA +AAGATCAGAACGAAATTGACTCCCGTAACTTACAACCCGCAGTGGATGCCGCAACACGTA +AAGCATATACCAGATCCTGTAATGTTGCTGATGAAGTAGTCCCCATGGGGGTAGTTAAAC +CTAAGGATGTTAAAGTCGTTATTATCGGGAGGTGTTATGCCACTTCCTGACGCTGATGAA +GCTGAGGCTGCTGATACACAAGCTAAACAGGAAGCTGTTAAGGCTGAGGTTGTTGAAGAA +CCTGAATCTGAAAATGAAGTTGCATTGGATGTTCCTGACCTCTAATGTGACCGAGTGAAC +CCTACGGGGTTCATTCAGCTGAGGCTGCTGATACACAAGCTAAACAGGAAGCTGTTAAGG +CTGAGGTTGTTGAAGAACCTGAATCTGAAAATGAAGTTGCATTGGATGTTCCTGACCTCT +AATGTGACCGAGTGAACCCTACGGGGTTCATTCACACAAGCGATTATTTGTCAGGCGGGA +TAAGCGATTATTTCAAACCACTGACCTCCATCACAGCAAGTTTACCCCCCGTCTGTTGGA +ACCATGATCGTAGATCACGGCGCGTGTCTTCCTAATTTCTGCCCTTCAGCAATTATATCG +GCAGTCTTCATGGTGATCGATACACAATCGCCGCTAGTAAGAAATAGGACGTAACACCAG +GTGCGGGAGTCCTAGTTAAGTGGAAAATTAGACAATTCGCTGAAATCTCTGAATGGATCA +TAGGAGACTTATATGACTGATACTAAACGTGCTACTAGGCGAACTATCCGTATGATAGTC +AAGGTTGGAGAGTTTCTAGCTACTAACGATTGGTTAGCGGGGAATAATGTACGTGCCAAC +TTAGTAGCCAGTCGGTTTACTAACATTGCACCTACAGCTTGATAATCATATTCGATAGCA +CGGTTTTGTTGTTGTCGAAAAACTCTGATGAGACGGCTACCATTATCAGTCACTGCCAAT +CGTAGGGTTGAATGCGTAACATGGTTAATAGTGTGATCTCGTCGAATATGTCTACCCGTG +TTACCGTTAACTTCTACAGTACCTGGTCGTCATCGGGTATAGGATACTAACGATTTAGAG +TGGGCAATGAGTAGGACGCTCAAAAGCTCATCCTGCGGCAACAGGGCATGATTAGAACTA +GGGCCAATGGACTATCTTGCCTAAACATCCTAAGTATGTATTCGATCGCCACTGTTTTTA +CGCCTTCGCACGTCGCTCGATACATATATGTGGCCGAAGATCTGTGCAGCGAGTTGGGGT +TAACAAGTAGAAAGATGAACAGCTTCAATAGGCGTTTATGACAAGGACCTACGGGCTAAA +GCTATACTGGAATATGAAGAACAGGAGTAAACAAGGCCCGTGAGTTCTTGCCTCCCCGAT +AATCAACAGTCAGCCATGACGCGGTTGGAGAATGGAAAGGTCCGTCCCTCTTCAATCAGC +CTCAGAGGATACGAGTCTGGTGACCCGTATGAATATGACGCTTGATATTAGTCAGTTTCG +TGTAGATGCTAAAGCGTTATAGTCTCAGGATACAGACGAAGCCTCAACGTCTGGTCGTGG +TCTATCACTTGATGCTGAGGGGTATGCTTACGAAGCTGCTGCGGGTAAGGCGAAACCTGA +TACCGCCTTACGTCATTTTGAACGTAGTATTTATGAAACTATGTTCATAGTAGGTTGTGA +GAAAACACGAGTATATTTAACCCCCCGTGGAGGCTTCAAGAATGGTCGTCACTTTCTGTT +CGGTTTTTAGCCATATCAACTACAACGCGCGCACACATTTCGCCGCCCGTACGGTTGGAG +ACGTAGGCTAGAAACATTTTATCGACGAAAATATCTGGGACTAATTTTATCCTATGTCGC +AGTAACAATGAAAAGTCACTACTGGTCGCTGTGTTGCGATCTGAACGTGCAATAGACTGG +TGCGCTAACAATGGTGATATGGAGATCATCCTGAACAATCAGATTGAAGCCGACGATGCT +TTGATGATCGACCATTACCGCATGACTACTGGGATCGTATTGAGTGCGGATTAGGAATTA +AACTTAAGTCCTTAAAAGTCATGCAGCATGGATGATGGTAAACCATGAGCCAAAGAGGTG +ATAAGACGTGGGCGTAACATCCCGCGTTGTGTGCAGGCGATGCATGGCCTGATTAGAAAT +GCTGTTATATAGTGCGACCGGGTGGTGATATGTTTGGTTGGATTAATCGTAAGAAGTGGT +TAACACCAAATCTTAAACCAATCGATTGGATTCTTTGGCCCACCTTGCCATAGTAAGTAT +AGTCCAACACAACAAAATGTCCTCTGTTAAGATCCGCTCCTCTCCTAGCCGGCGATGGAG +AAGGTCCATGCATTTAAAATGATCGGTAAAGGCACTCAGTTCGTCTTAACACAAATGGTC +AAACGACCGGCTCGTAAACGCAGAGTTGATAATAAGCCGTTGGCACTGTGGCAGGGCCTC +TGTCCTATGCTATACTCCTATGTTCTGGAGCCTCATGCCGACTCATAGCTAGGCGTACTA +TTTGCATACGAGGTCTAACGGTTCTGTATTGACGCTGTAGCCTACAAGGATGTGTGATAC +TGCTGATCACGTTAAAGGTATTATACAGATCAATGATAAAGTGTGCGGTGAGGCAGGTGC +TTACGAAGCCCTAGATCCTCTCAAGGATATACATGAAGTTGTGAAATTCGTGATTGAAGC +TTCCAAGAAGATTGATGAAAATATTATTCCTGAAGCTGAAGCTATGTGGTTATTGCGTAA +TTCACAAGATAACTCATTAAAATTCTTTATGGAACATGACCTAACTAATAGTAACTTAAA +TTTCTTAAACGAATGCTACCATGACCGTAAATGGAAAATGGAAGCTGATGATTATGAGGG +TGACCTAAATGAAATATAATATTCCTGAAGCTGTACAGCACGTTATTGATCAACTTAAAT +TGGTTGGTATTGAAGCTACGTTGGTAGGTGGTGCGTTACGTGCTGCTTAGTAACTTAAAT +TTCTTAAACGAATGCTACCATGACCGTAAATGGAAAATGGAAGCTGATGATTATGAGGGT +GACCTAAATGAAATATAATATTCCTGAAGCTGTACAGCACGTTATTGATCAACTTAAATT +GGTTGGTATTGAAGCTACGTTGGTAGGTGGTGCGTTACGTGCTGCTGCTCTTAGTGGTAC +ATCCAATGATTATGATTGAGTTATAGTTGGTGAACGTGAGGACTTCTGCCACAATTGAGA +AGGTGCCTCCTAATCCCCATTAAAACCTTTCCGTGTCCCACGATTACGAAATCTCAGAGA +TAACATCGCGTTGATACGGAGCTTTTTTTGGACTCTTATCTGATAAGGTGCTCGAGCACT +AACGTTTCGGTAACCAATACAATGACAAATATTATAACAACGAGAGTTATGTAGCAGATT +TGCGTAAAGCTGATGTGAGTATCATCATGTTTGATGCGTGCGAAGTAGCTGACTGGTATA +CTTTGATTAAAGTGTATGATTTAAATATCAACGAATGGTAAATCAACGAAGCCGCTGAGC +TTGCGACTGATTACTATGACCCTGAAACTAAGCTTGTAACTATTAGCCCATTCCGTGGTG +GTCTAGGTAATGCTGAACGCCTTACCCAACGCATTGAACTCTTCCGTACTATGCTTCCCG +ATCTCGATTGGTCAGAAATTGCGCAGCGGCGTAAGGTCAACGATTGCCTTGGCACGGGGA +TCGTAAGTTAAGACTAAACCTTTACAACGTATCCCACTTAATCAGTCACTAGTTATCACA +ATGTCCATCCTAGCCAATTGATTTTTAACAAACTGTAGGGTATAGAATGATGGCGTTTTT +CCAGATAAAAACCATGGCGGACCAGCCGGCTTCGAGTTTTCTCCTTAGCGAAAGAAAAAA +TAAGGCTGAAAGGATGCAGTAACCTGAATGGTCTCGTGGGTAACTACAGAGGATGGTGCA +GTCGGACCTTAGCGCCGAGTTACTAAACAAGGCAGTAAATGTCCTATCTGCTGACGTATA +ATTAACACTAAGGATGCAGGTCGATCTTGCCCCACGTAGTATCGGGCCACGTGGTCTAGC +TGAAGCGGTCTCGACACTCGACAGGACAGCTGCAGTGCTGGTCGGGTTCCCCGGCGATTG +TCCGTAAGATCGTCGTGTGCGAGGCGCACCTGCCAATCGGCATGGTACAGACTGCGTAGC +CGATCACGTTCATAAGACAGGTGGGATGCGTGGTGTACCTCATCGTTCGTGTAAAGTTGC +TGAGGGTAAGGTGGCCAATGCAGCAGAGTCGTGGGGTGCTAAGTCTATGGCGTATGAGGA +TATTGTCCCATTCGTTGAGGGTTTAGTTACATACTGGAAGAACGCTGAGAAGTATGGTAC +TGGTATGATGTACCCTGAGCACAAAACTGATGAGCAAAAGAAAGCTGCTGCGTCATTGAA +ACGTCTGCTAAGTCTATGGCGTATGAGGATATTGTCCCATTCGTTGAGGGTTTAGTTACA +TACTGGAAGAACGCTGAGAAGTATGGTACTGGTATGATGTACCCTGAGCACAAAACTGAT +GAGCAAAAGAAAGCTGCTGCGTCATTGAAACGTCGTAAAGCTTACGCTGCAAACAAAGCT +AAACAAAAGATAAAAGATAATGCATGCAAACGATAAGCTTACATGTGCCTATGTAGGGAA +GTACCAAGGCACATATCTTACAACATTTAAAACTTATACAGCCCTCAGTACCATGCACGA +TCATGGACGGGACTATGTAAATCTAGTTGATGATTCAGGTGCAGAACGCACATATACCGC +TAACCGACTAGTAGTAAAGGAGAACTCTCAATCTCAGAAACCCACGTTAATAAACCGAGA +CGCAGGCGCCCTACATGGCGTACTCCCTATCGATCGGCACTGGTAGACCTCGTGCGCAAA +GGGGTAACCTATCCGCTAAGATTACTGCAAATAATAAAAAGCGGACTGTACGGAGAGGGC +CAGAATAGACTCTGTAAGCGTGGACACAAAGTGCACTACGTCTACCCATGCAAGGTATGA +CTCCTCCTGATATCTCTCGTGAATTTAATTATGAAGTCTCGGATCGTACTAGCGGAGAGA +ACAGTCAGAAACTTGCACCTGAATTTGAGCGTAGTGTTGCACTTGCAGATCGTAAACCAA +TTATTTTCGTAATTGGTGATACACATTGTAAGCAAGGTATTGACCCCGATTCTATGCATT +GGATTGGGTCTTATATCGTATACAAGAAACGTGGCCTGATTATGCTTATCGGTGATCACC +ATGGTATGGCTTCATTATCAAGTTATGATAAGGGTCAGTTAAAGGCTGAGGGTCGTCGTG +TTGTAGAAGATATTGAGGCGGGTGATAAAGGTATCGAGATCATCGAATCTTATATTGCTA +AGGTCAAAGGTTATAAACCACGTAAGGTTGCGACGTTAGGTAATCATGAGCATCGTATTG +ATTCATTATCAAGTTATGATAAGGGTCAGTTAAAGGCTGAGGGTCGTCGTGTTGTAGAAG +ATATTGAGGCGGGTGATAAAGGTATCGAGATCATCGAATCTTATATTGCTAAGGTCAAAG +GTTATAAACCACGTAAGGTTGCGACGTTAGGTAATCATGAGCATCGTATTGATCGTTACA +TTAATGACAATTCTGAGCTTGAGGGTTTCATGGGTACAGATCAATTAGCCTTTGCTAAAC +ACGATTGGGAAGTCTTTCCGTTTTTATTGCGGAGCCCCCGCTGTCGATGCTCCCACATAG +GATGAGTCAGAGGAGAGCGTGGCTGGGAAGGTGTCAGGGTGAAGGACAGCTCTTTCGTGA +TTATATACGATTGAACACCCGCCACTAGCAGTGGTATTAATTTCGTTCACTTTGTACAGA +TCGGAATAACGGGTAAACCGCTAAGTGGTAGGATCTTAACTCGGCTGAAGAACGTGGGTC +ACTATTTCGTAAAAACACTAATAGCATGTAGAATCGAGACAGAGAGACTGATGACTCTTA +GCTTCAACTCCGTGTGCCATCTACAGACGGCATGCATTAAACGAGGAGCTGCAGGTGCTC +TAGTCGGCCAGGGCGAGTCAAGAGTTCAGTATTGTTGTTGGGAAACACTCGAGGGGCCAT +GAGGCGTTCGGTATTATATCAGCGTATATCGGTGGGGTTCTTAACCGATAATGTATAGGT +AGATAGCTGGTGCATAAACAAATACTTCATCATTGTACCCGCTATCTACCCCTAAGTGGC +CGGGTGCAGACTGGCGCTATCATTGGTGCATGTCATGAACGCATGTAAGACTACAAAGGG +GGACAAGATAATCATCACTTCCGAAGTTGTGTTATGCTATATTTGTTTGGCTGATACAGG +TAAGGACACAGCAGCATTATTGATTCAAAAGGTTTTTACGGATAAAGGTATAGCATACAA +CAATGAGTGCAGAACACACCAACCTCCAAGCGATGAGCGCTGCTTATGAGGACTAACCTA +GGTTGGCGTGGCAGCTTTCTCAGTACTATCGAGGTGGTGCGTAGGAGCTAGAGCGGCAAC +GTAGCGGTCCTTCCCCGACACTAGGATATGAGCGAACGTTGGATTAGGGCCAGAGGAAAC +ATCTCTTCTATACGTGGACGCATCCCAGCGAGCCTACCTTCCCGATTGATCGCTTTGCTA +AGCCTGTTAAAGATTCAGCTCGTGAGCTCGTCGGTGCTACATTCGATGATCGTGATGTTA +AGGATGAACCTGTTAGGGTAGCTTAAGATACCACGATTGAAACCTCATTTGAAGCGGTAC +GTAAGTGTCGACTTCCTGAAGATGAAACGGATCAAGAACCTGAGATGTTCGGCCCCTCTC +CATTTTTGAACACTTAGGATTTTGGAATTATCGATCGCGTCGTGAATCCCAACAATTGCT +CGGTACCGAGATTGGACGATCTGCGCGTAGTATCGTATGGCCTGATCGATTAACGAAGTG +TATAGCTAATCTGATCGTACCTGACGTACGGATTGATGGGCAGGTAGTTGATTTCAATGT +TCAAATCAGCCTTCATCCGGTAGGGGTCGGTAGTGTACATGCTTCTGAGATACTCGCAAT +AGAGATGCAGCCAGGTCTTAATGAATTTTATGACGCGATGATAACGAACACTGGTACTAT +TGATGAGCTTGAGTCTAAGCTCCGTACCTACATTGAAGTCGTTAAATGCCACATTCCGTA +TACGACACGCGCACCCCACGATAAGAGGCAAGTTTAATTGCAGGCTAACAACAGATCATG +GATGCTTTCAAACAAGGACGTAAGTATAAGAAGTTATTAAAGGTTGCTTAAATCCGGAGA +CCCGTCGAACTGCTCTATTCCTACCTTAGGGCGTCATCTAATACTACTATGATCTATTCC +CAAAGCCCGAGGTATGAGCTATCGCGGGGATCCGCGAGGTTATCACTGGCTGTGCTAACA +CTCACCCTAAAGTAATGCAAAGCTTCTTCCGTCAACTAGGACGGATTATGGAATCTGAAT +CTATATTGGTATGTGTTGAGCAAGAATCTTATGTTTATACAAATCGTACAGTAGCGTATC +TTCATTCAGCAGGTACTAAATCCACTACACACCGCTACCGCACGTTCCTAAAAGGCGCAC +AGAACATGGGTCTTAACTGGGAACAATGGTCTTTAGAGGAACGCATAGGTCCGGCCCGTT +TACTATTGACTTGCCTTTAAGAAATAGCTACCGGCCGAGAACGGTTTTATTTAAGTGGGT +AGCTAGCCGTGGTACTACAGATTCTATGTACTACCTTGTGCCAGGCGACACTTTAGAGAA +ACACTCTGGAGAAGTACAGAGTGCTGCTAAGGCTGTAGTTAAATATCCACCTACGTAAGT +CCCGCCACTGCATTGGACTGGACAATACGACGGGGGTTATATGACAGTGTGGTTTCGTTT +ATACTCTCCTATGGGTGTTATCCGTTTCATTAAAACTGTACATAAGAAATGAATTCTTGA +GAACTTAAACAGCGAGCAATCGCTCCCTGTACGTACTGCAATGAACAAAGCACAGTCTGT +ACCTTACCGTGTGAATCAGCGTGTATTGACGATTCTACGTACTGCTACGGCTATGCGTGT +GGGTATCCTTGGATTACCTAGTTTCGTTGAAACACCTAAAACTTAAACAGCGAGCAATCG +CTCCCTGTACGTACTGCAATGAACAAAGCACAGTCTGTACCTTACCGTGTGAATCAGCGT +GTATTGACGATTCTACGTACTGCTACGGCTATGCGTGTGGGTATCCTTGGATTACCTAGT +TTCGTTGAAACACCTAAACCTGAGGTCGCATTGCCGCAAGGTTGGAAAAGGGATACAACT +ACATAAGCCGAGCTTGAACAATTCCAATTTTGGGAAACTTAAATGCCTACTTACTACACT +AATGAGGTTAAACGTAAGGGTCGTCCCGTGGGGATTCTGTCTCGCATCAACGCACTTGTG +TAATATCGAGAGGAATCACGCTTATTCGTCCCGACAGTCATGGACCGGCGTGGTCGTTTA +TACTGCCGGTCTAACCCTAACCCGCAATCATATTATGCATTAAAAGGCTGCTTGGAGTTC +GCTGAGGGTAAAGTGTTAGGTAAAGATGGACAGCGTTGGTTAAAGGCGGATATCGCAAAC +CGTAGTGGTTTTGATAAACGCGACTTATTACCGCGCGATACAAAGGTAGCTTGGACAGAC +GAGAACCGGTCGCAATAATCCTGCGAAGGCCTACGTCGCAAATTTCGAACCCCTACACTA +AAATAACTATAAACGAGTCAGGAGATAAACTGCGGATAGTAAGGTATATAGAGAGTTACT +GACGTGTTTTATCTCCATGAATACCTCCCAGGGCTGGGGCCAGTTTATGTCATGTGGGTG +AAGCCTGGGGAATCTTACTCGAAACTCTCTTATTACTTTCGGGATTGAAGAATTTATAAG +TAACCGCCTTTATGCTGATCCCCCTGAACCTGACACAGAATTTCCATTATTGCAAGCTGC +TATCGCCTTACAAGAAGCACTCGCACTGCCTGATCCCGAACTTTATTTATGTCACGTACC +TGTCGCTGTGAATGCTACATCCCCAGGCCTACAGCACCTCTCTGCAGTTACTCGCGACGC +CGTAGGTAGTTATTACACAAACCTTGGAGATAACAAAGACAATAAAAAGTCTGACATCTA +CATGCGGGATGCTGAAGTTGCTAAGAGCATGATGCCCAGGCTAATTGACGATGTGACAGT +AGATTACCTTGGTTTTAAACCTCTCCGGGCTAATAGTTTCTGCTTCACGGCAGCATATAC +ATTTCAACACCAACTGCAGAACGAGGATACCGTGGGAAATTTCACTTATTGGCGCCTCCA +CAGGAGCTCAGAGGGTGGGCCAGTGGAACCCGCTCCGGCCAATAATAACAACCATTTCTG +GGTACGGACGATCCTGACTTCTGTGAAAAGTGAATGAGATCACACGTTCTAAGGCTAGGA +ATCCTGTAATGACTCATATGTACGGTGCAACGCTACTACGTTGCATTGATACAATTGGTT +TAGCCCCACCTGAATCAGGTGTTGAACCTACTAAGAACTATGCAGGTGAAGTTTTATATA +GTATTCTGGGATTTATTCATAGCTTTTCAGCGGCTTTCCCGCTTGTTATGCGTTGGAAAC +TGGAATAACTTCTTGAGGCGACGCTTCAGGTTGATTTACGACTCGGTGAAGCCCCGGCTC +ATCCTAGTTCTGTAACGGACCTCCAAGGTGGCTCCGCTTTCATGAAGGTGGAGGGGTCGC +CAATGGTCTGAACGGAAGAGCTTTGTCCCAATGTCCACCCTGCATCCACTGTGCGAATGT +GATTGCACTTGCTACACCTGTAGTGAAAGCTTTAGGTTAGGGTGTTGTAAAAACTGTACA +TGCATGTGTTAAGATGGTAAAGTTGTTACAGACTGTAGTATGTATACATAAAGAGCGTTT +TATGCGTTGGGGTACCCTTGCGGGTGTTCCTGTAGTTAACTGGGCAGAGCGTTCTTTCAC +CCAAACCCTTAACATCCGTTATATAGATGTCACCCCTGTAACTATCAAGGTAGGTACTAA +GTAATATCATACTCGTTCAGCAGCAAGCGGTATTGTCCCCCCCGATTTTTTCTTAATCAG +TTGAGCCGCTGTAGGCATAATGTGGGTGTCAGTGAGTGACAGTGCATCTACGGCAGGGGT +CGCGCGAGACCCACGCCCAAATGTTGGTTATGCTCGATTTCGCCAGTAGAGGAACTTTGT +ACATTGTATGGACGGTTCACATCTGTGCTGATCTATTAACGAGTGCAATGGGCATGTTCT +CCCTATCTACGACTTATTGATGGTATTATAGTTACCGTTGTGCCATTTGTAATCCGCAAG +TAGTAGCTGTGCTGAAATGAATTGTGGATTGTACGGTTTATCGTTACCCATCCTAGTGAA +GTAGGTGCTATGCAAGAAGCTTTACGTAGGACATTTGCGGATATGTATAAAGCTTATGAT +ATTAACGACTTCTTAACTTTCAATGAAGTCGATACAGAAGAATACGAAGCACCACCTCAA +GGTAATCTTGACTTGGACTCTGTACTCACAGCTCAATTTGATATTAACGACTTCTTAACT +TTCAATGAAGTCGATACAGAAGAATACGAAGCACCACCTCAAGGTAATCTTGACTTGGAC +TCTGTACTCACAGCTCAATTTATGTTTTGTTAATCAAAGCTTCCTTCCTCACGACCATGC +CCGTGGTGCATTGCTTATACGTCGAGTTCAACCGACGGCCTACTCATACTTAGCTCATTC +CTCTATGATCAACTCTAATCTAGGAGATTACTACTATGTTATTCACTATTGTCTCTCTTG +ATTTTCTTTCTTACACGTCGGTTAGATTATATGCTTTGGAATTGGAAAATGAGTTCATGG +GCTATAGTGACTTCCTCAAAGCTTGGGTAGGTTGCTTCTGTAAAGCAGGGCGGGGCCATC +TAAACAGCCTAATCGCTTGACCTGGGCCAGTCATAATTACAGGTCGCCCGGACAGTTCTA +AAGCCGAGCTTGATCAAGAATTTAAACTGTGTGGTTATGAGTTGGTATAAGCGTTCGAAG +CGTCCCTACCGCCTATCATGACACTAGGTACTATTGGATTGGTCGTGTTCTGACCTATCC +TACTAGTCGTAGTTAATATTCTAACGGCACTTGTCACAGTACACAATCGTAAGTAATCAG +AAGCCCTCGAGCCCAACCGCTTGAGGGCTTTTTTTTTTGTTTATCACTATCTCAACGAGT +TACTCAATGTTACACATATTGAATAACGTCTGTTCAATAGTGCGACGTAATTATATGGTT +TTAAATAAGCAAATAGAAGATAGACGTATAAAATAGGCAAGGAGCTTTAATCGTATGAAT +ATACCGAAGTTTACAGATGATCTGGTTGAGTGTTTAAAAAGAGTTTTTTCAGAGAATACA +GGTATGACCTTAGTCCCTAATGAGTTGAATAGACGATTAGGCAGTAGACATGTTATCCAT +CATAATGTTCAGTGCATTGAGAATCCCGAATTTCCACATACTACCACCACGGAAAGCATT +TTTAACGGATTTCTTCAGGAATGAACCTAAACCCATAACTACCTCCTAAGATGTGATCTT +ACGTTTACTGCTAAGGCTTCTAAGCAATAACGTGCAACGCAACTGGTGATAAAGCTCGAA +TAACACTGCCCGCGCGTGCGAGGAAAACCCGGACAAAGGACCATTACTTAGGTTGGAAGA +GTCAAGTGAGCAAAGTGCCCGTGTTCCATGGAAGCACTTGAAGACTGGGTGGAAGGCGGA +CCCGAGTTGTTGATGCCCCCGGTGACGATCAGGTGCATAGTGTGTTAGGTCTTGATGCAA +TCTAAGACTTGGCAGGCGCACACGAAGCACAAATGCAGCAACAACAGGAAACTAGTAAAT +TGGATGCTTCAGCGGAGTCACAGAACGTGGCGCGGTCTGATGGTACGCCAGACACAGGGT +TTACAGGTACGCATTCACGTCGCAAGGAGAAACAATCAGGTGCTTAGTAACAGGCACTAG +GTCTTCAGCTGCAGGGGGGTACTATAGTTAAGTATCCTCAGATCACTTATTCACTCAAGG +CATTGGAAAGTCAGTATCAGGTTACTGCACTACTTACACGAATTGAAGACTATGCTTATT +GGACTAACCCTAGTGTGTTTCCAAAAGGTGATAAAGATCTTTCGAATCCAGGTTAGCGTT +GACTTAAAACAACAGCACCTGGCGGCGGTGTGAGGAATCTAGGTCATTTTGTTTCAGGTA +ATCCATCTTACCGGCATCGCGGATATAGTCCAGATTTTAGTGAACTGTTTTCCTGTTTGA +GCAAAGGAATTTAGACAGTATTATCGAATATGAAAACCAAGCATGTGAACAATTGTACAT +GAATGCATCTTATGCTCTACTTGTACAAGCAATACGATTAATGGTTATTACTGGCGAGTG +TTTACTGTATCGTCATAATAGCGCACTACGTGTATTCACATTAAAGGATTACGTCCTTAA +ACGTTACAACGTCGGTGAGGTTATGGATATTGTTAGCTGTGAGCATACGTACCGTGAGGA +ACTTCCATCTGATCAACGTGTCAAACTTCAGATTTAGAGTCGACGCGCACAGACGGACCT +CCATGGACCTGTGCAATTGCGGATGGCCCTCTACGCTGGGCCAGAGCCGGAACATACTGT +TAGTCAACTTTTTTCTACCGTGACAATGCTTCCTAGGCCGTGTTGTATTGTGCAACTGAA +ACCAACGCTTTGAGGTTGTTGCTCACGCGTAACGTTTAACCGCCGGATATAATACAAAGT +CTCATACCCGTGTAAAAGTCTATACCCGTGTTGAGCGCAACGAGGTTTATGGTAGTGAGT +CTCGGCAAGTAACACACGAGATTAATGATATCGACCTTTGTACTTATACTGTGTATCGTG +ATAAGCTATTCCCACTCGTCCCTGACGCTTGCAATCTCGTTGATGGTGATTCTTATGTTC +GTCGCTATGTAGAGGATTATGCTGCTTAGATTTGGCTCATACCACAGCCAATCGGGATAT +GACAATCGGCATGACACGATGTGGGCTTATCTCACAACCGGTGTTCCTGCCTGCATTCCG +CCTCACTTTGCTTAGTTATCAGATATGTCTCGTGAGCTTACGTCTTACACCATGTCTCAT +ATACTGAAAACTCGACCACAACCCAGGAGTCTTGAGTCCCCGTAGGTAAGTTTCACGCCA +AGTACACTGTCTCAGATACGCGGTTGCCATTGATAGGCTACTATGCTGTGAGAAGGAGCC +TTTACGTCTTCTACATATAGTTTGCCCTCAAGGGGCTGTGGATGTAGAATCTGCTGTGAA +TGGCCCTAATGGTGAGTTTATGCAAGGTGACCCTAGTACGATCAAGCCTTATGAGGCAGG +TTCGTACCACAAGATTGCTGAAATTCGCAAAGCTCTTGAGGCAATTGAACAACGTTTCAA +TATCGTTTTTATGTATACAGCTAATATGCGTGAAGGTGAACGTGTCACCGCCTATGAAAT +TCGTCAGAATTCTGAGGAAGTTGAGCAGGTCTTGGGTGGTGTGTGCTTACAACTTTCTCA +AAGTGTGCTTCTACCATTAGCGTATTTGTTACTGTACGAAGTAAATCCAACCATCCTGGA +GGCTATTGACAAGCAATTACTAGACCTTGGTTCTCAGATGAACGAGATAATGCCTGAATA +CCAGTTAAGATATTTAGTTTAATCTCCTGAGAGTTCGGAGTTGAACGCTATTATCCCTAC +AATTGCACAGCTTGGGAAAGGTTTTAATATTGGTGCTATCGCTGCTAAAGCCATTGAATG +TTATAACGTGAACATCACAGATATTGCATACACTGAGGCATAGGTACAGGCTAAGGCTCA +TGCTGAACCAGAATCTATGGCTCGACAGCAGGCACAGATGAGTCAAGGCATGCCACAACA +ACTGGCAGTGCAAGGGTCTGCTATCCACGCACTTCAACAAGTCCAACTATTTTAATAGGG +ATTTAAAATGACTCAGGAAGTAATTTCATCTGAAGTAACCTCTGCTGCACCTCCACCTGC +TGCTGTACAACCAGTGGTAGAATCTGCTGTAAAACCCGGCAGGTTACGGTCCTAGTTTTT +TTCTGTTGCAATGGCAGAGACGGACTTCTGGTACGTCCTCCGACGTAAAAGGTGCAATAA +GAGCAACTAACCGTCGCTCATCCAGGGAGCGATTATCCCTCTACTTGAGCGACCCCAGGT +CTATTTCCGGGTGTTGAATCCACCAGCGACTTTATCAACGTTTAGCACTTTTTGCACGGT +TGTAGGCGACAGTACACTAACGGTGTCTTTACCCAAGGACAGTCCTTCTGGGTCCGATTC +CGAGCGGAAATGGGGTGTGAGGTCACCGTTAGGCACGCAAGAATAGTGCCAGACAAGGCG +GGGTATAAGAGAAGTAGTTGTATCTCAGTAGGTTCCAATCTTCATAGGTTAATCTGAACT +TGAAACTTCTAGTAATATCTTCTCAAGTGGCGCGGGTATTGACGCTGTATGTTTTGGAGA +TGCAATTGAAAATGGAATCAAATACAATTACCCTACTATAATTAATGTGCATGCACTTAC +CGCAGGTCCTCAACCAGAGCCCGCTGCTCAAGCTAGAGCATTGGCTCAAGCTGCATAACA +GAAGTAGGAATGAGATCTTGCGAAGGGCGTTGTAAGTACCTCACTACTCAAACTCGCTCT +TAGTAACGGCAGGCGCGCAAAAGCTTTAGACCGAGATACGTGTCATGTTCAAGTCGGGGG +CTTACCATGGATTTGGTCCCTGAAACTTATAGTGGTTGAGTCTTCAATGCATTGACAGCG +GCCAGCCCATACATTCCTGGAACAATCTATGCACTTATTCGTGCAAGTTGACTTTAGGTC +CCTAACACAGGCTGCAATTCAACCAACAAGCCAACGTTATTCTCTTACTACTGGCTCCCC +TAGTGCTTTTCCGGGGCCACATTCAGCGGTACCTTCTGAATCGCCACGTTGTGACCACAC +GTGCCTCACAAGAATCTATTGCGACGGCTGAACGTCTAGCAGGTGGCTCTAAACAATGGA +AAAATATCAGTTCTACATTTTATACTAGAGCACCTGCTCATTTGAAAGCAGTAGTGTCAC +GGATTTTAGATGCAGGTGCCGAACAGGATGCTGTTCAGTTCGTTTTTGACACAGGAAATG +GAGTAGGTCTAGTGAACAGTGGAAATGATTCGATGCAAGGCGGTGTCGGCGGCAATGGTG +CCGGATCTTTAGGTATCTCAAAAACAGATTATTTTGCACAATAAGTAAGCCTAGAACATC +AAGCGGGGTGTCGGAGGTCTCAGCCTCCAGCATAACTGTTCATTTGAGCAGGGCGAGTAC +GCACATAGGTTAACTTCACTTCGTAATGCACGTAGACTAGGTGGTAACAACGGTCCTTAA +TATTAGGAGAATTTAATCATGGCTCAAGCTAGTATTTAGCACCCGAATACAACTTGCTTA +CATTGGAGTTGTGCAAACTCAGATAAAGACGATCACTTAGCATTATCTACAGGCATTGTA +GATTCACGATTCCAATACTCTCAGATCCTCCACGGTTTCTCTGTTCAGCGTTCTACTAAA +TCAGGTTCCAATACTATCCGTCTCGCCGGTTTGAACAGTACATAAGTTAAGGGTCGTAAA +TCGGGTGAGGGAATCCAGTCTCAGCGGGAGACTTCAGGTAAAATGAAAATCACAGCCGAT +TGTGTGATGTACATTCGTGACCCGACCACCCCTATCGTTCGATGGTTGTTGGGCCTCTAG +TACCAATAGCGGCCCCGTTCTAGCAATAGGATGGACGATTGGACTGCACCTGACTTGTTG +ACCGATATTGGTCGTGACAACGGTACTGCGTTTGGTCTGGCGTACGATGAGGTGCACTTA +ATCTGTCTAATCAAAGTCCGTAATTGGGTGGCATCTGCACACTTAGCAGTGTCGTGTAAA +GATGGTACGCATATAGGGGTTGCCTTGACAGCTGCGACTATTACTGCCGATCTTGAAGCT +AACGTCTCAGCTAAACAGGCACGCGTTAGGCTACGCAGCATGGGTGCGCTTCGCATGAAC +CTATTAGGGAAGGACTTTTCGATTTTCTCCAGCACCATAGACGCAGCATCTGAAATGCTC +ACCTATAACATCTTACCTAGCGGGAGAACGGTCTTCAGATCTTCCAGTAGAGTGAAAATC +GTCAGGCTTACGCTGATGCTCTAGCATATGCTTACTGTGTGCTTGCAGAGGTATTTTCTA +ACCCTCAAGTACCTTTAATGGACATGGTCACTGGGGTAACTCCGAAAGTGTTTGGTTAAC +TTTTACATCACCCGACATTGATCTACAGAGGCTACGGAGCGTTGGTCTCCGTAGACAAGA +TATGGTTAGTACCCACAGTCTTAGGAAACGCAGTCATCTGTACGATAGGTAGACCGTTAA +CCTCAACGATACGACGACCTGCGAAGTCACCGTTAGAAGGTTACGCGTTTGATGCGTCTG +CGCATGATGTGAAAGGTGTGATGAGCATTTTCTCTAAAACGCTGTCTCTAGTCACTGTAA +CTACACAGGCATTCGTTTGATATATAATTGTCAATTCGGCTAGCATCCATGAAGTTTCTG +ACTTTTGAAAAGATAAAACTGAGATGTGAAACGTGTTGGACTGGTTCACTATGTTAACCG +TTGGTAGTCGTCGTGCTGATACTGTTGGTGTTGCGATGATCACTAGTACACCTCAACCAT +AACATGGAGGGCTCCGGCTCTCCATTCAATTTTAGGAGTAAAATAACATGGCTAACCTAG +GCGAGTCAATTGTATCCAATGCTATCTCAGGTAAACCTTTAACTTTATCAGATAAAGCTT +GTTCTTTGGTAGGACGAGCAAGTGATAGGGTCGCTGCGTTAGAGGTTCAGGTTCAAGCTT +TGCTAACTTTTGCAGGTGCACCAGCCTCGTGACTGATGGCTTCAAAAGCATAGCCCACTG +ACGTGCGACTGCTGCGTCAACCGTGTAGCGAACTTTTGGAGAGAACAAGTTAAAGTCTAC +CCAGCCAGGCCGTACCTACTGGGTCTATTGTCACCCAGATTTTAAGAAAATTGTGTAGAG +CTAACTCAATGCTTTCTCTATGTCATATAGACTGACTGTTCGTGTACACAAGGAGATGGG +TATAGCCTCTACACCAGTAGAAGCACCTGTAGCAAAACTTGTTGCTAAGGCTAAGACGGG +AGAGTCATCAAGGCGTTAATCAAAACGATTAATGCTGCTGATCTTCGAGGTACTAATGAG +GTGAGTATTGACTTCACCTCTATACTAACCACTATCAGTGGCGTGAAAACAGATACGACT +GTTAGACAGGCAGGCGTTAACGCTGTTTTTACGTTGCTTGGATTATATCTTAAAGTAAAC +CCTTTCGAGTTTACGGTGTTGGTGTAGTGTTAGTTTTGATAACAGCTACGTCAGCCTTTC +CCAAGTGGACGTATTGTGATGATTAGCCAGACCGCCGTACGGGGCAGCAACGCTCCTCGT +CTGGCCTCGAGTCCACGGAACGCAGTGCACTCTTATCATAGCCGGGCCCTGCAAGTCAGG +TCATCCCAGCATCAGAACGGGTGGTGTTGCCGAGCTGTAGCACATCTGCCACCCGGTGAA +ACCCGTCTTTCATTCTAAAAGAAGCTAACCTGCTACGTGGTACAGACGTTTAATTCTTAG +AATCTCTTTGGCCACTACGACTAGCTTTATCTTAAAGGGAATCAACCATCGGAGGTATGA +TATGGATATGTTATAAGCTATACATACTGGATTACCTTATATTGGTGAAAACGTAGGTAC +ACGTATTGAGGGTGCAAAGCATCCATCTGAAGATTTAATCAAAGCTCCTATCAAGCGCCG +GTAATTAAAATTGTTGACTACTGGTGGGAGGTTTAATGACCTACATCTAAAGTTACTCCC +TAACCAACAAGGATTCATTGATGTGCCTGTAGACACGTTAGAAGCGTATTGTCACAATAT +CAGTGTTACGTTAGATGGTGAGCTCTCAGGCCGTGAACCTTGGGAACCCCATAAGTGGAA +TGAAGAGACGTGGCCTACTTACCGGTTAAATAGACATCGGTCGAGTTTCTTCAATCCTGA +TGAGGGTTCTCGACATTTCTCTAAACCGTTAGAAGTTAAGATTGTACGTAATGTACCTTT +TGAGAAGTTACCTGAAACTGCTGCATTATATGTAACATATAAAGCTGCTATTGAGGTATA +TACTGCTGATCTTGGTGCTGAGGATGTACTTCAGATTCTAAACAATTATGCAAACGATAA +CTTGATTTCTTTTAAGGAACTCAATTTACGTCAACGGAAGTATAACAGTAAACGGACGGC +GCGACAGTTCAGTTCGTGTAATCGGTTACGACACCGCTAGGAGGTGAGCAATGGCAGTAC +GTGAGGGTACGTATAAATACCTTTGACAAGGGGTATCGCAACAGACCTCACAAGAACGTA +CAGATGGACAATTAGGTTCAGAGCTTAACATGTTTTCTGACCCTGTGACTGCATCAGGTC +GTCGTTGTGGTACTAAATTGACCATCGAACCCTCACGAGAGAAGATCTGTCACGGGTACA +AGAGCCTCTCGGATGTGATCAGCACTAGCTTTGGCCCCTTCGCATGAAATGAAATCATTA +CACGCTGTATTAGAAGACGTTGACATGGGGAGTAATATTCGCATGACCGAGATTCGAGGT +GCTATTTATACTACCATTACTGGTACAGCTAATGGTTCCTTAAGAGTATACACTTTTTAT +GGTCGACTAAAGTCAACTATTTAAAATGATTCTTTTAAAGCTCGTAGTGAATCTAGTGTT +CGAACTACGGTACCTAAGGGTTATTTCTTCATTCTAAGTACTGAGCTAATCCCTATCGAA +CAGCCCGAAGCTTAAGCGGGGAAGAACCCTCATCACTACAGGGACTCCAGCACTGTATCT +ACAGCGTTTAGTAAAGTATTTACTATATCTGTAACTCACCCCTCTATTGGTACTATAACT +AAGACGGTTACTGCATCTAGCGACAATGCTGCTGAGGCAAGTCAGGAAAATATCGCTCGT +GGTCTTGCGGATTTATTCTCTCAAGATACTACTTTTGCAGCGGTGTTTAATGTACACCGT +ACAGGTATAACTGTAGCGTTTGAGGTAAAGGATAAGACGCAAACTGGTCCTACGGTTGTT +GACTCTACTACTGGTGCTACTTATGTTGTTATGTCAGGTGCATCCCGTGTTGTGAATAAA +GCCGAGTCACTGGGTACACTACCATCGGTACTTGATGGTTATATGATGGCCGTAGGTTAC +GAAGGTAACTCCGCATACAACAAATTCGATCATGGGGGATAACGTTGGGCTTAGACTGGA +GTTCATGAACCTGACTATAAACTTATCACTAAGCCTATGTCTTGGTATCTTGATGTTGCT +GGTACTGTGAAGTCATTGATCTCTAACTTACACGGAGATGCGGTACTTAAGGCTGCGCGG +CTATGCGGGGGCGTCCGATTTAAATACGCAACCCAGAAAGTTAGTGCGATCTGGGGATCG +AAGCCCAGTCGCGTCCATCGCCTGTACCGTTAGATTTTAAAGCTCGTGAGGCAGGAGATG +AAGACAATAACACTGACCCTATATTCATTGGGTACGGTTTGACAGGTATTGGTAGCTACC +AATCCCGTCTAGTATTATTGAGTGGTTCATACGTCAATATGAGTCAGACGCGTTACTTCA +ACCAATTCATGCGTACTACGGTTACTGAACTGTTAGATGATGATGCTATTGAGGTTTCTA +GTCATTGGGTACGGTTTGACAGGTATTGGTAGCTACCAATCCCGTCTAGTATTATTGAGT +GGTTCATACGTCAATATGAGTCAGACGCGTTACTTCAACCAATTCATGCGTACTACGGTT +ACTGAACTGTTAGATGATGATGCTATTGAGGTTTCTAGTTCTGCAATTAGATCTGCACAG +TTCGAATACCGTCTGCCTTCTGATAAGGACTTGGTGATAACTGCACAGACACAGCAAGCA +GTAATCAGCGGGAATGCGGAGCCGTAAACTTACGTTATCTAAGGGCAGCGACGATTGTAT +GGAGCTTGCAGATGTCGGGGTCCAACCCCCCAACTAGTACTAAGGGCACGAGTACTGTTT +GTAGGGAAGGCCAGGCCACTGTTGGCTGCTTAATAAGGGTCATAGTGGTCATCTTCCTGA +AGAAAACAACAGGGAGAGTAATTAGCTGGTGCCCCTGCTGAGTCGACTTTGCTCACACCT +AAATCTGCGGTGATCCATTCGAGTACAAAGGTGGATCTGTCACTAGCTGCTGAAGCCCAA +GCTGTAGCTGGAAGTTTGTATTACACGTATCACCATGGGGCAGATTATTATCAAGTAGGA +GAGTTCATTCCCAACACATATACCTACGCACAGTATTACAATCAGAACTTAACTGATCAT +GTACCACTGTATGCTACTGGTGTTTGTACATGTATGAGCGTAGCGGCCTAGAAGCGCGGG +CTCGCTCATTCCAAGGACACATATGATGAGCACCTAAGCACGCTAACTTCTTCGGGTGTT +AGTAGAATCATGGGAGACCTCACCGTTGCTGAGGATGCTGCATCTACTACTAACAACATG +GTAGTGATGAGTTCAGACTCCCGTGATGTATTGGTTAATCAGTTCTTATGGGTTGGTGAA +GATCGCCCTCTGATGAGCTTCCATAAATGGGATGAGTTCAGACTCCCGTGATGTATTGGT +TAATCAGTTCTTATGGGTTGGTGAAGATCGCCCTCTGATGAGCTTCCATAAATGGGAGTA +CCCATTACCTGTTGTGTACGCTCAGTTCATTCAAGATGAGTGACCAGTACGGAAATACTT +GATCGTGTTCGTGGATCATGGGGAGGGTAACTTAGTCGTCGTTACGCAGAACGAATATTT +AATCCTATAAGATGATAAACGTGCCATCCATTATTAGACTGGCCCTAAAACTACCTAATC +AGGCTGGACCCACAGTAATCCGTCAACTGCAATTCCGGACGTTAACGCGTTCATGTGCGC +TTATCATTCACCTATCCCATTCCTAGACTCGTTTGGTTATGTGACCATTAACCCACCATT +AATGGGAAGTTTACGGCATTGCGGAGAACGGTGTTGGTGTCTTGCCAGAGTATTTACTTG +AGATGAAAACTGGTCATATGGAGTTAGCTGCATCTATATATAGTAACCATTATCTGCGCC +ACCAAGAGATTGAGTTCTCGTGTGATGATGCGGCTAATGTTACATGTCCTTATGGTGGCA +CAACTATTTTTTTAACCATTAGCGATTAAACACTGCTGCCTGTTATCTATGTTGGTGGAC +GCTTCACAAGTGAGTCTACTTTGACACCTCCTTTTATCAATGACGAGAACGGCAAGGACG +TGGCAGGGACTAAGAGTAAAGCAGTATCAAGCTCATTGTAGTATGAGTCACCCATAGTAT +CCTTTACGGACACTTTAAACGTACCTGTGTTCTTAAATTCCATGTCTAGGCGTACTACCG +TAACGCGGTCAGGGGCTGACTCAGGACATAGATGGGTTAATAGTAGCGGTCGAACTGGCA +GTCAGTGGACAGTATGGCTCATTCCTTTCTAGCGCTGCCGGAACAGAACTGTGCGTGTTT +GGGGTACGGAACGGTCTCGGTCAGGTATGTAGCTCCGGTAGAAGCGCTGCCCCTCTGCTA +TTGAGGGTAACGGTGCGTCCGCTTTTGATCTTAATAATCTTTGGATCTATTCCATGTCGT +ACTCGTTTCATGTCTACACAGTATTCTGTAGTGACTGTAGGTACAACAGATTGAAAACCT +ACTAACTGAAGCCATTTCTTAACGTTGAATGACAAGCATCGTAGGATTCAATATGGCAGG +CAATATTCAGCCAGGTTTATCTACAGGTATGCATGGCACACAGGGGATGGGTGGTCAAGT +TGGTGGTATGAGGGGTGCGGTCATCGATGATATCGGTGTCTTAGCTCTAGGTTATAATAC +ACCTAAGTACGAGAAGATTGCCCTTGAGAAATATAATACCGAGGTATTTGAAAATGCTAT +CTTGTGGAAGTTGTTTCATGCCGGGACCCAGCTTGAATGCTTGTATAATACACATTCAGC +ACATGAACCACAAACAAAGCGGGGGCGGTAAGACTCCCCGCGCACGGCGAAGTCGCTGCT +CTATGTCGGTCTGTCCTTATTCGATATGCGTCGTGTACAGATTGTACAGAACATGCGCAC +AGCACAGGCACTCGGAGCTCATCGAGATCAACAGACAGTTACTATAAGCTCATATTACGC +CAAATATGGCGCTCATGATGTGGTGGGAGCTTCTGCGGATGTTCGAAAGAGTACATTAGC +CTCTCATATAGCTCAGGCTATTGCACAAACATGGTCTAACGATGAAACAGGTATTGTTAA +CTATAATAGCTTTGTTACGTAAACACGGTATGTGGGATATGTTCATGGAACGTATGAACT +CACTACTGTTTAACGCTATTGCTAGTTACCACGGCTTATATGTGGATATGGAAGTAGCTA +AGCGTAACCAACAAGCTCAGGAAATTGAAATTGAAAATATTAAAGCGTCCATCTTGGATA +TGTTACCTGCTGATCTTCCTGACGACTTTGAGTTCTCATTCACATCCGCATACCACTTGT +CGGCATTCTTGTTCGGAGGTACGATTCACATTGGTGTTGCGGGTACAGTGAAGTCTGAAT +CAGCAGCCTTGCGTCGAACCAAAGGTGTTCAGCGTACTATGGGCTTAGGCGCGCTCACTA +ACTCGGATATACATATGTACAAGCAATACGGTGGTAGTTTCAATAACGCAATGGGTAACT +TGTGGGGTGGTGGTTCTACAACAACTCAAGGCGTGTCAGGTGGTGGCTTAGGCGGTCTAT +CTGATTTTGGTTCGTTTGGTAAAGGTGGCTCAGCCAGTGGTTTAACTGGTGGTAGTTCAT +TAGCTTAATATAGGAGTTTATACATGCCTACTATGGTTCAACAACCCGACTTAATTACAC +CCGTACTCTCTCGCAAAGGAAACGTTTAGTTTTAGACGGAAGCAACGTACCGGCACAAGC +AAAAGGATAGATAGCGGAAACAGTCCACCTAGCACATATACCTTGCAGCTAAGCGCACAG +CGGACTCTCCTCTTAGAAAACAACGGCCGACATAACGTACACCGATCTGTCGTGACGGCC +CAACAGTTCATTACGAGCTCCTTAAGCGCAAGGCGCCCGTACATTTTATGCCTGACCGCC +CCGGATTCCCCCTCGGCAGCGGACTTCAAGCGAGTGATCGTCCTGCAGAACATAGTGGGC +TTGGCTCATTCCTTATAGAATTACTCCCGCAAGTTAGAGCGGGATTAGACGAGCATCAGA +AAGAAAACCGAGACCATTGTGTTGCGTTAGGTCGTAATGATTAGTTAGACGGTGTACAAT +GCGGTCTGTGTATTATTGACTCCCGCAACTATAGCCAAGGCAAAGAGTTCCAAAAGGTTA +CATCTACAAAGGCTGAACACCAACAGTAATTCCGTGATACTGTAACTCAAGTGGCTCGTG +ATGCTAAGTCAGCTGAGGAAATCTTCGATGACGTATAAGTTACTGATTAAGCAGGATCAT +ACTCCTGCACAGCTTACCGAAATAACAATTTCACTTATACTGGTGAGTTCTTTGCCCTGA +CCTATCCTGAACCCTCAACTGGATTGGTGGTCACACCTTAGTCCGCCTCTGGCCCGTCGT +TGAGCTTTTACTTTTAATACGAGTGTCTGATTACTTGAGGCTGATGTACAGAATGCATTT +GCTGCTAAGGTCGCTAGTACCGACAGCCACGCGATTAGAGATCTGGCACTGTCTGAGTCG +CCTAATGTGTTAGGGCAGCCCTAGCGGGGATTGCGGCCGTAGATCAGTCCTCTGGTGCCT +ACAATACACCTATTTTAAGCTGCTCTTTCCTAACCCAGCCTGTGGACTAGGGAGCCCAAT +ATGGGAATTCACCATAATGAGGCTATGCAAGCTGCACAGTCTGAAGTACAGACTATGTTC +ACGTATGGGGCGGGTCAGAACGACCCGTCTAGTCCTGAAGCTGCTGCAGTCGTCACAGTG +ACAACAAGGGCGAAGTGGGAAATTGATATTTATTCGTTTTTAGCCAATTCTACTCTAATA +GATCGAAAGACAAAGCTCACGTCACGGCAAAACCTCGGGTAAACATTTAGAATAATACAT +TAGTTGTAGCTGTTCAGGGTGGTATCGTGAGTATGTCCACTGTTGTCGATTTACCAAGTA +ATACTAACGGTATCCGTTCAAAGATTCTTGAGAGCAACGGTAAAACACGGATTGGGTGAC +GTTCGTTCGATCTTATACTATCCAATTAGAGACCTCTATGTAAGAGCGTATATGGAATAA +TCAACGTGGTAATGCAGATTAAACTGTCTGAACCAGGGCGAAAAGTCACGACTTCGTAAA +ATCACAGTTAACAGAGATTAACCGGATAGAAGCCCAAGGGTCACTTTCACCTGCAAACGC +TTCACAACTATGAGCTAACTTATTCTCTTTTGGGGGTCGTGATTTGATACTACGTATTCA +AGCACCTGCGTATGCTTTATCAAATGTGACTGCTACAGTACGTCGGCAGGTTACAGGTTA +ATAGGAGGAATAATATGAACATTGTAGATCAGGTCTACATGGCACTGATCTACATTTGGT +CAGAGCTAGATAAAATGGTAGTCGGTATGGGTTTAACAGCCTATATCGTCGCTGTATTAA +AAGGTGAACGTAAACATCGTGAGGCAATATTATGCGGTGTATTCGCTATGATTGCAGGTA +CTGCCTTATGATACTCAATACAATAGGTTATTACCGGGCGCCTCACGTGCGGGGAAATTG +GGTGTTAGGCCTGTGACTGCGATATGCGGTGACCGAGATTGCACAGCTGACGTCGATCGC +GACTCACCATTAGCAGCCTGAACTAGATCATGCACAGCTAGTTAAGGTCGGTGTCTCTAT +GCTGGAGTATGCTGTACTTGGTAAAGGAGATGAGGCTAGCCATGGGGGTCGTATAAGAAG +TTATTATGATGGTATTAACAATGGTGACCCTGTTGCTGCGGGTTCTGCTAAGGTTGCCCA +CGCTTTACGTGGTGACCCTAATGGTGAGAACTTACCGTCGCTTATGCGTAACGGTACACA +GCAACTATCAAGTCAATATGGTATTAACAATGGTGACCCTGTTGCTGCGGGTTCTGCTAA +GGTTGCCCACGCTTTACGTGGTGACCCTAATGGTGAGAACTTACCGTCGCTTATGCGTAA +CGGTACACAGCAACTATCAAGTCAATTTGTTAGTTTCTTATCACTACCTCAAGACGAAGC +TGCTCAACAACAACATTATTAGAACGCAGTTGAAGCGTATGATAGTCTGAAAGCTACTTA +CATGCAATTGAAAGCTCAAGGTTCTCCTTTGGCGGACCAACTGCTTGCAAGCGTAGCTGA +AGATTACCGTGGTACTGTTATGGAGATGTTCGCAGGTAATGCTGACATGAACTCTAGTGC +TGAAGCTCTACGTAACCCTGTTATATGTGAGGATGTACGTGGTTCCTATATGAAGAATAT +GCAGATGGTCTATTCGGACTTTCATTTTAAACGGATCATGCTAAACACGCTCTTGCTAAC +GGTTCTACAGCTTCTAATCACAAACAACTTGTATCTGATGCTACCGCTTTAAGTATGCAC +GATAAATGTTATAACTCCCCTGGTATCGAAAAAGCATCCCGCCCCTGCAGGTTACAACGA +TGCTTTATTCACAGCGGGTGCGTCTAAGGTTTACTATACCATAACAGCTCGCTTTTGCTA +GAAGATGAGTTGTTTTACGGTATAGCGTAAATTCGCCCTGTTCCGAGAAACCCACGATGC +GCGCTTAACAGGAGAGCTTTGGTCCAAAGGACGAAGACAACCGCGGTCACTGTATAGGCC +GATCATAAGGGTGTTAAGTAGTCGGCTGCTTACATTTGCCATGCAATTCATGAGCGTCTT +CGTACTGTGCCTAAATCTGTAAATAGTTCTCCTTATAACGTGTTGATTCATGCAGATCGT +ACGGGTCGCTACGTAATTGTCCAACCGATCGATATGAGTGGTAAGCTGTTCAAGGATAAG +TAAGGTCACGCAGTCCAAGGTGAGGTTAACAATCAAAGCCAATTCGTTAACTGAATGAAG +AACGCCTATGATGCTGACCAAGTTAAGTACAATAAGCACCCTAGCACATTTAAAACTATC +GATGCTGCTTTCAGTAATAAAGGTGTTAGTGATTCACTTGGTAGTATAGCCAACGACAAA +GAGGATATGGCTAAGTGGCGTCAAGAGTCTAAGTCGTACACATTGAACACAGCAGGCTCA +CTGGGTCAGGGTCACCCACAATCCTTGCTTAATCCATAAGCTGAGTTCATGTCTAATAAC +ATGAAAGATCAGCAGTTATAGGATAAGCGTTTACGTATCCCACTAGCTACAACGTGATAT +TACGTCAGCGCCTAGGACCCCATTCAATAACTTGGCGCTGGGACAAGAAGACCTCGTTTG +ATTTGCTACACTGACTTGATGGGTGAGCTCCTGCTGGGATGGATTTCAAGCCTGACGCAT +TGCAGCTATGGGCGACGAAGGGACAGCAAGGTTGATCCCATTGCGTTGATCGGGCCGAGT +ACGACTCGTGGGCGGACGTATAGCCAAGCACTAGCTAAAACGCGTAAGTCGTCGTCCTTA +TTAATACCTACTTGATTAGCCATTTATACAACCTCCTAATAATTAAAGTTTACCCATTGC +TAAGTAGTAATCACGAAGCATGTTACGACGCGCAACGTTACGACGGTGACCATCACCCGC +GTGTGTGTATGCAATTCAAGCTCTTCCATCCGTACAACCTGCTATCCCTGACCACGCAGC +ACCGACTGCGGGTGAGGGTATTCGTCCTAGTACCTATCAACAATTAGGACAGGCAACTGA +ACAAGATTTAGCAGTGACGGGTGAGGAACTCCAAGATGAGGTACTACCTGAACAACCACC +TGCTATCCCTGACCACGCAGCACCGACTGCGGGTGAGGGTATTCGTCCTAGTACCTATCA +ACAATTAGGACAGGCAACTGAACAAGATTTAGCAGTGACGGGTGAGGAACTCCAAGATGA +GGTACTACCTGAACAACCTGCACTACGGAAAGTCCCACGAGTAGTTGCACCTACTGCTAG +AGACTAGGGTAATACTATTTACGAAGGCATAAAAGTTGAACGTGTTATTTATTCTAATCC +GGATGCGGATGCATATGAGCTGTTTTAAGCTCATGCTGAACGTAACCGAGAGGAACTAAC +TTATATTCATGGCGCACGTAGCTGTGAGGATATGCAATTCCGTCAACGACGTATTTTAGA +TCGGCGTGTTGACAACGAGATTTTAGCTGCCCATCCGATTGAAGGTACCATTGCATCTGT +CGTGGAGCACTGTTAGACAAATTGGTGTAACCTCTTCAATTAAGAGATTTGCTAAAAGCC +GGGCTCGAGTAATTCCGACGGCCGGCAACGACTATTTCAACGTACAGCAGTTTAATTAAA +GTGAGGAAAATCGGCCCGGAGCCGAACGAGTGACCCAGACTTTGAAAGAGTGTGTAGAGT +TCCGGGACGCCGATGTTGATTTACCTTTAGCATTCGCACCTGGTCTGGGGCAGACTGGAC +GCGCTGCTAAGATACGTCGCTTGACTCGACGCACATCTACTTGGTATGCAAACCGCTGCT +CTAGGTGGTGGTGCTTTCCGTCTTAACCAATTATTATAAGATGGGTTTACACGTGCTCAT +TCCGATCGTAACTTAGCTAGTTTGACATTCTGCTTAGTGGATTTGTTCGCCCCTATCAGA +GATGAAGCCCGTATTACTGGTACATAGTGAAGTAGAATCGGGCGCCGACCATTCCTGATG +TGGATTCAGTATCGAGTTGAAAGACCGTGGGGGCAAACTCGACCCCGCTATCCCAGGTCT +CCTACGTCATCAGTCACGCATAAAGAATCGAGGCCGATGGTGAATTCAGCTCAATAGATA +TCTCCTGGTGGTGGGCGACCTGGGGAGGTATGTAAGTGCGCGTAGCGCGCAGTGGCAGCT +TTAAATCAAATGGTAGATACTGAGTTAGAAACTATTTCTCACGAGAGAACTGATCCTGCT +AACCATCTAGGTACTGCAGATACAACTAACGTACTAGGGCATGATATTAAAACGCCTATC +TCAGAACCGATTGGTACCTACTCTAAATTAGCAGTACCTGATCGGGCTGTTCCGAACAAG +GTTGTAGTTGCTCGACAGTCATCGAGTCACTTATATCCTATTGACCTGCGGCCTATGAAT +AGAATTAGGCACCCAGTGTCAGCGGAAACTACATGTGGTGTCTCATTAAGGGCGATGCAA +ATCACCTCGCTAATAAGATTATAGCATCTCCTGGAACGCAAGGTAATAATGCGCCTTATG +CTACTGCACCACTACAAGCAACCCCTGAAGTTAGATTGGTTGGTGCGGTATCAAAGGCCC +CCAACCTAAGCGTGGCGTGACATTCCTATGACGAGCAGTCGCCGCATCTGTTTGACCAGT +TAATCAAGTACCACTATCTTACCTCTCAGCATCCCTCTTTCCGGGCTGTTTTCAATAGCC +CTTCCGGCCGGCACTGAACACCAAATCCTTTAGTTACATTCTTTCAAGACGCTATCAATG +ATGCAGTTGTGATGATGTCTGGTACAAGTCCTAACCGCTTCTCTGGTCTTATAGGTCATA +CAGTTGCCCAGTACCAAGTTACTGAACAATTCGGTCAAGCAATGCAACGCTTAGATCAGG +ACATACTGTGGAAAATGAACTCAGGACAACCTGTAGATAAGAAAATGATTCATCTGCCCA +GTACCAAGTTACTGAACAATTCGGTCAAGCAATGCAACGCTTAGATCAGGACATACTGTG +GAAAATGAACTCAGGACAACCTGTAGATAAGAAAATGATTCATCAAATGATTGATCAGGC +TAATGTTGCAGATGAGATCAAAGCTATTCAAAAGGCGATGCAGCAGCATCATCTAAGTTC +TCTAGCAACCCTGCTTGTTTAGCTCGGCTCAATGCAGTCTCAGCAAAGCCTGAATCTACA +TATACATTCCTGTGGTACTTACATGCCTGTTAAACAGAGTTATGAGCCTATGAACAACTT +GATTAAAGCAGGTCGAGTTTGCGAGGTTCAGTTATATAACTTCTTAGGTAAAAAGAGCAT +TCGTATGTACCCCGAAACGCGGCAAGCTATGAAGTTCGTAACTAAGGCGGGAACTAAGAC +CGCCGAACGTAAGTTCCAATTGACTGCTAAAGAGTTAGGTCAGAACTTCTTTGAGAATCA +ACGGCATCAAGGTCCGTCTTTAGCCACGTCCGGCGGGACTAAACGCGAAACGCTGGTAGT +CGCCTAACATGTGTACCCCTCCCCGTCACCTTTTTTCTGTTCCTTAGATAAACTAGCACT +AGGTTTATCTGAAGAACAAACAGCAGGTCTGACCAAAGGGTTATTAGATGATTATGTTAC +TTCGTAGATCCGGTGTTGATCATGAGAACTTAAATAAGATCGCTGATGCTATCTATAAAG +GTACTCTGAATGTAGGTACGGGTGGTGCTAAGCAATTGCGTAAACATCTATTTAGGGATT +CGAATATGAAGTTCGTAGGTAAAGATGGTGGTCAGTATAGCTTAGGTGATATTGTGGACC +GTAACACTTGCATGAACTTAATTGATTATACACGTACTACGTCTACACGTATAGGGCTTG +CTCCGTTTGGTATTAAGACCACTGCTGACCTTGACAATATACGTCAAGGTATCATGAAAG +ATTTACCCGCAGACGTTGACATGGCAAAAATCCTCCCTATAGTTTCATGCAATCCCGTTA +TGACAACGGAGAGGAATTTTCTCAACATTCACTCCATATCAGCTGGTGCAACGTTGTGTT +TACCGCTAAGCGTTTCGTACAGATCGTCCGAGTGCAGGCTTCAGGTCCTACTATGGGTGA +GGCCGTTCCTGAGACTATCCGTTCATTGAACGCTGTGGCAGGTGATACTTTCCTATCTGA +TTCAGGTTTAGATAACGTGGTGGATATGGCGACTCAGGTTGCTAAGATGGGATTAATACG +TACATCGCCTGAGATCATGAAAGGTCTGGAGAGCATTTTGAATCCCATGAAGAAAGTGTC +TAGGAGTGAAGCAAACGATTTGTACGATCTACTGACTGGTCTATTGAGGACCTAAGATTG +ATGGTGAAACACCACGACTCGTTATGCTGATCACTTTGTGGTTACTACCGGTTTTCATGA +GGATACAGCTTATTACGGTCAAGCTAATCGATTCATAAACTTGCCTGAGTACGTTCAACA +CATGCTGGGTCCCAACTAAGCATAGGTAGAGACGCTTAAGCCTACCGAAACAGACAACGA +AGGTGGTTAGGTTGGAGCTGACCATGCGCACTATACACAGAGGTGCACGGACGAACACAT +GGACCGTATCCGCGTTCCCCGCCGGTATCAATCGACACCCAGAGCTGACCCTCCCCAGTT +ATGAGCTGTGATGGCAGCAGGTGTTATTCATCTGCTGAGCCCGGCGGCGTCGTAGTGTGC +AGATTGGTATGATAGGTGGTGTTGGCACCACTGCATTTAAGAGCGCAGCTAAAGGCTCAG +CTAACGGTATTAAGTAAATGAAAGAGACCTTGAAAATGTCTGATGAATTAACGGAGGCTG +TAATCAAGGAACACAAAGCTCATGGTACTAATATTGATATGTGGTCGAATGATGTACGTA +TGGCTATGGAACAGAAAGTGTTTTATGAGGCTGATAACTTAGCGCATGCGATTCGTCCAG +GTGAAGTCCCTGCATTCATGGAGCATAGTTCTGTGGGTAGGACCATCTTCCCTTGTTCAC +GTTCTCTGCTTCCGCTGTGCAACAAAAGGTACTTCGTAGTACTTATCAACGTGATGGTCC +TGTGGGTGTGGCTTTATTAGCTGCTGCACAGTTCCCATCTGCTATTAAACCGATTTTCAT +AATTAAGCTCCTAAGAATTGATCTTTCATGTGTTGAAGTGATACAGGCTTAACCAAACCA +AAACCATCATTACATTCGCATTGATTGGTATGGCTAAGAATATTAAGAAGGGTAAGGAAC +CTGAAGAAGATTTGGCTAAGACTTCGGTTCACACTGTGAGTATGCTAGGTACTGTCTTGT +ACCTGTCAGAGATCATCATGAATAGCAGTTTAGACAGTAACAGTGCTGCGGTAGCACCCG +TACCTAGTGCAATGACATTAGGGCAGATATCTATGTCGGGTCAGCTTGATTAACGGACAA +TTAAGAATGCTACACATTTGGGTTGTTTAACATGTTTCGATCTATTCACTTCAGCTATAG +ATGATTAATTATGTCGCTTAATGAGAAACTATCTTATTCGGAGCTTGTAGTCGAGTCCCC +ACCTACAGGCTTCGCAATTGGCTTCAAGGATTACGGGGAACAATCAGATACAATTAACGT +ACTTGTAAATGATGTAATAGCTACGGAGGCGGGTTACACCGTCTTCCGTAAGAATGCTCT +AGTCATTGCACTTGAACCTGCTGTCACATCAGGCATTTTCGCAATTGGCTTCAAGGATTA +CGGGGAACAATCAGATACAATTAACGTACTTGTAAATGATGTAATAGCTACGGAGGCGGG +TTACACCGTCTTCCGTAAGAATGCTCTAGTCATTGCACTTGAACCTGCTGTCACATCAGG +CATTGTACGGCTACAACGTGAAACTAATATTGATAAGTCCTTTCATATCTTTAGTGCGGG +TGCTAAGTTTGTCGGTGCTAATATGGACGCAAACTTTGAGCAGATTTTACACTCTCAACA +AGAAACCCGTGATGGTTTTGATAAGCTGTATTCCGATGTTATGCCATTGGTGAAACTAAT +ATTGATAAGTCCTTTCATATCTTTAGTGCGGGTGCTAAGTTTGTCGGTGCTAATATGGAC +GCAAACTTTGAGCAGATTTTACACTCTCAACAAGAAACCCGTGATGGTTTTGATAAGCTG +TATTCCGATGTTATGCCATTGGTTAAAGGTCATGCAGATGCTTTAGCACAGGCTCATGCA +CCGTCTCAAGTTGCTGAGGAGGCTGCTGAAGCTGCGGAGGAAGCTACGTTCCGATTTCGA +AGTGCTAGCAATGTTATTGATCGTACAGGTTTAACCCAACAAGATATTAACGATGTGTTA +GGTGTTACTACCAAGCTACCCGCTGTTTGGGGTCGCGGTACTGTTATTGATCGTACAGGT +TTAACCCAACAAGATATTAACGATGTGTTAGGTGTTACTACCAAGCTACCCGCTGTTTGG +GGTCGCGGTACTATCCCGTCTATACTGGATCACATTAATACCAACGACTAGGGTGCTATC +TGAGATGGTTCTCTGCATTCCTTCCATGAGTGTGTTACATCGGAACGTTGTAGTAGTCTA +TTAGCTATCCAAATGGGATTCCCAAATGCAACAGCTTTAACTGATAGTATTGATTGGTTA +GTTACAGATTACTGCTTAGGTTTACGTAAGTGTATCTACGCACCGCGTGGTACTTATGTA +TTTAACCGCCCTGCGCGTACACCTCACAGTGGTAGTCCTAACCGAGTGGATTCGTTCCCA +AATGCAACAGCTTTAACTGATAGTATTGATTGGTTAGTTACAGATTACTGCTTAGGTTTA +CGTAAGTGTATCTACGCACCGCGTGGTACTTATGTATTTAACCGCCCTGCGCGTACACCT +CACAGTGGTAGTCCTAACCGAGTGGATTCGGATTGCAGTATAATCGGAGATGGTACACAC +ACTGTATTCACACGTTCGGTTAAACGTTTTCTGGTTAGATGAATGATGACACCAAGTTGA +ATTAGTGCAGAGCTTTAAACCCTCTATTTCGCTCTTCTAATTGGAGTGAGGTTGTTCCTA +CAAGTCATTTCTTAGTAGTGATCGAGCATGACGCGTATGAGGACGATATATGCTACCTAT +CACCTTCAACAGGCACACGTATATTTAAGGTAGCCACGTCTATTTCTGCCCGTGAGGTCG +GAGTATGACGCTTGCTCTGCCAGGTGGCCAATTCATTGAGGAGTTTGAGCTAATATCGTT +CATTGACCTCTTACTTAGATCGCTAAATTTTCAGCCGTCATGTTGGTTCTGATGATTATG +AAGCCTATGATAATGCTAACCGTGACGAAGCTATATTTAACGTACATGACTGTTATCTGA +TTTTTCGTAATCTCAGTATGCAATCCACGGGTATCTACAGTCAGGGGTTAGACCCTTAGC +TGTGAATATCGTACCGCCGGACGACGCGTGCCAATCTACCCCGGCGTATCTTGTAGCTAA +GCTACCACCAAAAGCATAGTCGTATCGCATTTCCTTACGTTTACGCCTACGCCTCTTGTA +GCACCATCGGTTTCTACTTAGAGCAATCCGCATCTAGTGCGGAGAACTCGGCGGTTCATA +TGTCCCATTTGTCTGGGCTTCAGATTAAAGGTGCTGGTACGGTTATGTTGCTCGCTGCTG +CATAGGGTAACCATTATAACTGTGTAAATAATATCTACTTTACTGAGTGTGGTAAGCTTC +TGACGTTGGTTCAGGGCGCTTGTTACTTGCTAAAGCATTCCAAGCTTCTATGGAAGACTT +TGAATCATTCTTAGCTAAACCACTATCAGGTATTGGTGGTTGATGTGGAGAAGCGTGGTG +GTAAGCATGACAGTTCGCCCATTCAGGTTAATAACAACCGTAACACGTTCCCTGATATAC +GATCTAACGGTACTAAGGTTGGTCTGTGGGGTAAGTCGGGAGATAATAACCGCGTTATAA +TGTGGGATCGTGAGGGTCGTGGTGCTGCGCCGACTTACAACAGTTTTGGTGCTATTCTAG +GGTTAACCCTGCATCCTGACAATGTAGCAGTTACTAATGGTGTATTTATATGATCAAATC +ATCAAAACAATGCTACATACTGGTGTAATTGACAAAGTTGAGGGTTCCCGCCGTTCTCAC +ATTATGGGATTGAGGTCCCAATATCTGGCAGGGGTAGAGGGTACTTACACGGTAAAGGGC +AACTTAACCGCCTTATGAACTGTGTGACTGAAGCGTGTGATGTGGAGTTATACAACGACC +ATTATCGTAATAGCTTCACAGGTGTAGGTTTTAAGGAGAACGTTTACTTAGGTAAGACTG +TTATCAATAAACAAGTACCTGCATACTATCAGTCACCGCATACACTCACGGTAAAGGGCA +ACTTAACCGCCTTATGAACTGTGTGACTGAAGCGTGTGATGTGGAGTTATACAACGACCA +TTATCGTAATAGCTTCACAGGTGTAGGTTTTAAGGAGAACGTTTACTTAGGTAAGACTGT +TATCAATAAACAAGTACCTGCATACTATCAGTCACCGCATACACTATTTTCACCCAACTC +TCTGCGGTGAGGACGTGGGATAGTCCGCGAACGTCTGGACAACCAAACCGGCAGCATGTA +AACCCTGGCAATCAGCCCCCGAGGCGTCGGGGCACGCTGAGCCTTCTGGCTACAACTTCG +GCACGAGGAGTCCCGAGTAACCAGCTTATGCTGGACAATCCATAGTTCACTGAACCTAAA +CACGTGGGCCTTCCCCACTGTTACCAGTTTAGCGTTTACTGTTAAGTCGTTAAGTTTCAC +ATTGGTCATATGTAAGCGTTGCGCCTAGTCGCACCAATTGCGTGCTAGTTGGAGTTCCCC +AACCCTATAAGTGTTACACGTACTTCACGGGATAATTCATCACGTTATATTGATGAGCGA +TTAGTAGACTGAGGCTGTGTGGTTGCCATTGGTTGACGCGTGGCCTTGGAGGCAATGCGG +ACACGCCCGCGCAGATTCGGATTACCGCGGACGTTCTACAAGTATGCCACCTGGCAGGAG +TCGAAGAGGACTGCGACTCTCAAATCAGTTCCATCACCCGGTTACTTGTCCCCATGACGA +ACAAGAACTAGTTGATCGGCCGCTTATTTAATCAGCGGTATAATTAAGTACATTTTATAG +GCAGATTCAGATGCTAACGCGACTGCTTATATTAAGGTAAATATCAGTGCTGATAGTGCA +GCATCTAACTTGGGCTTTGCTTCTAAGTTTGCTGTAGCAGCACACCGTACAAGTGCTAAG +ACGCTGACACAGTGCTGATAGTGCAGCATCTAACTTGGGCTTTGCTTCTAAGTTTGCTGT +AGCAGCACACCGTACAAGTGCTAAGACGCTGACACGTTATAGTTTACATATAGTTTACTC +TTTACGAGCGTCTGGTCAAGGAACAGGGGACTCGGGCGTTGTTACTGCTGCCCTTGTTCC +TGTGGGTAGTTCGCATTGGTAGCCACGCGATCACCGATGACCGAATTTACGTCACGCTTA +AAACGGCGAGCATGGGACGAATAAAATTGCCTTAATCGTAAGTATGCAGGTATTCAACTC +ATAGGGTCACAGTCGCTCATGTCCGACTTCATGTCAACATTTCTTTGGTACTGCCCCTGA +TAACTGCACAGTTTCTGGTGGTGGTAGTTCAGTAGCGGGTGCTATTGGGTGGTACGCGAC +CCTGAGACTGACTTAATTTACCGTAGATACTGCGTAAGTAGTCAAAACTATTCCGAGTTA +GAATCATCTTTACTACCTCCCAATTTATTCTCAATCTTATCGACTGTACGTACATTGATG +GTATAAACTTCCGTGTTTCAGAAATGAAGCAAGCGGATTCTACCTATCCTGAATCTGACT +AGGGTTTGGCTACTGTATATGTTGAAACTGATAAGACCTTCCAACCTATCGCAGAGCGAG +GTTCGGTTAAATACTTATCAAAGTAAGATACTGATAAATTAGCAGTACGTTTGGGTAATA +CACCTGAAGCCGATGGTGATGGTCAACTGTATAAAGGGCGTGGTTATGTTCAGATCACTG +GTCGAGCTAACTATAAGTTCTTCAGTACGATTACTGGTAAAGACTTAACGTTTGGGTAAT +ACACCTGAAGCCGATGGTGATGGTCAACTGTATAAAGGGCGTGGTTATGTTCAGATCACT +GGTCGAGCTAACTATAAGTTCTTCAGTACGATTACTGGTAAAGACTTAATGATGACTCCT +GACTTAGAACTAGAAGTTGAGGTGTCTACTAAGATCAAGACACATAGTATGCTTAATGGT +TCATTCACTGGTGCAGGTTTCCGTCGTATGCATCTTGTGTGTCGTTATGAGTTAGCGCAA +TACATGGCAGGCCAGCCTATGTCAAGGTGCAGTACTGGGCTCCGATACTCGCTAACACGG +GACCAGTCTAATGACTACTTCGAACGTGAGAGTTGATCGACCGCGTTTTTTAAATGCGGC +TTCTCATTGAAGACTTCGGTAACAAGTGTCCCATGCTGCTCGTAACATCGTCAGTAGTAC +AGATCGTGCTGGTGAGATCACACAAAATACTATTGTATTCGAGACAGCATAACGGAGTTG +GTATGGATTACGGGTTACATCATGATGGTACACCTAGAGGACGTGGCTTCTTAGGTGAAA +TTAGTAAAACTTATGGTAGTGTGATGATTGAGAATAGTATTGGTGGATAGGTTGACGGGG +AAGAAGTAGATATACCTACTATTACACCAATGTTAGAACTCTCGGAGATTAAGCAGTTAC +AGGCTATGCGGGATGGTGATGACATACCTTAGATATACCTACTATTACACCAATGTTAGA +ACTCTCGGAGATTAAGCAGTTACAGGCTATGCGGGATGGTGATGACATACCTCAAGGTAT +TACCCGGAGGGCTATCCAACATGCACGTAAGCGTAAGGATCATCGATCACCATACTTCGC +AACAGAGTACGACTACCTACTGAGTGAAGATATGCGTCGCATCATAGGAGTAGATCAATA +ACTAAGAAAGTAGAGAGTGCAAGCGTAAGCACGTTAAAAGCGCTACATGAAGCGGTTGTT +CGTTATATGCTTATGTGCAATCAGTCTGCACTCACTGATGAGGATGCTGAACCGCAATAC +CACGAGGCAACTGGTGATGTGATTCCTACAGTCTATATTCCCTTGGTTGCATCTGAGCTT +GAGGTGTTCGTATCGTTCGTGAAAAAGAACAACATCACAGCTAAACCTGATGTAGAACAC +TTCTCATCGGCTTGCGCACTCAGCCTCGCAACGAAGCCCCGATCTTCGGTTGCACATTGC +TCTTTCAGTTCGGCTGGACTGACTAATGAGTTAACCGGATACTTAGGTGTAGCTCTTGAA +CAGGAAGTTCAATCAATTGTTATGGTCAATGAAAACGATGCAGCACTTGCTGCGTACCTA +AGTTAAGGAGTTCAATATGTCGTGTATCCAACAGCAAACGCTTCGACGTTTAGACTTACT +GATGCCTAAATGTAAGAAGTACAACGATAACCCTCAAGCTATTCCTTTAGAGGAACGTGA +GGAATTATCAATGATGTTCGCTGCCACATTCAAGAACTTTAAAGAGTTCGCTGAGTTGGG +TATGCGATACCTTGGCTTTAAGCTATCTATGGTTCCAGAAGACATTGCAGAGTTCATCCT +GCCTGTAATTCACATAGTCTTCTAGGAAAATTGATCTTCGATTCCACTAAGACGGACGGC +TCATTGGGTGGTGGATTGAATGGTGGTCACAATAGTCGTGACTGCGACGTCCTCGATGGC +AGTGAGTAATATGGACGGGACATTTAACGTGTGTTAGCGAAGGCTTTTCACGGTCAAAAA +TTAAGAAGCTGCAGCATGGGCAAGTTAGGACGCCGGTGCCGTGGCAAGGGCGTGCGTGTA +TCGGTTGATTAAAACGCTGACTACTGGTCTGCAGTTCTACATACGAGTTCCTTGCTAAGG +TGCGCCGTGGCCATCTCTGCCTAATTACTGAGTCACAGGCTAGCTAAATGAAAGTTTGTC +GGATATAGGACCCTTTGCATGGTGTGAACCCGTCCACTTGTGAGCGACCTCAAGTCTAGC +CTATGATTCACGGGTCTACGGGTACTGTTCTTATATTCTCTCGATGGTCTACCGTTATGG +ATTAGCTACCTGACAACGTCCTGAGGCGCCATATCCGTGAATGTGTATGAATGGAGATTC +TTGACTTCCGGAGAAATGTGGTTGCGGCTAAGGCTTGAAATTTTTGCCGCACACACCTAG +CTCACCATGGTCAAGCTAAATCGACCCTAGCTGCTTTGTACTGTATTTGGCTTCTTATCA +TAAACCCGACTGCCCGTACACTTATTGTGTCAGGTGGTGAGAAGCAGGCATCTGATGTTG +CATTGCATATGATTCGGATTATCATTAACTGTTCTATCCTTTGTTGTTTATGCCCAGATG +CGTCCAAAGGCGGTAGAACTTCGGCTAGTGCGTTCGACGTACACTACAGCCTAAAAGGTA +TTGCTGAGTCTGCGTCTGTATCTTGTATTGGTATTACGGCCATGGCAGTGGTGACTGCGC +ACGCTCGCTCCTACAACTGACAGGGTATGGGTGCTGACTTTATGCTAGCCGATGATATGG +AGACTCAACGTAACTCTATGACCCAAACTGAGCGTGGGACGCTGTTGCTAATTACTAAAG +AGTTCGCTGCTATCTGTATCTCCGGTGAGAATATGTATTTACGCACACCGCACACTAAAG +CCTCTGTGTACAATTGCGGCATTAGCCTAGCATCAGACCTGGTATCGATGCAATCTCACT +GTGTCCTTTCTTGGTCAGGAACCAACGATGCAAGTTGGTGCGCACGTAGGAATGGTAGCT +AGTACGCAAGCTCCGGCCGTCGAGTCTTAAACGGTATCAAAGTTTGTACACCTGCCCCCA +TGCTTCCATCTAACCACACCCGTCATCGAGATTTGGGATTCTTGATTGTACGCTCAATCG +CTCTCTACCTGTTCGTGGTTACGGCGTTCGTGTTTTGTATGGTCATTACCCTATCGATAA +CTAAGGCAGAAGTTAGCCTGGAAGAGCGCGTCAAGCACCCTTACGGCTAGTCTCGGCCGC +CGCCTAGAATGTAAGGGCGCTATGGTCCAGTTCTGTCGGGGGCTTTTAGCACACAGAGGA +TACATAAGGCTAATTGCCCTAACGTGATCTGAACTATACGCCGCCCATCACCAGTTAGAA +CTCTAACACTATGGTGCAGGTGTGACAATTGCACCTATGAAATACACGCTTACTTCTTGC +CCGTGGGGTGCCGGTTTAGGCTGTTAAAAGACGATCCATAGTTGCTGAGGGAAGCTTCCT +TCCGACGAACAATGGGAGCACATCACCGGCTATATACATGAGCTCACGGTCCATCTTACG +GCGCCTCATATGTTTAATCGTGCATTAATCGGAAACGCTCACTTACAAGCAGGTGGTCGT +GTTGCTGGTCAACGTGGTAAGCCGACTCACCCTGCACATTCGCTGGTCGAACTCACGAAT +GTAAGAACCTTGAATTAAATGCTAGAAAGGTCGCGCCAACAGATTTAAGCGATCAATGAG +GAAATCTTACAAGAGAAAGAATTCGAGTATGGTGATGAGGGTTTCTCATTACAGTACATG +CTCGATACAACGCTCTGAGATGCCTTCGGAACGAAGATTAAACTTTCTGATATGATTGTA +CTAAGCGTAGGTAAAGACGAAGTGCCTGAGTCAGTACAGGACGTCGCAGAGCCTCATAGG +TTATTCAAGGATACTGCTGAAGCTATTAACGATTTGCGAATGCACCATGCTCCCGCGGTA +CCCGATGTTTTTGTACCATTTCTACATGAAGTGATGACACTTGATCCTGCGGGTTCATGT +GCTGGTGAATTTTCTTATGCCATTGGTGGTACTAGTACATCTTGTATCTATTTTCGTTCC +GTAAGTGGGTTCGCAGGTGGTATGACTGAAAAGAATATGAACTCCGTGTTGCAGAAGATG +ATTGAGCATAACGTTAAGTTACTCGACATTGAGAAGAACATGGGTCATGGTACTGTTGCT +ATGTTATTCCTAGCACAGTTAGATAAGCTGAAGCTTCACGCTTTAACTTCAAACCCTGCA +ATTGATGAGTTTAAGAATCAGCTAGGTATGAGTTACAAAGAAGTACACACTGCCCTTAGT +GGTATTGGTATCACCGAGTATTATGTGGTAGGTCAAAAGGACCGTCGGAGCATTGATAGG +ATCTCACCTTCGACTCGTCGCCAAAACTAATTTGGAGTATCTACTCGAGCTATACAAGAC +GTTCGGAATCATTGCTCACCACATCCATCTGGGAAGCGTATGCAATTCTCTGGTTTCTGT +CAATTAGGGAACATTACGTATGATTGCAATAGTTTAGTCCATGAGGACCGAGCTGACTGT +GTAAAACGTGTGGTGGAAGTTCTAAAGACGTTTGTCGCTAAACATGAATAAGAGACTGCG +GTGTTGAGTCAGGAGGCTGCTCATCGAAAGTTCTTACGTAACCCTATGGGGTATGCCCAC +GATGATCCTTGGCATAACTCTAAAGCGTATCGTAAGCGTTATCATGGGTGTTACAAACAA +CGATCTACAAAGAAGCAGTTACTAAGAAGTGGATAAGGTGGCTGCTTTAGACCGCAAGTA +TAATGGTTTGATTGATCAAGTACAACGTAACGATAAGGCTGTACGTGTTCAACTGGATGC +ACTTGCAAAGCCTACAGTATGTCCGTTGTTAACTGCTGTACCTAAGCATGTAACCGACCC +TGTATAGAAACTATCATCGCTCGGATTAAAGATGCACGATTTATCCTAGCATTGCTAAAA +GCATTAAAGAAGAAGTCAAATATCAAGTACTAAAGTTATCGTTGCTAATGTAGATGTACC +TAAGTTAGCAAGGGGTGTATCTAATGCACTAAGCGTCGCTAAAGCGGTTAGGACCACTAA +GTTATAGAAAGGTATGAATAACGTTGAGAAAGCCCTATATCGAGCTACTGTGGTCGCGAG +GCCCAAGCAGGCTACCCCAGGTTTGTAAGTGTATCCTATGCTCATAGAACCGGATGAAGC +CGTAAAAATAGCCCAGTTTCGTATCCACTTGCCCGGAGGTCTCTTGATGTAGGTGTAAGT +ATCTAACGTTTGTTCAAGCGTTAA +>NC_002486.ref length=45636 +CTTCCCATGGATCGTTTTGAATTCTTATTTTAGGCTTGTTATTACGCATTTTATAAACTC +CTTAATTGTTATTTGATACCAATATGATACCGTTTAATCAAATATGCTCATAGCTTGATG +TTTTTTATCAGTATATAAATGAGAGTACGTTTGAATTGTTTCTGTAATGTTAGAGTGCCT +CATTAATTCCATTAATAAATACATATCTACACCATTATTAATTAAATAGCTTGCGTACGA +GTGTCTTAAATGGTGTATTTTTAGATTCGAGAATACAGATTTAAAATGATACGAATAAGT +AATGTATCTAATAGGTTCTAAACCCCCGAATATAAAATAGTTTTCGTCAAAATATTTATA +TCTTTTAGAAGATTCGTTATACATGTTTTCAAGCATCTCTCTAATTAAATTTGGCACAGG +TATTATCCCTTTAGAGCTTTCTTTTTTAGATTATATTCAATTTTTCTATTACTTAAATTG +ATTTTCTTATTTACGTCAATTTCGCCTTTTATTTTATTGTAATCTTTCCACTGCAAAGCT +AAAGCTTCTCCTATTCTAAGACCAGAATAAAATAACAGTTTAGTTAGCTGACGAGAAGTA +TCGTTTGTGATTTGTTCTACTTTTTCATCAAATTCTTCACGAGTGATAAATTTAGCTTGT +GGTTTTGTTCTGGGAATAGGAGTTACCGATAATGTGGGGTCGTATAAGAGCTTGTAATGC +TTTTTGGCGTAATTGATAACTGCTTTAAAACCTGCCCACACAGATCGTGCATAGCCAACA +GAAAGACCTGCATCGTTTAACAAATAATTCCTGAAAGCAGTACATTGCGTAGTAGTGATT +TTGCCAATAGGGATATTTCCGAACCTTTCTTTTATGTGAGTATTGTATTCTGTAGTTCGC +TTTTCTATTGAGCGTGCAGAAAGATTTTCATTTTTTAAACGATCAAAAAATATATATTCA +AAGGGTTGATTGTCCGAGTATCCATATTTAACATTTTGTATAAATTCGCTTTCAGCTAGT +TTGGCATCTTTCTTACGTTCAAACCCACGCTTCATTTTTCGTTTGTTATTACCGTATACA +TCTTTATATCTAATGGAAAAATACCATTTCCCCGTATTATCATCTTTATATACTGGCATT +TTGCTTCTCCCTCCTCAAAATTGGCAAAAAAATAATAAGGGTAGGCGGGCTACCCGATAT +TTAGTACTAGGTACTAAATATGTTATAATAAAATAAAAAGTAGGTGATAAGATGACTCAA +TTTCTAGGGGCGCTTCTTCTTACAGGAGTTTTAGGTTACATACCATATAAATATCTAACA +ATGATAGGTTTAGTTAGTGAAAAAAACAAGATTATCAATACTCCTGTATTATTGATTTTT +TCTATTGAAACATGTTTGATATGGTTTTATACTTTTATAATTTTTAATAATGTTGATTTA +AAAAATTTGAGTTTACTTCAGTTGCTTACAGGTCTAAAAGCAAATATTTGGTTTCTAATT +ATTTTTGTTTTAACAGTGCTTGTATTTAATCCTTTAATTGTTAAATTCATTATCTGGTTA +ATTAATAAAACAAGAAAGTTTATGAATTTGGATTGTATAAGCTTATTAGACAAAAGAGAC +AAGTTGTTTAATAACAACGGTAAACCAGTATTTATAGTTATTAAAGACTTTGAAAACAGA +ATCATTGAAGAGGGTGAACTTAAAACCTATAATTCAGCTGGTAGCGATTTCGATTTACTA +GAGGTTGAGCGACAAGATTTCAAAGTATCTGATTTACCGTCAAACGATGAATTGTATATT +AAACATACACTTGTAGACCTTAAACAACAAATTAAATTGGATTTATATTTAATGAATGAA +TATTAATCTTTTTTCTTAGCTTTTTCTGATAAAGTGCTTTTTAAGTTTTCGCTGGCACCC +GGCTTTTCAAAACTTTTGTTTATTGGGTTACTACGAGTAGCTTCTTGTTTTTTGTTTTTA +TCCGCCATAAAATTCTCACCACCATTCAACGTCTACACTTGTAGGCGTTTTTGAATTTTT +TTAATCCTTTTTCTCGTCACGCTATATAGGTACTTTTAATCATAATTAAAGCCAAGTTTA +TTTAAAATCTCTAAATAATCTGACGACTTTGCCCGTAATGTTTACGTCATTTATTTTTGA +CATTGGGTAGCTTCTATCTTTAATGGTAACGTAATTAGATAATCGCTTTAGGGTAAATGT +GTCATCTGAGTTAAATATAATTTCGCAAAAATATTCATCAGTTTCGGTTCCGTTCTCTGG +GAAGAAAACGGTTATTATATCTCTATCAAAGATAAAGTCGATTACATCATCATCTTGATC +TAAAATGTAGCAAACAGTCATATCGCCATTTTCAACTCTTCTTGTGCTATTTATAGTAGT +TATTGGTTGGGCAACTAATTTGCCTTTTGCCTCTGTGTATCTTTTTGGAAATTCCACATA +ATTCATTAAATCAATTGTTTTATTTGTTTCCATATTAGTTCTTTTTTCTATATCGTTATA +TCTCCATAAGTATTGTTTCTCTTCCATCCCTCATCCTCCTCGCGCCACACAGGCGCTGTT +AATCACATTTTAGTTCTATCAGTGATTTTAGACTCCATAACTCTTTGACGTGACTCTTTA +GCTTCTCGAATCATATCTTTAAATTCTTGACTGTCTATAAAAGCTTTGGCTTCTTCTATT +TGTTCTTGAGTAAGCTCTTTGCCACCAGTATTGATGTGTAAGTGTTCAATTTCTTTATAA +GAACTCATTTTTTCGACTCCTGTTCTTCAAGTTCACTTTTAGTTATAGGTAAACCATTAT +TCAACCTATAAGTCAGTTCTTCTTCTGTATAAAAGGGGATTTCAACCATTTCCCACTCTT +CAATGTTAATGTCAACTTCTTTTAAATTCATTTTACTACCTCCTATAAAATAACTTTTCC +AACTAATCTCACACTTTCATTATCATAAAAATGTAAATCTTTATACTTTTTATTTAAAGA +AACCAACGTTAATCTGTTATCTTCTACATAAACCTTCTTTACGTAAGCATCTCCATTTAT +AATAAAGACGCCTATTTGTCCATCTTTGATAGTGTGAGATTTTTCAATGAATATAATTTG +TCCATTTTTAAATAACGGCTCCATTGAGTCTCCATTTACTTTTAAAGCTATATCATGTGC +GGGGACATAACCTCTTACGAATTCTTTTGAAATAGGTTCGTTATATAATCTTTCACCAAT +ACCAGCAGACGCACAACCATATATATCCACTTCGGATTTTTCTTGAATGTAAGAATTGAA +ATCTACCAGATTATCATCACTGTCATTATTTTGCTCTTCTAATTGATTAGTCGCATATTT +TAGTACATTGCTTTGTCTTGGAGGCGTGAGTTGAGATGACACGTTATGAATTTCTTCAAT +AATTTTCGAATCATCCATATCATGTATTAAATCTAAGGGTTTAACTCCAAAAACGTTAGC +TATTTCAGGTAATTTATCTAGTTTTGGACTTCTAATTCCCTTTCTCCATCTTGTGACTGT +TGTTCTATTTACATCTACTAATTCTGCTAATTCACTATCACTCATATCTCTTTTGTTCAT +CAGACGTTCTAGATTCGAAGAAAATGAACTCATATTTTTATCTCCTTTAAACATATTATC +TAACTAATAACTTCATTATATGCCTACAGTTCCAAAAATGCAACAAAAAACATAAAAATA +TGTGTAGAGGCAAAAAAATATGTAAAAAGCACTTGCAATTTTGGAACATCAGGTGTAGTA +TTGTTTTCAGGAGGTGTTCCAAAAATGCACAAAGATTTATATAGCTTTAGAAAAGCGGCG +AAAAAGAACCAAGACTTTATGGGGAGTTTGATTGGTGTTTCGGGTCAACAATACGGAAAA +AGAGAACGCGGAGAGATTCCTATTAATTTAGATGAAGCGATGATTTTTTCTAAGGCACTC +GAAACACCTATACAAGAACTATTTCCAGAATATTTTTTTATTGAGCGAGTTCCAAAAATG +CACAAAAACGAAATAACATCTTAAAAGGAGGACACAATGGAACAAATCACGTTAACCAAA +GAAGAGTTGAAAGAAATTATAGCGAAAGAAGTTAGAAATGCTATAAAAGGCGAGAAACCA +ATCAGCTCAGGTGCAATTTTCAGTAAAGTAAGAATCAATAATGACGATTTAGAAGAAATC +AATAAAAAACTCAATTTCGCAAAAGATTTGTCACTAGGAAGATTGAGGAAGCTTAATCAT +CCGATTCCACTAAAAAAGTATCAGCATGGCTTCGAATCAATTCATCAAAAAGCTTATGTA +CAAGATGTTCATGATCATATTAGAAAATTAACATTATCAATTTTTGGAGTGACACTTAAT +TCAGACTTGAGTGAAAGTGAATACAACCTAGCAGCAAAAGTTTATCGAGAAATCAAAAAC +TATTATTTATACATCTATGAAAAGAGAGTTTCAGAATTAACTATCGATGATTTCGAATAA +AGGAGGAACAACAAATGTTACAAAAATTTAGAATTGCGAAAGAAAAAAATAAATTAAAAC +TCAAATTACTCAAGCATGCTAGTTACTGTTTAGAAAGAAACAACAACCCTGAACTGTTGC +GAGCAGTTGCAGAGTTGTTGAAAAAGGTTAGCTAAATTCAACGGTAAGGATTTGCCCTGC +CTCCACACTTAGAGTTTGAGATCCAACAAACACATAAGTTTTAGTAGGGTCTAGAAAAAA +TGTTTCGATTTCCTCTTTTGTAACAGTTTCAATTCCTTCATATCCTGGAAAACAATTTTC +TTTAAATCCGAAACATGTTTTTTTGAACCATCCTTTAAAGTAACTAGAAGTTTCATACTT +ATCACCTCCTTAGGTTGATAACAACATTATACACGAAAGGAGCATAAACATTATGCAAGC +ATTACAAACATTTAATTTTAAAGAGCTACCAGTAAGAACAGTGGAAATTGAAAACGAACC +TTATTTTGTAGGAAAAGATATTGCTGAGATTTTAGGATATGCAAGGACAGACAATGCCAT +CAGAAATCATGTTGATAGTGAGGACAAGCTGACGCACCAATTTAGTGCATCAGGTCAAAA +CAGAAATATGATCATTATCAACGAATCAGGATTATACAGTTTAATCTTTGACGCTTCTAA +ACAAAGCAAAAACGAAAAAATCAGAGAAACCGCTCGAAAATTCAAACGATGGGTAACATC +AGACGTCCTACCAGCCATTCGCAAACACGGTATCTACGCAACAGACAATGTAATTGAACA +AACATTAAAAGATCCAGACTACATTATTACAGTATTGACTGAGTATAAGAAAGAAAAAGA +GCAAAACTTAGTTTTACAACAGCAAGTAGAAGTTAACAAACCAAAAGTATTATTCGCTGA +CTCGGTAGCTGGTAGTGATAATTCAATACTTGTTGGGGAACTAGCGAAAATACTTAAACA +AAACGGTGTTGATATAGGACAAAACAGGTTGTTCAAATGGTTAAGAAATAATGGATATCT +CATTAAAAAGAGTGGAGAAAGTTATAACTTACCAACTCAAAAGAGTATGGATCTAAAAAT +CTTGGATATCAAAAAACGAATAATTAATAATCCAGATGGTTCAAGTAAAGTATCACGTAC +ACCAAAAGTAACAGGCAAAGGACAACAATACTTTGTTAATAAGTTTTTGGGTGAAACACA +AACAACTTAATAGGAGGAATTAAAAATGAACACACTATACAAAACAACCCTCCTCACCAC +AATGGCAGTTGTGACGTGGAAGGTTGTAAAGATTGAGAAAAACACAAGATTTAAACTTAG +AAATTTTGATTATCCAAAAATTAGTAATGCTCAGAGCAAATCATTGTTGGATATTGCTAG +TCGCTATCTAAAAGATATTTAACTGTATTCAAAATTTTCATATCTTGTTGAGCTTTTAAG +CTTTCGTATAAAGCTATTGAATAAATAATTTCGTAAGATACGTTTTCAGGAGCATCTTCT +TTCAACTTATTTATTCTATCTCTAAAAAAGTCACTGTCACCACCGAATTCTTTTTCGGCT +TGATTACTAAGTTCACCAAAGAAATTTTGAAAATCATTAAATTCCATACTTATCCACCTC +CTTTCACTAGGAGATAACTAAATTATACACAACACAAAAATAAAAAGGAGGAATAGATAT +GATAAAAAATAGTTTGCAAGCTAAAGAACTTGCGGTAATTTTATCTGTTTCTAAATCCAA +AGCAGGACAAATAATAAGAGAACTGAATAAAGAGCTTGAAGACGAAGGATACATTGCGAT +ACGAGGAAAAATACCCGTCCAATTAGCTAGAAAAAAATTCCCTTATCACGACTTATCAGA +CGAGAGAATAATGGAGGAGTTAAAAAAAGAAAATGAGTAAAACTTATAAAAGCTACTTAA +TAGCAGTGCTATGTTTCACAGTCTTAGCGATTGTACTTATGCCGTTTCTATACTTCACTA +CAGCGTGGTCAATTGCAGGATTCGCAAGTATCGCAACTTTCATATTTTATAAAGAATACT +TTTATGAGGTGGATGATTAAATGACTTGGTTCGAAGAACACGTTGAACCTAGTGTGGAAT +GGGAAAGAAAAGCAGAACAAGCTGTGTTAAGTGATGATGAAGTTAAGACGATTACTGAAT +ACAGAGAGAAGTACAACAATCCATATATTTACATGTCGGTTCAAAACAAAAATTATCTTG +TTGAATATGTAGACAGACATACCGGTGACATAGTATTACACAATTTAAAACTTAAGAAAT +CATACAGAAGAAGAGCGCATCAATATTTTTTTGTCGGCCAAATAGTAGTACCAGGCGAGC +CAAAAGGCATAATTTATGAAACATCTTTGATAATAAGATAAAAAAACCGCTACTTGCGCC +AACAAGTAACAGTGACAAACATTTAAGAAATAAAATTCAAGTTAATTAAATCAAAATATA +CGGAGGTAGTCAAGATGTATTACGAAATAGGCGAAATCATACGCAAAAATATTCATGTTA +ACGGATTCGATTTTAAGCTATTCATTTTAAAAGGTCATATGGGCATATCAATACAAGTTA +AAGATATGAACAACGTACCAATTAAACATGCTTATGTCGTAGATGAGAATGACTTAGATA +TGGCATCAGAATTATTCAACCAAGCAATAGATGAATGGATTGAAGAGAACACAGACGAGC +AAGACAGACTAATTAACTTAGTCATGAAATGGTAGAGGGGGATTAACTAATGGCTAATCT +ATATGAGCTATCAGAAGCATTTAAAGAGATGTCTAATCAAGATGAATTAGATCCAACATT +ACTAAAAGATACATTAGATTCTATCAAAGCAGAAATGAACGTCAAAGTAGATAACATTGT +CAATTGGAGACGTGAAACTTTAGGTGACATAGATGTCATAGATAAAGAAATTAAGAGACT +TCAAAATTTAAAAAAACAAAAACAAAATTTAACTGATCGTTTAAGAGATTACTTAAAAGA +GATGTTAGAAACACAGGAAGTAGATAGTTACCGCACAGCTACTAATCATATTTACAAGCG +CAAAAACGGGGCTAGTAAAAATATTATCGATGAAAAACTTATTCCAAAGGATTATTGGCT +ATCACAAGCCCCGAAACTTAATTCTAAGCAACTAATCGATGATTTGAAAGATGGGAAAGA +TATTCCTGGCGTTGAATTAAAGGTAACAGAAAGCCTGGTGATTAAGTGATGAATAAATCA +GAAACAGTTGTAGAAATAAACAAAGCTATGGTTGCGTTTCGTAAAGAAGTAAAGCAACCG +CTCAAAGATAAAAATAATCCATTTTTCAAATCAAAATACGTACCTCTTGAGAACGTTGTA +GAAGCCATTGACGAGGCGGCAACACCTCATGGACTGTCTTATACTCAATGGGCTTTGAAC +GATGTAGACGGGCGCGTAGGAGTCGCTACAATGCTTATGCATGAAAGCGGTGAATATATC +GAGTATGATCCCGTATTTATGAATGCAGAAAAGAATACGCCACAAGGAGCAGGCTCGTTA +ATAAGTTATCTTAAACGTTATTCGCTATCTGCGATTTTCGGTATTACTAGTGACCAAGAC +GATGACGGAAATGAAGCAAGTGGAAAAAATAATAATCCAAAACAGCAAACTAGAACGCAA +TGGGCAAGTAGCGAAACTATAGGGATTTTAAGGAAAGAGGTTATAAGTTTCACTAAATTG +ATAAAGGGCACGGATAAAGAAGCTCCACAAAATATAGTAGAACAAAAATTCGACATAAAT +AACTATAAATTAACGGAAAAACAAGCAGCAGAAGCTATTCAAAAAATACGAAACAACGCA +AAAACAATTACTGGAGGAAAACAATAATGTTAAACAGAACGGTATTAGTAGGACGCTTAA +CAAAAGATCCAGAATATAGAACAACGCCGAATGGTGTGAGTGTTACCACTTTCACTATCG +CAGTTAACAGAACATTTACTAACGCTCAAGGAGAACGTGAGGCAGACTTTATTAACTGTG +TAACTTTTAGAAAACAAGCAGAAAATGTAAATCATTATTTATCCAAAGGGTCATTGGCTG +GCGTTGATGGACGTTTACAATCACGCAGTTATGAAAACAAAGACGGGCAACGTGTGTTTG +TTACAGAAGTAGTAGCGGACAGTGTTCAATTCTTAGAACCGAAGAATAACAACCAACAAC +AAAACAACAATTATCATCAACAAAGACAAACTCAAACTGGTAATAATCCTTTTGATAATA +CCACTGCGATTACTGATGATGACCTCCCGTTCTGATTGGAATGATTAGATGCCAATAATT +ACTAGTTATATCACTCAAGACGACGGCACAACAACAGTTGTCATCTCGGGTGTTGAATTA +GGCAATAAAGAAACATTACTACTTGATAACGGATTTGATGTGGAAGTAGATGTAAACGTT +ATAGATCCGTTTCAAATTACTGGACAACAACGTAAATTGATATTCGCATTGTGTAACGAT +ATAGAAGCTCATACAGGACAGCCTCGAGATTATATGAGACAAATGTTCCAAGATTATGTG +AAGTTTCTGTATGGCTATGAAGAACGCATATCTTTATCAAATTGTTCTCGAACTATAGCT +AAGCAAATTATAGAAGCGATGTTTGAGTGGATTTTTACAAATGCGATTCCATTAAATTAT +AAAACAAGCAAATTGATGAAAGAAGATAAAAATTATCTTTATTGGGCAACTGTTACGCGT +CATTGCATTATATGCGGAAAGCCTCACGCTGACCTAGCGCATTATGAAGCAGTCGGCAGA +GGCATGAACAGAAATAAGATGAATCACTATGACAAACATGTATTAGCGTTATGTCGCGAA +CATCATAACCAGCAACACGCGATGGGCGTTAAGTCATTTGATGATAAATATCAATTGCAT +GACTCGTGGATAAAAGTTGATGAGAGGCTCAACGAAATGCTGAAAGGAGAAAACAATGGG +AGAAGTATCGTGGATAAAACTTAAAGTTGGCATGTTTGATGACAGCAAAATCAAATATAT +CGAAGCTTTACCCGAAAGAGATACGATCATAACCATTTGGGTTAAGTTGCTAACTTTATC +AGGAAAGTACAACGAACAAGGTTACATTATGCTATCTGAAAATTTGCCGTACAACGAAGA +AATGTTAGCAAATGAGTTTAGCCGACCTATCAACTCAATAAGGTTAGCAATTCAAACTTT +TGAGACATTGGGCATGATTGAAAAAGTTAATGGTGTCATAAAAGTGACAAACTGGGAAAA +GCACCAAAACATTGAAGGACTCGAGAAAATCAGGGCGCAGAACAGATTGAGGAAACAAAA +GCAACGAGAAAACAACAGAAAATTGTTGAATGGTCACGTGACGTCACGTGACAGTCACGC +AACAGAAGAAGATAAAGAATTAGATAAAGAATTAGAAAGAGATAAAGAAAAAGATATAGA +TAAGAATTTAAGTTCAAATAATAGCGCAACTGACGTTACGCATGAGCAATTTGAGGAATG +GTGGAAACTTTACAACAAGAAAAAAGATAAGAAGATGTCTTTCGCTAAATTCAAATCATG +CTTAAAGAAACATACTTTTGAGCAAATCATGCAAGGTACTCGAGAATATTTAAAAACTAT +TACAGACAAACAATATCAAAAGTACCCTAAAACGTTTTTAACTAACGAAAGCTATATGAA +TGATTATAGCGAAGAGATTAAAGAAACTGGCATAGATCAATTGGAACGTATGAAGTACGA +CGAAAGTTATTGGGACTAGGAGGATCTTATGAAACCGTTATTCAACGAAAAAATAAACGA +AAGTTTAAAAAAGTATCAACCAATCGAAGTAATACTAAGACAGAATTGCGATAAATGTGG +GCGTCAATACGACTTATATAAGTTTGAAAATGGATATGAATACAAAGACGGTTGCGAATG +CGAAATTCAAAGATTGGCTTATGAAGAATACAAAAGGAATAAACAAAAGAAACTTGATTA +TATTTTCAATCAATCAAATGTCAATCCGTCATTAAGAGATGCAACAGTCAACAACTATAA +GCCACAAAATGAAAAACAAGTACAAGCTAAACAAACAGCAATAGAGTACGTACAAGGCTT +CTCTACAAAAGAACCAAAATCATTAATATTGCAAGGTTCATATGGAACTGGTAAAAGCCA +CCTAGCATACGCTATAGCAAAAGCAGTCAAAGCTAAAGGGCATACAGTTGCTTTTATGCA +TATCCAAATGTTGATGGATCGTATCAAAGCGGCATACAACAAAAATGCAGTTGAAACTAC +AGACGAGCTAGTCAGATTGCTAAGTGATATTGATTTACTTGTACTAGATGATATGGGTGT +AGAAAACACAGAACACACTTTAAATAAACTTTTTAGCATTGTTGATAACAGAGTAGGTAA +AAACAACATCTTTACAACTAACTTTAGTGATAAAGAACTAAATCAAAATATGAACTGGCA +ACGTATCAATTCAAGAATGAAACACAATGCAAGGAAAGTTAGAGTAATCGGAGACGATTT +CAGGGAGCGAGATGCATGGTAATAACAAAGCAAAATATAAAAGAAATATTACATTGTAGA +GATGTATATGCTCAAAAGATGATTGATTTCTGCAAACGGAGTCCAAGAGAAACTTAAAAA +ACTTATTGATGATAAGTTGAAAGAAAAAGAAGAAAGATCCGCTATCGTCGAATATTAAGG +AGTGATTTAAAAATGCCGAAAAAAAATATTCTTATACCGAGAAGATGGCACGGAAGATAT +TAAGGTCATCAAGTATAAAGACAACGTAAATGAAGTTTACTCGCTCACAGGAGCCCATTT +CAGCGACGAAAAGAAAATCATGACTGATAGTGACCTAAAACGATTCAAAGGCGCTCACGG +GCTTCTATATGAGCAAGAGCTAGGTTTACAAGCAACGATATTTGATATTTAGAGGTGGCA +CAATGAGTAAATACAACGCTAAGAAAGTTGAGTACAAAGGAATTGTATTTGATAGCAAAG +TAGAGTGCGAATATTACCAATATTTAGAAAGTAATATGAATGGCATTAATTATGATCATA +TCGAAATACAACCGAAATTTGAATTATTACCAAAATTAGATAAACAACGAAAGATTGAAT +ATATTGCAGACTTCGCGTTATATCTCGATGGCAAACTGATTGAAGTTATCGACATTAAAG +GTATGCCAACTGAAGTAGCAAAACTTAAAGCAAAGATTTTTAGACATAAATACAGAAACA +TAAAACTCAATTGGATATGTAAAGCACCTAAGTATACAGGCAAAACATGGATTACGTATG +AGGAATTAATTAAAGCAAGACGAGAACGCAAAAGAGAAATGAAGTGATTTAATGCAACAA +CAAGCATATATAAACGCAACGATTGATATAAGAATACCTACAGAAGTTGAATATCAGCAT +TTTGATGATGTGGATAACGAAAAAGATGCGCTGGCAAAGCGTTTAGATGACAATCTGGAT +GAATTACTAAAGTATGACAACATAACAATAAGACGTGCATATATAGAGGTGGAATAAATG +AAGCTGAACGAAGTATTCGCAACTAATTTAAGAGTAATCATGGCTAGAGATAACGTAAGT +GTTCAAGATTTGCACAACGAAACTGGCGTATCAAGATCAACTATTAGTGGATATAAAAAC +GGAAAAGCTGAGATGGTTAACTTAAATGTATTAGATAAATTGGCAGATGCTCTAGGTGTT +AATGTAAGTGAACTATTTACTAGAAATCACAACACACACAAATTAGAGGATTGGATTAAA +ACAGTAAATGTATAGAGGTGGAATAAATGGCGAAAACAGCAAGAATTGTAAGGATACATG +ATAAACCGTATAGGTTCAGTGAATTTGAAATGGAGTTAATTGAAAGTCACGGTATAACAC +CCGGGATGGTTTCTAAAAGAGTAAAAGACGGTTGGGAACTACATGAAGCAATGGACGCAC +CAGAAGGCATGCGTTTAAGCGAGTACAGAGAAAAGAAAACAATAGAAAGACTGGAACAAG +CTAGACTCGAACGCAAATTGGAAAGACAGCGAAAGAAAGAGGCTGAGCTAAGAAGAAAGA +AGCCACATTTGTTTAATGTACCTCAAAAACATTCACGTGATCCGTACTGGTTCGATATTA +CTTATAACCAAATGTTTAAGAAATGGCAGGAAGCATAAATGCCAAAAACTGATAGCGCAT +GTAAAGAATACTTAAACCAATTTTTTGGATCTAAGAGATATCTGTATCAGGATAACGAAC +GAGTGGCACATATCCATGTAGTAAACGGTACTTATTACTTTCATGGGCATATCGTGCCAG +GTTGGCAAGGCGTGAAAAAGACATTTGATACAGCGGAAGAGCTCGAAATATATATAAAGC +AGCATGGTTTGGAATACGAGGAACAGAAGCAACTAACTTTATTTTAGAGGAGGTTATGAA +AGTGAACTATGAAACAGGGTTCCAAATAGGTGTAATGGAAGCTAGGTTGAAGAAGATGAG +AAAACAACGAGATGAGTATAAGAAGCAACAAGATGAGCTTATCGTGGATATAGCGAAGTT +ACGAGAACGTAACAAAGAGTTGGAGAAGAAAGCAAGTGCATGGGATAGGTATTGCAAGAG +CGTTGAAAAAGATTTAATAAACGAATTTGGCAACGATGATGAAAGAGTTAAATTTGGAAT +GGAATTAAACAATAAAATTTTTATGGAGGATGACACAAATGGATAACCGTGAACAAATAG +AACAGTCCGTTATAAGTGCTAGTGCGTATAACGGTAATGACACAGAGGGATTGCTAAAAG +AGATTGAGGACGTGTATAAGAAAGCACAAGCGTTTGATGAAATACTTGATGGAATGACAA +ATGCTATTCAACATTCAGTTAAAGAAGGTATTGAACTTGATGAAGCAGTAGGGATTATGG +CAGGTCAAGTTGTCTATAAATATGAGGAGGAACAGGAAAATGACTAACACATTAACAATT +GATCAGTTACAAGAGTTATTACAAATACAAAAGAAGTTCGACGATAGAATACCGACTAGA +AATTTAAATGACACAGTAGCTAGTATGATTATTGAATTTGCGGAGTGGGTTAACACACTT +GAGTTTTTTAAAAATTGGAAGAAACAACCAGGTAAGCCATTAGATACACAATTAGATGAG +ATTGCTGATTACTTAGCTTTCAGTTTGCAATTAACTTTGACTATTGTTGATGAAGAAGAT +TTGGAAGAAACTACTGAGGTTATGGTTGATTTGATTGAAAATGAAGTTACTTTACCTAAA +CTACATTCAGTTTATTTTGTTCATGTAATGCATACACTAACAGAACAATTTGTAAAAGGT +ATTGATAATAGTATTGTACAAGTTTTAATAATGCCTTTTTTGTACGCCAATACTTACTAT +ACAATCGACCAACTCATTGACGCATACAAAAAGAAAATGAAAAGGAACCACGAAAGACAA +GATGGAACAGCAGACGCAGGAAAAGGATACGTGTAAAGACATCTTAGATCGAGTCAAGGA +GGTTTTGGGGAAGTGACACAATACTTAGTCACAACATTCAAAGATTCAACAGGACGTAAA +CATACACACATAACTCGAGCTAAAAGCAATCAAAGGTTTACAGTTGTTGAGGCAGAGAGT +AAAGAAGAAGCGAAAGAGAAATATGAGTCACAAAATACACCTATTGTTTACTACACTAAT +AATTCTAAAGTGACCTTATTCGAAAGACCTAGTGAAGAAGTATTAGGTTCTTTGTTCGAA +AAGAAATAAAATCATTAAAGAGGGGAGATAATAATGTTTAATACACCTAAAATGAAATTA +CCAGAAAAGCACACCGAGGTATTTAAGACGTATAAAAATGGAACGCCAGAAGAAAAAGCT +GAGATTGAAGGCTGTTTTATTAAAACTGTTAAAGATGAAGATAGTGAATTTTACAGCCCT +ATGTTAGCCAGTCTAAATGAACAACAGTTAAAGAGTATGTTGAGACAGGTACTTTTTTTG +ATTGATACAGGAGATGACAATGATGATTAAAAAACTTAAAAATATGGATTGGTTCGATAT +CTTTATTGTTGGAATACTGCGATTATTCGGCGTAATCGCACTGATGCTTGTTGTCATATC +GCCTATCTATACAGTGGCTAGTTACCAAAACAAAGAAGTACATCAAGGGACAATTACAGA +TAAATATAACAAGAGACAAGATAAAGAAGACAAGTTCTATATTGTGTTAGACAACAAGCA +AGTCATCGAAAACTCTGACTTACTATTCAAAAAGAAATTTGATAGCGCAGACATACAAGC +TAGGTTAAAAGTAGGCGACAAAGTAGAAGTTAAAACGATTGGTTATAGAATACACTTTTT +AAATTTATATCCGGTCTTATACGAAGTAAAGAAGGTAGATAAATAATGATTAAACAAATA +TTAAGACTATTATTCTTACTAGCGATGTATGAGCTAGGTAAGTATGTAACTGAGAAAGTA +TATATTATGACGACGGCTAATGATGATGTAGAGGCGCCGAGTGATTACGTCTTTCGAGCG +GAGGTGAGTGAGTGATGTGGATTACTATGACTATTGTATTTGCTATATTGCTATTAGTTT +GTATCAGTATTAATAGTGATCGTGCAAGAGAGATACAAGCACTCAGATATATGAATGATT +ATCTACTTGATGAAGTAGTTAAAACTAAAGGATACAACGGGTTAAAAGAATACAGGATTG +AATTAAAGCGAATGAATAACGATATTAAAAAGTAATTTATATTATCGGAGGTATTGCATG +TATAACAGGAAAGAAATACGTGAAATGATAGATAACTACAAGTGGATGAAGAACATAATA +GACAGTAAAGTCTACGATAACGAAAGTACATCAATTGCACAATATGGTTATCAATCTGCG +ATGCCAAAAGCTAAAGGCACGACTAGCAATAAAATGTTAGTGAAAGTTATAAACAAAAAC +AAAGCGCTTAGAAAGTACGATTACTTGATTAAGAAGATAGCGTTCATTGATGAATATGAA +GAATACATCACGAATGAAAAAGATTATCATATTTTACAAATGTTAAAACAACGAGAAAGC +CATAATAGGATCATGAGCATTCTTGATATAGGCAGAGACAATTTTTATTCTAGAGTAAAA +GATATAGTAAATATACTTTATAACTTGCAACAAGAAACCGACAGTTCGGACACATCGTAC +AGTTCGGACACATCGTACAGTTCGGACACATCGTACTAATTTTGATGCTACATATTGTTT +TTTATTATAATTGCTGTGTAGCAAAACATTTATATTTCTTTTGAACTCTCACATTAAGTG +AGGGTTTTTATTTTTATAAACAAGAGGTGGAGAATGGAGATATCAAAGTACCAAGAGATA +GCTACACGTACACACAATGATGAATTGAATTTAAATGAATCTATTACTTGTTACGGCTTA +GGTTTAACTCAATCTACAGGCAATGTTACAGATCTAATTAAACAGCATATGTTTTGTAAT +GTACCGATAGATAAAGGAATTATGATAAATGAACTTAGCGAAGCATTGTGGAATATAGCT +AATCTTACTAACGTGTTAGGTATTAACTTGGATGAGATAGCTGGTCATAGTGTTACCACT +ATCTTGATGAATAAACCTAATCAGACTATCAATTTAGACAATGGTATAAAACAAGGAGAC +AAAGTATTGTTTCAAGGTAGTAAGTATCTTGTTGATGGATCGATAGGAAACTTATTGTTA +ATTAGCAATGATAAAGATGATAGACAAGTAACTGTGCAAGATGTTAAGAAAGTCGACAGG +GAGTGATGTGCATTGTCTATTATGAAGCGATGTGGTCATCCAACATGTAATGTATTGATT +AATCATAATGAAAGTTATTGTGATAAACACAAGCAATATGCAAATGAAAATTACAATGAT +TTGAGACGTCGAAACGATCCAGAGTATTTAAGATTTTATAAATCGAAAACGTGGCAAAAC +ATGCGTCGAATTGTATTGTTAGAACATGATTTTATTTGTGTTTCTTGTGGCAATCAAGCG +ACTATGGTTGACCATATTGTACCAACAAAAATTGATTGGGCAAGAAGATTAGACAAAAGT +AATTTACAGCCTTTGTGTGATGCTTGCCATAACCAAAAGACAAAAGAAGATTTGAAGAAA +TATTAAAAAAGATAAAAATAGGAAGCCCCCCCAAAGATGAAACGGGCGTCAATGAAAGGT +TCTGGAGAACGGAGCAGAGTTTTCTTCTCAAAAAATTCCCTTTATTTAAGTTTTTTTAGT +AGGAGGTGCTAATTTATGGCGGGTAGACCTAAGAAGCTTTTGTCAAATTCGAACAAGAAT +TATACAAAAGAAGAAATTATTGAAAAAGAGCGTCAAGAAGCTCAATTAAATAAATTTTCT +AAAATCGATACTGAACCACCGCACTTTTTAGATGAAATAGCGAAACAAGAATACTTAAGA +ATATTACCGCACATGCAAGAATTGCCAATTTCCAACTTAGATAAAGCACAATTAGCACAA +TATTGTAGTTTTTATAGTGACTTTGTTAAAGCAAGTTTGATTTTAGAGCGCGAAGACTTG +ATTTTAGAAGACGACAAAGGAAATCAAAAGGTTAATCCGGCGTTCAACATAAAGGAAAAA +GCGGGTATTCGATTGCAACAAACAGCTAATACTTTAGGATTAACTATTGATAGCCGATTG +CGTATTATGGTTCCTGATGAAAAAGAAGATGATGATCCATATATGGAATTTGTGAGTGAT +TAGTAATGACTGATTATGTTACTAAATACGCAAAAAAGGTAGTTTCAGGAGAAATTTTGG +CAAGTTTGAAGAATATTCAAGTATGTAAACGTCACCTATCTTTTATGGAGAACCCGCCGA +ATGGTTGCCATTGGGATAATCATTTGTCTAACAAAGCAATTAAATTTGTGGAAATGCTTC +CAGACCCTAAAACAAACCAGCCCATGCCTCTTATGGAGTTTCAGAAATTCATTGTTGGGA +GCTTATACGGCTGGCGTAGAGGTCAATACAGAATGTTTACTAAAGCTTATATAAGTATGG +CTAGAAAACAAGGTAAGTCTCTAATCGTATCGGGAATGTCCGTTAACGAACTGTTGTTTG +GACAATACCCTAAATTTAATAGACAAATTTATGTAGCTTCATCTACTTATAAGCAAGCGC +AAACAATATTCAAGATGGCAAGCCAACAAGTAAACCTAATGCGAAGTAAAAGCAAGTTTA +TCCGTGAAAAAACAGACGTAAGAAAGACAGACATTGAAGATGTATTAAGTAGTTCAGTGT +TTGCACCTCTTTCCAATAACCCAGATGCGGTTGATGGTAAAGATCCTACAGTTGCTATTT +TGGACGAATTGGCAAGTATGCCTGATGATGAGATGTACTCAAGGTTTAAAACAGGTATGA +CATTACAAAAAAATCCTTTAACCCTACTTGTTTCAACGGCCGGAGACAATTTAAATAGTC +AAATGTACCAAGAGTATAAGTATATTAAACGTATTTTAAATGAAGAAGTAAGAGCTGATA +ATTACTTTGTATATTGTGCTGAAATGGATTCACAAGAAGAAGTTCAAGATGAAACAAAGT +GGATTAAAGCAATGCCGCTTTTAGAATCAAAAGAACATAGAAAAACTATACTTCAAAATG +TAAAAGCTGATATACAAGACGAATTAGAAAAAGGGACATCATATCATAAGATTTTGATTA +AAAACTTCAATTTATGGCAAGCGCAAAGAGAAGATAGCTTGCTAGATATTTCAGATTGGG +AACAAGTAATAACGCCTATGCCTAATATCAATGGTAAAGATGTGTATATAGGTGTCGACT +TATCGAGATTGGATGACTTAACATCTGTAGGGTTTATTTTCCCTAACGACGATAAAAAAG +TGTTTTTACATAGTCATTCTTTCATTGGATTAAGAACAAACTTAGAACAAAAATCTAAGA +GAGACAAAATAAATTATGAATTAGCGATTGAACGTGGCGAAGCTGAGACTACACAATCAG +ATAGCGGCATGATTGATTATAAACAAGTTATCGATTTTATAGTGAAATTTATAACGACGC +ATGACCTGAATGTACAGGCTGTTTGCTATGACCCTTGGAATGCGCAAAGTTTTATAACAA +CAATCGAATCAATGGCTTTAGATTGGCCACTCATTGAAGTGGGACAAAGTTTTAAGGCGT +TATCACAATCTATTAAAGAATTTAGAATGTGGGTTGCAGATGAAAGAATACAGCATAACG +ATAATATGTTACTTACAACATCAGTTAATAATGCCGTTTTGATTCGTGACGGAGAAGACA +ATGTGAAAATAAATAAAAAAATGAATCGTCAAAAAATAGATCCGATTATTTCGATTATCA +CAGCTTTCACTGAAGCTAGAATGCACGAATTCCAAGAAAATTGGACGGAGAAATATGAAA +GCGAAGAATTCGGGTTTTAAAGGTGGTGACAAAATGGACTTGAATAAAATAAATGTCTTT +TTTAATTTCTTGGTTGCTAATTTGGTTAGCATCCTTTTTTTATTAGGTTTGTTTGTGGTT +AATGTTTCTGTGTATAAAGCATTCGGTCAAAATATAGGACTTTTATGCATTGGTATAACA +CTGATTGTTATTTCGTTGATTTTAAATCATGAAAGCAATCAAGAAAGGAGTTAGTAGTTG +TGGGGATTTTTTATAAAAATGAAAAACGAGACTTGCAATACAACGAAGATGATTTGCAAA +TGATGGTTCAAACTTTGCCAAGTTTTCAAGGAACAAAATTACGACAATATAAAGATATAG +AAGCAATTAGGCATAGCGACATCTTTACTGCAGTTATGATGATTGCTTCTGATTTGGCAC +GCATGCCAATTAGGGTGACAGTGAACGGCCAAATTAATTATAGTGACAGGATTGTTAATT +TGTTAAATACACGTCCTAACCCAATGTATAACGGCTATATATTCAAATTAGTAGTGTTTG +TTAGTGCCTTACTAACATCGCACGGCTATATTGAAATTACACGTGATAAAACAGGAGAAC +CTATGAATTTAACGTTCAGAAAGACATCCGAAATAGAATTGAAATCAGACGCAAGAGGTC +GACTGTATTATTTTCATCAAAGGATAGACAGTAACGGAAATAATATAGAACGTAATGTTA +AGTTCGAGGATATGCTAGACATCAAATTTTATTCGTTGGACGGTATAAATGGTTTGTCAC +TGTTAGACACATTAAGTCGCACGATAGAATCAGATAACAATGGAAAAGATTTCCTTAATA +ATTTCCTGCGAAATGGCACACATGCTGGTGGTATTTTGAAAATGAAAGGTGTATTAGATA +ATAAAAAAGCAAGAGACCGTGCCAGAGAAGAATTCCCAAAAGTTTTAGTGGAACTAAACA +AGCTGGGAAAGTTGTCGTACTCGATGAATCAATGACGTTTGATCAATTAGAAGTTGATAC +AGAAGTTTTAAAGCTTATCAGAGAAAACAAATCATCAACAAGAGAAATAGCAGGTGTATT +TGGTATTCCATTGCATAAGTTCGGCATAGAAACAGCGAACATGAGTATCACGGATGCTAA +TTTAGATTACTTATCAACTTTAAAACCTTATATTACATGCGTTTGTGCAGAATTGAATTT +TAAGTTTAATGATGAATATGTGAATCGTGAATTTAAATTTGATACCACTGAAATACGAGT +TGTTGATGAAAAAACACAAGCTGAAATTGACAAAATTAACATTGATTCTGGAAAGATGAA +TATCGATGAAATTAGACAACGTGATGGATTAGCGCCAATACCAGGCGGTAATGGTAGCAT +TCACAGAGTCGATTTAAACCATGTAAATATTGAACTTGTAGATGAGTATCAGATGAATAA +ATCGAGAGCTACTGATAAAAAATTGAAAGGTGGTGAGGAAAATGAGTAAGGAAACGAGAG +TTGGCAACATTATTGAGGTACGCTCAAATGATAACAACGAAATGGTCATAGAGGGGTATG +CGTTAAAGTTTGACACTTGGTCTGAAAATCTTGGTGGATTCAAAGAAACGATTTCACGTC +GTGCTTTAGAAAACACTGATTTATCTGATGTGCGTTGTTTAGTAGATCATATCCCATCGC +AAATAATTGGTAGGACAAAATCGGGTACTTTGGAGCTCGAAACTGATGATGTTGGACTTA +AATATCGTTGTAAGTTACCAAACACAACATTTGCACGTGATTTATATGAGAACATGCGTG +TAGGCAACATCAATCAATGTTCGTTTGGTTTTATGCTTGACGATAAAGGCGATGAAGTGC +GTTTTGATGAACAAGAAAACATTTACAAACGTACTTTAACAGCAATTCGTGAACTTACAG +ATGTTTCTGTAGTGACTTATCCGGCTTACAAAGACACTGATGTTAAACCAGCATTACGTA +GTATTGAAACCGTTAAAAAAGAACAACGTAAAAAAGAATTAGAAATAAGACTAAAGAAAC +ACTCTATATTAAATAATATTTGGTGAAGTTGAACACCATTATCAAATACAGCCATTGGAC +ATGCTGAATATAGCGATGTCTATTTTTTTATGCCAATTTTAGGAGGAAATTAAATGAAAA +CAAAAGAAGAGTTACAATCTGAGATTTCAGACATTAAAAGACAAATTGATTTAAAGGTGA +AGTATGCAACGAGAGCACTTAATAACGATGAGTTAGAAAAAGCAGAAAAATTAGAACAAG +AAATTACTGATTTACGTTCTCAAATCCAAGAAAAACAAGAAGAATTAGATAAGCTAAAAG +AAAAAGATAGAACTTCAGAAAACAATCAACAATCAGTGGAAGTAAACGAAGCACGTACTT +ATCGAAACCAAGCAAACATTAATGATTTAGGTATTTCGATTCAAAACACAAAGGTAACAT +CACAAGAAGTTAGAGATTTTACTGAATATCTTGAAACACGCAATGATATTCAAGGTGGTT +CGTTAAAAACAGACTCAGGATTTGTAGTTATTCCAGAGGAAATTGTTACAGATATTTTAA +AATTAAAAGAGGTTGAGTTTAATCTTGATAAGTATGTGACGGTCAAACGTGTTACAAATG +GTTCTGGTAAATATCCGGTAGTACGACAATCAGAAGTTGCAGCCCTTGAAAAAGTTGAAG +AATTAGAAGAAAACCCTGAATTAGCAGTTAAACCATTCTTCCAATTAGCATATGACATTA +ATACACACCGTGGTTACTTCCGAATTTCACGTGAAGCAATCGAAGATGCAAAAGTGAATG +TTTTGCAAGAATTGAAACTATGGATGGCGCGAACTATTGCAGCAACACGAAACAAAGCAA +TTATTGATGTTATCACTAAAGGATCAACGGGTTCTACAAGTTCAGGTTTTGAAAAAGAAG +GCAAGAAATTAGAAGTTAAAAAAGCAAAATCTTTAGATGATATTAAAGATGCTATTAACC +TGAATGTTAAGCCAAATTACGAACATAATGTTGCGATTGTTTCGCAAACTATGTTTGCAA +AATTAGACAAAATGAAAGATAAGCTAGGAAACTATTTAATCCAGCCAGATGTTAAAGAAA +AAACGCAACAGCGTTTATTAGGAGCTAAAATCGAAATTTTACCTGATGAAGTACTAGGGC +AAAAAGGTAATAACACTTTGATTATCGGTAACTTAAAAGATGCGATTGTTTTATTTGACC +GCTCTCAATACCAAGCATCATGGACTGACTACATGCATTTCGGAGAATGTTTAATGATTG +CTGTACGTCAAGACTGTAGAATTCTAGATTATAAATCAGCAATTGTGATTGAATATGATG +ATAGTGAACGCGGTGAAGGCGATCTTGGCTTAGAAGCATAATAAGCGCTCGATACTTTAT +AAAGAGGTGATAAACTATGGCAATGTATGAAGTGAAGAAATCTTATACTGACTTGGAAAA +AGGCCAGTATTTAAAGTCAGGTAAACGTGTTGAAATGACAGTAAAACGTGCTGAATATGT +TAACAAAAAGCTGAAAGAGCATGGAGTAATACTTGAAAGAGTAAAAGAAGAATAGGTGAT +TGAATGCAATTAACAGCTGAGGAACTTAAGTTATTAAAAAAGCATTGCAAAATAGATCAC +AATTCAGAGGACGACTTATTAGAAATATATTACTCTTGGGCATTCCATGAAATAGCTAGC +GCTGTTACGGATGAACCAAGTAAATATATTGATTGGTTTAAAAGTCATCCTCTATTTGCT +CGTGCTATATACCCTTTAGCAAGTTACTATTTTGAAAACCGTATTGCTTATTTGGATAGG +GATTTATCGCTTGCGCCACATATGGTTTTAAGTACGGTGCATAAATTGAGAGGTTCATTT +GAGCAATTTTTGGAGAGTGAAAATGATGAAGAGTCTGGGACATAAATCCCTAAAAAAACA +GCAGTAAGATAATTTTCAATTAGAAAATATCTTACTGCTGTTCTCTATTTATACAATACT +TCGTATTGAATGGCTTCGCTTTCCTAGGGTGCCGTCTCAGCCTTGGTCTTCGACTGGCAC +TGCTCCCTCAGGAGTCTCGCCATTAATACTACGTATTAACATGTAATTTTACTTTGAAAT +ACTTTAAAAAAATAAGACACTTTCGTATAATTTAATAAATACCACTAAACTAAATTAACG +AGGTGCCTTATGTATAAAAATTATAACATGACCCAACTTACACTACCAATAGAAACTTCT +GTTAGAATTCCTCAAAATGATATTTCACGATATGTTAATGAAGTTGTTGAAACGATACCT +GATAGCGAATTCGATGAATTCAGACATCATCGTGGCGCAACATCCTATCATCCAAAAATG +ATGTTAAAAATTATCTTATATGCATACACTCAATCTGTATTTTCTGGTCGTAGAATAGAG +AAATTACTTCATGACAGTATTCGAATGATGTGGTTAGCTCAAAATCAAACACCTTCTTAT +AAAACTATTAATCGTTTTAGAGTAAATCCTAATACTGATGCATTAATTGAATCTTTATTT +ATTCAGTTTCATAGTCAATGTTTAAAGCAAAATCTTATTGATGATAGTTCAATTTTTATT +GATGGTACAAAAGTAGAAGCTAATGCCAATAGGTATACATTTGTGTGGAAGAAAAGTATT +CAAAATCACGAATCGAAATTGAACGAAAATTCAAAAGCATTATATCGTGACTTAGTTGAA +GAAAAAATAATACCGGAGATAAAAGAAGATGGAGATAGCGATTTAACAATAGAAGAAATA +GATTTAATTGGTAGTCATTTAGATAAAGAAATCGAAGATTTAAATCATTCTATTCAGAAC +GAAGATTGTACTCAAATTAGAAAACAGACCCGTAAAAAAAGAACTGAGATTAAGAAGTTC +AAAAAGAAATTTGATGATTATTCCGAAAGAAAAAGTAAATATGAAGAACAAAAATCGATT +CTTAAAGATAGAAATAGCTTTTCTAAAACTGATCATGATGCAACTTTTATGAGAATGAAG +GAAGACCATATGAAAAATGGCCAACTTAAGCCAGGATACAATTTACAAATAGCGACAAAT +TCTCAATTTGTTTTATCCTATGACCTATTTCAAAACCCGACAGATACTAGAACTTTAATT +CCATTTTTAACAATGATTCAAAATACCTTCGGTTATTTACCGGAGTATATTGTGGCTGAT +GCAGGTTATGGTAGTGAGCAAAACTATATGGCTATTATAGATGATTTTAATAAAACGCCA +CTTATTACGTATGGTATGTTTATTAAAGATAAAACGAGAAAGTTTAAAAGTGACATTTTT +AACACTCAAAACTGGAAATATGACGAACTTAATGATGAATTTATATGTCCTAATAACAAA +AGAATAGGTTTTAAAAGATATGCATACCGTAATAATAGATATGGTTTTAAACGTGACTTC +AAACTATATGAATGCGATGACTGTTCAGCATGTTCTTTGAGGCAACAATGCATGAAGCCA +AATTCGAAATCCAATAAGAAAATCATGAAGAATTATAATTGGGAATACTTTAAAGCCCAA +ATTAATCAAAAGCTTTCTGAACCAGAAACGAAAAAAATCTATAGTCAAAGAAAAATTGAT +GTAGAGCCTGTTTTTGGATTTATGAAGGCTATTTTGGGTTTCACTCGAATGTCAGTTCGA +GGAATAAATAAAGTTAAACGAGAGCTAGGTTTTGTATTAATGGCACTTAATATAAGGAAA +ATAGTAGCTCGACGAGCTGTATATTATCAAATACATTTAAAAAAAGCTGATTTCTATCAA +ATAATTAATAGAAATCAGCTTTTTTACATTGCCTAAGAACTTAATGTCCCAAGCTCGAAC +GTATAGATTTTTGTGAAGATGTAAGCGAGAGAGTGAACAGAAATCCGATGAAACCGAAGA +CGAAAATATTATACTCTTGTTTCGCTTGCATTCAAGAATCTAAAGAATCCGACACTCAAA +CGAATCTCAATACAGGTAGCAAATTCATTAAAACTATTATTATCAGAGATACACGAGGTG +ATTATAAACCAACAAATAAGCATTACGTCTTGCATGAAGGGCAAAGGTTTAACATCAAAT +ATGTAAAGCCAGATTATCAAGATAAATCTTATTTGCGTATCTATGGCGAGGTGGTCATTT +AATGGGAGCAAGAATTGAAAGTAATAATATTGAACAAGGTTTGAAAAATGCAGTTTTAAA +AATGAATTTAAATAGTAATGTAATTGTCAAAGCTGGGGCTATGTCATTAGTCCCACTTTT +AAAAAGTAATACACCTTTTGCGAATACTAAAAAGCATGCTCGCGATCACATAGCTGTTTC +TAATGTGAAAACAGACAGACACACAAGTGAGAAAATCGTTACAATTGGTTACGCTAAAGG +CGTCTCACATCGTATTCATGCAACAGAATTTGGAACAATGTACCAAAAACCACAATTGTT +TATAACAAAAACAGAAAAGCAAGGGAAAAACAAAGTTTTAAAAACAATGCTTGATACTGC +TAAGAGGTTGCAAAAATGATTAATGTTACCAAATTAATTAGAAACGCTATTATTGCAAAT +AACATTACAGATGAAGTGAATGTGTTTAACTACACTATAGATGACCATTTTCACGAAAAA +ACTGACAAGCCTATTATTCGTATATATCCCTTACCGTTCAATCCTGACACATACGCTGAT +GATAACGAGATTTCAAGAGAATACCATTACCAAATTGATGTTTGGTGGTCTCAAGATGAA +CCGAACGAGCAAGCAGAAAAAATTGTTGATTTACTCAAAGTGATAAATTTTCAATGTTAT +TACAGAGAACCGTTATACGAGAGTGACGTCATGTCATTCAGACATATTATAAGAGCAAAA +GGCTCGATTTTATCAATGAAATTGGAGGAAAATTAAATGATTGAAAAATTGAAACAAGCA +CCAAGATTTTTAAAATTAAACTTACAACATTTTGCAGATACAGGAGTTTCGGGTATCGCA +ATTGGGGTATCAAACTTTTATTATGCACCTATTTTAAAAGATACAGAAAATGAATGGGAA +ACTGGAGCTGGCACACGTATTCGTTTCTTAAAAGAAATTGAAGTAGACCGTCCACAAGAT +ACCGAGGAAGATTATGGAGATGATATGGTCGCAGCAACTGCTGTATCTAATGGCAAACTA +AGTGTTAAGACAACATTTGTTACTGTTCCTGCTGACGATAAGGCGTTCTTGAATGGCGCT +AAAAAAGGTGTAGGTGGTTATAAATATGGAGCTAAGGATATCCCGCCAGATGTAGCGATT +GTATTTGAACGACGGTAATCATGATGAGTCTTCAGAATGGGTTGGCTTGTTCAAAGGTAA +ATTCACTCGTTCAAGCATCAAAGGGCAAACAAAACAAGATAAAGTTGAATTCCAGAATGA +CGACGTAGAAGGCAATTTTATTGATCGTTTGTTTGATGAGAGCTCGCATGTTACTGGCTA +TGATAAAAAAGGAAGCACTACAGGGCGCGATTATGTATTCATGGAAACATTTGGTAAAAC +TTATGATGAATTCATGTCTAGTCGAGGAGAACAAAATATGGAACCTGTAGAAAAAGAAAT +GAAAAAAACAGAAAAAGTTGAAGTCACTTCTGTAAACGTCACTGATGAACAAGTTACAGT +TAAAGTTGATGCTACTAAACAACTATCAGCCACAACCGAACCATCTGGACAGAAAGTAAC +TTTTGCAGTGACTGAGGGGCAAACGTATGCTAGCGTAACATCAACTGGCCTCGTTAAAGG +TTTGGCGGAAGGTAATGCGACCGTTACAGCGACTGCAGGAAAGCAAACTGATACTGTGCA +AATTACAGTACAATCTAATTTAGAAATGTAAGTTTTGAGGGCTTAACGCCCTCTTTTTAT +TTTGGCCAAATTAAAAAGAAAGTAGGAATTTAATAATGGAACGTACATCAATTGAATTAA +TTACAGGATTTACAAAAACAGGAAAGCCGCAATATCAAAAGTATTTAGCAAAGCCGATTA +TTACTTTGTTTGAAACAATTCAAGGTTCAAAATTAGGTTTGAAACTTAACAAAGCCTTTA +AGGGGGCTGATTTTAAAGATCTAACAGAAGAAGAATTTAATAACTTAAGTGTGACAGAAC +AGGAAGAATACAAAAACAAGCAAGAAGAATACGAAAACAACATGGCTGTACAAATGGAAG +TATTAGAAGAAGTTTTGGATTTCATCGTTGAAGCTTTTGATAATCAATTTACTAGTATAG +AACTTCAAAAAGGATTACCAAATGGTCAAGAAGGTATTGAAAAGATTGGACAGTTAATTG +GACGAATTACAGGTGGGGAACCTAGCGATACAAAAAAGTTCGTGACAGAGAATCAGAAAT +AAGAAAAGAAGATTTAACACCTGAAGCTGTCTACAACAATTACAGGAAAATAGCTAAAGA +TTTGATAGAAAACGGCATGGATGCAGAAAAAGTGGCTAACATGCCGATACACTTCTTTTT +AGACATTGTAGAATCGAAGATTGAAACAAAGCGAACTGCGAAAAGTTTTAAAGATATTTT +TTAATCAGCCTTTAAAGGTTGATTTTTTTATTTACATCTTGGAAGAAAGGAGGTTTTTAA +ATGCCTAATCCTATAGGTAATATGGTCATAAAGGTTGATTTAGATGGTTCTGGATTCAAT +AGAGGTGTGACAGGTTTAAATAGGCAAATGAAAATGGTTTCGCGTGAGCTTTCGGCTAAT +TTATCACAACTTTCTAGATATGATAATTCATTAGAAAAGTCGAAGATAAAAGTCGAAGGT +TTGAGTAAAAAACAAAAAGTTCAAGCCCAGATTACTAAAGAGCTGAAAGATAGTTATGAC +AAACTTAGTAAAGAAACTGGTGAAAACAGTGCAAAGACACAAGTTGCGGCTGCTAAATAC +AATGAAGCTTACGCTAAATTAAACCAATATGAGCGAGAGTTAAACCAAGCCACACAAGAA +TTAAAAGACATGCAAAGAGAGCAGAAAGCATTAAATACTGCAATGGGAAAACTTGGGACC +AACTTTAATAATTTTGGTCCTAAGCTTCAAGAAATTGGTAACAGTATGAAAAATGTAGGC +CGTAACATGACTATGTATGTAACTGCGCCGGTGGTTGCTGGGTTTGCTGTAGCAGCTAAA +AAAGGTATTGAATTCGATGACAGTATGAGAAAAGTTAAAGCAACTTCAGGTGCTACTGGG +GAAGAGTTTGAAGCTTTGAAGAAAAAGGCTCGCGAAATGGGTGCAACAACAAAATTTAGT +GCATCAGATTCGGCTGAAGCATTAAATTACATGGCACTTGCTGGTTGGGATTCTAAGCAA +ATGATGGAAGGTTTAAGCGGAGTTATGGATTTAGCGGCAGCATCTGGCGAAGAACTGGGA +GCAGTAAGTGACATTGTTACAGATGGACTAACGGCATTTGGTTTAAAAGCAAAGGATAGT +GGTCATTTTGCGGACGTTTTAGCACAAACTAGCTCGAAGGCAAATACGGACGTTAGAGGG +CTCGGAGAAGCTTTTAAATATGTCGCTCCTGTAGCAGGTGCGTTAGGTTACACGATTGAA +GATACATCTATTGCAATAGGTTTAATGAGTAATGCTGGTATCAAAGGTGAAAAAGCAGGT +ACAGCGTTACGAACAATGTTCACCAATCTTTCAAGTCCAACTAGAGCTATGGGGAATGAA +ATGGAACGCTTAGGAATATCTATTACAGATAGTAATGGGAAAATGATTCCTATGCGAAAG +CTTTTAGACCAACTGAGGGAAAAATTTAAACATCTTTCAAAAGACCAACAAGCTAGTTCT +GCAGCTACAATATTTGGTAAAGAAGCGATGTCAGGAGCATTAGCGATTATAAATGCTTCT +GATGAAGACTATCAAAAGTTAACCAAATCTATAGATTCATCTACCGGCGCATCTAAAAGA +ATGGCCGATACAATGGAATCTGGTTTAGGTGGAAAATTAAGAACTTTAAGGTCGCAATTA +GAAGAACTAGCCTTAACGATTTATGACAGAATAGAACCAGCACTAAAGATTATAGTAAGT +GCTTTTAGCAAAGTAGTGACATGGGTTACTAAATTACCAACGTCAATTCAATTAGCGGTT +ATTGGGTTTGGATTGTTTGCAGCAGTTTTAGGTCCATTAGTTTTTATGTTCGGTTTATTT +ATCAGCGTGATGGGGAATGCAATGACAGTTTTAGGACCCTTGTTAATAAACGTTAATAAA +GCTGGTGGTATATTCGCGTTTTTAAGAACTAAAATCGCATCCCTTGTTAAACTATTTCCG +GTTTTAGGTGTGTCGATATCCAGTTTAACGTTACCTATAACATTAATTGTAGGTGTATTA +GTTGGTATTGGCATAGCTTTCTATCAAGCTTATAAACGTTCAGAAACTTTTAGAAATATT +GTAAATCAGGCAATCTCTGGTGTAGCAAACGCATTTAAAGCAGCTAAACTAGCATTACAA +GGTTTCTTTGATTTATTCAAAGGTGATAGTAAAGGCGCGGTTACCCTAGAGAAGATATTT +CCACCCGAAACTGTAGCAGGAATACAAAATGTAGTTAATACGATTAGAACAACTTTCTTT +AAAGTAGTTGATGCAATCGTTGGTTTCGCCAAAGAGATAGGCGCTCAATTAGCCTCTTTC +TGGAAAGAGAACGGCTCAGAAATAACACAAGCTTTGCAAAATATAGCTGGTTTCATTAAA +GCAACCTTTGAATTTATTTTTAACTTTATTATTAAACCAATTATGTTTGCGATTTGGCAA +GTGATGCAATTTATTTGGCCGGCGGTTAAAGCTTTGATTGTCAGCACTTGGGAAAATATC +AAAGGTGTAATACAAGGGGCTATTAATATTATTTTGGGTATTATCAAAGTATTCTCTAGT +CTTTTCACAGGAAACTGGCGAGGCGTTTGGGACGGCATTGTAATGATACTGAATGGTACT +GTGCAGTTAATTTGGAATTTAATACAACTGTGGTTTGTAGGTAAAATTCTAGGTGTAGTG +AGATACTTTGGTGGATTACTTAAAGGTTTAATATCCGGTATCTGGAGTGTTATCAAAGGC +ATCTTTACAAAATCTTTATCGGCAATTTGGAATGCGACGAAAAGTATTTTTGGTTTTTTA +TTCAATAGTGTTAAATCTATTTTCACTAATATGAAAAACTGGTTATCTAGTACGTGGAAT +AATATCAAAAGCAATACCGTCGGCAAGGCTCATTCGTTATTTACAGGTGTAAGGTCTAAA +TTCACAAGTTTATGGAATGCGACGAAAGATGTATTTACTAAATTAAGAAATTGGATGTCA +AACATCTGGAACTCTATTAAAGATAACACGGTAGGTATAGCTGGTCGCTTATGGAATAGA +GTGCGTAACATCTTTGGAAGCATGCGTGACGGTTTAAAATCTATCATTGGTAAAATTAAA +GATCATATCGGTGGTATGGTAGACGCTGTTAAAAGAGGTCTTAATAAATTAATTGAAGGT +TTAAACTGGGTCGGTGGTAAGTTGGGTATGGACAAAATACCGAAGTTACACACTGGTACT +GAACATACGCATACTACTACAAGATTAGTTAAGAACGGTAAGATTGCGCGGGATACGTTC +GCTACGGTTGGGGATAAAGGACGTGGAAATGGTCCGAATGGTTTCAGAAATGAAATGATT +GAATTCCCTAATGGCAAACGTGTACTTACGCCTAATACAGATACGACAGCGTACTTACCT +AAAGGTTCAAAAGTATATAACGGCGCACAAACTTATTCAATGTTAAATGGAACGCTTCCA +AGATTTAGCATAGGTACTATGTGGAAAGATATTAAATCCGGTGCATCATCGGCATTTAAC +TGGACAAAAGATCAAATAGGTAAAGGTACAAAGTGGCTTGGCGATAAAGTTGGTGATGTC +ATGGACTTTATCGATAATCCAGGCAAACTTTTAAATTATGTACTTCAAGCGTTTGGAGTT +GATTTCAGTTCTCTAACTAAAGGTATGGGTATTGCTGGCGATATAACAAAAGCTGCATGG +TCTAAGATTAAGAAAAGTGCAATCAAGTGGCTTGAGGATGCTTTCGCAGAGTCGGGTGAT +GGCGGTGTAGTAGATATGAGTAAATTACGTTATTTATACGGTCACACTGCTGCTTATACA +CGAGAAACCGGACGCCCATTCCATGAAGGTCTGGATTTTGATTACATTTACGAACCTGTT +CCATCAACCATTAATGGTAGAGCACAAGTTATGCCTTTTCATAATGGTGGTTATGGAAAA +TGGGTAAAAATTGTAAAGGGCGCCTTAGAAGTTATTTATGCACATTTATCTAAATATAAA +GTTAAAACTGGTCACCAAGTTAGGGTCGGCCAGACTGTTGGTATATCGGGGAATACGGGG +TTTAGTACAGGACCTCACTTACATTATGAGATGCGTTGGAATGGAAGACATAGAGACCCG +TTACCGTGGTTAAGAAAGAATAATGGGGCGGCAAAAGTGCACCCGGTGGTAATGGTGCAG +CTAATGCTAGACGAGCTATTAAGGCTGCTCAAAATATTTTAGGAGGAAGGTATAAGGCGA +GTTGGATTACTAACGAGATGATGCGTGTTGCGAGTCGTGAATCCAATTATACAGCTAATG +CAGTCAATAATTGGGATAGCAACGCAAGAGCTGGTATACCTTCAAGAGGTATGTTCCAAA +TGATAGATCCTTCATTTAGAGCGTACGCAAAGTCGGGTTACAATAATCCTCTCAACCCAA +CTCATCAAGCTATATCGGCTATGAGATATATTGTGGGTAAATGGGTACCAAGAACAGGCT +CATGGAGAGCTGCGTTCAAACGCGCTGGTGATTACGCATATGCTACTGGTGGCAAAGTCT +ATAACGGATTGTATCACTTAGGGGAAGAAGGATATCCAGAGTGGATAATACCTACTGATC +CAAGTAGAGCGAACGAAGCACACAAATTATTAGCTTTAGCTGCTAACGATATTGATAACC +GCTCTAAAAATAAGCGACCAAACAACTTACCAAATCCAAGTATAAGTAATAGTGATAGAA +ACTATATTCATACATTGGAGAATAAACTAGATGCGGTTATTAATTGTTTGGTTAGTTTGG +TTGAGTCTAATCAAGTTATTGCAGATAAGGATTACGAACCAGTTATTAATAAGTATGTGT +TTGAAGATGAGGTAAATAATTCTATCGATAAACGAGAGCGTCACGAATCTACAAGAGTTA +GATTTAGAAGAGGAGGCACGATAATCTAATGCAAGATACAATTCAAATAGACAATAAAAC +AATTGGATGGCTGGTTGTGCAAAGAGGGTTCGAGATACCCTCTTTTAATTTTGTTACTGA +AAAAGAAAACGTAAAAGGTAGAGCGGGATCTATTGTTAAGAATCGTTATTTAAATGATAT +CGAATTTGATTTACCATTAATTATTCGAAACGAAAAATTGTCACCAGGTGGAGAAAAAAC +ACACGATGATATATTAGAAGCATTGGTCAAGTTCTTCAATATTAAAGATTTAACACCTAA +AAAACTTAAATTCAAATCTCAAAACTGGTATTGGTTTGCATATTTTGATGGTCCATTAAA +ATTACCGAAAAACCCAAGAGGTTCAGTGAAGTTCACTATAAAAGTAGTGTTAACAGATCC +TTATAAATACTCGGTAACTGGAAACAAAAACACCGCGATTTCAGACCAAGTTTCAGTTGT +AAATAGTGGGACTGCTGACACTCCTTTAATTGTTGAAGCCCGAGCAATTAAACCATCTAG +TTACTTTATGATCACTAAAAATGATGAAGATTATTTTATGGTTGGTGATGATGAGGTAAC +CAAAGAAGTTAAGGATTACATGCCTCCTGTTTATCATAGTGAGTTTCGTGATTTCAAAGG +TTGGACTAAGATGATTACTGAAGATATTCCAAGTAATGATTTAGGTGGTAAGGTCGGCGG +TGACTTTGTGATATCCAATCTTGGCGAAGGATATAAAGCAACTAATTTTCCTGATGCAAA +AGGTTGGGTTGGTGCTGGCACGAAACGAGGGCTCCCTAAAGCGATGACAGATTTTCAAAT +TACCTATAAATGTATTGTTGAACAAAAAGGTAAAGGTGCCGGAAGAACAGCACAACATAT +TTATGATAGTGATGGTAAGTTACTTGCTTCTATTGGTTATGAAAATAAATATCATGATAG +AAAAATAGGCCATATTGTTGTTACGTTGTATAACCAAAAAGGAGACCCCAAAAAGATATA +CGACTATCAGAATAAACCGATAATGTATAACTTGGACAGAATCGTTGTTTATATGCGGCT +CAGAAGAGTAGGTAATAAATTTTCTATTAAAACTTGGAAATTTGATCACATTAAAGACCC +AGATAGACGTAAACCTATTGATATGGATGAGAAAGAGTGGATGGATGGCGGTAAGTTTTA +TCAGCGTCCAGCTTCTATCATAGCTATCTACAGTGCAAAATATACCGGCTATAAATGGAT +GGAGATGAATGGATTAGGCTCATTCAATACTGAGATTTTACCGAAACCGAAAGGGGCAAG +GGACGTTATTATACAAAAAGGTGATTTAGTAAAAATAGATATGCAAGCGAAGAGTGTTGT +CATTAACGAAGAACCAATGTTATCAGAGAAATCGTTTGGGAGTAATTATTTCAATGTTGA +ATCTGGATACAGTGAGTTAATCATACAACCTGAAAACGTCTTTGATACGATGGTTAAATG +GCAAGATAGATATTTATAGAGAGGAGATGAAAATGTGATACATGTTTTAGATTTTAACGA +CAAAATCATAGATTTCCTTTCTACTGATGACCCTGCTTTAGTTAGAGCGATTCATAAACG +GAATGTTAATGACAATTCAGAGATGCTCGAGTTGCTTATATCCTCAGAGAGAGCTGGAAA +GTTTCGTGAACGACATCGTGTTATTATAAGAGATTCAAATAAACAATGGCGTGAGTTTAT +TATTAATTGGGTTCAGGACGATATGGACGGCTACACAGAAATAGAATGTATAGCGTCTTA +TTTAGCTGATATAACAACAGCTAAACCGTTCGCACCTGGAAAGTTTGAGAAAAAGACAAC +TTCAGAAGCATTGAAAGATGTGTTGAGCGATACAGGTTGGGAAGTTTCTGAACAAACCGA +ATACGATGGCTTACGTACTACGTCATGGACTTCTTATCAAACTAGATATGAAGTTTTAAA +GCAATTATGTACAACATATAAAATGGTATTGGATTTTTATATTGAGCTTAGTTCTAATAC +CGTCAAAGGTAGATATGTGGTACTCAAAAAGAAAAACAGCTTATTCAAAGGTAAAGAAAT +TGAGTATGGTAAAGATTTGGTTGGGTTAACTAGGAAGATTGATATGTCAGAAATCAAAAC +AGCATTAATTGCTGTGGGACCCGAAAATGACAAAGGAAAGCGTTTAGAGTTAGTTGTGAC +AGATGACGAAGCACAAAGTCAATTCAACTTACCTACCCGTTATATTTGGGGAATATACGA +ACCTCAATCAGACGATCAAAATATGAATGAAACACGATTACGTTCTTTAGCCAAAACGGA +GTTAAATAAACGCAAGTCAGCAGTCATGTCATATGAGATTACCTCTACTGATTTAGAAGC +TACGTATCCGCATGAGATTATCTCAATCGGAGATACAGTCAGGGTGAAACACAGAGATTT +TAACCCGCCATTGTATGTAGAGGCAGAAGTTATAGCAGAAGAATATAATATGATTTCAGA +AAATAGCACATATACGTTTGGCCAACCTAAAGAGTTCAAAGAATCTGAATTAAGAGAAGA +GTTTAACAAGCGATTAAACTTAATACACCAAAAGTTAAACGATAATATTAGTAATATCAA +CACTATAGTAAAAGACGTTGTAGATGGTGAATTAGAATACTTTGAACGCAAAATACACAA +AAGTGATACACCGCCAGAAAATCCAGTCAATGATATACTTTGGTATGATACAAGTAACCC +TGATGTTGCTGTCTTGCGTAGATATTGGAATGGTGGATGGATTGAAGCAACGCCAAATGA +TGTTGAAAAATTAGGTGGTATAACAAGAGAAAAAGCGCTATTCAGTGAATTAAACAATAC +TTTTATTAATTTATCTATACAACACGCTAGGCTTTTTTCAGAAGCTACAGAATTACTGAA +TAGCGAGTACTTAGTAGATAATGATTTGAAAGCGGACTTACAAGCAAGTTTAGACGCTGT +GATTGATGTTTATAATCAAATTAAAAATAATTTAGAATCTATGACACCCGAAACTGCAAC +GATTGGTCGGTTGGTAGATACACAAGCTTTATTTCTTGAGTATAGAAAGAAATTACAAGA +TGTTTATACAGATGTAGAAGATGTCAAAATCTCCATTTCAGATAGATTTAAATTATTACA +GTCACAATACACTGACGAAAAATATAAAGAAGCGTTGGAAATAATAGCAACAAAATTTGG +TTTAACGGTGAATGAAGATTTGCAGTTAGTTGGAGAACCTAATGTTGTTAAATCAGCTAT +TGAAGCAGCTAGAGAATCCACAAAAGAACAATTACGTGACTATGTAAAAACATCGGACTA +TAAAACAGACAAAGACGGTATTGTTGAACGTTTAGATACTGCTGAAGCTGAGAGAACGAC +TTTAAAAGGTGAAATCAAAGATAAAGTTACGTTAAACGAATATCGAAACGGATTGGAAGA +ACAAAAACAATATACTGACGACCAGTTAAGTGATTTGTCCAATAATCCTGAGATTAAAGC +AAGTATTGAACAAGCAAATCAAGAAGCGCAAGAAGCTTTAAAATCATACATTGATGCTCA +AGATGATCTTAAAGAGAAAGAATCGCAAGCGTATATTGATGGTAAAATTTCGGAAGAAGA +GCAACGCGCTATACAAGACGCTCAAGCTAAACTTGAAGAGGCAAAACAAAACGCAGAACT +AAAGGCTAGAAACGTTGAAAAGAAAGCTCATGCTTATACAGACAACAAGGTCAAAGAAAG +CACAGATGCACAGAGAAAAACATTGACTCGCTATGGTTCTCAAATTATACAAAATGGTAA +AGAAATCAAATCAAGAACTACTAAAGAAGAGTTTAATGCAACCAATCGTACACTTTCAAA +TATTTTAGCTGAGATTGTCCAAAACGTTACAGATGGAACAACAATCAGATATGATGATAA +TGGGGTGGCTCAAGCTTTAAATATAGGACCACAGGGAATTAGATTAAATGCTGATAAAAT +TGATATTAGCGGTAATAGAGAAATAAATCTTCTTATCCAAAATATGCGAGATAAAGTAGA +TAAAACCGATATTGTCAACAGTCTTAATTTATCAAGAGAGGGTCTTGATATCAATGTTAA +TAGAATTGGAATTAAAGGCGGTGACAATAACAGATATGTTCAAATACAGAATGATTCTAT +TGAACTAGGTGGTATTGTGCAACGTACTTGGAGAGGGAAACGTTCAACAGACGATATTTT +TACGCGACTGAAAGACGGTCACCTAAGATTTAGAAATAACACCGCTGGCGGTTCACTTTA +TATGTCACATTTTGGTATTTCGACTTATATTGATGGTGAAGGTGAAGACGGTGGTTCATC +TGGTACGATTCAATGGTGGGATAAAACTTACAGTGATAGTGGCATGAATGGTATAACAAT +CAATTCCTATGGTGGTGTCGTTGCACTAACGTCAGATAATAATCGGGTTGTTCTGGAGTC +TTACGCTTCATCGAATATCAAAAGCAAACAGGCACCGGTGTATTTATATCCAAACACAGA +CAAAGTGCCTGGATTAAACCGATTTGCATTCACGCTGTCTAATGCAGATAATGCTTATTC +GAGTGACGGTTATATTATGTTTGGTTCTGATGAGAACTATGATTACGGTGCGGGTATCAG +GTTTTCTAAAGAAAGAAATAAAGGTCTTGTTCAAATTGTTAATGGACGATATGCAACAGG +TGGAGATACAACAATCGAAGCAGGGTATGGCAAATTTAATATGCTGAAGCGACGTGATGG +TAATAGGTATATTCATATACAGAGTACAGACCTACTGTCTGTAGGTTCAGATGATGCAGG +AGATAGGATAGCTTCTAACTCAATTTATAGACGTACTTATTCGGCCGCAGCTAATTTGCA +TATCACTTCTGCTGGCACAATTGGGCGTTCGACATCAGCGCGTAAATACAAGTTATCTAT +CGAAAATCAATATAACGATAGAGATGAACAACTGGAACATTCAAAAGCTATTCTTAACTT +ACCTATTAGAACGTGGTTTGACAAAGCTGAGTCTGAAATTTTAGCTAGAGAGCTGAGAGA +GGATAGAAAATTATCAGAAGACACCTATAAACTGGATAGATACGTAGGTTTGATTGCTGA +AGAGGTGGAGAATTTAGGATTAAAAGAGTTTGTCACGTATGATGACAAAGGAGAAATTGA +AGGTATAGCGTATGATCGTCTATGGATTCATCTTATCCCTGTTATCAAAGAACAACAACT +AAGAATCAAGAAATTGGAGGAGTCAAAGAATGCAGGATAACAAACAAGGATTACAAGCTA +ATCCTGAATATACAATTCATTATTTATCACAGGAAATTATGAGGTTAACACAAGAAAACG +CGATGTTAAAAGCGTATATACAAGAAAATAAAGAAAATCAACAATGTGCTGAGGAAGAGT +AATCCTTAGCACTATTTTTATACAAAAATTTAAGGAGGTCATTTAATTATGGCAAAAGAA +ATTATCAACAATACAGAAAGGTTTATTTTAGTACAAATCGACAAAGAAGGTACAGAACGT +GTAGTATATCAAGATTTCACAGGAAGTTTTACAACTTCTGAAATGGTTAACCATGCTCAA +GATTTTAAATCTGAAGAAAACGCTAAGAAAATTGCGGAGACGTTAAATTTGTTATATCAA +TTAACTAACAAAAAACAACGTGTGAAAGTAGTTAAAGAAGTAGTTGAAAGATCAGATTTA +TCTCCAGAGGTAACAGTTAACACTGAAACAGTATGAAAAGCTATGAGTTAGATACTCATA +ATCTTTATTCTTTTAGAAAGCGGGTGTACTGAATTGGGGTGGTTCAAAAAACACGAACAT +GAATGGCGCATCAGAAGGTTAGAAGAGAATGATAAAACAATGCTCAGCACACTCAATGAA +ATTAAATTAGGTCAAAAAACCCAAGAGCAAGTTAACATTAAATTAGATAAAACCTTAGAT +GCTATTCAAAAAGAAAGAGAAATAGATGAAAAGAATAAGAAAGAAAATGATAAGAATATT +CGTGATATGAAAATGTGGGTGCTTGGTTTAGTTGGGACAATATTTGGGTCGCTAATTATA +GCATTATTACGTATGCTTATGGGTATATAAGAGAGGTGTTTACTATGCTTAAAGGAATTT +TAGGTTACAGTTTCTGGACGTGTTTTTGGTTTGGTAAATGTAAGTAATTTTTAAAGGTCA +GTGCTTTGACACTGGCTTTTTATTATTGTTGTGATTATGGTAATATACAAAAGTGAGCAA +GTTGGATAGATGGTGGCTATCTGAGTATAAGGAGGTGGTGCCTATGGTGGCATTACTGAA +ATCTTTAGAAAGGAGACGCCTTTGTGGTATCTGTTGTTGATGCACTAAATTTAATGTTTA +GTTTCGGTATGTTTATCGTTGCTTTACTTGGTTTAGTCATCGCAATCGTTAAATTAAACC +ATAAAAAATAACCATCACAACTTTGGACGGTTAATGGTTATTTTATAATAATTTCAAAAC +TGAGCCACCGTCTTTTTAACGGGCTCATTAGGGTAACATGTTTGCGCATGTTGCCTTTTT +CTATATATAAATTAACACACCATAATATAAATATCAAATAGACGGCTTATTAGTCGTCTT +TTTATTTTGGATAAAAGGAGATAAGAATATGATTAATTGGAAAATTAGAATGAAACAAAA +ATCATTTTGGGTAGCGATATTGTCAGCTATCTTTTTATTTGCTCAAAACATCGCAAAAGC +TATTGGGTATGATATTCAAGTTTATACAGAGCAATTAACAGACGGTTTAAACGCTATATT +AGGGTTTTTAGTATTAACTGGTGTGATCCAAGACCCGACTACTAAAGGTATAGGTGATAG +CCACCAAGCTTTAGAATATGAAGAACCAAGTAGAAAATACTAGGAGGTAAAATAATGAAA +ACATACAGTGAAGCAAGAGCAAGGTTACGTTGGTATCAAGGTAGGTATATTGATTTTGAC +GGTTGGTATGGTTACCAATGTGCAGATTTAGCAGTTGATTACATTTATTGGTTGTTAGAA +ATTAGAATGTGGGGAAATGCAAAAGATGCAATCAATAATGATTTTAAAAACATGGCAACA +GTATATGAAAACACACCATCGTTTGTTCCACAAATAGGTGATGTGGCTGTATTTACCAAA +GGAATATATAAACAATACGGTCATATTGGTTTAGTGTTTAATGGTGGTAATACAAATCAA +TTTTTAATTTTGGAACAGAACTATGACGGTAACGCAAATACGCCTGCAAAGTTACGTTGG +GATAATTATTACGGCTGTACTCACTTTATTAGACCTAAGTATAAAAGTGAGGGCTTAATG +AATAAGATCACAAATAAAGTTAAACCACCTGCTCAAAAAGCAGTCGGTAAATCTGCAAGT +AAAATAACAGTTGGAAGTAAAGCGCCTTATAACCTTAAATGGTCAAAAGGTGCTTATTTT +AATGCGAAAATCGACGGCTTAGGTGCTACTTCAGCCACTAGATACGGTGATAATCGTACT +AACTATAGATTCGATGTTGGACAGGCTATATATGCGCCTGGAACATTAATATATGTGTTT +GAAATTATAGATGGTTGGTGCCGTATTTACTGGAACAACCATAATGAGTGGGTATGGCAT +GAAAGATTGATTGTGAAAGAAGTTTATTGAAAACGCGCAGTTAATAAAAAGATAATAAAT +AGTTAATTTTATGTAATTTTCTTGTTTAACAGAAAAATCAAATATTTTAATGTATATTGA +ATTTAATATTCGTATAGGCTTTATAGTTAAAAAATTAACAAGCATTAACAATACAATGTT +TTTCAGGTATATTTCTATACAACTATAATGAACTTTTTTAATTATTGATCGTGTTTGAAT +GTTTTTTGGGTGTAACAATACTATTTTAGAGATTTATTAACCTTATTGAATTTTTAATAA +ATTTTTAATTATATAATTATGAATTATGTAATAGTATAAATTTGTATTAAAAATATAAAG +AGAAAGAAAGTGAAACTATGTTTAAGAGAAAATTATTAGTTACAACTTTGTCGCTAGGTC +TAATTGTCCCTATAGCTACACCATTTCAAGGCTCTAAGGCTACTACTAATGCAGAAGATA +TTGGCGACGATGCAGAAGTGATTAAACGTACGGAAGATGTAAGTAGTAGGAAATGGGGTG +TAACACAAAATGTCCAATTTGATTTCGTAAAAGATAAAAAATATAACAAAGACGCATTAA +TTATTAAGATGCAAGGTTTTATCAATTCTAGGACAACTTTCAATGATGTTAAACAAAATA +GAGCAAATAAAAGAATGGTTTGGCCATTTCAATATAATATCGGTCTTACATCAAAAGACC +AAAATACGAGCTTAATCAATTATCTTCCTAAAAATAAAATAGAAACAGTTGATGTTGGTC +AAACTTTAGGATATAACATTGGAGGTAAATTCCAGTCAGTACCATCTATAGGCGGAAATG +GATCATTTAATTATTCTAAGAGTATTAAATATTCCCAAAAGAGTTATGTCAGCGAAGTTG +AACAACAAAGCTCAAAAACTATTAAGTGGGGGGTTAAAGCAAATTCTTTTGTTATAGCAG +GGCATCGATGGTCTGCTTACGATGAATTATTGTTTATAAGAAATACGACAAGAGGACCTA +ATGCTAGAGACTATTTTGTAGACGATAATGAATTGCCCCCTTTAATAACAAGTGGATTTA +ATCCGTCTTTTATCGCGACAGTATCTCACGAAAAAGATTCAGGCGATACGAGCGAATTTG +AAATTACTTACGGTAGAAATATGGATGTTACCTATGCAACCTACCTTCCTAAACTTGGTC +TTTATCCAGAAAGAAAACATAATGAATTTGTAAACAGAAACTTTGTGGTCAAATATGAAG +TGAATTGGAAAACGTACGAAATTAAAGTAAAGGGGCACAACTAATATGAAATTTAAGAAT +ATAGTCAAATCATCAGTCGCTACATCAATTACATTAATCATGCTATCAAATACAGTTGAT +GCAGCTCAACATATCACACCTGTCAGCGAGAAAAAAGTGGATGACAAAATCACTTTGTAC +AAAACGACTGCTACATCAGATTCTGACAAATTAAAAATTTCTCAAATTCTAACTTTTAAT +TTTATTAAAGACAAAAGTTATGATAAAGACACATTAATACTAAAAGCTGCCGGAAACATT +TACTCAGGCTATACCCAACCCACTTCTGATAGTAGTATAAATTCACAATTTTATTGGGGA +GCTAAGTATAATGTTTTTGTTAGCTCGGAGTCCAAAGATTCTGTAAATATTGTTGACTAC +GCGCCTAAAAATCAAAATGAAGAATTTCAAGTTCAACAAACATTAGGTTATTCATATGGC +GGAGATATTAATATAATAAATGGATTAACTGGTGGATTGAATGGGTCAAAATCATTTTCA +GAAACGATTAATTATAAGCAAGAAAGCTACAGAACTACGATTGATAGGAAAACAAATCAT +AAATCAATCGGCTGGGGTGTCGAGGCACATAAAATCATGAATAATGGTTGGGGACCATAT +GGCAGAGATAGTAGTGATTCATTATATGGAAACGAACTATTTTTAGGTGGCAGACAGAGT +AGCTCGAATGCTAATCAAAATTTCTTACCAACACATCAAATGCCCATATTAGCACGTGGT +AATTTCAATCCAGAATTTATAAGCGTACTTTCTCACAAACAAAAGGATGTTAAAAAATCT +AAAATTAAAGTGACTTATCAAAGAGAAATGGATCGGTATGAAAATTTTTGGAACAACTTG +CACTGGATAGGTTATAATATTAAGAATCAAAAGAGAGCAACACACACATCAATTTATGAA +ATTGATTGGGAAAAACACACGGTTAAATTAGTAGCTTCGCAATCTAGCGAATAAACTACT +TCCTAGATACCGTTGATTTTATAATAGGCTATGATTCGAAAAGAAATCTAATTACTCAGA +TATTAGGTGACTTATGGGTAGAAATCAGTTAATATAAAATTGTGGTGAGCCTTTTCTTGG +CGAGTGCATAATGCATTCGCCTTTTTTATTTACATTAAAAAACAATTGTGGTATTATTTC +TACATACTTTATTTAACATTTCTCTCTCAAGTTGAAATTGCGAGTAGTAGGCAGGTACTT +CGGTACTTGCCTATTTTTTATGTTATAATTACATGTGTATATAGTAGGAGTGAACTATAT +AGCCCGGCAGAGGCCATATATCTGACTGTTGGTCTCACAGGAGACATCTTCCTTGTCATC +ACTCATATACATATATCTTGCTAACATAGAGTTGTTATAGTCGCTACGCCACCCATACTA +GTTACTGGGTGGTTGTTTTTTATGTTCGTATTTACGTTCGTATGATTTTTATTATATCCT +ATAAATAATATTGTATTAAATGTAAGGTGAAAGGGGTATAATAATGTATGAATATGAATC +AAAATATCCAAATCCTAATGATTTTCAATGTCCTCCAAAAGAAGCAAATTTCGCTGAAGG +TATAACATTTTATAAATGTAGCGACACATATGAATTGCCAAGCCAGTACATGGAACCTAT +GATAGAAAAAGGTTCAAGATTTCCTAAAAACAATGAAGAAAGATGTTTAATGTGTGGTCA +TTCTGTCTTTGTGGATGATAAGGATATATTTGAATTGATTAACAAAAAAGGTAGAATAGC +AAAAGGAATAAAAGATAAATGGAGATTTGTCTTTTATTTTGAAGGAAGCCAATTTAGTAA +ATATAAATTTACACCTTCAAAAAGTAATAAAAAGCACTATACATATTGGCATTATGGGAG +TAACGATATAATATATAGCTATAAGAGTGCTATAAACGAATGAAAGGAGTGGTGATATGA +CAATAGTATTCTCAAAATTAATTGACGTATTTGATGAATTCATGTATCCCACTTTCTTTT +CATACGAAGCAAGAGTGGGTGAGAAAACTAAAATATTTATAACTTTATTCGCATATTATG +ATGAAAATAGTAGGAAAGACTATTTTTTTAATGTGCCAGTAAATAAAAAGAAATATGAAC +AACTTATAAATGGTGAAATTGAAATTAGGTCTTTGTTTGTAAACAATAAAGATGGTTTTT +TTACAGAAGGTTCACCTGAAAGTGTAGCAATTATAGAACCTATACATTTAAACGTTAACA +CTGTCGATTATTTACCAGAAAAAAATTTATTCATGGTATATGATGATGATGAATTTTTGA +TTGTCGATATAGAAGAAATGAATTCCGAGTTAGATAATAGTGAAACTGTAGAGAAATTAT +TTGACTTAAACATTGGTAAACAAATAAATTCATCAGAATATAATAATAAAGAAGGTTTAA +TGATTGCTTTTAGTAATGATAATCAAATTATAAAAGCAGATTCGTTAGGAGTATTGATAA +CCAAGACGAGTGAATTGTTTAATAAAATAAGTAATAATTTATTAAATTTAAATGTAGTTA +AACCTTTTGAAAGTAGTTTTGGTATTTCTTTGGAATTTGATTCATTAAATTTAGACATTA +ATGATAACGAAATATATATCAATAAGTTTTTAAACCTTCTAAACTTTGTTTCTAATGATA +AAAAAGAAGATTTTTTCAATGAATTTTTAGGGTTGTACTCTATCAAAGAAAAAGATGAGT +TCTTAAATATTCTTAATGAATTAAGTTCTAATGACATAGAAATGAAAAGTATGTATTATA +ACAATATAAATGGAATTTATAAAGGCAGTATATTGAAACCATCAGAAGCCAAAAAATTTA +TAAATAGAGTTTATAATACAACAGAAACAAAAGAAACTTTAAATATCAATAATGCAACTA +TATATAAAATAGATGTAAAAAATAACTCATTTGGAGTTATAATCGATAATGATATTTATA +CTGGAAAATTAGGAGAAAGTTTACAAGACAAAGAAGAAACACAATTTACTGTTCCTTCAG +AAAAAAATGTTGTTTTAACACAGATATTTAAAAAAGACGAATTTACTAAAAAAGAAAGAA +AGCATTACATATTAGAATCTATAAACTAATTCACACCCACCACACCCTAACCGGTGTGGT +TATTTTTATTCTCACACAACCAAAAAACCACACCACCTATTAATTTAGGAGTGTGGTTAA +TTTTTATATGTGAAGCTAAAATAACTACAAATGATACCATTTTTGATACCACTTTGTTGT +AAAACAGAAAAAAATAAGGAAAACAAAAAAGACAAAAAACGCATTAAATCAACGTTTATT +GTCTCATGAAATTTAAATGTATGTTGATTTGTCAATTTAAGTGCAACAGTTCATCACATA +AAACTTCATAAGGAAACTTCCAATTTAAACACTTTCTTGGTCGATAATTAATTGAGTCTA +ATGCATAGTTAAGTTGCTCTTGATTTACTTTAGCTAAGTCTGTTTTCTTAGGGAAAAATT +CTCTTAGTAAACCATTGGTATTTTCATTTGTACCTCTTTGCCATGCGGAATATGGATCAG +CGAAGTAGACATTAATATTAAATTGGTTTTCAATATTTTGATAACAAGAGAACTCTTTCC +CTCTATCGACAGTAATAGTTTTAACGGCACCTTTAGGTAGATGTTTGATAAGGTTATTAA +TTGCCGTCTCCATAGAATTAGAGGAACGATCAGGCATAAGTACACAATAATAATAACGTG +ATTTTCTTTCTGCGAAAGTAGCAATGCACCCTTTACTTTTGCCTCTGCTGGATACAATTG +TGTCAGCTTCCCAATGACCGAATGTATTACGTTTCTTTATTTCCTTAGGACGTTGTGAAA +TAGGACGGCCAATATTAAACTTACCTCTAGTTTCTTTAGGTTTCTGTCTTTTTCCTTTTT +GACGAAGGCATGAAATAAGTTCGAAATTAATCATATTAGAGTTAATCCATCGATAGATGG +TTTTAAAACAGATTTGGTTTTGTAATAGACGACCTACGATTTGTTCAGGAGACCAGTGGC +ATTTTAAATAATATTTAATGATATTACCAAGTTCTGGAGTAAATCGAGTAGGACGACCAC +AAAGTTTTCTTTTGGTTTCATAATTTTTTTGAGCTGTTTCAGCTTGATATGACTGATTTA +AATTATTCCTACTAATTTCACGTGAGATAGTAGATACAGATCGTTTTAATTTACGTGCAA +TAGATCTTAAAGAATAATTTTCTTGACGTAAAACCTCTATACGTGCGCGTTCAGTTAGTG +TAAGATGGTTATAGCTCATGTTGGCACTCCTTGTATGTGTTTTTTTGGTTATTAACATCT +TACAACAAAGTGCCAATTATGGGCATTTTTTATGAATTTTTATAGGTGTTGCACTTAATA +TTACAATCCGTCGTATATAAATTTCACTTCCCATGG +>NC_002486.alt length=45636 tani=100.000 alt=splitted in three equal-sized fragments, shuffled fragments, one fragment reverse complement +ATATCGGTGGTATGGTAGACGCTGTTAAAAGAGGTCTTAATAAATTAATTGAAGGTTTAA +ACTGGGTCGGTGGTAAGTTGGGTATGGACAAAATACCGAAGTTACACACTGGTACTGAAC +ATACGCATACTACTACAAGATTAGTTAAGAACGGTAAGATTGCGCGGGATACGTTCGCTA +CGGTTGGGGATAAAGGACGTGGAAATGGTCCGAATGGTTTCAGAAATGAAATGATTGAAT +TCCCTAATGGCAAACGTGTACTTACGCCTAATACAGATACGACAGCGTACTTACCTAAAG +GTTCAAAAGTATATAACGGCGCACAAACTTATTCAATGTTAAATGGAACGCTTCCAAGAT +TTAGCATAGGTACTATGTGGAAAGATATTAAATCCGGTGCATCATCGGCATTTAACTGGA +CAAAAGATCAAATAGGTAAAGGTACAAAGTGGCTTGGCGATAAAGTTGGTGATGTCATGG +ACTTTATCGATAATCCAGGCAAACTTTTAAATTATGTACTTCAAGCGTTTGGAGTTGATT +TCAGTTCTCTAACTAAAGGTATGGGTATTGCTGGCGATATAACAAAAGCTGCATGGTCTA +AGATTAAGAAAAGTGCAATCAAGTGGCTTGAGGATGCTTTCGCAGAGTCGGGTGATGGCG +GTGTAGTAGATATGAGTAAATTACGTTATTTATACGGTCACACTGCTGCTTATACACGAG +AAACCGGACGCCCATTCCATGAAGGTCTGGATTTTGATTACATTTACGAACCTGTTCCAT +CAACCATTAATGGTAGAGCACAAGTTATGCCTTTTCATAATGGTGGTTATGGAAAATGGG +TAAAAATTGTAAAGGGCGCCTTAGAAGTTATTTATGCACATTTATCTAAATATAAAGTTA +AAACTGGTCACCAAGTTAGGGTCGGCCAGACTGTTGGTATATCGGGGAATACGGGGTTTA +GTACAGGACCTCACTTACATTATGAGATGCGTTGGAATGGAAGACATAGAGACCCGTTAC +CGTGGTTAAGAAAGAATAATGGGGCGGCAAAAGTGCACCCGGTGGTAATGGTGCAGCTAA +TGCTAGACGAGCTATTAAGGCTGCTCAAAATATTTTAGGAGGAAGGTATAAGGCGAGTTG +GATTACTAACGAGATGATGCGTGTTGCGAGTCGTGAATCCAATTATACAGCTAATGCAGT +CAATAATTGGGATAGCAACGCAAGAGCTGGTATACCTTCAAGAGGTATGTTCCAAATGAT +AGATCCTTCATTTAGAGCGTACGCAAAGTCGGGTTACAATAATCCTCTCAACCCAACTCA +TCAAGCTATATCGGCTATGAGATATATTGTGGGTAAATGGGTACCAAGAACAGGCTCATG +GAGAGCTGCGTTCAAACGCGCTGGTGATTACGCATATGCTACTGGTGGCAAAGTCTATAA +CGGATTGTATCACTTAGGGGAAGAAGGATATCCAGAGTGGATAATACCTACTGATCCAAG +TAGAGCGAACGAAGCACACAAATTATTAGCTTTAGCTGCTAACGATATTGATAACCGCTC +TAAAAATAAGCGACCAAACAACTTACCAAATCCAAGTATAAGTAATAGTGATAGAAACTA +TATTCATACATTGGAGAATAAACTAGATGCGGTTATTAATTGTTTGGTTAGTTTGGTTGA +GTCTAATCAAGTTATTGCAGATAAGGATTACGAACCAGTTATTAATAAGTATGTGTTTGA +AGATGAGGTAAATAATTCTATCGATAAACGAGAGCGTCACGAATCTACAAGAGTTAGATT +TAGAAGAGGAGGCACGATAATCTAATGCAAGATACAATTCAAATAGACAATAAAACAATT +GGATGGCTGGTTGTGCAAAGAGGGTTCGAGATACCCTCTTTTAATTTTGTTACTGAAAAA +GAAAACGTAAAAGGTAGAGCGGGATCTATTGTTAAGAATCGTTATTTAAATGATATCGAA +TTTGATTTACCATTAATTATTCGAAACGAAAAATTGTCACCAGGTGGAGAAAAAACACAC +GATGATATATTAGAAGCATTGGTCAAGTTCTTCAATATTAAAGATTTAACACCTAAAAAA +CTTAAATTCAAATCTCAAAACTGGTATTGGTTTGCATATTTTGATGGTCCATTAAAATTA +CCGAAAAACCCAAGAGGTTCAGTGAAGTTCACTATAAAAGTAGTGTTAACAGATCCTTAT +AAATACTCGGTAACTGGAAACAAAAACACCGCGATTTCAGACCAAGTTTCAGTTGTAAAT +AGTGGGACTGCTGACACTCCTTTAATTGTTGAAGCCCGAGCAATTAAACCATCTAGTTAC +TTTATGATCACTAAAAATGATGAAGATTATTTTATGGTTGGTGATGATGAGGTAACCAAA +GAAGTTAAGGATTACATGCCTCCTGTTTATCATAGTGAGTTTCGTGATTTCAAAGGTTGG +ACTAAGATGATTACTGAAGATATTCCAAGTAATGATTTAGGTGGTAAGGTCGGCGGTGAC +TTTGTGATATCCAATCTTGGCGAAGGATATAAAGCAACTAATTTTCCTGATGCAAAAGGT +TGGGTTGGTGCTGGCACGAAACGAGGGCTCCCTAAAGCGATGACAGATTTTCAAATTACC +TATAAATGTATTGTTGAACAAAAAGGTAAAGGTGCCGGAAGAACAGCACAACATATTTAT +GATAGTGATGGTAAGTTACTTGCTTCTATTGGTTATGAAAATAAATATCATGATAGAAAA +ATAGGCCATATTGTTGTTACGTTGTATAACCAAAAAGGAGACCCCAAAAAGATATACGAC +TATCAGAATAAACCGATAATGTATAACTTGGACAGAATCGTTGTTTATATGCGGCTCAGA +AGAGTAGGTAATAAATTTTCTATTAAAACTTGGAAATTTGATCACATTAAAGACCCAGAT +AGACGTAAACCTATTGATATGGATGAGAAAGAGTGGATGGATGGCGGTAAGTTTTATCAG +CGTCCAGCTTCTATCATAGCTATCTACAGTGCAAAATATACCGGCTATAAATGGATGGAG +ATGAATGGATTAGGCTCATTCAATACTGAGATTTTACCGAAACCGAAAGGGGCAAGGGAC +GTTATTATACAAAAAGGTGATTTAGTAAAAATAGATATGCAAGCGAAGAGTGTTGTCATT +AACGAAGAACCAATGTTATCAGAGAAATCGTTTGGGAGTAATTATTTCAATGTTGAATCT +GGATACAGTGAGTTAATCATACAACCTGAAAACGTCTTTGATACGATGGTTAAATGGCAA +GATAGATATTTATAGAGAGGAGATGAAAATGTGATACATGTTTTAGATTTTAACGACAAA +ATCATAGATTTCCTTTCTACTGATGACCCTGCTTTAGTTAGAGCGATTCATAAACGGAAT +GTTAATGACAATTCAGAGATGCTCGAGTTGCTTATATCCTCAGAGAGAGCTGGAAAGTTT +CGTGAACGACATCGTGTTATTATAAGAGATTCAAATAAACAATGGCGTGAGTTTATTATT +AATTGGGTTCAGGACGATATGGACGGCTACACAGAAATAGAATGTATAGCGTCTTATTTA +GCTGATATAACAACAGCTAAACCGTTCGCACCTGGAAAGTTTGAGAAAAAGACAACTTCA +GAAGCATTGAAAGATGTGTTGAGCGATACAGGTTGGGAAGTTTCTGAACAAACCGAATAC +GATGGCTTACGTACTACGTCATGGACTTCTTATCAAACTAGATATGAAGTTTTAAAGCAA +TTATGTACAACATATAAAATGGTATTGGATTTTTATATTGAGCTTAGTTCTAATACCGTC +AAAGGTAGATATGTGGTACTCAAAAAGAAAAACAGCTTATTCAAAGGTAAAGAAATTGAG +TATGGTAAAGATTTGGTTGGGTTAACTAGGAAGATTGATATGTCAGAAATCAAAACAGCA +TTAATTGCTGTGGGACCCGAAAATGACAAAGGAAAGCGTTTAGAGTTAGTTGTGACAGAT +GACGAAGCACAAAGTCAATTCAACTTACCTACCCGTTATATTTGGGGAATATACGAACCT +CAATCAGACGATCAAAATATGAATGAAACACGATTACGTTCTTTAGCCAAAACGGAGTTA +AATAAACGCAAGTCAGCAGTCATGTCATATGAGATTACCTCTACTGATTTAGAAGCTACG +TATCCGCATGAGATTATCTCAATCGGAGATACAGTCAGGGTGAAACACAGAGATTTTAAC +CCGCCATTGTATGTAGAGGCAGAAGTTATAGCAGAAGAATATAATATGATTTCAGAAAAT +AGCACATATACGTTTGGCCAACCTAAAGAGTTCAAAGAATCTGAATTAAGAGAAGAGTTT +AACAAGCGATTAAACTTAATACACCAAAAGTTAAACGATAATATTAGTAATATCAACACT +ATAGTAAAAGACGTTGTAGATGGTGAATTAGAATACTTTGAACGCAAAATACACAAAAGT +GATACACCGCCAGAAAATCCAGTCAATGATATACTTTGGTATGATACAAGTAACCCTGAT +GTTGCTGTCTTGCGTAGATATTGGAATGGTGGATGGATTGAAGCAACGCCAAATGATGTT +GAAAAATTAGGTGGTATAACAAGAGAAAAAGCGCTATTCAGTGAATTAAACAATACTTTT +ATTAATTTATCTATACAACACGCTAGGCTTTTTTCAGAAGCTACAGAATTACTGAATAGC +GAGTACTTAGTAGATAATGATTTGAAAGCGGACTTACAAGCAAGTTTAGACGCTGTGATT +GATGTTTATAATCAAATTAAAAATAATTTAGAATCTATGACACCCGAAACTGCAACGATT +GGTCGGTTGGTAGATACACAAGCTTTATTTCTTGAGTATAGAAAGAAATTACAAGATGTT +TATACAGATGTAGAAGATGTCAAAATCTCCATTTCAGATAGATTTAAATTATTACAGTCA +CAATACACTGACGAAAAATATAAAGAAGCGTTGGAAATAATAGCAACAAAATTTGGTTTA +ACGGTGAATGAAGATTTGCAGTTAGTTGGAGAACCTAATGTTGTTAAATCAGCTATTGAA +GCAGCTAGAGAATCCACAAAAGAACAATTACGTGACTATGTAAAAACATCGGACTATAAA +ACAGACAAAGACGGTATTGTTGAACGTTTAGATACTGCTGAAGCTGAGAGAACGACTTTA +AAAGGTGAAATCAAAGATAAAGTTACGTTAAACGAATATCGAAACGGATTGGAAGAACAA +AAACAATATACTGACGACCAGTTAAGTGATTTGTCCAATAATCCTGAGATTAAAGCAAGT +ATTGAACAAGCAAATCAAGAAGCGCAAGAAGCTTTAAAATCATACATTGATGCTCAAGAT +GATCTTAAAGAGAAAGAATCGCAAGCGTATATTGATGGTAAAATTTCGGAAGAAGAGCAA +CGCGCTATACAAGACGCTCAAGCTAAACTTGAAGAGGCAAAACAAAACGCAGAACTAAAG +GCTAGAAACGTTGAAAAGAAAGCTCATGCTTATACAGACAACAAGGTCAAAGAAAGCACA +GATGCACAGAGAAAAACATTGACTCGCTATGGTTCTCAAATTATACAAAATGGTAAAGAA +ATCAAATCAAGAACTACTAAAGAAGAGTTTAATGCAACCAATCGTACACTTTCAAATATT +TTAGCTGAGATTGTCCAAAACGTTACAGATGGAACAACAATCAGATATGATGATAATGGG +GTGGCTCAAGCTTTAAATATAGGACCACAGGGAATTAGATTAAATGCTGATAAAATTGAT +ATTAGCGGTAATAGAGAAATAAATCTTCTTATCCAAAATATGCGAGATAAAGTAGATAAA +ACCGATATTGTCAACAGTCTTAATTTATCAAGAGAGGGTCTTGATATCAATGTTAATAGA +ATTGGAATTAAAGGCGGTGACAATAACAGATATGTTCAAATACAGAATGATTCTATTGAA +CTAGGTGGTATTGTGCAACGTACTTGGAGAGGGAAACGTTCAACAGACGATATTTTTACG +CGACTGAAAGACGGTCACCTAAGATTTAGAAATAACACCGCTGGCGGTTCACTTTATATG +TCACATTTTGGTATTTCGACTTATATTGATGGTGAAGGTGAAGACGGTGGTTCATCTGGT +ACGATTCAATGGTGGGATAAAACTTACAGTGATAGTGGCATGAATGGTATAACAATCAAT +TCCTATGGTGGTGTCGTTGCACTAACGTCAGATAATAATCGGGTTGTTCTGGAGTCTTAC +GCTTCATCGAATATCAAAAGCAAACAGGCACCGGTGTATTTATATCCAAACACAGACAAA +GTGCCTGGATTAAACCGATTTGCATTCACGCTGTCTAATGCAGATAATGCTTATTCGAGT +GACGGTTATATTATGTTTGGTTCTGATGAGAACTATGATTACGGTGCGGGTATCAGGTTT +TCTAAAGAAAGAAATAAAGGTCTTGTTCAAATTGTTAATGGACGATATGCAACAGGTGGA +GATACAACAATCGAAGCAGGGTATGGCAAATTTAATATGCTGAAGCGACGTGATGGTAAT +AGGTATATTCATATACAGAGTACAGACCTACTGTCTGTAGGTTCAGATGATGCAGGAGAT +AGGATAGCTTCTAACTCAATTTATAGACGTACTTATTCGGCCGCAGCTAATTTGCATATC +ACTTCTGCTGGCACAATTGGGCGTTCGACATCAGCGCGTAAATACAAGTTATCTATCGAA +AATCAATATAACGATAGAGATGAACAACTGGAACATTCAAAAGCTATTCTTAACTTACCT +ATTAGAACGTGGTTTGACAAAGCTGAGTCTGAAATTTTAGCTAGAGAGCTGAGAGAGGAT +AGAAAATTATCAGAAGACACCTATAAACTGGATAGATACGTAGGTTTGATTGCTGAAGAG +GTGGAGAATTTAGGATTAAAAGAGTTTGTCACGTATGATGACAAAGGAGAAATTGAAGGT +ATAGCGTATGATCGTCTATGGATTCATCTTATCCCTGTTATCAAAGAACAACAACTAAGA +ATCAAGAAATTGGAGGAGTCAAAGAATGCAGGATAACAAACAAGGATTACAAGCTAATCC +TGAATATACAATTCATTATTTATCACAGGAAATTATGAGGTTAACACAAGAAAACGCGAT +GTTAAAAGCGTATATACAAGAAAATAAAGAAAATCAACAATGTGCTGAGGAAGAGTAATC +CTTAGCACTATTTTTATACAAAAATTTAAGGAGGTCATTTAATTATGGCAAAAGAAATTA +TCAACAATACAGAAAGGTTTATTTTAGTACAAATCGACAAAGAAGGTACAGAACGTGTAG +TATATCAAGATTTCACAGGAAGTTTTACAACTTCTGAAATGGTTAACCATGCTCAAGATT +TTAAATCTGAAGAAAACGCTAAGAAAATTGCGGAGACGTTAAATTTGTTATATCAATTAA +CTAACAAAAAACAACGTGTGAAAGTAGTTAAAGAAGTAGTTGAAAGATCAGATTTATCTC +CAGAGGTAACAGTTAACACTGAAACAGTATGAAAAGCTATGAGTTAGATACTCATAATCT +TTATTCTTTTAGAAAGCGGGTGTACTGAATTGGGGTGGTTCAAAAAACACGAACATGAAT +GGCGCATCAGAAGGTTAGAAGAGAATGATAAAACAATGCTCAGCACACTCAATGAAATTA +AATTAGGTCAAAAAACCCAAGAGCAAGTTAACATTAAATTAGATAAAACCTTAGATGCTA +TTCAAAAAGAAAGAGAAATAGATGAAAAGAATAAGAAAGAAAATGATAAGAATATTCGTG +ATATGAAAATGTGGGTGCTTGGTTTAGTTGGGACAATATTTGGGTCGCTAATTATAGCAT +TATTACGTATGCTTATGGGTATATAAGAGAGGTGTTTACTATGCTTAAAGGAATTTTAGG +TTACAGTTTCTGGACGTGTTTTTGGTTTGGTAAATGTAAGTAATTTTTAAAGGTCAGTGC +TTTGACACTGGCTTTTTATTATTGTTGTGATTATGGTAATATACAAAAGTGAGCAAGTTG +GATAGATGGTGGCTATCTGAGTATAAGGAGGTGGTGCCTATGGTGGCATTACTGAAATCT +TTAGAAAGGAGACGCCTTTGTGGTATCTGTTGTTGATGCACTAAATTTAATGTTTAGTTT +CGGTATGTTTATCGTTGCTTTACTTGGTTTAGTCATCGCAATCGTTAAATTAAACCATAA +AAAATAACCATCACAACTTTGGACGGTTAATGGTTATTTTATAATAATTTCAAAACTGAG +CCACCGTCTTTTTAACGGGCTCATTAGGGTAACATGTTTGCGCATGTTGCCTTTTTCTAT +ATATAAATTAACACACCATAATATAAATATCAAATAGACGGCTTATTAGTCGTCTTTTTA +TTTTGGATAAAAGGAGATAAGAATATGATTAATTGGAAAATTAGAATGAAACAAAAATCA +TTTTGGGTAGCGATATTGTCAGCTATCTTTTTATTTGCTCAAAACATCGCAAAAGCTATT +GGGTATGATATTCAAGTTTATACAGAGCAATTAACAGACGGTTTAAACGCTATATTAGGG +TTTTTAGTATTAACTGGTGTGATCCAAGACCCGACTACTAAAGGTATAGGTGATAGCCAC +CAAGCTTTAGAATATGAAGAACCAAGTAGAAAATACTAGGAGGTAAAATAATGAAAACAT +ACAGTGAAGCAAGAGCAAGGTTACGTTGGTATCAAGGTAGGTATATTGATTTTGACGGTT +GGTATGGTTACCAATGTGCAGATTTAGCAGTTGATTACATTTATTGGTTGTTAGAAATTA +GAATGTGGGGAAATGCAAAAGATGCAATCAATAATGATTTTAAAAACATGGCAACAGTAT +ATGAAAACACACCATCGTTTGTTCCACAAATAGGTGATGTGGCTGTATTTACCAAAGGAA +TATATAAACAATACGGTCATATTGGTTTAGTGTTTAATGGTGGTAATACAAATCAATTTT +TAATTTTGGAACAGAACTATGACGGTAACGCAAATACGCCTGCAAAGTTACGTTGGGATA +ATTATTACGGCTGTACTCACTTTATTAGACCTAAGTATAAAAGTGAGGGCTTAATGAATA +AGATCACAAATAAAGTTAAACCACCTGCTCAAAAAGCAGTCGGTAAATCTGCAAGTAAAA +TAACAGTTGGAAGTAAAGCGCCTTATAACCTTAAATGGTCAAAAGGTGCTTATTTTAATG +CGAAAATCGACGGCTTAGGTGCTACTTCAGCCACTAGATACGGTGATAATCGTACTAACT +ATAGATTCGATGTTGGACAGGCTATATATGCGCCTGGAACATTAATATATGTGTTTGAAA +TTATAGATGGTTGGTGCCGTATTTACTGGAACAACCATAATGAGTGGGTATGGCATGAAA +GATTGATTGTGAAAGAAGTTTATTGAAAACGCGCAGTTAATAAAAAGATAATAAATAGTT +AATTTTATGTAATTTTCTTGTTTAACAGAAAAATCAAATATTTTAATGTATATTGAATTT +AATATTCGTATAGGCTTTATAGTTAAAAAATTAACAAGCATTAACAATACAATGTTTTTC +AGGTATATTTCTATACAACTATAATGAACTTTTTTAATTATTGATCGTGTTTGAATGTTT +TTTGGGTGTAACAATACTATTTTAGAGATTTATTAACCTTATTGAATTTTTAATAAATTT +TTAATTATATAATTATGAATTATGTAATAGTATAAATTTGTATTAAAAATATAAAGAGAA +AGAAAGTGAAACTATGTTTAAGAGAAAATTATTAGTTACAACTTTGTCGCTAGGTCTAAT +TGTCCCTATAGCTACACCATTTCAAGGCTCTAAGGCTACTACTAATGCAGAAGATATTGG +CGACGATGCAGAAGTGATTAAACGTACGGAAGATGTAAGTAGTAGGAAATGGGGTGTAAC +ACAAAATGTCCAATTTGATTTCGTAAAAGATAAAAAATATAACAAAGACGCATTAATTAT +TAAGATGCAAGGTTTTATCAATTCTAGGACAACTTTCAATGATGTTAAACAAAATAGAGC +AAATAAAAGAATGGTTTGGCCATTTCAATATAATATCGGTCTTACATCAAAAGACCAAAA +TACGAGCTTAATCAATTATCTTCCTAAAAATAAAATAGAAACAGTTGATGTTGGTCAAAC +TTTAGGATATAACATTGGAGGTAAATTCCAGTCAGTACCATCTATAGGCGGAAATGGATC +ATTTAATTATTCTAAGAGTATTAAATATTCCCAAAAGAGTTATGTCAGCGAAGTTGAACA +ACAAAGCTCAAAAACTATTAAGTGGGGGGTTAAAGCAAATTCTTTTGTTATAGCAGGGCA +TCGATGGTCTGCTTACGATGAATTATTGTTTATAAGAAATACGACAAGAGGACCTAATGC +TAGAGACTATTTTGTAGACGATAATGAATTGCCCCCTTTAATAACAAGTGGATTTAATCC +GTCTTTTATCGCGACAGTATCTCACGAAAAAGATTCAGGCGATACGAGCGAATTTGAAAT +TACTTACGGTAGAAATATGGATGTTACCTATGCAACCTACCTTCCTAAACTTGGTCTTTA +TCCAGAAAGAAAACATAATGAATTTGTAAACAGAAACTTTGTGGTCAAATATGAAGTGAA +TTGGAAAACGTACGAAATTAAAGTAAAGGGGCACAACTAATATGAAATTTAAGAATATAG +TCAAATCATCAGTCGCTACATCAATTACATTAATCATGCTATCAAATACAGTTGATGCAG +CTCAACATATCACACCTGTCAGCGAGAAAAAAGTGGATGACAAAATCACTTTGTACAAAA +CGACTGCTACATCAGATTCTGACAAATTAAAAATTTCTCAAATTCTAACTTTTAATTTTA +TTAAAGACAAAAGTTATGATAAAGACACATTAATACTAAAAGCTGCCGGAAACATTTACT +CAGGCTATACCCAACCCACTTCTGATAGTAGTATAAATTCACAATTTTATTGGGGAGCTA +AGTATAATGTTTTTGTTAGCTCGGAGTCCAAAGATTCTGTAAATATTGTTGACTACGCGC +CTAAAAATCAAAATGAAGAATTTCAAGTTCAACAAACATTAGGTTATTCATATGGCGGAG +ATATTAATATAATAAATGGATTAACTGGTGGATTGAATGGGTCAAAATCATTTTCAGAAA +CGATTAATTATAAGCAAGAAAGCTACAGAACTACGATTGATAGGAAAACAAATCATAAAT +CAATCGGCTGGGGTGTCGAGGCACATAAAATCATGAATAATGGTTGGGGACCATATGGCA +GAGATAGTAGTGATTCATTATATGGAAACGAACTATTTTTAGGTGGCAGACAGAGTAGCT +CGAATGCTAATCAAAATTTCTTACCAACACATCAAATGCCCATATTAGCACGTGGTAATT +TCAATCCAGAATTTATAAGCGTACTTTCTCACAAACAAAAGGATGTTAAAAAATCTAAAA +TTAAAGTGACTTATCAAAGAGAAATGGATCGGTATGAAAATTTTTGGAACAACTTGCACT +GGATAGGTTATAATATTAAGAATCAAAAGAGAGCAACACACACATCAATTTATGAAATTG +ATTGGGAAAAACACACGGTTAAATTAGTAGCTTCGCAATCTAGCGAATAAACTACTTCCT +AGATACCGTTGATTTTATAATAGGCTATGATTCGAAAAGAAATCTAATTACTCAGATATT +AGGTGACTTATGGGTAGAAATCAGTTAATATAAAATTGTGGTGAGCCTTTTCTTGGCGAG +TGCATAATGCATTCGCCTTTTTTATTTACATTAAAAAACAATTGTGGTATTATTTCTACA +TACTTTATTTAACATTTCTCTCTCAAGTTGAAATTGCGAGTAGTAGGCAGGTACTTCGGT +ACTTGCCTATTTTTTATGTTATAATTACATGTGTATATAGTAGGAGTGAACTATATAGCC +CGGCAGAGGCCATATATCTGACTGTTGGTCTCACAGGAGACATCTTCCTTGTCATCACTC +ATATACATATATCTTGCTAACATAGAGTTGTTATAGTCGCTACGCCACCCATACTAGTTA +CTGGGTGGTTGTTTTTTATGTTCGTATTTACGTTCGTATGATTTTTATTATATCCTATAA +ATAATATTGTATTAAATGTAAGGTGAAAGGGGTATAATAATGTATGAATATGAATCAAAA +TATCCAAATCCTAATGATTTTCAATGTCCTCCAAAAGAAGCAAATTTCGCTGAAGGTATA +ACATTTTATAAATGTAGCGACACATATGAATTGCCAAGCCAGTACATGGAACCTATGATA +GAAAAAGGTTCAAGATTTCCTAAAAACAATGAAGAAAGATGTTTAATGTGTGGTCATTCT +GTCTTTGTGGATGATAAGGATATATTTGAATTGATTAACAAAAAAGGTAGAATAGCAAAA +GGAATAAAAGATAAATGGAGATTTGTCTTTTATTTTGAAGGAAGCCAATTTAGTAAATAT +AAATTTACACCTTCAAAAAGTAATAAAAAGCACTATACATATTGGCATTATGGGAGTAAC +GATATAATATATAGCTATAAGAGTGCTATAAACGAATGAAAGGAGTGGTGATATGACAAT +AGTATTCTCAAAATTAATTGACGTATTTGATGAATTCATGTATCCCACTTTCTTTTCATA +CGAAGCAAGAGTGGGTGAGAAAACTAAAATATTTATAACTTTATTCGCATATTATGATGA +AAATAGTAGGAAAGACTATTTTTTTAATGTGCCAGTAAATAAAAAGAAATATGAACAACT +TATAAATGGTGAAATTGAAATTAGGTCTTTGTTTGTAAACAATAAAGATGGTTTTTTTAC +AGAAGGTTCACCTGAAAGTGTAGCAATTATAGAACCTATACATTTAAACGTTAACACTGT +CGATTATTTACCAGAAAAAAATTTATTCATGGTATATGATGATGATGAATTTTTGATTGT +CGATATAGAAGAAATGAATTCCGAGTTAGATAATAGTGAAACTGTAGAGAAATTATTTGA +CTTAAACATTGGTAAACAAATAAATTCATCAGAATATAATAATAAAGAAGGTTTAATGAT +TGCTTTTAGTAATGATAATCAAATTATAAAAGCAGATTCGTTAGGAGTATTGATAACCAA +GACGAGTGAATTGTTTAATAAAATAAGTAATAATTTATTAAATTTAAATGTAGTTAAACC +TTTTGAAAGTAGTTTTGGTATTTCTTTGGAATTTGATTCATTAAATTTAGACATTAATGA +TAACGAAATATATATCAATAAGTTTTTAAACCTTCTAAACTTTGTTTCTAATGATAAAAA +AGAAGATTTTTTCAATGAATTTTTAGGGTTGTACTCTATCAAAGAAAAAGATGAGTTCTT +AAATATTCTTAATGAATTAAGTTCTAATGACATAGAAATGAAAAGTATGTATTATAACAA +TATAAATGGAATTTATAAAGGCAGTATATTGAAACCATCAGAAGCCAAAAAATTTATAAA +TAGAGTTTATAATACAACAGAAACAAAAGAAACTTTAAATATCAATAATGCAACTATATA +TAAAATAGATGTAAAAAATAACTCATTTGGAGTTATAATCGATAATGATATTTATACTGG +AAAATTAGGAGAAAGTTTACAAGACAAAGAAGAAACACAATTTACTGTTCCTTCAGAAAA +AAATGTTGTTTTAACACAGATATTTAAAAAAGACGAATTTACTAAAAAAGAAAGAAAGCA +TTACATATTAGAATCTATAAACTAATTCACACCCACCACACCCTAACCGGTGTGGTTATT +TTTATTCTCACACAACCAAAAAACCACACCACCTATTAATTTAGGAGTGTGGTTAATTTT +TATATGTGAAGCTAAAATAACTACAAATGATACCATTTTTGATACCACTTTGTTGTAAAA +CAGAAAAAAATAAGGAAAACAAAAAAGACAAAAAACGCATTAAATCAACGTTTATTGTCT +CATGAAATTTAAATGTATGTTGATTTGTCAATTTAAGTGCAACAGTTCATCACATAAAAC +TTCATAAGGAAACTTCCAATTTAAACACTTTCTTGGTCGATAATTAATTGAGTCTAATGC +ATAGTTAAGTTGCTCTTGATTTACTTTAGCTAAGTCTGTTTTCTTAGGGAAAAATTCTCT +TAGTAAACCATTGGTATTTTCATTTGTACCTCTTTGCCATGCGGAATATGGATCAGCGAA +GTAGACATTAATATTAAATTGGTTTTCAATATTTTGATAACAAGAGAACTCTTTCCCTCT +ATCGACAGTAATAGTTTTAACGGCACCTTTAGGTAGATGTTTGATAAGGTTATTAATTGC +CGTCTCCATAGAATTAGAGGAACGATCAGGCATAAGTACACAATAATAATAACGTGATTT +TCTTTCTGCGAAAGTAGCAATGCACCCTTTACTTTTGCCTCTGCTGGATACAATTGTGTC +AGCTTCCCAATGACCGAATGTATTACGTTTCTTTATTTCCTTAGGACGTTGTGAAATAGG +ACGGCCAATATTAAACTTACCTCTAGTTTCTTTAGGTTTCTGTCTTTTTCCTTTTTGACG +AAGGCATGAAATAAGTTCGAAATTAATCATATTAGAGTTAATCCATCGATAGATGGTTTT +AAAACAGATTTGGTTTTGTAATAGACGACCTACGATTTGTTCAGGAGACCAGTGGCATTT +TAAATAATATTTAATGATATTACCAAGTTCTGGAGTAAATCGAGTAGGACGACCACAAAG +TTTTCTTTTGGTTTCATAATTTTTTTGAGCTGTTTCAGCTTGATATGACTGATTTAAATT +ATTCCTACTAATTTCACGTGAGATAGTAGATACAGATCGTTTTAATTTACGTGCAATAGA +TCTTAAAGAATAATTTTCTTGACGTAAAACCTCTATACGTGCGCGTTCAGTTAGTGTAAG +ATGGTTATAGCTCATGTTGGCACTCCTTGTATGTGTTTTTTTGGTTATTAACATCTTACA +ACAAAGTGCCAATTATGGGCATTTTTTATGAATTTTTATAGGTGTTGCACTTAATATTAC +AATCCGTCGTATATAAATTTCACTTCCCATGGGATCTTTAATTTTACCAATGATAGATTT +TAAACCGTCACGCATGCTTCCAAAGATGTTACGCACTCTATTCCATAAGCGACCAGCTAT +ACCTACCGTGTTATCTTTAATAGAGTTCCAGATGTTTGACATCCAATTTCTTAATTTAGT +AAATACATCTTTCGTCGCATTCCATAAACTTGTGAATTTAGACCTTACACCTGTAAATAA +CGAATGAGCCTTGCCGACGGTATTGCTTTTGATATTATTCCACGTACTAGATAACCAGTT +TTTCATATTAGTGAAAATAGATTTAACACTATTGAATAAAAAACCAAAAATACTTTTCGT +CGCATTCCAAATTGCCGATAAAGATTTTGTAAAGATGCCTTTGATAACACTCCAGATACC +GGATATTAAACCTTTAAGTAATCCACCAAAGTATCTCACTACACCTAGAATTTTACCTAC +AAACCACAGTTGTATTAAATTCCAAATTAACTGCACAGTACCATTCAGTATCATTACAAT +GCCGTCCCAAACGCCTCGCCAGTTTCCTGTGAAAAGACTAGAGAATACTTTGATAATACC +CAAAATAATATTAATAGCCCCTTGTATTACACCTTTGATATTTTCCCAAGTGCTGACAAT +CAAAGCTTTAACCGCCGGCCAAATAAATTGCATCACTTGCCAAATCGCAAACATAATTGG +TTTAATAATAAAGTTAAAAATAAATTCAAAGGTTGCTTTAATGAAACCAGCTATATTTTG +CAAAGCTTGTGTTATTTCTGAGCCGTTCTCTTTCCAGAAAGAGGCTAATTGAGCGCCTAT +CTCTTTGGCGAAACCAACGATTGCATCAACTACTTTAAAGAAAGTTGTTCTAATCGTATT +AACTACATTTTGTATTCCTGCTACAGTTTCGGGTGGAAATATCTTCTCTAGGGTAACCGC +GCCTTTACTATCACCTTTGAATAAATCAAAGAAACCTTGTAATGCTAGTTTAGCTGCTTT +AAATGCGTTTGCTACACCAGAGATTGCCTGATTTACAATATTTCTAAAAGTTTCTGAACG +TTTATAAGCTTGATAGAAAGCTATGCCAATACCAACTAATACACCTACAATTAATGTTAT +AGGTAACGTTAAACTGGATATCGACACACCTAAAACCGGAAATAGTTTAACAAGGGATGC +GATTTTAGTTCTTAAAAACGCGAATATACCACCAGCTTTATTAACGTTTATTAACAAGGG +TCCTAAAACTGTCATTGCATTCCCCATCACGCTGATAAATAAACCGAACATAAAAACTAA +TGGACCTAAAACTGCTGCAAACAATCCAAACCCAATAACCGCTAATTGAATTGACGTTGG +TAATTTAGTAACCCATGTCACTACTTTGCTAAAAGCACTTACTATAATCTTTAGTGCTGG +TTCTATTCTGTCATAAATCGTTAAGGCTAGTTCTTCTAATTGCGACCTTAAAGTTCTTAA +TTTTCCACCTAAACCAGATTCCATTGTATCGGCCATTCTTTTAGATGCGCCGGTAGATGA +ATCTATAGATTTGGTTAACTTTTGATAGTCTTCATCAGAAGCATTTATAATCGCTAATGC +TCCTGACATCGCTTCTTTACCAAATATTGTAGCTGCAGAACTAGCTTGTTGGTCTTTTGA +AAGATGTTTAAATTTTTCCCTCAGTTGGTCTAAAAGCTTTCGCATAGGAATCATTTTCCC +ATTACTATCTGTAATAGATATTCCTAAGCGTTCCATTTCATTCCCCATAGCTCTAGTTGG +ACTTGAAAGATTGGTGAACATTGTTCGTAACGCTGTACCTGCTTTTTCACCTTTGATACC +AGCATTACTCATTAAACCTATTGCAATAGATGTATCTTCAATCGTGTAACCTAACGCACC +TGCTACAGGAGCGACATATTTAAAAGCTTCTCCGAGCCCTCTAACGTCCGTATTTGCCTT +CGAGCTAGTTTGTGCTAAAACGTCCGCAAAATGACCACTATCCTTTGCTTTTAAACCAAA +TGCCGTTAGTCCATCTGTAACAATGTCACTTACTGCTCCCAGTTCTTCGCCAGATGCTGC +CGCTAAATCCATAACTCCGCTTAAACCTTCCATCATTTGCTTAGAATCCCAACCAGCAAG +TGCCATGTAATTTAATGCTTCAGCCGAATCTGATGCACTAAATTTTGTTGTTGCACCCAT +TTCGCGAGCCTTTTTCTTCAAAGCTTCAAACTCTTCCCCAGTAGCACCTGAAGTTGCTTT +AACTTTTCTCATACTGTCATCGAATTCAATACCTTTTTTAGCTGCTACAGCAAACCCAGC +AACCACCGGCGCAGTTACATACATAGTCATGTTACGGCCTACATTTTTCATACTGTTACC +AATTTCTTGAAGCTTAGGACCAAAATTATTAAAGTTGGTCCCAAGTTTTCCCATTGCAGT +ATTTAATGCTTTCTGCTCTCTTTGCATGTCTTTTAATTCTTGTGTGGCTTGGTTTAACTC +TCGCTCATATTGGTTTAATTTAGCGTAAGCTTCATTGTATTTAGCAGCCGCAACTTGTGT +CTTTGCACTGTTTTCACCAGTTTCTTTACTAAGTTTGTCATAACTATCTTTCAGCTCTTT +AGTAATCTGGGCTTGAACTTTTTGTTTTTTACTCAAACCTTCGACTTTTATCTTCGACTT +TTCTAATGAATTATCATATCTAGAAAGTTGTGATAAATTAGCCGAAAGCTCACGCGAAAC +CATTTTCATTTGCCTATTTAAACCTGTCACACCTCTATTGAATCCAGAACCATCTAAATC +AACCTTTATGACCATATTACCTATAGGATTAGGCATTTAAAAACCTCCTTTCTTCCAAGA +TGTAAATAAAAAAATCAACCTTTAAAGGCTGATTAAAAAATATCTTTAAAACTTTTCGCA +GTTCGCTTTGTTTCAATCTTCGATTCTACAATGTCTAAAAAGAAGTGTATCGGCATGTTA +GCCACTTTTTCTGCATCCATGCCGTTTTCTATCAAATCTTTAGCTATTTTCCTGTAATTG +TTGTAGACAGCTTCAGGTGTTAAATCTTCTTTTCTTATTTCTGATTCTCTGTCACGAACT +TTTTTGTATCGCTAGGTTCCCCACCTGTAATTCGTCCAATTAACTGTCCAATCTTTTCAA +TACCTTCTTGACCATTTGGTAATCCTTTTTGAAGTTCTATACTAGTAAATTGATTATCAA +AAGCTTCAACGATGAAATCCAAAACTTCTTCTAATACTTCCATTTGTACAGCCATGTTGT +TTTCGTATTCTTCTTGCTTGTTTTTGTATTCTTCCTGTTCTGTCACACTTAAGTTATTAA +ATTCTTCTTCTGTTAGATCTTTAAAATCAGCCCCCTTAAAGGCTTTGTTAAGTTTCAAAC +CTAATTTTGAACCTTGAATTGTTTCAAACAAAGTAATAATCGGCTTTGCTAAATACTTTT +GATATTGCGGCTTTCCTGTTTTTGTAAATCCTGTAATTAATTCAATTGATGTACGTTCCA +TTATTAAATTCCTACTTTCTTTTTAATTTGGCCAAAATAAAAAGAGGGCGTTAAGCCCTC +AAAACTTACATTTCTAAATTAGATTGTACTGTAATTTGCACAGTATCAGTTTGCTTTCCT +GCAGTCGCTGTAACGGTCGCATTACCTTCCGCCAAACCTTTAACGAGGCCAGTTGATGTT +ACGCTAGCATACGTTTGCCCCTCAGTCACTGCAAAAGTTACTTTCTGTCCAGATGGTTCG +GTTGTGGCTGATAGTTGTTTAGTAGCATCAACTTTAACTGTAACTTGTTCATCAGTGACG +TTTACAGAAGTGACTTCAACTTTTTCTGTTTTTTTCATTTCTTTTTCTACAGGTTCCATA +TTTTGTTCTCCTCGACTAGACATGAATTCATCATAAGTTTTACCAAATGTTTCCATGAAT +ACATAATCGCGCCCTGTAGTGCTTCCTTTTTTATCATAGCCAGTAACATGCGAGCTCTCA +TCAAACAAACGATCAATAAAATTGCCTTCTACGTCGTCATTCTGGAATTCAACTTTATCT +TGTTTTGTTTGCCCTTTGATGCTTGAACGAGTGAATTTACCTTTGAACAAGCCAACCCAT +TCTGAAGACTCATCATGATTACCGTCGTTCAAATACAATCGCTACATCTGGCGGGATATC +CTTAGCTCCATATTTATAACCACCTACACCTTTTTTAGCGCCATTCAAGAACGCCTTATC +GTCAGCAGGAACAGTAACAAATGTTGTCTTAACACTTAGTTTGCCATTAGATACAGCAGT +TGCTGCGACCATATCATCTCCATAATCTTCCTCGGTATCTTGTGGACGGTCTACTTCAAT +TTCTTTTAAGAAACGAATACGTGTGCCAGCTCCAGTTTCCCATTCATTTTCTGTATCTTT +TAAAATAGGTGCATAATAAAAGTTTGATACCCCAATTGCGATACCCGAAACTCCTGTATC +TGCAAAATGTTGTAAGTTTAATTTTAAAAATCTTGGTGCTTGTTTCAATTTTTCAATCAT +TTAATTTTCCTCCAATTTCATTGATAAAATCGAGCCTTTTGCTCTTATAATATGTCTGAA +TGACATGACGTCACTCTCGTATAACGGTTCTCTGTAATAACATTGAAAATTTATCACTTT +GAGTAAATCAACAATTTTTTCTGCTTGCTCGTTCGGTTCATCTTGAGACCACCAAACATC +AATTTGGTAATGGTATTCTCTTGAAATCTCGTTATCATCAGCGTATGTGTCAGGATTGAA +CGGTAAGGGATATATACGAATAATAGGCTTGTCAGTTTTTTCGTGAAAATGGTCATCTAT +AGTGTAGTTAAACACATTCACTTCATCTGTAATGTTATTTGCAATAATAGCGTTTCTAAT +TAATTTGGTAACATTAATCATTTTTGCAACCTCTTAGCAGTATCAAGCATTGTTTTTAAA +ACTTTGTTTTTCCCTTGCTTTTCTGTTTTTGTTATAAACAATTGTGGTTTTTGGTACATT +GTTCCAAATTCTGTTGCATGAATACGATGTGAGACGCCTTTAGCGTAACCAATTGTAACG +ATTTTCTCACTTGTGTGTCTGTCTGTTTTCACATTAGAAACAGCTATGTGATCGCGAGCA +TGCTTTTTAGTATTCGCAAAAGGTGTATTACTTTTTAAAAGTGGGACTAATGACATAGCC +CCAGCTTTGACAATTACATTACTATTTAAATTCATTTTTAAAACTGCATTTTTCAAACCT +TGTTCAATATTATTACTTTCAATTCTTGCTCCCATTAAATGACCACCTCGCCATAGATAC +GCAAATAAGATTTATCTTGATAATCTGGCTTTACATATTTGATGTTAAACCTTTGCCCTT +CATGCAAGACGTAATGCTTATTTGTTGGTTTATAATCACCTCGTGTATCTCTGATAATAA +TAGTTTTAATGAATTTGCTACCTGTATTGAGATTCGTTTGAGTGTCGGATTCTTTAGATT +CTTGAATGCAAGCGAAACAAGAGTATAATATTTTCGTCTTCGGTTTCATCGGATTTCTGT +TCACTCTCTCGCTTACATCTTCACAAAAATCTATACGTTCGAGCTTGGGACATTAAGTTC +TTAGGCAATGTAAAAAAGCTGATTTCTATTAATTATTTGATAGAAATCAGCTTTTTTTAA +ATGTATTTGATAATATACAGCTCGTCGAGCTACTATTTTCCTTATATTAAGTGCCATTAA +TACAAAACCTAGCTCTCGTTTAACTTTATTTATTCCTCGAACTGACATTCGAGTGAAACC +CAAAATAGCCTTCATAAATCCAAAAACAGGCTCTACATCAATTTTTCTTTGACTATAGAT +TTTTTTCGTTTCTGGTTCAGAAAGCTTTTGATTAATTTGGGCTTTAAAGTATTCCCAATT +ATAATTCTTCATGATTTTCTTATTGGATTTCGAATTTGGCTTCATGCATTGTTGCCTCAA +AGAACATGCTGAACAGTCATCGCATTCATATAGTTTGAAGTCACGTTTAAAACCATATCT +ATTATTACGGTATGCATATCTTTTAAAACCTATTCTTTTGTTATTAGGACATATAAATTC +ATCATTAAGTTCGTCATATTTCCAGTTTTGAGTGTTAAAAATGTCACTTTTAAACTTTCT +CGTTTTATCTTTAATAAACATACCATACGTAATAAGTGGCGTTTTATTAAAATCATCTAT +AATAGCCATATAGTTTTGCTCACTACCATAACCTGCATCAGCCACAATATACTCCGGTAA +ATAACCGAAGGTATTTTGAATCATTGTTAAAAATGGAATTAAAGTTCTAGTATCTGTCGG +GTTTTGAAATAGGTCATAGGATAAAACAAATTGAGAATTTGTCGCTATTTGTAAATTGTA +TCCTGGCTTAAGTTGGCCATTTTTCATATGGTCTTCCTTCATTCTCATAAAAGTTGCATC +ATGATCAGTTTTAGAAAAGCTATTTCTATCTTTAAGAATCGATTTTTGTTCTTCATATTT +ACTTTTTCTTTCGGAATAATCATCAAATTTCTTTTTGAACTTCTTAATCTCAGTTCTTTT +TTTACGGGTCTGTTTTCTAATTTGAGTACAATCTTCGTTCTGAATAGAATGATTTAAATC +TTCGATTTCTTTATCTAAATGACTACCAATTAAATCTATTTCTTCTATTGTTAAATCGCT +ATCTCCATCTTCTTTTATCTCCGGTATTATTTTTTCTTCAACTAAGTCACGATATAATGC +TTTTGAATTTTCGTTCAATTTCGATTCGTGATTTTGAATACTTTTCTTCCACACAAATGT +ATACCTATTGGCATTAGCTTCTACTTTTGTACCATCAATAAAAATTGAACTATCATCAAT +AAGATTTTGCTTTAAACATTGACTATGAAACTGAATAAATAAAGATTCAATTAATGCATC +AGTATTAGGATTTACTCTAAAACGATTAATAGTTTTATAAGAAGGTGTTTGATTTTGAGC +TAACCACATCATTCGAATACTGTCATGAAGTAATTTCTCTATTCTACGACCAGAAAATAC +AGATTGAGTGTATGCATATAAGATAATTTTTAACATCATTTTTGGATGATAGGATGTTGC +GCCACGATGATGTCTGAATTCATCGAATTCGCTATCAGGTATCGTTTCAACAACTTCATT +AACATATCGTGAAATATCATTTTGAGGAATTCTAACAGAAGTTTCTATTGGTAGTGTAAG +TTGGGTCATGTTATAATTTTTATACATAAGGCACCTCGTTAATTTAGTTTAGTGGTATTT +ATTAAATTATACGAAAGTGTCTTATTTTTTTAAAGTATTTCAAAGTAAAATTACATGTTA +ATACGTAGTATTAATGGCGAGACTCCTGAGGGAGCAGTGCCAGTCGAAGACCAAGGCTGA +GACGGCACCCTAGGAAAGCGAAGCCATTCAATACGAAGTATTGTATAAATAGAGAACAGC +AGTAAGATATTTTCTAATTGAAAATTATCTTACTGCTGTTTTTTTAGGGATTTATGTCCC +AGACTCTTCATCATTTTCACTCTCCAAAAATTGCTCAAATGAACCTCTCAATTTATGCAC +CGTACTTAAAACCATATGTGGCGCAAGCGATAAATCCCTATCCAAATAAGCAATACGGTT +TTCAAAATAGTAACTTGCTAAAGGGTATATAGCACGAGCAAATAGAGGATGACTTTTAAA +CCAATCAATATATTTACTTGGTTCATCCGTAACAGCGCTAGCTATTTCATGGAATGCCCA +AGAGTAATATATTTCTAATAAGTCGTCCTCTGAATTGTGATCTATTTTGCAATGCTTTTT +TAATAACTTAAGTTCCTCAGCTGTTAATTGCATTCAATCACCTATTCTTCTTTTACTCTT +TCAAGTATTACTCCATGCTCTTTCAGCTTTTTGTTAACATATTCAGCACGTTTTACTGTC +ATTTCAACACGTTTACCTGACTTTAAATACTGGCCTTTTTCCAAGTCAGTATAAGATTTC +TTCACTTCATACATTGCCATAGTTTATCACCTCTTTATAAAGTATCGAGCGCTTATTATG +CTTCTAAGCCAAGATCGCCTTCACCGCGTTCACTATCATCATATTCAATCACAATTGCTG +ATTTATAATCTAGAATTCTACAGTCTTGACGTACAGCAATCATTAAACATTCTCCGAAAT +GCATGTAGTCAGTCCATGATGCTTGGTATTGAGAGCGGTCAAATAAAACAATCGCATCTT +TTAAGTTACCGATAATCAAAGTGTTATTACCTTTTTGCCCTAGTACTTCATCAGGTAAAA +TTTCGATTTTAGCTCCTAATAAACGCTGTTGCGTTTTTTCTTTAACATCTGGCTGGATTA +AATAGTTTCCTAGCTTATCTTTCATTTTGTCTAATTTTGCAAACATAGTTTGCGAAACAA +TCGCAACATTATGTTCGTAATTTGGCTTAACATTCAGGTTAATAGCATCTTTAATATCAT +CTAAAGATTTTGCTTTTTTAACTTCTAATTTCTTGCCTTCTTTTTCAAAACCTGAACTTG +TAGAACCCGTTGATCCTTTAGTGATAACATCAATAATTGCTTTGTTTCGTGTTGCTGCAA +TAGTTCGCGCCATCCATAGTTTCAATTCTTGCAAAACATTCACTTTTGCATCTTCGATTG +CTTCACGTGAAATTCGGAAGTAACCACGGTGTGTATTAATGTCATATGCTAATTGGAAGA +ATGGTTTAACTGCTAATTCAGGGTTTTCTTCTAATTCTTCAACTTTTTCAAGGGCTGCAA +CTTCTGATTGTCGTACTACCGGATATTTACCAGAACCATTTGTAACACGTTTGACCGTCA +CATACTTATCAAGATTAAACTCAACCTCTTTTAATTTTAAAATATCTGTAACAATTTCCT +CTGGAATAACTACAAATCCTGAGTCTGTTTTTAACGAACCACCTTGAATATCATTGCGTG +TTTCAAGATATTCAGTAAAATCTCTAACTTCTTGTGATGTTACCTTTGTGTTTTGAATCG +AAATACCTAAATCATTAATGTTTGCTTGGTTTCGATAAGTACGTGCTTCGTTTACTTCCA +CTGATTGTTGATTGTTTTCTGAAGTTCTATCTTTTTCTTTTAGCTTATCTAATTCTTCTT +GTTTTTCTTGGATTTGAGAACGTAAATCAGTAATTTCTTGTTCTAATTTTTCTGCTTTTT +CTAACTCATCGTTATTAAGTGCTCTCGTTGCATACTTCACCTTTAAATCAATTTGTCTTT +TAATGTCTGAAATCTCAGATTGTAACTCTTCTTTTGTTTTCATTTAATTTCCTCCTAAAA +TTGGCATAAAAAAATAGACATCGCTATATTCAGCATGTCCAATGGCTGTATTTGATAATG +GTGTTCAACTTCACCAAATATTATTTAATATAGAGTGTTTCTTTAGTCTTATTTCTAATT +CTTTTTTACGTTGTTCTTTTTTAACGGTTTCAATACTACGTAATGCTGGTTTAACATCAG +TGTCTTTGTAAGCCGGATAAGTCACTACAGAAACATCTGTAAGTTCACGAATTGCTGTTA +AAGTACGTTTGTAAATGTTTTCTTGTTCATCAAAACGCACTTCATCGCCTTTATCGTCAA +GCATAAAACCAAACGAACATTGATTGATGTTGCCTACACGCATGTTCTCATATAAATCAC +GTGCAAATGTTGTGTTTGGTAACTTACAACGATATTTAAGTCCAACATCATCAGTTTCGA +GCTCCAAAGTACCCGATTTTGTCCTACCAATTATTTGCGATGGGATATGATCTACTAAAC +AACGCACATCAGATAAATCAGTGTTTTCTAAAGCACGACGTGAAATCGTTTCTTTGAATC +CACCAAGATTTTCAGACCAAGTGTCAAACTTTAACGCATACCCCTCTATGACCATTTCGT +TGTTATCATTTGAGCGTACCTCAATAATGTTGCCAACTCTCGTTTCCTTACTCATTTTCC +TCACCACCTTTCAATTTTTTATCAGTAGCTCTCGATTTATTCATCTGATACTCATCTACA +AGTTCAATATTTACATGGTTTAAATCGACTCTGTGAATGCTACCATTACCGCCTGGTATT +GGCGCTAATCCATCACGTTGTCTAATTTCATCGATATTCATCTTTCCAGAATCAATGTTA +ATTTTGTCAATTTCAGCTTGTGTTTTTTCATCAACAACTCGTATTTCAGTGGTATCAAAT +TTAAATTCACGATTCACATATTCATCATTAAACTTAAAATTCAATTCTGCACAAACGCAT +GTAATATAAGGTTTTAAAGTTGATAAGTAATCTAAATTAGCATCCGTGATACTCATGTTC +GCTGTTTCTATGCCGAACTTATGCAATGGAATACCAAATACACCTGCTATTTCTCTTGTT +GATGATTTGTTTTCTCTGATAAGCTTTAAAACTTCTGTATCAACTTCTAATTGATCAAAC +GTCATTGATTCATCGAGTACGACAACTTTCCCAGCTTGTTTAGTTCCACTAAAACTTTTG +GGAATTCTTCTCTGGCACGGTCTCTTGCTTTTTTATTATCTAATACACCTTTCATTTTCA +AAATACCACCAGCATGTGTGCCATTTCGCAGGAAATTATTAAGGAAATCTTTTCCATTGT +TATCTGATTCTATCGTGCGACTTAATGTGTCTAACAGTGACAAACCATTTATACCGTCCA +ACGAATAAAATTTGATGTCTAGCATATCCTCGAACTTAACATTACGTTCTATATTATTTC +CGTTACTGTCTATCCTTTGATGAAAATAATACAGTCGACCTCTTGCGTCTGATTTCAATT +CTATTTCGGATGTCTTTCTGAACGTTAAATTCATAGGTTCTCCTGTTTTATCACGTGTAA +TTTCAATATAGCCGTGCGATGTTAGTAAGGCACTAACAAACACTACTAATTTGAATATAT +AGCCGTTATACATTGGGTTAGGACGTGTATTTAACAAATTAACAATCCTGTCACTATAAT +TAATTTGGCCGTTCACTGTCACCCTAATTGGCATGCGTGCCAAATCAGAAGCAATCATCA +TAACTGCAGTAAAGATGTCGCTATGCCTAATTGCTTCTATATCTTTATATTGTCGTAATT +TTGTTCCTTGAAAACTTGGCAAAGTTTGAACCATCATTTGCAAATCATCTTCGTTGTATT +GCAAGTCTCGTTTTTCATTTTTATAAAAAATCCCCACAACTACTAACTCCTTTCTTGATT +GCTTTCATGATTTAAAATCAACGAAATAACAATCAGTGTTATACCAATGCATAAAAGTCC +TATATTTTGACCGAATGCTTTATACACAGAAACATTAACCACAAACAAACCTAATAAAAA +AAGGATGCTAACCAAATTAGCAACCAAGAAATTAAAAAAGACATTTATTTTATTCAAGTC +CATTTTGTCACCACCTTTAAAACCCGAATTCTTCGCTTTCATATTTCTCCGTCCAATTTT +CTTGGAATTCGTGCATTCTAGCTTCAGTGAAAGCTGTGATAATCGAAATAATCGGATCTA +TTTTTTGACGATTCATTTTTTTATTTATTTTCACATTGTCTTCTCCGTCACGAATCAAAA +CGGCATTATTAACTGATGTTGTAAGTAACATATTATCGTTATGCTGTATTCTTTCATCTG +CAACCCACATTCTAAATTCTTTAATAGATTGTGATAACGCCTTAAAACTTTGTCCCACTT +CAATGAGTGGCCAATCTAAAGCCATTGATTCGATTGTTGTTATAAAACTTTGCGCATTCC +AAGGGTCATAGCAAACAGCCTGTACATTCAGGTCATGCGTCGTTATAAATTTCACTATAA +AATCGATAACTTGTTTATAATCAATCATGCCGCTATCTGATTGTGTAGTCTCAGCTTCGC +CACGTTCAATCGCTAATTCATAATTTATTTTGTCTCTCTTAGATTTTTGTTCTAAGTTTG +TTCTTAATCCAATGAAAGAATGACTATGTAAAAACACTTTTTTATCGTCGTTAGGGAAAA +TAAACCCTACAGATGTTAAGTCATCCAATCTCGATAAGTCGACACCTATATACACATCTT +TACCATTGATATTAGGCATAGGCGTTATTACTTGTTCCCAATCTGAAATATCTAGCAAGC +TATCTTCTCTTTGCGCTTGCCATAAATTGAAGTTTTTAATCAAAATCTTATGATATGATG +TCCCTTTTTCTAATTCGTCTTGTATATCAGCTTTTACATTTTGAAGTATAGTTTTTCTAT +GTTCTTTTGATTCTAAAAGCGGCATTGCTTTAATCCACTTTGTTTCATCTTGAACTTCTT +CTTGTGAATCCATTTCAGCACAATATACAAAGTAATTATCAGCTCTTACTTCTTCATTTA +AAATACGTTTAATATACTTATACTCTTGGTACATTTGACTATTTAAATTGTCTCCGGCCG +TTGAAACAAGTAGGGTTAAAGGATTTTTTTGTAATGTCATACCTGTTTTAAACCTTGAGT +ACATCTCATCATCAGGCATACTTGCCAATTCGTCCAAAATAGCAACTGTAGGATCTTTAC +CATCAACCGCATCTGGGTTATTGGAAAGAGGTGCAAACACTGAACTACTTAATACATCTT +CAATGTCTGTCTTTCTTACGTCTGTTTTTTCACGGATAAACTTGCTTTTACTTCGCATTA +GGTTTACTTGTTGGCTTGCCATCTTGAATATTGTTTGCGCTTGCTTATAAGTAGATGAAG +CTACATAAATTTGTCTATTAAATTTAGGGTATTGTCCAAACAACAGTTCGTTAACGGACA +TTCCCGATACGATTAGAGACTTACCTTGTTTTCTAGCCATACTTATATAAGCTTTAGTAA +ACATTCTGTATTGACCTCTACGCCAGCCGTATAAGCTCCCAACAATGAATTTCTGAAACT +CCATAAGAGGCATGGGCTGGTTTGTTTTAGGGTCTGGAAGCATTTCCACAAATTTAATTG +CTTTGTTAGACAAATGATTATCCCAATGGCAACCATTCGGCGGGTTCTCCATAAAAGATA +GGTGACGTTTACATACTTGAATATTCTTCAAACTTGCCAAAATTTCTCCTGAAACTACCT +TTTTTGCGTATTTAGTAACATAATCAGTCATTACTAATCACTCACAAATTCCATATATGG +ATCATCATCTTCTTTTTCATCAGGAACCATAATACGCAATCGGCTATCAATAGTTAATCC +TAAAGTATTAGCTGTTTGTTGCAATCGAATACCCGCTTTTTCCTTTATGTTGAACGCCGG +ATTAACCTTTTGATTTCCTTTGTCGTCTTCTAAAATCAAGTCTTCGCGCTCTAAAATCAA +ACTTGCTTTAACAAAGTCACTATAAAAACTACAATATTGTGCTAATTGTGCTTTATCTAA +GTTGGAAATTGGCAATTCTTGCATGTGCGGTAATATTCTTAAGTATTCTTGTTTCGCTAT +TTCATCTAAAAAGTGCGGTGGTTCAGTATCGATTTTAGAAAATTTATTTAATTGAGCTTC +TTGACGCTCTTTTTCAATAATTTCTTCTTTTGTATAATTCTTGTTCGAATTTGACAAAAG +CTTCTTAGGTCTACCCGCCATAAATTAGCACCTCCTACTAAAAAAACTTAAATAAAGGGA +ATTTTTTGAGAAGAAAACTCTGCTCCGTTCTCCAGAACCTTTCATTGACGCCCGTTTCAT +CTTTGGGGGGGCTTCCTATTTTTATCTTTTTTAATATTTCTTCAAATCTTCTTTTGTCTT +TTGGTTATGGCAAGCATCACACAAAGGCTGTAAATTACTTTTGTCTAATCTTCTTGCCCA +ATCAATTTTTGTTGGTACAATATGGTCAACCATAGTCGCTTGATTGCCACAAGAAACACA +AATAAAATCATGTTCTAACAATACAATTCGACGCATGTTTTGCCACGTTTTCGATTTATA +AAATCTTAAATACTCTGGATCGTTTCGACGTCTCAAATCATTGTAATTTTCATTTGCATA +TTGCTTGTGTTTATCACAATAACTTTCATTATGATTAATCAATACATTACATGTTGGATG +ACCACATCGCTTCATAATAGACAATGCACATCACTCCCTGTCGACTTTCTTAACATCTTG +CACAGTTACTTGTCTATCATCTTTATCATTGCTAATTAACAATAAGTTTCCTATCGATCC +ATCAACAAGATACTTACTACCTTGAAACAATACTTTGTCTCCTTGTTTTATACCATTGTC +TAAATTGATAGTCTGATTAGGTTTATTCATCAAGATAGTGGTAACACTATGACCAGCTAT +CTCATCCAAGTTAATACCTAACACGTTAGTAAGATTAGCTATATTCCACAATGCTTCGCT +AAGTTCATTTATCATAATTCCTTTATCTATCGGTACATTACAAAACATATGCTGTTTAAT +TAGATCTGTAACATTGCCTGTAGATTGAGTTAAACCTAAGCCGTAACAAGTAATAGATTC +ATTTAAATTCAATTCATCATTGTGTGTACGTGTAGCTATCTCTTGGTACTTTGATATCTC +CATTCTCCACCTCTTGTTTATAAAAATAAAAACCCTCACTTAATGTGAGAGTTCAAAAGA +AATATAAATGTTTTGCTACACAGCAATTATAATAAAAAACAATATGTAGCATCAAAATTA +GTACGATGTGTCCGAACTGTACGATGTGTCCGAACTGTACGATGTGTCCGAACTGTCGGT +TTCTTGTTGCAAGTTATAAAGTATATTTACTATATCTTTTACTCTAGAATAAAAATTGTC +TCTGCCTATATCAAGAATGCTCATGATCCTATTATGGCTTTCTCGTTGTTTTAACATTTG +TAAAATATGATAATCTTTTTCATTCGTGATGTATTCTTCATATTCATCAATGAACGCTAT +CTTCTTAATCAAGTAATCGTACTTTCTAAGCGCTTTGTTTTTGTTTATAACTTTCACTAA +CATTTTATTGCTAGTCGTGCCTTTAGCTTTTGGCATCGCAGATTGATAACCATATTGTGC +AATTGATGTACTTTCGTTATCGTAGACTTTACTGTCTATTATGTTCTTCATCCACTTGTA +GTTATCTATCATTTCACGTATTTCTTTCCTGTTATACATGCAATACCTCCGATAATATAA +ATTACTTTTTAATATCGTTATTCATTCGCTTTAATTCAATCCTGTATTCTTTTAACCCGT +TGTACTTCCCATGGATCGTTTTGAATTCTTATTTTAGGCTTGTTATTACGCATTTTATAA +ACTCCTTAATTGTTATTTGATACCAATATGATACCGTTTAATCAAATATGCTCATAGCTT +GATGTTTTTTATCAGTATATAAATGAGAGTACGTTTGAATTGTTTCTGTAATGTTAGAGT +GCCTCATTAATTCCATTAATAAATACATATCTACACCATTATTAATTAAATAGCTTGCGT +ACGAGTGTCTTAAATGGTGTATTTTTAGATTCGAGAATACAGATTTAAAATGATACGAAT +AAGTAATGTATCTAATAGGTTCTAAACCCCCGAATATAAAATAGTTTTCGTCAAAATATT +TATATCTTTTAGAAGATTCGTTATACATGTTTTCAAGCATCTCTCTAATTAAATTTGGCA +CAGGTATTATCCCTTTAGAGCTTTCTTTTTTAGATTATATTCAATTTTTCTATTACTTAA +ATTGATTTTCTTATTTACGTCAATTTCGCCTTTTATTTTATTGTAATCTTTCCACTGCAA +AGCTAAAGCTTCTCCTATTCTAAGACCAGAATAAAATAACAGTTTAGTTAGCTGACGAGA +AGTATCGTTTGTGATTTGTTCTACTTTTTCATCAAATTCTTCACGAGTGATAAATTTAGC +TTGTGGTTTTGTTCTGGGAATAGGAGTTACCGATAATGTGGGGTCGTATAAGAGCTTGTA +ATGCTTTTTGGCGTAATTGATAACTGCTTTAAAACCTGCCCACACAGATCGTGCATAGCC +AACAGAAAGACCTGCATCGTTTAACAAATAATTCCTGAAAGCAGTACATTGCGTAGTAGT +GATTTTGCCAATAGGGATATTTCCGAACCTTTCTTTTATGTGAGTATTGTATTCTGTAGT +TCGCTTTTCTATTGAGCGTGCAGAAAGATTTTCATTTTTTAAACGATCAAAAAATATATA +TTCAAAGGGTTGATTGTCCGAGTATCCATATTTAACATTTTGTATAAATTCGCTTTCAGC +TAGTTTGGCATCTTTCTTACGTTCAAACCCACGCTTCATTTTTCGTTTGTTATTACCGTA +TACATCTTTATATCTAATGGAAAAATACCATTTCCCCGTATTATCATCTTTATATACTGG +CATTTTGCTTCTCCCTCCTCAAAATTGGCAAAAAAATAATAAGGGTAGGCGGGCTACCCG +ATATTTAGTACTAGGTACTAAATATGTTATAATAAAATAAAAAGTAGGTGATAAGATGAC +TCAATTTCTAGGGGCGCTTCTTCTTACAGGAGTTTTAGGTTACATACCATATAAATATCT +AACAATGATAGGTTTAGTTAGTGAAAAAAACAAGATTATCAATACTCCTGTATTATTGAT +TTTTTCTATTGAAACATGTTTGATATGGTTTTATACTTTTATAATTTTTAATAATGTTGA +TTTAAAAAATTTGAGTTTACTTCAGTTGCTTACAGGTCTAAAAGCAAATATTTGGTTTCT +AATTATTTTTGTTTTAACAGTGCTTGTATTTAATCCTTTAATTGTTAAATTCATTATCTG +GTTAATTAATAAAACAAGAAAGTTTATGAATTTGGATTGTATAAGCTTATTAGACAAAAG +AGACAAGTTGTTTAATAACAACGGTAAACCAGTATTTATAGTTATTAAAGACTTTGAAAA +CAGAATCATTGAAGAGGGTGAACTTAAAACCTATAATTCAGCTGGTAGCGATTTCGATTT +ACTAGAGGTTGAGCGACAAGATTTCAAAGTATCTGATTTACCGTCAAACGATGAATTGTA +TATTAAACATACACTTGTAGACCTTAAACAACAAATTAAATTGGATTTATATTTAATGAA +TGAATATTAATCTTTTTTCTTAGCTTTTTCTGATAAAGTGCTTTTTAAGTTTTCGCTGGC +ACCCGGCTTTTCAAAACTTTTGTTTATTGGGTTACTACGAGTAGCTTCTTGTTTTTTGTT +TTTATCCGCCATAAAATTCTCACCACCATTCAACGTCTACACTTGTAGGCGTTTTTGAAT +TTTTTTAATCCTTTTTCTCGTCACGCTATATAGGTACTTTTAATCATAATTAAAGCCAAG +TTTATTTAAAATCTCTAAATAATCTGACGACTTTGCCCGTAATGTTTACGTCATTTATTT +TTGACATTGGGTAGCTTCTATCTTTAATGGTAACGTAATTAGATAATCGCTTTAGGGTAA +ATGTGTCATCTGAGTTAAATATAATTTCGCAAAAATATTCATCAGTTTCGGTTCCGTTCT +CTGGGAAGAAAACGGTTATTATATCTCTATCAAAGATAAAGTCGATTACATCATCATCTT +GATCTAAAATGTAGCAAACAGTCATATCGCCATTTTCAACTCTTCTTGTGCTATTTATAG +TAGTTATTGGTTGGGCAACTAATTTGCCTTTTGCCTCTGTGTATCTTTTTGGAAATTCCA +CATAATTCATTAAATCAATTGTTTTATTTGTTTCCATATTAGTTCTTTTTTCTATATCGT +TATATCTCCATAAGTATTGTTTCTCTTCCATCCCTCATCCTCCTCGCGCCACACAGGCGC +TGTTAATCACATTTTAGTTCTATCAGTGATTTTAGACTCCATAACTCTTTGACGTGACTC +TTTAGCTTCTCGAATCATATCTTTAAATTCTTGACTGTCTATAAAAGCTTTGGCTTCTTC +TATTTGTTCTTGAGTAAGCTCTTTGCCACCAGTATTGATGTGTAAGTGTTCAATTTCTTT +ATAAGAACTCATTTTTTCGACTCCTGTTCTTCAAGTTCACTTTTAGTTATAGGTAAACCA +TTATTCAACCTATAAGTCAGTTCTTCTTCTGTATAAAAGGGGATTTCAACCATTTCCCAC +TCTTCAATGTTAATGTCAACTTCTTTTAAATTCATTTTACTACCTCCTATAAAATAACTT +TTCCAACTAATCTCACACTTTCATTATCATAAAAATGTAAATCTTTATACTTTTTATTTA +AAGAAACCAACGTTAATCTGTTATCTTCTACATAAACCTTCTTTACGTAAGCATCTCCAT +TTATAATAAAGACGCCTATTTGTCCATCTTTGATAGTGTGAGATTTTTCAATGAATATAA +TTTGTCCATTTTTAAATAACGGCTCCATTGAGTCTCCATTTACTTTTAAAGCTATATCAT +GTGCGGGGACATAACCTCTTACGAATTCTTTTGAAATAGGTTCGTTATATAATCTTTCAC +CAATACCAGCAGACGCACAACCATATATATCCACTTCGGATTTTTCTTGAATGTAAGAAT +TGAAATCTACCAGATTATCATCACTGTCATTATTTTGCTCTTCTAATTGATTAGTCGCAT +ATTTTAGTACATTGCTTTGTCTTGGAGGCGTGAGTTGAGATGACACGTTATGAATTTCTT +CAATAATTTTCGAATCATCCATATCATGTATTAAATCTAAGGGTTTAACTCCAAAAACGT +TAGCTATTTCAGGTAATTTATCTAGTTTTGGACTTCTAATTCCCTTTCTCCATCTTGTGA +CTGTTGTTCTATTTACATCTACTAATTCTGCTAATTCACTATCACTCATATCTCTTTTGT +TCATCAGACGTTCTAGATTCGAAGAAAATGAACTCATATTTTTATCTCCTTTAAACATAT +TATCTAACTAATAACTTCATTATATGCCTACAGTTCCAAAAATGCAACAAAAAACATAAA +AATATGTGTAGAGGCAAAAAAATATGTAAAAAGCACTTGCAATTTTGGAACATCAGGTGT +AGTATTGTTTTCAGGAGGTGTTCCAAAAATGCACAAAGATTTATATAGCTTTAGAAAAGC +GGCGAAAAAGAACCAAGACTTTATGGGGAGTTTGATTGGTGTTTCGGGTCAACAATACGG +AAAAAGAGAACGCGGAGAGATTCCTATTAATTTAGATGAAGCGATGATTTTTTCTAAGGC +ACTCGAAACACCTATACAAGAACTATTTCCAGAATATTTTTTTATTGAGCGAGTTCCAAA +AATGCACAAAAACGAAATAACATCTTAAAAGGAGGACACAATGGAACAAATCACGTTAAC +CAAAGAAGAGTTGAAAGAAATTATAGCGAAAGAAGTTAGAAATGCTATAAAAGGCGAGAA +ACCAATCAGCTCAGGTGCAATTTTCAGTAAAGTAAGAATCAATAATGACGATTTAGAAGA +AATCAATAAAAAACTCAATTTCGCAAAAGATTTGTCACTAGGAAGATTGAGGAAGCTTAA +TCATCCGATTCCACTAAAAAAGTATCAGCATGGCTTCGAATCAATTCATCAAAAAGCTTA +TGTACAAGATGTTCATGATCATATTAGAAAATTAACATTATCAATTTTTGGAGTGACACT +TAATTCAGACTTGAGTGAAAGTGAATACAACCTAGCAGCAAAAGTTTATCGAGAAATCAA +AAACTATTATTTATACATCTATGAAAAGAGAGTTTCAGAATTAACTATCGATGATTTCGA +ATAAAGGAGGAACAACAAATGTTACAAAAATTTAGAATTGCGAAAGAAAAAAATAAATTA +AAACTCAAATTACTCAAGCATGCTAGTTACTGTTTAGAAAGAAACAACAACCCTGAACTG +TTGCGAGCAGTTGCAGAGTTGTTGAAAAAGGTTAGCTAAATTCAACGGTAAGGATTTGCC +CTGCCTCCACACTTAGAGTTTGAGATCCAACAAACACATAAGTTTTAGTAGGGTCTAGAA +AAAATGTTTCGATTTCCTCTTTTGTAACAGTTTCAATTCCTTCATATCCTGGAAAACAAT +TTTCTTTAAATCCGAAACATGTTTTTTTGAACCATCCTTTAAAGTAACTAGAAGTTTCAT +ACTTATCACCTCCTTAGGTTGATAACAACATTATACACGAAAGGAGCATAAACATTATGC +AAGCATTACAAACATTTAATTTTAAAGAGCTACCAGTAAGAACAGTGGAAATTGAAAACG +AACCTTATTTTGTAGGAAAAGATATTGCTGAGATTTTAGGATATGCAAGGACAGACAATG +CCATCAGAAATCATGTTGATAGTGAGGACAAGCTGACGCACCAATTTAGTGCATCAGGTC +AAAACAGAAATATGATCATTATCAACGAATCAGGATTATACAGTTTAATCTTTGACGCTT +CTAAACAAAGCAAAAACGAAAAAATCAGAGAAACCGCTCGAAAATTCAAACGATGGGTAA +CATCAGACGTCCTACCAGCCATTCGCAAACACGGTATCTACGCAACAGACAATGTAATTG +AACAAACATTAAAAGATCCAGACTACATTATTACAGTATTGACTGAGTATAAGAAAGAAA +AAGAGCAAAACTTAGTTTTACAACAGCAAGTAGAAGTTAACAAACCAAAAGTATTATTCG +CTGACTCGGTAGCTGGTAGTGATAATTCAATACTTGTTGGGGAACTAGCGAAAATACTTA +AACAAAACGGTGTTGATATAGGACAAAACAGGTTGTTCAAATGGTTAAGAAATAATGGAT +ATCTCATTAAAAAGAGTGGAGAAAGTTATAACTTACCAACTCAAAAGAGTATGGATCTAA +AAATCTTGGATATCAAAAAACGAATAATTAATAATCCAGATGGTTCAAGTAAAGTATCAC +GTACACCAAAAGTAACAGGCAAAGGACAACAATACTTTGTTAATAAGTTTTTGGGTGAAA +CACAAACAACTTAATAGGAGGAATTAAAAATGAACACACTATACAAAACAACCCTCCTCA +CCACAATGGCAGTTGTGACGTGGAAGGTTGTAAAGATTGAGAAAAACACAAGATTTAAAC +TTAGAAATTTTGATTATCCAAAAATTAGTAATGCTCAGAGCAAATCATTGTTGGATATTG +CTAGTCGCTATCTAAAAGATATTTAACTGTATTCAAAATTTTCATATCTTGTTGAGCTTT +TAAGCTTTCGTATAAAGCTATTGAATAAATAATTTCGTAAGATACGTTTTCAGGAGCATC +TTCTTTCAACTTATTTATTCTATCTCTAAAAAAGTCACTGTCACCACCGAATTCTTTTTC +GGCTTGATTACTAAGTTCACCAAAGAAATTTTGAAAATCATTAAATTCCATACTTATCCA +CCTCCTTTCACTAGGAGATAACTAAATTATACACAACACAAAAATAAAAAGGAGGAATAG +ATATGATAAAAAATAGTTTGCAAGCTAAAGAACTTGCGGTAATTTTATCTGTTTCTAAAT +CCAAAGCAGGACAAATAATAAGAGAACTGAATAAAGAGCTTGAAGACGAAGGATACATTG +CGATACGAGGAAAAATACCCGTCCAATTAGCTAGAAAAAAATTCCCTTATCACGACTTAT +CAGACGAGAGAATAATGGAGGAGTTAAAAAAAGAAAATGAGTAAAACTTATAAAAGCTAC +TTAATAGCAGTGCTATGTTTCACAGTCTTAGCGATTGTACTTATGCCGTTTCTATACTTC +ACTACAGCGTGGTCAATTGCAGGATTCGCAAGTATCGCAACTTTCATATTTTATAAAGAA +TACTTTTATGAGGTGGATGATTAAATGACTTGGTTCGAAGAACACGTTGAACCTAGTGTG +GAATGGGAAAGAAAAGCAGAACAAGCTGTGTTAAGTGATGATGAAGTTAAGACGATTACT +GAATACAGAGAGAAGTACAACAATCCATATATTTACATGTCGGTTCAAAACAAAAATTAT +CTTGTTGAATATGTAGACAGACATACCGGTGACATAGTATTACACAATTTAAAACTTAAG +AAATCATACAGAAGAAGAGCGCATCAATATTTTTTTGTCGGCCAAATAGTAGTACCAGGC +GAGCCAAAAGGCATAATTTATGAAACATCTTTGATAATAAGATAAAAAAACCGCTACTTG +CGCCAACAAGTAACAGTGACAAACATTTAAGAAATAAAATTCAAGTTAATTAAATCAAAA +TATACGGAGGTAGTCAAGATGTATTACGAAATAGGCGAAATCATACGCAAAAATATTCAT +GTTAACGGATTCGATTTTAAGCTATTCATTTTAAAAGGTCATATGGGCATATCAATACAA +GTTAAAGATATGAACAACGTACCAATTAAACATGCTTATGTCGTAGATGAGAATGACTTA +GATATGGCATCAGAATTATTCAACCAAGCAATAGATGAATGGATTGAAGAGAACACAGAC +GAGCAAGACAGACTAATTAACTTAGTCATGAAATGGTAGAGGGGGATTAACTAATGGCTA +ATCTATATGAGCTATCAGAAGCATTTAAAGAGATGTCTAATCAAGATGAATTAGATCCAA +CATTACTAAAAGATACATTAGATTCTATCAAAGCAGAAATGAACGTCAAAGTAGATAACA +TTGTCAATTGGAGACGTGAAACTTTAGGTGACATAGATGTCATAGATAAAGAAATTAAGA +GACTTCAAAATTTAAAAAAACAAAAACAAAATTTAACTGATCGTTTAAGAGATTACTTAA +AAGAGATGTTAGAAACACAGGAAGTAGATAGTTACCGCACAGCTACTAATCATATTTACA +AGCGCAAAAACGGGGCTAGTAAAAATATTATCGATGAAAAACTTATTCCAAAGGATTATT +GGCTATCACAAGCCCCGAAACTTAATTCTAAGCAACTAATCGATGATTTGAAAGATGGGA +AAGATATTCCTGGCGTTGAATTAAAGGTAACAGAAAGCCTGGTGATTAAGTGATGAATAA +ATCAGAAACAGTTGTAGAAATAAACAAAGCTATGGTTGCGTTTCGTAAAGAAGTAAAGCA +ACCGCTCAAAGATAAAAATAATCCATTTTTCAAATCAAAATACGTACCTCTTGAGAACGT +TGTAGAAGCCATTGACGAGGCGGCAACACCTCATGGACTGTCTTATACTCAATGGGCTTT +GAACGATGTAGACGGGCGCGTAGGAGTCGCTACAATGCTTATGCATGAAAGCGGTGAATA +TATCGAGTATGATCCCGTATTTATGAATGCAGAAAAGAATACGCCACAAGGAGCAGGCTC +GTTAATAAGTTATCTTAAACGTTATTCGCTATCTGCGATTTTCGGTATTACTAGTGACCA +AGACGATGACGGAAATGAAGCAAGTGGAAAAAATAATAATCCAAAACAGCAAACTAGAAC +GCAATGGGCAAGTAGCGAAACTATAGGGATTTTAAGGAAAGAGGTTATAAGTTTCACTAA +ATTGATAAAGGGCACGGATAAAGAAGCTCCACAAAATATAGTAGAACAAAAATTCGACAT +AAATAACTATAAATTAACGGAAAAACAAGCAGCAGAAGCTATTCAAAAAATACGAAACAA +CGCAAAAACAATTACTGGAGGAAAACAATAATGTTAAACAGAACGGTATTAGTAGGACGC +TTAACAAAAGATCCAGAATATAGAACAACGCCGAATGGTGTGAGTGTTACCACTTTCACT +ATCGCAGTTAACAGAACATTTACTAACGCTCAAGGAGAACGTGAGGCAGACTTTATTAAC +TGTGTAACTTTTAGAAAACAAGCAGAAAATGTAAATCATTATTTATCCAAAGGGTCATTG +GCTGGCGTTGATGGACGTTTACAATCACGCAGTTATGAAAACAAAGACGGGCAACGTGTG +TTTGTTACAGAAGTAGTAGCGGACAGTGTTCAATTCTTAGAACCGAAGAATAACAACCAA +CAACAAAACAACAATTATCATCAACAAAGACAAACTCAAACTGGTAATAATCCTTTTGAT +AATACCACTGCGATTACTGATGATGACCTCCCGTTCTGATTGGAATGATTAGATGCCAAT +AATTACTAGTTATATCACTCAAGACGACGGCACAACAACAGTTGTCATCTCGGGTGTTGA +ATTAGGCAATAAAGAAACATTACTACTTGATAACGGATTTGATGTGGAAGTAGATGTAAA +CGTTATAGATCCGTTTCAAATTACTGGACAACAACGTAAATTGATATTCGCATTGTGTAA +CGATATAGAAGCTCATACAGGACAGCCTCGAGATTATATGAGACAAATGTTCCAAGATTA +TGTGAAGTTTCTGTATGGCTATGAAGAACGCATATCTTTATCAAATTGTTCTCGAACTAT +AGCTAAGCAAATTATAGAAGCGATGTTTGAGTGGATTTTTACAAATGCGATTCCATTAAA +TTATAAAACAAGCAAATTGATGAAAGAAGATAAAAATTATCTTTATTGGGCAACTGTTAC +GCGTCATTGCATTATATGCGGAAAGCCTCACGCTGACCTAGCGCATTATGAAGCAGTCGG +CAGAGGCATGAACAGAAATAAGATGAATCACTATGACAAACATGTATTAGCGTTATGTCG +CGAACATCATAACCAGCAACACGCGATGGGCGTTAAGTCATTTGATGATAAATATCAATT +GCATGACTCGTGGATAAAAGTTGATGAGAGGCTCAACGAAATGCTGAAAGGAGAAAACAA +TGGGAGAAGTATCGTGGATAAAACTTAAAGTTGGCATGTTTGATGACAGCAAAATCAAAT +ATATCGAAGCTTTACCCGAAAGAGATACGATCATAACCATTTGGGTTAAGTTGCTAACTT +TATCAGGAAAGTACAACGAACAAGGTTACATTATGCTATCTGAAAATTTGCCGTACAACG +AAGAAATGTTAGCAAATGAGTTTAGCCGACCTATCAACTCAATAAGGTTAGCAATTCAAA +CTTTTGAGACATTGGGCATGATTGAAAAAGTTAATGGTGTCATAAAAGTGACAAACTGGG +AAAAGCACCAAAACATTGAAGGACTCGAGAAAATCAGGGCGCAGAACAGATTGAGGAAAC +AAAAGCAACGAGAAAACAACAGAAAATTGTTGAATGGTCACGTGACGTCACGTGACAGTC +ACGCAACAGAAGAAGATAAAGAATTAGATAAAGAATTAGAAAGAGATAAAGAAAAAGATA +TAGATAAGAATTTAAGTTCAAATAATAGCGCAACTGACGTTACGCATGAGCAATTTGAGG +AATGGTGGAAACTTTACAACAAGAAAAAAGATAAGAAGATGTCTTTCGCTAAATTCAAAT +CATGCTTAAAGAAACATACTTTTGAGCAAATCATGCAAGGTACTCGAGAATATTTAAAAA +CTATTACAGACAAACAATATCAAAAGTACCCTAAAACGTTTTTAACTAACGAAAGCTATA +TGAATGATTATAGCGAAGAGATTAAAGAAACTGGCATAGATCAATTGGAACGTATGAAGT +ACGACGAAAGTTATTGGGACTAGGAGGATCTTATGAAACCGTTATTCAACGAAAAAATAA +ACGAAAGTTTAAAAAAGTATCAACCAATCGAAGTAATACTAAGACAGAATTGCGATAAAT +GTGGGCGTCAATACGACTTATATAAGTTTGAAAATGGATATGAATACAAAGACGGTTGCG +AATGCGAAATTCAAAGATTGGCTTATGAAGAATACAAAAGGAATAAACAAAAGAAACTTG +ATTATATTTTCAATCAATCAAATGTCAATCCGTCATTAAGAGATGCAACAGTCAACAACT +ATAAGCCACAAAATGAAAAACAAGTACAAGCTAAACAAACAGCAATAGAGTACGTACAAG +GCTTCTCTACAAAAGAACCAAAATCATTAATATTGCAAGGTTCATATGGAACTGGTAAAA +GCCACCTAGCATACGCTATAGCAAAAGCAGTCAAAGCTAAAGGGCATACAGTTGCTTTTA +TGCATATCCAAATGTTGATGGATCGTATCAAAGCGGCATACAACAAAAATGCAGTTGAAA +CTACAGACGAGCTAGTCAGATTGCTAAGTGATATTGATTTACTTGTACTAGATGATATGG +GTGTAGAAAACACAGAACACACTTTAAATAAACTTTTTAGCATTGTTGATAACAGAGTAG +GTAAAAACAACATCTTTACAACTAACTTTAGTGATAAAGAACTAAATCAAAATATGAACT +GGCAACGTATCAATTCAAGAATGAAACACAATGCAAGGAAAGTTAGAGTAATCGGAGACG +ATTTCAGGGAGCGAGATGCATGGTAATAACAAAGCAAAATATAAAAGAAATATTACATTG +TAGAGATGTATATGCTCAAAAGATGATTGATTTCTGCAAACGGAGTCCAAGAGAAACTTA +AAAAACTTATTGATGATAAGTTGAAAGAAAAAGAAGAAAGATCCGCTATCGTCGAATATT +AAGGAGTGATTTAAAAATGCCGAAAAAAAATATTCTTATACCGAGAAGATGGCACGGAAG +ATATTAAGGTCATCAAGTATAAAGACAACGTAAATGAAGTTTACTCGCTCACAGGAGCCC +ATTTCAGCGACGAAAAGAAAATCATGACTGATAGTGACCTAAAACGATTCAAAGGCGCTC +ACGGGCTTCTATATGAGCAAGAGCTAGGTTTACAAGCAACGATATTTGATATTTAGAGGT +GGCACAATGAGTAAATACAACGCTAAGAAAGTTGAGTACAAAGGAATTGTATTTGATAGC +AAAGTAGAGTGCGAATATTACCAATATTTAGAAAGTAATATGAATGGCATTAATTATGAT +CATATCGAAATACAACCGAAATTTGAATTATTACCAAAATTAGATAAACAACGAAAGATT +GAATATATTGCAGACTTCGCGTTATATCTCGATGGCAAACTGATTGAAGTTATCGACATT +AAAGGTATGCCAACTGAAGTAGCAAAACTTAAAGCAAAGATTTTTAGACATAAATACAGA +AACATAAAACTCAATTGGATATGTAAAGCACCTAAGTATACAGGCAAAACATGGATTACG +TATGAGGAATTAATTAAAGCAAGACGAGAACGCAAAAGAGAAATGAAGTGATTTAATGCA +ACAACAAGCATATATAAACGCAACGATTGATATAAGAATACCTACAGAAGTTGAATATCA +GCATTTTGATGATGTGGATAACGAAAAAGATGCGCTGGCAAAGCGTTTAGATGACAATCT +GGATGAATTACTAAAGTATGACAACATAACAATAAGACGTGCATATATAGAGGTGGAATA +AATGAAGCTGAACGAAGTATTCGCAACTAATTTAAGAGTAATCATGGCTAGAGATAACGT +AAGTGTTCAAGATTTGCACAACGAAACTGGCGTATCAAGATCAACTATTAGTGGATATAA +AAACGGAAAAGCTGAGATGGTTAACTTAAATGTATTAGATAAATTGGCAGATGCTCTAGG +TGTTAATGTAAGTGAACTATTTACTAGAAATCACAACACACACAAATTAGAGGATTGGAT +TAAAACAGTAAATGTATAGAGGTGGAATAAATGGCGAAAACAGCAAGAATTGTAAGGATA +CATGATAAACCGTATAGGTTCAGTGAATTTGAAATGGAGTTAATTGAAAGTCACGGTATA +ACACCCGGGATGGTTTCTAAAAGAGTAAAAGACGGTTGGGAACTACATGAAGCAATGGAC +GCACCAGAAGGCATGCGTTTAAGCGAGTACAGAGAAAAGAAAACAATAGAAAGACTGGAA +CAAGCTAGACTCGAACGCAAATTGGAAAGACAGCGAAAGAAAGAGGCTGAGCTAAGAAGA +AAGAAGCCACATTTGTTTAATGTACCTCAAAAACATTCACGTGATCCGTACTGGTTCGAT +ATTACTTATAACCAAATGTTTAAGAAATGGCAGGAAGCATAAATGCCAAAAACTGATAGC +GCATGTAAAGAATACTTAAACCAATTTTTTGGATCTAAGAGATATCTGTATCAGGATAAC +GAACGAGTGGCACATATCCATGTAGTAAACGGTACTTATTACTTTCATGGGCATATCGTG +CCAGGTTGGCAAGGCGTGAAAAAGACATTTGATACAGCGGAAGAGCTCGAAATATATATA +AAGCAGCATGGTTTGGAATACGAGGAACAGAAGCAACTAACTTTATTTTAGAGGAGGTTA +TGAAAGTGAACTATGAAACAGGGTTCCAAATAGGTGTAATGGAAGCTAGGTTGAAGAAGA +TGAGAAAACAACGAGATGAGTATAAGAAGCAACAAGATGAGCTTATCGTGGATATAGCGA +AGTTACGAGAACGTAACAAAGAGTTGGAGAAGAAAGCAAGTGCATGGGATAGGTATTGCA +AGAGCGTTGAAAAAGATTTAATAAACGAATTTGGCAACGATGATGAAAGAGTTAAATTTG +GAATGGAATTAAACAATAAAATTTTTATGGAGGATGACACAAATGGATAACCGTGAACAA +ATAGAACAGTCCGTTATAAGTGCTAGTGCGTATAACGGTAATGACACAGAGGGATTGCTA +AAAGAGATTGAGGACGTGTATAAGAAAGCACAAGCGTTTGATGAAATACTTGATGGAATG +ACAAATGCTATTCAACATTCAGTTAAAGAAGGTATTGAACTTGATGAAGCAGTAGGGATT +ATGGCAGGTCAAGTTGTCTATAAATATGAGGAGGAACAGGAAAATGACTAACACATTAAC +AATTGATCAGTTACAAGAGTTATTACAAATACAAAAGAAGTTCGACGATAGAATACCGAC +TAGAAATTTAAATGACACAGTAGCTAGTATGATTATTGAATTTGCGGAGTGGGTTAACAC +ACTTGAGTTTTTTAAAAATTGGAAGAAACAACCAGGTAAGCCATTAGATACACAATTAGA +TGAGATTGCTGATTACTTAGCTTTCAGTTTGCAATTAACTTTGACTATTGTTGATGAAGA +AGATTTGGAAGAAACTACTGAGGTTATGGTTGATTTGATTGAAAATGAAGTTACTTTACC +TAAACTACATTCAGTTTATTTTGTTCATGTAATGCATACACTAACAGAACAATTTGTAAA +AGGTATTGATAATAGTATTGTACAAGTTTTAATAATGCCTTTTTTGTACGCCAATACTTA +CTATACAATCGACCAACTCATTGACGCATACAAAAAGAAAATGAAAAGGAACCACGAAAG +ACAAGATGGAACAGCAGACGCAGGAAAAGGATACGTGTAAAGACATCTTAGATCGAGTCA +AGGAGGTTTTGGGGAAGTGACACAATACTTAGTCACAACATTCAAAGATTCAACAGGACG +TAAACATACACACATAACTCGAGCTAAAAGCAATCAAAGGTTTACAGTTGTTGAGGCAGA +GAGTAAAGAAGAAGCGAAAGAGAAATATGAGTCACAAAATACACCTATTGTTTACTACAC +TAATAATTCTAAAGTGACCTTATTCGAAAGACCTAGTGAAGAAGTATTAGGTTCTTTGTT +CGAAAAGAAATAAAATCATTAAAGAGGGGAGATAATAATGTTTAATACACCTAAAATGAA +ATTACCAGAAAAGCACACCGAGGTATTTAAGACGTATAAAAATGGAACGCCAGAAGAAAA +AGCTGAGATTGAAGGCTGTTTTATTAAAACTGTTAAAGATGAAGATAGTGAATTTTACAG +CCCTATGTTAGCCAGTCTAAATGAACAACAGTTAAAGAGTATGTTGAGACAGGTACTTTT +TTTGATTGATACAGGAGATGACAATGATGATTAAAAAACTTAAAAATATGGATTGGTTCG +ATATCTTTATTGTTGGAATACTGCGATTATTCGGCGTAATCGCACTGATGCTTGTTGTCA +TATCGCCTATCTATACAGTGGCTAGTTACCAAAACAAAGAAGTACATCAAGGGACAATTA +CAGATAAATATAACAAGAGACAAGATAAAGAAGACAAGTTCTATATTGTGTTAGACAACA +AGCAAGTCATCGAAAACTCTGACTTACTATTCAAAAAGAAATTTGATAGCGCAGACATAC +AAGCTAGGTTAAAAGTAGGCGACAAAGTAGAAGTTAAAACGATTGGTTATAGAATACACT +TTTTAAATTTATATCCGGTCTTATACGAAGTAAAGAAGGTAGATAAATAATGATTAAACA +AATATTAAGACTATTATTCTTACTAGCGATGTATGAGCTAGGTAAGTATGTAACTGAGAA +AGTATATATTATGACGACGGCTAATGATGATGTAGAGGCGCCGAGTGATTACGTCTTTCG +AGCGGAGGTGAGTGAGTGATGTGGATTACTATGACTATTGTATTTGCTATATTGCTATTA +GTTTGTATCAGTATTAATAGTGATCGTGCAAGAGAGATACAAGCACTCAGATATATGAAT +GATTATCTACTTGATGAAGTAGTTAAAACTAAAGGA diff --git a/example/output/ani.ids.tsv b/example/output/ani.ids.tsv new file mode 100644 index 0000000..ef79593 --- /dev/null +++ b/example/output/ani.ids.tsv @@ -0,0 +1,13 @@ +id seq_len no_parts +NC_025457.alt2 64164 1 +NC_005091.alt2 63696 1 +NC_005091.alt1 57455 1 +NC_005091.ref 57455 1 +NC_002486.alt 45636 1 +NC_002486.ref 45636 1 +NC_025457.ref 42654 1 +NC_025457.alt1 41066 1 +NC_010807.alt2 40555 1 +NC_010807.alt3 39891 1 +NC_010807.alt1 38815 1 +NC_010807.ref 38815 1 diff --git a/example/output/ani.tsv b/example/output/ani.tsv new file mode 100644 index 0000000..9e4c71d --- /dev/null +++ b/example/output/ani.tsv @@ -0,0 +1,133 @@ +idx1 idx2 id1 id2 tani gani ani cov num_alns len_ratio +0 1 NC_025457.alt2 NC_005091.alt2 0.001494 0.002977 0.532033 0.005595 4 1.007347 +1 0 NC_005091.alt2 NC_025457.alt2 0.001494 0 0 0 0 0.992706 +0 2 NC_025457.alt2 NC_005091.alt1 0.002508 0.003257 0.585434 0.005564 4 1.116770 +2 0 NC_005091.alt1 NC_025457.alt2 0.002508 0.001671 0.545455 0.003063 2 0.895440 +0 3 NC_025457.alt2 NC_005091.ref 0.001299 0.001808 0.637363 0.002836 2 1.116770 +3 0 NC_005091.ref NC_025457.alt2 0.001299 0.000731 0.518519 0.001410 1 0.895440 +0 4 NC_025457.alt2 NC_002486.alt 0.007605 0.003491 0.541063 0.006452 4 1.405995 +4 0 NC_002486.alt NC_025457.alt2 0.007605 0.013389 0.562615 0.023797 12 0.711240 +0 5 NC_025457.alt2 NC_002486.ref 0.005155 0.002774 0.551084 0.005034 3 1.405995 +5 0 NC_002486.ref NC_025457.alt2 0.005155 0.008502 0.555079 0.015317 8 0.711240 +0 6 NC_025457.alt2 NC_025457.ref 0.736880 0.639502 0.911601 0.701515 159 1.504290 +6 0 NC_025457.ref NC_025457.alt2 0.736880 0.883364 0.910539 0.970155 120 0.664765 +0 7 NC_025457.alt2 NC_025457.alt1 0.549073 0.456767 0.895776 0.509912 163 1.562460 +7 0 NC_025457.alt1 NC_025457.alt2 0.549073 0.693299 0.900639 0.769785 147 0.640016 +0 8 NC_025457.alt2 NC_010807.alt2 0.004994 0.005860 0.567119 0.010333 7 1.582148 +8 0 NC_010807.alt2 NC_025457.alt2 0.004994 0.003625 0.561069 0.006460 3 0.632052 +0 9 NC_025457.alt2 NC_010807.alt3 0.002518 0.003366 0.546835 0.006156 4 1.608483 +9 0 NC_010807.alt3 NC_025457.alt2 0.002518 0.001153 0.528736 0.002181 1 0.621704 +0 10 NC_025457.alt2 NC_010807.alt1 0.005496 0.006826 0.558673 0.012219 8 1.653072 +10 0 NC_010807.alt1 NC_025457.alt2 0.005496 0.003298 0.542373 0.006080 2 0.604934 +0 11 NC_025457.alt2 NC_010807.ref 0.005496 0.006094 0.556980 0.010941 7 1.653072 +11 0 NC_010807.ref NC_025457.alt2 0.005496 0.004509 0.546875 0.008244 3 0.604934 +1 2 NC_005091.alt2 NC_005091.alt1 0.931367 0.929776 0.938394 0.990816 124 1.108624 +2 1 NC_005091.alt1 NC_005091.alt2 0.931367 0.933130 0.935377 0.997598 118 0.902019 +1 3 NC_005091.alt2 NC_005091.ref 0.964573 0.965822 0.966809 0.998980 53 1.108624 +3 1 NC_005091.ref NC_005091.alt2 0.964573 0.963189 0.963239 0.999948 55 0.902019 +1 4 NC_005091.alt2 NC_002486.alt 0.001143 0.001962 0.498008 0.003941 3 1.395740 +4 1 NC_002486.alt NC_005091.alt2 0.001143 0 0 0 0 0.716466 +1 5 NC_005091.alt2 NC_002486.ref 0.001143 0.001962 0.498008 0.003941 3 1.395740 +5 1 NC_002486.ref NC_005091.alt2 0.001143 0 0 0 0 0.716466 +1 6 NC_005091.alt2 NC_025457.ref 0.000921 0.000738 0.580247 0.001272 1 1.493318 +6 1 NC_025457.ref NC_005091.alt2 0.000921 0.001196 0.637500 0.001876 1 0.669650 +1 7 NC_005091.alt2 NC_025457.alt1 0.001947 0.001523 0.567251 0.002685 2 1.551064 +7 1 NC_025457.alt1 NC_005091.alt2 0.001947 0.002606 0.597765 0.004359 2 0.644719 +1 8 NC_005091.alt2 NC_010807.alt2 0.003242 0.003846 0.573770 0.006704 4 1.570608 +8 1 NC_010807.alt2 NC_005091.alt2 0.003242 0.002293 0.494681 0.004636 2 0.636696 +1 9 NC_005091.alt2 NC_010807.alt3 0.004692 0.005385 0.575503 0.009357 6 1.596751 +9 1 NC_010807.alt3 NC_005091.alt2 0.004692 0.003585 0.533582 0.006718 3 0.626272 +1 10 NC_005091.alt2 NC_010807.alt1 0.003180 0.003658 0.529545 0.006908 4 1.641015 +10 1 NC_010807.alt1 NC_005091.alt2 0.003180 0.002396 0.494681 0.004843 2 0.609379 +1 11 NC_005091.alt2 NC_010807.ref 0.003122 0.002779 0.556604 0.004992 3 1.641015 +11 1 NC_010807.ref NC_005091.alt2 0.003122 0.003684 0.533582 0.006905 3 0.609379 +2 3 NC_005091.alt1 NC_005091.ref 0.968689 0.968689 0.970090 0.998555 69 1.000000 +3 2 NC_005091.ref NC_005091.alt1 0.968689 0.968689 0.970276 0.998364 69 1.000000 +2 4 NC_005091.alt1 NC_002486.alt 0.000427 0 0 0 0 1.258984 +4 2 NC_002486.alt NC_005091.alt1 0.000427 0.000964 0.543210 0.001775 1 0.794291 +2 5 NC_005091.alt1 NC_002486.ref 0.001426 0 0 0 0 1.258984 +5 2 NC_002486.ref NC_005091.alt1 0.001426 0.003221 0.503425 0.006398 3 0.794291 +2 6 NC_005091.alt1 NC_025457.ref 0.002397 0.002506 0.553846 0.004525 3 1.347001 +6 2 NC_025457.ref NC_005091.alt1 0.002397 0.002251 0.596273 0.003775 2 0.742390 +2 7 NC_005091.alt1 NC_025457.alt1 0.001188 0.001184 0.544000 0.002176 1 1.399089 +7 2 NC_025457.alt1 NC_005091.alt1 0.001188 0.001193 0.604938 0.001972 1 0.714751 +2 8 NC_005091.alt1 NC_010807.alt2 0.005693 0.005465 0.551845 0.009903 6 1.416718 +8 2 NC_010807.alt2 NC_005091.alt1 0.005693 0.006017 0.531590 0.011318 5 0.705857 +2 9 NC_005091.alt1 NC_010807.alt3 0.003616 0.003377 0.557471 0.006057 4 1.440300 +9 2 NC_010807.alt3 NC_005091.alt1 0.003616 0.003961 0.552448 0.007170 3 0.694300 +2 10 NC_005091.alt1 NC_010807.alt1 0.003189 0.002785 0.581818 0.004786 3 1.480227 +10 2 NC_010807.alt1 NC_005091.alt1 0.003189 0.003787 0.546468 0.006930 3 0.675572 +2 11 NC_005091.alt1 NC_010807.ref 0.002576 0.001775 0.531250 0.003342 2 1.480227 +11 2 NC_010807.ref NC_005091.alt1 0.002576 0.003761 0.542751 0.006930 3 0.675572 +3 4 NC_005091.ref NC_002486.alt 0.002988 0.003481 0.480769 0.007240 4 1.258984 +4 3 NC_002486.alt NC_005091.ref 0.002988 0.002367 0.596685 0.003966 2 0.794291 +3 5 NC_005091.ref NC_002486.ref 0.002735 0.003481 0.480769 0.007240 4 1.258984 +5 3 NC_002486.ref NC_005091.ref 0.002735 0.001797 0.491018 0.003659 2 0.794291 +3 6 NC_005091.ref NC_025457.ref 0.000509 0 0 0 0 1.347001 +6 3 NC_025457.ref NC_005091.ref 0.000509 0.001196 0.637500 0.001876 1 0.742390 +3 7 NC_005091.ref NC_025457.alt1 0.001076 0.000801 0.528736 0.001514 1 1.399089 +7 3 NC_025457.alt1 NC_005091.ref 0.001076 0.001461 0.631579 0.002313 1 0.714751 +3 8 NC_005091.ref NC_010807.alt2 0.004438 0.005883 0.587826 0.010008 6 1.416718 +8 3 NC_010807.alt2 NC_005091.ref 0.004438 0.002392 0.554286 0.004315 2 0.705857 +3 9 NC_005091.ref NC_010807.alt3 0.004541 0.004839 0.591489 0.008180 5 1.440300 +9 3 NC_010807.alt3 NC_005091.ref 0.004541 0.004111 0.557823 0.007370 3 0.694300 +3 10 NC_005091.ref NC_010807.alt1 0.003334 0.003899 0.586387 0.006649 4 1.480227 +10 3 NC_010807.alt1 NC_005091.ref 0.003334 0.002499 0.584337 0.004277 2 0.675572 +3 11 NC_005091.ref NC_010807.ref 0.003407 0.003011 0.586441 0.005134 3 1.480227 +11 3 NC_010807.ref NC_005091.ref 0.003407 0.003993 0.589354 0.006776 3 0.675572 +4 5 NC_002486.alt NC_002486.ref 0.999945 1.000000 1.000000 1.000000 3 1.000000 +5 4 NC_002486.ref NC_002486.alt 0.999945 0.999890 0.999890 1.000000 3 1.000000 +4 6 NC_002486.alt NC_025457.ref 0.013127 0.012731 0.570727 0.022307 11 1.069911 +6 4 NC_025457.ref NC_002486.alt 0.013127 0.013551 0.579739 0.023374 11 0.934657 +4 7 NC_002486.alt NC_025457.alt1 0.007405 0.010781 0.578824 0.018626 9 1.111284 +7 4 NC_025457.alt1 NC_002486.alt 0.007405 0.003653 0.576923 0.006331 3 0.899860 +4 8 NC_002486.alt NC_010807.alt2 0.003515 0.004580 0.595442 0.007691 4 1.125287 +8 4 NC_010807.alt2 NC_002486.alt 0.003515 0.002318 0.534091 0.004340 2 0.888662 +4 9 NC_002486.alt NC_010807.alt3 0.004946 0.005916 0.552147 0.010715 5 1.144017 +9 4 NC_010807.alt3 NC_002486.alt 0.004946 0.003835 0.529412 0.007245 3 0.874113 +4 10 NC_002486.alt NC_010807.alt1 0.003659 0.003287 0.551471 0.005960 3 1.175731 +10 4 NC_010807.alt1 NC_002486.alt 0.003659 0.004096 0.554007 0.007394 3 0.850535 +4 11 NC_002486.alt NC_010807.ref 0.004215 0.004404 0.561453 0.007845 4 1.175731 +11 4 NC_010807.ref NC_002486.alt 0.004215 0.003993 0.540070 0.007394 3 0.850535 +5 6 NC_002486.ref NC_025457.ref 0.012402 0.011329 0.578300 0.019590 10 1.069911 +6 5 NC_025457.ref NC_002486.ref 0.012402 0.013551 0.579739 0.023374 11 0.934657 +5 7 NC_002486.ref NC_025457.alt1 0.007186 0.010365 0.581081 0.017837 8 1.111284 +7 5 NC_025457.alt1 NC_002486.ref 0.007186 0.003653 0.576923 0.006331 3 0.899860 +5 8 NC_002486.ref NC_010807.alt2 0.002158 0.002016 0.554217 0.003637 2 1.125287 +8 5 NC_010807.alt2 NC_002486.ref 0.002158 0.002318 0.534091 0.004340 2 0.888662 +5 9 NC_002486.ref NC_010807.alt3 0.004747 0.005544 0.541756 0.010233 5 1.144017 +9 5 NC_010807.alt3 NC_002486.ref 0.004747 0.003835 0.529412 0.007245 3 0.874113 +5 10 NC_002486.ref NC_010807.alt1 0.002913 0.001906 0.514793 0.003703 2 1.175731 +10 5 NC_010807.alt1 NC_002486.ref 0.002913 0.004096 0.554007 0.007394 3 0.850535 +5 11 NC_002486.ref NC_010807.ref 0.003469 0.003024 0.541176 0.005588 3 1.175731 +11 5 NC_010807.ref NC_002486.ref 0.003469 0.003993 0.540070 0.007394 3 0.850535 +6 7 NC_025457.ref NC_025457.alt1 0.793287 0.757702 0.980195 0.773011 86 1.038669 +7 6 NC_025457.alt1 NC_025457.ref 0.793287 0.830249 0.983642 0.844056 88 0.962770 +6 8 NC_025457.ref NC_010807.alt2 0.003029 0.003540 0.551095 0.006424 3 1.051757 +8 6 NC_010807.alt2 NC_025457.ref 0.003029 0.002490 0.583815 0.004266 2 0.950790 +6 9 NC_025457.ref NC_010807.alt3 0.006651 0.005838 0.583138 0.010011 5 1.069264 +9 6 NC_010807.alt3 NC_025457.ref 0.006651 0.007520 0.560748 0.013412 6 0.935223 +6 10 NC_025457.ref NC_010807.alt1 0.006432 0.007080 0.587549 0.012050 6 1.098905 +10 6 NC_010807.alt1 NC_025457.ref 0.006432 0.005719 0.596774 0.009584 4 0.909997 +6 11 NC_025457.ref NC_010807.ref 0.006972 0.008581 0.569207 0.015075 7 1.098905 +11 6 NC_010807.ref NC_025457.ref 0.006972 0.005204 0.583815 0.008914 4 0.909997 +7 8 NC_025457.alt1 NC_010807.alt2 0.004080 0.003823 0.547038 0.006989 3 1.012600 +8 7 NC_010807.alt2 NC_025457.alt1 0.004080 0.004340 0.533333 0.008137 4 0.987557 +7 9 NC_025457.alt1 NC_010807.alt3 0.005151 0.003433 0.528090 0.006502 3 1.029455 +9 7 NC_010807.alt3 NC_025457.alt1 0.005151 0.006919 0.554217 0.012484 5 0.971388 +7 10 NC_025457.alt1 NC_010807.alt1 0.004882 0.004700 0.554598 0.008474 4 1.057993 +10 7 NC_010807.alt1 NC_025457.alt1 0.004882 0.005075 0.511688 0.009919 4 0.945186 +7 11 NC_025457.alt1 NC_010807.ref 0.005759 0.006039 0.547461 0.011031 5 1.057993 +11 7 NC_010807.ref NC_025457.alt1 0.005759 0.005462 0.539440 0.010125 4 0.945186 +8 9 NC_010807.alt2 NC_010807.alt3 0.969793 0.980939 0.986608 0.994255 51 1.016645 +9 8 NC_010807.alt3 NC_010807.alt2 0.969793 0.958462 0.985184 0.972876 48 0.983627 +8 10 NC_010807.alt2 NC_010807.alt1 0.986229 0.986266 0.986363 0.999901 29 1.044828 +10 8 NC_010807.alt1 NC_010807.alt2 0.986229 0.986191 0.986216 0.999974 28 0.957095 +8 11 NC_010807.alt2 NC_010807.ref 0.989467 0.989693 0.989693 1.000000 8 1.044828 +11 8 NC_010807.ref NC_010807.alt2 0.989467 0.989231 0.989231 1.000000 8 0.957095 +9 10 NC_010807.alt3 NC_010807.alt1 0.971502 0.958863 0.992810 0.965807 58 1.027721 +10 9 NC_010807.alt1 NC_010807.alt3 0.971502 0.984491 0.993113 0.991318 56 0.973026 +9 11 NC_010807.alt3 NC_010807.ref 0.982555 0.968865 0.995800 0.972951 44 1.027721 +11 9 NC_010807.ref NC_010807.alt3 0.982555 0.996625 0.996676 0.999948 44 0.973026 +10 11 NC_010807.alt1 NC_010807.ref 0.996664 0.996548 0.996548 1.000000 22 1.000000 +11 10 NC_010807.ref NC_010807.alt1 0.996664 0.996780 0.996780 1.000000 22 1.000000 diff --git a/example/output/clusters.tsv b/example/output/clusters.tsv new file mode 100644 index 0000000..5db8cc6 --- /dev/null +++ b/example/output/clusters.tsv @@ -0,0 +1,13 @@ +object cluster +NC_025457.alt2 3 +NC_005091.alt2 0 +NC_005091.alt1 0 +NC_005091.ref 0 +NC_002486.alt 1 +NC_002486.ref 1 +NC_025457.ref 4 +NC_025457.alt1 5 +NC_010807.alt2 2 +NC_010807.alt3 2 +NC_010807.alt1 2 +NC_010807.ref 2 diff --git a/example/output/fltr.txt b/example/output/fltr.txt new file mode 100644 index 0000000..b6cbc04 --- /dev/null +++ b/example/output/fltr.txt @@ -0,0 +1,13 @@ +kmer-length: 18 fraction: 1 ,NC_010807.ref,NC_010807.alt1,NC_010807.alt2,NC_010807.alt3,NC_005091.ref,NC_005091.alt1,NC_005091.alt2,NC_025457.ref,NC_025457.alt1,NC_025457.alt2,NC_002486.ref,NC_002486.alt, +NC_010807.ref, +NC_010807.alt1,1:0.998503, +NC_010807.alt2,1:0.994485,2:0.992863, +NC_010807.alt3,1:0.998316,2:0.996767,3:0.992419, +NC_005091.ref, +NC_005091.alt1,5:0.983056, +NC_005091.alt2,5:0.979575,6:0.958596, +NC_025457.ref, +NC_025457.alt1,8:0.989523, +NC_025457.alt2,8:0.951286,9:0.937156, +NC_002486.ref, +NC_002486.alt,11:0.999979, diff --git a/example/readme.txt b/example/readme.txt new file mode 100644 index 0000000..29b1ac5 --- /dev/null +++ b/example/readme.txt @@ -0,0 +1,11 @@ +This dataset comprises bacteriophage genome sequences with simulated mutations relative to the reference sequence (.ref). Mutations include substitutions (sn), deletions (del), insertions (ins), duplications (dup), inversions (inv), and translocations (tl). These modified sequences (.alt*) have known true total ANI (tANI) values compared to the reference. + +ref_id alt_id ref_len alt_len tani alt_summary +NC_010807.ref NC_010807.alt1 38815 38815 0.99753 sn;inv;tl +NC_010807.ref NC_010807.alt2 38815 40555 0.98985 sn;dup +NC_010807.ref NC_010807.alt3 38815 39891 0.98414 sn;ins;tl +NC_005091.ref NC_005091.alt1 57455 57455 0.97161 sn;inv;tl +NC_005091.ref NC_005091.alt2 57455 63696 0.96707 sn;dup;tl +NC_025457.ref NC_025457.alt1 42654 41066 0.80607 sn;del;ins;dup;inv +NC_025457.ref NC_025457.alt2 42654 64164 0.75921 sn;del;ins;dup;inv;tl +NC_002486.ref NC_002486.alt 45636 45636 1.00000 tl \ No newline at end of file diff --git a/images/logo.png b/images/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..eef8ffa7e677894f731e4470c604058a80bcb4a5 GIT binary patch literal 1452 zcmV;d1ylNoP)V-M#Pbbi)4Ffy=q) z-uK-1`?=3^pL?!gW{jrR-hkrqI#+LjI>CGk37%kKg<<=T5p=|WJJK2T$^4HdxJmQH zXaef4&)p{kuLCd%04x{=1j7~v{zkAcpp(XO%cC7vzgKvT5eMp?*E2p4)k1p**A~91D!Ody#Ym~#(5Qtr@~_t02t0gKm0mb6J#ru@ zNfl>XL`h~jgU6C!Xb?0LG%QL^pE|L%)~tHCqhed(+)|a>0D)ymFfkBV5J$#>7n?MV zgTMkX7#Jai_BLcMWhFWxFarP#Yy^g4`wHgWZS_ni!v4h=6GinC^Kfam#XD46)IG zrn#)gy3kj+&{WFo4WzI7eJl|pIIgoEZ@>xZjD0bEYn5{vOtRZ0_ zS;K>Ygf5ma@3++cdg#vdwab{}&r4Jpm8?=)rEDVvuCY91lEseY)hSdj9~@KaBeO! zj|~eSD#`K|%c~WEj@xcJ0Hn1wOB{H}20#uZBvX?t(&Ho>coCTVIDoRiZ3-r?%z406 zbS!A10f}gliAfd#p@>=u>Rr-Q^Idtm7m}R_OqL}iG`oS#yolW-;(!chm5^k~D%m)g zB~~dCG|VI`42dK~ZN_q{kNdawv5Q`~=w%mu?7~=n%Z1Lltl&Z;*0Y8Szc+$@P(gtz zuvOxiX&@M2p#7lun_&MlQQ!bNT6pvZ4X72dum6ID0rj_jTGgBC$(~r#XWbQj?Ec)x z@&FhMTRZRC=0a`uAv9uruurfqXDBwH41jgPmTy+s)iR@Rme6wwpCJZ37QC>vyXx4M+GDS4VOxh23}Jx)G{bH(Z0|6j z`in@i!OI{2dJqu10bt1YP;*zMXR>E%`mJtqp%1#O&q=6%8Q3Y1n!bI{td9ZU^t6d> zT9~hNRFy=_4g5J6FYVYf`%jV8A1cuCm^xf&v8c^#J|&|t0M1HM?_Y4GFx>V^&2Qy8 zB|0_eb~S`D)?ev>8C!OARX1_4^x0VZ*8^J62g6LV*peu0g89j|&RLt!tI)-?6`xN% zd&Z2JsjPibv&rcKWdfMv5d6^g&g#Yx1^}8nChgSLyb%^2O~nD*h3fg|qcAM6Erbc+ zM)vdJxw`L5`>dU#K{tA!a=|!lfdi+`6@9zUe_jW*_J;PNKfKB74cn)w;02mjCjhjF z)+@G_TlvJBU3cd{A4b&&-t+eyzSqF6H?Wnyt>U%|g%vDL0KBTLvwF~{$fyDWfXAo* zlqtE=t5bsO$l7TJG{L~8AaGJx@rwmIGW}v#>%J + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/makefile b/makefile new file mode 100644 index 0000000..ef22d8c --- /dev/null +++ b/makefile @@ -0,0 +1,34 @@ +all: prep + +ifdef MSVC # Avoid the MingW/Cygwin sections + uname_S := Windows + uname_M := "x86_64" +else # If uname not available => 'not' + uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not') + uname_M := $(shell sh -c 'uname -m 2>/dev/null || echo not') +endif + +ifeq ($(uname_S),Darwin) + STATIC_LINK_FLAG := false +else + STATIC_LINK_FLAG := true +endif + + +prep: + cd 3rd_party/kmer-db && $(MAKE) -j + cd 3rd_party/lz-ani && $(MAKE) -j + cd 3rd_party/clusty && $(MAKE) -j STATIC_LINK=$(STATIC_LINK_FLAG) + cd 3rd_party/ref-utils && $(MAKE) -j + mkdir -p bin + cp 3rd_party/kmer-db/kmer-db ./bin/ + cp 3rd_party/lz-ani/lz-ani ./bin/ + cp 3rd_party/clusty/clusty ./bin/ + cp 3rd_party/ref-utils/multi-fasta-split/multi-fasta-split ./bin/ + +clean: + cd 3rd_party/kmer-db && $(MAKE) clean + cd 3rd_party/lz-ani && $(MAKE) clean + cd 3rd_party/clusty && $(MAKE) clean + cd 3rd_party/ref-utils && $(MAKE) clean + rm bin/* diff --git a/test.py b/test.py new file mode 100755 index 0000000..2a46edb --- /dev/null +++ b/test.py @@ -0,0 +1,298 @@ +#!/usr/bin/env python3 + +from pathlib import Path +import shutil +import subprocess + +import vclust +import pytest + +VCLUST = Path('vclust.py') + +DATA_DIR = Path('example') +FASTA_DIR = DATA_DIR / 'fna' +FASTA_FILE = DATA_DIR / 'multifasta.fna' +ANI_FILE = DATA_DIR / 'output'/ 'ani.tsv' +IDS_FILE = DATA_DIR / 'output' / 'ani.ids.tsv' +FLTR_FILE = DATA_DIR / 'output' / 'fltr.txt' + +TMP_DIR = DATA_DIR / 'tmp' + + +@pytest.fixture +def test_dir(): + '''Returns a testing data''' + #print('setup') + if TMP_DIR.exists(): + shutil.rmtree(TMP_DIR) + TMP_DIR.mkdir(parents=True) + yield TMP_DIR + #print('teardown') + shutil.rmtree(TMP_DIR) + + +@pytest.mark.parametrize('input,params,error_msg',[ + (FASTA_DIR, ['--batch-size', '4'], 'error: --batch-size'), + (FASTA_DIR, ['--min-ident', '95'], 'between 0 and 1'), + (FASTA_DIR, ['--k', '2'], 'invalid choice'), +]) +def test_parser_error_prefilter(test_dir, input, params, error_msg): + out_file = test_dir.joinpath('filter.txt') + cmd = [ + f'{VCLUST.resolve()}', + 'prefilter', + '-i', + f'{input}', + '-o', + f'{out_file}', + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 2 + assert error_msg in p.stderr + assert not p.stdout + + +@pytest.mark.parametrize('params,error_msg',[ + (['--out-tani', '40'], 'between 0 and 1'), +]) +def test_parser_error_align(test_dir, params, error_msg): + out_file = test_dir.joinpath('ani.tsv') + cmd = [ + f'{VCLUST.resolve()}', + 'align', + '-i', + f'{FASTA_FILE}', + '-o', + f'{out_file}' + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 2 + assert error_msg in p.stderr + assert not p.stdout + + +@pytest.mark.parametrize('params,error_msg',[ + (['--metric', 'tani'], 'error: tani threshold'), + (['--metric', 'ani', '--ani', '95'], 'between 0 and 1'), +]) +def test_parser_error_cluster(test_dir, params, error_msg): + out_file = test_dir.joinpath('clusters.tsv') + cmd = [ + f'{VCLUST.resolve()}', + 'cluster', + '-i', + f'{ANI_FILE}', + '-o', + f'{out_file}', + '--ids', + f'{IDS_FILE}' + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 2 + assert error_msg in p.stderr + assert not p.stdout + + +@pytest.mark.parametrize('input,params',[ + (FASTA_DIR, []), + (FASTA_FILE, []), + (FASTA_FILE, ['--batch-size', '4']), +]) +def test_prefilter_default(test_dir, input, params): + out_file = test_dir.joinpath('filter.txt') + cmd = [ + f'{VCLUST.resolve()}', + 'prefilter', + '-i', + f'{input}', + '-o', + f'{out_file}', + ] + cmd.extend(params) + p = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True) + assert p.returncode == 0 + assert not p.stderr + assert out_file.exists() + assert out_file.stat().st_size + + +@pytest.mark.parametrize('input,params',[ + (FASTA_DIR, []), + (FASTA_FILE, []), +]) +def test_align_default(test_dir, input, params): + out_file = test_dir.joinpath('ani.tsv') + cmd = [ + f'{VCLUST.resolve()}', + 'align', + '-i', + f'{input}', + '-o', + f'{out_file}' + ] + p = subprocess.run(cmd) + assert p.returncode == 0 + assert p.stderr == None + assert out_file.exists() + assert out_file.stat().st_size + ref_pairs = { + ('NC_010807.ref', 'NC_010807.alt1'): 0.99753, + ('NC_010807.ref', 'NC_010807.alt2'): 0.98985, + ('NC_010807.ref', 'NC_010807.alt3'): 0.98414, + ('NC_005091.ref', 'NC_005091.alt1'): 0.97161, + ('NC_005091.ref', 'NC_005091.alt2'): 0.96707, + ('NC_025457.ref', 'NC_025457.alt1'): 0.80607, + ('NC_025457.ref', 'NC_025457.alt2'): 0.75921, + ('NC_002486.ref', 'NC_002486.alt'): 1.00000, + } + pairs = {} + with open(out_file) as fh: + next(fh) + for line in fh: + cols = line.split() + id1 = cols[2][:-4] if '.fna' in cols[2] else cols[2] + id2 = cols[3][:-4] if '.fna' in cols[3] else cols[3] + tani = float(cols[4]) + pairs[(id1, id2)] = tani + for ref_pair, ref_tani in ref_pairs.items(): + tani = pairs[ref_pair] + assert abs(tani - ref_tani) < 0.03 + + +@pytest.mark.parametrize('outfmt,ref_cols',[ + ('standard', vclust.ALIGN_OUTFMT['standard']), + ('lite', vclust.ALIGN_OUTFMT['lite']), + ('complete', vclust.ALIGN_OUTFMT['complete']), +]) +def test_align_outfmt(test_dir, outfmt, ref_cols): + out_file = test_dir.joinpath('ani.tsv') + cmd = [ + f'{VCLUST.resolve()}', + 'align', + '-i', + f'{FASTA_FILE}', + '-o', + f'{out_file}', + '--outfmt', + f'{outfmt}' + ] + p = subprocess.run(cmd) + with open(out_file) as fh: + cols = fh.readline().split() + assert cols == ref_cols + + +@pytest.mark.parametrize('input,params',[ + (FASTA_DIR, []), + (FASTA_FILE, []), + (FASTA_FILE, ['--batch-size', '4']), +]) +def test_workflow_prefilter_align(test_dir, input, params): + filter_file = test_dir.joinpath('filter.txt') + ani_file = test_dir.joinpath('ani.tsv') + cmd = [ + f'{VCLUST.resolve()}', + 'prefilter', + '-i', + f'{input}', + '-o', + f'{filter_file}' + ] + cmd.extend(params) + p = subprocess.run(cmd) + assert p.returncode == 0 + assert p.stderr == None + assert filter_file.exists() + assert filter_file.stat().st_size + + cmd = [ + f'{VCLUST.resolve()}', + 'align', + '-i', + f'{input}', + '-o', + f'{ani_file}', + '--filter', + f'{filter_file}' + ] + p = subprocess.run(cmd) + assert p.returncode == 0 + assert p.stderr == None + assert ani_file.exists() + assert ani_file.stat().st_size + + +@pytest.mark.parametrize('algorithm',[ + 'single', + 'complete', + 'uclust', + 'cd-hit', + 'set-cover', +]) +def test_cluster_algorithm(test_dir, algorithm): + out_file = test_dir / 'clusters.tsv' + cmd = [ + f'{VCLUST.resolve()}', + 'cluster', + '-i', + f'{ANI_FILE}', + '--ids', + f'{IDS_FILE}', + '-o', + f'{out_file}', + '--algorithm', + f'{algorithm}', + '--metric', + 'tani', + '--tani', + '0.95', + ] + p = subprocess.run(cmd, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL) + assert p.returncode == 0 + assert p.stderr == None + assert out_file.exists() + assert out_file.stat().st_size + + +def test_cluster_algorithm_leiden(test_dir): + out_file = test_dir / 'clusters.tsv' + cmd = [ + f'{VCLUST.resolve()}', + 'cluster', + '-i', + f'{ANI_FILE}', + '--ids', + f'{IDS_FILE}', + '-o', + f'{out_file}', + '--algorithm', + 'leiden', + '--metric', + 'tani', + '--tani', + '0.95', + ] + p = subprocess.run(cmd, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL) + assert p.returncode == 0 + assert p.stderr == None + assert out_file.exists() + assert out_file.stat().st_size \ No newline at end of file diff --git a/vclust.py b/vclust.py new file mode 100755 index 0000000..9e6acbc --- /dev/null +++ b/vclust.py @@ -0,0 +1,1185 @@ +#!/usr/bin/env python3 +"""Compute Average Nucleotide Identity (ANI) and cluster virus genome sequences. + +https://github.com/refresh-bio/vclust-dev +""" + +import argparse +import logging +import multiprocessing +import pathlib +import shutil +import subprocess +import sys +import typing +import uuid + +__version__ = '1.0' + +DEFAULT_THREAD_COUNT = min(multiprocessing.cpu_count(), 64) + +VCLUST_DIR = pathlib.Path(__file__).resolve().parent + +# Default paths to third-party binaries +BIN_DIR = VCLUST_DIR / 'bin' +BIN_KMERDB = BIN_DIR / 'kmer-db' +BIN_LZANI = BIN_DIR / 'lz-ani' +BIN_CLUSTY = BIN_DIR / 'clusty' +BIN_FASTASPLIT = BIN_DIR / 'multi-fasta-split' + +# lz-ani output columns +ALIGN_FIELDS = [ + 'idx1', 'idx2', 'id1', 'id2', 'tani', 'gani', 'ani', 'cov', + 'num_alns', 'len_ratio', 'len1', 'len2', 'nt_match', 'nt_mismatch', +] +# vclust align output formats +ALIGN_OUTFMT = { + 'lite': ALIGN_FIELDS[:2] + ALIGN_FIELDS[4:9], + 'standard': ALIGN_FIELDS[:10], + 'complete': ALIGN_FIELDS[:], +} + + +def get_parser() -> argparse.ArgumentParser: + """Return an argument parser.""" + + fmt = lambda prog: CustomHelpFormatter(prog, max_help_position=32) + + def input_path_type(value): + path = pathlib.Path(value) + if not path.exists(): + msg = f'input does not exist: {value}' + raise argparse.ArgumentTypeError(msg) + return path + + def ranged_float_type(value): + f = float(value) + if f < 0 or f > 1: + raise argparse.ArgumentTypeError('must be between 0 and 1') + return f + + parser = argparse.ArgumentParser( + description=f'%(prog)s v.{__version__}: calculate ANI and cluster ' + 'virus (meta)genome sequences', + add_help=False, + ) + parser.add_argument( + '-v', '--version', + action='version', + version=f'v.{__version__}', + help="Display the tool's version and exit" + ) + parser.add_argument( + '-h', '--help', + action='help', + help='Show this help message and exit' + ) + + subparsers = parser.add_subparsers(dest='command') + + # Prefilter parser + prefilter_parser = subparsers.add_parser( + 'prefilter', + help='Prefilter genome pairs for alignment', + formatter_class=fmt, + add_help=False, + ) + + prefilter_optional = prefilter_parser._action_groups.pop() + prefilter_required = prefilter_parser.add_argument_group('required arguments') + prefilter_parser._action_groups.append(prefilter_optional) + + prefilter_required.add_argument( + '-i', '--in', + metavar='', + type=input_path_type, + dest='input_path', + help='Input FASTA file or directory with FASTA files', + required=True + ) + prefilter_required.add_argument( + '-o', '--out', + metavar='', + type=pathlib.Path, + dest='output_path', + help='Output filename', + required=True + ) + prefilter_parser.add_argument( + '-k', '--k', + metavar="", + type=int, + default=25, + choices=range(15, 31), + help="Size of k-mer for Kmer-db [%(default)s]" + ) + prefilter_parser.add_argument( + '--min-kmers', + metavar="", + type=int, + default=10, + help='Filter genome pairs based on minimum number of shared k-mers ' + '[%(default)s]' + ) + prefilter_parser.add_argument( + '--min-ident', + metavar="", + type=ranged_float_type, + default=0.7, + help='Filter genome pairs based on minimum sequence identity of ' + 'the shorter sequence (0-1) [%(default)s]' + ) + prefilter_parser.add_argument( + '--batch-size', + metavar="", + type=int, + default=0, + help='Split a multifasta file into smaller files of n FASTA sequences. ' + 'This option reduces memory at the expense of speed. By default, no ' + 'batch [%(default)s]' + ) + prefilter_parser.add_argument( + '--keep_temp', + action="store_true", + help='Keep temporary Kmer-db files [%(default)s]' + ) + prefilter_parser.add_argument( + '--bin', + metavar='', + type=pathlib.Path, + dest="bin_kmerdb", + default=f'{BIN_KMERDB}', + help='Path to the Kmer-db binary [%(default)s]' + ) + prefilter_parser.add_argument( + '--bin-fasta', + metavar='', + type=pathlib.Path, + dest="bin_fastasplit", + default=f'{BIN_FASTASPLIT}', + help='Path to the multi-fasta-split binary [%(default)s]' + ) + prefilter_parser.add_argument( + '-t', '--threads', + metavar="", + dest="num_threads", + type=int, + default=DEFAULT_THREAD_COUNT, + help='Number of threads (all by default) [%(default)s]' + ) + prefilter_parser.add_argument( + '-v', '--verbose', + action="store_true", + help="Show Kmer-db progress" + ) + prefilter_parser.add_argument( + '-h', '--help', + action='help', + help='Show this help message and exit' + ) + + # Align parser + align_parser = subparsers.add_parser( + 'align', + help='Align genome sequences and calculate ANI metrics', + formatter_class=fmt, + add_help=False, + ) + align_optional = align_parser._action_groups.pop() + align_required = align_parser.add_argument_group('required arguments') + align_parser._action_groups.append(align_optional) + align_required.add_argument( + '-i', '--in', + metavar='', + type=input_path_type, + dest='input_path', + help='Input FASTA file or directory with FASTA files', + required=True + ) + align_required.add_argument( + '-o', '--out', + metavar='', + type=pathlib.Path, + dest='output_path', + help='Output filename', + required=True + ) + align_parser.add_argument( + '--filter', + metavar='', + type=input_path_type, + dest="filter_path", + help='Path to filter file (output of prefilter)' + ) + align_parser.add_argument( + '--filter-threshold', + metavar='', + dest='filter_threshold', + type=ranged_float_type, + default=0, + help='Align genome pairs above the threshold (0-1) [%(default)s]' + ) + align_parser.add_argument( + '--outfmt', + metavar='', + choices=ALIGN_OUTFMT.keys(), + dest='outfmt', + default='standard', + help='Output format [%(default)s]\n' + f'choices: {",".join(ALIGN_OUTFMT.keys())}' + ) + align_parser.add_argument( + '--out-ani', + dest='ani', + metavar='', + type=ranged_float_type, + default=0, + help='Min. ANI to output (0-1) [%(default)s]' + ) + align_parser.add_argument( + '--out-tani', + dest='tani', + metavar='', + type=ranged_float_type, + default=0, + help='Min. tANI to output (0-1) [%(default)s]' + ) + align_parser.add_argument( + '--out-gani', + dest='gani', + metavar='', + type=ranged_float_type, + default=0, + help='Min. gANI to output (0-1) [%(default)s]' + ) + align_parser.add_argument( + '--out-cov', + dest='cov', + metavar='', + type=ranged_float_type, + default=0, + help='Min. coverage (aligned fraction) to output (0-1) [%(default)s]' + ) + align_parser.add_argument( + '--bin', + metavar='', + type=pathlib.Path, + dest='bin_lzani', + default=f'{BIN_LZANI}', + help='Path to the lz-ani binary [%(default)s]' + ) + align_parser.add_argument( + '--mal', + metavar='', + type=int, + default=11, + help='Min. anchor length [%(default)s]' + ) + align_parser.add_argument( + '--msl', + metavar='', + type=int, + default=7, + help='Min. seed length [%(default)s]' + ) + align_parser.add_argument( + '--mrd', + metavar='', + type=int, + default=40, + help='Max. dist. between approx. matches in reference [%(default)s]' + ) + align_parser.add_argument( + '--mqd', + metavar='', + type=int, + default=40, + help='Max. dist. between approx. matches in query [%(default)s]' + ) + align_parser.add_argument( + '--reg', + metavar='', + type=int, + default=35, + help='Min. considered region length [%(default)s]' + ) + align_parser.add_argument( + '--aw', + metavar='', + type=int, + default=15, + help='Approx. window length [%(default)s]' + ) + align_parser.add_argument( + '--am', + metavar='', + type=int, + default=7, + help='Max. no. of mismatches in approx. window [%(default)s]' + ) + align_parser.add_argument( + '--ar', + metavar='', + type=int, + default=3, + help='Min. length of run ending approx. extension [%(default)s]' + ) + align_parser.add_argument( + '-t', '--threads', + metavar='', + dest='num_threads', + type=int, + default=DEFAULT_THREAD_COUNT, + help='Number of threads (all by default) [%(default)s]' + ) + align_parser.add_argument( + '-v', '--verbose', + action="store_true", + help="Show LZ-ANI progress" + ) + align_parser.add_argument( + '-h', '--help', + action='help', + help='Show this help message and exit' + ) + + # Cluster parser + cluster_parser = subparsers.add_parser( + 'cluster', + help='Cluster genomes based on ANI thresholds', + formatter_class=fmt, + add_help=False, + ) + cluster_optional = cluster_parser._action_groups.pop() + cluster_required = cluster_parser.add_argument_group('required arguments') + cluster_parser._action_groups.append(cluster_optional) + + cluster_required.add_argument( + '-i', '--in', + metavar='', + type=input_path_type, + dest='input_path', + help='Input file with ANI metrics (tsv)', + required=True + ) + cluster_required.add_argument( + '-o', '--out', + metavar='', + type=pathlib.Path, + dest='output_path', + help='Output filename', + required=True + ) + cluster_required.add_argument( + '--ids', + metavar='', + type=input_path_type, + dest='ids_path', + help='Input file with sequence identifiers (tsv)', + required=True + ) + cluster_parser.add_argument( + '-r', '--out-repr', + action='store_true', + dest='representatives', + help='Output a representative genome for each cluster instead of ' + 'numerical cluster identifiers. The representative genome is selected ' + 'as the one with the longest sequence. [%(default)s]' + ) + choices = ['single', 'complete', 'uclust', 'cd-hit', 'set-cover', 'leiden'] + cluster_parser.add_argument( + '--algorithm', + metavar='', + dest="algorithm", + choices=choices, + default='single', + help='Clustering algorithm [%(default)s]\n' + '* single: Single-linkage (connected component)\n' + '* complete: Complete-linkage\n' + '* uclust: UCLUST\n' + '* cd-hit: Greedy incremental\n' + '* set-cover: Greedy set-cover (MMseqs2)\n' + '* leiden: Leiden algorithm' + ) + choices = ['tani','gani','ani'] + cluster_parser.add_argument( + '--metric', + metavar='', + dest='metric', + choices=choices, + default='tani', + help='Similarity metric for clustering [%(default)s]\n' + f'choices: {",".join(choices)}' + ) + cluster_parser.add_argument( + '--tani', + metavar='', + dest='tani', + type=ranged_float_type, + default=0, + help='Min. total ANI (0-1) [%(default)s]\n' + ) + cluster_parser.add_argument( + '--gani', + metavar='', + dest='gani', + type=ranged_float_type, + default=0, + help='Min. global ANI (0-1) [%(default)s]\n' + ) + cluster_parser.add_argument( + '--ani', + metavar='', + dest='ani', + type=ranged_float_type, + default=0, + help='Min. ANI (0-1) [%(default)s]\n' + ) + cluster_parser.add_argument( + '--cov', + metavar='', + dest='cov', + type=ranged_float_type, + default=0, + help='Min. coverage/aligned fraction (0-1) [%(default)s]\n' + ) + cluster_parser.add_argument( + '--num_alns', + metavar='', + dest='num_alns', + type=int, + default=0, + help='Max. number of local alignments between two genomes; 0 means all ' + 'genome pairs are allowed. [%(default)s]' + ) + cluster_parser.add_argument( + '--leiden-resolution', + metavar='', + type=ranged_float_type, + default=0.7, + help='Resolution parameter for the Leiden algorithm [%(default)s]\n' + ) + cluster_parser.add_argument( + '--bin', + metavar='', + type=pathlib.Path, + dest="BIN_CLUSTY", + default=f'{BIN_CLUSTY}', + help='Path to the Clusty binary [%(default)s]' + ) + cluster_parser.add_argument( + '-v', '--verbose', + action="store_true", + help="Show Clusty progress" + ) + cluster_parser.add_argument( + '-h', '--help', + action='help', + help='Show this help message and exit' + ) + + # Show help message if the script is run without any arguments. + if len(sys.argv[1:]) == 0: + parser.print_help() + parser.exit() + + # Show subparser help message if the script is run without any arguments. + subparsers = [ + ('prefilter', prefilter_parser), + ('align', align_parser), + ('cluster', cluster_parser), + ] + for name, subparser in subparsers: + if sys.argv[-1] == name: + subparser.print_help() + parser.exit() + + return parser + + +def create_logger(name: str, log_level: int = logging.INFO) -> logging.Logger: + """Returns a logger to log events. + + Args: + name: + Name of the logger. + log_level: + The numeric level of the logging event (one of DEBUG, INFO etc.). + + """ + logger = logging.getLogger(name) + logger.setLevel(log_level) + + # Set log format to handlers + formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(message)s') + + # Create stream logger handler + sh = logging.StreamHandler() + sh.setLevel(log_level) + sh.setFormatter(formatter) + logger.addHandler(sh) + + return logger + + +def get_uuid() -> str: + """Returns a unique string identifier.""" + return f'vclust-{str(uuid.uuid4().hex)[:16]}' + + +def validate_binary(bin_path: pathlib.Path) -> pathlib.Path: + """Verifies if a binary file exists and is executable. + + Args: + bin_path (Path): Path to the executable binary file. + + Returns: + Path to the binary file. + + Raises: + SystemExit: If the binary file is not found or not executable. + + """ + if not bin_path.exists(): + exit(f'error: executable not found: {bin_path.resolve()}') + if not shutil.which(bin_path): + exit(f'error: file not executable: {bin_path.resolve()}') + return bin_path + + +def validate_args_fasta_input(args, parser) -> argparse.Namespace: + """Validates the arguments for FASTA input.""" + args.is_multifasta = True + args.fasta_paths = [args.input_path] + + if args.input_path.is_dir(): + args.is_multifasta = False + args.fasta_paths = sorted( + f for f in args.input_path.iterdir() if f.is_file() + ) + + if not args.is_multifasta and len(args.fasta_paths) < 2: + parser.error(f'Too few fasta files found in {args.input_path}. ' + f'Expected at least 2, but found {len(args.fasta_paths)}.') + + return args + + +def validate_args_prefilter(args, parser) -> argparse.Namespace: + """Validates the arguments for the prefilter command.""" + if args.batch_size and args.input_path.is_dir(): + parser.error('--batch-size only handles a multi-fasta file' + ', not a directory.') + return args + + +def validate_args_cluster(args, parser) -> argparse.Namespace: + """Validates the arguments for the cluster command.""" + # Check the metric and its threshold. + args_dict = vars(args) + args.metric_threshold = args_dict.get(args.metric, 0) + if not args.metric_threshold: + parser.error(f'{args.metric} threshold must be above 0. ' + f'Specify the option: --{args.metric}') + + # Check if the input TSV file has the required columns. + with open(args.input_path) as fh: + header = fh.readline().split() + if 'idx1' not in header and 'idx2' not in header: + parser.error( + f'missing columns `idx1` and `idx2` in {args.input_path}') + options = ['tani', 'gani', 'ani', 'cov', 'num_alns'] + for name in options: + value = args_dict[name] + if value != 0 and name not in header: + parser.error(f'missing column `{name}` in {args.input_path}') + return args + + +def run( + cmd: typing.List[str], + verbose: bool, + logger: logging.Logger + ) -> subprocess.CompletedProcess: + """Runs a given command as a subprocess and handle logging. + + Returns: + subprocess.CompletedProcess: Completed process information. + + """ + logger.info(f'Running: {" ".join(cmd)}') + process = subprocess.run( + cmd, + stdout=subprocess.DEVNULL, + stderr=None if verbose else subprocess.PIPE, + text=True, + ) + if process.returncode: + logger.error(f'While running: {" ".join(process.args)}') + logger.error(f'Error message: {process.stderr}') + exit(1) + logger.info(f'Done') + return process + + +def cmd_fastasplit( + input_fasta: pathlib.Path, + out_dir: pathlib.Path, + n: int, + verbose: bool, + bin_path = BIN_FASTASPLIT + ) -> typing.List[str]: + """Constructs the command line for multi-fasta-split. + + Args: + input_fasta (Path): + Path to the input FASTA file. + out_dir (Path): + Path to the output directory. + n (int): + Number of sequences per output FASTA file. + verbose (bool): + Whether to display verbose output. + bin_path (Path): + Path to the multi-fasta-split executable. + + Returns: + list: The constructed command as a list of strings. + + """ + cmd = [ + f'{bin_path}', + '-n', f'{n}', + f'--verbosity', + f'{int(verbose)}', + '--out-prefix', + f'{out_dir}/part', + f'{input_fasta}', + ] + return cmd + + +def cmd_kmerdb_build( + input_paths: pathlib.Path, + txt_path: pathlib.Path, + db_path: pathlib.Path, + is_multisample_fasta: bool, + kmer_size: int, + num_threads: int, + verbose: bool = False, + bin_path: pathlib.Path = BIN_KMERDB + ) -> typing.List[str]: + """Constructs the command line for Kmer-db build. + + Args: + input_fasta (Path): + Path to the input FASTA file or directory with input FASTA files. + outfile_txt (Path): + Path to the output text file that will list the input FASTA files. + outfile_db (Path): + Path to the output kmer-db database file. + kmer_size (int): + k-mer size. + num_threads (int): + Number of threads to use in kmer-db. + verbose (bool): + Whether to display verbose output. + bin_path (Path): + Path to the kmer-db executable. + + Returns: + list: The constructed command as a list of strings. + + """ + # Create a text file listing input FASTA files. + with open(txt_path, 'w') as oh: + for f in input_paths: + oh.write(f'{f}\n') + + # Run kmer-db build. + cmd = [ + f"{bin_path}", + "build", + "-k", f"{kmer_size}", + "-t", f"{num_threads}", + f'{txt_path}', + f'{db_path}', + ] + if is_multisample_fasta: + cmd.insert(2, '-multisample-fasta') + return cmd + + +def cmd_kmerdb_all2all( + db_paths: typing.List[pathlib.Path], + db_list_path: pathlib.Path, + outfile_all2all: pathlib.Path, + kmer_count: int, + num_threads: int, + verbose: bool, + bin_path: pathlib.Path = BIN_KMERDB + ) -> typing.List[str]: + """Constructs the command line for Kmer-db all2all. + + Args: + db_paths (list[Path]): + List of paths to the input kmer-db database files. + db_list_path (Path): + Path to the output text file listing the kmer-db database files. + outfile_all2all (Path): + Path to the output all2all file. + kmer_count (int): + Minimum number of shared k-mers to report in all2all output. + num_threads (int): + Number of threads to use in kmer-db. + verbose (bool): + Whether to display verbose output. + bin_path (Path): + Path to the kmer-db executable. + + Returns: + list: The constructed command as a list of strings. + + """ + with open(db_list_path, 'w') as oh: + for db_path in db_paths: + oh.write(f'{db_path}\n') + + cmd = [ + f"{bin_path}", + 'all2all-parts' if len(db_paths) > 1 else 'all2all', + '-sparse', + '-above', f'{kmer_count}', + "-t", f"{num_threads}", + f'{db_list_path}' if len(db_paths) > 1 else f'{db_paths[0]}', + f'{outfile_all2all}', + ] + return cmd + + +def cmd_kmerdb_distance( + infile_all2all: pathlib.Path, + min_value: float, + num_threads: int, + verbose: bool = False, + bin_path: pathlib.Path = BIN_KMERDB + ) -> typing.List[str]: + """Constructs the command line for Kmer-db distance. + + Args: + infile_all2all (Path): + Path to the input all2all file. + min_value (float): + Minimum value to filter all2all output. + num_threads (int): + Number of threads to use in kmer-db. + verbose (bool): + Whether to display verbose output. + bin_path (Path): + Path to the kmer-db executable. + + Returns: + list: The constructed command as a list of strings. + + """ + cmd = [ + f"{bin_path}", + "distance", + "ani-shorter", + "-sparse", + '-above', f'{min_value}', + "-t", f"{num_threads}", + f'{infile_all2all}', + ] + return cmd + + +def cmd_lzani( + input_paths: typing.List[pathlib.Path], + txt_path: pathlib.Path, + output_path: pathlib.Path, + out_format: typing.List[str], + out_tani: float, + out_gani: float, + out_ani: float, + out_cov: float, + filter_file: pathlib.Path, + filter_threshold: float, + mal: int, + msl: int, + mrd: int, + mqd: int, + reg: int, + aw: int, + am: int, + ar: int, + num_threads: int, + verbose: bool, + bin_path: pathlib.Path = BIN_LZANI + ) -> typing.List[str]: + """Constructs the command line for LZ-ANI. + + Args: + input_paths (List[Path]): + List of paths to the input FASTA files. + txt_path (Path): + Path to the output text file listing the input FASTA files. + output_path (Path): + Path to the output ANI file. + out_format (List[str]): + List of LZ-ANI column names. + out_tani (float): + Minimum tANI to output. + out_gani (float): + Minimum gANI to output. + out_ani (float): + Minimum ANI to output. + out_cov (float): + Minimum coverage (aligned fraction) to output. + filter_file (Path): + Path to the filter file (prefilter's output). + filter_threshold (float): + Filter threshold. + mal (int): + Minimum anchor length. + msl (int): + Minimum seed length. + mrd (int): + Maximum distance between approximate matches in reference. + mqd (int): + Maximum distance between approximate matches in query. + reg (int): + Minimum considered region length. + aw (int): + Approximate window length. + am (int): + Maximum number of mismatches in approximate window. + ar (int): + Minimum length of run ending approximate extension. + num_threads (int): + Number of threads to use in lz-ani. + verbose (bool): + Whether to display verbose output. + bin_path (Path): + Path to the lz-ani executable. + + Returns: + list: The constructed command as a list of strings. + + """ + # Create a text file listing input FASTA files. + with open(txt_path, 'w') as oh: + for f in input_paths: + oh.write(f'{f}\n') + + cmd = [ + f'{bin_path}', + 'all2all', + '--in-txt', + f'{txt_path}', + '-o', + f'{output_path}', + '-t', + f'{num_threads}', + '--verbose', f'{int(verbose) + 1}', + '--mal', f'{mal}', + '--msl', f'{msl}', + '--mrd', f'{mrd}', + '--mqd', f'{mqd}', + '--reg', f'{reg}', + '--aw', f'{aw}', + '--am', f'{am}', + '--ar', f'{ar}', + '--multisample-fasta', + 'true' if len(input_paths) == 1 else 'false', + '--out-type', 'tsv', + '--out-format', + ','.join(out_format), + ] + if filter_file: + cmd.extend(['--flt-kmerdb', f'{filter_file}', f'{filter_threshold}']) + + cols = [ + ('tani', out_tani), ('gani', out_gani), + ('ani', out_ani), ('cov', out_cov) + ] + for name, value in cols: + if value > 0: + cmd.extend(['--out-filter', f'{name}', f'{value}']) + + if verbose: + cmd.extend(['--verbose', '2']) + + return cmd + + +def cmd_clusty( + input_path: pathlib.Path, + ids_path: pathlib.Path, + output_path: pathlib.Path, + algorithm: str, + metric: str, + tani: float, + gani: float, + ani: float, + cov: float, + num_alns: int, + is_representatives: bool, + leiden_resolution: float, + bin_path=BIN_CLUSTY, + ) -> typing.List[str]: + """Constructs the command line for Clusty. + + Args: + input_path (Path): + Path to the input ANI file. + ids_path (Path): + Path to the input file with sequence identifiers. + output_path (Path): + Path to the output file. + algorithm (str): + Clustering algorithm. + metric (str): + Similarity metric for clustering. + metric_threshold (float): + Similarity threshold. + tani (float): + Minimum tANI. + gani (float): + Minimum gANI. + ani (float): + Minimum ANI. + cov (float): + Minimum coverage (aligned fraction). + num_alns (int): + Maximum number of local alignments between two genomes. + is_representatives (bool): + Whether to output a representative genome for each cluster. + leiden_resolution (float): + Resolution parameter for the Leiden algorithm. + verbose (bool): + Whether to display verbose output. + bin_path (Path): + Path to the clusty executable. + + Returns: + list: The constructed command as a list of strings. + + """ + cmd = [ + f'{bin_path}', + '--objects-file', + f'{ids_path}', + '--algo', + f'{algorithm}', + f'--id-cols', + 'idx1', 'idx2', + '--distance-col', + f'{metric}', + '--similarity', + '--numeric-ids', + ] + cols = [('tani', tani), ('gani', gani), ('ani', ani), ('cov', cov)] + for name, value in cols: + if value > 0: + cmd.extend(['--min', f'{name}', f'{value}']) + if num_alns > 0: + cmd.extend(['--max', 'num_alns', f'{num_alns}']) + if is_representatives: + cmd.append('--out-representatives') + if algorithm == 'leiden': + cmd.extend(['--leiden-resolution', f'{leiden_resolution}']) + + cmd.extend([f'{input_path}', f'{output_path}']) + return cmd + + +class CustomHelpFormatter(argparse.HelpFormatter): + """Custom help message formatter for argparse.""" + + def _format_action_invocation(self, action): + # Allows options with arguments to be formatted as + # "arg1, arg2 metavar" instead of the "arg1 metavar, arg2 metavar". + # https://stackoverflow.com/a/31124505 + if not action.option_strings or action.nargs == 0: + return super()._format_action_invocation(action) + default = self._get_default_metavar_for_optional(action) + args_string = self._format_args(action, default) + return ', '.join(action.option_strings) + ' ' + args_string + + def _split_lines(self, text, width): + # Allows inserting new lines on argparse help text. + # https://stackoverflow.com/a/56865996 + r = [] + for t in text.splitlines(): + r.extend(argparse.HelpFormatter._split_lines(self, t, width)) + return r + + +def main(): + parser = get_parser() + args = parser.parse_args() + + # Initialize logger + logger = create_logger( + name='vclust', + log_level=logging.INFO if args.verbose else logging.ERROR, + ) + + # Prefilter + if args.command == 'prefilter': + args.bin_kmerdb = validate_binary(args.bin_kmerdb) + args = validate_args_prefilter(args, parser) + args = validate_args_fasta_input(args, parser) + + out_dir = args.output_path.parent / get_uuid() + out_dir.mkdir(parents=True, exist_ok=True) + logger.info(f'Creating a temp directory: {out_dir}') + + batches = [] + # Input is a directory of fasta files. + if not args.is_multifasta: + batches.append(args.fasta_paths) + else: + # Split multi-fasta file. + if args.batch_size: + args.bin_fastasplit = validate_binary(args.bin_fastasplit) + cmd = cmd_fastasplit( + input_fasta=args.input_path, + out_dir=out_dir, + n=args.batch_size, + verbose=args.verbose, + bin_path=args.bin_fastasplit, + ) + p = run(cmd, args.verbose, logger) + for f in out_dir.glob('part_*'): + batches.append([f]) + batches.sort() + # Do not split multi-fasta file. + else: + batches.append([args.input_path]) + + num_batches = len(batches) + db_paths = [] + for i, batch in enumerate(batches): + logger.info(f'Processing batch: {i+1} / {num_batches}') + batch_id = f'part_{i:05d}' if num_batches > 1 else 'whole' + txt_path = out_dir / f'{batch_id}.txt' + db_path = out_dir / f'{batch_id}.kdb' + + # kmer-db build. + cmd = cmd_kmerdb_build( + input_paths=batch, + txt_path=txt_path, + db_path=db_path, + is_multisample_fasta=args.is_multifasta, + kmer_size=args.k, + num_threads=args.num_threads, + verbose=args.verbose, + bin_path=args.bin_kmerdb, + ) + p = run(cmd, args.verbose, logger) + db_paths.append(db_path) + + # Regardless of verbosity, always delete the partial FASTA file + # after building the corresponding partial k-mer database. + if num_batches > 1: + batch[0].unlink() + + # Run kmer-db all2all. + db_list_path = out_dir / 'db_list.txt' + all2all_path = out_dir / 'all2all.txt' + + cmd = cmd_kmerdb_all2all( + db_paths=db_paths, + db_list_path=db_list_path, + outfile_all2all=all2all_path, + kmer_count=args.min_kmers, + num_threads=args.num_threads, + verbose=args.verbose, + bin_path=args.bin_kmerdb, + ) + p = run(cmd, args.verbose, logger) + + cmd = cmd_kmerdb_distance( + infile_all2all=all2all_path, + min_value=args.min_ident, + num_threads=args.num_threads, + verbose=args.verbose, + bin_path=args.bin_kmerdb, + ) + p = run(cmd, args.verbose, logger) + + out_ani = out_dir / 'all2all.txt.ani-shorter' + out_ani.rename(args.output_path) + + if not args.keep_temp: + if out_dir.exists(): + logger.info(f'Removing directory: {out_dir}') + shutil.rmtree(out_dir) + + # Align + elif args.command == 'align': + args.bin_lzani = validate_binary(args.bin_lzani) + args = validate_args_fasta_input(args, parser) + + out_dir = args.output_path.parent / get_uuid() + out_dir.mkdir(parents=True, exist_ok=True) + txt_path = out_dir / 'ids.txt' + + logger.info(f'Creating temporary directory: {out_dir}') + + # Run lz-ani. + cmd = cmd_lzani( + input_paths=args.fasta_paths, + txt_path=txt_path, + output_path=args.output_path, + out_format=ALIGN_OUTFMT[args.outfmt], + out_tani=args.tani, + out_gani=args.gani, + out_ani=args.ani, + out_cov=args.cov, + filter_file=args.filter_path, + filter_threshold=args.filter_threshold, + mal=args.mal, + msl=args.msl, + mrd=args.mrd, + mqd=args.mqd, + reg=args.reg, + aw=args.aw, + am=args.am, + ar=args.ar, + num_threads=args.num_threads, + verbose=args.verbose, + bin_path=args.bin_lzani, + ) + p = run(cmd, args.verbose, logger) + + if out_dir.exists(): + logger.info(f'Removing directory: {out_dir}') + shutil.rmtree(out_dir) + + # Cluster + elif args.command == 'cluster': + args.BIN_CLUSTY = validate_binary(args.BIN_CLUSTY) + args = validate_args_cluster(args, parser) + + cmd = cmd_clusty( + input_path=args.input_path, + ids_path=args.ids_path, + output_path=args.output_path, + algorithm=args.algorithm, + metric=args.metric, + tani=args.tani, + gani=args.gani, + ani=args.ani, + cov=args.cov, + num_alns=args.num_alns, + is_representatives=args.representatives, + leiden_resolution=args.leiden_resolution, + bin_path=args.BIN_CLUSTY, + ) + p = run(cmd, args.verbose, logger) + +if __name__ == '__main__': + main() \ No newline at end of file