diff --git a/.secrets.baseline b/.secrets.baseline index c0824519f8..e087d4429b 100644 --- a/.secrets.baseline +++ b/.secrets.baseline @@ -139,9 +139,9 @@ "filename": "pyproject.toml", "hashed_secret": "79670e9c9d1c7ea5b81a96a2053d81437712c78e", "is_verified": false, - "line_number": 47 + "line_number": 48 } ] }, - "generated_at": "2024-11-01T22:26:03Z" + "generated_at": "2025-01-06T19:45:47Z" } diff --git a/CODEOWNERS b/CODEOWNERS index 044d1864ad..774c575781 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -94,3 +94,5 @@ sub-packages/bionemo-geneformer @jstjohn @malcolmgreaves @skothenhill-nv sub-packages/bionemo-scdl @jstjohn @malcolmgreaves @polinabinder1 @skothenhill-nv sub-packages/bionemo-noodles @skothenhill-nv @malcolmgreaves @jstjohn @edawson @cspades + +sub-packages/bionemo-moco @nvdreidenbach @DejunL @dorotat-nv @guoqing-zhou @jstjohn @malcolmgreaves @pstjohn diff --git a/LICENSE/third_party.txt b/LICENSE/third_party.txt index 48ff51c986..3b361fbda9 100644 --- a/LICENSE/third_party.txt +++ b/LICENSE/third_party.txt @@ -590,3 +590,283 @@ https://github.com/aqlaboratory/openfold/blob/main/LICENSE WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. + +Copyright MDLM Codebase +https://github.com/kuleshov-group/mdlm/blob/master/LICENSE + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +Copyright MultiFlow Codebase +https://github.com/jasonkyuyim/multiflow/blob/main/LICENSE + +MIT License + +Copyright (c) 2024 Andrew Campbell, Jason Yim + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +Copyright TorchCFM Codebase +https://github.com/atong01/conditional-flow-matching/blob/main/LICENSE + +MIT License + +Copyright (c) 2023 Alexander Tong + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +Copyright Discrete Flow Models Codebase +https://github.com/andrew-cr/discrete_flow_models/blob/main/LICENSE + +MIT License + +Copyright (c) 2022 Andrej Karpathy + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/pyproject.toml b/pyproject.toml index c4b9f6e6af..340e9dd198 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -21,6 +21,7 @@ dependencies = [ 'bionemo-geneformer', 'bionemo-geometric', 'bionemo-llm', + 'bionemo-moco', 'bionemo-scdl', 'bionemo-size-aware-batching', 'bionemo-testing', @@ -56,6 +57,7 @@ bionemo-fw = { workspace = true } bionemo-geneformer = { workspace = true } bionemo-geometric = { workspace = true } bionemo-llm = { workspace = true } +bionemo-moco = { workspace = true } bionemo-noodles = { workspace = true } bionemo-scdl = { workspace = true } bionemo-size-aware-batching = { workspace = true } @@ -131,6 +133,7 @@ executionEnvironments = [ './sub-packages/bionemo-geneformer/src', './sub-packages/bionemo-geometric/src', './sub-packages/bionemo-llm/src', + './sub-packages/bionemo-moco/src', './sub-packages/bionemo-noodles/src', './sub-packages/bionemo-scdl/src', './sub-packages/bionemo-size-aware-batching/src', diff --git a/sub-packages/bionemo-moco/LICENSE b/sub-packages/bionemo-moco/LICENSE new file mode 120000 index 0000000000..61bc2cda7e --- /dev/null +++ b/sub-packages/bionemo-moco/LICENSE @@ -0,0 +1 @@ +../../LICENSE/license.txt \ No newline at end of file diff --git a/sub-packages/bionemo-moco/README.md b/sub-packages/bionemo-moco/README.md new file mode 100644 index 0000000000..a1c99eecb7 --- /dev/null +++ b/sub-packages/bionemo-moco/README.md @@ -0,0 +1,35 @@ +# Modular Co-Design (MoCo) Interpolants + +## Description +MoCo enables abstracted interpolants for building and sampling from a variety of popular generative model frameworks. Specifically, MoCo supports interpolants for both continuous and discrete data types. + +### Continuous Data Interpolants +MoCo currently supports the following continuous data interpolants: +- DDPM (Denoising Diffusion Probabilistic Models) +- VDM (Variational Diffusion Models) +- CFM (Conditional Flow Matching) + +### Discrete Data Interpolants +MoCo also supports the following discrete data interpolants: +- D3PM (Discrete Denoising Diffusion Probabilistic Models) +- MDLM (Markov Diffusion Language Models) +- DFM (Discrete Flow Matching) + +### Useful Abstractions +MoCo also provides useful wrappers for customizable time distributions and inference time schedules. + +### Extendible +If the desired interpolant or sampling method is not already supported, MoCo was designed to be easily extended. + +## Installation + For Conda environment setup, please refer to the `environment` directory for specific instructions. + +Once your environment is set up, you can install this project by running the following command: + +```bash +pip install -e . +``` +This will install the project in editable mode, allowing you to make changes and see them reflected immediately. + +## Examples +Please see examples of all interpolants in the [examples directory](./examples). diff --git a/sub-packages/bionemo-moco/VERSION b/sub-packages/bionemo-moco/VERSION new file mode 120000 index 0000000000..558194c5a5 --- /dev/null +++ b/sub-packages/bionemo-moco/VERSION @@ -0,0 +1 @@ +../../VERSION \ No newline at end of file diff --git a/sub-packages/bionemo-moco/documentation.md b/sub-packages/bionemo-moco/documentation.md new file mode 100644 index 0000000000..993f6002e8 --- /dev/null +++ b/sub-packages/bionemo-moco/documentation.md @@ -0,0 +1,4300 @@ +# Table of Contents + +* [moco](#moco) +* [bionemo.moco.distributions](#mocodistributions) +* [bionemo.moco.distributions.prior.distribution](#mocodistributionspriordistribution) +* [bionemo.moco.distributions.prior.discrete.uniform](#mocodistributionspriordiscreteuniform) +* [bionemo.moco.distributions.prior.discrete.custom](#mocodistributionspriordiscretecustom) +* [bionemo.moco.distributions.prior.discrete](#mocodistributionspriordiscrete) +* [bionemo.moco.distributions.prior.discrete.mask](#mocodistributionspriordiscretemask) +* [bionemo.moco.distributions.prior.continuous.harmonic](#mocodistributionspriorcontinuousharmonic) +* [bionemo.moco.distributions.prior.continuous](#mocodistributionspriorcontinuous) +* [bionemo.moco.distributions.prior.continuous.gaussian](#mocodistributionspriorcontinuousgaussian) +* [bionemo.moco.distributions.prior.continuous.utils](#mocodistributionspriorcontinuousutils) +* [bionemo.moco.distributions.prior](#mocodistributionsprior) +* [bionemo.moco.distributions.time.distribution](#mocodistributionstimedistribution) +* [bionemo.moco.distributions.time.uniform](#mocodistributionstimeuniform) +* [bionemo.moco.distributions.time.logit\_normal](#mocodistributionstimelogit_normal) +* [bionemo.moco.distributions.time](#mocodistributionstime) +* [bionemo.moco.distributions.time.beta](#mocodistributionstimebeta) +* [bionemo.moco.distributions.time.utils](#mocodistributionstimeutils) +* [bionemo.moco.schedules.discrete\_noise\_schedules](#mocoschedulesdiscrete_noise_schedules) +* [bionemo.moco.schedules.noise.continuous\_snr\_transforms](#mocoschedulesnoisecontinuous_snr_transforms) +* [bionemo.moco.schedules.noise.discrete\_noise\_schedules](#mocoschedulesnoisediscrete_noise_schedules) +* [bionemo.moco.schedules.noise](#mocoschedulesnoise) +* [bionemo.moco.schedules.noise.continuous\_noise\_transforms](#mocoschedulesnoisecontinuous_noise_transforms) +* [bionemo.moco.schedules](#mocoschedules) +* [bionemo.moco.schedules.utils](#mocoschedulesutils) +* [bionemo.moco.schedules.inference\_time\_schedules](#mocoschedulesinference_time_schedules) +* [bionemo.moco.interpolants.continuous\_time.discrete](#mocointerpolantscontinuous_timediscrete) +* [bionemo.moco.interpolants.continuous\_time.discrete.mdlm](#mocointerpolantscontinuous_timediscretemdlm) +* [bionemo.moco.interpolants.continuous\_time.discrete.discrete\_flow\_matching](#mocointerpolantscontinuous_timediscretediscrete_flow_matching) +* [bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport](#mocointerpolantscontinuous_timecontinuousoptimal_transport) +* [bionemo.moco.interpolants.continuous\_time.continuous](#mocointerpolantscontinuous_timecontinuous) +* [bionemo.moco.interpolants.continuous\_time.continuous.vdm](#mocointerpolantscontinuous_timecontinuousvdm) +* [bionemo.moco.interpolants.continuous\_time.continuous.continuous\_flow\_matching](#mocointerpolantscontinuous_timecontinuouscontinuous_flow_matching) +* [bionemo.moco.interpolants.continuous\_time](#mocointerpolantscontinuous_time) +* [bionemo.moco.interpolants](#mocointerpolants) +* [bionemo.moco.interpolants.discrete\_time.discrete.d3pm](#mocointerpolantsdiscrete_timediscreted3pm) +* [bionemo.moco.interpolants.discrete\_time.discrete](#mocointerpolantsdiscrete_timediscrete) +* [bionemo.moco.interpolants.discrete\_time.continuous.ddpm](#mocointerpolantsdiscrete_timecontinuousddpm) +* [bionemo.moco.interpolants.discrete\_time.continuous](#mocointerpolantsdiscrete_timecontinuous) +* [bionemo.moco.interpolants.discrete\_time](#mocointerpolantsdiscrete_time) +* [bionemo.moco.interpolants.discrete\_time.utils](#mocointerpolantsdiscrete_timeutils) +* [bionemo.moco.interpolants.base\_interpolant](#mocointerpolantsbase_interpolant) + + + +# moco + + + +# bionemo.moco.distributions + + + +# bionemo.moco.distributions.prior.distribution + + + +## PriorDistribution Objects + +```python +class PriorDistribution(ABC) +``` + +An abstract base class representing a prior distribution. + + + +#### sample + +```python +@abstractmethod +def sample(shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu") -> Tensor +``` + +Generates a specified number of samples from the time distribution. + +**Arguments**: + +- `shape` _Tuple_ - The shape of the samples to generate. +- `mask` _Optional[Tensor], optional_ - A tensor indicating which samples should be masked. Defaults to None. +- `device` _str, optional_ - The device on which to generate the samples. Defaults to "cpu". + + +**Returns**: + +- `Float` - A tensor of samples. + + + +## DiscretePriorDistribution Objects + +```python +class DiscretePriorDistribution(PriorDistribution) +``` + +An abstract base class representing a discrete prior distribution. + + + +#### \_\_init\_\_ + +```python +def __init__(num_classes: int, prior_dist: Tensor) +``` + +Initializes a DiscretePriorDistribution instance. + +**Arguments**: + +- `num_classes` _int_ - The number of classes in the discrete distribution. +- `prior_dist` _Tensor_ - The prior distribution over the classes. + + +**Returns**: + + None + + + +#### get\_num\_classes + +```python +def get_num_classes() -> int +``` + +Getter for num_classes. + + + +#### get\_prior\_dist + +```python +def get_prior_dist() -> Tensor +``` + +Getter for prior_dist. + + + +# bionemo.moco.distributions.prior.discrete.uniform + + + +## DiscreteUniformPrior Objects + +```python +class DiscreteUniformPrior(DiscretePriorDistribution) +``` + +A subclass representing a discrete uniform prior distribution. + + + +#### \_\_init\_\_ + +```python +def __init__(num_classes: int = 10) -> None +``` + +Initializes a discrete uniform prior distribution. + +**Arguments**: + +- `num_classes` _int_ - The number of classes in the discrete uniform distribution. Defaults to 10. + + + +#### sample + +```python +def sample(shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Tensor +``` + +Generates a specified number of samples. + +**Arguments**: + +- `shape` _Tuple_ - The shape of the samples to generate. +- `device` _str_ - cpu or gpu. +- `mask` _Optional[Tensor]_ - An optional mask to apply to the samples. Defaults to None. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + +- `Float` - A tensor of samples. + + + +# bionemo.moco.distributions.prior.discrete.custom + + + +## DiscreteCustomPrior Objects + +```python +class DiscreteCustomPrior(DiscretePriorDistribution) +``` + +A subclass representing a discrete custom prior distribution. + +This class allows for the creation of a prior distribution with a custom +probability mass function defined by the `prior_dist` tensor. For example if my data has 4 classes and I want [.3, .2, .4, .1] as the probabilities of the 4 classes. + + + +#### \_\_init\_\_ + +```python +def __init__(prior_dist: Tensor, num_classes: int = 10) -> None +``` + +Initializes a DiscreteCustomPrior distribution. + +**Arguments**: + +- `prior_dist` - A tensor representing the probability mass function of the prior distribution. +- `num_classes` - The number of classes in the prior distribution. Defaults to 10. + + +**Notes**: + + The `prior_dist` tensor should have a sum close to 1.0, as it represents a probability mass function. + + + +#### sample + +```python +def sample(shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Tensor +``` + +Samples from the discrete custom prior distribution. + +**Arguments**: + +- `shape` - A tuple specifying the shape of the samples to generate. +- `mask` - An optional tensor mask to apply to the samples, broadcastable to the sample shape. Defaults to None. +- `device` - The device on which to generate the samples, specified as a string or a :class:`torch.device`. Defaults to "cpu". +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + + A tensor of samples drawn from the prior distribution. + + + +# bionemo.moco.distributions.prior.discrete + + + +# bionemo.moco.distributions.prior.discrete.mask + + + +## DiscreteMaskedPrior Objects + +```python +class DiscreteMaskedPrior(DiscretePriorDistribution) +``` + +A subclass representing a Discrete Masked prior distribution. + + + +#### \_\_init\_\_ + +```python +def __init__(num_classes: int = 10, + mask_dim: Optional[int] = None, + inclusive: bool = True) -> None +``` + +Discrete Masked prior distribution. + +Theres 3 ways I can think of defining the problem that are hard to mesh together. + +1. [..., M, ....] inclusive anywhere --> exisiting LLM tokenizer where the mask has a specific location not at the end +2. [......, M] inclusive on end --> mask_dim = None with inclusive set to True default stick on the end +3. [.....] + [M] exclusive --> the number of classes representes the number of data classes and one wishes to add a separate MASK dimension. +- Note the pad_sample function is provided to help add this extra external dimension. + +**Arguments**: + +- `num_classes` _int_ - The number of classes in the distribution. Defaults to 10. +- `mask_dim` _int_ - The index for the mask token. Defaults to num_classes - 1 if inclusive or num_classes if exclusive. +- `inclusive` _bool_ - Whether the mask is included in the specified number of classes. + If True, the mask is considered as one of the classes. + If False, the mask is considered as an additional class. Defaults to True. + + + +#### sample + +```python +def sample(shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Tensor +``` + +Generates a specified number of samples. + +**Arguments**: + +- `shape` _Tuple_ - The shape of the samples to generate. +- `device` _str_ - cpu or gpu. +- `mask` _Optional[Tensor]_ - An optional mask to apply to the samples. Defaults to None. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + +- `Float` - A tensor of samples. + + + +#### is\_masked + +```python +def is_masked(sample: Tensor) -> Tensor +``` + +Creates a mask for whether a state is masked. + +**Arguments**: + +- `sample` _Tensor_ - The sample to check. + + +**Returns**: + +- `Tensor` - A float tensor indicating whether the sample is masked. + + + +#### pad\_sample + +```python +def pad_sample(sample: Tensor) -> Tensor +``` + +Pads the input sample with zeros along the last dimension. + +**Arguments**: + +- `sample` _Tensor_ - The input sample to be padded. + + +**Returns**: + +- `Tensor` - The padded sample. + + + +# bionemo.moco.distributions.prior.continuous.harmonic + + + +## LinearHarmonicPrior Objects + +```python +class LinearHarmonicPrior(PriorDistribution) +``` + +A subclass representing a Gaussian prior distribution. + + + +#### \_\_init\_\_ + +```python +def __init__(distance: Float = 3.8, + length: Optional[int] = None, + center: Bool = False, + rng_generator: Optional[torch.Generator] = None, + device: Union[str, torch.device] = "cpu") -> None +``` + +Gaussian prior distribution. + +**Arguments**: + +- `distance` _Float_ - RMS distance between adjacent points in the line graph. +- `length` _Optional[int]_ - The number of points in a batch. +- `center` _bool_ - Whether to center the samples around the mean. Defaults to False. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + + +#### sample + +```python +def sample(shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Tensor +``` + +Generates a specified number of samples from the Harmonic prior distribution. + +**Arguments**: + +- `shape` _Tuple_ - The shape of the samples to generate. +- `device` _str_ - cpu or gpu. +- `mask` _Optional[Tensor]_ - An optional mask to apply to the samples. Defaults to None. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + +- `Float` - A tensor of samples. + + + +# bionemo.moco.distributions.prior.continuous + + + +# bionemo.moco.distributions.prior.continuous.gaussian + + + +## GaussianPrior Objects + +```python +class GaussianPrior(PriorDistribution) +``` + +A subclass representing a Gaussian prior distribution. + + + +#### \_\_init\_\_ + +```python +def __init__(mean: Float = 0.0, + std: Float = 1.0, + center: Bool = False, + rng_generator: Optional[torch.Generator] = None) -> None +``` + +Gaussian prior distribution. + +**Arguments**: + +- `mean` _Float_ - The mean of the Gaussian distribution. Defaults to 0.0. +- `std` _Float_ - The standard deviation of the Gaussian distribution. Defaults to 1.0. +- `center` _bool_ - Whether to center the samples around the mean. Defaults to False. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + + +#### sample + +```python +def sample(shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Tensor +``` + +Generates a specified number of samples from the Gaussian prior distribution. + +**Arguments**: + +- `shape` _Tuple_ - The shape of the samples to generate. +- `device` _str_ - cpu or gpu. +- `mask` _Optional[Tensor]_ - An optional mask to apply to the samples. Defaults to None. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + +- `Float` - A tensor of samples. + + + +# bionemo.moco.distributions.prior.continuous.utils + + + +#### remove\_center\_of\_mass + +```python +def remove_center_of_mass(data: Tensor, + mask: Optional[Tensor] = None) -> Tensor +``` + +Calculates the center of mass (CoM) of the given data. + +**Arguments**: + +- `data` - The input data with shape (..., nodes, features). +- `mask` - An optional binary mask to apply to the data with shape (..., nodes) to mask out interaction from CoM calculation. Defaults to None. + + +**Returns**: + + The CoM of the data with shape (..., 1, features). + + + +# bionemo.moco.distributions.prior + + + +# bionemo.moco.distributions.time.distribution + + + +## TimeDistribution Objects + +```python +class TimeDistribution(ABC) +``` + +An abstract base class representing a time distribution. + +**Arguments**: + +- `discrete_time` _Bool_ - Whether the time is discrete. +- `nsteps` _Optional[int]_ - Number of nsteps for discretization. +- `min_t` _Optional[Float]_ - Min continuous time. +- `max_t` _Optional[Float]_ - Max continuous time. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + + +#### \_\_init\_\_ + +```python +def __init__(discrete_time: Bool = False, + nsteps: Optional[int] = None, + min_t: Optional[Float] = None, + max_t: Optional[Float] = None, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes a TimeDistribution object. + + + +#### sample + +```python +@abstractmethod +def sample(n_samples: int, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Float +``` + +Generates a specified number of samples from the time distribution. + +**Arguments**: + +- `n_samples` _int_ - The number of samples to generate. +- `device` _str_ - cpu or gpu. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + +- `Float` - A list or array of samples. + + + +## MixTimeDistribution Objects + +```python +class MixTimeDistribution() +``` + +An abstract base class representing a mixed time distribution. + +uniform_dist = UniformTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False) +beta_dist = BetaTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False, p1=2.0, p2=1.0) +mix_dist = MixTimeDistribution(uniform_dist, beta_dist, mix_fraction=0.5) + + + +#### \_\_init\_\_ + +```python +def __init__(dist1: TimeDistribution, dist2: TimeDistribution, + mix_fraction: Float) +``` + +Initializes a MixTimeDistribution object. + +**Arguments**: + +- `dist1` _TimeDistribution_ - The first time distribution. +- `dist2` _TimeDistribution_ - The second time distribution. +- `mix_fraction` _Float_ - The fraction of samples to draw from dist1. Must be between 0 and 1. + + + +#### sample + +```python +def sample(n_samples: int, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Float +``` + +Generates a specified number of samples from the mixed time distribution. + +**Arguments**: + +- `n_samples` _int_ - The number of samples to generate. +- `device` _str_ - cpu or gpu. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + +- `Float` - A list or array of samples. + + + +# bionemo.moco.distributions.time.uniform + + + +## UniformTimeDistribution Objects + +```python +class UniformTimeDistribution(TimeDistribution) +``` + +A class representing a uniform time distribution. + + + +#### \_\_init\_\_ + +```python +def __init__(min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes a UniformTimeDistribution object. + +**Arguments**: + +- `min_t` _Float_ - The minimum time value. +- `max_t` _Float_ - The maximum time value. +- `discrete_time` _Bool_ - Whether the time is discrete. +- `nsteps` _Optional[int]_ - Number of nsteps for discretization. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + + +#### sample + +```python +def sample(n_samples: int, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Generates a specified number of samples from the uniform time distribution. + +**Arguments**: + +- `n_samples` _int_ - The number of samples to generate. +- `device` _str_ - cpu or gpu. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + + A tensor of samples. + + + +## SymmetricUniformTimeDistribution Objects + +```python +class SymmetricUniformTimeDistribution(TimeDistribution) +``` + +A class representing a uniform time distribution. + + + +#### \_\_init\_\_ + +```python +def __init__(min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes a UniformTimeDistribution object. + +**Arguments**: + +- `min_t` _Float_ - The minimum time value. +- `max_t` _Float_ - The maximum time value. +- `discrete_time` _Bool_ - Whether the time is discrete. +- `nsteps` _Optional[int]_ - Number of nsteps for discretization. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + + +#### sample + +```python +def sample(n_samples: int, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Generates a specified number of samples from the uniform time distribution. + +**Arguments**: + +- `n_samples` _int_ - The number of samples to generate. +- `device` _str_ - cpu or gpu. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + + A tensor of samples. + + + +# bionemo.moco.distributions.time.logit\_normal + + + +## LogitNormalTimeDistribution Objects + +```python +class LogitNormalTimeDistribution(TimeDistribution) +``` + +A class representing a logit normal time distribution. + + + +#### \_\_init\_\_ + +```python +def __init__(p1: Float = 0.0, + p2: Float = 1.0, + min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes a BetaTimeDistribution object. + +**Arguments**: + +- `p1` _Float_ - The first shape parameter of the logit normal distribution i.e. the mean. +- `p2` _Float_ - The second shape parameter of the logit normal distribution i.e. the std. +- `min_t` _Float_ - The minimum time value. +- `max_t` _Float_ - The maximum time value. +- `discrete_time` _Bool_ - Whether the time is discrete. +- `nsteps` _Optional[int]_ - Number of nsteps for discretization. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + + +#### sample + +```python +def sample(n_samples: int, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Generates a specified number of samples from the uniform time distribution. + +**Arguments**: + +- `n_samples` _int_ - The number of samples to generate. +- `device` _str_ - cpu or gpu. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + + A tensor of samples. + + + +# bionemo.moco.distributions.time + + + +# bionemo.moco.distributions.time.beta + + + +## BetaTimeDistribution Objects + +```python +class BetaTimeDistribution(TimeDistribution) +``` + +A class representing a beta time distribution. + + + +#### \_\_init\_\_ + +```python +def __init__(p1: Float = 2.0, + p2: Float = 1.0, + min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes a BetaTimeDistribution object. + +**Arguments**: + +- `p1` _Float_ - The first shape parameter of the beta distribution. +- `p2` _Float_ - The second shape parameter of the beta distribution. +- `min_t` _Float_ - The minimum time value. +- `max_t` _Float_ - The maximum time value. +- `discrete_time` _Bool_ - Whether the time is discrete. +- `nsteps` _Optional[int]_ - Number of nsteps for discretization. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + + +#### sample + +```python +def sample(n_samples: int, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Generates a specified number of samples from the uniform time distribution. + +**Arguments**: + +- `n_samples` _int_ - The number of samples to generate. +- `device` _str_ - cpu or gpu. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + + A tensor of samples. + + + +# bionemo.moco.distributions.time.utils + + + +#### float\_time\_to\_index + +```python +def float_time_to_index(time: torch.Tensor, + num_time_steps: int) -> torch.Tensor +``` + +Convert a float time value to a time index. + +**Arguments**: + +- `time` _torch.Tensor_ - A tensor of float time values in the range [0, 1]. +- `num_time_steps` _int_ - The number of discrete time steps. + + +**Returns**: + +- `torch.Tensor` - A tensor of time indices corresponding to the input float time values. + + + +# bionemo.moco.schedules.discrete\_noise\_schedules + + + +## DiscreteNoiseSchedule Objects + +```python +class DiscreteNoiseSchedule(ABC) +``` + +A base class for discrete schedules. No matter the definition this class returns objects using a unified direction of time. + + + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, direction: TimeDirection) +``` + +Initialize the DiscreteNoiseSchedule. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None, uses the value from initialization. +- `direction` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + + + +#### generate\_schedule + +```python +def generate_schedule(nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None) -> Tensor +``` + +Public wrapper to generate the time schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None, uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). +- `synchronize` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + + +**Returns**: + +- `Tensor` - A tensor of time steps + 1 unless full is False. + + + +#### calculate\_derivative + +```python +def calculate_derivative( + nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None) -> Tensor +``` + +Calculate the time derivative of the schedule. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None, uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). +- `synchronize` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + + +**Returns**: + +- `Tensor` - A tensor representing the time derivative of the schedule. + + +**Raises**: + +- `NotImplementedError` - If the derivative calculation is not implemented for this schedule. + + + +## DiscreteCosineNoiseSchedule Objects + +```python +class DiscreteCosineNoiseSchedule(DiscreteNoiseSchedule) +``` + +A cosine noise schedule for Diffusion Models. + + + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, nu: Float = 1.0, s: Float = 0.008) +``` + +Initialize the CosineNoiseSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `nu` _Optional[Float]_ - Hyperparameter for the cosine schedule (default is 1.0). +- `s` _Optional[Float]_ - Hyperparameter for the cosine schedule (default is 0.008). + + + +# bionemo.moco.schedules.noise.continuous\_snr\_transforms + + + +#### log + +```python +def log(t, eps=1e-20) +``` + +Compute the natural logarithm of a tensor, clamping values to avoid numerical instability. + +**Arguments**: + +- `t` _Tensor_ - The input tensor. +- `eps` _float, optional_ - The minimum value to clamp the input tensor (default is 1e-20). + + +**Returns**: + +- `Tensor` - The natural logarithm of the input tensor. + + + +## ContinuousSNRTransform Objects + +```python +class ContinuousSNRTransform(ABC) +``` + +A base class for continuous SNR schedules. + + + +#### \_\_init\_\_ + +```python +def __init__(direction: TimeDirection) +``` + +Initialize the DiscreteNoiseSchedule. + +**Arguments**: + +- `direction` _TimeDirection_ - required this defines in which direction the scheduler was built + + + +#### calculate\_log\_snr + +```python +def calculate_log_snr(t: Tensor, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None) -> Tensor +``` + +Public wrapper to generate the time schedule as a tensor. + +**Arguments**: + +- `t` _Tensor_ - The input tensor representing the time steps, with values ranging from 0 to 1. +- `device` _Optional[str]_ - The device to place the schedule on. Defaults to "cpu". +- `synchronize` _optional[TimeDirection]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one. Defaults to None. + + +**Returns**: + +- `Tensor` - A tensor representing the log signal-to-noise (SNR) ratio for the given time steps. + + + +#### log\_snr\_to\_alphas\_sigmas + +```python +def log_snr_to_alphas_sigmas(log_snr: Tensor) -> Tuple[Tensor, Tensor] +``` + +Converts log signal-to-noise ratio (SNR) to alpha and sigma values. + +**Arguments**: + +- `log_snr` _Tensor_ - The input log SNR tensor. + + +**Returns**: + + tuple[Tensor, Tensor]: A tuple containing the squared root of alpha and sigma values. + + + +#### derivative + +```python +def derivative(t: Tensor, func: Callable) -> Tensor +``` + +Compute derivative of a function, it supports bached single variable inputs. + +**Arguments**: + +- `t` _Tensor_ - time variable at which derivatives are taken +- `func` _Callable_ - function for derivative calculation + + +**Returns**: + +- `Tensor` - derivative that is detached from the computational graph + + + +#### calculate\_general\_sde\_terms + +```python +def calculate_general_sde_terms(t) +``` + +Compute the general SDE terms for a given time step t. + +**Arguments**: + +- `t` _Tensor_ - The input tensor representing the time step. + + +**Returns**: + + tuple[Tensor, Tensor]: A tuple containing the drift term f_t and the diffusion term g_t_2. + + +**Notes**: + + This method computes the drift and diffusion terms of the general SDE, which can be used to simulate the stochastic process. + The drift term represents the deterministic part of the process, while the diffusion term represents the stochastic part. + + + +#### calculate\_beta + +```python +def calculate_beta(t) +``` + +Compute the drift coefficient for the OU process of the form $dx = -\frac{1}{2} \beta(t) x dt + sqrt(beta(t)) dw_t$. + +beta = d/dt log(alpha**2) = 2 * 1/alpha * d/dt(alpha) + +**Arguments**: + +- `t` _Union[float, Tensor]_ - t in [0, 1] + + +**Returns**: + +- `Tensor` - beta(t) + + + +#### calculate\_alpha\_log\_snr + +```python +def calculate_alpha_log_snr(log_snr: Tensor) -> Tensor +``` + +Compute alpha values based on the log SNR. + +**Arguments**: + +- `log_snr` _Tensor_ - The input tensor representing the log signal-to-noise ratio. + + +**Returns**: + +- `Tensor` - A tensor representing the alpha values for the given log SNR. + + +**Notes**: + + This method computes alpha values as the square root of the sigmoid of the log SNR. + + + +#### calculate\_alpha\_t + +```python +def calculate_alpha_t(t: Tensor) -> Tensor +``` + +Compute alpha values based on the log SNR schedule. + +**Arguments**: + +- `t` _Tensor_ - The input tensor representing the time steps. + + +**Returns**: + +- `Tensor` - A tensor representing the alpha values for the given time steps. + + +**Notes**: + + This method computes alpha values as the square root of the sigmoid of the log SNR. + + + +## CosineSNRTransform Objects + +```python +class CosineSNRTransform(ContinuousSNRTransform) +``` + +A cosine SNR schedule. + +**Arguments**: + +- `nu` _Optional[Float]_ - Hyperparameter for the cosine schedule exponent (default is 1.0). +- `s` _Optional[Float]_ - Hyperparameter for the cosine schedule shift (default is 0.008). + + + +#### \_\_init\_\_ + +```python +def __init__(nu: Float = 1.0, s: Float = 0.008) +``` + +Initialize the CosineNoiseSchedule. + + + +## LinearSNRTransform Objects + +```python +class LinearSNRTransform(ContinuousSNRTransform) +``` + +A Linear SNR schedule. + + + +#### \_\_init\_\_ + +```python +def __init__(min_value: Float = 1.0e-4) +``` + +Initialize the Linear SNR Transform. + +**Arguments**: + +- `min_value` _Float_ - min vaue of SNR defaults to 1.e-4. + + + +## LinearLogInterpolatedSNRTransform Objects + +```python +class LinearLogInterpolatedSNRTransform(ContinuousSNRTransform) +``` + +A Linear Log space interpolated SNR schedule. + + + +#### \_\_init\_\_ + +```python +def __init__(min_value: Float = -7.0, max_value=13.5) +``` + +Initialize the Linear log space interpolated SNR Schedule from Chroma. + +**Arguments**: + +- `min_value` _Float_ - The min log SNR value. +- `max_value` _Float_ - the max log SNR value. + + + +# bionemo.moco.schedules.noise.discrete\_noise\_schedules + + + +## DiscreteNoiseSchedule Objects + +```python +class DiscreteNoiseSchedule(ABC) +``` + +A base class for discrete noise schedules. + + + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, direction: TimeDirection) +``` + +Initialize the DiscreteNoiseSchedule. + +**Arguments**: + +- `nsteps` _int_ - number of discrete steps. +- `direction` _TimeDirection_ - required this defines in which direction the scheduler was built + + + +#### generate\_schedule + +```python +def generate_schedule(nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None) -> Tensor +``` + +Generate the noise schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None, uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). +- `synchronize` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one (default is None). + + + +#### calculate\_derivative + +```python +def calculate_derivative( + nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None) -> Tensor +``` + +Calculate the time derivative of the schedule. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None, uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). +- `synchronize` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one (default is None). + + +**Returns**: + +- `Tensor` - A tensor representing the time derivative of the schedule. + + +**Raises**: + +- `NotImplementedError` - If the derivative calculation is not implemented for this schedule. + + + +## DiscreteCosineNoiseSchedule Objects + +```python +class DiscreteCosineNoiseSchedule(DiscreteNoiseSchedule) +``` + +A cosine discrete noise schedule. + + + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, nu: Float = 1.0, s: Float = 0.008) +``` + +Initialize the CosineNoiseSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of discrete steps. +- `nu` _Optional[Float]_ - Hyperparameter for the cosine schedule exponent (default is 1.0). +- `s` _Optional[Float]_ - Hyperparameter for the cosine schedule shift (default is 0.008). + + + +## DiscreteLinearNoiseSchedule Objects + +```python +class DiscreteLinearNoiseSchedule(DiscreteNoiseSchedule) +``` + +A linear discrete noise schedule. + + + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, beta_start: Float = 1e-4, beta_end: Float = 0.02) +``` + +Initialize the CosineNoiseSchedule. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None, uses the value from initialization. +- `beta_start` _Optional[int]_ - starting beta value. Defaults to 1e-4. +- `beta_end` _Optional[int]_ - end beta value. Defaults to 0.02. + + + +# bionemo.moco.schedules.noise + + + +# bionemo.moco.schedules.noise.continuous\_noise\_transforms + + + +## ContinuousExpNoiseTransform Objects + +```python +class ContinuousExpNoiseTransform(ABC) +``` + +A base class for continuous schedules. + +alpha = exp(- sigma) where 1 - alpha controls the masking fraction. + + + +#### \_\_init\_\_ + +```python +def __init__(direction: TimeDirection) +``` + +Initialize the DiscreteNoiseSchedule. + +**Arguments**: + + direction : TimeDirection, required this defines in which direction the scheduler was built + + + +#### calculate\_sigma + +```python +def calculate_sigma(t: Tensor, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None) -> Tensor +``` + +Calculate the sigma for the given time steps. + +**Arguments**: + +- `t` _Tensor_ - The input tensor representing the time steps, with values ranging from 0 to 1. +- `device` _Optional[str]_ - The device to place the schedule on. Defaults to "cpu". +- `synchronize` _optional[TimeDirection]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one. Defaults to None. + + +**Returns**: + +- `Tensor` - A tensor representing the sigma values for the given time steps. + + +**Raises**: + +- `ValueError` - If the input time steps exceed the maximum allowed value of 1. + + + +#### sigma\_to\_alpha + +```python +def sigma_to_alpha(sigma: Tensor) -> Tensor +``` + +Converts sigma to alpha values by alpha = exp(- sigma). + +**Arguments**: + +- `sigma` _Tensor_ - The input sigma tensor. + + +**Returns**: + +- `Tensor` - A tensor containing the alpha values. + + + +## CosineExpNoiseTransform Objects + +```python +class CosineExpNoiseTransform(ContinuousExpNoiseTransform) +``` + +A cosine Exponential noise schedule. + + + +#### \_\_init\_\_ + +```python +def __init__(eps: Float = 1.0e-3) +``` + +Initialize the CosineNoiseSchedule. + +**Arguments**: + +- `eps` _Float_ - small number to prevent numerical issues. + + + +#### d\_dt\_sigma + +```python +def d_dt_sigma(t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor +``` + +Compute the derivative of sigma with respect to time. + +**Arguments**: + +- `t` _Tensor_ - The input tensor representing the time steps. +- `device` _Optional[str]_ - The device to place the schedule on. Defaults to "cpu". + + +**Returns**: + +- `Tensor` - A tensor representing the derivative of sigma with respect to time. + + +**Notes**: + + The derivative of sigma as a function of time is given by: + + d/dt sigma(t) = d/dt (-log(cos(t * pi / 2) + eps)) + + Using the chain rule, we get: + + d/dt sigma(t) = (-1 / (cos(t * pi / 2) + eps)) * (-sin(t * pi / 2) * pi / 2) + + This is the derivative that is computed and returned by this method. + + + +## LogLinearExpNoiseTransform Objects + +```python +class LogLinearExpNoiseTransform(ContinuousExpNoiseTransform) +``` + +A log linear exponential schedule. + + + +#### \_\_init\_\_ + +```python +def __init__(eps: Float = 1.0e-3) +``` + +Initialize the CosineNoiseSchedule. + +**Arguments**: + +- `eps` _Float_ - small value to prevent numerical issues. + + + +#### d\_dt\_sigma + +```python +def d_dt_sigma(t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor +``` + +Compute the derivative of sigma with respect to time. + +**Arguments**: + +- `t` _Tensor_ - The input tensor representing the time steps. +- `device` _Optional[str]_ - The device to place the schedule on. Defaults to "cpu". + + +**Returns**: + +- `Tensor` - A tensor representing the derivative of sigma with respect to time. + + + +# bionemo.moco.schedules + + + +# bionemo.moco.schedules.utils + + + +## TimeDirection Objects + +```python +class TimeDirection(Enum) +``` + +Enum for the direction of the noise schedule. + + + +#### UNIFIED + +Noise(0) --> Data(1) + + + +#### DIFFUSION + +Noise(1) --> Data(0) + + + +# bionemo.moco.schedules.inference\_time\_schedules + + + +## InferenceSchedule Objects + +```python +class InferenceSchedule(ABC) +``` + +A base class for inference time schedules. + + + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu") +``` + +Initialize the InferenceSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `min_t` _Float_ - minimum time value defaults to 0. +- `padding` _Float_ - padding time value defaults to 0. +- `dilation` _Float_ - dilation time value defaults to 0 ie the number of replicates. +- `direction` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + + +#### generate\_schedule + +```python +@abstractmethod +def generate_schedule( + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Generate the time schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optioanl[int]_ - Number of time steps. If None, uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + + +#### pad\_time + +```python +def pad_time(n_samples: int, + scalar_time: Float, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Creates a tensor of shape (n_samples,) filled with a scalar time value. + +**Arguments**: + +- `n_samples` _int_ - The desired dimension of the output tensor. +- `scalar_time` _Float_ - The scalar time value to fill the tensor with. + device (Optional[Union[str, torch.device]], optional): + The device to place the tensor on. Defaults to None, which uses the default device. + + +**Returns**: + +- `Tensor` - A tensor of shape (n_samples,) filled with the scalar time value. + + + +## ContinuousInferenceSchedule Objects + +```python +class ContinuousInferenceSchedule(InferenceSchedule) +``` + +A base class for continuous time inference schedules. + + + +#### discretize + +```python +def discretize(nsteps: Optional[int] = None, + schedule: Optional[Tensor] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Discretize the time schedule into a list of time deltas. + +**Arguments**: + +- `nsteps` _Optioanl[int]_ - Number of time steps. If None, uses the value from initialization. +- `schedule` _Optional[Tensor]_ - Time scheudle if None will generate it with generate_schedule. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + +**Returns**: + +- `Tensor` - A tensor of time deltas. + + + +## DiscreteInferenceSchedule Objects + +```python +class DiscreteInferenceSchedule(InferenceSchedule) +``` + +A base class for discrete time inference schedules. + + + +#### discretize + +```python +def discretize(nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Discretize the time schedule into a list of time deltas. + +**Arguments**: + +- `nsteps` _Optioanl[int]_ - Number of time steps. If None, uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + +**Returns**: + +- `Tensor` - A tensor of time deltas. + + + +## DiscreteLinearInferenceSchedule Objects + +```python +class DiscreteLinearInferenceSchedule(DiscreteInferenceSchedule) +``` + +A linear time schedule for discrete time inference. + + + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu") +``` + +Initialize the DiscreteLinearInferenceSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `min_t` _Float_ - minimum time value defaults to 0. +- `padding` _Float_ - padding time value defaults to 0. +- `dilation` _Float_ - dilation time value defaults to 0 ie the number of replicates. +- `direction` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + + +#### generate\_schedule + +```python +def generate_schedule( + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Generate the linear time schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + +**Returns**: + +- `Tensor` - A tensor of time steps. +- `Tensor` - A tensor of time steps. + + + +## LinearInferenceSchedule Objects + +```python +class LinearInferenceSchedule(ContinuousInferenceSchedule) +``` + +A linear time schedule for continuous time inference. + + + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu") +``` + +Initialize the LinearInferenceSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `min_t` _Float_ - minimum time value defaults to 0. +- `padding` _Float_ - padding time value defaults to 0. +- `dilation` _Float_ - dilation time value defaults to 0 ie the number of replicates. +- `direction` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + + +#### generate\_schedule + +```python +def generate_schedule( + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Generate the linear time schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + +**Returns**: + +- `Tensor` - A tensor of time steps. +- `Tensor` - A tensor of time steps. + + + +## PowerInferenceSchedule Objects + +```python +class PowerInferenceSchedule(ContinuousInferenceSchedule) +``` + +A power time schedule for inference, where time steps are generated by raising a uniform schedule to a specified power. + + + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + exponent: Float = 1.0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu") +``` + +Initialize the PowerInferenceSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `min_t` _Float_ - minimum time value defaults to 0. +- `padding` _Float_ - padding time value defaults to 0. +- `dilation` _Float_ - dilation time value defaults to 0 ie the number of replicates. +- `exponent` _Float_ - Power parameter defaults to 1.0. +- `direction` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + + +#### generate\_schedule + +```python +def generate_schedule( + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Generate the power time schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + +**Returns**: + +- `Tensor` - A tensor of time steps. +- `Tensor` - A tensor of time steps. + + + +## LogInferenceSchedule Objects + +```python +class LogInferenceSchedule(ContinuousInferenceSchedule) +``` + +A log time schedule for inference, where time steps are generated by taking the logarithm of a uniform schedule. + + + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + exponent: Float = -2.0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu") +``` + +Initialize the LogInferenceSchedule. + +Returns a log space time schedule. + +Which for 100 steps with default parameters is: +tensor([0.0000, 0.0455, 0.0889, 0.1303, 0.1699, 0.2077, 0.2439, 0.2783, 0.3113, +0.3427, 0.3728, 0.4015, 0.4288, 0.4550, 0.4800, 0.5039, 0.5266, 0.5484, +0.5692, 0.5890, 0.6080, 0.6261, 0.6434, 0.6599, 0.6756, 0.6907, 0.7051, +0.7188, 0.7319, 0.7444, 0.7564, 0.7678, 0.7787, 0.7891, 0.7991, 0.8086, +0.8176, 0.8263, 0.8346, 0.8425, 0.8500, 0.8572, 0.8641, 0.8707, 0.8769, +0.8829, 0.8887, 0.8941, 0.8993, 0.9043, 0.9091, 0.9136, 0.9180, 0.9221, +0.9261, 0.9299, 0.9335, 0.9369, 0.9402, 0.9434, 0.9464, 0.9492, 0.9520, +0.9546, 0.9571, 0.9595, 0.9618, 0.9639, 0.9660, 0.9680, 0.9699, 0.9717, +0.9734, 0.9751, 0.9767, 0.9782, 0.9796, 0.9810, 0.9823, 0.9835, 0.9847, +0.9859, 0.9870, 0.9880, 0.9890, 0.9899, 0.9909, 0.9917, 0.9925, 0.9933, +0.9941, 0.9948, 0.9955, 0.9962, 0.9968, 0.9974, 0.9980, 0.9985, 0.9990, +0.9995]) + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `min_t` _Float_ - minimum time value defaults to 0. +- `padding` _Float_ - padding time value defaults to 0. +- `dilation` _Float_ - dilation time value defaults to 0 ie the number of replicates. +- `exponent` _Float_ - log space exponent parameter defaults to -2.0. The lower number the more aggressive the acceleration of 0 to 0.9 will be thus having more steps from 0.9 to 1.0. +- `direction` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + + +#### generate\_schedule + +```python +def generate_schedule( + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Generate the log time schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + + +# bionemo.moco.interpolants.continuous\_time.discrete + + + +# bionemo.moco.interpolants.continuous\_time.discrete.mdlm + + + +## MDLM Objects + +```python +class MDLM(Interpolant) +``` + +A Masked discrete Diffusion Language Model (MDLM) interpolant. + +------- + +**Examples**: + +```python +>>> import torch +>>> from bionemo.bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior +>>> from bionemo.bionemo.moco.distributions.time.uniform import UniformTimeDistribution +>>> from bionemo.bionemo.moco.interpolants.continuous_time.discrete.mdlm import MDLM +>>> from bionemo.bionemo.moco.schedules.noise.continuous_noise_transforms import CosineExpNoiseTransform +>>> from bionemo.bionemo.moco.schedules.inference_time_schedules import LinearTimeSchedule + + +mdlm = MDLM( + time_distribution = UniformTimeDistribution(discrete_time = False,...), + prior_distribution = DiscreteMaskedPrior(...), + noise_schedule = CosineExpNoiseTransform(...), + ) +model = Model(...) + +# Training +for epoch in range(1000): + data = data_loader.get(...) + time = mdlm.sample_time(batch_size) + xt = mdlm.interpolate(data, time) + + logits = model(xt, time) + loss = mdlm.loss(logits, data, xt, time) + loss.backward() + +# Generation +x_pred = mdlm.sample_prior(data.shape) +schedule = LinearTimeSchedule(...) +inference_time = schedule.generate_schedule() +dts = schedue.discreteize() +for t, dt in zip(inference_time, dts): + time = torch.full((batch_size,), t) + logits = model(x_pred, time) + x_pred = mdlm.step(logits, time, x_pred, dt) +return x_pred + +``` + + + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: DiscreteMaskedPrior, + noise_schedule: ContinuousExpNoiseTransform, + device: str = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Initialize the Masked Discrete Language Model (MDLM) interpolant. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The distribution governing the time variable in the diffusion process. +- `prior_distribution` _DiscreteMaskedPrior_ - The prior distribution over the discrete token space, including masked tokens. +- `noise_schedule` _ContinuousExpNoiseTransform_ - The noise schedule defining the noise intensity as a function of time. +- `device` _str, optional_ - The device to use for computations. Defaults to "cpu". +- `rng_generator` _Optional[torch.Generator], optional_ - The random number generator for reproducibility. Defaults to None. + + + +#### interpolate + +```python +def interpolate(data: Tensor, t: Tensor) +``` + +Get x(t) with given time t from noise and data. + +**Arguments**: + +- `data` _Tensor_ - target discrete ids +- `t` _Tensor_ - time + + + +#### forward\_process + +```python +def forward_process(data: Tensor, t: Tensor) -> Tensor +``` + +Apply the forward process to the data at time t. + +**Arguments**: + +- `data` _Tensor_ - target discrete ids +- `t` _Tensor_ - time + + +**Returns**: + +- `Tensor` - x(t) after applying the forward process + + + +#### loss + +```python +def loss(logits: Tensor, + target: Tensor, + xt: Tensor, + time: Tensor, + mask: Optional[Tensor] = None, + use_weight=True) +``` + +Calculate the cross-entropy loss between the model prediction and the target output. + +The loss is calculated between the batch x node x class logits and the target batch x node, +considering the current state of the discrete sequence `xt` at time `time`. + +If `use_weight` is True, the loss is weighted by the reduced form of the MDLM time weight for continuous NELBO, +as specified in equation 11 of https://arxiv.org/pdf/2406.07524. This weight is proportional to the derivative +of the noise schedule with respect to time, and is used to emphasize the importance of accurate predictions at +certain times in the diffusion process. + +**Arguments**: + +- `logits` _Tensor_ - The predicted output from the model, with shape batch x node x class. +- `target` _Tensor_ - The target output for the model prediction, with shape batch x node. +- `xt` _Tensor_ - The current state of the discrete sequence, with shape batch x node. +- `time` _Tensor_ - The time at which the loss is calculated. +- `mask` _Optional[Tensor], optional_ - The mask for the data point. Defaults to None. +- `use_weight` _bool, optional_ - Whether to use the MDLM time weight for the loss. Defaults to True. + + +**Returns**: + +- `Tensor` - The calculated loss batch tensor. + + + +#### step + +```python +def step(logits, t, xt, dt) -> Tensor +``` + +Perform a single step of MDLM DDPM step. + +**Arguments**: + +- `logits` _Tensor_ - The input logits. +- `t` _float_ - The current time step. +- `xt` _Tensor_ - The current state. +- `dt` _float_ - The time step increment. + + +**Returns**: + +- `Tensor` - The updated state. + + + +#### step\_confidence + +```python +def step_confidence(logits: Tensor, + xt: Tensor, + curr_step: int, + num_steps: int, + logit_temperature: float = 1.0, + randomness: float = 1.0, + confidence_temperature: float = 1.0) -> Tensor +``` + +Update the input sequence xt by sampling from the predicted logits and adding Gumbel noise. + +Method taken from GenMol Seul et al. + +**Arguments**: + +- `logits` - Predicted logits +- `xt` - Input sequence +- `curr_step` - Current step +- `num_steps` - Total number of steps +- `logit_temperature` - Temperature for softmax over logits +- `randomness` - Scale for Gumbel noise +- `confidence_temperature` - Temperature for Gumbel confidence + + +**Returns**: + + Updated input sequence xt + + + +#### step\_argmax + +```python +def step_argmax(model_out: Tensor) +``` + +Returns the index of the maximum value in the last dimension of the model output. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. + + +**Returns**: + +- `Tensor` - The index of the maximum value in the last dimension of the model output. + + + +#### calculate\_score + +```python +def calculate_score(logits, x, t) +``` + +Returns score of the given sample x at time t with the corresponding model output logits. + +**Arguments**: + +- `logits` _Tensor_ - The output of the model. +- `x` _Tensor_ - The current data point. +- `t` _Tensor_ - The current time. + + +**Returns**: + +- `Tensor` - The score defined in Appendix C.3 Equation 76 of MDLM. + + + +# bionemo.moco.interpolants.continuous\_time.discrete.discrete\_flow\_matching + + + +## DiscreteFlowMatcher Objects + +```python +class DiscreteFlowMatcher(Interpolant) +``` + +A Discrete Flow Model (DFM) interpolant. + + + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: DiscretePriorDistribution, + device: str = "cpu", + eps: Float = 1e-5, + rng_generator: Optional[torch.Generator] = None) +``` + +Initialize the DFM interpolant. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The time distribution for the diffusion process. +- `prior_distribution` _DiscretePriorDistribution_ - The prior distribution for the discrete masked tokens. +- `device` _str, optional_ - The device to use for computations. Defaults to "cpu". +- `eps` - small Float to prevent dividing by zero. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + + +#### interpolate + +```python +def interpolate(data: Tensor, t: Tensor, noise: Tensor) +``` + +Get x(t) with given time t from noise and data. + +**Arguments**: + +- `data` _Tensor_ - target discrete ids +- `t` _Tensor_ - time +- `noise` - tensor noise ids + + + +#### loss + +```python +def loss(logits: Tensor, + target: Tensor, + time: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + use_weight: Bool = False) +``` + +Calculate the cross-entropy loss between the model prediction and the target output. + +The loss is calculated between the batch x node x class logits and the target batch x node. +If using a masked prior please pass in the correct mask to calculate loss values on only masked states. +i.e. mask = data_mask * is_masked_state which is calculated with self.prior_dist.is_masked(xt)) + +If `use_weight` is True, the loss is weighted by 1/(1-t) defined in equation 24 in Appndix C. of https://arxiv.org/pdf/2402.04997 + +**Arguments**: + +- `logits` _Tensor_ - The predicted output from the model, with shape batch x node x class. +- `target` _Tensor_ - The target output for the model prediction, with shape batch x node. +- `time` _Tensor_ - The time at which the loss is calculated. +- `mask` _Optional[Tensor], optional_ - The mask for the data point. Defaults to None. +- `use_weight` _bool, optional_ - Whether to use the DFM time weight for the loss. Defaults to True. + + +**Returns**: + +- `Tensor` - The calculated loss batch tensor. + + + +#### step + +```python +def step(logits: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor | float, + temperature: Float = 1.0, + stochasticity: Float = 1.0) -> Tensor +``` + +Perform a single step of DFM euler updates. + +**Arguments**: + +- `logits` _Tensor_ - The input logits. +- `t` _Tensor_ - The current time step. +- `xt` _Tensor_ - The current state. +- `dt` _Tensor | float_ - The time step increment. +- `temperature` _Float, optional_ - The temperature for the softmax calculation. Defaults to 1.0. +- `stochasticity` _Float, optional_ - The stochasticity value for the step calculation. Defaults to 1.0. + + +**Returns**: + +- `Tensor` - The updated state. + + + +#### step\_purity + +```python +def step_purity(logits: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor | float, + temperature: Float = 1.0, + stochasticity: Float = 1.0) -> Tensor +``` + +Perform a single step of purity sampling. + +https://github.com/jasonkyuyim/multiflow/blob/6278899970523bad29953047e7a42b32a41dc813/multiflow/data/interpolant.py#L346 +Here's a high-level overview of what the function does: +TODO: check if the -1e9 and 1e-9 are small enough or using torch.inf would be better + +1. Preprocessing: +Checks if dt is a float and converts it to a tensor if necessary. +Pads t and dt to match the shape of xt. +Checks if the mask_index is valid (i.e., within the range of possible discrete values). +2. Masking: +Sets the logits corresponding to the mask_index to a low value (-1e9) to effectively mask out those values. +Computes the softmax probabilities of the logits. +Sets the probability of the mask_index to a small value (1e-9) to avoid numerical issues. +3.Purity sampling: +Computes the maximum log probabilities of the softmax distribution. +Computes the indices of the top-number_to_unmask samples with the highest log probabilities. +Uses these indices to sample new values from the original distribution. +4. Unmasking and updating: +Creates a mask to select the top-number_to_unmask samples. +Uses this mask to update the current state xt with the new samples. +5. Re-masking: +Generates a new mask to randomly re-mask some of the updated samples. +Applies this mask to the updated state xt. + +**Arguments**: + +- `logits` _Tensor_ - The input logits. +- `t` _Tensor_ - The current time step. +- `xt` _Tensor_ - The current state. +- `dt` _Tensor_ - The time step increment. +- `temperature` _Float, optional_ - The temperature for the softmax calculation. Defaults to 1.0. +- `stochasticity` _Float, optional_ - The stochasticity value for the step calculation. Defaults to 1.0. + + +**Returns**: + +- `Tensor` - The updated state. + + + +# bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport + + + +## OTSampler Objects + +```python +class OTSampler() +``` + +Sampler for Exact Mini-batch Optimal Transport Plan. + +OTSampler implements sampling coordinates according to an OT plan (wrt squared Euclidean cost) +with different implementations of the plan calculation. Code is adapted from https://github.com/atong01/conditional-flow-matching/blob/main/torchcfm/optimal_transport.py + + + +#### \_\_init\_\_ + +```python +def __init__(method: str, + device: Union[str, torch.device] = "cpu", + num_threads: int = 1) -> None +``` + +Initialize the OTSampler class. + +**Arguments**: + +- `method` _str_ - Choose which optimal transport solver you would like to use. Currently only support exact OT solvers (pot.emd). +- `device` _Union[str, torch.device], optional_ - The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". +- `num_threads` _Union[int, str], optional_ - Number of threads to use for OT solver. If "max", uses the maximum number of threads. Default is 1. + + +**Raises**: + +- `ValueError` - If the OT solver is not documented. +- `NotImplementedError` - If the OT solver is not implemented. + + + +#### to\_device + +```python +def to_device(device: str) +``` + +Moves all internal tensors to the specified device and updates the `self.device` attribute. + +**Arguments**: + +- `device` _str_ - The device to move the tensors to (e.g. "cpu", "cuda:0"). + + +**Notes**: + + This method is used to transfer the internal state of the OTSampler to a different device. + It updates the `self.device` attribute to reflect the new device and moves all internal tensors to the specified device. + + + +#### sample\_map + +```python +def sample_map(pi: Tensor, + batch_size: int, + replace: Bool = False) -> Tuple[Tensor, Tensor] +``` + +Draw source and target samples from pi $(x,z) \sim \pi$. + +**Arguments**: + +- `pi` _Tensor_ - shape (bs, bs), the OT matrix between noise and data in minibatch. +- `batch_size` _int_ - The batch size of the minibatch. +- `replace` _bool_ - sampling w/ or w/o replacement from the OT plan, default to False. + + +**Returns**: + +- `Tuple` - tuple of 2 tensors, represents the indices of noise and data samples from pi. + + + +#### get\_ot\_matrix + +```python +def get_ot_matrix(x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None) -> Tensor +``` + +Compute the OT matrix between a source and a target minibatch. + +**Arguments**: + +- `x0` _Tensor_ - shape (bs, *dim), noise from source minibatch. +- `x1` _Tensor_ - shape (bs, *dim), data from source minibatch. +- `mask` _Optional[Tensor], optional_ - mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + +**Returns**: + +- `p` _Tensor_ - shape (bs, bs), the OT matrix between noise and data in minibatch. + + + +#### apply\_ot + +```python +def apply_ot( + x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None, + replace: Bool = False, + preserve: Optional[Literal["noise", "x0", "data", "x1"]] = "x0" +) -> Tuple[Tensor, Tensor, Optional[Tensor]] +``` + +Sample indices for noise and data in minibatch according to OT plan. + +Compute the OT plan $\pi$ (wrt squared Euclidean cost) between a source and a target +minibatch and draw source and target samples from pi $(x,z) \sim \pi$. + +**Arguments**: + +- `x0` _Tensor_ - shape (bs, *dim), noise from source minibatch. +- `x1` _Tensor_ - shape (bs, *dim), data from source minibatch. +- `mask` _Optional[Tensor], optional_ - mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. +- `replace` _bool_ - sampling w/ or w/o replacement from the OT plan, default to False. +- `preserve` _str_ - Optional Literal string to sort either x1 or x0 based on the input. + + +**Returns**: + +- `Tuple` - tuple of 2 tensors or 3 tensors if mask is used, represents the noise (plus mask) and data samples following OT plan pi. + + + +# bionemo.moco.interpolants.continuous\_time.continuous + + + +# bionemo.moco.interpolants.continuous\_time.continuous.vdm + + + +## VDM Objects + +```python +class VDM(Interpolant) +``` + +A Variational Diffusion Models (VDM) interpolant. + +------- + +**Examples**: + +```python +>>> import torch +>>> from bionemo.bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +>>> from bionemo.bionemo.moco.distributions.time.uniform import UniformTimeDistribution +>>> from bionemo.bionemo.moco.interpolants.discrete_time.continuous.vdm import VDM +>>> from bionemo.bionemo.moco.schedules.noise.continuous_snr_transforms import CosineSNRTransform +>>> from bionemo.bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule + + +vdm = VDM( + time_distribution = UniformTimeDistribution(...), + prior_distribution = GaussianPrior(...), + noise_schedule = CosineSNRTransform(...), + ) +model = Model(...) + +# Training +for epoch in range(1000): + data = data_loader.get(...) + time = vdm.sample_time(batch_size) + noise = vdm.sample_prior(data.shape) + xt = vdm.interpolate(data, noise, time) + + x_pred = model(xt, time) + loss = vdm.loss(x_pred, data, time) + loss.backward() + +# Generation +x_pred = vdm.sample_prior(data.shape) +for t in LinearInferenceSchedule(...).generate_schedule(): + time = torch.full((batch_size,), t) + x_hat = model(x_pred, time) + x_pred = vdm.step(x_hat, time, x_pred) +return x_pred + +``` + + + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + noise_schedule: ContinuousSNRTransform, + prediction_type: Union[PredictionType, str] = PredictionType.DATA, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes the DDPM interpolant. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The distribution of time steps, used to sample time points for the diffusion process. +- `prior_distribution` _PriorDistribution_ - The prior distribution of the variable, used as the starting point for the diffusion process. +- `noise_schedule` _ContinuousSNRTransform_ - The schedule of noise, defining the amount of noise added at each time step. +- `prediction_type` _PredictionType, optional_ - The type of prediction, either "data" or another type. Defaults to "data". +- `device` _str, optional_ - The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + + +#### interpolate + +```python +def interpolate(data: Tensor, t: Tensor, noise: Tensor) +``` + +Get x(t) with given time t from noise and data. + +**Arguments**: + +- `data` _Tensor_ - target +- `t` _Tensor_ - time +- `noise` _Tensor_ - noise from prior() + + + +#### forward\_process + +```python +def forward_process(data: Tensor, t: Tensor, noise: Optional[Tensor] = None) +``` + +Get x(t) with given time t from noise and data. + +**Arguments**: + +- `data` _Tensor_ - target +- `t` _Tensor_ - time +- `noise` _Tensor, optional_ - noise from prior(). Defaults to None. + + + +#### process\_data\_prediction + +```python +def process_data_prediction(model_output: Tensor, sample, t) +``` + +Converts the model output to a data prediction based on the prediction type. + +This conversion stems from the Progressive Distillation for Fast Sampling of Diffusion Models https://arxiv.org/pdf/2202.00512. +Given the model output and the sample, we convert the output to a data prediction based on the prediction type. +The conversion formulas are as follows: +- For "noise" prediction type: `pred_data = (sample - noise_scale * model_output) / data_scale` +- For "data" prediction type: `pred_data = model_output` +- For "v_prediction" prediction type: `pred_data = data_scale * sample - noise_scale * model_output` + +**Arguments**: + +- `model_output` _Tensor_ - The output of the model. +- `sample` _Tensor_ - The input sample. +- `t` _Tensor_ - The time step. + + +**Returns**: + + The data prediction based on the prediction type. + + +**Raises**: + +- `ValueError` - If the prediction type is not one of "noise", "data", or "v_prediction". + + + +#### process\_noise\_prediction + +```python +def process_noise_prediction(model_output: Tensor, sample: Tensor, t: Tensor) +``` + +Do the same as process_data_prediction but take the model output and convert to nosie. + +**Arguments**: + +- `model_output` _Tensor_ - The output of the model. +- `sample` _Tensor_ - The input sample. +- `t` _Tensor_ - The time step. + + +**Returns**: + + The input as noise if the prediction type is "noise". + + +**Raises**: + +- `ValueError` - If the prediction type is not "noise". + + + +#### step + +```python +def step(model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0) +``` + +Do one step integration. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. +- `xt` _Tensor_ - The current data point. +- `t` _Tensor_ - The current time step. +- `dt` _Tensor_ - The time step increment. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the data. Defaults to None. +- `center` _bool_ - Whether to center the data. Defaults to False. +- `temperature` _Float_ - The temperature parameter for low temperature sampling. Defaults to 1.0. + + +**Notes**: + + The temperature parameter controls the trade off between diversity and sample quality. + Decreasing the temperature sharpens the sampling distribtion to focus on more likely samples. + The impact of low temperature sampling must be ablated analytically. + + + +#### score + +```python +def score(x_hat: Tensor, xt: Tensor, t: Tensor) +``` + +Converts the data prediction to the estimated score function. + +**Arguments**: + +- `x_hat` _tensor_ - The predicted data point. +- `xt` _Tensor_ - The current data point. +- `t` _Tensor_ - The time step. + + +**Returns**: + + The estimated score function. + + + +#### step\_ddim + +```python +def step_ddim(model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + eta: Float = 0.0, + center: Bool = False) +``` + +Do one step of DDIM sampling. + +From the ddpm equations alpha_bar = alpha**2 and 1 - alpha**2 = sigma**2 + +**Arguments**: + +- `model_out` _Tensor_ - output of the model +- `t` _Tensor_ - current time step +- `xt` _Tensor_ - current data point +- `dt` _Tensor_ - The time step increment. +- `mask` _Optional[Tensor], optional_ - mask for the data point. Defaults to None. +- `eta` _Float, optional_ - DDIM sampling parameter. Defaults to 0.0. +- `center` _Bool, optional_ - whether to center the data point. Defaults to False. + + + +#### set\_loss\_weight\_fn + +```python +def set_loss_weight_fn(fn: Callable) +``` + +Sets the loss_weight attribute of the instance to the given function. + +**Arguments**: + +- `fn` - The function to set as the loss_weight attribute. This function should take three arguments: raw_loss, t, and weight_type. + + + +#### loss\_weight + +```python +def loss_weight(raw_loss: Tensor, + t: Tensor, + weight_type: str, + dt: Float = 0.001) -> Tensor +``` + +Calculates the weight for the loss based on the given weight type. + +This function computes the loss weight according to the specified `weight_type`. +The available weight types are: +- "ones": uniform weight of 1.0 +- "data_to_noise": derived from Equation (9) of https://arxiv.org/pdf/2202.00512 +- "variational_objective": based on the variational objective, see https://arxiv.org/pdf/2202.00512 + +**Arguments**: + +- `raw_loss` _Tensor_ - The raw loss calculated from the model prediction and target. +- `t` _Tensor_ - The time step. +- `weight_type` _str_ - The type of weight to use. Can be "ones", "data_to_noise", or "variational_objective". +- `dt` _Float, optional_ - The time step increment. Defaults to 0.001. + + +**Returns**: + +- `Tensor` - The weight for the loss. + + +**Raises**: + +- `ValueError` - If the weight type is not recognized. + + + +#### loss + +```python +def loss(model_pred: Tensor, + target: Tensor, + t: Tensor, + dt: Optional[Float] = 0.001, + mask: Optional[Tensor] = None, + weight_type: str = "ones") +``` + +Calculates the loss given the model prediction, target, and time. + +**Arguments**: + +- `model_pred` _Tensor_ - The predicted output from the model. +- `target` _Tensor_ - The target output for the model prediction. +- `t` _Tensor_ - The time at which the loss is calculated. +- `dt` _Optional[Float], optional_ - The time step increment. Defaults to 0.001. +- `mask` _Optional[Tensor], optional_ - The mask for the data point. Defaults to None. +- `weight_type` _str, optional_ - The type of weight to use for the loss. Can be "ones", "data_to_noise", or "variational_objective". Defaults to "ones". + + +**Returns**: + +- `Tensor` - The calculated loss batch tensor. + + + +#### step\_hybrid\_sde + +```python +def step_hybrid_sde(model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0, + equilibrium_rate: Float = 0.0) -> Tensor +``` + +Do one step integration of Hybrid Langevin-Reverse Time SDE. + +See section B.3 page 37 https://www.biorxiv.org/content/10.1101/2022.12.01.518682v1.full.pdf. +and https://github.com/generatebio/chroma/blob/929407c605013613941803c6113adefdccaad679/chroma/layers/structure/diffusion.py#L730 + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. +- `xt` _Tensor_ - The current data point. +- `t` _Tensor_ - The current time step. +- `dt` _Tensor_ - The time step increment. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the data. Defaults to None. +- `center` _bool, optional_ - Whether to center the data. Defaults to False. +- `temperature` _Float, optional_ - The temperature parameter for low temperature sampling. Defaults to 1.0. +- `equilibrium_rate` _Float, optional_ - The rate of Langevin equilibration. Scales the amount of Langevin dynamics per unit time. Best values are in the range [1.0, 5.0]. Defaults to 0.0. + + +**Notes**: + + For all step functions that use the SDE formulation its important to note that we are moving backwards in time which corresponds to an apparent sign change. + A clear example can be seen in slide 29 https://ernestryu.com/courses/FM/diffusion1.pdf. + + + +#### step\_ode + +```python +def step_ode(model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0) -> Tensor +``` + +Do one step integration of ODE. + +See section B page 36 https://www.biorxiv.org/content/10.1101/2022.12.01.518682v1.full.pdf. +and https://github.com/generatebio/chroma/blob/929407c605013613941803c6113adefdccaad679/chroma/layers/structure/diffusion.py#L730 + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. +- `xt` _Tensor_ - The current data point. +- `t` _Tensor_ - The current time step. +- `dt` _Tensor_ - The time step increment. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the data. Defaults to None. +- `center` _bool, optional_ - Whether to center the data. Defaults to False. +- `temperature` _Float, optional_ - The temperature parameter for low temperature sampling. Defaults to 1.0. + + + +# bionemo.moco.interpolants.continuous\_time.continuous.continuous\_flow\_matching + + + +## OptimalTransportType Objects + +```python +class OptimalTransportType(Enum) +``` + +An enumeration representing the type ofOptimal Transport that can be used in Continuous Flow Matching. + +- **EXACT**: Standard mini batch optimal transport defined in https://arxiv.org/pdf/2302.00482. +- **EQUIVARIANT**: Adding roto/translation optimization to mini batch OT see https://arxiv.org/pdf/2306.15030 https://arxiv.org/pdf/2312.07168 4.2. +- **KABSCH**: Simple Kabsch alignment between each data and noise point, No permuation # https://arxiv.org/pdf/2410.22388 Sec 3.2 + +These prediction types can be used to train neural networks for specific tasks, such as denoising, image synthesis, or time-series forecasting. + + + +## ContinuousFlowMatcher Objects + +```python +class ContinuousFlowMatcher(Interpolant) +``` + +A Continuous Flow Matching interpolant. + +------- + +**Examples**: + +```python +>>> import torch +>>> from bionemo.bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +>>> from bionemo.bionemo.moco.distributions.time.uniform import UniformTimeDistribution +>>> from bionemo.bionemo.moco.interpolants.continuous_time.continuous.continuous_flow_matching import ContinuousFlowMatcher +>>> from bionemo.bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule + +flow_matcher = ContinuousFlowMatcher( + time_distribution = UniformTimeDistribution(...), + prior_distribution = GaussianPrior(...), + ) +model = Model(...) + +# Training +for epoch in range(1000): + data = data_loader.get(...) + time = flow_matcher.sample_time(batch_size) + noise = flow_matcher.sample_prior(data.shape) + data, time, noise = flow_matcher.apply_ot(noise, data) # Optional, only for OT + xt = flow_matcher.interpolate(data, time, noise) + flow = flow_matcher.calculate_target(data, noise) + + u_pred = model(xt, time) + loss = flow_matcher.loss(u_pred, flow) + loss.backward() + +# Generation +x_pred = flow_matcher.sample_prior(data.shape) +inference_sched = LinearInferenceSchedule(...) +for t in inference_sched.generate_schedule(): + time = inference_sched.pad_time(x_pred.shape[0], t) + u_hat = model(x_pred, time) + x_pred = flow_matcher.step(u_hat, x_pred, time) +return x_pred + +``` + + + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + prediction_type: Union[PredictionType, str] = PredictionType.DATA, + sigma: Float = 0, + ot_type: Optional[Union[OptimalTransportType, str]] = None, + data_scale: Float = 1.0, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + eps: Float = 1e-5) +``` + +Initializes the Continuous Flow Matching interpolant. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The distribution of time steps, used to sample time points for the diffusion process. +- `prior_distribution` _PriorDistribution_ - The prior distribution of the variable, used as the starting point for the diffusion process. +- `prediction_type` _PredictionType, optional_ - The type of prediction, either "flow" or another type. Defaults to PredictionType.DATA. +- `sigma` _Float, optional_ - The standard deviation of the Gaussian noise added to the interpolated data. Defaults to 0. +- `ot_type` _Optional[Union[OptimalTransportType, str]], optional_ - The type of optimal transport, if applicable. Defaults to None. +- `data_scale` _Float, optional_ - The scale factor for the data. Defaults to 1.0. +- `device` _Union[str, torch.device], optional_ - The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. +- `eps` - Small float to prevent divide by zero + + + +#### apply\_ot + +```python +def apply_ot(x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None, + replace: Bool = False) -> tuple +``` + +Sample and apply the optimal transport plan between batched (and masked) x0 and x1. + +**Arguments**: + +- `x0` _Tensor_ - shape (bs, *dim), noise from source minibatch. +- `x1` _Tensor_ - shape (bs, *dim), data from source minibatch. +- `mask` _Optional[Tensor], optional_ - mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. +- `replace` _bool_ - sampling w/ or w/o replacement from the OT plan, default to False. + + +**Returns**: + +- `Tuple` - tuple of 2 tensors, represents the noise and data samples following OT plan pi. + + + +#### undo\_scale\_data + +```python +def undo_scale_data(data: Tensor) -> Tensor +``` + +Downscale the input data by the data scale factor. + +**Arguments**: + +- `data` _Tensor_ - The input data to downscale. + + +**Returns**: + + The downscaled data. + + + +#### scale\_data + +```python +def scale_data(data: Tensor) -> Tensor +``` + +Upscale the input data by the data scale factor. + +**Arguments**: + +- `data` _Tensor_ - The input data to upscale. + + +**Returns**: + + The upscaled data. + + + +#### interpolate + +```python +def interpolate(data: Tensor, t: Tensor, noise: Tensor) -> Tensor +``` + +Get x_t with given time t from noise (x_0) and data (x_1). + +Currently, we use the linear interpolation as defined in: +1. Rectified flow: https://arxiv.org/abs/2209.03003. +2. Conditional flow matching: https://arxiv.org/abs/2210.02747 (called conditional optimal transport). + +**Arguments**: + +- `noise` _Tensor_ - noise from prior(), shape (batchsize, nodes, features) +- `t` _Tensor_ - time, shape (batchsize) +- `data` _Tensor_ - target, shape (batchsize, nodes, features) + + + +#### calculate\_target + +```python +def calculate_target(data: Tensor, + noise: Tensor, + mask: Optional[Tensor] = None) -> Tensor +``` + +Get the target vector field at time t. + +**Arguments**: + +- `noise` _Tensor_ - noise from prior(), shape (batchsize, nodes, features) +- `data` _Tensor_ - target, shape (batchsize, nodes, features) +- `mask` _Optional[Tensor], optional_ - mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + +**Returns**: + +- `Tensor` - The target vector field at time t. + + + +#### process\_vector\_field\_prediction + +```python +def process_vector_field_prediction(model_output: Tensor, + xt: Optional[Tensor] = None, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None) +``` + +Process the model output based on the prediction type to calculate vecotr field. + +**Arguments**: + +- `model_output` _Tensor_ - The output of the model. +- `xt` _Tensor_ - The input sample. +- `t` _Tensor_ - The time step. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the model output. Defaults to None. + + +**Returns**: + + The vector field prediction based on the prediction type. + + +**Raises**: + +- `ValueError` - If the prediction type is not "flow" or "data". + + + +#### process\_data\_prediction + +```python +def process_data_prediction(model_output: Tensor, + xt: Optional[Tensor] = None, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None) +``` + +Process the model output based on the prediction type to generate clean data. + +**Arguments**: + +- `model_output` _Tensor_ - The output of the model. +- `xt` _Tensor_ - The input sample. +- `t` _Tensor_ - The time step. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the model output. Defaults to None. + + +**Returns**: + + The data prediction based on the prediction type. + + +**Raises**: + +- `ValueError` - If the prediction type is not "flow". + + + +#### step + +```python +def step(model_out: Tensor, + xt: Tensor, + dt: Tensor, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + center: Bool = False) +``` + +Perform a single ODE step integration using Euler method. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model at the current time step. +- `xt` _Tensor_ - The current intermediate state. +- `dt` _Tensor_ - The time step size. +- `t` _Tensor, optional_ - The current time. Defaults to None. +- `mask` _Optional[Tensor], optional_ - A mask to apply to the model output. Defaults to None. +- `center` _Bool, optional_ - Whether to center the output. Defaults to False. + + +**Returns**: + +- `x_next` _Tensor_ - The updated state of the system after the single step, x_(t+dt). + + +**Notes**: + + - If a mask is provided, it is applied element-wise to the model output before scaling. + - The `clean` method is called on the updated state before it is returned. + + + +#### step\_score\_stochastic + +```python +def step_score_stochastic(model_out: Tensor, + xt: Tensor, + dt: Tensor, + t: Tensor, + mask: Optional[Tensor] = None, + gt_mode: str = "tan", + gt_p: Float = 1.0, + gt_clamp: Optional[Float] = None, + score_temperature: Float = 1.0, + noise_temperature: Float = 1.0, + t_lim_ode: Float = 0.99, + center: Bool = False) +``` + +Perform a single ODE step integration using Euler method. + +d x_t = [v(x_t, t) + g(t) * s(x_t, t) * sc_score_scale] dt + \sqrt{2 * g(t) * temperature} dw_t. + +At the moment we do not scale the vector field v but this can be added with sc_score_scale. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model at the current time step. +- `xt` _Tensor_ - The current intermediate state. +- `dt` _Tensor_ - The time step size. +- `t` _Tensor, optional_ - The current time. Defaults to None. +- `mask` _Optional[Tensor], optional_ - A mask to apply to the model output. Defaults to None. +- `gt_mode` _str, optional_ - The mode for the gt function. Defaults to "1/t". +- `gt_p` _Float, optional_ - The parameter for the gt function. Defaults to 1.0. +- `gt_clamp` - (Float, optional): Upper limit of gt term. Defaults to None. +- `score_temperature` _Float, optional_ - The temperature for the score part of the step. Defaults to 1.0. +- `noise_temperature` _Float, optional_ - The temperature for the stochastic part of the step. Defaults to 1.0. +- `t_lim_ode` _Float, optional_ - The time limit for the ODE step. Defaults to 0.99. +- `center` _Bool, optional_ - Whether to center the output. Defaults to False. + + +**Returns**: + +- `x_next` _Tensor_ - The updated state of the system after the single step, x_(t+dt). + + +**Notes**: + + - If a mask is provided, it is applied element-wise to the model output before scaling. + - The `clean` method is called on the updated state before it is returned. + + + +#### loss + +```python +def loss(model_pred: Tensor, + target: Tensor, + t: Optional[Tensor] = None, + xt: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + target_type: Union[PredictionType, str] = PredictionType.DATA) +``` + +Calculate the loss given the model prediction, data sample, time, and mask. + +If target_type is FLOW loss = ||v_hat - (x1-x0)||**2 +If target_type is DATA loss = ||x1_hat - x1||**2 * 1 / (1 - t)**2 as the target vector field = x1 - x0 = (1/(1-t)) * x1 - xt where xt = tx1 - (1-t)x0. +This functions supports any cominbation of prediction_type and target_type in {DATA, FLOW}. + +**Arguments**: + +- `model_pred` _Tensor_ - The predicted output from the model. +- `target` _Tensor_ - The target output for the model prediction. +- `t` _Optional[Tensor], optional_ - The time for the model prediction. Defaults to None. +- `xt` _Optional[Tensor], optional_ - The interpolated data. Defaults to None. +- `mask` _Optional[Tensor], optional_ - The mask for the data point. Defaults to None. +- `target_type` _PredictionType, optional_ - The type of the target output. Defaults to PredictionType.DATA. + + +**Returns**: + +- `Tensor` - The calculated loss batch tensor. + + + +#### vf\_to\_score + +```python +def vf_to_score(x_t: Tensor, v: Tensor, t: Tensor) -> Tensor +``` + +From Geffner et al. Computes score of noisy density given the vector field learned by flow matching. + +With our interpolation scheme these are related by + +v(x_t, t) = (1 / t) (x_t + scale_ref ** 2 * (1 - t) * s(x_t, t)), + +or equivalently, + +s(x_t, t) = (t * v(x_t, t) - x_t) / (scale_ref ** 2 * (1 - t)). + +with scale_ref = 1 + +**Arguments**: + +- `x_t` - Noisy sample, shape [*, dim] +- `v` - Vector field, shape [*, dim] +- `t` - Interpolation time, shape [*] (must be < 1) + + +**Returns**: + + Score of intermediate density, shape [*, dim]. + + + +#### get\_gt + +```python +def get_gt(t: Tensor, + mode: str = "tan", + param: float = 1.0, + clamp_val: Optional[float] = None, + eps: float = 1e-2) -> Tensor +``` + +From Geffner et al. Computes gt for different modes. + +**Arguments**: + +- `t` - times where we'll evaluate, covers [0, 1), shape [nsteps] +- `mode` - "us" or "tan" +- `param` - parameterized transformation +- `clamp_val` - value to clamp gt, no clamping if None +- `eps` - small value leave as it is + + + +# bionemo.moco.interpolants.continuous\_time + + + +# bionemo.moco.interpolants + + + +# bionemo.moco.interpolants.discrete\_time.discrete.d3pm + + + +## D3PM Objects + +```python +class D3PM(Interpolant) +``` + +A Discrete Denoising Diffusion Probabilistic Model (D3PM) interpolant. + + + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: DiscretePriorDistribution, + noise_schedule: DiscreteNoiseSchedule, + device: str = "cpu", + last_time_idx: int = 0, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes the D3PM interpolant. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The distribution of time steps, used to sample time points for the diffusion process. +- `prior_distribution` _PriorDistribution_ - The prior distribution of the variable, used as the starting point for the diffusion process. +- `noise_schedule` _DiscreteNoiseSchedule_ - The schedule of noise, defining the amount of noise added at each time step. +- `device` _str, optional_ - The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". +- `last_time_idx` _int, optional_ - The last time index to consider in the interpolation process. Defaults to 0. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + + +#### interpolate + +```python +def interpolate(data: Tensor, t: Tensor) +``` + +Interpolate using discrete interpolation method. + +This method implements Equation 2 from the D3PM paper (https://arxiv.org/pdf/2107.03006), which +calculates the interpolated discrete state `xt` at time `t` given the input data and noise +via q(xt|x0) = Cat(xt; p = x0*Qt_bar). + +**Arguments**: + +- `data` _Tensor_ - The input data to be interpolated. +- `t` _Tensor_ - The time step at which to interpolate. + + +**Returns**: + +- `Tensor` - The interpolated discrete state `xt` at time `t`. + + + +#### forward\_process + +```python +def forward_process(data: Tensor, t: Tensor) -> Tensor +``` + +Apply the forward process to the data at time t. + +**Arguments**: + +- `data` _Tensor_ - target discrete ids +- `t` _Tensor_ - time + + +**Returns**: + +- `Tensor` - x(t) after applying the forward process + + + +#### step + +```python +def step(model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + temperature: Float = 1.0, + model_out_is_logits: bool = True) +``` + +Perform a single step in the discrete interpolant method, transitioning from the current discrete state `xt` at time `t` to the next state. + +This step involves: + +1. Computing the predicted q-posterior logits using the model output `model_out` and the current state `xt` at time `t`. +2. Sampling the next state from the predicted q-posterior distribution using the Gumbel-Softmax trick. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model at the current time step, which is used to compute the predicted q-posterior logits. +- `t` _Tensor_ - The current time step, which is used to index into the transition matrices and compute the predicted q-posterior logits. +- `xt` _Tensor_ - The current discrete state at time `t`, which is used to compute the predicted q-posterior logits and sample the next state. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the next state, which can be used to mask out certain tokens or regions. Defaults to None. +- `temperature` _Float, optional_ - The temperature to use for the Gumbel-Softmax trick, which controls the randomness of the sampling process. Defaults to 1.0. +- `model_out_is_logits` _bool, optional_ - A flag indicating whether the model output is already in logits form. If True, the output is assumed to be logits; otherwise, it is converted to logits. Defaults to True. + + +**Returns**: + +- `Tensor` - The next discrete state at time `t-1`. + + + +#### loss + +```python +def loss(logits: Tensor, + target: Tensor, + xt: Tensor, + time: Tensor, + mask: Optional[Tensor] = None, + vb_scale: Float = 0.0) +``` + +Calculate the cross-entropy loss between the model prediction and the target output. + +The loss is calculated between the batch x node x class logits and the target batch x node. If a mask is provided, the loss is +calculated only for the non-masked elements. Additionally, if vb_scale is greater than 0, the variational lower bound loss is +calculated and added to the total loss. + +**Arguments**: + +- `logits` _Tensor_ - The predicted output from the model, with shape batch x node x class. +- `target` _Tensor_ - The target output for the model prediction, with shape batch x node. +- `xt` _Tensor_ - The current data point. +- `time` _Tensor_ - The time at which the loss is calculated. +- `mask` _Optional[Tensor], optional_ - The mask for the data point. Defaults to None. +- `vb_scale` _Float, optional_ - The scale factor for the variational lower bound loss. Defaults to 0.0. + + +**Returns**: + +- `Tensor` - The calculated loss tensor. If aggregate is True, the loss and variational lower bound loss are aggregated and + returned as a single tensor. Otherwise, the loss and variational lower bound loss are returned as separate tensors. + + + +# bionemo.moco.interpolants.discrete\_time.discrete + + + +# bionemo.moco.interpolants.discrete\_time.continuous.ddpm + + + +## DDPM Objects + +```python +class DDPM(Interpolant) +``` + +A Denoising Diffusion Probabilistic Model (DDPM) interpolant. + +------- + +**Examples**: + +```python +>>> import torch +>>> from bionemo.bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +>>> from bionemo.bionemo.moco.distributions.time.uniform import UniformTimeDistribution +>>> from bionemo.bionemo.moco.interpolants.discrete_time.continuous.ddpm import DDPM +>>> from bionemo.bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule +>>> from bionemo.bionemo.moco.schedules.inference_time_schedules import DiscreteLinearInferenceSchedule + + +ddpm = DDPM( + time_distribution = UniformTimeDistribution(discrete_time = True,...), + prior_distribution = GaussianPrior(...), + noise_schedule = DiscreteCosineNoiseSchedule(...), + ) +model = Model(...) + +# Training +for epoch in range(1000): + data = data_loader.get(...) + time = ddpm.sample_time(batch_size) + noise = ddpm.sample_prior(data.shape) + xt = ddpm.interpolate(data, noise, time) + + x_pred = model(xt, time) + loss = ddpm.loss(x_pred, data, time) + loss.backward() + +# Generation +x_pred = ddpm.sample_prior(data.shape) +for t in DiscreteLinearTimeSchedule(...).generate_schedule(): + time = torch.full((batch_size,), t) + x_hat = model(x_pred, time) + x_pred = ddpm.step(x_hat, time, x_pred) +return x_pred + +``` + + + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + noise_schedule: DiscreteNoiseSchedule, + prediction_type: Union[PredictionType, str] = PredictionType.DATA, + device: Union[str, torch.device] = "cpu", + last_time_idx: int = 0, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes the DDPM interpolant. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The distribution of time steps, used to sample time points for the diffusion process. +- `prior_distribution` _PriorDistribution_ - The prior distribution of the variable, used as the starting point for the diffusion process. +- `noise_schedule` _DiscreteNoiseSchedule_ - The schedule of noise, defining the amount of noise added at each time step. +- `prediction_type` _PredictionType_ - The type of prediction, either "data" or another type. Defaults to "data". +- `device` _str_ - The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". +- `last_time_idx` _int, optional_ - The last time index for discrete time. Set to 0 if discrete time is T-1, ..., 0 or 1 if T, ..., 1. Defaults to 0. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + + +#### forward\_data\_schedule + +```python +@property +def forward_data_schedule() -> torch.Tensor +``` + +Returns the forward data schedule. + + + +#### forward\_noise\_schedule + +```python +@property +def forward_noise_schedule() -> torch.Tensor +``` + +Returns the forward noise schedule. + + + +#### reverse\_data\_schedule + +```python +@property +def reverse_data_schedule() -> torch.Tensor +``` + +Returns the reverse data schedule. + + + +#### reverse\_noise\_schedule + +```python +@property +def reverse_noise_schedule() -> torch.Tensor +``` + +Returns the reverse noise schedule. + + + +#### log\_var + +```python +@property +def log_var() -> torch.Tensor +``` + +Returns the log variance. + + + +#### alpha\_bar + +```python +@property +def alpha_bar() -> torch.Tensor +``` + +Returns the alpha bar values. + + + +#### alpha\_bar\_prev + +```python +@property +def alpha_bar_prev() -> torch.Tensor +``` + +Returns the previous alpha bar values. + + + +#### interpolate + +```python +def interpolate(data: Tensor, t: Tensor, noise: Tensor) +``` + +Get x(t) with given time t from noise and data. + +**Arguments**: + +- `data` _Tensor_ - target +- `t` _Tensor_ - time +- `noise` _Tensor_ - noise from prior() + + + +#### forward\_process + +```python +def forward_process(data: Tensor, t: Tensor, noise: Optional[Tensor] = None) +``` + +Get x(t) with given time t from noise and data. + +**Arguments**: + +- `data` _Tensor_ - target +- `t` _Tensor_ - time +- `noise` _Tensor, optional_ - noise from prior(). Defaults to None. + + + +#### process\_data\_prediction + +```python +def process_data_prediction(model_output: Tensor, sample: Tensor, t: Tensor) +``` + +Converts the model output to a data prediction based on the prediction type. + +This conversion stems from the Progressive Distillation for Fast Sampling of Diffusion Models https://arxiv.org/pdf/2202.00512. +Given the model output and the sample, we convert the output to a data prediction based on the prediction type. +The conversion formulas are as follows: +- For "noise" prediction type: `pred_data = (sample - noise_scale * model_output) / data_scale` +- For "data" prediction type: `pred_data = model_output` +- For "v_prediction" prediction type: `pred_data = data_scale * sample - noise_scale * model_output` + +**Arguments**: + +- `model_output` _Tensor_ - The output of the model. +- `sample` _Tensor_ - The input sample. +- `t` _Tensor_ - The time step. + + +**Returns**: + + The data prediction based on the prediction type. + + +**Raises**: + +- `ValueError` - If the prediction type is not one of "noise", "data", or "v_prediction". + + + +#### process\_noise\_prediction + +```python +def process_noise_prediction(model_output, sample, t) +``` + +Do the same as process_data_prediction but take the model output and convert to nosie. + +**Arguments**: + +- `model_output` - The output of the model. +- `sample` - The input sample. +- `t` - The time step. + + +**Returns**: + + The input as noise if the prediction type is "noise". + + +**Raises**: + +- `ValueError` - If the prediction type is not "noise". + + + +#### calculate\_velocity + +```python +def calculate_velocity(data: Tensor, t: Tensor, noise: Tensor) -> Tensor +``` + +Calculate the velocity term given the data, time step, and noise. + +**Arguments**: + +- `data` _Tensor_ - The input data. +- `t` _Tensor_ - The current time step. +- `noise` _Tensor_ - The noise term. + + +**Returns**: + +- `Tensor` - The calculated velocity term. + + + +#### step + +```python +@torch.no_grad() +def step(model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0) +``` + +Do one step integration. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. +- `t` _Tensor_ - The current time step. +- `xt` _Tensor_ - The current data point. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the data. Defaults to None. +- `center` _bool, optional_ - Whether to center the data. Defaults to False. +- `temperature` _Float, optional_ - The temperature parameter for low temperature sampling. Defaults to 1.0. + + +**Notes**: + + The temperature parameter controls the level of randomness in the sampling process. A temperature of 1.0 corresponds to standard diffusion sampling, while lower temperatures (e.g. 0.5, 0.2) result in less random and more deterministic samples. This can be useful for tasks that require more control over the generation process. + + Note for discrete time we sample from [T-1, ..., 1, 0] for T steps so we sample t = 0 hence the mask. + For continuous time we start from [1, 1 -dt, ..., dt] for T steps where s = t - 1 when t = 0 i.e dt is then 0 + + + +#### step\_noise + +```python +def step_noise(model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0) +``` + +Do one step integration. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. +- `t` _Tensor_ - The current time step. +- `xt` _Tensor_ - The current data point. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the data. Defaults to None. +- `center` _bool, optional_ - Whether to center the data. Defaults to False. +- `temperature` _Float, optional_ - The temperature parameter for low temperature sampling. Defaults to 1.0. + + +**Notes**: + + The temperature parameter controls the level of randomness in the sampling process. A temperature of 1.0 corresponds to standard diffusion sampling, while lower temperatures (e.g. 0.5, 0.2) result in less random and more deterministic samples. This can be useful for tasks that require more control over the generation process. + + Note for discrete time we sample from [T-1, ..., 1, 0] for T steps so we sample t = 0 hence the mask. + For continuous time we start from [1, 1 -dt, ..., dt] for T steps where s = t - 1 when t = 0 i.e dt is then 0 + + + +#### score + +```python +def score(x_hat: Tensor, xt: Tensor, t: Tensor) +``` + +Converts the data prediction to the estimated score function. + +**Arguments**: + +- `x_hat` _Tensor_ - The predicted data point. +- `xt` _Tensor_ - The current data point. +- `t` _Tensor_ - The time step. + + +**Returns**: + + The estimated score function. + + + +#### step\_ddim + +```python +def step_ddim(model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + eta: Float = 0.0, + center: Bool = False) +``` + +Do one step of DDIM sampling. + +**Arguments**: + +- `model_out` _Tensor_ - output of the model +- `t` _Tensor_ - current time step +- `xt` _Tensor_ - current data point +- `mask` _Optional[Tensor], optional_ - mask for the data point. Defaults to None. +- `eta` _Float, optional_ - DDIM sampling parameter. Defaults to 0.0. +- `center` _Bool, optional_ - whether to center the data point. Defaults to False. + + + +#### set\_loss\_weight\_fn + +```python +def set_loss_weight_fn(fn) +``` + +Sets the loss_weight attribute of the instance to the given function. + +**Arguments**: + +- `fn` - The function to set as the loss_weight attribute. This function should take three arguments: raw_loss, t, and weight_type. + + + +#### loss\_weight + +```python +def loss_weight(raw_loss: Tensor, t: Optional[Tensor], + weight_type: str) -> Tensor +``` + +Calculates the weight for the loss based on the given weight type. + +These data_to_noise loss weights is derived in Equation (9) of https://arxiv.org/pdf/2202.00512. + +**Arguments**: + +- `raw_loss` _Tensor_ - The raw loss calculated from the model prediction and target. +- `t` _Tensor_ - The time step. +- `weight_type` _str_ - The type of weight to use. Can be "ones" or "data_to_noise" or "noise_to_data". + + +**Returns**: + +- `Tensor` - The weight for the loss. + + +**Raises**: + +- `ValueError` - If the weight type is not recognized. + + + +#### loss + +```python +def loss(model_pred: Tensor, + target: Tensor, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + weight_type: str = "ones") +``` + +Calculate the loss given the model prediction, data sample, and time. + +**Arguments**: + +- `model_pred` _Tensor_ - The predicted output from the model. +- `target` _Tensor_ - The target output for the model prediction. +- `t` _Tensor_ - The time at which the loss is calculated. +- `mask` _Optional[Tensor], optional_ - The mask for the data point. Defaults to None. +- `weight_type` _str, optional_ - The type of weight to use for the loss. Defaults to "ones". + + +**Returns**: + +- `Tensor` - The calculated loss batch tensor. + + + +# bionemo.moco.interpolants.discrete\_time.continuous + + + +# bionemo.moco.interpolants.discrete\_time + + + +# bionemo.moco.interpolants.discrete\_time.utils + + + +#### safe\_index + +```python +def safe_index(tensor: Tensor, index: Tensor, device: torch.device) +``` + +Safely indexes a tensor using a given index and returns the result on a specified device. + +Note can implement forcing with return tensor[index.to(tensor.device)].to(device) but has costly migration. + +**Arguments**: + +- `tensor` _Tensor_ - The tensor to be indexed. +- `index` _Tensor_ - The index to use for indexing the tensor. +- `device` _torch.device_ - The device on which the result should be returned. + + +**Returns**: + +- `Tensor` - The indexed tensor on the specified device. + + +**Raises**: + +- `ValueError` - If tensor, index, and device are not all on the same device. + + + +# bionemo.moco.interpolants.base\_interpolant + + + +#### string\_to\_enum + +```python +def string_to_enum(value: Union[str, AnyEnum], + enum_type: Type[AnyEnum]) -> AnyEnum +``` + +Converts a string to an enum value of the specified type. If the input is already an enum instance, it is returned as-is. + +**Arguments**: + +- `value` _Union[str, E]_ - The string to convert or an existing enum instance. +- `enum_type` _Type[E]_ - The enum type to convert to. + + +**Returns**: + +- `E` - The corresponding enum value. + + +**Raises**: + +- `ValueError` - If the string does not correspond to any enum member. + + + +#### pad\_like + +```python +def pad_like(source: Tensor, target: Tensor) -> Tensor +``` + +Pads the dimensions of the source tensor to match the dimensions of the target tensor. + +**Arguments**: + +- `source` _Tensor_ - The tensor to be padded. +- `target` _Tensor_ - The tensor that the source tensor should match in dimensions. + + +**Returns**: + +- `Tensor` - The padded source tensor. + + +**Raises**: + +- `ValueError` - If the source tensor has more dimensions than the target tensor. + + +**Example**: + + >>> source = torch.tensor([1, 2, 3]) # shape: (3,) + >>> target = torch.tensor([[1, 2], [4, 5], [7, 8]]) # shape: (3, 2) + >>> padded_source = pad_like(source, target) # shape: (3, 1) + + + +## PredictionType Objects + +```python +class PredictionType(Enum) +``` + +An enumeration representing the type of prediction a Denoising Diffusion Probabilistic Model (DDPM) can be used for. + +DDPMs are versatile models that can be utilized for various prediction tasks, including: + +- **Data**: Predicting the original data distribution from a noisy input. +- **Noise**: Predicting the noise that was added to the original data to obtain the input. +- **Velocity**: Predicting the velocity or rate of change of the data, particularly useful for modeling temporal dynamics. + +These prediction types can be used to train neural networks for specific tasks, such as denoising, image synthesis, or time-series forecasting. + + + +## Interpolant Objects + +```python +class Interpolant(ABC) +``` + +An abstract base class representing an Interpolant. + +This class serves as a foundation for creating interpolants that can be used +in various applications, providing a basic structure and interface for +interpolation-related operations. + + + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes the Interpolant class. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The distribution of time steps. +- `prior_distribution` _PriorDistribution_ - The prior distribution of the variable. +- `device` _Union[str, torch.device], optional_ - The device on which to operate. Defaults to "cpu". +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + + +#### interpolate + +```python +@abstractmethod +def interpolate(*args, **kwargs) -> Tensor +``` + +Get x(t) with given time t from noise and data. + +Interpolate between x0 and x1 at the given time t. + + + +#### step + +```python +@abstractmethod +def step(*args, **kwargs) -> Tensor +``` + +Do one step integration. + + + +#### general\_step + +```python +def general_step(method_name: str, kwargs: dict) +``` + +Calls a step method of the class by its name, passing the provided keyword arguments. + +**Arguments**: + +- `method_name` _str_ - The name of the step method to call. +- `kwargs` _dict_ - Keyword arguments to pass to the step method. + + +**Returns**: + + The result of the step method call. + + +**Raises**: + +- `ValueError` - If the provided method name does not start with 'step'. +- `Exception` - If the step method call fails. The error message includes a list of available step methods. + + +**Notes**: + + This method allows for dynamic invocation of step methods, providing flexibility in the class's usage. + + + +#### sample\_prior + +```python +def sample_prior(*args, **kwargs) -> Tensor +``` + +Sample from prior distribution. + +This method generates a sample from the prior distribution specified by the +`prior_distribution` attribute. + +**Returns**: + +- `Tensor` - The generated sample from the prior distribution. + + + +#### sample\_time + +```python +def sample_time(*args, **kwargs) -> Tensor +``` + +Sample from time distribution. + + + +#### to\_device + +```python +def to_device(device: str) +``` + +Moves all internal tensors to the specified device and updates the `self.device` attribute. + +**Arguments**: + +- `device` _str_ - The device to move the tensors to (e.g. "cpu", "cuda:0"). + + +**Notes**: + + This method is used to transfer the internal state of the DDPM interpolant to a different device. + It updates the `self.device` attribute to reflect the new device and moves all internal tensors to the specified device. + + + +#### clean\_mask\_center + +```python +def clean_mask_center(data: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False) -> Tensor +``` + +Returns a clean tensor that has been masked and/or centered based on the function arguments. + +**Arguments**: + +- `data` - The input data with shape (..., nodes, features). +- `mask` - An optional mask to apply to the data with shape (..., nodes). If provided, it is used to calculate the CoM. Defaults to None. +- `center` - A boolean indicating whether to center the data around the calculated CoM. Defaults to False. + + +**Returns**: + + The data with shape (..., nodes, features) either centered around the CoM if `center` is True or unchanged if `center` is False. diff --git a/sub-packages/bionemo-moco/environment/Instructions.md b/sub-packages/bionemo-moco/environment/Instructions.md new file mode 100644 index 0000000000..f565c2f23a --- /dev/null +++ b/sub-packages/bionemo-moco/environment/Instructions.md @@ -0,0 +1,8 @@ +Environment Setup +=============== + +from the bionemo-moco directory run + + bash environment/setup.sh + + This creates the conda environment, installs bionemo-moco and runs the tests. diff --git a/sub-packages/bionemo-moco/environment/moco_env.yaml b/sub-packages/bionemo-moco/environment/moco_env.yaml new file mode 100644 index 0000000000..0daadf6978 --- /dev/null +++ b/sub-packages/bionemo-moco/environment/moco_env.yaml @@ -0,0 +1,41 @@ +name: moco_bionemo +channels: + - conda-forge + - pytorch + - nvidia + +dependencies: + - python=3.10 + - pytorch=2.2.1 + - pytorch-cuda=12.1 + - torchvision=0.17.1 + - torchaudio=2.2.1 + + - pip: + - ruff==0.0.292 + - black==23.1.0 + - pre-commit==3.4.0 + - virtualenv==20.26.3 + - ipdb==0.13.11 + - click==8.1.7 + - tenacity==8.5.0 + - tach>=0.9.0 + - pytest-cov==4.1.0 + - pytest-timeout==2.2.0 + - pytest-dependency==0.5.1 + - testbook==0.4.2 + - requests_mock==1.11.0 + - awscli==1.33.33 + - nbval==0.11.0 + - onnx>=1.16.0 + - setuptools>=70.0.0 + - aiohttp>=3.9.4 + - jupyterlab>=3.6.8 + - jupyter_server>=2.14.1 # Fix for GHSA-hrw6-wg82-cm62 + - Werkzeug>=3.0.3 + - nltk>=3.9.1 + - numpy>=1.24.4,<2 + - jaxtyping==0.2.34 + - pot>=0.9.5 + - scikit-learn>=1.6.0 + - matplotlib>=3.3.2 diff --git a/sub-packages/bionemo-moco/environment/setup.sh b/sub-packages/bionemo-moco/environment/setup.sh new file mode 100644 index 0000000000..fc11ce8f51 --- /dev/null +++ b/sub-packages/bionemo-moco/environment/setup.sh @@ -0,0 +1,39 @@ +#!/bin/bash + +# Set the path to your Conda environment YAML file +ENV_YAML="environment/moco_env.yaml" + +# Extract the environment name from the YAML file +ENV_NAME=$(head -n 1 "$ENV_YAML" | cut -d':' -f2- | tr -d ' ') + +# Load Conda to enable command +source "$(conda info --base)/etc/profile.d/conda.sh" + +# Create the Conda environment from the YAML file +echo "Creating Conda environment $ENV_NAME from $ENV_YAML..." +conda env create -f "$ENV_YAML" + +# Activate the Conda environment +echo "Activating Conda environment $ENV_NAME..." +conda activate "$ENV_NAME" + +# Check if the environment was successfully activated +if [ "$CONDA_DEFAULT_ENV" == "$ENV_NAME" ]; then + echo "Conda environment $ENV_NAME activated successfully." + # Navigate to your project directory if needed + # cd /path/to/your/project # Uncomment and adjust this path as necessary + # Install your project in editable mode using pip + pip install pydoc-markdown>=4.8.2 + pip install pytest-cov==4.1.0 pytest-timeout==2.2.0 pytest-dependency==0.5.1 + pre-commit install + echo "Installing bionemo-moco in editable mode using pip..." + pip install -e . + echo "Setup complete." + # Run tests + echo "Running tests..." + pytest + echo "Tests complete. You can now work within the $ENV_NAME environment." +else + echo "Failed to activate Conda environment $ENV_NAME. Exiting..." + exit 1 +fi diff --git a/sub-packages/bionemo-moco/examples/continuous_data_interpolant_tutorial.ipynb b/sub-packages/bionemo-moco/examples/continuous_data_interpolant_tutorial.ipynb new file mode 100644 index 0000000000..a455b0c93b --- /dev/null +++ b/sub-packages/bionemo-moco/examples/continuous_data_interpolant_tutorial.ipynb @@ -0,0 +1,1844 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Building Generative Models for Continuous Data via Continuous Interpolants" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import os\n", + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "\n", + "from sklearn.datasets import make_moons" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Task Setup\n", + "\n", + "To demonstrate how Conditional Flow Matching works we use torchdyn, a PyTorch library dedicated to neural differential equations and equilibrium models, to sample from and create custom 2D distriubtions.\n", + "\n", + "To start we define our \"dataloader\" so to speak. This is the '''sample_moons''' function.\n", + "\n", + "Next we define a custom PriorDistribution to enable the conversion of 8 equidistance gaussians to the moon distribution above.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def sample_moons(n, normalize = False):\n", + " x1, _ = make_moons(n_samples=n, noise=0.08)\n", + " x1 = torch.Tensor(x1)\n", + " x1 = x1 * 3 - 1\n", + " if normalize:\n", + " x1 = (x1 - x1.mean(0))/x1.std(0) * 2\n", + " return x1" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x1 = sample_moons(1000)\n", + "plt.scatter(x1[:, 0], x1[:, 1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model Creation\n", + "Here we define a simple 4 layer MLP and define our optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "dim = 2\n", + "hidden_size = 64\n", + "batch_size = 256\n", + "model = torch.nn.Sequential(\n", + " torch.nn.Linear(dim + 1, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, dim),\n", + " )\n", + "optimizer = torch.optim.Adam(model.parameters())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Continuous Flow Matching Interpolant\n", + "Here we import our desired interpolant objects.\n", + "\n", + "The continuous flow matcher and the desired time distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.interpolants import ContinuousFlowMatcher\n", + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.distributions.prior import GaussianPrior\n", + "\n", + "uniform_time = UniformTimeDistribution()\n", + "simple_prior = GaussianPrior()\n", + "sigma = 0.1\n", + "cfm = ContinuousFlowMatcher(time_distribution=uniform_time, \n", + " prior_distribution=simple_prior, \n", + " sigma=sigma, \n", + " prediction_type=\"velocity\")\n", + "# Place both the model and the interpolant on the same device\n", + "DEVICE = \"cuda\"\n", + "model = model.to(DEVICE)\n", + "cfm = cfm.to_device(DEVICE)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training Loop" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5000: loss 2.752\n", + "10000: loss 2.838\n", + "15000: loss 2.709\n", + "20000: loss 3.096\n" + ] + } + ], + "source": [ + "for k in range(20000):\n", + " optimizer.zero_grad()\n", + " shape = (batch_size, dim)\n", + " x0 = cfm.sample_prior(shape).to(DEVICE)\n", + " x1 = sample_moons(batch_size).to(DEVICE)\n", + "\n", + " t = cfm.sample_time(batch_size)\n", + " xt = cfm.interpolate(x1, t, x0)\n", + " ut = cfm.calculate_target(x1, x0)\n", + "\n", + " vt = model(torch.cat([xt, t[:, None]], dim=-1))\n", + " loss = cfm.loss(vt, ut, target_type=\"velocity\").mean()\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " if (k + 1) % 5000 == 0:\n", + " print(f\"{k+1}: loss {loss.item():0.3f}\") " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setting Up Generation\n", + "Now we need to import the desired inference time schedule. This is what gives us the time values to iterate through to iteratively generate from our model.\n", + "\n", + "Here we show the output time schedule as well as the discretization between time points. We note that different inference time schedules may have different shapes resulting in non uniform dt" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700, 0.0800,\n", + " 0.0900, 0.1000, 0.1100, 0.1200, 0.1300, 0.1400, 0.1500, 0.1600, 0.1700,\n", + " 0.1800, 0.1900, 0.2000, 0.2100, 0.2200, 0.2300, 0.2400, 0.2500, 0.2600,\n", + " 0.2700, 0.2800, 0.2900, 0.3000, 0.3100, 0.3200, 0.3300, 0.3400, 0.3500,\n", + " 0.3600, 0.3700, 0.3800, 0.3900, 0.4000, 0.4100, 0.4200, 0.4300, 0.4400,\n", + " 0.4500, 0.4600, 0.4700, 0.4800, 0.4900, 0.5000, 0.5100, 0.5200, 0.5300,\n", + " 0.5400, 0.5500, 0.5600, 0.5700, 0.5800, 0.5900, 0.6000, 0.6100, 0.6200,\n", + " 0.6300, 0.6400, 0.6500, 0.6600, 0.6700, 0.6800, 0.6900, 0.7000, 0.7100,\n", + " 0.7200, 0.7300, 0.7400, 0.7500, 0.7600, 0.7700, 0.7800, 0.7900, 0.8000,\n", + " 0.8100, 0.8200, 0.8300, 0.8400, 0.8500, 0.8600, 0.8700, 0.8800, 0.8900,\n", + " 0.9000, 0.9100, 0.9200, 0.9300, 0.9400, 0.9500, 0.9600, 0.9700, 0.9800,\n", + " 0.9900], device='cuda:0'),\n", + " tensor([0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100], device='cuda:0'))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule\n", + "\n", + "inference_sched = LinearInferenceSchedule(nsteps = 100)\n", + "schedule = inference_sched.generate_schedule().to(DEVICE)\n", + "dts = inference_sched.discretize().to(DEVICE)\n", + "schedule, dts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Sample from the trained model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = cfm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "for dt, t in zip(dts, schedule):\n", + " full_t = inference_sched.pad_time(inf_size, t, DEVICE)\n", + " vt = model(torch.cat([sample, full_t[:, None]], dim=-1)) # calculate the vector field based on the definition of the model\n", + " sample = cfm.step(vt, sample, dt, full_t)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Sample from underlying score model\n", + "\n", + "## low temperature sampling is a heuristic, unclear what effects it has on the final distribution. Intuitively, it cuts tails and focuses more on the mode, in practice who knows exactly what's the final effect.\n", + "\n", + "## gt_mode is a hyperparameter that must be experimentally chosen" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = cfm.sample_prior((inf_size, 2)).to(DEVICE)\n", + "trajectory_stoch = [sample]\n", + "vts = []\n", + "for dt, t in zip(dts, schedule):\n", + " time = torch.full((inf_size,), t).to(DEVICE)\n", + " vt = model(torch.cat([sample, time[:, None]], dim=-1))\n", + " sample = cfm.step_score_stochastic(vt, sample, dt, time, noise_temperature=1.0, gt_mode = \"tan\")\n", + " trajectory_stoch.append(sample)\n", + " vts.append(vt)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "traj = torch.stack(trajectory_stoch).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(0)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "#for i in range(0, traj.shape[0]-1):\n", + "# plt.plot(traj[i, :n, 0], traj[i, :n, 1], c=\"olive\", alpha=0.2) #, s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(1)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.title(\"Stochastic score sampling Temperature = 1.0\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# What happens if you just sample from a random model?" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "fmodel = torch.nn.Sequential(\n", + " torch.nn.Linear(dim + 1, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, dim),\n", + " ).to(DEVICE)\n", + "inf_size = 1024\n", + "sample = cfm.sample_prior((inf_size, 2)).to(DEVICE)\n", + "trajectory2 = [sample]\n", + "for dt, t in zip(dts, schedule):\n", + " time = torch.full((inf_size,), t).to(DEVICE)\n", + " vt = fmodel(torch.cat([sample, time[:, None]], dim=-1))\n", + " sample = cfm.step(vt, sample, dt, time)\n", + " trajectory2.append(sample)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAHiCAYAAAA597/kAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXl8E3X+/58zSduk933fLVBogXLfN6iIFPHEe9XVXV1F2XUvv+serqu/dT2Q3dU9PFdXWW+KIIIccpb7aqGU0iMtPdM2TdMkTSaT3x9pUgptKUihwDwfDx/FNpnPZ2aSeX3en/clOJ1OJwoKCgoKCgqXFPFST0BBQUFBQUFBEWQFBQUFBYV+gSLICgoKCgoK/QBFkBUUFBQUFPoBiiArKCgoKCj0AxRBVlBQUFBQ6AcogqygoKCgoNAPUARZQUFBQUGhH6DuzYtkWaaqqoqAgAAEQejrOSkoKCgoKFwxOJ1OWlpaiI2NRRS7t4N7JchVVVUkJCRcsMkpKCgoKChcbVRUVBAfH9/t33slyAEBAZ6DBQYGXpiZKSgoKCgoXAUYjUYSEhI8WtodvRJk9zZ1YGCgIsgKCgoKCgrnwdlcvkpQl4KCgoKCQj9AEWQFBQUFBYV+gCLICgoKCgoK/QBFkBUUFBQUFPoBiiArKCgoKCj0AxRBVlBQUFBQ6AcogqygoKCgoNAPUARZQUFBQUGhH6AIsoKCgoKCQj9AEWQFBQUFBYV+gCLICgoKCgoK/QBFkBUUFBQUFPoBiiArKCgoKCj0AxRBVlBQUFBQ6AcogqygoKCgoNAP6FU/ZAUFBYWLRX5+PjqdjsTERLKysi71dBQULhqKICsoKPQbli1bxtKlS7FYLGi1Wp588kkWL158qaeloHBRULasFRQUzkp+fj6rV68mPz+/T8dYunQpguBg4MBgBMHB0qVL+3RMBYX+hCLICgoKPbJs2TJycnJ48MEHycnJYdmyZX0yjk6nw2KxkJTkRUJCPUlJXlgsFnQ6XZ+Mp6DQ31AEWUFBoVvcVqvT6SQmJgan09lnVmtiYiKBgWqioqrw8WlFFBvRarUkJiZe8LEUFPojiiArKCh0i06nQ5KMDB3qwMfHQUhISJ9ZrVlZWdx77ygCAmy0tNioqPBjyZIlSmCXwlWDEtSloKDQLYmJiQwcaCcysgawc/iwps+sVpvNxLBhsWg06QQFTea3v31SEWOFqwrFQlZQUOiWjIx0pk3LxstLwmQyIAhCn1mtx4+vx2AoIyFhOAsW/FQRY4WrDsVCVlBQ6JaKijwGDAglPHwK06bNIyvr+j4RSkmyotNtxWSqIS5uDGFhAy/4GAoK/R1FkBUULgGXS/GL8vKdNDaWkJo6m9mzF6NWa/pknIqKPPT6fHx8AoiNHYEoKo8mhasP5VOvoHCRuVyKX1itBhobjwIigYFxfSbGABUVezCb64iNHUdq6uw+G0dBoT+j+JAVFC4i7jQiUZTIzPRHFKV+W/wiP/8LGhuLCQpKYMCA6/psHLNZT2PjUby8/ElIGIu3t3+fjaWg0J9RBFlB4SKi0+nao4ntREY2kZzcf4tftLbWYrUaiI4e2qc+3X373qe+voCQkFQyMm7ss3EUFPo7ypa1gsJFJDExkZQUmeDgZiTJi6YmNVqtb78rfmE262lqOo6vbxhhYQP6zKcrSVZaWiqw2cxERAxBownuk3EUFC4HFAtZQeEikpWVxTXXjEartaPXW2lu1vTL4hcXy2qtqMijubmUkJBkEhLG9dk4CgqXA4qFrKBwEZFliXHjRnDgwBGGDZvOpEm/6HdiDCBJZqzWJkJC0vvUaq2o2ENzcwXJyTOIixvbZ+MoKFwOKIKsoHAR0euP0dhYSHBwAmPHzuyXYmw26zEYSvDziyY4OK7PxrFaDRiNJYiihoiIjD6N4u6JyyUFTeHKRxFkBYWLSGHhGgwGHZGRWf02gOnAgQ9pbDxOaOiAPp3jkSO5NDQUERycQFLSlD4bpyculxQ0hasDxYesoHARkWUrdruJ0NCB/TiAyYnZ3EBk5LA+nWNbm5HWVj3h4ZmEhKT22TjdkZ+fz7JlrxAUZCU1NRSQ+20KmsLVgSLICgoXEW9vfwRB3W9zbSXJitFYiUrli9Pp6LNxbDYTDQ3HUKl80WgCLkllLp1Oh59fE0OHWggKaiEqKqDfpqApXB0ogqygcJEwm/VUVe3C2zsElUp1qafTJRUVeRgMxQQFxRAfP7rPxjl+fD1NTScICUkgPX1On43TE5GRgQwaJCGKRrRaG7W1LUr/ZYVLiiLICgoXiX373qepqZjg4DiGDl10qafTJe6o57CwQX0a9dzQUERLy0nCwgZekkYSsizR1raHzMwI7HaRw4dtgNgvU9AUrh6UoC4FhYuE3d6C2awnPX0evr7hl3o6XaJWe2G3WwgIiO/TqGdvby0g4OcXdUm2q/X6Y5SWriUyMoqMjAXceedskpJSFDFWuKQogqygoAC4rEaLpQFB8MbhsPXZOJ98YuT99weRmrqASZOC+myc7pAkK/v3f4DZ3Ex4eCrz5j3TbxdIClcXiiArKFwEJMmKxdKAKHqjUnlf6ul0iStHupiAgAgiIgb0yRi5uXDbbYGI4kxkeQ6TJ5sYPrxPhuqWioo86uoOoFarGTr0dkWMFfoNig9ZQeEicPLkHpqbdfj7RxEZmXGpp9Mlb799gn/+M4fjx2/usxaIGzeCSuVEllWoVE62b7+40eY2m4n8/M9oazMSFTVcafWo0K9QLGQFhYtAdXUBJlM1CQmT+6UI5ObCr3+dgyhKrF+vZswYyMm58OPMmAFLlwqoVOBwCEyffuHH6Injx9fT0FCAt7cfWVm39Nv0M4WrE8VCVlC4CFgseiyWZnx8Qi6KCOTn57N69epeF7nosFzVqFRONm3qm3nl5MCKFbB4setnX4h+d1itBo4f/wqbzUZMzCildrZCv0OxkBUULgoOnE4b0HfFNtycTznIDsvV2eeWa07OxRViN/n5X6DXH8XPL5Ts7HsuWe1sBYXuUCxkhU6cq2Wl0L/Iz8/ntddexde3jcxMP0RR6lU5yA7LVbjoluvFwGo1UFGxFUmSiIsbfUlynxUUzoZiISt4UArt9w25ufD++9cSElLN8OF9W6FLp9OhVhsYORLa2mxAMAUFJnQ63VlzbC+V5XoxyM//goaGYwQERJKZecslyX1WUDgbyqdSAXBZVkuXLkUQHAwcGExlpZmlS5cyc2b/bBF4uZCbCwsWgCiORpbHMXjwuj7dDk5MTCQhQcLPrxW7PYCysrarvhykYh0rXC4oW9YKgMuyslgsJCWpSU6uJSlJrRTavwC4gqVkZFmFKDooKuq7+tAAAwcmM2XKQFQqJw0Nbciy+qovB3nkSC4GQymBgdGKdazQr1E+mQqAy7LSarX4+FQTHGynrs6KVht9VVtWFwJXsJSISiXjcKi49trAPh3v2LG1xMVpCAoaw6RJCxk6dP5VLcaSZKWp6QR2u4X09OsU61ihX6NYyAoAZGVl8eSTT6JWywiChFotX/WW1YWgI1hKZMUKuPHGvvUh19buo6WlmpSU4dx6q3L/KiryqKnZjY9PIFFRQxTrWKFfo3w6FTwsXryYoKA9lJXlcsstOdx33+OXekpXBBcrWMpqNWA06lCp/AkPH3TVp/XIssSJExtpaakhLm48ycnTL/WUFBR6RLGQFToRExOFVqshJibqUk9F4RzJz/+CxsYSwsKSGTjw+ks9nUtOY+MJDIbjqFS+JCSMVapyKfR7FAtZQeEKwWiswGSqISlp0lXvK83NhY8+shMRkcicOcFkZNx4qaekoHBWFEFWULgCkCQrJlMFTqcDUfS6qn2lHalmQ5Dl/0dc3JfMnx/c5+Pm5+ej0+lITEy86n33CufH1futVVC4DOjtQ76iIg+DoQI/vzhiYkZexBn2P1ypZuBwiIiig+PH+zbVDJSiOgoXBsWHrNAJQRARBBWCoHw0LjXLli0jJyeHBx98kJycHJYtW9bta8vLd2IyVREdnUV6+jUXcZb9jxkzwOHoaPM4b15kn47nLqrjdDqJiYnB6XT2qlypgsLpKE9dhU6Iog+CoEIUfS71VK5q3A95tdrGmDFeqNW2Hh/yTmcbdnsrAQGxV33w0ul1uRcu9O7T8XQ6HVarmfh4DfHxeiIj/ZWiOgrnhbJlrdAJh8OK02nH4bBe6qlc1eh0OtraWhk9WiY4uBUIYfduS5c1qWVZwm63tO9s9G2e8+XCxazLnZiYSGSkQHp6CSDS2tqKVhukFNVROGcUC1nhNJw4nU7AeaknclWTmJhIfLwTf/9mnE47DQ3d16TW64/R2FiIRhNBcHDcJZjt1U1ycjg33RSKINiwWh1UVvoqRXUUzgvFQlZQ6IdkZWUxb14mev0mKisF6ur8un3IFxauwWDQERmZpaT3XGSsVgPffPMzIiP9CQ+fQmzsw/zf/2UrYqxwXiiCrNAJJairf2CzmcjKiuPYsVgGD57Ms88+0+1D3uFopa3NQEhIGhpN8MWd6FWMzWZiy5a/0NSkQ632YdasZ0lJmX6pp6VwGaMIskInlKCu/sGxY2tpbCwlIiKNWbMeISVFsbj6E7IscfjwZ+h03wEiWVm3kpAw/lJPS+EyRzGDFDqxdWsqK1b8hq1bUy/1VK5qamr20NxcSXj4gB4f9Lm58Pe/X0N+/qyLODuFuroC8vPfx253EBs7kpEj77/qa4crfH8UC1nBQ24u/P73P0AUJbZuVTNixMWLVFXoQJKsWCz1OJ0QEBCNWq3pskBIR0WqscjyeNLSPmfGjEs8+asAq9XAtm0vYbG0Ehwcx/Tpv7nqU80ULgyKhazgwVXhSEaW1ahUMps2XeoZXZnk5+ezevXqbnOKy8u30dBQTEBAPDExo7otEOKuSCXLropUxcVjL+ZpXJVIkpW8vL9jMOjw9Q1ixozf4esbfqmnpXCFoAiyggdXhSMRlUrG4RCZPv1Sz+jCcjYh/L6v7w29qb5VWrqRlpZKwsNTsVpjWbp0KaIokZnpjyhKngIhF7silYJrsVRSsgZJsjNo0DwiIgZf6ikpXEEogqzgoaPCkciKFVfWdvW5lKE8n9f3Bnf1ra7E9VQEQcRmayM4OIWamkYsFgvJyQLJyXUkJwueKlAXuyLV1Y7ZrGfPnteRJInw8FSGD7/nqm7ioXDhUQRZoRM5OfDKK1eWGJ9rGcr8/HyWLXuFwMA24uKiLlhtYp1Oh81mYtgwOzExDSQnq88osSjLEm1tzYgiOJ0SiYmJBAR4ERFRi1bbgrd3Q6cCIVfi/eqPSJKVLVteorm5Cn//KK699iUlxUzhgqMIssIVj06nw2KxkJEhkZhYT0aG1GOtYZ1OR0BAAyNGmAgMbCEkJOSC1CZOTEwkNdVBWFg93t6tmM0tZ1TfqqsrQK8/hkYTQ2hoOllZWdx33wRCQmxYrU5aWjRKFahLQEVFHtXVu3A4HAwZciP+/tGXekoKVyDKfovCFU9iYiJ+fj54eVXj5WXD4QCtNqbbWsOJiYkkJEgEBloJDxcoLZW7LVt5LmRlZTFrVhYNDZuprHRQX39micWCgs9pbi4nMjKLIUNuAmDs2BT27AnH23sgjzzyEiNHKvmuFxObzUR+/mdIUhsxMUo1NIW+Q7GQFa54srKy+OEPbyA83IHVCg6HT49W5pAhGYwaNRSVCozGFgRBuCBWqdmsJz3dn6ioaObMuY0vvljF448/ftqrnLS1tRIePhiNJhiTqYbq6gP4+IQwatQ1ihhfAo4dW0td3X68vLSMGPEDZataoc9QLGSFq4KRI/1xOkMRhETuv/8lxo6d3u1r6+oKiIvzQq2OZeHC6Uya9OsLskW8Z8+7NDQUExKSwHXXnVl9Kz8/n8LCfCTJiizbANi16x8YjRWEhSUxevTD33sOCueG2aznyJEPaGtrIyZmFHFxSmqZQt+hCLLCVYHNZkQQHGRlje1RjAEOH/4Yo7GKmJh0brvt5QvmL7Ra62hrayY+fvwZ1beWLVvG0qVLSU6uICtLwmbbw5w54HTKWK0tDB48XvFbXmRyc+GDD3SEh6cwaZLE1Km/VqpxKfQpiiArXJZ0VbmqJ1QqDeBs/9kzbW1N2GxGIiMzL5gIuqpvNeJ0qgkMjO30YM/Pz+evf30ZL6+pnDw5Aa12DceObWTPnq3o9UdQqbwQhAsyDYVe0lEFbTiyPJKUlFxlQaTQ5yiCrHDZ4bYmLRYLWq2WJ598ksWLF3v+frpYm8166uoKEARfRLHnsAlZlnA6BQRBxMvrwpVDLC/fRn39UbTaCEJDB3T6m06nQxTHUlT0PoIgUVT0KBkZt3Ho0CdYrcX4+kaTkjLzgs3lSuBcF2TnirtqncOhQhQd6HRzLvgYCgqnowR1KVxWuHOKnU4nMTExZ+QId1XQY9eut2huLiMoKIFhw+7q8fg1NQeprT2At3ckgYExF2zeJSXrMZmqCA9P8kRPu0lMTMRun4IgSDidakCipmYOXl4tmM16IiMHKZ2ETqEviraczqlV62RZxZw52gs+Rl/RFxXmFC4OiiAr9Fu6erDodDokyciwYXbCwpoIDw/05Ai7xdrLq40JE0S8vNpYunQppaV7sFgaiIwcRFTU0B7HPHToIwyGCoKDoxg+/J4Ldi5Opx2bzUJY2IAzonQTE4MZN+4wTqcaQZAANbfeGkNUVBiyLOHnF6b4Lttx32OQSU4OB+QLUrTldC7XqnUXY7Gi0HcoW9YK/ZLutqUTExMZOLCNxMQGTCYfjEYLWq0viYmJ6HQ6ZNnAtGltyLKDzMwwduywYDK1AeDrG96rUocOh5mYmJEXrGmALEvY7RZARBDOXAPn5b3G2LFr8fX9GfX1P2TOHF8eemgyK1a8h1odgJeX7wWZx5WA+x5PmKCitlZNVFQAZWV6dDrdBd+6zsm5fIQYOmIRoqIsaLXBlJe7FqQzZ85UCslcJiiCrNDvON0Kqq1t6fRgmTJlKEbjDiyWNhobO+cUDxtmQau1YrGoKCgArVZLYGAwFosaUTx7ZJQoCghC717bW/T6YzQ0FOPjE3ZGYJDNZsJgOElbm4Xbb/fimmtczQp27XoTg6Gc0NAkhgy55YLN5XInPNyXadPM+Pi0ATI7d0oXpGjLlUBJyREGDqwjJkbAaHTicIRTVGTok8WKQt+gbFkr9DvcpS6TkrwYOPAkSUlenUpXZmdnERjoy7hxMzsV18jKymLUqGH4+EB1tQO73SXWMTFRl/J0OHJkFUbjSaKiBp6xDX7s2Fr0+iNoNJGEhw/0/L65uZiWlmoiIwcrHYXakSQrTU1rSE0NQhDg6FE7ICqlRAGTqYb6+neJibEiCFZkWU1lpVlZrFxmKBayQr8jMTERrVZLSEg54eF2WlpMaLXxnR4sXl4qUlPTzngQZ2cP58CBfGbOHM8LL7xGVlYWa9f+vFfjnm1r+Xyx2fRYLHpCQ+eesQ1eU7MHi6WR6OgRpwV7OXE6Zby8fPuko1BfRyn3BaWlmykv30BYWBwZGbcyf/5skpPTL5v59wWSZKWiIo9t215CkhpJSEhm9+4GDh6U8PLSKouVywxFkBX6HVlZWTz55JNs2vRTVCoA2fNgMZlqaGgoRBA0eHt3Tksym/U0NZ3Ay0vLoEFDz/lBVFdXQF1dAd7eoRc459SJ0+kEnGf+xWnH4bARETGwU7BXXt4w1q37A1arljkXOOPmbGlj/RGzWc/OnUuxWFqIispgwYLnrvoSljabib17/82hQx8jyw4CAyO4++4/sWBBEFVVdZfVYkvBhSLICv2SxYsXo9Gsp7p6HdddN4eHH3ZtS+/c+TpGYxVBQUlkZ3fe/t2z512MxgoCAuIYNOgGz+937BjCt9/+AYvFm2uu6X7Mf/0rn/Xr72XkSB0PP3zhIqzz8jJZt+6PWK1encZ31ak+iCj6dQrcys2F3/72LkRRYssWNcOHn3twUXcWsNs/LwgOBg4MprLS3O8Dfw4c2MO2bc9jNhcRFBTFtGm/verF2Go1sHXrS5SUbMThaCMsLJl58173LCSzsy/t/BTOD0WQFfolkmQlKEiDXu9NTEzcKb9vpa2tmdTUWWekMFksNVitTaSljSMpaTLgErff//5+RFFi61Y1I0Z0LW65ufC737lEcPNmNTNmXJgIW9dxf+AZPzu747g7d75OU1MpAQFRnQK3OopSqFGpZDZtEs9pLj1ZwO4o5cmTBRobHcTHB/TrwJ9ly5bx3/8+x9Ch9Xh5QULCgLOmrl3pmEw1fPPNUzQ2lqNSqYmLm8KMGc9csKwAhUuHEtSl0C8pLd2MXl+It3cwoaFpnt/bbK3IsoQgCGf4Vm02Ew6HhLe3nydv1yVuTmRZjUrlZNOmrsdzi6DrdXK3rztXehrf4bBgsxmJjR3eKXCroyiFE4dDZPr03o+Xn5/PsmWvEBJiJjPTF1GUOuXpxsfHMnKkhZCQRkJDm/t14E9+fj5/+9tLpKYa8fWFlhYv3nsvnyNHCi/11C4ZJlMNK1Y8RG3tEUTRyZAhtzJnzp8UMb5CUARZoV9y/PgqWltrCQ1NZMSI+zy/dzrB5ZM98z1d/c0lbgIqletnd+J2amWmcxXBnugY39nN+AI+Pv6dFhcdRSmEcy5KodPpCAhoYPRoI5GRDSQn+3SKUI+MFBg+PAIAvV7C6VT128AfnU5HfHw1cXFtCAIYDBEYjZLnXK423GLc3FyHj48v48Y9yZgxPzwjlqIvUKp/XRyULWuFfondbkGSzISFZXRa/Xt5+bbXmT6zWEZXf3OL26ZNMH169+LW8Tqxx9edKx3HFTod19VsoglQdxlFfb5FKWJjIxkwwI6PTxtWq0BZWZvHApZliX373iUw0JuQkAnMmvUo6enZ/VKMAfz9ZYYOlRBFEASoqZHQav36pTXf13QWYw0zZvyO5OSpfRKBfzqXYxDg5YoiyD1wOaaGXOk4HFZAaP/Zu7/1Vtz6qjJTV8ftqdnE98HPr5HMzGDq62uprHRtlbst4KqqvVRUbEWSZEaMuI7p0+++YONeaGRZorz8DUJDobUVCgtFDIarM43nUorxgQN7+O9/n2PQoDbM5mgqKpTqX32JIsjdoKwK+yc9tVE8lxaLl5r//vck69c/wJgxNTz00E1nf0MvKS7+Gl9fFQMGjGXOnCdJS+tI/zp06CNaWmoJDk5Co5nE6tWr++1is6zsO8rLtwEQFpbIo4/+hdTUIf1yrn2J2axn1apHaWo6iUbjf9HEWJYlGhqK2L79TwwZUo9G44XB0ITNFtVnpUoVFEHuEndqiFptY8wYLwoLbVfUqvBysPwFQfT8dyrbtw9g48Y/0doKc+fS67/1J1yR1/d6IrqnTr0wlrnRWEl19X7Ai6FD5zJz5h2ev5nNevT6IzgcEjU1al544aF+u9g0m/V89dWTOBwWQMsNN7xMZubVVT40NxfWrrXg7/8fkpIq8fLyYcKExRdFjE2mGrZvf5Wqqr20tp7E21vEYFBRVRVCbW1Lvw0CvBJQBLkL3KUbx4xxkpjYDASxe7fjilgVXi6Wf1f+4NxceO65RxAEiW3b1IwZ0yFkp/9NEPZw222afnm/vm9aU3d8+eWvOXkyHz+/ZMaO/XGnv+3Z8y6NjSdQqUL46qsCBEHbL/OQZVli27bXMBjKAIn09LmdcsqvBnJzYcECEEVvZPmnPPpoLQ8+OIhBg27oUzG22UwUF69l7943aWwsRaVSk5Q0Ars9m3ff3UZLixGt9up0G1wsFEHuAnfpRoejCm/vNhwOJ1pt7GW/Kjy9l3BTU1O/ehifSlf+4J6EbONGEEVX2pIgSLz88l4++ODP/XLBMWMGLF16fmlN3bF06Uvk5S0nJkZi374W1OqPO5231VpHW1szKtUgamurGT/egiy3olKFcvRoS79ZbNbUHKSg4HOcTjtqdTCDBs276lpPulPlHA4VouigoeE2hg3L7LPrIMsS9fVH2bFjKVVVhwGJ0NBkkpJmMXr0D/D1DScnp//vql0JKGlPXeAu3SiKKux28PUVeOKJn1z2H0S35R8d7Ut6ejXR0b6dUmL6E7t3j+Krr55j9+5Rnt/1lJo0YwbIsoggSDidajIzd6FW2/qkV+735fukNXVFfn4+//vf/yM0VEKWoaVF0+m8XRXBDiAIfkRHDyY93U5ERD3Bwc1YLIazbkFerJQXSbKyZs1z7Nw5kDVrXqSh4Qmysm7t0zH7I6emysmyiltvHdJnYmy1Gti582+sWvU4FRW7UakgNnYUCxe+w9SpT3kyHLKysrj++usv+2dgf0exkLth8eLFpKVJHDjwLwYMCGDevOxLPaXvjdvyDw8/QWyshMXSRG1t/7P8c3Ph2WcfRBRd28+jRnVEKneXmpSTA888s4eXX95LZuZWxo//mLKy/utquJAR3TqdjpiYBvz9wWwGWY7EYjF5zvvUimDjx9/K8eNr0etNGI1O9PqetyB/9atf8e677yJJEoGBgX264/DSS0+xYQOsW/cFgiCRl6c+4z5fDvEP35czU+W0fTKOu+JXbW0hggDh4elkZd3NoEHXXJTcZoUzUSzkHpgz52EGDRqFLOspKVl/qafzvXFb/mq1A5XKgVrt6Jf+oJ6qW+XkwCuvdC1mt92mITHxWbKzP0SttuHlZerR+rtSih3ExkYSGUl7Iw4oL7d1Ou9TK4IVF6/Dz89OfPwgbrrplU7tK0/n17/+NS+//DJNTbXExDRhMun7bMdh37489u17i7q6qZ5dDpD49FO95zXLli0jJyeHBx98kJycHJYtW3bB59Ff6Olz/n2RJCsnTnzLp5/eTX39cXx8NKSmzmbBgn8xdOhNihhfQhRB7gFvb38CA2Ox2Sw4nfZLPZ0LwuLFi5k//xYCA32ZP/+Wbh/Gl5KzV7fqmqysLBYtSsHPT6a1FUpKArpdcPT24X45iLbdfoSYGNe/m5roVH2ro6WkCkEQ0em2YLfbGDBgPLfc8mi3i7H8/HzeeecdvLwk5s2D7GyZhIQWjEZjn7g48vNXEBpqJTl5o0eMQU1ycplnPn/968tERJiJj4/E6XT2S3dEf8ds1rNx4x9Yu/ZpWlpq0GoDmD79D8ya9Xul/GY/QNmyPguutBsRu92CLEsXJRm/r4mICKK21puIiKBLPZUu6a66VW8YMiSBI0d8iIkZwU9+8gbDhmWf8Rp3cJsoSmRm+lNW1nWxg8shIl2SrGze/AcANBo1N964lF//eprnPE5tKanXF2IyVRMSksrMmb/v8bOs0+kQRTM33gixsdDWBj4+oFarL7iLQ5Ks2GyFBARAQMBK5szJ4fDha7DZ9nLbbT8DoLT0GKmpdcTGqqis1OJwhFBdXd2jO+Jq2N7uLa40qla02n+TmPgVarUXkZGDmDv3NQID4y/19BTaufzVpY/x94/GxyeMhoZi9PpjREZmXuopfW9kWcbpdCDL8qWeSrecr4/V6XQgCALJyQldijF0BLdlZqpJT68CQikosHR6uJ9Pm8K+EoCejltauhmTqR6A6Oix3HrrTzr93d1SMju7lBEjNmOxtDJo0DiCg5N7HDM2NpLx483Etz+rjUY4eBAWL77/gotbaelmmpsP4O8Pej14ea2kqWklfn6hbNgwgoyMdOz27aSmWpFl8PUNpri4qUd3xOWwmLpYdKRRaZDlX/PII3puuSWYiRMfv+rbWPY3FEE+C8OH30N5+Vb0+iKOHFl1RQjylYrNZsJiMSAIqh6jUhMTEwkMVJOYWIWvr0xgoOOMtDa3aA8erCE19SQqVRhHj1q6tcj6SgDOdtz33y9n3bpnSU7eyKhRcZ3Eu6Qkq1NLyR/+8BGGDKklIWHSWcf182tk+HBX2Uq7HQ4e9OWJJ57g+eef/97ndDoFBcsxmVzb4M3NcPBgCCkpUVitVl577VXS0tqoqlpLdHQwx49b2L/filrtzaJFizzb56f3fF627BUCA+2EhkbR0NB8Xul9V4qF3ZESqEIUJUymHzF1auJVl052OaAI8lnw9Q0nNDSNiort2Gz6s79B4ZJRUPAVBkMpPj4RxMdP7PZ1WVlZ3HXXUBoaKmlrA73e7wxfc2JiIkFBKlJTdfj7ywQH29FqY7q0yHq7BX6u5Ofn8/e//4XU1FZkOZTycnun4/7vf0388Y8PtUckP4nd/nO2bp3tiYhOTPwMlSobh0ONKDooLBzOtGlVDBzYcxkzs1nPpk3PATJ+fhAYOIl3311Kdvbo8z6X7vjvf6t4442xJCToycjYyu7dFqZPFygvF2ltDcFiOUF+/r/w8nKSnDySa699mjvvbGPz5s0sX76cd95554yFSllZMTEx9aSkqKms1CLLZ9/ePp0rycJ257278/RvuikNtVp1qael0AVKUFcvEEUVTqcKi6URSTqzqcHlRndlKS93ysvXYjY3EBqawLBhi3p87ZAhIYSGaoiNHcrSpWdGGmdlZXHHHQMICJCRJNDrfbsNENPpdDgczYwfbyImpo7kZPUFye/W6XTExdWSmdlCbGwN8fGd88Y//vgIouiKSBYEifXrY2hoqMXHx0BLSxNHj77eKZ81NTWP6OihZ42i3bXrLaqqdgJO/PxSefDB5X0ixl9+6eDuu2PZvv2HLF+ei9H4AjNm2AkMbCQpqQaTqY6xY604HG0EBsawcOF7jB8/i8TERD7++GNUKjvZ2RpUKrsnwEuSrDgcB8nMtKLRGAkObqWpqeft7dNxW9jBwRYyMgIRBMdlHUDmjsl44gmRFSvgxhsVMe6vKBZyLwgNHYCvbySNjSeoqMgjJWX6pZ7S96KnFob9kd5vHQrIsp3w8AE9+sYkyUpLSxUgk5qaysiR47t8XWZmLAUFGry8BvLAA//s9nWJiYkMGWIhPNxCWxuYzd5otQHfO/gpNNSHtDQHoijj5aWhstLsEZb8/HyCg9cgy5MQRQeyrKalZRPJyTBypIO9ew0YjV/yzDM/4uhRJ0FB/2bEiAKczsk9NpUwm/UUFa0EbAAMGTKvz4J+Vq3SI4phyLLLgj90KIjJk32prTWRl2dnyBArqakBBAaGMmPG7zzz0Ol0OJ1NTJsmYTaLpKeHcuCAhbKyYqzWPE6e/JKYmGBKSlrZu9eGSnVu5R5LSo6QllZLXJyIwSAjy6EUFRn6ZT57b+mrTmYKFxZFkHvBkCE3UVLyLTU1+ykr237ZC7IkmXE6nUiS+VJP5aycy9ahIKgQBAFB6NkCcAVC1aBS+XUbE2A0VlJffxRB8CIzc4xHjLtaHKSnxzN+fCwm0wnq66G+vntr+lxoaVlPfLyW+vpW9u/vSGfasGEDr7/+IhMmnGT+/INUVt5MefkqRo5cSVKSq3dwSgrk56u47TYN5eX/YP/+jykpCeLPf/4tdruz22u5a9dbVFfvBSAgYBCTJ//ie51Dd9hsJkJC3keWn0IUJWRZTULCeoKCYhk79gkmTaqjpuYjBMHJwIHXkJQ02fPewECBa681ARK+vv7s3i3h5+eDw3GQXbu+xG5vIz19HNde+zNuv73tnHzAJlMNdXXvkpzs2gnz8vLrtBBSUOhLFEHuBRpNMIGB8ZSWbsRuN1zq6XxvLocoa+jwzfr4WBg3TuLAAcsF8c0WFa3EbK4nImIQ48Z1nYe9ffvLtLRU4u8fx+jRPwK6Xxzs2/ch/v42IJxZs27j179+5Jznd7rQm0w1lJVtQKVSk5U1k+uue5zk5HQAbrrpekaNqiY4GNTqlZSXf8fcuUZiY13H0uth5054/PEHGDIkg88+201TUzMHDjRTVaUiJibGk8c7c+ZMwGV1RkeHcvLkd4BLjAYOnNFn1vHRo1+TmPg2999fRE3NDcTFrSYjYwPDht3L6NHzWbHiYQRBIiIijcmTf+EJQDIaKzl69I/ExPhSXd3K+vVqBMGLhx+eS2XlZ9jtdiIiUliw4G38/aPPaU6uvsMP0NJSQmxsFAcPtrBnj4xareqXBXQUrjwUQe4lXl5aRNGP+vqjmM36KzKJ/kJElZ5+jO9zTLdvdto0M15eVrKzQ9m0iW63DnftGs6mTcNpbXWleXSHKxbAQlhYarcP7ZaWGmw2E3Fx44iJGdFjGlRNzU6sVgMxMcO5884/nXMqSVdCP3hwDU1NZWg04cya9XPa2uLR6XSUlZURG1tHXJyMKILN5kVoqJXYWJdlLElQVeXDY48t4fnnn+e557by6ad3kpAQRUDASkaNcmC3V2K3p6PXm/jrX//KunXrsFgsDBhgY9asVgBUqnCSk2ee03n0FpvNxLFjn9HWZmLChCNYrXnYbFYSEsYzceIT5OX9k4aGQtRqfyZO/Lnnu2Yy1fDFFz+gpaWOsLBkJk/+JTk5wQQGChw9+ntMJhuhoXHnJcZGYyVffPEARmMNGo0vY8b8iPnzJ1BT03jZR1krXD4ogtxLhgy5hc8/t7FqVSYVFdv41a96eOL3c3btyua777I7CdeFiCo9/RgjRoxg//79533MxMREBg40otFISBKUlAjdbh3m5sLzz/8EQZDYvl3NuHHd+8xUKm+cTtfPrpBlCYfDitMJPj4BiKL6lDQoH9LTKxAEfw4dsrFu3WdoNIdxOCAqatBZxbirBcvpQv/Xv77M4sVx2O0WkpPHsWpVPsuWPYrFYsHXVyI19Ro2bZpBYuJGVKqVpKWBn5/r+KKYzO9//ybjx88iNxeeeWYygjCe/PwnmDYth/HjV1JbC0VFJ5HlAFatWoVGI5KZ6Y9GU05rqx0/P0hKGnnWaOzzIT8/n71736e+fi8qVQAWSxNtba2EhCRw/fUvI0lWSku/wW6XSU8f5dmqtloNrFq1hIaGEtRqLdOmPU1m5s1YrQY++eQOWlrq8PePZuHC985LjD/99C6am/X4+fkxceIvyMi4QUkLUrjoKILcS3bsGMLf/vYCoiixcaOaIUMuzyAJl3A96ukbPG4cpKZ+/7Sd01s71tbWkpubS3x8MBMmeFNQcO7H3LBhAwEBEt7eUFkJJSUOfvvbrrcOz6XHsMNhQxBcP7uiqmovDQ0nUKmCCAlJA1yLAz8/H2JjdQQEOPH1bcVoVLFu3R8ZN86HgIBEz9Z2d3S16ElPTwcamTbNSU2Nnfj4IGy2coxGG15eoWg0Q1m27HVAJiUlDKdzIN9++zmCILF37xJmzcohK2sVICMI/kyceDfjx8/yXJNTW1KaTNOx21dis0FBgQVvb5fPPSMjiPR0HeAuDysQEzPmgtc0XrZsGa+99iqZmRWkpDgIDQ3Dz88XtdqfadP+D3//aL799jc0N5cRHJzArFl/RK3WIMsSu3e/TU3NXpxOgays2xg8eAGyLPHddy9iMOhQqfw6BX71FpfV/QBGox6NRsPMmc+RmjrziqjIp3D5ccnyXi6HGsGn8t13qm4bHlxqzuVauoXL6XQLV0cRjORkSE2tITmZc07bcR8jJkbLoEGVBAeDKEqMH9/SnrpjP6djdviPO37n4+PHjBkzunx9T60ZT8VmM9HW1gJ44eMT2OVr9u59u73EZBLjxrkqX2VlZXH//dcQEuJEksDhgAULvAkKctDaasbbO4qYmBFnPR8vrzYmTBDx8mprF+cWJk40ERRkJDq6icpKMzExdmS5ldDQBLy8hrXfGzVDhhRhtU7xNF8QBAmrNQeQARXh4Vme+bqvyaktKWNjN2E2Q2MjTJoUTUiIH9BCenolfn426urms2HDKxQV3U1a2uzub8554D5/h2MKZWWvUlw8H72+AYvFRnLyOFJSpmMy1VBRsQ2bzUFS0gSPuNbUHOTo0f/hcAgEBQ3EZBpMYWExpaWbKS1dh8MBgwdff87Blm6fsdFYh1YbwJw5LyhirHBJuSSfvMsx6d6VXH/uDQ/6mnO9lu4iAacKl7sto69vBYGBEr6+VrTahHOKKk1MTESlUhEWdpSYGGhtFdBoICKiDUGA1tY2tNqwXh/TLfBhYa4uRtHR4HB030qxp9aMp/L66/v48suFpKZGc+21I7t8jdMpIUlWYmIyO21/DhhgQJK8OHnSTnIy+PpacDjA6QS7XX3W2tAORzMzZ1rx9m4Dwtmxw0Jx8SZiY31oazNTXe1EEASGD89AEMqIiBhEauoQgoJUpKeXEBzsJCVlIwcOLPFYvklJm3B9jb2Ijx/Wab5Tp5bxox+9ysGDKSQnbyEjYzUnTsDw4SItLc2IYiSxseDtDVu2/JHdu38DONi7V8Utt9hISTnbXeo9Op0Oo3EiDQ3/QRAkDh9+nHnzcoiOPsasWX9k9WoN7713gpCQdMaNkxg/3vUZNpv1bNjwDK2tzbS0OPjXvw7T3PwEgYFq7rzTj4AACR+fKCyWERQWFvd698VqNfD11z9Drz+BWu3H5MlPKWKscMm56J8+90oZZJKTw6mtbbkgkbN9zfdpeNBXnGp1ZWeLvdoW7lq4XG0Zt2xZgiiCj498zlGlGzZswGKxYLOBWg3gZOzYaDSaGurroaws8JyO6V4kOJ2u/3c6OWvqydlyLXNzYcmSqQjCRL777n6uv97E6C7qXbh87CNobXVy442u3xmNlZSXHwBc/uzgYFcQlSy7Gi9ERqad9XyGDDETGGjFboe6OjuyLJOf/w8iIlwlKhMTb+anP53KsWOv0dLiR0BAnKdAicFwEoDU1JXcccfPiI5+GR+fpWg0/wXUBAWlMGrUDz3jybLEhg2/JSFhJTExZtRqLSpVAkFBZTidMg6HF4JQS0gI1NXd3i7GTkCFKMps2eLNwoU9ntI5ERsbSWDgeBobO6z7ysrpJCVFsWlTfHut5fHI8iTi49/yWMe7dr2FXl9IW5vIN980ER0N8fGBCEId9fWVWK3BbNjQjE73014v7ju2wA8gCN5kZ9/NoEE39BsxvlJKdiqcOxf9E+i2fNLTg4mIaMTX15ejR1sui6T7/pZc776W2dl2EhKMQCA7dshnvZZdncfixYvx8fmGmpr1zJ49ix/9qPdtGd0Lg+Bgf6KjmwAnajUMHTqY+vpGIiLG8LOf/eOc7m9WVhaPPHI3NTV/BFzi931TT073M2/f7s8tt3R+TW4uvPDC457gsPHjXdfq1VcX0dx8nLY2EEXXosNsdlmXQUEJLFjwhx7Hjo/3Z/x4f4xGK83NAhUV3iQl1RMa6jpeVZUfhYU7mDDBgdmsx8cnDqMxnc2bvyIsrK79KCq8vBJYsmQRfn5lLF/+H2prAZxERQ3qtGVeVbWXkyd3I0nNqFRaRNEHtRrCw304edLGzp12ZsywERrqQ1HRnYiiE1kWACey3P2W//kgyxKCUMS4cXmUlj7m2UIfPLiAOXOe5P/9P9p3nlSIogOdzrVdbjRWUly8EpvNgUYTR2xsORERTiyWVvz9ndhscOSIGb0+mpiYMJqamnq1uHdvgUuSRHLyVMaMebjfBHCd646XIt5XFhddkN2WjyDo8fc34+/fQENDiJJ0fx64r6Us1+Pj40CWDWi1ied9LcPCgtHrVYSFBZ/T+9zbsZMmCWi1LpPW6YTWVhuCIJKUFHteD4shQxowt9cuiYoa9717N3e1XX86XQWHpabmk5+/nZQUl+/Y29tlFTc03EVZ2TimTrWdNbL3u++ew9vbTmBgBGPH/pJx47zZunUxGg1YrWC1RmGxmNmyJZ0jRybidG6gvPznTJlST2amCvBCFNWkpIwgJmYEq1Y9RkNDKaBBrfYmMDCuk4W3d+/btLbWAz7tBVPU2GwGfHwiuOGGxxg8+BtaW/cREJDAPfeMY80awSPKTz99YReeVVV72bz5j2RklDNs2HNUVMwlLe1rMjKOEBEx+DR3kIr582OQZYnPPvsp1dWF+PhEIIoOIiMlSkvnc/LkTBITNxAWtpLjx2VGjTKj16sRxSBOnqztcUFqMtWwbt2vMJtdkd1z5vzxggWvfV9xdC9s3SVBi4vtPS4wLkfXX08oi4tLIMhZWa7t0b/97SWioxuIjHRyyy3Drtob8H1wX8uNG3+KLH9/K/Js6UCn4/4CtbW1MWSIhYgIC4Lg+puXl4CfnzcWS++O0dWXsLx8j+ffQ4fOOqdz6Yre+Jm7Eu2ysmJUKtdCwx1ktn//fL799oP2xg5qJk3qXsSMxkoqK/Ow2doYNGg6t976BBs2/Jfycpd1LAhQW9uGLN/A228/125BLmbkyHuJjHwfo9FBYKAvgqAlODgJUVQjSW3k50+hrGwOWVnHWbSoY3CTqYb6+gLa2kx4efkiyyJOpw1ZVpGUNIqJExdQVfU/TCaBlJQJ5ORE4e/fN+4Yk6mGb755CoOhgR075nDo0G8QBIk9e0bR3FzIzTcXkpOTdZo7yJsXX/wFx49/3r7QbCAqKoimprtYs+aDdh/0k9xyy0NMm/YWTqcePz8b+/dbe3RrfPGFjXffLSAiIo1Ro5q59tq/nHOKVHd8X3GUZYmjR79jwIAqoqNV2O3epKcHc+BA1x3G8vPz+etfXyYy0opaHUZV1dnbg/ZnrrTFxflySZwmixcvZubMmWzf/jKNjZsYMCAcq9Wg9OY8DxYvXoxGs57q6nXMnTuHhx8+fyvybOlAp3L6F+iaawLw8bHQ2uqyIDMzhxIeHo6+hwZZZ/sSNjeXt/9L021FrXPlbG6HrkR73bpaIiJc4ule+JSXz/IEVp0tzWr79pdpba3Fzy+WyZN/hSiqKS9/Fz8/l+9YpwOr1YshQx5Fr+9IU5LlbHx938duBxAIDU0jKGgu//d/m1mx4j4KCqZ7FgTXX28jrd2NnZf3NwyGMqANu10ARJxOFYGBScybt5S8vNdoaakmJCSVqVOf7tV1OR9sNhNr1/6SpqZynE4VBw/O7BQhXlExgc2bN5OVldVp/L/+tZx//COO7OzrSU52pWnV1jbT3Hy/55qLokRt7XiyspZTUdHK7t1WjEY/fv7zrhekublw003eiOJ0ZHkWyckfERU19IKcp7sZRVCQjZiYUKqrW89JHE2mGrZvf5WTJzcyYEAbAC0t3hQXS10uMMxmPatWPUNWlg5fX29aWrxwOEIoK9NfFq4/N1argcLCLzl2bB+rVr1NaqqALEed0dXsauKSRTFkZWUREHA/3357grq6Ixw69Cljx/7w7G9UOIOoqCj0ejVRUVHf6zguP5p4Vn9aV8UsGhvriYlR4+enBdoYPHhQr46hVtsYM8aLwkLbGV9CQRAoLJxPRcUNjBgRfdH896eLk82WT3i4Szxd/w/jx5s5flxs32bt2efqqvrVSkrKeGJjR2O1GqisdNWL9vMTueeet3n22VGUlGSxaRMe0UpO3gRAYeF8DIY5JCef4A9/+IS6un/jSnUCp1N9RhCW2VxHa2sd9fXg62vFZoOQEDXJyePw9vbn5Mk92GxmBg4cSXBw8oW8dJ0oKPgKnW4bDoeT2NhxjBy5ntWrn/Ccn822juef34MkSZ6F2JdfOli8OAlB+AmlpU+wcGEOCQkrqaz0ZuRILV9/LXqaaaSn7wTC2bTJh8ZGGV9fEac7CvA0OlwRLj91be2NFySIS5YljhzZwPDhVWg03jQ1eSHLgb0SR6vVwJEjn3P48Ec0NpaiVvsQEZFBXl4FR46IqFRenh0vWZaorz/KkSOfsnnzJ1RVubIZTCYbTU2t1Naq+329bZvNRHHxWqqr9yEIKpqbdTQ1lVBTU8yAAa2ADwaDAYcj4rJv5nG+XNKwwri4sUREDKGk5Ftqa3cjSXf3m+CKqxNXUA8IPW4ln161SqUKx253PQjVag0Oh/3MQ5+G+xhjxkikpDRjs2nZtUvlsZgAioquZ/nytxAEiQULXJbrpQiq27gxhm3bXiE5eSMZGSvx8xvGCy88wi23nH2b12isRK8/hiyr8fePQhTVbN78EtACQFTUCBYuvA+ArCz4/e/fY82aZqKjvyUlZSVHjsxnzZpcjyWs1a7zCBqAIMidgrDMZj0lJbvYv/86KipmkJS0kfT0lVRXS0yePJOdO/+FwVCOVhvLkCE3d5rrqS4IHx+f7+XLM5v1HDjwLywWM6GhiZhMRYwdW4Ys57B583Ss1s3Exu5FrfbyLMSGDMlgxYoKBCHBY0WXlk5Hq/2Go0cjee65QOLi9vLxx4dJTt7B6NFH+cc/Whk40I7NFkxZmbNby6qzK0LFnDnaHuffG3+m2axn586/o9N9TEyMHUlyYDI5qK1tOas4Go2VrFq1mJqaY4iik4CAaJKTZzFx4uOUlNScUdd8+/ZX0el2UFdXgl5/ErUaKipUHD/uoKTEQESEH7/85S/7nYCZzXoOHfovFkszLS1V1NTk09p6EpDx948hIiITP7/hfPfd2zgcArIcfFU387ikgqxWa0hPv4bq6sPo9UWUl28jLe37+woVzg9JsgBODh7cy09/mtPtVrI7mCw8vJzgYJnwcAuq9gZLsuzwvM7Vc1nosu+y+xhabSk+PqBS2TEaVTz//PMei+nkyXke8XEVYxEuuiDn5sLLLz/dLohLWLToRhYu9EajCe7VNu/pTSpkWeK//62kqOgVkpM38dBDz3he29hYTEjI81x3XVX7bzS0tCzyWISCIKHRCFgsas91GTu2jqef7tg9ePXV7/jggxcoLJyLIEjs27eEhQtzUKlWYrUG0NZ2jLY2AwkJWZ0KabjdB3q93nPfw8PDz9uXt3Pnv2hsLMbLyw+73Uxbm4HAwFimT0+gtvbXpKX5UF2diNnsTXV1NTqdjsDAZtTqD3A63/CcX0jIJvbujeCxx35BbKwGWb6D665rJiIiCV/fBYwe/Qt8fZ1YrTIQTUGBqUvLqrd56qdei+4+/7IsUVt7mPXrn6a2thi1WiAiIpXvvtNz/HgbXl7e3cZy2Gwmioq+Ji9vGS0tdUiSHW/vVNLTH2Xq1BxEUU1WVjhZWVlYrQb27Xubw4c/Qq8vweFoQ5LstLW5iuBADOCPn18tTz/9NI8++ug536e+wL0V3dRUQVXVbozGamy2Rry8/PD3jyU6ejb+/rF4ewczcuQ9+PqGU1ub3n7NW9Fqz61d5pXEJU+8S0+/hqNHv6CycgfHjq0kJWVav8kHvFzw9vZHEDQ0NBRiMtWcd6CKSuWNJMkcPHgISOg2T9wdTLZ165Pt73SSkTEMOIZarUaSXCK8b98EvvtuMmazg1tv7TxWxzGeAFz+2ZiYGNRqtWe84cOPs3atq1euw6G6JMVYXOUnXe0BwcGmTb8jIWEtt93Wu/ef3qTinXeO85//vOsR+IkTy0lLc/UnLix8AZOplrKyO6ipuYHQ0PeZOLGezZtVHlGeMGEZKtUyjh2bjcFwmDfffIKsLNf9zs2F3/zmZk7dzhYEifLy6SQlraeoaCBr195EWJiNoUODPbtRbh9oYGAz8fEtlJeDydSKzeZ/Xr48s1lPaelarFYzWq0XVmsTKpWG8eMf4+TJEiZPtiHLNtTqWvLy/NFqtQQGCqxc+SgpKXXceaeBiooZJCfv5rrrxjJs2PMkJ4fz0Uc30drahL9/GNOn/54vvngUX1/Xzkxdnavka0+WVW8WUPn5+bzxxp/JymrBZAqnvNzR6RrYbCYOH17Onj1vYjY3odX6k5AwnhkzfsfNN+t7tKpdRU7+yIkT3wJ2jEY7GzY0c+LEIby9n+LJJytZvHixR/A3bvwDNTVHaGszIAgO7HYBp9OJWi1gtXrR1OSP1WolODiYqVOn9vr+9BUmUw17975Jff0R6uuLsVga8PHxJTQ0nejo+QiCD0lJ40hIGH/GTqg7rkiJsr7EeHv7Exs7ksrKA+j1hej1x7rtUavQNdnZ91BSshmDQUde3t+YPfu58zqOLEuAjEolk5ysJiHhJBpNGIWFZ1odixcvRq3+kvr6rUyfPpnw8HAKC4s4evQ6iovHcPBgIp99loMgSOzYoWbChDMfhnfffT1NTX+gubmRsDAfpk2zUFoaQUmJy38kCCKDBn1FQEAUzzwz5pJsV0+b5mDpUpcYg4ra2mH85S8jmDy5d9vnu3dns2XLRKZMMXPXXWo+/7wUQRjgEcvf/OZbfH1/Q0iIwO23OygsnMPy5f9qXwTk8PTTf2PFCvj2Wzv19Y8SE7MSSYKTJ3fw2GO/7XRPXH5SZ7v1BOAqkepwmAkK+hc//ekgRDEdWV7AiBHfeN5XXl5KZGQdo0ZZMJtdW+c7d8pYrV40NlrYvHnzOT0od+16i+bmclQqb2w2C6KoIjV1MpIkU1GxirAwLSdP2sjLkxAEgZ/85D6Kil7AYjEgimrGjt1DdnYeQ4fewuzZTyFJVlaseITW1no0mmCmTn2a1asXI0lmIiKiWLNGQqeT8fFRfy/Lymo1sHv3P5kwoao9HU3E4Yjx+DPT0+P57rv/x7FjX+F0QkhIPJMm/ZKUlKmo1RqysqJ7TLdaufJRamuPoFJ54e2dwCefFBAYqCIjw5+yMomlS5cyceJIbLZdHDz4XxobdchyK7LshZeXD8HBEURGDkIUbXz66T7q65vQaC5M7+3z5csvHaxZYyAlZTPR0W9gMFSiUjnx948hPn4sfn7hjB37414ZCVlZWVetELu55IIMMHz4PZSXb0WvL+LIkVWKIJ8jUVFDiYrK4PjxVVgsPYQ1n4Xg4GQKC2+hsHAMQUEbiIxcSUuLsdvc5rCwUOrrRcLCQgEoLJzHRx+9d0okrewJOuoqCnn9+mcAV9BRa2sbKSlttLU1UF2dwokTmbz44vWd/KWXgtGj9/DQQ+/x1VcPU1MzFKdT1e35nE5uLvzlL7/0+H8nT4bMzMOsXt1xXgkJG0hIUKPVnqSlxUlZ2ZxOkcRVVTeQkwPBwf9gx47PsVq1REbO5Yc/fIZhw7I7jefO5+2w6EXAwcGDvyExsXNQU3n5NM/7fHyaGDPGlZ8WFuYqeBIXB/v22bHZbDz//PM4HA60Wi233347U6ZM6VacP/vMwltvDSE8fCKDBn0NqAgJSSYmZiw7d76E1WohNnYoc+b8kRtvlIiODqWs7A1KSspwOr0IDAzGaKwmMnIAU6f+ErVaw65db3Py5HZk2Yvhw3PYtOkPtLa24O8fyEMPreDmm63f27Jy+3RPntyFr68r6r2sLNTjzwwP9+Xrr5+ivHwbAFFRg5k///VeCY3BUMbnn99DY2MtPj5epKTMpLrayqBBmwgNFbFaJSCc4uIGtmz5OXb7SSyWegBEUUtERDLx8aOIjh7HsGG3oNEEs3Dhpc/Zzc2FhQtViGIwsryQhx9ez+TJKuLjp5CcPLFLS1ihZ/qFIPv6hhMVNYyamsOcPLntiu033FeIohovL1+cTgeyLJ/3cfT6n7J8eUi7WDxJZGQOPj4ru12BS5IVcCJJVry8fCktneYRA5cY91yEw2YzAnYiIgZjMBwFXHm+S5YsoaQkqd3au3T+Y4Ddu/9FSsrnzJvnxZtvvtYulr2rZNVhsbrOYc2aZgYPfpdFi/ZTU3MbDQ3vM3v2CoxGAbXaiSjCgAFHycsTPaKckxOLwVDGgQP/wGq1EBmZyX33/bPL78cNN0j87Gd/YceOAJqaBnLs2GxkWYVKJSMI4inNN1TMnu1y+hsMZRw9+gKhoa4ocpvN1VN55041Xl4iarVMYmIbQUFa9u1r4KWXXuLf//43gYGBZ/hWc3Phllu0iOJcZHk+ixbdxogRuxkw4Dr27fs7bW02QkPjufXW/3miu/fvX45Ot43Dh2dTXT2XpKRvycjYyOjRP8bXNxyjsZL8/Pew2SQiIpI5ejQXi8WEv38gd965gtDQdEJD8bSyXL169TmJlCxLVFfvZ9WqxzEaawkKCsDhGM7y5fUYDC4f8k9+ch8nTiyjpuYIKpVIfPwErrvuz2d9Rn35pYNVq+pRq5eRkqJDo/EhMnIIjY1HaGwsJy5Oxm53Ulo6j6KiyWRnr8Fo/BpXYKWawMBk4uKGM2LE/R4r3E1/sCY7Pt+uRV5Dw10sXJhywXK7r0b6hSADDBlyEyUlG2hu1rFv3/tMnrzkUk/pssIVOCUgSVZkWTovP3xeXohHQERRorp6JnffbeInP+k6B9jLSwsIeHlpEUU1qambyct73CPCTz8NFkv3QTSuB4xARsZggoJCaG7ezujRE3n88cfJze0fzTy2bElix44/MGGCoddBQW5Ob0hSU7OJQ4ceZ+DAw/zyl/V8/fWXCAJoNC4/qCTBzJl17dHboqdIxooVz2EyVePtHci8ea92KwRVVXtJSHibgICT2Gwv8vzz13juxYMPwoMPdp6/zWZi9eonaGpy1cn28/PGz8+P5OSfkpMzkhMnjrJ69dMMGCBhMAhERMg0NIgEBQUhyzIvvvgiarWaqVOnkpWV1anKmdt3fe21zRw/vobWVgOBgdEsWvSZR4zdkdj79k3m/fffbveT38rPfvZnMjLmI8sSmzc/T0tLNX5+4bS1WbDZWvDzC+bOOz8nNDTdc+7nU1hCkqwcPbqC7757HovFiK+vP6NHL2bEiDu4+eYydDodoaE+nDjxMtXVJXh5qRgw4AamT/91p5oJXUVkd1iPEcjyK/zwh62MHHmQkycPAVaCgyOxWsfw2WdpHD7sKnaybt2PCQtbyJAhm4mNzWT06McZPHjuBW+DeaE4vcLavfdOwL9/TvWyod8IckTEYFJSppGf/xm1tfuUQiHniL9/NMeO3cT69XNoaSnjBz9IP/ubTqPjCwYOh5qUlK1ERPRkBQgIggAIhISkIYo6hg7dSHT0cB57LPSsoiVJbZ6f4eGBNDerCQ93tUTsD808cnPh1Vd/69lynj4dXnml9+8/9Ry0Wnj++Rs9faj9/X9NWJiKxkYHe/fOx2abwcCB+/j9718gMNDVo1qn07F9u5qKih3Y7VYGDpxGfPz4bsfbvftfmM31BAamcP/9NzBu3JkLiFOv4+HDKzh5cjdOZwvgjVodxOzZzzBmzCPIssSXX37DwIGuIjEqlTfl5Q7Gj3cQEGDg2DEvamr0/OY3vyE4OJgnn3ySGTMWs3RpR57wkCFH8PbWUFd3CFH0ZsqUX3TKe3ZHYpeX39e+I6BCFCXq6hbi7e3Pu+8W8/77k4mLMzN27B7M5hpUKi3XXvtiJzF2V62KjTURGenVqyYrNpuJ3bv/xb59b2O3WwkOjmbu3KXExo5qj3TOIjU1mhUrHqa+vhgfH1+GD7+PsWMf6iSQ3S0EOuc9Sxw7Np4hQ9bj6xtMZOQEhg69k5SUqRQVNVFQ0BFFX1U1nzvuiGTmzD/0e0uzP3xHrzT6jSCLopq0tNmUlm6iri5fKRRyjtTXP8F//hOCKEps2KAmNLTjod7bLbyOLxio1X/G338VML9X4+v1P+WDD1zjHz6s5rHHzv4et4XtcEgYja4+yaf2KD5bVGxf1751RVi7/bm98xufjvsclizhlN0Hmf37k5g92wdBeIG8vMXtKUpq7rgDyso6HvJjxjQyapSIt3cYo0f/uNudD5OphurqvdhsbaSnDyU4OLnH62cy1bBnz6uYzXpc+efeJCdPZMSI+xFFNceOraG8/AtCQ1VUVzvZssVJTg6EhIDDYUCvl/H1BY0miMZGmaVLl5KbO5Nf/CKV5csrSElZyfjxh6mvr8bhEBg4cCYZGR2fJaOxkqKiL7HZbIwbV8fmzaLn+ixYkEBuLtx/fzqimIws34koPsjgwWvJyso5o+9xcfEBhg+vJirKjt0OAweGs2dP901WbDYTW7a8wuHDHyDLMmFhySxc+K6nwxTAJ58YeeedXcTERDFsWCHZ2fcybtwjnbaNe+pcN2NGVvvixOXCGTgwj/DwgYwf/6Rn+/mTT4wUF9cjyzGemII77hjB9dffedn4Xvtbw53LnX4jyOAqFBIVNYySko2Ula33BDAonB3XdnNHU4RXXz1IefnN51wb1v0F+/LLYxw6pKapqaxXqVSnbnf33ufrsrDr6oqQpCa8vSPIzr6vV+d7vrVvz0XE3cUkzsVv3POxBE8UdHz8OgIDk6mvf9BjUYqig08/bWLr1o4GA35+NlpbISAgnpSUmd0ef/v2pbS0nESjiSA7+96znnt19YcYDOWAHfAhICCOefOW4u3tT2NjMd9++3PM5lbCwgYzadKvSEv7fzQ2HsVsdlBdLRMbCxER0NjYipdXFGVlej7+2MqLL/oiimnodE8xaFAFyclHCAtL59prX/BYlrm58O67JwgKymT0aJlHHrmVyZNPtbS0py1gJIqLxzF1aokn0Mt9PkVFuzh+/C9ERtpxOKChAdav1+Pr23XvbUmysmvXv8nP/y+S5CAqahALF77d6fOdmwu33RaIKF6DLF/P7373HmPG3HyGSJ44cZiUlBqio71oabGiUoVy4kQTZWXFDB5cyaOPrqegIJNBg/awYIE/06f/x+Nu6BhjCAAjRuzm5z8fwKJFI1C4eulXgqxWaxgz5kfo9YU0NZ1QrORzoKMSkeuBf+TI6/j6OomJiel1W7pTycy8jeLizTQ369ixYxlz5jzfi/HPzecrimoKC+dRVjaTpKR1zJql71F03LgtE1GUyMx05Z/25vx6I+KnilZH04Pe+427w7378NlnJxCE50hJWc2gQQ+RlubH3/+OZ8s2ObmMjRtbGDfOjtE4lWPHFtPaupHAwFrWrt3Q7UJi7dpAtm37LaNHV3V5DU89d39/b+6+WwMYcD0CvBg8+FqCg5OxWg2sWPEQRmM1Gk0g11+/lP3738XhqCUwMJy0tNGEhpbT0JAPgMnk9FSmKi1N9iwKRdFBYeFQUlO1ZGff5xG83Fzaex9PRpankZj4VpfWvPvz5KpEpmbw4ENce+2LHkF77bVXeffd/8eYMXV4e7tqjDc3w6FDrqIZXZXQdJW5XMGBA28jSc4uxRg6B+OJokxj4+14e3eIsdmsZ//+99DpPiMjw4JabcHf305dnZOAAB9MprWsWrWB1FQr2dmbmT79j2cEZZ0+xsSJ2Sxa1HP1MIUrn34lyODyJcfFjeLjj1v58stIHnjAyK23Bp79jVc5p/pz/P338O9/f0VMTAhJSZWUl4dTWtp0TrVhU1KmExGRRkXF1lOaPHRm794xbNkyhdZWK3/+87n7k44encdHH93Vnqv8KDExz6JWa85qxbrLbmZmCgweXAeEUlBg7/H83CLu7W1l9Ggnhw5ZzxDx7gT71HPpam69tbpzcsBoXExp6UYgjLa2UQwYkM+KFVke0U9OVrNzpxmLZRarV7tKZu7fv4Tdu+8GHuxyIdG5mpiaOXM4Y86nLmBkuZrGxlZCQwG8CApKZNKknwOwZ8/71NcfxeGAESPuor5eR0nJt9hsMmlpk1CrffDxaSAszJfjxyV27JBRqUSWLFkCtPLBB+HtIqpCFI1ERw9h2LBFnrl88okeUQxt/7uDmpqeXSJuXU1MnODp93zo0AH+978/MXlyA15ermA4SYKAABg9WkNoaDQ6nfWMz0NV1V62bPkTbW1mwsOTuxRjOHM3Y/Zsl5C6I7LXrfsl9fUnEASIjEzg4ME6CgrmodfP4dpri6iq+hKn00FISCI33fSfLuuFnz7G6aU8lVaEVyf9TpBFUU119SO8+WYyouhgzRrVJathfLnhtjLy8zV88IGWqKjjxMZKWK1N1NQknFNtWLVag1briqaV5TNrU+fmwosv/hxRdBX+cLcfPJf75Crw39HdqKhoZK+s2MTEREJCBAYPrkarhejoekpKOs6vq4eZW8RHjzaRlGQC/Nmyxel5aPemF21XcwN6vXVutRpobdUjy1YKC6t5/fVfed7zwAOuKkV1dXomThTJzZ3RqTOSxTKd4cP3Ull5Zpu9rno4n3ofdDodoqhn9myJ+noNRuNsVq26H5UKRo78D7fd5k9gYDwmUw35+e/R1tZKZGQWGRkL+OyzezCbzYSHpxAQEM/Ro58iSQ7S0+cwd+6T3HmnmcTERDZs2MDSpTPw81tMa+uTCIKDTZt+ynXXpXrcTsuWLWPt2sPI8r8Bl2917twwzzxPvW8bN2Z5XAWi6KCu7iZEUY0sS+zb9wHjxrnEGFyi7f53S0sYer18RsWu//2viTffLCcubgwTJuSzcOF73bphugpWctetLij4ErO5Ea3Wj7i4cYwf/xiffhrCF1+kIooOPvpIhZ9fK7NnG5g379VzGsON0orw6qXfCTLAvn2JngjFS5mD2p/paQV9amlLlQq8vBwXvJrP6Tm253OPrrnGvV3r8qGWlPjw0kt78fXt3op1n9/ttyfQ2lqN3Q5lZR21g7t7mLlFPCrK1J5qZEGrjfA8tHU6HTabiYkT7URFmYAwDhyQzhBsrbaVKVNs7NnjSvsB0GjEXm2dv/badnJzHyAsLBq7faPHnfDb3/6WZ599Fi8vO/PnG4mLE8nI2M++fWoEwYHTqWbUqG+JjDyJShXF0aOdK6d11cP5VLRaKzfc4Gpm0do6j2+//cTzt6KiBUyYsBmAHTuWYTSWo1b7MmbMg6xf/ztMJj1+fqEMG/ZD8vJewGo1Exs7lAUL/uERm1Mt8NDQIFpbpfaCMA4qK6/1vGbZsldISLAQHy9z4sR4fHx2kZ7+BHDmfZs16zVkeb5nK99tQR45kkt5+TJ8fFzb1OCyjq1WyM8PoKrKjo9P51rSubmwaFEIongTsnwb48fv7RTA1RWnLi6NxkpWrHiYmpqjqNUCYWGJTJ78NGlpM1CrNZSWdo6obmi4kwULhp41/qWrBWx+fj6vv/4igwa1YjZHUlHRO3eMwpVBvxTkmTNFXnuNc/JHXgn0dpuqNyvo00tbPvroufcTFgSRY8duYOfOH6DRdO3jc6VInd89clsJ//iHla+/9qOwcAZO5xzGjbuFxMTPOd2K7YyrIllTE1RUBOJ0Os/qW7799niPiOt0AZ0e2omJiQwcaCEpyYTTCQEBRrTa6E6C7XQ2MWtWCz4+DkaP9mflSq92a0hFU5MXEEFBQWuX883NhV/9yl2h68dMnnwH8fEbqa+309zcjJ8fzJvn2nZtbpaZNy+I22+Hjz46iV6/mKFDVyBJUFXljVYb2Mn666lxgl5fyL59SwgJgcZG2LZtCq5a12L7PXaJo81moqpqL21tZuLjJ2C3O6mry0eSJIYNm8fBg29gsRgJDo7l1ls/6GT5lZYeIzKylqwsJwUF66mouB+3BewW0uLiAwwdWk1UlIzV+jGRkRs4cMCKTufqGfnaa68SEGAhO1ukoKCN9eufYNmyYZSWJjF9uqvoyZEjq/jss0WAHa0WTCaXEOv1Powe/Wt+9rObu/z+dF48yhQWDu/1Z9RgKOOTT+6gqakGHx9vEhLGc801f+50/p0XRGruums0Gk3v/cGSZKWiIo+tW9+npOQQw4efJDDQG5OpCZst6rLrc6xw/vRLQb4a89t6u03Vmz7CbiIiItHrVYSEBJ5zsZD8/Hy+/TaLDz/8DaLoYPXqzu0PT02R+j73KCcHNm70Y80aR3uJTAmTaSKi+BleXq1oteFnbLXn5+dz/HgJsbGgUomIoqb9mqjbfcswZEgtp/uWY2O9qKoCiOOVVz5l5MiOnN6MjHSmTQugtdVEWxsUFASxaNEidDpXOlZiYiIjRjSj0ThxOuHkSZGgIC/mzLERGAgqlYWCAv9umxucmkLl2oIew7Bhy9HpoK0N7rsPBMH12sZG8PObyHXXmWhr+zVHjqzGYICaGpHq6q5rF3dlbRmNlSxffgsmUx2gYdMmb5zOPKDjc+V0isya5c3rr+fx+ee3kpAQzrhxCRQXf05bm5HQ0HTsdgstLVWoVL5cd91fOvlErVYDRuPnjB9vRpYhM3MFZWUPYjZP5LnnZpOTk4TBUIZO9wqJiTacTrBYVBQXS55rVVx8gCFDqkhIcCBJIpmZEezYYSEtrYDHH09Ckqzs2fMeX3/9BK6ocBcBARGkpc1h9OhHGD16MkCXotV58Sgyc+aZ3cdOR5Ylqqr2sGLFjzCbTfj5dRQNOb1Qx5kLot6JsdVqID//E8rKvqOgYDMNDRWoVO5FmURtbUivWjkqXDn0S0GGqyu/zS2yguBg4MDgLv2Ebjr6CDtITm4Ggti929HlCtrfPwZB8EWvP0ZV1V7i48d1OfbpVoV7cWAwPIUguCydrralL9Q9Sk0tx+lM8vhM09I2YbNBfb1Pl+Kj0+lwOFwCFhQkk5DgxfHjri3ZgAAv0tMr0GggLq6GkpIUEhMTMZlqPHW+U1KyOokxwLFj3+Dj4yqC4eeXwfjxE1m+fDnvvPMOWq2WH/1oEcOH+9HaaqKlBXS6IH7wg0HAJlpbJaqrVVgsZ7bdc1/f1NRMZDnJsz2fkLCJ1laor4cf/ABP+0qLBYqKNKSlDWX//k84ceJrQCQ1dRTTp/+M3/52aK8sJUmy8u23v8Jg0AFODhxwMniwjYCAfRw//hAtLbcxbtw4lixxBUwuWTIVUZyILP8QH59DnDgxgLi4YBYtCqS0dCM2m4309EmkpV3jGcNqNbBmzS/R6b4lJMSb6mo7Gzao0Go38vTT2Tz+uEuMly+/mebmUkJDtRQWymzfrkKl8mLJkiXEx/uzYcMrpKba2uftQ0EBHhGSJCt7977DN9/8EnAVkmlpcV2nY8ds3HDDCI8Yd8e5Lh5lWeLEibWsXv0kFouJgIAIFiz4l6doSHdj9Pa74I7SLi39Fr2+jNbWWhobm7DZwGzWUlnZRl6ejK9vA4GBgVdtK8KrkX4ryFcTbpEdPFhLcnI1KlUoR49auhRZdx9hL69qvLxsREY2EBQU0+UKetKkn1FcvInWVh179rx5hiB3ZZXPnDnTsziIjT1MU5PLanU41H3mOkhLK2Do0Cfw8ppGbOxGBg1aSWMjzJv3DI8/fuZWe2JiIiqVq2WjWg3JyceprExh6tSp1Nd/TWtrBQBWq8bzMPvmm19gMtUA/gwaNO+MY+7b9wZtbY3o9fDllzpqaooJD/dmypQADh2ysnfvC2RmeuPnpyE7+/+4996x7Nr1KM3NDoKDY7nnnud59tlRne7XqddXpVJx7bWPYzIFkZCwhmHD9uJwPEJk5BseMXY4XFvwkyc/Qny8P++++yxtbUYCAhK5555PO1mm+fn5bN7s8v26S1eeyrFj33DixHocDgkfn0QSEo6jUoGPTy1m816qq7/i5z9/i+uvv/60nF8n77wzDEEYgtP5IDExfyIsrA4/P1clK3fqjluMjx79EofDTnz8WObMeYacHMnzWfz887cpK/sLFksjvr6BZGXdzbx5c7nnHiOJiYlER6t5//3rMRobCA0NpLDQyo4dPohix0Ls6NGv+NvfdlBc/AeSkzeSkLASqxVOnoymtNSbZcteZ/bs684qWL0VzC+/dLBiRQVq9SoGDLASEBDBHXd81qky2Pni7oW8b9+/qKk5ht3ejFrthSQJSBKoVAJ2uz8WSxp+fjU89thj3HzzzYoYX0VcFYLc31MI3CLr719JSIgdvd6MVhvfpci6A7Y+/PCPREZa8feXueOOgV2eV2BgPNHRgygsPIbd3tLpb935W93bvoMH+5Ce/j6iaOfEiTH87GejyMkZ3Wfnn529gujoFTgcrt9ZrTBrVtcpMVlZWQwYkIzVWgaAKAqeB/iuXUYqKgTAn8cf/x+TJ88FoKbmAHa7mZCQLIYPv+eMY9bWNtHa6sRohDFjVHzzjcTgwRJJSWbAm+BgABsxMRNZtOhXfP31E7S0VAFezJjxFBMmdC5o4i7nGBVlwWqVOXKkBm/vXzFxIvj5wQ03fMTmza/gcMDhw/MpK5tBQsJGMjKO8fzzr/Dllw/Q0lILeDNjxm86ifGyZct49tlnMRgMAAQFBfG73/3O4+KQJCs7d76M2dyEt3cIbW01qFSuaOSKijCampo6bYOeHg/g7tIlCDKffHIzkyYd4Pbb/T2iJMsS27b9ncLCz7DbJeLihnLrrR95AqWWLVvG66+/yMSJJwkMhJCQACZP/j2jRt3vEXS9vpAPPphHS4sBf/9Axo//A/PnZ1NT0+j5nhoMZSxd+g0ffPAfT//onJwc4uJWYjRa0GoDaGhoOSf/ak/Pgo7604nI8t/58Y99eOGFxV2mLZ0rRmNle7eorVithvbUMJAkCbVag92uwmDw9mxTBwQEKGJ8FXLFC/LlkELgFtktW5a0WzE9R0UvXryYqVMnsmbNj2lrKyAzM6bbY6vVWgRBQK3u7NfqyOVVk55ehcvf6mrB52o3V0ZwsJOMjLcxmTZw2225F+x8TycrK4u0tHhaWyvbLQUYMCClx4fRiRPTOH58McnJG7nxxgxuv91lScuyE3ASF5ftEWMAUVQBTkJCos+IfjWZamhrqwQgKgoCAlqYOBEyM13b4hERNnx8AASSkychimqqqg4hy1b8/AYxYsT9Z8xPp9MRE1PFiBEShw/D1KmQmuqKDC4vV1NSko9ev5vCwvl89pkr33jv3iW88cYeDIYyyso2IcttxMSMJzPzNs9x8/PzeeWV54mPb2DIELDb4eDBRl588UWPi+PYsW/Q64sAGzZbEyAQHOzHV19pOHnS1KmHbn5+Pmq1jmXLMiktTWqvuS0iik5kWaSycgDLl3/CtGl7PXOorNzJoUNvYrO1ERExoJMYHzp0gPff/wOzZzei1bq6R+3dK7NgwRiPGBsMZXz00U20tDTj5xfIwoXvkpg4qdN2sMlUw+ef38OWLb/B3ddZECROnpxOYuJKYmObKS83YrOF9Nq/erZnwendi0TxdwQHB/Xq2F2Rmwvr1llJStqIRvNrGhqO4OrkJCMIfkREpBMZOZjAwAQEoZZ33tmAyWREq9Uq29RXKVe0IJ9LANSlZvHixQQG7qC8fCWTJw/g/vtv7fH12dmjKSpKpbCwoMs8YTdOpys3xGiswmYzeQJS3FZ5YGAZgYFOAgMtaLXJTJ06FUmS2LHjCcD1gLoYD4e4uBROnqzEz08AnF3mFINL6E6cyOT999/1WE0332zyHEcUXc0uXD872LdvLHl51zF+fCP3nGYgb9++FFnu2EHw9oaEBNdPu90VzRsZCX5+A5k48ac0NhbT0uLyzcbGDkKjCT7D8vLxMTJ2rITTCVlZoGkv0mSzwfr1kJTk6lJRVjbjlNKZMoWF2Wza9DAmUx2CEMy0ab/sFERUUnKEESNqSUtzbXE3N7uCwsrKzB5L8a23DrBjx9MkJ39LRsZKVKpAbr75HW6+eWCnOXYnUOPGwe9/L3DwoNPTvtEdmWw26/nmm5/T2tqIv380t9/+sUeMrVYDeXkvMWmSS4wdDmhp8WX/fi1VVXVkZ7ve/+WXD9LSoker9eOWW94nMXFyp3tdXJzBhg06jMabOHr0Ws+5O51qoqM30dzsCnyrq3Pi49P5PndHfn4+f/vbSyQntxAc7N1lA4rTuxdde+33E2NXRTIvZHkuixa9QUbGQcCPuLgRxMWNJj19rqeC1zXXQE5O/97JU+h7rmhB7giAcpKY2HMAVH/g2mt/wWefFWG11vWqXKUoqhEEAVm2dxtFHRGRiSiupbGxiIKCrxgxwlU1yW2Vu4XXx6dDeLOysnA6P8Zg2M748RO79OP2hnNxFbiFFLRAG2q1tpNg2Gw2BEHAy8sLs/lPCMK9Hqtp+3Z/brnFtZXqXpwIQseD2tXK8Q+eSlYzZnT2J65Z48eOHX8kOXk9iYkrMRohMNDln46IGI7ReA1r1sQyblwT/v7RfPzx7ZjNDfj4xHPNNf/vDGH78Y/vRBDeJSDA1WPYPRWVCnQ6CAyUaG2V8POD5OSt5OUt8eQQz5wpsn59DLt2/Yns7EpPEFV+fj4nThzm6NFlDBiAx4duMkFhIYSG+pKYmNjeoep37ee6mEWLbubOO2MZMOB61GpNp+pi//znC4webUSvj6C83OERqJwc12sWLDgzMjkv7w0aGo7hcMiMGfOgZxvbZKph1aonqK7Oxdvbdb4Wi8D27UF4eWlITExEliW2bHmF2tp8QGTcuEc83avc17CpaQoGw3sIQiJO5/T2PGwVIDNw4Cqiolbi7e1aLE2fHs6ePeqzfp/NZj15ea8yenSFpzoZuCK5T32vO/jr008bSE4uIzVVA5zfc2L9eglRFJFlFYIgUVY2gzFjjpORcS1Tp/6qy4Ih/aHHscKl5YoWZLcV6HDoASuhoTJBQRH9NoUgKmooYWFJlJQUYTRWdPmaU0UuJCQNlSqIhoYT3UZRjxr1APn5X7B9ezIbNoTw0EMdYrR48eJuhTcsLACDQUVYWMB5ncv5ugpcta0nkZVVxfr1Lh93eroXe/fWEBYG2dmh7Nu3GaPxAU9UtjvYTKfbRlNTOSAQEBDnOebpdYM//bSRnJyOIv+vvvpMu4A9waJFC8nIKABKAS3Bwe/z9ttDPWI+cyZs3ZrK7t3PMWZMLTU1EkuXLkWjMTNxop19+5zk5b3A8OGuSC0/P28OH76W8vIZxMVtJDR0JVFR89mwYQbJyRsZP76YO+7oSJlxXbs/ecabO9fV/WnZslfIyChnyBA8/uCaGtf8/fxC+eUvf9luHXdOr6qtXUBUVOIZdbCPHNnArFku33JwcD0ORyJFRQaPQHUVmfzJJ0b++c90IiNnM3VqOaNGuerMG42VfPrpvaxfH0tJyQskJ28gImIlu3drsdk6AusqK3dy7Njn2GwOEhPHMGaMq3uVu2hIWJgZmExzs7tCmUuM3fd55MiPCApybfvb7X4UFXmj1fp0+32WJCulpZvYvPkFqqoKiIx07Xg0N/t1iuQ+lbKyZWzdupR16yx88MG5u7hyc2Ht2lbq6jYjy3M9c58yxcGiRR8QHT38vHqVK1wdXNGfDLcV+PrrLxIS0kJIiI0778zot6tQUVQTEBCD06nCaKzEbNZ3akZ/usg9+ui9BAcnYjQWdxlFDeDrG45OdxsffLAEUXTw1Ved84nDw4MwGNSEh5//9tzpdFXV6myuAkEQKCzMYfnyjz1iFBxcw6hRa8nIqMPLC4YMAau1kXHj1lFXl4PDMZ2xY5vIyfkjALt2vcGBA5MpL59BQsIMz7HdW5HuYhXffPNrli0bekrfWpdYuwTsVqZNq6W29jjh4YMpKMjs1ILxrbdEcnNfOGWOe5BlAzNntqDVSowcKRISIuMqvqGmsHAun332JYIgsWfPEgYM+B/Hj9+OIDjYu3cJkZEv89RTHffDFfHcUQbz008b2bp1KXFxjQwZ4rKKwZX2s2GDFn9/X/7973+zcOHCU85V9AhBfLzMokUPeD4zTzzxOPPnD6Oo6Heo1S5hLy8PpbLSfIZAnRqZ3NGd6FZk+Q7Gj9+Er284JlMNn312L+vXR/Hhhx+0X5cn+eEPf87//d94UlIGkZWVxaefmvj3v08SFTWaMWMOs2DBGx5fflHRLsaMqSQ01EFR0RpKSx/yzH/atFeQJA0JCVsYNuxbbLYo8vKMHDnig0rVdVocuCz2jRuf5fjxb7FaWwgMDMTpjGbDhipOnFDj7d35vVargdWrX2Hjxj+TmSmg16dRU9N9+mFXdGxTa5DlucyY8RoqVRQ33TSAhx567LJpqahw6biiBRlcVuDMmTPZuPFXNDdvZ8CAwE6+1P5GcvJ0jh37hqamUnbteovp038JdB0V/frr/+Gpp5Kx2czYbM3dHrOsbJanL6tK5eSdd8pITW1t93UGAgJ2u+WCXRe3q2DKFANRUTZGj/Zm7Vqxx61FlcqHsrLpnnm6gmomkpn5H3x8YOhQ2gOroKAAYmJcEcHg8ByjvPxuPvzwBkRRYts2NeHhLkHZvv1XiOIxYAqRkZtxODaxdOn6U/rWCp5xs7OLUatdXwsfH59TqsbJ7V2EOpcMLS1NZOTIZnx9Xb56Pz8ZbXv8nCh6U1Y2zXNsQXBw/PjtgLPd8nNgMHQEbMGZXbuSk8vYt6+SCRPsndKjWlogLS2JoiIDPu4LA1gsTWRl7cNmMzF16g7Wr/+4UwzFf//7HEajHVk2ExTky6pVGior7Z0Cvbqic29oBydOTGzPdX6G6up9lJQ8f4ovXMJqfYD58wcDLqG69VZ/RDEHWb6JwYM/93SWOnToQ44ff5noaAeCAElJa8jOvhWYQEbGDgYPXo3TqcHXV0t09Gjmz3+Dm2829egKMRjK+PTTe6itLcLLS01kZBqjRj1GZuYN3HxzWaf3mkw17Nr1DyoqtlNWdpDkZBtOpwqttpG2thiqq6t77eI6PSgsICCT//4366ytSxUU3Fzxggzu6j33sWGDDr2+hKNHv2b48J6Dpi4VAwfOZe/edzh5cjstLaWe33dERWuIj68jNNSbHTvA4fAGfKivP4rBUNZlisbNN6eyfLnLwnM4RDZt+j05OVt48sknycxMRxD8qK8/xuHDKxg16i6AdutFpLm5AqOx8qy1f0+lw1XgKvbgcNjOWm1o795RNDamti8aXHWBr7nmiKdmcVubKzCqpQUMhuspKvq3x0qdNQtSU/PZsmWgRxTchUxSU/N59913CQ6u5dZbv6StDfbsgZoaL3Q6HTk5WfzqV0v57jsVSUk7iIu7nw8+SCAmJoT0dMcZVZgAVq7sSBGaPPkkNTVqTCYbJhMYDBDUvtkgy22kpu4jL0/tsfhcCwhXxLfTqWLRooRO1+HUKnUpKeW0tX3O9dd3iDG4rFq9PvgMq7ajZvM0ZFnN7NllREfXMHKkHbMZMjICSE1tQpbBxyecH/xgHTffrO6Vn79zeUgVs2apOHZsBcePf4Xdbmf06Ary8lSexcqNNyZ73ntq8wtRdFBVNdfjcy4u/haA4OBw9u5tQadzMHnyp0RErABEnE4NgYHBZGXdxZQpP0WjCSY4uOuKXACNjcV89NHNGAy1aDQ+JCdP49pr/+IRRbef1mYzcejQR+zc+Vfq60+gUjnx9fWjqEiF0ahGrw89Iz3sbJweFPaDH0zF39+7V+9VUICrRJDBJXSHD39IZeVOdLpvGTp0Yb/05Xh7+xMSkkBlpSt31mSqwd8/2iNyktSMVttCQICTAQMCGTHiCfbuPYnJVM3mzc+Tk/OvM455yy3+LFtWzm9+8y0BAZuZMmU1Bw6oWbp0KR9++G+CgnJpaSnmxIkvPYI8fvwTlJbuxGSqZtu2vzB37mvdzvn04C23q2DvXnekNj1aX7m5sGzZ8wiCBMDo0fXcdZcVlWoH9fUAEYSEhCBJRaSmJnPNNS/w4Ycd28ivvnqQ8vKbaWqagiy/hyg6cDhUTJ/u7nRk5s47wd/fZV0mJEB9vcrzoDUaq3E6Y2hsnMlTT81pF8/7GT9+A3BmUQm3b3XKFBtVVQ8CNiQJVq+eT2joDHS6Vux2PwYM2MiUKUV4ef2AY8eGodWKbNz4ZHuer8jTT3ddrCInx+XL/Mc/XmDGjBqqquZTUTGDpKSNpKauZP9+KCz0wttb1em6ni58xcUpTJzoSmUTBPD1bWoPuPLlttuWEx2dTXR09+J2+pxOXZjMnFnDf/7zWyyWFoKC4njiiR8xZ86p5W470uxOF/OpU+2sWPEwZWXbEAQIC0vj1ls/5O23LaxYcYCGhlVERHwGeOHnF8jEiU91ymHuDr2+kA8/XIDJZMTfP4CxY3/GqFF3n7Hr48oJ/gU6XR6S1Iq/fxBxcWNIT78RtbqEv/71n1gsjeecfnRmyV9FjBXOjf6nSH2Et7c/iYmTqa4+TE3NYWpqDhIbO+pST6tLRo36IaWlO2hurvBEW7tF7m9/e4m4uEaio2HatCFMnjyXurqP+OyzwWzYcB12u4Wbbz6zlm5aWgG+vr9hypQW4uJaAT82bYLGxjaio9MxGAo9KVIAsbGjiYhIprx8G42NJd3OtbvgrcWLF/OXv3yA2bybrKwxPUZqnyokIHH48Je8+uqfue8+V6nEiIhUBEGgrg4iI6MZMSKcDz7o2EY+cuR1QkMtXHfdarZsuY+WlqmeOsr5+YkMH27xbCMDbN0Kjz32AFlZWeTmwuuv/9ljwZ66LVtSMrnLSHG3QB8+/BVHj7quzcGD89HpcqmocEcFu3zEvr4PkZLyH1JSPuSGG17n5Mmum0CcSn5+Pm+88WemTath794/kpf3G8DBnj1LuP/+R3jppQepqqo7w6rtvN2tIjz8fQICoKEBysshI8MdOX4NBw40UVi4+pxSbE5dmPzhD9+wbt2PSUraxi9+cQ3BwcndVsM6VcwnTjQBj1FRsQdRVJGYOJYFC95kw4Zofv5zEMXByPI9LFq0gCFDtjJ27E96JcYGQxnvvHM9ZnMNGk04Cxe+S3z8uE6Lbnd96pUrH6WpqRofHzXR0UOYOPEXns5Nw4fDnDnzzjv96Goq+atw4blqBBlgxIj7KCpaRUNDMYcOfdRvBTkmZgQxMUM4fnwNNTX7Pb5dtz/8669/hNm8h8GDXRZeSckdfPjhXETRwdq1XfePdlvYTmcNoghOZytabSSJiYkUFLjycozGk1itBjSaYERRjUYTRGHhPLZuvR2N5kyhP1ued1iYFrNZICys52L7biEBCVCTknIQi8VBSUkVqakgiiKq9j1btVrd6QHv77+Hf//7K7KzG0lIsDFlynI2bVpLWloMkERWVhbjx/tgtbqsb70efvKTX/H8866Uss5WpasYhtuSM5tXk5PzRLeR4rt3L8VubwV8aGqaccq2tBNwRQcXF48jMfFNQkKyGTp0EaNGnf2BXV5eyuDBVdTVzW8XY9fxwIGPz5/Izg4lO/vM9+XkwBdfOHj//V1oNK8wcOCnBAWlIQj/Ys+eE5SUrCQ8fCX//OcajMav2gvAhJ9XJPHvf38fgiCxbdsj3HSTheFnaaCUk+Pq2LRx42vs2fMNdrtMauokFi58E1/f8E4+anBQWDgNh2Md/v4wdWrPYrx8uZ7XXvuWsLAsUlJK2b7dgla7l8WLJ3leY7OZOHDgP2zb9goWiwl//2AyMm5h8uQnOwVOQv9OP+rvVQcVvh9XlSD7+oaTlDQVvb6Eqqo95+wbvViIoprk5OmsXh3AunUTaWjYx5NPTgVor64UxbFj0NLiKvZRXj7jrP2jT887FoSObWSzeSZffaXl22+n0tCwlV/96gYASkvvYvnyWxBFB99+e6bQd+R520hLO/8875wceOaZPbz88l7S0vKYNu0jCgrCsblc0KhUKo/17v7ptkTy8zXk5tpJSLAhiuDv7+jk97NaDUCrpzDHwoUvMX/+zzxjd7YqBZ5+GiwWkZSUcpYuXUxgYCvjxskcOMAZEbe7d4/jwIGFJCdvJSNjIwcOLKHDR+zqXlVbG01hYQ733z+oVwFzkmSloWEl6emwceOMU/JwXaI8d25oj+/PylrPmDF30NbWhJ9fPOHhm1iyJB5BmIrT+RBjxizEzy+XlhYnVquVtrZz77d76iJGpZLZtk3LzTd3/dpTa24PGhTEoUNv0tZmJjJyMAsW/MMjhr6+IMui5zxVqjYOHQpmz55/MmfOvB7dHXfcEY4g/ACn84dMmnQ7LS3bPOdUUpLFunVWQkM/JSDgRSSpjaCgSObPf+MMC/picb6iejlUHVT4flxVggwwduyPKSnZQHNzKXl5r3HNNX+51FPqEp3ubt5778eIosR336lJTe0Qw7i4sRQXb8ZorKSg4CvmzFnE3/7GWXsTL168GI1mDdXVa8jOjueuu+a2j3UvH3zwKIIgsXWrmiFDXGOdPDnP0yC+K6F3W91BQTV4eUFQUCNabcp55XnfdpuGDz74M6NHl6LVQnLyScrKXDWeR46sQRBE9u69hVGj6jq9Lysri4UL1bS2uvzDu3cHd/L75eW9dcqrfZg79yed3t9dq8/VqwsICjrJ7NmugKjs7HA2beooJJGbC//4x1881cIWLcrhvvsepLHxKaKjw6itjSQ3F4qKruPYsRu48cams16D/Px8du16m3XraigrewWjMdaz/Q2qbn3ObsxmPatWPU5bWxOiGMy9937NCy/Ed8pLNpunMHjwl0ydClVVdqqrRQyGrhuZdId7EeMOEuzu83ZqzW2V6nrS02cwbFg248Yd4bbbPuwUfdzSYkMQ1DidIoLgoKkpgISEQI4da+52brIssXKlHlEM95xfc/NE0tJ2ceCAhY8/tvLHP7qi3WX5B9x77yamTTvBTTe9f0HqU58PvRFVd3/k0tL1SJIVgOrqWtau/YTUVBWyHE15ub3fVh1UOH+uOkH2948mNXUme/e+S2Xl7n5rJW/b5t8pveZUMRw16occPvwlTU1HKC1dzU03Lep1e7lbblnGW29dg82mZ/36Z7j11o+6Heuaa7T8/e/dC73b6t61y2V1O52dg7dc9aMFnE7HWfsxu491+PATiCJUVs5n48ZcTyQ14Pm3q8xgx3tDQmKAWiCeDz74GoDVq13+0RMnVnheFxQ0oEtfZFd+v8BAgenTXVW/NBo4cEDdyfLeuJF269UlBEVF07n55iqeftqV6rNkyalpQjI7d4Zw++3d35dly5bx1lt/JCVlAitW5J5iGbvE+Gc/M/KnPwV2fwDgpZe+Yc2ax0lKWsudd8YTGZnFtGkOli7tKK4xcOAm0tNdi5eQEFCpDLS1nVuxnLKyZURGHsZkGo2//x7KyoZyao9lcC0uXn31TyQkNGA2z8diyeXoUYkjR5aQmvpJp+5JjY3FiOIHOJ2/98wzNXULVVWmbqOcjcZKNm36Aw6HiCz/0/O+oKDdnl7LpaXJnvQxUZSorp7HbbdNOWsa0vlYsL15j9vF43Q6iYmJoampySOqiYnBbN++FLvdhN1upb7+OC0tVciyKyjPYrGSlmZFlr1pajLgcER0KuSicGVw1QkyuKzk0tKNNDeXs2HDb7nhhtf7XdL+6R14ThVDX99wwsLiqa/fT0NDEVargZyc4F4Fk4SGphMTM4gTJypoazOcNpaz01i96SO7ePFi/vznd7BaDzB0aHan4K2QkFS++SaEDRuuB47z4IODe5zb4sWL+dOf/oYkHae1daEnhclVjF/A6XRtkW7aJJ42F1X7eFFs2LChkwUybtw09u1zbVHPnr29x/FPfajW1v6XoCBX6ctjx0Ta2jpH3J7ewzk0dBNvvplPTs4PyMrKOi2yuHsr0j3uG2/8mTlz9GzffqYvWqWSkeWexTg3F373u7sQBIkdOx5jwQI9siyRkvIxd9+9kuLiMSQnbyIhYaUnjezIEaiqCjqnSGK3qPj7O8jI2Nreu3t9J0vNaKzku+9+xcyZdWi1YLfP4MgRybN4KSjIBlx+3aNHP2fDhmcJCanl3nuPU1Q0DfiakyfX09YWdsbcXNW3NrBu3f+h15cxcKDIww/7cOjQBFpaVlJW9i3e3v4sWbKEpCR38J9rsfnAAzPw9w/v4qw6OJ9t4e7eY7UaOHLkcxobjyNJdgoLD5GeXo5WG4bZDD4+vqjVZWzY8HO8vQ0YDKU4nW2o1Rr8/KJISBhJSEgq4LKQd+/+BKtVhSyfmfKmcGVwVQqyv380GRk55OX9jZqaQ5SXbyMtbdalnlYnziaGKSkzKSnZgtFYxb59HzJx4qO9PrbbUrXbzUiSlZwcTZfbtu55nE3oQ0L8qK52pRVJktWzuGlt/RPLl0chihKbN6uJiDj7sQIDg2hshMzMfLZvV7WLsqq9IEfX4uauW20ytfLee39h0CADkZFONm6cw/Ll73heV1S0gGuv7XoOpz5UAwPV3Hmnq9CKn18oDz74Gk6nHz4+PuTn57d3pypgyJD3aWiYS0rK14SErMdiCeyi9GTPEdXg8sUPGFCFRgNJSRvZu7fDFy2Kzi7P+XSLrHPhDpldu8LJzv6KlSsfJj29lfT05e3vFPHyiiUp6Smuv35Ar6zAU/3AdnszqanVJCXJSJKIShXL0aOuxhYDByZTUPAx69b9AYtFR3i4q7JYevpGCgqWAC5RnjXLG7NZz7p1z1BQ8CkOh42goEjuuiuBiRNzKCubiE730Blzs1oNbN36Ejt3/hNJsqDRhDJgwHR+/OOfEhycTH7+UHS6uzu9r/PnumsxNhor2b59KTrdcTZuXM3AgV4YDKnU1rZ2uy3s3lbevv1D1q17j6wsEaMxgaoqMytW/A4/vy2oVE00NVVjsxmANux2OxrNPMrLZxAfv5HExJVoNNDUtBV//yDCwlKJjh6Gj08gwcEDGTbslk6dyZqbR7d/RluVjlBXKFelIIMr4rqsbAMbNybw1Vd27r+/63ShS0lPYjhs2J0cOPARdXUHqKjYhCw/3OsAFdeq25vGxlKOH/+WwYNv+F7pGhERA6iu3k5raxXHjn1DZuYCAHbvjup227073NHU2dnb2h+mKo8YucUtNTWf1as7xKigYDoHD95JcvIx4uL+ydChrtf7+4/HVcLSVW9SELqeg9vq8/a2Mnq0E6OxitZWGT8/yMqai07XyNKlv+1kAbW0jOPIkd+0l9scRWtrAVrtzm5LT/bEvn0hVFW9grf3RtLSVjJ6dA7798/mgQcW4e8f2UnQXV2L/sZXX32Fw+HwzGfGjMWdLPLhw0v44ot7cDha20dxpZTFxo7m9ts/65WbxtXT+a8sX76c1tZW/Pwc3H67q3uVtzdIkkBdXQNabSjh4b6sWvVTDh16F3Bt9fv6uroymc0rCQrKoa3tOubN8yc52Y+PP15OdfV6HA4noaGJ3H77J4SHZwCQlRV9htCYzXq+/vop8vM/pqnJgtUKu3f7cu+9Izz+4K6io7u7BzabiaKirykr20R5+U6MxgpsthZSUyXsdoHKSgM2W2SnSl1Wq4H8/E+oqTmIyVRNQ4MOvb6U9HQbTifYbGUMHCijUjmorFyNVuuLr28kCQnT8fePYdu2NFaufARBkDh40NXbeeTIHQwYMJmwsFQmTFjS431xZ1koUdZXLletIPv6hlNX9yRvvTUHUXSwalXX6UJ9wYVIXdBogomOHszGjbF8++11tLae4IEHBvXqvZMm/ZzCwrW0tuo4dOhdBg++4bzm4GbGjN9RVLQBi6WWffve8AhyT9vu3eG2dgVBOONhmpPjsmSffLJje3DWrNd4882/nOJfrkIQXNuyJlMe0LFz4HR2PQedTockGZk500hoqJ2jR13NHwYM2MqsWXfx61//iAEDGkhJsbNjRwCvvfYq8fF/QhBGebZhKypm8uyzE8/5fv7nP+U888wEBGEMe/cu4cYbcyguXonTuYq5cxM8NarBde4vvvgizc0nmT7dJXj5+ZEsXbqU3NyZrFiRxaZNIt7ebbz33jaioqaSkZGLIGhwOq2EhAzotRgvW7aMv/zlz9hsVcycCaGhEBYGkit7jMZGKCsTqKz05yc/uY/CwhcpLV2Lu5SpIGhJSBjPjBk/JT9fx403QkVFBR9/vJyGhiqys20EBwvExU3kttuW9zgnV53pn1JQsILWVkt7/e0QjEYfXnvtr8yaNafX112WJaqr97Nx43OUle3B4WhErdYSFpaKKMZx4MBqLBY1BkOwp1JXcLCaNWueoqbmAI2NZVitDQiCwIkTt3D8+E/x9v6IIUNWotHYEQSXOyA8fDQpKcOJi5vC4MFz8fb255tv3PEYrjx3s/lBbrzxHs/fe0NPKVlKStTlz1UryAAlJVM8W6Jd+yYvPBcydcFk+iPLl0chCK5I7PBwl/V4ti9lYGA8cXFZfPFFBhs2LACauP32EOD8vtTBwclERCRTUVGB3W7x/L43PujTxzx0aAoHDtxGdnZ1l69bunQpgYEGrrvOwvbtbXz8cX2nfsJG4zWI4koaG0Gt3spDD31Fba1rwfHgg13PITExkYEDmwkNlSguns9XX7mCyVxbxx8RH1/hybOdMMFCXl4rsbGf4nTe6fH3PvvsNTz+eFKvrpcbo7GSt95a36mVpE43nbS0VezfD4cOHfIIcn5+Pm+++RzTp9cTEeEq8CHLoFab2bBB9JQBBViwwAdBuAOn8x4GDvyKkSP/RUbGJhYt+rxXYrxnz1ZWrnyKG2+04+Pj2nY+tXTnnj2wYMHz3HTTcKKjQzlx4q8cOdIhxl5ewUye/DvGj/8h3t7+TJ3qmv91172ERvMEQUEbEISV1NbCnDm/7XFOn31m4d13d+Lv30JGhrH9+JCSYgWCOHCg+wjx0z/LJlMNW7a8wNGjX9PSUkZjo52mJjCZZMaPv45f/OI5rFb397OBoCAV99wziP37f43BUI5aDX5+kURHT+fo0Wt4661H2uuU34Gvbw7R0StpalIzfPgdPPTQ62eIrGuB2lHv+ic/ucHTFez7oqREXRlc1YI8Z46mPV3o7IE3F4KeoizPZ0W7e3dUJ7+hu4Rkb76UNTU/YflyVzOHjRvVaLWu6Nnz/VKr1T4UFuawefOtBAV1bP+fbdv21AeJLN9AXV1Hjeq5c7vOe77uuib8/WHiRCvl5d8hyw947uGgQbvRaCAhIYHc3NxeXdfU1GimTPHCYpHQ6TqCqgRBYvXqOh5+2CVKsgw7dmgZM6aRhIQvWLRoAQEB/+SGG6LJyTk3MQbYuPFZYmNrcDo7WkmGhm5i61YZUVQzbNgwTx/kAwf+wXXX1SOKrhxyhwOqqiAvjzOivzuC4aCo6HqKim5gyZI/ERnZ/bXIz8+nvLwUUTzJrl3/x4gRnetng2vM//wH1Oo4Zs2aT1ZWFjt3vkNhYS5uMVapAlmw4N8MHnwjoqjGZjNRWLiCpUsPc/LkuwiCxIkTT5KTk0N+/nfccIPU7ZyWL9e35xjPwum8lkWLcggNXUl1tRqLJdgTTd1VYNPpAvXww7fh77+ShoYjgKvmuF4POt1AKiv/P3vnHRbVmf3xz50ZytA7iHRREcHeYsVeQY0lpFd3k2w0cbPpySZu2qZqTNtETS+kGCNj7Ap2VCwoIFKH3jsMwzDl98dl7jCARpNs+SWe59knK3PLe9t73nPO9/s9Os6e/Yp58+IJCVnFuHFL8PJKJDj4bTSaczQ3g4uLD0FB4wkJmc2gQXN57DGnLt+eHo3mTqZNm8KgQdMZMmRYr9fTk2L365yxRlNDWtrn5OWd46efviUsTI5O509JifYaJer/qf1uHfKVRHpXA7z5LczsUEJD3QkOLqGw0IuCgvpfTF3oygc1GkUJSVfX3lWzultu7vgu4g4mvv++lsOHrfv6Xs1HrVbfQkLCbchkevbvV1xR+n/Lli289NJLyOVy+vTpQ17eOMzAH5msZ8YiKCgILy+xtmvuCezufoh//KOQgoJgnJ03IZN9A8CwYXOu+J4eOvQ6oEOphOjoQk6dsjSDmDx5H4IgOuP9+6G52ZXW1tns3DmayMg8Pvzwyjv5dH0nL1wI4s03hxASUkF8fBy5uTHY2SWTkqJCr1ewcOFCiouLeeqpvzB2bDne3pYo1WCAvXvFrlfe3q489pgF3CO+E3IstXMZMpmBtrb7Ljmu9evX8+67r9GvXzlRUQbkcvFcOTkiDzwkJIm+fVV88gnY2Hjy1FNi7+UvvyzjpZf6otd/wYgRm4iIUNGv362SM66pyWLr1nspKzvHhQt/t1ronDo1C1vb9EuihGtqsvjww5Odkb6ZY7yCoUPD2blzCxqNFqXSxgrYZE5H79z5MklJW4mOllFevpT6+jGcOJHE0KGZ0vFlMvD0tKGtrZXWVrFWbOEt98FovI+bbjrAqFHH8fcfzYQJD+PvP1LCaVh/ewr+8pc4Fi36eQd7uQVq9zlLp2shN3c3paWptLc3YGOjRBDkyOX2GI3tVFZmUF9fSkNDEQMGaDAa7aiubqSjwwu1uuYaJer/of0uHfLVpG/+k9qzZiENX99i3N1bcHKqp77e5xdTF3qTkIyI0BMa+vOqWTNm2PL220hUp5AQNXv2tDF+fAceHnXMnKlg27YrF4yoqlrSo9PSz0XGL730ElptJXPnQnZ2E15e52lqUkhlhN54z0uXOtPaWoXBAOfP23DDDTdIqeKPPvqcPXtmUVg4i4CAaVd8HzMzdyBGeLa89tq9BAam8tFHBxkzJpnwcBVyOdTXQ2zsU3h4rGDVqmApil+48Mren94zAfeSkvIA8fFxPPxwKjY2N7NvXwAeHh6MHDmSNWtWMGtWbWdDCNEMBvjxR0c0GjfuvHMBDzzwgNXzMb8TYt9mS3rU2zuf9PSyHs/y6NHdJCf/lTlzDFJ6GkRnvHmzJXU/adIjvPxyKJMnT5aEUW65xR/wB0QE+4wZcXz5ZSKVlSHMnBnCTz+toq2tChsbB4YMyenkk4tOub39pNVCwmxGo56iosNs3nwbvr7XYTLdKr1X994bS1xcLAsW3GXluMQ2jgkUFOyjtDSd5uYCwsON5OXN5+TJrzslTFdjZxfH8OHncHIayNmz+3vUirvzlquqFjJnzi307z+jBy2y52L+10W7K1ao+O67KtzddzNsmIphw4bTv78X9fVltLSUYDLpEAQZMpkCQbDBZDJgb++Cp+dA3N2HcfjwtxgMcnQ6Vyorm//nKVHX6t292+/OIZvTwnJ5B8OG2ZOb+7+jaGMWv/jXv/6Jp2cLTk564uPDftW4ukpIfvGFEqWyADs7UCprLqua1T19FhYm7n/6tImZM8HOTs+YMU1X/FHPmuXYKSJi+lkAl/kZ2dgIzJ4Nvr5ga9vCkSMJ+Pi0Mnv2yyxd6tV5XdYfrouLA1qt6CBzchwpK/uGPn36sGrVKqqrHyIhYVEnF/fKaFbieCaRmXkHkZF5eHlFMHHix2i1D5OfH0tS0psEBiahVO7igQfi2bQpuEvN2kBysvxnz5Gens769W/i5tZOcLALp0+PxSytCQbU6lk4Ovbh6NFUdu7ciU7XQlJSI9On6ygsjKWw0NLpyd39Qdatm2U1kXW/R+Z3IjER1q49S2bme2zYsI0vvrDmyJ4+/RF79rxAeLiB/PxY0tLuBmDo0E2UllpS9zKZgZEjX+H++2XSNYnCKCZMJqHzL0ZycmZhZ3eKHTvW0NhoADpQKr2JilrKAw88htGo4uuvy4Fk7OwOYjL11JJXqw/w/fc30tbWyqhRx5gw4Ti5uSOZNs3yLM3AJqNRT0lJCrt3P0FlZQ4GQwO2tg7Y2PjT0lLQo/xQU3MP998/BicnP/R6S63YTCHqzlv+05/mM2jQpfnfcXEWzEZ6+uUdizm93NRUTkdHS2e0K97P7dv92bhxdWcW4G6io+NoalKhVnvi5hZIWNg0lErXHhGyTGbH2LH34+TkR13d8M7rafy3UKISE8VnPnWq9Tel0dRw7tyXtLX11o9djlLpgatrIP36xUg19Wv17kvb784hm9PCw4bJCQysQql05Phx3f9M+sZMXdi5815aW1OJjPxtVMIsWtWPYjC04+0N991302Wv2To7IO6/bt06amvB3x8iIsRevWbVq5871qW4zN3N/IwGDRLw9UVKkba2mnj66SGsXCnyRXv7cFtamgExUgwLC6CysllacJWUzLECeF0JSC8xET766B2riDcr62WKiy0RYmrqam6//bMugh8WfnRoaCFw+frxhQsHmDKlEEdHKClpw9a2L+aeyCDnwoUA7rzzHozGWmJjxX7KJSWxbN16N3l5C6UxzJwZx5tv3mP1HC43uYWFpVNTM4fZsxvo6JBLetzDhoVx8eIrlJUdJytrDqmpd5Obu1A6Zm7uQubP/0ZyxkajnKlTra9p+HBRGMViMqKikrC1bSE0tAUApdKX227bgZ/fMM6dO0tq6j3Mnt1MR4cTWVm2PRbKn31WyIYN+QQETGbEiBRuvXX7JeveGk0NR4++wZkzX9LW1kR+/iLKyuYRGnqWoKBPcHMDf3+R0212yitXxuHUibO6FIXI+h2+vBhLb/c+JGQVSUkwebKOIUMOcvHiNjo6NNTWZlFfX0FHRx1gQhBkCIIYVR8/bp3OLyqahk63jfHjB+HoOJ5+/RYzYsS4y47l30mJSkyEhQtFrM26dTKef/4rxo/PxmDQUleXR319Ie3ttT32EwRbbG0dcXLyJjd3O56eAykpUfPjj5sICwOj0eeaBGg3+905ZEvf4HpsbLR4euoICHD/n0rfREVFkZ8fydmz6VRVpdPQoP5NtHVXrVpFZKQ7R46sAnT071921ftPmzaNLVviMRozABlxcXFXvJK90vS/+RmFhxdY/f299/5lhSoWo+h2hg2TkZEhNkFYsqSWvLxYCgpEcQWl8jQXLoip+Zkzo64apNddUOOnn2ro27cEtfo+qwjRw+M26RrvuUfFt99WIZMdZO3aQ5hMl74vZWWpZGU9iaen+G8fHx1NTQGIzljo/G8QS5fW4uQkpozz82PZsiURsQ6MNFG3tKywmrTS09N56621ODlpiYpSWOEG/PwU7N59N9OmVWFrKwLBwJHjx+s4ePAeDIZKsrIWkpDwo3QeixkJCVnA+vWF7N9vZNo0mQRaM0fWpaUvEx9/HWfOrKC93UDfvh9RXq7EaHwOozGJ0aMPc8cdompWYuIKMjPPMGZMFY6OoNcbAF9OnrTWBr/99mAE4U5MphXMnVtIVVUzqak9F4NNTSVs2XIPRUXHEAQoLr6JTz99v1NudDmxsemEhqqIjMxj8OD9lJYOkTIuXe1qeMvma09P/46qqvNUVdWxZ893REebMJncycrS8eKL56mqMjsuW+68czP9+n2LIHSgUDjg5NSH0NAJ2NoqrSLksrJ2UlIsuIXa2tMUF7uTnl6AwZCLUvndFUWR/64uVZZmImIqf+9eDQ4On2IydeDo6IOnZwReXr1RJ+UYDBrKy09RXHyCwsIDtLQ0M3BgMzKZPY2N1yRAu9vvziGbI8V3330NL68GfHyMzJsX+T/3sCdPfpL8/KM0N5dy4MALLFy48Rcdp3u6ctq0G1GrP6C0NIWGhoKfP0A3i4qK4tgxN8rKoLCwEDs7P0aNMnHu3G+H3DQ/o3PnHpSASsHB7lac26KiIuTyambP1mI06gEffvqpht27Z3PunBi5nj27mjlz4lAq0zuvvydI7+dqVd0lLouKtnPu3IvY2LRaRYhm575lyxZ2776L6dOb8fc3cOSI2yXvS01NFp99NhejsQlHR6iuhn375CiVB9DpojE75UGDtuPubtmvsLCrfKY5Nazg4YdnSNvodC2oVC8waZIaR0doa7MhIsKPkyfbOH/+J7Zte5X29jrs7ECng8pKJenpEBPTiMEgpherq2+Qrs/aZLS372ftWrH1ZFqaEpPpIe655yYSE1dy8eJmoINhw46xaJEdanV/3nzTV0LInz27mpkzj5GXt4ejR9fT0lICmHB0hJYWGRUVrmRlGXugw7t2kPr44zqee64nY+DLL8v46KMD+Pp6Eh1ti7f3APLzn5CuQxD0lJbG0NCQRFlZKz/+6ENU1OXlMi9lZpDYqVMbMRoNNDSoqatT097eiE7XTni4DoUCtNpGwId9+0ZLDTfEuvUwJkxIx8trEDY2Svr3n09o6GRkMgXV1RdIT/+OtrYa5s4tobLycY4f74OLSxJeXtsRa+06WlpCqKpq+a9GkdbfiIIZMxwYNux2DAYtdnZejBp1R48WlmbT67WUlp6gpCQVQZBTUqJm9+5NnayFaxKg3e1355DBEukdOPA0dXVH6NsXWloqflZU/j9pbm4h+PtHcuFCLhUVZ9Foai75Ul/KLpWudHbuA5hobq74Rc0zXF0DKCsDFxcYNqyCgAAAJw4dMv2mK1lB6PqvDqtnFBQUxPjxLdjbi2jqiopmdDodarV1XbC8PIbVq2cCYmo9LCxI4uN2vz/Lly9n8uTJVs5ZFBsRI0Fvb0c2bLhDOv5jj7Wj09lJzn39+vW8/vpzTJrUQN++4qgnTGhj82b7Xu/Ltm1/ob29BoA+fcYwe/ZLzJvXTlBQEB98UMT339cSEvITMTHPSIjmoKAk+vZNIjV1tdRgIjZW6ORQi1Sympos3nhjKh0dFfj4iOdqbzeQlWWkT592srOfBdoBOxwdvdixo4OaGhne3hO4cGEibW37mTAhnxUr5rBvn1xC6Y8ZA35+MHFiGocOxXPddW10dDhx7pzA+vVv4uJylMLCLUAHDg5+3HqrmI4GSE+v4auvLJmGxMRyamqeBDqwt3fHx2cwRUUd7NihpqHBiFJpa1XntKCWDRgMcrTa5xg2rIi2Nm8JByIIC1m1KhiZ7AaMxptxdl5FSEgRcvlrGI1vS8/NxycZ8KK1VfuL3leNpoZTpz6itPQ4ZWWZaDRlCIIBGxslDg7e+PtPQqt1IDX1O2QyEyaTuMBwcjqJRvMnyXEFBPTnzJmdTJqkw9n5LS5c+IGsrB8wmUyUl5+nsbEYo1GDIMgYPlxOdHQHer0Rk8mB2tpGDIYOioub6OjwtFIM+09bTwDbTVe8r0JhT3DwZIKDJ0t/q6gIvSYBegn7XTpkEKMwT89n+eGHFTQ0qElJeYcZM174bw/LyiIiFlJQcITm5nKOH/+QqVOfvOJ9L5XSnTZtGoMGLSInZz8tLeUcOfIac+e+dVXjmjHjBS5c2I2tbT2+vqLjtLdvQam8uq5APzf2maIflZxRYeEHLF06WnKYYWFKtNo2WlogJ0eOIAhMmpTETz9Z6oJhYacxmcb0SK1PmzaNTZueZ+rUBpqbbTl0qIk33niDjRs34uLiIi1eujptjeZFSaRDJjOg09nx5pvWYx4ypJ5AsbSO0Qg7dnQgl8t73JfNm9vYuDGewEBHIiL2Ex9vUciqq8vF338EMTHjUauncuDA8xw79rSEaL711hWsXy9SubrX4ysqzrJu3XUYjdouiGjYt8+Ii8tEPD2vIytrHxERu4iJeY3rrruTJUvUnZSeUZ218oeYP7+EG25wR6m0TLQxMSUcPPgyp059z4ABms4opgVw4MyZkXzwwQRCQjSMHHmaO+7YK0ldAixbZgZEiRGih8cXgBE7O1/8/G5l6NCl3HnnKJYs6ZmxaGoqwcbmNe65B9LT+xMSspfAwEQAmpvr0GhcychoY98+owS4EgQ9584NwN//Q8LDnbj9dh2HD0fg4XEISCU3V37Vkdd33zXx3XcX8fT8loCAzzGZmrG1dcTLKxw/v+HY2jpYKW81NY3psuCz5emnhxAcLN5PpRJeemkacrmRd9915NZb8xk48EdkMjkymQI7Ozd8fSPw9Oxvlb4GgerqZk6e/JS2NjktLS4SCvy/GUX+lmyUaxKgl7bfrUMG8PWNJjBwFJmZiRQVHf6fi5IjIhZy5swXFBcfJT9/B2PH/umKo2QLeE1LSEgT4MKxY0aKioqYMWMhKSn/orz8BGVlpzt1e9VX/AF4eIQTGjqGHTtsyckRozY3NxWrV68GrgzkdSVjVyq702sUbNlyO+7uh3jooYews/MBCrG3d+Opp57l739f3SlRGEdRUQwBAckMHerPunXrcHevZcGCNo4cUbJu3ToUCgXDhtXg5QUeHnqqqkCjgfnzWzl9WmDdunUEBgaybt06HB2bmTZNy549+2lquqtX2lVRURGurgVERlqEOTZsgKYmcHfXsn//ful+JCbC0qVKqR66atXTkjNOT0/nlVc+5sSJTWRnL+ySmjZ0LgT02Nn9g5Ur+/S4b01NJXz44UwEQdspwShmDwwG0OtvoLQ0gbIyPSkpD7J27R6mTBFXPFFRUWzaZEEPy+Umdu+2x8PDklGoqDjLRx9dT2OjWOYwmUQke2OjE0ePzqG09BPy8vSkpKxk7txCvLysgWxxcfDooxq++aaUoKDviYjYDvjx2Wcd1Nd/ilL5rbQI6sobLio6TGLivdTXFxAYKCc01JGODidOnRIXPJWVOs6dq8ZoVKBQbMdg+It0zwYOTCU4eDweHuH8+c9P8Nlniaxbd5biYlMPjvLPWWIiLF/ugkw2HKNxNHfeWceUKSX4+kYyfvzDvWaZLuVY4uLE9ptd664lJdOYP78NBwdPbG0dUSgcJYR0b1ZbO6jT2df8LqPIf1e9+/+7/a4dskymYPToP1NcnPo/GSXb2joxaNBCSkvPUlubc1VRshkYpVRWoFCAUtkg0ZxsbZ3o128y5eVnqK3N4Z//XMEnnxy/KppBZeUDJCQskKK2m266iZaW4qsCef3c2G1s6KTaGKUUdHDwCAQhkXXr1nH77eL2Tk59eOihh8jOfh65vI7+/VUAqNVT8fbuQKksZfp0HXI5TJgA333XRkdHo9RtyGCA/Hz485/BYNAydqycn35ScO7cORSKKubMaUUQYObMr9m8WU5MzHPceWeoVURga1tPaGgsSUkiBcndXYWjIyxbJuPECaNVja+rWpZMpqe9/SFATHmLwJ8NWAO2xNS0OdUZG9vTGQM8/vjbnDnzJH37ik0o9HrIzTVTkKZ2yjiK51SrrWHR3XXFd+16gj17tqFUKrnrrjjk8k87uxLZ4OYWDESgUqXR3NyBRjMZc+9nudzE2bPB3Hab9dgSE+HVVx0QhFAKC5+gb9/TGAzfM2QI6HTuZGTIrO6RVttASsrbHDu2Hp2uETs7Z9rb3di7txJBaMTBQax9u7lBUFAsjY3T0Gp3ER+/i8LC2QwalMXEiZ4MGXKvhEDu7iDhyhePYg3bJOlMt7f/jRtvDPxZjelLOZbuddfly4eyZEn8Fbd5vRZF/jHtd+2QQYySg4LGkJmpQq1O+kU11X+nDRkST3r6d5SWniI3N5HRo++6oii+O83JwwPuvTde+nDHjl1JenoiKSn9OX9+DAaDnJiYXZw923ZFAJGiohmSUxEEPfn5oxGEv+Lo6MW0aVqOH9f/YqCJeex79+61otuIKeh9+Ps3sHmzPQqFA+npsRQXz8XPr4zBg4OoqakjK8s6qp437zAymQqDAY4cUaJUKvH0zKWhAbRaqK2FBQssSldnz9qhVCoZMmQIhYWtkuqXVivH3f0Qzz/fSvdL+uijg2zZYqFBDR8ex003qQA948e3sWWLnVTjs1CjxJrqvHleEiK6o+OpboAtIyaTnCefhLa23hXj9HotL7zwDe+//0rnvqtZvDgOrVbF7t1iKn/RIiXff6+Qntm0broo5jrg99/XkJz8MOPGfUdzswsXLlzHDz8EM3DgJCIidhIVdQN9+95BXV07Q4a0Y2dnR17eYFatkl+2Scj+/cbOFLf4vqjV1zFp0vcAdHQ0AUqOHRNR1VlZIXzyyUlcXc8zYEATDg6e6PWeVFZmMGQIVkIoOTmx5OaK9/2nnx5i/vw4nJ0f4KefnNm+3RGlcovVwtDsIK+W62rdE1zODTcMshrH1VrPuuvwqz7GvyuKvBSn+JfaNZGP385+9w5ZJlMwZcqTlJWdpampmIMHX2LevPVX3Krw32329m6MGnUPVVXZHDkSzo4dudxxh98VfSirVq1i2LAwkpLuADSEhORJvzk5+aHRPENCwnLJAYwYEcewYftITuZnASJmnW+zUwkJSUIuh7FjNbi7a5g5s4WtW385v3vVqlV8/bVtF+dkJDg4kYEDVTQ2ivrMDQ1PkJBwD4Kg58gRBX//+/1kZ6tITn5OithkMgN1dVMRBBUtLVBfLza1Ly9/t/P+wpQpj3Hx4iuA2ImnstKe+fNn4e4uIzhYdNpGI5w969FranD9+vUcOzaPrpG8TBaDXC4uAo4eVVrV+LpPxvPmafn88w3MmaNGrU5k+/Z7pOseM6aKJ5/s+bzNk1xAgD+Jifl88EE05rS2IOg5fTqGmhoVSqWSBx54gJdfvo3ERLFdZWhoIQpFhpVYhUZTg7Pzu0REfI2r60VsbCA7ey6FhV9SVKTnzJnVPPXUBoqLG3nkkRXdHNm8ztpo701CNJoaXF23YjTeLV1X//5pqNVihkKncyEjQ3ymonN3QiabitE4k/j4JURE7AAqcHW1HLO5WayNZ2dbg/guXowhMFBFZGQzra1uVFdbshNhYX6cOfMpFy4cJSlpKxERUFHhRVXVzzMEroZH35v15pT+kyqAV2oWTrGJdesEnnvuY6677kKn2IgOmcwWo1GHXG4n8aS7myDYERw8lsDAcbz33ofXRD5+Q/vf8Er/ZnNxCaB//1mcPLmRkpITVFSk4e/fUyXov2UREbF88kken376NDKZgS1buOJWkJMnLyA/P4rCwkNoNJVWv5WWxlpFucXFMQwdqsLJyetnASJdnYrR+Czu7ioaGiAtrYORI8VuQ1ej5NWbDRx4xop/OWjQR9Jvq1evJjv7FitVrNTUW9m+fQVmnWZBMGI0ygkLO4u9PdjbO0kNJdav/5DTp8XoOjo6H7/OpINGE4bJ1M7WrVtpbPyAiAjRabu6TiIh4b0eE3Z6ejqvvnqG0lLLJGMyKQgJScZggB07FLS2uvVw5ObJWKOpYfPm1RQVfYGLCwwerMJgWMaxY7Oxtz/Oxo0PEhVlnRHpGt3J5X+ltPQRLNrUolN2cUlFp/NEJrPn5ptvls6pVq9n7VrrCfL668fwzTc30tKiBkCpFNPBmZkzu3Ct9Zw6FY6PzwzGjDH2SDPHxUX1eB8TE+Grr4qwt19LaOhbxMdvpaRkLuPGNfHEE8/wxRcju0zWdqxevZr8/GBpkSdG0hOIiPgBEEsLbW1IDTSCg8HePgm12gLii45OJjRUXFhVVdXj4OCHm1shO3bci5OTgaamIrTaOsLCDOh0YDJVolbb0NTUOxK+q/1SB/prlKf+09GlJTUvdHKK23Fw+BxBsOnM1ojflRl81pvZ2DhRUZHCkSOf8OOPPxAaKtDSEvRfp2f9HuwP4ZABxoy5l4KCJBoaijl8+A0WLfrwinuQ/rvN1taJ5uZ7urSCFKORK50cnJz6AjLq6wupqcmS0K+zZil5911LlBsQkIyLC9x224Qr+mDME1RV1TLef389FRWTKC+fytmzSQwfriIiwvdXfXgjR6aQn/8CeXkLueWWcBwcTgBgb+/LypUrSUykM0oX70t1tXnFLiJSQ0NlrF0LmzfbsXPnmwwYcEEaT2PjoyQk3CpF15MmudLR4UJZWSp+fj8yYUIbeXmxbNs2lfDwg3zwwdu9ljLy8s7j6DjEKpJ3dc3HxgYGDlxMTMw9l61X7t//D7Kyvui8LiguhoKC7Xh6nuo1GjejuWUyPT4+cZw79wgiX1kGGPHxOcuECWsICNhFZmYQGRktkqNJTt7KiROPMG6cjpYWT7Ky5Hz66bPU17ch0qBkKJU+gCNJSQ3U1BzCZLoXQRBrz25ua/H1FWvb3dPM3cdpjrQEwR+TaS2LF+cxdGgya9f+Q6JCda+DRkSE869/HcFonIB5YWFjo+m8N96ADpOpEUEQywtOTuDpqcLGRgTx+fsno9OpOHNGHENIiA4vr1zs7UGjOYFWq8BkAlBQWytmPdrbQavtoKPDRHt7+5W+mj1Mr9dSWHiYnJztmEzQ0aFBEKC2toU9e74nIkJAp/NBrb7yUs4vdeS/xolbp+YVzJhhx9Cht15VhNze3khdXQ4lJYcYOLAZo1FJefl/n571e7A/jEN2cvJj6NBbOHjwFaqqznLhwg6GDl32bznXL/lg5s/3ZuNG+RVpQXe3adPWkJt7kJaWSnbteoSbbxZBT12jXF/fM2i1RwA5wcHVV3U9Pj5R1NevJCHhH8hkerKyVuPlFce4caVXdZzuVlp6O4cO/RVB0PPqqwruvHMJwcHv4eTk0W38IuJ5YzftlKAgEV3+2WcfStKXS5aI+1VWLu2SHTBw6NDTklMdOTKO0lL46SdLTfjGG3tfANXVJTJ4cCvZ2asRG1DIaWoKJSEhkUWL6pk3z53HH3+cTz75BL1eb0Wp+uabetatG0BISCwRESpuvnkXWq0/11/f+7uh1TZw5MjLzJhRgK0tJCVFSuc0O+UJE9bg56ciM9MPtbodpVKJnV0TGzaMpazsJP7+JgB0ukYqKmZjNI4iKyuJiIhtDBwYx5w5a3FzC0GrfYLa2ncZNy6OuroY+vdPJiJiFzU1ooBJ1zSzecGh1TaQlvY5OTk72LDhVgRhmZRKzs+P4eLFkyxZopCyEWCpg27ZouMf/ziPjc16Jk1K6nwe4nMJDc0jLOwLsrLmSt2lIiJUneeEfv1UhIWpOH8+lrS0N3F1TSImRoWDg06SXQUlRmMzovqZAk9PMeK2sYHGRsjJUWJnZ/ez7+Tbbxeyb5+RCROaGDlyC83Npeh0zVRUlFBXV4hMpsHGxoTJZAQEdDoDgjCL8vJpeHkdYsKE3TQ1tbB79yqKi4dhMGiRy+0xGLTY2ChJSYkiLa0fQUGnyM19kn79ZCgU7hQXt5CU9CQuLifw9+8DCNjaehEZOR8vr4FStPprdaB7pubvvOJ9zWYW+7C1VbF79wcIgvA/Q8/6/25/GIcMEBW1jOzsnygvP8fGjacwGucwe7bzb1rn+aUfzKJF8l9cw/LwCCc4eCTZ2YlUVp6jri4XD49woGsabjgbNgyirOwIGk0jRqP+qurozc0rrJDDanUMI0a8jVbbgL2928/u39sipanp7i7IYANFRRNoayumuHgO3t6F3HZbcI80okoF5vRtZubDvPnm/chkQ3voV5uzA2aQjpiOE51HSUkMRqPA5Vo9mq2oKIGBA2Hx4jgSE5/FYBiGySRqWR8/7s7Zs0/w/vuvMG2a6ABOn26xErEwd3RavXoN4eGzAHpdpNXUZPHNNzdSU3NWcibOzs2Izlh0ylOmvM7QoY189VUATU16lEoFt98+g8OH70CMgEWrqoLMzBs4efILCSX/979/xPLlt6HR1PDZZ3dz7Fg1Hh5rcHJKYtiwh2lvh4CA63FwGMxPP31hlWYeMCCEkyf/xeHDb9LUVAS04++vwGS6UVrk6HQ51Nf3jk1ITITrr7ftfE7fMGjQjs6sjdgmMjHxKaKj+0mLppSU1cTHxxERsRtwJi2thoqKWNLSEjvFYFYzeHAcYWGi09brAVpQKn1wcwvGZPLh7Nkd6PUm2tocqK1V4uJii1qtJj09/ZKL5BUrVGzcGAvo2bpVQXz8M0RE/AQYaW0V0+ktLQpCQsYwfHg0ggB79w5Apfpr5314iNjYOCIiVLS0HCct7SwWeVSBCxfm8tlnb3RuO5nFi5OIjFSh02kIDxeBhYWFiVRVOSAIAkqlF0VF+/H07I+9vTvl5cWdfY9lGI2+v1gH+tfWtruKfZSVBf6u6Vn/aftDOWR7ezemTn2W5577lA8//CcymYH33rvyeu3PmTndaGur/UVyk7/mQ5kw4W/k5x/l1Kkx7NuXzZ//HN7jWGYFrqYmNWr1AcLCpl/x8WNj/fnoI7mU6goJSUarreLYsQ+ZOvXRy+57qUXKnDmuvP++JSU9YMBY3n//JinN7OZmfT/CwtLx8XmLjo5RREYeoaZmLxcugNG4oYd+dddIQBRpsFBQgoKSEbOXqyWVqt4yElu2bOHkyVgqK6fi45NEnz5rKClJlFK8oaGFfPbZP/nzn8UoTXQM7Rw4UMuWLQ3IZAHSAkarffCS90erbeCbb5ZRU5MOgL29wOHDCzh+/GmJEhUT8wbffbcAL6+/SeIaJ07I2LnzIiEhs4iI2Iar6yBgJIcPH6S8fDKWBYeBkpIZbNo0mcrKAjIyRnPggKW14rx5C7lw4QCzZ9/N3XfPY+7c5dLiKSjIjYSEmyko2Ia4ELLHzS2c0aMrKS6Oo6pqKnJ5Dm1tOy8ZHXWnFAUGXseFC2YhDBkNDeEcOvQ0XUFrDQ33sHr1e7i4BPD444/y4YdBVmWDs2fvol8/FSaT6CjVahOLF8cRF/cPnJz8aG+3vHM6nQ5B0PLSS8+RkGBg+vRQIiP7I5fb0txcTmNjMfX1taSkPGEFIMvJiSEiQgQZdnRAdbUjZ8+6cOBAOUuWfEBUVBT79yMBDAVBT0FBDCNHFjNs2GhsbJwoKyuitVVLR0cbhYXLrDAdRUUxhIersLUVr6GtzYbg4DgpQq6ry6OyMpuqqvOAnLa2VgYM0GAy2dHQ8L+hA32NnvXb2h/KIYNIg6qvv0WKzK62Xns5MwtejBqlITCwhd9abvJyqfCAgHHU16/mq6+eQCbTs317z4XGjBkvkJOTTFtbPSrV0/Tv337FH1HXCH7UqEoKC09y7tx09u/vQ11dG0uWKC85ZjFiNDBggBv5+Q289NJLBAYGsnjxYquU9P79oV30jHv2VC4qKkIm28aMGR8TEmJArZZz6NA2nnkmlZaWUVaZhfT0dBSKIu66S7y+sWPF1H1q6huUlk4lJOSwpIbVGyp5/fr1vPXWXvLzEyWq0fz5cTg4xFFYOIdHHx2D0fgmU6da6FQmE+zfD21tLaSlrcNo/FiagOfMcbvk83v11Z/YseOuzlTtXu6+ez+5ueHSOyoIevr3vxkvLzEXLHKdnVmzJhhBmEFKyoO89NJ2HnhgGgqFPUuWpHcqcymkDIFG8yBlZccAUKtnWjmeY8fm4eZ2XnKm5jTz99+38Le/7cbd3UREhBEbGzeio5czZcozuLgEoFCITq+5ue2y0ZE1B1rOX/7ihp0dqFTmBhtmk0v3689/no/RWMzWrffQv382s2dXkpDwQOd2MvLyFpGTE0vfvioyMsLJyWlkwQI39ux5nI4ODX5+MGvWzaSlDcLGJoGICJWU3j5zZgI7d47pvN97pLMPHJhEeroFQObrmwyE09SUS0VFLGr1DPr0OYqd3TckJsaTlCSnpWUSJtM70j62tsmAEjs7Z1JSUjlwII2zZ3U0N3cAbhiNCzEvlDw9z5GTI6ejw4DB4MCMGY9yxx3PSuMxt2xsaalEJrOlvLy4s++x7H9KB/qayMdvZ384hyyTKVi+PILvvlP8onrt5cwseCGT1SGTGXF3b8LV1fk3+WB+LhUukylobb2vSwq4ZxrWwyOckJAx5Oaq2LvXm7//vQB7+y089VT0FaXVLRG8L0888RgJCQ8hk+lJTlZcMstgabUIgwcXUVMDWVky7rvvPk6cOMGkSZMkpwky3nqLS/Jdg4KC8PXtICTEgFwOfn6GTo1qeyve8OXu1dq1D0tp0RtvBJOpJyp52rRpfPHF07i7r7FyXBUVMYwe/TCtraeZNOklPvqohdzcN6Vexd9/DzNnQna2HW1tSSgUK6Tezmr1eh56qOeYEhPh2Wdvlsa0cWMmAQGRLFsGX3xhERhZsMDP6vqeecZJkvkUBD3V1fNQdH7N4gQJo0bBP/+ZS21tJjqdgdZWUX0rJKTSCt1uY5Paw5kmJsKyZU7IZHEYjddz22238Morf5MAW3Dl0ZElW2FNm1KprMTMsbc/RXi4G4GB/pw+/Tm5uf+ktbUIgKFDz5Oevp/09BjMaPN9+54lONiLwYO/IjS0HbX6I6AN0JOVNZ+EhOc7r/EmfHzi6NdPxcWLsWzdmtglNb6IIUMOoNPZ4O6uYujQFygunktg4A68vFTY2o4lN3dQZ0bBgMm0igEDFtPYWNbp0N9l8eIiiopiCApKJjxcRWsrpKQco7UVRoyAwYOhrg5qa3+gpCSO4uIYbGzSyMk5xBtvfIednV2v98/BwYvrrltt9TdL3+NrOtC/R/vDOWSApUudfhXn8FJmFrz4+ut/4OVVi1IJN9444Fd/MOYoU2yL52XVA7jrsefOdeNf/+KyaVhv7yV88w1s2yZOSk1NCl58cQXTpl26ttZ1HObJt7HxTslZyOU9nb952/b2dqnVolIJ110HgwcbOXKkmtdff50NGzZYAaF6m7jNFhUVxeLFRjQas/qWfY8J6XL3KikpyopG9f339Rw+vA4PjxomTLDIbgpCB5MmNVNYaN1P18cnmaNHbXjsscd4+WUNSUmJgIHU1NXExMSxdKkKQQBvbwPnzzujVm8jPn4xXl4ObNz4OLNmtdHWJpCa6m01pq5djjIyIoGegLa4OFHH+ptv7iEt7RTDh8dy4MBd0ti692UuK0tl165vOXbsVQQhlOzshUyaFEdp6RGqqt7C1bWI9vbrsLM7xp13+rNy5Uqre909zaxUrsPPr6es65VGR3PmtBAc/APp6d/y8cfNKBRKZs26id27b8OMCbCzO0J6+ioyMvTs2PEn4uN3MXy4Bnf3UPr2HUVIyBBuvFGGTGbCaJTT1DSM8+c/IiyshogIFfb2JrRadzIyyjh9epLVYio/PwZXVxWnT8+kaypfo7mf++5bh5tbCCtWqEhLi0UQ9NTVjWTQoFQMht20t78slQ7ARHb2DQiCQap1DxyoYuBAVY9rNkfkNjYiYrxvXwgPV1FUpKKkpC/l5Qbs7OyYN2/ez94/s11LEf++7Q/pkOHfR9pftWoVkyePZ8+ev6DRnCMoyHTFwKdLmSXKdCAsrBCl0psLFzQ9UuE91YF6Hqujw4PMTGuxhfr6oT+bVu8edU6f/hZGY2yvvYe7bzt8+HAEoQC5HFxdwcMDwMiPP5oICrKnsdFwWb6rtQk4OIj/7+GHv2Tq1OutFgpFRUVotRqiozsYOrSQ1FQvLlxQUFRUxNSpUZ0KWmLNOiRETVpaIdOmGTtlN5v59ltH6uq2U1AQS3HxVAYM+IbGxnCCg3cwYkQIr756mvx8UR5TBOuIoKvW1hhsbEShkKYmZyormzvlQWvYseNBIiLakMvBxcXEqFE6du+WdRmTrDMrYH0f4+LEuvmFCwdYv/5T6utTARNeXuDlpcLObjnnzi1Aq91Hv343AMFoNDUcOvQKKSnrOH36VavnrNHEMGuWiqoqaGv7nObmzZSXe/LttwpuueUWq+ffXblq3rxf3sJQrT7Ajh1/o6YmG9AgpqnljB+/D0fH7yksjMHd/SRZWXNoatJ3ifqvZ/782xg4cLYkOVldXci6da4UFLhgMontFisrp6FQHKO93Y6zZ0tpa1Mil+d11pvF41VVnWP7dj+MxnOAQkqf3333LNzcxLE6OcV26Y2tp77+NgYOVHZGvGakuwjSMp9brZ6Nt7eq81pFfndHB4SEeFNRUY0giJz91lZRMU6rhcJCsSf0L003X0sR/37tD+uQr8aulsY0bNgompuXcOBAATU12Zw+/RXjx9//i89vToX7+hbi4WHAaGymuDio14/55xYaOp2e4uIkTCZL5Gcy7aa9/dL0h67c2MGDnVCr29m370HWrx/SoyOReVulspVJk3Skpho5c+YMy5aJk6M5anBxgYEDTUyeXMa5cz5cuCBc0aIgK6uZ9vZYioqmcurULnbtOsG3334rOf8bbriB/v2bGDpUdIDDhtWgVoda9Uv+/vt6QkLUDBumprnZKDVqyMmxR6lUkpXlzJYtP2JGNwuCgcrKkTz1FERFwaZNWEVMIEeh0GAwQGqqqC+tUMi4776bOHnyr0CDpKldWSmQmmqLXC5HrVYzeXI6W7dG9cgKpKen8/bbb6NSNePrO5p+/fyIjhapT01NRlpaoKMjFaXyBEqljKCgR0hMhE2bzuPgcJGICD0hIQdJSbE855CQZNzcwNlZPEdlpQbwJCurmc2bNwMWBPivVa4C+Oaber788hROThsYOPAsYIeLSwhubkEoFEqamrTI5dvo23cnLS0B6PUOmEy3S1mMe+9dyODBTpLUY13dZ+h0fyI4eFaX2r6CkJD96PVNgIl+/cR33MHhR/R6BRUVg3j44ZEsX/43ioqWExQUxNdfw44dMHeuGLmfO6ciP38v9vZDMBoflM4/cmQpTk59mDDhIpMmfcahQ7d1eSeMnS0676WoyGC1AF29ejUrV66UFqY1NTW0tbUhk8kwGsU+0F5elnTzby1lec3+/5pgMolU+stZU1MTrq6uNDY24uLi8p8Y1/+M/VIak0ZTw+efL6K6+jwBAaOIj9/8q6Lk9evXs3fvE/TvL078np438swzX131cd577z0eeOABpkxZQGur2DGpqEjFXXe9y/33975o2L59O3fffTeDB5sYPLiOjAwPMjIENm3a1CPdZt521qxKfH1NVFYKbNnixA03NOPlJUYRMpnIdZXJxGi5qQl27gyVVLZ6s/T0dOLi4jAax1NY+EUXhalFhIVtZd48BUeOKKmr82L58gLMHZkOH1Zy442vsHLlSsnJ/fTTTxgMBsLCWpk4sRmZTBSQ2LYtkJUrH+Gdd/qRnT0HsVYpRkWCYOChh+S8+aZFFKOrehbICQhYwhNPTCckJISgoCA+/XQbhw/bddYat/Hjj+5UVNjS0dGByWTC1ta2xzul0dTw2ms3UF6+n+zsWJKSLI5n0aI4br11AIWF3rz99gdWDiA4eCULFyJhCOLj44CBnD49EUEwERX1kUQTEvtLw5kzUFKipLW1A1dXV6vSwa81i3CIOPZbb72ZRYvkTJv2D9zcQqTtun9fM2asx8lpATExMG1aBWvX7uPvf79ZOs7ixXGEh6vIzo6loCCG8PCLyGQb0GpN2NiIaGWTSUlDQxiVla0IgmD1XpnHZS7r3HvvY4SEfENHRy1gJCtrHgUFkwkLO0xk5G4EQUCvN1BV1URGxkIuXJiPRtOOyaTkhRdmMHVqs1Sa6a0W3LV0Y2dn12O77uN56qn3mDQpD0s7RpDLlZftDNX1PNfS2P+bdqU+9FqEfBkzR3tyeQfDhtlLjdKvhMbk4OBFZGQcyckXqarKIDX1cyZOXHnZfS5nq1atYsyYwezadTNQS0hI7S8+lkwmIyxMhY+POEErfuYtMEfoQUEF2NlBWFglanVwrxG6pQuVCbkc7OxMtLW1cfq0jOnTjeTnx1JYOJXAwCT69lVJqkyXAqeYJxq1Wk1bWxt2dqOs0rAy2WSmT9+Kg4NeSjkruwC+P/zwhNRs4NVXX6WlpZRZs6Cqyo7IyHZyc2MpK5vKyJFO/PDDdeTnR5Gd3XUEAiIdRy7VacPCfiA+/hOSkp6lsnIYYsSkp6lpHpMnj5Um2tdfj5LAQ598ks/nn2tITPyQkpK3MRqxqidPnjye8vIETpx4A60W3N2hudm6tJCUNIsVK8JYvXoeM2fOt5qAxXZ/YDCIrRwTE99EowmX9h8+/CMMBnEhZDCIi6GoKOjfvw2FAgwGg1VP7V86qZuf13ffjUEu9+isQetRKtdy/fU+PbYNDw/njTfewM7ODj8/D+TybDIyFtDQ0MGGDUVs377S6h4UF4tUocBAFUajivZ2UVu5pqYfFRUampqaUCqVGAy1vYKeNm4EQTBhNMoQBD1nz/ri51dGdvZSCgunExh4gFmzHgPa0elkgA2trW3odBAauhUvr600NtpQX29Levoy1q49YLVY775A/bn0stgZzCiNJznZhLPzZ1YqWfb2rp2iL6MlNS2TSY+LSxhDhizlww8/u6Yn/Tuxaw75MmbpOSwQGlqDjY0LqakdV0xjGjnyLjIzf6SqKp1z5zYxZMjiX9Vpaty46eTmjiAvbycNDUW/qL/z5MmTcXV1xdGxTvqbhweMGhV5yX3MYLW0tL8iCAbc3OC226b0eg/M22ZlibxbQaAT1NVMbm6sVcekAQO2MmLEJiIi9luBisyT+sGDB6V0tFwup62tjZEj91NY+JA0SQ8ZkoyNjbifTEZnynk5avU4QkJSiYqKkhZWbm5l3HSTuK2bWzsXLy5k//4fJZWvWbPgu+9qEAQ3ie/q53cCV9czVFamSHXaF1/8GrV6KgMG7KCycqQ0lhtusEiJiqAoC1jr1Cl/vLyeoKPjbamJgrmenJRkYO3ab8jO7ktISCwhIWItOjAwidRUS8rZzi6NoKAY6T73rPlaUukaTRiA5MjS0lajVt+Ct/cXRESoJL1og0HcX0z5OlxSKvNKrGu0azQuwGDYIN2D+fN9rKK4/fv3S9sKwjxCQhYSHf0N/v4byMqahlo9h5CQJEJCdpKScr90DwIDkwFRjzsigk4ZSz1KZR3t7X3QarU8+eST+PnZ09CwHXf303z//c0oFEpOnRqJSnUfZqqVOY2flTWHhISvOs9xN/HxDZ1KYUbMZRZzUOPiAj4+HbS1dVBf/wUDB9qi0QRQXPzLFjPmNo3m2nVMjMCwYbdZRchlZWeoqyuksjIDs960TCbD0dGH8+cT+emn/YSFydDp/CkpuTrtg19j11Ltv71dc8iXMUvf3moUCi19+ujw9fW+YiCGg4MX06Y9zebNK2hqKuLAgX8wf/57v6rTVP/+c8nLO0hTUwmHD7/OnDmvX9X+UVFRPPvss+TmWoQq+vSBxsa9QMwl91u1ahX79/fh0KHlALi7Z1x22zVrXgCq8fd3wsXFBSenZs6ds0R8ANnZsWRnLyQ+fgklJSkEBIyTJvWmpiYaGxvx94fYWFt27dLR1GQgJETFkiWitnFAQDJa7U/SeU0mmDFjPRs2LJCc7I03gkJRhK1tBfPmmSTOsJ0dpKbOkMYjlxtZuzaNzMz3MJk2SH/v3/8lqqtP4u6ulOq0CQnfSb/fc08FNTVtTJsmY+XKBdJYwsIKMRjERgoGg4zq6qO88EIQISGxBAaKnalaW8V6sky2is8+ewoQkbuLF8fh5qaioWE7NjZx6PXT8PBI4+mnR/Q6yZaUpFBSci/x8UEkJ4tRu1jfBnOHqgsXzPd+OY6OcUREHECh8OfChaxOcY2eUpk/ZzU1Wezd+yRtbbU0Nuo5evQoUVHQ2OhHScluQKR9xcXZc+7crXz7rQqdTlwB6PUwdKhAdXU8R45soqJCz7FjcUya5MuhQ49bKXbdfPNySkvn4Od3EoNBRU4O2NgIhIcP5MKFbEpK4qitnUtQ0HYGDjyDXv8VhYX1tLQUU1qqRyYTAIF9+4ZbiYuEhiZia6uiuPg7K863Wj2D4cPTOqmEjdTW1mI0QkODSF+yt4fwcCVKZRt+fgLV1fXodL6o1TVXvZjpCcTsWTZqaang1KmN6PU6KULW6Rqprc2jsPA8/fu3YjLZUV3dSEeH1y8ax9WapWuUkXXrZKxZ8ykTJ+ZLkb3JZMRo1ElR/K8p1/2R7JpDvoyZo733338FL68WXF2NLFoUflUvemjoNEJDryMraxdbt5rYurWKuDj/X7yiHDr0Vk6e3ERt7Xmys1VMnPi3q46SV61axY4dCk6c+AsAWVmx7NsXQm1tDfHxPdG0lshmEA4O4Wg0uWi1jZc9h7OzG83N1djY2LBgwWT0+q8JDhYjPkvtVYYgGEhOfpI1a77gwQedeOed1wkIaKOx0Y6GBgPjx5twc9MzYYI4IdraQv/+Kvr3V6HTwfbt/jg6jqSkZCohIUfw81tgFZkmJ8u4664gJk9uk5yxwQAJCWAypWAyPdCJJJaRm/sWMTEJFBUFU1Awl4CAHWRmHsXFxUVKfW7aZOEGy2QGnJ392LDB+trNiwo3t0kYjZMZOzaahIRpCMLkTifzMidOfIhGo8VoXEBV1VN0RWxXVKzm7Nl02tra8PE5zYIF/jzwwMO9vnebNmWyceNJQkKCOqM6GQkJP3ZZaCRiMMgQhHlStHz2bAzDhkXx2GMvdavh2lmleLvXJRMTYffuNnx9v8fN7XXq6goAUT9aqzUREiIijI3GCmxsYikqiqSj489kZPxAaysEBIgYAouZKCwca5WSLimJl56fTKanuno5f/3rcSZOnIWLy12kp//FakwrVqj48cfYTpWsFcTHx1Ffv5O8vCUUFf2NIUOyCQr6Ar3eRHDwQY4d+0uXxdZH1NVBaGgaSUlLpb+XlJzG3v5hVq1aRXp6OosXz8fDo53WVheqqxuxt5exdOktbNnyHno9aDTuEqr+l6Cmfw6I6eTkx5QpT1v9zWjUU1ubzYEDH3Hw4L8wGGTodK6/ahxXY5YMkAyZTM++fe04O38iBRsGg/ig3dwCKCs7hqurmZInx9nZn6ioxT2c9LU6+DVQ1xVZeno6SUkPU1d3CC+vcG6+OdEKmPJz1tCg5pFHXmfjxnckys2vkes8dmwtu3c/iUKhYOTIP191lGy2NWsUZGXNIyHBAhzqPq7uoJvbb+8ASrCxceGuuw5YCUV0ta1b7yEhoQq1ejojR7ZiND6Fq6vYcP7UqbtQqxdJ6TczKOqZZ1I5fHg0o0aJ4iGZmUauv94iSykIkJsr0pFsbFoxmRyJjr6ZDRt8pPE/+SS89JJFjnP9+kJWrgxmzRqB8+fF+rWvbxIHDiRhZ2eHXL6YyMj7GTOmgubmeVRUWNLqJpOC+Piveeqp6F5AQT2fY0lJCl9/fSslJbm0t4NabUd6ugMNDa/Q1nan5MQffFDOXXeJk8/XX4/hyy89Ou+DCCDbulWkO/3c5NQdOCXqP6s4fTqW0tIYAgOTCQxUkZUVy549lmvy9b0bB4ckCexknghdXARqazdTX59PYWEhGRn5XLxoS3W1K+PHv87mzbdZgcbEBYBIA0pLE5HvQUFJyGSwebPlfEuWxNG/v5iG7+iAmhqRAiQI0Nh4I0eOfAXoAcvzM0/2339/aRU4gNWrYf168VkIgp5Zs7YSGZnO2rXPSs9I7Ln8U+c4Z1uJeAA4Oio5eXIGBQXTsbU9T1PTHkwmeZdWntbfQHcUdfe//6ftvzGOrhGywXDpCLmpqZTq6iy02hoABMEWV1d/3NzC8PaOQq/X4ek5gN27s6yAir+3Ovg1UNdvaFFRUbi7v0BCwk00N5eyf//fWbTooytOPYvddf7SRa6zpyzk1djw4Xdy9uwXVFWd5dtv69m6tYG5c92u6njp6emAL2q1JY0skxlITpZflsL000965s+H8+djuPnmC6xcGc2iRT3btLW1/ZOEBC8pdRwfn4ur68ed96OAWbNOUl09mrQ0Y2fLSSNqdQiDB4sOOCzMSEAAEl1IpxP7O2/ZIopxmOlIKSlyzFrCMpmBo0fP4ez8Bi0to5DJknnuuUOYTM+yb9/LHDr0eOe+q4mLi0Mu/4mMjO0UFu4jJkaJTAYnT1oDqWxsZhIVZcka9CbYAVBXl8unn85Hr6/DwUFMa0ZEtFNV1U55+U8YjSskBxET07ULkgqTKVa6ppkzTxAXNwb4ea6pCFAySinYM2fuAqCsTOyY1L+/6HBGjlTh5CSm+ZXKY7S25lFe3sa332rZsEFPaGg5grCahoYSRJ6wyJsNCQE3Nx3bt1ezebMbINY5wcD+/aLEY0SE6PDF52Lk1KnV9Ou31eoeFhbGSAjv9nY4cEBsQ+nk5ISTUxI+PiuIjLyf1auHExeHJHMq3t9LO2Mw12DlUg32/vuXkJS0RGpeIXaUWkNAwGhGjz4NXEQu/xtarYmcHDnDho3ExcUZZ2cV48fvpK3NmeJiHzIzayQqmFmM49tvtRQUhBAc7GX198stnP4Tddb/hlhIz1T77b1up9HUcO7cl7S1mTNqchoacqmqyqK4+CgymQKTyZnDh88QEiJHJvO8qhaWvze7FiFfoRmNerZtu4+0tM24ufmyePEnBASMveL9N29uY+lSpSTX+WsbWqjVyTz99Ea+/PKLq466zStqG5tKBg+eLk2mILM6hoXCVIWvr5HKShl79ngza9YSPv30XWmB0XUfc7T19ddj+PprDwwGsanDXXdV0dz8J6to3BINWe7JmTMCWq3oEE6dcsLffyolJVPp2zeJwsKpnDq1stMBmelIZpCLiFR1db0NheJzrr8empth506Qye6gru5jLMIOBkaPfouYmIfJzfXn2DEjMTGjUaunAq2kpDyNOWLr7dp6m/QeeuhZjh93o29fUUazrU1cTFRUwK5dIJffwYQJTzFsWAPLl9vj4aElIeEO8vIyuHgxloKC2bS1pWJvf6BH5Nrb+SzUq57WlSIUECCOpbERNBo4dAgUCg8Uiuupqtog3TdLxCtaQwMSWC4tLZbduxO7nUMEj8XHx3H69N1kZ1sG06dPCuXl46RxzJkTR3CwChsbMdORmQmHD4O7uyf/+Mc/mDx58lVPvF3vTX6+WEowmeCee8TfxcyB9buxevVzjBhxgsZGLVqtEYNBj0Jhg9Fo5Nixwzg5GTGZbCgp6eD4cVAqPSUqWEjIKit60uOPv8XIkSewtXXExsZJaq+oUDhKFKXulKa77nqa667LJDAwFEGQYTSaMBi0KJU++PoOpX//6T16tP8e07gaTQ3nzydgMBhoa6shLS2JjIwj2Nvb0drqSEmJBxkZLb3SKv+/2rUI+Tc2mUxBTMyzFBefpqmpkAMHXmTZsq96fECXsiVLlL+pXGdQ0ESamjquuknGli1beOmll1AoZPj6hlEnga2FHtuaQW12dsZOCpMRe3sHWloe6nJei2xm7yhbsT67YIEfr722oEvkZCQ9Xdbjnpw544i9fSv29rB0aSp//etAzM0dIiO/kaJBsf4sTrhPPgltbTIyMt7l5MnPuesuMcp2dxe1pRMTx3RJj4u12oCAZGpq4MwZHW1tc0lI+Ewa2/LlOdjZubN0qZd0Py/HR09MhLfeWiONc/FiMUUrk0FwMMyfr0Cl2syJEzs4eVJg374GZs3SAiJqd8QIFUOHbiMnJ4CTJ0UUf1cUcm8pvK50GctCQ6zbmSPT7OwYbG1VaLVi7baiQoxQNZomhg+/ndpaUR3MHF1HRIg9h809ic0Rdl1dVzCeCbNSVdeovKs5OlZIwLugoGQpOgYx2+HhAa6uorcPCQm5akfTm2pcYmIscrkJlUrgoYeeZebMUI4ejaO11VVKZx875oKr6w7pOK2tlmP26yc6dIOhA6USfH0Fyso8JfT0hAk3ddK4RHrSwYMynJx+RBAUyGRyxMWhDDs7N0pKUujTZyiffBKLTDZBOn9amgfu7lsoLVWiVLpgMukBsLV1xtm5L1lZ3+Lm1g+TyYiv7wj27s35XaZxHRy8GDtWbBRiNOqxtR3Ozp3p6PVGZDIXqc/3f7tpxn/DrjnkqzAXlwAiIuZx9Oh7VFScJSNjG8OHx1/x/r+lXKdMpuCmm4ajUl15k4z169fz0ksvUV1djb+/kUGDqklMfK3zV9Ehb9pkGaMZ1Hb+vIjIdnSEe++NJyKiP5s3W+pHMTG9qXntwoyyNTu2ioqxHD4svnImk4zERLj7bnjzTcsYPTwCOXq0P2r1NGxslJLjBwOZmTdgTu0uXQqBgRaJ0PT0dJYufYo77rB0X5LJwNcXHB1P0N5+X6cGsoC//3GMRti61Z6mpgYEwQIskskM9O3b32pM6enpfP75M8yf30RNjcDZs76sW7eOwMBA7Ozs+O67Mchk7tI4jx59FpkMwsJUqNWiWEd8fDNGYzMnTsTS3j6V8+eTiI4WnWVjI9TUuFJeXs/ixS2cPLmc0tJWJk+Gujp3srLkPVJ4ZrqMJQo0dTpnSzvA6OjkTuUq8TqCghQ4OrqTkWEkJqaekyelt4mLFxexc+fzpKSIPYlPnRIXFv7+KpydrZXdLIs3cb/IyG86/y0uDLy90wkPVxEWJvKEc3PFhYAI+BIjZEFwxMXFRZp0ExNh3z49AwacxNn5WfR6MeIU6T8Cp0+P5cyZYPz8duDh8S2zZonH02jgwIFcZDI9BoO4ENmxYzgXLy5CEMR3xdzWMSQkWXqmXZ1xRYVY1xYE8V65uYGjowl/fwt6OjRUjcHgJaXGJ082MnDgIqsI2Wg0UF5+nurqPCorz+HiUonROFm6by4uB8nPl9HRYWDp0ln4+vpgMGjR6TRUVGRQWHiEgoJDyOUK0tNVHD+eTb9+Mkwm799tGlcmUzBp0vUsWFDSow7+e7rOK7VrDvkqbezYv5CXt5/q6lxOnHiTfv0m/ipu8a+x+HgvHByuLOo2O0w7OxORkRAZCV5eeuzt2y+9E2J96ssv08nN3YC9PQQEZPSqmb19u8jZHjxYz5AhpYAHGRlic4V58+aRnp5OQEApQ4e2k5Y2CpD12pTCwWEzCQmRVvQoc0renCYVe+rKrZxmUVERw4Y1olCIwDGz+MjZsyqee24EwcGwaZNAYiKUl49k69ZE+vZdwrJlP5CdvYukJBF9K3JBLcfV6VrYt+8Jpk5tQi4HpdIE6Pnppxruu+8+BEHAaFyA0bgBMUKVU1U1jM2bEwkKimPxYrHfrVwOFy/Gcv68pQ+xjc3djBwZyHffbcRoHIG//1Tq65Pw9VXh6WmOJhsBJ06etOYHd30GSiWkp4vXZhYxmTTpRYYOzUSvH4hafRGDARoaPMjPn42r6yiKizcwYICR7OxYxGyDnvz8uVa13927Y7CxOYRcfhQfnxW4uMRRWmpPW9sMumZUyspGYl4oied3kNDUra2QlwfnzoG/vz8GgwG9Xo+rq4uVdKSY2hUwGq8jPt6+sy2iGHlmZcWSkPBs59juYMmSNil6NxigvT2JnBzLgkGvF7pchwEfn7NMnbrGKiXf1VxdBSoqTJhMMoxGD3btqiEqCvR6JTU1zVJHsVGjur7zPftbG416qqsvkJn5PR0dGoYNA5nsCY4f9yY09CB+fkmo1WFkZLRw333xzJkzT3rHPvzwPEeOGBk2TM2QIclkZByjqWkmNTXT8fQ8TkjISTIyWv6rvY//nXataYZo1xzyVZqTkx9Tpz7D1q33U19fwM6dD7No0aYrTl3/1nalUbdF5ESJUmkkMFCMCIYP30Rp6UIEQUzZ3X13z30XL36JN974EaOxmpKSM2i1DcTFWYPIzOnt8PACbG0hPLyG/HxRQ7prilEunw180mtTCoD09EgrWtGCBXL69ZOjVMJLL1kaQ3Tfr7GxkKAgyM+P7UT4il2Ypk5NZuVKcWMxzWs+th4/vwm4u//AqFEq4CaOH5/Cww+PJC5ulHTcl17ayq5d0+jbVyAsTEVREaSm1jJ9uomAgGZaWmD//rbOrc2CE2KKUhDu4siRqVJ7xsJCa8BYU9NqbG3309Y2k7q6j6moEB11fPwSnJ1/QKeDujpXsrKMvabwuj57UanLiMEgntvBIYYFCxZaoYTr6yfR0PBpp/NdxaRJL5CdvVAak7f3DqqqRmLmLo8de4jJkx0AB5TKU/j5qUlMDGHz5plW43B0rKGhwaIKZo5ETSZITX2e9PR5CMIOnJ1f47bbvOjoKABqqat7jDVrnmTXrjcRhDslHvCFCzE4Oe1k8ODReHm5cOzYrdJzEwQ9ubkxeHmppAhZoVDx5z8/Q1nZJLy9D3Lu3DlMJst19eu3huHDawkJWQZATU0dZ88mIQjg52dCEExERIglAK1Wg1brwfHjjbi4NOPm5iYtHKKien5r1qAtBb6+0fj6Rku/e3mlkJOzAKNRi1rt2Ws6dudOJ1auvA653MgPP0zgmWdaqKjwYMeOVzqv4UEmT47juuu2U1X1Fbt3J2Nv78OoUXfg4PDLmn78L9q1phnXHPIvstDQGAYMmMnZs9+zY4cDP/5YTHz8oP9ptRqzwywp0RITI6ZzTSYYNUrF4MFvotP99ZJRtoODF2Fho8jN3cGZM6O55ZZcbrttlNW2XRW6BEFsN3fvvWI631p+dB8+Ptap7K7W0qLCaIwFxGjVx0fFm2/GAmb0rbzXcarVCeTnx3Lo0HOIDkVs/JCUFENiori9GZFr5rmaHYfRCJWV+/D1TWH5cgt4KTER1qwx6yivZuDAOCoqVNx4owkXF7MyGDg4jLGK6M0OrbBwEUVFoirZkiVxBAcncfr0aswdiFxcniUz8we8vd+kvt7iqM+fv5OJE73Zu3cbBoMBpdL2kim8oqLDqFT3UVMzBoNhkzSOsrI3uP76VB544G9S9PH0046oVEbJsRUUONCnz90MHPgAq1cP5+WXrdHy7u4GoAwQNaILCiAsDMLDZ5CbewPmFHVY2F6mTl1LWVkcgwenM3p0O+fPu7Nnz19JS3u6c7sRNDbO4Pz5F4mIyOs8g7iQCQ5WcezYCmns2dnJpKV14OOTy1NPPcX99y/uBMaJ7SBHj+7P7t2hvdJ80tP9iYv7Ch+fFZhMUxCEA5SXpzNvnrVOul4vLlIMhkYiI7V0dGiwtbXHZHKjqkqGn5+SJ5988rKAs+7iGI8++gYTJlyUUthyuT0mk57Zs6fy2WfHaW7W9ZqO7crpFQQ9+/cbgBCrxZtGE8O0aSoKC7+nuFiOvb07RUX78fGJQi63BwQGD74eH5/Bv0p46Jr9d+3ak/sFplDYM23aGnbscOKTT95AJjPw9df8auT0v9PMDvOtt9bS1ibWg82az76+G1i58n6pxV1vNnv2m+zc6UFCwhfIZHo2b+55vatWrWLjxmRKS7dgbw/+/mkUFU3E1raC2bM7aGw0AX05e9aSyu5q6enp7Nv3ID4+idJkum/fPtLTQ4mKirpsNuDcuYls3vwiYurUuimEmcrVNc2bmvoCpaVTMRohI2MfHR2OvU6UXRWcIIZp0yA11RL1FhVBUdFeTKZVmMFm/folotcLFBUtkNKmanUMQ4Y8THDwC7S2ziU8fAcRET+g1UJkZBIXL1pSrpmZG6moOIy9vT1xcXGsXLmyV5T1V1+dRxBeJSIinfDwdOLjq8nJEYFUffvu4sCBOP71LwPHjl1PRMQBPDxuxGh8B3NNtU8fDcOHf0RHx0ecORNOQ8P9Vk5ArY4hOloFBNPWpiEvrxqdDgyGMrqmqDs6/HnmmZGEh89EJrsZgNOnU3j3XXssgDOoqBhDQkJiD0R3RISKxYst6ms2NiqSk2NpbJzNiy+eZd8+c0csc2kmlvT0UCsaUlc08kMPPdSZkdlm5QC7btM9RWoNorPjscdW92i20p3CZOkZLQLjEhMH4ur6DwnkBSZkMgVubt789a8D0Oud8PYOJioqCJ2uBVtbJ9LT03F21mIwjJIWitOn22E06jhyRCFlBsLDUwEloMNoBI2mnry8ZAoKDiCXK3By8iEray+C4I+XVwCDB8dIqO3fI1L792rXaE+/wu65p5yPP/bp5NGaWLVKsKpr/i9aeno6W7YswmjMQ1yP6ZHLlcyf/9HPAtSWLk3hhx9GSVKTq1bJelxvU1MJa9eGAR3Y2AQSF7ed9eujcXMT630HDvhQV+fYa2en7du38/DDS5g+3UhRkT2VlUEUFdVcEf3huuvWkpKyCrOT6Prf7guH7oIazzyTyvLl9pekFpmd8rhxL0igJzOtyMlJxeefxwIW6lh0dBwwhvPnzdGhgIPDC2i1qRiNP0rjmjTpBSZMeAYQ68tFRTH4+ibj6KiipsaJoiIRKNb9XvUmCBIZeQyjsYO6ukZsbODChVi2b7cW54iOVrFv3/McOvS0VI9fsiSOsDAVxcWxnDx5N3l5C62uLyxMRV2d2JRCrxdrwY2NsbS2JmKmhpnFV7rbrFkn2LNnDF2dsiDoGTt2PSEhyajV0zo7YSXS2ipmHIxGcezbtlnGfvPNDzJqVCparR4HBxt8ff04dWo0r732mFTCmDQpDl9fsVnJ4MFD8Pb2RKPR4e7uTb9+4zh1Sse77358WcTyldDMzMj2L7+sxMnJtwf17Lbb/kR09EHkchtCQ8ei07VQV1dES0s5JpMWW1snHB19cXcPJiOjmj17TpOZOZe2ttvo1y+MF1/sJ72riYkic2LSJB0jRqRQVHQMrbYena6V4uJU6upy6OhoRaFwQa9vobpaI7US9fbux/Dh0zl3roTExFRKS8HOzvF3g9T+/2bXaE//AVuwwIdNm+RXjHL+X7CoqCgKCmZx+vT7iBMqZGTMYM8eDQ880MSyZZd+WW64IZLNmxVSei00tJDt2zOsJrCiogZsbf04d24YhYUz8fe3o29fZ7TaZgCMxo5Lpl+DgoKYMkWLkxMMHKijtbUMpdL1iugPNjatiE5YpDXZ2n6DINTy2mvziYuzdhYWypACmcxIS8soegsczBH1Y48dwGhsobBwJuZ0tCDoKSqKQS5XIQhTMaehBUGPo2MMer3IdzYvDDw9Hairm0Frq/lvJg4dehq9Hjo6HAkOTmLmzIcxmUSn5OOjRSaz6xXII0ZmSKjinJxnqarKxsfna4KCRLpVZeVUCW0tCAby80Vxjo4OR6so+Pjxuzh9+m4KChZ2ZgGgX79tDBnyEf36iVGsl5f4P50OnJxs2bdvJxrNIpTKOdx8c4CVhndX2717DH/6UxVbtthSU+Mm3XM3N3cSEhKRyfSkpDxEfPxC/PwSaWsTkdMFBda19uzsYPz91wOilnR9vYxDh6ZIIDxzSjc0VBxva+s5QOw5XVlpS03NSbKyKomMFLC1deX48ck884wTgmC9kLhcDbN7V6aPPtrLypUHGD36fk6eHIIZGJebO4SBAxOws3Ohvj4PP78htLeLvZrd3ftiY+NEZeUFsrP3U1VVgZ3d9dTVfQ7oSU9XsHfv68hk+djYKLG3l7NokblWPJng4MkA6PVaSktPUFx8nI6ONrKzD5OaugcHB9EZ19bKaWpSI5dvp6ysjEGDFPj5eZOZ+ftEav+e7JpD/hW2aJH8N+UW/6dsypQnOX/+ezo6qsnKWkJCwved3Mqe0pldbdkyFynl29ysYu3aB60iDhDrxTrdWEpLv+vkfip4+eVPgCUALF7seUlZP1ERTfz/RiPk5yuYPXvWFV1TR4cLXR1gZGQpFRWv0a9fCGDtkM2UIXO68ecWUllZ06WI0mwmk4KgoGT8/KCy8gyFhQrJATY19UWns8fcltFkUjByZDKlpXacPPkAXXnDx46JEXdq6mpmzYrDz08EK1VVeV2Sj2nu7GR2yqdOjUQQhmIy3Uh8fFxnW81WqY5uMsmxsxOjp5CQJFJSLOnxkpJFdOcvu7rmS84YREdcVmZ2hm44OMixtU3h/fdvp6kpklmzviUo6DDDhx9HoZCjUChIS5tARsZQfHx+YNmy78jIiKWqKoZhw7JoaFhgBdLKyZlCYGAi9vaiQxkwIImMDMsYAwKS0etFelhrKxiNRoYOrSQlRSFtExSUjEYDDQ32tLZqGT9+NCEhgej1WnJyTuHsrMfTE7KyJlNW9gmgZ9UqBcXFrzBq1CkEQY6DgycBAVMYNGhuD5Bm965M/v67yMj4kYEDGzl58psugLYUHB2D0GhqKS1No7LyfOfztqGpqQFPz8G4uvrT2KgnP7+C8nLrxcfJk3b4+3+DIMiQyRQolZ4UFx/A2zsCQbDBz28UAwfOIjjY4qCbmr4mN/cInp5KdDpbGhpcaGiooF+/gZSUlOPpKcfVtY2QEI/fNVL792DXHPKvtN+SW/yfMheXAIYPv5ETJ9Zz+vRtmKO+7tKZvVlcnKizHBf3YBfOcTuvvvoqAJ6ebZhMkykrs/B6y8sX4OHhSlbWZAoL5xMdbehVbnP9+vW0tYm1bUGA1tZmtm7dyu7du3821ebhEUXXCLmtTXNJcQFLLfnnF1JvvnkGQYi2Ugcz/7e1FbKy3JDLD+Dq+g6NjQ8Axi58aQgL20ZIyEc0NqrIyAB7+zfQah+WHLxZ+lImM+Dg8BZ9+kRKLSeVSkWv2QTL+EWO7/btRilabmm5nwcffJCUlK4RupHq6ig6OiAiIo34+MXk5EyioaEf+fnze4DR+vfPxtFxMFlZGbS3y2hoCOL8+QYaGlpwdTXg4uLIY4+tRi5fzB13gCAEYTItl2rDIk3p5U5HE8+SJXGMH6/CYDA7+RqMxjjMtWyjUUN5uRlkOJ6AgDpcXB6lsHAkISFn6ehQUVmpoLzcnfJyTxoaGti0aTxTp9bzySenqK9/l46O3Zw6FUlFhQZBEHj++X8RFRWFXq9l375P+de/VtPRoScraybmVLsg6Dl8WImTkwqZTMDGRklBwX4yMr7C2dkXOzsX3NwGMGTIUuLi3Fi/vpD9+42MG9fA0KE+tLfHM3gwBAe/R0ZGJH377iI09ATt7U2YTEYUCgW2ts40NzdTXFwJVKJUZuHl5YaTkw8uLnbY2+/GZHoAc4alb98CoqJuwMZGSUeHloqK81RUXKC09CRyuR2FhQfIydmCm1t/XFwCiYpaTL9+0RQW+pKTo8XV1YbGxiZsbT0YMuQvfPFFDt7eGhwcnP/Qghv/X+yaQ/6D2qRJT/D99xqysy3eqDc6UW9mplANHmwgOroM8OD0aTHduWBBPVVVezh/fiVmpPT06XK2b7+dhIS3EAQ9ixf3rOuaedLTp0NJiagW1a9fEg4OKRQVdVw21bZ+/XoOH3bqEsUayc2NYtGi3tsVwuUXUuZaYnt7OxcubMdk2oDFuVnkN48cWYC9/VEUina8vafR2AgioAzM0bGjYz5+fipSUqCjQ8DF5WVefXUpBQXBnVQuc6Qu5847Q4mL+ye33HLLz4JwzGM/fNistmXoRG5/y65didjZjQemdW4tIy9vEaWlsQwZcp6IiMP4+PxIdnasVc3Yzm4Pr70WwcqV/5Luqxno5OzszooV9zFx4kRpXBaqlUgjq6yMJyamhsOHb+kBDgsKEkVQ6uth0KBMJk16nUOH/oYgGDhz5ml8fE7g7q6ira2DwEAv5s7Nw2C4iEYj57PPBBob9WRnV6PX10uCIlFR7txwwwzWr89k3bo02trqeqCYFQp7Zs/+MxcvtndSv44B90rZjIkT24iIiEUQ5LS0VFJfX4RanYwggEJhh1LpRUHBdrKyajlwII2cHBvS0pytFojmOnJLSwSpqUp0umZaW2upq8ulurqYmppqQMBotCc310RZWSuTJrkQGqrExUXUGU9Li8FgOMXp08d47jkRM9Cd16zR1FFTk0NR0TGKio7h5ORHUdEBPDwGMW5cXzZvPkp5OchkMhYuXMjixYspLi6+rODGtZ7G/1t2zSH/Qc3JyQ+Z7IUuSlgm4uKurOGFmUIVFiZyjkeMqKa01IXmZmfk8noGDlQxd24cR44s5IUXZhAXF0xi4uPSJC2TGfj++3oUihPS5G528sePL+X8eXO/4dVMnx5HePh5zp61Fsbo6jTXrVuHre1ETCazjKMMg2ERhw79RHp6+s/qQnc1sxMyGBoZObKOW2+F7OxKMjJmUl/vT339EszOub19FzKZKINVWloKRHY5kqkz2kzG3x9mzIAzZ4IpKtLSr1+GVLsUqVzWkfqV8DF7almLILEBAz5Gq4UJE1SUlW0lL88i/KFWx0joZgcHiI5WoVTGkZ0dg16fSmNjEv36bcKc4v85sQbr1L+Chx66ibi4m+jTB/butSiGlZVBbm5fsrJAr7flkUc+Yds2T8z0NEHQU1MTw5AhKnS6VPLyzGpgAjKZnOhoE5WVIujrwgU9gmAt83olohJdt8nLK6SgILjznj8mbaPVNpCe/h0VFWmYTHpaW+uprr5Ibu4R6uurGDBAwN/fjRMndL0uEJ2c/IiJ+TtgqfPu2vUxR49+hpeXHUajLeBOSoqGZcuW4eiYRUbGx/j47GLEiNM0NPhQXm55z2Uya16zXq+luDiFgoL9GAztVFVdoKIijYKCI9jZFTFzpi3V1S6Ulck4ffo06enpl703FtqWiXXrBF56aQsPPjjpd8Vt/v9m1xzyH9hiY33ZuNECVulNFKQ3M1OoEhOfYsSIFgDi45W4uz9KTs6DnduomDw5gpUrxYPGxfXp0ktYzq5dT7Bnzzap/jxt2jSUSiVy+Xir6KqhIYbGxjNWqbaukZvJZEKrbWHixM/Jylpi5YBaWkZx8OBB3nnnHbZtM3N6L60JnJ6ezqefPsvcuQ3k5YltHmWyJAYPVjFggAqTCQoKYiksjCE4OBl/fzHqy8934sKFBNraRNBXV9pVS4soy6hW+1NT01Pgwxypp6ens337lVNTkpLoci7x/3d0OABiHVZ8BpvIy1uIOR0aEnIAW9swHBxcaWszkpaWBqjw9T1MUZFjr+nM3hYHXaOq3lL/cXGwYkUVGzb4AEbKy/9Kfr6GMWOewWBYwT33mDhzpr90PJNJgZ9fMlqt6Bzs7ZUIghN+fqFUVzcD5+jbF1xdZTg7e5KTI+9RB72SRczPbWNv78aoUSukf+t0LeTm7iY5+WtOnNiMj48ce3stERE9ldO6m0JhT3DwZMaP9+DVV5Nwc2vD29ue3Fw9dnaOREXNA+bx7LMCRuMYnJ0z0OtVl00pKxT2hIbGEBoaI/VDzsnZycmTOzEYcgkMtMPNzYC9vQfZ2Q3S+C513RbaloBMpmfPniaCgu7E23tQJ4faSGjoVIKDJ1yWEnnNfju75pD5fXZUuRLrTQLzSm3VqlVMnDgGlWoCYEQQjKxatYqPPjpCcfG3AHh6Hutxru+/r2fXridwdt5FSIhYfzZHGw899BD79+/l7FkLoMffP5m6OhsrLum6devw9q5kwoQ2kpLkyOV6Bg8Ge/tNVilYmewga9bspba2FoA+ffpgMpkumf4+eHAd06c3kJ8fy65diRLYau7cOOztobhY5B+HhiZTWDhV0qt2dm5BJjuIVns7np7ryc937tSXNlBX9yipqUfp6GjB2dmZxx77W4/zPv7443zyySfo9Xqpu1D3BcOPPxr45ptMbGxepl+/ndTVLQM+6LKFjJCQg8hkAygry6auDsrKVPTpE0dlZQxubud56qkXycoKISEhHReXTURE5FBQoKGhoQlBcGL16tWASD+7XDtBMxVs3ToF99yzmpEjU6iutuHjjwVsbJzIy2vg++/vAO7CnObPyHgaDw84dOhpzCAy0YyEhycSHS32SzYYQKttwsVFRkNDKXq9kro6UZGrrMxIeno1Dg4e/5E6qK2tE5GR12M0DuDNN09SVqahTx/bSyqn9WZRUVFMnfo2335bTV7eAdzdD1lJhpaXi2IulZUKRo0qZeFCPWFhfj97XJlMgbd3JN7ekdjbj+e7785gb6/DaHSjpOTS+ImuJmY4BCnDERmZRUXFBcrKUhEEG2xt7SguPoqPTzR2ds74+o5g4MBZ/zVVwj+C/eEd8uW6+HS336Pj/jWgtBEjxrF/fwitrfnIZFoaGtQsX/4Wa9fuITNzIrt3z8HRsZKbbvKVzqVQnGDPnm2EhGgZMaIYcCMjw56ioiJWrVpFff2D1NW9QE7OXDw8cqmunsrddz/FypViq8uioiJcXNRMmWJCLoepU8XadV5eLGfP3k2fPsdxcChHq01Aq92Ln18tN94oIpK3bCnBzi6ChoaGXqObQ4eqyM19k/r6sG7I1yepqRkHiHKcgOSsZ8yIw2BIoqioHXf3Qwwd+iN5ebdLlBxb21fp6KilpUWGIAiYTCYeeqiCb7+tJjx8KxMmPIPBADfcIPYIPnGipceCITERFi+WIwiDMJm+6gRPfcjixeWkpd2FRmOLIHzH8ePneOqpRPbv38+aNWtobGwEtuPufpRnn32W/Pwoli0DQRiFyTSO+PhKIiJUhIbaolQqqat7n0ceeZTMTAfkctdev4XuYinp6YEEBKzr/FUAZDQ2Ghg92pvdu1d0+TucPx/fQ9EMZAwd+hFmNYSmJvOZGmhvb0ChEBuENDeLTSk6OuQ9Utb/bouKimLVqr+ybt06SkqurvlBYiJs3BjbmRm6i1tvfZ1+/XJISfmAPXtuRy63lQB5trbTcXF5iy1bbsfbOxJBkOPqGs6QIUuxt3e75DlGjBjH8uXPdM5jrVc8vq7gxsmTDVx33U1kZtrS0dGGXG5PQ0MBDQ2F5OTsxGTqoLAwmYKCXbi4hBEcPJbAwHHXIuff2P7QDtkcbSkUOkaPtiErq/faEFyd4/4jWf/+Uzl7Np+MjBhuvjmTP/95HlrtGhISViIIeo4eVeDkZHH65vpzZGQFcjlERjZImtcAhYX3dEZRBioqRiIIBlJS5ERHi8cICgpi6lSTJICQmWmHvf0stm617tf75z/bcvz4N8ycaen+tGgRfPllHY6Ojj2ih8RErHo1g0V4Q3TGInq7K0UI9Bw+PBc3t5O4uo7FxWUixcXF9Ou3FUEwMXToR4SFqRg3DvLzjezd28gTTxjQaPwAX8rLo9HrYcqUZ1AoIDwc9Pp2jh5tslowdHeCavUcIiKOERAgdlTS6+Xk5/tLrRvNdcODBw8CSPKPq1dbH6e4eCGRkakYjbW0tWXT2goDB4JS6caZM71nEsSoSiEdJyqqGF/fcdjY2CCTCZSXN9PaeoZBg7Zy5sxJqqtHS/t217weODCRyEiR72w0is/JxUWkvDU3izXjqioxOi4vj6WtbQ5+fukYDFt6XVD9GoDSU0/Bjh0wdy68+GLP339p8wOLLKZYKz992oGAgATs7T2wt6/DYHhCooBNmqRFoXClrCyD0tJTyGQKHBy8KCjYiY/PcHx8onrtmfxrxmdZkMsBax1una6F/Py9VFZmdjrnAoqKjiKTpVBRkUJWViLOzoGMGHGrVHf+PQYt/0n7QztkM5Bo9GgBf/9qXFwcOHCgvcfHbnbcNjbtDBsmIyOj/ZKO+49mU6c+x5YtOhISPkMm07N9O4watVCasGUy645O5vpzXp6lW058fHyX+/hMF6dokro7daVj2diIHZ3U6qnU1p7Cz+9GutdTNZoxTJ0qNpswd35KTVVhY2PTa/TQs/FEGkaj6JQrKkZJnF7zOczbvvrqPKqrR/P886PorhDm7Z1O//4q5HLR2YotH6fQlT6VlzeXCROeoaMDiopEKpODg4L29nYpdTx1apSVE3ziifsJC5tMfPwMhgxppKXFsdc0akhICEFBQeTnR7FpkwjkMl+f0ajg0Ufv5uLFUezcWYSPz3Zksn8hl9vR0OCIu7sL5eXlHDx40GqCtURVis4yx1qr+3ju3Fluv302oaHN9OnzfqdDFp/NggWbkct/IC9vDAMHniYg4Dvq6nKlmrdeD2q16IA9PekUunBl374pNDVtld6LKVNKyMt7hS+/fA8HB19Gj/4TqamjWLxYLulKf/mlJTPzc/bUU/DSSwAmzpwRSE//hhUrDuDlNZRhw26QotNf0vygO395+nQ7/P2vo65Ojbf3e9x++wUKC6cybFgh06fraG4ehFI5AblcQWtrLVVVFykrO0NFRRqOjr7k5m7D3T2CiIg5eHkNtNKt/q2bM9jaOhERsYiIiEVWYiQtLRXU1eWQn78XW1slFRWpBAVN4+DBPN5//2s0Gu21oOUX2h9aOjM9PZ24uDiCgxsYPLgemQzS051Zv/6o1Yu9fft27r77bq67rp3g4CYKC104dszuiiQd/7/ZL1nh3nNPKR9/7NuJ1tZja7sXnW6OREPqTWzk8ceFTq4xbNsWKn28FlnIrjxdGVu3glq9vrMPcRQHD1qi2SeeMPRojLB+fSHfffe5lUykvf0NPPhgKP/85z97XG9e3mBWrQqWQGdAt/Sq6GRdXd/h+edju6B0xU5Lb71lWUR05SqPG/cCkyY9g04HFy7A/v3Po9dbJDXd3N7E3j4ZX9+pBAUl4eOjws5OjBBra6GgoA/33vs4ISGrSE7GqtZ/443vkpWlo2/fJIKCVPj6+jJ+/D2cO2cnyUQajQuoqtogXUtMzLuYTK4MHnyeujpbEhKel36bMSNOilY1GnEMBQWu1NTYY2/vcMUTbNdsktG4gMjI+1m9eniPd6ChQc3Bgy+xY8ePNDRUS4uS4mIf9PoqRo60R6sNJCXlIXS6P0klhP79t+HhUUhIyEGGDNmPk1Mfdu16gx07ZmE0ypHJ9EyY8Cnz52/AycmB4OCIHs61q40YAWfOWJ6bn99p7r13FKBEqfSkb99heHqGM378w7+o1apZAtP87MxgsfLyUxgMOsrKztDYWEZHRwtKpSvu7v3w8YkiMHACMplAcfFRCgrSqKy8iFyuxdXVEze3ILy8ounTZyTt7b5UVNT97Df7W1GcujrnsrJUGhpK0Wo1pKRcoKbGloaGYKqrmxEEoVeJ3D+iXakP/UM7ZBAnj3feeZ1x44rx8gJX1xAeeeSkFfTf7LjHjCnH31+LTgdJSX58882e39XL9kvT8hYKjii4MGfOUrKybKmrm84LL8zooXOcnp7OBx9EU14uRrmNjccwGFKlj9c8gSmVYpehmBizGEkcPj4F6PVvcvr0SolC9eCDIn/6qafyyMvLx87uC2xtbamq2kBX3rCLy8d4er4knaf79U6f/hbOzrHk5sJPP1lSu7a2+5DL1Tg5pfL000N6KI1Zrr87V1n875IlcRiNUFQkOt38/DGUlMzFyWkn5eUydLonpH2XLBGdoskkRoxZWbZkZfVl9eok8vODpcm0Nz1rkdJkR3l5O7W1UFYWwZkz62lrm44ZeT527HrmzHmYrKxY9u9/jqqqoZg506NGrWfq1Ieleq7JJC6YqqsdOH/eFZ3O/oon2K4Lu/z8qMs6gvT0dGJjpxMQoKGx0ZfmZgPNzc3Y29tjMBikRUXXLIg5yo+PX0RExNZOMRLLIm3x4jjCw0WKl6OjPa6uffDwGIinZz88PaOtnHPXCBkEJk16genTn+k2SlscHLwJCroOH5/hjB37p9+MHtTSUsGpUxvR63VUVJylrq4Yk6kFZ+dA/PyGceZMOZ9/fhAnp2Y8PGD8+Aj69LFBp2umtlZDWlo5JSUy6us9WLny4V6/2a4UJ4NB4NlnP2LatLpf3cJRo6nh/PkEUlK2cerULmxsnCgv96aiwo3y8vLfZdDyS+yaQ74KS09P58SJ9yku/hSQMWjQnSxf/pbVNuvXr+eDD15mypQKHB3ByWkkzz6b+t8Z8L/BzIsOJ6cmxo1rIyVFSUuLyxVPwH//eypvvHGKyZN/IjpaRUsLbNni1+sHuX37dp544kPOnftRmkCdnW8hIeGmS36827dv59575xMf37Xnsbjv1q0Wh61UtjJqlI6tW1+ksfHPdHWQ0dG3UV29h02bNhEUFMQNN8wkOroBnU7JmTNy2trkvP/++8jli62cnYfHnSxdattr1yWzJSbCe+81ceZMA1VVQdI5BcFAYKCKoqJF0vHCw7cSHb0JgC1bEum6aBg58i0mTXoYvV5U4Tp6FEymm2lu/kKip8XHL0Ktns/x43dKUWNU1HqmTHkYJycL7enEiZs5cOALq3HGx8cBbiQkfNZFSEVcDCxeHMfQoaITq6mxobW1AwcHOulejpw543zVE2x3RxAdfZApU3YwYsRRHB39mDHjRTw8wnssjlavXs3UqVOtsheCYMJkErpkT/SMHfs2c+b8DZnMnszMBajVY+nTJ5mwMBU6HVRUgL099O/vi0ymRaFQoFR64esbiZdXFGPH3o9aXcO993qQmenN2LG1PPDAi7S2VtLUVE5Z2QVMptouVyQgCE64uvZlwIB5DB9+G0eP5nD+fAZDhgxh8eLFV3xvejONpoa0tM8pKztNQ0MhdXUVXLxYQFOTLRUVgZSUaFEojLz++j3U1+ewb9/X2NkZ0eudycxUUl3t0Os3u3o1vP22heI0fvxGbrjhHdzd++HnN/RXU5xSUw/zyCMLASOtrYHXIuRudq25xFVYVFQUu3f3pahIi6urgQMH1qNWO/Pooy9I25hBE/v2PUBDwyFcXGqpqcnCyyvivzjy387M9fQZM2pxc4Nx4zSoVDZXrHu7fLk9X3zxCv37FyCXg0LBJakXQUFBFBUtsEIyt7SM4tChQ5ec7Nvb25kxQwT+9O+vYtKkOA4fnsbjj48lLu46tm8vwtu7gClTxMhywICdnDx5P2Znc911LzBmzOckJooAsiNH3mP+/AoA2tq0VFTA8eMy7rvvPu688wS+vjXAMIYP3095eRJ79rhdUoPbbLt2uSAIDp3/sjiOykqlVfo7NzeW3NyFhIdv7eIURdBYUFAyNjbidQoCtLTIsLWdaNXYQK2eTEiIipQUSw9hG5s09u/3ITy8EQeHdoqKYklLe5Ku8pkDBiQSEaFi9+53utx7A97eZ5kwYY0UUYItJpNOEuNobYUTJ1pxc3O7YrqROT165Ih4HQaDGWk9kfPnJ3dG9N9SXHycgIBRBAW5s3HjS1y4UI0gyCUgmkURTHQmXZ2xyaQgLOwMDg7BaLVNDBqkIiJiM83NBoxGUYNbq/Xh+HE9gwdPQalsQi5vwWBoorDwBHv2ePP00zuoqakiN/cxBEHPzp1+LFv2AB4e4WRkyBk3rh5v77eor88nP/8wGk0pJlMzDQ1ZnDypZv/+9Zw7p+fCBaislLFgwSI2b958RfeoN3Nw8OK661ZLgKrk5K9pacnF2dkINNLR4YVaXYNCMQpPzyGcPasiNNQBjcYOo9GFtraqXr/Z7hSnKVNM2Nt7UF19gfLyM50UpyN4eobj7BxKSMj4q0JRjxo1kcWLn+1cVFVfFRL9mlnsd++Qr6Qmmp6ezjvvbMTLy5lJkxqwsYG0tBf57ruBLFt2q7RdVFQU/v4b+fjjWbS21vDjj3dxyy3bL0tJ+P9iZvSzTCY6AycncHcXrngC7g7WsrWFBx64q9d7HhUVxbRpp/jhB0tzAC+vQ3zzzRluvvnmXvexs7OjsVFs/VdUNBVv7yScnP7OpEkJ0vinTLEgqmNiVNTWxiEIdyEIAn5+J0hJsfQ8fvHFEnJz3yQ4OIk+fcQU8e23Gzl+vJkffsggIGAqQUG7CA9XERpqz5YtdpddnCQlYbXACA7ehqNjPnCR6mojVVWzsaRcZZ20KFOncxGdjJ/fcUAEf7W1walTYiMFmewARuO9EjAoJOQggwadJj7+bi5cGExwcDJ9++4hOzuAEydkDB36DEePWhYj5v+OGPERYENQ0C6OHv2LNF69fg35+VBS8i+8ve2pq2vD23s7AwaoyMuDU6dkaLUCCxYsuCLZRUs6XYxorU2U+UxOfhagU/u6sPO3rzl3rp2aGgXPPbcMP7/bWbEinKlTgzudiYhWnjTpRTo6HAkJOUR0dDJyuTsuLu4YjR6YTK5UVaViby8itg2GKoYOhcTE7RQWKlEqldxzTwytrRPZtGmF1cLE/OzeeKOIzMyByGQG1q1z5/nnBxMR8TcKC+UEBu4iJOQrCgqO0N5ehiBAdLTYDevAASOJiYls2bLlV0fKZkCVThfC++8fwttbi07nSmVls9VCt6XFg3PnTLi7u1NfX3/F+u0LFqygunoimZk/YDQaaGgooKYmn7y8vdjY2FNScojc3KXk5Izj+uuDWbr057nHvxTpfc0s9rt2yFdaEzVHh35+Nuj1ojPx8IB3372b8vJ6q308PMIZPfpukpL+SW1tDidOfMLkyQ/9B6/q32Nmh3rs2CO4uOhQKOCGG3ytpCq702i626pVq1i7dgNNTemo1bHk5k4iPLz3uuHdd3vT3h7HxYt3YTIJhIZ2kJ5+afWjoKAgTp68jeLiTyVZTR+fFdLkExUVRXFxLLm5IqJ64EAVQ4fCli1iqjg3d6HUt7crxSk1dTWLF8cxaZIYHYaEzGH79s0Igp5Tp8TfsrL2YzKZaG9vv+T9M9OBLAApOfv2vUNbWxuOjkpWrNhGZeUCEhMtkpJ1dVtwdv6etrab0OvnUVk5ki1bEqUexWPGiDX28PAkOjriaGqK509/msywYS9QVFREdHQ7Tz99P3Z2jWRne0rNA7y9l0vgNEEw4Ot7lpiYNUREqLCxcSUwcAezZsVRXByDp2cyjY22pKV9j9lxi+O7l8WL4wgOVhEZaaK01JfZs2ezfft22tvbOXMmkOefH9XptOR8+62ldefGjeI9sXbG5sWIeI7KymEkJCR2qX1Da2sr/fqBTjeX6urPqK4WOzLFxz9BQsKjHD/uzsiRZdjbZ9LWVo+NjQP79t1KevpAQkP3M2zYYZyd3fDxGUBGRjYGA7i6QlAQ+Pm14OTkRXY2fPDBISZMeE1a4Ig64PIuCxSNxCMXBD1ffGHHxYtOnb8v4h//aOO221byySePU1t7FKVSzCQ4OsoxGo2cO3fuVztksw0ZMoy77368cx5r7BF5PvTQQ6xbt47y8vKfjUqtNQesZTktQLPTtLRUsW+fJ2+/fTcymZ6vv1awZs2X/O1vs3+23nw5pPc13eyft9+tQzZTlQTBwIABonrNpahK5ujQZKqgowPs7ESnHB3dwYcfvtRjn1Gj/kxm5lYqKzM5deotIiPn/C5S16tWrWLEiP7s2yemjRWKYjSaGjZu/KqL0AS4ubnx97//vdfFzY03fs7q1WtISNiCIOjZupVeUdZBQUGYTJCbKzrMvLyFVg62q5mzHL6+KygpsfT4jYy8X1Lv+vZbrZWT7ddvKw0NIurbDP4qKBDBZV15vWDg6NFnJdWtkyenW0W6+/fH0Nq6Azs7uO+++zhx4gQvv/xyjzFalMgaCAlRs3x5KA8+mNgjWhABa3JCQwvp1+8GgoKCeOUVP7780nLO0tIYOjpg27bETvGN1SxZEsfo0TeTl+fA7t0aysqgpKQv7u6r2LXLF5nMogJVUeGF0QhmreiYmHWMGJFLW5snHR1iPXTQIBWtrZCXN5XKSosQiplqJgh6SkpiGDhQxaRJJqCcb7+9npQUGaWlAkbjVsDY6fT1vPPOdzQ2foKNjZLq6vVA1+9BdMaTJomCL5WVw6RzqNUxBARYeMgApaXWLQlzcrwpKhrNuHEjcXHxZ/z4V3BxCSAxETZsEI9/7Nh9GI3LiYjYhY2NHHd3KC+H2lpbGht1mExgMGhxd+9DeXk5oaFFGI0+mIGIgwe/giDYEBqajKMjZGdbFN8qKwdjbt4hCHq2by/H3v5vgB2FhWLNvqoK1GoDMpmCIUOGXP5Du0q7XOT5W0WlZlWyyMjr0ela+OGHCqsWmbt21ePkdB3u7iEMHLgAW9uRVFU1XfE5u+tmP/fcJ0yeXHpZbvUf0X63Dtkc9Q4aZE9YWClyuScXLvQegZmjwzfeeBZv7zacnMTJwdERJk+uJCfnlNU+Dg5eLF36GZ9+Oofm5jq++WYZt9664xdRIv7XbOLEueTkxFBUlEx6+gSuv/40J0+eAcRGC8XFcOxYLa+++mqvixs/v2G0t1ukL7vzkM0WFRVFXd1DVhOv2cF2ta5Zjra2pzCZJmJ2GuPHD5d+r6x8HEEYJtVpzZrWYNbqluPklEp6ur3E6zWniquqhrF5cyLBwYsQhDPSeEwmBZMnJ+Pnp2fvXj1FRRpef/11qqqqWLJkSY/JSK1ez+HD69izp40vvug9IxMWlo5CYZ48xYXPsmXwxRcWbvONNy7ixRcdrO5Nfn4M0dEqWls1+PmBtzfU108mJeUJRId3F3Pm3ExGhpoPJEVNMy9byY03foSTkx+ff/5nsrJ2U1kZy5EjiXRFLlvqs6Lz6dcvGfvOEqJWK0aabm5GTpyI5fTp+dI1iRKnWyktPQzY0L//P0hJ+Uo6to/PCSZOfIn+/VX07XvCCg3dt28yCoUIHDMaoaMDAgKSOHPG8g75+SWj0eSRlVWKnZ0DBQUHCAwcx2uvPQqESOM/ffoWhgzZg06nwdERQkOhttaOgwd1ODlBY+M8WlrGY2+fwvLl9owaBWvXnicz8z1qa7fh5iZjzJgwBg0Kwdf3afbsmUxm5iwaG0Mwp/5FTfBkNJoyQKRMtbaKi3g7OwgLm33Z6PiXRomXizz/HfzjJUvC+ewzpCxCUFASzc15NDcXUlR0mOJiLSUlMjQaNxYvfpTVqx+77DG762bv29eOm9snErfaxSUQGxtnK5GRP6L9bh2yOep1c6tCqWxlwAANFRU+l6yJrlq1isDAQD766Abc3Tuk1XpFRSxvv22PXm9JyQF4eUUwY8Y/2LbtrzQ0lLBmzafodA8zc6b9//t0zPz5b/PXv75AQkJC56Q4i5iYWry9VXh7ixPn2bOaS6aXb7xxGFu2KKS06aVaOj7xxDSJLmQyKYiO9rb6vbuS2qFDdnRNqxYX1/PTT48yf347J05s48SJP9G1TiuTGZg8uRXIIzPzPTZs2CY5yq1bV/Hcc3LOnjVK4iPDh6/l+edbyc+HRx7ZS0uLOxcu3I1CAUuXqtixw0Rmpp5PPvmErVu34uLiwtixd6FWOxMSsg93dxUxMZCf34/CQgMvvniekydrWLbMi7i4S5dQLPU9eSdXNYzz5/uycaMlwh8+PJC+fe8hOXkjDg7Q3OyAWm3uBiI6pJ071+Djk0F3kZS8vAg2bboO8MbNbQCnTrlTWPiM1b6OjuUEBp4hKKgCW1t/brxxOHFxH/L113+hrGwH7e1tqNWiyEpXaVEzWAzgq69+BGDEiE1MmvQihw49BRioqhpHY6OMwkJwdlYRHx+HWh1DSEgygYFiutrYKW9dUBBLWdlURo9+gfZ2B4zGZCoqVGRkyBg8OBBB0FFTk0NDg5r6+sWIDlk0QTCi0zUASE7exkZLUJCMEyfm09Eh6kY3Nd3NoUOnWLFCS1zccNLTH6SoaLHVAmvu3BrKywvJyuo99d/aanlPXVxgyBARRObunsmePU/i7Dydurr2HtkRMUoUxUu2bLH0Bf9fS+d21eZ17UUAAQAASURBVLkfO7Yed/d+FBZOpLJSTWNjMR4e4OFhpL6+kSNH1hAUVMukSbf3ECsxW3dQ2fTpdgQHT6Gq6gKFhYcwGnXY2rpRWpqCr++IP6w05++a9rR+/Xr+9a9/MnFiOY6O4OY2hKeeOn7Zh/zaa38nL+95XFxENOyWLYlSerN76lWnayEx8S9s2dLBV199JSFhe0vR/q/apUBvd9yRx2efBUsSkUOGrGfevIcBUbBi61Yf9u3bd9l6UXchi97O+8EHRhITF1iJiISFib+p1Wo2bvwLM2ZASwukpt7GyZOfSs5g/PhXGDLkcdzcxLThzp2xnD9/N2BJN65fX8jGjaMYObIJtboPajWAjMTERPLzo6QJ0mCwPLeerQ1h8eI4iUqj0YBaLSMz8zbKyz+WzmWu/dbUKDhw4C/k56+z4gm7uKjo6ICaGjeyshzR620vSwt5++1C9u83Mm2ajJUrg3n77UKefnof9vZHCQs7Tlram50dpszW1RFbbMmSOPr3V0nR7qlTsahUid22Evc113SdnYNpbvZm27aL5OQY0Wqn0d7ePaIWr23SpDc5dOivVkcbMGArOTnzpQh/6ND1REQ8TG0tLFy4FD8/O9LT99PYWI5CIT6/s2dj2b/fEj0vXBhHnz4qKiqUnD/vBch4++3H0OlOU1ubx6FDYXzyyUZpTIsXi9fp0Al0NztNjQZOnNjEqVO3SSnY667bRHz8JwQHRzN58pO4uYX0uG+WRhqiUzbfG/Nxzc0wbG2t95PLbSgvh5ISgZISb+6//1GmTZvG0087olIFYzSKi8V58/Zw773byMxcwKOPzpHew671+P81+/HHL/jwwzvx9xd59gqFCZPJQGhoKCEhQ/HyGkK/flN7daa9CaTk5++lqiqL9vYGysrE+rUgGHF27ouX1yC8vaOJilr8/x44e432hKW+cuDA09TU7MHFpYm8vCQGDpx7yX0eeeQfbN1qz9mzz1NePlUCd/SWerW1dWLOnFf48MPDktOWy8WX7v+DQ74c6G3RohA+/VQupVGDgpKl/RwcYPHihZdNk12uaUXX82q1FqUomczI2rVpFBYuoa2tDblczrJlFtS3m9tWfHxWMHv2y2g029my5Ul8fWNJTRWBXGVlKm64QYVOF8uJE9Po6Migrq6S2bNrALC1LaSuLpyioloOHjzI/fdH9drtSkRMiwphohlJS7tL6vbUr5+K2tr5dHSstELn5uXFoFSq2LFDj1Y72CrlrFbHEBMjdjRyd28EnH+2hd/KlcGYmVaJiXRycW+jqekulMqtBAcfJytrJhYes0xSsjIaxQhxyJCP8PVVdXZRgosXYzl+/Dm6t4ns3jO5ubmQtLQhaLU34e+fRFaWdTTu55dC375H6d8/ldraRXRfDLS0+Fql/kNDkwkMhL59QaM5g8EwipCQO/jy/9g77/CoyuyPf6YkmfTe26QSIECA0FtCk2ICEQRUEMW2qwIirgVxLWDZomLsUhQRpEMSeksglJAQagKB9N57mZQpvz9uZiYDBNHV1fXHeZ59ViZz733ve++85z3nfM/3u/F9NBo61anC0WYEtDXsgIA4PDwUiERNJCdL0Wi8mTbtr7S21tG37zbMzN4iMdEKb+8EfHziqKgQUseuriaYm3cAaszNRchk5V0AXFLs7PZSWJhETc0lSkrO4+k59BbCEG2UeOhQC/b2W+jRAzIznYAKxJ23qlRCZaUQkYtEQs+zkVEH9vZgZSXFw6OSXbuW8vHHdtTVTUKtXq9bU2xsviMt7QgHDgxGLFaiUgm0pmvXHsLU9BgmJrb06TMLJ6fet406fw/z9w8hI8OT69dVeHnJaGmpwcamnUGDetLQUEFdXRylpck4OPQhKGiKgWO+eU3QU3NiICdZVXWDqqprZGcfo6LiEkVFJ3FwCP5/kc7+Yzzl39CCg4Px8vqMjRunUVubz6lT/8DTc9AdH+zkyYtQKC6SkRFPUtIS3Q/odqlXCwsXFiwI4/Bhqa5G0l2K9o9kPyWsMX26xEAu0ds7TndsQUEEHR3ziY39+RsP7XXNzRsZO7aVw4cTqKt7UpdduHr1C5ydGxg/XiAnkUr1vNWlpVdYvrwv4eFljB//Mj16TGXXLj2QKzQ0Eh+fOCAOf/84Nmxw4dKlQRQWfoSnZzyWlnGkpWUDYt577z2USqUuZdx1fJaWrWg0oV1GLSYnZzq5ucJ1QkJWcvGiIIChRyVL8fRM4OJFMbW1YGmZiEbzlG6jJpcnUFMj1LZzcibR2pqCqelxvLy87qo1ryvXNkB+fgQwjVGjVlJeHsyNG3rikd6919Gjh/C8VCqhherKFWhs1NaNVQjO89ZoVy5PAODKlQjd3Go0S5DJztLaqh+PtXUZERFCxuTo0V7cHJmbmZUxY0YkBQVheHkloFbDkSMfIZfHU1wsYufOYXh6nsXKSkRZmSmVlSLKy+OBJWidsptbAiIRFBdHkJsbTkBAAs3Nh2lpGYyZmQOhoU9RVrabU6cexdzciGvX3KiqsqeyspAXXxyCuXk7tbWFnD8/gMTE13RZmP79V+LuHkduLtjaKoBs6uvzMDU9Qn7+YXx8JukUlgQnYgk8CTzJxYvneP75CQQGCu2R7e0C1kQshvp6KdXVSqRSoUtDKlVjZqbExwccHOq4etWMtrbDiMVqnn46i7AwGxSKsQQFpZGQINWtM7a2P5CaegALCwfy8xNwdR2Ao2O/n1R9+m+YFm+zatUqMjIaMDW1ZO7cJcydO4+MjN0UFiZTWZlOYWECNTVpuLoOw88vnNpaGSUlFd2+413lJLWRc2VlJlVVVykvT6OyMo2ysnPI5eN1EfOfUcjiT++QAaysPBg48CmOHHmbysprJCZ+xIQJ73S76zQ2tmDKlI+orJwACPWugIDLjBy5HPC/5ftz5jhgZnarUPsf2fTCGs0EBTUiRGzmBhGbsBg5EB3dh+xs4bjMzIhOdik1e/bcHkH9U9c1Myti8uQOACZM2MaOHRLCwt6iT59qVq/ew9ChenKSzMwIYmL0aUxvbygo2IerazkSiSEaV6MJIzMT8vLCaW+Pp73dnl27vtU57JCQSF58MY7qahWpqbei7rtG7k5O9+Pk9Cq+vn5oNLB3rx5xevWq3vmBCgeHiwwY8DbFxRZUV/+badPi6ddvAxcuQELCUESis5w9m4az83skJb3WeeyzzJkznR07xnL8eCOZmRYYGVl225on1OC0alP6XuaODjMeeCCqc9MShlicQHFxHG5uQsQmFgtiHL16wf794wzG7eR0keHD36apCVSqufTtm4Wt7V4A8vMN59bVtZTcXHTX799/HQAZGRGd6lyG1q/fOgIC4ggIiNO9MyKRkgsX9PKVSUmLiYpqIjg4DicnEIvjqKh4kODgxbz8cgjXr0s5eHA6iYm7dBsDF5dZ1NVF4e8/mSFDnqajQ0NZmRmVlRKcnZ2pra1FJLIlPPzfBAbKuXFjPz/+6IsWcS4SKRGLzRCLhcg2IcGYt98Ow9JSSW1tAcXFqVRWZpCbe0DnmLOyinQLf0hIKLNmvc2qVavo6GjE3b0RW9t2HB01WFoqcXOzp6SkgaoqDVVVXojFRZiZtdPQMIWrV7/Uzam5uTWRkc+hVLYyeHAS7u4bOXvWHienPXh5HQbENDc30tR0iZqabKytz5KbexB7+yCCg2f+rlFzd8jukJDH6NVrJjk5R8jKOkJ1dSb5+cdITNxKamoeFy+aIJXeXu+7q3WNnFtaqrh8eSMFBaepqcmnufkHiotPk57exHffnaKxseNPJWTx/8IhA/TtO4dr12LIz0/m2rWt9Ow5FS+vEd1+38rKg4ce2kVLS7iuT3LDhvM88cQhLCxuFRD/T3SFfw/Tgt7c3AQZRDe3RkxNHW4LeuvaX3zmzOudnwoR0dq1P+++BfWiDp18YkWFCFvbRFasaAZk/PCDKTY2Qpraxgbi4iZ2SWkrSUiQsmCBFxMmwMmTzV1adaSIRC1dKDWX4O19idpafZtUU9MC4uOF9Pbw4YcNyD6OHNlIRsZipk0TIsozZ3bS2HiUd98Vas1xcZLOMUuZP9+J1au7IrHTOXJkIvX1zyMSqdi1awlicSSBgRvw9NzA0aPWKBS2XL3qfFMaezSenjEMHAhNTXO4fn0k776bxNixabfs+LXp07VrxcTG6tGvcnkCKhX4+QnOT6USRCF27xaYo3x9TQgMVKBSgVRqiCAfPPhtAgLiOiO8o6jVply6JObCBbCzi0ej0SOdBwxYR0jIOvLyhN7lvn0vIhYHkJc3DsN0tQY/vxi8vOIoLBTKG3l54V02AgJ6S/tMTp16kxEjwN8/Dnt7SE09SX6+DTExQTz44E4yMqo4dUrfL5yQ8ArwNiUlb3DixJckJtbR0aGksnISlZXjsbW9yPLlfXXzl5PzIKmp+nnUaITyi4UFeHtDe3s7Dg7TmD59JllZh7h6NYbS0ksUF5+nujqLAwc+Z+/eYoqKRJiYmOsW/q4OSa1Wcv36KVpbz9HWlo1Mdo3i4lrU6hzS0wXBDEvL0QbP/syZYg4dehVX18H06DGR5cvDUCpbKSyUkZtrS0nJBcrLc2lvLweMaGqqob6+lNLSi2RkHEUkcqV370cYPTryd3HM3SG7tc7U13c8eXkJpKRsJy8vEXt7EUOHmpOaqvpZSnlmZg4MHbqYvn0f4cqVzZSUpJKbe56srDRCQqRUVbmSn9/xp1Hf+3/jkGUyG6ZN+5INGyJoaChj796FPPJI7B1blRwcgoiM/JytWx8hI2MCeXnh5OV9xfvvv/C7p47+U9OmnjIzBWYtKyt4+umZ3b7QQn/xO5SUDPmPr+vgYEprq4KsrAguXAhn8uQAA6KDoqLFujR1375DOHRILxkYFqYlAZnOmTPayEwgoGhoeKqL81ZjaRmgo6XUaCS6nudz55bg4TELU9Nzug3I2rVbdMxdvr5xDBumICbGmIKCAiIjtbVmLSDFCY0mjq1bKxCLT5CYaEx9/Wr0Pbwq8vLC8PePw9QU+vWr5+JFV8Ti42g0C7qkh8+gUAjI4pSUb3UI4HffjWT+/F6Ehb1qEJ1FRgbrQGfaurev73vMnp1Cjx5lmJlBeXkEhYXh2NmdoqxsN2VlRmRl3YeR0UTc3a/j5PQUzc2DmDLFjCFD+mJu3o5SWUV19Q0aG6vx9QVHR2M2bowD3kUimUS/fvtxdY3r5IQWWM06OqzRaCxQq08Ai7s8YREhIeswMgInJ0FO0df3Eqmp0i5OWd9iVVERwq5dsURFRSKXx2FrO5wLF1azaZOaH36AZcuEnmqxWINabUgo4ukZR//+oFY/QHz8DjQaJRUVUtzcFLrRdG23ATV+frE6ilBnZ7C0hPz8jzlxIouhQ5/H338i33xzhYSEFhwcYjE2jqZPHyOcnR25elVpsPB3/a307RuCWq2ksvIaly//QErKQTSaSwwbJsHKyprU1OMGGxw3t51cupRAVtYBrl/fga2tH0OGPIuPTxg+PmE6TuucnHjq60tobW1CKlVSX19PcXEWYjGcO7eHkyfDefrpD7tFN/9eZmxsQWDg/Vy/3kZa2k58fExoajLGw8OMGzfq7pqSV2tmZg4MGfI8LS1VbN68nLq6S9jaSjA2rkOlcvxF5/wj2h/nCf4XzMZGzqRJ/yAm5q/U15ewc+d8Zs7ceNuIV2sBAVNQq79g8+bHO9NsUs6cucYrr5gRFWXc7XH/C7Zo0SLWrz9PXt56AGxtT3X7XReXEDo6XuZmRaMnnuj2kG7twQd/ZMWKtbo05urVUu6/X4gCFy1axEMPnWDHju26xWvWrExMTGyZOdNBF41LJB+gByQBaFAqndFotAuwGB8fM9LS9FzOgC5CqakZywcfjNKpS3UlFbnvvkhKS08hkUjIy8vrFN4QnOHy5at5//0mHB3jefjhOKqrTThyJNpgXjQaCXV1fty4EYGXVxxxcREolZORyc7w6qtnaGsbho9PPhJJOB9+mIBGc98tALCzZ1/i7NmvOXBgNFev3odMtovXX++jS8tpeyOCg4MZPvwbfvyxjJaWCjSa13UZgkmTIrGx6cHmzf+irU1JTo4UN7cFvP9+GwsXPg0Izv3oUSUSyTZKSx/BwUGDRKKkR48HOX/+dZRKJampA1Eqk3F2PoOjYx02NkrMzetpaKhn4MBriMWzKSx8CGNjCAlZp3PaJiaCDrS5+VZcXFy5cKEvYvGPWFpCSsqbVFSEoFWaKiwUSEjq60d2AVIqOX16O4sXt3Pw4AyuXzc1IBTx8hIca0PDSIP5+/rrOCwtzzN8+AuEh7t0od0UExCwjowMobXKy0sA6LW0pHHhQg3FxckUFMzn739/pPMdGseIEQX07LkHO7sW5HIH0tObul34xWKB/WrcuHepq/MiKelFqqtnUFo6EVfXZOrqHiY09AUmTy4hONiW2toBVFXlkp2dgKnpOYqLk3FzG6RLSQ8btoR+/eZx+fJG8vNPUlh4jcLC/E4SFWPE4nYKCg6zc+fzBASMxcioL42NYry9ff4wjsnHpwfV1Q7U1Kjw8DCjqKilW3rPuzEzMwcGD36ef/xjL56ezajVNv/xOf9I9v/KIQP4+Iylf//5pKSsprw8nbffXk9r6+Ju+4elUhk1NQ91odmDs2d78MAD/1vtTd3Zgw/+m08+iaO9vYaEBBdSUkqJjHS97X3NmRPMjh167uVly4T7/7ngil69plFZ2doteYhK9ZrBArtnzzGcnf9BaOgLgOCQZs3qwcaNXc8qYs4cGDJEX8sHiIvTczmDHry0aFE/Fi4cBhgCpkQiJYmJU5HJTiEStbJixQpdjUouX8S77z6lc3jaNqdevU5y6tTTBtfJyZlKdvY0+vdfSXPzckQiJW1tf+XSpUgCAvaya5cpN26YUV8/kbY2X4NUsgCs0nDp0iiSkmI6I2cpn3zyMCLRtE60tZJVq6RMm7aFmJjZiMVaVLge9V1XF0ZdndhgLr28+tPYuIH33x/KmTODiIsDiUSMSvUQzs7HcHGJJTAQcnPHo2WxEomUSKUC4rmkRESPHs9hY5PFyZPGVFWF4+5+EkfHRZw500xOTiMODgLq2EJHvqTA3v4D+veHkhLhf87OUFGhxwZogV9eXvGkpuqBlLa2m9Bo4nB23k5Ghr4FUS4/oduUdD1Go5Fib7+F5ORjXLiwAxeXwfz44yckJzsQFgY7d85i/fq5aKlRhVamPbS0VJGXl8SxY7MNEM9lZaOQyWJQq00oKGi7q4VfLJbSs+cYUlLmUVa2pnNcjzFo0Axef/0C4eHzkUqn09pax9WrO6mpyaSoKIWqqlxqarIpLDyFu/twAgLG4+k5VJey3bhxCU1NV7G0NEahkNHaaoNaXU1NTSknT35DVlYlxcUSiorsef75l/4QNdWuILAbN+p+FdGJ4OBgnnvub514j+Y/lZDFn7oPuTtrba1j794XiI2F77//Ttdn2J2DvR1ZvlisZvFiMR999F8e/G9gqalr+Pe/Y9m8ufuea63d3Ev4SzWUv/8+n/nzvW8797t2tfPAA8a6BXbKlBmUlByjvt7WoG83NhbefReqqmDOHOG/bzat1q12E2FhcYCHHlLyzTf3G9xT137kwMAYevZci4dHHBkZduTlmaNWSxkxIplNm2x0jrtPn2h69FjG5ct2tLY+S1vbZMRiJaWlA3UO0MnpEhUV/XT/Dg2NJixsKWo1JCbOJzn5uy413Wxef92P4cMz+PzzGWzb9iRXry7UHTtgQDRGRlacPfuY7jNn50uUl2vPb8jJPGdOJMXFg0lMXK7724wZwmdJScu5GWXt63uI6uo84KxOT1qb7tVzThthbe1NfPxHxMZG6M7r7T0XhcIUL6/5FBSsx8RkF717t2NjM528vAG4uh4jMFDo466qgj17BNS3s/M4AgOP4ewsJS9vJG5u8YhEdEbACV0UqODatQgaGmbRv382wcHHKC5OpbGxGbFY4AwoLQ1DLj9FUNBO6uoEQJtaDTY2ngwd+iDDhi3hzTc9dDKEIpFWvvFlhM2HhIyMB9i8eatuDqdPj8TBIY7SUmhuFhMR8TYvvngriO12FhZ2gePH+6Dd1AwZ8iVz567B2TkYB4e+DB78hK7bo6mpjHPnvqGwMIn6+mJEIjXm5o44Ow9i4MBHcXDoQVpaGvPmTcHRUYFabU9+fgcSiYaXX57GoUPfYGbWgURizo0bMoqLLf9Q0oe/BSL6fwllfa8P+Q4mk9kwefK/WbPmdJf+4dtTPEJXQI2oC6BG/D/R3nQ31q/fXOrr3bukClVs315LZOStrWFdwWvaFiZT02ZGjWrn3Dn1XYMrHn3UGxubruxU+r9FRRnzxhvn+PTTM4SHHyYgIA4fH9ixQ3YbFLh+LPv23frjbGnRU2eKxSqiokL55hvD+7oZMJWZOZUbN6YxY0YkISFxgB3p6U34+OShVofqoumysmsUF1ugVI6nvl7v9EAfiXt776e8fKDu305OCbS0CKC1pqZQg+hVLI4hK2s9Fy5YsH59JYWFhsAquVyQZkxKehIBNSxFLt9PWZn+/MOGraS93Qx39wTAvRMBLYxr6NCVqNV0OmMNXdm8NBop2dlTdAjwN988xIABQrZhyJBabGx6cO1aDvX1uZw925vY2Ai61sxFoplUVEynqkqFWj2SmTMXUVXlzebNVp3nfIHJkyPx9xecspcXXL68B6UyGX//NaxerZXjFAQ9xo4VNi1NTYJTlUrB2zsOR8f9mJjYY2IykJEjXyM7O4nS0ov063eMAQOOoVKpqKvT03C2t4NaXcj58xsoLDyLg8MSVKoZOsaoXr0y0ZdgJAQF7WbOnGnk5Y3B0VHQVdZohNYmpVKNsfEeEhKMDJxpd/bii/05flyffRk0qASFop6srIOUlKRSXHwSZ+cQXYo6LOzvOlRxcXEKFRU3KCiIp77+Bs7OAxky5C9MmTKfb7/9FpWqHktLSxYuXIKbmx9nzmymXz9T1Gpoa7NBoaj8Q9VUf216z9/qnL+3/b90yCDUIh57bBQHDkh1kdGdHKx28e8KqPlfT1drTSqVMX/+UPbv1/dCHjz4GtHRfe4Y7Wpbp0aNqsDZGUJD4dAhl7teCO6ETJ81S0ZR0SKcnYVWq5yccNTqq7dNF3YXpWt7itXq0E6EtISZM2+/iEZG3iqhmJUVRl3dKZ2Kkpb/+L338qmtzaB373IyM2vJyhqO1ulp69q+vnvo3XsdKSlxDB+eTHV1GMbGaSQl2XLo0EcMHHgKieTKLanqxsbLNDfDffdBfPxJMjOnIxKNJjj4FH36JJKRMdZg3CYmyUycGElDQxiuroYR5bFjHxncT0eHWSfi2XCs/v6xNDW5UlY2SIeE/vHHFuzsQnn55TVUVUkpKAhn9OgZSCQ3WLpUxs01c6lUpHt3QMX27X0QifR1e1CTkbEAI6M4qqogIwPs7Oz48ssvOXHifl1JSCRSkp8fhlwuOG4t4UZ2NpSVQVCQEhubctraTtDQUISr6wA8PV8mM3MXCkUJKlUpRkatdHRAbi4UFwuKTyYmHUgkhZibv8ySJdepqnqQ/v3VeHuHUldXRmtrKTU1WahUdQQF7cHTM5bWVoGwpL1dGIOZGVRXZ3D58jqKio7Tp8/j9Ow5uVthhJspUcePX8qFCw5UVKRTVZVJWdk1KiszKCw8iYvLAPr3fxQnp94MHbqY1tY6MjJ2k5t7nMrKGzQ3H+DkyZ2cPFmARqNCIjFh1qxZLFy4kLS0NIyMLElP/2kZxnv2x7b/lynrrvZTFI//XywtLY1x4z6htXUIDg5pqNUxiESiO6a9BLBTJFFRuRgbCwvXrl0+v1qq7O23vbhyJaRLK9OtqfS0tDQWLepDaKhAfpGV5YFKZcTs2bPZsmULCoUCtfp+evV6liVL+t/xGeupEgXH4uT0FGLxHkxNTRky5GHy8uwxMmruTAEL44mKiqS5GQ4dMqSi9PffTZ8+68jMDCcjIx6Vag8WFg/T2PiD7tjx4yMpKoLCwol4ex8lPHy3jvYRoKrKmjNnXCkvL2flypU8++yzRESksXdvkEEa28pqKWPGRJKXF4uJCSgUEszNoaBgCnv36ufOzy8GR8crnRGy4FBHjVqJk1MyO3bcTKWJDsl89SpcuWKHRGLNCy+8gLv7U8ycaao7x7BhK3F1TWbnztguGwB9tqCrRUZG4ugYR04O3H//Cl58cfktFJXTpwuRdEeHwIQFwv83NUFJiQ8iUQ0eHk0EBDigUikoKWkhL09ETY0V48c7U119VUfHmZ0Np06Bm5sDr78+EoWiiI6OJurrG8jIqOHMGVPEYhuee+5xhg41IzNzH/n5KTQ3NwLCO335Mpw+Db162fD88xNoby9EoajExMQSF5d+9Os3D2/vEXfNu6xFY1+9up2iohSqqwsQi5XY2Mhxdu7HiBFLdEBTrWNOTt7MmTOHAGOKitzJylIb/D5v3pQuWbKEhVqat3v2u9vd+tD/9w75f8l+y5rJvn37eOKJJ+jZU0q/fqVcuuTKtWtK1q5dy5QpU7o9Ljo6mvz8xRgbCwugufkTvPnmmru+7p3uqaTkHDNmnOTs2efRaARa0kWLMKjbf/75Ao4eraKwUOgvViiukJLSSEBANaNGCRHO2bMONDffXU2t6wZNy6mdnd1bB6S6uVYbGhqNh0dCJ1mK3szMSmhpcdMdY2oaiYfHM2Rl3adzpkOGRDNq1FJqaiA5+Uny84cikyUwaNA2rK07KCjwp6io3WDh/fTTfIOxaIFl5ubOHD/eQHu7KWq1OXl5LVhYNOPlNYHs7AXk5enJTIYOXUlHhxkBAWcJCtpPXNzbnD+/UNfTDSLdvY0btxSVChoaIDHRifp6I5YtW4ZKNZWDB+uor3+DoUPjEImEOm5BQRhmZi0GmxZtrVq7gYiIWIpEYoOLS0/693+OPn2mceCABceOKWlryyYj4yIuLjEEBW3nxo0ocnJGYmd3GLk8jvp6e7KzXSkuLuXZZ0dw40YcpqYawJiMDAvy8y0ZMsQNheIM5uZC6rqkxIaMDBmrV39J7942HDv2EcnJcYjF0NJiw6lTlqjVUmJjY/H39+DHH98gPv4z7O2FjUBNDZw/D2PGPM6zzy4iI+ME9fX7aG+vRq1uwczMFg+PkYwa9RI5OWU/6zeqbW8qKDhNdXUBIlE7trY++PtHEBwcpWt7y8y8xMGD72BubkZ1tQN1deaUlpYa/D7/l2qq/9/sXg35T2a/FDx1t6YlCgkOzkUmg9DQIioqnGlra2Pfvn3d/sgXLVrErl01XL78NhkZEeTl9UEuz2H+fN//+J7c3EKZN09DUtKtZQXt4nPyZI0Bfaar6wLk8m9xdY3QkYAMGRLP3r3Su0qlG6bRhRrVkiVdaSsNgVO2tgmcO3dr71dLixDh6KUlw7C0/JrMzKm6Y11dEwCoqYngypXVuj5kpdKbM2c2oVA0GCBIX38d9u/3Ri4vpry8kt699+DjIxB7QDljxpiQlVVDTEwNLS0SmpvNaWg4gVQ6ma4c0WCmo70EC0xNtbVqbVSr0iGftdt1KysID6/g/Hl4++1XMDf/N7NmzWLr1jRiYtyxtQ2npWUAvr7xDBiwF3f3ZPLywoAWkpL0zllLzalS1VFcnExVVQ4ZGdsYM+Y18vIcWby4B2KxP2r1bKZOncTevY92HruQiIhIysosuHFjLBLJKQoKTDlwwIIRI8xoaxNRWDiT0tI+WFp6cOrUAtzcGrGyMqW4WIapqTFyuT8+PsE4OVVz8eIxgoLENDUZIZebGLQzDRr0DB98sBu5vAEPj2YsLFSMHg22tud58sn7KC4GMzMZTz4Zho+PgqqqXPLzj3P27F6OHCkhJ0eCsbHFXf1GzcwcGDZsCf37P87VqzvJyIilvr6U8+e/ZP/+L4mLy6e4GEQiI9rbTXFzkyGVmt42Lf1nrKn+f7N7EfL/gGlTw2ZmTQwe3EZysgktLRa/KDV8p110dHQ0Fy68gIuLBpUKWlrM2LfP+Sc3AWq1khdeeItPP13ZbWq5u3uSy3MJDYVz5yAv7/bp7jshu6XSlyku1iORLS3XM2HCHnbs2KUbi5fXXCSS0784lX5zStXe/mMcHU2oqDhGQ0MMIlEsHR1dBUu69kcL0aE2kr1+PYIrV+5DoTiPpeUuBg1q4PjxHRQXC/rN2sh52rTv8fVdwIULg7h2zQWFwpZDh2y6nFtIF7/88noGDNhHbu4p2tqKaWoSgGxnznhTWyuiqmo4HR2P0tZ2H9o2Jj1iWlBEamuDM2dmU1ExGFfXFpRKM7y9EwgIEL6j1SpWqYTvFhTYk5ZmAYiZPXs269ZVUVGxWjffjz/+HHL5Rpqb69FoBEGL4mJBblF7TpVKmJ32djA1laJSmbNlyzsUFDyLgEpWYWZWS0uLrW4D5Oe3R0fuotFIsbSci0KxBSsrK4yMPqC8/CndvMyfv5ETJ964bQpX++6JxUrkchPy8tp0EfLNNKpqdR3Dh7fi7W1JdXUFSqUxFRXOXLsmQqORsHXr90ilWZw58x3nzx9HrTaiqsqJtDQJGo3kZ79zLS1VnDr1IVevHuXKlXN0dBjR2GjLlStG1NQI/bYqlepeWvp/zO5FyH8i04KnwsIacXBoZfx4iI1t/9koyp+KSBctWkRCgjfHj0/v/KQFT898BgyAU6dMu0VQi8VSOjpe0kWRd0Ks33xPoaEC4jg0FK5du7360c1o6t27FzNzJpSXQ3y8IR3ks8/2Ijd3sAGYqa4unJUrhxic9+ek97qCcxob4zh69FPq6hRYW5vy9NMvYWTkyIoVoG8jEumu7+KSjLl5uU7vVy6Pw9V1L1lZvqSnm1BV9QnFxXqtR20U2dZ2iV27TrB586IuqV+tMxYQwSKRkhMnqgkIKGbOnB/Yu/dfVFbuQywGK6uRZGc/SVNTGCKR4P1Gjarl6afbEIlUZGVZAQ0AFBZGUFs7Co3mMtnZaxk1SoVcrneaWpNIBKnBtrYajIyMqK7uYNSoURQVDWbTJn0fd1ZWPwIDj1NaWo9YDJ6ecdTU6B2xRIJOb9zYGFpalLS31xMUdISCgkVosxDNzbZ0Fe8Qi0UGz9XNLZT6+l1UVIxGrX6qy7yoyM/vYMWKsZibh+HvH2LwjLv2xqanN922j7UrPaaLix1Xr+5l584PsLMTYWnZgoeHwA5VUdHAlCmPkZcnpbw8CSsrIyQSFR4elr+YkSo8/E2qq205evQSTk4ibGwU+PubcvGiMcuWLUMul99LS/9J7Z5D/h8wbTq5qqoBBwdhEQsNrf9ZKEpti5KFhVZJ6fb8r2Fh08jOHklR0UmysiJobg6nsDCesLA4Nm9u6HaBmTzZhq++0rNk/VRLmPaeQK/mJJFc/sl7KigoIDQUcnKEY/z9U6iqmo1IFI6x8Rm2bElk3LhP0Gj66DYIK1eOZ+FCb905bt6YzJo1i9GjR99xkdNvCiJIS/O5xZmHhgroex+ffF5+eTttbWHY22dRVjYbkUhJdvY0bGwiCQiA0tIpKJUpmJrG4+Q0Wxd5g5revY8TEnKe1lbIzBxxSx22a4Ssdd7FxadYv34SNTV9OXDAFEfHKSQl/YCenUzSmaqOYezYENzc9vLDD0WsXXuc5uZcUlL0KWVj41JiY/fi4qIhJESDi4uALjYxEeZBIgF/fw0KRRl5eZCYmMiDD07hhx/0YLjqahs++WQDrq57CQx8g2vX4Pp1EUqlmIkTQ/H2Poulpf58JiYCitnFJY4+fSLJzFxBa2swAopbhbPzRcLC3kYiseLGDb3WtUrlw6BB4zh/fjTFxYaobxeXneTmHsPR8RLW1lG0tLgYtCl1J5DQ1bqmgI2NLXjnnfW4urYgkdjewg7l7x/C1asuWFm1YW1t9R+xR0mlMoKDp3Dt2udUVbVgbW1KVpYSU1NTRo8eTU5OMGvXQnj4/28g6p/R7qWs/0csOjqaL774JxMnFmNuDjKZMQsXpmNnd6v61O1MC9qKiCjDxgbq6iAuzuW2oK2KijSWLHmPTZs2GaCJGxriWLXqSrdO6+ci1qOjozl27IiBmtOdUt1paWmcOHGCI0cOdJEGlOLqGsncuXFkZUF6uhsdHSYsWRJPbq73LWOZN28p16554OYWT36+GTdujKK9/Qi2tolYWd1ZiSY2VmiNCg/XA75uXsz1JDJ6VSVtNOvuvoeiIn3KdebM75k371GD78+ZE8nAgVcQiYI4cMCII0f099mjxxbq6/2xsyvE2roIqbSOjg5z3N3jdcISJSWwY8dHtLYuRL/fFpz5nDmR9O2bSGvrv3nnnSd0G4GuILU+faKprl5GebkKCwsLrKzgkUe8MDEpob6+CqlU6O9VKCA5GSoq3Dlw4AA5OcEcOdJKWlo+8fE90G4cQkNXEhi4kpMnTVCpLPn000955ZXFeHjU4eraiKMjOkCgljRk374IGhpideMaNWolHR3myOXxAJw9u4DcXEOQmlCnFtjKRo16n3HjlumeiUxmj6NjMCNGvIKfX/hdo6Fv977eCcn8ayOdb3c+b++FneUTgQvhxx+rmDPnz60R/GeweyjrP6GlpaWRkPAy1dX7AfDwGMm8efu77YO8+djIyEjuvz8Xc3NhATxwwJFNm47d1sE+80wVq1fbGDBM+fklYGW1jqlTHX61nfn06eeJje2ro9C8HftZWloan332GXv27EGlUmFj8zLXr+vrxr6+e7C1zcXTMx5I5cwZ9W03Grc6S7os6pHU1aXQ1mbabR2767Hm5tlIpTuxs/vSIMJetiyYPXsEx3Azc5afXww5OVO7AL2imTOngPb2sRw+nI9cflhX221tlZKToyQpKYK2tjC8vRMYMSIOa2sAUSejlJ7ve8aMSJ1TvnQpgkOH9I48MHA3Awas05374MFokpL+esuGQbvx8vaOY/9+Yx566BVmzJhFr15BbNv2CQcOvIRCAaamQrkgPR2qqx9i/Ph3WbDAh8hIGDAALlzQp9adnM7z8MOhKBQi3N0fYPLkF1iz5gf27NlDe3sL5ua19O0rKHtpo/DCQkhOfgilchzTpo1hwwZ/gw1LXl44Z88uvOXdLCycxKhR7fTunU5+fiJKZR7Q1vkEpdjY+ODrO47w8DfvyF9/J/upUsevjXS++XxLlkB0tOCMxWIl48btZMmSM/j7T8bHZ/Qv3mzcs9/W7tWQ/4QWHByMXL6ONWtGUl+fzZEjDuzZc4lHHx30k0IX2rrZqVMv4e0taBHPmCGmV6+g235/6lQHvvkGHaORTNaio9b85pufr4PcnS1YMICYGLolZ4mOjuaf//wnpqbFPPywEJ0dOdIVFSwlO1uv4uTm9himpidumyrsSvxxs9hER0cYISFnSEi4fR3b8FhobvYF/oafXxvJyW+wbl00ItEjVFSsRsuApY3uWlrM8PJKACA7e1oXR5lAXV0cV69+QmmpLY2NxgQFBQHFKJWNeHhAaGgcsbFxVFdLGTv2WQYOhIsXd3Hjhj6drRVb8PWNo7kZ3N3jGDRoJoWFEXh772Ly5D0Ijlcwb+/DnDmzsHMOJPTqtYXKSn/k8v06YpFJk9qRy7ORyx0Qi6X07n0fr776T2xsKsjKAisrCRUV96NUbiIuTk1MDHz3XQ6TJ/ty4YK2zi2iR4/92NiAjY0GtXovq1bt4eRJM8CMqKgHsbOzY8uWLTQ1VeHi0oiLi4TGRg/k8muUlMTT0HC6893Q36dcHk9Skp7BzMMjAU/PON2G4/RpuHDBCFtbE4YMsQEaAQV1dZmkp9dTWXmVgQOfvyOpR3f2U0jmXxvpfPP5BF1ssY5Ixc3tEOnp+ykoOImr6wB8fO6jR4+JP/u+7tkfw8Q//ZX/XyZQMO4jLS3t9x7Kbc3CwoU5c7aTnf0QmzfvIiZmCA88YEzsrbwOt9iiRYtYvHgP5uYyzM0hI2MwDz98ld27Vbd8VwtkWrRIxIYNRYCLjolJAG39Ovejv86tYh1paWns2LGUhx8uJipKqBufPPkRvr5gbv4w4eFXGD260MAxNTWNYvbs2RQUFNzyDMPD9Tq8wquvF14wM0vg4kVpt3U/7bGCowFtBFhcPJnQUBgxQkFDQwgCkhlATWDgbsaNW8no0Uvx9Y3D0zOOyZMj6d07mmnTBPILsRiCg2Hs2A7a2oxYv74NS8sXKCoSo1BAR4clffq4Y2Njw6hRU7n//s/p3ft9jI1PGIDZvL0TyMqK4NSpj7hyJYKWlpPIZG9RUXGZ0aO34uIyGDBHqLMaGdzb1auzqarqR0rKcs6ejaC1FWxt4ehRNdOmxbNxYwkAEydOJzfXGoVCQnk5SCT3IRIJ0RqoWL36ACNHvsjixWX4+OQzatS7jBv3hu46zc2t2Nm1MX58O2ZmcPjwYR555BFiY2N5660PqKlxJzPTk7Y2O2pqBCGCcePEqFRixGJh82Vk1EZe3jhGjVrJgAHRREVFEhioR4w3NwuiFkOGdCCTqdi5U4WNzUjAnYyMGcTEvMbhww4kJv6duLhnaGgo+kW/+dhYWLKEu/rd/Zqm/b0sXixm8+ZaHn3UA2fnYNraOsjOPsLp0x+wZ8/zZGcfRals/e8O7p79x/a7R8h/pGb237rX99cyF5cQjI0/1C3GYrGKhATJXUWsw4dPxMkphjfe+JLNm4XWoC1bJLzxxjlmzZIZPAM9kMkDkWgKiYlCWvluQFs/x7qj0CwoKGDIECU5ORFcuvQEWVnTdJGwWDyd69fvZ/LkLzlxwlMHKJowwYgtW7bw3Xff3fIMu6KlfXzyqays5MCBVvLz15OZmXJH1Rjtsa+/riAtzQw9RaZQPnB2Blvbw5SWPqd7LgMGrEOhaOf48QiamsLRaOIpLIzDzW0P2dl+ZGXJGD68FRMTEIs78PeXcvGiApnMhZQUTx1AqL6+FUtLS91GISBgIBUVb+Hp+RgwGoViNwoF7N+vTVMvYejQSBSKM0yYMANHx0BGjDjKtWs7+eyzsyQkPHkTfaZG59ybm8Owtz9FWdljbNggvGPHjknp02chNTWJWFhYMGHCBMLDw7l4cQarV2uBZhLE4hpSU78mIOAwW7b8DW/vaRw7lsr167sAAcBlagpicTNBQWakpKgoKChgypQpBAcHo1QKesOlpaVdarDeeHvDoUMtVFWdZssWvRJYVJSwqdEi2NvbhXq09lqengpMTBR8++0pqqunUlS0BZFISVLSC8AD9O59gLNnj3LyZAsFBbK77h3Wt8GpWbVKzM6d7f9VKVb978UWeEunGpWbG095+XWKi1OoqcnE2bk/4eHLf3F6/p799+13rSH/kRygtsZqYqIgJETJxYvSbuuJfwS7uTf256aQo6IuExPTS7cQm5quxdn5Hz8Javpv0ozu2rWLdeu+Zc+eWG5WJnJ3j8bIKBqhF3YjGRkuBAWVsXfv+xgbh+PmFk9paTzV1Y4/+Qxv3hT+FHhr7NgEzp+3JCBgP0OHvoFYLFA0Hj4MTk5ReHmNw8vrIEFBcRw4sMKAqlIkmo6VVQKmpqZIJBKUyiaCgiSYmpqRlQUqlRGxsbEcO3bsZwGIzMw+5+rVCQaUmgMGLCU11Yz6ekcWLXoRuXwR06ZBV5lIvQmfzZgRSZ8+cRw48JFBnXbAgGh69XqFs2ed6OgwITY2lrVrg4mOFnqURSIVQ4Z8wqRJSwExpqb2eHuPYfLkj2lqKmPjxhlUVhYgkdApgACJiWZMnrwYNzcPRo8eTXBwMGlpaWzd2kpurpwHH9RjFWJj4a234NIlDWq1SDemsWMFgpO6OsHZK5VgZCT0TmsZxoyNxRw6tIbCwnnolZeiGTlyKR0dUF8PWVk2FBdbA+KffF9uruNOmXKYr792wsWlH2Lx7xfjtLc3kZV1iLS0zZSXZyKRaLC39yU4eD4BAeMwNrYweLfvIbT/e/aHryFr23BAjY+PPXV19Xzyycd3pRT0W5i2L3bIkDYcHWsJDzdh3762P5RiSle7mbj+5/y4oqOjOX36ChqNnswhPPwQJSU1d1RrupMYxK9tWodTXb3QoHarVSby8GgBLElPz+fbb6MQiUTEx0+gvl6IElNTlxARMZ2iorO6Z9id4/X1tcTPTzh7V/DWqlVSPDz+jVJ50GDDeOxYGLt27eKvf/2MGzdmYm4+nKqqeDSa/cyd24P333+ObdvmsWLFda5cGYQ2ggQVlpZhvPfeRF0v6Sef5LJ1ayVi8XFsbRN1EXpwcPAd23Lk8kWMGPEwPj55zJolIycn2AB0JpcnYGMDQ4e2kJTUyqpVqxgx4mHEYjtdi5WQdhdaqJycLjJixNs64g43t1uVplxclIwbV86BAxYUFBQQHh7MqlUgFmtQqyUYGbUgLClKFIpKsrOP8OqrH1Nf/zSRkRdpaVlAff1upFIhkh07toWkpPc5dQrMzOx48803kcsXsWKFEH3+8ANMmtTMgAHmBhKaAppaSkBAgm4+zM2hsVFIWZuYCE7ZxERIvbe0qHFxOUFh4eO6+3F2TqC9XXDcIhG0tdVhZeVAebmesas756Wv4wptdXZ2P7J79xXk8jGMHv3q7xaRGhtb0KvXA/j6jtWxfjU0VHLmzL/IyTlKbe1LzJ/vhUQiRPabN9cye7bt7zLWe3Z7+90cstYByuUOmJvX06tXHWfO8Ls5QG1fbFFRG87OYGHRRt++qv+6YsrPJaz4uQ5SuxFyc6ulf/8qEhJGMWpUAr17CxKH27eb/sfP4D8tQ6SlpbF9+0vMnNnBgQMpXLkiLPLC6yrUK5OSlmNnl4W/fxpyeRhZWeHk5AQa1JOTk8djZib0Nj/1VJyB4xs37hPWrIno/L43Xl4vIJFcwstrByJRH905nJz6Ymu7h7w8I9599wopKVU8+KADEkkUDg59SU/3o7FRSBMPH76HoqKhzJ6dydatAcDAzjvSk3mMG3cMMzML7Ox6sHVrK2vWRHQu7At45518g37p7gBC+uyILWq1A4GBRcydK2zQ9u9voKVlOc7OcUgkgqPq37+OY8daMTdPRq2ectMGRxiXr68A6JJ1gnQDA+OIiookNzcMtToBd3fBUZubq5g6tZ7kZCW1tUpmzpSyfbsIkUhNYuJy3N3PERR0AJFIxJUrYWzeLKS9N22S8q9/vYOFRW9qa9fT3l6ESCSgshsb4fz5Bv75z38SHq7dNAjZkAMHTDlwgE4nLLRoeXvnMmfOXuzt02luFsbb3AyWltDaas6JE2p6924lONiaxsY6ZDJwdNyJk1MzFhYjGDw4BSenOIyMhEg9L09QhpJI6jEzs8DLy+uWtPTWrQ08+KCVzkkvWwb19S04OGzD2fkGdXVlXLu2i4qKK/Tv/5dfBBj7tUwms2HAgAUEBUWSkLCSoqIUyspS2bXrEmKxR2dNXslnn8WiVp8hIuKte2ntP4j9bg5Z6wDLyxsJDKzB0rKZ0FAxLi52v8t4tCjkTz/9kKamWmxsYOBAY5yc/ntj+G+k8LUbofvuq8PScjdubruxtBTE3E1NwcLC+D/ahLz22mt8++23KJXKn+zrvdMYhwzpICcnAmPjQbi5fU1dHfToMYaLF/07nYmS1tahyOU1Bj3Jggn/rdFcYsmSJezaVdPF+S7A3n42W7dWGiCujYzmo1Q+ypUr0Wg03+r+5uOTgLd3DZWVM8jO/pqNG4XITTAfQAv2UnH69P2cPq0GHDBUOxLS7T16bKGwMJzY2HjOnBnPjz9GIxKF6BiuMjJs7mp+4uP1Gs8ikZJvvtnLpEljiIwMIjLSjosXF/D88z/Sv7/gjOzs2rjvvjZSU2djZxeFRDIUW1svMjMn65wcmHVyYgumUoG/vwBEUyjg+HFBw1guh6qqSD77LLJzIyHcn7bNq7j4foKDz6FUNlBQMN5gg/Tdd4dpafmM1lZjrK1h/HghfW3TedstLS2dmtMOup5i7Qasa/vYyJFvIJdnERKynOvXt1FQkIy5eTXNzWBv34y7ewQnTozlxo1zTJq0n9bWGpydGxgyZBspKfuRyx8lO9sUe3sFUikEBAhc3VeuaHjhBSFDsXatHvkvFitZvfoAVVV+PPvswM7OAxHbt0uZMWMBDQ0TOX78PQoKkqmpyePkyXfJytrNhAn/wMrK42e9+7+mmZk5MH78SnJyjpCREUdAQDL790fowJnW1js4fTqOGzcOMWLEwwwd+vw9x/w72++GstY6QBBTXKxCowFfXytEorzfa0idQgl7ue++z7CysgGUbNkyi6amst/82trI1cqqjqioOqys6li1atWvjvb28vKio6MDY2MB+OLggA4Uk5UVgYPDP8jMDPxF53711Vf597//jYlJOfPnV2NpmfuL7sHLy4vs7Ah27Ijl/PmFlJQ8g4XFOR5/3BRB9UkNSFm0qB8FBeFdHKsSU9PDRETk8cYb5zh6dDELFy7k8GFDJLal5TDE4uNdHLiY7OzpeHmF0dz8HRMnfk5UVAYDB64kMzOcI0ceJj9/EIJj0IKYhOMEE9qHun6mZ8eCwMBYhg5dyfXrs0lNXciuXbFUVkYQEnLYACnd1LSIkpJzPzk/4eHo6pcajRR3972sXTtKd2xISCizZr3NkSNu5OdLaGsTUrhDhjQRGKimvd2Y6uqsLk5OohN90FpHhxA9mpgI6eURI4TPT540Iy9vSueirk19C3MibEDKMDERY2Pjh1x+xuD+AgMTmDKlHiMjBZmZEr79Fm7cgDNnhHObmZkxa5aMmBiYOlV4KYU5FNrHhgyJ5qGHHiQw8BBVVXmcOfMe1tZy7rtvJY6O/TE3F2hAT56MpbHxeW7c+IEdOyZSWmqMRgPOzlL69ZOyZct+fH2fJynJibo6MRIJBAaasXixJ6NHu9De3kR4ODp0t1otxdk5li1bLiMWq1CpRIjFKtasOUhR0VksLFyYOjWaBx5YjafnYFQqNcXFqezaNZ8rV3bS3t50V+/9b2HGxhYEBU1n0qQPmTHDnKeffoWePT9lzJhp2Nkdp7kZqqpySU39jt27F5CcvIbW1rrfbbz/3+13RVlr6euys6+Qn/8RjY2FJCd/hJ/fyN9tZ6lNEyYkVHP8+HvU1xeyf/9Spk37+jdNQWkj10mTarGwgOHDW9m1y+Q3SeFrNBoqKoRoB4R2oqysJ3S0hA88YMiYdTcp6LS0NL777jssLJTMni04+/Hj4fvvG3/2PQQHB1NaOsXAifbq9awOcZuQIKC88/JSaGoSap3alPbcuW18840he9mECZ4kJuodQ2PjGWxtU/D3L+HcORe07U8tLWEEBsaRnv4+r7xyP4sW6SklbW3/jZaa8WbhCD+/WJqbXSkrG6K7potLEtbWp3FxSaB//zgSEz8yuJ+CgjAcHJbi4RGJs3MYAQEJ+PrG8d13McjlszE3D8PPr88dEd9799agVC7HyyuO1lbYsGEyAwf+leHDhd+VVCpFrW6npSWdrKw1lJZGkJSk12OOikpBLNZgZLRS18OrNSMjYYOWlRWOl1c8np5xeHpCS4sJGRln0GieuSkrIcxJZuZ4duwwJzAwldGjryKRPEVmZk9cXRPo0UMgLrnvvibi46Gy0pz4eKE1x9raildeeaXz9weRkVJiY+HQIQUSyb+ws1uJdiOkVptiZGRNU1MtmZmx1NVdx8TkB44du0Jhocxgnm1tB3H9+jY8PX2xslJQV2eHQlHN6NFhzJ37KDk5V1Eq06iuPkZTUyWJiW+Rnb2fiRPfIybGhSNHOvDyOoSVVTaJiWLU6sd1EaaDw1Z2775MYOB0Ro58AVfX/kybtpobN/aTkvIljY21nD79AdnZ+xk/fsXvGn3KZDYMH/4CJSXR1Na+grm5lOZmayoqnLGwKMDd3YHa2iJSUz+nqOgMPXpE6oBg9+y/Z38Ypq7MzAPExj6HUtmMr28406at/l1fhpaWKn78cQZFRckYG5syePBSxoxZ+psx4WhR3vfdl4uNjZAyPHzYjg0bjv+qDlmve1xBaKianJyITnF6PYpZLFayeLGUjz66+zT6vn37ePTRR5k0qRo3N8EhX78eweXL4TzzzFj+9rd+uvu8m/ry5s1VPPSQQ7co8k2bnmf79gIKCsKpqmqmstIemSyZ48eX3va8Qg25ArH4hA48paUh1C7go0dHIpEc49o1S4YMOU1srKcByriqqoX8fD1i2s9vN337rsPfP46srIhOTWRDdSeFArZvB1/fCE6fju3iDCOpq4vjzBlwdDTliSc8gRuAUA8tL4eUFFf+8pdX75jyb2oqIzHxH6SmfotK1YiRkQUdHXZs3dpKTQ06ru6YmA20tb1GXt5fdPc0fPgadu4ciVLZypYtc2hoyAagtVV4dl1LAf36ReLjs4f6el8uXBhBYOD7tLVVUFbWRnn5EIMxaY+ZN+9hBg++SHV1O0VF2VhbC6WR1lYBDe3sPBhr6wiMje10KOvbWXt7E+fP/8Dx4yu4eHEgeXnhyOXxhIScBSRkZEziu+/WdeEEx2Ce3dziyMoSU1oqp6FBTVd9aa01NBSxd+8iysoyEIvBwcGXcePeZetWS44dEzFiRAMDB+5i+/YWrlwJRC4/RkBAHBKJGWZmZjg49GTo0Bd0bFlNTWUcPfoGxcWXACXW1q4MHfoi3t4jflc2rbS0NGbMmIynZwvt7Y4UFbUCYjZtWk11dQxlZRdpb1dgZGSCq+tAwsPfMOAAv2e/zP7nqDOVylYOH17GpUs/YmIiY+jQVxgy5MnftY2gri6PDRsmU1OTh7GxGWPGvMngwU//Zj+o6OhoNm16k9Gj6wAwNzdlyZIbv2q2QOv4H3ggFyMjOHz4oy7i9FrwjEDS4et79xKJ2vPOnJmLRAIJCSs6+YWF+l9MDOTl/bwa+Z3arB56KJLNm/UOo3fvZ6mu3nVbysyuY9RuBnJygomPh+bmCjZt2o2JSQKDBh0jJ0eKUmnMkiXxLFrkbUBN6esbx4EDERgbh+HlJUR8zc1QXCxElBcuRGBpqf+bVrawsBC2bQN7+wgcHcMIDEwgMFDony0ogOPHjRGJbHFyambEiCZMTAT0b16eBadPz2HixPcNWoBuZxUVaWzbNpeqqmvU17fT3g4nTjxNfv5gZLIkFixwuEUmcc6cSPr3T+K++z4nICCcmJiVXLjwCRIJHDnyEamp+rYnuXwPTU25tLZCY+MSnfNzcFhFVdUL6Dd0eirOIUOikcvPUVAQhlS6B2fnONrbwclJSIU7OFjh6dmXBx7YgI2N/I7vbWwsfPWVgv37TQ3G37v3aQ4c+IDTpx8zGKtMloOPjwBWBD1PdlKSjEWL3mfRohduuUZrax3nz68jPX0nHR0dJCaGsHnz12izL08+GcOHHw5k795FlJZepqOjFY2mDbHYFKlUgkxmg4/PBMaMeRkzMwddG1Jq6hpaWgSFLF/fSVhYjKGiouF3417ojnNbqWyluDiZK1e2UlJyAY1Gg52dD6GhT+HpOfQeLed/YP9zDhmEqHTLltmUlFzFwsKCqKjv8PIa8Ztd726sqiqDDRsm09BQTlbWdBSKxTz0UF9mzDD9Ta53+fJFDh1aQHPzBQA8PEYwe/b2XzXdFR0dzdmzi/HyEpSWduyI1S2wkZHwxBOCA9RG0/PmlSGRCFF7XJyMDz/ccVunFx0dTXr6YqqrtVG3kN4VizU88kg12dmeDBvWSlkZnD/vTGur2S/WdH7qqRucPRupW4StrL7Dzu69W86nb23Kx88vHS8vL06fVvHMM/10C/vEiZ+Tnv7+LTqzsbHw5ZdJiMXv0atXHG1tUFhoRVxcIy4uGsaPh+vXITVVqDe6uroyb14EMlkidXXpGHUSYp07pwViibG0NCIwsI2RI0HauddUKODixUBu3KijsbGCSZNsMDHRcOHCI1y//rnu2WzcWM7DDzt3Oy8tLVWsX/8MV6/uJD8/grg4/YZFS/yydWsr16/b4+6+idLSC+TljSAg4BwPPmiLWj2CV155gvvuU5CfH2Eg+iGYtn+5q9PdT37+bhSKEPz86klN1af5R41aSWKi/t/h4ZE0NZ2gpKSdUaOU9Oxpg6mpMZaWToSHv4tC4UhJScUdBDs0aDRCarxr3/P58xHExurH6u8fQ8+ea3F0FJ6ZoyM6RHVrK0ycuISpU/+OTGZzyxyq1UoqK68RE7OETz+dSnq6flPi4/MFGzf2JiRkIGlp27hwYT3NzTVoNEpUqjZEIiOMjIywtw9i6NDnddFwU1MZBw++RFVVDmVlpWRklHP6tCkSifXvxr1wp0xVe3sT6enbSEvbRnt7I8bGFri49GfEiBfvRcu/0P4nHTIIUenGjdOor6/A3NySRx6JxcHh9nzL/y2rqsrglVc+ZN261TpGqF+Ly/l2VlOTxfr1E2hoyCMjI4KKijk88cS4Oy7GP9dOnz7E4cPTAQVHj64gJ2caM2c6s2qVHlaujXqnTMnVyeVdvx4BfMBjj/W67f3Hx+9k2bIakpIep2vN9Y03ztHUNAgTE+EcaWnhlJWlsnnzw91GtLez6Oho3n33CnV1M2lvvw9t9OLk9BTLl/c1IM+4WRDCxmY+traJODu/ytmzC3QLrbn5fjSaMvr1q+GRRywN0qfaOTA2bqVvXzWXL4upqmpHqVTS1CSAdSwsLJgzZw7PP/+8rt95zpzx9OxZQXW1hqQk6OiQ8thjjxEVFUVbWxsqVTnp6f+gvj4PsRhqaqw5c8aVzMxM7O3tcXd3Jzv7ORob5+vGOXbsVvbsmXJbR6K1y5cv8thjE2lqeoOsrL/qjo2MPM/OnQN0Gaddu9p54AFj3dw8/PBshg8v4rPP8lAqxcjljcBoysvDaGryIzf3fgxr6IJTnjt3NiNGVOHs/Cje3j3Ysyeb/fvLkcsTbhGBGDAgmsDApRw5AiKRFffd93eKilzw8jqGj08sKSkKLl0yxcjIknHjPsHCIoLwcGEz8+mnXfWZhTGMGrWSoUMFas6MjAguXFhgoKY1bVok9vZxlJWBiYkMFxclKpUSb28P/PwGMXlydLfZp5iYH1mxYgepqXoBj/vvj2TUqEymTfsIP79wWlqq2L9/MVVVeahUStTqFkQiY0QikMks8Pe/n+HDFyKT2dDaWsfevf8kNvZfiERqWlocOXdOxt0QkfweplYrqa6+QUrKN5SWnkelUmFv78uoUa/i4NDjd81c/i/a3frQPxyXtY2NnIce2oG5uSUNDdVs3BhJTU3W7zomB4cgjIz+oUNcSiSaX43L+XZmZ+fPvHn7yc9fwObNscTHz+KRR5zvijf3bnl5hw+fyPz5+7h+fSaJicspKenJJ584GVxDi4Q/edIepVKIpnftiiUmJpBp027P4xse/gAvv/woQgQlkE8sWwazZsmQSvXnyMpaSGPjD6xdW3nX85KWlsaaNUeoqFhNR8c4AExMjvLMM/t0iOqu1lUQQkBXhyIWK6moSLgJ3RxBS8vjnD79CsuWnSQyMpLo6GjdHIwb9wmlpSvZt+9VSktX8sAD33Hy5Emio6OJjo7m5MmTfPXVV7pFNTg4mKefXkZqqpzLl+2xsnJm2rS1WFisRqmcQlRUFDNn/oWIiB85dOgh9uxZRVLSQ9TUjEQq/RSlcgqlpaXIZEkG43R03MzWrbNpaCjqdo769g3hsceWU19/2eBYU9P3OXhwuQ5Be+KEMWKxWvednJwhVFWlMWcOmJo2cvasklOn4vD3X4qt7VoMnbEaF5eLPPTQLPz9d1JdfY7S0o8wNa1i2bIZ7NgxmqCgQ7i7xxuMQS5PwMMDJk8GE5MoNmxYyvHjc1i/fi3JycPw9GxmyBApLS3hrFkTQXS0mmnTBD1mlYrO9wm0G4KODjO04YSPTxw2NrkGz7uoKAxTU3B3F45JTLShvt4UsVhKWVka27c/RGbmodtyPvv59aGu7hx+fo/i5bWGMWMewNs7jtbWCg4eXMKhQ68jlcqYNm0tAwbMw8LCFiMjW6RSY9rblZSVFXP+/Eb27n2OpqYyZDIbZLJhJCVZ0NLiQFWVJc7OligUgpjJz7XfmktbLJbi6NiL8eNXMmDA45iaWtPYWEx8/Bvs2/cBcXE7/rB8///L9ofc5tjZ+RMVtY7t2x+hubmB115bhVi8ksmTbX43urcpU+z4+ms6U7eiX5XL+Xbm4BCEsfG/dBG5IOggviPy+ef2McvlYVhY9OpyDQ0JCSKDOdYi4dPSDnDypJUOYXq772otKsq4k0VM3KX+G4xEMpy8vK5tSmr273cjLS3triKEgoICjI3DDRZdiSQPJ6eB/OMfLvj4GPJxC4xKeocQGnqYhgYT0tPjmTPnFTIznamr8zOQRPTwCKWhQcobb1ggEuXj7e3d2cOsZ4lavVpMnz75LFz4bLdj1c5bQUEB2dm9WbTIW8eQtGwZtLSAmdlQ0tOHGqSFRSIVbW1/1aWYc3Jg9+4i2tr+RmBgHLm5EjZsmMpDD+3oVgtbuHYaW7cmc+kSmJl9QFDQblJSZNTUXCEi4mvCwz062aaE5ym0PTUADYweDWKxiKtXRSQkmOHoaIuR0Xk6Ogbo5iEs7G169IgD7FAq26iszCAm5kn693+CMWP+Rt++X3Px4mNERUVSVCTU1bUsYLa2IJP1A5S6Huzi4jBcXeMQi5VIpaN1fxOLVdTVNRETY91ZQzY3cPAikdZZg7t7PGlphipQIpEAJHN2VmBpqaZXrxeYOnUgSUnRNDTUcOTIq/ToEYWVVbhBXTc4OJhFi15k1apVtLUdpqjIhMmTn8Te/io1NQVcv76bysrLTJu2miFDnsfXdxzx8W8TE2PJlSt9cXGJRy6Po7m5kdbWJxg69EVaW1uorzfh9Gkxnp4yyssbuxUzuZPdTFryU6WM/8SMjS3o128eHh5DOHPmEy5cOEpu7l4qKiRkZTnw/PMv/SH5/v9X7Q+XstaaWq2kqOgsK1ZsZM2aL/4rqeKfsv82l7P2h6clKNDe++0c79ixY4mMjMTcvJEhQ1o5e1ZGc7PlT6bD9NcQFrY7ze/27U08+KCFjhjh5z6Lffv2sWbNV51oZL298cY53nkn9CePT0tL4+GHl3Hlir5e6O29kvx8fZ3SyekpXn+9j26ReOedY+zceRG5PIGmpqPk5dmjVkv58MMPefnlFxCLR3Pjxgbd8Xqxe+HfERGwZ09XIQaBR9nMbB1z557Xpam7zufNdItLlsAnn2jPIYCftO9z1z5e4X9C7+vixRIDXeiysots2fIgdXXZgBRray+Cg/9OW5st3t4+d3zGRUVJ/PjjDFpaShGJzHBwCGDOnG2cPOnPF180UFx8juDgVQQFCSC11lZQKEw4ftyY7OxxqNW70JYGxowpxtV1EUFBO3Xnr63VCzvY2loSFDQVb+8neeSRJ3Fyqmbw4EZMTNDxWGs0cPVqBHv36p/jtGmReHnFkZDwGFlZD6FQTNT97amnnmXQoGdJT++FTNZBQcF1xOJ/ERAgMLS0tgrXb20VWrWuXAmjd+8EevWKQyQSkOYymSVGRiY4O3szevQb2Nv7sn//Yqqr86mtrSYzs46TJ00Ri20MNrI3b3ybmspISFhBVlYCanULlpZODB78Ej17TiY6Ope//a1Plw3gdHr12k+fPoE0N7eSnFzBmTMdNDZ2YGpqioODwy0c5XdjS5bAp5/qSUvCw7fw6qvXfnNij3PnTvL3v9+PrW0zEokZubnGFBf/9Bpzz/6Ha8g325NPlvLtt46du+XbC9j/me3mTYC2pmlh0cDQoQqSkkxparLipZdeYsWKFUydWoadnbDoxcSYs2rV1p+s0cbGwvbtVcjlebcoPv3UeG6220Xu2s/a2to4dOgBjhzZTVZWBIIjUjJvXh3ff+9wx3NoTVtDbmoKxcLiHF5evQzQwFZW32Jn977BItEdqlT7eVXVcBSK5zEzc8TIqIqamoG68/n5VZOV5czNtVNr60iamvZhbT2PPn0W8eKL/QFtzVpAqi9bBu++C6+/Du+9xy3n0P+/vrdZu5h//fUlnn66n8G9NzWVsXfvUm7c2INa3UBNDRw9+gBFRZN58EFnVq+O6Pa51dXlsWvXUxQWngXA2toZM7NdPP10sA40NmfOTNzcdiCRQHm5MampC8jI+CtqdbCOicvbO5/ly1tRKh+nrCyZ1s5sr0oFlZUCVaerqzMeHr3JyAji2293oFQ2MGiQgj59DMeUnh5BYWEYzs5Cr/b164bgrAEDkunZ81PU6g5+/HGzbpy7dqkICytky5Z5lJWdBARnrFJBUxMolRLs7afg6FhOU1MeJiYSjI1ldHQoEYuNsba2JyAgErG4H2vWJHP+vC0eHvG4uR0nMdFKJ/DR3e9AqWwlNzeB+Pi3aWqqRiYzx9t7NF9//Vfi4vzRClj06/cZVlYvMWFCKFlZyYjFYpqa7EhKEtPeDl9++SVRUVHdPrPurGuErFaLmTfvcUJC4rGz82PEiFd0rVe/tu3bt4+nnnqcHj2skMk6qKqyorCw8o6dDfdMsD+8uMTd2v33O7F2rUT38v3WqeI/mt3MV60lEBk/vhobGxg9uoXduwUogKmpKSDuZLKCsLBm3Nx+mvszLy+akydXcfiwgh9+uHOq+0782beL3AGDz/r3H4mn51qdlKJGI2XmTL0z/uc/l3Pt2rvU10eQkhLOpEm5Bo5Gm44VHPYIPvwwhnPnuuoCn6OiQmFARtI1fdzVyWs/X7HChK1bA2ho0ACCyoT2fCpVEqAFNKlwdr7IyJFv4+sbx44dEeTkfMvx40qOH4eICL0AAmh47z0RQ4YI6Wn95wKrlz5NrXXGGmxts+nRIxa5PIHS0gOsW/c8AwY8TEiIkD2wsHAhKupr9u5dxbFjb5CfH0F6+g5EIiVr1kjp1es6S5b0uO2zEbAZ20hO/pykpC+or6/iiy8KgF46Cs6srJnY2+/AyAjq6+8jPf1LhE2DGIEeU0JenjdPPilh/fqtuLq+Q1bWOiQSIfp1dISsLHB0bCEjI4nq6hNIpSYolWacOqWmtLSNwECwtxfG1Lu3wLddUBDOmTOgVE66idTjBosXj+RvfzPRlUpEIiXff3+GSZP6MH9+HKdOfcjp058hk9UBdNJ/GuHgkE9IyNPExppz8KASufwEAwceR61W0trawfHjX3L48DBOndoGKElPX8KoUQ/h75/ExYuKO5LZSKUyAgIm4ewczKFDr1BZmU1+fiIeHlbACrTUrR4ex5DLVahULRQUiPH2liGVqggMtCY9vQkTE5Pb/5B+wvTCMmIGD67C3NyUggIH6uqKOXbsddzchvwmsoteXl6YmJiTm6vE1taO2traX5Ryv2fd2x/eIU+fLrlNPfL/r2k5wE1NhUXQzAwCA6sZPXo0SqWStWtXcN99VUgkYGcHa9bsBXozcaKpLsLu6pi0lJ2ursWMGNHOqVPGd1R86s6059H2LCcmwrvvvkvv3hXMnAk3bkRw9uwETp68zFdfTWHkyHPk5cmZOdPBoC6elBSNWKwnpVizRkrfvt2LLixdCqdOzcbcfAhqdQrNzaduu0h0J9QQHBxMZiZ0dYzGxtn06ROLl1cCALm5+s2Dj89+8vLCUanA0lJfzxaLVYhEkptS2yo++6wemczOgIt51KiVdHSYUVPjzo0bs3XfDw7ezLhxb9DaKkR8GRkfs3v3F/Tu/QyjRt2ne2YmJgPYu9caM7P7DBzY3r053TpkENiaRo58hczMKD78sJgbNybo/iY4kE1YWo6isvIU+flda/0qZLIqWlsd0G4mvvxyD2+/PYwvv9zN6NE1mJkJ5/H3hzNnGnF3F+q6o0bZkJRkQU1NB+npHeTlaTA11TBxogDwO3o0FsHpL8HNbctNILatnD6dzuTJn3P8uP5zE5N/s3FjNTNm/EB4+Jv4+09kx44naGzM7LybVqqqsvjsszNs3vwDoOT06SdRq+cwePB5WloqKCoqpq5uuMH85eWNwsTk5F07GSsrDyIjvyY1dTWXL2+lV6+9zJlTwalT/VAqj+PoeAAHB0uMjCrx9RWRkwNisRV5eW3/sSPTb4wdUKujKS+/wvHj71BRkUNubjx1dTkMH770VyUi0YI8b9asvpeu/vXsD++Q4b8r+/dHN+2P4ocflhMW1ohEAmPGqElMbCM3dxFPPjmN9PR5WFkldrJwvYlIpOTzz+HJJ+M4enSxQQTr7++PQqFgxIh2JBIYMaKdrVtL2LFjh+56d2PayD00VNgouLpGcOVKODY28eTkYNDTeuHC7WvGBQUFXLggwcLCkJ/62DE13ZXZgoODef75EbekpO9m3Np6r58fXLigVWQSERKymaKiN/D1BQsL6NNnOsbGozEyatHVl1NTl+DpuVK3mKvVUqZOvURt7WESE1/SRcSHD9shiDdIGDjwKv7+ywkKiqOlRXBIDQ1yFAp7evXazIgRb9DcLLBYSaUCGMnfv43c3Gi+/34dJiaOOrwA2FFVdf4mB/YlKSmV9O8/q9tFeM8eKU8+2Qvo2kqoxs8vFj+/OGQyU4YOjaS5OYeLF/XnDglZbVBbl8sP8u23Rshka9i1axdDh27QUbH27SvMrZsb5OR0YGdnS2trKxMnTiQxMZHW1jZ27KjDzm48XdP2JSWz6dXrX3R0SOnZM56goDjq6sDEZC7Llr3LpUueWFquJigolqIiWLduDHPn7sXbexRPPnmMnTsXkJ9/ElAALdy4MdDA4aakDKV///O0takxMQF39+Okp+tBYL16HaCtrZFp05bd9XtvbGzBoEF/xcWlP0lJ0YwZc5mhQ5NRKJwwNn4Vd/cWqqqO4unZgrFxE9evlyMSOf6qjkwsluLq2p/p07/VEZs0NpZx/Phb+PpOYujQ5+7YKvdzrLts0z37dex/wiHfM0PT/ihOn/6Y0tJ1ZGRE8NZbAzvT+t44OfWgd+9EGhq6RnBqtm6twM+vhqlTFZw6ZcqqVav48MMPMTU11bWPSCQQEjKRjz+25osvPjEASN3JvLy8kEgE2kJtaxOo2bVrCX5+MTdFIvJuzyES2VJdfUXnjEHK2LF37s67GdGck+NNbOydN3H6OpzgTHv12kF1tRxf3/2MHv0GxcXwww/g6elJW9sZWltj8PL62OA+KirsGDUqko6OsM40cxwSiZj77z9BaWkY9fV+ZGdP1d1LevpJ7r/fBEHMYqoBNaWLS7Ju/gFKSoQMh1gsMFsNG6bm/Hm1LnuhjVRsbOZjYjKI8PBDBAXFcfDgUSor0xk79jVkMptbQGZCK9itSlR9+65DLAZQUFERz4ABvly/Ph2VajQ+PgKzmLNzMuXl4cjlQt128+YdneOPYsSIoZw48RyjRwvCFAMHwpYtIBI109FRjqmpKW+++SYgbLxOnDjBt99eoWsNXSRSIRZL8PL6iNraKsABqObSpeEUFKjp2/c0/fs7UVpqBTTQ2FjAt9+GI5FspKAgjNGjdzJixLt8/30J166FYGzcbLBh8fc/hoXFIIyMrlJaWoq/fwxtbQ+SkzMSB4dGamvH0aOHHb6++bS0VHHkiMNt9ZBvNqlUho9PGM7OwSQkrCQlJYaCgsvU1h7n6lUHFiyYhbe3DVJpNp6eRri49OPBBx+84zv9S0wms2Ho0EX4+U0gMfF9qqtzuXFjD9XVV7nvvg9/tRR2d9mme/af2x8e1HXPujelspXjx1exfLkpZ88+p0udymRreO65v+h4qrsSY8yd+z3m5gJf8vbtLqxdu5asrCw2b36VkSMVtxzj7PwUR44svqsf4F/+8hesrL5m167dZGVN030uk52ltXWI7px3Qmdr69C1taNQq0cze7Yz33xz/13Nh97JCuCf6Ggh1d098lmfknVwKMTRcRH33x9HRwdcuiQcY2VlhaWlJfX1Y9Bo5tPcrEf/jhixB7HYBl/f9fj4rNFp854754mzcyFtbYZ80M7OkUil53nmmZns2OHN5ct6MJq7ezQPPbRU55BVKkhKEtS4rKygpsaKykov8vKqdCCaruUHK6s6Nm2aRltbDUZGNvj6hiMSrWXOHFsDlP7Zs4YAMxeXJEJD3yMoKA4LCxAcpDFgRH5+CzdumGFnZ0pHRwM9eiiwtZUCphw69D5nzjyjG/+QIV9QXv4SLS0dOgaz/HyoqhJhZTWX/v2XsGRJf4PnnpaWxttvw/btwWg3BsOGraRPnzc4fdqJ6Ohotm07x5df/ks3h+PGRVJbm0hkpBlQTkbGFDZvjtVtrJ54ooS1a9103x80aCXt7Wa4uibg5xeHs7MDISEPc/78foqLM1Eq4dy5CAPk/oIFz2Bt7cbHH7+pm7u7bS06fz6JV1+djLt7E2KxlLw8M3Jzrdm0aTXl5ZspLr6IStWGlZULUVHr7ooW93bv709Za2sdZ89+zo0bB9BolFhbuzF48MJ7FJi/k/3PEoPcs7s3qVRGePhLPPLIUF0UrFZLsLA4R1YWBATEdXIw7yE4+AIymRGmpnS2goBcPpQNG/ogly/im2+SMTd/nOvXDft8xeKpLFtmfFcEBM8//zynT8PNW7w+fTx5441zzJ1b95OtUosWLSI2NpaNG2dz6tSQ2zrjTz/NZ/r0XD79NN/g36+/ntSZPhbqnMuXH+Gpp+KYNk1wvl3JTMLD9TrGIKG62pNr12JZtSqCpCTBcVlZWfH+++/zyiunaGraSHPzWAD8/PYwbNhKTp26n5Mnh7J+/WpSUoSeZJUKjIyGsn//Gs6ehSlTIhk4MJoZMyJ59NE4jIxKUattyc1NNIjeHBwSiIszp6xMOIeQqYBjx4Sx5OVZ3NK3GhwczJQpUwgODsbLayRPPnkKB4dgOjrayc6OZ926+E65QKE9Zv/+mk6AmUDYIhKpkMtPExq6l5KSRzh48DMyMqYBakQi8PaWEBTUwvnzLVy4YIWZ2ROdnNPiW6QV5fIjzJzZQUcHbN4s8HcrlZZYWc2lvv57Tpzox7RpQuuc1oKDg9m2LZjXXtMCx1ScObOc6uoIZs5sICDAG7H4LYP3sbY2jIEDm9i7txUXl/Hk5U00AHxt3Fhp8P2ODjM8PJbS3CwIfajVbWRmxuDv74+f3/DOPmbDd/7q1WBSUjwQi5W6uVuz5iDXru25LYlIVysrqyE93ZiCAjmVlQ40NbmhUCioqWlj8uSPGTLkGYyNzWhsLGfXrsfIzj56x3NqN5mffiqQpGzcWHLH62tNJrNhxIiljB+/AisrdxSKak6cWElKyprfVQ7ynt3Z7jnk/3ETi6U8//wQYmJg8WIhCnr99T6kpXmSmys4x+zs6aSn96GsbA2HD0egVguSi0lJu9i61Y1p0yAnJ5gZM16kqirdYKEtLZ3O3r2+3TJzdbXg4GBmzfoEE5P1nZ8IaO/ly914551Qvv/+zgIJXc+jdTQ320MPPcSiRd7ExHixaJE3Tk5bOv/tSVra0JvYqU6zdavhAr19exUgbAoWLVqFtXUuWgSxsAEJ4/JlM2xt3Vm5ciXPPvssOTneiMUqtO0sDg4FtLebG5z37NlA4uKsuHjxAQ4d2kpDw3xKSmI5dAicnZfi6yuQYvTvP5UDB0YgFlvg5hbFgAGCs54wIQ6pVMOOHeZs2ya07xw6BM3NYjIyIDe3ARDfsfbo4BDEvHn78fYegUYjQaG40bk5ERjm6uqeJzS0pLOFSa+DfPTo22za9ANJSX9h8+YdZGRMQyxWIxYbY2enZtKkRkSiWjZvPkZb22w8PQcgkUgICjpAYOAh5syJRC4XENNPPAHW1lBRIcLIyJT+/ZfoOiREIiXr1h27RV9coZB0ZgYkOpIQaGXdurH065ejI5ERUPQJSKVKQkJqqKlxxNe30uCZh4TEGfzbzU1gB7tyBRISHHBxCUWl0lBamgZUUFgows4u5abNxXG8vI7qnLxaLcXV9RAHDizk9OnP7+jQtEjknBwlRUWOVFQ06TZRxsYW9O//GJGRX2Jp6YxC0cjx42/d0UnGx+t5CMRiYf6Skr6+K81ibSo9MvIr7OwC6ehoJyNjB0lJn3P+fNJdMfrds/+u3ash/0nMEPim15n+/HNrAyRwcPAafH3/zokTPXSLjZ4FLJjXXuvLu+8+hZFRT2QygcVK2wPelSmsO9PWc7duvRVF/Z9aWloamZmDDVqLKitnI0S5Qp3Wz28PdnY5eHgkUF2dyeXLSjSaBbo5OHVqEdHRQ1m0aBHW1iOpr9ezXWk0UiZMSOD8eSXz5s3TETaYmaFzbBqNFF9fI0pLj6DR6AFBo0YdRSIZwL59Ew0ctbl5OEePCoQbtrZdU9jjaWqajo3NUnx9hXadmTNVdHTczwcf7OSLL0QYGRmh0SiRSCQsXryYOXPm/GTpwMrKg1mzNrFs2VoSE18BhLkKDNxCZuYgDh9+gx9+WEFCgoi2tpfo6IDExOWApnNToiIvbxhBQTE0Nytpa1MjkUBYWDvHjlXz1VebePbZGDZs0BNgeHl9hZubIOAgkcDjj8OuXRoaGzvw9y8iIaG/LqVsa7uRbdtWMWPG9yQkeBAfr6fG1FLTCqxhoNEoOHbsLWCHwT1aWEB9PeTl/UBxsRgfnwtYWYXh6yuobLm6JpOZORULi714ecUhFsODD4Kv71zmzXud8+e/5fz572loqEEuF5OVtQd//0XU1PRi0KADBAWdwMTEmHnzHiEvbwL+/mcJCNiPQmHE+fPfUFeXw/jxb99WaOGnkMhaANaMGd9z8OBL1NTkk5GxjaamUmxtJ9+iAiWwzYk7nbIUT8/jJCUdIz8/galTPzaoC3eX2jYzc2DixH9y8uS/KS5OJj7+Oy5dWsG5czKkUqvfTeDint1q92rIf3K7ua6qTRl/910mjz8ecAsLGOhbo1JSjHnrrfHdahL/t23fvn28995XnDqlV5Lqqjyk0UixsxNSw5cu2ZCfb0VbmwpPzwEolWF4eyfg5LSHAwfkxMbG8o9/uLBxo40uAvPzi+WBB6IoKDAiOdmjM3Xegw8+MNJdZ9SolfTq9QY//giOjhFYWYXh4yPUJ1taYPPmmVRXb9ONZ86cWQwe3BtjYztiYvpz5Ig+irezW42R0Vu8887DlJZ+hUbTChizf387qakC2losFhMVFcX27dt/1lxNm5ZJXJyPQVq+a430X//6G0plK7NmpXD8uMA9rp3TGTMicXUVlJJAKHHk5EBpqYjycntGjEhmzx45KpXAWjZgQDQeHktxcgIbG73m8bVrMnJynAgPT+HsWWs8PbcwZMgixGIJRUXz+OqrVTrWtyVLqlAoxKjVb+Hmtg5oBVQcOPCRgUBF//7RjBixFBMTqKsDjcaI48c7qK6GQYOs6devXjcHeXmCrvSQISYUFj5AWdl9REX58pe/9Key8hr79i2mpOQa5eUNXL9uQkGBI3/5ywJ8fArIyzuOWt2GUqlAJLJEIjFGrW4AjDAykuHiEkxExBfdAqXuRve7tbWOkyf/TX5+IkVFBaSnV5CUZHqLk9SS8QweXIVa/TSlpVeQSCTY2noyYcIHuLj0Y88e6W1Z/bpae3sTe/a8z+7d/wI0tLbak5pqgkYjuce29RvbvRryPQP0JAKLFxs61MceCyAmBhYtuvXHq00Zv/nm+Nse+2tYWloaf//7OebNq7prgnwvLy/q6pIJCnqfrs64X7+V+PpG4+Q0CzjFtm3uXLgQSVXVmwQHL6O8/AQDB/4NX984iorMdYT+Dz7ooFvoQUxg4DpaWqCmRoNCoeCHH4o7nbEGLTGIQmGGlZWwySkujiM3dynu7kI62swMZs7cg6fnPPr1i2bOnEiCgrYhEu3A3d0WX98Gg9Soi8tFQIy7+wQWLIhHIrGioaGd4cNhzBgbbGyscHBw4K233vrZ8zt+vHGXe9NH90KNtAfffTcRsVjK009PQc8aJmLYsJUEBMRhaiq0XikUUFQkpM4zMzVIJBLGjROjUokQi1W6NLK/P5w/LzhBlUo4tmfPNmxsQlm92om0NCP27n0UheJdxGIply716KzRCk79/PndrFhRwYcfLiMoaCpSqS1gjlyuFagQrmVu3oKVlTAuGxtQq9U4OFjR0CAhJUXM3r0WKJXCHMjl4OcnISYmis2bN3H8+CMsXjyK997bjr19ALNnb0UuH4C7uzvjx7vy97+P5K9/fY777/+EUaP+homJLSKRDGhGLBZjYuKMVCqhpaWF7Oxk1q+PoqQkFbVaecv836nsojWZzIbRo1/F1nY4eXlFmJq2MmKECLFYyapVq3Tp5MhI+OgjmDPHgQceWMewYX9FJrOmtraUvXufJTX1e44cae+S2laxdWvGLWlwY2MLjI0HcfGiGa2ttjQ1GePhYfaLBS7u2a9v91LW/w+suz7un+rvTktLQyotYMGCX7ff8N13XyQxMYuDB4X07Q8/3JlDW2taFaW3376AsXEMrq4aLCzWce1aHCqVBBcXF5YvfwuIZNEib0QiJQcPSnFyusCxY/sJChKTkaHG1NS4M3KBl1/+jqNHa5DLE5DL40hOhnPnlNjZSUhObjRIj4MEV9cEQGhJGjPGmeTkdpTKiVRXb+mMDlsJCTnO9es7CQoSkk8lJVe4cGEeJ086MHDgMEAQW3B1jePYMTe8vLzw8AimR4/3+O67g5SUhGNre5agoHTy8qruyBrVnS1c6E1S0mquX2806J/WijI0Nuby3Xf3ERoazWuvWXPmTBkuLpuQy4XNhUQipIZbW+HGDcjP13RG1wtYuNAbb2/YvLmEwsIXdPXx4cNh40bo109MUJARIlEbHR0jDUBXN24MYvHipWRmpnLmzF91Y3J13c+GDe8SFfUdERGfk5q6hpSU1fTqdVKnqwwqEhOXY22dTI8eAkjL2hpsbZW4uzvyyiuCFONHH73KxIltGBu3Y2WlwshoiC4dDiq+/rofTU1f8847TzBjxkaOHn2D0tI0mpqus3//C3h6PkllpRu9er1KdnY0TU21aDQK2tsVtLQ0UVpajUYDRUXFVFVFMWPGRwQF3f+L0MuCkxxCaqo5vXtLaG+XIJebkJ7edNvnrm1t8vEJ5+DBv1FfX0Zq6pfY2KhQqZ7SZbNkso85cEB6S2pdLvenqcmO1FQVHh5mFBW13GPb+gPZvQj5T2p3K8PYnUVHRxMZGckTTzxhIEf4n14rLS2N7OwvqK42RLZqwVY/ZS0t/tTUfEtHx1Ty86dTXGyLo6M7Tz75JAcOHGDhwoXk5HgbnNvbez5KpTEpKR0olcYGNb0xY5yQSpd2Rs9CD217u4T7778fX98EXV0VRIwYsZLMzDgKCozJybEnJ0eKjY0NEybM5uRJD65csaaoyIWMDDUdHc74+r5NdbUwbmdnCA5WUFp6lMGDl+LvH4e5OcyZI6GhoYR9+/Zx/vwA9u2L5dKlhcTHb6aiIviuFsvupPhmz34KI6NZ1NQMYNSolQwZ8ilz5swgKEhwoM3NBfz732v5+us0btw4hLd3XhfNYcHMzSE0FFxcbHjppZd4T+iZIjISNm3y5IEHBnPxohUdHUJU/MQTJjQ02LF3rzk1NTJ8fE4YZAWMjP5BbW0xy5bN4qmnnmPYsDU8/PAj9O59mIaGanbteozMzEMMGfI8s2ZtxMbGhY4O2y6RvpLS0jBaWsDEBBQKFXJ5C08+2ZMFCx5m9OjRqNUOHD7sRF6eC9evR1BZOQy1Ws8dXl7elw8/fIVXX/0QgMmTP6ZfP4FMJS3tGNHRk3n22cd46qnl1NdPxN7eG7HYHJVKRVVVNW1t0NxsTkeHlJKSQg4ffovk5G9+MXpZ6yRTUsypr7f8SSYvbR165swfkMuHAVIqK68xcOA5wsOrWLjwdXr0OERu7hF27nzUIIrX1rg1Ggk3btSh0UjusW39gexeDflPaD9XhvFm27VrF3/961/p1auc0FBobIT9++cyatTHPPigIUjLsG94DLNmOd5R5GDfvn288MIsevYcayAkcLeKT8OGfWxQUwwOTmDTJpdbFJcEkQct0nYB8+Y5MXr06FtqemlpaUybFoGFhQIvLyUXL6rQaMw5cOAAFhZVvPbaR+TlheHunoCvbxz19bBhA0illgZqPbcTsPDz8+O55x5hwoRWTExayc93IiVFzNKlj9Paug6VqhyA/HwJR49aU1f3Lxob5+sQ3337RvPEE0Z3VAPqDiOg/byrCSn0Q0gkxqhUjVy+HMHOnbFdotQnmDEjBbH4Cl1plhUK8PQMYfTof1NT06YjX9GChy5fvkh6+n7y8j6ho6MdExNTnJ1nI5MFsWPHEhoaxlFWJpCn+PnFYWNjTd++sxk8+CliY5+hsbEGtVoNtNLa2oFEYkTv3k8SEfEGDQ1FLFnyL77//mvdOKOiBFR3Wxs4OZkA1tjZueDpORg3t0dYt24ze/bsoaVlLLW13980Y/p6+pAh0TzyyI+EhLxDXV0bpaWHSElZjVKppKnJmXPnZICYTZtWU1i4jt27zbh8uRceHidpa7uEQmGCXJ5J795uODo64uMzntGjX9GxYv2c/uHuBFB+ytrbm1i16iivvDJNB5xbvz4fF5fPuXHjEB0drVhYWDNs2N8Movi7qXHfs1/P/jTiEvfs55mWU9rWtpr772+gvR3WrXvnrrip09LS+Oyzz9i+fTu1tbU6GszKygjy8zdQWKgySC+npaWxe/diQkIi2LVrPd1xT3c1Ly8vlEonMjOTGTPmEa5cGYVUmsqsWYvv6t5cXeMN0M3l5VsAw2N9fdOYOnUZ168vQKMRYW3dxNatCcydO/c2UonBjB0bzdGjizl3ToGpqZVBxBAVtZNz5wTCDo1G6N8ePBjS0oz58MMPdWo9t6MUTEtLQySyJSGh3SBdPmnSw3h4PM26dZMpK8vA2lrF8OFijh07TUPDArQtPj17JjBt2st3nJP4eL0zFomU7NlTRWSkSycjlwaNRtT5TTV5eeMICjqKSiUFLMjNNcxStLT0x8HBlb17MwgJ6cDKSgBomZpCZeVFPv10Avv3P0ht7RadFq/wLoTQt28IVVVR/PjjAzQ21lBXF4uVVStnz5oyYMA5+vRJpKTEnIYGsLZu58aNfbS11RIZ+TWHD79CbW0J9fWNVFfXotFAWdl7pKWd429/28Izz8ygoGAalZVjCAwUNkZCvzeAGBMTNa2tCi5diuXHHzdy+rQ5YIK7+6PU1mrlLYU56Apuk8sTqK4+xw8/TOHECUvq600wNxcREuJIVZUlzs4y8vKqqKlpQyT6mk2bLBCJlKSlLWHcuDmUlR2lqMiSIUP8uXixL9u29eP48Y1Mm9abPXssWLEiFIkEVq366ZLML6WkNDa2oLh4qi4lLxIpWb/+NGvXTsXHZywnT/6TpqYaTp36JxUV1xg+fCEymc09tq0/qN1LWf/JTMspPWKEAnNzQQx+4sRqvv322m3TmlqLjo5m0qRJrFmzBg+PapYuFXqIr1+PIDHxLUBY9IUWKf21QkOhsNBwYd+9u7bbFLY2Zdbaasb168ewtv4ny5f3vavFoaCggIaGOKKiIhkwIJrx42cjFu+5BZBSUFBAXh5kZU0nJ2cq589vpbZ2lMH3tBFkdLSSNWsiWLIknrVr1xIbG2sQmZiZjeXKFQGopFYLurv5+QKY6Ga1npuBPNp7vV263MZGjo/Pq5SVCWlylUqNjY3pLfe8cWMEFRXdlwLCw9E5Y41GSnv7K9TUZHUSn4i6fFOMXH4UsdgEsVhCa6uic3OjTyePGHEIExM11dXunD7tRkaGOy0twvhEIrCw0GBvPxRQolaLEYvVHDumBzQJfdD7cHT0pqOjg6qqg/TooeDcuVYyM23Iz5dw6pQbjo4DUatV5OWdJD7+XSZP/gQTE0fKympRKEAkEuKE8vJD7NixhNDQ4QwZ4klg4FKsrIQ2JrFYeCZ1dQra2prp6KimsrICCwsFI0eqMTUVUVGxBcMlTsyoUSsZMCCaiAhBf7m1VWBCGzOmEUtLNbm5Gk6flqJQyAyIWE6dskAiUevmq6RkMIMGVaFQNPPPf3rz1VcfER8/k/fee46XXvqEjz8+Byg7SV7UHD3a3u0z7O79uVsbN06KWi1BLNZqgm9n27bHUKmUzJjxPU5OfrS3K7hxI4ZDh16mpeXuykP37L9v9yLkP5lp1aBOnTJl3LgOJBI66TAfRCLpGtXoj9FG1YGBxTz8sCDyHh8fjpFRM2fOLEcrjiASCShOrQSml5cX586Bp2c8587po9bKyr/z9deQkjKBqVNzb0lh/9JowMvLi6IidwIDjxAScpCzZ60wNbXEy8vLID3o6+uFsbHhJqGjY4RBTU6IIJWdQB81R4543zaql8v9uXrVhdzcMnx9BYBTSYkYR0ezuwLC3OleAwIGcvasB56eLbS3O1JWFmIw5ry8MIKC4tiwYQrz5x/CwSHolvNHRsL27QrWrTuMldU6fHxi2Lz5InPn7iUmxoOPPy6htPQc/fuvISgornPhtqWpSYW3dxzjx0dSWyuAzPz948jNjSMkZDwXLmSTmqrg+nU7xo6twcREAFC5ucWTlbVEN3cuLnEolffpUqE2NnJmz97Brl3zyctLxd+/hdbWFpKTa7G0tOfNN9/kscceYv/+l8jNTaC8/CpHj/4de/uZpKc7UFs7BmvrswQFxSCVtpCbe5RTp1bxzjsf8OabEhIT80lJGYOfXzw+PgLNaV2dAhsbIyQSkMmgvb0BLy8ZV6/u4Y03zpGcHEhRUTJ9+kTr+pJVKqGX2cpKyAJZWkJoaDMVFUYolWry8qoMeoi1/cDatHBgYAIyGYwda8PBg8MRNinCc2tqGkXPnqdJSfkLIpESlUqKtfUGWltn/GoiDze/A7t2qdi3r4qion3k5Y1C6Ct/ih49nsLYOBI7u0QUihuUlFwiLu5ppk7tvmXrnv1+dq+G/Cc0bT3Kzi6XsWMhMVHfyymRaFi0SMRHH+m/v2/fPp544gnmzSu7hctaizIWizWEhIh48026rSF3dIygZ889eHtjcI5XXz3DqFG1t9Qe/5N761prc3Kay5w5tgZ11B9/jGTzZkHgAsQYGe1n/nylbnNwuxprd2nF6Oho3nnnHerq6gCwtrbmrbfeuqsaX3em3UA0NekVuNTq+6moWK2bt/nzH8PHZwugRiZzwM/vDYKCRt52A9PUVMa2bQ9TUHAKAE/PIcyatRUzMweioxPZsiUNufxwJ6BLQkmJAFQrKDBBJmvF11cvbFFVJeW++74iPb0fJ08acfnySiIitqNWC3iCo0cj8PMLo0ePBPr0SSQs7G0GD37aAGWclHSUZcu+oLp6JM7OJ6isPEZlpSUHDhwgODiY1tY6jh//gIyMWJTKdrKz5/Dllyu71P0fY/ToLYSEuGNtbYOVVV/S0xfw3nsjdd+ZNGkaAQGxqFTg5GRBYaEAqsrOFuhGTU3tOH78OMHBwdTV5fH11xMoKcnS1ccVCqiqAk9PIQOg0UBOjpTZs9dhbm5/ywZqy5ZafvghGQuL73F03IRUChcvelBcPJ0bNz41qHG7uBwiMfFRNJog+vQ5y6BBKcjl4Uya9I/bEor8GnYznmDOnEjc3OK4cEFCcbErjz02Gnv7XFQqgds6MvKre075v2R360PvOeQ/qWlBGw4OZuzZk82KFU90SxqQlpZGZGQkI0fmcu3aR6SmLjQglNBSH3bnsLTXysvLIy/vOeLj9efQCicMGpTQyVIlOPj/pK/5ZkDKxIk7OHJkmo6NbPFiCU1Nr7N69btoHbL2ulrBCYAePWK4cSOi8+9KevfOZ/x4v9tuGNLS0jhx4gQAo0eP/tlpxa4RPNBJ4iBEatHR+fj5pePl5cWlS3Z89VUsHh77CAqKQy6fSF5eAvX17bS3Q3y8C88889ptQXpNTWVs3/4IBQXJiERSvLwGI5Nt7tysCM9QAHbFUVMDFRVSrl+35+rVcoKDhdq4mZmQoq6vX8z69at0x9naPkhQ0HYuXoSODil/+9t87O0P0dRUiYmJJWPG/J1Bg57UOeW///0cK1aE6pyUvf0hVKqNbNw4mylTpgACICkx8SPS07ewY8crJCY+3IU0ZQ3LllXh65vPpUt7KC0t4/DhT8jNfVb3nd69P6dHj6U4OalwdnalqqqUmhph05CYCBKJPQkJCbpndfr0Ib76KhJz8zYsLYW5b26GlhZBxEMqBXNzMX36PMqUKR/fNpptb28iJubvnDjxcecnxhw9akt1dQSDBr1AXd1b9O+/HZEIFAop585Z8Ze/9KO5uQiRSIOb2yAiIqJ/E6e8ZAl8+qmms0dcSUhINOHhS1Gr4eJFSwoLbfniizcoL99NW1sDMpkt48a9g5NTb8Tie8nS39LuEYP8PzdtPWrw4DDeeeeJbklAtN994YUXSElxQ63W1xVBwrJleo7s7hyo9lqjR4/WpbC71iYHDUroUmeWdNJw/mf3plROYe3aYGJjwd5+ve56arWEsDAoKorSEX7oaSEFbWUQHKyj41q0zlijkZKW5neLCEXXaz777LM8++yzv8gZC/VqQSDg88/rOjdHQn0xN9dbVzt85BE3tmwJpV8/IdLNy0vk7NmOTtYu6NWrwYA0oqtZWLgwc+ZGfH3DEIullJRc4OuvD3dGTEK6NS9vIiD0UTs4KLG2Lkethqwsa1JTgykqMkYkguvXAzvTs8L8WFiMITPTDisrZ1566SWGDl1DZuZFiooepa2tjZMnPyA19VudUEJurhzQqmlBdfV46urWk53dWzdeY2MLRo16kT59HsLN7YjBOxMWdpzHHpuDh8d8rlxpQKMBP7/jBt/x8TmKqakYZ+eRSKUy2tuF+2pqMsbLywmRSGSAGxg+fCIhIX+nstKUpiatbjf07OmBi0t/LCwsAA1paVuJiXmG5OSEW7AQxsYWREW9h6vrXDQa6OhoZ/ToKl580YrY2B7MmBHKtWs2tLWBiYmS6dMtiIqKJiBAmPeSkvPs3bv4N6njhoejc8ZqtRQnpwTa2gTGt5492zE3r6W93Znp09dgampHU1M1Bw++TEHBqduSm2itu7a6e/br2z2H/P/EtGw/3TnVRYsWsW3bQVas+AvR0fm88IIgk/juu3c+rqsFBwczffonXLyYho3NfExN12BqOhsPjzi8vePR6gKr1fo69C+xlSt3djo4lS7tPGzYShwdL+Hs/G/i4uIoLGztEuWLdExPQUGCsEFBQQElJSeIiookNDT6Fs3m/2TDcLNpBQK0zq28/DIqlbizviimb99Mg++7uYXy2GNHkckcAQVBQRquX7emrMyc7GzHOzIrWVi48MAD3xIUNJX29hbMzH7Qgb7UainBwVeRSGwBAT0dFCT0Gbe01HPtWj4XLjhhaxtKjx4pupqoAPg6yksvzeHIkSMMG/Y+06bB6tU2rFnzNSUl82lrazdwyg8+6IAAUVF3jky43wsXDBNyxsYWWFuPp6lpNxMnRtK3bzTTp0fi7r6ZtWsnkp9/jbNnzaiocMPC4hQ9ez6LhcU3zJnzHAMHJhAQYE1AgCPe3mMAIdp1cmonM7OCuro6XVZDay++uIxXXz1EcHAU1tZegCnt7TWYmCjx8RmJiYkDGo2CjIydfPzxOP7yl0dv6cOXSmW8+uq3REVtRC73w8PDGQuLI+TkHMPH5yVcXa9jbr4JudwfS0sz9ux5lt69owgKisLIyITy8jR27ZpPQ0PRL3yjbm9aPMHMmReZN28Bfn5xdHSIUCpFtLW1MWBAK2JxNjKZDZGRX2Fj44ZS2crJk//i2LGN7N0bd8tG72a1qd27Vd1c/Z79GnYvZX3PfnXTppTb2tpYunQptrbVjBihYO/eB6iqmsDKleO7bYu6G+vaiywWq7C1jaO6errOeYC+B9nffzcODmmoVGY4Oydw9eoVFi9ewtixYxk27CgwiuDgfbi6JrNrl77mPGgQuLhAnz7CIt81jf1z9Wlv7oueM2cWAQGTOHy4Drk8AQsLD0xNVzF+vLHB+crKLrJu3TgqK2tQKoX+5+ZmKVZWVrraaHd27txJPvhgIi4uCrKzIygvF/qA+/WLw9FxLFevHsPMTPhuZaWQ4q2rs2f16tVMnhxOfPx7bN9ez9WrPXB1TcDHR2g1cnF5hfLyD4iOVuui7nnzChg69EFqaoowNbVgxIiXGTBgPvv2yfjXv8o5edK5y73P4F//+hseHkN1Y923bx9PP/0YAwaYIJMpaG0V4e1dhYODORYWbqxd20RrqzHOzpaUlzcCYjZvXkdu7lfk559ELJbi4RHKpUtlFBaeQqMRAFvJyZZYWDjclqe5vb2JU6dWcfnyjzQ0FAMqrKw8cXMbQHb2cSorBWeZmWlJcrIMqdRYV//uanV1eWzb9hCNjfVkZ0/miy8+1NVwv/rqAhrNUygULZiZmTNp0keUlJzjwoXvaWtTYGfnxYwZ3//qdVylspXc3AQ2bXqasrJCQEjPu7t74O0dQI8eDzBw4GMola0cOLCUK1dOkZlZxPXrxtTW2rFo0Yu6koiQBtdTcs6adZX1630wNrb4Vcf8Z7d7Ket79ruZNoUdFRXFCy+8QG2tPdu22aPRJLNyZUu3zvhuU2N6fmMhRW1lJerijNVo+3hFIiW2tjmMGvUGYWECG5eRUSOrVq0iOtqJpqbFNDX1JylpOVeuPGJwjZQUiIuD996DTz5R6dLY+vSz6q4kKUHPJx4WtlXHbz1mTDYzZ34JwJo1X/D55xKmTYP163N0x7m4hDBs2GpUKgFwNHEigJqOjsn84x8ud7x2RUUDZ8+aU1LiiqXlGWxsVuHhITB0VVae5vJlqKmBtjYB0CQS6Vu5ZDIbxo37OxMnihg4cCluboK0olgMxcX/wMkpRRftC0pg7zJx4j9xdJSjVHaQlPQx+/d/jkQSx5dfVvLjj1WMHr2p8953sn79fZSVXdSNVStNmJYmobDQlfR0M1JT7ZHJbGlvb2T2bCkmJh3k5VWhlaAcPDiMiIjP8Pef2Jmev4iLiwn5+VJMTIywtpYxcKB9t9kEY2MLRox4gcGDn8TBIRCx2IT6+kLy8lKpqDBDoaATLNaIiUkl5eWlfPbZZ7ecR0CVb8Pe3oOrV0N076RYrOTiRW+mTVuNlZUD7e2tHDmyHHf3wYwc+RJmZjY0NdWyY8ejv3qkLJXKCAiYxJIlpwkOHoKLixsBAYG4urrQ1tZKevpmTp+ORiqV4eHxOOnppajVSgIDpVhathuURIQ0uFi3ybCw+IIDB1651zr1G9k9h3zPflNbtGgRsbGxt+3x7WqrV18xSI1152zS0tJwcopjxgyhF9nB4VFCQtYaiER0rQvX1Phx6VIEHR1QUAAeHoJwxNGjJugVozQUFIQb1Jz1pq8/JyRoiTj0i+7dprYFqsleBAcfB+D06U/w959PXt4E3SIu8HonGxynUMjYt8+S5mZTysvt8PB4ksbGH9i0yfaO8+Tl5YWRkSUXLxpTWOhCXp6Y+HgnjIzsgDYGDICjRwWd4KQkYW7MzPStXMbGFpiZTSArS4ZCISMryxKRSHDKMJMNG4qYOfMic+c+jLf3Rg4e/BuTJ3+Cvb03tbVl7NnzMs8//wMjRpzl6NEz/8feeQc2Wed//JXZJE3TPYAuRqFA2atMGQ5AiKCo1XNvT6kg5znOcd55enc/z6v1FBcORAFRkFaGyCh7rxKg0J2WznSlbZKmGb8/0oSGttBCWZrXP4XkyfN8n+dJns/3+xnvDykpkxk5MhcAi0XP11/f5KqvduYwgJC8PB12u4iEhFeZOvVfyOXeKBQCnn02goUL/8/tO6RQBDF9+nvExExFJJJgMGQTGirhxAkfKitDyMqytJCgbD7pk0qVlJQ8w44dX6DVPoDd3kBxcQYlJafJznZkYDc0wKhR4ONj4+eff241dq9ShXPHHYsZMiSn2URRjNX6Gl5ePtx553colUHU19fwyy8voFCEMGXK35BKJdTWlvDjj/d3ulF2juvBB38iNjYehUKBxWLBajViNjeSk/MLe/Z8SGlpBbt3K6ivD6OqygeFwt9tEuOcTD79tIF5896kT59fyM3deFlc7h48Bvk3zaXqWXcWFxI82LfvS774YqMrpioS2ds0dFqtlmPHoEePVAYOXMDw4dvp1u2sgVar1dxxh5oePX4GICfnVjZsSOHjj2ei1UJWlgi5XM6UKQ04jbEjxrzHVebleN3J2fjzxIlOIY6zD90TJ2rbneyyb99gcnNPkJV1NzZbPZs3v0ZJiXsyU1DQd+zYsc71mcjISGy2ILZuDcFs7kpl5UicIi0CQdvJcecaORDyxBOv8sgjm1AoQvH3hxkz4MABOH1ahI9PIC+++KLbPerevQ/Z2SFoNL6cORPF0aM+AJjNNRiNd/Dxx37ce28UUqk3ZWU5bNr0V6KjEykoMJCXdyt5ecuprX2Qzz+fyVdfmXn44VRUqr4AmEw6vv76FnS6DKDlxC0xcR79+9/OmDEvIJP50NhYQ339d0RHu2cny2R+3HTTW0REjEEmkzBggIKwMDPHjhmxWiVuqmvnJte9+KKR22+XsmxZXz799D22bp3KyZMzOX78PWprZ3LsmKPFY20t9Ovnj9VqPW/s/m9/e5L58//GuHFLSEi4g27dFvHJJ1NITz/GHXd8g69vCGazha1b3wIETJ/+fpMBrOWnnx6jrq6kfV+kDqBUhjFz5id06zYcgcAx2XQIiNjJy9tEQcFKbDY4eNBGVZWK4uL6FpMYtRr+9z8f/vGPZxg4cA4ikZyKilx++OG+Nrtdebg4PDHk3yjN63VFIhH9+79MSMjdLbSorxTni7u++aaIY8dudatdPl+J1ezZtxIcbMDXV86JEw306FHGiBGO9x2Zy7B583scOjTXlUgmEPwPpfJ1N/3pCRPeIjNzGjEx65gypY7jx0+QlzcRsdhAebnjIR4UpAEUREenMWfOTPr0Gc2SJb+walVPTp+e5cponTkTHnus7Zjy2RpRx/azZqnp2TOVujoZu3ZNRyodS3R0GjExqZSUwMCB/2T+/BcB93tpNP6FmppncU4k5s4tJDk5vM3rfm6JWEoKrFmjo7HxRaKiVgBeNDbeSdeuca2WczU/tre3Fw8/PBKF4iANDWZCQ3szc+aHbN78d7KzNwIiZLKefPTREcTif3Pq1OOuycbUqQdYuzae6uo8vvrqVmpqTgDg79+Hhx7aiErV+jlYLCaOHFnCvn0f0tjYQFBQNLfd9kWLuKvBoOOXX16iuPgQJpMFubwPI0Y8x/Dh41zbuMdDLURFFZGf383lnfDz+5mqqrO5CN7easzmVEaMCKCsTIHVKrlg3+C6uhLWrEkkI2Mj9fVVmM1gNguJinqRZ55JZPXqx6mpKUOhUBEefh96vZXi4kV4eQmQSpX06vU81dWWTteYNpmq2bbt3+TlpWGzWRGJhBQVlZKVVUhxsY2dO61IJO767K1hsZjIz99BWtrfqK/XI5crmDLlLaKjJ3hKp86Dpw75OqSzBN+ddcUREfmMGmUjK2tmUw2w40FzIePRmaxb9xGLF69n2bKUFg0QnGP96qsBSCQOmc49e6ZgtWrYtOm5Nq9BcyNht9sxm/VMnOhDQICOTZtsqNVQUOB+zk5xkubX9s03HSthg8HRy7dHD4caFZwVyQA4fXom+fmTkMvTOHPmGBMm/J0NG+IoLo7D0UsYnAayrYnE/PkOmU7n6rpHj2Ruu20BRiPk5ARhNutc2uFWq6Nu9N13tzFw4GDXddJqtSxdOpJvv/VvaglpZfz4z0lJuQU/v+gL3gvnpEAkctSqPvbYU4SHf0VpaSPr1qkQCPxbbUTS/HsZG9uLXbs+5ODBj7BY7KhU3QkMvJOqqtVUVh6jsdGMRlPL9u13U1T0lev6/+EPf+C9914mJMQh0vHFF7dQW3uajIyZFBcnMHZsOPfcE9DqPXc3yo3I5WGEhj5Kz54DyMmJc030br65mk2b3kCr3YndbsHPbxg+PtPp3r2PazLSXDhj0qQktmyZ55okde++mtzcWwFxk4FOpq7uT6hUAahUqnY3fNi3L43//ncaPj4m/PxoMsoi7r03lcGDhzQZ7INkZxdy9KgMs1nJPff4YLfXkJ9fxaZN3ohEvh1uCnMhzOY6du1KJjNzDXp9FcePn6ahwYZUquDUKQk5OV4sXLjQpc9+PvT6QlateoS6umpkMimjRs276BaUvwc8zSWuMy61Q1NznHrWo0bZEInctaYBUlNtpKaev7b4UmiuQqVUPkNW1nsuF69DC1voOq5Wq+XQIUfpTXh4KuPG7WP7dgFa7ew2DXJzOUpnJvfhw3Zkst4UFmbx5ZcWnnrK4cbOy5vImTOH6NJlJNOnu1/PXr0eJz39M4RCGDIEliyB++47+77VyjmTmfkEBb3H11//wSUn6szKdrq209JErV5Th/TiWdd0jx5pHDvmi0wmR6NpoLwcBAIfhg2rBaB//1rWr19EYeE01yTCUX/tGKdzP926rWHlyu+5994fLyjL6Ci/cgpHWCkvfwyZ7BMEAujV62b277+Jf/xjL5Mna9yu/bmNCOLjn6SxsZ4dOz4gN3czZWU7OHkygLvuCsXbu5K+fRuor1+JyWRDIBjDTTdtJiYmheXLD/Hgg7/i5xdNaOgWPv9cw8mTNyMQWNi6VcxXX93LjBk+zJ071+14YrGMwYMdN2bNmr9y/PhxKiq2s3v3fRQXL0IkspOUJGDlSgXTpr3Jxo2vc/DgDxw69CXZ2csoKAh2ZQ6vXg0bNhgQCv9F166fExmZjk53FyEhKzAaK8nNvc11bceMSWPgwOmMHfskUVHd2z1J1ukM7Nzpzdix3tTV1RMS0ojFYmXXrufp0WMJUVFP8tNPM5FILAwYIOLwYQFff13BuHE12GyNjBrlx4EDNpKSktrVFKa9SKVKxoxx/Ab27FmCzWZFJlNQVaVAJApEIKhuoc/eFs64+erVj1NVVciuXe9iNusZOPBej1G+BDwx5MtER3sEJyUlIRI1MnhwCXPm5JKb+xzr1n10Ucd26llv2eIQBXAKdTSvCRUKrZ1aawvw/fd/4p571K4s5M8/n0l+/kxXDbIzRty8BtmhTx3BwYN+lJQEkp4ubFcP4HMzuQUCAdXV1ahUKoRCX1ecefLkBYwf/2OrYhrV1QOoqnL821HS44ip2myO/wuFuJK9zibrnBU4EQis+Po6sqKdr3Xvnt/qeNVqWLGijrFjvyAhQc3YsakUF3uxfz+AAqUygJycQH7++Sl+/fU9cnJmUlDwP5599l7UajWPP57K/PmOfb355reMGvU/l+pWQcEOtm37t0uUoy2cwhHOJLKAgKXs2iUnO/sONm5cjl7/EGVln/H99+ffj1SqxN//Zg4fNmC3g7+/ncBAC999V4GPTwxKZQDjxgXx4oti3nyzkQceGIVCEUh1dQWrVj3OihV67ruvKxkZNwI0U+cazjfffMrUqVNb9N8Wi2WIxYPZvbsOm02ISiVGIBiBo4GDQwxj9ep8ZDI/wsLuIj29BqtVQGSkCJWqwXX/nfHQt99+li5dhtCv3yamTJnL7NkK4uM1JCTcx6hRH5OQcC8jRmwhOPgk4eG1xMb2Ou81aU5kZCRisYr9+xWUlYWzcWMAIMFqNZOa+hRa7XF27lRgMgWh18sIDlZSVWXll1+kNDSENnWa8jlvvfnF4jTKvXvfBoixWo0oFBa3RhrtRakM47bbPiM4uAd2Oxw9+g0azfcX/B56aBuPQb4MJCc7koseffTRFqICreFc0fbqJWbAAFwi+fv2PcPjjz/NQw9ld6gg35nQU1zcjf/8R0BOjqNDUs+ejuwjgcDhspO3bC500SQnJ7Ns2Wk2b/6ra/9gITt7Ij16pDJ1qhq5fBGvvXbAbQUZFxfHs8/+idxcf7Zvl2A2yzrcML15QtDWrVt5++23SU+XYWp6LiiVtlYfbgKBiFWrHOU/R45AQQHs3g2HD4s5epQm5Sd31TGBYG2z/4uYPPl57rjDIS5y661qevRIb3Occ+Yoee89GX37bgTgoYdUfPzxe6xfv5433ngDg+FGTp5cyNGjc0lJSSE/fyaTJ1swGifx+eczXclI/frdxqOPfk9s7M9NezZz8OAijh///rwJNmo1LFtWxQ03fENCgpqoqPcxGGaxdesbgNV1XhkZARe85iUllRw8qKCkpCsVFQHY7UHo9RZCQx8mKKgnJlMV2dlf89lnr5CYmIzR2B+5XE5p6XEWL96DUGjDbj/bFtFuFxMTk8Ytt4DNZmp1AlVUVIZGI6WgIJLS0iAUihM43cuOUMA76HQZlJXp2bdPgV4fQm2tAl9fVYv7r1SGcccdX9KlS3+sVhvZ2b8QG3s7Y8YcZNasfzF8+EECAsIxGg1s3vwaublpF7wmTpy/P5tNzPHjdRgMSnr3fonQ0HDMZhMlJYvx9vbi4EEZNTW+FBQYUSgUiMV+HDgga9FpqrORSpWo1W8QG3sXDidpFf36VXLzzRM6vC9n0liXLgMRCAQcO/Yt+/d/jtlc1+nj/j3giSF3Ms74bXBwKWPHGjAaYffuQJYsSWvTyDg/IxI10qtXIQMGOF4vKJjZFHt1PHA66mJetWoVDzzwAEJhHU8+6TD0W7f+vamDk+OB2Blu61WrVrFgwZfk5qbg1L92/o2Ovpdp01axa5ccvd6vzaQYZ5yyow0oztWI3rIF6uvLWL78Z3x9t3DjjSns2+eFwaBscWyNRsPEiROpqalCoXDEkqVSGUqlktraMoYNg5wc6NNnJnq9oyOSWLwWkSiRvLxwunRJIywsFaXybOw3IOApZsx4ps17bbGYWLXqIU6cWAXY6NnzQfz9byMqqjv/+lcY333n54ozDxyYzIABr7N16wcUFNwPOFz+iYlCXn01i6++mkJtbQGO+LUEiSSAHj2eJy7u/C38yso0fPXVjRw+HM+yZT9x1u3uuGdPP/0n3n33pTb1llNSYMUKHRs2vIy3969ugh0pKSno9UV88cUMRKJG7HY5u3f70dAg5qWXhlFVdQiN5ia++upzl754SMgexo59m169HOIjJ08GcOSIhM8//8Klew3wwQf5vPrqJmSy3XTrdpCqqioMhhuZMOHP+Pj8k+jolfj6BjNkyHs89FAiAoGV8HAFhYUG7HZRq9+9uroSVq16BJ0uE6nUm9jY2WRk/IDBYEAmUyEUWjAYavD2DkKtXkjXrsPanbx0bk6IXl/Ijz/ej9Gop7y8hmXLjFRX21xNUux2e4vGKZfSwORCWCwm1q37D9u2fURJSTEVFTIyM4OZO3dBh8NlJlM1W7a8SVHRIYRCIT17TiU+/hmPgEgTHmGQq0TzfsReXuDn5+hHvHXrK20W0ztn1FarhCNHwli1KhJv71vIy5t+Tuy1Y2Px8vJCqVRy220K12tms3fT6u785UXtJTk5mb///XYCApx1vA5jLBYf55ZbPkIg2MOqVX7o9X7nXfnGxcVRVTWYxMSoNvWkm5OS4jDYt92Ga/vbboOkJBuffRaCXv8QBQXfsGrVLAwGZavHjouL4/XXXyc0tAsikS+hoV345z//yaZNm7j//ic4dsyX0lIR+/enMn78Avr0SaV/fyV33NGbqVP/zqBBDsEMp4hETs5Mli7tzc03/7dNr4hYLOOWW94lMLAnYOHAgUX8+c8Ot7RMtttNrlKh2EZxcQiNjTtwrGSsWK1CJBIDAQG9uO++NSgUXZrea6SsrJQdO17k7rtvOq9XJiQkjttvX8zRo081veJ4DAQEnCEh4Q5CQz9k167/tLradiZGLV0aQFnZZ9TX3+Qm2OHorGRh40YljY0qjEYx4eFSamsbCQy8i7CwocTFbeKmmz5xuf3LyuKpr3dcR5sNevasJDTU3qJ+ODExirq6Bykr+4zc3AEIBAJefXUgK1bE8PrrD+Dt7YNer+PEidd5+un7sNtFnD5djd0uavO7p1SGMXv2F4SExGCxmDl1KoW+fe9GofDm8OExrFz5KtnZszEY9KSkPElp6bG2v5TncG65nyPu+g1yuYrgYD+efTaaF198hj/96U9MmjSp3TX7nYVYLCMi4hYOHDBhs0lQqbwICGhoUyv9fMhkfkya9AZRUeMRCkXk5W1iz54PPSvlDuJZIbfCpWQ7N18h33CDATjrgs7OfpD6+sdJSBjAnXe2vI6tlag4smJb79LU3rEoFHWMHFmOWCxk9+6ZaDQ/XfQ+W9v/HXfkkpvr3rYxJORxNm16DqDd1/Kmm1awadNsl+t03jyxW5tIJz/+aGTOHDkCgR273VkzfDY+fra22Mptt2n5+9/rz3vstu538w5PDQ3foNfvoa4Odu6UERZmYtAgx3bV1ZHk5w9yy+oOCHiYrVsXtHnctLTVrFw5C7EYDAYZmzYFYbVKeOSRb1m//hAREb8QGprK0qX3YDLdSHh4N06cuKVFt6ycnE0sX55AebkOsRjq6qCkRMaRI13OW6Jjs1kYNy6H3bt7u14bMCCNJ59MRKfLQSZTcc893xMZOc7tc81Lh8DG2LFlvPLKIbdr5+7xEZOVZXGVDEVHB/Hjj/fxxRd/YMeO+10TkGHDkomLW4BM5ui6FBQUzYIFu13lTedKOM6cmcNbbzW4jmmzWTh6dClbtryGxWIjNDSGPn1eobKyoV3fvbq6ElavfoTKyiKkUhk1NW/w4ovTXN6pp556npiYdfj6BnPnnd+1WabVHhwZyo+Sl3eSzMxytm3zRixWdXpWdXtYu3Ytjz/+ML17+yIW26iu9qawsIxFixa5eSfai9lcx549H5KXtwkAubwvMtkEV6b77xXPCvki6Wj891ycq93y8lBWrPAjKwtkMiEZGTP55puvWLVqFHfdpWp19XfujNqpktNWl6b2jsVgULJuXRgbN0bxxBNTLmmfzXF6AxobISYmlVmz1IjFyfj6PsCrrw50ZeeeTxSkOUFB35zT8af17b799nDTNs2NsZDmxtipsPXwwxfOjm1rjM07PA0Z8hJVVQ6JyaFDG8nMDKK83NG+r7FRy8GD7slfev0APvjggzaPaTBI2LVLjsUixWSCXr3EGI1Ghg6t4rXXCoiN3UBp6UzKyr6jru5BTpy4BUec11Ezu2ZNGQDR0TcQHHwHjY0Ol7vNBlu3mtDpdGi12jblSIVCMc8/37XZ9YP+/d+jb9+78fMLw2RyiFVUV+e5fc4ppdi0F3buDMNgcK9fdvf4mNDrpxIV9SM5OXFNK9Kv8PYWYLOJccaue/VKIzpaTvfuw4iIiMTbW0Jq6h9dXiXncZ0JaZMmFZCTE+c6N6FQzIABdzJu3MvI5T6Ul+ei1X7B5Mlj2vXdcyQofYFKFUJjo4Fff61taj3puJ9ZWaOQyWTo9RVN5T4XL+KhUoUTFfUkeXmlCIUmJkywIxI1XtTK9FKJjIzEy8ubvLxGKipU6HT6S4pdS6VK4uOfITp6Crm5eaSmLuQ//3mAWbNmdPhZ+nvEY5Cb4Z7tLCQ2toKPPvp3h38kTtfThx9+y9/+doxnnjlOZeWDTQo5HXM/X6hLU3vH0twNdqn7dOLM5t65U4nRKCIn5xcCAv7Nl1/O7rC7LTk5mbAwR6nS4MHJPPZYapvjk8n+20wqE7p23Ufv3qn067cchzF2qG09/nhZi31cbCs5g0FCeroAux3MZishIVJ++cWR+CUUQmCge/JXv35prFmzps3vTmRkJNXVIeza5UdpqUPm0WabwdKlI9HrX6FLl0Hk5U1pJqtpA0Su/RsML1JXV4JQKMbPbwJZWQ63udkMXbuC0Whk+3b/NuVIU1Jg504l8+friI8/m7G9ffubeHlNRiqVUV2t44cf7nczPmo13HqrBacRFwgsrFhxssX5Ob93jz+eSlnZZ2zbNtDVLSgtLZx16x5ylY7Fx79FREQqYMRsLiI8fBhSqYiioqNs2vQmZnMdajV8+20pN9ywhISEuzl69LsW5yYWyxg69EH69bsLiUTCmTMH2bMnud1Zv073tbd3ID177nHpdTsU1JZjsXjT0NBAcXEOa9Y8c0l6zvX1Eg4dkiEW+yAQWF0Tss7Oqr4QzsmTQCCguLgYgUDQ4aTKc5FKlSiVN7BvXxlWq4DgYAVK5dWZcFxveOqQm+Fc8Q0eLCMqKg+VCnr21KPRtOzyciHOrd185plYNmw4636+lPaDHeXcsXTmfufNm0dSUhLLlzsSUf7yl/ntEhZonozVo4djIjR1KvTqlUpISCrr13dHo2l9ddunzw8kJKjJynKoau3Z86rrwTl69FtYLArCw9PYt28Xycmvu9yAzYUxkpLaFvFojcjISM6c6YZIVIdY7E1GhpHycgGnTgXQrZsJi2UDffqoUSodXZW8vVPZsCEMrVbb6jnExcWRmPg8SUlJnDljxGabQVnZZ3z7rZUlS0TMn7+W/v1fYc+es0Z+2rRfqKo6QXT0Fnr1SiUlRc+cOV+jUPixb58Mu92EVOoodZPL5Zw8Geb6vgmFFtasqUStDjknFBLEokW3UFDgCC+YTI0cPPgZxcVyRoyQoNNlsWHDX5gx431Xgs4TT4hZs+ZsLbRQ+F8qK/9GQECvFue4aNFZIQ6h0MKHH1ZTURHUlFTomGDU1yuw2RwrfIWimDNn0gkPH0hJiYa8vK0cPPgZI0Y8zb33hnLzzfF8883fWLHiBYRCC1aro+PX+vW1qNV+iMUyqqoWsHHjaMLCUpDJ1hAc3I++fWe1KxnLGecVCh+ipuYBjh0bTK9eaUREpJKXB/n5EBgooqHBiFz+Cjff/O8L1n+3RlRUd+rqAti/v4HwcGmruttXiuZ1/Z2lEFZSUsnRo1L69g3EahUjFssxGkvb/D14cOAxyM1wrviyshyxL7CgVMKpU3/m559zmTjxtYtuleZ0P6elOYzx1ZCvvBxczI95xQo9d93lyGBNShLz2msmjEYjGRndGDCgjIyMENdqoTUpx8pKiI5OJTAwlZ0733NzFVssCiZNWoDd7mhW31xcwdmX2KGX7S5QciHi4uJ45pkXmsmRylGpBJw+7Y3BEExVVTXl5ak89FAqvr6OWK6Pj+S8D9jm186hwGVtUuCy89//BvLpp3Opr7+HvLwRdOuWRmhoKmKxo4cxQGbmKtasGUBxcQhyeSAnTljo1k1Afb2doCAFU6YIWb1a6IqDCoX/wmL5B1u2yJoZaisHDoQyffo7bN/+MkIhBAVBbW0DR4/aGT5cQV7eVn7++V28vIYRFdUdtTqOb78t5eOPU+jWLZXY2FS++eY4jz76S4vfh0MQReQaw8aNQQiFdux2oUsjvHv3NI4f9yUmpqYp272QigoFISF9qarK4/Dhb9DrFVitEURGRjJ79pdoNEvYvftsyZPd/nfq6l5g8+Yw7rxTiVA4BZvtZp54Yh4i0X8ICOhJly5D2nWvVapwunVLwNv7jwwZ4gijWK2O2HZEBOTkCLFYylCpDrBixTP4+t5Gjx79OmRo4uLieO65+SQlJXHkyNms6qtlrDp70u7s4JWVZcPf35uqqqqrNuG4nvAY5GY0X/H98osXkydb6NIFwM7Bgx9x8mQqQuEn5OdPadG7tj2o1b8dQ9ycjv6Yv/xyFwLBjU1GwkJeXjRyuZy8PBtGY5+mGkxpix+vM6Qwdarj/0YjdOu2hSNH5ruMcmRkGgKBo13hsWMzKS2dwfffm4iLcxoHYZNASdsx6rY4d/KxefNm/vGPYxw4MAKlcj8zZlRRVvYjKhUoFPDAA0PbFb9ursDVPCFt//4gZs8O4sCBBa6yKqNRSkmJmbAwx7ZbtrzJzz/7YjSKEAgE5OVJkMsVTSUzUUREWFm4cBUBAd8SFraezMyxTJp0O0lJZw21UvkZAkF/jhxxKJYJBBAZaWPv3kak0i7U1mazceObbNmioqEh0JV8FB/fg2XLttPYCNXV6axdu4BZsz5xK3VxTkR/+CGXAweyyci4sSkua0WlOsINN7xJ796pnDolJy9PTkiIHKu1kqqqYry9g1EqQ8nPP8ShQ8+ycaMPQqEfzz03l8ceG4bd/gQnTw6ge/c0unTZxJo1hezY8TVCocS1Is/KGsWAAZtZt24esbF/abdOtMkUxMmTUiIifCgsFFFZWU5MjCM84efnRV5eI0FBWjSawxQXryQzM6TD5UKXY2V6rdD8WVpcXHzVJxzXC54s61ZwZt2GhQVQU7OHPXv+jtlcTUbGrW1qMntoP/fco2bZMvdGEnl5DunQqqrx2Gw3cPfdIXz66Qy3z61du5ZHH32UadNKCAqCrCwICQGdbibZ2RMpLEzj4YdTycqayZEjj7rJIDrv1T333Ete3nCiow+wdOl3l3Qe52ojr14NAQHr2LLlQWy2ciSSbvTt+w9iYoa160H0hz9s57vvxrsyqefOfYkbbxzKkiV3Ex3t2MZigV9/FTNnjhyTqRarFXQ6CVu3dqGhwcorr7zSokmETpfBV1/dSH19EX5+sTz66GbWr1fy0UcrCQ1dSb9+2xk37jOefHIew4YVEBHh+JzZDP7+D6LVfo1EAhaLN1u3+rsypvv1i+WXX15k377/AWZAyc03v82oUU+3cA9bLCb++tdv+Mc/Hnfdk4SEJ5HLP8XHx5GMFhr6GN2769Bq92A2l6NQRAOhnDy5C6EQGhv92LnTB5tNzA8/fEdh4TdkZq6nrq4EgUCARKJEIPiIl1++3TXZePzxPzJkyGHKynLIyalhyxZluzKaNRoNs2bNQKlspLJSTVFRb4YM2cLo0alYLJCVJUckshMWZsFsVpCVJae8XHHB5hO/NzpLn/96x5NlfQk4s26HDo1n0qR5PP30QeLi7qGgwFkXLLqoumAPDpdzly6O5K0hQ84mbyUmJjJ//haqq7+mvv4hPvtsRovEK2dIYd++YHQ6FQcOeGE2OyQyJ05cgMmUyvr1Du3p3NyZAE0xzrN9i/v23czUqQvo23fzJZ+LozeyMz7qkCIdN24a48e/CEipqjrDl18+0e5s/UWLBvDYY08zatT7JCSoCQz8LyqVF+np3cjIEGG3O1avo0fbEQpn0tDgWLEplY0EBZkwmUxER0e3ePAFBcUyfPh8pFJfqqvz2bTpNWbNErNs2VCGDt2PzaZHo3mdJ554hMOHu1Fa6viclxdotV/z448ONbOyMpNb8pFQKOaGG14mOnocjkdJHdu2vUtx8eEW5yYWy3jlldk888xLjBqVTEKCmr59l3PLLX8iLCySoCB/AgMPMmnSXwgJ6YVA4I3BkMvp07vIyYGMjJls2/ZXvL2nYTQaKSmp5MYb3yQsLBaZLAS73YbNZkWheIMvvsjkvvvyePjhR4mM/BGTyUhBQRlicQNjxjhc5RdKMHLG+IuLp1NQsBCbbS4HDqRw5MhtCAQweLCE0lIhZ85EUFYWhM0WelWSsq51OlJl4cFjkNuFn180d9yxhKefVjc94K98YtZvAafLuaHBUSYVH7+ATZuecz0Y9+0zu/SuWxMtcS/jUmCzBZGX53hPIoGpU6G62ilQclaW0WYTk5XlbEqvICNjJuvWvcEHH7SuO91eHL2RRa5JmvP7oFSOIj/fjNUK4eGNSCTtE1uQyfz4+9+fZOrUl4iNTQXMnDr1Nk8+OZfjxyNITxdjs0G3bgJ8fWs5fVqI0ehwzyuVZdTWVrF9+/ZW9x0f/yjduo1EJJJw8uTP5OZuJiQkjhEjnsfLy4fKSi29exezbNlPzJr1FeCD3Q6BgRAf77h2ubl2TpwwuMUCFYogZs/+muDggQCYTAWsXv0se/ZsaqHlrlAE8dZbT3HnnR8TG5uK3V5DSUkqt976LgEBodTUlJOW9jYWSzIbNyaxdu2bHDz4Hnl5f2fnzhTy8p4hPf0TbLYZREZGolAEMXPmJwQHR+Dl1RW73YjRWElj4/38979wzz3dmkqVtJjNIBJ5YbPZCA9XtMt4JiYmcvPN7yAUWl0TOx+f1+jbdxR+fv4MHWpGqzVRUeF7yeVCHjyAxyB3iD/8oSurV8Nzz12+Tkm/ZZxZ7OXlUqxWKC+Xuh6M1dV5WCwvNWtCIWh1wtO8jOuVV14hMzMIvd5RjywUQr9+Z8uPwFESBbBmjZXbboO1axNZtiyFvXsfJzExigEDcjpcAuVErYYHHniSUaOSeeCBJ13fh7IyPWlpvphMMsxmMf3706oBaK0EKyxsMKNH/8n1/5KSfUycGMzq1ak888y39Oo1GhCRmZnKiRM28vIcruUuXaB7dxnLly9v1fDLZH6o1Z/g7x+BxdLI+vUvUl2dh073JCtWrGPZsuWsXNmIt3cZMTHD+PlnG/X1js8GBYFKBceP22loaFkWo1KFo1Z/jK9vd8BOefk+kpOn8uSTD7bwDvj5RTNt2ntIpY4a6Orq0xw69DGxsXfj5SVh48ZgnnpqCNu3P8C+fa9y5Egi+fmv4ihlc9zXvn2fcFO/mjr1vwQGBuLlFYbVWkt1dRG//PJnRox4hO7dJyORyFGpoKxMgE7nT2Ghod3G8847g1zxaJtNTExMKnPmfExYWDQREQGMGlWJTqftlHIhDx48BrmDdFYN77XAxdbkXixOl3N6eiB5eaGkpwe6Hozr1z9PbOxKEhLUxMd/wQ8/GNu8xk432IQJE5BIfNi+PZjSUj80mhB69UolIUHNqFEL+cMfHiEycrdrBSsUWtm/370VpUYTfUGZzvMxYsRhoqPTyMwcyvLlVa7zhAA2bQqgsjKY48cdZUjZ2f1d19sZf3Y2jFi1yuza57hxzxMYONT1/5SUF9Hri1Cr72LQoNcoLTUjEMCYMV78+isUF4PFIqZ796Dzrvz8/KKZOfNjfHz80et1vPji/7jzTiWHDo0iI2MaX3/9Bf/+9zoyMw9SXu7Ftm1QVASZmVBVBb6+vixcuLDVGvOuXYcxatSfEYv9qa+H4GAL/fubMZtbNoqIibmRQYPuAVSAnfz8/QiFNrp2HUF29uhmEqx2l7xm8xrs22+vdzt2WNggRo9+AT+/EAQCH8xmPZmZe/jll3e56aa/ExU1iOBgX0JDGygqKj+vlOa5qNWwcqWZWbP28dBDj9K16xfs37+IyZPfJCKiN3FxvXjhhWF8//1ioqLmtuv3dKV/dx6uHzwG+XfKJ58cdjMIV+Lh4HQ5m80ytm8XuHV2yspySFTGxqby5psy7rjjwq2onPszGr3ZsEGG0ehNcLCI2NhUpk37B8OGHSA6+uyK2RH7b9mKEmwsWnRx51Re/iTLlqWwZ8+jJCT4k5JydlyNjV7s3m2jsdGLG29MJjExiuRkx0r9888dJVg2myPbedWqHNc+FYog7r13OSDDaIT6eh0ffjidJ598mPT0XPbulWOxyNDrpfj7i9iwAYqL/cnKsl1w5RcePoqRIxdgsZjYu7dbs+sAYEOjiaGs7Gv8/b0pKfFjyxYRhw4BiHnqqada1Jg7jcvPP4sZNuw+lMpB2GyO+LNYrMdg0LlUw5yIxTImTnyJHj3GAnKglmPHljFs2CMMGZLTdH8c4i7OBLfBg98iLi6ZmTPVmEyPuimICYViYmNnEBk5AbPZTHl5DeXlxWze/CELF/6dmTM/JTx8AJGRXXnssV4sW/ZFh4RrZs+W8u23/Zgxw4ZYLCUraz1lZccZMOBhfH0ViMUVLF9+ol2/J+dE7IMP7Ffsd+fh+sFjkH9HaDQaFi9+lTffFPPVV2lNRkp4RRPU2hLQt1qrMJmgtBSeeuqNdsvsnbs/haInAHa7ndJSAxERjgSyoUOTueOOJEJCkpk2TU2vXs2fhELXqrWjVFQkuNVBb9xoanVc3t4z3BLABAJcgh2O0iP3GUFRkYmtW0XYmuxlUJCVtLSvePPNN9FqpezZ40dtbRfMZh+sVjHHj9uwWiUXXPkJhWK8vAZz/LiJ8PAtuD8ChERHb6Sy8hQDB96HwfBPamruIjAwlBdeeIF33nnHbV9njYvDCK1ZIyUs7D6Kix0iH35+DqERo9FIQ0OD22cdsecvCAsbDEipqclk5coXmT49kqeeep74+A8ZP/4thg59n9mz1UyZ8hq9er1GZGQqRmMpKSl/xGSqdu1PLJbh7z+VjIx69HoQCoWIRHDq1JecOHGKCRNeIyAgBKnURFnZqg43PZDJ/Jg27f8IDe2NzWZh796PCQ7uQXT0FMrKSlm71uj6PQkEFn75pabV/Thq4e1NPZxtru+Lh9b5vXkTPAb5d0JycjJ33nkL6en/wGSyulaOQqH1qiiHNc+81Gg05OTYsFodcWCZrGMye833ZzDUUF8POl0ZX3yRDTgSyCZPXkBGxj+566676NYtlTvumE3PnqtxrhCdWdLtxfmg8PX1dpPMbGg4O+7m4zo3Aezee6tYvRpuuOF7EhLUdOu21E2KUavVkpkp5/Rpb0wmR+JWnz409REWUVYmIiNDj4+PPy+88AKLFy9ud4egkpJK9u5VEBa2mVtumUV09E/07PmTSz4zPX0YP/74NgbDo9TXf8fYsf/i7bffbrGf5kIrQqGF1avz8fHpwoYNUsrKoKYG+vZ1uOu9vLxafF6pDGPy5L8CXtTXQ3HxUT7/fC5duuQxdepfiY9/jRtuWECvXqnY7RASYiA72wup1JuSEg0HDnzm1pFKpzOwc6eCiopwjh2LxmJRAI1s3vwSx4+XERAwCqFQTEHBLo4fX3He3tGt4Ugi+xSVKgyTqY5Nm15HKo3n+PFKunTZ7PY9MJvfaFXv2qHJLWiaiAkJDv6x3dKevzfOhnWsvxtvgscg/w5wZjfHxOgRNt3xiIhU/vSnz5g7197uBLXLNVvVarXs2qVEr5ej1QYQHKy8qBISjUbD1q112GyO8qCBA2HnToegBkBcXCkTJkwgIqIHcjmMGLEIELbIkr4QP/5odLkd334b7r13B6NGJXPHHWrk8pe5/fbpLVb4ajW89tpnjBr1IQkJavz930Gthuef305s7AYsllIOHPjEtX1kZCQSiQ9798rZudNRdlRbC5GRSiQSCa+88opr9f322293qLQkMjISkciX7dt9USj24+v7CFOnzm7K7IbMTGemusPApKWZWp0cORs+OFf5UukHBAUp8PHpxr59wRiNgVRUBBMUFNSmG72+PoD9+600NDgy5UNDTaxf/yuHDxupqcHV3lIgcLwfH9+byMiRCIVCjh79zq0dYmRkJGKximPHxFRX+3LkiAK7HbKyDvDZZ4/z17+mUFUlQyAQceTIN5SXt9TgvhAqVTjTpiXh4+NHbW0FR4/+lwMHJHTrto0pU+6kT5+F3HqrmvDwL9iw4S8tVuJqNXz/vZ6bb07lgQcexNv7DXJz0zo8jt8D7mWFFjZsqL3aQ7rseAzy74CzXZl8qKuDxkZYt07MpEndSEoSt8sYL1umu2yxr8jISKzWYH79NZiamhAKCowXVUKi1Wo5fVpBVlYodXVe5ObCvn246mptNti+fTtdHPJrxMY6E8CSeeCBJ9qdqPfDD5lNOsoCRCIQCHoyfPgCYmJSkUqha9f6Vlf4f/7zTO6++wNiY1M5fXozZnMdEyb8BX//KMDO0aMrXKtkZxxaJPLi2DEBW7ZAVVUQOp0jTjxhwoSLru88N8at1/sRHDwVcKxiJZL6ptWeo9ynb991rU6OnCpcs2fv4777EujWbTENDfuYN28eQqGS48clCIWt96J2UlRUxtGjCvLzQ6mrkyAQQFRUHbt3m6ipcXxfJRLHdzYoSIZSaaB792n4+0fQ0FDPpk2vtLhmzkYJJSUSCgokiEQCunQR4OfXyJIlZxAKVZhMBlavns/q1Us73PCga9dhDBv2LFKphIaGQmJiBOzZo0Ch2Au8jVS6EYnEm7y8rRw9+i0//WR1m8jeeaeK5ctHMG7cKWy2RjZu/EuLrloezpYVOid8YvG/LqnL1vWAxyD/Djir0S0iNzea1avDqa+PaLfBy8nZxPvvL3eVI4lEdGrM2fkgbU9D+fPh1M89dsyL7OzuVFYqsVjg9OmZbN78HiUlM1m+fDnZ2QL0ekfrxOhoh6hIjx6/tPs4gYHfudryWa3Qo8cZKitxxXvFYlmrK3ylMoyYmFsQiRRUVGRy8uRK0tLC2br1K7Kz76KyMouDBz93bZ+YmMj69et55JEnEAi6UVoqvuhrcy7nxrhfeOEbunQZSkbGTPbscZQZ2e2OTkxDhqxGqbS1uh+1GhYv7s2kSaVIJGKOHPmWBx5Qt5on0BpOT0B6uoyMjAhqax0GeNQo+PnnWk6c8KGiQozFAo5OXhZOnFjK0KF/RCbzpqwshx07/u1y+zY/r5deepVTp3ypqgpFr/dGLvdDr7fg7z+TsrIK9u7dxKJFDzN79q0dag0oFIoZNOguIiLGo1T6MmZMEHK5jf37G2lokDNu3CtERQ3BbrezaNFJZs8WueLszmx6lSqcO+9chlIZSG2tjpUr7//NG5uOolbDqlVW7r03myeemEtExAq3lpy/RTzSmb8TkpOTXY0RnLqy7Yk3/vrrYr744kcOHXqE06dvc81WL0cd9oVk9pp3iGrr2M3P0263U109gYaG712xPR+f+1Cp1nPzzRUEBTk+IxI5ynr69Xu/XVrEa9fO45tvCsjLG8uUKXISEsaTmDiKoUMNCIVw6pScY8fCWpVR1OsL+frrm6iszKGkJJGPP/4/l1vu3nsTGDEinYceWoufX3SHrk1nUFmZxezZ29m+/X5XPHTw4GRuu20BvXrdyt13/4BYLGv1s4WFe1m58kH0eh3du4/nzju/cdO0Ph/Oe1ZXpycgoIL4eMeKOD0dTp4UERXlzwMPKPHysmO365FK/QkLi0OliiI3dwNCoYxp096lZ88b3fb7wQf5vPrqJuTynfTps4vCQgN2u4h33/03H374BNHRdZhMMrKyFBcle2kw6EhNfYrKykLAiy5dHqdXr8HExcWh1xeyYsU9LF78CDt23O/SbX/ggUK+/DLatY9Tp9axYcPzNDSY6NnzRm699b/tvm6/FywWE3v2LOTw4UXY7RAZOZqpU//vorpsXS080pke3Ggru/l8JCcn8957P7Bs2WoyM28FYMAAAzNnXp4xnk9mb8UKfbtc5s3Pc+HChXh5TQWcdccWrNZxmEyQkxNKQcHZz4nFtDuRbMKElxg27ABTpy4gIuIb4uLimDHjL1RXO94PCTEyd+7jrZ6HShVOv3534+Wl5MiR7oDDGIOV/PyJ1NTksnjxI6SnH2n3teksAgJ6MX16qFtyUp8+B5BKfSksPHbeWGfXrsPo0+d2vLxkFBenc/r0unYf13nPnnlmLpWV/uh0EdhsgahU4ahUKhYseJNZs/6NUulNY6MEm81AWVkm3t7++Pv3oLGxgV273nNbOaWkQGJiFLW1D1JauoiMjMEu74JMpuDUKTEFBeGUlQVftOylQhHEDTe8hpeXBLu9loqK78jJOYFGo0GlCmfChNfo1++oyxjbbGLk8g/Q6wtd++jZcxL9+iUglcopLNxPVtaGDo3h94BYLGPkyMeJi0tAIvGioGBvh/pcX094DPLviI481DUaDcuXv0h5eXMhDStHj6pYu7bzapfbmyi2dOmRZi7zlrKazXGe5+zZs7nrrmCcyUkgZvp0BSqVilOnrGzdKnQZUbkcrNbSdj2Ulcow/Pwc7n6RSATA88+/wvTpL6BU+hIersDXV9umcR89+lkaGlRYrZU4BTBAhFCop7raxPHjW5g16z0mTjzc6Ql0F7rezz03hrlzX3HpTcfGLgV8aGw0sHPne26lRs0RCsWMH/88oaEDgEb27fugQy7YuLg47rjjDpRKP06eFFBUFExJiRA/Pz8mTJhA377T6Np1FCpVABaLFWggO3sTAwc+jEoVhF5fwqpVL/Hzzz+h0WiaMsBx9Vzu02ca33+/mLlz57pCG5mZ9kuWvQwJ6c/Ikc9RXl7Jjh3r+OCDh5g1awbJycl07z6BO+8M5IknEhk9+iseeOA+wsO/4+efE13XUSyWMXbsc3TpMgShEPbu/Z+bwfbgQCpVMnbsPMLDxwB2MjLWUlCw52oPq9PxGGQPrbJ69ceMHWtyE9ZwqCVZmzJrL712+dw61vMZH1/fxReU1WyNzz6bSULCQ00G5iFWrHjAlSxVViZg5UqH9KTVCkOHGti2bdsFxzx/Ppw4cTMCgZyysix0ugwApk9/Bbvdn7o6A2lpHzN79q08/nhqCwOYk1PCli3VmM3eTSpUDgGMykox9fVCzpyZSW7uYrZtG9CpCXTtud4ymR9vvfVHpk59iejoVEwmKC4uRK+vIz//MP/73+42DbpCEcTo0fORyVRUVOSRlvb3Dq1izpdLIJU6Okn5+3dDKvXHYKiiuDifjRuTsVh6UFhYyFdf6Xj44TNMmfI+dXWpTWV0tqa2nBsxGndgs1laJH9diuylUCjGYolm166apuPY8fc3kJSUREZGFmPGzOXGGyuYMyeJfv3SEImgqOgQGs0Kt2s+bdp/UCqDqKsrZ92659qc+PyekUqVTJnyBiEhMdjtVrZufes3N3nxGGQPLUhOTqa4+ENEIkcnpRkz1ISELGTIkLdcKw6b7dJrlzdsMLrqoC9k4Hv2XE9CgprRo7/ocPx6+HCHe3n48APA2WSp2bNnU10tIj3dsZ3ZDN9//32bK9vmdZH//e9r5OXdQ2Ojjk2b/gJAVlYh27eXYTaDRCJCKLyBzz+fyfvvOwzgXxybodVqycqSEBCwx3U97XYRvXqlUVQUQE7ONJdXonmnqvZwvhWwe92wtU1RCq22mq1bxa5yMZkMKitN7N8/mhdemHbeutDu3SfQo8ctSCRScnN3kJ+/o/2D5/yhFaUyjDFj/kxdnYHCwirKygo5dmwHS5YsZvPmeDZu/ImKiicpK/uMlJQUkpPz+eMfG0hMfBWhEF59NYyvv8694HE6SlFRGcePS2ho8EUgENKly1mNdqexDQyMRC4PQCAQAAIOH/7azZg4z00mU1BVdYa9ez/8TbpkLxWFIohbb/0Ib+9AjMYafvrpsd9UMpzHIHtww1mz7Ez1Mxph48ZUhgxJ5JZbXmsqE/ofn3567JKTuoKCljUTyzi/gZdIvIiNTUWt/leHjyuReLn9Bcdq7OGHH8bPz4/6+kCqqxUYjdHnjSWe226xvHwOICYj4yB79mxqKruSc+ZMGOXlIdTWTsGRrSwEHDXLf/kLLF06ksbG2ygq2s7YsfcyaJCjhrl371QCA6uw2Y43k/sUM368udXxnMuFVsDOumFn3XVExMZW9+MQJfEmL89hlAUCRwZ5fv4kN13wLVtaZl47ZDFfJjCwNxZLPfv2fdDh1d75Qiv19QEcPFhFY6OjLlsgAH9/OHbsbGhFILBQVzecnj2P88EHckaNmss33yxm+/b7eOSRGL7+OueCx+kIThf4wYMyysoCycjAzQXuMLYLUCp9kcnCEAis6PVlrFmT6HZtunefQEyMGqFQwOnT63+TLtnOQKkMY9asz1EofDEYqvjllz+5XcfrWd3LY5A9uOGsWa6sFGG1QkkJCARyevVyvB8RkcrUqRk8/viASz6WUvmmy8AvWnTqvIZWIlG4/e0IUqnU7a+TyMhIVCoVpaXeZGdHkp9/fi3oc9W2VKqTVFSYqKzM5+23Z7Ft2zbEYhWHDnlRXh6I1bqdszFiAWDl7bdh6dJAyso+Q6+fRnb2FmJjFzBgQCre3uDjY6WuTkdYWAq9e68lIeFe+vVb367zdEwYbC6Pw7kGU62GpUt1TJiwmISE2wgJea9VtSpnKdLOnSpOn3ZkPItEIJfvcNMFHzAgs9VxKBRBxMfPQ6HwJz//BEuW/KlFktrFUlRUxpEjMoqK/Dh4EDSamRw+/B5Sab1bMpq//27Xfdy/PxSRyOZ6/+uvd3RYOvN85OTEERn5IzU109i/vxGLRdrCBR4VNZYePaYil8sQCOSYzTVkZu5l9epXXSthsVhGfPwzBAb2wGo1s3Pnu7+p1V9nolKFM27cy0ilUior89mx413M5roOhcGuRTwG2YMbzprlI0eCKSgI4tChABobG2lsdLxfVwdff72hw2IKrWEyWYiNdfTDfeSRPhfYVuD2tyNIpRLAIa3YfNwXU/88YMA2evf+mfvvT2TfvveprBQglYJYbOL777/n7rvvBoTk5enw9t7M+PErcRpjRwze5pJOHDLkQRYtWsSDD/4XL69AACoqZnLmzDLKymZw6pSaQ4fu5rPP0tt1no4Jg9DlcYiLy2ixTUJCEPPm7WDAgC0UF2dSVHSgxTZnY6xyNmyAsjJH0lvfvquZNEntSvjS6e7myJGWnwfHaq+szAutNoudOxfxwAPTOlTr2xZONa70dDl5ebM5cCCFwsK51NS8iq/vWwwcmMyIEW8REXEzmZm9XdfFqShmt4sJDf2Bw4cXX/JY4KxXYseOIZSVfcbjj6e26gJ3GtvQ0Dhqa40UFZVRXFzEpk0Lee+9+a7tZDI/brnlP/j4BFFfr2P58kdISWk7jPJ7JipqLH373o1YLCQ/fzuHDn3Jpk0Wt7BMW5ri1yoeg+zBDefDuKFBTlqamPp6CXK53JX4ZDK13tv3YrBabW5/2yI5OZlTp45RXw+nTh3r8IO9oKCc+nrIyEh3ZcA6aW8s0fngPX58DKdOzcJiaaSuzkxJSTdqaxXo9WEYjUbGjx/vtr+NG2/m4YefJj7+fcaPfwu7/azUZM+e65k+fTo33vgUXbsOAwTk5U1yGVRwiJr85z+v8t13pRc8T7UavvmmkPHjvyAhQY239yutbjdx4uv4+ITT0FBNWto/Wo1VOuPs99//BEVFcmw2UCis3HCDkalT/0RERColJUd5+umprd6PjIwsvv02j7o6L8RiCWFhxg7pk7eF8/splcowm6cAZyU+e/eOZ9iwcvbvf5W9e+/i9tulpKScVRR75JFy7rnnTmJjU9m8+a+doo51tlmEwztRVdW/zQmdTOZHWNi9ZGTomhTIHJ3G0tO/YN++NNd2SmUY8fHPU1JS2iJz28NZxGIZw4Y9RHj4OAQCOH16LbGxh1zG2GYTIZG8e10JiXgM8nXElYqNnFvLGxQUxL59weh0KvbtC77oEpHmJCcnU1BQjMEABQXFbT5snDFtc1MY1Wxuf72w8/MHD+ZgtUJAAAQGtpS1bE8s0fngdSp05eYORCK5mQMH3mD37vvIyxO4rkvz/UmlSiZPLmDq1AVMmfIaTz75ApMm/UBCgpr+/dMAx4NlxIi5KJXhrqz25u0hBQILS5cebtf53ndfOE8/vY6+fX+luDi7VZenn180ffqokclkFBefaLO+OC4ujk8++YR//3sDPXrEExHRDan0DPv325vGDbGx1XzwwX9a3A+tVktNjZXTp3tRURFCdXV4p03knN/Pl14ahdMY2+1ipk3LQyZ7xbUSFgot/PqrEXAY5c8+68Kdd/oBAszmctaufb7DDSbO5WyzCCs2m5CuXc9ff63TGThxQoJAoKKkRIlE4oWXl5mDBz9wmxjV1vqya1c1VquEwEAvfHzMnTKh+a0hlSoZP/4FunQZikAAItEr/PnP65g16xhPPPEsERHL2bTpzU4NUVxOPAb5OuHTT49e0c4nzWt5582bh8GgZN06BQbD+bWJ20NzI2u3n9/IOmPapaU9qKz0obS0R4ce7FqtlvR0b+rr5dhsQqKiBBdlGJwPXufDXyKpoaDga/T6h0hP/4Ta2lvavC7jxr3g+neXLkncdVcysbHrqaurcc3eY2JuRKHoSUREKrNnq+nRw3GDncfz81vW7hKPmJg5yOUB1NY6snVbY8yYeQQExGA2V7Nnz4fnfWANHz6OhIT/0dgoQKs9idEIp045YssqlZWAAF2L6+kMfZSW1pOXF0JpaX2nTOScxMXF8be/DeeHH4zccsvP3H//vfj5/YcxY2pdkyabTUxQ0Pdun5sy5Q3k8m4AZGb+THb2pQlxqNWwYkUdN920mgceeAAfn7+dd+UdGRlJfb0/R44o0OlCycqSIBYLMJly3JK4nJnbFRVd0Ot9USj8O21C81tDJvNj0qQ3yM+vYdeuLeTm3saJE7cSHn4ckUhATs5mjh1bdsmTryuBxyBfo2g0GtasSSU19R3efDOIL7/c4pbh2lmlMO2hM0tE4KyRNZmU2O1gMrXd3cn5YM/Ls3L8eBR5edYOPdgjIyMRCv1IS/OjrCyY9HTxRRkGtRqeeuqFpvjpHCwW72alSVZuueWdNq9LZORYunUb3/Q/C0ajAZnMl7q6Qpd2tVgsw8dnPLW1jlIztXo2s2c7+jgnJKjp1etr0tL+3q6HyoABt9GlyyBEIjtZWZtbddkplWH06jUDLy8FpaUnLqispdOJ2LOnCrsdvL1h925Hwp/dDv37NxAU5J5s15m1vufjjjvkLF06mFGjjmEwlGO1PsZHH+1n9OiFJCSoEYvnU1mZ5dpepQrnvvtWIRYrgUZWrXr8kmtZ58xRsmzZUOLjNdTWlrXo1dycuLg4EhOfp7pazsmTteTm+hMePhS5XOqWxOXM3D55UkBVlQ/FxZ07ofmtkZVVyIoVedhsEry9xXTtamLJkizk8nBAyOHDX19Ud68rjccgX4MkJyczZ85U/vc/Ndu3vwJUEB292fXwb2+rQLO5jr//fWXTyvrSsg47U7rRaWTT033Izw8lPd2nzYeN88HuTJQCYbse7M5JSE5OHFOmvE9x8Vv8+ustmM2yizYMw4fvZerUBfTvv43evfe5ZRzPmRPU5ueEQjGxsXe6/l9fr8PXNwowkZ+/zWVk5fL+FBRAQ4Oj3WJIiKOPs7MtYnr6L/zww0cXdFtKpUr6938AhcKPioocDh78otVro9M9S0hIf+z2Bo4c+fq85UmFhUUcODCLLVsWcubM7fj5Cdm927FKjoqS09h4sMVnOnsi1xZ+ftEMGvQEcrmC0tLTjB59ij//OZ3Y2DVYLFWkpj7j5g7u2nU4gwc/DkgwGotJS2vZ6/nixvAYXl4SSkuPuwl/nEvz67Jy5Vrmz//ZlcT1ww/PkJr6I8BFfe9/r2i1WsrLbeTmdqeiIoi6uq7o9RZCQx8mICACk6mOLVtev+bjyZ7mEtcYGo0GtVpN//5l9O1bj0jkSKby9w8lIGAdp04NYeLECwtjVFfnsXLlA3z22Wz27p2L3S5GJLKRmCjkvfeuyKmcl442u+hIcwVnApYz2xIcCTc2m5Dk5Hzmzo26qDF/+eUNaLXbCQ2Np7Q0j6NHh6PVTiQ0NI2JEwfzwgt/cx3/3CYYJlM1H344gro6x2pNoRiKzZaPWBxEQsI3dOs2grVr1/L882pGjbJSVQVKJYSHO1akADU1kJsrIT29G889N/+8jTDM5jpWrEhAq91LcHAs9967CoUiqMW1SUragUj0BNXVerp1m82IEU+2en0/+CCfxMQonElUQUEPIJGsZ8GCfgiF+ahUkdx993KUyrCLuraXislUzfffJ1BUlE5ISAwzZnzIt9/ORq/PAuTcfvs3DBhwh2v7uroSPvtsPHp9HiCjb99/0K/f5EsyeCZTNStXPkxR0RH8/Tt2PbKzN7FkyVPk5WWRmamguDiE556bz+TJky97U5HfAs7npt1ux9/fn6qqKgQCASkpKcjlpWza9AoNDQZiY2cwadIbbTZJuVx4mktcpzjduUqliMZGhzFev17EoEFf8OSTQ3jvvfMbY41GwyuvpKFWp/Hrr36uJCFnfeqlqmt1Fh1dPXVkhd68HteRHOUwxiIR5OZe2Bi35eL38vIDpNTUVJOeXkyvXmdXsLt3v4tGo2lWB4mbR0Im86OuLoL6ekhPn8kXX9zH/v1Tqa8v4sCBTwCH58BiCefIkQBqawPJyZFjdOQkYTA4kqhUKhEyWeMFE3ykUiXDhz+DUhlMVZWWw4e/dl0bpzEWiWzk5IykokJCaekZNm36H3fc0Xp5Uk5OVJPMp8MrIBCM4eWXX+Pxx5fg5xdNdXURO3f+56rF6WQyP0aNeg6lMoDKyiKys39l/PhXEAjkgJFNm15yWx0plWHcc88KQEJtbR1pac8xZ07rGeMdGcPEia+iUoWg15fw66+vtTuZqLbWl4MHSxAKRXTtqkAqtZKUlARw2ZuK/BY4X4gkKmosZWXP89NPL7FqlY1Tp36+ZuPJHoN8jXG2DlhBSUkQqalh1NVFtit2lJyczMyZ/+SddyayY8d9LFuWAkj45JOjPPec8LK0TLwULlcHo+b1uI6vuKPUyGrlghOSswa1ZVepsLDhyGQ+mEwFCARQXy/FYHCIZkiljhh48zKY5k0wNBoN332XSXr6TFauTOHUqbn8+OMS0tNv4vTpPfz00xIAEhOfp7bWl4wMCTpdCEFBgwBcymm1tVKCg9uOuTenZ89JdOs2HLBy8OAKVq9eSo8e+S61LqtVSK9exfz0UylGoxhfX4iKqm3V2E+a5GjU4MxgnjOnhLlz56JShRMZOR6RCI4f/5WXX/6F++/XnTc00taE51JzHXr2nERU1HikUhEnTvxEdPRooqLGAiJqavLYsePfbg9inU7MgQNWhEJQKCAmpvqSM5nDwgY11caKO9S9ySF44kV5eRdKS4NRKAI9SVwdpK1J/tq1Ml577W7S0u5m4cJ/8fHHB6/ZeLLHIF9jnFsH3NAgb1fs6MCBHfz003wCA4e5SQiazX/niScGXXBl/VtCrYYnnljgErBISFAzadIP7ZqQnF1BChCJ3PW14+OfJiCgF9CASCQmPV2FXu8QHRGLoWvXELds7OZNMLRaLRUVRnbubN49y0JGxljy84/z8cePo24anPOh8tNPP3PLLU8jEDhEQ2w28PW1UVBgbFeCj1gsY8CA+zAYrJw6tZf333+U//53EgkJicTHf8TDDz9NeHgapaVQWemP3S5DJpO3agictbxTp67j3nvvpG/fn10rzlGj/khNjZBffonk3/++lW+/9WszX+HcCc+qVeZWX1+2rOOxPrFYxqRJb6BSdaOmpogdO97l1ls/QKkMBywcPryY4uKz5WOODHwllZVyGhogONiOxaK/JCMoFIoZMeIRQkIGY7fbOHJkcbvilk7Bk2PHxNTWyqisrPYkcV0ErU3ynR4zZ/a9RtOfHTv+fU028PAY5GuQjrpz9fpCNmx4nOHDbW7dmex2Mf37G67QqK8tRozYR3R0Gnl5kwG4556P2jUhaa73fK6LX6EIIiCgF2KxlH79Yigu9qa83IrFAjExvvj4VKNWw9y5LzNqVDJz577sOqbjgSvGYEhr1j1LjESShlAIoaEO9a5z3ZSDB99Nz55jEIlAKASBoA6p1NLuBJ/6+gCOHq1BIICuXR0r3Pz8b1Gr3yYq6jv0+g3IZAo0GimFhcFkZIjaNARqNfztb3qGDt2LXl/oShbLy9OxaZOOoqIpbpPBH35oaYjOehAc55uScqbF6wKBheXLj134ZrWCUhlGbOxdSKVSSkpOUFtbwpAhDyIQyDGZylm1ai6pqT+i0WiIjIxEJPJl+3Z/DAYlIpGB/v2N5OZmX9IqWSbz44Yb/oyPTxAVFTns27fwgi7SK5WV/nvE6TFzend69NhGTY3WJbd5LeExyNco7XXnHjiwg4ULp9PYmOHqzjR+/CwiIj6ma9dHuOuuK5u8cDVozdWZnj6OZctS2Lv3WZYtS+Ho0bHt2pdaDc8+6zCozz77cgsjHhDQF6FQCVTxl7/cxxNPfEF4eF+EQgEZGasBGDcuh1tvfZ3w8GWukhtnMwuhcC0DBqjp0eNnundfjdUKRqMXjY1SoqO9WqxOZTI/8vL80esd//f1hQkTvJg0aVK7zqeoqIycHDENDQpsNjHR0V7k54sRibohElmxWkuYO/dJLBZpmzrMzRkw4DZCQ+MQCBrIydmM2VyHVqslJ0eETJbu6pttt4upr2+50nQX0hATEvJDi9ftdjEhIT9dtI7z4MF3Exw8CKu1ngMHPmbw4Pvp2nUIYCMnZy/vvHMfarWazZs3M2/ePBobvcjNdRjMwEADycmvo1arLymeHBLSn8jIiQiFQrKzN7bLRXqlstJ/b6jVsHKlmZkz03j00SeIjd2A0VhHbm4ax4+vuKbiyR6DfB2TnJzMa6/dQkXFMQwGRwLYxo3+ZGbuRSR6j5deGvKbn2G3FfM9cWKQ22otO3t0u/c5dOgupk79E0OH7mrx3qFDVrKyyqmpKWHt2ncpKKghOnoENpsZjWYvR44c4MYb/4GPTxeMxiK2bHnD9dl33nmHBQsWUFysJDt7Fnl5t3LsWAqbN99FWVkgeXkNLVanGo2Gr75Ko6LCy9XkQa/PRa2e3C6DERkZSV1dAIcO+VBWFkBeXgNeXt5ER09AJvOnsjKPm27q0W5DIJUq6dFjBgqFH+Xl2WRkpLpqZisqNhEZ+SHOvtkrVw5t4bZ2ur5vvXUT999/L926fYteX+h6/f7783n00ceJjFzKvn0fX/hmtYJM5sfw4Y/i5aWkpOQUeXnbiIz8A5WVTnUxABtJSUlMnjyZlJQUbrvtderrpXh5waBBEtf7F7tSFgrFjB79RwICemA217F9+zvtcpFerryK3zuzZ0tZsiSOceOyEYlEGI1lNDQ0oNGsoKLi9NUenguPQb5OcapdRUUZEAgcST+//hrAa68t+l3NsH/5pbapp7LALYmqW7c1bq77bt02tnvF5SiJELYojdBoNHz44ZeUlYmx24WYTHaSkpLYvz+HigoD2dn7efLJaSxZspbAwBjAjtFY5baPf/7zn0ydmuw2WdDpbuD4cQM2m7jF6lSr1VJXZyYjoysaDVRUgEQCPXrUtctgOIUoqqoUbse49da/EBzcG7NZT1bWL/TrF9tuQzB06L34+/emsbGaEydWEhvby1Uzq9NJXP2dBQIrr7/e2KpR/ugjX0aMOEJtbSG7diW5Xv/8865Mm2ZoyojfctF1o1FRYwkNHYJIZGfv3sXs3p1Fbq4jDu/lZSEi4qw3Ii4ujpiYQRw6JKehIYCqKm9CQ30uOalKoQhi5Mhn8PJSUFGRx5o1/2bNmlSP/OVVQqkMY+zYF5HLfRGJvLHb62hsrGfNmteumQYeHoN8neIsjzp9OhyjUcqBA+GUlEjx8vJq88F6PfcJbYuAgG+b1Mvck6h69PjJ1drxvvsepFu3Raxe/Vq79ikQiHBoSIvcXndec52uF2fOhKDT9UKv17NkyQn0ejHe3hAW5tDKrquzIxJJqa/Xt1gZ3XlnkNtk4bXXRrY5iXJm3RcX17N1q4g9e6C6Ghoa2ielmJICubmJzJ+/xe0YCkUQ3bqNRibz5syZI5SWtj9mK5P5ERNzG97e/uh0OeTn73C5WxcsGNp0blbsdhHp6cJWk7S6dh1GVNR4JBIpWu0e12RJLJbRq9esJlGTbFe5VkdxJHi9ik5n5eDBrezZ8yFbtkBxsUOO1Ns7H7FY6PJGREZG0tjoz6FDCurrvSktre2UpCpn28WSkmJSUv6P559/4JLd4R4unu7dJ9Cnz2xkMgU2m4iCgjw2b/7pmmng4THI1ylnJSVF7N/fm7y8tpNxAH74oe6KamFfCh2ZOERHf0dCgpoJE5awYkWdK+YrEEiIjU2lS5fN7N8/mKNHp/DTT1+26wcnlfogFIoAgVt8yXnNS0oMZGV1oaTEgFgsxmgUUFkZgMXihd3uWFmJxT1QKALR6wtaqDap1fDww8+5ssBHjVrX5iTKmewjkUiw2SA7W0BeXghFRReWAG3eGzYxMYqGhhvdjhEf/yx+ftHU1haTnv7tBa9L8/0uXfoI+fkPYjLpOHp0CRaLyaUv/eqrHxMaehRHLFnUapKWUChm+PAnUKm6UlWV5+ae7tt3GqGhQxEIhGRmrrvoVXJeno60tEJATECAF2FhSjQaqK8HpbIBiaSazZs3A47r/Nxz8zGZJOTmVtBZylhisQyl8gYyMkqRSi0MGyZEILB6GkVcJcRiGWPGzCUgoDtGo4GyMi1gIzRUgkrVcNXvi8cgX6d0RFLSbK7jyy93X7QW9pXkYhqMx8amct99XzBnjtL1mt0u5NixmaxalcLp03NZtSoFrXZGu35wKlVXvLxUVFRo3VaOrWXCPvzww6hUKjIyJOTnh5CR4WhXOXjwPQQF9cNsrqGk5GiLY9xww0mmTnWIipSXHz/veJytEB977DFCQrpSXi5sV+/m5iIgzTOanSiVYUREjEUqlXLmzP52ufSd92fhQhnvvfcXMjNnUFysIT9/h2ubF16YwbRpzliywwsQFbWlRfJMWNggunUbgVAo4McfTTz7bD0pKWc7+Pj5hVNZmXfRq2StVktmppjy8lCqqvzx8QkhIwPq6gSoVCL69JG4fR8uV1JVWZmekyfF2O1KTCYR4eEKT43xVUQm82PatPcRiXwwm0Gh8MJg8MLXV3XV74v4qh3ZwyWTmJjYLmm9Awc+RaVKw26/ydUF51pR7DqX5ipbQqGNtDThecuVhEIBIGj660Cj0XDyZIWrt7DTPVxaehMNDXtdccO2GDNmAVrtLsrKsjl8+Cu6dBkCNHf/3kbPnsdd17xLly5NseSzMqDDh4+jrCyGkpID6HQZmEzVyGR+rmPIZGfl88rLs6irKzmvzGJcXBwff/xxhyREJ02CpKSz/ZcdGc0vuG0zYMBd5OenUVlZyIEDnzJx4uvn3afDyNPU/9dKbu4NxMT8zNGjS4iKGodYLEOlCmf2bAlG42zy8sYTHb2NqKhTlJbOdl1LcKyShw17jHXrFCxc+E+EQisffuhI7poxYxBhYUPQ69eQmbmOIUMeRKFoWy+8NSIjI5FIfDh2zEZoqA9FRaVYrSIKCrohlRoxGPwxGvVu34e4uLhOT6g6m1jXgK+visJCg6fG+CqjUoUzYMD9ZGa+hM3WgM0mQqs1XfX74lkhXyNcbHz3QlmZWu0Ofv31JWJjU0lIuINHHim95hS7mjNkSL5LZctmu7DUZ2sJWI6VkYLISPea7Nrane36walU4QQE9MJqrefkyUNukpjJyVYSE6PYuXM6ixbFkZLS9sqqW7fxKBTBFBZmsHTpa24rc7k8AInEF4CSklPtzijuSBZuczGPhIQ7GDp0b4ttQkL607XrSCwWM/v2/cy+fWlt7i8lBbKzzxpjm01Ez557kMmU5OYeZsWK/7rOMTb2doYM2dfkBViNXp/H4cNftdhnWNggiorUzbw3Ftavr24y1o/g69uNqqpijh79pl3XpznnepHEYil+fn7odALy8kIpKGiZ1X45aN7hKSND3y7vhofLz+TJTxERMQwAubwcsdh21e+LZ4V8DbB8eRUJCf4IhVaSkkSdZjD37NnEL7/MARoBMS+/nMDAgd0ufceXEaHwaRISxBQWTuOxx25Bre5x3u1bS8CKjIykpiaYiIhU7rhDzenTEzl+fBty+QHmz3+xXT+448dzOHz4Jo4fn8S77ybRp88zCAQDsdlEgI2333ZoYycl0XS/Wq6s+vadxk8/vUl19Rn27FnI3/++hnnz5pGYmMiECa9QULAbna4GqODQoV8JCJjB4MHDO37RzoNaDRbLD5w8+Ss1NYNarNSFQjEajYTMzFLE4kI2b57F9Ol/a9G4onlTChAyZMhBYmL+xbhxjWRliSgpSWfr1pM8/3w2ffo8w3PPTSQm5ibS05cCZsBCbu7uFp4AoVDM7NmRrF59toexSvUF8DxhYYMIDx9NZuZaTp9ex4AB93S4ecW5XqTNmzeTlJREXp7O5c24Eg/g9nqzPFw5pFIl8+ev5ttv/0BFRRHTpw/l7rsfvqpj8qyQryKO+sSP+N//fuj0+G5ycjLvvKOmvr6a+nqAWOLiZl/6ji8zDQ11xMam8tBDS3nwwfMbYwCJRAEIm/46cK5IGhogJiaV+PgFPP54GOvXr29XXFCj0bByZSSrV6eQnT2XkpLP2b//DHa7CLDjmAC01Ks+l9On89izJweLBaRSX+x2uytm6ecXTbduowCorYWTJ3fx5JPTL0uWZ1jYKORyf2pqtC0SzDQaDZ98soKyMgkSiRSwtBpnP7cpRdeuNQwalEZh4Sm2bs3BbJag18+mpORztm4dwO23SykoeBJvb6cBtVBZmcWBA5+2GN/990fw+utfMGrUhyQkqImIWIrBoEMoFDNu3J/w84uiurqAXbv+e1EiDs29CldTfMNTY3ztoVSGMW5cIiEhgRiNeeTkbLyq4/EY5CuMRqNh7dq1bNmyks8+G8vmzfMJD09t6shkaXev4wsdIykpiYAAh2ymyQTLl1dw4kTGpZ9AG3RWSVVrMeHzb+/Qki4oKGkzWUsohH79+rX7QehQnnKPP5vNkU3djgQIBDbs9pZ61a3tJzdXik4XRGVlCP7+7qVK1dV1VFc7XMByOQQGGi9LlufQofe6JZg1v1darRaDwUR5eXeKioKpro5uNbHlXEnRWbMi8fYOxWQ6g1JpRqcLobBwCs72jEKhjezsYURGjgUc98hmq2Xv3jUcOLDDbd9CoZinnx5GQsLnxMaupaLipCuRS6kMIypqCiKRmFOntrNy5eeXfH1ycuL49dfp5OR4DKMHiImZQpcuwxCLRWg0K65qz2SPQb6CJCcno1aref75OaxZcwc6XTpgJjZ2A3/60zs8+WRdp7irnfWyNTUqbDYoLFRRVWXvlOzB1gzvxWRGt0VbohxtceJENvX1DWzdutNV3+mckAibvt1CIR0ydJGRkSgUB93iz97e21wlPHa7kBkzvmHUqP8xf/5fUatbvy7O2tYjR+TU1sqoqqpyi1lKJH0xGEAgAIFAiNkccFmyPGUyP4KCeiOVyti4McCt/C07uz9yuZzS0nry8kIoLa1vNa6qVsNLLyUxevTH/PGPL5GQEEh4+EgEAgEKhZUTJwTIZEdwtme02YRMmSIlOnoy3t5dAKivt1BYuI8XX2xZhxsS0p+YmCmAFLu9nh07vuPQoT0ADB/+EJWVIo4d282XX867pHrRttpjXugzv7X6fQ9nkUqVTJr0Gr6+kdTXF7Ny5TyX3vmVxhNDvkI4jYRCUcf06Y4mt/X1EBQUyQMPrCYsbHCnHctZL3v8uBBQcvw4yOVel5y8cjaOaCcpSeCaPGzYYEQolGK1itqVGX0+2hLlOHccW7ZAjx75HDyYTs+eEBoq5tQpM0lJSU21wUaMRlCpwGjETZXpQsTFxfGXvwzghx/UGAwTUSjSuPPOmzh8+I+cPNmL6Og0Ro7MRq/PpGfPG9u8Ls7a1qSkJKqrS1rELPv3v5XU1LdQKi3o9VLy8uyXLckoJuZWtNqdHD7c05V17ciSjmLevHkkJSVRXFx83rjqzJlSgoP/hdUKJ070xN+/LypVCH37GsnNbUCrXUV8fDEwkUGDtEye/AJi8RwOHPiO4mItIpHDE+DnV09y8ntMnjzZdRyhUMyECS+xf/8S6uuNVFcfYt68W5kz5w0mT55MWlo+vXqJ6NJFQGmp0SV72VH3b/MmFiKRnS1b7KjVba9L2rq3Hn5bKBRBDB36GIsXP01e3lY0mhQqKoJcOR9XCs8K+QrhXLWOHNmAzeZ4LSsL+vT5Z6caYzibXdrY6MXu3TYaG706JXnFYXitLVoTdumyGptN1O7M6PNx9OgE1q9/l6NHJ7T6/o8/Gl3a1YmJUWzd+iOnTt0OCImNFWI0OiY7crmcmhoBNhvU1Ag6bOgSExO5+249M2e+yN1365k7dy4TJmS6aocd6luO2PW5D/nmMeXzxSwHDx5Ov34TaGgAq9WE3W68bElG3btPICioD1FRG11t6Gw2EePHm9sdVz3X9T1y5KMEBfVBJoNnn53JokWLePPNm7jnng+JjFzCvn0fI5P5IZMNwOzosojVCqGhFry9q1p4AvLydGzdasJqdciDRkToSU5+j23btpGZKaa21g+LRUpwsOyiPQlnm1g4wg0DB2afd/vzteP08NuipkbJwYOFgJDu3b2uioCLZ4V8hXCuWvftszJypJKMDAllZSp69hxwWY53MVmdzpXnpEmtrwLCwn7CZrunKY54tpY5LGwhCQnfcebMDJ566jbU6tCLGnNKCrz77ksIBBb27BEjlYLB4D6eVatyEQp7Y7U6vrp6/TTWrbuVESMeprr6V+RyORMmTMBisbB16/NYrVaUSjuJiU912NAFB4dQUSEmODgEAIUiwPWeUChCJBIiFEqa6n0FLa6Lk5ycOLZsiWPSJDh3CArFeAyGrfj6Wunfvx673d6hMbYXsViGn193hg5dCjxMbu4oYmKOMnDgHcCN7aq/dbi+z9ZWC4VigoL6UVKiwWLJZeLEkUilk6mq2kJt7S8uoZGBA+9k06aPCQhossrY6NXLTNeuIW77d5Sryena1dF1ydfXire3QwtcIvHhwIFGevXyISvLctGeBLUali7V8fnn6wkN/ZnAQF/gkza3d9ZyO+/tmDF1gLLN7T1cvxQVlXHkiBfx8d7U1UkJD1dw+nR1uz1rnYFnhXyFcK5aDQYl69YpKSnx47nnFlzWG92RrM5vvy1qtWuSE4NBh0LxGgkJasaN+4Jvvy1FrYbKyiyKizOIjV3PQw8t5d57L84YA7z33uFmiVRW3n67ZVw6NPQHbDYx0ORmwPGwPH483q11YGJiIvff/2cCAkKJjY3kxhu7d3g8AoEIoVDgcp+rVF0BLwAsFhsCgRCJxBu1GubPf7Mppvym22TmfDFLjUbDRx8tpqhIikgkwWzuWKy7o8THP0tAQAz9+qVx221v07Pn95w69XOH9uGorQ6hqqqYEydWMnDgPfj5RVBdXcrRo980CYNEIJX6UFKioa6uhOHDxyGR9KO2FurqoLERwsO98Pd379XtFPLYvPlONm1KJj9/Bt27Wxg3bgzz5s3DapVw5IgJq1VySZ6EhIQgnn/+AIMGpVFcrDmvQplaDf/851rGj/+KBx98lOjopRd1TA/XPo6e5SoOHvSivt77qgi4eAzyFeRa7XdqNtfx9de7XFnDrZXy7Nv3EbW1efTrt5GXX85wGd7Nm9/Aai1HLg9g4sRXL3oMGo2GrKz3myVSiQCrq8zGOZ7Bg3eSkDCLIUMcCT9OA75gwbAW13Tq1D+jUvWgsbGCfft+6PCYJBJvl9EFh4KXl5fj3xZLGQKBEIHA8ROKjz/B9OkvEx9/wm0fZ93ZLUuknGGM6uoe7N//B44e/ZiqqvGXTbpPqQyjS5ehgJH6+nosFhONjYYLfq45fftOIyRkEA0N5eh0pwkLG0TXriOw2+s5c+YAZnMdgwb9AR+fLi6Nao1Gw65dFRgMjsmM3Q4NDTV8++1bpKcfce07Li6OKVPep7j4S06ceIq1a1OQy/9AaKio0387gwffj0oVTnV1/gVFWZ57bgxPPLGS3r1TyM3djMViuqRje7g2cS6a7HYRp09XXxUBF4/L+gpzOaT5LpWjR5cQGLgeu31OU4y4ZelVbu5mwIqPTxjjx//Z9XpdnUMfOTCwB9HRN1z0GLRaLUOHLmXkyEq02onY7QYOHXq1hRtYIBARG7uWW281s3//EPbtC2bkyHL+9rd/tNjnp58uZsuW/fToYSE1dSV1dckdStBwGlyn0VWpwlGpelNevgeH2Io3paUnqKsrQSJRNBlvhds+zufOdoYxcnNHU1b2WdPk4gGys/M7dvE6wP79xeTl6ZDJrHh5wZEj27jlFnexkPMhlSrx8+uGl5ccrXYXBoOOiIgJFBTsoqIil5ycjWRkzGTt2nfw9/+a7t0zMBiyqK1tRKvtRdeu1ej1OiIjGzh27FeWL5/Oo4++5LovSuXMJhUwx8SsuHg0J06sJDR0QKf+dhwTiaHo9T+Tn78Fg+HZNqU5ZTI/unW7gfLyDIqLj5Ofv4OePW/slHF4uLa42gIunhXy75y6uhK2bn2H2NjVPPDAfTzxRE2LTNLq6jxKS3MAKQEBvVxqSTabpSnmKUIqVSEUXvz8LjIyEm/vRnr1SmX48AX07v0as2ermTDhB7fxSCRyQIBEImf06JNMnfoio0efbLE/Z1a7ySTBYhFjMkku6A4+t7xFJBIjEIgxGitcq6LQ0F6u7RsbLZSWOmQvrVYzAgFYrWa3farV8MIL/yI+/iNeeOFfbtfVOSM3mUa71Tzn5kZd3EW8ABqNhi+/3Ex1tQSBABoaHLKda9e+16H9xMc/h59fT+rqyjl48HP69LmZsLBBVFWd4f33TzF7tog1ayazePEStmyJxMtL5yqtOnnSh507G9DpQCKREhRkcrsvkybhShC028X07Lm/3Y0vOoJQKKZv3zkolaFUVl5YmnPkyEfx94/BYNBx5MjXnlXyb5irKeDiMci/c3bteo/6ei1CoZw//CGShQsDWiR0bdv2DxoaSpDL/Rk27BnX61u2fI9WewKBwAuVKvySxhEXF0dsbB8AKiocrw0alMpjjy12G4/VagEEWK0WhEIxAoGw1YmA0x1sMERQVuaPwRBx3szc1mqplcoo5HI/ysoyXd2MDh8ezfr173H06EwKC+uortaxffsGxGI5J0/eyuLFD7WIv48YcYTp019ixIgjLY6bmJjIW29Ncat5vlyNP7RaLXV1ZiorQ6ivV2IwiPHygsLCAx3aj0oVTlTURMBEXV1pk/xmOXl5hWzZInXTpT5+vDciUX5T/sSN5OYmYjbfxrFjIVRXh1FX183tvqjVsGjRKW64YQn33nsfcXHrKCo6wXff/anTY+vdu0+gW7fhQIPL3d4WCkUQUVGTkcnklJRkUFCwp1PH4sEDeAzy7xqTqZqMjPWAAD+/KMaNe77FNo7OSccAC0FBMfTpcwvgEDn55JNHqanRUVJSz6lTHdMYbo3Y2P54e0sYMWIM48bdAHi1cAHLZH4IhcILulid7uCCgoZ2NRI4VxoyLc2xKhKJgqmqymfHjq9ISYF//OOP7N3raOeYlzcTmw127tzD6tXBfPvt96xZM6lF8pZc7o9IJKO2trSpXMqduXOjeOml9xk9eiEvvfT+ZatzPdtD205eXhjFxULsdhCL61od1/lQqSKQy4M4c+YwW7YsYfHig+j1Enr02OqaXNhsYnr12k9R0WG6dHmIsrLPaGx8ApvtJwwGNYWFgZSV1bW4Lw891JPExDT691+DXl9HTk4uGzd+xx13TOtUaVGxWEaPHtNQKkMpK8skK2vDebcfOfJRgoP70tCg49Sp1IuS8fTg4Xx4DPLvmKNHv6GqKgex2JuYmFtbxNCcymIHD+6lvt5OQYEOsVjmcgdDA2Ix6HQCPv74u0tewTjitSKio7uSnT2FX375Pw4dinfbxmazIBQKsNksLbKgm9ORftHQUhpy4kT4/PPv2LDhCNXVen74YQXvvXcYofCsa7m4eCL19RAQYGfr1hCXETpXjzwoaBByuT9VVYWcOLGy1eMPG7aP6dNfYtiwfRd17dqD85rYbGKOH69Dp/MlICAaMJKR8VMH9zUbP78oKipy2bVrMRUVRurq/ImO3sDYsXcxYEAyCQn3MnjwVqqqzvDjj1mIRLYmd7QVkyne1VP63PsiFIrx9++LSORNUZEOoxF8fSVERtZ1ehZ6nz43ExzcF7O5moyM1RdcJUdETEQq9aawcD/l5S1DJR48XAqepK7fKRqNhm3bvgLqUaliGTfuTy3edxhdGwqFFDBz/PgpVz9eo9FIbW0IRmM1tbV+HVLCagungd2xozcffPAaAoGF3bvFjB17NoYsFjtiyI6/uGVBn0tHEjScsd4dO+SMG2ekR49bmTcvib59BQgEYLMJOHnyI2y2z1yuZaEwjdpah/pUaGgaubnzW+03PXjw3eTkrCc/fwc63elWjy+VeiMQiJFKWz+XzqL5NenaNYSCgq/IzFxHVVVBh/Yjk/mRmWnmzJkSKiuLMBph714lEIROt4PBg1cSGytDKOyNzVZLePgvWK1DXdfurbdupGfPLm3el5EjH+XgwRVIpWeor5djtXpht/t2yvesOVKpkpiY2ygvP0lJyUmysjbQr9/tbW4/fPhDFBbupLz8FPv3f8LUqe+2W+bVg4cL4THIv0OSk5P58MP/Y8KEQvz9Aewt2to5jW50dBBlZWa8vKrJzha4jJtcLicrqxHo0iTUILnkej3Hg03A4cM9XA9uR6mQwGWQz818bv7v1uhIZu6IEUdQqVbTp89taLUDMBqNiER+mM01iES+WK2rGDmyFKt1IuHhaVRVpbJjB4wdK0EuP8rNN6vR6yfSt28mavVC135lMj+UylCgsU3XsESiRCgUIZFcftGJ5tekoiIVsVjKmTN7m2rNW880PheNRsM33xxmxAgJgYGNxMeL2bbNxK5dBlQqFX37jkQmO41I5IVU6kWXLt/whz8Ukpvbj7i4LB58cAEq1XSgdUEahSKIoKDeFBQcRCg0otWGkpdnvSx1oX363Exm5mq02j1kZ/9K797T2zSyCkUQvXrdSk1NHqWl6Zw5s4+oqNZV5Tx46Cgel/XvDOfKNyKiHqkUzGbYurWwhRvQaXRLS2upqfFn3z4/amqCXSuazhRqcFJScgar1UJ4+DqXW/jcbkqlpaVN2c2ll3Ss1mhed+w8/4wMMVptMAcOTMNo/AcWC0yevICIiFRKS6GkBE6fDiE/3054eCpTpy4gKmpli+spEICjU1Trx7bbHUlqtbVFnZ7B2zx7/NxM8v79b8fHpwtFRadYuvSVdruDtVoter2FiopAbDYZUmkQcvndxMT8zPz5W7jllgfJyrqT5cufZsuWIWRlnaSy8iMGDEika9eF7NqV5BpbW4I0Y8Y8hL9/N+RyMJnKsNnEl6Uu1LlKViqDKC09fsGErYED5xAaOgiTqY6cnE2eWLKHTsNjkH9nOFe+NlsANTW+FBaGkJkpb5F93DwGm5NTSU2NzE1ZrLOFGpKTk9mwYTO1tWbCwn7kjjvUjBqVzN/+ts21akpOTmbdurXo9UbWrVvL7t27O9U4N199O8/fYpGyffskiou/xGh8jEOHUsjKmoleL6Gy0hcQo9WasNtFKJUSTCYoLi7j9tvdext7eakQi2Xs2hXLc89ZWmRiBwT0R6EIorw8y5XR3Rmca/DOzSQPCelPQYGdgoIsVq78ot2dlM56SYTk54dw9Ogt1NYuYd++ESQmRrFq1QN8/vlCtm27l2XLPuL06dsJCPChpsZGbW0DhYU5QMtmD81j7927T2DIkGlER3fhzjvjWbny+8smptOnz80EBMRiNuvZsuW/5+32I5P5ERl5A15eCrTa3Z5YsodOw2OQf2c4H6T5+Y0UFHTh8GEZEolPq27ACxndzqrXc68ZFqHXQ69eqYwfv4BDh6a5tVQ0mcRYrSJqaizs26ehpsZhnDsz+9aJ8/xvuOGvCIU2V/tFrXYilZWNKJUBvPDCCyxevJj//Oc/VFQ0curUTPbtew8vr3FuCUh+fr3Jzr6Lf/5zHv/7n7DFanDw4Lvx9+9BbW0RmZlrO+0cmjdHEAjsgB2rVdjUlQtOnMggLe0IRqMYPz8FPj7mdiVOneslqa8fh0BgbSp3svLLL47kNqenIy/vJgwGb4RCb8xm0Om0GAw6V7OH1rwhYrGMsLBR+PmFolQ2tpDa7EykUiWDBt1LeXk927en8re/Pexq59n6+c/G1zeK2toy1q17m59//umqtOvz8NvCY5B/Z3RUHu5KFMk7V+0NDV3R6bzR63F1xLJaLSQlJbFt2za3bfLyHJ2DGhtpl+jHxRIXF8cjj3THZhO64tp9+uxl8uQppKSk8PbbbzN9+nS8vLw4dWomq1alcOTIXDSa79xkMAcOnINWe6OrI9a5nYMcjRv6IBA0ImjLr30ROLPHHdnhAhxu87NduRwNHcSUl4dSVeWPQuHf7k5KzSdsjlpqUVNrRxH9++92E/hQqTZRUeFHdrYXDQ0ibLZyjh79BrUaXnnlQ8aM+Zg///ldZsxwd/8OHDiHkJB+1NaWo9Xu7rTr0hq1tb4cPFiMWCygRw/Jebv9yGR+xMbeQUVFNZs3f88rrzx0XgPuwUN78CR1/Q652vJw53J21W6hutoHf3893bs7+hg7hSMAt20KCvTU10NoqD8GQzBGo/6Ss2+FQmFTprf7PFWthj//+V127JDSu/dx+vT5ldjYh9yOFRkZSUXFFDfFLZttgsvzIJP5MWqUjnXrnLHxlgIgQqEEkcgLg6EKi8XUKdm7zu5Gixb9SljYGqRSHzIy+nHDDaBWz0WjcTR0OHbMRmioD6WltR1KnGqeIBYRYWXRoo34+X3FnXf6MX16LxYu/ImIiPUoFKmsXRuGt7cPXbtGIxIVudS3Jk0qJjBwCV5eQZSWTqFLlyGu/ctkfvj7x1BSko5Wu7NDiWcdpaiojPx8EUFBShobxRfs9tPY2JWjR8sJDLTTvbuC9HT7Rfdp9uABPCvk3y1XUx6utbE4V+2FhSbkckcDgro6Kfn5VldLRec2Wq0JEGO1+lNQ0O2Coh/tRSr1RihsvfRo9OgMpk9/hbi4zTiUwtwTr+Li4hg1qshNcevuu0PPub5fMWuWmqFDk4mPv428PPfVlK9vL7y9g6mszOLMmc6rR05ICCIxcSv9+q2hT59NzJjxOqNHH3eNuyP12udj1iwRjz22kr5912K32/jDH7py992fERubSmRkIJ988j4//fQzY8dOx8tLSUnJMQwGHfHxz+LnF4ler+XIkZYSliNHPkVAQC/0+mLS07/t0JjOTWI7H5GRkdTX+3PkiIKqKr8LdvspKamksFCIxeKDweCFv3/7vQsePLSGZ4Xs4ZrAuWo/cWIzhw//FYOhioICq5tLPS4uzrWy3759O8uXLycvz6GT3BnZt44VqpTq6iLM5jqk0rMlSCKRGKFQgkSiwGYzYDBUtNjmyScDgFnk5U1g4MByPvnkHdd7Go2GTZs0DBlSSe/eqRQVQVLSMbfV1MCBcygo2EJm5i5++eVLxowJ6MR627OTjYaGKrdJR2d6TCQSORKJgpqaXEymakJDe1NZeRSBACIjDcTFxREUZKWgYCc1NWdIT/+W+PjnCA7uR2npMSyWlnFiR5eqeIqKPmfv3jVIpaMYOjS+laO740xoEwptJCUJW2i0n4ujbefzJCUlUVysv+D3KjIykqqqAE6caMBmU1FVVXXF2/V5+G3hWSF7uGaIi4vDxycPlUpMjx5DePbZr1okkzlX9u+8806nt7L09e2FTOZPWdnJFjKKYrECgUCAUhmKStUNnS63xTYjRz7KgAG7mTp1AQMGrHN7T6vVkpMjoqHBsfqXSIQtVlMymR8aTQElJXn8+OM3nRqTdMSP7YhEIje3uJPO8pjExNyKShVBdXU5J06sRKWKQCLxxm6vpKjoEDabhZCQ/nTtOpzGRj21tcXYbBbk8iDk8gB0utOtNpLYu/cMGo2Wgwd/JTFxZruuy5YtDmNss51NYrsQHakeiIuLY+7cBZSXKygsLGtVdcyDh47gMcgerinM5jrsdhPR0cOZNeu+8z7cOtvtPnDgHESiUCortRw65J7p7HBRCwgMjEAgCKK8PLvFNgpFEEplCAA2m9XtvcjISKRSJUVFDplPnU7QYjWl0WjYs+cQZrMAX18VYOu0ZDWni10mk6NQBFFWduqyNEjo3n0CYWGDMJl0VFZmMmbMPOTyIMDO0aMrWbnyc06cyMDbuwteXv4UFR2iouI08fHPEhAQQ1XVGQ4c+NRtnxqNhs8+S6GiQoJc7oVM1tiu6+LoHCV0S2JrDx35Xl2LPc474qb3cG3hMcgePDTx6aeLWbNmF5WVVSxb9q3bKkwkkgF2jhzJIDV1M1VVlSxfvqTFSs3RHhKqqoo4cOBsPXHzOHljI61mt2u1Wk6c8EKnC0GnCyQ01KfTYpLe3hF4e4ciFkvw9e1GbW0RubmbLnm/5yIWy1AoghAKBZjNdSiVYcTETAMcwi8fffQ8arWavXvrCAyMoa6ujMzM9SiVYYSFDcRq1VNXV+omtqHVaqmvb6C6OpyqKn/M5rB2XRe1Gl577RPGjv2M5557lZtvru7084VrKx/jfEIrHq59PAbZwzWFUCjEarWTk5NzRes63eucpZhMYrdVmNVqwmKxcuTIfmw2EAodpVnnrtTKygzU10NtbSUvv3yrm8FOTExk1qyZ+Pl5M2vWzBarqcjISEQiXw4ckGE0yjqc8Xw+Ro58lICAGKqri6irq8JuN2GxNFzyflvD17cXPj5dKCs7SXn5SWpqGqmpAbEYlEoFdrudDz/8EqEwHIHAhk53GrO5DpksBLk8CJ3uFBUVZzW/nVn4hYUmCgqCmhL/2ndd7r+/O3/4wyKio39Eo1lxWc73WuJ8Qisern08BtnDNcWhQ8eprKxj06ZN3HZb+2KFnYGzFtps7kZZWQBms3ufXolEjtVqx2CwNOlbyxCJ/Ny20Wg0pKSU0dDgMNghIS27E0VFxeLrG4pQWNkiVtqZGc/n4tSGtlhqsNlAJJICtEv2saMu0IED5+Dn152amgJOnFiJQBBFba3jPalU7MpGtliC8PHpRm7uIb7//l/IZMMJDo6lpqaU06fPhgMu5bp07z6BoKA+mEwVlJUda98JXMc4hVaEQofQyqhRVVd7SB46gCfL2sM1g0ajYfv2o8TECPHzU7hihVeirrP5KqyxMajF6lQkUiCT+REcXM/hw3YgmIwMG3K51LWNVquluFhIVZWUsDAz4NWiO1F8/LMUFx+ksjKfgwc/54YbXnUbx+WsEReJZAgEjjis3R5IcfERKipOExzcr83POF2gIpGdpCTBBTOVgabrFMuZM3tobKwnNvZ2Vqz4B3K5CZvN6spG7tv3JlJS1lJaup+TJ9PJy/uWhx6KxMenHp3ulFst9sVeF7FYhkoVgUgkoa6utEVm/G8NtRq+/DKLJUv2Eh6eRmhoBPD61R6Wh3biWSF7uGbQarWcPi2loiIIvd6H4GDlFavrvNAqLC5uDiEhPYmJCSAiooH9+xuxWKRu20RGRiKTKahqWpTo9S27EymVYXTtOoLGxjosFnObY7kcMUmBQIhc7otAIMLXN5zq6mK3lWhrXKwLVCr1QyZzGP2ICBVDh47HZgOxuAKJxMr8+fMRi2Vs25ZOQ4MEpdIfu93Oxo3HEApVVFfntqjFvtjr0qXLyDYz43+LPPBANPPm7aRv39WuLHYP1wceg+zhmiEyMhKxWMXBgzJqanwpKDBe0brO82XMhoT0JyQkDm9vKffdN7vVbZxGvbFRhMkEjY2ty5LabA3Y7VZstssTw22LkSOfwt+/J3p9BSaTHoulCoNBd97PnOsCHTvW2K5jDR16v1vS1uOP/x99+45h0KAY3n33MebOnds0AZNQVhZGeXkI/v7+5OSIEAq7UFtbSkHB3s44bfr0uZmgoBjq60soLj7YKfu8lhEKxcjlQXh5+VJUdNTT/OI6wmOQPVwzdFRn+3KNobVVmFAoprragtHYgEAga3OllpiYyH333U1wcAB3330bzzzzdItt7HY7YGv6e+VQKsMIDo7FbC7HbrcgkwWg159ps0czOFyg//73eiZMWMJjjyXSt++6NrdtjkIRRGjoEAyGGg4e3ExRkZGYmAn4+NhRqRylX84J2LFjIhoaRFRVVSGVKunadQBms4X9+9e4ZapfLFKpEl/fHkilXpSXZ5z3fH8rjBr1R/z9u1NbW8qJEz9c7eF4aCceg+zhmuJarOsER+vHpUu/pry8gqVLvz5vsllkZH/8/bsiEJS7ZQs7kUqDACXp6TvZty/t8g26FcRiFTabhIoKKwaDmFOn9rNhw/kT5+bOjeepp1KIiVnVoRXm7t2ZZGQUsWfPGp566jb27TuOVOpDVtYuUlK+B2DevHkIBAKKi4tdwho5OUKOHMklPX0rf/7zbZ2S2BcXNwd//55UVhZy4sTKS97ftY4jNDIcgaDRlcXu4drHY5A9XHNcS3ViNai1AAAdvklEQVSd0LwkSoTNJsVkEp1XmGL48IeQSLpQUHCKLVsWtXh///5KTpwo4NSpXbz22uwr2iFo374STpwoIj19D9u3H6ag4BQffvh/5x2Do8FDT6ARq7X1uPe5aDQavvhiI1VVIvz8JPj6mlix4gD5+Xp2717Hv/71COqm7LDmE7BJkybx8cfLKS8Xo1B4IRS2TwTkQoSE9Cc4OJaGBh1lZcd+F3HVsLDhKJVhlJdn/y5i578FPAbZg4cLcKGSqHP5/PPvSE3dQXl5IYsXL3QzdhqNho8/Xk5pqQiZTILN1jkGpz04Fa/Ky4WIHF5j6uuhsbHtNoMXi1arpa7OjNEYQGOjF2KxD8XFZg4dysfLy05wsDd2u6M7EuCagGm1WgwGEw0NYdTUKLHZQjolsU8oFBMYGIdCEYhOl9mq5+K3hjN2bjKVUVx86GoPx0M78BhkDx4uQEeEKZyraaNRhNXqhdHovpp2GhyzOZj6em/s9qArlknuVLwqL1dRXg4ZGaDRQFFR54/Bec2ysgQUFASRlSVAKBRTWyugsdEbs1naaneks604GykoCCY/v7HTEvsGDpxDcHA/9PozZGauv+T9XetIpUqCg4cgk/lRXHykVY1wD9cWHoPswcMF6IgwhXM1XVcXTUFBKHV10W5Gx2lw8vJsaLVB5OXZrlgmufPYRUVC0tNF5OUJOH5cSm1ty/Ksc3H0iZZgsZja5e51XjOrVcKRIyasVgmPPPIIOl0oGRlydDr/VrsjXc7EPpnMj6CgAQiFQkpKjv4ukruGD38If//uVFbmcvDg51d7OB4ugEcYxIOHdtBeYQqn0Ssrq6OxMbCF0XEanKSkJI4fr+u01pHtofmxdToFdrsRmcwLLy+vC47hXDnM0NABFzxea9csLCysyYNQ3ua5X05xlNjYqRQV7UCrPcqyZW8yfPij10yuwuVAoQiiS5fRVFRkUVx8GINBh0IRdLWH5aENBPZ21F7o9Xp8fX2pqalBpVJdiXF58HDdkpyc3GR0jC6jc262uEajuSwGpz04j93Q0ICXl1e7xmAyVbN69ZOUlBxh4MB7mTTpjVa3S0lxiIlMmtS2otfVPHebzcI//nELRUVbyMoSk5PTjeeem09iYuIVHceVpKzsOL/88if0+mKGDXuY+PjnrvaQfne014Z6DLKH6572GIErzdU0OpeLzZvf4OjRrxg06CEmT36zxfvNZTat1vbJbF5pNBoNTz89ke7d66irU5GR4YXJJCElJeU3c5/OxWazsHHjX8nMXE1ExFimTn33Ny0fei3SXhvqiSF7uK45227Odk21m7vWSrc6A4FAikgkx2YztxpHvh46DWm1WnJzheh0YdTWqvDz871iSXVXC6FQTEzMjahU4eh0J8nJ2Xi1h+ShDTwG2cN1jcMI2LBahYhEthZGwNOsvfPw8emKQhFEaenxVsuGzpXZnDjxyo/xQkRGRiKVKsnIgLo6OSUldVdUnvVqERERT1DQAGpqKvj11085dGjP1R6Sh1bwGGQP1zUOIyBEILBgtQrdjMC1unq+XomLm01AQC9qagpaLRtSq+GNN75gzJjPeOONL645dzVc3haX1zJisYz0dBNHj2ayZ8865s69cq1NPbQfT5a1h+satRpef30RmzY1MGWKF2r1o673tmwBodCxehYKbaSlCa9JI3G94FDs6kFBwXYaGlqXYhw7NgsfnyVERo7FbL7rmoxVXs4s7msVpyhMnz5ehIWJkUqtV6y1qYf241khe7juGTHiIDNmvMaIEe46y5Mmgc3mWD3bbMJr0oV6vSEQeGGxCDl+/CBHjhxo8f71Itf4W4zxnw+nKIxe342qKn8sltDffOz8esRjkD1c19TVlVBenoFM5odMFuD2nloNr766kDFjPuXVVxd6VsedwN69Zzh6tIAdO1J44olbW7g9PXKN1ybO+vgzZ4wUF/tz5syVbW3qoX14DLKH65oDBz6lquoMAQExxMc/2+L9ceOymDnzDcaNy7oKo/tt4XR7VleLCAyU4utraqGBLZUq8fPric1mw/N4uXb4vcbOrzc8MWQP1zVmcy0WSw1hYQNQKsPc3jMYdJSVncTLyw+RSOF6/VqsW74ecLo9Gxv9aWysQSz2cbk9mz/YbTYzAoENm619naE8XBl+j7Hz6w2PQfbwmyU9/Vtqas7g6xtBXNwcoLl4hY2kJOE1KV5xrXK2YUQjEERWlqVVt6dI5IVQKEIk8ro6A/XQJnFxcR5DfA3j8Sl5uM4RIBAIAEGLdwyGKhoaaujSZSghIf2BC9cte2ib1hpGtOb2lEr9UCrD0OkyMBh0V2m0Hjxcf3hWyB6ua0QiGQKBBJFI1uI9q9WIzdaISCRCKHR81ceM0ZOUpGoSrxB7Mq87SHvcnkOH3k9x8X4qKrJIT//Wo53swUM78RhkD9c154tXOmTabTSXaw8PX8Sjj2ZTUHAD9947HLW6+xUc7W+DC7k9FYoggoJiKSrai9FYcwVH5sHD9Y3HIHu4rhEKpdjtQoRCaYv3Wls919WV0Lv3SmbPhmnTZl/JoXrw4MHDefHEkD1c1zhXyDt39myhWd3a6tlutyMQ2JFIFC43tofORyTyxsvLj6qqbEym6qs9HA8ergs8BtnDdY1QKEWjuYU33niwhWZ1a9m+54s5e+g8YmOn4ucXiU6XRUbGT1d7OB48XBd4DLKH65ri4gIyMoY3JWmdmzktwG4X0jwD21Mje2UICupDYGA/GhpqqKkpudrD8eDhusBjkD1ctyQnJ/PNN98TGLgOm03couOT1WrCbm/EajW5PnO+mLOHzkMoFKNUdsFstpCRcZz09CNXe0gePFzzeAyyh+sSjUZDUlISNpuAPn1SUavVxMZ+yP/93zGX0IdOp8dobECn07s+51khXznS0nZz/HgumzYt5b77Wupee/DgwR2PQfZwXaLVajEajdjtQZjN0KdPKhERz9OvXwHgWD1/9dViSkp0fPXVYpcx8KhIXRk0Gg1ffrmdmhoxPj4SAgONLXSvPXjw4I7HIHu4LnHKOObl2aiqUmA2g0QiJTIystnqGYRCCTYbLmMgEDhEQgQC0dU+hd80Wq2W2tpGampCsFoViES+nnZ/HjxcAI9B9nBd4pRxtNnEFBU1YLfDiBFjiIuLc62exWI/TCYvxGI/jzG4wpydMFkpLAwgL+//27v/oCjO+w/g772THwfIDxE8rPyq+DUoWLEkFSKKGSYhJohfjU3TjJaGVE2MVAepqTWRiUlGJ9MEf3VqmsTWiak1agJfa6uMVYRCE2lARcCAIoiiWDxP8I5fd8/3D3qrN4AeAne38f2a2QH2nl0+e3PDm332eXZNfNwf0X0wkEmxMjIysHfvLjzzzHSMGxeGGTNmALj7IQgSLl0ajdpaSQ4DIcwwmcwQwuzg6r/b7v6H6ezZNpjNI/i4P6L74J0RSNFUqm+h0XTBy2siJk+eD+BOGOTk5KC8vOdB7JYwyM//tNfIaxoefNwf0cAwkEnRbtyoRXt7E8LCpstPdAL6DwMO6rIvPu6PyHYMZFI0lcoFkiTB3d23160w+wqD5uYWGAwdaG5usWeZRET3xUAmRRvIqOktW7bg4ME/YsKE2ygo+COam/8HGRkZdqiShprJZEJXV5ejyyACALi4uECtHvzMDQYyKZqtg7QsU6HCwlSQJDd0d6uQk5ODJ554gl2qCiKEwNWrV3Hz5k1Hl0JkxdfXF1qtFpIk3b9xPxjIpGh93R6zL5apUG5uPmhvvwU3N295KhQDWTksYRwYGAgPD49B/fEjGgpCCBgMBjQ3NwMAgoKCHnhfDGRSNFsHad2ZCtUFYBRqa7s5L1ZhTCaTHMb+/v6OLodIptFoAADNzc0IDAx84O5rzkMmRbP1GrJlKpTJ5ILy8naYTC6cF6swlmvGHh4eDq6EqDfL53IwYxt4hkwPDc6L/W5gNzU5o6H4XDKQSdF6pjG12zyNifNiichZscuaFGvLli3YsWMnGhquYMeOnXy8H32nhIWFIScnx9Fl2M3x48chSdKwj6D/+OOP8eSTTw5om+nTp2P//v3DVNEdDGRSJMs0JkmSYDZrIEkSH+9HTiktLQ2SJEGSJLi6uiIiIgJvvfUWuru777ndyZMnsWTJEjtV+XBob2/HG2+8gfXr11ut//zzz/HII4/A3d0d0dHROHTokNXr69atw+uvvw6zeXjvgc9AJkWyTGNqawtBU1MA2tpC+EQnclrJycloampCTU0NMjMzkZ2djffee6/Ptp2dnQCAgICAQQ1gs+yH7ti3bx+8vb3x+OOPy+uKi4vxwgsvID09HWVlZZg3bx7mzZtn9c/9008/jdbWVvztb38b1voYyKRIlmlMzc1taGz0R3NzG6cxkdNyc3ODVqtFaGgoXnnlFSQlJSEvLw9Azxn0vHnz8M4772Ds2LGYOHEigN5d1g0NDUhNTYWXlxe8vb3x4x//GNeuXZNfz87OxtSpU/HRRx8hPDwc7u7ufdZSX1+PlJQU+Pn5wdPTE5MnT5bPCE0mE9LT0xEeHg6NRoOJEydi8+bNVttb6n333XcxZswY+Pr6ymf8WVlZGDVqFMaNG4edO3fK21y8eBGSJGHPnj2Ij4+Hu7s7oqKiUFBQcM/3raioCAkJCdBoNAgODkZGRgZu377db/uwsDC5N+LuxWLPnj1ISUmx2mbz5s1ITk5GVlYWIiMjsWHDBkybNg3btm2T26jVasyZMwd79uy5Z72DxUAmRbJMY5IkCU1NTZAkidOYyGYVFRU4dOiQwy5xaDQaqzPYo0eP4ty5c8jPz8fBgwd7tTebzUhNTcWNGzdQUFCA/Px8XLhwAc8//7xVu9raWuzfvx8HDhxAeXl5n797+fLl6OjowIkTJ3DmzBls2rQJXl5e8u8ZN24cPv/8c1RWVuLNN9/E2rVrsXfvXqt9/OMf/8CVK1dw4sQJvP/++1i/fj2effZZ+Pn54auvvsKyZcuwdOlSNDY2Wm2XlZWFzMxMlJWVIS4uDikpKWhp6XtA5vnz55GcnIwFCxbg9OnT+Mtf/oKioiK89tpr/b6vJ0+eRFNTE5qamtDY2Ijp06cjISFBfr2oqAixsbFW25SUlCApKclq3VNPPYWSkhKrdY899hgKCwv7/d1DQthAr9cLAEKv19vSnMhuzpw5I/7617+KM2fOOLoUGmZGo1FUVlYKo9E4qP1s3rxZhIeHC61WK8LDw8XmzZuHqMK+/exnPxOpqalCCCHMZrPIz88Xbm5uYvXq1fLrY8aMER0dHVbbhYaGig8++EAIIcSRI0eEWq0WDQ0N8utnz54VAMTXX38thBBi/fr1wsXFRTQ3N9+znujoaJGdnW1z/cuXLxcLFiywOp7Q0FBhMpnkdRMnThQJCQnyz93d3cLT01P8+c9/FkIIUVdXJwCIjRs3ym26urrEuHHjxKZNm4QQQhw7dkwAEDqdTgghRHp6uliyZIlVLYWFhUKlUtn0GcjIyBChoaHy+6HT6QQAceLECat2Li4u4rPPPrNat337dhEYGGi1Ljc3V6hUKqvjvtu9Pp+2ZiinPZGicRoTDYRlMKAQAkFBQdDpdHa5p/nBgwfh5eWFrq4umM1m/PSnP0V2drb8enR0NFxdXfvdvqqqCsHBwQgODpbXTZo0Cb6+vqiqqsKjjz4KAAgNDUVAQMA9a8nIyMArr7yCI0eOICkpCQsWLMCUKVPk17dv345PPvlEHqfR2dmJqVOnWu1j8uTJUKnudLCOGTPG6v1Tq9Xw9/eXbydpERcXJ38/YsQIxMbGoqqqqs86T506hdOnT2P37t3yOiEEzGYz6urqEBkZ2e8xfvjhh/j4449RXFwsvx9GoxEA+u3Kvx+NRgOz2YyOjg75zlxDjV3WRPTQsISMn58fVCoV/Pz87DIYcPbs2SgvL0dNTQ2MRiP+9Kc/wdPTU3797u8Hw5b9vPzyy7hw4QIWLVqEM2fOIDY2Flu3bgXQc4119erVSE9Px5EjR1BeXo6f//znvQaIubi4WP0sSVKf6wYzKrmtrQ1Lly5FeXm5vJw6dQo1NTUYP358v9sdO3YMK1aswK5du6z+0fD394ckSdDpdFbttVqt1bV4ALh27Rq0Wq3Vuhs3bsDT03PYwhhgIBPRQ8QyGFCn08FsNkOn09llMKCnpyciIiIQEhKCESMG3jEZGRmJS5cu4dKlS/K6yspK3Lx5E5MmTRrw/oKDg7Fs2TIcOHAAmZmZ+MMf/gAA+Oc//4n4+Hi8+uqriImJQUREBM6fPz/g/ffnX//6l/x9d3c3/v3vf/d7pjtt2jRUVlYiIiKi19Jfb0JtbS2ee+45rF27FvPnz7d6zdXVFZMmTUJlZaXV+ri4OBw9etRqXX5+vtXZPNDTuxITE2PzsT4IBjIRPTSUOhgwKSkJ0dHRePHFF/HNN9/g66+/xuLFizFr1qxeg5TuZ+XKlTh8+DDq6urwzTff4NixY3IoTpgwAaWlpTh8+DC+/fZbvPHGGzh58uSQHcf27dvxxRdfoLq6GsuXL4dOp8NLL73UZ9s1a9aguLgYr732mty7kJub2++gLqPRiJSUFMTExGDJkiW4evWqvFg89dRTKCoqstrul7/8Jf7+97/jt7/9Laqrq5GdnY3S0tJev6ewsHDANxQZKF5DJqKHihLvaS5JEnJzc7FixQrMnDkTKpUKycnJclfzQJhMJixfvhyNjY3w9vZGcnIyPvjgAwDA0qVLUVZWhueffx6SJOGFF17Aq6++OmTzbzdu3IiNGzeivLwcERERyMvLw+jRo/tsO2XKFBQUFOA3v/kNEhISIITA+PHje40st7h27Rqqq6tRXV2NsWPHWr0mhAAApKenIzY2Fnq9Hj4+PgCA+Ph4fPbZZ1i3bh3Wrl2LCRMm4Msvv7T6XFy+fBnFxcX49NNPh+Jt6JckLJXew61bt+Dj4wO9Xg9vb+9hLYiIqC/t7e2oq6u75xxbck4XL15EeHg4ysrKeg0Qs7eFCxdi2rRp+PWvf23zNmvWrIFOp8OHH37Yb5t7fT5tzVB2WRMR0UPjvffek+dd2yowMBAbNmwYporuYJc1ERE9NMLCwrBixYoBbZOZmTlM1VhjIBMR0bAKCwuDDVdHH3rssiYiInICDGQiIiInwEAmIiJyAgxkIiIiJ8BAJiIicgIMZCIiIifAQCYicrBFixbh3Xfftbl9Z2cnwsLCUFpaOoxVkb0xkImIHOjUqVM4dOgQMjIy5HUHDhzAk08+KT8ysLy83GobV1dXrF69GmvWrLFztTScGMikeHl5wKpVPV+JlGbr1q1YuHCh1e0cb9++jRkzZmDTpk39bvfiiy+iqKgIZ8+etUeZZAcMZFK0vDwgNRXYutWM1FSGMjmfixcvQpKkXktiYiJMJhP27duHlJQUq20WLVqEN998E0lJSf3u18/PD48//jj27Nkz3IdAdsJAJkU7erQbKpUZJpMKarUZx487uiIia8HBwWhqapKXsrIy+Pv7Y+bMmTh9+jT0ev2An2ls8dhjj6GwsHCIKyZHYSCTokVHV8NsVkGlMsFkUiEx0dEVkRLY8zKHWq2GVquFVquFr68vli1bhri4OGRnZ6O+vh5qtRqBgYEPtO+xY8eivr5+iCsmR+HDJUjRIiOPYOnST3D16jNYtCgec+dqHF0SOTnLZQ61GsjJAXJzgblz7fO7X3rpJbS2tiI/Px8qlQpGoxFubm6QJOmB9qfRaGAwGIa4SnIUniGTokmSGlFRh/GrX1VgwQKGMd3fsWM9YWwy9Xy112WOt99+G4cPH0ZeXh5GjhwJABg9ejQMBgM6OzsfaJ83btxAQEDAUJZJDsRAJsUym7thNDYDkNDVZXR0OaQQs2ffCWOTCXa5zLF//3689dZb2Lt3L8aPHy+vnzp1KgCgsrLygfZbUVGBmJiYoSiRnAC7rEmxdLoLaGmphYeHHzw9xzi6HFKIuXN7uqmPH+8J4+Hurq6oqMDixYuxZs0aTJ48GVevXgXQM5c4ICAA06ZNQ1FRkRzOQM+Zb0NDA65cuQIAOHfuHADI16ItCgsLsWHDhuE9ALIbniGTYtXXF0Kvv4zAwGhERf2vo8shBZk7F3j/fftcOy4tLYXBYMDbb7+NoKAgeZk/fz4A4OWXX8bu3buttsnLy0NMTAyeeeYZAMBPfvITxMTE4Pe//73cpqSkBHq9Hs8999zwHwTZBQOZFKu19To6OvQYOTIE7u6+ji6HqE9paWkQQvRajv/34nVaWhouX76MkpKS+26TnZ0tt8nJyUFWVhY0Go6d+K5gIJNiubhoAJj/+5VImTQaDXbt2oX//Oc/Nm/T2dmJ6OhorFq1ahgrI3vjNWRSrJ6BXCoO6CLFSxzgyDJXV1esW7dueIohh+EZMilSe/tN3LrVAA8PX2g0nPZBRMrHQCZFOnfu/3D9ehV8fELw/e/PcHQ5RESDxkAmRWpvb0NnZxsCAqZg1Kjx99+AiMjJMZBJkYQwwWzugqurJ1QqDoUgIuVjIJMidXS0wWw2oaOjzdGlEBENCQYyKZKrqxdUqhFwdfW6f2MiIgVgIJMiqVRqqNUuUKnUji6FaFASExOxcuVKR5dBToCBTIokhAkmUyeEMDm6FKL7SktLgyRJvZba2lpHl0ZOhKNhSJF4DZmUJjk5GTt37rRax0cn0t14hkyK1NKiR1tbG1pa9I4uhcgmbm5u8tOaLIta3fuSi06nw+LFi+Hn5wcPDw88/fTTqKmpAQAIIRAQEIB9+/bJ7adOnYqgoCD556KiIri5ucFgMAz/QdGQYiCT4mzZsgXbtv0O58/XY9u232HLli2OLoloyKSlpaG0tBR5eXkoKSmBEAJz5sxBV1cXJEnCzJkz5QdT6HQ6VFVVwWg0orq6GgBQUFCARx99FB4eHg48CnoQDGRSlIqKCuTk5ACQoFa7A5CQk5ODiooKB1dGdG8HDx6El5eXvCxcuLBXm5qaGuTl5eGjjz5CQkICfvCDH2D37t24fPkyvvzySwA9g8AsgXzixAnExMRYrTt+/DhmzZplp6OiocRAJkVpaGiA0WgEEAC93gtAAIxGIxoaGhxdGtE9zZ49G+Xl5fLSV89OVVUVRowYgR/96EfyOn9/f0ycOBFVVVUAgFmzZqGyshLXr19HQUEBEhMT5UDu6upCcXHxgB9WQc6Bg7pIUUJCQqDRaFBf3wmTyR+NjQZoNBqEhIQ4ujRSELO5GwZDCzw8/O12pzdPT09EREQMej/R0dEYNWoUCgoKUFBQgHfeeQdarRabNm3CyZMn0dXVhfj4+CGomOyNZ8ikKFFRUVi5ciWEUOPbb29CCDVWrVqFqKgoR5dGCmIwtMBguA6DocXRpViJjIxEd3c3vvrqK3ldS0sLzp07h0mTJgEAJElCQkICcnNzcfbsWcyYMQNTpkxBR0cHduzYgdjYWHh6ejrqEGgQeIZMipORkYEnnngCDQ0NCAkJYRjTgHl4+Ft9dRYTJkxAamoqfvGLX2DHjh0YOXIkXn/9dXzve99Damqq3C4xMRGZmZmIjY2Fl1fP3epmzpyJ3bt3Iysry1Hl0yDxDJkUKSoqCnPmzGEY0wNRqUbAy2uMUz6YZOfOnfjhD3+IZ599FnFxcRBC4NChQ3BxcZHbzJo1CyaTyepacWJiYq91pCySEELcr9GtW7fg4+MDvV4Pb29ve9RFRGSlvb0ddXV1CA8Ph7u7u6PLIbJyr8+nrRnKM2QiIiInwEAmIiJyAgxkIiIiJ8BAJiIicgIMZCIiIifAQCYiRbFhYgiR3Q3F55KBTESKYJmHy8cKkjOyfC7vni8+UM43K56IqA9qtRq+vr5obm4GAHh4eECSJAdXRQ87IQQMBgOam5vh6+vb5zOubcVAJiLF0Gq1ACCHMpGz8PX1lT+fD4qBTESKIUkSgoKCEBgYiK6uLkeXQwSgp5t6MGfGFgxkIlIctVo9JH8AiZwJB3URERE5AQYyERGRE2AgExEROQGbriFbJjzfunVrWIshIiL6rrFk5/1uHmJTILe2tgIAgoODB1kWERHRw6m1tRU+Pj79vi4JG+73ZTabceXKFYwcOZIT8YmIiAZACIHW1laMHTsWKlX/V4ptCmQiIiIaXhzURURE5AQYyERERE6AgUxEROQEGMhEREROgIFMRETkBBjIREREToCBTERE5AT+H6mfs7hJOWpZAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n = 2000\n", + "traj = torch.stack(trajectory2).cpu().detach().numpy()\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(0)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(1)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Now let's try a different Interpolant type\n", + "\n", + "## Let's create an architecture that has a formal time embedding as here we use more timesteps" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "from typing import List\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "\n", + "class Network(nn.Module):\n", + " def __init__(\n", + " self, dim_in: int, dim_out: int, dim_hids: List[int],\n", + " ):\n", + " super().__init__()\n", + " self.layers = nn.ModuleList([\n", + " TimeLinear(dim_in, dim_hids[0]),\n", + " *[TimeLinear(dim_hids[i-1], dim_hids[i]) for i in range(1, len(dim_hids))],\n", + " TimeLinear(dim_hids[-1], dim_out)\n", + " ])\n", + "\n", + " def forward(self, x: torch.Tensor, t: torch.Tensor):\n", + " for i, layer in enumerate(self.layers):\n", + " x = layer(x, t)\n", + " if i < len(self.layers) - 1:\n", + " x = F.relu(x)\n", + " return x\n", + " \n", + "class TimeLinear(nn.Module):\n", + " def __init__(self, dim_in: int, dim_out: int):\n", + " super().__init__()\n", + " self.dim_in = dim_in\n", + " self.dim_out = dim_out\n", + "\n", + " self.time_embedding = TimeEmbedding(dim_out)\n", + " self.fc = nn.Linear(dim_in, dim_out)\n", + "\n", + " def forward(self, x: torch.Tensor, t: torch.Tensor):\n", + " x = self.fc(x)\n", + " alpha = self.time_embedding(t).view(-1, self.dim_out)\n", + " return alpha * x\n", + " \n", + "class TimeEmbedding(nn.Module):\n", + " # https://github.com/openai/glide-text2im/blob/main/glide_text2im/nn.py\n", + " def __init__(self, hidden_size, frequency_embedding_size=256):\n", + " super().__init__()\n", + " self.mlp = nn.Sequential(\n", + " nn.Linear(frequency_embedding_size, hidden_size, bias=True),\n", + " nn.SiLU(),\n", + " nn.Linear(hidden_size, hidden_size, bias=True),\n", + " )\n", + " self.frequency_embedding_size = frequency_embedding_size\n", + "\n", + " @staticmethod\n", + " def timestep_embedding(t, dim, max_period=10000):\n", + " \"\"\"\n", + " Create sinusoidal timestep embeddings.\n", + " :param t: a 1-D Tensor of N indices, one per batch element.\n", + " These may be fractional.\n", + " :param dim: the dimension of the output.\n", + " :param max_period: controls the minimum frequency of the embeddings.\n", + " :return: an (N, D) Tensor of positional embeddings.\n", + " \"\"\"\n", + " # https://github.com/openai/glide-text2im/blob/main/glide_text2im/nn.py\n", + " half = dim // 2\n", + " freqs = torch.exp(\n", + " -math.log(max_period)\n", + " * torch.arange(start=0, end=half, dtype=torch.float32)\n", + " / half\n", + " ).to(device=t.device)\n", + " args = t[:, None].float() * freqs[None]\n", + " embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)\n", + " if dim % 2:\n", + " embedding = torch.cat(\n", + " [embedding, torch.zeros_like(embedding[:, :1])], dim=-1\n", + " )\n", + " return embedding\n", + "\n", + " def forward(self, t: torch.Tensor):\n", + " if t.ndim == 0:\n", + " t = t.unsqueeze(-1)\n", + " t_freq = self.timestep_embedding(t, self.frequency_embedding_size)\n", + " t_emb = self.mlp(t_freq)\n", + " return t_emb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DDPM Interpolant\n", + "### note DDPM is typically used with a Gaussian Prior. Here we show it working with the Cusotm Moon prior as an example." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.interpolants import DDPM\n", + "from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule, DiscreteLinearNoiseSchedule\n", + "from bionemo.moco.schedules.inference_time_schedules import DiscreteLinearInferenceSchedule\n", + "from bionemo.moco.distributions.prior import GaussianPrior\n", + "DEVICE = \"cuda:0\"\n", + "uniform_time = UniformTimeDistribution(discrete_time=True, nsteps = 1000)\n", + "simple_prior = GaussianPrior()\n", + "ddpm = DDPM(time_distribution=uniform_time, \n", + " prior_distribution=simple_prior,\n", + " prediction_type = \"noise\",\n", + " noise_schedule = DiscreteLinearNoiseSchedule(nsteps = 1000),\n", + " device=DEVICE)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train the Model" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000: loss 0.320\n", + "2000: loss 0.372\n", + "3000: loss 0.330\n", + "4000: loss 0.409\n", + "5000: loss 0.338\n", + "6000: loss 0.378\n", + "7000: loss 0.355\n", + "8000: loss 0.394\n", + "9000: loss 0.359\n", + "10000: loss 0.338\n", + "11000: loss 0.257\n", + "12000: loss 0.293\n", + "13000: loss 0.333\n", + "14000: loss 0.329\n", + "15000: loss 0.322\n", + "16000: loss 0.302\n", + "17000: loss 0.282\n", + "18000: loss 0.331\n", + "19000: loss 0.289\n", + "20000: loss 0.322\n" + ] + } + ], + "source": [ + "# Place both the model and the interpolant on the same device\n", + "dim = 2\n", + "hidden_size = 128\n", + "num_hiddens = 3\n", + "batch_size = 256\n", + "model = Network(dim_in=dim, \n", + " dim_out=dim, \n", + " dim_hids=[hidden_size]*num_hiddens)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr = 1.e-3)\n", + "DEVICE = \"cuda\"\n", + "model = model.to(DEVICE)\n", + "ddpm = ddpm.to_device(DEVICE)\n", + "for k in range(20000):\n", + " optimizer.zero_grad()\n", + " shape = (batch_size, dim)\n", + " x0 = ddpm.sample_prior(shape).to(DEVICE)\n", + " x1 = sample_moons(batch_size).to(DEVICE)\n", + "\n", + " t = ddpm.sample_time(batch_size)\n", + " xt = ddpm.interpolate(x1, t, x0)\n", + "\n", + " eps = model(xt, t)\n", + " loss = ddpm.loss(eps, x0, t).mean()\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " if (k + 1) % 1000 == 0:\n", + " print(f\"{k+1}: loss {loss.item():0.3f}\") " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Let's vizualize what the interpolation looks like during training for different times" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x0 = ddpm.sample_prior(shape).to(DEVICE)\n", + "x1 = sample_moons(batch_size).to(DEVICE)\n", + "for t in range(0, 900, 100):\n", + " tt = ddpm.sample_time(batch_size)*0 + t\n", + " out = ddpm.interpolate(x1, tt, x0)\n", + " plt.scatter(out[:, 0].cpu().detach(), out[:, 1].cpu().detach())\n", + " plt.title(f\"Time = {t}\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create the inference time schedule and sample from the model" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "schedule = DiscreteLinearInferenceSchedule(nsteps = 1000, direction = \"diffusion\").generate_schedule(device= DEVICE) \n", + "sample = ddpm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "for t in schedule:\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " vt = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = ddpm.step_noise(vt, full_t, sample)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/dreidenbach/mambaforge/envs/moco_bionemo/lib/python3.10/site-packages/IPython/core/pylabtools.py:170: UserWarning: Creating legend with loc=\"best\" can be slow with large amounts of data.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = ddpm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "for t in schedule:\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " eps_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = ddpm.step(eps_hat, full_t, sample)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAHiCAYAAAA597/kAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/XmUHPd53ot/aq/el+meFQMMNgIEd4qWqIUSlSjariX62lbs3Fw7tuXYTizryldeEh/b0rGVHDs+917FPkmuFTuO/Ts+kXxty6RkxpJMi5soUtxJkASIbTCDWXt6X2qv+v1R1YWewUKAAEmQqOccHADdVdXV3dX1fN/3fd7nFYIgCEiQIEGCBAkSvKEQ3+gTSJAgQYIECRIkhJwgQYIECRJcEUgIOUGCBAkSJLgCkBByggQJEiRIcAUgIeQECRIkSJDgCkBCyAkSJEiQIMEVgISQEyRIkCBBgisACSEnSJAgQYIEVwDkC9nI932Wl5fJ5XIIgvBan1OCBAkSJEjwlkEQBHS7XaanpxHFc8fBF0TIy8vLzM7OXraTS5AgQYIECa42LC4usm3btnM+f0GEnMvl4oPl8/nLc2YJEiRIkCDBVYBOp8Ps7GzMpefCBRHyME2dz+cTQk6QIEGCBAleBV6p5JuIuhIkSJAgQYIrAAkhJ0iQIEGCBFcAEkJOkCBBggQJrgBcUA35QuF5Ho7jXM5DJkjwqqEoCpIkvdGnkSBBggQXhMtCyEEQsLq6SqvVuhyHS5DgsqFYLDI5OZn0zydIkOCKx2Uh5CEZj4+Pk06nk5tfgjccQRAwGAxYX18HYGpq6g0+owQJEiQ4Py6ZkD3Pi8l4bGzscpxTggSXBalUCoD19XXGx8eT9HWCBAmuaFyyqGtYM06n05d8MgkSXG4Mr8tE25AgQYIrHZdNZZ2kqRNciUiuywQJErxZkLQ9XSTm5ub44he/+EafxuuG+++/H0EQXnPB3h//8R/zwQ9+8KL2uf322/mrv/qr1+iMEiRIkOD1xVVLyD/xEz+BIAgIgoCqquzZs4ff+q3fwnXd8+73+OOP8zM/8zOv01leHTBNk9/4jd/gc5/7XPzYYDDg3/7bf8vu3bvRdZ1qtcr73vc+7r777nibX//1X+ff/Jt/g+/7b8RpJ0iQIMFlxVVLyAAf/vCHWVlZ4ciRI3z2s5/l85//PL/3e7931m1t2wagWq1eUr18eJwEp/GXf/mX5PN53v3ud8eP/dzP/Rx//dd/zR/8wR9w6NAh/u7v/o4f/uEfpl6vx9t85CMfodvt8j//5/98I047QYIECS4rrmpC1jSNyclJduzYwb/6V/+KD3zgA9xzzz1AGEH/wA/8AP/u3/07pqen2bdvH3BmynphYYG77rqLbDZLPp/nn/7Tf8ra2lr8/Oc//3luvvlm/uiP/oidO3ei6/pZz+XkyZN87GMfo1QqkclkuO6667j33nuBUMn+yU9+kp07d5JKpdi3bx//8T/+x037D8/33//7f8/ExATFYjGO+H/5l3+ZcrnMtm3b+JM/+ZN4n/n5eQRB4Mtf/jLvete70HWd66+/ngceeOC8n9vDDz/MHXfcQSqVYnZ2lk9/+tP0+/1zbj83NxdnI0b/DPHlL3+Zj33sY5v2ueeee/i1X/s1PvrRjzI3N8fb3vY2fuEXfoGf+qmfireRJImPfvSjfPnLXz7v+SZIkCDBmwFXNSFvRSqV2hTB3nfffRw+fJhvfetbfP3rXz9je9/3ueuuu2g0GjzwwAN861vf4vjx4/zIj/zIpu2OHj3KX/3VX/HXf/3XPPPMM2d97Z//+Z/HsiwefPBBnn/+eX73d3+XbDYbv862bdv4//6//48XX3yR3/zN3+TXfu3X+Iu/+ItNx/iHf/gHlpeXefDBB/m//+//m8997nN8//d/P6VSiccee4yf+7mf42d/9mc5derUpv1++Zd/mc9+9rM8/fTTvPOd7+RjH/vYpkh0FMeOHePDH/4wP/RDP8Rzzz3HV77yFR5++GE+9alPnfNzffzxx1lZWWFlZYVTp05x++23c8cdd8TPP/zww9x2222b9pmcnOTee++l2+2e87gAb3/723nooYfOu02CBAkSvCkQXADa7XYABO12+4znDMMIXnzxxcAwjAs51Hnx/PPPB3/7t38bPP/885d8rFfCv/gX/yK46667giAIAt/3g29961uBpmnBL/3SL8XPT0xMBJZlbdpvx44dwf/z//w/QRAEwTe/+c1AkqRgYWEhfv6FF14IgOB73/teEARB8LnPfS5QFCVYX18/7/nccMMNwec///kLPv+f//mfD37oh35o0/vZsWNH4Hle/Ni+ffuCO+64I/6/67pBJpMJ/sf/+B9BEATBiRMnAiD4nd/5nXgbx3GCbdu2Bb/7u78bBEEQfPvb3w6AoNlsBkEQBJ/85CeDn/mZn9l0Lg899FAgiuIFXQOf/vSngx07dsSfR7PZDIDgwQcf3LTdAw88EGzbti1QFCW47bbbgs985jPBww8/fMbx7r777kAUxU3vexSX8/pMkCBBgleD83HoKK6YCPn3f//3+fjHP84nP/lJPv7xj/P7v//7r/lrfv3rXyebzaLrOh/5yEf4kR/5ET7/+c/Hz99www2oqnrO/V966SVmZ2eZnZ2NHztw4ADFYpGXXnopfmzHjh1Uq9XznsunP/1pvvCFL/Dud7+bz33uczz33HObnv9P/+k/8ba3vY1qtUo2m+VLX/oSCwsLm7a57rrrEMXTX+nExAQ33HBD/H9JkhgbG4vdq4Z45zvfGf9blmVuu+22Tec/imeffZb//t//O9lsNv7zoQ99CN/3OXHixHnf45e+9CX++I//mHvuuSf+PAzDADgjlf/e976X48ePc9999/HDP/zDvPDCC9xxxx389m//9qbtUqkUvu9jWdZ5XztBggQJrnRcEYR88OBBvvjFLxIEAVNTUwRBwBe/+EUOHjz4mr7u+9//fp555hmOHDmCYRj86Z/+KZlMJn5+9N+Xggs5zk//9E9z/PhxfuzHfoznn3+e2267jT/4gz8AwhrrL/3SL/HJT36Sb37zmzzzzDP85E/+5BkCMUVRNv1fEISzPnYpquRer8fP/uzP8swzz8R/nn32WY4cOcLu3bvPud+3v/1tfuEXfoE/+7M/48Ybb4wfHxsbQxAEms3mGfsoisIdd9zBr/7qr/LNb36T3/qt3+K3f/u3N73vRqNBJpOJXbkSJEiQ4M2KK4KQFxYWMAyDUqmEKIqUSiUMwzgjArzcyGQy7Nmzh+3btyPLF+8ieu2117K4uMji4mL82Isvvkir1eLAgQMXfbzZ2dlYXfzZz36W//pf/ysA3/nOd3jXu97Fv/7X/5pbbrmFPXv2cOzYsYs+/rnw6KOPxv92XZcnn3ySa6+99qzb3nrrrbz44ovs2bPnjD/nyiYcPXqUH/7hH+bXfu3X+MEf/MFNz6mqyoEDB3jxxRdf8TwPHDiA67qYphk/dvDgQW655ZYLeZuvC3zfpddbw/fP3z6XIEGCBFtxRRDy9u3bSaVSNJtNfN+n2WySSqXYvn37G31q58UHPvABbrjhBv75P//nPPXUU3zve9/jx3/8x3nf+953hkjplfCZz3yGb3zjG5w4cYKnnnqKb3/72zEp7t27lyeeeIJvfOMbvPzyy/zGb/wGjz/++GV7H//pP/0nvvrVr3Lo0CF+/ud/nmazuUnNPIpf/dVf5ZFHHuFTn/pUnF24++67zynqMgyDj33sY9xyyy38zM/8DKurq/GfIT70oQ/x8MMPb9rvzjvv5A//8A958sknmZ+f59577+XXfu3XeP/7308+n4+3e+ihhy7aUOS1xGBQZzCoMRicXRSXIEGCBOfCFUHI119/PZ/5zGcQBIGVlRUEQeAXf/EXuf7669/oUzsvBEHg7rvvplQq8d73vpcPfOAD7Nq1i6985SsXfSzP8/j5n/95rr32Wj784Q9zzTXX8J//838G4Gd/9mf5wR/8QX7kR36Ed7zjHdTrdf71v/7Xl+19/M7v/A6/8zu/w0033cTDDz/MPffcQ6VSOeu2N954Iw888AAvv/wyd9xxB7fccgu/+Zu/yfT09Fm3X1tb49ChQ9x3331MT08zNTUV/xnik5/8JPfeey/tdjt+7EMf+hB/+qd/ygc/+EGuvfZafuEXfoEPfehDm5TlS0tLPPLII/zkT/7kZfokLh3p9BjpdJV0Ohm0kiBBgouDEARB8EobdTodCoUC7XZ7U3QCocvSiRMnzttje6E4ePAgCwsLbN++/Yon47cC5ufn2blzJ08//TQ333zzG3oun/jEJ7j11lv5t//2317wPr/6q79Ks9nkS1/60jm3uZzXZ4IECRK8GpyPQ0dxWeYhXy5cf/31CRFfpfi93/s9vva1r13UPuPj4/yf/+f/+Rqd0eWD77sMBnXS6TFE8Yr6ySVIkOAKQnJ3SHBFYG5ujl/4hV+4qH0++9nPvkZnc3kxrCsDZLMTb/DZJEiQ4EpFQshXMebm5riAikWCS8SwnpzUlRMkSHA+XBGirgQJ3uw4X7uTKMpksxNJujpBggTnRULICRJcBiTtTgkSJLhUJEv2BAkuA5K0dIIECS4VSYScIMEl4mwq6sSxK0GCBBeLhJATJLhEnC1dnaSwEyRIcLFIUtYJElwizpauTlLYCRIkuFgkhJwgwSViqKJ+pccSJEiQ4HxIUtbnwY/92I/x7//9v7/g7Tc2NhgfH+fUqVOv4VkleC3guiZrawdxXfOc21xIXTipHSdIkODVIiHkc+DZZ5/l3nvv5dOf/nT8WBAE/OZv/iZTU1OkUik+8IEPcOTIkfj5SqXCj//4j/O5z33ujTjlBJeAev0oGxuHWVx8NCbTreR6IXXhpHb82iJZ8CR4KyMh5HPgD/7gD/jEJz5BNpuNH/sP/+E/8Pu///v8v//v/8tjjz1GJpPhQx/60Kb5vD/5kz/Jn//5n9NoNN6I007wKlEqzSEIAoqix2Q6GNTp9Vap1Q7h++4FTXK6lGlPCdmcG8PPptdbSxY8Cd6yuGoJeX5+HkEQzvhz55134nkef/mXf8nHPvaxePsgCPjiF7/Ir//6r3PXXXdx44038md/9mcsLy/zN3/zN/F21113HdPT03z1q199A95VglcL2+5TLu9GUbKbBFmCIBEEbkQErzwg4kJcuc5FvEl0fW6M+oEn4y0TvFVx1RLy7OwsKysr8Z+nn36asbEx3vve9/Lcc8/Rbre57bbb4u1PnDjB6uoqH/jAB+LHCoUC73jHO/jud7+76dhvf/vbeeihh16395Lg0pFOj5HNTlKt7o/JVBRlqtX9ZLPh7ObLRZZDchlGfENiTmYpnxvDzyabnbggG9Ik25DgzYgrSmV9zz3w7W/D+98PH//4a/takiQxOTkJhDNzf+AHfoB3vvOdfP7zn+eee+5BkiTGx8fj7VdXVwGYmNisnJ2YmIifG2J6epqnn376tX0DCS4rRlXRW40+stkJfN9FFOWYLF3XpF4/ytjYHmT54uYsp9Nj+L5Lv19DEMLHhiSTKLPPjov9bJIJWwnejLhiCPmee+Cuu0CS4ItfhLvvfu1JeYif+qmfotvt8q1vfQtRFDEMA03TEIZ3y4tEKpViMBhc5rNM8FphGE1BePM+2818KyHU60dpNI7g+y653FRM1GdLa28l+OGfsEwiJRHxa4CkDzzBmxFXDCF/+9shGXte+Pf9978+hPyFL3yBb3zjG3zve98jl8sBoVp6MBhg2zaqqgLE0fTa2hpTU1Px/mtra9x8882bjtloNKhWq6/9ySd4RQRBgO97501dDgZ1Go2jQLApCh5Gsmcj2bGxPQBoWi4m7/BYtU3RtCjKZyX40ddIpkBdGs72HSXZhgRvRlwxNeT3v/80GXse3Hnna/+af/VXf8Vv/dZv8Rd/8Rfs3r07fnxIsC+++GL82M6dO5mcnOS+++6LH+t0Ojz22GO8853v3HTcgwcPcsstt7y2J5/gguD7LkHgYRit+P9ba4vp9Bjl8h7K5b3xTT2dHotU1qGqt9NZivuUfd/FNNtUq/vJ52fiuu+wzgmb681nqw2Pir+SeuelIRHDJXir4IpZmn/842Ga+v77QzJ+raPjgwcP8uM//uP86q/+Ktddd11cB1ZVlWq1yq233srDDz8ck7MgCHzmM5/hC1/4Anv37mXnzp38xm/8BtPT0/zAD/xAfNzBYMCTTz55UYYiCV47hKlhiVSqCJy9tjgkx6HIavjvRuMIxeJO0ukq3e4KrdYJADKZ6lkj4eExRx8/V4QNpxcHYS1Z2HROCUKc7/Mb4pXS0+ca/nEhqvkECV5PXFFX4sc//vrVjZ944gkGgwFf+MIX+MIXvhA//r73vY/777+fn/7pn+bP/uzP+NSnPhU/9yu/8iv0+31+5md+hlarxXve8x7+7u/+Dl0/Leq5++672b59O3fcccfr80YSnBeCICCKUnzTPdfNe2vaOto7JmtdLyCKMmNje7ZMdFqh36+doc4eEuswwoYzyXb4mr7vkkqF5D0k8wQhLkSc9Urp6bMdIxF9JbgSIQRBELzSRp1Oh0KhQLvdJp/Pb3rONE1OnDjBzp07NxHTmx2GYbBv3z6+8pWvnJGSPh9uv/12Pv3pT/O//W//22t4dgkuBEEQMBj0OHlykV27dp31+hxGSrpeYDCob4puTbN9zsh2uE+9fpQg8MhmJ+M094VGYr7v0uksYRhNUqkStt2NW3sShLgckWwSISd4o3E+Dh1FciWeA6lUij/7sz9jY2PjgvfZ2NjgB3/wB/ln/+yfvYZnluBCEUacHkHgn3Ob0Ugpn5+JI9rzRV2j+1Sr++Mb+9ao65Vu+qIoI8s6kiRHi4CkB3krLoc461zDP862gEqQ4I1EchWeB3depLKsUqnwK7/yK6/NySTYhFA97cbtQ2dD2F4kIQjn1i4O67zDP0NC1PUCvd7aWduZtiqkz6acHu5zvrTo8DVVNbfpeBeCS43wkggxSVsnuPJwdf4SE7wpMUrCQzIDkCTlrNuH9WOZIPDPqWAe9gQPb8yjkdPWdiY4u4HHKLmNPv5KYqPBoI5pNgkCEISLiwYvlUwSMnp1YrAECV5LJFdZgjcNRkl4VED1SvsM257S6exZtxnekMMbcEhSul6g36/FYq7R7bbiXOT2SgQ7Go0P69UXiks1vrhajTPO5sJ2LiSLlgSvN66YPuQECV4JW12uJEl5RTe1rW1P58KQ7HW9hK4XWFs7yPr6C6ytHQROR8Znw8V6UG91BpNlfZMq+0L6kS9kiMWr2f9K7ol+tec2ut/F9CyPfq9X8ueS4K2DJEJO8KbBkIQvdh9BEDGMFrqun5XATrcfeWQyoX95qzVPvX4YUZQoFGY3+VyPkulwgTAUcZ2r7jyE77vUaocIAjc+xuh5nJ5o9PoKjoZkNcwSbG3luhLwaiPWrZ/r8O8LEd1dSPtaggSXC1fOry1BgktEWGN2ABDF09FzEPiYZoPBQDnrAImhU1e/X4uJcmbm+ygW58hkqptu3r7v0mgcYbRHeYjz1Z1HtwkCD0GQz4ioR8ni9U6XDl9P10sIgkwQeAwG9SuKfF5tmn20NDBKwBdDsldrij/B64uEkBO8ZeD7Lq5rEZp7ePEUJkEQ0fXiJuX0VsLL52fiwRLDmm61up9mcz62yhwSVrm8Fzjz5jyq2D7XDfx8HtajkfYwff56EcDoeQ0/hyuNfF5tC9SoE9vod34xJJt4Yyd4PZAQ8jlw5513cvPNN/PFL37xjT6VBK+A0+prCVnW8DwXCOJ6nyAIZDKVmFTh7BHP8Kbb6SzRaBzF81xsuwOE/cbD7c+Vxh1VbJ+rz/VC+l/DxcIGgiC95iRwLoX4W5F8tra06XrhDT6jBAk246oWdf3ET/xEVGPc/Ofo0aNv9KkluAiM9hGDgKLoiKJyBtmNinRGiXG4b6+3hm33qNUOYdsDVDVDsbiTUmnuFeu5w/11vRC/xjAKH3pkDxcIo8KioVtXp7MUP59OjxEEAf3+6f1G9z+fwGj4nOuaFyRCOpfI6a0oYhouuIYLs3r9aDKUIsEVhas+Qv7whz/Mn/zJn2x6LBmd+ObCaZIcRsUBcKb6+kJqvrXaS5hmE0EQUZRpstlJbLt/1lrjaHR5vhGLo+1UQ1/sYUtVp7PE8eP3kc/PxOeYTo+RyVQxjDr9frifaTbj/c9XXx4+Fw6s4KzbjOJ83t5vVRHT8L2qaoZ6/Wg8wetKErAluDpxVUfIAJqmMTk5uemPJElnbNdsNvnxH/9xSqUS6XSaj3zkIxw5cgQIU6bVapW//Mu/jLe/+eabN81Nfvjhh9E0jcFg8Nq/qasMQ/X1aFQ82rN8LoxGzMN/z8zcRrm8h/Hx6/A8B9c1N0W9oxiNLs81YvF0mvR0Pdg02whC+LdhNPE8l8GgRbe7Qq+3Eh9PECQ8z4rIu7SJPM/VZjV8bmxszwW1Yp2t/eliathvxkh6+J5tu49ltWi15pMoOcEVgauekC8UP/ETP8ETTzzBPffcw3e/+12CIOCjH/0ojuMgCALvfe97uf/++4GQvF966SUMw+DQoUMAPPDAA3zf930f6XT6DXwXb21sJeZXinhGyWj4b1XNkslUqdVepNWap9E4Rq126KyEcy5iHCWpcIzj0fj1tu5Xre6nUrmGdLqEZXVi9bVptkmlSjiOETuObZ0mdb5WnWFv86uJ+oYOYsPXPB/pvtlmEY++l1Bdv5dyec95Fx5vxkVHgjcnrnpC/vrXv042m43/fOITnzhjmyNHjnDPPffwR3/0R9xxxx3cdNNN/Pmf/zlLS0v8zd/8DRCKwIaE/OCDD3LLLbdseuz+++/nfe973+v0rq5ujPYre57DBQw0O+OmqygZVDWHpuUxjLBPeSvpjBLjaL24VjsUR7ohgrPe1Ifq7dnZ26lU9pFKlePxjiFpVyiVdpJOV1DVDGtrB3Fd85znfLmwdaGxteY9+poXa4ryanA532evt8bGxiF6vTVEUSafnyGfnznvwuXNtuhI8ObFVV80ef/7389/+S//Jf5/JpM5Y5uXXnoJWZZ5xzveET82NjbGvn37eOmll4BwjvL/8X/8H9RqNR544AHuvPNOJicnuf/++/nkJz/JI488kgyeeJ1xtmlP5zKDGN50fd/F8yxMs0OxuJ1cbopcLiw9nI10XNekXj9KqTQXH39rn/Ewytxar+52VzCMOppWiN3HTLNNNqvH0alpNkmnqzSb81H/M0xMXA+cJpdUKoy0zzUu8mKxtdZ+vv7o16Md6PLXs195gTaKpAc5weuFK4qQ3wgz90wmw549ey75ODfccAPlcpkHHniABx54gH/37/4dk5OT/O7v/i6PP/44juPwrne96zKccYILhSiGWoDRaU/nurmPCrBWVp7Fslo4TiVOH49ek6NuXf1+jVbrBBASpeuaGEYzjnSHrzM6Z3l4jG53hW53ldXVZ6lUrqVQmN100x8lgmGLztjYnk0mJZbVBqBeP3qGiOvV/p627ne+iVavBy7naw4XERdzrKQHOcHrhSuKkK9UZee1116L67o89thjManW63UOHz7MgQMHgDBNescdd3D33Xfzwgsv8J73vId0Oo1lWfzhH/4ht91221mj7wSvHXzfA9gUIW+9uY+2CRlGk1SqxNTUTZhmJ446t16Tg0GdjY3DmGabiYnr0PUSpdJcbItpGHUkSaHbXWFm5jZUdfNQC993qdePIMsqjmOgKCkkSY17nYfmJaNGIYNBnVSqtCk9ruslZmbeEb+f0QEV57PofCWc73f4RpDT5XzNhFwTXMm4ogj5Sk0N7d27l7vuuot/+S//JX/4h39ILpfj3/ybf8PMzAx33XVXvN2dd97JZz/7WW677Tay2fAm/N73vpc///M/55d/+ZffqNO/arF1HvLZIsZeb43Fxe/SaJzAdQdUKvsZH7+OiYnro0jqzElP6fQYqVQZCDDNTpxqhjYbG4ex7S6dzirt9nF832P37n+8ieS63RU2Ng4jCCLj4wfwPIfZ2dtjO8debyX2kgao1Q7R768hitIZ85iHxOu6ZuxMNnxf/f4amlaIVdPn66E+17znS8laJeMLEyS4OFxRoq5LnWDzWuJP/uRPeNvb3sb3f//38853vpMgCLj33ntRlNPDDt73vvfheR533nln/Nidd955xmMJXh9snQg1KrzqdJZotU7S7a7g+x6qmiGTmUTXi7GPM2y+JkdNPFKpEpXKfjKZKsOapOuatNsLOI6JpqXJZifjyHm0jSiVKiFJCoXCDJpWYHb2dkyzHSt/gwD6/fXI6rGO55kEAWSzU7Tbi3Q6SzFpLi4+yuLid3n66T/l8OGv024vxAKoIYGbZnOTIGmrSGqraOlsYrVXI2h6LcVQr4fyOVFXJ3i9IQQXIEHtdDoUCgXa7Tb5fH7Tc6ZpcuLECXbu3Imu6+c4QoIEbwxGr09VDQnGdU1WVp7CdW1EUaJYnCOVKkXOWA3S6TyynGZi4npkWd9Us93YOEyrNU8+v41MZjxOI6fTY5w8+R1WVp4iCHx0vcT09K1MTd0cE1M6Xd00FQqIPZZXV5/Dtvtcc82HGQzqLC09TrE4R7W6n6WlJ9C0HJbVpdU6gaYV2b49LJ10OqdYXn6aVusEkqSyfft7yGRCUk+lSsCZC92hp/PZzmdrzXyUlC52wXw5I+Stx9r6Hl4LvB6vkeDqwPk4dBRXXiiaIMHrAE3LI0kWltUFQJZ1arVDbGwcRlUzZLMTtNsLXHPNRzcNltC0PIqSJgiInLTWEQQJVc3geTYTEzdFJLYcp5OHCuxRD2VRlOPpQ2FN+TCm2SKTqTA2thdRFLGsNs3mPKlUkSCAQmE27pMe7pvNTnLjjT9KrRb2u4+N7WFl5RkUJU2zeYJUqoSuF6nVDsVCM9c18Tw3FoqNenD3+zUsq02hMIttD+J9zjXh6ny42Hrt+Qh8a1379ShvXakltARvXSSEnOAth9PDJs68qfd6K3iei6YVUBSbdvsUjcYxUqkSExPXk0qNo6o6J09+h2bzJJnMOKXSTmQ5Rbe7AvhkMlVKpZ0MBg02Nl6m3V4AIJUqMj19WzwlynVNNjYOMxhssGPHezbZWnqexfz8Q8iyjiQp7N79T+h2V5mZuQ1Z1pmaehuG0aRUmsO2+1HPcjOezdzrrcUtUaqaZWLietbWDrK4+BipVAHHGaBpWQRBwjCasRI8k6nSas0T1r/DFqsw1b6I77sIgoDvu6yvH6bROIzrmkxN3RxPuBqdmHW5o97zicm2kuPrIc5KBGAJXm8khJzgisMooQ7rvxfz/LlsM9PpsSgCrGMYTQyjhe97WFaXwWAD2+6hqikGgw263VNYVptW6ySKkmJ5+WkGgzqSpKMoGpKk4TgDbLuNYbRwnE5U77Xo9daZmLguItMeiqLHkXK/X6NUmmNp6QkMo0G/v0ouN00+P8Pu3f84PldRlDGMOvX66b7j4Xsbei8rSppudwVVzbC09AQrK08BMDV1a1yXHgqzRFGOo91yeU/8eUDYMrW+/jwQkMttiyw7zbiuPSSmkDDrm3y1LwUXE/Um5JjgakBCyAmuOIwS6tBx62KeH7WYBG/T49XqflKpUkRkGwwGdURRxnEMVlefRddD9XQqVSKTqTI+fi2Li4/TbB7DcQx830SWs0iSTD6/HRCRJIlut4vrrtBsHmdt7SC23WXnzjuZnb2dxcVHEUWFZnMeQQDb7jM7ezuyrNPvT5LJjG/qLx6SaLt9Mqpzy7HiemPjEEEAmcwYhtFiMNig2TxOPj9NtXo96XQ5rn1ns3r8vicmrt90/FAVHqJUmqPXW6NQ2IbjGBhGHc+zKRRmY1OUTmeJU6cep1TaTi43c1bSvNia8RsR9SZIcCUjIeQEbzi2RrybCfVMvNLzo9aZ59p/YuJ66vWjBEFAr7eKbXexrC6u6yCKIrKsUyhsp9fboN1eoNk8RjY7RS63DVHUKJd3YdsmxeIOJiaup9mcp15/mXr9KIqSRtNyuK5JrbaCougYRismPF0vIMt6RMjrKErYnx72DXvxORYKOwgC8DyLWu0QipKi3T5JJjOFIMjMzNzG4uJj+L6FIMhMTFwXi66GDmJjY3tiYdqwL3nrJCjb7pPLhT7eqppF1/MoSgZRPN0uZhhNut1TBIGHLKfPSpyv5CNwPsOR82239XFdL1w2V7IECa4kXLar+UL8ghNcnbiYFPNQ2XuubeGVCXf0NX3f3/T4sI7c7a6gaTl838Gyetj2AMNosX377ShKBsNoU6nsQVWzCAJoWolsdgbPMygUJtjYOIrj9KhWr6NYnGN6+m2srDyFLKeZnLyOSmUfy8tPIcs6rmsgyylOnLgfQZCQZZVWaxHH6TMYNMnlZqJe41AgVi7vxjTbVCr70fUCi4uP4Xk2QRAgyxkymSrV6v44Db28HKaqh6lkUZTpdlc2OYgN+5JTqTEqlT2b0tnDlqzhMYIAHGdAo3GcVKq4KUIfWovWaoficxjifCnn0wuCcMFxrkj4fNtd7GjJBAnebLhkQh724Q4GA1Kp1CWfUIK3Hi4mxex5No4zQFFSCIJ0XmK+kNfs93tAeJ0OHxv2+a6sPI3n2XQ6CzQaR7HtPqXSDsrlfThOD9NsI0ka1ep1KEoa2+5G1prPUCxuw7ZtPM9kdfU5BEHEdR1kWSGTmUSWdXQ9H7UfFVhbexHbtrDtJidOPEirdQLf96hW95PLTZFKleKpUPX6USRJJp2uYtt9BAF6vRUkScf3TTKZ6qbPLKxRv0ylshtJUllff4FyeTee5yHL6shiRyKTqcbp7NGoWddLGEYTTcshCAKdjouqphius0Oh2c2b9hkOaBiNeId+11uj2MGgThC4scf3+TzFR7cbxelRloVNrmQJErxVcMmELEkSxWKR9fV1ANLp9Ku6gSZ46+J0hAyC4J1nSw/bNvA8E9v2Ii9qAVnWLvqa8n2ffr/HxsYGxWIJQQhYWzuIYTQol3fHadhyeReSlCIIfLrdVSyrT7s9T7+/GvcBh/XceSyrTRCI0bEOI8sykiQjiiK23SeTmUDXi2Qy1ZGxjhJPPPFHmGaDdHqCbHaccnkPipIhlcpTqeyPU8qqmmYwaOG6JqnUVBS5FkilxmJVt2E0MIxmPKEom53g1CmDZvPliKynWFt7HssyCAKLtbUX4pR4NjsVT4wqFndE5BcOwhgqsXW9RBB42HaHsbF95HJTm6LQYVRerx+Nld9wevDE8LGtUayuF+h2V9D1HPDKnuJnS0ePpriH9fHXEonTWILXG5flKpucnASISTnB1YsgCAgCH0EQEQThjP9fyP6+7wACvu8himIUKUvnfZ1zoVAokM0K9HprGEYd0+wA4c09k6lEJhMrqGqWyclbURSNTGY8On64eMjlphAEiX5/nUJhDllWyWTGEUWVXG4aCBDFJrKcolq9Jnb0AlhY+C7r6wexrB7T01ksq81g0KZc3omuF3Ecg6WlJ6nXD5FKVZFllU7nVCQ066NpBYLAo9E4Qak0F2URLE6efDgWhu3Z80E0rUC5vJNebzV639O4rk0qFVpn2naXjY2XqdUO0usto6ofPcMiUxRlSqU56vWj8fvO52fiz3JIULbdY2PjEPn8tnggxqi/djpd3RTFhn3WRzGMOpbVRpb1c6a332hh1ygJh7Osj1Au7930OSRI8FrhshCyIAhMTU0xPj6O4ziX45AJ3qTo9zcwzUYUKVbO+P+FHqPVCn2gU6kxyuW5MyKU4XHDFKsU1zpHoSgK/f4q9fohisWdVCr7ozR2aJ/pOAayrFCrHcS222jaeFw3lqQmGxuHyOWmqVb3MzFxHbbdIZ0eJ50uIwgqExMHWFt7Ed83GAxqtFrzGEaNUmknAKbZwrYNKpUD5HJTiKJEvf4ynmegqnk0rYCqpqnXj9DrrSLLWdLpMr7vxen1kCAarK4+zerqM1x77Q/Qbofq6lrtUGTdCTt2vBvTbJNKjVEozCLLOoIg4LpGlEquMjc3ie/7TE7esMm3ekhAw/aqYc15uLAYunmdPPmdaDRll253MbIczZ7RsjTUAQAxGXueRSo1RiZT3TQ440rDKAmHSLJ9CV4/XNY8jCRJSJL0yhsmuKJwOVNzqjrJYKDEx5LlCq7bolCobBp+8ErHUJTwRnguq8bh6wxTpL6vkE5vvsGfHnG4hqJkmZq6mU5nidXVZ+j11lEUnUJhF+l0Fdc1saw6njdHsTiL51l0u2EN9uTJ72CaHSqV69C0HJ3OMpomUasdottdxHHsyC+6QSpVJpOp0ums4vsCltWOpjLdysrKc2SzE0xM3BAppk/R6SwxNrYHz7MolXYjCAIbGwfj4Rat1jzZ7CSiqOB5dqycVtVsZOV5CFGU6fdrUbuSS6GwI1oAyJvq965rkk6XcBwD1zVpNufRtBym2aLbXYlT7QCG0aTfX0cUJXzfZXn5SXq9dTzPYGzsGkQx/JyGvt/Z7MQ5BVhB4EW1+P0XdH298WrqzddeUqtO8HohKYwkOKOet7Vl5mKwNfIxzTaCQOwKNYqtC4HR/79SinD4OsOxiUMbyLDV6FDs49xqzUctTW0Gg9AQBMLe2yAA225RLM6Ry22j01lEEEQWFh5BljVcd8D6+hHW158mnR6nUtkXGYi0EEWR6el3EwQ+/X4D2+5gWeHjrdYpbLuDYbTpdE5FAxY28DwD0+xQKu3G82wWFh5CklR6PRnfdxgM1rDtHoNBk9XV5xkb20Wnc4picTvXXPNhXnzxHtbXX2Aw2CCbnUTTsgQBFItzADQaR/F9j3J59yYzj/X1FzDN0A4zNERpRqnnDtnsFN3uMrKcwrLacUTrOAaSpMYpbM8zSafHmJ6+FcvqIgiQTlfj73GrM9rZBFhna2E623c/vB673RUsqxWnjC9m4fhqF5mjJHylRvEJ3rpICDnBpptnr7d2RsvM5Tj22ZS1WxcCr6ZmNyT8ocFHt7vC6upTqGo+9p4uFufIZKr4vhuZYKxgmgamuRqT09TUzVQqe6jVDrGy8iyp1BjZbIV2+wSm2WVi4qbIeauDYbSQpAySpDE+fh2GsYFltZGkUBkeBA6DQY1sdgZB8LGsHqqawzAsZFnFNJtUKvvYvv0OXNekUtnL4uKjyHK4f6s1jyBI1GpHEUUN2x6wsvIc/f5q5J7lkclUcRyDTOY04eTz2+h0TgHQ661Sqx2iXN6JpuUZmp2YZpsg8CiV5rCsLt3uMoPBBoXCDsrlPfT7NTY2DtNuz7N9+3tptRaQJBnL6rNz5/vI52fi6U3p9FjUy+3FJDY6NGNIZum0vCni1fVCvN9w29FrYXjNhFmL0wYmFzMv/WJnq49G5QkSvFFICDkBcLr/UxCIJxiNje2Jn3s10ca5JvTAaeVtv19D1wtxbdf3vbPue65zGB7DdU06nVMUCrNMTt4a+TKDIMhxnbXXW41HLs7P34+m5SgUdiJJGs3mCQRBodk8Qqt1kmJxB4IQUChsj+vTJ08+gG0PMM0GjmOysfESmlZkff0Qup7FtiVUNUsQBGhaCVEUSKUq5HJTmGaL66//BEtLT6IoOr3eOplMGd/3se0exeIcQRCwsfEixeJcJEBr43kmGxtiNEGqgiynmJq6GU3LEQQenufGoi1Z1slkqmQyVZrNE7RaJ7CsDtu2vZ1MphqZlmh4nks2O4HjGICAJIV9xvn8TEyyoihg2z0kSaLdXiIIXE6efJiJiRuxrDaKkmFt7QXAJZudjiPbsHUr2BRddjpLrKw8RTY7heeZaFoRQYAgOB1db61BD+vWowKw0evllXCxgyGSHucEVwISQk4Q3UiPRJHXRNxSM/r8xUQb59pv601yNJ0NIAiQyUycETGd7f9DnI6QN2g0jpPPb2Nq6uY4dR0Seaj+bTRO0G4vsLb2Et3uKq5rUq3eAIjU6y/i+z5B4JNOj+P7AYKgkM1OMzl5E/3+Oq7roOtlKpUbGAzWaTYXGAyexPMc8vlZpqf3cfLkd0ilCgwGTQaDGpXKflQ1Q68Xnt9QMe04Bs3mUVQ1hyTJZDKTTEzcyJ49H6LbXSWXm2Rx8btIkkoqVSGbHafTWeLw4Xs4fPhuMplJJEkhmx1ndvZd9PsbTExcT7d7us/XdW0qlT3xaMhm8xiKkkGWNWq1Q0iSQi43xeTkjeh6gbW1g5RKc0xP30KzOU+hsI21tefjtqjx8VkgFNStrz+A77ukUiXS6fF4QIUkaXE2YpjGNowmptlEkjQ8zyKfn41r4KbZjAl467V1MeWPrbjYdPOF9DgnbVAJXmskV9VVjNE03VBVOhrVDP+/lUjPdmMafQzYlP7T9cKm4wHxGMKtxx1i1EVqawQ1itO+z8sEgRePUzTNNpbVxnUtggDa7WU8z6DbXaTbXcA0m2hank5nGd+3MM0OmpZDFBVEUURRUnieiarq1OvHkCQZTSswOXkD7fZJDKNMPj/D+vpRNjaeJ5Uqc+rUk3S7i2hajlSqimnWabUWyGYn6ffD6DwIXLZvfw/z8/fT6axSLEqRQG0dy2rR76fJZCroepGdO9/PqVOPIwgiudxU1B/co9k8SblsUSzuRhAUlpaewLI61OtHqVSuYWnpe9GiwolS34fodJaxrB7Z7BSGsRFHn5VKqBNYWzvI6upzHD/+LSqV/ShKClXNks9vY23tG6RSxWh/H1nOAGHLmapmabVOYJrtKNUuxu5kcLpvOTQwSdFqzWNZXYrFHfHzo9/p1lnR53MCu5wEeSE9zq92YZogwYUiIeSrGEMbyX6/FlsjDs0dhhGzYTSpVvefVUELmwl2WP8N09Or9Pu12ESi31+Le4kNo7mpfji8sQKbIqbhjN6zKV1HFxOhktdB04pxmh0CFhe/R6GwHctqYVkddL3Ejh3vxbL6uG4/UlIvYhh1er01gkBCEAJkWaVU2kmlci3Hjt1Hq3UCVc0xM3M7R49+A0nSyWbH0bQCYGOaLRqNw3S7awwGTXq9dbLZCVqtEyhKDtNsIggKoujQ7dZYXn4qOvcU+/Z9HF0vsrT0OIqSi0cmptNjLC4+ymCwwcbGYXQ9RzpdYfv2O1la+h6ZzBSW1cY0s2hagUbjGKqaY23tOSyrT7E4gySlEUUBx7GwrLD/ulTagablyGSquK4RR5tjY3tYWvoejjNgff0lrr32LnS9wPz8Q0DAYLCBphVYWHiESuUaJidvJp/fFkXADVQ1Qz6/DUEQ4pLHUGEtCFLc7mRZ3fjzzudnziC2YbZmOHt5tC1r+L0Pxz9urUO/GlwMqb+WC4IECSAh5Ksaw3GEw9YVIE7vlst7Nz13LjelzRDiKDf0Nncjj+YaQeBTLM5F/3aRJH1TND1qKrH1+KPKW9icwh62+/R66+Tz26jXj5LJVDl06GssLj7I6mqecnkPoqiyb9+7kCSNpaXHWVsD3zfo9Wqk0yU6nRX6/RUEQSabreL7Ht3uMplMhWaTqGb8Aq5rUy7vwHEsDKOBbVtks1OIYpogAEGQ6HQWCOcmh0K1Xm8VURRR1XzkSe2haVlmZt7Fzp13cujQ32JZbQTBRxBkCoVtLC4+iiSpgIBtt1lZeToaRrEE+LRax6L+63COc7t9klbrJI4zoNs9he9buG6fZvMIc3PvQ1XztNvHabVOUSptR5Z1VDUbf8ayrHP99f+Ugwf/AknSsawu7fYig8EG/f4audw2bHtAJjOOquZJp8fJZEIDkOPH/wFdL1Kt7seyuvH30++v0+vVsKwO6XSZHTveQyZT3STUOts1OczWbP3eIZx2ZVltisVdsUbgUtqStorJzkewW9PgScSc4HIjIeSrGMOhAaMRCGwW1mx97mwYkvBwzq5pNmO/5bDf9QSqmqbZnCcIPFKpMqlUaVOUOzzG6M1w9AY4tF4czgJW1Qy12ktMTd1MKlWiXN4T9c6u0WyeIJebpNfbADaw7T5jY7vp9dYpFGYJAtD1PJ3OApa1jG1XEEURTRtDFAVkOUWrdQpZ1tG0Inv3/hOWl5+h16sBHq67g9XVJ1hYMKJIei+6XqDVOoqqZvB9J1rINHGcHu32ApqWR9NyZLPTFIuzwE6KxWnW1g6ysfESnc4SmcwknmdTqx2m368hSQr5/BSO08P3wXUd0ukxbLtPsbibwWCNcnkX3e4qtt3DMDZQlFzUBhXgOCaSNCAIBCQJfN8jnS5uctIaYtiXfODAD9Jun4pFY8P2qkbjOLqeQ9OKbGwcilTjDTqdU0iSjuMMIt/x05oAx+nhOD0GgzVkWYm/X8NontPPWhTlWGE/OvhiuH0QgKJkSaVKseDrUqLT8y36LnTfYXdCEiknuFQkV89Vjq2r/q1RwrnG7G1NSQeBRzodOnHpeilOOdt2D03Lo6oZTLNBt7tKKlXGNMN+WM8zWVs7iK4XkKTTN+WtNzfTbGMYjag/uhmZYhym211l+/Z3ks1OEAQea2svIggCrdY8QeBg230qlX2USrvJZKrUai9HSvI8/b6Cbfeidqid6HqAbQ+w7Q6iqNDtLlEq7SQIJCYnb6JWewHfd2k2+ywvL5HPF9i37wZ27nwvi4uPUa1eRxD4BEHA8vLj1OuHkeUUsqxTLu9idvYOer1lQKHXO0Wvt0QuN0Wvt0ouN4MkKSwvP006XabVOoUgBHjeXkql3VF0vEIqNYcsp5HlAvX6yywuPkI6HaavPc9B10XGx29gMKhFftmlSEh2Csvq0GqtRp9nj0ymDITkU68fpVZ7kXr9Za655qORqYtOpbKPxcXHEEUVUZSwrE7kNx56b3ueharmmZm5DdNso6q52IM7n98eO4dVKvviBd4oaZ+PAIcE6XmhAj+cUT2GIMhnCA8vx/V/sQQ73Hdr90CCBK8WCSFfhThf7etCooRhqtvzLBYXH0VRdBzHRNeL2HYXXS/F1ov1+lFMMzTuEEWNXG6ScISfG9Utn6DROEYQBJRKc3ieiyQpsUJ31OJR0/LU60dYWzMIAuh2lzDNFisrGuXy3siCchHbNpmZeTuuayPLGqXSDtrtBRYWHqPVOk4QBFQq19FonAREQMR1w/OXJJt8fi++D5nMGOvrL0Sk7aMoOs88c5yvfvV/oGk98nmFU6fS/NIvfZAdO94NgG23WV9/GcfpR17UOdLpKkEg0OmcwvdNNK3Atm3voddbotk8Qa+3jOdZSJJMo3EM3/eiGcoNwENVdbrdGq5rYVltLKvL2tpzrKw8ia6XyOc7Ueq+CYSDLrLZGRQl7D9uNo/RbB5HVfMcOXIP6XSZbHaKYnFn7FKmaTlAxHEsjh37NqIoMja2B993yWQqMVl5no3rDlDVLKKoRc5jN8XZD89zotp5BtseRMr5SrS9vIn0Op0lut212Nhk9PoMrU37bGwcwfMs+v11qtXrLtjt69Xg1RLsxbZYJUhwLiSEfBXifKQ7FEmFrTpnRglDMh9GxpoG/X7o+hQOGqjGorB+fwPPswEpSlUXMYwWrdZJhqMAZ2dvx7YNarWD9PvrmGYzSqkWI0vM08ScSpWi1GwTQRCi2cAVDCP0dh4bC409PM+m1TqGrhfp95c5fvw4tt1FFCUcp8/4+M3Ydh/TbOH7FoKQwvNcDGODfH6GavUmHKdFs3kc1zVZWgqVzqI4zkMP/T3VKmQyKURxwAMP/Am33nqAW255f7QAOY7jhAMUisU9VCq7ADGa0tQgnS5RLM5RLu+g3Q7PUZZ1UqkKnmdSLu9hfHwfINBqLSFJCqurL9BuHycIBPL5bfi+jaIUyWanmZ5+O4JANBBCxPctBoMGltXFtnuoaiZy4PLxfZdicY58fpp+PzyfY8e+xeTkzSiKHtl7PkOzeZR6/TCTkzexe/cHEQSJSiUsR9TrR+O0dmiU0sd1zXjWMoQKfUnSkCSFavVaJEnDdU1c14xbigaDOmtrz0WGLhI7drwnvs4GgzobG6FBC3hkMjMoSgbTbGEYzWjClnxGNudy4WIJdmsmKRF7JXi1SK6WqxDnc88a9noOI55hWnr0Rjok82p1fzT4fgPDaNBszjM1dRPHj99PNltFltO4rkG3uxTNEvaoVPZEAjKBdnsRgGy2Sq9XjFqOZIIgVHenUqXIPrFNpbI/JuJK5Rpc18H3LRqNY3S7yywtPc74+A143oBa7QUGgyYbGwfpdlfRtCySpCNJcuTelaXfXyYIHHK5ycjBysD3HURRxXF6dLtLgBSJsHwkSaPfd8jlDHI5BdMMkCSZXs/i2LEHMc3nGBu7hmw2nBQ1OzsTGXFkaDZP0OksUa2qaNoubLvD8eP302yejDIDuyJRWtgPPDl5Cysrz6PrOTzPo15/GUXR8X2bTmeZTGYCTdOYmXkHudwMzebRKBIdQ1FSBIFHvT5Pt7tIpbKffH4Hptknk6mgafmoResxlpYajI3tjUxaSqyuHiSfn8Sy+uTzM2Qyk1hWh+PH/x7wGQwasQf3MFJV1SydzhLh9KxqfE01GsdIpcooSgbDqNNqzaOq4azlTGacsbE95POzyHIaTcttss0cjpzMZidxnAHbt78jVmeP1o5Hlf2jeofL2QL1apCIvRK8WiSEfJVgK/GOtiudzbzjtL1hmHYeuhdtjR6GCmpF0anVXuLYsb+n210mm50ml6tG9eI29frLCIIUtzVBQKNxnF5vmYmJm5ie/j4UJYVptuj3Q4UuEKVow5adTKZKqbQz6qUNI+1q9QC2bdDvr7G6+jSt1kk6nUWazRP4vovjWKhqFkHwcV0zmj3sxdFqOj0Rte6EtWXL6tDvr0V18EkMo4WiZJEkkWbTQNd9gsBE1zVM06FQEPH9VWxbZX39Ocrl/UiSHhHUGEtL34v8o+vIss7U1NuwbYNW6ySuO4i8pJeAIDrvebrdFSRJjdLxofGIJCmoahrXdXHdAaXSLnK5WUyzRat1AllOUSjM0uutIwgC6fQYplmPvLHX8TyTRuMoul5lbe1Fut0lPM9jMKixvPwsptlAlnW63WXS6SqSpCHLGidPfofl5WdoNOapVK5BECSKxR34vku1uj+2wtS0QpzNkGUd2+4jSVqUSSG2KB0M1uPrsdNZYGLipljtPdQmdLsrpFIldux49ybP8qWlFun0GKqaHbmywwvzSiDBrSLFs3l8J0hwPiRXylWC8w2Ed10zGh5fQJb1+PmhAltVMzSb81EdeDOZhxOGDARBY2PjpUgFm0KWFVqtkxhGaNRRKl2DKApUKvuw7Q6m2UNRdAaDBhDO3t3YOBTVQluRuUaZUmkng0ED3w/tHqembqVWe4HV1ecJAhfLapPLTdJsHqPTOYnvB0CArhexrC6iaNDrrZBOVxAEkX5/lZWVJ8hkKshyBtvuYttd8vlZgsBH0woUi9uZmrqFlZVnEITw3MBH11127drLiRPHGAxsVFXimmsqCEKPej0c1XjixD+QyZS58cZ/geeZiKKC69p4Xjh5amnpcYrF3biuiarmaLcXo4jyZSRJxnFMxscPUCrtx3F66HoeyzIYHz9AqzWP71uIohB9ThvoehnHMREEEUnS6XQW6HSWYmtKVc0hyylyuamovesknmchijq6niKTmcQ0w1nOipLGtnuYZhdVVXBdk7Gx3aytPYuuFzCMBrncLMvLjzMz832xqnrofd7vr2NZXTQtFy0gMtTrR0mlSszMfB/9fo3BoEwQBPT763FqvVzeDYSLwFrtJTzPxjDqZDITcSTebM5jmk2azfnYX/1s05guVx331aSdt/biD3vokyg5wYUiIeSrBOeqi4mijGV1abVOIIrypmESoyKX0QEOo0MChu1GhcK2KPW4hmn28X2LdnseUdRQFJ1icTvbt99ONjvB8vKTLCw8gmGoAFhWl3x+JrJ1HJDLqVjWAMOoR+fXptNZYGYmTF02GvN0u8uIokgqVcF1LQQhwLZNggBEUUPXy1H92sN1bXq9VTKZCYJAwHVtQKVc3sHCwv3YtkE6XSaXm0KSVHK5sMYaRmvLWFaHYnE3mlbghhveycTEDEFQQdNsJMnE9y00rUAQhP7Z7fYSS0vfQ9eLOI5BEIRDLRQlg+979HorBIGPZZnUai/h+x6iCLKcRVHCP47TjtTKkxQKOp5nIwgBudwE6fQUGxsv4vs2qhoKtzStgCxnEASZwaCJbXcIAuj3V8jnZ5ib+wD5/DQwz8LCQYrFHUxO3sjc3HsjFzUJ37c5evQbgEi/7xEEIqXSTubm7kTXixQK25iff4hUqowoqnEpIxS9eQRBQBCEDmB79nyQbneFjY3DiKLE7Ow7mZq6OepLX8P3BYrFneh6nkbjWDyFK2y3CiIfbyvugR8b2xPXoYeZjq1kdzmJ79VH3GHEngi9ErwaJIR8FeCVVvtDd6vTLlebMawLhsb7At3uSlTPC4VWYZRsIYpg2yahccUi6fQkuVw4yzdUDTfJ52dwnFAE5DgGudw0hUJo6BEOLdDwPAnLWgEEKpX9m86lVJpjfv5BwEdVi+h6EVGUMIxmFHVmEcUUltWk3T6FIMg4jo0khfXxcjk0lLDtNrqeIwgcZFkmnS6jqjk8z8LzXATBjf5tsLERti/NzNyK51lkMhNYVpPBYIPBoM/ExC0IgkA2O8XS0vfodJZYXn6CbdveSSYzFn1eLXS9yPLy40hSmDbftu0dFIuzUV91aFNpGA0Ggzqm2YlbmUqlnYyNXUOxOEevt86xY9+l262RzVaoVErR/ml830KStGiWskins4hhNHAcB9832LXrTh566HcBD9NsMBg0qdWOIAggiiKZzDjF4i4giNLmOrpepFSawzCarKw8g+c55HJTcTp5OHPaNFtMTNyALOt0OqcicvaiNicx7jNPpUooSgrL6pJKlWg0jrK29jye56IoaTKZcSYnb4hEcC0qlX2xuFCWdRqNI4iiHEX8Z7duvZiZy+fa/tUQajK6McGlIiHkqwCvtNqXZf2sYxa33rSCwMU0exQKszQaRzGMBvn8LM3mcXq9OoPBKiBSKu0ml6vSbp9CFLdhmnXqdRPfd8hkqkxN3cTq6jMIQpjyXFs7GKWvm0xO3kCzeSzyO57bdL6qmuHkyQdptebp9eq4roNptpDlFJ4XCrJKpZ1Ikozv+7TbK0CAqmbwPBPb7rC8/BSalqNc3km5fB253Ayua1AqXYNp1mm3F3GcPsXijiiCKzIYNMlmJ+l01hDFcPJSNjtBo3GETGaSXm+ZfH4btm1EkW+bVuskvu9h210cZ4BtB3Q630WWNRxnA89zkOUU27e/C8cx8Lw+tt2j3V6i2TxGsTjLYNCK+nxTbNv2ffT7DR599DvMzz+M60K3m+KWW3YyMZHBNJuYZgdB8Bkbu4ZCYTtLS9+j3w/NTAaDJt/97u9jml2KxV1s2/ZuwMX3bfr9GtnsZJRCbhEEAoqiYJoNNjaO4LoGi4uPABKqmmbfvo8iy3qUoj1KvX4Ey+rQbp9CVTMcOvTX0XcrI0k6mUxIasOUbpgB6JNKlUilxhgb20+/v06jEWoW5udbaFqeTCa0xzSMOppWQNfzqGo+ysRsvp4vNqJ9LWrOCQknuFQkhHwV4NWs9ofjGIPAHbHDJJ59G6aq65ESu4FpNkilxshkxpmbu4MTJx6KbuyheUS5vAdVzUQEAcXiDlQ1RzY7Qak0x9Gjf89gUGN19blY6SxJCseO/QOt1gl0vUS9fpTV1aep1Q4iihqW5bG4+CK6XoqmNxnYdpdstoJhtLGsBpnMDJpmA0Ucp4FtD6Iap0a5PM3a2lOsrDyDJOkIghSPHBwMmmQyFXbseA+t1gmazZPMz/89vu/geSYgkslM0e+Hi5B+fwNJUtjYOI4k6QSBQLN5DN8PhzA4TpsgEKIIeyrql26jKCkARFGi368hyzKiqBAEAtnsWNS6VKDdXmF19SSHDz9BKiWhKBqSFPDSS0fR9UlUtYamNRgfP0C5vIdG42VarbC/O5zGFJYQTLPHNdf8ALt23UGns8zS0pM4jhGZkjzO0tLTkbmJiySpZLPjsThOklTy+Zk4G+H7buxn3WqdQtOyGEaLVGocz3MRRQFBEND1YqyaH6Z0hyMaJyauJ5Opsrz8JOBj2wNSqUqstFaUFCsrC1Hr1ABVzaHrhThCfrXX+CttfzGEnbQ5JbhcSK6eqwAXsnIfVYiaZjsSei0TBEFs1iGKMqIoxZab4RShRbrdZRxnQKVyLRMTBzDNDpKkYdtdPC+0axQEGdPsoOsFstlJKpX9jI3tiSMtXc/TbJ7A8yxMs4fjDDh06B5CC8gespxnYuJA5Hq1F9PsRArmTpTe7eG6XZ566nYWFj7A3NyDXHPNy3jeKcAnlQonOEmSgOtarK8fot3+Iq5rMhjUWV8/RC5Xid63ga4XqdVqdLsriKKKadbJ53dimg0sq0E6PUG/v4Jp9iMSV2i3F/E8F01Lo2kZXDc0QJmYuCFSQ59C0/Ioik4mM4miZGk2j0eEKNJuL6EoOqqaQlXT0dzgViQOk2m12qyv+4yPp0mlPCRJp93uI4pj6LpAobCNsbHrcBwDxzHIZCYwjHXS6TKynI4WCA5BYLK8/DQrK0/R6SwSBAGKkqPbXcP3+4CComiIosbMzLvIZsfY2DiIbXdpNI4hSTr9/iqdzgoTE9fR662TTpdQlAzj49eRz8/EZYihylgQwmERlcr+TRqEoYf6cDbzUOlfLu+k212JSX8waKCqaWy7g2E0NokPL/Qav5jfxMUQ/JWg8E7w1kBCyFcRto62A+KV/TD9qCgZHKcXpRV7OI5Jp7PI+Pj1pFKlmLSHw+i73XUUJYPnhcMMFhcfY339eVKpobGHgCC4pFJjOE6PTkdkcvIm8vmZSMEd1iBLpTkGg2ZkFrEWiYSIotUG+XyG5eXvIQg6QeCwvPwkvV4Nz7MjJbPBoUMf48tf/isEweWRR/4VP/qjn2D//nui9wmVyk5kOUOns0CrdQpFUdD1IpqWRVUzBMEwQiviuh6eZ1GrvYhh1JGkFKJ4jFxuMl6A9PsbdDoLBIFAEHgxqaRSVcrlXXQ6a9h2m1brOLpeIZ0u4XkO/f4arutGrUANTLNOobADWVawbQNZTpFKVSKHqzy93ikMo4aq2kxMBCiKEfVsD8jlBFIpnSCwsG2TbvcUS0sPIwgq6XSZVGoCy2pTKu1BEISIxOcjkpQQBJWxsZ3k8+OsrpooSo58fgZBCBdfnmdGdqMKjtPC921arePMz59EFOW4danX24jHaWYyVVQ1Gyvnw3RzEWATCfd6a7Ra8xQKs5TLuwmCANvu4Lp9TLODYdTJ57dFfcfleJhGaLlqUasdYmxsT3y8sNXr9CzjS4laL4bgEwFXgsuFhJCvEgxT0KdVw3Nx5HIaQfS3QCZTJZebYnn5CVZWniSdrrKxESqCs9mJaDiEFxt1DD2rl5aeotWax/NmKRR24LoD8vlZJEmj01miXN7N2trBSOwj4Hkua2vPEQRQLs/huhaG0YoI2YvSpz6e5+K6DoPBMobRxjDauO4ATSsB4LoD5uffjyC4BIGMILicOvWP2b//m4CHLKsEgYCmFZHlGqoaDo4olebo9zdotU7GftqiqGDbLVzXiWw8vSjl7NLpnESSMlELkgAIKEoOx+kiCBK6XkBVNfr9OrncFI1GDwjwfZt8foa1tefodtcIa9tpBEFClnXy+ZlonCOYZgPDaEe90GMRQbXQdbjmmilOnVpgMHBxHI0bb5xDFAc4jkkQFLCsBqY5IJNREUUFwwjr6OvrBzHNDq5rsrLSxbJCJXwQ+Pg+1OvHCa0z+ziOSTpdodU6FZULKtE86AyCoES18iDqs/VpNE7gugP6/ZUoMq/g+y6t1jwnTz7E5OQtmGY7+j7D4SMAul5EEAQajRNoWi5a2NmkUqGIUFGyWFY3br8bFYaFIzzduMYMQfxYv19D03K0Wicol/fGwyou529plOyT2nGCy4WEkK8C+L7L2lpoTRmORYRW60TUqhPgeQ7V6n4qlWvjdOLwZrO2dhBBCFuPZDmNrp+eOTwcJhGSp4uul9m5871ksxNIkoZltdH1Is3mcWy7j6JkWVl5Nho00QQkJEmJVLaho1eYAl+KojcZWdai2uUsjcZher31qLVGjsb/FclmJ1hdPcjevY/y6KOfikn5mmueQdP0qHYpoygapdIuXLeNbVsoihxFbDVkWSKdLiLLKq5rsbT0IqlUiVxuBlXNMDl5M6urz9Dvt7HtLoaxQUiqpShFHbpHZbNTeJ7BYLCO45hMTNxCrfYC6XSZXm+dbrcDhG1XnueSyxVRFDUy8ehg2wNkWaHTWabfX2P37o+Qy02zsPAIkqQyNTWFrssEgUw+P46iBAwGdYIgwHUter1VbLtFKlWg2ZwHAoIgoNE4gm33UJQihcIsmlai2TxCr7eGbZtkMmP0ehsEgUertUCzeYx+fx1BkJmczDE7+25areMoSoaxsb10OguMje1nZeVJCoXtgEcqNcbU1M2026fwPIuTJx+i0TiGro+RTlfodE4hyylct4+uF1GUDIPBOuXyLlZXn6XVOonnmXieTbm8iyCARuNoPF95cfFROp0lJiauZ3z8OoAoM2OSyVTjIRlDp7fT9erLi3OlqJNacoJLRXLVXAUYDOoYRh3H6TE19ba4XcUwmjQaR+n1ljYprbNZHQhvMGNje6IIIBTeFArXU6sdwvddUqli1BJls7EBtt2jXN5JobCdTmeVTmcRSUpRq4WCJ9c1ohpqGk0rYBhNut3lSMns4zgDXNcgm60iihlkWY4UzhU6nfloXGILSSqSz8+gqml0fSxSOU9xxx0nyOV+hWef3cW+fU9z440PAuVIiBbQ72/QbB5GUfL4votp2rRaJ3BdC0UpRErjGp7nEAQCltWJBmFYrK29iOt6iKKHouSi50CSNBwnbLcqFsuIYgbXlWi3lwgCqNdfjBTIocALBkA4x9f3Q/VzOp2P5iuHwyEURSUIXFzX4Pjxv6VQmEXXsziOhe8LyLKDbbfpdBqRgEzE9w3AJVx4pDGMJr7vRGlqNWp/slAUD9+3abfn2dg4gm23GQzaZDJlisVtdDp1JEnCtgeAGE182oumZdC0DIPBBrJ8IxMTN9JohEMkhqrzsbE92HY/GjryQvR6GQqFKQaDFpqWRRBE0ulZdL2EaW7Q7YYLAk0Le7RVNbw+1tcPRS1jSxQKYYbFNJsEgYcgSLFVZqNxFAiQ5VlEUY4WX2FqvNmcv+xp5K0jIbf+zpJacoJLQULIVwGGitVyec+msXX5/Eyc/htGvaOr/LAftkU4dq+LabZYXQ2jWVHUURSNXbv+URSJQb+/wWDQRNfT9HrrZDJVTLNLoTCD4zjoegZBgPHxA1Sr+1lefhLb7lEszrKy8kTkrCWQz+/CNDdot5fJZMZwHItOZ5mNjaNYVgdBqFOvW6hqmnS6FHk7F0inK9xwwz+wc+f/IJWqUq1eT7O5MKLw9VlbeylqizIAmSAIyTEIPJaXQ4WxLCtRf7OHqpaQJIVeb4XBYAMQEEUV3/eRZRXPMxkMBth2C1nWSKdVDKOJrhfxvEGU7u7j+yqe1yMkTQ1NKyKKAfn8ZJQCD7MIvu8iyxMoSo7BoIVlLUb927NRa1gNx7HxvLDGLQg2ogiiqNLp1EilioBPLjdOvz8AhEgdL8Q+14bRjny75chgwyedLkV93V0mJr4Px+kwNrafVCqH44QTnhqNUIAWprpler0l+v0Wudw09foRBoMNZmdvxzBatNvzuK4RlUY0CoVpfB90PUu7vRLZlA6wrBa6XsB1TVKpHLZtUasdZGPjCKqao1DYFrWI6UxOhkNBZmffEff7Dmdwn75em+h6iWZzHs+zqNePXtYJUcPXSKer8cJ2+HtJaskJLhUJIb8FcbaBEZI0vPme/spFUY76bXfEgq8wcgxrfOn0GLXaSwwGG6hqnmJxjkplH53OCq5r4bpG1DKkUK8fjm/y/b4Q9eOGblGyrDA9/XbARxDkWF0tCBKO041q0RpB0Mf3wTBqtFqn4mg1lcqzvn6EIPAACcdpAx62baPrFWQ5zeTkLbTbx8jltiMIAr4v0Ggcx7IMBoMNNK0IhIsGQVDQtBSqmiOVKtLtrka9uFPoeh7f97CsDobRQhQ1HEdAFHV8n7gfWxAkXNdGFN0o8hUiG852FJ36qKoeLTJEFEXBdQXAA2xkWUFVNTzPp98/gWn28TwTQdBIp4t0u+t4Xh9RVHAcCVlWsW0zUi0LiKKGKEpRCtjB9wcIghilg0vR4mgdx7HRtHT8eWtagVxuPBatKcoU3e46mpbFNDcYDDao1Z6NFm/TlMtzrKw8g2H06HbX6XbnOXFigvHxG1hZeRrPs6MFmkSxuJNG4zilUphuzman8H0b02xFLWVdOp2wxSuTqbB37z9hMGjEi8LFxUfpdo+SSo0jSSqyrMSqfkGQyOWmos+4H49zzOdnNnUIDK//0Fa1SyolxW5fl+N3NYyOhzOTR38v2exEEhknuCQkhPwWRK+3xsbGYVKpMhMT17/iyt11TQ4f/jtWV5/iuut+CF0v0u2uoKoZSqWdcd14GMHlcj6qmqPfr2HbPY4du492e4Hx8ZvYtu02TLNJp7NMOj2GYTSjEYv9iCDbQMDY2B5OnXqahYVHUJQckiQgSWkcx4gIM4tlhS1Fq6vPAgagcOjQ9zM//x7m5r7NgQP3oygajtNneflR2u2lyNZRpt9fQxBcfF8Cgijd6QKhq1VoVSkDAobRwrb7WFaHQmGGdnuBwSBMjzab82haHlEUUBQtin5LkYq8F0XaIAginmfgOC6uayNJqSjiLNBuL+K6Br5vR594ODmp1+sDMrKsRuMKM8hyCscJo+qwtptF03IYRivynNZIpSbodhv4fg9FkSPi1pAkkVRqClEU0bQszeYpVDVFLrcNUQz7eB2nj2GEoxktq0e/30AURQyjRTY7gyiuoWller0VGo1j1OtHsO0OsqwRBDaiKNNovMT6+jM4jkMQWMiySrm8l1brGJ3OKZaWvsvu3f8ETRvDslpYVhfL6uI4fbZtezv5/Daq1f3Isk6ptCvKCujR3OoTCEJAtXoAQZCYnf2+aEGpADmCgJh4YbRf3otbrIYL0Upl/ybV9eg+o90Gr8ar2jTbDAa1KHVdTaLiBJcFCSG/RWGaIfH1emubDPg7naX4xjW8GdXrRzl+/Ju0WsdQ1RzT07dGzk8tMpkKudxU3C9crx+NRufNYFldTp58kHr9ZXzfolDYRre7iizrTE+/jeEoxWFtLRxDuEC/v8Ha2jMsLj5Ct7tKOj2cZhT6TrfbL0ZtSA7d7jLDuuuhQ/9L3Nb06KO/yL/4Fz/N7bcfxLY7qGo+UiMHaFoeTUtH9o0BguBHqVYbUVSRpDSeZ2Ka4eCLkCwHdLttbPtZgsDE973oORtJGqDrE9j2IkEQ2mnmcrMEgR0Nz3DxvCyGYeB5ZtRHHEba7fZJPG/YEmXG34/vt6J/OQSBEp2XQCpVQhAcXDcgnN/sYJpdbNvEsloIghLV7Q0cxwEgCBRkWUXX83hen8GgS78vIIouw8WIouTo9U5h2ya93gKl0t5oipSM6/aj0YmVqNe3x2DQ4ujRr5NKjcWReDY7Rbm8m2Zznnr9WPR5ith2H1nOsHPnnfT769EEqzXy+e0oioqq5jCMOpbVJZOpksmEM7NXVp6JBVum2YzGMl7L2Nhu6vVjqKpOq3USWQ4zDUEQIElK3OYUfo4u7fYiptmhVNoRjal0z6t+DmvPRwjLDxerkD7tVT1UfScirgSXC8lV9BZENjvBtm1vj/8/FJoANBpHIiFRKb4ZjY3t4cCBH2J+/gHy+RkajaMUCrPkclPxHNr5+Yfo92uY5kZce5RlFU0rMza2C0UJo6GlpScpFndQKIRRUL1+FFm28DyfXG6Sdvsk3e5K1PNrRn3PIRmKooLn2XS7dWApOmMBEAGB+fn3bmprOnr07bztbY+SyZTxfVDVNPn8DlQ1Q6+3gqJk2Ng4iuP0cd0BICNJIr5vYVktQMQwOgRBm34fbLuO78PYGICOJOUQBAvHCbCsYwSBgCimyeWm0bQMjpPFMBqElpI6vm8iigGeZ2OatSjF7KCqaVRVxzR1QlL24+9DUaoIQpjeF0UR3w8ixXABw+hg2y1suxUtUAJkGTqdU5FnuIXrhj7Uw75hy7KxrBaynCaVGiOfn0QQBEyzgSRlEUUbkDDNLpKkYFl9FCWD6w7YseNdkV+1HX0XofCvWr0WxwnVzOFEMI1sdpxicY5u9xSOY+I4A44f/xaKkqfdXkQUw8lVc3Pvwfcdnnzyj6lWr4tMZww8z2N9/Xmy2SkqlX2kUiUcxySXm6BWO0wmU8EwmhSLc6ytPUs2Ox5Nm5rG912Wl59C1/NoWoF6/RCe5yFJUux9fj5xVVh73hv/exRbyz2j6XDXNXGccLgFhOWLZKJTgsuJhJDfghjW1oBNaTyAcnkvxWK4snddk05nKWrXmWDfvu9nYeER1tdfiG74At3uEu32Er7vkM1OMTn5NjQty8bGIUyzg+9bOI5FNqvjujaaliGbnYnnGVer+1lcfJQg8Gi3TxEEHpqWo9dbjbytywSBj2m2MM0BrtsG2md9X3Nz/8Cjj34mJuUdO+7D88yoPioiCDNUKtfFLT5hJOUjy/lYDRwEwwEYIuBGbT6gqqAo4PuhiUg6bSLLeVR1IkrvDqLPExqNk/E4QnCAsJ/acayINF1cNxR9gYCqlnCcLqMR8hDDejh4eB4YRgvXtUiny6TT47Tb84CPKKooiorjGMhyGkka4HlSVGMVcF2DXq+L54X17NDJaiyqYcsYRgdBEAgCGc8bMBi0EMUAWc6iaTrV6g0sLz/O8vIzKIpGpbIfSZJoNI7geQ6ZzAS12vPU6y+jaXkmJ29m+/Y7EASRQ4fuod9folDYFl97rmtQKEyhqhm++c1fYWXlObrdFa677hPk87MMBhtks1NROj4cr2lZbdrtJer1wzQaLzMxcQuNxjFc16bVWiadnoiNQFQ1g+PYOM5KZLpSJJudolSawzTbqGoO1zVptU5uygZt/X1sRTiTeYV+vxb3Pw8GNfr9Go3GEVqtk5E/uRELIXW9EE3MurgUeIIEW5FcOW8hnK0PcnT1PpqqDu0iX8AwGuh6CU3L0mot0uut024vRK1JGSRJI5OpIAgy09M3IwgS9frLUb+sSrG4I1YVy3KGbdtuQ5Z1Xnrpb5iaupVUqhTbSrZax1ldfY5KZX80uGEM37eo1V5GlnN4XhvDOJO0hti//2v86I9+nIWFD7J9+0Ncf/19uG6aXq+GbfeRJJV+f510ushgkML3RTQtFbUM2ZhmnX4/JGmwoqMGKAqR2hokCbpdSKdlXFdGFI2YjIcIgi6GYXP65xNg2y1CcpYj8ZaA6zqoqkKvdzrtfiaGdWWB0JhFxHG6WFZYWx6mdycnb8J1jcjKU4qnI8lyinB0YhPbtggCE0ihaXkMox05XwU4Tpcg8BEECVFUyeUKkaFJB0lKsbj43ci8ZZFKZS+ZTJXBoMH6+ovIcoFt224hlRrDsnrIclhLP3XqO3ieS7N5GMPo4Lo2t9zyU5hmm3Z7ntXV56nVDkemLqFhiG136fdrdDqLlMu7yWSqUevdejSXegrTbBEEPq47QNfz2HYX13VotebpdvciSRqpVDnqC6+jKBrj49ciSQpLS0+QSpUIgoBm8wRB4JHJVC44ik2nx+j3a3GpZbiQ1fUCmpYjn5/F8yw2Ng6hqmkkSaNWOxSNCpXO+jrn609OepcTjCK5At5C2NoHufXHPrTHLJf3RG5bZQyjgefZtFqLGEboRjU19XZKpW1IUjgj13EG7Nv3v5BKjdFuL7K2dpCVlSeoVK6lUjmA5xmsrj4DQKEwRypVodtdRlWLiKLC0tLjbGwcoterEY5xXCOfn8K2OzQaR6K6c4rjx3+QZ57Zxfbt32D//rvP+h737/8G11//UHzzU5QMltWh01mNUowWk5M3U6lcQ7t9ilSqgm236ffX6PfbhKQZ1laHEMUw8oWQlHUdajUXXV9GUcL/h4SpcprI7ZF/w+no1+M0uYJtcx6InE5fZ1CU0JQkCCxMs44gqCiKBoisrx/CdcPZyo7jRbVsF0Vx8H0LRckSkr4AhHOZw4hYQtM0XLcfGaqEUbsgiEgSWJZPpxN6aIfOYOMoSpZ6/QWazUVMcwPPa6AoShQBh/OkG42nkaQUhcIMkpQlnVbQtDyua1IozGIY6wwGDTQthyxnmJ19NyASBCLz8w+hKCl0PRQdWlaXbnc5ypIITE3dFNlklslkqvT7NZaXn8Rx+jQaJ8jlQsJT1Vw0XnOoD5CjXmcJVQ1bvPL5bRQKs2cVXbmuGWsiZFmPH9e0ULA4HKARXiOnOxJWVp6JfL1PRL8RLxqscnZx19aoezQVvlWlneDqRkLIbxGczbBglKDT6XAub79fi20zJyZCf+r19Rdot5dYW3sOy2oyNnYNptnBtjv0+2tIUpoTJx5kbu4O+v3VyFIyHXkul2i15rGsDmtrz5BKHWR6+jZkOcVgsIZpTtFqncA0mxQK25iaupGJiVuQZYVm80SUWu5y8OA/4ktf+r0RH+qPs3//17a8SxlQUZQ0rhsKwMIpRBKKogBabNoxNrY/Tte6rocs6+h6CtMckpaAJOXxvDapVMBgAJYFcvSL0DTwvJCsTRN0PYxeQSEkWzc+q0OHPsb8/PuZm/s2+/f/LcN0+JkYEvDwb3/kOQPHCdu/wqhdw/NcPM+PWprcKFIfLiYEQMZxeoS9xl2CQCRccIiYZg9dz+D7Dr1emyAIXcVUVUeWNUyzEwnJVEDG920EQUAQVHq9NVQ1TbEYjpRUFAXHcaJI1QYENK1AobA9SufXkWU9Gh8ZDvMIfcgVGo0jBIGPqmaQJJmFhQcQRQVZ1tC0AktL38O2jWjcZCNydyuhqlkKhW2026eoVveTyVQjF7Ieq6svMDV1A7Van5WVBWS5hq4XGBvbzWBQJ5UqI8tq3CoVptDN2Pt6SL71+lEajSNR58BU3Mvcas1HRjp9DKMZOdxBtbqPfH4mJtVCYRvN5jypVGlTf/9WpNNjUYboKJqWo1jcEf82E5V2glEkhPwmw2jUC6cN9LcaFsBm0/vBoB6Zakib0tmiKNNszrO6+iThSDxwXRfbbtNsnkSWVUQx9C1+8cW/ikguIJutoqpjLC09TrN5BNPs0uvV6XRW8TyHmZnbkCSdlZWnMM0Og0EbQRApFmexrBbz86Hl4p49H0ZRdO6++x2bBFvz83eehZAVFCWDqmrIsoDnhSKtcITheFRHHEfTivR6q3Q6S5FXdJpKZR8bGy9jmi2GZBkqqVPAgHRaJZ0OaLVC5bIghDVlCIk5hMVmEiUaaHFPrPw++0Ii/va2/D0KD3BQ1QyKUo1U1I3oXB0sy0YQ8gSBRRgJy4TkG7ZcBYGIoghAGccZRIM9TEQxRRCErluimI1U1QMUJR3Zpg4IAgfbtrHtBYrFbdF1I0T93TfS768xGByj2Qz9rzUtTzY7xa5dH+X48XtxHDO+lur1FyPRXAfb7mMY6/T7DbLZSWRZQ1HyCIKFLOscP/5NFhdzgEuptJfZ2bdz6NAKi4svMD5eIJ9/gV5vidnZd0VRd5vjx78JCHzjGw/yJ3/ydRynx/S0yPd/v8+HPyyxsvIU2ewE1er1CMLpLMiQfIHYkW5YAx5qGvr9GmNjeyiX9+C627CsLqqaZn7+xUgj0I9/O5qWo9mcRxCI+/u3Tkwb/Y0C0aSqJsXijk2/zUtNVSdp77cOkm/vTYTRGcVDjEbAo3/D5vpx6NZVplzefUZqTBQlstkpQCSfn8RxBmxsHKbXWyIIAq699n+lXJ6j0QjTnaKo0O/XMIwVGo3jtNsnUZQMkiTgOAbN5nFkOUWlcm1kHGEjSTAYNFhefiYSyWxQKs2xd+//Qr+/we7d3+Ef/uGfxaQ8N3f/yBkWCVPCYS201xtQLu9FktQoijQjlbNPPj9LEAjR4qEDQD4/jW0PFyN5fL8LeFG91QGk6A+4roOuhyQcpn03fQNnfCdbB1qcfSFxPgzT2wqaVo4mPrWx7SZDwh0Mwho3NMlkYJgpgDAd7fsCokj0HYbmJ6a5jG1byHIm2t7ENBux81omo2DbdSyrjarmkSQfw2jR68m4ro2qpuh2l0mnxwnnU1soSgpFyaKqeUql7WSzZcrlPdh2h1SqQq9XAyQUJYOmFWMzmtALvYUkVRGEgEwmFKt1Oqci1bSN51l85Sv/jXvvvZfl5YBiUeauu/Zyyy23Uq3ux3H6tFonyGZn2dio81//61dwXZGpqUk6nSZf+tK9vP3td1KpXBtF9RpB4FGvHyWdDucqh+c9F3/yQ7vYoY3sYLAWR7u93lo0X3vA2Ng+TLPD+PiB6LoPPzdNK5DJTMSirn6/hiBAt7uCZbUol/fGSuxUqkSxuCteBFwszkW6W+8JSdr7zY2EkN9ECIcIeAiCvIl4hz/S8/0YR926XNdkaekJZmZuI5udYPfuD+B532AwWAdEtm9/F9PTb+Pkye/gOAPGx6+j19ugVnsGXS8hig6Fws7Y9tC2CxSLeyIl9QJB4JJOhx7SrmsiSSqiqKOqCpKkkskUo0g14PDhuwkClwMHvsFP/dTPcujQzWzf/g9bSG1Yqx2qkR02No5Eo/nEaPIQdDon6PfrUd9qOAEIxEgBqxISXFjjFcU0vh+KsMLjh4SfzYZk7LrEYi/PC4VeokhEiKcxN/dtHn30F8+xkLgQnI7ifB/6/RqjtWnDCBcFwzp3mD53GaasFaWAomgMBhu4roUo6pjmOv0+CIJHECxsOWcvmtjUj0xaXCDH+PgNrK0djDIgCqo6dPcK6PfXyGTGyOe3USyGs4n7/XWWlh5HEBQqlRsIsysyhtHEMGpMT78dy+qgKAVc12AwaEQ1UycaX2lgWR3S6QqiqLK4eIS//duvo6o+u3aVEMUGBw9+j9nZGd7xjt1RtJpDUbKcPNnB8wwmJycoFAak02m63Rbr6+tMT19Dp7NIv1/D8zy63UW63TUkKVSkhwrs7BkEF5ZeTuC6ZjSfuxD7mA8GdSqVPTiOEQ9omZi4KZ7J3OutsbT0GIqSJZebRtdz0Wd7eoHs+y6ZTAXTbGOa7Yi021Qq+y9oGtWo/mN0+633hCRafnMj+cbeRDhbmutCV8S6XqDfD2tti4uPxiKsnTvvRJZ1JEmi11vFsrpks+PRnOCQtDY2jpDNTqDrxRHTCyfyEQ7o9+u0WkdpNsOWkCAQ6ffrTE3dRru9QK+3jKqGrBAEDq7rUyrN4jhW1NdpI8saBw58k+3b/3+EpDkKI/pbQpJyeF6HIOjSbr8MKMhyGlFUo1T7ery/LJdw3T4hEducJj8xcs1SomOfrvnqekh6mjaMSsMINZslivIhnT59ZkPl9/z8nczN3b9lIaEwjHJfGQ6OE7pHGUZIvpuj863/D4AeQTDGYNDCtnv4vo/jWPR6LqJ4evvhOQuCjqqquK6N71vRMRU8z6HXW0IQZDzPo9+vo6ppgmBY5/ZR1TSFwnbGxvYhikdZWztIs3mUIICxsb2Uy3tpNI5F7mbHCQLw/QDLapPLTZBOT5BK5RkM1qJpUCa+b9Pvh+KvbndAKtVH1yukUh1EEXo9EMVdOI6Brof76nqFYlFjYkLEsjaw7Qz1+oB8XiOf9+IWvlSqRK+3GinAG/i+SS43E1mkTpwhgAxJuYxldXHd8HoTRTlq72uSTo+RSpVoNI5GdrB6bNvZ79dQlCyZzDjV6v54X+AM8xDfd2k0jtLvr2/a5lzR72h5anTxNnze913S6Ur8Hnq9tWTAxZsYCSG/iXCxBgSjP2jTbCMIYaQ8M3Mbvu9RKMyOiMGKbNv2Dmy7F7V1vEy7fQrDaESK2FCMYll9TLPJgQP/K77vk0qVWF19hoWFB4EAQZAwzTqKoiCKIq47IJUqR/7QXTqdJSyrg67nkSQ1EtUQ3XTTnJ/ApGigg0oYkan4vovr9lCUXDRa0iIkZJ1MpophBNi2wWlSD48TOlINzvp6+mnBLY1GSMaCQDSk4cyz2r//a+dIU18oGZ/GYBBGw6J4+rWOHPkYCwvvZ8eOb7N799eADENFdb8fzlYGG8cRAD9Ot5tmKFIbCtWCoI1lFZEkEcdxURQdSdKw7R6NxoBUqogkSYBHt7sKEJm3qPR667RaC7TbN6AoeSCg0zlFEARRO1MHw9ggnZ4mna5gWW3W11/AdW0Mo06lspdUqkI6XcWy+jQa82iaSjo9jutaaJqPLMu4bods1sW2XQwjTbVaJQhcGo0TeJ6PKIrs3Xszd931fu699z5WV5uoaoof+7FPceONd24SWGWzEwiCFI3sDM1XNjYOR8pvPRZAuq5Jv18jn98W18KH0eaQfAeDelxfDucvD7+vOoIAqVQZILYBDclxhXr9CIqSwjDapNNlxsb2oGmFKLujn3VxMHrsrYuG0cxY+PwGw5Gq2exEMuDiTY6EkN/kOF+KaqvKevj3UGE9GNTilJfj9CkUZllc/C6ynI5FOYKgIIoKpdJuWq2TNJsn8bxw8o8sp+h2V6jX5xHFAEXJI0kKtt0jlaqyvn6QbncZ2x6QTpdwHAPXNaNJRS7t9kpU5/UAH9OEMKq0Nr2PURXzddd9h9CSUySXG48GOYQGH0HQ53Sd18MwaqRSVVTVp9dbAXqAgqqWEASJkDANzoTOML2taSE5hp/1xXwzMoKgRrW98/Y+bcJoFCwI8PLLH+OrXw1FY08++Yv86I/+IPv3/x0hCQecjvA9oA9oSNLpvmrHCSP702jheTqSlMLzwPdNhpOvXDc0HQkCH0nKYNuNqHc9Gx1bwrJCm8ywDCBGKvQuGxsv0mrNk8ttI5OZpNkMp1SFQ0m2MzZ2LbbdI50uk8/PYpod8vlp5ubez/z8feRyAe9+9w4eeOARNjYcQOUDH/jn7N69P/LbDmdyp1JjpFIF/vf//Zd43/t+isXFw+RyNrt3X0+vtxZHnvn8DLKsR25zHYIgwLI61OuH0fUShcJ0LIBcWzvI6upT5PM7omi+CoRCsFSqSKvVxnVNms356HdT3/R7GtZxh+1Lw97xIAjFX63WSVqteQCazXl0PQ+E09ZGh2IMB1aMprmHi4azLcaHPdODwVqcIk/w5kZCyG9yDA3vi8WdyLK+iZi3kvCoQcjoj31lZZHBYIN6/TgQjFhthkPvZTkTD5fIZsfZ2HiRpaUn0PUsljVAEBQymRnq9Zd56KGdHD78QfbseYy3ve1+gsAlk6nSbLbxPDsi0ICDB/8RL754HXNzf8/+/d8grOG6bO7NPZuK+RPs3/91FCUbzfh1CII+kjRGeDmHbTngYNvh1CVBEACbQ4c+zsLCR9iz51Guueavo9c6G4YtTh6ZTBhpDsl4aw353PAjdfPFYUikw+h4YWGraOw97N//1S3nOuyRDt93Ngv9fkjEqnq2cw6FcOFnJcd/wp5pE03To/qzG5F1CUUJRXrhUJE1JEkDBLLZCfL5aURRptN5hCDwMYwNOp2FyAfcQRBkbLsTifu0aJKTSqGwA9PskMlUyeV2sX//FNdf/y6OH/97CoUyt9zyblqtBUyzgywr9PvreJ6LqqaYnb2d66+f5eab387hw3/LiRP3E2oAxqlU9p3+FnwX02wzNXUTkiRTrx8hn59EVXPxABXPsyJB4BS+78fE2O+vkUqNsWfPB6nXj6KqaXq9tfh3NEqeQeBFQ0dKsU/2cDSkrhfJ5aYxzbD9rNNZQhQl6vWjOM6ATucUe/Z8ENNsx/3KqVRpU9fE2XqmRVGmWt0fz4AG4vnQl9POMzE2ef2QfIJvAfh+qCbNZCqbrDLPZ64/+mPPZMK/ZTmsJ4bilw6ZzDiwTq32HEeOjFEqhbNts9lxer0mipLGNBsEgYRh1HjssRv4b//t/0IQXL7znX+F4/wzbr31MUBCFH06nSaOM+CFF/4Jf/7n/yUi2U/xYz/2E+ze/RXOZi15por5Xezffw+O0yOdrmDba4Rp2rAfd9SUY9gP67oWhw59iC9/+e6oz/nn+NEfbbB////k7HVej9E69mgK+yK+lVezE+l0uAAYRuV7936bJ598JdGYS/hTPq2+z2RGFzajn8nw3IzocQ3oU6tZOE6fVApKpTS6niMIRCzLwnUXYwIJRXljFAozDActmGaTpaUnoj7iFvn8HOXyHnzfQ9Py0VCSw6hqjmZzEd838TyHbvdU1Kcc4PseudwYuZzL1FQ1EnsJrK8fjNLAWSRJQ5YV2u0FVDVPoTCFIISRvWlu4Pt+9HqrpNNj1OtHse1elD0J6PVqCEIQGdT4rK4+Haecw9S1jSTJDAZ1ut0VDKNJubwHVc2SyVQ5dep76Ho+Jp7BoBYPt2g2TzA+fh1B4KEoWVKpEr7v0u2u0GqdpFjcQaWyl8GgQbm8E8cxKJXmOHr0mzSbJ1haeoIdO94TidEs+v3aJqORs/VMD9Proza5Q8X46ESsS8W5Uuqv9FyCi0dCyG9SjK5MM5mJaJZumJsc3ihGiflsg9RHU2RjY9dSqx1E01TW1p7FdS127Xo/6XSF+fkH2Ng4jGG0aDaPsrHxIqHFY5/BYC3qe+3w7LN3bCLPkyffz+23P0+ptJ1a7WVEUSSVynHixGaSPXLkFnbv/vJZ3+eZKuaHCcnFj3qbZYLAIZxXbAAqoqhFkbGILOv4fnDe9qRQkRy+XijYOtP0Y2bm2+zd+7Xoc7v83+coRo9/ftEYnCbbrUYkEuHPexhBj6bNh0QdknS77SGKkEqFyvJGY8DYWD4+pucF+L5Ft7uOoggIQjh+0/MMXNem211CFMNpU7KcQ9NCgVO/v47rmnS7a7huH9vuR4Smkc1OYFnhoso0W3Q6C2xslCJV9DKCILOy8iyDQY1ud4Vq9VoKhTk0rRD3Watqiqmpm7Ht6yMjmtDEY37+QRqN+cg/PIxQ6/VjKIpGtXods7PvYDCoo2nFaJEp0+ut4romqdQUvu/Sas3j+x79fi3+/YTRtBcP2ej3NxBFJSrNLOE4fTqdGWRZiT7XxUi0th7Ngi4iiiLF4i4kSca2++zZ88G440EUw1nhJ09+J7L8PO0pUCrNEc71zm0qQ22NTkOVe53BoH5B6u0Lwdb0/HB0pa4X6HZXSKVOmxEluDQkhPwmxejKdGiCr+uF6O8whTVqdlCvHyUIwqhv+MNaWzuIYTSi/twgmvurIUkKrdZx1tcPAjKiKNJuLyLLCt3uMobRRFFCb9/l5SewLAPXbbNjx0N897ufionvwIHnyeUm6XbXsKwWhtGkUJhi795HeOSRfzlCsvdxrjrraUL6R8zN3c+1195PEEgM25SCIIxuw95ikVCJLeL7HkFgY1km4J2zPck0QzJ23TNV1KPp8iD4RX7ohz7O3r1fwzBC8hpis1PXxfQgXxjOLRqDrcrb07hQQZmBKIaqct8/HZkHQZvTUXQaUPG8Hr6v4ft1YI1MpkoqFdptDgY1VDWN4wzwfRvLCkVMw1nQ4Mclkr17P85zz/0PPM+N1MrTbGwcjuw8s5HewMS2++TzO5DldDRbusT4+D48z0OWNTqdJU6e/C6KorFjx3vwfZfDh7/G2trzgMTExLVRm57MYLBOv19j5847o9GksG3b29H1AktLT0R9x4NoARfOtBYEKSqL9CiX95LLTdPtLrOy8hSqmse2O5E4cjuKkkXXCwRBgOsOopJQgUymimXNommj+orSpvLSzp13xt/GUHxp271N35Jt90mlivEIyyEZj0ang0E96pEO++8vVzp5qCRX1UwUqR9F0/KRst+NRnTKsXg0SV+/eiSf2psUo21Mw9R0r7cWp6LT6TEMo0kQuLH5fSoVRsfDvknXdXCcAbo+Rq32Ir7vIMsZXNfF9wNWV59BlrNAeAN0XS8yeQhtF9fWnmMwWI9qfBluv/0FdP2nePnl29i793EOHHgYwyjgOD0Ggwaua9FuL7Fz50l+9EfbLC5+kNnZb7J//9fP+1737/+7mJBCMh6S0JB0ZMKoL4zoHGcoCvNHjnFmpGmap5XTqhrtEe8i89RTnyRMew8j/jvZu/drm4RXF+fU9frBHMn+nz+id2JVt22Hf3wfZHkC398YqcGHvc9BYGPbNYaTsnK5STQth+sOWF9/CVFUMM161MtbjOqdItnsJNPTtzI19X1IEmiaRrfbwbbzZLOTZLOTQOhFncvdimE00bQMk5M3Mxg0EEWRVmueIPC56aZ/xtLSk3Q6p6J08jgAltXFcSx832E4+1oQiPqfIZ2eYGHhu9h2l2JxB/n8bCSK2kDXi2Sz+1CUFCdPPojrOqTTZXS9gCRpcTtVmBKuUyzOxWnnMPIvxKnusNVrClGU4xR0ELjk8ztHvpPCGWQZZhNWKBRmMc1CnIIekl3Yo+5tUoLD5gh2OH5yq3r7bNH0hWKYLg8V3eGiXhAk8vlpOp1lPM9hael7FIs7kaSLa8dMsBkJIb/JMFz1uq6JYWwwGJTifsgwrZaLex+HkbGmpbGs9qYUmKJkkeWAmZnbWF5+GsNYx3FMNK2AIECxuI1utx79AH2azWM4zoB2+ySCoGHbRjQdKQV0AJ+Jib28/e3Pcu2195FO57BtH9vuYZomQSAiilo0HnDA/v33cMst38FxXFw3TRgh+5zZgwybo70zn1fVErbdIVRnD/2mrTO2O1ekOapCHkaIhw59hJdfvit+PBz3eP+mKBJenVPXfff9NkeOfJS9e+/lH//j3zjvtq8Gw9apIfp9yGQ215EHkd4s9JwOzU9MM2zxyudBEAbk8+OYpoltt6PWmqFgDkJyFhgMGniehSD4iKJCPj/NYLCBbfdRFAdVzaLrJcbGriEIoNkMxzd6no+mZfD9cJBGpbIfTcvT6YRTu7LZcUyzSa+3hmHUaDSOY1ktHKfPoUP3YFmhGGzbtncgyzq93iorK8+QzU6Qy4W1ZUVJsbFxnLW1p6hWD2BZbfr9Bmtrz7J//13kclMoSoogCFPC5fJulpefjC1jdb2IIEgEgcvi4qPMzt4eq6yH9phbbWglSSaTmSCbnYiyUm48eGKUJIeOX6nUGBMT1xPajh6l1TqBLKfpdpfIZMZpNk8wO3s7sqzHmbAhAW/ViGwdK7nVOvdspawLwTBdHpYH+kC4oGg252PBm2HUo8lcg8tav77akBDyZcZrqToctckLVbinQ7WhUGuo0h0qMzc2DkUOS3MA8QSbcCKORrM5T6WyF8fp4vsejuPx0EO7eOyxEtde+wy33fYU3W6dfn+VZnOB0CQih+9bDAZtgsBEknQ0rYAo6hSL21GUDIIAlnUKz3NQFIl+38D3+4wSajhPeOuQhYtHSMajiumzp3HPllrear4xxCjRgs+ePfewe/fXEMXNEefFOnXdd99v89BDvw4ErK7eCvCakDKEJCtJwwXH6c9k6P41dCEbOpBlMjphKUCIJk8FqGol6uHtcvp7CgdsuO4GGxthK1kuV4l7zdPpaqzCtu0erjug1dKiASeLSJJOu30CwwjTs9nsNJ5nks9vxzCaWFYX33fQ9Uwk+HJxnAGKksG2DV5++euIosz27e9D14v4vsvKyjN0Osts3/4ORFHDMDbwPBtNS0WGNwOy2XHa7VNYVofl5aepVvfT7a5jWS3W1p7H8xw8z6LbXYpTstPTN9PprNBqnUDXi0xN3Rxno4bEGgRhSrdUmiMIQNdzcTuhJOmMje2J0+RDkgxnNR8HQrW2KMqUSnP4vkuns4LnuXF9tl4/GpP2MEofaj+2GokM67vDvuUhYY+2Ul2sCMu2+1GveT8Wqq2uPhs7nFWr+6nXjyIIUux1kM2+xkKLtygSQr7MuFTV4Sv1FQ9t8iqVPZsM7Id/q2om6nUsUKut0GyeoN1eYMeO96IoOv1+jXr9KJ5nR73GXVKpIkEA3e4SDz44xxe+8BMIgsu3vvXDfOYzn2fXrr+M6lIShcI0ul6k0TgZtbI4yLLG2NheZmZuZ3HxQcCn16vhOGZ0buVoAbE1uj3bRCQ4l8PVuWu1o9Gwz9nq0WdLLc/NfW1Tm9EoOW8l2ttu+2+bHLqGeGXR1WYcOfJRTgutAo4c+cg5CfnQoY9x9GhoCLJ379cuWEw2jI6Hkf9WM5NRFzBZHn3fp/Pcg8Ea4UQsPRILbl00CSP7mHS7LoqSQRTDMYyKkkIUQ4tOVQ2HN/R6K3ieg67nCQIfxxkgyyFxK0qOpaUno9a4euSZnSab3Y4kZUinx9C0Mp3Ocfr9ULCUz0/HqV9VzZFK5dH1cmTh2mf79j0cPPjVKLoPhVql0n5areOYZpOFhe9SKMxGArNBJFLsoCg5TLNDLjfF2tqLTE/fgm23N7UXDQ1Fut0VTLNNJlOh2ZyPovAaQRCQShVIpyuRJWmbcnlPXDsOvweXZnMe1zWx7S6CEHY8BEHY2lWt7mdh4REKhW2bPvnzGYk0GkdjpfVwKlV4TZwm860GI6+EYXnM912Wl59iff0gQeBRKOygUtkX61PC4yaTqy4FCSFfZlyqU875CP3MvuLTd+jhj2xt7WCsbk2lSuRy03Q6S3S7y5H4JIVltaKWlCyOM2Bs7BpsO5xJ+/DD6U0p2BdeOMDUVAfP62KaPqqq0eksRwsDEQh4+eWP853vfIJCQafd3svMzD3s2hXeCB2ng2WtsPVSO78Q6uxkfCm12nOlloe11iEpDUnvYoj2/KKrzdi7994oMg5JeefO/xmfwyjhjr7fJ544LSi7EFIe2n8O6+FnW0jYdlg3Dy0utz4bMBzjGLasSZEr2ujjW+HgOKHJS6hyN7DtPp7nk04X0fUskqQSBAK2PSCXm0SW07iugaZlaDZPRFG4i+ta+H444GJl5XGKxZ1ks1NkMhP0+8uRkGwqblECKJfnMM02g0EN1/Votxd58cV7MM06pdLuODpeXX0s/q7L5Z14nkuvt0GzeQTXHSBJErKskM/vQVHCEZSyrDMz847IA/57+L5PLjdFv1/j1KlHyWbDEY9jY3vo9XKcOvU4plmn05EQBClanMjUaoeQJJlKZT/Z7ATN5jyt1glUNYPrmmhaWG6SJJ3Z2eujqFOg3T6FrhfjT/pc95h0eoxyeU+0IPAYDOpnGSSz2Y/glbJ5vu/GqXdRlJmcvJEgEHDdDjMz74hMelwEQY6j8gSvHsmndwk42wV9qQ35W1sMRo9/vmMP09n9/jqdTpiWc5w+lcq+KBru0mgcRVHSkWo1jWl2yWZD8Um7vcRg0ODWWxf4+7+XY/LaseM+DGM9eo0+jz56C/Pz72Zu7gH27/8qhw7dxZe//N8Jo18pMpT4KD/2Yz0OHPgWp8l1cyvRl798D+Dz6KO/yIEDX+Gf/tMfPe/ncqlTlbZGvI3Gbg4d+tj/n70/D5L0PvP7wM9755t3VmXW2Ud1d3V34WiCAAkSIAkSJDQjznBAUh5Zg1nLWg8VCmtjZYft2diI1Q5D9i6lcDg2xruODcmxFidW9lrCSENpSMyQ4AwPkCCJgyCAxtEoVFV3V3fdVXkf733sH+/7ZmVlHV0NgBiZ6Ceio6uyMt983zfffJ/f8zzfY8825ucfj4Fc8MADX7+tRHvcSKrhxcXf4MyZ7/CZz+xWx5FxRPTz8PHevPlon3Z1nDgqcWcyu3PmCOx02DP12KijSfT5qeh6BUWJvK49b7gzIeK6bQxDILLsFAgCG89Lk89PUS7fzcbGq7Hoxg6ZzBil0hnCMIxv8gZhqCFJJoXC6b6vse/bFAon2dl5A9NsAgGO04oXCNBur3Lz5s8wjDrd7lqszb3ByMj5WJNdZ3T0AsvLz9LpbGLbTTStgOd5NJvXaDZXMYxNLKtLoTDN5OR9pNMTTE8/QKezSSpVoFZbYnX1Ber1RVQ1x8TEJfL5U+TzJ8jnT6DrpZjLn6JYPEm1Gkm4JrTESDhllWr1CsXizEC3S4pbv0UEQY4TXKQrkDhTDTtEHXYfSGbIyax6b5t6731qd/wVda0Ou68MduWSVn2k4Bbg++4eSc87yfjdx50z+C5iGCgx6IOacBcHZzrJa466eAe/bLcjFB99cTwymV2lomSfRFHGcbpsb18hCLaRJBXLatFoLJLJTKJpWdrtdWQ5xW/9VsiJEz/jL/6izfT0d5mZ+Ra2Hd14o0T6x3GV+p/HFeSnB2atIWEoIYpJwnyaXd1liaSVvLz8WZIbOIRcufI7fPe7i3zmM189NJEcJ6EeFUnF+/LLX2Fh4cssLn6BhYUv9Svt3UVCFIN/e6/jsce+ymOPfXUPEhoizeq1tahrMHy8p049857uw+FJOImopR6BeJLK2MWyhNgxbO9YQNdHcRwH33fj2bQUU9IiTm6xeIEgCOl0ksWd33eB0rQcqprFtrt4nkcqlSefn0TXCzF/PWqDj45eRBBUJEnC911qtauUy7NUq29TrS6QzU4DPkEQoChZLKtLs7nY15k+e/azAFSro7Tby6ys/CS2WOyRy01TKp1DklQEQSOTGaXT2UQQIpRxZEe6jSiqjI9HyThRzUr8lGu1RSYnP4zrmgiCQKezhSynOXv2XhLjhzAM+57IY2P37PmuJuCrpMXuOL2+d/PtxHDCPqjrltwvhp3jhmO4KxeJtGRIpYqMjs6+p4pgd+JOQn5HMWhEDhFAI+LmFfbA/pOZTiJlB+z5YgyvXId/P6w1ddDrPM8iDCNOciKtt8s1rqFpBdLpETzPQdeLsQxhiCDA1tabvPTSR3jttXN87GM7fO5zK1Qq/5b19ZcwjF35x4Oq1CRxJBUyBASBzKlT38d1W+zKOu5WU7uv2Z2lXrv2G3z601/dUyUOxq0S6nFibu6pQyvtvYsEgOAdeBu/81hcfJxvfGNvS/6JJ77I1auPcurUM7c1Q35vIgQMwjDR3YxMJ8KwS6dzk93PMx0raOXxvBYgxu5bPr4v4Hk+sqxiWVXa7XUsK/reyLKC63bxPDumVQWEYRAnUz3Wju7S7UZJUdNyFAqnSKdLbG29Sbt9ExC4fl3H8xxEMTIMCQKHTGYc2+7Q6dxkZ+cKIyN3MT4e8YszmTKRKcdGfzGg62UmJu4jnR7HtuuxHrbI2bOfZWvrDbLZMRyngyRFtpSKksW2W6ysvIAgCLhugXp9GceJRkFRtSuhafnYparWF/3wPKPPdkh8lw1jh3S6ElszNvp/f69msQfdR5IO3K3iICR3LjfOyMj5/n3mTrx3cSchD8StZirJ3yN93EhIPpsdj4X2wz2Ef9id6SQ/J5EoZA1v5yB3l8OkLwef1+1usbHxMpqWjyt0uU+NihYEUCzOEIY+9fpyrDfcimUEt/nRj07w3/63X0QUff7lv7yH3//9/47JyRfp9aqE4f5EOowovnDhm3S746yvP9R/ru977LapoxtuEnNzT3H33X/MlSu/Q5KUz579zj5+7/CM+aiEetw47Bh2FwlJiO/A2/jwfT8oklkvwI0b+4/r85///X71/swzf/hLEx45OkwkKRNrXyexixKTJA1Ny+E4LSAklSqQSuWQZYWdnUUEQcS2W2xtvYlh1PD9AFVNIYopXNfEcbbx/TS9noEoZkmlfFQ1i+e5MXo+0lM3zS5hGLC09Bd4no3vO3ieia6X0LQcnc4ajcZiTLspYZo1fN+LaVAjdDorVKtvoWnZWCLWxrZ7cUs7S72+RLN5g2x2EvDQtAzLyz8mDAMcx8D3XXS9hKJkyecnWF19EcfpxYIZWbLZCVzXoFA4ge+7lMuzhGHYXzBbVoNUqsTJk5/YlxgH/09+fi/bvwfdR5IRWCIelIiNWFZrX6dvMA5ynboT7118IBPyYYn3Vgjp5O+pVAlZ1tnaegNZ1ggCD00r9i/WwW0nHOHB1rVh1Gi3V+n1qqTTo/1K+7iAsIOep2n5vvCHYdTiL1oVVc0iiko8w1rHMKpUq2/F9IQauj7B669fQBQ9gkBGFD1effUEo6M9BEGIhTiiOfAw0AkYULKS2Z0jeywvf5K5uT+J924/6vlv/a0n+P73F1lYiGapn/70V/s0naMAXIMVeRjKKMrtGTjMzT3FI498jddff4J0urbn8See+CKvvPIVwhAeeOCP+slwMLneKtm+U/DZ6dM/5KWX9i8Uhrf3yCNfw3Uz72NyDvD93tBjGoqSJwhCRBEMo4ogiIiigiyr6HqZbneDIPABF03LEgQB6fQotl3HMNoIQium0HS5du0qQeCiqnDq1AjF4mki4REYGTmLqo7gOHWuXfsu29uvk0qVUNUMrmuwuvpzRFHCthv0elVyuQmCwKHZvI4oKmQyHyKfn6HZvEkqNYooSpRKM6TTo8iyRi43BQg0m9fIZEZQ1RTF4kWazTUEIYhHOhmWl6/2k1UqlcEwIonKiLoHsqyTz0/huiaVyhyW1YqpTddRFJ1Waw3b7u5zixq+Dw0KeBz091t+WrdBuxx2izLNBoIAvd5Of3F8FCjsTrz38YFMyIcp2AwnuuGLO4H/p9OjrKw8z/b267FE4CgQ9rmGB81rBukIo6OzbG29wdbWG+h6gVxuco+H6+1E0nZKkJuDqj66XsC2u2haNjZmH2Nt7RW2t1+jVDqD7wfo+iif+pTLn/95VJkFgczk5LdxXYPIrWgvZ2YQ6PT00384UNX5hKE0kFB+dOD+Dia0wVlqEETJOJU6HMBlmpGd4OTkC2xsfBxB8Hn22T9gevrFYyen+fnHYx4wNJuzPPnkt/pJcxjEdVAyfPbZPzg02UaV7H9Nsli4nQr+/Pmn+O3f/iI3bz7KuXO7qO69fGj/yPf/5UVAZEKRiIN0cV0/rox7gB3PjT06nU0Mo4rvR4Iyqloim51AllVkOYMsq4RhiKYVabfbvP76K/R6ClNTGmHYpVarMzKygSiaiKJEsXiKXG4K13VIp8uEYVSFK0qOVmuVdnuVUukMqpqOVbUyCIKLphWRJAVRlNjaepVUagTT3KBS+STt9gal0nnC0GF29vNsbV2JsSASzeYNDKOBZbWw7TblssWpUw+RyYzjeQGW1WJzc5Feb5UwDKhU5shmp7lw4a/Taq0Shl7Mw006ZwKNxjJray/GdqXrjIycA8B1e1y//gxnzjxKqXQW2Htvin6/PQrl7dAuB92ikvvIsATmnXh/4wOZkAcTb2RfuMTIyGwfoZhEYm04MnK+713a60Wt5vHxe+n1qoyMnMP33X7LJ9F9TareREGrUDgZm6zbWFaL0dFZGo3rqGqu/7zjAsAGwWSRPKZPOl3e8/pKZY5m8wbd7jaOYyBJMq7bw3GadDqr/Va56xrcffdV/t7f+x5XrtzFyZPPMDv754RhpBW9P3Y5wsPt30ce+cdsb99DGApE1fJePvFh1ePwbHS3Cg761aJpwtJSNGdN2t/JAuB22tYHzYqvXn10X2JdXv4s9frZPQuDxcXf2PP71auP9repKL04WSazdL+/78dtYZ8//9S+WfHwOY4WPpFYySuvfOV9bGEPIqqj68LzHMIwILqNRJ+3IIS4roEgaChKmlwucm3q9bZwXRcIKBSm8X2Dbncdz3MoFEpYVoDvFxCEFo6TQlVb2LaH6/awrDqFwgl6vW0UJU+3u4Gqtmm1llHVArqeRxRVXNdEUQxEUebkySiJttvrfZGcVGqEev06EU9+A9c1WFl5gVQqS+R8JmLbbU6duoRltZif/xb1+iKW1UCW02SzI7huGjDp9TYoFM6Qz59iZOQMrdYqo6Oz/ZGW50Ut/mJxhk5ng1LpXF9uMhE7qVaXaLfXqNev9xPyYS3s48SwreqtnpvcX7LZcXZ25vH9SOQnmx0/1gLgjvXiex8fyLO4vxI9WNkpuuAaFIteP9GaZgPPc2g0rpFK5anVFhFFsa9dG0n91fqSloMKWok4fIR8HmV29tf6VmkRZWkr5nzuB4ANRlKpR8IE63F1YtNs3uzTL7LZcVqtlXhlnmFk5Ay12jKimEYQFIIgxDCim5LnWdx33xoXLvwprmvw2mt/neXlTx2QQCKP4CT2trB/CoQ8++z/FUHwDgRc7a18fZ555h/1tzMYa2sf2/dZCMLeOWv8CR1LHWswDpoVnzr1TB9MttdQInmfKAmOjCyxufmR/t/a7en4uX7c2k+6BD7j46/y6KP/DcCRLezBOXLy+2AMnmNFMfrVPYi8/faXbwtp/t6FQtTKjsYFkXiIQKQd7SGKKoqSQhAUPM9EkhR6vXosO6pgGAaS1MbzWlQqIWHYRBQ1bNshDGUyGRlNm8Z1u7RaN6nVluh2txGEkDB0AAnT7MbgqWjb7fZG3E4uxkYMI/R6NTY3X8bzbLLZcSYm7mNm5q/HSmAS6+vPU69fRZI0wjCg3b6B7zuMjFyINd4L+L6LaTbp9eYplc70wZFhKJLJlJmd/Wvs7MyzsfEKiqKjqlm63Q1qtcU+lUlRdCYmPhTzlLfY2nqTavVtxsfvRZYfYXr6o/0zO3xvup2O2bCtKhxvPAeRn3OEK2mhabl93uqHvd8d68X3Nj6QCXkwjgIpRG3qPKbZQBRlBAFGRmbpdrcxjCqSlEJVc4RhQKez0U/a0ewsMUdvsr09z9mzj9LpbKLrUr+lJcspJEmm0Vjeo3k7DACLWl/0+ZCReICMbXdwnB5h6McAGPpzZIDx8XtZX/8F6fQoGxuXuXnzWSyriWE0kSQVVdX7Bu2iGPE9X3vtr/Hkk0+ScIT3JpD9GtG7rdXP7asohyvX3WovSlybmx/mySe/tWcuCvSlJZMFQJTwn9o3Z52efpFMJuoKHFaFHl6dRlXyww9/bQ+/d7hdPjX1EmtrDwEBV678Dhcv/jH5/Brt9jRvvx2B0qJkHJDMz8NQ5tFH/xvm5p4aausfXM3/9KeHa1sP7//W1iUWFh4HxAGk+94Ef1S8N85ULrudDxFZLiFJCpKkEgQRN9Wy2niehSjKmGaTIHAIggBJUrCsDcIQZDnkxIlJFha2EQQTx4F77imjKC6imKZUOsf29muIYhrH6RAETt+PWFF0gkBgdPQcW1uv0u0a+L5Hq7WM5zm4bo+pqY+QzU4QBAGiKPWRwbbdQZYjmcdudxPfNykWz6IoaSRJodVaxbKqKEqW0dELeF6XXG4qtkzsoig64+N3k82Oce3aD+KF+Aa12lJfjjNanBUpl3er5siNqUGtNt/XCBh0enq3cVB1fdR4Lgg8HKeLaUbI7lSqSLN5HdNsHMsk4t2KIN2J/fGBTsieZ1GrLfX5dMORzY73W8LR75MxCOsmrdYNICLMQ+RE02wuo+slMplx0ulRdnbmWV19nm53nUymzMmTD1GrLaGqmdgNJ2prH4ZqTOZQa2svxjq+XUyzTipVpFyeo1yeJZOpxEYTjb6AfdK67nQ2kKQU7fYmmUwFTcvH7TQXSUohigGaNsLW1iv0ek2CwODll383fveopfvss/9w4Ma937DhoIryIF3nJBE88sjXWFz8DTY3P0zS2h2ci1648M2BijMEJGZmniGV2p2zXr78Fer1u1hbewhB8PsmEMNV6EEt8uGEGxlb7MbeRYNMGAp79uftt3+Hhx/+Wj8Z7/oRi5RKb5NKNcjltg7Y3sFa10dpWx+0/w888HUWFr40sCjZu73DaGOHbe/dV9dB3xJQEAQkSadWuxm3bKP2tSTJCIKKLEcjkuh8hQiCTKlU5JFH7sJxNBznGtCj2VxmZOQ8tdoCnucgyxKFwklMs06xeBbHabCzMx+7lbVjbfYA1+2Ry42hqjlUNUOzuUq5fE8sVlLHMKosLj6N55nU69eRpIgjrWlF8vkpxsbuQRRltrbeiCmMKoaxRS53ipmZT+I4XRYXv0M2O46mFahW36ZeX2Bq6qOcOvVIP0FLUgpFSaHrJSyr1ZecVNU0uj7KyZOfQBAENC1Hu712oMLVO2kHH4RBOchgAnYLka2ty1hWi6mpB/uUycH70e2+3514d/GBTsiJrRjQJ+APfxEGHVaSL4YkRcIBjmMgyy75/CkkSUbTIoBWkhR7vS0qlbvI509RLJ7CMGoIAjQay/tQjIkM5uAiIeH5aVqeMIR8fhpNK1AonMB1zb4gSVRpK5hmoy/8nkoVKRZPY1mRWXmrZZNKjWJZzbiSv4HjGHQ6VXzfIAx9ZDnHoGEFwNraQ0e2RYcT3Pnzf8bIyLU9cpPDSfuRR762p/WbJD9B8EgqziQJPvLI1/rbSaVAUWBp6cv999+tTjmQW3wYb3pYcGNQMjMBb4HP+vrHk3eKz43PlStPMChskpyzRiMSedjcjBYJjzzyNba2LjE19QK53Ab33/9H+87jUdrWB+3/5z//+3uQ7oPV8a3i3VLG9odIYnsZhpFm+ebm63S7Jq4bGVeUyxqaVkRRsv0Wd9TGVWPTCAtV7VAoSLjueCwlOYrndUilioShRzY7xebmK2hagWbzWsxSWMfzDFS1RCYzQi53AttuxiOhEr3eJopSwPN67Owsks9PksmM4fs2jtNFVTPxTPcU3e4Gtm1Tr/8ckHGcBoXCDIKgsrHxEqlUBdvuxHPoIvX6dVKpHGEokM+fZHT0AqqaZXPzMoZRpVK5h/Hxe/qLedNs9t9PEARUNYuul/ZoFAwntluJDh37ExoQHFHVDJ3OBo7Tpd32SKdHmZz8SB9oOrgfd8wh/mriA52QE0m6QWm6W3mIJmjE8fH7iPxBQ9LpkX4iHnxepMgzQ6VygmZzmWJxhlSqtE/gfVBoZGXleQyjCkQiH0Cfy5x8Yba23mBz8xUMo0YmU+6DRJrNZbrdKs3mVQqF06hqmvHxD1GrLWPbder1q5hmE9OsxwboNq5rIss6iiKh6yNMTy+zsACDCeioG/dwgkvoQoMxnAhcN71vLjr4+gce+KNDNaT3g7LC/s+HcYsHHz+ORrXrZvbs7+TkSzHHOgJstVqDUoYJx3p3f5J58u68N4r77/+jfe81rG19/vx3Dj23yXENosEH58+Li49z48ZnmZ09mKJ1u85UR3sqS+ziCSLt6VZri2rVJJuNHKUANjZsJicbJLrYENkuRmpfLpKkIAjRQjRqH/tY1jaelyGTERgf/zCW1aRcvhfH6ZDPT9HpbKKqWVQ1w8jIOUqlM7EK2DqKksfzOnheiONs0mh06fWqpFJZTp16iHZ7izC0UNVRHKfB6upL2HYDy6pjmk2mph4in58mnR6lVltAklRct8vGxsu4rkmvV6NUOoNhNMlmJ9C0aPRUry9i2x00LY8oStGVEHo0mzfJZsfxfZfp6Y+ytfUGGxuvcPLkw2haAV0/GIA16ApVry/GqPF35jU8aPlo202azevo+giiKFMsno5pZnfi34f4QCdkUZT7qjgJynkQpbjL593pO6cMgrSiVnEN37cpl+f2rFyjn0OazWUSU/N8/gS23SEMfbLZiQHw1u4XJjJ7d/A8i3Z7DcfpkDgRJWCNyC0nJJ+fpN3eIAwjowjLim4Sydx7be3ncXt7luvXV7DtFrbdJQxFNK2A63aRZZ0gsHAckytXfp0f/vA/Z1d1K/r/qBv3cRLccBtYUYw9SWV6+sW+ItXMTIQyvtUCYDcEHnnka0xPv7hvH4YBUVEyv7UZxHDi+vSn/wkAy8uPUq+fY3HxC32k8/T0i/GMeXd/dlvce+PZZ//hvvnt9PSLTE29QK83yt13P8knP7k7Qx7c/+np6Nwc1pIeVPp66aXDKVrHNcxILBqT2P++g0BILW6/Rpxc3wdNi/4SSXQ6RDrYJTzPjcFfIp5nEoY+vu+jKAqynCUMBXzfIQhMLCvFxsYvKBZPo+tFJibuZnPzMoIgIAgqmUyRQmEG1zVwXQfft8lmdSQppNlcwbK20fVJstkJJicfoNersrr6ArpeRNOa7Oy8Sa+3jaalUZQJHMcgnR5D1/O028vIsoqqZlAUnY2Nl9naegtNy2BZDSYn78e2a6RS2bjSt+MOVoaNjZepVhcYHT1HPn8C1zXQtBy12hKNxjLt9irb229RLs/28SnDbetBs5hI/Wuv6NBwHNXiTl4TOWPtLwiOE3cQ1e9PfGDP7KC4egLGqtcj3duxsXv38HnDMLoYs9nxPhgiEgPJUSzOHHhxZ7ORvJxpRrJ5uj6KbXdiNPQKoijHdIiIFqFpuVg9p4TvuywvP0O5fDfj4/cAu1/QCCjWplg8jeMYGEYVy2qiKFkgpFCYxHVNNC2PIIgoSpZud5teb5ter4osywhCBklSuXr1P2Rh4aOcOfMsc3Pf5OrVT+xpIydI4Vu1NW+V4IbbwMPcYdclpkpFMXzzTyo9RenhuhkeeeRrbG/fu0fAI3mf+fnHefrpXVWr5G+3Mzs9LHEl2x+c4T7ySJSsX3rpKwBUKm/geWlWVz/JxsbH92x3be0h1tc/2t+Hwf0KQ5mpqRcBeP31XU3rqLLdu6/DGtiwX+lrmKKVdDmOa5gxmIwTu0bTBF3vP9r/ezZ7giDwkaQwrnajz3RQL1vXy6RSEwRBB993CYKIj+z7IUHQAtJks1l0fZIgcAkCn3r9OoIAQeBSLJ5lc/MtNjdfpderk06XcF2dWu1tNC1LGMoEgY8oCqRS40jSPJ7noSgKk5MfIwxDrlz5tzH6uUQmM4ZhbKEoWWQ5Szqdw3WzBIGBaXqx1naAKMpUq2+SzZ7EstrIcobx8XtIp0cplWaw7Q47O2+xtvYSo6MXEASJRuM6plnDdXucP/95JiY+RK22RKt1M24P38Xs7F+j0VimXl/q3yOGO3LJiCuTGe/rFBwWRyGeB1vR+fz0nr8dN9HeQVS/P/GBTciRjJ+FbXdJpYqYZg0Q0PXRvrRlKlVA03J9alISnc4GzeYy09MPHtruEUWZ8fF76Xa3+mjTQuEEr732r6nXF9nZuUIkt1lBURSKxbNkMuX+nMl1TSyrxurqz1HVDJlMZYB6VUfXI9/XXePzAo6jxSbrDplMmSBwuHnzp7iuzcbGy/R69Vj4PmRh4Uv8L//L/xtB8Pjxj/8T/u7fVbl0aYHnntt1ejpOMj4uane4DZwkiPn5vZVdYjM4uP3I9GFXKxtE7r77j8nn1/fty2DivXDhmzzwwNePnJ0etv/DiStJgjMzEbBsbW1/sh58blKx7o1gzz5E1fTufl2+/BUuX/67LC19ac/iYWbmqX47OvFGHo5hBHpC0RrkQ7/TEIS9CRp2K+jIa/kqmjaO79uMjkp0Oj69XuS1XCwCyH26oCyLCIKC4zTi82Hj+z6ynGAhVCDEMGoxcyAgCEJu3vxJPCc2EASZYvEchcJp6vUFWq11JEnCcQxEUSSylAwRRRFdL/cZELbdQRBAUTKoahpVvYAkgefZ2LZJOj2GabbJ56fwPDemDhrYdhdRrKOqWaamPkEmkycMfRqNyBM8msu2Mc0axeIZxsbuYWfnDWRZ7SOsNS2HZXWQJIlK5SKqmgX2K+wNJr10erQP2Eyq2sNisFC41XMH46AuIOxP1HcQ1e9PfGAS8kGqWzs7b/Ur03I5mtcOakpHyS/6QiWUBsOo0Wgs0+msMjIyS7F4ek+7G9jTgookK1cIAp9G4xq93jq93jaW1URVswiCgOOoMRClysjIDNnsBOfO/RobG5cJghZh6GLbbba2Xo/tExUymTFarU0ajWU0rYSiaIBKvb5Mr7eBqma4du37BEGA47SJTOaj/fN9m8XFB/Ykg7fffoCvfOX/h+v+H3jrrfNHtjQTm8Jud4L19Y8fiG4eTnKHzS8Psxk8SJxjd14cxjrY/h45yb3PhYWFx/vgqqTFfJQs5WGV83BFepCAx3CcP/8Us7PfZGnpcXb529K+fRg8JxFYbT9AzXU5ctGSvN/+ufx+YNxxYvh4D0rGvr+bqCP/kS0iNa+AXE4gl8vHhhN1IHKMct2AMMzg+yayrCIIAYIgI0khxeK5eD68jeOYRLQuNa64e3S7VbLZMfL5KbrdetwpqqLrBRQlhWV1EUUB349EeCId64jyZNvN+G923HKuo6opdL2M6/biTpIaYyvaSJLCyMhpRDHF5OQlrlz5E2q1K7FncR7HmaLb3SSTGSOTKVMqzcRa10XC0OHEiY+Tz0/h+wGW1WBt7SV838E0a+j6SF9AJAx9JEntJ8IkqSbjqmw2MsmIZECjBf5hFW1yrzGMndtCP6fTo7RaKzQai3HHLyowhgWT7iCq35/4wCTk4dWnZbX6xP3h+U0ivFEqzaDrJXq9HXzfZmdnnlJppv+vUpkjCDw2Nl5lc/NVVDWHJKmk07viHJHBxPm+CH3EXY64xY3GAoIQgYGazZtxq+7TsdRgilQqj+P0OHHiEba35/tcQc+zKRROsLLyPI3GIrbdwzRrTE5+mHL5Uky12ooVulRyuXF8fwMQYgqXHCfI/6KfDE6e/AGu63LPPd/h9On/MT4TCaVnN4ZtCoGhqo89XseDspQHtYGHE/WJE8/smYcOinNECS3ZLximTQ0KhkRJMOLqbm0dbGH3blHHR1GMAO677+v9and333Zj8JxUq+e4evULe44hSdy38kYeBHPNzDzDD37wXzMoZRqpSx3/mG4VYRjJnApClJj9vlZMNCuOn4Uo2kCM7kJGknQ8r4Ms60iSBgg4TgdZVpEkkU5nm1ZrBdNsxuwBFUmSkSSFTKZMq7UW8+7Btlu4bo98/gQnTnyEGzd+jGU1AQ9BEJia+gidziqyrNBsdgEp9l4W6Ha3cF0b01wmlcqTzY4zOfkArdY6tt2OAWrrpNOjTE8/wMWLX2Jz8zU6nTUqlQ/R6dzA9yMVMVU9i64XyOenKZVmyOdPxO3sM6hqhkZjmULhBEtL38N1O4ii1F/cR/K2iS5Bqp9Uq9V5TLPByMgspdIMhlHteyMf1Tp+J1Vs8p6u2+nbQibhedE9L9L9voO6fj/iA5OQhy/WYZ/PwYgI/FV0vdRHXK6sPI+ieKytvYSmRYkVYGvrDVZXf063u8nJkx+nXL4Yt+esfuto8IszNnYPqVSeN97417E60CqFwimCwMa2W1Srb5PPT5HLTdLrbTI9/SC9XjVe5UtkMgrV6tuYZoN0eox0epxO5zKdziq23WZj4zUiGorUF2NYWfkZnhfieR0EQSWVyjM398yeBHnx4l/S6Zyi260NnIn9Cmb7Uc7R85Lk8fLLfzd+LPr7oLzjQfPLubldDefEZvB739srppFQqRYWvkC9fnHg1YkYxy5t6sKFPyMMYWHhyyRJbW9reFch7HZRxwfFMMp518/4qT361I3GbsI9aKY7P/84S0tfIll4ZDJbPPDA1/vna3A/z517pq/wNQzmiiIx+Xj37erBSBYfohgl5TDc/T2KkIirLgESjtNhd9YsxvrWkSWjKJo4jg04OE6XnZ230fXR2FbRBXQURUdRsmSzFYIgoNW6iudZZDLjhKGLKCo0mzdj7WwHSUqRTo8RhiK+78SKXDkUJUO3u4YoCpTLd9PrbWJZrb7NYzo9zsbGq6hqFkWJxj7N5jKua9DtbpPNjjMz80hfiMd1LRQlHdMb1/uLinz+RL/DltCUKpW5ePyVJ5s9get26PW2yeUmGR2dpVZb2jMOS6dH0fVRTLPRny1nMmUcp4eqZo9Muu9UC1/XS0xM3N9ndSTbd5zuvu7gHVDXLzc+MGf2IF/Poy/e3T5dNG92YjeZMVZXf4GmpWm3b2JZnXgW3cL3I1ejRCQkaUOtrDyPpuXI509Qqy2xvv5zisWzpFJ5isUZRkZmMc06N2++iCAo2Hab7e23MYwazeYqhcIJbLuNJKVjgNZOfLOTEQQhtpMTabc3efPNOW7ceIwHHljlox99GctqxghUA9DJZMrYtgW0OX36KU6d2k2QQWChqjqO4xHd1N1DqTN7Y5eLOxzh/py+L5IWcBLD89AEuDUz80y/+gaR2dlvMTn5xp4KOaEWRQk52qfx8ddjINZehbDEc/g4qONbxUF+xklSPn8+mgEPVsvDSXIv8A16vck94LfD9nOvnGiS/KLOwdjYq3zqU7s4gMOq31upe0Wyr3ufn2wrMQTZGz4w7MJl9n8SRSVuS+9S1nzfiys/HxDRtByp1CiapqOqORyni+d5gEgYSqhqxDRotZbxfRvf76EoJcBDVTPYtkG7fRNJUsnnp/F9D0UpMTHxAL7v4jgdms0biKLI1tZLpNPj9Hob6HoF06ySTldwXZN6fZEg8BkbuxvDqLG19Rqt1gqZTBnXLccI8Kgj5nkWW1tvIAgRziTiN/eYmLjUT6wwgiBI/YQdhl5fdyBxk9L1EsXiTF/oZ1Ck471qHSetb8fpsrX1GuPjH+pbt4qijGW1KBZPY9udvuTnoK7/nfjlxAcmIR8Wg/Pf5GLPZsf7AKpkrtNq3URV0/GMq02zeY1S6SypVBHf9/A8g+vXf0SrtY4gCP22d/RvG9OsMzZ2D4ZRpderUSicYWrqQ6yvv8716z8iCHyCwATkGKXZplpdpFK5F9tu4TgGglCn213Dcbq4rhnfFHoYRh1FkXn11c/x5JPfQBA8nntO5r/6r/4J99//HLXaPNH8uEO32yVypqJPp0rmgKLYIp0eQZJ0XnnlQV5++T/uI4qHqTPPPvsPY7rPXonLREkqSZoPPLCfezscw3rOly49haIcjHIerqaBfZSnf/kv/zTeUpSQt7fv5Yknvsgzz/yjvkLYoNDGrRLx8P4dFAf5GQ+iower5VOn9if/+fnHY5GQvcYXt0JHDy9eYJeP/alPRVraTz/9h0xPHwwGg1u33kVx/2O3SuJHRRB4KEoKUcyiKBK+HyIIApZlIAg6ipIhnR7BNNtY1g7tdh1NSwB9FkFgY5o1BEFFVVWCIIVheEDk7uR5Vjx7NggCn16vTiqVQ1VVPM9idPQCQeCTy02zsfESuh5ZMbquz+bmy4iiCojkcmPU6zfi9xXY2bmCIMhUKnf3JWejeXSazc3LBEFk8lIuX0DXS1y//gO63XU0LR/PlCMQqa4X+0k2GYdFi/YsOztvEYY+oighyyeR5dQvRaQjaX13OlsYRp3V1ZdIp0vo+giZTAWAbHaCiYn7Birigxfdd+K9iw98Qk6sESPAxe4q1DQbNJvX+89T1RyiKDE5eT+l0gyJw5JpNpBlnTAMCAIfy4oAJ8Vi5E6jqhlAIJ+fwrJatFo3aDSW8DyHavUNarVFTLOJIARUKh8il5vmzJlHeeONbwCRI0xUJeQxjG1838AwGlQq95DLTVOvL6PrZdLpcdbXH+/fjEXR46237uGjH30ZRRnB8zrxkYRxe/SznDz5Q2Znn0KSiJGpLQxDZn5+V88a9itgJSpY6+sPMihxWa+fY2bmmXdUdR5kqnDQa4er6aOem0QY7qKgB2lGt9PKTfbvsMR8mJ/xQfu+vLxLzQJ4+eW/26/g944CxFvu43CiB/b8vDuLPxgMdtBxDh9jwil+9yEgCGlEMY2mpZCkTPy9MbCsLkFgIooykTZ85AQVLSQNwjBLVD2HWNY2ghDgOFZs65iOwY4S3e42+fw05fJ5RBEsq4OipMjnJzHNDisrP0UUU4yMzAAChcIZcrkpJic/zPXrP+LEiU9gmnVyuSk8L7KANM0WGxuvkkrlGB29i2JxmqtXf0SzuUihcIZudxPTbMf4DKHv9HTixMf7fONCIVLqk2WNjY1XGRmZ7SsB7uzMo2lg2x0UJY1tdygWzxzYlr4dPvCwg9zg85NtF4szQATiqtWu4nlvkM9Pk8uNUy7f1X/NUZr/d+K9iw98Qo5AV7MEwcyAUMcOul4CiHVyoVy+2G9NJXSmTmcDw6jjeSYTE/dimq24nWxgmh0UxY4pCz71+g10fQTD6CIIEr5v47pd8vlTlMtzhGGIKGpoWp5udxNdH0VV8wSBjeuGfVu0mzefxXUN6vVFPK8bz7xMwlBkbu5Vfvzj/wRRjHyNZ2dfYGfn9b7VIuxFFr/00n/Jf/AffJFz557qV0FBYHLt2kP7QFLDSWbYKAJgcfELfZenz3/+93/pn91BMT//+MBve6v02xHGOFqlan8kiXGQDnVQ8l5e3ovs3t3PXRnQTGaLEyde2CO1eRS9LEmyCS3qsceicz88ix8Ggx03blVBHz+iboqm6aRSEU/e8xyCILHpFGLaUzLqSABiPpG5S5owjJgCnmciCCKua2HbHVQ1g6pmCAIPVc1TqdxLs7lMOi3jum6sZPc2vu+iaQVqtTfR9TLRIkFgddVmZ+cNJElldPQiYejGyUdEECTC0EGSFAyjzubmy32u8ejoBWZnP0+rtUqvt023u8nm5mVMs4EghORy0/H+WrRaK31zGNOsc+HCbyLLqf58NjGPkWWVxDkO9ibTo5QEh5N1UmwcJM85+HulMhd3yiQcp0UqVWJk5Pw+JcE78+NffvxKnt3buYBEUd4zExlUsZHlFN3uJp4XzYhVNU2zeZ1OZ6M/S9K0HOPj98Xgh7f7VIGIXymRy41x/foP4or4LSJ7RQlRVJCkNKOjF7j33r/B0tJfoGklLKtGu71FvT6P41g0GlfJZMpMT38URclQKp2l0bhOuXwXvm/R7dbwvMhj+fz5P+Nv/+0qKyuPcc89b3Hq1L+m1+sQhiYJYvowxG40IxQBg5mZH+xBYF+48K19kpiDyW1Qveq90Ug+PI6yKxxcbABcvPit/kz5ILEQOHhbw4l0MCEd9f6XLj3FpUtP7fnb8HMHz38Uu3PUKER6vcl9yfgwH+m9wC6fl176L3n44a/xmc98ldnZvVV7UjUfdE6PikGw2rv7XAXC0MIwGoBKJpPFstq4rkEYCoiiiOe5JF7copgjMvgICAKXQmGaMJzAdU3S6TyW1cI0G4CH59mIooAgaAiCwNWr36bTWY3b2mkEQSIIXBwn0m0XhFHyeZ1udwPT3CGTmUSSVBynx/b2FXK5MYrFM0iSQjY7RrW6SKs1TxjaRNgNkVSqiCiqqGqW8fF76XQ2EEWJbneHGzd+QhA4OE4Hx/ks6XSZlZWfIssagqDguhm2tt4gl5vs33NEUaZUmomBo3larRWGk2kyCotUt2p0uxt9DvFBPOZEdveoyjZJ+CdORKjwQR19uCMK8n7Gr2RCfjcXUHLxJwT7dLrMzs4829uvY5oNstlKDCJx48oWJifvo1ZbiJ/TolicwbJa7Oy8QKUyh6Jkse2t/go+DME0t0mlRhAEePnl/xnT3Ob06c8wNfVRtrdfB0RSqXy8DxUsq0O1usT29hu4bg/HMdA0nWx2MuZGGqTTWe655zs88MBzCIIYJ+MQWS7ieW3A3ocsnp19Zp/60nEryUGE8KB61XFawe/GBjBJIMPbGF5slErXgMNVuo5KvMd5/3dybLuguGRWnFDLdjWxhxc1e5N4wMsvR6pgu4h2GHSkeu65P+D06aPBYMeNg8Bq7zwphxiGi+u67Ox0qFQ0dhckQnx8EZgQIAgaRJafUdKTZR1VlXGcNKqqMjp6F93uOu32FrIs4bo2ghCwsfEyipJBEEIymRKeZyHLaXS9gudtEARiPNc9RTpdYWvrtXh2epFmc5lWaxkoIwgyqpqn1bpJt7uKYewQhi6+H6DrkfeyquZoNK6zvf0WgqAQhi7r6z9HVQuEoYOqZtC0HKXSTFzxhrFPepUg8Fhbe5Eg8MlkyoiiTK+3g2U16HZTuK4VezzvorAtq4UgsGcGHYZ+v8JOkjXsLzYOi8GEn5jsDMYdUZD3L34lE/LtXkAHOSwNmn2fPBlJIBYKJ1DVLK3WSqzDW0CSFK5dewbTrFEonEVRtjh58lOsrf2cRuMamcwY4+OXmJt7nK2tK+zszGOaO/i+wNjYhxEEiYWFp3CcHpnMNOPj9+C6HrncFEEQoCga6fQkzeZiH5Di+z4nTz6IaTbodi8ThgGXL3+KGzc+x7lzP+NTn7pOq7WG76/Hs28Zz4vayslN+pVXvsKgXGV043P7v0XJ9i+BWxNTb/fGfxxBjlsl7IO2cRCNaWlpb5K+evXg6n0vl/dgcZDjJOtbHdvg+X/77S+TUJTuvvuPuXLldw5c1ChKb6CiFllY+HKMIh+O3cT+8stfuS2pzMEYrOxvBVa7nVZ2rxcBxEQxAhJWqzblcordRYmDKKoEQYQSj7yWM0hSliDwabeXYx6/hiSNEIYu09MPoWlvUq9fQ1F0TLOJ65r4fvTd6XQ2UNUchrENBOTzU0iSRjpdoV5foN1exfddOp0byLLeN10ACVVVKRZPUCicRNNGSKWWaLdXabfX0bQRyuWLyLJKq3WTmzcjYCaA43SRJI2zZx/DcTqUSjOx2l8Rx+lg210EQUTXS7hur+8SF1m7Rsk0MtuItOxVNbtHPAR26ZoJrSrpCiao7UHVrcPiuJ3EO6Ig71/8SibkwQvoVhddEHisrERCGoZR5fTpT/UfT0wmdufGm7iuiSiK5PMnKJcvcuPGT/E8C10fZXLyfhynTb2+hOcZ5PPTSJJGsXgSXR/lwoXP0+1ukclM4LoWrttla+uN/heq1brG1as/pFq9Els0Rm434GNZXTzPZHz8XlRVj2U981Srb/Pccx/ij/7of0AUPb7//ScoFv97Tpz4//DWW7/JjRuPcuHCy5w//+9i2khEzXr77S8jCF5/5js3922Gk/KgXvHx4ngozMMEOQY1qweNEX77t7+4pxV82DYGrQkTMwbXZV/bdrgyHubyHgf8NBwHKYsd1r5P9KkXFx/n5s1HOXfumfj4/9d9i5r5+cdjKtRe9HV0roX+75OTL7KxkZhcREn7KNvMW0WSaIfb3rfjvzwcCaJf3vM1tIhoWgJRApZw3XTctlaRpAyC4GLbTmy36FEq3UOvt83KyovUaosEgYcsq2QyY6TTozSbN1BVFdPs4roGsqzjOFbsp3ya6emP0WxewzQbOE4PXS8iSWlarWVsuxM7PPUQBJ9i8TyqqnPq1INkMqO4bo8ksUeOajqZTIVy+R6CwKVUmuHate+j60VarRtkMhWazVWazWs0GjcQBIlyebYv5Tk2dm//HpMUBqXSDLXaAvX6dWZmPt0XJUqoUUlS7na3+j/X60sUizMIgtyvmG91D7zTiv73L34lE/Jg3OqiM4xarFddR9NyGEYkjJFUx8kFnE6P0ulsUK8vxbSMMp4XAbM6nXWy2Qmmpx/g6tUf0utt9TVqFUWn2YxkNpeW/oJ0eoxcbhpBkOn1akBAOj2KoqRptW5SKp3Hslr0etuEYUCxOEO3q2AYm6hqhmz2BKIY9Ffh3e42CwuRt3AQREngxRdLbG19gief/HqfAvUf/UcmFy58izB0jlCokojkD+347DjHOse76l3BsdqaB1Wyw57JiQbz4Jx78MZ/2DaWlz+7h+IzjEI+KNEOV4Fra7cHftq/7/utIAcjWRAMI8YPqmajtvRwMh7mIYl84hP/JNbBjqQ6D1oMHDT7Hu5EDD9nuPtxPP/lSIxl7+IuikTVay+Vqi/1hePAboIOkWUR13VJp8ex7Sog0mrdiIU/DARB6C/AC4UzOE4r9kU28DwLz3NwnGgRraopJElkff3nhGGIpmUpFE4jSREgqt1eQZYVkrltEIRAZGuaShXIZEYpFE7jOJHdpGnWyGQSH+ExXLeHLGcYG7tEp7OJ5/kEgU8+Pxl7JW8jihK2PUkmMxqf40g3P6I+/RzLqrO19Qbr67+g01khl5umUlHQtMi/PQy9WOGrtAesmezz6OgsOzvzfc/jQSlgYE+SHiw6ksfugLf+auNX/qwPt68HL7rk92x2grGxe/asPg96jablAOJ2UzH2Ec5RKJwlnR6J57q5+AseUCxO026voKoZlpd/TLN5g8Q/OQwlLKuB6xoUiydjz+Im8/PfiGlMo4yOXuDEiY9Tr1+j3V5HUTI4TtT62tq6AohUq1eYnQ348Y9/b2Au/BwLC58aatV+lPPn/w1wVDJ7DEXp4LqZ25rtDqtz/fjH//CWr71w4ZtA2AeLPf30ICJ4V/YxkvV8Zt/rh60Vd6lD+yk+B1GlBuM4lKWjYniBkyiLJZaPa2sfO/CcDhpGDHcAgP5sfjBmZ7/FffdFQLXLl79CrzdBJhOhcYelOgeP46B5eYL4ThZSw50By4qEPwYXCgchx/dXyR7Rwm5vpNO7rx8WG9kNZ8/PvZ6IoogEgYOmjWLbTdrtKpIE+Xw5FrrpIkk6jcZCvKAO8X2bSL/dp9tdxzAkyuWLcXt6Bc9zGBu7hCRpmOYWzeYqmcwI2ew0sqzS621TLE5jGC263R1EUWVnZwHPs1DVNO32KpbVolp9i0rlnngx34hdqIwYZR2BC9vtDTQtQyYzjqJk0PVR6vVlHMeKHZ0EdnbexHFMLKtBPn+aSuUiudwEMzOPEAQugiD3lb0ielVkxzooGBLp88/HyGr61rLDs2XYNZWw7c4eVPYgSOydJOU7Sf3dxa/8GRuefwwqzkSKNFElPEzAH3zN7oVa66vo2HaHRmOZdLoUG42PoGk5NC0CeSRf/JGRWTKZCqOjs2xsvEqlMsfGxmU6nRV2djpAGMvXFeh01slkJvC8Hvn8KUZG5lhdfSF2jIqUj9bWfoFtt2KASIBpNnjggeeQpH/AtWuf5PTpH/Gxj70BKHuSdHRzjiqX4aoHEuBTAgzy97gl3W7bc339oUPbpcPVZEJJGl4kPPzw1/C8NKdOPcPs7MHbGWxvD3Omb4fiM2jMMNguPi71aXjfk2M66JwOujcNtskVZS/YbHHxcb73vf+e3Yo4YHb2W/zNv/k39rx3so2lpS/x27/9xQOdqIAD3aKGF1KXL39l3zlLtKoPQ5knsT8p2/uftO88Jm334dGIOPCYDyjYtkEY2rHeewQEE8VIkcv3I+MI2zZptzeAAFlOxy1yhTDsEQQhtdoiqVQFUXRJpUZjFTsT2+5gWS1UNRcDqjbJ5aaoVpcIgpD19Zf6kp2ZTJmRkQvYdjVW79um3V4BRGw7qljDMKDVukahMEs6PUomM8rNmz9B0yLlsVptnm53M9ba/gSCIMaSmXLMC/aQJJ1Ll56ImR5b/TOj66VYanSekyc/vocn3G6vUa8v4fsOmlZEllN4noVheH0gWDab6htYVKuLOE6bVKrI5OSH94HE3kkb+zD3qDtxvPhAnq1IvWenr916KwJ+cqFGsyYNWU7Rbq8iCAKZzBil0hnq9SXq9av0ejVKpbM4jkU+P042O0kmU4ll8SJjCEXRYjlLF12PZsGrqy+i68UYyJWOQSzXaDZXqNeXCAILTStSq70V85nr2HYbz4u8jz/2sVd56KHXqdevIUkzPPzw63S7X2J5+TP9Sg0k5ub+FNhb9QxWp4nIB+y6Jd3KBenSpUSdKwEV+YdSnw5rlx8EDDsOvWkXmSsln9yRFJ+DImnNDu/vcWejB+37Qed08HgPAkslx3ywdaOIKAosLj6+h3c8uI3Ll79CsXid06d3K/HEmSvpHiQzcoC1tY/teYdeb+LQYzyK+jX4HNhVgLv1OQzZr5cuDT3m4LohkfSmR4LK9n2Ben0RRVEIQwnbbqAo2dheVECSsmhaiSCo4XkZIHo8CFxkWY3tEJtIkoMsayhKBkVJoWl5LKuB43Sx7RaNxlVMs9WvbCVJo9F4myAARUmRyUTSltH39SYjI7Ok05GoSKVynvHxS7z11jepVufxPIMLF77I5OSH6fV2EASFkZEZbLvbB32Vy+ep169jGDVu3PgZ2exYvz1dqy2iKDorKz+LW/Yt5ua+2OcgRzaTPro+ShhGGvbl8lz/HpSoDm5tvUG9vkQYBkiS3NdcSGhXKysvoKpZguD2qtykDR6GIUFgsbMzfycp32YcIIr3qx3Z7DiZzDiCIPTnxQdFt7tFtfoW3e5WH82Yz5+gUpkjmx1nZGSWsbF7OH36U2Sz47iuwerqC3iegShqZLMVFKXAyMgZADY2XmZt7UVu3PgJvV4LTUszMfFxNK2EJOmMjs4hSTphGGlm7+xcYXv7LV544R7+1b/6T/n5zz+OYVQxzTaGUcf3DWy7SVJJRO2r6Lh0fQLfd5mb+xYzM8/w7LN/wAsv/Gc8+eS/GxLOiGJm5of9VvHeimV3Fjkcgzfk8+ef4uGHv0aSjEE6tO27+17726pzc0/tkbJMpXb/DcbepD6YjKN9fuSRrx1LkWp425a1++92Y2bmKR599PeZmYmS6v5zutfoYXb28PNw40Zi4JFElKAWF7/AN77xLZaXHyeV2r+NpaUv84tf/Gd84xvfYn7+8f7CZWEh+swHE/c3vvGtfQlYFCMxkcXF/dfIcSKIdzlSfYv+N4zEnvFWsSsCEp0vhaheCIiqbYsE+LULavNwXRPPa2EYTVy3g6blUNUCsqwQBBENKpXKk8+fJJ+fRFVVUqkcul4knY78x9PpMVRVI5XKUy5f5MSJhzhz5rHYbEInCFxMc4tqdZFG4xpBAI3GVRqNBcJQRFUj9LQoymxuXubEiQeQpBTV6iKXL/8r2u11Op11QIz9kd149h0iimrsbR7Nqi2rzcmTH0eSZAxji+XlZ+j1tjDNZoxHuUlkSxl1/pJ58Y0bP4k1EwxGR2eRJBVR1Gi11gjDXZ5zZJxTJwyhXL7AuXN/vU+NigCuL7C19SobG68ceX88KBJmSiZTiTEy23uq+ztx6/jALV2S5JoYhx8F+Eoq6YQ4P/icBCwBUfJeW3s5FgLokk6XWV9/kTAMCUOHc+f+Gvn8SVzXod2+iWHsxGjQm3S72/FKewpBWKTdXufNNz/HW289gKqa/PCHkUDHT3/695Hl/5R77vkuqpqm220SBD6aNoqiKLTbN3GcHp7nsLLyMxQlA8jHshgcnsdubd3LwsKX+6+r18/1E3kCABoG93zmM1/l9OkX97V9h+O94MYOt4inpl5gff1BkgWE66b3JdrBOKhqe6ec5INeG+3j3nPquukjdbkHz2cy094NgUFHq+GuwtWrB7tJDbpcRRF1DyIBjV2FtSTW1h5ibe3BYyHND6qSE6CWIOzVSff9KCmnj3SBHJwdq0QJOZLNjLdOdLuyAQFFSSHLJVy3huf1ABvL6pBKZWL8AQRBSBiC5zlks2M4Tg9ZTlEszpLLTdFsLsdiIR1kOYUsp8nlpslmx1lf/znpdBnLaqFpBXq9ddrtNRRFJ5cL8H0Dy/Iol/0Yma1gGFUcx+CZZ/4x3e4mhrFDJjNOOj3C2FjE7y0WT9Nub6JpWcrlu9D1Ehsbr2CabWRZiavhyGRCEBQcx6DbrZHLjSFJGtPTH2Fj4zKTk/dhWe1+0rOsBp5n4/s+YehTKs3Q6+2gaVkEYddrOQg8RkbOMTJyrn9PG1QBC0MfWc6iqrk9M+fjxOB7BIGDYUQywnBntnzcEMLw1n487XabQqFAq9Uin8+/H/v1vsTwRTIM+NrZmScMPbLZyX0JO6JJ7ZBOV+h0Nrh58zkcp8vo6AVEMWRj401su0k2O8aZM59FUVKoao5ud5NWazMGllgxD3EEXc/y4ov/lF/84mH+p//pfzgQ4PTII/9fHnvs95FliSAIURSddDqPbRs4jgEI+L4ZVyomEOxr7x5X2GF+/vE+V/Yg9PBBN+z3Rl7xeBHNkIdn4Ld3jINxUFJ9Nwl5eBu3W3UvLj7O5cuRAEil8gbPPfcHRx7f66/v9ZB+4omoLR2BtqIuwvT08zzyyD8ZeHyvIMngyOHBB/9ffQnOweM4Kg46xqRaBshkjnv0CoKQIpLJdIk4wRkcp02UpAV0fQqI1L1Ms0UQGICCphXi93XQ9VG63U0id6VcrAgmUqnMoqpZfN9BUXJxRSdw+vRnEEWRdnuL1dWfIAgKipLCttuxIlhILjeFpmUxzTq+b6JpRXw/xDB28H0X8EmnK9h2C0EQyOVOcebM57DtJoIgEIZQq71FoXCKiYkPEwQ+jcY1BEFkauoBCoWTscznMoqSodlcxvd9KpWL/UICiK0ft6jXl8jnT2CaDXZ23sZ1O0iSRrN5k1LpNKlUnsnJj/Tnyc3mciwV7LG+/jKTk/chSVo/cQIxIE0gm5049hw5uXd6nsXGxsuYZpN2e4V77/0dyuWLtNtrVKvzfc71sLb2r3ocN4d+cM7IUBy0YhumBwxqzCacv0EaVPK/LGs0GteoVD7D5ubrVKvXUdU0oihRqczFAgBm/yJsNJax7R6pVJ5cbjJGay6Qz5/g2rVPIYp+TGEKCEOp//vFi68ThhauG6DrI7GCV8SljOZqdgx42QuUGUY0Hyfm5p7qU24Grf0OowYddcO+XV3o4+7f4LG8VzaKv4x4Jy3wYWT41NSLvP76VziM632YQ1Zi6SgIfuzONWz1mLT8B5OyRCpl3PZnlVTNQbC3Wk4q5uOHSxi6JDaSIBOGKtHtSkSWs5hmlSg5ywP77SHLGr3eDqIY0m5vxvshxnaPCpIUYlmduDOlUyzmkWUNTSvGLd8IABahk0u0WteRJI1SaQZJUpDlFI5jkclMYBhVGo0bhKEfa2inKZUukM+fod1eplK5h15vh0Zjnmx2isg6MgGHVajXr9HtbqBpeQqFkzhOr7/Ij6xa30YUU2ia2sehWFaDVKrUvy/p+ij5/HQ8OxfxPJNer0ardZ1sdoJz5yJRo2jBkMzgo6Rr203q9etIkkSnEwFHz5z5HOPj9+4pTI4Tu2CuKpKk0+tF/PBG4wapVDHW725Qr1/Htlt3xEYOiQ9sQj6ImzeYZJOEnQi+J1SD5LmDNAPPs/B9l/X1V2LLuCbd7iaVyl3IcuTeEtnLtQCwrCa+3yOVOkEYBtRqCwiChKKkufvuV/n+9/9W3yDiiSd+gOumOHfueUqlf4ttR6090zSYn/8ECwsf4sKFN5ibewrX7RK19BTgcETzcWI/5Sa6ww7OPJeXby1/+W5awbcT70SR6r2Ko+wZ3f1U3GPHIDJ6ff1j8RjBPxRod9A5cN3MgSOLxx77at+2UhAMnntuUHzE59ln/4CtrUu3jbI/rCNw/Op4MASipOziujtErerILcrzWoCAqmZx3SBO+HL8HfNi1Sw5rlqdeFY8Qi43SSo1giTJcdUKjmOQShUIAolOZ41M5kS8CI/8jHO5PJnMBIqSRtfztNsbWFYT8NG0HIqSxvN6pNNTyLJKozEfMyNsgsAmnS4jyzlSqTyOY8Y4jwqGMY+qFsnnxykUTuA4PcIwusfcuPETbt58AQg5depT/XtTr7fTr3Qdp0e3u90HqUVKXxk8L9IvOHnywb4BRSpV6t/LgsBjdHS2D+KyrBaua9NudzDNBsXi6f69bVjXGvZTRwdlO3W9gG13mZn5FJ3OJiMjM1Sr8xSLM2SzE9RqV8lkJm67Hf5BiQ9sQj5IXjORpkvmy5bViGkAXn8OMxg7O/Osr79ENjuFIEh0OtfpdnfI5U6Sz5+gUJghlSrEPqg9NC2HIEiMjd1Fr1eLAWMqqVSBev0q+fw0Dz/8FvBVbt78HPfc8yZ33/1dcrkJer02S0vt/nvPz3+WJ5/8Z/F8Webv/T2B6el/SiJBCIcjmo8Tw/rJiVHDQW3id69xfLz4ZVTa7yQOkvU8LCn7/v7HjhPDtKgownh8cTiKfXg/6/WzR4Loktn11NSL/OQn/4itrQ8zjLK/Ff3tsPNxu2Gau7PniKPssVslR+G6BtAlWjykcZyAnZ1G/zxPTFTitnWAJGmxkUVEf0qnx8hmK0xM3I9pNqjVHFy3h6rmMc0Ga2svYRg1yuUeghCNpQRBQtdLdLsbqKqGpl0kDD2q1Suoao58fpJc7iS23WJj4zJBECAIuzzoIBDwPI9K5V5ct0cuN4Us66RSWSLP4wySpOG6Vqw2VomVxxIEdzPGnUSt6l5vC9/3sKwmOztvYtsdbLvJmTOPks2O9TnIlcpFWq0V6vXrfTYIgG1HwimiGKGrk+2OjJzpJ+jEyS6xnx3Wtx6mjhrGDkHgxQJLHtPTH8WyWuRy07HD1SL5/Akcx6DVuo4oikxP338sne0PWnxgE/JhLZOkco5WlKW+E0vy3MHWta6XCENwnA7T0x+NIf8ilcqFWFS+gCAImGYXQRBYX38ZURQRxRSdziqW1SSdrqDrJQRB5ObNnxCGEpcufZ+HHrpMPn+aMDxNuTxHs/nnCIJwqETjm2/exfR00heUAe9AAZDBSCgxwL4b7vBrE/ehg6hSg0jsoyrmwVZmEsdNsu9XpX2rfTlKq3r4Ne9ktpw8PkhpGkS9J0lZUQyefvoPUZTegaIjw85Xk5Mvkc0ejnhN2uN76VbRhzVMfxtMwPDeLMwMY7e9LQhRco6S8vCKxhv42aLdjlrrggC2DaurO8zNfQhJsrHtNtEMOkAQVGy7hWGkaDZXcZwGghBRyUyzim23cZwOYegRhg5ray/hODaZzCiGsU2vVyMIHDzPIwgCZFnHdXvU6zcoFM6wvf0Wnc46QeAyMnKBkZELNBpX6XRWyWanqNcXKJfvJpMZpd3eoNvdQlEysfBH0K9UAdbXf8HCwnfIZMpMTl7qm07oegnTrBMEAaqao1Q6T7e7STpdptm8ydmzn8Mwavi+Q7e7Tbe7jiyn8TwD226j66W++xNAvb6IYUQ2kWEokEoV2Nh4FV0voWk5UqkShcKJfeO6KKLRSVKkREjvH5HLnSCXmwQiZkm3u43r9mg0likWT5DJTJLJHE6v+6DHBzYhHxaDlfOgwUTiTzpsb6YoaXq9bVqtFUZHz1IqzfRnxon2rCynaDSWyWYnsO0Oplknmz1Ju72OZV0jk6lQrS7Q6dRQVRHPC+OVbwddLyMIAbKcYmnpSzz55L84EGR16tR3B47i1q5Nu3KXUQy3QW+Fhh5O2IpiHGkRCFEyPgr9vHsTfn/jdma876brMPyeB1G6khjWkI5i14gimQsPi44c5BAlCD7r6w8Bwb7EurT02X5SP336h8zOfrMvv7kL8tpLfxv8nC9c+OZ7cj4gqo4HZ8+3jgBR3F3oqWqkLBYJe+QJQ4eowpbwfQ/TjJJqvb6ILOtEmtQnkWWdXK5IsfgQkqRy9er3MIwumpahWJwln59B1yu4rhmr8JkIghTr0ZvU61fJZiv0etvxjLmF543GAKvIkW1s7B5838cwqrGGgYTjRLKfmpYZGGc1qFYXuHnzJzE9U2F09Ayt1ird7ha53BSdzgaZzCialmFm5pPU69fxfYe1tV+g60Vsu4PvO6RSBfL5aRqNm8hyCtNsUKnM9VHcUSWu4/sukqQgCFI87w/je0+JVmu1/1kMjvYi3nSh37qOONBBPBoYpduN5IOz2QgjE4YRGn18/J64fX1nfnxQ3EnIQ3GY9ygMw/o9Go1ler1NOp0NTLMez6dKtNuraFqEpIvQjC/FF+O9GEadTmcFx2kjCAGGsUO3u47r2oCJ68p4nonnydh2B1lex/PO0+ttc+PG39hz87tw4WnK5RVOnvzuULL9wp4K5iAgUCQUslcjefhmetRcdjhhH5Wobsd84N/3uFXX4XbiqCr/IDW1g871QaIjB+1nFNFn/corEXp7EIGdeCk/8sjXYvnNXVpUQrlKBGYGP+eouoqq+HdzPgaBX75/0LWgcpC2uiBESVgUd18vyyK23cV1bURRi5OOTaQ90ALCWG5TIwxXyGQqaFoG2MF1DQxjHVEMyGTGcN0u29uXyedPxOjqGrbdIwwTlsMYoqjg+yH5/CSe58TJp0kmM44kqZw//2uoapZ2ez12b0oTBJBOF2g2V5AkKaYwFhDFyPJR14v4votpNtjY6NDrbaHrZUZGZslmy2SzE8hyinQ6EitZW3sRUZSQJI2TJ++h292i19uh2VxlZ+dNRkfvIpfzWVl5Hl0vRleDKNNq3cQ0W4yMnKFcnhtgm+wgCFK/qBgEtiYWkJEBTnTOEwGQ0dHZ+DO0CcPo8UZjGdOsIQgSmUyZXG7yA4Wwvp24c1aGIgi8PWT2YTuzqFLexDQblEoznD79aQxjB9d1MIwdJEmh3d6IW1x+7A4T+b1Wq0t0OusYxg6KkiUIPHzfJQgCwCObPYGmpbHtiE9sWc3+F6TXq3P69A8Iw7/TvyE++OC/4kMfeg7bruP70U1xfv4LeyqYKKIK6u67/5h8fj3mEf9w4O8A4m3fTIcT9nuVqAbjsOr13bar3wnyGd4bHvXtvNfwAimJ3c8uuiMm5zw5rpmZXZ7z6uon2dj4eP+1YTiMEUhm0xGHe/D41tY+1kdjP/vsH/DII1/bM5MeG3sjtpE8PI7jfR3xhm81cx80PomOPZMJ6XSihOy6UCplUJQINe44DpKURpIkNC1So0qnVSKmZyQ7K0lRS8a2O/R6OwRBgKYVyWSyqGqaXm8rnvFeRZaV2ISmSBA4BEFAu70ef//buK6DoqRR1TSKkokX99MIgsTIyCzT0w9Sq13FMLYwjBaKUiCfn8Sy2rhuVBlHCVlnauohJEnGspqkUqMoSoYgcFEUhWbzBhMT9xEEfp+uNDn5QPzaDDdu/BRJktnaepOdnbdwnBZTUx/BNJsEgUMYFvcAUg2jSi43HvtGp/rt6eT/bDYVy3JGc+OkIta03J7nJ6wUz7O4evUHMU0NMpkyuj6KrpcQxf0U0juxG3cS8lAYRi0GRoSMjJxHEOS+/VmlMhdfyG+hKDqNxjKVyhy1WpQ0i8UTmGYTWa7ieS6W1aZYPEE+f4Ig8Lh+/UfxylNke/s1bLsTf0HAcUxs20IUp5EkFcuqxq2xXGy2LnLXXd/md3/3b3H9+sPMzPyYu+/+KUGgEMkq5giC7j4wVhSRHOGVK7/DYHtz1xeZ26JEHRTvJFENA6GOM4M9LBHfDuDrVsn4sEp9MNkdz/Xo1vFOgGpzc09x4cI3YwWuSLnq4sVv7dunhDq1K8UZdUQStH2U1Hcr5CSpDy4Ehivi4YR9qxb+cbyvk5CkoxJy0n4eDBEQyeUiOo+uZ2JQlEMQhLHUZQbbbmGa20hS5NJWLs/GKlbLgEipdAZZ1qnXF+NKtYQkybTbGyhKGk3LoigahhFJZMpymmx2hq2t1wmCAMtqIYoKjtNA10eZmHgA02xgWXW63ZvUannK5QvxAtyKAZ2r7Oy8jiD4qGoGz3Pp9TaRpBQwytTUA6yvv4xhbJFKjXLy5Ccol2dZW3uZev06v/jFHzE5eT+6XsK222hankymwsLCd9nYeAlJUjHNOiBTLJ4jl5vEcSILV10vUast4bpdut1tBAFarXV6vSrF4mnK5YuHVLDRF8MwajSb19G0fF/wpN1e63cKwxAURcM0XRQlRSpVjM9Hk2x24k51fETcOTNDEfkMF9D1EtnsONnsOFtbb8Qto2iVHbWkuoiixNLSX+D7Hun0KJXKHOXyxf5sxfN6zM9/k5MnH47bUCV8P0J2+r6D55kIghwjumv4foBtd1EUjSDwSadHKRROxGYVFkHgcfHiN7l48d8AEqI4jSCEKIqMZXUB95BWZTIL3NveHJSpfC/idqlHx6mcjhPvNeBL229UdNvxTirw29nvBx74+oC7lYzv79W5HoxBC8rEe9my6D8mywael+7/bTAOatHfTmfkdmfuSVI+mLc8nK2j32W5jOd1EQQZ02wiCAGl0hlSqRE0Lc21az8BXHy/RafjkM+Pk8+X8H0LQVCRZY1MZpJudxvbruN5JoYRYT9UVWd6+uPk8yfY2bnCzs4bWFaLVmsZQZBRVZVc7hTN5g2iqryDIECpdJpWK8R1LXq9TRYWvoPnudRqV9D1MXzfwDSbaNoV7r//b9NqRWMuQZCQpKiidt0Om5u/wPM6KIqGphU4efJj7OxcodNZQ9MKTE19OBYRSdNqrQA+udwkhcLZ2Dyjw8TEh0iny3uSoe/bVKsLZLPRnFrXc4ShgKblY53tKPkm1exgVet5VoyqLpBOj9Jur3H9+vcBhW53E1XNUiqdjn2oezQa11EUHdc1KZcvHvrZ34k7CXlfWFYLSUpa01HrOkI31vpIR1GU+45P+fwJms2bfZ6y4/RQlBTj4/cyP/9nNBrLNBqrTE5+CEUpks2WEYRTsTB+Btvu4Lp1EsG0MHSxLIPIsUam263Sat3EcayYb1ghCCxct0MQmHieG7eyMrz++q+zvPwZHnnka7huGkUxuHr111hf/ziDHNP3sqX8TuN2Kqf3O95tQn+n7fDBOGqxEmllR0n28uWvsLT0Za5e/ULf8Wk4KQ/ymQe3NSw+ctAxD8uqHmQneVRnRFF6A4pzx7vuDq+Uk0Xl4O8ynmcRXdetOJFLtFo3CAIby1Ipl8/R60VoX9e1abVWcV0Ly2oShiHNZhHLapLLldG0NN1uFd/3EEWJIAhoNJYwzTqWVccw6oShj+c5pFI6hcKpGBQWSVtmMkUkKVLlGxm5l2r1NSI+tNXXs1bVNOXyR3j77W+ys/MaCwt/yczMJ4CQXm8b348c4AQhMrKx7R6+75NKRQnw1KmHWFl5nmLxJNnsRHzPSfeZH0kbeWXleer1JWq1RVqtVSRJ4+zZR6nVlqjVFghDAV0fIZMZIwwDXNdA10vU61cJQ/qCHsmoDojvW1kymbH+LNg0G3heJOaiaVk8z+z/PXGP6vUigOzW1htMTn74TpV8SNw5K0Mx6IEcuSz5aFqeMIwqY1GUKZfn9pDis9lxms1lYBcIlk6PcuLER7ly5Y9pt7ep1xd4++3fZGHhQS5dWmBmZoNWazU2iPCYn/88y8u/zszMs8zN/TvAxTCiG0BE9XDxPJswDBHFSHjfcSwi84KQN974HE8++cf9amRXoSmaMV28+C3Gxt7oJ+oI1MVfWRI8qnL6Zc2NB7dzq6T5ftCqDnNMGuQgDy9Whk09hh2fhm0n9/OZj9aoPiiS9x4GgQ3u22FWm8n8OQwlHnnka4deb8n5iL5nu+di1zf5oDlCSDRTdthN1JFKnesGNBrriGJIOj1OJlMiDEfodjfiDlYVWU6j6yUkSY3tCjOASqUyytbWa4RhSLe7CXjoejem8JgoSpZKZQZNG0VVUzQaV3GcCJUdVY82tt2kVlui3b5JKlUml3uYsbH7cN025fIcmlYilcqys7PIzZs/Ipsdw/cdrl79NqlUiaWl73Lx4hcYG/sQEBAENisrz3Py5ENUKvfgeTZjY/f0uby12hKalouBoNGFWyicxPMMfN9nZ+dKzAa5ie87sVjHKfL5qXix0Safn2R9/ZX4PifRbC73k3vCTfY8B0narY6BGLndRFFSCILcnycPJt0wDNnefi1mrrQ4ffqT+wRH7sSdhLwvEpR1ApaICPLLaFoeSdL6f0tUbCKTiBv4fiTbt7LyfGzt1qLXqxLJ9rV5/fVP88//+f8NCPjOdx7n7/ydVzl79lXAHaoW/wFPPPGl+MZlsbci8PD9Jr4fVQZAXJmH+27Mi4u/sef3Uukajz321WNVpu9VK/moOAyt/E40pY+aRR/2+O1wht/ruNXxDH+WV68e3uZNjCh26W/P7HmftbWDE3ZSNQ9Sni5dOvyzPgwEdvXqo8zMPHXgMR00fz7OeRn8LHY5yUdpb4YH/GwShgq+7+N5FpZFDO4qEn13fFKpUTStQKl0BsOIDBp83yMILCzLwLZbBEEkX+u6Bp5nApDLjRMEIVtbL5PNVmIzhqiyNowtguAVRkfPoKoZInGQiAvtOG1EUaDRuM7YmM7U1CNYVjfGoyzGdCgZ06zT6+1QKJymVDqLquo4jonnOezszMee7Gf6Ury23cEwarRaN8jlJqjXl0ilSgiCgOvasYvVPThOD1UtEAQO5fIsmjaCoqTY2ZlHVXM0m6uYZmQLefbso339662tNzDNSEBEktR45GbT7W5h2x1GR2c5ffpT+6SIE9OLVKpEJlOhXL6b9fWXWVz8Nqqa4eTJh/Z9kgdJGn+QjCl+tY/uXYQoyv3Vp2230PXRvn/yysrzMfF+i1SqwPr6LzDNBpubl8nlJoAp0ulRRkdnKZfnMIw6L7zwHyZbBuD55/9Dzp59EmCPZrQgeLzyyu/FLcDDEmI4YK7wY+6662lOnfouP/vZ3x9IcN9hc/Mj+xLeewnCeTfxXqOV32sHp+O+x2HPezeqYgcl2cP2fXA+fOrUM/uq3+GFz6lTzwxUzbs85sHq+aD32UXl7wWBJQuAg/bvvaKIHU2HG25jJ+GS6FsngC5VzaJpaXzfxjRNgmATSdLY3n4dCPB9n1xuGsfxcJxoJBSGKrKsxi1kkULhBKXSDMvLP6PTWaPXqzI19QCiqKMo0T9N05GkFIIgcurUI3GrvEu3u4Vp1vvqVr5vo+sjCIKIZbWw7Q6qWkAURXq9bRqNa3Q6q0xNfZQLF36Tra030LRcrKAVSfGm0zKSpGDbbcrlWXzfBwx830GS1L55hO/b9HqRy9Tk5IfZ3n6TMAy5evUvEUUR13UZHT2Hbffi301UNcvKynMEgR9reWt9GhREMp71+hKGUeXkyYcIAo92ew3Ps2i1Vpme/gjpdAXH6bK19RqZzFicyLep168yPf3RfQn2IEnjgx77VY07CfkWkVwAg3SoxO3F80yuXn0pvkBDFCWD4/SYnPxwv5V95sxnabVuxG3m3YhAE+I+zegwlPsOS0dVsE8++Y34Of8ZTzzxBHNzf9y34jt16hnOnn2KyckXWVl5lNnZ3YR3q5tklLATq7/jSTS+0zis1TlocP9+xTtJokfZOr6bxH9Qkh2cAw/PfS9deurQNvSwzeP580/xve/94Z5qNwH6JdXzQcl1eJZsWek9C4DFxcdZW9trzTloQXk7i65E6CO5Do42psgQSWkeFImqlxNzm6OK1fMMBMFBlvN0OjfQ9XFsu83Y2ByTkx/BNLfwPJNudwvH6dFsXiMIQjKZCqqaRRBUUqkslqWh6+XYMOYmYRggSWnC0GNz81UEAbLZKcLQRZYLBIFJqTSL70c+zpqWj0WCZjCMLcLQo9G4gm1H89hudz1O3D6ZzDi5XMQ9Hhk5j+/btForNJvLbG1FC4owhJMnP97Xq5YkBUXJkM2O026vUSyeJAwFTLOBKKrcuPETms3reJ6DKIp4nsWJEx9FklR0vdQ3hEi6g5Ik4zg98vnpvhZDKlVCUXRWVp4nDIMY8HYj7gZInDz5ENeuPUO7vYIkaVQqdyFJYuzEtbWHXgUHSxof9NivatxJyLeIBNBQrb6NZbWYmnqAfP4kY2P3cuPGT7GsJqZZZXT0Qgz8ktjefpPIhFxkaek7uK7LRz7yP3P58qdIwFUPPfRNdH2E5eVf30NTKhav02qdHqpgv0tUWUcZYH+V+zBzc3+8R5s4CGB29ikuXHhqj/rVcGW6tvYxnnnmv+b8+W/z2GNfjUE4EU0qkWg8Kn4Z+tJLS/uTz3HpUe9HBTz8noOPvVfnYBBwNUhbGvQqPu57DSfs3Qp8t0IebncfFINUqFOnfrhv/5JF5CCwbGbm9k0/0ulISjNJyEf7KB+WjIfDiWUlPVy3iySp+L6P74uYZpN8vkypdJGpqQ/RbK6Sy51ibe05NjbewrabSJKE4xg0GstYVgNZ1igWzxOGHq3WDVqtdYLAp1CYwrYTtHEB379JKlXA81xUVUcQRHS9iKJkUNU0giDT6SzjOF1c18QwuoBPsXgWSVLJZk9gGDVWV19kevp+XNckk6lQqy2xs/NmvJ1II79YPIVh1LDtJsVipE3tOF02Njb6Fa7rmqyvvxxbPkZ2rbncJEHgkU5XmJj4MGEYkkoVWFv7BdnsBIIAzeYqmUwJVc3heVZsuONRqczFCV4iDEHTIopXp7PJ9PRH2dmZp9m8ju/bjIycQ1WznD79yb6+QsJtTrqRB0kaf5Ccoe4k5GNEKlWIdWsXGRu7m2LxNJ5nkUoVqFTuotFYivmIkQdoGIaUSjPU69dpNlfodFa5995r/N7v/T1WVh7jk5+0eeihAisr5zh79qc8//w/6CfYS5f+VR+MtVvBhkStQgXwmZl5ZqjK/UF/XwerCzi4ukgq0+9///8eg25CNjcfACJ3oF1LPv/Iud8vQ196GIR0EGp48H3ey324VWJ/r+fMxwGXAVy+/Hfjn8T496/cNjBr8HguXXqK9fWvce3ab1AsLpHPr/WT8fe+94eHzpP3uoftfjbDutvvZP+Gz/3RSfidhoVtC3HlmEJR0jjOJrI8iu8HCELUcg0CH8tqxFUmZDIj6HoJXR+h2byBJOlkMqNsbb0V61/7SJKMJKnk8ycRRSmueF1kOUsmM8HZs4/ieQGpVI5eb7uPau71tpDliCsNAkHgMDp6gWy2EpvKNLGsGu32Ko3GApnMFNnsGNnsJKqaZ2LiEpKkYZo1Wq0VFEWnXr9GoXAKUUyxtXWZbneHjY2XqVTm6HQ2se1OrLMvcvLko0iSSjpd6FOTTLPOyspzKIqObffodNZw3S6FwimCwIulOW1su9PXxvY8i0ZjGV0vkkpF/yyrhaLoiKJEKjXWr4KTBNtur2GajT1ezAfFnRnyBzwGrRctq4XnWVSrizFKcZVi8TQLC9/GdXuIosz4+IcwjDq+77K19Rq12jwAqVSOXG6SMIxs2mq1B2i3T5PLtUmltsnlJrnvvp8iSX+bq1c/walTTzM39xTT0z+PQVU/YW7u2+zyLzUgZG7uz3nkkf8H1679dS5c+BGg8PTTf9ifOQ/e3JIb20FArcXF32SQo7y4+Bs8+uh/80tR3Dpu3Ao1fNw4LNEdlrBvldiPm4yPamMfFMMLi8Na08d5r+PG/PzjPPdctOjb2voIv/3bXwTYsxBSlP2jkuHOzNrao1y69FRfdzsKkaWlL/Mnf/Kn3Hff1w89hqP2/ZeDcJeRpCyalkMUFRRFx3HaBEGA67YIggydzhqCICBJaarVt2g2b6IoWWRZYXLyo2haGkEQ6XTWkSSFIDAIQ49C4QSpVJFWaxMIKJfvxrLqFApn6HRWSaUKhKHAXXf9Jr7vcuPGs1SrVxEEEUHwGR29G0kS2di4jK6PMjp6gfPnf53t7fm+GIkoCjhOgG23mJy8j2LxNKbZjiUqQ4rFGWQ5RaezQSQRWieTkchmp7BtE8tqsrHxGqqaidXEcmhaBsOoUixGTkyqmkaWVVZXn0dR0th2G1FUY+R0ilwuEjnK56fZ2ZknDH12duax7Rbd7g623UDTRoi0sFuxTncEmgsCn1ptKVYflJiefpBudzPG4mySz08fmmzvzJA/4JFcABFBHnzfo1w+j6blmJ7+CDs78xhGFdOMNF1d16DdXmFn5y0sq0M6XUGW07zyykO88MJ/wMWLL1MqneEf/+P/PaLo841vSPyDf/BDZmdfRxDgQx96losXv43ntQGRubnvx4k4SZYQVUeRbOD8/Bd59tn/U3xTvAT8g2PMnPcDtc6f/3ZcGUfvc/78d95XaciD4ijU8HHj/URM3ypuJ7kc1h24776vs7T0JZJxx333Hc/X+rBOwrCa2+XLX6FYvH5LZPdh+IO5uaeGTCmiscPS0sG+ze/28zGMqAvk+8f1WZZQlCKqmonnn24spKOgqlkkKQso9Hq1WJhDodFYxrYjTQGAVus609MPYdsdHMcgn1epVO5GltMUi2fi0VUbx7G4evUv4hZsiK6P0O1usbr6UzKZCoZR48aNH2HbDbLZk+h6hVSqSLu9hu875PNTjI3N0Wqt0ettsb39KrKc4cKFL2JZDbLZcaam7o81rn+ObXfI5SaZnHyA06c/1a8ig8CjWn0b1+0xMjLDysoL+H5ArfY2pdI5MpnRPlVpa+tNLKtKLjeNbffIZCYQBIFcboJGI9LaNs0em5svA5DPT6Oqaa5d+wEjI2dig42oLV0q6WxuvsrY2L1916fp6Qfp9XZiA501crlparUlut1tarW3se02qVSk3T3svzw4q74zQ/6AxqCJRAI6CAIPz7OxrBaqmsZ1e0xPRxJ56XSZhYU/i71XfSyryZ/9mcw//+f/CYLg8fTTX+SjH30FUfQJAglR9HjttfOcOtUjkxnHcTrYdg/IIggCsqzheVJfLAQ67MpgEpvKD8pjCvtQ04MV8WHI6sce+yoAi4u/wfnz3+n/flzFrXeLJj4oolbpLgjp0qWnjryBD+/DrUFAe2PwtbdTnR5nX456r+T5g3FYd+BWSOqj4vXX9x/T9PQPCcO9Fe3DD+/VqF5d/ST/8l/+6R5bzoMML55++g+Znv7hvkXDoEPU8LX0bs6zYYDnRc5OcNwFj0DUDnZpNG4gCC6CoKLrRQQhQxD4mOYOQdDDtpuxcxFIkoymVTCMKq2W39cX0LRs3PKNsBY7O5fp9Zp9FT7HMVCUBoXCLLLco92O7B6vXfsBul4gCGx6vTr5/DSaVsDzfHzfIcKQnGNp6XuIokKvt4ZtG+TzZ9A0Hd83sO0mrmvGFokjyHIkB6ooeh9ImslU2N5+A8Nokk6XCMMQQaBPw9S0PEEQsLn5Oul0KZb+FMnnTzAz8wjLyz+hXD5PrXadTmcF349ayq5rYZq1OJluYRibqGoGXR9FEATC0KPdXkfX8yQudxGwbZJcbpJ6/SqalkdV83S7W/i+jSSlMIw6V69+v49mn5z8cL9LmfjSJ457v+rxq3+E7yASINfghWBZLSyrgWlGhuepVAFVzZLJjDM6Okuns861a88giiKSlOLNN+/q39xEMQKSJMk4CGSmpr6NbbfJZsd59dWHWFj4GOfO/RRBELl27VOcPfsz7r77L7Htzr79261Udh15IEJo1+vn+rPhpCIeNgQYbEM/9thX+4n4ncQvQzzj0qWnjuTE3mofjuNDPPy84ep0uLI7Ktm+U+3s4WRyVHdgWFXrOHFYxX3+/N6KVhA8PC+9R/lrY+PjbGxEtpyDc/xksXbQPPm3f/uL/Oxn/5CNjYc4TJlrfv7WGIGjzqcoghzftSRp+K8CEfZheCbp4bpVXFeLnZZ8VFXF8yw8z0YQRIIgRFGylErn6PWaCIJLoXCGfL6MIIgYxnZsAgOqqtNsXkVR0ihKHkGILBR9X8X3A3Rd4cSJh8jnT3Lt2vfp9aqxLKbfN68QxTV6vRojI3djmhu026t4nsPS0ncAyGbHUJQ0hULkMlWvX8fzDDRtNK5cl/F9C9uOBD1c1+xbKvZ6O5hmkzD0CcOwP1/2PIPx8Y+gqhleffV/ptvdpFg8yYkTnySbHSWTGeWVV/4XVFXHthu02+u022uk0yNMT3+kzyceHZ2lUDiBaTaYmLhEPj/N/LzP6urzhCGk0yNYViOusqf6BU06XUbTomTd6awBkM+fwPMsVDUHeCiK3qd3OU4nrowrH4jqGO4k5H4MAwcGq+R2e40wjJCPlcpcvGprxn6hKwSBh+P0kCQJVS1QLp/n0qWrPPdclASDQOaee/4p9977z7h583OcPv0Ms7N/iigW+PnPH+Rf/It/hiB4PPfc/xGIPI5/+tO/zxNPfJm5uW8O7GUyQ44qlWee+Udsbn6Y6CYUVSaLi1+INY79fhIeNgT490Wi8v2Oo270w9XpQZXdQUn5ncyZD9u3d1MJHxRHzeOTija5TmQ5QtO326cYtuUcfF2yiBimxyX7vLHxEEcpcw13a27efPS2Fl+Dnsn76XEpIiaCSPSdENi1bAwBF8ex4ja0giAQc4fTWFYDRdEQRYVcbgzTbOF5XWT5DOm0ExtDRApWoFAsnmZ09G5SqRSdzhaW1WR7+w2CoEcYiqRSUeKJHI9CRkbOoGllms2lWMbTodlcwzD+LbZtoSh50ukUYRjSbq8hijKyrKHrkdPT1tYVfL9HKjXCz3/eolCYRpI0ZDlNGIZIksz16z8mDL1YzMTDMBp0Oiu4bqQ6GFXXDoIQ3d90fYzZ2c8RhgGNxjLz839KGIZMTn6cycmzse2sxMTEPej6CKurP8ey2mQyFWy7Q7l8nlSqiCynKJVOU6st4PsWlcocYejv0W6IlMSy1OvL+L5LJlPBsrqUSqfI5aZZWXmRmZlPYdsdtrdfY2zsQxQKJz8QQK7B+OAc6S3CMGp0uxv0ejv7rBZ7vSqiKPX9Qmu1JXS9iOMkaj4+oqiRz08jSTrl8hy/9VsLwH/Om2/exenTz3Lp0vcQBIFPfvJt2u1tLCtFKlXi6tWPDbWfGUgKn2Fu7jtEK/4IbOL7UYU+KGe4+3p/4H9pT0V8qzb0+6HO9V5GkvwOSrIHtbE17ehjHK5ODwKz/bKS8eD2hrsDx93uQYuFW1XcDz/8NZ57LpK2jP6PvI93kzGASKNxbp9xxTA9TpaNfWjrra179+3n8Bz63Lln9j3nqND1o8YkZvx/ZK+4PxQymTKiGMSgplzMKwZdH8XzerGcbQ/TbGIYW4CAICh9sxfH6TAyMsXIyEVct4lluahqBlFUCEMBQUgRBCbr66+gaVnCEDKZMWQ5R6ezRqNxnV6vjqpmcN02nU4Xz3PQtDyl0llct00+P0U2O0mhcCpuTefxfYtut0e7fQPXNTDNbSYn7yebHUPXS7Tbm+zsvBlX4FmCIMBxukBIJjPJqVOfZmfnLcLQodtdR9NGOHfuMTQtS622yNbWL5CkNOl0mYmJe8hmx2g2LbLZMt3uNs3mKrXaAu32akyVmo7lQnN0ux62HQHMXNfAdbuMjV3qJ1LDqOE4bVZXX+g7P4miRre7TqeziuuauK6BKEqcPftZZDmDYdQZH7/3A5WM4U5C7kc6PdoXQk9mMcljul7sy2ZGxt/b6PoIlcocul5iZ+cKoihw772/i2HUmJv7La5d+xG/9mvf4eMf/1eIoorv3xNTIxRsu4vjNHFdi3PnXuTHP/69gRsZ/Z/PnHklTsJdItnM3r6kElW+j6EoBs8++3/pvzYxmDhORfx+qHO9m1nzUe3iw2aIw48NH+NwqzSpTtfW9ncRXPdgs4Nftt71ceOwfbhVxe26mQMWg5EKV7F4HV2vsr7+EEtLv8XS0pd4+OGv8ZnPfLX/2kF6nOel+wuAKEQWFr7M/Pzj+zyd32235p2fcz9mT5Tw/Tam2SKTGUWW1biNuo0ohvFs2I9HVR1UVQMEstkKMEY6XaHRuE6rdZ1eL+Ibh2EQmyqMYhg7VKtvAhrpdJl0uowghDhOK56tKqRSGYLARhRHCMMaYQiWVY95xRny+ZP0etuYZi3WsxapVO5BUTS63SqCINDr1clmy0iSiihKqGpENxIEgW53BVGUURSNsbE5ut31mFoFvu/jum0WF/+cTGacXm+LMBTI5ycYH5+j19tBFFVmZj7NwsJ3qVavIIoSghCSShXRtBxra69gWVVWV18kn59EktJ9kGuttozjWOTzk2xtvYEsKywufg/P6zIx8VHGx+/Dcbrs7LxBp7OB61qoqo5pNqnV3iaVisx8Fha+zYULv/mB0ry+k5DZbVcnsnDJvGLQdHuwdSKKEplMBVlO9d1YTLNGLjdNLjdOr1elUrmIadZjG7gitdpVfN9EVXO029sx0rPJ3NxT/O7v1rl+/eMD8paRJOZ9971AKjUZS+WJzM9/kSef/Df9pHLhwjd54IGv8/nP/xckN8ZhgNZx4nYt8m433guu8GG84+PG8DFevvyVfcCi8+f3z67fTxOK4yxabve9jpo9D1fQQB+XMDr6ZvysJOmGPPfcHyDLEe7goEp3bu4pXn9916d58FoaPLbbtel8byLy1IzMWUQkScKy6nQ6BiDheR6e1wEUdL2AIGgoik4qVQQkNE0nlSqTTpdi+k4d227huh6WtYYkKXieg65HGtKRCYOArhfRtAzZ7ESsEy3HVogVXNeOnZpKBIEBiHFylWM3pgBNy9PtbtBsLuE4baanP0YmM0G9Pk+zeQ3D2KJWW0KSUvh+VGVGAK0Zms3r7Oy8ja6PsLHxOp3OKpXKXahqGt93cJwuljUPRCpdxeJpbt58HstqMTPzGdLp0f49KzL5iKQvb978Ga3WGq3WdRQlzfXrPVKpUuyEpyDLCqa5w+bmK1hWF9uu4jgGmlagUrnQd8KrVO6NZ98RGv3mzWcwzRp33fUlXLeL77vUakuMj+/vtPyqxp2EzNE8t2GVmMGfI6DCKFNT91Or5cnnI09VVU1Tq10FBNLpcTQtg6atI8sjKEoOXc8TtQUNTNPg4sV/x8WL/4b5+d/qV7933fU9wrCI47RIQCrLy5/Yc/NcWIhkN594IuKRJkCuzc2PMD394rFvesM3V0Ux9vCafxlxu3zddxvDx7i09OV9wKJ3YzhxXJGPw+KgRcvtxu3uQ1JBJ0CuZNQBcPXqbw0ABne56s8++wf9a+ugSnfYp3lm5plfioDM8UOLBS8sEieoaPaqoesVHKcHgKKI+L5KKpUjkxlD07IYRh3T3CGVGsG2HTY3XyafH0MUI+k7XS+jqjl836LXaxGGFpbVJpUaQVEiFa4gcOO58Aq6XiYMHTqdNRyng+t2CEMRSRLw/RDDaMZa+AKt1kpMgzpBPn8Ky+ogCCqZzCiSlKbbzRME0ecSgcQUUqkJarVrKIrOyMg5PM9lZ+cKN278lG53oy8HKkkqYRh5RitKhl5vMy42QtLpMr5v4XkmQeAhy2ny+ZMUiyfY2Hiden0Jz3Op1yP7RlH08Dwvdq0jnl1HncZ0ehzfN2Lw6ySzs3+NbHaMlZUXMIwaa2vP4zgGoqjgeRuxScY2giAwO/vrNBrLlEoztNsRACwx0/hVjl/toztmJJaJEYjh8AgCj0bjGvPzkSjIvff+Tcrli6hqljD0eeutf8f4+H3cvPk8W1uXEQQVVdUYGTlLpXIRw2hRLp9jbGyOp5/+P9NqLcRbdnn77b+5p/r9j//jv8Ndd30Py3KJ7Bkfp14/O9Be3EstiWZd76zKHdYpHkRov18+xce9Sb/TxDd4jPX6ORYXv7AP7OS6oCi33tZ7vW/vJW/6OIuKwf08SGkL6M+HE8rQ7s+7+uYHVboHJeq/Ol64SCYzGYt/OAiChKpmCIKAQmEKCDGMFq7bRpazQEgQuHHHLKrqwhCCwCcIoNdbRRBEVDVHr1dFECLrwULhDKZZo9lcRhBkLKuOqiagrhqe10PTCmhajnR6km53hTCU0PVxXLcT+6K3UdUs6fQIgqDQ620TBDZh6NBsXkMUJXzfotFYQ5ZVRDFFpTIeMzeiz8ayOoyMnMa2LcLQI5XKxMpbKziOTS5XQZJS8XumMc0OoijxwANfoV6/Trk8SxjC1tZbTE7eQzo9ws7OFcJQZHX154iiRqVyno2NVxFFBcuqx5rXDRzHI5udoNPZiimiDkHgI8t6XF2X8TyX7e232Nm5giCIhCG0WjeQpDSR+1aeXO4UW1uvxZ2JyDFqY+NlgiCgXL74Kz9X/tU9stsIy4pmH5bVIps9PCt0u1u89tr/yrVr38f3PVQ1F3+JRrGsdoy0fIteL/IOzWTKjIycRxBAFFUURcWy2giCyujoOVqtVcBAFHOsrOy1S1xaepDZ2W/w1luf5+WX/06/6gCYmnqR9fWH9gGQ3o3CVnJzffrpP3zHif2weLfV40Hbg91tHnc+PUjZGaziErCT77+7hHy7x/hOqsSjwGyHvcet9mt39juIroZElGZk5G3q9Ysk7etbXVt/NS3pgyOquPRYKjNLEDiEoU+1uogoKhjGDqo6hqJIMXUpBMJY59omlSoBAaIIIyNnmJp6iCAwcd0esqyQzU4iSWJsaXiRZvM6zeYaQWDFs+gAXb9AGAqkUpGhgqrmSKdzjIxcoFp9i0ZjmSBwkOUUqVQF1+3GFKFzjI9/iGLxJNXq23hetO/N5lUymXFMs0uzea0v5Qvg+waynGZ9/TKt1jUsq06jsYIsayiKimn+glxuGtft0WptUquJaFqB06c/RadTp1p9HcOoo2k6nc4W2ewYGxtvUK8vkclUOHny4/h+QKezTqFwkmx2Cs9zsO06rmvHcqMymcwolco9mGYDw6iiKCl832F19RdUq5cpFmfpdrcRBAlRFOh2d5ie/hi6PoLnuWxuvh6zViLOdKezhq6X+vieX9W4k5C5PTeRkZFZ6vUb/OxnF/nBDx7hscfq/M7vQLF4gnb7JqXSWSRJpl5/G9OU2dm5jGXVmJkpYttter0q3e4OkqTEtmghqprl3nvf5Cc/kfs85dOnf8Rbbz3Gk09+g2H09alTP+PTn/4n+9qFUWXy68zM/MU+S8WkFQ4ciaZ+J5Z5yQ1/10x+f7xf/sO3qrRd92AHpINefzsLifcjGR/nvY8CuFnW8UQ5SqW3aTQuDry+wYUL3wRCxsffYHn5s6ytfQzXzRxrrPFOBWTevehMQBgahKGBIFSQZRFJKmDbBp4XYppbgBH7+44BLqqaJZ8/SRCYNJsAAoZRRZYzFItFRkbOsLX1GqIoksudIJ2epNW6GstspmLGRYhtR61YTSvSaq2Qy1WoVqOWtm23CUMRQbiGKIpxFemTyZSwrAaua8T2jy5BYMdymBFnNww9NK1EuXwXi4t/ES84JNLpMpXK3eTz41SrS9TrS4RhSKFwEllOo2l5FCVHu30N2+7geSa6nkVVM4DM1avfj2fVy6hqBAwrFs8gyymy2Qna7VV6vW2uXfs+29tvEIaQz0+QzY6hqilarS6K0iAMA7LZCpXKJTStGAPIunGnwaVafZNWa5UgEPA8E8+zefXVh3njjf8d999/k9/9XR/L6pLJRHrd4+P3srMzj+c5dLs7uG6vL9j0qxi/mkd1m5HMiROLxYO4b4kA+vT0x/j+98f5wz/8dUTR54//WML3X+Yzn4laXO32OmtrLxEEfsz76yBJKo3GClNTH6ZWW6DTWScMA2RZx/d7yHKau+/+Hr/3e3+fmzc/zZkzP+XEiT/n6af/yZ6ZceKZfBiNaW7uz5ib+3MGKR/D6GLgyHb07aJgTXOXCxp1Gd5Z6/mXPVMcfC/fP77QRrJfSTv7/Z59HxbJeb6d+exhQiHDfOXR0bfihBxVzIPdmIWFLzPoiXyUXOvgwu92z9PwcRnGuzOcCAKLMMzieXYMwPLQNA3btoAgRj8LOI6H674GBHhe1PYFhSBwCAKXhYWncBwTVdVj+8RNTLOF71tIkhrLaHZwXSOmg4lASLu9jiyr+L6HokRUq8ifuIgoCnEbvI4sR1xo06wDAmtrL1IszsYt6JG4sr1Bs3kVx+khCGDbDVKpErncWJ+DXCyeo91exrZtNM1FltMYxg7d7jaOYxKGCrlciULhbMyxdkilypTLGppWRBBkqtU3KZfvQVVTCEJ0DK7biUU9ZNLpEYIg6KOgE2WwbPYEsqxjmjUi4w0Vx+lRrUZANUGQUdU03a7PK688xNe//v9EFD1+8hOZycl/y4MP/oL19Z+TyZTj+XMF0/xx3/L2woXf6LtD/arFBz4hDwqCRFzkTXq9HUZHZzGMGhCBCQyjRru9wvXrz/LDH17qV7Ki6POXf2kwPv5nWFaEomy1Im/UcvkuwjDyFO31Nllff5Veb5tOZxVIBA48DGMdx8ly771P86EPPUurtQxY+6rVixe/xf33/9ERSVImMmbfjWHdYhjkOR/cjr6dluO78S1+v5LZe1GNJ63sfx9oTnCQStWt4zChkGG09X33/RH33fdHrK09ys2bn2R9/cE910+Cuk647sPX0VEUs1/G+Us+38O1rUXC0I0RzTkEQUSWBXy/EH+Pe4AXS3Iq2HaPMPSQJBVBSCGKFpnMBL3eZuwdrOC6KmF4DUVJk8zXw5B4FpxCUXR83yWdLpNKleh0tuPnhciyCkhYVotq9SqpVAZBELCsBpIkkctNkUrlsW2bXm8Hw6iTShXJZidIpYp4noHjdBEEiXL5LiwrqkxXV1/CcTp4nhF34jbo9bYQBAlFydHtbuI4Bo5jAD71epV2e53R0TNMTj6IquoYRkgmM8bOzhVkWaNavcLIyF2EoYgsS+Ry57HtLr4fFS8jI+cpFM7SbN5AVXMoSgrPc7hx4xkcx0LX86RSowSBhSyX0bRCPDJYwrbbvP32R/bcSy9fPs2nP73CyMgpCoWTeJ4VewqoBEFELdvYeI0g8I40pPjfavxqHc07iEGEdcI79n07Ntz2YxpBpGyzvPxj6vW3mZ3tEQSf72tTz81dZnPzF7iuxczMp5EkhUJhhmJxhlrtCkEgsL7+CyqVe2m1btLtbmBZDVKpUS5ffoQbNx7l3LnnSaWyzM9/lKmpf9tPik888eW4Wv3BMZKku++R4aQOuzzn98LJaVgt6XZ0pH9Z8W4Vs97p695P8NI7mXUfJhRyVAv/+ef/q4EtJPPl3Qr5oOvoIDWug3ytkzjOORfFgx+3rCgRCwJx1XlQUg6IrBfd2NtYj6u0FKKYIggcBEEllcpTKETApEhhKzpGWdYJAotcbgrLapLLTdFqXaPbXSeVKsdI4HVsew1JEuj1av15r+97SJKCIAToejQSM4xqbNhQixHNERI8CEIEQaZQOE06Pcr29gKm2cDzrFiH+xp33fUlarUlRFEhmx1DllPxLHwb1+313ZUUJUuns0YYRtaIoqgiigKKkotb4TpB0MNxLBzHjEWO6phmjXb7JqqaQZIkDKOG67Zx3Q75/CkymSlSqQLN5lVUtUQkWATF4gyiKOI4BtXqm9Rqi2haKR4BRDaSjcY1SqWziGKIZdVwnJATJ75PEPy9flI+ceK72LaP6zqsrb3Ezs7bmGadXm8TSdJoNK7jOD2CwESWU/1C6ldF0UsIw1vfQtvtNoVCgVarRT6ffz/2632LYcnMIPDY2ZnH920EIeIbJ3D7Wm2BV1/9F7iuw2uvfZq33rrEF75Q5sKFb/LGG39Cp7PO2bO/RrF4ElXNxm4mC9h2A0XJoCg5fN+g2Vyj1Vrn8uWH+PrX/xmDmtTJjSxqAz49sKeDyTbF/PwXWF7+1LESddQ+fHSI5/zeSWi+n63no9773cZRc+6jVLlulyP9bhW+joukPuhvi4uPH1ua80/+5E9jw4goRkbeplyep9sdBwRyuY1+x2bQxAJ2rRzDUD5Qr/pWxzS874ddV8lzEh/ww5+rsOuYJgIqoqjFi8mQbHYCUZSQ5TS9Xh3LqhK5NZXJ58eR5Ry23UAUQVEyuK4NBH2wkmW1CMOQVKqArk/Qal0nCAJyufHYvKIaI4dFHKeNquZRVZ16fRlRFDDNLkFgkE6PUyicpNVawTAaeF400pIkkZGR84yP3we45HKnKJVOY1ltTLOOZUVt82JxBklS6Xa3MM0anc4aQeCRy02hKFmq1bfodDZjbnFIEBioajGmSUWKWZ5nIQhw8uRnuHHjh9h2M6Y4CeRyM+h6lmx2mq2tV2NAmUMud5Jud5NabZ56fRnD2CSbnWRu7rcYGTnPwsKf0WgsMzp6kcnJB7l69Wm63XWazRXm5/8aN2/+Gvfeu8ijj64yMfERJEnG83ro+hjt9jJAXJHPMjo6x6lTD5HPT/cLqnS68u812Ou4OfR/+0uKdxkHzY8HxUCCwGNr6w10vYQkaUxMfJggCLjvvpNUKhNE7k9fIggENjZeJJ2ukM+fwjR3qFavYBh1dL1IsXiWbLbM9es/olg8yfb2a8zP3zeQjJO212A7+adE2rwe0UeloOuluCX4P8Ytwf/iltSk4Rb0e42A/ats4x7H2/idxGGz2YO2/Vdt93jYLPmgeCcmFUnU6xep12dJKsf1dYn77/8jXn99/2z6vdDkPu515fu7LfzgIMVMALS4GvbZpXCJ+H4PSUoTBC4Q4jhtZDkCUBnGTiyrWYqrZhPX7QAiqqpTKJzAtnsIgoCuV7DtLoKgkMmUCEOXVusGgiCiaSphWEBRUvR6dcKQWGYyUv/qdrcQRYEwVHCcLo3GVWy7ieNYiKKMIAQIgoYghLFaYOSyNDn5YRr/f/b+PEyO+7zvRT+1dvU6OwYYbIN9AAIECW4gJa6QJcoSJdlybEaKN0l2nOQ6juOb5OZe6ziOmcTxeaLkxCdOjmPTdqLIVGRFoigukrhA3EBSJEEQXAYzA2CwzGD23rv2qvtHVfU2PSsAAlD0Pg+ewUx3VVfX8nu37/v9Zk9jGLmwlF1ibq4V9RAAAQAASURBVG6EdHp9KCupIAgStm2QyfQDEI/3IAiwbt0BdD1PsXgBWY6Hjm0yBHxZSFIMTXuXbHYUwyjS1raejo5tCIJELneG2dlTGEaWycl3SaXW4HlgmrN4nkV7ex/gkk73ksudobNzgHfeuY+XXkqze/cge/f+Jfn8BVxXRxTT3HDDa9xxxziZTCeQQZbj2HYRUYyhKBqq2k6pNIZt65TLs9xyy91EEwArAeReC/a/vUOOrJkcJIq2Jiff4eTJpxFFkYGBT7Nx4x3V90T8174PGzfeHNLXaeTzZzGMWTKZjWQyW0L0pcnJk88yPf0uohgM5m/c+AN8/zdo1D2OgFsvATaSJOF5Cr4fgE8EQWVoaP9lZdb639mutHNdjn1QxzhfUrHG2lXfP3acxhn4s2fv4dCh3wGCvjVw0UIZC1kUjHheULKeD/ySCQLaSsiGFXhsQVCRZRnLUojF0qRS64jHMyHjlYnv+8iyhm0bTE+fCFHBZURRClHZZijBGDjMWCyJ59khermdcnkSx6mQy52lo6MfVW0jlVpLV9fekDP7NJ4HjuMgyyptbRtQlCSFwoVwBlkklVoH2IhiHMcpIMtxDCOPaeaYmXk35LAeJ58fI5XqDkvIcsgwlqFUmiWd7iObPUUi0YnvWwgCpNN9ZDKb2by5n/fe+xt830PXp3BdFxBCsFiJqanjmGa+ej6KxXESie6wjG3g+z6OY5PPj7FmzV48zyWZXEOhME5HxxZAxLYNvve9JH/4h19CEBxeeEHm135Np1i8wOjonfT3v8KBAy8hCAErVzBCVaCzczOynMC2TcrlC3ieRTYbMBaOjr7AmjW7gZpUbqk0+WNBHHJtH/0ltFaRVqT2FMwl2phmkc7ObdUyt6om0fVAB/Ub34jz8su72Lv3Xe6+u4IoqqRSazHNMq4bDPcLgoLrWsRinfj+FHv2PMNdd/2fPP/8PyFa7HbteoKbb36EvXtfRBDa8TwLVY2h6wHwpFI5z8aNT+L7f6+uF/wSsHqBiCtZcr6a7Eo44w+697wSq+fCluVKVYiiuX9s28zrTS+E6G5VSr/Ye27x7R0gFE9GJKg4yciygigGjXjP8yiXZ0gmu+np2U02ezpUJ0qEaGkLUZTRtAxRhy+iwHQcE12fplSaxfNcFCUWkmgEJCSmaVMonAc8PE+ns3M7rmvT0TGArs8iCD5jY1PhuJSE55mYZhFBCGafNW0tvm/h+ya6XsBxyqRS63Bdi7m50xQKZ0MazyyxWIKABjSg8g2IT2YJhD6OhbrEfaTTG+ns3MLw8ONVVSvDyJFMrsG2DfL5iXBUKYbnBVl1RPahae1oWgHXncQwKpjmLKqaoVyexvMcTLOEaRbR9RlEUUXTUrz+el8DcOu11x7k2LE7q6C/ePzXuPnmo8HVciwcp4xhFDGMc2QyfWSzo5hmGUVJEoul6e29jni8q9o/npsbBoR5rIrXov3EIYfW6mKWSpOYZoHNm+9ElrWqlFiUTReLF/B9lxde2MJv/daOcAzqBn7/97/KL//yJk6deo6zZ1+mo2NLOEd3nnR6Q5iJB7y1P/uzf8rAwCTvvz/Ahg1Ps3v3UyiKFsqvSdh2EJnXTGFg4Il5o0mrFYgol4NyXwTOuloEExaywcEHGBlZnbj9xdqlUnRa7G+XyjlfLPd3ZPUl7s2bX6uyuc0XLmksUT/9dCPBzNhYo8xiq/Nw+RTHBBQlgW1LIaBLQpa1cLTIx3EChaILF3Sy2TOYZhHDmEOStLB8aoQtqwSyLCFJCSwrRyAoUWFu7hyeZ5BMriEe70aSAhaqAF2cxTRLoXJclmLx5VBHOUEy2c3c3Blsu0ShMEks1hE6P5CkQG3OdSsIgowsJ5FllUplmq6uAK0cAJ2CGWTTzIe95gSGMYdtG+j6HD09u0PRHJ+JiTfRtE42bTrIhQvHmJs7Tak0QSLRRSLRQ1dXoGY3M/M+nifg+xVisQyOU6wyhQUjm044mpXFdcs4jks+fw7ftxFFFfBIpzfjujrJZC+bNz+D591NoActMTa2kagSKIouZ88e4t57zyHLEqqaxjCKlMtvIwgOlqWTy51B09L09Oymr+9mFCVZXasTiS46O3dUk6drfUb52j3yy2hRBhxcXIm2to0Nc2+qmmR6+n1SqTUYRoEf/agXSfJxXQlRdDl6dAM///O5cIxBQNM6mZp6K5xPLKEoSRzHRpJ8MpmtfOhD73HzzS8zM3MSUdQYHPwkw8MH2br1h2zb9iiSJCPLbWH52sW2fQYGGsk/3nzzi0Q3+UrK2FHvTRCuDoQ0LJw91QcdC4nbX432QQc49Z93qQhZakh6oSVP+r59jb3p5chZNhPWXD7FMQvbtgh6xhIg4DgVArnGYMbWcWxc16JcHsM0A8rMZLIHSUoiCC6VSg5RLKGqaTzPxHEMDGOOVGot6XTQf5VllWSyG8PIUyqdRxBUbDuL4zjhKFM6BGmlUJQ4s7PDFArjuG5A65nPn0OSFAKwWBzw0PUytl1ElhO4bjokIEmRTHaF9J0elqXjeRaiqCIIOSYn30KSYihKLOwhlzGMApZVwPd9zp59NSxrd2BZJWy7QjzeRTY7TDzeQ3f3bvL5s6hqJ8XiGQRBoVgcIxZLMzMzgqZlsCwd143aaEEAIstxHMfB98UwoFEAh/7+/8G993bw3HMBG9zMTH/1yniexN69g3ieHwpu2JhmgWJxnDff/BCnT9/F5s0/YO/e5+np0ZHleN22TpW5K0qSrvUs+ScOuYXlcmc4c+aHbNz4Ibq7B6p9iqhM/e6732J8/EekUhvRtCT795/EdW9EkjxcV2Lv3hPMzpbo6dkT0uR1Uip1k8+fQ5aTIVmIj+s6uG6Jvr4PhyxeWd544ya++tU/QxAcXnrpS3z+859jz56nqkw3tl0BTPJ5kOXAiZ4/H1BBRnYxI00XM1d8KWwxootW4zTAksxTyykLX87S8dVUdVgKrbyQnT69sgrMYnKWMH9Wefv2Ry8DLiJBULK2wt8jrWeLYOmLkUh04jjBe3xfwLY9fN8GYpTLs8TjLqZZxrZNYrEkYOP7EqoaJ5lcw8aNB0mn13Hu3Gt4no2uz2JZeujUS4iiGI5AmWzc+IlwegOmpt7Fsgo4jo/vQ6VSQBRlJElD12dwHJP29g10d+8klzsf4lp6KJcn0LQ2dD2Prs+G6G6XVGodqpphbu4k6fS6UO85U9VsFwQPVU0hyyozM++haR0hQ5gHyCFXwiSSNEZ39y7Wrr2OkydfIBZrw7YruK6P5zmkUj0kk2uYnR0Jz2kcTUuH58YnHu8I17I5TDOHaRqoahrHSVfL1jXMjMdNN73Bxz5WwLa3YFkFisVTmGaB11+/hUce+RqC4HDkyG/w4IM/R3v7u7S3b2TbtgCX0DyyWv/zWrWfOOQm8zyH8fGj5HJnyWQ20929qzoKZZp5xsZeY3Z2hImJt0gmz5FM9rJ27VH+2T/bzdDQzRw4MM7Onc9RLm/B9z0SiV5830KWY6RS69H1LJ4nkU5v5NixO3juuQ9z660zDAx8F8cpMTJyS8PCdPLkQXbs+CbBYhKI8pZKteN1HBgebiT/2LnzO9XFbKkyYOSIopL11eI4WlnzTLUsV1r2KVvZlf5ey2H4+qDGplZjIyMrl+hsJWcZWXNFJwCKyZd0Rh6kMGsrUnPKHhAncAoigiBhWSUCZi49rELJ1d+LRR1BkJEkCUXJEI+ncRwTWVbCMvdxHKdCIhEgsSuVbOjkgowx4LG3cV0b37fxfYvx8TcAgba2Tfj++ZAuU8eyCnjeHI5j4jgmoqjQ3r6Rnp4dFIsTFIuTtLWtR5JU4nGZUknDti/gOGYo7xgIWUhSmr17H6RQOI9hFEgme5HlGK5rhv3mAuXyNIoSCD8YxgyJRA++76Kq8XCsyw7Hr04himkqlSy2bZDNnsH3BWKxYGxLFOO8995HGRm5jYGBo9x223HApVyewrIq6HrQD9+69SVeeOFL1amS6OdHP3oE0yyGOJvz6HqOfP40o6O/1nS/3c3dd58lmaxlv/VO+FrPjCP7iUOuM8cxOHfuFVKpHkTxejZuvA2AQmGM8fGjjI+/jiiqSFKC3t7rEUUNWVaRJJnbb3+fT386eABl+SPIsornQTY7gu97GEaFSmUGw8hh2xVOn/4Ef/qn/w5RdHj6aZnPfe4ldu4co7//GV555bfqFqanqS0mgZ08+QBnzwZZ4aZNj7Fp03O88UbNUR048DAwPwtZKKv5IPV8L8YiWs+TJ4Ne5ULMU62Oa6HjiQKW9etX3pO+mD7txWhCX0prFSi0+j6tStCt6DGXugcGBx/gzTe/OK+iE7GDnT17T1Vb+eKthONoND4/LsFMchlwqVTmQvlDEUXRkKQEoqiEzF4VZDmGJMVD+kgH266gqh2IoosoxpiefodyeRIAQZCQJJW2tk0oikaxOIHv2yiKRiLRgywnKJUmEQSZdLqPeLybdetu4cyZFyiV5tA0DcOoIAg5ZDkZEnj4lMvT5PPnQ5UnEMUExeIpOjoCzXXTzCHLCdLpPgqF8+h6gcHBx6oVNd/3saxiiAxPE4/3BGenNIlpzgJiqLR0C5ZVolKZRpIkfN8gk9lAqTRFItEeosIr5POniUYw3377Pv7qr/6fsKInA/+AnTu/Q8Cv3YthzOJ5Jlu2PMKXvpTk9OkPIUklJGkNt99e4tAhF11fx8TEm4iiWJVxnM9S+AaSJFEsjlMsXqiydP04OOF6+4lDrrPZ2REqlVk0rZ2+vpvCksgs09ODTEwcpVKZQVUTZDIbcF0FWU6iaYEUW1fXLrLZQdrbN6OqnciyxtTUuxw5ch2vvNJGf7/D9u3HeP31g5w+fQfZ7HYEISjhCILDqVMH2LnzfyzJJT04+ADf+lbgZN9447f5mZ/5FNu3R9vc10AU0lzivZzjUZdK83apRb15proV89RCx9e8r/qAxfeX15NeCpRV/3nLtUud5S733C/0ua2ccnMJGlr3fBcLfGqOuB6s4LF9+3eq572VLvXqzSfoEzdbsXoMmtaBKMpUKjM4jouiCFWMRywm4rouvu/gusFIUyyWIR4XsCwD3y8gigk0rRNRjCFJIprWQTzeSXf3Tk6ffpZC4QKKEjCDnT37Q1KpXtasuY50eiOVyiy6Pkcmsw7f9+nq2kmxOI5ptuE4JhDIE8pyKiwvm5TLOfL559C0Drq7ZbZuPcTMzPt0dOwgkWinWOwln5+gUpnA9z0C6UmdXO4crhuMUa5ffyuiKGEYOUQxQSLRwdat9zM6+n0MIx8KOEA63U2pNB3OFm9CFGWKxSksy8C2S8TjaU6ePNiwxkQqdfF4hnXrbuDMmVepVAqAw4YNf8bGjX+BqqaRJIW1a69Hkj5Jd/cujhzZzauvdrJr11v09/81u3c/x513/iHDw/ezb9+rHDo0wZo1dyMIIrncGTo6tvzYOWP4iUNusK6u7QCoaoLx8Ter1JmKkmLt2hsoFsdJJtcyOztIsXiOjo5duK4fZsDFUBFlhnXrPKamTnD4cC9//Me/EN6w93Pnne288ML/p668zIIZx/33/07LY2x2sufP38P+/Y+FwhKNzmQ1yk1Xwpod8HIW5MHBgBnq9tsfwnESyyKgaHZUi1E8rsYutxbylR5Pqy9BP/XUVwA3vI/dRYO9KPCpOeLazH3Q0xUYHn7gEjvjxSw6Do1kspNicRLfN3AcB8uSUBSVRCKNJHWj61M4DsRi6TAATyFJMRxnGlFUse0imtYRApIMDCOHaRbC9k8HghDILsZibeTzp6qtsIDm8wKmWSCfH8MwCkxPvweAbVeQZQ3HqSAIPolEG7K8BsPIUyicJ5HoJp1eT2fnTkqlC2Gp2sKySiGCW0PTukJgWjdTU8eJxdJUKhPIcjuVyjTJZA+iCLZtIMsaJ08+Qak0hWEUcBw9BI8GRCcBGMzFdV0cx0ZVtVDmMcnAwDGef/5Xq8/Rxo3PYlk6ihInnx8LgV+RmQR83z6KkqBQuIDnmRw7didf/vImRNHlu9/9GL//+32cO/dyda2cmLiB66/P8olP2CSTa+js3HbN94oXsp845DqTZY3e3r0UCmNoWlsYDXeg61lkWcVxdNLpXrLZYZLJoGSi61Oh4knQYxIEmJg4ztzcMG++eVPDgj88/FMNv+/c+V06Ok4tmnE0W7OT3bbtcPjKfIj0SpWbroQtlVm3clijo/WZ7fKoGVvtb/365/D91hn2UvOyy3GkSwHFLiYzNozVCUwsZ78LWf33V5QyEUkISChKpeG99cFl0C+GmiMOLJmcpFxex8mTn2Bk5NOXGFm9HDPI58dCIKMIyHiej2VVMAwz1Dl2sO0SsViKVKqbYnGSUmkOSfLwPBfP8wAXxzExjGzI52xj2wa2XQACzux0ui9cK1wEQcSySniej+fZCEIgNGEYOeLx9pBkREAUE+E8skgm0xfuX0GWNVQ1zqlTT4Xl6AB05jg6IBKLBRloOr2BYnGMdHojup4jFuuuHqttV9C0LiSpxNTUe1iWiSDYKEqmynmtKGqIThcwTQvbLoTHbGJZBbLZE+zZU+JLX/oNhocP0t//HFu2/E9836RUMiiXc/i+E153lUhcIxgn0wCXs2df5Pvf/yii6OF50ZTKZopFpWGtPHq0j7vueoXt23+Knp4BxsffQNfzbN58B6qa+gDvmctrP3HITRbJLHZ37yKR6GJ6epCZmSEmJ49jmnPk8+cAgXi8Dc/zEEUVWRaZmzvJ5ORbrFlzPYaRDXmtj/DSS79RvbF27HiSiYmak65Xbnrqqa/UZc4eb775hQWVmFbiZJdSbrpUs5+XQ05xIefQDDBabWa7Y8fS5/JiytH2fK2PS2quu/ptlxtQtLLBwQcYHv5pogxXEFxsO9Hwen1w2df3atMeApTt+vWvMTz8iSvKOGfbswhCoAkMJrbtEXwvB8eJuK8hnz+NYWSrohGxWAJNA9c1yGbPAqeq88qxWAfZ7Onq2KRlFdD1QJJRkmTOn38R2zYwzaBHLQgekiSEY4cinueiqm3Yto6uTyFJMXT9bWRZRVGSqGoGyypRLM7gujrt7ZtIJNaEGbaPaRZpa+snlzvJuXM/qs4qBxzabSHj2FpkWcW29ZDzwA3pP7MkEr3IskalMovve/h+IPYgSSqiaIUkJioQR5ZFDhx4nV27nsTzHHQ9SgwsIBb2xQOQW9Srj8fTWJaFaZbIZkfZvPmHeN6eKgp748bvYdsGzzzzYPU53779RwRKWRrZ7CjDw09SKl0gnz/LDTf8HWRZm6dLcC3atXnUl9EqlVkMI4uqpjl37hUcp0I2O8rs7BCpVC/t7dtQ1Tjl8jQTE2/heTZdXXu4cOENisUpyuU5PM/CMLJs2/ZNHnywGFLEBQ5v/frXOHr0C/i+QAAukYF4NfMNTGRo6DMMDj7QtEDFAHNF8oiL2WrJRBayD6qMupBq0UpseDgoeW/fHrQHBgcf4KmnvrJoYLLSjPZiHObF2mLB0cVk5rXyczBCFKFl69shza2AVOpC+ErgwHftepQbbwyAh0NDn77CLRUf368QLYWqGoC6LKuI59X3nx1MM0vwHWQMQyAWqyDLGSzrXDiO6FIuiyEHtYjn2biuQyLRgSTJYe/VQhQdXJcQqe3S1rYRSYpjmrlQ2lGnra0TXR/Bssq47jkkKYksi6hqBs8zmJsbxzAKiCKUy3FMs0CpNEEslkZREoyNvUa5PEexOI6ipHAcB0EQ0PVcKIgRZLmSJBGPt4eON+DMtu0KqVQnllWmUsmFx+ABMQIdd5lEYi2algh7uqNYVj48TzGigMb3BWQ5Qywm43kWtp1HFBPhrHIF141jWWVuvPEIX/6yzCuvtLF584ts3PhtVDXOb/92G++8s5tt215l167v4/sfxrbLdHfvoqNjK4YRHNu5c6+wceNBpqcHKZenSCbX0Nu795p0ytfeEV9mi2aOp6cH0fVZYrF2ZDmJJMkIgkgq1cPatfvI588xMfE2uj7D2NhL9PXdzKlTz4bk8dFckhs6z28xOPhZnnrqKxQKfZw48RnAZWjo0zz44M8xMPAkAwOPsXPnowwNPUCw0LXKGMxL+l0/SNDXQraazLqe0nE14gXNtI533vkQL7zwu4sGJlcrveVy7FLOQTfqa7v09r7FPff8fpUtbnT0XhSl3DDCdODAwxw48HDLSsTV0VLxiJDYllUmkViDLMexrIi7W0AQIj55FUmScF037BWLeJ4Qvs8Dyti2gyBIYbnWwLIU0uk+RNEM+bNN4vE2JClJMtkVjvJ45HInKZWmse0ytl1C09owzSKxWCrs4yqhaEQcUdTQNIFKZTaUTyyRSHTT27ufiYm3yOdH8X0ZRQkYvlzXwnWDDN11A53iIOOMY1kGlcossVgKsBGEJNnsWVQ1TSbTheOUcd1COLYlIAhySNMpUirNhfrKgQCOLCcQRS38WzBmFYxREZIbpfF9PWwNZJHlNHNzQ9xwg0+ptJM33rgR05xjz54fcP31L3DDDS+H/N4VBgcfJ5c7y3XXfZ5MppfOzl0IgoAkKZw79wq2XWZ8/E16e6/HMHJs3HgwLI1fO/YTh9zCdD2LomiYpkxX1zYKhXEcx0JVE5TLE5RKPZhmgfb2TWSzw1hWGUmKk8lspFSaDvciEc0NB1nF39Co7BS8Pjp6BwMD32Rw8IFwO3HRjGHhEnNEor8cEwHvqgF9rcZZXIxqUfO41PDwxxcMTC5mLOrH0ZrvmXpnXN/X37Pn68zNbWfHjier57K/P/gZBTeatnRL5dJbq+ck6m/agBUyPkXPb9Co9/2asIYgJBFFE8MoEYtlEEUR1xXDfQT7UtVUqHUcfKYsB31OyzKRpIBxKpHoRJYVurt3YppFcrlT+H5AFBLpsgtCUN5Pp/tIJLpwHJtc7nTYu7aRJIVicRJB8EinN6Dr0+j6LKapo2kZ4vHucIY4+ExRTIfiFheQ5QS+PxOqXQVVPVlOoOtnUZRkWMqOkUisQRQDoQhNS5BI9FEqnUcUJXy/HJ6nOKDg+zqW5YXnwsVxyjhOwMMQj7dhWWaIUDdR1S4cR0AUJZ55Zi1/8idfRhQdnn/+V/mVX/k1UqmXcF0/5LWeZnDwY4yOfoSPfMTil35JRJYVUqm1lEqTZDLrKRYnEUWZqalBkskONK2ddetuuHy30mWwnzjkJiuVJimXJ/F96OzciixrZDLrWL/+JkCmu3uAfP4cU1ODlEpjbN58F2fPvgz4FIvnqIGravXKxqwiYqkJnPLc3DaeeeYPqhkawI4d3+XAgYfnLVS1cqHXlMnJQAaYW+a31ADjmgB9XQ5rLnk39/ajwGQ1Y1GXyy4lk1jzvqLyfTPbWb3jjGyhe6Y5c37vvV8IEbI3AaDryZb7X23mvnrsQ6ugNZpTVgmeJYFARCIIXANBiqjF5OM4M0SZs2EU0LQktl0ieK6C7UyzQlvbGixLRxB85uaCwF2WAx5tQRDCOWGLqaljKEoa0ywjijJtbeswTZNS6QKuGzCIdXRsRtdncF0P2zaRJBVJ0rDtHPF4G4ZRoFyepFSawPMcFCWG67roegnfd8NMUgICpjBB8LGsOVzXIR4XUBQFy7JDljAH19WxrCLxeCdtbRuJx9MUCpETt8PvEkOWkwQz3Q7g4rqBI45UtYBwNKwdQVAxzUmCwEfBdYto2hoqlVlOnLi5ToAiIEQaGPg2nifhOAaDg5/ikUe+EVaxZHbsOMuHPyzj+5BOB2NjmpZGEGLkcu9x4UKJWKyDnp6BaypL/olDbmGiKNPe3g9AsXiBjo5+dD2Lrs9RqeSQ5VgI8DqD5/loWoLvf7+T99//nXCB+Ha4pyDK7u9/Mcwqogy5FnkPD38i7KO51Qyts/NUy0WmhlYVw98j4JfD8p0xBKXv4IG5VBnKpQJ0NS+0l6NUvG/fYyhKo1NZv/61RZ3MpRiLWq1dDjWk6G+Dg61Vmeqt2XG2umeaM+fa/exWg836/df38Fd6/11q7EPNIsdsh4GFjCgqoVaygCCoBBKGKVRVwzTLSBKYZjTXHNBTWlYZUQwqbYEQRSF0XD6ghDPLCpIk4/sepllhYuIdPM8ilVqHKEro+hiuGzCYyXISXc8yNzeKIIjIciLkP5jEMAwkSSEeb6NcnsO2C8hyBkmSME0Dz6ugqu2kUr2Uy1O4romipMO5YpHJyfdDDekYsZiK66YQhJmQKtPE83wUJUY+P4uu55DlCpqWCWlCHTTNZ2TkZzl58g42bz7Mvn3fDzWjI1PRtHTIFGZTqyIIKEoKXc+SSKxh167XeeaZX0AUXTxPZseO1/G8oDKhaSnGxmpVLFF0OHwYfvZn96KqSbLZURzHwLYrWFaOiYl3MM0CJ08mEQSBDRtuqRKJRHa1AsCuniO5SizS1IwQ1uPjb+A4OuvW3Ui5fIFi8SyOY+C6LoKgEI93cfhwH3/xF78XLhD/kAcf/Bz79v2AWCzo09x442skk3+fwcH9iGIW244xN7e1ijAN5jmlBWeSo5Lg1NTehmO9ON7pKPqPrLGUtxIHG73X9wmp+FbnRBZaaFfjlCUJFGVhysrWgUjjCW12MqsBj11pW+o6LDfoWOp+qM+cFaVSdcK1+7uRf7w+CFipQ7282IeaUwYbz8uQTK7HcQxMcw4QSSQ6EUUwzQKuGy2hDhDMMYuiiucFfWdJknAcGdsuI0kxbLuIIPjougJIJJN9TEy8imEYZDK9JJM9lEoTAGhaOiQM2UwqtQ7DKCJJQrgfHRCQJPC8gMrSth0cx0AQfDStB0HIYhhZXNfBcfQQZKWhqhq+71EqTeH7DoYxjSBIpNPrSaUy5PMOkqTgOAF/9/j4m6Eylottx1DVNPF4O4ZR5p137uWrX/0qAef03yeT+U02bvwfuG4WiKEoaWxbxzDyIWBOY3Dwo4yO3svOnUfZtet/oWltfO5z6+ns/K+89dYGNm16jl27nscw4iEtaB9r166rBnieJ3PffSKa1saFC28xPn6UeLwT8BkYeADLKlEonCOVWk+5PMGpU8+yfftHGwSC6nmwryaCkZ845Dqrj5qAELGYwjBy5HLn6eoaINBGdlHVQNS8rW0Db78tNSwQk5M/zUc+cpZA7aWEJGls3foIGzf+JUF2KjA4+NMNCNM773yoKmkHjTPJEeioVgYP0KoRUnXlJhIsOPXW2hkDVCqthN/nW1AKW+UhsTBf8mq4m123EeW8EM2lpi0cCNQ7mfXrVw4euxTWrNx0MeNKrWw1QcdCAVd9kBNVHJqdcyvK05U61MuDfVgIg1GgXBYRRZtamTob9pQtgmey/lnyw4zLwbLKeJ4RzvI6IUmGgOMIoRKShK5P4fsC8XiKdetuwHF0HMcmnV5DPN6O4xgoSkCLuW7dPiqVKXQ9jyBIZDIbMM1Ay9hxKsTjaVy3REfHZjwv6EODhWXlkWWZZLKT7u7r8DyDcnk2zDZlBCGGIATtNNsuI8sK7e2bWLv2eiYn3yWXO0stUDGr89eO43Ly5IcaruU77+yhr88m6CmLOI5RBbkaRpHBwZ/lkUe+Dni8/LLIL/+yzoc+dBrbLvPxj8Mtt3yLubnTSNJm8vkz/OhH93L8+N/n6NHbEAQP35f4/Odf5MYbJ5ie3s74+FFOnfo+iUQP3d27UNUkmtaFZVXwPAtFaSOTWTvvql6tYhQ/cch1Vh81eZ7D3NwIiUQHrlshkegMB/qLJJM9TE6+BUi899432bJlLc8++7erN+ZNN51jzZr9eJ6FaRZDebNufH8G19Xw/UrLXlyUFc/NbV0QdAQua9fWkK2rs8UHZCOhiYXsYgktImt2tMuR7GvllDQNjh9v3Qdd6pgNY/GMK3Iyrba/nApR9cdX/3mXWlhiuUHHQn3mxfZbf38OD3+cLVueBCCX29qAwl6pQ7302AeFeszHfMvheQqq2gZ4WFaOIKh1m7YLpBMdx0FVYyE5iIkkpfC8ctiXdgCTSiWHqtokEp1Ikk9Pz24MIxv2nCVEMcgAy2UL1zWYmxtC1/PYdgnHCRy7JClha8DFtnU8zwwZxWLkcuOhxCSAi2kWkeUUguACPpnMegqFs3heBlGMAT6VSpaOjn5kOUZ7+xa2bv0p2tq2YppFLlw4DgQiHOXyNKLoAkU2b/4BR478g7qA68nwfUHw8v77H2+Q2HzqqT8Kjyloux09+kU+/vH/Qrk8SbkMExNvkUqtI5Ho4bXX9vPf/tu/Iark+b6IKLrMzc2Ry52hr+8A7e2b6em5jo6ObWQyfeRyoxQKp5mbG6GjYwfp9BrWrr1+nuO9Wnmwf+KQ6ywaeYr+6Xo2pIFLk8n0cfLkc+TzZ1iz5joEQeTMmeeZmzvFwMBb/NIv/SonT97KwMB77N79Lq67k2x2CElKUi5PheWfBLpeDB9MGnqVY2O3NpX5arSazaCji3PGS1ukixxpJNc750oFRLH2vlaOe7kSf82ZVvM403K/4/HjS/dBF7Nmxq6VOIgPUnlpNRzVix3fYuX7ZtBXq/MbVRcWA1cNDj5Qva8jgFcEXty27bvs398avLgUYGvTpscaUNsX12dfisElAHppWhuOY2NZUc84MpGgLwrgIkk+giCQSAQsf2CF/NhlBCFQWBJFAcuqEIjRJBkff4O2tvV0du5ClrNIkoJpFunq2okkxcjlhimXs2QyvShKhmx2JBy7CuaIA0bBWWzbplCYxXUtRDHIwiNVK9vOcebMS8Tj3WQya1HVROjIHQxjFsMwqFQmaW/vx7LyDA5+G9u2cRwTTYtjGEEgEPSWg2s4MPAod975EMPDH29A1INbV3ly6zgW6ttkIAgC6XQvppljZmaEYnES13UwzSLvvntP03ro43kSW7a8xMzMDJXK3WzceCuua7Bp0x0UixO88spuHn/8VgYGjrJ7t87mzR+qMnk19409z6FUmgwJXORqu/JK2k8ccmjRxQKqxCCa1kGlMotpOrz11n8jmz1DqTSGrs/Q0bENTevE9wNGnp07H2PXrseQ5RjFYop8/iyiqITzfza6nkcUA6BEVP5pHhWpB3bV02ouBDq6PCaTSDiUy4HjXUiSsd4ZX0pCkMXGmRYaQVqu6tNin7nSQGAhoNTVNq+8FHXncq7dQue3PhBaCFzViL6OMp1gPx0dp+bJMy4HsGUYtaBwpd9lZSaiKBlcV0RVFQQhkoqMUwNGykASWRZwnCzBnHIc37dwHDkcn1JIJjsxTQ3b1lGUGKKoVZWWFEXFsgoUCgFCWhBEbFsPgVo2vb17sKxuTFMnlVrH5OT7oWRkjO7uPjZsuJdS6Ry+L2IYp5FlCc+zicXSWJaBpqVpb9+AZenMzg6TTsdIJLpx3aCkWypNIEkJZLmIpnVhmiVMs0R3d4KpqeOUy5MIQopYzEeW2ymXzxI4+Qzvv393Q8C1fv1r1etVk9iMRj0Fosw4+v3gwW9hWUVmZ09TLk+FYDcNENi9+12ee06uoq/373+JQ4eeZ9++oyQStzExcZRicZx8/gynTlkcPryB3/qtG5CkDbjujezYcYGDB2vO+MKFt8jlRlm//hba2zdTKk0yNvYanueQTK65KrLmnzhkqBKB+L5LItFNItETXqQuVDXJqVOHKZenqVSmKJez+P4QIGDbOr5v43k2oujhODau64Y3ulbVM52ZOYnv27iuQL0UXPOoSD2wq55WEy4VGlqlWcpxvgWRbzLZ+tVWWfOlsKUIQhYbQboUzF0XM9f8QdoH4fCbP2Oh89vsqN988wvzAqbmfi/UKj81HnYWbNdE+7xYatfVmRfyUUuYZhzPs3EcC1Ek1EyOgmsRx2mcvfV9H0HwkOUYsVgixKLouK5JPN5FZ+cmJiaKeJ5DZ2c/khSjUplmdvYUsqyRSHQxM3OKICN1AQfP8zh//nUqlRyOUyaRSGDbDmNjR6rgLd/3KJfncBwP3y8hijKOU6JSyWHbJTzPxjSLzM0N4ThOCPJKYlnTxOMZAnnYEqqaqmaTplkmlQq4FyqVPEEgEkhUNrd7jh79QpUcpl5is1lQZGDgSW677Zts3/4cZ8+mkCQFURRJJvtoa9uEYcxy++3vcPLkn3P8+C3s3Pk0n/rUf2XTpltZv/4BNK0L161gGEVAIJns4oUXZETRw3VFJMnjyJE0n/988KmVyiy53Ci53Bk0raMK8IrFMsRibaTT666KfvL/lg65uXQRzR7H413VCKlQCMYOBEFAECQKhfMIgkQy2YnjGBQKp5mdHadcHgcERDGI6gLy+BimWcY0dUyzTCyWwTTzSJKGKCYxzaBP3bxY1QO7Wi8+KyH/aGVLOeOlLR4HvY5RcCVZyVJOd7F9LYYGrs9wIy3dpXrKrWyhUZxWTvBKKy9dLmv1XRdiRmt21ENDn5kXMPX3N/Z7gXmVnuZKETBvn83Z8uUICltbwG0dzN4CJBBFCVGUQoYukeC5Eqr/AgKOGKqaRJI0BMHFde0wi5apVMaQ5Rgg4fsekpSgu3sn587NoCgJOju3oSgxHMegUpmjUpnG96FYPI8gKKEKVDCSVSpN4jij+L6AogQzwsH50avnyfNkSqVxbDuYF3Zdm2JxCtd10LQklcosoijgOGUUpY10ug/Pc5DlOI5j0N6+CdcNSvXBPjwiWcvmNezEic/QWBFpzIh37fpOmGw8jigmKZdLGEYCVe2gq2sra9ceQBA8NK2Tp59u43vf+yKC4DA+fj179kxz663d9PTsYf36m5idHcF1TXx/MxcuHGX3bhXPO4gk+biuyKFDanWt17Q21q+/BVXN4PsupdJkw0TNlS5VR3Z1HMVltFbzZpXKLIXCeSYn36GtbQPZ7CiCIJBMBplxxGGdz49j20XOnXs+BGa1h70Hm2Ixh+MUiFDTAehDRVW7EUWHcnky1FCt4PsWouhXo+2IGGTl4JSLccaXzuLxxV9frdNdbH+LKTNBozTgcmZrm625T7qSUZzLUy69umzfvuD81l/b+nnuubltDUIR9QFTc3VnsbJ2fbumeZ/1qPuF+uGXxiLinlZmhUpMKpAIK0YmAbhLAVQEQUKSFDzPQBC8qshEJrMZy3ovzFBPEIw9deG6JhcuvBdmwgKuawFeSHtpEI93k8+fwXUFBMFGFGNoWoZUag3T04N4no2mtaFpGVR1E45TwLJMDGMK3xdJpXqxbQNBEEK1KIlyuQB4FIsG8XgbspxCkiSSyR4CZjEpFJewMIwy5fJE2A+vtR6gHmB3H3NzWxpGOSOuheic7tnzdX7+5x+s/sXzDIKplTK67qDra5mefodicQxBkHnjjb/fQBYyNvZR1qyxiMfbyefPI4oyc3NDzM6O4HkeN954hv/wHwZ4773d3HzzFPfem2Z6ukhAYQrt7ZvDbUaA1sCuKz2f/GPvkEulSebmhuns3EEms74OsJVjbm6Ec+deDjU2Ay3kycl3mJ09geO4uK7B2bMvUCpN4zgGqZRCPN6Nrs8hSdDWto2pKZOA/1XA8wRcN4frqrhu8HAFkm4ujuPSiov68lIHRr0bb6k3XjJbCri12v21yoIhUFRSlMZtljNb24wabjWKE+3raqfNvFTiEasZqYru38HBBxrG+JZqGzzzzB8wPPzT7NjxRF2WFWAo1qx5h0OHvjxvn3Nz26qCK5cvAGqez2/1uo/nBVKCgiDg+wpBsOyjqhk0LUGplA25o1O4ro6iqMTj3ciyhmkqBEAyH993mJp6F8MohmM6mRA05gKxUEjiFJnMWiRJRpbjuK6N7wfo6oB/WkRVk8RiATd2peKHghEmnuehqglSqd5QB3kNc3Nn8X0T31dC2UOXZLId1/UoFMaQpBhtbetx3aCXbNt2SH4SsZY12kL3QF/fq4yP30KESM9kpghcTkQOAhGgbnDwo5w//yn27n2f7duH8TwLQcjiebXZ45tvnmHz5o+TzY7i+w6qmgidMaRS69i58+Pce+9aQCeXm0HXHXw/QJh3dw9UgWidndtJpXoXTNau5Hyy4EeQ30WsUCjQ1tZGPp8nk8l8EMd1yaxQGGNuboT29v6qRFepNEG5PIPrWqEGaVd4I8+FbFxz2LaOZRXI58+Sy53GdX0ymTV0d++lWBxnevpdRFGhUBgLqTYFBCHoraRSnSF60cJ1g6grFkuh65MsPl6xHFtqwVjsvVGNb8lLvmpbaDzoUu5vKavPduv1kiMnrChljhz53YbXgYZt6gUnVqq5/EHaxchDNm+/1HZLXcegD9w4PtVqm4gqNipj3nnnQwB1s/ZStUIxOPgAb775hbpyeO1ajI5eGunQ+Raoqs03te61qP0jIAiZcNbWQ1XbUdVuSqVzBM5LCr+TgCCk8H0nlDGUsW2DWCyF6zp4noksx4nHMyQSPaHMo0cudwrX9Whv30BPzwC53FkqlRyBTrKE7ws4joEoqqRSXahqG7o+gyDIITtWMApVKJzHdT0sK4tpBmVnSUriuoGWe+CADXxfwraLdHRsw7JKlMtz6PoMvm8ROM/F15/gHriP/v5nARpaEQ8++FkGBr6HKAoh+5lZ3ab+fX/n73wOQVD57//9L4nuh09/+hv83u/pbNt2iESii9nZERzHYHZ2CMuqsHXrvdUMuL5MPTs7gu87pFLrACiVLiAIMj09A1Qqs5RKEwiCRE/PQMO2lzpDXq4P/bHMkOtPatQncByDqal3iMXaMIw8llVE0zqQ5RiVSpZyeZrp6eOkUusxzQLJZDfd3duIOGDPnn0FyyrS3b2X3t795HKn0fVpYrEOfN/BcQTAQRQVNK0TVbXJ5c7j+z6yLKPrOQYHf7ppAZEZHPz4EotKpCQTlatXku02vzfKmC+fLqDnzUfAftDWqufZ7KTrEe1nz97DoUO/07BNc8Y8NnZlaDMvpbUq9a7EebeqdtRvv1i1p3GM6qep53QfHv44/f3Pz6tQRPtrVfEAlkR4r94WUlWzmI/D8NE0DcdJY9sTWFYF150Ie8xy+B2D2d9AiMHHdSVisSS+7+I4JpIkIQhxEokOurv3oigKExPHkaQYqdRGKpVJFCXO9PQgppkHZBRFJZHoI5c7iWWVUZRAIMKycuGcsohh5BAEkXJ5DkGASmU6JCeJpDNloIjj2MzO6mhaBwCeZzI1NYQkCXieR6ByVU9KtLA13wPzW3ICntdOLJbm2LFbGR29ex6Qb2TkIIJQE9kRRQdB6CGRiAhG8tUydE/PHuLxDgwjy/T0YNWxJhJdVCqzdHVtxzDyaFpbWIIHcKv+oVyexvdr/uJK02le4aXz8lhUdgjACrX5MtPMY5p5Ojr6SSS6Wb/+phCwdY5s9hSxWAfl8iSWVcK2LWzbIJlcy+zsaRwnYNuZnj5GLJZhzZrriMd7aG9fj6KkSKc7SCY7Sac7UdUkhlHA8wJieMsqMjj4ER555Du8+upv8sgj32Fw8NPVyPCVV/4hjzzyHZ555g9afJulSAtg8ctYj3xxmn6/9HYpnfHFIIp37HiMQ4d+p+pE6x1sM6I9Kq/Wb7N583MN5BWCUOHpp7/C8PADDZ8jSVwTFjnSZnKRi7HlOPfBwQf47ncbz9uWLU9Q69MK7NjxJP39jee7fha8JufoVq/XQi2GlR5/9O9iLNA5zoW/mbiugyQlgCSCEPSVg9wnKteWsCwdCMg/Eon1JJNtJJNriMcTiGIMQQBRFGlrW0dn5zby+XOYZglFSaOqSTzPDR21TCyWIpNZRyq1Cd8XUdV2ogDetiu4ro7r6giCgiwnkOU2II7vOwhCkiiLt+0irmuHSlIGnueEOserD+AHBh7j/vt/B4CnnvoKg4OfRNNUzpz52zzyyLd59dXfZGjo0w3XfseO19m27eXq3zxPZsuWFykWJ0gkukgkusIRNKG6vguCjO+71dHVyAcYRp5UqpdCYYyTJ7+HosRJpdYiyzHOnHmRZLIbXc+hqskGv3Gl7McmQ67PilvRoqVSvaxff1uV8CMWS5PPn6e9fSPZ7Gk2brwVXc9z4sS3efzxBKOjG7j99iL79r0cRrExNC0Y9B8Z+Q6a1okkKczOnsKySkhSF7FYhmSyC13Pk0h0c/z4fZw4sY/+/mcZHb2naQG5i1r0HGSuL7zwuw1zfIFZ1JzyQtHpYk62uTz9wQDDLhYFe6nHe5oRwbff/hCOk1hQT7k+y5blSrXE3Qrw5V6+gsOqbDUa0yu1xa5PNMJUKPSFqk9uA7ju7ru/jCxTJZM4dOjLQGtt5IhYJAqibr/9oer1WorVbTHTdRgaeoBz52o4guWfp8ayrevmCUrZ0Y2gY9sB2DOg2IQAfd1GoBZVQRCkEBDmYFmzCIJIsThBuTxLe/tGEokeICL3AEXJ4Ps+mzbdTjZ7lmx2iGSyl/b2DSEjmIHjFPB9L+xFJ9E0DV3PV0vkkjQLyKTTXUxMvIPrmmhaF6rahW0b+L4TPrcKtm2G32sp0pSlrXm2XNP+Lhcu3NUE5PsBHR1D9Pc/z8DACyQSCdrb/znvvXcd/f0vceutU4jiA0xOvkM6vY6uru3VcrRh5Ksl6Pq1v57kaXb2JDMzJ0gk1rJ+/U2Mjb3B1NRxstlTxOMdZLOj9PQMVLe9UvZj45Cbm/H1DfnIWQfAhll832Vu7jSalg5nArcgywnK5WG++90Yf/Znf4wgOPzgBzL/9J8W2L17gni8Ddd1KZcnSKc3o2nd5HJnsaxcKL0mUi5PMDt7Cscpc+LEA3z1q38e3oT/iDvvfKhlBhAw2ASZgiC4C/D62sRia0Kg2Wqit5X0nRttNQt7JDLxwYylLM927HiMn/u5T3H+/PJ5qaPZ5Kef/krLcuqVtsXO72qc8EJ83/W2VKBUz84UEUIE1Qi3Cq4bHn4A207OY5xrVfJuLlc7TkCqvmPHxdFnDg09wLe+VUPV/+zPforrr1/uPjwCqUWbGrraRxRTdcQ/zc+biCCIiKKIIKSr2Z3rGphmGU1LY5oBa5ZtF9my5RC2XWJ6+n3i8Tbi8RSp1DpUtY3Nm+8gnV7Lpk13oesTFAqTTEy8ga4XUdU4khQnne4MyUdyYcuujGEEDtnzrDALtnCcSljVErGsAqqaRhBUAvpLiICpEWhtNdZ8DQcH97F79+P4fg0AdvPNX2XHjkfC89ZJV9d17NsXY//+P8V1LWKx6zh79qVqm3D79p9qcMLNiGlRDHi6A21rme7u7RSL50kmuyiVJojFUqxZs4916/ZTLE7Q0dF/xcvV8GPkkKOoRtPaKJUm5yHnAiDXNF1d28nnz6HrAb1cPN5BJAg+MXGMEyduaehdvPHGGnbuDErPlcoshlGgVDoDeExPn8A0SyFY4gI19KDDyMitDSXS4eGPt5wzroGHggWsPtKvpxDcvfswvr+QU10qRVvYGUdAk1boyXqaTFgeYjpyxFeTM45s797H2Lt35epRC3FsX2wWL0kXl10vpay12GjQ5cqiF9L+9n2JTZsON/Tyl9P7bSV+sbhi1/Ls3LlGJ3Hu3D0rcMgQPC/RwxFkkZ7nIopxPE8KXw80zyGJqkq4roPregiCgyhqtLVtwTDyoRyjjCzLlEoXsCwJXZ9GVTMhEFUgHu9CVeOoagLf98hkNpLLnWRy8lg4ViWG/ySSyXZAYmbmfRzHQNO6KZencV0Xz/NR1WCkShQDSUjH0UOSIxfDKIb9bR9JyqAoclWoIXAX9f3kpW1w8AHm5pq5y59hy5Zn+MVfNDh79iNs3PgDHKfEU0/9O/r7D3PTTcdIp/soFs+GGJ4YudwZyuUJbFtn/foDlMvTVQKVhWQVGyulXWzf/rFqhTTg6+4PiaC6KZUmqz4i6kNfCfuxcMj1F6EVbL2+eR88AMHXtu0KhcIFstmTtLdvQdPa2bnzNV544VfrehcvYVk6miaFzF1xMplNjI+/Qbk8SzDyFEMQ1FCXtBPTzIULyT8kKklPTt7AxMRN8xagQ4e+3JIWcz6F4GcYGPjuJT93kqThOK21lCNnHAG1vGUk2fF440K/Wsd8qWgoLwXFZVS+HhurXaNW2y8k+djKBCF476Uod0eft9T3anbel6OU3TjCFCGMJe688yH27XuMp55qrDacPHkP/f0Ll4v7+1uTklysbd/eGGTVs4Yt35ofiOC7BrKrYJo5wEAUfQRBRFFiuK6Bbdu4boFs9jSKEkx+pNNrcRxob1dwnAAcOjd3kni8k46OTczODmEYZc6dexHbLlMjAvHo6NiMYVQwjAq+72MYOXQ9S7F4AVlWEAQBWVaIxdK4roNtV9C0NlKpHnK5cXR9OvwuPmBjmllEMYaiSChKOhwXiuF54Dg6y7X6NQxgx47vcuDAwwwMPIkgJNm9+1luuukor7wywCOPPFqtJnZ2/jO2bZshnz/HG28cZHBwHzCHZUncfbfPhz/8YeLxjpYOdLFKqSjKGEaWZLKnCvyKrBngdaUoNH8sHHL9RWjVPxbFAOYeEYl3dPSTzZ4ikejk1Kkf4nlBr2Zs7Efs2vUuX/zi3+fMmbvZsuUF7rlnjFhsD7FYN7ncMJ2dO0O1E5VYLB7OIKrIsgKI6HoWxwnmCHfufJSpqevI57dUQUStyp3LKdWNjt7FwMB3LsHZaixfO87Mgu+MHHHkmEVxeVlyfekzyuLq/75cW61wQ71jWuizl3Jeze+PiDEWs2bJx8Ws/rxcKrtU+7uYYChyoGNjgfRic0VoIYKX+vuq+bMvB63p6hSjFiMMCWhpPa+IaVrU5v89PM/EdRUcJ4uiJBEEEd+XsKw8ljULqORyZxEEERBIJDqpVKaqZe3u7uuJhlNNs0ihcAHTnMW2KwSTHYEGs+/bOI6HbeuUSlM4jo7rCuj6LILghcAnB9vW0bRufN8Px5kiXEkN0xIwgamUSpMExCcCC6PPW1vzGtbZeSo8z2pIN1yhWCwzOvrrDVXJkydv4777vs1bb93Of/7P/7IhuHvpJYk1a57j135tA6ZZnOdAm3vIpdIkEDjn+teaM+DIR0TjUs1V1g/KfiwccvOJbhXd1PcUdD1LZ+dW5uZO0dGxjVLpAuXyLIIgoKpJbrvtGHv3/gDTrFAorKevbw1TU2+Qz49TLF4gk1mH53kkkz3oeh5ZjiHLKuXyNI5T5plnvtwwUwnUlWuOEDjFQIfU94stv1N///NNmq/Ps/weTieQo3Wpevm95ERiYdrIxZzrYlKHq83KVuIk7BY4lNXO5l4quxqFJxaz5fSTF7LIgUb7GBx8gKee+kqVYGWxjHc1n7fa0vvKSt6BRGFr+lkhfJZtgucrKO+KohaWeq2wCiVi2xax2BpkWcGyLGw7C4j4fuDsZVnG80x0vUAqFfDqz80N4XkeiqLR2bkdx9FJpTrJZs/T3r6JVKqXubkRLEsnHu8Iy7wqnhcPgVoOohjDcUohW6BFoXAa2+7E9yEW60YQZCwrHx6vj+d5WFYpbJN5rAZp3Uq3WhDaw0QGHKeE65r09/+QV175zSor1623zrBx44c4ebK/+reo/C8IDt/+9ln273+RO+74bSyrPC/5itb/gBRqhGjdXIomM9q2VJq8YuQgPxYOOTqRUUTU6qRHaDtVTeO6JrncJBs23MrZs0fo7t7B2NiPSCbXoKppcrnTlMuzOI6OLMeZmRmiVJrCtitIkhqyw/jo+jSO4/D++x/j9Ol72Lr1BRzHqCM9CKK6nTsfo7PzFP39L3H99S/iOEkURcM0F8pOJfbufZ4HH/wMo6N3VSP4SihvKgiL01eqqoJtp/H9PAsDurTwGBePehdyJLreWu3pYp3OYsQiy3Vqrrt8/d769wEN27RySis9ltXY5dr3lejrLyQKslJ+8YWQ0JeaGW5hW+w5iSHLcWw7Cq5dIEXj9INEsNyKmGYWVV1PPB5DVWM4jh4mDAqiKJFIrEUUBWKxDmKxFLZdCgksRFQ1aC/NzY3iOBaGkcW2KyGYtITrtpFIpEgkurGsMrZdolCYCI7KLVDr6wtYVgnPE4nFkvT0bGdqajBk5IKaWlWqKm4RrBkSUGE5yUGrKoTvC7z11kc4c+Yetmx5kZ07v8X+/S/S3v6PGRu7n9tvL3DPPSbp9AZuuy3Hd78rN2TIQVXlB0xPQzY7Sm/v3gU/P5HoqjIwAst2sq2qrB+U/VgxdUWRTSLRM++kR6/5PszODmOaORQlTbF4LnTmPjMzQ9h2hTNnnqNUmqVUmkLT2shk+qoISdMsoet5fN9DlmXeffdj/MVf/Gk1ChwY+B4nTnyEesmx+r6xLHeHQ/xGKDLR6vQrBA9NLRo3jPm93ESi1VmQw+0jUMnF20ooFS+W7Wkppq+FXl9Iv3cxlq3R0fmiBlFV4/bbH+Luu7+85He42HOzmkrDxdhKnNXFfr6mBbOnr776m9Wy5c03/0cOHQrmUuuZ03w/SX//c1WN4+j1+uu4kBRjq8/9YC1J8LzqtM4kRSCBJKkhMYcOSMhyO/F4W9hTLmHbwTObSvWhKAqynKS3dw+p1Hqmpo6j63NhH9gkn7+AbZdIp9dhGEVcN5CDbG/fgKZ1UiiMoWmdzM6eolKZI3CiDiAiy+34vovnRTzcEoqSCIUjwqgfFVBQ1QySJKDrRRQlhiQFspGReEXt+9UH/QEqu5WudTMr1+c+97e55ZY3SCS6UZQ4qpohkeigq2sn3d0DPPzwIK+/3oMkVbDtOFu3vsSNN77Mrl2f5r77/o+q1vFSdqU5qv+3ZOpaLLKpR2EHrDdD2HYZyzJIpdZiWWVisRTT08eIx3sAJVRoSRKLJXAci2Sym3i8E0kKdEsdx+T8+Y9SY31yEUWqYx6+H4BZaotIjGSyM0R1z9HIwFVvNpCgNnvsY9uN0ofzw6iAwi/g1NZZvjNeiCawZvUObyEmrotxTBejGNVqf8vVR26l1RvNhB858rv09b22ZCa3ErTyBzEfvNjnwcVnkMsJRoaHH+Ds2XvZtu25BXvGkbOtKQK5VdR15JRbkX9cDeNm861M8BxFILZmiwNWKBoRcGGDh+Pk0HUfxykTPIMSQVnWxzSLeJ6L6zro+iz5/Gl8XwjpLcHzdHzfoVA4j+e5KEom7JuKIRNhhUJhInS4TvW4FKWdTGYDllWhVLoQ/t0OnXHNVDUgOHLdIrpeQRBcJCmBZemIYizEStgEgYgHxBgc/Cijox9j69aX8DyDRx75X/PQ9M195TNn7uLAgVew7QqyrGAYU8RiCeLxHiYn3+XgwUF27DjBhg0HKZWmUNU0icTPsHnzh7GscoNDXszpXg1ax8uxHyuHvNhJr6dTk2UNxylx9uzLuK5JobCJfP48Z848h+OYvPnmQd56ayubNj3DTTe9hqqm6O3djiTFicXSlEqTDA8/jmEUEYRcw7xlV9frPPjgf2oo0wR8vF8CJG677evs3fsckiQjipkQmFFb2RqjyicIHt5USPQOqVTgjBsZogREMY0sB70oz1vMyTbzWS8PqBEtxLa9OmTwYlli5CRa9X5XY81jStu2HW7pDFtp9QYWnKNjx76wrNLqSgOKpXrcF1MWj5Dezfts/qyL5cCOjq95u/qs9kc/CkrUzT1jTYPjx78YbhFFd/NBj81I6FbkHx90kLOwmbRmzBNpPSrkAYk61LIKBMjpSqVAJrOGtrZNdHXt4OzZw+h6jnR6PbIcvE8URSzLpFQaw7YrWFbAnS9JEun0BhKJTjzPxDQdagjqYP+KImPbcjjuGDjTWmYcmGXlEUUB09SBYCTKskTee++nGR39MP39LzAw8C0iWtDBwZ+umwr5B+za9WTD2Ofhw78HEPaLf5tA0lJm5843icfbWbv2BlQ1ja7PhlrQ71MonCefP40sJzCMHD09u4jHexBFiMVSOI4RjnxdHcIQl8J+rBxyZK0iJc9zmJ4exPddEolu2tu3MDX1DpOT7+D78Oqr1/HsswN43gTf//7fRRAcXnzx15DlX+HQoQukUn2sWbOLubmzGMb7oTZogWIxkl6L6OcSDWCRqEQT2dDQJ8IRpicISl21B7X23iBbuPPOh0IWoxLt7Wny+SKeF2TItYVHJBhJsLEsk9bqTvWRe7RhRBQflMV1neq+W5fCA1MUcJzGfmQ9CchiTqT57/XbXcrybDNwKMq4WikV3XnnQwwNfZytW59kdPSnuHDhtpb7rO9lLoW2bmWtvt9CgU29w1ypU17KGbf6jOW8f7nWqjpRT2G6sHnznO5ykdBXj/TlckCU0bOoIkkCvi8hSQlEUUMUBQxjDkEQcN0yoqhy7twLVCoVwEMQBEyziGHkiccziKJHrcrmYllFJEnBsnKkUmvCccwoezcAJWQGs0Lp2ODYJCkRlrzrb0gdw3CpXzvee++jPPLI/wyd7j8MxSIeA5x5ma8g+FVnDBITEzfyyCPfqQqJRBaLpejtvaGaLJXLQWsxUKBaw7ZtH+X06cMUixdCkpMYgiBi2zqua4UsiweRZQ1Na6NcnkZVk1UsEXBVEH4s167+I1yFNUsuAiFDl0OkgpLNngYCtaa//utJ/uiPPo8ounheVG4ObqzTp+8AvsWaNbuYmHiX8fFXcV0vfIBsNm9+liNH/kFdFP9c9TgGBx/g8OF/QaNQNxw9+isMDDxKgISu2ejovSxMpSnQ1hZlvmmCPlR99CsRONnmBaB+VCOGomhhVu4RCVeUy8EDF/DnLl3WXGjWeDE0QqsFfymQ0cUstM3AoVbf6fjxiJbRY3LyJm6//aHQIQfXa//+h4H5WsmK0prM4loDeV0qqw9WmqsTzTKM0TU4cODPGRr6NNG53r79O+zf//CyRgKvbVNR1TZ838a2DURRQpZjOE4FywqeXc+rYJoac3PDKEoMVU0Qi+1AklTy+bGwMicgy2lqa4tMOr0JsJEkFV0voutT2LaJJGlIUjDmJIoxbLuIbUfMW4HzD5y2TSNVpkWwRgSYljNn7mtqIdzJwMD3gQT9/S82VJtuuOH/oafnzTqAq4ggBARJ9W2iF174BHfe+Z+YnR1CliU0rQdFURFFFU1rD2e0+/B9gY0bD1IojJPLDZNI9JDLnUFVk8zOjtDbuxfDyCMIhPr2tW9xLWXN15RDXlljvnG1r+8hv/3215iefg/DKGDbJseOba0642bhgf37T7Np093IcpKpqePk82OARzLZiSBIDAx8d0EO3ohCsLmUtZDjikqorak0DQKnqyHLcWQ5jmHMhd+tB98HXZ9jfnnMp+aQXQKZSDUcs4gYhmol8KA/tcSppbWTuJTCEpc76zEMOHassWw6Pb2Xz372Uxw79gXq758zZ4JAKYr4W/UyL7fDXG42ezmPo9U1OX68MVhpVaJute3AwMoIPxYCCI2OBqAw205eBhnG1ZpKpHccAboUJYVt5wGwrBxR8KwoPYiiFPZwBURRw/edkFTER5LWEyCzCySTa/F9F1EM6CxF0SMW6wx70wKmOYumtVMuz4X7DMaVFCWBqqbCrNLGNC08r0K0/EuSRiyWxLJKYeYcYSocas40RX//Sxw58v+qSz6eJaDYVBgYeCqcCrmH/v5nw37xPdQnGL4vsWPHk0xM3BSeJ5F33/0Ijz32n9m3713a27exbt1NaFo3rmthWQUqlTnK5Wna2zczM/MuhlHCsioUixfo6tqGKMp0dQVI6nr+agj8xZVETK/GrimH3EwAspBzjtSdWs2nFQpjJJNr8DwPUZTJ5c6xf/8pvve9mhO+664/wnVTtLWlOHPmIzzxxFHuu+972HaJSmWOd989xMjIHWze/Cw7dny9uggEGS7zwAu1KDb42dv7DvORibUSamsqTau6jeOIeJ6MLKdCsNlafN9C1yOQxkIWw/MC0e56oEdE/hEFCst1rM1OIiK7WAmP9ULZ32JZevM2ggCnTz/AyEjjmNNyR5/qbXz8VkZGPoMguIyMfJrPfvZTKEqZmnSlhKI09tuu5ux1MbsUx73cEnWr69lq/Kn+mCK940ikoh74BVTbO8G18S6DDONKTSBoCdUjkH1EUUSSRGS5A9PMhQ4j6N0KghQGxzKiKNHTsxNdL1MsnsKyTCqVGUqlqZD8Q0aWNXzfC7n1dVy3gucFrSfDKBDMNNuYphuWjQmR3fHQgbdTLE4higlUVSMWS4XjTz6OkwuPubGiBx6yDLt2PcaDD3421Dt+ulq5C9YSm4GBR8PKX2CNz43Anj3/k0OHvszk5PUMDX2SCMw3OvohBga+jSCoGEaWqan3UdUkhcI5XNdFEGBi4g0UJYOmtSGKIhs33ko83kUslq76AcOIAp5idQ26VsBckV0TDrlecBpqznihUsRSF0FR4qxffzO6PocowoYN/5XPfe4NTp8+yI4db7B//wu8/voB/vqvv4EgODz22CF0/Z9zxx0ag4Mf5y//8j+HPeYv8uCDwdxeI83lp+YBhvbs+XpV+SYoRb/OwMDjNKOsF6LSbHTgAarSNA0kSQrRkszbV6NpVdk2zyvUny2SSQ/DCG5gz1u8h7yQ1Tvh6GczIvtSZr31+6ofpYiyNGBe5tY8x7p//58zMlIrm/b0vMORI0GJrV4QIagquNW/2fYqTtAi1go1vxo09GKl7eVm2EuB75ptqRJ18/b1x7FQwDQ8/ADHjn2RkZFPUy9SEfUzg8yrUSktKoleWSS2Qiu9ZM8zcBwRTesikwkoHwNktYdhZAkYuhx830fXc8iyGnJi66HWsYampYjF4hSLBhEjoG2Xq1UyiCFJwbkIHJNFgO4WEQRwHItYLENbWz/5/BiuG2TokgSmWcLz6gmKmtcRu8oKNjDwv9i9+3vIshI+B06L7xxuZSfrrp+H46gMDj5AqdRLDW0eBbgSnlciFmtD03QqldmwpC+jaV04jgnYlMtTHDv2Yb7xDY9PfUrlvvtGsW2DmZlAC7mnZze+Dx0d/fNIQ64FuyYc8kL81PU/l2NRKSMWa6NcniKXG8N1LQwjz65dT3DddU8Qi3Vg2zqnT3+4IfI/enQLN9xwhOHhB+r+HqAHM5nzNJc077//dxpK2a2pMB+tO7oaeKJ130wh6hdrWlAu17QEhpHHNCNGncXMwLJa6SEH212ss2zOiFfijJfbI21VtoT5FH01J7rw6JOmzQd/RaXp+hJb5GAWQvuuNsuMWgSKsnrkerOthMd6NftYyLZvfxTw2b//4XmOtdnhRvtv7stH406N41A0zPNHC3grpbRaENVYvfhgLcp8m83CcVwcR2Hdur1oWpzZ2VN4nofrlkO0s4zv2xQKo0TfU9O6icViyHKG7u5tTEy8hePYiKJERL9Z6/nayPIa2tr60PUcEW0nSNi2jWVNYhhZdD2H65YIHKSD79thq64+IhQInHn9uYwqdBIB45hBK0EaaGwlBMcIIDI09BmGhj5Td46EMMBNkkj00dt7E5nMRsrlKRRFI5HooL29H1lOoqpJfF/g8ccF/st/+beIosNjj8n8xV9o7NnzAy5cOEqhMI4gKKTTa7Cs8jWVGUd21TjkxfrDmtZGsXihAea+0lKE5zlMTr6Drs8Si7VhmgUqlSlkOYksKyiKFdLNBT2I/v7DvPLKb1UX4c2bn0HX59i8+Vmef/5XqpHfxMQNdT2RxpJms2NtppFrtKVW5GhOUcQwJgkiYgVB8BEEP+wJLWUOgWO//CaKF+/k63mo54tt1OZVF5p1rXei2ew2hocfaEBIR0653om8/vpvU08OsmPHYwhCa63ei7FIhGIxR2zbNdR0/d+uFmsm7ti//+HqNW/VW64/z61mjPv7H2v4e2C1OeVIpCI6/1HVqf49R478Lps3N2uKf1AWOZrmdlSQzVuWTi53LiTqEFAUBdeN5nibnZuNYUxiGHFkeQZJksJ1TyIW60QQbFzXIeLQBjCMLIbRgaZ1YRg2kZa6osSxrDKe52GaMrXgxsJ1HQRBQxQT4f5cZDmNJKmYZv2a4hKtUQvR/cJ84o/OziHm5nY2nSOx+n/fl1BVn/b29aTTXZhmAdMsMj09giyDpnWQSqlVZsR33w3uD8+TEUWXV19t52Mfu4WJiTfRtDZ8P+DsvtYy48iuGodcL5FYr94RiEuPoOuzVW3PpThJF97/Baam3qe3dy/F4hSa1klv717y+dO4rkAqFbBo5fMT7NnzLA8++HPhzN0PufXWIWKxTvbsOcyDD/4tDh/+50xM7CfqXwUmLljSXDmZfSsi+2h8IUBIC4KMoigIQhqQcF2TgEDeYOH5YoeAdGQpB74yDWVNW5hOc7nbLzYuNTLSuIBHKkEwP9ONFv4IoDUy8hlOnvxEWJ7+VNUptxIxqAd19fW9BgTl5P7+x1qqEq0WAb1cCtCVZs4fJCK72amOjd1TPbdLkbO0krQcHX2AXK5Rqm/Xru+wZs0780QqBgcfqPaVa9WlhQVcrpxJBM+tFyYd0/i+G2bFGvWjh/MtKCs7TpzAeYEkqTiOjiQJpFKdmKZKoGI3CwgUCuPIcoKAW1sHFGQ5HgLJBHy/QiMhkUBb2wYMo4Tvl0IhDBvHqa0PC1Wm6i16z9zctobrHvS3602sC7iCIOr55/8xW7e+i2F8j87OrQT82waFQgnD+BHt7VtQ1Ti6XmBgoJPDh3+5ynG9desrTE8XSaXWkkh0k06vvaLyiRdrV81R18tflUqTVadbKk1SLk8Si7WRTq8DVgdjDxy4iu+7DA8/HmbjPYiiSjLZG6L1dmFZBV5++TqGh29i8+bnuP/+fwJImGY327d/lGPH7uDMmU3s2PEEExMHGqL5xQgMAAYGvheOCbRydM0OuBUUOyobxUgk1uH7Bo5TZu3aLczODmPbPp4nhf2pyCJx8fr9VqiPrFvb8p1xZIvxa1+sLdWrrM9060ul7e2nqWdSO3s2cBrHjy8M+ApAXU4V1NU8PnUtWn1LYblOe6n3LaQT3eq1SMc42l99EBVJH7aW6mvtABpBkzVnvNjz98FZNFIIkRJckAmbVCoFRNHHdSNHvNSFUIjH2/A8F8cxsKwCyeR6VFULUcYq+fx5CoWz4dRI0HcO0M8Qi2WqKOxg7WgkMJHlDK4LgiCGDH9CQwbcqjLVfE2as2KorYV9fUfJ5bYTZcZ33fXvgE6mp/sYHDxUddyDg9ezdevXMYwsmrYGx/E4ceJ+Tp78ELt3v82HPjSI65a57rrv8U/+yf/J0NABdu06yk03lTl7do62ts1s2HArvb17r1lnDFeJQ3Ycg9nZkWojPookIciQTTNPe3t/2OBvm4egXo6Josz69TeRzZ7GdX1s20TTutG0gC3Ltiu0t/fz6KMODz/8+wiCwwsvfIkHHzTYs+dpJCnGU08l+E//6V8RLQB79vwNHR0zbNkSiEqMjt5dRR+2jiptVLUPx8mH/eylHPC8MwUoCIKCooBlgSyrFArj+L6I60YzyfVOeCGg12IAsKvPllIJiqy5N7lr19epZ1IrFNYzONi6nKppMDa2PNrNq9UWcqCx2Mr2s5wKR7NTrV+oF7pezU45yqibdZLb2k7R37/QczSfZe3OOx+al0VfWQuoNGVZxnFK4e8Ba5frisTjnXWALKg9s/WBeeA4DaOIbZvhSJJNPn+GTKaPubmz1Hrtcgi8cqk5eQlJUvB9L0RVd4TtLr36uueJmOYMjhNxGAh1xyK2wL7Mrz40v2fXru/T2ztFLGbz/e//GvU0wocO/VtOnfosExN/q6ES0t//DJ5XplKxqFQmGBz8JI888lUEweHll2Vk+R9x3XXPoKppbrzxCB/+8Cj5/CgnT2axrApbt36UZLLnUl28K2ZX3CF7nsO5c69QqQTKR729e6t94ihDjse7MM0illWcV9JeiWWzo0QE7Nu23U0i0Q3AmTNtzM4OYVkFjh27vukG/BA33vgGsqzy7rsD1IN+3nvv5/jVX/27DAy8hOPkuPHGl9H17CJRpY9lTdE4fL8yk+UEvi9RqRSJxZK4rkss1oFp5nHdYJwpAHzEaRy/SBKNJ9QAH5feLqZsvZQtRyWouVQaROe1a3bixC/g+1rDSFo9RWbzQr8Yajiyq524o5UtdczLBYHVX5PmbRa6Xq322+q81wdXzdnZ6vSMPyhTicfbcRwbz4uetwoBfiMIxHU9hyTFcd2g5xlMOESl5KhPEQTYvl/AcSKglQVUKBRGKBSiKCvilG7ub4hhYmMhCHFUVcJxtDq6ThfPm8WyIGhj1Y4vcA1aSwnFZmt+zw03/BnXXfccTz31bxueRdtOcOLEp/ja1/6yWglpaxtl375HgCAoiwKv0dF7qtuKosPg4A0MDDyBJHVQKk0yMzOMaeZ5551DnD59F/fc47Fp04/Q9ew1nSVf8aOuVGZRlASCINLR0Q80yikCtLcHf9f1LOA2CFKvxGKxNLZdIZPZSHt7P6lUL7ncGRxHDwEBsG/fexw+LDfcgJ6no2lr2Lr1FZ577hepJ+4YHj7AwYNv43k9pFJ9jI+/xehoM6PNfQwMPMV8JpyVWhzH8YEyrhtcung8g22XkCSVYO4wyKID2bSaQ9a0BLbt4Hl22Ee69A45Gp2q/325TvlSObTmUunWrU8yOXkT9dcsWOSiW19kZOQzDA8/AARkIevWvUoyeWEeahhWN9t8NVgrQY+lRqFW2xuP9r0SjunIwZ48Wcuon376KyyWnS3F4nVlOK5jgIPjeKEcY0RRC43PfhnXNRCERCjdWKE17iNCKQdZsyx3180LR2XvhZ7l2nrj+xKu64V6x60sIgqpr5yVlhX41N5zX8hx/SiuG2PLlud56aVfb1hLT5061FDazuW2hmxeNAE2a07e82T27Hk3JEQKdKlNs8Dg4Cf4q78KRlCff14mmfwuP/uzU6v2D1eDXXGHHPWOOzu3hiol5Spgq1KZxTCy1RnXZLJnVeXqyGRZo6dnTzgyFMw063oWUZTo6hrANLO0tWXYu/dZLKvEgQN/xsDAk2jaNhKJLm699U2GhhqJO6677l16enYjCCKOY5PJrGH79jd45ZV6p/4sq3XEstwWRrQ2wQPrEvV+JUkIWbY0XDeLIMTxfS/8N92wH8MohdtfnswY5hOCLC3seeltoVLpkSO1aybL8xe+l1/+/3LhwsGGv0XUmZE1l8OjUveVyI4vNitf7bZL6REv9t6lbGDgsQb5xcV61EvZB6eTXG8SkVO17QKR8MLCExQuvl+TXWxt9eDLYJ651g8WgAyiaCHLCRzHDIPwVmuNS7l8fpFjgYXaWMuhL218TwAIvf765/nFX/wVhof3N7QcXnnlt6ihrWvg0SjwevPNL9DZebrahti+/Si7d7+N61ZwXZ329u309u7liScaE5/XXuvkZ36mVF3br0W7og45GnXq6tqOYeRxHIOZmRPEYhnS6XUNdJeGkb8ogvAo247HOzHNPIXCGKZZRFHi9PXdjOc5fP3rMR566KN1EZwPxLj55jdpb9+C5w1x6NAfhcQdH+XAgfMcPHgS3+9mbOxV8vkpHEdn9+4zfP7zn+fMmbvYsOEJoLEcE9lS6MXg9UP09/8wVFaRqQGxTAxjCihQKp1DFEV8X6y+1uIMUCMuuDyesnkWeblsXZfamkuld9/9ZTZvDshWFKVSx69bO8BKpZvGkQx/ntrTcmUdL7ddKTGFD/Jzo0rE7bc/hOMk5vWor06rd3bRmGJkARiz1ieOnmOf5QfrHhFYq2YGnqfhOC6q2o7rqth2iVofORF+1gc5L+cBNoKgsHfv02zb9tXw72I1m37zzS8wNPSZlkCw+r8/+OCn2L79BWy7i0SiG8exQopMm337RnjyyVriMzBwnGJRZXp68JotWwu+v3Qes1xx5ZVYvfpSKrW2Smt5/vxr+L5LPN5BMtl7ySDspVKgImLbBvn8ORQlxvT0IIqSZO3afeh6jn/7b/fzl3+5NuzlQLRAf+lLf497772A49gUCpNUKuMkk2sZGXmAN97YyNatrwIeJ07sbXCuktTD++/fy9e+9vWGGywCfdUjE5vRi61f/z7BqES+7ptFEWac+uy5ZlHfSUUUJTzPpbG3fGlttWXCxYTmV5LNLVRSjvb11FNf4ZVX/iGNiyXcfvtDIUtXo9WjrJvnbpsR2B+UXcme9VLX5FI47foZZt+X2b79UW6++c8Blhy/iWyx++niLFqLlgJFRtlfbbwo+F0Js9k8S3MPLNcURDGGoqRxXT2csogccJrAia8mCI9K2Alq45bzbaHEQlW7EQQN0xwnkptUFA1JSmNZed577xCjo3fR3/8SqVQPJ0/eythYO8PDP10Nem+77T/yiU/8AWvW7AvZwfIkEr34voPrehw/fhdHj25k8+bnOXjwOJs2fYgNG26hq2sX6fS6Ko3ylbbl+tArdqQBNVqJQmGczs5tQDDGtGHDrXieg65n8f3V94ubLcq2HccIe64aqhqMBJw48Ti6PsfNN/fy8MPrqS+niKLD+PgnsO3/i0plhkQig2EoHD16G3/+5zU0NjT2QAYGHsN185w6dUfLPthS6MWFX2+OdDVqoKV6RysAKqlUbzhXqIelMQ9Z7sJxZmk96wwLC60vbVdSCm+hknK91QQ8gnO2bt0r3HHHv657Ry1zbs6Cl4v0vlx2tcgMXj5nF1hQiXCrmdPIyAPhDPn8Z2whu3w6yYGDLZdrTHStx/2agZNR6drHcTwupTMGBc8LnnHXLdDIxqdTe87r/9743M93qkLd+x0a+RYa2biCFl7zdVHw/YjVRgVcBEFAkhRkWQr7whEftoimpdi27VGOHbuRoaFP1bUpXkJRVFKpdjzPx7YLaFoGy9KxrGn273+RbduC0VhN24umtZHPn0PX86RSa9i48faq4t+1YFfMIScSXUxPv4/v+2Szo9USQ3TyMpn1VeauS2H1QLFIO7OtbSPZ7GkKhfMIgsjevT/gP/5Hi69+Nc5rr91QHT6//vpTxGJpFCWB43g4jsl77+1tQOoCLZynRX//Mw2MX1EfrL//lUXRiwujGz1qkauELGuIoojjWHhe9OCJtLUNoCgSnhdorAavBT3oYEGAhaPmSKFq4X7z5QbMrGafC5WU6/e1kMpQPYAoMG8eylqSlof0/ok12krvlUqlj0bKzPl9xvoAdqEM7XIFMIYROOOIg7xchmRyuVt7LD7/32zNQKtmqwG3Ak3jZnNo1F2PUN8aUVm79VTIUyhKW1j+jsBjAXfB/Lljt+G6QFTJOMx11x1GVRM4josoBpSbESOY5xnUWMZ8oMjAwBM8+ODPcP78x9m27Qg7dx5GljPoehbP83n33Z9idPRebrllmltvfRNBUMjnz2Gam1izZjea1kkud5p43L4m2bqumEMWRZmNGw8yOztSlc9qZSuTXFze50YZdyaznnJ5mo6Ofp54Is7Ro5u45Zbz/MEfvM6jj/4PhoZuYteuo1x//TCynKCv7wBnz76E51nzdJChNTFIDYF4iO3b32DnzufxvBRgs3NnwAHcigChEd34ctPrtQdUECTi8XZc16VUMgmcrgY42LZLuTxNFJ0GPaxK3fatKP4iJ72wM9b1YCGKMoTFxO6XWhRboX9Xa80goG3bDrfcXyun2rxtpM/bLB84OHjlUNb15/lqG7Va6DquFFxVY+Cqz+hqvf3mZ2w5xBWXy6JmX8RLvrStjP0uyEojRquVOPFmayYKkqknJJlfjbuX3bt/GJbB/dApOwu8v1GuVlEqDddj587HuOOO77Bz57dwHAtJ0ojH29G0dnQ9R7k8TSRqE0yIBMIaIOB5DrZt8O67H+XMmXuQpBLPP/87VR7rP/gDmYMHj9LevgFVbWfjxluYmjpBoBWt0d2965pDW1/R4rosa/T27m35WiQoEV0wuDwC0z09A/zgBx383u9tRhRdvv1tiX//77v4xCe+hSS9w8mTdxGPd/CZz8RJpdaybt1tFIvjHDjwGrHYFxkd/TA7drxGqTTH88//NpVKD2Njt7YYz3iCQPnFY3DwZ3nkkW9Wb+IDB+rRvLXIdWDgMa677jC+L+F5UfnHJViopHBcLDg5lhWhqAEELKuMZZVw3QrB4tbM1gXB4qDW7Xd5ZTRBWBiwtZIFeLkOZbnOp7mkvNDCvND+IpGEm28OAiTDCBbbiE96IUKRD9I+CLTwQs50oWBgIbWq0dH5kphLWbDYuw0Z8q5d3+HGGx8OX28cv1kOccXlsMiJRP9fnq10wmH5z+TybT5D3/xq3HME9J42kiQjil2Y5hTRGrIYKUsjgxoMDX2CoaEHePDBPHv3PokoyqTTa0il1tDWtoFicZRicQbLqmDbFiMjP8PXvhYQgrz44q9x550DvPDC/68hAPC8oCr56KNbGRh4nHg8Q3v7DiYnj5NMrse2S2zYcBPxeMclPneX3658t3sBa4WwvtTZMgRBwdGjmxFFD8+TEEWXN97o49SpNH/8xw8hCC5PPPEJCoX3+Z3fGaWnZztzc3uwbYt9+37I9df/EN/3efTRX2N8/CDgV+fqDh36MsEDUCNzBxgd/fAii4hEkMmaQBLPE/D9aNZQrb4nFmsjHu/Adb2QiUckiqYVRQ35bME0CaXWWpW94shyBln2MYwcl/7hv3S23HGbxYgqWu3v+PF6qb/gmtx888PV/dfzSTfzaV9rLF6RLQXMqp8lXmof9dvU23L6+TC/3Fxb7OvZnb68bMauD4I2U9OgUqkFppcmQIpwGwqXDhHdCiMSjU5CVA4fGHg81Dm+i/7+Z8LzK2HbcqiTHh1XsIYsNZscYDRqOBxBcDhz5i5uueUonZ2b8X0Bz/OZnR1EEJQQ3xKU0k+fvrPhGRse/kRTaTwqR4i8/vrNvPzyNj760Ty+7yBJMfL5UQRBYHb2FIIgIsvaNZUlL1OK/oO3qLQcndBoLrlUmmB6erA6xnQp7N57wfNERNHF8yT6+r7L22/vbIjU//RPd/O1r00yM3MSz7OIx9vJZHrwfRfXrTA8/DHqpeCGhz9OcMMHrDeCEGW4Iv39LzTRxh2uO5oIISkBNr5fICgzu4iihiiqgBiiKXVct0yxOIltW0hSGllOAAKiKCBJAeFKEAjEgDSy3IWq9qCqAc2c4+RDZ6wS0f0FJtCMRI6slcDC5TLDqP1r/sz6f6uxKOMdGQn0k+uFK1rZ5s3PNVy3ZhavDwp0tVi1QJIu/ry0+rxW12Axa9XPr98f1MrNr776mzzyyHcYHHygutjfdtv/xYMPfqrqjJvfF1nt/f9x0XL1ar7DYpZIBGCulZ/jD3IWsBVGpD7oVoioMvfufZn77//ndecvKG27rhWSiTSutwMDj3H//b+zYKtt587vALUWw+bNz1AuX2Bi4n0qlUnGx9+kUJgIyZ4EoAA4bNrU+Ixdf/1r1d9BCgVfgkqDKLqcPHkHnZ072bPn03R17SSVWoPvQ2/vHjo7d1xzfeSrNkNuZfUCFJeSjeWTn3T4v//vozz55DSbNx/mwIFRisXN/PCHtbKZILi88ILM9u2HKZenicU6SSbXACK+D9dd9xITEzdW379jx5PUZg69cEY4iki/1RRhPt50RBGiMRr+Dx4sSRIRhDSyHMPzTCzLqJaqPc9HlpOIooDnudi2jm2buK5PxFGbTLYjCD6ghtt5RPOSsiwjSQksq0JNEaYVHV9gi2Wey+0hL/XeiyF3iMaftm+vZVTNWdbrr38xfHetV7kYXeZSKOuLXexXIvrQ6v0rIe1Y7uct9xo072spMZCgpN0oEHH48O8B84ko3nzzi0TX5mIZuxb7Dqu3lUwlyNQy4GB9EYRkWPKPDvRSZskLmYggqAQ66mbY2qon6vDw/TLBGrb85Cd6xg4ceJgDBx6uY+96MpR/nMY0s4iijOfZCIKGbUdjnA67dn2Hz3/+b3PmzN3s3HmUG254ke3bT/LuuwOsW/cE4PHII9+sJk9bt77I3FyBcnmGnp4BDCNLZ+cW2to2X1Po6siu2Bzyau1Slq2jfXmew/j4UV588V8zM3MqzH7X8c1v/iqPP/5LRCMyX/jCb7B377PhnJ+EpmVQ1SSxWBu6Psdf//XPMzx8iB07ngzL1ZEthZSsOd2AbctHEBRkWUUQwHFcgnGlBJ5nIEkavq/jeQqua4ZgiIhaL4UoyqHDNVDVjqqOdDLZi2kWiIIGx5kjipATifVIkkClkg9HJ6JRhytXxl7peE30/uZ54QcfDDLgemRoILP4xeo4DUB7+wj33/+PG9iiVmtR73klTnqlDhmWD6ZaaPvF9rHQfpaLCRgefmDREbHR0SDzrak1BRWp+kw3yo7rLehZJpc1j7zS77CwLaWOthqTw/36rI4bIAqaL6ZaGK09GvVgr2Ad0le078W5FRSC6+yFxx3oOouiiudVMM0SUck+FkvQ3b0b8EilekkkOpmZGWFu7iS2bXPu3Oc4e/Y+9u0b5oYbXmbXrk+yd+/PI4oypdIkwFUzfxzZVT+HvFqrR0lfjAWiFi8zPPx91qzZS6k0jaq2AS6SJFIsjrNu3Stcd916XNfkwIG/Yteu54E0tq3jeS6uq+O63aRSPZimwv33/xGHDv2z6EgJHrag9Ly4RTGRiiwniRi1BCGGIPi0tXUgyzHK5SkqlXLIZRtHUWRUVcNx7HDkwQ6VZSB6sCwrQlWblMuTxOMdOE7E1pUmWGQEHKeEaQphpBxl9ldvT3kxay6XBqMYwrwS6v79fx465KAasXv3I9UF5GKz3aj3fCnR0MvJgFs5xaVQ4ReTLS723ZYaEevvDyoOL730e0xO3lBF6548eU9L0BZ49PW9tsDc6+qPe3nf/1I7Y6hVwZrZt5ZrF+uMIXABAbNW8M8lIBOqJzWJrDb21KqfvzjAziZw+j4RA6JtW4iihaqmSCRSVCrngAqm6TA9PUQ6vQbbLhOLZWhr20AyuRbXddi7t0Jf3ziS1Ek8/qts2XInshxcxGsxK663q7aHvFxzHIPJyXdwnOWvep7nMDn5Du+8801GRp7ivfe+Qbl8AfDJZNYjyyneeeej/Nmf/QnvvXc3g4M/TRTVJRLtaFpPiG6WUZQ4kqSSSnWRSq1DUdqBGJq2Dk1LETzI9Q9zjbFnvtl4noks+8RiSSxrFtPMYVlFbLuCaZapOUmXdHodgeyiHn6GQ+CIHWqXtkxUklXVOIIgI4p+2Beqoa9rYwdR8FBPDHB12HIdR3Ovt7//cIgcbez/7tjxGLff/hCRUPqRI79b7U8296hX67RWgiSv/7nQ6yuxqFLwxhu/yTe/+Z2qgMZKeqmL4QUW28fw8AM8/fRXGB5+YNHzt2PHY3zoQ7/fMDqzadNhDCPIuObmttbN+oukUpMtgq2VfYfIIrBepdL69Yuz5Tw7EpK0mC7mUvu42MxYQJZTBA64PgDX8f180/tjgLdoP7/5GZsPsHMQBIlYrCME0WZxnDkqlTEqldG6z7ewrBz5/DiOY1EsXgh1nnOIokci0UNf3y1s3XqIjo6Nof7zj4ddcxlyZFG5uVi8QC53GghGmOrL2fXlbQhGqTStjQsX3uLUqWcxjCzHj9/HxMTPcMst01x/fSV07AKjo3c1PPinT3+I3bsfx/eDqFQQVDQthSiKxGJdTE8fJ5nsRFHi5HInqaGiVWpOTkUUFVKpjej6WIgsrDcf1zXwvHToMAPkYaUyh6aJaFoGx1FxXQ9ZljCMQlg+byYEcIBOYI4IHRmLdYeAMD8sD0WArUBAPZj7K9KIwGxm/7p6rd45RL3esbFGFOiddz7E8PDH2bHjyWrmZtvJRcdm6rOBS1HKrrdWjmIx5PNi27Wypbi3l9tLXWkw0IywVpQgi12onN6qNx/to7lK09t7nKGhTy+y6C/9HaLPj+aHLw/nenMnMAJ41n+fevWlGnq4Rv7TiujjUpgKyKhqIvz8iOlPYOFqXnAsi2XB89HXT9VtH+BhfN/CdS2Ghj7DyMgtdajuegswNKqqkkh0sX79QWZm3kGW46hqG2vX7qejox/LKqNpHdcccGsxu2YdcjSnHI93IIoyXV3bKZUmmZsbobNze5XpK9ADDaxUusD09PtMTb3PxMQxjhzZxZ/8yb9EFF3+1/+S+Bf/IsvGjcew7RJ79rzHD37wt6psXdu3v4YoSuTzZ1CUBJqWQlUzvPPOR/jGN/bS16eza9fjxGJaWCY2EEUZSVJw3QyyLCHLCUxzlmJxNMxGW1lAD5dIdOG6aRyngu+7KIqMpvXgeQaxWJJKJUe5fAHPi8pdzXyzxfCnDcTwPEgmu6hUJqmBuQA0PM/D82brtoXLU6Jbvl1smXfHjsfYt6/RsUalzomJmwDQ9SSKUl4wqm8mnWge3blSUozLPTdLAauifa2kp7wca9UyWKqs3Fzert9HxD4nCIGmbrToK0qF0dF7AS5q9viDEEEJerIujRKsgdpTrY8cCU2ILM8ZL4VNWcgCznvL8qjpL0s0Jg+tbXljZtEJra+2aQTBvc8773yYRx75avhc/VYDv38Q/L7ADTe8SCzWTSzWhqIo7N79WUZHfxhSY57h1KlnaW/fjCTFrqmxpqXsmnXIUVQ0H9zlt3wPQLk8jaLEicXa2LTpTv7mb26rovVE0eP99/eycaOApnVy552nicX+HcePb6e//0W2bn0Jz4uTSvWiKAkkSeONN27iT/7kD8Ob8+/w4IMPctNNP0JVbWKxNmy7gGnaSJKHIMQxjCgDVZCkFK5bQRDiiKKILMs4joXr5vE8k3i8B0mKUSjMIIoushxDFINs2fMsLKuIZRWr31UQfBSlG8uaA2KIYhLPm0EQEvi+g6JolErT4Tb1D50djpDVO+NIlebq7SGv1GE39yKDWfFgIdq16+tkMmPzFIWas4H6DHO5c7ZLfYfLOSoVBCRLc2/XH8dCfemVHGdzILB+/eGG15fTV9++PdhHzVl4VSao6BqtlqGr/vM9LxhhujTWCgQZIKZ93yB4rupR1lDPT1CzpQhEIrat1QbN0TEa1DL35T3vi80g1wB4Lq+88tvVGfJg/7W+QPOzePToF4DG6xmPf4nbb3+XVKoHzxNCHYFO4vE1dHZuRRAEZmZGSCQ6iMc7rvnecWTXrENuBe6KkHWtShiiKNPR0c/bb3+DqaljKEqc/ftP8jd/c0sdhP4IkqTQ33837e0bWbt2jo985FXOnHmNclkhnd5AItGJIMjoepa33upvWLDPnbuXu+4aQVF68X2JUknBdXPYdh7XzVHjn47hOMGssSQJtLdvYPfuzzA4+BjT0ycQRQ3PM7FtA1F0icWSiKJENns2RFX7iKJKItGLbZexbQtBEPA8i0RiHYIgkUx2YxgZHMfE9z1SqR4Mo4xl1eskRwtII5RAUVKhEEVzb+bqcNQrccb1JPg1nuro+wZjJydO/AKf/ez8Bb1Q6Gvg6q3PMI8daxzFuVpJQi4n9/ZCjrVVCXo5Tl3TgusVjDlRZYAqFNaHdJouL7zwu6H86cUxdF2eQCjAIjSaXfczAjYp1DLiqDXkhv9fTj/Up5768uKsFYPf4jZf+zj4LkG1IgqgmgmSalYTeAm2P3HiM/h+I+jy/PmfYu3aIAFS1QSFwgU8zyCTWUdb2ybm5kYwzRzS8nlLrwm7Zh1yK2t20hGRSLk8TU/PANnsKOPjr3DmzIv4vkMy+Tf8+q+/xJkz97Bjxxt0dn4Vy9pIe/tm1q+/mcHB7+B5Hj09u0gkOqqKSYnEGtat28z115/i5Zdr5c7t21/FdQ1c16ZSmQmVpYLydaAcpRGLdSBJKrat47o68XgXyWQvghBn/fqb0fUciUSkzesTiyUQBAXLKobzx8GIkyBIZDLr8TyBQuE0hlEKHbeIIAQRtqIkQkS4SbE4jqq2oWlrsawSnudRK2tHN3WwnW03Z9Egim1IklQ3M3h5baHFfinZv/rXm2X8+vpeZXz8FhoDkKC8duzYFxpK3M888wd1nMoSe/Z8vSE7rh+XalUOlqQaaGgxu1wiHZeL87r5eBdzys2BQL2z3bfvz1u+Xj/iNDT06TAbm+98a4u694ExdNVsoVLxQuXeCJTmEawFCWKxNJ5HdUQxKGdDPUtfa+ccvd7qMwI1qaVsKR32lVktm1eUYBy0niApcsr1Y2oDA4+xc+ejDA09QC2I8RtaRwMDbxOPt9HZ2U+pNElb23ri8W42bjxIItFFpTKLoiRIp/t+UrK+2i0Cc2laG8XiBUqlcTzPoatrO319B5mcfAfTLGAYWfr7v8HWrV/H92Vs2w6zzB5GR1/k+PGv0dGxjXR6A5XKDOXyHKqaJJ1ez3XX/RwzM/+KXO7nGB29k23bXuW6616hUjFDuUMTzzMZHPwko6Mfor//OfbseR5BUEgkOojFNiMIAq5rh0CwEbLZ08Tj7chyQNzR2dmPqiYxjAKl0gySZKOqCWKxDKlUL7FYiunpd3Fdg0QiTSzWTjLZRbE4Ti43CvhIUjBqYJoGruuFw/hRiWoxMYn6B1tCUVKYZq7F+y6fNS/2K3Uszb3MdPoCUS+yli037j9yZMPDP039wjI3t73lfsFj+/bvzHMuirI8h9z8+Rdjy0Vor7ZH3Ipgo9mC2eN72bTpuXn99gCkFdjQ0KfnlfmDDKsmJAFeg/P9IOkxF7fI6Sz3Ajc7bwPblkkme3BdPZz3tQgcrQoEgXWgy17/GUL4eiuH7LFcZ7xQqX81jjrY5hD9/T/EtpPUrl/07Lgtx9QicF4U8Pb2vsOBA/8jXCtfYvv24/T0/B+kUr20tW2kVJqmr+/GKjYoFktRKOTp6tp+Vc0bX6z9+HyTOqsHcyWTPeRyp9H1WQyjh3J5nHJ5mlJpElHUOHny05w4cTPbtx9h9+7HqVQKHDny78nlzlAqjWNZeshZ66GqSTKZDaTT6zh16jkqlTkGBl5nYOAJYrEOXNfBdYPhd9+Pbv5vVG/Gz33uc+zb9yyGUSCVWofj6LS3bwhHpTza2jYhigq6PlulDO3sHMB1Xc6dey4sJRdoa9tGOr2WCxeOUijMIAgSspyhra2XbPYMlUoBQfARRRlNSwOZkBBERNfNkIEnAloEaO5KpSYQkExaCEIXvj8bnlER1y0y34lfPWYY80FWzb3MvXsfZu/ehzl79h5kucKRI79LtIDs3/9wdT8AW7Y8wcTEAaKFZcuWJ6uf1bzfaNvIrpRu8XLKwqtl71pOsFDfV//Rjxr76mNj851tVOYfHn6AsbF7wwyrvnohVvuUzX3Lp576ykWVrC/OTJY3MboQmYiH51WwLINYLIEkteO6U+FrVvh6VNKut8ZebM0S4d+XZvhaqNTfylFH71/IQTdu81vceWc0Qhhd53rCl1q/eGDgsXC6IVKKcrHtJDfc8BIHDvwIWVbp7t5DNnua7u6diKKM45hMTr6NLGskEl0UCmN4nlOV7v1xsR9Lh9wM5lq//tbqa7KcxPMcXNfmvffu56//+k8RRYeXXvp1/tE/+n36+x9hevpdPE9AURJkMmvxPA9FSSPLIMsxnn22l+Hh21izJse6dcdxXR/P07HtaA44EH9oHp06d+4+9u9/Edc1GB9/HUmKI4oyimKgqilsuxIGDxUymW66unbS07MbQZDxvAqKEmd29iTl8jjZ7CmKxVlE0UcUQdMSzM6eCqlFIZXqIZHownEcPM8knd6I45RQ1Tiu6xJoJIPrSpRKJUSRkEg+0nfVCeYTA4cd9LyXZ5dbK7mVLQSyakV1Gf3s63ttQcDT3XcHfa9Tpz7O1q1PVn+Pto/2u23bYQAOH/7KijKLVgpJC9ly2Lcupa22zN1ckRgbu6faBmjsGwKIbNt2mNHR6LoFi/OePV/HdWP4Pg2ypM30mFc+a14O8Grx7T3PxXHKJBIZisWphtdqPNPNF6JVVl6vdby4LXTemh310aNf4MSJzywKmmveZnJyb1VStrf3HWw7gaJUqmXrqF/8zDP/Opwvb5RtfOyx3+emm87wyU96FApnMM08U1Pvs2bNbuLxTkQxaK1VKrOoahJBCHBBpdLkJRUcupJ2zX+DVrPGiURXQ18hQuB5nsPu3Q/geTZDQ4/x4oufDQFdMqLoMTf3tzl4cJCJiTcBlfb2dShKsBq2t2+nUpnk2LHb+Tf/5h+E293Ml75UYPv2R/E8gXjcQ9cD7mjXFdix40e88spvVm+6ffuG6Ozs54c/7Gdk5Ca2bHmZ2257C9+XiMfTqGoC3/eQZZFYLE2lMoeuzyIIsbAsvRZwmJ09jWnOIQgSvu+GHNQlHEfE8zwEIUZ7+xbAJ5s9jiAI2HYFUdTCcnoJQZAQRXBdF9+vKddE/wcLSUriuitDclYqNZ1k+GDkAmHhmdvFQE3NrzVn2Hff/eUGR9xq23r6x0ZkaWvHtlK+6YW2vZq0kCNrrhy00gV/880vIAhw440P12W6NRGX9977hSUR04ZRY/lqnjW/OmyxcaSowiRg23PYtgDMNr0n4pSu1y2u11JuzLxFMcKWLFZCD4iNFkJJNzvqZpBVqwpE8zZDQ5+p/r8+mJqc3FftFweaAP+cQCwCduz4Lr2971TL2i+9JLN27TfYvn2UUmkCz3NIpbrp7b2edHodnudQKk2g6zk6O7dRKk0yOfk269YdoL198yLf/9qwa94hN88aR/9vbvRHjru9fTO33fb3WLNmgJkZgaeflqoo64MH86EzX0N7ez9tbRuJxbowzVmmpt5nevo9Xnvt56qzyaLocPr0h9m793kEwSMWa0MQzmEYRUTRYe/ep/mlX/plhoZuYu/eQa6//g1effUmvvrVP6mWeRTlV7juusfxPBdVjdPevomAylJnYuINLlw4GhKCVMhmT6MoMVKpbiRJpaNjM+XyNK7rIssqrptDEGQUJVBpSSZ70LQOSqULiGIGVZXDm7wEJNC0DK7r4boBCCnK2CKH6nl+ODZVZLkmLqeStwJbjliFYSxv5nYxW80Yk6bRElm6fv1r1cWoObuNfi7EzHU1OtrIliIyaa4ctFICWmhRr+85vvnmFxYslTZ/3o4dj12xFsHCtpgzjsaeIuGYgPxn/vb1bHsCHR27KBan8X0d13Xq9hev29diVlNva3Udmh01sCQBS/02c3PbGB7+REsHfuDAnzfsK5paEASHzs5RPK+nwfkfOdLO1q1WWKrWGRl5lu9/v4Pjx3exd+8gd945SrF4nkplDlVNUS5fQJaTZDLrr/ks+do+euaXp6P/N4tQRI7bcQxmZ0coFMa57z744z8+wiuvtLFjx2vcdVc7U1MbKJXG6e29EUWJ09Ozi1Jpmrm5M5hmkU2bnsHzHkQQAqe8efNz2HYhFH6wicXSpNN9VCo5wGXnzsfZtu1bdHZuR1HSnD37U03w/o+EZewyoqhi2wbF4gSWlceyTEQRArpLgYAdrJ14vJ2+vu2oahrwyOfHAIVkspuADk/F8ywUJUEqtaZK7ZlMrqdSyWIYBvF4O5qWQpIk2ttNcrkyilI/lymGs5MakCFYOAyW2z+uZdoXb8tZcJdSYlrKlmK1aj6e+nGqemSpILicPHnPkqxeH1TlYLW2XNWu5vctx0k2g4fuvPOhhrnwKNO6GK7qq8+i2WGJGs99PZFPKwtek6T2MFh2QqBgzVGDhecFry1urcrfjdbsqBfTPG7eZnDwgQanOze3rSqnGTnu8fHPkEgIPPXUr9Y5+iOkUmt46aUawnrHjteRpBidnbuZmnqD559P8Sd/cjBMnG7nD/9wmhtumMY0A+1jTctQqcxQKk1e8/PI17xDbh51iv5fKIw1sHbJcoyZmSFSqV7m5oYxjAJr1+7n1399Hz/zM4PMzcURRZ9i8TSiKFIsniceb2dqysMw8iSTXfT2Xk9b21Fk+TcZGjrAzp1vsHfvEQzDx7ZLKEoi7DuvIxbLMD7+Jq5rIQg+vm9gmgI33niW73+/Ht5/DFEU0HWdbHYU3wfLyoUobRdJUpAkGUGQ8X0X08zhukbYD06Tz5/D8zxEMVCfisXSKEocVU1g2yV6e2/AMLJs2nQ7rusxMzOC5zlIkoLnuQiCQiyWpr3dIFgQNVQ1iWXlAA9JiiGKMWzboVDwq3SDySS0GrWIFujIIa8UZLQaJxV95sXM3NbmlOfPHDdb8zjVrl1f58SJX6iWXleanV8qa9VrXs75XExScbmfu9zMvhV46NChL4ezxYtnWtemRRrjAvF4J4lEF/n82ZCit7nnG0OWU/i+jevaBOAxGUGQwmTCohHUFY1SLYeta+VyjkvJWjbbzp2PUi73MjZ2kKGhTzI09Gn6+l7lrrv+FQMDT3Drre8iCCI9Pc8wPHwb/f0/5LrrnkGSNH75ly2Gh/exffub7Nz5Dr6/g+7urYDFyMi+hqrk4cM+O3ZMI0kihlHBdS1s2+Ds2SPs3Hk/qppa8Xe9Wuyaccj1o0yGkZ/XxG8ly+h5DsXiBRzH4NSpZ9H1LIqSoq1tE44zRKUyA8C6dTcgijJnz75MLJZBlgNaTNd1qFRyXLhwBE3rpqNjM5bVzoc/fJK77z6Laeax7RSOY/L22/dw6tQdbN36Qw4eHMI0s6EWsUss1oMoxpAkjdtue5vf+q1/ybFjm9ix43UGBn6IICSRpBKWZaGqKqrahiSZqKpEd/dWHMcileoJkeIFTLOI74Np6qhqEscJZp9d10KWY6RSfQiCR2fnbmy7gO+bvP/+t8OMuQNdn8Q0C1UeXUmKIQjJMKP1sW0rZBKzSCR6qVQKZLPBQiDLQRYdAL9aLwSrHaOJ/vZBZ47Dww9w5MjvVh3q7bc/tKhjb86mM5mxi8rOL6WtVvt3qfnuS2WLE3oIdeMwNWaup56qAeZWord99ZiFKMbDwNwNnW0rtLSJ78cIpFdlHCcQgPA8E8ch/NtqPr9e+nChOebVW7PsYq2FA+Pjt/HII9/hwQd/nptuepW3376Pkydvpr//MLKs8fjj/5L+/h8wMPCnbNmSIJnsplKJI0lnOHv2JURRbkhiPE9m06bniMUybNhwGyMjT5JOr0PXZ8jlTmEYOW644e9U1Z+uNbtmHHJUci6XpxGEwNlGrFz1JWkIsuRUqpdyeZqZmRMUi2NIUoxkspvNm+9gdnaE0dHDFApjZDLr2bLlHpLJHhKJdnI5gWz2BDMzw/i+x6lTf4uRkd/gtttm+KmfynPu3Auoapwf/rCfEyduYMeO17HtCn/1V/8VQXB44YVfxfN+kVtueQNZDnSGOzu3EY93UCpNYBhz3HbbHLfe+iaFwgUqlRKSFENRJDzPx/McVDWDZeVJJNaFzjYoFWtaJ5VKDk3rQVXlkGREJps9g2HkKZenAQlVTZJK9aJpaWKxFOfPv0qpNEky2YkoarS1baBSyVMqTeK6DprWQUdHG6KoMjNzgkizVBAELKsQLiC1PnN9v3m1tpyM6oNaeJsdrOMszqUY9aujbFqWKyvOzj8I/uRLYasNkBaqfLRC+c5f0GvWaob16nfCGpKkhipsAdjK8yrouodlVfB9m/kjUcGMcQCiLFHrCyth4CyEDno1FgHEIoYvhRo72PIz5+XJLtYAerW+ts+xY79KMtnNf//vAX7m5Zf/QfCtBYdXXvnN8Np+N2QWdMnlSti2iSD43HjjTv7pP/0PvPXWBnbteotDh0y2bv0YlUoWQVBwHJv+/hs5c+YlPM9mdnbkmh2FumYcctQjjjLkICOuOeBgxMegWLyAprU1ZM/J5FpSqV42b/4QoigTj3cwMPBpTLPE+vU343kOnuegKGkqlRlmZ09SKIwxOPhJvva1f40oOjz5pAz8FTffvJ7nn9/If/kv/29E0eG5536RgYHvNSzoJ0/ezsGD75HJbAQCXmvXtRGEYJRBUeJYVhHXtfA8l2SynUxmN7qeQ9cDhi9RDFSY4vFOstnTOI5BNnuagCJTJJncRj4/imnqiGIgCymKKqaZR1ESiKJMX98NVCo5EolOZFkL0dYGnieQyaxFFAPBDTAxzTKybCEIMrZthA7DQ1VjiKKALAdZcTwenNPLzVi32kyv3hYbF6p/bSWAME2jKtsYZdVHjvwufX2vrcghx5pU9xYLUJZbDl7O+y41c9dyLbp+rVC+3/3uV+qccdRTraGKr73ytYmqrkPXJ6llwi6+b+E4frg2ieGsceCcY7FuXNfCcQrUy6I2OszVIiYdAuavQt0+l+eI67ESC+lQNwdZe/Z8PWS5i0zg/fc/zv+fvT8PkuO+8jzBj98e95F3JhJIAAkgCYAXSJHiAV2kSpSqKKlGU1Psmu6uKdX09E5bHzNV02MzvV1d01aa6bUdG43Zms1um/WWds36YvXWdJXEqhIlkSVSFCmKoniIFwgkgEQm8s6MOzz89v3D3SMiIyMTiYOXiGdGQzIywsPDw/P3/b33vu/7bTYniCsfvd/t/PwjzMw8haJoJBJDBIFDEHjoeg7weeihFb7ylQBRnKBQuB9F0ajVVhDFAEmSMYwSk5P3kUwOMDAw3fsxPjLxoQfk7lJ0MjlAo7EKdIhblcoc1eoCQ0MzbG7Otq0YM5kxBEFgcPBYlP0OtIHctusUi9PtfnPsElUqnUWSVHzfQ5Z15ucfapdJBMHlF784xMMPl3nrrZktPQ1RFLbIvh079jqp1BCNxhKW1WB5+Y1IYSsdeXdKiKLalrrM5Q4gCH5kIKGhqiqu20LXs1hWhUSigGnWkKQEpllCFD0qlUu4roWq6qRSo4yMnGBz8xyiKOD7LpqWYXn5der1JWy7ies6pFIFLKuBIPgoSgLXdbFtE9suAwkUJfxPFFVc14rcqmQkqUEmA64L9Trk85BOw87CB1cfe+05x7EXgYvun3fLtvdCCOt+zblzj3L+/JcIF5dQ2OD1179+Vc5PMUA5ztUrel1vfFCgHEc3EejJJ7+5zXEL6PvzB6/Q1Ru9403xSFNAq7XEduZzONfv+x23p3gtkKQgsmMNna36jzBdq0qeT7gxuLKoT3cWDGwrRe9su/gVXnnldwCB2277t9x227/lySe/SaVyqP155udv63qncHMRr6MnT77L+fP/KZcufZbbb7/AHXf8CEVJkkgUGRm5Hdc1KBSm8X2LZLIYkVU18vkJEokikqQhSTLp9NhHtlwNHwFA7tajTiQKlEqzxDdVWHp+FoByeQ5VTQEhiOt6rp35xscxzXLknzm0jZWtaTkSiWE0rUQmM0EikePUqUv8+MedhWJ4+M9YXS1x8OAqvv9I+2Z64IHvcP/9f8Y779zG1NTzHD/+PK67H10vIopaW0bTMExSqRE8L8xq4w2BIIhUKuexrBaZzAi23URRUphmHccxcByDQuEA6fQgiUSuLf6RTBZIJkcZGTmJaZYply8SBD6aliUIQr/kUENbjmQ302QyIoIg4jitiMEtEgRheUySVDStSDJZQJZ1NjbO4Ps+QaAgCAkKBYVCIUGogR3KcnqeyLUI3feCwnsFxrs91o8dfKU4c6bbpzeUCAwCidnZr17VyFTv+7/fsddxqxtJ7Hrjjc6ct6JsXezvu+8buG6yXZ2I54uBKzJ9P7jobejGZhHxvRH3UkNwFQQn+luLM+AQYH0/wLLija3AtQNvb8QAHIuM7N6A7iXcHT367W2l6N7NUQjgn0NRmm12fKxB/sgj/x2PP/7nfcrZPseO/RWf/OS3mZ29kwMHfoxpSvzrf/2vEQSXH/1I5p/8k/+DU6deRJbT+L7N+Pi9DA8fY3n5dUyzRLW6gOsa1GorDA/PoOt5DMOkWPzoZsfwEQDkZHIgAqDwZuq+4CH4ZPB9LyIgTSIIEq1WiUZjFcuq02yuIooyxeJ0G4h7Z9VEUSaTGaNaXUCSBJLJLLI8wqc/vYLj/GPeeOMI+/f/NQcP/oj5+SyTk1V+53fWmJ29l8nJp9m//3sIgsK+ff8fzpz5Vf7jf/zH3HrrGT7/+TK53H4qlXlWV19HljVs28C2q/i+z4EDpxkePkmttkqrtQHIeJ7H4OAt1OuLOI6B6zZwHJtS6QKFwhHS6eGo5G2gqikSiRE2N8/Ram0iSaGsXKEwTbib9Wm1NigWj7K29joAAwPH2Nh4l1LpEo3GAoKgEWbH4ahUtXoeyyqQy00hiiq2XSWTGaLVCuVAfd/BcUJf01CHO4fjXF0vKo7dFvv3mrxzrWA4O9vr09tZQONFZ3Hx/XV+2s3I4moA9XpjN+GS3jnv6enuxT7s2z/00O+3j9Nt9PHhA+LdIp46sAjvi7A8HVZTWl3PEwgJVuH6EwQmgiDRkZ2M1br2WoHql/12/79MTObaWy/Ypdkc3QKksftWvDnqR+bqzqAfeeR/4LHHvhp5V9s899x/337uJz7xH7nrrhe57bZncF2D73znn7d/J4oub711nHvueRXT3GR5eZ1UaoxkssDY2O2UShdptS6zvv42lcpFSqXzJBJZNC1HOj3C2Ngde7xmH7740AOyKMoMDc1sU+PS9RzDw8cpFg+xvv4utl1HECQEAWq1y1EZQ4nclIba1ow7RTo9wvj4KRKJAoIg4LoOrtvkwQff5fjxJ2m1qqhqBklSqNVMDhx4nJmZp3HdemS8UOPMmS/w+OP/ZzTcLpPJ/M/cdtvzmGYpAjFIJoeo1RYiwlSDZnOT1dWXo/EoEVlWEASBRGIQWCOROAa8i2XVKJfPEQQWspyiVltEknRc18Y0q4TuVYNMTNzP+vrrNBorSJKKoiSpVhdoNDao11cRxddR1RTN5hrgIQgSqqoBOq5bx/cdLMvAthvYdhVBEDHNBoKgtcvdcVlNlkNfaMcpvSff/ZWy2hsVvQpd/SJ+325CV0enN26oh9myohjva1l4JyOLDxP5qdeQo9kc2VKmjjPjD9M5X310l7DjLHenfkQQPceJ2ORp4k1u+BqPq2sH7VaKFlDVFJ6n8dZbD+xoLtHbC15cvJcQZKUtCnRxhM5d/i4ZtMMtt3yfmZnvo2kppqZ+wYUL93Pw4HPcccdPkaQ8oqiQz49z++3v8vzzcls5cf/+pxkYOEalcolK5TyLiy/gOHUOHXqYAwceiASchlhczFAoHEAU1Xa7Lib8fhTjI3HW3bPGjcZqm8yVzU7QaKyiKDqeZ5FKDSGKMqIYOqnEQuR7+XLi1zlOi2LxCJqWxnUdbLtJKtUgm93H2NgpSqWzVCqX8bwWjlNGUbJIkkYQ2Nt2mK+8MsmhQ0sEgU8Q+BQKh1DVFKIIkqQiigq2XSIIAlzXIJUabRO9gsAikSii60U0LU2jsYjjWEiSHHkgt7CsJkEQkEoN4LqhJ/Lq6svYdp1qdZFEIofjmORy+zDNGoZRwvctEok8yWSRZtOLzCf86P0H8TyHbHYcgHR6jFptAVmWMM0yqpqNfJITyHKCTGYs6ulrdMzO92YBdy2xV9LS1cReFbq6QTvuN8uyQRAkKZUOc/bsrxGXJ8+d+2JbreuD0p/+IIGt32fubGQARJaXP9kuU8uywaVLnwW2ZsYfnYi5FN0l4Vj+Mlbj6hfh40HQxLZjHYD3Iixsu4EgiLuOne2mvOU4WycPYiGQOELQ/hd4Xo79+7/PzMwTyHJMJvWQ5TQnTjzL4cN/CgQoykw0fmowMnKSgwezDAz8K15//SAHDjzDvfe+gefdx8TEXUiSyvDwbYyOnmy7O2UyYwwMTFMsHkFVk1G7jojgtfmRtWT8SAByd3RUuDa4cOGHjI7eSrF4uA3asT3XtYqNr629Sbl8jmRyDMNYxzQbDA/fRjI5xOTkJyJT7ASe10AQEkiSimU1kCSfqakf8eKL/037hr/llreQJJVsdh/gUSgcJQiciMyl0WyuYZpVcrl9WFYNy6rhOE1qtSVkWWdwcAZBCNrWkbVaSNDKZsex7TqOYyKKccbqUyottA27fd/DskIih2lWEEWVcKbRRtNS1GobSFJIQInJboIgMzp6G6nUEKqa5Pz55xAEBccxkeUEqppiePg4pdJ5giCg1VrDdVuIoo7vx6XbvdnAxREv3h2FsGuPqwGhGMB2MkToBpV+oN1dXu0sTmHWvLp6B48//p0995KvJ7rHpz7M2eWRI08wPf1tZmdjTWO33TPuvraK8lFU5uqXycZ94u4Ro93ixoDxzhaKBkFwZVOOXuWtuAytKFvnpruBHQImJl7ii1/835DlHI5TRpJGKBanEQSRZnM9SjJs4k2KooTOVMPDt3PgwKeRJJGHH36Le+75c5LJUZrNSURRJZ8/SDa7n8nJe9uCH91J2cjISWq1RURRIp8/2E7CPqrxkQPkOJOdnf0ei4svUastcOTIFxkammkD8LXujtLpEYaHT/BXf6Xzs5+NMDX1NCdPvo7r1rCsEqZZwjSrSFLoGpXJhG5KguDjeS4zM092jXS8wOTkj6lUBHwfjh79VQ4efBDXtfA8n2ZzlXff/Q6t1iahoUQC06zgeWEPSRQlyuVzKEqCIPBoNEJVrVxuHyCRze6LpDOh2VzBMDbbYh+SpKGqetTvtXCcBslkDt+3CQIT02zh++GGQhDEaL55FdtusL5+BkEI2Nio0Gyu4ftNUqkJBEFEkmQqlcvEhhZBEBpThH9oMUN074SUbtATxfdfFETXYXq6vyFCd8a5k6zm3Fxn8Tt9+hv8/Od/B8MYbJfu5uc/0379ldjX12oc0Ts+1fv6DwtI6zrcffcfMzvbkVfcv/+Zbdf2ozPatFskCPu1uzGmb3zs5nUcx07mEr2xVdLUbzs2OU6Kqakf9rh3CSwu3ssvfvEQt9/+Q0DC9z0ymWHS6X0sLb3M+voZXLcBBKTT+ykUDkZs6UFGR4+zuTlLq7WG4xiR256FoiRZW3ubRCLP+vrbpFIjbe0J6IzCxu3IXwbHp4/k2SeTA4yP30WrVWFgYJog8K67TBGPV73xxmf5F//iSxGD+j/jb/7Nv829975Kvb6G79sYRo1Wq4YgCMhyAk2TMc1y1Ft1mZn5C2Zm/hLQcRwVQfBoNtdoNJbZ2DjH6OitKEo87rQfEFHVNKZZIpUaRpZ1fN9lY+MCouhi2xaOU8N1XfL5fZHZxQamuUkQ2JF/cj3qlxcJAhdFSSMIRAztOoYhUSwOcPDgZ1lff5tGYwWAVGoQRUng+5BI5KjXl1CUFI4Tjjz5vgV4UX9eicrTcjSa5ZJKjdJqVemvOrR7dGfGezWkuFF92d4sYqcFKgazXtCObQO7Fz8AQeiwamPBkL0aVlzL59pLj/292OTsNtcd/9xvU9B7rWO9750coq7lvT/4CFtAnZEnB1nORFKZuylkdStc7VWOq9sBqjdr9XjmmT8EtpPi+kli9susV1dv7Xqf7SIt4+M/ZWnpHmJi4yuv/C1mZr6NqhbwfZNGY5NabYlGYyOq0EmAg+c1URQtEk+xWVr6BbKssm/ffVy8+ENqtQVAwnVblMsXWVxcp9HYRNfT5PMHGB4+sWWt75VP/ijHRxKQY9Y0BDesTBGOVy3zve8JSJKG54U79qWlz1MoVKnVFmk0NtoatEEg4nkWipJC17M0mzERIx5nCDPPRCKBoqSp15eQZQXHMRgbu52VlV+Qy+0jkSiyuPgiltXA8xw0Lc36+jkcp4Gq5lAUGcex8Dwb2zbwfZNWq4okpbGsJqbZxHFqDA7OkEwOU61ejMqYIqKo4LoWtl2j0VhmYOAoul6gVJpHEARyuREqlQVEUSWbHUfXcxhGFdtuRgIqeVqtGrpeoF5fJC7D+b6CZRl43hKCIHSNcuyNFWoY8fd49e5Q1+sNvFMWEYPDlYBkYiIEkqee2i5mEc8kDw+/xoMP/vNd/YE/DK5ON0JHfKfY6VgxGMTv3TsDfiXbxZ0ev5pz37mse30hCBmSySGazU06WbGP6zbZKurRjxEdP3Y12phbq1GdrHVr6yS8x/9y2/PjiP8mwL+CoYffvpdfffXrLC3d2/U7MdKv/nXuuOP5aJRrE89zsKwmw8PHCAKHtbUzBIGKYZRIp0dZXz9DtTrP6OidaFoeVS1Ec9kqg4MnaDYXyWb3k04XSSaH2nrgv6zxkQRkuPFlCl3Psb7+TqThPByxBmXuu6/B6OjtNJvLqGqoCRsEHoIgkkyGUpS2bZLJFDGMJrYdW6eFajjJ5AEURUdRNFzXRNdznDv3AzY23miPMb322v289tohTp58h+PH/xrPM1GUDLncEIZRR1V1EolJZFmm0VgjlRohmfTwfVhcfBHfd3Ecg1ZrFdMsASKp1AiDg8ewrAaVyjwDA8cQBBXXNRAED1GUkOUkg4MzNJsb2HYLQZBx3SaGUSOVGkYQJGRZRxQDFCUbMcXDhSOU/9PpWMA16YDx7gIEokjkUNP7HVzN93VtJgrdY0sh8S60+puY2F5S7j7+1FQHtKFjRtHNso6P++CD/7x9rKvJ/t7P+CB1xHvfu3sGvNee8kbHXsq61xpBUKfZdNk+l99vXrk3rn5ssDfijeMzz/whq6t3tFsnO7UB4o3J/Pz90SPhpuHJJ78JdGwTO6NYYvte7vZL7jiduVy8+ACnT19EFAUGB4+zuvoLZLkVTW/UCZ3rfEyzzMrKWxSLB0mnx3GcJr7vUK/PRc+R0PUkR4/+F1hWnYGBaWy7+UtRlt4tPrKf7EaXKQxjkyefzPAv/+V0e5F9+OH/F5/5zCLJ5BCp1DCiqCHLOrXaIq5rIkkp1tZea48dvfnmp7lw4f5o5/29iA1tkM9PoaoJ0ukJfN+J3EksUqkRXnjhBP/7//7lSIZT5r/8L/8+R478KYqSwrJa2HaDRGIAVU3QalVwXQdBCEgkhpAkAVXNoOs5stlRfN9jYOA4llVFkjRqtXmCwMNxylQql5AklVRqGNtuYFk1XNeMdpuDWFYdXS9Gz7cQBJlMZoJ6fQnHsdB1HcfRiRcbTUtGphThxiDMAuLYCYxDNmoQdDLjq1Xo6o6reU3v2NJ2U/XdS8rdLGuAn/wk7K3FIyHhc77IkSPfbZPCruQPfD1xPYD1YcjOrxS9m4MzZx5ldrZ/L77f5m6n2N3c4kZEi3CD2rrSE29QdHssd8rT3fPB/TaCu+mHVyqH2pl1r0dy+PNzCIK2hcgYJzBTU8/heS2y2QM4ThVRFBFFEd/3Iu1p0LQcoRCRTC63nwMH7md5+c3odfvI5Q4hCOFUiizr7f8+yi5Oe42PLCDfyPB9l2ZzneeeUxGEjhyipk0xM3MKz3NYX3+HbDaUaWu1jrC4+BLPPz/NW2/9GgcO/JBMZj//7t/9b9HO+x/xW7/1W5w48YNI4rJFLjfJyMjtDAxMUypdIp8/QL2+wjPP3EK3POe5c3dz5Mj/iSDI+L5NIpElmx3GdT1CdqJKKjWBLMvYdqg5nc8fQNOKCELo3KTrJ1hffxfLqiKK4YyjKAq4rkk2uw9dz1Mun8c0q6ysvEMikUFVs2haFtc1UBQFz7NJJIqoaiqygdSANUKpPw1BkNH1IrVaq20+ceUIM+hEAlqtcCGVpGu3Ddxr9CpyxSBZLh/m/PnOaMdOHsi9LOuxsZ9Gvwl3FefPP8zS0icRBJeVlbuYmHipnU1fjyVkd3y4+qTvb3SDR79e/NWw86/EMr4x0WK7rOZ7GSFjOY69ELd2N4QQ25uVRx75/S2vj3/WtFFE8be4cOE+VNXGslSmpp7i5MnncN0RVlbeQFF0TLMOgOvaiKJIPn+EbHaETGYcUVTZv/8+TLNBtXoRWU4StiHH0LQhKpVLWFYDVU38UvWJd4uPPSD7vsvy8muUSucpFu9r90NDUN5gfX2FEyd+g0rlEqurb0Xs6jRnz36Vf/WvQpLDCy/8PW699Yc9TNxPcdttzyAIYXkGXBYWnmd9/a3I/GIECJiZeYXvfe+r7dceP/4Wudw+RFGNlLgGSafHcN0GQeDhugaVyiyeF5apTbNEpRKWiBOJgbY618jISVqtNYaGbkWWpUgn10FR9EhONECSJHQ9hes6yLJPo3EZ02wiiiqCIGCaG5GxRJpmczm6YiJBIGCaTWAN32/1KBDtLWKTijjeDzJSHDFInjv36DbWb7/o7QVXq5Nbfl+t7t+WdXWXt3vjvcxQr2ce+f1S9bpacl5vVtvdi7/a2CvL+Prj/QLjgH6kyit5GfduTE6f/garqye7Kka7bVZC/sxtt73Arbf+NZIUrw8mrqtTqVwmJLAJaNogiUSWIHARBBHLqmCaSZJJn7D9F/DXfz3En//5fXziE+ucOvUCrVYZXc+hKAmKRQFJGmnLIv+yx8cekA1jk3J5jkZjGdvWEUUf3xcjdrRHvb7K2bPfxXWtqEScZWRkhqWlwbaqjCi6wFaDif37f4RpWhSLt5BMigSBj2UZuK5Dq1WiWDxGIpHjoYdmqVR+l7Nn7+DEiXd56KEyjcYAllVDFCVC1xOHTGYcz7MxjDXK5QUMYz1SyhKx7RbN5gayrLK2dgnf91AUHdtuUK8vMTw8QzKZpF5fwbKqtFpVyuXz6Pog+/efZnX1Der1RTzPRVXThEYXWWq1RQSByBlKiZRwIAhCRxrTjEed4rJZPOIh0PFfjcURrm4++f2IW299AkXZzvrtjd4ydy63gGGMt3+fzc7TbI5/aHrFOwHmbiD4XmfgvZuEKzHEu39/o7PaK4HVexfvZyl799hpYxL2lXfbrITynq5bxnVNzpz5EnNzD0Ztur8iCAxCoaCwlO15LkHgoKoDeF7YCmu1SpRK53HdOs8+u5//9X/9fUTxTr7/fZk/+qM0n/vcKkNDJwkJpGCaFcrluY+speLVxMcekJPJASYmTlEqFfjCFzL8q38lRkArce+9VUBhZSWUogwCB8OoEQQWJ06M8yd/cmfbYOLRR9/i9Om/4vXXDzM5+QNGRv5PajWYm3ueqalphofz5POTBIGIKPoIQoAs60xN3cev/up3+LVfewUI55FlWQPSiKJCIhGqZzmOQTI5CIDrOpFC1yCJRBHT3CSXO0AiUaRaXcQ0a/i+RyjBmSObnUCWdQYGjrC8/HqkCOahKCq6nkeSQta0pmk0m5v4vo0opggCD9s28TyPbHY/qpqnXH43unIKIdg6CEIaRUngOA2CINz5dkA6oNuI4YOIfhlZN4N6p8V5JyYwEBlMhBuO++//X4DQEEFRDObmPovj8L7pWe8lI/4gx4X2Wv3YjZn9/mS173W8l2C8F/GRrdHv3t/+mETI/YjPvfMeZ848zOOP/2nUpvtvughyIrJcIAhsZFkhnR4lmRzi4MFPIYoygiBjmlXOnfsOP/1psd2yE0WPl18e5QtfaKIoKpo2TLO5iiznP9KWilcTH3tABrDtUDby858v8e//vc7TT9vMzLzO/feHxt5BkCKVGuPSpacQxQSNxipTU3X++/9+iTfeOMLtt1/i85+vUqnU2bfvj1hdXWyP9MgyLCzMkskcoVK5SDo9jCwXIiNukVptKVLGytBsrlKvr9BqreF5AZ5n0GyuMjR0HEEoIMspZLlBPj9JLjfJgQOfZm3tbVx3kkJhCl0fpNlcJZOZJJbDTCSGWV5+lXx+iuHh4yQSRRqNJbLZUZrNZRYWXmR9/QyqquM4XmTV2EDTslGGbmOaGwwP3xJJfTZoNldJJIqR8YVAENg4Tsg+72TCcWbsRj+HDPWdSnm6Ho5DiWJI9Ootae81dgKn6wWf3l5wP7vGrQ5Ge3d9ulLsdu7vZ6n/g4wPLqv9KMTWeeQbGx47bST6E+T+EkEQUNUEspwklZpgaOhkJJPZZHr6V1DVJE8//c8QBJWDB5/jRz/6nXZic/q0z+joSWQ5GdnPVikWpz/SlopXEx97QDaMTYLAxfNcFhdf4eDBBX7v98aj+d00a2tvks8fJJUapdE4huPYJBIZlpcvMz39p3ziEzOAT7kssbl5Dtu2kKSQrBRaJIZAY9sa6fQEsqwSBAG23WJh4Vk0LYttN5AkFdNsRuzCo+Tzk5RKl2i11slkxsjlDqAoGtXqJQxjg1RqkErlMoIQ0GwukU4P43lL6HoBEMjnD1CtzmNZJYLAj+aNtcj3+QyFwmHS6f2USpcIAg/f95EklSAQIpenUG4zmRwmkciRSg3TapUJApN0egBJSqAoCo6zTNhXtlHVAun0IM1mBcepRcIi0Fksdl80rlc681rAabfscm5uZ2ZvP7JW7wK1E0nsSj3UX0ZAvRnvZbxXYNx/Zjt+rNfHemrqeSQpH6kFJkml8uh6Fs8zqVYvoqo5KpWLzM8/T622iGGsMjPzV/z2b/828/MPcc89Jb74xf1kMkcplWbxfXeLb/3HIT72gBwPmdfry6ysvEKpdIFkcoB9++4llRoAPAxjmUOHHsayyuh6lkZjg6WlX2AYJRqNH7eZyIqik0wWuXx5g0wGVDXM+HQdRNGhXl8kn59EklJ4noUoquj6IIODx1lefpVWa60tcnLw4EOo6s9oNJYYGJghm52IVLFAEPwoU10kCARyuQNoWoZ0eoKNjXdptUpoWh5JCueK19beIpOZQNNSgE9oUVklCHxyuUl838Z1bVqtBrIc4DgBrVYdXc+j62lEUePs2b+i1drEcVqRr3KRWi10jIozX9c1oxGU2IS9m31t82HrIe8G4L3M3rgcZ5rw7LN/xPnzX6JQOEcms8SBAz/k6NEntvU6dyKJwe4CJ+9FlnsjzCeuhyz2YZTzvBm7R+/Mdj5/nvHxl3n77d8k7hEfP/4nZLOLUSvhu6jqMLo+SjJZACQMY4NEYohi8QhjY3diWXWSydFovRpDkpJ84Qt18vlfsG/fJxgdvR0Ay6oBkMtN/lLPHffGx+eT7hAxnV7Xc9h2A1FUkWUtYiILJBLDeJ6JaTbJZidoNjepVi/h+3Zk4NDEsprIsorjtEgkkuzbN8jm5gayDK4Lg4NFEgk1mrM7yNDQEWzbYHn5VZLJQWy7SaUyh2XVSCaH0PUCly49i6YVyGQm0fUCkiRTLs8iyxq6PoyuZ6hW50kmB1CUIpnMfgxjBV1PsbHxLkNDDpKUwLKWUdUMnufjOCap1BBB4KFpOQRBpFA4TCo1yMWLP0KSAlxXR1XDz6+qSRKJQmROIaIoWYIgQBAk6vUlRDEBmEhSEs9rRhKma9h2CxCRpAE8r0QIxDH5KwZlgbA3tZuc4AcXO82rPv/8H0UzyAFra6cAf8soTj9pSLh6EHqvQPla43pL4zdB+KMXW6U4w/nkSuUwHYnPgLff/s32ZlUQ0qTTYySTeRQlSal0DlXNk8/v58iRL2wxgkinh5mdfRJFSSEIIq3WOq5rsbFxFkEQGRm5LZLv/WjbKV5tfCw+ZaxTvZvKS0x6UpQElcolPM+h2VylWDwUKcgsoChpfN+h0VhGkmSSyTxC225HIpMZolCYZmiowcrKHM3mCpOTk4yNHYr6vxrV6gU0LUuzuUqrtYmiJMjnDzI4eAxVzaIoGq1WmURiEFnWsCyLtbU38H2fZnMR2zbI5SYQBA1BuIzv+2jaAOXyWQRBo9VqkE4P4rouokhEqAhHp+r1RWzbYmzsE4iiQKtVYnr6V3jzzf9Iq7WJZTVRVQ1NK6AoOoODJ7DtGolEDsMoIcs2uVy4KXGcBqbZACRUNYnnSUiSQhAIQJ1QozuB4xQi0ZBYbD+O2MT9xvW/bmQmthOz9403/gZbNxfilvJ0DMJzc6Gd4G59T+cK49sfft3mm/HLHB0pzvh+j+/5zsyyIHjtzaqipBgcPIKiJKnV5ikUDqMoGQ4deoiRkZNsbs4SBB77999Hvb6MrueRZZXFxVcwjHWq1QWq1Utt8qrve5hmlcHBI4yN3fGxAOVf/k9I2CeO7bp260fE5evBwWOsr58BoFCY4uc//xb1+iKDg8ciSbdixGAuUKnMI8spDGOFTGY/iUSOdPqWSJ0rhSznsO1NJCnB2tpbVKtzlErnGR+/G0EIMIwNDGMTWdYYGrqFRmOFVEphYOAI2ew45859H/CRpATNZhlVTSAICiMjJ9G0JJnMKI5jc/nyC+h6DlVNYhgraFqORmMBQVDRtGw07hReB88zSCYHsO0GtdpClP0mCQKBdHoo8pUWkWWZRGKKUuldbLuO74ekrUJhP6XSeRTFwveFyFrNR5IkFCUUF5EkHUFQkSQvOqcS/U0obmz/63pKqdDJ/GJm7yuvfJ3YKODpp/8oyhDiCMe5usvT3SIiO0kz7tQ/7lYD282E4iYof1RidwnZD3tsdXyKQ2By8jkWFk63BUXizWouN4GuZymX5/E8F10fIJMZptlcj9zoqqytvcOBA/eTSoXrTL2+jG23cN3D2HYdXc+gKGkMY5OVlVfxfQ/XbZLJjJHNTnwg1+H9jI8FIOt6jmZzHV3P7fic7izaMDajfvAQ5fIc1eoCtdplUql9JJNFNC0deRyLqGoOQfAZHJzG80IlKsNYi0wnQmCTpGFsu4YgSDiOSSIhIggK2ewU4GFZDUyzjG3XCQKPwcHjjI4eZ2PjPIODx8jn9wM++fw+TLNOuTyLIATs23cPlcplLKtEtXoZz3MxzU1836NUeodcbj+ynMRxmjQaK5FbE4iiiG03UNUMtdoKltUgkxnD80wGB0+SzU5Qq13CtuvYtkEiUUQQJCyriiAIKEqS8fG72dx8E88TcV2DZrOBbQuEZhMCrtvEskoAqGo2cnaJAfn6F6oblQn3A8Fu0IuFEjpm7J3suFA4y/T0X25hWl/JTnA3MN6rM9QHETf7wNcSHw4wvh4zDcdJbdGsnpj4Kb/7u5/izJmvcOnSr3Dw4E/wfZmnnvp/88lPrrFv32UymVE8zyaXO4BhrLK5eZbh4VtYWHiRSmWeWm2BqalPkUgMRCOly6RSY1hWBVEMmJo6zaVLPwYCFCXVdsD7OMTHApBNs4oghP+m0/1XkkZjlVJplnx+ClGU0fUCyeQA1epCJL5RY2Xl52Qyo2QyE4hiOLJUrc6Ry+0nn9/H6Oid0TEO0myu02qVsO1aBMKFqMw9gOM00LR0ZJWYRJIS1OuLrK6+iuNYaFqWy5cNNjbeIpOZJJsdp1y+iChKNBpL2HaN5eVXEYSQNJFMDjM0dAuiqGJZVXzfIZkcj4woBlHVDIIgoet5kskhwEdRkpFfcp0gcKOys4phrJHP7yOZHMZxDILAJpOZZnT0NjQtw7lzP0CWRRzHxPNETLOGLMfmGS6O08L3LYIg7ht7eJ6L5zW6rnboDCUIGkHQ6Pt9hNFffjAGBs8L2ezXmjWeObMzCJpmbw8tttSLNxMCn/vcP94Gmr0iIhMTz+xJlWonz+V+8UExtD+MINxqhVro1zMq98sW3QAMXJeZxnZFr/8l+o1PENgsLJzguef+BwTB5cc/lslk/i1f+pKB73uR09MmjcYKly49T6tVASCZHEbTciQSBXQ9jyhK7N9/P5XKZVRVZ2HhZZaXX6dcvhBNmOyj1SqTzU780petf7k/XRRXypBjLWvfd2m1yhFwDiGKMiMjJ5mYuB9R1DGMDQRBxvNcxsfvIZUaIpPZTyZToFg8QiJRwHVtFEVH1zN4no3v25EIR5Zsdh+12mVsu8Xy8suMj9+DZdVpNjewrBqynIrOJ2Qkh6NXdQyjhOe5rK+/SxD4pNPjaFo4T6zrOcbGbsN1HS5f/gmmWUbT0rhuHcuqYll19u+/j2LxMEEQzgR7XgtJSiBJKoXCIRKJAZLJIVZWXqZeX2Np6WWGh29HVbOYZhlFSZPJjEX62iZrawt4nkWjsYrn2ShKAknSSKWKqKoeubuY+L6Maa4Qgtl2cA3nlncLddtrIARiUQzBOI5rsRK80phSr51dJwROn/5G20QCOpn29PQPeeyxL3P+/NYZ5StFr+fybgzt9yL22q/+MGXJ3ecSbrg/+HO6MXHtFaReZvTRo98m9ucGb1vF5krRT5RluzGF1/4beu21/fzGb1RQFA1dzzExcQrLaiJJEvX6ZWRZi6Y9whbh4OAxEokC2ewEmpbj3Lnvsrk5i+M0KRYPI0k6kpTgRnjefxTiYwHIu2XIrmuysPAiipIglRphYGAa06y2+8myrHP8+FcYGDhMvb7M0tLPMM115udfYGhohvHxSTzPZmHhp5GLUxNZTkZApaNpWaBOMllEUWQ8L6BSmSWVGsWyatH4k0A2u59MZiSaA9aZmLibwcFj+L5LEHiYZoXBwSMIgkouN8Ha2lvYdugglcmMY5pV9u//FIXCfjwvYHDwGJuboTyd49hoWhrLqqLrQ2xuvsm+fbfSbC7jOGFW67otgiAgCExarTKmWaZSmWubY9RqF0gmh9H1ItkstFqhaTi0cBwXRSkwOHiETGYfFy/+kCCQkGUBSVLwvH6CIL1GyP2Uhvr1nLcC8c7f+ZUX5yuNKfWzswOfY8e+w0MP/QEQvkdvpv3YY1/moYd+/8onGUV3z3onIL9eH+jdYq8+wx9WERLfv3pf7Q93XDsg924ym80ROiQsCUXp/zcVR295u1+5e27u4W3GFPH/j47+Gb7/ILbtRu22A22/gFDfoEW5fAlVTSOKMpIkRxavIRQpSjJyoRsmm92H75soioYkab/UPshxfCwAOf4i+32hm5uzGMYGul4gm93X11VElnVyuUkkSSGRKLC6+haKogECqpqiVFrFMNYRhADPE5Ekj3R6kHz+YCRnucTy8suoagFZligWD0fewh6O0ySbHafR2KTRWCeZLNBoLNForJDN7mNz813W1s7ieRYHD36aXG4Sw1hnfPwuPO8k5fIcGxvnkCSJRGIATTtBtXqJcvkcIyMn8DyXUukCplmNKgUbiKJCtbqIYSxSKs2RTBbxfYehoVsZHDyBZZVR1Ryua+J5fmTNmMeyagwO3kK5fAFZ1nAck2ZzDU0rIopQLp9nZeUNHKcBBKTT+2g0VtjcNBCEULUsmw3LvpKk4ftylzFFP3LX3uUA97Io92Z3vSAI8NRT39zST+5nZzc8/CZPPvnN9iLVb0RqN3OJnWJm5om+r7tam8n3EyT34l/8XmbVcbn6wx9XA7LXTnTs3WSmUqtdoOnhODur7/Rm1+PjP2Vp6d5t5e6pqad48cV/2H6PRx/9tzQaHpOTf82xYz+lXB5nYCAkP/q+y/r6GQRB4MiRR6J1KBONiBbaugsQEm6Hho4TBOA4BgcPfirisBQ+FuVq+JgAcm90E7hijVRNy2Ca5R1tvjqgPhj1f8PHW61NAARBIgh8MplhTLPM2tpZkslRBgeHWF19k2ZzHdtuMj5+N0EQgqSu53Acm1ptKeoHh8IghrHO+fM/QhQ9DKOEaZbI5Q5imlUSiQL1+ioDA9NYVh3XbWEYZYLAZ3PzArqeRRBkCoUjJBJFDGMNw1hDFGVqtQV0fYBqtRSRtBrIcqJLK1tjauphVlZewzBKiKKIIIhRqT7MDkul8/i+i+fZ6HoR122hqjrZ7AiNxgaGUYnUzNLU62WWlw0Sic7CWa0G5HIKQRAgih5eG2/7LVb9FzBd7/QOQ7OLEIx3A+Xd2NRTU09sI1V199q6y3aKYvDcc/90yyLVuwiWSoeZm3u07xzy9Wa4V+uU9H7FThuBK2XV1wPW8bWIv/P3biNyI0bzrn/X0K2Q5TipviSt3hIzwNmzHUeznbyR5+Y+S6l0aMvc8dLSPeGZ9xAUZ2ae5LHHvsrCwsOcPHmRO+98HssqY5o1ms0Wly//lPHxU4iiTKOxGkntDjAxcXt7trjfGGrcIkylhoAQoD8OINwdH4tP2z32lEwOsL5+pt2/TKdHGBk5ieuabG7Wd+wzx0AdD6nHAN1orKJpOQxjg/X1N0ilBjHNKtXqBS5etHBdA8OooetZBgaOMjl5L5ZVJ5Eo0GxuUK0u02qV0PUhpqY+QyIxwOXLP0WSQpAXRYFC4Ugk6OGzsPACplnFdQ1GRm4jm51EVTNcuvQczeYykpTg4MFP47omQeBFYNtC09LIso7nWciySiYzztjY7di2QbF4iLm559rSdiCh6zkymQlarQq2XafV2sT3/Wj0yUVREpGs5gCt1iaCsJ90ephKZQlFUWi1aoCFpoU9X13vgCcQsSZ3TmmbTXAcH0GAXPSVmCZtAI8BPl6Mu3+Gqx9/uhI7OtZSfvLJb2553iuvfJ1i8eIW+7pz536Vs2e/wtGj3+bUqT++qp7dXtjM72X5ut/7dP//jXzPG1ECf++rAbEO+24CNlv9iN+LiLPXmM8gCN6OJK1e3e+djDnOnHmUV1753S2AHUa3S1v4/x0wDwWCNK2I74MgiOTz+9G023nuuf38/OeTPPSQwmc/O0w6PUKjsYooytEoZXj83byNRVH+WIw37RQfC0DuLll379i6S9h7YWLD1psppuKnUkNoWh7XdbCsFqOjd5BMDlEoHGR9/W3K5YtIkkyhcBjLqjMwME25fCE6lyVMs0oud4hkcojh4Vtw3QaJxDCua5LNmhjGKoXCQZLJIkEQMDBwlHR6FMuqI0ky1eo89foipllleHgcyzKp1d7EcVp4nkUqNYpplkinR4EAx2kwMHAISUqSTHr4fsDg4Ayl0lkajVVarXUmJ+/nyJFfoVg8wuXLP6PV2sA01/E8G00bxDQNJKlJKjWAaVZpNBYJgtBBSpJSiGIVy3LxPA9ZDgFUFONFOEkoHgL9so9WKwRYSQLLgkYjLHf7fqh8Fh8vBmVBuH6GbS+paieLv95suNs/9ujRb29Z2M6efZSzZ78SZdFP9B2xuhrXo6uNvRDdrlZ85P3aDHx4InY1i93K4n+779n3fiRnK+M/9mvfvnHsjjDzfYipqad55JHf3/a7EODDzxFvMI8e/QtWV09SqXTclQqFC3zhC78XvU+Kp576Z/zwh/8Q8PjJTyQ07Q/R9Rzf/ObvIYoezz4rcfKkzec/38mCPw793xsRHwtAjkHUdc12dpxIFLaUTXQ9R72+HOkx95dq6y21GMYmpdIsEDA0dBTPa5FKjaAoCdLpEdbX32n3nzOZcbLZSYLAY2Hhp/h+QKtVZXj4ViRJoV5fp1KZpVCY4vDhLwAhO3xh4ackkzkkSUUQJFy3heclkWUd266TSAywf//9tFplLKvOxMR9ZDIjzM4+ie+75HITkSlE6OQ0NHQUQYClpdcBIoGTIpnMGLpewHFMMpkJSqWLpFLDmGaFILDxPBNRlLBtG6gjihKeZzEwcDzSwa5iWVVUNY2uZxHFcCEbGlKYnw/drzwPBgZCPe1Ob1joc51DMPb90HAizqyDINQHj5+TugrP8itlnnu1+Ot+Xql0mHPnfrW9mIULZfd9E/pqnz//GRyHHUvi70XspJEN701WudMxP/rzyy6xB3AY/TgNAZBAFJWogmRzozPmXsZ/2BfevnHsLmt3Wiv/aNv91iuLGWfBkmTRnRmD2AXGSebm/kYExkH7PM6duwtZTrdtayXJ5+mnHR544MpiTDdja3wsADmOzc1ZTLNMMjkYAWqnjL25ORvJR1aRZb3vTdSr+JVMDlAsTrePoappms1wFKhWWySRKKKqKcbHTyHLGsVi2PcNAo+NjbcIAhtJUkinx3FdG0FQSaWG2qWezc1ZNC0TjWKp7U1Eo7HaHkMaHAzf3zTLrKy8RT4/geMYpFIjyLKKJKns338fFy48jW3X2Nx8l/X1d9ncfBdVzZJIFJEklXz+ABsbZ0mn97G+/gaqmqPRWMbz/GiT4pHNTuB5Nqo6hK4n0PUiQeAzNHQc09xkc/MCoijjuiamWSUIXAYGxkinw/I82KhqKDDSie29NaELo31/a584BmZhO45fMa4EBnu1+Iufd+bMo1vKfbfe+i18X2B29lHiTCoIJPbvf4bXX/9d4kUvzmyALQzWvQBXL+u1d/RH0654+lcsDe/l91cTHzawbjY7FZYrV1YUZDmJ69boZMICHZAOgVqScgSBSVj5ufEss14ew9rayUimthO940gxaPfLpHsrPUePfgdZtiLjiPD8JyZe4vTp/4WZme8DCVKpYS5f/nybJBbf3yMjf0kuN4bvfy7ihUg8/HAorHQzM766+KUG5O6MFkLiVj4/RSJRwPdddL2ArudYXz+D51kkEgOkUjvfRL1s7e5+h++7JBIFFCXB0tKrKIqOJOkUCifbpdVWq0yhMIXrmhw48Klo7CnAdeuMjNzOyMhxstkJGo1VFhZ+gu97JJODqGqaWm2JfH6KVqtMtTofScylaDQyWFYdy2ri+3bkbZxB1/PkcvvwPJdMZoyDBz/Du+/+BUtLr2PbFVqtCtnsOLncJI5j0Wis0Gyu0WyuYFlNXPcC4+N3MzBwFLCQJBXXjYVMhCjDL6GqKTKZcQRBYXBQw3GabG6ewfNaOI5JqXSeRCJPIiEDCq1WnURiBNdt4TibNBpBm5yVycTXObSsjEE3mw3/jf2S4drMGuK4EQt/DIynT38Dx0kyMdEZVZqd/QpxJnP69De6HgsjCGQUxdjCaO1V5uoHir0s2BuRZe/UF36/2Np7fY/rUZvqDtPsjM35ftge2R2UPTrmKHGIJJNjGMYqYTYsoWkihtHgvQDjOLo3gnH2G7dEetn+4WxwZxwpzqS7r+Njj/0nzM092K4I/ct/+XO6leg8T2Fm5gnOn//PuXDhU9xyyy84deoyTz0ltUH5M5/53zl69M9JpYb4u3+3xuLiw3z5y5P82q8dQZZvZsZXG7/UgNyd0QLYdh1RlFlefgXf9xkcPAaEAhWCILWzUwjJWruZUfRGrPQVSmZmMQwXXc+2yQzr62cwzXKk6VpDVVNoWjbqI6+RTo+1qf2ua1IuX0RRUoyN3UG5fB7XtSmXL2BZZVzXwHFsTLMeDd3LFIsHyecP0GqVsKw6udwEjcY6QeC2NwSWVcOySgiCzNDQcQYHT5DPH2Bzc5Zms47rNsnlpqhWf4YgiFhWHU1Lcfz4Y8zN/RjDWEYUgyh7XgSgVDKpVObR9Sy53H4MYxVB0FDVNK7rI4ohEUxVk5hmgyCwCQIbRcmzurqBphER2MJecToNIJBMdi9s4QJxrX7JN4I81H2MbkZ2EMhbwPTIkSf42te+zPx8OEp1661biWDgMz39nS2ShFdS5oqjd7zq/Pn+41W6fnUErA8rczuO92IjAuHmzr1i+1fDdW26S9WKkkfTshjGJiEgE4Hx+yPvuJMT2XZVrXCz2E/QI7yO/wmPPPLfEW8ijhz5K1ZWThGD8pEj341e828QBJfnn5f5r/6rf8Tf+3v/mNdem2Jq6kecPPks+fx+JEnnxIkn+dznlti37x4WFjY5cODBjx1L+nrjl/pq9Zs/dl0TELCsepThJSmVzjM8fKI99gT0NaO4kklFmJGXotJhtu3pKYoyiUQeAFVNtTcAMfM5BMsGFy8+y4EDD9BqlXEcA0VJRXPGF6hULpBOj5DLHSAIRBzHwLbrVKsL5HKTDA4ew7LqCEI446vrOXzfY339HTQtTTIZEs9SqTFEUUKWVRKJQSqVS1hWg3p9EVlO4bpG9G8dx2mwvPwa5fIcjcYirVa4kfA8h1argu/7uK5NELhkMuNRhn4W1zWR5TT5fArP8xBFiWZzA9f1ACdycdlAEDqqW54XM7CzhIIgAaARlgZjL2WXaxk/6Z5TvZZSd29cSebyyJEnOHLkiTbo9y6Ut9/+LRSFPXsnx7FXv+V4w7ET0F5v5vt+l5p3AqBrie52R3zv7R4uW4E2hSyHFatOn9gDatd0PnuN7sx2JyeyK/Egtl/HT3P8+FORMqDfFrs5d+6LHDnyXR566A+2TRW8886t/J2/8x85fPhP8DwYHr6NqanP0WqtAyKTk/eiqlk0LfOxUNa60fFLDci99PrusSXPszCMEouLr9BoLKFpOUZGTm4B72RyoF32VtUU9foyiUShb0k7nR6h1SrjeRaWFTKIfV/cwjBMp0cxjHVkWUfTwlJzKlWgVrtMuTyLrudIp0dIpYYYHj6BoiQxzQqu20QQAhqNRXR9kExmLCo7N2k2VxFFjWp1AccxEAQJVU1QLs8BYeYuCBql0l9Fto4Fksk8k5OnKZXmIoESn1xuiiCwSSRGCAIHy2qSz08jCAH1+gq12iKKkkJVc9RqKwiCjCRJyHIokCJJMoKg4boNLMtHkhw8T0DTstTrSzhOzKrWCIKw9+Z5Hfa0IISM6s54SQjekhSmxZ4X274J7KTgtVP0A+HrAapevep+wNh9rJmZrVlzDN6PPfZlXn3169TrY7zxxu8C7Mq+vpKaV7/Pt9fPdLUg+36Ss3YCoGuJRKLzOQWBPVRdQrDqRECrtUaH+NRfb/1GRr8Kwe4ExP67zt7reOjQS0iSjO/7xBvgiYmXcJwUExMv9X3Nrbe+S7F4lFRqlHx+H/n8NIlEhmZzgLGxOxkbuwNgS6vwZuw9hCC4ss5NrVYjl8tRrVbJxg29j3DE6jHl8hxra2+RTg8zMHCEZLJIrbYc7fLSQAhohrFOs7mBaZYpFo8wMnJyx+Maxia6novKWVuH233fjUrU67Ram4iihKblaTbXCAKXZHKYkZGTbQa3bTdYXHwZSQol50xzE9tuIggStt2g1dqgVJollzuAKKokEnmOH/91Ll58NtpExDJ0A9TryzQaS6RSE2haksnJB2g21yKZy4BUahhNy6AoCTY2Zmk0FhDFcG65VlvGNMvkchNks/sxzRq12kU8z4w2CPvw/RZBAKurb9BqVVCUFKJINKdcieYRFVQ1gyQp2HYZx6nRaAQEQZit5PMSipLG8zx8P1Qy64yZxIC8N+Wu3ria8u1eXv/ss3/ExYthJvHAA39wxWP0vv7cuUd5443f7XKRCmMv5dgbRar6MMReNwFhhrg7A/7Gh0h4z3UzpjVUNUsQeBQKB6lWF7GslT0e79ru3yef/CY//ek/aGep9977/9g2xgTbSV2PPfZVZma+S1xWj58zN/c5pqae5667XiSRGODHP76FubkH0DSbZ5/9va7X/6fMzPwlZ858ibm5T3PixFv8+q9rpNMjjI+fYmjoOIaxEYkcZRkePvmxniHeLfaKob/UGfJOYRibBIFLrXaZVmsDXc9TKp3j4sUFQEAUJSYnP8nmZjiGBJDPT1Euz7WVvfqpzXRn5P1uzPh5zeY6QeBTLE63ATsIPNLpUWQ5XJXS6RFqtXDnXSqdJ5MZRpZ1SqVZ0ukJVDVBEAyTSITCHa5rUq8vkE5PoCgJgsAlmx3H8zwymZEo+97H6OhxNC3H0NAMq6tvsrLyBpZVIZ0eJpebpFQ6iyzr6PoQsixTqczjOFUURcf3PQRBRBQFdL2AaVbxfZtEYhDHKaNpeer1pYj8pRMEDvn8FNmsh+O0sKw6ogiiKOE44XhFOi0AOhCgaXlUNY/v12m1Evh+nU65Gq4VjGH7Yn89PdNz5x7lJz/5p4DPyspdDA+/tGO2GpcaJyY6s8dxD3p7+d2/rnLs9cQHwXbufs8g2L23v1cG/I2NJNCMfu4IZdh2BVEMN7uDg0dZXNxgb1nytd2/vVmqohhbpFvj6C1Jv/rq19tzyDMz3wE0Zmae4bbbXkIUZRQlxTvvfJHHH/8XfZnZ8/Of5ZZbvs/MzPc4ceKH7Nt3Cl2/L3J0Cz+vIEgUi4eQJO1mefoGxMcSkONSytTUaTzPZP/+TxIEAePjd7O+foaRkZMsLLxIs7mGYWy0yQlDQzMRCMtX7CfvFL4fbgSy2Ym2qHrM+o7/i4E7nR5B1wusrb1FEARRz9XCcRoMDs7gugZgMzn5AIuLL1GtLqDrWXzfZ2zsVKSmNYBtN/E8F3AioQ4d1zWpVi+TyQwTBA6CIFEuX0CS0iQSHrKsIIoazWYJVc2haVlUNcXm5lkEIUAQQovK0L0ljWVtUK8vRK5Pg6hqAlEU8TwTVU1Fc8k+juNEphspLEtEVZOoao4gaOE4YFkr2HYI1snkBK3WGkFQ3+WK3tjYCRS6H4vLy7HS2Asv/JNtgh/Qm7F0mNTdPeitIe5Yju0FzA+bYtb1xo3o7d/YUAGTzmZw6xyy71cplWxgjveiZN3LKo9L1LXaRMSw3q7U1Qvc7777ZcDjxRf/AadP/9946KF/AlgEQYJ0eghNy3L27KltzGxRdPF9mdtvvxhV2QxEMUCWVYIAyuXZSEI4S7E43W7L3SRwXX98LK9gtwzm2NgdJJOD7XEjQRCo11fQtAzN5kZ7pjg2yTbNMrC7YQV0ytOwtWwtijL5/P62UphhbGKa5TbZpPvcDGOTgYHD2HaVXG4/qppmZeUNhodvYWPjHJXKJTzPotXaQBAUBMFnbu4ZFCV0m8pkRtm37z4kSWZ4+DiW1SAIXDY2zrC4+BLN5gaKkmZq6nMIgkelsoAkqTQay0iSFs0YH8Nx6qhqFvBQFB3Pc1DVJKlUaEQuigK23aBavYQk6QiCx/DwnVSrc3ieiWmWmZy8m1ptBdPcwPdFJElH11UgQJaVyA6yie9r2PYyINBqrdIxn9hr7K0seCNBbXn5k6ys3N32VL711tgVpz/5q7cHPT7+IpnMCnfe+S2AbdnPboBpmvRVAOv+nDejX1xJEnMv9lHxvSkACa6W27BT7MYqD9W1YqWurXaKvaI1Z8/+GrHT03PP/Q9MTLzAzMwTCAKk00NYVoXDh3/GD37wG20QfvTRx5GkEY4ff4fJyecQxcP8+MeHmJ19gE9+co3Pfa6E53kYRqXtwBRX9W7G9cfHEpDjiIEyBtXYN7lQmMI0q3ieQ612mUZjBdc1yeen2sPuu+mxApGK1znCEnjnubqew/PctiJY93vadrN9LqEAyDJBABMT97RF2bPZMYIgIJkscOnSMpKk02yuUatdwrIMPM9C03Kk02MkEkMUi1PUaktRJpvDcZrUaiZHj36J+fkXUJQEipIgm53EdW1WV9+gVDpLsXiEYvEQm5vn8X0Hywo3DanUEAMDJ2i1VjHNUEjFMBIReN8aXa8Gy8svEwQe1eo8qpqiUDjMyMhJNjfPUq+vIkkJfL9JEIDve8iyiiynIxcoO2oreFw9q1pjrwvjtYLyqVN/HPV+Y83fTplvcfEzbUDeiRV95Eh/Nuxex3vOnXuUxcUwe+pVAOudZ/4wxwer4uWzuz61RwjYds/jIuE9Flacwgi4UcpcZ848yjPP/E9031Mx6M7NfZaON3cIyt0Vla1M7GeiezQcYRIEj1deCUvYR4/+gsHBd8jnp7jrrhf4nd/5vzA3dz+f+MQ69913Bs8zWV7+BbXaOm+//Sv863/9/0UQXH7yExnP+2fceutLFAoHaTSWMM2Du0oN34yri481IPfqUm9uzuJ5JuXyHIlEAcuqYdt1Qt5bsCsI9/aUQxWvI8DWLDocY3qHIAgVsAYGjiAIYNvNLcdOJgdoNtcBLxpnIio7B2hahrm5H2IYm4iigCgqtFrrJJOj1OuXyWQmUNUUiUQOx2mxsfEuyeQIudxYu+cDAjMzX25n8b7voqppNC1DIjHI2NgdrK29zcLCi5jmBtnsAWRZIZ0eRZLCuWDXddG0LKKoMTR0C7o+yMDALZw582dAgG3XABHLalCpzOO6zUi9LM36+hkUJQEIkbxnCcNYQ5Liuc+YzKUSLn5C17878RAFti+gNz52cn/qZQDvxK6OXaZ6wfaVVzpqXuDzyitfZ2ZmqwY2dAA4NqDfbQTLNGFubndRjQ8SGD+8GbxDf5DtCGdsf/71RWdDFoPuVnnMXvnM06e/setm7vTpb7TL20EgtXXXX3xRRlH+az772VVyuQPceuv3mJn5NoqicflyNhJQ2o+iaNuqPK+9doA77kiQyYwyNnYXup67as2Gm7FzfCyvYD9CVpyRWVaDRELB910EQSKTmSCTGdvi29kveh2l+pWrAQYGpnGcJqXSXARIkEwObbuxu3vWqhrOIxcKIbHMMDbI5w/SalUjoZFSNIakUCweBgIMYx3XbVGrLdJsrlAqzWKaxxgdvSPq/4YWSvHmodFYxXGapFKjaFoGWU5EfeMEQZAnkxklmRwkCFxWV99ElpMMD59EEMT2tZJlHVn2GR+/i3p9CU1LIQgyplnGths4ThpdD4VYFCUROU8pVKuX0bQkkiTiuhaSlEAUWwSBSBA0CRenuIQoEIK0wVbNXeiA+N4jBqPYunGvANENqBMTL+3IAL711nAm+dy5R3nqqW8yPd0fFGMZzk6InD37VZ5++o/agP/yy/8t09NbAVgQgvbP/UawukVMdsu6P7zA+GGLgBAQ443ijYut4OeRz18kkdiMNmq7zxnPzT285b545ZWvAwITEz9ncNDA81zeeus0QSAjii4XLz7I5z73p+h6kfHxu9s+6aIokMsdjByahrnrrkWefbZzfx09+jLgoqpFgLbXMdzUrL4R8bEE5H6ErBhsBwePRexhl1RqEEGQ9mSO3d1T7jadALaUxQ1jE0GQSCbzbWZi7Bvae06x6cXCwotoWppq9TKWVaFeX8VxQttEw1gllRplbOwUR49+kcuXX0IQRDY3zxEEPsnkIADF4hFUNXRjCAK3rZUdBB7DwydIp0cYGzsVMcA9SqXzNBorqGoqIpqJSJKCIKjYdo1kcoiwHK+wuvpGNGcsksvtJ5ksYpobbf9m3/ciZnYe33fwPBtZ1kilhmg2N5AkEcdx8P0AQRCRJA1VzeA4Fp4X9plD5S+3LWIQ3rq9Wcm1sVivF4yuxACem9vZa7nznK1uPmGZ0eXcuS9uWWhFcSsA33nnt7jzzm+1F+le5a4r2UrejN1CoiNM08mKBUFFkpSIVHnjorfFUS5PUy6HUx3dEpnbvz8peu0/bL/27Nmvtn+7uAgPP/z/5M03P9vuFZ848Q7gUqstEAQuw8MnGBw8zuTk3SwuvgrAxsY73HrrD/nt3z7P+fP3cuzYK3zqU3MMD38C122wsPAioihRLE7fnDm+QfGxBOReQlZvxpxO61t8j3cz1e5+vBvcY9MJCFW/fN+l1SrTbK7SapURBInBwUI7k457yb1+zJubs+2Z5snJkxhGAUVJY1lVJEnD82yGh08yNnYHplnl0KHPMT//AoODMyQSBRqNFXK5fWQy45E5xQaCINFqlSPvY0gkivi+G81HlyKCmYQkSTiOQSJRRJaTJJOhBnUikce265hmCUnSMIy1aM5YJJ0eY2Bghs3Ns7Ram7RaZZLJIrpeJJ+fRBQlarVFVDVJq7WB7/vIcpgBG4YXleabOE4TzwtLc5qmoyhZRNHG8wxc1+0ie8X2jfHi6RISbJp8WGIvSlOdxTgW7g/LlUeOfJeVlbvarz916lucOvWtbVlS9/G6y8+9BLLrEdX4uIUkpfF9h1DMxiPmJgSBhevGm8IblyVvJ2XFJiXQPRLX3SsG2u5OR49+GwhoNMZYWrqH7gpSs+nx27/9XzA391kOHvwRMzOvIYqHef31T/Hmm0d58EGTr31NZ3PzYuR9DrncFJbV4P773+Izn7lMIpEllTqMJGkIgtCucsWqXDfL1tcfH8ur19sL7s2Ydypp7yan2Qvg3aYTMaAHgUsiMdAeFQDaxC9Ny2FZFQyjQDY70T6HeA56YGAaWdbJZifa7lSFwlQkaDLQJoFtbMyytvYGup7jwIFPkc93Xh+XwuPy+OjoHQBYVpVKZQ7TrAABmcw+kslBDh/+PEEgIMsq+fwhEokiKyuhbWM2O4HrmjSbJRKJIoqSiZyg0mQyQwwNnWBl5Q1su4XjLGFZLcBFknQ8zyUIbEQxjWGcizZGIrIsAjquayBJOpIkIQgBoqjgOCbgUCweolyej/rT0JkPlQEtcoSSCQKH96OfvFN0L5qK0twy41kqHebMmUe3gGhvX7pbg7hfSTxemP/iL76JojRxnFS7HN7dE+7W1j58+P0U1fjoh+97KEomkqotdf2m2/VpL7Eb72Fr9DqJdSIcievtFYfRbcko9TmqyIEDP+Dgwb/m9tt/jO972LbKD34wyLe+9fcRRY+/+AuJoaF3ueuuUJM/lRolmcyTyx3ANEuEY4gjpFKjqGoK17XQtDSVyibNZtgeg5tl6+uNjyUgd0c8+6vrhS1l5Z1K2t1ymsnkQPtx1zUplWYpFqe3iIJ0jzH1zuvFw/Xxz922hCHAriAIEkNDM1teE5aaXUyz2n48JoFpWui+FLtara7+AkVJsbk52xY1CVXA6uRykySTA9Rqi6yu/gLXNSPnJhFNS9Fq1chkxmk2VwgCH9tuIMtJRFHF9x1EUaZeXwBEFEXFNMssLPwY06xSLq9jWRKiqAIWhrGB74cksCDwIg1hEdf1abVKpFKjSFKK8JYMZ6Udx8D3PVzXbJe8k8kiggArKxU6gBszZi38q5e6vuGx06IZL5bnzv3qlhJkHDuVvvs93k0AijPq7nJ4LyjHzO9+0cs0/zD0k2+Uu9P1hCRJ6HoK1/VwnLgCEzP/97rZU7jWLPro0W/TaIy0R+JmZrYblURnSsy6DiMmnvmkUitMTPwMEND1LInEIEFgY9sGb799HEEIS9ii6PGTn2Q5fXqYqanPkkoNIAgSggDN5gS12nnAJ50eRNMKOE6dWu0y1eoCg4PH2jyYWi00nenlztyMvcXH/orFc8DJ5NAWcAO2Ea26naC6CVxx+L5Hs7ne92bsx9DuzaS7iWMxwAaBu0WkPSafCULHBCMG+4GBaRKJAkNDx9uuUb7vReXoVXzfRZLkyHay0N4QxEIhrVYZUVRIJn1AwDA2qNUWqNUuI8sJ0ukJGo3LKEoGxzGR5QQjI3fSaq3Ram3geRaKkuCNN17jwoVX0XWo1+HYsTzpdCE6pzq+76PrWYaGjkXiIQ6iqCBJKrKs0Wwa2HYF02xG10lDFLV2qb3RCIXsu9WTPkyxtR/cvWiGP9+Ifu6PfvR/pbMIx2bxW4/ZDaw7AdwHab24U7xX7k5XG0EgIAgajhNOO+wcu5WuY/vG/tHve+mVwDx9+hvMzX2WxcV7KJUObeEQRGdKJwsXun4WaTbHOXfu1zh79iskEv81d9/9MsXiYRqNNY4ceZkXX5TboHznnQukUmHrrWNRm4v+7jaQZY18fj+Tk/ezuTnLysobUULjt+WIY0ngK42F3oz+8bEH5H4CH/HNVKstsrFxhkRioK0xHT83zqwbjVVMs4yuF0ilhrcB6F6j9wbeqgzWObfeTL3VKkcZ+zr1+nLb7tE0y1GZN3Y7EkgkCls2CrHISTjfPEkutx8A226gqmmq1XkEQURVU+h6MRLw0ND1IqnUKK3WOqnUKPV6hs1NkYGBE1y+/CZnzz5JKgWKIqHrHuvrFdLpEbLZUVqtTSBkc3qeEymONVGUHM3mZTwvHJfyPAlJMvE8H99vYlmtNgs+CAJEMRFlw1u9amPz+fAaXdVXcMOil5wD9P25t3R95syjbUbtqVN/vCMIPf30H7G0dG/XIwK9IzLd8WEBuL3GjXR3up7wPJdWaxPPa9GRcI03gTFAxxuirbGXDL/3ezl69NucOvXH29jWzz0XyrR2+BKQTK6Ty82zvHx3u0KSz1+kUpmmM6sM3SIiZ86c5MSJv8IwErhui9tu+xG//dt/mwsXTnPHHRe5775jCMLt+L7L4uLPSCQKpFIjQIAkyXiew+rq220Z4UZjGVHUopnl+chPfmRXT/mbsXt87AF5p52c77vU68uUyxfxfa8NjN29ZcNYj0rdQ21S1410Odkpq45L4HHpOtTChlJplmZzjVRqmFRqCFV1KZfnsO0G6fRwG4xNsxyxmE2q1TcRBCHStk1imjXy+X1UKpfJZEZIp4ex7RbF4kGSyQEcpxX1inUcR0UQwHGaKIqMYaxRqaySy/mIoojvS2iajyAEeF6CfH6qDfStVpVGYykim+VwHIt6fY1UaoDh4dtoNJaR5SSt1hquqxICDiiKhmU1kGUZQUgRBCq2HWoJG0aAKIYjTI4TgvPQUPfV07m6cmMnWq1wY7OX0aje8RRgy8+vvvp13n33q1tK1xCrMIXRr6Qdx7lzX6I7K0qlVjh+/N/v2CP+IAHuWuabb6S705VDYecZ4ga23WQr4MYEQpnO+J1Mt0LcXjdAW+fO4ezZsG98/Pif9MmCxS3/NptjNJtjQGeD98gjvwfQV6krCCSmp38WWSMW0PWwJH369BwPPDBHNjsMzJBKDbGxcQbPszGMEsPDJ0gmRxkaugXXtWg2V7l06Xl838W2a1H7q4rjDJFMjjA0NHNTues64mMPyDtFON9bRdfzpFLD7VnduE/c3VvuzjqvpUyzE4P7SucXl651PcfKyusYxjqSJFMqzZJIFNqlp7BnK7czeV0v0GyuR0SucpuwtbT0Mo3GEvX6PlQ1jW03GB4+gSB0SlBjY3dQKp2P5o+9yMZyg2p1IVq8mlSrEo4joaoaqZRNEEChMEw6PUy9fhmQcF0PUVTxvIBEYoR6fRHHMVGUNCMjtyHLCnCZbHYY17WxrAaCEEQMTzBNA1VN4Ps2ti0BThswBaEDnlsjZMxeLSCbZnjMOPPeS0m3t+/bzY4NS6FbATLu+fVj1fZGr5H8qVN/3Pay7QeAuwFcP7WyaylX98sIr1Uj+0q+vrvH3glUYVzpuf1+77NVEW5ruXovG6DtpC2I5+jffvs3OX78T/A8jXff/Wqf8+mwp48e/Q7F4oXoOj0DNHtIYWG2/JnPfJP77nsb3w8BWhBgbOwOFCWBqmZoNJax7Sq23aBYnMZxbFZXf8Hm5iy2XcdxWoyM3EYmM0I2O8Ha2jtUKgvYtkE6PcahQ59GECQ2N2e3cF5uxtXFzau2Q+h6rs2I3jqH3JktvlE9kqs1qojL5cnkIOn0CKurb3L58ovYtoGiZAkCO+oHy4Ser8MMDc1gmtV2li8IRAzsKZLJIkEQUCwewrZDYlerVWFw8BiO04oAXWJl5XXm518glRolFB/ZwHFakUFGkUZjhXx+kGPHUrz00llsu4Wuw/h4EVk2OXfuuxhGKSK3FRFFBV3P0Gwu4bomoZa3hCyraFqOYlHHtmvIskkQhOQux6ljWc1o9ESOsvUstq1gmvX2gq9p3VcszoJi39erjyDYCeT3Fr19QehkNhMTz6AodBHAYDejiX5G8rAzAM7MPMHp099oP78XHK63X/xelMSv3d0p/oL2OpPuEma6XtdrBAQhTRC4dPSquyNgt03dThug7k1LmB13gyt0Vz3efvs3ozGm7vIzPc8XOXXqW13XSSLcKGjccsvz0abms0xPv8rtt/8I01TwfZ9K5TKFwgE0Lc309Bcoly/RalUpl+d5883/wB13/G2SyQK1Wih7G45pgiyr5HL7abU2SKeHGBu7iyBwOHHiawwPn2B9/cw1t+xuRhg3AXmHMM0qggCWVW8/1n2TdbsyXW9cyaiiN3qJaGE2PIEgwL59d+N5DgMD05G0pkQqNYQs623N2XjmeWQkBOmNjTO0WiWazU1qtUvUahcZH/8EkqRFIh1JKpXLrK+/wvz8c4yP30OxeITBwaNUq0sUi0eoVpci/W+bmZn9TEyM02gY2PYcvm9ExhI1XNdAlnORItAIgiDSalWx7Tq6nkNVcwhCyEa3rAqmuUmlsgS4OI6J57l4XosgSGDbZXQ9gSRlUdU84FOpNFHV+Lq2v63o34D+C+yVQxC4LgZ3b9Z0+PBfUChc2CKp+bWvfZnXX/86ALff/q1tIh/d8dBDf9AG4ivFmTOPttW+VlbuYmLipRtasv5ge769GXEvEEt9Hut9vdNzjICtDmOd3m0ndr4Z+mX4/Zn3O32WuEcde4BvzYoLhQsMDb3ZA8Z0vcYhCAJmZr7HzMyTKEoRzwtQVRVZ1lEUjUZjiWx2gsuXf06tNo9tGywtvcuBA5+mVruMZTUYH7+LanUZTRvAsjaxbTPSHtDJ58dQ1RXq9TFqtUV0PY+mZbaIIN2Mq4+bgLxDdFjOXnvH15kdngXY0jO+HnC+2my7F8DT6REmJ+8lkShsyea7zTNc12yPPsWbjThjLhanI4LaCr7vIAiQyYyxvPwaipJEUXQsq4JlNdG0HKKoo2nJqBe8gWWpJJMF6vUEpulQLs+Sz0+SyaRYWlrCsmoIgkw2O04Q+CQSBUAinz9CKlVgbe1MpIktUygcoFw+j+M08H2BIAg1rF3XQlV1LMtAELRIGMTHNJtks1mazVVCYku/K6YhyyquW6dDzNn7KIquhz1kSer8/9VGb9Z0++3f2mYCceTIE9dlDLGT61MvYL788teZnf3sjjKeceyVZLZTRvj+aGRfqeLRD4xVOiAci8lcKXTCrPjKu7J+5fvtzPvuUks3CEvtf0+d+hYjI29GpK44RL7whd/r812Ephep1CiiKNBqlRCEJJqWJJOZRBR9ZDlDobCfVquC6zbxfR9RVEmnx5mffw7LqrK29gtyuf3oegbLqpJKDUQmNwGl0js0GpfJ5SbJ5SZJp0cjzf86S0uvkEwWGBy85Wa5+jri5pXbIXZiOYcRLgLX6ol8tdENprGHcvf7mWYVSZLbv+v+DPHz1tfPRCIkMDQ0A2xnlo+O3k46PRqNFq1iWVVEUeTYsS+xsfEu8Q4+CByq1SUymVEkSWR09A4ajRUkSWdx8adAgKJkaLU2SSQyOE4NSRKR5ZChbVmVSL0rja7nyOXGWF5eQ5Z1yuWLbXbr8PBxBgePARaOYzM0dJwg8Dh37kk8T8R1w5lQ2zYJAgVo0D+bCZCkZCR1GNAZU+n33P6RSOzxy9oherOm3bLf7tjrPO6ZM49uc33ayXVqdvar7eedPv0NHCe17fhxRhfHbiSz3Xq+H4aZ5k7E37dDRx+9d044BsTuUab4NVeOncr3/Zj3neiAcfh9dERhYmGYH/3on9BqDXLy5ON9vwNBSCHLKpIUCukoioYspykU9jMycgcTE5/E8xpUKguRfkCsg24zOHgYUZQ5f/67FItHgYBmc410eoJKZY7Jyfux7TrNZhVFkdrJytDQDIcP/0p7ZDKVujmLfL1x82rtEr1uUL1uTnG81yWazc3ZNpiOjJzc9vu9lLwHBsIsWFES1GqLWxTINjbexTSr7Nt3D7KsI0lyBP4aExN3I4oypdJFSqXzeJ6HKDrk8/sZG7uDSuVSpNqTQxCWyOcP0mzqqKpGpVLFNGvoeh6QSaVG0LQMqppEVTPU62tUKnPttoBl1RFFiVJpFllOIstJDh58EEVJsrb2iyhbT6IoWRxnDVnWEAQHz2tGrG6dUOg+JMd0yo6xmEPcJwwXZEFQCAKL3bOscBFvNMIMWRCuHWR6+6Jx9thtp9gN1HNze+/N9mbBsQ1kDOinT38D00xSLh/m/PlfJTakj0vZvccPrf72RjLr99k+jCEIicisJM5INURR6GlFeD3/hnHmzJeYm3uIqamnr6Bb3r98388hbOsoUwjGO7UhlpY+iSC4PPfcP223HLZKaCpRv/glTpz4AZIko2lZfN/DsmrMz/+IRKJIrbZAq7VJELg0m8vk84cQBIUDB+6LMtxjuK5Fq7XO0tLL+L7DxYslcrmDNBorKEoSSdLbwkSxj7xt12m1ytF/N2eRrzVuAvIO0QvA3QzrbiWu9+OGixW24n93it3Y2rKsk0oNsbj4Eq5rI4oS+fwUqdQQmpYFgrZQSKxapqppZFlnff0M5fJFyuW5SKpzmFRqmGZznY2NM5hmhVRqDEVJkcvpFApTiKJGpbKM768gCD7Z7H4UJUE+fwhFkVlc/Hk0tuWTyewjlRohmx1nY+Msvi+gqilEUWZp6RVc16RavcTGxrskEllct0UQBMiyCqiYZoswO5YigNWQ5SSelyYIbARBjswvFLoX3CDwgQwhQO/UW/YxjA7L2vdvnHCGrm/NbPuB4l57s/3Kxr1EsunpbzM09Aazs1/ZMufa7/gdq784diaZfVQiJGklAJF8/gCSJFKtLuH7W0efeqsSW7Pef7RjVQF2Z7T3OoQ9+eQ3qVQOASKC4OI4/Qfnt98Hn2Nx8Z62tWL8PYXn9/f5rd/6LWZmngRKKIrOhQtPoaoZBMFF0waQ5QRBYKMoaWy7RjY7hmWFXuyFQuj0dPHis2haDts2SKWKGEYJzzOx7Ur0/EZbdz/OmBuNsD2Vz0+RyYzd7CVfQ9wE5B2iPwBfG0P3ekOW9b6ZcRzhuZ5DUdI4TnPbpqE7NC2LJFlUqws0Guuk00OMj59qzw7G5hOua7Ky8gtGRk5gmhVc18L3ncjBaRBNyzAwME21uohlGRhGicHBg1HJi6ikdZJmc4VCYYpMZgLLqqIoSWw7PEah4ERMcJ2xsVMRCEuYZoWxsTsZHDxCpTKPIAik08PUaqvRaFVY4nNdG0Hw6RhJ+IAaqZh5BIGJIGQRRY8wE+mVpQoQBB9NK0SgvnPEYByPPt2o2A10exd3RTF48slv9gWCfmXjrTKLMDv7KLOzX+G++76B6yaRZYOf/GRnL+fHHvsyr7zydQSBtnRjb/RT+op72f161B+U73IcspxEVZPk8+PU6+u4bo3uknW/knM/oY6dqhZXM7IViniEEQQy8/MP8O/+3Z9H/fq/IF6et98HjSjDjpXatirAXbx4P0eP/gmtloXjVJHlDLXaEoIgkEyKjIwMEwQ+qdQo+/bdg2U1qVQuRhMP621hj3p9iWRyEEEQcJzQpS6VGiOZHETT0ltGnAYGpmk0VtG0LJnM2I7rz83YPW4C8q4RAnCcORaLRz40JRjXNVlfPxMRpMB1bWq18ySThR1fE/d0wvEhg2YzdJEyjBKO00TTMgiCRBCEoiPV6qVIDGAF06wiyyq+H+B5JrXaZUyziuOEIh2e59Fq1dG0sHe8vv4O2ewg+/Z9EkVJIssK9foia2uvk8nsx3VNRkdP4fsu5fIlbNtA10O2dCo1RBB4ERnNwfc99u07zaVLf02pdD7KkMVoDEkGdCRJRFUzBIGPLCew7TogEAQGkpQGfHxfjbLizthKEDQx+6FKV3SPOt1oUL5SRtVb5uwGAmBLJtdbNu5kuXFpVIzeJ8mv/urvt8HxwoUvcujQd7eUy+MscTuTtxO9l+3cuUd5/fXfbWfgvVaTV5pLjt9zYqJDSruxoG3huhau22Rx0cD3Xc6c+eKWa9hvg7S9/9u/qhDHzMyTzMz8FdvL3p3Mux/JK1ZfC/v1/wknTjyD5zWYmflLHnvsq8zPf54DB37MxYv30yGAxSRFiK0Vp6dfAhSCQEaSdARBJAh8XNfAdXV0PYcsZ5iefoiRkdtYXz8DQBCIlMtzEfcjTzo9Bvgkk6GMpue1yOf3Mzx8glarHG3qVzlw4IEuXQTpZmZ8HXETkHeIbuCt1RapVOa2uDR90BFqyb6CrheYmLgHSQpVsyRJveKmIWZWj47ehm0baFoGx2m0iWyNRui3rCgpxsZuwzTDWWXHsVEUlVzuAJZVY3n5NYLAQdOKZDJ5bLvK2bN/EWnb+iQSw2Sz+/B9n9XV12k2N8hkJvA8I5pbXqTVKuE4Nq5bR1GmGR/fz/r6WziOQa22zPLyq6hqmnz+YNTzBddt4bomkiQjSSnS6TymWcNxWkiSgOfJyLKGbcuAiOfFGYSPLKuIYqqt7tUxnN85YrZwPIt8I0HiShlVSAh6gqee+uYWoIjVvnbrL3dnuWfPfnUb6J8792g7Q15dvYvx8ZdQlFBB6uzZr1zVXPG5c2HpvZ9eN7ANaHuz6K3l9ZCUduTIE++RrraJ45icOfNlHn/821s+Z78N0szMX/TdGO2sIrb9nurNvE+f/kaPGld3vz7g1Vf/NjMzf0bYZvGZmfk+MzPfRxQVgsDlxRf/ATEoP/TQ/8Hhw+eYnb2b6emX2bfvz/B9IeJraCSTg6yshPe7ZRmsr59n3747SKVi0pWHpuXJ5SYwzRKrq28wMHAU227guk1UNYvn2SSToyhKhvX1d9G0FNXqPI4TlrpTqaFoU5/FNKvtEcubcXXx4UCXD2HEVoWGsY7nhQt3rF39Qfh+9vaHY5JWrMjVbcnYzQzf3gc/h6blkSQZ2zYirV4LTctv+VyVygKh52kKTcvhOE0Mo4QgCARBgGnWqdeX0LQM2WyWRCKPKIo4TgLHaSKKEr7vsLHxbiRkYiEIIuAwOfkgQeDTaKxRq12KNHFVwOfy5Z+Sy+1DklQ2Ns6xuPgikqSyuvoarVYZz7MAAUlKIkkSoqhHWY8FtBCELEFgIkk+up5GFBOEjjXriGICXS8gSSJB4EZ9ZSu6wunos9ldj3XiekEhBnTfDzPubtb2boSoOKvs9TXup/a1EwM6DAFBCLaUni9d2poNvv7615md/SrXYoIRHqvb/i9ol9l7gRbYwgjfXhYO3/N6RsDi6NcP7mSpD297z0ce+f2+G6Te/u/uJWkluoZ++xyeeeZ/Is6swcNxkl0gb/Hcc/9j1+sF3n33qzz99B9FJC8VUFBVBd8PuO++X6Drf4cLFz7JwYMvcOutz+A4NW699Slc16FWC69/vDkfGjqB7wu88MJhzp9/kBMn3mRoqImqJrl48RnK5TmSyWI0urhGq1Vlff1dstkJdD2DYayTTBbwPBfHqbGyMksmM0E+P4Vt10kkQs5JPn+w/fPNuLa4Cci7RLfrk2lW2yYO8P77fvaOWMmyztjYHe3fi6LMyMjJLU5Uvu/26YOHJhOyrGPbDZaXX0WSNBQlQSo11PZitu06qprZsvEoFA4giioDA9M4zo+QZYVC4VBEnBIid6wNDGOZ0dFTEYiuomlhGT0Un5+gVlvgzjv/NqZZZW7uOSRJpVg8jGlW8DybkZETFItHeeed7wACopjEMOr4vkMQyOh6mkRiGFVNIMsKQaBQqZzF8wIURcGyzMhBKiCVGmR9/U3AxvcFHKeK62qIohTNMweEmbKBKGbwPIgtIG8UZyAG45gYFs6Ab3/ebqDf62sMtKURg0CmVgu/317z+u5sNwhk7rzzW+1jTk9vBXlRFLoyNoh1lncic3XPGYeez70iFrC6eusW0Juf/0zfzcR7oV/dLysNe68hEer48T/bkqXG73klxvjuvxdQlASOIwBG1/hYd4lZQlGMHpD/yRaSFwQRo/plZma+zZkzX+bSpYeZmXmZu+76OZ/+9EUefPBdyuUFXn75FK+88l8gijL33vunHD78H5DlNNnsMLo+APgsLPzn/Jt/8w8QBJef/ERmZORfMTHxEzY3z9BsrpHL7SedHiWZHMQ0ywwO3kIqNUi5fIlUagjPc8hkMvi+z9DQcSYm7iKVGo7APEwGQqU9+YZoM3xc4+YV2yW6afvptL7F0/j9jn6jTfF8cqEwhW032/7MsbRm2PvugEq3UIgoytRqLvn8ATwvnEms15fbzy0UDpJIDLSNLEJv1FD1y7abFIuHI9LHEIqioes5NjbeZWHhWQyjhCzrHD78EJnMPnzfZWnpZ8iyjiBImGaZ+fkfs7l5nkZjBc9zcJwG1WoooSnLWQyjRBDYJJODWFYTcJBlnWJxknL5IqIoIEk61eoStt0gkciSzRap1VZptUqAgygmWF8/S7jAqZGBRppWq4TnhVKakpTB902CwMXz6tFzY+OA2Elqtx5zPGYlRK/bLh7h+yEgS9Lu0ptXKs/GwiHxc44f/xPefvs3iaUW/8N/gLff/s02AEXvDvQvIU9N/XCbCUY3eE9MvEQqtbrtPPrNRgdBiq2gE4JuOOvaAb1q9TAjI29sA8Lu0v3Y2DNX2UMW6Ih9dK59b9Z97twXt5zj22//+ra53+sPMWJzu9vOoXNdvG2M6vi9Q/DuPG9u7tNAwOOP//8iMP27wN/hk598i0xmnNdee4DHH/8X7eOcOfNF/ubftLj33tcoFqfwfZdabYmf/ewLW67Fa69N8Df+hgEcQ1XzNJvLrK29jSyrZDLjZDKjAFhWhWbT4MiRL+E4LXQ9iyRpbVGkIHBZXHwZRUliWXU8z0WSFOD9T1p+GeImIF9FfJBzdf3eO55PNowNUqlBoAO6sRPV4OAtbRDvPUbY+xmmUAjt1Or1JWq1ecbG7mJ4+GSXq1VI8hAEuZ11K0qKgYEjKEoKy6phWQ0sq0atFo4+tFplHMdmevphLl8OxUJC0oeIpmUplRZYWnqZVqtMPn+YWm2ZZjME083NCVqtNTQtz/DwrVQqc5TLc+RyE1hWHcuq0GiYJBI1KpVlwMa2G4iigm3X6Ij+a4hiWD4MAh1ZVmk0qoQLd1j6lmUZXZ/AspqYZoWQsS0hiiq+79EREIFeq8fom6FbAxmShCNY3d9dp1zdbVIRl693i93UrkqlI3TrH8/NfaanJxmfH8TZbncJOe6bPvLI77eP2a9X2i0K0o+FHJ7LIbpVpuJxqjvv/BZ33vmtbQ5X/YDw2meZA/q1GXqz7iNHvsvKyl30AmP3599LhBuSzzM19YM+5+vhuk3ie6JDrOu+LlLfCkCsOR6PM4XP20oAE0WXCxfu595738Q0y5w5c4reefHLlz/Po48GNJvrJBIZSqXzjI19myD4z9rHOXVqEVU9wNjYnSwsvIii6GQyY7huC9OsUSrNks9PkctNRn9zdRRFxzRrWFYVCNeaZnMdTctgWXVCqeEqqdTIzbL1NcZNQL5CXIsT0/sVcR853rX2ZtHd59zvc8QSmrbdbI8tKEp6i8Vjo7GKrufaTPM46w71sSdR1RQLCz/F82wymQlGR++g2VzH82xKpfMYxgaGUWJk5HaazRKWVWJg4DCSpEc7bAgCk2RyilLpLJKkUq1eRBRVisUh0ukhSqWzQEClMo+iJJCk0J95Y2OepaV61CO2mJ5Ok0wGhNmSTDY7Qj4/TbV6CdNs4ji1aEEykaQ0spxAlpPYdgNNS2GaJUJws/F9ObJydOnIK8qcOfNIj0BEN3nHYTdFp9gaEojKe3v7nnfKEntdn6amnmlnyL0GFseOfYc77/zWFWebY1DsHpnqfl7v67vJZQDHjj3B8PCb28C293XXAoS9cSUVs50Ic1sB75mrfs/OhuQfdBHeuuU4txK6QpOIgJGR7delV4u7YxzyKEeOPMnMzBNIUpoXX5QRRQ/fl/nkJ8uMjJykVrvE5ORTwG90vZvI8eNv4roNdD2NYZQAmcOH/wOf/vSdXLz4KHfe+QYPPngBTTvOxsZZbLvB6OitDA4eo9UqUyqdxzSrVCqX0PV8e5JD10O2tWVV2utJLMWrqik2N2e3yffejKuLm1ftCvFeymPGN3Xco75a0JflcFdrGOsoSqr92n7ZdL/P0Q3chrFJKjWIIEjt33e/Js66VTWDpuXxPItWq9y2d6zXF8lkxjl69Iusrb1DEDgIgoggBBjGOkHg0GqtY1k1KpWLNJsbBIGDLKfJZKZIp0PwrNXmSaXGWV39GeXyeRRFi8hcLqKYoNHYQNOyNJtNFhdLqCrYtoyiBMzNLXD06ATZ7ARBECBJCRqNpWhUy0AUNVw3LG8KQgJNy0Y622GJLZUajDSxbUBAVTNYlkGo+BVw5syXePzxPycWiNirq1Gc5XpeJ0OOQTbOfn0f5uf3JpMZRz/XpzNn/m1fH+bu412pV3vmzKOUSoe2CIcoSlh16M06e/vBhcKFvmpTN7pHvFeHqd6s+6GH/qCLlPWjSEDjyu/Vb1xJEDyeeeYPo/d5ml4HqF5hlu0jZHFFoRNPP/1H7T73ysrtTEy8zAMPvMWBA/8Hv/jFYe69t8Kdd87heRK53CSf+9xlMpl/yl//9WfwPI/77vtTbrnlRUTxFhynxvDwSVqtCmfO/BrPPvvfIYou8/PHuOOOOmNjlwmtVSUkScO269EGP08ut496fRlBEJAkFUlS2u2uWFmvez1pNFb7yvfejKuLm1fuCnG1TkxXEzHgNZvr7TLm1YL+Xs4v7ifHClzd2XKcCXfbOcZ/ULqeo15fxnXN9nm5rkm5fLEtjzc6eiep1DCmWSMcMTI5cOA+HMdiYGAa226wtvYOnmeTzx9B15OkUqOsr79Fq7WJ4xh4nkWjsYooStxyy1fZ2JilXl/FcSwSiSKKkgICXNeP2OEmpllDlsF1ZTTNRVVFLl8O8DwB226RSAxEmwYDz2sSBAqKIqGqCkEgoSgqQeChaRlc10KWk9FniKOJ4yhoWhrHkfG8CnNzv9Ina/w+/cqlvbFTlhs/fq0Whr2uT90AdObMo3QTrGKziPHxn5JOLzMy8mYkkcmW18TnAURELW+LZGO/vnM3uezf/bs/B7YaUlyfx/H2uB6Hqaspjfd+L+PjP+3aqEisrNzB449/h9/6rcc4efKH2HY1eqWz4znulNnHrlwd0wuPS5c+zac+dZ7bb3+ee+55lXz+EKaZZH39bXS9yOjonfzO7xznrrv+V6rVBWQ5ga4PYRhrkYLWJqOjtzM/fw+C4EaVH5fXXtvP7/5uipGRk2xuzqJpGQxjg/n5F9C0NGNjpygWp9tTHN3WrUHgtbWr+1Xlbsa1x01AvkK8l33jXhZ3L1h27zR3eny384tf4/vuFrvGbiZ2TM5oNFawrPq2knbo8lRFlnWSyQFWV99EVZNkMmPIst5W6kmlhtqlascxOHDgAWRZZ3n5NQRBxPd9CoX9pNPDeJ6NJIV9J8Oosb7+JpIkIcs6iUQBQRBRlAz5/BTj4/eysPA8rmuQyRRx3RymWcEwSkgSSJKLroPj+IyOgu+38H0f122Rz++j0XgN162hKAVc18F1DVQ1jaKkItWwGrqeodXaiERDOuF5TWQ5ZqDnOHLkBV588e91ZXk/oiPMsFdvxm7Tgk7caAvDnRnGnYhnk7s3ANsFKyDsfW7VZe4+t86x/YhkFh9/qyHFjdS7DlndHZGO90rWc+v1gKWlTwCQy12kUjlIfG3m5z/DqVM/w7YbxByGK8mZ9m68QmetuB8cgvLBgy+Rz+8nn58gldpHobCP5eXXkCQtGlfMUatdJJOZwPd90ulRnn/+MG+9dYKTJ9/m1Kmfsrm5zpEjMi+8ILdB+eTJWTKZR1DVNKnUEBsbZ2g0NlAUHV0vRuTNOrKsb7NuXV9/B01Lt0dD4YPl1/wyxU1Afo9jtx50L4sb2AaWceykpb3b+8UZuK4X2v2fMBPevqtdX38Hw9hoy+HFpfRi8Uj7OYaxiSAIZDIT7d4RdGadIZ73lVhfP4OuZ3Fdk/HxT2DbIaiH88wVNjZep1a7jKLoZLMTEZCH/df19bfwfRtFSVEqvYttV7GsFiC2dXh1PcngYJHFxVL7s4+NFQg1qVUkSadeX4vGjZIIQoogCN2eFCVNobCPanUxEt83yOcPRc93opGVkNBlWZuAiqKM8OCD54C/xfnz97J//9PMzHyPTgbaa3IfR69fb3+rvxtd0o0X9xjgz579Ir3iE/GscHfptZ8rUS+g9GZ3jpPaxiQOw+8q6d4YIIZuf+cwSz19+hvvmbHFTmpnIyNvUalMtz/3vn1P8fLLJ5mb+/tdymnf5bHHfoOFhc9x6NCL3H33Rf79v/+7O2bNYaUhDoHTp7/BiRN/SaNxNKoU5Vlff4e1tTfxfRtdz7eNIAxjg2SywNNPD/Ev/+X/hCC4/OAHv8E//If/jNtv/zF33/0zLOs/ZW7uAY4de5PPfrazhoQyua9FWgTDHDr0GarVy31nik2z2iZxxVrWN+PGxU1Afo/jSj3onVyk+pd+gl1f2/t+vT1iw1hvbwK6z0UUZSYnP9m2eIwz5mZzfQvwxhl8/D6mWaZeX47cY4iY2OF4VKu1yfLyKwiCwOjonRhGkkuXnsU0a2haBklKkEgU24BomhvkclM4ToNcbgJV1UkmR2k0VvE8G983qVY3EQQFzwtL0vv27Wd4OGB9/W0UJY0kOZimTzI5RCpVxPcdYpZ0EECz2UQUk1FvuIVhVPF9A1nOYpplRNFFEFQkycPzRFRVjDyZQ0nAZrPMzMxfcvjwn9AZj2pSqYDv24giffyYRcLyo937iy1xLSXd3Uqf3Yt7EMgcOvRdVlfv6nq1QMw07i69PvbYl7eVpLt/7pfddWer4WftfPbV1c5x+32mvdpLdkc/gtiNOG6/18XfS0xeizPy4eG3ufPOf8Pi4q8wOflDfN/pUf36Grfc8hS33PJX3Hbbc5HIRpFjx17jxRe3zz6HrYOtY2MTE68hywmSyaFI3raFZTWi8ctw1HBw8DhBYDI6ekfEuh7ecm3efvs4Dzxwjnz+IHfc8R2OH3+KwcHDKMqR9prRapUxjArV6iLT07/C6mrI4AbalTFRlNsbekGQSCTyGMbmljHKm3H9cfMqvsdxpd5Kb+a7U+mne4Y4jhhku+ejexnW/Qhc/aLbwELXYXX1TYLAizRsLebnn2d6+le2jFQlk0O4rkmlcgFFSWNZdTQtjSDIFIvTFAoHMc1aW46zVDqH7/uoaprJySlMcwPbNqjV5ttiJUNDJ7DtBtXqZWq1ZarV0B85k9mHKEoYRgXLKiHLCdLpYXzfptlUcZwavi8gywqJRJFc7gC+70SsZi/S3E7heaFdoyDk0LQMvp8kmcxF5WqdbFZHEBQMo4IsywiCiuM0cF0TURTb88txhtlshvPFQQC2DfU6ZDLdZel+WTN0StcqMVj3L+n2Zthh7DR+NDf3WUqlQ1vKztPT3+HTn/4Dxsdf4vXXv44k0RYIeeaZP2Rl5Q66y9KPPPL725jXQF/mNWxlLU9OPsfCwmliUAmCreXuK32G7l723NxnUZTmNmelnUrB3YIoVzpuP6Defj5fZWbm2+3n1etjLC3dS2gw8T/y2GNf45FH/gDfN/nLv/zDnmvzaW655en2faJpOsnkILfd9iP+1t/6m7z00mMEQee+UJRw3K5TYfC5fPlXuPvun2MYGxQK0zQaS9G8vIskaQSBgGGsMjp6K6qaRpIUPv3pn/PMM+H3Hm4cvsPCwgvt7HdwcIADBz4TqXe5bbU/QRAigxmBiYm7KZfnor7y1taWaYa94xigPyihpF/WuAnI73HsrbfSWXCvplccg6vrmpRK59rmF65rsrr6JkNDM20Xp6vp8YTjUAKW1WRwsMDS0s+pVOZYXHyZAwcebL93/EcZn2es2BMEXvSYTCJRwDA2SadHOHbsUVzXxLLq2HaDWm2Zcvk8kqRE+tcuq6tvYFkN6vX5SDHMwDDWSafH0PVh8vmDrK7+gkQiQxAECILK4OAtiKJEuXyZEPxEWq31yF6uimlWoqw5R6tVx3HsqHSfjezlhkkmh6jV5ikWjyFJMisrr1GrLeB5NkFg4Xk2uj6AouiRUEn4+Ww7zIzj/5pNyGRSaFoWxynj+90zyQIdIREPUBDFNL5vsLP4iE4/a8jdxo86SlthxnXbbSH49gqLxNHNBO4ulfeCYpwJdz+3X7a69RyCHUvwu5GewnOKpTi9LcDaW03otSI8evTbfY/bYTD7fYlz28/ns5FKVqy2FYushJuMS5c+y513/gzLMjl48EVefPG/bRs8TE09SxCYgIVt+5RKC9i2Sb1+Gcc5ybvv/hrdM96O0yusIvKJT6wxODhDLjdJKjXI5OSDGMYSpdJFfN9C05KUSmewrDKFwmEkSWmTQ+NQVR3Pc0gk8mQy+7jzzt8mnR6m1dqkUrnY7hEPD5/AsuoMDc2gqmlGRk5uWYtga4Wse2MfA/vNLPn64+YV/ICjN/O9mjGrGGRrtUXivp1hbLK09AqWVWnLaV5tJJMDDA4ea59DMjnA4uLLTEzc3X5O9x9rd0877j/7vsvGRuijrOs5JibuaZNAQg/mDNnsBIqSoV6fJ5ebJJEYwDRDEpmqZvB9AUWpUygcxHUtgsCjUrlAENjIcgh6hrGBbdcQBBlZFgmCcEwjCHwUJYnnxRmFQqtlYRh1RNFtg7wshyU4x2nSapWYn3+WQ4ceRhSViLGawrbrmGaFIHDoyEOKyHIGxzFIJsNRJseBZBJCoZIa4eKqEbKwdbYqScmAg+83o8d3Iob1t4Xcbfwo+oaITe+PHn2iLULSC8Y7lcr7gWJ8vN5Z2v7iG1vLr3v5DBMTzwD91K3C9//e977JK6/8LqdO/XF0BKENxrEVoSB49KqDxRl0h9QW9tGffPKb7WuwddQrfN3Bgz9Bkga2EbviTcbdd68yMBB6f+fzb5HN/kPefPM4k5Pfj9ye4vdy8X2DavUSoYDLp3t9hYkJAABzkUlEQVSAP5xr7xYQ+fVf/zMefdRlYOB3KJcvkM2O02isks9P02xuoKoT5HJTrKz8DN9fRlGyNBpLvPDCXe1NgSi6rK9/jU99ah5Ny3DkyMOk08Ptv1HoAGucFXcDbe8mPv77bTSWabXKbUJndyvsZlxf3ATkDzj6qWd1/7tT9I4uxaHrOcbHT9FqlRkYmN7lCLufUzfIqmqagwc/A3RIZ83mOkHgRr7HM10lrK0Er2ZzFcMosb5+BkmSI8Z2gmazTDJZaOtcW1Y9EuvQ0bQCtt2kVjtPq1UDAmRZxbZb6HqRZjOchz569EssLLyE5zUply8TBD7J5CCKogJS1EP2EQSRtbUy587Nk0p5JBLg+17U18uiaUlct0W1ehnXtTl37ruIooLrOhQKw2jaMarVSwSBT6UyB2hoWo50ehjXzbGxcRZNA1mGbBagRRCE5DJB0AmCGGzDEqUgJAiCWETkyiNTcfSWW/uPH20lHzlO8oryk72jUtvL3iEoCoKLaYbWjd2v7QX0iYmXeOaZP2R19Y5dS9YzM6E+9+uvf50YtE2zH5EqBKlyeZpyebrdH++cXwf8g0Bqq4P1ekNvJbVBpXKIxx//Tpc6Vpj9HTnyF5w69S2OHXsCQSgwNfVstHHw6NbrliSFdHqUZnOD/fsfRFGeZ2LiX+P79eg6PsTU1FPMzHwfSdIjrQARTeuYTASBzNGjr3LixC8Qxd9gcfFLPPywzkMPrVOpVFlZeY1K5Tznz38fURRpNjfQtAz79n0CVdVQlDyOU8H3HdbW3uHEiRTf//7X2qB8//0W4+N3R1Wr0BGuu/cL4f+HVasa5fLcrpv4cJRqnSDwtmXPN+P64yYgf8hirzvNXvJWs7lOq7XJ4OAM+fwB8vkDN/S8YrBV1RTN5npbbjP+w4x7TN3Z/cjISVzXjMaWTEQxzdDQCebmnmN9/W0kSWZk5A5Mc4NSaRbTfAFFSZJOjxMKlIyjKDqeJ1KtzpLNjpNOFxHFGYaGjtNsrlIoHGBl5eUI6JOkUgV830NVUwSBQCIxAGR59dW30XVQlLDfW60a5HIGIyNT0ZyzjKZlkGWHZHKEZnMFTcuhKKEJRy43hmFUGBg4QrW6SCo1QK22RDaro6r7sO0VwmzYpjO2IiPLKoKg4nnhjDTIkSynGJU0oaPFbBECaY4gqNDdytip39rtNRyD2+zsdqvF7uPspYe6NdMOQTEIZPbvf6atud19rG7VrZmZJ1hcvIeVlbuIhUW6+7zdJfDl5Vvb/smzs1/ha1/7Mrfe+sQWI4jtmXaHIR5XAroz+O4xqzg6IN8d4ec6d+6LXRmrR6022XXfC8zMfJvHHvvytn77q6/u4+DBf48sa5RK52g2N3j77Yd45ZW/zdmzX46+q7/Pb/3Wb/Lgg7O4rs8775zm2Wd/r4sh/n/nrrteYnj4LpLJMySTm3ziE38XzxugWr1ErXaRUmkWQZAj1bsNZDlJJjOCroez9pZV5+zZP6PVanDy5Aa///syb755hKNHX+bWW0tAniDw0fUcyeQQ0BH1iH+O1bgUJUGttrhFjyCOftr5NzPjGxs3AfkjGrqeo9lcR9dzGMYmzeYa1ep8lLlt/2O63jCMTWq1y1Qql8jnD7TlNjc3Z9vjD729pkZjFdOsRazmkBjl+x7DwzO4rk02OxL5GJsEAShKKsrw78SyDMrlWXK5/TSbG4iiHzGzh0kkBnHdFhcu/AzDWMOyGoSAmkLXR9C0JI3GMoaxiu+7OI6P59nIstomeYkiNBplBgaG8bwkQeAyNnYqcupp4PsOmcwYgiCyvPwiQSCiaQmCQEDXw0xe11OkUuOoao1yuY6qpgmC+L20NiPW90PrQ00L3bNs2yC0eVQAEVHUEQTwPAlRlMnl9mEYKo5jRHrarV3nlA0jLJkfOfIE09NPMDv7KIuLncz5ySe/eUWyE2yfuY3BeGLiOVw3yaFD322bPlyJkBWDaTyWFL93B2BjoN9qfjE//xluvfWJnlGqXvZ23IuPZ8A7YNxPJQw6OtEvvfT3saws3bO+cZm9H+N8ZuYH7dd3X794c+K6AZZVwjAqvPLKJ3n88T/Z9pkuXLiXY8d+gCj6vPvu72z5HoMgjyhKiKJCsXgQz3N5550/48iRR0gkhigUphEEBV0v0Ggscv78M5F5g8jm5jl0PYvvOyhKBsOokkpNcPfdL3H8+PfR9SyNBgwMZMlkRpEkdQsrOpkcwHVN1tffIZ+fQpZ1NjbeIXRY6wBtvBmv15epVC4CXFMr7GZcOfaopnszPmwR61CbZhVdzyEIEqqaodUKy8Mx+eJ6IgbVeHY5dHNxaLU6WrbxOfSS0RqNVRYXX/r/t/enwXHm950n+HmeJ58j7wtA4iRAEiTBsw7WqSpZpyVLbtkeuydGbbt33fbuxkz0zGx39MTE7G53zHbsRL+Z2Y2eiO2YnjeOjvVut3o62nbbluS2ZFulskqlqlJdYrFAEiRBgjgSibwzn3zyOffFcyABAiyyDolVej4RFWAByMwnH+Tz/P7/3/H94nk25fJJxsYW6XbXabVuYllDJiZOIQgihtGj19tEVbPk83OMj59jbu5ppqcfIZOZJJudZnHxS8zPf46Zmeew7T653AKG0aNWe5dGYw3Pg1Qqi6Kk6XZvs7PzLrY9xHEG2LaOKA4ZHwdRNBEEkcHAl7HM5Sq4roNhNPA8UNUUiUQSyzIQRYF0eix4rxbDoY6ut/E8F0nKIUkKudwCnudgml187+gUoigjigKu6wV/Fy+qa4qiQqGwgOt6+LVhf+7a7952UZRUUJMfJ5nMoih5wt3gwsJf31UX3fu32rV4PHbsT6Md6ze+8Sf86Ef/Fd/4xp/w+uu/t6f7+vXXf3fPc4SvsdeYwmF9/dNUq4/xwx/+Y65d+xpwcENWSPizcCdpWak939sNpOFXCLuCQ2vJvcfiB9tTp/6Ykyf/ONCGdtgNyruvcxjhIsE0s+wGcSEK4l//+q9QqbzJrglE+J52m+3C9PzTT/8Lfvu3f4tHHnkxEI0Zw7J0bt58HkFw7npPCwvfw/PaOI4RNHvt/h3PnXuXbHaaVGqMsbFzmOaAWu0d3n33D/mLv0jzT//pHD/+8RMoSpYjRz7D7OyTQQ24wdbW2zSb18nnF0gmx6lUzpPNTuM4fnnEtg0mJi5QKBxlfv7TTEycvWtXu77+Grq+E9WPS6UTlEqLB05zJJNFSqUT77sUFvPexDvknxL3Y1LxIEYWB+lQh98bTSN/EPanoOfmnqFWW8ZxhuzsLAcX7vieOefwdwFUNYeq5slmp9C0PMNhD8cxg9EoiUJhAc/z2NjwoqBmGA1WVv6KXm8LSfLTyINBg0QigSR5SJKGbXdwXRNFSSOKMoXCApaloyipqONTklQKheMUCh47O1eZnDzCO+9sIIoWqipQLs8yOXmMft+XBk2lKpRKx2k0VtC0QiAX2EIQRDRtnHK5FOyGdkinc3ieg22bGEYb02wjCBKJhAQoeJ4vQ9rvV6PRK0VJYdtDarVlPG+3buzXqk3ADtLaKr1eDV3vYNs6YVPXveaURRGGQ7+GLQhgB2ux/UEzbHYKHsXVq7/G8vLX9qR471b0kqLfB3jrrd/l/Pk/3VPn3b9AOEzkZLRpaX99+OTJPzlA63mXmZlXot3v7pz1Xmepe4mprK5+YU9aulJ5k89+9p/eld4+rOM8xC8TfIdEIovraqiqiq63AJDl3p4ac6l0jbGx5eCRGoIgsrT05/zu7/4XvPLKfxo0HqYplY5SLB6jVFqk3V5F1+u8+OIJ/uW//K8QRYdvf1vCdf85n/3sDWZnn8GyDFqtFdrtVWy7RL+/Ral0nF5vC13fDiYLOoyPz5BMjlEqHSefn4u8znu9KqlUOZrx17Qi5fLiXb0jIaOKgrFW9UdLfGZ/StxP9/RBc8WHffgPmzF2XTtKI39Qp6r9DRuhmcX29iWGw849jwFgbGwJIBDdSHD06GeoVi/RaKygqjkAhsMeyWSZZLJMoTCHadqsr7+AZfkBV1WLOM4wmLNU0fVtBEGiVFpAlpNkMtOkUmWuX/9zkskijmNjmh1kOYfj9BFFGU3LMDUlMjV1il6vgyx75PMFisWj9HprCIKA57nYtoXj6IAQ7H5Nlpf/DNPskM1WUBQYDgV0vUahsEg2m6TXq6GqvtxnIpFBFB08z8GydGzbxg3snUyzy24Dl4p/6YkIgoose1iWiyDICIIUNJf12OscpbC09O0DA5YvHer/2/Mgn1cQRe2uwPjYY7+P5wlcvfo1wqav/c1We8dv7kYKvr2+/tShn5vDFg+j1o6WlYq+HiSEsldG0tmj+BU+/+uv/y693hSZzGYUzA+rkS8sfJ+XX/4/R+cil7tz4HF/+tP/Q2TWcfjsshHoqsu0WjdxXTBNI9ihh+fOodE4RbN5nKtXf5Xf+Z3/A+fP/zW2raNpGS5d+jyi6PDOO18km/1/8+lPX6dev4phNPE8i3feObunW/q11yY4ffqbpNMVjh37RTzPodPx/csTiST5/DFkOc3t2z8MTGByiKJEKlVAkpQDpzj8xyoUCkcD6d5dcaHRe8boNMfOzhWSyRKVyrk4MH8ExGf0p8R7dSOOGkAA7xm8RxkNjKNp5Ad9nns97+j7CAPt/pGIcKc8qp2taXkGgyaalo9GnkJlr0bjOo3GVTStwNTU49i2TqPxVrDbVJiZeZJudzMQsS9hWQaCICJJCTzPZXb2SYbDDtnsBMlkHtd1saw+udxRDKOBLKfI55eQJBXLMrDtIalUAtu2UZQ0t2+/ACTwnaiqpNNjJBJZbFun19ug07mFYfgKSYbRoFA4hm33keU06XQZ0xzgj7TY0Sy1r/3dQxA8XNdGlrNR7Xo4rOKLgezukB1ngCCk0LQCmlZEEMDzBGy7O3LWVUTR/891h/gNYP4oTSYzR69XJZvts3ee3Tw0MIbd2KO7wNGGq4PHlfz/f+yx399ngiAiCM6hNo6jHKZl/Zd/+f/ge9/7v3PixLcCx6r9MpLSgYpfoRZ36KR0r7r20tIfRkH86tVdX+aDat+CYLO1dZGZmVcB79DnlCQBWU5jWS6ybN0V9MOduyDYrK9/mV//9SS6vs13vvPkSLB1WF39DF/7mki3u8Fg0GRsbInFxR/w4ou/S6g9ffz4KwyHXUqlY4iizMmTv4Tn+YpdsqwwM/MY7fZtTLNPqXSMcvkUk5PnkCQVSUpgGG0yGS1aMIdlqHA6otfbDPyTi5FK1+j17br+RIVv5+h9KBm4mLuJA/JPiffqRgxVcMIU8H5Vrv0ctvs9KPB/mCMJ+9NaB2lnK0oWzyNqOBsMdtB13yc1lSqTTlcoFheo1ZaDEQyJVKrI9vYGkpREVX1xe0HwU9aOYyIIAul0iYmJCyhKEklSaDZvU62+xcTEOcrl04FFYwJd3wYsDKOLqm5gmr3gHLlYlonnechyKjrOQuEMhtGg1boZBMYsjiMiigkUJRekFU/huhbT00/R7a4DIpnMGOPjZwJFsTUMo4MguEhSClVVgA6yrJFIJBFFkURCoN/fZq+Mpo5tO6TT84iiFFhNGkHw9eU5BcEf0/JFRhwURcV1JVxXCXbeHrujOGX89LcBJO/L0GF/d/WZM/92j0kEwKlT/4HHHvv9kRGivaNG71d7e1eswwu8nQ/Sxg5njO/ty9xuH2FXv/vgRcK9muP263+vrf0SjuMe+Pu+xKoCiKTTRRwnw6c+dZly+f/C5ctngQZ//df/9Uj6+wUkSaJSucC5c8t897uhv7HEo4/e5vjxz7K6+iKm2aXZXOXJJy8hSf8Fy8uPcubMO1y48H1UdQJNKwEO/X6N8+f/M1qt2/iKcTvY9jC6xubmno1S1KPjSbuzxFt0u+sYRpeZmYtBsN1GVbPRPQj2GtQIgkC5vLjH5SnmwyUOyA8Jh0leHsZhKfD9j/0wV7H3q53tX7y7u/TRnZZhtHGcIWtrPyKfn6VUOo7nuZhmH0XJksnA1NQjDIc9ZFkNBESm6HY3MYxuUIvuBM1XPXq9dcCLREWmp5+gXD6JaRoUiydwHBfLWmEwaJPJjOG6Fp7nUKk8QaOxTLt9m+GwhW8p16Lb3aBcPkMmM4bjTGKaOobRp9tdR1WztNt3cByTTudWoMPdJp0uRSMp4JLN+jKgptkPasQ6nieSyUwhiiqmqWPbvSBo2ihKkVRqDF2vYttdBEFBlnPYtt9l7Xk2fgD089K2PcR1TcDANIfsNmF5uK6BIPhdyP6uuoBtN4LHCvcIZLu7uVxuPdpN9vuTpNPVKBjD6AjR3aNGD8q1a19ldzfuce3aV/jsZ//pPoMLgf113f3p+FBnOmwW8y029bteb2HhxQPq2xLLy792l/733NxfARYvv/z3o99vNBZZXv4Nlpb+PPADH0NVc/zkJ89z8+ZnOXHiR/ztv/0/YRhd5uff5ObNz3D27DucP/8anc402ew8zz33Kq77j7lx43lOnXqDkyevs7b2GXK5abrdGoZRRxRFvvjFOhcv/j6SpJHJ+HXmVGqMet1X5ZMklZMnv0KzuUqxuEC9voKipHAch2r1HTQtj6JkDsxy9fs11tffoN2+DviCPsNh+677Ryh5m8vN4XleZMcIBIJEu+JGMR+c+Cz+jNgf3A4KwveqAf8sBvL3627v91kO38NoDTx8H+GIluvaDAYtWq2bdDq3yOfnEQQJVc0yGrg9DzY23kCSEqRSYziOgWUNAQFVTeF5HhMT5+h217Fti83N1xgMOuh6DVlWg5GhE6TTE7TbmzSbq7TbeTKZMUxTx7K6zMw8iyxn0bQMudwiW1uv0Omsk06PBQuEFPn8AoLg70Jse4ggSJG5RadzO3i9DLKsIUlJwEYQ/PS15wkkEgqyXAjUwiRUNYcoKlgWmGYKUXQQRSnYFadJJIZBNmAcz3Po9+vBbGiVUFhElrMMh63gTIWdy+F56+EFmWvXtfClFP16NbgHBjK/M9ive4ZBan+T02h69/16Gx+kT33ixLeCnXHYCLXC6urn9iiCAXe91ugxNBrHuXbtl0d21L5bV9h1vbcG/E1+8zf/DjduPMvCwossLf0loN5lO3n27F9y7txfYNudPeYS1659latXf4Xf/u3f5sKF75NK5bhy5W/xP//P/yjY8X6B//a/TXH27Hd49tl3+N3fPYtt59D1J0ilJpiYOIGiZPnsZ3/IF7/4LUyzhWk6NJsrbGzUGQ6bmKaBpqUwTQNdr2PbFpbVIZ/309V+pkfHtnXW119jbu6ZyApV1+tUq69jmn0sq8fS0q/cde8QxQTj40tYVh9JkigWF0ilygwGzUPuJwLDYXePFStAo7ECePEs8odIHJB/RjxIk9dBv/Ozuwh265Sjafbwot+fIuv1qtRqV+h0btPrVYPO6QyTk49GNm6hsUQqNcb167dpNK6SyVRQlAyiKJHJjKHrO8hyAk3L0mqtMjZ2ikxmmlzu73Hnzsuoah5JSpDPz7Gy8hfRat/zCFLcLomELzFpGB2uXfsmp0//OuPjpxBFiZ2dt4OgKtLv+/PTiYRKqXQSTcvS6dxBkmQMo40kKUiSQCKRDAQb2ti2gSwnkWUFVc0ANrruMRz2yeePMhjs0OuFN1xfQUxRVIbDIbJs0+83SKeL2HYKy2qjaTkkKYEoSriuE5yrAf7NsYkk5QOjC4ndhcz+UTc7aFID8IPT0tJfHBjIDuo8vld690G9jXf1oHc7o8OabNhIVSqtcPnyfxa95n4v5f2ExxDWnPfLfB7sP/y3WVr6E06e/Aa+/GkOz7NYWPjunp3wxYv/mtB2c2npu3u6tEXRZn39S1y8+CogcenSqSj9LIoOt259lqee+nEw4mahaXmKxTn88kOCra1Xgs9RH03z55Db7Vs0m9fpdmtoWg5FSTEYtDCMWpA2N+h2b5HPT2MYPbJZkc3Nn+B5Lq7rcPToZ6JRyGx2BsvSyeVmDq31imKC6emLFAoLaFo+0KC3o1pzSLj7DctPsLsJKJX88SdNy0ed2/FO+YMRn72fEfezw33YZOn2627v76wOa026vkO/X0OWk6yufh9JkvA8D9vW2dq6Sj4/x/T0Rba2foLjmKRSBRKJFDMzTzA5+SiK4utcm2Yfz3NZW3uVZnOFQuEokqSiKHmazTXm5j6FomSC3WyG6ekncJwhGxs/xrYN8vmj2LZOoTCP69rMzDyNLGe5cuWPsW2TjY03mJ5+EtcdoCj5oKGlhaoWsaw+yWQJy+qi600KhaMkEgqt1hq2reM4DomEGvgzD1HVLIqSDY7ZxvPAMFoAgRlGieGwiW07qGoScDFNA1VVEQQRxxmg6/4uVlFSKEqGbHaabncLEHCcAZKk4TgDwEQUB2Sz85jmgMGgge8cFApmhEHaY7deLSDLSWxbPiCQ+YFmNBjDh+vRvF+ferQm/Eu/9I/4whf+yYFuUvcT9Ed3y/s7t+9+zuc5c+bbuG4SX0vcQZLUPQuVhYXvcezYt/E8jXR6lrGxi5w7d42XX05EzVhnzrwT1PZtlpZe59vf/luIoovrSjz11DbF4glcd0gmMx7UZ2tIksqNG99hMGhhWV00bbdR0S8xKMiyRjpdIpmcYDgcIEkZZDlBoTBNNnsk6DHQaTavMD5+jk7nNrZ9hFptmXJ5kbGxJcbGltC0PM3mKoqSPjRYhtdyOMooSepd95rRZs39qemwl+QwD/eYBycOyD8j7meH+7Clgg4Smw//P7wo/U5hPwXrC5SYpFLTSNIw0Mvt026v0W6vR+NQ2ew0yWSRen2FbHaKbHYKIAjsOyhKinR6gmJxAVFMcOfOFRzH4erV/8j4+ClmZi6iaflACcxEkmQURcVxLETRv9mpahbPcyiVjnH8+Bep168iCC7Xr3+L8fHzlMsncZwhspwkl5uJ3G/q9WX6/S1sexDoFWexLINebwNNKyNJIq7rkEpNYJo9dnaWsSwT23aQ5RSSpFIsHkUURbrdLSQJ8vkjgTY2yHKeZDJLo7GG47SZmblIJjNNNlvh1q2/QdfbDIftwIQiiaZNBLX0aXzrvDFAZjCo4nkykuQiCEnACZyqwtEpG8sKjSr8YH1Q6vleetkP7ivsmyYsLf3pXXXng2aH9y8AGo3je+ak737+vb7FwF0jTwctKlKpCpKUode7RahJ7Xki5879zZ7XchwD0xzQaNzgwoVb/L2/93/k9u3P8uyzXR555A47OwUkSeKppy7xT/7J/8o775zhscfu8PTT69i2Ejgq3cK2/XKF34fgq4RNTT1Ou72KafZIJFJkMhXS6Um2t9+iXF4ik5kgmcxx546DJKVIpQpoWoGJiXPo+ja53CySJJPL+TKz4e52NEgKAjSbq4QOUAfdS3S9juf5c/sHadL7TZIHZ+rC3wtLUbHr0wdH8DzPe69f6nQ65PN52u02OV89P+YD8kFnhD+q5/ogx9DrVYFdG0bL6mNZAxQlQ6u1Gjg4uWxvvx10TidQlCR+p+oEc3NPBe5Jfhdnp7PO5ubr1GpXWFjwlYbW1n6EIAjUalcwTT/dPT5+Gk0rsLHxGv3+DrpeQ9ebVCqnEUUlkOfsUyyeIJebZjCosrb2Kt3uepDalpid/RSOM8RxbBYXv0y7fZtS6Si6Xuedd/49lqVTKCxQKh2l32+xuvodstlpcrkZxscvIEkSjcZN1tdfpt1eQ1VzOI5FIqGSyUwyHLaCtKBAMpmm16vhODYTE6cRBIlabTlIIz7K3NynuHHje8FMuoNhNBkMOshyAs+TEUU3UOWSEAQhcLLqIggiqprGNAfBLl3El+j0ZToFwR8X88eu7vZoXl7+Fb7xjV3rwv3SmvfL/q7t8Hn8IHr3LnYXleXlL91lJbn3OBIsL3/lrucHDnxNv2Hrq/sWFRrF4lEsy0EQbPr9ZrBwkfC8AcvLX2F19fOcOPEjlpb+gkRCJpebQpbTTE4+xtjYGTY2fsjOztVIfS2bnaJUOkYioVIun6TXq/Luu3+EKMrIcpJu9w4g0O/vkMlMUijMY1l9bHuApvljfY5jBp7HLhcv/h6rq39Dtfo27fYdkskiyWSB+fnPsrT0y7Tbd8jnZ2m370Ta0vvTyobRRlHS1OsrJJPFKFiP3isOuneEi+tUajzqCTno/jL6e/7z7j4mZi/3G0PjpczPiAexWfxpPtdh7L8oD2pKC63YAFQ1i20bFItHSaXKJBIa+fws6+s/JpWq0OlsIMsqvZ4v9JHLTeN5Ht1uFUEQ6XY3saw+169/B89zMIwLrKx8l3r9auDvWsa2dQYDAcvSyWankOUsnreN5/np5MGgiSAk0LQiyeQYudwEw2GTTmeLREJlbu5TbG29hWl26HTWgpr0FNevfwdZ9keVVDVHubxIr7eFKCqYph6MNiXp9XbIZGbI5aaRJJlG43rQzOUhSQqFwhG63TsYRoNutxl8XwMUFKWEIHik05PYtj9P3O3epNncpF7//wazzBKqmkZV8/ha2hn8VPcASVIDh6wEpmnjzyULDAb1aMeUSKQRBA1BSAfp+C6W1cd1BXw7SN/MIgzOq6tfumfKeO+u9M8Y7ScY5bDa88F151DPWkCWS5w58+I9a9dgHyLbKez73udZWvo2IBzwugbN5jUgQyLhN7/558Bmeflv8Y1v/Pug5vxf85//5/+Ixx9/ibGxJURRYThssbHxKoNBg1LpOIqSQRBEkslxhsMuhcI8xeJR0ulxdH2bdHqKGze+iyynaTZX6fW2cRwzkEmdQNMKlEqLGEYH34FsFtsesrn5NrOzT2DbJhMTZ2m1bmGafXZ23uXWrRKyrATz7wlMs08mU4maLkcbrXq9KoNBg2bz5l3XaJiCPsxnfXRU6qD7ykc9YvnzSByQP2IeZF74/fLTqDXrep1ebyuyWzxoETDaVd1q3WQwaGJZfRIJjUrlHJubb9JsXsd1PSRJZHPzDWRZoVK5yPj4aTY23sAwmmxv/yRoakoH4xbgOA7d7iadzm00rYQs+ztrRUkyHHZpNq+j69s4jkOlcg7HERgMaqTTY2xvXwY8HMdkMNhGFBUmJx+lWJwHBDY33wicnvwg59daLdLpSXR9m0rlccrlLmtrL1GrbaJpJbLZKRqNa7Tb1zHNLoqSQ1HyQZrYRZY1dL0V6FZ7mGYDX4Yzxfj4OVzXxPdy7mGaIp1OA9t26Pc3gpR7gUymGGlpp1K+vGEikabTuc3W1mVE0cVxfGtKRZnCNNvYto6iFEkmMxQKc+zsXEXXmwwGOm+//Tyrq8+xsPAijz32BpbVxLYtoA8Q2AzuNjaNppP3N0f95m/+FidP/hGjfs2jXdSj9oK740cp/MazcG5aRZY1LKuLbw6iMRgY71m7vvvn3wf2+jKfOfMumjYWiVz4aXoVP/j7UqXLy58OZo9FHn/8/8PS0h+zuvoLewL7yspT/Mqv+I2BN258j3r9CiCSzU5w7NjXGAw2saweipJhcvI8jmPTbt9CltPkcvP0+1sIgkAmMxPNLScSMpOTj5BOT0Xp5H5/B8cxGB8/R7u9iqrm6Xa3mZp6hFrtXdLpSSSpgSRpkcGDpuWZm3smaqrStHzUaDV6T0gmS4SLp/u5V+wPwIfdwz7KEcufV+KA/BEx2uS0X/nmw04x/zRqzeHsYlgbDgXmDzI0D6UzbdtgOOxG9d1OZ4N+v0EuV0GSJikUOiQSaUqlY+zsXMF1fV3dhYVfYDjsoqpZkskCvV6VTucOyWSZ2dln6Pd3kCQ5CKLJYIZ3JzCAB9edCgK1hCCopNOTbGy8gigqdLt30LQS+fwMg0GLWu0dZNmv9/X7dURRxvNskskiV6/+CcNhn3TaF+7P5ebp9Xyt4E5nHcPw3ZzefPNfBfVivymnVDqObQ8inetEIk8+fyTYdUuk02VkOUu1epO1tTusrjao1RwWF2FubppSSaFQmCObneb69e8gCDKeN8Q0+/hOVTKyLOF5MqqawnUVXLeHIICvZOZGFpyG0WEwaPH220/zjW/8uyCg/gNk+be5cOEFZNliMPAAnaWlP+V3fuf/xPXrTzE391ecPLm7q7x7V/o8rttndfUzdzlJjYqLCILDiy/+Y2Zm3uTJJ39Cv78ZyJlm8TwvON/+/LRf8vBYWvrOgRKWu7Xvb+37+X8AEnz96/8Jq6uf4+jRlzh79g0syxdW8TMBHn4Q/mVWVz+DLPf3aHZfvfo1vv71X2Fh4S/3qG0tLr6GKAo0mzfpdjcZDuuAiOdZ3LjxJ9i2i+MMkOUkuj5Lv99kY+PVYOcsYJo6rguTk6fIZj/PrVvfp1CYZ3LyMcbHl6jXV1DVLKXSUe7c+TG12iVEUWFn5zKl0gnS6QVSqRLV6k+Ynn4s8AvPsLr6fVqtm2QykyhKJlLaCuvAo9dkpXJuz/0mvEbv1Rl9kOBPeL3vz5SFpap4HvmDE5+9j4jwQ+zP6O5VtvlppJg/bMLZxWr1Ev1+dU9NapTRC7leX8E3jGjT7W5Sry8jSRKO46CqOSqVR1CUHOAiigrpdJ65uaejrmldr+HbFfbQ9RqTk2dpNu8Eu1CbXO4Ic3NPks1O0+tVKRZ9swpNy3HjxvcYDtvkcrM4jolpdoLj8cjl0mSzU9TrNxEEEUGQkOU0giDSbl8nm50LFgNlGo0bQaezSLF4jNnZJ7l69VukUgVsW8cwBmxuvoYgZCgUpkilisGO3sQ0u0EK2yCdPoJtG/T7m0iSwo0bt7h8+RKCAL0ejI2ptNsC7fYtnn32GJpWYDBoIIoJBEEJzONvBkpmGXK5eRIJv3bsuk08z0GSRATBn9GuVt8hnR6PFgGrq5/eE1DX1r7Mk0/+GFnOoSg9ut01XBdOnfojFhb+IPhrJghHqfbvSmV5wDe+8cfRjvnkyf+w5/kbjcU9/7+19Wu47quIogKY9HoN/JntsOvalxNdXv4qr7/+e1H3ty9h+UoQlFOAx/Lyl/ZIXFar53n88f8fjzzyfZaW/iPg0e167AqFEDz3V6Jj3nWS2nVmCju+/87f+TtsbX2Fc+eWUdUS/+JfPMmpU68xN/c6slzA97SW0PUurjvEtofcvv3DIDORI5udZnLyAoNBh83NNxBFv8zgq6qJlEonyGan0PV6ICwzztTU4/R6Ver1ZVS1SDq9my4eHz9HJjPJYNCMfMhnZ5+iXr8azRD3+zUOM5U5KAi/1z3oIMGfgx6n6/V4HvlDJA7IHxH7lbcO+9nHiVCLeleU4m7CC9a/QdhB45Y/epHJTFIsHou6qAeDJv3+Nq3WbZLJAtPTj2GafXq9LTzPw3GGdLvrQad2mVZrLXK0GQyaLCx8BtPUEcVEtCMEqFYvIUkJkskSxeJRQKRafQNFKWCaLWQ5R7V6mUQiFdSbk3ieheN4pNNTZLOzZLMT5POzpFLjbG6+gecN6fc3sO0+5fIper0a5fJJqtW3cd0sudwc2ew4giCzs3MtUCSzyGTGot1SMjkBCBgGXL78LoLgexmrKkGHd45+30AUy8ENOUGzuRo0YqWjjMNgUCeRUFDVLJbVRRSTiCIYRhfTNAATVS3S6dzBMDrYtsXCwg95+eV/EAWjZ5/toGlFBoMmiYQUjI91Am/pMJgJ+LcIl6Wl7/D1r/+nrK5+hqNHX+Dmzc/sCbh+UN21FTxx4rtsbV2MxoQeeeRKkNFIYZpNbLsF2IEKmS/Bubz8y8Gs8l4/4b01ZGdPWhn83e3Vq7+KLP9dzp79y2jcLNwVB5/efaNX+w00xCg1/sQTr3HkiMYbbzzBP/tnfx9RtPnTP/0i//AfDnnkkR/Q6awxGHRJpUp4nken43fM23af6enPk0ho5HKzZDI2nc7toBchw61b/mMVJYsggCRpdLtbDIc64+Mn0fVmYPIwTjo9gSCIUZAdDJoMBnV6vSq93joTExc4depXovtLWEa61z3lsCB7EIcpBx408rg/TR7z/okD8kfEvVaLH+eV5Ogs8kGp91GrNv/m4s85mmaXdLpCPj8XzUgWiwvoep18foZMZio6J93uJr3eBs3m7SAg+w5K2ewclco5stlJTLODabbZ2VlGVbNRMAYolxeDkaAiopigXl9BkhQsq4ssZ2m3b+A4fop0aurJYIHg0mqtAS7z88/QbN7C9z5WmZq6gGH0cRwb1x3Qbt8GTCzLJpudCcQUKniei2E0sO1BoOrl4jgWhtELGm8mSafLbG7WUVUXQVDxvCHtNgwGYNsWipJiZuZxxsdPs7Nzjbm5J1GUQqBsthG87yGKolIozKPrdRIJDdv251ld1wA0RNGvGdr2gEQixSOPvEg+/4+4fHmJEydeZXLyJbpdf546mSyRSpUZDjv4AUwNjs1CUTKADJhcuPAijz32Eo7j4HkeL7/8X0YB7okn/i2PP/4HrK5+moWF7/HIIz9gcfEKt259nvPnV3j66cv0+zksywzSvjK+nKeMIKiAtC9gwt3Wjgbg7LF+9He4vnPVzZvPsbT0LSRJwXG6+CYcoe+yddcu/9Of/h/Y3j6H58Hjj/+rKOg7joHjdHnjjaOMOi69/fYJZmf/gG53DZDIZidJpUoMBjukUkUWFr6I41jY9oDt7cuYZp98/ghTU4/SaNwkm51GUdLMzl7Etk0sS6fTWcdxVmk0rqAoOdLpcWZmHmc41MlkxhkMWniex2DQwLL6ZDJT2LZOOr23m/l+7in3kue9H+XAg17nMMvGh2Hy4+NIfKYekJ/3D9pBs8ewm/YaFRIIz1FYb5blJI3GNSxrSKdzh2r1HVKpEpnMVGTnFtaf2+0NPM8mm51FVZMMh31UNcPRo5/Btg3W119DFBM0GtcYDJqR+Ec4Fxl6MOt6HVUtBLPR3SA9naNev4br+inkSmUJxxFIJKqAQKNxm05nFcsyKBbn6XRaWFYfVU0jy7N43hqeJzM7+zT1ul/7bjZvIssaqppHUTQEIYEgCMFN0GE47JNM5kkmJ5iYKDAcqmSzJoYhYtsuW1uwuCjw7LMXOXHiCTY2XqNev0IioTE3d4pC4Sh37rxMt7tJIlFHkpLBGNYpLGuAquao1d4mkUhjmk08T2Q47FAsHg3S5jbnz7/AuXN/Tr/foNvVkeU8mUwJQRDJ5Y5j2zq6vhPU5cfp93dIJFR8bWwNz7NIJNIMBjssLf17vv71X+f27S9x8eJtHn10k2p1OUoZO47K+fM/4LnnriMIUChcxPMcut0tVLWIYfTwA6oTdIQnWFh4aU/A3PVI/jMEIYMguLiuHs1Hv/HG73Hlyq6wydzcX6MoWfr9Bv7u3kUQEkiSiG2HAiK/ESwa/mpf53WYuk7gONBs3uLo0Rdw3a8SOi5NT38rMBbxm7wURUPXG+TzMxw58jzZrC93Ohx2gnq/iyQpwWfPnwefnn4KxwmFY7pkMmMMhwPyeX9hl81OMRh0kSQp+iz7ae0JJElma8uvJd9vENz/vfejCng/3O/scsy9+fmLKB+Qn5cP2v0sPA5Le+0/R2GXdat1K7BiLGKa3WCMxK+hha9Zqy3jeTaTk+dptW5TKBwJ5ni7kYm6afZJp8dQlCyKkiGZLGLbRiT/1+/XEASCJrQhltVjaupJ2u3rDAYtOp2VYO7TIp+fY2vrbQqFBfL5eUyzg65XabXWGA7bwehRkmazSadzG1nO0O9XGQ7r6Po2ipImnZ7C8/z3Ojn5BNvbb9HrrdPr7eB5DqlUmVzuKMlkGctqc+HCV7l+fZWXXvprFMXfkX75y49y8eIChUKWwaBDLjdDrXY56C5fQ5I0+v11er0tBoM2mpYNdsQDJicfxXF6FApf4/r1P6fVAs+zmZg4z/Hjn6PRWOPatT/FsoZ4noAsa4iiQD5/hHx+jkZjBd/pJ08ikSaRUHFdB1EUEASRVKpEqbTIzs4VTFMP0swCS0t/woULLzE5+QjN5jqm2UYUk0iSSCKhIUkJBoMmrmsGs9mFYOGSRlHSmCb4u1cDSSrx/PNXmJj4x7zxxjwzM99lael/AyQkqUA+f4RcbpJm8ybt9i2Wlv6SRx99hcuX/4irVy+wsPA9zpz5Hp5XRFE0TNMMxr/8HZzjDGm3Gzz22I84c+YFwMF184GKnB/owWF5+de4deszHD/+EmfP/j6/9Vtr3LnzRaan/yOWNeTP//yfsbDwMs8+e4l2e51kskKlcp7HH/9dJElmZ2eFXG6WcnmR9fUfY9vD6HOoqlk6ndskEioTE+ei/orJyePB4q9IIqFQLp+k0bjOwsIvYNvD6DpaXv4TtrbeIJFQGBs7ddf16E9CbEaWpWGN937uVx+0jBaaUJRKJyLHqQ/yfD+vxAH5ATnsg/ZJ6zbcfyEfFKAP2g3D4edIFP26riynqVTOo6q+R7Ln2VSrlyITCklSKJV80/ThsMfEhD/HPPr8foOU38iys3Ml6la1LJ2ZmScioYRbt36AYTTJZitMTp7jJz/5N3ieiKYVOXXqb5FMllhbexmQmJ//FNXq5eAmDbq+Sbe7hmFkcBwDwwjF9bOk0+Ooah5dr1EoHGEwqDMYNOh0bqIoGpZloKqZSLkomcxhmi2azRu8/fa/5mtf+98zO5tnY+MnqKrIyZNPYRhNEokkspxEkiQWF3+JwaBJpXKBWu1dHMfC89yg/piMFiT+cdXRtDKZzFQw2qVRKBzj2LEvIoo/YDh8nvX1HzMY1EkmJ7DtDqlUkWx2AsfxU6e2PQhGZETa7TWSyTL5/BySpOB5NsNhC9s2ARFRTON5bvBeO4CLpmWQ5Xzwd7XRtDF0vYYgyChKjkZjmV5vC0Hwm6IymTFse4hh9EgkFFKpcZ555goXLrxItXoZ206TSCSDRZ2IppU4ffoC169/F8PoAzZPPvk6589/B9O0UJQcrusiSYmgs9+K1KNyuRkEQcCyhqRSvnGD7y0toCg5PE/hzTefjzrRf/jD/5K/+3f/d1y48B2eeeYyr7xyjj/4g38bNbElk7/H6dPfwXF6VCqP0m7fwTBa9HobuO4CipLBtvv0+ztoWoljxz7HYNCk0biOKEpks1MoSoZUqsRw2EUQwDT7pFLjOI6FIAi023eixSrAsWOf3/M1ZDQz1GzeZG3tJcbGTjM9/fh9B8YPp4y2aw5zv93cMXuJz9B9MhqQDutK/CR1G+6/kA8L0PvHukZvDqNfwa8rq2oeVfUDWhjQ6/UV+v1tBoNGJK4QqmvJcjoIqi1KpeNMTT2KKCYYDrtsb/8kSHELKEoWgHTaVyhyXZtqdQ1FSQbNMS79fo1i8RiiKJJKTZDNTuML5xfRNL/Rq9O5jarmWFh4jrW1H+E4ZnDsBRzHQxAsyuXzeJ6vKOa6VtCY46siOY5Bu+2PVklSgomJ8xhGk2SyhCjKmGaPVGqSnZ1lZHmALPexbZP19R/heX73ebF4NAiMAuPjZ7CsPtnsFHNzz7O+/iquawZzqlVkuR2IpRik05PBX09mOOzSaCyzvPxnOI4VNG/J+OYULQRBDAzpy6RSE3S7WziOg2l2cF0XQfCCkSoL2/bT27ZtMRx2AxnPFJqWQVHyZDJTjI0t0W5vYFkdLMtAUfJBoPZ9oBOJFLncAqFms2F0SCZz9HrbqGoJsOj1dpAklXR6nFLpGK3WLUql42QyEzQa17GsPv1+jUJhnq2ttxkOu9i2iSQlguDeQ1WTQbZjjs3NN4IUeRbXHSKKKTzPRFHyCEKfbreHKEIuN4ksq6ytfXlPo9rGxld4+um3GBs7xebm1/b8bH39Kzz//HXy+flgtn7I+PgSmnaWUmkhkKI8i2W9gaKkoyyRvzjbtTAcDGymph6lXl+h09mk39+hUDhCoXAUVc1y584raFouuqecOfPrdwW50WvTNPtRyvx+rVwP4kFLc/vr0eE9I7w/jDrAxYH5cOIzc5+8V+rnk9ZtuP9CPixA7x/rGu2yDtPG3e4G3e4dxsbO0Ottoqo50ukKgkBUY3Zdm2JxAUGQogs31Lfu9zeoVn8CQD4/RyZToVhcoNerks/PMhg06XR8KUHH8XdFm5s/ptW6TTY7S6m0GMwyb+C6LkePfjHQ/m1gGF1UNYMoyiQSGqGQrGn2keUUviXgSba2Xmcw2MDzYHzcoVQ6Ty43hetCv78dnQNZzqIoORxnSDY7Fehcj+M4Ou32WhCUuzQa19H1BoXCbGAsP4WuN0gkUriuTbt9B3BJJFKUSkcoFI4gCP58qmWB51k0myt0u1Vsu4+q5hEEPwORyUximj1c1yKXm2J5+U/pdG5hGH0kSWY47AUNaxrV6ttkMmNoWi5wr5LQtCSW5VtNuq4TyTY2GsnAi9lCVTMUCjMoShbLajM9/QTF4jzt9iZgBg1525hml0JhgX7/DqKoMD5+msGgG3QVdwLFNgXTHGKabYbDLBMTFzCMFslkPmh8uo0kJbCsFq6bpd2+iW330bQMyeQEkiRiGDrgIstpstnJQM5yksGgTjZ7lI2NlzGMK6iqhiQJWJbLlSu/zK1bX+Dcucs8++wyp0+/wQ9+sGsgceTIX1IqHWN6+gl+4Rccvvvd3S7yJ56oceHC3yWRSFIsziJJKoIgIUkJbNvEcczIcnM47NDv+/cOSUqQSGgYRptWaxXbHtJs3gjG/KpBj4DC/Pyn8a1N81HTXcj+e9HotTk39zSiKDEz88QHCnwH3e/uFaT3q4ANBs2gXDMWLFztn4tS3wclDsj3yUGpn/0f0IMaLT4p7A/Qmpan293Ede09Kfqw+3p0RdzrVXEcm2ZzlVSqFO2SR1PekpRAltN3dXAKgv+cU1MXKZWOR+ffNPtksxU0rUAiodFo3GBl5bsUi/PBTWACSdIYGztFLjfDzZsvcOvWC5imjiTJlErHsSybbnedcvk06XSJwaDFxMTZwCIyh+ddRdNyFApTOM4Z0ukper07JBJJWq2btNu3IxnPVGoaQRgGqmAi+fwRTLOPKHYZDjsoii9f2etto+vbtNu3URSNubnngrSugOd5kdOTYdxhMGjR623Tal1lfPwcqVQGWc5QKJxElhPs7NwI1L4cBEHENLtksxUWF7/K9et/Tjo9zubmWxhGE8saIEkCniciigKDQQtRFILxMpNUqkQikQxqvyrp9HSQnk+Szc6ytvY32LZJPj+J68LExOmg81cnmSxRr1/BcQx8owJ/nMw0ewiCiGX1aLUMwKNYnA8sNwtIEiQSSZLJEoqSZTj067g7O++g6z2Gww62DWNjC4HlpT9C53kSjmOSySwwMbGE61rU69dwHA1B8N21EokM5fJRpqefpFZbpl5/N9AtV9E0jUuXvsi/+Tf/TwTB5qWXEqjq/43nnnuZcvmf8847S0xM/HuWlr7NcHgOELl48WX+/t//CZcuneCRR27w5S9nKBafJJ0eI5PxMxOdzh263WrUVAiQTJbwdccJro/xqORiWUaQPXKwbZOxsSUqlfNkMpPR5/ygXeVh0paua2OafebmnsEwfPvRcNLhQYPzQfe7/Wp9o41jvV41kPJUuH37JRQlQ632DouLXw4MNYh802MOJw7I98lBqZ/7bZj4JHZm+/XdNsNhi0RC29NlDdBq3aRUOkEioTE//xyiKAV+waGu8q6P8uio1GgqznVthsMOlcqFyBQ9ZPSG4Xd7b9NqrWEYdcbHz0S/Nxx2AUgkVERRJZ3O4roOjjPE9xnOkUrlabXWIitISVKC8aopBoMmyWQRQRBptW5TKs3Tbt9G1xuBfKf/t1fVNCsr3w00r7VAKazDcNigVDoVNEadwnEs6vV3SSZnmJl5kkJhDl1vBrPYJSzLYnX1+4yNnUXTfD9lx3EwjDaynKFSOcdg0ELXd8hkStj2AsXiUcbGzkRCKIqSJpUawzR1ZLlAMjlOMllCEAR03Q/yIKGqBRQlhWHUaTZv43kWqVSFVKoQCawkk2NRc5v/99VIpTIMh208zyGTmSSRSCGKItXqFWzb39WFwTOVKjE2dpJW6xae5yHLWXS9gWX1Ap3wBXq9Oq5rMhg0aLebpNNl3nzzM9y48XucPv0WS0sJPM/BsgxAwhfC2CKdzpHLHaFafZvhsI9pthkMdqLRI0X5WuQu5nsKJxgfP0GxeJzvfve3o52wINhcu/YUv/ZrGvPzXb785VdZX9+g2cwFHf47iKJEKjWGouQYGzvN0aPHGR9fCsoTfi9Ev1/DMHz1t/Hxs4yP+1aIqVT5rsBYr68EM+w2hcKxIH2/RaGwsKdH435Gj0IOyk7dy+npXhzUH7IrQGLvESAZLdfpeoNOZ412+06gZtdlcvI8oigyM/P0J+b+91ERn50PwP02THwSO7PfK0Xvug79fi3qsp6ffz5aRfupuOIeDV7wz9N+mdGQUBe7Xr/G3NwzexYBmUyFU6e+Rr1+nUJhNpArtOl07jAY1IOb3yV6vXUKhWOkUv4NdHr6sSiN7adFNSRJIZ2eiHYYqpqN0o253CyDQYtcbhrX9WeOe70dNC2F605SKp3E82xsW0cQ/Bu4r7udjuqi/gJGIZOZZWLiLNvbb5JIpCkUZun3t+h0rgcGGzLT049SKBwhkUhTLh+l329gmjksy0bXr7Gw8EVE0e+4LRTmaLc3cF0Ly+qSyy3gODqaVqLf38R1CawaBYrFo7Tbt8jnZzDNbjCa4+K6QwQhgW0PEEV/tlmSZAxjEFgHFsnlJpCkJJKkBgIYM8GCcztY9CiAh+vaJBIKnucgy75QRqt1g2ZzleHQ7yLP5Y4EdeA7uK4vBmLbNq+++in+9b/+V4iizYsvJpia+lc88cQrmGaLVKoSpNuTgTZ5jURCRZYzDIe9YOGXY3LyqaBMcZt+v4YoKkxMHOfYsc8xO/sUTz21xb/7d49FKeilpTeCWu41trffwnVtZDmLLGcpFk/xyitn+R//xycRRZvvfCfB2NgrfOlLPyaZzFOtXkIUExSLC3Q660GAuoFhNKNrZH+jp7/IkxAEl2SySCpVwjT7tFqrWFbvfdV+D8pOhQuB98P++9ZhAiSj94LJyTSbm28yMXGelZVvUywukMvNYlm+XvoncXPyYRKfkQ/A/V40H+cRgHsJy4+m6Pc3vfk1pL0raV+Zq4ooSoyNncYw2uh6LdAIblMoLEQpPde1GQyayHI6GGdy6XTW0bQc9foKlcq5PcdSKh2nVDpOr1fF89zA4anI1tZPmJx8JDB+sBkOu/R6NaamLiLLaSRJ5tatH5BMFrGsIa5rRHXknZ1lNjffxPNcKpULZDKVQOrSX0QMBl16vVskEifpdtdRlCTF4jFardvMzT3L5OQj1OvX2dx8jZ2dIbreiBYfguAyHDZRlAxHj36OnZ0VVLWE43iIYhJFUdnefgdJkjhx4pfR9TaNxlVSqbFAmERge/sSnufguk7gVDXLu+/+h8Bf2kbX/dnX8fHz9PubZLPTJBIq+fwCrdYNqtV3GAwawTkE2/awrCayPIFh7GBZOpblGzH4zUh5KpWL7Oy8gyhKQc05ga9BXmJu7jmGw26gKe6fRL/jWiWZTFGtvhXM4wpIksrY2Bk0rRDMbMPm5lsMh21u3/5sNPsrig6vvz7D5z43TaFwHMOoU6mcjYKZIIhMTT3GxMQSy8vfwjS7TE4+gqpm6HbX8DyXXq+KZenBbnQeSVL4whd2+O/+u3/O5cvnmJ//a776VSfoWs8xPv44qdQGnc462aw/MvWd7wwZFQn5q79y+cVfdBgOe/R62/R6G+j6ebLZSlBL3cE0u4cG2FxuhtOnf5WNjTdIJvNRk6NvqqLelS26H8I6bph98het2ns/8BAOum8ddM/bfy+Yn3+eTmcd3wWrQCYzuWfHfZjudkwckH8qfJy7ru93d7//90ZX0uF8seMMSSbLpNN7tb1t2wjGhprR41zXDsZ7lMAndotsdgrHGVIsLux5bL2+EjghaWhann6/hqbluXPnR3Q6a1Srl5iff5p+f4tEQkaWUwiCQL9fY2vrJ/T7VSxrEMgU1pDlDDs7V0gk0qTTE7Tba2xtvcn09EUajRtBvbmD6+oMBh3gZuDk47sYCYKAKCbJ5WaR5STb25cYDrsMh23y+YVIsjKfP0IqVcbzPFKpIo3GFUqlE4yPn8ZxBoH2toRhdJCkBJ7nkU5XgsBtoWklDGOHbHaSbneTnZ1rWNYAXW8yNrZINjtLPj9DrfYuk5NnuXHjL2k0VoL0tUIiIaMovq53r9dAUZLkckdIp8cxjDaNxgqiKKEo2aC+rdFoXAVEbNsfA6vXryEIAuXyIp4nYNsDHMfvAp+efop+vxoF3ULhOKqaRRAk5uaew7b7NJvXyOfn8DyXev06yWSeixfX+Zu/8YOx60pcvLhBMjmJrvs7/SNHnuO11x7j1VeneP75Ab/5m5MoSopeb4dO5w4LC18gnS7x7rt/iKIkyWT8skYyOR7oPx9lYuI0X//6VTY2vkmjcY1OpxTU/wVSqSKZzDhHjjxDq7WF61o8/vgaf/RHz0cLhS99KUUy6e8YfS9rkWLRH3caG9v9DMNu+ncUUfSbu1KpIpKkIoqJPX0UB4nu3A8f5uL//d63QhtITcuTyUze1WNyL93tn3figBxzT0Yv8Ht5It/r9/xdq40gSJFgQXiBhs0ow2EXz3Oo1ZYZDlvkcnMIQoKZmScwjDZjY6cCf2Mi8wnwa3E7O8vo+g7z88+j63X6/SqdzjogBU1JU1E39/j4qWC8pIFt96lUzgUd3QVqtaskk1nW11+l0bhKuXyapaVfQRQVNjZe4fLlf08qNR7c3EsAqGoORcmSzU4jSRIg0uncxjAabG+/Q7u9yfb25UDgwU9PKkqGcvkUkqSRTPoNL7KcQlWzwW78dKD0JNHprDMYNFhYeA7P84IU4Ay53CS93jaG0aLd3qDTuQVI2HaXwaBGo+EyOfl40HRWxLaHQc1boNPZRBB8/ezx8dOAGIyKiShKhuPHv4hl9YJdpW8TaRhN2u0E+bwUaHP7HbW63gxGwzxyuVl03RdD8Rt4JvA8k2r1jcA+UELTcpRKJ4PdaBJVLZDL+WWGXM5vJPuN38hz6tRrvPBCgnPnlnn00de4c6cfHOOA1157gv/+v/8dRNHmz/4sQTL5Ir/xGyaTkxdIpcrk85P0+w0EAVzXY3r6CZaWjlCvr7JrY6mRz89x/PjnuXz5DzEMnVrtMtXqW8zP/wKSpKIoaWQ5jWXp/PqvJ9ne/se8/vo0jz22xvnzM9y8OcC2DfL5uT1jfPfb4OmPBHUCvfW9TU/vN7D+NBf/90o/+9rbzWDSwNcZCHf/5fLiB0qlf5KJA3LMPbmXVOb+XXEmU8G2DW7d+gGe5zAxcXaPak84k3iQHm6xuMDa2o+QZQ3XdRgOu5H5ejirXC4vRv8fUi4vous7qGo2mnceDJrRvwVBpFr9CbncbBDM9WC36ZBIFMnlplGUDP3+NtlsBUXJUSq5WJZBoXAMUUxw8uSXcZwhOzsrgBhY7fmCIIbRCjyfVRzHZDhsIMsZPE+g1fK1uG3bt+BLp4uB4cRUMJK0QKezSa+3g2m2aLfvoChp2u1NEgk5qPXeptW6wcqKgSDAcNhmcvKRoMYtoGm5SM87kciRzZ5hYuIcut5EUVKRwIeqZoMu7Fm63XU6nS2y2ZnAVKIX7Or99GYyWUaW04yPn+LOnddot32HLcNokUoVAtELnXR6GlGUEUWJhYXPBjVkMVDlSpNKFWi1riNJaqDtrWJZemSTmclUOH/+69y582N0/SaqmiednmA4bPKFL9T44hc9Wq02m5sWOzuXSCSSuK7LSy8lR9LHDi++mOC3fivH0aOfZXX1xWAx9Ba2bWKaA8rlRcbG/IY6Vc1FC7rwM7i09KvcvPkCKyvfotvd4tatF5idfY5UqhhkCNI4zpB/8A8+x6uv/q9MTT0VqJvVMc0uCwuf2TPGd78B0Q/gxSgDEjY57r/uHiYOs2UcHY0CKBQWAm10f9F8584r9PtbzM4+zeTko3c1jMX4xGci5r45bPU+GiDr9RVarZt4HqTTE3vMKHq9KoqS3dN4Av5FvL7+Gq3WTTQtT6FwlNAcIpXyzSkajWsAUe149MYwN/cMtdoyltUPUqs5FCUNSBhGA9d1MIxOcMMfB8aj7ulWaxXT1DGMNpKkMRjsMD6+xLFjnwvSwFeC5iYV1x0giklsWw/el4QkqaRSY5RKx7hz52UUJRuYPehkMkXy+WMUCncYDjsUCsc4evQXAInhsEmns0mrdYt2+yaKUkCW00xOPoYsp9C0LIbR5ciR56jXr5FOj9Pv+5Keg0EruPE5lMvn8DwHz1ORZRXTHNBsrlIqHQucsPyshKblUZQcmcwEpdKxQHPZn+X1rRrHaDZXcF2XH/7w/0U2O4ckgSxrjI0dI5FIReIrkiTiOCaVyhKa9jzpdIVi8QhXr36LTmeDVGqMdHqCwaCLLOcwjCsUCkUymRlUNY2u19nY+BHT009Qr+eDjm2BfH4W2x4wGOywtvZDisVjKEoSSVICsZIEyWSaubn/iOt+JUppP/lknVZLjzIdpjlAkrRANnXA5uZbLCz8ApXKBZrNVRQlvefzAyCKEuXyKdrtmziOgGV1GRs7Tbm8yObmG4C/UPnMZ/6v9Pt1Op3JQCpykWSy/L52feG1MWrE8rCz3zEqvJbD6zlszEynx4OUfDm4ht8FHAQhcWgwj4kDcswDMLpq339DCxtQyuVFbNug1/ODWTJZjFyJDKMZzWSOzk7WastBJ+5c0MziN8lMTz9BoTAfmVOEXawhur5Dv19DVbO0WjdwHBdJEoM551LwmHna7TuoahpJ2pXflKRE0Ay2SLX6Dp3OHYbDNslkkfHxMxQK8wwGTdrtNWq1y1Qq5ymXTzI393QgH0m06vdnLt/Frx+LkftSp7PF0tIvk0xmWV19gUrlNPPznya007Ntg1ZrFUXJoyhpCoUFcrlpTLOHYXQZDrtoWo7FxV9EVbPcvv0y/f6bmKZLOj2NLCtYVpNud5PJyXNomi+kkclMMBi09kiI3rz5fa5c+Sa23adUWiSdHqfbXWd29lk0rUilchbHeZ533/1jdH0HxzFYWPg84+PnEYQElcpptrbexHWh0VgOPgMempZlYeE5XNfGtoeBDKVDu71GJuOnyf3mHZlEQqZcPkm9/k0Ggwabm28higqSJDMxcRZFySBJKqbZQZI0dL2GafaDGnuJXO4Iruvx7LOXgX/Izs5v8pWv5HnmGZNkcpJkssjY2FKwQ36bqalH6fW2yWT8MkO7vYZhNGk2V0mnx9H12p5gYhgNSqUTSFKKycknGR9fIpebIZHQ9tSDwxrx0aOfjr73fna0o4/5IM1XP01GgzDAqBhIuLgIJXAFgcgJbWnpa1GWa7Sm/nFYhPw0iQNyzPtidIXr/7//b03LY5o9+v06OzuXI5/i0Vnj0d2ArteDnYzB+PgSrdZNhsMWpukHozDw+7PLbRqNa8H8sP88yWSBwcBGVfPIchLD6JLNTlGtXg7mZCuk02MIghTNP/tNSrs2dK2WP4qTzx+lWPQXAL1elWJxAU0rIEkqnucxO/sU6fRual7Xt3Fdvzml3V6nVDrGmTO/Rqt1i+3tdwCo1a6Qz88xNnYK0xywufk6tdpVJiZOk81OMTFxhvX11xAEgcGgRrdbwLZ1FCUXzAGXSCaLdLubDAZNHMfXXwaPSuUC/X6NVKpEMjkWNIj53eLpdDmwfPQbhAaDGr3enaD73aXfrwIuKyt/gaYVqNUuBwpox8nnj+J5Fu32FkeOPE2jcT14f6cwjB1McwrTNIKbswNAIqFx/PgXabVu4zgGjcYqmlZkbu5ptreX6fer6HqDbneb6enHqddXgiaoHLKsMjv7ZCBIMhb4T3tMTl5AkmS63W3K5VMYRp1ut0o2O8mv/qrC0aNbFApJyuWvYhjtaB54e/sKw2GLQuFJpqefwrJ0+v0aspzCcRwsq4+iLNDtrvPSS/+c6eknWF//Ef3+NuAyOfkIltWh211nMGhSLi9Sr68wGNQZG1uKxr1gt4wzusD8JKdi9ytygV/7BvYEZkEQgtE//zoPpUNHnyfeGd/NJ+8TE/NT4aAVbipVZnPzTTY2XiORUINxBzHaPR+0Gwi7LpNJXzKzUDiKZZmkUmUkSQ1mOq/hS1guUigcDW6OjShlHKYLu91NbLtKrbaMb30nR7vE0VEqIFq9A3S7G0ENVou0tw2jRb/vdzD7kpYyljXYMzMtSSoTE2fY2rrEzs47qGqOREILLBOfDez1/KxBs7nKYFBjdfUlOp2bdDq3WVj4DJKkIcvpQOUoiWm20PU65XKObHYaVc2yufljer0a/f4WAMNhk14vQbe7ETkCpdNjdDobWJbOsWOfQ1EyKEqaavUSxeICxeJxKpULbG/7Jh7Z7DyGsUMmM0WrtYIgqDQaK2Sz0+Ryc6yu/jWdzhqdzg1EMYXvDnWcdvsmvjNUmsFARVEyeJ4DJJiYOMPExJkgKO0EXtCdIF2exPNs0ukcqVSF8fHTeJ4vJGGavi1mJlMJMh7+Tj+fnwt0zVtcvaozGNRpt68jCBqFwinK5ZOUSseDm7tGp7PO+vqPqNevMBi02Nl5B7BJpQr0+9vBqBRUq5ewrAE3b77A5uar6Po2CwufDWRCfYvMVKpEtfoOgiBG0paW1XvP6+DnIRW7vyckHFXc302+f1HySV+sfBjEZyXmA3NQk9bk5GNoWiGwnLtDrfYuc3PPRHWm8KLcLzag63Wy2Up0gwYolU4ARLs9v2bqUSotksvNRDfkcIeUzU6yufkWpdJREgkt6sjW9XqULh/V356ZeQpNK6HrO2xvv83k5OOIot/41ett0umsU612o9fKZqewbYPhsMPExFlsW6fVuo6ub7K9fYlOZwtVTeHbSyo0m6tomt9NnU5PY9s6yaTvFuU3ZV1GVSci/WNRVILU+RK9XhVZzpDJyLiuFYiqFAAPTcuzufkWggCdzjrd7uYeSdKbN1+g1bpJv19lbe3VYDEiYRht7tx5CUGwEQSZfP548Lq+FWQymY/GxwRBoNfbIJFI0un4phmKkqZUWoqsAXW9gSAItFq3yOVmkOU0udwsa2s/ZGfnGqKYYHHxC/guUULU5dztbmIYLTStEH0uBIFo3jvs5F9Z+S4bGy9jWSaaNobrWjQa77K+/lrUnCWKCRxnSKu1iesa+PrhQwaDerDwWkXTChQKC4Er2IDp6Yv0ehtMTT2NKKocP/45Op0tisV5MpkpFCXF5ubbZDITyHKGdPrsgTO499J8/yQymg0Y7SwfPQ/3UhID4qauQ4jPRMxd3M9K9rCdQKVyjkRCi266rmvTbN5E13eo11f21O4OupjDnWx4HGENavQ4LKuHLGcYDHY7tsPgnkwWabfvIAjQbq/t0ccevVmOPl+hME8uNxOMGDUjwQJ/DMlD08o0GitIUoarV7/J9PTFwCYxTau1hiSp5POzDId9ms01Op1bSJJKsThPqXQ8Ct7T048FHrgdhsNWMGstkcvNBP7AejC/OozsJkORlW53A1FUovegKGnW119HFBV8Wcci+fw0INHv14JO8xq3br3I5uYbbG6+hihqaFoBWVaxLBPHMej17tBqXQc8VLWAIIjUam8jSSmOHHku2AFNU6+/GyxSbKannw2a5HJomt8o12zeDALlTSRJYmrqcQqFBba23sY0O6ys/CWC4CtUhTKo/ogUTE5eAIjqj6rqu0A1mzfZ2nqLwcC34RQEkfHxs6hqilbrFs3mKonED5mbe5ZcbgbD6NDt3g5sLFMkEhq93jaSJGNZfVQ1F81zN5ureJ7D1NTjGEaNXs93y0qnfTOEZNKfFS+VjgbOTfcnYvHzlIp90Pc6ev39PGQS3g9xQI65i/u5WA7bCRxUK5qbe2ZPQweEQf/u1wh/3mhcC7yR984rA0xNXaTb3WRj4zXy+SPR42zbYHPzx8FuZuIuAZLwdXu9ahTERxcfYb17FMNo4Xlw9Ohn2dp6G8ex2dm5yvz881iWjiwnGQ57LC39Ku32HWzb72zWtDSFwjGAaPzDty60abdvYBi+hGahsEAyWSKXm6XdvsPExBls26RYXKBavUQ+PxsFKX9ON8/k5Dm2t99lMLhKq7VCKlWJsgGa5nctA9Rqy8FY1pBEwvcvtu0BqZTv0KVpRba3L7Gzs0wikWRu7nk0LRU5KWUyU1H2QlWzDIctjhx5nnp9GUVJBguEXWU113UQRYnNzdcRRY1cboqFhc9w+/bfBBKkm8zPPxd1zrdatzDNHo1GAVnWor9jo7FCs3mDVus2ptkjnZ5gcvIRer1tSqUFZmefptlcDerqrehzUS4vMjf3aZrNq0EzmIth1PE9kjUkSaZWu4LnOYGQi++P7DgmilKkUjmNouSC7vubuK5DOl2JFaUeAF+ydndhGy7KR/UKQltW+GRnEt4P8acsZg+jWtP3ulgeZHW8P0jvT3cdjEAyWYyCZhhIG40VSqXFYJclRKYHul7Dceygwzp/lwAJ+A04d+68gqKk96iCtVqr3L79A44d+zy2PYwaz/r9Gr3eJpnMFLKc4ty5v82NG39FJlNBllNRQ1aYAi0WFxgMmmQyUwyHviyoquYCZSwJz7NxnCGJRIrJyQUSCQ1BEEmnKwyHXTqd25FT0Pr6jzGMJvX61WCXXiCRSGJZfbrdLSYmTgf2k4u4roVhtCmXx6LOcYBUaoxMZoqpqQtcvfptarVLQdOVSTY7haYVyefn6fW2SCaLFItHmZ29SL1+A9PsBcYTbbrdraD+O0mjcRNNK5BKTZJKFbGsPrXacuAjnQ9q1znq9WX6/c1AUvNZdL0ZdLYrgRSqTS43HSiiqYRSm6Euci43Syp1JfDB9hc2jcYNkskxcrkZCoV5qtVLDAb+vHmYsnddA1lO43kekpQKHKwU2u3bbG29Rbt9m0xmkqWlX0EQZO7ceYnBoE0m45FIpKIFoCz7ZY7RRWTMe6PrddbWfki9fg3XtZmZeYLQJarb3QQIBFvs+LweQHxGYvYQjieNihQcRrjyHe2cHt11hg1ScLe4/r0C+uh8pn/zdkYe6wU7xiyFwgIzMxeD0Z5itPru92t7Ol9HUZR00GhUoFZbplxepNNZp9Va5caNv2Js7GTkaAMwN/ds4FKUxDT7nDz51ei9hvXs4bCLIPgOV8lkiUJhIRoDyufnMIwOnufPYEoSZDJlJibORhZ9mUwl0On2dw2NxkqkdlUozNForOJ5NpnMJFtbb2EYHVZXXwh2xAU6nY0gmBcDtTCijvKTJ3+J4bDLiRNfDpqvPATBfy9+V/sdisVjaFoJVU0Fwcyh2bxOr7cZZQASCZVEIsP29pusrq7TahU4dep5LlyYRFEyqGqeZLIc7SabzVs0m9cplY4jCBInT36Zen0FXW+QTBaQ5VTwGbuOKIq4rhu9f7+5bz4al9O0fCBP6XsL63qdXG6GSuUcvV41SNHX6fd3GA67TEycJZHQooWSLCe5efN7rK+/jmUN8LW1S/R6W5TLJzHNPvn8LLDbMeybIXhByeTjMZL0syJcLINfdvA831YTfGnb0KZ1MGgwGDTxTVeKhxrJ/DwTB+SYPTxIU8qo3Zvn2ZFg/Oj3B4MdQLhnAN5fsw5/t9NZp9+vBn7Du96vrmvTat1EkhJRvdi/wP1Urec5GEaXsbGlPVrXmUwlGh8aDPyUsWG0WVz8EuvrrzE19Sim2Y+6sSVJRhA0+v0qN2/+hETCr0fPzFykVlsOHt+hUjmLYXSQ5XQk09nrbdLr1ej1tkilJtD1GmNjp/bMcdu2EdVTM5kKpdJJisWF6H3453gH8BgOu+h6E9Ps0OttIgh+cNK0IpbVJZFI0G7fQlVzgQjJAiBEcqOynObChd/kzp1XqdXewbJ0BCHB0aOfxrZ7wXn1UNUsY2MnuH37b+j361hWD0nyHaU8z+Wb3/xrrl5dYW0NEol/zec+d4z/5r/5X5iYOLunrCBJYmAIskUmM06zuUpofDAcdpidfZJEQkGWM7Rad0gklGg+eNR8IExvO44ZmH7YmGaPzc03owyKIPgmFo7jRDt9/2+wFQX32dmnse0hjjNgYuIMiYQWzMgvkE6PR+dpNGtj2wbt9hq2bUQNfTF3MzoJkUyWGRs7QTY7yfj4EmtrLwfX8BiqmqPdvhX93UYbK2N84k9YzB4eJBU9Olsc7mR3V8rhjrW453cP4l4OMKKYiHSCYW8tOXztZnMV0+xRq71DpfIIkqSiqn4N1X/uKvX6VRYXv0S/v83OzrscP/6LZDJT0XGNj58OJCGHkdIQ7AZORcnR7a5jWb0g8OWD1G0R09SxrB62bWLbBjMzTzA19Ti3b/+QwWCHTmedUskPEmGz1urqC3ieS7G4wNzcp6LAMhqM/fN6DcsyaLdvMz5+jnJ5ifHxk6ytvUKns0ajsRKIcQjIsoZl6SST/jkvlRYJLfhs22B9/VV6vS0Mo41h1KPu82x2jsGgRrt9k+GwiyynGRs7Tbt9G8vqouvbbG9bNJsaL7ywgueBqsLiIuj6Df78z/8lv/M7/wsAa2svB1mWbjAulKXVGgAeY2NLZDIVHMek1bqJqhZIp/1F2HDYxzBaKEoqcOVqBHXrbjCnruNbFPYCr93byHKWfH4W0+wHzVfynu78fr+G4wyp11eCHXBoAJFGVbOB+lmNRmOFYvEopqlHnfq53AzV6iW2t99G04p77D5j9uKXGU5E/w4zSGHvwWDgZ0UEQaJYPEYyWb4rYxbjE5+RmA+FZLIYKfT4TTPqntnEe118hznAjKauQ4Wu8HuhD+/m5pu0WqvIsl/vHA67VCrnqNV8MQrPc3AcA0lKsL7+WpBe9ueXD9LoDsd9whtKo3EdVc0xN/dM0DG+iiRJ6HqDmZmLUc1Z1+vBAmCHZnOVSuUcrmtz5cqfks/PIUlKNBcsy0k0LY/jWLiuGy1EwF8AhLsNWU7T7+8EYiDQ6dymXD4BiJRKx8jnj5BM5hkOe8iyRqNxnYmJ01iWEcxpH1yjN4wmtj3k2rVvUS4vkk5PAh6FwhFMs0ezuYaq5jh79te5efMF+v0tdL1GrVYjkYB0GiYnIZUCz4N63bfUDBXXFCVDt7sRNPisUamcJ52uBKYYM9GizZe6LFKrXWE4XOf27duk0+NUKucRRSnatUqSytzc2UDgpBkF1WZzlWbzBo4zjJ5rMGjiezFrkROT59msrn6fTudWMFolsrmZRBB8CdBEQiWZLCNJiT0p6nJ5cY+Ea8zB7DfTCM9feM4mJs5Gwi2jpS2IZ5P3E5+BmPfNaGpaEAhkMQUMo0syKUXOTaXSibvcb/ZfiAcZn4e7db+Zyw9S+80utrbeZDjsMDf3qcAH2N8djo8vRf+enX2K9fUfk81Okc1OkUqN7QmAYRPb6E5f1+t0u5s0GjfI5aajnfr8/HPU6yskEkk2N99kbu6ZSLlJ0/Ksr78W2UP6zWzn8TxIJgtsbr6JYTQpFI5y4sRXogVMv7/NcNim16tx7NhnyWSm2Nh4A0nSGA5bTEycY2LibFDP7WKaPYbDDpXKeRzHYmLiLJubb1IoLLCzc4XJyUe4dev7kYqWr1p1lLm5ZxkfP002W0HXOxQK0yiKPws9HHYQBIlGY4Va7V0UJcf09GM8+uhvc+nSH+I4FqWSjW1DIgG2DZLkf83ncywv/wkTE2cZDNoMBi1kOUkuN8Xk5KMUCkepVM5FN9zRz0IioSFJCTStiKoWSKVKgQ7y3F038PB3fYnODJKUQFGyZDIVyuVF1tdfQ9d3EMVE9Hrh56pQWECW08iyL9wyGLQCkwuBUukovd42Y2OLez5/YVCv11fu0l4/qHciZi8HSYPur8fH4097iT9FMQ/M6A1pVAt4d6ShENV6h8N21PQxeuPafyGOPn7/DW5/SmyUfH4+MKl/FF2vs7OzzGDQpFI5FzlS+TvnDp3OHdLpCtlsJXL8GW1iC60bVTUfNIbtRPVoUdyOxomSySK9XjXwA16JpBX9NOjYHjchUUxEu7mpqUdpNldJJot7Zqc7nTVu3/5BoN3cIZ+fp15fRpbTTE09TqVyDtPsY9sG1erb6HoDTSuwsfFa1HEtSSo7O9fo9bbo93eCFKEYjSMBgXiGhaJkyeWOMD6+FC14dnaWUZQM4+OnkSQF0+xjGA1s22Bs7ASdzipPPvlLfPrTN/nBD94hlYJmE+bn53nssc+QSlUYDnuYZpfhsIUkyRw9+gV6vW1UNXvXAmz0MzQ2doqxsVN70p27JYq9qm7hV1GUWF9/haNHPxs16MlyklRqLNI+D99zeKM/ceLLAMF5vBT49U6wtvYqtdrlQD71yJ7PV72+cpexyf6FaPgZjnlwfh6EVB6EOCDHPDCjwTRs1EmlxqP6qGE00bTinhGc/avggy7Ew1bL+1NiIalUmWx2KhIhgV0f1rDuHI5DaVqeZLK0x5Un7AANU5K9XjUKkv4uucFw2CGdnkQQpKBRyk/5FosLNJuryHIyqDX+hImJ85H/a7hICQOeIIBtD8lmp/B9hOuRZeXMzFOUyye5ffuHQSPTGPX6FJKkRrswPwD4M7WKkkUQpMDusUOvV0dRfBMHxxmQzc4DbtDx6uB5RDPdvtgJuK6551yqap5Wy18sVCoXGAwaeJ7f5NXtVsnnF+j3q/zO7/xdnn76FhsbbY4cOcLzz3+OYtEfncpkJrFtHVnOcvLkl6hWL2EYDW7deoHJycfxPJta7V1mZp4IhDn8XoDRv20qlThwURZ+DsLPxebmW3S762xuvkWl4jteyXKa6emLdz1u/2KgVluO/l6mqaMoaSTJt1kcLZkAUXAfDfKH6bLHPDg/T0Iq90MckGMemFHHl8OsGN9L5zb8nVGRjgddLRtGO7jJL0ciIKXSYjSbetCNM5TZBAJbxxVSKX+2dXRHu77+Gn6KXMJ1LdLpschOLtzhSZK/u5XlTNCgtLsIgN2O3cN0v0NEMRHtEn2lLpt8fobV1b8mkfDtE33rwUL0uFA+NJudxnXNwL/5CJpWiDITvh2l36mt6zuMjZ0K3kOR4bCDbRvcvPkCtt1nONRR1TSO4wSmFsXo2PygvEY6fQRVzfNbv/V7dLtbkceyP2LkN9fV69cQBJF2+w75/Bzd7lawGCpG1py+ZnSB4dDvhB/lvVKYYXDN52fpdGYoFhf2/J0PCub7mwaTyWI0YuV5Dvn8LJOT5w/8jO6foQ/PyWEuTXFNNOaDEH9iYh6YcBc5GnhGf/ZeOrewd1RiVP7yQaX42u01trbeJJudIZ+fi2qGsGuWPspoqlRVs0HtMhvtjsO0eTJZRFEyTEz4nrihQcXo+xt9jWx2as+x71ciO8gJyHVtqtVL9PvbpNMTVCrnop36cNjD8zx6Pf85wgAZ/rzfrwUNUOei9wu+rWQ6PR51EIdGD6EvcipVRpbT2PaQWu0K7bY/L5xKjZPPLyBJfleyb8QgUCodxzR1crk5RFFiZuZJ2u07dLubgZSlH1CbzZtBzfUsqVQZVc2yvv4ag0EjaE6rBR3RbYrFBSxrQDIpoev1PZ+T91qUhQFb04qcOPHLe/4mo815+/WlR5sGQ0vFw2rAHySoxjXRmA9CHJBj3hejO+HD0sz3EpC/V11493nvfVPcTS+7dDrrZDLjGEY7mgOu16+RTBb3zEmHghlh/S8csxp9H2Gndbnseykf9F7CNHqns87OzjKqmo/OQRg096ud7b9Z+77IdbrdO4iiFAVWw2gyO/tkYL2Yj76XSvnvr9XyZSOr1bc5duwLkdzn6CIo9P/1fZbnI19kv87+LoNBk2x2hlRqHEVJ0e/XyeUmabfX6XZXSCYzSFIqUBkTGBs7RTo9juva1OsrwdhRmkRCpVg8GixwctHCJKyx+wIjW3S7k4iiwrFjn4uOV9frmGaPavUtpqYuUijMv+ei7DA98v0/2/85GW0avNcO96C/04MQ10RjPghxQI55Xxy0E97PvW5so3Xh+2n6Oozx8SUMo4UkKQyHvWiO1LfxywazjwuRxCWAr+O8uztyXT/tPdp8JAiwufkm/f42tdoyxeICkiQfeDzDYYfBoIFl9aPjH1U7G92Vgx/w/YCdZ2xsiUJhgeGwGx27f4zloOmsdpeIQqm0yHCoBy5aV6LzuH/37YtppKK6/traj1CUNJAgna4wM/MEudwMtdoyg0EdWU7jOEMcR8eyFMbGzkQiDmEGo9W6hSD4Dlm2PYzcpSYmzkaLmnA0KZc7Qr9fRxAS1GpXUNU09foRFCVDKuXPom5ubmIYbQaD5l064vf63O3nvRZwowuV8G942K74gwTVuCYa80GIA3LMB+JeN8j70cSGg4PvvW6K+8dOZmaeYH39NSRJZm3tZebmniGfn+XGjb/i2LHPY5r9SGQilFX0X8v/Wq1eYmvrdXK5edLpMTzPI50ep1BYYHn5m+zsvI3jmExOXrjreMKmrNGFSTjOFHah+7OwTvT7rdYtNjd/HO0Ke70qptmlXl+JOp9h70x0eMxANIOt65t4nkO1egngro5f0/RNLUqlo4EpxhWSyQKeZ5PN+oExrJGG5zNMdY/WwwVh928cjn8Vi0dJpcrU6yvR8YUKZ44zDP4eEqqao1b7CYqSxDQH9HobbG35s6m53EyUoRhtmno/3E/tOZxNDzMco6pp4bxy+Phwsbl/oRgT81Ei/qwPIOaTSThOFN787oW/KxmPdo6jHcr7dzG9XjWqFfrayLVodrjT2SS0edzcfJNG4waXL/8hoijRaNzEsgZ76q0hfpNPkWJxITKx95u7MpTLxwNFrjLl8mLUdDWq3xuaHYQ71dA8we+OruN5vs1i+P76/dqIeYW/UxaEBJalc+vW32DbBhA2rTnRHOzoOUilykxOPh7IPtbp97fp9+vYtoFtGwwGTRQlhyhKmKaOIAjoehVFyVKpnKdYPBqpkO1PxWezU1GTmyD4PsO12nLUxJdMlvfMbIfqYmFq2FdKywbpbhHHsXFdgVxumm63Sq32TvR+wllfw2gfWPO/X8LP0L1qz57nkEyWIwWz/T8ThMRd3w874vcT/h0OO+b3+nlMzEHEy76YD50H2R3DXgGQe+1yRht6RtPOvt9wm+npxwLpxyS53DT1ep5EIsmNG9+Lap6jzVdhIAqbfMJjHRUoGfV3DsePdo/n7mMdvbnvdv2ORzVjXfd3n9PTT6Kq2eg5yuVFrl79Fo5jUa+vRA1eYf07HMcJn6Pb3YwEP9Lp8SA4urRaqwwGTfr9bTStEO24HWcYWUmGdpCW1dtjcQmws3MFw2gzO/sUmUwlqsGHQTmZLCIIRGNL+4PYaL3Wtg2SyQLl8kkqlTOUyyeDx7kMBs1IH/qw3e2DNFfdT+05DI77F3qH1aXvlaUZPeaDeiXi5q6Y90MckGM+dB7EMWqU96rd7b9xjt5gw65Zf7RmFYCpqccQxQSynEQQQFFywU6xHhzn3i7okNF/j469pFK79d39xwS7CxHf9rBy13kIU9CZTIVCYX5PwPHVpOYZDrtR+vYgBbPwa7gICc9vaLARzkG3WjdQ1TyJhBYoic3Saq3R661j20Usy8C2/e7psKYLkEyWcF2Lft8/N6Gut5+KNqJ09kEiHiFhcOx01slm/XObTpfRtALHj38hSg+Hi4yD/u4HpZE/CKOTAeHfYr9H90GPuR8/8ActucTEHEYckGM+dN7vzei9djn7f77/RhjaISaT/usKgkAmM0kq5QeDcEcd7lzvdwd/2OsfNMo1GoD3nwe/q3oHXS9GATsMaGGwnps7u6devL/WuWtraUdCJeHCZLQbvFJ5hMGgiW0buK4dyUv2+7kRb2bpLtOESuUc1equMYMgSCiKTbm8SLV6iWZzhWQyNFvQ7llnHdUiD1P9wF2LjMPG4g5KI38QRv8e/gy6r8CVTo+j67W7RvXuxegxH/R5j5u7Yt4PcUCO+dD5KG9G9+qGPSgAHjTm4o/kPPgO/r0YFagYNcMAX3fbcYboepNczggsBYeRWIVhtCO3p8P8d31N7xVUNY8gwGDQClTGxlDVPI3GCo4zxLYNVDWPZfVpNDoMh13Gx5f2NG+N+lQfxGDQoNW6RTJZwLJ6kQqbaXb3dESHx1QqLd6lpjZ63kd3p/fTNHWv8ab3y+jxjCpwhc9/2AjfgzxvTMwHIQ7IMR8ZH4Vq0f5d8cG7x3o0VnMQHySdeJgm836BikZjBfBGaoo1LMtAELzIa3k47EbiGPd/TF7kauQ4Fp7nkclUgkaxFo7jkMmMk0wWI3UsxzGi9HB4TkaD5+i5CxvSNK0Y/N4s+bxv9ODrWp++y8sZvPc8Vwe9v/cai/sog1zYTDY6BhW+bpxmjvlZEQfkmI8MX7Jw60Cf4/fLYYHrQQT/P8jN/qA0+f4doi96snjXcdq2gWX1AzcjjbGxU/skPe99TKM/TyaLDIftyLdZVbOoaoFcbjL4OoOu10mnxxAE6Z7jY6HM6a51psb4+CkajZUope2LeHSxbQPDaEa19f2yp/c6V/vfX5imD+ezf9ocpBb3IE1lsUxmzIdN/CmK+cg4qEv4g3JY4BpNF39Qwf/RGy3sTX0fvCDYu0McFT0JCVO0o3rY/vcPTk8fdjxh6lfTioyNLUViF9XqW2haDlUtRIuf0XNykF3gYV3r4e+rap7BoE6nsx7UgosUCr6pRugVvD8rcb9dysB9pek/SvyF0+Fqce/VKR13Usd82MQBOeYj46Au4Y/yte4lh/ggjN5o/f/f2/Czv7HrftOc73dnvn/EJmyOGg2AqponmSzvyUTsHyfbnz04rGt9/wy5n2L31cISCY1kshjVoEdlSMPnOqh2fxA/607kgxZOozxI139MzIdBHJBjPlI+jg0vh43hjAbF0drjR/3+9gfOgxqk7tUdHKaGi8WFSNM6bKYaDaCjO2ZFydLv1ygUFshkKtHOOkzz+o5N5btGoO61a9y/03+YPxv3q6X+sB5/zMeTOCDHxOzjoPGm0R2yH5R2m7be66Z8Pzf3e/3O/tcId8nhfwc9B+ym2sPUsGn27xJgASJrwrDzOBwLarVWMc1epNoFBCYSvsVjqGgWjkCFjx39OsrHKcX7cTrWmE8OcUCOibkP9s+dHtS0dRj3c3O/nwa4g2rJo13cvnpXm1JpMfr56DEe9jVs5hrd5RaLC+j6TqAmtlv/94O7ECxO7paqvF8xjYedj9OxxnxyiANyTMwDMlp7vB8Dgvu5uR/WALdfzeuwIAuhelfrrp/vD5L7/3+0zj/6GvPzz99V/w+PE+z70ikf5eOU4v04HWvMJ4c4IMfE3CcHpZX9sadrlEonDm0Qup+b+2ENcIcF4cPS6qNd3PcbUA5TnTpIJSyVKv/UGvViYn7eiN2eYmLuA9e1qVYvsb39TtTQtYvwobzGaAAMnYL8xqvxQ0eLDnr8Yenu+3EfOuw5Rp2P7vU6MTEx75/4ioqJuQ98Heo6htHZ8/0HGXt6kNfaL6jxXk5YD/qcD8r+FHksihET8+ETX0kxMfdBKlVmbGwJ+Oi7bg+qD3/QJqMHffx7jSjFXcgxMR8+cUCOibkP9otIhAHLtg1arZv3rCG/n9f6oNrOH3Tm1+/63jy06zvuQo6J+fCJa8gxMe+DcIc4GDT5sGrIB3G/td/9jNZ83w+pVBlBSOB5zoHPEdeRY2I+fOKrKSbmffBhamffi3Cn2u1ukk6P7wmCh9VxQzcmx7HvMm6439rvaNf3qLJXHIBjYj464h1yTMz7INwhhm5IH0agcl2bTmedTmd9j161ICQYDHzJytHd6mG7YF2v02rdZDCoU6+v7NldhwG+Vls+dNcd7sqBSDbzvR4TExPzwYmXuzExDwkH2QGCb7Woqtm7urkPq+OGLkYHCY3sCpA4hzpwhYE+lAsNtbDv9ZiYmJgPThyQY2IeEkKd6GSyuEeP2jCapFLj993odZD29ejPDkpFh68VGk7AXkONUTGQeOQpJuajIb6aYmIeEgyjjST5Zg1hoHs/3cyua1OrLeN5NpnM1IFB07YNbt26RDKZjx7TaKxQKi2Sy81Ejla+V/Je1a4POhMdExNzMHENOSbmISFU5dq/o33QGrWu1/E8B0E4WLBE1+tsbr5Oq7XKcNgb+R1vz++MeiKHhA5TYaCOiYn58Ih3yDExDwmHaUc/SDAOA2YqNXZXILdtg1ptGVXNUqlcYDjsRjPG+xXHDtuZj6bQ43R1TMyHS3xFxcQ8hLxfJax7Bcx6fYWtrTdQ1QJHjnyKUul49LP3coQKiQVBYmI+OuKAHBPzEPIggW90N33Q48Kf5/Oz9HpV8vnZaCf9oLvc2JYwJuajIw7IMTEPIQ8S+A6yaBzFt4hcQVXzZLMVHMeK6sNxcI2JeXiIA3JMzMec0V1xGJxt22A47FIuLwa/5ZFMFkkktMjK8f3ukmNiYj4a4isxJuZjzuhONwzO7fYaW1tv0etVmZ9/LmrYEsUErmszGDTxPCfeJcfEPETEY08xMZ8gwgCbTo8jCAK23Wdt7WU0LR/thP2xKBtBkOLmrJiYh4g4IMfEfALJ5WZYXPwyoqhRr1/j1q0f7NHHzmSmDrRVjImJ+dkRB+SYmE8goX/z+PgpJMm3Uez1qpFpRFhvjs0iYmIeHuLlcUzMJ4z9bk3Hj38p+lnYjT3677iGHBPzcBAH5JiYTxi+a9QK4EU7ZSDqqD7IMSomJuZnTxyQY2I+Yfj2i4vRv0P2d1THO+OYmIeLOCDHxHzCGN0VjxLbJsbEPNzEV2VMzCeIMOhqWh7DaO+ZPfYtGR0g3h3HxDyMxAE5JuYThC+TeQ1VLSBJ/uWdyVRGZo8PtmSMiYn52RMH5JiYTxwCqprFsgZoWn7EknH8gb2VY2JifnrEV2ZMzCeIVKrMYOAbRwgCGEYbIPYwjon5GBBfnTExnxBc16ZeX4k0qlOp8XjEKSbmY0QckGNiPiGM1on3p6bjJq6YmIefOCDHxHxCGLVhDINxPOoUE/PxIdayjon5hBAKf4wG3tAfWdfrP8Mji4mJuR/igBwT8wkk1LNWlDSeB5qW/1kfUkxMzHsQB+SYmE8g4c642Vzd020dExPz8BIXlWJiPkGMKnUBexS7YmJiHm7igBwT8wki3BnDbmd1JqP9LA8pJibmPokDckzMJ4jRTuuYmJiPF3FAjon5BLHfYjEmJubjQ9zUFRMTExMT8xAQB+SYmJiYmJiHgDggx8TExMTEPATEATkmJiYmJuYhIA7IMTExMTExDwFxQI6JiYmJiXkIiANyTExMTEzMQ0AckGNiYmJiYh4C4oAcExMTExPzEBAH5JiYmJiYmIeAOCDHxMTExMQ8BMQBOSYmJiYm5iEgDsgxMTExMTEPAXFAjomJiYmJeQiIA3JMTExMTMxDQByQY2JiYmJiHgLigBwTExMTE/MQkLifX/I8D4BOp/ORHkxMTExMTMwnjTB2hrH0MO4rIHe7XQDm5uY+4GHFxMTExMT8fNLtdsnn84f+XPDeK2QDruuysbFBNptFEIQP9QBjYmJiYmI+yXieR7fbZXp6GlE8vFJ8XwE5JiYmJiYm5qMlbuqKiYmJiYl5CIgDckxMTExMzENAHJBjYmJiYmIeAuKAHBMTExMT8xAQB+SYmJiYmJiHgDggx8TExMTEPATEATkmJiYmJuYh4P8PH5BSoE4vDjMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## notice that his yields very similar results to using the underlying score function in the stochastic score based CFM example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Notice that there is no difference whether or not we convert the predicted noise to data inside thte .step() function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Let's try other cool sampling functions" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "schedule = DiscreteLinearInferenceSchedule(nsteps = 1000, direction = \"diffusion\").generate_schedule(device= DEVICE) \n", + "sample = ddpm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "for t in schedule:\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " eps_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = ddpm.step_ddim(eps_hat, full_t, sample)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# What happens when you sample from an untrained model with DDPM" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = Network(dim_in=dim, \n", + " dim_out=dim, \n", + " dim_hids=[hidden_size]*num_hiddens).to(DEVICE)\n", + "inf_size = 1024\n", + "sample = ddpm.sample_prior((inf_size, 2)).to(DEVICE)\n", + "trajectory2 = [sample]\n", + "for t in schedule:\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " vt = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = ddpm.step_noise(vt, full_t, sample)\n", + " trajectory2.append(sample) #\n", + "n = 2000\n", + "traj = torch.stack(trajectory2).cpu().detach().numpy()\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(0)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(1)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Now let's switch the parameterization of DDPM from noise to data\n", + "\n", + "Here instead of training the model to learn the noise we want to learn the raw data. Both options are valid and the choice of which depends on the underlying modeling task." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.distributions.time.uniform import UniformTimeDistribution\n", + "from bionemo.moco.interpolants.discrete_time.continuous.ddpm import DDPM\n", + "from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule, DiscreteLinearNoiseSchedule\n", + "from bionemo.moco.schedules.inference_time_schedules import DiscreteLinearInferenceSchedule\n", + "from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior\n", + "DEVICE = \"cuda:0\"\n", + "uniform_time = UniformTimeDistribution(discrete_time=True, nsteps = 1000)\n", + "simple_prior = GaussianPrior()\n", + "ddpm = DDPM(time_distribution=uniform_time, \n", + " prior_distribution=simple_prior,\n", + " prediction_type = \"data\",\n", + " noise_schedule = DiscreteLinearNoiseSchedule(nsteps = 1000),\n", + " device=DEVICE)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Let us first train the model with a weight such that it is theoretically equivalent to the simple noise matching loss. See Equation 9 from https://arxiv.org/pdf/2202.00512" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000: loss 0.504\n", + "2000: loss 1.002\n", + "3000: loss 0.446\n", + "4000: loss 1.014\n", + "5000: loss 0.375\n", + "6000: loss 1.849\n", + "7000: loss 0.489\n", + "8000: loss 1.577\n", + "9000: loss 0.314\n", + "10000: loss 0.468\n", + "11000: loss 0.332\n", + "12000: loss 1.729\n", + "13000: loss 0.374\n", + "14000: loss 0.779\n", + "15000: loss 0.536\n", + "16000: loss 6.597\n", + "17000: loss 1.269\n", + "18000: loss 0.501\n", + "19000: loss 0.546\n", + "20000: loss 0.490\n" + ] + } + ], + "source": [ + "# Place both the model and the interpolant on the same device\n", + "dim = 2\n", + "hidden_size = 128\n", + "num_hiddens = 3\n", + "batch_size = 256\n", + "model = Network(dim_in=dim, \n", + " dim_out=dim, \n", + " dim_hids=[hidden_size]*num_hiddens)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr = 1.e-3)\n", + "DEVICE = \"cuda\"\n", + "model = model.to(DEVICE)\n", + "ddpm = ddpm.to_device(DEVICE)\n", + "for k in range(20000):\n", + " optimizer.zero_grad()\n", + " shape = (batch_size, dim)\n", + " x0 = ddpm.sample_prior(shape).to(DEVICE)\n", + " x1 = sample_moons(batch_size).to(DEVICE)\n", + "\n", + " t = ddpm.sample_time(batch_size)\n", + " xt = ddpm.interpolate(x1, t, x0)\n", + "\n", + " x_hat = model(xt, t)\n", + " loss = ddpm.loss(x_hat, x1, t, weight_type=\"data_to_noise\").mean()\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " if (k + 1) % 1000 == 0:\n", + " print(f\"{k+1}: loss {loss.item():0.3f}\") " + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = ddpm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "for t in schedule:\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = ddpm.step(x_hat, full_t, sample)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Now let us train with no loss weighting to optimize a true data matching loss for comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000: loss 2.651\n", + "2000: loss 2.659\n", + "3000: loss 2.603\n", + "4000: loss 2.507\n", + "5000: loss 2.650\n", + "6000: loss 2.792\n", + "7000: loss 2.670\n", + "8000: loss 2.550\n", + "9000: loss 2.685\n", + "10000: loss 2.410\n", + "11000: loss 2.290\n", + "12000: loss 2.755\n", + "13000: loss 2.521\n", + "14000: loss 2.505\n", + "15000: loss 2.196\n", + "16000: loss 2.702\n", + "17000: loss 2.933\n", + "18000: loss 2.350\n", + "19000: loss 2.397\n", + "20000: loss 2.382\n" + ] + } + ], + "source": [ + "# Place both the model and the interpolant on the same device\n", + "dim = 2\n", + "hidden_size = 128\n", + "num_hiddens = 3\n", + "batch_size = 256\n", + "model = Network(dim_in=dim, \n", + " dim_out=dim, \n", + " dim_hids=[hidden_size]*num_hiddens)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr = 1.e-3)\n", + "DEVICE = \"cuda\"\n", + "model = model.to(DEVICE)\n", + "ddpm = ddpm.to_device(DEVICE)\n", + "for k in range(20000):\n", + " optimizer.zero_grad()\n", + " shape = (batch_size, dim)\n", + " x0 = ddpm.sample_prior(shape).to(DEVICE)\n", + " x1 = sample_moons(batch_size).to(DEVICE)\n", + "\n", + " t = ddpm.sample_time(batch_size)\n", + " xt = ddpm.interpolate(x1, t, x0)\n", + "\n", + " x_hat = model(xt, t)\n", + " loss = ddpm.loss(x_hat, x1, t, weight_type=\"ones\").mean()\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " if (k + 1) % 1000 == 0:\n", + " print(f\"{k+1}: loss {loss.item():0.3f}\") " + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = ddpm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "for t in schedule:\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = ddpm.step(x_hat, full_t, sample)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The choice in data vs noise and variance schedule are hyperparameters that must be tuned to each task\n", + "\n", + "### many of these choices are empirical and part of the tuning process to best model your data via noise, data, or even velocity prediction." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Now let's try a continuous time analog interpolant to DDPM called VDM\n", + "\n", + "### This interpolant was used in Chroma and is described in great detail here https://www.biorxiv.org/content/10.1101/2022.12.01.518682v1.full.pdf" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.interpolants import VDM\n", + "from bionemo.moco.schedules.noise.continuous_snr_transforms import CosineSNRTransform, LinearSNRTransform, LinearLogInterpolatedSNRTransform\n", + "from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule\n", + "from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior\n", + "DEVICE = \"cuda:0\"\n", + "uniform_time = UniformTimeDistribution(discrete_time=False)\n", + "simple_prior = GaussianPrior()\n", + "vdm = VDM(time_distribution=uniform_time, \n", + " prior_distribution=simple_prior,\n", + " prediction_type = \"data\",\n", + " noise_schedule = LinearLogInterpolatedSNRTransform(),\n", + " device=DEVICE)\n", + "schedule = LinearInferenceSchedule(nsteps = 1000, direction=\"diffusion\")" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "# Place both the model and the interpolant on the same device\n", + "dim = 2\n", + "hidden_size = 128\n", + "num_hiddens = 3\n", + "batch_size = 256\n", + "model = Network(dim_in=dim, \n", + " dim_out=dim, \n", + " dim_hids=[hidden_size]*num_hiddens)\n", + "DEVICE = \"cuda\"\n", + "model = model.to(DEVICE)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000: loss 1.251\n", + "2000: loss 1.152\n", + "3000: loss 1.156\n", + "4000: loss 0.908\n", + "5000: loss 1.174\n", + "6000: loss 1.355\n", + "7000: loss 1.008\n", + "8000: loss 1.567\n", + "9000: loss 1.092\n", + "10000: loss 1.290\n", + "11000: loss 1.149\n", + "12000: loss 1.350\n", + "13000: loss 1.480\n", + "14000: loss 1.061\n", + "15000: loss 1.223\n", + "16000: loss 1.180\n", + "17000: loss 1.127\n", + "18000: loss 1.351\n", + "19000: loss 1.059\n", + "20000: loss 1.074\n" + ] + } + ], + "source": [ + "optimizer = torch.optim.Adam(model.parameters(), lr = 1.e-3)\n", + "for k in range(20000):\n", + " optimizer.zero_grad()\n", + " shape = (batch_size, dim)\n", + " x0 = vdm.sample_prior(shape).to(DEVICE)\n", + " x1 = sample_moons(batch_size).to(DEVICE)\n", + "\n", + " t = vdm.sample_time(batch_size)\n", + " xt = vdm.interpolate(x1, t, x0)\n", + "\n", + " x_hat = model(xt, t)\n", + " loss = vdm.loss(x_hat, x1, t, weight_type=\"ones\").mean()\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " if (k + 1) % 1000 == 0:\n", + " print(f\"{k+1}: loss {loss.item():0.3f}\") " + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "# DEVICE=\"cuda:1\"\n", + "# model = model.to(DEVICE)\n", + "# vdm = vdm.to_device(DEVICE)\n", + "inf_size = 1024\n", + "sample = vdm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "for dt, t in zip(dts, ts):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = vdm.step(x_hat, full_t, sample, dt)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAHiCAYAAAA597/kAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvXd4Hfd9p/vOnDanF/RGgCRIghJVKKtapkXFilxiSY5LrGwSx7Fy7Wxsa+11stn4ul1HmyfZPDdR7JvdxBvHiTfeyLEdW5LjuClqtNU7RYIkSAIgOnB6mXKm3D/mzOAcFJIqJEFp3ufBA2DOnDm/Oe0z3y5YlmXh4eHh4eHhcU4Rz/UCPDw8PDw8PDxB9vDw8PDw2BB4guzh4eHh4bEB8ATZw8PDw8NjA+AJsoeHh4eHxwbAE2QPDw8PD48NgCfIHh4eHh4eGwBPkD08PDw8PDYA/tPZyTRNZmZmiMfjCIJwptfk4eHh4eHxmsGyLMrlMr29vYji+nbwaQnyzMwMAwMDr9riPDw8PDw8Xm+cOHGC/v7+dW8/LUGOx+PuwRKJxKuzMg8PDw8Pj9cBpVKJgYEBV0vX47QE2XFTJxIJT5A9PDw8PDxeBqcK+XpJXR4eHh4eHhsAT5A9PDw8PDw2AJ4ge3h4eHh4bABOK4bs4eHhsZEwDIN6vX6ul+HhAUAgEMDn873i43iC7OHhcd5gWRZzc3MUCoVzvRQPjxZSqRTd3d2vqFeHJ8geHh7nDY4Yd3Z2EolEvEZFHuccy7Ko1WosLCwA0NPT87KP5Qmyh4fHeYFhGK4Yt7W1nevleHi4hMNhABYWFujs7HzZ7msvqcvDw+O8wIkZRyKRc7wSD4/VOO/LV5Lb4Amyh4fHeYXnpvbYiLwa70tPkD08PDw2IENDQ9x5553nehlnjQceeABBEM54wt5Xv/pVbrzxxpd0n6uvvprvfOc7Z2hFy3iC7OHh4XEG+eAHP4ggCAiCQDAYZHh4mC9+8Yvoun7S+z3xxBN8+MMfPkurfH2gKAqf/exn+fznP+9uq9Vq/OEf/iFbt25FkiQ6Ojq47rrruPvuu919PvOZz/Bf/+t/xTTNM7o+T5A9PDw8zjBve9vbmJ2d5ciRI3zqU5/iC1/4An/2Z3+25r6apgHQ0dHxiuLlznE8lvn2t79NIpHg2muvdbf9zu/8Dv/yL//Cl7/8ZUZHR/nhD3/Ie9/7XrLZrLvP29/+dsrlMv/2b/92RtfnCbKHh4fHGSYUCtHd3c3g4CD/8T/+R2644QbuuecewLag3/Wud/Hf/tt/o7e3lx07dgCrXdaTk5PccsstxGIxEokEv/Irv8L8/Lx7+xe+8AUuvfRS/vZv/5bNmzcjSdKaa5mYmOCmm24inU4TjUa58MIL+cEPfgDYmey33XYbmzdvJhwOs2PHDv7yL/+y5f7Oev/4j/+Yrq4uUqmUa/H//u//PplMhv7+fr72ta+59xkfH0cQBO666y7e+MY3IkkSu3bt4sEHHzzp87Zv3z727NlDOBxmYGCA22+/nWq1uu7+Q0NDrjei+cfhrrvu4qabbmq5zz333MOnP/1p3vGOdzA0NMQb3vAGPv7xj/OhD33I3cfn8/GOd7yDu+6666TrfaV4guzh4eFxlgmHwy0W7H333cehQ4f4yU9+wve///1V+5umyS233EIul+PBBx/kJz/5CceOHeP9739/y35jY2N85zvf4V/+5V949tln13zsj370o6iqykMPPcQLL7zAn/7pnxKLxdzH6e/v51vf+hYHDhzgc5/7HJ/+9Kf553/+55Zj/Pu//zszMzM89NBD/Pmf/zmf//zneec730k6neaxxx7jd37nd/jIRz7C1NRUy/1+//d/n0996lM888wzXHPNNdx0000tlmgzR48e5W1vexvvec97eP755/nmN7/Jvn37+NjHPrbu8/rEE08wOzvL7OwsU1NTXH311ezZs8e9fd++fVx++eUt9+nu7uYHP/gB5XJ53eMCXHnllTz88MMn3ecVY50GxWLRAqxisXg6u3t4eHi86siybB04cMCSZfkVH+uFF16w/vVf/9V64YUXXoWVnZzf/M3ftG655RbLsizLNE3rJz/5iRUKhazf+73fc2/v6uqyVFVtud/g4KD1F3/xF5ZlWdaPf/xjy+fzWZOTk+7tL774ogVYjz/+uGVZlvX5z3/eCgQC1sLCwknXc9FFF1lf+MIXTnv9H/3oR633vOc9LeczODhoGYbhbtuxY4e1Z88e939d161oNGr90z/9k2VZlnX8+HELsP7kT/7E3ader1v9/f3Wn/7pn1qWZVn333+/BVj5fN6yLMu67bbbrA9/+MMta3n44YctURRP6z1w++23W4ODg+7zkc/nLcB66KGHWvZ78MEHrf7+fisQCFiXX3659YlPfMLat2/fquPdfffdliiKLefdzMnen6eroZ6F7OHh8briS1/6EjfffDO33XYbN998M1/60pfO+GN+//vfJxaLIUkSb3/723n/+9/PF77wBff2iy66iGAwuO79Dx48yMDAAAMDA+62Cy64gFQqxcGDB91tg4ODdHR0nHQtt99+O3fccQfXXnstn//853n++edbbv+rv/or3vCGN9DR0UEsFuMrX/kKk5OTLftceOGFiOKyfHR1dXHRRRe5//t8Ptra2tzuVQ7XXHON+7ff7+fyyy9vWX8zzz33HH//939PLBZzf9761rdimibHjx8/6Tl+5Stf4atf/Sr33HOP+3zIsgywypX/5je/mWPHjnHffffx3ve+lxdffJE9e/bwR3/0Ry37hcNhTNNEVdWTPvYrwRNkDw+P1w379+/nzjvvxLIsenp6sCyLO++8k/3795/Rx73++ut59tlnOXLkCLIs8w//8A9Eo1H39ua/Xwmnc5zf/u3f5tixY/zGb/wGL7zwApdffjlf/vKXATvG+nu/93vcdttt/PjHP+bZZ5/lt37rt1YliAUCgZb/BUFYc9sryUquVCp85CMf4dlnn3V/nnvuOY4cOcLWrVvXvd/999/Pxz/+cb7+9a9z8cUXu9vb2toQBIF8Pr/qPoFAgD179vAHf/AH/PjHP+aLX/wif/RHf9Ry3rlcjmg06nblOhN4guzhcQYwTZ1KZR7TPHlpi8fZZXJyElmWSafTiKJIOp1GluVVFuCrTTQaZXh4mE2bNuH3v/SOxTt37uTEiROcOHHC3XbgwAEKhQIXXHDBSz7ewMCAm138qU99iv/1v/4XAD/72c944xvfyO/+7u+ye/duhoeHOXr06Es+/no8+uij7t+6rvPUU0+xc+fONfe97LLLOHDgAMPDw6t+1vMmjI2N8d73vpdPf/rTvPvd7265LRgMcsEFF3DgwIFTrvOCCy5A13UURXG37d+/n927d5/Oab5sPEH28HgFrCe8tVqWWm2RWm3thBWPc8OmTZsIh8Pk83lM0ySfzxMOh9m0adO5XtpJueGGG7jooov4tV/7NZ5++mkef/xxPvCBD3DdddetSlI6FZ/4xCf40Y9+xPHjx3n66ae5//77XVHctm0bTz75JD/60Y84fPgwn/3sZ3niiSdetfP4q7/6K7773e8yOjrKRz/6UfL5fEs2czN/8Ad/wM9//nM+9rGPud6Fu+++e92kLlmWuemmm9i9ezcf/vCHmZubc38c3vrWt7Jv376W++3du5e/+Zu/4amnnmJ8fJwf/OAHfPrTn+b6668nkUi4+z388MMvuaHIS8UTZA+PV8B6whuJtBGJdBCJeEMQNhK7du3iE5/4BIIgMDs7iyAIfPKTn2TXrl3nemknRRAE7r77btLpNG9+85u54YYb2LJlC9/85jdf8rEMw+CjH/0oO3fu5G1vexvbt2/nf/yP/wHARz7yEd797nfz/ve/n6uuuopsNsvv/u7vvmrn8Sd/8if8yZ/8CZdccgn79u3jnnvuob29fc19L774Yh588EEOHz7Mnj172L17N5/73Ofo7e1dc//5+XlGR0e577776O3tpaenx/1xuO222/jBD35AsVh0t731rW/lH/7hH7jxxhvZuXMnH//4x3nrW9/aklk+PT3Nz3/+c37rt37rVXom1kawLMs61U6lUolkMkmxWGy5YvDweL1jmjq1WpZIpA1R9IannUkUReH48eMnrbE9Xfbv38/k5CSbNm3a8GL8WmB8fJzNmzfzzDPPcOmll57Ttbzvfe/jsssu4w//8A9P+z5/8Ad/QD6f5ytf+cq6+5zs/Xm6Gup9g3h4vAJE0U8s1tWyzRPpjc+uXbs8IX6d8md/9mfce++9L+k+nZ2d/Of//J/P0IqW8b4tPDxeZRw3NrBKrD08PM4tQ0NDfPzjH39J9/nUpz51hlbTiifIHh6vMk7c2Isfe3jYDA0NcRrR0dc9niB7eLzKrOXG9vDw8DgVXpa1h4eHh4fHBsATZA+Pl4muK8zP70fXlVPv7OHh4XEKPEH28HiZZLNj5HJHyGbHzvVSPDw8XgN4MWQPj5dJW9twy28PDw+PV4JnIXt4nCYr22T6/RJdXbsQRb/Xt9rDw+MV4wmyh8dpsl6bzEplnqWlg1Qq8y3bvQETHh4eLwVPkD08TpOT96cWVm3xBkx4nC6/8Ru/wR//8R+f9v5LS0t0dnYyNTV1BlflcbbxBNnjVeW1bBU69cUr22HGYl20t4+sqj1eKeCv5efG4+Xz3HPP8YMf/IDbb7/d3WZZFp/73Ofo6ekhHA5zww03cOTIEff29vZ2PvCBD/D5z3/+XCzZ4wzhCbLHy8IbO3hqVgq499x4rMWXv/xl3ve+9xGLxdxt//2//3e+9KUv8dd//dc89thjRKNR3vrWt7bM5/2t3/otvvGNb5DL5c7Fsj3OAJ4ge7wsHHGpVOYplaYplaYxTf11OXZwLaFd64Ll9fjceNiTjgRBWPWzd+9eDMPg29/+NjfddJO7v2VZ3HnnnXzmM5/hlltu4eKLL+brX/86MzMzfO9733P3u/DCC+nt7eW73/3uOTgrjzOBJ8geLwtHXAByObset1bLruvWfS3TLLSOEFcq8+4FiyPMr8fnxgMGBgaYnZ11f5555hna2tp485vfzPPPP0+xWOTyyy939z9+/Dhzc3PccMMN7rZkMslVV13FI4880nLsK6+8kocffvisnYvHmcX7ZvB4WTjistICfD3S3LvaEWJJShOJdDRGMXqTnzYa99wD998P118PN998Zh/L5/PR3d0N2DNz3/Wud3HNNdfwhS98gXvuuQefz0dnZ6e7/9zcHABdXa3vl66uLvc2h97eXp555pkzewIeZw1PkD1eMivn/SYSfafc5/VC86QnUfS7lvHr9WJlI3LPPXDLLeDzwZ13wt13n3lRdvjQhz5EuVzmJz/5CaIoIssyoVAIQVidpX86hMNharXaq7xKj3OF57L2eMmcTnLS+ZbAdM898MlP2r9Pl7XixCvd0p6beuNx//22GBuG/fuBB87O495xxx386Ec/4p577iEejwN2tnStVkPTNHc/x5qen2+ta5+fn3dvc8jlcnR0dJzhlXucLTxB9njJnE5y0vmUwORYTF/+sv37dEX5pVx0eCVPG4frr18WY8OAvXvP/GN+5zvf4Ytf/CL//M//zNatW93tl156KQAHDhxwt23evJnu7m7uu+8+d1upVOKxxx7jmmuuaTnu/v372b1795ldvMdZwxNkj5fMWlbfSsE5nyxD22KyGl/S1iktJsea/ulP21dddHjlYBufm2+23dS333523NX79+/nAx/4AH/wB3/AhRdeyNzcHHNzc651e9lll7Fv3z53f0EQ+MQnPsEdd9zBPffcwwsvvMAHPvABent7ede73uXuV6vVeOqpp7jxxhvP7Al4nDU8QfZ42TSLz/ksOLbFJODzmRiGcFKLqdma/uVf9vGv/xpqub25HKxZmCUpiWXZvz3OPTffDH/+52cndvzkk09Sq9W444476OnpcX/e/e53A/Dbv/3bfOMb32i5z3/5L/+Fj3/843z4wx/miiuuoFKp8MMf/hBJktx97r77bjZt2sSePXvO/El4nBU8QfZ42TSL8Pnkol5pxd58M/zjP85y660H+Md/nD3pl/RKa/r++3X3IsQ0dUxTR5LSAC3CXKtlEQRQlOIZPz+PjcUHP/hBLMta9fNAwxXzwQ9+kOnp6ZaSJkEQ+OIXv8jc3ByKovDTn/6U7du3txz3L//yL/nc5z53Nk/F4wzjCbLHy6ZZhDeSi/pU8dqV1rxp6uzdO80f/uEov/RL2pr3cVhpTV9//XIGda2WRVHy7nPh1Gk7ZU/nywWLx9klHA7z9a9/naWlpdO+z9LSEu9+97v51V/91TO4Mo+zzbn/9vQ4b2muv12Pc1H+5AgurF3721yaBHbtcKEwDnDKNd58M3zjGwv8+Mclbrwxwfvfv1w/urLkyanTdsqeNsLFisfGZO9LzCxrb2/nv/yX/3JmFuNxzvC+ITxedZpF+FTieCZYKbjrXRQ423Xd7g+cSg2d1gXGdddNcskl4/T1XdFy21oXKKdz0eLh4eEBnsva4wywMrYsSWk3vno2WOk+t+cVj7rzip31ZbNj1GqLVKuLqGqZcDh9Siu2VstSrS5QKp3wSpg8PDxeVTxB9njFrIzZNmcUi6IfUfSjKPlznIFtuX8560unhxpxXpNSaYpqdfGkR3AuKizLHgAgy/kzvGYPD4/XE54ge7ximi1i09TJZsewLN3NKD7XGdj2vOKdrutYUYoIAmhatRHnNdG0sntBcbJaYkXJE4lkCIfThELxl9Tsw2sO4uHhcTK8GLLHK8aZcmSaOqXSNOXyDILgo719BNh4cdSVMWZR9BMMxlfNLV6ZkOXs7/eHqVRmUdUyui5TrS7S0THi3ne9BK5zEU/38PA4f/AE2eMV47ila7VFDEOnXq8SCiXccYxnO8N4ZRLXSiF01lSrZd1GHfF4D9GoXabUmgy2+n7F4glM0yAcTlOvy1iWQaUyjyznsSzD3X8lKy8EPDw8PJrxBNnjVcERGUlKEg6nkeV8Q9CWXAvyXJU9rSWEzj7l8iyl0hSSlEIU/VQq80QibatKlhyaS6T8folUatB11VuWjiCsP9lpo3kKPDYGe/fu5dJLL+XOO+8810vxOMd4MWSPVwVHbPx+Cb9fwuezrWZB8GFZ+llJ6HJitJKUbMnsXqtpiRPX9vuDFArjJBK9rpXvCOx6pVKwXCLlHNv+6TmrFx4e5w8f/OAHEQRh1c/Y2Ni5XprHBsL75vB41Wm2SGOxLlfYzjTNlrEjrutZpc722dnnqNUWUJQKfX22wEpSksXFUSzLFl/HWq7VshiGiqIUMAyVSmX+pN3JXq8zoT3W5m1vextf+9rXWrZ5oxM9mvEsZI9XnWaL9GQtNV/trOPmbO7Tyew2TZ1AIITPFyWV6ne312pZLMtocT87Yp/LjVMuzzI/v59cbsy1/J1a51Jp+jUxcMPj1ScUCtHd3d3y4/P5Vu2Xz+f5wAc+QDqdJhKJ8Pa3v50jR44AdrldR0cH3/72t939L730Unp6etz/9+3bRygUolarnfmT8nhV8QTZ45zxagvW6V4IND9+sTiFrldRlNKK2HO3mznd7AYPBiNEo510dl5IJjO8QvDt2uTzceCGx8bhgx/8IE8++ST33HMPjzzyCJZl8Y53vIN6vY4gCLz5zW92B1Pk83kOHjyILMuMjo4C8OCDD3LFFVcQiUTO4Vl4vBw8QfY4Z5xLwXLiy8FggkAg2rIeJybsJHktLOxncdH+slPVErpeIx7vIZHoA5YFOxxup61t2I1fA6e8KPB4/fD973+fWCzm/rzvfe9btc+RI0e45557+Nu//Vv27NnDJZdcwje+8Q2mp6f53ve+B9hJYI4gP/TQQ+zevbtl2wMPPMB11113ls7K49XEE2SPM8rJ3NLnckKUYw2Lop9Eoo9otGPVekxTp1pdRJbzyHIOAEHwt3Tpco6Tz49jWTr5/Hhj+yKLi6NeExAPl+uvv55nn33W/fnSl760ap+DBw/i9/u56qqr3G1tbW3s2LGDgwcPAnDddddx4MABFhcXefDBB9m7d68ryPV6nZ///OcveViFx8bAE2SPM8rZjKO+lJh0JNKGYeiUSpMEg3H8fmnVPs4M40xmmPb2HcRiXaTTgwDouoJp6q5V3dY2jGVBtbqAaeoN4TbcjG2vQ9fG4ly8JtFolOHhYfenOe77UrjooovIZDI8+OCDLYL84IMP8sQTT1Cv13njG9/4Kq/e42zg+dI8zihnsxnGS+mE5VjBmlZZd8rTynGKAKpaRtOqbvKWk5WtKEXC4TSqWkQU/XR0jJzTiVceJ2ejviY7d+5E13Uee+wxV1Sz2SyHDh3iggsuAEAQBPbs2cPdd9/Niy++yJve9CYikQiqqvI3f/M3XH755USj0XN5Gh4vE89C9jhjNJf9AGfcInGsVUlKntZjhUJxRNFHOj3Usj7HeoLVMeBQKE4wGHXjx81To0TRT3v7SEt9stNYxEvu2lhs1Ndk27Zt3HLLLfxf/9f/xb59+3juuef49V//dfr6+rjlllvc/fbu3cs//dM/cemllxKLxRBFkTe/+c184xvf8OLH5zGeIHu8KqzlAnSskEplnsXFUSqV2Vfkuj6Vm9ERQUUpUqnMnTKGK8t5VLXcyIxedq2fzM2uqmUEQcTvlxpdwGx39cpksLXW5SV3bRw28mvyta99jTe84Q28853v5JprrsGyLH7wgx8QCATcfa677joMw2iJFe/du3fVNo/zi433bvQ4r3CsYF1XKBTGyWSGXevRsT50XaFanSccbjsti2S9hhqn62aMRNqoVhfdDmHr7WuaOppWcWPBzWte+bdzHrVajlispyUJzF7P6hi0h4fD3//93697m5Md7ZBOp/n6179+0uNdeumlWJbVsu0Tn/gEn/jEJ17mCj02Ap4ge7wiHJE0DJ3mmcMrEUWfK2KnolKZJ5cbaxF3OP149MoY7umwsqNX89+OZT4//xzz8y/S1XVxy7o8PDw8Xg08l7XHK0KSklgWtLUNt8wchtbSopW3nTrLdX1xPx1O5ZLUdYVicYpotGPNDOtmarUsudwRlpaOUiiMEwxGN6Sr08PD4/zGE2SPV4SiFBEE0LSqK4ArhzwA67qfV8ZpHYHOZLatcjXb7SkPukL+SpLE5uf3UyxOEo/309ExctJjRSJtZDLbSCYHCAROr/uRV+rk4eHxUvEE2eMVsTJb1TR1N4FLUYoA5HJH3KzlZrFeK8u1VsuiKHm3/aWD06TDNA13v2ZBPx0BbN5H1xVkOUsy2Y+mVVddHDTv6zQPicc7EQQBURQxTZ1SaZpSaXrNx1zrgsM5pq4rnlh7eHiswvO7ebwiVsZeVw5msIVYaLl9rcQsJ5FLkpLA6jix06QjHG5zS5MkKb1q+MPK4648hrNPMyebl9x6PJFgMA6IrhvbOTenvMk0dbLZMbeUyinBaq5HrlYXERpPyUaqgfXw8Di3eILscVo0Zz47otPWNrwq/rqymUZzLe7K25s5laA2Z2zPzj5FKJSks3OXa0WfTsKXs3bbMjXd7WuNaFzreOFwmlAoTjicRpKShEIpwuF0Y/322qvVxYZQQ1fXLiqVefc251hOI5GNVgN7vrAyu9jDYyPwarwvPZe1x2nR7ILNZsfI5Y6Qza4ert4swivLl042H7jZ9b3SHbyywYiu1zEM3bWm1zvuSje24wZXlDy1WnHN8zxZUxBZzqMoRbLZo9RqWXy+Zbe6JDkiHSeV2kxb23Bju530JknJV1z7+nqPSzt1uN5YQY+NiPO+bK4Xf6l4FrLHadFsMTpC6IjOWjixZMvS3fvZ/xvouoKqllssbEesTFN3Zw2Hw2lE0Y+mVRgff4ihoTcjin50vYZlJVhcHCUatQe812pLVKuLtLUNu9bnWla3I/gwhmWZ667ZiR23Xkzk0bQKilIAbBF+7rlHmJubY/PmXYyM+NG0MvF4D36/5HoSDEMhmx2jo2MEUfRTq2WpVGapVhfdbafDRm33eLbw+XykUikWFhYAiEQiCIJwint5eJxZLMuiVquxsLBAKpVac8b16eIJssdp0ezWFUU/XV27Vu3TbKmujCXXalkMQ0FVKxhGnUJhnFpticHBN7VYz6apI8t2IpTTSGR+fj/l8hT5/DgdHSMkk5swDINcbgxZztLePtL4UNjWo8/X6sZujuM6j7W0dBi/X0LTaq74Nq8ZaBG/UmmaYnGSdHor7e3bicW6+NKX/oSvf/1/oigqqhrn9ttv57bb/kNLXNuyDFS1QjgccJuULDcuMU7auGQlZ7Mv+Ealu7sbwBVlD4+NQiqVct+fLxdPkD1Om5O5c4GG5TfnWqqwHEt2RCgUErAsC0my47GOIDnWnySlaW8faXmMgQF7FF0qNYBp6mQyw66gGYZtzTqDHcLhNH6/hN8fYmJiH319l6MoxRZxLZenqVbnSKc3Ew4nmJ/fTzhszzC2LItMZghFKbYkjZXLs1Srs/T1XUlX1y6efnof/9//97cEAj4ikQFkucBf/uWXectbfpFdu5atcYBMZiv5/LjrWTidxiVrueHXinW/3hAEgZ6eHjo7O6nX6+d6OR4egO2mfiWWsYMnyB6nTaUyz9TU40hSYpU4OLFeXVfI58fRdYWenkvd+0UibbS1DXPixKOEQjE6OkZa7rfSmpXlvCtGfr9EJNLG3NzzhMNpotEufD4/gUAYyzIoFI6TyWyjvX3Evc/Ro/cxNfUzTNNg82a72f7ykIssDz44xPT029izR+H662cpFI4DFuFwmzvbWBCWz9Fus1nFMGyrdnz8IKZZIxzuRxBE0uk0s7OzTE5OsmuX7T1wnqNKZR5BsGu2nRabzc9fc4b5ydztHsv4fL5X5QvQw2Mj4Qmyx2nh1AH7/ZKbpNSMUz8sy0Wy2UMAJJO2Reu0wRRFP+FwGkHwuULlZCQnEn1unHlxcRRVLVCrZV3hbnZjO3Hi9vYRt853ZVOSZLKfUmmAdHpo1cXDvn2D/Mmf3ITPZ/K//7fIX/+1yfveF3OTvoLBKMeO/TuJRF+LS3l+/gSzsw9ywQURhoZ2IghRCoUcXV1xFhZKpNNB+vt73efL8SacytW8VjmUJCWpVhdXPc8eHh6vXTxB9jgt7HiobSVKkq/F1WxnSNtiEwhE0LQSqdSQW4fsiHlb2zCC4KOtbbjJ3d1ao2wYKqFQtGFt15iaepyenksIh9vIZIZdIa9WF9G0ijt1CZbHJypKHklKs3XrjQBujNhh374YomhgGD58PpMnn+zkXe/KuglW8/P7sSyLel12z+ub3/wWjz76fRYWYG7u29x++3/mP/2nT/Jnf/Ychw9fQSr1KB/6kJ9Nm9LuueRyY4B1SlfzWuVQTt11rZZtSS7z8PB47eKVPb3GeDVKY1Yew3ErC4KfUChKuTzt7rOwsJ/5+f2AbaXG4720t4/Q1jbM4uIokpQkGu1CEATXFZzNjmGaOrFYlzs/ePkxfPh8QWKxDkQx1Eh8yiEIArKcZ3FxlOnpJ5ic3MfExIPkcmMtIxPtOPBy7NoucWptz/mmN1UwTV9DlEUuv3yBcnmG+fn9mKZOMtmPIAh0de2iVsvy7LNPcu+9/0g4bJJKpQgETO68804E4Rampr5KofBhjh37e/z+9yPLecBptzlMJrPttIZhxGJd7sVF8wxlgEpl9pSjJD08PM5/vEvu1xivRuxx5THs/5cagiASDnewuDhKMBgllztOKmW6FrPT23p29lkUxRYnJ4EpGIwyPf1kSzLXsWOzHD/+U3p6uhka6iIa7XBLmRx3t2UZVKtFLMtAFH0kEv0Eg3GSyX4Mo04wGEVRigSDcWQ578ZrHSEMBqPMz++nrW0YXVfYvPmf+MQnvs3Y2Jt4xzvaeOc7LQqFEoArfIIgNJK9UoyO/hRJqhKJ+KhWLSKRNorFWX7ykxo+n4VhiPh8FgcPXkI4LLe023y5NJeByXL+JWdke3h4nH94gvwa4VStJ18Ka3XVKpdnKRTGCYUS6LrC0tJBAOLxXgRBRJKS6LpCuTxLOJwmkehndvbZlhhupTLvxpAjkTa+9KUv8dd//f8iCBUkKcR/+A+/zn/6T18EcNtPqmqZanUeQRAIhZKoaoVotINAQGpkbceZnn6SQCBMqTRNLNaNYWhuprZzrKWlQ2Szh5HlHMePP8hFFwX5zd/cwtDQDhQlTyYzjGnqlMszhEIJt7lHPj9Od/cmQKJY1JBlP7K8RDod5NprC9x7r4AomhiGyO7dUywsLCDLeTo6RtyLgrVczWslcq21nyj6aWsbJpsd8+LJHh6vcTxBfo3waljGzaU2zcdwkrHsLOQMqdQgpdIE0WgnsVg30Wg7ilKkWl2kUDjuZkZHo+1oWpVgMAYsJyql00M8/fQ+vvSlPycYNOno6EBR8nz72//ApZdup7+/j9HRR6jVQuzc+VYGBzeztDRGubxAtTqDaRrEYp0EAmGWlo5gmnU0rUo4nKBSmSOT2UKtlm1YlnZJlM8XwDR1CoVJZLlELNZGOr2FRKLPzeIulaZZWHge0+whmRxwz3vLlkH27n0TP/vZPsrlPMlkhPe97zf50Id6icUe5Sc/qXDZZTPs2jVPNhvA7w+QzY6dtF/1S+lr7XgdmrO0Afbv38/k5CSbNm1yM7s9PDzOXzxBfo3QnBhUKk0Da9cKn4yTiboo+olGO4lGO5DlPJ2dFxGNdrruaE2rUK9XSSQGWpK2nM5Yzj653GE0rcLY2GOEQmXa2jqp1wOIYgeKMs3k5As8+eSPuf/+n7C4aCHLX+G2297PG9/YiyiGME0FQYBotINyeZZSaQpVLTVi0b1u3bFTpywIPkTRz/DwjY1yrDo+XwBBEKjVim681mlKEgwmEAQRw1A5ceJRwuEUudw4F13UzeDgLyOKW+noaGfnzt1ks2NccsmztLc/Rm/vlXR2Xkg4nCEe73Hd9+t5KpovTjStesoe3M2/Ab70pS9x5513Issy4XCYT3ziE9x+++2n/Vp7eHhsPLykrtcYlco809OPs7Q0+pJGE8LqUYrOfZ2e0qnUkBvPjMd76era5ba+nJh4iPn5FxpNOSRX6CqVeebn91OpzJLPjzeadORIpYL4fBLlchEwmJurUColCQT6+da3HmZ6Okwi0YkkaXz96//I/HyOZLKf7dt/iWi0k2AwSjZ7FNOsk8kM096+nYGBq/H7JWQ5j2GoyHKhcTGwhKIUiUY7EEURENF1lWDQXrtzIaKqZcJhuxmIIPgIBCLIcoFotI1CYZpo1GTz5ihbt25DVSuNdp12x6hotJPu7ksIBCRUtXzKvtXNVu+pWHms/fv3c+edd2JZFj09PViWxZ133sn+/ftPeazT4fXeM9vD41zhCfJrBEdUZDlPKJRw206CLdJLSwfdutj1WPnF7/R2XloapVAYR5bzVCozLCyMommVli/saLSbUCjljh107ruwcKCRmAUDA1fR3b2baLSN7dsv5jd/89cIhSxqtVkkyeL22z9BMBggEKjS3h4nHNbp6wvg88lUKgZ+v0SpNOMmjcnyEoahEo22Iwh2rNgeSjHJzMyzbnmULOcb7urjTE8/hiiCrqsUi7OAba0ahk4oFG/Eqe2OX4FAhHA4RaEwgWnqJBIDbN16I+FwG+n0EKFQkkBAIhxO0dY2RCzWhSD43QSs9WgeH2m38RxteW1OJYiTk5PIskw6nUYU7aYksiwzOTl56jfKabDWLGcPD48zj+eyfo2wVi1rq3W2fhP+9aYlOb2YQyE7mcgwVIrFGYrFExQKx/D7JXp6LiUSaSMQCBOLdaIoRddlXK/XKBQmSCT6iEY7CAZjxOM9VCqzBAJRPv7xz3HllVeytFRm69bdbNnSw8MPf4NUys/8fAlNS2OaS5imREdHH7JcRpbn6Om5jL6+yzFNg0oljaqWG+VS/kZi2Rz1eqXRzamLcDgFwIkTj7C4eAC/P0JX1wihUMJ176tqEVUtEAql3OcgFIo3ximOU6lMI4phLMtCEARE0Y8s5yiVpgiF4vj9EQACgTD5/DiZzNZVrUad59SplXbKmqB1bNup8gE2bdpEJCIhy0tEIm3k8wXC4TCbNm061dvktPB6Znt4nBs8QX4NsFJQmxN/ALePtGOZrdWDei0BaJ5BPD39BKZp0Nm5k0AgjGma6LriClooFENVy0Qi7Y2hD/lGR694Q6yXa40jkQ63nGrHjhF27+5wk6ouvvhNvOUtH+Jv/uZbKMoCyaSfX/u164nFZGZmHsGyTCKRTnp6LqWjYwRJSrqegXDYvnAYHHwTudw4qVQ/mlZzy6GKxWkWFkaRpBThcDumqbCw8CLRaCfxeA+Fwgk3plsuz7K0dJhKZY5KZRbTtDAMGcNQUdUywWCMfH4cWS7S03OpW7M8O/sMpdIUkpTE75col2fRtAr9/Vc2BlgsNnpkdxAMRllcHCUQiLWI36kEcdeuXXzsY7/FN7/5P1lcnEIQ4nzyk5981RK7vJ7ZHh7nBk+QXwPUallKpRMsLh5046jNKEoRWc66GdAr62PXEwDni9mJIddqtsim04MsLdklRIahkskM4/NJhMOBRmayfZxUaoh6XXaTvCqVeWq1RbdHtJPw5ViSdj9pgQ9/+JNcc80bmZk5QXd3HxdeaCdQZTJbqVaXSKX63SzmaLSDYnESVa2Syx1m06ZrKRYnSST6GqMUTTdeGwwmEMUQgmCRSAwQjXZgWSAIkMsdZ2FhP6apEov1Ui7PMT39GJZlIEkJMpnNBAIRqtUlwuEU+fw4fr9EKBQmkRgAaLi1+93nz04qEwkGI+6oRed5djqCzc09i2UtD5xwvBvOBUylMr+m1+O2227jkksGKJV8DA9fdtpivHK29Mq/T1WG5eHhcebwPnGvAewe0Aep1bIsLo4Sj/e0fKFGIm2uSK7FySwi09QxDBVd1ygWj7OwcIB8vhtJyiAIPpLJAbf22CkfcmKfiUSfO9YwEvEjSUkWFw8SCsUplaaR5XxjNnKpUU612V3z1q1bGB7e7razTCT6yGbH2Lx5L8XiFOm0PZGpWDzREOMxDKPGxMSj+Hw+SqVZ0ulBRDFAKBRD0ypudrXd3CRNONxGMBhB02oEAhLl8gzl8qLbqUsUQ+Ryo0AQSWojlxsjGEzQ3r69IfAR6nWNSmXezciOx3sIBmMkk/089dS/k8tZZDICmzcbLTORwZ4nbV+kLCHL2VWlUicrjYrFurjyyne8ZOFs9obY/7f+fTplWB4eHmcGT5DPY5qtnYGBq8lmxxpdsFrdz8784pON+1vrmICb1JXLHSWfP4YgCESjXRiGjCQlKZdnGR29h66uS9i69S0Nt+1ThEJJN4PYGcloi2Aaw6gzNfUE1eoclcoCoVCc7u5LSCYHXMvQmRqVTg8RDMao1bJUq/OUStP4fH5CoTiqWqZQmKBQOIYogmUFSKV6yecnAAFdl8lk+hEECASi+HwSqlojEAihaVVUtUguN4YoisTjfcTjvRQKEywtvUh//xvJZDYzP/8sxeJhMpktBAJRNK1CJJKhXq+iaVUUpUAud5yenksRBD+aVuHIkR+wb9+zfPe7PyUUUpifT/KRj/wat976PhYXR11R9vslNm++rmUIRXOp1MlKo16uW3ktb4hzEXW6ZVgeHh5nBk+QzzOaBXNl7Lera9cqQXU4lRXs3MeZwJRKbUZVy8jyEtXqEm1tOxrH6CWR6ELTqtTrVSqVJbfe14kDm6ZJIBBFUQrk8+MEg9HG0Ig4kUg78/MvNjKg5/H7w42s8ExLjLtYPMHCwguA3XrTnke8RKWyhGHI6LpKLNZFOj2EZUEgEEQUQ0hSglisC8sSiMd7XDcwWIyP/xjLUrAsnXpdplSaJRptI5s9RiTSyc6d72J+/nkWFw/T3r6VaLSL6emnKJVO0NZ2Ien0IJKUIR7vZmrq8YblXaJeryEIPjo6Rti//zvs3/+vPPPMY2zeLCCKEsFgja997R+56KIhNm/e0uhk1tfy2qwV/3dc7ZpWXTXqcq0kvNNh5fugOdlsrcfy8PA4e3iCfJ7RLMLN1s56XbaAVdm+zphCJ2a4uDiKLGdpbx9xY8WBQAxBEJiefhpFKRAMlojFOgmHk0SjHfj9YTKZYTo7L0TTSnR1XUChMEE2O9YQ4yITE/uoVufp7r6UYNDOQhZFP5alNzKtJTo7LyCR6CccTjemI9lrTCR6qVaXSCR6OHHiEXRdw7IsVDVPsTiJIAgsLh5ElsukUn2Ew4MEgxFmZp6gv/8a4vEeyuVZ5uaeIxbr5sCB7zA3dwgwSSSGqFZnKZUmCYVSqGoeSYqTTA5Qr2uAhaJU6Om5jPb27WSzB2lr20JHx05qtSUOH/4hpdIEhcIUguBHUZbdvvF4B5omoWkWoVAY8BMMSsTjBaamDtDb246uK25vbbsue+2M6pXWrPOaOVnaa93n5eJlVnt4nHs8QT5PWKtXdfMAAjuByY7drvySbh4FCDQJ8iKLiwcxDI16veLeFomkiUY7UNUybW3bmZ5+HFF0SoqmkeUsslzA7w8RDMbw+fxMTz+BZZnIcgFJShGJdKAodhlRMJggEAjxwgtPUCz6iUTK1GqL+HwS6bSCqhap1RbQtCqJRD+Li6NUqwtEImlKpVlM00DXq0CAYnG8ETM+Ti43ysLCcQwjSH//lWzZshtdV5HlXOOC4GFkOcemTW8imx1Dlpfw+QKkUv1s2fIWZmaepFSapVZbYtOmCOXyNFNTj2JZJvH4PLOzz2IYBoGARK1WIBrtQNNkIhGRxcVDaFqx0SDlCsCu965UFuns3EKx+DjBoEW9HiMUWiKTEejp2UIi0c/U1BOoahHT1F2vxloZ8CutWedizMnSfjXE82QXch4eHmcXT5DPE05Wm+rUC1sWa36xO6MAAbcRxXJtsUY4nGlkMNszi9vbd7ZkQAuCSDY7SqWySLU6DfipVuepVGa56KJfIZPZhqoWUFWNatWe31suzyBJMeLxTfh8fr71rX/g/vv/lUrFQBQl3v72S7jmmjfR3X0R2ewhdL2O3x9ElvNUq4soSol0ehCfL+BehCwuHkDTZARBIJUa5Omnn2Jy0o4fHzo0xsTEFG9966+iqmVM02gMvbDrlFW1hGmq+HwiqlpuWPkJKpVnGvHcMLVaEVlewOcLo2kV5uaeY3HxeUqlGebm7ClVsrxEIGDXI5fLs/T2Xk06PYAg2OVhlgU7d+7hbW8L8P3v34VhLNHRYXLhhRciSSUsy0DTSqhqiUplgY4O3S2HahbgtdzSzVbsyQZWvBRXdq2WdWP8zQlnHh4eZx/v03eesJ572ok/Ai2uzOa4ZHOpU6EwQT5/jGAwQSazFb8/SDzegyznyeWOUqnME4t1Nep7s8hyjkgkQyz2ZlS1yNTUE/j9Eaana+i6yvT0U4hiEE0rNGp1debnn6e9/UIikS7S6UGeffbHPPbY3QwMqChKlJkZgwceeIY3vOEm6nWZnp43uGs2Tb0x4MHE75eIx3tQlAITEw9jWT5UtYCuaxw79ixPPPE8qZSfYNBHuSxw3332MXt6IqRSm0il+pmdfZFYrANZLgMWlmWiqiUOH/4hmlYiHO5onG+cQCBKLNZDKJQik9kKQLl8l/u8JRLHCQajFAoThMNpNK2KZZmkUoONhLEyPp+fYDDFu971Ni64oJdKRSSdlggGKxiGjCwX6eu7kkplAUVZ4vDhHzA8fOOq13Ytt/R6eQDOfXRdoVAYJ5MZXnP043oib/f91r3xjh4e5xhPkDcAp2PZNH8ZO/W8gJvc5YhyszsacF3azj6WZaAodmMLJyN7evoZ2to2I0kparUlSqUT1GpZAgGJ2dln6ewcoaPjQhSl2Cg/OkIi0YeiZJmdfR5FWcQ0DRKJLQiCia7LKEqOUCjRaKBRw+fTsCwf4Gs06sgxO3uE3l57UtTAwFVudu/AwLXMzDxLMBhBkpIcPXof4+MPI8sFlpZG0TQZw5ghlaqRSolomg9RjBAOVzl69H7S6V+kWPRRqy2Szx9laekgs7PPYLvsBQKBOO3t2ygUpvD5JBSlzMTEPjo6dtHZeQmKUsDn83Hs2H3IchFBEBCEAJpWwjBqhMO2K90wVOr1IrJcIBxOUatVSKUG0bQKo6PfAyxGRi6nq+siBEFgdPQe0unBRty9wv79/4xlCeTz43R17Wp5bU/mll6ZE+B4TwxDZ2XXr2bW8rI49c+nk4Hv4eFxZvEE+RzyUpN0mnsc21/YqzOtnUxp53Zo/SJWlBKSlECS2igWp5iaepRyeYG5uW6Gh99KMtnP3NwL6LrM9PQTVKv2sWS5hKKUmJ19gkAggmGYiGKYanWGfP44fn8Qny9IW9s2gsEYS0uHMU0ZXVcIh+sYho9KRUDTQpTLVYLBEN3dw8zNvYhhPImuq6TTmzBNnXx+grm5Z5iefpyRkV8inx/HMDSCwTCBQBTLChIIBBpCaWKXONWIRkXi8SiaJgNZyuUZKpUFFhaeR5bnAQtdFykUFvH5QmQyWzly5N9YXHyRZHKQTGYL5fIMhcJxstkjTE7uI58/RDTaiyQJWBZEIh1Eo12IYpDZ2SeQ5TK53FEKhePoeo2+vis5ceJRSqVJAoE02ewYPl8QSUqRTPZjGPXGOY7T2XkB9bpCW9tyOKH5tV05eKL5/ZLLHQHsFp5OeVRb27B7UXMql3czXmcuD4+NgSfI55CVSTqSlKRSmV/XUraTs+wv4vb2Edct3ZwUVKtl3T7Ja30RS1ISUfQTDEZYWjpEOr0ZCCKKUCpN4fdLSFKCWm0Jw6ijKCVOnNhHIrGJanUeTatSqcwRjbYTDMbx+QQ2b/4FdF0mFGojGu1EEERMU6NUqpHNHiIYVLniit387GcvADni8TC/8Au/RDodIputoihZcrmjxGKdBIP2dKaFhRfQNFvQQ6FEo092nkAgSr2exe83GR7extTUUWo1BcuS2LXrEjZt2klf32VUKksEg2E0rYQs1wCNUgmq1QIvvPAzCoUYv/iLv8zc3NOYpolpaiwuHkEQRCKRTMP9bjZahGr4/RHKZfv5CYfb0bRyo++1iKIU6ezcSbW6SD4/jqaV8Ptj9PdfiWnWG93FBojFdtPWNsz8/H6q1QWi0U56ey93Xyd7CMghwuFM4/VebIntNr9fMplt7mu6VsnSel4UT3g9PDYuniCfJU4nSaf5S3StulNJSrpfxCvFu1KZRZbzpNNDVKuLbiLUSvx+ia6uXZRK02haFV3X6eu7DJ8vSDLZ3xiRWEAQfMRinQ0L8wVyueNs2fLWhuu2hqYpVKtZqtUF/P4I3d27WVw8SL1eJBbrpVJZaCRICahqjaGhbvr6hlAUi1DIJBo1yeUONy4QfCwtHUaSEkQiGWq1RTKZ7RSL4wCEw2na26/lxImfUy7PI4p+fL4g6XSMSESgViuTSHTQ3p6iWl1iYeEQgiDg94cJh7uo1SpUq+Dzga77qddFHnnkfhKJArJ8gmAwid8fxjBUursvRhACVCpzBIPRRivQDLquAgqqmmNh4YVGHD6GJKWQpBjRaDtgkEwOks0eobv7MhKJHrLZMfz+MIpSxO/XGg1OFiiXp2hv37HqwsupmY5GO1omR8ViXY3e1wdJpYbw+6VGVvf8us0+nN8rvSivpI7Zw8PjzOF9Gs8S68XvVvYshtUuxeb7Nidnzc4+TU/PZSQSfY0JTGPoukIgIKEoRYJBnenpJ0kmB9C0CuXyLNFoh+vaDgQilMtzWJbFwMBVTE8/iaoWiUTayWQ2U6ksoOsKc3NPUqvlOHHiAXw+P7ncGLFYD/39V7KwoJNObyGfn6BUmsQ0TZaWDlEoTGIYCuXyfMMlnyUa7WZw8I1ueVC5fIJEYhBNyxMIxFlYOISm5TAMjVAozfbt70TTZNrbtzIwcA2iaAEGlmWhKHkKhXECAUink0hSiGi0F8uCWm2BUmmaQEDC55OwrLz7XEqSTiYTIpfTMIw0ojiDZWmUSlNUq0uN0qteTpx4jHz+BIaho6oFwETXq0hSAsNYoFSaIB7vxTDqzM/vJxrtIRJJNWqnext9s/2Ni4IM4KNWW2oMtsigqiVgdTlbb+9l7vvCiQ8774d8fpxaLcv09JO0tW1zS9kcT0mzyDa7oR2XtvMYp5om5eHhcW7wBPkscbLGC3bpyey6pSdrNYhYXDxEPn+cRGKARKKPWi1LoTBOItFPMBhvdLraz9TU42zf/g4ikXbGxx8mkehjcPBaqtVF5uf3U69XiMW6yefHCQQkRNHvJlgZhkIms5XOzkuYm3uGcDjTmF6kEAwmCIXa6Oq6DNPUG3OB21HVEqXSNIahIQgi9bqCaSpYlgX40TQNQQgQCkUAX2N4QwbTNPH5QBQD+HwR6nWFQmGScDjJzMxz1OsqhcIE9bpCKjVId/elHD/+AKLop16vEQjEkKQ4mlZmYWEGUQwQCEQ4ceJRoN7yfGqahs8X4PjxX+C5525lePjnXHHF85hmCUVZolIZYmnpMKq6BNiZ4z6fH78/iSS1YRgKhqERjXYRi7WTzx9ncfEAXV0Xkkz2c/z4/ViWQX//lYTDGcLhBJFIilis002gqterAG79uJPpLAh+dwiFk7jliHY6PUSttkQoFAPs4R2ynHe9JbncETKZbasyrJ2OX4pSJBaTvCYgHh4bFE+QzxInK1nRddv9a2fqnrr0ZGXdsf3FbSKKfgKBMMeO3YeuK+Ryx8jljlIszlCr5VhcfAHL0pHlCygUxhEEi0ikh1RqgHR6yJ3jW60usLQ0RiAQAkRSqc2Uy1MUCpONkYM5CoVxBgauJJHowzAMgsEYnZ0jzM09j6aVCAbjJBK9VCpzFApTiKKIJMUolcaxLIFIpJ1wuI3+/suZnX2aUmmKY8ceIhgM09X1Bmq1ccrl44TDPViWSj5/lHq9hqoWyWYPEY/3UCpNYRg6qdQwspzlhRe+h2EUSKd3snnzm0gk+jh8+McARKNQrYKiQLUaIBz+z/zFX/wnRNHg3//9V0ml/l8GB/8Bny8DmJimDFiEw2k2bXojkpTAzmA2yWaPoKrlRiLeVuLxXmKxPmQ5R7k8x8zMU1SrSxQKx7nyyo+hKDlUtUx7+0jDOzBHIBAF7IlQR48eI58XSadNBgf7mJjYRzq92Z1+ZY+ytMV6YOBqt991rZbF5/M3JX+tPfN6pQB7SVweHhsTT5DPMU4XLUWxLZ2VjT2cLlyGobgWdCTS5o4dzOWONZK04vh8YcbH96GqJSzLajTGiDMxcX+j5lgikeijrW2YcDhNMGgnbxWLk8zMVFhcrNHVFSedXmJq6hEEQSCdHqZanUFVi2iajKqWsSzbwuzo2InfH6VWW0RRitTrtYbAb8Yw6o04qF1+VK+DophUqzOARjg8Qzq9hYWFCJXKHEtLY9RqS5hmHUUp0t6+lUAg1ujc9TySFCQSSaGqRfL5o+RyR7EsH8FgBL9/lqmpJ6nXbTfs4uJhdu16N7nccUqlGfe5jkbDJJNbuPbaHdx1124EQcc0/YiiweOPt5HJ5NA0GcuyqFSKgI5pClQqswiCQSiUIhCIIAh+1x0ty0sEgzHi8Qz1ukokEqSr6xLm5p4lEIixsHCA3t7LiMU6qVYXyeXGKJWmSKU2EY128H/+zz/xP//nP2EYMqIY4Xd+5ybe/vbrkKQUmcw2d3KWLOcBo2Hl2mK6ltCuZfV6AuzhcX7gCfJZZK1kGklKYlkQCtkxR0XJt3yB1mpZDEOlUJgklRp0LWhnxKKiFBqtIkvoerVR92t3fRIEC9O0Gq0p88RiPUhShnx+3HWNT0zs41//9dv87//9M6pVDUGI8rGP/Q6/+IsXEAhIaJqGrqtIUhrLMvH7AxiGD9M0KZcX8PkCFAoz1OslDEPHNOvU62VKpTnqdZlotA0QKZVKHDhwlGTSQhCgtzeCrltomj01yTR1VFVBEDTy+UkEwSQa7aVWe6zRuatCJJIkEukkl5tAFAF85PPj5PPHMAzZfZ4tq8LCwgvMzo4CJXd7JGJ3JCuXFXp6foRlvRtRtEV569ZHkaQ4ogi6LqNpJUBHVRcolSQMo05bm+RatoLgQxCCaFoNw9DI58eJRnvw+yV27Xov27e/naNH7yOfH0eSUo3YfphgMEFf3xX4fCFGRw/xjW98nd5ejUgkTKFQ4ytfuZtrrrmeHTvs18dxaUejHS1Z9WtlTb9aAyg8PDzODd4n9SyyVjKNohQJh5PIcpFQKO7OFHaIRNool2cJBmPuRCXn/n19VzTaHtquy1isD11X0bQiqqrQ2bmD9vYLqNXm6e29rNF3OtjSlalQ8PHd7z5IICCwdWuCpaUaf/VX/5Nrr/0q27cPc+DAd5mbe5paTcEwkohiCkGwW2Q+/fRXqNcNfD4fbW1bCIUSVKtL1GpZQKBer2KabYhikomJA0gSmGYAv79OoVADZlHVPKFQHNM0GpOYLCxLpVicRdcNTFND12VUtcLSUhXTBNAJhTqo1SYxjDyr0Th+/Gmq1RdXPP9VHn/8RwSDdSIRk1tvXWJp6VfYvXuKkZED+P2byeVmURQLCAJVIEoi0YsgiJRKk2Szxxu1xSaFwiTBoEQkkmlknk9y/PghhoZ+AcNQkeVF/P4IdhzavrARBIF6XcHvD3HixCGgRnd3kECgRiQSRFEqFAoBV4wNQ8XnC7lDQWDtkiZJSrqu7OYSqeb3moeHx8bGE+SzyHrlKfZQ+CKFwngjUWj5C9Quu7EnITn1qc52v19C0yqUSidQlBKJRB+xWIZotIdYDBKJzVQq08Tjl9DevoN6veZa5E7GbTZbY2HBoLu7k0CgxsCAiWHMMzp6H8mkSql0gtnZOWZnT6AoEAxCX1+AWk1HlhexLJNIJEUy2Utn527K5UXC4TiBQBhdr2MYNWRZxe83CAb9mKaI333XVTFNH/W6jK7bMVu/P4TPFyUcjrlxW/s4dSqVeXTdboGpKGWgts4z7aNaPbpq68xMAVEMEQr5CIVMYrF/YWTkSYaGrkVRZE6cOMT09ALVKiQS0N0NkpQgGEygKDkqlTl03c62jkS6SKUGAJN4vJ9kspdjxx5ifv45SqUTDc9Eie7uS+js3EmhMEEs1kOlMkMgEENVK3R1dSJJAcplFcNIoShVfL4QXV1xN0/A5wutSvRz3j/BYJSJiX2EQrHGe8i+3cmiX/le8/Dw2Nh4gnwWWSuW57QuDIfTlMuzlMsz7hQg50vYdj/7Gq7nbEs5i6rWKBYnkaQM1eosoVCC/v6rGh2dlMas4RSVyhySlEbTKphmEUUpkE5vpq0tQiIRYn6+TDIJqVSWUMjEMEaZn08wOzvFxMQMoRCkUlCvQzZbp63Nj2WZgEkwmEIUg1QqM4TDMWQ5R6WSQ9Mq6PpxTLNOLAagUypZaBqEQmA3JAng8wUwTQgGxUZWcoq+vqsagxgUYrEMx47d14inmo1nrjVzuhWj8dPKzMxNjI3dyPDwTxkcvJtAAEZHJ3nuuQV27EhQKi2g6yBJIYJBFVkGWGoMvJhDVRU0rYoomnR2XsLAwFUUCtOkUps4duynSFI7khTHNC3K5XlkOYvfH2b//n9hcPBa4vEeksmBpkYuBjfd9HYefPD7lMt5IMyv/uqvMzy8GV1XiETa17WAY7Eu5uf3N7wRMDCwy719vfeah4fHxsYT5LPMWrG95uEPxeIJRDHXIryxWBf9/VcCrRaPohQpl6colWaIx3tIp7eiaVXqdZnJyYcIBGJ0dV1MOr2Fer1KOr0ZRbGnDNlf8im2bx/h13/9Vr71rW9QLFZIp0X6+4fYvPkqwuF2KpUi5bKJJIkIgokgQKUCbW0ZIIsgRGlr24LP56danSUQiFOv11laOoRh1PH7JSxLxO+PUK/XSCQMFAUSiQg+X6gxd9lAEEAUJSzLQBD8zM4+Qa1WBEx8PqlRz1x1zz0QaKNezwPqaT3vo6M38f3v34Mg6IyOfoybb76ZLVvuJZWChQWDmZkF/H7Q9SjBYB2/n4bFqRGNtuH3hyiXZ90yrsXFQ8TjvahqlvHxw8hyHlGcoLNzF7pebYixPdKxVJpEli+gXJ5FFP1Eox0UCuMoSp5f//WPcsUVe5ifnyaTSXHJJXvJ5cZQ1SJ9fVe5SX92h7Kq2xQkEmlzW262tQ3j90vEYtIreWt6eHicYzxBPsucLLa3nvA2C3YzkpQkGEySSHQjihFkOYckJanXKw2h81Esjjc6eG1G02rY/Y/B748QCIQB+MVfvJzh4RTj4/cRCgVpb+9AlucpFseJRKKIYpBs1qS9XUDXjYbLuQBohELtJBIDFIsTFArT2IlQlcYAixCyXCGfL6KqIEm2ZZxMhhBFEZ/Ph2FUMQyjMbrQxDTtNVmWiKblUVUNQdCxrGb3dJB6vQzop/GMB4A64+PXN47jRxB0pqb2smXLvYBIJiNgmiDL4PdXCQbFRqwawHS7Z9mdy/IYRpFSaQ5dr6HrdaLRbiqVRQKBCADhcCfd3QGy2THq9RqaVkYQBJ577h9JJgcYHn4r4bD9+iYS/Vx33SXMz+9H1xU0rUSxOImmKXR1Kfj9EssDIyxkOY/P53ffL8uDIfxe8paHx3mO9wk+y6wX23Ms5+bkneYuTo5rsvl2u4fyDnS9RrF4jHpdJp0eRtc1dL2GopSZmhrHNHU6Oi4kkdhEoXAM06wTiXTR3j6CZWlomkyh8DCiuAhEqNV8FApj1Osq9brGBRds4ciRIywsGEQiAlu2BLATnsA0FcbHH0KWc4RCcQwDQATsDOrFRZVgEEQRymUwTZAkCTAxDB1NUwCt8QOqWscWUQFRDBIKBVHVWUqNZGldh0xGw665NRqP5apnY/sgMA5EcOLMQ0P38+ijn3RFeXDwASwLJibeycTEXjo7H+Lqqx9rWPkmfr99AQGgaTWi0faGRR/AMMA0i5TLcySTPRSLU2za9GbK5QkCAQlVLaLrCt3duykWjyNJKebmngMENK1KOj2EKPqZni64rmhVLTI//zyKUkTTKvj9UWZmnmH79rfR3r7T3a/ZdQ1rN5XxMqw9PM5PvE/rWWK9UhUHx3J26k51XSGfHycUilKvK+i6TKk0RXf3bnp6LnWPGYt1s2XL9Rw9+lNMs45h6CwtHWRx8SChUIZAIEEs1kYqNYwgwNzcC9RqWZLJTYRCMWKxHjStQnv7Dny+IKLoo16voesWuq5iGBrptI+LLx4gEOimo2Mn09P/hqLMAqBpBro+jc8HhhHG7/ehaXV8PgnDqBAMgt8PVsPIswXbwLL8+HwChmFiC6uv8dse9OD3R9G0PIZhUK1aiCKNRihQLEIyGSQQiBEIhFGUEqbplDdZ2GIMzUlfIyMPc+utNzM+vpehoQcZGbmXJ564iX/7t7sRBJ0DBz7Jzp2/R1fX3wGtmdt2HbUtyrruxKaNxqjKCQTBwjBUOjp2NS4iYoRCaUAjGEygaRUkKU0gEKStbbvbL7xWW2J+fj+ynKNUmgV8dHVdSizWQaEwhWHIHD78b/T1vaHxWnc1YsPLrunlecbLPa+b30vNc7E9PDw2Nt6n9CxxqjKU5raYudwY+fxRTNMkHM40ZhCPUa0uMTPzlBuHVJQ8wWAcVS2zdesNVCpzHDp0L8XiBIahUypNEo93USzOEIl0Uq/LqGoRRSkRDhcRRR+iaLev1HWZwcE9zM/vJ5c7hmHohEIJ/H6del1FFCtkMjFk+TD1egXbEo2TSKQbk5HkxkSmKqA2WmVabkZ1IECjxhdARBAM6nVHMJsTsPwYhka9rgIyYCCKthDXahCJOLFdlUAgQTzeiyBEqVZLnJwyIyP3MjLyA2zR9pHNvqPFjX3w4C56eoQmdzVAAFkuoWk1fL4Qouh0w/IjywVUtYSuq4hijEJhgkxmK8nkZnK5g2SzRzFNDVEMkMlso7d3N6paJhiMuK1Fy+UZRkfvRdc1ksleNm16Iz09lxKLdXP48I+oVA4hyzna2oaR5fyqjOu15hk7tcp25rWw7nvOw8NjY+EJ8llirX7Uaw0DcCzkRKIfVS274/oMo0483kcgEEKWs0SjHUQiHZTLsxQKx8lktlGv2z2Wu7ouIp8fY2HhIAsLB1CUCrncUdrbt1OtLgEyhcIkk5OPsHXr21CUPKpaJp+faNS92hOdqlW7J7RhiCiKzMzMM2haFVsoweeLoOsGhlFHFKFer+PzCfh8Pvx+EV0PEY2a5PO24BoGtLeHCYXCjT7R9nZFwRXBSETBNA3st6bj2rYfz3F929a2RTDYjihaBAIi4XA/sjx1klfAWPFb5NJLj/Hoo35XlLds+TnhcIJqNdd0P8HNita0Cj5foLHdHphhx4f9FApTqGqJfP4Y6fQ2NC1PrbZIIjFIKjVEONxBsTiNqlY4ceKxxvvAx9zcMxiGQjTaid8fJhAINy6KxhBFwZ1aZRg69XqVxcVROjpGME2dbHasKaGrVXCddpui2FrX7rmzPTw2Lt4n8gyxnuA6rDcSz5lXnEoNuvspShFFWSSTGSQS6QRsYbdnF9v7p9NDBAJhtm59K6FQjIMHv0ehMIko+jEMA0EwmZl5GkdMLavG/PwLJBJ9VCrzWFYdWc5jGHUymWFkOcf8/IuYZpF6XUAQ6tTrjlvZxjDmePrpmxgfv56hoZ9x0UUPIQgQCESIRrsRBNB1g0hEpFabwk7CUlDVBew4sUGttuzOBigUIJVqLmnyE4vZfagDAds6jkQA6tTrBWKxIRRlEkWpvNRXiGp1ke3b70UQDHbv/nt27HgMny+1Yj87vi2KSXw+qNWWO4IJgv18WJaOaZaRZYVotItMZhBFSTc8GV3EYt3kcgep11UqlTnq9QrxeD9zc09hWXYWeVvbMIFAmHx+gkplBkHwEQolSCYHAZNCYZxqNUYs1kE4nEaW843Z2NDVtatlxcs1zFLLoIpIpO2kQyg8PDzOLZ4gnyHWc1GvHLfXnJxTqy1SLs+iqkUyGbukJZcbI5PZjN8fIpkcoFSaAiwqlXlkOU84nHZdlppWIRbrol6v4vNFicd7kaR2BEFkbu5ZarUjTSsMIYoB5ub2u5nOdiKVr1H/WyEYjFCvW0QiCQzDRNOqxONbWVo6AlS5774/4uGHP4MgGDz66CeB97Nz5w8QRZFqtUYwmEQUDV54YQ9HjvxHhoZ+zNDQvRgGCILmuqKdhhamSaMlpojdKUvHvoAQiEZFVtYWy3KBev0gmraI7YYWGj8tPufGsbSWLaOjN3HXXV9zrePdu7+JzxdAloushT3pqYticamxRSIW60RVa/j9AYLBOJKUoL19J8PDv8j8/H6y2UOoap5qNY7PFyWXm8DnCxAIBJHlLD6fhCj6aGvbRnv7DhSlhCTFqFSExgStCH5/CF2vkc2ONkq9KoTDGdrahqlU5gkGIy29z533lONpcSxpy2p+7tYeQuHh4XFueU0J8tlwx53uY6yXTb3eqEVnP11XkOUc1eoi4XC64SqtMTj4JsCOGcpynnJ5lsnJnyFJCbZuvRGAUmm6MY2pQLU6jWUZVKtzbNp0LbOzT9Nas+vHMFTK5Tl8Pj+iGEbX80iS7QY3DJVEYgC/P4jfHyafP4Ys1yiVpvD7Q/zoR/+Vhx/+DGBhWT4EwWB8/CpCIYkjR65h06Z/5+KL7+P552/hrrv+DkHQefTRj7F1691ceulX2bbtXsAWY+cHaDTjEPH7QxiGD8syEYQQliU2EsecrGwwTaNxIWG55wRR7JIsW3QnJn6JwcF/ZWTk3pbX4emnbwNMN348PX0DV1/9NLpeob5GzxFNm6RcDmNZSmOLSDTaic8XwLJ8ZDKb3VGW09PPMDHxIKpaRlWL+HxRQqEo4XAcXVcwTT+Kski9XqK7ezeGUWdi4hFqtXkuuOA99Pa+AZ/Pvliq12UUpYTfH8U0K5RKGvF4H4pSpFZbolZbQlFKqxrJ2O0zF6lWF5HlLOFw25pDKDwXtofHxuE19Qk8G/17mx9j5VD4Zppjwo670PkiLJdnqVSWO3I5x3W+JO2JSnqjbWZbIwt3Gr/fnldsWTr5/DiiGELX6ywujiIIAgsLL1IuTyOKdgcsRSmhKEX27/8OtdoczS+3INBorGHPKfb5EliWBpQJBgONJCZfIxt4nGBQQpLaEAQfTzwx4oqxbW3ZohwI1PiHf/gHBEHn5z//HeBmxscvQhDsrGqAo0dv4ujRW7jmmjvYs+ez+Hz2eiwLNA3a2yMIgojpZlYFGuvSMQwfoig14s0igYCEzyfh8/VQrxcRxRCGYZdj2Raw3QjkkUc+wq233uyK8ujoTRw+fIv7XFiWn507X0CS2lCUGraoG0AIWLaYq9UJlq30GqIYoLf3ShYWXkQQBDo6duH3+zHNOoIg4vfbLUAFwcTnCxEKJUiltpBO9zEzk8WyBHRdQ5LSZLOHqFazzMw8xUUXvZ9cbox6vUy9XiIe76e7+9JGtncVTatQr1fd+mi7rWrabRjSLLi6rqCqRXc4BXDS0ImHh8e54zUlyGejf2/zY5zOl5kdsxtr6bAUjXaQzx9HFLNufXGzyIdCcWQ577oel5YOUaks0N4+TCzWg6pWGvOFkxQKx0gk+vD7A40uUibRaDuVil0KYxgK9bqKaeokk72ASL1eQVVlV7xssbMTmVTVxLKS+Hx+arU8mlamWl1E0yKkUgMsLDzN+Ph/ZLlUyRblPXvuoF6PtmQtj4/vJRCoYlnL+zk1yo888hl6ex/noouWLddwGEDDsgQsS23cp9kCNhuuWPv/eh0Mw97PtqJ1RDGOaWZXNQIZH9/rCnLzbWCyY8c9bNnyDZaW6o2EsjqCEMSyVsal1aa1wOTko425zgkkKY3fH6ZWs/t7x2LdxON9ZDI7GmMe7ZrrbHaeycks8XiIVKqHeLwbwzCJxXoIh9uJRLrIZseQpCTRaAel0hzp9CA+X4hqdR5FqZBM9jXi/wNEImnq9RrVqi3WmcwwiURfywWh875byxr2el57eGwcXlOCfDb69zZ/0em6gmHobjx4PZw4XjicpFyeJRxO09t72SrXoa4rbl0qWGSzYwQCYYrFyUbWrIZl2Uk8zn7l8iyBQIpwOEGxOIkgWExPP+q6ulVVRdPygIQoBvH5/AiC0BgvuBY1NM0iFIpTKExjmmBZOppWYGHBvmhwmmw4orxnzx285S2fZXT0ppbmG0NDDzA+fj3L4g3Lwmzws599nkAARkbuZXTUSQ67f4V7eWW8sykDDAPTFBrHVhoZ0PWWNTpryeW2Mjp6EyMj9666bffurzWSwuwEK/BhWTqONWyv7Re4+OIT9Pb+hbsGUfTh8/nZvPkGDh9+hPHxo2jaMaLRNH19V9HVtbPRPjSBLOd44omf8fzzT2KaBpEIDA/v4vrrO1lYeB4Q2LnzXQAEg2FE0Y+myVSrs0xPP4NhyJimQVvbMPW6TL1eIxzOkEwOIIp+dF2hUKi476Vmj4vjpQFQFLvG2vmceD2vPTw2DoJlNee4rk2pVCKZTFIsFkkkEmdjXRueSmWepaVRwKK9fee6X2qmqbtj9GTZbgYB0N6+g46OERSlSDAYZXr6SQzDjo0Kgg9JSiIIAtVqlqmpx8hmR0kmB8lkthCL9VGpTKNpMuPjDxIOZzBNO4NXEEQsS0BRsihKhWp1AdPUsCyTUKgNexhEgnJ5AcNYfNnnb4vUXoaGHmgR0JXbm13HjtvaEWjblW0Lup0cZu/T7F4+OX6c1pggcvjwuzl27FqGhn4M2HHiarWL6emrsRO9RLZvv5vLLvsqQNM6f4QoBvD7U/h8FrJcxu5EZq5a/6233sLIyD3uCvr79zA9rfPss08RDGp0d0MwGGBo6E0MDV2MZQkMDl7DgQNPcvfdf4mqCoTDASSpgmnC1VffREdHByBywQXvplicJBCI096+hVotR6k0QySSYWbmKUzTYmjoTbS376BQGCccbnNjx80ibOcpzCEIPndSGFhkMtu8RiEeHueA09XQ192n8tVIYnHqUp1a4VNZyE5ylmHUyeXGsCyQ5SyLi6OoahFNq7K0NEpb2wixWCeynEPXFYrFaQxDxjBUwuH2RmetXmR5nvHxB1CUEktLh0gkBhFFAdM06Om5hGLxWKN15gQ+n4TfH0FVqxhGGUGIUCgc4vT6QK+P3WRjtWiu3D4yci+33nozTz/9IUCgq+sFjhx5O/PzlzaSwXSOHHn7uu7lk6O752EL5z+5yWOAK/g2IgCHD9vx41tvvZm3ve1TjdsELCuAKFroeg0ou9snJ9+2Ym3XtQjy1NTPmJ016e4WqNdpxMTrjI7ez+LiM6TT3VQqUyws1JAkjXA4TKUSQpJ0fD6FYnGeSMSko2MXudwYS0sH3WS6VGoT8Xgvuq4QCo2haRVUtdTIrreHSzS/l2OxLnRdoVyexTQ1VLVMIBAmFEoSDqdb2q56eHhsPF53n85XI4nFrg3OY1ng8/lRlKLbznCl4Dv72g0hfk443EFn507C4TQLCy9SLE65jR9E0UckkuHEicdZXDzQaLkYIx4fIhiM0dW1i1isk+npZ5mdfQFZLjZcl2l6e6+kUpmjXD5BIBBH0ybx+8MIgp9gMIlp1ggGO/H7AyjKyRponBkOH34XgqBz+PAt7NlzB3Nzb3CFLpMZY27uDTgtNYeGHnjJx3dc405cGFgRu3awe18//fSHmkQ/zMGDN3LixE0MDv6Y7dvvcvfetOkBfv7z321xw7diP5amWfh8NKZW2fHwQqHQSFB7FsPwoevg96tYVpj5eUin/USjdptNTasiCEGCwRSGobudvExTR1VLbNmyF13XKBanKJfnsCwN09Rb4sYAi4ujzM09QyzWh8/nJ58fJxptdxMCPTw8Ni7n7Sf05Vq6ayWxrHWsldua/3fuu7LRP6zOwjZNHUlKUyxON+LAFh0dv0w+P87S0iHy+WO0t48QCiUAk0plgXz+GBMT+/D5fGQyw1iW7cZOJDaRSm1iZmYftVoOXa9gGEajxlTAsjQKhflGfDiArusIgoCiTGCaOsFgHUVROBs0x4RXJljV6xG3r3QgUHNrmS3Lx9VX38HQ0L0oyvJwh9MhEKiynGQmNrauFGMHkcOH38Xo6E2Aj8ce+yDHj9+CIOj87Ge/xa23VhtibTEy8q2mHtiPNVpvtmJfmDl9uhuPIDo9vFWq1SWSyT62bNnO5OQY1Woevz/Mli1DpFJp7K5jURQlRz6fp1JZJJcrkk4Pks+PU6nMMjJyM6XSDIJgUipNI0lxKpUFfD4/5bLdVzwW60KSEo28hlhj5KXdpS2T2Xr6T+ZrFK/Ey2Ojc96+K0+3/Ggla5UjrdWMf6UlvfL/5jaXzTgi7BxfUfJEIh0MDl5LuTyNzxcmnx8nnR4iHu+iWrVLj0zTIJc7imUJ1OtVLKuOZfkIBiV0XadWm0JVy2SzRxBFCcNQqdcLAMzNPUe9bpJIdBMOtyMIAqXSHJZlYVkV6nWNQMCPZQnUatOv3ouwDs1x10cf/SR79tzhirFl+QkEao06YJvmjOelJbsMzDQ5LVF2hD+X2+KKuiAY9PY+0YgdLxMK5VDVFHYvbZ1nnvkQhw69i2WLem2XueOGF8UUpulnZYOS3l6YmrJFWJbtjmLBoHNrHb8/hSD4aW8PEAr1s3VrhFgsQmfnFmKxXhRlCVEM8fOfP8UPfvAAkiQjCD4OHXqBvXt/CdM0OXr030kk+jAMC8syUZQy4XAKRSkiy3lkOYcs5wkEwvh8PlS1QjI5SDZbwLIs8vlxOjpGqFTm3ff5682F7ZV4eWx0zttP40stP1rJWpas3Yx/9fEdgZWk9LrWcHPWqtOUQZLSSFK60QxCZ9euXyGfH3djf9Vqjmp1ilRqM6JoUShMUK9XkaQ20uktKEqRfH6cTGY7pdIk+fwEsmw3grC7UznUyWafplodpKtrK4IQIBZrp1LJASECgTjhcAZFKTYE7No1splfPU7HIl4bkbGxd/HAA3/E3r2f5VTphmsljDl/79nzxzz00P/NzMxV7v5+v4Kqiu4+liWsSDYzT+oyN83CumvZurWXfD5Htaogy7ju61JJA3IkEt0oSp54vA27P7ZCNJohHu/BMGSWlua5996HCIctQqE2AoEsL7zwIDt27KavbxPF4ji1mj3iUtMqpFKbkKQMilLGNA0UpeS+V5PJQUIhO6+hr+/ylvdcLjdGuTxHvV5jy5ZfcFu0vh5o/iyv7G7m4bEREE+9y8ak+QrfdiN3vKRaypX3sd3JBoKwnIXqHN+JAztiu/IYkpSkUplH1xVKpWl0XSEYjAO2m2xm5mmWlkZRlCKhUJzFxVE0rUKpNImm1ajVpqjVco2RiFECgVBjrN4ClcoCs7PPNeKKCoIguBcNK1GU2UYdchua5qNSEalUlvD5ggQCEo8/fjl33fVtHnvs49x11z0Nl+0yghDH52vH54u+xFejlaGh+1ss4r6+B9i06V7e9rZPUa9HWd3a0mr5+9FHP8ORIzete54OY2Otwj88/D2uuupLbpb21q0/aexpP161al80bd/+fW699WYuu+yr7n0Bhofv4Zd/+WaGhu6lVrOt3Wp1rUdeiYQoWvT1baOrawhFAVW1Bdnvh2pVplwuk8lsJZHoIpHoxO8PIUl2TXp7+wXU622Uy3VMsw1VlSgWu6lWBfL5LJZlZ+jreg1VLaMouYaVXCQcThMKxajVsui6QiAQxjA0KpVFSqUp1zJ2apFTqaHGGEu7d/nrCefzqyh5t/7fw2Mj8Zq4RHwptZRrzSW2hysY+HyhVePtYP3mCc7jlkrT5HJjhEJJZDmLopRIpzfj8/ndOmW7NEnn2LH7sCyTRGKA9vYRNK2KZYXIZkeJx3sIBhNYlkkyuYlyeYpyeYFksgdRFBGEEGCQzY6vc3YaJ048AMDcnO3uDQTAskoUCjA+/ucnzWa2LLUxn1hb6+CnjZNZffToXjZteoBt2+7lyJGbmJi4nnC4yurrQEd57ZivIBhMTu5taRqyFoOD9/Pkk8v1xJdc8nfufUZHb2qJTS+XWumk08fc87711psZG9vL4KC9Tnsghn18UbR/Tu46DwIGslxEliuATjq9fKso2rFlWVZQlIJbC97evpNqdYFcbpRUajuJRJBYLMTCQo1kMkU2m2fHjhCJRJiZmWcxzTrDw29H12UMo46qlqjXa/T2vqHhbZllbs7CsiwWFl4glRqkrW0bqdSgOyFKFP34/RKZzCCl0gxtbcPuOl9L8dXmfvHNOR5r9ZD38NhInN+fvBWczpfKWm7mZsFd636nJ/h2M41KZR7D0BqWSp1ksh9FKdDWNoyiFEkk+qnXNSqVWebn9+P3hwmFIiQSffh8EoIg4vMFSCR6KBSOUq+r1GpZUqkhZDlLpbKEphWwE5hEnEYYzSgKJBLLyUbVKkSjq5tlrHbNarxSMW4mn99KPr+VmZkreeSRzzS5k+/g2LEbKBQ2Ua32NrmNBVdAt25dubbVbNt2L+95z81MTi4Lv8PKblyOGK8877XKt5yunaYJY2M3MTl5PcPDzS5+CXCS48LYHbxkHEs/GLTbgAoCjYQ8gBylkkk4nKKn51IUpYRhyFSri0QifWzefCnvfe+v84//eBeFwhzd3QJXX30lkqRSKMyjqkVmZp5gaOjNhEIJcrljlMszGIZKJJImnd6OZWmNLl8pkskhhodvbMzRnicUirvTwQKBGJnMVjStSjAYA15b8VXnXKpVu1udk/Rm93ZfXPOi28NjI/CaagziWKrNZSArOZVon07G9cptYFvZ1eoi1eoCspxDEHxkMluQ5QKFwnESiQF3ju2RIz9iaurnWJaI3x+kp+dKNK2CLC/S13c5wWAM06wzO/sc8/PPUi7PIYo+gsEEkUgbS0tHWFw8iK6bQI2VIrpWIrVj4a3X0KMVx4Jd6Vo+OU6CVSBQXSNOvGyhbtv2fQ4ffpe7rbf3Ud785j8GOI21tdJ8ruPjy5ndAHfddU/Lvtu3f4/LLvu7Ux5bbkxYHBu7ie98p7kpyM2MjPwr9sVQ84WQY4H7ceqiq1XcPt32cx8nHI7S0TFCJNJDKBRBEHyIIqRSw6TTWxqJgGkmJp4gnY5RrT5Jd/cbkOU8qlqgo2MXoiiQTA5gmhq53Bjp9OZGjHg79XqNer2GKIbo69tNIBDFNHUKhXFCIbsdqhOmOZ33+PnEys+jYw0vLo6ytHQIy4JotJ1otI1YrOe8v+jwOL94XTYGMU0dWc5imkNr3rbSVb3WbWtZCmttc3pUZzLDxGJdrhgHg1FyuWOYpkE4nCEe7+bEiZ8BfjStjGHoFAoTWJZFPN6DzxegWp1CUQoUCpMkEr309V1BNnsYu5TJQhAEgsE4iUQPvb1X4fP50bQ8pdICkjRAuZzFmXAEtnXmiAG0/r1eQ48Vz9ZpPNutrE6wsjtj2Vg4ouVYws29sGdmrubpp2/jssu+2tSsY/3HaW6x2XyhYT++PQqyt/cxensfY2bmisY6DDKZY6c8d+f4fX2ry7WWXfwrnx8n69qP47WIRluvc6PRNny+ALVakc7OXViWRSzWjWnqCAKcOPFzTFOlo+MiNm2SyGYPUK/XyGZfpKPjYgYGLgd8qGqBSmWBer1GOr0NRcmhKAVCoRjxeG/jM5BjYmIfqdQgmcww4XAb6fQQmlZtyY9oprm64HwQ5ZVuadPUW9qCOucXDqdR1TKhUJy2tmE3lu7hsRHZ2J+6l4gzHQmWB7I7XyxriapTmtQ8g1gU/Y3s6KR7jPUb8FuYps78/H4WFg6g6zVisT7q9TKmCaFQjGJxikikA8NQMM0wlmUSDmfw+0P09dlj9nTdbMzOrVAsTqEoZarVOebmnkeW54nFetix42ai0TbK5Tm6uy9BUYpEo11UKnMkk91UqwaRSG9jnvAMs7NlJiZuYmHherZvf/UyqkdHb3JLli677KvrDGxo7l0NzoziSGSJN7zhfwE0pi0t1wk3d9Bab60ry6ma97Uff7kzV3N2tXNBEAjUTnpuzfOdLeuTXHNNa7nW2tnXjgjb7n6fL47fn0JVF1r2svtPV3BK3K644iPMzj5HrbZEKJRAECTy+TFEMUS1Ok4olMEeQxkmnx/DNE0sSyMSaadSmUcQLAoFe3iIZZmYpoksZwmFkoRCCQKBKIFAlGp1nkJhklAoTio12FLuB7QI8PnktnbGmC4uHiQcTjUs/9WJnaLoJ5PZQjiccYdueHhsVF5T704nK9r+0mmdObyWqDplINXqIqLoa5mYY8+bba07XvlYTp/qWm2JanUJRSmQSg0RCqVJJHpRlGLDmpEZGLiSQCDWiC0byPIi5fISgUCAer1OvV5BEHzMzz9HKrWpMUUoQ7E4g2UJqKo9DjGXO4IkJYnFuiiXZ9B1rVFbqlGpLCBJCXy+MMXiXn74Q1u8nn76ky+hP/T6OILo0CygK+PTTpzYrgW2m3XUau08/PBn2L79blZOi3Jqg0/WNnM9i3V09CYmJ9+4Tmcu53+TY8duoF6Prlny5SSBNc931vVIS4x6aGitdeksX3yYGEZl1Zd+KNRNMBhGEEQkKYEoBhgf30cwGGZu7lnAh65XGwl+BoFAiHpdxu8PUa9XCIfb0LQC+fxR6vU01WqdaBT6+kLMzT1NIBAmmz1CqTRDb++lgEixeAKfz082exTLMhoWeReVyjyzs0/R1XUJ9brcGKJhv5/Pp8lPdhXCIqFQ3K2MsEV6vuV7AOy+8a+3mmuP85PX1Du0uemHLOcxDLUlw3SlqEYibWQyw6RSQ+7EnFLpBKapux/4tfpUO+4yWc5TLE6gqmX8ftv6XVg4iCj60LQauq4iy3kUpYCqlkkkBpifP8Dc3FMoSha/X0LTZGq1JQqF4/h8ESwLRDFIIjFIOJwmGs1QrS5y8OA36ei4CJ9PwDSTKEqeZHIzlcocpmkBOqZZp1abANYXr1Ox0iXc/H9zM4/GM+Ee18msdmqN6/UoW7b8FFlOk8vtoNltvfx3s3jaNcCl0tqxf1g7KW3lRcLqzlzO/yLT01czPX2l69J+85v/W4uF3XyRYFk+N1HMSRYzTTs2LAgQiTQ/htHyd73eWlKjqhqpVA+RiP3enJt7hmLxOLFYP7quUi7PYZoqghBElpfo738npqlQqxUbpToipdI0L754mJ/85Ai6XkcQJN75zl9g61YoFMbRdQ2fz4/PFwKgVJqkVJoiGIwTCtmZ+4uLo1Qq8+Tz440e5xLhcMYV4PNp8pMo+unoGFkVKwZbgLu6drnlipFIhyfGHucFr8l3qfNhXVwcxbIMarXsunHj5ivnUmmacDjdqFUsIgi09Kl2cFx74XCadHorlmWQSPQxNfUYlmUxO/s0CwsvUq9X6ey8hEAgSj4/gWXBzMyT5PPHCAQkTFNAVcssLR1BVYtIkkkkkkFR8hw48G2CwUhjhGIOTSuTSm0mk9lFIBCnWDyOphUxTSfByASW5/eeOqN6GUd0S6VeDhx4P2C4HbacKUyOiK14pldlLANuLHfZYgVbGG0h9vvVpm3LxwKLAwfez49+dITrrvvsqlKjZtF3Er9++MM/Z3W8evm40egM1WpP0+Pb+83MXMVdd93jWvjLrTeXR0o2Z22DXcLkZGA7mesrqdVoXFQ5850BcihKG8FggnpdQ9fVxiQmhVptoTHGcVnhi8UJ6vVSo6FLN8FglBdf/BGPPbafYNBPe3uEuTmD73//Pj74wSvw+41GtnUbiUQXmiYTDF6APR86RE/Pheh6HUlKNC4y04TDGQxDJRo9f8XKuYCoVOaR5SyaVsY0dXK5MaLRjlVVFB4eG53z85N4GjRfQa81nH2teFlzoxGHtT7Mzb2s7bm1FWZmniUa7QD89PUFmZp6FFUtIYoWkpTBsixOnHgEVS1RKi1QqcwAAsFgmFAohmlqhEIxgsEolcosEKJYnKdSWUAUTY4f/y0eeug9DA8/wjXXPE4ud4iZmQlgfs3zX0u81qI5GWpZQG1hsqcwGQ0r2yAWm23cyxbA1QK9Mpa80n0sEItNNUTfuW3172PH3s511312zfpfxxofHb2JH/7wzymVemmta26tac5kjlKt9q7xOPZ5jI/vBWipWe7tfYy+vseRpOUs7iNH7IuWwcH72b597eeyVoN63a79ti/mltdfr9eoVJbw+4MEAgGCwQiFwglM08IwFHw+H7FYD+FwEkHwo6p2HkIk0tZwRy8iinWSySjhcJ1MJkqxuESlUqS3txdJamP79rc3Ys1mYwyniaZVqdcV/P4gPl+I9vbtRKMdtLUNu0lezTTPTt7obl5nraapk8kMk8kMU60uoqr2rO/zyeL38IDXiCCv/BIxTZ1sdoy2tuGWrOhmAV4rXrbyA7zeh9kRbXvOscLc3PPk88fw+YJccsmvo2kDSFKCycl9mKaAYSjk8ycoFI42SljyjbUoyHI7waAPUQygqlUCgQhdXRextHSESmUOqHLgwE3cddeXG0K3t2HVPX7K5+VkGdWtPaBXCuhyEpQj0pblo6trP5dd9nduD+jZ2Te0WJlgD3lYbkW5OpZbqfQ23ba2KG/Z8m8nPa/VFxG2VZtOH8I0/RSLm7Fj0gb1eoTWJLNWq3xo6IEVFxEwM3NFy3mNji6XPz311Cf55V++mR071n5eA4Hlv5uHTViWgCQliUY7UZQcxeIUmlbD5wsQDqeIRnvp6LiA9vYdHD36U+p1mUQiiqKUkKQUkUiEWk1C1+tkMiFUtUhPj4Ak+dB1GUGwqFZzRCJpZLnYEHaRYDCKZVkkEgP2GYv+RpZ+dc33d62WbXSVK9Hff+W65YMbATsH5Agg0N4+4uZ6ZLNjnlXscV7ymhBkJznLiR3btZfH0XUFv1+irW0YSUq2xIRf6dVzrZbFsgxUtUImsxVZzpHJbKVWyxEOp4nHu+nvv5bZ2ScbVpbJ0tJxFGWp0QnKNr0sawlVDQAmihJDEEIoSp5yeR6w+zauzGB+4IHPMz195boJSqdi7R7QzRaynQTVKmaOuEGxuInmUYfOKMPlxKhmFzJN/zcLo7OtVYx37Pgm11332ZOuf7UVbq8vn9/ReAzRPZ9t2/6tMdqx2TK2/96z5w73uXv00U82rak1wWxlPH5qai+XXHK6z7kf8GEYGvW6TKEwQSgUJRrtwLLm3PcsWGQyW8nnjzfGLhoUi9NYlk6pNEc63c4v/MIe7rrrGTStTHu7wa5dl7N9+/X0919BuTxHpTLdaDSSQddlIpFOpqcfJxbrRpbbkOVcY9rYSEsVwcp2sHalwin6lm4A7ByQbe7fzoW4ZRlrhpo8PDY6rwlBdpKznM48ThxY1xVyuSNuI3nL0k/rg7pWk4GVX1yOwPf0XMr09FN0dFyIIIjkckfRtLJbHxkIRBFFH/F4P4ZxL6paRtdXdtcysZOaNGq1eUKhJPV6zr3ViQc7gjY3d2ljnrAd673ttt9ly5Z/cqc/nQo7Oct0BWbbtu+TyRxjevoKTpzYgxNrdeYUN09pcizTZWFdHmW40tJ0BK6v73G2bPmpG4+2LD+p1DEKhc00J3ft2XMH1167LMbrtatcjo+vbIu5/H9X17Ps3fv/uILb2qhEaLKel937juW/Mu6+Mh7f3EVMUey4cnPfbafVjr1Nb7TLDFCpTDfc0GnS6UESiU2Uy7PUakuAn0OH7mbHjlsIh9sIBCLkcqPMzc1Rr8uEw3GuvfY6rr3215mZOYphHCISAUlKEIt1cPz4AxQK47S3byce76JYnMMw6shywW0QsrCwH9M0icW68PulVRPOnF7PTkLURrcyRdHvWvBOxYPt/pdcgW72nMHan2UPj43Ca6pTl64rrqva75fc/0OhOIpSQBB8p9U2z3FvRyIdAO7fjjvcaeSfy401GvVrlErTRKN2KVIwGKetbSuGUWd29hkUpUQud5QjR36EouSwS2V0IIgoxonHU43hASqmWcduxdjK6OhNPPDA55mfv7TFkhUEnRtvvJtf+qX/h1zuhVM+R6uzkmHPnjt4y1s+yw9/+Oc8+ujtOBbn1Vf/JUNDD/Dww5+mWu0gEllidvYNazT+wO22tdLydsTy1ltvBpY7cUFr8pezhtPF6ThmZ3RHEIRaS3vOZnfz2JjdPWx8/AZmZ692H3OtUrDmTmb2epc7f62MxzvxZac9pmUt/8DyjORoNEU0GkeSEtTrdSyrTjjchigK1GpZTNOkXi9jGHVisU42bXoTliWg62VqtRyaVqG//xo6Oi6gu/tiYrFOSqUZN2s6FuujXJ5ElrN0du6mWDxGsThJItFHJJKhr+8qfL4A09NPIYo+tm69Ab9fcq1zQeC8715VqcxTqdgjR52Erloty8LCflS1SF/fVe4UNuez7OFxtnhddupqzoyOROxM6Y6OEQC3Q8/pXBm3jlxMUi7PomkVCgXF/QLTtCrj4w+TTA40xF+jUDjRaFLQjmVZlErTaFoVWc6SSHSTTHah6zK6ruP3C/j9SUxTQ1VrJJP95HKLwMyaa2rOYG61CP0MDz9JtZpb834rWcuKdazHyck30pxpPDT0ANPTV7q1xIXCVoAV97eZmbmaiYkrGzXG9sXCkSO/5FrhR4/u5S1v+ZRbyytJuElnfX12eVFzG8yTzUFeWZrlMDj4eIuY/p//8z0OH77FXe973nNz4zz3snXr2oluzUljzU1I3vOem9m791Puupy1Otax2dS8a7l/tUMBXZeo11V8vkBDsAUMQ0cQQgSDAqIYRNdrRCLdlEozDQ9LpZEdnSYW6yca7WRy8jF0vUpX1y58viCl0iSyXCCT2czg4LVks2PEYj2AxaZN16Kqdl10sTjZ8CRtRVXL1GpLlErTJBL9BAKRFmt45YXt+dBW0/mc2mtddK1+p1EQrD8kxsNjo7AxP12cXm/dlfusNyP5pX4AncfL5Y4QCqWQ5Sxzc8/g80Xw+XwN93iOfP44tVqetrbNVKuLRKM9RCLtCALMzT3XcBeGCIVSgMnAwB5EMUylMk+9bk/rMYwKoKIosydbEsAatb4Rtm17io6Ou1HV05oT2OT+Xo6XgrHCpevjggu+ycjIvTzwwBdojvOmUkcZGbmnaa7x8m2PPLIcP96z544WMdy06YGWdSgKjYYia8di15uwdLJuXTYC09NXNq0N16J/7rkP8d73/jLbtt17UsGH1XXck5N7V100gF3e5FjFzt+CsCzITttSVZ0jEBgCLKLRNtJpe7hDPj/RqCEO0NV1FYFAEFUtUiqdaAygUEkmN1EsHiOXO+h6b0qlKZLJTfj9Yer1gpvFrShFDKNOMBjHspwyuiLBYAxRDBIOpykUxqlUFlGUPKZpMjLyTmC5u102O+aGeuLxnlVtKTcKzS5pAFm2ewNkMsPud0JHx4ib5OVlXXtsdDasIJ9OG7+V+zQ3BrGt2/S6/alPNTDC/jtPPN5LpTLf2EcnFEojSQk0rUQ4nCYS6UBRiiwuHqRaXeDYsR8iCEGCwQi1WoF8/giDg9ciCCKaJlOvq5TLR9c9b9v6u5GhoR+f1IKz8QNRnOSv08ER9Yce+jQzM1fjTEJaWct74MD7ue++I4hineakq4suust1LWez2xolTNDcgAPg2LEbVlnAzRw5chPT03bP6JW3Oawlyq1CafDDH/45Tz99G11dL7TEqFvXZK9rbOxdPPjgH1GvR1dMb1ptda+MG6+8oDCM1f3CV4qxZTXXIkOlMs7o6H9gevoGLr74EFu3fg/DUKjXq64Vaw+dCBCP96HrGpFIG9FoD5pWRVVL5HKzVKtVotEq27btIpHobWRXZ0gme6jXy9TrMoqSR5KSGEadcDjViEOnUNUyougnnR5icVF2cx0AN6Zst9ncTDicplZbbHyOOtYsHzyXNGdZOz27nc514XCaRKLvpP0EPDw2Ghs2hvxyLGSH5hhwc9y3eT875jSLIPjd0YiOJRCJdDQaDBwhEIixtHSYxcUDhMMddHbaGaozM08jCNDWtoOxsR8yOflzyuUZyuXxNdcaDnejaX4MY2rdc16Z/bxnzx3rZFKHsOPMIUZH38H4+J6XlG29Vhx5NU7ili3U6fQYPT1PkUjMrJimtDKjehknLrzSqjxypHWK0nvec/OaouyIdvO5rS55WmZ523prWp44tTLO3BwKcNY9OnpTy0zn06H502Sarc1DVr6+t976XkZGfkowGEDXBdLpDqLRbgKBKIahUKstEY120dGxHZ9P4rHHHufRRx/H56tTrca48cb3cuONe5DlBeLxfqLRdgKBaENYQZLiVCpzZDLDrqVot1YNIUlJstkxV7iARjx7+TOw1rCJlZ+ts8nKz7Fp6pRK08hy3s0NmZjYRy53lEgkw8DAG8+rgRker13O+xjyetNnVn4oHcFtLuFYGStar22mk5WdzY4hCDSGSqTd1plO049KZQ5NKyHLi/j9AeLxHmq1RWKxbo4e/RH1uobfHyQUal9XkGV57pTnvLK8qblL1q23voeRkX9p7KkCPkZH38Fdd/2Lu8/6Ar76cVpFy2T79nuoVrsb8eLWLGqAcHiJAwfe7z5WKnV0hSiu7iHtuMFlOcrgoG0JHzlyEz/96V/QnOXtuIPBFuGJCTsJy0nSanZNOxb+Aw98nrm53S3nYPegbraQW5uANMfdV5Y1NbfNfPjhz9DX97j7eGuNs1yJ00Sk2Uq2B304Mfm12pm+kZGR76JpIuCnVPLh84Xo6rqEQmEcyNLRcSHxeD/z87M8+ujT1OsBJClBMFjjJz/5DiMj3XR3d+P3B5HlMouLB1DVKuFwmny+iq5rCIKfaLQDVS2gqkXa20fQtCo+nx+/37YanQYb9rmk13XxvpI47Cu1rleGoZyRp6paolbLkkj0MTBwNZKUanivPDe1x/nFhhVkWP0BbL6Ch/XHI9oTm+z+tk5iykpW9sK1E8GW3dvOB7lU0unqupBIpJ1SaQpFyTdqnU2q1Sz1uoyqVohEOtG003cdr8VKN2mzeDz33IeZmLiewcF/Z2TEHs4wPr6nZd9WAV9/mMRyHNl9Ntw5wU6W8eTktS0Tk2S5vUXs7JKl5Xpfe9Th1U3HtEcsOmt68slPkk4fatQKL9PsDl5pOTef/9Gjy724WxPcls/BviCxM67Hx3+R2dmrcIR2ePgeOjr2t2RiryxrWs5cN07Z+/tUMejlbGsBCCMIsTXamT6EU/IGOvV6jkrFT6UyR602j2ka6LoCaMzPHyaZLBMMRimXdcLhEKpaoVwWiEZnKJWmGhePMyQSm9C0Cl1dl6CqRcCgWl0kEIhhWfYx7bK9JRKJfhYXR6lW56lUljCMKps3v2VdwVzvIvh0eKXTpFbmiDiDYQSh1VOy8mLeeWzPSvbY6Gzod2fzB9CeP3yEVGrzqjFrK6/aTVPnxIlHG/Wd0NW1q+W4K2cjO5YBLNcXOw1EHIHPZCocOvRv5PNjJBKbkKQk9XqVWm0Jn0+iWrXHJIZCA6jqCQDC4c2Ypoiqrh8zbmZl0lZzTPTgwbciCDfwyCMfY8+e/8Zb3vKZVV/wazXrcFgZI7311pt5+ukPIQiwe/fftYhdqxvXtqTD4Sz5/DArk8Gcel+w65uXlkYawyRaLVJglRiDxY4dd7vW8cTE9SvOZdni3bTpgZaYcnPtsGXhXlC88MKyqAMMD9/LJZf8nfsYvb2PMz3dWr40MnJvU99u+3EdsXbKphwLf3UG9TLNrTbt1x+WS9xERkZ+wq23vpvx8V9oPP7dTfcOAiEEQaRWW0BRKliWTjicwZ6LvUgmY6GqVXy+ELouk0qJiOIU2WyJaLSDQCBOItGH3y9hGDL1epmRkXcyOvp9dL2GYdRR1SK6rmBZFrValrGxnyJJScLhNIahUyqVkeU8iUTfSWt4X464NrecfaliDq2erpWDYZztTkKa7e5vd+9bqcxRLs+6JVGeMHtsRDb0u3K1u0lY05W9clutliUUigPQ1ja86ri2uI+RSg25ZR2O1Q1OH2I7CcRZQ6GgUK3OUa0uNL4EAiwuHmwMAlARBIFyeZ5EogtdDxONdmMYCuFwG7VaG/n8MVS1zPIgiLVpTtrq67PLeHK5rRw58k63/vjhh/9v+voeW1PAG8+c26xjrRKelXOE11uHI9qHD9ttMgEymSMNwbUtT0eMV9cf25w8piuwa9ffuf8NDt7Pk08uX2Bcc80d6Hpk3RjuWq1Bm0VdEHTS6WMt973oonu56KLVx3rLWz7rPt+OWDfPR37yyU+uG+tuZrXl7MMWVLsr2cjID7nggvswTaevpm1BS1IKyzIQRR+ynG/8LTI//xzhcAJJEunoaGdsrMDcXI1wOMj1119Fb+92Fhefw++P099/BbKcp61tG+XyPJ2dIxw48D2y2UPUalna2+3t7e0jJJObOHHiscZghhzRaAeDg9eSz4/T1jbcaKF5CEUp0tt7GapaxrLsNb/cUY3NwyBeipivbNSzstd28+3O5z2dHmrp1V2tLlKrzaOqBc+N7bFh2dCC3Ezz4Ie1rs7XKnNa7wrcboiQawxxl1qySB2aO/3ousLU1JNks4eo12sUi5PEYl1oWqmRtRqhWi2gqlksaw7LMsnnJ/D5QiQSPY02iWCL0vpivBJHcO677484fPgWlmOihjsUodnqnZ+/iMOHb+JUrR+d+zaL9Pbtd3PZZV9dJXCl0qYmK9cgl9vR0szDmbi0LMbO+dlr6O5+ktnZq1mLa65pnai0bdu9vOc9N7sW7HolUSdjpahv2vTAKd3LDs0Cv9Z85MnJvQCrEs1OjhObLgMSYGGaNWyrGUAimRzAMFTqdblhpc4RDMaRpCihUIxkchuqWmHz5svo6RG56qogqVQ7O3fuQZJilMvjhEJhZDlPOr2ZmZmn6em5lGPHfkqlMt+wijXK5ROoapVotIOOjgvo6BhBEMAwdGQ5i6J0uN6kSMRPOJzBNOuN5C976IVTwfBKRO2linnzZ1vXFY4d+3disW6SyQE37NT8fdDVtYv/n70/j5Lrvs874c9da1977wa6G0BjIQiuokhCIiXKUrTYJiVbsU3b4/GM9M6bZM44M47OvPMmsY/HYyUzOTnRnGxv3pO8VuLEjmklsixStmhZEklxpygQJACige4Geu+urq59u3XX9497b3V1dXWjsZEA3c85OOha7q1bt6ru8/tuz2OaWivTJctB+vqOEQqlrup197CH9xq3DSF3pqva/++8b7cXi1Ao1aovt9ea/JRapbJCLneB9fVpcrmL5POXCASirK2dYX7+ZWzbQhBkTLNGtboANDbt37JMDMPCskx0vYQbHV8dtupDuxd4X8YS7FbUe//9v+/N/lotqUvobsXYLp8JcPHi41y8+PkWMUM3EZL2/82W9OTW1Hm7eMjm/G4gkGP//hc3pZHBHRtSlK0R7G7EQtrT8e62TzA/v9Edvd1M8077yucP0t7o5TgSslxvpcOvVKffDD8adn2MHaddiU320suuLaPjWF6d1wGipFKHAMNrXMoTDMZQVQtdv8zKSohk8jDR6DCCICFJEhcv/gWVyjJLS28QDKYQBAlZjmJZNWxbRlFU0ukDrZRxf/+JluqcL6zh/34GBk6QyUC5vEg+X2B4+D40rdD193WlMcL2hfHVknn7b3tl5TSNRh5JUhFFCds2W+I/7anwXG6a9fVJ6vV1xsYeab3uXh15D7cybstvZrcf9HbNJt10qWGDjH05vY2xjlWy2fNYlk6pNE+tlsOyGp6TTD+2bXD58kvUamuIokogEMadHNO7HKlKtbpEtTp9ze91c+e1TSBQJBQqcu7cL/jvHIC33voSv/zLP9eqhfoNVX63cLsVI+BF3JvOoHf/BjG313P7+09z8OB3uzZFde7fMGgR4ttvf3nTqwSDhS1kDO5cr++O1E6enUTaSdDd0vGK4rordW53JVLuZrrhk/LJk24H+0ad/sqNXxvwMyMWjtPZ+KfTbNYQRQnHMXCcILIsIUlBbFvHtmF8/KMUi8soSoh6PYckhRBFkVJpHtNs0myWOXTo01iWRSAQI5PJIQgCjmMxMHAfqhrFMGrIcpBGI8fs7MtEoz309Bz1dKtNAoEExeIsxeKsZyPq/qZCoRTLy2+iaWVSqXESif1dI8ztslbV6gq1WrY1WtjeQLkbYvR/v8Fggno953mQHyQS6WF5+RS2bRGLDXkNmEusr08SCCQIBuM4joOihLy0fAHHMTcd3x72cKvhtiTkncYnOi8M7bfdx12hg97eOzZdWPzVda22TiAQQdcbaFqFanWRQmGe/ftPkkweYHn5DQxDwzRrQIN6fR5fEWorGtvcv3ts7ogWaTZ7aDbdRp92VCqDABhGZEt62k/F+uSxNcUs0t6sJQgmguC09uE4Mo888rscPvwMw8NvdJWebN+/ptEi3OXlB5me3ki3l0oH+OY3n96xHrsdeXaOH2na1lEiv+btd3bvpu7rY6usqOsk5TtQfetbT7FhhiGxtPThXe23e5nCrS2DiWkaSJKI4wiIooUkxQELRQlhmjXm5l4kHE5QLs94do0pwG3KajZLBINxTFNnZOQebNtkdPRRbFtjaOh+BEFgefktkskxDMM9gdXqMoXCBQRBQhRlms0iihIlEIhjWU2azTrF4iymqZFOTzA4eC/F4mwr5Qs7q+T58EcLLavJwsJrBAIxstnzBAIxarVsK7LdqQPaJfVVMpmzCAKk0xOMjn6EYnEW3/e5/TWbzbInbysRDqeRpIB3DDqGUae399guP7M97OG9x21JyDt1eHZ2cvrd0p0XCv/H79eams0Sc3MvEYsNoigDhEIWCwsvkcmcwXHsVrPN+vpFZDmI4zhYVoXtybgbfMWr3ePYsWc4cuTbrdrwVg9hb8/enxt+xNamKLYdnSnmkye/SjZ7gunpDaej++77Ovfd9/UtSluHDz9zRelJv9t4aupxZmZ+mvbUry/M0T57fD0YGXkOx/nNTSnybpKXu8FWWVH3PF+48EtMTf0RhcJh2s//wsKjrca5a4MbsTmOhmW5lpe2LQIGkUg/tg3Z7BkkSfXIWiEQSLB//0lWV98BXMvPUKgPTctTr+fp6TlCMnkAQRBQ1QjT09+jXF4klztPKnWQYDCFLMcJBII4joAsq+Tz60SjMoIg0WxWyOWmkKQAoVCKQCDBwMAJEon9LZ1oH9XqyqbO5WAwQSZztiU2Ioqu6M7CwmtIkkyxOEc02k8+f6nV2e1nqKB75LpB6jq12grJ5Lh3fy+p1IGWIIhf247H96OqYYrFBaLRQSqVVQKBaEupbE+xaw+3Mm5LQt6uKaR91b4daXf+6P0xCcPQ0bQisdg++vqOsbJyGlWN4xKIQ6k0z8rKO8hyCHCwLJON2uBucXVk7GNg4ExHUxd0RsiRyGqr3tzZdNWJzhSz3zw1NfV4K9XcOfPbrZbr11vb5S/9xzZmijf8lNvHoAqFQ0xNPb5jlNz+ep3jRz78RjD/uIEdNbR3wvi4u6+33/4S09NfoL2J7u23v4QkbZYRbW+uaz+27dLsrvOTf+/m745bV9YwDANVHcEwNHS9Qr2+SjCYIp0+SLW6gttB/yy2rVGpuAvOaLRMo5HDNBs8/PD/RDY7iWE0WFh4BctydbIDgUFM08CyHFTVwTB0HKdMoTBLo1GkXs8Ri+1D0yoEg2lvekGi2Sx5JDawyaoR3M7lanWZYvESIyMP0WgUWF19q9VI5WeoHMfCMCySyTGaTdea1J/Zv1KDl68XYNsmsqx69qUNgsFUS4nLt16s1TKIokS9nmd9/V0ajSKSJCGKEvv3P9xKle9hD7cqbktC3q4pZLtO6060i9InEvs87VsZQXAIh9OeUleadPoopdICqhrGNOvounsxMAyLG5GO3i382uVGlAkbhOyTg8CpU1/eFB36TVfd0Dky5KeZt4t+O+/bXG/dSA376ebN40cbNWg/Ep+Z+Rmmpz+/q5Ry+2xxtzS0f9w+fuEX3MXGduNSZ8487omsbNXR9vf1wgu/55lluOfdzx64EOhsrus8tnZXKN8RSpKgXofwlo9FYeP7ZHimDzqGoaOqEURR9RaMZTSthiQJCIKK49jU6zkEwU3VStICr732Lz1HpxqCoCBJKhMTn8YwdCzLoFZbolxeBgSCwQThcB+WpQMO+fwlLKtOOj2BaWrEYoNePdbNMnX+7nyibDRcYY6englPyARUNdKaUGg2S/T13YllGYyMHG3J1Pq4Uk233aNZVSMUCrOEwz2tkUXXB7lJKNRDJNJHubyI4zioaohEYnRXlqt72MOtgO4ixLchOg0l/ItHe8enf4HIZidZX58kn5+iVFpEkiSPhPtoNkusrJxmcvI7zM7+AE0rAg6h0ADBYC+9vQdRlO1O2805na52tK9GJLA5Onb/npr6GS5e/Pymum+3dPV2CAY3/u0Gvtyknx6fn39sk47z2Nhzbcci8cgjv8vHP/7b3vFuls28Ejpni5eWHtvxWO+88xl+5me+soVsNW2D3H/yk9/gm998mqmpx7vu4+Mf/21OnvwqG3retF7/6NE/4+GH/zlPPvnElpp953mwbVdCs9OicTNquCNRbsrdsgwajRVMs4aiqMiygmlqWJaFrpcxzSaWZSBJrnuTIEgEAikMwx1Rmpp6llotAzj09k5QqbjykgsLL6PrDcBB14voeoVms4Jh1DCMBoIA9fo6a2vnWVh4meXlUzSbJXK5aWzbxDQ1MpmzLdL1ibK//0TrtybLQSRJplCYpV7P0mxWCIV6MIwGjmNRKMwSjQ4gy0Hq9XWy2clN5Lwd/N+zrtdaOgGAF4GbCIJEJNLXJugzQjQ6QCw2BMDc3EsUi7O7fr097OH9wAdm2Viv51qi+J3d1b6yULE4y9raOW8m0V1NuypgbpOJbZs0m2Wy2fNMTn6bYnGOQCBKKJSmULiMa0IvIkmBbY5i9zPGu8Xk5OP86Ef/0Lu1uX6cTl/AtmVKpfFWJJpIXGZg4Owm9a2bAUWp0V4XluX6FgWroaHXqdd7OH78qZaOtdvg5b2bXaaUO2eLd7vQ6FTOgq3kvlONuZ1sXdit+nr7uW2vx+/b97xHGO5j7c5PjrPZIWoz6kAIUQx4xK0CIsFgEtPU0TQ3Q6PrBZrNAKFQH4riNlmVy8ueWIfb7BWNDpFMjpFKjTM7+wrr62eoVtewbQPDqBMOp2g2S8RiQ0iSSCjUR6ORJR7fjyyr1GpZJCnY+p04jkW1miGbnaRQmKFazTA29tFWCtiPcKvVDI7jjgKmUuMtkRFNK7U8lgVBIBRKEY0OeFry7u90twIh7sLE3NIb4ov75HJTFIuXUdUYihIhGEywsPAa1eoyhqExOHj3rl9vD3t4r/GBIeTOFLWfvjZNjUajQCAQo1hcoF7PUamscuTIT3vPySGKMoZRxbYtHAfW1s6haQUEQSYU6vUI3qbZdI0myuVO7+IoLjE12RB8uH5syFe2p6k36pftilm+uUKxeJBicYL77vt61/21C4lcD1yy2phNNk03D+vXe7/5zQ2d6Vdf/S2Gh9/okMa0OXr0ae66q7t5g28yMTbmzhYryhObVLR2wk5mEN2EQ670XL/J6+jRp7eQsV+Pb3eFsu0N8vUJ2U9Z75yBaGDbMpIUwbIsRNEVmBFFiUAgjqom0fUytm2iqmFAYHHxFJal0WyWCYXiJBKHkGUVy2qyvn6RWm2VanUNRQnjOCax2AiSJBMO9yMIKrreoFSaIxzuQ1FUkskDxONDGEaTAwc+gSjK5HLT6HqVtbXzlEqXiMWGyeWmcRxrS1OXP+JUr+doNHJIksLa2jlEUaVSWQLchkvf5tHXnd9JStPPbtVqWRoN9/faqaTn17eTyXFUNdrav6/a12gESaUOIUnBvTryHm5ZfGAIuXMO2RXhX2Ft7Rzr65MkEqMMDt6FKIocPPhT1Os5lpZeJxBIkE5PoChRACyr6al4hYhEBgCLSmWZYDCJLAdZWlpio94nIIopVDVMIJBC17O7cnXaLbaO4biv6WJDpAMsZLmBaUbx0+YvvvgPNpHvTvKZ14LOTu1DhzYUsbq5Sc3PP7aFDLstGtztN9eMFeUJz6N4a4PZ1aKzCexqOr1PnPg64+NbhUY6XaHEtsrFbksAGzCxLA1QsO0NpyrTbBAK9VCrKTiOry+ewjDKgOzVkTVkOUQ0mqbZbKCqYcLhARKJCs1mmUCgF9s2SCb34TgCjmOztnYWcFDVuPecRKt2nc1OIoruvguFJcrlOWQ55HV7x2g0CtRqaxSLlxkZebD1XD+dDA5LS2+ysnKKSKSPRGLUU7pboFRaQBAkhofvJ5udpNHI0dt7rGUF2Q7f99i2LUKhHkKhFKapUSzObSpN+VFvIrGf9fXz5PPThEI9RKOD9Pff2dIg2MMeblV8YAjZhx8Zu6NMRRqNIo4D8fg+VDVKb+8RTLPp1ZxtAoGEFyHXsG1XVSuVmkCWI4iiRCbzFobhKihJUgjbbhcAcbDtPIZhelaN18EUXbAxwuSTmx8d24yMvMHS0sMtUnbJeANLSw+zvPwAr73mNhp1pmp3L2rRHZ2d2u376uYm5ZNf5zbdyLWb1Oe1yGh2w+ys67F86NBzm7rLuzV57ZTebj/u7bbfDo3Ghm/y1gYvcDMtrpqXaSqoqoogBDCMRktms7//OGATCqWpVleo1wvMzr4ICBw8+Ji3iIwjyyEUJYLjOBhGk1Sqh1xuBtvWvei0B8tqIEkKqhpFklQCAYH19fM0GkVkWSWdnvBSz0WCwRSp1BgrKz9hYOAeAGq1tU1zxe1p5Hx+AcdxCAb7EEWVsbEPIctBKpUVyuXFln2ippVb777bjHMyecCzQa22asHBYILe3iObyNjvJUkmD3jzyLRq2+0iQHsp6z3civjAEXL7HHK9nkJRokQivchycNMPvFxeam0jywGq1SzRaB+m2aSn5ximWaVSySCKCrrupt9CoV5kOYxhVDa9pmWVqdfL3EhsSGa2exP7EZPIo4/+Y5aWHmzpLW/tuvYbp6yu0enIyPPXfYzdzB38+6/kJrUTukl9XivaI9TOLMEXv/gEwLYd3AcOXDm93d6NvZ0QSXupYHz8mU2NXldSELPtGo6j4jgWul7DsgzPiWmecHgAw6gRjQ5SLi8gilAoTFMuH6NcXmJx8RVCoR5P7KOC4zisrVnYtoEkBYhGB3AcE9NsUirNEYn0k0730mjkSacn0LQytm0RDMaRpABjY48QDvdw+fILrK+7o4JHjnwWTStiWU2y2cmWypdtmywv/wRBsOjpOYqqBnEcnUplhbGxRxBFGctqEon0tRqvdrJTdUl8mZWV0xSLc9i2TiQyxODg3a3ast+97feS9PUdI5eb3lJv3ktZ7+FWxQeOkNtXvxsp7DXW1y8QCqVIJse8UQ3X3alWy3D+/J9Rq62xb99JBAGq1TUKhVlyuWkqlSyalse2dYLBPuLxIXK5At2lMm8cNqerNxPu8LDr9LTR7LWR2tyIpN3/fQ3mQ4fcVK0fnd4IUY6dsBvi3Wnb3UTSV0In0XVG3m5H9PZCIv452y69PTX1uEfGbmOb323e/rz2ka3XXvtNfv7nNwh7wzN5JzQxjCqKotJoFAGbXO4SqhomGq3S13eMWi1DPL4fXa8Sjw9TqcwjywFkOUi1mkFRwkiSjGlaWJaOZZn09EwwPPyQJ22p4Dg6tt1kaupZqtUVDhz4NCCgaUXW16eJxQYIh3u92rFNs1lmefnHqGoQy3K7nPP5aaLRQQYG7sK2TSqVVUxTo6/vDsChXF4mEGi06sVuU5eFabq/R9PUWgtn9/PbqC0HgwkikX4CgRR9fRFqtTVAYHn5ba/OPUUgEGt1W/taBN2c2/awh1sVHzhCbp8xBigWZ6lWl9H1DZ/XTOYslcoKshwmn79MLjdDs5lndPQksdgIjiMQifRRKs1Rr68CLhs0GqsIgoQgKJ5+tcXN6KyG9rRve4QM7kXoYb7xjadYXn5o0zaBQBldj+HbNPrNX6YZRhRdb+BDh57ZVON8P2F0eG34qd+Jiec2+TI/++zXNomP7Aazs1sb2Dojbz/ibY+CDx16ftN+Omec2+GmtK228y219um/l2LxYEsMRRAsFhYe48iRjf1t5628ARHb1qhW54EAYOI4Brpu0GiIZLMXCYeTiKJIOj1BPj9NubxCMrmfUKgPWXalIwOBGLLsEAjEPdlXGdu2iET6W0YNkhSgUJihVstQKEwRjQ6yuvo24XAPlpUmkzmL49hEIn309BxlcfE18vkFQqEohqFTq61iGHXi8WECgQSKEiKdPkA0OuRNMFS80pA7O5zPT2PbFtXqCpZlIIoisdg+entdjW3fAz0e30+hMOs9v+ml2tMUChcJh9PkctNe/TtOKjVGLlckGEy0OrJVNdLKiO15Ie/hVsYH6pvZrtgDEAr1kEyOE40OUiot0tMz0fJC1rQiqhpDEESSyXGCwbtIpw+jqm4tVlVDXorvoqcBLKBpVdwuagMQCQT6EAQJ02ximje2YeTYsWfajCI2y2QCvPvuL9FZWz506C877nfJXJZd1yd3bMvd/uqbjTawGwemK23XiQ1lLzd1/OSTbjq5m/jIleDvCyxee+03OX78T4jHlxkff65r5O1Hwb4+926j8Y0ygEvKvp1k+3tp18X2sxXtuPL5s9lY9Jm4izPda0IUqdXWME2dYDBOuXwa2xYIhUR0vUw8Pka5rKGqcWQ5TCIxysDAcRxHotHIEAhEiMf3EQqlvLrtOocO/TTLy68zPHw/6+vTGEadSmUNVY2xunoaSVLo7z/O0NA9rK2doadngmjUJf5gMMnAwB3Ytk1Pz0QrFR0O95DJnMW2LVQ1RrW6SqEw67mlub+/cnkFw6gxN/cylcoqltX0fls6y8tvUa9n0bRSq9Gy2VwgFhtFVZOIYpBM5mUSiVFvJNFmevp7BIMJRFHy1MjW8f3U96LkPdyq+EARcrE4x+Lia/T2HkNVoziO6QkTpIjFBlpyfW7qehzfcH1g4Djl8gqa5pqXBwJxQqE0vb1HKBRmWVz8Mc1mmc3SlzaGUWdk5ENoWp1sNt/x+PUjk7nL+2u7MEpse9z2yLgdbif2q6/+FmNjb9yQueRuBg87OTLtFt2azjp1qZeWdqdLPTfnipb4c9LuebFadePHHvtK65iDwa2Wj93QjTi369juHO9y4S6Q2sfDrh4BwEKSYihKD7XaJQBM060v63qZcDhFKNTrCdnEsO1eZmffZXDwXgBUNUGjkSMaHQaklsgHQDZ7DlEMMjh4D6Io0dd3mGz2DJFID4ahUa+v0dd3F7VallxuBnAzUJbVQFWjRKN91OvuhMLc3CsEg3FisSFvBCpPubzA+voFenoOoyhBVDWGphUwDI14fIipqe9Sq62i6wUUJUgqNY6u1wiHUxQKlzznpjWq1SUqlWVisSFUNYIkiV5dXGVw8C4qlRUUJYQgSN57DhMIHAA2mr6uZBG5hz28H7hFkpc3BrncBVZWTlEsztHTM0GzWcWy3I5qx3Hl/MB1jHEt2waJRHqpVl1ziXx+imJxjmz2PM1mCdu2OHLkcQYGjqMoQRQljCzHEYQwrisSlMsrFApT3Ggy3j381xXbbvtRs90ai3r++d9hcrK7KtWNxLWOJG1W9pI9je2t97Urim2nLjYx4SubtQupbJha+MfZ/q8dnfvbiTwPH36GT35ysypY+3tpd9BqT2n78FPyV/5sArilEwHLalKrXcDtY9AxzQqyHEKWFWQ5QKORQ9OyiGKYYnERyzLIZs9jGA1WVt4kk3mXQmGay5ef4513/pipqb9gdvaVVs9EKjWGaTYpFhdxHItM5oxH9v2YZrNlxmLbNqFQj9dQ5aaMFSXI2to5VlZOcf78nzI//xq1WpZQKA2IXkOkGxXbtkU2e55icY56vYTjCNg2JBJjxGJDXoZrjHq9gG03WV09Q7O5DjgoSgBJCmNZGpVKFtNsUCjMks1eJJkcJR7fRyw2RLNZZmXl7VZjmKYVNo0/+Q1keyNRe7gV8IFaEgaDaVQ1hmUZTE9/j0ikl3z+Ms1mhXp9HdPUkCSFRqNAKJQiGEzi27TV6zmGhu7HskyWln5MONxDKnWgNTpl227qMBTqw7JCGEYDRVGo13OYZumKx3YtohydphLBYBZN62Mz0XRGz+3mExuay5nMvTz11NNXPX+8G4LdjdfwldAZbY6Pu3rQ241WdaJzLngj3b+Rvt9JCKTzPWz3fnZzProZXnRrDOvs+v65n3uCe+7xH1dwSyM+mv4RdDsqRBFvVj5CMBglFhtF07LYtoGiRIhE+pFlFUmKoGmLlEqzNJtFJCmAppUIBJJUKgskkzWWlnSv1itgGO5IlGW5wjiiGMCyNJaXf0yjkWdw8B7i8REvgnYjzb6+Y5imQTicplSaI5kcQZKCjI4+RLG4QDK5j3x+Bk0r4Mp4VpAkmUYjiyC4tw2j0erYrlQyaFoNTcsjSQLj45+kUJglHh9B12tEIr04jo6mlZibe45aLcOhQz9FvZ7HNLXWQry9WaxcXmpFy+3KX3vYw/uJDxQhDw3diywHKZeXKZcXqFazmGbNawbRicf3eeMWOo7jtAzY8/kZJEny3GvWWF+fJBRKMDh4j6f6Y6AoCoKgEA73EgxGCAZTWJZGobBMPl/APZXdVbquVZRjs6mE1UHGu0MgUGk1eu00f9ytLryTCcONRPsc7yc/+ZXWfUtL7gLms5/9ylXv85Of/G1GRt5gdvYxBKGOaYavKARypUj5SmTcOY/sm0y0+0O377ez63tx8TGOHvWNKRQ2dLSv3NEvigEUJUgwmCQcTtPTcwdLSy9Sr68Tjw+hqgmSyQMEAlE0rYSuV1DVKKZpUC4vEIk0CIfTCIJCrbZOJDKAZen0958gFEojywqGUceyGl4Xcx+WZdDTc4h4fB9nz36DRqNIf/9xenuPMjx8L5cv/4hqdYWVlXeIRvsAAUUJU62ueRrxAsPDH2Z9/aIn5hP33ksI23bLSW7Uvsjg4J2EQilUNeKNNzXI5SZpNuvYtsGJE3/TG4laQFHcZs1yeR5ZDnuyohv69tVqhvX1SUqleVQ1RiTSu2fLuIdbAh8oQpblIEND9xIKpbwZxx7W1y+STLp6vLHYkGfIXmrJ/QEEAjHvIlFCkkooSohwuI+VlVPMzDyLbTeR5QiKEiKRGEJRolhWjXR6gqWl17mSDWM3oYvdEHJnV7CLTmOJKxG03SLj7WZ6u9WFO9Wy2l2MdiKmKz3eic5mrs7ZYL/ueyUP5m7vZXz8mesSFLmayL/b+2h3v+qGzs93//7nu4xBqeyGkCuVRVQ1BhiIosDi4o9oNEroeo1CYQFFyVIoXCASGcY0NZLJ/UQiAxSLCziOTjCYZnT0URYXX/FERVLceefPeTPGBpbVJBYbwTQbDA6eoKfnELXaGo5jsbJyBsNoUC7Po6pRwuE0jUYZy7JoNPIEgykajRKp1BjVapZkch/x+D6azQqWZeA4Fs1mGccxSCYP4maDUt4COYNhND0bxuPEYv3oeoVyeR5JClOtXqJSuYwoSqTTB7Esnd7eI94MsptON4wa9XqupQIWDvcQCvXQbFaoVFYZGLhrbzZ5D7cEPlCE7CMeH/HqRUWy2YvEYgMkEmMtAvbFQVzPV5lqdcVLoZUIBlMEAilWV89SLl8mn59F06rEYvuJx/tJpyewrDrr68tcvvyCZ8W4MzovvPn8oV0Z2x871unP2w2dZLyZoJvNJABHjnznqgwnus3s7jZK7kZA25F0NzWs7WaD28mtW0R/NQuB3S4cdrvPK6l6dTsn/uc7N/cY+/e70fsGIde3brADTLOAada9+WQJw2iiaUXC4V5Ms0GjUcBxbMrlDIFAHLCJx/cTCISp1WrU6y75uQvPINFoH6XSIqbZJJebxLJMarVVBEHEsoyWPOXS0k+8aDvE0NADyHKASiVDJnMGy2oSCCTI56eRJJVGI49pNrAsjYmJz1CrZclm30UQLJrNErIcQhBERFGlVltF0wqIokCzWWZ+/kf09h7l+PG/iaYtYZoa1eoy9fo6hlGnWl0hnT5EKnWgtfB2f+dpMpmVTQ5PvktVoXAJw6hRqazQ23v0qs73HvZwM/CBaupqh2lqLC+fRtMKlMvLrR9opy1jMJhgfX2G2dkXWFt7m2JxjkLhAvPzL2JZNoriSgoGAkF6eo54/rD9gEy9nvF0h3eGL3Rx+PB3ANcq8amnnt7SyNPZ4DM56aZt/S7qrejWSNZJ0G5DUSp16apqx50NVaOjz7dmZq+3XtyOzmau0dHnu97Xjm4R/dWgvcP6am0nt8OVjnk73HXXM3zqU1/hyJFnEARXSvPKjV7bZUR0BMHtHSgWL1MqLVGrueIcLtHJRCL9nvKWiiSFGB19lOPH/yax2BCVygKOYzI09GFEUWVl5RT5/AyWZXniHGmCwV7C4TQAkcgg4XAKRQkSj4+hqhEGB08gSQqC4HjKdgHAQdNypNMH6es7zoEDjxEO97Rmky3LbbiUZVeatlbLsLDwCoXCJc9dzf1wAoFegsE4yeQYkqRimtBs5gGwLIuengn6+0+gqhFOn/5D5udfJJ+/TDic2tJBbdsm8fgI/f13MTLywK4+qz3s4Wbjto+Qu40t1Os5z8s1TzCYZHj4fsLhnpYF3MY4RQ+aVvIuhGlEUeXgwY+zunqGRqNIb+8xDh78NIuLr5NOHyIcHiSffxddd2vHul5FFIPYdpMrCYQcO/bMjqnrzjqz35S01VyiHVsvzNHoIoODb5LL3UGhcBRfQlNR6ts2lnVGi8Fgdxej9nSq42wWtbhSene7iLTb6FAwCIqy+bXbX6cbrqW7u/M97yZqvpr3sVu0n7cf/OD3Ws1obr/BFzl27E87ttiuo9+h0ahjmuexbYNms4yqxhkcvINGo0izWUBRIgiC+30yjAa23WT/ftdK8fLl5zGMCoFADNvWkKQooVCMSqWGrleRZYVAwG2E9L2GC4XLuDP6JaLRHhYWXqe//wSKksAwyqRShz1Di1FkOczAwJ3E4yOsr1/gnXf+M+HwEMFgFMsaIBodRBAkVLWMYVSR5QDhcIpAIOY1qg0wNfU9TwN7nUZjFVkOATaqGqfRKJBMjjE39xKl0iyWZXDgwE95dfWNlLRtm8zNvUyxeJnh4Qda2gN72MP7jduekDt1b8GtEQ0N3cPSkkk8Poyuu+m/bHaS1dW3qFYzxGIbzx0evo9icd5rOFlHENza19LS6/T330Nv7zEajTz1+ir1ep719SlKpUWg0vWYtsNOGs2dZD019blNtxOJWYrFQ1ypoeu++/4D/f1vtIQx/IYw9yLPto1l26VUO2uwPvFeWWFqK7ZLZberYbU/x3Gu4UV2eQzbzVNfS/obdjaY2G30vaFfDn7y6tSpX+tCyNtD05aRpH2IouI1bVUplZa8cagqihKmr+8IIKGqAZaX3wZEIpFeT8FNolicJRLpQ1F0KpVFms0qwWACWQ5i2wVKpQUAb4ZZQFVjhEI9LC6+SbF4iWx2Ck3LYRh1DKPO6OhHqFRWqdXWkCR3/Gh29kWy2XMkEhVSqSPU6+vs23cSRQkxMHAnKytvo6oREon9hMM9LC29Sak0T6Ewg6IkUNUwvb13Uqu5Kl/5/CS12j3U6zlGRh6gVltHVSOIokytlvVEQtzLXbWaoVxeplSap6/vjk1zybcj2tUJ95TIbm/c9p9cN8F41wZOwnFsisVFenuD1Os5b9QpQSo17jWfuNu4KW2JbPYsgiB6CkLu/e5IRAQQkSSVZrOCLAfZsGDcPXbjkOST8OHD32V19UOt23fd9VTbxXo72BhGuEOYwtdZdiP4nRrL/Aj6amUqrwfdyKo9W7CdYcONeJ3r2Ven29N2BhVXet32rMWpU1/e8vja2old9RtswKBWW6K39wSCINFs1igUpgkEEuh6FUnaj1vGEGg23Trs9PQa8fh+FCVJtbqKYYQ9EldpNNyoOhodQJZVdL3CzMz3iMVGvBFDnWazCghksxdoNNaIRIZIp4+Qz0/S23snIGKaOqZZp17PEwwmGB9/lFotQzp9mLm551hfn6JWW2N09DHv9ydQr2dJpQ6g6zVCoSSGUSedPkRf3x1oWolSaZHDhz/N0tKPaTZrmGaTSmWFnp4JRkdPAlCrZSkWLwPQ13fMG1PUaDSy2LbN6upZJCng6RLcnmRWr+dYX79AubyKLKscOfLZvaj/NsXt9+3rwHZSeI1GgWp1hWh0CEkKtMi33fUJ3NVyIBDzHguxvn6eQCDO4OC91GoZBEFGVWOYZo1qddUzay/hCjUYW173SriSQ1I7WY+MvMFbb30JxxEYGXmD48f/pIsa16az0Yq633yzXQd7Qw97u27rdhK8GpnKm4HraSi7EnYb+V5NN3mnMtfbb3+p6/F2lgw6yxTp9IUt2xSLB3aYH5fZ6C9oby7UKRaXkCQIBEJEIvtIp0cxjCax2H4kSaBWy9LffyeSJJHJnGZt7ZwXKbq61rHYCLVajkAghmHUqdcLDA7eRSw2RC43w/z8y6hqyCP9KqFQD4nEMIoS4OjRJ1hdPUUqdYB6PUMwGEUUZVQ1juPYZDJnCYVSHDnyM1SrawQCKUyzQaXSZH7+eXS9RCAQxTAaBAJxL4Vue1F+kWLxMo4jYRg1Go0Cg4P3kc9fxDBqrK6+Rb2eIxLpRRAkEol9FAqXiER6mZn5IdVqBlGEQCCNKAYIBmMUi7MYRu22lNX0Z6kDgTjV6pueCEuKQ4c++X4f2h6uAbc9IW8H35s1FEoRj4+0CLj9B2eaGqXSArZtcvjwZ1hePk2tto5pVtH1AQKBMPV6AV2voChBCoUlGo2cVzPuPnN8PehG1hcufAFBMLl48fNEIivsNOaUTl9oXfA3C2NIPProV1tzud1ENtzozL4iCe4U8V1pjrfzOe2Pbx5X8rMFrphHp/7ztWA3teFu9+1Gt3vDtxpAZHr6C0xNPc7hw8+0SFhRaptqwxse1RvGE7YtdezZ/ey2H5XzlcC29i+YZgbTDHpNVQaCoBIMBgGDXG4OWY4SCMSp1/NYluvMJMsKQ0MPMjJyD4ZhYxhVymVXA7paXaBW62dw8G7W1y+Sy11EEKC39wTJ5Dj79p1kbe0ssqwwP/8Kq6unKJeX6O+/E01z68GRyACC4Mpt5vMzVKvLxOOjyHKQWGyEQMAVNqlUVllamkNRghhGw5PAdLwu8XmKxVnS6UPIcohSaZ7h4fvp77+LaLSP5eWfkEjs88apTFZW3qbZLDE7+xLl8hyFwmWCwR7C4SR9fXcSCqUxjBql0iLR6OBtJaHpa/dblisak0wepNmsEosNvs9Htodrxe3xzbsG+DPJ4H5xfWUe2Iiqs9lJ5udfRFVjpFIHvB9nlXh8H7XaCvH4KMXiPNXqEqurpymXl7Ht2jUdT60Gkne93U361O20/b/xSRIsarWhHbfJ54/y+uuHeO213+TIkW9vijINI7yF8H2ymZp63FMEc+GT4Pe//7UtNdGrmc3tfO52ddtOAZLx8XalLVeLe3j4jS1p4GuV6bwaXOm9blgw+opgbJLo3Goy4T7n7be/RF/f2ZZTlONIDA//hGJxom1f4o7z4y5sZDmFaVbYukjUqNXWPKnNHOFwCscRkGWVQMBifv5VT60r5LktSdTra6yvTwF4jmgBQqE+0ukDCIJMPj+DqiYZGLjbG38aJZEYRRAc+vruYHn5x5RK06ys/ATDaKDrZcbGVCRJxbIaRKM9gMzy8ikUJYBpGlSrK9TrWWQ5yNjYIxSLc1QqCwiCTCo1wdLSq6hqnFjMVfwKBuMMD9+PrtfIZs+Ry00TjfZjmglSqQOIouwp6YWwrCayHKa//45W5suydFKpg6207szM98hmz3sWq8lbOkr2m1iDwQS53HTrs83nZyiX5xFFBcO4+nLaHm4NfGAJuR1ujWWSQuEyjgPJ5CiNRoFAIEY8vp9odBBNK5PJnMG2LcrlDJXKHKIoUSzOUy4voWlFbLtwTa+vaRtk7N/e6ULvpzI3w68Dt2tWd0bKVouA3Yu8vO0FvZ3MOlOuQ0Nv8Oqrv3VDa7jbod0vuP21Go3IFdPWVytCcjOw+dyBf95HR59naanTZGLzlGGnEls8vrSpbAHsQjY0RCKxn2p1lWZzrcvjGpomIEkBTNMiEukFbBqNHEtLP0YUHURRJR7vb80al0qXCQQSntFKkr6+owiC7HU3rxEMplCUMJq2wqVLzzI8/GHi8Z+m2SxgGHVsWyKZPEClkiWdPsT+/R9B04o4jkWxuEA+P0Wz6XZz79//EcLhIcLhnGeTOEcqNUo+fxHHESgWXW9nSVIZGbmPcnkJw6i1Zo1DoSS1Wg5JUohE+hDFIbLZSTStgCCIOI5NMJiiVFrCcSwsy0GSVGQ56Olbu5F7ONxLX9/x1jhWtZrxas2Flr9yoTBLT8+E10Ny49BOsppW2jZKb4+IV1beRtMKpNOHCAQiZDJvYxgNbzwtfkOPbw/vHf5aEHIwmEDXa+Tzl4hEBjxjeNNbkT+KbZssLLyKKIpIkoJhZCgUZgCZWm2ZQiGPbWeu+Do3ClubexxGRl5naenhtvuE1mMbdcQNRa777/8699//9VYNeids2Ai628ZiGVZXb04NtxPbCWp0HpM/17uT8cN7Tc7B4Ma5a3eX8j+b7kprLjHfc8/Xgc1ezD7xtpNvNyLeXIv+LvH4MKKoUC7b3lzu5hR2MnnAc1eKYpoaul6m2SwTDCZR1TSiKBEIJEkkRpiefpZ6vUogUPK0oqvkcjOEQv7ccJlCYY5gMIJl2di2q7LVbFbI5S6Sz19EFAWi0aGWQE+hcBlVjaCqEWzbJpkcRxQVIpFeVlfPYZplEon9yHKQYLAH0zQ9eUwLcH+n0egg1WoWQZAIBlM0mxUEwR3disX6kSS3N2Ru7mWq1TUikR56eibQ9TqmWefChT9H1yuEw4OkUuM4DkQiPTQaRSyrSTp9mHT6UIv0KpVllpdPUSpdprf3BLHYkDfjDQMDJ27k14h6PUe1ukI2e55QKNnq+u4k5no913Kwq9fXKRRmSKcPIUkBIpFeSqVFdL1KrZalp+fIDT3GPbw3+EATsr/ytG2TSmWFSmWFQCBBOJwmHO5rdVXatsnIyIdJpydIpcZ5990/pVrNAjKVSuE9JePuEHj00X8MwKlTX2J9/Q7y+aNsJmORRx/9KoYRbl3YJycf31SD7mwM8meJ/RnapaWNyOzixc/vKHKxXX11N/aM7diOeK9nrvdasNNx7lRHvuuuZ1CUJ3juud9hbe3elkzp0tJjfPazX9k0yw1bTSZ2a57hY6su+s+TSk3SbNawLAtXanPzh1CrlYhETCqVZcBCUZIYhkYiEWVw8B6y2XfQ9TJrayUUJUoyGQUkr4Fqjnx+lv37H6Sn5xBra2e8NHiMWGzEa7TKc/bsf8ZxHM+EooBl2eh6BUGQ0LQi8fgY+/Z9GE0rkUodJJk8yNLSKer1VWq1DMFgD8nkfmQ54NW1dXS9Sjw+hqJINBpV4vFBJMmNbHt6JigUZgkEYkhSgFRqnOnp77G+PoVt654H8zmGhu4hm12mVltrdYOnUmNetGySSOwnGEySSo1TLi+Ry02xsPA6gUDSe+/TKEqSnp4JFCVET8/Ebr5OV4VgMEE2e95TM3N92svlBdLpwy25T/95tVqWkZEHUNVJZFltSQC70r/PYhh1733u4XbEB46Q24VC/JWn40B//50AxOOjSJLSUu3ytymXFykWF0mlxhkYuJvl5bc4ffobWFa3NODVwScvnwCvVJe8//7f92q6LtEeP/4nrYhoYOAsFy9+wXumu2JPpS7xmc/8vS0X9J2ESPxj8udnJyY2mzj4RDEysj0Z7qYRCnYmu52It30++Ur7ulnR8W7ei39ON7rUN0oEnbPcnXXw7brut8PWz/RRjh37c+/R7pkQw1hD0/q8C7WFYRgtO0NZdhWyqtUMzWYVSVJbHcq53CSmqXuRmoRreAHR6BA9PYeQJIWengkajQq53HkkSUZRwoRCBwDZsyUVkKQgtdoyi4uvoihxLMugXM626sx9fceJRAaRZZX+/jsxjAZzcz9ClkPk89OAiWU1Mc0Go6MnCQSirYV2ONxLPD7ipXK1VhnKNA1Kpcs4jsj6+rteWn6YYDCNLAcoFC5h2yaCILQcr/L5KaamnmV+/kWSyVGqVVeWMxLpo7/fTWfnctMkEvsolRZvWPq6Ws1Qr68jy2EUJUijUWh9lu3XM1/ESNdrDA3d25rRtm0Tw6iTSh1CVSOMjX30uo9pD+8PPnCE3C4UEg73UKtlAWvTSthX6fKRyZzlzTf/LbpepV5fQ5bjnD//rRtCxj6uZg62fQRKUeotxa7XXvvNrs/v6zvb9aLemTIdGXl+E6F0Gki0R9A+UXQjOsMARdl6/06kuNNjncS7k8jGlfZ1PbheG8kjR74NONx//9dbGQp/IbWdwMrVYqu4zHNc2XzCwDQd0ulDWJbhZYyWsSyo1VYJh3sQBAlFCRMIRJBlFdPUUdUE0WiUUCiBJEmUSpeo1/NEIv3YdgPHMYjFhjDNJs1myUuz9qOqEaLRfhqNNRQlxtDQvaytncG2TQqFSRzHQhQVms0igUCcVGrCc3FyezSaTTeKdlPdYUKhOKXSKtXqMnNzL5FMjhMIxNH1Eo4jkkqNoaphms0akcggxeI0qhpH08pY1iSLi68QCKSQJFefoFpdpVRaIBiMtyL4ZHKMeHw/gqCi6w0ymUlUNYokhWg23eMqFGZZXn6LU6f+PaFQisOHP3tDZDcbjQK6XkZVY4iiRCTShyzvbwUV5fIC2ez51mu1O1eBK3hk2wbBYIwTJ35xbwb5NsYHjpD9FaP/LxRKtR7zV5ftXZS2bVIqzbbE92dmfsDs7A8xTb+b2p/jfW/hE+Kzz35tx8YggIGBs9vuw48+9+17nomJzWYH1+pCZVnuP7jxHc87iWy8F9jOwMI/Nj+b0H6eNs9wu/X7ztRyt/fh7/9aF2vd09wR3O/J5k5b01zBtntIpw95rkxhLKtJs1n1zCeKXur3JOXyPKbZ8DqVgxiGRjZ7kWh0sHUbFGKx/UQigzSbDVQ1TiTSTyp1kFAoiasEFvGapvo4dOizZDJnvehcZ2zsE8Ri/VQqaxSLl6hUlhAEUJQgw8MPMDz8II1GjtnZHxGJpBkd/RiOY1CvF1lYeJVIpA9BEDGMGmtrZzDNJuFwkno9B9g0m3WviWzOEwoSkaQQwWCceHwITSsjSSq1Wo5CYZq1tXMMDz9INNrbUuyTJIW+viNIUoCVlbdwHIfZ2edZWHiZWGyYRGKEUCjl1bivXVSkr+8Yoih7M9OzOI7lmWdkCId7WFk5TTZ7DlWNdl0ApFLj5HIXSacPouu1PUK+jfGBI2RwV5yW1SSXmyIUShIO93lpHQ3T1FpNE6apceHCX/Lyy/83KytvoihpbLuCZflk7Or+Ok7pfXsv3RuD2uGqc22Hbmnf7fbdbbTmSp3MNzpa3ck16b1CNyJ+++0vMz39+a7ZhG4LG+juWNUe/fvv188E7ET47YIi3dLc/nMOH/4Jx4//gGZz6+iL2yV8ENvGS183aDQCngJXDUEwWF4+hSyLGIaO27UPptlAVV3NdkkKUa2uAhaRSApBEJFl1RPuCGHbJktLryEIQRxHpFRaYn39IgcPfhJVDVOtLuI4UCpNMTBwD9XqX2IYure9RK22Tr2epb//MIuLL5HNXqRcnsWydA4d+jRgomk5QKSv7wjhcA+G0aBQmKJUapBOHwYsQqEE2ewZQEEQJAyjimk2UZQQjUYVUZRZXT3X8kLW9SKXLn2PWMwd42o01jFNjWx2ElEMYhhvUChcYnn5J54EqML6+hSaVmJg4K5diYp0090Hd0RzYOCEVzYoUihc9sw5elrNXeBQrWYpl5e2kL8fZKyuvkMolLqtZqn3sBkfuE+tWs14Pq0OgUCURqNIMJhiff0C2ew5+vruRJaDqGqEV175/3D27H8kl7sAmBjGKhBAksJYlgRUuvjTvrfolr7eaOZyO3u3n1HdDJ9YAO655/e3NHNtFx1fz3jR1UbQO3VXG8ZGZP5ewY/YO6VHZ2YeY3z8GWZnHyefP9h1xKx9sTM6+vyW6N+FxZtv/iYnT35106iZT/hbm7i2KnZtfo7Mk09+nmPHOsfmAOosL09hWQXcNLeDbWvYdgBVjXpa1U2aTcubyXe1qPv7j3uPhyiXVzxTFYdyeRVJirG2dpZGYx3DqFAuL2AYZSKRAWKxcTStQLNZwrabWJZJJDLIwsLLlMvzrK9PeSWiMKFQL+n0EYaH76S39w7K5UWvieowpdK8t2hoEAikSaVkQqEU6fQhHAdEUaJUWkCWRUyzSm/vMcrlFUyzTi43hSvdqWEYFQTBJhYbQVGiyHKYQCDF6OjDXLz4LKXSArncRRQlSDCYolxewXFMLEsjHB5naWkNEFGUIAMD99HffyeBQALHcRuuOtGuMR0O95DNTtJo5OjtPbapWctHONxDOn2YZHJDLyEc7kFVIxQKl6nVVpmaWuLQob9BMjm2abv5+ZcpFuc5c+Yp7r331zc9vofbBx8oQrZt06sZO6TTBygW55Ek1RMPuIwguKvlcLiHM2e+wZtv/gtqtRzuaZBIp48Riw2STo9y4cJfUK9fnXnEjUJ7RAS0/l5aetB7hkvIR48+s2uP4w1icTE9/flWGtV3WLoVsJ370/s1b7x1ztjuSrDusX+nVT+GrR3U3/nO1zr25euMW1y69LktUfaVHMJ8bH3Ox7chZJt6/TySlMSVfpVxHBnbbiBJCrIco15fRZaTKEoIWY4QCISpVlc8w5aHvTTunV49FnK580SjfdTrru+yaTaIRvcRjfYjSQKCINJo5FldfYfBwXuIRl1v8lotQ6ORo9Eo0tc3hKJEcJwGCws/RlHCLC7+mOXlU0SjwwQCYfL5y+h6jZ6eY5im0ZLGdbvF9xMO92FZLgE7jo1p6lQqaxhGg1Col0ikF8ex0bQS8fg4icQQ9XqOvr4j1GpZCoVpGo2yF1laGIbv4CYxMHAPoih6RjUNensnGBl5kDvu+Dy53LRnPJNrkWz7dEc+P41tmzgO1OvriKKEaWqsrJzeoiIoinJXovZ7XkqlBQSBlquVD1GUmZj4NPW6a+ixuPhjT3v8FvlR72HXuC0JebvUT72eQxDwTNEv02iUeOed/0hf3x2Ewz2kUgcZG/somlbkzTf/LbVaEUlS6O09hiwHicdH6O11hev7+o4zN1cHrk0MpB27kV/00RkRAZv+di/iIm4Ka/CKZOyT2dzcJ9hcg7avKh18LaTY/l7bu7o7o/ROdKbZ30/xj86IfWLiae655+scPvwM3//+1zYRYSJxifHxjUa4ztTyxIQ/s+x/DgI+KR88+F0ymQ0zEUWp8+yzX2vJcu5UVthN6aEdllVEEMI4joZlCchyimAw7lkuqkAd0wwRj48hCAK53CSl0jzgNhwNDNztpXlrSFIe23Y4cOBTzM+/SCAQJx4fRdNyVCorWFYDUUywtnYOVY1z333/LbIc4+zZ/0SxuIAoyuh6nd7eo6ytnaNQuMzi4hvYtkG16pK2osSoVDI0GiVkOYwgCJ7HM1Qqq5hmnWTyIJrWwLYNQMG2a4TDvViWK5bR13cn2ew5yuVlBEFAFAXC4X4sq8nk5NMUCnPePG8fzWYR27ZwHJtAIMbCwove/iv09Bwknb6Dnp5DXnd0DsvSqdWyrSYsd8RyFV2v0dd3mMuXf0SxOE8olGB4+MPU6+ssLLxCPL6/VX/20e3aFg730Nt7lGRyjGaz0pIFboeqRrn33l9jcvIZGo082exkS6lwD7cPbitC9r+shlFjaemUN6J0oqVu4zd0ZTLnKBQuce7cN7wf+Rz33/8/MDBwAtPUePbZv8/y8ttIkkAw2EsqNY5lGShKCMNwTSTcTtEU1er1EfLVzuW2RzvtadLNF3EAgaWlh/nBD36PT37yt3c8hs0CFj7Eq9aIvlpS7nyvfle3j/Yo/VZFZ1q/vVt6u/S6j85zNT7ulh9OnfoSFy9+wdOxljh58qsMD7/BxITbpT00dHaTF3bnfHknrtzotRWO43/2OooSQpKCJJOD1Ot5FCVEOJzANHVEMYggBFBV1Uv7VpmbewEQCQSimGYTx5FYWzvTaiqSJBldr1Cp+PXOANXqCgsLr5JIDJPNnsa2LQKBEMnkBKFQglot56W2dRqNGqFQjzeeqCBJMvG4K/6hqnFP2KTukWENUVRoNAqUStNYlo6qRsjnL6CqEdLpY1hWHU1bxzDKNBoFTNONOBuNPOXyAuB40eogihJhcXEeTaujqkFqtQyaVqRQmEUUFRzHJJ0eRRQlLl78S0yzQjw+Tjw+7EXL69Rq62Sz7+I4DpXKAouLb5DPzxIOp0gmDxEOp1GUmDf5kWg1b4mi3NVOdrvIuROyHGR4+H5mZ3/UMszZw+2F24aQfQUdw6ixuPgm+fw0pdI8KyunGRy8GwBZDjA5+R0ajTyFwgyG0UTT1tC0Aq+99s9oNMpUKjNcuvR9bFvzUlnuyEc8PsjAwAl0vUGttsbc3EvU64vv+fvs1sS1fUOXw9TU565IyLBBLK+88g9YWXmYdo3ou+7aHSFuR8Y71XfbSXmrAtnVRenvFw4ffmbTOfLPw7WIl4yPP9OqDbcLhrRrXotie0OYxdTU53jssd/dkWj9aNzVQP9aqwHsSggEkth2g3B4nHA4jWXVsSyLQmEeTati2waRSBrbtqjX84RCvQSDEXS9QbW6giCoFArvoutVFCWCogTQtBy6rnszv0ECgRjV6gqaluOdd57y3KOKJJO+CYLoRbJ9KEoCWXYJPRYbZH19knh82JOW7EGWFSBCNnsRy6pRrxcoFucJBpPk81Pe7PIUsqySTE7Q3z9BJjPJ2tpZVDVFJNLANDWKxQUA4vH9jI09Riw2gqYVWF09TbNZxjQNTLNJIjFAIJAkEIggCJBOH0VREtTrBQqFeVZWXuX48SdZXPwxx479LIFAzBNXGeXSpRfo7z+OplUxTZ1gMEGzWaBez5NMjhKP70PTSpsIuJud7G7gpsdnmJn5HvZWr5E93Ca4bQjZl40rFhcoleYplxexbRNZVlDVGNHoAO+++2dcvPg0+fwMgUCcRqPobW1QLl/izTf/NbKsIAgqfX1HGR5+kGbTFQ8JBmNUqzkWF12nmnp9DTcqVb19XGnWc3vYNp75+5XRGe0AHQ1dfqTs1pEPH/7urvbrOC6BzM19gtXVB1pp0KWlx3ZFyDen01rcFFVeTQOYIHBDG+6u9NrtC4v25+7Uxb4T2ue8O1PfGzrkbgS9unrvDhaMG+im4nXs2Ld2PA7DMNB1jXx+BlmOEI2OUCzOeXO+dWQ5jG1DKjVGs1klHI6jKDHCYYFstuTpXbsKUooSRtcbiKLrmyzLAQxDZH39PLGYu996vUS9nsEwGqysFCkWF1vuS8Fgmnh8ENt2iEaHWF8/Rzw+imUZBAJxr7krgGHUMU2TWm0d27a9kawems0GluV4jVgG5fI8sVgfmcxZstmzKEoYUZRoNiuYpkazWcGyNERRxnFMSqV5dL1GMJjEcWqYZsXrqA6iKCqp1AF6eibQtCyqGsUwCti2yfT0M0Sjg57P88eQJJn5+dcpFqdxHJvR0ZMMDd1HLncRyzKYn3+JWGwf6fShVuTrE/C1WkBWqxneeecpVlZOEY+PMD7+6FXvYw/vP24bQt7wMw6RybxDb+9hUil3xCGZ3MfKyilEUUHT8jQaZdw5yDRu84oJWDQaOQKBBAcO3MuBAz+DYVTJZN6m2Vzi4sW/QlFkGo28pwcsARFPZnD5mo87GHSdntpvXwnb6Rn79onl8gj5/ASHD393V9ExuARm21vTrLvt0L4RGBg4s0mB7OTJr24iszNnHmdp6ROMjHQXBGlHIHBja8vXsq8b0WwWDG7Uljt1yJ9//ndYXb2X7SwYO8ehtjZ3PbItIW9s+wJ33vkcshzEcZqUywUUJUq9nsVxHDStiCCEiET8OrOAZTWJxw8RDm9oJi8uJmg0CoiigGXpGIbuyVPqBAJpTFOnUJjHcZqEQj04joiiOFiWQ7NZRhRFFCVEqbRIMjlKs1kmFttPPj+N41gYRoNGI0+pNMuxY79MLjeJLAcQBBlJEimXcwiCSCKxj1AoxfT092k2i8zMfB9BcNC0EooSRpZDNJtFDENDFBWq1RUajUJrLlnXi54gygj1egEwCAQSNBplQqECzWaFcHiCVGof+/c/zFtv/ZH3PjUGBu5siREFAmFP42CRZHIc224iyyEvbZ7HNJusrLyFqkZvmLtUIjFGo7HO4OADN0Xicw83H7cNIfsrR9s22b//I+h6lYmJT2GaTUxT81R5NPr67kHXNXp772B29iWgCcRIpUY9RZ8EBw58EklyqNXcmlWxOIWulwAZSYoCYVxRexXDcLu2rweRyHW/feDqZRbbYdsbUbKfZj10aHf1xuslHb+Zy62LbtRNP/5xdzExNfU4r7zyD1lZech7/MqCINdzTJLkKo3drGaxnQwvui3I/KzIqVNfwu8R2EmOE7pFw0/surmrc9tf+ZVf5aMfvUixOIumNZBlWlrUYBOJhAEJXa9TrS7T03MMTcsSCqWJRHoZGnItDd1GphKCEMI036bRKHlmCA0kKYhp1gG7JdrjzhMLKEqAcDiBKAaQJJlKZc0jdhNdL7O+PoUkRZFlkUhkgEplHkkKIYpVUqkD2HYTQagQDg8wMfEZIpF+Llz4c0qlFRzHAWzCYTd9nk67zVil0jyqGiIW20e9nkcQBFQ1iKIMEg6nCQQSaFoRTStSqayj63l0XSOTOcPhwz+LJD1GPL6PwcF7eOed/0hPzyEUxf2hh0IpRkc/SrNZY3X1bWZnn0MURYLBNL29d9Dff4Jms0oyOX7VqentEI0O0N9/jEYjiywraFppTyDkNsRtQ8g+wuEeFCVINNqHaTZbJJ3NTlIuL9Fo5IlG+0mnD7C6eoZGY4FIpIe77/5VwGZ09GFUNUqlkuXUqT9gefl1wMAdezpAb+9RFhffol5fxjQ1tnrM3p4QxY0U7/sx6uR2Vtue+YKFabpiJp3jWP7jN7O23E3280oQOmSib0YK32302mwEsl2zVrdxKN/M4krNXZ3bXr78MHfe+ZdIkoKuN5GkFKFQBF3XkWWBRGKcUKiHanWJfP4ytm0RjfZhWRaBQALTtCkUZrw08jKOA7Zte9rWCXS9hK4XWvKcpmli2zqCoCCKrkVipbJOs1lCluPIsogoBggGY+h6zduXSSp1xHNDqqMoCsnkAXp6DtNsVrGshidMonvbGDiOiatYFkBVgy2Xt2AwgSCMkkjsR5KCuE1dMWq1HKKokEiMIctBDMOgUrmIrjewbYtaLYMkOR4pfxaAbPYiKys/IRzu9TIEMppWIBhMMTHxN0gmRzGMBuXyCqFQmv7+o0Sjg13dnK4HrpVkEFGUMIyra9bcw62D24aQXQOIJXK5aQKBKJIU2FR3CYd7MM06tt3wGlAKDA/fg2mWCYUGWFx8hWp1Gdt2iMWGOHv2P7G8/Bo+4abThxkbe4xGY41IpBfLqmGaJpbl0Omec7vCtjf7Mr8XkCQ3Ipue/nzrPseRWh3eW8exHBxH6uowdaNwLYQZCFzf9u3bdlsIbTdvvF1WZLtouF09rP32TtuOjf0Qw8hhGCog0WwWEQQHVVURRZFIpJ+BgbtZWChSrWYpFGYxjBrR6CCm2WB19U1qtRyNxhq6XsOyBKrVOVQ1iiCInlJWmVCoz7NKFLBtB9u2qdVyHpm6xGjbTXRdJBwO4zgiPT2HicUGCIeHSSYPUK9nqNUKKErMs4MsEA73EwodIp+fYWXlNCAQCCRxsw0ioqiQSh2iWs1imnUsyySZPIAoyhSLlzGMBqZZwzQtZFmmWJzDtk3W1y9Sr7uqXJpWAwwsy8ayDNbXp+ntPcLa2lvUalmy2Qs4jtmaOTZNjXJ5gcHBewDI56dJJPaj6/WWHeyNRl/fMWzbvZ7dqMh7D+8tbhtCLhbneOutP8C2LcbHP8bw8IcAWiMDAwMnGBl5CEUJoSghRDGA272p4Tg2a2uT1GoZVlZeY20twOLi24CJKIYZHr6faHQIx4FGo8jQ0H0Igkg2O8X1NHPdKHTWCq8F29kl3kz4UWW3GehLlz7H8PAbXcaxhC215d1Ckm6ekte16E5faV/t+9sp3dzt898uet6NstfGtj/F0aPnOHDgL9oeFTzdZ4V4fD+SpBCNDjA7e5q1tWUkSSYUClGprCEIoKoRLMvt0UinD5PPX6JeL3qL2SqWhaeQJSEIItCDYdjE4yNUKotoWtZzXUq15DMlya2/BoNRAoEk8fgYoiihaesUClOoahJdr1GprFAqLTE8fB+CIFOpLHlkCo1GFrdcpSAIARqNdUKhNKqa9FTDDNbX323VsC3LlRoNBIapVrNYloZlmYiiiiAEgQr+4r1YnKNYnCGTedurH1tUKkssL59mdPQk+fxFotFhL6rOtuaGa7UsgiBQKMy2fhs3qn4M7thTKJRiZuavqNfXOHDgp/bEQW4z3DaEnMtNUyrNejOSbqrHHczfGBk4fvwL9PUdIxRKEQwmuHDhz3Gch6hWV1hbm0bXy6yuniUU6gWaqGoP4+OPMjh4L9VqBl1vYFkGlqUTDCaRZTCM93eGoNsFFrgmgn6v1bj8xqtKZZjNphgimcx9fPObT3P06J949200evm15avFeyGreaPrzn7EfC0E2y163q1hyMa2UdxIUgYURFH1PMJFms0iAwN38+abp7h48WVU1aLRkDh2rIdYLISmhQGBtbVzOI5FoTCHYdQQRRlVTaKqqic/aREMpgCH9fUZVDWKrpfRtDqGYXgp7ByW1SQUShCLuS5M5fIS4bAF5CgWLyGKKrKsoCguCWqa2/ehaSUSiYM0m2UMw0TX82wspB1EUUIQFBxHRxAcCoUZL0Ve9J7T9P6PMjx8P8nkBOXyZRxHAATC4SSWZaHrq4BMKjWOaeooSpQTJ55kdfUt6vUqp079O3S9SjZ7lkikn1Con56eCSKRPs/gAgRB8jq1Szclii0UZlldPc3KylvYNgwN3XNdxhd7eG9x23xKqdQ4/f130dt7lL6+Y1SrmZZ+7EYHdrClTlOtZhAEmXJ5nlJpFtMsAybV6hy6rtPXdxf79p1kZOQhoEk6fRBBkLl8+YfYtkO5vOIZvr832C567bzAbohKbB8B3WhcbTdx+1jQCy/8Hhcu/BIb+ts+3NGtCxd+qdXo5b7P7Y0yPui4WoLtJrF6ZWUvBbdnwkcVUYzjOCKydzVwjRjq6HoaSVrmzJnXSSYtZFnCMGyWl9eYmDjMwYOfYn39XWq1rBcpNqnXC8hyhFRqH7pu4Dg2giASDvdQqSxjGA1s20bXHUyziSzLuFG55XVwW4RC/YiigOPY5PNTmGbdc54KE4sNoes1yuVFz5FNIJebJhRKU69XPdJshwk0sW0HVY17pa8Vr4nTlcZsPxem2UCWZcLhAarVDMWiSbX6DoIQwHXSarK+foFKZQmweeSR/5WHHvoKr7/+L6lU1pibe5FCYcbLtN2FrpeIxVyNA2i3Trw5q+P9+x8il5umWLzEpUvfRxAELwN44yLxPdw83JKE3E0+TlWjDA7egyBI1Os5rwN0a8rH3zYYTNDTc4jFxVdpNmvE4yM0GmVMs4wkOQwP38PIyIcolaYJhXoJh9MYRg3TbLK8/BaWZWLbIaB609/vTmpenanMtbW7cF14rs4y8VqO5Vojap8oBKHGq6+2m2F0wjXI2CBjl0A6X/f9lM68Ebie8ajtUtnbSax2KnsBHUIhxpbXsO0yoGJZKoIQRlFcjetQKECptEIgYOA4QSxLIBo1UFUT09So11cBCds2iMUGqdXyyHIdQTA92Uy3KVKWY4TDvdRqGcD2Zq0VLEvH7bIOoihBoICmVVhcfL2lYlUuL+GqygVpNCo0mxUcR/K8k933UqtlWVp6k3p9qes5dBzFM5zREQQ3E+COQ0I4nPLeh7v4Xl5+C13XiUbTjIw8xNra/w8wvQYxF81mE9vWKJXmEQSB8fGTnDv3J6yuLuIqmMVwHNuze0zTaOTRtNJ7QoquhOav8uqr/4picZp6vbBXT76NcEsScr2eo1pd3VR/ATfdo2kFGo0CkYhrqeiOPJW6Ss8NDd2LrpexLIN4fB/33/+3eOed/0QyOUY0Ooym5XEcB9NssLZ2jsXF18lmz3nyfyFuhI719aJ9JObixS9QKo3jGxJcyxzxToR7tTKf3dBuuLCTh7MLN0I5efKrmGaY0dHnW1rQ15Nev5m15GvB9Swotktlby+x6nDq1JcZGXmjJSbjk7ZL1JFtSh0ykiR587MWgUDUS7MaqKrN+rqALAeIRhteF3WDubk3EAQLsKnVioRCcQKBMLpexzSb2LaALDvYNpRKc6hqGEkKIEkhdL2AZTmoqkggkCIQCGJZYJoZDKNOubyAoqjefmwMQ8O2XYIXxSiCIHnv18K2LUyziXs529rzIUkSkcgQhcIkpml7jU8GINNs1rzt3C+MrudYWTnN0NDdrK3NYJrdFuQ1DEPFNHWWl8+QzU6ytnbGUy9b87J0DqOjH8dxGhSLc+zb92CX/dwc6HqNZHIflcoCPT3je+nq2wi3xCfVGRH7w/WOY3qG465TSjAY8y4WbodlsThLrZZFkuSWx3EwmGgRdbE4R6Ew50XTFsFglEce+V8pFufQtBKmqSGKrhvUysppGo0qwWAv4XAf2ewM78XI004X6/aUZDp9eZOc4sDA6SvKKV7pta6VcNs9fDux2R3JtYfcHtvXjDuVsa6G1BTl1iLkq0G3BVO3VPZGatrNMGxAoFYb4uLFz3Px4ue9x93ntZPzk0/+IseOfQd3LAhcQ4k4hpFBkgKYZgNFiSDLEmNjvTQaRWxbR1FgaCiJKEroeo5odD+WZXtRtYRta15X8wDu7HKNRiOHplWQZZVAIEKjUaTZ1JAkCUEIoGnr1Go6sqwSDKYxjCq2baNpNW8e2cBxmvhka9tF3EuXjKukp3nKem2t8G2wLMPrANcAfyRIAXSvLLWZxB2nwfLySzt8SiZgMj//MgMDd2MYZc8/ukE+fxFZFhkZeZhAIEiplPe8ln/IsWNPvCfkGAwmCAbTDAzcTSSyl6q+nXBLEHJ7VOs7prQ3Ppimxvr6FLrewHGaSJJEKNTTEhiIRPoAqFZXqVRWsG2TtbV3WVs748nsNbBtAVFUMYwm8fgQipKgWJz2zMd1ms0qplklEkl6BH7zU9XbQRC2piQfffSrm2qDV0vGNwKdfr7dxDs6lcBkuYJpbid0b7fmkbvhWiPL9yrFfaNtIXe7YJqcfNyTUXXJOJ2+QD5/mK2ZCMcja9v7v73U8SjHjv0VG4QMjuOmkC2rjiAEcZwgoBKNRjh5cj+mGcGyVpBlaDTWcZwwguDWnJtNdwVkGCaqqqCqcUyz7I0CWUiSgmlqOI6AZdmAjaKEkSSHarWC42joukAisR/HCeI4JqapI0nu+JNpdmarXIlR95+N25jVpBtMs0C5bLM5Xe//3W3ltjmt39//AMeP/yK2bXL+/DfIZk97j2icOvUfePLJp8jlpllcPIWmFahWV2k0CmQy54hGRxBFqaXH/V6krTWthCTJOI5DLjdNPD6y1219m+CWIOR2QXWfnP2IF9zOQU3LU6mskEiMUa8XGBy8B00rYlk6udwUQ0P3ks1OUq+vY5o6CwsvY5oa4fAABw9+kr6+O8jlLlKr5Vu14kJhhkikn3A4iSC4s5G12jqJxD7y+cn3/Dz40efExHMdzTyuwcCVXH+uF1cajWqPfgXB7CrecfjwRopVEOqcOvU/Ym6baBBZXv4wX//6Tzh06C+uubt6J+ykmnWj9v9e17jdGWM/++CQzx/d5pmddfvOWn0ITSu2PW4AKoIgI8tRbNsiFIogSVHC4X40LY8g9HvGLQ0cp+AJfeitESjHKaPrNQqFixhGg2AwQSjU67m0NXEcEEUFQRAxTRNZTqAoqjeXa1MqraEoMqIYRtPWkeWkV+PuBqvLe+wGB/BT0z7Zqux2pHFg4Djp9BjLyz/GthXcznR3wW5ZBf74j3+ZdPowjmMATfL5CyQSowwM3ImiqCSThxEEGdPUNl3XbhbC4R4kSWVp6Q0WF99AVSOMjT1yU19zDzcGtwQh+2nqej2HqkY8P9EVJMk9vJ6eCcrlJQRBpVxeQpJklpZihEIJ5uZewXEElpdPkUodolZzFX+CwQSWFSQe38/w8AOEQilyuSlkWaFaLWEYbqemphWIRAY9H1gd25bI5eboJpcpy4OY5jo3I5XdGX1uRMQbBgOrqx+6rq7q3cwid7vP3+ZKdoM+xsefwTDwFLh2GhuzWFp6FHBYW7sf4IaT8o2cH74ebGdecS3H5Td6udhKSJLUwLLcOXzfP1sQTI4c+Q6p1CXGx5/n7rvfQJbjuJcA//vspm8dR0HTMoCrbCXLSQqFWRxHQZZlTNPAFfFwI990epxgMOnN9l4kEBC8mq9LvrHYEIoSxjAmCYV6iMf7yecXgCaO00QUQ0DeO4YqhhH0vmNuSllRQjSbOi6Ztv8ufcm1rY1qW2Hg1p+TyLKKbdte1H3l2kYuN02l8u+Ynf0B3a4Ltp1nff2NtsccLl/+HobR4MEH/xeKxXmazTLp9IEt/sc3A67gyQJLS29iGA1GRx/eI+TbBLcEIYObti6XFygW5z0R9ponyu6uKPv6jrG4+BqXLz9HJDJALDbM/PzL2LbN2tpp6vV1LEskGk17F4kJksnDyLLSkpWLRgfI5y8hSQFPvECnVstRr1cIh3s9LVqHQmFuy/HJch/xeD+1mkizee1mE9uhM/o0jDBPPvnEFQ0GrhbXQ0xXYze4uZYMG53W7f9Lm25fuvS5mxIlw82JYv2U8k4LnU5byvbHOgU/divecuzYMwwPv87y8kNdH5flBpYV8m65hO04Mvfd9/XWd8e2U+h6GfcSILA5havg11ibzSLNZtZ7LIKi9GDbDrKcJhCIeX0bSQKBZMsyURAc+vqOMz//CqbZpFxeIhiMeqnnGpHIALpepVRawbbrbHwXLNzI1UEURSxLRJIiXnOXX+8Vvef4f1+NcI+DbRvousHu1fdCGIZGobDATpr2kcgxHKdBvT7bum9x8UVWVs57BhwWg4P3c+KERU/Podb16EZFy+19OKbpunfpehVBkNH1xpV3sIdbArcMIYfDPWQyZ6nX1z23ld6WLqwoylhWk/n5V8jlXBPy5eWfUK9nMYwaxeIS+fyM1+gVIR7fh6K45uSBQIRAIOaZlk/j1i2biCKIooRpakhSmWBwEEGwaDabNJtrHUcneA0as1hW5aa8/24uTFcyGLgZuBIh7NZusPP9TEx8m76+s94YVHvntdD6/+DB3VlJvhfY7ehVOyl3e6zb38Hg9oIfV9qP//jHPvaPeOopPwOxuXbcbCa9v/zHbI4ceXrTQm5rTbYdDi7R+fVZF4oSQJLAtjUkCUzTJJdbo1i8RCTSR1/fcSyr6Yl6rBAOp8jlLntKXgKiaFOvl5ibe8kjc8GbL44QCKQQhADBYJJ6fQldrwKSpx8QwbJsRDGMKIaQJLtN1MOP7n1CvxKuVrKyQTb7LorS27pHlnvo77+D1dVz2LZ7HjVtkX37PophHGB5+bnWcy1rnbW1Am4W6DTT039ONDpIPD7I3Xf/Cnfc8fkbUt8tFueYnn6WRqPM+vq7lMvzRCL99PQcZGLiU9e9/z28N7glCNlf3SUS+yiX5xgcPIHjOKRS454/aYJLl57HcRxkOUwgkCSRmKCn5xDVagHLMnEcC02rMjJyP8nkAYLBGIZRIhxOkM/PMDX1l1QqGSKRPiSpTrW6gijKxOPDhEJJGo0iq6tnMU1fMKAdCer1Eo6zXS3r2uFHRX70ubS0ebylmxPQzcJ2TUXXUifdLpoeHn6D73//a5RK7fZwDkNDr9+06Phm42rT0Jq2e0Wt7T4T/3sxM+PacW4WX3FJ2E1VuyWP++//+hXfx5UkWhXFzT5JUgRBcA0gLKuGZdUAEUmaIRzuo1S6jGHU0PUqoih5pgcihgGgoWmunaIgiNg22LblTVg43uxyALdGK3ja1jUkKUYwmMBxBK8BtLNs5L/nG2iS3YKGYSy6ryKm+ehH/184jsby8tnWMyyrwtzcs6RSR3j00X/CK6/8X1iWv+ixEIQojmNRr69Qr6+SzSqUSovMz7+EqkY8FTKVD33o/0E0OnhVR1evr/P003+LubkfAjEUBa935tPcf/+v0du7XY/BHm41vG+E3C7gkc1OemNONonEGM1mhXJ5AdPUGBg4QSZzlnJ5iXT6IPH4CKIoous5Dh78PIFAjP37H2Bu7kVyufPEYsOMjX2EaLS/5aqSyZwjkzmNrte8C4mCaTYIBFwd3mazzPr6TMsebjOCBIMRNK276MCNgH8Bv+uuZ7jrru7RZzcnoBuF3ZDttZIy+FrWG9H1D3/4TzueKSCKu6kD3h7YzXnarVViN5w5szF69slPfgWAqak/4u23v8T09BfaRqHc/x999KscO+bOd7t13a2LhsnJn+epp77ZRQHOJzqo1y8DCWTZ8VTyZJrNELatoeslCgXHKzEFvaYvG1kOIkkK+fwMbhe0QCDgdk7rehG/bGEYder1dQRBRlUjxGL70fUGzWYOf3ERCMRpNitsjC614735/ti2TiLRx7vvPg0UAYjHj2PbFarVBQqFi7z00v/BkSOf4dKl5zEMtzbuOHVEMY4kJbymKwvLajA19R1vrEtEVWMsLr7B8PADCIJEMjnCsWNfIBhM7nhMk5NPMzf3A+9WGdtOEo0OcP/9v8bw8If25pBvI7xvn5Qv/pHNnseydMrlJeLxESKRAc8pZQnDaJDJvIMgCBSLU8hygFhshGAwycDAcWzbJB4fIZ0+xPDw/bzyytdwHIuZmb/iwIFPMDz8odYccyIxjq5XsG0Lw6gTDPaQzZ7BNA00LY9ldftBC54N2/tbg9ltNHUtuJkdwt3GpJaXH6RQ2Lpiz2bvunkHch24WednJ2vFnbDd6JmiQG/vZVT1T5idfYx6vRc/jWsY4db7cBy3pn3mzOMsLX2C8fFXOHbsGebnP7PpO7aw8FmOH38OWY5gWboX7VlAHtNUqFQMAoFoy13IdULKkc/XEEUVRVERBAVZVnAc0dOFlgCFZHKcYnEZt1YcIh7fR71eQBSDgE08PoosqxQKcwiCjOMo2LZBubzkCYC8n6jy5ptf9xrbXITDcfr7H+Gdd/4T0MBxaly48KeoapqNVLqNbRex7QC6LjI29lMMDd3juU/VEUWVtbUzlMuLvPPOHyAIEsFgH5cvv8DAwL04jsW+fQ8wMvLglhT3sWNP8L3v9XiLF0gkRvjYx/7BHhnfhnjfPi1X23YFy9IJhdL09h71NF7dho/19YveeEUNUQygqglP5UchGu1H00o0GkVkOejpxAqcOPFLni+yG13Pzb3sCboL9PUdIxhMMD39A4LBXlKpQ1hWk1JpoTWjXKtZ2Hb7D17CNF1RkfcT1xNNXS+uhZD88a1i8eCWMam5ucfoJqXpyineWtjpvV9pnGo3GYXtrBV32k+30TPwO9o3RqHaG+fK5ZHWZyLLNdbX72J6+vOtaPhXfuWXOHToZV555f/Z2vfhw28hSWFPsc7sEFoxcBwLXVcRBBFnU5ZYx7bdXgxBCCBJKqoqEwolEQSo1XIUCrOEQmmazRyxWC+yHCAQiAIWsqxSr69gWQ6alvXek+M1hFXZ6Kx+/9ApGrK6+hqrq6+13eNmFVyTi43bEAZMGo1lJie/Qb2+wsc+9v9mbOwRZDlIvb7OqVP/CcOoYBgN8vlJ1tfPs7T0BpIUZn7+R/T330043A9YTEz8DV5++SgvvNDLiRM/Ym3tExhG1avTv8jBg5/YI+TbDO/bpyWKMpFIH41GzqvljgBu5FwqLbTNOto4jsPq6mkCgRhjY5/AsixiscFWndk3mjBNjd7eo6TTB1hc/Anl8iL9/SeIRHooFAoUi0Xq9SyyHEQQ8NS8ZtH1EsFgH6oa9HxP/bR1e/fn+4drjaauhO0I43pma7dKZ4IvSCHLdQ4d+gtvxGkzKTebvbzwwu+9Z3XkK73HqzXT6FbrvVps11DX/vfExNbRs60d7cKm/+fmHuXdd3+JDcLekNoUBJPLlx/hi1/8ZzjOf8PMzMOMjb3A+PgzOE4I2xa3yRDZ2HYe6CcQ6KHZ1PCtGx2nAkhIkogkiTQa66hqnEajADTQ9Tq6XkWSVGzbIRRKUK1mUJS4Z+yQQtMqmGYD0yx6x+s3qN0OpY3OstfG9SQQGEUU6ziOztLSGb75zS+zb989fPjD/yMHDjzGI4+442yuH/MFLl78K0RRoFxepFpdYm7uR2haCVkO88wzAv/n/3kcSXKwrOP803/6H5Ckv4NhVFhYeJWLF//iPVMH28ONwfv6SUWjA9RqWWq1NTKZs4RCKYrFWSQpQE/PERQlTCAQ49KlH3pWi3nC4TMMD38Ix3EYG3tkk8pXrZZlfv4lenqOYNs65fICoVAaTaswP/8jbNtCUcJeo0kA29Y9u0UBx3FaWsAbsHi/ydjHbqKpGwHhOvvGOiO4wcE3WVl5GEGwePXV3+Lkya9us+XNHXvqxK1mWLFbla72Zq7R0ec5e/ZXuXz5M1fQDRfaCNtpe46N48iMjf2ARqPGsWPfZWLij/EJRBRD2LbgKXhthzWaTT8ax1P3khGEIIKgomkVLMvBskoYRoWN35eNILiR89LSKc+8oUQolEIU+0km92GaTQwjQa22jLu4eP+9ya8PDSyrzMGDH8NxJNbXL1AuX2Zq6jlWVs4zPHwXqdRBPvKR/4V4fB/9/XfS338n4AYPS0tvkslMYlkalcoi3/nOMUTRwrIkJMlhZuZhPv7x+1ldfZts9hI//OHvIAgCR48+vkfKtwne10/Jj5KLxcs0GjnvXodYbIhU6gC6XuXChWcwTZ2+vjuR5QAnTvwitdo6AwMnWk1h4Oq3Xr78PHNzLwISw8P3EQ73EQjEKZUWEQQFRQkwNvZRNK1ONvsOul4nFhvGNDV0vUmzmeHmdGneetiOkALd5YB3jc5xp0gks8kE4d13n+yI5nwIJJPT1/fitwmudhb8Bz/4PaamfhpFqWEYEQ4f/gt+5me+wr/6V2dZX78T/zsbiSxTq+3bsv399/++J7W5ufP6yJGnuf9+dzbZskAQYvja0AC6biPLOqKoYtsRXELsFi23/2ZctS9FCbYc2VzJ2k7NaB3TNFhbewdf8EMUYziOG1UXiwvoep2zZx9jZuYh9u//PseO/enVnbhbEKa5xvnz/5VAYIjh4XtIp8colZaoVJa5fPmHzM29wuzsy+zf/2HGxh7lyJHPoapRZDnI2NgjLYEP09SYn7/EM89IXoQs8JnPxPnIR36PyclneffdP2Zt7TLf/vb/yPHj32Xfvoc5fvznr9ggtof3F4LjOFdkoHK5TCKRoFQqEY/Hb+gBuP6kSzQaBXp6JtD1GuGwq1M9OfkdisUFrwkrgiBInhxfknT6ELHYAOFwH9HoAOXyEi+//M9YWnqVWGyEQ4c+SyiUpF7PUqvlcRwL23a81b5DJnOGTGYS29ZwHBlNW8e23z/96t3iRtgj7qY2ej0R5NTU461xJ/Drm1fGxMSf8Tf/5s9d+wu/h7hWi8jdbjc15TZdlcvDXrp5s7BKMLiOpvVu2kYUNQ4f/rY3AuWS76OPfpWRkTc2zSwfPfpnm0RCNtDplQyimCQYjAEC9XoGt1M6wHa60QCC4HYRu37FbNnn9pCJxw9g2yGq1Xc2zWo7jvyeeH+/lwgE+kkmD5JO76dWy5FIjJDLTVMuz6PrDaLRfQwNnWBk5AHuuefXCId7t+zj6afh+efhscfgiSc27l9fn+SP/ugJKpVVLMsgGu3n3nu/xMc//r/t6Vq/D9gth77veQxfRUuSZHS9RjQ6gG2bzM297I1BOMRi/ViWQT4/jWk2CYVK9Pcfw7LMVu04m52kv/9uarUMIyMn6e+/g0ajhKaVsawm0egg+fwU1eoqgUCKWGyQ9fVL1OsZj6ivlYzfuxpz3Zv2EL2M4/XaFO6E66kjd4qHTEx8m+npx/ElHMPhLLXa0JbtarWrm7/shvdDW/paX3cnMt5ah99cF+4kYwDbDnDhwi9x8uRXcZwwilLHMCKcOvXlLVaN3YltK3EGAiFkOUyttsQGCe/c6ew4uR30y3eCSbk81bp1M6cLbh62LmpcuJ+jLEe9ujg0m3ny+Qb5/AUCAVfT++DBT9JorFOpZCiVFpiff5nFxbeZmfkBBw48xpEjP01Pz5FWCvqJJzYTsY/e3mP82q/9Bc8883fI56dpNBqcOfMNSqXLfOpTXyUe35pJ2cP7j/edkGGzuQS4jV2OY6EoAQ4e/ASG0cCymjiOzdraWWQ5wtraJOFwmkikj1oty9raWRYXX/c8XEXi8X3oeg1VjRGNDhGPj6DrDXS9iqIEqNVqWFbTUxFqT8Mp7L5eFWT3EnzXD7FbefAGwHE2asc3g+Tvuef3W129jiMTj893JeQbgfezNuz7MF9vlmFpqdPreLcfvADYzM9/ikgk49kvdpYHRC5c+AI/+MHv8clPblev39C3bjRKGIbeUtt6L0s6W6cLXn3PXvtq0F1QpdO8wq3fm2YTQYh5jW+mV1cPIssqa2uTFAqrpFIj9PUdJRgcRJJscrkL5PMz5HJzTE9/j337HmRk5AEOHvwUqhrd9rjS6Ql++Ze/xYUL3+P06X/H6urbnDv3HTKZM3zoQ/8Dd9/95F4K+xbD+56y7gbbNqlWXXF7X+/Vtk2Wlt5gdvZlUqkDNBo5gsEkY2OPoGlFnnvu/6BaXUYUJY4f/0XuuOPzVCorrKycRlHC1OsZms0GjmOgqknm51+gWFwklzuPZW1Ex/H4HZTL8+xOYi9E95razUH7Bd4n0ZuRtt4O/mt16jPvBt3T2Js7rW/FlPVO5/dqU/+7TVfPzm5O1bro1AJvR7f7NohcEEwSiVmKxYNsGE4IPProV8lk3Pnv++///R2izxAuoei4RG2z4Zx0c0naJbv26QIZNyv13swjq+owur69dv3VptUFIeZJAdfZ+h7SJJNpHAd0vUE43M/AwB3EYoMYRoNaLUM+fxnTrBONDtDXdyf79z+4K/GQanWVH/zgt7l8+Tk0rYwoRujpGWVs7BHuuutJ+vru2Gv8uonYLYfekoTcDbZtMjPzQzKZd4hGh4lGe4lE+hkYOMHMzA85d+4pdL3GxMTfYHT0UWQ5SKWyQqFwyevWrHkiHxqRSB9ra+8yP/8ilcoaxeICjiMSCkXo7z/K6up5ms2V9+V9Xgk3oobcbV+7wW6tDAXBbQ7rdqz+fVNTj/PKK/+AlZWH8QliZORFfu3XPnZ1B3WTsd053q262U7otg//3LUTEdCys3S1wP3xJVoNWjv7TtNmRuGT98Y+fGxPJn53tr8KixEMxmg2qzjO9j7Efx3w7LNf4/XXf6OVVn/ooX/B+PjzO0iQqshyEMcBSQpz9uxjXLr0YNtzXWOPWGw/0Wjam72WSCT209d3DE2rIIoihcIlarUMkhRmcPBu0umJbYVDfJimxszMc7z55r9hff28N4YWoLf3IPfd9+vcddeTO0bce7h2fOAIuVrNeO385+jtPUo8Pkpf3zFEUSaXu8jp039IIJBkYOBO+vqOkc9PUyhcxnV4sWk2KxhGk3J5DkkKoighFhZeoVCYx3FswuEoicQhIpE0S0unyOcvsX30+96m7m4WroeQd9p+JyJqT++9+eaXmZ7+/KbHT5786i2laX0zCbnbfq60zeTk47z11pdwHIGBgTOsrZ3gwoUvsDVK9m/7ndWb58I7yRjgyJE/41d+pVuGorNPQmm7LbI7O9L3trzzXqEzQn700a/y4ou/dYWIOURPz0FOnXqIf//vfx9RNLFtmV//9V/jwIFv4GYiJCQpRSSSpL//KI1GEcPQSCSGSaUOIQgKhlFH09apVJZoNjWSyRH6++8mmRyjv/8Ohobu70rOul7l3LnvMD//fQqFy5TLWQRBZHz8UR5++O9sqlHv4cbgtmnq2i3C4R76++/cpOjlp7Lr9TyKEqbRWGd19TQgEAolUNUYyeQYgUCMqam/BExs28QwcijKEJalIwgCguCuSPv6jmIYdQRBRJLCWJZN99X/7U/GO2E36Vb/vt0QU3tU7DcrvfbabzI09PqW57799pduKUK+EdiJdK8myzE5+TinTn25VRu+ePHzHDny7W1S2+1RsNWK4HxP5IsXf4Z8frOE6cYMegyXPN2UdDDYi67rLWcjl4DbzRzCdNeX3oA70wwu2ezkkX3zcCXzjGvZrlO0Z3eNaA1yuXPMzf1DRNHCtmUkyUHX/zc+9KE4MzPf81QM85TLOWq1HKnUKNPTX+D8+Xs5ePBH3HffKyQS+0gkRlHVPmRZpNHIMjf3I2ZnHeLxYdLpw6TTBxkd/Qip1MEWyapqlPvue5L77nuSanWVZ5/9Cmtr77Kw8DJra+9w4MDHueuuJ/eI+X3AbXO229W82lGtZryB+XcIBhPIssrq6tuMj3+UWGyQRGI/jUaBRGIfhqGh6zWvFjOLZdkoSgDTbFKv55AkFV2v4zgWgUAQTbOwbd+G7v3FblPVmubWdyXp2lLaV0sWO3n4dhJRp2hIJLK1LKBpyas74BuEbml293g2/r6a87lTY9e1NM75kVinypYgOK2/HUcmlZrhxImnGBl5g9nZx1CU+qaI7b77XNen1177e1tew31MRVVVHCeAYawDAppWZXMU7P8e/Aj8yqsy2y4BIUQxim3v3jVNEFwjCtf96dqxnd3ljdiuU7RntzK3/f1/jG3/MqJoYlkyTz55gp/92X9Nvb7O66//Gy5f/h5ra+/SbNZ46aWDPPXU/+5F01/g7//9f8nRo9+mVJonEhkgnT5ILLYPRUkTicQpleaYm/sR8/MvMzf3Ir29x+nvP8r4+GOb0tLR6CA/+7P/mrNnv8XFi0+zvj7JmTN/ysLCawwP308o1MP+/Q/tmArfw43DbUPInfAbv0qlBSqVVXTd7cQOh0cwjAqFwjyjoycBSKXGsW2TUsmd76tWswiCQDo9hmW5EnWm2SCXu4Bh1DHNCrquYdvFtld8/9LUnRf1eh3C4a3Pq9fxfJ43ttvpwr8TmV4NdvLw9TWUx8ae2yIacs89X2dh4WM0m+nWdrYdfk8lNCUJlF3KI/vnczvtar/Z7WaMorVHXi7sFsHed9/XW+SbydxFJnMXIyNvtCK2Rx/9KobhjkHNzn6CfP4g7V3cqdQlPvOZv9ciFV2vIAjB1utsNDgquL8Bk80pbBFBiHj7K3Ucud+xbQMGtr1TdLx1hNBxOiPv7caKdsa1jlB1bvfWW1/aMcq+GpnbzufWahJPPfXveP31Xj7xid/mv/vv/j5zcy/yox/9I374w59FENzUtiiavPPOAe69t5eBgWE0rUQmcwZdrxGJ9BMIBIjF9hMK7UMULUqlS1y8+DQLC70sLp4imRylr+9IK6UdDCZ54IH/nmPHPscbb/x/yWbPkcvNcO7cN5DlCJcv/4CRkYfYt+/DWwh9DzcWt00NuRPl8hILC69SrWZxHJNi8RKFwhwHD36KUCiNooSwLINkcj+S5MpPZTJnmJ9/EU0rY9sGjiOhKG5ULMsKQ0MPsLZ2nuXltyiVLmNZnReX9wedBGBZEIns/BwfN2tOeSd0S1E7jszExLfp6zuDaYZbHskvvPB7XqPS5i5i38XodsWVRp92qsd3+8w2IuQNHD/+J/ziLz657ePAtrXN9sfao76N9OwrHDv2NFtHdzo7nP3Udcgr8xTpNpfv7veTjI//oI2k/LGum5/CvlaRkc7toPt5u5HH6KaxJb797Y0Z4//8nzP86q8OtB7723/7N7nrrueJx0dIpdyynKIkKJXc66BpNr209SFM0wFsLKtKpbJCs1kmHt9PInGQgYE7SCT2MTBwdysCbje5qFSWKJfn0bQaqhqhv/9OEon9TEz8jb2U9lXgA9fU1QmfkGu1dVQ1QiZzjlxukkRijOPHP8/c3EsEgz3E40OIoko+f5FYbJxczvVeLpdnsW0D07RIJvcjywGazTLl8iL1eoFs9gJXqou9V9guIvNRq23WoG6fV94tIV9tc9GVjg/g+9//Gj/5yW9siupA3EK23/rWU5661AaGhl7j13/95O4P4hbEdqR8peY4X6XLj8Laa8edC5cnn3Sv2M8//7+zunovGzPLG01egmAyMPA2mcw9rUhvePhNLEvh8OHvtuaRu5PWs97+totKN2aWXXRGuSKTkz+zzX798Sm7Y/+d+7wx2DpCdXXb5fOHmJr6mdY5PHz4O6TTl6+6Jr113+5nPTv7iU0d24899of8x/94jH37HgZcVa7nnrO5775Fxsf/C+vrZ8jnp1vNXun0YVQ1hm3rCIJEsXiJanUdVY0Sj+8jEulH1zUCgQj1+gr5/CwAqdQYodAAQ0MnGBi4i0RitEW0ul5lZuZ5VlZ+Qjb7NuXyMrYtkk6PMTT0QNc0+B624gPX1NWJaHSA/ftPeqpeL1GvZ7EsHV2vsrJyDkUJEQ73MDHxaS5efBZNKyPLawSDcdbWznlG6EGgSqORw7KaNBolLKtJIBAlEAjTbN4ahBwMbqSj/dvtkLY2zG7BTqRwPXXOnZq6/BT1xkys2LIMbCfkEyf+aAshu36+HwxczeKms/HNj2w3osj2WWSLU6e+xMWLX0AQLDYLiPgrNMezU/wuq6sfapHi0tLDCILJ6uqHGBl5g2PHnrlCWlfBJcnO9bvIRpTcftt/rr3DfgO45B1iMyHfWDJuJ73PfvYr17zt+Pjz3qLIbZJzz/vV1aQ7991en3700a9u6gcYGPhTfv/3nyEeP4iq/iFTUw/xUz8l8sQTo8BX0LQiZ89+i/X1dykWp5mbewFBUEgmR4nFhkkk9tPbexzHMcnlpikULhEKxZHloySTE/z4xw9x/vwJjhx5gyNHniGTOU1f3xESiQkSiUHGxh5FVaPcccfPcvjwp1haepOVlXOsr5+lUlnalAZPpw+wf/9Dm5rH9nD1uG3PXHuTV6WywvLyTzynGJVgMISi9LN//8OoapSJiU+haQVCoTSVSoZIJE2tto4sh3AcAdOsIwgKoqhQr7uNLLIco9ks8V7bvW3X0dmtZuyjXWmrE9sR5s2U3fRx+PAzfPGLT/D2219ievoLmywDp6Ye5+23v9z27M1evtHorTUHfi3qW4ax+/q0j87Gt6mpz22pHW+Ie0gsLT3UmkUWBItwOEOtNkynwtfIyButemVnpOcT5Pa+20Hc30GQraOA7SltEVFUAWVT/0XnfhWlzrPPfs37jv8FNzMTda3NXNttu3mBJF5lTTqI+x3XAGvLQsU04zz55BeZnf3opij+jTfu5KmnTiKKJv/8n4t84xtlfuEX4q3ar2lqLCy8xsLCm5hmhWzWLc1JUoje3iPE46NEowMMDz9IsThDoTDFs8+e4J/+099AFG1s+26+9rVDnDx5hkLhMjMzzxIKxVlefovBwbvp7z9OIjHaMrfwo+Z8/iLl8hzZ7DssL7/G3NyPGBl5iERipEXme7g63LaE3I6BgRMUCjPk8/NIEtRqeYaHD7QI2zSbpNMHKRQuEw7HsawJFCVKLLaPSmUWTasQDPZQqSxTq+XI56e9kScZlyjemzGNa714hEK3np2gD1/XeneGExvp2KWlR9/T5q6bAcvaaPLabUmgs/HNj2w3INI+R1yrDdDu4PT4438bcAUrisUJ/Ej5xRf/Afv3v9o10lMUlxC7NyRJbIwqtZOx5HVMb3aAsu2tCnft+23v+na/47/AsWPfwY+mbzSuRw+727abrSzBb67bqZt6A+6XQBCSKEqA8fGXNy1UZLnC7OzHOHjwFU6ceAldd2e3/eOwbTe9/7u/+zqC8IecPPk/MTR0H7Ic5MCBxzhw4LFN5KxpGQqFGS5dOk8gkEIUJcLhQSKRQRYXf9ojYxFJsllY+AS/8RsnWVk5Tbm8Sj5/gUJhhlzuPIuLo6RSRxkYOMbAwN2tqNm2TYrFOVZWzrK8/Drl8hyTk98mFIqzsPDjvaj5GnDb1pDbUS4vMTn5HSqVJdLpw8iySjp9iKGhe1uzytVqhkplhXx+hlJpHtM0sCyNRqNAubxENNqHJIVYWvoxudw0htH0nKGavFeE3E3152pTbO2p7d1gt3XOnXC1i4Hvf/9rvPnm/8zmFGunNKRDIjHD3/k7h69u57cRtuvYnp3dqHWOjz/Df/2vf9ZmzuES7+YI2GJw8DSPPfa73vafYH7+I54y1wbaa7hLSw96xOju7+pSrjJuCttX8Nr9SNLW7/i/5rOf/U1u1gTD9ThGddsW2HTfkSN/1rKwvFoIQoKFhV9iZuYkoljmBz/4uy2RkF/+5V/ijju+iyg6nDv30/zxH//Jpm2ffPKL3Hvvq/T3H+bhh/9nDh/+6S1jSX4kW6ksUy7PUirNUa1miEQGuHDh5/mt3/oikmRjWeKmBjJ/28uXX6RYnCGfn6FezxEOp0mljnDu3Cf4yU9G+PSnI3zhC9Km51erK6ytvUO5vIhpaqTTE/T13UMs1teKtP86kvMHvoYMeKIgOWzbJBCIUa+73dTJ5BiSJFOv51oCIvH4CNHoAODqxBaLlwgG41QqS0hSiEzmXWRZxjQNJCmA45ieh+v7Kab//A7Pbq/bbSAc3rjId6aybdu93S29fT3p66t1OtqoLbejU6dZoFSaYGrq8du62/pa4M+1+ue005zj5Mmvks2eYHr6C7jfAalFxu02iy78v22PBK0tkd6VIsetZRSTa63zbv2O/4Cb+Ru7mjGk3W57rfvrhOOU2Lfv33L48Hd59tl/3BIJEUWbev1vkU5fpFCY5Y47vscdd3yX8+c/g1sWMFlc/DTHjn2H+fksKyvvMjBwnJ6eI9TrX+XHPx7gE5+AJ55wI1nYIOdM5jTl8hzj4/+Br3zlIrOzj/LIIwYf/egItr1ZPOTo0c9hmhorK6dZX79IPj/Fd74j8I/+0R1Iks2/+TcbRO4/vz1qXl8/R72eYWbmWRRFZXFxdEt9eg+bcVtHyNVqhno9SzCYolJZ4cKFP8dxHMbHH2Vg4AThcM+mCBlcPdfz5/+MZrPq1YttarUspZLbXW3bOs1mGV1vsDuDiRuLM2c2UrsTE88QCl3bfnyrxu0I2MeNqiNfrbb1xrjTTm5GNhMTT99yhhPdcC015p1mmjv39cILv8elS5/j4MHv8vGP/3ar+cs/f08++QQ/+tE/7IiK3cf273+RhYVHaTeV8D2SrxQ5bhclXoviVfs+bwSh3Y5IJO6kVJqmUwFwcvLneeqpb7bGmv7Lf6ly332vc+7cN8hkzvHyyxP8wR/8h9bjv/Vb/46jR7/F2toFNC2HYWjeZ/VfWqnob33LakWwPnyCLRaXWFt7i2LxMppWakWy25GlT7R/7++J/OEfjmFZIpLk8Hf/rsDXvtb9vfqvVS6vUq0uks/PUC4vEwrFSSQO0N9/J/H40KaRqw8qPvBjT7ARIQeDCbLZSYrFWWq1LCdO/MIm95NicY5Ll35IPD5CJNLP+voFlpdPUy7PI0kqpmmQzZ6l0chjmu7IgKYV2dxsIlKt2sheTuFmNER1Xpwdx41qO2eOr2Z/tt09hX29blHdXqsb/P1PTj7O9LQrEOJHvH5duVA41ErJdsOtpm/dDVdLyNt1ubfff+aMK6qiKDVefXVjhviLX3yCublPtEbKBMEikbjs1Yw3QxAsQqF1r2vdHUl6+OF/zmc/+5VdEWNnivnw4e+0uouvfRbXrY124lqlLW83HDv2yzQaGZaWfoxpVlr3+7PaJ05M8dM/XaO//04OHvwk9XqehYU3+au/ivLmm/2Mj7/IAw+cYnDwbiKRPrLZSSqVVf7gD/4bXn75v8dxZETR4ud+7jV+67emtnWD8qPmtbV3qNczlMurhEJxYrFRUqnxrvXfp5+Gz38eJMnBsoQtqe7t0E7Ofn1a04rE4/vo77+PSKSH/v5jH9iU9l8LQvZRrWYolxcpFudIJseIRgcRRRlVjVAozFKtZrhw4TvEYvsZG3uIYDDJ2bPfJJe7QCTST6WyiqblqdVyGEaJSiWPZeU3vUah4JJYMLj9+NH1opsAiGlCItF+7/Upht0IZa6dXJy6oVMgpHMOeSPaa8fmmvKtTsq7Tdvv9pxvFaRwG7kEwaK//zQHD37XI+luNWUf/n2bO9jbBUWu9jiOHPn2pg7tq+9z8C+2m1Pe11PrvVq838Q/Ofk4Kyu/wAMPLHHvvS8wO/vSJgtYFyrh8BB9fRPs2/cgvb1HOHjwUyws/ISVlZ9QLE5TLi9gGBap1H56eg7z8stH+J3f+W9bUfTf+lt/lwcffJt0eoLh4QdIJvd3nRnuJMu1tTNoWpF0eoKBgft5++2HOX36IJ/8pMwTT7ik/Pzz8NhjuyPjTvj15np9jVotQ7WaQddrRKN9DAx8CFlWP3Dk/NeKkG3bJJudxLKaOI6DppUIhZI0mxU0rUCptMLCwo+Q5QjhcJpk8iDl8iKalieZHOfSpR9iWRqG0aRWK1KpzNB5wajV8CzT3MjScbjmdPJ2aG/I8qNjgEhExL2QyYTDcer1OrCzHnC9vnGcO41MXS22S7HuREbtAiGCYPLAA/+CT35y80XcHYP6ErXaIFqsiP0AANmoSURBVCCwsvLQlv3cqupdN5KM/f1sPmcbY03t5Hvy5Fe5dOlzZDL30s29ycVmMm4XFLma5qZ2K8ibQZw3oqFxN7gexa6dSXyr7OduXv/LX/4NnnjCIpebJp+fpFpd7thPgGAwSTJ5kL6+wwwP38+JE7+EppW4dOkl1tZOUyjMUKtliET6uHTpl7lw4V7uuWeJhx56h2Jxinx+Cl2vE4+7xB2Pj2yrtNUZNb/wwjj/5J/85lVHxLuBbZuUy0uUSgusrr5DtbpCvZ4DIB7fRyIxTk/POLHYCPH4yG1Nzn8tmrp8iKJMX98x6vUchcJlMpm36es7wdjYR8hmJwEBx3mQYnGRWs2dM/7/s/feYXLc933/a8rO9n69od0Bh0oS7AUkKKpQlEhRzaKV2PlFspziWImjNBfFia3YT+JEcboTW7IdKTJlq5CiClUogVWsANEPuANwB+D6be877ffH7Gy7vYbCAt77ee65uy0zs7O78/5+2vsdCAywYcOdZDLzGIZKInGBcjlLuZykVcOKLb5hL1+Wq8teKuxt2kQsCDZBWxdgUZSRZR+yXEbTbJIuL9pOsVgjY0G4cjPHy800L4faKI81ZuNy5RelbG2itSPpVjh8+FNXjJAvpea73HYu9f561B9L8/jT7bd/gRMnHiGVGsSOhOfnd3HXXf+2kl1oZaloUCOKelLW1zT+02yecKWamuqxtobGS8eljEGtbhxxZTJutf/jxzfR3/85urvvYOvWD1SEjp4nnb5QiZpLFIuzzM3lSSbHmJ4+xvT065w+/SFOn34f99//cfbu/RkzM6+TyZxn48b/x8DA/yUc3ogs72Dz5ndx/PgDHD48wNDQS2zZ8jeMj6tMTr7MwMDduFx+tm59oJrSrhcCmZ5+na9+NVDtxJYkKzK+UoQsijKh0AZCoQ309t7E7OwxyuUs6fRkRYnxWWZmXsXr7aKtbTs+Xzt+f/fbnpyXwzXzqmxLxmRynEIhRT4/D1grvmIxSSo1jWlCLjeLIMCmTfuJRLYQi43R0bGLcrlALLa0EIjLVZOovJK113rY88Q26cuy1QxloQg4yOfjaJqdTl9MxtC4aDCM1Sl5XU0MDT3B7bd/odLEpfPss79TMT9ovKjVi2Is3+x1+bgSc9trIfW1lgpsURW7wW9o6Anm53dXCLnxcXakrKo+4vEhasIhIvv2fYHR0fczM3ND3e1Sdfb4UtK3NYJ2AQrWe3V56lqX0w29FqyG+JvPyeXMMq92/9PTLzA9/QKh0E62bNmPrgv8+McBXn99A/39P2Z4+FsUixmKxSwvvbSNr3zlYURR58tflnj88Q/xwQ9+gHj8DOPjPyceHyGROM3p09/h+PH38cUv/laFVG/mj/5oG8PD36FQiHPy5LdQFDeTky+zYcPdDZrWsuyiv/82Pv5xna99TaxGyPv3X/q5Xw6y7KK39yag1kA2P3+aYnGBWGyM8+efweFw43D4aGvbXmkG23XNNYO97Qm5vrGrWEzh8bThcvnJZKaYmHgew1CZnT2OaaokEmO43RFk2YHbHSGRGGdh4QTlchFF8SFJEqraKvXkACS83qvv5Vq7WC/W8zWMDIbRiqQkLBlCDShXI2ObmA2jRghvhtkEgKp6Gy5qZ87sX0TIjZG0hMs1T7HYjh3Ztbcfe1OOHWqd4s1YKxnb/6+WlHfvrp2jm26yxp/sxcp1132Z0dEHGxq+LFgR8b59X+C++z5f7aiuRcgGquq5LBUrUQwiCDK6nuZKSV02R+JXAysRf6tzcqnRe6vFTqv9Nz/utdeOc/r0J/ja1/4HkmTw/PN/n1/5lb/PwMD/wzCyjI7eXBUKEQSDf/2vNUDhoYe20da2rUFJ67HHdiOKOrouIUkGU1Pv4bOfvZ1z556lXM5y8aIVjR88+Of4/V2Ew9sIBDqrDV0PPyzz+ONw4IBwyTXjtUIUZSKRLRVjjCKzs8fQtCLJ5ASx2GnOn38Gj6edWGyMYLAPWXZdM+T8tifkfD5GPj9fcTFJVbr2dlMsJnG5gszNHcPlCpHJzOD1duD3D+DzdQAQCvVXxNg1dL1AJDJEInGBYjGDaSapRWgqNelAFeuCV29FdzVQX9qvnzlutSCoCUSAVTPOVSa2mlPrhcLSte8r0fC1FJpTsLZilw3bpnHbtq9XdK31Chnb6VaD+fldV/agVgG7Pmyaazs/SxH4ava11D6aFa8mJu4lmdzcsNBpZRoB0NPzElNTNZlN25rxUiM/y9N4ufYT++DfehJyyxF/q3Ny//2fW3P0vtxip37/rfSsVdVbtcjUdWsuWVH+PXfc0cX4+M/Yvv0YL75Y6y04ckTiQx+C//E/XuRXfmVXg5LWL/zCDE88IVXTzvv312aGAYaG3sPIyPcoFOaYnz/JhQtPAybT069Vx6Duv38fDz305swM10fOdlpb04qkUhfJZC4yM3MIpzPE5OSrdHfvedvXm9+eR10HlytILjeP0+mnVEpSKmXweqPYAhNtbVsBaG/fxvz8CTo6dpPNzjE1dZBweCMbN97DxMTz+P1pEomztLcPE4+fJZstUSNfS5/XugDZ0bNI8yzhlYQoBjAMW5JwpYuavWCowetduea7nMFEcxS32nnZpVCfgpVli0zs25u7sOtJuFYXFRkbe/gtI6e53Gu+XJGV5WBfyJstAW3hj2bTiPrHgnW+65WlLr1uuxwZ2++dUJHXtI0vNK7md+ZKYKloeK3RezOxHzzY2ke50edab2GRaXVMF4v/kvn5WXbu/AXe//5biUT+A3/91w9x8eIQpikhihqPP36ezZu/0WCP+Lf/dh+BABw4ILaMcF2uENdf/7ca5pPj8VNVQQ+Xy8f588/R3X3jIpvGNxr15FwfOc/OHiMeHyORGCMcHiIYHMDjCb8t681vnyNdAsViCkGw3qy2tu24XEFisTHK5TTp9HmcziDh8GY8niiFQgKn00c8PkY+HyebnaGray+y7GFm5hDlcpliMUOplEMQBEzTjjxlRNFqiqn5q1/dC4sgyPh8HWSz85e8Ddslyu4Ot7Zbu/9yHJ3qn7cScdtobtx69dXfqM7U1i5edicxLFabMvn5z3+Hnp6X37Bu67XWmludz5Ui37Wi8WJff77A1qeu1162bwOdSOTssunTxRCoZYaas0FLjeDplR8XkuQiGGwjk5lD05qNKd56sM/JoUOfwjQb00u2DWY224XPN8PevV9akqSbiX0pZ6ja42od9I2LLKv0MDDwvzl1Ck6d+jHBYDd33nk3fX0z/MZvDFeEQGR27x7jwoXnmJgQuXjxRdrb9+B2+3n3ux/hoYeWd0+za8b9/Y1jUDMzr7KwcJKZmWNEIpsIBl+ivX3wTVfaqifn7u7rmZh4AdMsk0pNMjX1MmDi9XYTDm8iGt2CLLuqqo1vZby1j24V8HiiGIZ1obDryNHoIA6Hm6mpQ/h87ZimSSYzQyo1wdTUy/j9fSiKh1xujnPnfkoiMUq5bGlXy3IEUYwhywq6LlTE8rUKEV+9JqNmiKIDVc1XTN/LNEbqq1cQE0WLkJdzhHojYZGvXiWT8+f343DkqoRhmhLd3S8xPX0zjdrNVv3Tfs7Q0BOrXghAa7WwK43liPZKlgCaL/b1M8rWeFQtupucvIVah3WtmcvGypGfbfrQ/NmXqM04tyqjuAEFWXZTKBQqj5eWeOxbD6dOWQR6+vSHGjSs62Hf16oOXL/YWcpdC6zzX3OQqs8M1exKVbV+bjFHKjXGkSNjOBzf5dd+7e9y8eK7ed/7grz3vbcyPx+t2iOeOvVNRNHN9PShigtTz6q8i21yBtiyZT8jI9/DMEokEucqBH2EmZkj9PXdjKapHDlyN889567IdV6R078mKIqPoaH3VseoMplpCoU4qdQF5uePkUqdx+n0oyiByqzzW7fe/LYmZLuhC6BYTFAoJDBNjVxuHrc7TFvbIIVCErc7jCy7OHv2Z8zOniIen2DDhv3oehlRFPD5OmhvNyiXc7jdAUqlDLLsoFwukM8XqaWpr+bFREaS2tD1GQBUdQrrIuuu27+Ez9dOPi9jGCksgq7vtF4csdhR8kpkfKWiuJVmci3ytQjCNCXS6V5OnfpElUxuv/0L9PS8XJWFNE2prq5s/W/Xn9cyzmXXc6/UuFMzVjqO1Z7b1TxuKfck05QrNUhPNeK1ounaHHPjxR2gHYhRSym3goZFsI1Wi7VygoPFGaMCYFIozFAbvXrjV4SX0kW+lMvT4oWJwaFDn+LgwU9z+vSHFtWBbWeteHxLdVutSgP1DY9WFuMC8fjGqrb1zp1nkKQQup5set4c7e3/nvb2/0gq1c6zz+6gq+t6Llz4ZV54IcSePWNs3fotstlJXn/9L/H5urh48SCh0ADt7Vvp7t67IjHZKW2783l29iQLC8fJZmd4/fWv8Prrd/J7v+dGkkz++I+v7JzyWlE/RmWTcy43j2nqzM4eZWFhBFl2E4uNEQ5vfEumtN86R7JK2CTs8USrDV0uVxiPp70qoZnPz6IoHnRdQxRldF3F5QrhdofQtCy53Cyy/BIdHTtwuyPkcvNIkpNYbIxUagJJMhEEUBQP+fzqBv4vH1qFjOtJVcc0bRtIDZcrjM/XQ7lcoly2L3AC1sXQduBZnBa0hUHsi72uWyns5gv+UgRwJVOuquqlFgnoJJODDRc/TVusYhKJjDb8PzV1SzVlbZPySguBN9OecrVd1mvvxhYafI5bpZ1X7hCOYxHNcotNHSsr48b6vBWp9S0sdwkpYi0atcrzWo/pXa763FJo1VgFK+twtzpnVqahOUsgcurUw9jnziJUsxrtvviiZaBSq99/t6UzVPP+3vvezwJw4cID3HprjP37TVyuf0A2O8WFC6+RSIzT6LClUyrNMDExww9/GOLRR29GFHW++tUhvvzlQXbvfp5icYFM5gLz80e4cMHqUo5Gh+npuZ6DB2/l5Zc7eNe7xCXJtL7zuVzez8TEC8iyzF/9VQBRvDpzypeDZnL2+brIZKZJJMbJZC4Si43g9/fR2bkLUZTxetvfEuT8tlPqymZnyWanEQSZcHgjsdgYTqcfUZQRRblS5D+Cz9fNwsJJCoU4fn8fLlcYw1A5evTr5PMLyLILRXHjdrcxPf0qkuQhEhlEEEQymfPkcnGSyXMUCtNX8dWsdCFy4XSGKZWSgInb3YZhFCmVClgXwzKN0YcPyCy5taVwpbur1yKjac8n2/93d79EPt9GOr2xmn7t6DjM3Nz1DanreinNqxX1rhZriY6Xe85qH7dWtamVNatXs+j0Yi38JFbfP2Gn0984x7T6iHh8/N5L1uFuPmeWkthnq5/BcPgM7e3HOX36gyytkma/bmFF9bGV3iNB8NLdvZeOjm0oiod0eoaFhVFSqQuoaqy6r0bFM52NGy/ymc+8xvvelyAQ6KdQyBKLnSAWO0k2u8DRo/v5T//pNy9Zieub3yzwsY+5r4qS19WA3QSWy81RKmUolzMUiykcDh/h8Cba27dx4EAfTz8tXdEU/DWr1OXxRMnl5tH1EpOTr2KaOsnkuYrOdADTBIfDSy43R7lcwO/fSCp1gYmJ5xFFEafTi2FYkbMkKeh6iXK5gMOhoygeQqE+RNFS8srlZilUA047Gm2tjrVWSJIXXS/RnCYUhACmqSKKTtzuCJIkUSrNAxKFwlzl8QZW5FEPk8sh4yut6rUUWgle9PS8zOHDn2Js7OEGyUy71rx58w+Ynb3RvhWgobnrzYx+m8/VlT6WVoultY4rLV8ndmNlVjQazVSaYX/ml4ukZcCFw2EdqKoaWBH4G4NWI0S2yIxpymSz3dW/VzpvzefMjmLttHV7+3FkuUgrWdIaan+bpkwoFCYY3IkkKeTzFyiVspimhii62bHjOYaHD2AttB00T02YZo6f/jTE+PhOtmx5lVtvPUE4vAm/vwdRhFwuSTw+wsaNByrHaZUpzp3r57d+awPT07/Du971ApHINgKBHrq7b+S733Xw+OM7EYRLj3A/+lH3Gz6nfDmwm8FsB0BNKxKLjZFMjjM/f4wf/MDNP/7HG960FPzbjpBtmcz5+RGcThAEiUjEUi8qFBLoeolk8gKFwjy6XkAQTEqlBRKJM3g8YUAgm51C08r099/B0ND78Hp7mJ5+hdnZY6TTF1AUP05ngLa2IUqlIi6Xm61bPwBYIhvHjz9KsWhJcF7qHLKut7r4iTidfkyzhCh6cDhEstkk1he9VVTioNZYc2mw09eX0/S1VhIaGnqioUtaECCdHqDZx7ej43XuuuvfMjT0BIcPf5p8vrthO1dSSvNysVbbxaVuXynt7nJdSZlJOzK2mwaXg00QThb3Ltiwuqt1vYhhlFlcc766DV3NC5W5uca59XprytWodNnbtP+uRy0yXoqMm2Hw5JN/l87Ol7j++pcIhbZSKhUr3sdTlMtZJEnE6exAFB0IgsHrr9/F2NitbNjwU0CtW2zI6PpDDA9/D1F04XZ34vV20NGxnbvumiEU+hx//de/Tjy+Efv79Morv8idd36e06cfQ1GCnDnzEX7v9z6DKJqYpoAoXroS10MPvfWJuBmiKBMI9AIQCm2o1pv/9E/brppU6GrwtiNkaNSu9niiAKTTk5TLWRKJCcBAln1Ikg9JkgmFBpmePki5nK+YT6QpFOKoapa2tq04nX7S6XHm5o7hdvvx+zvp7t6L2x2lWMwAGpnMDIIgkM8v0NNzCwsLx0inJy7h6L1YX15bVKR+JaxQKmUQBA1ZVkin4xiGPYtrk7/9pS9jfdkujUXtC789DtXKonEt27lU1Jye7FlVG2KVjAGuu+5LFenNtx5WOgdryTispnP8yslM2uNJa4GBILixKl0qtXStnZrW6ubnG593tdG8UDFNoUmKFeyFwdat31lSpQuMav3XrgVv3fp43basjnULQt3v5eRerY7pU6e2smnT/yaVAklqw+/vRxQjmKaGxxNFUWQKhQWOHXsvX/nK/0UUdX7+819j796XEEVLnUsUdSYnH2L79gMYRplc7gK53AVAxukMMTz8Y3p7P1QhZAttbdvYs+dTZDJTLCwc59FHu6quUKJocv31Ar/7u28/Yr0SqK83P/RQmb/4i6svFboU3paEDDXtarDqyhcuvMjExLM4HD4cDhf9/beSTk8yMzNGPp9EFJ2AgCQ5cDqDFItxBEFkfv4UhqETDG5AVUv4/V2AzNjYzyiX4xSLSUqlFMVihlxuDtOEcHgTkcgWMpl5TDPPWi42bneYQiGDLAtomn1Rk7G7Vl2uAIKgomnliqCCjCQ569Lb9sXAHjdpFaksX5tuvtAbRk2j+41Go3615evb3n6M6677ckP0e889nyceH6p2W9uLkdHRB9/UKPnNSpe3SkNfTaW1GkxMs0SNyJsJ/Y2rFzejeaECVLufa0Ib1t9793550fMPHvx05S+bVO3vmsHk5M11ZNz8RbFu6+19uSrMYpoyvb0vYpowNXVbQzZjZORDTEy8l02bfsbWrY9V95fNarjdnYiij4mJd1UJU5JMuruv5+BBuUIUEr/yK++lt/efUCjMk0pNMjc3QqGQrIgjxdm1679y9Ojd2N+V/fufYtOmu3C5QhSLSU6ffp0f/ECqEs87lYyb8eEPK29qCv5t19TVCoahcebMU0xOvoam5fH7++jruwmn08/Zsz+jUEgSi43gdoeJxc5UC/ldXbuJRrcB4HSGUBQX8fhZ5uePk0hMUCqlyeViOJ0eHA4/mcwMhlHA7W7D42kjl4tTLM5RI0Vbmah1LdfpjFIqlah1SNrEKSEIXkRRQhQlDEPHMEwkycQwrC+7NWttN3I5sb5orYwwBKyLyNKp9EuxClzqYn/lImTrwrGSxaJt0zg2VmvOeavaMtq4HHK8lHGpK7Hf1pCxPnvNc/BurI7qN4+Ml0KzdeRyWYWvfe0xTp/+0CXvKxQaY/fuR5md3UU2210VDwGqQiOdnUcrXdjW5/2Tn/xb3HDDC5imiaalUNUSkiQxMvIRvvrVv6yS8v/5P0fxejv56U9L3Hprik98IowoytUMYTx+hrGxp1lYOM709EHy+RivvbaXsbFb2bTpWa677iUCgQ42bNjHhg13cfLk+/nLv3QjCPDpT6+T8dXGNdvUtRTa24cRRRlFcaNpZTo7d5HNziKKEoFAF8HgAIVCimx2llBoAMNQ6ejYQyJxBjAJBPoBjUIhhtsdwTAMZmePYRhldF2mvb0P0zQwDBXTFNG0POVyisYI1YXDEaRUak3IpVKKxouWWf3tdocAg3w+CWg4nSGcTj+53HwdGTemt60acnMtenX62vU1Y8NoTFnbZhRLdS/X37daL+C1YLmu6aGhJ3jhhd/GitSsWqEtFPJG4I3u6H6zzEBaQ6S1KI2DWi36rYXmTMJy6f29e79UIeSl6sHL14mTyc0Vsq3h9OkPsW/fFyrjUXod4VtfuFdf/QTDwz/A6+1AFCU8HpG2tmE6OkZxOD7D6dM3MDj4MoYxitu9lY9/vB2/vwtZ/mU8npr6VlubZSwBVifx5OSrXHfdS0xO/pBsNkYyWWB29jjx+Cjf+laRP/uzj1RrpZ/+NOt4i+CaIOR8Pka5nKmSsssVJJ+PMTt7nFIphd/fXxHUmEPXC2iaxvDw+/F6u3C7w5RKGTyeKOPjTzM9/XrFMSqAooRQlAyS5KJQSONwuBEEN6KoUC5nkGU35XI9+RbQtKU7VWXZh6bp1LqhbUcnGVUt4fWGKJct4QyvN4IgyJUFgJ3aNqlpagtYX2onjQ1fK4+wuFzUdY8vrh+vpp7cTMrN960WjbKZFrnWOxw14+mnf7+hE7uVUcVbDVeic325SPmNS5vXCFcQ/EiSgKalsTI+bw8FruXQqJrVCq1T1TXYjWtC3e0Gr732GRZ7UlvweqP4fEHy+UnARBC8OJ1ztLUNsm/fWR58UKVUShOP5zh37qeAjNsdZWrqVcLhzXR37+Xkyfc3KGXJsosNG+5iw4a7MIx/TDx+hmPHvsf5809SKKT5wQ+urzOu0Pnrvx4hnQ7x6qvdy84ir+Pq45ogZNtgwuOJIssu0ulJJidfplzOIggioVAfgUAf8fg58vk4hgHZ7AJdXTcgyy7c7nAl7f0jVDWPaZbJ5xcQBAOHw4PD4cLt9uNw9OLztZHJzJDJmBSLyUXHouv1Yx52StoBuFAUHw6HSaGgYX1BbUJWEQSdcjmHLLuRZRlZdlfGsxzouh1Zu5EkX6VDW6O1wcXqmnSaHZ9WMqK4Wmh2gZLlPE8++cWKylGNmG03qNHRh6jvbA0Gz1zx6Hi5KHg1phJLPW+p+9c6x3y1R9NWA1l2oKqrGYV6e8G2qzx48FMIAnR0HGN2dheCAJlMN1NTlqRr62jZJt16iOTzbSwmY+vvu+76PorShqZZWTpNS5LNTpJMnkFRosiyTEfHLg4fvo9Tp3azY8dJBge/zszMIS5c+Dnf+pbK//yfVrT7x38sLhrTEUWZtrZt7N+/DcP4LAsLp5ifP85zz8nVdHgq9Tq/9Et/C0ky+S//hbf8LPG1jLc9IRuGRiw2hmlaCl62OIhhaDidQcrlHInEBA6HF48niMfTRnv7Tjo7d2EYGqVSCq+3HcPQUNUMsuxE1w0CgR5k2U8mcw5VLeNyRdiy5b0IgsjCwklk2UkyeX7R8eRyVueyroPX2wYkKveYFd9lpTL/XH+VNSuvRUdV8xSLOrpu4nT68Ps7SSatdLXTGUZVra5v64vdGI1bM8xlLsXy7kobIKwWzS5QtkjIiy/+RrU2vNgNCuwL2o4dj161Y1tLOn6152slsr5SuNrvn6qmr+4O3iAs5VncKrVd68K2iLe//1kymW683gU2b/5JVbIUrJrx7OwukslN1LJWNb3xrVufYO/evyAa/S4LCyKiqCDLHkKhHgxDJBQKUC7n+OlP+3jppfdx8uR7kSSDb3/7bv7P/7mDnTu/Qzx+kiefvBVRtKJdSTI4cGB5ta2Ojp38zu/sZNcunR/+MMXg4CFefHHwLam29U7E25aQ7cFuWyREVQu4XGGKxQS6ruH1diBJThKJCRYWXsXlCiBJHjo79xAOD+FwuMjl5itSmzFUtYDf30upVMTr7cDp9NLZGeHCBZNiMYHP10m5nEHTipRKCTKZKZxOPyBQLs8BArOzJr6KbrtpwtjYPIODCrZTjqYV0TQXgmCJkgiCgqaJKIoTv38AXS9QLKaBEsViGsMoEAhsIBTqply2mrhKJR1BULBa8UrUqwFZ3a8mi9PYq8MbGXXZEe+GDT+rziX/5CdfXJS+Hhp6YlFau6vrVQzDwebNP7hkK0aXC1TVWjhd6vNbYTkCV1v14L1t0dynsFjM4vJwdeQ067GcZ3Er2Cnt0dH3L/KbbvXYp576/Ur622rcvOOOV3A4jrN588vcfPMhPJ4AcDey7GV+/gSFwgzT0xcBGV3vZmTkfv7iL/4TdgbCJsyTJ3fzi7/YQTp9gelpnR/9SG7wO14NHn5Y4uGHI8B9fPvbZb7xjTdv1GcdNbxtCTmfjxGPj2IYOoIg4XaHAYsIo9FByuVcJVJWMU2NhYXT3HDDL6MoHiRJIZeLoWl5FhZGGB9/pqp1vWXLe9C0AqIo0tm5i76+WyiVkug6mGaJycmDiKIbn68TQRCRZTdzc0dRVQ8Ox7lqdFwq2Rdta9yqNvNpEathgGkW8HiCgJNyOYkgOPB4Quh6GUXxYRgagiAiim4cDlsVSMc0dRwON6rqRhBETLPIYq/ZK6fB3dz0dbmoj3htC8ahoSeqrk+2QpddG25Oa99xxx80pKkvhVxXI8Cx1nT9So93OK7MMbbSIH8zshuNkLiyhBwEkldwe4uxFsUz23rRHqOy/aZrjxeQ5W4Mo4jb3U4wGMXl2lpn7GGwaZOXf/7PJUKhTxIM/kt8vk7y+RiaVmRi4hXGxh5DVQuUSimy2TmOH99anT0GEASLMG+5JYbLFcQwNH75l6GvT+eZZ6RLHtN5s0d91lHD25aQPZ4okchQ9e9iMVUhMIusS6UM4fBGtm//EGNjP8Y0DaanD7Nhw53EYmNoWoF8PkmplKZQSJLJTDMwcDv5/Byh0BYMo4QkOens3EU+HyOVmmBs7Id4PGFcrhBeb4SZmSMkk5M4HD6czggzM+fQNIuMTRNkGdzubhwOa9ZYVfMUCumKz2oOcKHrOpoWQxAEHA5P9XUVCinS6fMYRpFU6jyCIKIofiTJga6X0XUdl8uLYYCmCS1GrWyhDSfWCv3Si8FLkXErElhq/Kb+9laNXEBF+KPm+mSTbiu5zaWO462K5Uiy1fz3WseY3uyacuPny4fVAHY5XdfJyzqaVnjqqd9ndPQBhoa+z333fX7Vimf1giFgm0joHDjwu4DduW2iaVMA5HJxcjmIRtswzV+obl/XP89jj/0Aj6eboaF3sXv3IwgC6HoJh0Pmvvv+HT5fJ7Ozx5ibG2NhocBzz9Wi3/e/v8TDD49y221xikWrgTWfn+fd75Z5+OHOyzo3b0e1rWsRb1tCrpc+A/D5XFWN6kxmmmTyHACdnbsYHIQTJ77F3NwJZNlZMavuYm7OsuMyTR2n00syOY7f3008PorH04aul4nFzmCaOun0JILgoFzOsGHD3czMnABMJEmueBdP09bmZHq6xNSUgNcrMDy8kcHBu0kmxygUkmhaFiuKtS9UJVTVxDBEPJ4ImlYgk5lHVYuVOnO50gAmIggOXC4vTqeHctnAMHKUSilMU644lHhYPAJlzyrXqwqtLQ3YKlIUBGieXl9LHbQ54t2y5cCiaKXZ9alZbnOpY6u/zz6uS8EbSfK2NeS1AUsvvlSC2mTAm4/69PHMzF4AentfpqfnJfL5KLt3P9pSuevgwU9XnJ7qVbisFPTMzA08+uh3lkx1Dw9/p6WiWj5/lsOHz3L48F8AIUQRnnnm33DunIe77hpj//5/Rbmss2NHJ//8n8c5cWInO3ee5PbbT6CqeV55BRQlgKL40LQiDocXSZKQZR/hcD/Dww/jcoWuynlcx9XFNSEM0gxbMDwaHUQUZWZnj3Hx4ktkMpOYJjidASTJSTI5hiC4cTq9ZDKTaFoRQXCQzZ7H4Qjg9UZwuztJpc7R2bkHWfZimhqaVkKWLbvGWOwUc3NHKRTyOBwCXV3vRdM8eDzgdhtkMjMkEuPoegFdNyiXC+h6ButiJSKKLjyeDtratrGwcIJCIYssS0iSB13P43KFMU0TlytAPp9EkhyIIkiSQjY7V1HzEnC5AqTTU7SyX7waaEVYdrq+Ga2Ic3T0Qc6f38+WLQeqBu/1DkYriX2sRLiXUuNdC9ZK+CtlEJqx1tf11sAbZVW6dvzJn7zGzMwN2IvSUOgMyeRgw2PqibUWFS8Fq6lQEDS2bv0u4fC5NXku2/sYH7+XdLqHEyc+Ud3mvn1/WKlPSwiCtQgQBAFRlBAq6RSrlCUjCBKmqSOKCpLkxu2O0tGxlWh0Oy5XELc7yLZtD64T9JuMd5wwSD1k2UVnpyUsb4mGzxEI9KAoPnRdpVi0JDELhRSbN9/EwMAdHD/+DebmTuD1BikWvZWUtYdYbJRiMY6inKev72YymSlUNYui9NDTczMLC6cxDJNgsJNweBOhUBjTVAkE+igU0mQyM7hcQcply0rQ+kK5yectU3hBkAkG+yr2kVSkO01EUSaXK1dGqyRUtYAgiOh6CdM0EAQnpmng8XSh6xlE0YHb3U6xGMPtjpLPz7GaNHWhUEuZXu7Ffi310aGhJxrmjYeHa2npdLqXZ5/9N0xN3dKyaWs1x7lUxH4lhEzeTLvHN79WvBxsu8W3HoaGvl+JjC3SE8Xm4zQYH98PWBKaljFFszZ1/diS9ds0ZU6deripMexHiKIbl6uN8+c/xqlTe9m+/SgDA/+XQmEBXc8tWoDWj/KNjT3AL/7id/B6Q7hcfmtvgojD4UUQpOr/iuJDVXOUy7mKKY1ALHaC2dkjTE29gii6cLlCnD37Uzo7r0fXy7S3D7F587tRFN+VP8nruGxck4RswzA0crl5SiVrRMPv78LpDAKgqjl8vg4CgR4uXnyVQGAjhgHh8ACCIJHLzVAqpVEUD9nsRUyzSCp1Abc7TDA4QCDQw8TE8ywsjKIoTrZv/xCh0GYymSmmp1/DMHQike0oigdVzVEq5bh48QXyeUuoxO0OUSyWMM0ckuQCDJzOKG1tWyuNWiZzcycQRbESYYPH04HXG2Fu7jS6nsQS+pfw+boRRYFcbgZF8ZPPT5LL6dVmLK+3dao6n7fI2GowayRnG5fqTFSPlaJC+/6hoSeYmrqloldtMjdnpRbrSflKkNBaSflKEt9q972ax70V5pEbsfbO/jcKdke03SE9O7ubeHxb3SNEHI78ClGxQCRyinh8CFsERFHSqKq/rq78bwCR4eHvcPDge3n00T9Ekkx+/OOP89/+2wdoa/vXFIt5nnyyUcO9fk754x9v5yMf+VOi0UFkefk32DC0qsmOYWgVTf+XAGvxPzPzKgsLJ5mcfBlBUAgEOjl//kWCwQ0oipuBgTt49tktV9z/dx2XhmuakPP5GIIAkcggbne4UmuFYjGB19uOrmtcvPgKicQZTNOsCHe4cToD5PMLuN0RdL2E399XITeZSGQTPl83U1OvcujQlykU5olENhEMDuJyBSsd3POk0xeZnPw2pZJIV9cO+vsHKZfzTEz8DMMwCYUGKBQylEppZFlElhWi0a3099/F/PwxLlz4ObpuIkkKihJF05LIshtVzVdJUxBkBMGBJAlkMnPouoCqJkindSTJItdyGXTdJBBYOp1omhYpW9ukbvvLX/QvVdN6ORI5c+YB6qOFs2ffz/vet/R4ydWQ7nyj8dYj1la4+vaJVxv33ff5KjGPjDy4SLd6dnY3zRagodBZRFGvkLdeR+IWiZbLfurnjGdnr+PRRx/jV37lH3L+/M4GRayf/UzjP/yHf8F3v/uPFjWU7d9/kmRyiAcekPnN35TI56FYTOHzLf/BqDfZEUWZTZv2s2nTfuvoDY2FhVOcPv1jRFGgUIiRyUwyPX2Qc+d+iqL4+Zu/SfOHf/jZN83/dx2NuOYIuX7FaAuv27/zeWtcQBRlDEPDNHVMExwOL+VyhkIhhaYdJxLZiig6KRaTbNv2ASYnD+JwBAgEenC5wuh6idnZo4CExxNhePjDmKbO/PwJ2tq24fd3c+jQ95mdPU8uB8899zo33/xR+vvjlZR5jFCon87O65AkAV3XSKfHMU1Ip8+TSk1SLKbQtBJO5wBOp4KqWhfEYtESL2lrG8LpDFEqpSgU4lhOVhqG4cA0S+i6FR3bEXCrdKJp1h4jirVu6lZNW1cLzWS6Zcv3K5GxRcqbN//gqux3LZGqjeZ08dVeDLy1FhteapKvb38MDz/B1q2Pc/r0g9jWiNZnrtEC9P77/ynj4/fy0ktbqjaOvb0vo+sOZmevxzQtMvZ64+TzEUxTQpJAUf6Qu+/+S154oaaIpSh/xPPPF0kmRxgeHuGRRx4iEPgzPvCBDh56aHt1r4bReN2ybqtd1+zAYrnboSYE0tGxs/rYePwM4+M/R9cLpFIT/M3fbEIUdXTdcn46cEBYJ+Q3EdccIefzMbLZaXK5edrbhxssGvP5ecD6oGezs7jdEXp7b8TlCqDrKuPjz5PLTVMqZSuKWDA6+kN6evaSSk1hmiXm5o7hcHjwevvo7b0Zl8vLhg13oGklCoU5wuENTEyMMDl5oVITFnA4ipw69TUUZSuy7MHpDNLTcxOh0AbAJJWaJp2eQlWLzMwcRhQVHA4XPl8PoFMuqxhGkXK5hCy7cLkCdHXdgMcTZm7uCMViBsNIIwhO7BlnufLO1kaWHICEKDoqjWAaXm+RXMUrwI6MdZ1qdL0aXA5htHqunZ4+e/b9bN78g2Wj46X2bYuODA5aTTZLSVWuRHjLZQDWEtVeTvS7Wtetq4/syg95m8BupursPNpgzyjLdsrdipL37fsCw8NPMDl5S51CnMjk5G3s2/cFZmZurHuuXCFja1b47rtNbr11Dxs3HuIHP0jhdn+R4eEnOHeO6nZ+8zd/iT17OhYdX33UayOfj5HPz1eEiTLVdLZ9O7DoOa22W29CUS5nGR092WDDuC4K8ubimiNkjydKLjePaerk87Hqh7Q+Ws7nYxSLCfz+bvz+7oqbEmzevI+pqcOUyykikUGSyXE8nijT068TiWwll1tAlj3IsoIomvh8URKJc7z66p+yZ8/fxuUK4HaHSSQKJBIm0aiIKBr4/aCqJvl8jLa2fjyecKXBrIiqFojHT1AsLqBpOoZRwukM4PN14/G0V7spDaNIMNiBKFri8pLkJJeLIUl+FMWFYfhR1RQ+XwQokE6XMU1LyrO72084vIFiMYVp6pX9Wq/Z6118DutrycsR81Kd1g7H5XUJ33PP51dU4FqOjFuJjjQ/90q4Vb0Z0eubl9p+a4wvXS6am6l27Pg68fggkchYXaezCOjMzu6qs2Ssb+gymJvbxSOPPMSzz/4Wk5O3kUqFALjxRoHf/m344Ad9ZLNDfPCD08jy73Lx4jMNx3HDDZ9h164Pr/q47etX80hncxZwLVAUH7/2azfT378uCvJWwTVHyKIo094+XE3jwOK0Tv2HOJudZXLyFYrFJMHgAG1tWymXM+Ry89x446cZG/sRbW0ygqCgKB5isXPMzp5AUbx0dOxhYWGUmZmX0TSNjRvvIBYbIxh04/M5cDhUZNmKVlUV3G4vPT0343C4KwuBMtPTh4nHz1IopAENVdUqjWP9OBxBdD3H1q0PMzn5HKpawufrJhTqZ2rqFTKZWZxOP6IoV2vfDoeHUilHIJABXHR399PW1kEqFUdVFZxOuRIJW1F3K9jGE8Wilbq2iWc1ZKDrjd3WVzI6XA1aiY6sZD7RipTfajXdVprL61g76ufdQefEiU9Ulbdq9WNrzvj06Yep1c0bXZ1OnXqYG274MrquUN/zUCppPPSQo9pz4vW209t7C7HYWQqFeaBEd/dd7NjxkYaAYTnUX78UxUuxmCQc3mgdSYtoeq1YFwV56+AKCiK+NWB/eG0LRvv/fH6ebHaWbHYWw9AwDI1kcoLZ2ePoeqlSM07j8USYnT1CINADCAwM3Ikkeejq2o2ulykWY2QyU5RKKaLRQSTJharmmZs7RjJ5Dk0rYxgTbNwYRpatlLGqQnt7mI6OLbhcHlwuL7ncLMViBl0vVEYaXDgcPlwuH35/H4FAP6qaqaiEnUUQFAqFGLpeJBjcSCi0Eb+/i2CwH0XxIcseRFFAVXNIko4ggNMpEQh4mZg4yyuvvM7Ro2cYGztFoTCHovgBF1Yqe3UoFht/1vKcVmglAVn/s9z2Rkcf5Cc/+SKjow823L9hw8+qZLycNWPz61hp31eToEdHH+S73/0iIyMPtrzfjupeeunXefTR7yz5uLcrRkYe5Mknl379V3IbGzfWPh81swe7v0JEEKy5/p6elyqPaX2JtKU2h4a+T01wR6C9/c/57d/+7/zqr87zrW9ZH64NG+6mvX0Ip9OHy9VLX9+NTEw8x2qzDvb1y7KZzeH1tlEut/KlXsfbHddchGx/eDOZaQoFaya3vX0YsARD5uaOk8stUCplKs1MEoHAAKVSGtPUmZx8FdM0KBaz5HLzLCycIpkcJx4fw+/vZfPme0kmL6AoARYWTlEoxJAkB+VymmRygljsNF5vH9FoB5AG3Hg8YYaG7kNVc+RyCyiKH01TEUUJVc3T1XU9mlZEVXMoipe2tu1Eo1s4evRRisUMmcwUgiCgqgVEUcLl8uN0hunqiiKKCqHQBmZnj5PPx3E6JdzuXSwsnEXTNBYWzjM3N0kwaKWfXS7I5TRgtnLGbBtInauZllxuLngt24Dl09K2zObhw59iOTP51RzbUse61AJjKWGU5dD8WppVn0ZGHuTAgX9TJQ5B0Dh48FNv62i5PtoH1mTwsNT2VruN4eEnqupZDkeeZ5/9neribd++LzQ4Nlnb1CuNW/UwKlKbz1b3Y49TlUrwB3/wOwiCzpe+JPFXfxXjlls8eDxtGEYZw1A5ffp7lemJIPv2fW7F11ef0bNHOV2u4JrO0TreHrjmCNn+0KbTF4nFxnC5FvB62wkEekmnJ0mlzjM/fwKHw09v7404HF4ikU0UCglKpQybNt3D+fMv0Nm5i1Ipg2lCuZyrGEyU8Pk68fu7mJ8/xZkzT1IsJolEtiLLFjEWCnGmp19D01RkWcHrbWd4+EFk2YFhRJmefpVIxEuhECeROIMgCCiKn/7+W4nHz1EqJSkUYmSzQZxOP253tqIwZiJJIqZpUCgkWVg4gShKtLfvwOEIEgj0YZoGiuJBlt3kcjGKxTS5XBxBsNLm9miT1UFdzxxrI2PTXH3T11qw2qh7NWnpsTFLrGFs7ENVwr7agh6rNY+oT5E3v5ZDhz61iKwarftkTp9uFqJ465Jyc6q9mTy3bn18SYOH1abpG2VXmzWmF6PeXrG39+VF0pY2Hnnkocr7cTelUqR6ezh8lve9758yPPwjxsYewTA6eNe7/gOGUai8XyamKSGK8NJLYR54YJi77/5NotEhcrk5SqUsMzOHyWZnqnK/y6E+LW2PchaLKVwuqoqEK80rr+PtgWuOkO0Pdyp1oXpbLjePz9eJz9dJV9f1yLIHlyuE0+lldvZ4JUrdQ1fXdWSzs3g8VtOUIOTxeEJs3vwu5udHEEWZZPIcsuzh5MlvEYudBXQGBu6ks3M3odAmRka+SamUQ5YdKIoftzvC9PQreDwdgEQw2Ec4vJlUaopodJBMZoZCYYGpqdfZsGEfFy68QLmcQVVzmKZJKLSVXC6GqhaRZRd+fz8g4Xa3VQwpAqhqFl0v4vd3kclMUSgkUNUSul6o6Gw3OjY1jjQtrW9tE4fdeV19xptIxrBYCzuR2MLo6INVUr6UOvJqjmutBhGrQfNrqVd9qicr0OnsfJ1A4CKjox9YwqHo6lsWrgWtItdmzXKLvGolBjs6XUvUW5vptaLZmZnrqxrTwKIFQf3/S3kf27DeD3uVZdWYLTL+ISMj7+PRR7+KKGo8//yvsmfP03URtYlhCNx7r0gg0Esg0Et39w0AzMwc5uWX/wdudzvT06/T3X19AynXS/82E219tDw/P0I8PgpQVSZcx9sb1xwh23C7wwQCfZTLOUxTqzZQdHdfj9/fTSYzzZkzP2Fm5hDR6BBOp7/OrMKsNmSUSikcDjdud7gidwkTE88Qj0+Qz8/i8bRhmgaaVmB+/ih+/wYEwUk+P0s+H8c0LcWscjlFKLQZr7eLUGgTmlZGUTbT1jbMqVPfo1BI096+jS1b7mN+/iTJ5AVKpRRtbdtwOPZX7CTzSJJMKNTH7KwL04S5ucNks3OIooDbbY1QlEoFZNlJuexEFFV6erxcvJijXPG0aG9XaLSEbIaCbYCxFp3l5XAla7D1aemxsYcZG3uwIRJuJrnmOvJq7QqXGnVq1QRmG0Ss1Qqx3skqkdjCmTM1shWERrLav//fAjSM6jQ6FL11yBha2xs2W2zu3ftl9u798qIodS3WiLZP8WuvfYZ8vg1LqMOodkCDwYsv/gb79n2hmqJeTXbh4MFPY6WnrexEZ+cR3ve+P+X22+eIRD7KgQP3IwiWPaIoGnR338CRIxKiaJHxb/1W62apjo6dbNv2IKdOPcHoqNXEqSg+FMVLLDZGMjnO1NRBBgZuZ8uW9zSQdX20HI0OYhgaTqd/VZH2Ot76uCbfQZ+vsyr+kc8vYJpmtZHL/tAmk+NIkoLH04mihFHVAtnsbPXDrmlFCoUEodBGcrl5stkpXK42TFNl06b9nD//HLmchq6rSJKTQGCAhYVTOJ0eRLELpzOAoszg9baTTJ7F6+0lEtmIIFgjTJKkoGl5vN52urtvZnLyJEePHmfLljAdHZsJBjcwN+ekvX0HhUKKbHaG2dnDpNMXSCYn8Xq7yWZnkGUXhYJlOuF0BtC0YmWmUMXhcFIszgMmAwMBTNOP2+1CVa3xJ03LsPgiLrGSbd6lGiu0wqWmj4eGnuDo0U9X/rNC/8OHP1V1hVrOrnGlY1rNcV2uFaLLBUePWvPSGzb8jPvu+xyjo9bCwiaiG274MjfcsJisWjkIXV1cWuTdrEaVTvdWRousKNKe84XF6eXlrBFbpcEtorUlKMGeF7b/Bjh69JG6jIPBwYOfaunwND5+Lw5HrkHJyzQl9u//XTZteoKZGchkMgwOdnLgwC9XhT8++ckEn/xkghde8HLvvTKf+ESoYduN0x5ONK1MLjfD8ePfqnzP5zh//ueoahFNy+PzddPdvXQntpUx6642fF1ut/U63nxck4RsryJtAraJuVBIVBu83O4wuq5hmgZgoKq1rsVcbp6pqVcB6Ou7jc7OXdXtWCNDZTyeDhKJcQzDIB4/jc/XXkk1naRczqDrKi5XuGKP5kNR3GQyUyhKAK+3nWh0kPHxpymXUxw6dIGnnnoGRSkRi32Tj33so7z73bejKF4uXHgZ09SJRAbx+zuJx8eJx08iCDKSJKKqBl5vBFGUSKWypNMpRDFXIWXbxrFQUSQrA46K6MlSusOXF2WtJqK+WrXc+fld1a5rm+jqydiOcFeqTV7t+WK7S7xVY1orsrVJ58knv9iQan3jIAHamp/VqoHKHikCHVX1rOq59edipTR447xwI0TR7qgGEDl9+mFGRh5suW2btGtjUI3bfO21LYyPD7Bv3xfQtAi7d59Fls/z3vf+Hg8/LGMYOZLJVGW/1qhlLDaGaVoZqQ0b7sA0Nc6ff4GJiZ9SKMQwTZOLF19FVTN0du6mo2PbivPFlzOHvI63Hq5JQrZhE7NFlKM4nb7qSlIUZXp6nIyN/QSHw4nPZwmEzM4eI5ebQ5Y9CIKEw2EN5fr93SiKl0RinFwuTjDYSy7XhyA4yOdTJJPnK7KaOoZhoCh+nE4/Hk+UjRvvJpudQ9fLmKZBKNRf6dT2MzMzyfPPP0EwqOH3O8jndb71rW/T16fj84m4XGFE0YnHE8bh2Es6PYmq5nG7owQCgyQS42SzU5w5c5KxsQncbpNSCTZv7qO7e6Di49yOtegokc/PkkpZZCzLtjCIrcUrUK9XvFZiWm16+0ppN+/e/aVKFGNdONPpTXzzm5Y5wFLCIGupTV4NLNXM1Vjnbrz4X7ljvtQa89rJ2Ia9ePja1x6jec63Md3e+rlgpa8nJ29BVb3E45sXpbLtaNrC0sX8eHxbxRxiK7Z1ou3wND5+b8O2F5OxXk2bNxP3I488RE/PE4yOwszMQXbt+ig9PbdSLFolK48nSjBofefD4Y1VPYSurusYG/shpVKWYjFDR8cuTFOnUEiSy81hGOaaGr7W8fbHNU3INorFFG53GEGQql8Gn6+TbHaWtrbBapNTPD4GCHi9Hbjdkcq405mKy1OoYuYA0egWhoY+gKJ4WVgYoVzOIYoysqwQDPaTSo3j8XRRLsfRtAK6rtPZuZPJyVeJRocoFFKAQTQ6xNmzF1CUEm63C8sfOczCQpJCwUFfXx/B4GZyuTni8XEMQ8fh8GIYBu3tO5FlBzMzh5mdHWdubrxCcgqlEhw9OkcwGMblCmAYAl5vhIsXXyGbtfySTdOaj06lIBh0YhFyzVA+n7fOia2FLUmNjWFgNXspitVdfKWwFsMKOzX9/PO/W6crbC0omonOltNMpxdf0O0L/+WkqVeD+u23qnPXR831xLuWeurSWJs1YmMW4XtY5HRpxLzYyEFgx46vMz5+L7B0N3TNk7i+y9y2H6ylspt1qevR0/MSU1M3Y6tv1Ts8maZcdXiqEbENezt2r4WEw2EtZK3jrs0vW+/HAUAnk5nkxRf/F5HIj4hGt9LWNkg+P8eRI1+lvX0niuIhnZ5EFGU0rUh7+x5KpQygkUicpq1tCFF00N9/F729N675XK/j7Y1rnpDt2rHH01aNjG3UK3lZ5HuOgYHbkWUXsdgYiuKrRMkeCoUkvb03US7n8HiihEIbCIc3MDLyHUqlHH5/J6HQxsr9ITKZOZzOMIah43IFyOdjKIqPTGa6sgAwKprWQ6RSHjIZE6fTiyjGCYcddHT04XD4SSTOkEiMUS4X8Pu7KJWymGaJM2d+SF/frZWIXKnIXboxTRnTVCqd2hKiWEDTdMrlDOBGFPNVzWrDsMd0SoAbO41dT8aCUOuwbu4ktududf3SyOpKmCcMDT2Bw8Gii+pSRNd8v8OR58knv0hv78+W7cRebqGwWn/m5uNurnMfOPDFlsS7XD21FRan5CVaE6qTVqWLS43IlyoFNKaUDSKR0YpClr7s9u2mKtua0G6uGhp6gkjkbEMqe+/eLy1yb+rtfZHNm3/C1NSt1e3USN0yiRgdfaBOHMTA650ll+vENpzo6Xm1UovWefbZ32RwcAqHo0jNLtEm6hJOZxuiKGAYZVKps8Rio0xPd6IoXsrlAsVimvb2Yc6dewqvt7uykJcQRYFkcgKHw40oOvH5ogQCvWjaW9fOch1XB9c8Idu61S5XeJErSn2t+eLFlygWY5w58yN8vh7K5QyRyCC9vTcxOfkqTqefYjHVQOjh8CZ27PgIMzOHK4YTHQiCwOjoSEXisodAYABZduHxbKFYTFfNL+Lxs6hqkUBA4j3veTff+c7TqGoSvx/uvXcYr1cll5tF13VUtUg+v4AkWaNU5bKVesxmZ9D1Ei6XQjbrJJ8XcLmclEoFUikfmzbtJ51+nVhsjEymhCiKlMs1dydNsyNeN9bFunaBbh6Rssl4qRnkN9NC0K43njmzv9pRbRPd8PATPPXUF+sIQScUOkdHxzE6O49V6po68BvcfvsXWmpo2wuSpRYPR48+WG0w27v3S6uOXu0GNPu8LUW8S9VTW6E1mX4PQXBhms3NemrLbVxKRL4ciTd2VkuVKLVGsK223yqqtp/T2XmswUbRXgRY0fCt1WeYJpX3F+yI196naUpVoq1vBMvluq29VV6/1ztLfYReKPwKXV1UtyEIBk7nJlyuAKVSClFUCIf70XXI5y+SyUwhii5cLh8bNz6Ax9OBrqvMzh5DkmRSqQtIkodAoJdgcADDMDGMMpHI4Hpd+B2Ia56QG/WsW7uiiKLM4OB7OXIkjqYVcbn8tLVtq2pim6aOIFhfWnsb1t8LlQH9UCUVdZ5cLkahkEIQZKLRQUxTJ52+SCJxFlFU2Lx5P2NjT1EqJcnlZggENnLPPfewfft20mkVTRslGAwiy04CgUE0rYBh6Hg87eh6mXI5jc/XjapmkWUfXm874XCMnTs3cerUOVQ1icOhcP/9txIIOCkU3MiyG00rIAgqoZBCMlnGktYEvz+ExxNFVeNYMpoypdIUilKzZrRJ2bZrXAuWioKXIvBLJXYrkqxd1O1o1+GgrsZoXVhTqU0kk4PUpyPB5Oc//x16el4GGpvCmvW57fT3hg2WeIddtwZrJOmRRx5qOJZmNLtR1b+GpYh3tY1cS5GpaaZbPLq1v/FaI/Ll9mt3QNud1RZp3kR91Ntq+4sbtWqmD3YzWPMiYN++L9RFwyI+3yw0+Btbr7nVcdi1Z0HQGBr6bjUCn5y8pWouYZoSExNF/uE/7OVv/sZ2SBL5//6/e+ju/iwnT/4N6fQ0sdgEkUg/mczv8cILAfr7f8jQ0Pc5ceL/EY3+M5zOCLLsJhY7STC4GUlyIIoiHk8IlyuKw+Gmv/+29TGmdyCu+Xe8uePa5QpWxT9qHdhW5Dw4+B6mpw/S3r6zYo1Y24bX214lcisFbrlKGUaZdHqyIo1n1Xa7u/dU67aCIKHrOrOzhymXM4iiSCSykfn5E3g8TkKhDahqlq6uLnp7FQRhG6VSnK1bP4Asuzhx4gnS6Yt4PGFcLh+GoeLz9SBJJpnMPP39d+B2d+D1jtHe3ommOWhr68ftNpifP4mmaQSDXWQyc5RKeWTZS2dnlFIpAZSRJB3TLKLrOpIkIAgi4bDl+AQ1UZDlbABXwlpT05eaxl5qBtgmugMHarVme863/oIsCHp1tnmpprDm7ujBwcdpNrU/c2Z/S0IeHX2Qw4c/XR1taiWVebkd1JdCps2wz9fBg8vLjz711O8zOvoAQ0PfX3K/zUTt909TayJsHH1a7nXYTVjLbVtVPQ0LGmBRGttORdeOo7GD2jRl5uZ209l5rFq/b1y03crevb/FV7/6j3jttR7274cPfrCdbPZTDA8/wLPP/gHj48/y859fx9e+9muIooFh/BKf+cw/wuv9Hj/96b+jv/8WBgc/QDS6EUlyYxglLl58CY+nna6uPYtKa+t45+Ad867XN3LVR8r1fqKBQG8lvVxLFdlfjvpUt62O094+TDY7W0nhCni97WzZci+K4quq7TidfgRBoL19F8ViHFF0oOsq/f03k8+nCAS6mJsbQVHcFYUwF+3t9xII9FZk8nQKhXmcTh/lsoTX24HP10kqNU4sdop8foG2tu0Eg30EAl0kkxfYvPkuJidfplhM4HT6iccvIssKTmcQ0ywTiWxBEEzm50cAKJXSGEYJw1CxicV2fFoKaxXAuFpoZVChqo0RbbEIGzc+wZ130lBLvuGGL9PRcaw6w2rJHQoNF/lmla/m7uhWpvatDC3Gxx+sRNKNTWerTQevVrt6LentlWBLdNpRf/22nnrq96tjTDMze9m37wst99ssBNLRcQzTtNLPe/d+eUmZzObXATT8/eSTX6zbdmODV/1x2guLXK6LycnbWr739W5NIJBMbubZZ3+HWGyIPXv+XyW7Ulu0vfZaG4OD9/DZz/4ZAwN3IopypanTyW23/QaRyDZ+8INtiKIlGiJJJvB5urunWFgY4cKFFykU5rjjjn/GwMAdpNOTZLOz9PXdVCdOtI53IgTTNFecg0in0wSDQVKpFIFA4I04risOmyDD4Y3VxqzmCNkm3Fa32UinJ4nHx4hEBiukucDhw49imho9PXtxuyPVVHc+P4/LFaZQSGCaGrquMTt7BIfDi6rmMU2NYjFNJjOJw+EjGBwgFNqA2x1GFGWCwT6OHPlrFhZO4nT6kWUn+XycYHAjsuxibOy7AHi9XXR13UAmM8HY2FPoukY4vIFyOUWhkCaXW0AQdATBgarmcTg8+HydlEp5RFEin4+j63kkyUmxmGDpGeXLQ73P8lq6qVthtepazRgdfZDJycWzrfbFfnLylrq6srRshGyaMh/9qCXFdPjwpxBF2Lv3yy2j4wMHvshLL/16XSevFVWv1DBV6zRe3eNbPf9SjCiefLJ2vLU07rnqdv7kT15jZuYGbCLzeOZ46KHPLDLGqO+StkaOtjWMCy01RrRS53UrQ4jVLWwa3/v6hUU9Kdu/bXWvejzyyEcZHn4cWfajaTo33vh32L//twEBlytIsZjiscdUfumX+ippbYHHH4f3vjfJK698mdOnv025rOJyeUilfoszZ+7irruKfPzjvvXI+BrFajn0HUPIs7PHiMdHiUSGltV9NQyN+fkRdL2EJDlpbx9u+JI0k/Xo6A95/fU/x+kM0Nd3Gx0dO1HVQkNHNkA2O0sqdYF4/CwuV5hQqJfZ2ZN4PBFmZl6vRK8G7e3DlfErcLsj6HqRQiFDNLqFsbGniMVGcDoDdHXdwMLCCVQ1h2Fo+P19aJrK6Kjd9d2F220J4s/NjSEIZQTBha5n0TQDRXFimhqBQB+6biBJIg6Hh7m5M+j6AuClVruTgRxW01eh4XxdjSh5NQR9OZKeSx1n7WJvRcs7dnydQGBqUQf26OiDi1TAlkvp22Ik9USydetjDRHiUvja1x5rSLv29r7IZz5z+6pe52qIrtl5qZULU60zvaawBTQRmUW69fuwjr1+FKmxVnvrrf+V++//3CLyt29vhbU8drWokXItNW2/pq6u15mdva7ahb1163f45Cc/vOj83X57mt/7vb+Hz9dVve8734EDB2D//pqEpmFozM0d5+mnf5+nn97E//pff1RJa4s8/vi6L/G1itVy6DtmORaNDjb8Xgp2E1eplMHtlhZJ0tXXpBOJs8zOWgTpckXZuvUB5udHyOcXiMXG8Pu7q8+z3KTSaFoOTVPIZudR1TSJRJLOzj0UCkkymYvkcgt4vV2k05NEo4MkkxcpFjPE42eQJBmfr4329j34/Z1kMufx+XpIJMaIx0/hdkdpa9tONjuLKDopFOI4HF683hClUoJ8PgUUAYFSyQDKJJMXcbkCFIs6oZAXRXFSKEiVhi4npmkgCCIQwDAMTLNGyDbp2PPJKzVkrZa8V6o5L0XG9c1Wy40wqWrr2emlzOtNc7HF41JEvNQxXqlU8uTkbXzta4+tqpt7pW7p5qYooKFL2j7eeHwLo6MfxDZNePbZ3+GRRx5ix46vc/r0B9E0N7Z+tFV3tkaWFtdv7VqtQX0tuNZ0ZzaMojUvEi5lBMx+na2yBB7PLrq7N7Fp0zP09v4txsdvZHLyZi5c2IdNzkNDP2Bm5sbq/vbu/fIS509mYeHTvOtd5wiHN3PPPb/DQw9tXESwtiDIgw/+CX/1V8eqspuSZHLggLBOyO9wvGMIWZZdq3JEsSPatrZtFIupRaMHdoSsaUWOHv0aZ878FI+ni87O68nlFujvv60aYc/NHaOtzYqwTVOrCo6USin8/u6KlJ6KaWooihufr4uOju1kMjOIIly8+DKy7KZYTNHevp3Ozl0VkZMI8/MjaFqJjRtvQlG8KIqHROIcqmp1iWcyc2SzF1HVDE5nO7qeRxCymKaMLHtxuXzkcnOAST4fR1F8lEo5otEtzMzkMAwT0yxVLBttEwql5Tlr7SLViKWMGpbCWqPt5TySm9HcNW3vr/liXz+fautkrwXNr3njxidaprOXQ22+thZdnj79YMu6bjNWIq/m+WBorG3ff//nqinlxmPQefLJL1Y61XVqEbAlR3n69MMsrwgm0tPzUvW/yclbGu61olWjbpHQOK+80sJmtX7LBw9uqjzuBYaH/5o77zxMNPoszzzzGEeP7qa//1sMDz/RwqLRiSC0L1rwjI7uZMuWLzMx8TMmJp7j4Yf/jL6+1t3SHk8bv/RLt/L441I1rb1//zKnbB3vCLxjCHm1qJei8/lcFW/lycr/VhOY5cZyiLm5UfL5BB5PG35/D6qaI52erETP44iiNSrVbDAei41RLlsCHapaoljMVPSlBWKx07S1bauMSTkBAY8ngt/fXTGqOM/Fiy+RyUxjGDrZ7AyK4qVYTGOaVDybu/B4uioCBZPoeo729u2I4jlKpThOZ4RQqA8wUZQgmlZAVbMYhk4mM4PD4QV0DMOHaZYroiIa1sW3Nqtcr9y12ij5auFyLReLxcbu4my2u26mVWRs7GG+8Y3HuO66L7Xc7lrr4Ks9T8PDT3D77V/g5z+3SMoiP3HJiHe5xqiVDByAReQ9MvIgBw9+ulr/tQU2ksnNla1IldsEGmuwy/tRTk3dzKOPfod9+77A0aO/yOIabi3N3TyvvFwnup1+tkl8Kb/lpeamY7Ez3H77Pdx770XOnDlKudzY+d7WtpN3v/uPUBQ3gjDJiy/KlZSzzK5dFwiFtpHLTZNITPC1r32cPXs+zt13/1ZDKtvGRz/q5vHH4cABoSGtvY53Lt4xNeRLRTY7y8LCSUCgrW0YjyfKiROPcfHiCwiCRDo9VW3IcjgUnM4AoiihKNYsc70xRT4fo1zOMjt7mPb2nSQSExSLCbq7r0dVC2hakVIpTT6fIJ+fRxRlNm++F1UtIAgC5XKWgwf/nPn5E6iq5RS1c+cnSKXOc/78UTKZPE6nTn//bgxDZWHhJMnkeRQlwObN95HNTnPhwtOYpkI4PFBxt+ohk5mkVMoiywqqWkbXiyiKD5+vDU3TSSRG0XWNVvXjZq9kG6sZk7qSxH306OJmq0vxQF6s6tU40gTiJW+7fh+t5pBbwT5v1shUbSSruSa8lsaoetiNTg5HntnZ3dR3P9easurRbLSwtJkDgNc7RTB4nqmp21rcu/xzmx9X72/scORQVW9DWtvhyDXUtW1VL7tbvP68XH4t2s22be8nkfgtjh0b4t3vdvGe9yQQRYlXX/0qBw/+98pYpEh39w7uuefzbNq0f5G/8TreGVivIV8heDxRIpGh6t+WKcUNFItJ2tu3Mj8/yqlT3yGfn8PtDjMwcAdebxcOh7uhISybnSUeH0NVixSLKUqlDD5fB5IkoSg+2tq2VRvKNK3M9PSreDxtlEoZ/P7uSjPICIZhOVQpih9N8/H6669w5sxpjh9/BVBxuUR27cpw00230d6+E00r4fcP4PW2oWk5XK52JMmJw+FEkjwUCrO43UEs710JQZAoFPKAQKGQRdPyldphCevj0ii/2EooxGihN2HXhe1I+kpH0auxXFwONkkmk/Va1zWZxfrIdK3Rd/N+6lPrzaS6VEe0Xbdu1SUOq6sXt9q2/Xc9mdt1UmsGt1lYwybQVmS6+La9e79cIfpm2I+1PyyWkUMkcrouEherv3fs+Hr1OGv36Q21b7v2Xy860uy3/Hf/7nW0tX2EXG6uEt3qGIbMHXcUCAT2kE4faXGsrVDg1KlvAd9m165bufPOP8Xns0pid9/9T9i164P84Af/lIWFk8zPn+G73/11brrpV7n11n+AovhWuY91vNOwHiFfAgxDI5udJZOZ5syZpxgff5psdhqfr4uNG++hu/sGJMlBJLKlGh1nszOkUufp7NyDrqsVKc4kgiA1ELemFZmYeJ50egrDKNHVdT0Ohwtd18hkppiePkIqdY5Dh57n2LGzpNM609NlXC4XnZ1RZDmBqsKv/upv0t3dwfnzz1EsZnA4XJTLKTStjCg68HjCTE4ewjBUOjq243B4yOXmSaUuomk5dN0ENAxDpFxOYF1Aa1KLtt61jfrUtSCsPMcMFkE3S3FeDlFfqqDIclrXt9/+BebndzVEppcaIZsmPPXUF3nttcWRWXOEu9w+Wp2j5hGjHTu+zi/8wiMN9y0VPTdHi1u3fpdw+FxdxLmqV0fz2FBv70sVecrGLIPTmaRUitAoW1nr0p6cvIXR0ffjcOQbGqy83umqtGXjfsGOiK0FVE10xJbYrEHm1ls/RySyicOHb+e55zwMDx/hoYcMkslJXnvtKyQSr9Wfbe6885/g9W7hRz/6HWB2yTOwc+cnee97/z2BQB9gfZfPnPkZBw78LpnMNJLkZePGfbznPb/fMoW9jmsX6xHyFUbzuJMoypRKKYLBfgYG7iKbvYhpGpTLWQRBIBYbJZOZxu2OkMvNIMseZFlBUXwEAr1V5bBmWGIg0N6+FUlyEo0OUiymyGSmkWUnO3Y8xIEDf8bBg+MUCgrlsoPJyQW2bCkiiiVE0Y+up5mdHcPpTJPPLyCKMg6Hm3I5XRGvbyOfn0eWZTTNwOkM4Pf3k83OYRiWTaMoupAkL4JQQFF86LqJLAuUSmlAa2jgqpfXXG30a5Nnsy725dSgL8XkQZIW15+3bPku4fDZhki71ajTao+j/rU2uzwtpTrVHIXbEbzbXUvVNkfRtTqvyYkTn+Cpp0a5777Prxg9N9eST52qLT727fsCc3O7yGS6KmnnpVLW9TKkFgF7vbMNixxbRKVUCtpnv/6daBinWpylgFyumcSaVbakVcwla7z88n/l3e/+z7zrXfNcf/1Ypf9iE6Io0dW1hUTiPGBL5KpomsbGjTfxy7/8KP/3/97bYpsWjh//GiMjz7FhwzZuuunvMzT0ANu2vZ/u7t384AefZXb2JGfPPsU3v3mWD3/4L6vEvY512Fgn5FWiXtHL5+vE44nS1jZMW9sw27c/RCw2xszMEebmjjA/f4pM5iIuVwRJcuL1dlfUuoarDWOaVuT8+Z+jKF66uvY0KPSIop06jjE/bxG3IIDX24mmlcnnJVIpEIQOYjEJjyeG222i60V03UQQBFwug3x+FqczAMgkk+cpFhMEAj309NyEw+Hn2LGvomll0umLzM2dQFWzZDKzWGnpbCW17UEQnLjdblQ1hx3piCKUyzW9a0laXVS8GlzNxrBW220myeuu+/Ii0q0fdboc2Kn15rRzjRT1Sid8vpKerq+N1kwO6huRatFxLVoEk9HR93PffZ9fsdu6vvnLGnH6QFVD+vjxj7N16/e54QYrjX3o0Kc4dephbNK1o+BWQh1gS1fWR8KwuBEMLL9uz6LRM5uMa68LbCKW5Rya5qU+Mo/FhggEppY4+x4gj2kW+PGP/z7gYPfuv8OmTXfj9baRySxQKqVpb+9nfj4FlAGd11//c9Lp88iyF/Aiy24UxY3T6cbpDLOwcA5NmwNA189z9ux5JiYO0du7hzvu+Mds2fJePvShL/P88/+Fkyf/hnj8PN/+9qf46Ef/73qkvI4GrKesV4nl1Lvs+ycnX2Vu7hh+fx8XLrxAd/deBgffTSIxXhUasSPe2dljTEw8jSBIbN36gepIk8sVJJ+PkclME4uNsLBwhp6eG3A6A/T3W40xzzzzNT7/+X+FKIKutxOPTxCJ5IhGZdraBDZu3MDOnbfg9faiaXny+VlmZ0+iaRk2bNjH3r2fYnz851y8+AILC2MVSU8rWrbGo8TK7LFlqiEIMppWqETBBey6XzZrvXZrsbC289kqXV2PK5W6Xm3UvNoI+FKa1fL5xlq7abZevPzwh79f6aauEVir2qhde9227Tv84i9+uCHlXNkDtspUoyvS6t2iGlFTCQNrxjib7cTnm2Xv3i8BLLntkZEHOXDgdyuqXss7k9jbrxdnsaL+Iewac63u3GpbdjPX6hS/7Jr6nj3Psnv3L1EsxslkpkmlZkmlztLYxChgjf2ZdHTsYe/ev8Nrr/0lkiRwyy3/mGx2lmee+T00LQXIiKIbwyjj83Vz222/zs03/yqiKHPixOO89NJ/RtdFPJ4ADz/8Z+uR8jsA6ynrK4z6cahWyGZnUdUcnZ27mZp6HRAqaeIc0ehgZebYatoqFGLIspO2tm0UCmkKhTjz8yOUSikiEUu4pFCIk0hcrETJI2zatJ9YbIz29mHuvvuTfOhDr/C9732DZHKKri4Xd9xxJ9u334gozhAISDgcIYLBXrLZadLpc8iyA0XpIJ9PcPToo+TziYpMpoFhaEiSE1kW0DQdWRYRBCeCYFAqFbAiBRW3uwPTDFAsprHcdPKsxfS+Ga3IeDmSXg3WOu9so5XYx6X4HrdCc+PbUq/PNL1LzAU31kYrW+XUqYd56qnfJx7f3KDpHAqdYffuRxvqp6s1rRgefoJQ6ExlrMmOPK1mNjs6rj8eex56qQ7l+qax5sXEDTd8mYMHP4UgwA031FTLanKVeiUFDzUSNmkk5+rZw06br6QTvlgQ5SHK5f9GV9dNdHXtpVCIs9g72gRKyLKfTZvuYWjo/czMHGZy8hCnT3+TD3zgf6IoDp577j8iigqy7KyUf4q88sr/RJb93Hzz32XXro/S0THMD3/4L8jlYnz725/i/vv/U2Uscf1y/E7H+idglVgpQgYr1VwqZXG5Asiyg2h0sJrmtvWtVTXH9PTBylxxFy5XGNM00bQihlG7CKhqjnC4D9Ms09a2jXT6IoFAL/PzI7jdYR566ANs2CBhGH34fALhsEhf3y2oapH5+RFisRNomo7TGcLn60XTdAxDR9NyJBLjgIjH04GmqRSLSQxDR5Jc+HwdgFkRMzERBBlVzSEILoLBfgTBJJ9Pkc1eRNcNah+h5gtYyzOETTSt1Lh0ffUNYWvBWp2pWv293ONXishXa8Sx3FywnQo+ffoDdSRVE9EAGBr67qrkOFfC7t1/VdfMZZGeacqYplB3bJZT1moMMoaHn2ggWZCqBNzqeapaW5jYOtrpdD8zM9fTyqHJPk6f7yLZbN+KKl5L1dRnZl4lmZzFsiF1YH1eHTgcMqqaBFxs3fpBbrrpM4RCG7jvvt/niSf+Ic89t42vf32MX/zFv8PevSlGRh7HMAx6e68nFjtNMjnJoUP/i/7+vfT03EhX13V8+MNf4rHHfoViMcMPf/jPuf/+/0RHx85VvT/ruHaxTsirgD2OZJoW6bSKlG1XKEXxEouN4XaH8fk6q2pftmPU7Ow0gUAfgiDhdocoFJIUiwkEQcDr7QCs8are3lswDI2BgX0VcwpLzlOWnYBVg45GQ/h8wYql5CSx2GnC4c0VV6tp5uaO4naHkWUvbncAw9BwOn14vb3kcjPk8wvouoqmlREEFbc7SFfXdRQKC+RycVQ1h9MZwONpwzRV8vk4gmBFKobhwLo4ClhiIdnVnMmG/5ojUbse/WaJi9QfC6z+GFZL3CtheLhxdMvhWJwKjse3NBCyBSsEFwQum4wB7rvv8xw//nHi8a3YEe3Wrd9h794vc/r0hxoi5NXKV9533+fp7X2ZQ4c+heX2tDSaFyb2GFZ9F3nzWBRANtsDrLwwad7+8PDZ6raKxQuAiNvdi8/Xjt/fRTA4wKlT30XXNSRJIhDorWTMukgk/gX//b/fhijqfPvbEt/4xufYsiXP2Nj3mZs7Qm/vbZimQS6X4Mknf4OPfexrBAJ9BAJ9fOQjf8H3vvfrFItpnnvuj7j//v+Ix9O24rlcx7WLdUJeBWx9a0GQF0lp2rBT2ppWpFhMYpp61coxlTrPwsIYLlcASZLx+3sIhzdWJTYdDg9ebwdebzvFYgJRlBuavAKB3oqHc1t1PwMDt3Hu3FMIgojb7SMQGCAUsr7ofX23UiwmmZl5nXj8BB0d11WibwGQMM0ykuRBln04nT48niDWRSiCnWoXBCtdKcsewuENFIvJSlRsYpqWh7L18REqXdZ2erN6RirnJYBhJFd1nu1ubZuUYfWkeKkjTyttcyXTiCu9v+bmsWZSqUlpLq6jrtwNsjqMjDzYRPpileDs5i+HI79ql6V62B3cy0l/LqUw1rxvhyNflyEQsUl1pYVJbfvvYu/eae6+ex6H45c5evSvsObtDQqFDNu2vQevtwtNK1fKPwvE4+cYHX2KnTs/VDlXe5EkA123JDCff97NH/zBvwBMLlx4noWFI/T338n4+FNksym++c1f4qMf/QqBQB8+XxcPPvi/ePLJz1EozPHUU5/nPe/5Q1yu0KrP5zquLSzfZbEOwIpYfb6uRc5PUJtJ1rQi2ews09OvMzX1KrncAh5PlHw+xpkzP+XUqceZmTmMJLmIRgdJJMZJJscr84lOvN52PJ4oHk/7ItK3x6yy2WkuXnyp2qGtqjnK5RwuVxuSJFEspkkkziGKMoOD76Gr6wZCoUGcziA+Xy+GYZLJzJBOz+D1hujsvJ729m0EgxtwOgMVu8YY+XwClytckdA0KBQWUNU0uq4jihKalsUyqTBwOn00XhBtCIiiu+IF20LKawk0k8pqiHapxqqrQZgr7fdKohXB2unfrq5DVbEMO/NQb3xwObBTuva2t217rEpww8NPcP/9n6t0bx9gfPxeRkYeXNN261PFS8HeT7OIycaNBypjXwe4777Ps2/fFwiFztY906qt147JBSwW4rC2/xt0dHyRePwC0egW3vWuLyKKnsojCpimA6cziCRJdHRsp6trB5pW5uzZn1AuWxmhd79bQdfFBj1qlyvE/v2/zYYNd2MYEI8f46ab/iFeb4hCIcEPfvAbFItJwNK03rfvXyJJHtLpi7zyyv9B067yB2sdb1msR8grYCW/5Hw+RjY7zfz8SdzuEMViqpqetn93de1G18sEAv3VLmvT1AiFNiKKMm53uBoZ16fDbbIHcLmCzM2dIJ9PcOHCSwQCPbS376CjYyeRyAbGx5+lXL6Irpcol/O0t29j69b7SaUmMAwH8/NH6ejYSblspb0HBu5hdvYwhqHh83VQLCZxOAKVWrZONhurpNKtiFUUJSTJiWHolfEPi4B9vh5yuWmKRYugczlbqUvH789V/l553VffzHW5jV1vJK5mer3VORgZebA6pzszc+Oa/IBXi+aUrj3y1HwcS5k2rHa7q0l1t9qnrdC1Y8fXq45cFqyFYWNd2ya3AC5XF8Xi6aatamQy54lEtrJt2wN4PEF+9KPPUi7nuHDhaTZtuo++vluYmXkdSXIzMvJNYrHj1Sj5oYdoqUetKD7uuuufUS5nSCTOMDd3hHe969/w9NO/Tz6f4KWX/oQ77/wnyLKLaHQrN9zwdzhy5K+Ix09x9uxPGRx873qT1zsQ6+/4CmieP26+zeOJksvN43T6EQSZDRvuJBDordo82nZrth716dPfZ+PGuzFN8Hrbq6npbHYWw9AaBEPy+Rjx+CggVKwVh5mbO47D4UIUJaLRrbjdESYmniefj5PNTqPr1gWoXE6TTl+kXM4hSU40rYCuq5VZ5RJjY0/S3X0LkuQglbqAYRiVTvECc3PnOX9+Hl23bAr7+nJEIh1IkgPDKCBJTqwREB3LSs+qM9rqXTahZrPg84mspFdc3/TUSorzSmOpLuo3G6tp/mqOMlXVc9l+wM1YjaPSSmIjl7pdG62kPi0pz9r414kTn8CuY9dmtJci+3RlOmAxdL1AIjFFOj1JPH6UjRvv5syZA2Szs0xNvcDOnX+Ix9NGMNhHOn2eiYnnOHPmu2zZcg8uV4iHHmptDOFyhbj11l/jZz/7tyQSp5mZOc511/0SR458nenpFxkb+xFbtz6AKMps2fIeUqlJpqZe5syZn9DWto1IZMuy53Md1x7WU9YroFUauf42UZRpbx8mEOijvX0YRfHR2bmrQUTeskwME4+fIZkcZ3z8GUqlJMnkOPl8rJqSLhYT5POxhv1EIkNEIoNEo4M4nQEikc1oWhFVLeL3dzE5+TIgoetlPJ42PJ52JMlFNjsPiNXxKksXO4Guq6RSUywsnCIeH63MKc9jGAZud5BiscT58/MoCrjdMroOiUSMQqGIorjRNA1VLSKKVlNXLpegVEpVj9kwLJEQh8OO8Jpry61Rn2KuT9WuFH1ejmnFSmntN6OxzD6m5Tqx60ec1hplrhatUsZX4jhW2i7UIuGXXvp1Hn30O9X0s2Uk0TiLbZOwrfR1663/ddXGGhas7vGxscc4ceK7TE6+Qio1idcbolwuMTb2E6amXsPtDqMoPu644zeIRgfJZCY5caJ5XnsxwuHNDA29D3AwNfVzOjp20td3C7qucfz43xCPn7GOQnZx/fV/m2h0O7pe5vjxb1XT4ut452CdkFeAnUauTx8139bqMfW1ZcPQcLlCbNhwF52d17Fx4904HD4cDi8ulyUj2Ir47eauQKC3ktoaxO2OEokM0t9/G5pWxuvtAnS6u68nEhmkr+82ZFkhm52jVEoSDA4QDPbT0bEd0xQqHZ49yLKCaarMz48yP38K01QBAVW1VcFAlnVk2QFAqaRWjskJWONULlegot6lVe6zyFgQaiNMNUWm5VCrMbtc1thTPSkVi7WfeqyGjFf6f6koeanxpeWw1HFeSdhR5tqJ5+1zHEvVmu36ua1bDWIDCd933+dXJPvF0BEEJ4nEOc6ceQK3u5NweBPB4EYkSSKdPs8Pf/g5ZmaOVMpUbWzYsI9yucTCwokVSVMUZbZv/wjR6BC53AJHjjzKzTf/KuHwIKVSkkOHvlLdhqL42LXro8iyQjx+mpGR7zWMQq7j2sd6yvoKorm2nM/Pk8vNN3QPd3buwjB0SqUUpVIav7+7boyitfBIvZlFqZTC621Hll3099/G9PTrJBJnKJdziKKErpcIhTZWn2eaJoVCHFUt4PO1k8vNYZqgaaWKtrUDRfEiyy5UtYjXaw0Ba5oljZnPq8gySJJGsZgFNHTdQJJMRNGJaQrougpkcbmsNHWpZJGXxwNWNLOSeMjShF1PboZxaTXbpR5/KdH1Umnl+ttM88rVllvta7UiH1cbV+s4lqs12+NTq0l7rw4mmpahXC5TLCbp61NwucJks1PoughkSKeniMfPMzj4HgAGBu5gYuJZEonTnDlzgO3bP7jsHhTFx003fZqnn/53lcbPo+ze/Qs899x/JBY7zsmT32H37l9AFGWCwQG2bHk3p059n8nJF+npuZ62tuYxt3Vcq1iPkK8gag1eI7hcQTyedsLhjZgmhMMbqxGwxxPF7Y5WdKZXt92FhRFmZg5RKCSqt8uyi3I5Ryw2iiBIRCJbcDi8iCKEQhvx+ToQRRlVzRKNDqKqBWTZjablME2TZHICWVZoa9tOOLyZ3t6b6O+/gf7+3WgaqKpJMAidnUE6OrYSiWzA7+/H5bL0fA2jhKqmkSQRcCEIHnw+D9FoBJ+vDbDIvViEXG6xQ1QNq4sC7PqyHYXq+pUb9VkLVkorX6mGtDe6q/utgpWi79WkvcFKfT/55BdX7AI3jAxQQtMKlEpJRNGBLHtxOj2Am3K5yNTU89Xu53B4Mz09N2IYJlNTL64qtRyNbmXr1geQZScXLz5POLyZzZvfjSAoTEz8rJq6FkWZTZveRTi8mVIpw5Ejj66nrt9BWI+QryDsBi/T1CkWUxWBjtnKXK1VZ81mZ/H5Ouns3FWNppeD3ejldAYJBjfg9Xbg8UQrc8lRgsE+XK4QXV27cLlC5PMxZmZeR9d1wuENdHdfj66rzMwcIh4fw+kMMjT0AJnMNOn0eQKBflQ1i6KE0fUiwWAXu3fvZWrKSy6XQRA0AgE/GzbsQ5bdnDnzJKHQJsLhzcRip5iePoIgyBXjizyFQhIoEQj0UCh4icUmqoIfmmYR81p1r2vnorHpS1r9NNUbBl2vCZy0wtWcY76WcLnRd6sucGBJv2kLKqVSAbc7Qn//HeTz88zNHadUyhOLnal2VouizJ49nySdvkAyeW5VUbIoygwPf4iFhRESiTOcOPEY1133SbLZGeLxMU6e/A633/7ryLILWXZx442f4oUX/hOlUpyJiRcYGnrvJZ+Ldbx9sB4hX0HYDV4+XxceTxTD0NC0IrpukWo8PkY8Pko2O7uiDKeNfN4aP/L7u+no2InbHWZ+foRsdoZ8PoYkOXA6A5RKKRYWRtD1MoVCkoWF48Tj5zh//gVyuXl0XcfhcBMKbaajY5ienr0MDOzD6fRX7BXzFArzpNNzeDxt9PRsZ+PGnXR2bsDtjlT8nMfIZufJ5xcoFlOV9LeKw+EkEulHEBRMs4hp5imVspTLFgGrqhUd63WZa0HwIgheLAee5ZnVaBT4wjRrP6vBUrXdlerLa4H9XLuG3mpb79SI981Acx364MFPtWwUa0Y+n2Bu7gg9PTfj91v+5v39NyMIEiMjf00+vwBYHdQdHbtR1cKqo2RF8TE09H5k2Usmc558Psb11/9tvN42EonTTE6+Wn2syxVi27YHURRfpSS1HiW/E7BOyFcY9Q1e+XyMZHK8kgaTiUQGiUSGAMjn5xs6qpeC3exlbzOZHKdQiCEIEh5PtOLlahCLjROLjRGLnauIhUQqaenzxGKj+P2dDA6+n66u3SQSE6RSE5TLGUTRiaapmKaGKDpRFBe6XsbpDCCKJqpaQFVTpNMXSSQmME2dcjlHPD5CPr+AaYIkyaiqiq6XsJIujsqIyTwOh0WosmwRqKoCODBNo1JXX3kkyo6K7d/2UwxjMVk3YyUSXCn9vBZcyW3Z21vu/3UsjeYu8HoXKKtRrLWvcbE4yezsYSYmnsXn66Kzcw/ve9+/JxTqJ5OZ4pVX/rTaaLV16wOMjn6Y//Jf7uFLXzq1quPq7t5LZ+cN5HIxLlx4iWBwgLa2HZRKecbGfthAvJ2dewgGN5JOT3LkyKPrgiHvAKynrK8irLElax65vgvbnjVeKV0NjS5T9dvzeKKk05NoWh5RVCoR80IlOvPjdkeIRLYwOfkyuVwMh8OFIEgoip/Z2SN4PGGy2Vmy2Sny+WQlJd6L293NwsIxCoUks7NHSaenkCSJYHAjTqe/IhAiUyzmkCQXXq8XhyNQWSQIeDxd6LpOqRQDdFwuB6qqomkWKYdCYDvngBNRVND11k1fuZz1u1Vq2vZgrse1SFjX4mtaGywP45WwffsvEIkMc+jQX5PPn1408wxUdLjtRrFnqDc7qUe5nGR+/ig9PXuJRDYjy2527fo4r7zyJyQSY8TjZ2hr28aPfhTiX//rX0IUdZ54QqK3t/U8cj2sZsybSCROs7BwknR6kj17HiGbnaRYTDIy8j127foooigjyy62bLmPQ4f+nFRqgtnZY/T23rTmM7iOtw/WI+SrCJtMDUNjdvZYdQQqn49VfY/XMtZQPwZVLKaYnHyF0dEfEY+Pkcmcp1BYwOFwE40O0t6+nWh0CK+3A8MocP78cxQKMZLJs3g8kTrtaRGHw4MsO3A4vESjG/B6rcVDqWRiGGVU1aBczqKqWfz+nopUp4IsuwgGe1AUJx5PG+3tg0Qi/SiKAzCJxcqkUta4lNsNoVAAy4hCwyJjB8YSIW6xuJh06yPQVj9vdSwV8b4R41JvT3hW1fioKIOEw0P4/R1cf/2H2b79YwwMvIfrrnuV++//V9V69COPfJxbb/3vPPLIw2zf/kNAwemMYoncNGJm5mUKhTgdHTvweKJs3vxuurr2kslMcezYN9G0Ij/7GUiSiWFYOtYHDqzuVXV27iEa3U6plGFs7CfIsott2x5EECTm54+RTE5UHxsMDtDbeztgsrBwaj1KvsaxHiFfZeTzMaanD1alMS2BkFGczhCSZJ3+5XyWW8Fu9AoE+sjl5tA0nUBggFRqHKczhKaVicVO4fFE6eu7jVjsNJHIEOVyAZ+vi2IxjiRJ5PMCgcBGOjq2USrl0bQ8giDT0bGbl18e47XXJvB6S+i6xtatMl1dm3A43KhqiXT6LIoSpVwuIIoyDofVlZpKXURVDSYniwiCNfoky1ZDl2X4bpGxJEnoemvlJBtrUe0qFmtNX80Wim+lRqqV5qDfTKertxK83s1VF7PWEPH7NyLLDkTRVZkcAElScLvbCQY30Nm5ndnZY8zOvk6plGZ4+BuVZi4N05QQBJFSqVT5TuTQtMYS0iuv/C9uuOFvV1zcfGzYcAczM4eJxY4zPf069957G3/8xwKSRFXHejWQZRdDQ+8hm71IJnOR2dljdHbuIRx+lbm5w1y48BKh0IaqYFBn507m5o4Ri51ej5KvcaxHyFcZHk+U7u69dHXtJRzeSC43j2HouN3hlkYSy8GeR7aawuaRZRe9vbfQ0bENp9NHKDRAW9tWurquIxDoRxAkdL1IINBLOLyJtrZBVDVJINCLJLlRlBCK4qRQSFAoLGAYBpnMNCMjL/DUUz8knXZgmiEWFpy89tokHs8eenvvJJebQxTdOJ1OZNlNqZQjm52jXM7j83UBftJpixxl2ZpLTiZhelolFjOJx0uV2WUbDgTBhzUm5Wh6zUudjdrjmmU3L7dOvB6xXhoUZQhJWmzksHa4kCSh0n+RwPpc1F+q2ujsvJ6+vpsJh7fg80UQRReCYPmKm6ZaaZiU2LnzozzwwJ/g83VjzbuXcDj8CIKCwxFEliXAhWEsLpscOnQjH/vYy3zjG1Zdd+PG/QwM7EOSHJw7d4D778/y+OPw2c9aetYrpavrEQwO0N19C6qaJ5OZQhRl+vtvQlG8ZDIXSadrC5FAoJeuruuQZTex2Nh6lHwNYz1CvsoQRZlQaAOh0Aay2dmKjaOEz9fZIK+5GthzzpawR5F0+iKdnbspl7OEQv2oapFodBCfz1IbsiKMWQqFBMFgH5OTBwmHt6CqRcLhAVyuAJpWIpW6iK6rCIJIOj3H1NQhvN4iHo8Hh0MjGlWYmyuysDCNwxHH5fKiqj58vi4yGes1qWoBw1Dx+/vxeufweKx0s6ZZhDw5CQMDFimWy5BIlAiH7fS1Ra4OhwvTFNC0Ai5XgXy+1sD1RkWN6xHrpcPhKGMYlzuE7cbpdFMopNF1e+a+fvEWYtu2u5EkFz09e/H52imXNSQJisV0RXAniyi6iEa34XT6aW8f4sMf/nO+8Y2/Q6Ewjapm8fl6ABeyHCCZnAVSDUdRPzb11FMy3/hGgY9+1MeePb/Aiy/+V+bnj3Pu3LM89ND710TENqzyUzeK4mVh4RRdXdfR2bmH+fkxYrGTzM0drwoGWbPJ91AoJKoR9XqUfG1iPUJ+A+HxRJEkZ9UV6lKeLwgygiBQLucol9MkEuOYpo7D4aW9fZhiMcH8/Ei1Nl0qZTBNnbNnDzA/f4yFhVEEQSCTmcEwDGZmjlAsJnG7wwwNvY/Nm+9jy5b3sbDgwTByaJpOsVjE6VRQFJVCIYGiBNmx4+N0dd2MyxXC42kHypTLeVQ1TzgcZcOGLjQNEgmYnYX+fruhq17nGuzGGtM0UdUSiuLD1r72eGoymotxbawlr6VO6lwudtlCLYoSQZZDuN2WR/diFBgcfLBirBLG5QpTLsfJ5+cr0bGGy+Wju3sXbncUWXYRi43R03Mjt9326yhKJ4LgoFwuIMsGpunC6Vz8WWoem/rrvz6BphUrke1eDENndvbQZY0jdXbuIhIZplRKMzd3vDI2uRVBEJibO94QJdvSuYZhrEfJ1zDWCfkNRG1OuXtNqerFz++iv/9Wurr2oiheCoVE5eIUJB4/SyZjiQ3EYmOYpk6hkETXy8iyh+7uPXi9Hfj9XczPn6RczlAoxCq61AUA9u59Hw89dCuyLGAYBWRZ4M4776W7uxuQMIwSs7OHEQSZ7m6rE9XpDKDrJTQth66XCYVCDAx0s337IPfc824cDitazufhwgXIZMBKIUoIgn1BVMnn5/H7+yr/LxVtyUC5+p9pWjPO9s/bjdTeTo1py0NH13Nc+mJJwjSLCIKGyxVGksJN9yv09t5KOj1Bd/f1mKZBInGeQiGFLPvp6NhJf//dbNv2IXRdq9w/zvz8MSYnX+OWW/4eu3d/jGBwsOKKJiNJAk5nhOZSSfPYVCDwfzh37hlEUWbDhrvw+TqYnz/JuXPPXuJrtUi2mYCbSbq+6bOzcxfB4EA1Sl7HtYdrI8x4G8Eed7I7rYvF1KoEQuphGBrFoqVpXShYjShWHTiBaZpIkoNIZLC6H11X0bQCgiDidAYrUUMMh8ODaRo4HD7On3+JXC6JLEu0tW3jfe/7GP393aRSSdxuuOGGB5EkN5Lk5MyZH2B5IVuKYwMDt3P8uES5nCaTmSGTma5kAtzIshNZtupzqmoRpqWNXX01WCbyeazUpEomcw6r81Wt3GdHAyKSFMEwCpimdZs9GmV5Nl8+qb3VmsDePhCxmvag1SjR6qCjqjFUNUY2e756q6JE2bHj4+i6Zf0pCAKlUgpF8eN2hytZmX78/m6Cwf5Kr8U0pmnS1XUdyeQ5gsE+NK3Eu971r9G0LGfOWMI2AwO3omkFRFHCNCVSqTGgtGhsqq/vCZ555gTd3Xsqnc83c/bsz5ibO8KmTfsqmZ21o7NzF7HYGVKpcebnRwgEemlv30o8PsLc3HE6OnYSCm0AalFyKnWeWGxskavcOt7+WCfkNwHNxhOw+k7reo/kSGSQtrbh6nZcrjCRyBacTj9Atf5kpainKzXoKbq6rqv6NTudAc6ff4ZE4iyJxGna27cTCvXjdIbZvfs+5uZOoqoZnM42Oju3oygeRNFBLjfN7t2/QDo9RS43jyQJFIuxCvHrGIZYMbsoks+n0fWaLaPbbQuEWAka08zSeBHXKz8OLI1sAdMsUG+5BzqFyvVfkqzmryula71OwjW0WpyIYhhRNNA0EEUTRfFimg5KpfOtN3KZKJcLZLMX0LQifv8A8fhpvN4uTDNLsZjG4wkDAvH4Ofz+TmZmjlEqpXG5gpimRii0CVl2kc/P4/G0c+ed/4xk8jxTU4eIx8/i9/fhdAaxFoBbSaVGAZnh4e8zPPx97M/mxYsv8+STn+Ohh/43w8MfIpGYIJE4w7lzz7Jt2/sv6bXJsouBgds4fdqyY7Wj5Pn508Tjp8hkpquEDDaBj63Xkq9RrKes3wTY6lvR6OCaO63rPZJ9vk4CgV46O3fh81muUX5/N8nkOJOTL1f1riXJSTDYCwhoWhlF8REI9LJp0z10dGynrW0HXm8HTmeQTGYG0xTx+7txuUJEo1vx+XrQtBylUgaHw4PHE6GjYze6rrKwMMbFi69SKmXwertxucLIsgdVjVMsZjBN8Pu9CIKAIFjRsdNp1YcdjjCyrOB2d+B0hoEQguCnNheqAiVM06jcJqLraUyzNi5ljZzUq4Ct40phKZUzw8igaUVcLg+hUD+h0ACRSBcOh93JvBLcazySPGfPvkQul8I0y6hqiVTKUsDL5WZxOKwu7HT6AuPjzzE3dxQwEAQJVS0gCEIlM2V916LRrWzadC8uV5RXXtnLV77ydzl69F683jY8Hhfd3dczPPwBAoHNWFmZAOAHDEZGvssrr/wZsuyip+cGwGRu7shl1ZIDgV6CwQGyWSu7ZKeyHQ4vicR4Q714vZZ8bWOdkN8E2IIhsuxa5KO8mufa4iCt/JibnaTsunNn53V0d1+P12sRNFjRttfbTiDQQ3f39bhcAQyjzIULz3H+/AsUCnF8vg42bboHtzuMphVxONzouka5nOXChZdJp88Ti52qROMOXC4fsuzG6+1AlhUikS1EIlF6eraSy0GhYHVdt7d3EAxGCAR6EEUTrzeCy+VGUdw4HD6sC7uM1YVtUiPpWk3Nls60/ZffimYTK+MKWUO9AagJqpk4HG7a2gbx+7solfLE42crPQgrpSl8NNdrawhgKXMthmEskEpNIMs+Ojp24Ha3YRhWdC4IMqIoVQVtTFMlGt3K0ND7GBx8D21t2/D5OqvfEVGUufnmv8fs7N/jq1/9Gk8//Qn+5//8Q44de08lUrZmlHfu/AiS5EXXS0SjG5HlALqe5cUX/zMzM4fZsGEf4fAg2ewMExMvXMIZtWB9f9uRZXeVgJerF3d27iIc3kS5nGZ+fuSS97uOtx7WCflNhD1XfCVNyC0hgV10dOyqqoTl8zF8vk42bbqHvr7biUYHKwYV0xWN7S0EgxvZsePjDAzcg8PhJ5EYJ5E4T7Fo1aUNQ2Nm5jBTU4cplzPkcguV33EUxQvIZLNTTE8fqQiMCDgcbhKJc8Ri80Sjm9i1611s2jTMrl230NHRQyDQh6bpaFqJRGKqUhvWEQQR68JuYhGWWRFRqb+QO/B6a5GxJF26i9Sbi7cuIdtlAF23avUWIbsQRS+SpGCaBl5vJ6VSnFJpAUiuYqt5YClBmDy2TKYotuP3bwai2OYj5fIC5849g6JEcLsD1UyNxxPGMFQkyYkoOivqbw5yOassVN+jYX/nXK4Qk5PvRxQ1DENGkgwmJu7D7Q6jKC6KxQUEQaStbRuCAOVyhi1b7kUUveRyCzzzzL8DYPPme1EUz2UbQDQT8HKRsBWd78XKGJWu6PVjHW8u1gn5TUQ2O8vCwgjZ7OwV3W6zwUU+P08qdZ6JiedxONzk8zFSqQssLIxVyBQMQyeftyJiVc1Vmlw0EokJ4vGzpFIXyGZncDhcyLIDn6+ddPoiiuLC5QrgdHpJJs9RKiUoFjO43SEUJUQqleHgwRd47LGn+clPXqFQcNLZ2Y3b3U6plMPhcCNJDhwOBV0XMQwNVS1hEZWCFRELCIKIwxGs3CZjpbMdeL0OgkEHXq8HK/q62pArafUrAQHwspLb1ZsFj8ci5HTamh0PBEK0te0gFOrB5+tBFB2oahZNW64b3okoBrEWU621o63bBUBDFH20t+9l795H6Ou7lUikjc7Om3A62wCTVOossdhpRFHG7+8iHN6AIEhkszOYpk57+xa6um4il5vi3LmfMTHxDOfOPc309OtoWrHynTtJNjvLww8PYBgyoqij6yLvfrejEiELFApZFhZGUBQXDkeIQ4du5ytf+RSx2D9BkmQmJp7j4MG/pL19B35/P/H4mcuKklsR8HJRsiy7cDr9Fb35pdTM1vF2w3pT15uOy+9E0rQisdgY0ehgQ9elLbHpclmWjRcvPk8yeY5QaBOZjPUlnpx8jWIxQS43gyS5cLujbNlyH3NzI+Ryc2Sz0yiKn87O7RU1I7MSOekMDd1f0ec2OHv2x8iyD6fTwDQFJMmJrmuMj8+Sz4t0dDgwzQLHjx+jrc2PomiUy0UymanKxcWHphUAJ4YRwzQtk3jDUDCMImCiaTlEUUFRPBSLGazRJwcWadsCI0rd7VejqKxhmldquyZWZ3Jrcw2LqGUsI443Bx6PhMcjAg4kyaRczuLxRBAEk0IhRSYzRbl8seVz+/vvwjT1SjalSC43B+RaPLJG0oah4/d3oaoFvN5oZSrAy003/QNeffVPKJUSjIz8DZqWxOPpJBIZpKNjGF3XUBQ3Xm8XguAgkTiLz9eLxxMiHj/D/PxxALzeduysxMc+5uMrX5nkm988zY4dx7n33u3Mz19PoZDEMEpks/NIEoyPf4KvfvWPEUWN73//AX71VxP09f0Fr7zyP9i48S56e/eSyVyoRsmX13Hd2LC1VFe1z9eJyxUmk5kkl5tvaPxax9sX64T8BsFOHdenz+rrvpeDWGys0nltfalt2F7KHk87/f23AuB0WvXZQGAAjyeC2x0mFivh8XTi8YTx+ToRBIlIZBNOp49MxoUoiqTT0+Tz85TLWRYWTldqxQpebztOp0J//124XBHy+XkWFk6TSJwlnxcwDBO/34HbnUMUTdJpk2w2iddrVmwZHSiKH13Po+tlNC2DYVjjT4ZRwjRNZNmFppWwyFCkVMpS68Q2qC1qFARBxjTFSu0vzpVY8CzGlWykWSrdaJHgm0nGtpWmdQ41dN1E1wv4/V0oiofp6dfJZKZbPtPhaKOtbZiZmdcBB6IosJiMFTyeLvL5GWpz5Tq5nFViyWRmK5GvTDS6mRtv/DVee+1PMAyNWOwsihIim51FECRyuRlAQJJcaFoZQRCJRjfj93dTKmUqJKtVv3/2d+6Tn+xkcPAxzp07wMWLWXbseIhMZhLDKKPrBTRNZ3LygWpqWxQNstm/h6J8g3w+zgsv/Gfuv/8/VqLkMSYmXmBo6L2XdrZlF+HwRmIxazFsGNqSXdVWb8g2CoUE+XwMTSuuj0BdA1hPWb9BqE+V2ahPLTdjLfXlaNTyWbZHmezn29GxxxNFUXxs2nQPgUAfkqTg93cQDPYTCm1Alj1IkgNJslyb7H1GIlvo67ulYlZxFitikwgG+/D5+tG0LPPzR5icfI18fpbe3ltoa9uB0+klHN5CMGi9NlUtUywKmKbB/LyJx+NCUUKEQv309d1BT88NuN3tgIxhiFhRroBhaDidPgTBhUUKZaCIaYqIoreSOq7v2C1imgaC4CAQaMfhiKz5faq8My1uu1JpZQ8rrYNdrgGCwS3IsucK7nctcFT2qwElJMkNyJUUdYFkcrKSJrUzEs1wMzBwM6VSrlIymSOTObHoUZIUoqNjOz5fLboTBAdtbVtxuQKUSgsUChny+XmSyfNs3nwXW7a8B0FQSKcnUdUsvb03sWnTPgKBPgKBTpLJ86hqBlGUSKetyL2//zaCwX4WFixzhvpFsSjKDA29h1Coj2x2krm50/h83Xi9URQljNsdZvv2QxiGJRJiGCLbt4/Q1XU9pikyMfEMo6M/prd3L4riplBYuKzOZ7+/G6+3m1TqAun05LK15ECgF6+3jXT64npz1zWCdUJ+Q2GlyprJthX52rXffD7Wckv1kGXXIpGAbHaWeHys4f90epKFhZEqUdv76+29CdM0yeWsiKRUSlVGRnLEYqOkUhMUi7FKE81O2tt3EAwOEIlsQZb9yLIDw9Dx+aJ0du6ho2MXgUAv/f072LixG1E00HUNTYObbx5maGgfbncARfFTLmfIZCx9YdPUsWvGNinIsg9JEqilnxXc7gBOpw9JEisqX3azlwSYmKZGPp9AVWtqXmtDqzqnAQQRRe//396fB0l2Z/d96Oduee/Nfa2stau7UQ0UgMY2WGfDAKQpKobDHovSo2k5bFqiHfIfWkL+w2H7H4cdli2HXvjJ8h+SxaDDpJ8pvfdkvcBQlCkuA8xwZjgcAgQwAAYNoBtd3dW1ZuW+3Hsz7+I/7tJZhWqgNwyqCr9PRAfQ2VmZN5e6555zvud7uJtetSTFJfaDGIBJLneOQmGWanWVSuU+bq5I/rTIkU4vTD2vimmGaviwkmGzt/ceW1tvEwQTZDmIxoIy0fGf5ty5v8jc3BcBF8PIc7Mqhef16Pe3MIwsur6AYcwwN/cFKpUV6vXHKZcfxjQLFIuLFIvL+L7Lk0/+KplMhddff5Z/9I9+hu997z4qlftZXHwOWdYJAg9dLzIz8xCeN2Zn5x2GwwajUYMPP/xDdnffZmfn7WiXeNhTDo0+nuP737+f/+K/yPL979+PJGmYZhFJknjqqVf5T//Tv8fzz/+/+dVf/TWq1X9APj9HNlthPB7x2mu/Ti43T7X6MN3uOleufOeOhVbxIhjH6SUWuDfrJcuySqWygqZlGQx2xAjUCUCUrH9KTJen42Ab337w70BSUru7cnZ4Iowf3/NcHCf00FZVgyBwGQ4b0aKKq/h+AChkszUqlfuStYqOM8SymlSrD2DbrUhEs0Gr1ccwClhWC11PUyrdx97ee1hWi8nEwbab1OtzVKuLuG6abDbHE0/8Jfr9HTRtk07nEsNhG13PEAQ+shyKfgqFWbrd64DHeNxmMrFQFBPP85AkE8saE6pxHcL9yuHGHlUNg4jrjnDdcTKjfIPQUOSjxONVn/ReOihKAd/vTN0e75XejywXUNUc4/H21GObBMHNStA2qlplZuYBcrlZbLuD58X3NYhFbPe2XA5hIB0RvwZNU9B1HVk+xXB4FUkqoKpqJLTz8LwA8JFlmEx6qGqG8dhC03wURSKXW4gWJvyY4XAP1x2jaTkc56PCRUnSKRaXURSJpaUv0u+vYxgl5uefZHv7bba2XsXzHIrFZcrlFQqFRYIgoNv9L/nt3/4VZNnlO99RmZmBb3xjFde16XTW6HTWgCX6/W16vQ1su0Oz+T6SpOA4A1qtSwyHu9GqxiIA77//Df77/z6LLHv8zu8o/A//w4QHHvj/A6G5zV/4Cx2effZt1ta+Q7+vkM1Wqdcf4erVH9DrXeGNN36b++77Gfb2fsLOzo+p1VbvqK8bl6K73WvYdofBYId8foFKZYV+fyPZoR5n+HGW3OmETl9zc4/f/ldAcGQQAfmnRFyeBjCMAsNhA8MoAIcH3+n73wnxBYBhFCKbzrB0ncnUkqv30G6zRbv9IUEQIEkyqVQa0yyTzdax7S5zc49j2122tt6g2XyfYvE0qRQoihIpq9eRJAldz0e9ui66nieV8pFlBU0zMIwKQeCSyczQbF6Myo190ukKQaCgqjK+bzAYNNH1ArY9IBZqjccKhpFB0/L0+z2uXWswHkOpBOVyrO6VkKQA3/dR1RSqaqBpacbjEdPBdjTycJxwRCqfhxt92tBT+6P9WpMwM45vt5lMJuwP6odnf6lUgUplmb29IApGLjesJeOLiNG+n3HdPQaDXYLAizL8EalUjslkBGiRQUrMzRTLt4tCWHYOX+NkMsZxxsiyj6LkSaeL2HYHXS+gKEo08+1HSxzKVCr302i8R6v1FpOJiqalohl5A8v6AYqiMRhcmXq+NHG/uFo9R6FwimLxNIPBJpbVwXVHXLnyXRxnD0VJkU7XOXXqaxQKy0wmFppmsL7+c8iyH40rBbzyisSFCyqZTI3JxMK2O/i+TxB4FItnoz5zeFxzc4/jeWOCIEDXcwRBWKF6+WVQFB/PU1CUgEuXnuKZZ97Att9C1zMoikalco6rV79HWIXxqdefxPcnXL/+Z7z//kucP/9LlMurhzps3Q6x2c/u7ttJ1luvn2c0amHbbXq9jeSxZVmlVDpNu30lGYG6HV8DwdFClKw/A2y7iySRbHz6uF7ynRI/pm13se02sqyiqgb5/AKqajAe98lkalSrD3DmzIvMzj5OPr+A5zlkMjUGgx2uXfsBg8EOtdoqiqLgOD1su4ckhX7XMzOPYJplfN+j272G645Ip6uRKUgG0ywBPsPhBru7b0Wlzlfp9zdJpdLk88sUi4voeo7xeEguN4OuZ6NMV0eSstTr58jnl1DVIteu7eF5MqVSaMHZ6QSkUiV0PY9pFslmq6iqgarqyHI6UruGPdjh8Ia1puPEyy10bsw7gyyXMYw6mlYllSqhKAayrLH/uvXW5oZte4ft7bcZj3t8NPtOUyqtoCiFj/xct3uN0aiD43QAmUymRDpdjXY9y9z4lb2TYHxQ9JMlm60hyynC90lDVU1cd8RgsIfrdhgMtplMenieTaGwRC63SKm0iKJouK5NqXQ6EtwBuPT7e4xGDSaTLkEwwfOsqc1eYVYcPk+BfL5GNluLBH0WrjtgMrGRpIB0eoZa7SEWF5/GNAsMh1voeg7DKPHii+D7MooS4HkSzz7bSQJRvX6epaXnIqOZAuEMe3jBtrLycxQKS+TzC8lOcsPIc/36j/jSl/p43o3H/PrXaxSLZ3jttaf5p//0L/O//C/P8Q//4Vf54INvAhL9/i6FwhI///P/gHx+geFwkx/84P9FrbZyqMPW7RD/rgK022v4vouqGqTT5aRfPF0SV1UD0yxGo4n3doRS8NNFXEp9BtybcvTtPVe8Gzm07bxx22jUjKz6Vtnbey8xAen3t+h21ygUliKjkUew7Q653Czt9uXoJNRAVdN4nsNo1GR7+x3K5bNUqw9x5co7tFo2hpElCHZw3Qnd7lUymWrkqT0mlSoyHvfY2/sgOumY5PML2PYAVdUxjBzz819kPG5z9eoVOh0Z0zQIgiGyHAZZSaqSTttRNpkFhoxGfYKgSxAEiVHEeDxBVcONU+n09PtTZzweAj6alsYwikiSy2QywfMm+P4E1zVw3Q77Fd0fT9gr9giCMTdKzmFmLcseqipH99lPKpWmVDqFqj4YZY09ZLlLEHiRujwdbSr6pBK7Eh1rHLjlqOw/LQqajxY2pPD9cORM17NkMmV2d38CTAgCk1QqT6l0msnEZjLpEwr7TlEoLBEECkEQEAv+QMG2O9h2F8vqkMnMMzNznnff/R3AjmbOdUxzjlxuEVnWWVp6mn5/I7JezVMqnWE02mNr602KxRUkKYXnWVhW2L545pkm/+yfPc6PflTh2Wc7vPjidUajWlQBmokCoYRpViiXz9BqrVEq3Yei6HQ6VxgM9uj3r6OqKQyjiON0+Jmf2eGll+Z45RWJr351zBe/+D6///tf5R/8g1NIkkcQKEiSTxD8HH/9r4955JGXuX79j3n44Qs89NBf4kc/+qc0Gu8QBMG+fu+dek3XaqsMBruMRntJRhxONBT2lbIhrIYVi6fpdNaEScgxRwTkz4C7LUffyXMNBjv7+tTxbdOLKnK5efr9TTY2foSmZcjnl8hkath2l1wu/pldJhOH99773Wh7VC4S0IR2mr3eFn/4h3/ASy/9Ic3mhIUFePHFJzl7dgbf93AcOykpOk6XYvEs2ewsg8FO1OMeouu5yH1pjKYZSFKZej2Fpr0ejXcQLdMAXZex7RGWtcdkMo4C6BDXDQgDoIwkZej3u8hy6Obl++FmKF2ficRhOpIUoKopUqks/f42suyRy82jqhqW1aXTcfD9EfvL1bFxiR9dHIS3ptOQz89i2xOgjSybpNNlLGuX8biHquo4Tj/KRqc/rTy6XgSIxsqWGY9/jCQVCAIJSQqz/VC0Nt2bPox4hnkS/fEPnKxDFXsQgCxrKEoRzxvi+w7l8jm63Ws4joSu69TrDwNBFOwGaFoG0yxTqz3E7u47pFImMzNPUCgscurUC0wmPYLAIQgmaFqWRuN94jK1JIWtDnCRJAnDyCNJCg8//MvYdhfDKNBsXqLReB/LaqEoKZaXv8RwGJZrbbuHLCt8/es2v/Ir4PtZRqNa8nOW1cSy2tF7WGIysajXH0aW1ajHPGRm5kFkWWZu7nFU1UjEURcuwIULsLPzPnt77/Htbz8dZcyxWFBGlj22tn4hKmeHrZwnnvgPuXbte7RaH/Lqq/+UJ5741UP7vbdDaKs7Q6dzhevX/2yfb/10KRuITFLmsKwWzealxJZXcPwQJesTzg2rwMJHFlnEiyqKxdNAOD6VycwwHtvs7v4kGiVZIJ2ukM3OYZolJCkMaKHoaEI6PYtphmXVdLrI2trbvPLK76JpHqdOldD1gB/+8EdANbI2lMhk6qiqHrlAbRIEIEmhDeBw2GIw2KTbvR5l3a/Tbr+P41ziwQdLpNPhlqfJBIrFEtXqbFRylZhMhvi+jCTFqxt9wv6yz6lTFUwzdJzyfchkdGTZYzjcZTweousFMpkZyuWVyD6xTDodv2clbly7poEUslzBMEpIUom9vRu+2kEA29sgSXlSKQmQCAKb8biHrhcoFs+Sy81GVqBjpn8FJUmm399mc/NNms33cF03UtBuoygpNM0klTKiVsBhJ/npX+dY+HbDxCQI+sn/K0qZXG4GRQlIp8tks2VMs4zrOly//qdIUhbTLFCtrmIYZTKZOvPzT/CFL/wNstlZNM2g2XyPdvtDFAWWlp7lscf+PZaXnyWfn6NYPBtVN2x2d18jztRVVcZ1XVx3hGV1KRbPsLT0XFSSrWDbXSqVFVZXf4FK5T5qtYdQ1Syl0pno4kFJvq9xsItbM0HgYpoVFhaejj7HIpKkJN/5bLYevZ4i1er9uK5z6IRCuPSlwte+5uB5ErIcJN8j31d44on1JIvf3X0Xwyjy2GP/Poqis7PzJq3WZlJRuhsXrVptFdMsY9stGo2LSSnb9z02N1/fF5Rj/4BY3CU4nogM+YQxPUIlyyq+79LpXKFcPpeUuGJi1ff6+g/RNBPLalOrrdJsXmI8HtBuXyWXm0seN1RQd0iljKQf63kDGo0dNC1DsXgKyzLp9z3K5TALgjSDQYd+32Zurs5gsInvK9GJpkMqpTMctnFdh2y2iq6X6HSu4fte1Kcc4boSo1EL6Cd+1eMxQDFSgquRqCsuC1vTrzK6fUylYgIKhlHB94dYVlgx0LQMrjvC99PIsoJh5LHtFq47ZjKxIteoIpOJTLm8ynC4zWjUZTKZEAT9SOR2o0etqjAcdslkMlQqVcbjPmGGWcPzJgRBQKsV7ozO5c7ieUM8T8L3x4zHHRynh+talMtW5G41wffHyLIUbeOCg9mxqpYip7MY9yP3uYFOoVCnXD4TWZVaaFpo4Tke97DtLqlUnrm5pymVljHNCkEgI0kKrjuMxH9ZgiAgk6mQy80xO/sE+fwimUyNVCpHq3WF8bgX2UmGb0wms0Q6PU8QjJBlnVLpFNlsLdoJru6bNjDNCg888Is4zoBS6UxyASjL4YXhaLSXfF+njT7iGeNstp6419l2d191KP7duFnLSFUNlpe/wl/5K00KhTH/5t/0kKQ2u7u7nD37XR5++Ic4Tijw295+nU7neVZWfp733/9XXL/+Kpub3+PRR/8qu7tvJTuO7zRLnp//Ah9++HIi2Ap/Pz9IgnSsqo6zfMtqJx4EQtx1/BCf2Akj3Jcclu7CrU+hN+/NaDYvMRqFRvrl8n2MRk3m55/A88YMhw0++OD3SKcrOE4/WjQBqmqiaRqpVJrRqEMmU0XTCuztXUaWNykUZCaTHvm8iWUNyeVAVTu4rkYmU8V1x+ztvRf1s0NHpvF4QD4/T7W6gqqmcJwujtPH83x0PY/vj9jbGxAEN1Yu7uxcQdMcNE2LVj6OODgWJEkGkhSqYoPARdM0Mpki3e6AOEOVZQXX9RgOt9C0NJbVptfbjHy70zjOAE1Lk8vNUa8/zN6exnhsRT1dBVWdIEn79zFLkofjNMnnzzMzs8p4PMK2+0wme3S713HdIUHgMjPzAKqaYjKxo2UIe9G6QC2yqaxhWaEIL7xAiAPtdLBV8P0gUrcXyGTKjMd9ut0tPK994BNXKRSWqFQeIJUqk8lUGY8dJMllOGwl3xXDyNPtrkcXEeFWpevXvw9IpNM1CoX7cN0+rmtRrZ6n0XgHz7NYXHwOwyixu/stms33GI/D51fVPLlcuCLUdUcsLDzN0tKXyWRqSbA8qG3IZueYnQ1bO7KsMhw2CAI3KUnDjcUpB9tA08LJg5qNW2kZxff52Z/d4LHHLuJ5HqPRHu22x3j8IJ43wbIadLvrrK19n8cf/6s89tiv0ulcp9m8TKu1hqZlkx3Hd6q4nhZsxRWrxcVnuHbth8nscZzdhzPMDTqdNTKZmrDTPIaIgHzCCMvQK/j+6SQLiE9KsX2nYRSiLCiD69oUi6ep1VYZj4f4vovrWmSz9ciOUKNYPJ1kJcNhE/DJ5cIMRFUDJpMxijKh273CcPgTnnlmlddee4fhsEsqpfLEE49Rqy0iyykkyQdkyuWzpNNzwARVNaJy7Ra53Cz5/AKOU6DbXQd8VFUF8nS7kM+reJ6PJPmkUjCZDFDVAul0ickki+N08bwRYbBVkOUATQv7o5OJx2QyxrLC1xBaLWbQ9VIy0hNm0+GcrSzryHKK8bgTBVuPdnsNTdOjErUNeKTTocBsNAqz42p1hmw2w2AwwPPCcrUsa5hmAc8bkc3WGAwUTLOA749ptTZIpTJR6bhGEMjk83Pk84v0+5u0Wi8zGm0QZpppbpinxEKqSdQf1tA0hVQqy3hsIctK1P+80fdWlDyFwiKpVBrHadLr7ZBKaZErmI8kyVFVRKLf3+DSpRbFYti2sKxm1A8vRWXccN+w44Sl2Xb7MqNRh6tXv83GxuuRD3UR00wzN/c4lco5LKuNJFUwjDKl0mkg7PXGQTie048tX+MqT3ixsoskKVOl6JvvEj8sY75d4uf1fY90ukyt9gDLy19mOGxgWS0ajZ9w5cp32dp6ldOnv8zS0nPUaqtcu/Z9Pvzw93nwwb9Eq3X5rrymDxNs3Wz2OF4tGc5dX7rjzFzw2SE+rRNGvC95mmw2vIKOhV3DYQNJgkbjXWy7Tbl8jlQqi6oaUb+5RD6/CEChsJhcgUuSgiRJ2PYA2+6i67lIUFIHVHS9hKqmOXcuz8rKo9i2xMzMImfOPIjjjPB9m/X17xEEof1mvf4o3e515uaejErDY7rddSqV+xiPB0iSEpmX7JHLzdLrmYzHE9JpDc9zSKfBNEtkMiXG4z66rqPr84zHXYbDcNRLkhQUBTQti2lW0DQV35ciw4piFBQnBIET9XfnIy/kgHr9URyni2XNAxKu69DpXCWTmUGSPG74L+tkMpDJhD3cVCo8KdZqD5LJVOj1NlGUFLqeJhRTeZTLpykUlqJSfICiaOTzp5AkCc8bk8nMAHLkXiZxoz9sE88Op9P1KLv0gQGTiUyns02vt5XYXBYKD2CaOba3XwfG+L7DZBJedIUmHuu4rk02W0VRrkaqapMgkFFVnXL5DJnMHEEQUKs9nIjxLl36IyQpwHVD0xbf92g217h+/c+wrF3AQ5ZVVlZeZHX1G5RK9/HGG79Ft3uFIADTLPLWW/+MavVBlpe/sq+sfDCjjV3nwvftvuR7CHzEH3769+BuhZOjURNJAkVJoShasr88n19gNGpSKp2m1bpCt3styZIfeugv02i8w2jUptlcI5udvSuv6ZsJtm42e1yrrTIaNQkCb58SW3A8EAH5hDG9xAL2n7CmS4K23aVYPE27vUapdJpebyMK1BLZ7Czj8RBFUZlMLAaDLUajNkHgRXO1GuNxj2p1lZmZh2g2L9HrrXP27PNRidOOhFbgOB12dt5CVQ08z2Zm5lGGwybF4hKW1Yp6euG+4729dygWV8jlTjMeD6K55wnjsU2plOHJJ5/j0qU/TtyuZmezkX2jgaZN8H0/CiYehiGh61ksq8Fk4pDJFDGMUtS3nWFn593IpSy065QkiWLxPiqV5SirLWDbPfr967jumFTKJJXKYNtdhsNdVDULhME0lcpQqdwf3X8b1+0C4VrJYnGZdvsqrjtiMrFJpTLoeoFa7VEURUFV0wSBj2HkSKWy9HpX8bwxnc4VZmYeptfbJAzIJqFAyyEWSI1GseFI/Nk7gBP5Lptomo4sK2SzM+RyC/T7VyMf6KuAG9lzruB5Y8rl+3DdIZ3OFTwPbHuXVCpLOj0DgGXtks8vUirdx3vv/R7d7geoah5FCdD1ApPJJDr2bnI8QQBnz/5bLC9/Dde1E8W+adZIpUoAUX/9kzNa0ywTBOGFSziXrUbf9f0Od/eS+Jiq1dV9pe/4+NLpCvPzT9LrbdBsvkuvt8HS0nPcf/83+eCDf8Xu7huk088ns8N36qKVzdZpNC7S6ayRTlcSdfjBUjbcWOO4tfXnYgTqGCIC8gljWhgT/v2jJ6zpE16ttkqjcZHhMBSCSZKKYRSjewZRBlqjUHAYjVrRdqhL+L6DpqVxXYt0uoLrDikUlllYeIZG4yKpVJrr1/+Mvb13o56ojiSlGI3ayLLC1tbrjEa71OuPkM+fZTzuc/bsXwQkTp16GkVRMc0aly//EY7To9e7xvnzq+RyTWx7QiZTYDLZxPMCstkirqszmYzwfRdNM1AUk8mkj6qG+5pV1cTzAtrti0iSxNzcU2xu/kn4KgMJw8iRThfIZOaQpLfpdNaYTN4hXHYvoWlpdD2DaebodDajsngK8PB9Gc9zyeVm8TwLx7HxvAGeN2F3912CACxrhKL00TSVVCpNs/kOhlHA972onBuK6TzPod2+hiwrNBrvoes5JCkMekEwisRssRGHz/4xrBsGHblcHcfpMxjsMJkMo76rllwEaFqWfn+DXG6OU6e+PCXSqketglCxrCgaudwchcI899//C0wmDltbf8ZwuI6m6UiSRL+/zng83heMQUbT0uztvcvc3GMois7y8vMsLX2JTGaGSmWFdnsN0ywd2gM+6O9erT6AYRRot8OgFKqNP16cdbdMH1NcZTr476dPf4W9vfcYjXbpdtcpFpdZXv4iV6++Qqt1iWx2iWJx4a5ctA5z4/q42WNZVvnjPz7Lq6+afP3rHv/2v300920LPooIyCeMw0xHprPlgwE6LG+FJ18Ay2omquxq9cEkYxkMdlCUHpOJxfLyl5PMejweYhgFCoWlpP+nKCquOyaTqUXuXz75/ByDwQ7DYR/fH1MsnkPTMuh6kU7nMs3me/i+Q6GwyNran9DtXiGbXUTTwnLoaNSMREZpKpUik8kI151FVQ2q1QfwfTnKUtaRJJ1crspwKEfuUvO0Wlfo9a7huhaW1aBYPEW9/giO02U8HpDNLiFJGv3+dTzPiewVJQwjVC+Hf3fRtBqwjmV1CMeKwj3Bw+EWQTChVnuYbncjsThUFBVNS1MszqIoKebnv8hwuMlwuBuJvAZROT0cQ2o2TQwjz3hsoaoKnjfGNCv4vkcQ5NC0UST80qK9zIftZpZx3UnUj3bxPKILC0ilMlSrD6BpWVQ1g6Zlo9nvLNXqg5RKp9nbe4/hcA9F0TGMAouLz1AsLlOvn2c8HnD58h8wmUyYmXmEZvN9HKdNKuUxHDYIFe5ZFhcfJ5sNy/+t1hoPPfRNcrm5feXlj8sYB4Mdrl//EUHgRY5yocYhFmpls8ZPdZ7/ZhQKp6hUHqDbvcrGxp+zsPAU9fqjnD79Au+//69otd4nnS6ys/MW2ezsPRV33Wz2+NvfnuVv/I0FFCXg139d4qWXwvlqwdFHBOQTxvRJ6uCV882CdXy/OKDC/oAdu3sNh40og1tLxk1SqSyuayfe3PFjp1IZfN/l1Kkvc/36n+K6FsXicjRi1KNUuo90uoDjtLHtLrIsoWmhj3W3e5XRaIdCYZlS6Qz9/iayLOO6oVDJNMO52FLpDKpq0mp9SLG4iG3XabWuoOsqi4vPMBo1WFn5eba23qHReJt0eiaaNb4Py2qhqmkymRqqaibHE267GuC6DrqeQZKUKBiCLBv0+9cZjfYIM1MFWU6jqnlct89kEi7vyOXqGEaGycSJjCcUisVlbLtDo/EGlcqDkZ95k07nQyyryd7eu+TzpzCMPMPhHsViNVmFGQQuspzCcTpUq6t0u9ewrBajUSxgg/BX2Y/+KOTzM+Ryc+h6ma2tP0OWw53Evu/T7a6xtPQV6vVHAbDtFv3+dSYTi35/MxExyXK4q7rTuYqu57HtLjs7b2NZe6TTJRYWHiOXm8Vx2gRBaLzR7V7h7NkXee65v8Pm5pu0Wu9RKMwlJd/byRANI4+mZaIqRyEpU8d/pr+fn5V4KbTrXOX69R/Q6XyYuHOtrv4iOzs/pt2+Qqt1OdlrfKdCq8My4sNK2QDf+Y6SWIDe8Pq+l69a8GkhAvIJ5mBGfFhGESsz4/vFJcA4Kx6NGskJQNdzWJaL59k0GheToNxoXGRz81V6vY3kNtvuoihqJISZAwIWFr7AaNRiff0HNJsfRGv9wgy6XL4fWZZpty8xGrWwrB7d7jVKpfuiGVSPUulMVIY20bRwh3MqVUKSQvV0obDIaBQGaccZkkrlWFv7Y0ajBkEQLs7IZCqk0yUsq4Vtt6JRoSyyHGAYlejY+wwG2wDk84u4bol4q1Ons0kQSBQKp5JKgCzDeCyhqhKGUSSVMkmnZ+l2L2EYFUyzxGCwiaIY0UYtLxJS1XGcNuPxCMfpAx6Li1+i19uiUjnH6uo3se0+u7vvomk6k0mfTmcN163heQ79/lbyOUqSHvXWwxL7cNgim51hMrGxrD6qqpFKFZAkJeq5p5iZWUXTTC5e/B0Mo8re3sVon/CQUulMpOadRdN0giB0+srn56hWH0TXc5w793XG47AcPh4PsKwmzWaRev1xNM0knw8vTFQ1zWCwzXDYSL4fn0T8ffV9N3Lo6ia3DQZbWFYb0yxh2+3k/p8V9fqjLC4+y7VrP6DXu87c3OMUCqdYXv5qZHzjk0pl7kpoFYu7QpFhOwnsh80ev/gi/MN/KEXjgRIvvHDvX7Pg00EE5BPMrXpmx/8ei2TiX+x4G5Xvu+zuvkO/v8HS0pfodq8TBGE/OZ9fiBy8Qg/jra3XIg/hFdLpWrTa8VqUma3jeS6mWcJ1dykWF0mnq1FQS5FKZRiNWtH+2h1Goz0ymRlSqTyGYVKpnCGVKtBsvk+3e41OZx1NM5EkmfG4kwjJQs/lAe32DtnsLJOJTS43QzpdxbZ7dDobyYWIJEG9/hjj8SBaKfkh4GGaZVQ1xfz8o3S7WzSb79PpXMFx+uh6lnS6yHAY2oiGJftZKpUHSKerZLMzrK+Hizl0vYhlNaLXqJLLLaJpWcbjIY7Ti8a9ruM4+SgLHWBZLTY336BWW6VUWqFaPUcqlaHZvIRtvxV5Ok+IF2eAhiwbmOYMw2GTTKZENlvFslpY1mU8r0cqVWRu7lEkKcV43MX3J6yvh7Osnc5VZFlHVVUMI4dhFMhk6qRSOVQ1RaVyf2Sw0cbzXGZmHoxmwz2y2XoSHJeXv0Q+P4vnuQRBwNLSF7GsdtIvDi0/m7cUPOOLx4N94ulKzXDYIJO5+ejTTwtVNchk6njemI2NV5mbe4JicZnTp59nc/N1ut1r9PsNFEWn39+640Uy2Wydfn+LVusSplmiWFyOVjOGW9viYH/hArz0ErzyCrzwgihXHydEQD7B3GqP7eDJLxTUbCUZDRCVKtu022soiopt95IytWW1OX36+eQkM/28g8EOc3NP4vtuYkIyGrUxzQKaliGbncWyWmxvv02/f51ebx3HGWAYVUAilUpHQqkxnc4GpVK4w9Z1h2xtvY5hFDDNmWjJhYumZSK/Y41z536BVisUcalqOE/d7W7QbH4AuOTzyywuPovr+pHoScZxukiSjKYZ5HLz5PNLdDrrjEa70SYiF8Moomk6udwC4/GIUmmJUukce3tv43nZqP+rUy6vMDMTlnW3t/8c1x0DHpKkkM3OMTf3KFeufJdOZ4NsdhbPGwMSul4kCMY0m2tMJjZBEO6f9jybfn+DVCqLZfXQNIPJJECWNbLZMpqWwfMsDKNMPj8fXZi4BEEHRTHI5ZYIAptcbpZKZQXDKEd2o2PS6Rq+75HJzJDJzLG4+AwQMBxuRzPSoTlMPDscbkoqsL7+Q1qtS0CArpeYm3sS1x1hmiXa7SvJJq94HOd2g+fB73C4LzgUIoalfPVIzNrOzKxSKCxh2z12dn5CPr9AoXAqUWF3u1f44Q8f5K23Cnz9611+5Vdu/yLiZnPGplmi1bq0L9jHvtyC48Vn/00WHBmmA7NltaO9vGFGU6ut4rpDKpUVVNVIRqQ2Nl5NZpnr9fOJOjZeAzca7UXbgIgCo86pU19KNkwBbG6+hqrqeJ6HJKUiX+kqmUydfn+DTmeNbLbOZNJjPB5FQiUv8l62KRQWkOUUk8kukqSSSpl0uyN6vU1mZh4mk7mM501wXSea952L5oTvp9W6hOP06fWuk8nMRgKvOUyzzGQyYnf3bXq96yhKmKHncgtomkk2u4jv2xhGaJjR768DMpOJTT6vYxglTLNCJlNJMprRaA/XdZhMrGgz0Syzs19gMNhAlg1Go136/e0o2JVQFDnai9xnMhnSan2I500AmVIpXIMYzjEryHI4sxwEPqqqI0nhVizfd5CkCbbdxLabfOELv0a3exXbHpLPh8Ysvu9SKJzBdW0sq4Ftd/F9H9tuMRq1oyzvOuXyGbrd60krwra7kfq8SD4/h+s6lMv3oaoG/f5W1Gu/O3OOm31P7zTAf1oUCqdYWvoSv/3b2/wf/8c83/xmGHRjFfa3v13n7//9r6MoPv/7/y6TTt9ZwDxszji+IOl01hI3NMHxRARkwUeYPuHFaxuz2TpLS1/eN9PcbF5ibu5xut3rVCorQGzd+QHhvtkbyu1QGBUk3timWYp6102KxVOMxzamuUMqlcUwiphmkcnEYnPzzwgCmVxugXL5HLu7YcnWsloA0XyzE43B+KhqiosXf8K77/4e169reF6Wb37zOZ5//nmazffJZGbJ5eZw3QmZzBzD4TaeN6FUOpuMlLjuGF0vsb39BoNBEc9zkCQfSVIJgvCiYjRqoGkpdL1Iu/0Bk4mF73vRJqcBqmqyvPw1Ll/+PQaDHVTVIAh8FCUsGXveiMuX/xBJkpmZeQzPm9DpXGY06qKqKuXy/Whamn7/OtnsAqqaZWYmy2jUZHb2CZrNi5ETlkK3e5XBoEm/v4mi6BQK82SzFfL5OtXqQ2xsvIpl7aLrBUyzTLP5Advbr0Y7hovoehFJkqhWV7h6dRvLarO3dxHDyDIe97HtPr7vk8lUWVp6eN9M7nDYoFoN2xNA0susVFaSHuenkcEeBYX1NLKs8tprT/Hf/DczyLLPP//nYdD9xjdCFfabb1aQZT/ZuXynQqvD5ozF+sWTgwjIgkM5uLbx4Axl7BXsus5UtqImG6Ri3+EgICojd5Ekib2993GcLpnMHLlcnbm5x1EUg1ptJeptBszPP4ZhFLl48XdIpYpomsPc3LOsrf0hsqzhOH1GowaFwjKmWYpUzuFihd3dNX7yk4sYBszMZLl2LeD//D9/yKOPfon5+afodq8zmQzodK4iSSqaliefP4PjtND1Aq3WJVx3iO/b0dxxifn5L7C5+RqdzhXa7Q9xnAKmWcW2PWx7iOsOGI9H1Grncd1BVP6e8OGHfxDt3TXJ5xdpNt+n3b4SlZTrtFofkkrlqFYfQNeLmGYVx7Fw3dBkQ9fzKEo6cjEL9z0vL38F3/eiMr6Lrp8hl1uMLE1DByxdL+K6I6rVR5mdfZh0eobRqEG1+gCe5zAz8zCO00NVTUyzgOOMSKdrBEFApXIOSVKp1R6i11tDlhUURSGXm0m2MmWzRlIJ0fXcvu9Np3MFkKhWV6nXz38q381p85ujUK6O+dGPqihKHHR9Xn4ZLlwIVdhPPfU6/9f/JSfq57sRWsmyiq7n94m7DhN8CY4f4lM7gdzNCevgzx4UfAGJS1GcDQ0GO/vUrvn8QjKSMRzuMBzuMRqFiualpWcZj0eRArzJ1tYbSXm6VnuQycSi2XwvmZE1jCz5/MN0OpeYTPooisHi4pfp9a5SKp1mdvZxdnffptsN9wy7bp7RCHTdwDQdzpzRuHLFptUakEr1MIwC4/EARUkhSZNIVGaTzS7Qbl9B03JMJkOy2UU8zyKdnolK7hKKEo89NSmVwDSzlMtLdLu75HKLFItLkWI6nG1utS4zHncpFM6Qzc5jWe1okUfoQ53J1AAt2dubTtdJpdKoamhdCX7ke71Ds/kes7NPkcvNsrn5Oo7TRZZNVHUnKluH5iaynKLXWycIPIrF1UjRfolUKovnjVhb+y7Ly1/m/PlfxvMctrbeJJ8vYVm7eF648SmXq6PraQqFZYrF02Szs0nfNhbyDQY7bGz8aZR1h2V7XS+Qzy/hOP1EEHgvOPidPGye/ijwMz8j8z/9TyRB+emnd4EZ6vVH+bmf+w62/f/k6tUX+JVfeZQLF1J3/Dyhz3xjn5DrsNsExw8RkE8gd3rC8n2XP/mTb7G5ucmZM+d56qkXkqDc623geS6pVIbBYCcJ1K3WJYrF0x8x+o/L3qZZYjz+c3Z3v0OxuIzrPhxtG1pha+sN5uYeZzweArC09Fy091UhCMD3PWq1R0in82Szc2haLrJzLJHNlqlWV9ne/jG7u2/hOBammSefL2DbOp2OTy4noygDTDONouzQaDTQtDQLC18gk6lTqZxlMAiXB0wmIzQtjaZpmOY8qipTKj3AaNRgbe277O29h+9P8LwxiqISBA7Z7CqWNcQ084zHfXzfw/cdUqkMw+EO2ewMQVClUllhMhlSLJ4il1vANAuRqnuThYVn8P0gsoOUGY/7VCor9Ptt9vZ+zHC4jaqmyeUWkOWA3d13abcv4bpjCoU5FEVDUeTo2MP1ksPhFpPJCM8b8eCDv8g77/xLFEVjPB5FwRoeeeSXo5GcCa4rsbT0ZZrN99naehPL2qPZDPvetdqDqKrBxkZYIUilclGJ9BSalo0qICZbW9fI50Pf81D01z3U3epWvoMHLyanv8/xhaBhlI5M/zgmVjf/7u/u8cADb/Dsswq+/zVU1WB19Rdotf5Hnn/+Ko899u8Bz93x88RCrk7nSlKivpm4S3C8EJ/YCeRWx50O8o/+0d/nt37rH2PbDuNxlr/5N/8j/vbf/s8ZjZp0OmtAQLu9hrRvm2PwETOSWNAVZ8vd7jqmWUbTcuh6jtGogee5SBJJMA5LxeHqxGJxOZmtBJft7TcpFrtks3PMzz9Bv79Fv7/BcNiM7CG3KZXuJwhc8vk0zz//OK+99udYVuik9Yu/+Jc4ffoRrl59hfG4z2QSkMuFvsr1+kO89db/h5WVv8Durkex+ADD4TbN5ofMzp5HVeeZTAY0mxcBFVmWyeXqlMsrOE4Pz7MJFcbZyBRkAdvuUiqdxfcnzM4+Rru9xocffhtdzzE//yQzM+cjsdwsudwimUyFIIBq9Vw0qtQhCGzG4z7jcZ/Z2SfJZmei2WiPavVhdN2kVDqLaZZoNC6zvf0qIDE//0XW1n6fTucq4DEYNKhUVhkOt8jllnFdh3S6RrN5KTI+SWEYeSYTC9d1otK/H63yO5uM6lhWG03LkkrlGI32SKWy0cKMHJOJRbF4CtOsRBaPa3ecIR92MTn9fT64CeqoceECfP3reX7jN+r8t/9tkZ//+VDcpesFSqUVGo13aDYvs7Dw1F0d/2FlayHuOv4cvW+04K65E8HL22+/zf/8P/8GqZRCOr1EEDT5zd/8J3zlK1/hC1/4CsXiaSyrndhlThvtT5e14zK1LN/wzw0XN5ymUFjAcfpkMjV8P3S1cl2bdnsNz3PY3HydIBgzGOygaelIwdzHcfr0+9sYRpVudx3XdRgMtvB9j/G4QyYzS7l8hlQqx87OGzz++CPMz+cZDidkMimef/7/ga5n2Nz8Ie32Dv3+h1HAG7Gx8ef0+9fZ2nqbdLqE41yk211D00xmZx9ncfFxRqM9lpa+wmCwiarqFArLSJLGaLTNaNTB82zK5RUymRp7exeBINqfvEinc5Uf//if0+tdo1JZ4f77L5DJVMlm68kMbahqDg0wVNVgMhmh6zlKpRUgoFpdYTTq4boOhcIpdL0YvX6f3d2LeN6EdLoczTeHgTOdrjCZjGk03o2WeMwiywGzs4+SSuUIAi8q/z9Np3MF0ywxN/cEjjNiMNginZ7BspqoajoyE1HIZKrR6Ng6up5L9jevrPxbiS1mvCHpTjPkwy4mp7/Pd3qx+dPkX/9rg//kP3kMRfH53/63WNxV5/TprzIe9+h0rtLpXKVcvu+On+NmZWsh7jreiIAsAODatWuMRjaFwhySJJNOV2i3N9jZ6SPLalKKHI+H+4L99P/H4ximWUHXc9GsqIcsKywsPBWNUzUThXW5vEKvd52dnTfJZhcoFhfZ2PgRul4mlUozP/8Eu7vvMBhsRkYjFTTNiManMqiqTj5/ltAqcpl4C5KmpVlcfITJZMhwuMXGxqtUq+c4deprSNIPcBwLXR8zGGxgmhWKxTPk83U8b4IsK5FlZJFy+RTd7jbt9hWGwwamWYysN1eioFRib+8S43GPRuNttrffjPYla9TrX2Bm5iE2Nj7Ashr4voNplqJtUqEHtevaHzHK8H2XubknSKXSQCio6nbD+WzPm2CaFdbWXiGfX2Jn58d4XmhMoqom5fIK7fZlJMmjVnuIXG4uEoNlMM0Ks7OP0OttUSgsMhhskcnUEg/kOJjm87MEwZhMJpw7Ho/7FAqnovnkUEmdyVSTLWBB4NPtXk+EfWG5vnHHGfLHXUweVTHXQV5+mUi8Na2oVikWT5NK5Wk03uHatR9SLC7f8euQZZVMpoZlNRkOG0mJWoi7jjfi0xIAcOrUKdJpI/IprtBqdZCkLMvLZ4CPz0ziE2UqFXo/V6sriQmIJCksLj5NPr9Ar7eRLFXPZKooio7j9NjZeYta7WEmE5tK5X4UxWB5+cuMRk1U1SCfX4rK2S6DQYP19T/Btnv4vkepdCoq3e2Sy82jKDpBIKFpBnNzj7C7+25kLjKhUFig1Zql2bxIqbTM8vLPIkk+k4mNohgoSpr5+SejjVE6zeZV0ul8tP8YTHOGYnGZ7e23sO0WhlEmnS6STlep1x+n2XwfRTEj17EcmUydRx75Zfb2LkbrB2fY3PwxqZTBeNxH03JkMhUWFp5JHK+CwIv2/aqRveV5DCPPT37yEp5n026/n+yJzmTqDId7WFYbz9slnZ6jUjlHLjfH/PyTpFLZxJBFkiR6vS3G4170PCT+0HEANIzQWrNQOEW1+kBiEhPfZ/rvoSFLKXHiikvN8a7t28mQP25l6DRHVcx1kJtZV2azdarVVRqNdxgO9+5afCXEXScPEZAFAJw/f56/9bd+jd/8zX9Cu72BJGX5u3/373L+fDi68nGZS6+3wdbWa+Tzp9C00DCiUlmh19tkONyh0bhINlvHdW0ajXejLUt9TFOh2fyQIIDt7TejkukAw9DodK7SbF6ORE7nWF//PqlUluGwEZlwSKTTJXK5eXq9DUyzSqGwSK12Ht8fMx5bDAYt0uky5fIKup4llcqSShmRerqWrJAsFqv0eltoWhrH6TKZDBiNdgEfw/gK5fJKVPJN4ThtGo23o4BTQ5ZlarVVUqk8tdr5KLCnKBROYRg5ms01Tp36CoPBLp5n4boDFhaewHGGGEaWySQc1xoMduj3N6PRoxUMo4DjFMnl5vB9F0UJdxzXaucZDK5Trz/K9vabSJLKeNzFtttoWord3bcjG8dJ0lesVFbY3v4x9frDuO4Y17Wx7TbN5qV9G5hsu0smU0GS1JtmV9Pfg2JxmWJxOVHbG0YpWZE4Lf77uCwtbnMEwY01kjcLusehXA3c1LpSllUKhUUKhdNYVoNud/2uxFcfJ+6avk1wfBABWZDwt//2f85XvvIVdnb6LC+fSYLxJzEcNuh0rpHNzu9TW8uyQrN5iVbrcmQk8l7km6zx1FP/Ef3+Ng899M3I1nKZyWSMZTVpt9doNN7G9/2pDE+NjCmepVQ6i223o2UTIyYTi8uX/w2t1gO4bh/TrBIEYxTFIJ2eIZebJZ0u0+ttoutllpe/im2H/euwtLsAyPT7G0npdW/vJwwGezSb73D27M/R6VxDlmWuXfuQIAhQFANVNdH1DJbVQtMyhHtrl9H1PMXifXQ665EVaItstoKiGJHFaApJGgAyphlu0up0rnL9+p9SKp1G03R0vUgmU02WdwyHu9RqDxIEPtXqA+TziwQBOE6Xq1e/Hy10CMv4mpZmMNhlONxFVUPzknS6hKLo0batUDwXW6TC/lG222VaaBWvSJwW/31cNhuv/5Sk/XuNDwu6R80M5OO4mXVluPXpMo3GW2xvv0mhsHRXWezNxF0HbxMcD8QnJUiQZZWnnnoBuKGWvpV+XSZTo1BYJpud2aeyNs0CtdpDU6psiSAI+7xbW28SBB693ibLy1+h1Vqj01mj211HUTSWln4G13XY2HiVZvMixeIZarWHotGpMdev/wnb229QKq3gOP1ooUFY8tb1DI4zpFQKZ2iHwwaXL38bx+mgaTlqtafQNINGIyxd12qrkcisRzY7R622yrVrfxw5VLnkcvMsL3+V69dfw7ZbpFIZZFmhVDpNEEg4To9O5zLp9AyalubUqUeizDZc25hKZXBdi7m5L1AoLLO7+xMajZ9Ec8cmpllic/MNbLuD7wdoWhZdz5HJ1DCMAr7vUyyeRZYNbLtNv7+B74OiqFhWD9938Twn+pxkNC1Pp3MFXS9y6tRzZLN1RqNmtJjgMrKsUC6vIEkSkqTsE+hNb/6Kmc7iDuvjxj9vGIXI3a2UiNVudbHJ9OMdl6B7J6iqweLiU7Tbl+l2rzEeD+7q8UTZ+mQhArLgUG6lXxefnLPZOqdOfQnfd5NFA8XiGSRJZXHxqakTd5lS6WzUg8xz8eK/wrZb7Oy8iaaZ9PsbAFSrD1CpnIt8tUNXqnJ5JXnOUuk0jcZFDKPMYLDNuXN/gW53ndXVC7huuJZQllsoio4sq1hWKxJSaXjeBN8P1+HFo0tbW29Evs0NhsPdSE1+BknSmZ9/ksce+6uRb3OKcvkBJElhMulhWR1qtYcJgiApc9dqD5NO16LsPBd5dIdqWl3P0e2u4/sTqtUHAQlJkqIRpDSFwiKVyn30eutYVotcbp7hsIHrDsnl6uTzoWo7CErR+NYQx+mzufkeV658SKlUYXHxPlIpDcdJkU6XUFUj2smsRoYlYe86vNCY29cbjq1S4/e51foAkPZlpod9L6Zd3eJMOXb0+iSOU9Z7rwg/Dw3L2mNz8w3K5fvuumz9L/+lxTvv5PiLfzF0BztM8CU4+ohPSXAot9KvO3hyPljutKwmnc4Vstk5er3rFIunWVh4Cgi3R2Wzs1F/1IyyapVCYY5sdjYpn2azM5w69VUkSUoWQeh6DsPI0+lcQ5JUut11Hnrol3BdByAyy0glmXkmM4PjhNuput0rZDJl8vk5DCPH9euvRr1bL5pp3iSfX6ZcPsfDD/8V0ukqqVSWtbXv0mp9iGXtYhglgiDA85zIB/sMzeZ7zMw8SLG4gmXt0e/v4Lo29fqDjEZNTLPIzs5bdLvXonnkp6nVVmk2L0Ve2RXm5r4QeWnbBAGRYr1EtbqajJvNzj7KYLDDcNggnS7zT/7Jf82Pf/wyzWaAZeW5cOHf5+/8neex7e5HPsdqdZVyOdyfK0VvThyEm81LBMENb+Tpz/KwUvJh34vj0uP9rMlm6ywvf4nxeIDnje86i/2938vyN//mF1GUgH/8j8P+9Te+IbLk44gIyII75uAJWJbV5Bff993IUKKFZbXodK5i2x1Ms0S3G1o7TiZDVle/gW33aLU+TMaKFEXDtrsMhw16vXUymRk6nevIskq/v0EQqCiKQqGwQL+/haaZvP/+v0GSQqFRobBEuXxfYlDh+y7F4mlyuXCLU7l8XzIz7HkWkgSSlELTskiSjG130fUMu7sXKZdPc+3anyBJcmTN6TAaNaLFGRN03SSdrmHbTfL5JYbDbRqNt+h0ruL7E5rNJ4FJ5EP9VVQ1zXjcjzy4jaRnrap64lwWKqsL2HY3GmkKs9xUKguQjKD95Cdv8Pu//7ssLUnUahm2twN+67f+f3zpS1/l2We/jqoayWcRVzLiz2g0aiZ2qKHvuLevjzv9WU5zs4z2uIwkHQVkORyBKpdXaLU+oFw+c1dZ7A9/WEo8shUlFJNduCDEXccR8ZsjOJRbKVkfdnKePjHHM5GpVJaZmfNIkkS7vYZtd+j1ruF5Po3GRebnn8TznEjNXE9+Pi6f9nobtNvv4/s+4/EATUuztPQlqtVzGEYpCt677O6+BUChsES7vUYQeDQaF9nefoNUKsfi4tORY9LpyE3rDIqiMxrt4XkultXCMPLR2sd11tev8MYbr5NKtVhcPIcsa3iew3g8oFg8gyxLBEHAYLCJLOtsbLzGaLSHaVZw3THjcZ9UyiSXuw/TLJDNzqIoOpbVSk6+8Xt45corbG+/AcCZMy9E77uRLPeIP4c4gx4Om2xurrOxEWAYdYJAQZYlNK3FlSuvs7Jyf7IOM1YxxyNL6XQoJBsMdkilcvuO406DwnEZSToqZLN1FCXFaLTL+vqfUCqdueMs9oaHNngeyZiVEHcdP8QnJDiUWy0/HpwhbTQu4nk2w2GDUuk0khQ6dmWzdUyzFImn+pw58zXW1r6bnCiq1dVk1aPr2vT7W9Rq4cagUul0ZIRQZXf3bTzPxzSL7O1dote7xuzs4xhGgclkRLG4RLe7vs8JKXTC8mi1rqBpBm+//f9lZubhKBjvMhy2GAw2o/WQC8zMrPJHf/RDvvWtlxgMHObnZb72tW/w1/7af4bj9FFVHcvqUigsYZoVNC3L9vabNJsXmUxGlEqnqVbvZzjco1A4Tal0Klk7KUlhCX3aanQ0alKvn8eyWszNPf6RzyEeKwrHxi7Sal1C1/PMzi6gaRk++CBgaUmj2+0xGOQ4c+YJSqXTyXs5HO4kqzCnBVu2Hc4jSxIYRuljM9xPyoCnj/PgZrBb+e583oKFLKssLYUuaa47uasRqJuNWU3Pth80oBEcTT5fvwWCW+ZWxTajUZPBYDtysirheQ6dzjWKxWXa7TVMs4hldVBVA8fpI0lEs69VVlcv7DshDwY77O1dZGfnLVKpLLKsUq+fJ5XKcubM12g0LlKtrkYOUgOGw136/U1OnfoSrjuOdu+m2N5+A8fpUa0+QK22moiWJAk2N1+n17seZczPYFmFaLGDjq6bqKrOj3/8PV555V9gmhKaNkur1eVf/Is/5Omnn0964JPJCEVRKRRO43kOs7OPAy6OY5FOz2IYedLpGnt776BpqUR8k07Xkvc1DpixIrpavT/pg08TGn/YNJsf4LoWg0EDzxtz+vRZ/vpf/3d46aXfxPfbZDJp/oP/4D/msce+jG2Hs8me50a2l+E4mmW1E0MQICmNH9zmddjn/HH/Pq3Qjr87Nwu4sRI/NBGRbvqYJ51C4RT1+mN8+OEfsrn553c1AnXYmFU8g95sXrqn27cEnx4iIAvuinS6kuw+BlAUnWLxFIqiJ4sGFhaeYjweJhlwv7+V9EZjy8a4jKrrBdLpmWivby7JtkajJp7n4Dh9Fhaewra7eJ6L59l0OusoippYdqpqGk3LUqmsoKoGc3OPJ8FB09K8//7vkc/PJ7aR3e46tt1gMJggSTKNxhr9/oRCoYLvS/h+ndFog52dHXI5H8PIkUqlkWUNWYZUqsT8/BPMzKyyvf1mtOP4/mgWeBvH6dJq2ZhmiZmZ88iySq+3Qav1AapqMhq1KRROoWmZj1QkYjtSxxmg6zlcd8xkMqDf38Syuvzczz3F+fOnaDbbnD37LPffv8L6+g+o1x8lna4lATd+n4PAo9m8RK22mgTBbNbAdW0sq31TQ49bqZgcvM/Ngvho1KTV+gDf98hk6p9bEVh44VKL5sa3k/nwe4ltdwkCN/nMP2+ViOOG/FkfgOB4Mj1vHJ7cQ8cn0ywls7zj8ZAgcGm310inK0mW3OlcodkMtztdvfo9er1wx3DY88oxGGzieQ6t1qXkOdLpCpKkMB73uXjxd3Fdm6WlZymXVyiVTifHJcsqqZRJNltLNknFt6fTFcbjEYaRZzweJqKp8LlDAZQkBSwtPc5oVKDfH5HJDJHlHcbjLCsrX6RUOoMsm0wmFpXKOVQ1TSZTSUaLUqkc6XSFWm2VdLqMrudJpfJoWiaxq7zxHnpYVgfDyKMo+qEly3S6QjY7y9LSc5H6vEwmMxtllgGSBKdOLfKNb/wazz338zhOH9tu4zj95IIjftz4PQyC8OJkGtvuJoYeo1HjI/8+nfXu7Lx9aPA42IcOL7JqHwm46XSFcvkc1erq5z5I1OvnqVZXAZ9G4717LsBKp8NNYsPhbvK7JDi6fH5/EwS3xSctiT84hxoHgFjBG/ewKpVwnjgupY1Ge8CNrKrbvc5o1MB1x6RSaYrF08ANM/21tZfp9dYZDjc5ffpFMplwLCmTqUeLLFQWFp7Z95gxo1EzEpnlkCSFVCrD+voPse0OlcoKphl6Odfr5/nVXx3x67/+PzIYDJAkk7/1t/5jnnnmZ6P+9nV83yIIfJaXv5yUfB2ni+87SJLE+vqfMhhsRGNUC2haaAASX3jEvtGmmUPT0h8rjpue91UUlXx+nlyujmmWyWRq+9oLcYCL3+dp4h3V0z3/mGlzj48z9AhFcn8eLcF4/GO/Mzdre9xMwf15RFUNKpX72Nl5nU5n7Z6PKAkrzeOFCMiCW+JgAD6shHnYGNTBAKCqRqL+1fUc5fLKvj5vuXwG3/9ZfN+h19uk2byclLYB7r//F9jYeB1dT0dZmpGUuxuNcInDdFYIN7L58PFX0PUCjtOl2byEpqWjwBj2VSVJYTDY4a/9tV/mxRdf5Nq1NUoln2ef/Xq0IrHL6uoF1ta+y9mzP5MYYMRiJl0PM2DLatHv7+L7IEkyhcISjtNP1izG26MkKXyPgH2l4un3Oy43x9l1tbqaBM2D2WX8/t6MjwuS0yXsm2GaJQyjFFUybs3JTfDx5HJzFItnmUyGn0rZWqitjw/ikxHcEocF4DjQxcHvsJN9nCnH5bL4vrH/cfxzEAb9yWQULUGwcZwho9Eee3sXMc0KjtOlXF7h/Pm/nOxdnkyGNJuXMM0SjtOl0/kwURRPP/fGxp+iaVlyuXkymRqTySBxzgpL2IOonOvRbl8hnS5x9uyDnD07x2jUSLLgUOFcSARY05msqhpomoFhlJKdz5bVQZJUWq0PmUwGSUA7uEXp4HjT9Pt9WC/2sKB5mIhqurVwN2NN07PMCwvPMBw2GI/7+45JcGfk8wsUi2fY2Pghjcb7d7WW8TCElebxQQRkwS1xMNiGwpxLUdBpJ1neYara+L4QJI9zWDk7na4koz1B4KEo4WOYZiUKuJ0kMIQl5lLyGADl8gq+fxogUfD6vstw2EBVTWy7Fx1biWr1QcbjAaPRHvn8IoXCUhK8h8NGokqOfz7uNft+OM8b/3scLONyoGGUklnqfH4hWgfpEgQBmpbBstpkMjXG435S2ofDx4bi9/tWR9AOC9yHvfd3wvTrjEdpZFm/LUHW53nM6eMILxxLOM6AnZ03qddDz/Z7+fjCSvN4ID4VwR2RTlcoFk8n1o+DwU5yoob9WVMo4gl7moZRoNcLPavjPbrTQSgWJRlGiYWFp/cFEVU1PjKeEweIOEOFsPQbum+FM9CSBOGOYrCsDjMzD6OqBltbW4zH/SRLl2U1yXJjkVb4upqMRqWpuU53XwZqGCWA5Lind0OXy2fodtcpFk/jOP1EjR6LnT7am298bOD8uKB2szZC/N7fjZo5/lnfd6OLJf22BVnCPOTmhL7iszhOh0bjvXteWhZZ8vFABGTBHREHr0ymmgS+w9boxffN5xcS16jhcAdZVg6dXZ0Wfd0IwDfETdNuU73eBleufJtcbiE6od3o5U7P+wJ4nkuncwVVLUe7jA0qlZXEzvNglhuPaIW3BcnrmO6JT68djANkvNLQsjqYZhFF0alWV/eNAk0H08Fgh15vPdoTfZ7hcC8RssVMB7K4bF4uryTv6fRjHtYyuJcn3/h57iTLFV7XNyefX+D06a9y9er3GI32PhVxVyZTw3G69+wxBfceEZAFd4xhFBgOG5Ehh/qJJ+p4962uFxKl8cGSrW1394m8wvK1m9xnOvhYVhvf95IVgvH9Pc9JxoiAJDMoFML56HjW1vfdqBTeT3q+nc4VyuVz2HaXwWCLIIBy+dxHNhvFxxP/d7pfHc5HjwmCj64ujJnertRovMto1GRt7buJvei0MGv6ecJ+cLDvPR0MthgOG5+Ysd5NyfheZLd3UzI/6ciySi43h67nGI/7n4oievq9v1U3NcFPF/GJCO6YeHY1zDjrn3iynS572nb7I+M1B/uxcX9YUfSP9Gvj0Z7pEZ+dnbcZDneRJIVMppqU0YfDXSaTQbS4QqXdXkvsIiVJwfdDUwxdzwFScqzDYQPwkmM7GMgOBpjBYIdW6wM0LYuqppKRpIOv78b9t+n3tygUljCMIqXSabrd6x8ZWdqvgL4xUxwfZ7+/xWi0g2mWPjarupugOj0WJdTVnw7hRWqR0ahFo/FeMkd+Lx8fiNZqIsrWRxDxGyW4Y263BDltLhEHlYPjPRAG7L29i4xGbSqVG2NR0/8e/0ycSYbBt8V4PGR+/gvIsspw2MDzbCRJYW7uyURsNS2aymbriYgMQgFZLOAKS9qfbCu5H4lMpoaqLn1EkR73m+Pb+/0tWq1LiYOXYRQxjOKhj3rYXPLtcjcl4/j9OqgGF9w7stk6xeIyu7s/wXG6ZLMznzjrfbvEmgsxk3w0EQFZcMfcaQlyOhjHs7XTPdBY2RwHt/jKPv732OZx2vUqFC/dF/1ciCRJOM4QSZKSnrcsq/vMS4CkLxz7XTebl3CcDuXyOfL5hUOf7zCms9eD2WPcb06lcjQaF6lUVhLlq2lW7khBDTcuREzzkwP1vSgZiz7wp8cNUWE6mUm+16VlMZN8tBGfhuAz4ePKp7IcLpU4zFEKDpbKjeRnVNVgMhnS6Qyivu8shlGk01lLfvbgeFF8LHFWHM8Ih65bNwxFDj7fNLcy6zudFXc6VwD2Zf6fdGI8GAjjjDk8YSsfKY9PH9u9HDWaDupijOneU6utMhjs0m5fptO5elcLJw5DqK2PNuK3SPCZEAvCbpZ1flw2d7MsbXrEJw6Mvu/uc/o62EeLVd7h3DKJOnt6xCosM3/Uk9l1bZrNS+h6LgqyUvKY06rr6VJzLGSL+9+3mrEeNgceH9u0ijt+vlQqQ7MZzokriravTXCvgqcYY7r3qKpBrfYAnc4VbLtzz0vLQm19tBEBWfCZcFiWe6t8XCA7GHQO3jcuh7vuOFEmA6RSGdrtNVKpTBJA4/v6vnto5ttsXqLV+oBi8Qzl8rnk9ukgdTBofZK15ccxHdwPXpRMj2KNRg0ajXejMa806XQVz5vc88AsytefDrG4y7Y7DIeNT2UmOUaorY8W4pMQfCbcysn8dkui07uZbzYCFK8gHI8HSQAL+8o3th1J0g3xi2W1cJxu4o89zcGZ6fiY45GuwWBnX4/8bjlsoQeQrHKcHs/KZmcZDvfI5+cYj4fJOFf4OPcmqxVjTJ8O2Wydcvk+Njb+jM3N18hkavfcuQuE2vooItYvCj4Tpn2cb0YcgA6uArwZhlHAstp4nn3Tn0mnK/t2NofPE6u8a1QqK6TTNSA0OjHNMuXyyqEBNc52Y0evafW2bXcTD+z4dbqufdPVhTdjuo+dTleSHvfBmebhcI9+fwsIT+jd7nUmkz6SpESbrbLJe3RwDaTgaBGXlScTC8tqJ62He43ve0kFSHA0EBmy4MhyuyVR2+5imqXEKOQwDrptxbcdLP1O3/5J2fnHbWaaPo64xA3cctn6YFYcBv9wfjnuRVtWGwDH6TIY7EQZeh5dL0Yn9wqW1SEIPDY2XsU0i3fUKhD89Ai/pw/S6VzD88b3XIAlxF1HE5EhC44s0+NRB6/ipzPHmFA4NbtvneFhV//T2fn0/w8GO+zuvs3Oztv4vnvLGe101hk7ZzWblz4SzCuVFcrlc4fuKr6Vx45foyQpdDprbG+/zvr6nzIc7pJK5SgWTzMcNuj1rmPbPRYXn6FeP082O8fS0nMoio6mmVhWR2TIR5xstk4uN4dh5Oj3Nz4Vcdd3vrPE3/t79/Ov/7W4MDsqiAxZcKS5mZL3sNune5q3Y2AxPULkOD0gzGb39i7S660DfKxBw7RA7eAWq2m7z+ld0LfqdmXbXYLAo9m8lPTFa7VVdD2XuIttbb2O74f3kSQp2e9sWe19veZabZWdnbejLVdNkRUdYWRZTWxdPw2+9S34d//dCooS8L/+rxLpNFy48Kk8leA2EBmy4EgTKoo/OnJ0s9sP/vv+JRH7iQNj+Gcby2ozN/cFqtVVKpUVisXT5PNLmGbplo8xDpjZ7GziPb23924ypwy31xuPM+IgcJP7y7JKsbjM3NzjFIvLlMsryLLCaNSk19ugXD6DohjJRUFM3JsUqtrjQay2Bu55r/fll0FRwPMkFAVeeeWePbTgLhABWXCkuZn465NEYQfFVYcFv+nFDJ7n0GxeAsIgGGeky8tfPTSTnC6ZHzyWjx6btO9nP+li4uDrCAP83EfuH2f2tdoqS0tfpFq9PxGrTV8UTJPN1qlWV4U6+hgQq60BWq3L+y7q7pYXXwTPi4MyvPDCPXtowV0gLpUFJ5LpbUqwX1w1/W/xAgnb7jOZ9BkOG7TbVxiN9vB9l1xu7tDHP1gyv9mI1sFlEHD740I3u3+vt8H6+g8xjBJnzjyfXEjcbBXjnTy34LMjrmgA99wk5MIFeOmlMDN+4QVRrj4qiIAsOJF8nIvU9L/Fiuty+T7a7Tq6nkOSwow23pN82GMcZsxx2H0PMya5V3aTltWm1XofTUuTz8+TydT2ma0Ia8vjz6dpEnLhggjERw3xWyo4kXzcyNTBPcbToqfBYIdsdpbZ2ceA/WNQ0xwMtLc6onUv7SZrtdUkayqVTmPb3X3bpIS15fEnLltvbr5Gq3WZXG5OiPFOMCIgC04k05ujDiqab1a2jTcyTW+CulOv6ZtxL+0mVdVgYeEpfN9NVkhms7PJsQtry+PPp1m2Fhw9hKhLcCI4bC4Zbl/RfFBsdbPHvVNuxaHskzh4TKEdqPsRQ5R78VyCz55PU20tOFqIgCw4Edws8H6Sovlmaunpkajbse/8aXDwtYaGKHNUKiuHmqgIjjefptpacLQQl86CE8HNyrOfVEr+JOORm61e/Cw5bKcz3Ci5g+gZnyRE2frzgwjIghPBnY7zHAzkh41LTWfMR0GxHFt+jkaN5FiO6sWD4N7waa9kFBwNxCcq+FxzMJDfjlXnZ8lhFYGjcLEg+HQQauvPB+K3VyCY4mal76OmWD54IXEULhIEnx6ibP35QARkweeWuAwNNxy1hMOVQCD4rBAqa8HnltGoSasV7ig+SipqgeAwxPjTyUcEZMHnlnS6Qrkc7ig+KqVogeBmhItBHsAwinQ6a2L86QQiStaCzy2yrAphjODYEG/+Ggx2RB/5hCIyZIFAIDgmjEZNxuM+EC4XEUH5ZCECsuBzz722xxQIPk10PU8QBAyHDVG2PmGIgCz43HM7ftcCwWdJNlsnk5kBfLrdq+Ii8oQhesiCzz1HbcZYILgZsqximiUcp/9ZH4rgU0BkyILPPWIrkuC4IcsKqVRO9JFPGCIgCwQRopcsOA7IskqhcApJkkUf+YQhArJAEBH3kuO1iyIwC44ioo98chE1OoEgYv/Gp6OzSEIgmCb2tW61UihKSrRaThDikxQIIuJesu+7yLL6iSKveFWj2LIk+GkTu8zpeg4g+c4KjjfiExQIDnCriyRGoyaDwRbDYYNabVWcEAU/NWy7iyRBu72GJIW3Cde544/oIQsEd0g6XUGSVILAEzPMgp8q6XSFIIDhcId2+4roI58QxCW9QHCHxN7CcdlaIPhpIeaRTyYiQxYI7gIxwyz4LBHzyCcLEZAFAoHgGCLmkU8eIiALBLeBMA8RHBWy2Tq53DymWaDfvy6+kycAEZAFgtsgVlY3GhfFCVDwmSLLKpXKCrKcIpOZFWXrE4AIyALBbSCU1YKjxGjURJIkJEnBslqibH3MEUoUgeA2EMpqwdEjmPojOM6IDFkguE2EslpwVMhm65hmBfAJArFC9LgjArJAIBAcU+J55F5vg9FoT7RRjjkiIAsEAsExRpZVUqkctt2h398Swq5jjAjIAoFAcIzJZutUqw9gGEU6nTUh7DrGiIAsEAgEx5hYaGgYRXzfExnyMUYEZIFAIDjmjEZNxuPQ11rMIx9fREAWCASCE4Cu5wmCQNhoHmNEQBYIBIJjTjZbJ5OZQZIkHKf7WR+O4A4Rg5QCgUBwzJFllUymxnC4iyQpYh75mCIyZIFAIDgB/NEf1fjv/rsH+c53Fmk2L4k+8jFEBGSBQCA45nzrW/BLv5Tit35rkV/7tQd46SVf9JGPISIgCwQCwTHn5ZdBUQI8T0JRAn7wg7TIkI8hIiALBALBMefFF4mCcfjfp59ufNaHJLgDhKhLIBAIjjkXLsBLL8Err8AzzzR57rmxWH5yDBGfmEAgEJwALlwI//h+gcFgBQDfd0VgPkaIkrVAIBCcIOIA3Gp9IIRdxwwRkAUCgeCE4fuusNA8hoiALBAIBCcMWVbR9bwIyscMEZAFAoHghJHN1jHNCpbVEmXrY4QIyAKBQHDCiK00ZVn5rA9FcBsI+Z1AIBCcQNLpCpbVFr7WxwiRIQsEAsEJZDRqYll7jEbNz/pQBLeICMgCgUBwQvF9j+GwIYRdxwQRkAUCgeAEIoRdxw8RkAUCgeAEIssqplnCcboiQz4miIAsEAgEJ5QwKJeFfeYxQXxKAoFAcELJZuvJ/wtf66OPyJAFAoHghCJ8rY8XIiALBALBCUb4Wh8fREAWCASCE4zwtT4+iIAsEAgEJ5hstk4mU0eSJGEScsQRAVkgEAhOMLKs8oMf3M9/9V8t8Ad/UPqsD0fwMYiALBAIBCeYb30LfumXUvzGb1T4pV9K8a1vfdZHJLgZIiALBALBCebll0FRAjxPQlECXnnlsz4iwc0QAVkgEAhOMC++SBSMw/++8MJnfUSCmyGmxAUCgeAEc+ECvPQSvPIKvPBC+HfB0UQEZIFAIDjhXLggAvFxQJSsBQKBQCA4AoiALBAIBALBEUAEZIFAIBAIjgAiIAsEAoFAcAQQAVkgEAgEgiOACMgCgUAgEBwBREAWCAQCgeAIIAKyQCAQCARHABGQBQKBQCA4AoiALBAIBALBEUAEZIFAIBAIjgAiIAsEAoFAcAQQAVkgEAgEgiOACMgCgUAgEBwBREAWCAQCgeAIIAKyQCAQCARHAPVW7hQEAQC9Xu9TPRiBQCAQCE4aceyMY+nNuKWA3O/3AVhaWrrLwxIIBAKB4PNJv9+nUCjc9N+l4JNCNuD7Ppubm+RyOSRJuqcHKBAIBALBSSYIAvr9PvPz88jyzTvFtxSQBQKBQCAQfLoIUZdAIBAIBEcAEZAFAoFAIDgCiIAsEAgEAsERQARkgUAgEAiOACIgCwQCgUBwBBABWSAQCASCI4AIyAKBQCAQHAH+b7GdhD0XIyhuAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = vdm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "for dt, t in zip(dts, ts):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = vdm.step_ddim(x_hat, full_t, sample, dt)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What is interesting here is that the deterministic sampling of DDIM best recovers the Flow Matching ODE samples" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "inf_size = 1024\n", + "sample = vdm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "for dt, t in zip(dts, ts):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " # sample = vdm.step_hybrid_sde(x_hat, full_t, sample, dt)\n", + " sample = vdm.step_ode(x_hat, full_t, sample, dt)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n", + " \n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "inf_size = 1024\n", + "sample = vdm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "for dt, t in zip(dts, ts):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " # sample = vdm.step_hybrid_sde(x_hat, full_t, sample, dt)\n", + " sample = vdm.step_ode(x_hat, full_t, sample, dt, temperature = 1.5)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n", + " \n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "inf_size = 1024\n", + "sample = vdm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "for dt, t in zip(dts, ts):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " # sample = vdm.step_hybrid_sde(x_hat, full_t, sample, dt)\n", + " sample = vdm.step_ode(x_hat, full_t, sample, dt, temperature = 0.5)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n", + " \n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "inf_size = 1024\n", + "sample = vdm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "for dt, t in zip(dts, ts):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = vdm.step_hybrid_sde(x_hat, full_t, sample, dt)\n", + " # sample = vdm.step_ode(x_hat, full_t, sample, dt)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n", + " \n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "moco_bionemo", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/sub-packages/bionemo-moco/examples/discrete_data_interpolant_tutorial.ipynb b/sub-packages/bionemo-moco/examples/discrete_data_interpolant_tutorial.ipynb new file mode 100644 index 0000000000..8b3f72fafd --- /dev/null +++ b/sub-packages/bionemo-moco/examples/discrete_data_interpolant_tutorial.ipynb @@ -0,0 +1,831 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Building Generative Models for Discrete Data via Discrete Interpolants" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import os\n", + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "torch.cuda.manual_seed(42)\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from torch.distributions.categorical import Categorical\n", + "from tqdm import tqdm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tutorial\n", + "\n", + "This notebook walks through how to use 3 discrete data interpolants: (1) Discrete Flow Matching (2) Discrete Denoising Diffusion Probabilistic Models, and (3) Masked Diffusion Language Modeling" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Task\n", + "\n", + "here our object contains 10 binary elements with the goal distribution being a uniform distribution over the 10 elements.\n", + "\n", + "We initalize our interpolants with a binary uniform prior so on average each sample with have a value of 5 out of 10" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Define the Model Architecture" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# training\n", + "B = 32 # batch size\n", + "D = 10 # dimension\n", + "S = 2 # state space\n", + "\n", + "class Model(nn.Module):\n", + " def __init__(self, D, S):\n", + " super().__init__()\n", + " self.embedding = nn.Embedding(S+1, 16)\n", + " self.net = nn.Sequential(\n", + " nn.Linear(17 * D, 128),\n", + " nn.ReLU(),\n", + " nn.Linear(128, 128),\n", + " nn.ReLU(),\n", + " nn.Linear(128, S*D),\n", + " )\n", + "\n", + " def forward(self, x, t):\n", + " B, D = x.shape\n", + " x_emb = self.embedding(x) # (B, D, 16)\n", + " net_input = torch.cat([x_emb, t[:, None, None].repeat(1, D, 1)], dim=-1).reshape(B, -1) # (B, D * 17)\n", + " return self.net(net_input).reshape(B, D, S) # (B, D, S)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Define the Discret Flow Matching Interpolant" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.distributions.prior import DiscreteUniformPrior\n", + "from bionemo.moco.interpolants import DiscreteFlowMatcher\n", + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule\n", + "\n", + "B = 32 # batch size\n", + "D = 10 # dimension\n", + "S = 2 # state space\n", + "\n", + "DEVICE = \"cuda:0\"\n", + "prior = DiscreteUniformPrior(num_classes=S)\n", + "time_distribution = UniformTimeDistribution()\n", + "dfm = DiscreteFlowMatcher(time_distribution=time_distribution,\n", + " prior_distribution=prior,\n", + " device=DEVICE)\n", + "schedule = LinearInferenceSchedule(nsteps = 1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "model = Model(D, S)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train DFM" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/50000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses, label='Training Loss', linestyle='-', color='blue', marker='o')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.title('Training Loss')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sample from DFM" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1000, 10])\n" + ] + } + ], + "source": [ + "num_samples = 1000\n", + "xt = dfm.sample_prior((num_samples, D))\n", + "print(xt.shape)\n", + "ts = schedule.generate_schedule(device=DEVICE)\n", + "dts = schedule.discretize(device=DEVICE)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "for dt, t in zip(dts, ts):\n", + " t = schedule.pad_time(num_samples, t, DEVICE)\n", + " logits = model(xt, t)\n", + " xt = dfm.step(logits, t, xt, dt, stochasticity=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generated DFM Samples" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "counts = xt.cpu().sum(dim=1).float()\n", + "plt.hist(counts.numpy(), bins=range(D+2))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ground Truth Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_ones = torch.randint(0, D+1, (1000,))\n", + "x1 = (torch.arange(D)[None, :] < num_ones[:, None]).long()\n", + "counts = x1.cpu().sum(dim=1).float()\n", + "plt.hist(counts.numpy(), bins=range(D+2))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discrete Uniform Prior Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x0 = dfm.sample_prior((10000, D))\n", + "counts = x0.cpu().sum(dim=1).float()\n", + "plt.hist(counts.numpy(), bins=range(D+2))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## We see that with DFM we are able to approximate the ground truth distribution.Now let's try a different interpolant" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# D3PM Interpolant" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.distributions.prior import DiscreteUniformPrior\n", + "from bionemo.moco.interpolants import D3PM\n", + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule\n", + "from bionemo.moco.schedules.inference_time_schedules import DiscreteLinearInferenceSchedule\n", + "\n", + "B = 32 # batch size\n", + "D = 10 # dimension\n", + "S = 2 # state space\n", + "\n", + "DEVICE = \"cuda:0\"\n", + "prior = DiscreteUniformPrior(num_classes=S)\n", + "time_distribution = UniformTimeDistribution(discrete_time = True, nsteps = 1000)\n", + "noise_schedule = DiscreteCosineNoiseSchedule(nsteps = 1000)\n", + "d3pm = D3PM(time_distribution=time_distribution,\n", + " prior_distribution=prior,\n", + " noise_schedule = noise_schedule,\n", + " device=DEVICE)\n", + "schedule = DiscreteLinearInferenceSchedule(nsteps = 1000, direction=\"diffusion\", device=DEVICE)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.5000, 0.5000], device='cuda:0')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = Model(D, S)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)\n", + "d3pm.terminal_distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train D3PM" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50000/50000 [01:03<00:00, 784.48it/s]\n" + ] + } + ], + "source": [ + "model = model.to(DEVICE)\n", + "losses = []\n", + "for _ in tqdm(range(50000)):\n", + " num_ones = torch.randint(0, D+1, (B,))\n", + " x1 = (torch.arange(D)[None, :] < num_ones[:, None]).long().to(DEVICE)\n", + " # x1 e.g. [1, 1, 1, 0, 0, 0, 0, 0, 0, 0] or [1, 1, 1, 1, 1, 1, 1, 1, 1, 0]\n", + " optimizer.zero_grad()\n", + " # x0 = dfm.sample_prior(x1.shape) # B x D\n", + " t = d3pm.sample_time(B)\n", + " xt = d3pm.interpolate(x1, t)\n", + " logits = model(xt, t) # (B, D, S)\n", + " loss = d3pm.loss(logits, x1, xt, t).mean()\n", + " loss.backward()\n", + " optimizer.step()\n", + " losses.append(loss.item())" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses, label='Training Loss', linestyle='-', color='blue', marker='o')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.title('Training Loss')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.ylim([0,1])\n", + "# plt.yscale('log')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sample from D3PM" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "ts = schedule.generate_schedule()\n", + "num_samples = 1000\n", + "xt = d3pm.sample_prior((num_samples, D))\n", + "for t in ts:\n", + " t = torch.full((xt.shape[0],), t).to(DEVICE)\n", + " logits = model(xt, t)\n", + " xt = d3pm.step(logits, t, xt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## D3PM Generated Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGdCAYAAAA44ojeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAG+VJREFUeJzt3X+MVfWd//HXADLMUmYUGmaYCHW2IcFftSpKR8z+qJOyLjESSbsmdMOikc3uUAWSWtgVjFt11G0twaVQTddqIrXtH9JqUzZkbDCmiIilqWuLNqUrqZlhG8uMYhhZ5n7/6LeTTiVV7J3ez8XHIzmJc86Zw3uO2PvsuefMbahUKpUAABRkXK0HAAD4fQIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4kyo9QDvxfDwcF599dVMmTIlDQ0NtR4HAHgXKpVKXn/99bS3t2fcuD98jaQuA+XVV1/NzJkzaz0GAPAeHDx4MGeeeeYf3KcuA2XKlClJfvMDNjc313gaAODdGBwczMyZM0dex/+QugyU376t09zcLFAAoM68m9sz3CQLABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxZlQ6wGAP+ysNd+t9Qjv6Bd3Laz1CO/IeYT64goKAFAcgQIAFOekA+Wpp57KVVddlfb29jQ0NGTbtm2jtlcqlaxfvz4zZsxIU1NTurq68vLLL4/a57XXXsuSJUvS3Nyc008/Pddff33eeOONP+oHAQBOHScdKEeOHMkFF1yQTZs2nXD7Pffck40bN2bLli3ZvXt3Jk+enAULFuTo0aMj+yxZsiT//d//nR07duSJJ57IU089leXLl7/3nwIAOKWc9E2yV155Za688soTbqtUKtmwYUNuueWWXH311UmShx9+OK2trdm2bVuuvfba/OQnP8n27duzZ8+ezJ07N0ly33335W//9m/zhS98Ie3t7X/EjwMAnAqqeg/KgQMH0tfXl66urpF1LS0tmTdvXnbt2pUk2bVrV04//fSROEmSrq6ujBs3Lrt37z7hcYeGhjI4ODhqAQBOXVV9zLivry9J0traOmp9a2vryLa+vr5Mnz599BATJmTq1Kkj+/y+np6e3HbbbdUclT8Bj3UC8F7VxVM8a9euzcDAwMhy8ODBWo8EAIyhqgZKW1tbkqS/v3/U+v7+/pFtbW1tOXTo0Kjt//d//5fXXnttZJ/f19jYmObm5lELAHDqqmqgdHR0pK2tLb29vSPrBgcHs3v37nR2diZJOjs7c/jw4ezdu3dknyeffDLDw8OZN29eNccBAOrUSd+D8sYbb+RnP/vZyNcHDhzIvn37MnXq1MyaNSsrV67M7bffntmzZ6ejoyPr1q1Le3t7Fi1alCQ5++yz8zd/8ze54YYbsmXLlhw7diwrVqzItdde6wkeqFP1cL8RUF9OOlCee+65/PVf//XI16tXr06SLF26NF/72tdy880358iRI1m+fHkOHz6cyy+/PNu3b8+kSZNGvueRRx7JihUrcsUVV2TcuHFZvHhxNm7cWIUfBwA4FTRUKpVKrYc4WYODg2lpacnAwID7UQpWD/+vuh6e4qmH80h11MPfR/hjnMzrd108xQMAvL8IFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4J/1ZPABQsnr4eAgfa/DOXEEBAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4E2o9AAC/cdaa79Z6hHf0i7sW1nqEU4J/1+/MFRQAoDgCBQAojrd4AHjX6uGtCU4NrqAAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMXxaca8r/lkVoAyuYICABRHoAAAxal6oBw/fjzr1q1LR0dHmpqa8uEPfzif//znU6lURvapVCpZv359ZsyYkaampnR1deXll1+u9igAQJ2q+j0od999dzZv3pyHHnoo5557bp577rksW7YsLS0tufHGG5Mk99xzTzZu3JiHHnooHR0dWbduXRYsWJAXX3wxkyZNqvZIpyT3TgBwKqt6oPzgBz/I1VdfnYULFyZJzjrrrHz961/Ps88+m+Q3V082bNiQW265JVdffXWS5OGHH05ra2u2bduWa6+9ttojAQB1pupv8Vx22WXp7e3NSy+9lCT50Y9+lKeffjpXXnllkuTAgQPp6+tLV1fXyPe0tLRk3rx52bVr1wmPOTQ0lMHBwVELAHDqqvoVlDVr1mRwcDBz5szJ+PHjc/z48dxxxx1ZsmRJkqSvry9J0traOur7WltbR7b9vp6entx2223VHhUAKFTVr6B885vfzCOPPJKtW7fm+eefz0MPPZQvfOELeeihh97zMdeuXZuBgYGR5eDBg1WcGAAoTdWvoHz2s5/NmjVrRu4lOf/88/M///M/6enpydKlS9PW1pYk6e/vz4wZM0a+r7+/Px/96EdPeMzGxsY0NjZWe1QAoFBVv4Ly5ptvZty40YcdP358hoeHkyQdHR1pa2tLb2/vyPbBwcHs3r07nZ2d1R4HAKhDVb+CctVVV+WOO+7IrFmzcu655+aHP/xh7r333lx33XVJkoaGhqxcuTK33357Zs+ePfKYcXt7exYtWlTtcd4Tj/ACQG1VPVDuu+++rFu3Lv/8z/+cQ4cOpb29Pf/4j/+Y9evXj+xz880358iRI1m+fHkOHz6cyy+/PNu3b/c7UACAJElD5Xd/xWudGBwcTEtLSwYGBtLc3Fz147uCAsD73S/uWlj1Y57M67fP4gEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOKMSaD88pe/zKc//elMmzYtTU1NOf/88/Pcc8+NbK9UKlm/fn1mzJiRpqamdHV15eWXXx6LUQCAOlT1QPn1r3+d+fPn57TTTsv3vve9vPjii/niF7+YM844Y2Sfe+65Jxs3bsyWLVuye/fuTJ48OQsWLMjRo0erPQ4AUIcmVPuAd999d2bOnJkHH3xwZF1HR8fIP1cqlWzYsCG33HJLrr766iTJww8/nNbW1mzbti3XXntttUcCAOpM1a+gfOc738ncuXPzyU9+MtOnT8+FF16YBx54YGT7gQMH0tfXl66urpF1LS0tmTdvXnbt2nXCYw4NDWVwcHDUAgCcuqoeKD//+c+zefPmzJ49O//1X/+Vf/qnf8qNN96Yhx56KEnS19eXJGltbR31fa2trSPbfl9PT09aWlpGlpkzZ1Z7bACgIFUPlOHh4Vx00UW58847c+GFF2b58uW54YYbsmXLlvd8zLVr12ZgYGBkOXjwYBUnBgBKU/VAmTFjRs4555xR684+++y88sorSZK2trYkSX9//6h9+vv7R7b9vsbGxjQ3N49aAIBTV9UDZf78+dm/f/+odS+99FI+9KEPJfnNDbNtbW3p7e0d2T44OJjdu3ens7Oz2uMAAHWo6k/xrFq1KpdddlnuvPPOfOpTn8qzzz6b+++/P/fff3+SpKGhIStXrsztt9+e2bNnp6OjI+vWrUt7e3sWLVpU7XEAgDpU9UC55JJL8thjj2Xt2rX5t3/7t3R0dGTDhg1ZsmTJyD4333xzjhw5kuXLl+fw4cO5/PLLs3379kyaNKna4wAAdaihUqlUaj3EyRocHExLS0sGBgbG5H6Us9Z8t+rHBIB68ou7Flb9mCfz+u2zeACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDhjHih33XVXGhoasnLlypF1R48eTXd3d6ZNm5YPfOADWbx4cfr7+8d6FACgToxpoOzZsydf+cpX8pGPfGTU+lWrVuXxxx/Pt771rezcuTOvvvpqrrnmmrEcBQCoI2MWKG+88UaWLFmSBx54IGecccbI+oGBgXz1q1/Nvffem49//OO5+OKL8+CDD+YHP/hBnnnmmbEaBwCoI2MWKN3d3Vm4cGG6urpGrd+7d2+OHTs2av2cOXMya9as7Nq164THGhoayuDg4KgFADh1TRiLgz766KN5/vnns2fPnrdt6+vry8SJE3P66aePWt/a2pq+vr4THq+npye33XbbWIwKABSo6ldQDh48mJtuuimPPPJIJk2aVJVjrl27NgMDAyPLwYMHq3JcAKBMVQ+UvXv35tChQ7nooosyYcKETJgwITt37szGjRszYcKEtLa25q233srhw4dHfV9/f3/a2tpOeMzGxsY0NzePWgCAU1fV3+K54oor8uMf/3jUumXLlmXOnDn53Oc+l5kzZ+a0005Lb29vFi9enCTZv39/XnnllXR2dlZ7HACgDlU9UKZMmZLzzjtv1LrJkydn2rRpI+uvv/76rF69OlOnTk1zc3M+85nPpLOzMx/72MeqPQ4AUIfG5CbZd/KlL30p48aNy+LFizM0NJQFCxbky1/+ci1GAQAK1FCpVCq1HuJkDQ4OpqWlJQMDA2NyP8pZa75b9WMCQD35xV0Lq37Mk3n99lk8AEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQnKoHSk9PTy655JJMmTIl06dPz6JFi7J///5R+xw9ejTd3d2ZNm1aPvCBD2Tx4sXp7++v9igAQJ2qeqDs3Lkz3d3deeaZZ7Jjx44cO3Ysn/jEJ3LkyJGRfVatWpXHH3883/rWt7Jz5868+uqrueaaa6o9CgBQpyZU+4Dbt28f9fXXvva1TJ8+PXv37s1f/MVfZGBgIF/96lezdevWfPzjH0+SPPjggzn77LPzzDPP5GMf+1i1RwIA6syY34MyMDCQJJk6dWqSZO/evTl27Fi6urpG9pkzZ05mzZqVXbt2nfAYQ0NDGRwcHLUAAKeuMQ2U4eHhrFy5MvPnz895552XJOnr68vEiRNz+umnj9q3tbU1fX19JzxOT09PWlpaRpaZM2eO5dgAQI2NaaB0d3fnhRdeyKOPPvpHHWft2rUZGBgYWQ4ePFilCQGAElX9HpTfWrFiRZ544ok89dRTOfPMM0fWt7W15a233srhw4dHXUXp7+9PW1vbCY/V2NiYxsbGsRoVAChM1a+gVCqVrFixIo899liefPLJdHR0jNp+8cUX57TTTktvb+/Iuv379+eVV15JZ2dntccBAOpQ1a+gdHd3Z+vWrfn2t7+dKVOmjNxX0tLSkqamprS0tOT666/P6tWrM3Xq1DQ3N+czn/lMOjs7PcEDACQZg0DZvHlzkuSv/uqvRq1/8MEH8w//8A9Jki996UsZN25cFi9enKGhoSxYsCBf/vKXqz0KAFCnqh4olUrlHfeZNGlSNm3alE2bNlX7jwcATgE+iwcAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIpT00DZtGlTzjrrrEyaNCnz5s3Ls88+W8txAIBC1CxQvvGNb2T16tW59dZb8/zzz+eCCy7IggULcujQoVqNBAAUomaBcu+99+aGG27IsmXLcs4552TLli35sz/7s/znf/5nrUYCAAoxoRZ/6FtvvZW9e/dm7dq1I+vGjRuXrq6u7Nq16237Dw0NZWhoaOTrgYGBJMng4OCYzDc89OaYHBcA6sVYvMb+9piVSuUd961JoPzqV7/K8ePH09raOmp9a2trfvrTn75t/56entx2221vWz9z5swxmxEA3s9aNozdsV9//fW0tLT8wX1qEigna+3atVm9evXI18PDw3nttdcybdq0NDQ0VPXPGhwczMyZM3Pw4ME0NzdX9djvJ85jdTiP1eE8VofzWB3v5/NYqVTy+uuvp729/R33rUmgfPCDH8z48ePT398/an1/f3/a2tretn9jY2MaGxtHrTv99NPHcsQ0Nze/7/7ijAXnsTqcx+pwHqvDeayO9+t5fKcrJ79Vk5tkJ06cmIsvvji9vb0j64aHh9Pb25vOzs5ajAQAFKRmb/GsXr06S5cuzdy5c3PppZdmw4YNOXLkSJYtW1arkQCAQtQsUP7u7/4u//u//5v169enr68vH/3oR7N9+/a33Tj7p9bY2Jhbb731bW8pcXKcx+pwHqvDeawO57E6nMd3p6Hybp71AQD4E/JZPABAcQQKAFAcgQIAFEegAADFESi/Y9OmTTnrrLMyadKkzJs3L88++2ytR6orPT09ueSSSzJlypRMnz49ixYtyv79+2s9Vt2766670tDQkJUrV9Z6lLrzy1/+Mp/+9Kczbdq0NDU15fzzz89zzz1X67HqyvHjx7Nu3bp0dHSkqakpH/7wh/P5z3/+XX2WyvvZU089lauuuirt7e1paGjItm3bRm2vVCpZv359ZsyYkaampnR1deXll1+uzbCFEij/3ze+8Y2sXr06t956a55//vlccMEFWbBgQQ4dOlTr0erGzp07093dnWeeeSY7duzIsWPH8olPfCJHjhyp9Wh1a8+ePfnKV76Sj3zkI7Uepe78+te/zvz583Paaafle9/7Xl588cV88YtfzBlnnFHr0erK3Xffnc2bN+c//uM/8pOf/CR333137rnnntx33321Hq1oR44cyQUXXJBNmzadcPs999yTjRs3ZsuWLdm9e3cmT56cBQsW5OjRo3/iSQtWoVKpVCqXXnpppbu7e+Tr48ePV9rb2ys9PT01nKq+HTp0qJKksnPnzlqPUpdef/31yuzZsys7duyo/OVf/mXlpptuqvVIdeVzn/tc5fLLL6/1GHVv4cKFleuuu27UumuuuaayZMmSGk1Uf5JUHnvssZGvh4eHK21tbZV///d/H1l3+PDhSmNjY+XrX/96DSYskysoSd56663s3bs3XV1dI+vGjRuXrq6u7Nq1q4aT1beBgYEkydSpU2s8SX3q7u7OwoULR/295N37zne+k7lz5+aTn/xkpk+fngsvvDAPPPBArceqO5dddll6e3vz0ksvJUl+9KMf5emnn86VV15Z48nq14EDB9LX1zfqv+2WlpbMmzfPa87vqItPMx5rv/rVr3L8+PG3/Rbb1tbW/PSnP63RVPVteHg4K1euzPz583PeeefVepy68+ijj+b555/Pnj17aj1K3fr5z3+ezZs3Z/Xq1fmXf/mX7NmzJzfeeGMmTpyYpUuX1nq8urFmzZoMDg5mzpw5GT9+fI4fP5477rgjS5YsqfVodauvry9JTvia89ttCBTGSHd3d1544YU8/fTTtR6l7hw8eDA33XRTduzYkUmTJtV6nLo1PDycuXPn5s4770ySXHjhhXnhhReyZcsWgXISvvnNb+aRRx7J1q1bc+6552bfvn1ZuXJl2tvbnUfGlLd4knzwgx/M+PHj09/fP2p9f39/2traajRV/VqxYkWeeOKJfP/738+ZZ55Z63Hqzt69e3Po0KFcdNFFmTBhQiZMmJCdO3dm48aNmTBhQo4fP17rEevCjBkzcs4554xad/bZZ+eVV16p0UT16bOf/WzWrFmTa6+9Nueff37+/u//PqtWrUpPT0+tR6tbv31d8ZrzhwmUJBMnTszFF1+c3t7ekXXDw8Pp7e1NZ2dnDSerL5VKJStWrMhjjz2WJ598Mh0dHbUeqS5dccUV+fGPf5x9+/aNLHPnzs2SJUuyb9++jB8/vtYj1oX58+e/7TH3l156KR/60IdqNFF9evPNNzNu3OiXivHjx2d4eLhGE9W/jo6OtLW1jXrNGRwczO7du73m/A5v8fx/q1evztKlSzN37txceuml2bBhQ44cOZJly5bVerS60d3dna1bt+bb3/52pkyZMvJeaktLS5qammo8Xf2YMmXK2+7bmTx5cqZNm+Z+npOwatWqXHbZZbnzzjvzqU99Ks8++2zuv//+3H///bUera5cddVVueOOOzJr1qyce+65+eEPf5h777031113Xa1HK9obb7yRn/3sZyNfHzhwIPv27cvUqVMza9asrFy5Mrfffntmz56djo6OrFu3Lu3t7Vm0aFHthi5NrR8jKsl9991XmTVrVmXixImVSy+9tPLMM8/UeqS6kuSEy4MPPljr0eqex4zfm8cff7xy3nnnVRobGytz5syp3H///bUeqe4MDg5WbrrppsqsWbMqkyZNqvz5n/955V//9V8rQ0NDtR6taN///vdP+L+HS5curVQqv3nUeN26dZXW1tZKY2Nj5Yorrqjs37+/tkMXpqFS8esAAYCyuAcFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOP8P0rE7M2wRmLQAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "counts = xt.cpu().sum(dim=1).float()\n", + "plt.hist(counts.numpy(), bins=range(D+2))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## D3PM Prior Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xt = d3pm.sample_prior((num_samples, D))\n", + "counts = xt.cpu().sum(dim=1).float()\n", + "plt.hist(counts.numpy(), bins=range(D+2))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Now let's try a new interpolant and a new prior" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MDLM Interpolant" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.distributions.prior import DiscreteMaskedPrior\n", + "from bionemo.moco.interpolants import MDLM\n", + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.schedules.noise.continuous_noise_transforms import CosineExpNoiseTransform\n", + "from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule\n", + "\n", + "DEVICE = \"cuda:0\"\n", + "prior = DiscreteMaskedPrior(num_classes = 2, inclusive = False)\n", + "time_distribution = UniformTimeDistribution(discrete_time = False)\n", + "noise_schedule = CosineExpNoiseTransform()\n", + "mdlm = MDLM(time_distribution=time_distribution,\n", + " prior_distribution=prior,\n", + " noise_schedule = noise_schedule,\n", + " device=DEVICE)\n", + "schedule = LinearInferenceSchedule(direction = \"diffusion\", nsteps = 1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prior.num_classes # The inclusive flag allows us to chose whether or not to add a dimension" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train MDLM" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50000/50000 [01:32<00:00, 541.11it/s]\n" + ] + } + ], + "source": [ + "# training\n", + "B = 32 # batch size\n", + "D = 10 # dimension\n", + "S = 3 # state space\n", + "\n", + "model = Model(D, S)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)\n", + " \n", + "model = model.to(DEVICE)\n", + "losses = []\n", + "for _ in tqdm(range(50000)):\n", + " num_ones = torch.randint(0, D+1, (B,))\n", + " x1 = (torch.arange(D)[None, :] < num_ones[:, None]).long().to(DEVICE)\n", + " # x1 e.g. [1, 1, 1, 0, 0, 0, 0, 0, 0, 0] or [1, 1, 1, 1, 1, 1, 1, 1, 1, 0]\n", + " optimizer.zero_grad()\n", + " # x0 = dfm.sample_prior(x1.shape) # B x D\n", + " t = mdlm.sample_time(B)\n", + " xt = mdlm.interpolate(x1, t)\n", + " logits = model(xt, t) # (B, D, S)\n", + " loss = mdlm.loss(logits, x1, xt, t).mean()\n", + " loss.backward()\n", + " optimizer.step()\n", + " losses.append(loss.item())" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses, label='Training Loss', linestyle='-', color='blue', marker='o')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.title('Training Loss')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.ylim([0,1])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize the MASK Prior" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_samples = 1000\n", + "xt = mdlm.sample_prior((num_samples, D))\n", + "counts = xt.flatten().cpu()\n", + "\n", + "# Compute frequency of each class index\n", + "class_counts = torch.bincount(counts)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(8, 5))\n", + "plt.bar(range(len(class_counts)), class_counts.numpy(), color='red')\n", + "plt.xlabel('Class Index')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Discrete Distribution of Class Indices')\n", + "plt.xticks(range(len(class_counts))) # Set x-ticks to class indices\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Sample from the MDLM trained model" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "num_samples = 1000\n", + "xt = mdlm.sample_prior((num_samples, D))\n", + "for dt, t in zip(dts, ts):\n", + " t = torch.full((xt.shape[0],), t).to(DEVICE)\n", + " logits = model(xt, t)\n", + " xt = mdlm.step(logits, t, xt, dt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualize the class breakdown (green) and generated samples (blue)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "counts = xt.flatten().cpu()\n", + "\n", + "# Compute frequency of each class index\n", + "class_counts = torch.bincount(counts)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(8, 5))\n", + "plt.bar(range(len(class_counts)), class_counts.numpy(), color='green')\n", + "plt.xlabel('Class Index')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Discrete Distribution of Class Indices')\n", + "plt.xticks(range(len(class_counts))) # Set x-ticks to class indices\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "counts = xt.cpu().sum(dim=1).float()\n", + "plt.hist(counts.numpy(), bins=range(D+2))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## here we can take binary data and rather than using a uniform prior introduce a MASK state. Here MDLM trained on the same data is able to generate the desired discrete data shown ion blue although starting from pure MASK states seen in red." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "moco_bionemo", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/sub-packages/bionemo-moco/pyproject.toml b/sub-packages/bionemo-moco/pyproject.toml new file mode 100644 index 0000000000..1b3c30ce35 --- /dev/null +++ b/sub-packages/bionemo-moco/pyproject.toml @@ -0,0 +1,34 @@ +[build-system] +requires = ["setuptools>=64", "wheel"] +build-backend = "setuptools.build_meta" + +[project] +name = "bionemo-moco" +readme = "README.md" +description = "BioNeMo Modular Co-Design: Making building Diffusion and Flow Matching generative models easier" +authors = [{ name = "BioNeMo Team", email = "bionemofeedback@nvidia.com" }] +requires-python = ">=3.10" +license = { file = "LICENSE" } +dynamic = ["version"] +dependencies = [ + # bionemo sub-packages + # external + 'torch>=2.2', + 'numpy>=1.24.4,<2', + 'jaxtyping>=0.2.34', + 'pot>=0.9.5', + 'scikit-learn>=1.6.0', + 'matplotlib>=3.3.2' +] + +[tool.setuptools.packages.find] +where = ["src"] +include = ["bionemo.*"] +namespaces = true +exclude = ["test*."] + +[tool.setuptools.dynamic] +version = { file = "VERSION" } + +[tool.uv] +cache-keys = [{ git = true }] diff --git a/sub-packages/bionemo-moco/scripts/README.md b/sub-packages/bionemo-moco/scripts/README.md new file mode 100644 index 0000000000..8993e43d56 --- /dev/null +++ b/sub-packages/bionemo-moco/scripts/README.md @@ -0,0 +1,35 @@ +# Create Documentation Script (create_documentation.sh) + +## Overview +--------------- + +The `create_documentation.sh` script automates the process of generating local documentation for the `bionemo.moco` project and ensures its accuracy by performing a post-generation cleanup. This process enhances discoverability and maintainability of the project's codebase including local changes. + +### Usage +--------- + +```bash +./create_documentation.sh +``` + +## Step-by-Step Process Explained +------------------------------------ + +### 1. **Generating Documentation with pydoc-markdown** + +* **Command:** `pydoc-markdown -I src/bionemo --render-toc > documentation.md` +* **Description:** This step leverages `pydoc-markdown` to parse the `src/bionemo` directory, generating Markdown documentation. The `--render-toc` flag includes a Table of Contents for easier navigation. The output is redirected to a file named `documentation.md`. + +### 2. **Cleaning and Refining Documentation** + +* **Command:** `python scripts/clean_documentation.py` +* **Description:** Following the initial documentation generation, this Python script (`clean_documentation.py`) is executed to: + + Remove redundant or unnecessary sections. + + Ensure proper linkage within the documentation (e.g., fixing internal references). + + Optionally, format code blocks and tables for better readability. + +## Output +---------- + +* **Location:** The refined documentation will be available in the project's root directory as `documentation.md`. +* **Content:** A comprehensive, readable, and accurately linked documentation for `bionemo.moco`, covering modules, classes, functions, and variables documented within the `src/bionemo` directory. diff --git a/sub-packages/bionemo-moco/scripts/clean_documentation.py b/sub-packages/bionemo-moco/scripts/clean_documentation.py new file mode 100644 index 0000000000..8992720332 --- /dev/null +++ b/sub-packages/bionemo-moco/scripts/clean_documentation.py @@ -0,0 +1,43 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import re + + +with open("documentation.md", "r") as file: + lines = file.readlines() + +# Delete lines that start with " * " and " * " +lines = [line for line in lines if not line.startswith(" * ") and not line.startswith(" * ")] + +# Join the lines back into a string +markdown = "".join(lines) + +# Replace dots with no space in anchor ids +markdown = re.sub(r'', lambda match: f'', markdown) + +# Replace dots with no space in links +markdown = re.sub( + r"\[([^\]]+)\]\(#([a-zA-Z0-9_\.]+)\)", + lambda match: f'[{match.group(1)}](#{match.group(2).replace(".", "")})', + markdown, +) + +# Replace 'moco.' with 'bionemo.moco.' +markdown = re.sub(r"moco\.", "bionemo.moco.", markdown) + +with open("documentation.md", "w") as file: + file.write(markdown) diff --git a/sub-packages/bionemo-moco/scripts/create_documentation.sh b/sub-packages/bionemo-moco/scripts/create_documentation.sh new file mode 100644 index 0000000000..44027eb127 --- /dev/null +++ b/sub-packages/bionemo-moco/scripts/create_documentation.sh @@ -0,0 +1,2 @@ + pydoc-markdown -I src/bionemo --render-toc > documentation.md + python scripts/clean_documentation.py diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/__init__.py new file mode 100644 index 0000000000..67abd91797 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/__init__.py @@ -0,0 +1,20 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from .schedules.utils import TimeDirection + + +__all__ = ["TimeDirection"] diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/__init__.py new file mode 100644 index 0000000000..af646f22ba --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/__init__.py @@ -0,0 +1,23 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from .continuous.gaussian import GaussianPrior +from .discrete.custom import DiscreteCustomPrior +from .discrete.mask import DiscreteMaskedPrior +from .discrete.uniform import DiscreteUniformPrior + + +__all__ = ["GaussianPrior", "DiscreteUniformPrior", "DiscreteMaskedPrior", "DiscreteCustomPrior"] diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/gaussian.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/gaussian.py new file mode 100644 index 0000000000..01fb494195 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/gaussian.py @@ -0,0 +1,80 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from typing import Optional, Tuple, Union + +import torch +from jaxtyping import Bool, Float +from torch import Tensor + +from bionemo.moco.distributions.prior.continuous.utils import remove_center_of_mass +from bionemo.moco.distributions.prior.distribution import PriorDistribution + + +class GaussianPrior(PriorDistribution): + """A subclass representing a Gaussian prior distribution.""" + + def __init__( + self, + mean: Float = 0.0, + std: Float = 1.0, + center: Bool = False, + rng_generator: Optional[torch.Generator] = None, + ) -> None: + """Gaussian prior distribution. + + Args: + mean (Float): The mean of the Gaussian distribution. Defaults to 0.0. + std (Float): The standard deviation of the Gaussian distribution. Defaults to 1.0. + center (bool): Whether to center the samples around the mean. Defaults to False. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + self.mean = mean + self.std = std + self.center = center + self.rng_generator = rng_generator + + def sample( + self, + shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ) -> Tensor: + """Generates a specified number of samples from the Gaussian prior distribution. + + Args: + shape (Tuple): The shape of the samples to generate. + device (str): cpu or gpu. + mask (Optional[Tensor]): An optional mask to apply to the samples. Defaults to None. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + Float: A tensor of samples. + """ + if rng_generator is None: + rng_generator = self.rng_generator + samples = torch.randn(*shape, device=device, generator=rng_generator) + if self.std != 1: + samples = samples * self.std + if self.mean != 0: + samples = samples + self.mean + + if self.center: + samples = remove_center_of_mass(samples, mask) + if mask is not None: + samples = samples * mask.unsqueeze(-1) + return samples diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/harmonic.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/harmonic.py new file mode 100644 index 0000000000..ba320072da --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/harmonic.py @@ -0,0 +1,103 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from typing import Optional, Tuple, Union + +import torch +from jaxtyping import Bool, Float +from torch import Tensor + +from bionemo.moco.distributions.prior.continuous.utils import remove_center_of_mass +from bionemo.moco.distributions.prior.distribution import PriorDistribution + + +class LinearHarmonicPrior(PriorDistribution): + """A subclass representing a Gaussian prior distribution.""" + + def __init__( + self, + distance: Float = 3.8, + length: Optional[int] = None, + center: Bool = False, + rng_generator: Optional[torch.Generator] = None, + device: Union[str, torch.device] = "cpu", + ) -> None: + """Gaussian prior distribution. + + Args: + distance (Float): RMS distance between adjacent points in the line graph. + length (Optional[int]): The number of points in a batch. + center (bool): Whether to center the samples around the mean. Defaults to False. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + self.distance = distance + self.length = length + self.center = center + self.rng_generator = rng_generator + self.device = device + if length: + self._calculate_terms(length, device) + + def _calculate_terms(self, N, device): + a = 3 / (self.distance * self.distance) + J = torch.zeros(N, N) + for i, j in zip(torch.arange(N - 1), torch.arange(1, N)): + J[i, i] += a + J[j, j] += a + J[i, j] = J[j, i] = -a + D, P = torch.linalg.eigh(J) + D_inv = 1 / D + D_inv[0] = 0 + self.P, self.D_inv = P.to(device), D_inv.to(device) + + def sample( + self, + shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ) -> Tensor: + """Generates a specified number of samples from the Harmonic prior distribution. + + Args: + shape (Tuple): The shape of the samples to generate. + device (str): cpu or gpu. + mask (Optional[Tensor]): An optional mask to apply to the samples. Defaults to None. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + Float: A tensor of samples. + """ + if len(shape) != 3: + raise ValueError("Input shape can only work for B x L x D") + if rng_generator is None: + rng_generator = self.rng_generator + samples = torch.randn(*shape, device=device, generator=rng_generator) + N = shape[1] + + if N != self.length: + self._calculate_terms(N, device) + + std = torch.sqrt(self.D_inv).unsqueeze(-1) + samples = self.P @ (std * samples) + + if self.center: + samples = remove_center_of_mass(samples, mask) + + if mask is not None: + samples = samples * mask.unsqueeze(-1) + return samples diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/utils.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/utils.py new file mode 100644 index 0000000000..9a9bf9dfe5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/utils.py @@ -0,0 +1,38 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from typing import Optional + +from torch import Tensor + + +def remove_center_of_mass(data: Tensor, mask: Optional[Tensor] = None) -> Tensor: + """Calculates the center of mass (CoM) of the given data. + + Args: + data: The input data with shape (..., nodes, features). + mask: An optional binary mask to apply to the data with shape (..., nodes) to mask out interaction from CoM calculation. Defaults to None. + + Returns: + The CoM of the data with shape (..., 1, features). + """ + if mask is None: + com = data.mean(dim=-2, keepdim=True) + else: + masked_data = data * mask.unsqueeze(-1) + num_nodes = mask.sum(dim=-1, keepdim=True).unsqueeze(-1) + com = masked_data.sum(dim=-2, keepdim=True) / num_nodes + return data - com diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/custom.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/custom.py new file mode 100644 index 0000000000..6b2f040b77 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/custom.py @@ -0,0 +1,72 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import math +from typing import Optional, Tuple, Union + +import torch +from torch import Tensor + +from bionemo.moco.distributions.prior.distribution import DiscretePriorDistribution + + +class DiscreteCustomPrior(DiscretePriorDistribution): + """A subclass representing a discrete custom prior distribution. + + This class allows for the creation of a prior distribution with a custom + probability mass function defined by the `prior_dist` tensor. For example if my data has 4 classes and I want [.3, .2, .4, .1] as the probabilities of the 4 classes. + """ + + def __init__(self, prior_dist: Tensor, num_classes: int = 10) -> None: + """Initializes a DiscreteCustomPrior distribution. + + Args: + prior_dist: A tensor representing the probability mass function of the prior distribution. + num_classes: The number of classes in the prior distribution. Defaults to 10. + + Note: + The `prior_dist` tensor should have a sum close to 1.0, as it represents a probability mass function. + """ + super().__init__(num_classes, prior_dist) + if torch.sum(self.prior_dist).item() - 1.0 > 1e-5: + raise ValueError("Prior distribution probabilities do not sum up to 1.0") + + def sample( + self, + shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ) -> Tensor: + """Samples from the discrete custom prior distribution. + + Args: + shape: A tuple specifying the shape of the samples to generate. + mask: An optional tensor mask to apply to the samples, broadcastable to the sample shape. Defaults to None. + device: The device on which to generate the samples, specified as a string or a :class:`torch.device`. Defaults to "cpu". + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + A tensor of samples drawn from the prior distribution. + """ + samples = ( + torch.multinomial(self.prior_dist, math.prod(shape), replacement=True, generator=rng_generator) + .to(device) + .reshape(shape) + ) + if mask is not None: + samples = samples * mask[(...,) + (None,) * (len(samples.shape) - len(mask.shape))] + return samples diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/mask.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/mask.py new file mode 100644 index 0000000000..cd8031cc99 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/mask.py @@ -0,0 +1,112 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from typing import Optional, Tuple, Union + +import torch +from torch import Tensor + +from bionemo.moco.distributions.prior.distribution import DiscretePriorDistribution + + +class DiscreteMaskedPrior(DiscretePriorDistribution): + """A subclass representing a Discrete Masked prior distribution.""" + + def __init__(self, num_classes: int = 10, mask_dim: Optional[int] = None, inclusive: bool = True) -> None: + """Discrete Masked prior distribution. + + Theres 3 ways I can think of defining the problem that are hard to mesh together. + + 1. [..., M, ....] inclusive anywhere --> exisiting LLM tokenizer where the mask has a specific location not at the end + 2. [......, M] inclusive on end --> mask_dim = None with inclusive set to True default stick on the end + 3. [.....] + [M] exclusive --> the number of classes representes the number of data classes and one wishes to add a separate MASK dimension. + - Note the pad_sample function is provided to help add this extra external dimension. + + Args: + num_classes (int): The number of classes in the distribution. Defaults to 10. + mask_dim (int): The index for the mask token. Defaults to num_classes - 1 if inclusive or num_classes if exclusive. + inclusive (bool): Whether the mask is included in the specified number of classes. + If True, the mask is considered as one of the classes. + If False, the mask is considered as an additional class. Defaults to True. + """ + if inclusive: + if mask_dim is None: + mask_dim = num_classes - 1 + else: + if mask_dim >= num_classes: + raise ValueError( + "As Inclusive accounts for the mask as one of the specified num_classes, the provided mask_dim cannot be >= to num_classes" + ) + prior_dist = torch.zeros((num_classes)) + prior_dist[-1] = 1.0 + super().__init__(num_classes, prior_dist) + self.mask_dim = mask_dim + else: + prior_dist = torch.zeros((num_classes + 1)) + prior_dist[-1] = 1.0 + super().__init__(num_classes + 1, prior_dist) + self.mask_dim = num_classes + if torch.sum(self.prior_dist).item() - 1.0 >= 1e-5: + raise ValueError("Invalid probability distribution. Must sum to 1.0") + + def sample( + self, + shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ) -> Tensor: + """Generates a specified number of samples. + + Args: + shape (Tuple): The shape of the samples to generate. + device (str): cpu or gpu. + mask (Optional[Tensor]): An optional mask to apply to the samples. Defaults to None. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + Float: A tensor of samples. + """ + samples = torch.ones(shape, dtype=torch.int64, device=device) * self.mask_dim + if mask is not None: + samples = samples * mask[(...,) + (None,) * (len(samples.shape) - len(mask.shape))] + return samples + + def is_masked(self, sample: Tensor) -> Tensor: + """Creates a mask for whether a state is masked. + + Args: + sample (Tensor): The sample to check. + + Returns: + Tensor: A float tensor indicating whether the sample is masked. + """ + return (sample == self.mask_dim).float() + + def pad_sample(self, sample: Tensor) -> Tensor: + """Pads the input sample with zeros along the last dimension. + + Args: + sample (Tensor): The input sample to be padded. + + Returns: + Tensor: The padded sample. + """ + # Create a zeros tensor with the same shape as the original tensor, except the last dimension is 1 + zeros = torch.zeros((*sample.shape[:-1], 1), dtype=torch.float, device=sample.device) + # Concatenate along the last dimension to make the shape (..., N+1) + padded_sample = torch.cat((sample, zeros), dim=-1) + return padded_sample diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/uniform.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/uniform.py new file mode 100644 index 0000000000..53a71b601e --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/uniform.py @@ -0,0 +1,60 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from typing import Optional, Tuple, Union + +import torch +from torch import Tensor + +from bionemo.moco.distributions.prior.distribution import DiscretePriorDistribution + + +class DiscreteUniformPrior(DiscretePriorDistribution): + """A subclass representing a discrete uniform prior distribution.""" + + def __init__(self, num_classes: int = 10) -> None: + """Initializes a discrete uniform prior distribution. + + Args: + num_classes (int): The number of classes in the discrete uniform distribution. Defaults to 10. + """ + prior_dist = torch.ones((num_classes)) * 1 / num_classes + super().__init__(num_classes, prior_dist) + if torch.sum(self.prior_dist).item() - 1.0 > 1e-5: + raise ValueError("Prior distribution probabilities do not sum up to 1.0") + + def sample( + self, + shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ) -> Tensor: + """Generates a specified number of samples. + + Args: + shape (Tuple): The shape of the samples to generate. + device (str): cpu or gpu. + mask (Optional[Tensor]): An optional mask to apply to the samples. Defaults to None. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + Float: A tensor of samples. + """ + samples = torch.randint(0, self.num_classes, shape, device=device, generator=rng_generator) + if mask is not None: + samples = samples * mask[(...,) + (None,) * (len(samples.shape) - len(mask.shape))] + return samples diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/distribution.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/distribution.py new file mode 100644 index 0000000000..bc3fb34965 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/distribution.py @@ -0,0 +1,64 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from abc import ABC, abstractmethod +from typing import Optional, Tuple, Union + +import torch +from torch import Tensor + + +class PriorDistribution(ABC): + """An abstract base class representing a prior distribution.""" + + @abstractmethod + def sample(self, shape: Tuple, mask: Optional[Tensor] = None, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generates a specified number of samples from the time distribution. + + Args: + shape (Tuple): The shape of the samples to generate. + mask (Optional[Tensor], optional): A tensor indicating which samples should be masked. Defaults to None. + device (str, optional): The device on which to generate the samples. Defaults to "cpu". + + Returns: + Float: A tensor of samples. + """ + pass + + +class DiscretePriorDistribution(PriorDistribution): + """An abstract base class representing a discrete prior distribution.""" + + def __init__(self, num_classes: int, prior_dist: Tensor): + """Initializes a DiscretePriorDistribution instance. + + Args: + num_classes (int): The number of classes in the discrete distribution. + prior_dist (Tensor): The prior distribution over the classes. + + Returns: + None + """ + self.num_classes = num_classes + self.prior_dist = prior_dist + + def get_num_classes(self) -> int: + """Getter for num_classes.""" + return self.num_classes + + def get_prior_dist(self) -> Tensor: + """Getter for prior_dist.""" + return self.prior_dist diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/__init__.py new file mode 100644 index 0000000000..0d1b736ca1 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/__init__.py @@ -0,0 +1,29 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from .beta import BetaTimeDistribution +from .distribution import MixTimeDistribution, TimeDistribution +from .logit_normal import LogitNormalTimeDistribution +from .uniform import UniformTimeDistribution + + +__all__ = [ + "BetaTimeDistribution", + "LogitNormalTimeDistribution", + "MixTimeDistribution", + "UniformTimeDistribution", + "TimeDistribution", +] diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/beta.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/beta.py new file mode 100644 index 0000000000..0a4164d161 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/beta.py @@ -0,0 +1,75 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from typing import Optional, Union + +import torch +from jaxtyping import Bool, Float + +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.distributions.time.utils import float_time_to_index + + +class BetaTimeDistribution(TimeDistribution): + """A class representing a beta time distribution.""" + + def __init__( + self, + p1: Float = 2.0, + p2: Float = 1.0, + min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes a BetaTimeDistribution object. + + Args: + p1 (Float): The first shape parameter of the beta distribution. + p2 (Float): The second shape parameter of the beta distribution. + min_t (Float): The minimum time value. + max_t (Float): The maximum time value. + discrete_time (Bool): Whether the time is discrete. + nsteps (Optional[int]): Number of nsteps for discretization. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(discrete_time, nsteps, min_t, max_t, rng_generator) + self.dist = torch.distributions.Beta(p1, p2) + + def sample( + self, n_samples: int, device: Union[str, torch.device] = "cpu", rng_generator: Optional[torch.Generator] = None + ): + """Generates a specified number of samples from the uniform time distribution. + + Args: + n_samples (int): The number of samples to generate. + device (str): cpu or gpu. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + A tensor of samples. + """ + if rng_generator is None: + rng_generator = self.rng_generator + time_step = self.dist.sample(torch.Size([n_samples])).to(device=device) + if self.min_t and self.max_t and self.min_t > 0: + time_step = time_step * (self.max_t - self.min_t) + self.min_t + if self.discrete_time: + if self.nsteps is None: + raise ValueError("nsteps cannot be None for discrete time sampling") + time_step = float_time_to_index(time_step, self.nsteps) + return time_step diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/distribution.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/distribution.py new file mode 100644 index 0000000000..846e95e4f6 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/distribution.py @@ -0,0 +1,124 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from abc import ABC, abstractmethod +from typing import Optional, Union + +import torch +from jaxtyping import Bool, Float + + +class TimeDistribution(ABC): + """An abstract base class representing a time distribution. + + Args: + discrete_time (Bool): Whether the time is discrete. + nsteps (Optional[int]): Number of nsteps for discretization. + min_t (Optional[Float]): Min continuous time. + max_t (Optional[Float]): Max continuous time. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + + def __init__( + self, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + min_t: Optional[Float] = None, + max_t: Optional[Float] = None, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes a TimeDistribution object.""" + self.discrete_time = discrete_time + self.nsteps = nsteps + self.rng_generator = rng_generator + if discrete_time: + min_t = 0.0 + max_t = 1.0 + if nsteps is None: + raise ValueError("nsteps must not be None and must be specified for discrete time") + if min_t is not None and isinstance(min_t, float): + if not 0 <= min_t < 1.0: + raise ValueError("min_t must be greater than or equal to 0 and less than 1.0") + self.min_t = min_t + if max_t is not None and isinstance(max_t, float): + if not 0 < max_t <= 1.0: + raise ValueError("max_t must be greater than 0 and less than or equal to 1.0") + self.max_t = max_t + if ( + self.min_t is not None + and self.max_t is not None + and isinstance(self.min_t, float) + and isinstance(self.max_t, float) + ): + if self.min_t >= self.max_t: + raise ValueError("min_t must be less than max_t") + + @abstractmethod + def sample( + self, n_samples: int, device: Union[str, torch.device] = "cpu", rng_generator: Optional[torch.Generator] = None + ) -> Float: + """Generates a specified number of samples from the time distribution. + + Args: + n_samples (int): The number of samples to generate. + device (str): cpu or gpu. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + Float: A list or array of samples. + """ + pass + + +class MixTimeDistribution: + """An abstract base class representing a mixed time distribution. + + uniform_dist = UniformTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False) + beta_dist = BetaTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False, p1=2.0, p2=1.0) + mix_dist = MixTimeDistribution(uniform_dist, beta_dist, mix_fraction=0.5) + """ + + def __init__(self, dist1: TimeDistribution, dist2: TimeDistribution, mix_fraction: Float): + """Initializes a MixTimeDistribution object. + + Args: + dist1 (TimeDistribution): The first time distribution. + dist2 (TimeDistribution): The second time distribution. + mix_fraction (Float): The fraction of samples to draw from dist1. Must be between 0 and 1. + """ + if not 0 <= mix_fraction <= 1: + raise ValueError("mix_fraction must be between 0 and 1") + self.dist1 = dist1 + self.dist2 = dist2 + self.mix_fraction = mix_fraction + + def sample( + self, n_samples: int, device: Union[str, torch.device] = "cpu", rng_generator: Optional[torch.Generator] = None + ) -> Float: + """Generates a specified number of samples from the mixed time distribution. + + Args: + n_samples (int): The number of samples to generate. + device (str): cpu or gpu. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + Float: A list or array of samples. + """ + samples_dist1 = self.dist1.sample(n_samples, device) + samples_dist2 = self.dist2.sample(n_samples, device) + mix = torch.rand(n_samples, device=device, generator=rng_generator) + return torch.where(mix < self.mix_fraction, samples_dist1, samples_dist2) diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/logit_normal.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/logit_normal.py new file mode 100644 index 0000000000..0d6c9a28c4 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/logit_normal.py @@ -0,0 +1,77 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from typing import Optional, Union + +import torch +from jaxtyping import Bool, Float + +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.distributions.time.utils import float_time_to_index + + +class LogitNormalTimeDistribution(TimeDistribution): + """A class representing a logit normal time distribution.""" + + def __init__( + self, + p1: Float = 0.0, + p2: Float = 1.0, + min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes a BetaTimeDistribution object. + + Args: + p1 (Float): The first shape parameter of the logit normal distribution i.e. the mean. + p2 (Float): The second shape parameter of the logit normal distribution i.e. the std. + min_t (Float): The minimum time value. + max_t (Float): The maximum time value. + discrete_time (Bool): Whether the time is discrete. + nsteps (Optional[int]): Number of nsteps for discretization. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(discrete_time, nsteps, min_t, max_t, rng_generator) + self.p1 = p1 + self.p2 = p2 + + def sample( + self, n_samples: int, device: Union[str, torch.device] = "cpu", rng_generator: Optional[torch.Generator] = None + ): + """Generates a specified number of samples from the uniform time distribution. + + Args: + n_samples (int): The number of samples to generate. + device (str): cpu or gpu. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + A tensor of samples. + """ + if rng_generator is None: + rng_generator = self.rng_generator + time_step = torch.randn(n_samples, device=device, generator=rng_generator) * self.p2 + self.p1 + time_step = torch.nn.functional.sigmoid(time_step) + if self.min_t and self.max_t and (self.min_t > 0 or self.max_t < 1): + time_step = time_step * (self.max_t - self.min_t) + self.min_t + if self.discrete_time: + if self.nsteps is None: + raise ValueError("nsteps cannot be None for discrete time sampling") + time_step = float_time_to_index(time_step, self.nsteps) + return time_step diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/uniform.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/uniform.py new file mode 100644 index 0000000000..444abe4d08 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/uniform.py @@ -0,0 +1,122 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from typing import Optional, Union + +import torch +from jaxtyping import Bool, Float + +from bionemo.moco.distributions.time.distribution import TimeDistribution + + +class UniformTimeDistribution(TimeDistribution): + """A class representing a uniform time distribution.""" + + def __init__( + self, + min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes a UniformTimeDistribution object. + + Args: + min_t (Float): The minimum time value. + max_t (Float): The maximum time value. + discrete_time (Bool): Whether the time is discrete. + nsteps (Optional[int]): Number of nsteps for discretization. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(discrete_time, nsteps, min_t, max_t, rng_generator) + + def sample( + self, n_samples: int, device: Union[str, torch.device] = "cpu", rng_generator: Optional[torch.Generator] = None + ): + """Generates a specified number of samples from the uniform time distribution. + + Args: + n_samples (int): The number of samples to generate. + device (str): cpu or gpu. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + A tensor of samples. + """ + if rng_generator is None: + rng_generator = self.rng_generator + if self.discrete_time: + if self.nsteps is None: + raise ValueError("nsteps cannot be None for discrete time sampling") + time_step = torch.randint(0, self.nsteps, size=(n_samples,), device=device, generator=rng_generator) + else: + time_step = torch.rand(n_samples, device=device, generator=rng_generator) + if self.min_t and self.max_t and self.min_t > 0: + time_step = time_step * (self.max_t - self.min_t) + self.min_t + return time_step + + +class SymmetricUniformTimeDistribution(TimeDistribution): + """A class representing a uniform time distribution.""" + + def __init__( + self, + min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes a UniformTimeDistribution object. + + Args: + min_t (Float): The minimum time value. + max_t (Float): The maximum time value. + discrete_time (Bool): Whether the time is discrete. + nsteps (Optional[int]): Number of nsteps for discretization. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(discrete_time, nsteps, min_t, max_t, rng_generator) + + def sample( + self, n_samples: int, device: Union[str, torch.device] = "cpu", rng_generator: Optional[torch.Generator] = None + ): + """Generates a specified number of samples from the uniform time distribution. + + Args: + n_samples (int): The number of samples to generate. + device (str): cpu or gpu. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + A tensor of samples. + """ + if rng_generator is None: + rng_generator = self.rng_generator + if self.discrete_time: + if self.nsteps is None: + raise ValueError("nsteps cannot be None for discrete time sampling") + time_step = torch.randint( + 0, self.nsteps, size=(n_samples // 2 + 1,), device=device, generator=rng_generator + ) + time_step = torch.cat([time_step, self.nsteps - time_step - 1], dim=0)[:n_samples] + else: + time_step = torch.rand(n_samples // 2 + 1, device=device, generator=rng_generator) + time_step = torch.cat([time_step, 1 - time_step], dim=0)[:n_samples] + if self.min_t and self.max_t and self.min_t > 0: + time_step = time_step * (self.max_t - self.min_t) + self.min_t + return time_step diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/utils.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/utils.py new file mode 100644 index 0000000000..e4bb0ca173 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/utils.py @@ -0,0 +1,35 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import torch + + +def float_time_to_index(time: torch.Tensor, num_time_steps: int) -> torch.Tensor: + """Convert a float time value to a time index. + + Args: + time (torch.Tensor): A tensor of float time values in the range [0, 1]. + num_time_steps (int): The number of discrete time steps. + + Returns: + torch.Tensor: A tensor of time indices corresponding to the input float time values. + """ + # Ensure time values are in the range [0, 1] + time = torch.clamp(time, 0.0, 1.0) + + # Scale to the index range and round + indices = torch.round(time * (num_time_steps - 1)).to(torch.int64) + + return indices diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/__init__.py new file mode 100644 index 0000000000..0a1606c098 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/__init__.py @@ -0,0 +1,25 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from .continuous_time.continuous.continuous_flow_matching import ContinuousFlowMatcher +from .continuous_time.continuous.vdm import VDM +from .continuous_time.discrete.discrete_flow_matching import DiscreteFlowMatcher +from .continuous_time.discrete.mdlm import MDLM +from .discrete_time.continuous.ddpm import DDPM +from .discrete_time.discrete.d3pm import D3PM + + +__all__ = ["DDPM", "D3PM", "VDM", "MDLM", "ContinuousFlowMatcher", "DiscreteFlowMatcher"] diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/base_interpolant.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/base_interpolant.py new file mode 100644 index 0000000000..ac6018a402 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/base_interpolant.py @@ -0,0 +1,241 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from abc import ABC, abstractmethod +from enum import Enum +from typing import Optional, Type, TypeVar, Union + +import torch +from jaxtyping import Bool +from torch import Tensor + +from bionemo.moco.distributions.prior.distribution import PriorDistribution +from bionemo.moco.distributions.time.distribution import TimeDistribution + + +# Define a generic type for Enum +AnyEnum = TypeVar("AnyEnum", bound=Enum) + + +def string_to_enum(value: Union[str, AnyEnum], enum_type: Type[AnyEnum]) -> AnyEnum: + """Converts a string to an enum value of the specified type. If the input is already an enum instance, it is returned as-is. + + Args: + value (Union[str, E]): The string to convert or an existing enum instance. + enum_type (Type[E]): The enum type to convert to. + + Returns: + E: The corresponding enum value. + + Raises: + ValueError: If the string does not correspond to any enum member. + """ + if isinstance(value, enum_type): + # If the value is already an enum, return it + return value + + try: + # Match the value to the Enum, case-insensitively + return enum_type(value) + except ValueError: + # Raise a helpful error if the value is invalid + valid_values = [e.value for e in enum_type] + raise ValueError(f"Invalid value '{value}'. Expected one of {valid_values}.") + + +def pad_like(source: Tensor, target: Tensor) -> Tensor: + """Pads the dimensions of the source tensor to match the dimensions of the target tensor. + + Args: + source (Tensor): The tensor to be padded. + target (Tensor): The tensor that the source tensor should match in dimensions. + + Returns: + Tensor: The padded source tensor. + + Raises: + ValueError: If the source tensor has more dimensions than the target tensor. + + Example: + >>> source = torch.tensor([1, 2, 3]) # shape: (3,) + >>> target = torch.tensor([[1, 2], [4, 5], [7, 8]]) # shape: (3, 2) + >>> padded_source = pad_like(source, target) # shape: (3, 1) + """ + if source.ndim == target.ndim: + return source + elif source.ndim > target.ndim: + raise ValueError(f"Cannot pad {source.shape} to {target.shape}") + return source.view(list(source.shape) + [1] * (target.ndim - source.ndim)) + + +class PredictionType(Enum): + """An enumeration representing the type of prediction a Denoising Diffusion Probabilistic Model (DDPM) can be used for. + + DDPMs are versatile models that can be utilized for various prediction tasks, including: + + - **Data**: Predicting the original data distribution from a noisy input. + - **Noise**: Predicting the noise that was added to the original data to obtain the input. + - **Velocity**: Predicting the velocity or rate of change of the data, particularly useful for modeling temporal dynamics. + + These prediction types can be used to train neural networks for specific tasks, such as denoising, image synthesis, or time-series forecasting. + """ + + DATA = "data" + NOISE = "noise" + VELOCITY = "velocity" + + +# Adding useful aliases for Flow Matching +PredictionType._value2member_map_["vector_field"] = PredictionType.VELOCITY +PredictionType._value2member_map_["flow"] = PredictionType.VELOCITY + + +class Interpolant(ABC): + """An abstract base class representing an Interpolant. + + This class serves as a foundation for creating interpolants that can be used + in various applications, providing a basic structure and interface for + interpolation-related operations. + """ + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes the Interpolant class. + + Args: + time_distribution (TimeDistribution): The distribution of time steps. + prior_distribution (PriorDistribution): The prior distribution of the variable. + device (Union[str, torch.device], optional): The device on which to operate. Defaults to "cpu". + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + self.time_distribution = time_distribution + self.prior_distribution = prior_distribution + self.device = device + self.rng_generator = rng_generator + + @abstractmethod + def interpolate(self, *args, **kwargs) -> Tensor: + """Get x(t) with given time t from noise and data. + + Interpolate between x0 and x1 at the given time t. + """ + pass + + @abstractmethod + def step(self, *args, **kwargs) -> Tensor: + """Do one step integration.""" + pass + + def general_step(self, method_name: str, kwargs: dict): + """Calls a step method of the class by its name, passing the provided keyword arguments. + + Args: + method_name (str): The name of the step method to call. + kwargs (dict): Keyword arguments to pass to the step method. + + Returns: + The result of the step method call. + + Raises: + ValueError: If the provided method name does not start with 'step'. + Exception: If the step method call fails. The error message includes a list of available step methods. + + Note: + This method allows for dynamic invocation of step methods, providing flexibility in the class's usage. + """ + if not method_name.startswith("step"): + raise ValueError(f"Method name '{method_name}' does not start with 'step'") + + try: + # Get the step method by its name + func = getattr(self, method_name) + # Call the step method with the provided keyword arguments + return func(**kwargs) + except Exception as e: + # Get a list of available step methods + available_methods = "\n".join([f" - {attr}" for attr in dir(self) if attr.startswith("step")]) + # Create a detailed error message + error_message = f"Error calling method '{method_name}': {e}\nAvailable step methods:\n{available_methods}" + # Re-raise the exception with the detailed error message + raise type(e)(error_message) + + def sample_prior(self, *args, **kwargs) -> Tensor: + """Sample from prior distribution. + + This method generates a sample from the prior distribution specified by the + `prior_distribution` attribute. + + Returns: + Tensor: The generated sample from the prior distribution. + """ + # Ensure the device is specified, default to self.device if not provided + if "device" not in kwargs: + kwargs["device"] = self.device + kwargs["rng_generator"] = self.rng_generator + # Sample from the prior distribution + return self.prior_distribution.sample(*args, **kwargs) + + def sample_time(self, *args, **kwargs) -> Tensor: + """Sample from time distribution.""" + # Ensure the device is specified, default to self.device if not provided + if "device" not in kwargs: + kwargs["device"] = self.device + kwargs["rng_generator"] = self.rng_generator + # Sample from the time distribution + return self.time_distribution.sample(*args, **kwargs) + + def to_device(self, device: str): + """Moves all internal tensors to the specified device and updates the `self.device` attribute. + + Args: + device (str): The device to move the tensors to (e.g. "cpu", "cuda:0"). + + Note: + This method is used to transfer the internal state of the DDPM interpolant to a different device. + It updates the `self.device` attribute to reflect the new device and moves all internal tensors to the specified device. + """ + self.device = device + for attr_name in dir(self): + if attr_name.startswith("_") and isinstance(getattr(self, attr_name), torch.Tensor): + setattr(self, attr_name, getattr(self, attr_name).to(device)) + return self + + def clean_mask_center(self, data: Tensor, mask: Optional[Tensor] = None, center: Bool = False) -> Tensor: + """Returns a clean tensor that has been masked and/or centered based on the function arguments. + + Args: + data: The input data with shape (..., nodes, features). + mask: An optional mask to apply to the data with shape (..., nodes). If provided, it is used to calculate the CoM. Defaults to None. + center: A boolean indicating whether to center the data around the calculated CoM. Defaults to False. + + Returns: + The data with shape (..., nodes, features) either centered around the CoM if `center` is True or unchanged if `center` is False. + """ + if mask is not None: + data = data * mask.unsqueeze(-1) + if not center: + return data + if mask is None: + num_nodes = torch.tensor(data.shape[1], device=data.device) + else: + num_nodes = torch.clamp(mask.sum(dim=-1), min=1) # clamp used to prevent divide by 0 + com = data.sum(dim=-2) / num_nodes.unsqueeze(-1) + return data - com.unsqueeze(-2) diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/continuous_flow_matching.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/continuous_flow_matching.py new file mode 100644 index 0000000000..2ace71ab9c --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/continuous_flow_matching.py @@ -0,0 +1,567 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from enum import Enum +from typing import Optional, Union + +import torch +import torch.nn as nn +from jaxtyping import Bool, Float +from torch import Tensor + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +from bionemo.moco.distributions.prior.distribution import PriorDistribution +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.interpolants.base_interpolant import Interpolant, PredictionType, pad_like, string_to_enum +from bionemo.moco.interpolants.continuous_time.continuous.optimal_transport import OTSampler + + +class OptimalTransportType(Enum): + """An enumeration representing the type ofOptimal Transport that can be used in Continuous Flow Matching. + + - **EXACT**: Standard mini batch optimal transport defined in https://arxiv.org/pdf/2302.00482. + - **EQUIVARIANT**: Adding roto/translation optimization to mini batch OT see https://arxiv.org/pdf/2306.15030 https://arxiv.org/pdf/2312.07168 4.2. + - **KABSCH**: Simple Kabsch alignment between each data and noise point, No permuation # https://arxiv.org/pdf/2410.22388 Sec 3.2 + + These prediction types can be used to train neural networks for specific tasks, such as denoising, image synthesis, or time-series forecasting. + """ + + EXACT = "exact" + EQUIVARIANT = "equivariant" + KABSCH = "kabsch" + + +class ContinuousFlowMatcher(Interpolant): + """A Continuous Flow Matching interpolant. + + ------- + + Examples: + ```python + >>> import torch + >>> from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior + >>> from bionemo.moco.distributions.time.uniform import UniformTimeDistribution + >>> from bionemo.moco.interpolants.continuous_time.continuous.continuous_flow_matching import ContinuousFlowMatcher + >>> from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule + + flow_matcher = ContinuousFlowMatcher( + time_distribution = UniformTimeDistribution(...), + prior_distribution = GaussianPrior(...), + ) + model = Model(...) + + # Training + for epoch in range(1000): + data = data_loader.get(...) + time = flow_matcher.sample_time(batch_size) + noise = flow_matcher.sample_prior(data.shape) + data, time, noise = flow_matcher.apply_ot(noise, data) # Optional, only for OT + xt = flow_matcher.interpolate(data, time, noise) + flow = flow_matcher.calculate_target(data, noise) + + u_pred = model(xt, time) + loss = flow_matcher.loss(u_pred, flow) + loss.backward() + + # Generation + x_pred = flow_matcher.sample_prior(data.shape) + inference_sched = LinearInferenceSchedule(...) + for t in inference_sched.generate_schedule(): + time = inference_sched.pad_time(x_pred.shape[0], t) + u_hat = model(x_pred, time) + x_pred = flow_matcher.step(u_hat, x_pred, time) + return x_pred + + ``` + """ + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + prediction_type: Union[PredictionType, str] = PredictionType.DATA, + sigma: Float = 0, + ot_type: Optional[Union[OptimalTransportType, str]] = None, + data_scale: Float = 1.0, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + eps: Float = 1e-5, + ): + """Initializes the Continuous Flow Matching interpolant. + + Args: + time_distribution (TimeDistribution): The distribution of time steps, used to sample time points for the diffusion process. + prior_distribution (PriorDistribution): The prior distribution of the variable, used as the starting point for the diffusion process. + prediction_type (PredictionType, optional): The type of prediction, either "flow" or another type. Defaults to PredictionType.DATA. + sigma (Float, optional): The standard deviation of the Gaussian noise added to the interpolated data. Defaults to 0. + ot_type (Optional[Union[OptimalTransportType, str]], optional): The type of optimal transport, if applicable. Defaults to None. + data_scale (Float, optional): The scale factor for the data. Defaults to 1.0. + device (Union[str, torch.device], optional): The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + eps: Small float to prevent divide by zero + """ + super().__init__(time_distribution, prior_distribution, device, rng_generator) + self.prediction_type = string_to_enum(prediction_type, PredictionType) + self.sigma = sigma + self.ot_type = ot_type + self.data_scale = data_scale + self.eps = eps + if data_scale <= 0: + raise ValueError("Data Scale must be > 0") + if ot_type is not None: + self.ot_type = ot_type = string_to_enum(ot_type, OptimalTransportType) + self.ot_sampler = self._build_ot_sampler(sampler_type=ot_type) + self._loss_function = nn.MSELoss(reduction="none") + + def _build_ot_sampler(self, sampler_type: Union[str, OptimalTransportType], num_threads: int = 1) -> OTSampler: + """Build the optimal transport sampler for the given optimal transport type. + + Args: + sampler_type (OptimalTransportType): The OT type to build the sampler for. + num_threads (int): The number of threads to use for the OT sampler, default to 1. + + Returns: + The optimal transport sampler object or None if the optimal transport type is not specified. + """ + ot_sampler = None + sampler_type = string_to_enum(sampler_type, OptimalTransportType) + if sampler_type == OptimalTransportType.EXACT: + ot_sampler = OTSampler(method="exact", num_threads=num_threads) + elif sampler_type == OptimalTransportType.EQUIVARIANT: + raise NotImplementedError("Equivariant OT currently not implemented") + elif sampler_type == OptimalTransportType.KABSCH: + raise NotImplementedError("Kabsch OT currently not implemented") + return ot_sampler + + def apply_ot(self, x0: Tensor, x1: Tensor, mask: Optional[Tensor] = None, replace: Bool = False) -> tuple: + """Sample and apply the optimal transport plan between batched (and masked) x0 and x1. + + Args: + x0 (Tensor): shape (bs, *dim), noise from source minibatch. + x1 (Tensor): shape (bs, *dim), data from source minibatch. + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + replace (bool): sampling w/ or w/o replacement from the OT plan, default to False. + + Returns: + Tuple: tuple of 2 tensors, represents the noise and data samples following OT plan pi. + """ + if self.ot_sampler is None: + raise ValueError("Optimal Transport Sampler is not defined") + return self.ot_sampler.apply_ot(x0, x1, mask=mask, replace=replace) + + def undo_scale_data(self, data: Tensor) -> Tensor: + """Downscale the input data by the data scale factor. + + Args: + data (Tensor): The input data to downscale. + + Returns: + The downscaled data. + """ + return 1 / self.data_scale * data + + def scale_data(self, data: Tensor) -> Tensor: + """Upscale the input data by the data scale factor. + + Args: + data (Tensor): The input data to upscale. + + Returns: + The upscaled data. + """ + return self.data_scale * data + + def interpolate(self, data: Tensor, t: Tensor, noise: Tensor) -> Tensor: + """Get x_t with given time t from noise (x_0) and data (x_1). + + Currently, we use the linear interpolation as defined in: + 1. Rectified flow: https://arxiv.org/abs/2209.03003. + 2. Conditional flow matching: https://arxiv.org/abs/2210.02747 (called conditional optimal transport). + + Args: + noise (Tensor): noise from prior(), shape (batchsize, nodes, features) + t (Tensor): time, shape (batchsize) + data (Tensor): target, shape (batchsize, nodes, features) + """ + assert data.size() == noise.size() + # Expand t to the same shape as noise: ones([b,n,f]) * t([b,1,1]) + t = pad_like(t, data) + # Calculate x_t as the linear interpolation between noise and data + x_t = data * t + noise * (1.0 - t) + # Add Gaussian Noise + if self.sigma > 0: + x_t += self.sigma * torch.randn(x_t.shape, device=x_t.device, generator=self.rng_generator) + return x_t + + def calculate_target(self, data: Tensor, noise: Tensor, mask: Optional[Tensor] = None) -> Tensor: + """Get the target vector field at time t. + + Args: + noise (Tensor): noise from prior(), shape (batchsize, nodes, features) + data (Tensor): target, shape (batchsize, nodes, features) + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + Returns: + Tensor: The target vector field at time t. + """ + assert data.size() == noise.size() + # Calculate the target vector field u_t(x_t|x_1) as the difference between data and noise because t~[0,1] + if self.prediction_type == PredictionType.VELOCITY: + u_t = data - noise + elif self.prediction_type == PredictionType.DATA: + u_t = data + else: + raise ValueError( + f"Given prediction_type {self.prediction_type} is not supproted for Continuous Flow Matching." + ) + if mask is not None: + u_t = u_t * mask.unsqueeze(-1) + return u_t + + def process_vector_field_prediction( + self, + model_output: Tensor, + xt: Optional[Tensor] = None, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + ): + """Process the model output based on the prediction type to calculate vecotr field. + + Args: + model_output (Tensor): The output of the model. + xt (Tensor): The input sample. + t (Tensor): The time step. + mask (Optional[Tensor], optional): An optional mask to apply to the model output. Defaults to None. + + Returns: + The vector field prediction based on the prediction type. + + Raises: + ValueError: If the prediction type is not "flow" or "data". + """ + if self.prediction_type == PredictionType.VELOCITY: + pred_vector_field = model_output + elif self.prediction_type == PredictionType.DATA: + if xt is None or t is None: + raise ValueError("Xt and Time cannpt be None for vector field conversion") + t = pad_like(t, model_output) + pred_vector_field = (model_output - xt) / (1 - t + self.eps) + else: + raise ValueError( + f"prediction_type given as {self.prediction_type} must be `flow` or `data` " + "for Continuous Flow Matching." + ) + if mask is not None: + pred_vector_field = pred_vector_field * mask.unsqueeze(-1) + return pred_vector_field + + def process_data_prediction( + self, + model_output: Tensor, + xt: Optional[Tensor] = None, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + ): + """Process the model output based on the prediction type to generate clean data. + + Args: + model_output (Tensor): The output of the model. + xt (Tensor): The input sample. + t (Tensor): The time step. + mask (Optional[Tensor], optional): An optional mask to apply to the model output. Defaults to None. + + Returns: + The data prediction based on the prediction type. + + Raises: + ValueError: If the prediction type is not "flow". + """ + if self.prediction_type == PredictionType.VELOCITY: + if xt is None or t is None: + raise ValueError("Xt and time cannot be None") + t = pad_like(t, model_output) + pred_data = xt + (1 - t) * model_output + elif self.prediction_type == PredictionType.DATA: + pred_data = model_output + else: + raise ValueError( + f"prediction_type given as {self.prediction_type} must be `flow` " "for Continuous Flow Matching." + ) + if mask is not None: + pred_data = pred_data * mask.unsqueeze(-1) + return pred_data + + def step( + self, + model_out: Tensor, + xt: Tensor, + dt: Tensor, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + center: Bool = False, + ): + """Perform a single ODE step integration using Euler method. + + Args: + model_out (Tensor): The output of the model at the current time step. + xt (Tensor): The current intermediate state. + dt (Tensor): The time step size. + t (Tensor, optional): The current time. Defaults to None. + mask (Optional[Tensor], optional): A mask to apply to the model output. Defaults to None. + center (Bool, optional): Whether to center the output. Defaults to False. + + Returns: + x_next (Tensor): The updated state of the system after the single step, x_(t+dt). + + Notes: + - If a mask is provided, it is applied element-wise to the model output before scaling. + - The `clean` method is called on the updated state before it is returned. + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + v_t = self.process_vector_field_prediction(model_out, xt, t, mask) + dt = pad_like(dt, model_out) + delta_x = v_t * dt + x_next = xt + delta_x + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def step_score_stochastic( + self, + model_out: Tensor, + xt: Tensor, + dt: Tensor, + t: Tensor, + mask: Optional[Tensor] = None, + gt_mode: str = "tan", + gt_p: Float = 1.0, + gt_clamp: Optional[Float] = None, + score_temperature: Float = 1.0, + noise_temperature: Float = 1.0, + t_lim_ode: Float = 0.99, + center: Bool = False, + ): + r"""Perform a single ODE step integration using Euler method. + + d x_t = [v(x_t, t) + g(t) * s(x_t, t) * sc_score_scale] dt + \sqrt{2 * g(t) * temperature} dw_t. + + At the moment we do not scale the vector field v but this can be added with sc_score_scale. + + Args: + model_out (Tensor): The output of the model at the current time step. + xt (Tensor): The current intermediate state. + dt (Tensor): The time step size. + t (Tensor, optional): The current time. Defaults to None. + mask (Optional[Tensor], optional): A mask to apply to the model output. Defaults to None. + gt_mode (str, optional): The mode for the gt function. Defaults to "1/t". + gt_p (Float, optional): The parameter for the gt function. Defaults to 1.0. + gt_clamp: (Float, optional): Upper limit of gt term. Defaults to None. + score_temperature (Float, optional): The temperature for the score part of the step. Defaults to 1.0. + noise_temperature (Float, optional): The temperature for the stochastic part of the step. Defaults to 1.0. + t_lim_ode (Float, optional): The time limit for the ODE step. Defaults to 0.99. + center (Bool, optional): Whether to center the output. Defaults to False. + + Returns: + x_next (Tensor): The updated state of the system after the single step, x_(t+dt). + + Notes: + - If a mask is provided, it is applied element-wise to the model output before scaling. + - The `clean` method is called on the updated state before it is returned. + """ + if self.ot_type is not None: + raise ValueError("Optimal Transport violates the vector field to score conversion") + if not isinstance(self.prior_distribution, GaussianPrior): + raise ValueError( + "Prior distribution must be an instance of GaussianPrior to learn a proper score function" + ) + if t.min() >= t_lim_ode: + return self.step(model_out, xt, dt, t, mask, center) + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + v_t = self.process_vector_field_prediction(model_out, xt, t, mask) + dt = pad_like(dt, model_out) + t = pad_like(t, model_out) + score = self.vf_to_score(xt, v_t, t) + gt = self.get_gt(t, gt_mode, gt_p, gt_clamp) + eps = torch.randn(xt.shape, dtype=xt.dtype, device=xt.device, generator=self.rng_generator) + std_eps = torch.sqrt(2 * gt * noise_temperature * dt) + delta_x = (v_t + gt * score * score_temperature) * dt + std_eps * eps + x_next = xt + delta_x + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def loss( + self, + model_pred: Tensor, + target: Tensor, + t: Optional[Tensor] = None, + xt: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + target_type: Union[PredictionType, str] = PredictionType.DATA, + ): + """Calculate the loss given the model prediction, data sample, time, and mask. + + If target_type is FLOW loss = ||v_hat - (x1-x0)||**2 + If target_type is DATA loss = ||x1_hat - x1||**2 * 1 / (1 - t)**2 as the target vector field = x1 - x0 = (1/(1-t)) * x1 - xt where xt = tx1 - (1-t)x0. + This functions supports any cominbation of prediction_type and target_type in {DATA, FLOW}. + + Args: + model_pred (Tensor): The predicted output from the model. + target (Tensor): The target output for the model prediction. + t (Optional[Tensor], optional): The time for the model prediction. Defaults to None. + xt (Optional[Tensor], optional): The interpolated data. Defaults to None. + mask (Optional[Tensor], optional): The mask for the data point. Defaults to None. + target_type (PredictionType, optional): The type of the target output. Defaults to PredictionType.DATA. + + Returns: + Tensor: The calculated loss batch tensor. + """ + target_type = string_to_enum(target_type, PredictionType) + if target_type == PredictionType.DATA: + model_pred = self.process_data_prediction(model_pred, xt, t, mask) + else: + model_pred = self.process_vector_field_prediction(model_pred, xt, t, mask) + raw_loss = self._loss_function(model_pred, target) + + if mask is not None: + loss = raw_loss * mask.unsqueeze(-1) + n_elem = torch.sum(mask, dim=-1) + loss = torch.sum(loss, dim=tuple(range(1, raw_loss.ndim))) / n_elem + else: + loss = torch.sum(raw_loss, dim=tuple(range(1, raw_loss.ndim))) / model_pred.size(1) + if target_type == PredictionType.DATA: + if t is None: + raise ValueError("Time cannot be None when using a time-based weighting") + loss_weight = 1.0 / ((1.0 - t) ** 2 + self.eps) + loss = loss_weight * loss + return loss + + def vf_to_score( + self, + x_t: Tensor, + v: Tensor, + t: Tensor, + ) -> Tensor: + """From Geffner et al. Computes score of noisy density given the vector field learned by flow matching. + + With our interpolation scheme these are related by + + v(x_t, t) = (1 / t) (x_t + scale_ref ** 2 * (1 - t) * s(x_t, t)), + + or equivalently, + + s(x_t, t) = (t * v(x_t, t) - x_t) / (scale_ref ** 2 * (1 - t)). + + with scale_ref = 1 + + Args: + x_t: Noisy sample, shape [*, dim] + v: Vector field, shape [*, dim] + t: Interpolation time, shape [*] (must be < 1) + + Returns: + Score of intermediate density, shape [*, dim]. + """ + assert torch.all(t < 1.0), "vf_to_score requires t < 1 (strict)" + t = pad_like(t, v) + num = t * v - x_t # [*, dim] + den = 1.0 - t # [*, 1] + score = num / den + return score # [*, dim] + + def get_gt( + self, + t: Tensor, + mode: str = "tan", + param: float = 1.0, + clamp_val: Optional[float] = None, + eps: float = 1e-2, + ) -> Tensor: + """From Geffner et al. Computes gt for different modes. + + Args: + t: times where we'll evaluate, covers [0, 1), shape [nsteps] + mode: "us" or "tan" + param: parameterized transformation + clamp_val: value to clamp gt, no clamping if None + eps: small value leave as it is + """ + + # Function to get variants for some gt mode + def transform_gt(gt, f_pow=1.0): + # 1.0 means no transformation + if f_pow == 1.0: + return gt + + # First we somewhat normalize between 0 and 1 + log_gt = torch.log(gt) + mean_log_gt = torch.mean(log_gt) + log_gt_centered = log_gt - mean_log_gt + normalized = torch.nn.functional.sigmoid(log_gt_centered) + # Transformation here + normalized = normalized**f_pow + # Undo normalization with the transformed variable + log_gt_centered_rec = torch.logit(normalized, eps=1e-6) + log_gt_rec = log_gt_centered_rec + mean_log_gt + gt_rec = torch.exp(log_gt_rec) + return gt_rec + + # Numerical reasons for some schedule + t = torch.clamp(t, 0, 1 - self.eps) + + if mode == "us": + num = 1.0 - t + den = t + gt = num / (den + eps) + elif mode == "tan": + num = torch.sin((1.0 - t) * torch.pi / 2.0) + den = torch.cos((1.0 - t) * torch.pi / 2.0) + gt = (torch.pi / 2.0) * num / (den + eps) + elif mode == "1/t": + num = 1.0 + den = t + gt = num / (den + eps) + elif mode == "1/t2": + num = 1.0 + den = t**2 + gt = num / (den + eps) + elif mode == "1/t1p5": + num = 1.0 + den = t**1.5 + gt = num / (den + eps) + elif mode == "2/t": + num = 2.0 + den = t + gt = num / (den + eps) + elif mode == "2/t2": + num = 2.0 + den = t**2 + gt = num / (den + eps) + elif mode == "2/t1p5": + num = 2.0 + den = t**1.5 + gt = num / (den + eps) + elif mode == "1mt": + gt = 1 - t + elif mode == "t": + gt = t + elif mode == "ones": + gt = 0 * t + 1 + else: + raise NotImplementedError(f"gt not implemented {mode}") + gt = transform_gt(gt, f_pow=param) + gt = torch.clamp(gt, 0, clamp_val) # If None no clamping + return gt # [s] diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport.py new file mode 100644 index 0000000000..e64aa192db --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport.py @@ -0,0 +1,206 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import warnings +from functools import partial +from typing import Callable, Literal, Optional, Tuple, Union + +import ot as pot +import torch +from jaxtyping import Bool +from torch import Tensor + + +class OTSampler: + """Sampler for Exact Mini-batch Optimal Transport Plan. + + OTSampler implements sampling coordinates according to an OT plan (wrt squared Euclidean cost) + with different implementations of the plan calculation. Code is adapted from https://github.com/atong01/conditional-flow-matching/blob/main/torchcfm/optimal_transport.py + + """ + + def __init__( + self, + method: str, + device: Union[str, torch.device] = "cpu", + num_threads: int = 1, + ) -> None: + """Initialize the OTSampler class. + + Args: + method (str): Choose which optimal transport solver you would like to use. Currently only support exact OT solvers (pot.emd). + device (Union[str, torch.device], optional): The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". + num_threads (Union[int, str], optional): Number of threads to use for OT solver. If "max", uses the maximum number of threads. Default is 1. + + Raises: + ValueError: If the OT solver is not documented. + NotImplementedError: If the OT solver is not implemented. + """ + # ot_fn should take (a, b, M) as arguments where a, b are marginals and + # M is a cost matrix + if method == "exact": + self.ot_fn: Callable[..., torch.Tensor] = partial(pot.emd, numThreads=num_threads) # type: ignore + elif method in {"sinkhorn", "unbalanced", "partial"}: + raise NotImplementedError("OT solver other than 'exact' is not implemented.") + else: + raise ValueError(f"Unknown method: {method}") + self.device = device + + def to_device(self, device: str): + """Moves all internal tensors to the specified device and updates the `self.device` attribute. + + Args: + device (str): The device to move the tensors to (e.g. "cpu", "cuda:0"). + + Note: + This method is used to transfer the internal state of the OTSampler to a different device. + It updates the `self.device` attribute to reflect the new device and moves all internal tensors to the specified device. + """ + self.device = device + for attr_name in dir(self): + if attr_name.startswith("_") and isinstance(getattr(self, attr_name), torch.Tensor): + setattr(self, attr_name, getattr(self, attr_name).to(device)) + return self + + def sample_map(self, pi: Tensor, batch_size: int, replace: Bool = False) -> Tuple[Tensor, Tensor]: + r"""Draw source and target samples from pi $(x,z) \sim \pi$. + + Args: + pi (Tensor): shape (bs, bs), the OT matrix between noise and data in minibatch. + batch_size (int): The batch size of the minibatch. + replace (bool): sampling w/ or w/o replacement from the OT plan, default to False. + + Returns: + Tuple: tuple of 2 tensors, represents the indices of noise and data samples from pi. + """ + if pi.shape[0] != batch_size or pi.shape[1] != batch_size: + raise ValueError("Shape mismatch: pi.shape = {}, batch_size = {}".format(pi.shape, batch_size)) + p = pi.flatten() + p = p / p.sum() + choices = torch.multinomial(p, batch_size, replacement=replace) + return torch.div(choices, pi.shape[1], rounding_mode="floor"), choices % pi.shape[1] + + def _calculate_cost_matrix(self, x0: Tensor, x1: Tensor, mask: Optional[Tensor] = None) -> Tensor: + """Compute the cost matrix between a source and a target minibatch. + + Args: + x0 (Tensor): shape (bs, *dim), noise from source minibatch. + x1 (Tensor): shape (bs, *dim), data from source minibatch. + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + Returns: + Tensor: shape (bs, bs), the cost matrix between noise and data in minibatch. + """ + if mask is None: + # Flatten the input tensors + x0, x1 = x0.reshape(x0.shape[0], -1), x1.reshape(x1.shape[0], -1) + + # Compute the cost matrix. For exact OT, we use squared Euclidean distance. + M = torch.cdist(x0, x1) ** 2 + else: + # Initialize the cost matrix + M = torch.zeros((x0.shape[0], x1.shape[0])) + # For each x0 sample, apply its mask to all x1 samples and calculate the cost + for i in range(x0.shape[0]): + x0i_mask = mask[i].unsqueeze(-1) + masked_x1 = x1 * x0i_mask + masked_x0 = x0[i] * x0i_mask + cost = torch.cdist(masked_x0.reshape(1, -1), masked_x1.reshape(x1.shape[0], -1)) ** 2 + M[i] = cost + return M + + def get_ot_matrix(self, x0: Tensor, x1: Tensor, mask: Optional[Tensor] = None) -> Tensor: + """Compute the OT matrix between a source and a target minibatch. + + Args: + x0 (Tensor): shape (bs, *dim), noise from source minibatch. + x1 (Tensor): shape (bs, *dim), data from source minibatch. + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + Returns: + p (Tensor): shape (bs, bs), the OT matrix between noise and data in minibatch. + + """ + # Compute the cost matrix + M = self._calculate_cost_matrix(x0, x1, mask) + # Set uniform weights for all samples in a minibatch + a, b = pot.unif(x0.shape[0], type_as=M), pot.unif(x1.shape[0], type_as=M) + + p = self.ot_fn(a, b, M) + # Handle exceptions + if not torch.all(torch.isfinite(p)): + raise ValueError("OT plan map is not finite, cost mean, max: {}, {}".format(M.mean(), M.max())) + if torch.abs(p.sum()) < 1e-8: + warnings.warn("Numerical errors in OT matrix, reverting to uniform plan.") + p = torch.ones_like(p) / p.numel() + + return p + + def apply_ot( + self, + x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None, + replace: Bool = False, + preserve: Optional[Literal["noise", "x0", "data", "x1"]] = "x0", + ) -> Tuple[Tensor, Tensor, Optional[Tensor]]: + r"""Sample indices for noise and data in minibatch according to OT plan. + + Compute the OT plan $\pi$ (wrt squared Euclidean cost) between a source and a target + minibatch and draw source and target samples from pi $(x,z) \sim \pi$. + + Args: + x0 (Tensor): shape (bs, *dim), noise from source minibatch. + x1 (Tensor): shape (bs, *dim), data from source minibatch. + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + replace (bool): sampling w/ or w/o replacement from the OT plan, default to False. + preserve (str): Optional Literal string to sort either x1 or x0 based on the input. + + Returns: + Tuple: tuple of 2 tensors or 3 tensors if mask is used, represents the noise (plus mask) and data samples following OT plan pi. + """ + if replace and preserve is not None: + raise ValueError("Cannot sample with replacement and preserve") + # Calculate the optimal transport + pi = self.get_ot_matrix(x0, x1, mask) + + # Sample (x0, x1) mapping indices from the OT matrix + i, j = self.sample_map(pi, x0.shape[0], replace=replace) + if not replace and (preserve == "noise" or preserve == "x0"): + sort_idx = torch.argsort(i) + i = i[sort_idx] + j = j[sort_idx] + + if not (i == torch.arange(x0.shape[0])).all(): + raise ValueError("x0_idx should be a tensor from 0 to size - 1 when preserve is 'noise' or 'x0") + noise = x0 + data = x1[j] + elif not replace and (preserve == "data" or preserve == "x1"): + sort_idx = torch.argsort(j) + i = i[sort_idx] + j = j[sort_idx] + + if not (j == torch.arange(x1.shape[0])).all(): + raise ValueError("x1_idx should be a tensor from 0 to size - 1 when preserve is 'noise' or 'x0") + noise = x0[i] + data = x1 + else: + noise = x0[i] + data = x1[j] + + # Output the permuted samples in the minibatch + mask = mask[i] if mask is not None else None + return noise, data, mask diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/vdm.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/vdm.py new file mode 100644 index 0000000000..fe9f395453 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/vdm.py @@ -0,0 +1,515 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import warnings +from typing import Callable, Optional, Union + +import torch +import torch.nn as nn +import torch.nn.functional as F +from jaxtyping import Bool, Float +from torch import Tensor + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +from bionemo.moco.distributions.prior.distribution import PriorDistribution +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.interpolants.base_interpolant import Interpolant, PredictionType, pad_like, string_to_enum +from bionemo.moco.schedules.noise.continuous_snr_transforms import ContinuousSNRTransform + + +class VDM(Interpolant): + """A Variational Diffusion Models (VDM) interpolant. + + ------- + + Examples: + ```python + >>> import torch + >>> from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior + >>> from bionemo.moco.distributions.time.uniform import UniformTimeDistribution + >>> from bionemo.moco.interpolants.discrete_time.continuous.vdm import VDM + >>> from bionemo.moco.schedules.noise.continuous_snr_transforms import CosineSNRTransform + >>> from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule + + + vdm = VDM( + time_distribution = UniformTimeDistribution(...), + prior_distribution = GaussianPrior(...), + noise_schedule = CosineSNRTransform(...), + ) + model = Model(...) + + # Training + for epoch in range(1000): + data = data_loader.get(...) + time = vdm.sample_time(batch_size) + noise = vdm.sample_prior(data.shape) + xt = vdm.interpolate(data, noise, time) + + x_pred = model(xt, time) + loss = vdm.loss(x_pred, data, time) + loss.backward() + + # Generation + x_pred = vdm.sample_prior(data.shape) + for t in LinearInferenceSchedule(...).generate_schedule(): + time = torch.full((batch_size,), t) + x_hat = model(x_pred, time) + x_pred = vdm.step(x_hat, time, x_pred) + return x_pred + + ``` + """ + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + noise_schedule: ContinuousSNRTransform, + prediction_type: Union[PredictionType, str] = PredictionType.DATA, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes the DDPM interpolant. + + Args: + time_distribution (TimeDistribution): The distribution of time steps, used to sample time points for the diffusion process. + prior_distribution (PriorDistribution): The prior distribution of the variable, used as the starting point for the diffusion process. + noise_schedule (ContinuousSNRTransform): The schedule of noise, defining the amount of noise added at each time step. + prediction_type (PredictionType, optional): The type of prediction, either "data" or another type. Defaults to "data". + device (str, optional): The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(time_distribution, prior_distribution, device, rng_generator) + if not isinstance(prior_distribution, GaussianPrior): + warnings.warn("Prior distribution is not a GaussianPrior, unexpected behavior may occur") + self.noise_schedule = noise_schedule + self.prediction_type = string_to_enum(prediction_type, PredictionType) + self._loss_function = nn.MSELoss(reduction="none") + + def interpolate(self, data: Tensor, t: Tensor, noise: Tensor): + """Get x(t) with given time t from noise and data. + + Args: + data (Tensor): target + t (Tensor): time + noise (Tensor): noise from prior() + """ + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + psi, omega = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + psi = pad_like(psi, data) + omega = pad_like(omega, data) + x_t = data * psi + noise * omega + return x_t + + def forward_process(self, data: Tensor, t: Tensor, noise: Optional[Tensor] = None): + """Get x(t) with given time t from noise and data. + + Args: + data (Tensor): target + t (Tensor): time + noise (Tensor, optional): noise from prior(). Defaults to None + """ + if noise is None: + noise = self.sample_prior(data.shape) + return self.interpolate(data, t, noise) + + def process_data_prediction(self, model_output: Tensor, sample, t): + """Converts the model output to a data prediction based on the prediction type. + + This conversion stems from the Progressive Distillation for Fast Sampling of Diffusion Models https://arxiv.org/pdf/2202.00512. + Given the model output and the sample, we convert the output to a data prediction based on the prediction type. + The conversion formulas are as follows: + - For "noise" prediction type: `pred_data = (sample - noise_scale * model_output) / data_scale` + - For "data" prediction type: `pred_data = model_output` + - For "v_prediction" prediction type: `pred_data = data_scale * sample - noise_scale * model_output` + + Args: + model_output (Tensor): The output of the model. + sample (Tensor): The input sample. + t (Tensor): The time step. + + Returns: + The data prediction based on the prediction type. + + Raises: + ValueError: If the prediction type is not one of "noise", "data", or "v_prediction". + """ + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + data_scale, noise_scale = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + data_scale = pad_like(data_scale, model_output) + noise_scale = pad_like(noise_scale, model_output) + if self.prediction_type == PredictionType.NOISE: + pred_data = (sample - noise_scale * model_output) / data_scale + elif self.prediction_type == PredictionType.DATA: + pred_data = model_output + elif self.prediction_type == PredictionType.VELOCITY: + pred_data = data_scale * sample - noise_scale * model_output + else: + raise ValueError( + f"prediction_type given as {self.prediction_type} must be one of PredictionType.NOISE, PredictionType.DATA or" + f" PredictionType.VELOCITY for vdm." + ) + return pred_data + + def process_noise_prediction(self, model_output: Tensor, sample: Tensor, t: Tensor): + """Do the same as process_data_prediction but take the model output and convert to nosie. + + Args: + model_output (Tensor): The output of the model. + sample (Tensor): The input sample. + t (Tensor): The time step. + + Returns: + The input as noise if the prediction type is "noise". + + Raises: + ValueError: If the prediction type is not "noise". + """ + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + data_scale, noise_scale = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + data_scale = pad_like(data_scale, model_output) + noise_scale = pad_like(noise_scale, model_output) + if self.prediction_type == PredictionType.NOISE: + pred_noise = model_output + elif self.prediction_type == PredictionType.DATA: + pred_noise = (sample - data_scale * model_output) / noise_scale + elif self.prediction_type == PredictionType.VELOCITY: + pred_data = data_scale * sample - noise_scale * model_output + pred_noise = (sample - data_scale * pred_data) / noise_scale + else: + raise ValueError( + f"prediction_type given as {self.prediction_type} must be one of `noise`, `data` or" + " `v_prediction` for vdm." + ) + return pred_noise + + def step( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0, + ): + """Do one step integration. + + Args: + model_out (Tensor): The output of the model. + xt (Tensor): The current data point. + t (Tensor): The current time step. + dt (Tensor): The time step increment. + mask (Optional[Tensor], optional): An optional mask to apply to the data. Defaults to None. + center (bool): Whether to center the data. Defaults to False. + temperature (Float): The temperature parameter for low temperature sampling. Defaults to 1.0. + + Note: + The temperature parameter controls the trade off between diversity and sample quality. + Decreasing the temperature sharpens the sampling distribtion to focus on more likely samples. + The impact of low temperature sampling must be ablated analytically. + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + x_hat = self.process_data_prediction(model_out, xt, t) + + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + alpha_t, sigma_t = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + + if (t - dt < 0).any(): + raise ValueError( + "Error in inference schedule: t - dt < 0. Please ensure that your inference time schedule has shape T with the final t = dt to make s = 0" + ) + + log_snr_s = self.noise_schedule.calculate_log_snr(t - dt, device=self.device) + alpha_s, sigma_s = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr_s) + sigma_s_2 = sigma_s * sigma_s + sigma_t_2 = sigma_t * sigma_t + alpha_t_s = alpha_t / alpha_s + sigma_2_t_s = -torch.expm1(F.softplus(-log_snr_s) - F.softplus(-log_snr)) # Equation 63 + + omega_r = alpha_t_s * sigma_s_2 / sigma_t_2 # Equation 28 + psi_r = alpha_s * sigma_2_t_s / sigma_t_2 + std = sigma_2_t_s.sqrt() * sigma_s / sigma_t + nonzero_mask = ( + t > 0 + ).float() # based on the time this is always just ones. can leave for now to see if ever want to take extra step and only grab mean + + psi_r = pad_like(psi_r, x_hat) + omega_r = pad_like(omega_r, x_hat) + std = pad_like(std, x_hat) + nonzero_mask = pad_like(nonzero_mask, x_hat) + + mean = psi_r * x_hat + omega_r * xt + eps = torch.randn_like(mean).to(model_out.device) + x_next = mean + nonzero_mask * std * eps * temperature + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def score(self, x_hat: Tensor, xt: Tensor, t: Tensor): + """Converts the data prediction to the estimated score function. + + Args: + x_hat (tensor): The predicted data point. + xt (Tensor): The current data point. + t (Tensor): The time step. + + Returns: + The estimated score function. + """ + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + psi, omega = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + psi = pad_like(psi, x_hat) + omega = pad_like(omega, x_hat) + score = psi * x_hat - xt + score = score / (omega * omega) + return score + + def step_ddim( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + eta: Float = 0.0, + center: Bool = False, + ): + """Do one step of DDIM sampling. + + From the ddpm equations alpha_bar = alpha**2 and 1 - alpha**2 = sigma**2 + + Args: + model_out (Tensor): output of the model + t (Tensor): current time step + xt (Tensor): current data point + dt (Tensor): The time step increment. + mask (Optional[Tensor], optional): mask for the data point. Defaults to None. + eta (Float, optional): DDIM sampling parameter. Defaults to 0.0. + center (Bool, optional): whether to center the data point. Defaults to False. + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + data_pred = self.process_data_prediction(model_out, xt, t) + noise_pred = self.process_noise_prediction(model_out, xt, t) + eps = torch.randn_like(data_pred).to(model_out.device) + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + squared_alpha = log_snr.sigmoid() + squared_sigma = (-log_snr).sigmoid() + log_snr_prev = self.noise_schedule.calculate_log_snr(t - dt, device=self.device) + squared_alpha_prev = log_snr_prev.sigmoid() + squared_sigma_prev = (-log_snr_prev).sigmoid() + sigma_t_2 = squared_sigma_prev / squared_sigma * (1 - squared_alpha / squared_alpha_prev) + psi_r = torch.sqrt(squared_alpha_prev) + omega_r = torch.sqrt(1 - squared_alpha_prev - eta * eta * sigma_t_2) + + sigma_t_2 = pad_like(sigma_t_2, model_out) + psi_r = pad_like(psi_r, model_out) + omega_r = pad_like(omega_r, model_out) + + mean = data_pred * psi_r + omega_r * noise_pred + x_next = mean + eta * sigma_t_2.sqrt() * eps + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def set_loss_weight_fn(self, fn: Callable): + """Sets the loss_weight attribute of the instance to the given function. + + Args: + fn: The function to set as the loss_weight attribute. This function should take three arguments: raw_loss, t, and weight_type. + """ + self.loss_weight = fn + + def loss_weight(self, raw_loss: Tensor, t: Tensor, weight_type: str, dt: Float = 0.001) -> Tensor: + """Calculates the weight for the loss based on the given weight type. + + This function computes the loss weight according to the specified `weight_type`. + The available weight types are: + - "ones": uniform weight of 1.0 + - "data_to_noise": derived from Equation (9) of https://arxiv.org/pdf/2202.00512 + - "variational_objective": based on the variational objective, see https://arxiv.org/pdf/2202.00512 + + Args: + raw_loss (Tensor): The raw loss calculated from the model prediction and target. + t (Tensor): The time step. + weight_type (str): The type of weight to use. Can be "ones", "data_to_noise", or "variational_objective". + dt (Float, optional): The time step increment. Defaults to 0.001. + + Returns: + Tensor: The weight for the loss. + + Raises: + ValueError: If the weight type is not recognized. + """ + if weight_type == "ones": + schedule = torch.ones_like(raw_loss).to(raw_loss.device) + elif weight_type == "data_to_noise": # + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + psi, omega = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + schedule = (psi**2) / (omega**2) + for _ in range(raw_loss.ndim - 1): + schedule = schedule.unsqueeze(-1) + elif weight_type == "variational_objective": + # (1-SNR(t-1)/SNR(t)), + snr = torch.exp(self.noise_schedule.calculate_log_snr(t, device=self.device)) + snr_m1 = torch.exp(self.noise_schedule.calculate_log_snr(t - dt, device=self.device)) + schedule = 1 - snr_m1 / snr + for _ in range(raw_loss.ndim - 1): + schedule = schedule.unsqueeze(-1) + else: + raise ValueError("Invalid loss weight keyword") + return schedule + + def loss( + self, + model_pred: Tensor, + target: Tensor, + t: Tensor, + dt: Optional[Float] = 0.001, + mask: Optional[Tensor] = None, + weight_type: str = "ones", + ): + """Calculates the loss given the model prediction, target, and time. + + Args: + model_pred (Tensor): The predicted output from the model. + target (Tensor): The target output for the model prediction. + t (Tensor): The time at which the loss is calculated. + dt (Optional[Float], optional): The time step increment. Defaults to 0.001. + mask (Optional[Tensor], optional): The mask for the data point. Defaults to None. + weight_type (str, optional): The type of weight to use for the loss. Can be "ones", "data_to_noise", or "variational_objective". Defaults to "ones". + + Returns: + Tensor: The calculated loss batch tensor. + """ + raw_loss = self._loss_function(model_pred, target) + update_weight = self.loss_weight(raw_loss, t, weight_type, dt) + loss = raw_loss * update_weight + if mask is not None: + loss = loss * mask.unsqueeze(-1) + n_elem = torch.sum(mask, dim=-1) + loss = torch.sum(loss, dim=tuple(range(1, raw_loss.ndim))) / n_elem + else: + loss = torch.sum(loss, dim=tuple(range(1, raw_loss.ndim))) / model_pred.size(1) + return loss + + def step_hybrid_sde( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0, + equilibrium_rate: Float = 0.0, + ) -> Tensor: + """Do one step integration of Hybrid Langevin-Reverse Time SDE. + + See section B.3 page 37 https://www.biorxiv.org/content/10.1101/2022.12.01.518682v1.full.pdf. + and https://github.com/generatebio/chroma/blob/929407c605013613941803c6113adefdccaad679/chroma/layers/structure/diffusion.py#L730 + + Args: + model_out (Tensor): The output of the model. + xt (Tensor): The current data point. + t (Tensor): The current time step. + dt (Tensor): The time step increment. + mask (Optional[Tensor], optional): An optional mask to apply to the data. Defaults to None. + center (bool, optional): Whether to center the data. Defaults to False. + temperature (Float, optional): The temperature parameter for low temperature sampling. Defaults to 1.0. + equilibrium_rate (Float, optional): The rate of Langevin equilibration. Scales the amount of Langevin dynamics per unit time. Best values are in the range [1.0, 5.0]. Defaults to 0.0. + + Note: + For all step functions that use the SDE formulation its important to note that we are moving backwards in time which corresponds to an apparent sign change. + A clear example can be seen in slide 29 https://ernestryu.com/courses/FM/diffusion1.pdf. + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + x_hat = self.process_data_prediction(model_out, xt, t) + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + alpha, sigma = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + # Schedule coeffiecients + beta = self.noise_schedule.calculate_beta(t) + inverse_temperature = 1 / temperature # lambda_0 + langevin_factor = equilibrium_rate + # Temperature coefficients + lambda_t = ( + inverse_temperature * (sigma.pow(2) + alpha.pow(2)) / (inverse_temperature * sigma.pow(2) + alpha.pow(2)) + ) + # langevin_isothermal = True + lambda_langevin = inverse_temperature # if langevin_isothermal else lambda_t + + score_scale_t = lambda_t + lambda_langevin * langevin_factor / 2.0 + + eps = torch.randn_like(x_hat).to(model_out.device) + score = self.score(x_hat, xt, t) + beta = pad_like(beta, model_out) + score_scale_t = pad_like(score_scale_t, model_out) + + gT = beta * ((-1 / 2) * xt - score_scale_t * score) + gW = torch.sqrt((1.0 + langevin_factor) * beta.abs()) * eps + + x_next = xt + dt * gT + dt.sqrt() * gW + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def step_ode( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0, + ) -> Tensor: + """Do one step integration of ODE. + + See section B page 36 https://www.biorxiv.org/content/10.1101/2022.12.01.518682v1.full.pdf. + and https://github.com/generatebio/chroma/blob/929407c605013613941803c6113adefdccaad679/chroma/layers/structure/diffusion.py#L730 + + Args: + model_out (Tensor): The output of the model. + xt (Tensor): The current data point. + t (Tensor): The current time step. + dt (Tensor): The time step increment. + mask (Optional[Tensor], optional): An optional mask to apply to the data. Defaults to None. + center (bool, optional): Whether to center the data. Defaults to False. + temperature (Float, optional): The temperature parameter for low temperature sampling. Defaults to 1.0. + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + x_hat = self.process_data_prediction(model_out, xt, t) + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + alpha, sigma = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + # Schedule coeffiecients + beta = self.noise_schedule.calculate_beta(t) + inverse_temperature = 1 / temperature + # Temperature coefficients + lambda_t = ( + inverse_temperature * (sigma.pow(2) + alpha.pow(2)) / (inverse_temperature * sigma.pow(2) + alpha.pow(2)) + ) + + score = self.score(x_hat, xt, t) + beta = pad_like(beta, model_out) + lambda_t = pad_like(lambda_t, model_out) + + gT = (-1 / 2) * beta * (xt + lambda_t * score) + + x_next = xt + gT * dt + x_next = self.clean_mask_center(x_next, mask, center) + return x_next diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/discrete_flow_matching.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/discrete_flow_matching.py new file mode 100644 index 0000000000..668058da43 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/discrete_flow_matching.py @@ -0,0 +1,311 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from typing import Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F +from jaxtyping import Bool, Float +from torch import Tensor + +from bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior +from bionemo.moco.distributions.prior.distribution import DiscretePriorDistribution +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.interpolants.base_interpolant import Interpolant, pad_like + + +class DiscreteFlowMatcher(Interpolant): + """A Discrete Flow Model (DFM) interpolant.""" + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: DiscretePriorDistribution, + device: str = "cpu", + eps: Float = 1e-5, + rng_generator: Optional[torch.Generator] = None, + ): + """Initialize the DFM interpolant. + + Args: + time_distribution (TimeDistribution): The time distribution for the diffusion process. + prior_distribution (DiscretePriorDistribution): The prior distribution for the discrete masked tokens. + device (str, optional): The device to use for computations. Defaults to "cpu". + eps: small Float to prevent dividing by zero. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(time_distribution, prior_distribution, device, rng_generator) + self.num_classes = prior_distribution.num_classes + self.eps = eps + self.use_mask = isinstance(self.prior_distribution, DiscreteMaskedPrior) + if self.use_mask: + self.mask_index = prior_distribution.mask_dim # type: ignore + self._loss_function = nn.CrossEntropyLoss(reduction="none") + + def interpolate(self, data: Tensor, t: Tensor, noise: Tensor): + """Get x(t) with given time t from noise and data. + + Args: + data (Tensor): target discrete ids + t (Tensor): time + noise: tensor noise ids + """ + if data.dtype == torch.float and data.ndim > 2: + x1 = data.argmax(-1) + else: + x1 = data + x0 = noise + t = pad_like(t, x1) + threshold = torch.rand_like(x1.float()) + xt = torch.where((threshold < 1 - t), x0, x1) + return xt + + def loss( + self, + logits: Tensor, + target: Tensor, + time: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + use_weight: Bool = False, + ): + """Calculate the cross-entropy loss between the model prediction and the target output. + + The loss is calculated between the batch x node x class logits and the target batch x node. + If using a masked prior please pass in the correct mask to calculate loss values on only masked states. + i.e. mask = data_mask * is_masked_state which is calculated with self.prior_dist.is_masked(xt)) + + If `use_weight` is True, the loss is weighted by 1/(1-t) defined in equation 24 in Appndix C. of https://arxiv.org/pdf/2402.04997 + + Args: + logits (Tensor): The predicted output from the model, with shape batch x node x class. + target (Tensor): The target output for the model prediction, with shape batch x node. + time (Tensor): The time at which the loss is calculated. + mask (Optional[Tensor], optional): The mask for the data point. Defaults to None. + use_weight (bool, optional): Whether to use the DFM time weight for the loss. Defaults to True. + + Returns: + Tensor: The calculated loss batch tensor. + """ + assert target.ndim + 1 == logits.ndim + loss = self._loss_function(logits.transpose(-1, 1), target.long()) + if mask is not None: + loss = loss * mask + num_non_masked_elements = torch.sum(mask, dim=-1) + num_non_masked_elements[num_non_masked_elements == 0] = ( + 1.0 #! prevents divide by zero since if the row is all zero the sum of loss = 0 + ) + loss = torch.sum(loss, dim=(-1)) / num_non_masked_elements + else: + loss = torch.sum(loss, dim=(-1)) / logits.size(1) + if use_weight: + if time is None: + raise ValueError("Time is required to compute the DFM liklehood weighting of 1/(1-t + self.eps)") + loss = loss * 1 / (1 - time + self.eps) + return loss + + def step( + self, + logits: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor | float, + temperature: Float = 1.0, + stochasticity: Float = 1.0, + ) -> Tensor: + """Perform a single step of DFM euler updates. + + Args: + logits (Tensor): The input logits. + t (Tensor): The current time step. + xt (Tensor): The current state. + dt (Tensor | float): The time step increment. + temperature (Float, optional): The temperature for the softmax calculation. Defaults to 1.0. + stochasticity (Float, optional): The stochasticity value for the step calculation. Defaults to 1.0. + + Returns: + Tensor: The updated state. + """ + x_1_pred_logits = logits + S = x_1_pred_logits.shape[-1] + t = pad_like(t, logits) + if isinstance(dt, float): + dt = torch.Tensor([dt] * t.shape[0]).to(self.device) + dt = pad_like(dt, logits) # type: ignore + + if self.use_mask: + if self.mask_index >= S: + raise ValueError( + "If using a non inclusive DiscreteMaskedPrior initialization, please pad the logits input with DiscreteMaskedPrior.pad_sample(logits)" + ) + + mask_one_hot = torch.zeros((S,), device=self.device) + mask_one_hot[self.mask_index] = 1.0 + x_1_pred_logits[..., self.mask_index] = -1.0e9 + + x_1_pred_prob = F.softmax(x_1_pred_logits / temperature, dim=-1) + + xt_is_mask = (xt == self.mask_index).unsqueeze(-1).float() # b x n x 1 + step_prob = ( + dt * x_1_pred_prob * ((1 + stochasticity * t) / (1 - t)) * xt_is_mask + + dt * (1 - xt_is_mask) * mask_one_hot.view(1, 1, -1) * stochasticity + ) # (b, n, S) + step_prob = self._regularize_step_probs(step_prob, xt) + else: + x_1_pred_prob = torch.nn.functional.softmax(x_1_pred_logits / temperature, dim=-1) # (b, n, S) + + pt_x1_eq_xt_prob = torch.gather(x_1_pred_prob, dim=-1, index=xt.long().unsqueeze(-1)) # (b, n, 1) + + step_prob = ( + dt * x_1_pred_prob * ((1 + stochasticity + stochasticity * (S - 1) * t) / (1 - t)) + + dt * pt_x1_eq_xt_prob * stochasticity + ) + step_prob = self._regularize_step_probs(step_prob, xt) + + x_next = torch.multinomial(step_prob.view(-1, S), num_samples=1, generator=self.rng_generator).view(xt.shape) + return x_next + + def _regularize_step_probs(self, step_prob: Tensor, xt: Tensor) -> Tensor: + """Regularize the step probabilities to ensure that the probability of the current state xt is set to the remaining probability mass after clipping and scattering. + + Args: + step_prob (Tensor): The input step probabilities with shape (batch, node, class). + xt (Tensor): The current state with shape (batch, node). + + Returns: + Tensor: The regularized step probabilities with shape (batch, node, class). + """ + device = step_prob.device + # Clamp the step probabilities to ensure they are within the valid range [0.0, 1.0] + step_prob = torch.clamp(step_prob, min=0.0, max=1.0) + # Set the probability of the current state xt to 0 + step_prob.scatter_( + dim=-1, + index=xt.unsqueeze(-1), + src=torch.zeros((*xt.shape, 1), dtype=torch.float, device=device), + ) + # Set the probability of the current state xt to the remaining probability mass + step_prob.scatter_( + dim=-1, + index=xt[..., None], + src=1 - torch.sum(step_prob, dim=-1, keepdim=True), + ) + step_prob = torch.clamp(step_prob, min=0.0, max=1.0) + # Clamp the step probabilities again to ensure they are within the valid range [0.0, 1.0] + return step_prob + + def step_purity( + self, + logits: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor | float, + temperature: Float = 1.0, + stochasticity: Float = 1.0, + ) -> Tensor: + """Perform a single step of purity sampling. + + https://github.com/jasonkyuyim/multiflow/blob/6278899970523bad29953047e7a42b32a41dc813/multiflow/data/interpolant.py#L346 + Here's a high-level overview of what the function does: + TODO: check if the -1e9 and 1e-9 are small enough or using torch.inf would be better + + 1. Preprocessing: + Checks if dt is a float and converts it to a tensor if necessary. + Pads t and dt to match the shape of xt. + Checks if the mask_index is valid (i.e., within the range of possible discrete values). + 2. Masking: + Sets the logits corresponding to the mask_index to a low value (-1e9) to effectively mask out those values. + Computes the softmax probabilities of the logits. + Sets the probability of the mask_index to a small value (1e-9) to avoid numerical issues. + 3.Purity sampling: + Computes the maximum log probabilities of the softmax distribution. + Computes the indices of the top-number_to_unmask samples with the highest log probabilities. + Uses these indices to sample new values from the original distribution. + 4. Unmasking and updating: + Creates a mask to select the top-number_to_unmask samples. + Uses this mask to update the current state xt with the new samples. + 5. Re-masking: + Generates a new mask to randomly re-mask some of the updated samples. + Applies this mask to the updated state xt. + + Args: + logits (Tensor): The input logits. + t (Tensor): The current time step. + xt (Tensor): The current state. + dt (Tensor): The time step increment. + temperature (Float, optional): The temperature for the softmax calculation. Defaults to 1.0. + stochasticity (Float, optional): The stochasticity value for the step calculation. Defaults to 1.0. + + Returns: + Tensor: The updated state. + """ + if logits.ndim > 3: + raise ValueError("Purity Sampling is only implmented for logits shape batch x sequence x state space.") + if isinstance(dt, float): + dt = torch.Tensor([dt] * t.shape[0]).to(self.device) + x_1_pred_logits = logits + B, N, S = x_1_pred_logits.shape + + if not self.use_mask: + raise ValueError("Purity Sampling only works with a DiscreteMaskPrior") + + if self.mask_index >= S: + raise ValueError( + "If using a non inclusive DiscreteMaskedPrior initialization, please pad the logits input with DiscreteMaskedPrior.pad_sample(logits)" + ) + x_1_pred_logits[..., self.mask_index] = -1.0e9 + x_1_pred_prob = F.softmax(x_1_pred_logits / temperature, dim=-1) + x_1_pred_prob[..., self.mask_index] = 1e-9 + max_logprob = torch.max(torch.log(x_1_pred_prob), dim=-1)[0] # (b, n) + max_logprob = max_logprob - (xt != self.mask_index).float() * 1e9 + sorted_max_logprobs_idcs = torch.argsort(max_logprob, dim=-1, descending=True) # (b, n) + unmask_probs = (dt * (1 + stochasticity * t) / (1 - t)).clamp(max=1) + # For M mask tokens we have p chance to unmask so we try for each one and see how many to do + number_to_unmask = torch.binomial( + count=torch.count_nonzero(xt == self.mask_index, dim=-1).float(), prob=unmask_probs + ) + unmasked_samples = torch.multinomial(x_1_pred_prob.view(-1, S), num_samples=1).view(xt.shape) + + # Taken from MultiFlow + # Vectorized version of: + # for b in range(B): + # for d in range(D): + # if d < number_to_unmask[b]: + # aatypes_t[b, d] = unmasked_samples[b, sorted_max_logprobs_idcs[b, d]] + + D_grid = torch.arange(N, device=self.device).view(1, -1).repeat(B, 1) + mask1 = (D_grid < number_to_unmask.view(-1, 1)).float() + initial_val_max_logprob_idcs = sorted_max_logprobs_idcs[:, 0].view(-1, 1).repeat(1, N) + masked_sorted_max_logprobs_idcs = ( + mask1 * sorted_max_logprobs_idcs + (1 - mask1) * initial_val_max_logprob_idcs + ).long() + mask2 = torch.zeros((B, N), dtype=torch.long, device=self.device) + mask2.scatter_( + dim=1, + index=masked_sorted_max_logprobs_idcs, + src=torch.ones((B, N), dtype=torch.long, device=self.device), + ) + unmask_zero_row = (number_to_unmask == 0).view(-1, 1).repeat(1, N).long() + mask2 = mask2 * (1 - unmask_zero_row) + x_next = xt * (1 - mask2) + unmasked_samples * mask2 + + # re-mask + u = torch.rand((B, N), device=self.device, generator=self.rng_generator) + dt = pad_like(dt, u) # type: ignore + re_mask_mask = (u < dt * stochasticity).long() + x_next = x_next * (1 - re_mask_mask) + self.mask_index * re_mask_mask + + return x_next diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/mdlm.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/mdlm.py new file mode 100644 index 0000000000..350950edf0 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/mdlm.py @@ -0,0 +1,355 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from typing import Optional + +import torch +from torch import Tensor + +from bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.interpolants.base_interpolant import Interpolant, pad_like +from bionemo.moco.schedules.noise.continuous_noise_transforms import ContinuousExpNoiseTransform + + +class MDLM(Interpolant): + """A Masked discrete Diffusion Language Model (MDLM) interpolant. + + ------- + + Examples: + ```python + >>> import torch + >>> from bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior + >>> from bionemo.moco.distributions.time.uniform import UniformTimeDistribution + >>> from bionemo.moco.interpolants.continuous_time.discrete.mdlm import MDLM + >>> from bionemo.moco.schedules.noise.continuous_noise_transforms import CosineExpNoiseTransform + >>> from bionemo.moco.schedules.inference_time_schedules import LinearTimeSchedule + + + mdlm = MDLM( + time_distribution = UniformTimeDistribution(discrete_time = False,...), + prior_distribution = DiscreteMaskedPrior(...), + noise_schedule = CosineExpNoiseTransform(...), + ) + model = Model(...) + + # Training + for epoch in range(1000): + data = data_loader.get(...) + time = mdlm.sample_time(batch_size) + xt = mdlm.interpolate(data, time) + + logits = model(xt, time) + loss = mdlm.loss(logits, data, xt, time) + loss.backward() + + # Generation + x_pred = mdlm.sample_prior(data.shape) + schedule = LinearTimeSchedule(...) + inference_time = schedule.generate_schedule() + dts = schedue.discreteize() + for t, dt in zip(inference_time, dts): + time = torch.full((batch_size,), t) + logits = model(x_pred, time) + x_pred = mdlm.step(logits, time, x_pred, dt) + return x_pred + + ``` + """ + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: DiscreteMaskedPrior, + noise_schedule: ContinuousExpNoiseTransform, + device: str = "cpu", + rng_generator: Optional[torch.Generator] = None, + ): + """Initialize the Masked Discrete Language Model (MDLM) interpolant. + + Args: + time_distribution (TimeDistribution): The distribution governing the time variable in the diffusion process. + prior_distribution (DiscreteMaskedPrior): The prior distribution over the discrete token space, including masked tokens. + noise_schedule (ContinuousExpNoiseTransform): The noise schedule defining the noise intensity as a function of time. + device (str, optional): The device to use for computations. Defaults to "cpu". + rng_generator (Optional[torch.Generator], optional): The random number generator for reproducibility. Defaults to None. + """ + super().__init__(time_distribution, prior_distribution, device, rng_generator) + if not isinstance(prior_distribution, DiscreteMaskedPrior): + raise ValueError("DiscreteMaskedPrior required for MDLM") + if not isinstance(noise_schedule, ContinuousExpNoiseTransform): + raise ValueError("ContinuousExpNoiseTransform required for MDLM") + self.noise_schedule = noise_schedule + self.num_classes = prior_distribution.num_classes + self.mask_index = prior_distribution.mask_dim + # Gumbel used for confidence sampling. Note rng_generator not compatible with torch.Distribution. + # self.gumbel_dist = torch.distributions.Gumbel(torch.tensor(0.0), torch.tensor(1.0)) + + def interpolate(self, data: Tensor, t: Tensor): + """Get x(t) with given time t from noise and data. + + Args: + data (Tensor): target discrete ids + t (Tensor): time + """ + if data.dtype == torch.float and data.ndim > 2: + x0 = data.argmax(-1) + else: + x0 = data + sigma = self.noise_schedule.calculate_sigma(t, data.device) + alpha = self.noise_schedule.sigma_to_alpha(sigma) + p_mask = 1 - alpha + p_mask = pad_like(p_mask, x0) + mask_indices = torch.rand(*x0.shape, device=x0.device, generator=self.rng_generator) < p_mask + xt = torch.where(mask_indices, self.mask_index, x0) + return xt + + def forward_process(self, data: Tensor, t: Tensor) -> Tensor: + """Apply the forward process to the data at time t. + + Args: + data (Tensor): target discrete ids + t (Tensor): time + + Returns: + Tensor: x(t) after applying the forward process + """ + return self.interpolate(data, t) + + def loss( + self, + logits: Tensor, + target: Tensor, + xt: Tensor, + time: Tensor, + mask: Optional[Tensor] = None, + use_weight=True, + ): + """Calculate the cross-entropy loss between the model prediction and the target output. + + The loss is calculated between the batch x node x class logits and the target batch x node, + considering the current state of the discrete sequence `xt` at time `time`. + + If `use_weight` is True, the loss is weighted by the reduced form of the MDLM time weight for continuous NELBO, + as specified in equation 11 of https://arxiv.org/pdf/2406.07524. This weight is proportional to the derivative + of the noise schedule with respect to time, and is used to emphasize the importance of accurate predictions at + certain times in the diffusion process. + + Args: + logits (Tensor): The predicted output from the model, with shape batch x node x class. + target (Tensor): The target output for the model prediction, with shape batch x node. + xt (Tensor): The current state of the discrete sequence, with shape batch x node. + time (Tensor): The time at which the loss is calculated. + mask (Optional[Tensor], optional): The mask for the data point. Defaults to None. + use_weight (bool, optional): Whether to use the MDLM time weight for the loss. Defaults to True. + + Returns: + Tensor: The calculated loss batch tensor. + """ + logprobs = self._subs_parameterization(logits, xt) + log_p_theta = torch.gather(input=logprobs, dim=-1, index=target[..., None]).squeeze(-1) + + sigma = self.noise_schedule.calculate_sigma(time, target.device) + dsigma = self.noise_schedule.d_dt_sigma(time, target.device) # type: ignore + loss = -log_p_theta + if use_weight: + loss = loss * (dsigma / torch.expm1(sigma))[:, None] + + if mask is not None: + loss = loss * mask + num_non_masked_elements = torch.sum(mask, dim=-1) + loss = torch.sum(loss, dim=(-1)) / num_non_masked_elements + else: + loss = torch.sum(loss, dim=(-1)) / logits.size(1) + return loss + + def _subs_parameterization(self, logits: Tensor, xt: Tensor) -> Tensor: + """Apply subsititution parameterization to the logits. + + This function enforces that the model can never predict a mask token by lowering the mask logits. + Then, for all unmasked tokens, it copies over from xt to enable carry over unmasked. + Once a token is unmasked, it stays the same. + See Sec. 3.2.3 https://arxiv.org/pdf/2406.07524. + + Note that recent work has shown that allowing the model to rethink + carry over unmasking is beneficial https://arxiv.org/abs/2410.06264. + + Args: + logits (Tensor): The logits tensor with shape batch x node x class. + xt (Tensor): The tensor of unmasked tokens with shape batch x node. + + Returns: + Tensor: The modified logits tensor with substitution parameterization applied. + """ + logits[..., self.mask_index] += -1000000.0 # clean input is never masked + logprobs = logits - torch.logsumexp(logits, dim=-1, keepdim=True) # normalize + unmasked_indices = xt != self.mask_index + logprobs[unmasked_indices] = -1000000.0 + logprobs[unmasked_indices, xt[unmasked_indices]] = 0 # Unmasked token remains unchanged + return logprobs + + def step(self, logits, t, xt, dt) -> Tensor: + """Perform a single step of MDLM DDPM step. + + Parameters: + logits (Tensor): The input logits. + t (float): The current time step. + xt (Tensor): The current state. + dt (float): The time step increment. + + Returns: + Tensor: The updated state. + """ + sigma_t = self.noise_schedule.calculate_sigma(t, logits.device) + sigma_s = self.noise_schedule.calculate_sigma(t - dt, logits.device) + alpha_t = torch.exp(-sigma_t) + alpha_s = torch.exp(-sigma_s) + p_mask_s = 1 - alpha_s + alpha_t = pad_like(alpha_t, logits) + alpha_s = pad_like(alpha_s, logits) + p_mask_s = pad_like(p_mask_s, logits) + # Apply subs parameterization + log_p_x0 = self._subs_parameterization(logits, xt) + if p_mask_s.ndim != log_p_x0.ndim: + raise ValueError(f"Dimension Mistmatch {p_mask_s.shape} {log_p_x0.shape}") + # Equation 6 from MDLM + prob_s_given_t = log_p_x0.exp() * (alpha_s - alpha_t) # righthand side (alpha_s - alpha_t)*x + prob_s_given_t[..., self.mask_index] = p_mask_s[..., 0] # lefthand side (1 - alpha_s)*M + sampled_x = self._sample_categorical(prob_s_given_t) + carry_over_unmask = (xt != self.mask_index).to(xt.dtype) + return carry_over_unmask * xt + (1 - carry_over_unmask) * sampled_x + + def _sample_categorical(self, categorical_probs: Tensor) -> Tensor: + """Sample from a categorical distribution using the Gumbel trick. + + Args: + categorical_probs (Tensor): The probabilities of each category, shape batch x node x class. + + Returns: + Tensor: The sampled category indices, shape batch x node. + """ + gumbel_norm = ( + 1e-10 + - ( + torch.rand(*categorical_probs.shape, device=categorical_probs.device, generator=self.rng_generator) + + 1e-10 + ).log() + ) + scaled_proability = categorical_probs / gumbel_norm + return scaled_proability.argmax(dim=-1) + + def step_confidence( + self, + logits: Tensor, + xt: Tensor, + curr_step: int, + num_steps: int, + logit_temperature: float = 1.0, + randomness: float = 1.0, + confidence_temperature: float = 1.0, + ) -> Tensor: + """Update the input sequence xt by sampling from the predicted logits and adding Gumbel noise. + + Method taken from GenMol Seul et al. + + Args: + logits: Predicted logits + xt: Input sequence + curr_step: Current step + num_steps: Total number of steps + logit_temperature: Temperature for softmax over logits + randomness: Scale for Gumbel noise + confidence_temperature: Temperature for Gumbel confidence + + Returns: + Updated input sequence xt + """ + if xt.ndim > 3: + raise NotImplementedError( + "step_confidence is implemented for Batch x Sequence x State Space shaped tensors." + ) + xt = xt.clone() + log_p_x0 = self._subs_parameterization(logits, xt) + # sample the code from the softmax prediction + probs = torch.softmax(log_p_x0 / logit_temperature, dim=-1) + preds = torch.distributions.Categorical(probs=probs).sample() + + confidence = probs.gather(-1, preds.unsqueeze(-1)).squeeze(-1) + # add Gumbel noise decreasing over the sampling process + ratio = curr_step / (num_steps - 1) + # Using manual definition of 0,1 Gumbel to pass in generator + gumbel_sample = -torch.log(-torch.log(torch.rand(xt.shape, generator=self.rng_generator))).to(logits.device) + # gumbel_sample = self.gumbel_dist.sample(xt.shape).to(logits.device) + gumbel_noise = gumbel_sample * randomness * (1 - ratio) # type: ignore + confidence = ( + (torch.log(confidence) + gumbel_noise) / confidence_temperature + ) # stems from tau of https://pytorch.org/docs/stable/_modules/torch/nn/functional.html#gumbel_softmax + + # do not predict on already predicted tokens + mask = xt == self.mask_index + confidence[~mask] = -torch.inf + + # choose the predicted token with the highest confidence + confidence_threshold, idx_mask = torch.topk(confidence, k=1, dim=-1) + confidence_threshold = confidence_threshold[:, -1].unsqueeze(-1) + + # replace the chosen tokens + to_replace = confidence >= confidence_threshold + to_replace = (mask.float() * to_replace.float()).bool() + xt[to_replace] = preds[to_replace] + return xt + + def step_argmax(self, model_out: Tensor): + """Returns the index of the maximum value in the last dimension of the model output. + + Args: + model_out (Tensor): The output of the model. + + Returns: + Tensor: The index of the maximum value in the last dimension of the model output. + """ + return model_out.argmax(dim=-1) + + def calculate_score(self, logits, x, t): + """Returns score of the given sample x at time t with the corresponding model output logits. + + Args: + logits (Tensor): The output of the model. + x (Tensor): The current data point. + t (Tensor): The current time. + + Returns: + Tensor: The score defined in Appendix C.3 Equation 76 of MDLM. + """ + sigma_t = self.noise_schedule.calculate_sigma(t, logits.device) + log_ratio = -torch.log( + torch.expm1(sigma_t) + ) # log ( exp(-sigma) / (1 - exp(-sigma))) = log(1/ (exp(sigma) - 1)) + + # Create masked and unmasked log scores + masked_log_score = logits + pad_like(log_ratio, logits) # xt is masked and prediction is not + masked_log_score[..., self.mask_index] = 0 # xt and prediction are mask + + unmasked_log_score = torch.full_like(logits, -1000000.0) + unmasked_log_score.scatter_(-1, x[..., None], 0) # place zeros where current predictions are + unmasked_log_score[..., self.mask_index] = -pad_like(log_ratio, logits[..., 0]) + + # Combine masked and unmasked log scores + masked_indices = (x == self.mask_index).to(logits.dtype)[..., None] + log_score = masked_log_score * masked_indices + unmasked_log_score * (1 - masked_indices) + + return log_score.exp() diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/ddpm.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/ddpm.py new file mode 100644 index 0000000000..c5dabd99f6 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/ddpm.py @@ -0,0 +1,526 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import warnings +from typing import Optional, Union + +import torch +import torch.nn as nn +from jaxtyping import Bool, Float +from torch import Tensor + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +from bionemo.moco.distributions.prior.distribution import PriorDistribution +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.interpolants.base_interpolant import Interpolant, PredictionType, pad_like, string_to_enum +from bionemo.moco.interpolants.discrete_time.utils import safe_index +from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteNoiseSchedule + + +class DDPM(Interpolant): + """A Denoising Diffusion Probabilistic Model (DDPM) interpolant. + + ------- + + Examples: + ```python + >>> import torch + >>> from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior + >>> from bionemo.moco.distributions.time.uniform import UniformTimeDistribution + >>> from bionemo.moco.interpolants.discrete_time.continuous.ddpm import DDPM + >>> from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule + >>> from bionemo.moco.schedules.inference_time_schedules import DiscreteLinearInferenceSchedule + + + ddpm = DDPM( + time_distribution = UniformTimeDistribution(discrete_time = True,...), + prior_distribution = GaussianPrior(...), + noise_schedule = DiscreteCosineNoiseSchedule(...), + ) + model = Model(...) + + # Training + for epoch in range(1000): + data = data_loader.get(...) + time = ddpm.sample_time(batch_size) + noise = ddpm.sample_prior(data.shape) + xt = ddpm.interpolate(data, noise, time) + + x_pred = model(xt, time) + loss = ddpm.loss(x_pred, data, time) + loss.backward() + + # Generation + x_pred = ddpm.sample_prior(data.shape) + for t in DiscreteLinearTimeSchedule(...).generate_schedule(): + time = torch.full((batch_size,), t) + x_hat = model(x_pred, time) + x_pred = ddpm.step(x_hat, time, x_pred) + return x_pred + + ``` + """ + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + noise_schedule: DiscreteNoiseSchedule, + prediction_type: Union[PredictionType, str] = PredictionType.DATA, + device: Union[str, torch.device] = "cpu", + last_time_idx: int = 0, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes the DDPM interpolant. + + Args: + time_distribution (TimeDistribution): The distribution of time steps, used to sample time points for the diffusion process. + prior_distribution (PriorDistribution): The prior distribution of the variable, used as the starting point for the diffusion process. + noise_schedule (DiscreteNoiseSchedule): The schedule of noise, defining the amount of noise added at each time step. + prediction_type (PredictionType): The type of prediction, either "data" or another type. Defaults to "data". + device (str): The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". + last_time_idx (int, optional): The last time index for discrete time. Set to 0 if discrete time is T-1, ..., 0 or 1 if T, ..., 1. Defaults to 0. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(time_distribution, prior_distribution, device, rng_generator) + if not isinstance(prior_distribution, GaussianPrior): + warnings.warn("Prior distribution is not a GaussianPrior, unexpected behavior may occur") + self.noise_schedule = noise_schedule + self._initialize_schedules(device) + self.prediction_type = string_to_enum(prediction_type, PredictionType) + self._loss_function = nn.MSELoss(reduction="none") + self.last_time_idx = last_time_idx + + def _initialize_schedules(self, device: Union[str, torch.device] = "cpu"): + """Sets up the Denoising Diffusion Probabilistic Model (DDPM) equations. + + This method initializes the schedules for the forward and reverse processes of the DDPM. It calculates the + alphas, betas, and log variances required for the diffusion process. + + Specifically, it computes: + + * `alpha_bar`: the cumulative product of `alpha_t` + * `alpha_bar_prev`: the previous cumulative product of `alpha_t` + * `posterior_variance`: the variance of the posterior distribution + * `posterior_mean_c0_coef` and `posterior_mean_ct_coef`: the coefficients for the posterior mean + * `log_var`: the log variance of the posterior distribution + + These values are then used to set up the forward and reverse schedules for the DDPM. + Specifically this is equation (6) (7) from https://arxiv.org/pdf/2006.11239 + """ + if self.noise_schedule is None: + raise ValueError("noise_schedule cannot be None for DDPM") + alphas = self.noise_schedule.generate_schedule(device=device) + betas = 1 - alphas + log_alpha = torch.log(alphas) + log_alpha_bar = torch.cumsum(log_alpha, dim=0) + alpha_bar = alphas_cumprod = torch.exp(log_alpha_bar) + alpha_bar_prev = alphas_cumprod_prev = torch.nn.functional.pad(alphas_cumprod[:-1], (1, 0), value=1.0) + posterior_variance = betas * (1.0 - alpha_bar_prev) / (1.0 - alpha_bar) + posterior_mean_c0_coef = betas * torch.sqrt(alphas_cumprod_prev) / (1.0 - alpha_bar) + posterior_mean_ct_coef = (1.0 - alpha_bar_prev) * torch.sqrt(alphas) / (1.0 - alpha_bar) + # log calculation clipped because the posterior variance is 0 at the beginning of the diffusion chain + posterior_logvar = torch.log( + torch.nn.functional.pad(posterior_variance[:-1], (1, 0), value=posterior_variance[0].item()) + ) + self._forward_data_schedule = torch.sqrt(alpha_bar) + self._forward_noise_schedule = torch.sqrt(1 - alpha_bar) + self._reverse_data_schedule = posterior_mean_c0_coef + self._reverse_noise_schedule = posterior_mean_ct_coef + self._log_var = posterior_logvar + self._alpha_bar = alpha_bar + self._alpha_bar_prev = alpha_bar_prev + self._betas = betas + self._posterior_variance = betas * (1.0 - alphas_cumprod_prev) / (1.0 - alphas_cumprod) + + @property + def forward_data_schedule(self) -> torch.Tensor: + """Returns the forward data schedule.""" + return self._forward_data_schedule + + @property + def forward_noise_schedule(self) -> torch.Tensor: + """Returns the forward noise schedule.""" + return self._forward_noise_schedule + + @property + def reverse_data_schedule(self) -> torch.Tensor: + """Returns the reverse data schedule.""" + return self._reverse_data_schedule + + @property + def reverse_noise_schedule(self) -> torch.Tensor: + """Returns the reverse noise schedule.""" + return self._reverse_noise_schedule + + @property + def log_var(self) -> torch.Tensor: + """Returns the log variance.""" + return self._log_var + + @property + def alpha_bar(self) -> torch.Tensor: + """Returns the alpha bar values.""" + return self._alpha_bar + + @property + def alpha_bar_prev(self) -> torch.Tensor: + """Returns the previous alpha bar values.""" + return self._alpha_bar_prev + + def interpolate(self, data: Tensor, t: Tensor, noise: Tensor): + """Get x(t) with given time t from noise and data. + + Args: + data (Tensor): target + t (Tensor): time + noise (Tensor): noise from prior() + """ + psi = safe_index(self._forward_data_schedule, t - self.last_time_idx, data.device) + omega = safe_index(self._forward_noise_schedule, t - self.last_time_idx, data.device) + psi = pad_like(psi, data) + omega = pad_like(omega, data) + x_t = data * psi + noise * omega + return x_t + + def forward_process(self, data: Tensor, t: Tensor, noise: Optional[Tensor] = None): + """Get x(t) with given time t from noise and data. + + Args: + data (Tensor): target + t (Tensor): time + noise (Tensor, optional): noise from prior(). Defaults to None. + """ + if noise is None: + noise = self.sample_prior(data.shape) + return self.interpolate(data, t, noise) + + def process_data_prediction(self, model_output: Tensor, sample: Tensor, t: Tensor): + """Converts the model output to a data prediction based on the prediction type. + + This conversion stems from the Progressive Distillation for Fast Sampling of Diffusion Models https://arxiv.org/pdf/2202.00512. + Given the model output and the sample, we convert the output to a data prediction based on the prediction type. + The conversion formulas are as follows: + - For "noise" prediction type: `pred_data = (sample - noise_scale * model_output) / data_scale` + - For "data" prediction type: `pred_data = model_output` + - For "v_prediction" prediction type: `pred_data = data_scale * sample - noise_scale * model_output` + + Args: + model_output (Tensor): The output of the model. + sample (Tensor): The input sample. + t (Tensor): The time step. + + Returns: + The data prediction based on the prediction type. + + Raises: + ValueError: If the prediction type is not one of "noise", "data", or "v_prediction". + """ + data_scale = safe_index(self._forward_data_schedule, t - self.last_time_idx, model_output.device) + noise_scale = safe_index(self._forward_noise_schedule, t - self.last_time_idx, model_output.device) + data_scale = pad_like(data_scale, model_output) + noise_scale = pad_like(noise_scale, model_output) + if self.prediction_type == PredictionType.NOISE: + pred_data = (sample - noise_scale * model_output) / data_scale + elif self.prediction_type == PredictionType.DATA: + pred_data = model_output + elif self.prediction_type == PredictionType.VELOCITY: + pred_data = data_scale * sample - noise_scale * model_output + else: + raise ValueError( + f"prediction_type given as {self.prediction_type} must be one of PredictionType.NOISE, PredictionType.DATA or" + f" PredictionType.VELOCITY for DDPM." + ) + return pred_data + + def process_noise_prediction(self, model_output, sample, t): + """Do the same as process_data_prediction but take the model output and convert to nosie. + + Args: + model_output: The output of the model. + sample: The input sample. + t: The time step. + + Returns: + The input as noise if the prediction type is "noise". + + Raises: + ValueError: If the prediction type is not "noise". + """ + data_scale = safe_index(self._forward_data_schedule, t - self.last_time_idx, model_output.device) + noise_scale = safe_index(self._forward_noise_schedule, t - self.last_time_idx, model_output.device) + data_scale = pad_like(data_scale, model_output) + noise_scale = pad_like(noise_scale, model_output) + if self.prediction_type == PredictionType.NOISE: + pred_noise = model_output + elif self.prediction_type == PredictionType.DATA: + pred_noise = (sample - data_scale * model_output) / noise_scale + elif self.prediction_type == PredictionType.VELOCITY: + pred_data = data_scale * sample - noise_scale * model_output + pred_noise = (sample - data_scale * pred_data) / noise_scale + else: + raise ValueError( + f"prediction_type given as {self.prediction_type} must be one of `noise`, `data` or" + " `v_prediction` for DDPM." + ) + return pred_noise + + def calculate_velocity(self, data: Tensor, t: Tensor, noise: Tensor) -> Tensor: + """Calculate the velocity term given the data, time step, and noise. + + Args: + data (Tensor): The input data. + t (Tensor): The current time step. + noise (Tensor): The noise term. + + Returns: + Tensor: The calculated velocity term. + """ + data_scale = safe_index(self._forward_data_schedule, t - self.last_time_idx, data.device) + noise_scale = safe_index(self._forward_noise_schedule, t - self.last_time_idx, data.device) + data_scale = pad_like(data_scale, data) + noise_scale = pad_like(noise_scale, data) + v = data_scale * noise - noise_scale * data + return v + + @torch.no_grad() + def step( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0, + ): + """Do one step integration. + + Args: + model_out (Tensor): The output of the model. + t (Tensor): The current time step. + xt (Tensor): The current data point. + mask (Optional[Tensor], optional): An optional mask to apply to the data. Defaults to None. + center (bool, optional): Whether to center the data. Defaults to False. + temperature (Float, optional): The temperature parameter for low temperature sampling. Defaults to 1.0. + + Note: + The temperature parameter controls the level of randomness in the sampling process. A temperature of 1.0 corresponds to standard diffusion sampling, while lower temperatures (e.g. 0.5, 0.2) result in less random and more deterministic samples. This can be useful for tasks that require more control over the generation process. + + Note for discrete time we sample from [T-1, ..., 1, 0] for T steps so we sample t = 0 hence the mask. + For continuous time we start from [1, 1 -dt, ..., dt] for T steps where s = t - 1 when t = 0 i.e dt is then 0 + + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + x_hat = self.process_data_prediction(model_out, xt, t) + psi_r = safe_index(self._reverse_data_schedule, t - self.last_time_idx, x_hat.device) + omega_r = safe_index(self._reverse_noise_schedule, t - self.last_time_idx, x_hat.device) + log_var = safe_index(self._log_var, t - self.last_time_idx, x_hat.device) # self._log_var[t.long()] + nonzero_mask = (t > self.last_time_idx).float() + psi_r = pad_like(psi_r, x_hat) + omega_r = pad_like(omega_r, x_hat) + log_var = pad_like(log_var, x_hat) + nonzero_mask = pad_like(nonzero_mask, x_hat) + + mean = psi_r * x_hat + omega_r * xt + eps = torch.randn_like(mean).to(model_out.device) + + x_next = mean + nonzero_mask * (0.5 * log_var).exp() * eps * temperature + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def step_noise( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0, + ): + """Do one step integration. + + Args: + model_out (Tensor): The output of the model. + t (Tensor): The current time step. + xt (Tensor): The current data point. + mask (Optional[Tensor], optional): An optional mask to apply to the data. Defaults to None. + center (bool, optional): Whether to center the data. Defaults to False. + temperature (Float, optional): The temperature parameter for low temperature sampling. Defaults to 1.0. + + Note: + The temperature parameter controls the level of randomness in the sampling process. A temperature of 1.0 corresponds to standard diffusion sampling, while lower temperatures (e.g. 0.5, 0.2) result in less random and more deterministic samples. This can be useful for tasks that require more control over the generation process. + + Note for discrete time we sample from [T-1, ..., 1, 0] for T steps so we sample t = 0 hence the mask. + For continuous time we start from [1, 1 -dt, ..., dt] for T steps where s = t - 1 when t = 0 i.e dt is then 0 + + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + eps_hat = self.process_noise_prediction(model_out, xt, t) + beta_t = safe_index(self._betas, t - self.last_time_idx, model_out.device) + recip_sqrt_alpha_t = torch.sqrt(1 / (1 - beta_t)) + eps_factor = ( + safe_index(self._betas, t - self.last_time_idx, model_out.device) + / (1 - safe_index(self._alpha_bar, t - self.last_time_idx, model_out.device)).sqrt() + ) + var = safe_index(self._posterior_variance, t - self.last_time_idx, model_out.device) # self._log_var[t.long()] + + nonzero_mask = (t > self.last_time_idx).float() + nonzero_mask = pad_like(nonzero_mask, model_out) + eps_factor = pad_like(eps_factor, xt) + recip_sqrt_alpha_t = pad_like(recip_sqrt_alpha_t, xt) + var = pad_like(var, xt) + + x_next = recip_sqrt_alpha_t * (xt - eps_factor * eps_hat) + nonzero_mask * var.sqrt() * torch.randn_like( + eps_hat + ).to(model_out.device) + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def score(self, x_hat: Tensor, xt: Tensor, t: Tensor): + """Converts the data prediction to the estimated score function. + + Args: + x_hat (Tensor): The predicted data point. + xt (Tensor): The current data point. + t (Tensor): The time step. + + Returns: + The estimated score function. + """ + alpha = safe_index(self._forward_data_schedule, t - self.last_time_idx, x_hat.device) + beta = safe_index(self._forward_noise_schedule, t - self.last_time_idx, x_hat.device) + alpha = pad_like(alpha, x_hat) + beta = pad_like(beta, x_hat) + score = alpha * x_hat - xt + score = score / (beta * beta) + return score + + def step_ddim( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + eta: Float = 0.0, + center: Bool = False, + ): + """Do one step of DDIM sampling. + + Args: + model_out (Tensor): output of the model + t (Tensor): current time step + xt (Tensor): current data point + mask (Optional[Tensor], optional): mask for the data point. Defaults to None. + eta (Float, optional): DDIM sampling parameter. Defaults to 0.0. + center (Bool, optional): whether to center the data point. Defaults to False. + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + data_pred = self.process_data_prediction(model_out, xt, t) + noise_pred = self.process_noise_prediction(model_out, xt, t) + eps = torch.randn_like(data_pred).to(model_out.device) + sigma = ( + eta + * torch.sqrt((1 - self._alpha_bar_prev) / (1 - self._alpha_bar)) + * torch.sqrt(1 - self._alpha_bar / self._alpha_bar_prev) + ) + sigma_t = safe_index(sigma, t - self.last_time_idx, model_out.device) + psi_r = safe_index(torch.sqrt(self._alpha_bar_prev), t - self.last_time_idx, model_out.device) + omega_r = safe_index(torch.sqrt(1 - self._alpha_bar_prev - sigma**2), t - self.last_time_idx, model_out.device) + sigma_t = pad_like(sigma_t, model_out) + psi_r = pad_like(psi_r, model_out) + omega_r = pad_like(omega_r, model_out) + mean = data_pred * psi_r + omega_r * noise_pred + x_next = mean + sigma_t * eps + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def set_loss_weight_fn(self, fn): + """Sets the loss_weight attribute of the instance to the given function. + + Args: + fn: The function to set as the loss_weight attribute. This function should take three arguments: raw_loss, t, and weight_type. + """ + self.loss_weight = fn + + def loss_weight(self, raw_loss: Tensor, t: Optional[Tensor], weight_type: str) -> Tensor: + """Calculates the weight for the loss based on the given weight type. + + These data_to_noise loss weights is derived in Equation (9) of https://arxiv.org/pdf/2202.00512. + + Args: + raw_loss (Tensor): The raw loss calculated from the model prediction and target. + t (Tensor): The time step. + weight_type (str): The type of weight to use. Can be "ones" or "data_to_noise" or "noise_to_data". + + Returns: + Tensor: The weight for the loss. + + Raises: + ValueError: If the weight type is not recognized. + """ + if weight_type == "ones": + schedule = torch.ones_like(raw_loss).to(raw_loss.device) + elif weight_type == "data_to_noise": + if t is None: + raise ValueError("Time cannot be None when using the data_to_noise loss weight") + schedule = (safe_index(self._forward_data_schedule, t - self.last_time_idx, raw_loss.device) ** 2) / ( + safe_index(self._forward_noise_schedule, t - self.last_time_idx, raw_loss.device) ** 2 + ) + schedule = pad_like(schedule, raw_loss) + elif weight_type == "noise_to_data": + if t is None: + raise ValueError("Time cannot be None when using the data_to_noise loss weight") + schedule = (safe_index(self._forward_noise_schedule, t - self.last_time_idx, raw_loss.device) ** 2) / ( + safe_index(self._forward_data_schedule, t - self.last_time_idx, raw_loss.device) ** 2 + ) + schedule = pad_like(schedule, raw_loss) + else: + raise ValueError("Invalid loss weight keyword") + return schedule + + def loss( + self, + model_pred: Tensor, + target: Tensor, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + weight_type: str = "ones", + ): + """Calculate the loss given the model prediction, data sample, and time. + + Args: + model_pred (Tensor): The predicted output from the model. + target (Tensor): The target output for the model prediction. + t (Tensor): The time at which the loss is calculated. + mask (Optional[Tensor], optional): The mask for the data point. Defaults to None. + weight_type (str, optional): The type of weight to use for the loss. Defaults to "ones". + + Returns: + Tensor: The calculated loss batch tensor. + """ + raw_loss = self._loss_function(model_pred, target) + update_weight = self.loss_weight(raw_loss, t, weight_type) + loss = raw_loss * update_weight + if mask is not None: + loss = loss * mask.unsqueeze(-1) + n_elem = torch.sum(mask, dim=-1) + loss = torch.sum(loss, dim=tuple(range(1, raw_loss.ndim))) / n_elem + else: + loss = torch.sum(loss, dim=tuple(range(1, raw_loss.ndim))) / model_pred.size(1) + return loss diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/d3pm.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/d3pm.py new file mode 100644 index 0000000000..7e7b8fb43f --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/d3pm.py @@ -0,0 +1,354 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from typing import Optional, Tuple + +import torch +import torch.nn as nn +import torch.nn.functional as F +from jaxtyping import Float +from torch import Tensor + +from bionemo.moco.distributions.prior.distribution import DiscretePriorDistribution +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.interpolants.base_interpolant import Interpolant +from bionemo.moco.interpolants.discrete_time.utils import safe_index +from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteNoiseSchedule + + +class D3PM(Interpolant): + """A Discrete Denoising Diffusion Probabilistic Model (D3PM) interpolant.""" + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: DiscretePriorDistribution, + noise_schedule: DiscreteNoiseSchedule, + device: str = "cpu", + last_time_idx: int = 0, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes the D3PM interpolant. + + Args: + time_distribution (TimeDistribution): The distribution of time steps, used to sample time points for the diffusion process. + prior_distribution (PriorDistribution): The prior distribution of the variable, used as the starting point for the diffusion process. + noise_schedule (DiscreteNoiseSchedule): The schedule of noise, defining the amount of noise added at each time step. + device (str, optional): The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". + last_time_idx (int, optional): The last time index to consider in the interpolation process. Defaults to 0. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(time_distribution, prior_distribution, device, rng_generator) + self.noise_schedule = noise_schedule + self._loss_function = nn.CrossEntropyLoss(reduction="none") + self.timesteps = noise_schedule.nsteps + self.num_classes = prior_distribution.num_classes + self.terminal_distribution = prior_distribution.prior_dist.to(device) + self._initialize_schedules(device) + self.last_time_idx = last_time_idx + + def _get_Qt(self, alphas: Tensor) -> Tensor: + """Calculate the transition matrix Qt based on the terminal distribution. + + The transition matrix Qt represents the probabilities of transitioning from one state to another at a given time step. + It is calculated based on the terminal distribution, which can be either uniform, a mask, or a custom distribution. + See Appendix A.2 D3PM https://arxiv.org/pdf/2107.03006 which shows what happens for various prior distributions. + + The terminal distribution can be: + - Uniform: a uniform distribution over all states. + - Mask: a mask where the last dimension is 1 and the rest are 0. + - Custom: a custom distribution provided by the user. + + Args: + alphas (Tensor): A tensor of probabilities, where each alpha represents the probability of staying in a state at a given time step. + + Returns: + Tensor: The transition matrix Qt. + """ + QT = [] + for alpha_t in alphas: + stay_prob = torch.eye(len(self.terminal_distribution), device=self.device) * alpha_t + diffuse_prob = (1.0 - alpha_t) * ( + torch.ones(1, len(self.terminal_distribution), device=self.device) + * (self.terminal_distribution.unsqueeze(0)) + ) + QT.append(stay_prob + diffuse_prob) + return torch.stack(QT, dim=0) + + def _calculate_transition_matrix(self, alphas: Tensor) -> Tuple[Tensor, Tensor, Tensor]: + """Calculates the rate transition matrix `Qt`, its cumulative variant `Qt_bar`, and the cumulative variant of the previous time step `Qt_bar_prev`. + + Args: + alphas (Tensor): A tensor of probabilities, where each alpha represents the probability of staying in a state at a given time step. + + Returns: + Tuple[Tensor, Tensor, Tensor]: A tuple containing the rate transition matrix `Qt`, its cumulative variant `Qt_bar`, and the cumulative variant of the previous time step `Qt_bar_prev`. + """ + Qt = self._get_Qt(alphas) + Qt_prev = torch.eye(self.num_classes, device=self.device) + Qt_bar = [] + for i in range(len(alphas)): + Qtb = Qt_prev @ Qt[i] + Qt_bar.append(Qtb) + Qt_prev = Qtb + Qt_bar = torch.stack(Qt_bar) + Qt_bar_prev = Qt_bar[:-1] + Qt_prev_pad = torch.eye(self.num_classes, device=self.device) + Qt_bar_prev = torch.concat([Qt_prev_pad.unsqueeze(0), Qt_bar_prev], dim=0) + return Qt, Qt_bar, Qt_bar_prev + + def _initialize_schedules(self, device): + """Initializes the transition matrices for the discrete diffusion process. + + This method computes the rate transition matrix `Qt` and its cumulative variants `Qt_bar` and `Qt_prev_bar` + based on the provided noise schedule. + + Note: + `Qt` represents the rate transition matrix, where `Qt[t]` is the transition matrix at time step `t`. + `Qt_bar` and `Qt_prev_bar` are the cumulative variants of `Qt`, where `Qt_bar[t]` represents the cumulative + transition matrix from time step `0` to `t`, and `Qt_prev_bar[t]` represents the cumulative transition matrix + from time step `0` to `t-1`. + + Args: + device (str): The device on which to compute the transition matrices. + """ + if self.noise_schedule is None: + raise ValueError("noise_schedule cannot be None for D3PM") + alphas = self.noise_schedule.generate_schedule(device=device) + log_alpha = torch.log(alphas) + log_alpha_bar = torch.cumsum(log_alpha, dim=0) + self._alpha_bar = torch.exp(log_alpha_bar) + #! Note to users that the tranditional cosine schedule is a very quick convergence of alpha. Pay close attention to the scheduler here + Qt, Qt_bar, Qt_prev_bar = self._calculate_transition_matrix(alphas) + self._Qt = Qt[-self.timesteps :] + self._Qt_transposed = self._Qt.transpose(1, 2) + self._Qt_bar = Qt_bar[-self.timesteps :] + self._Qt_prev_bar = Qt_prev_bar[-self.timesteps :] + + def interpolate(self, data: Tensor, t: Tensor): + """Interpolate using discrete interpolation method. + + This method implements Equation 2 from the D3PM paper (https://arxiv.org/pdf/2107.03006), which + calculates the interpolated discrete state `xt` at time `t` given the input data and noise + via q(xt|x0) = Cat(xt; p = x0*Qt_bar). + + Args: + data (Tensor): The input data to be interpolated. + t (Tensor): The time step at which to interpolate. + + Returns: + Tensor: The interpolated discrete state `xt` at time `t`. + """ + if len(data.shape) <= 2: + x1_hot = F.one_hot(data, self.num_classes) + else: + x1_hot = data + ford = safe_index(self._Qt_bar, t - self.last_time_idx, data.device) + probs = torch.einsum("b...j, bji -> b...i", [x1_hot.float(), ford]) + if torch.all((probs.sum(-1) - 1.0).abs() > 1e-4): + raise ValueError("Invalid Probability Distriubtion: distribution must some to 1.0") + xt = self._sample_categorical(torch.log(probs) + 1.0e-6) + return xt + + def forward_process(self, data: Tensor, t: Tensor) -> Tensor: + """Apply the forward process to the data at time t. + + Args: + data (Tensor): target discrete ids + t (Tensor): time + + Returns: + Tensor: x(t) after applying the forward process + """ + return self.interpolate(data, t) + + def _sample_categorical(self, logits, mask: Optional[Tensor] = None, temperature: Float = 1.0) -> Tensor: + """Sample a categorical distribution using the Gumbel-Softmax trick. + + This method samples a categorical distribution from the given logits, + optionally applying a mask and using a specified temperature. + + Args: + logits (Tensor): The logits of the categorical distribution. + mask (Optional[Tensor], optional): An optional mask to apply to the noise added to logits. Defaults to None. + temperature (float, optional): The temperature to use for the Gumbel-Softmax trick. Defaults to 1.0. + + Returns: + Tensor: A sample from the categorical distribution. + """ + noise = torch.rand_like(logits) + noise = torch.clip(noise, 1.0e-6, 1.0) + gumbel_noise = -torch.log(-torch.log(noise)) + if mask is not None: + sample = torch.argmax((logits / temperature) + gumbel_noise * mask, dim=-1) + else: + sample = torch.argmax((logits / temperature) + gumbel_noise, dim=-1) + return sample + + def _q_posterior_logits( + self, model_out: Tensor, t: Tensor, xt: Tensor, model_out_is_logits: bool = True + ) -> Tensor: + """Calculate the q-posterior logits using the predicted x0 and the current state xt at time t. + + This method implements Equation 3 from the D3PM paper (https://arxiv.org/pdf/2107.03006), which calculates the q-posterior + distribution over the previous state x0 given the current state xt and the model output. + + Args: + model_out (Tensor): The output of the model at the current time step. + t (Tensor): The current time step. + xt (Tensor): The current discrete state at time t. + model_out_is_logits (bool, optional): A flag indicating whether the model output is already in logits form. If True, the output is assumed to be logits; otherwise, it is converted to logits. Defaults to True. + + Returns: + Tensor: The q-posterior logits. + """ + if not model_out_is_logits: # model_out.dtype == torch.int64 or model_out.dtype == torch.int32: + # Convert model output to logits if it's a categorical distribution + x0_logits = torch.log(torch.nn.functional.one_hot(model_out, self.num_classes).float() + 1.0e-6) + else: + # Otherwise, assume model output is already logits + x0_logits = model_out.clone() + + # Calculate xt_guess: the predicted probability of xt given x0 and t + xt_guess = torch.einsum( + "b...j, bji -> b...i", + [ + torch.nn.functional.one_hot(xt, self.num_classes).float(), + safe_index(self._Qt_transposed, t - self.last_time_idx, model_out.device), + ], + ) + + # Calculate softmaxed x0_logits + softmaxed = torch.softmax(x0_logits, dim=-1) # bs, ..., num_classes + + # Calculate x0_guess: the predicted probability of x0 given xt and t-1 + x0_guess = torch.einsum( + "b...c,bcd->b...d", + softmaxed, + safe_index(self._Qt_prev_bar, t - self.last_time_idx, model_out.device), + ) + + # Calculate q-posterior logits + out = torch.log(xt_guess + 1.0e-6) + torch.log(x0_guess + 1.0e-6) + t_broadcast = t.reshape((t.shape[0], *[1] * (xt.dim()))) + q_posterior_logits = torch.where(t_broadcast == self.last_time_idx, x0_logits, out) + return q_posterior_logits + + def step( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + temperature: Float = 1.0, + model_out_is_logits: bool = True, + ): + """Perform a single step in the discrete interpolant method, transitioning from the current discrete state `xt` at time `t` to the next state. + + This step involves: + + 1. Computing the predicted q-posterior logits using the model output `model_out` and the current state `xt` at time `t`. + 2. Sampling the next state from the predicted q-posterior distribution using the Gumbel-Softmax trick. + + Args: + model_out (Tensor): The output of the model at the current time step, which is used to compute the predicted q-posterior logits. + t (Tensor): The current time step, which is used to index into the transition matrices and compute the predicted q-posterior logits. + xt (Tensor): The current discrete state at time `t`, which is used to compute the predicted q-posterior logits and sample the next state. + mask (Optional[Tensor], optional): An optional mask to apply to the next state, which can be used to mask out certain tokens or regions. Defaults to None. + temperature (Float, optional): The temperature to use for the Gumbel-Softmax trick, which controls the randomness of the sampling process. Defaults to 1.0. + model_out_is_logits (bool, optional): A flag indicating whether the model output is already in logits form. If True, the output is assumed to be logits; otherwise, it is converted to logits. Defaults to True. + + Returns: + Tensor: The next discrete state at time `t-1`. + """ + pred_q_posterior_logits = self._q_posterior_logits(model_out, t, xt, model_out_is_logits) + nonzero_mask = (t != self.last_time_idx).to(xt.dtype).reshape(xt.shape[0], *([1] * (len(xt.shape)))) + x_next = self._sample_categorical(pred_q_posterior_logits, nonzero_mask, temperature=temperature) + # # Apply mask if provided + if mask is not None: + x_next = x_next * mask + return x_next + + def loss( + self, + logits: Tensor, + target: Tensor, + xt: Tensor, + time: Tensor, + mask: Optional[Tensor] = None, + vb_scale: Float = 0.0, + ): + """Calculate the cross-entropy loss between the model prediction and the target output. + + The loss is calculated between the batch x node x class logits and the target batch x node. If a mask is provided, the loss is + calculated only for the non-masked elements. Additionally, if vb_scale is greater than 0, the variational lower bound loss is + calculated and added to the total loss. + + Args: + logits (Tensor): The predicted output from the model, with shape batch x node x class. + target (Tensor): The target output for the model prediction, with shape batch x node. + xt (Tensor): The current data point. + time (Tensor): The time at which the loss is calculated. + mask (Optional[Tensor], optional): The mask for the data point. Defaults to None. + vb_scale (Float, optional): The scale factor for the variational lower bound loss. Defaults to 0.0. + + Returns: + Tensor: The calculated loss tensor. If aggregate is True, the loss and variational lower bound loss are aggregated and + returned as a single tensor. Otherwise, the loss and variational lower bound loss are returned as separate tensors. + """ + assert target.ndim + 1 == logits.ndim + loss = self._loss_function(logits.transpose(-1, 1), target.long()) + if mask is not None: + loss = loss * mask + num_non_masked_elements = torch.sum(mask, dim=-1) + loss = torch.sum(loss, dim=(-1)) / num_non_masked_elements + else: + loss = torch.sum(loss, dim=(-1)) / logits.size(1) + if vb_scale > 0: + target = F.one_hot(target, num_classes=self.num_classes).float() + true_q_posterior_logits = self._q_posterior_logits(target, time, xt) + pred_q_posterior_logits = self._q_posterior_logits(logits, time, xt) + vb_loss = self._variational_lower_bound(true_q_posterior_logits, pred_q_posterior_logits) + vb_loss = vb_scale * vb_loss + else: + vb_loss = 0 + if vb_scale > 0: + loss += vb_loss + return loss + + def _variational_lower_bound(self, dist1: Tensor, dist2: Tensor) -> Tensor: + """Calculate the variational lower bound (VLB) between two distributions. + + The VLB measures the difference between the true and approximate posterior distributions. + It is used to regularize the model and encourage it to produce more accurate predictions. + + Args: + dist1 (Tensor): The true posterior distribution. + dist2 (Tensor): The approximate posterior distribution. + + Returns: + Tensor: The variational lower bound loss. + """ + # Flatten dist1 and dist2 to simplify calculations + dist1 = dist1.flatten(start_dim=0, end_dim=-2) + dist2 = dist2.flatten(start_dim=0, end_dim=-2) + + # Calculate the VLB + out = torch.softmax(dist1 + 1.0e-6, dim=-1) * ( + torch.log_softmax(dist1 + 1.0e-6, dim=-1) - torch.log_softmax(dist2 + 1.0e-6, dim=-1) + ) + # Return the mean of the VLB across all elements + return out.sum(dim=-1).mean() diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/utils.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/utils.py new file mode 100644 index 0000000000..12be71a573 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/utils.py @@ -0,0 +1,43 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import torch +from torch import Tensor + + +def safe_index(tensor: Tensor, index: Tensor, device: torch.device): + """Safely indexes a tensor using a given index and returns the result on a specified device. + + Note can implement forcing with return tensor[index.to(tensor.device)].to(device) but has costly migration. + + Args: + tensor (Tensor): The tensor to be indexed. + index (Tensor): The index to use for indexing the tensor. + device (torch.device): The device on which the result should be returned. + + Returns: + Tensor: The indexed tensor on the specified device. + + Raises: + ValueError: If tensor, index, and device are not all on the same device. + """ + if not (tensor.device == index.device == device): + raise ValueError( + f"Tensor, index, and device must all be on the same device. " + f"Got tensor.device={tensor.device}, index.device={index.device}, and device={device}." + ) + + return tensor[index] diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/discrete_noise_schedules.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/discrete_noise_schedules.py new file mode 100644 index 0000000000..6775997cbd --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/discrete_noise_schedules.py @@ -0,0 +1,157 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from abc import ABC, abstractmethod +from typing import Optional, Union + +import torch +from jaxtyping import Float +from torch import Tensor + +from bionemo.moco.interpolants.base_interpolant import string_to_enum +from bionemo.moco.schedules.utils import TimeDirection + + +class DiscreteNoiseSchedule(ABC): + """A base class for discrete schedules. No matter the definition this class returns objects using a unified direction of time.""" + + def __init__(self, nsteps: int, direction: TimeDirection): + """Initialize the DiscreteNoiseSchedule. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + direction (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + + """ + self.nsteps = nsteps + self.direction = string_to_enum(direction, TimeDirection) + + def generate_schedule( + self, + nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None, + ) -> Tensor: + """Public wrapper to generate the time schedule as a tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + synchronize (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + + Returns: + Tensor: A tensor of time steps + 1 unless full is False. + """ + schedule = self._generate_schedule(nsteps, device) + if synchronize is None: + return schedule + synchronize = string_to_enum(synchronize, TimeDirection) + if self.direction != synchronize: + return torch.flip(schedule, dims=[0]) + return schedule + + @abstractmethod + def _generate_schedule(self, nsteps: Optional[int] = None, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generate the time schedule as a list. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor of time steps + 1 unless full is False. + """ + pass + + def calculate_derivative( + self, + nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None, + ) -> Tensor: + """Calculate the time derivative of the schedule. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + synchronize (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + + Returns: + Tensor: A tensor representing the time derivative of the schedule. + + Raises: + NotImplementedError: If the derivative calculation is not implemented for this schedule. + """ + raise NotImplementedError("Derivative calculation is not implemented for this schedule.") + + +class DiscreteCosineNoiseSchedule(DiscreteNoiseSchedule): + """A cosine noise schedule for Diffusion Models.""" + + def __init__(self, nsteps: int, nu: Float = 1.0, s: Float = 0.008): + """Initialize the CosineNoiseSchedule. + + Args: + nsteps (int): Number of time steps. + nu (Optional[Float]): Hyperparameter for the cosine schedule (default is 1.0). + s (Optional[Float]): Hyperparameter for the cosine schedule (default is 0.008). + """ + super().__init__(nsteps=nsteps, direction=TimeDirection.DIFFUSION) + self.nu = nu + self.s = s + + def _generate_schedule(self, nsteps: Optional[int] = None, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generate the cosine noise schedule. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor of time steps + 1 unless full is False. + """ + if nsteps is None: + nsteps = self.nsteps + steps = nsteps + 2 + x = torch.linspace(0, steps, steps, device=device) + alphas_cumprod = torch.cos(0.5 * torch.pi * (((x / steps) ** self.nu) + self.s) / (1 + self.s)) ** 2 + alphas_cumprod_new = alphas_cumprod / alphas_cumprod[0] + alphas_cumprod_new = self._clip_noise_schedule(alphas_cumprod_new, clip_value=0.05) + alphas = alphas_cumprod_new[1:] / alphas_cumprod_new[:-1] + alphas = torch.clamp(alphas, min=0.001) + betas = 1 - alphas + betas = torch.clamp(betas, 0.0, 0.999) + result = 1.0 - betas + return result[1:] + + def _clip_noise_schedule(self, alphas2: Tensor, clip_value: Float = 0.001) -> Tensor: + """For a noise schedule given by alpha^2, this clips alpha_t / alpha_t-1. This may help improve stability during sampling. + + Args: + alphas2 (Tensor): The noise schedule given by alpha^2. + clip_value (Optional[Float]): The minimum value for alpha_t / alpha_t-1 (default is 0.001). + + Returns: + Tensor: The clipped noise schedule. + """ + alphas2 = torch.cat([torch.ones(1, device=alphas2.device), alphas2], dim=0) + + alphas_step = alphas2[1:] / alphas2[:-1] + + alphas_step = torch.clamp(alphas_step, min=clip_value, max=1.0) + alphas2 = torch.cumprod(alphas_step, dim=0) + + return alphas2 diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/inference_time_schedules.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/inference_time_schedules.py new file mode 100644 index 0000000000..2c2d621bfa --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/inference_time_schedules.py @@ -0,0 +1,421 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from abc import ABC, abstractmethod +from typing import Optional, Union + +import torch +from jaxtyping import Float +from torch import Tensor + +from bionemo.moco.interpolants.base_interpolant import string_to_enum +from bionemo.moco.schedules.utils import TimeDirection + + +class InferenceSchedule(ABC): + """A base class for inference time schedules.""" + + def __init__( + self, + nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu", + ): + """Initialize the InferenceSchedule. + + Args: + nsteps (int): Number of time steps. + min_t (Float): minimum time value defaults to 0. + padding (Float): padding time value defaults to 0. + dilation (Float): dilation time value defaults to 0 ie the number of replicates. + direction (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + """ + self.nsteps = nsteps + self.min_t = min_t + self.padding = padding + self.dilation = dilation + self.direction = string_to_enum(direction, TimeDirection) + self.device = device + + @abstractmethod + def generate_schedule( + self, nsteps: Optional[int] = None, device: Optional[Union[str, torch.device]] = None + ) -> Tensor: + """Generate the time schedule as a tensor. + + Args: + nsteps (Optioanl[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + pass + + def pad_time( + self, n_samples: int, scalar_time: Float, device: Optional[Union[str, torch.device]] = None + ) -> Tensor: + """Creates a tensor of shape (n_samples,) filled with a scalar time value. + + Args: + n_samples (int): The desired dimension of the output tensor. + scalar_time (Float): The scalar time value to fill the tensor with. + device (Optional[Union[str, torch.device]], optional): + The device to place the tensor on. Defaults to None, which uses the default device. + + Returns: + Tensor: A tensor of shape (n_samples,) filled with the scalar time value. + """ + return torch.full((n_samples,), fill_value=scalar_time).to(device) + + +class ContinuousInferenceSchedule(InferenceSchedule): + """A base class for continuous time inference schedules.""" + + def discretize( + self, + nsteps: Optional[int] = None, + schedule: Optional[Tensor] = None, + device: Optional[Union[str, torch.device]] = None, + ) -> Tensor: + """Discretize the time schedule into a list of time deltas. + + Args: + nsteps (Optioanl[int]): Number of time steps. If None, uses the value from initialization. + schedule (Optional[Tensor]): Time scheudle if None will generate it with generate_schedule. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor of time deltas. + """ + if device is None: + device = self.device + if schedule is None: + schedule = self.generate_schedule(nsteps, device=device) + if self.direction == TimeDirection.UNIFIED: + schedule = torch.cat((schedule, torch.ones((1,), device=schedule.device))) + dt = schedule[1:] - schedule[:-1] + else: + schedule = torch.cat((schedule, torch.zeros((1,), device=schedule.device))) + dt = -1 * (schedule[1:] - schedule[:-1]) + return dt + + +class DiscreteInferenceSchedule(InferenceSchedule): + """A base class for discrete time inference schedules.""" + + def discretize( + self, + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + ) -> Tensor: + """Discretize the time schedule into a list of time deltas. + + Args: + nsteps (Optioanl[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor of time deltas. + """ + if self.padding > 0 or self.dilation > 0: + raise NotImplementedError("discreteize is not implemented for discrete schedules with padding or dilation") + if device is None: + device = self.device + return torch.full( + (nsteps if nsteps is not None else self.nsteps,), + 1 / (nsteps if nsteps is not None else self.nsteps), + device=device, + ) + + +class DiscreteLinearInferenceSchedule(DiscreteInferenceSchedule): + """A linear time schedule for discrete time inference.""" + + def __init__( + self, + nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu", + ): + """Initialize the DiscreteLinearInferenceSchedule. + + Args: + nsteps (int): Number of time steps. + min_t (Float): minimum time value defaults to 0. + padding (Float): padding time value defaults to 0. + dilation (Float): dilation time value defaults to 0 ie the number of replicates. + direction (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + super().__init__(nsteps, min_t, padding, dilation, direction, device) + + def generate_schedule( + self, nsteps: Optional[int] = None, device: Optional[Union[str, torch.device]] = None + ) -> Tensor: + """Generate the linear time schedule as a tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor of time steps. + Tensor: A tensor of time steps. + """ + if device is None: + device = self.device + if nsteps is None: + nsteps = self.nsteps + nsteps -= self.padding + dilation = self.dilation + 1 + if dilation > 1: + if nsteps % dilation != 0: + raise ValueError(f"nsteps ({nsteps}) is not divisible by dilation + 1 ({dilation})") + nsteps = int(nsteps / self.dilation) + if nsteps is None: + raise ValueError("nsteps cannot be None") + schedule = torch.arange(nsteps).to(device=device) + if dilation > 1: + schedule = schedule.repeat_interleave(dilation) + if self.direction == TimeDirection.DIFFUSION: + schedule = schedule.flip(0) + if self.padding > 0: + schedule = torch.cat((schedule, schedule[-1] * torch.ones(self.padding, device=device))) + return schedule + + +class LinearInferenceSchedule(ContinuousInferenceSchedule): + """A linear time schedule for continuous time inference.""" + + def __init__( + self, + nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu", + ): + """Initialize the LinearInferenceSchedule. + + Args: + nsteps (int): Number of time steps. + min_t (Float): minimum time value defaults to 0. + padding (Float): padding time value defaults to 0. + dilation (Float): dilation time value defaults to 0 ie the number of replicates. + direction (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + super().__init__(nsteps, min_t, padding, dilation, direction, device) + + def generate_schedule( + self, + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + ) -> Tensor: + """Generate the linear time schedule as a tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor of time steps. + Tensor: A tensor of time steps. + """ + if device is None: + device = self.device + if nsteps is None: + nsteps = self.nsteps + nsteps -= self.padding + dilation = self.dilation + 1 + if dilation > 1: + if nsteps % dilation != 0: + raise ValueError(f"nsteps ({nsteps}) is not divisible by dilation + 1 ({dilation})") + nsteps = int(nsteps / dilation) + if nsteps is None: + raise ValueError("nsteps cannot be None") + schedule = torch.linspace(0, 1, nsteps + 1).to(device=device) + + if self.min_t > 0: + schedule = torch.clamp(schedule, min=self.min_t) + + schedule = schedule[:-1] + if dilation > 1: + schedule = schedule.repeat_interleave(dilation) + if self.padding > 0: + schedule = torch.cat((schedule, torch.ones(self.padding, device=device))) + if self.direction == TimeDirection.DIFFUSION: + schedule = 1 - schedule # schedule.flip(0) + return schedule + + +class PowerInferenceSchedule(ContinuousInferenceSchedule): + """A power time schedule for inference, where time steps are generated by raising a uniform schedule to a specified power.""" + + def __init__( + self, + nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + exponent: Float = 1.0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu", + ): + """Initialize the PowerInferenceSchedule. + + Args: + nsteps (int): Number of time steps. + min_t (Float): minimum time value defaults to 0. + padding (Float): padding time value defaults to 0. + dilation (Float): dilation time value defaults to 0 ie the number of replicates. + exponent (Float): Power parameter defaults to 1.0. + direction (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + super().__init__(nsteps, min_t, padding, dilation, direction, device) + self.exponent = exponent + + def generate_schedule( + self, + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + ) -> Tensor: + """Generate the power time schedule as a tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor of time steps. + Tensor: A tensor of time steps. + """ + if device is None: + device = self.device + if nsteps is None: + nsteps = self.nsteps + nsteps -= self.padding + dilation = self.dilation + 1 + if dilation > 1: + if nsteps % dilation != 0: + raise ValueError(f"nsteps ({nsteps}) is not divisible by dilation + 1 ({dilation})") + nsteps = int(nsteps / dilation) + if nsteps is None: + raise ValueError("nsteps cannot be None") + schedule = torch.linspace(0, 1, nsteps + 1).to(device=device) ** self.exponent + if self.min_t > 0: + schedule = torch.clamp(schedule, min=self.min_t) + schedule = schedule[:-1] + if dilation > 1: + schedule = schedule.repeat_interleave(dilation) + if self.padding > 0: + schedule = torch.cat((schedule, torch.ones(self.padding, device=device))) + if self.direction == TimeDirection.DIFFUSION: + schedule = 1 - schedule # schedule.flip(0) + return schedule + + +class LogInferenceSchedule(ContinuousInferenceSchedule): + """A log time schedule for inference, where time steps are generated by taking the logarithm of a uniform schedule.""" + + def __init__( + self, + nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + exponent: Float = -2.0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu", + ): + """Initialize the LogInferenceSchedule. + + Returns a log space time schedule. + + Which for 100 steps with default parameters is: + tensor([0.0000, 0.0455, 0.0889, 0.1303, 0.1699, 0.2077, 0.2439, 0.2783, 0.3113, + 0.3427, 0.3728, 0.4015, 0.4288, 0.4550, 0.4800, 0.5039, 0.5266, 0.5484, + 0.5692, 0.5890, 0.6080, 0.6261, 0.6434, 0.6599, 0.6756, 0.6907, 0.7051, + 0.7188, 0.7319, 0.7444, 0.7564, 0.7678, 0.7787, 0.7891, 0.7991, 0.8086, + 0.8176, 0.8263, 0.8346, 0.8425, 0.8500, 0.8572, 0.8641, 0.8707, 0.8769, + 0.8829, 0.8887, 0.8941, 0.8993, 0.9043, 0.9091, 0.9136, 0.9180, 0.9221, + 0.9261, 0.9299, 0.9335, 0.9369, 0.9402, 0.9434, 0.9464, 0.9492, 0.9520, + 0.9546, 0.9571, 0.9595, 0.9618, 0.9639, 0.9660, 0.9680, 0.9699, 0.9717, + 0.9734, 0.9751, 0.9767, 0.9782, 0.9796, 0.9810, 0.9823, 0.9835, 0.9847, + 0.9859, 0.9870, 0.9880, 0.9890, 0.9899, 0.9909, 0.9917, 0.9925, 0.9933, + 0.9941, 0.9948, 0.9955, 0.9962, 0.9968, 0.9974, 0.9980, 0.9985, 0.9990, + 0.9995]) + + Args: + nsteps (int): Number of time steps. + min_t (Float): minimum time value defaults to 0. + padding (Float): padding time value defaults to 0. + dilation (Float): dilation time value defaults to 0 ie the number of replicates. + exponent (Float): log space exponent parameter defaults to -2.0. The lower number the more aggressive the acceleration of 0 to 0.9 will be thus having more steps from 0.9 to 1.0. + direction (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + super().__init__(nsteps, min_t, padding, dilation, direction, device) + if exponent is None: + raise ValueError("exponent cannot be None for the log schedule") + if exponent >= 0: + raise ValueError(f"exponent input must be <0, got {exponent}") + self.exponent = exponent + + def generate_schedule( + self, + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + ) -> Tensor: + """Generate the log time schedule as a tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + if device is None: + device = self.device + if nsteps is None: + nsteps = self.nsteps + nsteps -= self.padding + dilation = self.dilation + 1 + if dilation > 1: + if nsteps % dilation != 0: + raise ValueError(f"nsteps ({nsteps}) is not divisible by dilation + 1 ({dilation})") + nsteps = int(nsteps / self.dilation) + if nsteps is None: + raise ValueError("nsteps cannot be None") + t = 1.0 - torch.logspace(self.exponent, 0, nsteps + 1).flip(0).to(device=device) + t = t - torch.min(t) + schedule = t / torch.max(t) + if self.min_t > 0: + schedule = torch.clamp(schedule, min=self.min_t) + schedule = schedule[:-1] + if dilation > 1: + schedule = schedule.repeat_interleave(dilation) + if self.padding > 0: + schedule = torch.cat((schedule, torch.ones(self.padding, device=device))) + if self.direction == TimeDirection.DIFFUSION: + schedule = 1 - schedule + return schedule diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_noise_transforms.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_noise_transforms.py new file mode 100644 index 0000000000..d40320e722 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_noise_transforms.py @@ -0,0 +1,182 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from abc import ABC, abstractmethod +from typing import Optional, Union + +import torch +from jaxtyping import Float +from torch import Tensor + +from bionemo.moco.interpolants.base_interpolant import string_to_enum +from bionemo.moco.schedules.utils import TimeDirection + + +class ContinuousExpNoiseTransform(ABC): + """A base class for continuous schedules. + + alpha = exp(- sigma) where 1 - alpha controls the masking fraction. + """ + + def __init__(self, direction: TimeDirection): + """Initialize the DiscreteNoiseSchedule. + + Args: + direction : TimeDirection, required this defines in which direction the scheduler was built + """ + self.direction = string_to_enum(direction, TimeDirection) + + def calculate_sigma( + self, + t: Tensor, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None, + ) -> Tensor: + """Calculate the sigma for the given time steps. + + Args: + t (Tensor): The input tensor representing the time steps, with values ranging from 0 to 1. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + synchronize (optional[TimeDirection]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one. Defaults to None. + + Returns: + Tensor: A tensor representing the sigma values for the given time steps. + + Raises: + ValueError: If the input time steps exceed the maximum allowed value of 1. + """ + if t.max() > 1: + raise ValueError(f"Invalid value: max continuous time is 1, but got {t.max().item()}") + + if synchronize and self.direction != string_to_enum(synchronize, TimeDirection): + t = 1 - t + return self._calculate_sigma(t, device) + + @abstractmethod + def _calculate_sigma(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Calculate the -log of the clean data value for the given time steps. + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the sigma values for the given time steps. + """ + pass + + def sigma_to_alpha(self, sigma: Tensor) -> Tensor: + """Converts sigma to alpha values by alpha = exp(- sigma). + + Args: + sigma (Tensor): The input sigma tensor. + + Returns: + Tensor: A tensor containing the alpha values. + """ + return torch.exp(-1 * sigma) + + +class CosineExpNoiseTransform(ContinuousExpNoiseTransform): + """A cosine Exponential noise schedule.""" + + def __init__(self, eps: Float = 1.0e-3): + """Initialize the CosineNoiseSchedule. + + Args: + eps (Float): small number to prevent numerical issues. + """ + self.direction = TimeDirection.DIFFUSION + self.eps = eps + + def _calculate_sigma(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Calculate negative log of data interpolant fraction. + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the sigma values for the given time steps. + """ + cos = torch.cos(t * torch.pi / 2).to(device) + return -torch.log(self.eps + (1 - self.eps) * cos) + + def d_dt_sigma(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Compute the derivative of sigma with respect to time. + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the derivative of sigma with respect to time. + + Notes: + The derivative of sigma as a function of time is given by: + + d/dt sigma(t) = d/dt (-log(cos(t * pi / 2) + eps)) + + Using the chain rule, we get: + + d/dt sigma(t) = (-1 / (cos(t * pi / 2) + eps)) * (-sin(t * pi / 2) * pi / 2) + + This is the derivative that is computed and returned by this method. + """ + cos = (1 - self.eps) * torch.cos(t * torch.pi / 2) + sin = (1 - self.eps) * torch.sin(t * torch.pi / 2) + scale = torch.pi / 2 + derivative = scale * sin / (cos + self.eps) + return derivative.to(device) + + +class LogLinearExpNoiseTransform(ContinuousExpNoiseTransform): + """A log linear exponential schedule.""" + + def __init__(self, eps: Float = 1.0e-3): + """Initialize the CosineNoiseSchedule. + + Args: + eps (Float): small value to prevent numerical issues. + """ + self.direction = TimeDirection.DIFFUSION + self.eps = eps + + def _calculate_sigma(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Calculate negative log of data interpolant fraction. + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the sigma values for the given time steps. + """ + return -torch.log1p(-(1 - self.eps) * t).to(device) + + def d_dt_sigma(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Compute the derivative of sigma with respect to time. + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the derivative of sigma with respect to time. + """ + derivative = (1 - self.eps) / (1 - (1 - self.eps) * t) + return derivative.to(device) diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_snr_transforms.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_snr_transforms.py new file mode 100644 index 0000000000..b3b001b5ec --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_snr_transforms.py @@ -0,0 +1,294 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import math +from abc import ABC, abstractmethod +from typing import Callable, Optional, Tuple, Union + +import torch +from jaxtyping import Float +from torch import Tensor + +from bionemo.moco.interpolants.base_interpolant import string_to_enum +from bionemo.moco.schedules.utils import TimeDirection + + +def log(t, eps=1e-20): + """Compute the natural logarithm of a tensor, clamping values to avoid numerical instability. + + Args: + t (Tensor): The input tensor. + eps (float, optional): The minimum value to clamp the input tensor (default is 1e-20). + + Returns: + Tensor: The natural logarithm of the input tensor. + """ + return torch.log(t.clamp(min=eps)) + + +class ContinuousSNRTransform(ABC): + """A base class for continuous SNR schedules.""" + + def __init__(self, direction: TimeDirection): + """Initialize the DiscreteNoiseSchedule. + + Args: + direction (TimeDirection): required this defines in which direction the scheduler was built + """ + self.direction = string_to_enum(direction, TimeDirection) + + def calculate_log_snr( + self, + t: Tensor, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None, + ) -> Tensor: + """Public wrapper to generate the time schedule as a tensor. + + Args: + t (Tensor): The input tensor representing the time steps, with values ranging from 0 to 1. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + synchronize (optional[TimeDirection]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one. Defaults to None. + + Returns: + Tensor: A tensor representing the log signal-to-noise (SNR) ratio for the given time steps. + """ + if t.max() > 1: + raise ValueError(f"Invalid value: max continuous time is 1, but got {t.max().item()}") + + if synchronize and self.direction != string_to_enum(synchronize, TimeDirection): + t = 1 - t + return self._calculate_log_snr(t, device) + + @abstractmethod + def _calculate_log_snr(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generate the log signal-to-noise (SNR) ratio. + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the log SNR values for the given time steps. + """ + pass + + def log_snr_to_alphas_sigmas(self, log_snr: Tensor) -> Tuple[Tensor, Tensor]: + """Converts log signal-to-noise ratio (SNR) to alpha and sigma values. + + Args: + log_snr (Tensor): The input log SNR tensor. + + Returns: + tuple[Tensor, Tensor]: A tuple containing the squared root of alpha and sigma values. + """ + squared_alpha = log_snr.sigmoid() + squared_sigma = (-log_snr).sigmoid() + return squared_alpha.sqrt(), squared_sigma.sqrt() + + def derivative(self, t: Tensor, func: Callable) -> Tensor: + """Compute derivative of a function, it supports bached single variable inputs. + + Args: + t (Tensor): time variable at which derivatives are taken + func (Callable): function for derivative calculation + + Returns: + Tensor: derivative that is detached from the computational graph + """ + with torch.enable_grad(): + t.requires_grad_(True) + derivative = torch.autograd.grad(func(t).sum(), t, create_graph=False)[0].detach() + t.requires_grad_(False) + return derivative + + def calculate_general_sde_terms(self, t): + """Compute the general SDE terms for a given time step t. + + Args: + t (Tensor): The input tensor representing the time step. + + Returns: + tuple[Tensor, Tensor]: A tuple containing the drift term f_t and the diffusion term g_t_2. + + Notes: + This method computes the drift and diffusion terms of the general SDE, which can be used to simulate the stochastic process. + The drift term represents the deterministic part of the process, while the diffusion term represents the stochastic part. + """ + t = t.clone() + t.requires_grad_(True) + + # Compute log SNR + log_snr = self.calculate_log_snr(t, device=t.device) + + # Alpha^2 and Sigma^2 + alpha_squared = torch.sigmoid(log_snr) + sigma_squared = torch.sigmoid(-log_snr) + + # Log Alpha + log_alpha = 0.5 * torch.log(alpha_squared) + + # Compute derivatives + log_alpha_deriv = torch.autograd.grad(log_alpha.sum(), t, create_graph=False)[0].detach() + sigma_squared_deriv = torch.autograd.grad(sigma_squared.sum(), t, create_graph=False)[0].detach() + + # Compute drift and diffusion terms + f_t = log_alpha_deriv # Drift term + g_t_2 = sigma_squared_deriv - 2 * log_alpha_deriv * sigma_squared # Diffusion term + + return f_t, g_t_2 + + def calculate_beta(self, t): + r"""Compute the drift coefficient for the OU process of the form $dx = -\frac{1}{2} \beta(t) x dt + sqrt(beta(t)) dw_t$. + + beta = d/dt log(alpha**2) = 2 * 1/alpha * d/dt(alpha) + + Args: + t (Union[float, Tensor]): t in [0, 1] + + Returns: + Tensor: beta(t) + """ + t = t.clone() + t.requires_grad_(True) + log_snr = self.calculate_log_snr(t, device=t.device) + alpha = self.calculate_alpha_log_snr(log_snr).detach() + alpha_deriv_t = self.derivative(t, self.calculate_alpha_t).detach() + beta = 2.0 * alpha_deriv_t / alpha + # Chroma has a negative here but when removing the negative we get f = d/dt log (alpha**2) and the step_ode function works as expected + return beta + + def calculate_alpha_log_snr(self, log_snr: Tensor) -> Tensor: + """Compute alpha values based on the log SNR. + + Args: + log_snr (Tensor): The input tensor representing the log signal-to-noise ratio. + + Returns: + Tensor: A tensor representing the alpha values for the given log SNR. + + Notes: + This method computes alpha values as the square root of the sigmoid of the log SNR. + """ + return torch.sigmoid(log_snr).sqrt() + + def calculate_alpha_t(self, t: Tensor) -> Tensor: + """Compute alpha values based on the log SNR schedule. + + Parameters: + t (Tensor): The input tensor representing the time steps. + + Returns: + Tensor: A tensor representing the alpha values for the given time steps. + + Notes: + This method computes alpha values as the square root of the sigmoid of the log SNR. + """ + log_snr = self.calculate_log_snr(t, device=t.device) + alpha = torch.sigmoid(log_snr).sqrt() + return alpha + + +class CosineSNRTransform(ContinuousSNRTransform): + """A cosine SNR schedule. + + Args: + nu (Optional[Float]): Hyperparameter for the cosine schedule exponent (default is 1.0). + s (Optional[Float]): Hyperparameter for the cosine schedule shift (default is 0.008). + """ + + def __init__(self, nu: Float = 1.0, s: Float = 0.008): + """Initialize the CosineNoiseSchedule.""" + self.direction = TimeDirection.DIFFUSION + self.nu = nu + self.s = s + + def _calculate_log_snr(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Calculate the log signal-to-noise ratio (SNR) for the cosine noise schedule i.e. -gamma. + + The SNR is the equivalent to alpha_bar**2 / (1 - alpha_bar**2) from DDPM. + This method computes the log SNR as described in the paper "Improved Denoising Diffusion Probabilistic Models" (https://arxiv.org/pdf/2107.00630). + Note 1 / (1 + exp(- log_snr)) returns this cosine**2 for alpha_bar**2 + See https://openreview.net/attachment?id=2LdBqxc1Yv&name=supplementary_material and https://github.com/lucidrains/denoising-diffusion-pytorch/blob/main/denoising_diffusion_pytorch/continuous_time_gaussian_diffusion.py + + Args: + t (Tensor): The input tensor representing the time steps. + device (str): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor representing the log SNR for the given time steps. + """ + return -log((torch.cos((t**self.nu + self.s) / (1 + self.s) * math.pi * 0.5) ** -2) - 1, eps=1e-5).to(device) + + +class LinearSNRTransform(ContinuousSNRTransform): + """A Linear SNR schedule.""" + + def __init__(self, min_value: Float = 1.0e-4): + """Initialize the Linear SNR Transform. + + Args: + min_value (Float): min vaue of SNR defaults to 1.e-4. + """ + self.direction = TimeDirection.DIFFUSION + self.min_value = min_value + + def _calculate_log_snr(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Calculate the log signal-to-noise ratio (SNR) for the cosine noise schedule i.e. -gamma. + + The SNR is the equivalent to alpha_bar**2 / (1 - alpha_bar**2) from DDPM. + See https://openreview.net/attachment?id=2LdBqxc1Yv&name=supplementary_material and https://github.com/lucidrains/denoising-diffusion-pytorch/blob/main/denoising_diffusion_pytorch/continuous_time_gaussian_diffusion.py + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the log SNR for the given time steps. + """ + # This is equivalanet to the interpolated one from -10 to 9.2 + return -log(torch.expm1(self.min_value + 10 * (t**2))).to(device) + + +class LinearLogInterpolatedSNRTransform(ContinuousSNRTransform): + """A Linear Log space interpolated SNR schedule.""" + + def __init__(self, min_value: Float = -7.0, max_value=13.5): + """Initialize the Linear log space interpolated SNR Schedule from Chroma. + + Args: + min_value (Float): The min log SNR value. + max_value (Float): the max log SNR value. + """ + self.direction = TimeDirection.DIFFUSION + self.min_value = min_value + self.max_value = max_value + + def _calculate_log_snr(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Calculate the log signal-to-noise ratio (SNR) for the cosine noise schedule i.e. -gamma. + + See https://github.com/generatebio/chroma/blob/929407c605013613941803c6113adefdccaad679/chroma/layers/structure/diffusion.py#L316C23-L316C50 + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the log SNR for the given time steps. + """ + log_snr = (1 - t) * self.max_value + t * self.min_value + return log_snr.to(device) diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/discrete_noise_schedules.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/discrete_noise_schedules.py new file mode 100644 index 0000000000..bc8cfc2cd8 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/discrete_noise_schedules.py @@ -0,0 +1,173 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from abc import ABC, abstractmethod +from typing import Optional, Union + +import torch +from jaxtyping import Float +from torch import Tensor + +from bionemo.moco.interpolants.base_interpolant import string_to_enum +from bionemo.moco.schedules.utils import TimeDirection + + +class DiscreteNoiseSchedule(ABC): + """A base class for discrete noise schedules.""" + + def __init__(self, nsteps: int, direction: TimeDirection): + """Initialize the DiscreteNoiseSchedule. + + Args: + nsteps (int): number of discrete steps. + direction (TimeDirection): required this defines in which direction the scheduler was built + """ + self.nsteps = nsteps + self.direction = string_to_enum(direction, TimeDirection) + + def generate_schedule( + self, + nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None, + ) -> Tensor: + """Generate the noise schedule as a tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + synchronize (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one (default is None). + """ + schedule = self._generate_schedule(nsteps, device) + if synchronize and self.direction != string_to_enum(synchronize, TimeDirection): + return torch.flip(schedule, dims=[0]) + else: + return schedule + + @abstractmethod + def _generate_schedule(self, nsteps: Optional[int] = None, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generate the noise schedule tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + pass + + def calculate_derivative( + self, + nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None, + ) -> Tensor: + """Calculate the time derivative of the schedule. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + synchronize (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one (default is None). + + Returns: + Tensor: A tensor representing the time derivative of the schedule. + + Raises: + NotImplementedError: If the derivative calculation is not implemented for this schedule. + """ + raise NotImplementedError("Derivative calculation is not implemented for this schedule.") + + +class DiscreteCosineNoiseSchedule(DiscreteNoiseSchedule): + """A cosine discrete noise schedule.""" + + def __init__(self, nsteps: int, nu: Float = 1.0, s: Float = 0.008): + """Initialize the CosineNoiseSchedule. + + Args: + nsteps (int): Number of discrete steps. + nu (Optional[Float]): Hyperparameter for the cosine schedule exponent (default is 1.0). + s (Optional[Float]): Hyperparameter for the cosine schedule shift (default is 0.008). + """ + super().__init__(nsteps=nsteps, direction=TimeDirection.DIFFUSION) + self.nu = nu + self.s = s + + def _generate_schedule(self, nsteps: Optional[int] = None, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generate the cosine noise schedule. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + if nsteps is None: + nsteps = self.nsteps + steps = ( + nsteps + 1 + ) #! matches OpenAI code https://github.com/openai/improved-diffusion/blob/main/improved_diffusion/gaussian_diffusion.py#L62 + x = torch.linspace(0, nsteps, steps, device=device) + alphas_cumprod = torch.cos(((x / nsteps) ** self.nu + self.s) / (1 + self.s) * torch.pi * 0.5) ** 2 + alphas_cumprod = alphas_cumprod / alphas_cumprod[0] + betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1]) + betas = torch.clip(betas, 0.001, 0.999) + return 1 - betas + + def _clip_noise_schedule(self, alphas2: Tensor, clip_value: Float = 0.001) -> Tensor: + """For a noise schedule given by alpha^2, this clips alpha_t / alpha_t-1. This may help improve stability during sampling. + + Args: + alphas2 (Tensor): The noise schedule given by alpha^2. + clip_value (Optional[Float]): The minimum value for alpha_t / alpha_t-1 (default is 0.001). + + Returns: + Tensor: The clipped noise schedule. + """ + alphas2 = torch.cat([torch.ones(1, device=alphas2.device), alphas2], dim=0) + + alphas_step = alphas2[1:] / alphas2[:-1] + + alphas_step = torch.clamp(alphas_step, min=clip_value, max=1.0) + alphas2 = torch.cumprod(alphas_step, dim=0) + + return alphas2 + + +class DiscreteLinearNoiseSchedule(DiscreteNoiseSchedule): + """A linear discrete noise schedule.""" + + def __init__(self, nsteps: int, beta_start: Float = 1e-4, beta_end: Float = 0.02): + """Initialize the CosineNoiseSchedule. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + beta_start (Optional[int]): starting beta value. Defaults to 1e-4. + beta_end (Optional[int]): end beta value. Defaults to 0.02. + """ + super().__init__(nsteps=nsteps, direction=TimeDirection.DIFFUSION) + self.beta_start = beta_start + self.beta_end = beta_end + + def _generate_schedule(self, nsteps: Optional[int] = None, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generate the cosine noise schedule. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + if nsteps is None: + nsteps = self.nsteps + betas = torch.linspace(self.beta_start, self.beta_end, nsteps, dtype=torch.float32, device=device) + return 1 - betas diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/utils.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/utils.py new file mode 100644 index 0000000000..e6bd485c16 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/utils.py @@ -0,0 +1,24 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from enum import Enum + + +class TimeDirection(Enum): + """Enum for the direction of the noise schedule.""" + + UNIFIED = "unified" # Noise(0) --> Data(1) + DIFFUSION = "diffusion" # Noise(1) --> Data(0) diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_gaussian.py b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_gaussian.py new file mode 100644 index 0000000000..113aa9e0fb --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_gaussian.py @@ -0,0 +1,73 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import torch + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior + + +def test_gaussian_sampling(): + """ + Test that the GaussianPrior can sample with various shapes.""" + mean, std = 0.5, 2.0 + prior = GaussianPrior(mean, std) + + # Test sampling with various shapes + shapes = [(10,), (10, 20), (10, 20, 3)] + for shape in shapes: + samples = prior.sample(shape) + assert samples.shape == shape + + +def test_gaussian_centering_without_mask(): + """ + Test that the GaussianPrior centers the samples without a mask.""" + mean, std = 0, 1 + prior = GaussianPrior(mean, std, center=True) + shape = (10, 20, 3) + samples = prior.sample(shape) + + # Calculate the mean of the samples along the middle dimension + mask = torch.ones(shape[:-1]).bool() + + # Calculate the mean of the samples along the middle dimension + sample_mean = (samples * mask.unsqueeze(-1)).sum(dim=1, keepdim=True) / mask.sum(dim=1, keepdim=True).unsqueeze(-1) + + # Assert the sum of sample means is close to zero + assert torch.abs(sample_mean.sum()) < 1e-5 + + +def test_gaussian_centering_with_mask(): + """ + Test that the GaussianPrior centers the samples with a mask.""" + mean, std = 0, 1 + prior = GaussianPrior(mean, std, center=True) + shape = (30, 4, 50) + mask = torch.ones(shape[:-1]).bool() + mask[:, 2:] = False # Mask out the last 2 elements of the middle dimension + + samples = prior.sample(shape, mask=mask) + # Calculate the mean of the samples along the middle dimension + sample_mean = (samples * mask.unsqueeze(-1)).sum(dim=1, keepdim=True) / mask.sum(dim=1, keepdim=True).unsqueeze(-1) + + # Assert the sum of sample means is close to zero + assert torch.abs(sample_mean.sum()) < 1e-5 + + # Calculate the sum of all the masked out samples + masked_out_samples_sum = (samples * (~mask).unsqueeze(-1)).sum() + + # Assert the sum of all the masked out samples is close to zero + assert torch.abs(masked_out_samples_sum) < 1e-12 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_harmonic.py b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_harmonic.py new file mode 100644 index 0000000000..a5cddb6e54 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_harmonic.py @@ -0,0 +1,28 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from bionemo.moco.distributions.prior.continuous.harmonic import LinearHarmonicPrior + + +def test_harmonic_sampling(): + """ + Test that the LinearHarmonicPrior can sample with various shapes.""" + prior = LinearHarmonicPrior(length=20) + # Test sampling with various shapes + shapes = [(10, 20, 10), (10, 20, 3), (10, 40, 3)] + for shape in shapes: + samples = prior.sample(shape) + assert samples.shape == shape diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_custom.py b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_custom.py new file mode 100644 index 0000000000..24c7191291 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_custom.py @@ -0,0 +1,76 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch + +from bionemo.moco.distributions.prior.discrete.custom import DiscreteCustomPrior + + +def test_discrete_custom_prior_init(): + """Test the initialization of the DiscreteCustomPrior class.""" + num_classes = 10 + prior_dist = torch.zeros(num_classes) + prior_dist[-2:] = 0.5 + prior = DiscreteCustomPrior(prior_dist, num_classes) + assert prior.num_classes == num_classes + assert torch.sum(prior.prior_dist).item() - 1.0 < 1e-5 + + +def test_discrete_custom_prior_sample(): + """Test the sample method of the DiscreteCustomPrior class.""" + num_classes = 10 + prior_dist = torch.zeros(num_classes) + prior_dist[-2:] = 0.5 + prior = DiscreteCustomPrior(prior_dist, num_classes) + shape = (10, 5) + samples = prior.sample(shape) + assert samples.shape == shape + assert samples.max() <= num_classes - 1 + assert samples.min() >= 0 + + +def test_discrete_custom_prior_sample_with_mask(): + """Test the sample method of the DiscreteCustomPrior class with a mask.""" + num_classes = 10 + prior_dist = torch.zeros(num_classes) + prior_dist[-2:] = 0.5 + prior = DiscreteCustomPrior(prior_dist, num_classes) + shape = (10, 5) + mask = torch.ones((10,) + (1,) * (len(shape) - 1)) + mask[5:] = 0 + samples = prior.sample(shape, mask=mask) + assert samples.shape == shape + assert samples.max() <= num_classes - 1 + assert samples.min() >= 0 + assert torch.all(samples[5:] == 0) + + +def test_discrete_custom_prior_sample_on_gpu(): + """Test the sample method of the DiscreteCustomPrior class on a GPU.""" + if not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + num_classes = 10 + prior_dist = torch.zeros(num_classes) + prior_dist[-2:] = 0.5 + prior = DiscreteCustomPrior(prior_dist, num_classes) + shape = (10, 5) + device = "cuda:0" + samples = prior.sample(shape, device=device) + assert samples.device == torch.device(device) + assert samples.shape == shape + assert samples.max() <= num_classes - 1 + assert samples.min() >= 0 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_mask.py b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_mask.py new file mode 100644 index 0000000000..d182745413 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_mask.py @@ -0,0 +1,69 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch + +from bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior + + +def test_discrete_masked_prior_init(): + """Test the initialization of the DiscreteMaskedPrior class.""" + num_classes = 10 + prior = DiscreteMaskedPrior(num_classes) + assert prior.num_classes == num_classes + assert prior.mask_dim == num_classes - 1 + assert torch.sum(prior.prior_dist).item() - 1.0 < 1e-5 + + +def test_discrete_masked_prior_sample(): + """Test the sample method of the DiscreteMaskedPrior class.""" + num_classes = 10 + prior = DiscreteMaskedPrior(num_classes) + shape = (10, 5) + samples = prior.sample(shape) + assert samples.shape == shape + assert samples.max() == prior.mask_dim + assert samples.min() >= 0 + + +def test_discrete_masked_prior_sample_with_mask(): + """Test the sample method of the DiscreteMaskedPrior class with a mask.""" + num_classes = 10 + prior = DiscreteMaskedPrior(num_classes) + shape = (10, 5) + mask = torch.ones((10,) + (1,) * (len(shape) - 1)) + mask[5:] = 0 + samples = prior.sample(shape, mask=mask) + assert samples.shape == shape + assert samples.max() == prior.mask_dim + assert samples.min() >= 0 + assert torch.all(samples[5:] == 0) + + +def test_discrete_masked_prior_sample_on_gpu(): + """Test the sample method of the DiscreteMaskedPrior class on a GPU.""" + if not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + num_classes = 10 + prior = DiscreteMaskedPrior(num_classes) + shape = (10, 5) + device = "cuda:0" + samples = prior.sample(shape, device=device) + assert samples.device == torch.device(device) + assert samples.shape == shape + assert samples.max() == prior.mask_dim + assert samples.min() >= 0 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_uniform.py b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_uniform.py new file mode 100644 index 0000000000..fbfb28cd47 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_uniform.py @@ -0,0 +1,68 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch + +from bionemo.moco.distributions.prior.discrete.uniform import DiscreteUniformPrior + + +def test_discrete_uniform_prior_init(): + """Test the initialization of the DiscreteUniformPrior class.""" + num_classes = 10 + prior = DiscreteUniformPrior(num_classes) + assert prior.num_classes == num_classes + assert torch.sum(prior.prior_dist).item() - 1.0 < 1e-5 + + +def test_discrete_uniform_prior_sample(): + """Test the sample method of the DiscreteUniformPrior class.""" + num_classes = 10 + prior = DiscreteUniformPrior(num_classes) + shape = (10, 5) + samples = prior.sample(shape) + assert samples.shape == shape + assert samples.max() < num_classes + assert samples.min() >= 0 + + +def test_discrete_uniform_prior_sample_with_mask(): + """Test the sample method of the DiscreteUniformPrior class with a mask.""" + num_classes = 10 + prior = DiscreteUniformPrior(num_classes) + shape = (10, 5) + mask = torch.ones((10,) + (1,) * (len(shape) - 1)) + mask[5:] = 0 + samples = prior.sample(shape, mask=mask) + assert samples.shape == shape + assert samples.max() < num_classes + assert samples.min() >= 0 + assert torch.all(samples[5:] == 0) + + +def test_discrete_uniform_prior_sample_on_gpu(): + """Test the sample method of the DiscreteUniformPrior class on a GPU.""" + if not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + num_classes = 10 + prior = DiscreteUniformPrior(num_classes) + shape = (10, 5) + device = "cuda:0" + samples = prior.sample(shape, device=device) + assert samples.device == torch.device(device) + assert samples.shape == shape + assert samples.max() < num_classes + assert samples.min() >= 0 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/time/test_time_distribution.py b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/time/test_time_distribution.py new file mode 100644 index 0000000000..15404806b3 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/time/test_time_distribution.py @@ -0,0 +1,146 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch + +from bionemo.moco.distributions.time.beta import BetaTimeDistribution +from bionemo.moco.distributions.time.distribution import MixTimeDistribution +from bionemo.moco.distributions.time.logit_normal import LogitNormalTimeDistribution +from bionemo.moco.distributions.time.uniform import SymmetricUniformTimeDistribution, UniformTimeDistribution + + +# List of distributions to test +distributions = [ + (BetaTimeDistribution, {"p1": 2.0, "p2": 1.0}), + (UniformTimeDistribution, {}), + (SymmetricUniformTimeDistribution, {}), + (LogitNormalTimeDistribution, {"p1": 0.0, "p2": 1.0}), +] + +# Devices to test +devices = ["cpu"] +if torch.cuda.is_available(): + devices.append("cuda") + + +@pytest.mark.parametrize("dist_class, dist_kwargs", distributions) +@pytest.mark.parametrize("device", devices) +def test_continuous_time_sampling(dist_class, dist_kwargs, device): + # Initialize the time distribution + dist = dist_class(min_t=0.0, max_t=1.0, discrete_time=False, **dist_kwargs) + + # Sample from the distribution + samples = dist.sample(n_samples=1000, device=device) + + # Check if the samples are within the correct range + assert torch.all(samples >= 0.0) + assert torch.all(samples <= 1.0) + + # Check if the shape of the samples is correct + assert samples.shape == (1000,) + + +@pytest.mark.parametrize("dist_class, dist_kwargs", distributions) +@pytest.mark.parametrize("device", devices) +def test_discrete_time_sampling(dist_class, dist_kwargs, device): + # Initialize the time distribution + dist = dist_class(min_t=0.0, max_t=1.0, discrete_time=True, nsteps=10, **dist_kwargs) + + # Sample from the distribution + samples = dist.sample(n_samples=1000, device=device) + + # Check if the samples are within the correct range + assert torch.all(samples >= 0) + assert torch.all(samples <= 9) + + # Check if the shape of the samples is correct + assert samples.shape == (1000,) + + # Check if the samples are integers + assert samples.dtype == torch.int64 + + +@pytest.mark.parametrize("dist_class, dist_kwargs", distributions) +@pytest.mark.parametrize("device", devices) +def test_sample_shape(dist_class, dist_kwargs, device): + # Initialize the time distribution + dist = dist_class(min_t=0.0, max_t=1.0, discrete_time=False, **dist_kwargs) + + # Sample from the distribution with different number of samples + samples100 = dist.sample(n_samples=100, device=device) + samples1000 = dist.sample(n_samples=1000, device=device) + + # Check if the shape of the samples is correct + assert samples100.shape == (100,) + assert samples1000.shape == (1000,) + + +@pytest.mark.parametrize("dist_class, dist_kwargs", distributions) +@pytest.mark.parametrize("device", devices) +def test_device(dist_class, dist_kwargs, device): + # Initialize the time distribution + dist = dist_class(min_t=0.0, max_t=1.0, discrete_time=False, **dist_kwargs) + + # Sample from the distribution + samples = dist.sample(n_samples=100, device=device) + + # Check if the samples are on the correct device + assert samples.device.type == device + + +@pytest.mark.parametrize("dist_class, dist_kwargs", distributions) +@pytest.mark.parametrize("device", devices) +def test_min_max_t(dist_class, dist_kwargs, device): + # Initialize the time distribution with min_t and max_t + dist = dist_class(min_t=1e-2, max_t=0.99, discrete_time=False, **dist_kwargs) + + # Sample from the distribution + samples = dist.sample(n_samples=1000, device=device) + + # Check if the samples are within the correct range + assert torch.all(samples >= 1e-2) + assert torch.all(samples <= 0.99) + + +def test_mix_time_distribution(): + # Create a mix of Uniform and Beta distributions + uniform_dist = UniformTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False) + beta_dist = BetaTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False, p1=2.0, p2=1.0) + mix_dist = MixTimeDistribution(uniform_dist, beta_dist, mix_fraction=0.5) + + # Test sampling + n_samples = 100 + device = "cpu" + samples = mix_dist.sample(n_samples, device) + + # Check that the samples are within the correct range + assert (samples >= 0.0).all() and (samples <= 1.0).all() + + # Test that the device is correct + assert samples.device == torch.device(device) + + +def test_mix_time_distribution_edge_cases(): + # Test that the mix fraction is validated correctly + uniform_dist = UniformTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False) + beta_dist = BetaTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False, p1=2.0, p2=1.0) + + with pytest.raises(ValueError): + MixTimeDistribution(uniform_dist, beta_dist, mix_fraction=-0.1) + + with pytest.raises(ValueError): + MixTimeDistribution(uniform_dist, beta_dist, mix_fraction=1.1) diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_continuous_flow_matching.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_continuous_flow_matching.py new file mode 100644 index 0000000000..d3cbb0e16c --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_continuous_flow_matching.py @@ -0,0 +1,270 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import pytest +import torch +import torch.nn.functional as F + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +from bionemo.moco.distributions.time.uniform import UniformTimeDistribution +from bionemo.moco.interpolants.base_interpolant import PredictionType +from bionemo.moco.interpolants.continuous_time.continuous.continuous_flow_matching import ContinuousFlowMatcher + + +@pytest.fixture +def flow_matcher(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = GaussianPrior(center=False) + flow_matcher = ContinuousFlowMatcher( + time_distribution=time_distribution, prior_distribution=prior, prediction_type="vector_field" + ) + return flow_matcher + + +@pytest.fixture +def data_matcher(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = GaussianPrior(center=False) + flow_matcher = ContinuousFlowMatcher( + time_distribution=time_distribution, prior_distribution=prior, prediction_type=PredictionType.DATA + ) + return flow_matcher + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["flow_matcher"]) +def test_cfm_interpolate(request, fixture, device): + # Create an indices tensor + flow_matcher = request.getfixturevalue(fixture) + assert flow_matcher is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + flow_matcher = flow_matcher.to_device(device) + indices = torch.arange(3).repeat(32, 10) + + # Create a tensor of shape 32 x 10 x 3 where each element is a 3-dimensional one-hot vector + data = F.one_hot(indices, 3).float().to(device) + time = flow_matcher.sample_time(32) + noise = flow_matcher.sample_prior(data.shape) + xt = flow_matcher.interpolate(data, time, noise) + assert xt.shape == data.shape + + # When time is 0, the output should be the noise + data_time = torch.ones_like(time).to(device) * 0 + xt = flow_matcher.interpolate(data, data_time, noise) + error = (xt - noise) ** 2 + assert torch.all(error < 1e-7) + + # When time is close to 1, i.e. 0.999, the output should be the data + data_time = torch.ones_like(time).to(device) * 0.999 + xt = flow_matcher.interpolate(data, data_time, noise) + error = (xt - (noise + (data - noise) * 0.999)) ** 2 + assert torch.all(error < 1e-7) + + # When time is 0.5, if the data is the reflection of the noise, the output should be zeros + data_time = torch.ones_like(time).to(device) * 0.5 + new_data = torch.clone(noise) * -1 + xt = flow_matcher.interpolate(new_data, data_time, noise) + error = (xt - torch.zeros_like(xt)) ** 2 + assert torch.all(error < 1e-7) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cfm_step(flow_matcher, device): + # Create an indices tensor + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + flow_matcher = flow_matcher.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + time = flow_matcher.sample_time(32, device=device) + noise = flow_matcher.sample_prior(data.shape, device=device) + + # Check if the last step works + T = 0.999 + dt = time * 0 + 0.001 + model_out = data - noise + xt = noise + (data - noise) * T + next_xt = flow_matcher.step(model_out, xt, dt) + assert next_xt.shape == data.shape + error = (next_xt - data) ** 2 + assert torch.all(error < 1e-7) + + # When data is the reflection of the noise, check if sign flips after passing t=0.5 + data = noise * -1 + T = 0.499 + dt = time * 0 + 0.002 + model_out = data - noise + xt = noise + (data - noise) * T + assert torch.all(torch.sign(xt) == torch.sign(noise)) + next_xt = flow_matcher.step(model_out, xt, dt) + next_xt_gt = noise + (data - noise) * 0.501 + assert torch.all(torch.sign(next_xt) == torch.sign(data)) + error = (next_xt - next_xt_gt) ** 2 + assert torch.all(error < 1e-7) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cfm_loss(flow_matcher, device): + # Check if CUDA is available + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + flow_matcher = flow_matcher.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + noise = flow_matcher.sample_prior(data.shape, device=device) + # Set the ground truth to be the flow, like rectified flow objective + gt_flow = flow_matcher.calculate_target(data, noise) # data - noise + # Set the model output to be the flow with small noise perturbation + model_out = (data - noise) + torch.randn_like(data) * 0.001 + # Create a mask to mask the last 4 elements of the sequence + mask = torch.ones(32, 30, dtype=torch.bool).to(device) + mask[:, -4:] = False + # Mask out the model output to test if masking in loss works + model_out = model_out * mask.unsqueeze(-1) + + # Calculate the loss, only model_out is masked but not gt_flow + loss = flow_matcher.loss(model_out, gt_flow, mask=None, target_type="velocity") + # Check the shape of the loss + assert loss.shape == (32,) + # When mask input to flow_matcher.loss is None, the loss should be large because gt is not masked + assert loss.mean() > 0.1 + + # Calculate the loss with input argument mask as the mask + loss = flow_matcher.loss(model_out, gt_flow, mask=mask, target_type=PredictionType.VELOCITY) + # When mask input to flow_matcher.loss is None, the loss should be small + assert loss.mean() < 1e-4 + # Calculate the loss with input argument mask as the mask + time = flow_matcher.sample_time(32) + xt = flow_matcher.interpolate(data, time, noise) + loss = flow_matcher.loss( + model_out, data * mask.unsqueeze(-1), time, xt, mask=mask, target_type=PredictionType.DATA + ) + # When mask input to flow_matcher.loss is None, the loss should be small + assert loss.mean() < 1e-4 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["data_matcher"]) +def test_cfm_interpolate_data(request, fixture, device): + # Create an indices tensor + torch.manual_seed(42) + flow_matcher = request.getfixturevalue(fixture) + assert flow_matcher is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + flow_matcher = flow_matcher.to_device(device) + indices = torch.arange(3).repeat(32, 10) + + # Create a tensor of shape 32 x 10 x 3 where each element is a 3-dimensional one-hot vector + data = F.one_hot(indices, 3).float().to(device) + time = flow_matcher.sample_time(32) + noise = flow_matcher.sample_prior(data.shape) + xt = flow_matcher.interpolate(data, time, noise) + assert xt.shape == data.shape + + # When time is 0, the output should be the noise + data_time = torch.ones_like(time).to(device) * 0 + xt = flow_matcher.interpolate(data, data_time, noise) + error = (xt - noise) ** 2 + assert torch.all(error < 1e-7) + + # When time is close to 1, i.e. 0.999, the output should be the data + data_time = torch.ones_like(time).to(device) * 0.999 + xt = flow_matcher.interpolate(data, data_time, noise) + error = (xt - (noise + (data - noise) * 0.999)) ** 2 + assert torch.all(error < 1e-7) + + # When time is 0.5, if the data is the reflection of the noise, the output should be zeros + data_time = torch.ones_like(time).to(device) * 0.5 + new_data = torch.clone(noise) * -1 + xt = flow_matcher.interpolate(new_data, data_time, noise) + error = (xt - torch.zeros_like(xt)) ** 2 + assert torch.all(error < 1e-7) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cfm_step_data(data_matcher, device): + # Create an indices tensor + torch.manual_seed(42) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + flow_matcher = data_matcher.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + time = flow_matcher.sample_time(32, device=device) + noise = flow_matcher.sample_prior(data.shape, device=device) + + # Check if the last step works + T = 0.999 + dt = time * 0 + 0.001 + model_out = data + xt = noise + (data - noise) * T + next_xt = flow_matcher.step(model_out, xt, dt, time * 0 + T) + assert next_xt.shape == data.shape + error = (next_xt - data) ** 2 + assert torch.all(error < 1e-7) + + # When data is the reflection of the noise, check if sign flips after passing t=0.5 + data = noise * -1 + T = 0.499 + dt = time * 0 + 0.002 + model_out = data + xt = noise + (data - noise) * T + assert torch.all(torch.sign(xt) == torch.sign(noise)) + next_xt = flow_matcher.step(model_out, xt, dt, time * 0 + T) + next_xt_gt = noise + (data - noise) * 0.501 + assert torch.all(torch.sign(next_xt) == torch.sign(data)) + error = (next_xt - next_xt_gt) ** 2 + assert torch.all(error < 1e-7) + + next_xt = flow_matcher.step_score_stochastic(model_out, xt, dt, time * 0 + T) + error = (next_xt - next_xt_gt) ** 2 + assert error.mean() < 1e-2 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cfm_loss_data(data_matcher, device): + # Check if CUDA is available + torch.manual_seed(42) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + flow_matcher = data_matcher.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + noise = flow_matcher.sample_prior(data.shape, device=device) + # Set the ground truth to be the flow, like rectified flow objective + gt_target = flow_matcher.calculate_target(data, noise) # data - noise + # Set the model output to be the flow with small noise perturbation + model_out = data + torch.randn_like(data) * 0.001 + # Create a mask to mask the last 4 elements of the sequence + mask = torch.ones(32, 30, dtype=torch.bool).to(device) + mask[:, -4:] = False + # Mask out the model output to test if masking in loss works + model_out = model_out * mask.unsqueeze(-1) + time = flow_matcher.sample_time(32) + xt = flow_matcher.interpolate(data, time, noise) + # Calculate the loss, only model_out is masked but not gt_flow + loss = flow_matcher.loss(model_out, gt_target, time, xt) + # Check the shape of the loss + assert loss.shape == (32,) + # When mask input to flow_matcher.loss is None, the loss should be large because gt is not masked + assert loss.mean() > 0.1 + + # Calculate the loss with input argument mask as the mask + loss = flow_matcher.loss(model_out, gt_target * mask.unsqueeze(-1), time, xt, mask=mask) + assert loss.mean() < 1e-2 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_optimal_transport.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_optimal_transport.py new file mode 100644 index 0000000000..9c594803ed --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_optimal_transport.py @@ -0,0 +1,141 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import pytest +import torch + +from bionemo.moco.interpolants.continuous_time.continuous.optimal_transport import OTSampler + + +@pytest.fixture +def toy_data(): + x0 = torch.tensor( + [ + [[1.1, 1.1, 1.1], [1.1, 1.1, 1.1], [1.1, 1.1, 1.1]], + [[-1.1, -1.1, -1.1], [-1.1, -1.1, -1.1], [-1.1, -1.1, -1.1]], + [[1.1, 1.1, 1.1], [-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]], + ] + ) + + x1 = torch.tensor( + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + [[1.0, 1.0, 1.0], [-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]], + [[-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0]], + ] + ) + mask = None + # Calculate the cost in naive for-loop. For exact OT, sqaured Euclidean distance is used + costs = torch.zeros((x0.shape[0], x1.shape[0])) + for i in range(x0.shape[0]): + for j in range(x0.shape[0]): + c = torch.sum(torch.square(x0[i] - x1[j])) + costs[i, j] = c + return x0, x1, mask, costs + + +@pytest.fixture +def toy_masked_data(): + x0 = torch.tensor( + [ + [[1.1, 1.1, 1.1], [1.1, 1.1, 1.1], [1.1, 1.1, 1.1]], + [[-1.1, -1.1, -1.1], [-1.1, -1.1, -1.1], [-1.1, -1.1, -1.1]], + [[1.1, 1.1, 1.1], [-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]], + ] + ) + + x1 = torch.tensor( + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + [[1.0, 1.0, 1.0], [-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]], + [[-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0]], + ] + ) + mask = torch.tensor([[1, 1, 0], [1, 1, 1], [1, 0, 0]], dtype=torch.bool) + # Calculate the cost in naive for-loop. For exact OT, sqaured Euclidean distance is used + costs = torch.zeros((x0.shape[0], x1.shape[0])) + for i in range(x0.shape[0]): + mm = mask[i].unsqueeze(-1) + for j in range(x0.shape[0]): + per_atom_cost = torch.where(mm, torch.square(x0[i] - x1[j]), 0) + c = torch.sum(per_atom_cost) + costs[i, j] = c + return x0, x1, mask, costs + + +@pytest.fixture +def exact_ot_sampler(): + ot_sampler = OTSampler(method="exact", num_threads=1) + return ot_sampler + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("sampler", ["exact_ot_sampler"]) +@pytest.mark.parametrize("data", ["toy_data", "toy_masked_data"]) +def test_exact_ot_sampler_ot_matrix(request, sampler, data, device): + # Create an indices tensor + ot_sampler = request.getfixturevalue(sampler) + assert ot_sampler is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ot_sampler = ot_sampler.to_device(device) + x0, x1, mask, ground_truth_cost_matrix = request.getfixturevalue(data) + + cost_matrix = ot_sampler._calculate_cost_matrix(x0, x1, mask=mask) + assert cost_matrix.shape == (3, 3) + assert torch.allclose(cost_matrix, ground_truth_cost_matrix, atol=1e-8) + + ot_matrix = ot_sampler.get_ot_matrix(x0, x1, mask=mask) + ot_truth = torch.tensor([[1 / 3, 0.0, 0.0], [0.0, 0.0, 1 / 3], [0.0, 1 / 3, 0.0]]) + assert ot_matrix.shape == (3, 3) + assert torch.allclose(ot_matrix, ot_truth, atol=1e-8) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("sampler", ["exact_ot_sampler"]) +@pytest.mark.parametrize("data", ["toy_data", "toy_masked_data"]) +def test_exact_ot_sampler_sample_map(request, sampler, data, device): + # Create an indices tensor + ot_sampler = request.getfixturevalue(sampler) + assert ot_sampler is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ot_sampler = ot_sampler.to_device(device) + x0, x1, mask, ground_truth_cost_matrix = request.getfixturevalue(data) + ot_matrix = ot_sampler.get_ot_matrix(x0, x1, mask=mask) + correct_mapping = {0: 0, 1: 2, 2: 1} + + x0_idx, x1_idx = ot_sampler.sample_map(ot_matrix, x0.shape[0], replace=False) + # print(x0_idx) + # print(x1_idx) + assert x0_idx.shape == (x0.shape[0],) + assert x1_idx.shape == (x1.shape[0],) + all_indices = set(range(x0.shape[0])) + sampled_indices = set() + for i in range(len(x0_idx)): + sampled_indices.add(x0_idx[i].item()) + assert x1_idx[i].item() == correct_mapping[x0_idx[i].item()] + # When replace is False, all indices should be sampled + assert all_indices == sampled_indices + + x0_idx, x1_idx = ot_sampler.sample_map(ot_matrix, x0.shape[0], replace=True) + assert x0_idx.shape == (x0.shape[0],) + assert x1_idx.shape == (x1.shape[0],) + print(x0_idx) + print(x1_idx) + for i in range(len(x0_idx)): + sampled_indices.add(x0_idx[i].item()) + assert x1_idx[i].item() == correct_mapping[x0_idx[i].item()] + # When replace is True, not all indices should be sampled diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_vdm.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_vdm.py new file mode 100644 index 0000000000..b76ace8a9a --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_vdm.py @@ -0,0 +1,194 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# tests/moco/interpolants/discrete_time/continuous/test_vdm.py + +import pytest +import torch +import torch.nn.functional as F + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +from bionemo.moco.distributions.time.uniform import UniformTimeDistribution +from bionemo.moco.interpolants.continuous_time.continuous.vdm import VDM +from bionemo.moco.schedules.noise.continuous_snr_transforms import CosineSNRTransform + + +@pytest.fixture +def vdm(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = GaussianPrior(center=False) + noise_schedule = CosineSNRTransform() + vdm = VDM(time_distribution, prior, noise_schedule) + return vdm + + +@pytest.fixture +def vdm_centered(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = GaussianPrior(center=True) + noise_schedule = CosineSNRTransform() + vdm = VDM(time_distribution, prior, noise_schedule) + return vdm + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["vdm", "vdm_centered"]) +def test_vdm_interpolate(request, fixture, device): + vdm = request.getfixturevalue(fixture) + assert vdm is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + vdm = vdm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) + time = vdm.sample_time(32) + noise = vdm.sample_prior(data.shape) + xt = vdm.interpolate(data, time, noise) + assert xt.shape == data.shape + + data_time = torch.ones_like(time).to(device) * 0 + xt = vdm.interpolate(data, data_time, noise) + error = (xt - data) ** 2 + assert error.mean() <= 2e-3 + data_time = torch.ones_like(time).to(device) * (1 - 1e-7) + xt = vdm.interpolate(data, data_time, noise) + error = (xt - noise) ** 2 + assert error.mean() < 1e-7 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_vdm_step(vdm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + vdm = vdm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) + T = 1 / 1000 + time = vdm.sample_time(32, device=device) * 0 + T + dt = torch.ones_like(time) * 1 / 1000 + noise = vdm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + xt = 0.99 * data + 0.01 * noise + next_xt = vdm.step(model_out, time, xt, dt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert torch.allclose(error.mean(), torch.tensor(0.0001), atol=1e-4) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_vdm_centered_step(vdm_centered, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + vdm = vdm_centered.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) + data = vdm.clean_mask_center(data, center=True) + T = 1 / 1000 + time = vdm.sample_time(32, device=device) * 0 + T + dt = torch.ones_like(time) * 1 / 1000 + noise = vdm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + xt = 0.99 * data + 0.01 * noise + next_xt = vdm.step(model_out, time, xt, dt, center=True) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert torch.allclose(error.mean(), torch.tensor(0.0001), atol=1e-4) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("weight_type", ["ones", "data_to_noise"]) +def test_vdm_loss(vdm, device, weight_type): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + vdm = vdm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) + T = 1 + time = vdm.sample_time(32, device=device) * 0 + T + noise = vdm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + mask = torch.ones(32, 30, dtype=torch.bool).to(device) + mask[:, -4:] = False + data = data * mask.unsqueeze(-1) + model_out = model_out * mask.unsqueeze(-1) + + loss = vdm.loss(model_out, data, time, mask=mask, weight_type=weight_type) + assert loss.shape == (32,) + assert loss.mean() < 1e-3 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_vdm_2d_step(vdm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + vdm = vdm.to_device(device) + data = torch.rand((32, 10, 10, 3)).to(device) + T = 1 / 1000 + time = vdm.sample_time(32, device=device) * 0 + T + dt = torch.ones_like(time) * 1 / 1000 + noise = vdm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + _ = vdm.interpolate(data, time, noise) + xt = 0.99 * data + 0.01 * noise + next_xt = vdm.step(model_out, time, xt, dt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert torch.allclose(error.mean(), torch.tensor(0.0001), atol=1e-4) + T = 100 / 1000 + time = vdm.sample_time(32, device=device) * 0 + T + noise = vdm.sample_prior(data.shape, device=device) + model_out = 0.99 * data + 0.01 * noise + xt = 0.9 * data + 0.1 * noise + next_xt = vdm.step(model_out, time, xt, dt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-3 + error = (xt - data) ** 2 + assert error.mean() < 1e-1 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-1 + + +@pytest.mark.parametrize("devices", [("cpu", "cuda"), ("cuda", "cpu")]) +def test_vdm_to_device_multiple(vdm, devices): + if "cuda" in devices and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + vdm.to_device(devices[0]) + + for attr_name in dir(vdm): + if attr_name.startswith("_") and isinstance(getattr(vdm, attr_name), torch.Tensor): + assert getattr(vdm, attr_name).device.type == devices[0] + + vdm.to_device(devices[1]) + + for attr_name in dir(vdm): + if attr_name.startswith("_") and isinstance(getattr(vdm, attr_name), torch.Tensor): + assert getattr(vdm, attr_name).device.type == devices[1] + + assert vdm.device == devices[1] diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_discrete_flow_matching.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_discrete_flow_matching.py new file mode 100644 index 0000000000..793b8c3bbd --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_discrete_flow_matching.py @@ -0,0 +1,233 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch + +from bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior +from bionemo.moco.distributions.prior.discrete.uniform import DiscreteUniformPrior +from bionemo.moco.distributions.time.uniform import UniformTimeDistribution +from bionemo.moco.interpolants.continuous_time.discrete.discrete_flow_matching import DiscreteFlowMatcher + + +@pytest.fixture +def dfm_mask(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = DiscreteMaskedPrior(num_classes=20) # 19 data classes 1 mask class + dfm = DiscreteFlowMatcher(time_distribution, prior) + return dfm + + +@pytest.fixture +def dfm_mask_non_inclusive(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = DiscreteMaskedPrior(num_classes=20, inclusive=False) + dfm = DiscreteFlowMatcher(time_distribution, prior) + return dfm + + +@pytest.fixture +def dfm_uniform(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = DiscreteUniformPrior(num_classes=20) + dfm = DiscreteFlowMatcher(time_distribution, prior) + return dfm + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive", "dfm_uniform"]) +def test_dfm_interpolate(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues)).to(device) + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + result = dfm.interpolate(data, t, noise) + assert result.shape == (batch_size, num_residues) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive", "dfm_uniform"]) +def test_dfm_step(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + num_classes = 20 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues)).to(device) + t = dfm.sample_time(batch_size) + logits = torch.zeros((batch_size, num_residues, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(2, data.unsqueeze(-1), 1) + + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + xt = dfm.interpolate(data, t, noise) + if isinstance(dfm.prior_distribution, DiscreteMaskedPrior) and dfm.prior_distribution.mask_dim == 20: #! exclusive + logits = dfm.prior_distribution.pad_sample(logits) + next_xt = dfm.step(logits, 0 * t + 0.5, xt, dt=1 / 100) + else: + next_xt = dfm.step(logits, 0 * t + 0.5, xt, dt=1 / 100) + assert next_xt.shape == xt.shape + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive"]) +def test_dfm_loss(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + num_classes = 20 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues)).to(device) + t = dfm.sample_time(batch_size) + logits = torch.zeros((batch_size, num_residues, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(2, data.unsqueeze(-1), 1) + + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + xt = dfm.interpolate(data, t, noise) + loss = dfm.loss(logits, data) + assert loss.mean() == 0 + loss = dfm.loss(logits, data, mask=dfm.prior_distribution.is_masked(xt)) + assert loss.mean() == 0 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive"]) +def test_dfm_step_purity(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + num_classes = 20 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues)).to(device) + t = dfm.sample_time(batch_size) + logits = torch.zeros((batch_size, num_residues, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(2, data.unsqueeze(-1), 1) + + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + xt = dfm.interpolate(data, t, noise) + if isinstance(dfm.prior_distribution, DiscreteMaskedPrior) and dfm.prior_distribution.mask_dim == 20: #! exclusive + logits = dfm.prior_distribution.pad_sample(logits) + next_xt = dfm.step_purity(logits, 0 * t + 0.5, xt, dt=1 / 100) + else: + next_xt = dfm.step_purity(logits, 0 * t + 0.5, xt, dt=1 / 100) + assert next_xt.shape == xt.shape + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive", "dfm_uniform"]) +def test_dfm_interpolate_square(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues, num_residues)).to(device) + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + result = dfm.interpolate(data, t, noise) + assert result.shape == (batch_size, num_residues, num_residues) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive", "dfm_uniform"]) +def test_dfm_step_square(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + num_classes = 20 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues, num_residues)).to(device) + t = dfm.sample_time(batch_size) + logits = torch.zeros((batch_size, num_residues, num_residues, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(3, data.unsqueeze(-1), 1) + + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + xt = dfm.interpolate(data, t, noise) + if isinstance(dfm.prior_distribution, DiscreteMaskedPrior) and dfm.prior_distribution.mask_dim == 20: #! exclusive + logits = dfm.prior_distribution.pad_sample(logits) + next_xt = dfm.step(logits, 0 * t + 0.5, xt, dt=1 / 100) + else: + next_xt = dfm.step(logits, 0 * t + 0.5, xt, dt=1 / 100) + assert next_xt.shape == xt.shape + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive"]) +def test_dfm_loss_square(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + num_classes = 20 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues, num_residues)).to(device) + t = dfm.sample_time(batch_size) + logits = torch.zeros((batch_size, num_residues, num_residues, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(3, data.unsqueeze(-1), 1) + + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + xt = dfm.interpolate(data, t, noise) + assert xt.shape == data.shape + loss = dfm.loss(logits.reshape(logits.shape[0], -1, logits.shape[3]), data.reshape(data.shape[0], -1)) + assert loss.mean() == 0 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_mdlm.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_mdlm.py new file mode 100644 index 0000000000..4f9ae56bdd --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_mdlm.py @@ -0,0 +1,181 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch + +from bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior +from bionemo.moco.distributions.time.uniform import UniformTimeDistribution +from bionemo.moco.interpolants.continuous_time.discrete.mdlm import MDLM +from bionemo.moco.schedules.noise.continuous_noise_transforms import LogLinearExpNoiseTransform + + +@pytest.fixture +def mdlm(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = DiscreteMaskedPrior(num_classes=20) + noise_schedule = LogLinearExpNoiseTransform() + mdlm = MDLM(time_distribution, prior, noise_schedule) + return mdlm + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_mdlm_interpolate(mdlm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + data = torch.randint(0, 16, (5, 10)).to(device) + t = torch.rand((5,)).to(device) + mdlm.to_device(device) + result = mdlm.interpolate(data, t) + assert result.shape == (5, 10) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_mdlm_step(mdlm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + # Create a random data tensor + num_classes = 20 + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + mdlm = mdlm.to_device(device) + torch.manual_seed(42) # for reproducibility + data = torch.randint(0, num_classes - 1, (32, 5)).to(device) + # Create time tensor + # T = 500 + time = mdlm.sample_time(32, device=device) # * 0 + T + # Create a mock model that outputs logits + logits = torch.zeros((32, 5, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(2, data.unsqueeze(-1), 1) + # Sample noise + noise = mdlm.sample_prior(data.shape, device=device) + # Create model output and xt + model_out = logits # torch.softmax(logits, dim=-1) + xt = data.clone() + xt[:, 0] = noise[:, 0] + time = time * 0 + 40 / 100 + next_xt = mdlm.step(model_out, time, xt, dt=1 / 100) + score = mdlm.calculate_score(logits, xt, time) + assert score.shape == logits.shape + next_xt = mdlm.step_argmax(model_out) + # Assert shapes + assert next_xt.shape == data.shape + model_out_onehot = torch.nn.functional.one_hot( + model_out.argmax(-1), num_classes=num_classes + ).float() # (B, N, num_classes) + nll = -torch.sum(torch.log(model_out_onehot.view(-1, num_classes) + 1e-8).gather(1, data.view(-1, 1)).squeeze(1)) + assert nll < 1e-10 + loss = mdlm.loss(logits, data, xt, time) + assert loss.mean() == 0 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_mdlm_step_confidence(mdlm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + # Create a random data tensor + num_classes = 20 + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + mdlm = mdlm.to_device(device) + torch.manual_seed(42) # for reproducibility + data = torch.randint(0, num_classes - 1, (32, 5)).to(device) + # Create time tensor + # T = 500 + time = mdlm.sample_time(32, device=device) # * 0 + T + # Create a mock model that outputs logits + logits = torch.zeros((32, 5, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(2, data.unsqueeze(-1), 1) + # Sample noise + noise = mdlm.sample_prior(data.shape, device=device) + # Create model output and xt + model_out = logits # torch.softmax(logits, dim=-1) + xt = data.clone() + xt[:, 0] = noise[:, 0] + time = time * 0 + 2 / 100 + next_xt = mdlm.step_confidence(model_out, xt, curr_step=90, num_steps=100) + # Assert shapes + assert next_xt.shape == data.shape + model_out_onehot = torch.nn.functional.one_hot( + model_out.argmax(-1), num_classes=num_classes + ).float() # (B, N, num_classes) + nll = -torch.sum(torch.log(model_out_onehot.view(-1, num_classes) + 1e-8).gather(1, data.view(-1, 1)).squeeze(1)) + assert nll < 1e-10 + loss = mdlm.loss(logits, data, xt, time) + assert loss.mean() == 0 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_mdlm_interpolate_square(mdlm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + data = torch.randint(0, 16, (5, 10, 10)).to(device) + t = torch.rand((5,)).to(device) + mdlm.to_device(device) + result = mdlm.interpolate(data, t) + assert result.shape == (5, 10, 10) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_mdlm_step_square(mdlm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + # Create a random data tensor + + num_classes = 20 + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + mdlm = mdlm.to_device(device) + torch.manual_seed(42) # for reproducibility + data = torch.randint(0, num_classes - 1, (5, 10, 10)).to(device) + # Create time tensor + # T = 500 + time = mdlm.sample_time(5, device=device) # * 0 + T + # Create a mock model that outputs logits + logits = torch.zeros((5, 10, 10, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(3, data.unsqueeze(-1), 1) + # Sample noise + noise = mdlm.sample_prior(data.shape, device=device) + # Create model output and xt + model_out = logits # torch.softmax(logits, dim=-1) + xt = data.clone() + xt[:, 0, 0] = noise[:, 0, 0] + time = time * 0 + 40 / 100 + next_xt = mdlm.step(model_out, time, xt, dt=1 / 100) + next_xt = mdlm.step_argmax(model_out) + # Assert shapes + assert next_xt.shape == data.shape + model_out_onehot = torch.nn.functional.one_hot( + model_out.argmax(-1), num_classes=num_classes + ).float() # (B, H, W, num_classes) + nll = -torch.sum(torch.log(model_out_onehot.view(-1, num_classes) + 1e-8).gather(1, data.view(-1, 1)).squeeze(1)) + assert nll < 1e-10 + loss = mdlm.loss( + logits.reshape(logits.shape[0], -1, logits.shape[3]), + data.reshape(data.shape[0], -1), + xt.data.reshape(data.shape[0], -1), + time, + ) + assert loss.mean() == 0 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/continuous/test_ddpm.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/continuous/test_ddpm.py new file mode 100644 index 0000000000..15001ca382 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/continuous/test_ddpm.py @@ -0,0 +1,365 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch +import torch.nn.functional as F + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +from bionemo.moco.distributions.time.uniform import UniformTimeDistribution +from bionemo.moco.interpolants.discrete_time.continuous.ddpm import DDPM +from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule + + +@pytest.fixture +def ddpm(): + time_distribution = UniformTimeDistribution(discrete_time=True, nsteps=1000) + prior = GaussianPrior(center=False) + noise_schedule = DiscreteCosineNoiseSchedule(nsteps=1000) + ddpm = DDPM(time_distribution, prior, noise_schedule) + return ddpm + + +@pytest.fixture +def ddpm_centered(): + time_distribution = UniformTimeDistribution(discrete_time=True, nsteps=1000) + prior = GaussianPrior(center=True) + noise_schedule = DiscreteCosineNoiseSchedule(nsteps=1000) + ddpm = DDPM(time_distribution, prior, noise_schedule) + return ddpm + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["ddpm", "ddpm_centered"]) +def test_ddpm_interpolate(request, fixture, device): + # Create an indices tensor + ddpm = request.getfixturevalue(fixture) + assert ddpm is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + + # Create a tensor of shape 32 x 10 x 3 where each element is a 3-dimensional one-hot vector + data = F.one_hot(indices, 3).float().to(device) + time = ddpm.sample_time(32) + noise = ddpm.sample_prior(data.shape) + xt = ddpm.interpolate(data, time, noise) + assert xt.shape == data.shape + + data_time = torch.ones_like(time).to(device) * 0 + xt = ddpm.interpolate(data, data_time, noise) + error = (xt - data) ** 2 + assert error.mean() <= 2e-3 + + data_time = torch.ones_like(time).to(device) * 999 + xt = ddpm.interpolate(data, data_time, noise) + error = (xt - noise) ** 2 + assert error.mean() < 1e-7 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_ddpm_step(ddpm, device): + # Create an indices tensor + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + T = 1 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + xt = 0.99 * data + 0.01 * noise + next_xt = ddpm.step(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-4 + T = 100 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.99 * data + 0.01 * noise + xt = 0.9 * data + 0.1 * noise + next_xt = ddpm.step(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-3 + error = (xt - data) ** 2 + assert error.mean() < 1e-1 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_ddpm_step_masked(ddpm, device): + # Create an indices tensor + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) + T = 1 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + xt = 0.99 * data + 0.01 * noise + + # Create a mask to mask out the last 3-4 elements + mask = torch.ones(32, 30, dtype=torch.bool).to(device) + mask[:, -4:] = False + xt = xt * mask.unsqueeze(-1) + data = data * mask.unsqueeze(-1) + model_out = model_out * mask.unsqueeze(-1) + # import ipdb; ipdb.set_trace() + next_xt = ddpm.step(model_out, time, xt, mask=mask) + + # Check that the masked elements are unchanged + assert torch.allclose(next_xt[:, -4:, :], xt[:, -4:, :]) + + # Check the shape of the output + assert next_xt.shape == data.shape + + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-4 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_ddpm_centered_step(ddpm_centered, device): + # Create an indices tensor + ddpm = ddpm_centered + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + data = ddpm.clean_mask_center(data, center=True) + T = 1 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + xt = 0.99 * data + 0.01 * noise + next_xt = ddpm.step(model_out, time, xt, center=True) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-4 + T = 100 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.99 * data + 0.01 * noise + xt = 0.9 * data + 0.1 * noise + next_xt = ddpm.step(model_out, time, xt, center=True) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-3 + error = (xt - data) ** 2 + assert error.mean() < 1e-1 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_ddim_step(ddpm, device): + # Create an indices tensor + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + T = 1 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + xt = 0.99 * data + 0.01 * noise + next_xt = ddpm.general_step("step_ddim", {"model_out": model_out, "t": time, "xt": xt}) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-4 + T = 100 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.99 * data + 0.01 * noise + xt = 0.9 * data + 0.1 * noise + next_xt = ddpm.step_ddim(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-3 + error = (xt - data) ** 2 + assert error.mean() < 1e-1 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("weight_type", ["ones", "data_to_noise"]) +def test_ddpm_loss(ddpm, device, weight_type): + # Check if CUDA is available + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + ddpm = ddpm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + T = 1 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + mask = torch.ones(32, 30, dtype=torch.bool).to(device) + mask[:, -4:] = False + data = data * mask.unsqueeze(-1) + model_out = model_out * mask.unsqueeze(-1) + + # Calculate the loss + loss = ddpm.loss(model_out, data, time, mask=mask, weight_type=weight_type) + + # Check the shape of the loss + assert loss.shape == (32,) + assert loss.mean() < 1e-3 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_ddpm_2d_step(ddpm, device): + # Create an indices tensor + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + data = torch.rand((32, 10, 10, 3)).to(device) # shape = [32, 10, 10, 3] + T = 1 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + _ = ddpm.interpolate(data, time, noise) + xt = 0.99 * data + 0.01 * noise + next_xt = ddpm.step(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-4 + T = 100 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.99 * data + 0.01 * noise + xt = 0.9 * data + 0.1 * noise + next_xt = ddpm.step(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-3 + error = (xt - data) ** 2 + assert error.mean() < 1e-1 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("ndim", [2, 3, 4, 5]) +def test_ddpm_ndim_step(ddpm, device, ndim): + # Create an indices tensor + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + shape = [10] * ndim + batch_size = 32 + data = torch.rand((batch_size, *shape, 3)).to(device) + T = 1 + time = ddpm.sample_time(batch_size, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + _ = ddpm.interpolate(data, time, noise) + xt = 0.99 * data + 0.01 * noise + next_xt = ddpm.step(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-4 + T = 100 + time = ddpm.sample_time(batch_size, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.99 * data + 0.01 * noise + xt = 0.9 * data + 0.1 * noise + next_xt = ddpm.step(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-3 + error = (xt - data) ** 2 + assert error.mean() < 1e-1 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-1 + + +@pytest.mark.parametrize("devices", [("cpu", "cuda"), ("cuda", "cpu")]) +def test_ddpm_to_device_multiple(ddpm, devices): + # Check if CUDA is available + if "cuda" in devices and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + # Move the DDPM instance to the first device + ddpm.to_device(devices[0]) + + # Check that all internal tensors have been moved to the first device + for attr_name in dir(ddpm): + if attr_name.startswith("_") and isinstance(getattr(ddpm, attr_name), torch.Tensor): + assert getattr(ddpm, attr_name).device.type == devices[0] + + # Move the DDPM instance to the second device + ddpm.to_device(devices[1]) + + # Check that all internal tensors have been moved to the second device + for attr_name in dir(ddpm): + if attr_name.startswith("_") and isinstance(getattr(ddpm, attr_name), torch.Tensor): + assert getattr(ddpm, attr_name).device.type == devices[1] + + # Check that the device attribute has been updated + assert ddpm.device == devices[1] + + +def test_set_loss_weight_fn(ddpm): + # Define a test function to set as the loss_weight attribute + def test_loss_weight_fn(raw_loss, t, weight_type): + return raw_loss * t * weight_type + + # Set the test function as the loss_weight attribute + ddpm.set_loss_weight_fn(test_loss_weight_fn) + + # Verify that the loss_weight attribute is set to the test function + assert ddpm.loss_weight is test_loss_weight_fn + + # Test that the function is callable with the correct arguments + raw_loss = 1.0 + t = 2.0 + weight_type = 3.0 + expected_output = raw_loss * t * weight_type + assert ddpm.loss_weight(raw_loss, t, weight_type) == expected_output diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/discrete/test_d3pm.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/discrete/test_d3pm.py new file mode 100644 index 0000000000..2993c09c1a --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/discrete/test_d3pm.py @@ -0,0 +1,80 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch + +from bionemo.moco.distributions.prior.discrete.uniform import DiscreteUniformPrior +from bionemo.moco.distributions.time.uniform import UniformTimeDistribution +from bionemo.moco.interpolants.discrete_time.discrete.d3pm import D3PM +from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule + + +@pytest.fixture +def d3pm(): + time_distribution = UniformTimeDistribution(discrete_time=True, nsteps=1000) + prior = DiscreteUniformPrior(num_classes=20) + noise_schedule = DiscreteCosineNoiseSchedule(nsteps=1000) + d3pm = D3PM(time_distribution, prior, noise_schedule) + return d3pm + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_d3pm_interpolate(d3pm, device): + data = torch.randint(0, 16, (5, 10)).to(device) + t = torch.randint(0, 10, (5,)).to(device) + d3pm.to_device(device) + result = d3pm.interpolate(data, t) + assert result.shape == (5, 10) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_d3pm_step(d3pm, device): + # Create a random data tensor + num_classes = 20 + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + d3pm = d3pm.to_device(device) + torch.manual_seed(42) # for reproducibility + data = torch.randint(0, num_classes, (32, 5)).to(device) + # Create time tensor + T = 500 + time = d3pm.sample_time(32, device=device) * 0 + T + # Create a mock model that outputs logits + logits = torch.zeros((32, 5, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(2, data.unsqueeze(-1), 1000) + # Sample noise + noise = d3pm.sample_prior(data.shape, device=device) + # Create model output and xt + model_out = logits # torch.softmax(logits, dim=-1) + xt = data.clone() + xt[:, 0] = noise[:, 0] + # Take a step + next_xt = d3pm.step(model_out, time, xt) + # Assert shapes + assert next_xt.shape == data.shape + model_out_onehot = torch.nn.functional.one_hot( + model_out.argmax(-1), num_classes=num_classes + ).float() # (B, N, num_classes) + nll = -torch.sum(torch.log(model_out_onehot.view(-1, num_classes) + 1e-8).gather(1, data.view(-1, 1)).squeeze(1)) + assert nll < 1e-10 + loss = d3pm.loss(logits, data, xt, time).mean() + assert loss.item() == 0 + loss = d3pm.loss(logits, data, xt, time, vb_scale=0.5).mean() + assert loss.item() < 1.0e-1 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_discrete_noise_schedule.py b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_discrete_noise_schedule.py new file mode 100644 index 0000000000..7ddcc7adfd --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_discrete_noise_schedule.py @@ -0,0 +1,64 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch + +from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule +from bionemo.moco.schedules.utils import TimeDirection + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cosine_schedule(timesteps, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + scheduler = DiscreteCosineNoiseSchedule(timesteps) + schedule = scheduler.generate_schedule(device=device) + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("synchronize", [TimeDirection.DIFFUSION, TimeDirection.UNIFIED]) +def test_cosine_schedule_direction(timesteps, device, synchronize): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + scheduler = DiscreteCosineNoiseSchedule(timesteps) + # import ipdb; ipdb.set_trace() + schedule = scheduler.generate_schedule(device=device, synchronize=synchronize) + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,), f"Expected schedule shape to be {(timesteps,)}, but got {schedule.shape}" + # Check if schedule is on the correct device + assert ( + schedule.device.type == device + ), f"Expected schedule to be on device '{device}', but got '{schedule.device.type}'" + # Check if the schedule is in the correct direction + + if synchronize == TimeDirection.UNIFIED: + assert ( + schedule[0] < schedule[-1] + ), f"Expected schedule to be in increasing order when synchronized, but got {schedule[0]} >= {schedule[-1]}" + else: + assert ( + schedule[0] > schedule[-1] + ), f"Expected schedule to be in decreasing order when not synchronized, but got {schedule[0]} <= {schedule[-1]}" diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_continuous_noise_transforms.py b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_continuous_noise_transforms.py new file mode 100644 index 0000000000..f495fe8142 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_continuous_noise_transforms.py @@ -0,0 +1,73 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch + +from bionemo.moco import TimeDirection +from bionemo.moco.schedules.noise.continuous_noise_transforms import ( + CosineExpNoiseTransform, + LogLinearExpNoiseTransform, +) + + +class TestContinuousNoiseTransforms: + @pytest.mark.parametrize("transform_cls", [CosineExpNoiseTransform, LogLinearExpNoiseTransform]) + def test_init(self, transform_cls): + transform = transform_cls() + assert transform.direction == TimeDirection.DIFFUSION + + @pytest.mark.parametrize("transform_cls", [CosineExpNoiseTransform, LogLinearExpNoiseTransform]) + def test_calculate_sigma(self, transform_cls): + transform = transform_cls() + t = torch.linspace(0, 1, 10) + sigma = transform.calculate_sigma(t) + assert sigma.shape == t.shape + assert (sigma >= 0).all() + + @pytest.mark.parametrize("transform_cls", [CosineExpNoiseTransform, LogLinearExpNoiseTransform]) + def test_calculate_sigma_invalid_input(self, transform_cls): + transform = transform_cls() + t = torch.tensor([1.1, 2.2]) # invalid input, max value > 1 + with pytest.raises(ValueError): + transform.calculate_sigma(t) + + @pytest.mark.parametrize("transform_cls", [CosineExpNoiseTransform, LogLinearExpNoiseTransform]) + def test_sigma_to_alpha(self, transform_cls): + transform = transform_cls() + sigma = torch.linspace(0.1, 1.0, 10) + alpha = transform.sigma_to_alpha(sigma) + assert alpha.shape == sigma.shape + assert (alpha >= 0).all() + + @pytest.mark.parametrize("transform_cls", [CosineExpNoiseTransform, LogLinearExpNoiseTransform]) + def test_d_dt_sigma(self, transform_cls): + transform = transform_cls() + t = torch.linspace(0, 1, 10) + derivative = transform.d_dt_sigma(t) + assert derivative.shape == t.shape + + def test_cosine_transform(self): + transform = CosineExpNoiseTransform() + t = torch.linspace(0, 1, 10) + sigma = transform.calculate_sigma(t) + assert torch.allclose(sigma, -torch.log(1e-3 + (1 - 1e-3) * torch.cos(t * torch.pi / 2))) + + def test_loglinear_transform(self): + transform = LogLinearExpNoiseTransform() + t = torch.linspace(0, 1, 10) + sigma = transform.calculate_sigma(t) + assert torch.allclose(sigma, -torch.log1p(-(1 - 1e-3) * t)) diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_continuous_snr_transforms.py b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_continuous_snr_transforms.py new file mode 100644 index 0000000000..d9633a2eee --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_continuous_snr_transforms.py @@ -0,0 +1,127 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch + +from bionemo.moco.schedules.noise.continuous_snr_transforms import ( + CosineSNRTransform, + LinearLogInterpolatedSNRTransform, + LinearSNRTransform, + TimeDirection, +) + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("synchronize", [TimeDirection.DIFFUSION, TimeDirection.UNIFIED]) +def test_cosine_snr_transform(timesteps, device, synchronize): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + t = torch.linspace(0, 1, timesteps, device=device) + snr_transform = CosineSNRTransform() + + log_snr = snr_transform.calculate_log_snr(t, device=device, synchronize=synchronize) + + # Check if log_snr has the correct shape + assert log_snr.shape == (timesteps,) + # Check if log_snr is on the correct device + assert log_snr.device.type == device + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("synchronize", [TimeDirection.DIFFUSION, TimeDirection.UNIFIED]) +def test_linear_snr_transform(timesteps, device, synchronize): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + t = torch.linspace(0, 1, timesteps, device=device) + snr_transform = LinearSNRTransform() + + log_snr = snr_transform.calculate_log_snr(t, device=device, synchronize=synchronize) + + # Check if log_snr has the correct shape + assert log_snr.shape == (timesteps,) + # Check if log_snr is on the correct device + assert log_snr.device.type == device + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("synchronize", [TimeDirection.DIFFUSION, TimeDirection.UNIFIED]) +def test_linear_log_interpolated_snr_transform(timesteps, device, synchronize): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + t = torch.linspace(0, 1, timesteps, device=device) + snr_transform = LinearLogInterpolatedSNRTransform() + + log_snr = snr_transform.calculate_log_snr(t, device=device, synchronize=synchronize) + + # Check if log_snr has the correct shape + assert log_snr.shape == (timesteps,) + # Check if log_snr is on the correct device + assert log_snr.device.type == device + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cosine_snr_transform_alpha(device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + t = torch.tensor(0.5, device=device) + snr_transform = CosineSNRTransform() + + log_snr = snr_transform.calculate_log_snr(t, device=device) + alpha = snr_transform.calculate_alpha_log_snr(log_snr) + + # Check if alpha is a valid value + assert alpha > 0 + assert alpha <= 1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_linear_snr_transform_alpha(device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + t = torch.tensor(0.5, device=device) + snr_transform = LinearSNRTransform() + + log_snr = snr_transform.calculate_log_snr(t, device=device) + alpha = snr_transform.calculate_alpha_log_snr(log_snr) + + # Check if alpha is a valid value + assert alpha > 0 + assert alpha <= 1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_linear_log_interpolated_snr_transform_alpha(device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + t = torch.tensor(0.5, device=device) + snr_transform = LinearLogInterpolatedSNRTransform() + + log_snr = snr_transform.calculate_log_snr(t, device=device) + alpha = snr_transform.calculate_alpha_log_snr(log_snr) + + # Check if alpha is a valid value + assert alpha > 0 + assert alpha <= 1 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_discrete_noise_schedules.py b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_discrete_noise_schedules.py new file mode 100644 index 0000000000..9eb048da0f --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_discrete_noise_schedules.py @@ -0,0 +1,62 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch + +from bionemo.moco.schedules.discrete_noise_schedules import DiscreteCosineNoiseSchedule, TimeDirection + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cosine_schedule(timesteps, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + scheduler = DiscreteCosineNoiseSchedule(timesteps) + schedule = scheduler.generate_schedule(device=device) + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("synchronize", [TimeDirection.DIFFUSION, TimeDirection.UNIFIED]) +def test_cosine_schedule_direction(timesteps, device, synchronize): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + scheduler = DiscreteCosineNoiseSchedule(timesteps) + schedule = scheduler.generate_schedule(device=device, synchronize=synchronize) + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,), f"Expected schedule shape to be {(timesteps,)}, but got {schedule.shape}" + # Check if schedule is on the correct device + assert ( + schedule.device.type == device + ), f"Expected schedule to be on device '{device}', but got '{schedule.device.type}'" + # Check if the schedule is in the correct direction + if synchronize == TimeDirection.UNIFIED: + assert ( + schedule[0] < schedule[-1] + ), f"Expected schedule to be in increasing order when synchronized, but got {schedule[0]} >= {schedule[-1]}" + else: + assert ( + schedule[0] > schedule[-1] + ), f"Expected schedule to be in decreasing order when not synchronized, but got {schedule[0]} <= {schedule[-1]}" diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_inference_schedules.py b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_inference_schedules.py new file mode 100644 index 0000000000..d509391df6 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_inference_schedules.py @@ -0,0 +1,162 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import pytest +import torch + +from bionemo.moco.schedules.inference_time_schedules import ( + DiscreteLinearInferenceSchedule, + LinearInferenceSchedule, + LogInferenceSchedule, + PowerInferenceSchedule, +) +from bionemo.moco.schedules.utils import TimeDirection + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("direction", [TimeDirection.UNIFIED, TimeDirection.DIFFUSION]) +def test_uniform_dt(timesteps, device, direction): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + scheduler = LinearInferenceSchedule(timesteps, direction=direction) + dt = scheduler.discretize(device=device) + schedule = scheduler.generate_schedule(device=device) + + # Check if all dt's are equal to 1/timesteps + assert torch.allclose(dt, torch.ones_like(dt) / timesteps) + assert dt.device.type == device + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if dt has the correct shape + assert dt.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + if direction == TimeDirection.UNIFIED: + assert schedule[0] < schedule[-1] + else: + assert schedule[0] > schedule[-1] + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("power", [0.5, 1.5, 2.0]) +@pytest.mark.parametrize("direction", [TimeDirection.UNIFIED, TimeDirection.DIFFUSION]) +def test_power_dt(timesteps, device, power, direction): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + scheduler = PowerInferenceSchedule(timesteps, exponent=power, direction=direction) + dt = scheduler.discretize(device=device) + schedule = scheduler.generate_schedule(device=device) + + assert dt.device.type == device + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if dt has the correct shape + assert dt.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + if direction == TimeDirection.UNIFIED: + assert schedule[0] < schedule[-1] + else: + assert schedule[0] > schedule[-1] + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("direction", [TimeDirection.UNIFIED, TimeDirection.DIFFUSION]) +def test_log_dt(timesteps, device, direction): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + scheduler = LogInferenceSchedule(timesteps, exponent=-2, direction=direction) + dt = scheduler.discretize(device=device) + schedule = scheduler.generate_schedule(device=device) + + assert dt.device.type == device + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if dt has the correct shape + assert dt.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + if direction == TimeDirection.UNIFIED: + assert schedule[0] < schedule[-1] and schedule[0] == 0 + else: + assert schedule[0] > schedule[-1] and schedule[0] == 1 + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("direction", [TimeDirection.UNIFIED, TimeDirection.DIFFUSION]) +def test_discrete_uniform_dt(timesteps, device, direction): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + scheduler = DiscreteLinearInferenceSchedule(timesteps, direction=direction) + dt = scheduler.discretize(device=device) + schedule = scheduler.generate_schedule(device=device) + + assert dt.device.type == device + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if dt has the correct shape + assert dt.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + # Additional checks specific to DiscreteUniformInferenceSchedule + assert torch.all(dt == torch.full((timesteps,), 1 / timesteps, device=device)) + if direction == TimeDirection.UNIFIED: + assert schedule[0] < schedule[-1] + else: + assert schedule[0] > schedule[-1] + + +@pytest.mark.parametrize("timesteps", [10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("direction", [TimeDirection.UNIFIED, TimeDirection.DIFFUSION]) +@pytest.mark.parametrize("padding", [0, 2]) +@pytest.mark.parametrize("dilation", [0, 1]) +def test_uniform_dt_padding_dilation(timesteps, device, direction, padding, dilation): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + scheduler = LinearInferenceSchedule(timesteps, padding=padding, dilation=dilation, direction=direction) + dt = scheduler.discretize(device=device) + schedule = scheduler.generate_schedule(device=device) + + # Check if all dt's are equal to 1/timesteps + assert dt.device.type == device + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if dt has the correct shape + assert dt.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + if direction == TimeDirection.UNIFIED: + assert schedule[0] < schedule[-1] + for i in range(padding): + assert schedule[-1 * (i + 1)] == 1.0 + else: + assert schedule[0] > schedule[-1] + for i in range(padding): + assert schedule[-1 * (i + 1)] == 0 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/test_env.py b/sub-packages/bionemo-moco/tests/bionemo/moco/test_env.py new file mode 100644 index 0000000000..0b60811790 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/test_env.py @@ -0,0 +1,51 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import torch +import torch.nn as nn + + +def test_torch_import(): + assert torch is not None + + +def test_gpu_availability(): + assert torch.cuda.is_available() + + +def test_tensor_creation_on_gpu(): + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + tensor = torch.randn(2, 2, device=device) + assert tensor.is_cuda + + +def test_loss_calculation(): + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + input_tensor = torch.randn(2, 2, device=device) + target_tensor = torch.randn(2, 2, device=device) + criterion = nn.MSELoss() + loss = criterion(input_tensor, target_tensor) + assert loss is not None + + +def test_backpropagation(): + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + input_tensor = torch.randn(2, 2, device=device, requires_grad=True) + target_tensor = torch.randn(2, 2, device=device) + criterion = nn.MSELoss() + loss = criterion(input_tensor, target_tensor) + loss.backward() + assert input_tensor.grad is not None