├── .gitignore ├── .readthedocs.yml ├── CHANGELOG.md ├── CONDUCT.md ├── CONTRIBUTING.md ├── LICENSE ├── README.md ├── docs ├── Makefile ├── changelog.md ├── conduct.md ├── conf.py ├── contributing.md ├── example.ipynb ├── index.md ├── make.bat └── requirements.txt ├── poetry.lock ├── pyproject.toml ├── src └── seqwalk │ ├── __init__.py │ ├── analysis.py │ ├── design.py │ ├── filtering.py │ ├── generation.py │ ├── io.py │ └── prebuilt_libs │ ├── __init__.py │ └── kishi2018.txt └── tests └── test_seqwalk.py /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | pip-wheel-metadata/ 24 | share/python-wheels/ 25 | *.egg-info/ 26 | .installed.cfg 27 | *.egg 28 | MANIFEST 29 | 30 | # PyInstaller 31 | # Usually these files are written by a python script from a template 32 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 33 | *.manifest 34 | *.spec 35 | 36 | # Installer logs 37 | pip-log.txt 38 | pip-delete-this-directory.txt 39 | 40 | # Unit test / coverage reports 41 | htmlcov/ 42 | .tox/ 43 | .nox/ 44 | .coverage 45 | .coverage.* 46 | .cache 47 | nosetests.xml 48 | coverage.xml 49 | *.cover 50 | *.py,cover 51 | .hypothesis/ 52 | .pytest_cache/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | target/ 76 | 77 | # Jupyter Notebook 78 | .ipynb_checkpoints 79 | 80 | # IPython 81 | profile_default/ 82 | ipython_config.py 83 | 84 | # pyenv 85 | .python-version 86 | 87 | # pipenv 88 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 89 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 90 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 91 | # install all needed dependencies. 92 | #Pipfile.lock 93 | 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 95 | __pypackages__/ 96 | 97 | # Celery stuff 98 | celerybeat-schedule 99 | celerybeat.pid 100 | 101 | # SageMath parsed files 102 | *.sage.py 103 | 104 | # Environments 105 | .env 106 | .venv 107 | env/ 108 | venv/ 109 | ENV/ 110 | env.bak/ 111 | venv.bak/ 112 | 113 | # Spyder project settings 114 | .spyderproject 115 | .spyproject 116 | 117 | # Rope project settings 118 | .ropeproject 119 | 120 | # mkdocs documentation 121 | /site 122 | 123 | # mypy 124 | .mypy_cache/ 125 | .dmypy.json 126 | dmypy.json 127 | 128 | # Pyre type checker 129 | .pyre/ 130 | **__pycache__ 131 | 132 | # PyCharm 133 | .idea/ 134 | 135 | # RStudio project files 136 | **.Rproj.user/ 137 | **.Rproj.user* 138 | **.Rproj 139 | **.Rhistory 140 | 141 | # MacOS 142 | .DS_Store -------------------------------------------------------------------------------- /.readthedocs.yml: -------------------------------------------------------------------------------- 1 | # Read the Docs configuration file for Sphinx projects 2 | # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details 3 | 4 | # Required 5 | version: 2 6 | 7 | # Set the OS, Python version and other tools you might need 8 | build: 9 | os: ubuntu-22.04 10 | tools: 11 | python: "3.9" 12 | # You can also specify other tool versions: 13 | # nodejs: "20" 14 | # rust: "1.70" 15 | # golang: "1.20" 16 | 17 | # Build documentation in the "docs/" directory with Sphinx 18 | sphinx: 19 | configuration: docs/conf.py 20 | # You can configure Sphinx to use a different builder, for instance use the dirhtml builder for simpler URLs 21 | # builder: "dirhtml" 22 | # Fail on all warnings to avoid broken references 23 | # fail_on_warning: true 24 | 25 | # Optionally build your docs in additional formats such as PDF and ePub 26 | # formats: 27 | # - pdf 28 | # - epub 29 | 30 | # Optional but recommended, declare the Python requirements required 31 | # to build your documentation 32 | # See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html 33 | python: 34 | install: 35 | - requirements: docs/requirements.txt 36 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Changelog 2 | 3 | ## v0.3.3 (23/10/2024) 4 | - Verbosity arguments 5 | 6 | ## v0.3.1 (22/03/2024) 7 | 8 | - Fixed odd-k incrementing in max_orthogonality 9 | 10 | ## v0.3.0 (22/03/2024) 11 | 12 | - Added hash-based filtering 13 | 14 | ## v0.2.1 (11/03/2024) 15 | 16 | - Fixed 3 letter filtering indexing 17 | 18 | ## v0.2.0 (10/03/2024) 19 | 20 | - Fixed adapted_hierholzer function for RC free library generation 21 | 22 | 23 | ## v0.1.0 (22/06/2022) 24 | 25 | - First release of `seqwalk`! -------------------------------------------------------------------------------- /CONDUCT.md: -------------------------------------------------------------------------------- 1 | # Code of Conduct 2 | 3 | ## Our Pledge 4 | 5 | In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation. 6 | 7 | ## Our Standards 8 | 9 | Examples of behavior that contributes to creating a positive environment include: 10 | 11 | * Using welcoming and inclusive language 12 | * Being respectful of differing viewpoints and experiences 13 | * Gracefully accepting constructive criticism 14 | * Focusing on what is best for the community 15 | * Showing empathy towards other community members 16 | 17 | Examples of unacceptable behavior by participants include: 18 | 19 | ## Our Responsibilities 20 | 21 | Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior. 22 | 23 | Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. 24 | 25 | ## Scope 26 | 27 | This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. 28 | 29 | ## Enforcement 30 | 31 | Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately. 32 | 33 | Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership. 34 | 35 | ## Attribution 36 | 37 | This Code of Conduct is adapted from the [Contributor Covenant homepage](http://contributor-covenant.org/version/1/4), version 1.4. 38 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing 2 | 3 | Contributions are welcome, and they are greatly appreciated! Every little bit 4 | helps, and credit will always be given. 5 | 6 | ## Types of Contributions 7 | 8 | ### Report Bugs 9 | 10 | If you are reporting a bug, please include: 11 | 12 | * Your operating system name and version. 13 | * Any details about your local setup that might be helpful in troubleshooting. 14 | * Detailed steps to reproduce the bug. 15 | 16 | ### Fix Bugs 17 | 18 | Look through the GitHub issues for bugs. Anything tagged with "bug" and "help 19 | wanted" is open to whoever wants to implement it. 20 | 21 | ### Implement Features 22 | 23 | Look through the GitHub issues for features. Anything tagged with "enhancement" 24 | and "help wanted" is open to whoever wants to implement it. 25 | 26 | ### Write Documentation 27 | 28 | You can never have enough documentation! Please feel free to contribute to any 29 | part of the documentation, such as the official docs, docstrings, or even 30 | on the web in blog posts, articles, and such. 31 | 32 | ### Submit Feedback 33 | 34 | If you are proposing a feature: 35 | 36 | * Explain in detail how it would work. 37 | * Keep the scope as narrow as possible, to make it easier to implement. 38 | * Remember that this is a volunteer-driven project, and that contributions 39 | are welcome :) 40 | 41 | ## Get Started! 42 | 43 | Ready to contribute? Here's how to set up `seqwalk` for local development. 44 | 45 | 1. Download a copy of `seqwalk` locally. 46 | 2. Install `seqwalk` using `poetry`: 47 | 48 | ```console 49 | $ poetry install 50 | ``` 51 | 52 | 3. Use `git` (or similar) to create a branch for local development and make your changes: 53 | 54 | ```console 55 | $ git checkout -b name-of-your-bugfix-or-feature 56 | ``` 57 | 58 | 4. When you're done making changes, check that your changes conform to any code formatting requirements and pass any tests. 59 | 60 | 5. Commit your changes and open a pull request. 61 | 62 | ## Pull Request Guidelines 63 | 64 | Before you submit a pull request, check that it meets these guidelines: 65 | 66 | 1. The pull request should include additional tests if appropriate. 67 | 2. If the pull request adds functionality, the docs should be updated. 68 | 3. The pull request should work for all currently supported operating systems and versions of Python. 69 | 70 | ## Code of Conduct 71 | 72 | Please note that the `seqwalk` project is released with a 73 | Code of Conduct. By contributing to this project you agree to abide by its terms. 74 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2022, Gokul Gowri 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | 23 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # seqwalk 2 | 3 | `seqwalk` is a package for designing orthogonal DNA sequence libraries. It can efficiently generate libraries of sequences that satisfy sequence symmetry minimization constraints (i.e. minimizing longest common substrings). `seqwalk` additionally includes off-the-shelf orthogonal sequence libraries, as well as some tools for analyzing orthogonal sequence libraries. 4 | A code-free, interactive version of `seqwalk` can be found [here](https://colab.research.google.com/drive/1eVbcn_b5EE5FcL9NL5EyxeFAqNoImNSa?usp=sharing). 5 | 6 | For more details, see the [paper](https://www.biorxiv.org/content/10.1101/2022.07.11.499592v1.abstract). 7 | 8 | ## Installation 9 | 10 | ```bash 11 | $ pip install seqwalk 12 | ``` 13 | 14 | ## Usage 15 | 16 | ### Designing a set of barcodes with minimal sequence symmetry 17 | 18 | If you want a certain number of barcodes with maximum orthogonality, you can use the `max_orthogonality` function from the `design` module. You must specify the length of desired sequences (L) and the number of desired sequences (N). Optionally, specify the prevention of reverse complementary sequences, GC content limits, allowable alphabet, and specific prevented patterns. By default, reverse complementary sequences are allowed, there are no GC content constraints, a 3 letter (A/C/T, no G) code is used and any 4N sequence is prevented. 19 | 20 | For example, if you want 100 barcodes with length 25, with prevented reverse complements, and a 4 letter alphabet, and between 10 and 15 G/C bases, you can use the following code: 21 | 22 | ```python 23 | from seqwalk import design 24 | 25 | library = design.max_orthogonality(100, 25, alphabet="ACGT", RCfree=True, GClims=(10, 15)) 26 | ``` 27 | 28 | This will generate a library of at least the specified size, with the strongest possible sequence symmetry constraint. 29 | 30 | ### Designing a set of orthogonal barcodes with maximum size 31 | 32 | If you have an orthogonality constraint in mind, you can use the `max_size` function from the `design` module to generate a maximally sized library with the given sequence symmetry minimization k values. That is, the shortest k for which no substring of length k appears twice. 33 | 34 | If you want sequences that satisfy SSM for k=12, and you want barcodes of length 25, without considering reverse complementarity, and using a 4 letter alphabet, with no GC constraints, you can use the following code: 35 | 36 | ```python 37 | from seqwalk import design 38 | 39 | library = design.max_size(25, 12, alphabet="ACGT") 40 | ``` 41 | 42 | ### Importing "off-the-shelf" experimentally characterized libraries 43 | 44 | The `io` module provides the ability to import libraries that have been previously experimentally characterized, using code of the following format. 45 | 46 | ```python 47 | from seqwalk import io 48 | 49 | PERprimers = io.load_library("kishi2018") 50 | ``` 51 | 52 | We provide the following libraries, accessible with the identifier tag. 53 | 54 | | identifier | # of seqs | seq length | original use case | ref | 55 | |------------|-----------|------------|-------------------|-----| 56 | | `kishi2018` | 50 | 9nt | PER primers | [Kishi et al, 2018](https://www.nature.com/articles/nchem.2872) | 57 | 58 | If you have an orthogonal library you would like to add, please submit a PR! 59 | 60 | ### Quality control using pairwise comparisons 61 | 62 | Once you have a library in the form of a list of sequences, you can use the `analysis` module to perform additional quality control. For example, we provide a function to compute pairwise Hamming distances. 63 | 64 | ```python 65 | from seqwalk import analysis 66 | 67 | h_crosstalk = analysis.hamming_matrix(seqs) 68 | ``` 69 | 70 | Since sequence symmetry minimization does not explicitly guarantee low off-target hybridization strength, a simple function for using NUPACK to identify "bad" sequences is included in the `analysis.py` file. However, it is commented out to avoid the NUPACK dependency in the package (problematic due to NUPACK licensing). 71 | 72 | ## License 73 | 74 | `seqwalk` is licensed under the terms of the MIT license. 75 | 76 | ## Credits 77 | 78 | `seqwalk` was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter). 79 | -------------------------------------------------------------------------------- /docs/Makefile: -------------------------------------------------------------------------------- 1 | # Minimal makefile for Sphinx documentation 2 | 3 | # You can set these variables from the command line. 4 | SPHINXOPTS = 5 | SPHINXBUILD = python -msphinx 6 | SPHINXPROJ = seqwalk 7 | SOURCEDIR = . 8 | BUILDDIR = _build 9 | 10 | # Put it first so that "make" without argument is like "make help". 11 | help: 12 | @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 13 | 14 | .PHONY: help Makefile 15 | 16 | # Catch-all target: route all unknown targets to Sphinx using the new 17 | # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). 18 | %: Makefile 19 | @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) -------------------------------------------------------------------------------- /docs/changelog.md: -------------------------------------------------------------------------------- 1 | ```{include} ../CHANGELOG.md 2 | ``` -------------------------------------------------------------------------------- /docs/conduct.md: -------------------------------------------------------------------------------- 1 | ```{include} ../CONDUCT.md 2 | ``` -------------------------------------------------------------------------------- /docs/conf.py: -------------------------------------------------------------------------------- 1 | # Configuration file for the Sphinx documentation builder. 2 | # 3 | # This file only contains a selection of the most common options. For a full 4 | # list see the documentation: 5 | # https://www.sphinx-doc.org/en/master/usage/configuration.html 6 | 7 | # -- Project information ----------------------------------------------------- 8 | 9 | project = u"seqwalk" 10 | copyright = u"2022, Gokul Gowri" 11 | author = u"Gokul Gowri" 12 | 13 | # -- General configuration --------------------------------------------------- 14 | 15 | # Add any Sphinx extension module names here, as strings. They can be 16 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom 17 | # ones. 18 | extensions = [ 19 | "myst_nb", 20 | "autoapi.extension", 21 | "sphinx.ext.napoleon", 22 | "sphinx.ext.viewcode", 23 | ] 24 | autoapi_dirs = ["../src"] 25 | 26 | # List of patterns, relative to source directory, that match files and 27 | # directories to ignore when looking for source files. 28 | # This pattern also affects html_static_path and html_extra_path. 29 | exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] 30 | 31 | # -- Options for HTML output ------------------------------------------------- 32 | 33 | # The theme to use for HTML and HTML Help pages. See the documentation for 34 | # a list of builtin themes. 35 | # 36 | html_theme = "sphinx_rtd_theme" 37 | -------------------------------------------------------------------------------- /docs/contributing.md: -------------------------------------------------------------------------------- 1 | ```{include} ../CONTRIBUTING.md 2 | ``` -------------------------------------------------------------------------------- /docs/example.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Example usage\n", 8 | "\n", 9 | "In this tutorial, we will demonstrate three core capabilities of the `seqwalk` package.\n", 10 | "\n", 11 | "1. We will use the `seqwalk.design` module to design maximal orthogonal sequence libraries using the novel methods outlined in our preprint (coming soon!). \n", 12 | "2. We will use the `seqwalk.analysis` module to analyze orthogonal sequence libraries. \n", 13 | "3. We will use the `seqwalk.io` module to load \"off-the-shelf\" orthogonal sequence libraries from previous publications." 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": 1, 19 | "metadata": {}, 20 | "outputs": [], 21 | "source": [ 22 | "from seqwalk import io\n", 23 | "from seqwalk import design\n", 24 | "from seqwalk import analysis\n", 25 | "\n", 26 | "import seaborn as sns" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "## Designing sequences using seqwalk\n", 34 | "\n", 35 | "The algorithms presented in our preprint are the first that allow for the design of maximally orthogonal and maximally sized orthogonal sequence libraries. The `seqwalk` package implements these algorithms in two design functions: a `max_size` function which designs maximally sized libraries for a given set of constraints, and a `max_orthogonality` function, which designs a library of desired size, with the strictest possible orthogonality constraints. \n", 36 | "\n", 37 | "## Maximally-sized orthogonal library design\n", 38 | "\n", 39 | "To design a maximally-sized orthogonal sequence library, we must specify a desired sequence length, and an orthogonality constraint in the form of an SSM k-value. This value is the smallest $k$ for which no substring of length $k$ appears twice in the library. For example, SSM k=3 means that no length 3 string can repeat multiple times in a library.\n", 40 | "\n", 41 | "Optionally, one can specify the prevention of reverse complementary sequences, GC content limits, allowable alphabet, and specific prevented patterns. By default, reverse complementary sequences are allowed, there are no GC content constraints, a 3 letter (A/C/T, no G) code is used and any 4N (AAAA, CCCC, ...) sequence is prevented. To see in detail how to specify each these constraints, see the API reference for `seqwalk.design.max_orthogonality()`\n", 42 | "\n", 43 | "Suppose we want to design the maximal set of 25nt sequences that satisfy SSM for k=12, with a 4 letter alphabet, without considering reverse complementary sequences, and no GC or pattern constraints. **We need to write only a single line of code, which executes in <1 minute!**\n", 44 | "\n", 45 | "(Note that the Python implementation is slightly slower than the Julia implementation, which can be found in the supplement of the preprint.)" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 2, 51 | "metadata": {}, 52 | "outputs": [ 53 | { 54 | "name": "stdout", 55 | "output_type": "stream", 56 | "text": [ 57 | "The 25mer library has 1198372 sequences\n", 58 | "CPU times: user 30.6 s, sys: 464 ms, total: 31 s\n", 59 | "Wall time: 31.5 s\n" 60 | ] 61 | } 62 | ], 63 | "source": [ 64 | "%%time\n", 65 | "\n", 66 | "huge_25mer_library = design.max_size(25, 12, alphabet=\"ACGT\", prevented_patterns=[])\n", 67 | "\n", 68 | "print(\"The 25mer library has %d sequences\" % (len(huge_25mer_library)))" 69 | ] 70 | }, 71 | { 72 | "cell_type": "markdown", 73 | "metadata": {}, 74 | "source": [ 75 | "## Maximally orthogonal library design\n", 76 | "\n", 77 | "To design a library of minimum size with maximal orthogonality, we instead need to specify a minimum library size and desired sequence length. The same optional arguments apply, with the addition of an optional `k_init` parameter which serves as an initial lower-bound for the lowest SSM k for which a library of the desired size can be designed.\n", 78 | "\n", 79 | "\n", 80 | "Suppose we need only 200 barcodes with length 25, with prevented reverse complements, and a 4 letter alphabet, and between 10 and 15 G/C bases, and no 4N homopolymers. We can use the following design code:" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 3, 86 | "metadata": {}, 87 | "outputs": [ 88 | { 89 | "name": "stdout", 90 | "output_type": "stream", 91 | "text": [ 92 | "Number of sequences: 204\n", 93 | "SSM k value: 6\n" 94 | ] 95 | } 96 | ], 97 | "source": [ 98 | "small_25mer_library = design.max_orthogonality(200, 25, \n", 99 | " alphabet=\"ACGT\", prevented_patterns=[])" 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "Note that the identified minimum k-value is half that used in the large library design problem. Based on sequence symmetry, this library will have significantly less crosstalk than the large 25mer library." 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "## Quality control using pairwise comparisons\n", 114 | "\n", 115 | "While `seqwalk.design` uses a graph-theoretic representation of sequence symmetry constraints for efficient orthogonal sequence design, the `analysis` module supports pairwise comparisons of sequences in a library for quality control. For example, you can compare the Hamming distances of each pair of sequences in a library as a form of additional quality control. Note that these functions can be applied to any set of sequences, not just those designed using `seqwalk`." 116 | ] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": 4, 121 | "metadata": {}, 122 | "outputs": [ 123 | { 124 | "data": { 125 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWMAAAEGCAYAAACw+/QIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOy9e3hW1bktPlYSQqCEJBBulQqNwVJ/UStEN5TWExELm+MNASkWrICXYlEU0aK0ghfUKo2iqFsUtIaWgqCoHAoVMFulckrAqhwbJbCJBwqBYG4IgVzW7485x7veOb8PCJJ242nm8/Spi+/L+tb1ne8c73jHCMIwRMtoGS2jZbSM/96R8N99AC2jZbSMltEyWoJxy2gZLaNlnBKjJRi3jJbRMlrGKTBagnHLaBkto2WcAqMlGLeMltEyWsYpMFqCcctoGS2jZZwC4x8WjIMgGBIEwadBEJQEQTDtH/U7LaNltIyW8f/C+IcE4yAIEgE8DeDfAZwFYHQQBGf9I36rZbSMltEy/rtGEATfCoLg7SAIPgmC4P8EQTDZ/vvMIAh2BUHwV/u/ocfbV9I/6BgvAFAShuF2e2B/AHAFgE/+Qb/XMlpGy2gZ/x2jHsAdYRhuDoIgFcCmIAjesp89Hobh7Kbu6B8FU5wG4P+q7Z3231pGy2gZLeP/mRGG4e4wDDfb/64B8Dd8xVj3j8qMT2gkJZ8WAkDF+LORdH6O81nj9lIEGWkIzsg220WbEGSkIayoAgAkZPUwX+yQCQCoXbgKrftnI8hIBwCEFZUIMtJlPwAQ9O2HcNMG2Yf8u/qNA+v3Ibmj2XVy705o3F+DpMF5AID61YWo31eLpE4p8m/4otz8/soiAHCOQY+wolL+O8hIl+0gI13+NmVorvM3/j75N4ffL3G+y3PltQi3lcgxNG4vlXPl9eB2WFGFhNy+AIDqOauQeml2dIxnZMs153b96kJzn/zfOcp27cJV5jjt9p6Za9H11nOjE+yQidqFq9xzz+oNVJYj3FYi1+do11F/7l9ffZ41K0rQfqx7vQ6/X4LW/bP1rnD4ffOb/vXm+fNY433OZyo6hjTn3/gs6/OtXVmEpE4pAID6fbVI7t0JQUYaGkp2AgASs7sjyEhHdYF5DtqPzTX32j6vfOb1MVbPWYV2Azo5v1k9Z5Vz/uiQicaiTfKdeNdTXz//87Ci0jw79h2s37gFSefnxNyD6NpUOv9WXVAU86zx2Tra/a1dWYSMZYUBTnLUlW9vsg5EcqczbgJwo/qneWEYzvO/FwRBTwDnAfjfAAYAmBQEwbUAimCy54pj/U7wj9CmCIKgP4CZYRgOttt3A0AYhg+r79wIe4JzfnhW33FnfQsZCz7Gax0uRM82B9C5Rw0AIPXSbBx+vwTJvc2D1bi/BgeLa+W32g3ohO2/r0XWNSnO53wQE7J6SCDmS5YyZog5hh4Gxt46/HlUHmqN7115QPZbvy/6DQDYsj4T3buYlyqzf6L8O4Mx9xVW7TW/e7o3qXy+BUFaZzSue0P+TQfBoMdZCNI6I6zaK/sAAFSWR/so2oSEQYMRpHUGAOwe9xS6zrw4Clg2cHKf8QZfPr5AfOhrVph9pF6ajZoVJfKSNJTsRGJ2d/n7ICMdCXkjkJDWGY32OMOqvUg8PQf1H69zjzvdBudNG5A47HrnWmB7sQRnAEg4Jw8Nr70Q/U7ffgjSOsu5JqR1Rv3H62QbAMLST5zzcSbcjHTsefJDdJ15sfmyPZbGNauj6/NFOeo3bpH9JQ3OQ7itBNueLgMAZP/yO6guKJIApr/L7zPAMWjpSRwAdm5ORXb+AAm+W9Znos+EKJbsXVGJrk+Miu7zF+WoXVmE5N6d5B7VrixCypghso8206egYVkBtv/ePKO9lt2AxnVvyDWuX/AbE4D79gMA7LltMTpfmm72Z6959ZxVaNs7Re5tQ8lO8yzbpKJxe6lcUyD2vTtY0Qrp2XU4sh9YvdXsY8TtKTET+95Sc/6AmYQBoPOl6bLPvy5vJ+9d/b5aVJa0Mtdje7H8Vv3GLfLbByta4dsfvnXywXjv1iYHvladex3394IgaAfgPwHMCsPw1SAIugAoBxACeABAtzAMxx9rH/+ozHgjgF5BEHwbwC4APwZwjf6CnVnmAcCh+VNDAHhteQaGffEOFnS6CINhgnFYUYX31nfDxf2/AcDgKskda7FzcyoAoN0AoF37WgAmGCedn4P25wN7nvwQAND5UsjDccQGnBT7wDUUFQAAsq5Jweb5IXasbgUAOOPnXZCYDSQMvByACdbpbQ7LQ5SQ1QPVBUVoN6CTBGHABAc+zDg9xwTWD94x21m9kXh6DoJhJpg0vPaCeWHU3zcWLkVw3oXRi5meCXxRLgEzYdBgYHsx6jYuBQB0vfVc1K8uRPn7DQCALmOBI8X7kLS/UK5F4/ZSJA4fK5MAX0idcQbnXYh2FQWy3W5Ap2jl0TFVVhJynlV7UW8nF573kWUF5vg40jPlhQorqqJzg5mojixeKoEgOCMbYdVeEzzs3wRpnRGWfoIw3QT8xspyBD3OMtcYUMdvgm91QRHaTx4iwfnw+yXoemuu3I/61YVodePN5ti+iCa4+n21UTb+RTnKCkqRdY25z/Ubt+Avxd2QZ4OwBAsb4IMeZ6H92Ch4AkD7yUOwZ+ZaeVayepvf5m+cub8IQCe5Vp2xGrDnBsCer8mAeb1aV1QCX5RL9lw37xkkZndH5x775PoDdpKDeU70/crsn4gD6/chNSMNDfZcDla0QltAAnZ5wWJ0HZWJpB9eDQA48vgvEFZUInH4WADA3nFPIbN/FLyTbWLTfmwuBtuMPcjIde5huwGdkNxxn0winS/thAPr98kkknVNKr53ZQ0SOpp3GftqzXXbXmwunH0OkrJ6I3nuQgBA6qU90CwjbGye/QAIgqAVgGUAfheG4asAEIZhmfr8eQArjreff0gwDsOwPgiCSQBWA0gEsCAMw/9zvL/r2eYAFnS6COP3vY0PkvsAAJI77sP25O74gb35yb07obKklfxN4/4apGfXyUsZVlSioWQn2mbUAYiCU2J2d+wttQHczvqb55vJ8XtXHsCZvWvlcy5vGcCyrknBgfX7wIAPQLIhvggMnLJUr9qLxnVvREGtQyYaq/bKC8MlJv8+6YdXo/6Dd0xWbLM4VJZH0AMgLxiz9iSYJWzb4hJ77lVo3T9blrdhRSUSsnqYQMflYlZvJJyeg0YbkMKKSoTr3ojgHrhL0qBvPxMs7N8H510oGSvPBbBB3k4iCefkmXvDz1QGDERBg8eZdEa2rAqc8UW5m6khCsL6753vq8FlNAAcLK5F+w/eQZCR5mR7SZ1SBAZK6pSCA9UpyNxfI/tIR51kZW17pwAlDfI74RfvIKyoRFKnFLl+nAwa7T4Ss7sjKauHt3SPri8TBXmOeBzr96Ht/mfM9vk5qN+4RQKhWeHtdDLwICM9yiazepvzVs9LuwGdzDNnr1l6dh0SOqbL33e99VyEmzagnpOhhVd4XG0z6lC/rw6m/BNBd43bS8114fmcnoNG+xwEFZVo3T8tBrrhqjch6zsIMiol6Ulh4qKel/CDd4Cs3gLDcPI46dHYPME4CIIAwHwAfwvDMF/9e7cwDHfbzWEAtsT7ez3+YZhxGIYrAaw8kb/p3KMGg1GDD5L74LxdmwEAVdd8Hz/evxNvbjAP4vDeh9E2ow7vlncBAGR1PIzK9xuQjgiCSKiowmfF7QAAlWiFgRPqUVZQip6DDbywd0Ut2mbsQ9+p5gavnW2+036seaEk67UB6PD7Fmu0DwmzUb2cCreVGExysoFAGte9YR4c+0JUz1mFtPyz5Pv1G7eg1Y03SwCqf/0ZBOddiIZlBUgaf4fZR2WhuTB8OG1wYZbFbLBt7ygoJQy8HMEZNlMq2oSEgZejYVmBZDjhB++gsTLKthtKdro4fVZvhGtWR8v9tM4I1fcDmAweWb2RdPZAc+wfr3MCIVcESVeYTLT+3SUAgEQL3dS//kzMvU9I64xGlRHxWJh9H1mZj6T9UXbbuO4Nwe0Bk5HWLlyFNtOnAACSlxWYcxs1wmwXLxRMk0E8oWMqGvfX4Mh+83NJnYDufWpQuLwbAGDQrNOQvvpTHKwwk3/7USOQiaURdjtjDMosBMDjPlBQhLYZwMFikwwk7ysxtQV7jZM7ujhqY9EmE8jt31fftxDtBnTC3tJWyJ5slvfEf8sKzCSS2d/sL1EF+NqVRXLuQVpnVK9fKM/zkf1A5YpKdMamqO6xcBUSh4+NJoGs3khI64yqKSaeEMLg5JLc0UIuv/yO/J6e+DnqF/xGsv7gDFsvmDQGgEkm2vaucaC9xmUFsnpMyBthnq10NXnb2oGMSnfC/aojbKhvlv3AYMNjAXwcBMFf7b/dA0Pn/R4MTLEDwE3H29EpUcBrGS2jZbSMf+poJpgiDMP3YHIUf5xQIgr8gwp4Jzq+nD4yBKKl0ZHifYLBpT32Z1Q/9O8yAxcuz8CgZw1WCgCvvZmJ4dcdlmXhweJapF4aMRn2PPkh2mbU4Q/bu+PHWWYf7QZ0wub5oRTkut56rin2PDHKHND2YlQXFElG1PXWc80y2c74jWtWW9gCUugitHGk2Pw7Cy7M3JJGjUC9xkmJrdmMKNy0QZZrggEya7KD1X/i5dkLrsCe2xY7RarGNaujzMQWDBMGXo66eSYbTXnwGdR/vA6Na1bLfveuqIz2wcFM18tMgh5nIfH0HHwxYjzazxgTHdumDbKETDg9x2DiZ0SVco3Z1s17BkmjRgjsElZURQUnhZfrgmfisOvx2aBZUqhNyO3rQBZkbzisjA6Z8pwQl0wYNBjV9y2Uv2NGDQDvre+GnC7l6GIzyuefrMWNv82T49z2dBl6LbtBMjk+M/WLl0b7z+0rxTH+7pHifZJ9E97ifeVqqFFBIy4cYZ6l6jmrZNUVbivB4fdLJBM+NCvfKfDx3EumrAcAyWa5MgAgdYOjsVS2PV2GM37eJYZZIquCyUNQv7rQwD/2uAjTVc8xx9F+xhgDWxQulf2zGKm/L0XY3L4IepyFhmUFRy1CBz3OQkqfy0+6gHekdHPT2RQ9+pz07zVlnFQwDoJgAYBLAewNwzDH/lsHAIsB9IRJz68+HqXj4OzrQ8A8fO+t74btyYkSOFMvzUb7e/6ImsW3mC9/UY4103fhgt4Gjmk/Nhdrpu/CoEU2mFSWo3bhKoE1RtyeIpSmH937AQBg5WWtkNAxFS8UtAYA3HBrCsoKSgX6GLkwTyrQHP7L0lCyEztWt8IZPzd/E1ZUOS96+8lDBLoAgLT8KVExjyOrt7zora67B1+MGI/0+Y8IdBFW7QW2F0cQgaVEcaLi5LV3hfmcdDGHQtQh0yz7VJDTL4hPIQorqhwan/O3iFgjQVpnYT8EZ2QDX5RLwSks/QQJ5+RF51H6iQRXAHGDOTFjXr+0/ClOQZSFyEOzzDKabIN6VVwjy4BDf36wuBbp8x9xJ4kvyh22RO3KIlSWtHLu+7KXWmPE7SlyPasLiuS4GzWcYyeicNMGQzn0Ag7P45V792Dkwryo+GkxUV7joMdZqJv3TFTUAmSiql9s7llCx1QkDh8rkAIZR5reVrOiRI6zZPzr6Dm4TtgfACwMl+ZQxlKG5jrJgYZ5aucudBge8oz17YdaW1xLGTME+KIcCXnmbyonTEO7AZ0c9kp1QZFg3SmTxqB+8VL5DQDA9mIE513oJCRJ4+9wnrU2w6adfDDeUdT0YNwz92sRjC8EcADAyyoYPwrgizAMH7GaFBlhGP7iWPs59NojIRBxiA+/XyLBdNhl5UganIfUUU8BAKru/L6wGQCDZbXun421s78EAAx69lw0Fm2S4Fn+fgO63nouiqbvQO6z5qW7evJ7ePn8A5K1PraqI6ZNaiOFhiPF+2LwMBZRAPMyHFi/D6mXZguO1/XWc1Hy4KeShchLrrm1moameLiAyRyT75xpMDf78Po0tPqNW5zqP7mm/B5gGRcaV7PZclTgNFkos/BDs/LRun92lJVX7XWyZjI45Fh19q3oWMjqLcFCArkdmgUBmMwuYeDlElhTJo0x+7L7AUyg0y/h4fct9mpfXAl6ZELYrJj4ZOOa1ThSvE+2mb0mDBqMPbctBmAoVgm5fSWD7N6nRrJQIJpQ5R7blZOeMOrmPWOyTRXEDr9fIkXmrreeG5OR1i5cFQVrxToBoqBYv3FLFKRsgsFgy/PWk1/96kIn+69fvFQKvc45KZpeYnZ3pyAWbtogyUP7GWPc5yC3b8QXt+fB90zf73BbibxHSePvwJHHZjoTCxAVMBMGXu4WuRm0NWZsj6vVdfeY4353SfME4+1/aXowzrrg1A/GgBCdV6hg/CmAvDAMdwdB0A1AYRiG3znWPghTNO6viblx6+YnYdCs06QCTtiCM3rR9B3oMyGQG/nKpC24rN9OedhrF67Ckf0RLxIwL3/R6FXIGWCCSXLvTlj2UmuMnBsVsri8BUxwqV9dKMvHhIGXm0KYWm76vEzALv9ttupzR8mJJTe08aNCyS6ZQZc8+Ck696iRZSCbJTgRAfblsoGgdu5Cc972Ya5fvBRJg/MQ9DhLsqiDFYbHqTN4Dack3zkTjR8VyvknjRoBVJZHE4OFQKrvW+hANIRQALNM1kwGBnSdhevCYVhRiZoVJSYbttk0Az5XDsEZ2SiZsh7d+5hJNmWMWSaTjpidP0AyLyDKrPV5cFLiJPvam5kYeX9XhyN8sKKVwBRSkFUNPTJxABF0kJ4pAb7L2B4IK6qEvtW9Tw2Se3eK4CubfeqJi0tzAFFwUxxo4f+qCbH6voXRymJ7sWH/2ASk1Y03I0jrjL8MmA0AyH02N1r+k35o7wcn4YZlBUjI6iHMEvJ9mfWyEcXn6pP7DlgmxUeFsTDFR+YehNtKEJyRHdH47KqAQT9h0OBo1abONUjr7FBE21x0/UkHx8PbNjQ58LU+o9/XNhhXhmGYbv87AFDB7aMNwhQ1K0qQ3NE8CKSmtZ88BGsmfohBs0yHYVhRifb3/BFvd+gPAOgzIcCB9fskYNWvLkTh8gz0bGOI5Nn5A1AyZT3O+HkXVY1ORNKoEfICcfuVMYUADLQR9O3nZgYqGxciuyXocyT3dpdkpNkBUUAnJ7jzpekONp40/g5UTpjmdiTZY+CL3Lp/trMEZqDhJCHYq+qe4gTBSaC6oMgh+5cVlAomDgCb54c4f+W1EhyOFO9zlv+cMBOHjxUcOqFjqtNQIBmqypz10hPpmaiduzCiK2Wky0tJ1gdgYRoV+NLnP4L6Bb8BEDVXONkis00AJVPWG3yXUInFtKvvW4i0fIO1hqWfoGhiEXJn9bTXz9wvyTDtPZdJx0IFzFgb16zG9t/X4oyfd5GJZ++KSmT2T3RwXy7HOVrdeLMEFycDBqTrUPN1CdGEmvplryGfC95/cz3ThD8OAG8NXYRBiy42/O7HZgKwk+z2Ygn4+pg4BLqASXq+d+UBpws1Mbu7PHNyH+Hizmz4ABCdl72nglmTQWMhCgcCI83UTjQJHVPxjVmvnHww/uy9pgfjM3/w9Q/GdrsiDMOMOH8nHXhP/nufvuPPy8KB9fuE6/vBEXODh11W7nT+tB+bi6LpO3DRF+8DAHZ9vxfa9k7BgpUmENw4w2Q6y15qLX8z8v6uqN+4RV4ywhAalkgZM0QgBMnaPIiBgxlam+kRDhxWVKKsoBTdXjTYtgQeRfnSAalkynpkL7giuiC2mOdkPHbo7NBpTbYZqaZqAYiBOZz2ce8z/hu7o7rOvNiZZFr3z3ZwQWnz9gp7zHoACM4sWengPAd71nAUYDrK2MGnceX6d5dIFrV73FPo9uIt8rl0mZGvbX+f95BBkL/JYhM7M4GomKeLbbqDrnX/bGx7usw2FZkJtHF/jQM57Jm5Fu+Wd8Hw6w4DMJPE6q3dMewyr7FEwSfSdWfvrW4p5mQp1w3RpEvYwW/DThx2vcHCFeRQO3ehBNLalUXYsj4TubN6SoCum/eMCcCqiUZDR0f2w2mdXjN9F/KurJBjKpmyHp171Bganq1ZdBnbw2lBT8jt60CGrW68GY3r3nBWUEDUci0Uv8py4aqHVXvlmACzqm2WzLj4P5sejHv/j69tMD5hmIIdeJqMz8Cy7KXWGHl/VwkObCclm+G0P29FzeJbZGn0l+Ju+MGA3ZItbJpdCQBIb3NYlrgcUuG2nVtaf4HwBhAVSHTm1Vi0yclsEwYNloAFmIemcc3qmAdRrpvVomj76CMATEcel4z6e62uuwd1Lz1k/sZmynqfUgACYhonEk7PMQ0WFnMEIMcr10Avn2FxaNVxJ0HNZmk85soJ02TSIHtCs0GcSr2X9XK5zN9g+3Wr6+6JOMg+v9RCAQxiSWcPFG62PncGF40fAwozViscBhs+d2yr53NA6IT3o6Fkp5NBVhcUIS1/Cqqm5EsSccbPu2Db02VY12D2cXlGGXaWpeHM3uZc2s8Yg9q5C51nq6FkpyQcyR0jmIcjyEg39Qg7ecuyXtUSWG8AoglXT7As/Or2+0Oz8h1GxpH9kIngr8vboXuXKoHZGreXSp0EiGCjHYfayaqVXOfd40x9p/Ol6Ugaf4fDptCD0J0ujre68WaBTACY52B7saPb0mbC7JMPxn97u+nB+LsXfW2D8WMA9qsCXocwDO861j4YjEse/BTt2tciPbtOCiCdL03HuvlJuHiqaYcOK6pMd5LKHlJHPYXqh/7dHI8VRPlLsSHuD5xQLze7cLlJ0C/ovRvJHaPAROoR90m2BF8QPoDULOg5uE6yFL2PlEljIizW0zNgduhXxLn8ZxaROHysZH+Nn29xixevP+Nk+FwSOxmxKoI5bdXqvx0WgBVn4bm2H5uLPU9+KLgpiywcicOul6YOX3xITwqHZuVHwVAfB0wgPfL4L2IhCUC1UFc6mS6Xt7oQlXTFzThwk2n396lsrW68WYqTHFz6M4D7FKrahasciIyQmc5i/VFWUOpoS7CQRhy1ZPzrJoja83rl3j0YeX9XOQZm/HqFZa5plPnyNzjZt5k+xSm0coLh5Fg7d6HTtl00scjUVVQnINk/+pw0YwMw74EU9Cx2zomsbW8jktVYtEk6Wc9feS2qpuSjw9IFAIADN41HZUkrfPPVBwCYuoiGhYLzLkTVlHxZrRD6Sr5zpnRpkg6qIZC2U184+WD8f9Y2PRj/fxef+sE4CIJFAPIAZAIoAzADwHIASwCcDqAUhtr2xbH2o9kUAJwlLCvoa0abWX7Qs2amnjfZ3KwfZ+0U+hsA1Dw72uH7vrmhO0bcnuJktq9M2iKiJkBUNNHLQeKzgHkhu4ztIZgzX9Z2Azo5fONNsyuRu8hmz16BhFxQwhZ7nvzQUS5r3F6K5Nt/jZ0X3xTxnf1uIxvMydcNq/YaLNQ+qAz8yXfONPu0hTjBdNVv+UpbOltkFsRz9F9iwgMCQ1g2gS5KOYI7C65wYIvE7O5C5QMU7a9DpsASjeveMBCEDeC1cxc6GTpgYR8GcbIxvHMUxsEH70gBjsfJZbp+7tixCESTW8mDnwKwmiXDrpcMlPSyvaWpDsXRWTFl9UDJg5+i17Ib5Dh+8cD/xaOv/sRsk76n8fYxQ5zCmM8cqd+4RQp/cr5q+a+fXcAE741DX8aZvcud2goTArneFlPnfSecx6HhFN1CruETh2ppJxAmVt989QEceWxmNPFbxoaWJaBimy5s+2pzzZIZb3mr6cE455JTPxg316gYnhcCkLZRLQ+oye6ACaTDLisX3G7N9F0mQNsXMXXiInxwWh+hmJU8+CnWNaThx1k7o2x61AhU37fQkcjUI8hIk8ALGCxs6eO1ggOS5nawuDZmqauX/RrPTczu7nBByVPmcWoNCs2NpVwiYJbNuogVZKSZpb1VSws3bXAaLSRLriyXJWt6dh1a93cpeVroBjBBSAdOXcxkoc55QbwGAq2eBkQ8ZAYcQkLEOP1ClDk3sy+dbW8d/rwEPV8GNSG3r1PUcni+iM3CAIPvasU1nzMsnFcb8GvnLpRlPQBZ5ocfvINX7t0DIFIuY0Bqm1Hn4KrMogVCuPVch0HTuL1UGlr8rFS3igtzhueomycs9loy/nUApukjIW+EoU0qydn61YVHpaURstEaGw0lOyO6nF0FJnf0mBUe7VRDe9VzVqHD0gXSHk+qnGYgUdRKa6E4rJjzc5onGH+0uunB+JzB/zrBWLMp2o/NdZbizJI1HPDe+m4YOKFeto/sh7xk239fi/N2bcau7/cCYJZTr72Zicv67ZQZum1GHdr2jmb0ypJWwgcFIrUzvkDp2XVI7t0J6+ab7nFi0ppPmp5dh6ROEUtBnw8AefhJxSJ+7Xdm6SBFSpmmw/nc2cTs7rFYrRZTsRk6/43Yqcbp9KpAOhiVtrPWTvCLiRyJw8e6tDQbHHkMCXkjImEhS8XSvFIpZCnqlW6WIOtAwzx6BdW6f7YDawAuxEKIQl8LNjZoGUkyBAC4uKW+ll7TSFp+xDbZPD9E7qyejua0M9F5TRNhRZWDq8r+lVqfNHBwVcBGHsW20KsXMkKYGACQVcXR2BPsBNTMHc2z92E5ICoMx+sSBSBFQ0fn+ozsSEjq8y2upGm8YZ8N3SnYHMG49q8rmhz4Ur536b9OMNYFvL0rKtE2ow6fFZsbmDurJ165d0+UlQ7OQ8mU9cK2GHF7CtbO/hI/GGA68lKG5qK6oAin/XkrAGDrd2Ot93aWpeF7Vx4Qmhlgsl8uq7v3qXFmbGZQfJB3rG4VU0lmgOfwGwy63nquFCOAaKmpAxqXhfLg2WU7Xxq/dZarCD8giaqYhUmOVeRjG7bGhQE4E0LQ4yz5G+F8evxQvw07RoFND04ynpaz5pcmnJMn3Gsgaj3WhUQtWF+/utChiPmNKRTb0UtvskQ0VXDH6lbScg2Y4Eq93aTzcyKuMeAEN013O1K8z4UULMcZgMMAASK6ly6YAq45Affh1yP8zkwWg488NtPpDt00uxI5A8rjwhfOZKWgJJ0M8bj0MQnUpTNy22xCmKxywjQpSMrwvu8XaYO0zo42NnXBOVkF513YLO3QtZvfaHowbobfa8r4ysE4CIJvAXgZQBcYZaJ5YRjOOZl2aK3v8N56U4CjVgCX1enZdUgZMwSvTDIvwbcbatFnQiBUtvOSq9BzcJ0E2l5/+wRvd+hv9Ih7RNngZ8WZ6Ds1HYDJPFiQAEw2qBs2WFgkllu/eCleezMTwy4rdx5aPvQAJJjrzjedLe65bbHZv8IK2z23wLQJT1bLPiUmT1xV60YEaZ1jME7BSW07tX4BiBGy4k0qm9CLbFHHWSYqvi8nB60SJr+jA77mrNpjdgpnqkFG82LJhpBJSHXk7V1RKdRBAE67NDNvydx1K7j9e2at1LruMraHQ9tjY4POjGME5S0/l9efXWu6+Lvt6TJZ+bTuH1tLoNoegCjDVTTKLmN7YNPsSnk+ATgQAVdgmtanR9C3nyQBgIFGBLKwvF+yK0Qh0CrxMeD/pbgbLp76DSf4kgLK3+R5+4Fbwys+S8mnZuqiKye0+sVLkfKgYdU0Vu1F40eFco4JAy9vnmC8aXnTg3HfK0/5YNwNRr1ejPgAXAngOpxoO7TKjIlX8gazkMRsoLqgyDRdWKyVZHQuNZ9/shYZDcAPM02Wu7MsDRd98T7e7tAflTAQwQ8G7MaR/ZDs+3tXHkBCx1TpmsrOHyAuBYBhT/x1eTuhJzHD0u4f1DPQBT0yP3j8PvyiHTVYPddZkibuA67mrdwHX9zeak8AJkgGaZ2lA0qGx+qIadhQOJ8OotwnAEccR6QYlQ4zf0e2PZYHea2AwV61zCQAd9Kx21qAR7JgFRiTzh4YuY1Yrqqcu51wNE/YgRwQNTL43GUOf3Kk4BHZI0AUKLnEp42SfrZ4nQFIWzMzVC774xVR5R7Y7kY/a9W6wXTRAICcAeVImTTGKaaxk5PPnxaTAszqr137WsdQQT+/xHa1fgWhJkIdAlOoCVXDWXzOdV3FX6UlDLw8pgmkWWCKjcuaHozPH/5PCcZJX/UPrXDybvvfNUEQ0IjvChiGBQD8FkAhgGMGY7+AkpjdXTLhNyq648YZXVE0fQcAoHsXs/xixpLexjxcXH79OCuiJJnPD+PtDv1x0RfvY99lBkdm1k1oo/z9VmibsQ9Z1xg8rHahfemjuoJdqppAwEAMAFvKzP9fsH63VXmzwve2lbatdd3QD7I51/RI8BuqUKmE3AG4Iu42oDhefjoDtZmyOD6cnmN0gi3uBkTUNAak+o1bkJAVCcKnTMp0GAuCFSs7Kdk/lcfSOiNUxt9JP7zaNGwwo2dWbbcPWWYEj53sAZ3Jsngmy2g7WQgmTxF0tQrQTSMhTCVe2Bnb3pBA7DQZWKofYHRMumRDJoHD75cgRd8LrnLspJjQMdVMLICTMeouvtYKgwYgOh0ClejORJiaR8/BBsJKzbC0PstJZ8t6YnZ32xlpVjlJJc+grKBU6IgAUF+8D0C7aHvxUmxZnykrN2p2MxAGffc6+ivd+xjhfSlI5/aNgdWCM7KRoM4tCqTmb/pOTTcQC6GnrB7OufLZT1KwHI0QpKHl9Bw0fL5FJu5mG83o9NFc4ysHYz08I74uSuF+DwyM0TJaRstoGafOaD5x+WYbzdH00Q6uEd8Jt0M/NXxA3/H9euPw+yU4st9oP/QcbLi8B4trMWJrIv409xIAETGfyyfiy+Qfa/0HwBTW2JXX6U1T1KsYfzbK32/AgWqTaZzx8y5Y+nitQBvdXrwFSy5bIi2uQUYatj1dJsdEXHBdQxquPd9kFqwyk3Ex6NlzHadltprqYkY8x2pmrgCcwh0QcUm1c4LOuqhf4EMbjmqahTGoUaDZH0Akoam5zNqjTb73wTtOAcmXzDyehGbtL292Cm5aOwIwHFSHO2zxWWmlnTTG1Vo4P0foW0AkTsRMLzG7u7QNc2iHYwAOP5hDty77bAw2z/jKZ76EpuZ1N4eEZtL5OULVAyAUTd3VV7OiRBhGukmKg63fWj5US2iyTVzDQfo8gKhb05fQ5GD2rV1mtGQpuen8DafWoGiQ/wgJzdr1v2s6TDHgJ6c2ZgyARnwrAKym/9NXaod++wVzEPbl07Qy6gFcs9IEuSW/vdKRBwTgONSOXJiH6vsWCh58Zu9yJHc00ETelaaOmLHgYwnIAHCgOgXZC66QIkfWNcbTjIUeCgkVjV7l7PPIfuAP283vXnv+TmcZeGR/1OoKRNisbusEXPI8l9CaCwrA6UIrGf+64I5a7QtADEWImCntzzkoPAMAVVPy0X5srlNcA+AUXXy8l8wFR69CCdvIsSuOr2PWav+NGCWV4QA4BTctRkQRc19TQ2hShUtjKHxa2lK0GrwuPd1JeGD9PrSfMcbB7DVXnDZZ8rkNRI4E6QfvOJAUayCaz+u3amtFO9LrHHUzy7PV4kOa7+yL0yd0TJXuTG4Tf9a6G0AEFbCOoHnEe25bLNCH3F+qqemir3rufMF/x31bKecBkabGMSU0bUzQFl7NEozfLWh6MP7h2FM7GFtFtt/CFOtuU/9+wu3QwqZQtCwSxz8rNloUTlFg0ZC4VCAATmUbgBTe/lJsXBwAE1wzFnyMmmdHAzC4afn7DdI+Wj1nFT4rzhT9YzoraIUwBl7ieDtWt5JCH2CKJpUlreSFYCGHD5y8oEqe0VExg6FzUXOXx6UDEjsHHa1aJVjPFuVw04aoyUOdIwBHIhIwQXL3uKfkJWTHmX6BGguXuoyAL1zjVP5mTCFMBVpf5IcBhsGXmSwzXeL0mmGgRWmSxt+B+gW/kedE70sPPYn432PbbYzUpy4WqklGn7PGoR0ONc/foyvqoZsapIDoifU7kppkdKjC2Pbf1zoKadVzVkVONTMvdn0bAZlEdIMLxa4As6JsPyO2W9Exy+V9VZOu1pUg5u+zPjRPW2s9J+SNiOiM9tySzh6Ihs+3yCor6eyBaJWZddLB8dA7LzU58LW58LpTPhj/AMC7AD5GZAR8DwxufELt0NQzplbD5vmhvHRlBaV4o6ILxg+15H9rl67ZC7qrii8jC3ikCeUMKBe7onbta9H11nOROnERAEhQZhfVyIV5CDdtwPNPmizhhltThMsJQDSDtRsIl5K6Uy2sqBShor5T011FK93cACDpipuP6/RBqIPn0WvZDU7lWVpmVfbiNwjQHVoaNNa94ajNUcRHlp6KUwu4BTO9PHUsorzf1B1m8rl64XSm6WfXfIHJMmAht8+EQK47z73to48IH7Vxe6mzvCVzJWHg5QLZEEZiQFozei16tjkggjzMDEnVAiD6xfy824u3CKsAiM/95u8DEcuGI2n8HdL8wEG4iW3Y2QuuiOHv6uU/Ax4nWNqO8e+796mRpg9ev/NXXusKV9mGGX0eJQ9+KtCcL7KUPv8RWXXp9nvAdcim8A8QQUeyOlTNS0DUJt/w+RbH6cPRMCn9pFky40OFC5oejPPGn9rBuDkHM+NtT5dJCyZFfQbNOg1hRSUemXsIAPCLnxxB4/4ax8VAi6NzicbBZozy9xsk2yP+yxk5deIi7Pp+L8GySh781NGoXTc/CRf03u10+QGmzZRQhjg6KNlDkY6EK2kIQKrjuvsr+c6ZOHjXNKcyL/xkxNLOuK3dQ7RXHyrLY5wkJJtTLiO+pkOMJrIm51tmBilHQMRa0ALgAGIodvIbVPGyx+DLZAIR7swXnHRH8mLrF/zGeQ7Ea5BwALMuzy2DXGJzLSKsGIgmFd/HUEs96jbvhIGXY/e4p9B97XNCqdOBBbCZtepwFBEhpenLAAQY2Ehzd+W3vAlSYBh133R3nw74e1dUosvYHg7Lg76HPv+cFL3W/bOROOx6weT9jj6u8nQLNZMprV+hHaXFCcdPFjwKo0PXpP6K6ppsDqEggUabMJpDsrMp45QKxswiz+xdLoFPa6UCwNLHazFyYZ6jjavF5Zmh+a2h1JkFIo87NnWwY4/Kb75uRO3KIry8sTtuuDWCP7Y9XYYdh9pFnX8289A27iJuA0gBRIoZNrMk9te47o1IEc1mBb4CmMbbOHxrKMfwERBPMt1uG69NWDsr6OMm3KBfkMTTcxzVNV9xzWl9BpziFIdPyfNhJ1/xLeGcPEd8n8etxf0115Z+ebrbjgUibZ9FtTwgau/lNWajhcb3nZUHh8ftdjJOz6TAKQjyO2qiCqv2xiiVAREEAEQWSCw2Ei/29Y71eQJuIa9weQYu6L1bEpA9T37o6EUfvGuaqMPJfVA61yz2BWmdXbPbd5c411NLAvgeg442NODAQzEdoEofvDl4xofW/EfTg/Ggn53awTgIghQA7wBoDUORWxqG4YwgCL4N4A8AOsI0gowNw/DIsfZF1TbHRscGQmT1xitjCoXZkJDbV1TXOHRAou6CtuMpmbIeWdekSGA/UJ2C7PwB0sU38v6u4iACxCq/Jfc26mws1t1wawoaSnY6jSBaUlCORWUzWgQJiK3kJ42/A3+/6lfo+sSoGFEe3T7qiAFZaUyKzgAQt2JeC8chAlFjDQMjGxc4qu9biPZjcx1xeWmpViMhbwT+ftWvzG96XXy0k3KYDcq6ifCBxiu1QA6HboDhyoG/STcNR0ODKwJ1HoRVKOrjyGZajrGu9uvMLKzaiz23LRaVPmpQ+N/3j9lngehz5/XR9zCmfVxPjoh42xy1C1ehzfQpkYeglQDQXYC+yhvfC9Y0+kwIpCMRiLJpbaH0lwGzpXOQ90F7JTqQkh06oJLR4YtnMenKndXTKXYyODv8csvU0dZNzZIZ/+mZpgfjH918ygfjAMA3wjA8YFkV7wGYDGAKgFfDMPxDEAT/AeDDMAyfPda+tAceMwJHADyrt4NPOtiWlWv0e/oZTLic4gMMGFyUlXNAuecq2KJm8S3yktEOilnW2tlfmqxixhhpO6W/nrbA0VkXHzSeFx9SZrEszlFDAYioVr4AvFaIa90/W/BIX3uBOKuW64xxJKG0pFLe4hIWiFwmNBvAX9pKJ5bKcrS+LturGRipeXvkcdMLRLxd++olDrtehPGBqGNN6y/QbJa/91lxphM8tj1dhjPXTDfHSFaJKuA5mgmAw7wAomfNpw8yCLaZboTlkzu6+Cd9BAHIykQmJnY7+t2KdjjWRMrLUAv7UMdZr6o0nMWWaj1RCfRkg3zRxCLHXosTtDaJ9amDvM6A7Qr09JAJa/BZCbeVYO3sL8W5XYqGutFprKvalpDVAwl5IxxapMaNG9e90TzBePXcpgfjwZNO7WDs7CQI2sIE44kA/heArmEY1gdB0B/AzDAMBx/r78vyjIQmA55++H2TSKluK8EYjb2WFZQaBoLFrfY8+aHgxq+9aR7Ekfebjj5dmSdeDZgHM3XUU6gYfzYA8yCumb5LBO6DjHQ8/ICBJ+7+lenm075fgOEu+/bpmn8aoyegtRQ8cRt9LVic4W/qZbAvQqMLeJqjyusGwDFJ5T6dwBrHcYNLUwnQPGYP+3OOQ8k/+u3QZBOwaASYFQ0FhACj8KULplQ643lQylIXh7RMqjZq1Zq9XEoDELU6TSV0xNfJCFEZYULeCIe7TD3kGKlKdd1joA6l0MbfdxT/vOya0ql0gAFcFhHFtLTcaP3ipc7kBbgTpnbPBkzgdLQrPt/iwGqE2Xx/P7069CcAbfLL72qxeYpP6ZqFVszj9WyWAt4fn2x6MP73W0/9YBwEQSIMFJEN4GkAjwHYEIZhtv38WwD+SBeQow3qGQORkpRP7/J5lJruBUT8Se0QAkTi3gAk2DLzo0D99WMPOxxgygdmLPjY/IbFktfO/hIAjIBK336Y99NCYXn4ffV69gcitxDH9t1jShA35iB+rIODxh/50JKDeeTxXyAhq0fEyaROgx5eIGxc94YxjrSwEAtBDjYYR5zIYVN4jAu9HxlqHxo7B6IGEk2TEnqYDaBBWmc5VgCR2ajfuq1MUDXvmNdaN9UQU+Z3Ssa/HmO7pDP4A+v3ocPSBRIEywpKzQpC6Sgn9+7kwFOUZ9XPoC6EEQYi7ip+eQp+kmfZPvNcGQqLwardMQiymUO7iKflGwofufV8/jRdjmJMQKRiSP8/fn/N9F0AYLLdynKsmfhhlKRYwwGNUbcb4Jr0+hROFvkAowHjQ2uEMThJ1C9eitT/WHXywfh/PdH0YPw/bzv1g7HsJAjSAbwG4FcAXjrRYEyY4kjxPuzcnOo8sFQ/E9lIO/P6hT0GuS5je0gnH+B28/m6tRyU4GRBhA8zA2X7e/6IXd/vJQGV3XqdL013BGAcGcd4nFQVbPY8+aFpJlEaEZRJZEbkN0v4CmoAYvinuikk4Zw8s2xUEo6amQHEWvj4BULR0lXVfy6JdcMFYLJEAM4SXUaHTOf7mnnCzFrjvj6OSqlL4rkNywpiBOpTJo1xM1lbtAOiTC65dyen8Og7UmteLGCX0jZ7JNVN6ySwq1IvtbXmNLYXx8BEjm6zhSNYAPRhASBWbpUekdpc1hHzVxRKs50mmTNrKQAcZgM73bT7tjiwAOLBx+dE5F4V5ZOrEzKM+H4woNOw1Bef598D0Xa754x1U8PnW1A37xl5X5tLKOjQivymB+NLp3x9gjEABEFwL4BDMKJAx4UpdDv0nB+e1XfcWd/CX5e3E6lL7aChq65CElcqYxoKWPp4LYZfd9iBKahfLEW9BVc4OrbVc1bhD9u748dZBodmxx5n/JoVJTjtz1sFtkjomIp185NQkZgoOss0HOWSVx5ktcxy2BQfvBO5lMAEOb9dN6yocrIEWjORBsVWZ8H9LIvELw4BcFTBfJlInVESGtH0JKeqvr0YSVfc7LApRH82nlobh6/+piYZBiiHsmizQwbfIK2zof3ZIJdweo6jd+xPdgK3eC3XvAZAxOdl4OK11TKeGnKQ31DZOs9FSzwSwwUihgaTC7+Qy7/RcIw/MfI3dTOPZpH4SnH8b1/asqygVGobFMvSZqKkswGGTeHAFB8VOu8ag7AWoecEweCquf6AYUv5DVw5A8olCdq7ojLGgZsJiIZCmiUzfv3RpgfjK+46tYNxEASdANSFYVgZBEEbAH8C8GsAPwWwTBXwPgrDMLYVSg2yKfbMXBuzJNN4JxCZJGorppIp62X2zeyfiMLlGdL6zGzT78rrOzVdin7knuomD8CFJTRsUTH+bCRmd8em2ZVIb2NYHt371DicX+0VB0STht8MoGELuh7E8IbV8pTOEADERsdxhFAZPRAtHfVkxusCWBF2pS3cuL8GB4trpXury9geDobP7yaNvwN/GTAbgKnMJ42/AwfvmibX04E6bAB1DDVVNxc1mTWsQRF3nem2uu4ebMi5y/lNLa2ou7kAuJxrRFCHbl32leKkCwxwHEiAqGlB471sbdaB3peJ9FkhAJwilxQrOdhdpyAXf9tppLE6xLrwm9Qp4ipT7J5WYUDkeK69+nTrd8qDz2DnxTdJ8G77qGnycArSasXF66NXdrUri3BkPxzcXlPyEnL7Ys/MtfIbLFYzwzbXs9Ixu21csxrfmPXKyQdjG3OaMpoDo27KOJlgfA5MO3QigAQAS8IwvD8IgiwYalsHAB8AGBOG4eFj7avmZ0PkIPygQXsdnc1sHf68/C3hAe1uHA+H0iwDsiOYGetiB2CCMJtNgCjbJlSSseBjbP3uWeh667nStXdZv52iRwFEQVCWV54LszYz5Wg/eQhKpqwXWOVo3Vy6nZSYOmAe7pIp6522WN+5gV1UfHGJO+sCZNY1KU5lXovgNxZtiuGHCj7sd9R5PFnflklj4UFaZ+we95RwcNklyCyV58VMmX52nJjYlcYhbhsqcPrHnpA3AgfvmibXNXHY9THZtmYpiDuJyvyLJhYZI00ljJ7QMRXJt//abL/+TNzGBh/i0deuoWSn6GBwn1x5AYhxb2EDiNbY0GYJ0mmouMf1+2qF6gdEzBjdGq5rIOxw5OTHQK4ncrIr/AK8niT0PZEmJr26sUwSuT42I9fCS80CU7z6UNOD8VX3nNrBuDmHNiSlCSdxJzIhdLBFh0xZCnE2JUbctneKYzG+emt3XNbPiPjoLJYaFwBEIEgrxT294zTc/eJFAAxWuKUsU2CLsoJS9PrbJ/jgtD7iHsJj1IL0WnvCh1cYqPng0sVCZ4hOBxnsS6coZgAkIAOR7kRMsU0toxlwfPNKDrEN0kI2HlzAF0SL1ejgkHB6DhoLlzraCswAARiOsSeEE49CBsBpOtD4LYAYp2hd+CUdUjfAMJiKLseMMQjSOov6GVud9WSiBdj1JAhAmmm0CzhxaJ2R6265GNdqW4TkNhXbiNny+gARzs+inw6UOzenxiQU9IlkEbvyUGtpI6e9mbZwkskIiFZT3rMh98VSzmi5Za6X29lIY1/i5X4TCqmf2mvQaY2HmpQVTNYswXjpg00PxiN+eWqLy7eMltEyWsbXdjSeeuLyp0RmrGEKmTVtZlF930LsLY1mfTYy6M4qAA4TIrkjnFZRdh1tTjZY8I+zdjpuIF1vPRdrpu9COkxmnLtoCB4e9zY6NpoJ8fqxh7Hspdb4doPJznNn9UTJg5/ivF2bxfBUFyn4nXg2S5o7ShI8EPFLHfzQ4pNa7SpGOEV1xhFf822Sks4e6HRwaR0JLg1ZQCJLQb6bke6S8K3OhM/pZTYs99FrwXZEgCz+qdujq6bkS9MLAMehmsfcsKxA2Cu9lt0QmZjq31RMDt/JWdq0FWdVWysd7drqrkl9bRvXvREjbON3y/n6xNLYZH9TVgdKx9dv6ae4kY/XanNbCmgBhsXA9wCI3gX9DH/vygNSOwHgyIQCkGvda9kN5jiPdq09jrRumT6yP1qp8vppuh3pdxpe0o1fvB7aEBeV5c3DM140o+mZ8ej7vh4wheUaFwHYFYbhpSfTDg0g6kNXOBKgCl23nhsR5wEHJwPgQByAeTD3rqjElrJM0ZF4eWN3jB8amYnuXVGJ9Ow6gToOVrQS4R8gksckG+ODI2kY3GsnDla0Qq+/mZdw1/d7YW9pqhQSfbdotqjqCUAf586yNOTO6onalUVOUcUJxraKzqW3/6KLS7PFOBPOyUNj4dKYIqBuPqGgETE6VtE1r5PC7YCBGEgN1NV76RoDomYTO3gcWiDGb3kld9aBYVTxlhKkWjeCMptARAkTUXzLXebnYdXemJbupCtuNoHTkxDlkOdQN6wAMXS5lEljkHT2QHOc7y6JEbohk4b3CMDRmSeewSo/8wOSPq49ty12nl8AMWLyvF/kGfP51LUEp/BLT0YVFOU+Ai40oyei159xNLoPFtdGzSiEPewkEjNJAzEynIQueB8bPypsnmD8u181PRj/5IGvTTCeAiAXQHsbjJfgBNuhaUiqcTSN2+kGAmpG+HbrugVYY8jaGFQXEjTGxmqtfvE1XY74JrNwIKITEZum0BCLbS9vNN59fDC3rDf6yMT9Ht90Gu55dZTsk+amVNfi0FmCaAh7OLR2s6DMJhBhi1QCA2I78LR+AT/X6mSJw653BHoSh10vRa+YwqIq2PkvMgDnuCWAAy7H2L6Y7A4jnt+9Tw1ShuaKBCQlSbUkpJ85a6ph+8lDnBUGELUey7NG2prXOKJ5xY3r3oh1+lAFUGbPmqoGwF0VIAronEx9NTh/aFNOn31Rv3gp/rq8Hc5feS0AuBg44OKyPA9Ls9RFQbZ2AxADU/89kw48K7gkOseI+M48/o1DX0bfqemyXTfvGacwycRB66RwMuU5tO2d4hQvw4qq5mFTLJze9GA8ZtZRf8/2UrwMYy8XApgXhuGcIAg6AFgMoCeAHTBSwhXH+p2T7cDrDsOomAWjSXEZjBvhCbVD62DMbMTvgRer8V9+x3ECSc+uQ8qkMeLC0WdC4HTr/XV5O/SZEAiHEQA2zw9jKuDxuMv6IdJLS72U1u3P7e/5o3TrhRVVWDc/CZesNFrJjeveMJbtSpjlkbmHpJ2aPE/fWNKhlVkqkLard6ycbDspl9rxXECcwh0itS4OCunwBTk0K9+hbh1+v0RoU3qC1IE0JuPx9I35Oe8pAydZBECkXsZMmZ1evCe7xz2FrreeKxP4xqEvI3dWT9neOvx506WnFPC4XNZccO2SEbeLUgkgaXcU/j1ZHb5OB3+Lk6MuduqALrS+OPdHmmjYJKOLgMqlmsfL1WO3F29xhPVb3Xgztg5/PtI1RjSRaKEqFmYBOMkIEGXKvm4zqXz6ODhJt5k+BVuHPy9JD1vFdXGWcqz62jjPgbVqkmLmB+80TwHv5bubHoyvffhYwbgbgG5hGG4OgiAVBg24EsB1MMYbNNnICMPwmMbMJxuMlwJ4GEAqgKn2AL5yOzRlKH0e55H9cJpA/GBxZD+kys7ZXFulH9lvoAc6Of9gwG5sWZ8plWVW2DXda9vTZU5vvxaxAQwFrPJQa3TvYh7m9Ow6tO6fLcpvfgv1JStHx83c+ALx7wE4x872cHNc6XINANu0UPqJTA58YPki6oxCvyC+qHj96kLn4d/z5IcOxUw3W+jMVbMMfK0Jf1s3fVDAXmeHzJTFA2+y25nVZvoUvDV0UUzrLY8bsBOHgnA0VY6UK92UkDJpjOO75uPnhDp8pTJ9HswudXB1mn3UNeO9o+6v3EPVeMJ7qgchCtEX0V2eiLo5dRtyckc4Gt9kVFASIMhIc5TdqOHN8+DzflTslu+pctfmeenJzTkP+5zohiNfuZB6I74+tW6qSelz+ckH499Oa3ow/ukjTf69IAheBzDX/u+E7OdOhmd8KYChYRjeHARBHk4wGMczJNX43tE0HqQ7TOnv+lJ++gbzhutGkeo5qwzPWC3RfQK7I7pjA4lWuCL1hxn8H7Z3x/VjD8tys/09f0TNs6Nl+fr8k7W4cUZX2X/R9B2GWmePveTBT9G5R43jm1f+foNpmfb5ova4iPf6zgp+VuR7pCWNGuFAMjrzZUari0e6HZXLWS2z6Td5sE3Wl/7kPYlXpPF9+tgC/PDtptHm9r670Lp/tBKhhoRumqFSGxBNdtzOXnBFTAcer5eenLQTCO+9FsGPKZj63XHUTbb7oPyjVp1r/HyL08yiu+WA2ICc9MOrUf/xulhHFNUI8evfJQsVk1xlLfbkc7/ZVKPb5F+ZtMXpKPXvu85qATOJJt85UwK036Lu22tVz1klDiFA9PwysWJDDrtTAWDghPoYrYpm6cB78a6mB+Nxjzbp94Ig6AkjK5wD4HMaM1uFywpt1Bz3708iGD8MYCyAegApANrD6FMMxleEKVi115mGyO4p4SBfHtAvPoieAuA8bBpe0HAAWzu1oLnvqqGrxr57AxBf2S114iIc2GDg8vCDdzDvvj2xAZmKVZY7zXZZwLww2kiVLiZy3NZahxVv30Kpakq+KN4xABE7Z3AWjQMt0KPwRS6PdVFGMwMAiLeaH+Alk7MFQtFdGDVCAgYAcTjR91nfTwB4ZO4hTJvURjJ8Okg4mLwtgHL7/JXXYve4pwBEprK6mMZONV5vwX1VMNGBkdm+Nm2VphDd1AE42LAWgGr8qNAx3PR54AxGAtmpoXnZWtGOvO2iiebcz195LcLST1zNCPsbfgavz1lPZsySHW1tVVdhMY4NKUC0cnCU9LxzI3zE8/AZLIQpKIJ08K5pOLIfDue6WQp4L0xpcuBre8PjN8EmjnbMC8Nwnv5OEATtAPwngFlhGL4aBEGlDr5BEFSEYZhxrN9pLqGgPABTbQHvFZxoO7QKxqz+66o5nYEBxJgYsvDEB6Ju3jNIOj9HmAr0MNMUGwYBUt7Y/KGVt7S0IjWVtVgOC4vaZYFLaQCCb7brNxEAcGDDswhLP3FeGCDCH2mv7jtKJw4fGxVkZoxxlLMuWTkaYeknou5FDJUBqOut5zq6D7xO8cRwNCan2RcJ5+TJy87rH0PLs4U0nhMDQbxiD+8R8VnA4L3nr7zWWYq3uvFmp/CYmN1dAjJgstvN80P5zcZ1b8RIlG57ukz87GrnLjRwljJ0Fe0HNfHrF5/FNa1NofFM2kQ5jiKe+Sb3ryEG3WhCDRNdQCXjwKGMARLEnYIjINZQWi9aQ2q6o09gIIo/qUlYFxE3za5E36npjjVVDGRmmT6Oe7a/ctAB3XYv6vqPDvA8xsY1qyNhMLuK0xl6c8AUB+fd3vRgfOPjx/w9q+e+AsDqMAzz7b99in8WTOEdTB6iYHzC7dAMxtoO3u+SYoBJz65zWiiZQejCQ4wUY1YPJxg0LCtwGBnEzrSteAzepcRZUsYMcQpCQPTwMsA8d+US3Dijq7wg7fpNRM3iWyS7eWvoIgmmAJyefS3hCETBoWpKvlwPwASDb776gNCN1kzfhUtWjpYXpmZFCdLyXYyYLswaBiJFDohcgBng2RUo18WKq+vMl3jv0V4yXSgFIsaGDvh/v+pXTkGuakq+FMiASOuaXogMyj4mr92hNTzj28THuz6EGHi+xDAJRTFwOjQ1iyH715NBSTQkFNShWQNC41Ktzf6EmXBOnsOP9usmAJxCGSEife7hpg2OFgWhIi0zUDfvGRFqajN9irAhgAiekklb4eeaHeGr/gGxNRC9stD60Xw2Abd/QAv6J/fu1CxsioP/Mbnpwfhnc45VwAtgSAxfhGF4m/r3xwDsVwW8DmEY3nWs3zklmj40myLx9Bw0qvZHZrq+NgIfZoE0lCNEUqcUx4iSGqu+LKdejvvbju6qfbh1tk68WIugFE0sioqCWT0MLDEnwkFTRz0lhT3qIRO2YNaljzOpkzFSpe0Ps2ctkrRn5trIU80uEZkd6pZxnhuPWU9EWtNXhF5scKi+b6GTTWofNV0w0t+hbbxDJdMC9zY4cJA2ldQpxfFx47UGIHxVToA6SwbgaDIDBs7qOvNih6MdnHehk8UCcK+nxYc1hin0O0DkLnnsZQWlyOyf6GSEjoYy/4b7RtR2LJANTWuVT2DDsgJHzlI3OQERTOFTxMRGbGEeADh604RLdLOJnryIHzsMGat1AkRym1IHsFmuNgtFZTlKpqxH9z5mEohxUvGvj31eZQVlIQ2Nd1cXFBnev231byza1DzB+Nlbmh6MJz51rGD8AwDvAvgYANv67gHwvwEsAXA6gFIYatsXx/qdUyIY05AUUBxKTYPyeJx80QDE3LywotJ9MS3dC4joXAxYmkaksxu+oP7yn7Mzl7taFyI9uw4pQ3Mjpwr7+741OtkWBzY869ixsyBFTBSILKS0BZWfvbMjkefqNxjUzl2IypJWDs5cNH0Hcp+17JSiTSZ42uNlN5fGy2kJBbiaGjoL0hQniphraycATtekMGfsb/qFNJ8/zpWJ3n74gd2459VR8hslD34aiSR9Ue7g6UKV0z6ENitznLA9Hz6H06tgKgAOnKSFlbq9eItDqYuZfJRgDwuZGrtNOD3HsZziPnSzibZlEg0OG/ClFqGybRbaHBaH0rGmgJKGSzSVjTxmXRz26yYsFm+eb15nZtW6UKs7HlmH8YuuGlZL6JiK7b+vdXQ3msN26eDTk5oejH8+99Rv+giCYAeAGgANAOrDMMz9KmRnHYyBiLYEwGn7BCJal4i6e7zjzP6JqN9XK9SY8vcbRNRaDy3CI27Iahmoq8J0kuYLw4dFH9vDD+zGtEltHBxU817fGroIgxZdLC9Uu34TJSADkLZQCttzaGqVXt4C0VJe6x3HWyZqPV0u+zYOfRkAcMH6qQir9grWTQcHPRE1bi91OhxZiT9WJ5XjW+hRyPzrT681HXB4brrRhp5zPI7gvAvx0FXGg/CeV0chLP0EayaayfGSlaNjMFJKqbI41PDaC44tEOEFn0nC4xSWgrfq0s0/LI5q+lntyiLx7iNnWDc3aIaMr1AGIMa2SBonVCOJ40QOV5wIiFZ6fJZIL+Qg28V3IdHsCxZFAQORtc2oi4GStND+5vmhgzuzIcQP6HpFxYAsx2Unfc2iaZbMeM7Pmh6MJ//H1yYY54ZhWK7+7VGcINmZMIUEQa3oRc6mykoOv1/iaORq/dOSBz8VbWEA0kCi+999U8j6xUudrjtZutsHsX7jFhQuz3DE5qkHy/bmbi/egoeuWixL56BvPxSNXiUPLxDhyIDJEokj87wAOFkBM1AJhBYK0NVn3VBAN2NmpFp0ni+0DrIAhFPMIMhiGsdDVy3G9LW3SPcXG1c0rOMHYz9Y83y1/i6vOxBlYdueLosyWwtrMGgRXmAwIb2Ok91DVy3G3Y+fHYvJqxZi4rUxNL3JETdZDx8OYIOCxofZOegX1ZwCnl7dWMxfS1VqbjPvG5swAMTAJ6IMp9T92NgBGCaEb1Tgc3wBU5ST9nxLDfSP3++qFKqghaE0zkvVPK1Nsbc0VVZd1QVFzj3bPe4pgXl4TzmZ6XoM3zfAQEPf/vCtkw/GT9zU9GB823Nf22B8wlVEZsZS/FDC4wCchyThnDwjqq4sxSmyzqGDL5edfqFA41nMPjWP2H+Z0CFTAlnbjDoxs9RNGylDI10M7VoMRLCGA2N0yETqKFOY1E0iWvqQrcMAnNZeDt99oX51oeOWUTL+dcc5hewKB/9WUp9C/lcvpZ78dFMGrweLqr4TNjMk3enFz7W2BT3O6EHHe+CYDXji5zEQDYBX7t2D4dcdlr93uMv2/sVbJfndnj5rRrdzy0QDSNVf1zRkGa6eX2fFYLWNBUryOu94X7SZrd8JyBZsbQigWR+Cs9pagu4wlcK4laJ17hnxa3vMvqaJPq81o9cKY0gXePXKjM8WVysXT/2G8x4mDLzclT6wtR82egEu+wUw0Fubi64/+WCcf0PTg/GU578Wwfi/AFTA9GQ/F4bhPM2vayrZ2demSDw9x4hywwSPVtfdg9pfmtmTnFVHEUw1GPgPKgWtfSfc+n214rNV+8ubHdGZygnTnBlcd4gBJiCxqECqGgDkDIi4pjs3pzpFLL5cmu+r6Uft7/kjDmx4Fo3r3hCGwMAJ9Ugaf4cUe0h1E+raE6McSOGbrz6Axs+3CKvhzDXTEVbtdSrticOux2eDZjktqoLh2lEy/vXI4v7zLVgzei1+tH6yud5Ve1E1JR+fFWei35ZHzTV+/Bdi1gkAdS89hLKCUnRf+5y53lY8hqsVCtb7ynvUQ+Bo++gj+GzQLAAQTrE/iXKQQqXZFHXznhEdbLImtIty8p0z0fhRobP8163JgKvkJsJAnlCTfnaYKMTrLgQQ02HK50fTK5M6pThFQWa+DgtBaWpQDVA/88m9I/OC9jNMU4/Pvxexd0DcQqSrUuHYQNT0oR14qu9b6PgjahF7HjcQsWn23LY4Kjbb7W4v3uIWIlUBkeeim5IaSnY2S9OHD40eazQHRt2UkXSSf/+DMAx3BUHQGcBbQRA4rXBhGIZBEPz3VwhbRstoGS1Dj/D/YT3jIAhmAjgA4AY0AabQ7dD55/Xqe923v2laRW3Gq6k8VVPykT4/KoDoLJe8UG1zQ2U3AGj3nLFW18sjzvpc9nPff7/qVwDgMDWAqMItVCPL8dTOEuwM5KC1E5dbPhbmsxHYIKKLepo9AESUOmYsxG+1zKjmBS97qTWufvNqR78i9dJsR9mNjsuybZsHnEYTmGUpYAp8LPawap77bK7jZUbIQhcNNVMkZdIYcVrmuW8c+jL6TAhixHiYxbKaz1XBgeoUnPHzLs5Ko/2MqL3X3/7175JNkc9rSgAQU92X4xya67TWU4eCmtU8Xq0B7et0AIjhGTtSnpaPTXlWFrB03YQMA0Jz0masmlWYTQNHwdeVwzUAyUgpsHXB+qk48thMh2fs60w4Cnf2tx1qG8yqkVxkaY9W7iuOpyChJFUQJd9e4+F6ZdFcHngHfz2u6ZnxL148tWGKIAi+ASAhDMMa+99vAbgfwMU4QbIzhYJ0IUqLjwRpnSUQ8oXwGyL8rjMObTVPzd76Bb9BkJHmOOFqB2Quv2ifTglJvrQlU9Yj65oUx4QznuKaVu/SnUyACdLtBnTCuvlmcaI79oSLfEa2I2BE/Qd9nbQBJDpkGq840vo6ZGLe5C0YP7RcsFN65mlsUjeBbJpdaWhvFkMWGqHdfuXePTgvuQq9lt0gQZ+WUSxKHSyudars1BPR2tNp+VOk4JR1TYowPEiHShx2Pf5+1a/ketKbj8FaBKKUTKSGfsjZ1rS/q3+6HItv7eoEX4dfHk8Mx/47f8PXXuBv+qatmpHh83vZLQggeu486VDf6JNNG/wbX5GPXHp+v2T861IMDXqcFVPwpIiSbiDSE7kYgx7Fg5DQFymIgHW+HpwXcZOtHogu+iE90+l01e8QE4FDs/KFDdXqxpuxcejLAgG2mT6lWTrwvpx1bZMD3zemv3zKB+MsGC0KwMAdvw/DcFYQBB1xgmRnpwPP8icZCBs/KoyKekDk4KBmZs0FrV+81KXDkduoXBp83qvWY+VIyO3rmEbqAC+8ZsVh9otSAGK0hjWHmB1/fIHWzU8SE1RykXd9vxfaTx4iuGKfCYE48AJRS6s8/PblE/L/3Bzgi3IJoICptDuKdLbSz0mNEx2DXLitxPiYKdL93hWVOFCdIr9Xu3CVYORAJOqkAyV1IIBISY+fM6smtg9ExTSeK9vEtW5HZUkrZxWjO8zMuaVFko+jRgCV5fjRpLfwRj8jsN5m+hSnCYQMBJ3Vamob25i1TgKDYIwEps1idfGZx5k47HpJLqitrfnRbC3XGLGYkCJW5IdUOn2tnBZsK8bjZPA2iGojA0eqkloWmoOtvftsC7emI/JaaiqbPo76fbXiMs373vWJUQ5F0vxdusOn18JWidndmwXD/fLBMU0Pxr9ceGoH4+Yc8dqhOXzTw+2/rxW9AUAtk1QRQbMN4glrs7Ku5RX9F11rFACqbdUO3xaeyykG3MqSVkjPrnPsoHwLGi3ATmglZUxkPXTan7di63fPQmb/RADAa29mYuTcHLfTbcEVzlL87hcvkgf3sVUdcfeLF6FxzWose6k1AGBwr51oN6CT8LK5kvDVzbTegF6ucnvZS60lwGddk4LN80Oxtbp+7GHhgQNmAqBpJmDMWg8W10r3IlcVbTPqJLPVuskc5K1ylBWUOtCID5X4sqhcZg9+/L8AAEt7NbjNPYp9wHPVS3lfP4Psg6LRq6IGB1tI5LMiRqkqM/YDvM+ljts0o6iY2kEagGSSfLZEk0MlJNQY4SBDQzeb6OPmsUsSZNURj2akyqHfEwp/6UlEr0A5UTlmtzbx8W2p9GiWzPj+nzQ9GN/7u3/BYGxpP779C+DaKwkFCUDS2QMFEwYgS09dAQ/SOrseXspnTO87JrtRVXVmFuaY0lybIUA4nLoLrXB5hojLU0GNlDdfwCf5zploeO0FJyvdM3Mtev3tE1SMPxuAaWDRLtU1K0rwWXHkcr3ntsV4saqz42r9YlVn3P2rbo6U5/VjD7uKa7axA4BMCMTLeTx6+y/F3TDo2XMlY38lJRG/fvw8kbvs2Bjgxjk58vmZvcvRfmzk0tFnQuDKX6oJgQ7d2juQv8t2cMDoU6dn1+G99UacP6dLuWM9ROqhAwfYoMb7++OCQ/j90Hr5La1XAkAaPHQioJsSdNYtuhx2Ke93ujkSlsp6iK4gDJT8vPq+hY7rhi9rqusVGuMHIkEpH6f2/fv0ilIyeKX5wu/xuPz30g/EevWq9+F7CTp4uuVy6//2r5fvttIswXjm6KYH45mL/nWCsYjL2yDgczt9Cx/NrQWAVtfdIyaQemkFwJnJtTOCU9Cz/Em+dKQGyZLOsw+i3Kbf4qo74Mj51dQq/cJwW2Oc5M6yMPa9Kw8AADIWmCBXs/gW1K8uFLW581dei0Oz8iXjPOPnXdBQslM+7zs1Xba5r4PFtfjD9u648bd5ACLesMbefQ3l5I4QOlf1nFXYW5rqNNYIPcu2WD98+8e4ve8uh8rW+dJ0mQD+urwdcgaUO6sG4q46Y9ct6sTjdVfklrJM0zEIQ8ejNRNgsO0Rt6c4utY+Hpk0agR+NGYR/jT3EnNTLJ6ptRK0IJRvPUTsN575gRaq0nq8DCy6a1K4yvbzeAJPunPNNx3g56ybyHVSyYJk5PZ3JGNXcB9/l0MHcGLOsnq1PGRts8QOUR3AtQ444HL4+cxr2p9YOcUx2uVoDqePL+/9cdOD8f1/OPWDcRAE6QBegBFTDgGMB/ApvmI7NCvGOsgBbnu0tDdrWUEltF1930LHBkeWeN6STFd9D83Kd0w4sb04LmMjHqGdL53vT8fGE+1y7XMwkwbnOaL5frPEspda44eZZYKLpo56CjWr75OX7JVJW4wojN0umbLeEVHncjXctEEYADkDypEyNFdkOAfNOg0AomYVW6zjNgtzNLJkkYccViDCcwuXG7nWi6d+Q4KUPjdOTLSrEkEZCynolYPPTonRprDPhGYh7B73FHaWmXvEiUqaB1SwZMDn+f5o0lsAgD8tHO22glset9+a7/sHasaF76DB34yByuzzSnaBKKwNzovB4KVwqLSe9W/4eiKy6lPJg68tzIRHax472iA2kGrXas18EJ6y12npOHIDjvkDDRVEY8NzgAFibaucfdnRHHrGX/7q6qYH4weWfC2C8W8BvBuG4QtBECQDaAujWPSV2qG1jqvPPuBIGZrrOCgDkcg5EAmVS2FCQQ/cFx90sd9Ry3IgWhpJVjVoMJLOHogjj//Cfp4mjSaiemUxSw1DlBWUyjaXnqRqEXtlUKPGhO7wQmU51kz8UMTlk0aNQOrgGbHKb7/Nk+8XTSxydIWLJhY5Ghk+hUxatG1wYBVeV839bXqpkSa1sywNuYuGSJW8sqSVIzbvi9GzeYX6GJQeZVaurw8nQE7U/I0j++GwGCi6fzQnC3Gc8BynNS7944JDWHxrV2ef+jz0cXFI95uCtKilDJhJwnHwVqwSIGIH+YVf3yVc21wBcFZ2vD58ltiqryUB6HWogyuZHUDUlKThAMdfEa72iW/HBKhi51Ha4IPzLozRV9HZN1evmk1FZoq2vmqODrwDdw9vcuBr9/CyUzsYB0GQBuCvALJCtZOTaYfmUqx+X63jzZV1TYrT6qkxTFKYtAlnwqDBriMBGRWeG7GIDdlOOd89RGPJ2lmB1WCf5eFbM4XbShy9XS57AWUpb/+erbrUSwAi3JNZbe6zuQi3lTjKb3XznolE8i3nWL5vtzWLgyaRLIIGaZ3x3JVLcNPyq83xeHQ54pF6m12CxMMPzcrHjE1d8OirP5F74JuxagYHs2Iu97WLsBbb18LkFPvXsM6O1a1knzUrShwHE7+FXBfydLAVfWx7D64tb8Rbb06W4+JKAjDZOsVxeN7xkgP97FAA39eE1mI5epS/34DOl6Y78pU9B9c5NlX8Pa0N4juQBGdkx6gO6qW/bCvYwc/wNR+dPGa/+9PpUFR8aiAqvukJwE96/GCtMWQgkjHV2h3NgRkf+MVVTQ/Gv371lA/G3wMwD8AnAM6FcUWdDGDXibZDEzOuLGkVq+kww8Vm2c6qsS/feNL3//J1aBn0fZK8b/Uk56qCNBAJ7+iHxp/xic85vE6lr0t8Tleri0avkmIcANGV4Mu/5LIlGLkwL0b5jUM7ZgAQoSKdeVEQyRd8ef5JMzHdtPzqGB63n8HzpZeltYVWtJIeTTL1b/oFLxbrNJeUAZruz37tQDcM+JOdz0rYPe4p0bYg/Uu7SBwsrhULLiASyyHb4q03J8dwghvXvSEC93c/frZh74zNFQiMRUitx6s56tVzVon9PM9T4+mUpdTuNmsmfohBs05zkgOHV+yZJzBD9RXwRHqTQ60SaCrgmDQoWhqV6TTbhU0x+vpp+I9ZN7Na/z3TWuNAJPmq5UCZjWsed3M0fRy4c1jTg/Fjr53ywTgXwAYAA8Iw/N9BEMwBUA3glhP1ftJsChZM+PCy+CPLQGu7pCliervVdfeg7qWHZN+yvFEODYBbSCD+qJ1ofUlIPYPvefJDmTS0/qvWXwAiojwQuVkwOGj3AgDyAAr2DEiAJuE9ZdIYzPtpIcYPNdutbrzZUX4LepxlYIffmvMgzDFo1mmSAYms5ZjoRaeAC2Bx6Lk5MTAFhzZz9f3neH33rqhE11vPlWvDri4WzgATkNnVR9PJrcOfdwK0dp5gZqYbTQQCQqThq4+h24u3uJk2C8P2RResVWW+unh59eT3sGTOD+Q3fF7smum78IMBux2Fv5j6hGUoOGatWr/Ywl3EsXVDji+KxEGHa2bjvhaFL+NJXFoXEkkz08wQCjbJUAwOADHBWeiZKonRgVRfD/63b/EFeKwL1WADqAlfSZI2RwHvwNQrmh6MZ79+ygfjrjBO0D3t9g8BTAOQjRNsh35q7CV9J/yPc2SWbZtRJ9hq0uA8V73LFvh0luXwI7N6O9xN6vf6wdgX6mko2SlFKqqyscW69pc3I6FjqoNfMhho5SztFs0iou4M1JQmAPHZAtZkFDD8XXZTAVEHk8N7Lf1ElN9qnh0NZPXGL8aZgtSvf/WtuFi1z3P1TSLnTd4iDiVieW+LiGyd1jzsQ7Py8d76bgJLMJPWbbHaSNXvnmQ3F9uiAYMj+91dOliQ+qUV1LTwDVkJvMdUeNONNoSzGHzjsSl+NOkt/On+8+TZ0rKoYdVeYXFovz9H7tJbdvurF2aHPAY62ehCLm2ZyHzhteOz1fnSdMeBhVmsVi7U7fC8BwcrWgmX2XfUQXqmuIMAClLQ3Yke7kxGUdL4O+T6UBaTx6EZRlxRaJNUilaJ2arnSN1smPGUy5sejPPfOLWDMQAEQfAugOvDMPzUalN8w350Qu3QWkLT11ylz5ivSMVB915iscyqHdoaIA8XEFVx/ao4GQTMTnQBjwwLAE53mt+jH6PWZTOmNdN3ORlq45rVjlyj+MDZoAcYiti4tL1OS3B2/gDH0eH8lddKhpE6cRFqVt8ncMzgx//LMAQUA4Cdb8IQsJ2EEvAtlvzKGPM52RqaYcDJ8LU3zYs74vYUlBWU4t5KE+Seu6UDDr9fgjc3dJfPw4oqaTwZOTdHMmwgwrE1JMMsmUGKdEYG8ra9jUUT9Xi7jO3hMAwIaXBFJUwAW+QEDP9ZG8D6bAlqpfzo3g8AGNiCRVbATgR2f9L0obi6AKRLU6udlYx/3XEgcVqf7YpNdz1qjRQAMrnquoNe7jMr5nPArFjDTay7aN0N38lZc5kBywpRjKOEvBGRCwogOs2aCgio1djQXNd0wGbRetIRGpuaFLhvXq/mCMY1t17a5MCX+uSKr0Uw/h4MtS0ZwHYA4wAk4Cu2Q7MLLcaRQBk2orLceYgYKAUuGJwXY+3CbFkXEjTlRrrflGC9Xm6Jxq99MMXeRz1IfNj1LM5+fzlPVZ3mKoC4KjE+BxZIz8TD497GnUP2y3d0t1fCwMtdWAJA6uAZgiOHVXuFR6uxal3o4jJdO6ho6c9H5h7C3S9eJC/2ptmV6N6lCl2fGCUv1ZsbumPkwjzZ3rLeNKIwg2fTB4MYVyuaF8usmHxoWfEoNgyZB4CLWQLA0sdrMfL+rjJhMljp5guRgLQvOHFrbZiqXat1LQIArv7pcryyPHJsZ2cirYGAqINRN2Q4xqg24+UqS8NoemghK9pt+aL4Wu5SaxW3G9Apht3Bjr2jmdX6HOPGdW8YPrQyzNVOK/RRdMSDlM8g4PosctvX0tbHtO3pMtE80bCkZpIEGenNAlPUTBra9GA8d+WpH4ybaxx67RE5CMnY1NLR6e9nEPVmTq1loQMtO5waP9/iZMZOwLaGkH52nfRDwzDQDSVAlP3odlE+rLpKrqvP5EZr3WVdrd65OVVYI6/cuwcAMOyycgnAQEQB41KexT7CEo9MShWxIcAI1gcZ6VgzfRcu6L0bgCmIaose6i1onLpk/OuO3vGSy5ZgxO0p9rjTY9rFfZiCOsLa8p7FMiC+67UP67TNqEP7yUOEUUCFNi1wpL39ADgdfFyqM/sm+4BCSYAqGA2NmCK+c8qa0WuFix2cdyFGXjlPAjL1Ger31boT+dBcBwdlWzCvhaZ/1W/cYroguSJi3UAVrtmVp5uSqKsBuHxn8/9VjlgRg7UjDWA5xj7Mo8/dtzvT2hSk6+kJMl4TR7xJgttte6fECNpTs/po2hRJ5+c0TzC++d+bHoyf+ePXQs+4ZbSMltEyvn6j8b8/CfXHKZEZa8zYpzBJBViZMmrxGMcrDBBYQuuuUpuC2YmjUwHEVHABONAI3XodnzOLQUuh4bUXYrQpDhbXCj+3uqDIKTixwq3toxZfONcordnRFMxYy13+6N4P8KeFo+U429/zR9Ox9xUwYzZ0MGPzleDqN25x+M17nvwQL1aZa3H3r7qJgSU/d/jPz+bGYMZ+Nl01Jd/4p1nIRuOyvBbd+9RIhx0QGWLyelO6E7DQ0oIrTggzZnfZww+YVQX1kKmxkTurJ9Ah87iYcTw6maZe0nmG14LUQp8ipusTWihIK6gBkXKhLoJpFTkeJ4uzgHWJ+ahQsla96gFitZ0TsnogIW+EY4HmF4Plt1X3od+N6DQ5Ieqg9XVidB9Bc1Dbqm8a3OTA1/651ac2TBEEwXdg2p45sgDcC+BlnGA7tKa2cSmlhUocT7HKchf0t0Uwv2XVXyYmpHUWuAGAQBPy397f+Ial5GECZkLwHXqJDWoscPe4pxwBdU1lI35GrJEPsDYtRVbv42LGdJ3m+NGYRU71X3fsAcfHjH2hIF/A/pG5hzAyqEavZTfI+by8sTtuWn61bBOyIJxyZu9ytJ88RDisPmbc+dJ0ofpp3QgtQO+L8WscEogU3HyhID2pC3dZdRseCzP27ajm/bQQN9ya4nxOlofmWGstBT4XGgOlHgUAJ6ACkOdO6xenTBojx8b7TsF5nps2ENBWSECkS6F58H4zBQ1cOYSbbJ95dnZq3Wu/UYd6ybzvZJ3obc1hbz95iGgtAxHOrzsxk87PcWC2tPzm0TOuvuFHTQ/Gz//p1A7Gzk6CIBHALgD/BuDn+Krt0ErcW4vL+9u+s4IW+REDUk/cR7Mp4vmSJeSNkGyZjsnOOSpHX8Bg2kk/vFpapKkmp+lvOhjwvzWflG2uACQLrF9dKCyF4dcdRkJWD8nE+k5Nd9x3yVkVloc1maQBpNZHrrrz+3IcSx+vFQwYQEzlfu3sL0UZLshIx7z79uCGW1PkvNbNT8IPBux2OteI8XJb6x1zouQof78Bmf0TJbhQh5iYrlwf1f4s52txfhqv6nbdefftkYmMnYc6uGN7sYMZcwJgQKeAz9HU0RLyRojRAK/Nnic/NF18Nmi/MqbQMFDsYBbMid732PM1OYQFopg2xHa1frHvkact7wG3C5BNSpSjlaF4xFr/BYDsP4bpoAwWdFGbx6GbVbjKlZUHqXM2yaFjCQefZd1EQ/6zfq+aIzOuGjeoyYEv7cU1X6tg/CMAM8IwHPBV2qG/nD7StEOrQKoLBWRIAPHNFzXzwQ+krMj7DAvduBFv6GWf2NwoOU/ROuD3LVeU2R8zJse2RpH9RTvAHjer5+3H5grP+IMjaRhxe4o8zLQe0i2qurjBTjdmHqx4hxVVSHvszwCAqju/jyAjzelca1hW4GTofpdZY9Em/Pp3yc729t/XitAPO/r0NuU9AbOcZ6ELMJnx3hWVkv343V0ARNdDF6W0bRWbfbT7c7wWd61xwi5A8snZTCQaJRS9US29AJxuMC3AQ3uljUNfRvcu5ne6PjEKD497G3c/bmRPyV3WBVM+0wAcqIB/v+e2xU4Gj8pyR6ebmigstklyoSYqXSRkM5LDQlKUPwBOwAMipoNeDSbfOVOobOKMrSh0bJRi8S35zpnCNQaiTFirz+lVmG735rkBiFlxNkdmXPXTi5sejH+79msVjBcA2ByG4dyv4g7tqLYRq7UPUtIVN6P+43WSFexdUelkYTLbqwdP+4EBhj2RcE5exInkC6fEuvn7AKLAq15KkvEBM8Mn5I1A40eFzoOkdZR9DFRsgjz1MC7D6TKhrZtqVpTgD9u748dZJhgndzS0MS7/GJT54Pq+ddr5geeW9tifsfW7Z0l2uG5+EgYtulgCOgM+KWEvFLTGTcuvdrYHJlYhO3+AMB0qD7VG7rO5gitXJMLRM/7elQeQmN1dWrCzrklBkJEm29Re0FQ/dp05miRexgTACfC8dwBckSa4DTYcbDDiPYmRb4zT1KA7MdlAkpDbN5IRndUTyOqNeT8tBADccGuKs5ohN1mzRHy7e5opaFcOLQnA7+vuNPrgcdsXfvdpl8zQ2ZBSNSXfwdxZd9E4NS26ADgrCH6HWLV/rL7LNWs39YuXOo084tJjvfB4vTQPG2ieduiqsScQjAu+JsHYqrX9HcD/F4ZhmQ7G9vO47dDxOvCoBZtwTl5UlLMWTCK+bVsydceSs18LB+iighaYB6ydumerpGlqVF/TSzhyNQHIUsw38nRUrazIjZ7RD83Kl6IWzTUZFClcrrPUrGvMy/VCgWmWuHFGV0cDgg4a8hLapapWkmss2oRlL7UWWKKsoBS9/vaJKezBFOp2lqWZIAJIVk6IwYccCEno4pr/nTUTP8T25ETp4iOkoG2XtD3P9t/XCnVNt/QSC+V91tq5DcsKnOyQXX6EWwQ6sYGW9DKtoMYWbHoGUlXsaPKNOjDz86KJRTLZ8Pp2e/EW+d7zT9aK3gcQ8aO5snuhoLXxKFSt+H7rcsmDn6LXshvkWjAjZ4ZJnFtzgHVbPo/d7wbUGTqboDRk40tq6tZorlQ0ZZHKb1rqU19HSh1ozJ3qexy+J2NDyc4YWmSXwsKTDo6VPxnY5MCX/rt1X5tgfAWAn4dh+CO7/dVhCtWB43Mmtci1bwCpIQTRF7AQw57bFptt5UfX6sabY7zMfEdfzTf19Y61vJ8jOD80NnPTLxkQPZiUttQPOB9mDmaKPJc1o9ca9TebWYjppCo0AnAKUoB5WQlLDJxQj4RBg5E6eAYASFB2Ou7svgFTkKLRKbdrVxZh5+ZUgSWSe3dypE65zYknZ0A5kjqlSBabMjQXr9y7B5f12ynbos5nl8+1C1c5VkIx4v1WPF3r8YYfvCM6zdphBYhab4lBArEt7JQx1Q1E+KLcYfJoDWs+q7weQOQxKNZglo1B9xUu47VuhD+hilCQnUh0swyPW+PlRdN3GH9ErZmsNCEIr8TDb7WKGq8z96nbtqnkp4WvqGDHSUGLI/Gac4IDoklDC+trjRj+/rz79shEHq+Y2RwdeJWjL2p6MF709tcmGP8BwOowDF+024/hK7ZDA9EMzIeGWJbcDKsbzIySmLGmajlCQrbRQuONvpWQr3Mbr0tKFzMY/P2HW5yUgchyXBVrtLhL0vg78PerfuXo91I1SxelKNsImId73n17IrnL0k+wZuKHEnjYqquXksx2ONG8NXQRcrqUC66eOniGBGTABOWr37xatqmloLe/d+UBxwCTlD1u7y1NRfaCK2J0gznYLPDQVYaMc3vfXdISrYWCNC1KHDTs8I0/uQrheW4c+rI4jwCIgqon2qMbQypLWjku13TUkNXPmFjMUwdIwDwHmsZH5gtV8W78bR4a16yWQi4hKS0KxEKWLhTqrJXf15NbyYOfyrXjO+C3S/sYsPZwJGymO0YdzZIP3hFNZO7TV6Dj93Ww1asbTmbMzqkmyL8XCl5lOeZN3iLXS8MeDSU7kfofq04+GI86gWC8+GsQjIMg+AaAz2E0javsv52wOzQzY75MuoLtOz6I/oDKSJM6RZKaLFbEaKlCLZvUvgE4AvBA1EUlS3aV5cjwzVNtR55kCRb70rxN6voCplCmJQ3ZwQcgRmnMYUvAsAYACMNBm4k6GhrWC83vOvOlOlMHzzAiQ3ZQAY3nWTR6lbPduGa1wCoAxPpJb5PuBsTXMyZWCkA6/LR1EFcEfBETh12PygnT5BqI84RnCqtFgMhZ5bZfvWfRkM9DdUER9pamynH6KxNmh3yOygpKcaA6BVnXpLiegkqQnj6IfC4WrMzEjTO6yoQAwBG4l4I0IAHpx1k7nePUfF8OQi4ARLjIp5z5Pnia2cHCOZ8d6kmz+zP32VwgPVOU9gY9ey7wRblIBXA4ovY2q00cdj0AAwfqZEFDN0BE4dO48itjCg2rSOHKzRGMKdvblJGx7ORhkaaMU6Lpg+3QdPP1l1saQiDmp73S+AABkXwgs2CKxWh3XGa6R+MVk8vMwaxMtzLrZhIAOPLYzFgep88KURXuNdN3GciBk4UVUNFZ7NbhzyPrmhQpvFArgb/53JVLcOMcV+5SL/VLpqyXbS1UnnR+jrRcj1yYB2wvRurERQAgTSKaTqd9+ZjpUdwdiLz39HZZQSneqDAv6fih5TFc3JIHP41slyaNEdt4vnTiaafcKvzJjq3cAIQTy0Kar+PM54HHDkSrLq1zEm7aEKP1rL8PwGHI0PW6XXtzbj6e7jA1YCb6xzedJrAFJwzB+W0rsG+wwKwXiKyZ/FoBnxOuCvhcODrCKnnQhXI+41xhsi6iWUx6QuD98y28/AzekQv1zIVJv+O5OxKrCt7TzuJn/LwL2k594aSD4xfD/keTA1+H1/7zXycYl+WZWUrfbJ15an5kwuk5+MuA2bIE9Q1IG7eXOvKYlGH0q7LkK3MwkwJiGwboMkGJwh2rW0lxTb9ETncR1bqUZXvVlPxIGtQ2cKS3OQwgymqLpu9wbN9r5y4UZbKuMy8WnzvAFCeXXLYk6tqzuhKSyQMxAX7j0JeR3uawo8428v6ucr210BAAxwWEf58zoFx86zjaTx4ik9Xm+SFyn82V7SPF+5wXjefP632wwtg0+VrNPkyhi1pCa9OrmTFDZEKl1KXv4aYpYAAcqyxHlQw2E54crSB8nq5WH/M7GvkZoSqNuaNDpqjgkV6n9XsJk+lni8cHQL7PhORAdQqyf/kdSUqSO8JZqYg8pu32A6KJhYNQoKaUVU3JF2aOYN0s+CGixTEJ2Tj0ZbPi0p53CioiPU8zOFIvzXabbMa4hXEd2AGzGvn2h2+dfDC+4gSC8etfg2AcBMHtAK4HEAL4GEa1rRuAPwDoCOP+MTYMwyPH2g8xY3aHOdmK72pg6Tg6o9xz2+JoGe4VBICoRZWFGWbW2h1Eyy9KEVA59vqVfvJWfdFvbXUDuC+QI9tpHzpfsUp3UtEhwnnRlfAKP9f4mqZNsf2XAvKAWRX4tksbh74sMERw3oUxgvU3DHsJ8564QLYp+q5hleSOcJgNtBviNq8XEDV5MJNj5pYw8HLBke8cst8J2OSW6wKfhqsA87JzEk4cdj3+NGCO4x9IxT/nuQAc8XP/cz35sdNT1yNYv9CrF427+p1vbw1dZISHVFFQ7i1U04cS+ikrKHVU8njtdOGMAjsARMhpb6l5Zxy/R5Whk6fObW0YQE1hds9dsH6qsFGASEyLwka8RyUPfooz10w351K1NwrQ9vqxWQSImmZ0Ew6/7zdoaXW75hAK2n9Z04NxxzdP8WAcBMFpAN4DcFYYhoeCIFgCYCWAoQBeDcPwD0EQ/AeAD8MwfPZY+9IFPL/tVStOAZEBJLMGvuBa59ZXgmLhRrdYAwqrOorOqt/p5jgoU01O8TATBl4uWJfIKNqXTlwi7DJxz8y1xiDSFjcSzsmLMFH1ovquJ9pUsrqgyGlZfWXSlpjOOuLtbOL4xU+OOJkaCy6EJeIK1gOi6fun+89zLIYAk+3Vb9wiMAW3F6w053HjjK4IKyodbFvzYlvdeLMjMA/EBi0uwx2xfvVccBLWhV4AEmi5fNZZcWPRJicrJV/d4c8qLWd2TfpqaPycx+VkhGwwYiOS1cbQAcqhI/orLECunQ99aBF8n5GgVd42zw9jGm/YbMH3xp/4yfPWcpcaZiPvG1BuN1b2VDSTZ7ic6jPXTEfjR4XOKkE/F9371AgTR5+bLnwn5PZtFnfo/f/zBILx//p6BOMNMP531QCWA3gKwO8AdA3DsD4Igv4AZoZhOPioO0KEGTMDThg02BGT9of2qOPSSpsxalFxyaIJewBAZbnTBOIXduI9eOxmA6JMxe82OnjXNLR99BE57rp5zyD5zpmy7UhVflGOhx/YjWmT2pjjtEFd6zFo7ihgcFFfiMWpeFftxcPj3sY9r9qMX7lDM6jNm7wFl2eUSeZO+3QWysiL1YL1X/5tmeDtgx//L7zRr0FwXsCKD80YE6NnTHpc9z41TmdguwGdHFiIbIyi0asiPWNL8dK+buzo4rauzEsGZie7oolFuGD9VIevru2HgFiGAKv58QR2AMRAQNKFdn5OVOy1nGXd1g0gpjPQvxZaUpMTsA6MZQWlMdKf1OHgBO741yk9F+Lg1FoGIhpljLu2kgjQLhzUxtD4uWaQABDpT0IhB4tr0bZ3nOKk6pblBAcAr9y7ByPv7+podyQNznNEpYDmKaiVD256MM5cfYoHYwAIgmAygFkADgH4E4wh6YYwDLPt598C8McwDHOOvheXTeEUGfRQS0nqV3BoMW8WJXz7bwCOk7OPD6Ky3LUcV9gYdS3E+dnyixPOyRM9Cz6I2iaINCcgKiRqbdek8Xfg4F3TABhxnUGLLo7NxFS7blKnFHk4uQ8HGrEZu3CGrcLavPv24PqxBpuWRgebZQU9zsLGoS+jz4RAPr9h2EuYd2+WOde8EfjGd4dHbAtr/6NhCR+moGM1YQqaeurJTLMU2ImlGQHt2tei6xOjnOq9X0wLMtIcxbWi0atwZm/znKTPfwSfDZolt5CQjaPfYKEj35hAQ2TMnvkcOJCY1Rbx6V3ZC65wltlJo0aI3nblhGlRAIYJ8JWHWkdsFSgan33m+Wz52hR+A4rz/bG5Mc40Puat3xtfy4P7p9koG1l0ezmfcd/rUFMrNUWUjSJ8t5h8CXdcaVNoswM2BPF3myMY77uk6cG401vHDsa2A/lSAHsZ66zz0Q0ASMC/JwzDlcfaT0JTDyjOAWQAuALAtwF8E8Zyacgx/6hltIyW0TJOgRE2Nv1/TRgvIX7sezwMw+/Z/x0zEAMnB1OMBDAkDMMJdvtaAP0BjEQTYAqnHXr4gL7j+0Uwgu+eq4eu0ANwut4AOK3QACTjdTLkqr1uNs1sW8sYAk427ivDMYvWesYAYnr5iV1qbBOIik38fsLpOfjTgDkxxZ3jYca62r9n5lqHk63V2U4UM/7RJOMesvr2byPISBfqG91DHFsgq48sRpN2u3C56YInJ1Xzn33M2C/UbB3+vENt47lzdeJLfdJlgpgxVxFaCrTv1PQTw4y9egUAR2nPX5kA8TFj3XHHrkGuEghHULyo6xOjIrspH2agHZetZ/g6EY6Fk4LlKLvqaC3bZ/6toea+8rnTmhlB334CJTH7J8uBOivUggFiZU91yzZgoLwjj82UbQpEkWGkKavaKPWvy9vJyq1xf02z8IzLLmp6Ztzl7ePDFEEQ9ASwwsuMD4RhOLupv3MywfjfACwAcD4MTPESgCIAFwJYpgp4H4Vh+MxRdwRlu2QfFE1M59CwhNZ2Pfx+Cdo++gjqF/wGQNRSrVubw6q9SDg9JyquWeEg2baBOsYjj3+vAzcgDrhacD5x2PU4eNc0x8JHKEWIQ207PwdF03fIsjotfwrCqr1CcgcMZHA8zNhp667a6zZodMjEw7d/LAEYOD5mvGl2pUMJiydYv+v7vZCWH3WmsXPN1zPWTQgpQ3PdIKYwYyA2QCcNzjNMBiXDqaUo+ZITHpCWdcWxJo0MAJCeGWvkeRzM2A9qvrCNMBIUZkzrLB8z1hhouK3EEU3SmLFmjOgJ3HdIZzMPACkEO63hpZ84Zp4+fEIIgefyyphCjLg9xTERFW4yIFZcOjHI7J/oFNNZO2CtgN93GEYe7Q+IEqvKEiMluufJD3Gg2jwH2fkDsGbih0iH4Vn3nZreLDxj0mmbMrr+53/eBJs42jEvDMN5+jtHCcbXwdTTigDccTxd95PFjO8DMApAPYAPYGhup8FQ2zrYfxsThuHhY+2n5mdDQiCS3NNOHElX3IyGz7dEeK3tpCLoTwEYUdayoj46ePKFcnA89WI3rnsDra67B/Wvmxdcq68B5iVNvv3Xol1M3MtvjdWdgOI04b24ehLRAQowFe1tT5dJA0HnS9Oxbn4SerYxRa2sa1IcilhYUeVoQrTuny0i60DUJrvjUDsMnFAPwGBwnXvUSEGE3V/aW84/Tq02V11QhNP+vBUV48+WbO7Witb4/dD6o25vKctETpdyvFtuKE0ViaarjMdwZL/hGqdn1wmnum1GHVIvjYp+ABxfOF/Hg5KaWstC82qZlWm9XdESVv5zAJyVkS+lCsDpBtuxuhWy8we4nGvb+egMJbvpq7ARSwUireeEjqkOlZI61ECkc+23dcvv25WJ7kasX7xUugN5LtrNhsVNRwLA88FDVm/BvunwoZMcNmRprr3G6f3vSxLERMtSDx13d089MehxVrNIaO658ASC8TvHx6jjBOMuAMphaL8PAOgWhuH4Y+7jVGj6oLg85TJpcwQY4n36/EecbWaR3NZ0MNF9tVmBk20pq5vq+xYKoZ3FuaTxdwAwDxq1WgHIA8XP2dYZDyIRWo8tQgicYls99Qui3Y+LJhahz4TAKWJ9cCQNI+fmSMbDzINFrYET6p1lc9veKQ43Vy8t2cGkpS8BU9ii4wUQdXfJMto2nmg1r7p5zyBjwceoGH+27Gfom3VYeVmruNvl7zfg8aoOuCE4aC7nIaNCx6Xn5vkh/isxBcOvO+xkSVqAnq25PiXsaAUpFnL1/SEkQPjk4qnfcOUt7eRIrrJvEMAgo/cJuBRCChFp6U8gmsw0jxiAqPB17mFFlzqac0/PrpPntnB5BvKurJBrQe1orsLWTN+FQc+eKxMCxeqddn/7zOumI31fOUH4msLa8kmvHkXl8ItyJOTZyapwqRTegMgYQkZluagw8vvalirhnDwceWwm6vfVCiup8aNCBD3OciDG5gjGf/9+07Upvvnn42tT+MG4qZ853zslgrGFKQgdhFV7kXT2QABA/cfrHHdoVtS1ezQpRkAk8sMhFu2KH0osl0Gu7aOPIKzaKxxWf9nHz8WVeVZPcRLWspA6OPsZpu9Y4OtjdF/7HDbk3GXUt9RSm1rBQJTJaTxNN18suWwJLuu3U7Z1txzPZefmVKcJgC7PnAA696hxtn2dAwaLzP6JyFjwMQBg63fPQmb/RAx90wT0lzMTnO2lvRpwsKIVri031RAGab99+kB1ijQEbJpdiUq0koyeDAIeF9vEHYt7pVQGwNEe1sLwpIzRlZlZGGmSWrbTt4dKGn+HrNqog+JjvnoS8LWHaSukdawbC5cKZt9nQiAdn6Kr4blaA3C6TNmKzq5QCv/rJpDk3ia7Jjuiy9geMa4xfmbsw2x0WQfg0EM1W8nXC9F8Z0J7zLa1uw4Ah3nEQeEgyt02VzDe1b/pEpqnvX98Cc04mXG3MAx32/++HcC/hWH442Pu41QIxmz6SBh4eUQ/U5jt0bQiAIjmhC7G+RkTNSTIORUYQzs6KE88LiVlbC9G0hU3C0wBRLO+v9zUeN/eFZWOnY7vZgFEjSfEO/fMXCswQ3LvTrj7dwkYWWte9L5T07FpdiVyBpjjTBmai6LpO2S7df9sLH281pGmnHffHlyeUSYv/6bZlejepcpRvePfAlHzjIYlADiWSj4M0etvnziwxbXljVh5WSvZfre8Cwb32onVW83E9O2GWjlmwEwIhCyYwZObzOCRnl3nWLjvWN1KNDGASEHNd1bh8XdYugB1Lz3kTORFE4uc1nBCGprbDMARCiIlEQAO3jXNcKqtwSoAofg5k4TK/ujCIe4Ynl7DkeJ9EjgdXFnh0F3G9kBwRnbUVWcnBDGIfTbXaYBhhutzrAFIVlu/4Dcx7jVBj7McOqfW/KZejH6vhAbo1X6YXTvvt92/HlJYt44hgFpJKDmE1mf0O+lgvPPfmh6Mu//vYwfjIAgWAcgDkAmgDMAMu/09GJhiB4CbGJyPup9m4BnfACAA8HwYhk8EQdABX9GQlAHP7z4i/gdES1Fn+el9rp0TtOawiMnbwptj6KjwMenB1118Ci/jbJ6QN0IyBT5EzktmFc8ASEOCL/3Il1Rnvcz+mBVrx4ykUSPwi3GG6fDwTxqRkNVDhFoojUkYI6dLObq9eIs4LQMRTKFFeuLBFLpCHo/54MMSx4It4sEUhCUAA1NwgtDFoLa9o5UF8XG288bDQOV+w9XwBSLZ1PrVhU5GztZs/u2a6bukdVzDTkDEHvD1ErRnYDyYQotfNQdMsXb2l8aDULXv6wyfLid6hUgRJJlsLa6tuw39QrV2R/EF72WCiQNT+MYOgjuzMO6rH9p3gDWYxOzukdLbPwim+L/nN93p41sbT3GnjyAIcmAKdRcAOAJgFYCfwVQdT8yQlGwKrZrGYRsufN8sOQ5LW9NaxE63nT5mXSWPMxwDRzVoseT39zt+aV42QAhDNwNoBTa9fAaA5Nt/jQM3jRdKFmCYD/sTQvFTWzPxQ/xgwG6BIfx93jDsJTyZ+4V8/tBVi3F7310OTPHmhu4xOLSGJbi/psAUPixxNNjiaDCFxm7LCkqxpSxTghr1gMkMYXHuqDrXNmvWS2Tt0qypksTMicnrJhpf8yE470Isucy4ig+/7rDTqMPVTDyYgst/doceD6bQ7At6FBKiiQdTsBkCMBM/xfkBiGqhzwDS+LcWJDL7SHOSHMli1XPtsEuaAFMwWXEmSqUUp2EkfY80TEE95OaGKT7PbXowPr3o1A/GPs/4VwAOA5iAE3T6IEyhObcE/vUyCIBwLCUgkkescD4ADhsiLP0EST+8GvXvLpF96Bk5xtpJMzGAGJ5xkJEmL5Ee2j2Xy0StkeALgGuOJvnEuirfbkAnvFDQGvsTzD2aNqmN2xbrvaRBRho2za6MWoqtzXlOl3J5+Z9/shZZRxocdgUhAcAEQe0aUTR9h8nI7QSxZuKHmJdc48AUPizhwxbHgym0a8h767sBAH4wYLcYiHJo3rCPyfuaJrz2xIdTHnwG9a8/IzgvYCCXNyq6GIElQFY1pEXq4hUQUSqZtf39ql8BMJ2PXL3kDChHm+lTHH4tNRsASGHY79RkUKT2SlNgCt152Vi0SWROc5/NFWdmng+pbJIMlH7iFKU5wch7BTjJRmPRJsdxJx4NlCp3svrL6hGDCwfnXRgV9XTGDEQMCmutBrjSp4CZTJtDm6K0T9PdoXtsPsXdoYMg+C6A12EaPQ4BWAvDpxt7ooakhCl4YxNOz5EbGFZUmsCn8V7VMs2g59CcVF++fqAEprBGog4uDDgtq85DRQK+wrGCjHTJmPVxCUxhj0HEh6wRpbxAFI6x+2RQ1dxi6uIyi+V+NAyh9Zx9xw3il1uHPy/L4PaTh2De5C249vydsr95Py3E5RnmxWdgkYBu24y5fTSY4liwRTyYIr3NYcnk4sEUOzenivYyAOGn6kk4nqSlNtTU25wow20lMUUsaYdWFkxARClzrIoAR4C9ZkWJI0i/7eky0acADNOBrBf9t8TkyanVMAUHJ+rpq9Iwa0iV47NHDJ370DDF2tlfYtCs0+LCFFq7GduLo9Wg3dbMEnLjAQNrBGmdHc9H6mH4zjR8tslSOtoEQFhDrxooGMUJ78hjM50JsOG1F5qFZ/xf517S5MDXHJKdTRknixlPAHAzgC8B/B+YzPi6phiS6uHAFBafFTbFu0tiMl8tgk1YwiGae8U3ZPWWpRSASEzeLsFillO2gquLhlqIhQ+q7AeIgSm4NNXFIN+MURtTEqY4sj8qlsVjU+imBb/xYcllS/DthlrRhBD2h8Kd/e3vXXkArW68Gc9daVYN1489jMThY2V7YGIVei27QTq1erY5gHbta4/JnvBhi13f79UkmAKAU2gEXJiCEwEQ66d2tHuk9RtYvDsamwJwi0wsUpFNAQDffPUBSRRYWyiZsh4fHDFZ+ciFeSKUD0DYGLorjc4mQOQK7jtn+2wKBnUOH6YgNg3EhylI2fNhCgdTH+tSNXUxL9xWYpIiWyOpX7xU3j1dJ9F0zraPGkrqntsWR9fu8y1HVUekOal29o7XPNUcMMX2s3/U5MCX9fGfTv1g7OwoCB4CsBNGLOi4MIVuh84/r1ff6779TaHXaK8z+T5tlFgQUJ1V5C8CiIKob4vk7atx3Rtul57qWPILGQDcrjz7+3xAAbhQij4uBnRV8JBtr/VWZzLm38xLebDCBC8NRwAuE0N/X3f5UciGD7Mv6gLAgQPISmAm50tP1i5chffWd0NOl3Lx5lu9tTt+mFl21O3T/rwVb3foj0qY86hITMQPM8vk93eWpSG9zWF07lEj56p9/+T6+/fV3/YZMdb/UF8ztk3z+u3cnCoZOjFV33lCf19fb83cYGGMWbIOelrhDIgVdm/cXyNFRTb86GvwWXEmzuxdjj9sN8fx46yd8u+AocPxd/Q+fXeT8vcbYjz3fJd1rjSETqrfCb3i9JMVwNFUBuC+o0AMLEElPY4gI10KqE4G7703zWFIui1ncJMD3xlbVp/6wTgIgs5hGO4NguB0GNW2fgCm4wQNSQlTCL6kKGekAvlec8SddOMEP9csh+P51snveri0gynrf4PFsde94VBw/Eox4RX24ksDiSpeAHC0FqibrP3RdPbMF45yjGQDsGuNcoSOj5mSYgQiqyDtvKE5qnQe1rCPFt4HzFL08aoOuD3NWBu2zajDrB1djrq9sywNF33xPhZ0ukj2cV5yVKR5JWyPcWl70TajTgJM9y7mcxq2soNOrqO9lrp1Xu6J+lwXhRigfO1rXcxM7hgF2+2/r3Xsjnj9GCjI9fX1FTgpAnC6DPmb/kTIVQAAmZT+UtxNWoABoBKtcEFvw4z6S7HB1XO6lMv1zRlQLsd9YP0+JHeE0+xErrHu2NQdo/QPlHfJGrhy1RDTkWffD22JVjUl3+k6DdI6O1Q2vfLl/dEFPV8GFIDAgRyNn29plmBcclbTg3H2J1+PYPwujKNHHYApYRiu/SqGpH7TBwAkWvy2gdQxtXT0uZAOm0JT0hDRa2JgCvUQsKWagdGnuvFzwcsmjYlw7ROAKQA4ugiA6wRCEW1mUTtWt0LlodaC11IfVjeSAFHmRo6xLsblDChHUqcoABCL5TaLYFwm9xxc52x37lET05a8emt3nJdchZuPGAz4BnQ75vZdDZ1RkZiI8fveBgB8cFof6NG5R01MNv30jtMwMqh2JgkNU/BaHq/pw7eR58oAiFqP4xWJADhUMQCO9m68fenv+J2ZurioO/aIWevMmNeAq4T07DrHZw+IsmYgwq75fV8zgkyTg8W1AmWQiaIn3Zh2aCVaL5ziYzR90NGFE7cP/zWl6YPwjO+D2dxsis++O6TJge/Mv528MFFTxinR9EEwvesTo6JWaMX5TXnwGdS99JB8P+jbz/GzS7791/K5cDh1FdgGunbPLTD7fP0Z1/rdZtt8qGIKeKqKDJiHTrSXPVFwB5MbNSKGcid4mXUX4efkzFIrGIh0I7QZaFhRFQmVL7gC9YuXOmppjUWbopZsu713RaVDi9IvDHmuLDqJGaYtlNFWXvN5XyhojT5HamWSYLPB0bZfe9PcC2bD5+3ajKo7vy+TzmtvZmL4dYed5Tp1ODRUoG3d2SEpymVVe+OuknSBiiJKDKIHi2sd0wBmuMy+qUDG4Owr7VHbuHF/jdwD+vnplnStQd1+8hBXwW6yoR1uWW+u0VsprfGLnxzBkeJ90gDTc3AdDhbXCkxx/djD2LuiUlYNABwDU9ou8TmiEcDOzanS4OJ7BrKLVTuBxGv6cBgmnkzAwbumyeoOiE+HO1Y7NNIzDRatWDO81jqZao5gXHzm0CYHvt6frfzXCcbCpoCbbQCRcSWVydgCrHvqG9esRvLtvzafv/SQ205psxRNl6Fwto8LM5tpdd09qHvpIceR2hGbV4NYtr9E1liY2XdVFMBhCyBeJxYVxLRSW+ql2YJV0mSSGTpfLq1+lpY/JUbprW7eM5K5MSOj6MzVb16NxnVvOJZIjWtWx2hqyEtq2RqfFWdKsK3fV4s3N3THsMvKZZsZOGAmGqpwASbQpj32Z1Q/9O9ybTbPD2WyAdwCFRAV37T9luYd+5kvOcK8FuQQvzV0kXCZAThUwFY33oyNQ192mCRrRq91/APpvAxAgqruqtRi7ECs8P7ucU+h68yLHVNODY007q/BgpWZuPb8nU7Thy5yvljVGdMmtXGgEP49EInm666+mC69RUOchIZsC74TIpCkbZaUmag2D5UAbesezoSoGUUM/h7PmIlOkNYZlROmOdeLn+tVa3ME47/1anow/u7Wf04wTvpn/EjLaBkto2WcSiNs/KfE1xMax82Mj2IpErfl2fKK58CYkh6EobltPt5BaJ6xttYBbDOEVQ4DIjF5Zot0FdZ8SF14o9iLXi5xKXQ0BkbjmtUxTSP6c7ZcA25jQMn41yM/ug/eEToW9+FIeyqIAoiydd94srKklaMjsWV9plDX6uY9g8LlGbhkpbFEOjQrX7SF9XaXsT3kmrJYx8z38U2n4Z5XRzmi4cymAbOU933NmIkRLqGR5Lr5Zm7/wYDdznZOl3InMyYu3f6ePwIAqu78vnSd6axVc3ZJI9MrEa1Z4NQMoNT77Kies0rE4EnrYyZOGIg0P7/7kBTBvlPTxV0bgMOT7jvV3CN2wxHfZXs7VwnMvvl9PrtsV2dR9r313YzgOwzs8N76bkJtO7B+H/6wvbtYaRHu8VkafIZpe5UyKZIg9T3xHPYCIMU5soVEL9y/3taxHIiK7T5G7NwbWxgEEFsoV7ZRLIiyTqCFwZqjgLcl69ImZ8Y521ecGjBFEAQXAjgA4GUVjB9FnJbnIAiGArgFJhj/G4A5YRj+2/EOQnjGccbRZBK5tNHi6oBdPlmbcUA9iAof4344/EqxdNIpOo0OwGHV3pjOPwCOvnHS4DwknJOHvwyYDcBYnesHM/nOmY7kIB1xG5YViNsBmxI0vhhuK5Hq+/krr0XDsgIJir2W3YDGdW/I8jUtf4oUVQjrUOGLQa52ZZFpkV6YB8DgoOnZdbJM9Nu6Oel9VpwpAaVmRYmzve3pMlQeai3bm2ZX4q2U1vh5T6OhsXprd9GlACCQRVhRJQF84IR6R5kscdj1+MuA2bhg/VS5B77hqwMVWbNYkeC0HWs+dq4xThrPEi/fc9tix6uPQkF8HrUfHu8BxeKpSZLe5jCyf/kdUWVjN+MrkwycMuyyctTvqxVGzIHqFGT/8juoLigS1kTelRWCSQMGhy5/vwFvVBgY58dZO2M4xI5hqA2QWgiosWgTtv++VpIHwiUad9YqhHwffDU6MRlFHEF/G2xjDF61aJLXkk04z3et1lzw5mj6+PjblzU5GJ/9X2+eGsEYiCsP9ynicImDIHjO/vci/3vH2n/FcCP0TKnKIK0zEigEb7FbBr3qOavQfsYYaQqpe+khp5BGXqzwfwuXCm1H5Cut4pXW6NVmixTj1i+ytt5JHD5Wgp6vfcvRULLTkbfcPe4pJ8ixCUQ7KzDr1Q4a2kapZkUJ0vIjjVm6cnB729Nl6LXsBsHXyEBoWFYgRT0eLzFiBnDReLDZk48h6xd7z22L8W55F+EKa1H4eNsHqlPQrn2tiMsPv+6wk00CxkGEGDJgbKLufvxsp7knrKgU3LTrrec6bAlOFj4jRrtKJA4fK44gAJz7BUTPga92xlUFVy9yraztkw4W5DHrlVNZQamsVvj3fA54b3TR9mBxLdqPzXUKjdpl2cfXOamsnf0lgMhCac1E0z496NlzxaiWin5tpk9xmk98yUxf0IiKbVppzReHZ4efLiA7RUDroqK3HfEsK5if1CkqojIJ0rrIzZEZf9Sz6cH4nB2ndjCujNfyHATBCgCPhGH4nv1sLYBfhGFYFH/PZjAYa5sXh8+otgnmMztJOnsg6j9e55D9Yx4idsopWEI7TMermmvB+saiTdKxBCiLcd0JaJkTmk+src5jMjULa3Aw6G2eH0rXWXVBEfaWRk0Jvj8YReN1dvNZcQRj6GyHGY3WtgAg2RFfkBcKWuOm5VcfNeDrxofjwRQ8Xp+qRToZg8fACfUIMtKcgMzlPs9NCq4KagIiWp8IrisWiC/4RCEhbf+kr2uXsT2QMPBymQwZwLka8H3gNAdcF638jj692tE+fkCkt03YiFzgLevdAimZNebapImGCI/fv6c9B9fJBMWiId2tAStJOimySMrOHxCjjuYIw9vnmRMAi9Ga5aCDOa+3ToKYTHDoVmkgusf6d5j4aH+/NhNmn3Rw/OD0K5ocjM/7/PWvRzC22xVhGGacSDB2DEnHXtJ3wv84x1HZ0nQYZsPytz5nGHC0U7V2BQBZLpF1QAxUt1gempXvcC4djQFP54CC2QfW74twSUuPE+zado4xu+FLrLNx9uoDEUyhYYbUS7Olcwow2SD5okCE7bJCfv7Kax3mRLcXb5Ft3XmlrYeoOEbqWv3ipXhsVUfc86rZrpv3DHasbiVBkftLz66Tc2Eg5DYlHrldVlCKnWVp4vfHCYYvqcaKNY4MwMnIBeu311sLMwFuEAz69sOe2xZHnXzKsonDl7vkZKlZNHp1Q1shBpCtw59Hdv4Ap87Bz3Xbtmby7FjdymHA8B5r3jc5wqS2adF4bjMgAwbLjjfJapx697inHMiFcBQdNf40YI6R5VTaH7zOQJQZy/W1LApNMyXdTtdJWLMBIKsMjW1rmENEwJTAk6weFf2tOTLjzd9qejDu839P7WDcrDDFobdfkIPQgRaIlkJ+NsGmEDqByN/bYM6unbBqb0wBTvAzJUivWzMpTKQV4PSSl3BK47o33GxaFQ/p7Ky7kzRHVWyf7PdrF67Ckf1A+vzIXJVC4wwWpL4xS+XyV8MUPtWt/YwxwhUGTPanW36pMEZ+b69lN0hhEDBL3D0z1zoGkdRe3llmgmnOgHIc2R+15+YMKMfOzalir3Rm73IcrGiFF6vMvf3FT4441LWwogq//l0y7v5VN8k0iSM71DU9oY7NRULeCFROmGa+b624NH0x/OAd6WYk7k3XFyDKlDUX2RfTCTdtcFqHHa1n+7cJWT0cSqY2LfVNTH0dZi3qxOOMB1PQIxCAFHV1O7bfxq25zWyi0DKbCYMGO07OesIAILRLnnvynTNdEwe/vR+Gs35g/T7HYsqhj9qmHK2hrOl1nICoUgcoB3TFh/7GrFdOOjgWdb+yycE4d+fyUzoYP4Y4Lc9BEPxPAJMQFfCeDMPwguPtnwU8KYh5rcdaz1R3AMUdulrLbbgzO5djbIFmJ5FzzrqV09O/0Pqtuijo8HEtnqiLaT4eqbPYb776AConTJOmAe5PZ2I+g4DQB7MdefGVbVO79rWisQtEZqvM3BgoNLaq3Yq5f36+c3OqOGxooZ+Gkp2Sofedmu5sMxgzoDOL1l1+7ScPQcmU9Y5OhI8jkxEAQAKF7nA81rXSTQ/xWCyA5TIrbi2lWp0gZVuLgcgV25HL9PnOqvGH2zwWADhzzXRHKIiOyvRE5NCZbmJ2d4cfTRhDF1l180q4aUOMpCh1wdl+XFnSSqQ4AYiQv5b+1BANIRydJLEV3/fZ06JJzvfjTHbVc1Zh9dbuGNzL/BuFg2TSaCYJzY2nDWtyMD5/12unRjA+iqXIcsRpebb48VwAQ2CobeOOhxcDkZ6xqEIpzQGNI8kxnZEdCQeRMuYrtXEoQR5NaPcLeoDSUz0jOyZAU49Cvm8DNB9uugTz4X5802mYNqmNPGh+KzOLOHw4+bJp7QRKOPpDMjfbWcihq9oAZAmt215pN6Xdd53lvm1kIIwR9DgLbw1dZIpAdrATjcexd0WlMD94fR0fNHXNgVhVsbCiUgKrDmya/sagzKAFANm//E4k+WgnP114DDdtcNTf+Du6SOXDHJqpw2KfloCsXbjKYVt0GdvDXUZ72ikyqWvnabUKY0br61rrwpdv8eU3K2kfOzkXXUizKzBNrRRPQDsat5fK6oTHGU80X8OH9asLzQrEJi10pNbWYwy4QNS4o4udWmuEYkRkegCmPVxPEgCaJTP+39+8qsnB+N/+/uqpEYz/GcNxh353CRqLNjkyfPULfhN1hI0ZIstkINIFZubmZ5wstAFwRLD9ricK0QCQdmBmwIdm5aPto4+I+Dy5wEGPsyRTAIwwuub8MiADsZb3WjeWo2j6DqS3Oews3w+s3xedq7XS0aamenlMxTV+ziIP4Q7AcFR173/j9lLHZJMvqRYnShqcJzrMmf0TY7jHvv8c4GaEpPnx+urOOSCi+fkFTz0Bt7/njziw4VmpEcy7bw+uPX+nXL+i6TvQd2q6BJuHH9iNe14d5Ux2xFp1MPP1d/1OSu3ozWKSPxlqKEmCnF7ZVe2VFmAAMZO81oDgfdXt+SJiZQN6WFEpWhHcn2b/+MwIBlbfBYXynUAk5fn8kyYI3rT8amkxB6JM2feJrF+8NMKI2ZKuiue+lghZREDEUpLJjh54Shyo4bUXnMJfWPpJs2TGG04gGPf7VwzG5CTSvgWAFI94U3esboUz10yXzENXigGgZPzr0n8PwCnikNbFZSBZC8S60uebYsbBu6Y5tDJS4UTb4t0l0kTAwbZrMgRYkHpk7iEAkCyZMIa2QQfcTJlB7a/L2zn0Ly7TdfFH+/0FGWkx2xwae9XV6oTcvqies+qoVe4grTMaXnvBqWbT24+sDWKzkn3b66VbWnUDjN9eXjSxSAKpXt5rK/mEgZejXb+JOLDhWbPPqr0oGr3KaZ5gQQ0wGf1zVy4RFw8K+2tXjjN7lyMtf4qz9PZXItowgOfmu0nr+6ilRgE4/G6eV5DWWQq9afnGvFRLqbJgrK8nAIcNVL+6UK4hBd6d1WPffvKc8N42LCtw9Fg0xEVdD57bI3MPOZOZL37ku7UDsTh9m+lTYr0l1STtFzeT75yJxs+3oPq+hTFNH3qiaY526PVdRzQ58A3Ys/TUCMZH6cAbCWAmgO8CuEBDEUEQ3A1jvdQA4NYwDFfH7NQbDMbEdbUsnxDL7dKQGJS4Bdibp4sGeinK2ZnSkUD00nEJe8H6qWh47QXhsH7z1QdQv+A3TjMFX37AsBbCqr0oGf+6Yy3vc341w+CRuYckSwYimo9WFWOBjtkfVazIJCH2x336XVPV9y2McZ8GEEOaJ5+Wn/HF5HGgQ6ZkwsRE/exQU/N6Dq475kumMW0AUkjTAf/vV/3KZKjKoLX9DEW9+uV3EJx3Idr1m2g+f+jfkTDwchG9v3jqNxD07Rf3HgERdUtrIVRNyRcHCwDCdmFm3LhmtbPMBqJgqT/XEJbWyObwTQj0xKQLigCADpkCwTEQspNNN084HaJ2svOV+HyGBznPvK8+Z1oonTDvzUNXLZZnVj8zAITbH0/Ols9avGfcSQSsoJc/ufFeABEuryfM5oAp3j2BYPzDUygYx+vA+y6ARgDPAZjKYBwEwVkAFsGYlH4TwBoAZ4Zh2HCs3yBm7N9wIFrKaHxXZ6XJt/8a9a9HSyHSzjRbQGZnj03hCArZRg+O5DtnykPWsKwASePvEJbDgfX75CXWFKayglKTpSPqcNIFqUfmHoowOcARmSGvll5wAByresBYItHtA4DAB8z8fa1cesvF1a21AVyUzmzWxSIkl//8vq7Us/hDHI94NwM26Uoag6ciF4+bbBPedwYUfylNDHhdQxpu/G2eBMb29/wR+y7rJRPT80/W4vqxhx3vvtxFQ+T7LGDVLlwl2DotmMjb9jN4v7GH2tDad2/vikrjSqHdy/v2E1iCbCBfepLwgDQ0eC38GjoC4AQ93Q0KRHUT3bjjWyj5WDVxaQa5NtOniE8eELVS0/Fl/NBymUQBRD6QHxU6jSB6dULfSE1PdCY2y6bQiZWIFSk++cHi2gimaCae8TtdRzY5GF+45+SDf1PGV2JTqH8vhBuM7waAMAwftturAcwMw/D9Y+1fDEltBqeX877gOoOBLkglXXGz6B5rBSkAjui7WIp/VOioWvkWNGL7ol8wW9QDTJ8+zRZ9E1NmmCxQsQ2Wy2nCFve8Osp5+DUxnhgxYMj5NOmkXbtTeY8jRk/jSlKheN04tMM2G1p8nWXNSNEa0gxGtG7nNdcVb3JJfSdsXRijqwuvv78cpTA/g3PtyiJHl+PQrHx0enOrFPZEz8EWGmsXrnIkI7mq0M0oxL+1M4rfQq1tgchG0PrHhGT09UzI7Rvjn+ibnerOQSdzVhQuX/1Mt/gDkAxeXDg8TFmaNuwEQDqmnJtyRtGwB4CoEGmLcw/f/jGmTWrjwBO6+AlAGqn06kSfK8/Xt86K10WpffH+ETBFYZemB+O8sq9nMJ4LYEMYhgvt9nwAfwzDcCmOMRiM2VLsCwVp2KHkwU+F/gNAZnfdeeUTyQG3mJB850zUL/hNjH1RDPlcNXnogpJ2hmaA/8uA2fLwAbHtz5Ru5Mv40FWLJSCbc6+MsZyixdGgRSbbLhn/ekyzxKBZp8mkoXmjACSr0wWr2pVFaDN9iiOUj+3Fkf6FrbxrjrX/MvguJz79TZb6qosySOvsBOW6ec8IfJFweo4YT2retsZziYn6mLxmW2i63SUrR6NhWUHkmLxoSGRiarNnWvzo5fyR4n3iykFPON11ppsWiKM6sI9lq/iWRL5IlZbQbD821+00tQU3DhZA+cxJlqyuL1d7ACJ2hye0r00WdKDm0NcGgIsRZ6Tj4Qd2C2zBd1WfO9kSnFBYV+BvEUaLCehqVeabMTAr1lTM5oAp1nW5usnBeGDZkn+dYKz1jLUoDgCnK4dD60pIYPQyOU1Wj2fBlJA3QuzJmW1rxgELK4DygVOCMvxcd9htHPpyVNQ6WoHJdvURkxPYwjY0aDobxW3Iz+217AbsHveUwBJp+UZRjHzUICMNSx+vFb0BZtldbz3Xae0GomUoMUudteprXTSxCLmLhjjMCQrjaz5uDKNAcZWJg0rWbf9WXzsAMQU4XegrmljkYPLPP1mLa8+PXE18TvLa2V9KQAai7Fs36pAKp1uudeWeWLletWhMXsMW8USk9NDB2ue8+040hMWcVZfCkrmi0isP3f2Zemm246jOrFfDEqTs0Wy16xOjHG69j1uzQ5SwxQ23pgi8pI0XtPMKYSbNj/ZrHgm5fZ3fItuF+6yb94wDUzQsK2iWYPxWl1FNDsaXlC3+pwTjhGbe3y4A31Lb3e2/xYwgCG4MgqAoCIKi+f/5UTMfRstoGS2jZRx9hAia/L9/1mjuzPj/A/B7RAW8tQB6Ha+Ax8xYXAI8nE7P6FKM4DHorj0gatNUnXEUE2JRpeG1FxBWVEnhQJbIFoOjPY8sHQGnwYPZkjYcpcaBJuBrPJeZY8mDnwKAZICUUhx+3WEkDBrs2C5VlrRycF/S7bRaV8rQ3BjMmL/BYuDLGyPtWwBR0QmKfaLwQjZ1ABCGAjN8beyp5RgB1y1ZZEsBwUz193ULMTNLrd3B4o6mmrHdGzBw1Lr5Sci7skL20f6eP6JmsSnG4YtyzLtvj0Nt4+8SU2ejCrfjcdZ9qpbmldPOCIBoPNQv+I0jEynDcxb324gJTxGOqN+4ReRBGwuXOgU8X0RLuL2errDGmGMMRe3f+24f/mpGF9S1ANfDD+zG3S9e5LwXoj3MIqyVniVrqc+EIJY6qFzRyVzRhrnseNQ1ouYo4K3q8uMmZ8ZDyv5wasAUR+nA+wLAUwA6AagE8NcwDAfb708HMB5APYDbwjD84/EOgpgxENG1uARjF5Smb1HXF4iWirrQo+lJrG770n2O8E+HzBjdZPEIA5zOJUAR+9XScevw5w0Fzi7zSqasNypidh/kgvKFWTPxQ2cZzcYMzfIgfkm6UdH0HY6HG6EVjfM57ahWoaz92ChAE2+nvGI8bJUvBBBRnsRPjbKR6nrEY0Hoici325EmBCUY7tPI2JFHIXfq5JIjnDurpyMTefHUbyA4Ixupo8yymw0iN96/HQAw76Whojvh6B6MzXVYB/pceJ9ZF6icMM3RM2YQJE8dMPAaO9OAWLEc3VUHqOdbNybZZEKYD57wla+jDcQ+o44kgN2nI39p5TA1LU3rSvj3VBc2eX8oKOVPUL5WOM85nvSnZt1o3rbvwK1NYZsDplh5AsF46KkSjP8ZQ9gUXiYJwOkGA8xDvHX48w4FTLcVk+focxl9DQlN0yFmqjE3XYByCPmINAt0lhGcd6EEZA7f0WH3uKckIw3Ou9BpMw56nCWaAlIgslX5ZS8ZwZ2r37w6Rvlt97innKId9XQBiNOuFhXX/GEeY+6iIZJFbRz6shHCt3hj0cQiXLB+qqwARJheYca+9q1/faSzTgVjx5RzbG6MNKrfDffwuLdFSY7HmTOg3CmQDpp1mmCNbBBhsFkzei0GLbrYyQQTh4/FksuWYOT9XeW4dFDjffe1nmXbSmhq8X5SMUkF5ApJi+Nge3EMi0YzEzTGC8S2/ItUq1cD4T1KGjVCGBQAnO5GJ8Cr4/CpndSh0MkEz5mjdmURXt7YHTctvxqAqjfYrN/v5gRcb0Ot0wLA4SPLtbAqhVyp1awoQZfCwpMOjv+ry+gmB77/WbboXycYE6bY8+SH6HrrubJ0BiKrFh+20FqrfpbrfE5LcUtn49DLwCOPzXS4tSUPfioW9QCkgUFX0fXSiYPBEYi0cbVFT0Ju30g3YsEVDk8ZcB0ZgNiCkW+dQ46sb7qpt31LdjqH6PZSDUuwkYKTRMI5efhs0KyIO0oRJ6UfohkhQJwOPAsj6e/rIhaX1dheHEEGXut3wsDL3Y46ROwSwATW565cghtnmMDKBpGa1feZL9vAo68POxg1syRI6yz3kI0RerWmtYn5rPo0Pxa2eE10MU1fa/N5lTNZUhPFaTP2rhczYwmQY9xsnAqBUlQkjKdWcpQHZbClTZWvG8HJi4kB7wcZTmFFpdA1737xIlfmND3TaciiazXV/fpMCBxhfXaXahNe6mbzPgPNo03xZtemB+PL9vwLBeMvpxvOn3a1jfHaUl1cnPkByHJOt+s6AjBqiSYzr+0W00Lveh9BWmccvGua0OW0mwEAZ8nI7KNywjRH6q9k/OuRYpo9bl9Ss/2MKHusLigSzQjCEKRa+boSXBLzv3VTgs7KmLnRhgeAs0QHzLKaXGMg4tpqXYOSKeslm9EMAs0u0RQ6/j2Ds09ZTOiY6mhBs2EhZWiuHBftj8hZ7TMhQMKgwdJRd8bPuzgdd/z8xutWAjCwBACkDp4BAAZL9iiLdJWQe9kx1cHTeU80xKCPm6we3eHou4A7mShi/Rf33LYYO8vSRIFNr4p0S7VuFfc7HHUTCmCyXL/ZQpszAIjwY9UZSH0PAJGAlAfPaV2Uouk7DHXNTjyv3LtH7Lt47tqlZ8/MtY6Jg89EEQMBRe2j3Kg+1+awXVre9ZomB74r9/z+1AjGR2mHfgzAZQCOANgGo85WaT874XZogSnsA0bTS8DMjAfW73Nk+bTsHgAnMLDQwb58BjjNmWSBgCLtDKKOpTjgFgX18BS6AIiehg7wvsW9o3ql9wOT7Tx01WJTFLFDHmaPLqSbJdiAwW0Nv9DFQ2sxt5k+xUAAqruLhRYgagaQa2EnJAa93EVDkHB6jhRBAdMF+cWI8TIptLruHtS99JBzyTSMocX5ef2F46r4uP5qRbJzqEB4lCC3ZvRasR8CgNRRT6Hm2dGuJvLkIc6qi8LubINnVyG3s/MHoLFoE14oMLDRDbemIHHY9e7KIT0TRaNXSXAl/1pE2wEnWwzOuxC7xz0l2tC5z+ZKENbWTOvmJ4lB6Z4nPzRC8aqrMmnUCClQ1y/4jWlkUt59dHxxcHwNFVndax/71u4i2lpMq6uRrkmjYL0i8gX/S8a/LhAjj0evatlhqhtA/MmtOYLxqycQjK86hYJxvHboHwFYF4ZhfRAEvwYAa0j6ldqhy/KM7RJbjDV/N6FjqtOKDEBYBwCkoMLgwYIXcarN80P0mRCIMhsQ+eL5cpYcbEjQrbR0oQY8zQAb1HQWCEAeIH2cWkeY3Ekf1hh55TwsmfMDcyC26OXAAbbYyOsQrzqug96e2xbLclqun6dNEbP8VDKH/I7WG2jbOyVy+kUkRallOXV24zfuMKPiddy7olI0MHRzydbhzzsKdvweoOQs7cRJyUnd+OBbL6VOXGQyZKXe5/PJY4rFqiGDWiQMDCXjX5dAxAIpZVB1wYlQERAJRLF55ZKVo53J8s0N3THqnUk4eNc00Tz2DQPS8qdg6/DnI6F4a/+l1dOcoKeW/3yGd497SrjF3KaTNQBUHmod48fo6x237h/rUqLPvesTo2KKwXqip8bMZ4NmmfO0+iM0wQUMdk37MF6/5ujAW9rtJ00OxiN2/+7UCMbA0alt9rNhAEaEYfiTr9oOraltAFyZQ5u16ZmRhSkATuABIt0JXWTxl83M/hzXWlVo4MuoMw1fAU2yML/Ip7uL2I0FdykOuG3TgAly7Pga/Ph/AQBW3/5twV+BSPhda+E6PnwWq2ORruvMi4EvyiWT4u/pVYW+Lnr4tDVW++tXF0oLMX/P/329fOfn+neTzs/Bmum7BJcmtKKVxygM74gPqZZfBk45XvvM+MVep9OwsjzKkGGyUl1kTRx2PSonTHPw863Dnxc6XZDWGW8NXSQyqWHpJ8YRecEVssqRa6+cPLSfYvWcVUifH8mxbppd6RQiG5YVGF3hFy9yEgzdjcjzoZ8dW/e1Spt2PQFi6xFB336O8Lsf0MUw176HfIb4OQNmvKTFYUtMcqVW2z76iNuMoiAUXSjX0rBJo0Y48FRzZMavnEAwHvk1CsZvAlgchuHCk+7As1V24pwAxK9N6+nqpTi75XznCl3k8otBnM01dU1zbWmBdDRZyfCDd4QWJcMusTS84lwnj19J/dgYQfYOmRJ8L9+QiFXXdZBrUf5+AzL7Jzoi7do2aPP8ELmLhkjRRW/7tkscOsMBIFmxbjfX0ossHq2Z+KFwfJMG50lhEjDL+T0z1zoTADNqOX/rVgFAOggd/Nu+kLqyzowaMIFwz8y1gu9SaY7bvgVQdUGRYPSpE43SW/VD/47gjOwYrrdWekN6Jh4e9zYAqyeilOAIAWmmR1i1V/zlAJPJVU3Jd8T6/QBPZggQZbGrt5oMGYgPO2gnD5/u6fg32muj7Y4Ad7UDqJWEcpFhqzfPq3buwgiCsNspQ3NjjCA4EvJGGI1itfKQ7k1EmhosKhI+0zUfv5MxrNrbLB54i08gGI86TjA+CpTbAcBiAD0B7IAx4Kg45n5OsuljOoBcAFeFYRierDaF78QBQF4oBpxlL7XGyLk5Dolet4b6XnPx3BG4FKIGgWTZ6kEkZQmIqux8qBLyRpgW68pyJP3Q0HrqXnrIEWch5kkWg+hEqMxZ48EUHdKtoFVT8nH99nZY8tsrAUQmkpUlRkiobUZdzEu5tzQSx+G2dn/WkAAQBUq5BsqlAYiogXqbBTsuR3eWpaHv1HQsfdwsV3+YWYYuY3vI5+nZdUjqlCKC/20z6mJYIsyotEA9j4/3j/gmEBl5ausnXmcg1uaKfGn+O2BaqGtW3yeT17r5ScjpUi5UwU2zKx3lN2r8auds0gIfuspkqXf/qhuQ1VsCdtY1KeI3B8TPYoO0zuLlBxgfxM8GzcKOQ+0AAIMWXRxjX+TTJEXjAhC2i+DDql6hG0HEWQdRYKRvHiENaZeeebGo3AERNdJJUkjBO0ogjScz6rugkAnlvLfquAE0C0zxu2+OaXIw/snfFx4vGMeDch8F8IWypssIw/AXx9zPVw3GQRBcB+AmABeHYXjQ/luTYQrtDp1/Xq++1337m6IRoSvc9MXSWhVF03eI07BeAvJzre0q7gSaRG8DHh8OLvd1wNFZhBSf7O+QtqV1Dti4oHVmfQyUEwWPwcmuLcdVG0uSsjT0TZNl/WnuJahfXego2uluJUIB+nN/FVA9Z5UJ2DZz0jKeABwZUABRtmnPXZbh6t/8Bpd5k7cYipn6PDt/gOO/tmV9pqOpwevMQe63rsR3e/EWmexoGsBj97PBV+7dg6vfvNrhrhKWyH02V+5Z6uAZUdeeLb4Jo+CMbJdJYtkbzM4b172BTbMrHYcRv7gmTiKKNZOWP8U5L60QWL94KQqXZ2DQootlec/6AvHc7n1qJOMGolqLpuRpWU7CAb4juuNqYrVCtHyoTgzeGroIeVdWyMTPycGH73xPQb2KBeDoHQtjI84x+EVrDTs2RwfewhMIxmOOE4yB2Bh5NNPmY+7jKxqSDgGQD+B/hGG4T33vK7VDMzNmkYd8RABSBWaBhM6xusCnAykAh7fJIo/+HICz7OODFQNDzIiobbohgbg1q/GAaivW/mpKl9WXOdQYIgCnKKalPLVt1I8mvYVV13WQbT9Q+hgcq+x+owIAl0I2NFp5aLEfIFJt0+LyLJ75rcvac01TBznBaF62NiylP51IlyKiUenJTi+TgVhpRirl8Tw1dY3MjLCiUjL44dcdRkJuX+naq7rz+0jI7Suwxcj7uwq1DzCFNGwvFlnU3EVDRPFOGwAQB+ZxkD/PIU0x9vtlBaUC6dBk4I2KLsKprp270OnErC4oQnLHyEVEahGeGBSfk3gUPN3ABCA2ubDPoQTKyvIIH4epzbCjzmmGUiJTvG98Hkmd8/nPWmiocd0bTuOSL9OJL8qbJRi/fFrTg/G1u75SMK4MwzDd/ncAoILbR93HV2yHvhtAawA2ZGJDGIY/s9//yu3QvusEABQuz8APBuyW7SP74Zhhbv99reOoAcApUCV0TEXj/hqUv98gLyr3wYr2oGfPddtJbdGQusG9lt2AxNNzRMQ+IW8EGj8qdCUHlWOBHr7gty/e7ZhOWraEdsL2aVFX/3Q5nswwOhNdnxhl2BJPRJ1pvicZtzV8ws8BiAocg4kvNh93W3XaARDxer8Aq1cXuoHFd4Bg5scXEYjlgrOtVnOoAa/o63f52dUKYCZfFpDIzFk3P8npykt77M/Y+t2z0PnSdADACwWtceNv8xwMXrNAtv++VoxP/a68X/8uGQDwi58cQeP+GuxYbaCl7F9+B43bSx0XmcZ1b8izVnmoNXIXDcGe2xaLWl/2L7+DNdN3YeCEejlX3cgDuNRBnUkCkUmBztB97Qm/+MbfEDlRSz9k7YGONJRkBRDpUijusg60/I5+/nQGLFKrynuPdEct/dkcmPFLJxCMx/39dzfBruLtmBeG4Tz9nWMFY7tdEYZhxrF+55Ro+tDaFGUFpThQnSK0HOKjXDqzMESOcLsBnRzKk7Y9AiBLTMAlxWN7sZNtA4jRB2CGQd1WxyBSsTEAiAyidgWmJCMAZ2kKIMZFmJVuh3Zmm1E07hluK3HYFhqWYOanA4NP3BctYbVc1RQy/mYMm0VtMxvUUpOFyzOEZeBLUTKIaj+4vy5v5wjFkzoYz9rH3LtK6MGgzXM/sh+OSSqbCbh0Z4ClSwsQNVwQttgzcy16/e0TkeLUztKAgRy2lGU6prO8zpwU9q6oRHp2neC7ZEYwuPBZdQL6L78j57dpdiW6d6lC11vPxZrpRvCwZ5sDOOPnXZwAm9y7U0xNw5nYbYETMJh9vPZ9+hkCEEiDzzwL4zzHnZsNtMUOSa7YHBcexR4CED3jyrDAt/8CXPMBamZwEErR4vzNgRm/eCLB+Ktlxv8YmOIfPSqGG57xzs2pyLomBY37a5zCjLYdZ1ase/+dApTtPtJDd/YBEUbJJRjNH/lwaP0HIP5SSVeagah44SzBPPocfcjkuFR3EgCxgeffEHPW3NDOl6ZLVn3JZXPwp7mXyMN7aFa+s4zndrzlp98041vc62PU/F0es1+o0VktuaG6U80Xw6lfvDTKFhdc4TSl8HppnWVxDrb3LN5kd2hWvqOdoOGBkgc/lXPzJ2oNWwQZaSJYX7P4FoTbSiQoU0+Zk+Fbb04WDiyPW+O6AJzMEogwe2qYcLLQMEV1QRH+UhyZCsz7aSGuPX+n42auB2l/utWZGDngFbU9NTmtuEZRIyC2yQMwGtEslOqJgQlT50vTHdcYv2Dn0AwBUXyTrkMKeHn6Flo8q3F/DVL/Y9VJB+P53ZsejCfs/ErB+DEA+1UBr0MYhncdax9JTT2gltEyWkbL+H9l1DfjvjSUGwTBThgo9xEAS4IgmACgFMDVx93PV2yHfgDAFTCmpHsBXBeG4d8tUD0HwFAAB+2/bz7eQWhqm+NSDGDefXuM0aTNquhgy2VdzYoSU4TyWph1QYpLd60Ex4IRYCAQKX4Bwr7QbbNafMhZtit8zNGptXQwZjHJd84Uoj/gZpgAnOKextkcW/v0TFlaAyZT0x17CefkRS7LdrDo5UsuyucLV0l3lVxfpbEhmLFnI6SbK6h9oTFLnVU1lOzEjtWtJBMlfslsmA7A2vtM2zgBkWKa0+Gorhmr8NowkwwWwBRIiU3zWhRNLDIQhd3HvPv2oM+RWoEtUkc95XTszftpoSmq2eX+jfdvx7wnLohRoNPPVnp2HVKG5grkcPHUb7gayrarjcp85yVXCfOEBc6+U9PdIt/gPKyZ+KFgyNQv0cVXnT3rzFO7s3DVxHvE+gr/Rms/k/Gh2+Ip7KR1oHWzjy9ORFEqbS4aM7wiJLn02paqOQp4//GtpmfGP/u/x8+Mm2N81Xbo9mEYVtv/vhXAWWEY/iwIgqEAboEJxv8GYE4Yhv92vINg0weXZ+moQ3obU6TKXnAFXhlTKFZC5ELuLTUPGK2INOcy/OAdqXh/78oDwlLQouK6YsslF5db5Jm2uu4eAMAXI8Y7dkiETXTTB7FZ3UVEWUggKkSwq+/IYzMdCo+wB/SE5Fncs+vP8Zo7Ixs/mvQWAOBP958HZPXGmtEGK6Q/nhZ298X4iSHr6jWpaAAirWEPYtDwiW+N4y9PNaeZg7ZI/FwLzMu5WZYG4LJfgKizzenYi+Pf5tPlCFdwlIx/PUZXQlPbdMcesnrHNHjM+2khbpzR1bGtSuqU4nSyaaF3eh9y+JDCoVn52Lk5NQYjTpk0Ru7rBb13Iy1/CpZcZiyQRs7NcVzDCRMRumMBW1MBacml+cJaFJ8azLrApxs2CCdQ+hWIZAjE7blwqYgtAVGXH+s9LNpq6Il+lkeD94K+/ZqlgPfMCQTjm0+VYAwctwPvbgCnh2E4MQiC52CA6kX2MwGxj7V/PzM+WFwrDskMjJLFWp0FbncZ20MESADIi+a0glJHQZtCjhoRZb6KMgRE0pN+wU+ybc2VVA+ST4AHIEFP05+cYR9+p9NNGTpqdwTdTgwoKpH9jR/d+wH+tHC0ZD/ixqAKN46iHSKc2g/40qTwxCinmKmF1UVK8olR0jUGACMX5qF+8VJp8uDkx202EEiBzHrs6YAezzHY72LUqx1W/+m4cfCuaQ5dUXe9saOO5prEkEmb9Klr7NijYD0/p+7zw7d/HAVoJW0JRG3Lwt1Oz8S8nxaKBjA79lhgJG3ztTczRQGN14bPz5rRax3OL9XX/GzSV83TtReyIzhY9ONgkJVn1suCY7SqAafWALg1GSBOgdk+u/4q1ikE2ndB2BSln6DNsGknHRznnkAwnnSqB+MgCGYBuBZAFYCLwjDcFwTBCgCPhGH4nv3OWgC/oC3T0YbmGbPpgw+aiLHoGXnSGCdj0hmX1n8Aom4+rXfB7FkHXxouApCgSA7wwYpWEvQBb+luj8t33WWBicMv1vl8T9J3dEAH3CACwAly3V68RQRf+Jsjr5yHV5ZHLJznrlyCn709SehcLIpJM4RtqmH2AsDhbZO+pa83l7B8ifwuSQYDrkTYgae7KnUnnE9143FpNxDfAkh3Mup9+I0Q2nSgZMp6R/zfV8krGr0K3btUSbZI/WTeWwrW+/cm3LQh0vR9/Gw0Fm1yZE4BRE4qs3qicXupQxEDouKWZoW89qYJRCPv74qSBz91tJuXXLYkWi16jtS0cdKaJlxZMGDyevn3wJcZ4HEx22c2zt92OMFxBKL84cNXFLEHTAGf3aKyErPBWjM2mgOmeOoEgvEtp3owVp/dDSAlDMMZJxKMdQfeUz8b1nfCjy5A/epCCTTEx6Qyr7JK35GArZ2ACYZOG6zi6B7NxoYcY80BDqv2IunsgQBMq3O8hg0fR/blLp2gR9xLdUXpBxGA0zoNRAFFU6jiOZIIjjerJ4LzLsTIKw0FcsmM3ggrKkWEiMek2RV0bfYdH7SPGZXfABeLpx1R/YLf4EjxPslK2dbNzw/eNc1x1w4rKrFpdqVQ25j1aose399PsEiFEetB3z2dKetMkKudtbO/FJYCdSFIXaP7ChkDQd9+eHjc2+LgTcF6BmStj0GYwXcgqZqS72icyOSpGiG+d+UBZwWwbn4SBj17rqOQpoWB0rPr0Gb6FLw11GTsl6wcHesDabUlgChBEbswQLRUNL8ciPjvPme4ZMp69BxcJ8dJV3LtMC2dh7oJaXCeUOxIh4vXxQlA5EzZWQpAWDjabqs5gvGc05sejCd//vUJxqcDWBmGYc5XhSlIbUvqFHWh6YJIjAat9lODq/Eryy2lXSFttfbfpAB3FMESUqT4MIvmhBK019KWAERDWRcntGaGv8wWPq/qcCqaWORYIPnUNvqlcZ8PXbUYd/+qm4M3amrbxqEvCx0rprNK6YA4imoqe+Jx+t11zjVEpKvBF6jto48Ysf2xbmOGo7BnO7qA+NQ2caKYFAWLeKLtfpMCv187d6FTmJw3eYtkuaSfnfHzLkgYeDk2Dn0ZACS4XHLZHAAGg2cLNQCZPNr1mwgAqFl9n/DAfesgv2Vdi1Lp1m02gHTuUSPXl/S7M9dMBwB8NmhWjFEBEKnkNRZtcizvfRyabiXxjFJ5D85cMx2NhUtlNcOCKu875V7bZpjGKa6EKFHLQQ1tIPadoNdi7iJbbLdcf83zL5pYZIwC7LOy58kPnaakkvGv4+z/evOkg+NvTiAY33EqB+MgCHqFYbjV/vctMG3RI4Ig+J8AJiEq4D0ZhuEFx9u/7sBjpsZASTxNCwG1G9DJYVdonVafa4qs3o5lEhC50GrRE7+oFX7wjvNgAnBghoRz8kwGqKAL2vIAEZdZa7vuuW2xUxEHoqqx/ltZogGuYL3N3rV2xZqJH0qmx+PQhSwqZXFi8fWKD79fIq7T3D6Wj9mR4n2iW+t3eTEw7l1RKTgxB2U3AeveYJX0+H3KfYp7tmowAAzOTL4yhyO16nXc+V2CrftnmyCYP0CCFuUztT4xdR8A4IZhL2HeS0Ol6Coi8nZSTx08Q2ydWFzLu7LCyQbZcMHPL576DQR9+0VF1mfPBb4oxyv37gEADO61U+AD3SFau3CVo/Gr9YxlIlLPvWZU6FWOfG6fVz7TWnEQiHTBHRkCpRuuxelZFOTzoC2+HFfryvJjsnKo/6IFifi+aAeU5sCMZ59AMJ56qgTjo7RDDwXwHRhqWymAn4VhuMtS2+YCGAJDbRt3PLwYcNkUPjWIAtVa4rFkynq0a28yD+KmnLGJG/LFp0UNKsudAKSl/3aPe8oRx6HmLHVXKQxEuGDL+kzkzuqJpCtuxoGbxgOImk+0t5x2BdaC+RyaSgREkIx2NXHcQjz3YmoUiAi5EuPhtSL0o6vmm+eHsjRnZqYNXnVGyeo3mxbqVxcKTY3ZdtHEIhPUlOlp24w652909k3bJY1TE1bQqnF+Nb/N9CmOUBALgYCSRVVt0nolkjjsejQWLo1hUxSNXiXXAlm9RQcCMKuweZO34MY5NpjZwiYnrqBvPxEaYoAnlsvkgLgyVzv06eOzt3X488j+5XccSIe4MQPfe+u74ZKVo2O8+7SiGgW0ADj3FnDrKrrrjdgyACerBqIORk0NjJFrfTYX4baSCFYba59PUjEV7ABAjAx0TSQerBevXZ8BP6yoahYPvEd7ND0Y31V6igTjf8bw3aF1sYcPkt+ey66pwb12ov2MMRGbwroF+LoH2sOOS2xmi62uuwf1H6+LEcnWalLaYVpTu2S/lm3hdPdVlse10DHnmhbT7qur3kCkR0yIxu8+9KvTVELj53p7y3pz7LnP5jrKb8w0fWshbbpZv3FLxISwOJ/WKybv9Wj6xmf8vMtx9YzjtdZS6Ahw28UBxOgisE7A8xHurQ02JVPWSyFY6xPrLj76+In0pA3sDz9gULZpk9q4nyvBerZQB2dky1IbgOgj66W78JXteGVMIQb3MhMVi3fl7zfgm68+YM7lsZniBQfE6hn7+iMsejPgk7+tISgaLDhGBUqZkJOc35WqGRJcUfn0QR/e0xZeur2f19jvjGVhj9fLEcU/I7tZMuNHTiAYT/tXDMZCJVNeaI7gNeDQgABb7c8fIA/P0sdrRSQcUF5qY4Y4NBm/wYC+bgBiNCF8qcCgbz+jQ1H6yVH1jP2AD7i9+4RXtCswfeUYQOLhi5rpwGW6xga3PV0mmR+xx+wFV0jxh9rDpHP1HGxWFLpwSgU0ADhQnSJcbm7TOZurF2YuR9M3HtxrJ9r2Prqe8banyyTT1pk9ACfLcq6lt9qhdgh1gZk9ansp8qeZBRJz10wdjcn7xTefI0zXj8Z1b0gLdfVD/46wogrr5pvm1pwu5eh8aXrEprBi//z84qnfcLLcthl1SJ//CI48NtNpF/edsHePe8opcpPPLENTMVmUVXxn1hF4LbgiIweY19Bvm9fvaHVBkTCNgGjFqV1sfKdsfU98fZGdm1OFuaPfTV2zSL00u1mcPh4+gWB896kSjON14KnP7gAwG0CnMAzLv2oHHt2h6byrqUHawYCjrKBUYAk+MNo4cdPsSkcrV9NvzL+lO/sTDVVP2UzrsGpMl1lG0tkDUf+uofr4ehUx7ruAg4WxsqxdhX0pUBZcnOBrl3pANBE5LA/fWNXikeLaa/mistS23WC6MONLPpY8+KkzIdAgVkuQajpi7dyF8mIBcAIJACfr5j4b99cgaXBebOeVHZyIGDykKOWZnGq8nfrQvJbMODVXNt610Gppvixk0cQiMRsFYPjAc3PkPra/54+ouvP7Mnk//2StgTnsPSp58FNHvCqeHjK79piBz9jUBY9MSnWfnaweMRm6T5dkEVxDDAKb+c+nFcfiiqbn4DokjRohkzgApw5A3F/L3XJC1pxpDYUAiFFy00kRkwANGdKSS2t2N0cwfqBH050+flV6itguxevAs//+LQAvAOgNoK8Nxl+pA4/B+EjxPsfFgkMXFsiZJAfzvOQqZF2TIktztoXyQWU3k2+cSO4xEHEldZZav+A3kl37QkK60KYVpnw1NEpiAhENTjMlJOsDZMkYz8eNRRbRpY1j1QQghikBRKR8Ls3vfvGiGEaB3zRDyhdg8UfdBmu3daGQnYZ6mzAC4BZ0AAhdToKeEifS19gRCrLXUlprNbtFXUMyDRI6pjqYM4MeAxoAsYBn2zEhHWLw/nNDpTQGBhZC9eQPGCnOivFny3FQqhNwVyt6m5h96/7ZeGTuIfy85y5HXOgvxd0EBqIcrKbx+Tx2XSgrmr4DOQPKnSIrefI6i9XNQBTV19g3AzQAuX+EoIDIHFizPZwOPav/7f9mPI1lzQrSrI72M8Y0Swfe/ScQjO89VYIxcNSmj6UAHgDwOoBcG4y/ErVNB2MGWy6XKLrO6jQfAM7QC1ZmOpqzrOTrG8vgq4tDmhQfEywsgV5nHhouSTp7IOo/XgdUljv+XZpdEc9dRPOMJfiqDj4ATnsol5qaHeFQgSw+F0+KUG/r3503eQtuuDVFfoO28tr/T2tZiMOG70wB10CS1xqI1TcGXH87Fjq5NN9ZliYUPF/PWC+9tbh8kNbZTJh6AlDyi8KqUV2XzIq5cqAsJI/78U2n4Rc/OSITOzUzdEOGboTQmhoadmgo2YmMBR8DALZ+9yykZ9fhvfWGq0wHj8dWmQyDXYAa4sldNARFo1c5bja+nrEO4MJ+8dgSHLR90m7Q/mRH9TlONCyyameaouk7ZNJJHD4WVVPyHXW5kvGviwA/nw+tbCjJironflKUNGqEU2th1q9XTM2h2jbzBILxzFM5GAdBcAWAgWEYTg6CYAeiYHxSHXjbni5D1jUpQtUB4AigAO4LD5gs4UB1imMjpB8qUrB0RukXKeQh4LDLN01Oj8F+lRC2/LvaTjg9RxpQgKgDT5yUbbsqg6IWffe1HbS+hea9ntm7PLKjAkSyUwfhIK2zgyeGmzaYpfOMrma7ohJrZ38pAv7SrWUzfIEQ1DbxQs2pPpa+MTnDWs9Ytz5TT9nHEzXGyetyNP80bdGk763cG8WX1rzXvSsqHbjk179Lxs97GlEfPke6iKgD1OH3SwSO4XL+jYouuH7sYYFiev3tE9Ssvs/B7HNn9RTa3q0VraU5B4jcorW7zbqGNNxwa4pDHQsrqqKiq13NOMI7ytgWiMwNjipChf+/vW8Pj6o61393CBA4CYRyVyoUwaaWegGkKL2kSgvl4BXU4gEvoPSgiBWtomhFK0qtxeKNUxTUQqUoKio/BAXMsY16NIAoVZBIgwWBgCUhCAFC1u+Ptd5vf2vNBCYh1VRnPU8emJk9M3vv2ftb3/q+9wKvcRv2Adqc2ghV2ytl5cp69XMvtpHmo5yvwCWchKz9v53k4ebZPOXKl5jsZAJGzIwBoH1BwREHx191ST0Y31HSQINxFEXNAbwK4CfGmPL6CMbMjCkkknlKD1nKsPnGIEb3Z2Y3awrboPfcgZ4BJBBrKFDfQY+QQs06LDPnjBPysf+3kzwfs3aDc+NGotNhBXwMJ91yAQhesiZEhrctfKEhTfVlsxCI62s1+ZQxaItQi3Ij0QiB6OQfiIHmhLHNPIEeir9oUXa99CQV2hOACTSk+Zg3drvBubLq4e9cOWdxDMlzmGJ9jtnE0Yp1IdGk+uM1koUxGGsfQ5JRAHgTshCKlMg84BhkoWaJK6nwOBoNGZGgy6tr4hm9e2HpmNUyuWWNHY6cAbfFrL3yUjw9vCCu4TuyD+vQhDuWLGkspYzKB+fgr4UdrfATrL/fuWfukHOzdMxq/HjRMI/iTsdzILZy0ma2VCrkfSClOne90vyWrMr9v52Equ2VsjLZO3mqhUCqRIWkm5ARKhA8xzwMLdM4aXBFNeP2rR7aRKv11RfO+JYuF6UcjO8sefJzCcYZdXjPsQC+AWC1C8SdAKyMoqgDgM0Avq627eSeSxhRFI2OoqgoiqKiWas21GE30iM90iM96jZMLf4+r1EfdOgSxJlxnRh4umYcWgV5DsqIa8Danr7FCJ/AoaFvxHkCiN2DXU1Yd5s1Qw+I5Rb5Pg+87vYtZA9pi5nKRUVofo+FKAGxchyziEbnXu5Rhr16shqeN1/4nS6rYLbCMohgNN2yXWtoiOasy4BmXFKAkYN2eMJM3Z+5wsOsHrd0oli6V82bL8ciUp/BY2bPmvW3Z21ljR54tGDScK3QzTgjf6hdrYSZsqJH61WEUMBJi0cs+8ih699AXI/nCokZp9Y/PmXRxfKYrwNIaHiSYdej/Q50fOxqj0IN+MpxmlwBxFhjbdhauahIVhaNhozAXefNw7W9XDklr60IOslxKvzu/rXbBdrJFU7JksZevZzNyZq8JIl04WrnqGd/jYPPPYptszcKoSjUs9g6aRnaj+gsZYoP+0/2hJrEgUQhSagSOOMaey0xQ9YCR/VRprixy7CU4+xvSuY2jDJFMgaeMWamer0EcTCuEwOPNeMV95ZJ04J1pKxBvS0060E3D7ibXgtmPz28wDr5AgkiKcT2Rp2P9/RfAXiwstKFZR4kR1/8hMdxsDkVauxqlbDMkdeJVx5f81THwoaegvx4deZVryU0yrRaWs7gbp4UpV4G0ik6hDR5JZKueWLrw/O9dOJmS9N1QwTn3QgJAaGGRqhvHOoZR8d2k8Zg+H6iPKRz785Pxgn5XlmCv6knxKTOTUb/AUKO4LmIWrbzsMPiAq4mew3zyxlskQ2i7BZA4QAHXXsiXx4Xj3xeECqAY/jNjc9dzoDbrD6ya2KRAah/e5q38nflb6tLcVRuA+z1XF20Iq4hO9NT9lo081PXv0sXlnlEkha3DZfzW71ho1eeCrW/gZiwoZuXmoVavfwFL1ibVa9h6cTNnhCTJxFw4dCE80Ut8/q2XbqhFsH4noYSjD+Psfe5KQZAApkBiC8KzeKJWraTOhQxmTf++h8AgN/cd3LsuoEgkKh6bbOJsVwg65QeO0mhKdhEDDNBz8ocsXIb4EtpAjbgNPnlJFQX2ItbsM3KrJGfqRseuokVig+FgjDUK9CEF9blpMZdQxZLltlN933Ho9b2uj43wXOQzTCtZ3wofeMhl+7zYItk8YkS1/TesU+e23fWLLXqHpuRgHVOMeWlfvYf1Ix1/Z0km0bnXo4P+08GEDe+WAMm4YMTAllsfzjHBr3LR+zzV1oOOUA3GiBGOpBMk3lKjwScd86YuZIhUyOFzuXMTKmjwX1/a21HmSCLxxeiU8+KBA0WXr+E8cl5c3Xy7H5tPb0KTa1n8NaNar0PrEFze7IytTlwk9b2HGqOgCf6pdiFvA4oNgQAndqXS6NQCyvte6PYQ3nUBx36+loE43u/SsGYqm36ZpShVdcAafAxs9CqUIAtU7Qf0TlBQF3jhIn39YR5HOgdgPxfw2u0W0bGCfleIADiUgAbWaQ7sxkU6vWSNaUFUDgBSKNL2eQAEHyvBsmHTgls6nF4WgGwN7IO2GHQEyF0N3ExY+KNLmy5JOzCULJRi5vrJXCopTv/vkpc8OIFCXhSZpkA5FzqrMujzTpkhW5mapU3bFgrWRmf23X7HM9iio04TnZbLntAsjo+1mWNpRM32zJGeWmCEBDLEJe1LEWH31/o4bwBmyEDlrHHDBGwKAbqCgtrz01WPH9cQVDpjTR5uXfcakgCr5uAk7mRc3BCYNAj+kUTTTTKiU7lmiEaShkAvuhVddGKBOsnonc4OEloQ+LQ/PQbq1854uA4vsvPUg58U0v+/NUJxhQKko66YqI1GjIiwVJcd4EB56lG1k4oRu30HzzLcAf5EpSCxge77wCUALwCpgPJoW0amgYkwrAomK3F0DUdWstnMlNLpmeRcfpZEtR3vHHQYysR2iZL9yRL8+rlL+CR+ytxxbiYEbfvjWJhUTF70qpywvRzj6mfoe11tN0OtRSorVA163cJCmvaC42TkiZpVCwsRu7MKSKKr6VI9WPWWltOHZ9ANGH5CYiV9ygrysHJG4iDHEWoQm9EkmFEd8IJ1mvSSpiVXnj/Vjw17Xvyu4evt7j5JWw+rbt3LujqwYl9+cxMDy3Bko7Uqaf3jtUOkejmIsegcPGA74JOurhmB26bvdEryYTu0GsK2+C4vB3iyrNmWxuhdwMQbWg+DlXytv5inkeN54TQbKKPQdfUegC4ePOR05OvrUUwvu9zCsaZh9ugBkPSSQCuAEDw383GmEXutZsAjAJwEMA4Y8yShA8NBm+gDr8fHtcIXb1LvLkUhCnzwjae80THx672CA+Z+e2k4eRl1srU0HxtB0yuDaSNL70ZBz+O62rGSf3pTDrj9OPj5lDBfLs/J8cY2IzWOR4L7WDxJkTHxjjYjK6dbbBsZR8ns04nyYGQr06Tp6L5PVNik0jAqzu3G5zrmZ4yoInOBOwEsWdnY+xxF3fHx67GyOKHse8Ne3E3PbUbMttmoUlenKFXLynwbJbKZi6OyxxOK2DDk5Xo1nW+7It+nHlKD+xesk5gZdWfVuCdmQYnnRNrETRpHQfSJq2B/WsrkY3ZXpZ08LlHY1Ekl/mK6amj87Lea8pLUb1hY4LE5qZt7p5zou49+u2QINan8Hp0GHdi7I2IFzzpzuqiFRYW5rLWjo9djZPO2Y0NTzrNiK470O2Wb+Lp4QW44EWrUdILL8jqAbAC/2z8AUDvVq959kWbTyvG0a+vxyphRHZC6ZJtaKKajX0KF3uTxop7y9ALL8ikYD8/DrL73ihGU8Q9hkbdOkkmrOv9TfLaxpnusd2Q3aIyDuK5bZD7RrGXpHyv3xxEvewKKqtVLjoVr0bO4G5o4d7zwjVr0L9VriQo4sHo7k2ZhNw1v2lbS/QaEQfn9m7fD8x4WPo3zQu3Izq2N4ZeG3MC6mNU18un1O+oqyHpJAC7jTH3BtseD2AugD4AjgKwFMBxxpiDh/qOiv8eaICYPqmF4HX3HohryAzO0oDRLs1Q7DBNt1T4Xa1n4fH1AeH584dv8stJ9rtVwBaQvSKQaN0IwG/8MTPR+0LfOyBGfXS75Zvymcnoz+HQ2TExxfr9rCsywHDloQV5Mlrn1EgnD99PFbc9ayvx4Vr7PT1HRdhduF0ypHaDc7G7cLuYxgJA2d6mYjJbtrcpeo6KpOGU3aJSaqZ6bFqZI7VXz9oHSOqRlswBm8f5zoJsceBIZnEEQKRB+Zs992IbKZ8AEGsuTiJL1nfCha+NRdmoCXLs1GvQ5rZEkwAxg4+vd3zsaqwf8ghO3mwlXNZ/63i0H9HZqyM3yWuL5TMz0SfP1vWz+9nHZOTtLtyOJq0hmGDuD4M3j0evJlnW0K45JUsaxyL3bpILzXFDtxy9ctB9nWQj45geNpFRq1zW8vmZFGvSKm2hnkVWz7OOOFMd2+XClDPjB0vmNZwyRRIG3iQkD8Y3AYAx5m73eAmAScaYNw71+awZC33V/UiAhZ1peyIyfPh6k9YxcweIFda043O7wbmeAwG79+zQ7i7c7tk6sT7sgdEVaoL6ynqSoASmXk5LiQWJYkRsIoZ6veXjp3oWSR6awqmaaWNPT1iIvnz8PdyKQJNPxDFDTUxamJzOHwn6F0pFr3RhmaeNoAM5YDPhqu2V8rh0YRl278qS5f9j5e3wy4GfSnBgwyvUdw491DyjSsBzfIlO/oGtmXPCLNshGiM8N0+PXeMp+okUpWtKhXrAxXeu8xplbILp9zdpbYMPewMMghoJwckKgAfvA+z13ahbJ6nNdv/gfWw/szv2fwppgJ7ZdxM2rczB8oM2QF18yiYpKwG2UaZryhSvz8UBOZ6iiSXIbbZPyk1hH4XXYY1iRK4H4Jn0ur6K7jdoKQIACU1uygQAMWNVN87NR8W+zgZZpaohXh/B+MouF6QcjB8uearBB+NLAewCUATgOmPMziiKHgTwpjFmjttuJoCXjDHzk30uh8YZA/CaAMwuhenmmG2aXRTWyAB4uhPUxuWgQEkoqK3ZdBrDKqgEBRWSxlsolqPEunWtmw3DkB2XIFakPO1OOme3xwhr0trXfyWTUGc+mmHGUkgy5IPnAqFMJENNCa2vDMQsyR1vHJTMi7VZ/Vg37LTKHmAzu0dnN/XgdKSxM4BTwU+G017wtBUCa3m9KmDGxnIWPfomn/GA0J1zZ07By/2moUf7HXJuWMcEbJCj9xtgs8Olw5ZJ3ZT44OZ5WbJ62nPDBNy34mhp1IWKdrtun+M505SPn4rSjTlS1tj3RjHavrge28/sLudi+cxM5J+zUyQ1S/Zm4/RRVR7DMRkMTeti97o+VyYAwGa+DLRATJfWvobaqTy0vRK8erAa1PK3ZExqYSAAXrDG19og44R8+x0fr5GALiVCpzciUqi9+taLUNCYWgTj6Q08GLcHsAOWoPJrAB2NMSPrGoxDPWO9xD32qvYwO8v94OGslIA4AGmBat3Zp6KWbgqGGSQbfjqge5A41xRkRsSmWIsRveXiNeWlXtkCQEJTpdG5lydkbntumAAAIs6jnRDocqA1HDr1rJBaomgiK9C8drHmja9F7AmN80gGLrMCErVAvEyU58vJGmrpxH1vFIsYDjvgfH3PzsZYs62NLLOJIef2ffK2oMWI3qIuBtgAXTSxxGu2aY8/CgXxumjyy0kCBeT51e7SGhnz9PACAFbxr9usszHjEvv4rFbb0GHciVg60Qbr/HN2olG3TtI8IgWZMpPEE3tY2VN6YNfsIinh9J7cBcV3rvPKLdRgASCwTa1W2KQ1JCADtpzy4do2gsHnvcGSQvO8LI+qfGDGw5bUoWBp22ZvlBITAM8VBUCC1KWU05TwFZuVADwzBU3QkuvNvUcP7/4DJMhqc1xS/hm4CfPkfVNfmfHPu5yfcjD+Q8mRQ+lSGfXBwJPXalOm0O7Q075/fK/Ljv+6YGa1gEmIPxVWViD2kxCAlBMxkQvatBSA4Em7XpTlZVVc/uo6qZd9u6VTCCuLWrYTqyYOXSPW+hfEQmv5QGbXHNRBCG1rtCtH1ZICDx6na3DUnNDC+lrfgedHCweRaXioMgX1jPm9G56slDJDsse7C7fjw7Vt0Km9m2x3ZVlSh1uJLJ24WeQhmf3p9wOWREPxfSD2S9O28I3OvVyahtqhArCTHScz1lZf7jfNetYp9mHJ3mxRISsattiK9rhl+NPDCzDk0n2yunm53zR8r98WNL9nimCXOVmyjFa60QoJcbUDWPQDMdZMFDhZvPhmJ8Flt31xPQBI2ULX5HkN8DqglCc/v7pohUDjqJesiSAhaYnuNRwsw/E4eE/JPeEakFpDWl97AHy4HZCg7w3A65vohIiBW0qIhHh2zauXzPiKWgTjRxpyMI6iqCNlMaMouhbAd40xP4ui6NsAnkTcwFsGoPvhGnjMjJOKuThxeZ21agQBRVBEIPzYbtg1bbHngUcRcl17BeAtwTK6dkbm2RaaVnnLld4SV6BeyibeazYizoLZaGh0TI9YeB6OQVYwP4E4opfVLFOEspuhNQ4/o2BBK4trVRNPsnqdRwPObSPGm0BcImC2RTSBhjRxMuO5qy5aYTV6nXANWVj68U1/ysBvbrUyJazFMuvNbJuFggWtREwns611mAjLFNn9YtcNnmdZ0hbMT7B5B+A1hzT9nIFh1+1zPIEj1n15LorvXCe1WSqliX7xKT1QuajI8xyk3RSD2o2XvYKJXbZJ3X/G7Vtx8SmbJAstmljiqe0tHbMaffK2yD7tX7sdfy3siD55W2S/mCVzpVG6McfzLMxsmyWYc/5e9KMDYuqz2VnmeUlq8g/7Gbqhl3nhUGnKJTOhpauHdsKuWFgsx8ZyomDBHWlJSnUfr0kQmCK2nBmx1PyJotlZVi/i8iO7DE05GM8qmd8wgnENhqT5AE6CLVOUAPi5Cs4TAYwEUAXgF8aYlw63E8QZk4Wma7KcGaVT61THWOelupV+Xeu6MpOuXFQkGQ6f051i3Y1PYHOp2hmAhG35nLdMBvxlWtCI0DRoIK45ez5vAZFBU2UBxNmOYhBqOVD9WPvoaZU2wN5EugaPrnnCMqNFvH5MhIBmUoU+eRq43ydvC95a2xFdmu0GALFtovtxn7wtMnnyd2fTT5bFmpDD36C8VJybq98t8CZHaQS5MtHSiZvRJ2+LR77h0p4lm7fWdvRIBmXFjYVNCMRZLqFuGhNLofxjr2ovxwXYko2WKKVTNB/z/Wu22ePq0mw3ugw4gHcWZHvSALpssWllDkr2ZstqgprAkmSoIMvXH53dVFiCHLofQF0YzczkNvH2cf2X98+etZUy8RDZxG3IOGUJMXPkdRJcgdilPYSrcfIAkOjgktumXjLjy7oMSTkYP1byTMMIxp/H2JbvGHit4xlY3KEDqb+Qqpw1dniC1gI2rJXMmk2vsIF3sHiT13TR5pVSI1Zi9MkQCLp8kqxZERqWhlqyobUT64f6WDxnbDYrk2hUABCmnO5487H21dNNF9b89E0owjJIrPNVF63AM4839fQC2Lyr6fGjs5viZ103yTL7hZ3tcVarbYIl1U7RXH536lkh14Ldz1yvgUcWpcaXe+4fjkWpG5NsEnJSFry0spTSUp/Vn1agYEErKVuEeg5V8+YnEDRKF5ahzamNJJgxyPG3Cj0b2bhlc+3PGzrh9EblaNe5Qs6XriMDQPkvT/Pcbs6/owOKJpag9/S4Brx0zGppNB4s3oSCBa3wdlaGNBYpLavJM2GJQbvMiGCV9qZ01wTPMTNkEa5yJByBujmReF0z1th8JgH6/ES9+nr+lBmnn1UvNeNLahGMn/gqBWNmxsx4q7ZXeuLwniNy4PfFi0azzrhEBWKoFhB3cXmBiG7tbcM9+nP2H2bhwON3yf55aA63n6TjsrYdWjUBSNhPnWGHsB59LMxaCT3SjwF4lFQAUtcDfCcKvl/TrslyC7GnYRlIn2+tnsZMZcOTldKEilq1xLJ7P/OcKLQX2u7C7XhrbUdBLbQbnOuJuDfPy8I7C7JFBwNIdGxhzV5PIoBvPc/fBognOw3ZomsHl/s8V2EjUtsqURcCAH68aBj2Tp4qr/PztTgOBet1mYd0b76uYZbVy1/wbJtYpujSbLecX05QfNzyt6+L8SnPb4vbhkvGTshj6PBdsqQxnjYtAFhatqfD7DSotWb31knLZOIJbbEIudR62nRXCUsfrJfTzYXXb7OJ4xOgm7yWtZiTpnEDqJfMeETn81IOfLM3PtswGHjpkR7pkR5ftvHFp6CJo87u0FEUXQ3gKlja8/8zxtzgnq81HVpD20JcMc0Jmfnsml2UVOqPy1MBoSsfLmbW2uSQzQQgJiloF4PsP8xC5S228cClu15+yWyturzecGUJbRWva5rIbeOZerIkoTvQ7HBrZEDW8IGeH1gIaQqlK/n+UJlMk2hCBp5+HYDHWmMJRbsCExqnG1v6cbvOFXhrbUeBtpEY8cj9NuM7q9U2IUqQMmt2lmPlTCMEDK6aQv0PTWZJQMQogkHVvPnSX2CTascbBz2POx4/m8O0juKqi4w83a/o/swVODDjYa9erpt8XS/KQvWnFeJ5d/OzF2Lv5KnyevdnrkD18he8+nl2v7YeWqJTzwr8tTA2JG3UrZO4UAMQdAvPDR2WeZ2ItZTTBAFsOWT0E/myOszu11bcnAGIo4yHdNDGtY4pquGDABI0XEIpTy2LWjlnMZrfE+uPsKSza3aR9BBE2VAxbJuNuveIM9WLOp+bcjx+cuNzDaNMUQMd+kcAJgL4T2PMviiK2hljSutKh6aEZvH4QrTrXCGsOiAG1suyxenxaqF3T6/XNb1COrQW8G45dbzn1MzAzIBEZpxgHN8t8KjFQgpRNTQAXg0TXfMs/dNB3bTAOwBvMrHH0VIIGhxk8Gk942Q1Yy2GEy4DQ+PJkOASKmdRFpE3NmuJnBC2XPaAyJbWpNJGTKvGendqXy5kiuZ5Fj3BOrFuLhGORRsiLS7PJh2HngwTasaur6CRENUbNno1X/YWdK00lGt85vGmIn9pVryJZfd+JlKWLAXQZRqAMA95LW1amSOTE2Cha+ff0UF6Gh+ubePZgpFW3rzVAUG4sH7OGvGQS+25avnb1wEAFdOH+Wp/zhaLqAbup7a12nX7HDxUcjRuftaeC7o/s48S+tUdfGa2l5AQD5x5Sg9BywAWVqelarWRAZML7eWnS33VRStsyWVE7wT6Pv0o2w3OrRcJzQs7n5NyMJ63cUHDCMZAUmjbUwBmGGOWBtsdER1auxJziD6D6hQnaP4qTV8GVt2w4g2mLdeBuO7IBhZv/GRi7iEmk3VtEeU5tZHXeAwlBxkYw1osB6Fd2u+PWa82Z/S8+1rl+jdhQGYB4CFPAFtTNyvejDGpk7t456t4fKGnjyG6ze5cMNtfdu9nkqnRvVvkJZ2Zqzb6JAuMx6H7Ajz2suLGXq3Vg1GFjdokHoMecSHAcWv6OgMhJ2UicRg4WB/d90Zx7LyszmeIi/XcVVwfQMMnlw5bJvV0/kY6WSgaUxQ7QV8zUKCbDFLEkjPDFNinQzHkjJmLinlXSya8cqax7E13PXM1Wb10iScE75maugmDzTZP29sdh+7FEPkEQIhPbLLp3y9rUG+5lsiS5PafnHer51jNezdsqmb0HyDb7J08Fa2eOXKnj/M7n51yMH564/MNOhi/A+B5WEePSgDXG2PePlIGnnyfCzKADU6VcxZ72YqG29C+SONgNdpCU3IpvJLZNstjKPHip5hLdr+2Hh1Xy14C9iagbgHHmsI26HV9rjTGfru4tQi1A1bngN8HQOyStPNzKMrCbj1XBXsnT5UyAhBLTxJN0TwvKykeWh8DNTD4vWwm6f3wLKYUgoSPyU4kE63LgAMeM43WRVpfpGp7pZQ1iCdmNq7pu5riyzIMfzMNRySlPZRa1bZWzO4A25WnKh6zZ8p4cjXDFRYTAsnUNC1bDa6W9IQn+POgoegRjJSBK39LXSrhxKNXh2z0Adb1gwkBYO+RnAsfiE1PV73mu+PAKrvRdRoA7v71Ftx0a0fPhMETnw+ErYgMCtEsUct2EoSp5yLlvPJSq4/NlYj6PH6mkJIAr3RHyzNt08TPrI8G3tDOZ6UcjOdvfKFBB+M1sA7R4wCcAmAegK4AHkCKwVgz8B4Y0q/XyL55MV1YwcDIQNO2K3SIBiAdYGY3FApi5kzWVtSqpSfOotlF5OnrLrpmtrGOrRlhRAxw6d1y6njPfy+j/wAUDVssdN7q5S9g/n2Vnj2UqLQhDgRaYD1nsAXRiyLYpDPkpgEgtGaN0dVW8hRkz+7X1oMhaWwou+y86EnzDksQ+vfQ2sdArH0QaiFoTQsAXndf618A8FTIgFghTUuGcn84dGlEyAZqItI1z8yR18GUl3oQLjLKQi1sKXmteq1GHRK+XjSxxLMJkqyYuHRng6VZftqWiWUWnV2SKEGpz17X53poF1pWhWxN+uwxKPP9pyy6GKa81ENP0LZJO5CE+6EhkUJQ0pmxQgYBcQ1f3KGdzrLnpq0t0ZxnofRVnBCUXvGI+JCiWNeHO/R5tQjGzx4mGDvruQrYPlmVMab3obav8XPqGIwXA/iNMeZV9/gjAH0BXA7UvkyhbZcYZAXMXzDfU34KaciEpOkacuj5Fboa8CLTs7QeFKvXwdrsLJNAsP/T2F2BgROwAZl1adZZ+ZiOEnKhzh0Is+JNmSCEBTbWd9XQwuWcVDg4QWixIT1hsLTiCQM5VpXWJahcVIQ1hfbG0toQ9jvLhNEFQJTgtk5aJkSHblP7YeukZbE+w4B8YaYB8STBSYO2OroRmXlKDzEE5XPaxJTZoZYkDQ1JPQhi17zY1w3xpB21bBfbKjnbpZrE+6kPrR9rQR5+V/Gd6zzNBh2o+Fi0MZzmBhuTvK6kGeqw4rqWumvaYl8mFr6ZKj+Pk0R23zHYdddPPVF3HZCBePXC1QyxvbocxQYwz78u6bB847m9BJkx+wu6Ma5ryOF1qNmpHiQ0kIWtjzLFucecmXIwfu7jF1MJxr2NMTsOtd3hRl2D8X8DOMoY86soio6DpT0fA+B41IEOTdIHbzwd5FpcM9CjN5PVo8sYWyctkxJE1tjhgoMFLGOMvlpauKZ5qwMSYNjx1aUNbSejLWw4Cha08phje9ZWynIciKU+vYtK6TBXvb0GTX45CZ+cdyuAuMbMACxjw1pPFL9yUZG3rGMpA4jx0h41mI/VZ+ibmvVOLs3ZRBVJ0fD9FOBxrEaeLy3OpLHBQFwj9hTZRvT2smOqwVGbItTd4MSiqeLajksMSxXr0XxU7K2oiKZIZmUFKBdllV3rVYSXGQIeUiAcYozqJn3df9DMN77OXgPdMjwxIVfCIqPx9FFVCWUgIj0Am6G2uPkla3zqxozbt+JnXTfJPUbkig6MXBkCie7c7BVo4R6uAniNb5u90Wv+EoOt5Wm95rtbubEMRINZGuny92HmDdRfmeLsYwanHIyf/3hhwwjGNdChZwOYBUuJ3g9bM17utq81HZoSmiGbDYizDs7Iawrb2Fne1eS4zGTmsWml5e3rWvGmbTZzZNe6+tMK7HjjoGR2hB+FMp3MWrkc56AC3P612xNKGxwMVtwPBiRhI7nlmhY4ajnVNjA1ayyZaho7yx0fuzrRd0/dHNSFFXlJxJmtpmFrtAoQG5vyN9EZJqCYaC4zYxNR6wdIRuMe8/g5wtp3CCMjs02IOSN8yJOcy8AtWgdnU17qkYFEzlIhSWRig826yoobe67VeuVB7RTtgs3smdl1ONHwGtGljmQaEclUBikmRGQJs1QSasISArfn/ZEzZi4AWPNT5wGoG4meChvgMVcBeJR1shB5HzLb1fZibMBpuVay7gBX11dEJ30e5VwgprIDEKMJBuSoZTs0PbbvEQfjwcf8Z8rB+P/9Y9HP4UqqbswwxszggyiK/g5gJyx8+Q/6tdqMBsHAYwOPM6vOYtks082vpWNWx1z/4QM9WxtSMLns7j13oFxAutaplbIoQK/tixiEgDhj12UK3nCh5ZF27gj96AB4S1zvpnT6EQzIHDrAePA6KMlCpXQVOmuzscUsVkt1Ar4RKhBn9LyxWa/0bnQHKdOfqWmtou2sgrGnYds1LyFDIuOLgTDBUNT5t+lGo85URRRf12JVuYATijjHALKy0EI3yfwAdelH6zSzJKZ7GFXz5uOdBdlSR+ZS3Du/apIl1V9T3osmlng+ecySQ3EszXBscc1Agf29PeiPtgziVjM5A27D7jenw2x83/9dlXHqzc9e6EEFOaHqEpheDdElRdP1WaPnJPv2oD9aVIeCrumSQygAxpWMlvLUDj8c9QFtG3TMoJQD36KPFx0uMz7aGLM5iqJ2AF4BcLUx5rXa7lODCMa6ZkydgpDKqW1rNMWyR78daJLXVvCpfQqvR/XHayQAb1qZ4wH9gbikoAV1dLOJDbsQa6uX37xBNDyu+M51UtogfZc3CDMIzvB7bpjgLYmZJWsH5KhlO1QXzPc0LULHYt3wowhOGGw0KJ96yaEDiW6iVC4qkqDPiZDZNl05tKpdiJGmwDgnM5ZvtPMwUTKAcgV3AZm/u85cNXwMsBkTs18+DoWC9ARAkoonxwh4qnjbZm9Eh99f6NXoNbWZAUlKEEGWC8QrIuoTU7CeTcKwgRo6fpMWTqw2x4zbt6Lrflvtyz9npwRkfkfRsMUyAUQt2+EP5zwlsqjRyT9Adt8x2Hxad1nhEG7HwPnKoLnoP/1ET5IUQAKkNLQu07jh/Z/G5BF+L01IAYtw+eS8W72SolbRA+KVhL6GPdnXepLQ/OnXf5py4HvpHy+l/H01uSCl9N66MPCiKJoHwMkqIRdAmTHmJPdarRl4rBmzUaYhS8Rbsj6W3a8tMkdeZyUUEdftuLzixcBl30cPbUOnnhVYU9hGlnt71lZiz87GcrEz2HMJzAudDSkgJkPw9aKJJfh7oyyce+YOeU4zr7TFPBDXykKbG17cu6YtlkChiSC6oRTCplhPY5OQkpNhds4sE4hLF14pQ7tvw68fMuhq1azQ1TdsLIaPuazmpFG6MUcCOmAnw/n3VeL8OfmeH50nGOPIPdr1O7TjCaFXXv0cidmewN3Uje/V6IEEyU1Pv8Htu7YVCh0xpM6vFAO5igLg/RaAvV7bda7wSh2sMf/mT00AAOdHu9Btaj/PYWP/2u0xA3LW2dh1+xzR1Og//UTsmrYYR7++HjtHfsfux/ZKS0BRhBY9eJ608LtHWuI517wAt8LSzUh9LTFz5sTDx4K9H27hkl0vyvJ8KTOO6eF9d30IBQ2oRTBecohgHEXRfwDIMMZUuP+/AuAOY8zi2u5TnRh4weu/A1BujLmjzgw8JaEp9VLeIA6krzOJqnnzY5A9Pd4C+UCNwWSDz8vMxg6X7LrnqMg6GC/IBuBYRP/cIZnH7l1Z6NSzQi4yCquvnGlEML3DuBO9ZlCYHbI0outnOqul0AtZdBxaBjJhue+W6RreFWbw7IKHuNaEAO9uKtoVhUSIkOlWNW++EF46PnY1ysdP9SB3GnZF8ouQUxzsjxkTu/CUrAQg2aIWaCKZBIBkqx5VXEHwdC2Tr4dQOZ7bsPEYEl7YO5BzqyjXRPfo79JLdcCuZmQiZ2PMTUQa2sVzwYY1jz0shdx92au4qstmL8vtP/loTxmODjmAhRoSm9xq1nsAYuU3NgX7zz3Dg5QSMaOFgoho4bniteA12BwcEICwLD2Re+UtGZJstIKdYLtD6dkNa+uFDv2Trw9MORi//I/FhwrGXQE85x5mAnjSGDO5Lvt0RE4fURRFAD4GcLoxZn1dGXgMxrtmF2HPzsaeUzAhUDXZLoWzLYOLB6J3fHcGCwYHDcFZs62NNDdEE8FlSHSAoCThvjeKUVbcGG1ObeQRRfjZ3KbZxPFyEekJBIBf+0Rc393iLOUBCEjeUyZzjSrA3jCVcxZ7GhGeXRQQYzaVV1xSo1RFfNASmsLKUjRjsqJCEXyphw/IlxIJR9X2Sk91LmvscA9mRT0MvbynUzDPq1YI0xofQHJtCh30PBUydyyh5nHYBOS55fkMz62ugXqOM2HTauP7PiFGaUBoA1sg1mcImZXauaP33IGYcUkBftbVlkdyBnfDlAf3CrX54DOz7TXsJDXNR8WiqczPpPKb1yh3AvT8TTVahefUSzZcTV7/7qGbzYzbt0q5JHQ319cEAG/C1tlzmH3XRzA+o9NPUg7Gyza93HBJH+r5HwCYSpBzXRl4rBkzK9bLuBD0D8C7KfdOnipwNiDGrPJ1Zp9k1QHwtAiAOBuhb9kpiy72XJoBK06uBcHLx0/Fh2vj0gfrriJvyU6/alaENjTagUNTUbVQfkb+UI/hlKxMseWyBwBAjBy11ZA0ZQI4m155aIF6ZqShM7PWKCAMUDcT9QghX9p3DYgnWH5n8cjnsWp/S5w/J1+Ovay4sa2zKsqtZtR5WtFIUqaglq7ex6BxSJsmja3VojRR5+M9Ig9JNhqKFRqjhnR0LcYOQMpfPI5kutgk2uj3amfmDU9Wotuss6X5duN/7UdG1854+ldbAQDnP9gD5qNifPTQNgC2bFG9dAmeebyplNUoNlSx5Ha7ny6gam0Kzf7k6kqXD1jL9YxN3UoUiOGaoVwrmYSascrBcqFumuoVJVA/DbwfdfpxysH41U2v/FsE4+kAio0xv3OP6xSMCW0Lu+cAEux0iFBgMKGpYeiOoWmxZDVp6BobA4AClrvB4ORlei5ocbAuzRuEdT2d6YbIBi1cntF/ALb+Yl7M2OvaWQw4Q6UsjpqEV3Sg1O/RZQ/d8dZ1Sll2q661RpKwBk+TTkKcGDQAoPk9Uzx/Ojo6SG3WUdQ180oTcbj8/eihbThu6UR7LM89GmsbIG5wMlgD8GBpWyct84RwvDo3Yuqzrp/rej4QL5u12W3G6WfVrFymDD/19edpVbhzHU7SmiyhxYkaj75SSi685sM6MxMMbVTbbWo/WSUUj3zeg6zdfdmrgpZYOswGyv6Tjwa65iFnwG0AgL2f/AVVzz/sZeyabUkMe2jGWuPqA7beToU+ICYlaQq4ds4mZl4H492F2z3hsBX3luH7W4/cBim/U/+Ug3HBpqWfSzDOqOsboyjKBHAeLBWaYzOAr6vHndxzyd4/OoqioiiKimat2lDX3UiP9EiP9Kj1qDYm5b/Pa9Q5M46iaCCAm4wxP1TPHZEhKX3V2AwDkNCN5lKJ5QsC8WUfuJQP7I48KmdQQuByVJuaspHF72QtD4jZSDrbjk7+AaKW7cQlmJmKbpxpw0diYiX7vnAoMo7pYZWsCGlSsCtACauo/dCKbI1HX+k10jJHXoeX+01D/+kn+m67SnuCXXOd4etzum32Rs9x4+lfbcXQa7O8xgvLL57amXJSIV5XCwJpsRxmeWbj+1g6xjZN+889w1s5MNvWlj0hjC80t9x1+xyv8SsQs8Ap2yt5DY/xuprUAUDOLQ01y0ZNkGw7tL4SUalrBnpMwgTopoK86etCw92YLessVbNMu03tF1OmAaFf856JWrbDK4PmWvNatxooHvk8ugw4gKw77fXT7KjvY9ddPxWGXdmoCR52mRrJGred3a+tNGOB2Ola4ImTzvDIU8R5s1HOEh8f9+i3A01P7SZsRH6Gx8ycdXa9QNu+f/QZKUfZv2xe1jDKFMkYeMaYmVEUPQ5bkvifYPtaM/AYjCmwws4tAA9JAMCr7wFO2Eaxw0LPN2nkqK68tmIC/HookIgGoE283p4GpPwcdoC5/J9/XyWGXhvTS7lESyhjKGgbBcI1VE3TXpPVujW7jg0oEWZxgUVrDGgtWSDWHtbcfy17yCU2SwKsfYcBXP82Ya02FAViYNZmmHQ41qL3mQPycfe1tvs/YWwzz5aHWg0hu0tjmzV5hX5v2oKKFGxPljSwn9L14NCzTRsfeK7f7jwCsXBVWKZgnXXTyhxkt6j0DE21YA4AQbN4TtdK5Y9U85DxqHU62AzWaJxQNlZTqKOTfyDYYx77lssewFHP/lre/3K/aUmxygzYW38xD0c9+2tLU4cqn7jzWTy+ENktKgU3r/H8LIvRRJbXRVlxY3xj9ZHXcPsdfXrKwbhw8/KGEYw/jyHBuFUuMs++ElXPPyy44ZzB3YQMAcQGo5rRBMBDNWiasocfdplu5YNzBA0B2Iu5+T1T5KKpfHAOssbGnmLtBucic+R12P/bSbLPRG3oDB2AhyctWdJY8MZhU4bEB52lsZmjVcMAJMC1vM67Qjro2iUAoTnrYBwK1JMOrZ0VtM8boVg6M2FGqTV5w5pwMoadlvH0XLyVYhh/A9ZJGWBm3L4VV4zL8mrwnn5zoBsRTrgVC4tRujEH3Z+5QlZNIeNRN4mAGOMujx0ShQ1TwiU1Dr50Y47oagAWn66JJDxvuqmlJ5k9OxvbAPZugafFzG15PquXLvEs76vmzZfmW3XBfI8oRcdm3V+gzgRdNojdJ4V6110/RdSrL2ZcYo9j9LQevtCVQxvdfdmrmDC2mexX0bDFguKIOh+P9UMe8WQw9WPC50ISSIsRvUU9rmzUBOzZ6VPUc/6nZqhZqqPvUfkpB743PzlyYaJURoMIxoS2aZA7L0AGNN2U6jDuRM8p4aRzdku2E2Isl8/MRJdmuz2cMDUPuKyjclbze6YAgDD4GEwqFhajSWtrVAoABx6/KyHTZUmBS7KWU8d7GrRszOmsigI7HNHJP/D1Xf+5w2Pf0e7Jw6WqBl+oaEdCiLanz7xwKKKW7Tx5RQq6cL+1fgCX8XrSoQ2T6Na6pqnAzhyCw1P0CmBpGtFB1T0SUgAAuW08tEnU+Xjcdd48gW/xfOhzp3U9Go++0pYxVNO2aEyRJ7qeTNiIWG372F5Dukyh7Y20HKeWZy1Z0li0PejcwRIYVxV6haJx3MnuAQAJ6AKtg8LShtZ80KsEfTwadkZYI4+F1ywAtLj5Jex+c7o8XnFvGXpP7uKRqboMOIBG3TqJfdboJ/KBsh2yGmHA9pTectv41k1OSlY/XjpsmcBIM04/C+uHPIKSvbaU8eNFw+qF9NHnqB+mHPje+uR/v3rBGEhkSQG+NGRoZ7/1/tVoP6KzXNwULddaxNS84GC2wovguKUTYcpLJUD1KbweVbN+JzU5iq9reyOz6jUU37nOy3x17fpg8SZPZWzFvWXoPb13gmxniMbQ9fBkzsdeEHRBL8ycw4yaQZzb6M9eP+QRb+moUQfcLyAO+mScad0NjRwAIIE5dG3hYE1fB/zQy5D4aF1Tj1q2w13n2dUKg3JN54p9Bk0o0LRvvkeTPkLhfdpVeXZdyjuRr4eTo56UExynLxwqmsZAbHrgQfCo6atcNjSsjJT4kCyiWauAL9rP35H1WBJ1RLp1+EAsHbNa0DJRy3bI7jtGtJEBW4b48aJYCe7tQX+0gvVuNfj08AJc8OIFsl/L7v0MP140LAFDHYooachb77kDvWShR78daDZxvDzObbYP3/n7oSUtUxmnHPWDlAPf25+81jCCcQ106JMA/A+ALNja8JXGmLccCWQagEEA9gC41Biz8nA7QWgbEIPkeWFxKe7JHAb4Vu1jlrCkcze6LOkRa9/qIfAcQJZ8lLfsMO5EZOQPxZ4bJgCIsxnteZcsywr1LphNAPBhdoi5/tqpgzdlskADwLuQ5bvVcp3aDh4Qn1x/lT1r/QAuNfVj0p+BWNsh9OLTMD4aX2oWlW5EsuaphczFT1BJjGa0zvGcP3geAeCR+ysxeloPT6I03AddT5drQLH0GNR02ULDqKR5qfV3hw/0ShLtOld4Kw+anDIgbZu9EUc9++uEEpdmEupJRyv76dKcZz0WBOeQhcraMOuuZ1z/H759EiDCS95Es/F9zLjGlomuGJeFjNPPEsH6iiW3i+YFAIy+rQMy8ofirX73yrWScfpZuOG8P+E3j/1YjpXwSgCSrWvs8tZfzPPYibJiVYQrXVeuL9ul3h2/n3IwLtrylwYTjJMZkr4M4D5jzEtRFA0CcIMxJt/9/2rYYPxdANOMMd893E6EaIrmrQ7IjE0lLS5XyUQqg61hUttVZ5zaDUIaG7qm6MgSukmnPyM0Gi0e+Ty6Te2HjBPy7f7eMAFZY4d7hqOia6AQGglqac4ZAoBY4DCIa6ytlq/UsoZ0stDWQ7K/boTGlBQe9+yKWuX6PmrKNZj1Oh08uOQHnGaEW06G3mUaB6vRFTw+DrPqNY8RmdG7l5wvBko2SHWdXwfSAzMettZWt3aU46bBJaBq8kqIiVmhZjguHbNamlSAbSqJrkggmhS6opD5qUWQKM1KwaiwsacnD/sdPpZce/npmnFIwtGfQQ2ShBWRYn+SCOVpojAwIw6aXM1QCZGfkTPgNtvcc9c3zQO03RbF+rl6uenWjohO/kEs5j+1n9SRAVuW0K8fe1V7ZJx+lods+leVKXp2/F7KwXjllr82jGAMJELbHM15ljFmXhRFwwCcaYy5KIqiPwAoMMbMddutA5BvjNlyqM9nMK5YWCwKXyJ6css3PedmfcMBEAUsbTEeUm/ZZBHZyCA484bT2a2HCHB1L04IGSfkW5iVyu723DDBEwJiQGLAInNLyxxqOx2vcx+I2zDYMlvUNcwWtw2X76Amgs7WGeQJWeJ+8jO33r/aazBxOS9qaIH2LGvS9D8D4ps+rOGKHc+7BUBuG3FvMeWlvoynohTr7M6jKieB+VUvfwFTHtwLwJYtNKFDU2vlPa7WqiUzDxZvkuYkqcoewWXDWtEo6fjY1Tgw42HR5Ojw+wsTauM8hxquBfgmuDq4kqYcGoFqc4NQkyQkwEgjmESpYPWjtbP1bxYSYzRhg/rHLEtQH5llC5rSfq/fFrnXHrm/Ej9fcIFcDySbcLwyaK4lmyjfPa2eSLSFdmPpMuAAGo++Uh4DqJcyxYkdTks5GK/e+nqDDsbfArAEQARLHDnNGLMxiqKFAKYYY/7qtlsG4EZjTFHyT7ZDB+Ocwd08WI4nEoREQXDiGLlNKHSu4U/6OeS28ZaBQCyYzWbGK4NsZ/n0UVUJUC4vUCDG/GoBmNC2JlSsknotkKBDweFZTMHerMzw2o/oLLVpDr0MFEaeyoKSCdvITeLODZ08gHgC0MpaGSfkW9U85f6h3UCilu2Epi5DqaERuqgDPs+PbjBpfHloZhlaZz1yfyVG39bBm1DDIMmaPIenAwIIeoZZGWuYHKyJcmlPY1WNmdZWV4D1/ev42NUeAkOjgUKxHE2Z5/4IakNdWx4qwa0odBmr+T1TpKzG3y1knTYaMsKzoMo4pgfe6ncvAEtVzjj9rLgsMa0Hos7Hx2WL6cME/qabbYJHhr03GaABSEOb2uN6ZQHYc0kcvDZy1WWKLZc9UC/QthM6nJpyMH536xsNOhjfD+B/jTHPRFF0AYDRxpj+dQ3GbOBtvX81crsdQJO8tt7NH4pQJ7PnEd0DVV8G4sAJ+JkbvtZGyg7MchksQplEZsXsYHMJnHFCfqwbodXUAO/mACBYTw/yNOkMj+QAwDMp1TVUQGk+uP0UenRQppBmkZP6zG22z7Pw8dwY3I0TeqFpl5P9a7d7llXtBud6LsqhGJEWfAdi4SCduYXSikDgGhFkbnINKCgg4C/3pzy4F78c+Kkcu8bRej50igxBx20gxpfLtedcmjUlm6gCfmbouqyzaMCWUwidBOzKROv1Cq47kDDVz/GxbhwCvrWTd37dOdarMkJEa9JyrlhYjNyZU0SatvjOdRYG6K7hpRM329qzu9ZyxsxF+S9PQ0bvXlJnHv1EvhCkgLj2ztXLTY/9yCfEjPDPGbUsaAllf9dcFE0skbJk/8lH14tQUI/2fVMOxmu2vdmgg3E5gFxjjHFNu3JjTIvalCmSuUOz1qsbU1zShZ5h/EGJ6+SNRrNQXjTaDSOh2aMCvNR8gYSyhBAfFAuQ+6LZWsSMArEUpReg6EkHu0TTJA56henmIut8YTdaSzwCkMecHLRGBCcL3dg8WLxJMKhA7I7Nc6+biKHQjTgdl+2QyYxlBz6uLpifgPvVkx/r7FoYSgvlADGT0nNKUSWcjPyhHhaXmTbFc67ttVnMPwFL+mCJgBM3kROihja5S4J5qD6OsCnL8srWScviBqdzpmnX2a6AmudlYccbB2N2p3Ok1tl3p/blsUM1kohK0WFa1Z3JEuVvQ5Ypt2eJir9PqBooTT+36qpeugTLZ2ZKUkCmXJ/C6wFY4SBaYwE2q23529ex/czu8pn3rTgaE5ddLddcxcJiDy435cG9uOnWjjKJrJxpcNI5uxPQFHr1R1Gl+ffZ3+zkJuX1Uqb4dvvvphyM/7bt/xp0MP4AwBhjTEEURWcAuMcY0yuKov8EMBZxA+9+Y0yfw30+0RTaP4zLeXqhsdus8ZZAbPHO7YWNpKzp+b5QREZTUBN0g3v1jUVVpp/omVtKdqpgZUBcJwasu3WoMhYK9oQwtVCoXFugAzF5gmUXLbTDz9Dv82rIqkTAmwSwk4g05eCzsvRjBusmeUrc331mxjE9EsoWmo4b+v0RCaCX1R5cz71HNwU52XmCUEAsJxrIi/7hnKcEEQDY5a4I2itMr4ZQss7MzI5+eDz/rKcTZnVc3g6ZUBk8crsdQNNTY++4nY0a4fw7OnjZH81RAaBd5wopzQHxqis0U92ztjJGp7gmrv6d+jA1cQAAKfVJREFUNGEmNArlCJt2DPJAbCJAAfsJY5th3xvFsX3Z9N6onLMYfy2MBesr5yxG2xfXY9ddP5XzpyVH6RPJVUHVrN/h0dlNpWyxd/JUrClsI3X1zLZZ3rUI2Aw9u0WlTF7L7v0MZ26de8TB8Vvt+qQcjD8ofathBOMaDEnXwULYMgFUwkLbVrgs+UEAA2GhbZcdrkQBxGWKp3+1FQO6bxI2GGCXuJVzFnuOyHrm7DDuRBRNLIkt5l0H3VNYcwEytBln861q1u88IXMypDSFWJtKyrkJsmvt0ZYg4h544FGeUDCtbqlZ+eAcCUzh0GgDIK55Sjapao98TKiQZseFvmVsxgC2W60ZeVzuc1Rtr0SzieM9we8EC6SA9KEJH4CdLA4+92jCykQjXFhOSdCiUHXT0LGEJQHAZr13nTdP0BZAjLjQ9fLq5S94bMTq5S94qAttxsrrTsPsKhYWI7tfWwnqWocBsDX8nMHxd74yaC765G3xluha8wFI1GZmKYO/A5X3SK7oU3g9Dj73aIKLjDb8ZJDXKzkNoysatlgIQICrwT+R7zUUiTLh6xefsglNT+2GFjdbxYOKeVd72uMUihcss9MVf6jE9icmjG2GioXFIl3bc1QkGh/aiunR2U3RyqnbDLl0X71IaOa1OyXlYLy29O2GEYw/j1Hx31Z1n7CrhKG0eNk8CoH6vIhExlJlgkBsN8ShRcSjzsej0TE9UPW8DZyEdmmZTp318nOjY7sh8/t2lt9/341efTpEU7A5xZth7+SpaHpqN8l+dhdulxWADiihW7SXEbGcooSDtE4CReOltADI52uPO9FDAAQKx/NH7K3GvooLhftdQqNJT7QGsf8cbzCWW7ifZFkS2gjYDFLrL5D0UdNkxyW4ZyowdjieHm7P3dBrs6REITRtt9Tn+aZZqCYlhCgbNjT16yHax+wsF8JQp54V8tkAPM84APhrYUdsaNIIF59iJ0ea4zIoAbbspoMaEBvxArGDhkAzj+1mkRFOcIrEFd0YozGBhozqMgUQNywBO8HOuKRAslqWhK7ttVk+I+fCB6zxqZuUi0c+79HPpR/irpPi8YXo1LNCri2SYYh1B+zqo8VtsRFBdovKemngdW/bK+XAt377iq9OMNZ06Iz+A5BxTA/hzFN/INRB4OCFJpjVwCSS9WZNCBAreZd1kRShcZ2ZA/K9IKixuFyahnAj+6/CjwavexhiJerCEYoNcR+1qalulJFYoZlXmmX20UPb0P2ZK3yhfNe00dlgGMCKRz7vYZ2p5QHYbFEjB4DY4UE/pr4wjzVZwNI1UTYntWUP4GdIOuCLzbyqyetJh81SjVPWrs48994k7SzvdfnK88xz117xnesA2EArbs9uECrIIXq/rjRCfLXOHrVAOxuyCdeFqutzgtAwQN3TYHM0XMlpwhRXHVphDUBMZZ7eG1Hn43HDeX8CANzz7H8BgKBCqNdSNmqCZ7elWXvUTxYct/NP1Odn6bBl6JNnW0otbhsuRqkaUZLb7YCsFuuL9HFsm54pB76Pdqz86gRjT7XN3RBaqi935hQJzrsLtyNncJxRli4sQ6dlf8CmM34OAEIYYZ2qbNQEb5kExLhN3Z32zC4VtZTfoSmrOnPioF6Dpr2GnXhdg+s5KkqwfScAvqaA7Z0fxMQSzWTTNyXZdb2n9/YlGpOQPjThJSN/KMpGWVgUtRh0gCf2Wwvya+QHJ1XtWBIiQzzIoVOm8zI3ZvTKkYRlBp6LojFFMfRMWczzOPR1REcUZtzchxCpw/MKxOUX3QSlQBTgJkeXkXLyz2id43v3OcSFFs8J/QI9o88AAshj1YL10ixWFPWM08/y9EaAOHCSvr9rdlFcfnITJgOjBEk3uRWNKbIZt/uOuy97FTc99iN5nXoiXiPRrV5C1h4homz+haQPwudGDtqBxqOvxFNnPiWKhyR9sCHacur4eiF9dG1zcsqBb8OOVQ1DXD6KollRFJVGUbRGPXdiFEVvRFH0XhRFL0ZR1EK9dlMURcVRFK2LomhA8k9Nj/RIj/T44oYx1Sn/fV6jrnTotwFcb4z53yiKRgL4hjHm1rq6Q2vSB5shmkvP7BiwimqkJwNxx1Yv0dYUtsFxeXYGb3HNQJnlNb5RC7OzjqjFXbg/AEQMnFJ/1KglYxCwAtm6ARKK/gA+EWHFvWU4Lm+H16wk4oMZUaNzL7coC2WYqdXR2HzS9NewBAEgIXvmvgBxFqsFjTQNlg1A7zsDXQ5NYQYstC1k4EWdj/fYX8mgcFrJjbCr0NWahAsyD5kNMourSfCeSILKB+fIqsmUl/oC9QrCps+RzlQ9ko1yzNauyXqlQblQoinaj+jsrbyWz8wUCyR+JksQGjXT6NzLBQPM3oDnPaekVLdOWuZparA5p5XciFoSUfxrrHed6Eiseg1LJ26Oa8gb1uLuX28RuUwACc3Ljx7a5tk95Qy4Dbvu+qnXvOw/94was+8ZlxRg9BP5HgOvU88KNJs4Xh6X7M2uFzRF59YnpJwZb/z03YZTpjgMzvjrAJYYY44/Unfo4jvXoVPPCtGjAGy5gWgHwBomVr9bIBdq5sjr8Ml5t8aaqA4poaFYrEWyhkZxcw17ate5QpaOvEG09Xl2i0rBkgKW/KDdoXMGd0voOIckhbAW+NFD22RS0SLnWsRHj9AWnctk0ZVwOGVNseaEECIIakIUhMtqulToejAAr/vvWakDUvOXmrAie9gTutYjOfAzPK0Qmp4qfWgug4EYtsexfsgjom0AxPoXhPBpeGCy88p98LZ151ajKfT5puh51thESnp4rrVwkBbz11hf+Y6gxEJtCakZO2KTFvXfev9qT0xHQ8yqlhTgnQXZ6NFvhxBcHp3dFFeMy/LYnI3OvTx2qnG0ZF3qACAlBcIGtQMJWassR1Qvf8EzPTUr3sSyez8Txp7ZWS5YY8AmI8883hRDr40hifx8/o71xcA75mvfSTkYf/zP9xp0MH4dFlu8IIqi8QBuN8bk1NkdmhKaDnCv3XIpvqPriwC85lpG/tBYYY3geZXlsOmlYT0JWhWAd7FrNhMzDS3TGTYKQ3lG1hI1VlQ3elhzDXUQiu9cl6DsFjKv5DtchhTWsEW3eYQlPZx0zm5PaFw3qTIH5PtMQjeBsHvd9aIsT1t3xxsHxfiTWSublaG0JG9k1iLlfLt6smbgkbqtg6mu45MiH9q9a5TIOwuy0XNUfN/ohh+bXLrhRkINzyvPZ4gd143HbbM3eipk2s0ZgDR6GTyilu3wyXm3ikOGKS9NcJjWOHAei7AWEU9UvCeKhi32EC8o2yFZPxC7gmtyEuva1MygeJTnVKN0TshM5MQSisTfdd48TBjbDI3OvVxo17xvyCr98aJhMOWlYnpKpIUI1t/WwRMKIg481DMuHz8Ve3baBnLHx66ul5rx0a2+nXIw3rzzbw06GOcBuB9AawAvABhnjGldm2CcjIEXYjjtv/axFt0GAv1axe4qGzXBY+CFUooAYkSB8gPr1LNCbihSijXumHrEgG1ehF10CnWzM88bko+T2RlpIfNtszdK0CIDDIAHf1s509jlpv5MpdNB1Ikmp4T287qRB8DTAQGcFsg1Az2FOhI9AMTkjiQMvBoZd+49FAoSpTs3KJJETC6QyMBLEIvvmiduwgCkqUs2HRukGgVS07nle3huhYGnRP6BJAy8QJaU+63PMxBrGAOxgDoD5cqZBr2uzxUhp+qP18TWYeqaJeMQgHdeAFfeIiUasVONztYzR15nA7QisJCNqfdRu3B4xB0XZBkko159cfdlr+LG/9ov+1l85zrJqAGIbgXv1ey+YyRLBix0TmfBbw/6Y4Ke8Unn7Ebj0VfKxL5mW5t6KVN0zD0+5WC8pez9hhuMg9eOAzDHGNOnrmUK1oy3zd4opQDWUqu2V3oYVV50Wpic2R8AZN35MKr+8pR8NpfqZuP7sryUurSCnmmKKgCPNhtiSYmRJTsQiLMXThZc8rGGRoEeDmH8EUOtlLa0uhlLEdymat78BDshbSul9Ryqi1ZI/Z2rAiDQgOBNpzK74vGFUj4BEgNLxjE9hO0FQDIzjjCT0zRzb6jneQMLScbhffVKSIv18xzWZEz70UPbhN3GxxTDYe2VtdlQqpIroP2f2uvQM1Lt3ctzsmD2nlT/hN+h6vqvDJprpSddRq+vY55/oUOr31EPym6GVk4asqdRNVSeazc41zufWmaAAkcyacw625NvpbA+6eW9rs9F1CoXM27fip91tQG9xYjeXrlEoG0Ku8w6Mvd76cTNyD9np/3NB+RjxjVrcMW4LJmcXu43TXzwANszaF9w5NC2DrnfSjkYby37oOEG4yiK2hljSqMoygDwOKwexay6ukNrnPGGJyvRrnNFTP1EDKMBYvKGpx8AeJq/lLgE4gtX6xrwJtQZEHWSAQgUTC/hqNAF2AmhumiF0LcBJGgkEx/MJVjXi7I8JwtClXQtU1yoFdtQB/GQYcX6p1YR043IFiMs40nTyVl3DZtvmkxBXWUAAtLXIklk4DGoJehQuCxYlq+UeNRed9SvcIOTpnYYOZTjC0snh9IJDlcz3r4gniAT6ueBbZXW1pYVDCB0eBJ4+BslU+/TYkhSN3bnKpzMtC42oCRbXSDliojH1PyeKZ5hbgIT013rmW2zPIILm84ABALJSZsQS12moB4xEDtlNxoyItYvvu87vq2SE53StkxmxZvC2GNQpjUZ6eV6hZzRf4AIzAN2hVMf7tDtW+alHIy3la9tGMG4Bjp0NoCr3CbPArjJuA+qizv0tnxrDtg8L0t85TQSIBQy11mAOPS6JgyXaDJUd5oXfIKWAoVYtGynE3Lnd6wpbOPd2GwUeo69TgweQIyR1RNA4MxLVwggtkKvLlohimrtR3SWmxuITVBDdIUMFTSBmKxCxAkAuSG1vq79Nzc+dsWe23r/ahFrCY+TCA0iPrzfjPsHSCDm9kRbcDuSNbTaHrNqmUQG5PvuxoG+cegtB8QWXDwX1DzReiF6daLxxQAS7KO0tCgHg7Guf2sNEmafglpwTinsT5QVN8ambS09HLJIYio/QMBv6OoJgHXs8B7QDUlO3OFKQotzlSxpHK+IQglTlyVrchVlCLgfgqZw90DRxBL0HBVJGePpX23F+XfEMqctbn7JGp+633TG7VvFvSXU+mBysGp/S1y8ec4RB8e2Lb+ZcjDeXr6uYQTjz2OwTLHi3jJRcdIqbQlIg0BWcnfhdu8i0ctbIFHlirUyzdbSDhqUntR6F5VzFsf1Rxc0SWHmZ2hhFkKTNKJAZ/jcnzCDavLLSXEJQPnBAXHA1G4Xmaf0SNCA0DVlUsU1wmJ34Xav067PNz0DtYEmAE8zQIgKCtqlH/N30aQV73cjAUS7QzuRH7IBCR/U4kJ6ZaHLTzIUIaZyzmJR8AMghrPVH6/xmrOhfb2GPPLc6vNuNr4vcqMUowdidTvWb1la4Lnmb6izPr5OujPggnWgbc3yl+4FaDcWEoxEbClAkrBEl92vraeOF1qPkYoO2Ay0at58eY7C+hxspr6zIFtgpE1aW3q3RlNo/WJqoLDuDNiAvHPkd+Tc/eZPTRLgcwC8clN9qLZ9Lad7yoHvnxXrv3rBmMtQrehFHGyYNWlKbkbrHK9xowOxR2nWesVa9yBALQD2gte0V09jWVNKVSceQI3aCYTS6bKFxiF7PmtKawJIhF7pc6MZXIQ7aaiUborxe8K6q6ZDU1aS2grdbvmmhxoRcRlV9pEJQEl6ho4anuaIC7wMpAxcOriSXl2TWH+jcy/3bJnCmj2PSweo4jvXCetLzmOw6uJ5BWJ1Ps9/cfhAr4YbUr1DX0Jmntq66Z0F2dLjCJ2deWwavgkgQchK15R5Lr1JO0DMcHWUzDQXiLHIvBY2rcwRvRDA2W3NOlsQG2XFjQVhJMpucwdi1+1z8OcN9vhHP5GPqnnzRaGu+zNX4MCMhxMQHa1mvQcA2H5md2S29SVHgbj+D9ig3Pz6R484OLbK7pZy4Nu5u7hhBGOHI/4jgPYADIAZxphpURR9DcA8AF0AlAC4wBizsy6mpHufm2IAeHVgWdI6yx4Pq6oyMKIYGPTCzjIQ40NrormyAaIprRn9B3gmkRRwsdu3lBqvzowaj74y7mArFS3ALiu1ahaxzcyspfGmSh+8Kb2gp7DGoTu0DjgABHEQoj50sGDZQR8rqd0A8OKbnXD+HR0kQJUuLEOHSWf45y9YAgMxJAlIQrl2TUqvkRY0oejoEr5Hw6i0QzV/MwYLOmN4KAd3bgW54M6tnvQ8zLQ7twzScm6VnjQJH1xGU5Bdew5qAaQOv7/QM+Fk4JEJ1NWP9fmkYaleyRECCviSrvyNNbJHNwR17Z+lFT7e/2msNocNa61olKObmxVvetoqQKxHzDr+hicr0W3W2XItzVrUBpeP2CeloncWZKP39N7SSP/zhk64fMQ+mcjavrhelN+00FKTvLZYPjMTgJUkrY8yRcvsY1MOxuW7P2owwbgjgI7GmJVRFOUAWAHgHACXAvinMWZKFEUTALQyxtxYF1NSqrYJhlVBekJoFqUadbaoIU/M0iTw6huMQdx9FhXXqv7yVMJy1cuS3bJTO0BwmacFu5PJMepmUBisktkMaQU6lh3C7DqEtnESozwkAynB8qFQkM6+GbA5Mgfko2hMkeB1M7p2xq7ZRYLz7DDuxASJUSDRNFMTYOiVRvxz87ws8S7kuaaIDWupm1bmeI1ckiN0HTRsvPG8AnZFor+Dy/bwNwqtsUJoW9g8pgYv4Dd6+Ttv/cU825wLXDr4uGjYYpx0zm65XjWLjr8hSxm8NorHF6LLgAOeBjKbs0CANAK8jBiIWarMdgF4dWwgkXWqJUABh6ZQDD46hxSPfN7LWpfd+1nsm1deiqeHF+D8OfnyPTMuKcAV42xAj47thruvfS92ZxmQj5wLH8D2M7tLrZrO5Nyfrb+YVy+kjxb/0TXlYLzrsw0NIxgnvCGKnofVLH4QzsXDBewCY8w362JKKqQPzu6KfSRC5Cpb0ZjL6qIVnqMFAE/asvKWKxOlOZMIw+ubm3q7mgWU2TZLAq9eErKO12jICE9Pl/A3Zg18PUQDJIPPeYJGKgCxSy+ZcdDg0epnAMReqcO4E2NCi8vOQ28zjec15aWSYZLgQjovYGvmXmbmaMfarTj06tMGoRm9e0lNF4CIq2unlOqiFXjm8aYYcuk++x43KUgdNHCkJj1YCy9pZTOWTTxJTHduteY0dZJlqJUYYWyhF6L+XXlsRMTwXI+e1kM+LyS86PezdBUiRTRbUzt5A3HG7glKBdhnMil17Z8ZK+BswIjwAMSMlKsCQtb4uGhiicDbBMl0m2UGPvN4UwDABS9ekKCVrfWiWYrg43aDc7F/7Xa0fXG91JET+jeDeteL7VJ282+kHPh27/l7wwvGDuL2GoAeAD42xuS65yMAO40xuXXxwRPVtla5iVjUkErrmhuy1AwJBYRMue0zv3M6Djx+l91/hdfVnx11Pl7YVIDqsruRefaVonUMKFcFVS5hoOCNXbCgFX5SeI00WRgI9PIV8PUvdB0bSEQQsFaoA5AXkFTXn+9n5qYnFqptAcCMa9Zg9BP5nhqXFrdnoNAQp2Ovao9G514ey5y6hhIfV39aYRuRrgzBIBZKV/JcEa9dvXSJh37YNbsIpRttkDpu6UTs/+0kz+tQZ/RhUCOdOgx6PC9A3LzTiJiwXxE2CTUmW2NqQ8QLVyc0HBXWmTvXZKn1aL9DvN+AmOxSvfwFzz5La3jz3EnpY9yJQrgAYkq11i4G4NXpGZw5SheWYc22NvhJ4TUAbJlNG7KyTEFSiIboaRsl2iYBsYQrVy0r7i1Dn8Lr5TopXViWUBtmmYN15J0jv/MvsV36j+ZdUg58n+0paVjBOIqibAD/C2CyMebZKIrKGIzd6zuNMa2ONBhLWUJRPT1UAuDXSZ2/lxaCN+WlEpy5TaNjemD/fTcCsNlL5vcviB+rLr0MR7AAfMNMwN4wGSfkx/VsxPoBWnBdCxhVL13ioT7s8caCSMSB6qBBcXgZDsqmgwcbmHIcykqHMEHWEL3zpRylyYTi0FkZEC+TAcRwPTXhhTV5Znb6O0MjTP0b6hID/092os6i6D4MWG+0xqOvlLo0Be+ZpREmSZggTVQ15jcBghcwGHluQ91lfmabUxvZjFLp84YrucOdawpGCa7e9UcyTsgXGVONguB+aG9EwGbUWmvYu6aVczcHG55aKIgZNxDrbmxaaa8tNt/ECPiWb6Lq7TUoWdJY6si7C7djz87GnkYGELuuH5jxMAoWtBISSOWDcxIQL2XFjdFh3IlyDbea9R42n9ZdiE2/Xdwad5T86YiDY1bWMSkH48rKjxtOMI6iqDGAhbCCQFPdc1J+qEuZIhkdOgFu5oZuFrHWqpENZmdZXOtyMCLdpGGdOVQV42CJgq9T5Ca0X2dA0Z5tOpCEmgPavoiUzt277ONjr2ovqldAvLTX2UhYZyZbTOvYhkFP2wTRZPL0UVXe70k4FYfZWZ7g6KtZaDmDuwkwvwyN0X/6iQloiNAtGohNUKl/ITRo16AKs0ldY0fZDqu367RGdk1bLNrKAOTc6sckvQA2mJduzPGyxVB/QVTughWTZrZpo082WRm0WPvWE+z+tds9D0ZhQarfTGOhZZWimrSA++0dxJHXISnpouSncNxewy/Yb2LtqQIIwOs7AJBEgAF9964sdH/mihofb9rWEr2uz8W22Rvxwk5bhx79RD4qH5zjBXBOlkDcv+Bqh/cAH3e9KAu7C7fjw7VtxB26YmExjn59PTafFhuf1gcDr2nW11MOxvsq/3HI74uiaCAsaKERgEeNMVPqsk+p6BlHAGYC+ICB2I0XAFzi/n8JgOfV8xdHdvSFdY5OqBcbY2YYY3obY3qP7JsXvpwe6ZEe6fEvG8aYlP8ONaIoagTgIQA/BXA8gGFOSrjWIxU0xfcA/AXAewCotHwzgP8D8BSAYwBshIW2/bMupqRs4O2aXeRlN0CcDTa+9GYAQNXzD6Pq7TVSOwRiDCeQ6G6s62zMHBpfejOq3lvuQ8RUJh4qaSXo2Cr6KsshbPiF2YlmPGmoFtEGnk1Tr74JzR3AX05rjYnQZw+ISwR8f/n4qQlZsGaqsaZJCitlKLkEZqbHsXKmQe/pvUUECLDiNrosdPC5Rz39XQACVeT51kgSjZTQTUndFGRji/tN1EmomqfLGizjADExYtPKHE99jJBDAAm1Wq5WNA1dr1y0jCVXZmG2zNIUt+M+8fp98c1OnliO5xIeOKNomB9XDgA8LQgAnkIhAFGm87JlV/7TWsTUDgashkYuDghh45VBc9Gl2W45d68MmoudjRph6LVZXj1XZ8OlG3O8bJr7qrNtZscA8Nbajug/9wxUPjgHL75peyrnnrkDe9ZW4ujX1wMA1n/r+HpBUzRucnTKmfGB/Ztr/L4oik6F1d8Z4B57+jy1GQ2C9LFziKVDE0iufd70chgAkNsmZmMBMd05MDLVZYgEeiksrI2CQmEjB4DH2CPbSDeHACRoK2gaN2U6eVNozQXA3pSlC8uk3lg1b740ykKYllfbdEtSfqY2X+X5kH1yDSitscs6IUsZrIuzoRjq7eplLLfTkDIACXrGRJvoAMPt9JAlsw4+mpijmGzU+tDu0WHdlAQMIDEI8nyGcEOvJu8IIJqBJ9oRgJQSSAbqNrVfgn8iEOOCAdecVPXYsJb9lx3tce6ZOzyIZIh35vkJ8eWecaqSfaXaGidIlt3C463esDHWY5k70MM/Nx59JdYPeUQMVSnwLhoRrmlYsjdbymA0YNABvUf7HTJZiDO2u/aeHl6Ak5uUC9xu/n2V+H6bbfLZAPC0aYGrumwWaGX3D95H1SGCY6ojsxbB+FDfF0XRUAADjTGXu8cjAHzXGDO21jtVm3T9X/kHYHR9bpf+zPRnpj/zq/WZ/6o/2N5WkfobrV4bClsn5uMRAB6s0/d80QeqDqKoPrdLf2b6M9Of+dX6zC/iD8CpsMAGPr4JVjit1p912AZeeqRHeqRHetQ43gbQPYqib0RR1ATAz2BBDLUemfW6W+mRHumRHl+hYYypiqJoLIAlsNC2WcaYv9XlsxpSMJ5Rz9ulPzP9menP/Gp95hcyjDGLACw60s9pEGiK9EiP9EiPr/pI14zTIz3SIz0awEgH4/RIj/RIjwYwvpCacRRFeQDOBnC0e2ozgBeMMR8E27E7+YkxZmkURRcBOA3AB7Ai9wc+x91Oj/RIj/T4l43PvWYcRdGNAIYB+DMAmnB1gg26fzZKZCOKoj/BThjNAZTBGqE+C+AM2H2/BPUw6HZdH5/1rxxRFLU2xnya4rZfumNKj6/GiKKoPVSiZozZ9kXuz+c2vgCQ9IcAGid5vgmA9cFz77p/M2GdqRu5xxFfO8x3tU7y3NeCv9awtlGtAHwt2LYRgJ8D+DWAfsFrt6j/Z7rtFgN41/29BOC/9bEC6ApgFoA7YSeWRwCsAfA0gC7B508B0Mb9vzeADQCKYXVAfliXYwLQAsDdAGYDuCj4jIeDx1/oMdXwe551iNeSXVNtkjwXwTrQnOf+vguXlATbHQMg1/2/CyzTqkcK+9gNwBAAxx/J8aR6TKkeT6rHBHsfRurxjwBcB+CnhzueI/2NAJwE4E3Yle9S97fWPdczle//d/77/L/QntzOSZ7vDGBd8Nwad3G0AlDBwAIgC1ZFTm+b0o0OK3b09+DvgPt3Q/CZjwJ4EsAvYO2mpqrXVqr/zwUwHUBf2Cy/k/v/dADz1HavARgDYII7tusAfB3AKADLg+9+T/3/VQCnuP8fh4CVlOoxAXjGnadzYIHpzwBoGh5PAzmm84K/IQC28rHa7kewK6wdAF6GmgCSHNNP3DXxkvttH4WdbIoB/ERtN8Gdu7UALnf/zgTwNwDjg898FfF1NwI22XgUVljr6toeT22OKdXjqc0xAVgNa6EGAL8E8DqAWwC8AuDuf+VvBOAdWF2HMDb0BbD6845Vn/ff5/+FVs2NF9AM98cLaGCw7bWwQXUjgHEAlsFmXu8BuC3YNqUbHTZYLAbwHfXc32vY13fV/zPdvj4LoCmAVeq1Dw9xvB+q/+v3fBxstyp4/AGATPf/N2s61tocE4B3gscTARTCZtJh4Pqij+kArIb2LACPub8K9+8std3bAL7t/j8UwHoAfQ/x/V2SHM83oCZ32ADVzJ2XCgBt3fP/AWBN8N41wb60dv9vHlw/KR1PbY4p1eOpzTEF/y8C0Exd/+8Gn1mvvxGClXHwXcU1vfZl+ftivtSiOPrCzqRD3P8b1bDtUQCOcv/PdT9mnyTb1eZG7wS7jJ4KIAdBRqy2W5vkudtgA9h69dybAM4HkBEc44UA/k89twJ2cjgFNkvo7Z7vluRCvxo2izgdwCRY8eofArgdwOwk+3XYY3LnKCN47lJ3o24Mnq/tMfUJjqn7kRyTO0fLAIxRz/09yTGtDh5/G8A62Ow/nGDW8xoJnm+ib3bE5bFGAEqDcxAG41UAjnb/fxVAlnrv32p7PLU5plSPpzbHBJsJ93D/X4w4S85Kcuz1+hsBuB/A/3PX2Gnu70L3XJ3Ed/6d/r7wHai3A6ll8HLvOQs26Gyt4fU5CLJ19/zlAA6ox10AzAOwHXaZut5d8PMAfENtd4a7CD8A8D3YMgG3PSfJ9+S7z1gFuxpYBKsglVB7S+WYANwDoH+S5wcisV7PYyp1x/RhHY7p7EMc00p1TD9Pdkywwf8a2CDXB8knmCIAHYLnOsEueSuC529y5/JGABe5vxvdczep7R6HLU89D1uumQ3gv2CX9U8lOZ6/AbgDVsf7ddgJ+xUA19f2eGpzTDUcz4TweGpzTABOgC1V/NH9fQSb6RYh6DP8i36jnwL4HwAvur//ATDoi4wtn9ffl4qBF0VRPmz98jjYZdU/ACyAXTJVqe3yYLu1/wfgIIBjjTFroigaaIxZHHxmHwDGGPO2U/AfCJsxJ6U/RlHU2v13mjFmeAr7vBC26VF9mO2+D3uxv2eMeTl47buwy9JdURQ1h52MesJmrXcZY8rdduMAPGeM+UcK+9UEFvXyCWzgHAigH2zgEVih2m6zsfDD/0q2nfrcrrCroa/Dnvt1AJ40xuw6xL4cDeA+2Ky7a/BafwDbjTGrg+dbAhhrjJkcPH887IQVwirfV9tkwq4KDID5sOf9IgAfA3jIGPNZku+6CPF1twnA88aYtUgyoig6CsDvkx3PYY4pF8BV+piiKPoWksNE3w/eGx7Td2F/t4Rjcu4VPwmOZ4kxpizZ8bj31OU3Sjier/L4UgXjmkYURZcZYx5z/x8H4CrYTO4kANcYY553r600xvRU77sNdqbOhM10vgubAfwY9uKc7LZLptJ0OoDlAGCMOas227lt3zLG9HH/v9zt8wLYm+RF40MA/wbgRGNFS2YA+Aw2Qz3DPX+e267cvfYRbHb0tDFmew3njLDCZgDKYWuLzyGAFaa6ndv2GgD/Cdv0GwSbwZUBOBfAlcaYgmT78mUdURS1N/UM26ol/LFBwQrdpHYT7OTSHnbiKIXN5qccajL4UowvOjX/PP6gGkuwS+Ns9/8usEuoa9zjVcH73oOtsTUHsAtAC/d8M/jNmZWwJY182NJIPoAt7v8/VNutSmW7cF9gGyC64RLWwHXzKayTvhN8fwZsQJ8JW1ZZDOthmBO8LyVYYarb6fPp/t8c1rgWsJCr8Ny3hEV+rAXwTwCfwk6gU+DgWSn87i8FjzW0b1jw2sM1bHc4CGAHWITJQ7DNsUmwMMCnAHRU24Xww6+hZkjlwOA8zHSf+SSA9uo1jSDqBdvsXo/k8MdkaKOEbWGv5VtgV4uHO7+9YZOTObArnVdgJ9e3AZystsuGLeP8DXbC3g5bSrs0+LwlsCWXDsY/vxMAvPyviA0N6e8L34F6O5AYCxv+vQdgn9rub8H7smED0lQkog1WJfu/e/yO+n8GLPLjFQAnueeS1c5S2s49v9rdqK2RCPsK9+VpWK9BwNb32EQ7DsDbarswUDeGXbLPhV1G6tdSghWmup177j3EULpW8FEuYXOophvzRn1jwpZjkv31ArAl+MyUoH2pbuceL4btV0xw19uNsIHpathSBberDaRS78ujsBjuzu7aWaDPp/r/qzg0VDBVtNHfAdwLW754y33nUTVco2/BrhyHwZYEh7rnzwDwhtruedhGcScA4wHcCtvgfQK2jMbt1iX7nsO99mX5+8J3oN4OxGZlJ7mLVv91gaVTc7vlcIFQPZcJ26w4GDz/fwCau//r7nPL8KZ0zxPR8CACmFdtt4PNmjbwZoXLsmAnj3eCbVvCNmg+cvt8wL3nf2HLFNxu1SH2qXnwOCVYYarbuW2vgQ1Yj8BmvJxA2gJ4Ldg2pRsTtu68HDbAhH97g/eF5y0ptC/V7cJzGv6W8Cfs2kAqD7Uv+jNrgyBKadvgu78P4GFY7PCrCCyQDnPs+rUQTfE27ykoxBJsA/4G+Nl/e9gJbmlN18OX5e8L34F6OxC7lPteDa89qf7fCUFnV70Wsuya1rBdG31TJXn9P6Fm/CPdLnhPcyg0Q/BaCwAnwmaF7ZO8flwtvytVWGFK27nXv+1ezzvMd6d0Y8Jm5t1r+Ix/BI9Tgvalup17frX6/53Ba3WFVG6CzSCvg53oNCNOl4hqAxVMaVskTzIawTZwHwuefwO25HU+7GR8jnv+h/Cz7dfh7k3YlZi2KdITaysAv4GdqHfClqc+cM99Ldm5+jL9feE7kP5L/yX7C27MfwY3Ziu13VAA36zhM84JHqcE7Ut1O/fcHXA9iOD5bgDm17Bfh4NU3hb8sV/QAcAfg23zkRz+mAx/fNhtYfVhUv2NToQtJ70EIM8F+DLYSes0td0JsCWNnQD+CpcUwK6IxgWfmQegf3hOkQRi+mX7+8J3IP2X/qvtH1x5o762+yI+E7YJ3KM+P/Pf5dhr2g62zLUOFjVUAoVTR5KM/cv295WAtqXHl2tEUfSxMeaY+tou/ZkN4zOjKHoPwKnGmN1RFHWBxUPPNsZMi6JolTHm5FS++991NCQPvPRIDxlRFL1b00uwteNabZf+zH+Lz8wwxuwGAGNMiSNxzY+iqLPb9ks90sE4PRrqaA9gAGydUY8ItiFU2+3Sn9nwP3NbFEUnGWPeAQCXIQ+GFSL6Dr7kIx2M06OhjoWwTZx3wheiKCqow3bpz2z4n3kxgCr9urEyBhdHUfSH8L1ftpGuGadHeqRHejSAkfFF70B6pEd6pEd6pINxeqRHeqRHgxjpYJwe6ZEe6dEARjoYp0d6pEd6NICRDsbpkR7pkR4NYPx/0QPhh7kupQMAAAAASUVORK5CYII=\n", 126 | "text/plain": [ 127 | "
" 128 | ] 129 | }, 130 | "metadata": { 131 | "needs_background": "light" 132 | }, 133 | "output_type": "display_data" 134 | } 135 | ], 136 | "source": [ 137 | "h_crosstalk = analysis.hamming_matrix(small_25mer_library)\n", 138 | "\n", 139 | "p = sns.heatmap(h_crosstalk)" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "## Importing \"off-the-shelf\" sequences from previous publications\n", 147 | "\n", 148 | "If you would like to use orthogonal sequence libraries from previous experimental publications, you can use the `io` module. Simply use the `load_library` function with the appropriate identifier tag. The following libraries are included:\n", 149 | "\n", 150 | "| identifier | # of seqs | seq length | original use case | ref |\n", 151 | "|------------|-----------|------------|-------------------|-----|\n", 152 | "| `kishi2018` | 50 | 9nt | PER primers | [Kishi et al, 2018](https://www.nature.com/articles/nchem.2872) |" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": 5, 158 | "metadata": {}, 159 | "outputs": [ 160 | { 161 | "name": "stdout", 162 | "output_type": "stream", 163 | "text": [ 164 | "Number of PER primers: 50\n" 165 | ] 166 | } 167 | ], 168 | "source": [ 169 | "PER_primers = io.load_library(\"kishi2018\")\n", 170 | "\n", 171 | "print(\"Number of PER primers: %d\" % len(PER_primers))" 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": null, 177 | "metadata": {}, 178 | "outputs": [], 179 | "source": [] 180 | } 181 | ], 182 | "metadata": { 183 | "kernelspec": { 184 | "display_name": "Python 3 (ipykernel)", 185 | "language": "python", 186 | "name": "python3" 187 | }, 188 | "language_info": { 189 | "codemirror_mode": { 190 | "name": "ipython", 191 | "version": 3 192 | }, 193 | "file_extension": ".py", 194 | "mimetype": "text/x-python", 195 | "name": "python", 196 | "nbconvert_exporter": "python", 197 | "pygments_lexer": "ipython3", 198 | "version": "3.9.5" 199 | } 200 | }, 201 | "nbformat": 4, 202 | "nbformat_minor": 4 203 | } 204 | -------------------------------------------------------------------------------- /docs/index.md: -------------------------------------------------------------------------------- 1 | ```{include} ../README.md 2 | ``` 3 | 4 | ```{toctree} 5 | :maxdepth: 1 6 | :hidden: 7 | 8 | example.ipynb 9 | changelog.md 10 | contributing.md 11 | conduct.md 12 | autoapi/index 13 | ``` -------------------------------------------------------------------------------- /docs/make.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | pushd %~dp0 4 | 5 | REM Command file for Sphinx documentation 6 | 7 | if "%SPHINXBUILD%" == "" ( 8 | set SPHINXBUILD=python -msphinx 9 | ) 10 | set SOURCEDIR=. 11 | set BUILDDIR=_build 12 | set SPHINXPROJ=seqwalk 13 | 14 | if "%1" == "" goto help 15 | 16 | %SPHINXBUILD% >NUL 2>NUL 17 | if errorlevel 9009 ( 18 | echo. 19 | echo.The Sphinx module was not found. Make sure you have Sphinx installed, 20 | echo.then set the SPHINXBUILD environment variable to point to the full 21 | echo.path of the 'sphinx-build' executable. Alternatively you may add the 22 | echo.Sphinx directory to PATH. 23 | echo. 24 | echo.If you don't have Sphinx installed, grab it from 25 | echo.http://sphinx-doc.org/ 26 | exit /b 1 27 | ) 28 | 29 | %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% 30 | goto end 31 | 32 | :help 33 | %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% 34 | 35 | :end 36 | popd 37 | -------------------------------------------------------------------------------- /docs/requirements.txt: -------------------------------------------------------------------------------- 1 | myst-nb 2 | sphinx-autoapi 3 | sphinx-rtd-theme 4 | seaborn 5 | matplotlib 6 | seqwalk==0.2.0 -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [tool.poetry] 2 | name = "seqwalk" 3 | version = "0.3.3" 4 | description = "Design orthogonal DNA sequences" 5 | authors = ["Gokul Gowri"] 6 | license = "MIT" 7 | readme = "README.md" 8 | 9 | [tool.poetry.dependencies] 10 | python = "^3.8" 11 | numpy = "^1.23.0" 12 | 13 | [tool.poetry.dev-dependencies] 14 | myst-nb = {version = "^0.16.0", python = "^3.9"} 15 | sphinx-autoapi = "^1.8.4" 16 | sphinx-rtd-theme = "^1.0.0" 17 | python-semantic-release = "^7.29.4" 18 | pytest = "^8.1.1" 19 | 20 | [build-system] 21 | requires = ["poetry-core>=1.0.0"] 22 | build-backend = "poetry.core.masonry.api" 23 | 24 | [tool.semantic_release] 25 | version_variable = "pyproject.toml:version" 26 | 27 | [tool.pytest.ini_options] 28 | pythonpath = "src" 29 | addopts = [ 30 | "--import-mode=importlib", 31 | ] -------------------------------------------------------------------------------- /src/seqwalk/__init__.py: -------------------------------------------------------------------------------- 1 | # read version from installed package 2 | from importlib.metadata import version 3 | __version__ = version("seqwalk") -------------------------------------------------------------------------------- /src/seqwalk/analysis.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | # import nupack as nu 3 | 4 | # RT = nu.Model(material="dna", celsius=22, sodium=1.0, magnesium=0.0) 5 | 6 | def hamming(seq1, seq2): 7 | """ 8 | compute hamming distance of two sequences 9 | 10 | Args: 11 | seq1: string 12 | seq2: string 13 | 14 | Returns: 15 | int 16 | hamming distance 17 | """ 18 | assert (len(seq1) == len(seq2)), "Sequences must have equal length" 19 | return sum(seq1[i] != seq2[i] for i in range(len(seq1))) 20 | 21 | def hamming_matrix(library): 22 | """ 23 | matrix where element i, j is H distance between seq i and seq j 24 | 25 | Args: 26 | library: list of strings of equal length 27 | 28 | Returns: 29 | NxN numpy array : hdists 30 | hamming distance "heatmap" 31 | """ 32 | 33 | hdists = np.zeros((len(library), len(library))) 34 | for i in range(len(library)): 35 | for j in range(i+1, len(library)): 36 | d = hamming(library[i], library[j]) 37 | hdists[i, j] = d 38 | hdists[j, i] = d 39 | return hdists 40 | 41 | # def np_crosstalk(seq1, seq2, model=RT, conc=1e-6, RCfree=False): 42 | # """ 43 | # compute thermodynamic binding probability 44 | 45 | # Args: 46 | # seq1: string (DNA seq) 47 | # seq2: string (DNA seq) 48 | # model: nupack conditions (default RT) 49 | # conc: molar concentrations of strands (default 1e-6) 50 | # RCfree: Bool, True if library is to be RC free 51 | 52 | # Returns: 53 | # float 54 | # equilibrium concentration of on target binding 55 | # """ 56 | # A = nu.Strand(seq1, name='A') 57 | # B = nu.Strand(seq2, name='B') 58 | # ct1 = nu.Complex([A, ~A], name="c1") 59 | # tRC = nu.Tube(strands={A: conc, ~B: conc, ~A: conc}, 60 | # name='t1', complexes=nu.SetSpec(max_size=2)) 61 | # tRCfree = nu.Tube(strands={A: conc,~A: conc, B: conc, ~B: conc}, 62 | # name='tRC', complexes=nu.SetSpec(max_size=2)) 63 | # tube_results = nu.tube_analysis(tubes=[[tRC, tRCfree][RCfree]], model=model) 64 | # if RCfree: 65 | # return [tube_results.tubes[tRCfree].complex_concentrations[c] for c in [ct1]] 66 | # return [tube_results.tubes[tRC].complex_concentrations[c] for c in [ct1]] 67 | 68 | # def nupack_matrix(library, model=RT, conc=1e-6, RCfree=False): 69 | # """ 70 | # matrix where element i, j is binding prob between seq i and seq j 71 | 72 | # Args: 73 | # library: list of seqs 74 | # model: nupack conditions (default RT) 75 | # conc: molar concentrations of strands (default 1e-6) 76 | # RCfree: Bool, True if library is to be RC free 77 | 78 | # Returns: 79 | # NxN numpy array : np_probs 80 | # binding probability heatmap 81 | # """ 82 | # np_probs = np.zeros((len(library), len(library))) 83 | # for i in range(len(library)): 84 | # for j in range(i+1, len(library)): 85 | # p = 1 - np_crosstalk(library[i], library[j], model, conc)[0]/conc 86 | # np_probs[i, j] += p 87 | # np_probs[j, i] += p 88 | # for i in range(len(library)): 89 | # np_probs[i, i] += np_crosstalk(library[i], library[j], model, conc)[0]/conc 90 | # return np_probs 91 | 92 | -------------------------------------------------------------------------------- /src/seqwalk/design.py: -------------------------------------------------------------------------------- 1 | from seqwalk.generation import * 2 | from seqwalk.filtering import * 3 | import math 4 | from warnings import warn 5 | 6 | 7 | def max_size(L, k, alphabet="ACT", RCfree=False, GClims=None, 8 | prevented_patterns=["AAAA", "CCCC", "GGGG", "TTTT"], 9 | verbose=True): 10 | """ 11 | design a max size library of length L sequences with SSM k 12 | 13 | Args: 14 | L: integer length of desired seqs 15 | k: SSM k value 16 | alphabet: string of allowable letters (default "ACT") 17 | RCfree: bool, True if orthogonality with RCs is required 18 | GClims: tuple of (GCmin, GCmax), allowable range of number of GC bases 19 | prevented_patterns: list of prevented patterns (default 4N) 20 | verbose: bool, True if print and warning statements are desired 21 | 22 | Returns: 23 | list of strings : seqs 24 | library of orthogonal sequences 25 | """ 26 | 27 | assert (L > k), "L must be greater than k" 28 | 29 | if RCfree and len(alphabet) == 4 and k % 2 == 1: 30 | if verbose: 31 | warn("Falling back to Hierholzer algorithm for odd-k, ACGT, RC free") 32 | seq = adapted_hierholzer(k, alphabet) 33 | seqs = partition_path(seq, L, k) 34 | if len(seqs) == 0: 35 | return seqs 36 | if GClims != None: 37 | GCmin, GCmax = GClims 38 | seqs = filter_gc(seqs, GCmin, GCmax) 39 | for pattern in prevented_patterns: 40 | seqs = filter_pattern(seqs, pattern) 41 | return seqs 42 | 43 | else: 44 | seq = "".join([alphabet[i-1] for i in simple_shift(k, len(alphabet))]) 45 | seqs = partition_path(seq[:-1], L, k) 46 | if RCfree: 47 | seqs = rc_hash_filtering(seqs, k) 48 | if len(seqs) == 0: 49 | return seqs 50 | if GClims != None: 51 | GCmin, GCmax = GClims 52 | seqs = filter_gc(seqs, GCmin, GCmax) 53 | for pattern in prevented_patterns: 54 | seqs = filter_pattern(seqs, pattern) 55 | return seqs 56 | 57 | 58 | def max_orthogonality(N, L, alphabet="ACT", RCfree=False, GClims=None, 59 | prevented_patterns=["AAAA", "CCCC", "GGGG","TTTT"], 60 | k_init=None, verbose=True): 61 | """ 62 | design a maximally orthogonal library of N length L sequences 63 | 64 | Args: 65 | N: minimum number of sequences in library 66 | L: integer length of desired seqs 67 | alphabet: string of allowable letters (default "ACT") 68 | RCfree: bool, True if orthogonality with RCs is required 69 | GClims: tuple of (GCmin, GCmax), allowable range of number of GC bases 70 | prevented_patterns: list of prevented patterns (default 4N) 71 | k_init: initial guess for SSM k value 72 | verbose: bool, True if print and warning statements are desired 73 | 74 | Returns: 75 | list of strings : seqs 76 | library of orthogonal sequences 77 | 78 | """ 79 | if k_init == None: 80 | k_init = max(int(math.log(N)/math.log(len(alphabet))), 2) 81 | 82 | while True: 83 | if verbose: 84 | print("Attempting SSM k=%d" %k_init) 85 | 86 | library = max_size(L, k_init, alphabet, RCfree, GClims, prevented_patterns, verbose) 87 | 88 | if len(library)>N: 89 | if verbose: 90 | print("Number of sequences: %d" % len(library)) 91 | print("SSM k value: %d" % k_init) 92 | return library 93 | 94 | k_init += 1 95 | -------------------------------------------------------------------------------- /src/seqwalk/filtering.py: -------------------------------------------------------------------------------- 1 | def rc(seq): 2 | """ 3 | reverse complement of DNA sequence 4 | 5 | Args: 6 | seq: string with letters in {A, C, G, T} 7 | 8 | Returns: 9 | string corresponding to reverse complement 10 | """ 11 | complement = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'} 12 | return "".join(complement.get(base, base) for base in reversed(seq)) 13 | 14 | def filter_rc_3letter(library, k): 15 | """ 16 | filter library to be RC free 17 | (Supplementary note X) 18 | 19 | Args: 20 | library: list of sequences 21 | k: SSM k value 22 | 23 | Returns: 24 | list of strings : filtered_library 25 | list of sequences without reverse complementary k-mers 26 | """ 27 | 28 | assert (k % 2 == 1), "SSM k must be odd for RC filtering" 29 | 30 | to_remove = [] 31 | middle = int((k+1)/2) 32 | 33 | for seq in library: 34 | for i in range(len(seq)-k+1): 35 | if sum([(s == "C" or s == "G") for s in seq[i:i+k]]) == 0 : 36 | if seq[i+middle-1] == "A": 37 | to_remove.append(seq) 38 | 39 | return [seq for seq in library if seq not in to_remove] 40 | 41 | def rc_hash_filtering(library, k): 42 | """ 43 | filter any library to be RC free, using simple hash approach 44 | could be slow for large libraries 45 | 46 | Args: 47 | library: list of sequences 48 | k: SSM k value 49 | 50 | Returns: 51 | list of strings : filtered_library 52 | list of sequences without reverse complementary k-mers 53 | """ 54 | seen_kmers = set() 55 | to_remove = set() 56 | 57 | for seq in library: 58 | bad_seq = False 59 | for i in range(len(seq)-k+1): 60 | 61 | if rc(seq[i:i+k]) in seq: 62 | bad_seq = True 63 | if rc(seq[i:i+k]) in seen_kmers: 64 | bad_seq = True 65 | if not bad_seq: 66 | for i in range(len(seq)-k+1): 67 | seen_kmers.add(seq[i:i+k]) 68 | else: 69 | to_remove.add(seq) 70 | 71 | return [seq for seq in library if seq not in to_remove] 72 | 73 | 74 | 75 | def filter_gc(library, gc_min, gc_max): 76 | """ 77 | filters library for sequences that have desired GC content 78 | 79 | Args: 80 | library: list of sequences in string representation 81 | gc_min: minimum number of GC bases (int) 82 | gc_max: maximimum number of GC bases (int) 83 | 84 | Returns: 85 | list of strings : filtered_library 86 | list of sequences in string representation 87 | """ 88 | 89 | assert (gc_min <= gc_max), "gc_min cannot be greater than gc_max" 90 | assert (gc_max <= len(library[0])), "gc_max cannot be greater than seq length" 91 | 92 | filtered_library = [] 93 | 94 | for seq in library: 95 | 96 | gc = sum([(s == "C" or s == "G") for s in seq]) 97 | 98 | if gc >= gc_min: 99 | if gc <= gc_max: 100 | filtered_library.append(seq) 101 | 102 | return filtered_library 103 | 104 | 105 | 106 | def filter_pattern(library, pattern): 107 | """ 108 | filters library to remove specific patterns 109 | 110 | Args: 111 | library: list of sequences in string representation 112 | pattern: sequence pattern to be prevented 113 | 114 | Returns: 115 | list of strings : filtered_library 116 | list of sequences in string representation 117 | """ 118 | 119 | filtered_library = [] 120 | 121 | for seq in library: 122 | if pattern not in seq: 123 | filtered_library.append(seq) 124 | 125 | return filtered_library 126 | 127 | 128 | -------------------------------------------------------------------------------- /src/seqwalk/generation.py: -------------------------------------------------------------------------------- 1 | from itertools import product 2 | import random 3 | 4 | 5 | 6 | def rc(seq): 7 | """ 8 | reverse complement of DNA sequence 9 | 10 | Args: 11 | seq: string with letters in {A, C, G, T} 12 | 13 | Returns: 14 | string corresponding to reverse complement 15 | """ 16 | complement = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'} 17 | return "".join(complement.get(base, base) for base in reversed(seq)) 18 | 19 | 20 | 21 | 22 | def partition_path(seq, L, k): 23 | """ 24 | partitions self-avoiding walk into appropriate length sequences 25 | 26 | Args: 27 | seq: self avoiding walk (string or list) 28 | L: length of desired sequences 29 | k: SSM k-value 30 | 31 | Returns: 32 | seqs: list of strings, each a length L seq 33 | """ 34 | seqs = [] 35 | for i in range(0, len(seq)-L+1, L-k+1): 36 | seqs.append(seq[i:i+L]) 37 | return seqs 38 | 39 | 40 | def is_necklace(seq): 41 | """ 42 | computes if a sequence is a necklace (as defined in Wong 2017) 43 | 44 | Args: 45 | seq: typically list of ints 46 | """ 47 | 48 | p = 1 49 | 50 | for i in range(1, len(seq)): 51 | if seq[i-p] < seq[i]: 52 | p = i + 1 53 | elif seq[i-p] > seq[i]: 54 | return False 55 | 56 | if (len(seq) % (p)) == 0: 57 | return True 58 | return False 59 | 60 | 61 | def f(seq, k): 62 | """ 63 | helper function defined in Wong 2017 64 | * note confusing notation switch 65 | 66 | Args: 67 | seq: list of ints 68 | k: alphabet length 69 | 70 | Returns: 71 | int corresponding to next element of seq 72 | """ 73 | 74 | p = 1 75 | 76 | if seq[0] == k: 77 | if sum(seq[1:]) == len(seq) - 1: 78 | return 1 79 | for i in range(0, k-1): 80 | if not is_necklace(seq[1:] + [k-i]): 81 | return k-i 82 | return 1 83 | 84 | elif is_necklace(seq[1:] + [(seq[0] % k) + 1]): 85 | return (seq[0] % k) + 1 86 | 87 | else: 88 | return seq[0] 89 | 90 | def simple_shift(n, k): 91 | """ 92 | simple shift rule from Wong 2017 93 | * note confusing notation switch 94 | 95 | Args: 96 | n: SSM k value 97 | k: alphabet size 98 | 99 | Returns: 100 | list of integers corresponding to H. path 101 | """ 102 | 103 | seq = [1]*n 104 | 105 | while True: 106 | seq.append(f(seq[-n:], k)) 107 | if seq[-n:] == seq[:n]: 108 | return seq 109 | 110 | 111 | 112 | 113 | def out_edges(v, alphabet): 114 | """ 115 | lists outedges for a node in a kmer graph 116 | 117 | Args: 118 | v: string corresponding to node 119 | alphabet: string containing all valid letters 120 | 121 | Returns: 122 | list of outedges represented as strings 123 | """ 124 | return [v + l for l in alphabet] 125 | 126 | 127 | def adapted_hierholzer(k, alphabet): 128 | """ 129 | finds RC-free path through 4-letter kmer graph using modified hierholzer 130 | (see Supplementary Note X) 131 | 132 | Args: 133 | k: SSM k (integer) 134 | alphabet: string containing all valid letters 135 | 136 | Returns: 137 | path: string corresponding to RC-free self-avoiding walk 138 | """ 139 | 140 | assert (k % 2 == 1), "k must be odd for adapted Hierholzer" 141 | 142 | # dictionary to store visited nodes 143 | # list of all nodes 144 | marked = {"".join(l) : 0 for l in product(alphabet, repeat=k)} 145 | nodes = ["".join(l) for l in product(alphabet, repeat=(k-1))] 146 | 147 | # initialize stack with a random starting node 148 | v_stack = [random.choice(nodes)] 149 | path = "" 150 | 151 | while len(v_stack) != 0: 152 | v = v_stack.pop() 153 | unmarked = [s for s in out_edges(v, alphabet) if not marked[s]] 154 | 155 | if unmarked == []: 156 | if path == "": 157 | path = v 158 | else: 159 | path = v[0] + path 160 | else: 161 | n_edge = random.choice(unmarked) 162 | v_stack.append(v) 163 | v_stack.append(n_edge[1:]) 164 | marked[n_edge] = 1 165 | marked[rc(n_edge)] = 1 166 | 167 | return path 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | -------------------------------------------------------------------------------- /src/seqwalk/io.py: -------------------------------------------------------------------------------- 1 | from importlib import resources 2 | 3 | def load_library(identifier): 4 | """ 5 | load a library of prebuilt sequences 6 | 7 | Args: 8 | identifier: string identifier of prebuilt library. listed on usage page 9 | 10 | Returns: 11 | list of strings : seqs 12 | library of orthogonal sequences 13 | 14 | """ 15 | 16 | with resources.path("seqwalk.prebuilt_libs", identifier+".txt") as f: 17 | seqs = [s.strip() for s in open(f, "r").readlines()] 18 | return seqs 19 | 20 | def write_library(seqs, filename): 21 | """ 22 | writes a list of sequences to file. contains no information beyond sequence 23 | 24 | Args: 25 | seqs: list of strings 26 | filename: string corresponding to filename to save to 27 | Returns: 28 | None 29 | """ 30 | f = open(filename, "w+") 31 | f.writelines([s + "\n" for s in seqs]) 32 | f.close() 33 | print("File written!") 34 | -------------------------------------------------------------------------------- /src/seqwalk/prebuilt_libs/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ggdna/seqwalk/6ba27c831268ffd57dd1ea731945095ecdefc9ab/src/seqwalk/prebuilt_libs/__init__.py -------------------------------------------------------------------------------- /src/seqwalk/prebuilt_libs/kishi2018.txt: -------------------------------------------------------------------------------- 1 | CCAATAATA 2 | ATAAACCTA 3 | CATCATCAT 4 | CAACTTAAC 5 | TCTAAAATC 6 | AATACTCTC 7 | TTATTCACT 8 | CTTTTTTTC 9 | CCTTCTATT 10 | CTCTACTAC 11 | TAAAAACTC 12 | AACTAATCT 13 | TTTCTCTTC 14 | AACATACTA 15 | TTCATTTAC 16 | ATCCTACAA 17 | CAATCAAAA 18 | CTTACAAAC 19 | ACAAATAAC 20 | TTTTCTACC 21 | CCCTTATTT 22 | TCTTTCATT 23 | TTCTTACTC 24 | CCATAAATC 25 | CATTTATCC 26 | ATACTTCAC 27 | TACCTCTAA 28 | CTCCTATTT 29 | CTATCCAAA 30 | ATCCCTATC 31 | TCATTACTT 32 | CTAAATCTC 33 | ACTACTTTT 34 | TACTATCTC 35 | ATATCTTCC 36 | ACTAACTAT 37 | TTATCAACT 38 | TAACTTTTC 39 | TCTTTACAT 40 | CCTATACTT 41 | TTCTTCTTT 42 | TCACATAAT 43 | ATCATATCA 44 | TTTCTATCT 45 | TCCTTTTAT 46 | TCTTATACC 47 | CATATTACA 48 | TTCCTAATC 49 | TAATCTACA 50 | TAAAAATCT 51 | -------------------------------------------------------------------------------- /tests/test_seqwalk.py: -------------------------------------------------------------------------------- 1 | from seqwalk import design 2 | 3 | def rc(seq): 4 | """ 5 | reverse complement of DNA sequence 6 | 7 | Args: 8 | seq: string with letters in {A, C, G, T} 9 | 10 | Returns: 11 | string corresponding to reverse complement 12 | """ 13 | complement = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'} 14 | return "".join(complement.get(base, base) for base in reversed(seq)) 15 | 16 | def check_ssm(library, k, RCfree=False): 17 | """ 18 | check a library to verify SSM is satisfied for length-k 19 | RCfree is boolean that is False if RC-tolerant 20 | returns True if SSM is satisfied 21 | """ 22 | 23 | seen_kmers = set() 24 | 25 | for seq in library: 26 | for i in range(len(seq)-k+1): 27 | 28 | if seq[i:i+k] in seen_kmers: 29 | return False 30 | seen_kmers.add(seq[i:i+k]) 31 | 32 | if RCfree: 33 | if rc(seq[i:i+k]) in seen_kmers: 34 | return False 35 | seen_kmers.add(rc(seq[i:i+k])) 36 | return True 37 | 38 | def check_pattern_free(library, pattern): 39 | 40 | for seq in library: 41 | if pattern in seq: 42 | return False 43 | return True 44 | 45 | def check_GC(library, GClims): 46 | 47 | for seq in library: 48 | GC_count = sum([i in ['G', 'C'] for i in seq]) 49 | if GC_count < GClims[0]: 50 | return False 51 | if GC_count > GClims[1]: 52 | return False 53 | return True 54 | 55 | 56 | def test_3letter_RC_tolerant(): 57 | ## test 3 letter no RCfree 58 | library = design.max_size(25, 6, alphabet="ACT") 59 | assert check_ssm(library, 6, RCfree=False), "SSM failed, 4 letter RC tolerant" 60 | library = design.max_size(25, 6, alphabet="TAC") 61 | assert check_ssm(library, 6, RCfree=False), "SSM failed, 4 letter RC tolerant" 62 | library = design.max_size(25, 6, alphabet="CAT") 63 | assert check_ssm(library, 6, RCfree=False), "SSM failed, 4 letter RC tolerant" 64 | 65 | def test_4letter_RC_tolerant(): 66 | ## test 4 letter no RCfree 67 | library = design.max_size(25, 6, alphabet="ACGT") 68 | assert check_ssm(library, 6, RCfree=False), "SSM failed, 4 letter RC tolerant" 69 | 70 | 71 | def test_3letter_RC_free(): 72 | ## test 3 letter filtered 73 | library = design.max_size(25, 4, alphabet="ACT", RCfree=True) 74 | assert check_ssm(library, 4, RCfree=True), "SSM failed, 3 letter RC free" 75 | library = design.max_size(25, 5, alphabet="ACT", RCfree=True) 76 | assert check_ssm(library, 5, RCfree=True), "SSM failed, 3 letter RC free" 77 | 78 | def test_4letter_RC_free(): 79 | library = design.max_size(25, 5, alphabet="ACTG", RCfree=True) 80 | assert check_ssm(library, 5, RCfree=True), "SSM failed, 3 letter RC free" 81 | library = design.max_size(25, 4, alphabet="ACT", RCfree=True) 82 | assert check_ssm(library, 4, RCfree=True), "SSM failed, 3 letter RC free" 83 | 84 | def test_pattern_free(): 85 | library = design.max_size(25, 5, alphabet="ACTG", RCfree=True) 86 | assert check_pattern_free(library, "AAAA"), "Failed pattern filtering" 87 | 88 | def test_GC_lims(): 89 | library = design.max_size(25, 5, alphabet="ACTG", GClims=(10, 20)) 90 | assert check_GC(library, (10, 20)), "Failed GC filtering" 91 | 92 | def test_max_orthogonality(): 93 | library = design.max_orthogonality(100, 10, RCfree=True) 94 | assert check_ssm(library, 6), "Failed max orthogonality" 95 | --------------------------------------------------------------------------------