pax_global_header 0000666 0000000 0000000 00000000064 14643672530 0014524 g ustar 00root root 0000000 0000000 52 comment=34a6e9aa4b824142078af00e6d6fd96e296bebf0
jmschrei-pomegranate-8de2be8/ 0000775 0000000 0000000 00000000000 14643672530 0016333 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/.github/ 0000775 0000000 0000000 00000000000 14643672530 0017673 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/.github/ISSUE_TEMPLATE/ 0000775 0000000 0000000 00000000000 14643672530 0022056 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/.github/ISSUE_TEMPLATE/bug_report.md 0000664 0000000 0000000 00000001471 14643672530 0024553 0 ustar 00root root 0000000 0000000 ---
name: Bug report
about: Create a report to help us improve
title: "[BUG]"
labels: ''
assignees: ''
---
**Describe the bug**
A clear and concise description of what the bug is, including what you were expecting to happen and what actually happened. Please report the version of pomegranate that you are using and the operating system. Also, please make sure that you have upgraded to the latest version of pomegranate before submitting the bug report.
**To Reproduce**
Please provide a snippet of code that can reproduce this error. It is much easier for us to track down bugs and fix them if we have an example script that fails until we're successful.
**Response time**
Although I will likely respond during weekdays if I am not on vacation, I am not likely to be able to merge PRs or write code until the weekend.
jmschrei-pomegranate-8de2be8/.github/workflows/ 0000775 0000000 0000000 00000000000 14643672530 0021730 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/.github/workflows/python-package.yml 0000664 0000000 0000000 00000003126 14643672530 0025367 0 ustar 00root root 0000000 0000000 # This workflow will install Python dependencies, run tests and lint with a variety of Python versions
# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
name: build
on:
push:
branches: [ master ]
pull_request:
branches: [ master ]
jobs:
build:
name: ${{ matrix.os }} Python ${{ matrix.python-version }}
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-latest, macOS-latest]
python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
steps:
- uses: actions/checkout@v3
- name: Set up Python ${{ matrix.os }} ${{ matrix.python-version }}
uses: actions/setup-python@v3
with:
python-version: ${{ matrix.python-version }}
- name: Install dependencies
run: |
python -m pip install --upgrade pip
python -m pip install flake8 pytest
pip install -r requirements.txt
- name: Lint with flake8
run: |
# stop the build if there are Python syntax errors or undefined names
flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
# exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
- name: Test with pytest
run: |
pytest -m "not sample" jmschrei-pomegranate-8de2be8/.gitignore 0000664 0000000 0000000 00000000164 14643672530 0020324 0 ustar 00root root 0000000 0000000 *.pyc
*.c
.ipynb_checkpoints
*~
.DS_Store
build
*.so
.idea/
.vscode/
dist/
.eggs/
*.egg-info/
*.pyd
.python-version
jmschrei-pomegranate-8de2be8/.readthedocs.yaml 0000664 0000000 0000000 00000000766 14643672530 0021573 0 ustar 00root root 0000000 0000000 # .readthedocs.yaml
# Read the Docs configuration file
# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
# Required
version: 2
# Set the version of Python and other tools you might need
build:
os: ubuntu-22.04
tools:
python: "3.10"
# Build documentation in the docs/ directory with Sphinx
sphinx:
configuration: docs/conf.py
# Optionally declare the Python requirements required to build your docs
python:
install:
- requirements: docs/requirements.txt
jmschrei-pomegranate-8de2be8/LICENSE 0000664 0000000 0000000 00000002060 14643672530 0017336 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2022 Jacob Schreiber
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.
jmschrei-pomegranate-8de2be8/README.md 0000664 0000000 0000000 00000032300 14643672530 0017610 0 ustar 00root root 0000000 0000000
[](https://pepy.tech/project/pomegranate)  
> **Note**
> IMPORTANT: pomegranate v1.0.0 is a ground-up rewrite of pomegranate using PyTorch as the computational backend instead of Cython. Although the same functionality is supported, the API is significantly different. Please see the tutorials and examples folders for help rewriting your code.
[ReadTheDocs](https://pomegranate.readthedocs.io/en/latest/) | [Tutorials](https://github.com/jmschrei/pomegranate/tree/master/docs/tutorials) | [Examples](https://github.com/jmschrei/pomegranate/tree/master/examples)
pomegranate is a library for probabilistic modeling defined by its modular implementation and treatment of all models as the probability distributions they are. The modular implementation allows one to easily drop normal distributions into a mixture model to create a Gaussian mixture model just as easily as dropping a gamma and a Poisson distribution into a mixture model to create a heterogeneous mixture. But that's not all! Because each model is treated as a probability distribution, Bayesian networks can be dropped into a mixture just as easily as a normal distribution, and hidden Markov models can be dropped into Bayes classifiers to make a classifier over sequences. Together, these two design choices enable a flexibility not seen in any other probabilistic modeling package.
Recently, pomegranate (v1.0.0) was rewritten from the ground up using PyTorch to replace the outdated Cython backend. This rewrite gave me an opportunity to fix many bad design choices that I made as a bb software engineer. Unfortunately, many of these changes are not backwards compatible and will disrupt workflows. On the flip side, these changes have significantly sped up most methods, improved and simplified the code, fixed many issues raised by the community over the years, and made it significantly easier to contribute. I've written more below, but you're likely here now because your code is broken and this is the tl;dr.
Special shout-out to [NumFOCUS](https://numfocus.org/) for supporting this work with a special development grant.
### Installation
`pip install pomegranate`
If you need the last Cython release before the rewrite, use `pip install pomegranate==0.14.8`. You may need to manually install a version of Cython before v3.
### Why a Rewrite?
This rewrite was motivated by four main reasons:
- Speed: Native PyTorch is usually significantly faster than the hand-tuned Cython code that I wrote.
- Features: PyTorch has many features, such as serialization, mixed precision, and GPU support, that can now be directly used in pomegranate without additional work on my end.
- Community Contribution: A challenge that many people faced when using pomegranate was that they could not modify or extend it because they did not know Cython. Even if they did know Cython, coding in it is a pain that I felt each time I tried adding a new feature or fixing a bug or releasing a new version. Using PyTorch as the backend significantly reduces the amount of effort needed to add in new features.
- Interoperability: Libraries like PyTorch offer an invaluable opportunity to not just utilize their computational backends but to better integrate into existing resources and communities. This rewrite will make it easier for people to integrate probabilistic models with neural networks as losses, constraints, and structural regularizations, as well as with other projects built on PyTorch.
### High-level Changes
1. General
- The entire codebase has been rewritten in PyTorch and all models are instances of `torch.nn.Module`
- This codebase is checked by a comprehensive suite of >800 unit tests calling assert statements several thousand times, much more than previous versions.
- Installation issues are now likely to come from PyTorch for which there are countless resources to help out.
2. Features
- All models now have GPU support
- All models now have support for half/mixed precision
- Serialization is now handled by PyTorch, yielding more compact and efficient I/O
- Missing values are now supported through `torch.masked.MaskedTensor` objects
- Prior probabilities can now be passed to all relevant models and methods and enable more comprehensive/flexible semi-supervised learning than before
3. Models
- All distributions are now multivariate by default and treat each feature independently (except Normal)
- "Distribution" has been removed from names so that, for example, `NormalDistribution` is now `Normal`
- `FactorGraph` is now supported as first-class citizens, with all the prediction and training methods
- Hidden Markov models have been split into `DenseHMM` and `SparseHMM` models which differ in how the transition matrix is encoded, with `DenseHMM` objects being significantly faster on truly dense graphs
4. Differences
- `NaiveBayes` has been permanently removed as it is redundant with `BayesClassifier`
- `MarkovNetwork` has not yet been implemented
- Constraint graphs and constrained structure learning for Bayesian networks has not yet been implemented
- Silent states for hidden Markov models have not yet been implemented
- Viterbi for hidden Markov models has not yet been implemented
## Speed
Most models and methods in pomegranate v1.0.0 are faster than their counterparts in earlier versions. This generally scales by complexity, where one sees only small speedups for simple distributions on small data sets but much larger speedups for more complex models on big data sets, e.g. hidden Markov model training or Bayesian network inference. The notable exception for now is that Bayesian network structure learning, other than Chow-Liu tree building, is still incomplete and not much faster. In the examples below, `torchegranate` refers to the temporarily repository used to develop pomegranate v1.0.0 and `pomegranate` refers to pomegranate v0.14.8.
### K-Means
Who knows what's happening here? Wild.
### Hidden Markov Models
Dense transition matrix (CPU)
Sparse transition matrix (CPU)
Training a 125 node model with a dense transition matrix
### Bayesian Networks
## Features
> **Note**
> Please see the [tutorials](https://github.com/jmschrei/pomegranate/tree/master/docs/tutorials) folder for code examples.
Switching from a Cython backend to a PyTorch backend has enabled or expanded a large number of features. Because the rewrite is a thin wrapper over PyTorch, as new features get released for PyTorch they can be applied to pomegranate models without the need for a new release from me.
### GPU Support
All distributions and methods in pomegranate now have GPU support. Because each distribution is a `torch.nn.Module` object, the use is identical to other code written in PyTorch. This means that both the model and the data have to be moved to the GPU by the user. For instance:
```python
>>> X = torch.exp(torch.randn(50, 4))
# Will execute on the CPU
>>> d = Exponential().fit(X)
>>> d.scales
Parameter containing:
tensor([1.8627, 1.3132, 1.7187, 1.4957])
# Will execute on a GPU
>>> d = Exponential().cuda().fit(X.cuda())
>>> d.scales
Parameter containing:
tensor([1.8627, 1.3132, 1.7187, 1.4957], device='cuda:0')
```
Likewise, all models are distributions, and so can be used on the GPU similarly. When a model is moved to the GPU, all of the models associated with it (e.g. distributions) are also moved to the GPU.
```python
>>> X = torch.exp(torch.randn(50, 4)).cuda()
>>> model = GeneralMixtureModel([Exponential(), Exponential()]).cuda()
>>> model.fit(X)
[1] Improvement: 1.26068115234375, Time: 0.001134s
[2] Improvement: 0.168121337890625, Time: 0.001097s
[3] Improvement: 0.037841796875, Time: 0.001095s
>>> model.distributions[0].scales
Parameter containing:
>>> model.distributions[1].scales
tensor([0.9141, 1.0835, 2.7503, 2.2475], device='cuda:0')
Parameter containing:
tensor([1.9902, 2.3871, 0.8984, 1.2215], device='cuda:0')
```
### Mixed Precision
pomegranate models can, in theory, operate in the same mixed or low-precision regimes as other PyTorch modules. However, because pomegranate uses more complex operations than most neural networks, this sometimes does not work or help in practice because these operations have not been optimized or implemented in the low-precision regime. So, hopefully this feature will become more useful over time.
```python
>>> X = torch.randn(100, 4)
>>> d = Normal(covariance_type='diag')
>>>
>>> with torch.autocast('cuda', dtype=torch.bfloat16):
>>> d.fit(X)
```
### Serialization
pomegranate distributions are all instances of `torch.nn.Module` and so serialization is the same as any other PyTorch model.
Saving:
```python
>>> X = torch.exp(torch.randn(50, 4)).cuda()
>>> model = GeneralMixtureModel([Exponential(), Exponential()], verbose=True)
>>> model.cuda()
>>> model.fit(X)
>>> torch.save(model, "test.torch")
```
Loading:
```python
>>> model = torch.load("test.torch")
```
### torch.compile
> **Note**
> `torch.compile` is under active development by the PyTorch team and may rapidly improve. For now, you may need to pass in `check_data=False` when initializing models to avoid one compatibility issue.
In PyTorch v2.0.0, `torch.compile` was introduced as a flexible wrapper around tools that would fuse operations together, use CUDA graphs, and generally try to remove I/O bottlenecks in GPU execution. Because these bottlenecks can be extremely significant in the small-to-medium sized data settings many pomegranate users are faced with, `torch.compile` seems like it will be extremely valuable. Rather than targeting entire models, which mostly just compiles the `forward` method, you should compile individual methods from your objects.
```python
# Create your object as normal
>>> mu = torch.exp(torch.randn(100))
>>> d = Exponential(mu).cuda()
# Create some data
>>> X = torch.exp(torch.randn(1000, 100))
>>> d.log_probability(X)
# Compile the `log_probability` method!
>>> d.log_probability = torch.compile(d.log_probability, mode='reduce-overhead', fullgraph=True)
>>> d.log_probability(X)
```
Unfortunately, I have had difficulty getting `torch.compile` to work when methods are called in a nested manner, e.g., when compiling the `predict` method for a mixture model which, inside it, calls the `log_probability` method of each distribution. I have tried to organize the code in a manner that avoids some of these errors, but because the error messages right now are opaque I have had some difficulty.
### Missing Values
pomegranate supports handling data with missing values through `torch.masked.MaskedTensor` objects. Simply, one needs to just put a mask over the values that are missing.
```python
>>> X =
>>> mask = ~torch.isnan(X)
>>> X_masked = torch.masked.MaskedTensor(X, mask=mask)
>>> d = Normal(covariance_type='diag').fit(X_masked)
>>> d.means
Parameter containing:
tensor([0.2271, 0.0290, 0.0763, 0.0135])
```
All algorithms currently treat missingness as something to ignore. As an example, when calculating the mean of a column with missing values, the mean will simply be the average value of the present values. Missing values are not imputed because improper imputation can bias your data, produce unlikely estimates which distort distributions, and also shrink the variance.
Because not all operations are yet available for MaskedTensors, the following distributions are not yet supported for missing values: Bernoulli, categorical, normal with full covariance, uniform
### Prior Probabilities and Semi-supervised Learning
A new feature in pomegranate v1.0.0 is being able to pass in prior probabilities for each observation for mixture models, Bayes classifiers, and hidden Markov models. These are the prior probability that an observation belongs to a component of the model before evaluating the likelihood and should range between 0 and 1. When these values include a 1.0 for an observation, it is treated as a label, because the likelihood no longer matters in terms of assigning that observation to a state. Hence, one can use these prior probabilities to do labeled training when each observation has a 1.0 for some state, semi-supervised learning when a subset of observations (including when sequences are only partially labeled for hidden Markov models), or more sophisticated forms of weighting when the values are between 0 and 1.
jmschrei-pomegranate-8de2be8/benchmarks/ 0000775 0000000 0000000 00000000000 14643672530 0020450 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/benchmarks/Benchmark_1_Distributions.ipynb 0000664 0000000 0000000 00000015002 14643672530 0026545 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "6bc2e9e8",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"numpy : 1.23.4\n",
"scipy : 1.9.3\n",
"torch : 1.12.1\n",
"pomegranate: 0.14.8\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-197-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"import numpy\n",
"import scipy\n",
"import torch\n",
"\n",
"from torchegranate.distributions import *\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p numpy,scipy,torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "7dd56360",
"metadata": {},
"source": [
"### Normal w/ Diagonal Covariance Distributions"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "5efcc291",
"metadata": {},
"outputs": [],
"source": [
"n, d = 100000, 500\n",
"\n",
"X = torch.randn(n, d)\n",
"Xn = X.numpy()\n",
"\n",
"mus = torch.randn(d)\n",
"covs = torch.abs(torch.randn(d))\n",
"stds = torch.sqrt(covs)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "1c3325d9",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"143 ms ± 12.5 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
"227 ms ± 14.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"1.12 s ± 18.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
}
],
"source": [
"%timeit Normal(mus, covs, covariance_type='diag').log_probability(X)\n",
"%timeit torch.distributions.Normal(mus, stds).log_prob(X).sum(dim=-1)\n",
"%timeit scipy.stats.norm.logpdf(Xn, mus, stds).sum(axis=1)"
]
},
{
"cell_type": "markdown",
"id": "bd46b4b0",
"metadata": {},
"source": [
"### Normal w/ Full Covariance Distribution"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "07fab284",
"metadata": {},
"outputs": [],
"source": [
"d0 = Normal().fit(X)\n",
"\n",
"mu, cov = d0.means, d0.covs"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "194d7679",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"211 ms ± 19.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"205 ms ± 22.3 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
"765 ms ± 36.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
}
],
"source": [
"%timeit Normal(mu, cov).log_probability(X)\n",
"%timeit torch.distributions.MultivariateNormal(mu, cov).log_prob(X).sum(dim=-1)\n",
"%timeit scipy.stats.multivariate_normal.logpdf(Xn, mu, cov).sum(axis=-1)"
]
},
{
"cell_type": "markdown",
"id": "1a5adc6a",
"metadata": {},
"source": [
"### Exponential Distribution"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "f70bb98d",
"metadata": {},
"outputs": [],
"source": [
"X = torch.abs(torch.randn(n, d))\n",
"Xn = X.numpy()\n",
"\n",
"means = torch.abs(torch.randn(d))"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "ab3d0af3",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"150 ms ± 1.31 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
"89 ms ± 3.47 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
"1.36 s ± 86.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
}
],
"source": [
"%timeit Exponential(means).log_probability(X)\n",
"%timeit torch.distributions.Exponential(means).log_prob(X)\n",
"%timeit scipy.stats.expon.logpdf(X, means)"
]
},
{
"cell_type": "markdown",
"id": "5108fce5",
"metadata": {},
"source": [
"### Gamma Distribution"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "06865521",
"metadata": {},
"outputs": [],
"source": [
"shapes = torch.abs(torch.randn(d))\n",
"rates = torch.abs(torch.randn(d))"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "2459f3f0",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"270 ms ± 9.09 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"250 ms ± 30.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"2.67 s ± 75.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
}
],
"source": [
"%timeit Gamma(shapes, rates).log_probability(X)\n",
"%timeit torch.distributions.Gamma(shapes, rates).log_prob(X)\n",
"%timeit scipy.stats.gamma.logpdf(X, shapes, rates)"
]
},
{
"cell_type": "markdown",
"id": "c81f8f06",
"metadata": {},
"source": [
"### Bernoulli Distribution"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "7cee5e63",
"metadata": {},
"outputs": [],
"source": [
"X = torch.tensor(numpy.random.choice(2, size=(n, d)), dtype=torch.float32)\n",
"probs = torch.mean(X, dim=0)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "0f697993",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"181 ms ± 8.04 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
"419 ms ± 20.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"3.78 s ± 66.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
}
],
"source": [
"%timeit Bernoulli(probs).log_probability(X)\n",
"%timeit torch.distributions.Bernoulli(probs).log_prob(X)\n",
"%timeit scipy.stats.bernoulli.logpmf(X, probs)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/benchmarks/Benchmark_2_General_Mixture_Models.ipynb 0000664 0000000 0000000 00000347164 14643672530 0030322 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "23e5667c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"numpy : 1.23.4\n",
"scipy : 1.9.3\n",
"torch : 1.12.1\n",
"pomegranate: 0.14.8\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-197-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"import numpy\n",
"import scipy\n",
"import torch\n",
"\n",
"from sklearn.datasets import make_blobs\n",
"from torchegranate.distributions import *\n",
"\n",
"from sklearn.mixture import GaussianMixture\n",
"from torchegranate.gmm import GeneralMixtureModel\n",
"\n",
"import matplotlib.pyplot as plt\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p numpy,scipy,torch,pomegranate"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "1cbdc77a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"n, d, k = 200000, 2, 8\n",
"\n",
"X, _ = make_blobs(n_samples=n, n_features=d, centers=k, cluster_std=0.75, random_state=0)\n",
"\n",
"plt.scatter(*X[:,:2].T, s=3)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "236be605",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"Exception ignored on calling ctypes callback function: .match_module_callback at 0x7f0b0f857ee0>\n",
"Traceback (most recent call last):\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 400, in match_module_callback\n",
" self._make_module_from_path(filepath)\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 515, in _make_module_from_path\n",
" module = module_class(filepath, prefix, user_api, internal_api)\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 606, in __init__\n",
" self.version = self.get_version()\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 646, in get_version\n",
" config = get_config().split()\n",
"AttributeError: 'NoneType' object has no attribute 'split'\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"2.47 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
"1.38 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
]
}
],
"source": [
"means = X[numpy.random.choice(X.shape[0], replace=False, size=k)]\n",
"means2 = numpy.copy(means)\n",
"\n",
"covs = numpy.array([numpy.eye(d) for i in range(k)])\n",
"covs2 = numpy.copy(covs)\n",
"\n",
"priors = numpy.ones(k) / k\n",
"\n",
"%timeit -n 1 -r 1 GaussianMixture(k, tol=1e-2, max_iter=20, means_init=means, precisions_init=covs, weights_init=priors).fit(X)\n",
"%timeit -n 1 -r 1 GeneralMixtureModel([Normal(means2[i], covs2[i]) for i in range(k)], tol=1e-2, max_iter=20, init='random').fit(X)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "54316b85",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"Exception ignored on calling ctypes callback function: .match_module_callback at 0x7f0b3c27e4c0>\n",
"Traceback (most recent call last):\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 400, in match_module_callback\n",
" self._make_module_from_path(filepath)\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 515, in _make_module_from_path\n",
" module = module_class(filepath, prefix, user_api, internal_api)\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 606, in __init__\n",
" self.version = self.get_version()\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 646, in get_version\n",
" config = get_config().split()\n",
"AttributeError: 'NoneType' object has no attribute 'split'\n"
]
}
],
"source": [
"means = X[numpy.random.choice(X.shape[0], replace=False, size=k)]\n",
"means2 = numpy.copy(means)\n",
"\n",
"covs = numpy.array([numpy.eye(d) for i in range(k)])\n",
"covs2 = numpy.copy(covs)\n",
"\n",
"priors = numpy.ones(k) / k\n",
"\n",
"model_sklearn = GaussianMixture(k, tol=1e-2, max_iter=20, means_init=means, precisions_init=covs, weights_init=priors).fit(X)\n",
"model_pom = GeneralMixtureModel([Normal(means[i], covs[i]) for i in range(k)], tol=1e-2, max_iter=20).fit(X)\n",
"\n",
"y_hat_sklearn = model_sklearn.predict(X)\n",
"y_hat_pom = model_pom.predict(X)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "7d4dc4bb",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.figure(figsize=(14, 5))\n",
"\n",
"plt.subplot(121)\n",
"for i in range(k):\n",
" plt.scatter(*X[y_hat_sklearn == i].T, s=3)\n",
" plt.scatter([model_sklearn.means_[i, 0]], [model_sklearn.means_[i, 1]])\n",
"\n",
"plt.subplot(122)\n",
"for i in range(k):\n",
" plt.scatter(*X[y_hat_pom == i].T, s=3)\n",
" plt.scatter([model_pom.distributions[i].means[0]], [model_pom.distributions[i].means[1]])"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "5e4e5bf9",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"Exception ignored on calling ctypes callback function: .match_module_callback at 0x7f0b0f8afd30>\n",
"Traceback (most recent call last):\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 400, in match_module_callback\n",
" self._make_module_from_path(filepath)\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 515, in _make_module_from_path\n",
" module = module_class(filepath, prefix, user_api, internal_api)\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 606, in __init__\n",
" self.version = self.get_version()\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 646, in get_version\n",
" config = get_config().split()\n",
"AttributeError: 'NoneType' object has no attribute 'split'\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"10.1 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
"6.31 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
]
}
],
"source": [
"n, d, k = 200000, 25, 8\n",
"\n",
"X, _ = make_blobs(n_samples=n, n_features=d, centers=k, cluster_std=0.75, random_state=0)\n",
"\n",
"means = X[numpy.random.choice(X.shape[0], replace=False, size=k)]\n",
"means2 = numpy.copy(means)\n",
"\n",
"covs = numpy.array([numpy.eye(d) for i in range(k)])\n",
"covs2 = numpy.copy(covs)\n",
"\n",
"priors = numpy.ones(k) / k\n",
"\n",
"%timeit -n 1 -r 1 GaussianMixture(k, tol=1e-2, max_iter=20, means_init=means, precisions_init=covs, weights_init=priors).fit(X)\n",
"%timeit -n 1 -r 1 GeneralMixtureModel([Normal(means2[i], covs2[i]) for i in range(k)], tol=1e-2, max_iter=20, init='random').fit(X)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/benchmarks/Benchmark_3_KMeans.ipynb 0000664 0000000 0000000 00000761251 14643672530 0025101 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "3b1a4c97",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"numpy : 1.23.4\n",
"scipy : 1.9.3\n",
"torch : 1.12.1\n",
"pomegranate: 0.14.8\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-197-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"import numpy\n",
"import scipy\n",
"import torch\n",
"\n",
"from sklearn.datasets import make_blobs\n",
"\n",
"from sklearn.cluster import KMeans\n",
"from torchegranate.kmeans import KMeans as KMeans2\n",
"\n",
"import matplotlib.pyplot as plt\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p numpy,scipy,torch,pomegranate"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "ca364a44",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"n, d, k = 100000, 250, 25\n",
"\n",
"X, _ = make_blobs(n_samples=n, n_features=d, centers=k, cluster_std=0.75, random_state=0)\n",
"\n",
"plt.scatter(*X[:,:2].T, s=3)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "59bd2bd4",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"Exception ignored on calling ctypes callback function: .match_module_callback at 0x7efd20a478b0>\n",
"Traceback (most recent call last):\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 400, in match_module_callback\n",
" self._make_module_from_path(filepath)\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 515, in _make_module_from_path\n",
" module = module_class(filepath, prefix, user_api, internal_api)\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 606, in __init__\n",
" self.version = self.get_version()\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 646, in get_version\n",
" config = get_config().split()\n",
"AttributeError: 'NoneType' object has no attribute 'split'\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"356 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
"2.7 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
]
}
],
"source": [
"%timeit -n 1 -r 1 KMeans(k, init=X[:k], n_init=1, max_iter=50, tol=1e-2).fit(X)\n",
"%timeit -n 1 -r 1 KMeans2(k=k, init='first-k', max_iter=50, tol=1e-2).fit(X)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "0ee6d695",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"Exception ignored on calling ctypes callback function: .match_module_callback at 0x7efd209d28b0>\n",
"Traceback (most recent call last):\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 400, in match_module_callback\n",
" self._make_module_from_path(filepath)\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 515, in _make_module_from_path\n",
" module = module_class(filepath, prefix, user_api, internal_api)\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 606, in __init__\n",
" self.version = self.get_version()\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 646, in get_version\n",
" config = get_config().split()\n",
"AttributeError: 'NoneType' object has no attribute 'split'\n",
"Exception ignored on calling ctypes callback function: .match_module_callback at 0x7efd403ac9d0>\n",
"Traceback (most recent call last):\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 400, in match_module_callback\n",
" self._make_module_from_path(filepath)\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 515, in _make_module_from_path\n",
" module = module_class(filepath, prefix, user_api, internal_api)\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 606, in __init__\n",
" self.version = self.get_version()\n",
" File \"/home/jmschr/anaconda3/lib/python3.9/site-packages/threadpoolctl.py\", line 646, in get_version\n",
" config = get_config().split()\n",
"AttributeError: 'NoneType' object has no attribute 'split'\n"
]
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAABHgAAAGsCAYAAACmZRDdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9d3wkd324/8zMVvV+0ul6P/ua71zOBRewccGAKSEkBDAEAoFvEkNCyS8JX0JIgkkChoSAAxiTfJOAAYMp7uCGz+Xs674unaTTqa+6tGV2Zn5/zO5oZ4u0OvXT++HF67SzszOz69Xuo/fnXRTLsiwEQRAEQRAEQRAEQRCEBYs61xcgCIIgCIIgCIIgCIIgTA0J8AiCIAiCIAiCIAiCICxwJMAjCIIgCIIgCIIgCIKwwJEAjyAIgiAIgiAIgiAIwgJHAjyCIAiCIAiCIAiCIAgLHAnwCIIgCIIgCIIgCIIgLHAkwCMIgiAIgiAIgiAIgrDA8cz1BUwV0zSJx+OoqoqiKHN9OYIgCIIg5MCyLEzTxOPxoKqyxjSXiD8JgiAIwsJgMv604AM88Xicw4cPz/VlCIIgCIKQJ1u3bsXn8831ZSxqxJ8EQRAEYWGRjz8t+ABPMoK1detWNE2b46uZHQzD4PDhw4vqOc8l8nrPHvJazy7yes8e8lrbJF8Hyd6Ze8SfFsdznkvk9Z495LWeXeT1nj3ktbaZjD8t+ABPMq1Y07RF9x99MT7nuURe79lDXuvZRV7v2UNeaxspCZp7xJ8W13OeS+T1nj3ktZ5d5PWePeS1tsnHn2QJTRAEQRAEQRAEQRAEYYEjAR5BEARBEARBEARBEIQFjgR4BEEQBEEQBEEQBEEQFjgS4BEEQRAEQRAEQRAEQVjgSIBHEARBEARBEARBEARhgSMBHkEQBEEQBEEQBEEQhAWOBHgEQRAEQRAEQRAEQRAWOBLgEQRBEARBEARBEARBWOBIgEcQBEEQBEEQBEEQBGGBIwEeQRAEQRAEQRAEQRCEBY4EeARBEARBEARBEARBEBY4EuARBEEQBEEQBEEQBEFY4EiARxAEQRAEQRAEQRAEYYEjAR5BWKTEQ2FGXu0kHgrP9aUIgiAIgiDMe8SdBEGY73jm+gIEQZh94qEwnffsw9JNFK/Kkrt24qkMzvVlCYIgCIIgzEvEnQRBWAhIBo8gLEKiTYNYugmApZtEmwbn+IoEQRAEQRDmL+JOgiAsBCTAIwiLEP+qEhSv/euveFX8q0rm+IoEQRAEQRDmL+JOgiAsBKRESxAuUOKhMNGmQfyrSjJSiD2VQZbctTPn/YIgCIIgCIuRXP4k7iQIwkJAAjyCMAuMF2yZiWPlUyfuqQyKnAiCIAiCMC+ZTnfK93gT+ZO4kyAI8x0J8AjCDHM+TflSJQRw/Zw8FppC1Qe3EFhblvH4bHXiIiSCIAiCICwEzrehsfiTIAiLHQnwCMIMkCoYE8lC+opSqtTgUcC0wLTrvYuuqnOOhWHRc98Raj+5K0M+knXiSTHSyvyMvNrpOoekGAuCIAiCMJ9I+okxHJuUOyW3iT8JgrDYkQCPIEwz6atOlXde7JKF1KZ82VaoUgNCxC1nX0s3Gfptm/tkhpV1dSm1Tlwr8xO6/zXX9aTeljGfgiAIgiDMNe4AjWoHaeJWXu7kqQyKPwmCICABHkE4L8ZbwUnP2DH6ozmb8mXL7kldPXKhAIbl3uZRck5xSNaJj7za6TrH6IEuST8WBEEQBGHWydefiJuU3roKtciXlzt5KoOT8qfxpmCJPwmCsJCRMemCMEmSK0d9PzpJ5z37iIfCrvtTx2jiUTGGYwAU7lqSMxUYxmQjuXpUeusqe/UKQFMof9fGseM6KBNeb/o5CnbUyJhPQRAEQRBmlcn6k5XYlo87AeP6E54Uf1Kg8s6LJwzOiD8JgrAQkQweQZgkE/XUSQpG+EgPA080M/hIE4NPtFBy0woKtlTlNXLTUxmk+LrlBLdUue7TSnz0fPcwJBen4ibhIz0UX7c85/VmO8d0j/mUmnRBEARBEMZjuvxpPI/J5U96xzDDz5yzd7Jg+MU2PGX+cZ1lpv1J3EkQhJlAAjyCMEnSG/BlW8HxVAZRi3xjNeBxk8FHmhh6ssVVsz3Rl3tyW/hIDxaJfJ20zOOBJ5oJpgWOsh1npsZ8nu+kC0EQBEEQFg/T6U8Tke5P6RnPkcMhOo/3TXjMmfIncSdBEGYKCfAIwiTJdwUnWy146opVtmbMRn80YyJEx1dfHRMdDTvNOJ4S5YnbjQLj/VFGD3RRsKMmY/RnpKE/533JIJNW5s84fz7ISFFBEARBECZi7v1JyWi+PJ4/xUNhJ0CUnoGdvP98/UncSRCEmUICPIJwHuSzgpOeapw+CSL9y73nviNgWI6sxFqHiDYOuGQEA0puXYE5Gmf4mVZns94zSt+PTgIwureT8t/dSOElNYAd3On59uGs97kmViSY7EpSPitygiAIgiAIc+tPKzP8yRjVs/qTHSDa5yyoDT7eRO0nL80+kj3BZPxJ3EkQhJlCAjyCMIOk1oIPv9yO0Rsl3h+1++mU+d07JyY8WLrpBGSyoZX4ibUOubYNP9Xqut33wxOYg1GCW6oYPdDlvu9HJ/CvKM4cKZrA0ifu65P+HKe7p48gCIIgCIuXmfKnSOOAa9vwnnOu230/PIFW4sPoj7qzpQ0YPdJDScKNpupP4k6CIMwUMkVLEHIQD4UZebWTeG9k6sfqjzL8zDnCh3vo+fZhIg39tjycB30/PEHkcGjC/QYeaaLznn3415S57zBh8OmzxENh98SK1Mc+0Zwx3QJSXpO0+zyVwaxTwgRBEARBWFzMZ3+KnehzbTP7Yhn79dx3xA4iqe6+PeZo3HGg6fAncSdBEGYCyeARhCyk13drN/rO+zjRpkHCh9xZNAOPnKH01tXufjoKYGUeYypYuokxGLVDuSkLTaN7Owkf6GbJXTudFSS9a2RswkSir0+qdEhDQEEQBEEQxuOC8CfDwuiPUnLrKgZ/dcbZPPxcK5hjpVjiT4IgzEckwCMIWUiv7/b2mBM8IhNXfbZ7EQi9dZie+45Q/s4NmINRLOzU4b4fnpiGqx9D8aqYo/GMyVtgP6/+R5so2l0HQGBDBSN72nPWg0tDQEEQBEEQxuOC8CeP7UADjza5tyeeiqWbDD59loIddj9D8SdBEOYTEuARhCykN7/TqyZfzeiqz862smRY9D1wgqoPbSWwtozBZ85O7aLT8NYWoNUEGX62Nec+kcM9RA732Dc0hfJ3bgDTyqgHj4fCmMMxZwKFNAQUBEEQBCGdC8WfRo+GCCf9KAujezsZ3dtp3xB/EgRhHiEBHkHIQmrzO8+KIjpajk/6GFqZHzTFaf6XFQt6vn2YkjetZvCx5ilccSZ6xyh6x2j+DzAs+n58ktpP7sqZWoxHpeTWlc640GQKtTQIFARBEARhVv3pO4cpuW0G/Kl1GL11OP8HiD8JgjCPmNEmy3v37uWjH/0o11xzDRs3buTJJ5903W9ZFv/6r//KNddcw7Zt23jve9/LqVOnZvKSBCFvnOZ3FYFJPzYeCtPzvdfGl5MUBn91BsxpbsBzPhgWfT8/7WoC6FpJi5toRT5HTjrv2Uffj07Sec++rE0FBUEQhMkj/iQsZKbuT0fy8ydL/EkQBCGdGQ3wjI6OsnHjRj73uc9lvf/b3/423/ve9/jc5z7Hj3/8Y6qqqvjABz7A8PAkouaCMMvEQ2EGnznL0DNniTT0Z50qFW0adI/XXEBET/TT8ZVXiDT0M/jMWfSuUTu1GMCjYA7HnJWn9JpyQRAEYeqIPwkXIkl/6n/kDIPPnM0a2Agf6YH4PAjYnAfiT4IgzAdmtETruuuu47rrrst6n2VZ/Od//icf/ehHeeMb3wjA3XffzVVXXcUvf/lL3v3ud0/qXIZhTPl6FwrJ57qYnvNckvp6x3sjdH9tf4Z8KF6Vqj/d4axWeVYU2eM158Oq0vlg2KnPTu27plD4uqWMvNDBwCNNDD7ZQvn7Nrvq7D0riqb8npT39uwir/fsIa+1zWJ//vki/jQzyO/h7DKRPw0+0Uz1n13iyvQxF6o3JRF/WhTI6z17yGttM5nnP2c9eFpbW+nu7uaaa65xtvl8Pi677DL2798/aUE5fPjwdF/ivGcxPue55PDhwwSa4pRmWVmydJOGxw8T3uRFG7anRliXeijdq6PME1exyBhGMfEDkhgWfYfa8SWeu6WbtP7mOJGrPGijoFepdp19C87z16tUjKLzSxKU9/bsIq/37CGvtTBVxJ+mzmJ8znNJTn+KWzQ/eJDRTV6MIhVt2MTXZlCsgjLPkqAn5VDn4U/a0am7E8h7e7aR13v2kNc6f+YswNPd3Q1AZWWla3tVVRVtbW2TPt7WrVvRNG1arm2+YxgGhw8fXlTPeS4xDIOjLxxkdWAp3m1BevcfzZo+XHIsTl15NSPPt4EBaNg2ME8CPJMK7mTBN+B+IgVnDApbLVfmUrw3Qs/XDzirUqn35YO8t2cXeb1nD3mtbZKvg3D+iD+dP/J7OLvk408FZwwKzloUXlU75k8z2kDi/JiKQ03kT1N1J5D39mwjr/fsIa+1zWT8ac6naCmK+yPTss7vr2FN0xbdf/TF+JzngnhvhIrHIwwZjfYX7we2EGsdQgHMUZ2hZ84ldrQYeTZFrhdgJqFa7sPsi+W9v6WbxFuG8VcXAhBpGXbVlafeNxnkvT27yOs9e8hrLUwX4k/nz2J8znNBLn8yR+PEe8NEDocSO5puf5pn2Tv54KkNEu/Iv1lyqiNNlzuBvLdnG3m9Zw95rfNnzmLk1dXVAPT09Li2h0Ihqqqq5uKSBCErsaZB1ESwxtJNYq1DaEU+gluq8G+osEd5XiBkC+6opb5xH6OV+Z2f/atKULz2x4riVfGvKpneCxQEQVjkiD8JC4Vc/lR0eS1Fu5deUP6ULbijFIy/jp70J3EnQRCmkznL4Fm2bBnV1dU8//zzXHTRRQDEYjH27t3LX/zFX8zVZQlCBr5VJZgatqSoMPh4U6IES7Fzdg3LbqiMtSBXnSbCHIjZoeAcz83ojzo/eyqDLLlrJ9GmQfyrSvBUBmfnIgVBEBYJ4k/CQmGx+5N/QxmRAymB2LSy/aQ/iTsJgjCdzGiAZ2RkhJaWFud2a2srx44do7S0lKVLl/K+972Pe++9l1WrVrFy5UruvfdeAoEAt99++0xeliBMCk9FgP5rfFT8VrdlJEnqz6ZFYGsVkcM9mQe4ANAqAngqA0RP9rvkJNtKk6cyKHIiCIIwBcSfhAsBT0WAwV1eyl7R3QGcReJPkQM9eFcUgQn6ueFx/UncSRCE6WJGAzxHjhzhfe97n3P7H//xHwF429vexpe+9CU+/OEPE41G+du//VsGBgbYvn079913H0VFRTN5WYIwaby9lltIkiQzWxTwVE2uId5CwuiJYPREXNs8tUGCGyvm6IoEQRAuXMSfhAuBeG+E0r169mETi8Sf9JbhjG3iT4IgzCQzGuC54oorOHHiRM77FUXhT/7kT/iTP/mTmbwMQZgySix788qi65Yx/FQrWNj/LiLiHWGGOs4x9HwbtZ/YJStPgiAI04T4k3AhEHkthJKj97f4k/iTIAgzw5xP0RKE+Uw8FCbc2J9z0nn0VN+sXs+8JG4xeqQHrcjn1I7HQ2GpJRcEQRCERUo8FEZvzcxeSRI51juLVzNPEX8SBGEGkACPIOQgHgrT8dVXIW5RpJK10bB+bmQuLm1eESvs4uzh5wmG1uOP11L29vX0/fgkGBaKV2XJXTtFUgRBEARhkZDqTxZ2b+GMfTpGZ/uy5h3iT4IgzAQS4BGEHIwe6YG4nbujmFB47VKMviiRw6GxnXKl9iwSYsEumq/6HKYSQTF8rNrzRfoeMJ3XxdJNok2DIiiCIAiCsEhw+RPg31qJryLA0DPn5vbC5hHiT4IgzBTqXF+AIMxX0lec1AIvZbesBk/innn62xMLdjGw9LfEgl0zfq5w+UlMxW6+bGkxwhWnMoJeWpl/xq9DEARBEIT5Qbo/+eqLKLy8TvwpBfEnQRBminn6ESsIc09wSxV47F8RS4PAxZXuHcwsD5olTCza1D4a1A7a1D7MhBXEgl00XfXXdGz5Dk1X/fXMSIqKY2/BgY2o2NMvFHxou3VCqx5xndfoj07bqcPhFtrbf0I43DLxzoIgCIIgzDriTzlQFfEnQRBmHCnREoQceCqD1H5iJ+HGfhpGW1laESByYCzteK44o3bxovckI8rYF3+h5We3voGK8pNYWgxIrAiVn8QXrpnyOWPBLsLlJwn2bcAXrnHdXvncFxiqeYXQup9ybuh+2AA9a39C1em3U9J7Of5Vl7qOdb4NBMPhFl586TZMM4yqBtl9xcMEgyum/NwEQRAEQZg+xJ/GEH8SBGG2kQCPIIyDpzJIQZkP40AbMPfpsmfULn7tPZyxfYQov/Ye5vUDS1EMH5YWQzF8BPs25H3sdAlxjl1+jNZd/wyqAaZG7ZEP0Xnx95xzrNrzRTx6CZamjx1Mi9Oz8QF6lV9QW7ALD7ZIxENhOu/Zh6Wbk24g2N+/F9MMA2CaYfr794qgCIIgCMI8RPxJ/EkQhLlBAjyCMAn01qGc9/nWlBBrHJyxc5tYvOg9ad9IL3BXAAteiod4+56/I1J+KkM0xiOZmpwqHb5wjS0nl34ZlMSqm2rQseXboNr51clVLk+4kmyjMkxrTCTC4RY6T/4a01OCT69xGgjqBd309++lrOwyfL76nNdYVnYZqhp0VqDKyi7L67kJgiAIgjC3jOdPM434k/iTICwmJMAjCBMQ740QaIoTXxHJPTRLAaxsg0Cnjw6135VWnO0aRogSivpY2nbNpI4dzpKaDNC665/G5CSJaoKpgWrYq1z9GwiXncw+BxUIBOpd6cHKVQkB0pdg1g3w8ktvd6Tjskt/kfMag8EV7L7iYUdmZPVJEARBEOYv+fqTt74IvXV4xq7jQvMnf7xW/EkQhJxIgEcQxiEeCtPz9QOU6iY9Bw5QeefFoAFG2o4WxM4MzOi1hMmv2V6++6US7NvgSk32hCvpXf1LZ6UpFcXwUr/vk8SDobFVLgswvJCaZpxgpKeJQd8hJz3YqW3vqmVgZJ8rbXhg4BVgTe7rDK4QMREEQRCEec5k/Gkmgzswe/6E4SXuHWSo5pUc/uSjft8n8vanvo5XifKQ258qTrH0tjfQp/xa/EkQhKxIgEcQxiHaNIilJ9JpdROjP0rJG1cx+EjTrF9LkPzq1/PdLxVfuIZVe77opAuf2/lVW1aypA2XNd/klpMERV2XMFz3smtfxfAx8PBZOrd+Z2yj4SHuHSTm7aC0f4Mrbbi09FI6Ononff2CIAiCIMwfFps/JZsl92x8AMXw2pPCUmYVF3Rto6L51kn4k5czrV8HLT620fAS9www0ttI2dLLxJ8EQciKBHgEYRy0Mj9oChgWilfFv6qE+DSOrZwMtWYZhZafEaJO0CUQGKKktIvBgRoi4WIK8VNrluV9zJHyYwzVvUBx+5V4I/YY00jJGSfd2AnuJAM9hpf+lU/YDQFNlZLWayno30jHlu/YTQRT9qs6/TYCg6tp3fUvQIqgKAY9Gx8gtO5nbCj7AlWBGwgGl1Nf/258vnoM8xgdHQ9SUXGFrDYJgiAIwgLkQvanWLDLztIBirvsSVd6YYfTLNnSdFw1aYZKRfOtY4tnefiT4R2mb83DziECPRuJVJy2/WnoIVacu5Ply96H11tGTc0t4k+CIDhIgEcQchAPhQnd/xoYFqYC5XesJdo0iDkcm5PrUVHYrW+wp0BYEAgOsXPXL9A0A8PQ2PfKm9k9tBU1VzF3GnYDwLtBgYH6Z1FML5am2ytPhse9aqRAsHcDhd076Nn4QOKCTAZXPM3g8qfHAkEKVEZvpuSVN+AbqWFg6W9BTTmOBai29VhajBNnP+vcVVl5LYZhMDT0Fxw/EZ2TUZ7hcIvUqAuCIAjCFLiQ/SkW7OLMVX/llFT1rHsQBWUsqKMApuK4DkBR16XEg6GxxbM8/Cm08uHU0xKpPOn09LGI0txyr/0wxUdNzS2Ewy3iT4IgABLgEYScpKYXqxYMPHgaDMv+Mk5MXcCjgmnaqbizwGqzhjfoW3nRe5LC0gY0zS5m1zSD3UU+Vg/kN/UBYKjuBZdYuFaeTM3enpQVC0pbb8ATLbObSac2Dkz1IRPC8VbUG/bgj9VSqlxMF0FMK5y13CuVo8c+Q3nZ1ZCogc82ynMmBSK1keFcyJEgCIIgXAjk508KxHO2Xp52psufwuUn3f1ytPhYso4CmKrdfyfFn4q6L8nLn0aUExS/6WJiA71UciW9PIRpRRPHyv5aWVaMEyf+loKC9Yg/CYIAEuARhJz4V5WgeFUs3bQXY4zEl2vyO1ZTqPrAxQD03HfElpdZYLVZw8poNW09SxhZtxc0HcXwsaL30kkdp7j9Sgbqnx2TLTORtZOY8ACMTQdTLDovvg8LK1MyUiQGFUYLX2M09lriPg8XX/RP9PW9QFv7A66HBYNrCIcbnduRSCvtHT90biuKn7KyyxwpCQTqOXDwQzMmEP39e10NC9PlSBAEQRCEicnHn8rfsYG+n5y0gzzZmi/PANPhT8G+De6myIZnLINniv4U8TXR1PcVUEBRvFy0+ctZ/SmdUO/ThHqfdm6LPwnC4kYCPIKQA09lkCV37STc2E/z2WbK9qbXVFvorUPoPeFZC+4kUVFYNrKe2J6/dxojp9aDpzbvSxILdhEuP+k09yvs28yyVz7DUN0LBHs303Hxd+0dLcZKtFLSjK0sEx7sOxQKerYxWn0wy51xXjv659Qv/V3sj5uxcq1wuHnc57hi+Z0AY+NBFS+WZV/DTAhEWZm7YWFZ2WXTdmxBEARBWCzk40+Ro6GxDB4D8KkQm/l06Onwp9V7/t55TGBwNa07/8Xe8bz8aSuj1YfGtiWyeixLz+lPE0XExJ8EYXEjAR5BGAdPZRCfaVLyszQ5AdAUBh5vmpVVp1wkRaTpqr9yBKJn3U9ZvefvXZISC3bRdNVfJ5r7eag98oegGgT7NlB79IN0bL5/rOeOZoyVnKlWSk25mnXsJ6rFaOXBcUqwTM61/S+KomFZtpSkykYuWs7ebz86OR7U0klKzkwIRDC4gt1XPCw15IIgCIIwRRx/+mkWf/IohI/0uLfNQnAnlcn50185PQrr932SeDDkBIOm7k+H3P7kcqnz86fmlu8RDp91+VPyceJPgnDhIwEeQUghHgoTbRrEv6oET2UQgFjToJNxm4pvXSmxE/2ze4FZCJefdK8OaTrh8pP4wjXOpIdo6mQsNU7H1nsT0qFReu51DNQ/7T5oymhPFPD3ryYwtJKB5Wn7Zds/B5ZlABrr1n6GkpJt7D9wp0tSAoFlaFoRIyPHE/tHaTn7XdcxFEWluuo2li17z4wIRDC4QsREEARBECZBNneChD+lxTUCW6tQgxqjL3fO8lVmko8/jZYfd/UobN31z3YZ1kz5U5aFson8qbBwEwXBdXT3/DKxJUZXt7tJ87q1n2Zk5BS1tW8VfxKECxwJ8AhCgngoTOc9+7B0E8WrsuSunfYK1KoSV1k1gOJV8ZQGmJt5EG6CfRtQDO+YpBhegn0bXKtOgHtVKPmvauSWjhSiZWeIFp+dsFHyxBjoej+BwFIsy32gSKQ1Y2/LiqfdtqWlJ/SUNPETBEEQhDkmlzsBtj+lJq94VMpuWUXvj0/N3QWnkLc/pZKUwcn4U0nztPgTkNWfRkaOO4tjuTjd8GUsS6ej8xfiT4JwgSMBHkFIkDr1wdJNok2DeCqDeCoC9L4xwGpzCUTiqAVegluqGHm5PetxlKCGFZ6+uq302u90fOEaVqXUgxd32c0Cu9f92C0nyUZ+5ysYWnziffKgq+NxhodPwBTCYzPVxE/GfAqCIAhC/uRyJ8D2p5sDrByuwOyPUbi7DoBY00DGcZQiL5gW1uj0uAZMoz9NlWzlWefB0NBRBgcPcz7+NJM9eED8SRDmExLgEYQEqVMf8KgYwzHioTBKmQ+A4d+cdVaogluqMkrKAfAoWNHpDe4ke+coho9Ve76YURuelJfirksJl59ED4Q4t/OrYyVZqeQK7owX+JnyqpObcOwM4d4zee6d3khQBcysNeRTlQsZ8ykIgiAIkyOXO6WWao2+2IGlm0SO91J844rMnjyANTyNARVmwJ/Oh2n2p86uX0xib9uXxrB9SvxJEC58JMAjCAmcqQ9Hehh4opnBR5oYerKFqj/dgbfHdK1QDT59Fq0gy69PfHqnadn14bZoWFosozY8tO6nTuM/C+yxnen1ZONhJdJ6xhOQaZSTybB06e8RjbS7Rn+CSWXF9axc+WGXPEyHXMiYT0EQBEGYHLncacldO1HKfBn+pLcOZ8YeZoBs/pTc7glXcm7nV87fnywgVgD+0Rm7/qmQ3Z8M8SdBWCRIgEcQUvBUBlGLfE6gxtJNYk2D6FXq2AoVMLq3EzzKWNnTDGHXh/ucFaix2vC/dq0wuVKJE83/7H+zTG5w9eKZ3fHu+VJddTvt7T/OOiki1Ps0vX0vsHbNXdTU3EIwuCJvuRhvlUrGfAqCIAjC5MnmTtGmQQI7qjL8KXy4B1TF9o9Z9CdPuDJlmuhYIGdS/pREIb/gzhwskJWWXkF7+4NYVjTjPvEnQVgcSIBHENJITTdWvCq+VSUYLSpVf7qDkWfP2cEdmPZsnWzY9eFfdNWQDyz9bfb0YUdKtPGlaY4ycvJHobvnEcabP29ZUU433E3jma+z+4qHM+QiEKinvf0nLhGZaJVKxnwKs4X0KhAE4UIj3Z38q0oAMIqy+JOZyBzWFDBmxqXS/Sk1oycjSyc1qDOTUadZYGDgpXHvF38SFjLiT/khAR5BSCOZbpwc+amU+aDFbhZYcv1ywge6nZWoJN5lhejtozMiKr5wjatuvHu4hudbd7Oh4hTVwZAtSYaX2tc+SMeW74Ka0qBQNae9BnzmsUgP7mhaGYbRn7FncrWpru4djlwEAvUcOPihDBHJZ5Uqebu/f6/rtiBMF+FwC3tfebP0KhAE4YIi3Z08lUEMw/4uT/rT6L6uMU+yoPiapei9USJHe8Zb0zlvMv1pCScHVrKhtInqYK89PMLxp++4Az/T1Bh5viL+JCw0xJ/yRwI8gpAFT2XQaRCYFJTk9tRa82QWj946Ahp4lxXZ9eUzxOmSk/zRcDmxo7+PT43y7xXN1PkiBPs22FMg1CzTJxLBne7RSk72rWVDeQPVBaEZu8aZIFtwB0BRvAQC9YAtE8HgCtrbf5JVRPJJIZZGgcJMMzDwivQqEAThgiTVnbLdV/XBLfTcd8QO8nhUhp5vsz1qFhahWrz9fO7FvyBm+vGpUf6jqI/qoq4Uf8odYVrI/pQL8SdhoSH+lD/qXF+AICw0PJVBiq9bTu0ndhHYWjl2h8GMBndiwS6eXfYbYqbfvm36OWxBads1AITW/TTnY7tHK/ncns9y32t/wOf2fJbu0cqc+y4cFCxL58DBDxEOtzhbkyICuEQkmUJ80eYv5xSPbKtUgjCdlJZemvX9KQiCcKETWFtG7Sd3Uf47Gyi6um6s1H2Gq6Ky+dN+7+D5+dPIheBPqviTsOAQf8ofyeARhCkQOdY3a+cKl59kQ8UpfGrUWYGq2/gjYvtXJGrLc48YPdm31iU2J/vWXgCrULYRJkUiEmmjo+MhamvfmrMWPLlKlQtpFCjMNLl6FUhduSAIi4Fkhk/fT0/P2jmn1Z/611JduND9yS4/E38SFhLiT/kjAR5BOE+iTYMQT6nRnsFmgWBPhKjxD/GFq77kShVONhBMTotIJZlWXBkMucRmQ3nDpM+fnqI8n1KWdX2Ao8c+DUBb+wPsvOS/qat7B+FwS0azwPGQRoFCOjMhDumiPB2p7SI4giAsFBazPwHzxp1A/EmYOcSf5g4J8AjCeZI+MaLyzovRW4dcvXmAaRul3mYq7D/8PurXPcTV9S/bhza8znStVXu+yFDNK4TW/RRL0+keqeRvXvhLdNOHV41x1yXfJBSppDIY4mTfWoAMucgVtEmmKCcF5892fouv7fuoc/sLV31pFkUl8wXt6PyF63Zr638TCCw9rw/9iVaphMXDROIwXVIwXgPL5DkCgXoikXNZzyW9DwRBWEjk9KfHm8cCPQoUXb+M4adap3SuWLCLxuImXnvlLpZcfH9+/jRayd/sSfGnnd8kFM7tT+MteKX6k1eJgqKgm745cCfI5k/nzv2P67b4kzAdjOcl0xlQmcifuroeBaCm5pas57pQ/UkCPIJwnmSbGBFYW0ZwSxWDT58dGweaLbijgndpEb6lhYy83Om+L0tAyGmu3LUNX89GRwoqT78NgIGlvyXYt4HirksBiJQ08WikCN30AaCbPpoGV7JryUFXoCZVLtKDOKn3vdq53ZWi/NDp2+aw5Cv9BdUYGjri2tLV/RjB4HLXh35T0zdZteqPL4gPbmF2mEgcpksKcqW2p54jSbZz5TPhRBAEYb6Qy58sYPCRJnsnC8zhLKVTCX+CtL6HCgS2VhI5NOYisWAXL1/yL2PNlV/81Lj+FC05w1DdXl7t3O72p4Hc/jSeO4Hbn3TL7yjM3JTLZwrpaPiM63Y2f+rqepSVK/9oVq5QuDDI5SXTHVAZz59eePEWLCsKQOOZr7H7ikcyznWh+pMEeARhCmSbGOGpDNrjQPd32Zk8GqAo9s8ehaKrl6IAaoEXtcSfGeBJ+/51mgMe/X37dlIKAgN4ouWcueqv6I6WcLJ3PRvKzlBd1AmmhtV8nes4ZwaXYyUe7zpOQi5y9enpHq3kZ6dvdV3gyf71JOeve9XYeaUsTxemZaBmTOAwaDl7H4ridz7c29ofoL3jIa7c/egF8eEtzDy2OAQwzQiqGnD1FMhXCpIrVcXFO3PeV1Z2WdbU9tRzJMl2Lul9IAjCQiObPxVsqWIwmQXtUSjYUcPo/m67nCvNnyxVcQd4LIgcdgdLhmpe4eTAyky3Gc+frMwwyHj+NF6Pw2z+lBwZ5lH1OXWn3CT9yYdl2WVrpxv+hZKSbZSX757jaxMWCrn8abLuVFZ2GT5f/bj35/KnpP/b54pkPdeF6k8S4BGEGSORiqMoYCV0wbAYfu5csr+dXXee42FJhmpeyWgOuKG0EdQ4HVu+TXekPOvq0aVLDvLQ6VvtFSMsXuncxf6u7XiIEsePV40xGCuie7TSXs0KhhiTDytx2w782MdIvcCUf62Zq5vPh8zgjo1l6axb+xkGBw/T1f1wYluUrq5Hqam5ZcrpoQPdYdpP91O3rozS6uxjYYWFj5V4f1tp7/P8x8be6ghOYeE/pd3nXsWqq3tHznMkUdUAsViIcLjFee9K7wNBEC4ckhKU/HKfhD+l6YjhHWZDeYPjT35VZ0PpmfPypwPd2/AqUXTL7U+53AnG8yewzFmYDX+eWJZOTfVtjjtBnP0H7uSSHffnLBWeDGeHzrKvcx87l+xkefHy6bloYd6RzZ/ydyfbjxTFy7at3wUCWe8fz59SF3lVNUAgUJ/RV+pC9ScJ8AjCDOBqIJjaj8fCLSCGlRHQKbltNYOPNjl16IZ3mOqC0FhzwNIGqosSAqGaGatHT7deyYhexO66vfzd1V/iV2du4rlzVyVO50FT4NaVj/Nk83X8+NQd/LzhVr5w1ZdoGlhJavDmxfbLqAz0u+TIq8bAslzColv5pxnPVmPm2HAVkdDFBNa/AUpIkRTQ9f4pp4cOdIf5wd+9RDxm4vGpvPtvrpAgzwVIV9ejjhxYVtS1+pOPFHR1PYppRgB79Wh05B46OqLE490MDh6ecBUr9RyBQD2Dg4doaLyH0w1303jm6673rvQ+EARhoeN2J5PRA13uUeoT+BMexe1cMCV/+smp29nbuStxOV5uXfU4Rd5Rfnb6Vsef3rr2EVLdqWlgJaFwJRvKGzL8yTAVTLz25eOZVInWzPuTAijEhiuIhC5mw8rfo1t5Asuyy+QsS2f/gTuxLH1KpTVnh87y9p+/nUg8QsAT4MG3PChBnguQXP6UjzulZvlYls7BQx/A67mclpbriUQa8HrL8/KnK3c/6vTgKSnZxoGDH8rq/heiP0mARxBmgNQGghNNhyi8bIm7TMu0KLqmnuHnWon5u+hb+QRgS0p1oBdU97HSV48ebboJUHju3JV86tKv86bVT/BC2+XELfvX3bA8HA+NrSrFTD/PtF7JY003pBzV4rlzV7Gn7XLeuPI3/NnObznCAvBK53YearjNaRSYT5rxRHXq00VsuIozj30ey/Dzs/1nueNTb0BVv+ZkUXi9ZVOut20/3U88ZktoPGbSfrpfAjwXGOFwC41nvubcVhR/xkrTZKXAMBs4fuIvMrarahBF8XLs2F9SW/vWrGnwgcBSBgcPOcJ0IdWKC4IgQGbzZf+asrF+hllI96eiq5di9EYJH+0h5pu6P60sOesEeACOhdZTU9Dj8qeu0UrXMX506i2AiqbEM/wpFCnjq69+nLjlmdRErtnxJ4vYcKXjTw/vj3Hbn93HqZYPYlk6iuJ1gj1T+f7Z17mPSNxe+IjEI+zr3CcBnguMifxpIneys2/G3m9goMdfoPHMC84+qurHNKM5/SlZwpVsrtzc/B8XZK+dXEiARxBmgNQGguZwjIFk00DIWHHyVAbHgkEqY/XnChhb20BLbTKoAoZrJScUriSjbCrx81Nnr+GPt3+fD2z5L759+L0kf+XPDK1x9tKI8Xjz6zFdHwf2cQzLwyNNb+SJ5ut52zo7C6a6IMStq3/DpUsOusZ+Pn/u8nFXlsarU59Owj3rsQz7PPGYSWdjmN1XPMK5M68y2r2egBpEVb8+pXrbunVleHyqk8FTt65smp+FMNfYK0gR5/baNXc5DQLHW3lKvb+m5hYaGu9x1YGnU1N9G9XVN/Ha0U8AY2Nqy8t3p6Up26UCSdJ7AgmCICx00psvR5sG3TtM4E/Dz7c5/hQuP5nhT92jZa4smIn86Z3rf8nPTt1KHPvzt2loNU1Dq5y9NGL8tu3KtGPk9qdNFQ188eq/d11DPpk5c+VPI12rWbnl+xw/9wvWVl9O+6n/b8q9SnYu2UnAE3AyeHYuyexPJyxspsOfLtlxv5Mxlo3Cwo0sqbkVv782w5/Sp8Dt2P4dGhrvcR67GPxJAjyCMEMkGwjGQ2EGn2yhVY9zSDF43W3rKH78rLNCFdxShXdZMT33HbEzfcyxdGTt8FKUq3xYWgxMDVQj68jyZF24u24d9ndt43jvWr7/2u9DlgAOQF1hJ60j46+exC0fPzp1Bw8lyrmqC0LO/3OtLKVLS2qq8mRWriZLsOoUihbFMvwoWpT2oY+zpOc+fv2tcuKxLjw+lTs+9RCm58B519uWVgd5999cIT145jn5jOJM3yd1LHlqnXhNzS2uqQyK4s9o2O2eeqVSv/R3uWTHfYRCz9Lccm/W8/eEfpOxraPjIcrLd6elKbuDRGtW/9mE793pHEUqCIIwG6Q3X1a86nn5U7BvA4ox5k/dkbIMV6kMhtDQMfCSzZ9uWP5bFFVJ9P3JDARNxZ8gd2bOfPEnvaKJ9z7+p4lgzGP84I3fpSDeOqXvlOXFy3nwLQ9KD555zmT9CXB+Tu+zc/7+dH9OfxoaOsTIyCmqKm9wbe/oeIiysktd2TodHQ+5HGox+JMEeARhhvFUBoneuZk773uJsGESfPwov7rzcpb068540GjTYNYyLl+4hlV7vki4/CTdwzU8t+wpBvSgayXnXNtu7FFd4F6BAsPy8vTZa5z9xxgTmbaROhQMLLTEv2rGcZLETD8/PnU7q0rOcumSgzknSIQiZXzl1Y9hWF4nCBUKV7pSlWeqB4+vKMTO332UttMhglWn8BT0cObIUeKxQsBeleprLWDTle+Y4EjjU1odlMDOPCafUZzp++zY/h1XjfaO7d9xNZRsbv4PV0356dP/xLp1n3KOa/fcSTZENjnX9r+0tf+IS3Z8H02roPHMP2Zcp2lGCAbdgltb+1bA3YxQUfwoipIoNbSFaarPXxAEYT4znf70cFGTy1UONd7Cj9t3YTh/CmX3p+S49DHG/OncyFJU4ph4psWfXu3cDsDPEg2eZ9+felh98+cJ96wnWHWKsyNXusqpjgx08NZ1U3MnsIM8EtiZv0zWn9L9ZPcVD2f02ZkZfwpn9adAYKkrwFRb+1Y6On/hCjhN9fnPdyTAIwizwL7+UcKG3bMlrBvs6x/lnbuWOfe7e/YAhr39HCaHwmUsCe/m04wSOfp7eNWYk7GjonM4VohujferbJK+MpX681hplsXr6vfw7LnXjXMse5rEK527eOj0rfzd1V9yrSx5lDiaqvPVVz+OkbimmOl31ZzPVO+d1Gscif+S0lVjW+o3VHLQF5OSqnGIh8JOWnz66NqFSD6jONP36eh4yHU7EjmXMZkhla7uh+kJPcWO7d9JNED+asY+lhVn3/73UVf7Ttf2ZH25qgapr383lZXX0tHxkKuGPBhcweZN/0DL2e9RUnwxS5bcPu4Ek9QVp3xHkQqCIMxnJuVPiRKuc5gcIs7OwnribVV8lGEig7UkXUhTdM4pMWLjuhNM5E8WGhagYvDGVb/m0aY3jnOs7P7kVWPopg+PqjuBnSSz7092kMdX1GPf6H+Mpf4gbVFdyqnGYbH7k2VFnYG6yf3r6t4xrnPMtD/t2P4dWlv/G4+3lMHBQxkLdulcaP4kAR5BmAUuX1VB0KsR1g2CXo3LV1W47k+vOx84c5xjex7hM331nAtX4QHiiX1108fWqiO81rMJEy+He7aQKSBJ9ESDwHzGcSoc6NqSOFOuj4ax4+iWn/8+/g78WpSbVv6ah8+8kbjl4b4jf+AEd+xHxJ0GzxPVjseGq5yVI0cwpoFe43mq3reR2qG1rFy6lPbT/QCLIgMnH/GI90bo+foBJ+19yV07F5ykpKfT5jOKM32f9FWe9MfU1NxC45mvuWrLTTPMvv1/QMZ8XhcG7R0PuLaUlu7E561k2bL3OA0H05sDKorXqS0fGjpEe8eD7L7i0ZxykrritHnTP7juHxlpcI1WFwRBWAhMxp/0wm6OPPFzPtNru5O/L8rVioeI8/GsoGBiWF6eOXfNBGeO5u1PJhqvtG8nt4tBuj99dd9HuH75c1iJsjLTBBN3trWm6MQte+rWeP40U+4EMf56yzt5clDlTWveREmkiuNH2hdNabr4U37+lJ7Bk23/6fSngoK1VFVeR339u7P6U1fXozQ0fhXLijmPUdUAu694ZNH4kwR4BGEWWFFZwGN3XcvLTb1cvqqCFZUFGft4KoPoBd2c6/ovGoe/hrklwl8ZPj6357P0hKtc+9pBnVRyCYVnnPsyGdTL894XrJTrGJMaw0qtZbe4bfXjPNH8BifDpzKYvalg6vQrRYuy+ubPT5uofP/o93liQKFKX8rvPvhZDN1yjTcf6A6P20/n7NDZeVMvPpmVongoTOc9+yYUj1jToL36CVi6SbRpMOt+83WVKlc67USjOIPBFezY/h3Xys9Ej6mtfRttbT8k0ZQhwXhykn2f/v6XAOju+bWrFt1dh665HmOa0ZwrSekrTn19L7jub265l7Ot/7kgU40FQVi85OtPQ+pBuynrxbrLnX6Du0mrXUYFE7uRL499xuiJLsl7X7DoHK3lhyfe6ZzDHp9uQuL6VAzeueFnPHjqreimD68aY0N5Q4Y/zaQ7Afz09E95YkDh2aMv8rsHJ+9PE90/m4g/ZTJd/hQILJ2wZ810+dPIyHFGRo5TWXntOH183JhmZFH5kwR4BGGWWFFZwIrKAlpCo/z41dYMUbE/mG6lP6xR4rcj3H7N/kJPD/Dkx5goTDcKZook2VvS90j++2jTG/nglv/iviN/QNzycs+rHwVFcUasJ1OOU6c3WIafcM/6PCVFZezLwsPFF/0T0WgHpxu+CsSIDtcSathAcdEZKgbrMXT7iyIeMzlypJGO4ga6v1+cIS1Jzg6d5e0/f7sz8eHBtzw4Z0GefIUjSTRP8fClj6ZdVTLlc88mudJpJxrFGQ63OD13Ojp/4Xx551rhSTYInE4syx20cdehG659FcVDIFBPX9+LGVKV2hRaUbyUl19Je1pjwYWaaiwIwuImH39KnbgzNXeC8TNxJrPPRI9Lf/yYV5lo/Ojk21CtxPeAZRGKlPG1fR91NWX2pbnTUOtOKjc9PuFVKIoPyzIY+57J9CcTD/uG7eut6Ju8Pw10h/nB373klMen3z+biD9lZzr9KVdJ+0z5U2vrf7syd5qavpk1uAN2Wddi8icJ8AjCLNISGuXme54lrBsEPCp3Xr2K8gIft26pwxp+lM7hQr6+/8P89e6v4NdimIaP031r0o5if9mqWJg55EJT4vjUCGGjaEaehx3cSZWU3KJjWB5ebLs0kdljpyYng/HJlONSUyE6UEtq5o+nIN8VqNSVgDjd3U+wbt2nCKhv4PhLxzj5dAGXx+ESNcoTF9+H5lUwdAvNq/DXDZ+koq+e1+t/YD86ZtJ+ut8lIPs697maDO7r3DdnAZ58hSOJPw/xAPBUBFwlgtmOOdlzzyb5pBNnI98666Q4TLecJAkE6p3zNJ75Wso9Xtav+zRt7T9mZOQ0lhXnwMEPYpr2dbS1P4Cq+jHNqJNWfPTYp7EsnWPH/5L0Va+pjLYVBEGYSybyp57RQop8I/g1najhY0XfRvZkuIl9W8HCynCW5H3pC1i5OJ/gTvrjLGyH0bLuaVoep0+ibvl5sf2yjKEWl1WdAjUKie09r72V4mX7Jlwgcwd3IN2fDu/fyzd6vk1I67KPW9YyaX9qP91PPGbmvH82EX/KzkL2p67uJwiHWwCyZO54Wbr0nYyONNI/8AqWpS8qf5IAjyDMIi839RLW7S/USNzkW880AvCVJ05y/+9qnOxbS9vIUj6357NsKG+gfmgVXeHqtKMogIGJRvbAShzTsmYsuOO+jtSfcwd8Xgtd5DSG9ipRVwbPWl+fk16cerz4aBVwynVGywJlAqfq6n6YpqNNtD77CUxjbIXPa/qpHKyn7novK4qX01hxkJ7X2oiWRNHVKF7Tn7UB884lOwl4Ak4Gz1w2GcxXOJJ4KoNU3nkxowe6KNhRM65QpI6mzZZKPNlzzyb5pBNDZp25onhd9yuKN+vY9BdfutVVN26TDHKmpxcr+Hy1xGLteV//4SN3oSga5WWXpZ1H59TpuxnrwIUjJ+m3k2nFyRXs9OtdWvcuVq364wWz+iQIgpDKRP50vHcDP2+8hQ3lDZzsW8vl8WKyZxfbU0OzN0+OJ+6bLRSYcMHMvu1To+yu28tL7btc49J9BSGqt/yc7kO/Y+9t+LJmQLuPar8O6bj9qYbr1b+ga/vdDAVC9Pu68b67la2xnXQUN+TlT3XryvD41Hkx4EL8KTsz6U99fS+6MuvGyOVPGoHAUiKRs3levc4rr74HwxjJkrmj09b2Y0gp0VxM/iQBHkGYRVKbBaYSjZs0DV9KZfCnaIpOT7iKwWgVqzeG8RyLEnc13rPINRbdxpNHRev5phaPd4zkzwari5s4M7TWucdEY1fNAVYmxoMCTg25r2sD/Ya7saCixYhHiokNV7kkZaLgDti9fFqe/j8Z3xuGEmdXyy20Nsdo9zZy/Z9vIeAJMBQI8dDOe/ji2q+wZcuajNWl5cXLefAtD2b04JmLvjzpzbjzqSEP3f8alm4SPtCdV1pwrlTiyZ57tsknnTi9zjy9zrrl7PcYOX4S04ygKF7Wrf10oulyenAH3JljqViTCu4A6Ho3AJ1dv8hybzztdsqYPdzTJNxNov0umSkvvzJvcRMEQZhv5ONPfZFS9rRdgVeBXbuHePwF36T9aWKmw59SST1Wpj+BwoayU7x13cNsqmjgC1d9KaMHD+Bk8eT0p4znkEm6P3lNP6tD24h4h2kvaeSe018m4AnwjTd8g8CJif2ptDrIu//mClcPnrnqaSj+lJuZ8Kfq6lvo6voV2V0plz8Zkwju2MRibePcmx5YOj9/qq1964LzJwnwCMIskmwWeO8zDfz3yy3Odp+msLpmGV94+GMYlj140zAV/vtYECVjlWU6xGImj6FRXdjLmaE1pK5I7e3cxcHuLawubebMwErnnmDVKdBiYPhAjVGx4Ql6T95I96Hfoee1t0zYMDBQtINCXxmh3qcBCPesB2tsZcEgjoWFJ3WbbkF70BW4KYlU0X66n/aRdk7ED7vkY3nxcpeIpPfl+cYbvkH7cPusCEvqStFEnE9a8HiPmcy55xvp6cRdXY/i9bqbig8NHXJ+tiydU6f/flavMT8MR0rAvs6VKz7iTJNIrsTFYiFON9ztPOrosU9TWrojQ0ByNVgUBEGYT+TrT2ChWwp3v1BEfN76Uy6y+9PJ/vV8bd9H+bOd33L5U2y4isbH/nbMnzY+TO+pN0yfPylxLj97Gx7LR1yN8cPtX2IoEKJ9uD1vfyqtDjqBn2w9DYFZC/iIP50f6f7U1PRNCgvXu/ZJ96eurAtWc01+/jQy0kBzy73OowYHDzm9flKZz/4kAR5BmAMeeNUdob56XRX/9WIz4UQDOyNFIGY3XXh66B6tJFt2T8z08y+vfNypKf9Zw23ctel/eM5nELdiNPkj/B//iFNLPlGz5dhwFf1NBay5/A5i1tP4FDtgpGhRLMNPXNE5WPcUu9re6HqcocQJBwfZVLyR5cXLXY0A40qcX23+Hn2VX8zZUDm9L89Hn/gouqnjVb1866ZvcXnt5ef1uk12ysJE+59PWvB8TiWeCnbttA+IAd6MEZoLifR054GB/dTXvxsYW4kLh1toaPyKS2Sy1cjnW0cvCIIwH5jInxzfQGEh/pkzKX+qfc4O7gCYPoZHK6fVn45Vv8jWrtcB4DF9bOrczUCwi/LYEmfhazL+lO5OTzY/yb8f/Hci8cis+lM++4o/jWGXY41lv7S1p44tT7ZoWBjk40/Nzf+R17Hmsz8tvE8+QVggtIRGs471fLmpF91wfxg+daKbqmAPVy21a8cBp478/KdAzB1nBlen3BpLZ1aJO3ICUKD7ib/wR7zO0ohh0aFZdA2soNBJNY7aGT5ZSB0N2rnP4Lmddeys7iIyrLH20tPUlO3g70N3EzWi7Gh/PZo1dl7N8vDbbzcT/JSXTavWuBoBeiwPtx/7GD/Y8Q+8fGI/I7qHunVlDAZ6nFWm1L48XtVLYLSE1YNraC9p5KNPfJSH7ngo50pUrvTkyU5ZGG//pLxoZX6Kb1yBAgS3VOUVNJrvqcTny8DAAezgDoCOtXB8ZEL6B17mxZduY8f27xCJnCMQqCcSOcdFm7/sNA3M1SDwfBssCoIgzBTiT0ly+5Nu+ngxvISdWPhQ0LEYNX0UTNqf4jRcUYu3qBtt1MPFKf60tGuj63FJlzr4jUFqPtU4aX+qK6pz9TQE8A4XsmJwa17+lGvk+mT8aaJ946Ew4SM9WEDlnRdj9EfzdqEL0Z86On7Oa0c/Mc4eC1umsvkTkNKAOUBNzS1ZHzuf/UkCPIKQJ+FwC0ND+/Kqs0yd9hD0ajx217WOpFy+qgKvprgkpSrYwxeu+hJ+LUbc9GFYVmIShJefnb6NfV3bF5ioZOvNAyuKW2gaGpsKtsxQ8Fh2hpIPhXeN+NBGdqNoMaq2/SjrJIjYcBXhnvXokeKx0aBxjTvCWymx9nHm+b+hz/DTr4a5+/2fo72yhxVXrGTPt1vBGLsW1fDwuZ98iX/5o7+hq/QccSWOJxEE0iwPq0Pb6Ly/iI74MVSvwgPbv0SPt40qfSlfXPsV/uvqH/LC8DP0d4+i/GgNXtOPrkZ5YPvdGZO2kkGduqI6Pv7rj2cduT7ZdOD0/QefPkvJ9faxkvLi/BfwqgS3ZH//aMMmo/u6CK4pO+9U4slmHs024XALR4/9xVxfxoximmH27X8fqfXlqhrkkh33E4mcy/m5lW+DRUEQhPNl8fnTVPr05OdPAC/0redo6RCrowGuiXgpOHfJefiThyuGtuHznOHcbz9Bn+V1/OmsFqLrfjDjEEd3St0z/WnsPs3ysKFvJ13fL6ZDz/Snv112D+GqEMuX1XK44QTvOviZnP6UuiBWEqnKOXJ9Mv6Uvm/4SA9qkc/Jtun46j6IJ/zJo1D7iV05j3Wh+9NicCfI7k+K4mfd2s9QU3NLzs+s+exPEuARhDwwzE72vvL+vOssU6c9hHWDl5t6HUFZUVnAf33wCt5730uOpGwob8Cv2dkFHjXm/GL6NZ3f3fgQd6x7hM/t+ewCC/JkktokudRQCJr2qpMXBRMTLTGa1DJ8eAJDeAvdcjLStZ7WZz+BZXpRtBiWEkOx7PTkniNvQVEYkxbTwyvfD/Oev30jpeuChP4gxNHvD6MlXl0Li+KRCv792W/zWO8vqdq8gtuPfQzN8qCrUQLxAqxEf1tTt1jatZFoZZS3HryLA690onkVfrj9B/aYUHMzYDckXDGy0TVpK7Xm3Kt60U07PTR95PpkU3tT9wcY3dtJ+EA3JTeucAV3YEx4ACezx+iPopR4qXg8woBxmsGUlayJhCP1fmBSmUfpzHSDunC4hdOn/ykxEvZCx/0cTTNMJHKOurp3ONuyvd4TNVgUBEE4XxanP01/n55sQybi+Llhw88o6lmN94zdI+R8/Kn78FsADRKLXJbp4ZX/DPOez98E/xcefeEZfvbaz7m6+R3OkPl+bxdf3/d1ft3y6wx/WhfchJkomUv3pzOvRNG8xfzb9r9J+JM9Zj3dn9L79dyz9P6cI9cn408ud/KoDDzRDHELxatScuOKseAOQNxygkWpmT0FW6owTPOC96eurkcXiTtBuj9ZVhSfr9L1ui4kf5IAj7Bgmc3O5Ub8WEaDsfFG5l1SN8L1y/dypGc1I/ElXFI34tR01tTcwu61K/j1J6/n5aZelpUFOd3c5owAt4CY4cGvjU3P8WsxNpQ3zIigVAV7ZjCdeWwVS1N0mgdXAnZw584hPz4UYlg8GwjT6Ynz1uEifCigxfAU9DDYfCXBqlP4inqIDVdx9plPOA0ALcNHrPAs/pFEpozlJzZU5TqnZao8/+o+rA39/M9Tj3EVdzhXpqCws+2N6B1RAtufpb20gR/s+AfqEqVWq0PbXM/Eq3qoG7QzdcBu1FzRV097SaMzJlTxWHz+7Z9xZe+k1pwn+/Topp4xcn2yqb3J/QefPsvo3k77+eom5mj61ADAo4Kq0PGVVyE1vV1TUBPfaalBICcDyKNQetNKgluqiPdHGT3QhX9NGf0PnnLuD26unHQjwiQz2aAuHG6hq+tRTjd8lbHSrMVFesrwfG4IKAjC7DGX/tTV9SgrV/5RzuvaVPI8y4oNWofKCXq1Cf3p0Mmzjj8BRC9wf0rfpzzQx09738R7EqVa+frT6JK9FHYmvh8sf+aRDdufilZo/PzIw1x59m0oietRUKgeXsGjTY8C0F7awC83/zvruy/lVPUrVA+v4CrWOcc6H39K79fTUdyAx1eSdeT6ZPwpdV9jOMbgI032883mTwpoZX4iDf303HfE8afBJ5opvnFFXv7kXVZMrHUIBfAuK3Ymc6EpFF1TP8/96SvTcryFyEL3JwnwCAuS2f5F0zybnTpLsBuMtXc8xJW7H806labl5Dt47+YwFgGWrfkGzSfehmXZI/caGu/hyt2PsqJyBSsqCwiHWxhp/hdnwUcBfnb6TShY3LHuYXxanJjhdWrLp5PU1Oao4ZuBVS67+drGshOsKWvhkSa72fEyQ7VFBLs0yxscoC9exqs+nTJLpX71c7Q+92dYhl1Hvvrmz2dMdwBrLLiTwNQLSV05M4nzr6e+QVvnaS6N35r1Cr2mn/qhdRwPhBhK/B/gTOUhLjt7K17Lj+ZV+Oy7/w/Pn3ueSLMJcRXNq9Bbfo4h7/hjQlP79Uw0cWuyqb2eyiAFO2oY3dcFhr0CpRR4M3c0TfoeOJFZKm1YWCooJs6qV/hIz1gGUNxi4JEmZ4ULcIJJyfvDh1PGsE6yqeBMNKhLiknjma/lGG++OFAULzu2f8f1es7nhoCCIMwOc+NPAefz+HTDv1BSsi1jKk3qdX3hqgD9Rd9je33puP7U0HaCFd6vuLJbLkR/qi3s5plzr8u6zxNN16Obvkn5k6LqhJY9R6B7G5rpt0esW2MZPGD703eP/hfX/+L3ucq4I+dVaopGQbiM245/BK/pZ31oFw9vuhddibr86WDja/Q2gWmQlz+lu9PlGy+h5G+qsvbggcn5U3K/8JEe8ChOBk+GP1nQ893DmVO94xZYYGqgGuP7U9qLNbbIZlgMP9dqL8DFJ9+UWfxp5kidrJVkofmTBHiEBcls/qKFwy0Y8WNs3XIv7e0/oKv7YcBO38u2EpV6bQoRrPBjjpwkH7f32INUFC/hZP9aqrQ9wNiqgW5qHOjaTlmgD0WxvwgUxaQi0DftK0Spqc0zt8qlcKJ/Ew0Da0iuSLVqJrHEalMMi+5IOR8M+/AkgjPmyeud6WGW4efQqZtZtuxlZ7oDxEn/+FK0GGXrnma4fXtiHwsVD7cc+xC/2nQvW9uuc+1vYaGgoKtRNq9cT0VTNcP6CGcq7VGPq0PbOFr/PO/e/juYVSP84KmHeDr+MLGtOitGNvL5t3+GN1V+hyebnwRgxcoSSovdcpGsHz/fMer5pPqG7n/NFgZNofLOi/GU+RlMCcjYL2iOE6gwcKmXlctXElxTRrw/ysBjTVkuJC0ylGVoQsFlSyi5fvmkAlTT3aAu9Q+EXNTUvHmeju+cXixLJxI559wOh1uIxUIoih/Lis67hoCCIMwOc+FP9Uvfy9nWbye2xtl/4E6u3P14zj+gLCvClcvOAmdz+tNL55Yz2P8E20rGSisMy0PT4ApWlbQ4X1EXgj+d6Hc3Oy41FJYZKq2aSV//Gj4w5Mebw586z13Ckvr9Y/6k6Cx93Vd5UWvidTd/nlhoPcGqU+ij5Zx99hNgekn603Wnfg/VypzkqhN1XOl3iz+AerTWyc7xmn4u6riao/XP847178AfD3Lql4P0Hi/CNCxUTeH2/7ODnaV/x68af8Wb1ryJy2svzvrsP7b9YwDcuPJG252KyQjs5GI8f0pttIxHpeTWlRQk+hTm5U8KmGGd/mt8rK5aMb4/pWJYbn8yoeh1dXhrCifdg2cu/Cl1ktaFTGHh2ozSrIXmTxLgERYks9W5PBxuYe8rb8Y0wxw+8j2WL3tf1n1SU50DgXoUxetMrqmtfSvn2n+KkgjixAwP0dC30Pt1goaHsBLHY7eeIW6qfH3fx3j/zrNsCH4PNbHdqxp8ctc3+Ovn/zpvgcgndfhk31qihs9ZgZqJVa4khXE/ywyVAcWi1lCcPBsFuD3sQ03JvFHRiGPhSUyG+J+O3YRDO/i/136N4EgVnoIeZ4UK4pSueZbKTU/gK+ph9c2fp/vQ2xhqtUdtekw/l7bfgBd3CrKFwemKg3QWn+HK39zBksTK1RUtt2NiOPsfO9dDHJ1qazt3qJt4YPvdvFa5hxPxw+xkpzPi898P/ruraXJ6/Xiukeu5yGcqRGqzQAyLkRfbKdxdR3BzpSuzJoOkYJhQslfHrNCJtgxlZvmoCpiZExLK37URvWOY4WfGAggFO2om3SAwW4O6qTQcTP0DIUnyd9Fh0dST40yDcK/YB1i7ZvzGgYIgXLjMhT9F2gLYf3LYpVOWpdPfvxfA+fxPd6fkddld+jL9aZmpYhWN/fUdN1UaI+/lz3d9A486tv1C8KdSQ3X8aa0ywiXD5XhRiGOx16c7wR2w/SmJjsW/Nd3CXyzf52TyJMu23nzmUroOXU/Z2qcBiI9WsfzarzLYvJuBM9cCuKaPpqIqKqtD2zCVOMUvbEFJOb+FxfreXdALp1v7gD7XY03DormtjbtesQdOPHzm4Qw/SvenG1feOKnXayJ/crlT3HSVUPnXlhE90Zf9wAAqYMLIs22UKWDenMOfsuFRKX/Hevp+dMIJHA0/307tJybXewcy/ck7Ws3I0c7zbtaclz8tguAOwOhok/PzQvUnCfAIC5KpdC6fTO15+kqX11vmpBqraoCSkm3OL76ieLlo85c5dvz/w7J0FMXrBIRURcWyIG5qPNF8HW9a82sAfCl14jYmV9Y9z8aCfRkN9byqybX1z9MxWuuSjmwiMl7qcPr+n9vz2RkfKZracyeZOeM8ryzNCGNYPBqMsdLQOOo1GNAsMP2ciJZzaUEPg827KVn5LAONNwIeBhpvoGTFKwD0nr6GodZLXMer77so4xwqHtb37mJd707X9Wh4nEbMAFgKHuxGhF7TT93gGvSiEXYu2ZlRI57aNHlf5z7X+M/0yVoTMdFUiEhDPyOHuhzZAAgf7hk/sOM8p5TXwYKhR5sz99EUCnYtYfTlDmeTb3UJJTeuJLC2jJFX3SZj9EfTj5AXqQ3qJjsqPh37D5dASmqxh3VrP82p03/v7NPV/QSK4sOyLvy+PIODhygv3532ORbJaBwoCMLiYW78KcLKFR+h5ex9TgAnEKhPyRjwoKqa406bN/0D/f17CQTqc/pTahDHxmRt8HtoWZoRLzx/Guu/k+lPY4tVHhQuj3mdYRXp/Dag06N4Odq7liuXvoynoJzQsVtBiSb8SSHcswG7T50f0PGWN5OaJZ3ubACa5eWqljuy3pd+Ox2PT6WjuCGnO4HtT+Wheqenz3T7E6riyqSJHA4RORya+MAKroyenP6UluXs21hOcE0pwS1VeCqDmIPRsfKt+OR676SS9KepuhPk50+Lhabmb7J06e8QDK5YsP4kAR5hwXI+ncsnW3ueutKlKF5KSrax+4pHHMFxpxTrvHb0E85jLUunueVeR2gAPKrBsF7krPqk41Hhqvp9Oa/n5lW/waNaRA0vn9vzlwApIjI2EjRX6nAucZnp6RKpPXfG+/I3sXjJp9PkNXnHiC00F8U0vlccZcCjs7+zlJqGDyWOkTqGVKHthQ9jREuAzHRi0DAxUNEyhGQiGUnFwmLI38vta26nfaSd3kgvPs1HzIhlNE0ujy1xjf8sf1153ueBzEkPxnCMeMh+r4283M5QSvbMtKNA+Ts32KtMKSSDO+nXl147ni0LJ5/MnMmOik8nGFzBmtV/xumGu5NXQm/v82l76Vg5ViUvNEbDLQA5V8azMZvNVwVBmBvmwp8qK6+lvv7dWf0J4pjmWHbPkaOfQMGdQZD0J93U8KqZmQTJTOhc3LLqN2iq5bgPzGd/GvOSifxJQ6FtyTFOD6wlYMKlMS/eRPn7Ka+JpsR5bHSIoye2cP3hP83qTzhBIy963zrX8RUUx58yr3Jy/nRsyR7WXV9BoGJVzoETACuGN/GWo3+CgsLm7itZce2yvM8D2f0p0tBvL0SpCn0/PDHxQbI/iYlRoOS21Qz+6oyzKdbQT8Vb1jo+E9xSxeCTLdPmT1N1J8juTwMD+7M/wbxeiIWM5bTgWKj+tDgsVxASpGfkdHU96tyXLeUuGFzB1i33cvDQB7EsnQMHP8TuKx52jR1Or0lNneZg39adDwdFCXDLpe/GsF7PS6fu55Ka/fiyxSNy4FHtD1W/pvO6+j10ji5JEZGxkaD37PuIE0SKGV6KvUPOylOquNy2+gkePnPTjAd4UnvuJAMs8cQXRLLvjoHF6NaHCESqeXtfNb6RDYCd4XN1WCGuBikduAN3cdcYRnT8AIqaCPIoTGCBZF+xss9oT4748ckf8+OTPwbAr/n55K5PjtWIJ5/zyRBe0/6C9Zp+Wk+GIDORKIPUL/Ild+0kfKSHgSeaGXykicEnWgArsyfONFN0bT3xjuGM2nO9dQhPmd91fdlEpOOrr9rX6FGo/cQuIL9RoJMdFZ+NmppbXJOzQr1PZ9krPXPuwqSt7X8pL7uco8c+m/gjyZPReDmVhTYlQhCE2WM2/ClJ8ts3mz/FjW2ow19EUyf3Pag5/hRjZ81BhvWiBe1PGjgjy18YWc4bL/sOx3s3ElGHMNu3gBZme996RnU/pxo/RL3aktOfJmbqY98VFPr93dzX8gDYaw94VS/feMM3MrJz+g+brold/YdN2DHxOcbzp9mi6Np64t1pfWziFuEjPQS3VM2IP02HOwGUlLinx3Z1P5Jlrws9uGPTeOYe/P5ajh77tPM5tJD8SQI8wqLCXXsecP0h2Hjma+y+4pGMX8hotI3kH4SpDQnHIrWX0t//krN/emkVQEX51ZSXX0FNzS1EIm28uv/PuaIuntHexDRBVSFmqGiKiabadeWZqchw86qn+MqrH8vIBvJrMaqCvXxuz2fZWXOQO9Y9zLs2/py3rns0IS5e/JqOZcF1y15gd92r5z39IZ869WQzwJ8Uxii1FAYUi1JLIWjCDRGfs99Jr8FSS+OShkvBdPfLuSjuc0RmKmRbgYLMgM54q1IlkUoua34TJZFKjtY+T3tpA2CnFAO0j7Tzq8ZfccmKK+hSY3hNH7oaY+eOzRNe38j+Lqc2O/lFrhb5xgI68VzdkqeX4RzZQQOPNTHwRIsz8WHJXTvxrypxxoMC9D/alHK9FsMvt6MWeF2rS/0/Pw0+D0W765yMIJj8qPhUWkKjvNzUyyV1YRTFwlocDjIhLWe/l9KkNO6UbcHYalMgUE8kco5YLLSgpkQIgjB7zIQ/FRZuYGTkWM5zWqisXP5BvN4ySkq20dyxl662f0VTrYzFtKQ/xU07w8Azjj/dse5h7tn30Un50/dee7eTPTRd/rS9tBGzaz1Do1Wc8pp2OXoK2fyp1lCoNVQ26/afcAoK14SDKH3L+Z3qVzn7zCedaVhXJI5zbcSLks8KUw7UPBbG8sEfL6BuYK1TetVe2sCvGn9FXWEdJZEqjhxppKO4gTVbN0JK8u36y2snPPaE/jRL5OtPlXe6G0vHQ+Hz9qfpcKfLV1VgDR9Ku3fxipRpRnnt6F+QDEBnG1wxn/1JAjzCoiK19jwWC6WkItq1lelN/yKRNkKhZwEvMJae5+42n2UsdRqh3qfp7Xsev7+W145+CiUhPGpaHEFVQTdVHm9+Pa+FNrOqpIU71v0KTyKVIlVovKrB6pJmPrfns+yqOcAd6x7Bp+lEDR894Qp21RxgZUkLfs1Ob/ZrMbZUHkVT7GMlj3O+0x9S05X1uI+7f/uXnIlVuvZJrR2PYXF/cZQBzaI1cd/VkbFVqc26B47cRrYSq9SVnHzIlYGTi8nse3HXNc7+63p38suLv8FXX/0qFhZexYueSCd/kAf5uw/dzWhLmJ07NrNp1RrXcVJXmgCGX+5g+JnWseeQSLNNTzXGNN014CU+zGE9azPkacfEPn/i+oZf7mBkT5t9bRpAygjQBMPPncuIekZO9Nv/Hu6h6sNbM4I8k00tbgmNcvM9zxLWDa5fvpf3btYnfIymlWIYA5M6z0IkGFzJ0FC6tGWfmKGqgQU1JUIQhNljZvzJTarj2D9bNLfcm8jiAdCdHjvpi2lJf3qsKbs/peLX9En70x9u+X94VRPDVFzZQOftT1d+Cb8nhhn3ceaxz3PNUJVdjp4I8mTzJ4B3jPgy+hkuNTQ4cjtnuZVsf9ppdsGb+7WepCdNB9vbbmBn201O6dWT677Pka6z/NG+u3jziY9h6Qq66uXfdv4pX/no1+k/bLL+8lqWbRzL0E4vV4qHwvn5UxbUEh/mqD47QaA0f0qOX1e8KmVvX0/fj09OyZ+m6k5Br8b//v7E7rR4cGcXKorXcaKF4E8S4BEWBel1kckVpIbGe5zVbVUNpDX9s6UkyfJlH2b58t8nGFxBe/tPUn6x8/tATO/RkwuvanL7mid548pn+NnpW/GnNGJ+oW0nl9UddOrP71j3MGcGVzKkF/PVfR+lKthLT7iCu3Z+03lcUpiihpebVz2NJ612/XynP6SmK3s9Md4fbOar4SrXClRq7bgPeyVqQDNcq1I7Yiqb9WSQTMNdG35+TEVaktJjYTHoDVGqu8UtPdNnbddOzpWcojhSSd3gGob8vRRHK2gvaWR/5CX+9o6/zTiHa0SnBlhZplWpOAKTXJnRyvxETvYx/Gyrs7BiDo6tPhbsrmX0xQ5mlJTy61Shsr8Hs0iSmWN7gtEDXa4ATzr51DS/3NRLWLff10d6VmMRQCGSdV/nci/I4E7yP44X+z+ISXf346iqH9OMoqoBampuAbJPzDDNCOvWfgafr3Je1JALgjD3zKw/uUn+LWtayQUw+7vDPcknN+P504Gui9hcedLZls2fdFPjk7u+gVd1L6rppups01TLuT0lf/LY392qJ2aPKR+pdhwJsvtT8mfI5jkKk/mzbiaCOyamk+2TLYDkSVkQVVB4w+n3oqJhKHEsy97Xa/qp6Kunpeg4b33vW12PT28mnCswks2fUBXCR0NEXutxFsmS/lR03TLMaHxW/Sl5DZZu5p7ANcP+lOpOYd2gcfgyyhJBisVH8j+OJ/GvO7hzyY77nddwIfjTnAd4/vVf/5V/+7d/c22rqqri+efTG2MKQiYTfXiFwy10dT3qiEh6XeTaNXeh6/14vWXU1NyS9kvrFoqRkZP09+8lEmljZKSBsZGf2WvIp4pP0yn0jjolVQCX1x3g5fYdTiNmnxbnL3b9m6tx4K6aAy6pURR4pvVKOkZq+N2NDznb46bCTxvfwCvtV51XevHJvrXocR/exApUrGcDyyx7pFNynGfQxJnuEMOiVTMpNXBWpfSsX1zjS4eV+F++KcPnm82joFCiV2IQd03VSj2ehcWp6lcojlQ6DZWT9+tqFGtDI2eHzmbUl7vHm9tHSqf8dzY6qzHJf52gUA5mXE5gahm7nkQgK+UpFOyoybl7vjXNl6+qIOjVKPR0sqXqDLXLP0/n2b9msfTaGSP5H2fss8uyoqxd45aOcLiFWCzkrDYlUdXgghj/KYg7CVNnfvhTdtKzmyeLT9OpKgg5ARrLgt5oOc+fu5zXr9iT2MftT/fs+wif3PXvTiAHxvxpOFbIm9Y86Wx/sv0i2gfXcqJn+3n5U3vPOuJxH56EP4V71mNgMaBYXBqxs5g7NMvpvZP0p2LTvQgVJ/sk0lyYiS/fyZZc5etRqcedaH/b4+znmjqO3cIiHBykrqgu4zHpzYRzBUYm60/Dz51Dq/BnvW9ayeVP+XjVDPhT0p3CusGy4j42lA1StfxLvHb0Uyxef3I/76V172LVqj92XruF4k9zHuABWL9+Pd/73vec25o2ia6zwqJlog+vbCl0ybpIwPXYHdu/MzaSM1Fjnk5v3zP09j2TttVDcfHFDA0dnJHnuKH8FKOxAP5gcoqEye46d1f71FRhO634rOt+y4Lj/XW0xOFthgefFiduwTe7vZz27mUkfvV5XVtPuIq7f/uXvD/YTKxnAyMjVQwUxjLGoceweCoQc+rLL45pzgrUZMQkiZL4X77CMZl9sz1Wy/IxaWCgoWEkJPaS1hvxJvoGJc/jNf385pVX+Z+2+3nwLQ+6gjz+VSX2l3V6WrAC3vpCiq5eRuEl7i9uV1BogRLYXEnR7jqiJ3vRe6MZPXjAnX7dH9ubV03zisoCfvnHqzlz/M9RiNDV6mXxyUk6PiCGqgYpKdnm1I739b3I/gN3JiZCBFi75jPO/fNh1UnIH3En4XyZL/5UWLiOkZHjU34+6f14AC4qP+5sUxR4/fLnMcy0cd8p/nT9st9mTOeyLDgZ9tA3VM/NpoZHNYiZ8Ipymp6Cs4zEd0z6WksNhbd01dP82OcJVp0k3LOB8EgVDwdjTvkVQByLvT6diIrjT8sMzbUIpUxyxWWy/pT6uOnExOTVpY9xSccb8Jg+130KCsFwCR//9cezupOr5MpyPTCnP4WP9IzvT6aF0TN+1u9cU3T1Uoour2Pk5fZp86cVlQU8dte1vNJ4hLLhT9N5NkKXIv6U6k+1tW91PvcikbYF40/zIsCjaRrV1dVzfRnCAiN9okP6h1e2FLpkXWT6Y8d+YW1ZaW7+do7pO+nEMc3McefTgWXB+vLmjO1qjskRcdNOOfZpcZfsKAp88KIHeXpIA8WWF9OCFT6LfiNKpKCJ+EBl1mMq3hBaQRPG6CosPXOf3nAVvxysIWBCJKCzSlcy0od9KFSYdmYPuCdCmFio5ykOcyUndtDH/kPKg4/bj34MDU+GMOlqlPaSRiLxCPs697kkxVMZpPSmlQykT3ZQFfTWEfofPIV/RbGrnlorm4XVpZkgJSU5criHyLFeaj9hj0SNNg0SD4VdEyRS069L/nhrSlNPd03zUNtJWhv/m1iwmxVr3keBcs4py0qdvLJYKS7eTDBQT0HBKvbtfx9goKqBxCjiZNPTCD5fpdN0WVhYiDsJ58tM+dPmTf9Ay9nvZe37lUmc6ZjOBJnBHcuC2qJQxn65Jm/FTdi5JPOaFQU+sPY5TJ5LNG1W+EW/xhq/CZyfPyVLr/SRavSRak574pwN6BRbY/4E9oTRK2O+xLhzO1Mg1Z8MLGcKab5Mtp9hOtPVt0dF5ZKON2A5peljpflxJTauOy25ayeDT59ldG9n2kGz+1M8FGbg8aYpX/NcM/zbNgIbKii8vM4eg57mhFPxpyuXnePoMfGnJBeCP82LAE9zczPXXHMNPp+P7du388lPfpLly5dP/MAUDGP6S2TmK8nnupieczaKi3e6PryKi3e6XhP3/QFWrfwTqqtvxuerp7jYcO5L/SCzRecgvX178r6O8SZATIVs07hyYVl2/93kB0/6Y70q3FQ69tr4VHhruc4tpTr/t7mU7mzn94YoXHMPiqpjmV5GGu9ySUpqA8D00eeua8Nie8zDRTGN3wZ0TnlNHg3GeFPYh5ZjJSmXRMxFU8D0c6dfQzLDJ3Xb8suK+a/ot7giso5TXj87qnYQ7R4h1jSIb1UJnooAvosq4PFmd+144mdLNxl4qoWi65YBEGsaJN41OgvPcgZIf0vETYZeamf0hXZHRKr+dAeeigDhxn5X+jXnirns0l8wMPAKpaWX4vPVYxgGwx2neeXoW0CLQwx69j/Gpo3/7Po82LD+7zhx8rNYVjzr6u6FztDQwYzMQtN0r1AqijfjczNJONzivO7TuSq12L+3ppPpcCdYXP9NxJ9sZsqfkiOF82V++VP294RHTf3Z4u3lcbuvocl5+VNqkAZgbVxjXdyDjuXansSHwnpdJWzAgGI5RVC5/Gkmmc7AkDtzZ+y+/SufoFCFawavYYdnC4ZhEO+NuPyp8Np6Rvd15fSnkcPdFL2unnhvhKHHmmeii8LsY1h2Y2Z7VJzLnYBp96fjJz4NWRqULwYuBH9SLGtuh8k+88wzRCIRVq1aRSgU4pvf/CaNjY388pe/pLy8fMLHG4bBgQMHZv5ChXmJYXZixI+heTajqUsmdb9hdqLHXsS0honFHsEe9+nB57uNWOznrn01bS2KsoR4PP/Az1wymT9ov3vkPexpuyJju6f0VYJLf+TcDrf9DvGBXc7ti2Mat436Mh5nYCUmNmRHx0q0Alw4f3FbWByueYYtXdeioo4FtBQdVVFQzbEMHkszWHOTwZa9BaiGgq4atOyOsvqlAlQDTA163xjAKFLxN+uUvqyPJbmooJhja1mmAopqJ15ZCijjfFpPvTX19JDPdUSrFPw9Y09mcKuX8CYv2rBJxeORjNcpFcPsJN7zIGH/U67tPu/r8Qfe5vy+6/pLRCL/L/s1LsKATyYeCgv/Cq/n4ox7DLOToaG/AKKAn+Lif876+ToVduzYISVFU2Cq7gTiT4ud6fOnh7F77uTqR1gB9M7AM5gZZsOfLo1o3BDJ9KenAjHXCHSw/cPAdqb4eWTtzDUWFq8sfZTlA5sIe4dYMXARmuUhrsawLAuv5U/xJ5OqG3rZva+GqK7SY1p4rvRRtz+etz+BHZYYvNxL6at6MnF9gmucO39KPfdkr2N0tcboJi9GkTqhPyV/n9VQH8MF/+s6Tj7+lDo9Tpj//jTnGTzXXXed6/aOHTu46aab+NnPfsYHPvCBvI+zdevWRSOLhmFw+PDhRfWcx+fmrFvtCGojpaVvzxpB7et7kUOHH0ikI/qwLA2IJ4I9bgyjAWiY5uuePpJCYlr2l0OyqWC2tOXUbXFTyzkBwhhdhWV6nRUoY3SV6/7UVajU7JbjnjiDqsXlMW/WQM/59N2ZaxQUtnS9zmkgqKBwpuwIBQEfh4r2UBgrIxAvIOIZ5UzlIa5q2cg24w8YMSzaInByTwe1xmoKNQXVgOXdJRRdtIyYOcjAy6cTx4Tim1YSOdmLfmYIADWlkf94wZ3k4+cD+VxHanAHoOSYwdo3bsVTESB+0dhKXX1iZSpJONzC3lfej+kPu0zIAiqX/T4bV1wL3Ew43EJj48NEspbUqyjK4lyVSlJddStr1vx5zpWljo4HOX4i2TwwSv3SEWprd0zLuZPfX8LUmC53AvGnxc3U/WkMFTvIk162PvPBnakE7fPxJ7t3j4WWst4wFX865TW5OpLpTx2axSlvnPW65gRyFBTnj7WFFtwB+/ovabsRD96UxbE4L+/4CWesU6wObSMQLyDqCdNYeZCr2jZyif4enhqKYwDKr8NcWaBR7VXH9Sff+jJiiRHiKlC2V897KMRcvqpKjp/zoeCMQWGr5WTy5PInx53MMEqBDwwNEtPaUv0pHN7MwMArjIwEOZsyJNUiWd6YOgZscVJX+zusWPGRee9Pcx7gSaegoIANGzbQ1NQ0qcdpmrbovqwX43POF/vD7M3jNhA8dPgPHTmxrFQhWVh1p6lTIlInT6TKSdRQaOhfx+aKU67HGtbYTqn14iWRKpbFajh36s8ZLm7IqCFPHXN+ka6xPTZWpnRx3Esci4NenW2611l1soc3L8wVKMCZ9gBgYrCq/2IUFG5kPYYSx2N50dUowyUtFOlBBiydZ4cSCa6R5fyGOK8v9lCoKfS81MnJlzpZffsa1zmsmOEEdxYVcZN4yzD+6kK06kL81YXEQ2EiB3qcUacAQ0P7xvpCKFDAbvZ2xPjl2as5+1SUx+6KUl3Q4/zuj5G6sry4gzsAPaHfsH79p3N+f1RUXOFK166ouEK+a+Y55+tOsDhdYjE+53yZrD+NoVNcvIOhoQOzer0wtYzMifxJNxMDyNMGT2Xzp6KhtdRHKmk1qhhsvCtrD57x/KnWUCi1FB4Oxrgt7MODPahCwfanhZgBDWPj0ZNlWh7Lg7+jEpac4rLWW/GafnQ1ylBJM0V6kG7TcL6xLQteHDF4fbEyrj/FTg24T7pI4hCWPrE/pbqTRYzVy/6cvvZ2nu847vjTL//4NC0n3+GUZSYbDYOK4njTInlRx6Gu7g6KilbnvH+++NO8C/DEYjEaGhrYtWvXxDsLQg7GayAYDrdw+vQ/XTANxFKbKefCq1pcVHkqY7tfi7OhvIFQXHHqxYtGl/Cug5/Fh0pstJb79XIGtLEP9dTeOzEsflIY4+KY5hIODwo7dR9xLF7wxTjst78ckuPTf2fEt+AEJZXUYI+Cgsey5cVr+vlk4/9hrc9Po667QgkmMLSiGFqGnJWpgz88yQ2FdtAHYPiplCWTCwG/ajcqmADFq9qTxRKkNgvEo1Jy0woKtlRRVnaZ64uzvfDP+MrjyQ4IBi839bKp5HlXcGdp3buorX0r+w980DXScjFjWdGcE8kAgsEV7L7i4XFHKAvzC3EnYbqYij/NRXBnOhjPnzQF1CwptOn+VBIr4V1nL8dr2o2R76eKgbThFNn8aXNisqiOxdURL77EQtjDwRgeRaFVG/OnVs2kNq44PQwXGqm9eHa23YQ/HnQmkKb6U7+mY2GgJFwrH3/CvMCCDx7yGmaVjz8VrXc3XK5bdTv7RlW+8niyz4zBa83PUej83kdYt/Yz+HyVBAL14k8pJCeS5mK++NOcB3juvvtubrjhBurq6ujt7eWb3/wmw8PDvO1tb5vrSxMWMOl/CCa7x4fDLbzw4i2L7oNKzeEBUUOjtPg4tWYPw6pOpWZylc9HYWEIfaQaHworfS0cVgucFajkBAhITMgKNPNjTxnvHKjOCNp4ULgi5qXY1AlYKoOqSYWiXlA5FFZiRSOZYu2z7I/VJZqH19Q4ZuLJal6Vog0aPWdMZ2XKMCFkWLagXIiZrzmCO+W/uxFMC63Mj9EfdWXpQNpI+LjJ4CNNDD3ZwpK7drq+OLtHqwh6nyWsGwS9GsvKgnz0BwZ/dbkXn6aD4qG29q2Ul++mru7ttLX9b9brWRz4UFUV04w4n4nhcIsz3jh9zGcwuEICO/MYcSdhphB/cpOPP/m9Ua4yCygIDjjutJxRRkqPujJ4svnT9/3F1EcqKY/DlTG7L48HhdvDPg5646yNqtQaHlo9BnGvwm0LNLhjYgKWE7RRULio6ypXiVrSn8pUL52rnqK6+XVolgfNqyw+f8oS3AlsLKPo2uUY/dFJ+ZPypMqlf/wgw8ph53v+8lWjBL2a409V5ZfTP+zDr8WImxo9g91ctO4WACrKr8xzsvCFTfrn4Xz2pzkP8HR0dPDJT36S/v5+ysvL2bFjBw888AD19fVzfWnCAiZXBLWr69EMOVEU+wvVXaa1cJhM7blp2g34k3gUg3eufJU3m3BvVwEfqYngV09gLv88Zx77PKPhEnpW/IBC36AzBeJcIIQersFracSVGMWFR+kuP8ILrW/hdaFtGedUUdgSTzQTnMIkg7mcoDUeqdekoLA/bDBoWGiaxca3+yk3l2EBBUsi+P73HFWaBw1bUjSgMrn6dKHJSQ4C2yozRsCn419VguJVxyQFOw052jSIf1U1JW3X4PWVsKIyyGN3XcvLTb1cvqqCl5t6icQNnBfTirP/wAe5ZMd9tLf/eIaf2fxGUWD5svfj9ZZRUrKNrq5HaWi8x/V5mK0cQ5ifiDsJM8Vk/cme1bIwM6In5U9pZVyp/qQAvjR3Cq35JsGCLtcUrWz+FCw/wsmhS9nRuRtiY42XVRQu0b3O7dK4ykXx+elB+aCiZtnmzobeHzYIxU1iwA033kLfjSFqh9ZSWeEZ15+0ygBGT9amexcUaqkfT5mfwNqynPvk8ie1vZTqVbcRPTpIfFWYFZUFLn965Eg7P9n3Ef5817/jUQ36u+9jT/f/cxaGFjdeaqpvYtmy9wDQ3Pwf896f5jzA89WvfnWuL0G4QMknglpTfRvLlr2HffvvnJ2LmgEmU3veMLCS9eXNzu1kw0C/Cjs9FfhVexS36onRdNH3eTo+ylAgZMtL5dPoAzuIr7ifB2IlrO7ZwWWtN3NVyx1c1norD2+6l3jvJjxW5mSI6SBfqbEsEzN+DqwRUApRPfUoSqZYTBfpgScLhdMxO8Cg/2SQnX/SzlVLtnP4od9SRACfBjcUewgZFhWaMpZevEiIHArR8VovVR/c4qw+xfujjB7oomBHDYG1ZXgqgyy5ayfhIz0MPNEMcQvFqxJSwfrKq2iGfXvJXTtZUVnAisoCwuEWlnieYmfNQXza2NKXZUVpbPzaBVOSeb5YVozmlntR1QCWZWVdhU8vxxDmL+JOwkwi/pRJQ39uf0qS6k7DgZB9DlXP4k/buaz1FsefHth+N63F+9APfhZvlkCIc70TeJCV+F+2YEq+i2Sz6VDZ/Kk58VXd9uMIV79nLRtKqjjUsJ/lFLr8qTLFnxZDcAdg9OVORvd1UfWB6fWnhrYTPH/4f1hVMoRHTV2JjTlZ6Isbna7uh+kJ/WbB+NOcB3gEYTYpKdmGongTk7O8VFffRHPzt1moq0+TIWZorCrJ3uNFN2FfPMRl5ljblOd95xhU7a9eywJf+V68pftQVIOhQIiIbxCvNVY7XRyt4Ic7vsTyM39A0cgyLtG948rETGTkGLFT6KNPgTU8tlEpwltwA5pv/bSeyzn8OM/Ba/l5dc8R1jYbVOsBVyqy/dj5M958VjEser6dmASQklo9ureTqg9vdSQluKUKEnf3Lyvin+97lU8b9nsumdHjqQwSDrfw4ku3YZph7ljnJWZ4XEGe/oGXZ/HJzW/GX4lTCQQkA0QQBDfhcAsAqurHNKOLzp+ihmdcf7IAX8Kd9vibGVR9YGooqpHDn4Zc/lQ3uIaTNXv5r6WvsqN7+3n7k5L4Xzby8a3ZdqjxrklB4eyPu6gO9rLMU0hUieG3fI4/WYvTniBu0fOdw2PymMWfANQinxMICpX5xvWnM8ffzvsvihA1Mv1JGGMh+ZMEeIRFQzjcwoGDH0qZnKXz2tFPzPFVzQ5xE55v38ENy17NuM+04Jtdfhp1hS93BFjjN2mMqrT3XIqvzN7faeSsGlimiqKatJc0oqtRZ/pBe0kjg74BXvb6uMgLij72xTuCSWHaitKMBHdGfpF5hzWc2P7mKQvKeEEpC4vXan7Lpu4rnCwmXYlS7w86qbIKCqeLQhxvLXFSjG8o9iy6LB4XaaVpg0824ymzJSTZKFDxqhy8cSmvGDGGgv2Y5afwD2wkVLaFR15tdTVW9ms6D5x4Cx5N4327RhkeeGy2n9E8xTZBdwZP6nQxAJMDBz80r9KMBUGYW1ID6OBzFskWkz/tad+e05/+tXkVI/4Ox51Chkqsfye+8leA/P3JMr306nV0pPlTNu+YiTKtmXaoifzpZOUrrA3tcCZuWVgs99glXKNRi54NJYTbOjjdXpjiTylZ0BdiH55cWGn/Jhh80s4wC93/muNOS+7ayctNIRp8bXSXt1LatxEttoRQmc/xJwU7cOHXdH56+g4+/Lo1qPHjdHU/PItPaj5ju9JC8icJ8AiLhtTJEIsNjwrX1mfKCcCZKKz0m6z0mxwKa+wd9VChmlxdv4czMVtW3JhEBzZiFZ/gge13Uzewjlb/AH2ja9FbrwOgo/IF9MhuR15eKuzhhqGlaam405fBY1mmveo0Dvro06jetVNKNR5PTk5UvsLB+qc4WP8UqxO9iFoqjxCImGwy/5rhuJcij87P1VdYy+sB+6vBaRIoABA7M0jnPfsouXGFExizdJPteFCLe2m6/O/xaTEgwP/9wV/SOlTOsmKDL1wVwLIiKEqAmy/9PS6qHkUf+gnDzqjPxY6FonjZsf27BAJL6e/fy8hIA80t97r2mm9pxoIgzC1ud4phLZY/ohNM5E9ry85hAYfDGiFDpUI1WbNsD2ei2fwJooMbsYrG/KnFE2FgaAv6wOWA25/i6IA9pdQgjoKCipbVn6biVLPhUOP50+GaZ9iz9qe8EnmEzZ27KY5U0lV9jFu6fp+RuM+enPXqEIpa6MQ0Mvxpkb0vsxE7M0jPfUfASGQ5JTJ1LqkboeCqf6RXi9Fl+Cgr/y/uvP8lwrrh8ieLAJ+4/Y+oCPbR2nocxJ8SGAvOnyTAI1wQJLuZpzYETN+WOhliMZIrhrDGD2sDdlbTLaU693b5+EhNzCnV+nJHwCUpigq+khNjteuKiRboxuc/jhUvxF/1NDHV4oGqZ6gbXMOQv5fbjn3M9eVuYPJs2Rmu7V+JNg0fQ3a9+PD4O1lDmPFzaN7lUz5fNjaFLmNd7w5+tfmbnKk8RN3gGgxMRkx4ajiOx1SJq3GOLDvCWu16MFR3k2XBwdJNzFHdaRSoeFWWbqniW0s1Os8mZSPCiuKTtA5dQetQOQMFX2JTyR5qa98KmOzb/4fO8cqqP8hD+05w3fLn5+T5zBcsS6e19b9Zt+5T1NW9g3C4hZaz92c0CkxOiRAE4cJnIn9KdSdF8aMoyqJrupqPP92alz+Z+Iptfxr0hxisCaEo4LPAslTHnx4uPsjtxz6Gxxprspx0JQOTg4XtXDKy1Cn5TpZmnW+QZy4dSkHh4q5r0D0xWsuO0x/s4tiSFxkKhPjjokaubLuJJUNX2pdg2g5qmYg/5cKw7DdsoteOf1UJBbHf4tdsd/JoMTr1A4T1OoAs/tTHvv3vcQ5XVv1BXjz+HJsqT83Fs5k3LDR/kgCPsOBJTR9OdjEHMrYlJ0N0dT2Krvfj9Zbh99fS1HwvIyPH5/hZzC59OpQnvCG1yaBfhUuLDKdpoF+FNX6T0GhaeZUCxZFK3nXwM06WzgPb72aw+inneEOBEEOBEBu6LsNruT9qNFRWjFbz6zU/4MbG38/aEHBSWCPTu99Eh0mTqOTPHsvL7Uc/hqWaeEwfuhpl77JH8JiJ0aemj2WjK1hz2TClRyqoVJiz7B0Tiw61nzBRgvipNctQZ7iePbOhYuL9l2Xlbei356j64FankWBbf4TuI7UoZWOZOi1DGwBYVtxH6eg/0jYSob3jIWLKarwpx2rpPs2VSxdjH57MF7er+2G6e37NlbsfJRhcwSU77qOj4yHKy6/EsnTXH3mCIFzY5OtPyalagUA9g4OHAMSfOH9/Sn+sooA/xZ+KoxVoVvY/0TRUto/UOd+l2Vxk0syiQ2ULQml42NX2Rna23YSC4jhlRyDEk7VP8K7OnXZGkxpj8yVQdKJg0fvTeJTcsgqtwOuMUB89vgEsPyhRVDXIxStfR9B7JpHBM7E/rSk7MzNPaoGxkPxJAjzCgic1fTiZHpf8OXVb8peu8czXE+ISwLLMBTsefSoUa9m3WxaciqjsKjCcFajGqOrcB7aIWBbUDa7Ba7qbBA7VhDKO2V7SSFyJZUzXWhsrYfV0BHcAlMLp3W8cDEXnaPWLlIVrWDq8Ds1yp0treCAxdcBr+rlu2XXE2gyUuEZcjXFX71uo6PfP6afvGbWLF70nGVHGVh4KLT+79Q2sNmtm7LyZfQTInVZtQNfJXhpHo5SMRin+VRPr8TAU/Ft6bx6kU9vCB66t4rGjnbx/ezvWqL2ibFlRvNZxZ/ytZUH7kJeNJRd+I9BMLEDFeUMmt1pR53PywMEPYZphOjp/MW9qxwVBmB3y9ae6uncAqYEf8ad0DAteHdFy+lMyeJP63QRjP6cGfFJ79GQujFho0+FNqcySQ5mYNJUdIaAXUjuyOsP/ks8z6ZQ71l7EnrY9PLD9bjb1bbP9qUH8aSLiXaP076im8ekmSmoKKf5VH6uDf8dA+QmOrr+KYLiK919lcrY3zLu39BAL5fanwdFBSgoXc9Nld6+dheJPEuARFjyp6cOp6XHZtrllZu5SjE1UjrOZfsopo49NHENl9mYRetSxLM5UFAU8irvZcjK9OH21qdXfh67G8Jo+dEWn2fK5JKU4Uknd4BraSxr54Y4vcenp97JxaLXrfCrqtPTiUT31oBSNn2KsFNv7TRHV8rC163XE0Xlh5U+5suUONMvjmpBlYaKioXgt/jf2H0S3RlkxvJH3LL2ZioPVU76GqXBG7eLX3sMZ20eI8mvvYd6gb512STmfWReWBrFnWlmHQoxufIkjFIeX8I2HSvil1Q10A9DfP8ynL818jzb0r6B5cBnX1I/fW+DCJvNzRVH8lJVdlvWPu/kkKIIgzCziT5PHo9rNldW0L7WGiEJDzMOXO9QJ/cnUC9BH1mEMb8ZTfBTLVPCVHXLtt3fZIwB0F7VweePvURex3SG1FGu6ehnOlkOpqKzp34aJQXPZEVb2b8k50j1SMMTLHYcwLINwwQC3V11KxV7/lM4/VebCn86H4Zog0W8fdvtTuIbqcA3PtYX5q2dedPZtauvnE7vcjqYo0Dy4lPqiDpYVHsgIQC4uDBTF5wSzF4o/SYBHWLCk1ogn04dT0+N2bP8OHR0PUVv7VmdbIFDvTICYK/ZyBf/JB+lVqpxtFVYP7+M+LuOlWbuObJmtscSKU8hQM9KKU7EsGCk5zQPbv0Td4BraipqIFnQ72Rip5VtxNcbLyx6mwTfEhhmaBqEoKt6CG7JPgEjgLbh+Sg2WnXMly7HwclXz2x05SU2Xrvd6qPAavPK6w/QMtoEXXgvswbPxdqzXQIlDlCi/qHqOd/TfhBK3wKNAPHs6y4hhETIsKjVlSinJJhYvek8mn0j6EwMLXvSeZGW0elrTjSc6klkVQO8J40/saQHddQXUtI4C4EMhhoUPhTAW+yz3alJVsDdDPqKGl+XF7awta8n7Oi90iampvo2Skq3U1NzifCZm+0NOEIQLG/GnqaEqmVk5jw3ahS35+JPqHcVfdgir5DCgOuPUwe1PhhLnQN1vOB4IURupygjqTNegitl0KAAVjdX923JfDwpvLngr3zDuBiBuxgmuLsfan8OfxmGh+9NEvIDOTjyOPwF0Hu2hLnE73Z8O4fanUn8o42qjhpf6ok48amIC7AXsRflQXXUjJSVbARaMP0mAR1iQZKsbT6YQJ+9PT50DUsakz808xb1cwT18KmN7LxXcw6e4i3+aVUlJpTECvxrwscZvQiLzNH0VKkl6n5307anlWx7Tx1Utd2Ao8RkZ7ZnEHt/5ZnsSROoqlFKMt+D6KY9Iz0au8rJaj8Jynx9v8GLuHxzbXlNYg2VF7XaIikq/MsCJNw5wZeGlRJsHGH25M+NYI4ZlT5Bg6mPVO9R+V1pxBoq9EtWh9rPULD+vc+RLalZPV7GHhh6dq/ElL4Pq1lGiWPgTUjL0plUMdo1QuKaMvgcPgj6WMnuyby1Rw4dfixEzvPzs9K1YKPzuxofyv54LPLijqgHWrfuUa4Up2Zcs/Y87QRAuXMSfpofU74vDIwr9hsplBXF641DhIas7pT9OUS2S5R/J3oaXtN7o+JNm2b1p4ujjBnWmI5NnLhwq57UATb37IRHH82t+tlRdjGW1ZvjTzu71jO7NdCe4cP0pianAo1aMESxuZKwNQu2Z4Qx/amsZ4J+PnqPNcP/u5uNPE/nRhe5Py5a9h/Ly3a5t892fJMAjLEgmSo1Lv7+r61F8vsqUCVqzLycmKv/JB+0b6Z+EibEA/8kH2cXeWU03TrLaDx+pjuFT7UweAF+OSRATkVo/niS1jGmm0HzrUb1rExMhRkApRPXUT3nVKd/rNjFRUTkYNin3q4wWuFc6Rxt6UY0iAHyWlw91vwPrCQXermQN7oA9BjQZypjqWPUw48jJeeyXL+cwOUScbXiodzKewFNbQLw7TO2ZYWrxpa1MQnx1Cc8SZ8vl9Vx2SR0toVFeburle3deRmt/mIHRGD8/2EZnbw8Pnb4FTVHY372D9pFKqoI93LHuEfxazFVPnktCLmQ5Wbr091i18o8yBCTb9BxBEC5sxJ+mn62FFhcVRPCoY98zk3Wn1MyddOfw4HX8IhvT5VUz5VCTQQUuL1Z5NtjobPv4jo9T0V1In5HISkn1p125n/uF6k8AKKBa8HkKsmR2QU9tkO7qANt2L2P92nKqQqP83rICAGpLAjx+tJOyoJenXgs5/rSvezsdI1XiTwkqK65n5coPZwR3YP77kwR4hAVJrrpx9/0Bp068ofEeLtlx35yOST/OZldacQaKSi9VHLc2cxGvzdh15PqwVhTwJW77Ur5Dck2CGI+hQIgfbrubi7p2c0liKsJMB3eSKIo6I2M88yEpXwbQG7PY+EQpK9cspVltI+AJsGrLRpQX2rH0MQFVdIu+B07kPGalpjgt3qY6FjRIfvXrQfy5pWKSnMPk/QwTAQLA9ylyjqeV+ol3jDr72u+TsfXhv2np4mVDJ9jaw/dKfHzg/r2EdYOAR+XOq1fxveebKPZ28YWrvoRfixE1fLzcuR2AnnAVn9vzWW5b/QTXLXvBPn5ak8vFwuhIA+AWEsg+aVAQhAsb8afzZzx/8ihjP8Pk3Sk181lBwcRAxe7obGExW4G1mXCoyWACEUPhC2c/zh+v+SL9BSPcuPJG/LESFK+a4U+jL3bkPNYF608pSXTZMrssLP6xo4cTIYXHbllLS2iUm+95lrBu4NXsPWOGRW1hD5/bLf6UC00rIBI5Rzhsl/ovJH+SAI+wIMmWGpceTV2z+s843WDX71pWlEjkHJs3/QOvHf0kc7EC1U9+KZv57ne+5IrEp29LNmFOnQSRD6nNlfuDXdNeK24l/tvNRrBoclioKJiMiYSiW3xzwz287D9F7dBaSoJ1FN5VR/tTZzm7p32sJnyct2OhpnBDsWfKNeTnMDlgFhI3i/EoQ9kb41hQiB/TLOHOHEGZyXKIOMl2nJHE7fpkKZY/S/p64t/WjSVUnAizFIU23eCnB84RTpRlReIm33rGXt3bVdOAX7Ob3/m1GBvKG+gJ238I9ISrePjMTeyue9XZBxaPnCTpH3iZF168GbCwLB1VDbJm9Z/O6waBgiDMDOJP54+iZG+wnI3JulN7SSO6EsVr+dGVKIfrnmFn2xvt86KgMDa+a7YWzGaDbM8lqEDA8vO5+s9QfdFGRo54GFkHS+7amelP43DB+pOF/SY0M38XTeDrhKlFo0uP83JTL4DjT3pKidaaUvGn8ejqfoyu7odRFB8LzZ8kwCMsWILBFc4vVLaa8pISdwO3/oH9tLf/CLecZI4QninK6JvW/abCRB/QlgX/L+TFoyg568jTKY5Usjq0jcvO3orX8mNisGflT4mrMTymD4M4JgZe/JiYWJhoTL5sa75KjYrC7kKNsAWlHoNCVcHyKJw51kL3/iI6jE6O/LSbN318O7966hyGYeVdE144xeaAqatAvthG3uw7TDFRt6Qkfi126xs4jJEzKDNZtuEhkDhOIHE7SeRQKNfDWHZikL8mSBiLP/KEuWpNJT95tZV4mtCk1o9HDR8n+9a67k+uRL2ufg9vWv3khKnGFyqp44yTYjKfGwQKgjBzTI8/zR7zyZ8mCu5ETXh0wMuhsDap8qzVoW2O32iWh1HvoONPcUXHsky8iSwSkzgKWs6SrYWEhUW9V6VNH3tvhS17kmYkDE//UzOGYeHxqeJPqX+2ZwnugP1XzccJ4k303/GXFdKGmTUelI8/3bPvI/z5rn/Ho9oBosXlT8nnvPD8SQI8woInHG6hqembGdHUdNra/jdti8JsBXcANnGMCquHXirsmvF0LJMKetnEsVm7plRSP7BfC6vsD3vzfmxq7XgSFY2rm9+Bgd2HRsMDCsQtHQ9emKYR6VMh1/nzyRJKf6yJLSU1fp3PLf8Gm6JreE/nrXiOBjAM+0siHjM59XIHRmIFZao14fmSugoUQ6FS34TXd5yRlFrxQvysiW3kBauEAQz82L22M6RiktSj8n2KJp2unHxFgih87ep1vOsnhzKCOzAWwNlQ3sDJvrX0hO368dTbPeEqOkeXOO9xRYEDXRexteo4mjr7/RrOl7LSK+gf2Ev2z638G58qipeamluoqbllXteQC4Iws5y/P80u892fUnl0wMtTw9PrT1hwpvIQG0L2H5Ia9vGNxEQkbZ79OTeR26Xer6JS7LHQdNuJTEWnRAPFUCl4Pohh2N934k/5+5M38doGUTBbh7nziSNZ40H5+FNVsNcJ7gA8fOZGgp5Rrl/+AqoyNwHf82N6FvQXij/Nr08EQZgkqStPSVKjqePXjM/uB5OKyfu4z54CYZluSbFMQOF93DcnDQJTsSx4amjij4ZKzXSmbFWm1I6noqDgSVm50CxPxv1Zr2G2+vXkOEc+16Wg0FR2hPqB9XgtP6oHHlr6EPtK99HhC7FEr8SPn6BiOl8rmgZd9adRPUWYcQuVRE14skh8hkhfBXqDVUFd9Go61H7CRAkm0orfzwjRhLR4gY/h57qESD5CzBGVycpGPWpeK1gGdkNEX8rrr3hVDhAnEs/9e5EM4gBUBXtcPXk+t+ez9ISrMlaqXuy4lO3VR/O6/mzk03hwOimpeCfN+jso5Q/S7vGwcsUfMjB4gP7+XBNkPCiKimXFUBQvl+y43xGS+SgmgiDMPFPzp9llrv0p38/5mAmHwtqE+03Wnzx4WRfalbFPMgt6vjGRv6X2GNLVKMF3l9H02x/Rpcep1BTKQu9kxLCImWT6k1aIaTDmTx4FJhiVPhWmy5+WoNKJOem+PPn6U9JPLc3uo0TcRPGqPD06OiV/SnenI6HNfGLnt6YU3JkLf+oc9hGM/Y9ru6L4qat7O21tPyR38Gdh+pMEeIQFTeq0B4Clde9i1ao/dn7pdl/xMF1dj9LQeA+WNb2d7c+Hy3iJu/gn/pMP0stYw8AKenkf9836iPRkn53JUqmZfLo2gl+FmKnwyLkCV/Aj18/ZbmdjpsaATpX089cPrOfptf/LssGNrL2smufa9lHXv4aREmjy9HE8onMqYn9tKEBkyX6+0PBzPAWfYFk8QLfP4rrrVlC1oYq+H5/E6JuZ92iuVaDUUZ6PEHPNftCB8sTzTaYn+7HDojEmri3P1WTwHCbPEAMUrsPLUlTnVdVQ+B8ibN1ayw0XLSHa2E9TTYC/e/RI1nOkrzQBbCjPXlOevlL19nU/d4mFaYFpKXjUTGk51buSdeXNGU01U/+dblLFx7BUXmt6gYixl9Ly1Eigwvp1n6Gh8StZ/xBT1QBrVv8ZNTW3AORcbZrv0yAEQZh+xJ/yJ9vnfDZ/8ipQppnjlmadrz/N9AStmeZs8XHqhtfiscayjw4s/TUxbxir62JOmf20lzdSqMK5zjfz6rDqhK7W+RSO1b3AFxoew1OY8CevxY3vvoiqkgCh/z2ONaznPvkUmC5/SpJPX558/aku5V2hoPAkMdRrlvGuDUsYPdA1Lf60p+0KlzttKG/Ap7lf6/ECNrPhT6nntSzQTfAl4qympfDyqYNoaoz1KS26Cgs3sWrlRzh2/P8jW3BnofuTBHiEBU36NIhUOQE7ulpTcwu63k9zy3eBOODBjJuoHvsXerbrSS/jJXaxl+PWZvopp4w+NnFsTjJ3tBzTIK4uMuhqW+I0Sx4K2L1SkqtORapFsj+uT7W4zKxlMDXrIu3n1PGe6dMh8mWugj7jncNr+bmh4T14LC/6r6K8W/n/0CwPcTWGV/Fxwkg9Dli6j409b2Cf6mXAZ995pECl9P7XXJMhZoKJVoG24XHSigF8iW2p6cmpAjNebXmuyQ/nMHkvwySrme8lyhWo/D2FTkrxu/Dzg8MdtB3pYrvloQKFaqAt7Rz5Zuqk1pQnAz0byk+xa8khZ7tlwX8cfh/Li9p405onXeeJGh72de9gfUVzztcunen4TDFReLTx9ZT7+7hy6T6Wl5zLdiZON3wZy0oXWx/r1n6CmppbMj4P08nWf2M+SYogCDPDdPjTbLPY/SnJfFjwykau64orOvuWP85FHVezvtfORPLiZ1v7DXgsL1azxetZh65Eefzi7/LqqOrKS2qMWZimkeFP+wdHKXiwYUH4U5KJ+vLk60/fJMomFP6dIsef1qLxP880sfHZDuotlWKsafGn1Cyf1aVNrve9bqp898gfsLv2FXbUuLOio4Z3Vvwp/XdQU1R+07Kb65a9iKaabKo8lfGYkZHjHD326QvWnyTAIyxosk2DSCVbCjLEXV3yXKv4ZuKuGU4dVDFndJTnZMj2HLcGDQpO/yEM1aOrUR7Yfje+wu6UVSe7kaBfBTPuI9yzPuMYcZK9diC9HG7/0l8T9YxyeetteMzzaz4Hs7NypaBgEHc1hE7+ayhxZzXKi995mh7Tl5E0rQFXj25mw4hGqxamS7MIaApbRs0Zl5N8qEflPyniGXTA4jp8iZWjsfRkH/Y6R5zM2vJ9xHkCnZvw0omZtcngIeLEUs5pAHswuZco/4cAAD1Y/BcxItaY3GzDQxvuL+EVxa15ZeokpSRJVbCHT+76dzwpvXcOdm9mIFrKBy7O7DNxoGsLfdFS4qbmqkMfD0VJfJZMof+lplh0jNaytqxp3M8hy9JRFG9iusPYilO+kpG6ip/af2M+rkgJgjB9TIc/pZJaOSX+NDV/SnWNk5Wvsik01sT1TOlhTle/yutP/0FevXdmMxiU6zwH657ituMfwWv6s/pT8nFey8+H1U/TZg67Hm8CW7uvZKO6cP0pSTL4k8r5+JMFHMNy/OkcJh9mhAjwlDXsBIam25/+cMt/u973+zq3MRAt5eKq4659D3RdxMm+dXPjT6qJploT9li8kP1JAjzCgid1GkSSZMpcLBbKKF1QFC+qmj2VM/UD5ULtEt8fh5aowtYCK6NEJeltXhVKKpoZHKrHa/qpG1xDaUVnyqoTPNTnJR4t5uL9fwoj1cSVGAoamqURV2Mcqn3aGfGpojkBH12JcnzJiwwFQpypPMQbTr6X2pHVY9eRyO6ZLytUFhanK/ejWqqz8qSgcLR6D41L9nPz0Q9l1M8rGpiWgWJqqMCmgEqZpvDSiN1n5gME0IottuOh5Lft9lKgMXM15PlSj8rv48/Y9v2EuHyHKHHs+vIvU+CkDu8jzp8yCsAv0PkTfPiwS7lSZWZboqNAUlI8wK14OI1BGIsgSsZY0H3EOZRoJJnKvq7tnBuupb6oI2emTirJdOQlBZ14U0TDsmBHzTEurjrp2p6874q6A1xeeyDj82C8lGTd1DKOlQ+n+laypvQsmmqimz56w5W0DS9hY3lDzs8jVQ2yY/t3iETOnZdQpK/iBwL183ZFShCE6WU6/UlZBP7UGFZo0xWuLjZdzzG1XGuq/mQocadfoYJCb+E59NA2Z4LW8qGN7FnzU15a8UuuarnDdX3pi1DzwaMMDBRwPMnlT699CK/ldo6ykhLalWGsFCVSgNMRFXOB+5NdXOVmuvwp20j1arxT9qfUUq6dNQcz/OmKugPsXHIYb0owxbJgc+VJdtQczepIU/GnXMHjdH863ruea5a+NG6Q50L2JwnwCBccqatOiuKFxEeionhZsfyDVFZey4EDH8K0wpiGiqKaE8rIhTIW0LKgzAOFqpX5oWqBYtnyETchHC627yg+x5L6w7TFx1adoolGgiEjwoF133VSkQFWh+zxqt1FLWztuA6v6UdXozy95n+pH9jAqepXnJRlgHOlp1gyssqRkVOV+1zBlNlgPAlSUNgYugxTMbBUO2hjaSYbVq/kcPwpHt50L7cf/djYSpoKD1/0LXo9XVzWfSV/NHgTpapGc9x0+iibwHbDQ72mggEFl9cw+krnrA11y1XfPd6+MCYWOvCzRNNAgPtw92f4BjHnyyX1Va1H5b8octWQ16MSV+FPrRGCFrwLn6uh4c+J0pa1iaTCl/f+Cduqj2ZdaUolNR05VRoNU0FL9NzxqgZx092DJ1edeMxQXTKjmwpe1SJqePjZ6TfRNLiCu3be65wv9fGWBRZKRoNCw1T4zpH3A7C5ooGecAV/uvNb+LUYcdPuI5lOcfE21q/7DOXlu3M+94lIX8XPtiIlAR5BWBxMxp/cn235T/FbyCz3WzTENBTF/cfsz/o83F4Wx38e/pTqTMXRCob8vU62i65G6S5qoaniiONEHtNH3eAazlQe4rKztzoBkvRS+NR/5xINjUvab8zwp/+fvfeOj+Ou8/+f07aod1u2ZMtyt+Uelzi9kd4ghAAXSIADchxc6OUuBHLcAfe7L4QeOEhyAY4WDOlxepzEcYlb4irbkizLlqxm9W0z8/n9MbujmS3SSpZt2dnX45FY2p2ZnVnNzjz3XV7vuv5tSJIEYpDBZEVi38bmhODOdJ/MgaD1np8p/ORcrhDJ5qcQ8DtCdrXOm3EBmNHykySEHQDyAfNR+AL9J8RPTnYKG5rL0HsofpIk8Cq6/bNTzuuGbkogSWiyGcdPD+BVIkn5yRQyiuT+YxumxIM7P4oJzCk8SFugiH9Z+sshgzsF+Suorv6Xs5afMgGe06jGjgE2NXSyoqqIKcVZp3t3zho5P2BW+Z2KECpCRDjc9Ah5/puoW3svnvx9eHKbKZn37LDbPNODO7GLZOw4NDkxaOWV4flulUvydFQZKi/8CU/XLuCaWe8wRxaETPhVm4ciFepCMh2GTG6w2NVnnhssZnnT1TaYPD3nlwnAMrNjGU/P+SWlfVNsOHGO+pzdsRxdihAhZGesTrbSgSBZKOgiwtuTXmRB80VomybzXvlLbK54xlUmbQqD/O6JdBa38lLlk1ROyucDWTcyt2wiO3+8Az1iohCd/hDVwNZWss6ZyMCmFudOjTkvxwz6fhM1BIy1QEHyyVjOXnAPuLJHL6HzOn0IID6fazqWC0G0bBlipcsfirZjxXTMNNmFgQFslYJ8X/g5EB0Q+5irKNmtvkgu64+uHPa4ncaBznP+2YZLuXzqa3a/+UO7buPjNb9Hk40ozIBXScxWa46gsCTB1pbF7OyY5wKl+7d+ii8s+3lCJkqSQIr7wwoB/7Pzdnvd146UsHrSRnuf1RQM2dv7Ntt3fGLILFE6BoDxWXxnRio2USejjMaLMux08pQuP+VPf5LC6a/b62nSIiJi+2na65MrJytpMlyap7sekyQICplftXm4qyw8In6a1rHQblWPtXP1+jr486LvU95T7WKnWBAkIods5np67i9ZeOQSKrvnOFriEyt5TrckISfw09XSp1yVSgCmaYIxuL9zzill/vQCPBU5NIyEn06CRsJP8T46X4ljnieI8ESUi+K/iJ8IP6nAbWgUIaMDrUNAZDr85GSneGPl0fKTk8E0RfCnfTfQF8lxjWmXkiwLljdhfNAmxk+tUX56PeDmp1Tq6t40JD+la548XvkpE+A5TWrsGODK+9cRiBj4NYW1d1+YAZUxUkHBcrunEkCIwei4aQY4XPc6wa4qJLWYiec84lhThSSljGeDkgWoEssiYcCU7EoBjywoq9iFJxqR98pQpMLmAeuykRss5tYdX7WDOTEgiZXhaqaX3FARtWWbmdW63PX4tXvusnuvgYQ+clVodHiPUhyaNBaHf0JyGkKraEzonWZnzDTTi1fPQpd01CioyEJhdeNNLG+6mjcWPMQHsm6kfE4VarGf2765kuYDXRR5ZMKP1g4GcHRB5Giv+4VPQnAnfppDEAse/ocQEazWq985DP1+R8hePgxcispLjs/IULfPWDDIC3ZpMsCvCfNbxwSJI5j8lpBd3RQRggMYPEiYIIzQiju5nMaBMTAPGR7WHTmPdUfOc/Wb13dX2b8DLCvbzk0znsajDB53fEbplabzqT3u9lEo8XemLDN2lifvaJvH2kOXJazv3OewoaLJetLP8VBZotEYAA7ny5FRRqdTGXY6uUqXn7Rjcyioft2+jqnZ04j0bz9Ne31yFX/djZ+cpZtW0Kbaa46Kn2KKtXP1+jrs/5zsFGtt2lbxgp1QiwV/EvY5SQXPqQ72xL9ePD8pQo3zagTE4PKKKjN/egElC0tGzk9jrFT89Dhh/kQYHYt5YmzzapRfYsu9PsR3Cx1Yjcx6RwnSaPlJB/5KhAhWZfUKVI6ewPcaN4cMBm1OhJ+cChsaW1sXuSqIkk3pikmRxIj5KWIoaEpyFkvFT6M1Tx5P/JQJ8JwmbWroJBCxTrhAxGBTQ2cGUsZIfv8Ulix+mG3b74hCijdaDBFCkjQmVEzHm3+Myot+iOz40O/tnMacwv0JDbJnantWyLDarVKN9zSi7VhgHePGPpnGsOQqI97Sr7Asy7B/rwsNlhLEB3NilTwROWQHfWJtW87HncZ6qSQQwwZ3xhpWUm3vWPYhSvsrUbHKUyf3znQtu6z1Cqbd7OXA3wbsbBRY78nddZ9BOtTOsWc7mXD3UvJL/eSX+unfcoxwXAAn0tQ/ZseSTMmmOXiApmilDFiVOI8TYiUaX2AgAQvy434fqsjoE3goROY4Jj93hILCDJoGJoMmDehG2I+N3MkmUU7jwPZAESX+Tle1jRMu4vvP1x66nC2ti7lg8nqurHoZTTbsa4JuSvyp9iZK/J10BtsBHLBTZPeShwwFVbJM/5xmg5IEW1qXJMCJc5/nFdVx7XwfJfw66bEJNAZEDY9uaUqoaBhtuXAyX46MMhoPyrDTyVW6/FS+8iFXBcvGQ7UsLMbFT2cqO8HQ+24IkBl83gQW+o1R81NMTmaKKZ6pYsGdVNuw9z8Jz4ylN08660tIdPiaKQiW2kMq4vlJVVQmrtI4sj6IItzpnDleCX1tA8deahyX/KQBfyRsM0oYeJUwc1D5ZVz662X0IVPIIu69HC0/KQxWVMd8eE5E8abLQIIBc7r8dFXVS/Zwi4gp81rTKtoCpfayMa+f9kARYUPDo0QIGypvHVvIyonbUGTh8udJh58+urSLC2aodDT/IOnxybI/KT+dSKvVeOGnTIDnNGlFVRF+TbGzUCuqik7r/qRbinamqLBwFTWzHueF//sLfS0z8OYdp/KC+xEiwr66u8guv94V3BEC5hQljtGDxGx9/GPjVd4UpQ+GgJ+3epjjM7kif7BH9vw8k5XZYV7frEEhvJEt024q/FeLlZmKlRXHlCyY4ywtdo4HTVVyrEsRJCG5JlQlGwmaTKng4nDuXib1zUAR6pDbEggEpl2dk2p75f3V6FKEA0VbmdGxNHFZXaJroJuNlWtdhoeSBCXR5UTE5M2Nr1B1QQ2VuZV4q/Ksvhv91E1/WJhkmoMJHI5rXN+NwR+JJA2s/C0OFlIFdzzAHFSOYVKC7AIbp2lgPDTF4OQvRMa8ns4JHrXH01vHCRxXTF2HJhtETIXf7PwwmmzQHiiyvXZChjWo1KNE0E0FU8T60mUkJBtOfrPzw9w5/492WXN7oIjVkzYm7YNfOWMBX73q/ZRmtbNh4+8xzYDrdSKmQs7EH3PdL+qTVjTEGwBm2q0yOtM13tgJ3h38VBHlp9r6fyKn/LoEflpYkjjVaijvjfGuoYI7P2/1sMRvcH6e9R54ZLixMELEYHT8JIXYXPkM9cVvu/wJgZRMFb+N+IBLqiDOUIylE2FP2Qbmta1GEUMPuhCYCLD5KZWKg+VD85MhEcrtYXv5ayyLDuUA6/0vj0796AsatD/XSNXlU8gv9Y8bfjJItP1pQvBLBhL4STA0z2xwrHEi/OR8XQnoGuqg0lR80GYov0On4vlJlU10U2Ftw8Xs7Jhns9NNM57h/q2fsn+3+ClGl4JzJrwzKn66ZcUKPnv1XKsa59gvMM1B37CwoZFd/GkmT7w6KT+dDeyUCfCcJk0pzmLt3ReOiz7y0ZaijXd1NubS1zIDf8l+FG8vIhbXlkIIE0xDsSElXeg4U+AklSImPNBmjSW/JC/xdqMpcPNek6yNClfmCh6+wmTTbJmOgUQYGCqYEw8p8Y8718sJFTCv5TyqOmvQ8CIwiRAZlf+OTpjy/mqr9FeKsK38Bc45elVSSLEeSy+TpQqN1uxGph6fbwOZJEmopgfVI7N08Vx+1f4jIk2DVUqzVxYi1YbAFASlEPcd+T5dj/ez5oY1VBZXMvHzS+nb1ELfq00jPs7RKDbN4XeE7N5vHXg7DlF2YJ6wV+EMJL7EgCuHJQPXoXG5PdVBdUGTDK5M2CTg6Anux2gkY7JC3kuVv4mLVz2LpuiurJEmG2iywfqjK1193s5ec+c4UCtjZbrWdVYTDQaIPHxz/ddsSNEUidtXTQXgqd0yS2b9lV2HXuO+56zqt1mFB7ls4XvID1URiOwAEisaxlO5cEYZjYXGEzvBu4efYnUBgiBmhp9YlZuYAhkLfkqmVEwFsLniGXx6FguOXhTlJ4tndCmSslI6VdJrT9kG5rSvQBEKJgY7y15jQetFSflouMCOU6rQ6Pa2J2UtJz8tarkY1fRgSAazVxYg1Yboj5i83KtjvHqEDW82c9s9K8kv9Y8LfkrGSU8SGRU/OZNl81HS5CclKT8BFAGdo9iPE9Vw/KTKBi0DEynxd7rGtK8qf8vhOegIdikGsSMbKT9dPKss6tc2yE8/XddnV3B/7brLaG0maUXo2cBOmQDPadSU4qzTDidwYqVo41lFU3qZduW3kNUwpqGB8IAUxtQ99B1ZSrCzisqLf4AcN9rvTIeQofRKr0qXIfO1iUH3VB7rfoEUAs8B6+Zf1AtfXGPy/94Lm2YnB4KhwCOmeCNm53rJesgVVJAk3il9jZrW89PqIW8o2MnRvAMAdhWNKjSWHr1iyOCNhMzOsteY23pugg+QU7oUpr74beqL33ZNDLuz6J+49eLryS/189FVH+R/jO8zrWMhyw9fzYENvTRoMtMvDPD9ru/T4ukAHbYe20plbiVqsZ+cFRPpe61pkBRkxnQSRPy0h2OY9GO6XsbA3Wo1Fi+/O0ltjwk8RYRniRDGKm/+f2Txv2TzNgaFSHyFACaWKeH3yOZrDKSYAHFydKW8iXu1R5gkddJc4mW3Yk1CcbZlCQHtAatqwNnnHTI0FMl0wUlMsbas2DjSWEbMHSAKR6HFqvuKGIKPPrQJCQjqJn5N4aE7bqZf30wgYtCvT+B7C6yM6FAVDeOlXDijjMZK44Wd4F3CT7qGqWvIamRIfoIzl6HS2e/xwk+xx2MePoak2/xiVegYbJjyGOcdet+w/OQMCPX6OmwWk1FSBndGKl0OE1IHErY1fVkp5940w8FP30vgp8VLSjE2HbO2EzZpPtBFfqk/OT+NsdLhp3iNxa5sS1I/bQJPE+GZqL9OzO8nFT/dP875qTNY6GAnDxuaz2H1pE1JfQvHkp8O922m9riblVLx05nOTpkAT0ZjXoo2XsqVDfkdZNX68MtKhLa3byESyCXQPpNIfymR/lKa1n2Bigt+OGwm6kyFlnhdlKszYEpocbyR/YKMdkzCc0BG7bAONHYTu+N5k80zJYQ88jcgmRGzE1JS9ZArQiEnXOgCgjb/YfaVbeTcxptdvdoCQWfWUQ6X7kI3DXuKl4kxZNAGQJciHCzZRkgNsOToZSmzUlumrnUFp2Lqqz5Cfqmf7rYAs9pWUKQ/Q0GgzDYR1CMm/pIpdIX7QQef6mPphKX2+gM7211EkHXORALbWhGRE8eEZFMc7kvoIrd0IghQBrSmuexgLsbKB3+BAT6Jxy5HvgYVCYkr0KhGYQbKCRkEjkRXypv4hXa//XtBdwTZEJiKhGQKiJ7/kkQ0A5TYn17kO25Pzho0c9a4f+unE3x/ID5A5LF73GN/j5CjBD0QMWjqCiStXhhPFQ0ZZfRu0ruCn9QIrdtvQQ+5+Wmg8VtkVX7b1a51pnJS7MvnUPs/nvjJyU6KUDEYDPLIKEzonebip25PG/nh0oTXkJA4kruf7VOfp0trZ+Xh6xImW52ICucr/NL330RM3bVtgPwS/7D85KnIQd3ehh42UT0y5TMK7PXj+cnOVI3BBNKR8NOpkpOEwlh+iVUoTEBmLwbLUViGao9PH9/8NNPFTu2BEn6w5Z8y/DSGygR4TrPSvZk7x4JOLhj96OhkrzeWpWgjLVfubgvQfKCL8hkF5Jf6R/268Wo9UkvTwQYkvAhCIDQG2qsItM+2l9Gy2/AWNNDfMo/cye8MuT1JAtMEeXhrmNMiQyROdkgmjwyVHtM2AgQgAtlvKDaYOCUDJb0w97Bg99SR3+yTGTGn6iF3AgowaHgUVeEsD+fuvAlFKK5lJSSWHn0PC1ouQry/jt7SPRS9sAjZHL6E+LivhWv2fMoGCqdimS3VI/OJGz7Ai115TM+fzg+2/ABDWED7+z2/5+riG3n1B43oYZOr+bRrG6pHpqammjXnrGHrsa0snbCUytxK+/n4d9ToDlLw3pkcf7TW+qM65ZEhnH7gx9mfbU17SD6VYCQqB5rjHms7ge3pEDUQdBsSPk+E70nZvCZODZzImNyrWRP1YhzuD5qs2nKcrnwNT8Bgx4J8hCK5QCLWY+7MKv3bG/9qlw9PyzuEQKIzWDikEWC8aWEqVRT4k1YvjKeKhowyOlXK8NPY81Mg0MjRw+vpbc1FlvyYIgBCI9A5yE9adhv+kv101BVjSEvIn/rWkNsM9RXizUnT+Ow0KR2GGk/8FO+BuK9kEzWtF9jr9vg6XM/3LDpI3uaSpBU8k3tnUrZ7isVP2bUUvD4vrf0TmEhD+CXKClx72wqW9v+Krdv3MO2Dk9n2x2OIKMbseKmJynnFPPWzHSn5qXpJGdVLypKe5/HvqKcqD++UXHrfOAq6g58krD9Y8PTy01jr/4gMWk9EtQ2Di9Cow+C1UxTcGS0/xav2+EybnyKmwtyi/WxoPofa4zOT+iaOhJ88imwHcN4t/JQJ8JxGpXszjx8L+vTnzjvh1xP4mDZnDdMnWTfsdEvRhgOqkZQrd7cF+OO/b7Qj87He2hNV65Faduy6MdqapSIrCkgRKi/8EfVrv02kvxQtu41pV96LrMZGgSZmcExTAlNGVkfWZ346JAFv90vUZAmGShQJAUuzDTt2YphQ9hM1KZw4Vdg3uv1yQoguRej1uruCE8yXo8GWiBTi7ckvU9k7G9X0YCo6b3VtYJVxI4DLlDkmzfSymIspLi/iRXOP63Xa/IcpDEx0jeMUCEoDlaSShMS888opWCDz/Wd/QKd6jH16Cx9d8o882PgAACEjxNbte9DDieftvPPKWXpVlTX5gUpXYCcmf00J3c8fsmEktK+LUG1X0uxTzrnl9L16JH4nOSIGy4gB+2env40GXIDC9hOcSRUf3IExn+YOWPv8p8ka4tS017NC3sskKbFj3R808QdDAJy75Tj/mf0+num8gPZACSX+du5b/b2E/u/YfyX+dpeJoLM/3Kl4A8Oh9Mt1B5kUDfJklNG7WRl+Gnt+CgQa2bDhGkwRwNQ9HNv2UcqXP+TiJ8Bu3YrnJue/wpSQFWuksTfn+LiugjYFvNUnsSJHDLmPp4WfpJDNRM4JW/EePgCz21bYy+6dsIG9EzZQ3lPNsbwGJnZWU8mqhNeIMZTNT9OLePH1PQnLxZJq7ilccvzGXECw+PIpHNzWyqYnDmFE/HSrrcxdPYndr1vuekbEZP+mFvQkiSsnPwFJz+14fgrX9xBu6EmEEgE5K5PwE+42LDi5/DTWSsZeYeD5aX4erW87Zc1ZY81PgP3cqvItKdkJ0uensGHyzM5mrq4pf9fw0zitR3h3KNnNPJnix4JubjiOYR6jpWUNgUDjqF5PIsi//+0PNHYMpL1+DHB27/kKGzZek/S1Y+XKwLDlys0HuuwLe6y3dix0uO51R2uWTqwpRFYj5EzeCoC/ZL8d3IHBCh3XzV3IdNWf51pmvEqWYEE0uBNX+OL63TnWFECRITxVMLDSQC9OfTs4njO6/er1dfD0nF/ao9Gv2fspcoPFCcvUlm2mOf8gf178fV6a/jv+vPj7NOcf5E+LvsdL03/HHxb+JweLdhCRrZuFkMyETJSswNRJkyifUYCiufvOSwOVIAvqC3YOvhfx+R9FMOOSwXVVj8zMFRN589dNXFD7AW7Y/VkuqP0Anr/OpiRijXD3qT6WLp6L6nFfSlWP7IKTVFKL/eRdMdX9oMCVSjyCyTOKTuesAgo/MHswbSVLHBFWGfF/EOQj9HG74+dXCfMVfGhY7VD/Q5hv4uN6NN4zAoPE06UZFXmn7LXK0pg14Q+adDdPsGFiWdn2hP5vp2YVHhzy+XRV4m9n9aSNlPjbeXlfG5f94BU2HBysgmvsGODRLU0jupZnlNGZrtHy05a6XYTDr4yIneJf72zlp66uzVbFDiCrYbLKthFrDInxk8VO1nXNyRNOfpIky9+u98iCBOYYj5Il7ODOSPkpsGJodoLR85P1WpLrX6di7BTz8nHyU+yx2rLNdPvaOJp3wMVP8UrFT2Ax1JtT/87u0vU2NyVM55Lh8jvm2SykaBI7XmrizTUHMSLW+2Pqgj3rj6JEe9xijHUi/JRz3iT3g+nykzTYhjUSfjr3DGCngVIf/afw2/1Y89NYsRO4+em7z+zlih++6rpun838lKngOY1Kt3c7fizo4kn9HN73JfbuC41oakNBwXIEPiSChAwPO9unuSauOOUsaY49n052aSTlyuUzClA9ctLe2hNRZfX5dO7yWBU8poLsMO2KXdsD7TNt08CYZBlMU7ZNA2XFQPEk/9CPx2yUEz46IlCsDf5umBaMxGfawib0Xm+AB6SQQel3NFc2ygQ6c2FP5egPNjdUZPddJ2vTcsppOigh0evroN9/HDNa0/vnRd9ncu8MvnH5l9n0YDN62ERRZUzTxDTgyZ9uZ+EllSy8tJL9nfvZdnAnMzuXAaCaHlrz66nomekaKyprEhsnP0Ft4VYiej+//eKfoNlP+YwCmg90IfQ4oNFlvjP9B7RXHrBbrsrvKaf5QBc5RT76OoN2KXE6JfSeitzE9+z8Sahl2RyVBXc8uo2AYfKDhzfx19UzyLPdkIWrjDjkWD+E1frkHK8ZBH5PiPmovDDOMlHJ9NsNI/sCdiJqpWBEy5X427lpxjP24yFDSyg7TtUfPhKlynLd/uBGXvzCxQCu6gTniPSMMjqbNRp+qsg9TtHAVxgQQTa/9dCIJl69G/ipoGC53ZZl6h6MoNuzRSLGTh5XBQ8k8pOkGJj66NvhTrVGw09CwMD5goHlEcri2AlOnJ/Ke6pRTWtql2p6hmQnSOQngUCRFAxh2BU/Q/HTEz/ezqUfmcuK66up3dhCx5F+e1sLlRU8W/k7ZnYsSzqWXVZkJlbnc9s9K2k+0MVAb5g31yR+MRcmrLxpGv5cj81FsXVGyk96R4C+NxLritPiJ8Go+OnUpZ1Gr//bdHgM3JPS11jz01iwU+x1kvHTMzub+dRF0xOqO882fsoEeE6x3Df+9G7m8WNBleBTxC5HI5na4PdPYdqcNfz73/7AzvZp9OsTXI7hsfLhAVHDdb+oTzjp0wWqdMuVnRf2E+khd94EwBrvOX3ynzl29E0UMYE+5esIEcLUNXqPWAa3kf5S6td+m8JZz1I4Y519s+7YdRUl859Fkk1M3UPXwYvJrdjmMhGE8W3GLATkOpIMYRN+2eahSIVOHde/ObLgxsJom5oXwjNM1A5rZRML6B6+Qh6VQWBM8b3izjJjp5zTIkJZvfziil/Q3NeMKqt87bWvARbAXH/+x2j07uWiLyyAZj+B3jDroyBhRATbnrMCA7Lq5cDczVR11div3Vi6iyWrZuBpL+WcmYvwB/LYpW1my67nrZ3QYZ/+Djeee6O9X7IqYTr6uWVFoqammvzS+fZj+aX+hPM33RJ6oyvkfkCWyF5RjlrsZ8eWJgKGBcyBiMEb6xq52tFmNgHZzjAlk457MNdBBAfHYS/5cCrGGvl5skqON5lzOCqKmEhn0hZHU0ALxWwy5wBWhsnjGIv+9wPXJJQJj9RfJ5mSZbLaAyVEDMGmBqskOtmIz4wyOht1ovw0J+81jh22vtKNdOLV2chP8ezUfEBj/qw1tB3byLG9FSy7sISG1pdc/GSx07eilTz9TFj652H4aSuyMrz3iRDWfyfb53A4RkuXn5ZlG6zOiXKhF0IOdoKx4ad02QnGhp9MQ/DCQ7sBi3vs9wTBy76/05/VhXh/nc1PXe+Y7I4GWIyIVUU259xyOziz+cn6hPYrWZGoXlLmOl9Hy0+hhh7Q484tVU7NT6+dOD+dKYrtaQHQzcljJxh7fhoLdoq9TjJ+svc7rrrzbOOnTIDnFCp5tDC9m7nTBKr2SA2G8KBI4ZSgkCyDBDB90mzuu+0rCc/F95dnq18hECmxSpoPvEh/63omTrxxzMwEY0p2YR+JnDcBq6xUwoiY0RLQmRgRgSfvXnyTDhI4PJ1I/2BGKtJfSrBzOpK0DrBu+sXz1lpwYigcXvc5Au2zad54J5PO/XVagZuTFdyJzxwZAt7stWDi3FwDRYKIgC4dmkOw0FES/GqvysGwysGoj63z32LF5Kr8iGUYGB4c8QlW5unhK+SUIz7TVXyveLIMVPy0CPN9g5mfhaUL+c2Vv+GpuqdYMXEF33rzWwT1ID7Vx5ob1lAeLGNTEpAwdfj6vHt5YcbjvP32fuu1tQ6m5FYy37ec8skWFGf3LsG3z2dvc+mEpS7wvf6zi3nix9sxDYGsSlz/2cVJz9nutgB121oRwPSoKWB8CX2y9bxVeaDKFqgoEiUfq0EttpZzZp99wELH9LAjmHyZASIMPV39zEGS5MoFerGOQwbyII2C4JHJRObbkY/wC+1+HAMfrOeib+C3I7dHB6QmZpi2ti5Kut2R+Osk08Gu5JmsZCM+NUWiomDsjOozymg8aSz46eDRpXYVzlBBlrHip2z1GDv2/gxRkU9Z2VXjip+GZqcKjIig9s0OKmt+QGfnW/b0LMCeopU3db2r8iWen/RAEUPfnQYlSRDuLcabN/TY8JEqelt18ZMuYEMcPxkCmsMSzWGJ5bmD+5uKn7oMmWVZBl4ZdAMGWmSyHa87FvyUDjvBifPThsfqMOOGOpi6YMmVU9h39AB/MB6gOf8gGFBQmkVRpZeSCVlUTy6hdvOxhCqyGD9d+5lFtB7qYdMTdRiRsecnb1UekiZbU0cViZzzJ5ETDe5AlJ9UmYBuWvxkvvv4qY9BdvICgZPwGieDn06UnQDqkvCTpkhcXVMOuPn6bOSnTIDnBJQKAlIpWbSwNKt9RDf8g0f38eOnfk2+dzl5ngA3nvuZhPWGKztL5hje2vqsq7+8pqSeVw6XsKDkIHn9P+JoPxxt/jNLl/ye8vL32eud7pGezpuA1ecroj8PXq7DPaWEe0qjJaVuOcuNTUOxK3VkxcBX1ECgfTaSYgyb8TmZVTvOC6bd+y1Zma4XezRe7tNYla1zeZ5OqQYlcZ/qATP1znUYMv/V4qPaa1IflCi7UqKwz+oZ31M5utGeyeQsHU6m+GkR6zfW8lDTLwFsEPn26m/z2IHHCOpWBjaoB9l6bCs3zriR2+5ZSd22VjY+Xo8RzegomlVpM8X3D7y3/b0E9SAlkUm0/W8uL0b22FmhytJK1twwOOUqL1iSkDn60LdWDZkp7W4L8If7Nti95hsfq+PSj8wdQQl99C4ogeqY8hLLPr/2Sj0zNrcz2WGb9jhhu6zYJDWknOmAko0V4AHr+LpO0uusNVdwV+Ru7tUeYRKDhoEtFPPtyO2sNVfYj51ohil++lYyScAnL7mA/3hVZmrefmqPT6c7VMLXr57jMgp86I7l3P7gRiKG4I6HNvHc5y86q7JQGZ19Gik7wYnzU2PHAB99aDMrJpxHZW4zF8xdmXK5seCnne1w3+rv4g1FOHAQ6up/xKqVz4wbfkqHnYyIScM2D7A66TaG4ycj1BH1QUxPWnaiUeuJSpISvXNUyWKfl/s0tgV0Pl0aRpOhwiso97jvmKn4yclOdSGZztsk5h4WY85Pw7ETJPLTS1u3joifrv/cYp74yXZXpbLqkZl//mQqfV5+/vgR0MGrePnp9p8SNsL2duOryJJV3kxPMQUrpnh+2vR4Pdd9dtGw/KQW+ym+Yz7tD+4EQ9C/vpmcFeX281OKs/jbFfN57Zn9LEQdkp/i/KFtnen8FPv0mZyc4E5M442fFAm+fv3l/MdTg/x0PFjC7z+x0r5+TynOOqv5KRPgGaVG07sX76WzpLyfDRvfl/ZIzECgkfq9N3HzjMGRwk11dzF1wlrXevEg9MzOZopzvClhKhBo5GDd/fbvsuzlnps/yHXN2ZToL2L0Dy574NBfWV64yl5vJCM9x1rdbQEGesMJLTSp5Jq4FB3zGWifaZcbe3KbKZn3rGN5SxbEqMjqIKg4gzonY4S6q7ddSgwiCQGrcwyWZRn8V4uPbEW49ycaFIqxWrFi0mEMvYNCktg99fT4rjunRQCsaLqG+uK36fV12CBSmVvJ0glL8anuahuwMplL3jOV6iVlHNzWigR2GXA+VgDnhUMvoO/JJhyFCGdWqDJ3cMrV3p3NrszRwW2tZDn6xZPu/4EuG07AKnV+6ZE9XP+5xa6e8mSyyoyj6+qCUEOPnYEC6yb0gYurOba9y8pUYWWf/hQ3WrwAGHs8Pv1qOYWvtdZcwfOhc1gh76WMLlopYJM5x848jYVS9YXHSwDfe3Yv/33LpXzpL8VETIFPlROmQOxo6iISzb4GddPuL88oo/Go0foenCg/vVW3k2+s+A7eaGtAd/tu3uz4P85d9exJ4aeN+17CKwbbEEwz6GoJO938lFPkQ1IkhCGQFBAjsGVLl59S+fUkS4qZBsjK2Hyddm4/1ejzq/MjvB1QKFJBc1zeFcmq+lHl4fmpw5AhBNVeK8VyWvkpRStXOvxUMbuQD927KqkPToyfNu3bRmd9kIc6f07YwWU3zrjRxTbxlTdbn21g6VVVzDm3nFSK5ydDN2k91JNWC6LRFbLKrwARMRP4aUZNKbkvHLbYKZoFS8ZPWUA/o5MgcWT7u1HjiZ8MAS09Qf7fB6/h9t9stPlpUlyVztnMT5kAzyg1mt69eC8dLfyMy3Tv+e3PsXjWh1Jup6trM1LcRUkinNBHHgOhbPUYcwoP8tC6dlr6S/BrCg/dsZymrgBLyvvJknZSULCcrq7NCDHoA2KaOpMK/UyfVMHfNl5CrnjMLm9tCl3Icsf+pDvSc6zlzBLoCBoUgxnG0KdzzBTOGpFujfk0dQ/1a79Fz6HVaNltFM16EVmNJPj1tO+8ibLFj9rb6j82m6zSA8iKYfeNJwOYZOPXh5MpooMAHI/Frxv73SvDQr/Bln6Fc7OjlUYCSt/5GH+Z9FfOK+rmxsII1+RHeKDNw8Gw+z0qVky+MjGIV4aQCb9q8zAlmsF6O6AMGxQaK/X6Othc+QyrG28CEg0Fy3MsOKjMdVfbxI8ezy/1s/Q9cVOpovr5jp+j9WVzq/w1NNOTMivkNK9UNNkuLx7KRyc2eSI+yNPXGRwSbMBdZixpstWyFSe12M+Eu5cysLOdnucbeVsP48yLKhIsKM7l1fbehHUzGplMZDaY84ZcJl3ISKbh+sKdihiC9XUdRMxBADnb+sQzendptL4HJ8pPpZ49hBW324YQoaT85FVlcrVW5hYd5OF1HTT3F4+Yn3w5ywh1aXZASeB1tYSdbn568qc7EIbAQLBLM1h4Evgp5tdTNOdpCqe/bm8rnp8kyZrCZL/WCfBTust6ouz0dkAhbFq/A0iGxh9bCsjN6uKq/MgZw09DtXKlw09DtfvlBUtofyQPPZzDrfLX+POi7xHJ6bcDRK7XcvATwO43mqndfCwlO8XWkWTLgDkmaZh9imk4foqxU6ihB6XAS8fDu3g7EsdPwIJJuWw4Ojp+ygR3BjWe+On4QJimrsC7lp8yAZ5RKj6b5DTbi1d8OfJg3/ag6V7I8HDfcxq+l9bwwK0K0yvOo22ghE0NnVQU+KNQMei9E5MhPBQULLeySE1vsPFIJbpUzteuyKU09Hm8SpiwofH3A1ezpXUxtz+4kXxPm/3hkmU/c+f8J+4GD4PW1meZOvWTLJtxGZ956F9YUraJLceWc8OKeTR2DDClOIsBUZNWP/vJkDNLoCJRZShEEGhISLKEEMJVW9kg66hAham6xnzKahh/Sa3dU16/9tt2Zsrp19N7ZCklNY/bmaicifswdY2eI/PIm/wOEFdhY0oggSQL+7lt/Qq6aXJOjhgSQEZa1XtVfoT/avHxZt1irvbmkdt8LtnH51JUuB6v3A1YGaq7ysJ8t1l2QUe117T8d7CCRXeVhlFl93ZPFaTUF7/N8qark2ahmvsGJyU4q23S1dZjWwnqQYK+IH9e9D3+ecKXufa8S5PCg9O80mlAOJSPTn6pnw9+cxW7Xz/CthcOIwyBoskEesN0twWGhBQngHir8lzZp5j0jgChhh6yako4lqfR98YhvM0hQoZAA74ufHwvE9w5ZRoJZMRrJBMiNEXi5sWTeXz70ZT3mqtryvnB87WEdBNvtMIno4zGq0bCTpA+P/10XR+Ttv4X99z8QaZPmm2vF+On7t7plBuDARdLifzUHiihyNvKPau+d0L8dE71P/ChB/6N+UVbUBWFD1/4EZ7aLbOianzwU6wVS0FiXlCxD0FWJEwh7MPRETTJxqj5KdJfSufea8ifuumE+SlfNqhOciuNr6hOV1dFq3her13FrZIVXMttPYeCgmfo9r1hs9GZwE9DtXKdKD85eVszPfzzhC9zwWULk24nxk9bn22wDZiHYqfYOjf8yxIe//E2hGG115dOzWPvm83DGoinw09Oda+eQKClG++BY4P8hI/vjTK4k9HIdar4CYa/35zN/JQJ8IxS8dmkVBHBocqRYyMxn9/+HPc9Zzm7f2PFf3DscJjWJh/fXP91mnoL7W35NYXLZ/0XWugJJuc009Q3CU/WKkLb/kRW8EEgTHk0Grq0bAcfmG19gDxKhFtnP86NM561n4t9uEwzwM7dX0GKc++IRLrs4/zZnZ/gmZ3X8ufaWr77zF7uf2E/D92xnDsfrqcy5x85f/IWbj3/46e0vLh8RoEFItHSOhWJNz1hloc11OihSBLMPX8Su984SpU5eKq7+sZ1D4H2WYPHHYUSf8l+fIV1ZE3YS8+hVQTaZydkomQ1AinGgMaXGhsmvB2QKVBk3urTWZYDshTteTcUjrZOpWJCnSuLBVaZocxgFsvA6h+PlRCDBRbVXpN1gQ4+uOcufMJLUArxptnNfHOw/FiVrOU6BgZfpC4kEzKtbehicJvO7TqXP5lKlYXyKJ6kmaKRyFmaHMnp54LLFpKfmxoEYpmj7rYAG5+ot80ny2cUpBzdmV/q59ybZzDv/Mkc3NbKpifqWL/mIBufqGfl9dMSJkc4pRb76TfhcG0XOUVBu0QaoGVHG9mvHAbd5Igi+KjRSxDLMO/uaWWcWz/A2+hxtX0ZnUydyBjPkfSfnz+jhEkF/iHvNVOKs3j+8xeN2NMko4xOh9JlJ0ifn366ro+7l/4SrxKmfu9fgDX2JKuYfKpMnvZ1zp/8hs1PuXnnMxDHT7/Y9DUunLzeZqTR8tOM4iz+79PvZVPDxVQU+Lnz4c0EIoftSqDTzU+x9iyw+MkwBQoShmEiISHJULmsjIObj6XNT075S/aRN3WDi59Ka9aQN/UtYOT8VBeSmOZViAgDzVHVYxoKtYcWMLtqu4ufDAEHgxIzfSKBn2KKMc4m7Qh31t1ps9POrANEQjKRM4ifUmks+MlZlaN6ZCs5Ngw/Lb2qyjZgllWJnCLfkGPPK2YX8uFvnWu3iT31sx12FXW6/FS7ZdCkOcZvLn7C5KP0EcS6Hnxh9gRW7uvL8NMp1snip2Q+SsPdb85mfsoEeE5Aycz24k3zhitH9vunMH/qBdSU/AGv3G2DgxBBpuTWEtSnu07k6pIcZquv4VXCzC/ZhxCv4AkOFht6lTDLyrZz44ynE/Z38Lln7Md0U0GVhx6bPKU4i+IcL0F9cNzg37YfIVs9ZkNVU91b+KXPU1Z21SkBlfxSv8sYzgTyTAnVUSwpBNTu70xwnnWO+Yyv1HGWH8cAoqD6dRpf/hKB9tn0HFpFQfXrNjAMtFeTM3mHVZZsqICJrJiYhuwaDarI8JHiiJ1dMnSF9torGDDhdwVvYMhH+TruD+TOfplZfhNFtluMreCOgN93atxWFLFLg+tCMh2eDu6q/g41AzPYmXWAFrmbB9o83FUWRpWscZ85snD1kzuNAjt1+FRp2C5Vjm33VCo+C3XLrFv4WM3HAHjswGNJ27JS6XDvYVcp8lCtXUNL2P/2dgZt8Ii1bAGu6Q/5pX6ycj12u5YRMVm/5iCbnqxPWabsbDmMKTbZZBKCpdnWmfG2ESEYfT4EmIEIrxKmG4Yc95nR2OpETQLTnRDx8r42Nty/jrV3X8gtyypSLpfsXpRRRuNVqc7XkfITQHVJNrMK99jsJBHkyS3PEIjMTDDj/PA5k1iWPTQ/XTj5Da6Z9mLCvnmVMOeUbeeGNPhJ0wpcx/nolibXcYwHfrrhc4PTIcGq5IFBr0JhQuOhLrS4BpRU/ORu3VKRFN3FT3qgiJzJO+ztmIZC75HFafPTewt1m7uO7LsI/chyjIIG/li2FsO3N4GfJCExyy+ImFAXlJjhEzY/mcJqyUrJTp4OMOQzjp+cev+s91OZW8nlUy8HTpCfSivT8sNxKr/Uz7WfWWSdY7rgyZ9uJzapzdnu3rTvOPs3tTBzxUQqZheSX+pn75vNDgPw9PjJNeTi8Tqu/+xinvrZDsqFg5/QbX4K6iZdYZ3fEWIJCh7IBHlOkU4WP8nS4HclgIffaOBDK6YOy0dnKz9lAjxjqHjTvMWLfs0EdR8lfuyTMX4MWyDQSGPt+7h9bgBTKAg8SFhRzfZAkaNPUeOVwxezuEBgBqzLkCYnuuKFDI2peYfxJplcEDI8TMhqd5Uor224mCumvoJHcW/rUOOveadjLstmXMaU4qyEMrebF0/mWMsaB1SFOXDw+9TV//iUmQVWzC7k0tvn8sJDu5GBeXri6RxqCdjg4lSspDhezvJjZ8lv3tQNBNpno2V3uB4vW7yGw6/ejZbdQaB9pr2NSH8xlRf+yMpSgWt7AIpqEO4tZ9uASmu+wXKv6cr+CAFdpmTDgtMoUJVAlSTXBIcYcLR4Oiw4iepgWOW7zTIL/YbdTx5fOtxhyHaW6fst1rJwanvIU2lx6WIA3vv4e12jPYeDlMO9h5OuM5rS5MFAjWD/ppYEA+aYRw/Apifq+eA3V0Y9eWTXRJKhypSdJdAxxSabdMigC4EqSSxUNHxG0K7geaD1eAZKTpPGYoxnvBTZyqQ7lY7Ra0YZnekaKT85l795hgdTKMiSQcjw8NuthXE+DxY/nT9heH6qKdnjulfHqmVDhocrZxt4HWH0Tc2LWFm+DUV2f2Zbj9expXUT51TXjG9++ojFTzDoseOU0RpKm5/crVuD/DnITzNdPCQrBuUrHuHwun8ZET9JEmSpBsfaZ7NP6qa1NDk/ydG/iSbDdK+wGUqV4LEujT5TGpKd4Mzmp0Wli7hxxo0pWWgoJV2ntDKtwI5TfZ1BO4DonNQWY6HeziCP/XAbYHn13Pj5JVTMLhwVP7n8D3XBrnVN6GHTzU+o+IAg4FEkHqxvB+CJTGrslOtk8JMRV74TM01+t7LT6f32doYqEGikufmvBAKNgFVG/OiWJg42veEyzdu2/Q7CHfdx3+rvUeK3LiRNXe5BdU6jPVkyMMwIT9VdzjfXf40Sf6ejTzHClVXPYwZeQCQZNBA2NF5uXI0imaws35awzHH9HAaUK7iocr39mCFUcrVgUtABA3/vF/nQA2s4eHQfou93/PFDB/nhzSZ/+chxFk3q556bP4jA51orZhY43HuWSt1tAfa+2Ux3W3oD/RrebrN/jocTE5EUToZSrPwYsN9DIaDn0KrB541B+2NZ0dGyO+g5tNqGnp5Dqwm0z+bwun+h58gChKm4tgdg6Cq7zAFyg4WUyBI5ssBxL0OSYGV28rEWusAGk80D6rAQ0WHI9JmSq1fcmvqQfNmX+6zR66c7uBOb8hDzzwFrIsSv3/k1h3sPD7lu/Dpbj20d1T7ESpPBGhs6c8VE1+8SuKc/RAYhZNGl7ooLSSblqPRYy2H88oomM2DCuqCJ76oqSj9Ww6eXV/HJScV8enkV4eR/xozOQEnAXRdV41XdnzuPIvHD52v50l92cOX962jsGDg9O5hRRmOgseInJztBGFky0E2Jh3bdRnugJM7nYTh+UtnROg8JwdS8o67nhLaafQMfISvvWvJ4yn7cFBLnTtqaENwB6On8C76uj44JP6XLTnB6+cnJTqauJvCT8/mYZDU8Yn4SAlqa57KvdNOQ/ORc3nlJ1YUVfEmHneDM5Cev4rXbssYLPymahKINslP5jAL2b3LPyIz9Php+khT3Y7klflSPm598V0/j9knF/MvyKq6YN3FUx5TR+JSMxUrx+n/P7XvXslOmgmeEis8yTZn1V7vXuyLX4L7VPoQIIkkaIjoiM2Yi1a9PsA2eYgaANcXF0duo9WVelQXvqXqZdUdW09AzE0N4UaSQax/iTeQipsyDuz7Ix2t+jxoN1sSP1M6WtuEhLmAgTC6sfCPlsWqywTVVf6d+73eQohHuPOBYP7QdscZ6Tjr3GVpbn6Wu/keYZnKzwHTHgTrbVIaaWORcvn7HYMZFINABDQmBQE4BJ8kyVTE5y4+Fobg8eGLPH37181RedD+yokd70GcmvnfZba4MlGFK1G25hXxNEFT7eDZ7NzMKDyHNeJ6vFwVRFIOIGe3jjpYRO0d3xnrBIyY80OYZMTw4e8VPd+lwOrp5+s3846J/pDK3kub+Ztdza/av4en6p4fMRKUaBzpSxQwDYy1YACuum2a3YwFsdFTwxHx6ALzZmmtblXNTm4nGtxzKqsT1n11MbpHPLovulgXX/PBVgrqJKuDWuj4UH/Gf6ozOUAngpy8f5MMrpvD7TYNf5q6YN5Gn3rE+AyOZOpRRRuNNY8lPbzVVkh/XWKHKgo/X/J767qoR8JP1wKKy3Un3WYq8yQz/Zox+d5Y/5qGXSl4lfML8NJJR6ieDn+JZKV12CrTPRPV3ujx4AOrXfoucyVsprXksOm0rfX5q3HkVBdm9dLXMpz63jqMFO6nIOc7XCyJJ+Ul1VPy82/jproV32WwUm6AV0+nkp+x8L0drjzNzxUTyS/3MXDHRNmIGmLliMOgSz09zV08a2qT5c0vslkNFk5l//mTmnz/Z5qemrgC3/PpNIhJoRzq475p59n01ozNfsZDrtQvKXX/XcLSs593ITpkAzwgVP9py16HXCESsC2hTbyHrun7ILTUdTC6ZxvYdn8A0A0iSj1vOvY7vRct1Y8aB2eqxaAmx4ZoCoMkG18xs4ffv1PCN17/KBZPXc+20F1JOB9Bkk/MrD6WoxLG2G9+CJQQocvIshHM05crybUmXMc0AO/f9hMOR93NO9T+weNFCWloeY+LEGxMAJN1xoM42leFc9xs7Bnj1hXoMffAYDjpGpaeCkHhACWHisSwF7cec5ce9TSsTthFon039s/cl9fCJyVv4uqu8WJEFW6oeY+qrdxIqmsi3POfTfO59CGUQTjUZttUtgkAhO7MOcuvUw67xm0UqrpLimIoVM6FVK17OXvGhlhsP0tD4eM3HbfhwToCIKZZVSgUoJ+a5k6hNT9a7WqhUj0zZ1Dz6OoNc98+LaTvU4/LgIfrzpqhBM0Djrk7+8O2NTFtUzPwLK6iYXeh6jYrZhXzo3lWugM7zDR2smFVEN4KfvXLA9sHSJTgiDJaW5bK5NTP94WxSVyDiaue4fdVUXtrbmvbUoYwyGq8aa37699UCj0ICP11UdYTH9y1Kk58EkNjSHpMqC0bibjaW/DSSUeong5+cXGQmSZr1YpCDbC/nZKdIf6kd2Ikp0l/K8dor6TuydMT8tLH8Reav+zQ35C7iUnM6DTWvJvDT5oa5BHUvjVI3t0yrH5af0mEnOLP4ySN5uHzK5fbv45Gfajcf49rPLKKvM8jld86zgz5OJpq+pIxNjw+eo/s2NjNpZkHSZSHKT99y89Omhk6bn37yfC2R6OkbkeDAoW5WTStiQ33nCR1bRuNHYUOwsCLf5iWfKiOAkG6+K9kpE+AZoQoKBkdzyrKf+VMvwK8NTmt4eGOEP20tZO3dC1m18mmXYWCsFLmjL0QgYrCkdLCEWJJANyVUWRAxFTYc9mIIq09xIJLlghPDlFxlwUJAvrLHBTknohicJNuWE156OtfgM57kMw/dxeeX/RIhgjS3PE5XzkN273my9yzVONB4p/5U5ZiNHQO8//+to3IAzkdDQyKCYLPPYGq/Ymeg4jNPAhIARSZ1MGgopfLwATDC++lp2IexHJRoEiJswv6IjOp7mgt7P4o5vcEFJ7FlnvTto0OVQYKGZh/VvkGg6DIsGCGEDRjFislXJgZtkBlqLKezV3w8y8Skpb+FqQVTAXc2KaZ0skoxz53utgB7dw4/btM54QGwf07mj6OHTVe26IPfTJ4tXXn9NI4d6uHgFqsU3tBNDmxp48CWNm78/BK7QienyGdPzppzbrlreoxHtkbGhh0NxpKAV306ZII7Z53eM28CX71qjmuqQ7pThzLKaDxrrPnJE/UTjOend1qyiJjp85Pl2TI2x3gi/HSk+XGmzVnD9Emzk75fQ41SPxn85Pw3Wb2SNy45lq5Gy09L/PV4WEp3YW1SfnrWU0+HbPFTnSMgA1Ckuu/hI2EnODP4SZVULi++3PXYmchPsW0tvKyCbWutalYjImy/qJhfz1D89J5otXOs5Tmkm1aZrGTx08O7j2Sqn88yqTIsqihw8RLwrmWnTIBnhIqN5nSCx9q7K/nZKwf402arrzVWCnbLsil2tsWZdZpTVEeJv9o1Ki5iKvy59gZunfUYmmxw99IH+Ob6rwNwk2MillV5477VShJU5rWO6DiGCwTFt3g5De4MIaFEy5O9SpglZZsQIhhdNsizb/2Rxzflcc/NH2T6pNlJ37NkipVzDufUv/7tFm7r1KJ21ILsFSWsvKCCiU1ddP71ECI6VatF1plsDmakkh2yNsY2VEKYRAZeBuFh31+m45vZxa7qHraHFLpDChM6vXTrG9AKL0cyPAglbIFJt4cdASuQU6wOZpU2D1j7nxRGdJlqr5nQGz7eISSZYhAJYGBw10t38dhNjwFWP/jPLvsZzX3NlOeU09zXnHZWabiy9RhISLLES4/ssYBDlUESGBFhjQT9zCIbnO39VXCYB1pmy0vfMzXp6yqahKLKrmwpwM51TRx6pyOhMui2e1ayqXFwekzYTERrMQaB3NFKxmSFvJcyumilgE3mHMyMndsJSZWsEmNTwNfWvJMwNetsnfKQ0btLJ5Ofnq6/jGunPR/lp1/yzfVfA9Ljp7FIjMVv0/ma6fKTRJAfPPk/3HXJMqZXnJc2O8HY89NxyaBEKNH9klCSbMtzivkpcLwZvTiC//gsFz/talhkJceS8FOqQM7Zwk5O6ULn6faneenJl1hz4xrgzOOnBHaKmi07fZVgaH56dVeLXe0ccnJX9HMopNPT2n7q2Ska0TrLFbPe0U248+HNSfnp3ahMgGcU8vunuG60U4qzuHnxZNZsbSJiiIRSsMaOAX72ygFHS5Y1Jeub67/GQ7tu4xM1v0WTDW6d9fdoubBlCrisbDsCCY/inkhwqhX/moqj9zxsaGxrXcHFldsQIkjYUHnvzCfQZJP6vX9hUuEz+P1TaBsoYdPRlazwFDFlCCP+/FL/sE79lbpCR/Si5UFiok9Dag8xK6Lwpj448rPcTIYkJ1emfgREHwDhXg/hrWUU7ClkblGICZ1ecgMa/Rxh3ZEw0oaPs3Pmn9imD9BhyMimQrEWSRrIOT9YjVe2shc2jBgydcHx3xvuDN6kkkCgSAqGsG67ETPCC4de4Oc7fj6i6Q/xSla2Hns8p8hnjzx3yhmI0cMmfZ1BLv7wHHa/foSqRaX4szUO7ergwFuDQdVDO9uRgOpoi5bzdY2IQEpixOnL0uxlumSTJsWkQpc5uK2VFctK8SoyIcPy2xGAIXHa79dXypu4V3uESdJgWfNRUcS3Ix9hrbni1O3IWcYtuuP0eDf2imf07tFI+CnmVdjRFxqWn26ofs5mlZhvT47WN6b8NJoq6XT46YKKrciECBsq11c/xrHDf7N9emL89NTuTlZUDQx5XRhLfioSp54lhuMnAv08G/wNTFnJC03F5OV0UBeSmXlkLt2Vhyj2BBP4abpG0kDOmearM5Sc7AQQNILjhp9aD/Ww8JIKutsDTFtYijDFkPwUz05Lr6xk2wuHEXEjkobipwpZRhVWK7sqQFakpImyU6nTw07xF6uzDJyiMjL8lFSZAM8YqLFjgDsf3kzEEGiKxEN3LLdPLmerxepJzqkOYS6YvJ4rq16O9nhjB3diKvG3My3v0AntWzyQDAcoIwUYPevj/OzOT1CadRM79/2cro6/IMeyVQTp6tpM20CJ/R74NYW1d194Qh++msVlvP1YPWb0RnJwXTMH1zUnuOjLSOgI1FN5QRP9CQ/lBjRyj7gN4waMbvrbp/DKZBNdkVEND9fs+STazOfwytsBCzxWhStQ9ryXKWYBxpR7UdSIC0Y6TEdveFCmwxw9pEwMF1MzMIOdWQcSxoWORhISNcU1vNPxzrDLehQP962+j3veuIeIGcGnWNNF4ic5jBRQ4svWc4p8dnZIViVMfeibvqJJSLJklwYf3d/N5XfO48AWd8Xc0dpujtZ2s/GJOj74zVX2VIcYc4kkdlexbFSXbPJQbmgQRh4/wA3Tcvmn86ax/flGZoRkFFXiwHQfLzR3jej4x1JXypv4hXZ/wuMT6eQX2v3cFbn71AV5zj5GwaNIhJMkCDLK6GxWKn5ytakqEudMGJqf4jlnWn4D03LrT2jf4nloODYaLT9FQlfyyAv/yfmTX7f5Kea5k+EnNz/1690Eugc4KALoAyqq4aG6cxHVnYsIzf+Ti58uHphDXv0VmJf8CFkNEzYl6oKD481dvjq6POr7ylizE0BVXhUNPQ1pLfsf5/8HrQOt/Gz7zwgZoXHDT7IqsfHxg5jRGGv9jnau/+ziIfnpun9ePFjxI8Gx+p6E4A4MwU9PHODSj87jgrCGaQrmGCqX3jGPn62vY93RrhEd/1hp/LBT3AkuwG9C4NTnwsdcGX5KVCbAMwba1DDYThExhGuU51t1O7lg0nNICOp7phI2NLtv/KqqF204SaaLK98cdlLDcIqHjZG0Zg0n04TC/EVsauhkTt5GejoHgzuWFPr7D/J20077/RmL6Gp+qZ9VN0xj/ZqDrsdFXM2ljmCzJ8K5YfdozpMqKTvt5fJCJdy+/x8xKjahNK0gFC7kOf9+VjiySjQvY1LvTDq87fypxcdUv+Q2+RNj0xs+MVzML+r+DZ/wEpRC3FX9nRMGFYEYNrijSAofnf9Rbpl1C5W5ldQU1fD3t/7OTefchKzIrgzUaCY55Jf6ufYzi9i/qYWZKybS1xm0sz6mLpAVyS4VTqaFl1S6RskCvP3yYVIVJBkRwcFtrWTnexPOx3jtWW+ZHzYpJnqsxFSCvYrOww9tIGQKNA/MCHkpEAo3LJrMy0e7Tkslj4zJvdoj1s9xrytLVmvRvdpveT50TqZda5T64ntmU5zjfVf2imf07lUqftrU0Ellzl5Wlb/FhuZzqD0+PW1+kiS4dIgJoenqRKt1hpIJzJy8nLfqdjLV9zwXVrwet8T446ehpmiNidLkp7xQObfu+CrdZduZ7jUQqqBDl3g1jp+CbbMpPT6Ld17+F/Ys/hn7I6YrCeZipxMI7ow1OwEc6hk+uStLMv95/n9ybfW1AFxacemY8hO4p4Y6q2vS4afqRSUc2DLIT6Yu2LWuaUh+aj3Uw4obqln/6AEQcKS2K+mye99MwU+yzsNrthHyCjQBs3oVXv7tHmouKOONI6een8Y1O0lwBheuuZThp0RlAjxjoBVVRa6pJ7Ho4fHjG8jv+ygfmG2Fr0OGxnOHLuK66hcAazqD03QvHg5ONLhzsiXL0Nv8WX619S6+tOxnKAkXCoNDjb8kl4eYnPMNjvQVjVl0tXpJmWs8dTJt9eo0qIJlYYEHKTpGL/X49LGQrE4GKccuM/bkhskuH6C/OYtwbxSUpFxkdTJadhuzopklc+abvLj5ZtpNYWeV6oMa72ldDEBzXh2twqB1wPGRTXWTir0lI7iR1QzMwCe8APiEl5qBGbR4Ok5KZiomVVb55RW/ZMXEwcxFRW4F5xeeT0VuBYqinPAkh+62AE/+dDtGRLBvUwuX/MNcO/MU6w9vPdTDxsfrkmajwgGdgV73BJW8Ej+th3pTQsqGxw6SlZs6qGiXExsyRYpCheEuJ0ZAKFpOHJEsgMHQ+eHzezAkyxjcPMUVLCvkva7S4njJEkyigxXyXjaY807OTiQ9l8+ckmOZwVGeybSoooBV04tP1e5klNG4UDJ+CgQameb5LV8550EkCS6c/Cb/9dZn+fuBq7l19uPA8Pw03iUDDfs/hQ+JLiXZlC6Ln/J5iIrcf6Wpt/CU8ZMJPO0P0+LgJx0RHUpx8jQSfipWOzhn+d8sftIfp24IfmpQu9gQBJxfoMeIn1KxE5xYZc9Qbe2arPHZJZ/l8qmXu7hoLPnJ6YUjKxJlU/PIKfKlzU+SDFULS10BHgCPXxt8b5NoJPxUmAY/1WoGb/hC6G8dwqNKnDch/5RW8owLdoLk57I49Sw5WmX4aeTKBHjGQMmmnAQCjWzbfgeIwf5vrxJBQqCbCmp0pLkkWZUwYzXB4VTLo+hcOfVF18j1eNiSCTO94AAfueAjXF1TPobR1dR3CUmWWBHSWBwSDnPAkxvcAZAkGS3rEiL9T+DJDTP7/XUomsCISOz7SzXhXg9a1sVIkoy/ZD+yapWcy2qY6V4D1fDQQZjjfRrX7b4LgO3lL9LtbUcyZUTsfTYhWbBfEhJCiMHn0jzcnf4DBKWQnYXa6T/AxHAxD9Tdg1d4CElhPl3970NCSsxrR5ZkzGQ9SXHSTd0e4Xm49zBbj21lccli1zKxSQ6jVd22VhtijYiwjQAlCS7+8BwqZhdSMbsQSZasjFGcdr12NHGjQjDznDL2b05ubC4M6O8KJ30uvpz4P+dMQbzVxp29XhtaAF4XOkZ0mTxTYqNPJ2REM2dY0wL04d/iMVMZXWO63KiU9Fwe/gSXgTkTc9ndcnonjg3353JWfmaU0btF8fxUmtXOho3XREekW8tIEtw4/WkeO3gNuimjRu+DZzo/aUriePbEYFWY715ncExfNMbZ6dT8JANXBzw8mh22UUImcQrpWOu08VPsy6+Iut0r0fcljcPdmRXHTlkWR4yUn8CagqWLxHMiXhEzQpGviMrcSpudlk5YyqSsSa7lToSfXNU6huDxH29DlmVM3c1PuUU+etoCiawkwcu/25Ow3b6uIBOqcjlWn/x+nC4/aQJ+fN5seLZxSH4KIOwKn7AhmFWYzcbWHrf58knUuGAnSH4up3F+37BwEo2dA2xv6hrrPRqR4v9apbke2noHz5MMPyUqE+AZI8VPOenq2owQiVmZK6auY0fbXJZN2Gk/JstgmCSpgEnUeMxUzS/Zbf+cbP9ChsbujmpuyPGeEJzEDBdXVBUxcKAbI5L8Aq0jiE3E9DiuYCcbTmJSPDOB68ku/wuKFjUt1ATZ5SbCvD76PATaZ2LqnmgGyoNoXsqth5fRnFdHeU81AH9a9D2MZNk9GWRTwZQNFENjQfOFAOyY9DIM0faXSi3eDu6q/o4r2/S+9svwCiuT4hUezutZzF9LXky5jZkFM5lWMI2FJQv5/976/4Z9Ta/iZemEpRzuPcx7H3+vVUqs+Lhv+n0j3v9Uin8nYuXEQsBLv93DxOp8ejuDSYM7qRSfkRqJ4suJX97aTI2hUoBMQbR0vMsZLAUezQm7yopVAe+ZUsLTDe2j3o+RqpWCMV1uzJRGhtWE0x7cSaX4vnHnNS5TZpzRu0VOfmpu3oxpumFdCJhTdJDq/AcQcag/kuDOeOQnuwoJ6A35yfO6jz1kaHSH53LL8orkG0hT6fJTTBoSlwYU24PnbOUn2VRY1XA9G6qewJQNko4LG0ItnkR2AjivZ/GI+Kkip4JVk1bx+IHHCZvJAxwxqbJKeU65m51UH49e++jIdn4Ilc8ocLVgCQOMaJIpxk/ZBV67Qjpe1vKJjzfuTF3NMpyc/BSR4PEX6qgxh+anLb7B3kNFgPRmO5ctLDpl/DRu2SlNPb3z6ClNJqar7gEdryoT0s0MP6VQJsAzBnKeVJHQYXY3PM7k3DAmHmTC6KZk94p7lAiLS3cmbCO+NzOVxhucREzQHIDl3D/dlHnh0KW83LQan6owJ+81AoHzhhz1mUpOw0W/prDmIytQNCnhxnJA0WlXBEvDqiu4E6+T3UuueGYS6f84pv5tZDWCqWtE+j+O4plgLxPpL6V+7bfwl+wn0D6TSH8peUBeWwkA+0o3JYcTsE2Ze33HKe+pJi9Uwr7STYMZqqgkU7aAOBkEx305bvF0nFAbVm1XLbVdtbzQ8ELKZVTJuuToQrdLkLce2zpoBmgEqe2v5T28Z9T74VTZ1DwkRUIYAlmVEALbsM/ULb+cDY8dHGYrY6f4cuJYxsmpWs2wAjpg/wuABBURifOCGm3HTm22YpM5h6OiiIl0Jr1WmQJaKGaTOeeU7I8sYGZYpioiszZbP1O6tFAk98QHZ984MKZmqhlldCYonp/21G3HjwrohAyVpt5JTC9oBLD9d+KVbuBmvPGTM7EnAXnegH0suqmwtuFi9nfV8N0bDxIITBwVO0EiP/3+hkVJ/VOOyQZFpoyGRATBBDP5V4SzjZ+a8+qs4E68TAkk4b6/2NU+2I+fKDsBNPU18Wjto8gpfFhUSeWmmTfxt/1/Qzd1PvPiZ/inRf/kNlJu3coURneOJNOiyyrZ/mIjwrAGTpimm592rWsa0iZhrJXAT/oI+AmYEZHpkQTPnsLk2HhjJ7ACXVPCEo0ekfAexWs8BXec/BQ2TL5+9ZwMPw2hTIDnBLXhYAe3P7iRiCGYmN3Bvav+kywlwvEg6IbK3w/cQH3PVO5e+gDe6M0mWaXOmdpHrg6xv2v2X8fSef/MuQs7yO/9KMcOh2lt8nLuqmdHDCpOI8ZAxGBHUxfxJcaSIjHVUJhhWHByXDIpTDHqM9ZOdDIhRR+YQP3ab9sAog+UJiwT6S8l0p/4OEB5TzWKobkgRTZlFh69hHmtq8kLlUCve3nV8KArYRAwMVLMgr7ZHDNDvF2yJfWORkFFCIWrp9zApPxCfrf7d7yRt53b267Di5cQId7I257WcRsYqLKKbiaWGjvLj8NG2C4t9qk+u4JnVvastF4nXt1tAZoPdFE+o4D8Uj/dbQGe+tkOO7hz/WcXA/DET7ZbBoGqRFtj77BmyGOpAlN2lRMXJJt6FsdLcqxPWkCTJnhUDXNZYTYEEieOnCxLGhOZb0c+wi+0+zGFOyAdmz767cjtJ98kUEBFGJo9sM9rst8zjugjhbyqzJ3nVZHvV8kKtPHdN7oJ6iaaIrGoooBJBX57FPRYmqlmlNF4VzJ+8kfvdxFT5v6td9EZLOS+1d+1+SmZJCn9KujxJEVOPqnr1aZzKSz9OOcvyua6vjs5djhIa5PGksUPU1i4asSv4+QnT9Dkzf/dC4ZlkisQ9j1wgqkQQfCyL8zsiMIkI3k5y5nLTworGq+lunORm596sNlJNlSQTMr0Qmr6Z7Ezu9YdvJGgsK+c49lWe3k8P+X4Ff6+/++j5icTMyk/6ULHFKY9Dj0W2LHZSfWxtGwp7b2jC144+Qmw/XcUTWbljdOoXlJGb2fQxU+R8Km9/54oP+3zmNRq4dTuRieBn8YFOzmCkjF+qvcKJMFJY8axkqZI/PctiwjpBoH2pgw/jUCZAM8JqLFjwIYTgOr8A64Mk0fR6Y3kUnt8Jn8/cA0fmP3YkNuTJNjdPoO5xQfGbaAn3bGhuinRGSpgXsHrlGcf41C0V1KIEK2tzzJ16icT1gkEGunq2kxBwfKEAFC8EWOlrtDhKDHe4dHp0+C8fuuU1pA47DEoHMIi/qROg4hqKABJR8sPX01Q7SekBNg7YSOmbLCz/DXmta62lylWoMIjsw+Ncw5fxdG8A+R7w/zH4c+iCY0QET6d1+CGFGcPuu1zYPDikSd5YN4DnDf5PP59/b/zaRJLj51SJAVZkomYbvi+acZN5HnyeHDng67HNUkj4mhdLM8ppzK3kp9d9jOeqnuKa6Zeg9oy8suS0xAwZv63f1OLa+LDrnVNrLppBtd/djGP/2gbpi448FZyH52TqQIzBZhENUtX7B5yRcAtfR52ewze8Vo3L0OC548cty0DXDqJp/RacwV3Re7mXu0RJjFYZt1CMd+O3H5qxnxK0OQd/DWVQWDs3XXiZ74hUWHINCkm3UpyxIuvsDkReVWZL1wxy/YdMwyDZ1/vxIzOd40Ygg//egOKbLVp+VQ5oeQ4o4zOVg3HT5psUuLvTJufdnfOwieHmFl06KTu94komV9QPEMJAU19E3nh0GF+dP079Ihg9PEI27bfwbmrnkuaIEuXn6pRIWqIaxqC17N1ciOwKDzITgEZ3s4ymNSbul/pTOGnbm87eyZsANlEEvJgcCeqYgUWyWXk7vkXXi19HdmUUPJabX5KmIwl4LjwD95rJet/Nj9d8YDNPp+ePjp+unzK5bxw6AVXQkxGZnr+dNdy80vm2+x0bfW1VORW0M7IAzxOflI0mWkLi212MiImrYd6AMuc28lPh94Z28Eb6ehE+Um4qq/izJhO0il92tnJca46+SmBH6MaLT+NhWIMlpyfmjP8NAJlAjwnoE0NnTacANExniqeqHGeENAesE6yra2LeO+MJ9GU1OUCQsCUvKZxG9yB5DCSbH9VWfCpBY8Q7oBDHe4FIpGuhOUDgUbbWFGW/axa+bQLUuKNGPNNib0vbsKTv4+e9hlslPMAOE/RrKuDKvGpf1jAmw/uSenWPx6UJUOxItFhCAbMwd8PKZ38eeH30ZUwquHhnMNXIaIlxLoSZmPlE6w8fD1VejHn5WhIksRUinmxdDdh9TjfqfsmGhoAXjTm98+ixfMmmLCISykpquLFrsHgi3Pawz+u/UdkSbbgwsOQpcdfWPYFLplyCd/d+F1eO/Ka/fiU3CkU+RIvsPGTIZr7mjnce5jPvPgZgnqQp+ueHpUHj9MQUA+bPP7j7XYpcUwHtrRR/3Y7iy6tJA0P6NOi2ISIW/o89MiCPFOiRxbMCyvs9gyWHts3ZgFIKRy3T4LWmit4PnQOK+S9lNFFKwVsMueMm9Ho5YZEnyzojb4/MVjINyTu6PXiQSKM4OHcEN2KsCczxGBiUUUBH31o0wkZMMaDCVhfZjfUtfNm3QBhx3lpiEGfgqDuLjl+t2efMjq7NRJ+auiZMmyFc01xLQMRb+oFxoHS8QuSJPjg7L9hisfo6XRfh4SIJE2QjYSf5udlse4nbyNpx/BP2E9L3xR2B0qYG1bwIKFoMrdfb10LX/rB9nHLT/Hs5HzMyU+yqUC0dd1QImyY8iRlfZVUdy6K46cq1uf8jTb1OL908JNPeKlx8NNq9WY25j6Jk+Qnhotsfvrkc5+0g1/DtW6l4ieBSDBbNjH54dYfuh7b1b7LHoX+dP3To/bgcfKTETETfAYPbGnjwJY2Nj5Rd1bwkzuQYzBi46VRaLyzE4ycnxSsdy/GPBPzfHzp0R2u6/pI5FVl/vfOFTR1BVwMlOGn0SkT4ElDsR7xigK/68TT4hoq2wMl/P3ANfYYT0mCqrxGSvydFqgMM/ZckiDHEzxpx3EyNBRwDT7nPm5NKwDcGaeurkFjRdMM0NW1OSEL5TRiDAQaqb7y25giQInhQVv/NdoDJTycF+T+S+cxdUoe+ze1jAs46fG228Z/zsxRlgyX5KqokoQuBBv6dFblWL/XUMzjRi4tSofVcgWucuP+/MOE2cicY1cjRd9oCYlrj1/AWzm78UThBCxYqAyVMSlYxlFfK7uM11m2IwemWs9PDBfzi7p/wye8RKQI/1r5E97JHpwEMVQG6v6t93PJlEv4+sqvs/GxjYSNMB7Fw+VTLwescZ7O7JQudPsxn+pj6YSlY+LBUz6jANUj2yM9470FYjIigkM7T33WKR3FT9h6X5/HNlhWBFzVr/F0dsSddZHs/50ymcgnd5znKCULmBNUeDlrEIxjp0GFIdueXB6sTFS3EiZ32iN8puYerpoz0762fOGKWXz3mb1pv64mw5eunMOiioIEMAG3/8VQ8mvKGE8ZzCij0yunvw7gMsBMh59Wlb9FZ7CQqrzGYRNfkgTZntBJOY5TLVkCWRr6W/SJ8FPxVyexc99nEAT5suHhm+u/xsOUUiUUvvep5Uwq8LP12YbTzk/pstPLvdY1P/aYk59iRsqmbICAupJtDOQ1UpEdHAE/TbD5aYP+uMuvJxU/pTMiPRU/3Tr7Vl5tetXmoph0081PwJh48Dj5aSgZEUHd9tEPmTiZGhU/IXMqT/Jxx06O9qzR8NMPPzyDcDjPxTwtPcG0+UmR4BvXzEWP9qol458MP41emQDPMEp2cnkUiS++ZzZvN3UnLL+ldTE3zngWrxImbGjcNONpvErEZbT87pZKXt7ChIzT4kW/Rpb99u8FBcuTrh3rE9aK12MKC2g8SphZhQdpD5TQJkwOqwbv/HSHa0rEye4XT6Uebzt/XjRYiXPrjq/aoFKsSKhRuFAliQqPbP/uQWFh3xxait5ANTxUdy4iqPazveJF1/hNFBBC2JCyuncxb+a+TUSKoAkLUiQkPnD8Sm7sutguNZYESIaGUCLUDMzAJ6zMpyY0vtP4Wf5tyk+YFZjK7e3X4xUeu0x58azlvND4gt0fHjEjbD22lRtn3MjfL/wLDTv3UVUz2x7N+cAVD/Cp5z5lZ6O8ipefX/5zmvuaWTphqb3cUB488d46qbT8umlIQLA/wta1jfbjsixhmoOfvY4jSbxrxoHiJ2xt8kZcZoG7tVTjU8dxyd9oNZK+cAGTI3B+yMOfc8IJ62my9d6GEXYGqkkxUfM3Yvr2MWFCA1OKFwHW9R6wS33VqEeGIazr/tIphbx16LgNJGAZzRfneFk1vTjp7j2zszkpnMiS1YPvU2U+H1fxk1FGZ7qc7ORTZUwhCBsCTZb47cdXsr4u8Uuvk5+EgIsq3mRV+Vvs6ZiZ8nXORO/C0Wus+GkrAisw4I3y0/pACTvQ2dHUxas/fvu089NI2KlYGfwZEvnpogMfYPfE9TTnHxwVP916/D3c0HWRzU+xgJEQJOWnH0z6LV9svj2hxeuqqqvS46eJ1ay5YQ0vHHqBn277qT1VK56fALuCJ5UHz3D8FHv+2s8sovVQDxseO+jyJYxPmHWd4gEP6SrDTw6lyU8SMCECMyIqkw05gZ80EyJyhCZFSspPwi+4ZcGNwGAwf1FFgd0O6uQnTbb+daCTVR2U5eGWZaknBGb4afTKBHiGkdOcLqawIfjuM3vxKImfoPZACd9c/zVmFR5kYlYL11ZbYxFVWQwLImciqKR7TCYaMgLQ2b7jE1RP+5wr4xQMHmHVyqdT9pCDu0/YV6BQfaUfUwQw8XKoxwJAv6aQ22O4/Hmk6mz+cKyTiYbEhUEN5RRe0Jvz6uwKHF0J05xXZ0956DAEuhCokoQhBG0R0w7y6EJQdegKLumsskd+vlO+DrCAIjZ+E7DhBEBD44tHP8rftZ3cHF6IKg2Wf/qEl5qBGbQrvcw7voTJgeVE/C3UFb9AhIhdkuxB4z8Ofw5NqAnrzs1fwYQpF/P7Q/egi8EqnMONdZi/amKanoP0ZjP63eWoxX5WTFzB4zc/zguHrMlal0+93A7qxFSZW8maG9aw9dhWFpcspv3gIKDEe+vcds/KBEhJ5r+z46XDGBGBoklc98+LadzdwYEtrfS2j98KOeeECEVAveYOCNd7z+IAcTyQjOQjKsGCiEaPLJL2lE8uCdHQ6uXh3JCrh9zjOY5mlnPsWBWNhVZg54ofvkpIN/EoEqrsniARNgS3nFPJf92yiD9sauR/XjuIbjJkv3djxwA/fL424XG/pvDQHcuTVvxklNHZICc7BR0fpIgpuP3Bjfz3LYv40+bDrnVi/HTNtOe5qOJNALxKhMVlu1OyxpnGTCNR7Jhl2YtpGryb+Gkk7OSRoMvxmJOfcoOFPD33V/bwibHgp/fu+ScMv0wYifqyJxP46SvNdyJHb0ax9Vo8HUn5qTynnGe2PkHN3wqZFhnkp8riSu6suZPLp14+JD/F2GnphKVMyprk8uAZjp+SPV82NY8nfrwd0xA2T51p/CRn+Cm91SRYEtaoiajs1HQ3Pwm4oV/jpaJDHGdqAj9l+/uY6JnPo1uaqCjw263tXlXmv963MKFVK2LC16+2JoX9v+f2ETYEXlUe0isnw08npkyAZxg5zeniFTYEn76omlf2tbG3xbLjL/G3R6tJirh97p9dy6dTYnwmyTQt/4pkk7QsnpNRZZOIqbD+yAouqnwjul6Anp53kGUfphm0M05+/5Qhp2s5+4SDXcWo+v/wm9q17GyfRm+khK9fbUVx17/dYkebdQSeqmzaezpp0g16JcH1Ac8py0Y5J1uphscO1gAMmLChT+fcHBVFkliSrbKtX6dUk2kKm8hGIbODK8iSIVxYT6mRR4vSwc6sA4TR8UQ/vs4MFICGSnVXDS8bBnm+XpZ6ctBQiAiTKa3nc8mRK7nBW4YXCQLFhJrmuopUdUxXcAcgKIU4pnVg/D3CW0GJoP+LfPlGD1dMXwXHIzz/h0d5j36utT8Rk1BDD2qxBRKVuRaoDKXK3EoqcysxDMMFKPHeOs0HuhIAZeuzDa5l+jqDfPCbq9j9+hG62wP0d4V4+6UmV0ZyPCo2IaJWM3jNN8zobwHVYYmwZE3WSut0Hs/TEkayX46JEETLsSuj4+ZjgIcAvwkBBRpaLZjvVgTdUQ80jyLxyeVX8uvnr+M/9zXxm6eaef/UUnwhQUjB1ecdUyyQc7QrwK9fr0M3rQkPD92xPCVgbGrodH25vXl2FufWTGdVdUkGSjI6q+VkJ02R3LBvCCKm4I//uIpvPbErgZ/2dM7kwslvpjXQ4UyVaVrHlGyCajw/FRddT0/no9H1AkQiXQkVOyeTn451d9BkmKeUn4Zjp5d7dco1iTk+hZosFV2IBH5aEl5BuLCekmi7FhJ0h7xEMNCivivp8pMuTPo7FjKv+XI+JE/CG7bWCTV91sVPJiayY3prRIpwTOvg8q6V/PaJLur7s/BH+alm4lTue+Yebmy5mAWR8639GSE/xdgJwDDc31OG46eD21oTnp9zbjnXf24xu9Y1kRvdhzOFn97X5+EvOeGUwxdsCZgTlumTxLuXn4iOmo+ykzNAJgm4pl+j2lDZ2z+N4x7TxU+qIvjuZZ/ijv85gCdoMtWU8ckWO4V0k+d2H0vw4Ym1UB3tCtifl+F2O8NPJ6ZMgGcYxczpntnZbEcdY1IkKM3x0tN3iNWT9tMeKOLupb/Eq4TRTRVVTlUSeHZIllNbu2Zl1xAO7ARAkw1WT97ger617WnAw4zpX6Ws7Kq0xqY7+4RVj8wRdQKvHI6VIpsU53itD/3Cidz5bC03dGuoSEivtfOT987lR0/sxSdOzfSHmPJCJdy646tJ+8gBsmQJxVFqvDTbCvZUeGR3X7kxi8vr7uG3JU+wIXs3L4e6uNxTjCJJLjgBMIUgYAq2KDqvKTI1RpBb8LBIVnm/MR1dEnYpM4A37q9Y66tnRnAKHjRChHi+YAMlkUK+c/izeIRGAMFHA5BnLKQ8XMyRX23mPfq5dhm3oQq8VXmubeodAUINPXir8mxwSUfxf/PYCE9wZ59iUjSZQG+Ylrpuu03r4Jbx2TOeTAWmTJZpugBFivKHGc1MEf25zpMmmNgbGss9PQ0SUGJARUSmXRXMDCv4kMgzJXts6p29Xg4pJlMNmSxTipoBJm5KkiRyRQ3ByF7yDYnbujQ8nd3cgXfQQFAa7EFXZSuQA7gm/0QMwY6mrpSZpPjpf5dXZ3HV0skoysk3dcwoo9Mpp7FvRYGfjzy40eYnVZY40NpLRYE/KT8ZpnrWBXTi5TRcjj/WoJhJjrIfsPipu/Nvrst3Q+NDVFT/gnxvR8qKnXidCD9956oZPPJiHf5TyE/DsdOACWETV6uWk59sT0NjFpfV/RvfrPwZ5aEJVB29lO26yTnZMlIa/HShEeJLsh9VkvlKeDFbMfAOwU9v+2uZF5iOB40wEf5c9Bz/2fgvqCgEMPgoAxwNFJBnLKLj6Dbur/0yPuG1+UnS5FPGT5ueqLN/VzSZnCIfW587xMbHDxKb0r7t+cbT7sWUrnpkkRDccTJTLLihAPs95qDpcjo6069HAibqEhN1iRZVUGZIzI2oVmsbYfYWv0PJwAIWhFWqoiPoIwiaFEF8dEuRFJo7vXiCZlLz5SlFWfhU2Q7OpOKnoG7yzM7mlMbIGX46MWUCPGmqOMfLIx9bSVNXgO6BMP/+1B4MAb946TXuW/1dvEqEiKmgRc3XVFl/V/vuxII7gOt9iVuK3nAuU9OAE4D8Uj+33bPS7ifulgX+l2oJRAy8qkxHX4gNBzto6grwhdXTaXjGKv82Iia1f6njatNDGIGBQEE6ZX3lEyMlzO8qtaY9xD3nLDU2hXAFe+L7yr3Cwyfa3scdrTfTIg0uGy9Zkjg3R+XlcIRsBb5FFn7HcaqS+9jjExPzgtYozgg6D5Y9xqdb3+96n/xInKN4WFFVRKihB0UfNCl8rvBNrvjgLTR72tl6wCobLg+XcOz+rYiIiaTJTLh7adqQEv83d2afYtkpLbsNf8l+yiaupH6rxPo1B5FSRR5PkmL7EGifeUJjXSGxVeuqfo0+Rdh/qFf9UfI604FjFGpXoV0xrXGfqs5V/RJ/yTEwJRlFwEd7PSyKWLe1Ltmk0IAyQ6ZVEcyeUcimemtEaUg3OT4QRlMkKsKJBoIhr+CO86p44FULgHVT0NQVoKkr4MpMqTL88PlagtHRnGvvvtAFKc4vucum5NPZmFhunFFGZ6tin4VNDZ088rGVvFLbyq9fq0c3BQ+8WsfLb6/lm6t+jiYbLk5Q3uX8lKPst6t6dFNBjeMniTA/ee5Jvvq++/D708tknwg/tT/VxDWmBx2BjkA9RfyUFyphYkeJNS1LHpyWFdNQ/OT0NPQJL99tvBsFGcMraJXNhMBOTPH89Hn8dluaD4nVqCn5SSBYHLDaUCLo/Kbsby5+8qOwEJXjmsmKqiKkvTOQhFWxLCEhFucw8Yo5p4yfjIiw2aV67kU89bMdiUbLJ/kjeLLYSRVwXkBloiHTopq0yCb7vNFJYWlU+JyNfNWiCVpUKzHYogp2eq1qJwmDwvw6qntrWBxR6ZJNdmo6bbJhV/gk46epZnJ2+uCKKRRkabbZcoafTo/GRYDn97//Pb/5zW9oa2tj5syZfOMb3+Ccc8453bsFuI0CYyfg958ddAhfVrYdb3SykSYbGKaMIptETJl9ndOZX7zfzs6cao8dE5m9zKWLQgo4zhz2IHOqyywlwr4PooV/l/CMENBwbDfTKxrTykCBdcOK3aTywa6u+uHztfz8yX12j6hPk7lD9WLqwmUSF7sYmQhkxxX8ZMFKsklZWfLgaM/4UuNYXMIUggFTEBDYABOTKslUeBJLi51SJIlZmsK5qK7gTkzOY0111Boq17S+J+F9MRSJL31sGZOQGOgLEzMrMVTBFR+8BQo13vv4e23jvzVVjyBFy3vjy4/TkfNvHlN3W4BAbxhvfgdTL/sWshpGmP+HvPNejEjpqMZ4jgY0tOw2cidvpaTmMWQ1gql7qF/7rbTWT/V6sVatJsUkz5T4a07YNRnC2YZktypB4h/yTIeUVH3ljn+3eQVmNJpnSHBQNSkOK3ETNQT/0OuhUWrCo2YR1i0T5YffaCBiCFo8AjksYerCHhG8euFEjnYF+M3r9WSFoRqV+XlZZBf5XG0nnzi/ml+8ehCAQMRgU0NnQhYqNr3GMAw6G8koozHVmcRPd18+0zYoL/G38/llP7eDOhl+ckuSQCBRWHILvZ1/Snj+2mlPsGPfBEqXfOCE+ek3z9by+GP7+XnUX6NMkvmo4gNDIKvWtRFAjbZtHVB0ZhiDXx/GGz8ZQtAUHvQ0FEKgRO8TiiQxQZPT5ifPCPjJ+XgyfhISXHvVTL5RUUBxQy/KxHLatA6kiEBoEuXR4M7p4KeA+X9I2r0QHl2QZTT85C/ZR+VFP0RWjBGxU6rXc7JTLDDhnKylCIsTVGHZSzirelxK9fiZrCT8FLuaCRS6225gcdiTMI3szl4vWabEO0n4ySsLIgg0JBc7xeRVZXwhkeGn06TTHuB5+umn+e53v8u9997L0qVL+eMf/8g//uM/8tRTTzFp0qTTvXsuo8BAxOCZnc08v7vFfl7EXQEU2UQI0GSTmpL9rudOJZxsZiWP8DE6pcGy1iLRzkd4kOVsPKmv7QYxQXaS4A5Yy/jD/8eGjX9j1cqn04YUp6YUZ1Gc48UbEgmlgr/OCTIxLBHU4JZ+rw0pgCu4A9HsiSsrkxxYsmRrgkMMMIZT/LSHmN9ObLRnDFKcpcZgZZFW5ai83KuzrV/nnGw1AUYkSaI5bDBBk5GTnFzvlzwJx+mUgYkStb5OtpQpBJqeh2NiKDkXVZCzwrqAx7JKKOBfUEL2qnJ8Uwp47MBjFAxkUzOwiJ1ZB9jpP8BCrcjOQMWXH49Uztasgun7kFXLiFGSQ+RM3ooRyiXQMZNIX/qgomW3Me1KC3TSBQ3nOjHJahh/yf4RrZvs9QpMq0R2p6a7JkPs9hi8r89Di2rymk+3btCp/sRnOpxIMDEMLRrJgUtAnI+i/Xz8RI1jiuDY3lzC3iB3XVpJgbfAzi51YFL4vqks9vntLGdjxwB3PryZrLAFOBoS637yNrfds9LOKMXMAR9e32B/gR3KMDCjjMZaZxo/HR8YvFbOKjzoquwVIsNP4OYnCZE0uAPgVXQIPsCGjf97QvyUb0p88LjHxU6tismvsgJUo3LPrQvY8PBehDEY5Kky3C0S442fJCAgrODPAp/MRI97f2VJojGkU+FRkrITDM9PJiZySpMCi5/kSB4M+jlTdOtsrp6Sy7H7t3I8YoIqkXveZOQslayaEtRiP1sPbD39/DTCaprR8lPlRfcjR31d0mWn4V4vxk5AAj/NDstM1GUmGjKP5kSvRWcpP2UbEJAZbFlLwk8w+JghwZFoO5bzPWtSTGpMNSk/BRUrgPalpVO54fJqm51iQf0ySeajA34wRIafToNOe4DnoYce4n3vex/vf//7AfjXf/1XXn/9df7whz/wxS9+8TTvnbsHsCL3OLnmc+R5smgPWDf+ra2LuHnG03iiVTyQHERM091zfTK1mZXcz5cTHu+kiPv5Mnfz/51USBkOxHTTKvqIyTQDdHVtHhWggPU3qnZkWjxITDVl3lYMOqI3132Lc2h/u4NVYS1lpin2eHx1T0zx2aQYYMSeSwYuzhJiIKEFayCazRwwBYZwt12pksRMr4yKe9JDLPMkopO3msJm0gBQKnCJKZbvSraUQCBLEpM0x7OKRM6KiajFfnpePWwFdwAMCLzTTnBvJxPuXspSzwJ+Ufdv+ISXoBTCe2U1E+4uH1UPeTI5jQP7W2aC6QU5hKlrlEYraYTppe6Ze9OCDH/JflRvrw066YKGv2S/K7gDYOoeAu2pR/omW1dWwxTNeZrOvdckvKaz5BgB73gN9ngMzguowxsJngVq1WB2WKJDEfgNOOzBDvbIQJMHl9nyrIgF8hWGjBwNYaoCJhgS630mCI0e/QgfXDaX+1/Yb4PF6oUTXZmj2BfTakNBi35CnCaUzmWdwJIx/svoVOpM46cS+UVK/Lm0B0qoPT6dkOGJeu5YlTtw+s2UxzM/mUIiYkp4lUHIOFF+qtQVOuLaLLoVg25FsI0IdbKBdFEp+kvH7FYldYiqllPNT1kyeGRc/CRLEuWaRNi0AmbJVOFR2Dmg45UlZvmUEfPTUMGd2PqVHjc/eafkMrCzfZCddEHfq02gSmTVWN8p3lX8pAz6lJqGkhY72euOgp/2eUwOaibnBdSR+e+caRLQr1j+QxURCYTAI6RB38YoPzkrmJyGy842twpDtkejJ+OnsE/movdMIz96XjqD+qUhyTYyzPDTqddpDfCEw2F27drFJz/5Sdfj5513Htu2bRvRtuLd48dKhmnwuUtnoHGUar6CEEG+c57CD7b8E7XHZ9IeKOGe9V9nadkObp7xFB4l0VhZCNjVMZOakv1Jb95jWXpsIvMIH7N+id+oJIMweYSPsYzNJ63ceKjjEcId3LF2UyM3d+mo/4aTC7x85xNLeOUnO0EXoEr80zWz+OWzB6hDJ+iVeKahnQWylBDcSZZpSpW1ic8mOQEjFbgMmLA3aFDjd3/UTCEoVwcDPKtzVORoH7kEdgCnyqtgCOEqJ3b+uyBLpVdP3U8+WiUNghmC7pcb8S8qpef5xFpJETEJ1HVRgJ9u4QWs3vf8Y36kpR7UKTkE6rrwmCZqkS/p68bOgaHOhQnVubZxoIhMYELW/7Lt1bWo3l7KFluTRiQ5NCxkuLNAGqau2W1W6YBGoH0mpu6x12/beSN9R5amlYFyrisEFE5/nfypm5JW8tzZ62WdL8I+T3TahQQBSdjlxi6lM57gDCo9NiXYFxtvqlol1ucPqAleRAtCCqtCAq0GpwABAABJREFUqp25yxE6k6b+lqsnfYa+5ib+VpdDt6yBFOa6eTVMLvDy9OfOY3PDcZZXFTK5wOs655ZNycevKTQZpl2CrHpkJlTnJpybkwu83Ly4HBj6vE3n3H436N1+/GOlM42fpvEViOOnb67/GrMKDxIxFT5e8/ukXn26aV2ytFOQIBsP/JRKQoAsDbYa2bt1gvw0b2Ex7zxejxExkVWJay+dSusbDZSFJNp9UJ7n4fvbDrNSU5gbcXPM6eYnQwjbWNl0cJIQgnk+qzonnp/s/YzyU7+RulVrTGUIup6pJ7inM/E5XdD/dhs5F06m4Ni7kJ8MlcOv3p121dBJ5adh2ClXh15tiGXGg6LHYErRKasAiLT56fZemcLry5g/0c+mbW/x8N68tPkpxk6BiEG7D5SIjBExM/w0RhrJ8Z/WAM/x48cxDIPi4mLX4yUlJbS1jWzyzTvvvDOWuwbAztYQ//7acXQTLpy8kWnzg4DVK/6FZT/n3974V9oDJbQHStjauoibZjyddDuSBAtK3eXGrjLcMby37GWuq6w4cWdkOilhr5jLPHaN3Qs7XyJFBdPmY0tYWR4PngpZWd9g375OIMmNbwRa/L4cmhpCHNFN6tY0cLmhImSV9tkyf9s3wPlBT8I6I+kbd2aTdCHoiEamU4ELWJkpcGeXhLCqY8q9ChM9VotULFvkzBrFoEORJHoiOrlqYpZJkiTytFPjKC+AwFutDGxpRUqSFTMlODjQBECRArIBphJ97PUmip4L2o91vseHkZOa2If7PNfcnE1vi07uRJWmQzo9h1ajZbdRUvO4DQyR/uIht+HOAkU4tv2WlOXJ8f3esd8Pr/scWnbHiH17YuvmTd1A4fTXo/uQmPnqkk2aFJP8JOmmZSGFTV7D6fDItf0WeTyVHRlfQZwxCioZEmQJiQpd5g2fbmeZnHDin6zTu6COf53wMSDAv3X/EH1mDlmB6Xx65uV4OnrY3rGd1nArzf217D0wi05PWcJr/fflhexpj1DlU/D1QO5ElbqmfdB0YsdwMu5VGb37NJ75qaVPZ0NTiD/t7iVsDM1PAPet/h6abCRU94J12Yh/7GT58YwHfkomU4AcPV5Vjo2JMBgrflrwXut+GsyDg53t3NHjBQOkELz43C4+FG3hig/ojISf2g1zVPzkwV21HOOlGD9JKdgp9psiSQR1E5+apOpIkshJ8vjJkACCOztSPn/06FEGtrehDJinkZ9iXoLasEGa0fJTbN1A+0zq135rRL49zu3Ur/0WRXOeHhU/BSUxGJ51eBmuCihs9BuIZC3hWL/3nva+l9ErHX4yJ3azZLWPycXQGjzEo+qPkvJTsMckr0XnaN8xOvPc52KMneaWaBSYsn2uZfjp1GpcnKrxX1qHMj9LpQULFozp6LTGzgG+s+Y1dNMyA/SpfRhCQZEGDQFnFR6kPVBCib+da6Y9b5stp6OTlTDoonBMlxuN4uFLCNjVOYv1Ry9gefluZEL2c7KsUTP/Ald5cWPngB0ZnlKUfsleY+cAn3jpDar74RrDCuZIJlw2ZSp7du2zWy2cikRdlJKVHLuOCcGAKfFyr55QSpwq8OPMTJmOOmEpBYgMpWTBnbGSSepx907FXj1ZcAeg8JaZTF5s3Vz1eUHCDT14qvKYXORjYGsr3cYBwAKX6VkVZC1O/FJtGAbvvPMOCxYsoP94mOYD3ZTPyCevxF2W3NMeoNljPcc8OPTmW0T6Szm87nNR0z6dygt/PGQvuLsCx5Oy+ia+3/vwus9ReeGP0+o317LbyJm8FQnoPbIU1d8Z7TvX7W3lT91kb8sJVV2yyYO5IQzJqlyRxeCo9K0+w+6TtiVZz9dEVCb1yqzzRuypEfHLnXIN95ruUSQpl1eiJcPxZop5pvV+HfGYvO+6CjojA3iayznSdwRvIJewrwM8nVROv57F0xfT1NvEp5/8NEEjiE/x8eh1j1KRW5HweledwCHHy3luv5vHfMbeh4zGRuONnxo7B/iHH79hl+nb/GQqKLKbn4AoO1lfFFUZIqa7WkdJcnN6t/FT7fEqpuUfiTKmB1kCIYwx56drfuzmJ2FAcV8W0A8kBnQiCGSwW7dSee+YCAInwE8xxfNSuue5Lz5COIYaKT+l0tQVs/BW5wOnh59GqtHxk5WAcg6k6Dm0OuVrOPkp0FlF5YU/sgNQ9Wu/Tefea0bFTzu9phXEAZfpcKGQ+USvNTq8QzbZ5E9SLZHOKXeqq6RPkJ9MBDs1nUokqs+XKZIqKMsqZ29jc1J+6mkP8Of/eAs9bFXm3Pqv5yScY2PJTpDhp5hGwk+nNcBTWFiIoii0t7e7Hu/o6KCkZIgsShIpijKmf/Qtjd1EDEGJv537Vn8vCiAedFOgyiYhw0ND9wzX87Ebc+qx4CdfBRwf0+VGo4TKZgkWlNSyoOQgZWXXEAgcorf3bQBMM0hHx/N4PMUUFCynbaCEa6JwmGxs3lDa0thNIGLQpFhmgZ5oW8XCJRP5YEeQI682J6yjIOGvzCJ0OH6AedwxRK+YlqmfO8IxYMILvRH8CoQNyQYXZ2YqViqcarT5cDqZJcRjtuW+iP0ZFLKMLMsosozoCsOADqoEukDSZPzVBUN+XvuPh103kNvuWQlY/eM5RT57nKfqkbn2M4tYeEkFLXU99IU7RmTa177zBgQM2VoV3++dN3WD6/ecyVs5XntlNLtUS6jHRMtuRZh+Jp/7uL0/JQv+Dgj3/hU10LbzBjsA5NyHWtWwS4gNCVYEFYoNmQFZDJbXOiQLGJAFjYpBi2LiE9L4ascaal+kFD8n2UStajBLd5spOic/PPunA3y0x0eJ2Qn4uVX6Gn9e/D0iOf2cU34OiqKwvX07QcOqKAgaQba3b2dqwdQxOMjhNdb3qozenRqv/BS7DwMJ/BQxBVqUn7qDxQnsFDI87OmYweKy3WOyLyPVeOWnOUUNgEJB/koUxU9H5yuAxU+HD/+Kqqq78Pun0NgxMOb8tPzSKbz2m91Jk2AKEr5JPsJHrWtpqnSVPAw/vdgboVSRXYEfJz/FNJrg5cnWWO2N6Dm9/NTa8RayaiWpZTWSlo/OyPlpMAke750zHD+Zpowc9emS1Qj509bRXX/hifNTlEuUKD8dFSZNqkmJfgL8dKpP0XT4ScCFA1bwCgb5qUs2+d9ca1KrjMEda3x0mG3soA3I4lb5a/x5kZufjtX12j5OetjkWF0vhRNyTuohxpThp/R1WgM8Ho+H+fPn88Ybb3DFFVfYj69fv57LLrvsNO7ZoDngrMKDdnYJwkyc/AUOdXmZVT6DX1U1s+twA16iLvQSvNp0Lns6Z/KJmkcSyopPheawhyLRTidFVs94vIRJEZ3MYc+p3zkMWlufcD0iSV7q6n+EaQaRZT/Hsx90Td1INjYvlWJ/s24M/lgU4QeXzKVmcRn5pX4uubyK373WTHzbvAwJwZ1YFmokoz9DZqysWNjZLGdmyhCCo2GDSm96H7lTCTJj9SrdzzUAoFXk0vHwLstIUJWsV4jW3uddPdWeFpFMPe0B2mrD0N7muoHUbWtl05P16GHTNfZeD5s8dv8223tGy3ZnlVKVGVtZpXvtbFDfkaUpjys+U9VzaBX5UzfasFJa8xhBR3Yp9mUlPhMrx/lzCQElNX9HVq1qnt74fYj7w/iFRE1EpUs27fLaGIDI0eN/1a+Pr6COU0OAR6rnJMFgpg0rA/dqls4bQueOXg+FpnWjd07NMlFoUWRKop91TXj45wlf5oLLFlKZWwnA0glL8ak+exRteU45jx14jKUTltrLZJTReNZ45SensfK84joXP5U7+OlbpU/R0+lmp6frr2BafgOLSnefFrPl8c5PXd2J5s5Hm/9My7EnWLXyaTY1yCeFn1r3d3Nw3dGEdWSwgztgsZOJFfgZCT8FTYlG03Qt7+QnUwjawyZl3vS+2J2J/IQs0b/lGEqB97Twk5ZdSdaU4dkJToSfBit4nN45VlX0MPwku+G9ePZzFM160a4GOlF+MonjJ0/iNk5YJ4PNhtqm8zkJXsnSEdG2rBg/xbNTsyJR7HirNTORn8pnFNg+TqpHhvJAhp/GoU57i9add97JV77yFWpqaliyZAl/+tOfaG5u5rbbbjut+zWlOIu1d1/IW3VFSH1/RQgrADGr6npmARs2XoNpBiiTfQjhRYgQIcPDhuZzuHvpA6cluAMgY/IRHrSmQAjTDSnCBCQ+woOn3CAwmSaV30pW1jQOHPw+YE2DmFVwEL9WOKqxebG/WTJH9vxSP+feOTdlJgpAK/cRaA6gIqWcBOFUPMDEoMapuqDBdJ+CIklUeBLhxIz68cRrvGWp0pIB3c80RO35o4/pVtDL+tlEbw9YP3YEEqZCdLcNln02aA0o2qA5mwAbWExDIKvS4Nh7x1se6S8dsq871sPtyW12ZatiVTjxii3fvOkjZE3YS8+hVQTaZ9O+80bbkFBWI+RWPmdvL5W3ljAVhDCRFWE/L6l6dBuJ1UazIoqrTzo2ISpWXrvBq/OON5rdSjODc1oCP6kMMwRMC0OjB+LrHRUBy4IKW3xGwnNgGSUeUQSF0fPMOS3DOQ0CQCdMxaxiF3hU5lay5oY1bD22lfKccj7z4mfsYM+aG9ZkICWjM0LjkZ+c9+El5TNorP0rphlIyk8xCXw8XW8Fqe6c/4dhgzsny4PnTOKngvwVdHVvAgYnaa2outoOro0lP517xVTq1zdj6iJ54EYCJvqINAfwpMlP8UqWVHPyU6knEarPJn46/mitNXHoNPHTcOwEY8NPeqAowTsnfX4ykKMYLSkmEqa9jTHnJ0cAyH6fTvS0Gs36o+CnWMLPOSULR7LMyU9DsRNARErkp/xSP7fds5LmA11QHuD2Nz6Q4adxqNMe4Lnmmms4fvw4P//5z2ltbWXWrFn86le/YvLkyad71wAw5UlMnb2GLGknBQXL8funsHP/H2w4Mc0gM6Z/ld5wLl/+2zFWlb+V4MVzsmAklZazkbv5/3iEj9HJYKl2EZ18hAdP6ojPdCUESP4rKSurpq7+xzYATq84j7V3l4x6bN6U4qyU6yxdXo6/wMvLLzYgQgZlpkzrvm77+dKSLI42W9koOY0MlBQFmWTLp+ofd78HyeHkVGjMMlyxG4hTTvZ1ZqCAgc3HGNjWZq0ULTeecPdS1GK/a3ynERGsfm+1BQilB8jNnoT6pOwqK96/qYXdbyS23UX6S+0bvZbdRl5FHT1N1QCDveCGO9jmyW6laNZaywixswotu4NIf7HttRP7DOdXbeDwq3fTe2TpoKGz7qFjT4iCaRKyKhIyUKZhHa6sGq73yjQUJNmwlxVx+xTfJx1rR4o9tyqkssdjefHEV7rYisvgpA0psf1M9xQZsv0qSTouum2PJGNIjhNGWGPRLwx5aFJMDGkQXaaFJRo1gZEERIZ6r0Dinjf+jV9m/Qqa/ZTPKCC/1E9lbiWVuZU8duAxgnq0XUsPsvXY1gygZHRGaLzyU+wevKkBlsz6a0p+AivR48m/A/WNDbxnaqKXYdJLR4pLyljoTOEnb957kXvfsdnJen9TB2nSUSp+yi/186F7V7FzeytvH+9FNAcQe3sH7xMCJL+CJ3oTsHho6NuHgWCPGmGuriVU/JwoP53sCp6Tsn0j9q3c8dgp5icnO0GiOfJY8VO8d073oV4KqiVkJX1+cn7+TV1NqDgaCT8llYA5YZm9MR/DkfLTSE6PUfJTQJYwnKaYUX6aaCquKVkVEYlFIZW12RFXIEcghmEneKf8FR7Z8hwPFD1Ac1+zXaWTX+onv9Sf4adxrNMe4AH48Ic/zIc//OHTvRsuNXYMcOX96whEDDRF4rcfu5jy8mIaOwb49J8NvrHCg1cJI0k+ysquQj8e4LNLbnL1kwOYQkJO5Up7ErWcjSxjM3vFXLoopIDjzGHPuMg8gfX+1DYfYE7Vxaxa+TRdXZttAJziZ8Rgkq7mzixi7kwrq9XdFuAP923AiAgUTWL55VN5Ys9xTF0QRvBiTpirCwugKZAYxIhKRkKPGg06g0HlWmL/uFOnu5d8LF47a8UEBt46lvK98S0opuCqaQB0P9tA4J2oV4Q+eA6KiEmooQe12J9Q9jl5fohd++/AbLIA9uavrqGzMdf+gp5b5KNu1048+fsIdMwk0pdYrRMDkuL5Htp23jDYC64YCFNGipb9FsxYZ39mbbAwQZZj7xfR9XQqL/oh9c/+u53t6mvJQe9/GhE10jZ1aHunCMVjoPpMQj0aE5d2urYDEDxeSVZJg/141oS99DatdB2D02cmXgWmzPv6PPwlJ+zO1GBlcM4JKSBwGQXODkvs84jh4SNZ1ipdD52kzycuIAuo1eKuRxL0y9ax9UjCNkZUBVwe9EAQ9qlG0i92qd4rFY0l9Vfy4n/Xgy4leBLMLl/gatdaOiF1uXlGGY03nen8VFV1F0ePB/jmqu+NiJ9O5u3zTOCnuvZurohjJxg6yXUiyi/1c94VUzkv+nvTvuM88ePtmIawvHoumcK6ut1oSEQQeM4tobxP0Lyr0yp+ipOCRJsKs3RQGFt+OtlsdcLblyHngsn0vXYkwTYgppPNT56cNppb3qSvZQaRgdIEjosfLjFifjIkV7WytV4iP4V6DKZc/FtkRWDqcOjlSXhyInhyw0Pyk/Pn/mNzk1YcjYifwGYcScA1/Rp9imCv4w80PSxxcCT8lK4kho5Yp6jgadHi/mhRfpoVUnjdp9sG01cHPBSYMpN6ZRc/xT5zBaZMviklTWgLYFrLYr78xDfo9Byzq3TygiUZfhrnGhcBnvGoTQ2ddi9zxBDc/uBGXvzCxWxq6KSpt5Bvrv8aswoPMqvyfKYeD7Dv4M/sXnNJgo3NS2jomYIuZD40+2+npZ9cxjylozzTkdNMcf7UCwDw+6e4pkCcKuWX+vngN62s1GHVwCzx8qF7V/H6+iaeb+tif0M7oqOba8TgePV4fx4dkdDylSXDHN9ghiNZGfGZWEIcr1Bdd0o4AVCL/KjFfvSOAIE9jvGgsbGk0QyUtyoPsP4et/7rOWx86R1WXrqAoLnWUSkXwJDfYc6577M348mxAESIIAgvB5++13WTjzdHlsDdCy4Zg8UtScBBTtFmKSsG/pL99BxaTaS/FCO8l5zJAyhWezmKBmWLOu1SYlNPvHebhowR9rqyVaGuSanfzBTqkcUgnEgwOyQz0ZSZFVFsA73YxC1VwIUhDxBmnzfNoLOU4udRShImVRGFUlPGb0q8mhVnFi1gUcjqk/9rFLwUAe/r89jHs95vlV2/4dO5s9frArhkVXcCwczOZfbv8Z4Eqkfmt1/4E/v0dzI95BllNAYaC35qDxRzxdSX8SinZ2DFmcBPp4udACpmF/Khbw3yU0l1Pld+cQlPvVTPH+pb6djTxGJd5QpTG9x/x/U5jMBvSnbVT0zx/JQsmHPG85MJwX3Hh+Qnb0XuSeOnQKCRXfvfy4RlASaYXnx9v2T7s+7KuRPmJyU5Y8TzU07FX1GigQpZhbKFnfiKgjZPOfnJWdUjyYOvlT1xD1p2W1qj1p1y8ROwImQZMccqWbpM09XmdWnIg0ZksKpnLJXOOW3qVIUNJMlHfTKGi/ITuAu3nUrFT8laJA10FjZfhCa8ROQQf170fXp9HWzat432R/Iy/DTOlQnwpNCKqiI0RSISLZuMGMIue/VrCu2BEtoDJdQeb2ZFzr8kTIJYc+B62gMlrJ608bQEd061kgWfkz0me5fSL61g5uTlZEk7CQT8JwVQutsCNB/osrMVKZeTBZ9Yt8fqWX+plofuWM4XNx8gGM2SOCdK6Ahe8Ya5OORBjf7uvMQKBIc8BtcrHlf26dTXb50aGe3BIZ+Xs6zLS6ihJ9pLbinvCssoML6HHCCvxE/uRJXmA92UVC1Alv2uEnSnDtU/aQV3AKQQ2RP201U3eIOPN0fuPbKU3iNL8ZfsR/H2MiHqoROv4Ur/Td1DpL+Ykpq/omW301k7j3CPhqlbgALYwR0YfMz13igmuZP22b9LEmSV1NF1MPXrJlN8//TisEqPPPheO8tv80yJJsVkRkRlnyeSWJkT/+9J0MxQmBuDhYA1+ep1oduTLhCwKqAwT1fZqel26bQhWSDWJUw2eAcf1yXLXNkZ4IkP7mRNkhiI8waN9yTQwyY0+7nx3BvH+nAzyuhdqbHgp1mFB09bcOdU62zip18eOkYkSj31kkEYFQ8SBgIDy7tWR/CsP8xVAXfyLBk/nfHBnBTSW4aY3KpI+Gus9sCTwU9dXZsH2yTlEA371yEp5yIcH7fR8tNwiuen/tYim52EgOwJbq508pNdWR1nZykrOrmTt9KZxAdoKDn5SRGWEbOzTcnJT7mmxRvVEZm9HtPNSNGinqRt8ukqDe6aOXCYGyNz6FbgQU/IZidJQLEBK4NaAj/pEtRqBlmmyYAsRsRPhTM99Oy3OEkzvZT3VBPJ6Wdi73Rawses7WT4adwqE+BJoSnFWfz2Yyu5/cGN5HvamF9cR3dvPlDEQ3cs58O/3oAhcE3ZkiTY2zmdxw5eQ3ughBJ/OzlaH2FDsUHlVPvxnAqlOiZJgkM9kyjPbsWj6AgBhLeSLe3iaP1DHBEhZNnPqpVPjymkdLcF+OO/b3SNiMwv9dPYMcCr77RQocssXTSB/FK/K9MYiBj8dsMhO7gD0K0IHs4NUWHIdo9qrGInvnInW5a4y+/DI0l21imMwHO2/cHTlJLnBcBblYekydZUCEXCE81MJZsE0dMe4O2/9mLq+1A9Mjd/dQ2G/I6rBB2sDNSRlp/av5u6RnHpSrrqBrflNA2M9BfbveQ9h1ajZbdRGp1g5VSgczL+oiMpj0kIieMHVjPl4h/Y5cl5U95yBXdGq5yKLfgP7iPQPjvtdeIDOH/NCdvBnlh2JnYDj40RV+JBIj7VM5LT1bEtSZiUBlto9TsqkZwXByFYHM6lSzbtz9LHer3s0HTe8hmYErzlN1igmwmBqzxTsvc/9prJDAFdkqC0qJDGY50Iw/r7rLxhOtOXlAGw2VHBUz6jYAQHnVFGGQ2lseCnIt9xIqaCJg9+6zzb+EkI679k1aLjkZ+e2Wl5tlxdU86U4qyk/BRxjEHv1+B3+SEmRmT8JlwStAI6KhIzdcVVvZOSn07LZIDTq7yrqmw+8lbl2SPSUSV7itaJ8JPPN+jRJQSEuosoqcylraHXfnwofvKX7MM0FHuEeUzBrgn4Co6lPK7k/JTYEp96/dTLlCz4K4HOqlHxU61q8IZf51W/nlDZMiw/Yf0+6kRudHsyUBQO0e7xOp5z89OicDbdqhWYuaXPQ71q2OzUpcCk6L7G85OzXWsoQ2WBwCCCigdkQaG3gF5lkJ8+dMlNrJj9bfKCJez8W1uGn8a5MgGeIbRqejHPfmY6dXu/hEyIUOTP3PaLb7Bk2nzbD632+HRChsfOQM0pOsiMgp+zrmkl50/ejEeJoJuD4eazCU5iGuqYpuYdJWSobGxewsrybQAIEbKfj01/GEtAcZrN6WGT5gNddMuC9/zwVYK6iSrgE0/Ucde/nesa6epTZQbC7i/81y4o50MrKvjL67spFX6Ke0zE3oGk5YxFimQHcyRJ4nHCbCHCt0TWWZuFGkrH/7IPsyeEv6aE4jvm0/7gTjAEHQ/vso0B49V8oBsz+ifQwyadjbmutqyYuro2A4PnUcfem1iycgEHN+52LRcr2XX2ktev/RaqvxMpOrbcWf4b6S/GW3AEWY6a+0luoJAkQdHsVxJKkhXt/2fvPAPjOOvE/czMVvVerWJb7k2Wa3oCKU6HACEc5UJCC7mDwNH+tIMD7o4WQgk1hNCOAIlJdeL0ghM7dhT3Ksuyeu/S1pn3/2F2RztbVGxJlux58sHZ2dnd2dXuzrO/91cYF0Low1jCK1CR529ZEUZ9+kRSjcNBnOhVm8jVmchRmKqE0ZTZJnS/UONl8ETUowuiroOYFSchyXS4CiI2mKfQLPIMscepUOMIGLJxodeGW0hGmnT4uJcHbKbGf5HHjwQrfAobfTYyNDluWZYk6w9/cn/3yDZJJq8szViZDk+BGGuV2sLCYuJMhj9FBnfg7PMnSZp9/gRw97NHefYzl4zpTx+5aC7vXTuHHz/xJmqvHXHEFzqNCLxRP4ktfxqh/+k6HEUpqL0+lAwn402tHa8/eb0ji1iSBK70bhaszjcFeCC+PxkjzaMWrYUA/0A+jrQ23Z+CetRCjsgoTuRPoHvWeAK4mjr5/pQktFEzWxL5U/hPooQyeCIXoMb0J8yXNQk9uBN6UpLQEFH+tC+5gJpQ5o4ioMIvx7hT2AfD/jQsCaMUXpXgkmEbSaFMpXTN/GJLSLxRuoVkNY1VTW+L8acNqRcxuN9LWgWWP80CrADPGCRJ+5FDPySdip/ytGM8uS+LHHcnCzOPc7RnPl9/7UtcM/dZLpnzOgA2WeVtpa8Z92GTVVRNQpFF3McYi9m+auVUgvR4sw2RQ7IhISOEP27pzekS3WyusCKDZ+u6DDkJSnBSC9JS08vi8wrZetfFPLW/hbufPcqLRzpGjtsm88VNiynOcOLqT2XenEX83zffIPyNHNmDR0XQrUJQCGyShE8InsXPtcKBJJv/eGe6wfK0oelj0/uePYl7SbYxJSKyMWA0hRXpyDa97nq0lYGMjHVG+rGEi7e96za66+N/vlKKq0215DnLNyPZfDHjOCUJ0kr2Rtwy3HTOXG89nlT6REgSSIr5sn8wB0/nAn38aEpnzLjP8TLauMvI68LjMiUBVw3ZKdL0AIoXwUtJQURIHjYN2dEkPXvmoRR/7LjyOM85UkgigzuS0DjiToGIiVmqBC+7g8gCUzPl8HFHN0iMfG7h4I5+GCMHYvTI0mJlWA1opqagt3xtA4vPKxzfi2thYTFhJsOfznVmmj8B+IIab9R18+41c0b1p39ZX0ZxhpMPrkxluCuLvUdOAPp3dq8iCAQE9jj+5BeCRlSWCVuMP50TqMJYEDOPTU/sTnDq/nT5v7yH7vr4q1Sx/vSoMdIcEvuTlCDTJpE/jcej4vlTJOH+PhP1p7FGhSfyp0uHbbjQgyXNssaW5MD4/Qnix+skKfQYkf5EXH864tQSZjSH/alX1tgmIsbFB5WEjaeDUoAT2XvZcPLamOssf5p9WAGeMcjIWIckuRDCi091cLRnPjnuTv7rfH3ig0918PXXvsSWE1dwftEbMStOAH7VBmgop5jENxtjAdFf1h84fyW1/dfhHPo8iABITirmf5G8vE2TXkOenuuOiS6vl7Nw2WQjg6dMthknv9LsJLJTnPgiBOa960q489IKSrOTUFWV1sEg2148QYdQyUEv0/IjeDjZT7qQcErwQb+T7YNBHLLEwy4f35OTcctSTEBHkmK3jcWsDgoFxcgECDA1BowmLcfNynelkukoonhhVsKVAbe71Ji+5nIV09//EmpyJ9mL++hvqDKNSc9d/qjptulluxDj+CjqTQJjd4x+b4/1ZxlNXLx9BZx87qsI1Ymk+Ci7/Nsx4z4jR5WOJi5jjQX98ICTV1wBjjj097mQYEtygI8MOJmjytyf6jNqyFVJD7gsD+j13EafnNGe6ygLjPmqQqst/osengC23qOwKmCLKx+jPbfoxucJD1QCLRRkDK9MWytPFhZTx2T402xf4DoVZrI/gR68WV+uTyMdrz89U99Jeajkyo/gmF3jmF0vf3dK8IGQP6UqEovdCp+U3FFdDiNfn3PAn+KNTVekhO4EE/en9vanAbAndSOlP0v24vo4/vSIcTshIDnv2PiCMQkWtBP5U6L7G+2xNNUGCCObSAvaT8mfxhoVnq5Jcf3ppaQgHxnQS6qeDgV3YBL8KWq/fFVK6E/hzKDwIIqJPreRhxe8Vfgchf3z8Nri9Iey/GnWYQV4xsDtLuW8jU9xvHEbO5pK6PH2saFwh1E37lT8LMw8zmvNG7j7zU/y2TU/NyQl/MUkSRp2OXHX9bNFYCKfh/6vvvQgcOJ0L2MxW2keCoT29eFwZE/ZBIj0XLfpy6c0O4lnPnNJTA+eMJGpxm67YshJfdcwT+5t5kfPdeL2S3xYOI0Gyw8n+2m0a2hC4vek4LbrmTsP+n28X3Lijkg3jmaisjHr5CQREmTfuizhChSAK01mUWUBiqIk3CeM39/FwUNfBfTPY+5KyF76CCe2/heBodzQJIhAzO2m8+Uc7bG6Dm1CqLogCNVJ5/4bSJ/7Cpo/hYEmfdxkZHp07VP/RdCTDWDqZRNZL57oBK4/SNRFCY7aVJKENCIh6Bk14dUg0+rVKPd72bDNyACKRBGwxmvjyeSAISNzAtDoiNhJgjddKqsCiU9JiZ5bOKgTGeQRCDQ0FJTQ4QmkiAOz6sYtLKaeSH/6/ZsZdHo0zi+aqD8lvv9woP5sOD1G9iCJ9CdJclJasAYHj55xf4ruwRNm3P6Efq6TQs+uRxGkyBoPRPjTMTWIM447RQZpzll/0hL8yI9gvP7k9TZzvPZuhBjxo/j+NFJ2N1YwZixO5bfOaPv31p5Pz9FNpBZXIzsGUezD5CzfTO/xS/F0LjKNevf2FVK39ZuEoyfR/jSaO0lhcZkif5rrk0gVEntdsb8Tx+tPrYpGqRr/bz6mF4ae45rmK5FRCOBDlYIoQvcxy59mJ1aAZxy43aUsX1DK8gWQk97Etx7rNNJlNZwsLLmQt6+u4Gh7Cf6MC+jrfw6/902KXHrNtF3WRi3ROlvOPZHPQwh4oeUT9Aw24bINcYX6CZxKZFqnc9JTi8eiNDuJD146L2Z7fdcwb9R187tb19HY62FOht58uaaul58+uJ/DUgC/DAtUGXtEg+VMTWKt184lNhvu0OhKpyTxIYfTlKUzK1ePJglbQZJ5WoSAQOMArvkZCW/j7dc4sr111BUoj6ee7TuuGZkEEYFsC1K+4QjHXsglMJQ96QHUybyvnKVPMVB/HiAjKT7yVm3GkaJnO+Usf5SO/Tea0qMdac0EPdn0yprR9C+yoXIiIvePybSRYE7QPE3i3RGrQUYjQrvKK67YAA7ASr/M2oCdpCHJJCIrfTIb/HYyNJmUQYmDDpWlfoU0IfFbu880olSVYmvfx0Nk5o75X0F10TOkerNNY9KXXlBI1aZya/XJwmIaCPvTv2cN8+i+l8x9d3CN6U+jES7tOCuI8qdf7/sAGc4+0p0ehPgw4UUMOHP+9PFL5sdsPxV/siPxzkEHHrtgvUMx+dNyW/yx6ueqQ5kQ4NnfSeoliUdRj9ef3tp9qym4EybSn2Tb0KT6U7z7OZ37z5y/jYGG9ciOQbIWP4McMfii/sXPYU/uMvzJ11NOZHBnMv2pOCiN6U+R2T+RSAIu9znolwR7nX7DnVb5FDI0ySipivan39h9McdxusihBTE7Tt4sfAafbZjcwRLLn2YpVoBngty4upj8tOt4em8h6wrr+Z/nXTQOBIBDAPx1J+S4i/jW+b83buNT7Tx07Dr+ZdE/TqucYzaxp2MJu5oU7qp6yliti2SmnKzru4a56p5XjJWn3926jg8/sBNPQNW/+IecrMLB71P9NCoaAfSacZcsuF1zsNplQ4kI4mhCIEetMqnS9H/QNAStci8efLhxUqBlIE/3NAoZUi8poeevR0ybR/Px6CkQ4Qke0fT27kQZTCGlpwpP5lECSR2m6x2p+uXUkjdm9OfJmdbG3E1fwds90oMnjGwLYE9uN6ZVaKpMXuXfOPncQhplxdQUsNndT8ZQRuwDhJrbRDcpjmyyvDCgjDuNd4VPZp9Ti2kwuMGnS7kmYUozLlZH6r1LVYVSz8gK0+1RE7TGnIqVAIGGQEJGJtK+FGyUlOSTXu5A2SyhBvTa8apN5QAcfr1lQg0Cxzs62MLCIpbS7CSe++ylPLW/hRbxGxZmHuf/PaGMw59svNm6kvOKqhNO6wwznkk8MxEhILLVzJ6OJfT60rl12YOz3p8qo/wpXZbIUiSyNZmNbhu2URbBopvnTwczwp1AT3GSILp5y2T5k20oA3fPwoT+5M45Qn7V36bcn07n/iVZpfTSH8T0+5EkyF35ED1HLzf8yZl5HEnxIVQnTXa/yZ9akvrIGMyM8wC6KI3mTwsCMpmaMqY/patSTHNmScDNoWBQoz1ocqciVWZ5REZztD+9d9DB31P8hjstDIyd8Q7mSVkqwZDD2dBQjQAPwOKsJdjP6ybNm0PgQcufZiNWgOcUKMpws7x0KY2D82kcOBxz/cLM4zgislUeqbkGbzBpXM1ZZ8h5e8I0DeaR6+7BoQQQAirzDrEs50jC0jRN80769IfxEF5tWl+eRWl2Ek/tbzGN+fzH7ibjcrgr/XrVxne8LvYJDY8kSJckLku1Y4vqq7NV81PggZVJdpOsRI9Tn2pOyO1stx9lSBqZtpEsnGwMLGSuljdtxyGnO+jdfMy8MTTmMxHRUyBaanpxpHTQ27vTNOozVVRS/vq3kVUnmuyj7vyvmiXFXos75wiZ81+Z7Kc16TjTOnGmdca9LrPiFWOVWlY0XOmtzL3qG9ibK3mu7loCKDhkP8U+V8xtVYLImoJEbJqwBFzkUciTu0nVctBtMj6m1SswDFMBLhy2mZr2jdWsMJIMTeYSn4NVgdhSs4kgoyDQcOdLeCImtKpSkNcGXibrrXy+ePvluD1pRlpxvDHAo5FodLCFhcX4Kc1O4urlhbxR5+Rgb+E4/elaBgMpnF9cbdovnj/NxuAOQE1vGaVpLcY0sZnoT9HuBPDa3lbmDUGjItFHYn/6b6+bPUJFkYXhTqoQKBGLYW9oftZKdmOB7EwwU9wJwF6UQqB1GFMTnmn0p6xFDbPi90iiZs5JOXW4s+8z/MmV3s7cq76Bp3MBqSkdPFt9Z8iffJx/0d0MvvIpU4+eIAEUYQv5kxTjTxd4JArlPlK1LCBxcKVHVnkg1W/2p4hMn3BZ1UTcCfSAz+3jWJSLeb2QkLGhEkTBRgAfJ5fsolSbj3xk5Pkf7j7E4V3bKR1axBdv/6zlT7MQK8AzQSJXLFw2GadNNjWXA/PoT79qR0LQ6ckamYIQYjZ8eY4HIeBk3xwer93Ex1f+CSnU6d0uawQ0WZcUyUlZya3UNzyAEL4pmf4wFvFWm3707FHjeqdN5p2VxTxS3YRP1ZsxL9ZkLkvVV5nOF4IXg0EKbZIpuAPgQfC47OfupOSYsiwRyiGfjlW3E3I7z9v3xWwfwsfz9n28PbBi2kRF86gQGPlsOOamkby+EF9dP8CYU7RkRcKR1sn2He9D0zzIspuNG7bgdpcitaQgh3rXyJoTV89Ck6Co8mFKLjmS8OQ/UxlPA0JHSifl817hM95UOrObKBxKw7/7vTH3pUR8vWdoMhd4bMa4TE2CZE1mrk8faz5ayrJp9QqMVSZVgiQhGZMawqIxnkygSMZTHz4WEjKeNvPaZnNKDdce/gQ2zcHrtY28/z/PJz3XzVvPnIwZAzyWbMQbHWwJioXFxLD8KRYhoGM4m+cbLknoT7LsomTOv54xf4p2p613XUy6JtG7uZ5rAg78CB7MCozqTxuFjcMe1XAnRZKMqVleBCtlOzISASGQwNhvukrcZ5I7AQQ7PRDx2XCtyCFl4/T5U3LBFD/BaSDanxwpnThSOkkNOvhMwSt0ZjexMPM4uUldqFHTtxRsRgZZhqbE+FOKZqPclw+M7k9NikjoT/2yoFdMvzvp2c767ezCSUOwjlZfK+fzDmOfrKFC3rvnS5Y/zWKsAM8EeaOu21ihSLG389mLh3GlrKEoa75Rf/w/Tx3i6699iaq8PbyjYgs3L3oMn+rgx9UfpzztJO+seBK7opp+zM3m0ixJgvOLq1lXuAcpaqT0M3Vvo9NbwH/e9C/ML1pEcfEtMasJU004NXCnzxOTrRM5+vOzVyxk4/xsNt+6gZ///E2KfBKlimKIhk2SKLRLLHaNROsDQnAfXl6Uglwm7DjiNAGcrnRqDcF2eyhgFf2QobTQ7fajlPlypyfl2GvOLfaf6Md/QpcTFImc25bH9OJJy3Gz6Kpkjjw9jKYKtm95jPw1ep8dTfMYq5bO8jSwyRDUUNHwpNfEPLw+BWt2MZ4Szt6aixnuWMiCDb9jkaLiH8zhxL53GM2aE7EwqJjGZUauEEUGccIrr/GycvSDgMixnPHkZvkozZInE/PkLPP2koHFI5eDEi01vQDsePyEsV2xS+NqFhhvdLCFhcXECPtTeEz621deSXpqOXMy3DT2eqhpH+CXLxPXn35S/XGWZB9iU/kL2GRtQuOVZzJj+VO3r5CvvfN9Z9SfHn2h1uROb9R1s9yvoIYWcBxI3H3Zkhh/KovyJ4eEqTfhtmE/ryVppEoS/4aehWqP+mNOhz/NOHcCRJQ/eQ924j3UrQd9JtGfNNmHN/NozOdIHl/Fz6winj8BaKpCYCjbtG/0ZM5ofyqZBH9K06Qz5k5hgrKflKGs0LEHsAk7AsHcvhXGPpY/zU6sAM8ECU8LSLa16aM+hR95yM2q5VvYOF8/4d52wVw+/dc+BgMpRmNhp+In293Nif4ybFGjQFUh0TyQR0laW8zjzVS0qJpxIDT9Qp/8APp4+FeazqfTk8NbLcnML9IbLk5nWnFkauCAE1yp+qhPt13hnZXFPLa7GYdXYx42Li7Sa3BTs1xcdMN8gnWDvPlWG6uFLilBoXfRj8zeOeJVSQrIXGKz81H3yA/sRKtOU7ka1Sr3mlKLY5D01ahWuZciLU698RQhpznQ+qP6CKiCzvv2kfORFTGS4h/UjHGMg60VFOBC4DWtWg5p8MJAgGx7P8kX/y9qyuz57JwOkgTp818lY/42pND3iCOlk7lXfYOhtiV0HbzWmLIVzWh9dkZLD45ssoyAAlWmXxbGfey3BxPKzVQjIRmpxqAHdjypvSQNmN/fkk1QWJFBS02v8aMEYP3188a1khRvdLCFhcXEWF+exZzUHr68Xh+TLomHOW/pU7jd+ndWfdcwv9tWR6cnJ8afytJOcmXZy9iiypY0ISMJbdTyrNkQBNL9SSHcdCXSn647w/7UHwxiT4WABG67wvryLNI1CcUuowY0FLvM8so86ruGOdQ/zM0fWMYv/ryP4aCgMsKf/GIkYCNJEqkoFA2AbAfhGgn8hK+fLmaqO5lQwSjXmiR/Ks7bh33VnwkkdZyJLkPTTjx/ApAVlZKLf2KaUgqgoRpuEe1P6RETIk7Vn0YLDE0H7e56sjyFrGm+EtDL+nvyG8hsMzfxtvxpdmIFeCZIaXYST9wxlyPHt+AM6D9aIyPj9V3DfGmznuZ5vHc+qnCiSD5U4eRoz3yumftsTNqgIglTcGe8MnImpSWoKQgETmXkw64fjwbYyMz9EJ96rIxOT6YhBGeCyNTAVB/84voldGXajDryzR9azws/3gNBwSs/3Qv/vpKb/vAG2cOC9ww5KEThhWCAHEWmU9WQkFgcSisOCkFLQJChyawQUkxPnunGwyiCcgr7TRYxwZ0wAjrv30/BZ9eY0o1TC2xGtF8E8lm+6B+o8j7TqmXD0QNIBf9kMLUFV1RwZzbI/Okgy4Lozot66vGreDor6D95foJbilBKrwRRq1NhCWlQNEripAdnaDLrfRHbIh5+orXj4yGy5MvjriN/qMzUADCSyFI0CckU3AngY3f5c3zpljsNqQi/t2SbRF5ZWtz79HjqY1bKo0cHW1hYTIzS7CTuvamPzhb9nCBE4l4ykf7kUx0IJFNvHsOfogI+M723oRDg1xScUVncAAKZ8tKPMBhI5t82p88Yf8pA5tYBJ2mXFHDj5fOMEei/S/WS44VOF1T2DxsNlstVmXcOO7AhjepPXap+TirRpHGNQJ+qBbKZ6k4xjKyfToo/dWcdJyuqwfK56E+gTylNyjti8qdItxCGP8mokkqQAHb0Rd2wP51UApSp9gn501S6U4Ym02/vIjWQFTfTOddTYtquYCOtrdCIM1v+NLuxAjwTxOOpp/7ou3BGjGeWZTfDYjkPvdlI16DPSGVtG85hMO0BzpvTwK+2p9LpCbC9ZS0XF78+6heoKmRsUvzmemHiZdBMJrHiYc5cdSgqu1qrWFsw0vhwZP8gjYP5/OCWq2ns9Zia8k030amBVavyTV8yUqcPgvpqR9Cv8fBjR3F4Nd4z5DSaI3s0ie0EKdb0H5gvDgTJUiS6VcFw6M/UqWpGPbkqBBqxqcYwtYEfN6OX6Ex0v6nAtTIb796ukQ2qoP+lBtIuLTEkxZUmc/NX1tJWOxAR7V9o3MTjqafd/yGKNvjijsiVJBBa4uZ7ZxORn1NNtaE4B7And5hqyUeQjH/7HJ2k+83NGtM1iWMFz2JvPx+09HEfw3gncI2X6JKvDw7MSRjcGQu7zcGXbrmTxeXzAF0yrr1zFY//ZDdaUPDkvXtiGv55PPVs33FNTN8CCwuL08Pjqaer9V7jsiy7yMhYZzTw7Rr0GT15wv5kC+7lv57Rp/S9s2KLKcgTj5ngT9FE+pMkwSM111Gc0s6Fxa+b9pMIMBhIpmb4Rn5wi3tG+VOOzcYtb5tPeug8/UZdN22aSpsD0gMSjz16DIdXw4HEOwccJn86qWlGadOLA0GyFYmuCH/qUsUZ9afZ4E4ASWvzGX4jcpKA5U+nw0T8KTIQ0uNqIcczx3R9uiYxUPI4ouUi8OeP6/Gn2p1uHXCQGchGEM4OTPycwijY9C9IJMufZjlWgGeC9PbuRIsI7hQV3owj/Vau+8WJmMaBbrvC2nnLKcxeT1XJTo42PM7Rnvn8at+H+MjyP2KTY79dhSAmBTkemtCFYariBTErYFHXB4WDC1Z+FG/7Z5Dwmq4LaAr/9Ywdl+0pfnmzQm7SBcDUfMCjR+9FXx4rNTAly4WkgAhF1FOPDbHCIcdMvmqwaeT6ZRxIDGswrJn/dh5NMomLJmm8PcUR04x5KinQMkgWTobwxf7BAAQkh8Z+nim8+7titg3vbMOzu4P8u6qQMhyAXkuemZ8S9z7a259GCH0lLdHLezbKiRCAJiEpAi2oIMkCKfK7QgqSX/kQucsf5cTWbxIYyjV6VEST7s+J6V8jIbGm+UrqMg4wr3dlzErQaExGo+Qw0WnLrYpMToKvxEQ9eAyCErS4oXxk02C310hhj9fwL/I7PjI708LC4vTo7d1pfHcDzJv7aTqGc+I2Xg77EyzH8dxDlKfX8KPqT7A8+xBXhfrwRDNefwpVW09bpkLkwwgBBdmruWLlKoab3xfjT7959QRP1u5hTmrPtPoTEONJo/nT+vIs8mWFkmG40GvHPjDMrTjZ5grE+FNk35p4/jQcKhnKUWS6VIFT1rgo2TFtmdCzwZ0AhnfFlqJb/jQ+JuxPw7kgC70bchQ5njlx/en8k+/kWHY1mV35Y/pT+PZT6U5NiiBTA2miC2Qi4k4sf5q1WAGeCZKRsQ5ZdhvRyfLyO3jyoGxk7XiDGv/v6sVkpziNlRePp56k/lu5fbkXn+rg6699ia9s+xpr8nbzrgVPokTUgkqSHiCxy7EphJHYTvP74HTTMJuD7+e3j7azNOsqMpzDbJr7CkL4ENi5+81PAPDl9d+hrcFPR9PURHGjR+9de+cqnrx3T8wovnipgfVdw7z6WgN9TzUhIqdQIrHeb8ePwBH68hYITtg1ClWVJcJmWn1KkjFdHtYESTLkygp9QY1s+8gX61RPg5CR2BhYqE+CiE65CvnUxsDCaWsSGJdEP9QDGr66flyViUeAhhn21Me/j7M8tXigcQUpRQeQ0MVEigwQi5ERwbItQEpxNT1Hr6J0WRYn93fHvb94gREZhbLepXTLKr8PjfaMngox1USXfBXHEawwEhKqFEQRNsJvek0KAhqycMRt6DdWw7/o7/jpnvZnYXG2Ev3ZysvbxJMHu8f0p29e8L/I+Ax/eqXpfC4qfo1r5r6AHJGtM15/Uk7jq0wIUMWpO5gkwbz0k/z6+eM0D36UhZkN3LRgC0L4ETjZ0bKCHHcnX17/v9PmT4pdL9tVA7FjjKP9KZxtNU9T+Ndeh8mfHEhkqFKMP4XPNdG+ZL4s0RDyp1K7LcaVptKfZoU7geVPp8FgyyJSCvRG2jH+RHx/KlqWSvPewbj3l8if5ndVjsufRl2YOkVOr1xef+OrUgDQUITT8qdZjhXgmSBudykbN2wx1ReuLx/GbVeMEZJXLy80pdT29u40Vmmcip+Fmcd5rXkDzzdcTuNgOZ9afa/ReNmn2lDTf8jz+5/kqrJnjBV4EfEDLpqJfjGH91c1GQ0N+wRFJahJyI6lfHn9V3Aqfnyqg37XF1iUcRTJfRUNL3q5uGirMdJ0qqK40aP3jr3ROq5RfPVdw7znh6/w/m47StwURYkTSpAKVf94SEgUqBILhWKM/AwKwfbBIBtTRi6/OKCPUAzvo0WlTniCgiT71J5B52p5vD2wgu32o/pqVIhknGwMLJzWMZ+AMYEiIaFaX8ku65MdIoiu4/V46mlqepDm5r/Gf6izTE40zfyZT52zb6R/V3T2X9Rz1/xuFMcgDYc0wuMwA/ixYR8RiwR/GwUbzUps4+RwU0EpjrifLvH6ASVa/YrcNyj52brsPr608C56er6LOpSOK/sYkgTDnYtYf8knYr4DwqvSJw8eJyn3GI6UDiJXyON9x1tYWJw+p+pPcuhcFulPj9fewNGepfH9ad8TXFX+7JT4E+jBnVP1J1WTKLb/mQ8u8RsBq7evupTFaa8hua9i6Az4kxoQhE8GY7nTVfe8gsOrcfuAM64/rQjY2OUIstGvl9XpjfAFqbI0IX+KDugMBwXJU+hPM86dxoPlTwmJ9qeUwiOJ/Sn6tn43iqufnY57KU59BwwUE5D8yEgowh7ei7BbRWLDntCfpiKoE8mplHxJssSaa7NoHfyq5U9nGVaA5xSInmRQmp3E1rsu5o267rj10pERTZ/q4GjPfOyKxEcunMcvXob79r+fjy7/E4qs4bQp9El5NA3mmpoxh/9f1WB3x3Kq8vaf8ojQyOaEpiSAOPcV04tHQLf8cZZmvk5/ty4gTsWP0/Ndmj0BZPlx/nH7z2is3RrxeM4pieJGR5IXrC/g6M4243JKlottz56kwaZy/soC4+/yRl03OV7iykmYflkjqApsSAQRlARk8hTZNPJzkdt8udQhMaSOTNmSo15MbZpOoHO1PMp8ubTKvXjw4Q6lFp+J1SfXihy8eztjttvnpJByQTHO0lR8df04y9OwZbtR1dAoVk89O3ddb6wCVK66j7d232ZK79eR0SMVo6/YzkZk2fz5G+/n3NtXQF/dhUTLR2P6EdPoy5qsXczvWhNXOuKtBElI9Nm7SA1kIiOftqxEBmoi7yvczDBaiFy5KsczHqde7mH90Q/qWTsSfPGiW8mU/0rAdhAiSucdKZ0cq38DzfZZ8vI2ARjS4UiBLnELHa0eGtpjV8ine1qNhcW5wrT401BeQn8C2WjMHNQmnolzuv40JF9KGi8CujttKNxH+vBTNA95z5g/RWfwjOZOnoDKPFVJ6E+2UAP/ICP+tM8eZINim5A/xWTwTIO+zCR3AuIvwkjgXJhJ6sVzsGU4T9OfxlqBm71Mhj/NeesjzLnim/zj5FyaJA/XHPp4KKYWNBlQ9GJXIn8asPWQHEybcE/BiSymhUu+RNTfNSkbPD0CEfVD5KL35ULGr0jpSOxPaWkr8XqbjICNI6XD8qdZgBXgmSRKs5MSNsLrGM6hJ/l+FmYcx51cxZeyko2pCI/seoPbl/95ZBKE8JHrOMSJvgp8qsNYxQmjyLAq9xC/2vchlmQd41D3Am5b9n84lKCxz0SCPpH71Q8UUZbWnPB6IeCpE1dxzbz7jeCOvpMdhN74UNM8CM9WpIgVkPnz7pqSD3u8+vDw5ZQsF0/8bA9qQMOP4D3PHuXv/3ExpdlJ5CKTgkQAgT3Bl2amOlK1qgAVqo0uIQgIgV3SBSbXZv6SrnAqvD4YNJoFakLEBHmmCxlp0sZ5nk6mRrB9OO72QOMgvZuPkX9XFclrYhvSdXRsNdXxtrY+GkdOoKz0ozgcORyr+c4pHd9MZ6Jvn4GmFfTWXkZ0cEdSBF73APSNbBMi8YpSopWg9ED8EeynQqLHlpAYsveSHMgwbbelvMLbVz9J26Er6RH6qcumOWh/7Um6nD24c3JwpHSaMuyFCFBz/LvUnvgxQgiE8CHLbubN/ZTp/VVT833c7hLs9gzy8jaN+n0Vb0KEhYXFqTPZ/lTbNz+hPwU1eLL2coYCSZzoL+MzVb+YFH+Kd5v4/vTCyDacfPSiuXS16BneZ9KfgDHdaVlaEpVBG52SNqo/pWlmf1odsGNTIeCc+f40me4Ep5npGi/2IsBX00vmDfOxZbtNE7TCjNefiopuobn5IWD0xuWzlYm8fYbaFuHpmounayFhfxKqE2/zavJkH+pQAXahN9lWon46R/99E/lTavBU3lcaUpxModE4kbGf0t4lKBGBJGHfg9BWxex7eP+vUMbwpzDhpsnRfXYOHvwixcXvQ4jAqF5kudP0cha20ppZhFNaP/twB+/5QyZ2ZwnvXjOH3KROxOCf+J8rtkXVi9v5f08otAxl89O3PsHO1tUEoyKuNlnFLqv84eD72Nm6lr8fu95opCoEPFZ7JT7VbuzvV234Q+VGkftFIgSUpTXHbcgK4Epew2DSV3nPaoARacrLvYaqygeQZf0kI8tuCgpuNF0Or55PBem5bhafV2iqF198XiGD3V7UgC59DiRyvPDU/hYOHevmrd8c4uJh/fWptvtR45xFyzVbTHbBsAa/9vh4DH/cE7YiSSTJEtsHgzT6Vep8KmrEC5pikxGJXuAZzOlkagRb4wd4YKRuPBpVa6Pu5E9HHl9yUFBwI5IUPcHCcVYHd8ZL5Gc6Of8g+av/D0kJyZwUBAIIVWJJ+/mghHZWNA4WbCMgh6UvlJ4v+Y2VnwxNZnlAmbbeO2EEgreKnkONkk6Hcxj/YA49B24wtmmSn47919Lyxm2c2PoN/IM5cd+vmuY1BFfTPPT07CByfaO9Ywsn639FzfHvsn3HJk6e/DWeOL0KwhMiDh76Att3XBN3HwsLi8nhVP2pdSiHH1d/nB0t8fxJo204n60nL+doz4LT8qdEPhWN2Z9GvtfKS29lUfn1M8KfErlTyTC8/MwJGo/08PJP9nLFoJ13DTl4KNnP6474/lQYlE/JnzIUicNelSPeIMe8lj8lRBVx3Qkm5k/JSfM4W4M74yHy7ZSUd4Sshc+Z/ElS/HTsv4HSAx9gQ/21CCUUSFY0AkQGzOL5k8SycfhTdKZNNI70k1H7CNO/wai/n0qQlrQaU3AHAuQs3ooUFfAerz8Z+2se2tufZmjoOJH+1Nv3BgcOfoaDh77A69uvpKdne8xtLXeafqwMnkkg3HQuXnpxOKUVwBNQufelGj52npP6ozehad6oe7LTn/x9Ggdkctyd/PvqX+JU/GhCIaCpRq23ENDt0VewctydvHfhI6Y0xAznAG8M/oSypDd4vbab6nY9arsw8zidnixy3N0syKjj4jnbjEeOvL0QEpI08oUiyy7ml30A36EvMOQxf5mkpa0gM3MjGzdsob39aQBcrqIzXoNZWJGBYpeNVahGRePuZ4+izS8yVp3sSCiSHDfVONGXXEpQ4i/CxxWSHTd67biELidBoXE47SA3B1cYacZqlJBM11SIM4m/KBlH89CY+8WrGwdQg4dMnw0hNFyuIs7b+DTt7U8TCPQa1x2r+Z9JOeaZTKIV5fB2UymCTcWR0smci35M46ufQ6gRX/GaXm+98ab5JC1U+d0/G/nbqu8yZ2Ahty7/EG3HB7ElQf+OyAeLfWCVAPqcufG+l6O7VpoZTG4gZagk4hElNjRcT+vyP1B84F8hlK3TffRyFMcwaCOi2pi9j9LONfqjqE48nQtwpMSWBIIuukLogtPV/VJoq0x050pN81Fz/Lscr72H+fPuMmX0WBMiLCwml6nyp09X/RKnEkAVNgJa0ORPXSZ/+keMPz1c/11s/pcQSDH+tLFwF5fMed3YH2SkiEbPmpCQTf7kTuhPdnuG0bNipvhTpDsFEFzotdP/chuP/7PdmJ7jQCJdSPTYQPHHfrdnJFg7HsufFiVJ2FGM/jvnoj+Nh0TuBJY/RRPjTyEdid6u+1MQR0onc6/6BtsblqEOZFBYd52+gyazr/gFPnTh+8ie6+aO5+6gqH0RycE0riq/Eo9tEFmW6XkpfKfxDSmIHxkbcugzMrpHCfx9RVH7jNx/oHAnfc4ucuo2RdxC0JFSjyb7kTV9qhqyQHH3kLPsUTr2vsfYdyL+pL9GTo7X/sjwqHglfkIEeGv3rayufMBU1mW50/RjBXhOk/AKU7hB4Na7LjZJyvryLKOBIMBfdzbQ1rqTDy4xy0lR4c2Ul9/BnuZkYDsLM48b6cWypCLEyA8RSYLStHpyk3pIsvWbxq0LAe1DRfzbeV24k9/Dt1+qIXROptOTw/XLNK6oSGFOipOejm0RRzBy/0FN5pmTl3JF2cs4lCCapnHw0BcQwiwnsuwyrS7VnvgJmuah9sRP2LhhC4WF7zr1F/Y0Sc91c8mnVvLHx4/yZEs3fYqAoEDKcxqpxX4EJxWV5SSuJ48mQ5PZNODgfpuPVZJC2NeSXEP8buFPWeIrxday0thfidMs8GxGCMGeo71UJdtQIp5z5nsXofb7kAD7nFTUXp9RNx6NYluCJNkj3m9Bent3Ulj4LsrKPmasBIRPFtONhsxhltBLJhn0sJhDyInGW0wC0Wn+gy2LyCqWCXAozt7651j1FCHiTFAQGiSlOlhcXsg/sv/B9kNv0l8tOProIHbhICj7EZLPSEU23RZBffYuMpemkvLqAsY/enOU974UZMm6v9DwyqdNgRu75qRYTSO1uJqBxvX6Rs2J6ktmJGAkyJ+zG7m3Uh97qvhw59QmfKic1I/TdiJA0PlQhMRoUe+1iOcrfKHyrp8YNebWhAgLi8ljqvxpTd5unIr+mVakIPs6llKZdxAw+1Ouu8XUg0cION67iE9c0sv/e2INjQMjJRVhf1o3PwDenUC4rEtDV2n9sipkVCGwyxpgZ8ni/55V/pSe6+Z9X9/AP19r5K2aLjKP6Vm4miqQFQlNFcaiWaqmN1CO9CcNYepZIxB0oJKHbVR/OlL0Mrd13giMBHLONX/ShJ6roUQ937Rr5xJsH8Y5LwM0kdCdwPKnaGL8qW0RNrsPd3ZdnL11f7Kn9vNy+g6K+95OYcS1g0o/nSU1XFB+I394731s21FN18PJtDYHCcgSWxb/kmvkj2PXYv1JI8iJ/Ncpa9+ALGSjdE9DM4I9cY4eiL2vMPk5dSwqqab25Nsh1PzZhp35aga5yx6la18omKM58HQuIHVONZ0HbkCoTlB8JM17FblvNVpADvnTsYSPlep4N57OhQzLv47wp/jZR+EgjxABo6zLcqfpxwrwnCbRK0xv1HXHrELddfkC9jb28eS+FgD2d85F4DTqrCXJSXn5HbjdpTT2NgLQ6ckiqElG8EaRNWP8p1+1846KLTiVAAIHkcEZSYL3LHqMtoaHkWU3P3rX7/jUQ+2Avlr1jjnfA4+XPp/LWNGWZRfJGdcx0P0QAHZFJcfdHVGX7jelMkqSnfnzPjsjV7bDq4FzMtx8+A879b9N6HeoXZGoXJxL+sI8XvpnA48dauaGfodJTgIIGmwqZcHEQZ8MTSbDD10R295KPkCTuwVV8eOXAjhCX7bnkpyALmZpisQLA0Eursol3a2QsrEI1/yMcd+HIuezcsVv2bvvduMEEXkyiHyvTTc72cAfuI1uaWQcaZbo5EPczzp2TOljh1ecUouOEEiQ1VtW+lGSk+cjL6jkkbcaQlNSwhNSZGS7xAH7TpIHVpPmzaH7TxkE/RrhggSb5uBE+j5smoM5AwtNK0cSEsuTJAa3LUJEfTbi9xlQ0T984YCMeeqEQFC0/rck5x1j3qZvMNBYRcf+G/RAj+yDIzcyoDmM20uKD9kxROQKVrlDwn3lV/F0Lsadczjh6pN/MId/PrwIoTqRlOXMveoboX1tLF3yPTo6nsVmT8duS6O+4QFTv4JwWrLDkU1Gxroznp1oYXG2MFX+lGw3lwa3DRfjU2twKn6TP2lRQeoB6TJuX/Eg/i4v/3W+iz3en/Hjl/X7MvzJ60WWnWgaQBBZdpOcce2IP5lKxgL09LxuCu7MFn/63K7jOLwaH8apZz3bJDb862I8vX72+T04/nmCd/Xo/hT+hg8i2OL2c43HgS2iRCs34nVO5E+H0nfx/q6rcQqHsV0VIibYcTYjAW8OBVEkiSUXFZGtSCRV5ln+NAkY/lRwJOE+YX8ats1hqPnfOJG9l/O7zsPl6sfrTaUp7zDd3tU0DDSQ5s2h5x9pRp2XXXOSO1jK3oKXyRsoo3igwtRMWcZGpd3NQOj9LYWakcvICfxJLxETQoQWv4LU5bxFWeda47bJ2SdwpHRScsmPaHj5MyDsSIqPa+ceQvNm0iUFjG3JucewJ+vZ3f0nN5JWtp3Fecfw5/wnns6KMf1p19ZLQ/70DZM/Laj4Ih0dz5KRsZaT9b9BiIApwBjpT5Wr7jNl9VhMLVaA5zSJXGFy2xWj+R+YV6ecNhmXTcYb1BgK5jN38T+wBV4GMJ3o15dnMSe1h7uqfmXKzJEkF23Kt3h+/x7ctn5uXvSYvj3UDyf85RXUFGzyyAdrXXE9D370Uv6xu4nrKjrxd4Wb+XmpmP9FHI5shsVy7n7iN9xUMfK8Oj3ZRpNCSXIiSRKa5kWS7KyufIDMzI2m12EmRGcjX2+7IhFQBemqxBxVpsUu6FY1PvzATrbedTF3fHgVK5/NYPfDx2Pu56WkIKs9gtUBe5xHiU9h/zxsqoNWRxd/ytrCbV0jK1FhSdFC6chne8BngUvhlfRqNm7YhNufiS3DSbDLY0x7aBlqoW7/EcqXL6KkdJ7pth5PPX7/S7hcN3Hexmfi/pB2uYoTZl1MJTvZwD18PmZ7N1ncw+e5i+9PqaTEe9tkZ11KV/ergIokOSkuvsV4rW75WhEnDx6npf9ONOHF07mUP0oN1Bxow3XExQ9zf2SMyQ0jEMakrXDd94h8CGT7QMwUBoiXZiwABUkOkrPib3pasLDH3EYNZQrZkzvJXvwMqXOq8XQuwNdXQPeRa4w9XZm15K56KOK+9eOxJXXiSOnEkfLPUV87T+cCfdWKyFTkbsrLPmasrodXmoqLb6Gp6UFO1v/KuH04LTm8z5nMTrSwOFuYKn+6vOxl435k2cnHN32Gl45+gJf3PWvyJzli+qJftfH8iXTeWaE7khBebqns5ryF8fzJN6o/hRfjJMlFQcGNtLY9jqZ5Zp0/eRT4XaqPMk3mpKzxs8f2sPWui7kgO4mSoELdUw3ASMhdkSQ6HYJ9waDJn8Yq5y3sn8erygB/zHmcj3SMfLce96rMcylxx6aHOZsW0SRJoirZxv3OahYsKcTpzxi3P3k89XR370DVksnMvGoMf1IQYnonj85Ef0pNXcnAwCEgEONPm2/YzFtNz5Ky8FsI4UPDjr3Nxd1v3s3P9/ycH+b+yChZBFClIOvqr8YekXFjCtzIPuwpbeZjiupTNXJFgMzlj5BSXA3eTBpe+Qxodsq7KyHiNv7hXJI5pi+SXf11PJ0LjCyc+lc/rTuXFCBzwXMABIZyaHz10wjVSX/9hlCgphVHSuuor91o/lRz/HsIEaB/YJ9RliVJdg4c/Ixx+2h/soI704MV4DlNRhvxGbk65Qtq/L+rF5Od4ozYb1Hc+/vlzQptDSPNsHz2a1k0/066W5J5pclJjruTGyueNk2IkCR4ufE8tres5QvrfoOE1xCFwsJsNs7PxuPJYPuO7xsSERajh95sZEfLCq6b+wQOJYCGgwtX3c6i4s+SJO03ZGO0VetwHfl0rmxH1+5Hvt4BVZCNzAcGHDhC5VgPpProQ18lBKjzRtfw6315rh20kxXVGK3f2UlLWi2F/fNI8+XE3C7Nl8Nte7+MlNpKAM0I6gSF4K2hoFGyNBubBE4UWZKQ0uuw/18jPaIjNIdWL5ETNvCrfuaKFLyv1tJwB4akRI723Lnrd1Suui/mvnt6thupn9M54lND5g/cpl+INgVJBqHxB25jDTunNN3Y9LCSg+6e19GDO3ZWV95v+tyl57pJL3+Npj3e0In/IJm+fhi2kSyGGfR9CUn5CkJ1ItvAMd+P98jI6mmkfLhzjpKz/BGGu+fGPZZIkdFQjZUrodmwBS+OCe4AaLKPjHlZoI30sNCDNZ10Hb7StK+3Zx6Nr36anGWPEZnBExzOAWLTiv2DOYbsOFI6ceccQ1J8oRWocCqyRt3Jn48cT2gaxLx5nyY5eb75+YVqzsOr6zD696GFhcXYTJ0/jQT/B+0fxu4sIT01mVea1sf1J4BHaq7hzfaVvKPi6dP2J0/q95iTNcj8OReMy41moj/ZZImgJuhTBHuVUDAglGXV3Ovh66/X8AF0vwojCVg9rLAsMPLTYix3ghF/Sk7pJoCKHQVVCNqDgvA3sQZIcSZrnS3BnTDKKfiTuezKicezBEWJLaEe8afxB3cmMlUuETPRnwAGBvYiyy7mzf1szPTMktQSNHeQmlA2r0yAEptEqz/WnyQF0qtUBneay6kkJAqWK6jyQ6TOeQNVSHQeuQpZmH96CwSqFMAmHGhSgKOrf8a+pFoYhA8FLgAt5E+aHU0KIAs7QvGRsaAMAq8DwnAngJ4T5xkBGYSd7sPX0nPscnKWPRYnUBObtXOq/lRb+2Pmzfs0Xm+T+flZ/nRGsAI8k0CiEZ/Rq1NXLy9MOAoU4HjzEQ7WPUZxqp41I4QPn+rg66+uYeiZE/zu1nW47Qqdnhy+/tqXqMrbY6Qa+1QHW05cEVrd2mwEZtzuUtNoungSsb48i6FgPl977f+xoXAfH71oLheWF4SuH5GosT6IbnfptH1Y49XuR7/e/7GslJ6X9Mi0A4kFAZkDLpiT4eaKH71MxbDENThi7jtfU0iSIVuR6FIFrfZO/rbquwQVPzbVwc17vmgSFYEgWZa4zJmDLZCn/9iVJFShsX1QJUmWjDTjs01G4hEM9SJwhfu4BEdO2FIQnKHX3CWcdDx3nMIbC7Flu2PS1KNreIGI4A5MV3AH4DBLTGnFMUgy3eRwWCxhKQem/Hgy0jeQlDyP5ua/AHrNc/RJ1eOp59DeP3Ji6zeME3Nw/feBDhYlKTiTW5h71TfwdC5g+fp3kp9/DX/5r+2oUfVfih2KNvwZe3IzuHpo23cDNuGMqCEPsnvuP7giVUJGoGScoPGfn8amObE5ZFZdsp6WQyeMHjuSopG17GHS51Qja2a5MNKo51TTuf9GhDby+RSqE293mZ62rDoS1oz7B3NMzzmcThx+rmFpiUdv3xtUv/V+yss+aWSJRWYwyrIbl6uY17dvQggfkuTkvI1PW5JiYXGKTIY/eTz1HG/cxrHuFOaldZv86ZvP5TH09Cv87tZ12BXJ5E83L3oKCT8+1cGb7ZWT6E+rTN8J43GjmeZPt64q5pXXmuiTBOlColHR8Ltk5mS4+cBvtxMEHkj1cZHXxpKIgM7KgI1UWSJbkTipdPO3lYndCaL8KZhnyhzNsI24U3Sp1tmUuRPJRPypYddRSkrnRZVd+ejoeIa6kz81gpHx/Wl8TMZLPNP8ye2ei8dzAtCrGRyO7JjPnsdTT03tj4zLQQ36hR0Qif1pt9mfJAUqL87nZNfzCOHDr8HLy+/lon2fxIYdFR9NOfspXWejQvo7vs55KFnHeHhwkC5VxmVzMb/qbRzYNRJcKbr2CLTuIinnGFIg1mOEgOTcY4YnGdvVsH9FB2rMWP509mAFeKaQ0VanojnefISjB24kSQnQ4wVwMOz8BN98Lo9OTw6g0tjrYetdF/PM3l28sn8H1e2rONhdxS9vVnAnV/GlrOSY1a3IyH6i8oLwce6q3U/G4PfoavGyve0XMzqVLl7t/rvXzDFe7zkZbj79253cgt1YYbrM7+DyjUW8dLQdX1CjUdEzexxR6ZFJMlyWasMWysD5rb2JYGi1L6j4aUmrJa1j5GQlocuMTTJ3xVckmQxFo1cVhoyEfxQnqrkNy82UjNacRKKP33h+QvBs5naOuk/ilXy6pMRZgXIKBwJB7lEXbfdUk39XlSlNPbqGt67uFyQlzZ32sqwwvWSOvdME9jtdevt20Ns3ks4sSc6YtP7e3p0Md5SZVmzeoZXx7vM+wLLsZdQfuD20p53U1BWh5pobqX2rHc9QgL3PN6IGNYRQjRWY5LROalb/nEW7P4WkKUhygKILf8SJpEZy03TB9A/mEFj4JEtL38v6i9YCsPZaH/1djThdhQilmWF7dVxJcKYsxj+k14LnLDdPfAChN1yWfeSu/Dupc+LfR/x04k7TCtdYjKxM2SgqvAkBBAN9zJnzfrq6XjF69Ajho6npQSoqvjCu+7WwsBgf4/Unj6ee17dfjRBeUgV0Dunfh/H86Y+3beAz//ckc9OPc7C7irmLP06StJ9hsdzypwh/WpaWxMs/2cs1AceIs8iw9PxSdh/uMGIOfYrgNXeQRUEb4Y4CqbJk+NNysnlMTaVV6YrrTpDYn2ySjD0iGxow+1O8cq0EXjXTOB1/CqgjPR7nVCcTvMRjcie9Ka8wLZZZ/mQmHNwJ43IVxx5L704QI1l+Nhk+nuPHU/SFMf2pt93D4deb0VR49jeNlF2RiiPFh0OGnNQu5FDbVJsiccHahyhd8m66GttwhUq4rpDtZBS+h3Ul19Ay2MKyj0HTW8fITVtKdlY/Pa7X4zwrBWfKCnyDu3GkdJJZ8VxEmTsgBUmdU22UwScK1Ey2P+XlXkkwOEBKyiKj/D3Sn9rbn6as7GPjul+LiWEFeKaYRKtT0Rw4+SrJSuSXr5/SrCSW55xgfycMBfNZX55FblIn86VPMneZB4GLuYs3M79Il5H5RbH3O97mfaXZSdj9DRw85B1z35lAotr98Ov90JuNtGkq1Q6Jjf5weiM892wdu5N0O+lTBA8n+7nI7uLCC+agDAQ5/kpLSDbCkiGxfLiCJ1SHsQpV2K+XFPU7O6nN2qPfdU8VK0UONsncMG2JW+GQRzVkREKiS+klW82I+7xmg5wAqKih2WPmzCRJkri690KuHLwA+V8KyPSnG+M8I2vIO547Tu5RFwAioOGr6yd5TSnr1j7Ovn2bWbBgI3v3fdQ4ETS3/C20EmBDiGCcI5paMuiZ1P3Gy3jTo0tLbo35rGZkrCM57yfmFZvsg1SmX0dh7gZS5j/KP75XhxqQeGx3M7d8rYT0XDerryzj8OstqCGL14KKcZL3aeAZLkTSwiVYdjwNG3nXxTa8nt8Zqz9u1cnRI8MU5B7ntb93EvRrKHY3QvSgBZOiGvWFUUiypRNWqtQ51XTse0dEeVfohdCc2FwDCWUjfjrxqRKkKZQlBdDe8ZxpJDJAfcP9ptp9CwuLyWE8/tTbuxMhdG8Jf1cK4UvoT9+58LsI4UWSXBRlPoXbrQdsLH8aeb0Pv96CGggN7gif4zU4tLUeFIn0JIk+RTAnIHN5UjIla3I5+WIzNiTSI/zJgcLKwcW0Zm2LcaeWtFpSvZkMuHrQBhbE9acKl0KNV2WR22YcS7O9naJAXtznNZY/zZQA0Gn505vH4QXdM6Qghjtt3LCF7u4dNDUnk5u7hBN1P7H8aZz+1N+/N25fLEl2ISJGzssEWJeePqY/7X15P1qoLaAakPF0LsGR8io+DYLdS5FDJVdCdRDsXoAa7DMd88aUAL6+P/KVY4/QGlDJCRTx3j1fpCcQQLFfQNkVT0b5j8SCii/R3b2N8HgIxTlkej5ZC58xbjNaoGay/amt/XEAurpfIiVlMSfrf2vaIxDoPY37txgNK8AzQ1hWdhFHD/wAhxHkcdDVei8fXOIzAjml2Um0tIwIh4SXJGk/4dWm6JpqmFjzvpnQ6G+8jLW6FxaYcEZMGJcGQU1gVySS/PCuIQcOBEefrGdHUpAet8ZlfjsrhWJk8Ax7k7l5zxdNdeT9zk7+uup/UUN/r50lT8Her5DuCDCcUct1/RcBelpxsmsYn+Qyslay1YxTEg0tVJuceKTi9GEb46tDCUpk+tNJXpM/cpvQWM+S7HkU3lhI2z3ViICGZJcNiXG7S3H7L0Y+4sbuycXvajRuL4TPlFo7nSzmEFmik26y9JrxaIRGFt0sjju6/NQZb3p0fcMDMUEGt7uUi9/+R0rmPMeRt17FlX0QV9qQ8bnuaUxCDegPEPRrtNT0kp6r/40KKzJQ7AI1IBkn+bSca2lxVPK5ikt56YcnQ6nIgr4TF7O3QaP8ysdNqz8IO6/+XytC6K+XGoBwkCZ+/bdqykqyh6ZDNL7yGYSmp0aHp2mNJh3jTSc+NcwTBUEvj4ucsjVTf9RZWJyNZGSsQ5JcCOE1ftBJkjOhP4WDQUJ4jSBMPHcK3/e56E/6979sBHlMqIK5QqEzoHHLkANpKEjji81sTfIjITFHSFRF+FP5ySu4rLvc5E7hkvdwv/xXVQdDh+6kvWgHC70lXNd3CaD7k8M5jA+XUZqUG8g6LX+aCQGe0/GnwjXzaXs1vjsVFBTTUVONf8+Q5U+M35+O194T04PH7S7lvA1PcaThr3Q2/RYpaiLZaP6UlHsMSXEZQZLFVRejpV9ArU/hQ0VL2V8ziAjKSIofryeVv+5+lasKzMfslGGJ00trwM7igcKQP4EakPB0LozyGsGxmu+YnlPKnGo6D9wYKmf3kzH/1XG9FlPpT01NfwFiA4yRZbCWP00eVoBnhqBn4TzKwbrHKMlMIjPJTs3x7wLmQE4iiYhXU12anTSh5n1notHf6TDa6l5pdhK/u3UdP7p3F0T0UvTK4LTJ/P7D69n8+/04BvQ0ZQcSFw3b8SPolzReHAgaPXiGNb0JYGRqcUtarRHcAVCVAMdSj+GxDVAcFTmfK6fhEz6CqNhCzWdPRTKmOrAzljTFpBWPdtk2Ih7xsGW7yb+ryliVCstLsNtL1jNehlUvZfLXqDv/qwSSOozbnQk5AZDR+BD361MghGaWFKEBEh/i/mltEOhyluD16VNMhPDFXTF2u0tZWnkbcxddHvO5LqzIwOaQQ9k1I+PTS1L1lah3fqGc1577Dq7sA7jShli+4HOsc5fS1+EBToYeIdRYOSgz2LSBlOIdEBrNqR+XPHJZ9ulp6KP0z4lEApLzjjF3kz4dwpbUSXA4Z1zSMZF04onhQJK0qFVQxZoSYWFxhnC7Szlv41NGD54FWYOkOgbG7U+J3Cl83+eiP6Xnuln1tjlUb603tgUR2JBQ7DL/8/F1PPLb/UihH2sSEov8Ci+4g2T6ZF4YCJCjyHSpAlnLZJF3vXE/LWm1Rsl7WBeCip/t+S9yPGs3aZ1vNx3LXDmNACOuZT/Fny0zyZ8EggBBHNjjXj+aPyVyJ7D8afxIoWBXrX4Io/hT5cLP4yl576j+JNkEFI6Mni+eu4b5V3+QofYSkvMamLvoj7jdpaQPNHDTYzdhX5HMyt5KltZdRc++91As+/Bd/R2cyS2mrKNN6QHq/RLXzj1EfU1kVs3RMZ+hM6WTuVf95ykFaqbKn4qL30dvXzWRQZ5AsD+mDHamf3fOFqwAzwxiftEi5hfpYwQ9nnpqT/wkRkTeqJNZueDvdNVvYcWKm4wPQrya6khJGe8HZjob/U0V4dW4ztZBVE0QQGBHIoDgmF3js1csYklaEmVBBTBPE3AgkSMUhgUMa4mb+Bb2z0NR7UaQR1HtpHozeWXJ36hT0/hg5/U4xUiDM2fE6MTROJMpxBMJ7oT3P+KoY5G/POb2riVj11Lbst0mOQHw1/Ujh/4ksubE3bPQJChnknXs4C6+zx+4jW5Ggn1ZdPMh7p/SEZ/xCAd3IH4Pnkjifa7Tc93c/JW1PPvMNn7hu5vOA824jrjYfMNmcmwCzbabS9/xMbzeJpPYtNT0xjRiBigtvZ3SqkuYW5zMC7/1IjQZSfEx56IfG4EZYMLCYZaN00kXPh1kyko/SkrKYg4c/I+o61RjKslopRkeTz1+/0t4PFmkpMSfRmZhYTFx3O5Sli8oZXno8kT86Y2DjQndKXzf54o/RWYyRX/D73IE6bYJPnj9QgC8Az7SGJnUZBdw64ATBxIeoCGBPxX2z8MWKnkPZ/Aoqp0TWfsB2Ja2O8af7BGBkNGYqf40wBCpJJv2fSbjNVKCKVw6uCbm9mP5Uzx3Asufxo8wgjtw6v500afn8M1/fI+G1KP8btsQm7M3U5JaAsDiFe8HMGUGVbdV4w168bq8dMj9KKFG2jbNSYrzf1mwpI1j7f8k0PUYoGfx3FYyH7f/0Cll1diTp2qha6JILFt6N05nHkQF8Zqb/0b4d1gif/J46unu3oGqJWMxfqwAzwwlejWoYzjHtMr0g8svNH0IEtVUn2uEV+McXo0PDzi5DAcBBC+6/Byza/QpgsUpbv7vm9v1pnVjND2ORiAYcHbRklbLtYc+TnuKvsI1r3uVkdXTqnTxiXnfYlP3Rdzcc4Vx/wEpiEPYR818idyuoiIhndbK02QIj0Dgxx8TpNIkwZyLViGe70OKeCwBePd10Xa4h/y7quKKSDw8nnr6knehKTnIqgR28GaFT8JO9JPA9NePR7KOHaxhJ4fFEnrJJIMeFnNoWjN34iGESl/fbtrbnwaISTdORFqOm5bCw3Q2NQPgDXp5q+lZUlvvTriiErlyFUaxw+L1C3GkZOL3P82Ftw1Ts3cP7pyDIcEYCczMDOGYKPpzPXjoc0QLSiSJSjM8nnp27roeTfOwc9fvrFUqC4spZCL+ZLmTTmQmU76scGu/y7gugGCvU6VPERSmuXjhR7vJ0xSTPwUkYgZWJGJtwyYA8gZLGXD14LENsL1c/1Hb6ujix0kvUG5XeE/v5SP3H8p4Gb8/aUicXubOZPlTKskx97UhqQrWliIe67H8aZb60xF1HwdzQw2Pg3oAJ8cmTBkpeXmbjP2r8qtw2Vx4g166M5uQ7QItIKHYYdXqNThSOigaOs7JrvDis0JK4DiCU8uqmTlD5gQdHc/S0fkssf6kGkNV4vlTZKN7cOLxLLEWyMaJFeCZwURGjaNXmQ51BtgUse9EJnadzYQzmeapCvbQydSOhEfWmyoD1O3pQAuOTKuKTp0ddSXG2WXUj8uawnUH76BoYIF+ZT/GylSnMoBroMgkHn/IeYxifz5X911o3F+b0kW+mm1cDj9+gCA/LPo9n2n+oFF7fqaQkOJmIMlIFDky6aPP2E8UOZCa9fTrcPPk8QhKT892Y4Sn/bxilmf+nLTF83F47+e5//s73r4sUosPkLXoWSCIJDlwueaYVmGmCxltWkZ5TowgBw5+xrh0vPZHnLdxq/H90TDQQHVbNVX5VcYKU5iFyQtxKS68qheXzcU8p0rbKI1F03Pd3PK1DZw8eJz61q/gH0olOa8BzfZdXt9+m9HYMb1cYbRgyGzjZP2vIWZdO4xMUdF7SQq9TtE15eNt1mphYTE5jNefLHfSicwCz/GCFjGe+5+ugMmfwl/rka5UEbSN6U+R/XfC/rSoYz39zk52lTxtDLJI7S9FSh4y+1Pu+P0pSBAVFSfO0wrSTEY2UORziDyW3NZU0gPp9IUaC0+nP4GC211m+ZPBqflTVV4VDsmBX/hx2VxU5VfR2/tGwnN9SWoJm2/YTHVbNcvTC6gp+IJRxqXZvstrr38YU0+JiOzg2U57x5aE16WnV+GwZzNnzvtxu0tN/hTpTuCjr2+XFeAZJ1aAZ5YQvcq0JCc2ZXW8E7vORsKpxXMy3LjtCo2qZirNalR0I3HbFfJdDgYjbht5Eh8rmyeyflyTVZ5Y+gtu2f1l47pLat5LU0YNxb0VPFb2EFfVLcAlnHglH9vSdgNwWf86XEIXj0g5iTwWDZW53mJTcEdDm/Bq1GSnK5teGwF7mvdTKicjaxLIQNvIycmHj+7cISMxOdFJ0uOpN+QEIJDUhKf8EFnZy+l+PZXB1grmXvUNZJsfUMhI30Bv31tnRE5mC0L4jfGTDaG6b29QD+BsvmGz6fXPc+Txlyt+wpGWJ1lcfD1FKYV0nPzxqM1C03Pd5C48Qoe6H3euvq219VEjuKNzdojJCIlLNkGjOTRtq/bEPQih1/WHM6BmUwNWC4uzjbH86Vx2J9D9qWvQh9Mm4wtqtDsFgWFzaTvo/pTuNvsTJA5iRNOcdjyhP61t2ITXpvcvfHLJr8hV07i+duUp+pMwFqUkpEnJhh4viZ5/zHbtzPiT/kAqHs9IfyULM+P1pzmpc/j2gm/jS2+iwi3IsQkY41xfklpCSWoJLS0PY0tqJL1cb4Td2PhnzMGd8RF+rNlMb69entfR+RyrK3/H7j0fMV6/ylX3RTxHJ+npa8/swc4irADPLCFylWlNaTrd9WM32TpXiG6S+Ltb1/Hgi7WIXf2A/rNMkSSuXVHAzYsLOPTAEdPtI0+8KgJllKBIQf9cZE1BCxU6a7JKbdYeY/UpXFN+NPcNNFnljnnfZvlwBfvdNbQ6ugC4Y963ubnzKtNKVDROnJT5zHNbDztPsNQ3f8zXYyIrVvH2jbfNh58TrkYWe+cZ24IEebDjr3xRu02/nYbpVo9kvUiFf4gS5o16ktTH3AYibmkzvsQLKzJIKagJyQlET1qykBkrSyZc9w16CVZ1W7VJEFWtjYZDX8CleajvfYSiDVvG1SzU5So2UmvBgc/XPspR6Eno5wKa5ov4f30Fr7DwXaxb+zj79m029U6zsLCYeix/SkykP7lsMp+4ZB5/f+mE8W0tAZlIXLiigCuX5vPff9/Hv2DHFqdMaiz3KOqfPy5/AmhVukb8KSnCn+Z+m5u7RvcnB3bTUAsFheOOBub7SxLeJvq5nAoCwevJezh/qNK0PUgwZnKWn8AZ8afIo7IY20vG8qdsm2Co/R7aNA8dJ3/MxlP0p6HhxAuWbve8hAuasz24E4kQfhob/2zKgPJ6m9i4YQvd3Ttoak623GkCnPl5yxbjpjQ7iXevmUNp1rm70hSP6AbTjb0eFikOox7cgURhUOLJfS3c8+B+U4PY4Wy7ccoLInjS7ScY+sJvTj3GS/MepDl1pH9Iui+Xaw9+AlnTxcGm6hk20VMhNFlF1hRaHV08n74Tx0ABkqZf2ero4m85W/FK+g9BHz6eSH+ZYNQJt2p4CT70fQIEmO8bW070Q4i/ehSPZntsA74AQXyS/nxUVA46j/NI1gs8kvWicT8CwQ+Kfs+qoUURq3dm3tF9GVWOFYB+kswYTuby3g1kDCdT3VZt7BfObtBRcLs/aaRpDge3cPG7L4RxNlk827Dbs8jIOG+UPeIHd2TZZdR+h+u+ASONOBI1eChuSnFh4bsSnkw9nnp27/lISE4UwE9X90sJjzIjY+Moz+FsRJf5yBU8t7sUh+NSS1AsLM4Alj/FJ9KfvEGNnuEABQHZ8CcbEjcNOPjn7lY+99Ae2jSVvyf7OWQP0pVv55A9GLcHTjx/SvPlcN3BO8b0pzDttl6qlQbabHoZEwJanePzJ03S8IembwkE8/0lCT0okngLXolup0WdfyUk1gwtwS/pjxtEZbf7ME+nb8MXkZ0RIMhXS38a40+RjzL1/qTE2XZ2MbY/Rb7iNiQpfN6efn8aGjqc8CiTkspHe5pnFW53ifF+DvuT211KQcFNKHL+GT662YWVwWMx64nXJHEoLYmtOzqxI+GPKNGqJYgm25A1vXHgjqEhLguVQdmQsEkSLzn9LHGc5PFl94IEh/Ne54YD/2b02ikeWMgtu79MS1othf16Rkv0CpRNdbD+5DW8Xv4oQtaozzlgOpe0OsyrU8uHK7iu7xLT83IIO3/Nepqbet6OXZxegCNR0Kc4kBez3YGdJ9Je5qq+87FjZ6lvPkt98/Hh47tF97NqaBF7ko9gFzb2JB9hU98Fce/fiZPMjmQohSrHCn5R+1Uj3dp51UgmkNtdSuWq+4w0Y4/nV/T0rGXf/o8baZrLln6PAwc/T3jVSZJspKQsY2Bgz2m9LjOdQKCb3t7Xx7VvUeHNFBTcGDP1KrLuO14PHsW2ZMLlQ+a66LFLsQKBnnE9h7MDG8uWfp/BwcN4PA14vc1WUMfCwmJGEu1P76ws5qU3mwkOCyNLR0FijipzQFXJ0iTeNaQvoInOIM+4VOYHFByhci6AjtQaHlv2s7j+VDSwYEx/UlQ7c7tWUJNbTXdqs75dw1iSnog/vav7CiOTZzy9FqOvk5A4aW+mLFAUs1+8ki8nTvyhjBoFmUrPYio9i/Hh469ZTzOgDHHUfZL8QHaMP0lR9zNV/gQK2dmX0NX1QtzX4GxhIv5UMf8/yMvbFJN5MxP8yettHtdzOFtYsvi/6eh4Frd7fIvaFvGxAjwWs564TRKzk2j/6BJ++H97OSlrRoPAPkVwX7KXMk3mpKwHfS7wCn21SoLl8zPpOdLHsdzqkbOtBEdz3zQERSBI8+WQ1jEy6vHmPV+kJa2WVG8m7Sn19Dk7Q8GdiKhOlE+0OrqMtGMAr+QzasslJLySjwFl6LSDO+FjDktEkCBvJh9kw9DKhPunakkxo0mdOLELG3/L2WqSje8XPcAt8g3kN6bixGE6/nANeVZHMj2hkZAuMSIuxnP3NkWkGftob3/ctCoiRIDzz3uWpqYHqW+4HyECZ31wZ2IolJffkTCQEK77jntLOZ91ax9nYKA6bkqxx1NP04k3Ge5YQNnS+aTnunG5itFPH+NN8z6XkkWDHDj4RcL19O0dW1i29Eeoqs8a82lhYTGjiOdPf/+Pi3n1tQb6nm5GqMLUx7AwOJLdI6mCHEnm4WQ/ywMKJxSVBUGFttw3T9ufDhW8ZrqPU/UnW5xMldHKyeJl8BQGco3L4/EnR8idIu/LiZNGZxv7k2pM/vSrvIf4SPs7sWHTM6eF3j9oqv3pbA/uTAzFmJwVz6FO1Z/CzYLlYCU9jUkUVmSckj8FxNmfbRXmZP2vTJcbGn9P5arfMjzcYPnTBLECPBazir4ODy01vcYXZZh4TRLnlmdw1C3wBgVOm8zlS/J5cl8LfYpgr6JiVyQCquCJ9ADvHnSiqYLCfYN02QULOqo4nPe6kTe7sGPNqMcVFpbm1GNsL30C5AlMDxLmFamAFGTV0CJeTH+DDnsPH+i8Dpdw4pcCyEI2CctJezNzAvkoY6TbRorGA7mPsi1tN5W1i3EKR4zo+AnwZOarbBxYaZqe5cNvrJa5ImRDETI7zjvB83ufZkF/CW32LvID2exPquHf/J+hhHk4y9OQ7DIioCHZZZzlacb9ejz1+P1dSJIz1KTXSV7e9bS1P2FaFXG7S0lOnh9Vb24BsKDiS6eVJeJ2l8adTODx1PPK8x/k+FNfQqjtvGZv5+Lb62jt+QETqeEfGjp4ysc2U0lNXUl+3tVIko1jNd+JutbcLPHAwc+iL0NbYz4tLCzODOP1p9LsJC46v4T3vH6CHC90OAUXLi/gyX0tNCoafvRFMZtD5uvvXcnrvz8MQcFyFCQk0kbxp3hBldPyJ8bnT0GCKKHjCx/HcUc95f7iUf1JQjICNqD701H3SaqGl2AXI2Pbw//6pQBCaDETvBL505AyzB0L/pvFg2UcTjlJUAsYmUmWP00PU+FP4fHe3v5kTmz9BkJ1YnNIXHTbiQn7k2/owAwaeT45ZGddSn7+NQQCfXH8aQRN81L91ofQM50sf5oIVoDHYtbQ1+HhwW/tIOjXsDlkbvnaBpOkRPNGXTfe0KhPX1Bj5Zx0XjjcbmrG3NjrobBb5ZUndtCSpacMr/bloAYWcNmBT7Ivfxfr29aNjELHvPojECTLEtmKxEmlm8eX/nzCcmI0FQytRoVXdy7rX8cd875tSkXODWTynfpPYQ+t9vwl9ym+2Bxq0oeg2n2I1Z4lyAnSjyOnUSBGRsVHIhAs9JTxSNaLvLd7k7H9j7mPG8cYXi3zSj72J9Xw6qHd/Pzqn7OtaRsvHfgD+0QNdtlOYUohALZsN/l3VeGr68dZnmaM/gyfBHURcTG3/PN0dJaSmbkxbqM6Pf117MbC5xrHa+8mN/dy43WKHtN9qvT27mSovQSh6kKqBuBw9Qukl/ti9s3Ofts5tSpYWvJhCgpu4OTJX49j73AmnzXm08LCYvo5FX9q01TaHIDA8Kc+VB7MCnD3ZUtYXplHS00v/UoHLZm6P6X5cigeWMgNB/6No7lvsrBjDUUDCxJmzCTJnJ4/hRiPPy3ylPO55luxoeCVfPw951mTPzXb2ikM5iactuWVfBx1n+S/Gu7ELuym5slG+ZcQPJL1IgWBbC4ZGCnXGc2f7rrs8wS1IJfLNr627Ws859hh+dM0EulPk+lOmubB01lp+FPQLxL6U2rqqoRZ6WdbcAegoOBG0tMrqav7xTj2DpexWf40EawAj8WsoaWml6BfPzEF/RotNb2jCkp0bfnVywu5enmhuZQLOHiyhr+t+i5BxY9NdXDzni+S5sth0cAiFg4s5HmnnyJG6tEBU3DnslQFmySznCweC2aa0oYnSvTqzvLhCp7L2GHcZ6uji4/N/6YhLDd3XmVakWp3dPO9zPv5YvNtJpkSCJ5Mf4VWR6fxOJHZOZE4cfCRjnfhw4dP8uMUDlNgKLr+vdXRBSpsa9rG/x3+P4IiSIE/m+XDFfzXU1/jF+++j5LUEmzZbkNMwkTWImuaF4cj22iklihdVpJsCJFonKRETvZlBIND59S0rcjmfmbp08d0n6qoZGSsIznvJ0iKD6E6kRQf7pxjUftsoK/vrVBw59yRx57eN3A68zhee3fc64uK3kdz84NEN3K0xnxaWFhMN1PlT03DTXH9qWhgAUUDC1ARaIi4i05JMtPuT0fcdYa7/Gv7DSZ/2pt8jD8mPzGqPy30lBmPYcOGn4Apw8eJg/d2b5qQP73R+gbXzruWO5+/k4AWmGZ/ktFXGVXC/uTzd51TJfBhfwIm1Z1k2Y0759i4/El/vc8df2pte5yDh74QN6OsuOh92GxpnKy/D3OPIsufJoIV4LGYNRRWZGBzyMYKVGFFxqj7x+3NE9oeybHAAWOKQ1Dx05JWa9SHt6TW4M3bSXu7OYsHdCFIcg1hk/TjcGBj+XDFaQnK/qSamNUdwDjhh4Ug/Bh1zmZTNtGe5CMccdexx32ESs9i07Fe2Xc+Dux8oPM6vl5yr/E4PsnPI5kv8I6et+EUDuM2Tpzcl/MwfbZB05hSiK1/B3hg/wNoaBT4s0dqzFt9PFX9GE32dq6ddy3rC9abbhM+CYZPqOnpa2lt7U74+ugjQRMFdwAEnUYWiYPk5LkMDR0Z7SWfFWRnXTrqlKrI5n5m6RsJ/JwKbncpF7/9j8yf9yZ9zal0eP4Te3KnaZ9AoC/ib3JuyAlAc/NfaG7+G4maJNptaZiDOwrJyV+xGi5bWFhMO2fCn5pTj7E7byeVcfwJOKP+VODP5vzBSuO2AmGUdY3mT9GBm6+X3MtCTxkf7Lz+lP1p87HNPFrzKKpQz4A/RZ6zI/3JjsORg9/fMvqLPgsYrz9NtjuFs6iqVi+krdZDc/8dlj+FGC3bu7llM/Pn3YXZrSx/mihWgMdi1pCe6+aWr22IW0N+OoTHIHqDXlyKixVz1+LrELRETIJozN1hmgQRZn9SDWvUFTFCkYho0Ygm3upOgT+bX9Z+Dadw4JP8fGLet4ztt7e/07QClRPI4K6WrxorTJGEV5lcwkl+IDvmcZ7O3MYF/ZV8sOM6o8nftrTd4xau8MjQ6FW0Q7vf4rmMHWw+tpnfXvVbQ1LCqbCVq+4zJj85HMVANx5PvdG0DjBSZs1C40LTgiSuZfaTk30pHk99xMSC2YcsOykouDGhoGRnXcqiRf9pSsOe6FSH0XC7S6lYWgpL4eTJD1Jz/Lum60cb7zldaMgcZgm9ZJJBD4s5hDwtspR4AobH02D0RZAkOytX/JaTJ13TcEwWFhYWZqbLn9aUr2Ugyp/qZ6A/XdBfiSNigMWTGa/QYe8xgivRhP0pXuBmX3IN29J2n5Y/qUI/l4zHnyLLiCJLsSbiT2MToLDgBuobHgj19pmdjOVPebnXUFHxecOfJtudwvebXwLplj+NCyF89Pfvs/zpNLECPBazivRc97jFpL5rmKvuecVIMd5618Uxq0+gd8j//YV/4ZVD21hTuJanXhlim7uLQP7OhJMgwrgHirhzyXdZ6iszS0do3GfkvwWBbNP0hDvmfTuhpERuv6C/0lgZcgoHF/RX8nDO8ywfrjClBgckPdUxnpwEUVEJGuIRnQkUftyHc55nW9ruUSUqmnD2UJjMhUUE21VsqkJACZqk7cnaJw1BiZcKq6oqqtbGzl3/agRxhBAI4TP2ixQar7fZGA8aj3AHfq+3CZermH37P0Mg0D7mc5pJzJt716iNEbu6X8Lr/aghEpErR5F15GPVlo+n9jwvbxO1J+5B02aO8O1kA3/gNrqlkaksWaKTD3E/6zhzZXrtHVuQZRfz532RvLxNOBzFnDy5+4wdj4WFxbnNVPvT4uI1vPLSMNkMcnSUSVphkgaKuXPJ/7LUV677hj3Kn8BIaigITq4/xdzO3mkKrkQS7U/xAjfj8SchYvupTNSfVqQXxLhTYeG7ACbkTy5XMf39ezlee0/CAE5D4+9ZXXk/Xm8TgUAfx2vvQdOG4u47UxnLnzq7nqei4vNAYneC0f0oMqA2WoaJ5U/jx/Kn08cK8FictbxR140noK+KeAIqb9R1xwhKfddwxDjQEt6gjWzgahxs7VkNOTtGnaSV7sultG09z5U/Zr5CMv8rCSluffjppCO32btM5Vk/LPwDR9x1xtSISB7OepanM7eNK3ATr/xqLGRkNDQcioPHurbwavkrrPAsRC5x09o/cl/h7J3RUmHV4CFTXXmY8H6Fhe8yBTPO2/gMTU0PxoxXDN++q+sVAoEekpP7Zl1wB/SaefOUjFhaWx8lM3OjcTm6/n6svjweTz07d10/au25x1NPe/vTaFpYRhX0mvEzN5VjJxu4h8/HbO8mi3v4PHfx/SmXFLd7Hh5PbcSWcGRXf/8ND5+IuU34tQSM8awWFhYWM4Xx+NOhY93seLURT3UXWrCE3bTxTLKfd+NgYcca0yStBR1VMY+R5svBPVjIc7lR39GRQRAZJE2edH866j5p8qej7pN02HtieuoEUfly6Y/psPectj8lapYb15+GF5KzqJjWNrM/jVVGNBF/yszcSF7eJupO/prm5r/EHFfYnwYHj4xa4jSTGcufNM1neg3j9S4azZ/MAbXEfXssf4qPy1mC19cQscXyp8nCCvBYnLVENwlcX55lur6+a5j3/PAV/qXbbmqgDGBH4rquJZz038nx3DdZ3LGWooEF9Ds7aUkbmRbR79TraRXNhionHnsoZJGwPnwstqXtNtJ+fYw068sPZJvKs+yajayWDu5Tv8VixwW8PbjJkJc3Uw6eUuBmPIjQfxISizIWsa9rH60OH62O16HfvG9Q01+j0cqIFNsSUxlW5ApUvJTZ8PjPeEiSI27gZ2ajEFn6Ex4hKUl2yko/DhDznAoKbhz1HseSwr6+XaNeHyk4I6iMVqI01WjI/AF9AkrssqgMQuMP3MYadk5purE5uAO6nIw0S2xu+RutbY+zbu3jof3r2bnrOkO+j9few3kbn7YkxcLCYsYwlj8dOtbN1h++hT3CnexIFKgSAigaWMDVB0b8KXeggl5nB21pJ0z+lOrLNmfsxEHI2pT70+rWLI57j/JX5+/5QOB2w51+UPQA+5L1x5pKf5IlmZU5K9nVtmvEn9rM+wa14Jgl2KfiT4jo87juILPRn/Qm0iMuHu1PwWA/TRHBLEmyj1mKNf4Fyfh9eyx/Sow5uAOWP00eVoDH4qwluklguiZx+PUWo/78jbpucrzEBHcigzhlAwspG1hIv7OT3YXPs7PkKVQlgE11cM2hj7Flya8JKn4U1U5FexU1udUJRSXu9Klx0Oro4hPzY28XKTx+fNz88BEyOjSgHVtJK9KaEXnJD2Szj/EJ0akiEOzr2pfwepfNRVW+voo3WiqsIuezbu3jcWvIE32JZ2SsM63QSJKD+fM+Q0/Pjhm68jSySjGCTFnpR3E4cjhW898x1wsRoL7hflZXPkBD4x9CsqCwbOkPTNk78RhLCtPT1456faTgzBQOs8SUVhyDJNNNDofFEpZyYPoODNDlJHIlykNf3y5gXiiYNrKyKoSP9vanKSv72DQfo4WFhUV8Iv1pWVoSw0f76KuQjBKvXbtaTMEdgAACv6OLE6kNhj9l+rNoSasFanhiya/Q4viTpCogawgp+pw4wlT6k6b6uP6Jo4hhDVuJYnInu5ien0ma0NjVtitmezjQFPYnt7skoTvBqflTQcGNNLf8zbi8bOkPECJAW9uWs9KfWlr/gaZ5kSQ7qysfGDM4MP4FyfhBNMufJorlT5OBFeCxOCvp6/AYzQTfvWYOfR0e/vJfO1ADGopd5n1f38D68iy+7wL/sMCBhKxILLslg8/UfgE/PmRN4bqDd5DizzTGgIYJKn6O5r5pbFOVACX9SyjrWcbzC/6oB6DjcKpZNPFuFxae62vnc8XWo6QPj3TnV7uOIYI+JJse/BnvatdUYJft/PvqfycvKY8fV/+Y4pRi3r3w3ZSkxqbCNg408s+ef5ITfAdlobpyYMwTsF6q9bQpbROg9sQ9k/tkJpHk5MWmBnsV8z+P01nAgYOfSXgbIQJ4vU2jCl48RguojXW9x1OP398Vamrtjb7rM0YvmZO63+QzIpjhCSdNzYfw+7uRJIdpmkntiR9bqcYWFhYzgvquYWNh7IrS7Bh3Ss91s3ZtIVtfbsWORADByqvKkCu8/L76i5wI+dNlx/6Flyv+SlDxI2sKmqxnLET7k1BUNtbdQL+zk4MFr426SDaZ/vRLvsXH35xPsOsYhPxpJrkTwOfWfo50Zzo22Wb2pwg/AmgYaGBXyy5cfheV7kpSUuYa1411XsnM3EjV6j/T2vooBQU3kpm5EY+nnsNHvjYlz+n0kUhNXcHAwF5jy8T86alJ86fogFq87B3Ln04Fy59OFyvAY3HW0dfh4cFv7SDo18Am8bZPr6K7bgA1oKf8qQGNN7c1UZSfzAMfXs+exl5KggrLK/N4uOkJ/OhZIJqs8sTSX7Cy+VJTcAfApuo15jU5bxoZPB7bgP6JShDcmQrabJ2sfq4NMWx2IjHcydAL30TOXkCX9xhti3oYNQd6ErHJNiQhERABFBQ+uPSD5CXl8aVXv2Ts86eDf+KRdzxCSWqJsa1hoIF3P/FuvKqXP7X+ic03bjZdPxZud6kpit/S8vAEm9mFX5/Eq4gg43AU4Pc3x702yT2P4ZiSnXiIqOkJNjyeemqOf3/UW4VXiOLViY/FWLcZq/ZcT9ueOWTQM6n7nT7xVhUBFCpX3QfAwMDnGBjwIcsusjJHRrdqmnfcI1nH0wzbwsLC4lSIbK5sVyS+uaLc5E77d7ezvDIPqdPHxbcv5UBNN2vXFrJkQRb37/47wQh/emHBnxCyMC6jKSCrcf0J9J4806QpSJrgxufaCQy0zxh3An1BTAhBUASxSTZUoWKTbaP6U8NAAzc9dhPeoBeH5GDpkqWUZZRN6HEzMzeaMoH1rJPJ96fRR4EnOodGo5mCO5LkIBDoPWP+5HaXmgJqYSx/mghT70/nmjtZAR6Ls46Wml49uAMQFHz517u46tJS/OiZOgEEh56t55AKil1i/fXzmL86j/RcN2pNOUJTkEIrTZqssnfOSyN3rilUNF3N+o7VpPlyuHnPF3kz5y1qireyvfwxFNWOrNrQlMT9eCaTJQ2CnIH414nhTtThTjKAJQ0yB8umR1LmJM+hbqAOABWV+/ffjyKZT25+zU91W7UpgFPdVo1X1Vc4vKo35vqJopdt2UedoBBJdvZldHW9kOBaibLSj4XSf7+T8D7GF9yJRgaCprrweJSVfpzi4lum7cTk8dRTV/eLiNTiM1cvHo/FHCJLdNJNll4zHo3QyKKbxRyapiMSCd5vKl5vE8PDDRD+8aN5SUlZRE/vjgmNZB2rWbaFhYXF6RDZXDmgCn5QXccHceJAwo+gzutlf2gBLexPRRl62ZbqMftTOLgD+gQpb9smKr2prOlZYPhTbdYedpY8Ne3+NBPdCaA4udjwp6AIcvebd4/pT9Vt1XiDujv5hZ/q9uoJB3iimUx/ysu7nrTUpXR2vkRv32hNe8cT3IlzK+Efs1eQ5U9mZrs/ZWZumJA/nYvuNI25BhYW00NhRQbY9BOyH0EtQaQUOw9mBdiS5OeNZNX4rlUDgtc3H+fBb+2gr8PDVQuXoTZ/FKHpJ1SbZEeL+GJWFIkNJW/TV5qAVF82fjUZVdG/lFQlQF7n2tjzlIj6d5LIHJzc/SaDsJxEokY18XPIDqMfT5iq/CpcigsAl+KKuX6iuN2lrK58AEmyj7pfRvp6qlb/GUV2JdjDRlnpx8jOvphjNf97WsekM/K1qx9b7IqWJCksqPgKZaUfJy/3GqpW/5mKii9Mq5xs33GNqS5/piGj8SHuByQQUa+h0Gu4P8T9U9ogMBp9DG70+01Bkuykp68FHMbWhsbfU7nqPpYu+d64ZSNes0cLCwuLyWJ9eRZ2ZSSg0S0L/pThZ0uSnwezApS7XMYC2nj8KYwkQXLhVi6vukhvrIzuT45gismfFrSvS+xPk8hMdCc4NX+qyq/CZdP9xSE5qMo7PXeC8flTUdH7KCq8eUx/ys15G7UnfjJGcGcyUSgqeh/Llv7IOD7Ln8zMNn9yOotMW9PSVrJxw5Zx+9O56E5WBo/FWUd6rpu3fXoVX/71LmoJ4nfJXL28kKuXFxoNA1/56d6RLB8g6Ndoqell8XmFbP3Eh9l6dD0D8lsc7Wzln+0PI8khoRFBbBkNQDmgN8BzDc5DUe2oSgBZU2jN2xGb0Rs1Nn2y6EmZ3P2mCrts51sXfIsXG16M6MFjzs4pSS3hoese4pFdj/COte84reydMJmZGzlv4zP09u5Ekuz09LxOZuZ5HDr8ZSOSv3Tpd42TQ3vHFuO25WWfZGDgIF3dr3Ky/lfUN9zP6a/C2Ckr1ScX2O0ZpKWt5K3dtxnNoWXZyby5d53xemJ9nOfMagoYj3Xs4C6+zx+4jW5GGgZm0c2HuH/KR3zGEkDE/BhROXDwM6xa+Qdcrpvxev8E6KtQXm8ThVG9FEZjrGbZFhYWFqdDaXYSf7xtAx+8fwcBVeC2K9x76zoaez3GsIr9j584JX/SCFIvHeWV5GKWBhQO2lWc/hKTPx0p2J7YnyaR2eJOMLY/laSWsPmGzXoPni4Xc1LnTMrjhv2pvf1pAoFeAOobHjCmcpWXfczkKZH+VFz0/lBWcpADBz8PnH5WVnnZJ/H7O8nMPA+fr5XjtfeYRp/Lsot5cz9t8qeCghtO+3EnQmzmzsxlNvlTyRxzE2Wvt4nMzI3j9uRz0Z2sAI/FWcmSBVn8+EsXGo0CS7OTAIx/i762gdq32tnx+AnUgIbNIeuZP6F9Ni0v4KZHf4NX9SJhQ2ggyRpCs/PXaie322XUgEYAwbKAwpFwt3dJjZWRMUaAng6HSiQ6UyFrIH46ngZ0p+r7nSnssp1fXvFL1hes59p5146675zUOVyYeeGkCQqYa6fDJ/v09MqYWtzMzI0sqPiKMYGh7uTPTfcjRCAihVShuOgWmpr/PMGjCXCy/lemFNHo5tBnOm3U46nneO09Y+w13lr5qWcdO1jDTg6LJfSSSQY9LObQtK48jZD4dWlvfxy7/WL8/ofHlIxEteJjNcu2sLCwOF02zs/m+c9eGuNPYW4Zw58uKMrkQy//Gp/wATZdRGQNm+og/aUMAk6JZ+wB0lWJK7x2Np8Bf5rp7hSenjVefypJLaEoqYjdA7sn9TiiexsWF98S9/wT7U9mNwqi/9wMAg7yci8nKak8xrHG4mT9bxAiQGvb42zcsIW8vE309u7E5SrG62064+fE+OPQ42H5U3wSvy5ebwPgBHxjBmji+dO56E5WgMfirKU0OylGTMKk57pZfWUZ81bnGdO2wuM/AbbVbDf6wSAHWdJzA0eGXAx6yxgMZJBxUymVLjfNrUP8Ze8LIzXj8VxgCv1AyBIPXCHzH5s13aEirgsPGnzgChkhT7+k2CQbn6r6FJeXXT4p2TiTSbyGeT0926k5/r8kOsGER2qGRQKgpfUhNM2HJDmQJCmmKWF0t/8wmuahru4XlJffYRIoj6eelpaHp/wEFD4BpqZWGZfDUyB6e3eaVsXioQe6Yp/XmUJGOwOjPOORWNry8q5n8EQf5WX/jixLCYN5Y9WKn0qDSAsLC4uJcKr+1Nfh4de/exjfXP0cIslB1g6+g9TWZAr755Hiy+LuTfNpyVLwH+vnxSN/PiP+NJPdCXR/+veqf59x/pTo/DOWP5WV3k5y8nzDbTyeeuobfjuGP0X2ZFGM/4/0p3AGbNhpwsc4lSTyJ7+/a1yZO5Y/JSKxP2Vnv52BwWyKCgspKLgm4d94NH8619zJCvBYnNOk57pNgZ0whf3zjbRhRbVTdWIVF/iy+V2qD79L5vyVBZRmJyGOdeM9NHwGjnyENxbJ/PAmuPVZzdQ0sDtVF5Q3Fp2ZVltBESTLlTWj5CQRPT3bqX7rQyQqwQoHdyKnTERO6RLCz/x5X6S/f58pTbm05MPUN9wfEhMZSbIZJ/bmlr8ZK1Fh4ZmOJnDRj+N2f4Gdu75nXK5cdd+YIz1nkpzMVCTJztIl36On53UKCm7Ebs9nYOCjoSkQbvLyNsW9Xbxa8XNJSiwsLGYH8fyppaaX/J65KKUj/rTo+AoyAnlGts/yyjyWA8e7VJ62D52Zg2fmuhNAQARmhT95PPW0tz9NzfEfksifZNkZ0+A4ckpXYn+6jfqG3yJE0Lif8G0i/QmYtga6o/uTK2JRL5yxFIvlT2MT6U+RbRXqTropKLgm4e0sfxrBCvBYWMQhtzwNjpu32ZH4XFUZl1w5l9LsJOq7hrnpb3/BVjQyOUDSZAr75oIk0ZpWiyZPT5rjG4tkdi6QWNIgyBzU68YPlUhnbPUpTGFKIaCP8axuq6YwpZCWwRaq8qtmjLh4PPW8tftWIuVEkhSWLvkBPl8rMFI6FZn6GV3Tm5e3iby8TXR2vWhsAyJWoDSEUNHHZYamtEWcgCbzxDTaOMjox/H7njFd7u/fi6aN/r6VZSdCMGamz7mKJNmMgGC4LLCp6e+MTIFI/Pc9F2vFLSwszg4KKzJQ7ObAiFBh3bVlJKe7jFKuB7+1g3rnEXYvfdHYL+xPPpuHrpTmaZlOPlPdCWa+PyUqSZpcfwoHSVR0LYn1p/D/R247nR/1p+5PXkZ+VifuOWT50+hE+5O+mDq+v6/lTyNYAR4LizgcCxwwTXZoSaslqy+PGy6fR3q2fuLZevQAStFvICKIIxA0Zx4PX5hWhCxN6zjPSBQU1DirNy2DLTQMNHDTYzcZYzwBXDYXm2/YPCMkRS9JihzNqLC68g+mbB2In/oZrul1uYoNIYis8w331hnB/BpJkt04AU3WiWmsTCCXq9iU+hwI7kKSnEbjRJ3RV5iSkxezoOILnDz5G7q6Xzql4zybKS25Peb9o0/RGruG/FysFbewsDg7SM91U/p+gbp3xJ9aM2qZt/oaMvP1jsWHX2+hW2rniaW/QJj8SRvxp2nkTLoTgCIpMZOyYOb7U2SwI0y8bGeYen+arB/1p+NP4x0rn5y8mNKSWzlw8HMxz8ki1p8m4saWP41gBXgsLOIQHjvpDXpxKS4WLS4gdUkbR9R9tNToKygD4iiSPPLlrDdijojqnPkFoGlDkiQckgO/NhIYsMt2ClMKqW6rNskJgDfopbqt+owLCugn7EiWLf1BjJxA/NTPcP13tBCEt+flbaLm+I8IB0z0WnMZTfMaIjTZTeBGywTyeOrZvecjURISYG75F3C5cowTZ/R0imgGBvbw1u4Pj0tmzkXqG34Xk5IO4HK+m6KiYgoKrh7173uu1YpbWFicPVxQsRHXQd2fnJKTVRuLeKnvWYpFMS2DLSwoWkZb5gm0CH+KaYRzDiEh4ZBnnz/pP7wjy7ltcYM7MPX+NFk/6k/Hn1yuYnbv+ciYfXgGBvZw8JAV3ElEtD+53aWsWP4rDh16gCVLbh3z72v5k44V4LGwiEN47GR1WzUF7gI++fwn8e/zwz79epfNxabsryA0G5IcTsWcOZ3xp5ugCPLuBe/mRN8JKjIqeOjoQwS0AHc+fyf3vv1eI1gWxmVzUZVfdQaPeASvt8l0OZxWHE2iVYTIkeKa5qG9/WmjabLbXcr55201TckCEorIZJyYIo9TkuymAFa8FTdwkpt7JSkpc40tqyvvZ+++fyMY7En4OOd6Hbkk2dAbP8YGwoTwm94HHk89O3ddH1FDfvU0H62FhYXF9BDXn9pHzhcum4s7l32ZlwbsRqb0ucxs9Se3u5R5cz9NzfHvhrYE6e/fGzfAM9X+NFk/6iODVrLsMmWLjMefNm7YQnv709Q3/AG/vyXh44g4GVvnEhP1p337P46medi3//Up7bF0NmEFeCwsElCSWkJJagn/OPoP/FE/Zr1BLwNqB76OK3DlPwVEZe+cgzx09CEA3mx709jmDXppGWwxZC9eDXm4vrwqv4qipKIJP+5o9dLjISNjnZFiC1B74sdxJxzFy7CJN1L8eO09pttHjxkNb5sq3O5SKlfdx1u7b0WIALv3fMQ4IZqDP07mln+ajs4S0/HoPYlus+rDx0CIIMVF7yE9fTUuVzGNjX82NYiMxGr8Z2FhcS4xlj/1J/ewruFqtpc/pm88R7N3wpyKP0W606lm85yuP+XlbTJl/M52fwIQQpj+DTMefwJMWUcW8Yn2p9HK/S1/OjXOaIDnbW97G01N5tXzj370o3zuc587Q0dkYRFLVV6VXn4kzCtQby/fyJadLoT2HJIcwCbZCY5VsiI4p0q3YKRRIEBhciHrC9YblyPry102Fw9d+9CE7nsyJk+53aXMn3eXsQqlad6EJ5DoVaJ4I8WF8J3xE5DX22QaKRo+nmjJcjiK6e7ebdzO46mnru4XVnBnnDQ1/42yso8Zf+vIAE9a2krj/63GfxaTjeVPFrOBRP60cv56hl5JZZf6NEHFj12yE7D8KYZE/hTtTptv2DzhBTLLn2KJPKboYxmPP9XUfB8ruDM+wv4E0N3zurFdlp2mKaOWP50aZzyD51Of+hQ333yzcTkpKekMHo3FuUR91zBv1HWzvjyL0uzE77s5qXP49oJv4832Upym15AXOJZy6+/eQHOewN/0YT7xtiwWFWTwlX9+xdQsL9uVTZe3a+TOIuXkHJGVA50HuPP5O00iEl5tiqwv9wa9VLdXU8r4T+yTFdnPy9tE7YmfTPgEEluDrhPd12e6iT4hulzFtLQ8bKychV8jVR15ryaaiGExGqrxnosu9evv34vX22S85uvWPs6+fZtZseIma/XJYlKw/MniTNDX4aGlppfCioyYMenRjOZP9uxaCk/ezjuuzKC0MN3ypzgk8qcYd2qrpmjuxAI8lj/FEi+YEJ3lZPnTZKEaU9AiA33z5t4FYHJWy58mzhkP8CQnJ5Obm3umD8PiHKO+a5ir7nkFT0DFbVfYetfFxujzeEGfPEcelfMrURQFgN+8vhOl9IfY5ABCs6MFvsU3Xv+GSU4cssMsJ9FIIARIZ7GkuGwugBgRCQd4TM2sbS6q8qroHOgc9/1PVmT/VBscx9ag60T/2J9uIp9PZOO/0Vbp4teXW4yGJDkSTEFzGWnrka+5w3GpJScWk4blTxbTTV+Hhwe/tYOgX8PmkLnlaxuMIE+iwE8ifxJygCbNzlDQ8qdIZGQ0tFH9KcadTqEnj+VPsUQ/F4htAm350+QQ6U+R78O0tJVxX3PLnybGGQ/w3HffffziF7+goKCATZs2cfvtt+NwOCZ8P5GR1LOd8HM9l57zZLO9thNPQH/9PAGV7bWdqFom1/xkmxH02fKpCyjNSor7ekuuWiRZTyeW5ADNwW2mJnhXll7JC/UvmB80zorT2SgnoMvZJ1d9kstLLwfg57t/jlfVJ5JV5lQar2VRUhEPXfsQ1e3VVOVVUZhUSCed435vOxzFrFv7OH19u0hPX4vDUXzKnwuHo5i8PH3laCL3kZ19hakGXZZdpKZWnfHPZ/j5tLZuNq3SdXfvoKCgGI+nnp6enahaCqqqomnneBOEU0CIAMeOfY+ioveRmbnReC/6/V3Unvg+MPKa5+beCFjf2+f6859MLH+aOJY/nR5NR7sJ+vXR5kG/RtPRblKyCujv9PC37+wyAj83f2UtaTluy58miCIp/Ortv6J5qJmqPD1oE8+fot2pKKlowu9ty5/iE/lcLH+aOoQIGv4U+T7s69sV85pb/qQzkecvieguUtPIAw88wNKlS0lLS2Pfvn388Ic/5O1vfzvf+c53xn0fqqqye/fuqTtIi7OS1sEgn32mE58KTgXuvjKHQ50Bfrazz9jn39alc1l5/PTjdn87Xzn2VQLCj11y8Pm8T/PDth/jQ68lr0ypZOfAzul6OjMGGzZuyr+JtelrATg6dJSFyQtN/5/nyDuThzglqFobAf92kCTs9g0ocv6ZPiRAPy6f71n8/ifRR3I6SU39AQADA58DfICT5OQvMTT0bayxnadOcvJ/YrctA/TXPfL1TU39wYx5T8wUKitHVvQtJo7lTxZnAm+/xt6HB9CCINtg5btScaXJdBz1c/zlkQyG+Ze4yV0YP9ho+VN8FBQ+V/45lqQsod3fbvnTGT4mNXgIgQ2P5+dAEMufpg7LnybGePxp0gM8P/3pT/nZz3426j4PPfQQK1asiNm+detWPvWpT7F9+3YyMzPH9XhhQVmxYsU5I4uqqrJv375z6jlPBfXdw+ys62FdeSalWUnUdw8nzOCJ93o3DjRS3V7Nct8C3A/20iJ3sC19N3/MfwK/du41WbNJNn759l+ytmAtjQON3PT4Tfg1Pw7ZwebrNzMndc6Y92G9tycPj6eeN3Zea6yMSZKdlSt+S2bmRurr76P2xPeMffPz301b28QaXFuYyc25mmXLfmxc9njqjRUpt7vUem+HCL8OVoAnFsufph7rc3j69Hd6aKnpo7AinbQct7EtUQZPIn/adWIHSzrLSHs5QIt0jvuTbOOXb7P8aSbg8dSzc9f1ppIry5+mlsKC97Bo0cjihOVP8ZmIP016idb73/9+rrnmmlH3mTMn/hdVZWUlAPX19eMWlDCKopxzf/Rz8TlPJnNzU5mbm2q6vPWuixM2Xo5+vcsyyihW83jrp0/zz5Qalg9XkB5IMcmJrMlosjb1T2YGEBRBWj2tKIrCC40vGK+DX/PzQuMLfHj5h+PeLt6YdOu9ffoMDFSbGtcJESAQaMXvb+JE3Y8j9nRQkH8DbW2PYU1/OHWSkkpN79mUlLmkpMzF46mnvf0RUlP1dHvrvW2RCMufpo9z8TlPFpn5KWTmp8Rsu+VrGxI2X45+vYvVPGybi2mmmR3Jlj8FNcufZgoDA9Ux/XRG86fMjI1WgOc0KSx8h+VPk8ykB3iysrLIyso6pdsePHgQwGoaaHHGKM1OGnWiVjS1Rw9zR9m38cl+nJqDbzZ9Epfiwqt69bGf8hhjP2cB4YZ/4yFypOd4ON0x6RaJ0ZvXOYgM2kiSPWY0qcv5HlyuIvJyLzeN+bbQkSQ7SUnzGBo6ErFVhqjPRHb2xTG3jR5Dm5z8vZh9LCzCWP5kMZtJz3WPOVUrjK+un2bauWPeiD/9V/OdZ50/SUgIxlcoYfnTzCCy+XQkifzJ72+b7kOcNUiSQnraWnr7dkRuBdNnwo7LFTsBzvKn0+OMdYV66623eOCBBzh06BANDQ1s2bKFr3/967ztbW+jqGhio/4sLM4U+901+GT9B7RP9jN0noN7L7+XmxbcxDdXfQ2nFqpBjz6/z6JFqVuX38pvr/ota/LXjLlvy2ALAJeXXY5TcQLgVJxcXnZ53P3jjUm3mBzc7lIq5n/GtO3Awc8hSXZkWZdwWXaj2CrYuet6K7iTACEE5WWfAOzGNkmykZq60rRfvMkf0WNo1eChKT1Wi3MDy58sZjvO8jQOpB43+dPwZe7x+dMs4sPLP8xn13yWq8qvGnNfy59mBuFJWkWFN5u2J/KnupM/jdjLQUw38HMYISRyc83v3wUVX47yp4AxLj2S9vanLX86Dc7YFC2Hw8GWLVv42c9+ht/vp6ioiJtvvpmPfOQjZ+qQLCwmzLr5G3Htc+HVvDg1BynbA9zZcide1csW2xZ+dv6Pefzw4zzWO/LjWRISF/ev4dWM6nFnxpxJLii+gMLkQi6Zcwl7OvYQ1ILGdVeVX8VLDS/hU32mUZ0lqSX848Z/GKnD4bHoYE4pPt0x6Rajk5e3ieO1dyNEeCVU5eChL7C68gG83iZSU6vYs/cB00pVaupKBgcPIkQw/p2ecwQ5cPDzSJIg3LFOCD8DA3uNPRKNmHW5ik2XJdnKrrA4fSx/spjt2LLdXHrLO7j3pQfxCh9OzUHSix7urB3bnyQBmnwKUZ84k7gmExmZZdnL2Ne1z9gW9ieA5+ufPy1/inSnuKPSLX+aNNzuUsrL76Cl9R/j8KeRCXAZ6aujslXOdYIcq/kf05ZjNd9Fb1qtE8+fPJ56jtfeE7GPC8W2ZCoP9KzjjAV4li1bxt/+9rcz9fAWFuOmcaCRf/b8k5yBHMoyykzXlaSW8OeKX7PtpedYPlzB/qQavOrIikqb0sUn3vZvPPPYC/pKiwAhCV7O2IWMNOXCcSpcXX41T9U9ZVw+0HmAO5+/E2/Qi0N2oEgKqlBx2Vx8uurTfLrq03EDOSWpJabLEJtSvPmGzWy+YbOphryTmSUoHk89vb07ychYh9tdeqYPZ0K43aWsrnyA6rc+RHjCgxABvN4mCgvfxeDgCbxe8/dwZODCIkyQROMIigpvpqDgRmMFKvI9Ep3VI7SOKTtCi3MHy58sZgMNAw3satmFy++Ke315aQV/XvCbCfuTCDvTRP1pil1rTf4aLppzkSnAM1n+FM+dSlJLLH+aQk7Fn6zgTjyiF7JHgjuJ/Cm6FK687N/p7rYmaU2EMxbgsbCYiQS7PPjq+nGWp2HLdtMw0MC7n3g3XtXLn1r/xOYbNxsn3fC+pXlzSR4+HxHQwAcuWc/oCa/IFPpz+OGcb/Opui+iSiNjFDXE2MKRSGDGKzanEEB6pu4ZnIrTWFUCjDRgv+bns2s+a9o/XiAnETEpxW3V3Fhxo3F7VZ1ZYyaja4A3btgy6yQlM3MjVav/QPVb/woEkSSnsVrS17cLq7GymdTUStyuItLTV8esNI2gACqy7Kag4EZ27/lI3PdIZC2/ns5trUBZWFicnUT6U4uj0whIOCQHS5csNS2Qna4/AafuT1PEzrad7O7YPSX+FM+dwre1/GnqsPxpIkiUl92B399JcvKCuP4kSQpgQwjfqP4U7U65uVfR3d19Rp7VbMUK8FhYhAh2eWi7pxoR0JDsMvl3VVHdUz2yoqSOnFSj9824aQE9Dx2l0JvDL2q/Qv2NAdbN30hueyqt97/J8ZS9qEWncPKNlpOwsExRcAdAReX8gvNZkLmADGcGy3KWmdKAl+Us447n7sCv+vnZ7p/xyI2PjDvAE5NSHEpJnqlE91Dp7d056wQFwOUqQpZtaFoQSRp5U6SnryW6EbNOdBO8c4eBgf0MDOymo/N5ZFlB06IDPBLLlv4AIQJkZKyLeY+0tz+Nw5FtrFhu3LCF3t6dpKZWceSIJSgWFhZnH9FOtPNdzSOBDeGnur3aCPBMiT/F853TCe6coj8FtAAXFV806f4029wJLH869xCcrP8NQgSQJGdcf8rNvYaK+Z81srpG86ewO2VkrMPhKAYsf5oIVoDHwiKEr65fX0UCREDDV9dP1cIqY6qDS9FPqt7jvfQ/d9K8b20vqPoXeoEnm4qWYoIHBuncXwcClg9X4NQc+GQ/iiaDBKqkTVmKcaotlXm9hexJOTqBOx/h1aZXebXpVQDssp1vXfAtglqQqvwqnjv5HH41NMJT9fPcyecSjvCMJjqleLyBoTNF9CpCvD4rswH9JKrLtqZ5jXTYvr5dOBxX4/c/GnWLc1FOQD8l6kIihC9BWZbg0OEvm1Yjw+8RSXJSe+LHaJoXSbKzuvIBMjM34naXhlZXLUGxsLA4+4j2p+WeCiMg4ZAcVOVVEezyMLy/E3/j4OT4UySTlKmTZk8j35VPcVM6L6XtOqX7iPQnp+Lk55f/nJbBltPyp9nmTmD507mGJNmNfkWJ/Kmj42kq5n+WwsJ3GdtG86fwfjMtO202YAV4LCxCOMvTkOyysarkLE+jJNXNgxf9ma2vP8FV511Hbnsqnb/ZZ7qdZJdJqszDs7tDlxYJBl82994oDOTwi9qvsj+phjx/Fl8vvRdV0rBJNgQClZEvL0WTEZJAk079JDEQHGBPygA2TSEon94XY0AL8LVtX+PRdzw6IamIbggYZiIlXWeayAyM2VhDHiZatFyuYiN1OnI61LlORvoa+vp3h2q/463M6USuRka+R/z+LmqOfxfQa/Xf2n0r5218Zta+bywsLCzGQ7Q/zVu4mM3LN/NGzetk1iSR25FK6+/fhKDZa07HnwwiFspO15/6A/30B/qpS7Nh12wE5NMbNuBTfRzoPDDuRbAw8fxpNrkTWP50rpGeVjWmPwkRMGVyWf40dVgBHguLELZsN/l3VZl68AS7PLju6+CGwDqkAx0MLjYHS+xzUnDNTyfQOEDqlWX0P3kiYfC+MJBDYV8Oz6Zvxy/rUe4gQd6WfBEvDL1q2teQk7EyfAR8tP3dvFSxm2MDNTFXZwcyqBpcwlNZ/xz3Cle4CWAkAS1glKddXnY59+6+F5/qSzjCM1FDwNlI+Ef8bCXc5LBy1X14vU24XMW0tj4aMTkrMOrtwyQlzWd4+PjUHegMQG+QqFBW+nHs9gxDNnQUJElBCL8heS0tDxvi6naXhiY/3B2xihWYtWnpFhYWFuMlnj8VduWwcXMxIqDRvfugkaUTxrUiB3uWk0DjAMkXFjH4YuOE/Alg+dAC9icfM+07EX/6dOEd/KX7Idr95gb4AYKsHVxGdcohNHn8007j+VMklj/NLibLn84FIv0J4GT9ryKulQHNyOSKbr5t+dPkYwV4LCyi0Ab9DO/vJGl5TkzasT3LiTdi30DjIIHGwQndf2S6sVNzcOWBNWwr24FP8sdm3EiwcLico0l1I9tC0iJpEjd3XsVh1wlODJyIfSABbc4uttq3jTu445Jc3HvlvbQMtmCTbXxt29cIaAEcioNubzcNAw2jjkAPk6ghoMX0Et3ksHLVfUZDuxEcSJIUWnUZKVGK5mwP7oygcrL+tyxb+n3CzZTD24sKbyY9fTUuV3HcxoDhqRtv7b4VIQKzOi3dwsLCYiIEe3346vpQMpzYst0mf0IV4d94OjJ493finWCiTbQ/faDjWv4z6ecJ/SmGCH+6uH8NLYMn6Eru1o8tar9daQcmdGxhfzrQeYCfvfUz/Jofh+JgWc4yHq151PAly59mB5PpT+cOKifr7yM76yLT1uTkheRkX0Jx8S0AcZtvW/40uVgBHguLEMEuD60/qoagbiD9z54k58PLkewyzbRzIPU4ly57B7kFi+j5+5HYyX/jJDLdePlwhX75uDn9OLxCZddsrBpaSJ2rCb8cQNYk3tN5Fb32AUq9hfym4KHEwZvQdk0eMSi7ZOeTebfz07Zfo0U8AVmTuXBoNR+84iOsL1hvbF+Zu5LnTj7Hvbvv5e437+bne35urCaNJhyzsSHg2Uh0AzvzyhMUFryHwaGLWbpkCQMD1UiSnQMHPwec6/XOQQ4c/A+iP+RNzX8hP/86vN6mhM0jMzM3ct7GZ2Z9WrqFhYXFePEe7zXK14d3tpHz0RVG2VbYny689hpy6l0M/rM5JptnvEzEn2yaggBUWcWu2agcXER2MJNUNYlHsl/g5YxReuxEeZVDcvCxvFtxZSXxg0P3mK5TNIULhioNf1pfsJ7Lyy6nuq2awpRCY0x6ZDaO5U8zH8ufThWVru6XTFuGhg4zNHSY7OyLLX+aJqwAj4VFCF9dvxHcASAoUHt9eD+Syx0vfQrf/2/vzOPjquuF/Zwze7YmmTRN0iRNF1Lapm0IdNGWFpBVFARc8CpYEBVevFhQwHsVfVXuq1wVuSwWrggI1wXFIriUpVwpUC0tbVMa6EKXNE2TNM3aLJNZz/vHzJzMmSWdNMtk+T5++JjMnDnzO9M05+n3913w8Mibz/LMtEfIOM3gTphwunG87x89dA9vZe6ky9TDC7l/5w9TX8EasHDj8asod83QBUYJECshAQsaWty68atKruTjb5xNzbEDBIqMF6CoCm9kbmfrO++xvmi9oeY7156L2+8Gkt9NGo8NASci0bXjOTkfoqHx9/rz+fkfx3XEjsNRislkYsvbH0XkJEz8v+RNTS9QVnbLgM0jx3tauiAIwmDorW6O+T73mnKjP1U/y6+mPEjWaQZ3wgzGnzyqF3PAxNqG63iw6Ne4VQ9qQDFsfOmEsntMAROoGv6Ie8B1zZdz+fuVPFD4a8juf8kZmWdwpOtIjD+F/3vhwAuDzsYRfxobiD8NHbu9mL6+ev178afRIzopURAmNL5WFz3bj+NrdcU8ZyvLAnPEXwmzginbxjv7/4k71Cysz9fHP9/ZNKJrLPTm8am2iyjxFOg7UR7VS7Y/k/2OI/pjmkp/vboGnzpxMd+vuxUlFPWxaObgxAnAFrDymbaLKezLo6J3DtZAf2M4s2rWmzyHBSSS8G4SMKjdpJLMEq6cc6XISQoJN7CbP+8/Wb7sb3ptcxi3u0H/OnK3SojEZPiuoODKmM9VZEQQhInOQP6UVplv+N42K5ue7cepbqs2+NPbu98a0TXG8yef6ufd9P241eA6Aqpm6PVjCZi5qeOT3HnsBswBE37Vj0kzGfxpRedZAJzfYfzH6LkzzsUTcX3iTxMH8aehkxtVqiX+NHpIBo8wafC1uqh++GV2Wz9goecMKr96CWano//5Djf2ebmoDjNmpx1rcSatT73HLLKwzeqv+a7omTMq642uNTcFTPw9Z6vhmNWd52DXbJzfuYSzp1TyO8cLutR4FR9fbL6KKf5M8j25bLW+TYUlmNL86KF72L6kFtusbBbkLTCkEBdmFBrqxWU3aXwTvRsSuXMyZco5NDUFR3dH7lZNLhQSdfYMj+qE4M5TQcGV5OQsB2SXSRCEycNA/uRrdeGp7yJtaQEBlxfH/Dw61n+A5g1QarNgK4vwp97U+FNpX2EwKTO8h6fAuZ1VlPfNYEXXWRT683gu+1W9h49H8fLF5qti+jQvdpXzYPa9vD51B5fPupzC9EJ+s/c34k8TFPGnU5HYn1TVTtmML1Mw7WPiTylAAjzCpOHQ/r3cXPoD/Yb/m/0zKP9QcFemZ2cz7c/u049NW1qAp74LzRugkNia79EgstbcFDDx4+lPxpRk/TNrF48euodCbx5HfXU8M+sv+nPWgIUVXcHru2XWvfp1rzv0bQr9eaxZcD7+Djc2Sxbrr1jPtoNbyOvM4taNt9Lnj60XFzEZ/0SPLbVapwNthueam1/i4KEHQk0DJzIKqmolEOi/TkWxMGf2XXR27sThKGH69GsNteGCIAiTkUT+5Gt10XT/O/2VKSYFzePXmysXuseoP2lwefsqFrvKAWi0tPDMVKM/neGawXdLf45b9fA/U/8adCdvHmdZF3Hu3Iv1iWHiT5ODZP3pwMGfEW9E+MQi1p/ATFHRp7CYs7BYssnPv1QP5Ig/jT4S4BEmDe9qe/UUXbfq4V1tL7Naz8RV00LnhlrDsb1bmwzfR9d8jxbh932g4Ndxmyl7VC81aQco7MyjJu2AYXzo5098jEJvHq/mbDFcd03aAebMXUDrU++heQMoFpWpaxaw7I9FvJL2D/qKZHrDRCLeOMpw0MLvN9aLOxylzJjxZfLzL+XAgR/TfOJvqVjyqGAyZeH3d+rfFxV+moKCKw3TscITHwRBECYzifyp46VaY9sRv4Z7X4fhtWPSnxRotrZBKOEinj81W9ti3KmwMw8FjeMP7BB/mgScjj8BHDh436ivdTRJxp/y8y9N4QoF6cEjTBoWKWdiC1iBYE31gt7ZHH9gR0xwZyyyqKfcmAUZ+joy5Tmckhx+fGX3WWSsns75n70Ku2rvP949B5PTYRj/3lvdTAPNdJq69P48Mr1h/BMe8/n+nrvY8vZHcbnqknqdw1FKcfHnmMh7AJFyoqoOyspuiTvdQRAEYbKTyJ/6drekeGWnJsafCGboRJaLRfvTR6ZfwPIlq7GbItypdw6YFZQ0i/jTJOB0/Sk//1LUkHNH9/CbKIg/jX0mrr0LQgS+VheFnjzWHfk2NbYDLPScQfGsQjq9taleWlL4Vb9hB+pTrRdT4ikwpDzHGx/a/VYDuRll/PzAv1NjP0CFew7lyxZjLc4MNpT2BcCs0namj1tOBsu4rAELt5XdwqVVH5fdp3FO9JjPyHGUA+Fy1bGz+kbAR3AfoH+aiKKYSUubTU/PvkQvH1fkT/0oWVkLgdipGdHTHQRBECYbE82fVnVWsebEJwzlYtH+lOs1wR4vT1/wc7ZsfZ2KnjkUBqaSubJI/GmScLr+FDw+0ahdE0GfGtokubGC+NPYRQI8woTH1+rS02kLzfnMPf8c0iqCN/aTG+uCOzFmlYwVhXS/1QBDHOE5EkQ3DLysY2XcWvaYVGi/xsm/HqaQPArdwce7Nh2ja3MDaKHr1AJsr31bT0X2qF4sb/dSWDH6KdXC8HK6N9zm5pcievCEO1MGADOaphiCO4pipbTkBo7UPc54GxGqqnZOtLxG84m/cejwgyxf9jdDjX20zEWnawuCIExkkvInUyh6MgbdCWL9KTq4EybGn3wBMl/p4yLC/UM08adJxFD8qb8Hj59IfwpGGvs9SVXtlBR/QfxJGHYkwCNMeNy1J/V0WnwBTBlWzE4HvlYXWReWogFpFXmYnQ7cBzvx1nendL3xiJedMyR8ESLmh1lbsg2TwhZ0zcZde9IwZQyCshduLBj9nDD2iG4KmOxN1evtiHokgKJYKCz8JA0Nv9UfdeaeR07OMmy2Apy559La9ibjQ1JU5sy+E+ivlQ/v0BUWXhP3cwqna4dlT8Z7CoIw0UnWn3wdblp+sTula02E+JNwOog/JcLMnNlfB8SfxjIS4BEmPLayLBSLqjfEs5VlGXalFIuKtTiTk5vqx2RwJ8xINirUBSjjABXdcygiH1tZluGY6M9s2toqkZRxwGDHUbpcddQdfSrmcU3z4vN2Gh5rbXuL1rbXh7jC0WfB/J9SUHAFLlcdhw4/mNQO3VDStQVBEMYjp/InzAoK0He485TnSiXD7k8R06HFnyYuw+lP7r5Gw2Pj059MVJ31K3Jylos/jXEkwCNMeMxOB9PWVuGqadGrXntrWgxN8lp+WQOBsZFe3GhpGfJOU7LnMBWk4W/qBYKSMv/iFRDQdDnp2X5c322K3MnTvIG4O1SThbrWXrbWtrG0LJdSZ1qqlzOsdHRsSzwiXYluGOgb8fUMN4piZsqUSmBwO3RSXy4IwmTjVP6ETxtTgypGy5/si/Lo29XfYLpQy2fhJ8/H3+EWfzoFk9WfWts2618riglNG4/+pGK3FwHiT2MdCfAIk4ZwvfjJV4/E9jcbQ8GdW2bdq6f6rjv07UFLymDOEQ7uhHEf6iDrvGBjwOjdpng7eZORutZeLnngDVxePw6LiZfXrppQkhJ5I1YUC5rWPzq2ufnPo7ACY1Pn4UbTfDQ3v4TV6jSMPj0Vp5uuLQiCMN4Z0J/GCKPmTwqG4A5A5opCQ3BH/Ck+k9mfoP9rbYz+HToVmuYVfxonSIBHmLBE1jsb68jH7m/WmrQDerM+t+qhJu3AoNOKh3KO3m3HcVWfCNbWR+02pZ89jWlrqyZ9DfnW2jZc3mCdtMvrZ2tt24QSlMgbsd0+nepdN+mptSNNevqZ9PQcYCQDPAAHDv4M8BhqwZNpADjYdG1BEITxRnSvGPGnqHPE+Qi63joGflAsqvjTAEw2f9pZvSYqyEOcwM/wkJm5iK6u9xjpPj7iT+MDCfAIE5Loeufsq89I9ZKSInraQ0XvnFE/h+YNoEHc3Saz0zFpxSTM0rJcHBaTvgO1tCw31UsaNOGbcWZmVdznI2/ElYsfZ2f1Gsw92Tjay3HlHCKreC6tbW8QG4gxoygamnZ6ghGczjWYf0BENEJIiIlY4QkKfLgWHJAGgIIgTHri9YoxZdtSvaykGHF/sqrgSbD5ELrFiD8NzGTzp/nz/pP33r8dS+9UHO3lZJ45F3OOJc7ULBMzSm+i7ugvh1C6pTL8wR3xp/GKBHiECUlMvfOhjtQuKEmGY9rDcJzDWpxp2G0CYz35ZKbUmcbLa1eN2xry6GkG6en/OeCx9fW/xtyTTdk/7kUN2Aiobmo//G2UdDOaFgB8KIqV2bNuJz//Uvr6GvRdq8HvVA12d3jg4+O9v6ra0TQNTXPrteDSAFAQBCGOO9WeTPGKkmfE/SlRcCcK8afETCZ/am/fwrFjv8XSO7Xfn/aE/cmEpikE+xia9cbFTueq0/anrq7qIV6dmci+iuJP4xsJ8AgTkuh6Z3N+Wn9rD1UZMz134jEc0x6Geg5/hxv77Gx9HKpMfzASlpKttW2G78cD0Tdjv28PcEnMce3tW9ix8wuAj6z2FaiB4C6uGrDhaC/nZNpm5sy+21CLDcHdqw8tfyUiRfkLCXakVPLzL6en5wN6evYOy7Upio3Zs9aSlbWIvr5jhhKz8HP5+Zfqn0N43X19DbrMSANAQRAmK/F6xbjrusSfBoH408QlWX9qanqR996/HWBQ/pSTszxJf1LIzFxMV9e7DE9Je3A6VtibxJ/GPxLgESYk4ckP7tqToCq0P7tPfy5j9XS6/16fwtWNQVSC4ubTYhoAToTpD+GpDcXZDuo7XEPeOapr7eWin23C7QtgM6u8evvqMRvkia6Njp5mYDLPi/uandVrCO/muHL2E1DdwR0okxtXzn5U1UFW1iJOnnyX5uaXyM+/1BDkCX9dWvJFjtQ9FvMeRUWfoanpeQKBvmG5Tmfuecyd+13DzpHLVcesmbcBGNYXXmP4mOpdN+k7ZpWLH5fdJ0EQJiWR7mQry8LX4Tb4U9rSafRuaUrhCscQ4QrhSeBPG2qCI74vqygcsjuFmyxbTArP3LiM5bOdw7XUYed0/em997/R/33OfgImL6rfMoz+dC1NTc8zXP0Ki4o+TU7O8pjrEH8av0iAR5iwhOud2/643/C4a3dLgleMDgE0mtQOXLhxYKMgkI2KkpK1OBbmYT8zVxeSeA0Ax/v0h0ihCDPU6Q0bahpx+4I3VrcvwG+2HuGbl8Xe6EeLo11H2XF8B1XTqijJLNEfj04nDtdGh5sAZmZWsW9fW8z5gqM++1NzvWknOLLyB1TkrMMyw4ZFuTO0u3SjPhL04KGf8aHlL8fc3KdPv5a6o08ZRoeqqh2LOcsQ3Mmf+lHMlik0NPxWf8yZex5t7f8MvdZCMOAUuXtsITyZoq39n4b3jbx2RbGQlbUornhE7shpmpe+vmNxP2NBEITJQGSvmI6XDhuec9W0pmJJOmPJn6ZcWoaaYZ3w/nTxzzbRF/Kd+1/dP6QNrcgmy16/xuce38Kvb1qe0iDPSPhTZN8ab9oJ0m9yYG+bhVbYrfvTjp03EO5nc+jwf7F82YbT9qfsKcvo6HzH8L75Uz/KiZbXQq9VQ/9FZgP1+1Nj43rKZnzZELgRfxrfSIBHmFBETn+A4A3XnG+8Eflbhidj4HQ4rDazxbKfHqX/l3W6ZmO5t5yZgfxRX499vpP0s/rfN97OUvSO3njbfYoUijDDPb3h8TcPk5NmTXp3K5xRNBw16FubtnLzqzfjDXixm+2sv2K9LimJaqPD//n9fiBWUCJ3qcDMjNIvMn36tfoNPoPZNDb+0SAdmuahufklZsz4suFcwZKtl2hufgmvtwMAiyVb/zpMVtbCmMdycpYxd+53aW5+iYOH7keLmC06veizeL2dNJ/4W+j93Yba72jx2Fm9hg8tfyVGUoLXaicQ6ENV7ZJeLAjCpCN6cpav1UVvTQt97xvvD1r38E//SZax5k+W4kzss7P17yeqP4WDOxDc0BqKOy0ty8ViUvD6g/dyvwbXPfE237h4blL+NJzuBKPhTyYWzP8JzoIPwUyAaWQwmyNH/ptwcCd4/r64vWscjlLOqnyCpqYXyMn5EG53MHsu2pWsVieRwR1FsTBnzp0UF38uYpJX/5+j+NPERwI8woQhstYZswIo4AuAKTW7O9EcVpt5zbI75vEe3Lxm2c1HvAtHXVL63m/F29SNKc2CpTgTf4c77m7UeJz+EFmWFZ7aEGao0xsuqyjkJy/vwxvqReALaPxww15+8sq+U6YcR2YUDTWT6GjXUV1OAPp8few4vkMXlOh04mRuvsHdrJ0sWPBL0n31CcdeBs9lbMqXiL6+hlCApv8fB4piQ1GsaJoHRbGRlbWIndU3Rjxv1b+2Wp1Rr7XQ0Lg+alfLeH3Z2UsMTQI1zZuw+V84cBQZQBIEQZgMRPeJca5ZQOtT7/WPRh8DjEV/6tnSSN/+NkBBTTOTVhHs2xMdzBnv/mQ3q3qQx2ZWh+ROpc40nrlxGZ97fAuhGA9ef3L+NJzuBMPvT5GZQOEsn4HGhkeiKJa45w+WQH2RQKCPpuMvoGnBYEy0P02depEerAGYM/suOjq24fG0xm2ULP408ZEAjzBhiKx1xqehl3L4teSmKY8gATS2WEKlYtHxptDatlj2M8M9dVTTjeOWq6mAooBfG7dNAaNF4Mk1S6jvcA1bD55SZxrPfHEZ1z3xtr4TBUFRue6Jt3ntjvMSnj8yo2iomUQ7ju/Q5QTAolqomtY/ujMynTgZ0TjadZSrX7yaPl+fvpvlcJTEPdbhKKXqrF/pu0Oqatcb8IVxueoism+MkqFpbkOTwWBZWGRGUIADB+/j0OEHqVz8uC5aimKhtORGQ116UeGnKSu7xZBe3NGxjfnz/pP399w1YPO/yPeN3sUSBEGY6ET3iemtbo4N7igEN8t8oy9S48WfTr5cG1xQYPy6E8T601M3LGVXfQcw9B48AMtnO/n1TcsH7U/D6U4wvP4Uz51KCq9JeHx+/qUcOvxfBAJ9KIqFsyqfijm/y1XHgQM/1kuxAoFIP4r1p0gOHPzPUF8cm55hE26UHHz+Pv1Y8aeJiQR4hAlDZK2zIYMHjMEdBUzTHPibXKO2tia1w5BWHIMS3IlqUjsoCuSM2rriEoDwBzZemwJGi0B9h4tPnl08LOeOTBF+7Y7z2FDTyI9f3qv/qHn92oDisbQsV88oGmomUdW0KuxmO32+PiyqhUcvetRQQw7Ghn0DcbTrKI/vfpw+X1Amonez4hE58SFagCJruOOhqo6Yxn39ItK/cxQIuOjrO2YQLYCj9U/rO2vRchJZN39W5VP09R0bMBNpsFlOgiAIE4XoPjFplfn07jzR708QVIKAhmNhHt52F776nlFb37jxpwngThDfn76yevawnHso/jSc7gTD608bj2wclDsFg0cbEgaPEvtTMGs6WX/SNDezZxmndblcdRw6/KD40wRHAjzChCHu9IfnP4jtuaOB/0TfqGb1uBhATk7juFHDPP6aAoJRBOxmldZuN3WtvTHSECkbwClru+OlCH9l9WwWF2fru1GnEo9SZxovr101LHXkJZklrL9ifdwGgdEkaiQIUN9Vzyf/+kldUADsZrthNysRiQQosoY7jKJYmD8vuLMUTxj6U32ViLpuh35s5PGJdtai6+b7+o5ROMBO2mCznARBECYS8frEZKwopHtTVMPUQChrxayO6vrGqz+Zsm2pXsJpEelPFpNCcXb8INVo+9NwuhMMrz89XP2w/r3NZBuSO0Eif7JxVuUTCQMuifwp3gQs8aeJjwR4hAlFuNbZ1+oauIbcr5GxupiAy0vv1uMjvi4Hyd3okz1uuLDOzMI81YHF6UDNstH+h32GqYtZF5WOyx2osAhsqGnk/lf388MNe3lg4we8vHYVgF5bvubJrfT5AphVBVUBT0gwwiVd0RKRKEV4+Wwnr91xXlzxiNcUsNSZRqkzjbrWXp7bXj8kWSnJLBlQTCA2ffjRcx6m92AbpfPLAdjRvMMQ3Ln6jKu5qfgL5O634itz6X+nkmkUGT4us7AyoqwqmBocLRqRGEu0PMyaadx1iiaRHJ3OjlKyu3SCIAgTkcg+Mb5WF92bGxMf7AuQtrSA3q2jMy59rPuT6rAAGt1vNUBEyZG/Y2wFnJKl1JnGk2uW6EGXG57apve7iezNkwp/Cv8X77nTYbD+NCNQxA9n/F/qs1uYP2sREPQnj7+/YfKtlbdS6MmjZ/txQ9Ny8SdhNJEAjzAhMfTjAcwFafiaeg3HdG+qH7X1FASySdds9OCOrSEH0CA9NPJzJHEscqLazbjruvA19+I5fBJPXRcZK4twVOSR98WFtDxRE5QUk4K1OHNE13M6JHtTL3Wm4cyw6ePMXV4/G2oaeWDjB7i8fkxKv4v5Av1S5vL6dbExqQr3f2oxV541nbrWXg40d2FWFXyB2J2mSPGIXGuipoDD3TBwIHYc7w/gZPemM+WpLqZpGfS9eZj2j/iomt2fqmw327mp+Auov2ikPU7TzejeApE7W4WePEOzziW3vECXUp3Uzk6wqZ9NbyCYlbXotEZuJtpRCteVyy6TIAhCYty1Jw3lWaY8O/7WPkPG82gFd2Ds+FP60mkARn86cpKcT80l/ax87OW5Bn8aixk8yfpTfYdL748TDsYAurNMRn8q8Dh54NCd2Pf5cCgObj3jy9w6by1V+UZ/ujBrdcKm5ZH+FJ0VFN3sfDD+ZLdP10uzVNUxrP4k7jQ+kQCPMO6JFxk39OMxKTjm5tAVFeAZTVQUlnvLg1MgNIySEro3LveWj3iDQFdNq95AWcev0b3pGN2bGyi4/WzybqzQJaX1qffGVKPAwdzUw0IRHsnpsJgA9B0kf4LyPMMIz4DG156tBuCuP76rB4ssJoUn1yw5pVAM1BRwuBsGDkRkrfnivrnYtaB42jUbfNBG7hQr6899lh2e3VRNqyJ3v5X2BE03I3sLxDQWLHsaJeI4pTGDwrMTp/dGoygKmhb8Ed1ZfSOa5kZVHSxf9rdBiUX0jlJ0XflgzycIgjARScaf0hY46You1xpFxoo/aUDvjmZjo+kAtD+7D1OWFfvs7AnjT8XZDt2F7KHJWZHOMhn9qaJjjsGdrjx+Hm0Zx8g1Vw7anxqtLTFNmXNrrYbjkvWn4KStm0JNlS3MO/P/Ub3rptP2nUh/Encav4xuIa0gDDPhiHf7H/bTdP92+g526MKSffUZhLcZujY3gim1a50ZyOcj3oWkR6URp2MbvRGfARLfmX0a7tqTwbRiv7FRYLL4Wl30bD+Or3VkGljHu6nHo661l4t/tolHNx0K7iQp8IUPz2BxcbYe6InGalL4t8vO5CefXIwS5YlPbD6sywkEGwGGp0qEy6zqWmMDiOFadogdzT7Qc8NJeJfokY88wr0r7uWzF9+IW+lPJ557pIDOPx5A/UUjl+dcTElmiS74gN50M/y936zRNjXYYDMyM6jP10eN44DhdYPp3xSs/e6fFhFONw4EXNTWrsPlqjvtzyC6rjx64oQgCMJkI9qfenY207M9WLLuXLNA/CkKb0N3wiliPVuCJW0TxZ/WPLk1IlATYENNI8XZjkntTxefeyWBUFqEhsZlnStZtaN8UP4UzuyKdqcdx3fEvC5Zf4r0G03z0t7+T4PvDMWfxJ3GL5LBI4xrDKVYfo2WX+4GVQ2mFxtzSJlyWRn+Xi/dbx4LBjpUglsyozj1c2YgnxnuqTSpHbhw4wilFY/maM+B8Db3Yi/PMUzUSPYmE51eOhI7V8lOUdha20ZfhFD4NXh00yF++dZhfvLJxTSd7OP+V/fj9gVQFfjsklI+vriIXfUd3P3Hd9GifibeO9Zp+HECuP/V/SwuzuaGp7bh8vqxmVXuuKjcMEZ0oKaA4ede2vsBJkctirUViN2BSjalOl4TwMgMG5vJxq2Vt1I1o4qTK45ieysoekroZy8yMyde083Alwp56MUfs9O2h443e1h/xXpDZpDdbKfijEqmrc1LqtY8GmPttx1N0/QgT0Pj72k6/ufT3j2SSQ+CIAhGov2p/dl9QPAfl5kXloo/ReEdYHKY670WujYdxVKcOeH8yRuAH27Yi8WkjJg/WUwKz9y4jOWznfoxQ/WnwfToSdaf8q/Lx/vGCYoPTgGS9yfnmgWGzK6qLy00uFPVtCrMmbGvS4ZovykouJKm43/WAzND8Sdxp/GLBHiEcY2tLMsYyAkAgX5hQQ0+plhUHBV5mJ0OY510WFJGERUl9aPQQ1hmZuE93L/D1L2pnp5/NOBcswB/h3tQN5lIWRypEaHJTlFYWpaL3awaJAWCO0dfe7aaey6fx39es4g7fl+NX4PndtTzxx31MceHCW/aqQqEy83dvgDPbDmi74i5fQFDM+fohoTh3bLINSvWVn5RexN9vj4e3RNM041s+JdsSvXWpq3c/OrNeANePd23JLPEsEuU48rg3dc284fM36Kg8F/Kndg1GxoaCgp+s8YbylYquiopySwxNCzv2X6cGuU9NmS+RYHHycqWxWyueZ1rP3Rd3CkUp/PnHl37DVBbu46Gxt8D/btHpxPgkUkPgiAIRmL8KYTmDeCt7wazAj5N/CkBluL0/qBPADo31Oo9V8a7P9nMqiHrBoL+tPbZah74TOWw+5PXr3HdE2/z2h3nGdxpaVmuXh4WvoYwA/nTYMrRBuNPv0n7FQDrlG8b/EkzGaemRftToNtjyOziqDuhOw32zz2e3yxf9rdh8Sdxp/GLBHiEcY3Z6TDUPGMO7eREpNFmrp6OrTxXT5WNTKElzv1IzbISOOmJfWIC4q3rCqZe+/sf07wB/B1u0s+eNqhzRdbtD7Y8B4I35C2HWkjv9Q14XLxmfPG4umo6v9l6NO5zP/jrHkyKov8YRItMIgJRMvu33bGTRlxeP4+8foDy/Az+34a9+CNeFC0a8dJ0IwM80SnVL+39gC+vWGx4v6NdR3U5CZ+n5oNqcjUraSYLJsXEVHc26w4FhcTd6KY6fR8bs7bQZG1hv+MI07xOatIO0LS7FXuEKB2tO0Tgv+sx+RQqLDmcNX0e3znyZeyajb4X3RydfoiS0lmGNSc7LSIe0b1zyspu0Xeihrp7JJMeBEEQ+onxpwhcu1vApAzan8i0QJd3hFc+NvA29k5If2rocOHzx3ciDfjas9WY1OH3J69fY0NNI+29Hh5/8zC+gIbNrOrvMRh/inanx97eyM3nnhUzMSuRP+Hq5rivHrNqJq9vSr8/YfSnFksHdzRcj9Vviem5FOlPmPrbR2lofGv3d/mPRT/lyjlXGtZzuv4U7TcOR+mw+ZO40/hEAjzCuMc+O5uCO87Wfyn21rRwckNt8MkAdL15LFhD7uvvaK83EIzGpEya4A4Afg3rzEw8h7v6HzMpg5YLIG5aarJE7rbYTDB/fi8zp2bGHBO985TosYt+tumU0uGPziM+DRKd4dlt8QNLkXXvW2vbKJm6ICZNN5KlZbnYLQp9Xg0UD4/uv5PLFv3SICk7ju/Q5QRgum8a8/+YRbt/PzMVK1NnZXNp+wq9OaANG8t6guM93bi5p/QRw3tm96bzyovrqTxnOc+++hS3+f4FAMWrsaq9ytBksGbnDgrTC2ncW0uN4wAVlrkov2sGv4bfrKF+uZiS0llxP4tkREZ2jwRBEEaOSH8yZdvorW6md1uwDw9+bXD+pCqTJrgDTFh/+vwvtyRs1RjGHx2tOQ2iz2BS4Ccv7yXyRyvS4wbjT5HlaCge/nTsAV55sTcmSzrSnwo8Ts7tPpsF67NRfC18hLk0TF1NoScvoT/9KffvWLEEr8cboPEv71OzsAFn0TSee/FJ3Z/w9/cGV1CY1VPExiMbua7wWlw1Lfh7vYBC9+Zj4BN/EoaOBHiECUFkWmNaRR4nXzkSt2wr3NHeuWYBXW/U497XbjzRqe5qExDPkf5UbEwKeTdWnHZq8Omkl4Jxt8Xth2217QZBMQhMqNdNZP12eGcH4JHXDyS9ozTcFGbZaDzpTvi8zaxSnO3Qr8ViUvjptb9Cc3xgSNMNU+pM486rvPz4zfWY0mrxqm08t/85Zk2ZpR9fNa0Kq8mKx+/BpJio6JmNyR/c9bJrNq5puZDLO1fFXw82/l/dbZgx48HL/UVPs7bx88EMnZou6kua6FPc2DUbXpOP/53yNuedPCf4vOLmiFLPsfu3YvKrlOPAxzEsoduKyafw4Is/5l+/8O8x1zWYfgOyeyQIgjByRN63zdm24KSo0/GnYfhH/3hjvPlTuNdNUYSHOCwmnlyzhPoOF63dblKkT0zLtNEwTP4ULkd77O2N/OnYA6jWNvp8xPqTdSGXda2kXm3i+0dv1QM5EPSjm05cg5ZgK8+GjWvaLjQ8puzppXxvGl+d8y18Nq/uTwE0Q6+oTH86Hxx6n8bfbUeJ07hb/EkYKhLgESYc8cu2FMJ3rd5tx+nd2Rw/mBNZJDxBsc3Nxr2/o3/7JKAx5ZIy1AzraZXVDAeRuy02EywpM9bYGwQm1Osmchyny+tnQ02j3vhvuJhXkMmepq5THxhioOAOwB0XlVPf4TLUnX/9d7W8dsdFlGTGT5uuyFuASX0RCO4w1b31Hn9Le4E2exffLvwG8xtLObejCiWg8X7aYRrMzXjwYsWCGzeXdq7UGwECes14+Gtz6DZgxcI3Gr6gf2/XbEzzOrll1r1U9M5h3syFTDvs5Dslj+glXQtry7ncfzYQlJ1IPHjZadsTU3YGsf0G/vn265SdWxFznCAIgjB6DM2fiF+2NYEY7/4U7nXzxZUzDSVM1z3xNl6/hkVVhu2PMSfNQntv8hldAwV3YPD+VOpM44qK+fzp4BwCHKAIRfenFlsnP5v1/5j1t3RuC/wLAUVD1eI3607GnyKxaVYubF1Kve247kvXT7mWqXv7HanL1IPrcHfc4A6AW/GIPwlDQgI8woQknHbcW9OCAliKM42pxwl+qVqK0oPNBScwmatKyFxVogtcZAPFVBHebQnWkDdSmmu8Wcdr+ueNEEy7WaW91zPsmTuDCe6cCpOicFlFIQ0drmD9eiiQ6PVrbK1tM9TFh9Nv31cD3PmHDzg38BmacPMTJQ27ZsWjeHnffpDF701HIcDXuQ4FBTduUBSsWPAqXl7N2sLHOlfr5w3LiQ8f+21HmO+ebVijGXN/00A0vEqwnn+KL4ML/7mIj2pVuHHzzNS/ALDbsR83bmzY8OLDjEl/7f1FT9Pu6I4pOwNjv4E+xc33j91Hx4s9MenTgiAIwuhin51N3o0V9FY3k1aZjznbxsnXjybhTxkTx5+CzVJiGK/+ZFYVfBHO8Ys3DunPW9T+zTJvQMM0TBudgwnunIrB+lNDTQtbWrt4851jTAlcA3hZp2Rg16x48fHylM3MeN+mZ9WommII3vgIuk9kACfSnxRUTKgJ1/vptkv0Y3+Rv54p+/qP9eEj05/OfscR3HiwYY09gQY2s038SThtJMAjTGi6NtbpaYzONQtwVZ+IXztOcNKW7YzsiSMoCQhL25SLZxDo9aKkWVK9JCAoKdOzp1NdfSLuc3dcVM4PN+yN+9rbLyof6eUNGZMabF54w1PbYhovh8eVbjnYymtbjnLdnm5Un0YOGk+Qjh0FD3asoR0mq2ah0nWmfo6wlNiw6VJq0Sxc1rlSP8ZPQBeSeLtO0edSUPh6w/VoSvD9woTTlj/f8jG+U/IIiqKChl6aFX6tRTNza+WtBuE4WneI2pp9lFXMhS8V8l8v3Mcu+z6arK3gg41HNnJDxQ2D+2AFQRCEYcPX6qL1qffQvAFc1SeYtraKrPNKgpk7CYI7E86fEsQ3+va3Y8lPI+/GCrz1XaM9RCwhp/Knm86dyaOb+oM6kQlYXzx3Jr9867Ae5BmO/jrDzWD86fPvd2Pya3wIjQ9jx4WNJ+jDrgUDKRbMho2vMJGZOmbM+CO7Z0c8P5A/xTv25uZPxZz7M22X8om28/X+PdHYsLKu/AHdn3ytrv5eh2dUxvWneNk+wuRFAjzChCU6jdHf4ca5ZkHciRGW4gwyVkyn/bn9qVjqqNK77Xj/TlyIro11TFsb3Ck43QlII83i4mzD91aTgsev4bCYuKyiEICfvrIfT4LpD6nG49cMY0EBls7M5Y4Lyyl1pvHCzmN87dlqLsWCSvCzt0dIgRUFv6JhSpBGDMb0YQATJsNzkcxzx2/eF4kFS0LRtWs2Pn/iY4bgTxgPXtrtXVw4o78+/WjdIdzrDjFTy6DvzUO8c0UjL2f9w/C6R6of4cIZF4qkCIIgpIh4I7uDjYNj01qsc3MwZ1mxzcqeFP7Uvak++IU5NCPep40LfzqvPN8Q4AlnRDssJv5l6QzmFWTxtWerU7fAUzCQPwH8aMMeHt10iEuxYAr5U9iFHCjMU0z4ie9P0d4UfizSn5J5TSISHRdd1m7ArFB4ZhkQCu48sB3Fq3GG4uCW8pu4Zsm1Mf5UmFGY1HqEyYEEeIQJS7yxk+7ak3Frx7313bT/Yd+Erx9PhOYN0FvTYsh4Gqhx20jS1O3jjzuOsXxWHqXONH3SQ2u3sT776xfPpb3Xw76mLn7y8j78mkZVaTZbDreN+pqTwaLCxj2RgTWNrYfbuOGpbXzj4nJ+8Nc9ALyLDxcaDhT60FAAWziNWFV4v/go844U66VQkfIwkHCYo2RFQdGzenz4MaHGPWciNDQWucoNx3vwohDs5/PdupvZXPM6KyrOoySzhNqafczUMoBgcGhqXYY+ASOM2++WXShBEIQUktCd4pRAe/a14wF6tx+fXP4U8VmMVX8C9ClZ9R0uw3F3XFTOkdYedtR18JNX9jJG98V0rCYlrj9d/8Tb+AOarvWR/hRZbn6BZkUzgdfvDW5cRRDpQpGPDUTka6JfmyzhTbfwGiPf1ef38dz+51hRcR65tVYUb/BYu2bjnLZ5AFhUi2GCamO3cey8MLmRAI8wYYk3dtLX4U5YWz1h5cSkYJ+fS9/u1oSHKJZgJXL0rt1oC0pdWy93vNKC29+iT3YIT8qym1V918liUujq8xp2pMY63ohpJEGCt3KX188P/rqHIhQWYeZdfNxJD18rcPJfTa3Mw8St4R0pP2zw/C9PlbZyfudSdqXv4/aG6+LXcCcgUnpMqKFGgf3Bn0QNBaOJLOUC8OHnlSn/0FOfLX4ze/+xnf1bdrGy6MPkzi7CTbe+a1W+eyqPXvcwv236A3+v+zuegAeLapFdKEEQhBSScGS3WY0b5AEmrD85FjlxvRvHnSIyeMaiP9nMwTX1hbJ0nlyzRG/EbDEp1Lf38putRwHYO4y9BkeKkpw0Drb0RDwS2lQKRXai/em2nGzea+8hE4ULQ36k+OEfmdU0WYJ/np9ovwCbZsWreNmW9h4f7qnUz36qjS4NjfdtB5nvnn1awZ3gFSh46Q84Rb6bWTNx7M29vPW/baycswpMwfUDXNfycaxZM8lfkc+33voWfs2PzWSjra+No11HZYNMACTAI0xwIsdOhuvKx0zR9GihaZhz7f1ypkDWR2diSrNgyrbh73CH0q/hZMQOVPix0WRbbTvu0E3M5fUbUnL7fAFuWT2bx986hNev8fDfD476+oaP4G5N+OsiVH5Fhp61Y1EVTE1ufkw6d9LTn9GjuKlJO0CTtZXd6Qco8DgNozfjv1N/QAf6d4uiAzTxSDYFGYIZQpd2rjC833UnPhYM6BwHd3UPL+Zt4lMtFwfP7dP47StP8HLWP7CqVkyKCW/Ay62v3RrTLDDcdHospr4LgiBMNOKP7J5s8gSq3QwmJZj5rSqknZOPxenAURHMkOkvXxtb/hQ5cMLl9VPf4eLJNUv0aVnPbKkb9fUNBWNwJ9KfgsGdsD95CP5xmdp9lGPDjYYbDVvISVZ3LaFPcXPLrHvZnvE+99b9K1bNwjk9Cwzvp6BwzNxMkW9qjDOFv17oPmPI19Uf3IktEQs3amZnNwECKKFAkk2z0rD9APd034Nf82NWzAS0APdvv5+f7/q5+JMASIBHmERE1pXHZaKOSA9A96ZjYEK/xq5XjsRNIY67azeKLCnLwWYCtz8Yj3rl/Sb9OZtZJTvNYpieNX5RDF8vwowj9JgdRd8NdaBQMmU7N095h8vslbzsf50maysFHicVvXOY21tmSDeOLpdqtJxghrco9C7JlXINBXNUo+XIGnObZsXpnmIIABW68iiwO4NNAkP0+foMZVq+VhfHH9iR8tR3QRCEyUqwRGuAe284CDLB6Nl2PBhPUAEFerceN0zOirwXjSV/iv7jKM52UN/hmoD+hMGfrGCIQ9pQCKyezu6Dm1lYXwYEy5zWNF+BLWDTmxxbsRhKrTx4KfA5426EjYQ/narcXg2V0oezrZ1vm7hi6io2Z1UH/Sl0zeJPQpjTyysThHFIuK4cALNCxuri/vuEApnnFpGxupjM1dMn5t8MP3oAK5xCHI3Z6SD97GkpuQFsOdjKuk2H+OyCDCwmBV/AOAr9kgXTgGCMaqJhLrXhCt2h+9DoC3+teNibt5GTU46xuGop809WsqLhkzx28Lt8vfELXN65Sj9HtCCoKJR6Cw3Pjza+qCkU53ctNQjTZ9ouZd2hbzPdOw2rKZhGbTfbqbIupGf7cX3nKTr1fTAc7TrKCwde4GjX0WG4IkEQhMlHtD+lLS3of1KFzJUT1J/Ct80AesRkPPhTdBznz7saaO12j9DWTirR2B3quwNBf3JHuI7fFCC/PJfSstl4FG/oFcFMnuU9iwxnCgd3wuXrAzVZHm5OFTTy4TOUgtmwctOJa+L6U2FGoe484k+TF8ngESYN0XXl7tqT/TdvDbo2HUOxqGRffUbiTORE/XvGKqoCihYM7phCNxC/lrIU4kRsOdjKtb/YMuAxL+5q5MVdjfplTCT+UtfBDiwswkwTfuZhIhMVRfOxomMlnzjrY+Q+52Oe75qE5VXRghA9ynOksnYG4qUpbzHVl8OykEjFW4Nds/HjWT8ge0kxO47voMq6EPUXjbSHdpycaxbENPxMlqNdR7n6xavp8/VhN9tjUpcFQRCEUxPPn3q3hjJsA8n5U9ryAnq3NMV/cixiDt2vfNq496dfbw2WZIU6B00QgqVax9D4At0Gf5qNwgzrCd7M2cqXnjIxxRvsNgjJNVAezeDOqfDjTziaPdqfCjMKufW1W/ud59xnUcWfJiUS4BEmFdEpteF/OIbRvAHaf7/PeAdUoG+airO8AFO6lZMbakdvwYNFgZxPz8V/MrhTE64Td9W00PnqEV1UnGsWjKk0zeerjyV97ITIMI7BTAMa4NNryYOBHBu0XkJgvQc1cOqeOWMJDY2a9APk+516gCeMDx8BNKxY0CwK8xZXYs50UJJZQs/247RH7Dj5O9ynnfq+4/gOfUpXdOqyIAiCkDyn5U+AJ0dh6oVzUFHGdoBHgYxV07GX5xp6E04kf5o4vbCNfXji+pOnhDOPF6NE9B9M7synniQ6mDHpp0P46gKqhilginpOQ1MUVI0Yf3rhwAtG5/Hs5vK1F4s/TUImUiKlIAyK8I5U1mVloYkIBHdpouTEekY2vXPNZF1ShinLFnMeAHNB2sguNlk0IKCRtbqEzNUlupCpGdb++nm/hr/DPeBpRpurKqenegkppwiFz2PTa8kN5VYBhUCS+26dpGYihhb6XxgFha83fIFMXzpayE8CisYuxz78BILBHRNMXVNhkA5DKYBJwZRtO+3U96ppVdjNdiBU+jWtamgXKQiCICTvT+XZdC+ykFY5NWF9tZqT/BTIEUUDS3469tnZ+v1G/GmsolCEwqVYKAp9Hc+fFD28kxzJBm6GO7gTXUKvAG+nv8v63NcIhFIxAooWaras4MWDdkEOhWvPNnhR2HkKPE4u61pJlXWh+NMkRTJ4hEmN2ekga3UJaRV5wZItVaH9D/sM2xye/R3k7IeO3oO4djTHPY+vqXfkF6sCDNwIOlEKZvgfzeE0TVO2jZ7tx8dMV/3ls53csno26zYlnoz1uaWl/G7bUfzaxEvhiZwCEdmEOHJqw6mmZYXJImMkl5qQeMJjwcynWi/CrwTQCGDWzCx2ze1/jR+89V3YZ2fr/XZM2TbSP1xI91sN4Ndofeo9Al8qZIdnN1XTqga1g1SSWcL6K9YHS78G+VpBEAQhMdH+5O/1cvJvh/vTD7Tk/CnQ7hn5xYaDT/H8KbTWiexPy2fmsuVw2yiuamSJdKZwz0J7lDfpDKK1QqoypOO9b1XPfJb1LMKvBPCF/CmctWTTrJyob6Tw7NlAsJyq5oNqKlxzWL/o1wSebcLkU+C/Gzl5kYW0UFPwwSD+NL6RAI8ggP6Lr+ln2/uDOxE3BQVwbTueiqXppJ0zDZPDTNem2HTctKUF2GZkJRSOyPp5U7aN1qfeG3Nd9VeXTx1QUA6d6GZZWS7/ONya8JjxSuQUCAUFHxpmFPxoVOPlbJLf4RyLJVwmTSVRwmjby4fpyHWh/v5E3Cl3mjfAQy/+mA2Zb51WHXhJZomIiSAIwghhdjrwdbhp/8N+/TFr2RQ8hzuBMeBPKmSsLEJz+ejZGrUOk0LejRV6SdZE9aeTLu8ormbkiZk8GiLafwKAOk73BC2hf6LH8ycNjan77Ry7fxst19v47j++wwP770TRWtBMYPKH+0cFOLmhlq6Ndaf1syr+NH6REi1BCBEzBnSgm8JIdPo9xSl7tx6na3NDbJqzClmri/XGh75WV9zXh9M0/R3uIXXVT5a61l6e215PXevA2U3h43bVdxgeXz4z1/D9Pw+3TcjgThEKpah6iq4WCu4AmFBYjBkPvlQucUQxBRTe+suGuMEdAL9ZY6dtD9BfBy4IgiCMHXqro7JzrAP882K09yAC0L3pGD3vxAaZcj5Zjn129pjyp2TdKfLYaH+qLJ5i+P79ptSUbo8U7+LTM3fcEeXh0aVOfgJJTxBNxaTR0yUcyDL5Ff76t99zxskS7FqwhYQSOVQlxEi6vjA2kQweQQhhK8sKTk0IB3nMKjnXnEHv+y30vdeKEgDMClMumoGjIg9fh5uWX+6O7VoXLx3UrKA4zGhdCXZRQs2R4zUoNODTyFg9XS9fCb/W1+FOelcpOt14JKZB1LX2cskDb+Dy+nFYTLy8dhWlztg+RZHH2c0qVpOCJ3Rd249MnHTiRESmGYeJzOABMKPiQeHFtBo+2rtAfzwZRroR4HDRYGomYNJQ/RFrDf1d65jppePNHvBJHbggCMJYJK0yn96ILJ2sVcWwqpiuLQ0x/mQpzqTlyffAFyeoH8efFIsKdlNCf7KdmYP7QIdxgy4eAYL/8I2Y1NCx/gNMWdYx40/JulP0sdH+tPtY57CuayyjYOy5E4klTh5DIi+KLo0fK/jwJZyiBRAI+GlxdOJVvFi04OCKqWsq8NZ36c3Bx9rkN2HkkQCPIIQwOx0U3H42vTUt+gQqs9OBfZGT3W/tYHZaMY5Z2fqN3+x0UPD1c+h46TB9u/szS9KXTKN3Z6jcxKyQXpVPwOXHe6IXX6IAjwaBk24KvnEO7S8exL2vPe5hikUlY2khapqlf5qXP7h7Fr2rFE9Qwn1OnGsWDJiSPFS21rbh8voBcHn9bK1tiyspkcf1+QIsm5nD24eD154goWNCUITCIszkgCG4A+BC40f0cg9pejDHisK7vWW86/wz32r9eNIiMlZEJV5foTBefOzM3McnOy4GFFAh89zpaKHmiIXphVIHLgiCMIaxz84m70sL6a1uJq0yH/vsbAAsZZlx/ang9ip6a1o4+coRQ8Alc9V0uv/ROCh/cu9rJ++mhfg73LiPRIxvj0KxqDjXLKC3ulkPRmnewJjyp2TdKfrYaH+amNNGg4QbKtsj/MiDhjWBY0Q/5wdMcY4bi8EdD17CA94T+dOBtHruPfpVzJoJTYXcq8vx1nehAXk3DFx+KExcJMAjCBGEmwZG4mvrw9ISwLoq9hek2ekgY3mRIcBjnRmUGA0wZdlof3Zf/PcqSDM0Zw70ejE7HeRcMZvjD+wICY5K1kWlWIszDb+k0yry6NpYp+8ipVXm46o+MeCukq/VpZ93pGvHl5bl4rCY9F2opWW5pzzOZlZ1OZnIRDcH7EPDHvr6l/SxCR8NaLTSw/2kY0XBhUYTcMnJJQl3qsYqfbixE0odjhEvL98ufYjy3hmYAqGdtgB0vdmgN8M8+eoRCm8/myvnXDmq6xYEQRCSxz47Ww/shEnkT2HXinYkc0EGWReWntKfDGjBZv2Zq0uwlWXh2tk8oD+Zs20GXxpL/pSsO0UfOxn9KRzw6EPjD7jpBPbiYx4mbsKOLfTcD6M2zBJlQY9Fp+ox9ZLjD5bbKSgcMx9nmi8PMyaDP5n9wVGlSoBgL6xwM3GzQsHtZ0twZxIiAR5BGABfq4uWB6uZ4g3QUl0dd+cmemRm+3P7g9snZhVLvPHpoXIs/0l3fxYOoKRZAGNDv2Sa/oWPOdVr3LUnk9qlGg5KnWm8vHYVW2vbWFqWm3AHKnzchppGnt95jL1joE5cJcBSdS/5dNBMNlsDZxIYxnZl0c0BH6aPDjTexUcDAUChEpWLsfIf9JKPSiEqD5CO2ZsxIrtMATSa1A5cuHFgoyCQnfTUrlNhxRLzmEfx8qec/+WkqZsTlnbKXTOiFhSx/ejTaNxbS8mKecOyHkEQBGHkScafoqdancqf7AvzyFheSN/+NrojBk6EzzLe/SlZd4o8drL6k4LCRjysxMJ12HGh8QW8gJ838dJIgLfx8QmsgyptHwwj6U6AHtwJM83n5N9L/4sC71R2p+2nydoq/iTERQI8gjAA0Tf1lidqwK8ZdnAia7IN9d2+AN767tiThkZ1plXkcTJUH4tZIa0iT08BtpVl6U3/gISSEr0jNpBwjEbvnUhKnWkDyklday9ba9uwqAo/eWUf3jGQU3yJupXvWp6mSOnv/9Og5fI97/W8HFg6LO/xLj5caDhCmTlv4KVB11OFShQeIh0FhY9jwQPYBpgSMVQOq81sseynR+kPVKZrNpZ7y5kZyB/Suf34MWGKfUKDT7RfgFWzcH3LFTyf8xpu3NiwoZlAUfp7Yblx87X9a1m36HEpzxIEQRgnjIQ/Oc7MxT47G3O2je7NDXH9yZRtO+XaxrI/ncqdIOhPG2oaae/18NTmWvri9TMaZVLhT/vwc2FoyqgDhY9j5vPY9ZLwT2Mz+NNwMpLulAgzZspdM9icVU1F7xymenMAxJ+EGCTAIwgDkEg+IndwEo3QTERYDsI9f8IBHSCiNCvYNg7f8KUDJ7NLNVpENgccK1yibmWd5YGYxwtoY53lAW7xrj1tSQn33Hk3VH51Jz1cjJVX8OjBnfAxyzEZyrAGUtWhZvMcVpt5zbI75vEe3Lxm2c1HvAuHJCpxgzuEsnpCHm/VLHym7VL8pgDa6hwKz56Nr8PNvo3vsLHz77yUs5kmtZUdx3eIoAiCIIwTht2fTIruSgP6U4jhLKUaa/508c82jYmgTphU+VMzGjeGAj4eNGaNkj+NtDsNxPze2Xy+5WPYNVt/XyHxJyEKGZMuCANgdjrIu62SziVWctfMD05zICgOpmwbPduP42t16SM07bOzmba2iimXlYWCNJEnU8m6rMwgHOHXmZ0Ow24XPk2fMDHQeENfq0tfQ7LXE36/VBLZHDASi6qwotjKzLw05uSlj9p6VAJ81/J08OvoKfSh779reQY1ZmTaqSlC4Wky+DYOniaDSlR+TDpXYOXHpFOEQhHwq9Ax52JJelznUII7ATS2WPaHTxR9YgC2WPYTGIHRoYE4n6PJr5LrnApA61Pv4Txs48r28wGZniUIgjDeGFZ/Mink3VgRk3UT159CnGo09Hj2p3jBHbtZnXT+BHAn3Xoj5XMi/ElDwzuAv5yuP6XSnQAW9p7RPxKd8Lh08SfByIhm8Kxbt45NmzaxZ88eLBYL77zzTswxDQ0NfP/732fLli3YbDY+/vGPc9ddd2G1WkdyaYKQNOZcO31lZmyzpsTdaYreJTI7HWSuLsFRkacfm0wXe8NuV1QGT6qbJg83kc0Bw5hVhUsXTOPPu5sAz+iuR91rSCuORlWgiFaWqnvZEpif1DnDu04zUPRpD3YUPoFVryF3hI4Jfw3Bcqx38TIfM2YU3PhoUHqYqU2J/0anSZPaYUgtjkEJ7kY1qR0UBXKG9F7RO2XxxMqNmzZrJ+mvd+qibtdsfGf63ZSdW0GhJ4+e7cdTvnsqCCONuJMwUUiJP4UYqJRqvPuT3azqQR6rSeGLK2dR39YzYfwpzCosSfmTNcKfnseNCYVXcDMt/X3+vWcJpmHMZxhNd4pHppYe41QD+lPFXHL3W/GVucbNz7gwdEY0wOP1ern00kuprKzkueeei3ne7/fzla98hZycHH7zm9/Q0dHB3XffjaZp3HPPPSO5NEE4LcIpxT3bj5+y4d6parrDRNaNZ15YSnhEOzAmmv6NBJGNBIuzHeyq7+Bnr+4Pycnok0/HsB5XiapPwPJE7eI0EtBryD1oNBEMcoV3oAAWYcFNgK2Wes72Fg97cAfAxQCCchrHDUR0QCdegOdPuX/nk89eQq/P+NySuR/C7LGNWxkXhMEi7iRMREbLnyxRU7PiMd796ZXbV7OhphGAxcXZrHlya8pKtobTn6LLsZRT+JOXAPmouNH0XjuXYeEb5joWWE5yQ89STMPcg2c03SkR0Q71avYWLnvWSq8vYrqY4qasZDbqLxppF3eadIxogOe2224DYP369XGff+uttzhw4ACvv/4606ZNA+Cb3/wm3/zmN7n99tvJyMhI+r38/rHTy2OkCV/rZLrmVBLv8zaXZhga7plLM07rz8PX1kfLg9Uxu07W+bmYc+3YK/Ni3nu41zCS1LX1sq22nSVlOZTmGpsGTs+2cVVlYei4noRyoioxgzaGnWayh+24IhQ9uAPBnSUvGhYU3Gh0Aj+il2+RhhWFn5COQv8OVBgbKh/2jlzNtGPA6vTBHzcU+hQ33WYXJl+siHnbXHjbXAYZdx3qIC17fGUqyO/tIJP9+pNhNN0JJtefifw9HF1S4U95t1ViL8uMed9IJoI/3bSyDIA/7jg2IfwpcgR6cCJWN5vw8UU07An86f+ShoKCLyIQZEflv3wz4vrEcDAW3Ck6gyfLn6Ffr4LChilv8fu8l7mn7i5meYN/F8arO4H83g4zmOtPaZPl6upqzjjjDF1QAFauXInH46Gmpobly5cnfa7du2ObXU10JuM1p5Loz9t0oRVLSwBvnkpT3V6oG/w57bU+psSpGz/wRg19Zaf+6zkcaxgpmrp93PFKC24/2Exw/8V5FGTEXlNTt4/d9X1YVfBEOcrKYitbGzx4RlhQtgbOpEHLpYC2mBpyCApSE062Bs485bkWYTYEazxo3EEP8zDxRex8FbshW8ee5O7ScI9HLwhkk67Z6MEdW0cefEPSQ2M/Rwoffo5YG9jjOMQ++2H6FHeocWBwSQETHOytByDXpKH6FQImjYO99firG0ZsXSOJ/N4WhspwuhNMzp/JyXjNqUT8aXAM1p8sKkT3pr5opp1NR/rGjT9FjkAPl1+9hJfr6WY15rj+FHYiM4rBkYY7ayeSseBOCgpefFgw48XHPzKrWdpdgV2z0ae4+X3ey7TZuvDYVAImUP3gU/283bmLnOqpI7aukUZ+bydPSgM8LS0t5OXlGR6bMmUKFouFlpaWQZ1r4cKFmEzxJ7ZMNPx+P7t3755U15xKRvLz9pX20VIduwM1Z1UF5lx78udp68NTexJrWdagXjfcRO44Haxtx+0P/j12+6EnrZDKyukxx3/+wc24vH5sZpXzZufw1oFWfBrYzCpeczqewMjXkwdQ+Z73etZZHiCgGRsFhne/vue9jkASddyRYzzDwZ1qAhRg0oM54dKtyP8feH0B1GHuia+isNxbHpwEEY6ohAld83JvOeoIipIJE7M9Jcz2lHBR53LuKX2Em2d8icUZC+nb00rakgKmV06lvque/3Pwy5zTPg+zaua6GbdQXFI2YusaCeT3dpDw5yCcPsPpTiD+JIwcY92fdHcqTa07wdD8yWJSuHxhPi/VHMcf8qc6lwVPoG/E1z1c/hQ9Av1dfAA0oNEOcf0pMqgznBtgAzEW3ImIt7Vg5vaGz3NP6SN8Nf/LFJsL+Z7vbqafU05xSRn1c2p58M8/od7URPGeAm79+DfEn8Ypg/GnQQd4HnroIR5++OEBj3nuuedYuHBhUudTlPh/ARI9ngiTyTTp/tAn4zWnkpH4vE1T0w2NB5NpJhiNr9Wlpymnssa2rrWXj4Zkw2Ex8eSaJXojZYfFxPJZeTGf3yvvN+uNlt2+AK9/0IrVBF9ZUcYTb9Xydm37qK3/5cBSbvGu5buWpymiv2FgE06+570u6RGfDaHU4sg6coiVlzvpoQATTfj5CenYQ9JiwSgqGtqwB3fCzAzk8xHvQrZY9gd3o0KkY2O5t3zExnyGifwtb8PG0t6FzCydQ9evawHoqO3i7Z7tHM1txu1366NB/Y8fQ7u9aMCf83BvhrHWlFl+b09Oxqo7weT8mZyM15xKxqI/jRV3gqH7k9ev8cr7zXxnVQ4NWjaPvXGYfU1do7b+4fCnRO5UhEI2Cn2hUq1If/IS0Mu13GhYMfqTBx8aAWwMb1lSqt0JwBzxT3gbNs50z6akOhPF10UpGWjVDbxy9fs0WVvYad/DukPfFn+aRAw6wPO5z32Oj370owMeU1xcnNS58vLy2LVrl+Gxzs5OvF4vTqdzsEsThHFJss0EEzFWmgVGjj53ef3Ud7j0RspLy3IBeG57PUvLcil1plHX2sv9r+6POY/HD+29vph049Hg5cBSXnWfw1J1L/l00Ew2WwNnJpW5E0kDGg14Yx6LlZfgRV4f8fg8FG7GQSHBm5iCggcfVszDXqYFQVGZ4Z5Kk9qBCzeOUGrxcO8+JbP2q1svJO1dP+GhtQpwePO7PFbyR87rO0cfDWryKQP+nI/nCSnCxETcSRCGn6H401hxJxjYn4qzHWytDQZNSp3BXjzx/Mnr1zjRG6BdM7rHaDEc/hTtTpF9efrQeAQXmwz+pLEnyp8+h50+NHbh56XcVzBnfMCXm67mw56yYfWn0XKnAAGU0P8iCZdoQXCKlhbwo/j66/EUH7zy5gu86awWf5qEDDrAk5ubS25u7rC8eWVlJY8++ijNzc3k5wejnZs3b8ZqtVJRUTEs7yEIY4mRiIpHjgcdaCzoSBM5+txhMemBnHAw55IH3tCfC4uLO6IxoFkFXwCsJkhlfD6AOuhRnskSL/ATfjwfP1/GxrlYsEWkHrvw8yN6+Q6ZI1ZXrqKMyDjPMPFKzDQllJ2k9V+Tqin0Znj0q9TQ+PuUrbj9bs45ZwX+4xomn3LKn/OxJO6CAOJOgjBUhtufxoo7QWJ/AmLcqdSZFuNPAA6LialpKq29I9x0ZwCG258i+/LYUWgHPbMnSPDrHOBjWPk0Vj3L579xM79rIY1tq1jKlBEp4RppdwoTvXbNBPcUP8JZXXMp8Dr5a86bnLC0s6btE5j8Qddy46Ym7YD40yRlRHvwNDQ00NnZSUNDA36/nz179gBQWlpKeno6K1euZM6cOdx1113cdddddHZ2ct999/HpT3960FMgBGGsM1JRcbPToacppzKdMnL0eaScQOzu1IaaRi6rKDQIzZNrlvD3fU08/kYtv32nPiXXMFpEjwKtROUh0g03cQWFjXj4b9wswjKiTQNHmrglZprG/qoTzN6Ra9iFavY3sugzVbTtO8Y9nT9it/0AdrOdFRXnUViel9TP+VgSd0EYLOJOgmBkJPxprLgTJPanaHd65PUD3HreHENAyGZWueOicvIzLHzjud34tdErbR9p4vXlifQnMPE0GTHDKhzhaabejFDp+8TwJz0T2q9x5bSPUVVXgk2zsrxrMc9M/TM7zm/gQstKOtydfO3Y12lSW8WfJikjGuB58MEHef755/XvP/GJTwDw9NNPs2zZMkwmE4899hjf+973+OxnP4vdbudjH/sYd99990guSxBSwkhGxYda5jVchDN2ollalovNrOo7Tj97dT+XVRTGlHA98dYRxtMQxOhATbKviR4FejHWuLtLK7HwJzzMiGomOF6Jbojo2dOBhf5adRNmSrba6Nj5AYVrq/iB9SfsOL6DqmlVlGQGR8Yn83M+lsRdEAaLuJMgGBkpfxor7gTx/SkykAPw7LajvFjdwMtrV8X400d++jr+1CXvDIpk3Sm6tB0w+NMvcSecRBoeXhHdjHk8Eb3uSH/KeVfBpgV7C9mwctOJa9A2KTjW5pHpLGFd1+PiT5OYEQ3w/OhHP+JHP/rRgMcUFRXx2GOPjeQyBGFMMJmj4qXONO64qJwfbtgLQJ8vwNbaNj55drEuNI9tOog3ME7shKCghHeO+tC4nu6kgjzxRoG+goePY0GJEhF7eBdqADEZLXEZjveJvD4NjTprI2f2zcSqWQAwh4rzwgJfcnaJLiaDZSyJuyAMBnEnQTAyWf0pnNnzyOsHeHbbUSCYyTOe/Wmw7hRZ2n4pFoM/KWh682Ug4VTS8RjcgTilWRH+1GA5wZl9s4zHezU9+FmSKf40mRmZ0SyCIMQQjornfKp8UjYtC5dkAXqNeZhEDZfDjMVb82rMulTYUVidZLw8nHIM6CnH1QT4V3p4EQ//l179+WRGqI+WuCTzPloSAS4FhRa1HQ8ePta5GiXOSxSLStvUHl448AJHu44anjvadTTu44IgCMLEZDL7U6kzjVvPm3Pa/lRZPGXE1zgYTtedINafNuHjerp5BBcP08cd9Bj8aTyRrD/58aOgsKL7LLyhrCYdk4KtLCuhJ4k/TR5GNINHEAQjkzkqHq/GvK61l621bRxo7oppGAjBCLQGY/I2rcXsrCQXaAmmHJ9kESbeRdN3rqoJUE0fgD4VogkvP1bsODQrfWhsx8uKYR73ORKEd5l8+NHQ9B47YXICUzCF9hcsWAgoAVRNBQUyVhXTtUDj6jc/Q5+vD7vZzvor1lOSWcLRrqNc/eLVMY8LgiAIExvxp/hTSTfUNMb1J4WgQ1XXd47uYk/B6boTJPan30YMrwiXdHnxcg/pembweMOPHx/+mBHvptD12DQrf81+k8tOnosagIASQLm2kEZrS1xPEn+aXEiARxCEUSOyxjxyslY0VpOCJ1RMPhaDOwBv4OUmbHqa8RtxpmMlogFoIPEc+EZLIw3ePMDMF7RuLkg/gq9nHnvxURWRojzWiKwPfzv9XSp75mLDhg+/QbJMqIZUYy08SUuD7s0N1Exro88XDHb1+frYcXwHJZkl7Di+I+7jgiAIgjCRiTeV1GZWCWhGSwr7kwKn7GmoMPqONRR3AmhAGdCfGkJX/SsyMY+j/juRa/Th599L/4sTlna+0HwF53UtifuaCzuW8u8z/oupnmxq0g7QvqubW5VbxZ8ECfAIgpAaIqdDRBMO7kTfwlMhI4loCNWOD7bJcpB4sqERvkLNW6A/mo+VG3sWYcWEC43H6OZfSdczYMYSkSJ1Vs88rPT31okM8njx6Vk9Copxf80XoLgjz3DewoxCAKqmVWE32/UdqKppVSN7QYIgCIIwhoh0p3iZO2Pdn4bmTono9ydQDb0Ow04yXgI9AH58nLAEp6EdsNfx4a5K3aciXcqGjUvbPsyv8l+kydoKfuhwdxjOJf40OZEAjyAIKSF6OkQkZhV8AbCo4I2wlLEgJ5FENv8bPhR9wkQTfkOTZQcKXyVtxII7QxWgAAE9fdiKxRDIMZlMZKycjinNwsH0Y2T8sRu7Zot9T7NKfXYLRJSIN3Y3AlCSWcL6K9bHTIYQBEEQhMlApDuFXSmMClhCE0uT8adUOdXIuBOE/SkHcKNhi5pAFekbwx3wGer5YgI37Su4qu0jWLEQMEPGiqA/dVi60F5s0d/rvK4lfKhrETfPvpd2RzfZtmzDecWfJicS4BEEISWEa8o31DRS19rL77bV4dfAqsJ91yxkS20HH57l5NFNB9nT1JXq5Y4CwZt15Bh1D35Dk2UfPswRv7Z9+AHN8NjQVnD6cqKh6cGd8PdmxawbpOKHrs5OWDCF5+s38I9Zm7i94ToWucr111gK0nCclU9FXmHCnaZCTx4Xdi7HljM5pqgIgiAIQpjIfjwWVeHrf6jGFwhujN1zbg5z5szhN1vrmeIws7OuY9L6kxc/RPXfiXScf6bvYknvAiyaZdimhJ4uGpqhjF1D41Ptl6CGzqn6oMvUy47pB6k6Xh7zXjZs/IBvMH3VfMix8PNdPxd/muRIgEcQhJTywMYPcHn92M0q3/jIGaT1NfNvz79Hny+gjwUd34RTh8MEQt/Hl4HI1GIrJnxKALOm4sHL/UVPc3vjddi0YNM9P37+4HyVz7V+9LTkYihSE/3a6PMoKIbtQQ0Npbobb3U7H5S+S1N6K/8z9S/cV3e7/lrvCRfeDbWoFpX1X3qWHZ7dhp0mX6uL4w/s0EflTrZpKoIgCIIQ7mV4yQNvBLOdTQpPrTmHjobD3Pir7XFLtyYGif2pCIXPY9P9yYJJH+AQ2fMv7Btn98xnW/p7fKhn8aiXbiXjT9ETRgP/28Kre5/nF5mNrDN/GyVqgFbxwSkov2hk2tqquJk64k+Ti7HXxEEQhElDZC15ny+AM8PKgTYvfRNKTqLFQY16TDP8f+QY0D7Fg+lfCjm8qpuvzP4+m6Zs55m8P+uvtGHls62Xnbac+EJTGk6HyDTneHjwEu6dHB7rCcGpWf9RdxsFHidnVC6CzxWQtmQamaunQ7ixtjdA7ol0rpxzpSGN2F17Ei2Uc655A7hrT57W2gVBEARhPBPpT16/xrGOPrbU903g4A4k8qci4FdkcAVW3UkCZoX8mxZzeFU3d5f+jJ8W/orf576sv9KGlQ/3VKYkuPNr598IDNAo2oM3xqxMmLi74UayXGnUXN1B1mVlZKwuxr7Q2X/ukBeVZJaIP01yJMAjCELKCNeSA9jNKq3dHro8Y63TzvCiAiiRtedK//8rvtAY0E7+M/dvvHNFAyULyyk7t4KOtB4ANmdV41Y8QLBZ8an68eiyE0cmLJiHPEI0nhwdsTSgEdB3oKL/RC2YOcs9j5sW3kTJwnJyryknfWkhiiV4LYpFxVYWm0JsK8s65TGCIAiCMNGZjP5kNRHXnxZFTBdVUDgx20rR7Wdjn51N2bkVfDClno3Zb/NSzmbdn5Ih0QbWUPDj57XsLfxtyptxnz9orQv6U5znFBQu7PoQFWdUkrW6hOzLZpJ96cykvEj8aXIhJVqCIKSMUmcaT65ZwjNbjvDq+03c9/I+rKb+MZ8qsZMgwiSaCDHQa8YGGpacN/G2XRD1uAdHyZNo3hwclk7sgUJWTF8BGJvjHazdCwf7r9yNBxvWhO8WDsCoEaPJh4NwA+Xo1GcNjRneIsOxZoasYCcAAB+OSURBVEwEFA01lNITMGl85qI17Di+Q78+s9PBtLVVuGtPYivLips6nMwxgiAIgjDROZU/DcRgJ2qNFa/62LIO/rx3R4w/vYsLl2LCoVkJmGBOeb+DhP1p45GN/O6f/wOhsfLJ+NBIZPeYMVPRO4c/5m3kos7l2LAZ/Gm2pzThazU0LvroJwB44cALwRIsZ0lSXiT+NLmQAI8gCCmjrrWXG57aZpik5fHD3ZeewdRMB8XZDr7w5Na4KceJ5CSehFhU+OZl87j3r3tSPokrgALuAsBH5K/gOz9UTJXv/zBFyyRjpx/Vr6D8ohHf2kLMTgclmSWUZJZw9Hg5Ci1AMBPGi4+/TNnEVF8OVT3z9alV8YgOxCSSFw2Nv2duZYa7iNmeEsPj4df+tOhXWDQzM0rmcLL2BJ9vvhwrlvjnNKvk37CAEwfrqe+ux7ogh5vf+areBHD9Fev1IM+ppCOZYwRBEARhIjMS/hSNAjzwmUoA1j5bnXJ/+tOWKeAoMDx2+cJCbliURvvuI9h7slCPuOncUMvJjXV6n5mSzBJuqLiBpbVzsR0Mfl4KCn78+AnoI8hPRbL+9Ncpb1DsnUZl75lxX3vc0kqTtZU/L32HK7cu070tkT9pH82hZe8x8pbMgDIHV794tdGfnCVJeZH40+RBAjyCIKSMyBryMJbQ/W1pWS6lzjRevX019720l7/ubjyt9/jc0lI+vriIG57alnI5CRPomQ/4Q/+ZmGk2c8VWN4o/nf4mgv110o3WFr1hXuGZZTT8pRlVC6baWjCzL62WR7Kf5bt1N7O8Z1HC9/Xi46dFv2J51yI+3F2JVYsvNQoK53ZVYcESV2gUFCyamY3Zb3NOmp/rpn8ca7PxXBoanJUBORZq8mpxpu/n1hO30ufrw7LVgjcQTLPu8/Wx4/gOGdkpCIIgCEkSz59MwKLpU1hxRj7AkP3pgc9UclZpDpc88MaY8KdAQIGe+YSHV9jMCncvn4n65HvgSwP69GPj+VNpZgmd1OrHmDDx5NQ/sfJkFWe6Zw743gP5U7QfAczrnaU/HzkBVUFhmtfJbg4w1ZsTd1MuYNJQlk4h05pFl6mHW/bdzhFTA/Z37fwf5f/Q5wtep/iTkAjpwSMIQspYWpaLxWTcsQgA9720n0seeIO61l5KnWncfemZ2Myn9+vqrBk57KrviBGh0SJxgq8JMHHz6ln8asUZKHFSqhWLStvUHq5+8Wq+vfnbfOKFT/BM4+9ou8aGNzRCwa14mOLLoMDj5IitwfD6yPpxHz6+Vfogm6ZsZ3vG+wmDO2EsoR2tSGkJny+8AwXwzvF3eKP+jTjXrUCxg6tP3Mhdu/+dm1+9WZcSb8CLRQ2eP3qMpyAIgiAIAxPPn/zATU/voK61F2DI/uQNaGyoaUyZP80vyEzwjIKqwK9uWEZ2fTf4Tu1PV/7pSvYXNEDEZ+YJ9fP5k/N/B+y348U7oD9FZ95c3rkqpnQ+nj89dfK3eIkahwUoq3MpXFlOzz8aUP63nQf230mBx6k7lN1s1/9f/EmIhwR4BEFIGaXONJ65cZkuKRaTEh6khMvrZ2ttm37cq7ev5t8u6xcVq0nhzIQ3/346ez3c/+r+uM9VFmdz/typw3AliTGdooS7q6kHdXPU7ppJYcplZUxbW8UOz279pu7xe7h/+/18ad+/8uql7/P41D+CpnHTiWtYd+jb7MjYpwuLR/HyaP4fOGA9SrVjL/9e+iAnLO1c2LGM45ZWvIZGhck1E4wM9kzz9k9u2O84YpAXADduNqvvJAzqPHrRo9y74l69PEsQBEEQhOSI9qcwke4UPm64/UkBzizIZPnM3KFdxCn4oLkr4XMBDfbvb+Hkq3XGJxL4kzfg5Utbb0H7ShFHl/TwbO5LaFqAm05cw9rGz7NrcT3+iKmibtz8JXsTr2du41ulDw3oT9FEB3zMmBP6kxY1D92Ll3sO/4DGvbX61Cu7ZqOidw52s50LZ1zI+ivWiz8JAyIlWoIgpJTls528dsd5bK1tozDLyo1PbcPtB4fFxNKyfnkodabxldWzuayikK21bfpzF/1s04BjQV9+/7jh+ZtXzyInzcrPXt1PdX0HNrOKSdEndA+JeI0LfRpcsaiQF9+NnyLdub8NtP6aaMfCPKZcWqbXSVdZq7Cb7bqkQDAt1+JMw2wyY8MGBAXgR4t/wB/KX+Toex9Qk3YAgBtOXIndY2Ne3UxQFGyalT7FzU8Ln+aOhuuxYsGHP2aaVnSNuUfxomkBbNjoU9z6+QGmeZ0x6ckowf8Pr91qsvL5eZ8n25bNhTMuFCkRBEEQhCEQ9qcNNY3c/+p+3L5AjDvByPjT3qYuzOrIjhj3Bgb2p21v1nFBwK5/H8+fLGp/Sbg34GXjyU0sWLGAxoYWgz+dX/4RHpv6FCd3Bd9rv+MI3z96K3bNxoe6FsX40zca12DWTHH78STrTxW9cwzZQD78WLDw7dovsW/eIeZZstG8AfymAMuWruaOiu/q7iQOJQyEBHgEQUg5pc40Sp1p+P1+7r84j560QpbPyqPUmZbw2LrWXjbUNHLDijIUFJ7YfBi3LxAzQeKS+dPYXd+Jy+vHYTHxL0tnsLW2jb6QtAwkN4mwmBS8cSJCGmAzq/gDAcKntZlVFkyfYhCU8+dO5e/7TgCwQ/PhNymY/BqKRTXICfRPgHhu/3M8UfOE/vgiy3wubDkDPaRkVqDExm/e+APubDcAF3V8CLsWFBgbNv1Qu2bDopn5yuzvU9E7h2L3ND7Tdql+7r32Q5zZ118/vilzG0/lv4hZtXBm9wz2ZNTSZG7Vn69JO0Cf4tbfC8CmWVkROIcVoekVj1Q/whM1T+g7UIIgCIIgDI1w8Obi+fn88Y1dXLNqcVx3Ch87nP7kCwx+Z8ykKPi1+K9Lxp8WF09hV30nANsDXvwmx4D+9OhFj/KVV7+CLxAshXpo50OoikqOPUP3lnA512/2/AF3npsCj5NrWy9L6E953mwCoQc8eFAxYcGMGzeH7ceS9qdId/IqPiyaWX+PuabpBL5k46EXf8xO2x46DvWwouK8QX/ewuREAjyCIIwpCjLMVFZOx2QyJTymrrWXi3+2SZcMm1nlVzcspb7DxdKyXHbWtXPH76vxa/CTV/bz5Jol+nNh8bGZ1UEHd0xKsO5dA7YfaSOUPYuqBNOFIRgw+rfL+icnXFZRCMADGz/QJekrq2az5VCwQWK7RUVZs4CcDk/C0ZUlmSXMmtIvDAUeJ+rmkyi+/p2rKRfN4H89O3D73fpju9P26/Lgxm3YgYrMwDlsP2Zopvxn55vMbZ6N4tXoU9w8lf8iHWk9PPKRR2jsbuSzGYXcsvEWPH4PAE3WVm6ZdS8rTlZyQ+tVmAIqmkWh8MwyzJkOcu25+rqkKaAgCIIgDC+luWmcX+agNDd+cCfMcPiTWVUGHdyxqDA7P5PpUxy8tq9Zf3z5zFy2HA6WlCXjT/922Tx9elgy/rS0YCm3nXUb92+/H0DP5mmyurll1r18Z/rdfGjZefy1/RXc/mBwZ92hb2PXbKFWzsT4E4A1FIyxYePxqX+k09xNTdoBzIqF/z7y3aT8KexOFb1zOG5p5YfH1mLy9/vTX9tfYUPmW8EL8SHuJCSNBHgEQRh3RO4gQVAK6jtcfPLsYv35yF4+z1cf49bz5hh2teYWZPJuaBcoEqtJRVGC5zSpCv5IiVEU/nm4v7b9X5aWMMOZzuLibF04HBYTl1UUxuygvbx2lZ4aXepMi/n+VFRNC5ZqZfem6/KhL8ui4qjIiynnCsvD1/O/ysNtvyDLlcb5nUv5+5StqIqJRw7+G3bNhgevocTqpgVfpPBfKnHXnqRtag9f9dxO1bQqg1j86co/sfHIRjrcHfzPnv+hydrKXws288VP3UbOiXRdtnytLqqOlzMjUMQRtUGaAgqCIAhCihiKP9W19rK1to1zZuToQZl42MwqPn/AUPruDcDepi72NnVhURUuXlDAdctnUJTt4JIH3hhRf7pwxoX8fNfPDaXuAO2ObsrOrcCc6dD9qaJjju5XCqBVZvA1170GfzKrFrQT4bJ8jf2OI5ywtFPRO4dlS1dTeNXZg/Knjda3sZvtqB8rMfhTVc9CLutaGczgSesRdxKSRgI8giCMO5aW5WI3q4YdqOJsB89tr2dpWS5Ly3JxWEz65Idntx3lxeoGnlyzhF31HXqtejy+fnE5l1UUsqGmkb/tbtRTgQFjsIdg356vrJ4NxApINOHU6ETfn4pwqVbtmzXYD/YHd06U95F34WzMTgcl9JdzPf3+0/gCPjrSelhwwTLWtVfhe6wOi9/E+SeX8D95f9ElxooFTQFFgz7FzV2Hv8/35v8HS89eSjpQwizDWnytLnJrrVxXdi1mp4NPln9SH0NaklmCL92Fu/Ykvg43rU+9h+INsM5yDzVXtVNxRqXsQAmCIAhCCjhdf/rR1Qv5xnO78Po1Eg3lunn1LObkZ1Kc7eCHG/YY/CkSb0Dj/DPzWT472Gx4tPzp8d2Ps/6D9frj55WcF3PM5prX8f8lgMmvolhUCi46k3U962L8KdxhR0Hh4x3nsfTkAmzYCPwVKIf0s6fF9aejXUfZcXyH3otwIH9Sn2rkNu+/4DdrqF8uFncSkkYCPIIgjDtKnWm8cvtqNtQE67KjM2heXruKl9eu4pHXD/DstqNAcCfquifejts7x2pS8fgD+u4R9KcERxLde+eqyumGNQ1GOE6X7gIfmkXR03/v8v8HHW/2GKYp/Gbvb/AFfFhUC4985BFKMkvo2X+cdn+w7M2u2TCbLPp5IBjc8eDlhZy/4wt4ufnVm3nhEy8AGOWj1cXxB3ageQMoFpVpa6socZbo7x35fGT3asWrsUpbSnrmtBH/jARBEARBiOV0/emOP+zSN7l8gWDbv3PLp/KPg616c+d/WToDQM/ISYTVpMQM0RgNfyrLKsNmsukl4y/Xvsym+k0Gf/rpoQfJLkvnLPc8/vWKOzE7HeTWpg/oT+ee7M+sUX3QuLcWFmUY3AmCwZ2rX7yaPl8fdrNdf99T+ZPJp5BzIh1KR/wjEiYIEuARBGFcEm4sCPDc9npdJsIjQj95djG3njeHF6sbcHn9CRsjQzBrx5lh03ePIs8HsHRmLndcWA7A5x7fgl8LCkpRtkNPWU42Vfh0iRSDGbOK+Grul/hp88M0WVsNtdkbj2w0jAVt7A5KnK0sC8WiBicymDW+cPUt5DumcWT9LtIOB6/VioXPtF3Kle3nc8use3lu/3M88/4zeANeXUZya6366E7NG+Dk60fJOq9Er313157Un8ev6ZKiWFRsZVkj9vkIgiAIgnBqhsOffBpcvqiI711RYXCgeP70uaWl3PncLjx+DbMCT9+4zFDyNZr+ZDVZuaTsEl6ufRkw9gUM+1OTtY8N1rdY4bmUEmYl5U9hNDTecVXzHy/8FLffjc1k4/krn6cks4Qdx3fofpbdm07tmzUULssTfxKGHQnwCIIw7llalqs3TbaZVX1nKLJWuzjboe9SRU5qiFfzHZmibDEp3HFhOctnO3lue71eU+7xa2yoaTQ0/3t57aq4kjIcEhMpBkfUBhpnd9HR3QM+9L42R7uO8nD1w/prSv1FVB0vx5fjwux0MG1tFe7ak3p9t/tED74MFc0cQPH1y5tds7G470yefu9pfFpw8kRYgi4vu1gXHYDebcdxVZ9g2toqzE6HQYQUi4pzzQL8He6EDRAFQRAEQUgNxdkOPYATOWI9kT+FCR8bnX0Tz5/qO1z6dC6fBvUdLupaew29d+L503AFgCL9yeP3sMC5gE31m/RMmmh/KvA4qeybR5V1IcCg/ElBQev06llCbr+bjUc2ckPFDbG9FA/aOP7PHeJPwrAjAR5BEMY9DR0uAqGxm0rUc5HyESkru+o7AOI29Ct1pvHkmiV6SdcNT23j5bWrDOLisATTdaN3vuIJyqkkJhnCYhAWkgtnXMiFMy40pAC/cOAFfbJVgcfJz2v/HWV/C8dfatMFIiwJvlYXLQ9Wk+UN4DdpPJf7Mp9ovwCbZsVr8nPOOSt4ef9m/f3Nqpm2vjYarS0Urq3i5OtH6d12HAhm8rhrT+rnjxYhQRAEQRDGFnWtvax5citev4bFpPDkmiUJe92E/cmiKvzjUCtXVU5P2C8n2p+eXLPE4E5Ly3LZWts2oD8NlzvB4PwpcoqW8otGfGsLdbdJxp/8pgCeIgX2979/h7uDFw68QNW0qpheiuJPwkggAR5BEMY1da29ht46fb4Aj7x+IGZqFqB/Hz2xIR71HS79nJFpy5HNAME4vjOypjzMqSQmWcINAKNruiOb7kVKzFnueZj8wU6IkQIRJjIV2ORXaHK0cXPOD6jsm8dtV97JipzZ2A89SJ+vD7NiRkHh/u338/NdP2f9FespPK8EV/UJfacpMn04UoQEQRAEQRh7bKhp1Jste/0am/afiBmJHiban16sbkgYdIn2p/oOV9xGytFBn0iGy51gcP4UOUUrnjtBrD+5rG6eyfszZpOFL1x9CytyZmE9+AAevwerauV/9vwPHr9HL3X/0LLzOP7PHeJPwoghAR5BEMY1W2vbYmrDw1Mf4slHstIQna0TmbYcefyppj8kOs/pENmML9HzYYkp9hfgf8aNyafErd+OTAXWLArvpR+kydTK/zq2cluOxXCutr427t9+P9BfqnXlnCtlp0kQBEEQJgi/ePOgXro+3P4UbxLWQP40nO4EyftTzQfVaOuVYNmVOX7vm0h/wqzwhZZPoPg0NItCYXoh5kwHf7ryT+JPQsqQAI8gCOOaSAmIGDqQUD4S1ZtHcyr5iDxuoF2lZM8zXIQF5uoXryZ7hnESRCRmp4O82yo58EYNR2Y0cfS9YDNmj9+jNxwM/3e06yg/3/VzQ716+BwiJoIgCIIw/risopD7X92P2xfArAanY8HY8KfRdicI+lPhjDya2B56JP5gjkh/KnYW0vXSESA4LTSc8SP+JKQSCfAIgjCuSdQIMJ581LX2csNT2xLWm8c793BIxWiNAA0TbigYPQkiGnOunb4yMwtmV2LfZ48RkDCJ0psFQRAEQRiflDrTePX21WPWn0bbnSBYfkW4abJPi1uiBf3+ZC910v3a0bjlViD+JKQGCfAIgjDuidcIMN6OT2R6sdevUd/hGtF1jdYI0GiiGwpGB2yiKc4sPqWAnCq9WRAEQRCE8YX4k5HoSVanGk9uzrWfstxK/EkYbSTAIwjChGKgHZ/hrukeiOGcADFYTmfHSAREEARBECYv4k/xR6In8xoptxLGEhLgEQRh0jCaNd3DOQHidJCAjSAIgiAIw8Fk8icJ2AjjHQnwCIIwqRitmu7R3O0SBEEQBEEYScSfBGF8IAEeQRCEESAVEyAAjnYdlWZ+giAIgiCMS1LhT75Wl4wtFyYMEuARBEEYIUZ7AsTRrqNc/eLVenPl9VeslyCPIAiCIAjjitH0J1+ri+MP7NAbK09bWyVBHmFco6Z6AYIgCMLwEB6PDtDn62PH8R0pXpEgCIIgCMLYxV17Es0bAEDzBoKj0gVhHCMBHkEQhAlCeDw6kNR4dEEQBEEQhMlMeDQ6kNRodEEY60iJliAIwgThdMajC4IgCIIgTFZOZzS6IIxlJMAjCIIwgZDx6IIgCIIgCMkjo9GFiYSUaAmCIAiCIAiCIAiCIIxzJMAjCIIgCIIgCIIgCIIwzpEAjyAIgiAIgiAIgiAIwjhHAjyCIAiCIAiCIAiCIAjjHAnwCIIgCIIgCIIgCIIgjHMkwCMIgiAIgiAIgiAIgjDOkQCPIAiCIAiCIAiCIAjCOEcCPIIgCIIgCIIgCIIgCOMcCfAIgiAIgiAIgiAIgiCMcyTAIwiCIAiCIAiCIAiCMM6RAI8gCIIgCIIgCIIgCMI4RwI8giAIgiAIgiAIgiAI4xxzqhcwVDRNA8Dv96d4JaNH+Fon0zWnEvm8Rw/5rEcX+bxHD/msg4SvP3zvFlKH+JMw0sjnPXrIZz26yOc9eshnHWQw/qRo49yyPB4Pu3fvTvUyBEEQBEFIkoULF2K1WlO9jEmN+JMgCIIgjC+S8adxH+AJBAL4fD5UVUVRlFQvRxAEQRCEBGiaRiAQwGw2o6pSJZ5KxJ8EQRAEYXwwGH8a9wEeQRAEQRAEQRAEQRCEyY5snwmCIAiCIAiCIAiCIIxzJMAjCIIgCIIgCIIgCIIwzpEAjyAIgiAIgiAIgiAIwjhHAjyCIAiCIAiCIAiCIAjjHAnwCIIgCIIgCIIgCIIgjHMkwCMIgiAIgiAIgiAIgjDOkQCPIAiCIAiCIAiCIAjCOEcCPIIgCIIgCIIgCIIgCOMcCfAIgiAIgiAIgiAIgiCMcyTAM85Yt24d1157LYsXL+acc86Je0xDQwM333wzlZWVLFu2jHvvvRePxzPKK52YXHDBBcydO9fw309+8pNUL2vC8Otf/5oLLriAhQsXcvXVV/POO++kekkTjoceeijmZ3jFihWpXtaEYdu2bdx8882sXLmSuXPnsnHjRsPzmqbx0EMPsXLlShYtWsR1113HBx98kKLVCsLkQfwptYg/jSziTyOP+NPIIv40fJhTvQBhcHi9Xi699FIqKyt57rnnYp73+/185StfIScnh9/85jd0dHRw9913o2ka99xzTwpWPPG47bbb+PSnP61/n5aWlsLVTBz+9re/8cMf/pDvfve7VFVV8bvf/Y4vfelL/PWvf6WoqCjVy5tQnHHGGTz55JP69yaTKYWrmVj09vYyd+5crr76av71X/815vlf/OIXPPnkk/zoRz+irKyMdevWccMNN/DSSy+RkZGRghULwuRA/Cn1iD+NDOJPo4f408gh/jR8SIBnnHHbbbcBsH79+rjPv/XWWxw4cIDXX3+dadOmAfDNb36Tb37zm9x+++3yF2AYSE9PZ+rUqalexoTjySef5JprruFTn/oUAN/61rd46623+O1vf8vXv/71FK9uYmEymeRneIRYvXo1q1evjvucpmk8/fTT3HzzzVx88cUA3HfffXz4wx/mL3/5C9dee+1oLlUQJhXiT6lH/GlkEH8aPcSfRg7xp+FDSrQmGNXV1Zxxxhm6nACsXLkSj8dDTU1NClc2cXj88cdZtmwZV155JevWrZP07WHA4/Hw3nvvsXLlSsPjK1asYOfOnSla1cTlyJEjrFy5kgsuuIDbb7+do0ePpnpJk4L6+npOnDhh+Dm3Wq0sWbJEfs4FIcWIP4084k/Dj/jT6CL+lBrEnwaHZPBMMFpaWsjLyzM8NmXKFCwWCy0tLSla1cTh+uuvZ/78+WRlZbF7925++tOfUl9fz3/8x3+kemnjmvb2dvx+P06n0/B4Xl4eJ06cSNGqJiaLFi3ivvvuo6ysjNbWVr0vxV/+8hdycnJSvbwJTfhnOd7PeUNDQyqWJAhCCPGnkUX8aWQQfxo9xJ9Sh/jT4JAAzxjgoYce4uGHHx7wmOeee46FCxcmdT5FUQb1+GRnMJ//mjVr9MfOPPNMsrKyuO222/jGN74hv9yHgeifUU3T5Od2mIlOf62srOSiiy7iT3/6EzfccEOKVjW5iPdzLgjC4BF/Si3iT2MH8aeRR/wp9Yg/JYcEeMYAn/vc5/joRz864DHFxcVJnSsvL49du3YZHuvs7MTr9cZEPYUgQ/n8KysrAairqxNBGQI5OTmYTKaYXdLW1taYHVVheElLS6O8vJza2tpUL2XCE67bb2lpIT8/X39cfs4F4fQQf0ot4k+pR/wpdYg/jR7iT4NDAjxjgNzcXHJzc4flXJWVlTz66KM0NzfrfwE2b96M1WqloqJiWN5jojGUz//9998HkIZrQ8RqtbJgwQI2b97MRRddpD/+j3/8g4985CMpXNnEx+PxcPDgQc4+++xUL2XCU1xczNSpU9m8eTPz588Hgp//tm3b+MY3vpHi1QnC+EP8KbWIP6Ue8afUIf40eog/DQ4J8IwzGhoa6OzspKGhAb/fz549ewAoLS0lPT2dlStXMmfOHO666y7uuusuOjs7ue+++/j0pz8tEyCGyM6dO9m1axfLli0jIyOD3bt388Mf/pALLrhAxlAOAzfccAN33XUXFRUVnHXWWTz77LM0NjZKZ/xh5r777uP888+nsLCQtrY21q1bR3d3N1dddVWqlzYh6Onpoa6uTv++vr6ePXv2MGXKFIqKirj++ut57LHHKCsrY8aMGTz22GPY7XY+9rGPpXDVgjDxEX9KHeJPI4v40+gg/jSyiD8NH4omxWvjim9+85s8//zzMY8//fTTLFu2DAhKzPe+9z22bNmi/+DffffdWK3W0V7uhOK9997je9/7HocOHcLj8VBUVMTll1/OTTfdhMPhSPXyJgS//vWv+eUvf0lzczPl5eX827/9G0uWLEn1siYUt99+O9u2baOjo4OcnBwqKyv52te+xpw5c1K9tAnB22+/zfXXXx/z+FVXXcWPfvQjNE3j4Ycf5tlnn6Wzs5PFixfzne98h/Ly8hSsVhAmD+JPqUP8aeQRfxp5xJ9GFvGn4UMCPIIgCIIgCIIgCIIgCOMcNdULEARBEARBEARBEARBEIaGBHgEQRAEQRAEQRAEQRDGORLgEQRBEARBEARBEARBGOdIgEcQBEEQBEEQBEEQBGGcIwEeQRAEQRAEQRAEQRCEcY4EeARBEARBEARBEARBEMY5EuARBEEQBEEQBEEQBEEY50iARxAEQRAEQRAEQRAEYZwjAR5BEARBEARBEARBEIRxjgR4BEEQBEEQBEEQBEEQxjkS4BEEQRAEQRAEQRAEQRjn/H8bXSLiNA4KPAAAAABJRU5ErkJggg==\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model_sklearn = KMeans(k, init=X[:k], n_init=1, max_iter=50, tol=1e-2).fit(X)\n",
"model_pom = KMeans2(k=k, init='first-k', max_iter=50, tol=1e-2).fit(X)\n",
"\n",
"y_hat_sklearn = model_sklearn.predict(X)\n",
"y_hat_pom = model_pom.predict(X)\n",
"\n",
"plt.figure(figsize=(14, 5))\n",
"plt.subplot(121)\n",
"for i in range(k):\n",
" plt.scatter(*X[y_hat_sklearn == i, :2].T, s=3)\n",
" plt.scatter([model_sklearn.cluster_centers_[i, 0]], [model_sklearn.cluster_centers_[i, 1]])\n",
"\n",
"plt.subplot(122)\n",
"for i in range(k):\n",
" plt.scatter(*X[y_hat_pom == i, :2].T, s=3)\n",
" plt.scatter([model_pom.centroids[i, 0]], [model_pom.centroids[i, 1]])"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/benchmarks/Benchmark_4_Bayes_Classifier.ipynb 0000664 0000000 0000000 00000011262 14643672530 0027121 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "752ca88f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"numpy : 1.23.4\n",
"scipy : 1.9.3\n",
"torch : 1.12.1\n",
"pomegranate: 0.14.8\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-197-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"import numpy\n",
"import scipy\n",
"import torch\n",
"\n",
"from sklearn.datasets import make_blobs\n",
"\n",
"from torchegranate.distributions import *\n",
"from torchegranate.bayes_classifier import BayesClassifier\n",
"\n",
"from sklearn.naive_bayes import GaussianNB, BernoulliNB\n",
"\n",
"import matplotlib.pyplot as plt\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p numpy,scipy,torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "1d323e83",
"metadata": {},
"source": [
"### Gaussian Naive Bayes"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "db6dc2d8",
"metadata": {},
"outputs": [],
"source": [
"n, d, k = 200000, 500, 50\n",
"\n",
"X, y = make_blobs(n_samples=n, n_features=d, centers=k, cluster_std=0.75, random_state=0)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "4a980a8a",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"787 ms ± 22.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"872 ms ± 16.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
}
],
"source": [
"%timeit model_sklearn = GaussianNB().fit(X, y)\n",
"%timeit model_pom = BayesClassifier([Normal(covariance_type='diag') for i in range(k)]).fit(X, y)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "24f702bc",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"20.9 s ± 24.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"15.6 s ± 152 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
}
],
"source": [
"model_sklearn = GaussianNB().fit(X, y)\n",
"model_pom = BayesClassifier([Normal(covariance_type='diag') for i in range(k)]).fit(X, y)\n",
"\n",
"%timeit model_sklearn.predict(X)\n",
"%timeit model_pom.predict(X)"
]
},
{
"cell_type": "markdown",
"id": "f0f5959c",
"metadata": {},
"source": [
"### Bernoulli Naive Bayes"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "1a73281c",
"metadata": {},
"outputs": [],
"source": [
"n, d, k = 200000, 200, 25\n",
"\n",
"X = numpy.random.choice(2, size=(n, d))\n",
"y = numpy.random.choice(k, size=(n,))"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "f711516d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"14 s ± 242 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"359 ms ± 905 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
}
],
"source": [
"%timeit model_sklearn = BernoulliNB().fit(X, y)\n",
"%timeit model_pom = BayesClassifier([Bernoulli() for i in range(k)]).fit(X, y)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "bab540b7",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"628 ms ± 12.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"3.01 s ± 35.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
}
],
"source": [
"model_sklearn = BernoulliNB().fit(X, y)\n",
"model_pom = BayesClassifier([Bernoulli() for i in range(k)]).fit(X, y)\n",
"\n",
"%timeit model_sklearn.predict(X)\n",
"%timeit model_pom.predict(X)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/benchmarks/Benchmark_5_Hidden_Markov_Model.ipynb 0000664 0000000 0000000 00000300562 14643672530 0027551 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "72ea7293",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n",
"numpy : 1.23.4\n",
"scipy : 1.9.3\n",
"torch : 1.12.1\n",
"pomegranate: 0.14.8\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-197-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"%pylab inline\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"\n",
"import time\n",
"import torch\n",
"\n",
"from tqdm import tqdm\n",
"\n",
"from torchegranate.distributions import *\n",
"from torchegranate.hmm import HiddenMarkovModel, Node\n",
"\n",
"from pomegranate import State, NormalDistribution, IndependentComponentsDistribution, DiscreteDistribution\n",
"from pomegranate import HiddenMarkovModel as HMM\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p numpy,scipy,torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "9b312b25",
"metadata": {},
"source": [
"### Normal Distribution w/ Diagonal Covariance"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "412487ff",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/jmschr/anaconda3/lib/python3.9/site-packages/torchegranate-0.0.1-py3.9.egg/torchegranate/_dense_hmm.py:23: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
"/home/jmschr/anaconda3/lib/python3.9/site-packages/torchegranate-0.0.1-py3.9.egg/torchegranate/_dense_hmm.py:24: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
"/home/jmschr/anaconda3/lib/python3.9/site-packages/torchegranate-0.0.1-py3.9.egg/torchegranate/_dense_hmm.py:25: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n"
]
}
],
"source": [
"n, l, d = 200, 50, 10\n",
"k = 50\n",
"\n",
"\n",
"X = numpy.random.randn(n, l, d)\n",
"Xt = torch.tensor(X)\n",
"\n",
"d1s, d2s, d3s = [], [], []\n",
"for i in range(k):\n",
" mus = numpy.random.randn(d)\n",
"\n",
" d1 = IndependentComponentsDistribution([NormalDistribution(mu, 1) for mu in mus])\n",
" d2 = Normal(torch.tensor(mus), torch.ones(d), covariance_type='diag')\n",
" d3 = Normal(torch.tensor(mus), torch.ones(d), covariance_type='diag')\n",
"\n",
" d1s.append(d1)\n",
" d2s.append(d2)\n",
" d3s.append(d3)\n",
"\n",
"\n",
"starts = torch.ones(k, dtype=torch.float64) / k\n",
"ends = torch.ones(k, dtype=torch.float64) / (k+1)\n",
"edges = torch.ones(k, k, dtype=torch.float64) / (k+1)\n",
"\n",
"\n",
"model1 = HMM.from_matrix(edges, d1s, starts, ends)\n",
"model2 = HiddenMarkovModel(nodes=d2s, edges=edges, starts=starts, ends=ends, kind='sparse', max_iter=10, verbose=True)\n",
"model2.bake()\n",
"model3 = HiddenMarkovModel(nodes=d3s, edges=torch.clone(edges), starts=torch.clone(starts), ends=torch.clone(ends), max_iter=10, kind='dense', verbose=True)\n",
"model3.bake()"
]
},
{
"cell_type": "markdown",
"id": "6554dc39",
"metadata": {},
"source": [
"### Forward"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "e8291aa3",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"959 ms ± 7.29 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"184 ms ± 2.41 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
"130 ms ± 2.38 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
]
}
],
"source": [
"%timeit [model1.forward(x) for x in X]\n",
"%timeit model2.forward(X)\n",
"%timeit model3.forward(X)"
]
},
{
"cell_type": "markdown",
"id": "72667302",
"metadata": {},
"source": [
"### Backward"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "f709ef72",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"995 ms ± 7.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"319 ms ± 42.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"133 ms ± 4.41 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
]
}
],
"source": [
"%timeit [model1.backward(x) for x in X]\n",
"%timeit model2.backward(X)\n",
"%timeit model3.backward(X)"
]
},
{
"cell_type": "markdown",
"id": "d88fc2b3",
"metadata": {},
"source": [
"### Forward-Backward"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "fe16cb7e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2.58 s ± 10.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"801 ms ± 38.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"370 ms ± 39.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
}
],
"source": [
"%timeit [model1.forward_backward(x) for x in X]\n",
"%timeit model2.forward_backward(X)\n",
"%timeit model3.forward_backward(X)"
]
},
{
"cell_type": "markdown",
"id": "41a0b064",
"metadata": {},
"source": [
"### Fitting"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "016e640c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 11916.92540384506\tTime (s): 2.761\n",
"[2] Improvement: 356.23982110453653\tTime (s): 2.799\n",
"[3] Improvement: 187.82563967100577\tTime (s): 2.811\n",
"[4] Improvement: 132.1274677386391\tTime (s): 2.817\n",
"[5] Improvement: 107.64460236663581\tTime (s): 2.816\n",
"[6] Improvement: 95.06285029207356\tTime (s): 2.816\n",
"[7] Improvement: 87.14057147293352\tTime (s): 2.81\n",
"[8] Improvement: 81.8166760643071\tTime (s): 2.814\n",
"[9] Improvement: 78.61675650975667\tTime (s): 2.804\n",
"[10] Improvement: 76.616654075915\tTime (s): 2.813\n",
"Total Training Improvement: 13120.016443140863\n",
"Total Training Time (s): 30.7974\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/tmp/ipykernel_49503/2413083255.py:2: DeprecationWarning: Calling np.sum(generator) is deprecated, and in the future will give a different result. Use np.sum(np.fromiter(generator)) or the python sum builtin instead.\n",
" sum(model1.log_probability(x) for x in X)\n"
]
},
{
"data": {
"text/plain": [
"-141610.99530855467"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"_ = model1.fit(X, max_iterations=10, verbose=True)\n",
"sum(model1.log_probability(x) for x in X)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "c603db97",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 11916.924049986032, Time: 0.9671s\n",
"[2] Improvement: 356.2397617994575, Time: 0.8338s\n",
"[3] Improvement: 187.8250123585749, Time: 0.8203s\n",
"[4] Improvement: 132.1275977602927, Time: 0.8282s\n",
"[5] Improvement: 107.64466150157386, Time: 0.8327s\n",
"[6] Improvement: 95.062770339282, Time: 0.8272s\n",
"[7] Improvement: 87.14074739645002, Time: 0.832s\n",
"[8] Improvement: 81.81688827590551, Time: 0.8347s\n",
"[9] Improvement: 78.61642209693673, Time: 0.8035s\n",
"[10] Improvement: 76.61670887985383, Time: 1.664s\n"
]
},
{
"data": {
"text/plain": [
"tensor(-141685.9139, dtype=torch.float64)"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model2.fit(X)\n",
"model2.log_probability(X).sum()"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "607d1627",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 11916.924035742384, Time: 0.3742s\n",
"[2] Improvement: 356.2398789973522, Time: 0.4464s\n",
"[3] Improvement: 187.82526078561204, Time: 0.4137s\n",
"[4] Improvement: 132.12753497209633, Time: 0.3989s\n",
"[5] Improvement: 107.64437899994664, Time: 0.3825s\n",
"[6] Improvement: 95.06291119300295, Time: 0.4098s\n",
"[7] Improvement: 87.14107854760368, Time: 0.399s\n",
"[8] Improvement: 81.81658541041543, Time: 0.3975s\n",
"[9] Improvement: 78.61654813570203, Time: 0.3884s\n",
"[10] Improvement: 76.61647296641604, Time: 0.8219s\n"
]
},
{
"data": {
"text/plain": [
"tensor(-141685.9138, dtype=torch.float64)"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model3.fit(X)\n",
"model3.log_probability(X).sum()"
]
},
{
"cell_type": "markdown",
"id": "e68ae32a",
"metadata": {},
"source": [
"### Categorical Distributions"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "46dd6613",
"metadata": {},
"outputs": [],
"source": [
"n, l, d = 200, 50, 10\n",
"k = 50\n",
"\n",
"\n",
"X = numpy.random.choice(4, size=(n, l, d))\n",
"Xt = torch.tensor(X)\n",
"\n",
"d1s, d2s, d3s = [], [], []\n",
"for i in range(k):\n",
" mus = numpy.abs(numpy.random.randn(d, 4))\n",
" mus = mus / mus.sum(axis=1, keepdims=True)\n",
"\n",
" d_ = [DiscreteDistribution({i: mu[i] for i in range(4)}) for mu in mus]\n",
" d1 = IndependentComponentsDistribution(d_)\n",
" d2 = Categorical(mus)\n",
" d3 = Categorical(mus)\n",
"\n",
" d1s.append(d1)\n",
" d2s.append(d2)\n",
" d3s.append(d3)\n",
"\n",
"\n",
"starts = torch.ones(k, dtype=torch.float64) / k\n",
"ends = torch.ones(k, dtype=torch.float64) / k\n",
"edges = torch.ones(k, k, dtype=torch.float64) / k\n",
"\n",
"\n",
"model1 = HMM.from_matrix(edges, d1s, starts, ends)\n",
"model2 = HiddenMarkovModel(nodes=d2s, edges=edges, starts=starts, ends=ends, kind='sparse', max_iter=10, verbose=True)\n",
"model2.bake()\n",
"model3 = HiddenMarkovModel(nodes=d3s, edges=torch.clone(edges), starts=torch.clone(starts), ends=torch.clone(ends), max_iter=10, kind='dense', verbose=True)\n",
"model3.bake()"
]
},
{
"cell_type": "markdown",
"id": "8195331e",
"metadata": {},
"source": [
"### Forward"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "e6091b50",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.02 s ± 9.35 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"198 ms ± 2.94 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
"150 ms ± 3.22 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
]
}
],
"source": [
"%timeit [model1.forward(x) for x in X]\n",
"%timeit model2.forward(X)\n",
"%timeit model3.forward(X)"
]
},
{
"cell_type": "markdown",
"id": "aaa826b1",
"metadata": {},
"source": [
"### Backward"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "a4b5218d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.05 s ± 5.57 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"362 ms ± 39.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"150 ms ± 5.81 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
]
}
],
"source": [
"%timeit [model1.backward(x) for x in X]\n",
"%timeit model2.backward(X)\n",
"%timeit model3.backward(X)"
]
},
{
"cell_type": "markdown",
"id": "fe327bb6",
"metadata": {},
"source": [
"## Increased Size of Dense Transition Matrix"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "c0521cb1",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|███████████████████████████████████████████| 35/35 [10:45<00:00, 18.44s/it]\n"
]
}
],
"source": [
"times1, times2, times3 = [], [], []\n",
"\n",
"for k in tqdm(range(10, 351, 10)):\n",
" n, l, d = 200, 50, 10\n",
"\n",
" X = numpy.random.choice(4, size=(n, l, d))\n",
" Xt = torch.tensor(X)\n",
"\n",
" d1s, d2s, d3s = [], [], []\n",
" for i in range(k):\n",
" mus = numpy.abs(numpy.random.randn(d, 4))\n",
" mus = mus / mus.sum(axis=1, keepdims=True)\n",
"\n",
" d_ = [DiscreteDistribution({i: mu[i] for i in range(4)}) for mu in mus]\n",
" d1 = IndependentComponentsDistribution(d_)\n",
" d2 = Categorical(mus)\n",
" d3 = Categorical(mus)\n",
"\n",
" d1s.append(d1)\n",
" d2s.append(d2)\n",
" d3s.append(d3)\n",
"\n",
"\n",
" starts = torch.ones(k, dtype=torch.float64) / k\n",
" ends = torch.ones(k, dtype=torch.float64) / (k+1)\n",
" edges = torch.ones(k, k, dtype=torch.float64) / (k+1)\n",
"\n",
"\n",
" model1 = HMM.from_matrix(edges, d1s, starts, ends)\n",
" model2 = HiddenMarkovModel(nodes=d2s, edges=edges, starts=starts, ends=ends, kind='sparse', max_iter=10, verbose=True)\n",
" model2.bake()\n",
" model3 = HiddenMarkovModel(nodes=d3s, edges=torch.clone(edges), starts=torch.clone(starts), ends=torch.clone(ends), max_iter=10, kind='dense', verbose=True)\n",
" model3.bake()\n",
" \n",
" tic = time.time()\n",
" [model1.forward(x) for x in X]\n",
" times1.append(time.time() - tic)\n",
" \n",
" tic = time.time()\n",
" model2.forward(X)\n",
" times2.append(time.time() - tic)\n",
" \n",
" tic = time.time()\n",
" model3.forward(X)\n",
" times3.append(time.time() - tic)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "4e8f25a7",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x = range(10, 351, 10)\n",
"\n",
"plt.figure(figsize=(6, 3))\n",
"plt.title(\"HMM Forward Algorithm Time\", fontsize=12)\n",
"plt.plot(x, times1, label=\"pomegranate\")\n",
"plt.plot(x, times2, label=\"torchegranate sparse\")\n",
"plt.plot(x, times3, label=\"torchegranate dense\")\n",
"\n",
"plt.xlabel(\"Number of Nodes\", fontsize=10)\n",
"plt.ylabel(\"Time (s)\", fontsize=10)\n",
"plt.legend()\n",
"\n",
"plt.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "cd8aa82c",
"metadata": {},
"source": [
"## Increased Sparsity of Transition Matrix"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "0ae5e00b",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
" 0%| | 0/29 [00:00"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.figure(figsize=(6, 3))\n",
"plt.title(\"HMM Forward Algorithm Time\", fontsize=12)\n",
"plt.plot(ps, times1, label=\"pomegranate\")\n",
"plt.plot(ps, times2, label=\"torchegranate sparse\")\n",
"plt.plot(ps, times3, label=\"torchegranate dense\")\n",
"\n",
"plt.xlabel(\"Proportion Non-zero\", fontsize=10)\n",
"plt.ylabel(\"Time (s)\", fontsize=10)\n",
"plt.xscale('log')\n",
"plt.yscale('log')\n",
"plt.legend()\n",
"\n",
"plt.tight_layout()\n",
"plt.show()"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/docs/ 0000775 0000000 0000000 00000000000 14643672530 0017263 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/docs/CODE_OF_CONDUCT.rst 0000664 0000000 0000000 00000007640 14643672530 0022301 0 ustar 00root root 0000000 0000000 ===============
Code of Conduct
===============
Our Pledge
----------
In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
Our Standards
-------------
Examples of behavior that contributes to creating a positive environment include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting
Our Responsibilities
--------------------
Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
Scope
-----
This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
Enforcement
-----------
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at jmschreiber91@gmail.com. Because the project team currently consists of only one member, that member shall investigate within one week whether a violation of the code of conduct occurred and what the appropriate response is. That member shall then contact the original reporter and any other affected parties to explain the response and note feedback for the record. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Should you wish to file a report anonymously you should fill out a report at https://goo.gl/forms/aQtlDdrhZf4Y8flk2. If your report involves any members of the project team, if you feel uncomfortable making a report to the project team for any reason, or you feel that the issue has not been adequately handled, you are encouraged to send `your report `_ to conduct@numfocus.org where it will be independently reviewed by the `NumFOCUS team `_.
Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
Attribution
-----------
This Code of Conduct is adapted from the `Contributor Covenant homepage `_, `version 1\.4 `_.
For answers to common questions about this code of conduct, see https://www.contributor-covenant.org/faq.
jmschrei-pomegranate-8de2be8/docs/Makefile 0000664 0000000 0000000 00000016774 14643672530 0020742 0 ustar 00root root 0000000 0000000 # Makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
PAPER =
BUILDDIR = _build
# User-friendly check for sphinx-build
ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)
endif
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
# the i18n builder cannot share the environment and doctrees with the others
I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
.PHONY: help
help:
@echo "Please use \`make ' where is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " singlehtml to make a single large HTML file"
@echo " pickle to make pickle files"
@echo " json to make JSON files"
@echo " htmlhelp to make HTML files and a HTML help project"
@echo " qthelp to make HTML files and a qthelp project"
@echo " applehelp to make an Apple Help Book"
@echo " devhelp to make HTML files and a Devhelp project"
@echo " epub to make an epub"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " latexpdf to make LaTeX files and run them through pdflatex"
@echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
@echo " text to make text files"
@echo " man to make manual pages"
@echo " texinfo to make Texinfo files"
@echo " info to make Texinfo files and run them through makeinfo"
@echo " gettext to make PO message catalogs"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " xml to make Docutils-native XML files"
@echo " pseudoxml to make pseudoxml-XML files for display purposes"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
@echo " coverage to run coverage check of the documentation (if enabled)"
.PHONY: clean
clean:
rm -rf $(BUILDDIR)/*
.PHONY: html
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
.PHONY: dirhtml
dirhtml:
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
.PHONY: singlehtml
singlehtml:
$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
@echo
@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
.PHONY: pickle
pickle:
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
@echo
@echo "Build finished; now you can process the pickle files."
.PHONY: json
json:
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
@echo
@echo "Build finished; now you can process the JSON files."
.PHONY: htmlhelp
htmlhelp:
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
@echo
@echo "Build finished; now you can run HTML Help Workshop with the" \
".hhp project file in $(BUILDDIR)/htmlhelp."
.PHONY: qthelp
qthelp:
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
@echo
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
".qhcp project file in $(BUILDDIR)/qthelp, like this:"
@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/pomegranate.qhcp"
@echo "To view the help file:"
@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/pomegranate.qhc"
.PHONY: applehelp
applehelp:
$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
@echo
@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
@echo "N.B. You won't be able to view it unless you put it in" \
"~/Library/Documentation/Help or install it in your application" \
"bundle."
.PHONY: devhelp
devhelp:
$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
@echo
@echo "Build finished."
@echo "To view the help file:"
@echo "# mkdir -p $$HOME/.local/share/devhelp/pomegranate"
@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/pomegranate"
@echo "# devhelp"
.PHONY: epub
epub:
$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
@echo
@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
.PHONY: latex
latex:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo
@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
@echo "Run \`make' in that directory to run these through (pdf)latex" \
"(use \`make latexpdf' here to do that automatically)."
.PHONY: latexpdf
latexpdf:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through pdflatex..."
$(MAKE) -C $(BUILDDIR)/latex all-pdf
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
.PHONY: latexpdfja
latexpdfja:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through platex and dvipdfmx..."
$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
.PHONY: text
text:
$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
@echo
@echo "Build finished. The text files are in $(BUILDDIR)/text."
.PHONY: man
man:
$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
@echo
@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
.PHONY: texinfo
texinfo:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo
@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
@echo "Run \`make' in that directory to run these through makeinfo" \
"(use \`make info' here to do that automatically)."
.PHONY: info
info:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo "Running Texinfo files through makeinfo..."
make -C $(BUILDDIR)/texinfo info
@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
.PHONY: gettext
gettext:
$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
@echo
@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
.PHONY: changes
changes:
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
@echo
@echo "The overview file is in $(BUILDDIR)/changes."
.PHONY: linkcheck
linkcheck:
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
@echo
@echo "Link check complete; look for any errors in the above output " \
"or in $(BUILDDIR)/linkcheck/output.txt."
.PHONY: doctest
doctest:
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
@echo "Testing of doctests in the sources finished, look at the " \
"results in $(BUILDDIR)/doctest/output.txt."
.PHONY: coverage
coverage:
$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
@echo "Testing of coverage in the sources finished, look at the " \
"results in $(BUILDDIR)/coverage/python.txt."
.PHONY: xml
xml:
$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
@echo
@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
.PHONY: pseudoxml
pseudoxml:
$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
@echo
@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
jmschrei-pomegranate-8de2be8/docs/_static/ 0000775 0000000 0000000 00000000000 14643672530 0020711 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/docs/_static/custom.css 0000664 0000000 0000000 00000000407 14643672530 0022736 0 ustar 00root root 0000000 0000000 /* Sidebar header (and top-bar for mobile) */
.wy-side-nav-search, .wy-nav-top {
background: #A91D47;
}
.wy-menu > .caption > span.caption-text {
color: #A91D47;
}
code.literal {
color: #A91D47 !important;
background-color: #fbfbfb !important;
}
jmschrei-pomegranate-8de2be8/docs/_templates/ 0000775 0000000 0000000 00000000000 14643672530 0021420 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/docs/_templates/class.rst 0000664 0000000 0000000 00000000244 14643672530 0023257 0 ustar 00root root 0000000 0000000 {{ fullname }}
{{ underline }}
.. currentmodule:: {{ module }}
.. autoclass:: {{ objname }}
{% block methods %}
.. automethod:: __init__
{% endblock %}
jmschrei-pomegranate-8de2be8/docs/api.rst 0000664 0000000 0000000 00000011122 14643672530 0020563 0 ustar 00root root 0000000 0000000 =======
The API
=======
pomegranate has a minimal core API that is made possible because all models are treated as probability distributions regardless of their complexity. This point is repeated throughout the documentation because it has important consequences for how the package is designed and also for how one should think about designing probabilistic models. Although each model documentation page has an API reference showing the full set of methods and parameters for each model, each models has the following methods:.
.. code-block:: python
>>> model.probability(X)
This method takes in a set of examples (either 2D or 3D depending on the model) and returns a vector of probabilities.
.. code-block:: python
>>> model.log_probability(X)
This method takes in a set of examples (either 2D or 3D depending on the model) and returns a vector of log probabilities. Log probabilities are more numerically stable and, in fact, calls to `model.probability` just exponentiate the value returned from this call.
.. code-block:: python
>>> model.fit(X, sample_weight=None)
This method will fit the model to the given data that is optionally weighted. If the model is a simple probability distribution, a Bayes classifier, or a Bayesian network with fully observed features, the method will use maximum likelihood estimates. For other models and settings, the method will use expectation-maximization to fit the model parameters. When a structure is not provided for hidden Markov models or Bayesian networks, this method will jointly learn the structure and the parameters of the model. The shape of data should be (n, d) or (n, l, d) depending on if there is a length dimension, where n is the number of samples, l is the length of the data, and d is the dimensionality. Sample weights should either be a vector of non-negative numbers of size (n,) or a matrix of size (n, d).
.. code-block:: python
>>> model.summarize(X, sample_weight=None)
This method is the first step of the two step out-of-core learning API. The method will take in a data and optional weights and extract the sufficient statistics that allow for an exact update and added to the cached values. Because these sufficient statistics are additive one can derive an exact update from multiple calls to this method without having to store an entire data set in memory.
.. code-block:: python
>>> model.from_summaries()
This method is the second step in the out-of-core learning API. The method uses the extracted and aggregated sufficient statistics to derive exact parameter updates for the model. After the parameters are updated, the stored sufficient statistics will be zeroed out.
Compositional Methods
---------------------
For models that are composed of other models/distributions, e.g. mixture models, hidden Markov models, and Bayesian networks, there are additional methods that relate to inferring how the data relates to each of these distributions. For example, instead of just calculating the log probability of an example under an entire mixture model, one might want to calculate the posterior probability that the data was generated by each of the distributions. These posterior probabilities are found by applying Bayes' rule, which connects prior probabilities and likelihoods to posterior probabilities.
.. code-block:: python
>>> model.predict(X)
This method will return the most likely inferred value for each example in the data. In the case of Bayesian networks operating on incomplete data, this inferred value is the most likely value that each variable takes given the structure of the model and the observed data. For all other methods, this is the most likely component that explains the data, P(M|D).
.. code-block:: python
>>> model.predict_proba(X)
This returns the matrix of posterior probabilities P(M|D) directly. The predict method simply runs an argmax over this matrix.
.. code-block:: python
>>> model.predict_log_proba(X)
This returns the matrix of log posterior probabilities for numerical stability.
API Reference
-------------
Distributions
=============
.. automodule:: pomegranate.distributions
:members: Bernoulli, Categorical, ConditionalCategorical, JointCategorical, DiracDelta, Exponential, Gamma, Normal, Poisson, StudentT, Uniform, ZeroInflated
Models
======
.. autoclass:: pomegranate.bayes_classifier.BayesClassifier
.. autoclass:: pomegranate.gmm.GeneralMixtureModel
.. autoclass:: pomegranate.hmm.DenseHMM
.. autoclass:: pomegranate.hmm.SparseHMM
.. autoclass:: pomegranate.markov_chain.MarkovChain
.. autoclass:: pomegranate.bayesian_network.BayesianNetwork
.. autoclass:: pomegranate.factor_graph.FactorGraph jmschrei-pomegranate-8de2be8/docs/conf.py 0000664 0000000 0000000 00000002123 14643672530 0020560 0 ustar 00root root 0000000 0000000 # Configuration file for the Sphinx documentation builder.
#
# For the full list of built-in configuration values, see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# -- Project information -----------------------------------------------------
# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
project = 'pomegranate'
copyright = '2023, Jacob Schreiber'
author = 'Jacob Schreiber'
release = '1.0.0'
# -- General configuration ---------------------------------------------------
# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.autosummary', 'nbsphinx']
templates_path = ['_templates']
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
root_doc = 'index'
master_doc = 'index'
# -- Options for HTML output -------------------------------------------------
# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
html_theme = 'sphinx_rtd_theme'
html_static_path = ['_static']
html_css_files = ['custom.css']
jmschrei-pomegranate-8de2be8/docs/faq.rst 0000664 0000000 0000000 00000010455 14643672530 0020571 0 ustar 00root root 0000000 0000000 .. _faq:
FAQ
===
**Can I create a usable model if I already know the parameters and just want to do inference**
Yes! Each model allows you to either pass in the parameters, or to leave it uninitialized and fit it directly to data. If you pass in your own parameters you can do inference by calling methods like ``log_probability`` and ``predict``.
**If I have an initial/pretrained model, can I fine-tune it using pomegranate?**
Yes! In the same way that you could just do inference after giving it parameters, you can fine-tune those parameters using the built-in fitting functions. You may want to modify the inertia or freeze some of the parameters for fine-tuning.
**If I have an initial/pretrained model, can I freeze some parameters and fine-tune the remainder?**
Yes! Do the same as above, but pass in ``frozen=True`` for the model components that you would like to remain frozen.
**How do I learn a model directly from data?**
pomegranate v1.0.0 follows the scikit-learn API in the sense that you pass all hyperparameters into the initialization and then fit the parameters using the ``fit`` function. All models allow you to use a signature similar to ``NormalDistribution().fit(X)``. Some models allow you to leave the initialization blank, but most models require at least one parameter, e.g. mixture models requires specifying the distributions and Markov chains require specifying the order. Other optional hyperparameters can be provided to alter the fitting process. the initialization is empty (or requires a few parameters, e.g. Markov chains setting the order.
**My data set has missing values. Can I use pomegranate?**
Yes! Almost all algorithms in pomegranate can operate on incomplete data sets. All you need to do is pass in a ``torch.masked.MaskedTensor``, where the missing values are masked out (have a value of ``False``), in place of a normal tensor.
**How can I use out-of-core learning in pomegranate?**
Once a model has been initialized the ``summarize`` method can be used on arbitrarily sized chunks of the data to reduce them into their sufficient statistics. These sufficient statistics are additive, meaning that if they are calculated for all chunks of a dataset and then added together they can yield exact updates. Once all chunks have been summarized then ``from_summaries`` is called to update the parameters of the model based on these added sufficient statistics. Out-of-core computing is supported by allowing the user to load up chunks of data from memory, summarize it, discard it, and move on to the next chunk.
**Does pomegranate support parallelization?**
Yes! Because pomegranate v1.0.0 is written in PyTorch which is natively multithreaded, all algorithms will use the available threads. See PyTorch documentation for controlling the number of threads to use.
**Does pomegranate support GPUs?**
Yes! Again, because pomegranate v1.0.0 is written in PyTorch, every algorithm has GPU support. The speed increase scales with the complexity of the algorithm, with simple probability distributions having approximately a ~2-3x speedup whereas the forward-backward algorithm for hidden Markov models can be up to ~5-10x faster by using a GPU.
**Does pomegranate support distributed computing?**
Currently pomegranate is not set up for a distributed environment, though the pieces are currently there to make this possible.
**How can I cite pomegranate?**
The research paper that presents pomegranate is:
*Schreiber, J. (2018). Pomegranate: fast and flexible probabilistic modeling in python. Journal of Machine Learning Research, 18(164), 1-6.*
which can be downloaded from `JML`_ or from `arXiv`_.
.. _jml: http://www.jmlr.org/papers/volume18/17-636/17-636.pdf
.. _arxiv: https://arxiv.org/abs/1711.00137
The paper can be cited as:
::
@article{schreiber2018pomegranate,
title={Pomegranate: fast and flexible probabilistic modeling in python},
author={Schreiber, Jacob},
journal={Journal of Machine Learning Research},
volume={18},
number={164},
pages={1--6},
year={2018}
}
Alternatively, the GitHub repository can be cited as:
::
@misc{Schreiber2016,
author = {Jacob Schreiber},
title = {pomegranate},
year = {2016},
publisher = {GitHub},
journal = {GitHub repository},
howpublished = {\url{https://github.com/jmschrei/pomegranate}},
commit = {enter commit that you used}
}
jmschrei-pomegranate-8de2be8/docs/index.rst 0000664 0000000 0000000 00000007204 14643672530 0021127 0 ustar 00root root 0000000 0000000 .. Introduction documentation master file, created by
sphinx-quickstart on Sun Oct 30 18:10:26 2016.
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.
.. image:: logo/pomegranate-logo.png
:width: 300px
|
.. image:: https://readthedocs.org/projects/pomegranate/badge/?version=latest
:target: http://pomegranate.readthedocs.io/en/latest/?badge=latest
|
Home
====
pomegranate is a Python package that implements fast and flexible probabilistic models ranging from individual probability distributions to compositional models such as Bayesian networks and hidden Markov models. The core philosophy behind pomegranate is that all probabilistic models can be viewed as a probability distribution in that they all yield probability estimates for samples and can be updated given samples and their associated weights. The primary consequence of this view is that the components that are implemented in pomegranate can be stacked more flexibly than other packages. For example, one can build a Gaussian mixture model just as easily as building an exponential or log normal mixture model. But that's not all! One can create a Bayes classifier that uses different types of distributions on each features, perhaps modeling time-associated features using an exponential distribution and counts using a Poisson distribution. Lastly, since these compositional models themselves can be viewed as probability distributions, one can build a mixture of Bayesian networks or a hidden Markov model Bayes' classifier that makes predictions over sequences.
In addition to a variety of probability distributions and models, pomegranate has a variety of built-in features that are implemented for all of the models. These include different training strategies such as semi-supervised learning, learning with missing values, and mini-batch learning. It also includes support for massive data supports with out-of-core learning, multi-threaded parallelism, and GPU support.
Thank You
=========
No good project is done alone, and so I'd like to thank all the previous contributors to YAHMM, all the current contributors to pomegranate, and the many graduate students whom I have pestered with ideas and questions.
Contributions
=============
Contributions are eagerly accepted! If you would like to contribute a feature then fork the master branch and be sure to run the tests before changing any code. Let us know what you want to do on the issue tracker just in case we're already working on an implementation of something similar. Also, please don't forget to add tests for any new functions. Please review the `Code of Conduct `_ before contributing.
.. toctree::
:maxdepth: 1
:hidden:
:caption: Getting Started
self
install.rst
api.rst
CODE_OF_CONDUCT.rst
faq.rst
whats_new.rst
.. toctree::
:maxdepth: 1
:hidden:
:caption: Features
tutorials/C_Feature_Tutorial_1_GPU_Usage.ipynb
tutorials/C_Feature_Tutorial_2_Mixed_Precision_and_DataTypes.ipynb
tutorials/C_Feature_Tutorial_3_Out_Of_Core_Learning.ipynb
tutorials/C_Feature_Tutorial_4_Priors_and_Semi-supervised_Learning.ipynb
.. toctree::
:maxdepth: 1
:hidden:
:caption: Models
tutorials/B_Model_Tutorial_1_Distributions.ipynb
tutorials/B_Model_Tutorial_2_General_Mixture_Models.ipynb
tutorials/B_Model_Tutorial_3_Bayes_Classifier.ipynb
tutorials/B_Model_Tutorial_4_Hidden_Markov_Models.ipynb
tutorials/B_Model_Tutorial_5_Markov_Chains.ipynb
tutorials/B_Model_Tutorial_6_Bayesian_Networks.ipynb
tutorials/B_Model_Tutorial_7_Factor_Graphs.ipynb
jmschrei-pomegranate-8de2be8/docs/install.rst 0000664 0000000 0000000 00000001176 14643672530 0021470 0 ustar 00root root 0000000 0000000 .. _install:
Installation
============
The easiest way to get pomegranate is through pip using the command
.. code-block:: bash
pip install pomegranate
This should install all the dependencies in addition to the package.
You can also get the bleeding edge from GitHub using the following commands:
.. code-block:: bash
git clone https://github.com/jmschrei/pomegranate
cd pomegranate
python setup.py install
Because pomegranate recently moved to a PyTorch backend, the most complicated installation step now is likely installing that and its CUDA dependencies. Please see the PyTorch documentation for help installing those.
jmschrei-pomegranate-8de2be8/docs/logo/ 0000775 0000000 0000000 00000000000 14643672530 0020223 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/docs/logo/pomegranate-logo.png 0000664 0000000 0000000 00000056013 14643672530 0024176 0 ustar 00root root 0000000 0000000 PNG
IHDR sRGB gAMA a pHYs od tEXtSoftware Adobe ImageReadyqe< !tEXtCreation Time 2016:10:30 13:11:42ol [NIDATx^_lW/H挘bHF` bµI q0Ag; ۑBbg"C!`7%q 0
As1A3kʞOڵV~8۵V?Z3O<;""""""""3/ """""""0TADDDDDDDa P
"""""""2CDDDDDDDd* UA """""""0TADDDDDDDa P
"""""""2CDDDDDDDd* UA """""""0TADDDDDDDa P'OM"""""""[/u_ JW, )*(U'[l N`\ DDDDDDDd*(U -1TADDDDDD59EPyFvV"b P*##]n
""""""J՜ E2*\o n -DDDDDD CWnLCj\I +wu~^6ɿxdSѧ """""f<'RP#c[;^zT5G%v < [Y """""".*H =SH<(_n1TA}7}k?q 1ejk=8_D. GVx?djF liWv _n',
22-q!u73t !m@8k |2fLTs(f *FB~bk*p{n>Q(wx vףo PL633{y~ʷH%\GW E_H? M 43(daQOO]
{ tvDd]W"3z4ګi{9t&yɺu7mߋRh2 N1Cjza
5 ~8}8YsP,T} *5 4d눫5 ?z Uh# -pքj i+<6C8(;dB-?\D;Fq ʗeE( DbJ='|BSg/_lʴ(wFQ0)n$xn2%=Ȅ*Gfԍ7UVd= tђjӂR< 8Վ6[25?,jU[lMŖ
N]Gh5lMePս[= 75Āb-9cokr{Vq {L-ۡ
mߤZ)8D7 wDRѰFr{M6zG|,:4 :iܺ:}BLP+Їv= NP
Iz# hSpь Z EYvm06`aŅzW
5ձCaDSz )4ݽ@{c "hS+!ЂA;frQŽo`j Zo4l93)6q PD܅C&$u8ŒdݺPfȇ'F15-GȣP:-Jh! mju
i= `bͥx?FG)0~!LLm,[c{8
\\ 6>.rq]7ߨrM;V
ʢV9oLa ɷm.6#8 ĀƄ+w2I*pWmO@)n7&Ci2Ŵ Ipan+#c~][$mf漚m-hs..T;kM$ETŌÈf/Ňm:+s{obC IK߈i;]n8 &l+Q إ[}>"\ Px̯ ΑL ŔOL _eƲ52 Cz4l1a$E,?oD[d[;l:.n -x<2m݉{Sڰi!j|Z ,.1~o& ;cNE ;cQ u{P O-3iFG|rv*E`N! 9ykKGOx\).^ɨNDlicH]U":BŸ~i4RP g@6N\o<#PEu@+} Tr8?,l۵A&63sֺ⢳ )ķ{S]~و F]SoeL n[\4VKE E;kNcg 9z֩ X dSt9շh˄1x jxF6*Hu!OB $pИCsD&Z [UG/HA̼]^xI, T5lQȄDB&Lb7d1|/6,}+6)Uh
zJܖMM$B'>6vޜi z 7='ӎ*hR$"`| yeB[8z2A&̆h{bW[r"{jPvs3o~x4wMΪ8A2Aasp|p[Nu8PRKX\Y]b}x=%1}q0mmq"v
tN\ϸ̏SψÅZQ@y
lz
?eʴ 2 +!
.8 fg.x=āc*0Z 'w
RӨܚĉCWŐ b-k ZW 'ZS4q/.\Z^ ӭn5#[ M>2 拗%LI9_7?gl͑ZDk*Ծ
5 o P/\HجFd3wo:'4ˊ
^lT|gzc{
|7 plS1TaUioзnLP( Gv{oqEOE b*7~O'R*íkZWkCL'WHsPƄ `
VZ[>m>˴y4GRf͂Q}Mxθ4qu6jYd:. g\®LjLPT\btլwbAK P~{"CoXXrUI}8n/T)Va*Mbz
P}kySo dͥxaɡ+?n ffN_ k:^![05 }8Ǯ̀? #j8;ztZPVgr -P̂^^|* .[ѦV5g@\o۫SnYֱ~zʒ#й8Ԣ?`/b
qBNȐzD[stEb/wZU-l*{[#۵aw!iy9 w'F@W^X&pB r^=VW'4LQ>.#/7)Sګp|<-YU.ZE,CTZ1T!į\P
z㛫FXs66F n
Y]w,~2bK}pT r
O[ZƅcXLp {*gs2=
칍[A UAYzޭg| 281bBx?{'\LM_}Z.2Vuq*J? JgS*L^
gVh Jl.;-! sLnt6TT "`ǯX\l;!ΈJ\C )ViJ _Tl-ܪ/b̃K@&N ZE؛X~['| GjY|>JϤq,C]&|}imSt%MNTxdO/tmQQ:wSn+0=P@g)E&v:s.;
[aWtP&T_#ʠus >\Gk Fɣ
z } ~b/D7 o9ՂW+U osӝ ;/6S .4XAaEduWeZhS_*P@+pvU
: _82CWn-2ЭHGZp4s"PL-
%xȝ ~[
J ٣FyהL% ~1^ )($seH PKV B8y?
5h9Hz>TEٕ[7-P;ۿB l6umvwPXrn᪻ߢ;![J ڬe -(
mB=W&FVH}\.ހ lTli٦zZ 1j=VU*_494S5urfw?) &%4|~`*`W[=XT[Fݠ;b&d(ƢFL8
5@Ev܂GZ8hV>
4]P-{P_Ҫu. -T;(pM"@(=7Fd&vB)4D\/~or T5tZp{5i˦LMh} ]akh e7>S[U1hʛE=*sd,>DDʔJ Su2SH⢳7*P`8\*bR:yLSK4\2m a
`άS6byLu
ká
ԯ+!pJ0G|<2r&ϳwR9t%|g@64M
UbQ y]Q02:.zU)h8evtڶ.a={OkGi+?ל !l`!zFؠacXgy 4TC UP18>}QB>bȐW*{íf+~]"wm ̜8Pۡχ*3Yhw|
(qyʄӖ-[9ޒ*ƟΪpUԣzh8Kn7nCCTĂ]a"J==|= AЕ [z?HWC{woWteq*l (0}]T5?1}q~6T۵aEi$4 Xd F"S/ U(&CգW!rq #zYKM-;G5SX!<-Kb VZ!h
JWڢ4T=7dL>ӑۘAgŻ ?~Wo?oU~Oi33EH"<1ej: SONޮ~S< r\u'B #5BG= P JX@_99'Hz鯮)Uh
B`QODe 2v̹TG!ǴU!A^S:Hg@ ~.PgCBzjy_enevg= %ӬSFTGyj+N1t;a"{yk ϫf/Na1p&ɳv{p1R=BsSQx-xZGp7 %3xpzjpa[*
90{}omq*T/ oO:{ T V y6,iڟ6Ӂ2}JUH ~Qߍ͉%E5l ar^lIp5T0Ci^OԻY%ǃ
E^8E*,6<0pHaQXi , OnA
CqG 7B^;ېEr4 5jxELNfޮ
%_6Z ADdv : `mښўAlo*O[[í&lE9(*dxd{ApWCgpR7ʉF+ RqqYKh=#c;!1LnڐLU߉(mD?S&FѓT O>:Kū6Y>l&
Pl LI^ĕ;v 4է~P"## *<4gxF4OW e(| UBb>ˎW*C+K>hnk = L@ꏌ
0ejzޮr7i[b4x$·'(qZcӿ빸*WnU }{2LM Ȅ(PDj4-ݽJQN>h+ccd P/ohaTW~y OV:y1$KOB%|P3
ű
kvhWj>~ f+hI8bԟXn^=fLA/tq1T`
{ j9d
=Wddw^lֹkC{[՟]ɋ$Yzqԏ|pVE@Py3[c~.yx/~b
UEg?H=N0*ڢIu8QH`?^D
G '5:A6::iLF)H-Qt|v!*n> aȌ-[\\4ܣ8;MneX7qCn5(;? kyjWx E8P[-mcٚeEOxLQ59)6q$'sSSL^Z5^H518 }Rȸ
u [8_Gdߺ99:gg0B.P TP0qH)g .'h7T(IIppiJGfs@D!VւrB|@AFFZ>MۥT,̟ _<*]YǠHkLly GܼuػvuL(Rlޥ̌fq I?z}{QgHVAO+OO_Qd
vusuj[uZÆ2gcٚg}Յ'>ܻ{{ _6ŇGgN E6-֦hq"-dfw F+Df{ddxx4%ÄzFѦmōPQc6j:h82T n( g _Zy&f/i_t'Y
_^=% !?E`?;0|8k]1>f MvGKj吊-{٦\E`: 3aWn P \l'] 'āCp?tܕQ:(]auȀEdy ,:L0~fvT{%B-"hWŁ9#:xmqӂsrcMhV9xVCFF%ʚ)TB:= 3CƝG/uo2pY)Sӭ?1AG=aȣ4D 9>Z5!WJKcZ[GB;@MV$gi賽0[I
6
P)09?Cf,^Cpo@U8[ڲ)ݮkk{XC*4 F+7,jZyvmJڬ-e-/96hOSr'8
χ*
1Y%L8j̬) ]oNt 65#SC$Y]zK"*Tw"ZFD3cʇh.@%V=ӄP'
Z[CQ[UZtek+R_ vs}{ 硘25I.P
;uH/$q7j,h쫫GqO-e~[]8EvV&[-:3\k\S}|Ce h*o4 w hw9xZ4]%X\n)0}q+R1~oʇ7{ &O!w=
"I |6a-؍oӲANѲ5 [QuHn~uFX4n";+ӭ \Pw>)(eFXBNXhx=U. |͂*)GvR G25=o׆/g+.qIͫ/υ
Ux߾ /r6'[P :*m i eE{wor\DFO^5 (Bs,IiC]e9j&܍CܺAoK
< * -ђU;kph"АM F_OUC=xa#4t˅?otޮ
q l+:~QgӘ8C*ȣPx' ,R]gER ;+@M7_]!^O|wJW8x; l͑Z!Ķ9y ZY_SCgÏr|'[J*psTE%Bnidv
G?rZzm qиBkGQΟ\h-(Ag1/-]íBÐ
5쭋㑱[Z·7S"`j%~)//qaCpzOz "CT?S(oѤP;qgnei r ?ãN5 47ćݽ 7_]Ga[!= rIQCy3%Z6)yÏ=7'qޓO
pEGH}LX !@s+/ޤh( 9'ǜ jkU!H24?UgLGa *PERvucL`$cf12AI
ZBO+,ywTz:ZjS48/?UR6Ys߇u]H_ F@*BU]VML
.N1p-VB'"d zX( /-[Diۀn d4)xE :Xt+ߓf:s>z92<4y\ū6
|샘z7/lYQ
LQp
C&Z.{baL{3֜ rLQAy&HF&9JXwv /Z8_kl}lv2matr+4>t ^[/j9';/f%iDH=/u8ނBCt0X#0Μ "f2_> ܊Y5Cj5ej2AJ+\-p|!32
:o/?bƓ- GX n'Poz7C]Wڲ B]\M CfA>P[-.}r=FLLaֺ8ъU uC9\T0.յp=QB,ѓ-%
2u/- ?& "y:Lh
kv 72
eKc+<HOOC ъ4LM/:A.72ᐻ:E"ᐍK {~
"CGaEA}{[,Zf_]} O r&{
de\sh~ /=
4 Zޮ
Eg?Hp8NG 7·{)LM_Pig[H U(BM+4E<^,X#MЈ2sqɲ29+~[Zx:W +ܻ{;qxl
OG+%_6nvxí2{:^m|H=-89Q|h6BMʲ`lԱdUy?rOP ;K
tv3Zl
i5E& M|ZSϫVtg?z}{
]P`Q{i334W16p *g(Ƚ,l)YUޜA#>@2 Zzsrs2a dxyll|s8| Mw9y4&^p"q:rz4}\N Lq^6 }pSֈţ7?uymzNYP 3o׆/͟Ag ̻ϸR8Th[^|b@;,+µ_X[c}b)~v)زwr
MMܻ{xEbs"ٲb3'UP`$CS ͫWt۵㑱ímz_Ыʮ{C"oYy#¬u%_6:J z 3cW<> "lj6m{g_]}@ƫ{eJ K賉;
!&JIAɌQ!0tSCq
!g
O [;.[P*2{GhgNZWZ G?ieXJQʡ-XP~CaZ{ $aAD :&>xx 246^e;ű{eB
:KUߨLdB%
E=zoX0;g@%jqS.k4xp||BoQj}HFix ff=}awMD9Fa)f̞ٕ6| v+| 'ܼbk)N
D]T 7C鱬h+?!=Du7*kgsG`73%|#q NB#>qiz p47 >* q& *bs. "@0db?'P(0_ BVb҇'WDŽ'G&?wE:!_2b;3qN 9tk&u p2]% U~C
v1()23y"Ei.v&] PZhj """Hq
+' \MDDDAP*W7m{gȍEa9/T
"" b(U:b0^:gp(?.z8')PQJБ 22]|"ccٚg """rCDDD)'ݩ.OPsOCDDD)ZքDB&
""a(%zʬZ.nSa0TADD=UTl1+4P<;+S&㴚DDDAP}Cbˊ
1^_DDD{ UwOrKLn$p~""""rCDDD˚2 s|/1TADDd:=a
""" |濾Z%"""C0TADDRw/u-Lk1txӶw4?ROCDDD*?7;+S&~`pmَkdڷv-ҥbK""" at\(^1~`p_]=ѓ-XFs ̓'O]noL(Sr+o?nNn+-I{oqZW_'##b3 ""
&*BL(;+`9WĞ?0{?H}ΥU( U9g.Ȅ12f<'aFG\ 7Gʒ52ADDDPc_E3GĜܜ'> DDDAi5{o-"""S}V&(y8j ""
8B#r({22OP( U+[JWT f3yHҕ%2Ag U)q
+s SQCDDD >cHҕ%GkETˊ
""<DDQGwvq(*τ*FG 6`8@aEDDD1ddݽ2[Pc cBDDDq8P%2 $ˊ
+݉()^V1""tt;.gysOH}mGu^
U"""8tuG x &9K
""" 7A
"""'OMJVy4H}mpQР2m}[ۥO/zzeɆ߬ DDDd%rK國|Rǵvu˴G,+*|ҕZDDDc*qcW͏Y~fd˷RPFGzn]mCÚp/L"""R
"""?{ ~˝AlwHS0?"H1?(H)*yg`pdtܩLdgefĆؖFDDD CDDDXCVxG`8 s6d ldxQ """r CDDDDDDDd%"""""""2 CDDDDDDDd* UA """""""0TADDDDDDDa P
"""""""2CDDDDDDDd* UA """""""0TADDDDDDDa P
"""""""2CDDDDDDDd* UA """""""0TADDDDDDDaw^c= IENDB` jmschrei-pomegranate-8de2be8/docs/logo/pomegranate_comparison.png 0000664 0000000 0000000 00000156127 14643672530 0025501 0 ustar 00root root 0000000 0000000 PNG
IHDR 5 F sBIT|d pHYs ~ IDATxw|% {S>FVHګV)EjԪӪVR_SUޣLlJQ$V(be^?- iwnn79u'92L4 N"UJW AM N& BP S! TRt Y,ߗ/_noGUjUJ~ϟֱv
ּyTr$'((Huԑa:u3 ~-]Tǎ ӵk .WWW˗O+Vo!$yx;ƍsުU8N4IӧOW6m4fI +u:q sJ2dV^W^)] 23qe]Zf :EGG+w*X7nF)C )]zK0aZhoY,m Zd߯`ݻwO3gVVZhѢ|ުU֭[Zz/ jDP aY |Ae7mڤP1/ʋ^L#Fŋ"yyyUwd4hwnwΝ;ս{ҋ)S&u9E:õrJ[]/^ oPSJ> ;1xyܺuK P@@RJ%UTIҥSPPۧݻw뫯ɓUWJl jݺk5k0 uYi.\8HTT&L ~A*P|}}5kVݽ{Wǎ ӬY4{l>|\\\bO>p֮]kθϹdRP!^ZCUqx]|ҥKL2֭[/)cѢEZxrʥN%Kˏ֬Y_/Tf8qinnn>|xJW#Q6lؠ;wZj:qℎ 9]Ŋ qc3^ wo`yyyiرzWܸqC&LڵkթS'͟?_*TH#!{vQYF4lذ]%6}ѪVZ2vG }ڵkob9q2f"=5 ԬYSwі-[,s
ٳG+WVڴi_`RΪUd:v
IJ*zjժ)K,ڳg]c^TUU-Z$0ԴiSիWOijɒ%)]- @ g881rH|={v$Ν[_|ׯ( 92j
g5o|8u}5kLEGd+ŢRJٕ}ƍ| lkZji̘1zAk#7oڵkʕ+lٲ^ەZ,.^< },V:͛7bѡCli2e7o+bŊjҤK sOyz*WjO>$ 1pq1θp6l 04zxa SYvmY,kj<==]ɓ+WhРAZʕ+^{M+V|gΜ{եKy{{|z4g WX?OOOOiVnʅhĉjܸʗ/okӧ+,,a 8p
諯te 9RWUbE5mT~BBB}}2 CC Qy-?~
wyG*W4hSsoݺuڵ|||lcAܹSE[֍7ԭ[7yzzjر2/^_3驆
O>˗vd,?dlٲiݺqr ⢺ujϳyf
8P*UTG Ú:uV^+W\c =N:)<<\%K߿3g̙3qy֬Y/*U*y{{PB
ݻ}vG[R`A?^/V&M>}z +VL;w֒%KC5h@y-QV =w^eɒEիWk. 8p@{ 9rD=zPhh|||TjU]zUvΝ;5fi&{T߾}uY5mT }Q` +Wnݺm۶i
ԩN<,YAJ>nݪ={Yf ^3.?$Aʘ1+?͛հa$[CM+WVΜ9umY7nСC/Iի"E؝k߾}rqq۷c-sΜ9#777[~:t+W( ̙3zjʓ'yڵk Ν[͛7aڱcߟM 1pq)=ذaLT
Θ}ZyճgXIߺu>sժUKŊӾ}g 8qB?U`Aխ[WOѣG5l0Ν[ηeM:U*TPÆ
umm߾]Ǐsl/N_&MÇq*X-̙3۷UH5iD >T``&Mkyʜ9˗/M6w
*z)<<\˗/Ç_vBի >|ŋQFԱc4{l\RKX+00P7nPLԴiD]Yf?~n I&ʝ;6m$777˒q 5J+VTƍ۷kʔ) jW>?tWrҹsn:_^&L1bnܸ-ZL2۶mG |i:qϟo{/32 iXL41cƘŜ1cFrǎ 3 =ziiX̠ [[n*U2-9|N:߿]믿nZ,sСv٨Q#tҦb1 8`;tiX
*v =zVyW\ظqn9uTܹs>N1n}v2keʔ1CBBl-^={J2˖-k^v- 2dnvUcǎiN6.СCc\bKgիWm ?6tbV\ٴX,alØ"""L???bϘ1tww7vtww7?C[ڥKl ĉMwwwiӦ;wmfZ,L2ٳgM4e˖{gW688tww7{iZ,sv־կ_?[ZΝMb4 nv<ƍ3f͚ ߿nvŌ?~رy]lG Isczb1'M}]l߾}zv2e-mǎ ٨QXVjZ,ܴi]yLwwwbŊv?l5j0/]dwƍҥK*T{֬u6;vhw>4͡CŜ:uj:N6ʹX,-X~ ɨe˖2MSK.tRa[Ȋ+t}*UJ :tK& .4eݾ}[ғ%M
dwL֬Y5x`EEEźw}'IWJ<<<ԵkW ~!q7 ziJ:^ɓ'I&U߾}5w$-(Pƌ?X˫R
.( 9rĖuVhѢjݺ1jܸJ*_5~Zj*Vɓ';|b\ϯ^z٥UXQ
$oUǏÇ}ݘ6mڤ[nPBlR...ڷo^sKO-^Xaߗ]~͚5UfMEEEhWv2 CRN߿_az꒤_USL4fIV6mڴ裏!CۮYٻwoeȐ*UD͎qFl3 1g>O+0ԨQ#2eRm3n4M;w.V] Ð4h`mgݺuH5iD2eKߺu~w(P yc IZrm{G i֭2 C {>qFݸqCS |TRСC<ϟQ`Ak=q5kTݺuZn-0#ݸqÖ>k,{/իFw:w Y
~o Ě-oDP Q2eTD ]tI GDDhڵʘ1c c
aY|Ţlٲ)**ʶ7ˉ'$=y+hUVuVOkFUV-IaRSWV3gNa{qT^=unbŊM6jҤ|{"Z1-ZW_}a 5sL,YR3gTt]_0 J$>u=u$ IJ _u\rF[/ :}BCC:uj9,c]>c ̙S%KիWm8s/ ܷo$.8i)S&go-{u~NE 9 qc3R~a
Ƶ?1?c*W\4^*T4ݿ껕*Ui:}--)%&GuTbnϯ%J(""¶3g 4i#1%gK@@Fʕ˶Pb} x>f :W6>^B.]:R 7o%489-*4g5IJ:<==cmoĞ Zh>L?m@eݽ{Wz_rERr(P@wQppt?lٲ?{2 C .tyu#[nʘ1c|"EhĈ1bΝ; Sq}1b괎?crqqQ,Yb
ԩSԢE -ZT~~~VV ̚5k/Rׯ#>}z-_<%acIyWWWI2#tGO/"Go}2 Ca/ŋ7ߔdI ۷ok̘1Zxq8r䈺u (SLVܹm~ze!_msYrb
8Pi***JKrK͔q| /iJ& +ߺ ڵkڱcG6')}Xzm-ZŋvmWʕ5c 8p,M~}y7aLKO0h2a0{ YF !{@ nKKJ
stIb
&'y}^SkK/>S=.]$0l'Vb~nyq9g/= t/YD+ty]xQ ,PLԵkW;
j@2˕+k.mذA5jЮ]/_>K b Gy
&EW P߾}u &m VZc
N<khmw>s sʥל9sgPKN1q}ϺUTTmXK%K$)>l ^^^ruu-UYreIOz7mi\d=_5aDo""",߽ 81ΰ<+VԦM{D a NJ| Nǜ 20 CL1Iy^_ј0.\~=H mU` S&7k]\\lu${ =zڵk֭[{jzqmS F[lц
^{-Ƿu)u)u/뾀O~u̙5kV=o߮;w&X6'd[vԆ
i9bѢEjР h
6,6l
ٳg٭[͛ʞ=N|' AڴiըQ#jϞ=*S~iٲfͪ~-֞, <иqdZje[rQD +VLѶoBBB_;;s2 C+V{ =zCO>މo(wܺu~8Ν;Yt9Ͷmj̘17`vFzWɓ' wmٲEaJc*O<ڷof̘o٤[Lܹs~1x葆
%7V][j`y =uرL_|k5kg KNmڴ˫ZLʕ+kLٳe-j.___EDDh̘1۶mSնm[}ef̘a,""BGNh <1xqF%8jذa*Qo:&((HӚ5k3gNM86#4)y1MS;w֭[wޭ={0 5
IDATnXRKBjԨŋ{?~|%KԷo_uI̒i2e1 <Є ^؞St
}vy5jLTݺu|)Ӛ7o-[ԩ×IO> ;jӦ6mjo}CBBlmw4M͚5+־7oԀ5k$| ?5l0 ;v,VmC,X? /;EZh9sf}gׯƍUV]wum/_>K^gϞZpN8e{ڱcjժ 2~;bŊzg[nQ"Et][SٲeիW$AL4k,G V:uTbE)RDiӦխ[tE>}ZR[oݻlٲ:{ƌ5k֨PB裏Խ{wM0Aƍݻ'O ;wNG ѨQt ?~\gֵkԵkW)RDu릙3gjϞ=*]nܸ;w***JÇ-K֬Y駟_SL*VvrK.Zb^&Mf͚J:vܩ|m۶EgŊVٲeUD7iDǏŋ(//g{^t!۷O
6db|ҤIqzKbQΜ9cV^^^2 Ə Ν;kͪW&M9sFG Qԩ fgJR>}/jܸ {*}jڴ.]Lm Gr32f̨ ~Ao߮ ;D*]2dȠ+Wh߾}MfJj| o~[EHQ:vh')I%/M
W_}%-ZH{f=yN>kܸqv/I2d <۷^´k.)RD~~~C4iW_̙3m6)SF >ԑ#Gtu(QB#G| ?^sٳ5h M8Q*UR֬Yu] ?~\ҦM>}o߾QxqO^Wf͔?~ungѲeK :tHK,Q˖-UjU͛W7oݻcխ[7?gϮ_ǏWvTR%)RDaҥK
T4i &$5 8sSm&իkҥ5kۧSNUŋW^ԶmX߰VZUMcǎٳ*Xz衷~[m۶ux]CsÇtҩXbjԨڷogcdɒZfVX_~E ?He̘Q
Pǎ ժU+.]: ua =zΝ;+::Z-Ү]ҥKﾓ߿+ @۶mSǎ %Iʕʕ+5}tܹS˖-S'&~}||ԣG͘1CC {krM?&M;wjݺuʟ?ZnݻoxKOfX_Yғ_*ԩuiɒ%- I&f͚ jժUڳg+W.lR]tcj*J*R$777(QBgϞU| Jʛ7~g}ڼy6lؠʕK͛7W.]U h"M4I{˕+W.ժUK дiogčqF$8i3gӵ~^Zڲe={vUVMM4Qƍ ;)SMėWJj̙ZfThQkN :t+b
jW%Jhʕ5ko߮5k(**JyU۶mյkW+vǸk
8P[֒%Kg ۷OS,YT`A5mT[sh,Y4vX}r =zddN 3FիWעEt*cƌP˖- 4kǷzKŋO?cǎĉRܹռysu9a&& ?~̙.]hذa)] o gԮ][W^ܹs$fj v횎 ?iӪf͚ =*0 & j :q'777-\Rɛ 9ӫN:)XK g ' KN:jذ6lؠ-ZFʖ-Ο?*UT5k֔* p23 & /h-[L-ҹsYS:uz淒 X1pvںv̙ÞK& A֬Y3խ[Wׯk7nf̘?\UT$eϞ]Ou\Z^^^
j˗OKҵK.
6)Dw]vձcԻwo; TTucǎ0ue ^>ɓ# ;V=5 >>ѣM2EE Ғ%KԴiSyxxO }oY:uRժUڵkkĈzj R35_b\̻ﾫ={}*Wm6M0Aׯ_СCjڰa%J(G
$]zU|z\rI p8{222R={T2e͛;wy -\Pe˖}{Ln1uֺڵk'www觟~R.]4}tUVͮ? =v)sZj-Z 2hذakjРAP̙33gvޭ5k(}t_ x~j|||G*gΜvywծ]TV-}ᇶ-[j s$Kӆ
ʕ+gϞ= TBs
iF}/_^5k&MLPb2eBBB_qƶ&MaÆ?~֬YcK7MS{պu1cFIRFTF
mܸ\j Ќ3f;Ssх Ttg/ } ;7 dL͗ܕ+W$a Qz2#bŊ a]VTF
5JyM1g2<$I ?=9=|PzG ٥M6s/_^K.ٳyf :tH&MR5tPիW/Qu5?QRәЦɋL~i= ms)]Dqzv5HcRWg?裒SNiY%9s /;w0 yyy̙34h@
4Ѓw^-]TuUV)U䛐t^ԙ2dWp3?K6Ej̘13f ?͛7kzw5oyxeKlӦM:wիg_f\2f̨uT^=?^gϞM:ݹsGg+W(G ruudX.\fΜYrefstbŊ%1+WNԧ~hmڴo ɇK*00P ~4deo߮ڵkkݱ3˯5v/^l ;vݻʕKnݲ3""B?S=1[
{vo8죹~+W.Qc
S۶m X6 ˁ)̙3ڰa$r{nmݺU9s7|e7TbEEEEwUvTD CiŊ@`2MSӦMӹsTfufD͛W֭SPPʗ/`͛7O֭\ݺuuAGm۶UxxVX%JԩSvLlz-[hĈ:}/Wj J:FOsuuU2e?{U2f̨+W TƌժU f
2 CWիmi2e
8P۷WLb c%K-^XӦM5|IRBԿ cÆ
n:ݻW.\cw>G{Zl4c }'8qdX4x`ʽ[z-[O>DyoMjժUvNlݲe˦EiZzBBB%Ky{{w*YdwG XbZ| =x@9r䐷z"Ey x5SH˖-ղeg:;,ܹskȑ 6mZM6-V狯~_usqqQ^ԫW,u˙3F %o߾۷üyJС:ty S S! Tj p*5 8
AM N& BP S! Tj p*5 8
AM N& BP S! Tj p*5 8
AM N& BP S! Tj p*5 8
AM N& BP S! TRt?I*$уNQOgB&/3ѦɋL~Ҧ' L* ]L*$ΩsSW$;ɏ6 Tj p*5 8
AM N& BP S! Tj p*5 8
AM N& BP S! Tj p*5 8
AM N& BP S! Tj p*5 8
AM N& BP S! TjY,u) <S&˖-5k֨`ծ][ ܹstɓ'+{I6|p-[.-UTʜ9J,&Mm۶2 #E GP3O>ӟׯ\ΛXahРAzW$I~VZ?XG S p^5So߮͛7nݺ)]G vi۷WӦMb
|^{M.]hΜ9^Ǝ >}($$D=zʕ+p1MS2f̨ O>N:ĉٳ&N֭[kj۶_.Iz%IK.u~M.\PÆ
.]:IҀ_L2=z{= Խ{w ?^ :tP@@:vk @by
Vׯ9se˖*^xeoܸ,YkPڴi5jԨxΝ[3gδ4hɓGAAAq :uj5lPW\ѯjKmTT)+VLғ gLP۟ժUKgc)U\Y+WZh[jĈV͚5ܹsmMk@4dwmڴQdddY6lPBTR%I94h`w/WzC4MڝdɒTZ /35SP-[L]tdŋ5` [4Mծ];:^zUojʕ7n/_5jO*UJԬT X5SXΝl2}gS2g ٳgաCzK+V{Kƍ5p@IOfeNZM4{rȡI&4M*RtXo?oذjԨ~['NԄ $I&MUxq
6L VڴiuܹXXӧO&Mh:uJ*k*UTvA (UT ,XPTpa-]Tgֆ
4c M>]9rP~Ԯ]DɣU.9K= mhG&/3Ѧ;:UHg= mhG&?goS)E#GTǎ ;\>|kܸqjٲ]^DDDӨQ#ӹsTpam۶MUTQΜ9me2f̨ kܪUyަ yM ,l1nZ-ҪUTT)[NUT2cƌ2MSŋ{" IDAT3.y5|p9sF[nռy4j(e̘Ѷh|ʔ`vA3MhE{&?giS/Jޛeq9= mhG&?giR-d ;v,VuO*Uإ_xQ!!!k&4yff͚ٕ)^ ?~ӧO:Ν;EFFǒ?S vziܸq-{Wr]wT*z {/\pA]w:eKJ_2{W̙$/~c9fq͛7O4m4 X]Ϫ\sisI<.ֽ{3&orq?mݖg]wݕ?O9蠃Ҷm:ݣG\vey7ҥKZ5g?]wݕ+K.]2k֬~ysy}O=Tr֬Y2eJƌ-[WUy|}ߟ_z+#G̐!Cҿ<=zttR] tA2dH&OC9$kf ;wξ z(?ӳg,\0w}w}ٜtIեN;!Co߾֭[[o|ᇹ[ӤI vae7 Rs[ڛ;찌 =:/bq{W?3ÇFCM~K/M7ݔVZm۶)J %\3g.qy>|x{yGkd뭷%\.]}ӟj,[wuCͱ
6ؠz 暙0aB }l6K;OW_!Ccǎեz뭗;>/?9^{mƌs9'R)mڴc͆no9\rIf͚~q 3xk `(Uu ƪңG4k,Fj888/9(B"1|?sZg+ʜNy~b:tXs~L80/9(B0Ϝ/Yi+ʜNZLM
iȑy7sq5t V1Ss /dĈmݲ7t, V1&駟WU6m =znH 4 &F_l 40
E R (& P(JM P @(5 BQj
E R (& P(JM P @(5 BQj
E R (& P(JM P @(5 BQj
E R (& P(JM P @4i _բr@CG(үy9PcH;_je蠭: ԫyXCG(ϱ&Cnj X
E R (& P(JM P @(5 BQj
E R (& P(JM P @(5 BQj
E R (& P(JM P @(5 BQj
E R (& P(JM P @[9}ѣG} ` MkG ,oRT_ XB?/ j噚PQQ}6tzQQQ?{QGm۶_ V?v7ѣ3hР$_u hd6&Mdu-رcӤI,Zhk8UUU 2|lF9蠃[fܹy饗2jԨ|93|رJ? z+5q)JߨR}y3gΜ4o|=Xf̘ :dҤI
a\q>|xg\tEYs5k/~ GK G=SE9s'.\TJN2ws=3fLڴi7#G w1;c8 6,ϯ1ʶnӧ;^{lNvmt9~ {,G }t*++vۥK.9'$ڵKkwޙ :c6lX6d 2dB3I6tqK3pNi]?L2eq3_gIEEE
I&#LӾ} ywjl/NKNg= '* ޮlѢE X_[mliݺuF C9ƺYfe9{-E]*{w8∔JL0!?^z)_|ۜs9СC<ȴjժL3gLSUU:na???[O믟_|1#GOL4)rKN=Ԍ5*I[/G yd6x|ӯ_p
vm?ΰaê+N |ՅdsnF/Yg?<'tR>|x~ $Iϟ??-[ȑ#:T o7΅^#F /RsΜ90aB~: _|ERT7l:?)cǎg=ܳƺ7x#Riɓ?`[o$iڴiwߌ =էw_4iR6k]gynzekVxV_9Z Ѕ &Iz#FdyGҩSe]Ҵi;9 Vz+5,XP]}'
ʄ gYs5, ϟ?,qbƍ˴iҫW\p5֍ 9r? 4(oVnp
5erΝ[0yӪU<߿ƍ ,/ -K 'Eb^,w2p 80NƏ #FdСiܸqN8ecv =W}BlQ9#o=kCXc>#-ik5t\t
,E/
Y2WKީ8B5tp:FYrSCG(KQEa>9EӥYZ+ݺuˣ>~:R8}J.5/Z(ߗ :tG _ /0j6mڤ*~GO[V/kԨQw)S}ݗ^;]tYf]f7ߜO>qz{rmhݺu훛o9M4}d:thZj=أαZJUU/2gΜ$ɼy;Úk.(-g $I*++{ͬYjl3rȔJtڵ8 Irg oʺ]{ui_9 /1w/~,\0{WY[Ww]zU=Ziܸj fo߾+RÇpɗoN ;f7s=c99kkk6m}{y3}r)9ssק*?+W۶msi /iڴi~旿e? |Ywu3yvma r!Ovf+Ȃ ro߾Os嗧{9蠃[gys wI&KҡCy}yW}.n-?Oӳg|{˿q Y`A<ȯ W3}zp
e]Vf^ [RsРA:uj.\zI,\0IRUU-[欳Z9I f֭3vvmyꩧ;dyi֬Y6dTVVCwݕ +L^;}M߾}WV ZR3I,XI&孷ܹsӼylq ӨQ X!Ujz2dHfΜR)lA~ߥK. `KqNVrG?A\s̝;7j xz>|x:t23 be^{m***2bĈ:K?sG+W\Q! +!SNMk-4EO~ɓ'[8 *Ԝ?~]wݥiٲe>쳯
.emQ^xᅥy~P u)ҥKn\uU9sfurW[nɾ[! +EA'tR&L.(ӟ}/kV>|ᇩ[o̼ \٥wz뭹2nܸ裏k]v֭[?4mte .5Yf߿ ,U X ,וƏ ?0ycJR ^/HZTϓ_"'ned-UK:lǞ[/[CG('!
:2 BL'SGd!75toK?6lX:T*}P u)Լ뮻ҦM <8Yc5Vf. ZL͏>(}vm L٥[n9s, Tvyi˛o2 ,Us=sGoM6$M6]b\T5$ be7pC.TUU{:N Le\sM6huY~ 4K͏>(ӭ[ `~Q,X`ef XK38#7pCO2 ,UٷO:5?яҭ[t!nio?_! +?uSj +S٥u]2s RsvZ9 R VJM P @(5 BQj R/ٳ3w R-W9bĈ 2Yr1Ǥ2~z X٥1cry߯^v9'[o w1zknᆕ YRsȑmr&I>{ｩߞ믿>]v͘1cVZX K7|3ݻw )lٲeμ+iܸq_50 ;s6|z X٥f4j(m۶u! R/ Rs̘1y睳W.W^~2 ZYj_\]jNTJUUUT*-MUUUJR Xi,5?lv5> 4:K{/3| >` Ȍ3$Zvm>}dZb:*>l6ddz vadM2gΜ;vlg?% sФI̓O>]wݵl IDATc
70I2z:K1cd vȤIj]߾}JUu\
rd yGӻwlYc5jݩ[wM]3'N\/g֬Y՟L0!ƍ&l$9ꨣ{eܸqI>:ӦM#<$ܹsvq\tEI;~wM.]2` 0 ng?~z|/W_}uv} =: 뮻.K=^J |stС# |u q)J5-?$u}TRjRg̘1ygXWQQQsm{gРA0aBXc{9sγ馛fv wܑO?=wqG6`ne8+ݪ+D")ʜ~%
,Sm4hQ9#(Ѣ(|_SW솎L/ {n!ro
,?7>Wu12l;
,m4tмuCGX"}GGCG(KQ M5RS_s]۠ r!=zt
D"vs9'<@}o}[ `RgP_ڷo={;~}ٵ>{<ƍ$Ykҽ{<Y`A<.$us=7Cg}*c L}SNIǎ WU =$ɭޚ'x"=z,Z(ӧOC=O6tӜwy;~{J
͚5KnrgmI65/ 4UoMc>vm{G T*UVzsqeO&K~=z%fǎ [yj-ӧOFUk)Vt RKMXY*++Fk]~|ԩ5>oK,Kږc VC: X敚fʌ3k-[\@ KRrT*套^Z@ KRs-L-VE eZfy)d[Y ɋ BQj
e[, ˴
0`U ( BQj
E R (& P(JM P @(5 BQj
E R (& P(JM P @(5 BQj
E R (& P(JM P @(5 Big/i4٢r@CG V"۔Q6YcM
a٦Vn*V;*JM P @(5 BQj
E R (& P(JM P @(5 BQj
E R (& P(JM P @(5 BQj
E R (& P(JM P @(5 BQj
E R (& P(JM PrGNEEE:|GH߾}UTT"կ_~z1c8nEEE|ɥcH۶m<+ V&
T*vM4Ƀ>9s9fiܸqhҤIF ]-رcӤI ʥԤATUUv۷ϼyrֺ~q!;,u K+F {̘1#ڵ[ \JM
eM7M6m2jԨZ?1cF:w\kqZ*ҩS̝;7sO3fLڴi7^ P?Nn=oƌ78nmoiݺuϚ5+ǏO]53 GI?~f͚U矺3IrX>{ ?>zZ3;{왿6mZcǎ^} V?JM̥^Ztbr6Keeeǎ UH;I}̘1i߾[ Vc^L9CrֺO?̀ܶO>4hPxnI;#ڵ[ltMO?=Iog9sW X4֭[u }Rڵk9~mogҤI9s>bt }3z謹rbSBۭjEk˥ys_(Ys_YsO()_ĩ5t!ύoe+J"+J֢싒(?XYsԤZkt-sOfϞ;c Q;>uYg2mӮ
m*My~b!r*/{ ׆L<{ICG(KQIqHѢ(ʜ*^W_ ڶi4qkyB
,?7>Wu12l;
,E&ֿ"}G(s35)>}dyGswSNYwu~q1裏駟λA Ԥ:v֭[禛no]ѧO̞=;CMV { '&֫W ?ƸڞYNLȳ>;Z?TVV]v9#3eʔT*W^СC >ʙ 7 vX*++_SQQo>6lX {,G }t*++vۥK.9'ضsڵkL={]v3gN /d vH3{$/N;-:uo=#'pB&MT\ j櫯Res͑G [o5={ ǜtIs1 N[7pÌ ;6 ./">`bt1Irg)J9묳.[ou OZ|{umfΠArꩧ+̀j k= iܸqvi?رc~4m4>lb ;wnc$ɛoR6m,-Zd[oĺM7ݴ<
s=aÆm۶5##FwqU ?"#1qB Pfj\;,eC3rL3bpD(?|yS< ι x^><9Ahh(OOOt :ta&ILjۗL |ؾ};p!35kĨQТE dbi$G"66#F#G l3fۿjժيu!<< ظq#~裏ʜ { йsg^NQN:aHMM-m۶űcЯ_?$&&BJ͜ &`Kcllb
a`PΝ;Э[bԩM6!44qqqXn ֮] sss 9&L [
Tryhu٫#9FR'wJ AQ|++U?^:B!褽&UߟSV9)>>sZm&5R^=t7oƕ+WдiS[*
/zl~~~իj81[lyKO,֭[Իv1F#F8p 6n܈
6 ?? _~e_5e֬Y۷/ Z}>JJcǎU]]]yf tpp@dͭԊ>} ::7nDΝYlLZ\~ {ņ
xbcܸq=\+I*)"g WWGVDwJ BǖH R=
Ğ:B(?H C1|.o)uJkWT7^Eqf%;TGbU;ϊV˳K R=*|>T|ryN˛x6{j% tR'
燔\t v킯o<ۏ[ѿlڴ uΝ; 5aÆ=z4 :۷82sM4
?ԪUK7oDjj*N8KãGдiJ[}||당s|I{cذaA?H7p!Ԯ]͚5 X[[؞ =¢E`bb~ARa̙xqKG 044Dll, |Xl>PF2=Uɮ)cǎ Νb^ Kၓ'O"!!......aaa+v'v777XZZb۶m*煇Cro
T+++̙3 $"""""""fvء~T Փ>>>8v&OAѣG_1p@ɓXjz&M xvVZĉhܸ1^b%>C̝;СCQfM$$$ &&I ;bʕ0`
'';v@zz:2ޫWr'Ggw~9s&Ǝ ۷o< `ggGo:uBdd$nݺxsss4o 022*ry?F~PfMDLL
oW"""""""""ͨ ..qqqcƨ_>0|piF}n@TT 4jƍCPP 0c OUOj@pp0RRR \jaÆ֭ [[[7cƌذaV^0<|FFFh9bwqJv'''PMj*su
{F|||q}> `ɸq6n܈͛'5;vڵ+绺ܹs(u+xg IDATbA7*9ӧ#11-|}}QfMbժUxкukX]v-#""""""""T/OFf͚ݻR!9~\>79CN(H|Qx $7
Wʩpu9ues9䍂&>s*><^,U=5r9DEE!((DDDDDDDDD2V-.?פ}ҥKXf
j]~DDDDDDDDDT)~RsyHKK3>sԮ][HDDDDDDDDD?m6#tfOM"""""""""RNjpRdDDDDDDDDD$+$"""""""""Y&
'5HV8IDDDDDDDDDIM"""""""""NjpRdDDDDDDDDD$+$"""""""""Y&
'5HV8IDDDDDDDDDIM"""""""""NjpRdDDDDDDDDD$+$"""""""""Y&
'5HV8IDDDDDDDDDIM"""""""""NjpRdDDDDDDDDD$+$"""""""""Y&
'5HVJ: ?~\DDDaRG`#""R:'5HVx9
'5HV8IDDDDDDDDDIM"""""""""NjpRdDDDDDDDDD$+$"[nСCŎm!!!$Q2~R|rc0 y"
v0qH(u/T*! .F֭f @xx8fϞo_$eTHNNȑ#ꊟ tR,^GAAVX]J:vXM$Dk L\|/;Ʌ_$R\\r-[T ;~8ahh`4nX21uT ;v k֬kOkk֬Ǝ &M`ɒ%RǕq!556l
KKKDDDÆ
C͚5տPIU*Aٳg5$Iװ L\|/;Ʌ_R "y& \ ɓ' /`ӦMhڴQǏcСxԏ߿ ͛7 V2xwaee 8z( ?~I&N: ,ZHʘggg:hⅿF9sFiy%`aߋ&.v0P랓D
l2dffbc̓)[aX|9ϟ/a/##LJ T [. =z$E :u >}iii;v,w 4h6n(eLYԏ 8W
ÇQfM)ɒn~w^4lcwEڵ'=z@ =#!&&| +AAAxˣtݰaðe ?~ =X__K&. L|`='5{xWՏݳgO1;;;ܿ_xҢE DDDIII8sL*
۷o) 6l= & &&JڵkcȐ!2d._h!..Ճ?=Z 3fqDGGcժUXlzͥ);|͓.a;^,>v0i_QBu !!!8p 9rD=fӦMX`) 9r$R`eeHԯ_ ;ȑ#?>+qZy8w
> 999hٲ%oK M6eDGGɓ022BϞ=Ν;COOOꈲ<v0ġ='5jذa(((+p1_~/c&Lw~0<8q[n
T2c F0a]000@>}UYСCJP9xb$%%Λ/ڵkBll,amm
oXAekt;bb;Q랓D
k.{}\&M !&&3gĐ!CJDH0557*u/ Ls8IPvB l2J G֞v0qZ&B5lYYYRP |xY~$L6M777[pqq} >LQQQU+BMo`aUg`е)իW? *_QQL;wBT*/uRTի.\===ʃcUIliZXH^ӫ\Br& v0q +]`$RdDDDȑ#߿?ܨWiغu+._l>>>dț q_T ]+Hz&;;FFF;,ܱ L _a ;f(qRH}/\r`ll,u :vL8;;{Աdh+I HF;4C LSD'Zu q < ::?#;"00>>>챊Կnݚ"hܸ1n)u "`;UW`&>w0$"\A`oo`W^:lh .D$< ̙3Cll,N< cccAAAԩKa%;wQQQزe ߿" 5:l`̙lmm{ i;84C D:z*rssaffM c֭رc^
===tիWw7tPL<ڵS?0MRW"**
7oƍ7Pn]!((͚5:,<} Dtt4899!88>>>Ye *
iiiKJcP :~G ٳgyfl߾ 7n܀!x
\xW\.\sssVkoFzz:>}Zx^^ SNINRSSܾ}&&&APP4Ǐ c_}}}H v0b{y_Y`_ 9uF ]jm/233 wynnnx)-[?RGֺw7oAx7͒'ll۶
8q
'O抋*Zt)]iӦ!88uQw ñl2\&M0)c;ؿ`Sz&BuhӦ
||| J-[/O0j(xW G ]vi+줧w ] ?`֬YnܸTdػwo_#7G !>> yyyppp{ｇ I MbԨQ%Y[[Ý;wuVYjc;ؿ&>v0Pz&B{طo >̞=M6 rrrpedffFo\6mڴ
} O ?IԙBOO <(v{ Y&uʼn`kk
+̙t nݺ1ΈR""a;ؿ&>v0Pz&Bկ_ QQQXx1vލduƄ -?ݾ}QQQHOOGaaas8r} SSSضm222ftQDTMKQz&B|xѪU+u Ä 7779vQd
7nܨ˗/{$cǎy&A@*u<*a.va;ɑ;'5vvv_o]vRG{hذ! 7o <<ᣏ>«*qZ9s&}]lݺRǑ6m`3fLc/\( *&"*ARaƌJ7Đ!Cȁ~ IDATW^yw zI Z=ztcyyyHJJQFcA@hh6"R||S̛7/FΝ wƇ ~Ty5 EgϊFYF GZj>$&&bHJJ?͛'a оW>ؘ1cpqdggڵ;ݫ@T] v0i;4C D
U APC";;+R bׯ_lΞ=Ɉ(1LL2 0665>}{ɓ'PT_~Of5!**J_$ry)RRRpQ$$$ 99U\\\vڡm۶RG%z)`/ L\`IM":uTpDDDYf:u*^y-ڷoqaȑcΝC`` ~oD ={ &&ݻ}}}ԫW...߿?\\\HTLaa!N>$$$ԩSǙ3gFR^;
;ɍ:oDPNNNek߾z_8ZL&YYY_~c666 KKk֬,d#G@__ ѭ[7nwݻK qe\v
oF^^ԑDr4KsHn8IjԨ P" Ν;ammD$6777<~*
pwwGN&MH HH[ؿt;'5t۷ʑӧO ggg .]##c|6mB5n:ږ9iӦXv-郍7bҤIZLID.NNNח:d*& /"ݦIM"ѣG
K'OTߗz|%=)-!!;wT)@5СCro8oZLF$>v& /"ݦIM"RTe355EFгgO :T#((Hs lٲ[nX
&""mILLDFFFcnk)氃 v0q6w0Nj)Ԟ={ ksΕ:Ĥ
7 "
Տ?s|7ѰaCm#v&./"ݣK D:"//yyy011)6ԭ[.]3gΠnݺLDDL_qT*U+LLLСC^KFRb"=8I`7V^<|P}
5j7o.aB%ĉ+E֬Y34k ?i`T] ]`M_H <ǣ1rssG WqI:u
ozƥqiDFFQIHl鰲*uO$`T6w0Nj)T~p
,X ;v,q6m4ip .;w.BCCѠA 8_>p
:tx!&N#vڅDܼyzZRR\\\);U7_DIM"rrr1nܸ2,YWɓ'tJ+|rAMMM1e 6LD$ ? J X~=cxxx˗/WJ `Tݰ.w0IPnݠAnXOZ%ƍ`۶m믿p=^zxsssV^ÇcĈի >gddXr%&M$aRF
Rz&Byxxɓx7 s)tAӧpnܸgggXZZJ I,--1dclٲ}ӑU\50zh\|[ne&7v0H(y"Ќ3%KΝ;edd`ʕ8}4fΜ)QByE.]'ҥKs~~~?$LGDTU8Ӿ}{k)氃 RH!zQXaa!.]KVZ033Cnn. >| xW0vXDFFj; >>8p jԨ!uLݻ ݻ7бcJbHDKUfv@"+v0).u0Nj)Ԁ0aRG!
vz~Q :cq^KFrE|X̙3
՟_ꫯO>۷/5j$uDÆ
o>\z999033CӦMՉ'0{l? ЬY3ci ;fHt݊HAnܸIR SNc mFSNaǎ GZZT*lll0rHERG 2/_ XXXVZѣGX]%ܹs n¨Qԛ{xxয়~bqb+-[Ddd$ ss糲W:bv0b""&B[kň#>3\t zbbbf ?^йs}L/oԨQ;v,ѧO 8889998QFI E60w\dff[aR`ii3gWDDD/ L^ ) Wj)CtA @pp bccMi
_|2rrr`jj
<""%v0a{q_D$$R" 9rر
6 ,, xi*
6 <ݾ}ׇt.]:nϞ=U ;EDJIM"jР/Çطo \]]aff sX[[KR n݊
acc'O{Uu놑#GJ U6
5k֔yׂ̙38{& :ꫯCHOOի+H UvjԨ +V@ƍwI814 Ls4Hw( *J%u"zyXhz~\ ѣQV-\7 J? 0i5lذ
χ
d4"҂/bȑO? Ls^)qRH! KKKrwwT,Esի "7ltX[[ݺu8aU_)ç~۷oxW`oo_ ArJ U ;汃U
)qRHq)ܿ W ڵk 55`DDT (qRHΞ=Ǐ A <{ի>CKtŋamm_tDzzzj0 fQuE{8I0G 㑛 777o uEaa!pA\xkʕ+$uj2{ -w 8s6" >| 000@QQ`bbGGGL0]t8-ыc vc"=J`\I ϟWaUFN?j02EGGc>G RXK 觟~BӦMtRXZZ kE۶mEw,D ; /"ݣIM"yׯ_VVVx)ŋ1{l$%% .Dv%KaaaRG "-t&Lƍ#++K}:uB֭1` XXX ((H¤DUY``"=J`zR "iӦ!::eZ 8'J D:u Tvv|ڵ1h d L3HYR v_7owO^h%HOO/S^^ 6lի/ anng7P]6RSS%JHD
;w0Nj)̮]*?h8|ѰaC^;w:bcڴi/sJSt ?3,,,0|kΣ?. K|\ʅ+hh.f};}OTf c_4MqCJR!II
jX8s{5jH5mT͚5ә3gxbb V0`bQ|||a % 0 ={j z饗4k,iFrqqQ-t)͛7Owt ?nَ
0S SLQZZ>#?^}UJJ, Pٲe5k,;T S 05 L%$$ɓP۶mUJGyJ1 IDAT `Z/ (t :~
$Iu֩TR߿^z%W `.f`N. a 9R۷oMOVŊ T! (̞S Pd `]rEW5vXM8QO=BCC(''fѼys͟?_e˖/T
8жŋ"_@e Ƌ wqiʕ:u<<<3(44T^^^.?t [ϟ$(22Reʔ$o^iiiZ`4iR g Ơ& }vM>];wbQrrKP 222m69;;uֶ %>S˖-մiSV % 0/3g05 Zl6mڤ ժUKaaaz ] ) g̩ p-[L+W.777uY=zP㕘3ghȑw)???r"@J f0 Wj͚5SRR$) @=zPN
,ڲe Ðb jJ~~~9sm' @!%3wj ֭[Y^yF.@!ꫯe
8P :tP߾}mJ.M:UfҨQ X) (̞S P$V\\\`y{{kB @aڵ5j?XW\Q@@~7ށ;5 E&;;[ڱc_}QVVm6\]]믫 \̜ @8ta]zUʕSzԾ}{U\ Y3 (T;w (Q̞ @Z]wݻ vtI g >^.\PեK% 3 (Rn֭[zj+##CkV =Գgb=a= lAM 8Ç;())ITti \ 9!1 "+WjժUd7n =zhTn]G `
f` j eggkÆ
Zl~'egg]O?z)jo>
G UrrtR 3 pٳgkƌڵkK (1ss ~A ,ЩSm,33Sϟ 0'3g05 Pl٢#FH\\\-(''Gnnn ?g v 0c խ[Wl"I7o4g 5h@ ;vTPP+ 0g0 @:|F:uʕ+ҥKu?+*,,́ 3wj P]|Y*U$*UJtUrwwwGQQQ ̞ @V :$I*Sʗ/d>JIIqDy d Ơ&
Uv4w\] 5Rdd%IgΜŋUJG `*f`0 G JMMUxxjժ9sh֭2d Ðrrrd"""+8\ S0{cP JIIj$mY:u<<<{ɉ
3 7 b/''G {uMG P")8 Sff.*IҞ={ĉxr Ld0 ? @rC0 Y,ڂsff͛7ڵkZx qG Pl Ɲ (psյkWUr$I+VPj$IOV>}O>đe k%)1 qFo^SLyzzj=z-LKRj͚5( 4JREA (pǏ W``][nݔ_vmUy T2 (p]Sʕ*V(IPBeʔэ76 *IAM
J P x>gffbo/bE] ) f1 pt 0zX,%''B5 %CI`ܩ : $e0 P
5 + j (Vb7TÆ
u"wbbV>3[[~dZ맆
z=NjՄ 7,Z\\V/_/K V`&2 G
V*U ]bqt H~ =z |3fPhhW~VREӦMS5
?^% B+xd P 5nX7vt%oɓ+˔) ;x] /2c @{J6 @# P 3FVn>}W_Upp4i@
>\v6 =1c(((H
Ұa믿
& (44Tsխ[$IZ[ￗjs=g;wVNl/\']vV-4bٳ'Ϻ{Հ뫀
>\G 1y~ܹfΜ]v)<<\~~~СCuĉkf;u!
2DM6^|Ei>lEFF*,,LU]5}teeeqZV
XٳѠApBy{{u{ӧ А!CTF
j۷,YrߏZZlڶm{N...ڴi&O}ijժ$iǎ zꩧln߾]ʕSrr_.777IRZZ ;pI˗իW/]xQ{Vzŋ^W_}͛KΜ9+''Gף>kȐ!*W\NWۧhK={Ԯ]tR =Z˖-F hڵPUJ;wNt9
>\O?´c7ТE_111֭/gggرC_| >^ :tP۶mue}WVZݻ5` yzz_TժU~-ZH?j3 `d02 3faZSNa3VvZ~Ν3
d,_ۼy1p@cv?e;۷^^^mmj}{e :4Ͼ
fXVc݆aFǎ =z 1Ǝ kXVcͶUVV 0I&52c~jjo&MdXVcٲev}WXaxyy7>ܿEÆ
0` j'N6OnXV#11vIv2İZnw̘1>M65ug_f2"""ׯ߳ܿߛ4aÆj5.]jk45kf۷2gŋF˖-
jڻwn.]qFlm>_ Sd02 0<9UREsUhh=oݺ͛.]HQ+W 5cX,z,ѣ ƍ%IZuUI\?r䈂#(11Ѷbw S:ut?eʔ߯+WHm&'''ӵkW/_۵~NKK]$1 ggg={6y:tM2e]\\ԭ[7gUREG }TgϞߺu,];wkKIIQrrڴi#bw}}}n} `#Ev (**J7nTppZl-Z5_Xft]~nX}_ 9rDԠA< }QIұc$,Y$ڂoӦMﯝ;wݾ}|||TlYeddٳJKKS@@@>2siyyyĉZj0ڵkkuYfҥKK}nWV}5|;w\(22Jve˖vmWPA?n۷M6M͛_tYY,ySYSҥ;YܵlR-[TVVj*XBԺu^r??7`鮇kuxg @72 (,̩ &TfM_111rqqѺuԩSј ;vWOt< >,VZ_Ǖf͚Iԩʕ++11QX
˗ ;
#G
$7NݻwMԞ9sF ,t﹃SN2 sbcǎVZ)++KX,vW6mD%%%lEGG۵_tIz饗lmu\nn~7uIy^e _W~ $q^ ڵkkvmjRÆ
~mݺnݻٳg ̎ F+d02 "55U]tQPP](2e/_KI&w\EիW/jժxVX,s!!!;wF nݺ)55U ,[oI&)99YK,ѓO>ciԨŋkjD
4vXm˗^zTmN,
|X-RժU3 ̇ F#P<1 Œgmb\]tQ
ٳgҥK*W_GeeeizwՠA{z'uUM<_mm?}tM= 1.22.2
scipy >= 1.6.2
scikit-learn >= 1.0.2
torch >= 1.9.0
apricot-select >= 0.6.1
networkx >= 2.8.4
pomegranate >= 1.0.0
sphinx-rtd-theme
pandoc
nbsphinx
jinja2==3.1.4
jmschrei-pomegranate-8de2be8/docs/tutorials/ 0000775 0000000 0000000 00000000000 14643672530 0021311 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/docs/tutorials/B_Model_Tutorial_1_Distributions.ipynb 0000664 0000000 0000000 00000042564 14643672530 0030715 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"id": "e425a05c",
"metadata": {},
"source": [
"## Probability Distributions"
]
},
{
"cell_type": "markdown",
"id": "dcd7151e",
"metadata": {},
"source": [
"author: Jacob Schreiber \n",
"contact: jmschreiber91@gmail.com\n",
"\n",
"Everything in pomegranate revolves around usage of probability distributions. Although these objects can be used by themselves, e.g., fit to data or given parameters and used to evaluate new examples, they are intended to be used as a part of a larger compositional model like a mixture or a hidden Markov model. Because everything in pomegranate is meant to be plug-and-play, this means that any probability distribution can be dropped into any other model. \n",
"\n",
"A key difference between distributions in pomegranate v1.0.0 and those in previous versions of pomegranate is that those in previous versions were usually univariate, in that one object represents one dimension, whereas in v1.0.0 and later each distribution is multivariate. If you wanted to model several dimensions in earlier versions you would have to use an `IndependentComponentsDistribution` with many distributions dropped in, but in v1.0.0 you would use a single distribution object. As an aside, `IndependentComponents` is still available in case you'd like to model different dimensions with different distributions. "
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "de49566f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"numpy : 1.23.4\n",
"torch : 1.13.0\n",
"pomegranate: 1.0.0\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-208-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"import numpy\n",
"import torch\n",
"from pomegranate.distributions import *\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p numpy,torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "321909d0",
"metadata": {},
"source": [
"### Initialization and Fitting\n",
"\n",
"Let's first look at how to create a probability distribution. If you know what parameters you want to pass in, you can do that easily. These can be in the form of lists, tuples, numpy arrays, or torch tensors."
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "13805af8",
"metadata": {},
"outputs": [],
"source": [
"d1 = Normal([0.3, 0.7, 1.1], [1.1, 0.3, 1.8], covariance_type='diag')\n",
"d2 = Exponential([0.8, 1.4, 4.1])\n",
"d3 = Categorical([[0.3, 0.2, 0.5], [0.2, 0.1, 0.7]])\n",
"\n",
"d11 = Normal((0.3, 0.7, 1.1), (1.1, 0.3, 1.8), covariance_type='diag')\n",
"d12 = Normal(numpy.array([0.3, 0.7, 1.1]), numpy.array([1.1, 0.3, 1.8]), covariance_type='diag')\n",
"d13 = Normal(torch.tensor([0.3, 0.7, 1.1]), torch.tensor([1.1, 0.3, 1.8]), covariance_type='diag')"
]
},
{
"cell_type": "markdown",
"id": "ce70220e",
"metadata": {},
"source": [
"If you don't have parameters you can learn them directly from data. Previously, this was done using the `Distribution.from_samples` method. However, because pomegranate v1.0.0 aims to be more like sklearn, learning directly from data should just be done using `fit`. This will derive the parameters using MLE from the data."
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "24d644dd",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([-0.0132, -0.0643, 0.0985]),\n",
" Parameter containing:\n",
" tensor([[ 0.8174, 0.0668, -0.0590],\n",
" [ 0.0668, 0.7918, 0.1045],\n",
" [-0.0590, 0.1045, 0.9713]]))"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"torch.manual_seed(0)\n",
"X = torch.randn(100, 3)\n",
"\n",
"d4 = Normal().fit(X)\n",
"d4.means, d4.covs"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "b7adb829",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[0.3500, 0.2000, 0.4500],\n",
" [0.3500, 0.3500, 0.3000],\n",
" [0.4500, 0.3500, 0.2000],\n",
" [0.2500, 0.3500, 0.4000]])"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X2 = torch.randint(3, size=(20, 4))\n",
"\n",
"d5 = Categorical().fit(X2)\n",
"d5.probs"
]
},
{
"cell_type": "markdown",
"id": "ee80ed6a",
"metadata": {},
"source": [
"Similar to sklearn any hyperparameters used for training, such as regularization, will be passed into the initialization. "
]
},
{
"cell_type": "markdown",
"id": "62024af5",
"metadata": {},
"source": [
"### Probability and Log Probability\n",
"\n",
"All distributions can calculate probabilities and log probabilities using those respective methods."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "6a7da803",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([-3.9452, -3.2879, -5.3004, -3.6380, -3.9600, -4.9730, -3.2313, -5.4351,\n",
" -3.0938, -4.7396, -3.6861, -2.6550, -2.8112, -2.9265, -2.6482, -8.2887,\n",
" -3.7147, -2.6614, -2.8981, -9.5658, -6.2381, -3.2002, -5.7639, -6.9646,\n",
" -4.4075, -3.8988, -3.0689, -3.2529, -3.6521, -5.3077, -5.5544, -3.2166,\n",
" -5.6651, -7.9825, -2.6263, -2.6650, -3.4593, -6.5449, -2.8980, -3.0915,\n",
" -4.5713, -3.1680, -4.8918, -3.0811, -4.6555, -3.1913, -3.5364, -3.1703,\n",
" -2.5797, -3.4614, -2.5375, -4.8910, -2.9253, -3.9987, -3.0313, -3.2010,\n",
" -2.6444, -3.2952, -3.7149, -3.9957, -4.4953, -3.8348, -4.1071, -4.5762,\n",
" -2.9732, -2.9576, -3.4012, -3.4736, -3.9769, -3.7505, -4.5513, -4.0950,\n",
" -4.5067, -2.7840, -3.3281, -4.1321, -2.9699, -3.8536, -3.9683, -5.8055,\n",
" -5.3984, -4.9514, -2.7441, -3.8885, -4.5353, -3.0082, -2.8207, -3.3852,\n",
" -3.9225, -3.7536, -6.9391, -3.0570, -5.8579, -3.4830, -2.6783, -5.0286,\n",
" -2.9454, -3.4192, -3.8757, -4.4241])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d4.log_probability(X)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "b28cdb26",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([ -9.6459, -2.8243, -16.0460, -3.9857, -2.9930, -11.8263, -2.6130,\n",
" -6.0255, -5.7931, -3.3603, -7.4735, -5.1014, -3.1393, -3.6045,\n",
" -3.4457, -14.1638, -2.9771, -4.5638, -5.1863, -5.1922, -10.3993,\n",
" -5.5200, -5.2215, -7.2889, -7.4847, -7.9908, -2.9989, -6.8441,\n",
" -4.6477, -4.3911, -6.8748, -3.9965, -10.5521, -22.9875, -3.1194,\n",
" -2.8532, -6.6198, -8.0589, -3.4627, -7.2507, -5.3280, -3.2750,\n",
" -4.5530, -6.5848, -2.8317, -4.6167, -9.5592, -5.2165, -3.4062,\n",
" -3.2597, -3.9544, -14.5495, -3.4490, -3.8333, -3.5855, -2.8570,\n",
" -3.3047, -5.5304, -10.1993, -11.8056, -3.3747, -8.7955, -3.4717,\n",
" -10.6717, -3.0119, -2.9799, -3.2086, -3.6065, -8.6801, -3.4716,\n",
" -4.2680, -6.6669, -4.1253, -3.1685, -5.0236, -3.8058, -3.1228,\n",
" -5.6273, -3.9447, -5.2440, -14.2746, -4.6809, -4.1667, -3.5050,\n",
" -3.8123, -4.4155, -4.7357, -5.1111, -3.4382, -6.3055, -6.9832,\n",
" -2.7879, -5.8146, -3.9857, -4.3523, -5.0716, -4.9841, -6.1210,\n",
" -3.9729, -10.4107])"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d1.log_probability(X)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "9d25b42b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([1.9348e-02, 3.7332e-02, 4.9895e-03, 2.6305e-02, 1.9064e-02, 6.9225e-03,\n",
" 3.9505e-02, 4.3607e-03, 4.5328e-02, 8.7420e-03, 2.5069e-02, 7.0302e-02,\n",
" 6.0135e-02, 5.3586e-02, 7.0780e-02, 2.5134e-04, 2.4362e-02, 6.9850e-02,\n",
" 5.5130e-02, 7.0085e-05, 1.9536e-03, 4.0754e-02, 3.1389e-03, 9.4471e-04,\n",
" 1.2186e-02, 2.0266e-02, 4.6471e-02, 3.8663e-02, 2.5936e-02, 4.9533e-03,\n",
" 3.8702e-03, 4.0090e-02, 3.4649e-03, 3.4138e-04, 7.2346e-02, 6.9601e-02,\n",
" 3.1452e-02, 1.4374e-03, 5.5134e-02, 4.5435e-02, 1.0344e-02, 4.2086e-02,\n",
" 7.5080e-03, 4.5910e-02, 9.5090e-03, 4.1118e-02, 2.9118e-02, 4.1990e-02,\n",
" 7.5798e-02, 3.1386e-02, 7.9060e-02, 7.5137e-03, 5.3647e-02, 1.8340e-02,\n",
" 4.8254e-02, 4.0721e-02, 7.1046e-02, 3.7061e-02, 2.4357e-02, 1.8395e-02,\n",
" 1.1162e-02, 2.1606e-02, 1.6455e-02, 1.0294e-02, 5.1139e-02, 5.1945e-02,\n",
" 3.3334e-02, 3.1006e-02, 1.8743e-02, 2.3507e-02, 1.0554e-02, 1.6656e-02,\n",
" 1.1035e-02, 6.1790e-02, 3.5861e-02, 1.6049e-02, 5.1307e-02, 2.1204e-02,\n",
" 1.8905e-02, 3.0109e-03, 4.5240e-03, 7.0733e-03, 6.4304e-02, 2.0475e-02,\n",
" 1.0723e-02, 4.9382e-02, 5.9563e-02, 3.3871e-02, 1.9791e-02, 2.3433e-02,\n",
" 9.6916e-04, 4.7028e-02, 2.8573e-03, 3.0714e-02, 6.8677e-02, 6.5477e-03,\n",
" 5.2580e-02, 3.2739e-02, 2.0740e-02, 1.1985e-02])"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d4.probability(X)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "c0e24986",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([6.4691e-05, 5.9351e-02, 1.0748e-07, 1.8580e-02, 5.0137e-02, 7.3099e-06,\n",
" 7.3312e-02, 2.4163e-03, 3.0485e-03, 3.4725e-02, 5.6796e-04, 6.0884e-03,\n",
" 4.3315e-02, 2.7200e-02, 3.1883e-02, 7.0588e-07, 5.0939e-02, 1.0422e-02,\n",
" 5.5924e-03, 5.5596e-03, 3.0455e-05, 4.0060e-03, 5.3992e-03, 6.8307e-04,\n",
" 5.6159e-04, 3.3856e-04, 4.9844e-02, 1.0658e-03, 9.5840e-03, 1.2387e-02,\n",
" 1.0335e-03, 1.8379e-02, 2.6139e-05, 1.0391e-10, 4.4183e-02, 5.7661e-02,\n",
" 1.3337e-03, 3.1628e-04, 3.1344e-02, 7.0967e-04, 4.8536e-03, 3.7815e-02,\n",
" 1.0535e-02, 1.3812e-03, 5.8910e-02, 9.8850e-03, 7.0553e-05, 5.4264e-03,\n",
" 3.3168e-02, 3.8402e-02, 1.9170e-02, 4.7997e-07, 3.1776e-02, 2.1639e-02,\n",
" 2.7723e-02, 5.7439e-02, 3.6711e-02, 3.9645e-03, 3.7195e-05, 7.4626e-06,\n",
" 3.4229e-02, 1.5142e-04, 3.1063e-02, 2.3192e-05, 4.9196e-02, 5.0799e-02,\n",
" 4.0414e-02, 2.7148e-02, 1.6994e-04, 3.1066e-02, 1.4009e-02, 1.2723e-03,\n",
" 1.6158e-02, 4.2068e-02, 6.5808e-03, 2.2242e-02, 4.4035e-02, 3.5983e-03,\n",
" 1.9357e-02, 5.2789e-03, 6.3185e-07, 9.2710e-03, 1.5503e-02, 3.0046e-02,\n",
" 2.2097e-02, 1.2088e-02, 8.7762e-03, 6.0295e-03, 3.2123e-02, 1.8262e-03,\n",
" 9.2731e-04, 6.1549e-02, 2.9838e-03, 1.8579e-02, 1.2878e-02, 6.2726e-03,\n",
" 6.8462e-03, 2.1963e-03, 1.8819e-02, 3.0109e-05])"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d1.probability(X)"
]
},
{
"cell_type": "markdown",
"id": "e5be6cb8",
"metadata": {},
"source": [
" Similar to initialization, these can be lists, numpy arrays, or torch tensors."
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "5cc0c465",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/tmp/ipykernel_88680/2372227.py:1: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
" d4.log_probability(torch.tensor(X))\n"
]
},
{
"data": {
"text/plain": [
"tensor([-3.9452, -3.2879, -5.3004, -3.6380, -3.9600, -4.9730, -3.2313, -5.4351,\n",
" -3.0938, -4.7396, -3.6861, -2.6550, -2.8112, -2.9265, -2.6482, -8.2887,\n",
" -3.7147, -2.6614, -2.8981, -9.5658, -6.2381, -3.2002, -5.7639, -6.9646,\n",
" -4.4075, -3.8988, -3.0689, -3.2529, -3.6521, -5.3077, -5.5544, -3.2166,\n",
" -5.6651, -7.9825, -2.6263, -2.6650, -3.4593, -6.5449, -2.8980, -3.0915,\n",
" -4.5713, -3.1680, -4.8918, -3.0811, -4.6555, -3.1913, -3.5364, -3.1703,\n",
" -2.5797, -3.4614, -2.5375, -4.8910, -2.9253, -3.9987, -3.0313, -3.2010,\n",
" -2.6444, -3.2952, -3.7149, -3.9957, -4.4953, -3.8348, -4.1071, -4.5762,\n",
" -2.9732, -2.9576, -3.4012, -3.4736, -3.9769, -3.7505, -4.5513, -4.0950,\n",
" -4.5067, -2.7840, -3.3281, -4.1321, -2.9699, -3.8536, -3.9683, -5.8055,\n",
" -5.3984, -4.9514, -2.7441, -3.8885, -4.5353, -3.0082, -2.8207, -3.3852,\n",
" -3.9225, -3.7536, -6.9391, -3.0570, -5.8579, -3.4830, -2.6783, -5.0286,\n",
" -2.9454, -3.4192, -3.8757, -4.4241])"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d4.log_probability(torch.tensor(X))"
]
},
{
"cell_type": "markdown",
"id": "1b314697",
"metadata": {},
"source": [
"### Summarization\n",
"\n",
"Although the primary way to learn parameters from data is to use the `fit` method, the underlying engine for this learning is a pair of operations: `summarize` and `from_summaries`. In `summarize`, the data is condensed into additive sufficient statistics that can be summed across batches. For instance:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "49587093",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([-3.0192, -0.8312, 2.1886])"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d = Normal()\n",
"d.summarize(X[:5])\n",
"\n",
"d._xw_sum"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "543d0533",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([-1.3155, -6.4282, 9.8475])"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d.summarize(X[5:])\n",
"\n",
"d._xw_sum"
]
},
{
"cell_type": "markdown",
"id": "8f0c8be5",
"metadata": {},
"source": [
"These values would be the same if we had summarized the entire data set."
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "2e035557",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([-1.3155, -6.4282, 9.8475])"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d2 = Normal()\n",
"d2.summarize(X)\n",
"\n",
"d2._xw_sum"
]
},
{
"cell_type": "markdown",
"id": "fe1fe2b3",
"metadata": {},
"source": [
"From these values, usually stored as `_w_sum` and `_xw_sum`, one can perfectly recreate the values you would get if you fit to the entire data set. You can do this with the `from_summaries` method."
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "d05fe160",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([-0.0132, -0.0643, 0.0985]),\n",
" Parameter containing:\n",
" tensor([-0.0132, -0.0643, 0.0985]))"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d.from_summaries()\n",
"d2.from_summaries()\n",
"\n",
"d.means, d2.means"
]
},
{
"cell_type": "markdown",
"id": "f31caa1d",
"metadata": {},
"source": [
"We will explore these ideas more in other tutorials, and specifically how this allows us to trivially implement batching schemes for out-of-core learning and for how to fit to large data sets using limited GPU memory."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/docs/tutorials/B_Model_Tutorial_2_General_Mixture_Models.ipynb 0000664 0000000 0000000 00000506312 14643672530 0032445 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"id": "a93a8ea3",
"metadata": {},
"source": [
"## General Mixture Models\n",
"\n",
"author: Jacob Schreiber \n",
"contact: jmschreiber91@gmail.com\n",
"\n",
"It is frequently the case that the data you have is not explained by a single underlying distribution. Typically this is because there are multiple phenomena occurring in the data set, each with their own underlying distribution. If we want to try to recover the underlying distributions, we need to have a model which has multiple components. An example could be sensor readings where the majority of the time a sensor shows no signal, but sometimes it detects some phenomena. Modeling both phenomena as a single distribution would be silly because the readings would come from two distinct phenomena.\n",
"\n",
"A solution to the problem of having more than one single underlying distribution is to use a mixture of distributions instead of a single distribution, commonly called a mixture model. This type of compositional model builds a more complex probability distribution from a set of simpler ones. A common type, called a Gaussian Mixture Model, is composed of Gaussian distributions, but mathematically there is no need for these distributions to all be Gaussian. In fact, there is no need for these distributions to be simple probability distributions.\n",
"\n",
"In this tutorial we'll explore how to do mixture modeling in pomegranate, compare against scikit-learn's implementation of Gaussian mixture models, and explore more complex types of mixture modeling that one can do with probabilistic modeling."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "199f725d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n",
"numpy : 1.23.4\n",
"scipy : 1.9.3\n",
"torch : 1.13.0\n",
"pomegranate: 1.0.0\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-208-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"%pylab inline\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"\n",
"import torch\n",
"\n",
"from pomegranate.gmm import GeneralMixtureModel\n",
"from pomegranate.distributions import *\n",
"\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p numpy,scipy,torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "b5f34383",
"metadata": {},
"source": [
"### A simple example: Gaussian mixture models\n",
"\n",
"Let's start off with a simple example. Perhaps we have a data set like the one below, which is made up of not a single blob, but many blobs. It doesn't seem like any of the simple distributions that pomegranate has implemented can fully capture what's going on in the data."
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "41e8c12a",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAGVCAYAAAAv0IKdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABJdUlEQVR4nO2dfXRV5Z3vvyeYFxIhLzB6jrQCKramEWIYbVhQu2TgloLK2Jk7A9Y7a6qlYy13Wda8YGd01EV7W8Y7C12D1SmtvWtGhc7caUsVy1wQ1li4SWnFFNM4V4yALSa2SSBoEt6Sc/8IO5yc7Jfnefaz93723t/PWl2rhn322WfvZz/f5/m9ZvL5fB6EEEIIiZSSqC+AEEIIIRRkQgghxAgoyIQQQogBUJAJIYQQA6AgE0IIIQZAQSaEEEIMgIJMCCGEGAAFmRBCCDEACjIhhBBiABRkQgghxAAoyIQQQogBUJAJIYQQA6AgE0IIIQZAQSaEEEIMgIJMCCGEGAAFmRBCCDEACjIhhBBiABRkQgghxAAoyIQQQogBUJAJIYQQA6AgE0IIIQZAQSaEEEIM4JKoL4AQQtLG8EgeB4704Tfvn8ZlUypw0+w6TCrJRH1ZJGIoyIQQEiI727vw6Asd6Oo/Pfa3XHUFHr6tHssachFeGYmaTD6fz0d9EYQQkgZ2tnfhi88eRPGka+2Nn7qriaKcYuhDJoSQEBgeyePRFzomiDGAsb89+kIHhke4R0orFGRCCAmBA0f6xpmpi8kD6Oo/jQNH+sK7KGIUFGRCCAmB37zvLMYqx5HkQUEmhJAQuGxKhdbjSPKgIBNCSAjcNLsOueoKOCU3ZTAabX3T7LowL4sYBAWZEEJCYFJJBg/fVg8AE0TZ+u+Hb6tnPnKKoSATQkhILGvI4am7mpCtHm+WzlZXMOWJMA+ZEELChpW6iB0UZEIIIcQAaLImhBBCDICCTAghhBgABZkQQggxAAoyIYQQYgAUZEIIIcQAKMiEEEKIAVCQCSGEEAOgIBNCCCEGQEEmhBBCDICCTAghhBgABZkQQggxgEuivgBCCCFisClFsqEgE0JIDNjZ3oVHX+hAV//psb/lqivw8G31bNuYENjtiRBCDKRwN3y0ZwCbdh+ecIy1N2Yv5WRAQSaEEMOw2w07kQGQra7AvvWLab6OOQzqIoQQg9jZ3oUvPntQSIwBIA+gq/80DhzpC/bCSOBQkAkhxBCGR/J49IUOqJgtf/O+mIATc6EgE0KIIRw40ie8My7msikVmq+GhA2jrAkhpIio0otUdrmWD/mm2XX6L4iECgWZEEIK8Jte5EfMZXe51lkfvq2eAV0JgFHWhBByASugqnhSFE0v0iHmizbuQXf/aSE/MvOQkwUFmRBCcFEMnXy4XulFfsW8+DwAxp3LOs+Xl1yLWdMrWakrgTCoixBC4B1Q5ZZe5BYdbf3t0Rc6MDzivf9Z1pDDU3c1IVs93nydra7AU3c14f4lc7CycQYWXD2NYpww6EMmhBCIB1TZHScj5guunub5Hcsaclhan420bjXrZocPBZkQQiAeUGV3nKiYd/cPoaWzV0jkJpVkhMRbN8MjeWze8xa+u/8ITg6dG/s7/dXBQ0EmhBAAN82uQ666wjGgyi29SFTMN+x4A30DZ8f+2xSRs3bDuzu6se3nv8LAmeEJx3T3n8YXnz3IutkBwqAuQgi5gFdAlZMYyUZHi543DFg32xwY1EUIiR3DI3m0dPZie9txtHT2CgVLiZyzenIZPrdwFmqrysb9mxVQ5SSak0oyePi2egAXRVYE2YAv3bButlnQZE0IiRVB9AW2O2ddVSnuaJyBJfVZoYAmKzra7jx9A+ccPycb8KUL1s02DwoyISQ2OOX6+vFvOp3zxMA5PLP/KG6UiC62i47uPnUa677X5vnZsEWOdbPNgyZrQkgs0JnrG+Q5rehoK1c4O1U9ejtIVBcAOdbNDgwKMiEkFvgp3BHmOYuxored9tgZRCNyKguADFg3O0goyISQWOCncEeY5yzGLeAryuYQXguFYmorS5nyFDAUZEJILPBTuMPvsT3vn/EVBb20PosvL7kW1ZNLx/3dK3o7SEQjw2sml2Ldkjn4+YNLKcYBwzxkQkgs8Mr1VcmRlckfVo3ktovgrplcis8tnIW1i+dEbv61u75pVWVY2XgFlgpGmBM9UJAJIbFBtXCHyjmd+OadN2D53Cukzm3XASoPYN2SOZg1vcqxjGZY9aRZt9oMKMiEkFgRVh6yEyUZYPPqJiyf6/5dXu0ciyn+Daq/k+IaXyjIhJDYISo6MuI0PJLH/9p/BBt2vCF0DU977MZbOnuxekur2A/C+F0+AKXeykEsVkh4UJAJIYlERZy2tx3H/dvahM6f8/BXy5zLIgPg8qnlADLoPmW/s3bylbuZx4Fo62UTMRhlTQhJHE41mq2KXjvbu2w/JxOh7ZWfrJLnmwfQfeqMoxhbxxR/dxAFTkj4UJAJIYnCjzhZubmiuOUny+b5yvLj9q6xxhphFDghwUNBJoQkCj/iVJibK4LbLli1A5Qo/9RyDKu3tGLRxj3Y1dEt9Bk2hTAbCjIhJFH4rb61rCGHb955A9wCk0XLXVodoLKCu+4MgOzUcmSniu+su/tP45n9R4WO9VvghAQLg7oISRFpSIkRjW7euqbZtd3hS4e6cN/zByf8XSVIqvC+H+0ZxOO73wTgnEsNQCo3OgMgkwFEtNYKbCvuSpXEsRA3KMiEpIS0pMTorOgV1D0TOa9MbnQhVtERr3+vqSzFycGLfZqTOBbiBgWZkBSQtpQYnRW9grIqiJzXOubH7V34p5Zjnue8Z+EsvNTerdTnOKljIU5QkAlJOF4Vo1RqQJuCm6jFxSIgIswyZvibZtdJFTgpJM5jIQlcEvUFEEKCRSbq2M2nahpegrusIWe8n1R00WClUHmZ4a3fN31KudL1xHUsJAVGWROScMLo+Rs2ooU/JpVksODqaVjZOAMLrp5mnBiLFi+R7amsUpSkkDiNhSRBQSYk4QTRRzhKklCVSuU3OKVQ2fVU9luUJC5jIWnQZE1IwpExd8aBJJjgVX+DqBne2lF/8dmDnlHXhcRtLCQN7pAJSTiy5k7TSYIJ3s9vEDXDO+2oaypLASRjLCQN7pAJSQHW5FwcQJQ1MOrYiySY4P3+BtFULKcd9a6O7kSMhaTBtCdCUkQSKnXpLPwRFX5+g650riSMhaRBQSaExA6dhT+iQuU3pK3AS9qgD5kQEjtkIo5NZVlDDk/e2YTaqrJxf3f6DUmILifu0IdMCIklcSj84cbO9i5s2NGBvoGzY3+rqyrFQyuus11QJCG6nLhDQSaExBYr4jhuOJmeTwycw5eefw1PlWQmiDJ7HicfCjIhhGjGLWDKy/ScwajpeWl9FpNKMhgeyaP17V587+e/Evruy6ZUMGArplCQCSGhk2TB8IqCljE99w+dlWrBWFdVihMDZyc0EzGxqQaZCKOsCUk5YYtjXLow2eF1r5xM0Rb3LJyFyWWTsHlvp+d33b1wFr67/6hwlS0A+L2P/g72/OdvjYzCTvIiTBcUZEJSjIw46phQ45y243WvvNpcylJXVTYu4EvsM6XoGzhn+29R5mfHeREWJhRkQlKKjDjqmFDj3JdZ5F5VTy4T6lnsRQZArYuw+mXrmuZQA+HivAgLG+YhE5JCZHJaZdoEuiHjOzUJ0XvV3T/k+7sskVo57wrf53IizChs5k7LQUEmJIWIimNrZ6+2CTWuTSFE75WsedkOqyjIh2orfZ/LiTBrfMd1ERYVjLImJIWIil7L2z3ailFE1RTCr+9b9F7VXVru2ubSibW3XIM5l1867tq+/+qvJc4gRhStFeO6CIsKCjIhKURc9MSES2RCjaIv80uHuvDg9vZxu1dZ37fovcpOrVDqQbzwmukTFjMnBv3ttou/P6rWiknozBUmNFkTkkIscXSamjMYFS7R4B+RCTXsvsxff6kD9z1/cIIpuavI9z08kkdLZy+2tx1HS2fvBPO76L26aXadY41tr88VU1dU31oE63zfvPMGY2p8y9w7wh0yIanEEke73VyhODZfNU3rrjasvswvHXoX//jKEcd/z2PU9z0ykseGHW+Mu5a6qjL8fuMVWFqfHTMhi9wrayFRWGN7V0c3ntl/VHrHmq2eLPV7C8+3rCGHT10oQBJ1zq/svUs7THsiJMWIpDMF0eowyCIRwyN53Pi1XVrShgrvhWrql8rnZHOaTc/pZR6yGBRkQlKOiDjGaUJt6ezVkg9skcHFRYfqQkLlc25VvzIAvrzkWsyaXhmbqles1OUNBZkQIkRcJtTtbcdx/7Y2beeLomCJda93dXTjh23vCgWlxeX5EGfoQyaECBGXVoe6I3bD7jNsZ42oqyrFHY0zsKTAr+31mbAtGFwQ+IeCTAhJFFZkr66a0hZh5Mq69Ul+Zv9R3OggxnafsSqphRFdbcKCIAkw7YmQFOGV4pMErMhet73Zmk/Mdk3HsUPXztvpGaiUmTShNKWu0qqEO2RCUkOadjFO6VV1VaX46soGLJ97BebPrBUq4qGzYInbM6ieXCZdFU2mNGUQ5navBUEGowuCpfVZmq8FoCATkgJMMGuGTWE+sJ1f00m0C9GZK+v1DD63cJbQeQpN592noi1NGfWCoJi4+7EpyIQknDTvYrwC0QpFe3dHN37Qdnxc/rKugiUiz2B727tC57JM5zvbu7DhxV9KfcYPdmJnUq3qJFiAKMiEJBzTdjGmYYn2gqun4a9X1GvbYRUKWM/7ZzyfQe/AWdRVleLEwDnPqmhuOcpOn/GDk9ituvFKoc8HXas6KRYgCjIhCcekXYzJ6DR32gmYCHc0zvAstQnAcbddiC5zu5vYPb77TdRUlqJ/0HsRERRJsgBRkAlJOOy4441Oc6fo7tWOJfVZ3Di7zrXWd0tnr5DQ11WV4Wt3NPjaGYqIXabg/0dRqzpJFiAKMiEJJ4q2h6YgWhZUl7lzeCSPR37kvXstpvAZTCrJuAajiVoyHlxxnW8zrYjYnRg8h3VL5mDbz34VaMMQJ5JkAaIgE5Jw0tpxR2TXK2vu9BL4zXsOC0c+W9g9A7dgNOH+zJIdo+wQFbFZ06uwb/3iSCKck2QBoiATkgLCantoCqK7XhlzZ//QWVeB39nehU27D0tfq+wzCNPiISpi0y8tj6y0apIsQBRkQlKCV15uUpDZ9YruAHdf6GvsJPBP3tmEDTs6hK/xoRXXYfqUcqVnEJbFY3gkj5GRPGoml+LkkHsryz//lzY8cvvHIlnYJckCxG5PhJDYIOITFm2/uHVNMwAIHVtXVerYXzmD0QCq3oKOTG7kNHWOCjLvVjZK3E9vbF0wD5kQQkJCdMKVCfK5de4VnuZOL7G1cohF0bVbC8rioRIlbkJ6URIsQGwuQQgxHpkGBjJBPpa5E7i4y7Ow/ntl4xWqlz2BW+fmtO7WLL/tysYZWHD1NC1mapEcZzsK/e1Roft+hA0FmRBiNLIdjawgH6epOIPRnbUV5GMFvGWrxwt5troCT93VhKX1WaHrrK30Nji+euyEa+clP9247D5b/Lez50dcz+8V5CZCHNKLTIUma0KI0cgWflAJ8nEzdw6P5IWieP/4dz+Ex19+y/W3uBWo8OMDtftsTWUpAODk4EXfd0kGKNTg4vPrENM4pBeZCnfIhBCjUSn84LXrtRM4J3Onm1kbGBX8VTdeiZnTL1X+PX56Cjt99uTguXFiDIwXY7vz+xHTYssDkYc7ZEKI0agWftAR5GNFdZ85P4IvL7kWWw+8Y1v4Y9PuN1FXVap0nX5qMfvx+dqd3yun14m4pReZCgWZEGI0fgo/+ClWYWcGzk4tx21zs3jhUPeE453Soryu008tZh0+3+Lze5n7v3DzbPzoF12pKDATNhRkQojRRFH4wSn1571TZ2zFuBiZ6/RTi1lnAJV1LpGqbn+17LpYpxeZCgWZEGI8YZb+FInq9qK2qgx9BbnJbtfppxazzgCqwnN5mfujKpOZdCjIhJBYEFbhBx1m4IdWXIds9WSh6/Rjklf1+Yqcn6IbPoyyJoQYg1MervX3Fw+9CwC4de4VgRV+0GEGfqdvULhAhUhxEieTvFcEuBcMxjIL1rImhBiBUx7u7fNyE4KIgqxRLFoL24unJes6685Drq0sRR5yecgqiNQXJ2JQkAkhUgQxAcvWTw6ymcHwSB6LNu7RYgaWbSLh597afRbAuL/Nn1mLV4+d0PbsktDQwSQoyIQQYYKYgC0BlPXbqoqeCNYCARAP5LJj65rmxPphnRZRJnR+iiv0IRNChPBTTcoN1SCqIJsZOFX6kiWpdZ1l64sTMSjIhBBPgpyA/YpWUKK3rCGHfesXY+uaZmz6o3moqyqTPkdS6zrLFDMh4lCQCSGeBDkB+xWtIEXPSv3JVk8el1fsRdLrOvspZkKcoSATQjwJcgL2apfoRJiip/K7kpxK5KeYCXGGgkwI8STICVgllzbs/FmZ31WSGa33nOSAJtme00QMCjIhxJOgJ2AriOryqWLCd/nU8lCjeGV28fk88K1XjigHucUBP8VMiDMUZEKIJ2FMwMsacvj7/zpP6Ni//6PGUHegMrv4tEQZq/ScJu6wljUhRAjVBg8yxS56Bs4IXUvPB2LH6cTp99vh1jJRBVOrYYVVXzwtUJAJIcJYE3BrZy9a3u4BMBqF3HyVvejIFhIxPVjI+v2bdr2JzXvf8jz+xxfM1n5EyvRqWGxCoQ9W6iKESCEqECqVnLzKVgZZnUsG2XrXqgLKaljpgj5kQogwotW6VAuJxCVY6KbZdaipLBU+XqWaGathpQ8KMiFECBmB8FNIJA7BQrs6usd1UfJCRUBNq4bl1BqT6IM+ZEKIEDIC4beQiMnBQtbCRBbZQC+TqmGZ7sdOChRkQogQMgKhIzjL1GAh1WYYFqL30ZQANyc/tmWGN8VqkQRosiaECCEjEEmu5OR3Ryp6H024h/RjhwsFmRAihIxAmB6c5ccf6mdHKiOgJtxD0/zYSYeCTAgRQlYgTA3O2tnehUUb92D1llbcv60Nq7e0YtHGPcIR0KrNMADg9nk5KQGN+h6a5MdOA8xDJoRIIRvgY1KVKV15vdZ5ANiac53IKeZQR3UPRfOtt65pNtLfHzcoyIQQaUwSWVGsoiNOJljZoiN2CxMRZMUrynsdl0ItSYFR1oQQaUyNgHZDxh8q8tuWNeSw+KOX459bjuJY3yBODZ3DD9ve9fycjHk36nQjy03xxWcPIoPx1gATYgGSBgWZEJJYCneXh997X+gzooKpukMWDQozJd1ItakIkYeCTAhJJEEKppNYumGZd0WirL3SjTIYTTdaWp8NZXdqcqGWJEFBJoRoJ2ofc5CC6SaWbucGMBal3tLZ63pvdJvXdRBHN0XcoCATQrQStd/Tr2B6LRxUKnVZ5l0AEwLL7O4N043SCfOQCSHaEO0GFSSqginqkxUVwbW3XIMnVjVi65pm7Fu/GACE740pZTNJuHCHTAjRgil+TxnBnHP5pdImdVERXHjN9DETr+y9sYqPeKUbxbH0KHGGO2RCiBZMKbMoI5grG2dgwdXTpBYIKjWmZe+NCWUzSfhQkAkhWjDF7xl0UwYVsVS5N1GXzSThQ5M1IUQLpvg9wyhmIZubq3pvmG6ULlg6kxCiBdPKLIYR7S2a3mXavQmaqNPe4goFmRCiDaemC7LNG3RhkjCYdm+CIuq0tzhDQSaEaMVpQn5oRT1qq8qMEMeoSLpY6eqmlVYoyAnHpB0CSQ/F4+7EwBls2PFGYoVIhqS+k7q7aaURCnKCSfpqnMQD7prSgam9k+O0AGKUdUIxpVMMSTemFAshwWNK2lshcduUMA85gXhNgsDoJDg8QuMICRZTioWYwPBIHi2dvdjedhwtnb2Je/9MSXuzMKGMqyzcIScQEzvFkHRi4q4pCuK2U1PBpHKfcbXMcIecQDgJElMwbdcUBXHcqalgUrnPuFpmKMgJRMckmHTzGgmHoMtYmk7a3EemlPuM66aEJusE4td0lAbzGgkHrzKWeQCrbvwwXjz0rvERsCr4dR/FKULYwoRyn3G1zFCQE4ifWr6Mzia6car7XF1ZCgDYtPvw2N+StvDzs1OL88J4Ukkm0vgUk/zZMtBknVBUTEdpM6+R8FjWkMO+9YuxdU0znljViHVLrkX/4DmcHDw37rik+VVVd2oqfme6mS5ikj9bBhYGSTgyJi9TE/tJskhTRSeVphIq9yfOu+kgidt9ock64ciYjuIaCEHiRdzS8vz4cVXcR7L3h24mZ0zwZ8tAQSZjxDUQgsSLOC38dOywZHsny9yfuObbhknU/mwZEi/IcYxSjIq4BkKQeBGXhZ/OnafMTk3m/sTN2kDcSbQgx81/EDV+orNF4OKIAOILv/kza9HS2RvJeAli5ym6U5NZGL946F2h7zbB2kC8Sawg06+ihqx5TRQujoiFyMLv9nk5fPKxvZGNlyh3njIL47hYG4gYiYyyTlMUZ1Do3M2y/R6xw2mRdvu8HL71ypFIx8v2tuO4f1ub53FPrGrEysYZgVyDyCJWJYqbmEsid8j0q/hHVyAEg06IE3Z+1fkza/HJx/ZGPl5M2HmK+J2DdjORcEmkIMcpijPpcHFE3Che+LV09hoxXkwJcBRZGAflZiLhk0hBNmF1S0bh4ojIYMp4idvOM275tsSeRJbOTHuHGZPg4ojIYNJ4MaVzkSjWbnpl4wwsuHoaxTiGJHKHHLfVbZIxxfRH4oFp44U7TxImidwhA/Fb3SaVuBZ5J9Fg4njhzpOERSLTngphMQozYB4ykYHjhaSRxAsyMQcujogMHC8kbVCQCZGEQkEICYJEBnUREhQ0pRJCgoI7ZEIEYQlQEjW0ziQbCnJAhPXi8AUNB9ZHJ1FD60zyock6AMJ6cfiChgdLgJIoYfe6dJDYPOSosF6c4snbenF2tnfF6nvIKKaUdCTpw6tBCzDacGN4hMbOuENB1khYLw5f0PAxqaQjSRcy1hkSbyjIGgnrxeELGj6sj06igtaZ9EBB1khYLw5f0PAxsaQjSQe0zqQHCrJGwnpx+IJGA+ujkyigdSY9MMpaI2F1qpk/sxYlGcDNRVySGT2O6IXdf0jYsHtdeuAOWSNhmTVfPXbCVYyBUbF+9dgJX99D7GH3HxI2JllnhkfyaOnsxfa242jp7GXwqEa4Q9aM9eIU5wdnNeYH04dMSPowwTrD2gfBwkpdARFkBa2Wzl6s3tLqedzWNc0sUkEI0QJLxwYPd8gBYZk1gyAsXzUhhADetQ8yGK19sLQ+SxeOD+hDjiFMwSGEhAlrH4QDBTmmmBTkEQY6AkkYjEKIGoxbCQearGOMCUEeYaAjkITBKISow9oH4cCgLmI0OgJJGIxCiDrDI3m0dvbiS88fxMmhc7bHsP2oHrhDNgD2NLZHRyAJg1EIUcfOslQM41b0QUGOGJpSndHRg5h9jAlRw8myVIzOGgtph4IcIWw67o5ogEh3/xBaOnttLQwMRiEy0Fo1iptlyaJmcime/GwTmq9itTpdUJAjIg6m1KgnJ9EAkQ073kDfwNmx/y60MDAYhYhCa9VFvCxLAHBy6BxKMhmKsUYoyBFhuinVhMnJqwCKRaEYA+MtDEvrsyyiQjyhtWo8tCxFA/OQI8LkAW9NTsULhq4Lk9PO9q5QrsOtAIob1qT66AsdAOB6jjyAVTdeqXyNJP54WauA0bGUprx1WpaigYIcEaYOeC/fUR7hTk5OBVDqqkpdP1doYXA6h8Wm3W9i0cY9oS00iFmwCtVE2IM5GijIEWHqgBfxHYU9OS1ryGHf+sXYuqYZT6xqxNY1zfib5fVCn7UsDNY51i2ZY3tcd8i7f2IOJlurooLleaOBghwRpg747v4hrcfporAHcf/QWXztpTeEPldsYdj2s1/ZHqfbNMkynfHBVGtV1KStPK8JMKgrQsLonSxLcYCUE/vf6sEdTR8K+GomIpobaResFVYgnQkBcaYQdaS+CKrd0+Lw2/ySlvK8pkBBjhg/Az6ICaHu0nKh43a98R6GR/KhvpgiuZGFFFsYwjBNMlr3IkEuTHSOfcta9cVnDyIDjHt2hdYqAGP57kd7BrH1wDvoPpX8RVeQrWTJeCjIBqAy4IOa7LJTxcxy/UPnQ0/JEvFvA6MBX//jjusn3IegTZNxyC0PiyAXJqpj303EvaxVALBo4x7X8ZfGRZcqabAuqEBBjiFBTnbzZ9aiqmwSBs4Oex4bdpCL6Pc9dOvHbH+/qmlSFNNzy8MiyIWJ6tgXEXEna9Wujm4hN0naFl2q0KXjDIO6YkaQOZM727vwycf2CokxEH6Qi+j3Oe3y/QbSeQVqMVp3lKDSiFTHvlNevV1kfWHwoLVoknGTpDFFSgaZZ5FGKMgGIBORG9Rk5/Si2BFVSpaOVDHVyNGd7V1YtHEPVm9pxf3b2rB6S+uE3GVG644S1MJEZez7XcCKukmKSfqiSwUWYPGGJmuf+PWFyJpvgpjsZIKlokzJEg2+8bou2UA6UTNp0CbxuBDUwkRl7Pt1I6gKq+hvS5MvlS4dbyjIPlDxhRS+gEd7BvH47jel/GFBTHYyu4CoW63pShUTDaST9YfqWDDEnaAWJipj3+8CVnbRIPPb0uZLpUvHGwqyIirBJSLNvgH34JAgJjvRF2DtLddg3dJrIxeUMHMjZVf1JuaWh01QCxOVse93AWt9p+iCNQ+x35bG9Di6dLyhD1kBFV+IjI/WOo+dLziICl+iL8DCa6ZHLsYWxcE3QV2XyqrertTnvvWLEzfBuhFElSeVse837qDwO0W4e+Esz9929vwI/voHr6fOl2pquWCToCArIBtcIlvQohA7QdA92UX1osgEs0VVipKrenWCWJjIjn0dC9hlDTmsW3Kt0PUtrc+6/vvO9i40f/1l9A2cczwmqZHappYLNgmarBWQ3TWpRmoCzhO9TrNtFL5PGf+ZLl+bSgCNipk0bb5BN4Ko8iQ79nW4EdYuvgZbDxxD96kztv8u4ioSLftqkURfKl067mTy+Xyy7CIh0NLZi9VbWj2P27qmGQuunobtbcdx/7Y2qe+wXvB96xf7FkJRIQpLSJwmJuuKCnc6Msd6fafqb7OuAbBfrARxvUQ/OjIiRMeB3Xd7Vfoqxpo/kkiaostliESQ4/gwCq95elU5/vxff4H3TrnvmiwxFRXwws8DeiZvWSEK4tmMu3eXluPP/6XNc6exb/1iAO7lCkUXLTpEUuQ+ek26OhdZJBpUF3YycwDHSXoJ3WQdR3Oe3TXXVJaORUN7mXi9zJ7F6DLfqERyqpgY3URcNLLcoth/Jpu3WHwt82fWainjKGImZZ5l8lF1Fcman9PuS00roQpyHEP9na65f3A0KKO6shQnBy8GaNiJqZePNg9g3ZI5mDW9SuuuNIxGB24LLABSPrNCZCYw61i7a6mrKnNtKSkjktZixRL9Fw+9O+55Mc8yfqhYhFQWraJBf06NUUg6CE2Q49gJR+SaKy4pwXOf/zh6Pjjj+kKHHcwQxm7Na4FVfcGKoIJM1PJlUyocr0W0v7OoSLotQBiRHS/CtNaJWMmmVZWh5Su/h7JLmPySVkIT5Dia80SuufvUGZRkMljZOMPzfGEWtAh6tzY8kscjP/qlay5loeVAlOJoVZEI5/kza/HJx/Yqiz8gJpJeC5An72xi6cyYELa1TiST4Wt3NFCMU05oTz+O5rwgrjmsghZB79Y273nLMTBLlWL/u2je4qvHTiinlQFASQY44bGTFikGs2FHBx5acZ3n9ZpiAUorUTU5kMmhjirvPmz8/s6k3afQdshxMOcV+5OmV5ULfc5EE6Royb8TA/KiurO9C5t2v6l6aY7Yme9FTP3b2477+t6RPPCl5w/iqRLnXZGohae2qpx5loYTpbVOxEoWx8BXFfz+ziTep9AE2fROOHYPNzu1AjWVpegfPGfkNXvxx7/7YTz+8mHXYzbseAOfasgJ79qs3YVfrHv3P/9wHnoGvP3vbpOY6IIokwHckvzcYhhkrCUrG2eE5pog8kRtrXMLCotj4KsKfn9nUu9TaIJsciccx4d7yvmFjPqa3ZBJNZLdCbS+3StsHq6tLMWJwXOuz3vhnOlC53KbxEQWe7VVpcLlCu2+R9bCIxKJG8d8/CRgqrUujoGvKvj9nUm+T6FGEARRcN4vonWmi59rlNfshmwTC0AuwvhLzx0UPu/XP3M9nlZ43l5+oeJ/B+Dpa75DIOgOcL4Xuut972zvwqKNe7B6Syvu39aG1VtasWjjHuxs7xL6PFHH1CYHsjXy44rf35nk+xR6YZAwI41FEK0zbWnC3QtnYWl91sjdjGoTi6M9g57HyNbhXbdkzpjgyjxvL7+Q278/eWcTHtzePi7VyfLdVk8uw3f2H/W8bqddkU4LT1LNbXHBVGud6MJ4/1u/NWLuVMWvy0D183GwSEXSXCKIgvOqyPiJMgB+3N6Nv1kR3MvqZ9CoNrF4fPeb+Ej2Utcdq4zQ56orsHbxnLH/Fn3eXkL1hZtn41uvHLH993ufPYjKskkYPDs87t8Gz54HoCeGQUcueZLNbXHCxCYHoibyzXs7x/5/HIOY/LoMVD4flwCw1Hd7Eo2kBoLPlfY7aPwEobiJgIzQZyC/uxgeyaP17V488G/uPWK3/GSiGBf+e7EYA0D/0Hnc++xBPH1Xk5ZdkV8LTxzz8ZOKadY62RK7QDytKn4Xx7Kfj5NFKpZZ6FpzzxTevSCiL518v9agEfEtqgahePlcRH9vTWWp9OC2fKmf/fZPcXLIvZCIn8dsLTh0xDD4ySWPOsKXjCesugCi1+IUC+FEkHnTQeG3L7LM56PKOVcldjtk3aaHng/k83B1R1/qMmN6FbfwwkkERH/vk6ub0Hz1NLR09gr7i1VrXctiLTii3hWZGuFL5AnCJ+lkSncjjlYVvy4D0c/HzSIVK0HWYXqYUPzjUnGTdVB5xzoGzfBIHht2+MsPdhKB+TNrcWn5JHxwZqJJGLh4X/qHzk1oP+i0WFINQPODteCIMobB9Hx8IkaQPsniRePh9z7A5r1veX4uaquK7ALF7+JY5PNxs0jFRpB17CLti3+Uuxb/KCaI6Esdg0Y1oMsiO7XcVgR2tnfhge+/7ijGwOj9v31eDl96XnyxpHK9JRcKe4TRsEIW0cnI1AhfIk4YPsnCRWNLZ6+QIEdpVVFdoPhdHHt9Pm4Wqdj4kP3mnjn5aN87dQYnL4ix2xSYCzDvWMeg8bvCO31+BLs6usf9bWd7F+599qBnk4iq8knY3vausJ9meCSP/W/1CF9b5sL/1nxi9th/yxJkXqlsTrGJ+fhEjCh8kqbmTVvoiH8JCtPvXTGx2SHL7CJVmtRXV5ai4pJJ46pzTasqw8rGKwLPO9ZhxvS7wjs5eA73PnsQ37yzCcvn5qRKZA6cGcaAxw7aWiz1D52V8o8B4/1CN1xZK/15ILhdp+puKWpfdprQ6euNwidpslXF9DQ+k++dHbERZFHBOdozMMGPKdKk/uTgOTx3TxNKLjSaD3OC1DFoVFIm7Fi79SA24wbUVpX7MoHbsaujG9/df1T4+moml+LJO0cDxazfXihk754YxCMvduD90+cdz5HJAE+uviGQXaffycikfPykotvXG5VP0sS8aSAeQVOm3js7YiPIIrvImspSbNo9sZmCaJP6noEznn2Ng6r24nfQuIm6DCN54L7nX8M9C2cpnsGZHzqYtR3JAO+fOTfh/k4qyaB/6Cwe+z9vuooxMBr5vXxuMC9cHCajtGD3Xu7q6Nbu643SJ2miVSUuQVMm3js7YiPIIrtIv14br5co6GovOqIOZVMmnNj281/5+nwhF5s7yKVl9Q+es504Ld+2G2FU4YnLZJR0nII1T58f0W5KjTpK3jSrSpyCpky7d3bEJqgLcA+G+fKSaz2Dj5wQceyHFbjgt1DBsoYc9q1fjK1rmvHEqkY8d8/HkZ3qHNTghJtP2A2/zR0KKQySOXt+BC2dvfjBwV/jL/71kOvnLi2/BP/xl7cEboqK02SUVBzfywvBmk6oNiDwW9QiacQtaMp0YrNDtnDaRb546F2l84m8RKYHLhRTvBJ85PZ6zx2lH6xdwUMrrsOGHW/YmtxFmzsUY02czV9/WXiH/cGZ8/jZ0T4svEastaMqUe+W0oSdSRqA71x2FetFmD5J0xsixC1oynRiJ8iAvelBdBdSV9QXV+QlipOv0O4FXtaQw90LZ+EZBUH0ovClW9aQw6cacmjt7EXL2z0ARp9T81Wj98RP0JmsufvZ1mOBC3IUk5HpE3QQOLmKVt14pW/XjKr1IgyfZFwaIsQpaMqLqN+vTD6fN6OIp0+GR/JYtHGP527lP/7yFrx67ITUDd/edhz3b2vzvIYnVjV6BoW5Xb/fgeD2AldPLsPqLa1K1+ZG8QThdg0A8MULO/WgB11V+SQcevhTobxMYU2cur8n6slHBKe0Mj+Bi9bns9UV2Ld+sXG/GXD/3QCkAtLCes5hjqcgvsuEBVBiBBm4OIgB+92KatGFls5eITHbuqZZaYcsMxCcBqLXC/zknTdgw443hHeoXtXL7FKSvCbPuxfOQvXkMmw98M64fO+SjL/GEU6oPg8Vgp6MdE7Q1vminny8sBbZutPv/M4HQeP1u2UWE3F4zrIE8Zt0v1+qJEqQgWAelujuW2W1LTMQnH7bQyvqsWGHc2T1RR9vPb70vPsOVXQ3W1NZim985vqxa5OZPLNTy7H6pisxa3oVLptSgT3/2Y0tPznq+TlZ7l44C39728e0nzdsdE7QgDmTjxeiC2EnnAr+mC5IujYAcXnOMgTxm3S/X36IpQ/ZjSB8O0H5CmWCxdxyKu973j1gy/Jx11aV2fp6nCqSPXVXEx74/uu20arFKUkytanfO3UGj+8+jKfuakL/0Fl8OwAxBoBn9h8d86HHGZ0xDHEKUPSTLmZd+Tc+c30s8k8L0ZFOJ/qcF3/0cmkXXlQENXZNihFKnCADweSbBRG4IDoQWt/u9ayfK8Jv3j+NlY0zhCeopfVZPPKjXzpeW+ELIDN5Wp8dPXfG9Tf4MWebJC5+0JnvbNLk44WfdLHi9zJOrgsd6XSiz7k4e8Fk60FQY9ekegKJFOSg0L37Fn3ALZ29Wvxo1gssumA5cKQP3aec+0UXvgCyk2cecD23hR/fskni4ged+c4mTT5eqJaDfWjFdfjThbNDX4TpcpfpSKcTfX7F2Qs6O1bpJqixa1I9gVgVBjEBv4U7ChF/wP7c/HbJ+cMj+bFCG9/5ydv4wWvH0dLZO65LjcwL4FUgIEpMEBc/6Cy+YNLk44XlKpId/dOnlEcixroKB+koPqL6/ILqWKWDoMauScVNKMgRIjoQFlzlL582D4y94C2dvdjwwi9x49d2YfWWVqz7l19gw443sO57E9sGyrwAbpNI1JggLn7QWR3KpMlHhGUNOdw2Nyv1mbCfdxAtGf226PSzQFatYhY0QY1dk6qvUZBDxtqZbm87jgNH+vDQCu+B0Hz1NM+BWFtZ6vq9r71zYqxn73f2Hx1XHKWQroIV/fyZtairKnM9b21l6dgL4DSJOF1zdmq5UllPGUwSFz/o6qFs0uQjwvBIHj853Ct8fBTP22+vdieKy+BuXdOMfesXj8tssOaSYuuWjgWyaZalIMeuKT3KE5f2ZDJOPqbb5+Xwo190ufqevHKsqytLlWt5F5PBaFpT+SUlQn7epy8MWCugpbt/CH0DZ/HrE4P47v89Znt+YDSKG4Bt9LgurP7OSUFXvnNc8lNlU5++eedo61A/90f2HodROKgY0ednd1xxtUInwszjlyHIsRt1sRwKckh45c/9w6pGvPf+GRzrG8SHayvx0cunoG/o7ITiH04lBDftfjO031J8/U51rGUWGw/82+s4OaRnQVGIqZNKUMhMKFFPPiKIil0mA3x+0Wy8eMh9rHmhMtkHVThItQhQ8Y6u+DzzZ9bik4/tDaSuQljEYeyqQEEOAZGiGW7pPYUTgt1AfPHQu0KTVthcrBLWhNqqMteXZ/9bPfjst3+q/Rp07kpMJy67XhlExe7W63PY8XqXr4IRqkUngigc5LcIkNd3BVXVkPiDPuQQECma4Rbv0dV/Gvc+exAvHXrXNsr7aM+g5ivWg/WTNuzowE2z61wj05uvcveTF1NX5e4zt4h7QJcoYbUHDRuR4KTqyZfg58dO+Aqq8hOYpdu36fYs73t+4t+Lr1XEX22Kz5SMh4IcArqCI9ZufQ0vHRo/se5s74rMXC2C6AThNallAKxbcu1YcEvrV5bEKlo4SIKI8jUFkeCkuxfOHlcasxiRMeg3MEuXwIk8SxFE5hyvoDESPqkuDBKWH0LXLm0kD9z3/EE8XXIxiOqB77+u5dxBIzpBOFVDW3XjlZg1vXJcL1wn37ndriSpPicgXtW3VHAaF5Y5/sz5EaHzFI/BwjFx+L0PlM5RfJ1+CwfJlKB1Q3TOCaKqIVEntYKs09/mNdmrVhxywioH2fp2r1Bk9a3XZ7Hj9W4AetseFtf1dkN0giie1I72DGDrgXfGCW/NhRQvp99eXDYxib7VQuJUfUsVN7Fr6RRLiyocg3ZjQvYcdvgVOL/PSKSKFzGXVAqyU/CGStk4kcm+sDmFDqzdjuhENGv6pY5NJW6bl8OHaytxtHcQ/9w6MUXJjWxBkImfMn/FWJPazvYuPL778ITzui1C1i2Zg7WL53i2hDS5RKAscaq+5QcnsZMtNek0JtwIS+hknpHORjfEDBIvyHYh/7o6hshO9na5wpkMoBLnPrqSFvtg52/fx1986iOu5rSWzl4hQf7Dphn4xLW/M+7zJSUItROWExkA2372K6xdPMfzHKZ1NvKDjtrHYeBkSfLrTpDpxqY6rgrPESSiz9IuzdBPoxtiBokWZPuk+LIJBdULEfW36WidCKiJMTC6kj7y2wGhY3965ASGR/Ku5jQRs3quugIb/3DehElJVyeswom55/0z0ubE4meXdN+qRVDtQXXipyiOCKJjUMVHG4TQOS1CRJ/lsoYcPnWh7WkS4yLSSmIF2Wn36ibGhXj5coRbJ3Y6t04EnJuoO2GtkOfPrMW677V5Hg+M/mYv0fE7qfsNaFH16dlhPbs0+FYtgmgPqgund7Gr/zT+8ZUjE45XdSe4jUFLAH8smP619parMefyKVqFzrqGXR3d+GHbu45tD5fWZ/HlJdfiu/uPjCuWU/wsVfzVcQ1ujOt1y5JIQVYxSxXj5csRbp34do+ncJ8cPIfn7mnCz4/1YdPuw57nfPi2erx67ISQgFv4jXIWmdRVA1pUfHpuWM8uLb5VC93tQXWg8i76cSfYjUGVxd7Ca35Hq9XE6xqsRcgXbp49wWJQVT4JaxZdhf/+e3N8Pcu4BjfG9bpVSKQg+0kdEPW3iU/iYi9Qz8AZ3L/kWnwkO8XxxS0chNvbjgt+/yiqUc5BT+o6Fk8Wxc8uLr5VnZiWxqL6LupyJ8gu9oIYEyLXYP2bncVg4MwwHn/5MIbOncdXltfbft5rBxnX4Ma4XrcqiRRkVROkjL9NdLJfcPU0bN77lud3W4JZKIhWk4a6S0e7IhW+ZDK7urqqUqUoZyB4U5GuvEu7Z+fXDJ8WM1mQ+HUH+Pm87GIvCH+7zgXnP75yBPM+VIPlc68Y93evHaRKcKPs2A/iXUlLUGYhiRRkUbEq7noi428TneytkpAyuzSRXc5Ns+uQnVohZLb+6soGpZcpDFORyoRbW1k6Zuq3cHp2qmb4NJnJgsSvO8DP52UXe0H423UtOC0e3N6OTzXkpNL6qieXSQU3yo79oN6VtARlFpJIQRbdvf7HX96CV4+dUF7ViU72TsKNC/+96sYPy/5ETCrJ4JHb63GvR27zn908e8KKuhC36NdvvXLE9kW/99mDuHvhLCytz/peCYtOuA+tuA7Tp5SPq9QluiKXNcOnzUwWJKpFcQoXqqq7L9HF3p8smIlPN+QCsYDoDhjsGzg3JkCiO8i/WvZRoXP/5v3T0mM/yHclTUGZFokUZNHda9klJb5XViKTvZNwW2zafRjbfvYrpVSPp+9qwgPff31CfvOl5Zfg7/5grmsvYLeXyc6XBVy8l8/sP4pn9h/1vRIWXTz96cLZEyZLmWcn6ltNo5ksSNzeRScK39FdHd3Kuy/Rxd6nG3KB7bCCCBi0BEh0B9n3gXdPcwCYXlWOv/jfvxAe+0G/K2kLygQS3FwizG4mdh2Y7K5n3/rFWLfkWttzFHblGR7Jo6WzF9vbjqOls9e1KcCyhhxefXApnvv8x7H2lmuw9par8dw9H8cvHv4vrmKsq4i9325Cujvl+MVvkwEyEad3MVddgT+7eTZyDu8oAF8drLw6RYXRgESkW5UslgCJ7gzrqsqE7gMykBr7Qb8rJjy/sEnkDtnCxDSQbT97x/bv1oryge+/jkd+1DHON+y0Iyg25a1beq3wb9Pl29KxEjYphzaNZrIwcHsX/2rZdRP+DgCLNu7xtfsyoWCKioXAjUIBEt0ZZqsnC92HHsGddFh5/iY8v7BJtCADZqWBiKwoR03P483Pdv4Yv4EUMjnMXugIrjBl8ZRGM1lYOL2Ldn9v6ezVEtATxmLPy8ftdA1TKibh/dPDwt+TwXgBkknrm1SS8bwPsk06wnhXTFqsh0HiBdkkVFeKoqU4ZQIpRP1KMjj9PtGgHBMWT6PR6+XoPmV/f5KYu2wiOndfQS72RBfGdtcwf2YtPvnYXqGAN7tzyu4gx6VUnhr1LddUluH4iSH84OCvcdmUCmSnVuC9U2IZIWHl+ZuyWA8DCnKI+FkpjpXifNu5FKeM+biuqkz5Wpyw+31xSx/a1dGN0w79dZNqJjMR3buvIBZ7shHGdtfgJqh5wDObQXYHOakkg/6hs/i7nf9pa4GouZBS6JQR8tAKfXn+MpiwWA8DCnKI6OiLrMuUl62erHgFE3FaCcctfcirolJ1ZSm+8ZnrjbrmpGJ6lTWRoEiRhbEOk6zMDtJrjFvZGnad6QBgw44OlJRg7LrSZlIOGgpyiOgJ8BD7lJcpz5rw/AZ2Oa2ERVMiFn/0cl+54LoQqag0uXQSltZnQ7umNCPbUtFNjERdJjL5ziJBkaJxFTpMsiI7SJmqYXmHNnR2i+k0mZSDhoIcMo4ryqnlOH1+BP2D59xLcV41HZv3dnp+z2VTKlwnmMIJTzQ3tKayFOWXlIzzrzqthEVTIpq//rJj15sw0TnBEj2I7L68XCKiLhPR42S7Ru3q6BYaL2GYZGUyK/qHztv+3cktlhaTctBk8k5LIcOJe51hu+u3grUA+x3BU3c1YWl9Fos27hFoYF6PDTvUJiK7cxZ+v8h93952HPdvaxO6F07fFaYoi17vE6sasbJxRvAXRMZwK+1qt6C0xtAXbp5tW22ueIx5nafwONmuUdOqynDgb5YYMTepvpNObF3TTBHWTCx3yHELFLLDbkXptxSn9crfPi+HLz0v5rstNjcd7RnE1gPvjEuLKv5+kZdQNYAtqmpYTHcyF7t3RcQlsuUnE8W48N8tl4mIa2VkBLbvlBe9Ar3Iw0L32GUuvn5iJ8hxCxSSxU8pztGd8XXYsOMNqSjs4glv7eJrfFsf5s+sRUkGcCky5kgUReNNDyIqJu4WIr+IuETcbH/WGPvnlqNCrpUHt7crB2KaIlw6gkoL4eJUP7ES5LTUGRbxxzgJt44OKTr8Qa8eO6EkxoWEOZHFqSpQEixEftE1No71DQodVxjnIIspwlU4xr2oqSz1jGcxZXGaJGJVy5p1hsdjV0NbtAJX8YQmUz9b5fwqhD2RhVn/XBXLQqRa3zkp6BobM+sqtZzHDhNrLVtjvLh+uEWuugJP39WEb3zmegBm1JdPE7HaIbPOsDs727uw4cVfCh17+L330dLZOxZMpnvH5WfCjHIFbnIKR1osRCKIuBgyLi4Ta4z9twWz8O19R1zPU1vUN10Ek4XLrmJXXVUZstWTx431J+9swoPb28dZB5hfHCyxEmQG3jjjlfBfzOa9ndi8txM1DgUA/PrkRf1VKubh4ZE8Wjt70fJ2D4BRK0HzVfZdtlQwNYUjjQ3bnRBxMaz5xGiUNRz+3WrBevu8nGO7UQD46soGbNjxhutYLo6XkBGuIOIBvM7pNcZ3tnfhr384sa3r4NmJ6VBpj2fQSawEOW6BN2FgidMD//a6UqCGnRgD/ndcIhPmF26ejR/9okuqws/O9q4J/Z83730LNSmoopUEC5HOyVskK+GGK2s985i/5SLGX7h5NpbPvQIlJRnXsbx5dRNqq8qkf1cQ8QB256yZXIrPLZyNtYuv8byune1duNfBz9w/dB73PnsQT7ukgolcP0XcntjlIVs7QcA5VzfJk3IhKnmRKvjJN/R6YWVeTLeJwuLpBD//ls5erN7S6nmcqfmhQQWjqVbqGh7JY9HGPa7vT666AvvWLx7Le9Z5/aL5zzrOaeG1cB0eyWPhN/Z4xqJkp5bjb2/9mG0qmNf1MyjRmdgJMsAHCsibqP3gtxiGjtXw6ETxsmMXJovCCTRpWALiZSEy8fcHIT5+UVng6NrZeS0GVJ6lyALDwmnhKnpPgNEGNU7R507Xb+I4MIlYmawtTA68CQOZmrQ68OuT1+GTHQ1A8W4ZmWQfapxSswoxNRhNxQVQOJb9iHMQ8QAypTGd7reMu8MtFczu+k0dByYRS0EGzA28CQOZF88PJvnkZSYKk32ofoljdx1Tg9H8BIn6tdIFEQ8gc6zT/Q6ympep48AkYivIJhN0wILMi2ftpNwS/Z0+B5iz45KZKJIeZR83C5GpwWiqQaI6qgUGkTEiO+7t7vdNs+uQnVrh6UOurbwEJwbtG1A4XZOp48AkYlUYJA7sbO/Coo17sHpLK+7f1obVW1qxaOMerQUbZF68rGCif01l6YTPmeTPGZ0oyj2PM60QQ1DYFYUxFVPTFS0XADDxvQBGF7Krbrxy3N9E+yB7FdaxFgNOT02lqIh1TlHs7vekkgweub3e87Nf+/3rpa/f1HFgEhRkjYRVRemm2XUTBLSYmsmleO7zH8e+9YuxrCHnWoXq6bua8OqDS7F1TTOeWNWIrWuaxz5nCqMTxcc8jzNlR08uEoT46MJ6L6od3qdNu98ct6DWVS3QbTFg/fdDK67DgSN9wtXzrHN6jX6v+72sIYen72qynWNqKkvx9F1NWD73Cs/rL34XTR4HphDLKGsTCSJq0omXDr2L+55/zfWYwijKQhP69KpyIAP0fHDGeFOnHXZ5yABQW1mKryc8DznOBJGuqMs1JJJOlwHw5SXXonfgDP6p5ZjnOUUzE5x80bfPy03I0Rf1UTu9I9bvAMTu9/BIHq1v96KlsxdAHguumo7mImuMrC+daavuUJA1EUaO6PBIHv/w8mE88fJhV19wTWUpXn1waSC5kyYQdKUuEgwqY9GtF7KOcS2TKiSDzHte/BtPDJxVyu8tPufmPYfx3f1HcXLoojAH8e7LLoySOCfpgoKsCV0N7t0mIKdVrx1b1zSjf+gsc/6IUcgWgnHaPX7rlYm9jlXGtUzerQh+LWG6LW2mVsQy9bqihlHWmtARsOA2AbnV2rWju38If/fv/485f8QoRNMVnSKZu/pPO74LKuNaZ0SvjswE3alBpqaHmnpdUcOgLk34DVhwCwiTFWNgNGmfrSpJHPFT+EZ2XOuM6NWRmcDUoHTDHbIm/FRREkmlkCFXXYG6S71ThADzX2yattKHjsI3ouNatCuZG3+yYCY+3ZDTMjaZGpRuKMgaUa2ipLvy1sO31aN6cpnQsSa/2Az+SCc6Fol249ppcWctpFX5dENOm/mVHe3SDQVZMypVlHTtUksywObVN4x1UfJ6seuqytDdP4SWzl7jdp46qiGReOJnkehWXcttcWe3kFb9Lj/EtV450QOjrA1AV6TnN+9swvK5F0XKKefPDtWUkSDMybJt8Uiy8OpqZeEkWMWLNdEOQ9Z47j51Gn0fnEFdVRne6RvEpt2Hhb9LF1FZh+giihYKsgGITkBOuBXFkO2ZXCzqTgQ5YcS97y/xj1cBiS/cPFuocIaONCKdOc8yYidyvE4BpYsoeijIhqAyAdVMLsXnFs7C2sVzhF7s7lOnseHFX6JvwDmX2TJ7L597hee1BpXf/IPXjmPd99o8j9v0x4244wb1Ps3EbLwEQkSMRBd3z93zcSycM93x3/0KXxBip/Oc7FNsBhRkg9AxAbkhYxp3amAeRonQ7/zkbWzY8YbncQ+tuA73fOIqpe8g8cDvmBct2FMzuRTf+INgSq8GIXY6zxlm2V/iDoO6DMIrIMxvMr1M8JhTcYUweprWVYlFiIseR+KL3zEvGiB2cuicVLCg6ELBK6VRpUCP7nOyT7E5UJANI8gKNjLRq04vYBiFC7LVk7UeR9KLbJ6xiJDJmIqDEDvd52QxEnNgpa4UIdsv1e4FDKNwgch1pr1NGxGjsM2hFyJVvmRbrAYhdrrPyWIk5kBBThEykxNg/wKG0dPUq69rBszFJOJYecY1k917iFs4CZlIRb1HX+gY17c4CLHTfc75M2vh9SqVZEaPI8FCQU4Zyxpy+OadTa4voJuoijRW1yGW1iRavFPOaagXTNLHsoYcnvxsk9CxR3sGbP8uYyq2CGIBO39mrWv8hOw5Xz12AiMe9vyR/OhxJFjoQ04hy+fmsBk34L7nX5vwbyKiqloiVBaVqmeEONF81TQhf/Km3YfxkeyUCeNYxVSsu/KW5b/uGzhr++8q56QP2RwoyCll+dwr8HRJRllUwxJLtmkjuhCtW+0UpaxqKta1gHVKdSpEZVFMH7I5MA855bBUHkkbT+w+jE273/Q8rrgSnFdFPa98XT/vmkg52bqqUrR+ZQnKLpHzRPr9XUQf3CGnHO5ASdqYNb1S6LhiE61f87Ofd02kI1zfwDm8euyE9HfEsaFFUjcSFGRCSKrwY6INK36imKD9vFH9LhWSXHObgkwISRV+ew5HEWwYhp83DkGUSW/LSh8yIRIk1VSWNryauZg2sdPPm46a29whEyJIkk1laSNOJlrA3c+LC/+96sYPh3pNYS9O01BzmztkQgRge7pkEjeLh1d/87AWiFEsTkU7dz2xqhErG+PZlpWVugjxQKVkIokHVuTzysYZWHD1NKPFGBjd2e9bvxi3zrUXvS6Hmto6ka3nrYs05EtTkAnxQKVkIkkWwyN5tHT2YnvbcbR09vpefPk537+3d+HFQ86il0dwC8QoF6dh1NGPGvqQU0DczHKmwdKC6Ua3edbP+YZH8nhwe7vndwTlS43SjxvHfGlZuENOODvbu7Bo4x6s3tKK+7e1YfWWVizauCdQk1bSSIOpjNij2zzr93wHjvShb+Cc0HcFsUCMenFqBeNli5rOZBPSdIY75AST9Jy9sPCbt0riiZd51qnmdZDnkxG6IBaIJixO45AvrQp3yAmFgUj6CKvlJDEL3bEDOs4nKnTTqsoCWSBai1MvTgyc0f7dhcQtGE8UCnJCYSCSXpJuKiMT0W2e1XGcqCBuWNkQiEhNKsngoRX13t+/4w0u9hWgyTqhRO3rSSJJNpWRieg2z+o4rjCwyUnu/uzm2VjukBalg9qqMs9j4l6gIyooyAnFBF9PEmF3rPSgO3ZA1/mcqozVVZXiqysbsHzuFULXo4opi/0kZo9QkBMKA5EI8Ydomg0AtHT2egqDzrSdKK01Jiz2k1rGlqUzE0zcCugT4oegdkxukz8AaWGIu5hE3egiyWVsKcgJJ+4vPyEiBD3O7cR+V0e3sjDE3dwa1WJfZ8cnE58BBTkFmDjwCNFFFDumNLQC9CKKxX5LZy9Wb2n1PG7rmmbXWA9TNyr0IacABiKRpKK7eIcoaWgF6EUUfmwdAWUmF0yiIBNCYktUwmhKpHEhUVjCwl7s+w0oi2oBJwoFmRASW6ISRhMijQsx1QSrG7/ZI6ZbNlipixASW0QF72jPoNbvNakVYFT9iaPAbxlbEy0bhVCQCSGxxUsYLR7f/aZWYTKlvrlozfqz50e09nOOEj9lbE2zbBTDKGtCSKzZ2d6Fey+k4DgRVNRz1KZi0ajjuqoy9A2cHfvvJJizVXzmUedQe0FBJrGHaV3kid1vYtPuw57HeaXDqBDl+Nvedhz3b2uT/lwSimioYnLBJAZ1kVgT9Q6FmMGs6VVCxwXhG4wyrVDVtGpCRHFUONUCzxowb1CQSWwxOZ+QhIuMbzBJFhWvqGM3oo4ojhJTO7dRkEksEQlmeeD7r2NKeSmaE9TAnNgjmg5zYuDMhApbcbaouDWsECWtLVhNLJjEKGsSCcMjeV9Rn175hABwcvAcPvudn2LRxj2JSv0gExGJer59Xg5fev61xKUHOUUd11WVCn2eLVjNgUFdJHR0+H1lgllMCNYg4eA0th5aUY8NOzoSXXu62BQ/f2YtPvnYXmMjislEKMgkVHQ1AhBN9yg8PyefdGDnIz5wpE9LU4K4YXJEMZkITdYkNESLGIiYr0ULQhSe3wpgIcnG8g2ubJyBBRfiB0yv0BQUfopokPBhUBcJDZ11ZFWDWZI24RIxTK/QFCSmRhSTiXCHTEJD9y7FafXvRhInXOKNSbWno8DOakDMg4JMQiOIXcqyhhz2rV+M5z7/cdRMdo4qTfqES9wxpfY0IW5QkEloBLVLmVSSwcJrpuMbf3A9MuCES+yhP5WYDqOsSagEHfXJUprEjsLI6+lV5UAG6PngDP2pxCgoyCR0ghbNJJVGJP7hIo3EBQoyiQSKJgkDXXnvhIQBBZkQkkis3rdJrs5FkgWDugghiUQm750QE6AgE0ISSVqrc5H4QkEmhCSSNFfnIvGEgkwISSRpr85F4gcFmRCSSFidi8QNRlkTQhKNTB4y0/FIlFCQCSGJR0RoWUCERA0FmRCSelhAhJgAfciEkFQzPJLHoy902PbUtv726AsdGB7h3oUECwWZEJJqWECEmAIFmRCSalhAhJgCBZkQkmpYQISYAgWZEJJqWECEmAIFmRCSalhAhJgCBZkQknqWNeTw1F1NyFaPN0tnqyuY8kRCg3nIhBByAVbqIlFCQSaEEEIMgCZrQgghxAAoyIQQQogBUJAJIYQQA6AgE0IIIQZAQSaEEEIMgIJMCCGEGAAFmRBCCDEACjIhhBBiABRkQgghxAAoyIQQQogBUJAJIYQQA6AgE0IIIQZAQSaEEEIMgIJMCCGEGAAFmRBCCDEACjIhhBBiABRkQgghxAAoyIQQQogBUJAJIYQQA6AgE0IIIQbw/wHLU/4OgBduVwAAAABJRU5ErkJggg==",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"numpy.random.seed(0)\n",
"\n",
"X = numpy.concatenate([numpy.random.normal((7, 2), 1, size=(100, 2)),\n",
" numpy.random.normal((2, 3), 1, size=(150, 2)),\n",
" numpy.random.normal((7, 7), 1, size=(100, 2))]).astype('float32')\n",
"\n",
"plt.figure(figsize=(6, 5))\n",
"plt.scatter(X[:,0], X[:,1])\n",
"plt.axis(False)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "3de9d63e",
"metadata": {},
"source": [
"It seems clear to us that this data is composed of three blobs. Accordingly, rather than trying to find some complex single distribution that can describe this data, we can describe it as a mixture of three Gaussian distributions. In the same way that we could initialize a basic distribution using the `fit` method, we can initialize a mixture model using it, additionally passing in the type(s) of distribution(s) to use and the number of components."
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "535e27a4",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 0.216064453125, Time: 0.001145s\n",
"[2] Improvement: 0.0286865234375, Time: 0.0008411s\n"
]
}
],
"source": [
"model = GeneralMixtureModel([Normal(), Normal(), Normal()], verbose=True).fit(X)"
]
},
{
"cell_type": "markdown",
"id": "51197af4",
"metadata": {},
"source": [
"Now we can look at the probability densities if we had used a single Gaussian distribution versus using this mixture of three Gaussian models."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "7c76bb0d",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x = numpy.arange(-1, 10.1, .1)\n",
"y = numpy.arange(-1, 10.1, .1)\n",
"\n",
"xx, yy = numpy.meshgrid(x, y)\n",
"x_ = numpy.array(list(zip(xx.flatten(), yy.flatten())))\n",
"\n",
"p1 = Normal().fit(X).probability(x_).reshape(len(x), len(y))\n",
"p2 = model.probability(x_).reshape(len(x), len(y))\n",
"\n",
"\n",
"plt.figure(figsize=(10, 4))\n",
"plt.subplot(121)\n",
"plt.title(\"Single Gaussian\", fontsize=12)\n",
"plt.contourf(xx, yy, p1, cmap='Blues')\n",
"plt.scatter(X[:,0], X[:,1], s=10)\n",
"plt.axis(False)\n",
"\n",
"plt.subplot(122)\n",
"plt.title(\"Gaussian Mixture\", fontsize=12)\n",
"plt.contourf(xx, yy, p2, cmap='Blues')\n",
"plt.scatter(X[:,0], X[:,1], s=10)\n",
"plt.axis(False)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "0b121c05",
"metadata": {},
"source": [
"It looks like, unsurprisingly, the mixture model is able to better capture the structure of the data. The single Gaussian is so bad that the region of highest density (the darkest blue ellipse) has very few real points in it. In contrast, the darkest regions in the mixture densities correspond to where there are the most points in the clusters."
]
},
{
"cell_type": "markdown",
"id": "d0908c21",
"metadata": {},
"source": [
"### Initialization and Fitting\n",
"\n",
"Initialization of mixture models is similar to that of probability distributions: you can either pass in initialized values, or not. If you already have probability distributions, and optionally already have prior values on which distribution generated the data, you can pass those into initialization and use the model directly."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "fd8c565f",
"metadata": {},
"outputs": [],
"source": [
"d1 = Exponential([1.3, 3.3])\n",
"d2 = Exponential([2.2, 0.4])\n",
"\n",
"model = GeneralMixtureModel([d1, d2], priors=[0.2, 0.8])"
]
},
{
"cell_type": "markdown",
"id": "2dcbe803",
"metadata": {},
"source": [
"Alternatively, if you don't know the values, you can pass in uninitialized distributions and then fit it."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "bed00021",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 0.8422355651855469, Time: 0.0007176s\n",
"[2] Improvement: 0.23958969116210938, Time: 0.0005503s\n",
"[3] Improvement: 0.11565399169921875, Time: 0.0005138s\n",
"[4] Improvement: 0.07136917114257812, Time: 0.0004883s\n"
]
}
],
"source": [
"d1 = Exponential()\n",
"d2 = Exponential()\n",
"\n",
"X2 = torch.abs(torch.randn(15, 3))\n",
"\n",
"model = GeneralMixtureModel([d1, d2], verbose=True).fit(X2)"
]
},
{
"cell_type": "markdown",
"id": "f1bbc5d0",
"metadata": {},
"source": [
"You can inspect the learned prior probabilities."
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "5ae58b98",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([0.8565, 0.1435])"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.priors"
]
},
{
"cell_type": "markdown",
"id": "011f5250",
"metadata": {},
"source": [
"After training, you can inspect the distribution objects."
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "0991595a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([0.9047, 0.9780, 0.7445]),\n",
" Parameter containing:\n",
" tensor([0.7281, 0.3527, 0.9284]))"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d1.scales, d2.scales"
]
},
{
"cell_type": "markdown",
"id": "d25758f7",
"metadata": {},
"source": [
"### Probability and Log Probability\n",
"\n",
"Because mixture models themselves are technically probability distributions, it should be unsurprising that the calculation of probabilities and log probabilities are identical to that of probability distributions."
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "d08b210b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([-1.9188, -3.7001, -2.8847, -3.1817, -1.6772, -1.8678, -3.8099, -2.6887,\n",
" -3.4597, -2.5457, -1.5600, -0.9176, -1.4670, -2.0735, -3.8544])"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.log_probability(X2)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "350c3068",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(tensor([-1.8586, -3.6041, -2.8660, -3.0401, -1.5696, -1.8315, -3.6627, -2.6193,\n",
" -3.3195, -2.6105, -1.8031, -1.0723, -1.7300, -2.1385, -3.7464]),\n",
" tensor([-2.3815, -4.6215, -3.0040, -5.5725, -2.8109, -2.1167, -6.7331, -3.2486,\n",
" -5.7406, -2.2277, -0.7321, -0.2995, -0.5996, -1.7543, -4.9963]))"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d1.log_probability(X2), d2.log_probability(X2)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "a1b8107f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([0.1468, 0.0247, 0.0559, 0.0415, 0.1869, 0.1545, 0.0222, 0.0680, 0.0314,\n",
" 0.0784, 0.2101, 0.3995, 0.2306, 0.1257, 0.0212])"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.probability(X2)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "44495983",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(tensor([0.1559, 0.0272, 0.0569, 0.0478, 0.2081, 0.1602, 0.0257, 0.0729, 0.0362,\n",
" 0.0735, 0.1648, 0.3422, 0.1773, 0.1178, 0.0236]),\n",
" tensor([0.0924, 0.0098, 0.0496, 0.0038, 0.0602, 0.1204, 0.0012, 0.0388, 0.0032,\n",
" 0.1078, 0.4809, 0.7412, 0.5490, 0.1730, 0.0068]))"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d1.probability(X2), d2.probability(X2)"
]
},
{
"cell_type": "markdown",
"id": "d032028c",
"metadata": {},
"source": [
"### Prediction\n",
"\n",
"A key utility of mixture models, as a clustering method, is that they can make predictions for which component better fits each data point. These methods mirror those of scikit-learn. Starting off, if you just want predictions of cluster label for each point you can use the `predict` method. Let's return to the Gaussian mixture model for an example."
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "07010715",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 0.216064453125, Time: 0.0007911s\n",
"[2] Improvement: 0.0286865234375, Time: 0.001209s\n"
]
},
{
"data": {
"text/plain": [
"tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
" 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
" 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
" 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
" 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n",
" 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n",
" 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n",
" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n",
" 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2])"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model = GeneralMixtureModel([Normal(), Normal(), Normal()], verbose=True).fit(X)\n",
"model.predict(X)"
]
},
{
"cell_type": "markdown",
"id": "ea3af78d",
"metadata": {},
"source": [
"If you're interested in the underlying probabilities, which are the likelihoods under the probability distributions multiplied by the priors and then normalized (sometimes called the responsibility matrix), you can use `predict_proba` to get these probabilities."
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "7b3d7c41",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[3.2331e-10, 1.0000e+00, 5.0365e-06],\n",
" [1.3677e-06, 9.9998e-01, 2.1502e-05],\n",
" [5.2814e-05, 9.9995e-01, 1.1250e-06],\n",
" [3.7857e-05, 9.9834e-01, 1.6255e-03],\n",
" [1.1822e-07, 1.0000e+00, 1.1827e-08],\n",
" [8.1322e-06, 9.8747e-01, 1.2524e-02],\n",
" [3.6977e-06, 1.0000e+00, 5.8392e-09],\n",
" [9.9969e-01, 3.0660e-04, 1.0668e-06],\n",
" [1.0000e+00, 2.7696e-07, 2.4643e-11],\n",
" [9.9968e-01, 3.2161e-04, 1.4796e-12],\n",
" [1.0000e+00, 6.9959e-09, 8.9382e-10],\n",
" [9.9966e-01, 3.3986e-04, 1.9472e-09],\n",
" [9.9987e-01, 1.2673e-04, 1.1254e-07],\n",
" [9.9992e-01, 7.5676e-05, 2.5076e-08],\n",
" [9.9969e-01, 3.0740e-04, 3.1747e-06],\n",
" [1.0000e+00, 2.4480e-08, 1.8340e-10],\n",
" [9.9986e-01, 1.2941e-04, 7.4965e-06],\n",
" [4.5694e-15, 3.9609e-07, 1.0000e+00],\n",
" [2.0310e-08, 1.0201e-02, 9.8980e-01],\n",
" [9.1368e-08, 1.3950e-01, 8.6050e-01],\n",
" [9.5965e-08, 1.5413e-05, 9.9998e-01],\n",
" [1.2553e-08, 1.0525e-04, 9.9989e-01],\n",
" [6.6068e-06, 9.7937e-03, 9.9020e-01],\n",
" [5.7233e-13, 1.8398e-06, 1.0000e+00]])"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.predict_proba(X)[::15]"
]
},
{
"cell_type": "markdown",
"id": "a3d69298",
"metadata": {},
"source": [
"If you'd like to go even deeper, you can get log probabilities -- which are the space where all the calculations are done for numeric stability -- using the `predict_log_proba` method."
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "7ac64b1a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[-2.1852e+01, -4.7684e-06, -1.2199e+01],\n",
" [-1.3502e+01, -2.2650e-05, -1.0747e+01],\n",
" [-9.8487e+00, -5.3883e-05, -1.3698e+01],\n",
" [-1.0182e+01, -1.6646e-03, -6.4219e+00],\n",
" [-1.5951e+01, 0.0000e+00, -1.8253e+01],\n",
" [-1.1720e+01, -1.2612e-02, -4.3801e+00],\n",
" [-1.2508e+01, -3.8147e-06, -1.8959e+01],\n",
" [-3.0780e-04, -8.0900e+00, -1.3751e+01],\n",
" [-2.3842e-07, -1.5099e+01, -2.4427e+01],\n",
" [-3.2187e-04, -8.0422e+00, -2.7239e+01],\n",
" [ 0.0000e+00, -1.8778e+01, -2.0836e+01],\n",
" [-3.3998e-04, -7.9870e+00, -2.0057e+01],\n",
" [-1.2684e-04, -8.9735e+00, -1.6000e+01],\n",
" [-7.5579e-05, -9.4890e+00, -1.7501e+01],\n",
" [-3.1066e-04, -8.0874e+00, -1.2660e+01],\n",
" [ 0.0000e+00, -1.7525e+01, -2.2419e+01],\n",
" [-1.3685e-04, -8.9525e+00, -1.1801e+01],\n",
" [-3.3019e+01, -1.4742e+01, -4.7684e-07],\n",
" [-1.7712e+01, -4.5853e+00, -1.0253e-02],\n",
" [-1.6208e+01, -1.9697e+00, -1.5024e-01],\n",
" [-1.6159e+01, -1.1080e+01, -1.5259e-05],\n",
" [-1.8193e+01, -9.1592e+00, -1.0514e-04],\n",
" [-1.1927e+01, -4.6260e+00, -9.8486e-03],\n",
" [-2.8189e+01, -1.3206e+01, -1.6689e-06]])"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.predict_log_proba(X)[::15]"
]
},
{
"cell_type": "markdown",
"id": "c3618610",
"metadata": {},
"source": [
"### Zero-inflated Mixtures\n",
"\n",
"A common way to view zero-inflated distributions is as a mixture where one component is a dirac delta distribution with a probability mass entirely on zero and whatever the other distribution is. The zero-inflation is explicitly modeled because sometimes your data will have zeroes that do not come from the primary thing being modeled. Although zero-inflated distributions are explicitly implemented already, one could manually implement one like this:"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "eaac089c",
"metadata": {},
"outputs": [],
"source": [
"p = numpy.array([30, 1, 3, 7, 8, 7, 4, 3, 2, 1, 2, 1, 1, 1])\n",
"X = numpy.random.choice(len(p), size=(500, 1), p=p/p.sum())"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "c9bed3e0",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([3.3220])"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d = Poisson().fit(X)\n",
"d.lambdas"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "79560b18",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 1369.84814453125, Time: 0.0006914s\n",
"[2] Improvement: 89.228271484375, Time: 0.0006466s\n",
"[3] Improvement: 0.164306640625, Time: 0.000586s\n",
"[4] Improvement: 0.0001220703125, Time: 0.0006366s\n"
]
},
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([5])"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model = GeneralMixtureModel([DiracDelta([1]), Poisson([1])], verbose=True).fit(X)\n",
"model.distributions[1].lambdas"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "12bbc00a",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x = numpy.arange(0, len(p)+0.1, 0.1)\n",
"y1 = d.probability(x.reshape(-1, 1))\n",
"y2 = model.distributions[1].probability(x.reshape(-1, 1))\n",
"\n",
"\n",
"plt.figure(figsize=(6, 3))\n",
"plt.hist(X[:,0], density=True, bins=numpy.arange(0, len(p), 1))\n",
"plt.plot(x, y1, label=\"Poisson\")\n",
"plt.plot(x, y2, label=\"Poisson in Mixture\")\n",
"plt.legend(loc=(1.05, 0.4))\n",
"plt.tight_layout()"
]
},
{
"cell_type": "markdown",
"id": "56cffd0c",
"metadata": {},
"source": [
"Alternatively, we can use the ZeroInflated wrapper to do this."
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "77784dff",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"d0 = Poisson()\n",
"d = ZeroInflated(d0).fit(X)\n",
"\n",
"y3 = d0.probability(x.reshape(-1, 1))\n",
"\n",
"plt.figure(figsize=(6, 3))\n",
"plt.hist(X[:,0], density=True, bins=numpy.arange(0, len(p), 1))\n",
"plt.plot(x, y1, label=\"Poisson\")\n",
"plt.plot(x, y2, label=\"Poisson in Mixture\")\n",
"plt.plot(x, y3, label=\"Poisson in ZIP\")\n",
"plt.legend(loc=(1.05, 0.4))\n",
"plt.tight_layout()"
]
},
{
"cell_type": "markdown",
"id": "a85dfcfe",
"metadata": {},
"source": [
"The ZeroInflated wrappers extends to multivariate distributions in a way that the mixture model implementation doesn't. Simply, using a DiracDelta by itself will give a zero probability to all examples that have one or more non-zero values. Because we want each feature to be scored independently, in that all zeroes in the matrix have some probability of belonging to the DiracDelta component, we need to modify the internals slightly. Here is the result of using that."
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "f4e3a7d2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([3.3160, 3.1280, 3.1860]),\n",
" Parameter containing:\n",
" tensor([3.6519, 3.4448, 3.5087]),\n",
" Parameter containing:\n",
" tensor([5.7558, 5.3920, 5.3447]))"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"p = numpy.array([30, 1, 3, 7, 8, 7, 4, 3, 2, 1, 2, 1, 1, 1])\n",
"X = numpy.random.choice(len(p), size=(500, 3), p=p/p.sum())\n",
"\n",
"d = Poisson().fit(X)\n",
"\n",
"model = GeneralMixtureModel([DiracDelta([1, 1, 1]), Poisson([1.0, 1.0, 1.0])]).fit(X)\n",
"model.distributions[1].lambdas\n",
"\n",
"ZIP = ZeroInflated(Poisson()).fit(X)\n",
"\n",
"d.lambdas, model.distributions[1].lambdas, ZIP.distribution.lambdas"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/docs/tutorials/B_Model_Tutorial_3_Bayes_Classifier.ipynb 0000664 0000000 0000000 00000253056 14643672530 0031264 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"id": "1dd79907",
"metadata": {},
"source": [
"## Bayes Classifier\n",
"\n",
"author: Jacob Schreiber \n",
"contact: jmschreiber91@gmail.com\n",
"\n",
"Although most of the models implemented in pomegranate are unsupervised, a simple way to construct a classifier using probabilistic models is to use Bayes' rule. Specifically, given a set of probabilistic models M, one can make classifications on some data D by calculating the posterior probability of the data under each of these models.\n",
"\n",
"\\begin{equation}\n",
" P(M|D) = \\frac{P(D|M)P(M)}{P(D)}\n",
"\\end{equation}\n",
"\n",
"Specifically, what this equation is saying is that one should calculate the likelihood of the data under each component, $P(D|M)$, multiply it by the prior probability of data coming from that component regardless of what the data actually is $P(M)$, and then divide by some factor. \n",
"\n",
"More concretely: if you have a set of probability distributions and want to classify points as having come from one of them, you just calculate the likelihood of the data given the distribution and then multiply through by the prior for each distribution, which can just be a uniform distribution."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "398080bf",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n",
"numpy : 1.23.4\n",
"scipy : 1.9.3\n",
"torch : 1.13.0\n",
"pomegranate: 1.0.0\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-208-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"%pylab inline\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"\n",
"import torch\n",
"\n",
"from pomegranate.bayes_classifier import BayesClassifier\n",
"from pomegranate.distributions import *\n",
"\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p numpy,scipy,torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "cb496012",
"metadata": {},
"source": [
"### Naive Bayes\n",
"\n",
"The simplest form of a Bayes classifier is the naive Bayes classifier. The reason it is \"naive\" is that the classifier assumes that the features are all independent from each other. This assumption makes the classifier fast and interpretable."
]
},
{
"cell_type": "markdown",
"id": "9ef85791",
"metadata": {},
"source": [
"#### Initialization and Fitting\n",
"\n",
"Bayes classifiers can be initialized or fit in the same way that mixtures can. Specifically, you can either pass in learned distributions, or uninitialized distributions that are then fit."
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "6a97eb9e",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"numpy.random.seed(0)\n",
"\n",
"X = numpy.concatenate([numpy.random.normal((7, 2), 1, size=(100, 2)),\n",
" numpy.random.normal((2, 3), 1, size=(150, 2)),\n",
" numpy.random.normal((7, 7), 1, size=(100, 2))])\n",
"\n",
"y = numpy.concatenate([numpy.zeros(100), numpy.zeros(150)+1, numpy.zeros(100)+2])\n",
"\n",
"plt.figure(figsize=(6, 5))\n",
"plt.scatter(X[:,0], X[:,1])\n",
"plt.axis(False)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "7659596c",
"metadata": {},
"source": [
"A Gaussian naive Bayes model can be initialized like the following:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "dbebf231",
"metadata": {},
"outputs": [],
"source": [
"d1 = Normal([1.1, 1.3], [0.3, 0.9], covariance_type='diag')\n",
"d2 = Normal([1.3, 1.8], [1.1, 1.5], covariance_type='diag')\n",
"d3 = Normal([2.1, 2.3], [0.5, 1.8], covariance_type='diag')\n",
"\n",
"model = BayesClassifier([d1, d2, d3])"
]
},
{
"cell_type": "markdown",
"id": "920657cc",
"metadata": {},
"source": [
"And we can make predictions for the above points just like other methods:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "c2142598",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"y_hat = model.predict(X)\n",
"\n",
"for i in range(3):\n",
" plt.scatter(*X[y_hat == i].T)\n",
"\n",
"plt.axis(False) \n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "4d733034",
"metadata": {},
"source": [
"Wow, looks pretty bad. Let's try fitting to the data."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "20538f6b",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABPSElEQVR4nO2de5gU1Zn/vz0jAzOEGQaUmZEoohuj43jZyQ8B7+TBDCJBN6C7Gi8JWbMx7iZKVkF3/Zl93DWQ+FOTjSYbI4nB1cSFbEQgEHkCUVcQEoILGU12EdEoAzpcZbiY7v79UVMz3T1Vdc6pOlV1qur7eZ48ZGaqT5/qbvt9z3v5vrlisVgEIYQQQjJLVdwbIIQQQki80BkghBBCMg6dAUIIISTj0BkghBBCMg6dAUIIISTj0BkghBBCMg6dAUIIISTj0BkghBBCMg6dAUIIISTj0BkghBBCMg6dAUIIISTj0BkghBBCMg6dAUIIISTj0BkghBBCMg6dAUIIISTj0BkghBBCMg6dAUIIISTj0BkghBBCMg6dAUIIISTj0BkghBBCMs4xcW+AEEKIPvKFPDbu2oh3e97FcXXHoX1UO6qrquPeFjEcOgOEEJISVm1fhXnr52Fnz86+3zXVNWHuuXMxeczkGHdGTCdXLBaLcW+CEEJIMFZtX4XZa2ajiPKv9BxyAIAHLnmADgFxhc4AIYQknHwhj47FHWURgVJyyKGprgkrZqxgyoA4wgJCQghJOBt3bXR1BACgiCK6erqwcdfGCHdFkgSdAUIISTjv9ryr9TqSPegMEEJIwjmu7jit15HsQWeAEEISTvuodjTVNfUVC1aSQw7Ndc1oH9Ue8c5IUqAzQAghCae6qhpzz50LAAMcAvvnOefOYfEgcYXOACGEpIDJYybjgUsewKi6UWW/b6prYlshEcLWQkIISRFUICR+oDNACCGEZBymCQghhJCMQ2eAEEIIyTh0BgghhJCMQ2eAEEIIyTh0BgghhJCMQ2eAEEIIyTh0BgghhJCMQ2eAEEIIyTh0BgghhJCMQ2eAEEIIyTh0BgghhJCMc0zcGyCEEBI/HHCUbegMEEJIxlm1fRXmrZ+HnT07+37XVNeEuefO5ejjjMCphYQQkkHsSMDqN1dj4asLB/w9hxwA4IFLHqBDkAHoDBBCSMZwigQ4kUMOTXVNWDFjBVMGKYcFhIQQkiFWbV+F2WtmCx0BACiiiK6eLmzctTGCnZE4oTNACCEZIV/IY976eShCLSD8bs+7Ie2ImAILCAkhJAJMqNbfuGujVESgkuPqjgthN8Qk6AwQQkjI6KrWD+pQqJ7w7ZqB9lHtSo8jyYPOACGEhIido68Mze/q2YXZa2ZLV+vrcChUTvh2N8Gcc+eweDADsJuAEEJCIl/Io2Nxh2toXrZa382hUG3/s/ezq2eXsG6gua4Zc86dw7bCjMACQkIICQlRjl6mWt+r6M/+3fz185Ev5IX7qa6qxtxz5wLodyRs7J+vP/16LOhYgBUzVtARyBB0BgghJCRkc/Re1+lwKEqZPGYyHrjkAYyqG1X2+6a6Jjx4yYO449w7MK55XGSpgXwhjw1dG7D89eXY0LVByqkh+mHNACGEhIRsjt7rOh0ORSWTx0zGpBMmxdrdkC/k8ejmR/FE5xPYd3Rf3+8pgxwPdAYIISQk2ke1o6muyTVHL1OtL+tQdB/uxvLXl0sb9uqqaoxrHie1tg5KOyHe3P8mFnYuxP4P9g+4TrWwkuiBBYSEEBIidvEfgDKHQLb4T6borypXhUKx0PezaadrWfljG8ogRw9rBgghmSesvHW+kEfD4AZcd/p1GD54eNnfmuqapE6/XkV/NqWOANB/ul61fZX/zWtCRf7YhjLI0cPIACEk04Q1vtdp3cbBjZh28jRMOnGSco7eab3KiEApJpyuRa2VIuZfOB9TT56qeVfECdYMEEIyiy5BINl19x7ZiydefQLtTerFepVFf92Hu/H1DV93vb70dB1lbUApfuWPbSiDHB1MExBCMonO/v0o1gX6i/6mnjwVI4eMlHpMnEOGgjx3c10zZZAjhM4AISST6O7fD3vdSnS0LYaN3+fOIUcZ5IihM0AIySRh9O+HuW4ldtuiW1FhDrnYT9eiPToxfPBwthXGAJ0BQkgmCetkraILEKRrobTLoBJThgzJdELYNNQ04Jazb8Gaq9fQEYgBdhMQQjKJqH/fbzW+yjCgIN0FgFWo+NWXvlqm4AdYp+t7Jt5jjFF169iYeepMnDjsxFgUEEk5dAYIIZklqCCQ6rpeqLYzunUs2Fx/+vWeTkapImAUxjjq5yNq0BkghGQap1OrjvG9flT3ADkHRKV/38nJCKKtQKOeTugMEEIyj6yBUzWE+UIeT772pKceQCmyqYkNXRswa+Us6TWBfifDLaIg44yEJdBE4oeiQ4SQzCMztMePIayuqpbWAwDkhYJUOhGKKCKHHOavn4+LRl/kqYFgXzfphEkDnJGwBJqIGbCbgBBCBLjp68vMAPDTay8y9qpr2k7GT/7wEykNhCdfe7JsTkOYQkrEDBgZIIQQD0SG0Os0DYjHGDshMvZ+1gSAt/a/JXVdaVrDrvqXFVKKS/qYBIORAUII8SCooqCXHkAlskJBKv37pZxQf4L0tTa7enbh4U0PS1373BvPaZ36SKKDzgAhRJqwRv2ajA5FwcljJuOBSx5AU12T6zWqQkH2mqPqRgmvtZ2Mvzz1L5UVAVUiD0/9/inMWjkLHYs7sGr7qkx+XpIKuwkIIVJktZJctnJ/QccCYYjc7kZY/eZqLH19KfYc2dP3N7/tjKVrLnx1IXLIeWom+NFAUMXeQ8PgBuw70i+IlIXPS1KhM0AIERKkHS3phKlUqLtfX1YzQVUDoZRKZ0P1sUC6Py9Jhc4AIcQTkcCNX2NoGl7GOSylwjDwo5nQfbhbSgvhlrNvwaL/WeTLibBJy+clbdAZIIR4ojNMbioyKZCwlArDRMUxkI1+AFZR5XNvPIenfv+U770l+fOSRthaSAjxJKqRvHEhK6YzecxkTDphUmKkeFVqPOzuhNlrZrvWHJQWNtpGPIgzkNTPS1phNwEhxJOwRv2agKqYjq1UOPXkqRjXPM5oR0BVJMmtO6GprskxDWJrHah0JpSSxM9LmmGagBDiSVgFdCaQxhRI0BoPlcJGP50JSf68pBlGBgghnngJ3Kj2xptGGlMgOkSSZKMfbtGE4TXDAaTv85JmWDNACBFif+k75aBNLqATkcYUiA4HRyU64FZLsfqt1an7vKQZOgOEECmSVkAng0jj3w5pi+SBTSKog+N3OmNlGiWNn5c0w5oBQkimSZKGgAxBajyyLC6VdVgzQAjJNKpV9KbjNRjJK2fPMcXZhmkCQkjmSWNIu76mHvuO7iv7XcPgBtwz8R5HB0el8DApnRVEHjoDhBAC57x3EnEL9QPA3iN7XR+3+s3VUusnqbOCyENngBBCEoRXpb9XqB+w0gTz18/HpBMmlT1mQ9cG/PR/fir1/HbhYRiDlkh80BkghAQmTsOQBqMkew9Olf6jakfhqlOvwon1J6L7cLdSqF91emHj4Ea0j2rP7DjrNMNuAkJIIFQMg27DnQajJHsPXuF/VeZfOB811TW4bc1tSo+7/vTr0d7UbnzHQRocxKihM0AI8Y1KK5puw52GNjjZexBJDKvy/U98H19Z85UBBYYiHr30Ufzjf/2j0eOs0+AgxgFbCwkhvlBpRfMzOEfXc5uKyj2IKv1lySGH5rpm/KbrN8qOABBc6jhsdH/OsgSdAUKIL2QNw693/lq74TbdKMmgcg86KvjtaMPt427Hk6896WsN2cfF0XGQBgcxTugMEEJ8IfuFv37Heu2GOw0DhlTuQcdsBFtEqXFIo6+oAADsOyL3uDhmOaTBQYwTdhMQQnwh/YUvOe5exXDHNWAoX8jj1zt/jfU71gM5YFzTOOFkv6B7swvgvGYouHHHuDswcsjIsiK6pVuXKu+1lPqaehw4esC4WQ5pcBDjhJEBQogvbANVOabWxs5Pj2uSE/JRMdyyz63TKK3avgoX/+Ri/PUv/hrf2/w9fO+/v4ebnrsJFz99sa9ctMo9eI2R9nrstaddO2AU8Z4je5T3Wsr1p1/vuI+4xxOncQJllNAZIIT4wstAlRqGcc3jtBtu2efWZZRWbV+F29bc5hhe33dkH25bc1uZQ2AL+Sx/fTnWvbMOL+94GctfX44NXRv6ctaq9+A2Q6ES0f03Dm6Uve0B6zbXNeOms24ycpZDHA5immBrISEkEE6tXM11zWVz68OaDCjz3EHJF/L4xKJPYNehXZ7XNdU1YeWMlVj91mpPIZ/KNjfVeyjtoX/zwJtY9IdFSve/oWsDZq2cJbzvUpzeJxN7+dM2gTJK6AwQQgIjYxjCMtxhGyUV43nL2bfgkVce8czr6zasqo+V0SyoylWhUCz0/azbwQqTKBzENEJngBASGSaeJkUsf3055rwwR+ra+pp67D+6X3hd3OI8v3jjF/jKr77i+Lcccrj/4vvROKSx7H0CkJj3Lomfs7hhNwEhJDKSOBlQpeBMxhEA4h0HvGr7Knx9w9cd/+Z2gjZJ1U/G0CfxcxY3dAYIIcSD9lHtGFU7Slgz0FDToNy/H3Wbm2i+we3jbnd0BJweY6v6RZmHN8kpSRvsJiCESFNaJV9aGZ9mqquqcef4O4XXXdd6nfLaUba5yYw3/saGb5S9pyap+lFqOFzoDBBCpFi1fRU6Fndg1spZmPPCHMxaOQsdizsy8SU8ecxkPHjJg2ioaRjwt+GDh+PBSx7ETWfe5NnaVkpYbW5ezpofhT5TVP1MckrSCtMEhBAhJoWK42LymMmYdMIkTwXCuefOxew1s5FDzvMEDugX5xGF0P0o9O08KDccKex0h4pTEnWtQFqKFekMEEI8EZ3Kcshh/vr5mHTCpER+CapQXVWN8S3jMb5lvOPfbWEgkc6A7jY3GWdNVaHPq9DQ7TE6cDKupkoNp6mGgc4AIcQTk09lJmJHEGyDNmLICORyOXQf6tZycqw0lmcfe7aUs7bsL5Z5zjconSsgKjR0eowO3IzrzFNnSj0+yhqMtEXL6AwQQjwx9VRmMnZrm+4QspOxbBzc6DlvwHbWXnnvFdc0RmnqAoBnoaHTY3REhLyM6yObHkFDTQP2H91vxICkNEbL6AwQQjzhABh/6A4huxlL2cFD7/a8i6knT3VMY5SmLjZ0bfCMBNk0DmnE3RPu1nL6lTGuuVyu7/+7OTJRGd40RsvoDBBCPBGNz41zbG0cyEov6wwhi9oCZbCdtco0RuU9yEZ4bv8/AzUJ/CJjXPce2Ytbzr4Fi/5nkasjExVpjJbRGSCEeGJP1xOFl5MSDg2CzGlfNYQs41w8+t+PSp3WnXBy1rwU+mQjPE1Dm3ztxwlZo3li/YlYOWNl7NX7aYyW0RkghAhxq5KP41QWF7KnfZUQ8r4j+4TOxartq/DwKw/72rMfZy2OSJCs0RwxZIQRUsNpjJZRdIgQIsXkMZOxcsZKLOhYgPkXzseCjgVYMWNFJhwBFdEb2VPu6jdXCxX17OeVpXFwY9nPTXVNyikJOxIE9DsTNmFEgvKFPArFgqOgUyX/8OI/GCFyFfVrFAWcWkgIySyy1f6yY4wXdCwAAKlrvboA7JPlP1/wz/jrX/y1cC3AGjK07C+W4ZX3XtESQo9iFLDTc3jhNP45TtI0LplpAkJIJlGp9lcpGOs4qUMYQm4c0ojdh3e7rmOnEtbvWC95N9ZJtOaYGm0hdFGhYVBktQxKMa1tL+zXKEqYJiCEZA7VoTcqBWMyIeTLx14ut1HxmAMAwJSTpoRyErXz81NPnor2Ue3YuGvjgLkHfoZXBemOiGoegiylr1GpNHXSYGSAEJIp/AjGqBaMiQouGwY3YOGrC4V7Hdc0Dj+r/ZlwfPJvd/0W+UJeaIj8iiC5RVGmjp2K5duWl/1+VO0oXHXqVTix/kTX5xAVWcqQpLa9JEBngBCSKfwIxvhpr/QKIecLeSnnYlzzOFx16lXCboKdPTuFAjd+RZDcwvk7e3biB7/7wYDrdx3aVbZfp+fQYciT1LaXBJgmIIRkCr+CMfZpf1TdqLLfe1Xsu4WQRamEIoq4dMyl2LhrIz487MOB70s1LWKjQ+zI6TmCGPKwxj9nHUYGCCGZIohgjK6CsXwhj4bBDbju9Ouw9PWlZV0FuVwOxWIRC19diIWvLhzQLqiyX/u5/Oro6wjnOz2HKO3iRlLb9pIAIwOEkExhG6LKE7mN6OQZtGBs1fZV6FjcgVkrZ2Hhqwux58geNA5uxMUfvhgAUCgWyq4XzR4Q7VclLVKJrrx85XOIIiM55PDZMz6LprpylUM/uglEDkYGCCGZIk55Zbf8+94je/GrP/5K+Hg/+w2io687L1/6HDKqll9u/3Iq2vaSAJ0BQkjmiENeWUbFUMTwwcPLIgUy+w2SFvEbzpd9DlHaxQTp4axAZ4AQkkrc2ujs3x/NH8W/XPAvKBaL2H14d+gnTx359zvG3YGmoU1KJ+UgOvpeURQVRM9Bgx8/dAYIIalDpS/ebn0L2yDpyL//8cAfMe2UaUqPCZoWcYuiNNc147Kxlw14PSth0V8y4GwCQkiqUJW5jUrvXna+gYgHL3nQ1z6D6uiLIi3v9ryLNw+8iUV/WBSKVr9fwSQiB50BQkgshPHlni/k0bG4Qzkcb4exV8xYEZqBsfcWJP8edJ9RGNQwnsOvYBKRh84AISRywvpyD3r6XtCxINR0gR21AOSLBp0Ie58m4RbpMW2CYdKhzgAhJFL8quHJEDQvH7bevZuKoSpZ0eWX6cCYv36+1HAk4g2dAUJIZIT95R60Lz4KvfvJYyZj5YyVuGPcHb7XyIoufxDBJKIGnQFCSGSE/eUuUhd0I2q9++qqaowcMlL5cVnT5Q8imETUoDNACImMsL/cvWRu3Yir9c3P6b6IYqZa9IIIJhE16AwQQiIjii931bz8qNpRsRSh+Y1iZImgcySIPHQGCCGREdWX++Qxk/EvF/yL1LX/fME/x1KN7jeKkaWCOdFAI4BiRrqgM0AIiYzSL3c33L7c84U8NnRtwPLXl2ND1wahQew+1C21p92Hd0tdFwaqUQy7puKRTY9IvQYyqL6uUeP2GnGCoV6oM0AIiZwHfv0AHu98vGxcb1WuCje23ojZ/2f2gOv96BLIag6Y0LNvC/U898ZzeOr3T0k/Lqg2Q5LEfKhAGC50BgghkaIqIuNXdEak+BeF6qAqqqJJQYR3KOZDSmGagBASGao6A0F0CZKYb24f1Y6GwQ3S1/vVZjBZzMf0tEVaoTNACIkMVZ2BoLoEScs3r35rNfYd2af0GD/aDKaK+azavgodizswa+UszHlhDmatnIWOxR2BVCmJHBxhTAiJDFWdAR26BJPHTMakEyYZn2+2T+t+UdFmMFHMxy1tYctUm+i8pQk6A4SQyFDVGdClS1BdVR17kaAI0WldhIo2g2liPqK0hd1SOemEScY5cWmBaQJCSGSo6gxkSXQmyCl8eM1wpdfAtNfV1LRFlqAzQAiJDNWivqQUAeooegtyCt97dC9Wv7Va+nrTXlcT0xZZg84AISRSVIv6TC8C1FX0FkSe2I8yoUmvq2lpiyxCnQFCSCyoisiYKDqju1ffXg+AY/5chB8BJRNe1yRqQqQNOgOEEOID24C55br9GjAnVcCGmgbsOypuOZx/4XxMPXmq9HOZ4AjYuDlCFEGKBnYTEEKID1SK3lRP65VnNNnUgUoY3TQpYjtt4bSnOefOoSMQMnQGCCFEgdI5AjKoFL25pR1EUQE7CiFb/W9qT39SNCHSCJ0BQoixmBTGBpxP0yJkT+syEsFOqFb/m97TnwRNiDRCZ4AQYiSmhbHdTtNuqJ7WZUWHGgc3Ys+RPX0/22H0SSdMwoauDULHKcz0BkkudAYIIcZhWhjb6zTthJ9efdl0wh3j7kDT0KYyo7/6rdUDihndHCf29BMnqDNACDEKEyfqqUoF++nVl00nNA1twrjmcZh68lSMax6H1W+txuw1swfsz3acKvUO2NNPnKAzQAgxChOlaWVPydd89Bos6FiAFTNWKEcu/EgE+3GcTJMiJmZAZ4AQYhQmhrFlT8mXnnQpxjWP81V450ci2I/jZJoUMTEDOgOEEKMwMYwd1WlaVSLYr+NkkhQxMQMWEBJCjMI2vCJp2ijD2PZpevaa2cgh56iQp+s0rdJrH8RxSkNPv2mtp0mGcsSEEOMwVZrWqd2xua45NoW8LGv6m9Z6mnToDBBCjMTN8N4+7nY0DmmM7TRo2mnUVMcpTHQPiCJ0BrJNIQ9sfwl4fyfwoSZgzHlAyk4PJNlUGt49h/fg6xu+ztNgBaZFLMIkrAFRWYfOQFbpXAKsmAPsf6f/d/XHA1PmA63T49sXIS7wNOiNaRGLsNjQtQGzVs4SXudnnLMOkvo+sIAwi3QuAZ6+AajMMe7fYf3+6h/RISBGYbqevglkRdPfxNZTmyTXMbC1MGsU8lZEwFFWtfd3K+Za1xFiCCYKEZlCvpDHhq4NWP76cmzo2hCpMmMcmNh6CvRHrmSVIE2DkYGssf2l8tTAAIrA/ret68ZeGNm2CPHC5NNgnCT5JOoXE1tP0xC5YmQga7wvqa8uc10hD2x7Adi8yPo35ScSEh+mngbjJOknUb+YqKCYhsgVnYGs8aEmPdd1LgEeagMenwYs/pz170Nt1u8J0Qz19MsxcZhTlJimoJiGyBXTBFljzHlW18D+HXCuG8hZfx9znvsaLEAkESOjAHj7uNsTWcXtB5WTqFtRYVKr3m1MUlBMQ+SKzkDWqKq22gefvgFADuUGvffUNWWeu96AsAAxZxUgnnY5NQuIVuzToFOO/LKxl2VKfyDoSTQttQamdFCYWMegCnUGsoqjzsBoyxHwOtVve8FKCYi4cSkLEEkoOAkR/f2v/j5T+gNBeu396jUkPZIQNklXgqQzkGX8KBBuXmTVCIiY8Rhw5kw9+yTEhaSq0QU1rH5nEvh9vdISSQibJCtBMk2QZaqq1U/vugoQCdGAjtx51OgwrH6nKPp5vdwiCXbXgukn3igxqY5BlWx1E7AVLjh2AaJLVbdVgDjauwCREE0krYpbZzugn4p61dcr610LfrDrGKaePBXjmsclwhEAshQZoBa/HoIWIBKiEZUq7rhz3mEI06ieRFWr3pMYeSH+yIYzwFY4vbROt14zR+dKUIAoA6cpEklkq7j3HN4zIFcedc47LMOqUlGvWvWetMgL8U/6nQG2woVD63TrNdNttBnBIQrI5M4vG3uZY7dB1DlvEwyraq1BGvrniRzprxlQ0eInatgFiGfOtP7V4Qg8fcPA98uO4FDdkDjglTu//+L7sXzbciNy3qYYVpVaAyo/Zof0RwZ0avGT8GAEhwTALXduUs7bJGEa2VoDv10LJHmkPzLAVrhkwAgOCYhTFbcJoXkb0wbsyFa9mzYHgIRD+iMDOrT4SfgwgkNCwJTQvI2XpLLJwjRJ7p8ncqTfGWArXDJgBIeEgEmheZukGlZT5gCQcEh/mgDob4Wrbyn/ff3xbCs0BYoZkRAwLTRfuq8kCtOQ9JKt2QTsXzebPj0IwDGCQ8eN+CTJmvGEREG2nAFiPn6nKRIiIG4FQkJMhs4AMY80RnDSeE+EkNRAZ4CQsKGqIiHEcOgMREnUp0OeRuPHbS4G6yCIYTCNkm3oDERF1KdDnkbjp5AHHmrzEFPq1bi4dTOdNBIrTgWWUQ9yIvGSjdbCuIlac58a/2ZAVUWSAFZtX4XZa2YPkG22Bzmt2r4qpp2RKKEzEDZCzX1Ymvu6BqVE/XzEHaoqEsPJF/KYt36eEYOcSLzQGQibqE+HPI2aA1UVieGoDHIi6YbOQNhEfTrkadQcqKpIDMekQU4kXugMhE3Up0OeRs3BnosBYKBDwLkYJH5MG+RE4oPOQNhEfToccx5QO8L7mtoRPI1GBediEIOxBzlVzm2wySGH5rrmSAc5kXhI/9TCuIllaiK7RY2idTpw2uXUfCDGYQ9ymr1mNnLIlRUSxjnICQDyhSLWb9uNXQcOY9SwITh37AhUV7kdqkhQqDMQFVFp7m97AXh8mvi6G5cCYy/U97yEkMRi2iCnFVt24J+e7cSOfYf7ftfSMAT3fLIVU9paPB5J/EJnIEqiUATcvAhY/DnxdTMeA86cqfe5CSGJxRQFwhVbduDmJza6aXbiO9e10yEIAaYJoqSqOvzTOAsICSE+qK6qxrjmcbHuIV8o4p+e7XRVSckB+KdnO3FpazNTBpphAWHaYDsbISShrN+2uyw1UEkRwI59h7F+2+7oNpUR6AykDbazWemYbS9YKZNtL/hXW9S1DiFEil0H3B0BP9cReZgmSCN2O5vjoCLNBYumoWtAEwc9ERI5o4YN0XodkYcFhGkmayOMdY0L5thhQiLFbiPs2ncI9y57FXsOHnWsG8gBaG4YghfnfJw1A5qhM2AyWTPmQdA1LphjhwmJFKc2QifYTRAuTBOYCsPUaqgMaPLq6NC1DiFEiFsboRPN1BkIFToDJuIWpt6/w/o9w9QD0TWgiYOeiGaopOeMVxuhzYihg3D3tDPQXM/XLWzoDJhGIW9FBLw6bVfMteRtTQhTm5LKkNVNqDvW6gxw2y91GohGqKTnjqiNEAB2H/wAzfVDMPGUkRHtKrvQGTCNJIWpTUpl2PoK+3fA2ZHKAbWNwDM3e+9XZp3646nTQIS4hcC79h3GzU9szHzum22EZkGdAdNISpjaTmVUOi7737F+37kk2v0I9RWKwKHdDvvdUb5fz3VgrdN+o7Ztk3QiUtIDLCW9fCG79dtsIzQLOgOmkYQwtWcqA9bvV8yNXqTHbVzwh5qBmmEuD+q9h9L9uq1js+Y+q+MgaoeHJAYq6Yk5d+wItDQM8dJKRUuDVStAwofOgGkkQU5YmMpAfyojalqnA7dusaYyzngMuOQuoHAUOHrA40HFgfu117nkLueHVEYUCCmBIXAx1VU53PPJVgCuWqm455OtLBqMCDoDppEEOeEDO/Repxt7IFR1DbDma0BPt9zjnFIvG3/ocrFDREEHlEBOBQyByzGlrQXfua4dzQ3lr0Nzw5DM11REDQsITUSHnHCYVf4H35W7busa4Kyr9TynKsJUhgOVqZeoizlNKsg0jLDb83Svb4fAu/Yd9lTScwqBZ60VcUpbCy5tbc7UPZsInQFTaZ1utQ/6MehhG5Whx8ld9/tlllGOI4ohk8row6VDIMpiTmpLuBJ2e14Y69sh8Juf2GiXr/ZRGgIHgLVbu/uM4J6DR3Hvsuy1IlZX5dg+GDOUI04bUejqb3sBeHya3LU3Lo2nBXLzImDx5yQvzjm/LrL3GfQeKYHsilt7ni5p2qDri07xXo4GAMrwRkDWIi1+YWQgTUQlWHTCeKDmQ8DR98XXxtUCqSJCNO1BZwcpKs2BJGlLRIioPS8Hy5he2trs68s96PoyEQW3EPhznV3SMrw67jWrUPRJHhYQpgkVo+KXziXAt86WcwSA+FoghV0ZsByB2a+6R0p0FHPKFAQmRVsiYsJuzwuyvh1RqHy8LSi0Ykt/8awdAr/inNF9oXCRDK/KXogzKu8RoTMQDroqwlXXCduouAkNORJzC6TQkOesiMAxNd7ruGkO1B8vTrl0LrHC/49Ps1IWj09z1idIgrZEDITdnud3/aCCQjIyvLJ7Ic5Q9Ekdpgl047d4r7L6v6cbWHmn2jphGhWl6nxDWiB1dGXY66gWc6oUBFIC2ZGw2/P8rq8SUXAqigti0FXuNcu58qDvURahM6ATvxXhTg6EE6J1wjQqKtX5qsY2TIJ0ZZRiaxfIoFq7YUcxnr4BcKs9j9uxioEg7Xlhrh80YuHHeVG916znyin6pA7TBLoQGgA4C9Qohd4FQjdhChbJphYuvN2qejfBEbCxDfmZM61/wzaqfmo3gqQjUkrYCnV+1w8asRDJ8DpRdNlLKflCEWu3duPeZ3+HL2Q8V07RJ3XoDOjCjwHwI4wjKgIMy6jIphZOvjj+E2zcKn5+azdapwNfegXouA849/PWv1/alElHwCZshTo/6wfV1C91QmSZdf5Jnve6YssOXDD/l7jm0XV47L/ecLwmS7lyzj1Qh2kCXfgxAErCOArPpys0XkqceW0VNUUTVPz81m447X3ttzOvQBi2Qp3q+rKCQl77s52Qu/5zC3YfPCrc46Wtza5/c9NKcCIruXId71HWoDOgCz8GIEirmOj5VHLcMsSV11Yx7rpV/PxKOvtxnKhA6EnYCnWq69vGvDIv36yQl5/S1oKPn9aECV9bhd0HP3C8RlQr4FU170UWcuU63qMsEa8CYZj6+VFQuv+6Y4FnbhYbgFIVORUlP691gqD6Hjga59F6CgYr93KwG1j0GUipKepW8QsaYegz7oCj4xTm3klk6KjYt0/2gPMJ1isdsnZrN655dJ3yvp+6aUKqIwOlZLmrQoX4nAETwrlBcNp/bSNwaA9cT86Vp7s+I+DmQFSiUVIY0NcGKePEiR7jtJdcFVAsuCxYYSD9Sgc77eu1ZXoknWUdp6hkj4mx+K3+f2bT2/jyjzdJP48daXhxzsdpEEkZ8aQJkh4Sddv/ob3Wv7WNwKESpTC3VjvP0LsDOlv2grwHqikIkdPhthdXRwAYINHrp2bDbV8fHBq4F/s5VSSdS2s3Duywpj0OPc76fJQOcKICYarwcxL1WxehUg3PXDnxInpnICr9/LCQ2f8xQ4Abllhf/qKTs6swzmjgE/cBQ0fqT6NE+R6InI6rfmiJKylnPXuxDaRqzYbrvkQFnYpzAqqqrWjRqnvcnSEqEKaGIP39fuoiRFoJpTBXTryI3hlI+lAWmf0feMcKcZ85U27NMKr/vYjqPSjkgZ/fAU+nY9lXgJ73/D+HbSBVivZ8tXRWIHtKl4nAnHY5FQhTgFtVv93fH8bUQVHVfBFWW+Klrc3MlRNPotcZSHpINKz9RymME9V78Pz9VnjclWIAR6Bi9oGK4FKQlk6b7q3ia2SFqIDwxKJIJMSphe+llfDd69rxfz95BiaeMjLzjoAtyvTMprexdmu37/dC1zqmEX1kIEkhUafisiTt340o7qFzCbDmPv+P98TFQMrOItDhaK75GjDqdO/6DZUIjK45CiQW4tbCV6k5yGJ1vS555jTLPEfvDCRlKItbcVnH15Kxfy/63gPB6fhgt7/1+07EktSNBHp2wzVsX9lV4GUgZVIuuhw1UV2FagQm6nQR0YYJWvgyNQdpNmZu6ErfxJEGipLo0wRh6ufrwm1ewP53gP+4EThhAvpy3mUYsn8Rry3rrZgXsPwrwJ/E6mgDeONFhaFGo4GpD/T+4DJqeOYPrLa6GY9Z/4pmH4hSLrYz5CVWWjNMsHGBLDTgLwIjmy6KW3KZlJEELXzbmGVpZoGu9E0WRiLHM5vA5KEsMsVlv/up1R5WO7z89ybsX4Tt6BzaI7625z3ggdOtx6is/x83iK+zmTIPaLvS+/NwxpXuBlJkFJ3+LuOQtl8vt3+v07+M01Fa9yBL5xJLn+LxacDiz1n/PtSm9j4RrZiuhZ8FY+aESvominVMJj45YlNDorLFZba40CV3ASNPCX//OtQa/VTR97wnr/3gVjnvxiV39a/p5/Mgo1/g9ferfggsmw30dFf8fZ7l7K17RHwPXqf/MCSck67RkVJM18KXNWbrtnajqiqXmnoCXekbv+skqT4j3tkEuvXzdaBaXLbx8fBlYnWpNQapohflx1UdjfrRwEV/X/47lc+DyCie93fAS//q/fffLhwYITnaY/2rq7ZFZ2Fg0jU6Uo7JWviyxuyWJzdi76H+OQlJryfQlb7xs07S6jPinU1gIlvXAAuvUHtMmDKxrqdtH9LEmxdZYWW/eN2n0pyFnL8TrB0dObDDMno9HgWOnlLGEly90PpXdr6ACB2RHcoWJwITT4N+ZxjIzEcwmXyhiAvm/9JVlElWnll1HbdiQ5Nfz3hqBnQRRhFVzsd/tGFpIsj2qcvet0xvvBde9yn7GtSOsMLztY1q71tpnvynN3k7AkAwRwDoP2Hrqm3RoSORdI2OjGBX9V9xzmhj+vtFNQ1uJL2ewE7fAK7VQVLpG5V1klqfkdwRxmENOjr4rvpjwtIU0KkU2LnE6o0Pgtd9yr4G537ekh9Wed9UaxF0UNr/b0ptSxo0LognYUUVvGoaRIStkeAHlddJV/pGdp24NSf8kkxnQFcRVRBRIQChawroOgkGlt+VuM8TxgM1HwKOvu++Rm0j8Kv5A/fh9b7pkA72i/26mlLbkhSNDuKLsHPMbsZseO2gsjoBN8LUSFDBz+vkdxCUn3VM0JzwQ/KcAV1FVG6RhU+IRIUqCFNTQNdJMLD8btEamuR2n51LgGe/5OEI9K5R9m/l3xzet0IeePm7/vaeqwKKRZfnkySKE7ZKLUEY3QnECKIStHEyZoViEZ/+/svCx8apkWAT5HXyMwjKzzpJ0JxwInk1Ayqhc8C5rsBVVGgHsOgzQJs9YMjDa6wfHX4bl64+dR055F/c6dzH3rkEePp6sW7BMbXlY50HUPG+2TUCK+9S3GivUNHEvy352Qd++v9V8aMXYLJGR0bQrU0fdY65sqZhwskjjdZIsElKLt50zQk3khcZUAmd+51Xv2Vx/2jd0sfWHQucdTXw0anR5I11nQR1nHD3v2MZ/aset0SAADXZ4T9JKB4C/e+b3xqB0pa9D48b+P7LEvYJO0iqy6Q6howRRig/7hyz6RoJNnG/TrIk5fWsJHnOgKxh697aWzDnc1593Ujg1i1yX7g62sbc0NGnLsw1K7Dos9YSbVdaUwmDTv+rpO5Y4JmbobTPXJVVmHjatPLXvtRo7n8bWH47cGS/91pDGoHp3wr3hK0j1WVKHUOGCCuUb0KO2WSNBBsTXidZkvB6VpI8Z0C2iOo3P3D5uyTv75T7wg2rq6GUoCdBzwiDIsUCsOhG4J0vAS99y/86A+h933I5dQejWABe/jdgzPkDX5OqaiuFseJOsSNw8Vzg4jvCP2Hr7BIhoVBZrf6xMY2eIeocrBD1pa3Nyic+U3LMuorswsKU10kW01/PSpLnDMiEzttvDD4+VyYCEaU0bNCToFuEwS9rvx3gwR4pDz+tnTb2aRrod5y6t4o/C7UjgE9+M7p8O/UCjMYpFTBi6CDsPuhecR8kRG3nmEWCNlHkmHUV2YWBSa+TLCa/npUkr4AQEBdRjTwlwOKSRXm6BYGioHW6lfqwJwBe/4ygQNEDv6I+l9zlXfzmu76h9zT9/P3lRXkyTmH14H4nIgqoF2AsbpP9vByBUvyEqHUJ4/hBdzFkmMT5OmWBZMsRu+XqlaRxS1GQmU2iNKzT6/XasogEfXrTALdutn60ZYUPvgsMPQ4Y1tLvgD3Upqe+QYUo36dCXnCPJa+VzpRFmLUtCcJNsMaWnPUqUhPx1E0TfJ8Eo9ayT5p2vk1S9+2GKfLVyUsTlOIWOpepK6htBI4ZbBkkG5WivKhCvbq+wL1qG67+EbD0NmtCYSg4dD4c2gOsusd5P7rqG1Qo/RyETRx6ASHUtpjyJaaClyFpqK3x7QjoCFFHmWPWXQwZ5Wchabl4L0xybJIdGfCiL58PuA6ZCVKUF0VkQPUL3M1xkBl2dOoU4IHTxJr/fQ9VEPWpH13uZHnupwhM+CIwZDiw8Yfl9x50+JAXHfcBE28JZ203HN/f0fIOqcrz6Bp21YtJX2KyiIbHTGlrxs+3dCmva/LwGSdEERDZ4T02SfwsqBKGs2PaMKP0OgNAuF+2YYd6Vb/A3RyHjq8N1Etw22dfygAu91Ty/H0jgj2urR0OjP+iNaq4VFXwoTa5IsZhLcDHPmvVgHyoCfjDioCFix6Mvxm4bF44a3sRduhe+Hqrf05N+xKTQUcKwGbE0BrsPni07+ekGT7ZCYYyKY8kfhZUCcPZ0e2Q6SDZaQIRYYqzhBnqVe1D9+pq+I8bBU9W0sYm03GgIupzaJ+l9TDq9H7HRUUa+UCX9firf2SlFdY+7H7tGZ8CfvdTuXWdePk71mcjagW/sPUCNLcxilTggrTYhYlIsEYG+wv6V7dPwm+270lsiFpXv35SPwsqhKUtYaKAUrqdASDcL1sdgkBOqHyBjzlP3NUgg13bUOlADT3OSgf0vDfQmWqdLkgvODguSjUUvY//+Zxe/8ojWvHmut46Eb9tk5IzLZKG5toWE7/EZAgqRFNarV5zTFXk96YzTK2rX1/2s7BuazeqqnKJc57CdHZMFFBKvzMQNmFEH1S+wAMPIeqltI1NxYF662VBnUHFyVO5Xa4IHJBQjTzwDtD6F0Dnfyqu77LPtKC5jdHELzEZggrRxKkcpztMratfX/Y9vuXJjWVTEZOSVgnT8TVRQCmZOgOmYRvPM2da/wY9Wap8gQcWpnHQVSgd7rR1DfD6r8oHPZWievIUDl8KQOfPgq+RNqEfXcOuejHxS0wG2wD64W8nnYIX53w8NkfASffADlOv2KLeBaOrX1/2Pa4cjxxk71ESpuNr4jAjOgMmovIFHliYpmilNADL2K+4E7j/I/2iPQuvAH403X2qnurJ0661sO9DKxpqYdMm9OP5eqvXtpj4JSZDqQFU5fw/Oy6WsHaYU/ps7fzmCgepuWGIdB5c9Flww6QJg16E6fiaKKBEZ8AUSk/j21+yugAACL/AZRyHWsEX8x839Kv2rXvEO+xvSy3bDsEJ463hQl7Ujig/ebopSLrtf9jx4UUTSolibHEcaBx7bOKXmCyXtjajrkY+ahe3Y6MSpvbDlLYWvDjn43jqpgn45l+dg6dumtAXAZFRJvT6LIgIuvcoCNvx1eGQ6STdrYVJwa0tsG0msGWRuDVSpKlQO9yqxtdGbzvaJ+4DfuHVtljC1QutPZe20tUdaw0m+sMKywlxeh7AMlhA+EqJpeOZ04jGNsYk9pbLttTZ5AA8fO2fo3Ho4MDFb34KAJ/Z9Da+/ONNwrW/+Vfn4IpzRivvyQ3V99bp+uG1gwakB5zQvXfd2GkawHkUsQ6jbYp4F52BuBHpCcxYALy/A9jzBjB8DHDc6cDhPQO/zN00FXQMbQqMh/NgiygBYk2IziXAs38HHNobzjZNko6OCwWHwZQvMVlkjSsANNcPxhXnHI8lr+wI7PD4dZx06gFU4vbe+dUNqFyvUCzi099/OZS9R00SHV8/0BmIExkBHi/VvUo1Qqcv8t/9p5XvNxZFRcjXf2XVMITBjMesItCsEsU47hiRNa4z20fj46c14ZYng4vpBBHlsYVpRFX/qsI0bsbt7stbce+yTi1COGHtPS6S5vj6gTUDcSLTFuglv7v/HeDp64EtP7N+dupqeG2Ztu2GQ8mER0DclXHSBeL6gVzFx1pU02CTtuJBFewIVeXnsbJGJMHIFLwNrxuE+z51Fu5dFrxwL2gBYBj1GV7dCV98cuDvK/csm+dPcm2JE/Yo4ivOGY2Jp4xMzL5VoDMQJ7ra2BZ9Bvjdzwb+/hd3B1Pli4ySHn8Rwur4HDDzB/1jmm9cCsx+Vb29rrSg06mlMk0kcRy3D2QK3uZ96kz8ZvseLUZRRwGgziIzGedEBtlWOtMK5Ig3FB0qJeoRr9pOokVLdji3sD+c+6ej4en4h4Wsc+Sl/NhxH1A3svw9BID2z7jUTji016U8XD4AzZLFJmMbKK8c8DOb3pZay8koloaT/2fn+77Xqdyzjil9OiSZAbVWujRNGEw7dAZsdBsAGcdCOGpZkVI53Q2Pyk34G3MhsP3F3h/CKB9RGEOs4hw5KT8e7B44lKl2hPX8bt0UldLRXnMenr7B14Q/44lqHLchiAyU3/5yp1y8n3WcsMPUQdAhyexnTLOOvZPwyZYzoDri168BkHUsqqqt9sGXvhXotvr3W3J62/OG3GMGDXE+ZdcdC5x1NfCRDqv977WlwPrvqe/JPq2vvFM84VG1x79UNrlziZUuqVz/kEco95K7Bk5UVBkQlRY0SxaHjY5iLi8D5Ueu161Q0Au/xtUvKid6l9FricrzEzWy4wyIRvzqMgAqjkXnkpIxwJqwT29H5UKU+ON64NqfiCv5c1VyzkDtSGD83/SPHbbXyVWFM+EREBhxN3LAxsctZ8AmQ+HyMoQRKp/OWgh4tXnpCkfbtQU3P7FRyih65eLdCNO4ujlLsk7O3ZefjnuXvVr2Gsc5m4FEQzacAV0jfkUGQOVkCUgaMIUwO2AZ4ELemikgw+F9/ffmdX8yKY26Y61ivWNqBv5N54THyghPseBjWJPD+5qxcHkfYY7j1ojXONkvPLERw+sGYW+PnoE4brUFTkbRTy5et3G1HYDnOrvws03vYPfBo31/K30d7r68FV98cuOAx5c6J1PaWtDR1uLbsUpDG14a7kGV9DsDMpXSMsgYAJWTJSBnwOpGWuODZbAr4re/JDHprwSZe5MxGNMedHYEbHRMeHSK8NQOl398JaX3nrBwuVbCGsetCZlK+FJHAAg+c96rtsBPoeDfTjoFH2kapt24iGoV7Nfh8xeNxZJXnIcDVTonfvP8aRDoScM9+CH9zkAYI37dCONkOeVrwLAW4PfLXSR7S6/tPb2pnlxljZsOg6EyHrkStwhPEEXC0ntPULg8FMIYx60JP6fvoDPnAWej6LdQ8Pw/O057IZ1MrYL9t397fpvrNdPOag5s6LwiN0GcsihJwz34Jf3OgJYRv5IGIIyT5bCW/hD+iROBZ780sDK+dgTwyW/2G2OV9Wsb1Yybk8E4YTzw1stWT35YBsRXXYAXDu9rQsLloRLEWQsRv5XwQWbOO2FSoaCfWgU3Hn3hDfz5CY2Yetbxrs/lFTYXRW7cnDLVcHyY4Xu/95AW0u8MKIV0AxoA1ZOl6inUNsTbXrDaAYuwvrhPuqB8f2POs/L3MumF8TfL3ZtXJ8a3zg6/J19XhAeA5/saJPoRtU5FhvAzJraUoG11gHmFgrp0A2z+8Zkt6GhrGbBPmbC5isCS7ZTpGIikM3zv5x7SRPqdAVkD7TpERyFfqnqydL0W1s+fuG+gMamqBk65xPqf1z4u/3/i4sjaEeXV9G54TVV86V8H7n3/DksmecIXgY9O1WMUZSM8tY3lkRMnnQHR++onXJ41oaKIEVXCi7CdiSAnSxMKBUvR4eCUsvvgBwMMnWzYXHYv9nWq4fgowveq95A20u8MyBro1ulA6yeDn+xUTpZu19r84k6gqsqfMTnjSuDtL3loGOSs1ILo/rw6MVzX7r123SPW/3QYRdkIz8wf9tdNlCoQqr6vKuHyLAoVRYxXu58XpSH6oCdLWSMQVqFgJUGjJU6U3qNK2FxFqEk1HB9V+N6v2FRayMZsAtvo1lf8B19/fPkXtdOgH7/Pd+uWcn38Wzc7G4TW6ZbWgROVQ2JU9fI/cS8w83GrI6GU+tFyBqqQB579MgJ3YugYdmNHeETzBez6itL3UNf76kRGdP1NwE3rfnjdIADeA3Ge6+xyHdBz8xMbsWKLc5V9KbJG4Pw/Oy6SgTYyg5dUKb1HlbC5aC85WI7XuWNHKM9s0DHjQQaVe0gj6Y8M2ERdKS17sizke0WPnCjRJigWBkrtep247fx18U/AjAWWiuDBd9Xu+/n7vRX8pNGg3mdqcV9WhYpiwq3d77nOLldNgEtbm3HB/F8GPln6USYME7/REjcqDZ1K2FxFqEk1HB9V+F5VbCptZMcZAMyslJY1Jk75f7cwtFf+Wvb+C3ngZUEroxIajKKJvfBZFSqKEad2Py9NgLVbu7UUhkVtLGTqG9zEkYYOrsbBI/LRqJzD3lXD5rJCTarrRhm+VxGbShvZcgZMJJCRcDhx68pfb38pWP++G0GNomm98FkWKjIMN6EcnSfLqIyFSn2DkyNUKBbx6e+/LPVcbuv6iYSU7qVr/2Hsfv8IhtfV4O09h/CfG/+I5oZafGxMo9K6UUdksjppkc5A3AQ2EiUn7jHn6Ru0E9ZJ1u1+VdryTIrw9HRbcxdcJ0SmXKgoAeg+WYZtLPxUzlc6QvlCUdh9MbxuEB6+ph0TXGob/EZCqqty2HfoKL6+4jXHiExLwxBMP7sF33t+m2t6o3TdOML3WZy0mI0CQpMRFsZJ8v5OdTlkL7SfZHP9csmVdC4BHmoDHp8GLP6c9e9DbcEKDqOgcwnwH58Rj4pOu1CR4YRRGGYbC92FgqLK+SKs+oZ8wbtCwDaggHNhZQ7AvE+difM/cqzn3t2KNpsbhri289nOjFtqZse+w/je89vw+YvGoqG3+LMUp9/52QdRI1csFnVJuhG/9IX2gYF+r+Tbc+NSyyFY/DnxtTMesyrrvSjkLYPsNZhImt4vG6cUhVtao/Ixpgn69L0+Hs5Xrtoq3my7MrJtEWdsAwU4nyxLDYpMrl5Wr0BV12Dt1m5c8+g64f08ddMEqZOrLqEelfu9YP4vpfQYKgdL2Ti9J6r7IOowTWACXoVxfWJIEkqFMid+oP/U72VgPav3BdSNtMLnpffhVOAn25an2kkRBTKKiMU8MDRboUZTkc31yxhPWQOrYohtI/dziRZHAHius0vKGdCV0pANm6sIMzk5AoB3h0cWw/dRkY7IgGmnRr94Sf66Rg5Qfnr2PM33Og63bgZeWyanmOfUmeBK7/pf2mTNKhC9H9tesFICvvCINkTB5kX6ojAkMrxOlm65+tKTKgDhNVPaWqTW8nIuRIwcWoP1/zDZuFPxM5vexpd/vEnberIREBKc5EcG0iQD61YYJ9tSJ9uL/9oy+Y6Dyur97q3AGlskyWX9Y2rkCvx0d1JECbsIEonbyVJW5a5YLAqv+fhpTdKKebYYkuqJrPvgUSM18nWr86VV+tdEku0MZEkGVralTuQ4nHa5FT1Q6TiodFJGna6n119nJ0XU3QVJHneclkiaRmRV7rywr1m49g2ptdZt7Q40ddBEQxl0hkQlaZX+NZHkOgPCfHOMp8awkG2pc3McAODl7wZXzNPV6z/mvIH1BX6IQ9DHVEVEEWmKpGlEp2HdvrtH6rq1r78XaOqgiYaytA1QxPC6QdjX84ERao4kya2FOtvo0kilHv9ry6yIwMq75B5faWAr5yIAwfX+q6qBs/5S/XGVxBWKl515YQp2JK3yvxsdsyMSjk7DOmZEneSV/vL9pmvk28WaLQ3Or2lLwxB897p2zPvUmQC8Z0qYVhORZpIbGaAMrDyu7XsevPuaZfTHnCdfbOiHj061Jhv6woBQvGmKiG5kMZKmgKzKXbFYxM79RzyvuX7iSfj+i9uEa008ZSS+vfp/lfZpiqEUtfg5KRGOGFqD5obasmu/c107vrqkE137syX9ayLJdQZYwCWHpxHw4PlvWP+rHeE8rEhXXYYw927jIxRv58YP7LCGNA09DhjWot9Ym6SI6AYHKnkiq3IHQHhNzTFVmH52C/7t+W2uz3fPJ1sx4eSRwvx6VQ4o1RfyYyh19+bLtkzKtAH+9s092Lm/PFXSte8wfvvmHmoMRExyWwtV2ugyeNIB0Dts6LvyqQFlNL3GotbJ8/4O2LKoIjIx2rtg0aslMos58pS1QoZlGHToDLi1Fdr8zUVjcefU1r61vMSQHr62HY1Da3zfpy7RodL1vO7tkWvbMfUsuXW/trzT02GqfJ2C3AcdCTHJdQYA+f77LKKkDxCQG5cGP006FraVGHyVCniptEguW58PWU0HHe9lyOg2cJUEUSCUUeBraRiCF+d8vEzfIIz7UdE6kEHm3qpywLev+XNMPet4z7WO/qmA0+7+ObxUlatywGv3XoZfvrYz0H2E/XlJC8l2BgCxEckifmoEgqDrNKmj5U1GJhhA5iJHKYmk6TZwuvErJ6z75Coy3HbdQqlTIkL23gDgu4L34bEXXse9y14VrvMPU0/Hgv/a5vs+TP+8mERyawZsklLAFRXKNQI5oHY4cGiP/+fUVZehI/cuIxMMIHM58qS2QpYgKwxUKWEbJX7HJZfm13U4BrK6CSrCRSrtl6L3Qbb9csMb3b7vIwmfF5NIvjMAJKOAKyqkjSHQZwTG3wysuc/HkxlQzV+JavdIlrpNZJUsDSUMA6eboOOSdYW0/TolXqi0X4reB9n2y7oaORPldB9J+LyYRHJ1BpJGZZ9+IR/O86gYN7sf/qK/9zFG2dDTpGqUImvdJq3TgVu3WLUBMx6z/r11s/GOABCOgdONaFwyYM0V+NiYxgG/dxv927XvMG5+YiNWSA4xAoI7JU7Y9yaL1/tw/cSTIDqMV+WAGe0flnoup/tIwufFJOgMREHnEitf+/g0q6L78WnWz2GIvMgat477+o2AHUIG4CoBUlvx5WWqsI7dqigkZ9WWmBTViIpKQSqTnDkPwjBwurFbFL3oPngUF39jdZlxF4W0ASuknfequCtBxikZMXQQuvYfxtqt3VLrytxbKV7vQ80xVbjpwrGej7/pwrE478+O9bwPLwGmJHxeTILOQNhErfp2sBvIeb2tvUZw/Bf6jUAhbxn7CTdb8sCl1B8PXL0QuH1rMk6TfY6NRJTDtKgG8URk4ExR5pvS1oLPX+Rt6HZUnPZVQtoylBput9dr98EPcNtPNuGaR9fhgvm/lIo8TGlrwSPXtnue6mXfhzuntuJvLho7YK2qXH9bodd9iASYkvJ5MYXkdxOYjLCyXXMFd+cS4OnrBRdVtNQ5dWPUjbRkgj86NbnFmJ46AxnvNkkwor78INXhuir6ZVrwbFoahuD+mWdjZWcXfrR2u/D6b/7VObjinNHSe5Edj6z6+i3/73fwxSd/G3gdwGozXLj2DWzf3YMxI+pw/cSTUHNM+YHGby1FmJ+XtEFnIEx09nZ7td3Z9Qg/uRY4etB9jVw1MHMBcMaV1s+uLYgp0WmISoGQRIpfw+Bl7HX2oqu04KlS2ZIog33fXfsO4d5lr2L3waOO16m2G0bdv+/XWaPOgBzp6CYwFV3zE7wmzQHy4kLFfH8aIAta9ewySSWluveyhsHLIABw7EW3C/dUT49hFKQFmeJnty2u3drt6ggA6tX1ft6HIMjIGzsR9T6TCp2BMNExP8Ht9L5/h0RKwAHb8aBWPUkwKobBTXima99hfOGJjRheN0hrL7rugjRdw4nCqK73a6CjJin7jBMWEIZJX2W7RwmLV0W78PTuA9vxSOPUx6jaN0likKnS39vzgevjVQv3ALlKfhWaG4ZoyW2zup54wchAmARVfVMSEJKgtrHf8Ujb1EevVEqS6x5IIERV+rI4nZbdctilExCDcMPEMbisrUVbSFt2TDOr67MJIwNhY6u+1Vd49TJ9+rpP5eNv7nc8ZKIWdcdaxXemn7Kjbt8kiUFX/r7ytLxiyw5cMP+XuObRdfjyjwe2501pa8F3rmtXEump5LK2Fkw8ZaS23HaQNj2SfthNEBV+hvDIdiPIUDsCuP1/y5/TdeqjA35P2TqGD4nWFw0mqh9t/AAeEg5BK/udKuxVht/0VfLvP4zd7x/BiKE1GFU/BF95ehN27j/ieUJXGSKkQtzV9RwnbCZ0BkxGOGlOFo9xvaqjjq96vL81UUQUofsUjeYl+rF7/r1C4w11g7Cvt25A1Iuuaxqg7v53VQOrcr1O4x23I0LcoTNgOq6n99IahMp6hBJkBHZK+/FXzAV6ut2vzVUBM34AtF0pue+QNQz++2ngpzeJr/vUo8BZVwd/PpI4ZAwvACkjJRtp+PfPjcf5HzlWuC8dhjFMA6tzbY4TNhs6A0nA8YTda+QBBwXBYy3Dp6ogqJKWuHqhuzGPUnlx7cPAyrvE13XcB0y8JdhzkcQiY9RkTsDPbHobX/7xJuHzDa8dhHkzzhQat6Cn7jANrM61dUVUSHiwmyAJtE63xH/ccu9ef1NBpWDRS5AoSg2DocfpvY6kEhnhGZledNm2u72HPpASLKp8znyhiLVbu6XD915tk340EsJam+OEzYfOQFLwUtPTpbSn0kboZcyj1DAYJnnqkb2OpBYdwjOi9rxKVAymakg+TAOre22OEzYfthaSfqTH//biZsyj1DCQ2XNWRxUT7aiM8bUN5rrXPWpwerFD8pUG2JZEdpooGKaB1b32sR8arPU6oh86A6SfvvG/krgZ86DKiyoIRxbnOKqYaMXWEBheO0jq+lv+3dmY28ioJP7Ts53IF8qvCEtRMF8o4r0DR/SuLVuZxgq22KAzQMppnW61D+a8PhoCY17mVLjIm+g00H3CThURgvrRyZ+8SIxkSlsLHv50u9S1dv2Am0OgEpIvRSR7nIOVZlBRFLTFlO5d9qrndaprv3dQzrmQvY7ohzUDZCBnXGl9Ay260eGPksbcNtCOOgOCVkc/iIosCdHMhJNHaqkf8BuSL5U9dhE7V1IUdOseqMTP2pyLYD50BogzbVcCVQuDGfOoDTRHFpMIUZlB4FVwF8RQ2imLysLDZkUtAK9URSWqawOci5AEqDNAvAlbTpiQhLNiyw7MXbwZew+5Tz+0+eZfnYMrzhld9jsZlURRD35QvQJZMaW7Lz8dnzl/rC8tAN2qi0QvjAwQb3jaJsSTKW0tGDZ4ED792MvCa51O9zrC/UHbJqW7AoYN9i0KpCuKEQdZmKdAZ4AQQgIy4RTv+gFRGDxuQxlVTl9G/Mk0sjJPgWkCQgjRgI4weFwnUB2pijSSpXkKdAYICRvWXWSGJJ8iTc3px+0gZWWeAtMEhIRJFGOciTEkMQxu45aqqKupxkWnHodhQwYhXyhGei9xOldZm6fAyAAhYRHVGGdCNJIvFPHtX/4v/u35reg5mi/72/C6QZj3KfE0Rh3EHaKXnVDp1CGSRKhASEgYFPJWRMBLZHbFXOs6QjRiTz58ZtPbWLu1e4CMsYjnOrvw4Ko/DHAEAGBvzwf4goeaoi78SjTrJGtCSUwTEOa0wyDKMc4ksejOhwcNq+cLRXx1ye+E1/kdjSyLCSH6rAkl0RnIOsxph0OUY5xJItGdD3cLq9uTD2XC6uu37UbXfvF8gLANsQkjj3XLPZsO0wRZxs5pV55g9++wft+5JJ59pYEoxziTxOFnZLEXusLqKsY1TENsSojeLqpsbih/nuaGIalqKwQYGcguwpx2zsppn3Y5UwZ+sMc4798B59c4Z/1dxxhnkihEhjsH9TC8rrC6inEN0xCLQvQA0Fg3KJIQfZI7RFRgZCCrqOS0iTpRj3EmicHvyGIvdIXVzx07As31g4XrqI5GVsUO0XvFMfb0fIDnOrtC20PlfiaeMhJXnDMaE08ZmTpHAKAzkF2Y0w4fe4xzfUUosf54thVmmDDy4brC6tVVOXx1+hnCdaLIlV/a2ozhdYNc/25HUMLsKMgSTBNkFea0oyHqMc7EeMLIh+usfJ/S1oLvXteOuT/djL095ZMYG+sG4WsR6Qys37Z7wPOXErXoT9qHFdEZyCrMaUcHJz+SEmQN98fGNGLt1m4p46O78t3Ok6/b2o21r78HwAqTTzg5uhC5CR0FNkmWmZaFCoRZpk8hD3D8+mAom2SYME+CojkAn79oLJa8skPZ+KTJaK3d2o1rHl0nvO6pmyaEGhmIWwkxKugMZB1HnYHRVnEbHQGSUaIwqm7PMf3sFnzv+W2+jU9awtkmTFLUPazI5PeGzgChAiEhJUR5Eqw0Dh8b04iLv7E6M5PyRMQ9SVFndML0qA27CUh/TvvMmda/dARIRolaE7+yZe032/dobztMMnGL/uiqW9AtMhUGLCAkhJBeZDUA1m3txvkfOVb785tUNFdJXCHuOEV/dHR+hCEyFQZ0BgghpBdZI3vLkxsxb4b+FjtTZHgriTvEbUdQokZHy6YJQ5dkYJqAEEJ6kTWyew99EEp41zY+bufDHMJX/6tENsQddHSyidgtm4CrjqiwZdPkaE8pjAwQQkgvMpr4pegO75o2KU82xF0oAPcuM7c4Lgh23UJlZKRZ8v5MjfZUwm4Ckj3YPUE8cOsmcCOMPve4w/I2stX0TqStD99vzYQJLZIyMDJAsoWjrsLx1lAh6ioQ9J8E5y7ejL2H3OVwbcII75oyKS/IvZlUHKcDv3ULpkV73GDNAMkOtuJi5bTG/Tus33cuiWdfxDimtLXg4U+3S10bVnjXhEl5Qe8ta62QbsTdIikDIwMkGxTyVkTAq4N86W3AqVOAY2qi3BkxlAknj5SuJDdZWS4IqjUUbsRdHGcCpkR73GDNADEbXfn9bS8Aj08TX1c3Epj2EFMGBICcAh4AI/L7YeH1GsRZV0H0wjQBMZfOJcBDbZYRX/w569+H2vyF89/fKXddTzdTBqQPUXgXgPHKckHxeg0eufbPjWuFJP5gZICYSd9ERReFeNWJirKRAfs56o8Hbt3MLgMCwLmSHIDWITam45YKiXt+ANEDnQFiHoW8FQGoLPTrw4ex7ltzB6SDmzcutWY1EOKAKSN2TcCUVkjiHxYQEvPY/pKHIwAARWD/29Z1ssa6qtpqH3z6Bvl9yKYWSCZJirJcFJheHEfE0Bkg5iFrhFWNdet0K72w9Dag5z3x9R9qUlufZIqkKMtFRVzzA4geWEBIzEPWCPsx1q3TgdmvWl0DruSA+tFW5wIhLpg4R4AQv9AZIOYx5jyrJsDrazaIsT6mxmofRM7hOXp/njKPxYPEEx1DbAgxBToDxDzs/D6A0Iy1nTKoryhuqj9evVOBZJJ8oYiG2hp89vyT0Di0XKjKJGU5QmRgNwExF8c5AqMtR0CXsebQIuIDp+r5EUMH4S/OGY3Jrc0sniOJg84AMRsaa2IYblMN2VdPkgydAUIIkcQeR5sVoSGSHVgzQAghkqzfttvVEQA4pY8kFzoDhBAiCYWGSFqhM0AIIZJQaIikFToDhBAiCYWGSFqhM0AIIZL4FRrKF4pYu7Ubz2x6G2u3diNfYN02MQt2ExBCiCIqU/o40Y8kAToDhBDig3yhKJzSR00CkhToDBBCSAhQk4AkCdYMEEJICFCTgCQJOgOEEBIC1CQgSYLOACGEhAA1CUiSoDNACCEhQE0CkiToDBBCSAj41SQgJA7oDBBCSEhMaWvBd65rR3NDeSqguWEI2wqJUbC1kBBCQkZGk4CQOKEzQAghhGQcpgkIIYSQjENngBBCCMk4dAYIIYSQjENngBBCCMk4dAYIIYSQjENngBBCCMk4dAYIIYSQjENngBBCCMk4dAYIIYSQjENngBBCCMk4dAYIIYSQjENngBBCCMk4dAYIIYSQjENngBBCCMk4dAYIIYSQjENngBBCCMk4dAYIIYSQjENngBBCCMk4dAYIIYSQjENngBBCCMk4/x8qhY8YejO+rgAAAABJRU5ErkJggg==\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model = BayesClassifier([Normal(covariance_type='diag') for i in range(3)]).fit(X, y)\n",
"\n",
"y_hat = model.predict(X)\n",
"\n",
"\n",
"for i in range(3):\n",
" plt.scatter(*X[y_hat == i].T)\n",
"\n",
"plt.axis(False) \n",
"plt.show()"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/docs/tutorials/B_Model_Tutorial_4_Hidden_Markov_Models.ipynb 0000664 0000000 0000000 00000533614 14643672530 0032074 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"id": "70d24e61",
"metadata": {},
"source": [
"## Hidden Markov Models\n",
"\n",
"author: Jacob Schreiber \n",
"contact: jmschreiber91@gmail.com\n",
"\n",
"Hidden Markov models (HMMs) are a probability distribution over sequences that are made up of two components: a set of probability distributions and a transition matrix (sometimes represented as a graph) describing how sequences can proceed through the model. HMMs are the flagship implementation in pomegranate and were the first algorithm originally implemented.\n",
"\n",
"HMMs are a form of structured prediction method that are popular for tagging all elements in a sequence with some \"hidden\" state. They can be thought of as extensions of Markov chains where, instead of the probability of the next observation being dependant on the current observation, the probability of the next hidden state is dependant on the current hidden state, and the next observation is derived from that hidden state. An example of this can be part of speech tagging, where the observations are words and the hidden states are parts of speech. Each word gets tagged with a part of speech, but dynamic programming is utilized to search through all potential word-tag combinations to identify the best set of tags across the entire sentence."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "d4ba80d9",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n",
"numpy : 1.23.4\n",
"scipy : 1.9.3\n",
"torch : 1.13.0\n",
"pomegranate: 1.0.0\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-208-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"%pylab inline\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"\n",
"import torch\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p numpy,scipy,torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "c06a7df3",
"metadata": {},
"source": [
"### Identification of GC-rich regions of the genome\n",
"\n",
"Lets take the simplified example of CG island detection on a sequence of DNA. DNA is made up of the four canonical nucleotides, abbreviated 'A', 'C', 'G', and 'T'. We can say that regions of the genome that are enriched for nucleotides 'C' and 'G' are 'CG islands', which is a simplification of the real biological concept but sufficient for our example. The issue with identifying these regions is that they are not exclusively made up of the nucleotides 'C' and 'G', but have some 'A's and 'T's scatted amongst them. A simple model that looked for long stretches of C's and G's would not perform well, because it would miss most of the real regions.\n",
"\n",
"We can start off by building the model. Because HMMs involve the transition matrix, which is often represented using a graph over the hidden states, building them requires a few more steps that a simple distribution or the mixture model. Our simple model will be composed of two distributions. One distribution will be a uniform distribution across all four characters and one will have a preference for the nucleotides C and G, while still allowing the nucleotides A and T to be present."
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "3770cbc1",
"metadata": {},
"outputs": [],
"source": [
"from pomegranate.distributions import Categorical\n",
"\n",
"d1 = Categorical([[0.25, 0.25, 0.25, 0.25]])\n",
"d2 = Categorical([[0.10, 0.40, 0.40, 0.10]])"
]
},
{
"cell_type": "markdown",
"id": "5939f6a7",
"metadata": {},
"source": [
"Now we can define the HMM and pass in states. Note that in pomegranate v1.0.0, HMMs are split into two implementations: `DenseHMM`, which has a dense transition matrix and so can use standard matrix multiplies in the backend, and `SparseHMM`, which has a sparse transition matrix and uses more complicated scatter-add operations. Also note that you no longer need to wrap the distributions in `Node` objects. You pass the distributions in directly."
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "2b033a88",
"metadata": {},
"outputs": [],
"source": [
"from pomegranate.hmm import DenseHMM\n",
"\n",
"model = DenseHMM()\n",
"model.add_distributions([d1, d2])"
]
},
{
"cell_type": "markdown",
"id": "99ab6ba2",
"metadata": {},
"source": [
"Then we have to define the transition matrix, which is the probability of going from one hidden state to the next hidden state. In some cases, like this one, there are high self-loop probabilities, indicating that it's likely that one will stay in the same hidden state from one observation to the next in the sequence. Other cases have a lower probability of staying in the same state, like the part of speech tagger. A part of the transition matrix is the start probabilities, which is the probability of starting in each of the hidden states. Because we create these transitions one at a time, they are very amenable to sparse transition matrices, where it is impossible to transition from one hidden state to the next. Note that we are passing in distribution objects, not node objects as in the previous version, here."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "a3a45214",
"metadata": {},
"outputs": [],
"source": [
"model.add_edge(model.start, d1, 0.5)\n",
"model.add_edge(model.start, d2, 0.5)\n",
"model.add_edge(d1, d1, 0.9)\n",
"model.add_edge(d1, d2, 0.1)\n",
"model.add_edge(d2, d1, 0.1)\n",
"model.add_edge(d2, d2, 0.9)"
]
},
{
"cell_type": "markdown",
"id": "ad8c3b70",
"metadata": {},
"source": [
"Another big change is that we no longer need to bake the HMM once we're done!"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "453e2e92",
"metadata": {},
"outputs": [],
"source": [
"#model.bake()"
]
},
{
"cell_type": "markdown",
"id": "08cc2637",
"metadata": {},
"source": [
"Now we can create a sequence to run through the model. Make sure that this sequence has been converted to a numeric representation of categories. This can be done either simply, as below, or using a preprocessing tool from some other package like scikit-learn. Also, make sure that your input sequence is 3D with the three dimensions corresponding to (batch_size, sequence length, dimensionality). Here, batch_size and dimensionality are both 1. The inclusion of batch size helps significantly when processing several sequences in parallel."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "a3f465b3",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1, 51, 1)"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sequence = 'CGACTACTGACTACTCGCCGACGCGACTGCCGTCTATACTGCGCATACGGC'\n",
"X = numpy.array([[[['A', 'C', 'G', 'T'].index(char)] for char in sequence]])\n",
"X.shape"
]
},
{
"cell_type": "markdown",
"id": "66ee1c74",
"metadata": {},
"source": [
"Now we can make predictions on some sequence. Let's create some sequence that has a CG enriched region in the middle and see whether we can identify it."
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "77aba624",
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"sequence: CGACTACTGACTACTCGCCGACGCGACTGCCGTCTATACTGCGCATACGGC\n",
"hmm pred: 000000000000000111111111111111100000000000000001111\n"
]
}
],
"source": [
"y_hat = model.predict(X)\n",
"\n",
"print(\"sequence: {}\".format(''.join(sequence)))\n",
"print(\"hmm pred: {}\".format(''.join([str(y.item()) for y in y_hat[0]])))"
]
},
{
"cell_type": "markdown",
"id": "66fb5e21",
"metadata": {},
"source": [
"It looks like it successfully identified a CG island in the middle (the long stretch of 1's) and another shorter one at the end. More importantly, the model wasn't tricked into thinking that every CG or even pair of CGs was an island. It required many C's and G's to be part of a longer stretch to identify that region as an island. Naturally, the balance of the transition and emission probabilities will heavily influence what regions are detected.\n",
"\n",
"Let's say, though, that we want to get rid of that CG island prediction at the end because we don't believe that real islands can occur at the end of the sequence. We can take care of this by adding in an explicit end state that only the non-island hidden state can get to. We enforce that the model has to end in the end state, and if only the non-island state gets there, the sequence of hidden states must end in the non-island state. Here's how:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "7ac4a61d",
"metadata": {},
"outputs": [],
"source": [
"model = DenseHMM()\n",
"model.add_distributions([d1, d2])\n",
"model.add_edge(model.start, d1, 0.5)\n",
"model.add_edge(model.start, d2, 0.5)\n",
"model.add_edge(d1, d1, 0.89 )\n",
"model.add_edge(d1, d2, 0.10 )\n",
"model.add_edge(d1, model.end, 0.01)\n",
"model.add_edge(d2, d1, 0.1 )\n",
"model.add_edge(d2, d2, 0.9)"
]
},
{
"cell_type": "markdown",
"id": "533e21a1",
"metadata": {},
"source": [
"Note that all we did was add a transition from n1 to model.end with some low probability. This probability doesn't have to be high if there's only a single transition there, because there's no other possible way of getting to the end state."
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "e1a4e059",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"sequence: CGACTACTGACTACTCGCCGACGCGACTGCCGTCTATACTGCGCATACGGC\n",
"hmm pred: 000000000000000111111111111111100000000000000000000\n"
]
}
],
"source": [
"y_hat = model.predict(X)\n",
"\n",
"print(\"sequence: {}\".format(''.join(sequence)))\n",
"print(\"hmm pred: {}\".format(''.join([str(y.item()) for y in y_hat[0]])))"
]
},
{
"cell_type": "markdown",
"id": "ff42a49b",
"metadata": {},
"source": [
"This seems far more reasonable. There is a single CG island surrounded by background sequence, and something at the end. If we knew that CG islands cannot occur at the end of sequences, we need only modify the underlying structure of the HMM in order to say that the sequence must end from the background state.\n",
"\n",
"In the same way that mixtures could provide probabilistic estimates of class assignments rather than only hard labels, hidden Markov models can do the same. These estimates are the posterior probabilities of belonging to each of the hidden states given the observation, but also given the rest of the sequence."
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "d80b5c2e",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.plot(model.predict_proba(X)[0], label=['background', 'CG island'])\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "53ce7fda",
"metadata": {},
"source": [
"We can see here the transition from the first non-island region to the middle island region, with high probabilities in one column turning into high probabilities in the other column. The predict method is just taking the most likely element --- the maximum-a-posteriori estimate.\n",
"\n",
"In addition to using the forward-backward algorithm to just calculate posterior probabilities for each observation, we can count the number of transitions that are predicted to occur across each edge."
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "cb57f555",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[28.9100, 2.4128],\n",
" [ 2.8955, 15.7806]])"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"transitions = model.forward_backward(X)[0][0]\n",
"transitions"
]
},
{
"cell_type": "markdown",
"id": "0519180b",
"metadata": {},
"source": [
"### Initializing Hidden Markov Models\n",
"\n",
"There are two ways to initialize an HMM using pomegranate. The first is to explicitly pass a list of distributions, a dense transition matrix, and optionally start and end probabilities. We can recreate the above model using this approach."
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "6bd07c92",
"metadata": {},
"outputs": [],
"source": [
"model = DenseHMM([d1, d2], edges=[[0.89, 0.1], [0.1, 0.9]], starts=[0.5, 0.5], ends=[0.01, 0.0])"
]
},
{
"cell_type": "markdown",
"id": "6adc4910",
"metadata": {},
"source": [
"We can check that this initialization produces the same model by making the same plot of predicted probabilities across the sequence."
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "21036aaf",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.plot(model.predict_proba(X)[0], label=['background', 'CG island'])\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "fef1d863",
"metadata": {},
"source": [
"This also works when creating a `SparseHMM` object, though the edges must be a list of 3-ples rather than a matrix."
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "58e15480",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from pomegranate.hmm import SparseHMM\n",
"\n",
"edges = [\n",
" [d1, d1, 0.89],\n",
" [d1, d2, 0.1],\n",
" [d2, d1, 0.1],\n",
" [d2, d2, 0.9]\n",
"]\n",
"\n",
"model = SparseHMM([d1, d2], edges=edges, starts=[0.5, 0.5], ends=[0.01, 0.0])\n",
"\n",
"plt.plot(model.predict_proba(X)[0], label=['background', 'CG island'])\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "45a110ac",
"metadata": {},
"source": [
"The second way is to follow the procedure outlined above where you first create an uninitialized model with nothing passed into it and then you add the distributions and edges using the appropriate methods. Although this can be used for both `DenseHMM` and `SparseHMM` modls, this is likely most useful for `SparseHMM` models that are very sparse or when you're trying to procedurally generate an HMM based on external factors. Here is the same code as before that implements the HMM using this approach."
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "63d27732",
"metadata": {},
"outputs": [],
"source": [
"model = SparseHMM()\n",
"model.add_distributions([d1, d2])\n",
"model.add_edge(model.start, d1, 0.5)\n",
"model.add_edge(model.start, d2, 0.5)\n",
"model.add_edge(d1, d1, 0.89 )\n",
"model.add_edge(d1, d2, 0.10 )\n",
"model.add_edge(d1, model.end, 0.01)\n",
"model.add_edge(d2, d1, 0.1 )\n",
"model.add_edge(d2, d2, 0.9)"
]
},
{
"cell_type": "markdown",
"id": "40c26d2c",
"metadata": {},
"source": [
"Similar to other methods, we can create an HMM with uninitialized distributions. These distributions will be initialized using k-means clustering when provided with data. When using a `DenseHMM` we can also choose to not pass in edges and have them be initialized to uniform probabilities. When using a `SparseHMM` we must pass in edges because, otherwise, the model will not know which edges exist and which do not. Essentially, it would have to assume uniform probabilities as well, at which point the model would have a dense transition matrix but just operate inefficiently by treating it as a sparse matrix."
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "96e650df",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([-0.6929, 0.2710]),\n",
" Parameter containing:\n",
" tensor([1.0994, 0.7262]),\n",
" Parameter containing:\n",
" tensor([ 0.4207, -1.0267]))"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from pomegranate.distributions import Normal\n",
"\n",
"X3 = torch.randn(100, 50, 2)\n",
"\n",
"model3 = DenseHMM([Normal(), Normal(), Normal()], verbose=True)\n",
"model3._initialize(X3)\n",
"model3.distributions[0].means, model3.distributions[1].means, model3.distributions[2].means"
]
},
{
"cell_type": "markdown",
"id": "d480be39",
"metadata": {},
"source": [
"You can control how the k-means itself is initialized by passing in a value to `init`.\n",
"\n",
"However, you do not need to manually initialize your models. If you call the `fit` method or the `summarize` method, these distributions will be initialized if they have not yet been."
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "c9481c5d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: -23.134765625, Time: 0.007689s\n"
]
},
{
"data": {
"text/plain": [
"DenseHMM(\n",
" (start): Silent()\n",
" (end): Silent()\n",
" (distributions): ModuleList(\n",
" (0): Normal()\n",
" (1): Normal()\n",
" (2): Normal()\n",
" )\n",
")"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X3 = torch.randn(100, 50, 2)\n",
"\n",
"model3 = DenseHMM([Normal(), Normal(), Normal()], max_iter=5, verbose=True)\n",
"model3.fit(X3)"
]
},
{
"cell_type": "markdown",
"id": "fd93f0d6",
"metadata": {},
"source": [
"#### Dense and Sparse HMMs\n",
"\n",
"Separately from whether the HMM is initialized by passing in the distributions and edges initially or building the model programmatically, the transition matrix can be represented using a sparse matrix or a dense matrix. Although a dense transition matrix allows fast matrix multiplications to be used for each algorithm, once there are enough zeroes a matrix multiply wastes a lot of computation handling them. \n",
"\n",
"Because the backend and strategy for initializing the model (i.e., passing in a dense transition matrix or a list of edges) differ, pomegranate v1.0.0 splits the implementation in two: `DenseHMM` and `SparseHMM`. Both have the same functionality and API and, given the same transition matrix, will yield the same result. "
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "c392872e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[0.8016, 0.1984],\n",
" [0.6708, 0.3292],\n",
" [0.6163, 0.3837],\n",
" [0.4196, 0.5804],\n",
" [0.3092, 0.6908],\n",
" [0.2535, 0.7465],\n",
" [0.2361, 0.7639]])"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"edges = [[0.89, 0.1], [0.1, 0.9]]\n",
"starts = [0.5, 0.5]\n",
"ends = [0.01, 0.0]\n",
"\n",
"model1 = DenseHMM([d1, d2], edges=edges, starts=starts, ends=ends)\n",
"model1.predict_proba(X)[0][12:19]"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "212880ce",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[0.8016, 0.1984],\n",
" [0.6708, 0.3292],\n",
" [0.6163, 0.3837],\n",
" [0.4196, 0.5804],\n",
" [0.3092, 0.6908],\n",
" [0.2535, 0.7465],\n",
" [0.2361, 0.7639]])"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"edges = [\n",
" [d1, d1, 0.89],\n",
" [d1, d2, 0.1],\n",
" [d2, d1, 0.1],\n",
" [d2, d2, 0.9]\n",
"]\n",
"\n",
"model2 = SparseHMM([d1, d2], edges=edges, starts=starts, ends=ends)\n",
"model2.predict_proba(X)[0][12:19]"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "e46f5fb3",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"102 ms ± 13.9 ms per loop (mean ± std. dev. of 5 runs, 10 loops each)\n",
"177 ms ± 12.9 ms per loop (mean ± std. dev. of 5 runs, 10 loops each)\n"
]
}
],
"source": [
"X = numpy.random.choice(4, size=(1000, 500, 1))\n",
"\n",
"%timeit -n 10 -r 5 model1.predict_proba(X)\n",
"%timeit -n 10 -r 5 model2.predict_proba(X)"
]
},
{
"cell_type": "markdown",
"id": "b7e1c416",
"metadata": {},
"source": [
"Check out the benchmarks folder to see a more thorough comparison of the two, but it looks like even for a tiny model that the dense transition matrix is around twice as fast."
]
},
{
"cell_type": "markdown",
"id": "4f42ef6a",
"metadata": {},
"source": [
"### Fitting Hidden Markov Models\n",
"\n",
"Hidden Markov models are usually fit to unlabeled data using the Baum-Welch algorithm. This is a structured EM algorithm that accounts for transitions between distributions as well as the distribution parameters themselves. Essentially, one uses the forward-backward algorithm to infer the expected number of transitions across each edge and the expected probability of each observation aligning to each state and uses those estimates to update the underlying parameters."
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "7ffaad1d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 16405.125, Time: 0.09408s\n",
"[2] Improvement: 420.75, Time: 0.0876s\n",
"[3] Improvement: 207.25, Time: 0.09545s\n",
"[4] Improvement: 116.125, Time: 0.107s\n",
"[5] Improvement: 75.3125, Time: 0.09284s\n",
"[6] Improvement: 47.6875, Time: 0.0797s\n",
"[7] Improvement: 34.75, Time: 0.1045s\n",
"[8] Improvement: 27.3125, Time: 0.08161s\n",
"[9] Improvement: 16.0625, Time: 0.08903s\n",
"[10] Improvement: 15.6875, Time: 0.1197s\n",
"[11] Improvement: 9.1875, Time: 0.09623s\n",
"[12] Improvement: 10.625, Time: 0.08911s\n",
"[13] Improvement: 8.125, Time: 0.1064s\n",
"[14] Improvement: 6.3125, Time: 0.07936s\n",
"[15] Improvement: 2.3125, Time: 0.08887s\n",
"[16] Improvement: 5.0625, Time: 0.108s\n",
"[17] Improvement: 4.3125, Time: 0.08656s\n",
"[18] Improvement: 3.1875, Time: 0.08103s\n",
"[19] Improvement: 1.75, Time: 0.1282s\n",
"[20] Improvement: 4.4375, Time: 0.09025s\n",
"[21] Improvement: -1.6875, Time: 0.07991s\n"
]
},
{
"data": {
"text/plain": [
"DenseHMM(\n",
" (start): Silent()\n",
" (end): Silent()\n",
" (distributions): ModuleList(\n",
" (0): Categorical()\n",
" (1): Categorical()\n",
" )\n",
")"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d1 = Categorical([[0.25, 0.25, 0.25, 0.25]])\n",
"d2 = Categorical([[0.10, 0.40, 0.40, 0.10]])\n",
"\n",
"edges = [[0.89, 0.1], [0.1, 0.9]]\n",
"starts = [0.5, 0.5]\n",
"ends = [0.01, 0.0]\n",
"\n",
"model = DenseHMM([d1, d2], edges=edges, starts=starts, ends=ends, verbose=True)\n",
"model.fit(X)"
]
},
{
"cell_type": "markdown",
"id": "d5e96225",
"metadata": {},
"source": [
"We can change the number of iterations by setting either the `max_iter` parameter or the `tol` parameter."
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "de6627ad",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 16405.125, Time: 0.1029s\n",
"[2] Improvement: 420.75, Time: 0.1356s\n",
"[3] Improvement: 207.25, Time: 0.1192s\n",
"[4] Improvement: 116.125, Time: 0.08874s\n",
"[5] Improvement: 75.3125, Time: 0.1781s\n"
]
},
{
"data": {
"text/plain": [
"DenseHMM(\n",
" (start): Silent()\n",
" (end): Silent()\n",
" (distributions): ModuleList(\n",
" (0): Categorical()\n",
" (1): Categorical()\n",
" )\n",
")"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d1 = Categorical([[0.25, 0.25, 0.25, 0.25]])\n",
"d2 = Categorical([[0.10, 0.40, 0.40, 0.10]])\n",
"\n",
"edges = [[0.89, 0.1], [0.1, 0.9]]\n",
"starts = [0.5, 0.5]\n",
"ends = [0.01, 0.0]\n",
"\n",
"model = DenseHMM([d1, d2], edges=edges, starts=starts, ends=ends, max_iter=5, verbose=True)\n",
"model.fit(X)"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "66c35bdf",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 16405.125, Time: 0.1512s\n",
"[2] Improvement: 420.75, Time: 0.1788s\n",
"[3] Improvement: 207.25, Time: 0.1501s\n",
"[4] Improvement: 116.125, Time: 0.127s\n",
"[5] Improvement: 75.3125, Time: 0.08657s\n",
"[6] Improvement: 47.6875, Time: 0.1011s\n"
]
},
{
"data": {
"text/plain": [
"DenseHMM(\n",
" (start): Silent()\n",
" (end): Silent()\n",
" (distributions): ModuleList(\n",
" (0): Categorical()\n",
" (1): Categorical()\n",
" )\n",
")"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d1 = Categorical([[0.25, 0.25, 0.25, 0.25]])\n",
"d2 = Categorical([[0.10, 0.40, 0.40, 0.10]])\n",
"\n",
"edges = [[0.89, 0.1], [0.1, 0.9]]\n",
"starts = [0.5, 0.5]\n",
"ends = [0.01, 0.0]\n",
"\n",
"model = DenseHMM([d1, d2], edges=edges, starts=starts, ends=ends, tol=50, verbose=True)\n",
"model.fit(X)"
]
},
{
"cell_type": "markdown",
"id": "bef914f3",
"metadata": {},
"source": [
"The same parameters and signature applies to `SparseHMM` models."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/docs/tutorials/B_Model_Tutorial_5_Markov_Chains.ipynb 0000664 0000000 0000000 00000026210 14643672530 0030571 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"id": "e785571c",
"metadata": {},
"source": [
"## Markov Chains"
]
},
{
"cell_type": "markdown",
"id": "18476b1f",
"metadata": {},
"source": [
"author: Jacob Schreiber \n",
"contact: jmschreiber91@gmail.com\n",
"\n",
"Markov chains are the simplest probabilistic model describing a sequence of observations. Essentially, for an n-th order Markov chain, each observation is modeled as $P(X_{t} | X_{t-1}, ..., X_{t-n})$ and the probability of the entire sequence is the product of these probabilities for each observation. Naturally, the first observation in the sequence cannot be modeled as this conditional distribution and so is usually modeled as a marginal distribution. The remaining $n-1$ observations also cannot be modeled as this full conditional distribution and so are modeled by smaller distributions.\n",
"\n",
"These chains are easy to implement and use in pomegranate."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "e54bf2cd",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n",
"torch : 1.13.0\n",
"pomegranate: 1.0.0\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-208-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"%pylab inline\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"import torch\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "ac9f587c",
"metadata": {},
"source": [
"### Initialization and Fitting\n",
"\n",
"Initializing a Markov chain is simple. If you have fit distributions, you can pass them in and then use the model for inferene. If you do not have fit distributions, you can specify the `k` parameter, which is the number of previous observations that the probability of each observation is conditioned on. pomegranate will automatically construct the first `k-1` distributions as well as the main conditional distribution."
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "45a08fea",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"from pomegranate.markov_chain import MarkovChain\n",
"\n",
"model = MarkovChain(k=3)"
]
},
{
"cell_type": "markdown",
"id": "b0ed3346",
"metadata": {},
"source": [
"The model can then be fit to data using the `fit` function. However, this data must be three dimensional, with the dimensions being `(n_samples, length, dimensions)`. Most other models in pomegranate only use the first two. This does mean that Markov chains can be multivariate but a multivariate model will assume each of the dimensions are independent of each other."
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "6421a2a7",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"MarkovChain()"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = torch.tensor([[[1], [0], [0], [1]], \n",
" [[0], [1], [0], [0]],\n",
" [[0], [0], [0], [0]],\n",
" [[0], [0], [0], [1]],\n",
" [[0], [1], [1], [0]]])\n",
"\n",
"model.fit(X)"
]
},
{
"cell_type": "markdown",
"id": "b22e05cd",
"metadata": {},
"source": [
"We can then inspect the distribution and compare them to the data to ensure that they're right."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "3f44c198",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([0.8000, 0.2000])"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[0].probs[0]"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "0e9bfd76",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[0.5000, 0.5000],\n",
" [1.0000, 0.0000]])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[1].probs[0]"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "cc6e0a3e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[[1.0000, 0.0000],\n",
" [0.5000, 0.5000]],\n",
"\n",
" [[1.0000, 0.0000],\n",
" [0.5000, 0.5000]]])"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[2].probs[0]"
]
},
{
"cell_type": "markdown",
"id": "d21b4c03",
"metadata": {},
"source": [
"If we wanted to fit a multivariate model all we would need to do is increase the size of the second dimension."
]
},
{
"cell_type": "markdown",
"id": "a403c81b",
"metadata": {},
"source": [
"### Probability and Log Probability"
]
},
{
"cell_type": "markdown",
"id": "1bb609d3",
"metadata": {},
"source": [
"The probability of a sequence under a Markov chain is the product of the probabilities of each observation given the previous observations. Another way of putting this is that the joint probability of a sequence with n observations $P(X_{1} ... X_{n})$ is factorized along a chain and equal to $P(X_{1}) P(X_{2} | X_{1}) \\prod\\limits_{t=3}^{n} P(X_{t} | X_{t-1}, X_{t-2})$ for a third order Markov chain.\n",
"\n",
"If you data is multivariate, the probability of each dimension is independent and multiplied together at the end. If you would like dependencies between your dimensions, you should consider encoding a single dimension to include all combinations of observations across the features.\n",
"\n",
"We can calculate the probability and log probability just as easily as other models."
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "aee0caa2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([0.2000, 0.2000, 0.2000, 0.2000, 0.2000])"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.probability(X)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "b9128d9b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([-1.6094, -1.6094, -1.6094, -1.6094, -1.6094])"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.log_probability(X)"
]
},
{
"cell_type": "markdown",
"id": "0dad7b7f",
"metadata": {},
"source": [
"### Summarization"
]
},
{
"cell_type": "markdown",
"id": "332dcf36",
"metadata": {},
"source": [
"Markov chains can perform summarization of data just like other models but that data has to have the three dimensions mentioned before. Further, each chunk of data that is summarized must have the same length. This means that if you have data with different lengths, you must either summarize them one at a time or bucket the sequences such that each bucket has all the sequences of the same length."
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "02a61b78",
"metadata": {},
"outputs": [],
"source": [
"X = torch.randint(2, size=(30, 8, 1))\n",
"\n",
"model.summarize(X[:10])\n",
"model.summarize(X[10:])\n",
"model.from_summaries()"
]
},
{
"cell_type": "markdown",
"id": "e6965782",
"metadata": {},
"source": [
"### Sampling"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "61c3b5e1",
"metadata": {},
"outputs": [],
"source": [
"X_sample = model.sample(100000).type(torch.float32)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "735921b8",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[0.4667, 0.5333]])"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[0].probs"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "0f604e1d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor(0.5332)"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_sample[:, 0, 0].mean()"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "2f32b318",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[0.3571, 0.6429],\n",
" [0.5000, 0.5000]])"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[1].probs[0]"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "2d399fed",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor(0.5039)"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_sample[X_sample[:, 0, 0] == 1, 1, 0].mean()"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "b623d9cf",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[[0.4000, 0.6000],\n",
" [0.2222, 0.7778]],\n",
"\n",
" [[0.1250, 0.8750],\n",
" [0.7500, 0.2500]]])"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[2].probs[0]"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "6477501d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor(0.2550)"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_sample[(X_sample[:, 0, 0] == 1) & (X_sample[:, 1, 0] == 1), 2, 0].mean()"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/docs/tutorials/B_Model_Tutorial_6_Bayesian_Networks.ipynb 0000664 0000000 0000000 00000055430 14643672530 0031503 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"id": "a44a9073",
"metadata": {},
"source": [
"## Bayesian Networks"
]
},
{
"cell_type": "markdown",
"id": "14ce3241",
"metadata": {},
"source": [
"author: Jacob Schreiber \n",
"contact: jmschreiber91@gmail.com\n",
"\n",
"Bayesian networks are a general-purpose probabilistic model that are a superset of all others presented in pomegranate. Specifically, Bayesian networks are a way of factorizing a joint probability distribution across a graph structure, where the presence of an edge represents a directed dependency between two variables and the lack of an edge represents a conditional independence. Importantly, the lack of an edge does not represent true independence of two variables by itself, but a conditional independence."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "1b6e4ad5",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n",
"torch : 1.13.0\n",
"pomegranate: 1.0.0\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-208-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"%pylab inline\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"import torch\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "fc74c689",
"metadata": {},
"source": [
"### Initialization and Fitting\n",
"\n",
"Similar to the hidden Markov model, the Bayesian network is comprised of a set of distributions and a graph structure connecting them. In this case, the graph is just a series of directed unweighted edges. Most Bayesian networks require that this graph is acyclic. However, because pomegranate uses a factor graph to do inference, there is no strict requirement that this is the case. See the inference sections below.\n",
"\n",
"Likewise, similar to the other models in pomegranate, a Bayesian network can be learned in its entirety from data. However, exact structure learning is intractable and so the field has developed a variety of approximations. See the Bayesian network structure learning tutorial for more.\n",
"\n",
"For now, let's implement the simplest Bayesian network: a child and a parent."
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "ee0487b9",
"metadata": {},
"outputs": [],
"source": [
"from pomegranate.distributions import Categorical\n",
"from pomegranate.distributions import ConditionalCategorical\n",
"from pomegranate.bayesian_network import BayesianNetwork\n",
"\n",
"d1 = Categorical([[0.1, 0.9]])\n",
"d2 = ConditionalCategorical([[[0.4, 0.6], [0.3, 0.7]]])\n",
"\n",
"model = BayesianNetwork([d1, d2], [(d1, d2)])"
]
},
{
"cell_type": "markdown",
"id": "51b582aa",
"metadata": {},
"source": [
"Alternatively, one can use the `add_distributions` and `add_edge` method to create the network programmatically."
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "39494b12",
"metadata": {},
"outputs": [],
"source": [
"model2 = BayesianNetwork()\n",
"model2.add_distributions([d1, d2])\n",
"model2.add_edge(d1, d2)"
]
},
{
"cell_type": "markdown",
"id": "a0ad8a0c",
"metadata": {},
"source": [
"Once these models are initialized with a structure, they can be fit to data."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "94cc3184",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0, 0],\n",
" [0, 0],\n",
" [0, 1],\n",
" [0, 0],\n",
" [0, 1],\n",
" [0, 1],\n",
" [0, 0],\n",
" [1, 1],\n",
" [1, 0],\n",
" [0, 1]])"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = numpy.random.randint(2, size=(10, 2))\n",
"X"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "2d0bba9b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"BayesianNetwork(\n",
" (distributions): ModuleList(\n",
" (0): Categorical()\n",
" (1): ConditionalCategorical(\n",
" (probs): ParameterList( (0): Parameter containing: [torch.float32 of size 2x2])\n",
" (_w_sum): [tensor([0., 0.])]\n",
" (_xw_sum): [tensor([[0., 0.],\n",
" [0., 0.]])]\n",
" (_log_probs): [tensor([[-0.6931, -0.6931],\n",
" [-0.6931, -0.6931]])]\n",
" )\n",
" )\n",
" (_factor_graph): FactorGraph(\n",
" (factors): ModuleList(\n",
" (0): Categorical()\n",
" (1): JointCategorical()\n",
" )\n",
" (marginals): ModuleList(\n",
" (0): Categorical()\n",
" (1): Categorical()\n",
" )\n",
" )\n",
")"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.fit(X)"
]
},
{
"cell_type": "markdown",
"id": "328bcb71",
"metadata": {},
"source": [
"Next, we can check that the learned parameters are correct."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "4a4d34bd",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([[0.8000, 0.2000]]),\n",
" 0.2)"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[0].probs, X[:,0].mean()"
]
},
{
"cell_type": "markdown",
"id": "8cc48140",
"metadata": {},
"source": [
"Looks like the model learned a marginal distribution where the probability of 1 is equal to the mean value, which is correct.\n",
"\n",
"We can also look at the conditional probability table and compare against the probability that the second column is 1 (by taking the mean) when the first column is 0."
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "4f32e05e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([[0.5000, 0.5000],\n",
" [0.5000, 0.5000]]),\n",
" 0.5)"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[1].probs[0], (X[X[:,0] == 0][:,1]).mean()"
]
},
{
"cell_type": "markdown",
"id": "5b4c1d7c",
"metadata": {},
"source": [
"Also looks correct.\n",
"\n",
"Finally, if we know the structure of the Bayesian network that we'd like to learn but don't know the parameters of the tables, we can pass the structure into the initialization and call the fit function."
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "72ed676e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[0.5000, 0.5000],\n",
" [0.5000, 0.5000]])"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model3 = BayesianNetwork(structure=[(), (0,)])\n",
"model3.fit(X)\n",
"\n",
"model3.distributions[1].probs[0]"
]
},
{
"cell_type": "markdown",
"id": "0e9fae78",
"metadata": {},
"source": [
"### Probabilities and Log Probabilities"
]
},
{
"cell_type": "markdown",
"id": "67163cab",
"metadata": {},
"source": [
"Much like other generative models, Bayesian networks can calculate the probabilities of examples given the distributions and graph structure. Because the Bayesian network is just a factorization of the joint probability table along the graph structure, the probability of an example is just the product of the probability of each variable given its parents."
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "d122a19c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([0.4000, 0.4000, 0.4000, 0.4000, 0.4000, 0.4000, 0.4000, 0.1000, 0.1000,\n",
" 0.4000])"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.probability(X)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "5c38c8fa",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([-0.9163, -0.9163, -0.9163, -0.9163, -0.9163, -0.9163, -0.9163, -2.3026,\n",
" -2.3026, -0.9163])"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.log_probability(X)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "c9ff8acb",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([-0.9163, -0.9163, -0.9163, -0.9163, -0.9163, -0.9163, -0.9163, -2.3026,\n",
" -2.3026, -0.9163])"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[0].log_probability(X[:,:1]) + model.distributions[1].log_probability(X[:, :, None])"
]
},
{
"cell_type": "markdown",
"id": "40e7863d",
"metadata": {},
"source": [
"Similarly to other models in pomegranate, the inputs can be lists, numpy arrays, or torch tensors."
]
},
{
"cell_type": "markdown",
"id": "ed1ed550",
"metadata": {},
"source": [
"### Prediction\n",
"\n",
"Perhaps the most useful application of a learned Bayesian network is the ability to do inference for missing values. Rather than a traditional prediction problem, which has a fixed set of inputs and one or more fixed outputs, Bayesian network inference will use any variables whose values are known to infer any variables whose values are not known. The set of known variables can change across examples, and so do not need to be known in advance.\n",
"\n",
"In pomegranate, this is done using the loopy belief propagation algorithm, sometimes also called the \"sum-product\" algorithm. This algorithm is run on a factor graph, which is constructed in the backend. The trade-offs for this, versus normal junction-tree inference, are that the algorithm is faster, easier to implement, exact for tree-like Bayesian networks, and can provide estimates even for cyclic networks, but that the inference is not guaranteed to be exact in other cases or even to converge when the network is cyclic.\n",
"\n",
"The implementation of the prediction methods differs slightly from other models in pomegranate. First, the unobserved variables are indicated using a `torch.masked.MaskedTensor` object, which holds the underlying data and a mask where `True` means the value is observed and `False` means that it is not observed. When the mask is `False`, it does not matter what the underlying value is. "
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "09d83981",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/jmschr/anaconda3/lib/python3.9/site-packages/torch/masked/maskedtensor/core.py:156: UserWarning: The PyTorch API of MaskedTensors is in prototype stage and will change in the near future. Please open a Github issue for features requests and see our documentation on the torch.masked module for further information about the project.\n",
" warnings.warn((\"The PyTorch API of MaskedTensors is in prototype stage \"\n"
]
}
],
"source": [
"X_torch = torch.tensor(X[:4])\n",
"mask = torch.tensor([[True, False],\n",
" [False, True],\n",
" [True, True],\n",
" [False, False]])\n",
"\n",
"X_masked = torch.masked.MaskedTensor(X_torch, mask=mask)"
]
},
{
"cell_type": "markdown",
"id": "8f31835e",
"metadata": {},
"source": [
"If you have already set values in your tensor to some missing value, such as -1, you can easily just do `torch.masked.MaskedTensor(X, mask=(X != -1))`.\n",
"\n",
"Once you've created your `MaskedTensor` you can pass it into the `predict`, `predict_proba`, or `predict_log_proba` methods of your Bayesian network. As a note, when data is provided, those values will appear in the output with a probability of 1. Probability distributions are only provided for unobserved variables."
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "3f9a8d54",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[tensor([[1.0000, 0.0000],\n",
" [0.8000, 0.2000],\n",
" [1.0000, 0.0000],\n",
" [0.8000, 0.2000]]),\n",
" tensor([[0.5000, 0.5000],\n",
" [1.0000, 0.0000],\n",
" [0.0000, 1.0000],\n",
" [0.5000, 0.5000]])]"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.predict_proba(X_masked)"
]
},
{
"cell_type": "markdown",
"id": "69c03439",
"metadata": {},
"source": [
"You might notice that the output from these functions is a different shape than other methods. Because there is no guarantee that the variables all have the same number of categories, pomegranate cannot return a single tensor where one of the dimensions is the number of categories. Instead, pomegranate chooses to return a list of tensors, where each element in the list is one variable and the tensor has the dimensions `(n_examples, n_categories)` for the number of categories for that dimension. In principle, one could return a single tensor of size `(n_examples, n_dimensions, max_n_categories)` where `max_n_categories` is the maximum number of categories across all dimensions, but one would likely choose to slice the unnecessary categories out anyway, and there is no guarantee that a single variable with a large number of categories wouldn't come along and massively increase the amount of needed memory. "
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "e214351f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[tensor([[ 0.0000, -inf],\n",
" [-0.2231, -1.6094],\n",
" [ 0.0000, -inf],\n",
" [-0.2231, -1.6094]]),\n",
" tensor([[-0.6931, -0.6931],\n",
" [ 0.0000, -inf],\n",
" [ -inf, 0.0000],\n",
" [-0.6931, -0.6931]])]"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.predict_log_proba(X_masked)"
]
},
{
"cell_type": "markdown",
"id": "e0d0d976",
"metadata": {},
"source": [
"Unlike the previous two methods, the `predict` method will preserve the shape of the original data but replace the missing values, according to the mask, with the maximally likely value from the `predict_proba` method."
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "9eccf44f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[0, 0],\n",
" [0, 0],\n",
" [0, 1],\n",
" [0, 0]])"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.predict(X_masked)"
]
},
{
"cell_type": "markdown",
"id": "87ecf843",
"metadata": {},
"source": [
"### Summarization"
]
},
{
"cell_type": "markdown",
"id": "ba843259",
"metadata": {},
"source": [
"Summarization for Bayesian networks works entirely the same way as summarization for other models. When given complete data, summary statistics are derived using MLE that can be added together across batches. This means that Bayesian networks can be learned in an out-of-core manner. \n",
"\n",
"Importantly, the Bayesian network must already have a structure or it will not know what statistics to calculate per-batch. This is because structure learning is not implemented in an out-of-core manner and would otherwise have to be done on the first batch. If this is what you want to do, then you should use `fit` on the first batch and the `summarize` on successive batches."
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "274a11f8",
"metadata": {},
"outputs": [],
"source": [
"X = torch.randint(2, size=(20, 4))\n",
"\n",
"d1 = Categorical([[0.1, 0.9]])\n",
"d2 = Categorical([[0.3, 0.7]])\n",
"d3 = ConditionalCategorical([[[0.4, 0.6], [0.3, 0.7]]])\n",
"d4 = ConditionalCategorical([[[[0.8, 0.2], [0.1, 0.9]], [[0.1, 0.9], [0.5, 0.5]]]])\n",
"\n",
"model = BayesianNetwork([d1, d2, d3, d4], [(d1, d3), (d2, d4), (d3, d4)])\n",
"model.summarize(X[:5])\n",
"model.summarize(X[5:])\n",
"model.from_summaries()"
]
},
{
"cell_type": "markdown",
"id": "781d5d33",
"metadata": {},
"source": [
"After fitting, we can check what the learned parameters are."
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "29901f53",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([[0.6000, 0.4000]]),\n",
" Parameter containing:\n",
" tensor([[0.5500, 0.4500]]))"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[0].probs, model.distributions[1].probs"
]
},
{
"cell_type": "markdown",
"id": "19f3af2b",
"metadata": {},
"source": [
"And we can compare them to the actual averages from the data, which should be the same as the learned parameters for the first two dimensions."
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "32d18a0d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([0.4000, 0.4500, 0.4500, 0.6000])"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"torch.mean(X.type(torch.float32), dim=0)"
]
},
{
"cell_type": "markdown",
"id": "ecc2b7f1",
"metadata": {},
"source": [
"### Sampling"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "3068aead",
"metadata": {},
"outputs": [],
"source": [
"X_sample = model.sample(1000000).type(torch.float32)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "b9df335f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[(), (), (0,), (1, 2)]"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model._parents"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "3b020e0f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[0.6000, 0.4000]])"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[0].probs"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "2285d738",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[0.5500, 0.4500]])"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[1].probs"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "77bbc355",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([0.4006, 0.4501])"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_sample[:, :2].mean(dim=0)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "1384cfc0",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[0.4167, 0.5833],\n",
" [0.7500, 0.2500]])"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[2].probs[0]"
]
},
{
"cell_type": "code",
"execution_count": 25,
"id": "2bb22d29",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(tensor(0.5836), tensor(0.2500))"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_sample[X_sample[:, 0] == 0, 2].mean(), X_sample[X_sample[:, 0] == 1, 2].mean()"
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "93cca0b3",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[[0.5000, 0.5000],\n",
" [0.2000, 0.8000]],\n",
"\n",
" [[0.4000, 0.6000],\n",
" [0.5000, 0.5000]]])"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.distributions[3].probs[0]"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "4eaa1041",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor(0.5998)"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_sample[(X_sample[:, 1] == 1) & (X_sample[:, 2] == 0), 3].mean()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5379938",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/docs/tutorials/B_Model_Tutorial_7_Factor_Graphs.ipynb 0000664 0000000 0000000 00000044300 14643672530 0030571 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"id": "e509b5de",
"metadata": {},
"source": [
"## Factor Graphs"
]
},
{
"cell_type": "markdown",
"id": "aed2998e",
"metadata": {},
"source": [
"author: Jacob Schreiber \n",
"contact: jmschreiber91@gmail.com\n",
" \n",
"Factor graphs are a powerful and, in my opinion, underused probabilistic model. Potentially, one reason that they are underutilized is that they are not as conceptually intuitive as Bayesian networks or mixture models. Here, we will alleviate any confusion.\n",
"\n",
"Factor graphs are similar to Bayesian networks in that they consist of a set of probability distributions and a graph connecting them. However, unlike Bayesian networks, this graph is bipartate, and the set of probability distributions is not simply the variables in a data set; rather, the distributions are the union of the marginal distributions of each variable and the factor distributions, which are usually multivariate. In the graph, marginal distributions are on one side, factor distributions are on the other side, and the undirected edges only factor distributions with the marginal distributions of the variables that comprise it.\n",
"\n",
"One way of thinking about this is to start with a Bayesian network. If you convert all the conditional probability distributions into joint probability distributions and keep the univariate distributions as is, you now have your set of factor distributions. Then, for each variable in your network, you add in a marginal distribution. This gives you the set of nodes in your factor graph. Finally, you add an edge between each factor distribution and the marginal distributions corresponding to the variables that make up that joint distribution. When the factor is a univariate distribution, you just add a single edge between that factor and its marginal distribution.\n",
"\n",
"Once the factor graph is instantiated, inference involves an iterative message passing algorithm. In the first step, marginal distributions emit messages which are copies of themselves. Then, in the second step, factor distributions take in estimates of each marginal distribution, combine them with the joint probability parameters, and emit new estimates for each variable back to each marginal distribution. Finally, in the third step, the marginal distributions take in these estimates, average them together, and emit the new estimates back to each variable. The second and third steps are repeated until convergence.\n",
"\n",
"Note: although parameter fitting is implemented for factor graphs, structure learning is not yet supported."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "2327088e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n",
"torch : 1.13.0\n",
"pomegranate: 1.0.0\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-208-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"%pylab inline\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"import torch\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "517ce156",
"metadata": {},
"source": [
"### Initialization and Fitting\n",
"\n",
"A factor graph is comprised of two sets of distributions: the factor distributions, which are a mixture of joint probabilities and univariate probabilities, and the marginal distributions, which are one univariate probability distribution per variable in your data. Marginal distributions are usually set to the uniform distribution, whereas the factor distributions encode statistics about the underlying data. These two sets of distributions are connected using an undirected unweighted biparte graph such that factors can be connected to marginals but not to other factors. Each variable in your data must have a corresponding marginal distribution and appear in at least one distribution on the factor side. Each variable can occur in multiple factor distributions.\n",
"\n",
"Let's start off by implementing the simplest factor graph: two variables joined in a joint categorical distribution."
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "2bd14a31",
"metadata": {},
"outputs": [],
"source": [
"from pomegranate.distributions import Categorical\n",
"from pomegranate.distributions import JointCategorical\n",
"from pomegranate.factor_graph import FactorGraph\n",
"\n",
"m1 = Categorical([[0.5, 0.5]])\n",
"m2 = Categorical([[0.5, 0.5]])\n",
"\n",
"f1 = JointCategorical([[0.1, 0.3], [0.2, 0.4]])\n",
"\n",
"model = FactorGraph([f1], [m1, m2], [(m1, f1), (m2, f1)])"
]
},
{
"cell_type": "markdown",
"id": "f4e137fe",
"metadata": {},
"source": [
"Note that the order that edges are added to the model denote the ordering of variables in the `JointCategorical` distribution, in that the first edge containing `f1` (just the first edge in this case) indicates that the parent of that edge is the first dimension in the factor tensor. \n",
"\n",
"Similarly, the ordering that marginal distributions are added to the model correspond to the ordering of the variables in your data. Specifically, `m1` covers the first column, `m2` covers the second column, and accordingly `f1` is made up of data from the first and second columns. The ordering of variables in a factor do not need to be sorted. If the edges were added as `[(m2, f1), (m1, f1)]`, a valid factor graph would be produced with the only difference being that the first dimension in the `f1` tensor would correspond to the second column data."
]
},
{
"cell_type": "markdown",
"id": "6d2bf514",
"metadata": {},
"source": [
"If you are constructing the factor graph in a more programmatic way you might prefer to use the `add_edge`, `add_marginal`, and `add_factor` methods to build the graph slowly. These methods are used internally when these values are passed into the initialization but can also be called themselves."
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "aa9779e7",
"metadata": {},
"outputs": [],
"source": [
"model = FactorGraph()\n",
"model.add_factor(f1)\n",
"\n",
"model.add_marginal(m1)\n",
"model.add_marginal(m2)\n",
"\n",
"model.add_edge(m1, f1)\n",
"model.add_edge(m2, f1)"
]
},
{
"cell_type": "markdown",
"id": "0569120b",
"metadata": {},
"source": [
"If you have data, you can then train the factor parameters in the same way that you can fit other parameters."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "dcf33396",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[0, 0],\n",
" [1, 0],\n",
" [1, 0],\n",
" [0, 0],\n",
" [1, 1],\n",
" [0, 1],\n",
" [1, 0],\n",
" [1, 1],\n",
" [0, 0],\n",
" [1, 1],\n",
" [0, 1]])"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = torch.randint(2, size=(11, 2))\n",
"X"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "a3955630",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[0.2727, 0.1818],\n",
" [0.2727, 0.2727]])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.fit(X)\n",
"model.factors[0].probs"
]
},
{
"cell_type": "markdown",
"id": "7116ab8a",
"metadata": {},
"source": [
"Importantly, these updates DO NOT change the marginal distribution values. This is because the factor values encode everything that you can learn from previous data (the likelihood function), whereas the marginal distributions represent your prior probability across symbols for that variable. When doing inference when you know the symbol coming from some variable, you set the marginal distributions to be that value 100%."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "5dc9145a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[0.5000, 0.5000]])"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.marginals[0].probs"
]
},
{
"cell_type": "markdown",
"id": "c26256c0",
"metadata": {},
"source": [
"### Probabilities and Log Probabilities\n",
"\n",
"Like other methods, one can calculate the probability of each example given the model. Unlike other models, this probability is factorized across the factors and the marginal distributions to be $P(X) = \\prod\\limits_{i=0}^{f} P(X_{p_i} | F_i) \\prod\\limits_{i=0}^{d} P(X_i | M_i)$ when there are f factors and d dimensions to your data. Basically, you are evaluating the probability of the data under the likelihood of the model (the product over the factors) and multiplying that by the probability of the data under the marginals (the product over the marginals). Without any prior information, the marginal probability is constant and can be ignored. "
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "ecdf7a22",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([0.0682])"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.probability(X[:1])"
]
},
{
"cell_type": "markdown",
"id": "6ea3c4e1",
"metadata": {},
"source": [
"Remember that the above value includes multiplication by marginal distributions, so will probably not directly match any of those in the factor."
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "533f2276",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([-2.6856, -2.6856, -2.6856, -2.6856, -2.6856, -3.0910, -2.6856, -2.6856,\n",
" -2.6856, -2.6856, -3.0910])"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.log_probability(X)"
]
},
{
"cell_type": "markdown",
"id": "a1f1bd27",
"metadata": {},
"source": [
"### Predictions"
]
},
{
"cell_type": "markdown",
"id": "215dabac",
"metadata": {},
"source": [
"Similarly to Bayesian networks, factor graphs can make predictions for missing values in data sets. In fact, Bayesian networks and Markov networks both frequently construct factor graphs in the backend to do the actual inference. These approaches use the sum-product algorithm, also called loopy belief propagation. The algorithm works essentially as follows:\n",
"\n",
"\n",
"- Initialize messages TO each factor FROM each marginal that is a copy of the marginal distribution\n",
"- For each factor, iterate over the marginal distributions it is connected to and calculate the factor's marginal distribution using all OTHER messages to it, ignoring the message from the marginal distribution of interest, and send its belief of what that distribution should be back to it\n",
"- For each marginal, multiply all incoming messages together to get an estimate of what the new marginal value should be.\n",
"\n",
"After the messages converge the new marginal distributions are returned representing the probabilities of each distribution\n",
"\n",
"When one knows what some of the variables should be, such as when they have an incomplete matrix, you can set the initial marginal probability distributions (not the messages, the actual distributions) to be consistent with that (i.e., in the categorical case, observed a `2` means assigning 100% of the probability to that category instead of using uniform probabilities).\n",
"\n",
"Specifying an incomplete matrix is done by using a `torch.masked.MaskedTensor`."
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "f73cac6e",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/tmp/ipykernel_89475/916229149.py:1: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
" X_torch = torch.tensor(X[:4])\n",
"/home/jmschr/anaconda3/lib/python3.9/site-packages/torch/masked/maskedtensor/core.py:156: UserWarning: The PyTorch API of MaskedTensors is in prototype stage and will change in the near future. Please open a Github issue for features requests and see our documentation on the torch.masked module for further information about the project.\n",
" warnings.warn((\"The PyTorch API of MaskedTensors is in prototype stage \"\n"
]
}
],
"source": [
"X_torch = torch.tensor(X[:4])\n",
"mask = torch.tensor([[True, False],\n",
" [False, True],\n",
" [True, True],\n",
" [False, False]])\n",
"\n",
"X_masked = torch.masked.MaskedTensor(X_torch, mask=mask)"
]
},
{
"cell_type": "markdown",
"id": "43c982e1",
"metadata": {},
"source": [
"The mask indicates with a `True` value which indices are known. It does not matter what data value is taken when the mask is `False`."
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "eb4bb44e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[0, 0],\n",
" [0, 0],\n",
" [1, 0],\n",
" [1, 0]])"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.predict(X_masked)"
]
},
{
"cell_type": "markdown",
"id": "aff7591e",
"metadata": {},
"source": [
"This is a somewhat discrete view of the result of the sum-product algorithm though because a full distribution is calculated. If you would like to get the entire predicted probabilities you can do that:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "948b92bd",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[tensor([[1.0000, 0.0000],\n",
" [0.5000, 0.5000],\n",
" [0.0000, 1.0000],\n",
" [0.4545, 0.5455]]),\n",
" tensor([[0.6000, 0.4000],\n",
" [1.0000, 0.0000],\n",
" [1.0000, 0.0000],\n",
" [0.5455, 0.4545]])]"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.predict_proba(X_masked)"
]
},
{
"cell_type": "markdown",
"id": "bd41a294",
"metadata": {},
"source": [
"Note that the output here is a list with two dimensions. Each tensor in the list corresponds to a dimension in the underlying data and the tensors have shape `(n_examples, n_categories)` when using categorical data types. Basically, the first row in the first tensor includes the probabilities that element `X_masked[0, 0]` takes value 0 and 1. Because `X_masked[0, 0]` is an observed value, i.e., has a mask value of `True`, this means that the probability is clamped to 1 at the observed value.\n",
"\n",
"If we only want the log probabilities we can calculate those as well."
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "86c4906f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[tensor([[ 0.0000, -inf],\n",
" [-0.6931, -0.6931],\n",
" [ -inf, 0.0000],\n",
" [-0.7885, -0.6061]]),\n",
" tensor([[-0.5108, -0.9163],\n",
" [ 0.0000, -inf],\n",
" [ 0.0000, -inf],\n",
" [-0.6061, -0.7885]])]"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.predict_log_proba(X_masked)"
]
},
{
"cell_type": "markdown",
"id": "2105983d",
"metadata": {},
"source": [
"### Summarize\n",
"\n",
"Factor graphs can make use of the summarization API for training just like the other models. Basically, you can summarize one or more batches of data using the `summarize` method and then call the `from_summaries` method to update the parameters of the distribution. This will only update the parameters of the factors and leave the marginal distributions the same."
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "2a693544",
"metadata": {},
"outputs": [],
"source": [
"model.summarize(X[:3])\n",
"model.from_summaries()"
]
},
{
"cell_type": "markdown",
"id": "ea3b601e",
"metadata": {},
"source": [
"Then, we can check the parameters."
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "554ff220",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([[0.3333, 0.0000],\n",
" [0.6667, 0.0000]])"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.factors[0].probs"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/docs/tutorials/C_Feature_Tutorial_1_GPU_Usage.ipynb 0000664 0000000 0000000 00000032571 14643672530 0030163 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"id": "58b7d540",
"metadata": {},
"source": [
"## GPU Usage\n",
"\n",
"author: Jacob Schreiber \n",
"contact: jmschreiber91@gmail.com\n",
"\n",
"Because pomegranate models are all instances of `torch.nn.Module`, you can do anything with them that you could do with other PyTorch models. This includes using GPUs or any other device that is supported by PyTorch using exactly the same method calls. Here, we will see how to use GPUs to speed up training and inference."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "94f8d0a5",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T03:34:38.820898Z",
"start_time": "2023-04-16T03:34:32.232716Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n",
"numpy : 1.23.4\n",
"scipy : 1.9.3\n",
"torch : 1.13.0\n",
"pomegranate: 1.0.0\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-208-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"import os\n",
"os.environ['CUDA_VISIBLE_DEVICES'] = '0'\n",
"\n",
"%pylab inline\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"\n",
"import torch\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p numpy,scipy,torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "a479bbc4",
"metadata": {},
"source": [
"### Overview\n",
"\n",
"All models and methods in pomegranate can be sped up using GPUs using the exact same methods as other PyTorch models. Let's see that in action."
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "124bc1ec",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T03:34:38.873756Z",
"start_time": "2023-04-16T03:34:38.825577Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([-0.0236, -0.0205, -0.0137, 0.0102, 0.0062]),\n",
" Parameter containing:\n",
" tensor([[ 1.0031e+00, -7.6397e-04, 1.2268e-03, 1.8175e-02, -1.2175e-02],\n",
" [-7.6397e-04, 1.0070e+00, 1.0800e-02, 1.4855e-02, 2.5852e-02],\n",
" [ 1.2268e-03, 1.0800e-02, 1.0058e+00, 7.3037e-03, -1.7321e-03],\n",
" [ 1.8175e-02, 1.4855e-02, 7.3037e-03, 1.0094e+00, -7.5648e-03],\n",
" [-1.2175e-02, 2.5852e-02, -1.7321e-03, -7.5648e-03, 9.8117e-01]]))"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from pomegranate.distributions import Normal\n",
"\n",
"X = torch.randn(5000, 5)\n",
"dist = Normal().fit(X)\n",
"\n",
"dist.means, dist.covs"
]
},
{
"cell_type": "markdown",
"id": "b160ed65",
"metadata": {},
"source": [
"All we need to do is use the `.cuda()` method or the `.to(device)` method on the data and the model. Similar to PyTorch, the model will not automatically move data to the GPU for you. You have to do this yourself."
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "6e558641",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T03:34:39.496200Z",
"start_time": "2023-04-16T03:34:38.876199Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([-0.0236, -0.0205, -0.0137, 0.0102, 0.0062], device='cuda:0'),\n",
" Parameter containing:\n",
" tensor([[ 1.0031e+00, -7.6398e-04, 1.2268e-03, 1.8175e-02, -1.2175e-02],\n",
" [-7.6398e-04, 1.0070e+00, 1.0800e-02, 1.4855e-02, 2.5852e-02],\n",
" [ 1.2268e-03, 1.0800e-02, 1.0058e+00, 7.3037e-03, -1.7321e-03],\n",
" [ 1.8175e-02, 1.4855e-02, 7.3037e-03, 1.0094e+00, -7.5648e-03],\n",
" [-1.2175e-02, 2.5852e-02, -1.7321e-03, -7.5648e-03, 9.8117e-01]],\n",
" device='cuda:0'))"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dist = Normal().cuda().fit(X.cuda())\n",
"\n",
"dist.means, dist.covs"
]
},
{
"cell_type": "markdown",
"id": "c9d0cc1c",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T01:17:06.819163Z",
"start_time": "2023-04-16T01:17:06.810940Z"
}
},
"source": [
"All models operate in the same way."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "6b24e63f",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T03:34:39.626392Z",
"start_time": "2023-04-16T03:34:39.499859Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 134.63671875, Time: 0.001251s\n",
"[2] Improvement: 38.76953125, Time: 0.001229s\n",
"[3] Improvement: 17.02734375, Time: 0.001173s\n",
"[4] Improvement: 9.13671875, Time: 0.001179s\n"
]
},
{
"data": {
"text/plain": [
"GeneralMixtureModel(\n",
" (distributions): ModuleList(\n",
" (0-1): 2 x Normal()\n",
" )\n",
")"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from pomegranate.gmm import GeneralMixtureModel\n",
"\n",
"model = GeneralMixtureModel([Normal(), Normal()], max_iter=5, verbose=True).cuda()\n",
"model.fit(X.cuda())"
]
},
{
"cell_type": "markdown",
"id": "20fbb008",
"metadata": {},
"source": [
"### Timing Examples\n",
"\n",
"Using a GPU helps the most when the workload is complex. So, we will see only minimal gains on small, simple, workloads like basic probability distributions. For these evaluations we will do timings on the CPU, using the GPU but including the time to transfer everything there, and using the GPU once everything is already there. All evaluations are done on an A100."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "55c8bc9d",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T03:34:53.804660Z",
"start_time": "2023-04-16T03:34:39.629276Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"28.4 µs ± 107 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
"91.3 µs ± 361 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
"54.5 µs ± 170 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
]
}
],
"source": [
"n, d = 100, 5\n",
"\n",
"X = torch.randn(n, d)\n",
"X_cuda = X.cuda()\n",
"\n",
"mu = torch.randn(d)\n",
"cov = torch.exp(torch.randn(d))\n",
"\n",
"d = Normal(mu, cov, covariance_type='diag')\n",
"d_cuda = Normal(mu, cov, covariance_type='diag').cuda()\n",
"\n",
"%timeit d.log_probability(X)\n",
"%timeit d.cuda().log_probability(X.cuda())\n",
"%timeit d_cuda.log_probability(X_cuda)"
]
},
{
"cell_type": "markdown",
"id": "08e206ab",
"metadata": {},
"source": [
"For this extremely small workload, using a GPU is much slower than just doing everything on the CPU. Let's try a larger example."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "9fc26808",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T03:35:11.130177Z",
"start_time": "2023-04-16T03:34:53.806166Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"131 µs ± 7.32 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
"256 µs ± 108 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
"54.2 µs ± 68.3 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
]
}
],
"source": [
"n, d = 10000, 50\n",
"\n",
"X = torch.randn(n, d)\n",
"X_cuda = X.cuda()\n",
"\n",
"mu = torch.randn(d)\n",
"cov = torch.exp(torch.randn(d))\n",
"\n",
"d = Normal(mu, cov, covariance_type='diag')\n",
"d_cuda = Normal(mu, cov, covariance_type='diag').cuda()\n",
"\n",
"%timeit d.log_probability(X)\n",
"%timeit d.cuda().log_probability(X.cuda())\n",
"%timeit d_cuda.log_probability(X_cuda)"
]
},
{
"cell_type": "markdown",
"id": "8c144010",
"metadata": {},
"source": [
"Looks like the CPU time increased several times over but the GPU times didn't change as much. This is because using a GPU has a relatively large fixed cost but the variable cost associating with increasing the size of the data doesn't increase nearly as fast. Let's try a huge example."
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "a21e44ac",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T03:35:31.914911Z",
"start_time": "2023-04-16T03:35:11.136952Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"844 ms ± 90 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"213 ms ± 639 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"11.7 ms ± 2.97 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
]
}
],
"source": [
"n, d = 100000, 5000\n",
"\n",
"X = torch.randn(n, d)\n",
"X_cuda = X.cuda()\n",
"\n",
"mu = torch.randn(d)\n",
"cov = torch.exp(torch.randn(d))\n",
"\n",
"d = Normal(mu, cov, covariance_type='diag')\n",
"d_cuda = Normal(mu, cov, covariance_type='diag').cuda()\n",
"\n",
"%timeit d.log_probability(X)\n",
"%timeit d.cuda().log_probability(X.cuda())\n",
"%timeit d_cuda.log_probability(X_cuda)"
]
},
{
"cell_type": "markdown",
"id": "0ed1eafc",
"metadata": {},
"source": [
"We can see the expected results here: despite having to transfer data to and from the GPU it is faster to do it than use a CPU for large data sets, and if you're in a setting where everything is already on the GPU you can get huge speed boosts.\n",
"\n",
"Now, if you have a more complicated model, you can unlock even larger speed boosts."
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "d50706e3",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T03:35:42.652225Z",
"start_time": "2023-04-16T03:35:31.917040Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"10.1 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
"643 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
]
}
],
"source": [
"from pomegranate.kmeans import KMeans\n",
"\n",
"model1 = KMeans(512)\n",
"model2 = KMeans(512)\n",
"\n",
"%timeit -n 1 -r 1 model1.fit(X)\n",
"%timeit -n 1 -r 1 model2.cuda().fit(X.cuda())"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "7e617469",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T03:35:42.754909Z",
"start_time": "2023-04-16T03:35:42.654315Z"
}
},
"outputs": [],
"source": [
"del X, model1, model2"
]
},
{
"cell_type": "markdown",
"id": "7b1b51e4",
"metadata": {},
"source": [
"Seems significantly faster.\n",
"\n",
"Now, let's try with an even more complex model: the dense hidden Markov model."
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "a7540a37",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T03:35:52.233950Z",
"start_time": "2023-04-16T03:35:42.757731Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"8.23 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
"1.08 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
]
}
],
"source": [
"from pomegranate.hmm import DenseHMM\n",
"\n",
"n, l, d = 1000, 25, 15\n",
"X = torch.randn(n, l, d)\n",
"\n",
"k = 256\n",
"\n",
"dists1, dists2 = [], []\n",
"for i in range(k):\n",
" mu = torch.randn(d)\n",
" covs = torch.exp(torch.randn(d))\n",
" \n",
" dist1 = Normal(mu, covs, covariance_type='diag')\n",
" dist2 = Normal(mu, covs, covariance_type='diag').cuda()\n",
" \n",
" dists1.append(dist1)\n",
" dists2.append(dist2)\n",
" \n",
"\n",
"model1 = DenseHMM(dists1, max_iter=3)\n",
"model2 = DenseHMM(dists2, max_iter=3).cuda()\n",
"\n",
"X_cuda = X.cuda()\n",
"\n",
"%timeit -n 1 -r 1 model1.fit(X)\n",
"%timeit -n 1 -r 1 model2.fit(X_cuda)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/docs/tutorials/C_Feature_Tutorial_2_Mixed_Precision_and_DataTypes.ipynb0000664 0000000 0000000 00000025621 14643672530 0034264 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"id": "fd9dc061",
"metadata": {},
"source": [
"## Mixed Precision and Other Data Types\n",
"\n",
"author: Jacob Schreiber \n",
"contact: jmschreiber91@gmail.com\n",
"\n",
"Because pomegranate models are all instances of `torch.nn.Module`, you can do anything with them that you could do with other PyTorch models. In the first tutorial, we saw how this means that one can use GPUs in exactly the same way that one would with their other PyTorch models. However, this also means that all the great things built-in for during half precision, quantization, automatic mixed precision (AMP), etc., can also be used in pomegranate."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "c9cd05a4",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T02:53:44.483551Z",
"start_time": "2023-04-16T02:53:37.715664Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n",
"numpy : 1.23.4\n",
"scipy : 1.9.3\n",
"torch : 1.13.0\n",
"pomegranate: 1.0.0\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-208-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"import os\n",
"os.environ['CUDA_VISIBLE_DEVICES'] = '0'\n",
"\n",
"%pylab inline\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"\n",
"import torch\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p numpy,scipy,torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "d3ffb2aa",
"metadata": {},
"source": [
"### float16 (half) Precision\n",
"\n",
"Doing operations at half precision is just the same as it would by in PyTorch: you can use the `.half()` method or the `.to(torch.float16)` method. However, very few operations seem to be supported for half precision, including the log and sqrt methods not being supported for some reason? So, until more operations are supported, you will probably be using other methods.\n",
"\n",
"### bfloat16\n",
"\n",
"More operations seem to be supported for `bfloat16` though!"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "d2b18f5b",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T02:53:44.531124Z",
"start_time": "2023-04-16T02:53:44.487008Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([-0.0076, 0.0164, 0.0164, -0.0033, 0.0105]),\n",
" Parameter containing:\n",
" tensor([1.0291, 1.0491, 0.9661, 0.8947, 1.0778]))"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from pomegranate.distributions import Normal\n",
"\n",
"X = torch.randn(1000, 5)\n",
"\n",
"d = Normal(covariance_type='diag').fit(X)\n",
"d.means, d.covs"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "3a191622",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T02:53:44.543246Z",
"start_time": "2023-04-16T02:53:44.533626Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([-0.0075, 0.0165, 0.0165, -0.0034, 0.0103], dtype=torch.bfloat16),\n",
" Parameter containing:\n",
" tensor([1.0312, 1.0469, 0.9688, 0.8945, 1.0781], dtype=torch.bfloat16))"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = X.to(torch.bfloat16)\n",
"\n",
"d = Normal(covariance_type='diag').to(torch.bfloat16).fit(X)\n",
"d.means, d.covs"
]
},
{
"cell_type": "markdown",
"id": "e501c8a5",
"metadata": {},
"source": [
"However, not all operations are supported for `torch.bfloat16` either, including the cholesky decomposition used in full covariance normal distributions.\n",
"\n",
"Although not all operations support all data types, all models and methods (inference and training) support them to the extent that the underlying operations allow. For instance, we can just as easily use a mixture model with `bfloat16` data types as with full floats."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "a30dc725",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T02:53:44.575031Z",
"start_time": "2023-04-16T02:53:44.546736Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 32.0, Time: 0.001619s\n",
"[2] Improvement: 32.0, Time: 0.001082s\n",
"[3] Improvement: 0.0, Time: 0.00106s\n"
]
},
{
"data": {
"text/plain": [
"GeneralMixtureModel(\n",
" (distributions): ModuleList(\n",
" (0-1): 2 x Normal()\n",
" )\n",
")"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from pomegranate.gmm import GeneralMixtureModel\n",
"\n",
"model = GeneralMixtureModel([Normal(covariance_type='diag'), Normal(covariance_type='diag')], verbose=True)\n",
"model = model.to(torch.bfloat16)\n",
"model.fit(X)"
]
},
{
"cell_type": "markdown",
"id": "c40b3b61",
"metadata": {},
"source": [
"And we can use the resulting trained model to make predictions at whatever resolution we'd like."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "77fa2ecd",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T02:53:44.580895Z",
"start_time": "2023-04-16T02:53:44.576451Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(tensor([[0.8281, 0.1680],\n",
" [0.2451, 0.7539],\n",
" [0.0874, 0.9375],\n",
" ...,\n",
" [0.6445, 0.3574],\n",
" [0.3145, 0.6875],\n",
" [0.2695, 0.7305]], dtype=torch.bfloat16),\n",
" torch.bfloat16)"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y_hat = model.predict_proba(X)\n",
"y_hat, y_hat.dtype"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "1b654637",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T02:53:44.590926Z",
"start_time": "2023-04-16T02:53:44.582423Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(tensor([[0.8299, 0.1701],\n",
" [0.2463, 0.7537],\n",
" [0.0793, 0.9207],\n",
" ...,\n",
" [0.6496, 0.3504],\n",
" [0.3148, 0.6852],\n",
" [0.2788, 0.7212]]),\n",
" torch.float32)"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model = model.to(torch.float32)\n",
"\n",
"y_hat = model.predict_proba(X)\n",
"y_hat, y_hat.dtype"
]
},
{
"cell_type": "markdown",
"id": "4d62dd1b",
"metadata": {},
"source": [
"### Automatic Mixed Precision\n",
"\n",
"An automatic way to get around some of these issues is to use AMP so that operations which can work at lower precision are cast and others are not. Keeping up with the theme, doing this is exactly the same as using AMP with your other PyTorch models."
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "1dc7e946",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T02:53:47.577003Z",
"start_time": "2023-04-16T02:53:44.592405Z"
}
},
"outputs": [],
"source": [
"X = torch.randn(1000, 50).cuda()\n",
"\n",
"model = GeneralMixtureModel([Normal(), Normal()]).cuda()\n",
"\n",
"with torch.autocast('cuda', dtype=torch.float16):\n",
" model.fit(X)"
]
},
{
"cell_type": "markdown",
"id": "6b29eb8b",
"metadata": {},
"source": [
"This would have crashed if you tried to run `model.fit` alone because of the unsupported Cholesky decomposition.\n",
"\n",
"### Speedups\n",
"\n",
"Unfortunately, because pomegranate uses a wide range of operations to implement the underlying models, the speedups from using mixed precision are inconsistent. It may be worth trying out in your application but the speedups observed in training neural networks are not guaranteed here because not all operations are supported -- and if they are supported, they may not be optimized to be faster. Basically, because AMP will fall back on normal precision for many operations, the entire method may end up not being significantly faster in practice."
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "fe0d5f03",
"metadata": {
"ExecuteTime": {
"end_time": "2023-04-16T02:53:51.522075Z",
"start_time": "2023-04-16T02:53:47.579203Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 1015.0, Time: 0.1042s\n",
"[2] Improvement: 417.5, Time: 0.1044s\n",
"[3] Improvement: 310.0, Time: 0.1041s\n",
"[4] Improvement: 243.5, Time: 0.1041s\n",
"\n",
"[1] Improvement: 1232.5, Time: 0.1039s\n",
"[2] Improvement: 613.5, Time: 0.1042s\n",
"[3] Improvement: 446.5, Time: 0.1043s\n",
"[4] Improvement: 344.0, Time: 0.1043s\n"
]
},
{
"data": {
"text/plain": [
"GeneralMixtureModel(\n",
" (distributions): ModuleList(\n",
" (0-9): 10 x Normal()\n",
" )\n",
")"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = torch.randn(10000, 500).cuda()\n",
"\n",
"model = GeneralMixtureModel([Normal(covariance_type='diag') for i in range(10)], max_iter=5, verbose=True).cuda()\n",
"with torch.autocast('cuda', dtype=torch.bfloat16):\n",
" model.fit(X)\n",
"\n",
"print()\n",
" \n",
"model = GeneralMixtureModel([Normal(covariance_type='diag') for i in range(10)], max_iter=5, verbose=True).cuda()\n",
"model.fit(X)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/docs/tutorials/C_Feature_Tutorial_3_Out_Of_Core_Learning.ipynb 0000664 0000000 0000000 00000022154 14643672530 0032364 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"id": "692646c3",
"metadata": {},
"source": [
"## Out-of-Core Learning"
]
},
{
"cell_type": "markdown",
"id": "79d62d75",
"metadata": {},
"source": [
"author: Jacob Schreiber \n",
"contact: jmschreiber91@gmail.com\n",
"\n",
"Out-of-core learning refers to the process of training a model on an amount of data that cannot fit in memory. There are several approaches that can be described as out-of-core, but here we refer to the ability to derive exact updates to a model from a massive data set, despite not being able to fit the entire thing in memory.\n",
"\n",
"This out-of-core learning approach is implemented for all of pomegranate's models using two methods. The first is a summarize method that will take in a batch of data and reduce it down to additive sufficient statistics. Because these summaries are additive, after the first call, these summaries are added to the previously stored summaries. Once the entire data set has been seen, the stored sufficient statistics will be identical to those that would have been derived if the entire data set had been seen at once. The second method is the from_summaries method, which uses the stored sufficient statistics to derive parameter updates for the model.\n",
"\n",
"A common solution to having too much data is to randomly select an amount of data that does fit in memory to use in the place of the full data set. While simple to implement, this approach is likely to yield lower performance models because it is exposed to less data. However, by using out-of-core learning, on can train their models on a massive amount of data without being limited by the amount of memory their computer has."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "732d90aa",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n",
"torch : 1.13.0\n",
"pomegranate: 1.0.0\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-208-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"%pylab inline\n",
"import torch\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "e77be408",
"metadata": {},
"source": [
"### `summarize ` and `from_summaries`\n",
"\n",
"Let's start off simple with training a normal distribution in an out-of-core manner. First, we'll generate some random data."
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "40c81d88",
"metadata": {},
"outputs": [],
"source": [
"X = torch.randn(1000, 5)"
]
},
{
"cell_type": "markdown",
"id": "68782e46",
"metadata": {},
"source": [
"Then, we can initialize a distribution."
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "fec969dc",
"metadata": {},
"outputs": [],
"source": [
"from pomegranate.distributions import Normal\n",
"\n",
"dist = Normal()"
]
},
{
"cell_type": "markdown",
"id": "e18b3d50",
"metadata": {},
"source": [
"Now let's summarize through a few batches of data using the `summarize` method."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "8d181be6",
"metadata": {},
"outputs": [],
"source": [
"dist.summarize(X[:200])\n",
"dist.summarize(X[200:])"
]
},
{
"cell_type": "markdown",
"id": "6df91e38",
"metadata": {},
"source": [
"Importantly, summarizing data doesn't update parameters by itself. Rather, it extracts additive sufficient statistics from the data. Each time `summarize` is called, these statistics are added to the previously aggregated statistics.\n",
"\n",
"In order to update the parameters of the model, you need to call the `from_summaries` method. This method updates the parameters of the model given the stored sufficient statistics."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "9cbbe4dc",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([ 0.0175, 0.0096, 0.0228, 0.0592, -0.0089]),\n",
" Parameter containing:\n",
" tensor([[ 0.9786, -0.0106, 0.0344, 0.0571, 0.0330],\n",
" [-0.0106, 0.9970, 0.0165, -0.0330, 0.0021],\n",
" [ 0.0344, 0.0165, 0.9405, -0.0075, -0.0374],\n",
" [ 0.0571, -0.0330, -0.0075, 1.0399, 0.0333],\n",
" [ 0.0330, 0.0021, -0.0374, 0.0333, 0.9978]]))"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dist.from_summaries()\n",
"dist.means, dist.covs"
]
},
{
"cell_type": "markdown",
"id": "2ae90d8d",
"metadata": {},
"source": [
"This update is exactly the same as one would get if they had trained on the entire data set."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "c33e1a42",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([ 0.0175, 0.0096, 0.0228, 0.0592, -0.0089]),\n",
" Parameter containing:\n",
" tensor([[ 0.9786, -0.0106, 0.0344, 0.0571, 0.0330],\n",
" [-0.0106, 0.9970, 0.0165, -0.0330, 0.0021],\n",
" [ 0.0344, 0.0165, 0.9405, -0.0075, -0.0374],\n",
" [ 0.0571, -0.0330, -0.0075, 1.0399, 0.0333],\n",
" [ 0.0330, 0.0021, -0.0374, 0.0333, 0.9978]]))"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dist = Normal()\n",
"dist.summarize(X)\n",
"dist.from_summaries()\n",
"dist.means, dist.covs"
]
},
{
"cell_type": "markdown",
"id": "9b217107",
"metadata": {},
"source": [
"### Batched Training\n",
"\n",
"Sometimes your data is so large that it cannot fit in memory (either CPU or GPU). In these cases, we can use the out-of-core API to train on batches at a time. This is similar to how neural networks are trained except that, rather than updating after each batch (or aggregating gradients over a small number of batches), we can summarize over a much larger number of batches -- potentially even the entire data set to get an exact update. Let's see an example of how that might work."
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "a6232d3c",
"metadata": {},
"outputs": [],
"source": [
"dist = Normal()\n",
"\n",
"for i in range(10):\n",
" X_batch = torch.randn(1000, 20) # This is meant to mimic loading a batch of data\n",
" dist.summarize(X_batch)\n",
" del X_batch # Now we can discard the batch \n",
" \n",
"dist.from_summaries()"
]
},
{
"cell_type": "markdown",
"id": "7c30c9f4",
"metadata": {},
"source": [
"Batched training is easy to implement for simple probability distributions but it can also be done with more complicated models if you want to code your own expectation-maximization. For instance, let's try training a mixture model using a modified version of the training code."
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "14012265",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] Improvement: 1945.53125, Time: 0.01443s\n",
"[2] Improvement: 99.875, Time: 0.01562s\n",
"[3] Improvement: 34.1875, Time: 0.01019s\n",
"[4] Improvement: 17.65625, Time: 0.00994s\n"
]
}
],
"source": [
"from pomegranate.gmm import GeneralMixtureModel\n",
"\n",
"X = torch.randn(10000, 20)\n",
"\n",
"model = GeneralMixtureModel([Normal(), Normal()])\n",
"\n",
"logp = None\n",
"for i in range(5):\n",
" start_time = time.time()\n",
"\n",
" last_logp = logp\n",
" \n",
" logp = 0\n",
" for j in range(0, X.shape[0], 1000): # Train on batches of size 1000\n",
" logp += model.summarize(X[j:j+1000])\n",
"\n",
" if i > 0:\n",
" improvement = logp - last_logp\n",
" duration = time.time() - start_time\n",
" print(\"[{}] Improvement: {}, Time: {:4.4}s\".format(i, improvement, duration))\n",
"\n",
" model.from_summaries()"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
C_Feature_Tutorial_4_Priors_and_Semi-supervised_Learning.ipynb 0000664 0000000 0000000 00004245555 14643672530 0035427 0 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/docs/tutorials {
"cells": [
{
"cell_type": "markdown",
"id": "20ef7db1",
"metadata": {},
"source": [
"## Priors and Semi-supervised Learning"
]
},
{
"cell_type": "markdown",
"id": "339b87c2",
"metadata": {},
"source": [
"author: Jacob Schreiber \n",
"contact: jmschreiber91@gmail.com\n",
"\n",
"Most classical machine learning algorithms either assume that an entire dataset is either labeled (supervised learning) or that there are no labels (unsupervised learning). However, frequently it is the case that some labeled data is present but there is a great deal of unlabeled data as well. A great example of this is that of computer vision where the internet is filled of pictures (mostly of cats) that could be useful, but you don't have the time or money to label them all in accordance with your specific task. Typically what ends up happening is that either the unlabeled data is discarded in favor of training a model solely on the labeled data, or that an unsupervised model is initialized with the labeled data and then set free on the unlabeled data. Neither method uses both sets of data in the optimization process.\n",
"\n",
"Semi-supervised learning is a method to incorporate both labeled and unlabeled data into the training task, typically yield better performing estimators than using the labeled data alone. There are many methods one could use for semisupervised learning, and scikit-learn has a good write-up on some of these techniques.\n",
"\n",
"pomegranate natively implements semi-supervised learning by accepting a matrix of prior probabilities for most classes. Specifically, the prior probabilities give the probability that an example maps to each component in the model, e.g. one of the distributions in a mixture model. When this probability is 1.0, it effectively acts as a hard label, saying that some example must come from that distribution. If all examples have prior probabilities of 1.0 for some component, this is exactly supervised learning. If some examples have prior probabilities of 1.0 and others are uniform, this corresponds to semi-supervised learning. When you have soft evidence, these prior probabilities can be between the uniform distribution and 1.0 to indicate some amount of confidence.\n",
"\n",
"Note that prior probabilities are not the same as soft targets, in that the training is not aiming to classify each point as being proportionately from each distribution. For example, if the prior probabilities for an example given a model is `[0.4, 0.6]`, the learning objective does not attempt to make the underlying distributions yield `[0.4, 0.6]` for this example, but rather that the likelihood probabilities across distributions are multiplied by these values via Bayes' rule.\n",
"\n",
"Let's take a look!"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "d8514fef",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n",
"numpy : 1.23.4\n",
"scipy : 1.9.3\n",
"torch : 1.13.0\n",
"pomegranate: 1.0.0\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-208-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"%pylab inline\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"\n",
"import torch\n",
"\n",
"numpy.random.seed(0)\n",
"numpy.set_printoptions(suppress=True)\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p numpy,scipy,torch,pomegranate"
]
},
{
"cell_type": "markdown",
"id": "a2395019",
"metadata": {},
"source": [
"### Simple Setting\n",
"\n",
"Let's first generate some data in the form of blobs that are close together. Generally one tends to have far more unlabeled data than labeled data, so let's say that a person only has 50 samples of labeled training data and 4950 unlabeled samples. In pomegranate you a sample can be specified as lacking a label by providing the integer -1 as the label, just like in scikit-learn. Let's also say there there is a bit of bias in the labeled samples to inject some noise into the problem, as otherwise Gaussian blobs are trivially modeled with even a few samples."
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "3bdd2f99",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from sklearn.datasets import make_blobs\n",
"numpy.random.seed(1)\n",
"\n",
"X, y = make_blobs(10000, n_features=2, centers=3, cluster_std=2)\n",
"X_train = X[:5000].astype('float32')\n",
"y_train = y[:5000]\n",
"\n",
"# Set the majority of samples to unlabeled.\n",
"y_train[numpy.random.choice(5000, size=4950, replace=False)] = -1\n",
"\n",
"# Inject noise into the problem\n",
"X_train[y_train != -1] += 2.5\n",
"\n",
"X_test = X[5000:].astype('float32')\n",
"y_test = y[5000:]\n",
"\n",
"\n",
"plt.figure(figsize=(6, 6))\n",
"plt.scatter(X_train[y_train == -1, 0], X_train[y_train == -1, 1], color='0.6', s=5)\n",
"plt.scatter(X_train[y_train == 0, 0], X_train[y_train == 0, 1], color='c', s=15)\n",
"plt.scatter(X_train[y_train == 1, 0], X_train[y_train == 1, 1], color='m', s=15)\n",
"plt.scatter(X_train[y_train == 2, 0], X_train[y_train == 2, 1], color='r', s=15)\n",
"plt.axis('off')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "d0933ed2",
"metadata": {},
"source": [
"The clusters of unlabeled data seem clear to us, and it doesn't seem like the labeled data is perfectly faithful to these clusters. This form of distributional shift can typically happen in a semisupervised setting as well, as the data that is labeled is sometimes biased either because the labeled data was chosen as it was easy to label, or the data was chosen to be labeled in a biased maner. However, because we have lots of unlabeled data, we can usually overcome such shifts.\n",
"\n",
"Now let's try fitting a simple Bayes classifier to the labeled data and compare the accuracy and decision boundaries to when we fit a Gaussian mixture model in a semi-supervised way. As mentioned before, we can do semi-supervised learning by passing in a matrix of prior probabilities that are uniform when the label is unknown, and when the label is known has a value of 1.0 for the class corresponding to the label. "
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "84ce3098",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Supervised Learning Accuracy: 0.8842\n",
"Semisupervised Learning Accuracy: 0.9206\n"
]
}
],
"source": [
"from pomegranate.gmm import GeneralMixtureModel\n",
"from pomegranate.bayes_classifier import BayesClassifier\n",
"from pomegranate.distributions import Normal\n",
"\n",
"idx = y_train != -1\n",
"\n",
"model_a = BayesClassifier([Normal(), Normal(), Normal()])\n",
"model_a.fit(X_train[idx], y_train[idx])\n",
"\n",
"y_hat_a = model_a.predict(X_test).numpy()\n",
"print(\"Supervised Learning Accuracy: {}\".format((y_hat_a == y_test).mean()))\n",
"\n",
"priors = torch.zeros(len(X_train), 3)\n",
"for i, y in enumerate(y_train):\n",
" if y != -1:\n",
" priors[i, y] = 1.0\n",
" else:\n",
" priors[i] = 1./3\n",
"\n",
"dists = []\n",
"for i in range(3):\n",
" dists.append(Normal().fit(X_train[y_train == i]))\n",
" \n",
"model_b = GeneralMixtureModel(dists)\n",
"model_b.fit(X_train, priors=priors)\n",
"\n",
"y_hat_b = model_b.predict(X_test).numpy()\n",
"print(\"Semisupervised Learning Accuracy: {}\".format((y_hat_b == y_test).mean()))"
]
},
{
"cell_type": "markdown",
"id": "d1201b15",
"metadata": {},
"source": [
"It seems like we get a big bump in test set accuracy when we use semi-supervised learning. Note that, due to the smooth nature of prior probabilities, distributions are not initialized according to the hard labels at first. You can manually do this as above, though, where you first fit the distributions to the labeled data and then fine-tune on the entire data set given the prior probabilities. Let's visualize the data to get a better sense of what is happening here."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "c6c91a20",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAABR4AAAUbCAYAAABIkrz0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXgTdf4H8PckaXolPaClLeUo0gY5Sk8EwQNQ1IqKihfeP3TV9XbRVXfxWERF12O9j13U9VY8EQRE8ViLgrRpAUHbKuXowdmGlJYeyfz+aGdMJjM52rRpy/v1PPusTZPJdyYp/faTzyGIoiiCiIiIiIiIiIiIKIh0oV4AERERERERERER9T8MPBIREREREREREVHQMfBIREREREREREREQcfAIxEREREREREREQUdA49EREREREREREQUdAw8EhERERERERERUdAx8EhERERERERERERBx8AjERERERERERERBR0Dj0RERERERERERBR0DDxSr/bMM89g1KhReOaZZ4JyvHXr1mHUqFG47LLLgnI8ot6qt7/XL7vsMowaNQrr1q0L9VL6lLvuugujRo3CRx991K+fk4iIiHoW9479E/eO1BsYQr0A6n1GjRoV8GOOOeYYvPHGG92wmiPTZZddhvXr17vdFhUVBZPJhOHDhyMzMxMFBQUYP3580J9bCvLedNNNQT92Z7W1teGDDz7A8uXLUVZWhoaGBsTExCAhIQFHH300jjnmGJxyyimIjY0N9VKpGz3zzDN49tlnPW4PCwvDwIEDkZOTg8svvxy5ubkhWB0REfUVvXGv++WXX2Lr1q04+eSTMXr06IAfz72jO+4dCeDekai3YOCRPKj9w9vQ0ICysjLN71sslm5ZS3x8PEaMGIH4+PigHC8yMhIjRoxASkpKUI7X3VJSUuS1tra2wmazoaioCD/99BNeeeUVHHPMMVi0aBFSU1OD9pzSL+fesnlsaGjA1VdfDavVCqD9PWGxWOB0OrFjxw6UlZVh6dKlSEhIwLRp00K82t6jr73XA2Eymdz+zbHb7di5cydWrFiBlStX4v7778dFF10UwhX2L4mJiRgxYgTMZnOol0JEFBS9aa8r+fLLL/Hxxx8jNTW1U4FHCfeO3Dt2FveO3DsGC/eOpMTAI3l45513PG5bt24dLr/8cs3vd5dLL70Ul156adCON378eKxcuTJox+tus2fP9tjENTQ04IsvvsCzzz6L9evX4/zzz8eHH37YLzcJAPDoo4/CarUiPj4ejz76KE444QT5ew6HA8XFxfjoo48QHh4ewlX2Pn3tvR6IMWPGeGSdHDx4EP/4xz+wbNkyPPzwwzj11FOD9oHFkW7evHmYN29eqJdBRBQ0vWmvG2zcO3Lv2FncO3LvGCzcO5ISezwS9TEmkwnnnnsuPvroI1gsFuzfvx9//etfQ72sbtHW1obPPvsMAPC3v/3NbeMIAHq9HhMmTMDDDz+MyZMnh2KJ1EvExMRgwYIF0Ol0OHz4MIqLi0O9JCIiol6Be8c/cO9IEu4diXoOA4/UZa4DYA4cOIAFCxZg+vTpGDt2LO666y75foWFhViwYAHOOussHHPMMcjMzMTJJ5+M++67D9XV1T6P7eqjjz7CqFGjcNddd6GlpQXPPPMMZsyYgczMTJx44ol4+OGH0djY6HE8rabJu3btwqhRozB9+nQAwKeffopzzz0XWVlZOOaYY3DzzTdj586dmtdgy5YtuO666zBhwgTk5OTgggsukD8xHDVqVKd6CfkSFxeHRx55BACwfv16lJSUuH1/7969eOONN3DVVVdh+vTpyMzMxIQJE3DppZfik08+8TiedK0l0rql/+3atQtA+yfFX375Je6++27MnDkTeXl5yMrKQkFBAR599FEcOHAgaOe4f/9++XUMtOzIV1NjrfeW6+179+7F3/72Nxx33HFyb6TFixejra1N83lra2uxcOFCnHrqqRg/fjzy8/Nx2WWXaX6C7Nooe+vWrbj55psxefJkHH300fjoo49w8803Y9SoUVi8eLHmc65ZswajRo3COeecI9/mrUF4WVkZ5s2bhxNPPBHjxo1Dfn4+TjnlFMybNw/fffed6nP89ttvuPvuuzF9+nSMGzcOEydOxDXXXIMffvhBc10HDhzA/fffj+OPPx6ZmZk49dRT8dxzz6G1tVXzMV0RHR0t92rSeo7i4mLceOONmDx5MsaNG4cTTjgBf/3rX/Hbb7+p3n/69Olu738lrUbnrrf/9ttvuPnmmzFx4kSMHz8e5557Lj7//HPN82hsbMTjjz8u/9xOnz4dixYtwqFDhzQfc/DgQSxZsgR//vOfMWPGDIwfPx55eXk4//zz8frrr2u+Z13/fVq1ahUuueQS5Ofnu52zr5+lQN8bdXV1eOSRR3DaaachMzMT2dnZmD59Oq666iq89dZbmudIRBRKbW1teOeddzBnzhzk5+cjMzMTp512Gp588kk0NDSoPmbNmjW46qqrMHHiRIwdOxaTJk3CmWeeiQceeED+vSPtQT/++GMAwN133+22/wrWgEWAe0dfuHfk3lEN947uuHekzmCpNQXNgQMHMHv2bOzevRvp6ekwmUzQ6f6Ibf/pT3+C0+nEgAEDMHjwYDgcDuzatQvvvvsuVq5cibfeegvp6ekBPWdrayvmzp2LDRs2ID09Hampqdi+fTtee+01lJeX45VXXgn4PB5//HG8/PLLSE1NRVpaGn7//XesWrUKxcXFWLp0KQYMGOB2/7Vr1+Laa69FS0sLTCYTjjrqKFRXV+OWW27B3XffHfDzB2LMmDHIyspCaWkpvvnmG2RnZ8vfW7JkCZ566ilERERg0KBBsFgsOHDgAH766Sf89NNPsFqt+Mc//iHfPyUlBbm5ufKnfcr+RlI5yt69e3HDDTdAp9Nh4MCBGD58OJqamlBVVYXFixdj5cqVeP/995GQkNDl84uOjoYgCBBFERs3bkRGRkaXj+mv+vp6nH/++dizZw8sFguio6Px+++/49FHH0VxcTGeeeYZt/c30L6Jv/7662G32xEREYHhw4fDbrdj/fr1WL9+PebOnYs777xT9fl++uknvPTSSzAYDBgxYgSioqIAAGeccQZWrVqF5cuX46qrrlJ97PLlywEAM2fO9HleGzduxGWXXYbDhw/DbDZj5MiRcDqdqKmpwbJly9DU1OSRHfD555/jr3/9K1pbWxEdHY309HTs27cP3377Lb777jv8/e9/99ik7t27F3PmzMHOnTthMBiQkZGBpqYmPP3009i0aRNEUfS51kBVVVWhrq4OAHDUUUd5fP/tt9/GggULIIoiBg4ciFGjRmHHjh349NNPsXLlSjz99NOYOnVqUNf0888/45lnnoEgCEhLS0NNTQ1+/vln3HbbbWhtbcWsWbPc7t/Y2IgrrrgCGzduhCAIyMjIgNPpxGuvvYb169cjLS1N9Xm+/vprzJ8/H2FhYfLPe319PTZv3oyNGzeisLAQL7zwgsd7VvLyyy/j8ccfR0JCAtLS0lBVVeXX+QX63rDb7bjggguwY8cOhIWFYfjw4QgPD0dtbS0KCwtRWlqKSy65xL+LS0TUQxoaGnDdddfhp59+gk6nQ0pKCqKjo7Ft2za8+OKLWL16Nd544w0MHDhQfsybb76JBx54AEB7v7Ojjz4aDQ0N2L59O8rKyjB06FCMHDkS4eHhyM3Nxfbt27F//36kpaW57TWDXQ7NvWP34d7xD9w7dh73jtw79ksikR9+/PFH0WKxiBaLxeN7Tz/9tGixWMTRo0eLF154oVhTUyN/7/Dhw/J/v/vuu2Jtba3bY5uamsQXXnhBtFgs4qWXXqp57Kefftrt9g8//FC0WCzi2LFjxdNPP138/fff5e9ZrVYxNzdXtFgs4rfffqt6Hsrn2rlzp2ixWMQxY8aIubm54jfffCN/b8+ePeKZZ54pWiwW8Z///Kfb4+x2uzhlyhTRYrGId911l9jU1CSKoig6nU7xzTffFMeNG6d53by59NJLVc9bzaJFi0SLxSLOnTvX7faffvpJ/OGHH8S2tja327du3SoWFBSIFotFXLduncfxfK334MGD4kcffSTW1dW53W6z2cQFCxbI1yJYLrroItFisYg5OTniSy+9JFZWVvr1uDvvvFO0WCzihx9+qPp9rfeWdPuYMWPEM844Q9y5c6f8vfXr14t5eXmixWIR33zzTbfH1dbWisccc4w4atQo8cUXXxSbm5vl7xUVFYnHH3+8aLFYxDVr1rg9TnqtR48eLd5zzz1iY2Oj/L2mpiaxublZfk7X97mksbFRzM7OFkeNGiVWV1fLt2u916+99lrRYrGITzzxhNsaRVEUN27cKC5dutTttq1bt4rjxo0TMzMzxffee090OBzy97766isxNzdXHD16tLh161a3x91www2ixWIRzznnHLd1rV27VszJyRHHjh0rWiwW8ccff/Q4Jy3Sa6M8p4MHD4o//vijeM4554gWi0W89tprPR67ZcsWccyYMaLFYhH//e9/y+fR3Nws3n///aLFYhHz8vLE3bt3uz1u2rRposVicXsfuJJeP+V5SLePHTtWXLBggfxvodPpFP/5z3+KFotFPO644zx+Ph966CHRYrGI06ZNE8vKyuTbt27dKh5//PHydVO+r7du3Sp+/fXXHq/pjh07xEsuuUS0WCziRx995LF+6ed97Nix4nvvvSc6nU5RFEWxtbVVbG1tFUVR+2epM++NxYsXy/9eKf8NqaqqEl999VWPNRIR9QRve93bbrtNtFgs4hVXXCHu2LFDvr2+vl688cYbRYvFIt50003y7a2treKECRPEMWPGiKtXr3Y7Vmtrq7hmzRpx/fr1brf72rf4wr3jH7h35N5Rwr0j947UO7DUmoJGr9fjqaeeQnJysnyba9PmCy+8EElJSW6PiYiIwHXXXYe8vDysX78eu3fvDug529rasGjRIowYMUK+LTs7G+effz4AaKb+ezvejTfeiBNPPFG+LTExEbfeeqvq8ZYtW4a9e/fiqKOOwgMPPICIiAgAgCAIuOSSS/z6FLGrpOutLFPJz8/HpEmToNfr3W4/+uijcc899wCA3AMnEGazGeeccw7i4uLcbo+JicE999yDlJQUrFixwmtJSSDuu+8+xMXF4dChQ3j88cdxyimnYNKkSfjTn/6Ef//736ipqQnK8yhJ760hQ4bIt02YMAG33HILAGDx4sVun7y++uqrqK+vxxVXXIFrr70WRqNR/l5ubq6cIfDaa6+pPl9GRgbuv/9+REZGyrdFRETAaDRixowZAP74dNrVmjVr0NjYiLy8PL+yIiorKwG0ZyC7rhEAMjMzceaZZ7rd9txzz6GlpQW33347LrjgArdPPadPn47bbrsNDocDr7/+unz79u3b8eWXXwIAHnnkEbd1HXvssbj55pu7VDKzfv16t1Ku/Px8XH755dixYwf+8pe/4Omnn/Z4jFTmdNJJJ+Hqq6+Wz8NoNOLee+9FRkYG7HZ70AcKjBw5En//+9/lfwsFQcAtt9yCxMRE7NmzB7/++qt834aGBrz33nsA2t/3rlka0s+t1nU7+uijMXXqVI/XdOjQoXjooYcAeP95v+iii3DBBRdAEAQAgMFggMHgvSiiM+8N6f138cUXe/wbMnjwYFx55ZVen5OIqKf98ssvWL58OVJTU/Hss89i6NCh8vdiY2Px6KOPIiUlBV988YWc8VNXVwebzQaLxYKTTz7Z7XgGgwHTpk3DhAkTevQ8XHHvyL0j947cO3LvSD2JgUcKmsmTJ3sEFpU2bdqExx57DNdddx0uvfRSzJkzB3PmzJH/Qfnll18Ces7Ro0cjMzPT43bpNq3eGt6cd955msdT9nlcu3YtAGDWrFmq/9Cee+65AT9/oKSyCrUeHg0NDXj//fdx5513Yu7cubj44osxZ84cPPbYYwACv96ufvjhBzz00EO45pprcMkll8ivpd1uR1NTE7Zv397pY7s6+uijsWzZMlx55ZVyCU5dXR2+++47PPbYY5gxYwaefPJJOJ3OoDyfJCcnB2PHjvW4ffbs2QgPD0dVVRV+//13+fYvvvgCAOSgt9Lxxx+PsLAwWK1W1Y31WWedpVnKIG3oli1b5vE96bYzzjjDxxm1kzZyK1as8HnflpYWfPvtt9Dr9ZrvZakv6k8//STf9v3330MURUyYMEG1xOm8885DWFiYX+tVYzKZkJubK/9v7NixiIuLg91ux4cffoiioiKPxxQWFgKAat8iQRDk26X7Bcvs2bM9XtewsDC5N47rvylFRUVoampCamqqR8kSAJx00kle/41taWnBZ599hvnz5+Oqq66Sf96lEi1vP+/Ksh1fOvvekN5/X375ZdD+wCQi6k5SMOS0006DyWTy+H5kZCSOPfZYiKKIDRs2AAAGDBgAo9GIysrKLu21ugv3jtw7Atw7cu/IvSP1HPZ4pKBR64shEUURCxYswNtvv+31GDabLaDndP3U2ZXUG8dbQ1018fHxMJvNHrdLPXuUA2ukgKnW8JjuGCqjJJ2jcjO8ZcsWXHvttdizZ4/mYwO93kD7L43bbrtN3ohrqa+vD/jYWhITE3H33Xfj7rvvxm+//YZNmzbhhx9+wJo1a3Dw4EG8+OKLCAsLw4033hi059R6P0dFRSElJQWVlZWorKzEyJEjcejQITnLQcoI0NLc3Iz6+nqPPkYjR47UfMykSZOQmJiIbdu2YcuWLRgzZgyA9qbQ//vf/2AwGHDqqaf6dV5XXHEF1q5di/nz5+OVV17Bcccdh7y8PEycOBHx8fFu962srERzczPCwsLwpz/9SfV40if3rtnK0s+F1jU0mUxISkrq1AcDQHt/qjfeeMPjdqlnzJ/+9Ce8++67GDduHID26yRldWhdZ6m/rLT2YBk2bJjq7Wr/pmzbtg0AMGLECPnTY1c6nQ5paWmqmeHV1dWYO3eufAw13n7evb3/1HT2vXHuuedi8eLF+Oijj/Ddd9/h+OOPR15eHiZNmqT57zkRUSiVlZUBaP+j12q1qt5HGpIo/Xun1+tx2WWXYfHixTjnnHOQm5uLiRMnIj8/H3l5eW4VQaHAvSP3jtw7tuPekXtH6hkMPFLQSJ+eqvn000/x9ttvIyoqCnfccQemTJmCpKQkuTT59ttvx2effRbwpxhaz6n16V+wj9fU1ASgvZG1Gq3bg0kqF3FtRO5wOHDrrbdiz549OPHEE/GnP/0J6enpiImJgV6vx/bt23HKKad06lOjl19+GV9++SUSExNx++23Y8KECUhMTJTT9OfMmYPi4uJu+0Rq5MiRGDlyJM4++2zU1dXh1ltvxY8//ojFixfjmmuu8SgX6CzXBvFq36usrJQ37q7TLKUG694cPnzY4zbXMhklnU6HgoICvP7661i2bJm8eVy1ahVaW1tx4oknegw90jJ16lS8/PLLeOGFF1BaWorff/8dr7/+OgwGA04++WT87W9/kz8ZtdvtANqHOPk6r+bmZvm/pQ2RtzUlJCR0evOo5fTTT8emTZvwyiuv4Pnnn8fzzz/vth5A+3WVNvOBfljhi9brKv2b4lpy5e91U3PXXXdh27ZtyMrKwk033YTRo0cjNjYWYWFhaGtrw9ixY73+THr791tNZ98bSUlJeO+99/DUU0/hm2++wccffyxPcs3OzsZdd92FnJycgNZCRNSdpH/vtm/f7jMjz/Xfu9tvvx1JSUl4++23sWHDBjkb0mQy4eKLL8ZNN90UtD1LoLh35N6Re8d23Dty70g9g4FH6hFSf4g777wTF110kcf3a2tre3pJQSH9YlBmQkqC/YtIjVQaMH78ePm2jRs3Yvv27XI/IuWGqiu9baTX8uGHH8bxxx/v8f2efC3j4+Nxzz33YObMmWhsbERFRYW8sZI+9RM1JuBpvWYSZd8jV/v37wfwR2DZ9Rfv5s2bu1QKouWMM87A66+/js8//xx33HEHBEEIaCKhqxNPPBEnnngi6uvrsWHDBvz4449YtmwZVq5ciR07duD9999HWFiYfH5JSUkB9UuVroc/1zDYpI3Hxo0bPdYjPe+gQYM8Hrdv3z4A2h8WdPZ9FIjOXrfdu3dj3bp1iIyMxMsvv+zR/6Y7ell19r0BtP8B+PTTT6OlpQVWqxU//fQTli9fjpKSEsydOxefffaZW38sIqJQkv5tXrhwoWZJrBqdTocrrrgCV1xxBXbt2oUNGzbgu+++wxdffIGXX34Zhw4dwr333ttdy/aKe0fuHbl3/AP3jtw7Uvdjj0fqEdKnU2qfRrS2tuK3337r6SUFRVpaGgC4Nfl1JZXndJeff/4ZmzZtAtD+aaREKt0YO3as6qe4XenPIx1b7bWsq6sLeEBQV7mm2Ls2T5aCwlq/iHfs2OH1uFrvyaamJvmXsfT6m81meUNSUVHh38IDlJWVhWHDhqGmpgZFRUXYu3cv1q9fj4iICI/G9f6Ki4vDySefjPnz52PZsmUwm83YsmULNm/eDAAYPnw4wsLCsHfv3oDKn6TrolW6cejQoW77I0Pq1+RaGhITEyN/Eqz1ukqvm7R2ibShq6urU32csu9rV0hDsrZt26a6WXU6narXVCrxO+qoozw2joD2v09d0dn3hiuj0YiJEyfixhtvxLJly5Cbm4vGxkbVRvhERKEilVN2ZU83ZMgQnH322XjiiSfwwgsvAAA+/PBDtx6DamWS3YF7R+4duXd0x71jnMf3uXekYGPgkXqEVFKt9onLRx995PVTmt5sypQpAIClS5fC4XB4fP+jjz7qtueur6/HXXfdBaB92pvrp9bS9ZY+iXPV2trqNilMSXqsWkmH6/fVXstXX31V9Tp0Vltbm89eQlKqvk6nc9tISv8tba5d1dbW4vvvv/d6XKvViq1bt3rc/uGHH6K5uRmpqalufWhOOeUUAMB///tfr8ftCunT6WXLluHzzz+Hw+HAtGnTglLSn5CQIH9SKPV2ioyMxHHHHQen06naF0fLcccdB6C9MbTaZnrJkiVdmkzojdR/S9nzRVqT2nmIoog333zT7X4S6ZqovY9WrVrVqV5XWvLy8hAZGYmqqir873//8/j+mjVrVP84c/2ZVNt0/uc//wnaGiWdfW9o0ev18hAvb73FiIh6mhSgWbp0qWYgIRDZ2dkA2vdZrr9DpL6PWvuvYODesR33jtw7uuLekXtH6n4MPFKPyMvLAwD861//cgsyfvfdd3j00UdD3mS7s2bOnInExERUVFTgvvvuk/tRiKKIt99+W3WSXFc1NDTg448/xrnnnouysjIkJiZi0aJFbvfJysqCwWBAcXExPvnkE/l2u92O22+/XXVTKZF+6a5fv171+9JruWjRIrmUXBRFfPLJJ3jllVc0X8tdu3Zh1KhRGDVqlN/9WRobGzF9+nQ8+uij+PXXX91+MYqiiK+//lreQE+dOtWtv4k02e2rr77Ct99+K9++Z88e3H777T43uQaDAXfddZf8KT0AbNiwAU8//TQAYO7cuW7ZCX/6058QFxeHjz/+GA8//DAOHjzodrz6+np88MEHcu+YzpAmFK5cuRJLly4F4P9EQsltt92Gb775Bi0tLW63r1y5EmVlZRAEQS45AoBbbrkFRqMRL7zwAl5++WWPPyr27NmD//73v3jnnXfk24YPH46TTjoJoijizjvvdPuEet26dXj22WeDXlIkiiKWLVuGt956C4DnpL25c+fCYDDgq6++wiuvvCJ/ut3S0oIHH3wQZWVlMJvNmDNnjtvjpPfRf/7zH7fm4Rs3bsTChQuDeh4mk0ku4/vHP/7h9gn7L7/8ovl86enpiI2NRW1tLV544QX556S5uRkLFy7Eli1bgrZGV515bzz55JNYsmSJx89HWVmZPC3T9f1HRBRqmZmZKCgoQH19PebOnevxb6rD4cC6deswb948+XdrRUUF7r33XmzcuNFt79LS0iJnPKamproN5pD2Xxs2bNAs0ews7h0hPyf3jtw7Srh35N6Reg57PFKPuPrqq7F8+XKUlpZi2rRpGDFiBA4ePIiqqipMnDgRgwYNkvu/9CUmkwmPPvoorrnmGixZsgQrV66UJ4ft2bMHd911FxYtWtTpYTcffvgh1q5dC+CPT3B37twp/+KbOHEiHnnkESQnJ7s9LjExEZdffjleeeUV3HnnnXjqqacQHx+P3377DQ6HA3//+99x//33qz5nQUEBysvLcd1112HUqFHyxMMnnngCiYmJuOmmm7B27VqsWbMGJ5xwAoYPH469e/diz549mDVrFmpqajQ3noESBAENDQ1YvHgxFi9ejNjYWKSmpsLpdKKmpkb+xNBisWDBggVujx05ciTOO+88fPDBB7jmmmswZMgQmM1mlJeXY9iwYZgzZ47XT+8vvPBCrFmzBqeccgoyMjJw+PBhuVRh2rRpuPjii93un5ycjOeffx433HADXnvtNbz11lsYMWIEIiMjceDAAezatQuiKOL000/v9PUYOXIkRo8eja1bt6Kurg4xMTHy5sZf//vf//D555/DaDQiLS0N4eHhqK2txd69ewEA119/vdsnvqNHj8YTTzyBO+64A48//jieffZZHHXUUXKphFQ6pJxOd9999+GXX37B5s2bcfLJJyMjIwONjY2orKzE1KlTcejQIfz000+dug5btmxx2+Q1NzejqqpKLts48cQT8X//939ujxk9ejT+/ve/Y8GCBXjkkUewePFipKSkYPv27Th48CCMRiMee+wxJCYmuj1u9uzZePvtt1FeXo6ZM2fiqKOOQktLCyorKzFz5ky5bClYbr31VhQVFeHnn3/GzJkzkZGRAQAoLy/HmDFjkJub61FOEhYWhltuuQULFizAU089hbfffhtJSUlyE/sHHngA8+fPD9oaJZ15b5SXl+PFF1/Evffei6FDhyI2NhY2m00e2DBx4kSPjT8RUag9+OCDOHjwIAoLC3HOOedg8ODBSExMRFNTE3bs2CH/8fzQQw8BaM8QfO+99/Dee+8hJiYGQ4cOhSiK2LlzJ+x2O8LCwnDfffe5PceMGTPw5JNPyn3LUlJSoNPpcM455+Dcc8/1e63cO3LvqDwn7h25d+TekUKNgUfqEYMHD8a7776LJ554Aj/88AN+//13pKam4qabbsI111wTsubawTB58mS89957ePrpp1FUVITffvsNI0eOxF133YVp06Zh0aJFnS5nqKmpkf8BjoyMhMlkQm5uLsaPH4+CggK3Ehmlv/71r0hOTsa7776LnTt3oqmpCcceeyz+/Oc/e526d80118DpdGL58uWoqKiQP92UsjnHjRuHt956C//6179gtVqxbds2DB8+HNdccw0uvfRSXH755arHlT4pHzhwoGqDZjVmsxmrVq3Ct99+i7Vr18oTJVtaWhAbG4spU6ZgxowZmD17tmo/on/84x8YPHgwPvnkE9TU1KC1tRUXXnghbr31Vp9lLfHx8ViyZAmefPJJfPfdd6ivr8eIESMwe/Zs/N///Z9qMDkvLw+ff/45/vvf/+Kbb77Bjh074HQ6kZSUhOOPPx7Tpk2Ty2o664wzzpDLeE455ZSAJzEuWrQI3333HaxWK/bs2YPGxkYkJydjxowZuOKKKzBhwgSPx8yYMQPLly/Ha6+9hu+//x7btm2DTqdDUlISZsyYgZNPPhnTp093e0xSUhI++OADPPXUU/jqq69QUVGBwYMH4+abb8Y111yDuXPndvoaNDQ0uE3D0+v1iImJweTJkzFr1izMmjVLtVfWxRdfjFGjRuGVV15BcXExfvnlF8THx2Pq1Km49tpr5T5ersLDw/Hf//4XTzzxBL7++mtUVlZiyJAhuPPOO3HllVfiiiuu6PR5qImOjsYbb7yBF154AZ9//jm2bduGQYMG4corr8RNN92EBx54QPVxl1xyCcxmM1555RVUVFSgubkZ48aNw1VXXYUTTjihWzaPQODvjT//+c8YOXIk1q1bh+rqalRXV2PAgAE45phjMHv2bJxxxhkwGLg1IaLeJTo6Gv/5z3+wfPlyfPLJJ/j555+xZcsWxMXFYdSoUTjmmGNwyimnyJl7w4cPx8KFC/H999/jl19+kYNPgwcPxsyZM3HVVVdh2LBhbs8xbNgwvPjii3jppZewZcsWVFdXQxRFHHPMMQGtlXtH7h2VuHfk3lEN947UkwQx2Ln8RCTbvHkzZs+ejaOPPhqffvppqJcTUq+++ioWLVqEm266CTfeeGOol6PpmWeewbPPPosbb7wRN910U6iXQ0RERHRE4t6RiKh/YI9Hom4kDZfJzc0N8UpCr7i4GBERER5lJkREREREStw7EhH1Dww8EnXRjz/+iOXLl7s1XG5tbcWrr76Kd955BzqdDhdccEEIV9g7WK1WzJo1y62JNxERERGRGu4diYj6BxbDE3VRdXU17r77boSFhSE1NRUmkwmVlZVoaGgAAMybNw+jR48O8SpD7/vvvw/1EoiIiIioj+DekYiof2DgkaiL8vPzcemll2LdunXYs2cPdu3ahdjYWEyYMAGXXnopjjvuuFAvkYiIiIiIiIiox3G4DBEREREREREREQUdezwSERERERERERFR0B1xpdZOpxNtbW3Q6XQQBCHUyyEiIiIKiCiKcDqdMBgM0On4GXJfxP0oERER9XX+7kmPuMBjW1sbNm3aFOplEBEREXVJZmYmjEZjqJdBncD9KBEREfUXvvakR1zgUYrCZmZmQq/Xh3g1/Z/D4cCmTZt4vQPUUHMA697+Cpt++RXGUcmYfdksJCUldtvz8XXqO/ha9Q18nfqOvvhaSWtmtmPfxf1oz+qLP+e9gSiK2PT+t1j/9XociBVwwjnTMWlSXrc9H1+nvoOvVd/A16nv6Kuvlb970iMu8CiVs+j1+j71gvZ1vN6Bqf1hK35/Zhla4cC7y77A8NFpOOusU7v9efk69R18rfoGvk59R198rVii23dxPxoavN6BEZ1OrLvzVQDABrEO68q24pOl/+325+Xr1Hfwteob+Dr1HX31tfK1J+VH5URERERERERERBR0DDwSERERERERERFR0DHwSEREREREREREREHHwCMREREREREREREFHQOPREREREREREREFHQMPBIREREREREREVHQMfBIREREREREREREQcfAIxEREREREREREQUdA49EREREREREREQUdAw8EhERERERERERUdAx8EhERERERERERERBx8AjERERERERERERBR0Dj0RERERERERERBR0DDwSERERERERERFR0DHwSNQLCfr2H81I6DDCGIv33/4EbW1tIV4VERERER2JhgmRqCz9Ddu37wr1UoiIqI9h4JGoFxo2LQt6cyTCIeAEIR6GwiqcOu1CNDU1hXppRERERHQEEHQ6pJ01CQAwChE43TkYs469ABuKSkO8MiIi6ksYeCTqhSLizbj460cRlhgDAwSMhQlN5XvxwQfLQr00IiIiIjpCnPrM9bBcNh0AMAxGjNEPxF//8o8Qr4qIiPoSBh6JeqnopHic8sR1AAADAKNgwIG6+pCuiYiIiIiOHIJOh+kPzYU+OgIAEAE9DtYdDPGqiIioL2HgkagX00cYQ70EIiIiIjrC6YyGUC+BiIj6KAYeiYiIiIiIiIiIKOgYeCQiIiIiIiIiIqKgY+CRiIiIiIiIiIiIgo6BRyIiIiIiIiIiIgo6Bh6JiIiIiIiIiIgo6Bh4JCIiIiIiIiIioqBj4JGIiIiIiIiIiIiCjoFHoj5AABCm0+PQocZQL4WIiIiIjlB6CGhtaoEoiqFeChER9REMPBL1YqbUgQCACOgwVTcQn//rQ7z2yrshXhURERERHUmiBw8AAIxDFMY2mjH7zCtx+PDhEK+KiIj6AgYeiXqxmKGJmPLQlRAFYCAMmGlMxbN3PYOln60K9dKIiIiI6AhR8OIt0MdHIxwCpujioC/Zh4svvC7UyyIioj6AgUeiXi7zspNx8rM3AABioUOi0YQvV38X4lURERER0ZEiNi0Jl//vCQhGA/QQMFiIRNEPJaFeFhER9QEMPBL1ASn5llAvgYiIiIiOYOGx0YizpIZ6GURE1McYQr0AIiLyn9PpRHV1NWpqapCSkoKcnBzodPwMiYiIiIiIiHofBh6JiPqQ0tJS1NTUAACqq6sBAHl5eaFcEhEREREREZEqpskQEfUhtbW1Xr8mIiIiIiIi6i0YeCQi6kOSk5O9fk1ERERERETUW7DUmqgPEQAYocOB/XWhXgqFSFZWFmpqaiAIgtzjkYiIiKgnhQkC9E6gsbEJUVGRoV4OERH1Ysx4JOoDIuLN0EUZIUDAiUI8Dn5dgZtv+BucTmeol0Y9TKfTYfDgwSgoKEBeXh4HyxAREVGPGThqCADgKNGIgsijMC3/TFRXs+0LERFp41+sRH2AIdKIM9+8C2K4AVHQYbo+AT9/vA4PPfRUqJdGREREREeIExZeidisNOggIBNRyLKbcdq0C/lhOBERaWLgkaiPSJlgwWXfPQ4AiIAOCfoIrP1ufYhXRURERERHCqMpEhd+ugCmtCQAQKJgxP7a/Th40B7ilREFptBmQ0FpKYasXYuC0lIU2myhXhJRv8Uej0R9iGnwQEAQAFEM9VKIiIiI6Aik0+swKGsEGip3h3opRJ1SaLNhakkJRFGEA0BtSwu+rK/HN9nZmBIbG+rlEfU7zHgkIiIiIiIioiPCwspKOegIAA4AoihiYWVlCFdF1H8x8EjUR4jMciQiIiIiIuqSTYcOyUFHiaPjdiIKPgYeifoQ1+CjDjq0tLSEcDVEREREdCQTAITpdGhtbQv1Uoj8lhkdDb3iNn3H7UQUfAw8EvURgiBAEASExbf/QsyHGeG/HsTtt93HSYJERERE1GPMqQkAgBTRgALTSJx10hzs3r03xKsi8s/8tDQIgiAHH/Vo/1vrnrS0EK6KqP9i4JGojzntpVsgGvWIhg6nGAZh03uFuPuuB0O9LCIiIiI6QuTecBbMo4dADwHjEYWcOhOmHXs2q3GoT5gSG4tvsrMxIz4eqUYjZsTH49vsbEzmYBmibsHAI1EfkzppNC5e8ygAIBwChunNWLn0yxCvioiIiIiOFOExUZjz+YOIGzMUAgQkC0aI9c34+eeyUC+NyC9TYmOxIisLuyZPxoqsLAYdiboRA49EfVDs8CSED+IvRyIiIiIKDZ1Bj4yCY0K9DCIi6uUYeCQiIiIiIiIiIqKgY+CRiIiIiIiIiIiIgo6BR6L+QBRDvQIiIiIiOoLpBAEiuCclIiJ3DDwS9VHGmCgAgAWRSD1oxL3zH4HIACQRnE4nioqKsHz5chQVFcHpdIZ6SURERP1SeFw0AGCgqMeUqFTcctWd2LfvQIhXRUREvQkDj0R91LRFcyEadDBDh1MNSdjwyle45eb5oV4WUchZrVYUFRWhqqoKRUVFsFqtoV4SERFRv2SZfRxMlsHQQ0AOopG9NxInTjgTdntDqJdGRES9BAOPRH3U4ImjMeerRwBBQDgEWAwx+OTdZaFeFlHI1dbWev2aiIiIgsNojsKcFQ8hPjMNAgSkwoioQ8CaNd+HemlERNRLMPBI1IfFHZWCgdlHAQAEgCWlRACSk5O9fk1ERETBozcakHPVaQDa96OCIMDhcIR2UURE1GsYQr0AIuoaQQj1Coh6l5ycHADtmY7Jycny10RERNRNuB8lIiINzHgk6uMEXfuP8QDRgGS9GV9+9V2IV0QUWjqdDnl5eZg5cyby8vKg0/FXHRERUXcShPbftRHQYVhYDD77eAUrcYiICAADj0R9XuZlJwEAEmHAeeHDseDie/DSS6+HeFVEREREdKQYcmImdNHhCIeAE4V4OL6uxMwZc3D48OFQL42IiEKMgUeiPs5y7nGY+tR1AIA46DExPAkL734MDQ2HQrwyIiIiIjoSRA4w4+I1j8IwwIQwCMgUYmD7uQbvv7801EsjIqIQY+CRqB84+tzjkFYwAQAQDgGC04lDhxpDvCoiIiIiOlKYBg/Eqc/cAAAIAxAuGLB334HQLoqIiEKOgUeifsJojgz1EoiIiIjoCBYWFR7qJRARUS/DwCMREREREREREREFHQOPREREREREREREFHQMPBL1M5HQIdEYg5KSzaFeChEREREdgQwQMFAfieL1VoiiGOrlEBFRCDHwSNRPpM3IAQAMFPWYHT4MD1x+Pxb/+60Qr4qIiIiIjhQDRw+D3hQBAwScIMRB+L4KZxdchqamplAvjYiIQoSBR6J+4qjTJuC4R66CCGAADJhqTMaDf/0ndu6sCvXSiIiIiOgIEBYdgQtWPgh9fDSMEJAvxOBgaQ2eeeaVUC+NiIhChIFHon5k3MXTMO7KGQCAcEFAtD4cVdW1IV4VERERER0pYocn4fyP7wMAhENApD4M27ZtD/GqiIgoVBh4JOpnBmSkAgDiRT0mRqbg7lsWoL7eFuJVEfUtTqcTRUVFWL58OYqKiuB0OkO9JCIioj4jMiEWEAQIEJArxGD9J4X49tsfQr0sIiIKAQYeifqZjHMmIyptEAwQkItojKnS44T8M9DQcCjUSyPqM6xWK4qKilBVVYWioiJYrdZQL4mIiKjPCI+NRub1MwEAQ2DEOYah+Mv587By1dchXhlR71Jos6GgtBRD1q5FQWkpCm1MGKH+p8cDj59++inuvfdenHvuuRg3bhxGjRqFjz76SPP+DQ0NePjhhzFt2jSMGzcO06ZNw8MPP4yGhoYeXDVR32E0R+Hi1YsQc/QQ6CBgGMIRYRexihs9Ir/V1tZ6/ZqI+j7uSYm615S7LsLxj14FAEiAASPD4/HME/8O8aqIeo9Cmw1TS0qwuq4OVS0tWF1Xh6klJQw+Ur/T44HHp556Cu+99x6qq6sxaNAgr/dtbGzEpZdeitdeew0jRozAlVdeiZEjR+K1117DpZdeisbGxh5aNVHfYogw4pibzwYACBCgg4DW1rbQLqqfY2lu1/Wma5icnOz1ayLq+7gnJep+Y+dMA/Ttf3LqIKC1jftRIsnCykqIoghHx9cOAKIoYmFlZQhXRRR8hp5+woULF2L48OFITU3Fyy+/jMcff1zzvv/5z3+wdetWXH311bjjjjvk259++mk899xz+M9//oObb765J5ZN1OcIghDqJRxRpNJcAKiqap8knpeXF8ol9Tm96Rrm5OQAaM90TE5Olr8mov6De1KiniEIgBjqRRAFoNBmw8LKSmw6dAiZ0dGYn5aGKbGxQX+eTYcOyUFHiaPjdqL+pMczHidPnozU1FSf9xNFEUuWLEFUVBRuuOEGt+9de+21iI2NxQcffABR5K8xIm/CISAlzISvVn/Hn5duxNLcruM1JKKexD0pUc8ahHDU/laNPXv2hXopRJp6svw5MzoaesVt+o7bifqTXjtcprKyEnv27EFubi6ioqLcvhceHo78/Hzs3r0b27dvD9EKiXq3wceOhhARhnAImCYMwKFVv+LcM65Ac3NzqJfWL/VEaa7T6YTVakVZWRmsVmu/K+fuTeXNHC5DRBLuSYm6JnVaNgBgNCJwmiMFp+afjc2bfwntoog09GT58/y0NAiCIAcf9WivWrsnLS3oz0UUSj1eau0vafOWpvFDN3z4cPl+WvfxxuFQJjVTd5CuM693zzPGReP8VQ/ig7Puh9HWiFwhFh8Xbcebb32IK6+40O2+fJ26bvz48RBFUS7NHT9+fNCvp9VqRXFxMQDI/9+fSoB74hp643Q6UVpaitraWtjtdrfv1dTUBLQW/kz1HX3xtepLa+0PunNPyteyZ/TFn/P+5NTnb8CqW17Ars834CiEY6w4ADdc81es+d/Hbvfj69R39OfXaqNG+fPGQ4eCfr6TTCZ8lZmJh3bulMu6/z5sGCaaTEF5rv78OvU3ffW18ne9vTbwKP3RZzKZVL8v3a7849BfmzZt6tzCqFN4vUMn4y8F+PW+DxEGAVF6I4qLS5CdNUr1vnydukYQBKSkpAAANm7cGPTjl5eXe3zd33p5dvc19Ka6uho1NTWq3xNFESUlJQEfkz9TfQdfK9LSnXtSvu96Fq936KRcczyqvtkIsbEF0dCjtqpa8/cqX6e+oz++VsMdDtQCcK0r0nXc3pm9oC/RAB4EgPBwoK0NJWVluLOlBRVOJ9J1OlxlNCLb0LWwTX98nfqr/vpa9drAY3fLzMyEXq/sqEDB5nA4sGnTJl7vEDoYn4Jf8SHCIeAYXTxWfFSIC847G8cdP1G+D1+nvkEURTnTEQAyMjKQnZ0dugX1M8qgo9lshtlsRnJyMrKysqDT+d+dhD9TfUdffK2kNVPf15fed31ZX/w5749+HTYIB3/ZhQxEYldLDN55aykWPXqP/CEqX6e+oz+/VotsNpy0cSMEtGc66gEIAB4ZNw7ZMTHd+tyFNhuu27gRYsdzH3A48FNTE74aP75Tw2368+vU3/TV18rfPWmvDTyazWYAQENDg+r3pdul+wVKr9f3qRe0r+P1Dp34owZj9FWnYuviVRgKI2bph+LmC/6CZz96CscfN9Htvnyderfc3FwA7ZmOGRkZyM3NDSgYRt6lpKSgurpa/tpisXR5qjZ/pvoOvlakpTv3pHzf9Sxe79CavugqfHz+QphagVMNg7D6vR9xY8NdePHlx9zux9ep7+iPr9UJAwbgm5wct6nW96SlYXI3TLVWenjnTjnoCPwR+Hx4506sGDCg08ftj69Tf9VfX6te+xer1C+nUqOJq9RvR7ofEWk78f7LMPHeiwEAg6DHEGMcXn/t3RCvigKl0+mQk5MDi8WCnJwcBh2DLCcnB3l5eUhNTUVeXl6X+mcW2my4qbERw9atQ0FpabdMQiSinsE9KVFwJOdl4OI1jwJ6HYwQkKGPwbIPVoV6WUQepsTGYkVWFnZNnowVWVkeQcdCmw0FpaUYsnZtUPd5mzT6S246dCgoxycKlV6b8ZiWloZBgwahuLgYjY2NblMEm5ubsWHDBgwaNIibPCI/jT7vBKxb8DYEtJeztLX1r4nIRF2l0+m6nOEItG9GT9q4EU4ATocDu1ta8GV9Pb7Jzu5UmQwRhRb3pETBE5uWhMTcdOz9qQwC2tvIEPUlhTYbppaUyJOva4O4z8uMjkZtS4tb8FHfcTtRX9Zr02UEQcD555+PxsZGPPfcc27fe+mll2Cz2XD++ef3u8EKRER9ndPpRFFREZYvX46ioiI4nUdWkHthZSVE/NGU3IH2P6wWamRLEVHvxj0pUXDxR4WCrbsyENUsrKyUg45AcPd589PSIAgCpEJbPdp/B92TltblYxOFUo9nPC5ZsgRFRUUAgLKyMvm29evXAwBOPvlknHzyyQCAq6++GmvWrMF//vMfbN26FWPHjsUvv/yC7777DqNHj8bVV1/d08sn6rME3R+7vGFCFNav3Yi9e/cjMXFgCFdFneV0OlFSUoLa2lokJyf3qtJrq9Uq/ztfVVUFAEHJJOwrWCZD1DdwT0oUGkLHfiVe1GNwWCyWL/8SM2eeHOJVUV/VnRmIarpznzclNhbfZGeHpL9ksBXabG7nMT8tjZU/R7AeDzwWFRXh448/drutuLhYntSampoqb/KioqLwxhtv4Nlnn8WqVauwfv16JCQk4Morr8SNN97oVupCRN6Fx0Yj6djR2P3DVoxHJKKbdJiRPwvvffEa0tNHhHp5FKDS0lL5383eFtyrra31+nV/xzIZor6Be1Ki0Mi8/GTU/vgLEmDAeeHD8OhVC/H73ypx/Q3/F+qlUR+kloGo78hAXJGVFfTn6+59ntRfsi/r6WAw9X49HnhctGgRFi1a5Pf9zWYz7r77btx9993duCqiI8NZb92JFdc/g10rizAS4ah0xODuOxdiyYeLQ700ClBvDu4lJyfLwVDpa6fTCavV2iszNINtfloavqyrgw7t5dYskyHqnbgnJQqN9DMnQQTw5fXPIhZ6TDIOwj/vewqXXDo71EujPqinK03mp6Xhy/p66DuCatzneerpYDD1fv3zrz4iUqUPM2Dmy7cCAAQIiBAM2Fu7P7SLok5JTk72+rU/uqsXo9p0aKn8uqqqCkVFRbBarUF5rt5oSmwsvho/HhP1egw2GjEjPh7fZmf3yTIZIiKi7pBx5iSkz5oEAAiHDmHQw2azh3hV1BdlRkfLPREl3VlpIpVDz4iPRyr3earYdoiUeu1UayLqHoIgICIpDod31yMbJhzYvhd/u+tBnH/h6aFeGgUgKysLgiC4ZRAGqrt6MapNh+7NGZrdYUpsLJ6JikJ2djb0euV2mIiIiOJGDgYAJIl6zDCNwCWz/oR/PP7XEK+KukN39vsLRQZifyiH7k5sO0RKzHgkOgLNeOYGiGF6mKDDqYZBKH3rf3jm6VdCvSwKgBTcmzlzJvLy8gIuW3Y6nfIwBUl3BgODkaFJRERE/cf4q06DaVQq9BCQhSjk1EXjhrl34fDhw6FeGgWR1O9vdV0dqlpasLquDlNLSoI2eZoZiL0Pp3OTEgOPREeg1GNHY85XjwAAwiFghN6Mwq/Xh3hV1JOsVivsdveSpu4MBqqVX/dlnSlT767S9iMFrx8RUf8SHhOFOSseRPy44RAgIEUIR3iTgOLiTaFeGgWRWr8/saPfX7BIGYi7Jk/Giqysbg06FtpsKCgtxZC1a1FQWhq0AGqonyuYGAwmJZZaEx2h4kYkI3pYIg7t2ItYwYCwwwK2b9+Fo44aHuqlUQ9QZjeazWY5GNgdg2DUyq+7ItTDajpTpt5dpe1HCl4/IqL+Rx9mwNHnTMEPm7cjQhSQGGbCT+tLcPzxk0K9NAqS/tTvL9jTmr2VoPf1ydAsRydXzHgkOoKNOKX9j/Y00Yhzw0dg9nFz8H3huhCvqv/xN1OrJzO6lNmNFotFDtwFexBMd5xXqIfVdKZnZU/0uezPWYFHWp9QIqIjRepxYyEKAkzQ4XRDMlY/9gHuvOMBiKIY6qVREPT08JfuFMzsTV8l6D2RKUrUUxh4JDqCTbnnYlgumw4AGAojJuuTMffim0O8qv7H3yBZTwbTvJU+BzvA0x3nFeogVGd6VvZEn8tQB2S7E/uEEhH1TwljhuPMd+6CaNDBBB2OC0vEyleX4bv//RjqpVEQ9Kd+f1rZmxvs9oBLon0FFr1livbVEmxf+ut5EUutiY5ogk6H6Q/NxZ4N5ajfuhNRggEN9Q2hXla/42+QrCeDacrSZylTrra21iNLrqsBnu44r+TkZLncVvq6J0mB2kCminfmMYEKdUC2O/XE9SMiotAYMmUsptx3Kdbe8zqMogCTIRw7d1T5fiD1elK/P9eS4nvS0vpkvz+1ac06APvb2rC6ri6gkmhfJehak6GHhIf36RJsLX29tJy8Y+CRiBB7VDLqt+7EYNGAY03DcNWVt+Kl/zwGg4H/RASDv0GyUAbTXPvnAUBKSgp0Ol1QAjzdcV6hDkJ1pmdlsPtcqgl1QLY79cT1IyKi0Ik7qv13VjQE5Icl4l//eA5TphyDESOGhXhl1FX9pd/f/LQ0fFlfD31HcEyP9mChruP/0fH/+o7MRW/nrBVYlErQ1Z5LEAQA8MiU9Of5vPHWa7KnqGWAdvW8qPdgVIGIcMxfZmPbV1ZEHm7DNN0AfP9lOc4+4wosW/lWqJfWL/gbJAtlME2ZGafT6TBz5sygHLs7ziuUQaieHGwT6HN15VqHemAPEREd2QYfOxqRmUPQtGkXRiMSEc0JmDn5fCwrfJ/DD6lXUMve3NDQgH2trW7382d4jlZgUSpB18oUveDnn4M6rKe3ZBr2pyFE5ImBRyJC3MgU5L4wF5tueh1oOIwMnRlv/rgZO3dWYejQ1FAvr8/zN0gWSDDN6XSipKQkaEGi7syU62+Zaj05XTnQ5+rKtebUaCIiCiVBp8PYf5yHPYsLsWP5TxgsGpEimPHe+5/i7rvYg5x6B2X2ZkFpqVxmLfFneI4/JehqmaK+MiUDUWiz4exNm9DmMsgpVJmGwTwv6n0YeCQiAEBYfDSOPv94/PzqaoRDQJwxCtsqdzLw2EuVlpaiuLgYQHCCRKEuXe5L2XY92Uexvz4XERGRGkEnIP/6M7Fj+U/QAzDrwlBR9nuol0XkxrU0eUh4OIA/yq4DGZ7TmRJ0X5mSgZzD1JISt6CjJBSZhsE6L+qdeudfdUQUEoNyRgIAEkQ9zg4fjtvPn4dPP10Z4lWRmmAHiaRMuZkzZyIvL08z6CcNoVm+fDmKioo8BtF0Vk9MYw7W2ntyunJ/fS4iIiIt5uGDoIsIgwECThTiUbfyV8y94ha0tbWFemlEcsBudV0dqlpasMFuBwDkm81INRoxIz4e32Zn+z08J9BJzlKm5Iz4+E49n0TqqagmFJmGwTov6p2Y8UhEspFnTkJd5W6UPPExkmDADGMqbvu/u5BbmsnMx14mOTkZ1dXVbl/3hO4qx+2JbLtgrb0ns0N743P1pexUIiLqe4ymSJzz8X34cPYCRDa24AR9PD79YhMef+JF3PnXG0O9PDrCzauo8CxN7vjvzOhobDp0CA9UVvo1oKWz/RWDMaxHraeiJFSZhv1lCBF5YuCRiGSCIGDSbbNxeLcNv7y1BlHQI0YfgbLy3xl47GWysrIgCEKPl0Z3V4CwMz0mAwmAOZ1OlJWVud3W2bX3ZM/K3vhc7AVJRETdLXFcGi5a8SDePfEOREAHs96IzRu3hnpZ1EN6w5RlrXWt68hwdOUAsM5ul8ut/Q0gLqyshFMU4XQ5jq6H+iuq9VQEgASDAZ9mZjLTkIKKgUci8jBo/Aj88hZgFnUYF56Ip//5EiYfm4/IyMhQL406qAWJOpuJFsjjumsITWcy+wIJgFmtVtgVG0WWEncOe0ESEVFPiE6OBwQAInC0YMbqb0qwceMWjB8/JtRLoy7wFVTsLVOW1dZa56Pc3+Hy/1oDWgptNsyrqEBJQwOaVUqdnYBcvt2dtHoqugYde2sAmPoeBh6JyMNRBRPww2NLgL0HcawQg9LNDZg6aRbWrP0E0dFRoV4eaehsJlogj+uu0t/OZPYpA141NTUoKipSDaAq72s2m3t8gE5/0Z0T0ImIiCRhURGwzJmGsre/xlEIxyxhCC6fcRWe/uBJnHD8pFAvjzrBn6Ci1HvQnyBeT661qqUloMc7AHxRV4eC0lI5YFdos+FEq1WzxLkn+Zqq3ZsCwNT3sSkTEXmIiDfh0q//iahhidBDQDqiINQ2YenSVaFeGnnR2Uy0QB7n7xCanqAMeImi6DGgRhooc/DgQY/HS98PJun5VqxYgerq6qAe35/hON01/MdVTk4O8vLykJqairy8PAZwiYio20xbNBe5t88GACQjDEcbB2Lh/Y+HeFXUWWpBRbEjqChR6z0YyJTlQIe1aN1fuVZvYvV6uc+jKyeA1XV1mFpSImcP+nM8m8Ph9/q7QuqpuGvyZKzIynIrr/bntQqEr9cl0Nets4+h0GDGIxGpCo+Nxgn3XYqVVz2JMABReiNqd+8J9bK6pL8MxRBFEVarFbt373Y7j85movl6XG+6bq5rSUpKQm5urnwd1AKortmcAGA0GtHS0gK73S7fLmVaBuM8lc9XWlqK/Pz8zp6u5rG1MlN7ov9iT/adJCKiI5sgCDjmlnNQ8sxSOJtbEQUDKmoPQBRFCIIQ6uVRgPwJKqr1HvR3ynKgWXre7u9t+IpEB0AnCFh01FG4qaJCLltWnp+Uselv8LRVFFHV0qK6/kDLn0va2vD3zZuxOcByaa3X6uv6ehTabAFlPfp6XTqTXcmMzL6FgUci0hQ3MgUAEAkdTtYn4sNFbyHWbMbcqy4O8co6p78MxaipqUFNTQ0A9/PobBl0Tk4ORFFEeXk5gPbAptPplINuwbhuwQpeKtciZV8CkLMdJWrBSOUfKa7fD+Q8tc5HLfipDJYC8Aga+3N9/MlMZf9FIiLqj6KHJcJeXo1sRKPZ1opzTr8c73z0MvuP9zH+BBXnp6VhdV2dx2P9mbKslqUHUcS8igr8qLKn81bWrTV8xZUTwHPp6bguNRWZJhMWVlbii7o6KOtNpOBqZnR0QCXbyjLzF6qqcH3Hfh0AavwIrF7b1AQ0NQUcnNM6/2ZRxNSSkoACfL7K5ztTXt9bSvLJP30v1YeIekzcyMGY8vD/QRSAATDgnLAh+OieV3HbzfO7pYSzu0nBOq2vu1uwymAbGhrcvpaCS50tg9bpdBAEAXa7HXa7HcXFxbBarR7H1/raH1JQz7UMujO8rUWtBFiZvTlgwAC3r12/H8h5ap2P8vmSk5Pd7ltcXIzi4mKPx/lzfdSO3Zn7EBER9TVnvDIP+gEmGCFgshCHwZsbMG3CLNTU7A710igA89PSIAiCXJYsDTTxJ6joOYbFk1aW4jq7XbUMVyurb4PdLq/VGz2AT/ftc7stTOUxUnB1flqaakk2ACSEhSFc5bFS0LLQZsMNLkFHoD3w6fRS/vzQzp0Q4T70xt9yaW/nH2jJta9M186U13e1JJ96FgOPRORV5qUn4az3/w7RaEA0dDhFPwh7PyrFWadcgkOHGkO9vICIislxyq+DRSvAGKzgm8lkcvs6GMElb0G3QINZaucfrEw8b2tRC7wqg5EFBQXy17m5uRBFUV6nlI3oz3lqnY/0fIMHD0ZKSgqysrK8nqv0PX+ujz+9Fdl/kYiI+qPYtCRc/r8nEDN2GPQQMB7RONEWi9MnnIuioo2hXh75SRpoMiM+HqlGI2bEx+Pb7GyP3oJq/Al0eSvHVnt8ZnS0akBkf8f06m+yszHRbNY8pmtQcGpJCVbV1XlMqnYNrk6JjcW3OTmYaDYjXBAQLgiYaDajMCcHe6dMwbS4OI/ApBS0XFhZqRp8dUI72Lbp0CHN7EtfpNfKWzDUX5nR0ZrnVWizoVklGcNXeb23Y1Lvw1JrIvIpddJoXPrtY3jvzHuAfXYcI8Rg2ZY9ePDBf+Ghh/4W6uX5TZkB2F19CrVKdoMVfEtJSUFKSopbuW5Xeevz6KuEW1kmLIoiiouLAfxx/sHqIxloOblaP0Lp66KiIrfXKTc3V36dfB1b63yk53M4HCgpKVHtvak8jrfj+TqXztyHiIioLwqPicJFyx7AF395EZUf/4ARCMckIQmXnHcttv6+lj0f+whpoImWrmSyzU9Lw0qVMm3puP7eXwDkkt3H09Mxr6IC6+12j8CfDkCz04mTSkrQppHQMCoyEv8++mg5uDolNla17Ftaz5f19XKvSNeg5QU//6xx1u1rUOu7KJVLu4b1AgnOTYmNxbS4OKyuq+tUz02J1nnNSkjA1JISOFWunQPArISEgI/pT/Ys9TwGHonIL+YhCbjky0fw3+zrYYSAaF0Yyn/9PdTLCkhnh68ESivAqPX8vWF4i7eAnq9gljLQajQa3b5fW1uLgoICzeOrHQMI7tAXJafTibKyMrfbysvLERMT49dzBBIAdb2vlFX59d69+Nhkwj+amzG+tBR/O+oo5Pl5PCIioiOVzqDHaU/fgHe27IDt1yqYBQMOHjgIh8MBg4F/2vYHXRkuMyU2FhPNZqyz291u13r8lNhYJISFYV9rq9vtUhahsqeiK13H/Q60tXlkFbra09rqltHpa/3fZGe7DY+5Jy0Nk2NjkRkdjRpFEFFyoK1Nte/i34YOxZd1dRDwR6m6A8DYIAQNAwnwaZ3XAx19GtXOSQfgpooKZJpMqr0kvV0r6n34rzMR+c0YEwXodYDDiUzBjOVrt2LNmu8xffpxoV6aXzo7fCVQWgFGrecPdHiL1nCZruhKppwy0NqiaJqdnJzs8/jeskG7YyiQ1WqFXbEplXpc+vMcgVwv5X0LbTb87dAhiA4HHA4Hdrs0+p7JbEUiIiKfBmSkwvZrFZJFA/Kjh2DerffiyacX9vgHtxR8XQ10PZ6e7jbt2NvjC202QCXbTg9gSHi4R09FSbggwKzX+ww6Au1BwUBoZYRK1wUqgTonAEFlsMqU2FhcZDDgLcUaHt+1CyMjI/Hn1FS/1pRnMqGkoQEGANkmE55ITw84wKd2Xt4mh2udk69jUu/EwCMR+U0fZkDOLbNgfeJjDEYYZhuG4c45d2L+y/dg1qzTQr08n3qqDFUrwKj1/IGWYGsNlwkVtVJis9nslj3oS1JSktsxXPstKs9v8+bNABBw5qNr5uTBgwfdvqfX6+Fw/LH1cX1O6XE1NTUQRRE6nc7ndGrpvuPHj4der3d77gdjYjiFj4iIqAvybz4H21ZbEdXcipP1CfjfxyW4oOpqfPDxK6FeWsgU2mxu2V/zO3oK9tb1aH2/q5ls/j5e6suoLPPVAXLZvlY3+ISwMADwGXQEgAEGQ6deG7XHSOelNTl7ZV0dJhUV4fH0dPn4yzUCn/du2+Yz8ChdI9cgblFDg1+DfvwxJDzc65RvDovpPxh4JKKATLxtNmJSE/HtvJcxAHqMMg7EY4ue6xOBx54SaIAz0BJwk8nklq0XSMl4d5Qt5+TkoLq62m1KuMViCVqQV3l9mpub5QxI1+fwdW6umZNKgwYNclu/6zVVe5zreqqqqlBWVgaLxeLW3xIASktLkZ+f73aMrUYjHB0bVom/G6veUJZPREQUagNHD8Ul3/wT70z/K4xNLRitj8EbXxdh+/ZdGD58SKiX1+OUAaJal2qKUAQffa3H1/e1Mtn8DeD5kwm3UKPMd4DBgE8zM732VJTKtrVKn11dmZzs87VRntdZCQm4uaICzo71VbW0YFVdHZ7LyMCKrCwUlJZ69F2UrLPbcaLVim9zcjDJZMJBlfsA/mViSteoOz4sL7TZsEFRfaTEYTH9BwOPRBSw0RecgML730CbvQkm6GHbsw+tra0IUwRTyD+BloB3ZbhMd5Qt63Q6zJw50yMgFojdu3drfi0da/PmzWhubpZvV2ZCFhcXuw21EUUR+fn5mvd3zcrMyspCaWmpx/rVekGqsdvtKCoqglkx+VBtanVqSwsOGgxwujTB93dj1R2vHxERUV9kHpKAcZefjI0vfY4wCIgNi0RVdc0RGXjszgBRd6ynM+sNdnDVW5mvr56K96SlQQSwSmOQDQCEAbhlyBBsPnTI67mqndfKujq5h6REBHB9eTme3bULEATNtUvPsbCyEsvGjUMMgHqV+wzw0RO10GbD1/X1qoN+fAUM/eFrSjmHxfQvDDwSUafEZQzGvuLfMA5RcLQMwMlTzsXHK1/HgAHxoV5anxNohqQgCMjOzoZerw/4uYIxWVsr687XOXjL1lNmNTqdTjidTuh0OvnYyqxKp9N9K1iu6MNTXl7uFnhUPofFYkFOTg6sVitWrVqF5ORkFBQUeGRJKntBBsJ1gJDk9P37sTUqCnq0b950AERRxPnNzfI5awnWZHQiIqL+YODoYQCARFGPsyKG46Zzb8Gjbz2Ck6YfH+KV9ayuTILuDr7W05n1qgUrIYqYV1EhT4l2zRwcEh4OANjV3KyaHalV5ruvrQ2FNptqT0UBwAsZGXLZ9kCDAfs0MgedAP5VVYU4vd7ruaqeF7TLuLc0NWl8x510/GuNRjyicp4LR4zQfKwUDNWa1L2/4xp1JZtWK/AbLghICAvjsJh+hvVZRNQpMxf/BZFpg2CAgFyYkF8TjpNzz8Kvv1aEeml+cTqdKCoqwvLly1FUVOQRxOqva1CWZbt+rbYetdukrLuqqioUFRXBarX69dzeHpeTk4OUlBT565qaGo/jCi4ZgsqvnU6nWzakmpycHOTm5sJsNsNsNstl0d7ORRnYMxqNGDx4MFJSUmA2mz0meIuiiJSUFPk+WR2f2ruuNf3wYczbuRPH6PVIFASMPnQIt+/cibaSEp/X0tvrR0REdKSxnDsFY/7U3u5nMMJwnmE4Flw8H88/92qIV9azMqOjofw4OpRlqr7W05n1agWq1tntKLTZ5GDZF3V1qGppwTq7HevsdlS1tGB1XR2mlpS0D5Pxw7yKCrlX5Cnx8Ug1GnFafDy+z8nBtS59EfPNZo/zkDjQvi+Uzk3rXL1lXnaFdPzzw8Px7MiRSDAYoAOQYDDgxYwMt/NQkoKhWgSoZywW2mwoKC3FkLVrUVBa6vV6a70HpsXFYdfkyViRlcWgYz/CjEci6pTIhFhc+uUj+OxPT6L2643IQARMjsG4+MTL8fDrD+GUU6aGeole9YaS1VCswVtZt9p6AHjc1tmsO+X9ysrKvPYqVN4/JSUF1dXVbl+7rl05TTsjI8Pta51OB0EQ5AzG4uJij9LosrIyr5mYmZmZAODW8zElJQUNDQ2w2+1oaGhAQ0ODXA4vHUe59vTDh3Fix4Ab1+N7u5ZOpxOiKMprzsjI6LbJ7ERERH2BIAg44d5LkTh6GL6e9zLiRT1mhaVi1YPvYtPGrXjuhUVHRC/krk6C7un1dGa9mdHRmoNI5lVU4LemJs0MPbVS7l1ePrCWgplKyqMrz0PteSEIEARB81wzo6NR29Li9nhB5bkCoUd7OXihzYa7GhuxfedO5JvNfg8c2tDQ4DUY6oRndmqgpfC97T1L3av//ytMRN1GHx6GWf+9A5nXnwEASEEYjgtLwXVXzEObHw2LQ6k3lKx6W4NW9qHVakVZWRmsVmunMiSlsuWZM2fKQU7peZS9DGtra1WDhcqJ0P5m3SnvZ7fb3TINfWXz5eTkIC8vD6mpqcjLy3MLuqn1b8zNzZW/lq6nNBFb0tjY6LEmZSam8jmVz9XQ0OAR9KypqXErC1dmdErnpzzHpKQkzSxYq9WK4uJi2O122O12CIJwRPwxRURE5Mvo80/A7E/vB4wGREGHSfoBWP/R91ixck2ol9YjpOy8GR3ZeTPi4/Ftdna3ZIwV2myYuXkzChoaMHPzZtUAna/1dGa9870EpNbZ7ZolzxJlKbevbNB5FRWYWlKC1R0ZlGpZk67nEa6ozAHag2n5JpPXcz0rIcEtyKdD4EHHWL0e4YKAcEHARLMZ3+XkQARw0saNWOdwoDqArM9Cmw37Wlu93kctO1WtZFzsCPaqCfQ94JpNOamoCJOKivzKrKTegRmPRNQlgiBgyt0XoXb9r9i7oRxRggEtjc04fLgZJlPv/Scm0EnSPb0GrexDaXhKcXExBEHocoakt0nP0npcn9+136HZbJb7JPrDNdvy4MGDbseqra1FQUGB/N9SFqS/U5yV11I6N+n+WufpcHh+nuua9ejau1JaizLwqtUDsqGhQf5vXwN4pNtEUdTMgu0NwXIiIqLeKiknHdMfvRprbn0RRgiINoRj584q3w/sJ/yZ5NxVyqy2L+vq8JVGVpuv9QS63imxsZhoNmNdJ3tv69He17GgtFTuAakc4OKqpKHB51AY10nUT6an4+aKCvkxrhl8k13OtdBmwwMufSg32O1u6+hM46XU8HC8PGqU22tQUFoK0eV4/g4cWlhZ6fW6aGUmavXt/Lq+Xu4HqTaV3J/3gPJ955r5GuoJ7uSf3hsVIKI+JT59MPZuKEeyaMBx5uG4+vJb8N93nkN4R2Pn3ibQSdI9vQZ/gkzBCDx5m/SsXI8yWBgTE+MRlPMWIHQN4hUVFbkFApOTk1UH1LjeT60cXXrempoat5Jnacq0dH/leQqCoNm7Rsp6VK5FGbw0Go1wOByqwUsAMJlMmufvyvW25cuXu33Pdd29IViuxt/gMBERUXeLHdH+uzEKAiYYBuLlhxfjxBMmY/ToDB+PJH8EOo1aLdDUleDQ4+npbgEoaVCfv6RpzFIpsAAgWqfDIUUVkdR7UGsojFZZ8dPp6Vi6b598vrMSEuQgY2Z0NMZGR+OJXbvkjEat0vFAbWlsxIlWK77NyZGvb2cHDm06dEg16BgGYJDRqDn0Ra1kHACaRRFTS0rwtCIwqxUwVHvPKN93ynMK5QR38g8Dj0QUFPk3n43fVv6E8PpGHC/EYeNP+3DSxLPx8eo3kZg4MNTL8xDoJOmeXoNWkCnYgSfl82RkZEAQBNTW1soZg96ChRK1DE1pYrRaQMrfwK+vAKwyGKjs2SjdX3me0dHRbhmJSmr9J5XPrSyvBiD3dXQ6nXIAMzc31+9AnLJ83vXr3hAsV9Mb+qUSEREBwKCckRhyai52rSru6D+egsumXYkFryzA6aefFOrl9XmBBLMC7fnnT5BSKs91vV9dWxs22O1eA5ATO/aHrveTApfjoqNR5JLdKGX0ZZtMHseVSoy1ArBL9+1zy2x0Pf+alhasrKvzskrfvPV+dABuwTe1QKCvAT6FNhuaVVo56QGcFB/vNbDnOgVcSRRF3Lttm8+gtdZ7Js5g8Pr6hnKCO/mHgUciCoqYoYm47LsnsOTcf+BQRQ2yEY2Y/Qacmnc2Xv/83xg37uhQL7FP0QoyiaKI8vLyoA0WUT6Pt1LfQDM0vQWkpKCrlC23YsUKt2NKAUtlIE4ZbPWV9SndPycnB9XV1XLfRWkAjBQkdO3HCEDOmnQNonrrqanX65GdnS0HW6XzDrQkXlm27fp1MIPlalmKP9jtncpKYAk4ERH1FoIgYOa/b8MPjy5B6bNLkYIwnB82DI/NfQBbb/8V826/PtRL7NMCCWYFkh0ZSJBSWaItPVYaUiKVCSeEhSHfZJKz8xILC1WDpruamz2CmfekpUEE3I7rWmJ8wc8/+wzAKs+/MyXUrsIEAa1eJk1D8fzz09LwZV2dW9m0A0BdW5tc+uxKuo5OxXPo4N/QFykofFJJCZoVx3AAONDW5nENfF0z6T0DUfSa3RrKCe7kHwYeiShoIuJNuHjVw/j8+qdRtaoYIxEBIBlnT7sYP2xZ3SszH3srrSBTTk5O+6ew2dlBKWdVPo+3Ut9AMzT9CUj5mqQN/JFFqJblp5bJmJGRgd27d3vcX5nhKPVddDqdKC4uRnl5ufw9Zf9JqZxbotfr3Uqso6KiutyL0el0emRRCiqNypU6U8akvO4lbW247vBhv7MSXPXWEnAiIjoyCYKAyXdegITRQ/HlTc8j1qnH6WGD8dFj7yE2LhZXX31JqJfYZwUyiVgrO/KLujoUlJbirIQEuSy52emEUxQD7kcIqGdBKkuBtQam6NAesNrY0IANdjsOtLVhT0sLfjh4EMfGxLiVTg/paB81a9Mm2FQG2bgGvwptNnxVXx9QGbgWHQCdICBXJQNTyTX4NiU2Fl+NH48bNm/GZpcPz9fZ7TjeasVzGRkYbzLJ1035GkgGGAz4NDPTr0FFU2JjMS0uDqvr6jwG5ujhGXxVBgy13jMA3CaDK4/Badi9HwOPRBRUeqMBZ/z7Nqy45l/YsbIIA0UD4oQI/LiuCGeecUqol+eX/tizrrNDWvwNIqllQ1qtVp/H8idIJwUItZ63qqpKflxtbS0GDx7scX+r1eqRTSitR6fTITc3Vy4xl8qkXe+nXFdUVJTbfTIyMtzu35lraLVaPQKPrsd1Jb2ea/bswd2RkQAQUMBQeT7P2+0QXcpYAtnwd7YEPNh9n4iIiFxZzjoWscMH4eMz7oMJOiQZTPh82ZcMPKLzv4OlIN8DlZUorq9Hblwc7u3IDpSGtkjH0+r550R78HGlIhtPKZDyWbVBNa7n2Ox0qpYpiwDiDAZc7/LhsxOAzeHAqro6eU8FQM4GVFuv0LHeDQ0NGLt+PbY0Nvq1bn+IAJ5JT0emyYSpJSWqpcwSZTbjlNhYmAXB4zqLAK4vL9fsZekqXKcLaDq6FJzWuVwrJzyvvVompVZGbb7ZLPd6dA0C72pu1uw5Sb0LA49EFHSCIOCoGXnYsbIIERCQGhaDFcu/whkzZ/iVwRVq/bFnnb/npBZE0gpa+gpm+hOQ8qeXpdPpxPLly5GUlAQAbtmMOp0OhxSb0vLycuTn57vdpgy0GY1GZLlsUJW9IqUsy6SkJIii6DHJWrqPIAhISUlxO7ecnBzNknhv10xt0E9ubq7H87qu97+pqRBFEc6Onyt/A4bK674zLAwOlbIYfzb8nSkBD7TvExERUWckjk2T/3uwEI7CTb9h7979/bIKx99gYmd+ByuP/behQxHd1obscePwY0OD5qAV1+xIV/5McFZmwwUSLFWeo5YYvR7v7t2r+j0R7S2O5lVU4JfGRrR5CfhJ39nX2qqaWdkVAoB7tm1DuE6HPJMJ9rY2bGlqUr3vBrsdU0tK3F7LCqfTa3DXm86UME+JjcXT6eluwVzAM/Bo1uvx+fjxbgFDbxm1k1WCy9R3MPBIRN1i6AmZEMLDENHcium6gVi3dDNm77wSb3/wEiIiIkK9PK/6Y886f88pkMnSvoKZ/gSkXIN0QPsGL7vjk2Up+1AqcXYNlLn2Xmxubvb6HIBnoK2lpQWlpaWa5dFSlqVyoI7RaERLS4vcAzIvL8/jHHU6nWZJvLdrplyjxWLRzLSV1ltlNMpBR4k/AUPXoLDT6cTQ1lbsNxjcNqbd2S8n0KmYwaL2R8skxfRxIiLqP3QGPVJOGIea7zZjLCIR2ZKEU3Jn4b/LX8b48WNCvbygCSSY2JnJ1B7HrqvDi5GRyPZyvKX79skl0F/U1QXU41BZPhtosNTbFGTX5wjzkRDhQHtpcig5AezrKO2uammBHsC8IUPw+K5dHvdVey3TdTrsdfgKMXrqSgnz0n37fE4ctzkcHsFIf8rmqW/q27WDRNRrRSfH48LVD0MfH41wCJiii0NS6UFMO+Ys7N6t/slib6Esje0PPeu6ck5aQcuuBGidTieKioqwYsUK1NTUyIG84uJiOSA4c+ZMryXuUu9FtfJk6fjLly9HUVERsrKyNCdeA9rXR3lOyozdsrIyr0Nn1Nas9bU0QTw1NRV5eXleS5al9aW2tECnbAIuihjmcHhdlxQUTk5ORk1NDU6qrgZEUd4UdHe/nECmYgaL9EfL6ro6VLW0YHVdHaaWlKDQZuu25yQiotA747XbMaQgDwIEjEQ4zsYQXH3Kn/DJJytCvbSgUQv+iR0BKKVAfwerHhvA4o79l7fjSSXQp8THy2W9WgQAYWgPUMQbDHgmPV0OOAVyfoU2G7720V9R2uf0RQ4A/6mp0byeytfyKqMRgZ5pQlgYZsTH45n0dDxQWYkha9eioLTU7z2T2ntCjdrrJ71ndk2ejBVZWQw69hMMPBJRt4kbkYzL//cEzKOHQg8BWYjGCXWxOC3/HFitm0K9PE2BBID6iq6ck1ZQrivBTCnzr6qqymOidFlZmRwwlMqrtdalVZ7sevyioiKUlpbCYrForlfr+ijPacCAAW5f2+12WK1Wv8/b2zWTgoEzZ85EXl6e16CrtN4rdLr2ZtvSMTqCkMdv2+bXuqTrl374MObt3InstjakGo2YER+Pb7Ozu22zlxkd7bFh7u6JhFp/tDy0c2e3PScREYWePsyAmS/dipx5syECSIIB54UNw3PX/RMPP/gURB+TgvuCQIKJgf4O1jp2RccHnP4cb35amvt+ReX/xY7jShl+fy4vx6SiIhTabJpr2NDQgILSUjkw9kJVFaaqTFWWniPBYHDb5+SbzZpBud4clrQ5HH5PeM42GHDr4MFu9xE67qdGByDfZML8tDTcVFHRqQ9s1d4Tar6urw84qEl9E0utiahbhcdGY87nC7Hqluexfek6jEA4zsEQ/Pm0P+OO5+7C7PPOCPUSPXSmZ10wdcdwm66ck1avxs4OFZEeo0XKfqyqqkJubi7y8vJQW1ur2uNROcBGKk9WyywsKCjQXK/r9XG9/klJScjNzZWfMysrC0uWLPGYei2RHltTUwNRFDF+/Hjo9X9svbpyzVxJ680DMLmjfPin/fuR3NSEmfv3Y+Thw35loLqWd6cfPowL4+N75L0fyFTMYPH6R1lHk3IiIuqfBEHAxFvPQcLooVh17VOIcegxMywZa59fics3/YJX3ngaYWFhoV5mp2kN5VALJgb6O3hIeDiqFNUlADCoI2PQ2/FcW5zkdbQ2kQaCzEpIwKcuU60PtLV5lGNLE5hHR0V5nJ8O7T0VpQnKVS0tWFlXp3mNdILgMZ1ZWrtDFN3KfqN1OhwfG4u6traQlFqHCwLMBoPXfpFapczK17KkrQ3PVFe7DZgRAdw2ZAheq62Vy7glTrTvjTrbFueFqir8cPCgXxmPzaKIqpYWr6XzHEbYPzDwSETdTmfQo+C5m7BhzHD8tOh9DIIBZxuH4pEbFgFArww+hlJxcTGKi4sBtPcBFEXRY1iKN8rAGeA5kCUQWkHLrgQzlf0MpWEuBw8edAvq7d69W3OiNaAdyFMbWuPvepV9GM1mMywWi3ztLBaLW99Hp9MJp9MJnU7nMaSmtLTU7bXrjqC2VJKyYcMGFFdUyLd7yxaVBCsQGqhQ9PDx+keZYtNNRET908hT83HBygfx4TkLENFwGCfoBuD773dg9qy5WPr5G6FeXqcFEkwM1u9gKSNQ63gi4NGXURAEt+DSdampAIAha9dq9oAUAWxpbIQefwTb9GgPkEnTpH0JFwSsUank8HUtCm02nGi1+vUcnRGGP7I8JXoA0+LiAMBrIFUrT9e1RB1oL4l3wnOQz2O7dmGi2YwDdrvb93Ro3xt1pi3OC1VVHkNlACDNaMTOjuC12rXUCmpyGGH/wcAjEfWY/BvOQsLRQ7HyyscRBz2Gh8XitVfeZeBRoVzxC1ttSrM3agNMXP9bK/AVSKZlV7MylcNNBEFAcnIykpKS5KAr4Lt8WyuQ19mAmtPpRFlZmdttdrtdvp5SGXZ1dbVcIl5TUwOr1SpnZrpSfq123QAEPcPVX/4GQrsjC3dKD08n1Pqj7O/DhgG//95j6yAiotBKOHoYLv/+Cbw55TbgUDNG6Ex4vbAYdnsDzOa+OXAs0GBiIL+Dd2kM8dvtUs48JTYW89PS5Od/oLISdW1tXjPmXDPZmp1Ot4w8NSa9HoedThgAZJtM+KWxETY/hqZIgTxf10JazwU//4whHZUQvzU1waTX41BHaXNni/KlUnId4LYHuTk11WNIjAPAKi8BR4natdID+HTfPjmgC3ifam1XyTJ1AhjXkSnrbxYt0B4kvEUl6AgADU4nvs3JkV/vfa2tHuXwDrSXXhfabHJQMVTDCCn4GHgkoh6VdlJO+8eTIhAvGFH0exUaG5sQFRUZ6qWFnBTcaWxs7NIxlIEzV97Kb31NqfZ23+rqap/DYFxJAS/XqdHV1dVupdXeAoa+AmFapdO+gmZWq9Ut49KVdO10Op3H46XvqWVaKo+vvG4pKSluGa6A9nX3Zvfu3V6/7gpf742+UAaj9UfZRJMJJaFeHBER9ajIgTEYNi0L25atRxQEJISZ8fOWXzFpYuha7XSVWjAxGL+ftSoG0l32QmqZaVqZbZsOHfK4f8efBl5JQUY9gKKGBkQH8AGoVhm5dH02NDRgX2urHPxUKy33Ro/2gTh1bW3q5c8Ajo6KQnlTE5wdw/wyIiPxpMpkaqDzAU61jERvU61/O3xY9do/vmsXnsvI8DuLVno9tepHDrS1ub0/C0pL5RJ5V82iiKklJXJGYyiGEVL34HAZIupxA7KOAgBkIwqTDsVjWv6ZqKqq8fGo/k8K7jgUm4OMjIyAjqEVOAO8ZxCqZes5nU5s2LAB77zzDt555x1s2LABTqfT4741NTVYvnx5QBOe1YKku3fv9mvAinJ4jLdBKoHc11tg1vXaaQ2JkYa+DB48GCkpKchS/AGgdt1KS0v9XoM3yjUdPHgQRUVFXl8T5fRvrft6y+TsS9OiOSmRiIgkw6dnAwASRQNmR6bh1rNuwfvvLQ3tooIoWL+flYNh9GgPpF3t0h9ZLTNNjZQxp7x/IIE2aThcox/ZjkB7pqTa8V2vj9RL0f9drDtBEPDAiBGa33egvVy8taOXZGvH1519Pm+GKPpWa021lnbYatdGBLB03z58k52NGfHxPgcPSq+nlgEG93w36T2lxnVaeSiGEVL3YOCRiHrc2e/cjdjxadBBQCaiMN0+AGcccx5++qkk1EsLKWVwJzw8HHl5ecjNze30MaQpz/5Ms1YLplmtVhQXF8sDX4qLi2G1WlUDmFLJsZJWcEstSKoVGFUeQzkJWy1YJz1m8+bNPu+r9fwmkwnh4eFISUlBZmamvAZRFFWvq5RpWVBQgMGDB3sETtXOTxloDmQ6uCsp6Gk2mwH8USIejKCst2ncWtOipU2jq0KbzW36ZG8MThIR0ZHh6PNPwIS/XQQRwCAYMNs4FItveQr33fNov5h0rfb7uU0UcVJJSUC/g6WKAdcA1JqsLGS5DM9Ty0xTcs2Y8+f+3jjQPizGn2CGzeFQDbjOq6hAm8v16axYvR7fZmfjutRU5HfswXqC1rn/ZLe7nWu2wYBnRo70eKxOEJBt0m4tsOnQIZ8f2Er7ui9UshddLVQEZaX3VLhK8NE1o1E16N3NwwipezDwSEQ9zmiKxIVLF+Co848DAAyHEbN1Q3HzmTfh7Tc/DPHqQkcZ3Bk3bpzXrD9/jmGxWJCfn+8zgxAAsrKykJKSIgfasrKyVIN0tbW1yMnJQUpKisf3Nm3ahM8++8wtyKgW3FLLdjSbzZqBUeUxlH8QSANe1B7TrOhN5C2wJwXvUlNTkZKSgoaGBjQ3N6OmpgYffPCBvIbi4mKUl5cH3O9Q67oJggC9Xg+j0ah6Lv6Qgp4xMTFut2/evFkzm9FXT0rXdUvXRRnA9rcMpi9lRhIR0ZEh789n4PT/3g6nQQcz9Dg9LBm/vvItLjr3ao/9Q1+jFdxrFsWAfwd7BKAUew21zDQlk14vDz7x5/7e6NHe51GnkTWn5HT5QLTQZsOkoqKgTatucDjkrEGtfpjdQQCQpshuBNqzNue5DBsEgOsGD8b3OTk4rSN4fEpH9uIVGntiAUCz0+n1g2LXfZ3WrjUMwIsZGbjWpeekZEpsLKbFxXnNaFQLemtlXVLvxh6PRBQSOr0OpzxxHaxjhuPHf7yFBBgwO2wo3rjjBWzatBUPLfq7Zgp+fxWMCcNZWVmorq7GgQMHEBYWhurqavnYvoJjJSUlbgNTSkpKPHoWAsDevXtRXFyMgoICrFixwi37sKWlRf5aepxacEst29FischrVPZlVB5Dp9MhJSVFdcCL6/O4Cg8Px7hx45CTk4NCmw0PVFaiuL4eQ1tbcb3ZjP+bMMGtN+Ty5cvdHt/Q0OD2tXLojDeu55OSkgK73e52PFEU4XA44HA4YLVaUV5ejtbWVgwYMAAFBQUwGPz/dZ2UlOT2mjU3N2uu01dPSom3ITRep0W7YINwIiLqjYZPz8ac1Yuw5Oz7EW5rxPG6OGzcsB/TJ87CJ6vfQmLiwFAvsVPUfj9Lgv07WDnATY3N4cBNFRXINJk87u9rsIySIAh4Ij0dIoBpVitafdzfCWBDQ8MfvQiDmNHqAHBSSQmmxcVhSHi45jXvDlUagc4SxZ4V8OwBWmiz4d5t21QfL6K9L6PU73JlXR0mms14PD1dc/CLKykz8RsfQUJ/prH39DBC6h7MeCSikMq5ugAz37oTYpgOJuhQYEjCL29+j7lX3BLqpfU4KbjjT3ailtLSUtTU1KC5uRkNDQ2oqanxWW4rUZumnZOTg9zcXBiNRvn2lpYWFBcXo6SjKbg3Up9IV2o9IpXZjsoMR+UxkpOTNQe8SM9hU3w6Gx8fDwB4fNUqnGi1YnVdHfaKIkr0elzT2IhXf/pJfmxRUREOHjzo9dy0nreoqAgrVqxAdXW1W1m5a7ZkRkaGnF3qem0lrpmWK1as8GsdgaxT4prJmJubC1EUffZ7VPK3DIYNwomIqLeKTx+My//3BKIzUqCHgGxEY8L+aEzLPxO7d+8N9fI6Rfn7WSmYv4NdM9O87V6lVizKTLYJZrPq49RuEwDkmUwQO573JB/PKbG1tuIkP4KOCQYDxkQGNvRSyiLdYLd3ejBMZ3Q2wCkFYPe1aY2D8QwEr7Pb3bJktTJqdYDfmYnMaDxyMPBIRCE37IRMzPnqUSBMDyMEjNbHYvWnX6G+vneVYPo7iCOUtEplOzOwpLm5WQ56hauUcpSXl/s8bnJyskfmqiAIqr0UJWpl2IIgeJT6eus7aLVaPTIU9+zZg6KiIvzX6YQoivKGytmxvuc7MjClIKGUkWk2m1XLo13X6/q8RUVFqK6udhscI12niogIPJ2ailPq63F/ZCTSzjwTmZmZmscGgAMHDnj9vpLWNGu1bEbXYLcgCCguLvZrCI8rfzeNbBBORES9WUS8CRevehiJE0dBgIBhCMfAlnB88OGyUC+tU1x/P6v10gv272ApM+2U+Hivwc4NDQ0oKC3FhT//DAB4b+xYxBsMHgNQpCxI5bFEtPcxlIJg89PSoPMSYJW0oj1A6M1Esxl7jzsOP0+ciIkB9muUgnBmfVeKyAN7Pr1GdZi33o3AH/0tA6Uc/KIMJukAnBIfj/lpaXigslIu1X6hqkqzxzcH/x0ZWGpNRL1C3IhkpJ81CRUfFsIIATFhUaiu3o24uN7zy0cKKgF/lBH7KrEFPMuGvZU9B3JfNWql0dLtvo6fkZGB4uJi+TEtLS2oqqpSPR4ANDY2qt5uMpkQGxuLpKQkiKLoUVItiiJqa2thMpnk4GBNTQ3ee+89WCwW1cekpKQgLy8PbW1tWLFiBTZt2gSj0QiTyYSWlhaEh4dDFEW0tbWhtLTUY6CMdO4AUGU0ysFG+XuCgEqdTjUbs7m5GbNnz8aqVas8htoAcAusKr8vfZ2cnIxv9+/H40OHys9XIoqYXlqKb7KzkeN0YuPGjR6DZgBgwIABHrd5o3wPmM1mWCwWn6X7/vZ7VONPGYw/5TREREShpA8zYPId5+PT8xbCAAEmXRgqt+0M9bI6Tfr9LGW4iT3wO1j6fQ+VwJYOwL7WVqzuGEZS29KCL+vrEafXe2TPOQEkhIVhZESERz9GJwC4lIo/nZ6Oe7dtw4G2NugBn6XX3hTabJgSG4vH09NxotUaUFahA4Ddz2nb3hgAaOcittMDyDWZsMFu92h380R6uubjCm02n/0ttUrfXbNkz0pIwMq6OrfvOwGMjY52e6/VdJRqS8eUvk4IC0N+R9n9FAYb+z0GHomo10jKGomKDwuRLBpwTuQIXDLj//DskicxZfIxoV4agM4HZgIJWAZyX9cgYlJSkrymlJQUCIIAURQhCAJSUlLkoJO34+fm5kIQBNTW1uLgwYMewT+JdGxlkMxoNGLcuHHIzc2FTqdDUVGR/FxAewDMZDKpBu+AP3ommhWfMEsDV5YvXw6bzSYHK1taWuT7SOXfNTU1mseXpLa04KDB4BZ81IkiUpqaUFxc7NEjsaWlBatWrdIMALtmEipLz+12O5xOJ3JycjB3b3uplvS8TkGAThTx0I4dWKjTeVxPKTO0oKDA6/koqfUK9Sd47W+/x86SMi8WVlZi06FDyIyOxj1pafxkm4iIepW4kSmAXgejw4lpugR89eZ3uBMPYNGj8/ts//Ge/B08JTYWT6en4+7ff4fNZW+jR3vgSQd49HuWvq8MoOV7ydxzoj0IVmiz4eaKCrdqFiDwvpEAsKEjk/Kb7GxMiY3Ftzk5mLlxo9t5eKMHEG8woK6trUt9HocYjah02eeqcQIYERGBXxobYXM4oANwdFQU/j1qlNfXVcpYVKMDcHRkJH5talL9vmuW7H81/g76T02NW+9Hp8b/SwHoL+vr5etN/RcDj0TUa4y74mTsKduJ8je/xlAYcZ5uKO4893Zc9dCf8X9z54R6eR6BmaSkJBQVFfkM8AQSsPR1X6fTKZfxiqLoMchFkpeXpxqwVB6vrKzMbf3SY5RBQ1cmk8kjKGkymWA2m1FTU4PPP//cbfCLRDlt2V8tLS1+l/36U5Z8+v792BoVBZ0oysE/AJi5fz/KDx5ERkaG6nHHjRunmf0JtL82yvLuhoYGeehNTWQknMpp3IKATYcOoVbxiTHQHgj2J6NWydsgGK11W61W1NTUICUlBTqdrtPDjXxhg3AiIurtIhNiMfONO7DsisdgagUKDEn48e0fce6WK/D2By8hMsD+f71FT/0OLrTZcFN5uUfgLd9sxm9NTR59BR0AIAjt/ShVMjIv6CjJVpMZHe1RNiwFNwcYDAjX6dDsdMqDUlyFCwLMer3b95RDd6bExsKk1/sdeBQEAQ+MGIGbKipUMz791QrgosREvLtXu7+oCLh93wlgS2MjShsaPAKPhTYbHt65E5sOHcK+Vu18UCcgBx3HREZii0sAUpklqzbABoDf1wrgoMEjCXs8ElGvIeh0OOnhqzDloSshCsBAGHBO2BB8OP8V/OXWe0PeU9F1EIdrgM5XTzwpG1Hra1fe+hYCfwyPkYKPWjZv3qw5lMWV3W5XXb9y6Ehubq583tEq/YCkQTbS2tSGszidTr+y6EwmE/Sd7I+jVpaszE5IP3wY83buxOjGRsS1tmJ0YyNu37kTIw8fBqDeIzEsLAxZWVnIy8vz6Hcp3V9tUjfQHtx95513kHTokBzklOhEEZnR0R7XxTVL1Ztg9B1V9qVMTk7u9HAjIiKi/mDo8ZmY89Uj0A8wwQgBU3RxSNlox/RjZqG2dk+ol+dToc2m2VMvWMe/qbERw9at8zj+vIoKzWy/kRpB25EREW79ovPNZuSZTLjg55/R7HRqBi1mJSSolg07AYTrdNg1eTI+ycxU7QEp9UFU7pyUQ3fUelSrCRcEfJudjUyTCXkmE8L8eIwaKatwW8e+NFB3//6729dLmpsxdeNGrKyrQ1VLi88+l9JrNywiAt/n5OC0AAe/CPDsy+nr+aTM1YLSUiR+/337/woLfb53u/t9TsHDjEci6nUyLzsZAzJSsfSSRYhuAU7RD8L6D6yYteVSvPfJYkRFheaTZmUm2fLly92+35kBLhJ/s878fY7m5mY5YzEnJ0cuyR40aBCSk5NRV1cHURTdypWlY3vrA6k2+EVLi6JERBAE+XxKSkrcSov1ej2Sk5PhdDp9lkobjUa3Y0s9JZOTk5GVlYUVK1a4HUNt8vZ4nQ7ZLmXbksOHD7sNupE0NDTgzTffxLhx4zB27Fi3XphS0FDrtZGCkQWtrdgydKhHpuV5hw+jdt8+uUReCjr6E/jrbN9RV13p7UhERNRfxY1IxuX/ewIfnr8QB7fswHhEw1xvQMGEc7H40+eRmzs+1EtUpeznKPVR9LectdBmk0uyh3R82LqruRmZ0dGY35HtdtLGjXACcDoc2K04vlYmXElDg9ehJ1r9KKWSadfSaQHACxkZ+GTfPs3jNTudGLJ2LYaEh8MSGYnypiY4XPaE6zUmUCuH7ih7VGsx6/UobWiQy75d1x4mCGj1MwNSyiqcXlLi1/2VbA6H3Key0GbDIz5KttVIwUBllqwU6Nt06BAidDo0q2Q3jo6KQllTk3y9fJW86wEMCQ/H1JISOBXl8l94KcXu6vucehbTGYioV0qdNBqXfP1PGBLMMELAZCEGw7YexrT8M1FV5T0w1VN8ZSdKlBl0ahl1yqwzZbagr+cA2gNwymy82tpa+dhVVVVyQLG5udkjMGiz2fDZZ5/hvffe08zk1MrqUzNw4EC3r6WAal5eHqKioty+53A44HQ6PUqljUYjUlJS5P6QJpPJoxeixWLBzJkz5Sy95ORknxmTjY2NHr0kAaC1tRU1NTUwGo0ex5D6SALtwb3BgwcjJSUFtbW1KCoq0sxklSZZ/zslBcMPH8bww4fdMi0dpaWoqqqSg87+ZBtKmY7KITqdCRr6+z4mIiI60oTHROGi5Q8g7exjAQAjEI5zMQTXF1yP999bGuLVqVtYWenWY88B92nE3kjBnNUd2XHr7Hass9tR1dKC1XV1mFpSgnkVFRABt/Jkf4+/q7lZ9faShgY5a22eS+AOLs+jR/uwmdPi4/F9Tg6uTU3FBo0gJwAcaGuTz2FLY6NH4E8tDCjVyNS1tcnrASBnYyYYtPO2DrS14YbycjgVa5eGwBj86A8a0ZE12dXem/MqKgAAD+3s3GAktYnnyveG2hAdPYCbUlOR13G+4YKAo6OiNINOUvk2AI8enUD79dN6b3XlfU49jxmPRNRrxQwb1P5J80UPwlZaiUxEIcZuwBnHnIeXP3kOEyZkh3R9akM81PgztEMZMJIGrQDuGWxZWVmoqamRB7y4ZvaNGjUKANx6MyYnJ3sNRknBNYfDgYaGBo8MQOXafAW2TCYTYmJi5H6HRqMR4eHhyMjIcLs+ygnagOdEaF+3S1wDuVar1e9+kFIQdPPmzWhWbISVQVlX5eXliImJ8eixKfW5bGxslIOjFRERbpOsD3ZsWOft3Il0lRKazgwscqV8b/kzJV3tfeya7SBlOPDTYyIiOhLpDHqc9swNKBozHOsfeheJMGC2cSgW3/IUft78C+5fcEevGjqz6dAhj8w81/Jh6Xf8BumDZEGQpwsrgznKY+hFESUNDV6Pn20yqZY/Z5tMiDcYUNvS4vH4ZlFEVUuL6vckrQDq29ow33Uojpcsws40aJJ2SNKkaNcsOikbc15FBYrtdo/J2dLzKVfkQHtgNVqn89n/8LAo4qO9eyECmhmF/pCyTl1LxgPhQHvwVcqcBDwDfcpemkPCw2F3OPDn8nL5OHq0951UCzyGCwKmxcXJfTy1zlRZ+i7x9T6n3oWBRyLq1YymSFz46QJ8ecfL+H3J9xgOI2bphuCqmdfi5c+ex6SJgQ/fCBZ/h3j4E6BUTlKWKANROp0OgwcPRnZ2NgRB8AgquT4uKSkJoihqZk8C8MgeVHPw4EEUFRUhJyfHI4jqKiUlBTNnzvQIirW0tMhDbKQy4tzcXL8mUHsLAEpcMw0DyfhzOp2ora3FgAEDNNehLOsG2oPCalmfakHbzzuyPpWTrD8fOBA3q1xH18Cht6Ch8jzDw8Mxbtw4t/eANAlcOYBI+Z5Vvo9ZukJEROQp789nIGHUEHx+1RMwtwGnhyVj1eIvcUu9DU8/86DPx/fUh3qZ0dEeATwpg036Ha9V0hqn13stJ3YAbuXKyuMDwOPp6TjRavV4/ifS0yECXsuWfe1KpYy27hpEohbIgihimtWK2T6GvXjTLIp+BxH/tWsXnqqq8hhIGIgWUcQLVVVo7kJ//HV2O46zWjHRbMbj6emqgT6pl+Z7Y8diakmJ25AfAB5Zq64SwsLk11HtPStRZl9KP0daQ3L2tLQg8fvvkW8284PzXoSBRyLq9XR6HU554jqsH56E4sc+RBIMGGKMxyuL3+7WwKM/2WL+CHTKsCtvZa9ax/VnMrU/pKCblH0p9UpUBuPMZjMsFot8fdSCf1I2ZXV1NURRRH5+vhykVMs47Cy1wKiUHeoqKirKZ9ATAMaNGwegPctR4k+puVTGvcdkUp1kXWU0yusdPHgwdu/e7RE89ta/UXme48aN83gvSD1DXfkKzDqdTtyxcSOcTqccLO0rEweD9fNKRESkZfj0bFy0ehHem/5XhIsCRhlisOTtpT4Djz35oZ6yJ6HUOKaurQ0nqQSHgPbAkNBxux6+A4Bq7klLk4NC8WFhcjZivtmMe1yyFL/JzpYDsPtaW30OO3GlzGgbGRmJfX62AOqKVsCvoKPUz7Cz1xAdjxNEUbUU3F8igOvLyxGMPNx1djumlpQgz2TSDGhL2ZD+0uqjqTxvHdwnaSt/jtS0AtjX1ua1PyT1PAYeiajPyLzsZBQ/9iEECIgTwvD7r5VwOBydnoDsSzAGd/hLre+j2Wz2a7KxlkD7/UmlwjqdDklJSSgrK3MLMJaXl7sF3aSAY1ZWFkpLS7FixQokJydrZm9KysrKIAiCnJUZHx/vtlaTyaSaPVgREYGViYnYaTAgtaUFp+/fj/TDh90em5OTA1EUUV5eLvexVNsI+RPoNJvNyM3NBdC+6fHWe1ONyWRCTmwsvqqvd9sc6UQRqR3XVa/XIz8/X/Xx3oa++JNFq/b6++rfaLVasfXwYTjD3Gcx9oXSlZ78eSUioiNXfPpgJOZlYO+GckRBh2iEYdeuagwZMljzMWr96LrrQ70psbFuwb0h4eHYYLfL5cNaHAAgCBAEwecgFaV8sxmlDQ243uWDWqA9wORWGg24DSwZu24dtjQ1+f08rgGrQpvtj3LxXkIaevPpvn2dCqxKuhJ09HYcoeN/geZBSntp1/eG1J/RV6m01nAZKZgItL8nnk5P93j/OAE8l54uv3+8tQJQkoLpvf2D8yMFUwGIqM8Ij41GRFIcAOBYxCD1t1bMPOkiNDR0T0CkJ6f9qgWELBZLlzK2vAWZjB0ZdxKz2YyLLroIZ555JgoKClBTU6Ma/HMVExODvLw8lJaWug2j8fXcLS0t8v2Li4vdrqvRaERGRgZyc3ORmpoq90ySeiX+HBGB+rAwbI2KwuNDh6IiIsItsKjT6ZCfn485c+YgMTHR6/p9ka6/6+AftWuSkpIiD5qRMh3tdjtqampwQXNz+yZNWl/HWmfu3+/zOnkb+iJlu7oO1fH1eKnMXUkaVLN8+XKUlZUhtaVFXqdErcl4b8Pp3ERE1FOGTB4DABgqGnFuVDrOnHg+1q0r1rx/d/ajkyYNS8NQpL58K7KysGvyZMR39Jf2FazRA8g3meRBKqlGIyaazQjzo39lsUrQUXrOmRs3uq3Ndd2BBh1ds9+CMUREQPADIvds2wYAeG/sWEyLi0P3pEd0jutQoEBIfSrjDAbEGwxIMBgwIz5eHoSTGR2teZ5a11gZFF26b5/HMfQAPnWZXK72c+Rr3b39g/MjBQOPRNRn6PQ6nPfZPxCWHIcwCJgomGH5zYlpuWdgxw7tDLvO6slpv1LfQ7PZLGfadSXbUTpmXl4eUlNTkZKSImc05ubmyiXEkoyMDFitVixbtgzvvvuuahmyyWRy+1q6HsoAz+bNm6HT6TzuL1FO3nbV0tICq9UKQRAwc+ZMOaCm1itRul0rOOurTF2N0WjE4MGDkZeX55ZVqHVfaVK31N8yJibG7T5Rv/+OhxobcYxej8FGI7IdDvy1qgqjnU7k5OR4fY2Vr19NTQ2Kiorg9LNfj/I9lZKSono/16nndrsdp3cERXUuJVeuG/3eitO5iYiop0z4y2yMvPAEAMBwGDFbNxS3zboVb76+RPX+aoGZYHyop5w0LE2edg3w+ROsEfDH73rXoOWPeXk4yY/gmXJitCubw4GqlhasrKvDcVYrXuioSggkcCgAboEuIPAglJoYvR66IA4GcuCPMt+pJSU4KyEhaMcOtWZRxL7WVtS1taHe4XDLZJ2flgZBEDyCS2MiI5FvNquWfCtff3+C894CnFqGePm7g3oOS62JqE8xpQzE5d8+ho8vWYQDGyowBpEwNyVi1qTz8ewH/8KUyccE7bn8nVrdWcqedLm5uW5lt1ImmtrzO51OlJSUeO1n5623pNPplMudk5OTIYqiz36QgiAgLy9PfkxmZiY+++wz7Nmzx+1+LS0tqK6uVj2GyWRCenq6z8nTUrBv0KBBqKmpQZXRKAcb5XPo6JWYPGCAan8/6XrV1NRAFEU0NDSgubkZoiiiVaMhdXh4uJwZKF1PrYE6AwcO9Bjcoryv3W5HrN2OKwE5eAgALWh/faTncF2/NCxH6vuYlJQkTwCvrq5GSVsbPoiI8NmcXqfTQRAEuTy+uLhYfg3VrrUkJywMiw4fxscmE7br9RgfHe3Wm6m36u6fVyIiIolOr8OMx65B4pjh+OG+N5AAA84NG4K37nwJmzb9gkWPznebdK3WdzEYH+r5U8LtbXCHq2dcSlpdKdfeVTeUl2O8yYQNPiprXAmAR7lsZnQ0alpaOpXBJwkTBNVhOV3lBOAURTy7a1fQjx1qau8xqVT6BkXW65amJtV+l2qZiFrvUylwWGizoa6tLeD34Aa73W06N4UGA49E1OeERUXg/A/vxdfzX0PZG2swFEacpx+GO8+9HVc99Gf839w5QXmergyF8YevnnTFxcVywKmqqgqiKMrBlNLSUrfvKR8bKLUek0opKSnIy8uTg2Rvv/22X1OnXTU0NMjBL29DZaRstVNPPRVvv/02UltacNBgcAs+6kQRR4eHIysrS3N6c15eXkBDdqRBOtLjAXgEMHU6HZKTk1VLe5OSkuRya6nHpOTAgQMe9we0p09L/y0dD+goOW9shNDU5Nac/sWICCTv2+dz+rVW30fX57RYLJiTl4c7fF2sXqa7f16JiIiUsueeioGWVCy7/J8wtQIFhiT8+PaPOHfLFXj7g5cQGRkJwLPvYmaQPtTzJ0vMn8ChDu0lrdelpnp8T61nZLHdDvWPcH0T0ZHtFkDAz+zSz10aYLPBbu9S0BFoH7gT/LDjHwIpJQ8lrT6MAgCjIHj0qVQLHC7dtw8CPEuo/ZlUDbS/T1fX1Xncd4PdjheqqnBzRUVAA2xcsc9j6DHwSER9kqDTYfpDc5E4Zji+/9urGCgacE7YEHw4/xVsKt2Cx578R6+faOsrKFSu+NSwvLxcs/w30H52yqCnVhkuAISFhSGio5ei0+l0C4h2xu7du5GUlOSxeZDKll2z1TZt2oSWjkEyW6OioBNFODt6Jgo6HR7vGGzjbXqzr2sjZQY6HH9sjVwfoxXQksqTJTabze3r7WYzPk1MRJXRiNSWFlwmCIh3+eRbymxUmz6t5fOBAwFBcMts0Ikinty3DzdXVfmcfi0FOV0DlMwUJCIi6ryhx43DxWsexfuz7oPxQAOm6OKweaMd04+ZhY9Xv4nk5EEA3IeqBItalpgyqKMMHKoNPPHVC0+59tNKS7G6rq7Tgb9A++4dcjpRUFqKsxIScHNFBZyi2OWgI9D5ydP9jda1HB0VBbNej3UqQ3xiDe6hpE2HDvn9mqhl+06JjUW+2az6XPdu2+b3UBkl9nnsHRh4JKI+LfPSkzAgfTCWXrII0S3AKfpBWP9hCWZtvRTvfbIYUVGRoV6iJmVQKJCedMnJyW7lzIH2s1MG46QsxOrqauzbtw+tra3Q6/VISEjA7t270draKpfqKgOiEpPJhNjYWLmMWxRF1YCaFLx0JfVIVAaLpXWmHz6MeTt34vOBA7HHZEJeXJycKbBcJbDoGmDzNWVbrWeiP9fTNWDndDrdzrUiIgKPdxzDKQg4aDDg74KAv0REIP3wYdVz1OLaK3OPyQSn4o8FJ4Aql2FBZWVlqkFF1zW6BiiZKUhERNQ1sWlJuPx/T+DD8xfi4JYdyEI0YuoNKJhwLhZ/+jxyc8d3y/N6K+GWMgOVrVkKSkvxhSJoqINnBprW4wHgb0OH4su6OrmMVspHHBUZifKmJp/ZkFUtLQgL4DzbRBEr6+qwsq5ONauuLzOgfS83wGCAAUBtW1tAj+/O62Fra3PLNnW1pbERk4qKsKu5GZnR0RgSHo4qPyuh1Mr6C202lKiU3zsAHGhr0wxqur4HnfCc2t0XBiQeCXp3OhARHdFcp+16G6qROmk0Lvn6nzAkmGGEgMlCDIZtPYxJY2dg5cov/B7G0dOk4SHSROTa2lq388zIyHC7v+vXWVlZ8uCRvLw8ZGVlaV4rteuoDKy5lnFL/Q8dDgfqFCUPZWVlqueSkpKC8847D8nJyfKwlYKCAo9MypSUFLeeRxJlv0Npva7nkX74MP5ms+HVhgYsbGvDpI4SZOW5mEym9r6QLlO2pWulNfDGldls1sz6c11bcXGxnLWpnHatNgxHFEX5duCP8na19efk5LgNlbHb7bDb7Rja2uoxcVonikh12ejZ7XbVHprKNXLqMxERUfCEx0ThouUPIO3sYwEAIxCOczAE1xfcgCXvf9YtzyllM0pTqKUBLCKgOXTmrIQEjyCOE8CsjkEohTYbJhUV4TirFSs1htZMiY3FS5GRONnleb/LycHPEyfipPh4v9belVLt/uTk+Hg4pk7F3uOOwwCXD5L91V3XQwrY7dJoiwQA6+x2+f2xQSVTUYvrpGoAeKGqCsdbrR6ZuIB2GTgAjImKcnvvP5+RAV1HZZR0DsEckKg2QZ78w4xHIuq1fPVAdBUzbBAu/+5xfHjhQ7BtqkQmohDTNhh3XHEP9jy2H5dfFpy+j8EkZZq59iCsqqpCdXU1Zs6cidzcXLcBMDk5OXKgS3qs1G9xyZIl8hAR5bVSu445OTmorq6WM+BqampgtVo9+hAqezja7XakpKTIzwVAHoqjPA+1IKUy+CVxDb65rhf4owTb4XCgtrYWDQ0Ncs/L/Px8j1Jh6T6SzZs3QxAEDBgwAOeddx42bdqkmqUoMZlMmmX6yr6bWrwNw5G/7sjKTEpKcusZ2dDQAJ1Oh5kzZ2L58uVuxyjYtw8lSUlyybkUhJzZMYlaIh1LeS1dceozERFRcOkMepz2zA0oGjMc6x96F4NgwGzjEPzn5n9h86atuH/BHaofwHaFWgl3QWmp5tAZwDOYI/V4zDSZMLWkBG0qpdjKgSLZBgOuHDcOekX/xa/r64N4dv3fV/X1eKGqCkv37cOWxsZue54wBBbslQJ2D1RW+sxklDIOx0RG+tXX0rX0udBmw/Ua1VSA98CqWa/3HDpkMgW9l6q0zqklJfLPldRn/ZvsbA6u8QMDj0TUawXax9BojsKFny3Aaxfdi5YfKzEcRlxoHIEXbn8eBsGIiy+d3Z3L7TTleUlBQGk4iivXPoSAdmDJW4/D2tpa1SBjbW0twsLCNAe+SJTTrbX6TtpVPvl0vc1oNCI8PBwZGRlyxmZtbS0OHjzo9hgpCPfOO++43V5eXo78/HyPUmFl70UpeFpTU4MlS5YgLi4OycnJyOroDyn1kXRdo2sfRADyxGnlBG9XZrMZzc3NaG1tVR+GA2BIRwl7ZGSkW9mz6wAZ4I9yaWU5vmvJeZXRiCGtrTh93z6MVJRvS0FF5Wvi+jxSz87e3guViIior8n78xlIGDUEn1/1BMxtwOlhyfjhlW9w0eZf8fq7zyM8PNxrKbO37/nD19AZtYzHTYcOyVOy1TgAfF1f354RqVJBIgVmlEFL8q5VFHF9eXm3l6K2wnv2oCsdgG+zszE5Nhbz09KwUmXoi5IDgM3hwPc5OTh70ybs81Iy7lr6LAXD1YQLAsx6veax1LIxu6OXKuDfBHnSxsAjEfVanemBqNPrkHXXOVj3/KcQvvgdCTBgtnEo3rjjBWzatBUPLfp70D9p7irleQL+l8FqDSVxvVbK4yuHoEicTqdmRqIrabq12nN6ywJUSkxMREFBAaxWK95//33N53Y6narl8s3NzaqBM2U2p6tDhw7h0KFDblmhoii69ZxsaGiQsyqrq6vR0NCgGkRVslgschaq7qefcE1jo7zBkzITT9+3Dw6Hw+d1lsqlpcBnWVkZ7HY7WlpakA7gZo3rbDabYbFY5McpXxOpDB2A3LOT/R2JiIi6RjVQOD0bF325CEtm3Y9wWyOO18Vj44b9mD5xFv724Qs4e9cO1ewpAF3OrPI2dKaurc0jg036nlrA0lWzKGJqSQm+ysyEsmuet6BloMIFAQKAw108XrROh0O9tOWSUk+s0t/nmGA2y1mCU2JjMSYqymc2pvQemhIbi08yM3GcStsfyY7mZgxZuxaZ0dHY4GVP3CyKcPoZwOxu/kyQJ20MPBJRr9XZabs5OTnA9cC20VbsefZbmBw6nGZIwro3f8Dsn6/E2x+8hIiIiO5cekDUAmX+lsEqN3hGoxGZmZlu10p5fGXQS6/XIzs726/JytLxpexE5XRkURRRWlrqkZmp5uDBg1i+fLnP562pqUFxcTEyMjLcAoQtLS1yZqiSPwHUsrIyueTa23N7YzQakZiY6PH+zNLrMX//fnxiMmGHXo/UlhbM3L/fIzNRkpGRgfLycrcAZ21trZzNWVtbqxn8NJvNiImJcXstJMqfIeX5SNdA7bFKUlm/v/cnIiI6EngtwRw5GJf/7wksOW8BDpVVIxvRiNkfhr+ccAnEBdfBMXIYAM9S6K5mVmkNnZmVkIAbNMpapbJaZcBSSRRF3PH779A3NWH7unUY3xFo9RW0DERbJycYK/WVoGNvogfwRHq62202HwNvlL0Up8TGIkwQ0KoROJaCmNJ7zduAHK3ycD0QtN6N/vBngryWrmYw9wcMPBJRr9XZabvS4/Ly8lA/+wwsOfs+hB84hCm6OGwuPYhpx5yFT1a/haSkxG5YdeB0Oh0KCgqwYsUKHDhwAAMGDECWl42lKIqwWq3YvXs39imaMxuNRo9r5jq4RY3T6YQoih6TstW0tLRg1apVbmXC1dXV0Ol0crBULeio1+s9bpcGpvijvLwcF154oWpwThkEtVqtfh03kOfXMm7cOOTn57vdZrVaUVxcjFQANyjK2V2ZTCa0trZiwIAByM7OhiAIbmXz3rJWlbQCgcqfoc8+c29uL10DXz1UpfPyt+cqERHRkcJXCWZEvAkXr3wIK254BrtWFGEkwnGxbhg+/duLKLn5XIhT8uXHSdlTXc2skobOKHvd/aWiQjXrbVRkpFxW+2V9PeAl09ABYH1DQ3tVh8OB6pYWrOyYcB2IWL0edocDAtTPt6ukacfk3ZjISJgNBnk6tdQT0TVY1ux0qvYFHWAwIFynU+2lmGsyYZ2PfbavoKMrPQBDR9VatsmEJ1QmY3cnbxPkvSm02XCi1Sq/F6VhPN/m5BxRwcc+EXicPn265h9cF154IRYsWNDDKyKiviJuRDIu/+4JfHD+Qti37kQWohFTZ8Bp+efglaUvICcnM9RLBACUlpa6DXopLS3VDOrU1NRoZuI1NDSgqKjIIwjlLXAllRqbzWYYjUaPgTLKoKGyN6RrEFJtarTRaMS4cePcshU7Q6fTwWKxuAXnpCnT0vNXVVVh7969Hs+fmJiIpKQkAO3TpA8ePOgz6Kg8b0EQYDKZEB0djYaGBrlkX1nu7a1MXq/Xw+l0QhAEOStTer29Zfi6fk86DykIa7fb3aZ3u16b4uJilHdkNiinpCv5Ku8PtOcqUX/D/SgRqfGnBFMfZsDMl27FT09/gqLHPkQSDLjIOBwDnvkc323bhdZLZkEvCHL2VGczq1yp9bor0agI+a2jIkMKWPrq0Qd4lu36E+STgjVS/8BCmw3zKip8Bqg6w5/1xOr1OOx0qk5T7u9i9XocHRWFXc3NGBYRgcfT0916jLpm8cqtg1z+X7piUgafMgj4eHq613Jrib9X3gFgRlxcyLIFtYL5voKf8yoqVP99mFdRgR+PoA/w+0TgEWgvJbviiis8bh83blwIVkNEfUl4bDTmfL4Qq255HtuXrsMIhOMcDMF1p12Hvz53N2afd0bQnzPQstRAgjq+yojVglDKwJUycxBQHwYjHcM12Oetf48yaAkAAwYMkCd0S70KtahlRgJ/BM2Uwblff/3V7X5q123gwIFyL0npcUlJSZqBUEEQkJycjEGDBqG0tFS+XRRFjyxJtT6JWkFe13NTXkPXkueCggKfmYtAewBVmf3pSsq8dF1rSkqK6jkDf/TS1HqfdqbnalexvJt6G+5HiUjJ3xJMQRBwzC3nYODRQ7HqmqcQ49TjjLBkxK/4FSu3PYemu/+Me9LSIAKdyqzypdBm0yx9dQ0iSj36ppaUwCmKbt/zNztNS77Z7JGpVuRHexyliWYzHk9P73LQUgq8+Zra3B/ZHA5ssNtV+4jOq6hwGxIkBRsHGAyAIGBfayt0APa1tWF1XZ1qD9IpsbF4PiPD68TqQK2uq8Pqujrkm83Y1dyMIeHhACBna3Z3ULIzg2u0gv1at/dXfSbwGBMTg5tuuinUyyCiPkpn0KPguZuwYcxw/LTofQyCAecZh+GlG5/E5k2/4N7753kMnelK0CPQstRAgjomk8lntp5aCbLr8yvLel0pewY6nU5UV1djz549cDgcqsFFSXh4OMLCwnDI5VN+KVCq1qtQmWGpFnQ0Go0A/sgsdD2PsrIyr9dBOlfl65Gbm4uUlBTVzFFRFFFTU+N3GbYy4Cf1uiwrK4PZbJaH03jrexlIybPE13tGLQjr2jMyKSnJLXvWdZq6ms72XO0KlndTb8P9KBEpBVqCOfLUfFy46iG8e879iGhoxom6AYgra0DJXx/D0V++jQED4juVWeWNlMGm1fGwVRSRWFiIfJMJ8zvWbYmMVB0oMiYyEr82NXWqjLmoocEtcNnZgTS/HT6MhZWVeDw9HRsbGnD377/D5kd/caViux1R+kCLxPsP1/YAQkd7gPlpaarBXCcgl1Wvrqvzqwfpn1NTMf7/2TvzuDjqu49/ZmYPYHdZrgQ25CAG8AiE5TBq4hFvaepZz9Zaa30erdbaag+riT1Mta1Hq9b62GpbbW1NbeuJaI4aD1IPloVA1AAqmsBCQtgsuwT2mnn+WGaYmZ2ZnV2WK/m9Xy9fkZ3rN8fCbz/7+X4/VqvwLC80mwWxczLj5ccnFoxTCWEiTB9zRngkEAiEdFB343koOHIRGq/9NWxRYK2xENsf/w+uaP8IT/79EZjHvzkDJid6JFuWmoyo43A44HA4MDAwgPnz56O/v18QBXnkJcjysfPiWFdXF4LBoET849OZedxut67gGSAmiu7fv1/yWiAQEAQtuVhmNps1hUwg5qJUS2CWB84o4XA44q7/wMBAQhFZT0ANAOzbtw/Nzc2oqakR+mlWV1eDoig4nU68+uqrSfWS7OjoAICEQneiZ6awsDDOeVlUVCRcQ5ZlsXHjRslypbAZuQCv5MicKkh5N4FAIBBmO6mUYOYftQjXvP1r/OPCn2L00wHUwIrsfUGcUX0+/vbaE1h9VFnSziot9Ah8g+Gw4CgDlEuVaQA2gwGUwjI9RDgOF7S34/nKSqy221MWoQbDYWxKMFY9hIGUBEseed/DuQwH4L/Dw0LAkRILzWa8fuCAYunw6wcOCEnVYueh3CXY5PPh9NbWtJe3pxLCNB04VXpdOhXaUx3KzBnhMRQK4bnnnsPAwACys7NRU1ODo446aqaHRSAQ5iAlZ1Tjss334NkLfgLz8ChOpnOx4/1BnH78hXh+819RUJAHILHooeWITLYsNZkgHV7QYkTf0EYiEUk4jRx+7PIxX3bZZQAgea2qqkriltQj9phMJuTn56sKlLt27RLciQ6HAxRFweFwCP0l9SAX5Pg0arlrkmEY0DQNs9mM8vJyIXBGfD+Gh4fj+lFarVbdYqMYsTDKH8vj8YDjOLAsi+HhYcn6auXkPMFgULFcXk6y4UsOh0MiTiqF8Cg5L+UCvDhMaKpLn2eivJtA0ILMRwkEghKplGBm5mfjys2/wMv/+2t4/rMDZciAlXXgylOvxl1//Bnq609P2/j0Jk4nWieKWFnr1hUrcGNHBzpSSI0ejERwituNIzMzE/aR1GI2CH78DGgqxzLZ8nYxBgC1Npuq4DsSjeL1AwdUt9cSioMch95QKKHzcLXdjlNzciSuyXSRbAjTdHB/aakkXAZQTg4/1JkzwuO+fftw2223SV476aST8Ktf/UrxQzaBQCBokbPMgarffg3N3/sLDHtH4IQFtkEDzqo5H39pfBzLlx+ZUPTQckROd1mqPJxG3suPH7vSmMVj4zgOjY2NksAYrb6APPPmaSeEiwU9v9+Pmpoa1NbWgmVZzbAcMbwgxwtf/LZyotEoqqqqQFEU+vv74Xa7hZRwvsck/19RUZGkLHwy9Pf3o6GhQTIm8f/bbDaUl5ejv79fM6FavD8l9LQAYFlWCJXhkaeby/cvF0T55fL1xM8GMLWlzzNR3k0gaEHmowQCIZ0wZiPO+/P38d9fPYu2374IB4y42LAY9379Lnz4/U7ccus347YRpw3r7Wun1IcypfGO72u13Y4/WywYWboU9+zeja0HDqj2j1QiCuCD0VHV5XPFSZi6bKqfdImONABQFO4vLcXJKqEvEUDS21GMAfrOV4/zUN6egIdPOk/13qcSwjTVrLbb8UZ1dVpbJ8xF5oTweNFFF2HlypUoLS2FyWTCxx9/jN/+9rd48803ccMNN+Dvf/97XG+2RGi5TQjpg7/O5HrPbg7H++R2u7Gj6wMYr61G6F8fwLhrCKXIgI0rxtdPvwZ3PLYeX/jC6eA4ThA9VqxYIblGctHL4/FIljudTuH/OY7TdX1ZlkVbW5vEfSgWi9TulXwsFEWhpqYmbuxKYxa7DpUEseHhYcW0azF9fX2wyP7Qm0wmmM1mcBwX5yTs6uoSRKREv7/F7kalc1Wio6NDGG9vby9aW1sxf/78uP6YetyciRyKPNFoNOH++OutZ//Dw8Nobm6OewbEoTG9vb3gOC5OkFNyM86fP19yHL4UuzsjA6/k58OTmQnH6Ci+sH8/SsfGUFhYiHA4LLn2SuejdW0SPc96SOV9lAxz8fffXBrroQSZj85d5uL7/HDkcL5Px33vS8g/aiG2fvtR5LAMzjUuwFv3v4iO1g/x6OP3wmCIfWxv8vlw+o4d4ICJUBCvF1tXrNAUH3+0aBG2eL1gkHpZMs/tixfjLa8Xtx88iM8++giVFgu+5XDg1319k9zzBHNBdJxrsIj1cbyrpwe5BgP2J+k2TWbtKIAdIyOq7+XjrVZsrazE3bt3C2LcHYsXg+M4nL5jB6jxffC1XbXjYTKBaBTDKvvk1x2KRFA8XvJ9+6JFiu+LJp9Pcmy19dLF8VYrXpaF0MmvzVz9/ad3vBSXSjfXWQDLsrjyyivhcrnw2GOPYc2aNbq2i0ajaG1tndKxEQiE2Y84XZnjOETe/Az0m5+BAgUfotgUHkDFJcfhq1/7kuoHyb6+PokIxpcb86XEqSDfp8PhwIIFC9K2ndJ6fPhJOuDFRqvVisLCQnR3dyuWLzMMg6qqKng8Huzfv19R1OSv5/DwcNpciYkEVDURkL+fyfzJ5AW9XpMJxaGQIOjx4+CvEy9ua405Pz9fKHuX9/PknZRilNLDrVYrKIqC1WoVXKxb9+7F7ZmZAACWokCPn9/do6M4ff78ODeq/Polej5TfZ4J+pC3XCBMP2Q+SiAQ0snIx3vRccdG0GMRRMDBjQB25o/iF7+5AzabFTcdPIh3ZY4wGsBxDIOHs7I0990aieCJUAgfRqOIABgDBAGTdxjS46+pzXYqaBrfMZtx3egoONE2LNJbEjxZ0iGwHqoYAVxqMODpJIRHNQcqDSAbwLBsudozyT+D3SyLUprGN0wmOA0GzXWuNZtRNT7XaY1E8L+jo3FjyaEoLKQofDD+ZTn/XFIAHsvMlByjNRKJe36V1iMkR6I56Zy9sjRN46KLLoLL5UJLS4vuiR5PZWUlmaxPA9FoFO3t7eR6z3IOx/skdvlRFAXjKSVYckIlPr7vFdijDM41FqHp3614cN8B/OHPv4bRaIzbx4oVK9DW1oauri74/X6EQiF4PB6hrFnN5aXmAmNZNi6lme/nyKN0r1iWBcuyCAQCCAaDMJlMgstR7i7jxyw+dltbm+4+i4mIRqOw2WwoKipCX1+fas9EpVJpuai1fPly1NTUoLGxMW3CYzgc1nQwqi1L9ju67owM3L9oEUBRYAEMGwz4MCsLt+7ejdKxMYRCIYTDYVgsFpx55pnYtGkTBgYGFPfFP1eAstvTarXC6XRKniul5HP+XvAl5jU1NVjX0QFK1GOHpSgwAF4vLsb3KiriBNGCggJBANXjYFRy4oqf59nAXPz9x4+ZMPOQ+ejcYC6+zw9HyH0C4ASqT1qJf37pZ8Du/aiFFdn7Dbjlmjvx91efwGfBIFjZPIUF8BnDJPz76gRQJnNMMuP/1Vqt2BMKodJigTcSwXsqX0gPGQx4NiMDnEj84f+dCdFRSexcabPhk9HRSfWPPJQJA9gYieC7Cxbgt319COvYRs2BSgP4eWkpbu7uFlyK/PrRrCyMLF2K1XY7mnw+fP/TT/GeqLx+KBrF+6Oj2LpiBQBIHIi/KCtTdCA6EXuG5U7JVdnZWNvRgQ/Fc1rEnu1nMzJwtchteEdHByB7fpXWm27m6u8/vXPSOSs8AkBubi4AYFSjP4QaDMPMqRs61yHXe25wON2nmpoaABD64JWVlcX6Dp6+Gv+66GfICIzhFDoPbU19OPukS/Dca08hLy9Xsg+GYVBXV4eBgQGJyNPd3S383NfXF5fG3NraKgh94uWtra1xYlFRURFaW1slJdP8sfl71draCreoV0soFILb7VYMH+HHLL8WvHiqBy3XYDQaRV9fH/r6+jSfpXA4jA8++EDymnyfe/fuVbwmyYTAUBQlEQ0TleomStjWg9lsxttLlwIiRwLvJnwlPx/fHi9n552OW7ZswbnnnhvXH1LO0NCQ4usURYFhGMlzBWhfp66uLtA0jWafD1GZcBgF0DEyAoZh4HA40CcqnXI4HEkH2si3n62/Yw6n33+E9ELmo3MHcr3nBof7fbI58vHV/9yLF79+H/a+/QGORCZs4SJ8+ZSrUPzT6zBQviQuqGKFxaJ4zeT9IL2RiCA6AhPiI0VRWGGxoH1kBINhdSlqhcWCZr9/ykqh9fZ2pADcunAhfjPeciYqW7YsMxODaarmmWoYQHDfTRdRAH8cGNAlOqphBPBQWRmuLy5Glc2GW7u7JenNLr8fp7e346HSUny7uzuudyT/7P3g00/hCgSE+zgQCmGrRjjNyXl5OFmhp3KHQoCSeE6b7HozxaH6+2/qoiingR07dgAAiouLZ3gkBAJhrkHTNOrq6nDFFVfgiiuuQF1dHWiaRsHRi3HV2w8gc+l8GEChBlbU9ZtxRs35+OijLsV9JUraTZSOrRbiYbPZAAAulwu9vb1wuVxoa2tLuH/x6y6XCw0NDXC5XKq9+miajivVFWOxWGCz2WCz2VBTU4MKhW8DKYoS+g/xaPUGBBKLfNFoFC6XSxAebTabquil5rpzOp1TmoRstVqF+8RTUVGBzxgmbgLJUhR6Taa4fQwNDcUFvyihFlzBl03LnwO73Y6amhrYbLa40v9QKASXy4Wi0VGhvJpH3Ji7urpa2IfNZhOSuvVSXV2N2tpaFBcXo7a2loTDEA5JyHyUQCCkG0OGCRf+7Uc45n/OAQAsgBEXG5Yg884/gnl+k9DPjhcN15eUxO2jyefDmtZWbPZ60RsKYbPXi3cVUomjAN71+4X1gipVHhSgeBwlaCQvNNgZBnk6S10pAH/u74eZouLOp9nvR7PfPyeEDgrAmbm5ONZmm9bxcgB8k+wlGAVwU3c3mnw+RYEwilhQzc1dXWBVnqkogFaR6Mi/xo2H0yRDpcUCuVynFDajdz1Cepn178fu7m4MDw/Hvd7c3Iw//elPMJlMOOuss2ZgZAQCYaZhWVaXsJYsmfnZuHLzL1F06gpQoFCGDJwbdeDKU6/Gq6/+J259ubhSVlYmWS4XvtR+lr9eXl4eV36rJDKqnTcv3PGiJf+f0vWqrq6OE9B4QqEQrFYrsrOzhVLZ2tpayfocx8UJZxzHwWQyJR0mwrN3717Jz9nZ2aitrVXsn6l0DWpra1XXTxcUReGSSy6JE9cqLZa4P7A0x6FYQWzl3VJqAqnZbEZtbS3q6+tRW1uLBQsWwOFwxImBSs8VRVHw+/2qpeJf2L9fGBsQ/wGGpmlhH36/Hy0tLRJ3bSJ41+3atWtRW1ub8rNAIMw0ZD5KIBCmG4qicPKdV+KUX18HlgJyweB8YzHO+YcLSx/+CxYwDM7MzcUbTqdiQu6Gnp44QUeLRMsfLSuLHUfHvIoD8EhZGX5XVga7DvcWjZgQNqSzPJoFMBiJYERh/hfFhJtutpd35hsMWFdSgpZAYFKOxwKDQdd1TicsJgTCJp9P4nYUE4a6m5MfsZIY3i5qs9Tk86G+rQ0Lt29HfVsbmny+uH2tKymJVQGJ9q0kyutdj5BeZvt7EY2NjXj88cdxwgknoLi4GCaTCZ2dnWhqagJN0/jpT39KGtUTCIcpbrcbLpcLwEQaczJloFowZiPOf/L72P7LjdjxyMtwwIiLDYvxy6t/ho9+0IXv3HKdsK68pDkSicDj8WBoaAh5eXmoqqqS7Jt3fYn75LlcLvT39wvBNA6HA9XV1XC73ZKkaSVxSk1Yk5fm7ty5U5L0DExcL971yF9PMeFwWCgBFm/X398vKYNWcjBSFIVrr70WL774oq4EaTFyMbGwsBBArCw+UU9KcXm7WomyHIfDAYfDIUnEToTf78ezzz6L8vJy1NfXC8La7YsWYfPQUKxkSBTacvHBg6ol0FVVVejr64sLj1m+fDkA4LXXXkNhYSGKiookpfEtLS3weDzCc0PTNIqKilBdXY3GxkbFcZvNZoRCIZSOjeHW3bvx9tKl+JxhUGmxYH1JieQDTCLHLoFwOEDmowQCYaY4+uKTkLfMgecu/TmyxsI4gylA7rv70HfHg/hHw59hs1kVt2tXKCnl4cNXtEJYzBSFAqNRmBtwAOrb2uDXIQ7yjsRmBYelEvJ+kekgjNnvslqWmYlT3O5JB+FsWLoU63p6gGlOROYFwmTdiTwURcFptcY9J2IHIu/c5UX0/lAIWxRKsVfb7djmdEpaC8jntMmsR0gvs154PO644/Dxxx/jgw8+wHvvvYdQKIT8/Hx84QtfwNVXXy30OyMQCIcfUy2IUBSF1bddjoKjF2Prtx9FDsvgPOMCvHnfc+ho/wj/94d748qLAaCtrU0SBtLa2gqKogShkXdI8vBORB7eqQfEi5QrVqwQyvp45H30eOS9DMOynj3y6yU+FsuyqmnT/HZFRUUSUVQJjuPQ3NycdDiLFjU1NaAoSjG5WXxcl8uF6upq5OXlafZOBGL9VNauXQuapuF0OtHY2Ij9+/eD47i46ybH7/cL94+/b6vtdqzfvx//zMwUUq3X7t+Pc5cvR0dHh2R7r9cLQPrcABNp1fy5AFC93uLtxM+P2j0qKysTnsnaoiL8orpa1Y1YWFgo2QcvABMIhxNkPkogEGaSwupSXPnm/fjH+T8GPF6spGzY9ekYTqs5F89ufgolJYvitqm0WNAfCsUJOnU2G3INBknfRyXhx2m1Cuvd0t2N5vE5l14hsTUQmPFk6ensm5gK/mg0pWtEjf+XZzBgw9KluK64GH/q79fszzkVMAAWms14/cCBpLc9zmbDA6Wl4ACsaW0FMy4syh2ISs5dZtxp2Sgyd8j7ma7TEBNX2+2SbQlTz6wXHleuXImVK1fO9DAIBMIsRC6qTFUvvyPPX4XcpUX49yUbkHkwhNOYfLi2fIJzTrkU/3rlz7DbsyXrywU9sTtNyZmpJaDK3ZRKwSi8YCgX4jIzMyXOOrn4J79e8mPJBVH5dtXV1ejr69MU9UKhUNoSs/myc36ccselHJfLBY7jUFRUhIGBAc1SfJqm0dDQIITRUBSF/Pz8hIKlmPb2dng8HnAcB47jUBII4NsityXvYpVfM15YlD8H2dnZqK6uxsaNG3WPAZA+P3IxmXdF8mnmBAJBH2Q+SiAQZhqrIw9f3XYvnr/yl9j/fheORiasY/Nw0arL8ODGB3DSScdL1l9XUoItBw7ECTq82MOLNAvNZgBSFyQAidDYm4bwPYIUCkBXKqFkiPWFlItuzWkI09Eb7sPDAqol1mrwgqNYFNRyICo5d5VKsfW4Igkzx6wXHgkEAkENuRtwKoMr5q84Al99837844KfAHv241hYkfN57Jvmf2x6EsuWlQjrJnICygWmyQqovBDHl2bzIpNY3JInUdtstoTXi1/Oi2k0TaOwsBAcx6GhoQFFRUWor69HW1sb+vv7MTw8rDsZWw/yMe/btw8ulwuVlZV47bXX4npAKqE3rVtcTq6FPCVbTCgUUnSeAjHRkXdU1tfXo7GxUSip5oNe+JAYnqKiIrjdbs3x22w2WK1WydiHh4fx0ksvSUr2xW5GlmUlCdqJ2hTI+4zKfyYQCAQCgTA9GLMycPE/1+P19U+i86mtWAQTLmYW40cX/xBf3/C/+Mb/fEVYV62klHeYiUUaIOaE3BMMqroglTBTFMIcFydWUYg5JpMVpQ4nOADhFCqCogAqLBbUt7WhORAAOA6+SCQt7tJkHaLJjp4BkGswKJY/qzkQ1Zy74jAYxX6mHIcL2tvxfGUlER9nAUR4JBAIcxa5Q2+qsRTm4qv/uRcvXH0v9m3/EEciE9ZQES458Su47+lf4rTTTgQQL4hyHCdx/cmFxXQJqOLr0dDQIFnG9/TjKS8vB03TYFlWECv5EtqBgQHFknBA6oLs7e3Frl27YLPZQNM0rFarLpFPS7wDJkqMPR6PRMjjBbpdu3Yp9kgE4sXKdAqhQLxrVC8URQnXuaioCGvXrkVjY6NEcN6/fz+qq6uxd+9eoffns88+q7g/s9mMiooK4Vlxu92C45X/DwD6+vrQ19cniJ78unKRVatNgVwYLywsFBya/HNCQmMIBAKBQJgeKJrGaT//OuYvL8Fbtz2BPM6AC03FeP7Hf0b7jg/wwIN3CX+XlQSd+ra2+NJVxAShd8bnfQu3b9dXUj0uOlKQilCPlpWhwmpNS/9CGsCxNhs+Hh3FoM7wmUMZCsB9e/bEXfO5gNipqFQarSQQqjl3xWEwav1MByMRrGltJc7HWQARHgkEAiEJDJkmXPTM7Xjzp3/Bh09sQjGMuMSwGD+94g7s+vHX8c0bro4TRPkSV6UwGf7ndMELifL0VXFPP7G4qRTQI/7/2tpaiTgp328gEJCIgHy4SWFhITwej6KL0GKxqAqHABAMBtHX16cqGmptO1sZHh4WRNTe3l50dnbGiZihUAhdXV2wj0+MWltbVa9BRUWF5BnTKj33eDxwu92CI1beYxLQdtkqCelTFepEIBAIBAJBHxVfPhV5pQvwwhX3wBKK4ExmPpqf24Gi986D88H1+PHRRymKLXpKV5VcZkrwAS4sACMAejwspMJqxWq7HW9UV+PW7m60js/dlmVkYNd4ebF833yJ95GZmegaHUUYMZGNGQ9RfL6yEie53XNObEs3nOzfZDEAmCn5lncqJlMarScMRut55RT6QRKmHyI8EggEQpJQFIVTfnIV5h9Tgte/93vkcgzONxXj1Q1/R3vbB3j4d/eAYRhhfa3eib29vZKef5MVcsRCIhBzAJrHe/coOdO0nG78Mvk+taAoCmvXrgUQ77oUr8Ond4vdeTyhUEizTFwNvevpIZErU2l9i8WC0dFRSR9OpVJoQN2JyQu5vb29sNlskmU0TcNgMCA/P19RrNYq8e/v71e9j3w5thry51d+X9WeIbFgTZyRBAKBQCCknwUrj8SVb9yHv567HqZBP46nsmHvG8VzV3wPp9z7Xbxx5ulxQo6e0lUllxkQK8duDQQQFM2R+PLcMABwHJr9fsFlBsSclAVGo9BLMtdoBMa3X5aZCQBCiTdfCn6K2w1gohz5Xb8fp7jdyGYY+KY5uflQgkZMdJxOtyR/LLFT8S6dgTE8icJg+OcVCnN3uaguRq/rkjB5iPBIIBAIOokTUi4+EbnLHHju8ruRNRbGGUwBmhs+whdOuwz/fPnPsNmsivuRCzVDogASpeXJIN82FAoJAS8ejwc0TUtEIC2ximVZNDc3Y+fOnbqPLxbr5PvmhUFebKytrUVRUVHC8BklQZFhmLignXSJjkBMbFMK8tFCyYk5NjaW8hgOHjwo+ZllWUGUbWtri3OjFhYWoqamBgMDA/D5fJLxFBUVxT0b4nLtZARBtZ6k8vcH/zMQE9Q5jkNdXZ2uYxDRkkAgEAizhdkuTtgWFqDh0WtQftvTKP94EMuRBVvEgX/fdC++d28Y/73yMsn6WqWr4nOttcbmsWJRcJXdjoXbt2uGzfAi0q3d3XAFAoLAJN6GP+b9paXCtWzy+XBXTw+2er2KzrUogGKzGT7Z/IigDwYxkTjZAJnJks0wsDKM5BnS47pNBt4VeUF7e1w5Pp+8Xd/WJnkPA/G9TkkgzdRBhEcCgXBYkA4hQ6ksuba2Fl998z5sPO/HQP8BHEfZ8NEnYzit9lz8+IEfgKJYyfFYlo1LV87Ly5M44iaTzq0lJCq5KnmnW0dHB4LBYNz6yaQ6A7FJJBC73hzHCa69srIyDAwMSMYm7iupxahC4p+S8ChHywEpdzRSFIWioiLhdXmAisViwYjGZEjNIRkOhxEOh1W3MxqNwrXi/9ODkhu1t7cXtbW1WLt2reLz7na7JddfXq6t9z2i1pNUPhaTySTZrqurS7fwqPZeIxAIBMLcxtfkQ8+GHoy0j8BSaUHJuhLYV8/eD/lzJS23lQ3jlTvPw2VPvIVT3uzCYphwpWEJXr71t/grS+PKqy4R1k0mdIaiqLhz1VOGHYV22rFYnMw1GNAcCGAwHE7oxPNFIvhdWRm+1dU1reLZXIdCzK06E30yx1gWB046SfKaHtdtsqy22/F8ZaXkGVZKaOffw7VWa1KuS8LkIMIjgUA4LEiHkCF3jPE/Wx35uOqN+/DcV36JoeYuHINM2Ebn4fZv/BTnfO10lJYuEY4nD/ZwOBySZOhkw2XkYlFVVZUQMqLnXMRltHrLqbUYHh5GQ0NDXKp2W1sb5s2bFzd2rYRkXqhVEhi1xDw9GAwGyT6MRqNwH+TXgWEYoUfmzp07FcVMuZgsRy5M8sIpPwaHwxEn8hYUFKheH16cVnsmlYKXqqurwXEcurq6wHEc+vr64oRJPe8RtVAn+ViSdYxq7WsyLmACgUAgzA58TT60romJAogCof4QDmw5AOc256wVH5XScmejOMELOc/8zynoLcnH5U+9gwIYcLFpEZ7+4WNob/8Iv/jVOuELYt2hMwrnuq6kBFu83kk753hxUryfRF+/LjSb8WR//5wUHafbaSiGA+AKBFBrtcKrI618quFdt7QoET0K4PyCgkntV0lUlye08891ayCQVtdlumjy+XDP7t2z1mGdKqRuiUAgHBakQ8iQOxHFPxuzMnDJv9aj/MrTAACLYMJlphI0PfkWtm9vEY4nPy7ft6+2thb19fUAgMbGRjQ3N6O5uRkNDQ1wuVyqwhYvFvX29sLlcqGtrQ3l5eWSdWw2GxwOh+a58AnW8r6CycL3J5SLaNFoFP39/bBaJ8rPPR6PpmBnMKh/N6bHGahVei0XLkOhEF555RV0dnbGrRuNRtHa2gqapnHVVVfFXUsek8mkev3kzkFxD1AgvtweABYsWIDa2loUFxejpqYGNTU1KC4uljhVtZ5JtTH4/X4EAgF4PB7hueHFazHyn1mWhcvlUn0m5ceeP3++5OeysjLVsclJ5rwIBAKBMDfo2dAjiI4AgGjs73nPhp6ZHJYm6S4JTUSTz4f6tjYs3L4d9W1taPL5dG23rqQEFEWBAfDWmRV4+LZ6BBkKVtCoNxRiz9/fwUVrr1KsIuHRe66r7XZsXbECxzEMzONC5mRIRoxr9vs1nZTpIt0iCYWZEx15kuldnk6c1vjWU6vtdjxUWioRmmkAN3V349He3pTeA+J9N1ZVYc+qVbF/g0HF5xqYcERC9PNkXJeTpTUSwek7dmCz14veUAibvV6saW1N+hrMRojjkUAgHBao9aVLBrUSUx6KpnHaPddg3vIleOtHf0I+DLjItBCvb/oYzwRfQn19veY49CRMy1ESi3gBU6kUVm3svIuNd77JXZPpCm6RT3j3798PhmHAMAxyc3Ph9XqF46SzZ6MeBgYGNCdl/f39oGkaa9euhdvtRnt7u2SMoVAIJpMJDodDEPd4MjMzNdO4IwplL3v37hWCetRI9EzK6erqUj23RO+RRI5I+ViqqqpSdvIme14EAoFAmP2MtI/ERxlHx1+fpUxFSagSTT4fbu3ulohqyZR1y51eJSdWYMXJx6H7yvtgGgpgFZWDne0BnHrs+Xhu81/gcMS3ulEroR4Mh1Hf1iZxXq222/FwVhbOGR1FcJpKdxlMTyDKVIiEsyGJO4pYv846m21axFuelkAAx7tcQj9Pvo/o6wcOSK4LCwAchxu6ugR3aG8ohFe9XvyurAwrrNaUeq2qvYedVitcgYBir9OZ4olQCBww6x3WqUCERwKBcFiQDiFDrcQUkJU8H12ELz5zG1766q9gCQNnMfPx3lu9OO+sr+Dvz/1BdRx6EqblyMUilmXR2NiIoqIinH322WhraxN+1tPXkj/H/v7+hOXacvQkQasFwkSjUdA0jXnz5knOx2azITs7Oy4sRQs9/R/1ID8fvj8nf43EaeQ8fCp1dXU1+vv7hQRvcdAKEDtvo9EoOC+VxisOaFHru6j2TCbb07SwsDDheySRI1JpLKmOTeu9RiAQCIS5iaXSglB/CHIFwFI5cw6jRGgFsaQLvo9kRDaHSlZ0UCqfXvXWA/jXpRswvPNzrIAFNp8BXzj2IjzxwqOoqV0hWVd+rjxBjsNmr1dRBJ1OQS2VmR2TwnazQSScKiotlilz6zKI9ZEEpP09xankD5eV4dvd3ZKSfjGs7F+eG7q6BHdisr1W1d7DD4w7LuW9TlfNYFlzN8vOyvLvdECERwKBcFgw1UKGUsjHVW8+gI3n3QnsG8YqKhsf7BrFGSvPx7+3/FVxLFrBMMPDw3C5XFixQjpJFItF4r6Kvb29EmFMT19LsSDkk1n69SRLJxIdEwmCQ0NDqKioiLsGRUVFceNRgw80SUV4NBqNknOsrq6WBOx4PB4888wzsNlsoGlaU5jdsWMH5s2bh3POOQdGoxHNzc1x6yj1qeSF1mT7LsppaWkR0sLFidJlZWWKKeJdXV2gKEpToEyHaxggwTEEAoFwuFKyrgQHthwAx4yXWzMxAaBkfclMD00VtSCWdIoTfB9JJSYrOpizs3D5y3dh03f/Dz3P/xdLYcZF1CLc+IUb8N2HfoBLLztPWFd8rq8fOICgaExRABgPg3lnDv3NpikK0RkqMZ6NrC8pwV09PYrO1nT07PRHo/hYpZw/CuDOTz9VFR317F/8/3pF+UTv4dnkJCylaQxFo1PusJ4JiPBIIBAIaUDJDRYTH+/Hvy77OXw7elCBLNgCBnxx5cX4/fOP4NhjnZJtxCIin/bc1dUFv98Pv98Pl8sFjuOExuCAVFBtaGiQ7E/eN1CpZ5/YecZxnKIoBcQEMYqiJGLb/Pnz40qKtUhUbpyXlydcA77Umz9veUKy0WhEJBKJm6inUp7NOxv5bW02G8rLy1FdXY1XXnlFsi7vaEwE39OytbUVFEWhra1N11jKy8slIpz8nrW0tIBlWdTW1mo6GOUl1XyidE1NDSiKiksx568zoC4Cpqv8OdV+q+lIpicQCATCzGFfbYdzm1Oaar2+BPZVszs4QclJmE6UeivyTEZ04Eta20dGUHntibh2WSH23v885sGAi0yL8MTND6Kj/UP89K4fxIXOLNy+Hb0Kc6p3/X40+Xw4frxv37LMTOxX+CK2xGRCodmMlkAAUY4T3GqTiwZMHrmL9HDmOJsNq+x2rCspwWavN255OsrLPzh4UHP5UCSiehxmfAx671gyovxUv4fTxTdMJrw/Oio4dWdD+Xe6IMIjgUAgpAE1N5jJmonLXvwZtnz/9/jk2bexBCZ8iV6Em8+9Cd+67zv48pVfihNU6uvrBUFlYGBAIvb19/dLwk3E28rDPoxGo0RcStSzTytYZsGCBQCkyddqomNRURFGRkYEMY8X9NQEO4ZhMH/+fOG8q6ur40Je5D0Q8/PzkwoIstlsOHjwoKITUsllwItak23E3d3drbtk3eFwoLq6WvOechwHt9udsoM3UYq51jVVOmYqYmCqzknilCQQCIS5j321HVWNs18AmE7UeisCqYsOfPk27y7rDYXwqrMAF6y/AGfc/SJsUeALxiL8909v4rKdu/CXZx6F2WyWjElJeARiDs2XKypiP6jMk3pCIfx1+XKhDLbJ58MF7e0YnKZ+kDwUDu3S6WR4oLQUQEyEm+4+jzx5BgO8kUjcs24EYDcYEOY4+HRWLR0qTkAxToMBW1eskKRaz3T5d7ogwiOBQCCkAS03GM3QOOuB6+E+Zgne+enTKIABFxkX4S/ffxQ72j7AxZfVS8pigQlBJZnADwCwWq2CwBcIBOBwOEDTtFCG7XK5BHEokXDHbys+H47jBDfdQYVvNflwldra2rixqVFUVCQJUXG73XFiHS/AURSFoqIiietTD1arNW6fDMOAZdk4cdHv92Pjxo1x6eDpwmQyYd68eZg3bx66u7sxMjICi8WCs88+GzRNw+VySa6bUu/M/v5+uFwuRcGPZVlYLBbJ+ZaOTzZ55M5SnmTLp1MRA1N1TqYjmZ5AIBAIhNmGWm/F42w2PFBampLowJdvyyWc58sL8O49X8K6DS/DPDyKk+gc7GgewmnHnY/nNv0V8+cXCGN6VcEVB0hdZns0Kk0uaG+Hmaax0GxGs98/IwLgTCdJzxZuLS4WnqMmnw+tOquV0gkD4K6lS3FTd7ek3yIQu0+8ICkXi+nx13gONSegnNV2Oxrz8mZ6GGmHCI8EAoGQBvQ40KqvrUfBkQvx8tfuhTUM1BsK8c7f3sEtb72DNWcfD5qiUFgodfLJRZoVK1Zgx44dwnK5+CLvG8gLh7w41NfXJ+xX7qYrKysDRVGa7jV5ubWcUCgEt9sNiqIwMDCgeT145CEqw8PDqutyHAePxyNxfQIxMS8SicSdEwAhZVqOVh9IvvTYOl5KxKMnuIamaRgMBnAcFycAAjG35tq1a/HSSy9JROLXXnsN5557btw9lfeeBACfzycIfXLBj7+OcuRCpTjFXEsE1HI1piIGpurWTFePSQKBQCAQZhN8D7pbu7sFQchpteL+FEVHQLt8e6/Djlcf+wYu/fG/EejsgxMW2PcbcXbtBbjvyXswf14BjlpQiOMUXHFyl1mlxYI+FfGRdzeqOScni51h4I9GZ624yAAwUJSkV+ZM8WBvLy6cPx87AgHcIGvHM9VQAFaKRPRKWTq1NxJBs98vPK8cYmJjnsEAM00Lrj+9QTCSFgNJpF8TphYiPBIIBMI0suikSlyx9Vd49vwfw+QdwWo6Bx29B/Hao6+BBQefIYRf/HadsL5cpJGLXnIxJi8vT5K0XFRUpCgOud1uyXp8D0WtUlmWZeNKoE0mE8LhcJwjr6urC2VlZZKxiVOceaxWq9BbUq2/pBJ79+6V/KzU21Fcwv3ss8/q3reYEVnvGD3Co8FgEMbT398ftw1/feU9OPmf5fd0+fLl8Hg8GBgYEK6zvGxdfI+VxL8dO3YIYxALlXpEQC1X43SKgenqMUkgEAgEwmzEFQgILsVmvx9rWlt1pfYqoVW+HQWwKRpE64/PxVd+uxVL/tuNI2DGBViIu768HiNsGAfZEOp/+HW4Vi4XxqTkMrt90SK8puKMnGqGo9EZK6M2UBTKMzM1expGgVkTbMMCuLW7G++lUF5tpCjUWK143+9PSeSlAOQaDMK9kvdbnNfUFPecsgDMNI09q1ZJXk/Up1HeYiCZ9GvC1EKERwKBQJhmcpYW4aq3HsA/L90A/we7UQULys2Z4AAMIYK7b/wVMjOtqK8/PeG+5GJMVVUV2traJOKM2+2OE4fk4lQoFEJLSwu6urqEYBUAceEzcvdeRUWFJPlZC7PZHCc8BgIBtLS0gGEYla2U0RL/eKEvGo3C4/Ggra0tLs1ZXJKuhVxQVUr3ttlswv78fn/cciWxGIgXifPy8oTSb77fZllZGZxOJ2iahtfrlfTsVNon///yZHD5GJIpU9ZyNU6nGDjVyfQEAoFAIMwU8tLoZFJ7leDLt9V6MAY5Dru5KO795ik4s9iO8/7pQiEMuMhYjCg4BMHhnV+/AMfx78Nx2zfRG4lIXGb8vGK13Y7flZVNu4sOmLnejQYAbzid4ACc4nanlNA83bAAWgOBlK5ZhOOwIxBQFB0NAGptNuwJBhGIRhX7M7IANnu9igJgk8+HwXB85BCN1Po3pvI+Ig7J6YEIjwQCgTADmO0WXNGwAa/d/Dt89uK7yETMBZcFEy42LMa9X78LH36/E7fc+k3N/fBiDF8O+9prr8UF1CiJQ3IxkkecbgxA4nSTi4MmkwmdnZ2KAl5ZWVlcqfXo6KjqeSRyESaDPD27vb0dFRUVqKmpwcDAgCDQNjY2xgmmVqsVNpsNQ0NDiiJfIBCAxWKROCGXLVuGlStXoqGhQbUM3WQygaIo5OXloWp84lNfX4/GxkYMDQ0hLy8P9fX1cLvdEoGUT8RW6pWp1IMTiN1vjuPQ1tamel2TcSZquRqJGEggEAgEwuRRKo1OJrVXjrh8WytEJEpR2Hx+NeYftQgn/OIlmCKxLnuZAE5nCpDz3n68eN16PPPSH3HWwmLFfXyzuBhP9vfPSFjJTBABcEt3N/YEg6iz2TAQDKJnisrJ00kityI9vo68xyIHYFRFwM4xGPDO+DxQ7jYUoyYAbujpEY4rhgNU+zdqCYXJvo/0OCSJMJkeiPBIIBAIMwRtYFD/yE0YuvkijO0fxkDbx/jvPRuRwzI417gAb93/Ana278Jjj98Hg0H717VWOSyfFM27F91uN6qqqtDX16fqVOzo6BDKr3nkIpY4sZrHbDajoqICVVVVeOWVVzS3V0IepGK1WoWEbL3IhVDezVlbWysJsVEqKbfZbFi7dq1mMI68/LqtrU0IqlGDv068A5Mvc16wYAFomkZhYSFaW1uxc+dOyXZqzkSr1Yq1a9cqngNN06irq1N1ovLp2XpRctWqBdsQCAQCgUBIHqXS6Mmm9q622/FOba1EOBkMh+N6DkYBbK1cgMdafotrG97Azr37ccGTTSgcOoiVlA32QSNuOPEybH79b1i6dLHisfaoVGQcqvAiK9+/Ukk8m22ENebSFICzcnNxfkFBUu5VXySChdu3C4LcNqcTG3p6sMnrjbseSgJg+8iI4nXLNxhU+zdqCYXJvo8SOSRJ6Xb6IMIjgUAgqKAVqpFO8sqLARRjwQlHo3j1cvz74ruQeTCE05h8tGz9FGeffAn+3fgk7PZs1X3IBapdu3aB4zjB4cf3UQQmhEmtcwkGg6plvVp9DpcvXw4AePbZZxXdf/Jt5UKj0WiE2WwGEEti7u/v11USrQf5NVIqSfZ4PGhpaUFNTU1c4rMaHMcpBtEkGoe4r6WS+5Qfo9LycDic8FmULxeLwnyPT47jJK5JNSFT7GoUp27rTbImEAgEAoGgjjzZOp2pveKeevVtbdjs9SoKMxm5Nmw7Ig+9C63YubwY19/7Co7ZtRdHIxO26AJcvPpy/PqZB3DyycfHHUOrp+RspcRsxufBYFoEw9kuOh6dlYWPDh5ULbU+OzdXENqSKccOIya+ekIhvOr1osBoRJ3VimNtNklgDKAsAKoJhXXjLYfkaAmF60pKhGRs8b603keJHJLpboFwOEMsCgQCgaAC73rr7e2Fy+WC2+2e8mPOr1yKq956AOaF+TCAQh2sWLGbxmk156K7+1PV7eSls3zvRH7sXbJvL/v7+1FYWCh5zeFwCKIfj1LvRaXXLBYLHA4Hurq64HK5VAU7sejocDjgdDoly0OhEPx+P/x+P7q6unT1jtQLy7JoaGiAy+UCy7KorKyMc3UCMbcnAJSXlye1f6WAG61x8MdRg3cmVldXx4maeXl5CY8jfyYqKipQW1srlG7zjtdkn+9UkqwJBAKBQCCow5dGn5mbi2KTCWfm5uINpzPlVGs11pWUgKIo8DM5GjExpTkQQH1bGxaazWAAhM0G/Pb2c7HljKMAAAthwpeYxbj9kh/i8d//NeF+08lUCBYUgEKTCTRFTcHeZxc/MpuxLxTSFBTPLyhAk8+HUxLMBdXuLy+8DobD2Oz1onn8cwC/vpoAKH9uEgmFcjETgCSMqVn2+aPOZtN8H1VaLHHnJBZI090C4XCGCI8EAoGgwkwJLFnzc/CVrb9ERuVC0KBwJDLxhVARLjvpSry+rUlxm+rqaiGQRA9KPf78fn+coDV//vy49ZTKnimKgsfj0XQIUrLJ3dDQECiKQk1NDYqLi+PGny6nI49cZHv11VcVxcJQKASXyyWEvMiFVqPRqLh/JRFTjM1mg8PhEMaRSKikaVr479JLLxWEYYfDgfr6esm6LMvC5XJJhNXq6mrU1taiuLgYtbW1kpJpJfQ+3/JnZyqTrAkEAoFAOFzgnYl7Vq1CY1VV2kVH/hi8wFkwnjRMQ1kw4mgKz3/tRPz1GyeCpYA8GHChqRgv/OQpfPfb6+NazNRarTBQFMwUBTvDTEpoYAAcZ7Oh2GTCWbm5eLSsDMqzr9TgALzv96PWaoXlEG8X83AwCF8korqcBvDC4CBu7e7WdKxeMW8e6my2hPeB30edzZZQSE9GcG/y+bBf4Tz4uyfvLckglqat9T5KJHwmEibTRZPPh7UdHagPBLC2owNNPl9a9z8bIKXWBAKBoIJWqIYW6SjRbv9wJ4LnL0Uki4Xh3T4Uw4iLDYtx15fXY/U1ZwgBJTw0TaO8vFy1LyFftswHmVRVVeG1116TrBMIBBAIBCShJUohLPJkan7bRGRlZUn6IwaDQbS0tICiKBQWFsJisegqbTaZTMjLy8PIyAgCgUCcEMowDDIzM2Gz2bB//35Fga+/vx/79u1TPUbreD8XHofDIaRWK52/w+GAw+GQBMMAsV6MdrtdeA4aGxsTnh8Py7L4+9//DiAW1iPu6cgLjR6PB8PDwxgdHRXcpL29veA4DnV1dYol0Eol5vzrep5dpbCi6WpLQCAQCAQCYXLwAqe87Jov8a6z2ZBrMAgi5K4zK/H2kYuwet2zsIQiOJOZh+YX2vE91w68tOnvaOdYSR88BkAgGgU1/v9RTPRA5P/lX1ejzmbD14qK8OLgoOAuq7HZ8L7fn7ayZhZIayAODcDGMIrJzjNJohk6Cwj9P9WgAJyUk4N/dHXpKqePItb3850ErXiUglvUhMINPT1xwTf8+EFRKTkTeeFTPIb1ojFMZQsEHnkfyS1eL7Yegn0kifBIIBAIKigJLHrQCnrRS39/PyiKgumsUkQKrcBLncjlGJxvKsYbT76NG/f+AJd/9UvIyDDj2DonDAaDZLx8GbW4xyMvHno8Hjz77LOqPQlpmpaEsPBhK/39/fD5fCk7EbOzs3HUUUeho6ND0j+S4zj09/erOgmBmNjIC4ihUEjTnReNRgURVaksHIiJbFr7kIuZgUAANptNVRilaRpOpxMejwd79+4FwzBCUjXDMHC73WhsbIxzBxQVFQlibGlpKQCgu7sbwWBQIvbyAi0fEpSo/2RXVxfq6uoUl/HPiVKPRz3PrlKSNen7SCAQCATC3KHJ58PrBw4oijV7gkHcX1oqEUP+4bBg8y8vxvd+9gLs3lEcT2XD3juKM1ZeANxyJbjRUURLFgF2W5yAyQs65xcU4IVxIbHSYoE3ElEsnQVibsR3/X5BqOyfI6nRvmgUl8+bh2c0vtyejQSi0bjQITE0gDs//VR3D089rsBkg1vUgmj4vpJqvUvFx1NKpxb3QJWPb0NPD3L4zxIUhTqrVSJMpoPDpY8kER4JBAJBBSWBRQ9qJdrJuMLErjRDVRHKVlXjgzv/iawQcAZTgJbXurG+4Q6wXBQBK4f7Hv0JzjjjNNXxvvzyy5Kf+T6KfBqzWGjjnZ3y8dbX16OhoSFl4XHBggXC+JScmXJRTuy83LVrl+4eilqYTCbk5+fD4/FohuTI8fv9OHjwoOryoqIiIbAFiImfQ0NDaGtrA4A4JyTPggULJAKhVn9MPpFczdWqF63nOtX2AqTvI4FAIBAIcwNe8IkoCE28WKMkhgwWWPHjX16CG37xCso/GcRyZME2YkDTj5/C8RyLfdGD6Lr5UnAnHqvqeLu+uDhuHIysRBaY6BnI/8uLmbPRUShnromOABJe0yiAIY1ybTF6XYHJCm6qQTRWa0JnYrIip3x9fn9ajsxUOVz6SBLhkUAgENKMWol2Mk5IuduS4zgYvlmH4B9bYPKHsZKyocZoA4tYmtwtV92B//nRVVi9+jjB5SgWNpX6MgLSsBebzYby8nLh2PLxdnZ2xiVdm0wmzJs3T3BYdnV1xQlnDMOgsrISHMehoaEB8+fPh9VqjRMwOY6TiI3icYyOjiqOPxF8yTVfYs4LhErwDlA1YVUuUtI0DYvFgrKyMlRXV+Opp56SLA+FQmhpadHs/djV1SW5X1qCXSKXphjePZksqbYXSHU7AoFAIBAI0wsv+CjBizWX7typ6G4LZprwmx+fh8v++BZOeaMLi2HCAsMCcAD8Rhb/+W0j3vx0D9grL0joeBOXuW7yehOWUEeRWCAjaGNnGBgpCr5IBOqF1fHw/RIHE4iPvPtQjyswWcFNS1xclaBkOlmRczpdiGqCarr7SM40RHgkEAgEneh1LKqVaCfjCpO70hoaGkBlm2G+YSVCf2+H8fNhobnzETDjUuNS/P3uv+PDCztRU7M8TtjU028vOztbckz5+NSceMPDwxgeHlYVu6LRKAYGBgQ3oFJ/QSB2fT0eD2pra4VxvP/++4pCocViwdjYWELHYnl5ueAoZFkWGzdujFvHYDBg3rx5oGlaUqLOj0cNPrxFfJ5KaDk1eecp35dR7vo0mUwwm82CuOl2u+OuH19OLj6+PMhHCaXnOdX2AqluRyAQCAQCYXpREnwAwExR+M94sIeSGMLD0TSeufYU9C7Jx2V/eQcGLjbnyAODLxqLkPdqFxp7HsFtzzyacCzifpN6xMe5Dg3gWJstrb0lkyEQjeKN6mpctnMnenVWEvEC311Ll+JbKj0ej7PZ8EBpaVJuwGQFt0T9GNVKpoHkRc7pdCFORx/J2QARHgkEAkEneh2LaqWsk3GFFRYWore3F5SJgflrThzjOAJcOIod/9gGuulzzIcBXzItwubnO9Dftw/1a0+RCIfyY4t7JoqP4XK5BPGIP6YWoVBI2I+akxCIJVjrpb+/XxDFWltbFdcZSfCHny+pHhgYgMvlEkQ7JfE0EolIRFFe7CstLUVRURF27twpuVYMw2D+/PmoqqqSiHcZGRkJx0VRFIqKikBRlCA68sjdonxgzcDAgCAkVldXo6+vTyKIOp1O9Pf3S+7VwMCA4vHF4xULq+LnOZX2Aqm2JSAQCAQCYarxNfnQs6EHI+0jsFRaULKuBPbVh05oQ7KoCT6n5uSohmoo8daZFXCdUIoc70Hk7Q/gq7/7D7JHIziZzkVO5wjurL8a/37tL8jPz0s4pnUlJXjV6530uc12WAAn2u0zJjwCMTeflrAshgZwZm6uIPBVWq24tbsbrYEAWABZNA0jRSF3PCFdjlpfxSafD95IJO4ZTCS4aYmLWiQrck6nC5EXVO/q6UHLgQOoycnBnVNQ0j3TEOGRQCAQdDLZPnZ6XWFKTjQ55iI7amtrccAYQu+ibET/sRM2lsFaYxH+6/Liz33/xgMP/1T12FVVVWhtbUVXVxeAWGoyAImwarVaJWnOPHw59PDwsK4UagDIy8vTdA+KKSoqgsvl0hQyE8H3cQQmRDW994sXU91ut6JAG41G4fF4hP6N4p6L/Pomkwkmk0mSNg1ACPmpra2Fw+HQ7NcYCASE3pBiYVAc9sM/Hy0tLRLhkXduytHqEan3+pAEawKBQCDMFXxNPrSuifVqQxQI9YdwYMsBOLc5D1vxUY/DSu4uW2g2CynXYjHmoDUDB60Z6FuUh5/ffzl++POXkdd7ANWwIHsgiBOcX8SP//1bfOXYGtXxNPl8uLW7e0rOdTZy/549iunM0wHv2tu4fHlCYRkA8gwGidC32m7HO7W1Qg/EQDSKKIDNXm9cz0R+HZbjhNZQr3q9uHXhQjw4Xukjpi4F16ReknUVTrcLcbXdjoaKCrS2tsJZUaEajjmXIcIjgUAg6GSyfez0usLkzsq+vr640tmdO3eCpmnU19fjL4ODCF6XgfCfWmEei+IkOhf2gRF8/5s/wXObn8a8efmKx66rq5MEmzQ0NEiW88nQNTU1oChKSEHmeyBaLJaEwiPDMHA6naiqqkJbW5uQuN3Z2SnppcgwDLKyslT7JSaDyWTC/v37Ja91dnamtC+tMunOzs645eLkbZPJpFp+3d/fj/r6euH/+T6eaiE0/HpA6u5ClmU1r4OaWCnfR0NDg6JTkkAgEAiE2UbPhh5BdAQARAGO4dCzoQdVjYdOYmwyJCpZFa8nFp3E7rXBcDguBXnYloG7NlyIrz64GTWte1CKDFyBRbj/i99C/yM/wq0Xnxs3Fq2gGy34tGv+37nGTIiOQOx6VVoskmegORDAYFi54+NQJIL6tjbBqcijpwfihp4eQXQUc/+ePXH3je8hOVUuP73PfKrrExJDhEcCgUDQSTJ97CbjCpM7zzweDxwOh+S1UCgEl8uFvr4+5Ofnoz8chulbKxH8cytMg6NwwoLs/QacVXM+HvnHr7Fo4QLk5ubAalUvEZALqzx8+Im8NNjv9yuGxIhhGEYQpcTiFEVREued0+nU1S9RD0pioV5nZjIk2qdWIE5RUVGcgMiyLCiKUhUi5aXw4mdKXlqtVGqtVmqeDOLkbp7Ozk7ieiQQCATCrGSkfQRKzdpG2g+txFg5aiWuPKmUrIq3OaetDZsVejKOGRj84Zaz8YV/ufDFF1rhgBGXmZag4VsP4EdbtiFy2iqU2az446rjsdpux63d3UmLjgBAUxRuKS7Gn/v7MRSJgAagL3N59sIg/lFNNyyA8wsKAEjv5/Eul2L5N4uYm3Gz14s6mw17gkFUWixoDgQS9kBs9vtVRWH569OR4pzsM59qWTdBGSI8EggEgk6ScZpp9YNMJEoqCYD8sdvb2yXCmsfjEdyQVKYR5v+tBfPKp4i09mIZMmDFQvzwgu/BzwYxxkVw009uwI3fukZxzLyQ2tnZKRGootGoanluKBQSSq+VwljUEp0TibgFBQVx4hnDMHGCpM1mA6AuAtI0DYPBILlmibbhxy3ehj8/tZ8pioorGZGPVymxWz7WREKk2jOlx42bqJRarS9kon34/X643W7ieiQQCATCrMNSaUGoPwR5szZL5dxIjE0kICotB4A1ra2CI60/FIorg50sty9ahC1qPRkpCq9cXIe+RXm45pH/wM4xOM/oQN5LH6L7X02IsizqlxXgZ08/lHKvw/KMDPx6zx4AMRGLQszNZ6IojKUgZCrBu/KmqyzayjBTntpNA3hhcBDXFxdLXr+/tBSnuN2Kwif/Gn+v+N6HSq5Fvgdik8+H/QkSsOXjOtRSnAlSiPBIIBBmPXOxp5xSP0jeraYW6sGjFCDCn7f8dQASwYtiaDh/fAmib+9Gy/3/QiEM+JKpGGEAYXDYdPdGtO/4EI88+ou4/iG88MUHsfDXW6s8NxQKwePxoKamBjU1NZIyXCCWKq0Efyz+3jY2NkoEOaVU5qysrDixsLy8XBivXJQFECc68tv09/erCo9WqxWXXnopGhsbMTQ0hLy8PPj9fomzU77foqIiyXnLnaBFRUVCUIwctedbKdlcjPgZ0+PGVXO0iseRCLV9JNvvlEAgEAiE6aBkXQkObDkAjhkvt2Zic4yS9SUzPbSE8GXIagKi2vJaqzVhGaz8OFriphKr7XY8lpmJG8fG4kqueVqPOwK/LLTjOxtehDUIrKFzcVxGDjgAn3vG8MBZXwd+9R1gXn7S1+YDWVUJf67pFB3Pys3F+QUFuO2TT6ZcEAQwLcdgIXUW8vdeycGohpLoyMP3QNzQ05OUYMuJtiUcmszuT+4EAoGACfdgb29vUqEjLMvC5XKhoaEBLpdLl7CSLuSOM34svb29ccKhXLShaRpr165FbW0tiouLJWJgooAWm80Gp9MJw0mLkXf9iWAZChmgYQONPDA4gynA2Cu7UH/qZfD7lUukaZpGdXU1ioqK0N/fj2AwKFlOUVScMNjV1SX0nHQ4HDCbzXA4HHA6nZrjld/bhoYGbNy4UVHIKisrQ01NDWw2G0wmE2w2myC61tbWKoqVZrM57vpwHIfh4WHVMWVnZ6OtrQ0ejwfBYBAejydOvDSbzZL7c/bZZ0vOm3dV8oyMjAgBMC6XS1JCrff5Vnqm+P/0CPPV1dXC9bPZbLDIvllWun5K+6itrY07v2T7nRIIBAKBMB3YV9vh3OZE7pm5MBWbkHtmLpxvOGFfNft7tSn10ePGBUSt5a06ymB5ePFys9eL3lAIm71erGltRZPPl3B8ToMBa3JyoBWD0VuSj5/dfxn65llhAAUbaGSDRgWycGXEgaO+fR+ws0txW35WMt2CBYOY6NhYVYXri4sxNo2fH6YauSuRv/dqPR7VULoiHCaExvaRkaR6b+ZPYX9HwuyAOB4JBMKsJ9U0aa1y56lG7kDTEgyVRBulsm75eSuVHpeXl6OtrS123vNoMDetxLLMQixxLMSbP38aGPBhJWXDrk/HcFrNuXh281MoKVkUd3yt9GOn04mdO3cq9lLkBTsAQvKzvHy4paVFSNOWlyerXSer1YqamhphHb/fj1AohJaWFng8HqxduzYuOdtqtaKsrEwi8lmtVsnPNpsNVqtVsp3D4Uj4jFmtVsl5uVwuyXnLe3LKxduuri4h2Efv8y13vHo8HkGk1POc0zQtCRRyuVySeywfsxJqrlj+eZ+L7mQCgUAgHNrYV9vnZJBM+8iIpoCottyA+H6BYsFJjJ6QEDVaIxF4kbgvod+ehbt/dQnKPvTAHIyg+r/dOO69HiyGCVcaluClnz2F5mvORPTskwEAdoaBlWFQabHg/IIC/Lm/P+WS7FSZa+67AqMRyzIyNK8TDWkys/zeTxYWwK3d3XinthaVFgt6NQIaxTCIJVoTDm2I8EggEGY9qaZJpypYpgO5cMgHwfAk6venhPw6zJ8/H4FAAMFgECaTSSg7bmxsFNahbGYEiy0oW7sKJWfX4Pkrf4n973fhaGTCOjYPF626HDfedR2KivIlQpH8WplMJhQUFMDhcIDjuDjRsaysDEDia+52uzWTmxOh5Pr0eDxoaWlBfX29pDy6vr4eNE1L+iTKt83OzsbZZ58t2a5qfKItvtbyno9yd6D8PCmKgsPhEP5VSsDm0ft88+XXWsdVe02JZMKSlMaiJG7OpNhPIBAIBMKhRKXFIvTT4xELiGrLnVYrXIEAmHFRiYFUcAImSmw3KQTE6An6aPL5cJ1KiJ5SGW7UwOCjyoUAgLa6Eny8uQOXP/UO8mHAxaZFyP/zm9j68W4Ev/llvLJihcT99sLgoOZY0k0UwIluNwwUhRqrFcsyMuJKuyfDVCRxL8vIQK7BoBlQwwI4KiND4kpMd3F363iboXUlJXjN640rtRa7WOXPpt6Sf631UmkbQJgeiPBIIBBmPakKJKkKllOB0jkk6wSrrq4Gx3Ho6uqKc+lVVlYmDBoxZmXg4n+ux+vr/ozOv/wHi2DCxcwi/On2xzFkDYOiKJx93mm4996fxpWl8yEytbW1cb0GbTab4EZMdM2VRDGbzYbs7GzFcBqeQCAgcUrK6erqQk1NDRYsWCAIukp9EpubmyUCcGFhYZxLs7GxURAM+X3JE6Z5dyDv8JOXbhcVFYGiKDidTlAUhd7eXklPSV6oBaTPRmFhITiOQ0NDg67gIf76pvKcJxOWpJeZFPsJBAKBQDiUWFdSgi0HDqgKiGrLHygtBQdIBJj1JSWCmCfuDakkgKm5I8V8/5NPFEUrI0XBzjAIc5xmz8K3zqxAf3Eebri3EdYIjbMNhcjZ7sF/3rsD3y/IQUnpEjz0yM+Rn5835WnHSnAAwhyHd/1+0EifWEgjlsj9SGkpvtPdrdofMxX0CIkfjI5iTWsrtjmdSbkS9RLkONS3teG8ggIcnZWFDw4eFJbx5/5waSleGByUPJsc9AUiafU9hc59EGYGIjwSCIRZT6oCyWQcXekmHSIP33uRoijNPpFa503RNE67+xrMW74Eb//oT8jjDLjQtBD9oTA4cPhkYzNOaToXV1z1RRiN0j8RnZ2d6O/vjyvvFvcKTHTNCwsLFcNJioqKUFVVhba2trhUbZ6uri7NJGolt528JFhe2s0LuWLE17a2tlYIweHHwG/Hi47icmWGYZCZmSk5Dn98HofDIQi1gPTZEJc/qwUPAcrXdzY857NJ7CcQCAQCYS6z2m7HNqdTVUBMtFytVFqrxFbJHSmnyefDewHlPuFhjsNgJAIGsZJpLfGx65gF2PDLS3DLT15Anj+IVZQdi9kshAc4DA/048yaC/D0q08oOjuTYbKiIQvgGJmIlio2hhEcnS8MDmKz15sW1+HHo6NYlpmpS0jk+4SuKynBq2rJ5Ej9um3yevGq1xvXm/NYmw0PlJZild0el6pd39amq+RfqzUAf26ptA0gTD1EeCQQCIcsU+Homi0UFRVJnHtigUfPeVd+5XTkly3Ec5f/HJYwsAyxEJaltBn9vUHs+HnM1bibDuLYb5yC4uJC+P1+ReGvv78fbrcbtbW1ccdmWRbNzc2CYJeVlRW3vd/vF8Q2vn9gS0sLOjo6JOXJ8j6JYsrKyhTddnIxUh6K0t3drSlm8vvkS7b5dVtaWoQSbjHRaBSBQABut1u4Jzt37pSso1QyLT+e2s9q91btfk93z8XZJPYroXQ9CAQCgUBIhK/Jh54NPRhpH4Gl0oKSdSWwr556F9Vqu11TNEm0XAk1ZxwN4MzcXIl4qQQv8mjB71+r9BcA9s/Pxl33XYYb734ZpZ8NYQlnGl9ixhFRM353xi1YzLG4hGKx6ayjMPS18xMeW06ewQBvJDIpge/j0dGE56IHXzQqlB+vKynBZg3hb6rgS+lX2+04zmaL6wsp7rmYSm9NVvYvv89cjQCZRP1M9a6nN1RJL8mWbpNSb3WI8EggEAhzkKqqKknvwkQCipLgsmDlkbhy23145bb/Q2DvARg+H0T1PB9KznSAtmcCAEJ7vPjDk++h+fQSFC4ogM1mQU5Odtz+Ozo6ACBO2JL3dEwk8vHj7OrqiuuJqNUjsaamBm63W+K2Gx4e1kyvBoCDsm+v5b0cxYKukiiolZQ+NDSkWGrMJ1ErCYDpdgxOd8/F2S72K12PRMnrBAKBQDi88TX50LomVsKJKBDqD+HAlgNwbnNOi/iYbtR6Q/Ji06U7d2qKJnqFnIMsC4qiQMtKunknHYVYSfNYlgkP/OwC/HTbJ4i0fAIcCODkod2oONWKzNJSAAA3Fob7hc9wzfpH8enX6gGGAZYUAzq+TL1r6VLc1N0tlKSnSrr6IfIOvNV2O+oUhL9U2B+JYFDnfsSl9PeXlkrKk/l78/F4T8t0lZgnEgAT9TPVu56efehFq6xbrfckKfVWhwiPBAKBMAdJVuBRE6Dsi+fj8qfXY+Chp2HoeB5ZXzgRVPbEH0fjCuCm8k/wxoMf4bOR3djPcnixmMK5X6+XBKwEg0GJa5EnmR5/RUVFmmnaQEwYDIfDklLmoaEh0DSNqqoq9PX1Ye/evYhGo4oiZ1lZGSiKEsq55WXj+fn5CIyXD5WVlUkEXSVRUCutXL5vHj6NWikZOt2OQdJzUQq5HgQCgUBIlp4NPYLoCACIAhzDoWdDz5xMy1bqDQkAzePzpkSiie7SZ45Drc2G1kAALMchi2FgpGnUWa04v6BA0ufv/IIC3MQwKD/Cin9ufAaLv3406JKlkt2tPLoEr/zxXbx+1/MIc0ADNYpN918PFOSqDsHOMLi+uBiVVitu7e5GayCAEMfFhZ5owQBYlpmZllJrAHj9wAEs3L4dlRaLIPBNFr3nIy+lF5frNwcCGAyHQQMYjEQS7ss4/m9Yx3FpaAuAifqZ6lmPAxSfa28kIlzvZByIySa+TyYh/nCACI8EAoFwGKAmuHCRKHZ/5+ew27pgvPBkUOYMcJEI/MNjyDAxMFkzwZQegVM35IMbGwXGgvjk2V247d5/w16zEOFwBBzHgWFo1B5XAY/HA5fLJQhnSj0dHQ4HAoEAOI6DzWaTpHuLE7mVMJvNiEajElGP/39xSIwSfG9FPrVbLEyazWbk5eXFbS8WBvm0a7koKC55F0PTtKr42N/fj5aWFsEN2tvbC47jUFdXJ/SUdLvdaGxslPS/TLZkmvRclEKuB4FAIBCSZaR9RLGGc6R9+kNP0oG8N+RCsxkfHTwo6ceoJZqsKynBlvEeflpuuDBiYiYvAo2wLLatWCEIP5VWqzCGZr8fp777Ef703svI/dpxoObNBwB4DwaRazKDo6KgbNlYfP3JuOqAF2A5XOH+DPfc8jh+f/ISsGaTcNzg8lKwNRWgAZyQPVGlw48lEQxiQh4znmr9QGkpbunu1rGlPoIch95QCH2hUFIC6GQwUxQKjEbFoCH+HoDjdDscaegTHHlYAOcXFKguT9SvVO968ue62e8X7nuyDkS95d+prn+4QYRHAoFAOAxQElxYlkXLY89gkee/MJ62BpQ5A+FQBK94GAxHrHA4HCja04XlC7JA2e2gxv9IL/vWfPz+X++iu2WfsL8oS2HTe9vQ/PUQFiyMCXG9vb2oqalBTU2N0OOxrKxMEP94xCKbVukyv31fX59ESJ03bx6AxO41cW9F+fWoqKiI276trU0QDtXKlHmX5dDQEDiOk5Rpm0wmZGRkKDovi4qK0NnZKXmtq6tLKJ8XJ3z39vair69P8rPSWJRIJjH7cEDJUSoPHCIQCAQCQYyl0oJQfwjyGk5LZWolnLMBvjckXx4aUfhbqCaarLbbsXXFCty2cyc+YxgsMpvxvt8fJ1jRgKr7S16WykSiuPefLyPn6lJBdPwRm4v/y56PrU4njuPGEHr7H6AyzaAKY18aWgoL8ZMFH+Giv36CqGj4n27rwU+WbMee9f8jOOZu7e5OKDoWGAx4obJSsQ/hHo0+46kynbOPNTk5eFUmIMvvQTIkW35NA3hhcDAuVEaM3n6lWuuJl9W3tQFQfwYTobf8O9X1DzeI8EggEAiHAXLBpaqqCg0NDQjv+BAlmTRgiBVMDOSUwcaGUFZUFAtnCVrx+Z4olmaMwURxWGqjQWdkIvfyk3DsReKeixyO/XQPnv/tu3icGwVnBBzlDixYsABf/OIXUVdXpzo2eXm11WqVBLnwmEyxb7PPOeccvPbaaxgaGkJeXh7q6+sBxIuJFEVJRCVxb0UlAUreI1LuVlQSNrVcljRNo6ysTNLjEgBsNhuqq6vjhEdxubqcoaGhhGNRG4PexGwlpjucZqpRalGg5kolEAgEAgEAStaV4MCWA+CY8XJrJjbHKFlfMtNDSxp5+IU3ElH9Ak5LNFltt+PhrCw4nU4wDBO3X75sV4xYyJSXpRqiLCxsCMjIAAC8wZrxoHEewHFY09qKbU4nTjjrfxD5uBmewDDovm4UWDNgdB6DmqOWSlS8uoAfdU+14vZr78N9xdmwz8+F+8qzgRxllxuNWL/JZZmZQn/L8woK8GR/P1rH2+9k0HTa+h3OBHcsXhz3mla6ebphMf3Ov8k6EPWWf6e6/uEGER4JBMJhy6EmqmghF1xcLhc8Hg/kRQ9HlB+FsvxFwjq9vb3YH2awPxzrlNLi53B+wQhM2RYgM1OyreGYclx0ZzZOemEHuDCHzz47gAfveBxnnnkmzGZz3Jj4688H0/AEAoG49GkgFi7Dp0mfe+65cct5MZHv3yifSHs8HkkadVFREerr64V7zm/f0dGhmKCtVJarJQBaLBZUVVXB4/FIxMny8nJFUTKi0U9HXgaeSolwKv0NpzuchkAgEAiE2YZ9tR3ObU5pqvX6EthXza3ACKXwCy3RKRnRRO5Cq29rw2avV9X9pZaszXMAE/Nxbtyltq6kBBtCNrSHaVQuORlf++S/ON/OgMqQzkepzEwccePJePzVZozsGcFBby8sNz2GR9ddDPbII+KOxSImPvIluZ5QCK/K0qaDsi8p+WCcuUAFTWNVdnwwZKJ7MBnkIq2aiD2ZFOhE207Wgai3/DvV9Q83iPBIIBAOGZIVEg9nUUWP6MQLcR6PBxzHCb0Yrc4qwL8fYCPo3NWJXZ2dKDUcxBGFWaCLilB4XUwUKzw4gt88+x5uWnYRPAjHkg1pChEzjZsf/gHyCmyaQTLJjF1877Xo6uoSnJTyey53B/LYbDaUl5crBr3IXZZyaJrG2rVr455LIJam7PF4hDAceZm5w+EQrrlSj8dkn/dU+huSMBYCgUAgEGLi41wMkhGjFH6hhhGxYJa7xgW/ZFN51QJs+KCPIMvqdhBGERMF5aLpq3lHo4QNYZGo22BJNIhHgntgyMyA7YITYQPARaO4u/VDlP3yRbwaHgUvGUYAtNYuwuDNV4IVBSbqGROH9CU+pxt+XAxiAul3x12kcnSHBCXJMVlZ6BwdBZXA+TeZFGg926bDgai3/DvV9Q8niPBIIBAOGZIVEme7qKIkLKWLRIIZkCA5O6cQAPDJUCv2BinsDVrg2T2GVYU06PEG31SWBfO+ciLuPeYjsP4xYdOwP4iXb/o1/nVCCY6pLRVepygK5vFtS0tL0d/fj6GhIRiNRiFpmh+7nERp2Grw91x8rQsLC1FTU4OBgYGEgp64ZHvfvn2SHo98ebTadVQr02YYBvPnzwdFUZLji1Ow3W43OI6ThNMA2s97KonZJIyFQCAQCIcCviaf1LG4rgT21YeXE0nL4cYgJvDxolUUsWTjzV5vUoEcPEoBNuKgD/44YpFMDX4GpiSa9tAm9GAiWOYt2oJXGRtahz9Eri0muFEMA2NtBb6xLhtXfTwgrMuxLD7ePoTrv/UAWu65DjCIRmE2A4x2FdRsEx2bqqvBARLH3e2LFyPrk08U1+eFOZrjkj4XA2LCrRwKwB+OPDJuHErOv8mkQOvZljgQZxdEeCQQCIcMyQqJs11UURJSnU6nrm3loqXcMccnNPs+HgaSaLnC77evrw9+vx+jo6PCsk/DGcibX4Oammpwo36Mbn0KtCUDpmMrJfvIAHDZsR6UPNSKTVt6JvYNDh1ZYfzg8R+BoihBlAsGgxL3n1gwUyvXttlsyM7ORmFhTCDlRUSxWAdM3HP5ta6pqUER3+fS7Y4TH+XXt76+Hhs3bpQIj1rXr7+/H8PDw4rrRKNR4dz7+vrQ19cnuCbFY5SXo+sJ1xELkyzLShLIlQTWVMRKAoFAIBBmE74mH1rXxNxRiAKh/hAObDkA5zbnYSU+qpWe1tlsyDUY0D4ygiDLYigSEYSoZAM5xGgFfbCif2kA5VlZqvthAYyxrG5n3hBtRM+pX8PqjnZ4QiH8fegjnJNjALNkMZgl0l6Hy1eP4rln38UTN/wBQXFADRXEc9+uR3jl3HCvfX/hQkFQE9+naDSKVpVteGHugvZ2DGq0+1FCTajMNxgUx9Hk86G+rU1SFj2ZHox6tlUqxSai48xBhEcCYRZwKPQanA3nkKyQONtFlck4MuUilVoq8r4PB4He11ParxiTyYTKykpUV1eDomlwmdnY5TgeBZ82Icc8Ub5CURQMlkzQCxw4/vYsrBwYnNgJx8Hn6sVPr7wHeV8+DqOjE5MHhjbh69dcJaRfiwNhlMZTXl4eJ7Lxz6eSiCm/tkol2dXV1WhpaUFXVxeCwaAgMvb29oLjuLiejXl5ebqvnxYejwcbN25MuF4ywjnLsmhoaEiYlK3peiUQCAQCYQ7Qs6FHEB0BAFGAYzj0bOiZ8+XTyaBWevpAaakgyCzcvj1OVFISg5p8Ptx28CA+e/ddrFDpzScWfgbDYVXhkAXw4cGDMbucAhSAABsvddEAjh3/EpYPgXFarcL5HGW1ocfrxUX5x+DWkT24NbIfBtExLBkmUJmZKPjyifjBibvBRSeOEdnnR/0T/8F3W3dheEW58DpnzQB3TDkwSz6nWWgaSzIy8Le9e9E+MqJ4H1ojEdzR0YEOhV6Iq+12mJM8FwZArsEAbySiKGLLUSuLrrVaU+7BmKh/42TKuOVjT7UHJUEKER4JhFnAodBrcDacQ7JC4mwXVSbjyJQLaUqpyGwwjMCmrchfNg8wj/d/Ge9xoyYkq4mfFEVJrqXb7YbL3QogNgGw2WywWq3weDxYZhzFCQuMoLLtYLKlf7xzly3Fr5a0Y+tTrQixE189f/Z8F67b0oy6UytBUZRwXeTjMZvNQhBLc3MzgJjbkWVZSVlzbW2tZLyJSs9556M8oZqnq6sLZWVlgguxtLQUlMK1lLsceWemfHxy5AnfAFBWViYE5cyfPx+9vb3o6OgQkr4NBvU/8W63O+54nZ2dc/rLDwKBQCAQlBhpH4lvaBgdf/0wQq30lEPMkdgcCMAnS6IG4sWgJp8Pp+/YARYAG41iQEHUkQs/iTj7vV3IKTeBsucAACIiFVItxIUDJKKpnPMKCoSQmPstC3E/FkqWF7EhtPl2wpZtAXXEUuk5lwGXLC1E+cOt+OzdifnhQZbCX6nnse3BmwCbvpCSyWKkKIDjIL8zNIARlsWugwdVxbUmnw/XjY4Co6Oq6yw0m9GboGJHDEVRuGvpUtzU3a2rf+KGnh6wonLuKACa4+CPRiUiNy3ah1zwO6+gAC8ODkp+Fovo/H69kYiwbapl3DzpEi8JMYjwSCDMAmZ7r0E9TMc5JHJVznYhMVmUhFR5UrMaciFNnopcaLXjs8u/iXmrjKCrjgPFMABjAm1XLj0GYmKdmkAnd/fJ7392djbq6+uF+7fNO4gjsR8GauJ8cs0MjLYsmFc5UX9MCcBNTEc4/wh2/nknbr+vE4aFMXHvtRfeRG5+Ho6sLIHdbo2tx3GSMmU15OOTX2ulkmytZzoYDErWpyhKEB61XI68M1PuQFSDFyrlz/9LL70kjM/j8aCxsVEx+ZtH6Vz8fj/8fr/gkF27di0RHwkEAoEw57FUWhDqD0Fuj7JUTo9wNJuQh1/w4gqr0udPLAbxbOjpAQdolmPLhR8tbv7XG1gf2oHMy04FZbGCZTk8weQm3C6bYTRLZ18cHFRdZqYoLLHnYylVhQdGenBUdKJ1UAEXxVKrGbTDAec6O5zBiT7lXCSKtW/twh03/BbPOeeDpScE0sCaYxGtXp5w3MkSVbk34uvP/0tzHC5ob4eZplFpsWAoEkl4r5KhwGDAC5WVWGW3o9Jq1dU/sTkQiBs/C+CDgwdBY0JYZgE8UloKDpAIfnzKON8PlBcAHyotxZP9/XhX9OU8H0KUwzApl3HzpEO8JExAhEcCYRYw23sN6mE6zmE2uCqnEyUhNRrV1+FGLqTJezw63ulBRu4A6GPOBMUwoIyZMJ9wKSjGIGwnhv+Z3y/f4zEcDgsOOzFKz4M8NXqrTIyjAJwZ8KHQYQeVkyNdlpuHiltz8ceN72Jfz/gEMORHaMCPZ1//GKPfWI2iBQUJeyyKxyNGqf8h7yYUl3WruSJNJpPk2HxJN///8nULCgrgcDiE60nTdJzIJ98nEF9CziN3tMp/liO/PxRFSURtj8cDt9t9SL+/CAQC4XDicA5XKVlXggNbDoBjxsutmdjfvZL1JTM9tBmHF1fUevbliYQmHj399dSCbMwUhRDHCWLTvKEAvu3ejsz/XQnKYkWU5fBFuhhv0DFRmIK649EXjaLJ51N1n2mJTP9xOnFXTw+CFI3rrUfELb9qpB+PGoZAZWUBov6TFIDsC/Jxv2MHbmiUzgnbfrsZt1e1YuCmLwsVRJMlg6IwptN0AMSEOb5fo1pitfxe7QkGVffHhw7xjkbxs6A3wTmsUCYvHq/4WC8MDuKFwUGJ4MfK/uUFwBcHB5FrMAhjFC8Tj128fz1l3DyT6UFJiIcIjwTCLGC29xrUw3Scw6HgDJ0ulERL8c97XtsJxkwB4+W4ppq1oIxmYbmakMzvN5Egleh54H/2eDzgOE4Qvrb7rcjecwB5hompyOL5+ciLDIGyWFFw9akoEIuvLIvlH36Mv/7uHTzNjoATzfPyyubhnAtPBS36Ntpms6G8vDylMnzecdrV1QUAsFqtoCgKDodDNbSG/3/xtQyFQnA4HHH7l69nNpslwqPNZlMdt9zRmpeXp+kQ5vfT2dkJv9+v6KQl7y8CgUA4NDjcw1Xsq+1wbnNKhdf1JbCvOrTOPZV+dFpJ1wBgpuk4F1ui/npa65yak4PPg0F8cPAgAMB2MAijGcJ89FE6F28wVmEbDhPJ10rc2t2Nd1TmpJUWCzyhkOK2HLTP/SlLEf7D5uHS8JCQuM2Aw42jA8i3ZcF8ghNH10ndjUd5h1D5WCu+d/UvMJQx8fpIdiY+/cFXgXn5KkdTJ5HoqHVttBLMKy0W4XkZVCmvF4cOpZoI3eTzwafTNCEW9RJtobVuFADGK4/0lIKroec5J+iHCI8EwixgrpYIT3egzKHgDJ21pDnNWOuZlge9VFVVobW1FV1dXRgZGUGAM6BP9OWrN5SN+lPOwcjWp2CwZsaN1eg8Blets+GCt7slr3/+wSh+dt+/UH/zeTCbTQBiJd+pvNdYlhWCZYBYf8WamhrheY9EIvB4PBgaGkJeXh4qKyuFpO3q6mpB4ONREvUSlXuXl5ervr/q6+vR2NgoHJ8va1dzCPP3p7+/X7F/JCB9f82G8CgCgUAgpAYJV4mJj4fyuabaj05JXOFRE1nWlZRgi6j0VUnUUQuyWV9Sgkt37lQdT4CKn1uo++WAd/1+1Le1KYqs60pK8Np4j0cxNGJOT61zB4A9tAkPmCfmQgUGA162L8UDvc04MccEymiUrE/NL8TyW0/Es5vdiIxMiHmj+0P43a1/xIPfPw/RyiM1ziY57AyDEZYFpaOkXe5cPL+gQLUHp1LokBqJxO4NPT26z0f8vGndl0TrMgDqrFasKynRVQquhtYzTEgeIjwSCNPIZD+8z7YP/9Nd+nwoOENnO/JnrL6+Pu3PmFbithJFRUVAlh3b6KUY+bxfEnq4Zh6N7EwWzOJFyP3yIsl2OWOj+P1z7+G+X7yGfi4ivP5/9G9w2s3n4+Zbb9A8N/G1kIe/8IJgTU0NWlpa0NHRIbgTPR4P2tvbhR6PNE2jvLxc0udRSTTXU+6thsFgiOvpqMchLBfzlRK/gcOvzQGBQCAcShyq4SpTXT4+l8rTU+1Hx4srtKzcWqm3I89qux1bV6zAbTt34jOGwQoFUUctyGaV3Z5Q8EuWzV6vosi62m5HvsEglB7zsABe83pxy8KFcQElahQYDNh34okAgCbf0Tjng3bsGxsBB8DGMDgxGsBdo3tAZ1lgO/9EybY5LIsfd+zCUQ82Ysvo88LrEXB4Z3kB+m67JqWU7DGWRa015g7dEwxiIBRCRGE9K4DVublCqvX5BQVY/+mniCi4Kc0UhVNzchRFOqXAl293d2uK3VplybyTVC7qcYDkvvACt5LQLV9XvGyVjlJwLeFU6xkmJA8RHgmEaWSyH95n24f/6S59nqvO0Kkk3WK02jOWzuMkStzmYRgGVVVVQn9Fjyf++XrRw2FlngFlmaOAgQbGJ1GUwQAqIxN5l6zGXRXdYEcnSpajw2NofGIzbv7oU9yy7mZEohG8se0NDA/7UFg4D3a7HUVFRejr69N8pjs6OtDV1aXoGBT3eASkonlhYSE4jkNDQ4PmtZzs867HIawk5iuNJV3v9dn25QmBQCAcDhyK4SpTXT4+18rTU+1HJxZXmgMBYR5VZ7Npiiyr7XY8nJUFp9MJhmFU11ESfsROMjn8l8u8Q0+rlJhHS2Sts9mwyeuN2wcH4P49e3DrwoV42+fD+36/5nE2LJ1IvV5tt+ONE6TiYpPPh6rmd/Af/0fIzzRNnA9Dg6JpGFccjS/facelvROBN1yUxedvDuD6b96P/66/EhBfx/wcwGSCFkGOQ7PfD4qi8FBpKW4Yr8qRY6AoNFRUgGEYNPl8OMXtVhVaC4xGxXum5KgVB74AyvdBTWS2M0wsrRsAKAp1VqvkeZMLfucXFOAFUaq11rp6xUE9LmG9fSwJiSHCI4EwjWh9eNfzgTyZD//T8QGflD7PPKmI0WwojGB7G7KPzIv7hlXtGUun6J0ocZvH6XQKoiNftiyH4zi8uz+Czx2Lce4XzsXLL7+Mvr4+mCkO5+UFkJFjg6HyqLjtLqgcQMnDbmw86duSNL2nmRGccfNazURsnlAopBpmoxVe43K5puULBD0OYb3iZrre67PtyxMCgUA4HIgLV6EBRIFAcwBt9W2z2smnxlSXj8+18vTJ9KObbnFFLHY63t6JzGIjkBkLcDkiIwPFMAli003dflKTuAABAABJREFU3bpKidVE1vMKCvCqQrk1z+MeD0ZYVlN0PCYrCxVWq+IysWNuYU4BVphqpD0NOQ5/ObALX8qmQRcvgKl4gWT70poxPPvcu3jmR/9ASCTEdnNBPH3daQiefCwAwELTGFEIaYmOH+NGFdERAI4WzfVv7e5O2PtRCSVHLRAvCsvvg7xcmRcq/dGoxL24TsExK38mry8uVhyb0rp6+p2S1OrphQiPBMI0ovXhXc8H8mQ+/E/HB3xS+jzzJOtEi3j92PM/38P8YykwzpWgaBowZIDKyAag/ozpOY5esVspcbuxsVEiPvKJz+LnWAveNelwONDX14cgR+Ff+204acyPggwKFGLlyCwbhTnbArqwENW3nQineDLKcbjW9Tl+9sBr8K5ywGgyxh1nXmEeyo9cGve6GL5v5Y4dOxSXT5dTOJ0O4XS910lAFIFAIEw/4nAVf7Mfkf0RgAbCg2F4N3tntZNPjakuH59r5elzrR/darsdf9raBsPnryProjWgbNkAx+Erx9ThqpyJzzeVVuuEsGeOhSC2BgIIytySaqLZi4ODmq5JXzQKZb/mBLsOHsSa1ta4Um65Y65X6ctoisJXc4+C0RxE7cBHEvFlXoYRtDkDuZeciOtP6gdEwmJ0nw+n//FtfOfddviOXILiDDM+GwtOfFmeaUbkpGOBjNg10YqgudY8ER7ZGgiorscBqs9LohAiHvl9kJcrB1kWQ5GIpktysujtd0pSq6cXIjwSCNOI1od3PR/Ik/nwPx0f8Enp88yTrBPN8+unkVO4F4zzTFAGA2DIRMYJl8QESKg/Y3qOoyR28+KhXIyUPzdygZKmadA0Hffcms1mVFRUxPWFzMvLk4y/tbUV0WgUb4zYgJFYIvRlF14Gt9sNds+HWG72gbJaQcm+wbYtXIi7izvwzlOfI8xSkLMvNIB/5uzEtXd+Hfv27RNeN5lMMJvNQuiMUkq0+NrNNadwut7rc/HcCQQC4VCAD1dpq2+Dd7N3zjj51Jjq8vG5Vp4+1/rRHez4BOFXn0b211fHREeWg9F5Dpgc6bxAzc0mFpa0RNb2kRFNNyMFfQnKYnGMd9O9fuCAYp9EOTSAb0Ut8OZUSY5VwIbRdqADuXYLKJmbj160COcvnI+jfteMvob4L7LDLPDsk2/jmZ9fBW7JgrjlPCttNuh9V9sYRvV50erLqRUyBEjv4cLt2xO6JCeLXicjSa2eXojwSCBMI1of3vV8IE/mwz/5gH/owTsKu7q6wHEcampqknaiRfr6QeeaYqIjgIwTLwfFTDj71J4xPcdREruVgmTWrl0bJzSqPa/y1ysqKlBbWyu4JMUpzuLxyxOhy8rKJs6tthZR/xAiH20HFwmD4zjs3r0b84xRZNitMK1cgZOWHyH0ORLDjY7hxGd34I5b/4Dg4myEwiGYjCbkz8vHzXfcgCrncgBANKo+jdVzLQ/VXojEJU0gEAgzy1xz8qkRVz7OxESPkvUlkw6F8TX5EPFG4kRHfv+zlbnUjy7kGYTRQgOmmBvPUHosDPOW6No2GZE1UZDNErMZu4NB3aXcctFTDywQF3ADAIO0EUfkOnH7WC/KI6PC64vYEKqzGNDz5+OoH52Go8LhuG3BsljT9jGO/vHf8fsFZkRFts2huqMROf90UBSF+444AvjkE2GZ02rFuwq9yYFY+bMa60pKsFmlZJ1FrDekvE+jEtMh9ul1Ms41l/BchwiPBMIsId0fyMkH/EMPt9stiGktLS2gKAq1tbWTcqI1vvoaCoscCYUtPaK3XCQsLCxEZ2enZB2PxwO32x23L6Xya5fLBY/Ho5i0rJTiLBbrCgsLUVNTg4GBAcXnn7HlgTn2i8LPfpcL21wunDbiQ/ECOyiLci8fympD8bUn4ZHXmjHY4R3/KzqK6OBuNF7wI7TecQW+9j9XaF4nPdfyUO2FSFzSBAKBMLPMNSefGuLycUFgXF8CcJhUKIwkVEaErc6G0gdKYV81Ox2Ecx3KnJXU+npFVl5cUvoymQJQaDJhTygkEZ/Y8WViZx4vjsnddJOBAWAzGvEzamHc/r40NognowOgzRmAOUNx+4yTavCd+dm45LmPwHETVTqfbtqBHzZ9AM99N+Pnn3+OSyIROMeX3V9aihPdbsX95Y2bEtT6I9bZbKqiZZ3VmtT9mEqxT6+4OddcwnMdIjwSCLOEdH8gJx/wJ0cq35ZPtUttsuXzLMvC5/MhP3fitd7ePuzpjQWpTPZ5qa6uBsdx6BpvcN3X16ea+CxH/ryKA1j4sSUr1tlsNpSXl+u6D7wwuau/H0GLFeXF80BR0m3Y0CjCH7wFOjMD1nNXwSrSPTmWxTc/242tD27E+b/4CyIUwEWjoBgGeUcX47GNDyIrSzqp1npeSC9EAoFAIEwFWk7BqUbP3CrSGkHHHR0Y6Ug8/+LLx8W01bdNKhQmLlQGABjAkGs47ERHPQEdsx1eXDq9tTWuLyQHYE8wqJigLA61EYtjl+7cmRbREeP7vGvpUtzU3Q2a4yRC578yCrCNzcFpUT/o8Q6O1PiYKQDf9fei0m6G4chSLLmtVLLfJcM+PPe3Zqz78j3oNUTxZwDPMgyMFhNuf3Q9bl24EPfv2RM3ng1Ll2r2R9wTDKqei95S6ekQ+5IRN+eSS3iuQ4RHAoFAkCH5tjuJb8un2qU22fJ5t9uNgM+nuCxVYUsungEQxEYl0RHQN2414U1NrGNZNs5d6ff7hfuR6D7oFeoNi47B2KY/gsqQtiKnaBrM0iU4c70Vq9/plHyzPtg5hOuOuRh3v/kHLFo80cNH63khrRIIBAKBMBWoOQWnWlTTM7fyNfkwet0oRjGaklsRmHwp+aFSij5Z9AZ0JLtPXnC6+NM9uC29Q1Zltd2OU3NysNnrldxaGkCQZXHZzp2otFiwcfly4dzEoTZicSxR6bZeaAA5DIMXBgfxUGkpXhwcRDM/b6Yo+MJh7KcNeJbOlWxXYDCgzmbDyaZ83HPgY1yXGQLFSL8op7LtWHDNSfi/5e2I+CbEwtBwEP++6i5s+/IJsJ+1GgejUUQA5BsM2LB0Ka4rLkZ9W5tqf8RKi0U5QAfJlUpPtdhHnIyzEyI8Eghp5FDty5YMh8I1iPu2W+e35VPtUhM7CsvKypIun+/v7UPRWABUti1umVzY0nsflVyGaogdiImOpVS27XK50NnZKQiaYrHO7XarCp3y+6AlXiY6Z9poRtbab4ILj0nExdCu9xD1fAAqPx+WtSdItsmKRPCbbS34/Yk3Ynckvk/PGFjsK7NgwYKJ5uCkVQKBQCAQpgolp+BUo2dutfvu3TFLF6u+Do+ae3KypeRzoRR9OpyIegM6khmzWMgc/HQPTDkMYDQm3DYdyF1wfCAKn7AsF1ZX2+1YV1IiXOe7enqwrqREcT8cgGwm9oW0T6NPohi+7+NmrzdO0G3y+XCSQjk0DaDOZkNjVRUWbt+OW+xH4A6OhVXklVzKhvDqSBcyLJkwn1QLs2h7C4CrT9yNpb95F6888TY4URZ2G4AbABywsIjeez2QM/E88f0RNy5fHifeAjFH4Wzri5hI3DwU3LxzDSI8Eghp5FDty5YMh8I1SPXb7ql2qdE0LRGgGhsbdYu7EV8ASx//NxadkwumNvaH+GAYWFC8AEXjPR7F6L2PicRVeX9GfpxikY9lWSGhWpyGze+/qKgIHMdJSq/lx9cah/w+qJ1bMs8uZZT22zFXnoJIwUKEWl6N1cAA4DgOlNEAymBA5unH4tuln4MNjMbtiwtH0f3qHtx1x+OYX1gMiuL79DCYX1gMlgOGh/3IySETIgKBQCDMTfTMrUbaR6AUeSuff2m5JydbSj6Tpeg8WqLIVDgRlVAL6GgOBFDf1oYdIyNYEo3iFz4fTs7LS7g/QcjkOPzvy+9gw4H3kXHeKbGe2hwH2jYvbWNXQu6CC7KsIDry5yZPrla7zvx+mgMBDIbDoBETHBn1w6sSBQCOw63d3XhnfM65oadHKKsWw2JC4OOdl6MUjVHE5tYMAM6cgaVUBTb5PsCRpoltGZoGYzKCWbwIp6634OTevYrjCXywFxtuegz/980zwObbhf0utmXDZMrC0/Y8/JoNozUQABALq3mgtHROuQmn6z1EkEKERwIhjZC+bIfGNUj12+7pcql5PJ44oS6RuLvn9odQXHYQTN1KUAyDUATIOeXLWJupHKKi9z7KxdaysjJQFJWUU1Lp2PLS54aGBtXjK40DAMxmMyoqKuLug/xcOjs70d/fj3379mmulwiDYxkMa28EEEu1bm1tRdWKSoS2PAnKBFAlS6AmDx911FL8ZuO72HzJz+I+cwHA38NhVNx5Oa657sqkxkQgEAgEwmxAcW4FgA2y8DX5pG5FWaqHfP6VyD05mVLymSpF52ny+XDjX9z48l+Aaz4BPj0ihBu/6sUjX63Gars97U5ENZRKimkAg+Gw4HrrB3D6jh3YVl2dULDhhcyVHZ/jJ11vwvLVk0Fl2xGNssioOhO0LT9tY1dD7IJbuH27ksYt9CpMdJ0bq6pQ39YmcQDq8ToqCYoA8K7fjyafD6vtdrSPjCjOBe0Mg7vGhdOFZrPifviekatyK4X+hgDwelUVXn+nEd9jfKBy82DIVRaL7ceU455lH+Dk378JX4SSLHMDGGY5lC6z4a1Nf4Rxmtyq6Wa63kMEKUR4JBDSCOnLlr5rkEq4S7pI9dvu6Qr0CYx/y8ijRyCL9PSAXmUDNV4Kkn3GNaAY9T8Beu+jktiqp7Q+GYei0nhMJpNEVKyurkZfX58gyAJARUWF4v2Q78vv9yuWaadafi6GohlknnMtwjvfQLTvY4U1OHBsCFRmFuZdeSKu+IJXcT/s/gPY9rtncdXLb2BZVXnccos1C9f875eRl5ersDWBQCAQCDOLMLeiOYmwGBmKoHVNK5zbnFh0+yJ4t3hjaonG/CuRe3KypeQzUYrO86fnunHfdwCKAxgWyBsCalzAn6zdWH11raoTUW+4h16UAjpYxMRH/vh8+rMewYYXMpf2DcGUywCZmQCAx7KX4dbCZWkdux4SJR/ruc5K6yTCRFFxITc8p7e24tScHCw0mxVF3+FoVBA6PaGQojhZabVKnJ0VFgsuDQaxKjsbdy9Yjvq9n+GewG5kcRNbWxgmJmSGR0FlmGCsrcC59zjARRTOLhRGf8NH+MoxF+CYS08RVelMUH/u6Vh5XE1S12U6ma73EEEKER4JhDRC+rKl5xqkGu6SLmb62+5EWK1WiVCWtLhLGzVFR0D/fUxVbGVZ6XTJarXCbrcrHotlWXAcB5PJhNB4U2v+X7EQWF9fj7a2toRjFp/b8PCwouhos9nAcRwaGhqEfclLsfv6+rB27drE4iNFwVSxBqhYo3wtDg5jdMufQVsyQM2fr7gOPX8+Tl+Xj2WPv4/9DW/FLQ9HKdz5SAOu/vc9qDt2ej8sHQp9XQkEAmG2MpNfxKbz2Pzcqv2CdkQGIxMLWICjYm7FipcrkPlYJjKezZhItVaYf+mtTJnJa5cqlf8XEERHIPZvlI69jqsTC2bpQimgo9nvx2AkIllPr2DDC5ny2cGZxSVpG3MyJEo+1nOdUwmacVqteFelJ3mQ47DZO/EFtEh/F/pJikVfJcSOTGCiAoc/5zUHDuBkY7bknN9wOlFmt4PjOIy9sRGIDoPKy0e8pBjDcc08/PbVZnS+8rai6/L9vzbhlYtX4if33a5+IdJIsv0ap+s9RJBChEcCIY1Ml+NtNpOOa5BquEs6mclvuxPhcDjgcDgwMDCgW9yluAhAxYtBaqLRVD/L8m9Is7OzsXbtWsV13W43Wlpa4l7v6OgQBMhU+4nKRVzx6/wx+X3LXZoejwdut1sQJZMV28XX3rHgBFTYOSAYm7wPDOzF3r0DAAAbFcXCvAxQefko+e7pKFFqXM5GUbvzE/zpsvW4a54ZMMTf69KqcvziwTvTXhpzKPR1JRAIhOlGjyg2FV/E6hXjpuLY9tV20GaFL6ZEbkWD04CKqyvAMOod8/RUpqRj/DMhXB7x6YToyMOwsdeBxIJZOpEHdMhLiwH9gg0vZG7d9iFoekKuWm6dGbEnUfKxnussX0cPD5SW4pbublXxkT9Wnc2GXINBGNt/h4cTBtfIReAmnw939fSgJRBATUcH1peUaJ4zRVHIXHM5ogOf4P/a3sGI7HhmcLg6cgCmrAxY1x6PmjOVE65rhobQ9tj7OPfoc0HnZcUtz7Jl4c5f346jjy7TPB89pNKvcTrfQ4QJiPBIIBA0mQk3U6rhLocLFEXB6XRqTsp5OI6D5+7fI/eIAJiK42PbGya6Tc+UaORwONDX1yf5WQ21smxedEy0nhx5f0k+AIdlWVAUBYfDISnZ5vet1Eeyv79f8Ro6nc6kxtHb24teh0NwUO74rAG9fp+wbtHBEE4vioA2m1UTIE3HVuLagmxcuGkXlKbA+1p34KsVF+KR7U8hPz9xI3i9HAp9XQkEAmE60SuKpfuL2GTEuKn6EjiZPtpqwp+eypTJjn+mqm+yK62IvO6XiI9ROvY6kFgw00Oqib5Kic4U9Ccar9i1B0uaG2H6Ug2ozJggJQ/rm860Ya3kYz3XWb7OYDisWkYNAMfZbFhlt+P+0lKJWCYnCuDjsTHUWZX7sKshFoHlgtwWrxdbxwW5RGXxTOEReLnQrygyb7Mvx9O974HKZICMDMXtqQUL4Py+Db9/uQVBXzBueSjgxT/qb8GKB27AeRfVJ3WOclLp15iO9xAheYjwSCBMAcmKdVMp7intG5CWqK5YsUJ1e7k4wnGcrvCQyZBquAshnt47fweL93WY154CymQGWA7GytOE5TMlGiVTki8X/BiGAcMwccLj8PAwXC5XwmdSfo40Tce5LV0ul0QY5ZO3rVarpMdmUVGR7msofy/KxU2xg1Jeit4fMWFjL5BjAubNK8Cq1asnFnIcQu7XAdYPZukSzL9uieLx54eCePDVFvzCeTU+RjhueZQBVn7lNNzx8+8rbq8G6W1LIBAIyaFXFEv3F7HJiHFT9SWw3j7aiYS/RJUpkx3/TFXfOH9aCvc2N1gaoFmApQGGApw/KxXW0RLMEjGZRF+xYMOnWv+yokKXYBNw7YLvJ99H3pXHgSqMfdnMFJWDtk58EcqPjeU4sAB6QyG85vXikbIyfLO4WPOcpkKs1HOdxesoOUJ5DBSFB0pLhW346/j6gQNxYmVciI+Ocm65a2+yASpqrsDvH1GKTGcNuBEvuGj8XJId3INw1zugrDbkXH6K4r45lsXNH3+Khjsew5dufkixXJtekos/vvIYsrNtktfl97rZ70+pX+Nk3kOE1CDCI4EwBSTrIpOv39nZifLy8rSIekpjAaAoJiohF1G6urqE0tSpcsilGu5CiGd061bkXLEwJjpygGnV5WAsE5OxmRKNkinlrqqqQl9fH/bu3YtoNCr8J8fv9wvPtda+9ZyzWBjlRUce3iEp7v2o5xrK34tKLk/eQSkXJQEgwgGDQWBJ4RIw9kLJssxTr0Cw/Q1E+3aCMij/aadMZti+eBzWH9GJ6P5A3HIuHMXOrf/F196/Gr9+5teKvxNsNisMsv2T3rYEAoGQHHpFsXR/EZuMGDdVXwJruRXFf9tTEf7EDkk2yMYUnAQJ2WrMVPWNfbUd1W9UT1mf8ckKUrxgw/cOdGZn6zqu96U3kV1iBApivawNJTUwLquLGxsvOvJwAG7o6sIKq1VRTJyMkKrEZERMtdLr42w2XF1UJCRS8/ttrKqKG79SiI+a6EgByDcYYKbpONfeZANUErkCKaty5QxjLwQ9bwmCbz4DKtOkuA5F0zCULcO56204+6PPFdc58JEXt1Rchm+/dB8WLV4AAHh3eBhfbG8HOCBqNKB/PGBH4W1O+jXOQojwSCBMAcm6yOTL9QooqYyls7MT2bJJQn9/v2qpq1ykCQallvmpcMilEu5CAi5U4DhgvJU3lWWXiI7A3BCN2traFIU4k8kEiqLAcZzE/ZjomVQSFeVOSbEw2tDQINle7pBUuoacQqmNktNSXtat5KAEYmE32dnZmvfIXHkKuIqTFZdxkRDGXnsCVKYBxoqjoNblsfZ4P4qeehe/WXE1ogpfQe+hwvjSQzdJSmNIb1sCgTDXSXcvv0T70yvqKX0RCwARbwTbF25PeqzJiIlT+SWwnj7ayQp/coekoEbw/yY5/pmsvpnKPuMzlejLsdJJBbPgyLh12kdGEoamKL0+GSFVTCIRM5EoqSbWcYDmfrc5nbi1uxut4xU1LMcp1KXEEAfOUBSFFyorFR2n6QhQSdUVyGQXIOuL31KcCwNAqGUTokOfgi6cj4xC5VDFwhOjuHd5G54+7w54IhNPxQ/H/x0Bi+fKbdiz/lqwNB13XUi/xtkHER4JhyVTIVKJ9ykvk0zkIlPqHQfERMLJjk2+b7/fD6usZ4jW+Kqrq9HX1yeII/Ly1qlyyCU76SIBF6mhJBrNNhFXb49HnkTPJH/OLpdLeGb4smqlZyaRQ1LpGsodmSzLKv5eUAqmkTsoAaC8vFzX86zmXKaMZmSuvR6h/76IqHeP8sYmAyirDcXXnowfnhP/+wgAIvuG8fLtj+K219/B8acdrzoOhmGw5tRVsNmS609EIBAI0026e/np2Z9eUU/+Rax5oRn+Zj/8zf6UxpqMmGhfbUfpQ6X49M5PERmKgLEyMBWbsPPSndMStJKs8BfnkBwXHQ15BtBmWvNLbCWh+FCtvpnNib6VFgt6VeZ2asKompDaHIiv7EiEloi5rqREl7NSSayrb2tLKI66AgHVno+AcuCMVl/CZANUpqJcXW1Oaq49G5HPdiLU8QYU87kZCpTRiIwTa/D1I/qAsfg+kWwogv9p7MH/XH8fXFedhiMyMrA/EsZicwYumT8Pe4e24/nxdY8+phxHHrlsUudCmDxzRnjcsWMHHn74YbS2tiIcDqO0tBRf+9rXcO6558700AgpMpPixlSIVGqBFXpcZPzyzs5OScKu3++H2+2e1Niqq6vj9ktRFGprayU9Hnfs2KG4PZ9wLEaP+2q6IQEX8fheb4ZtQRD0vILYCyoTADlTJeKqvecT/S6QC382W6zfi/iZTuWZ1PvMyB2NVVVVcLlcSf3ukpdPOxwOYTv5teUdk11dXQCAsrIy1XNK5vcoRdEwr7pAdYzR4UGMvfE30FkZoI5YqriO6QjggpIilP22BT2Nrar74jjgB8EHceXf7sTqk49TXY9AmGuQ+eihR7p7+enZXzKVHeIvYtvq24R9pjLWZI7ra/Kh+9vdsXNhgagvilHfKICpD1rxNfkQ8UbiREct4U/RIckCtJnGqj2rNI+lJhQnW30zF5iJRN/w0DCi7iYwaxYC43MUJVFqXUkJXvN643r+0VAXRistFnjGS27FDIbDaPL5khLP1ETM1w8cwOutrYiIHHzJOCsTuUzlgqcaD5SWSoTGJp8P9W1timIh76S8q6cHLQcOoCYnB3eqCJXpLlfXg2HJchiWLFdcxrEsxrY8BTAh0AsWKK5DA1i6dBGefe49bP/z2+BkT41Yvn4pBDz+hUr86tG7VMVQwtQzJ4THd999F9/4xjdgNBqxdu1a2Gw2bNq0Cd/73vfQ29uL66+/fqaHSEiBmXSoyQWGjo4OAJiU+KknsEINXnyorq7Gxo0bJYLKZAU0mqZRXl4eJ4qKr7VSvzwxcuFHr/tqOtHTt2+2Ofmmkn1PvgRuyxPI/soaUPYccBwHY4lT17ZTJeKqvecT/S5QKmWWC/1lZWVC6BEf0KJ2b/nnYHh4WPJ6YWGh4vpycVDslNT7u0vp94Pa+GiaRl1dHerq6hSXi5Ffu76+PiEZO1mY7AJknnMdwu5N4A4Oxy3nQmPgqDDowkJU3L4GFcExjb1xOOfjPvz16z/H7ysdsOTY4tZYuHQBbr3tRpjN5qTHSiDMBGQ+emiS7l5+eveXSjltOsaq97hxAqrsmHoEz1RK2COtEey4fgfk6pOtzobSB0pVhb9US6MTCcVTGSSjl3S60aY70XfsUw/6b7wJ889bCqq0FBRFgbLkA+b4+7LabscjZWW4YfyLVyAmMNEawigvVsqhoV6erYaSGxSAalK13hL1RC5TJWFSCfEo9IiFq+12NFRUxHpxVlSAYRjF/aazXD0dUDSNzLOuRri7GdE9u4TXh6NRtAdGQIPDsUYWjDkDuZesxtpz4uesYjj/CD586gNcVH0hHM7SuOWmDCO++Z1v4Mij4pcR0sesFx4jkQjWrVsHiqLw9NNP45hjjgEA3Hjjjbj88svx8MMP45xzzkEJqeOfc8ykQ02pb6HL5ZpUYrN8n4WFhUm7opREQr1JvVpMto/fXOgDqGeMh0s5NjsWgu+R/4Pj2mNA2XMAAKblp8LgKNe1/VQFzqi95xP9LlBzBfLrFhUVgeM43fdWLlomSyq/u6brmvLJ2Kk+17TRDPNKdedW5LOdCH24DVRmJpCZqbkvU20erl6fg1OeakNkML5Hp6+tE9c8uRX3N/0JRQ7lHj8EwmyBzEcPXdLdy28qewNOZ99BRZFTTALBM9US9tAToZjCIjtHQ65B022Yamn0TIXI6CUdbjQl4XK6BKX+B55E7lEUqGXLQFEUaPsCmGrqVZ1n3ywuxgqrVdLz0Gm1KiYf8xiAuJ6ILJLvW6kWDqOG3hL1RC5TNcFTjlgITKdYOFN9PxNhLK2DsXTiS/gMABk+H05vbYU1GkLbgQ7k2S1ATq7mfqicXBzz3Vw89Oy72N/dGbc8EgX+ffYtKNlwNa746kXpPg3COLNeeHznnXfw+eef46KLLhImeQBgtVpxww034Lvf/S7+/e9/45ZbbpnBURJSYabSdIEJ0aKjo0MSljKZxObJCCFiJ15hYSFqamqEsegNmpF/q7z49sX4JOuTtLj75kJ4hJ4xplPsns3uSS4cAcVFAFMsQoTOXahbdASmTmhWe8+n8rtAfr/lATCdnZ2q90btvg8MDEzqPLSYrmvKH2OqMCxZDrpwCaK9u8aDi5SJ7N4FsCOgFy3EEbc5lNcNh7D8jXb8cuU3sDPBZ6ejVlXg3kc3qH5bTyBMNWQ+euiS7l5+U9kbUNg3zU20RmOBgvMLJrVfJWeiosgpw7xQ2bHua/Kh/YJ2cBHR736dLkm2m1UUAv3NfrTVtwm9LgEguCco+X9rrVX4f72l0VMh5qYzrGiyAtNMlNGKYX3DoIqNoMbnYabatbrKXcU9D5v9fqxpbY0bM39uEYXtU+lbKXeDDobDqm7HZErUE7lM9QieUQCbvF7Ut7VhXUlJWsXCRI7Mqej/mCqr7XacmpODzV4vSnKduDg8hEIuAhpAWWYmrpWVZnMH/Yj07gSVZUH+V9cgn1XoKclxOOrzPXjtl0/hiz//I1iD+vOZmWvFvX++B0csK0nviR0GzHrh8b333gMAnHjiiXHLVq9eLVmHMLeYSRedWLTQcj4l8wE+kRCitS+5E6+2thbZ2dm6S66VvlX2bvbi81s+x1jp2JS4+9KdADkdpFPsnlPuSSa5X/VTJTSrvefT8btAKUTJ7/cr3hu1MCe9z0Oi8fKidFdXFziOQ01NzZReU3H4EzD1X+LQGVbQy7TPxVhah9CH/0VkdysoNbHQYEDWWcdi/YJdGPlwr+b++j76AF+uvBB/eOdpZGfHl20TCFMNmY8euiTT93Am9iffd+lDpei6YaIUFRTQfVM3rJXWtIbhlD5UGi9yJrO/iIJgo8NJSJfSiA5FpUIgDUT2R+Dd7I2NsXeig5vS/9uOs8XmpTquebqF4nSHFU1WYJp1ZbQ6REe9Y+bXUztOKn0rxeEw9W1t2Oz1xl1/M0Xh1JycpErUtRKi5cJkkGUxFInEve1YAJu9Xmw5cAC1VmvaQoK0HJkzLVxrjZcD8IwpXxjvG1VOGBXGZCitwdh//gIq0yT0GJXDLFuK+vU2rH79g7gEdjFjQ0H86bSbcOJjt+Csc05N0xkdHsx64bGnpwcAsGTJkrhldrsdubm5+Oyzz6Z5VIR0MBtcdEouxZaWFmH5ZD7AK4lcai45JSdeMiKZYn8amkP+K/no/XavsM9EsCyL1tbWhC6+dE+q1MaSbkdhOsXu2RxmEx70wZTNgTKapvQ4yd4jtfd8On4XiO/t8PCwpmgvXpdlWVAUJYS96CHReN1ut/B7pKWlRQhzmgr4XrLy+zAbMB19AoxlteBCB+OWcdEIgm/+C1QGDeOKo5Gz4mjNfdmDQfzm5fex4ZivoJ9T8jbECFEcFpztxP2P300aiBPSCpmPHtqk0m9xOvcnZvDFwZgywM/5WICj0h+GM/jiYEzkvLlLVXgM7olPmxX2p4QOJ6HpGyaMvj86cY78vzS0S79F+N/1o3VNq655abqF4nSHFU02hVo19dnvVw0mSRdcNArONwiqTLs1ixy9Yqtab0QzReE/Tuek+1aqCXLp2LccsTDJi32UggMyCgAch48OxuZW4rfJZMRWNUemnkTu6SbZPqV0lh2Za28ENzqMuOaxAMKdLkT3dYEqKID9kpM1j81xHL6/phvPfftBXDVyr+a6w3kmPLblDygsnKf73A5lZr3wGBjv7cCnmMqxWq0pfeBPFKZBSA/8dU72erMsi7a2NkmK7FSVsa5YsQIcx8Hj8aCwsBDV1dUYGBgQ0p5TfVb4/YqTo1taWgRBore3FxzHobq6GoWFhXH9IZW2VxvLyI74/jQUS8HUOyE8FRYWqm7Pv+52u9Ha2ho3Pjk9d6lMqu7qQUVDhZ7LkxCxeKM1lmRxOp3C/3Mcl/L9Vbpn0/F7JdF7KuDuxPBPf4S8K48FVTRebpBdMCVjm4p7NJn3Pn9vxeMClO+N+DngmczzIEbsPuR/nupnI13PddqhGMCs/PfbdPY3EH7nBXD+foBWFwkpgwGU2Qz7BSdg/dEfgz0Y/0FXIBLFx1t34fLjLsNPnvq5pvg4ryAPOTn2lP9OzSRzaayHCmQ+OreZi+9zNZTmfIjGXk/l/NT253/fD+8WLxTrWMdhx1gMvTkkEfcU98dDAYtvX6w5HzU4DajYXIHeX/QKQqDf5UdkUGMgCnCc/nmp9XgrKl6Wriceo6/Jh9137xbGs+j2RaqCZrrvz48WLcIWr1cqMAG4fbH6dRSP96clLB66HNhRObGcBrA/EhHcfP2hELZ4vdi6YoVu8THReyoaGEXvjesxr44Fc2xN7EVTlq5rUKEitlZYLJLtldYDACvDIBKNTvr9frzViq2Vlbh7925B4Lpj8WJEolGcIxJtb1+0KK2irfi4m71eRd3fF42CAVBrtWJPKCSM7TirVXLeen/3HW+14uWK+PfADhUReMdIas9zulAbryZmq+LLhso1oPoWIrJjM2DQ+MxB06BoGoajy/ClH9tw/p59mocb6RrCPXVXo/4P38OSpYvUh2UyYfHi4jn7d0rveClO9Sup2cE111yDpqYmbNq0SfFb5jPOOAP9/f1CKnEiotGoIKwQZi/y0kGHw4EFsp4Nk4UXG/fv349QaKJMYyqOxdPZ2SlxYtlsNpSXlwtjCQQCsFqtcDgcSbl1Dt50ENF3o9JvpGkg4oxg3/f26d6n2vjkBOoD4PbF/+qg5lGwNir/Uk8WrbGker0irRGEngiB7WZBl9IwfcMEgzO1718me8+mAm5kDPbb7saCq48BvawMAOClsuHJLgWmYGx6n5dkSMd7f6bvzXT8/jqcoNkIjtjzX5iys3Stz42OYvAf7+Bfr49pfV7GABvB6BmluObbV6ZnoDOA0+kkfS+nCTIfJcwW1OZ89DE0KBuV9BxHbX/IBjAM7TJrGgAFZD6WKRxLcX8AkANk3Z8FpopJej6mus8EpGNeGmmNYPS60dixRVNf0w9NMF8S3+NS7XoyxzHIeljf3zE5rZEIngiF0M2yKKVpXGs2o0rld78wXg4xNywNRCngll8D7ZWxW8Zi4l/REHEcw+DhrNTGKIe5/xksXfA5jGetAcUwCEc4fJq3AhE6cTVOaySC60ZH+VPgHzP8PitLct6tkQj+d3Q07rGgxrd5LDMTTkN6fVZqY5uKYwHATQcP4t1oVPHR13vP5M/PN0wm3WNVOn66n5U5A8ehaKADueagrs8VHMsi4v4Azz/2OQZC6uuHOQ7vWMP43u9vg8Uyd69pojnprHc8Wq2xPxbiD7diAoGA6rfPWlRWVpLJ+jQQjUbR3t6e9PWWO4YoilJ0KE0Gt9sdd5ypOhaPvJS7rKxMONZknGK+X/iw4/Qdsb98oq9Da39Ti+xV2Qm35++TxWKRvNesVqviteio6Yh9Cy7rvxNeFAbHcWlxqGpdK/G98/v9cDgcCe+Zr8mHHdfvEJISo0NRjL4/ihVbV6RcHj4TJa1a76mDH/TggCUCavx3IpW7EIVVZ6NwisaidY9SZTLvfbFb0uFwTKlTWosVK1bA7Xbj448/xrJly2ZV8NBchXPWINzcAM4b/ztbAgNQmZko+MqJ+N8ztPtGciOjaHu6C7/6zgNYekIZHA4HaEr7Pq06cSWc1elxdU8G/vcAYfog89G5Tarz0ZlGyWmHXyB+zgeA/XBcGkhyjqM2hzQYDIiwCVyGbGz9jGczUHF1heb+ql6sQvaqbOX52HujyCzPxNgnY+A4DlanFYVXFWLopSGMtI8ga2EW/JRfWmKeCAbIqclBhXNyv7M77ujAKDcaV6EZ+lUIR33hqLjrq3b+Fb+sQLYz8ZxcCSeAq5MZL0YFVZFiAQMD3PyMAXfW0qi0WODy+zEYkd5bFsBnDKN7zpXoPfXJ4MOgV9iFPs9Zp34NFYxR176dAMp8vjin4aps6fUb8flA7dgRtz03/t8Pw2GYo9G0uhLv6OgARGLn+FsAz2Zk4OqK9M8PfuHz4fQdOxSFR/E9axq/Xs3jf6MoALU2G9bm5OC7n34KIPY4DkWjeH90VLe7lT++7HHGLysq4MxO7Xme21Qj8vlORD96B+C0fhlFQZlNMNZW4OK7C8EFQxqrsrh6+6dYf+XdyPtSHRYuXphwPjq/aB4uuLAehikQu5NF75x05keagJLxPgWfffYZKmRvZp/PB6/Xm9KHf4Zh5tTEY66T7PV2OBzo6+uT/Jzu+6WWYDsVx+KpqakBRVFpT0LOOzkP1duqk+5Pw/fo83g8iv149u/fj9bW1rhxlqwvwYGtokbcNMCBQ98Zffik5ZO09LSrqYmVZXR1TTRQpygKNE3H3buBgYGE92z3PbuFSS4A4a/n7nt2I68xb1JjnQnk7ykuGsWBvzwHW1UekB2770ze1D3LgL7nOdk+kJN577e2tgpCaF9f35T2VtSCYRjU1taCGZ8MJnMPZnNa+ozCMDCccEHC1diDwxjd8mfQlgxQxcUJ16/+fiHu/su76HqpJeG6ALD9Nw345xeduPvhH8+4w5kwvZD56KHBXLreviYf2k9vn+inPRDCga2xftryOV/EG4G/2Z/SHEdtDtlzV48Q5qJJFDiw7QDeXfKuEDaoNSdVnI8BGP1wVNhl4L0AAu8FBFteaGA8NKbOFpdkbV5oRsQfwegHE9sLATF3liS83+KwRPF++XMZ6RhRdlpy8dfX1+TD7nt2w5AT+4hNgYK1zpq2cCE9jHQol3of/RmN3lWrACiHpjAAVlgsSb8/lN5TvjdcsFoHwSw+NvaCIQMGU0ZS+z05Lw8n52k/u/fs3q26jEWsnBwABkIhbE1TIEqHSulxx8jIlPxuOTkvD9uqq3FBe3ucWMzfs3cCAZze3g6W4ySP6mavF695vRJ3Ky8e3rN7NxoTXF/x8fX2UzwcYJauAJau0FyH4ziMbdsIsMOgCuYh0Ywxp3gB7lvQivefbQPLtSUcgz9M46s/eQKP/fcvyM3N0T/4GWTWC4/HHnssHnvsMbz99ttYu3atZFlTUxMAYOXKlTMxNMIUMh2J1/LwFpvNhrKyMnAch4aGhin50J+OEA01YSKVRubiZGZgwtHBEwqFhOXiccsbcR8sPIi+M/owtmwMQHqCVmiaBkVRgrtEHNKRSjr1SLtKz50E6YpzgWg4jA8uuQlLnEEYjj8RlNEIgAJTWDqlx9XzPCeb/j2Z9/5sDvzRy5xKS5+F0FnZyPzCNxH56L9gRw6orxgJgvXvA2W1wXHtKXCENPpGijjJN4ydj7fjgooLYFmcr2NAFC655iJc+KW1idclzGrIfJQw3SQKKRHP+bYv3D6pOY7SHLLgvAJ4X/Pq2p4Lcgj1hiRhg2pzUsX5mBpitYQGDLkG1L6j/DdRLCDq/QI+LixRnJA9fi4Z5RlAr/L24usr35cgfupM106WuPNdVwL7ajsslRaE+kOQq4riUB+tFOPJsv+ZTYi+8DDsV54Eyp4LADAsrZn0fpVQC5eRk85AlGTDfpp8Polol0qIz2q7Hc9XVkrSpcX37K7xdG+lFGzxvzxR6E9F548/U0EycxWKopB56uWI9O5CZM8uzXXZfZ+DyjTBfFINTqzVeV/CYZy07QPcvuIrOFAxH1RCaRMoOWYpfnLPD2EyTW34qBqzXng84YQTsGjRIrz88su46qqrcPTRseTLQCCA3/3udzAYDLjwwgtneJSEdDMdiddKAofeD/3T6UqSH0tc3jpZYUIuzASDyh++lQQc8STV5XLhE9cnwrLJpIFrHZf/ORVxSs9EbK7ifup5FLM9MCw/BZTRiEgUsJ58BaiM9PTbnAzJioGTee+nIkjPNg4F8XSmoQ1GmCq0UwkBIOrbh+Bbz4DKNANGfeVflMWKilvt+N1z7yHQtz/h+hwLuG//PW555S3c//g9xCU5hyHzUcJ0k8wXpuaFZoloJn5djppgJV4WaA4gPBiGjs+yceNLlOCsOB/TAwt4t3qxfeH2uHEDiZPElZyNgdYAuIhK3MH4uShdV/G58CgJxRGaw79+0I4jX6lMa/hInGAqEnxL1pXgwBZRVRIvgK4vEbZPNhU4GYZ++3s4LlkqiI7Go9fAsGBy/b/VUBIB1UhWbFMjGdGWT6fmxcL+UAhbUnReat0zvQIsTzKp6ITJYSg+EobiIzXX4VgWY5ufBGUIAxb9n92yzzsB9xS1Y+DNPbrWH3pzP762/EI8tP1JzJtXoPs46WLWC48GgwEbNmzAtddeiy9/+cv44he/CKvVik2bNmHPnj34zne+g6VLl870MAlzECWBI9GHfl4EFIdqTLUrSS6GyntI8WNMJIaKlxcWxrr+DQ8PS/ZVUFCg2PcykYCTqkst0ZjVhKRUxCk9E7G5yoH+vVhkpAAmdu262RxUzwLREZheMXA6nNJTzaEgns4VGPs8ZNZ/E+G9Pej5+GOUlJSAZtS/QGKHBxH5xAXKYkHeladCb4OGxfsHceQfXLh0yVqMGRLn+bEGCufeeAmuv/nrOo9AmA7IfJQw3UzFF6a+Jh/cp7iFfYZ6Q/Bu9qL6jdjfS4ljD4jra6iLBE7LuPlYMoQR56zU06dbEOpYLla6rSEmSogCUb/6IMVzSCWhmGEBW2cEa1pb01Lmy5PIDSuuSlJzf06Vi40LBUEZx0vNs3KmTHQE4kVAHjvDwC8LREmX2JaMaLth3Iko6YAwCeel2j3TEmD5MmtJKnqa3K2E9EDRNDLP/jpC+3vR82FHwvko2ChC7q2gMo0wH1+Fxcfre5YWBcfw4BY3flnzdewyJujfO05u5UL84R+/hdkc/yVWssx64REAjj/+ePztb3/DQw89hMbGRoTDYZSWluLmm2/GeeedN9PDIxxCJPrQLy9N5km3K0ksyMnFQTn8GBO5NZWW89hsNlitVpxxxhnYsmUL9u/fD5PJJIicHo8HLpdL1dmZqkst0ZirqqrQ19eHoaEh5OXloWoSEyR5ebjeMhxg9vfdy8nJkfxss+corjcTpCIGql3vRPdhOpzSU82hIJ7OJSjGAGb+Uvj7fGAcpdr9mRxlMBQfhbFtT4PK1F+mQuUX4KibT8Jj/+0AG0z8KZsNRdHypxdww3/b8PDT9yu6JJV68hKmHjIfJUwnyXxhGtyjXLEif7371m5FF6X7VDcMdoMgzE2KBOKofD5mXmiG/31/csfV4awU07OhJ7VzY2Ll3RFvJO662Y6zSeaQSkJxlAY+OSL2OzsdZb48idywSu5PLafrlJEgIGOyqImAHIA1ra2gpqCUnD+u/F4qlVQrORHT5bwUwwuwtKzcmh7/7wdmM9xZWXAFAsD4/OGunp6Uyr4JUweTUwR/Zn/i+SgAZkE5xv7zN3DciO5qGsqcAWv9cbhz0S6Eeg/o2mbfh0O45uiLcO9bT6DIMT9+n0lU8swJ4RGIpYQ+/vjjMz0MwiFOog/9agJjul1JagInAJSWlqK/vz9OjEvk1tQSR202GxwOB3bu3Ck4HkOhEGw2m/AzH/jBCzvpEOMSjbGtrU04vuf/2Xvz+Dju+v7/OTN76NiVrMvSWo4tO5JzWLIu57JzQbiMCKFASAIJxxcKFEq+QOgvQB36bWMotE1C4dtCoXwLJS0ESDkVx0mABHASJ9Zl2UksKYkcW17JliVLu5K8K+3M74/RjGZmZ/bQYfmY5+MByu7OfOYzx8qj17ze71c4TFdX14KEpfn0wYQzv+/eatGPb4UHvKoYsnbt2mWe0RzzEQOdjveZfh4Wg3NBPD2XEQNF5LZ8EmYy6wmZOH6YeOcuhNw8cl+fef+/a68/SeV3nuOv1vwZMzZ/KX/4Z/fC8rToOe9x70ddThfZPDC1dUeKIMdkU2lypN0+lZ1pmBnOzAFjQkR1RYpkVU1ivR8b2z1G3119aumzoiDlSiTGE6kdlwk4+fuTjO0eSyugTXQ7BMSkYnZf1t27jr5P9SUJwNX3m/toa0LxjKggybOHRYZLD8BbfwntNy+e2JStGzZVafZiio/xwRFyAtOQm12QzEJwcgEupJQ8276MTiXVzYFAVv0g54tRgNVSrREENgcCfHHNGvJeeYVtF1zADd3d+hwfHx2dd9m3y/IjCCK5N9yOkpgGOf1DbWVmmlO/fRAhV8K76RK8qbNxdPLeOM0//66d7171ccKJ5H8j/BtX89Wd/5LRWGeN8OjicjpI90e/XSDNhg0bFt2VZBXggsEgBQUFeo9HOzGuvLzcNDetnNpp7tbP7LY7MjLiOK/FEIHSOUzPlH53Z8o8rCiKwuD9/4m359f4b7wOIS8fFAWpMPmJVLYsp8vT6XifqefB5fxCEATwZvZHlWdVDeKKcmJP/QhFmc5sfL8PoXAFF37qGv72VfvEzp6DvVB3YcZzdnFxObuwutM2PrQxpUCU5I6cra+cGZlRS4sH45klVGeDCIIoUP3NaoZ/OZx1NYkVT5EHb4mXxNoEVe+r4pVPv2IuJ7ZBiSl0Xt+ZVkDLr8tPW14t+AUCDWqbGj3VenZfAnUBRwHYeK4CzQFeey3KirCqmApAYAI+83V4LE+CLVkdEkcyccMa5yXHZLPjM0vHaCZEu3oZ/ev/j5LbmxDXqPMQiysXZez5MN9S8vn0ZXQqqQb1vCxFiI8Vp/1NJBJ0Al85fHhRy75dzgwEyQtS+j7lgjeH3JaPE3/mFyROOqRlWfFICB4veW+4jDtrXkM+lfw79Ehn+n7n+nAZL+nichYx31LNdNg5IrX1F1OosQpyGzZs0EW91tZW07Ka+GItvbO+Ns5dEyWHhoaoqKhg06ZN7Nu3j4qKCt3ZCFBUVGQSd4xi5mKIQOkcpmdKv7szZR5Wxn7XhvDHH5N3+3UIwQKQFbwNb0HML1rw2MvpLnQ63vM5D2d6mbzLuY+YV0Duto9lvPzM8BHie36OkJOL5xL73lghuYjkbrwuLi7nAvNxp1ndkXJM1kVHYH6Co+Zm9AA2z008xR7W3bvOLDrOI8E5KQ16EF5+9mWkAgnBKyAgkHNhDpG9Edv9UJQ5Ac0uQCZ2JGYbsmNF8AhMvTxFcHOQ6vuqUwbXjO0eo2tbF5G9EWZOzKgK46zAWzRr1NQKEAXU12/+dhy+nNWhccR4vqN7oyiz1tD+e/up2l4F2PTrtJJF6nk65Pg04U9+ntCtaxHXqtsXS9fhrbliUcY/ncynL6NTSfWRWGzJQnyy5XSVfbucuQiCgH9L5iF48sw0p3b9P4QcEWFdFXZ/PZXGX814PFd4dDknWapSzVSOyMUUalIJck7iS19fn2mMvr4+Lrvssozmnkio/xTV1dURDof1Mu7y8vKU5eULFePSOUyNx0GW5bS9JhcbTbQKh8OEQiFEUTyj+u6denkAX5EEubkAeDdej6dsccqsreddO/anQ8Bzuv7n0//wfCjPdjm38JSuRrzhQ8Sfb0U5Zf8HQellTYRf7j+9E3NxcTktpAsOccIojj29+un592r0grfQS2BzgKp7qjjwngO2bsGZEzP0fqLXJLplG/jSv6Ofk78/aU6Wnp13YiwxV9Z8n1rW3HlDJ0rMUn89K6AlCbaGOccH43MKoAPyhIw8ITP62GjK/UgSSjGMO/va2vVMADi5mHZT9XxXba8yzWX0cXXugeZAWrfoQoOKjCQik0gzEcQC1TEqBMvw179xUcY+3WQj0Gkl2cPTycq8VlK9VCE+2VKXn8/QaSj7djl3ED1ect/6Uab3P0Vi8BXbZQrf8JaMx3OFR5dzkkxLNRdTTLGmQdulQ6fC6swy9m7s6OjQ55ap+BKNRtm7dy9NTU0Z71N3d7epjDsajZo+Hxoa0v/baR6ZOMxSLeOUvq2liFt7TS4l1l6bzc3NZ4xoFR88wdRvfkbghgvBpz7JFwOZ5uymxyosK4py2gQ8J0F6Pv0P3fJsl7MRMSdAzjW3OH6uPSxycXE590gXHJIJtj0AMyUBMydndPei41iK5WcW5bu24p3DXBQUOq7uAC+OwqF/tT9ZsLWMkzEyKILzfqTcTgo8xYv/Z7eTSB3tjKYVHTPpxZkJSiLB0H3/QfFVxVBcCoAYLFnwuMuFXUK0nUBnLcnGsvyZlhz9xQsu4LeGBPAzcY4uZx6CIOCrux7qrndcJtN7Uld4dDknsXPjybKMLJsf/zqJKfMpz0xX6pwOqzPr6NGjughonJuT+FJTU0N7e7tp++3t7QiCkLFYk06UMboaneaRicPMaRlZlvnNb36jz8OpJ+XpEo/OVNFKCY8w9IV7WXnzRYjr1T5vQqAUIVi6aNuwCssLPRaLWfKczViLXSbvlm67uLi4uCwl6YJDMkkntusBaMLwnhSQVHehhkV4SxorFRkKpPMS71K0yY3sjeAt8i5eD8sUwTW2wrCR2f6aVtbtWLdIk0szlwTqX/gSSWFDnmIPol9cUC9OI4qicPijX6K4Moz3zVcjeH2ggGdNhskVZyBaQnQ6gc5akq3hFwRet2LFspVUO6EF0NzV10fnrLGkIRBImd+UDdkG8ricf7jCo8s5iZ0bTyuZ1dBKZ41oYko25ZmaEGENYsmk96Pxs/HxcdP61vHSuTObmpro7e3VnYHWfcoEa49HRVHSlhgb90GWZU6cMDeZ7enpSZqzk4iljZPJPJ1Yyl6bmYpWMzMz7Ny5Uy9Z37ZtGx7P4v26FXY+z4oLFYTZ9GqxeA2+hjepoReLhFVYbmtrW5CAt5glz9mMNZ/y7MXatouLi4uLS7akCg5J1//RGnQC5qAUFJJCUg6854BZeASTgGjsJzj62GjqEm6bJG27cuW04t08UFAcRb95jecQXJPWTSqDt8KLPCWTiCTUXpg71lH5sfkHrRhTvwECDQGq76t2FKkDDQGibdGka6jul3ULFhtNHDqG53AH3jdvVUVHRHKuvhUhJ7B42zjNGBOi7foyagLbY6Ojtpdaqdd7RpRWO9EWjeqC6d5IhOs7OxecbD2fQB6X8w9XeHQ5J7Fz41kFLU1MsxNTrMvu378fwFbEspbjWsdKJVQ4rQtQXFxsEkrTlbqKosiGDRuSxstUIFIUBUVRCAaDxGIx4vE40WiUaDSassQ41T4ARCIRIpGIac6ZHncrmaSIp3JTZitI1tfXc/ToUV1ArM/wRmLnzp2mkvWdO3dy4403ZrRuRsSnEXwCCOr8fZdcgyAsretuoQLeYrpHsxlrPuXZi7VtFxcXFxeXbLEGxRjdaV3buhz7P1r7/cUH4wiCkCScWcuH0zkstTnV76yna1uXczq2NUl7IM7oo6MEr0gOa1lQKbgd1l6Li4QxuEYjSRi26R05PTgNEjT+oTGjfpepGNs9Rsd1HaZjFdkToeO6Dmq+WWMrUlffX20rMi+G6KiL2/smkCuiCGVz96Oe9U1nteio4dSX0Siw2YmOp6Nn4kKchfMJzlnOcV3OLVzh0eWcxSo0lZeXJ4ldTmKKVRiLxWK6mJVO0PT7/dTW1prGdlre+lkgENBdaxUVFYRCIT152q4/5d69e+nt7QWgulptvB0MBjl16pSaXOX3q/84yrJjn8VwOIyiKJw4cYJ4PLl5uN08M/nM7/fj8/lMDsyenh4aGxsdQ2Os5whIclw6iYXa/mgisXV+83GqdXV1mQTErq6ujEQsq1vV+vpsZKEC3mKWPC9nyviZmnDu4uLi4nJ2kapk2pqirOFUWnvy9yfp/H2nOaQlw56LqRyW1nnq6dBaGe+s2Ogt9aKgmJO0Z4nsiSQ5B/VtLpZSKEFwc1BNmR6eyXp1wSuox846nQRE90bp2tZlOk9JCeJ220yQUb/LdPTv6HfsWzn8q2FHkRqSReaFYnXciidkuN6wwBI/BF9unMqrwVySvVRlxwt1Fi5VsrWbmO2SCa7w6HLOYhWampqaaG5uTnK8aWKKNdSkqamJAwcOEIvF9DHtRDarEFFcXGwSyFIJFVahLRgM6kJXR0cHzc3NtLS0ALB3717TsuPj46ay6I6OjqS5xeNxxz6P6ZyK1n20oh0va4m4Rm1tLYBpG5FIRN+v5uZm2tra9M+PHj2qnxctobumpibjcByn/RkfH6etrS0p7CcTp9p83W1Wt2px8eKFvijTM/jCRxA3F8IillYvNYtZ8rzY5dNny7ZdXFxcXM4unMTFdCXTTjg5BZOSnjUy6LmYymFpN09QRb5TL5/ShcPA5gDRvVHHMmerc1DbZt9dfUT2ROxXypRZ8TOyN2J6nQ3elV78q/3JcxFhenhad3kaz5MpQdyBk78/mbbsPB2pzt9E94Sebq2dv/57++e9rXRYe3NK3iFyV3ogJ2fRt3UmYiewgXrJvbGoiHuqqlBgycqOF+oszDQ4J1uWalyXcwtXeHQ5Z7GKRENDQ7qIZ4dVqGxubqa2ttYkZtkJcI2NjaYgmHA4rKdQa0JmKBRCEARCoVBKocKaIm0s8U63bCoy6bNoRZLUruMrV66krq4uqb+kVegLBoO6Y9O4nz09PSbXYyrH5+DgIJWVldx2220Z75vTWBqRSIS2tjZCoZDp/UycavN1t23bti2px+NiMHMyyuE//xxVV0tIjVeo7lhvLvjzFmX8pWQxS54Xu3z6bNm2i4uLi8vZQypx0SmNOGt3YgZMD0/Tta0rpRjl5LC0m6cWSjNzckb/TC+/dhL9bATQwq2FND/bzMC3Bnj1S6/OuSVtSpftEPwCnqCH6eFpEFFdh/Pp8Sipqdi6cGlEnt2nFOcpvy6f+IB9xZASU4gPxDMWlu1INX5+Xf68Rez5YHTc5pb8iQv/rJPclusRggWgKEhFqxZ1e2caTgLbG4uKdOFvW1fXkpUdL9RZmGlwTrYs1bgu5xau8OhyzpKtaGQVrnp6erj55pv1z5zcTaIoJjnyenp6kgS3pqYmQO3/p401NDSUck7GEu90y6Yikz6LVhIJ9Z+2cDjMrl27khK2rceroKCAbdu26WKrJr5a+04az4PdHObbMy/d/miCUTZOtfm62zwez+L2dJxl4O//H0UVx5Eab0DweMCTS86V717UUBkXFxcXFxeXhZNKXHQqmc7WnTh9bBplOrVKp8QURh8fnZcY5TTPaGc0WZAUcRYMLT0jNcZ2j9F3Z586libyZSIcSrDidSsAzD0nMxUdte3MlpU74iU5Tdtynqq2Vzn3vTSsk4mwbIfj+BJU3VNF/73zE7HnQ35dPvFwHFEKs3rzn8h7w9UIwQKUaZmZ3GvILVy5qNs707AT2ABGZ2ZY/fTT1OXnszcaXbKy44U6C9MF58yXpRrX5dzCFR5dTiuLmTicbjuyLOPz+UgkEpSVlaUNBrEKV5FIRO/pp83bKBoa5223rhVj4rS2rHW9mpoaBEFg//79phLvzs5O3YFoxefz4ff7kWWZCcM/aoFAgMLCQsbHx1P2WQyHwwwPDzv2dwT7sB1r+XBFRYVtH0WjeFdeXo6iKLS2tlJRUaGHtxjLkufbM8/qPLVSUVGRtVPtTHO3JY4MIK7NUUVHIOea9yKI9teFy+Jwun5nubi4uLicW6Tqx2iLgzhnxehO/OOKPyYnUtthCaExllWXvr2U4V8N2/aadAqe0cY0IYOn1EPuhbnmkmVLz0gjSeJshqKjNt6B9xzIPqBmViD1lHoIbg6mHEcQhWR3qU1yd803a+j9RG/q7SYyK722K89vfKoxOdX6/moKtxTOW8RO1WPUiartVYw+OoroH8dXKIBP7fn52v9bSSwyQ/11qQ/B2Y5VYFvt97M3EmFvJKKXVdsZfxer7HgxnIVOwTkLZanGdTl3cIVHl9PKfAI+5rsdY8/DwcHBJBHRKiQ0NjY6lgWnm7dRXLMKfU4MDg7qJbh2oobRJZhIJHQHopWysjJaWlpobW01CY+FhYW0tLSY+iiCKoq2trYiiiLl5eVUVFQQiURSCo+KYn6EHYvFCIfDScEvO3fuTNpHo3hnnIt2HFtaWmhvb9dDcpzCcNIhiiItLS2mPp2AHs5ztvfiG239E3nTL+LZdLn6hiC6ouNp4HT9znJxcXFxObfIqh9jCnHOibHdY86io125ckLtg2gqyw2rydMa8YE4o4+P0vhUo9470C54JtAQUEuTLZvPvTCX5mebk0Uth0RlW9HMDgnyLspTHZ4oKNMK3Td1MzOafZCM5nQMbg6ay6VtBNZAQ4BoW3Ru/63J3bNlzYHmwFzgTgr00utwnNFdo3hKZsXPDHp/Nj9rf++RSSq5lfmWZxduLcRbGqPkgt+Re1U1BIIATB3yMTVwfgSJGAW2bV1dgL3xV7scFrPs2HUWupzNuMKjy2llvmEdC92O8T0nIUEURcey4HTzdhLXQO19uH5yPfFvxjn14inilXFOvPUEFc0Vjo46TSSzOh/t0OZodU8eP36cvXv30tDQkCSoWsumNXw+Hxs3biQcDifto8/nAzAJlNFolFtuuSWjIB2wP46iKCIIgj4/pzCcTMjUoXi2udiGf/wYyq/+mYLbrkcoKERRFDwXXr4k2zrbjs1Sc7p+Z7m4uLi4nFtk2o9R8AuseN0KW3EulSutf0e/45ieEo8qytk4FdM6DBPQd1cfzc822wbPlN5UysA3B2z3KbInQtuVbVTfV51Rma9/td+xf6F1TpMHJ1VFJ9sejg7jWcul7QTW6vurQcGcYG1M7p51kkY7o9k5L2fXnxmeMZXBz6f3Z7pUcjvm22M0fnSYippvUfH+GsSaGgAi3RJjHfkU3XD+BYnY9VyUgVKPh83B4JKIg66z0OVsxRUeXU4r8w3rWOh2jNtKJSQ49fTLdN6yLKMoCsGg+gSwpqaG9RPr2XfDPhRFwSt78Yx7yH8pn/U3rnecv1XItKKVUWvlylpqcyAQ0ENntETrcDhMTU0N7e3tjtvTiMfjiKLI2972NlpbW01ly/F4nFAoZHovEonw0EMPsWHDBlP5tlNPRKfj6HROlkoEs4rPPT09+j6ciSLb6H/8mIrXVSIUqDcth/MupPqCjUuyLdfhZ+Z0/c5ycXFxcTm3SOrHODxt63b0lnqp31nP2O4xurZ1mUqg9f6Hs6600cdHCW4OEjsSU0NVHFh37zr6PtVnduolMItmKdBKeq3CZ+nbS+n9y96UIltkT4SOqzsIXhGk+r5qRwfd2O4x+0AXJ7ItqU6FaHYEpkr2BswJ1tbjl0D9izqV4zFVYM4Ce38a5z7aFeWVdQo/fD/k5PezfazKNkl5vuXZI7/6E0UXzSBcsBqAk8/4Ofh3axAUMSu37rmCU8/FzcGgKw66uFhwhUeX08p8wzrmsx1FUfTy3ZqaGkcRUesHqYXEpHIgWudtFcYURTEJfL29vZz8p5NIioQgq82rBVkACV77ymsU7SyyHcdY/q0oCl1dXaZS62AwSEtLC7IsJwmEVsLhMIqi0NTUxNDQELIsp1xeE/1CoRDHjh0zbVcURYLBoMk9qaVGG48ToPdb1BKutf2xO45O4o5VBDt69KiptDsbkdB4jMfHx02fGffhTBPZElMxpNgoQv4a9Q3JT9RftGTbcx1+Zk7X7ywXFxcXl3MPYz/Grm1dySEhs/0C/1T2J2ZOzKgClZxcAg3o65n6J9oQvCJI5ccrCdQF6N/RT2RvRB07y8Rnu3Lc0V2jGSVOa/PsvL7TsXw3lWNzwczuq7fUi2elh6kXpsyfy1B6U6npLa20XBMA++/tT+p7mLYk2+HgCD4BZSaF83VW9JtP2bQ29+iPq3hjZ6eeqCyNjvLEyZM82dCQJD7Odzvx1wbILfCDpEoIA63lFL2+mKov2ZfSn+u4ac4uLpnjCo8uS4Im8mii16ZNm5Ak6bSGdQiCQEFBQZJIZQ0hCYfDdHR0pJyX07ytwlggEDB9HolEKH2lVBcddSxPFVOVf2/evNkUTAPorkbtGKdjcHCQysrKjMRKLSTGziFZUVFBRUWFrQtTS7K2fnb06FHT/mQj7FpFL2uJuHWsVA5Ju7nZ7cOZRDx8goGPfYaV77gA8eJLABCCJUu6TdfhZ+ZMCxhycXFxcTk7SSqJtfQLBOZEvfmUExvLg5kTPW0FzzQEGgK25bjZosjO5bsZ93ecB55iD+vuXUflxyvp2tbF1EtT5mMqwvAvh6n8eKX+ViZ9D/WEaQtaSXb3O7qZGbb0nbTrFWllVvRzGj8TN+GO/n5ddITZqmtFYUd/f5L7LtvybEWWOfqlbxKceAbvG65G8HrVaX+jiNqmWscAzHMdt+eii0vmuMKjy5JgFXm6urrYvHnzsmzfKlJpzkYj8xWcrOvZBbTEK+N4xj1m8dHyVNE6jpY87eToUxSFX//617bzrqioYGhoKCkQRlvWGMISDof1NOxYLMbGjRttQ2IkSaK+vl4XBK09IwHKy8vp6emxne/+/fsBHPfJKO4YxcOxsTHb8bQ5WMdLdd6txyoYDOI96CX3Z7n4BnzEK+OUfsb89DsTlrIn4mt//kXKr/Ii1dUCIOQU4qm9Afa/sCjj2+E6/FxcXFxcXBYfazmvHJNVJ+ICexYKfgFvqdcxxCVrgU9ShbR5JUZbkWH0sVG6tnVl5h5cJGZGZ+j7VB+BuoC6/9ZjLCeXFdv2PRQVut/RjegX9VJzW2ZvuXMvzCUybLg/nhWXp16eUgNogFMvn1LL5DUHqlH0c3KTZuAytes3mJh930q60nIrx/+jFf+hx/G/5w0IeXkgK0hNb0PuP7Me2C8Hbs9FF5fMcIVHlyVhucs1023f6uoaHx+nra3NUTRyEpes4/j9/iTx8cRbT5D3Yh6KqCDIgvoTgSOvO0LnDzopLi5OGicSiZhcmNYejbFYTHc9GgmFQnpKtNWxaHSuaWXPR48eNR0bQRD0/c3py6HkkRJdlOt/dz+CINDY2JgUwhMKhfR52xGLxTIuZc7Emahtq6Ojg8bGRscSauO+WY/x+sn1nPryKRRZUctxxr1MfXyKPexhuGI4YxFxMcvBrShDRxCLL1ZfePz4t9yMLGdY4zRPXIefi4uLi4uLmYFvDfDql15lZmRGddP93Toq/6Iy/YoWjKXXfyr7U8Zly6mQghIbH9ro2Esx4wAX1DLtig9W0H9vv30PySzLtUFdfvTxUUYfG0XMFZEnZBDAt9Y3uwMsvvg4Kxr27+hPWVZs7GE5PTydPA8Z3cEYH7Qpf5+l764+25RvZEBUx4iMRhAEgYYnGwBsRb+ubV2246cLfQHnfoN1+fbl08Zr0Qnt+MRfeJoNb/eqoiPgv/JdKHlFgCs8ns3sHhszuTW3V9n3BHVxWQxc4dFlSVjucs1027c697Qef0ePHqWlpSVJLHJy0lndYdYejwDypTK5/5ZL5F8j8KrqgDzRcoJTK05BbK4Ho7V3olE0a2pqQhAEBgcHbXs0CoJAU1OTLnQ1NTUB2Pa4NO6TdRytXHr0j6NccN8F6tiygGfcQ969eRyYPABAfX09R48eZWRkRBdODxw4YBrLLgU7lQCtibuaOzIT9u/fbyqbt2I879Zz5flrD1OKofRm9ufwA8MM3DmQNlhFm293d7fp/XTl4Jky/MNfU7TRg1C+EgAxbwWCMNsd3sXFxcXFxWXRsUuRju6L0vuJXn2ZmeEZ/fV8xMf5IhVKJKKJpGTnmZEZx16K2Qa4RPZG5pa3u90QoOZbNQx+f5DIc5HMhdPZseSJ2YkrEO+PgwDBy4NMvTxl6nG5KMgw/sw4m1o3qWXFomK65/Os8NBxTUfW+2D3fqTdRnQ0zENbzpgcnXH5eQahL5Dcb3BTN7zvQbj8cJSu+mTHaTq00nPEE1yw+UU8l1brnwm5BYuhmbssI7vHxrje0BN0MB537Anq4rIYuMKjy5KgiTyaqFZ/mi3o6cpFNceftTQ4HA7T3t6ui3zauk4OSqs7TJbVu4ve3l5isRjxeJx4PM4+9sHHned7/Phx6uvrTaKl1otRm4O2ndbW1qT1KyoqTPPQekM6lbfLsmxbFl1RUcHg4CAlj6h9BI2BOIqoUPJICYPXDerHSvtpJ/zV1dUB5lTuVAK0k9MxFAohCAKKohCNRk3ibCwWS9p2MBg09fbUsJ6rp/c/bftk2jfg01+mEkqXsmfkwJe/S+7AY+S863Xq02VFQVo/V4puF9zj4uLi4uLiMn+cevyJ+fb/xr76pVcXJDwKCE4fqGKYMQlZgPVfXU+gLpDcR1AGRbDvpZh1gEu6Z5sJdU7Nzzbz9OqnM3ZSOqLA5EuTbGrdBED/vf2M/m4UnAO7syIxpu5Q9TeqTeIxwPEfH1+cjUDmz4QTzqXnMP/QFzD3Gzz1TIR7PjODCJCYZvTYaFK/ynT07+hH8ISpuvpBSu9oRKhUDQnj3YXk3uCDhPsg/Gwmm56gLi6LgSs8uiwJmsiTSCTo7Ow87cKIXbmoXQK1XWmwMchFc63ZOSidyq83b95MU1MTDz30kG3PRzu05Ojm5mbC4TDj4+Mm51xPTw8bNmygsbExaS6BQIBt27YljZkuaMW674FAgPr6evbt28fIwEhSII4gC/gGfLw2+Jpp+1b8fj+1tbUm0S+TfoFWkc44jjZvoysyFovZjrNhw4aMXIa2N3ei6kjVcBJKnYRbK/Nx+s6MRTn1q4dZ8fFGXXT0bb4JaYU6VldXl35tGIN7XFxcXFxczkbsXIbZOLMWC9sef5Kii1dWZkZmbN/PlMDmAKOPjSaFnhS9qYjSt5eahTIB+j7VR8OTDYh+m3tqB1fcUgS49H6il8CmwKL1aEyMJei4roOab9aob2RwWD3FnoyPvy6+GsvEF9uul00J+mzpuZ0Q6BRAFNkbcRQrjWj9Brs+38Uoo0nXciYl2xoT3RPkF/+BFZsLdNHx6H8HGdq1mvJPZ7ivLmcs2fQEdXFZDFzh0eW8wVouHQwGM1pvcHBQF/aMAlqqIBM7YS8dQ0NDtLS06CXfRrRScLB3c4qiiCzLtLe36+XV+fn5upiXSdBKTU0NoihSX1/Pk+ufROlUTOKjIirEK+O6SOqEoij09PSgKApNTU0mUczpjwtZlnW3qMbGjRsB2Llzp2k/tfGsPSaNfRUzwSnRr+yzZVBOyrEyOb/BYHBewSyJk1F8+TKCV3VeShU1uugIy98/1cXFxcXFZbHIJEn4dOFU5uokKnmKF/ZnlH4fIiQnC/ff22/ufWhwNWbjisumv2M2dN7QSaBBDUuZV99HKwno/WSv2eWZgmxE3+jeKDNjCw/xccJf5SfWb/8w3BEHIdAY+hLdG9VDaGaGZxzFSjsWUrKtkVebh/TKOEJeDgDKjMLhH4QoemMg4zFczlyy7Qnq4rJQXOHR5ZzDKsDV1NTQ1NSUVqAJBoNs2LAhqU+jk2stlQCUalta2bDdvPfu3ZvUK9G6DU1809x/mjBnnbdVGEsVtFJToz5l7ujooLe3l+kbprmg8wI9EIfZh+snWk44zk1DKy/XStY1oTDVHxd9OX2mkmktrMYptEUr3V9IknS2iX5GrOfX5/Ph9/tNx3zDhg1Zz2nq5QGO/e/PUPqeTVCxCgAhv8i0TEVFhUmYXvL+qbt3w44d0N0NdXWwfTts3bq023RxcXFxOS9wchlm48xaLJwqIfRAFAvrdqxb0PZS3Yc4CUeRvRFyL8xNEh31VGQD2fZ3zAYlpuhjBy8LEnk+YivsaYnbUqHE1AtTaQZlSZyItiE5i8jM6Mz8xFcbIdD4gF5BMY+bxXcjvy6feDie5KbNpGQbQI5PEyz6GaXvEpGaGwCIDUq215nL2Ym1J6iE+nvknqqqZZ6Zy7mKKzy6LCupyoHnS0dHh0mA0wQwO7HN2stRcw5a37dzN6YKsLF+lglOvRKNlJeXm/YzGwdnqqCVTZs28eijj85tvxoO33XYlGrN+1EDcQz4fD7q6ur0ROlUYqftHxeiwvN3Ps/xz5n77IiiyNDQkOm9xQptMZJJop8d1vNbV1dnStfOxnmpkYhMMvDBTxJ674WINRsAEAvK8azdZFquvr6ecDiMIAh6j8clY/duuP56UBS1l8/gIDzxBDz5JPJVVy36d9fFxcXF5fxiMZxZi4VTmas8ZVaUpEKJ9V9bT+XHFh4s43Qf4iSCzpxQ05GNBDcHqb6/OunBadb9HbNldm5TL0+p4qM11VmCQEMAT5GHie4Jci/NZeqlqSVzHtqisDiOzBQ4leKnxZKsbXQ4Os43w+9G6dtLkxO4ZSi9qTSjqR2+++uUhHrwXn89gsfDzFiCwcfqaHjqUgq3FLJ7bIx7+/tpj0Zp2r+fe9w05LMOY09QLdX6nqoqtrjn0WWJcIVHl2UlVbnyfLFzGzqVS9sJJXaBMdZ+fj09Pdx8880oikJvby+KonD06FF97Pr6ej0x20p+fj7RaDTtfvj9foqLi01ipKIotLW1EQ6HGR4eTjuGIAgEAgFqamqor6+nra3Ndv8TiUTSnE5Vn2LgzjlxzefzIUyb3ZobN240lT5bw1aMATmxfTHbMBflleRem+Xl5QiC4CjeLnd5sVO5+0Ku3amDr5EbOIVQrDocxcIKfM03IgjmXpuiKLJq1SoaGhqQJGn+O5EJO3bMiY6g/pQk2LGDjh07Fv276+Li4uJyfrGQMI3FxupATEQTqqhkFIEkKLiqYFFERyfGdo+pLjprDaQmhlre9xR5bKs1FqO/oxgQkaOpVbuZYYMYqs1z9vbElJA9iFpKvcRCoIan1KPPb9FYrLnPulRLbyo1VQNBmvEtYqVTX9ThXw0nz1WE4V8OU/nxyrTVLPGOdjw3liF41GMYuPFDXPJOteTamob8xOgov51NQ67dzxnRr9UlM7SeoC4upwNXeHRZVpaiX52d27CioiJrYUhzY9oJiJFIhK6uLgRB0D/ThDtt2xs2bDAJcVopd11dHbt27WJkZASv1+soQhYXFzMyMmJ6r6+vz7G3YE1NTZJrUgvQEQSBrq4uk1CkKIru7Fy5cqVt+bcRY1CO5nQ0ipnl5eU0NjbS19cHqGE1RpfiJWsvgSFMN8Fa30gr2lyCwaAeImPc/kLKi+U//pHI3Xfj6+khvmEDwa99DfGaa7IaY6EioxVFURh79A/kXRiAfLV3jlhWlSQ6nna6u5NTCxMJ6O52e026uLi4uCwYp37Ly1XOqTkQx3aP0XF1R/ICS+zGNLWlMRDcHOTUy6eSy4YTMPrbUcZ2jwFm0UcqlCC74psk5KjM6rtWc+S+I6kXVCD34lziA3FdrBXzRNUtaigVRlJLs6PtUZTpRairFnEs0fat9DH1cpry7izIuzSPyZcmF2Ws3Ityufi7F9N/r6UaKB0y5Nfmp+2LOtE9kSxgyrPvp6hmYetWol295AfGEFeqbZgEXx6CN0cfxikN+T9+3scdfx49I/q1uri4nHm4wqPLspKqXHm+NDY26k5EUAW5+ZSjGt2YdqQSWnp6eggGg7ahJx0dHYiiSG1tLfX19XR1denCnTauMdU6E4LBIA0NDYAqgE5OTppCYHp6eigoKDCts3//fl3My7YsXOvdaHQ5DgwM0NzczG233QZAa2uraZ3on0XJez4PWZQRZAFFVO8S7fpG7tu3zzbERhNv511evHs3wuteR1BREGUZ/549CK97HTz1VFLfwqVoA2CHIsu89ql7WRHsw/vWaxH8OaCAVFa16NvKmro69YbUeC4kCerqluS76+Li4uJyfrGQfstLSaoy5aV0Yya1pQHd1Wibgg0wDR3XdqhuQlBFn8UKlBFg8AcZPFiUMfdwVLDti0kCIu0RBHFxHqxKQdVaaVfuPPnC4oiEGtPHphfNqTl9bNq5l6cRa9iOAkf+6UjK3o9ju8eQYzYT1ZzEOz7vWM0y+qntnPreV1lxxxaE0pXqaqs3moZxSkOu+3b0jOnXmop0blEXF5elwRUez0NOl6CSCXYlq/PFul+33HLLvPZLG2f//v0pl9OEFjvRLhKJ6M7E5uZm23Jkp/JUu1Rrv99PbW1tUoCMxoYNG+jq6rL9TJtPIGBOoTM6CK34fL6UnxcXFwOpHatWYWrl61ey/nfraft0G8orqtPxRMsJTl14ikAgYHJ+OiVnFxQUzMu1ql0TTffeizIrOgKIsowsigg7dsDOnaZ1l6INgB3jf+jCd+RZvHdooqOA78p3I+YVpF95qdm+XX0KLklzN6aCAPfcs6jfXRcXFxeX85f59lteSlK5GpfSjenU8/Lk70+qIpuT8LVUpcuK2ldyUZlGDU5ZBObdXzFbROc5F9DNWh4kwCtEWc8hbmecupTDaanctq0GNCTU82qX9G0937NOXN0xK1tWEA1O4vc4V7MM77iP0K3rdNHRs/4yvOvM93dOacjrX+WM6dfqRKqgS1d8dHFZWlzh8TzkdAkqmeBUsjofcXSx9iuV09Hn81FaWkooFKK+vp7Ozk6CwSCKohAMBhFFMSlkxSjGWV2Mdq5GOydlbW2tnmTd29trGj8YDNLY2MhOi3BmRXMpOvWeNLJixQomJyeZmFBvFowlP5Ik6f0y7Vxv2rk7evQogUCAqakpJEkikUjwp5N/Ivyx5H3WyqnTka2rznpN1LW345PNd2uiLKslxRZOVynxzPBJvPmAxwuA99JrkQJFqVc6XWzdqpbeGPsA3XMPbNmCiNvT0cXFxcXl3MRJEApeEUzrxlyIo8ppu0pMYSa2yALgmYidyHYmIMPMWPLxL6CbBj6DgIKAjI8RimijkwdSio9irkjXti7Gnxm3FR2lQomCqwqI7I1k1qNy1s2oO2YtwqSn2EPdL+vUa9ehmkWprUM8MYGQq5ZVC4GSJNERnNOQC+oCKE8mBwwtR79WJ2yDLs9AV6aLy7mIG0F6HnI29GbTBKOBgQHa2tro6LDps2NhsfYr1Xp1dXW87W1v04W+9vZ2IpEI0WiUVatW0dLSwoYNG0zrlJeXs3fvXn70ox8lJTXb9VW0imvG5GJRFJPG37Bhg17OnYpQKERzc3NSybUdx44dIxpVSyasc1y5ciW7du3i+eefZ2BgAEmS8Pl8NDY20tjYSHt7ux6AE41GSSQSxONxOjs7HcvHp6enbd8HVeytrKykubk5a1ed9VyevOACFIuArcyWDluRLQKl9fViEO3sYfL73yD3DY0IQfW8CHln2BPXrVtVN+iRI+rPLVuWe0YuLi4uLi5LStX22T7LWoabBIJHoPr+6pTraY6q0cdHiQ/EGX18lM7rO/UejFlv9zQgFUo0/qkRwbvMfaUhc9HxNB4fHZtb1bU8qIuOAAIyAgpreTDlUPKEzOhjo/aOTUH9vGp7FcHNwfTzMvRFdSrdFv3inGC+fbtavaIFFEoSCdHDoZzVlN24GuGCNeo6eStsN6elIb+hqIgyQeANRUU81dBAw99WJ39nlrFfqx1OjuIzyZXp4nKu4joez0POht5s2YqIsiwnCUPz3S/r8bH2adSSmq0imjZHawmqU3k0qP0YtXAWWZYRBEEtCW5qYnBwUC0LFkU6Ojp016dx/PLychRFobW1lfLycpqamjhw4IDJQShJEps2bdKXW4iAZg2M0UgkEoTDYURR1HtrLhZ1dXVZO+s01+X4+Ljp/Z73vIfSzk4UUUSUZRRRVG+S7rknaQxrsMtiB72c+J/fM/3QA5TccQVCaRkAYtl6xMLyRd2Oi4uLi4uLS3YYe09G90b1Mtv+e/tTOhhTOaqqtleldUJae15OD0+jxJbWApgYS7CvZR++Sh+xfksFiqi65WZGZk5LEnUmCH6BQEOAyZcmbYW7+ZQ+a0iFUlbl2wFe0UVHfX7IBHgl/cpOx1MBRZ67ZkYfHU1eRgBPiQfRL5r6omaUEm+pZolfVMdRb5DS1+UjXnoxgiiC4MVbc6Xj1LcWFtJaW0tnZycNtbVIkgRbOSP7tRrJ6Pi4uLgsCa7weB5yNvRmy1Yc7ejoMAmBRpdgttgdH2OZt+bms5szoIuDWqm4VfwyEovFksq6jx49SnNzM6FQyLZ03FiebhfuUltbaxozkUgwODiYdHyi0SgTExNZCZFa6bUdVjdnOrTyayvBYJCamhqGhoYyvj6tpflWsTcQCBAMBunz+Thx1100PfIIxQMDTKxfz8pvftPWxRcKhUy9NkOhUFb754SiKIT/4Xv4+3dR8N7rEAJqqb73wivwrmtYlG24uLi4uLi4LIzCrYVUba+a65knw+ijo4zuGqXmX2qo/IvKpHWcHFWRvRE6ruvQP9PckI1PNdqKj1rZZ9e2LkYfHzWPKaKWJNs52/JF21CX4BWqcy7yfMRW8EqMJRzdd+vuXUffp/qS+wYuE5WfqmTg6wMoieT5zLf0GQAJ1n91Pb1/kfkD9Cjr8TFiEh8VRKKsz3gMW2SI7o1SuLWQmn+tofeTvXNuUBEEUZgrnTaQcUr8bDVLZO+LnPzbL1D2zg2Ia1Sno5C7Av/lf4Yw2wIoG87Efq1GMj4+Li4ui44rPJ6HOPVVPJPIVhy1OiJFUdTFwmz7RaY7PnbuS6vQmS4RW8MpxKWnpyfpfbvt2jlD3/zmN9Pd3W1af2RkxLScKIrccsstfO9730s7RyN2peFWAoGAYw9J4/46Bchs2LDBdPxnZmZobW1lZGSE4uJitm3bhsdj/tVl7eUYDJpLUyYnJ/XwmqHqanbeeSegCrkrZ7dlvU7q69Ubp8UW6Id/+Ci+7p+T+54bEPIDIMt4G7ax77VhBl9oXfbAJxcXFxcXFxeV/h39uuioo0DvJ3oJbAokiYZOjip5SrYVJPvu6qP5Wed7TiehxLPCw/Rwcu2vPCEj5osocQVEyLkwB0/QQ+xIDP9qf9auxbyL8qj8eCWBugDd7+jOrN/gUiLC4PcH1XNic0tqV/oMImt5kG6+lnb4QF0gK9fjIW6niDZAREBGQURB4BB3ZLFT9mgu28q/qCSwKZCRkzCblPjp4ZMc/8znKP9gnS46imUX4qt7/aJX+ZwpZHN8XFxcFhdXeHRZMjQhp7e3F0VRaGpqylhMyVYcTeWQTBU64yRKphIr7bYVCoXYuXMn5eVqmeyBAweS5ujz+fD7/QQCAQRBIBQKOZZh2wl3dq5P61zGx8f5yU9+kiRaejweU/l1RUUFHR0dGQmJoVCIkZGRtAEw2r6nullJlZStbcsq8O3cuVN3a4bDYXbu3MmNN95oWsYqwE5OTppeW12dkiTR0NDA+sn1dG3rYqJ7gsSaBK9e/Sqnqk8taejSRNsBikr8qugI+C5/J519h8+YwCcXFxcXFxcXlYnuCUexzi6Qwk4oBGxdiADRzmjK7TsJJf339tuX4Bq3JcDUC1OqQ1JWE3yzZfKFSdqubCN2JEbuhblERmfvT09TmLSVArmbtcPOZdQLKn2eFYJFr0giwx0cp45OHrCUdt/BOLXqArPHfqFk4yTMdNmpg4fJKUwgzPZ+F8uq8G+6YUHzPBs4012ZLi7nKq7w6LJkdHR06KJae3u7nqq8WBjFQa2/oV15bqp+kVZR8ujRo7S0tKQUK1P1cDSKgFZKSkpYtWpVkoNOEAQGBwcZGxvTXXlG/H4/tbW1to477T0tqdrJaTgxMUFFRYUppTrT8B1RFJPKt634fD7e8pa30NbWlrK0PB2CICSJ01a3pvU1JAuwmpvSqZxbkiSqT1XT+fpOvReTEla4YM8FHL7rMKeqTyUdn/kkrVuJDRxH6H0Oz1vX6u+J+SsYHHzetJzW83Oh23NxcXFxcXGZP/l1+cQH7AU7u0AKO6FwZnSGyB77+zMlptC1rStl30irUDK2e4yZ0Qych9qzZU34mqdYqM1dEy6Dm4PEjsROS/9JI5mUUWdU+pxCDIzsiRC8Isj0yHTGguE4dfZuytn+mKJfxFPoITYQIxFJqGK0c6aivm5GwTLzREkkGPtZKwWXFsPsg3CpOLl1wOlmIYnwLi4uZzbuX7EuS0Y2ATGyLNPW1kZrayttbW16WIz1PSPG5GtN2GxpadH7IGpYnYLG19Y5hcPhpH6R2vuZ7qcTJ06cSErq1pydLS0tFBba/8NaXFxMfX09HR0dScdCWz+TpOqRkRFdnGxvb8/I7QjooleqHoclJSXs27ePtrY2W/E0U+zmVFxcbHpdVFTEnu/t4YnmJ3hq5VP8ccsfOfa7Y3oIkBFJS+yzof9ecwN4QVadmiWPlADJ1818ktaNRJ57gWMf/wil79mAeMklAIhFqxE8PttrdKHbc3FxcXFxcVkYVdur1H6KVkTnQApNKNxyZAv1O+uJHUldMZJN8vXY7jE6rutwFDKXlIT6v6mXp9j40EZWvG7FaU2XziRB+hC3oyCgzP6Jm1T6LIIUlOzPqQFBXIRkcVlNk9740EameqZIRBOqmJlJtbqAue/g7t2wbRusXq3+3L173tNKRCY5dMdnWVHyMt7Xb0Xw5wAiUtk6fZmx3WN0bevi6dVP07WtK+NU9oWw0ER4FxeXMxvX8eiyZGQSEKO5ujTHHphdg6nKTzMVNlP1i7TOEVT3oLWs2CiIWd2QgUDAdrtW0vVsdAp5CYfD/OQnP9EFPc2ZaUzattuPdNuPRqM0Nzc7ui19Ph91dXW66CmKIoFAwFZYDIfD8xIctbJ245xkWTb156yoqODEiRMkEgnKysqQXpSY/OIkEhKKrDBzYoacPTkcvuswnks9pv30+/3U1dVx8OBB0/zi8Tgnnj+BmDALlYIskDuYS3Nzc5LD1O56s3MlAkm9Ivfd9z1WdT1CyfuvRChWhU2xvBrfxtcB9tfozp07U27/rGL3bj09kbo62L5dbWzu4uLi4uKyxIztHqP/3n6i7VH2N+1Xe7pl6KIq3FpIzb/U0PsJQ+DIbLhHpoEU+XX5xMNxZwddAhRRoe+uPjxFHke319juMfa17Fu2MmeNmeEZOq/vpPob1WpZuV2zxQzINn06kzLqtKXPMmn7N0aejxC8LHUYT0bMpiUnJZ1ncLiCm4NzfQd374brrwdFgUQCBgfhiSfUZGqHeykn5+CpQ4MM/uVnKH1zBeJFzWqCtegjZ8vNCP48fd3O6+cqguKDcU4+cZKGJxuW1H1oPU4FCfX6yL2hH17X5N47uric5bjCo8uS0djYiKIo9Pb2UlNTY1sq7BTCkkmQip2w6VSe6lTi3djYyNGjR02ORrtyZaOTzjqPaDTqKMilwirEpuqNaB1bm+/AwIAuilrLikVRRBAEJEnC5/MljTE5OUlnZyeSJHHRRRexf/9+W8dhR0eHyW2nOQvHx8cdS7udsB4nj8csFEYiETo6OvTzZd12NBql8IfqTY/mUBRkAUVUKHmkhOOXHjdtLz8/n+bmZurr63nwwQdN25oKTZF3Mk8fBwAJSi4rob45ufeL3fVmV5IPZsF8/MFHqRt5lrxbX4eQH0CRZXwXbcWzZu7m2u4azTbZ/YxlHjfMLi4uLi7nJ4tdamkVUUafGOXkb7MTUbIJ97BD7/uI4ixiybMlzRK2Yo++HzOLXNo8u71sUWYUBn8wSMOTDfMKnZlP+nSmCdKOpc+ZIqsp5KC6I1MKlU5l24a05APvOZD1Mfa8tIfxsjvxj/QgSjN4EjKCMruhRAIkSX2ga3lIDc7C4aU/DjH57b+i7NZLEKvUYybkl+C/7CYEaU4SSBJKE6BIim1P08XEmAhvuj5iMjz+uHvv6OJyluMKjy5LhiiKNDY2IggCDQ0Ntv3pnFxcmsiSSnixc4ml6s1oRRMptaCXVGKacdt27sLCwkIuuugiBgcHUwpyPp8PQRAoLi5GlmVaW1tNpcxHjx61XS8Vvb29ttvTnISJRIKSkhJmOmcoeaQE34CPeGWcE289wanqUyQSCbq7u5PWj8fjtLW1JZUrR6NRbrvtNvbu3WsKxqmurkYURcLhMIqiIIqiHjij9d6sr683hcXYhc3s378fUM+vnchbNlBmFgtRxUffgBreYxxTm3tXV1fStk689QR5L+bN3TSKqrM1dnPM5LrUmK8rseSZveS8e7UeJtMxXcbWNc5P9DXq6+s5evSonuatpWyfdezYMSc6QtobZhcXFxeX85OlcFotRERZLBHU2vcxfizu3OPPYZ56urYDgldAKpSyT51eQPBJZE+Evrv6ENLVLdswn/TppUyQTkK7ZXESHUVU56Ld8ROh6I1Fujhtm3SeggK6qRubE2UV2aYyPJFQq0g0DJUlQmwtQflWxuU6fV8USeHwl3eyrllGWLVanWZJFb76NzL+9LjpOo/sjdgmsNv1NF1MjMfJen24944uLmc/rvDosqxYRbxgMMiGDRuSwmGsJdJg7xLLpq+k1W3Z3NxMRUVFkgPTmLSs9Z60ugsrKir0ubS1tTkGsWjiVzgctnUtBoNBJicnbQNRFsKpvae44L4LAFWk84x7yHsxTw9SSYV1LpOTk/zgBz/A6/XaLq8JucYwFE3k3bVrV1pnaCwW04+fncgbr4zjGfeYxEdFVEisSVBTU2MSQzXB2O46OFV9isN3HWbVb1fhPewlujLKiZYTnJo5hdQhJV1b2bgStffEU9Pk+2II+Wr5SuTUDDkVVSn3X6Orq8uU5t3V1XV2Jl13d8+JjhrWG2YXFxcXl/OepXBaGV1UOhmIKIstghoDYnaX7WZ6OF26iHmekb2pS369lV48eZ7shUeRBZVuz7fX5HzSp9OWUZ9OUgm2supy1RyxSUnnaUgWZVWN0yQ+SpLaugaSKkuChGlgj9k9mgB55ChiQa66LuCt3sz40+NJ17n2MN60j5JzT9PFwnicAonk68O9d3RxObtxhUeXZcXORWZ0mqVzK1rXy6Y81U6k3LZtm6nfJKiCkzYna+kvqC5GRVF0l1xjYyPd3d22bj4nnFyL6QiFQiiKknbd/P9RbxbsypMH7kzdG9JKIpEgkUgk9cHs6+tL6tNpLJlOlYpth3Y+kkrhN0XIO5CHgoKAgCKoom3x/y6mqalJTwk3itVOPTBPVZ9i6popBkYGTPuTaT/FVP1Dj+87SPX//A/lt1yMUF0DgJxfYttywGn/U70+a6irU8urjeKj8YbZxcXFxcWF+YuEqbB1m2UgoixluWlgc4DRx0YzchsmogmeXv00M2OpBcV4f5w45vvOtD0URZACaUqJl4hMy6atLLiMOhUp0q6zpfsd3az7u3UM/2qYie4JcjbkEB+IZ3Ss7UXZOfFRQQQZJm76DAFIqixJdo8mCFb+hgtvPob3+q0IkgSICDlB+ne8kHSd68dBK8M3lI0vJUZn8OTvL8QXM18f7r2ji8vZjSs8uiwrqfovpsKppNoqBNXV1fHrX/9aL1fdtm0bHo962duJlKIosmHDBpNIlioFG1QXY3t7O+FwmJaWFkRRtC35XblyZcp07HRIkoQsy6Y+jKIoMjaWPu3Ne8TrWJ5sxedT38tGOIXkPpSdnZ309PSQn5/PyMiI6TNJkpAkCUVRmJ62f+ovyzI7d+4kFAoRCoU4cOAAwgGB8ofKQQBBmd0fBfx3+9n8wc2O15PxupBlmUgkgiAIBAIB23OSaT9Fp+3VxLxU/OIhit5bj1CplrQI+SWUX3aT2sjbYX81MV2boxGtbP2sY/t2tS+PJM2VyggC3HPPcs/MxcXFxeUMYr4iYSqS3GYZiihLIYImzUmYmxNgW7qbGEvMSxjMtIei6BVJLENazWktm86URRIdQQ3gMQUS2TzjtxWGpTomxPX4pk8gGFJoFASmKUDBqy4r3EHkU34a6sYotKks0d2jwilKL/4Ra+/IQWraiuDxgAK+K25C8Hjtr3MZvKVeApsD8+ppuhB0Z/Du+2ZdnIJ77+jico7gCo8uZyVObjCrEPTrX//aVK66c+dObrzxRsC5h162Kdga4XCY1tZWPf3ZKBzV19fT1NSkC0uaCDk6OkpxcbEeVJKK+vp6BEEwiaLj4+MZCYRO5cnC+uS+PMbxgsHZVL8M3JjWYJpEIkEkErFdV3NNagQCAYLBoC5e5ufnm0rRGxsbKS4uRnxEFe100RE1WTK/I9/klDWKeMY+k7IspxR//X4/tbW1GbsS7Rj+70dItH6HojuuQigqBkCsuAjfpdemDBCajyt0oTg5hxeVrVvVZuDGVOt77oEtWxZ3Oy4uLi4uZzXzFQlTobuo7u3nZPtJVjStoOpL6UWUpRBBk+ZkCavp+2zfvEuXrWTUQ1FBDbxZRKdfppzOsum8S/OYPDiZfUm5ZjNcApyE4S6+jvDud8CPnjM4HAEUXuVDhLlJHUAGhFkHrk1liSJKRIovZvWG7xJ6XxXChg3qPaiUQ85V79YTrJ2u88DmwJIGyaTFvXd0cTnnOG+Fx/Fn9lF09fzFBRdn7EQfp8/nK3ZYBUCt96J1HKvTzvjaqYeek4tNcxsGg0G9LNcq+hlFrUAgwPT0NMXFxXq4jrEPpCaWhsNhKioqCIVCnDhxwnbcUChEU1OT/lorB8+0PFsLUlFERS+zBpi+LXWPIUVRUopl2ZLTl2MbcDM1NWVyTFrLuDs71f4z6wbWJTk3keFk+8m5l7OhPUbhMlNqa2uzduCarvf8Qoq++U0qPtKgi47ei67Gs/rStOOkK6UeGhrKal6ZkE0Y04LYutVtBu7i4uJiw9Gv/Bur//rjjm748wknQW6hTqvCrYXUttbS2dlJbUNtUmieES1QRu+paCg7nY8I6hRQY+z5qBE7EnMYJXsy6qGowMzITNaio1QokXdxnp78PF/D5JKWTRuYenlqfsLqEomO4CwMX3LRw8Qfj4PaTGj2M9XxWMrTc8IjzDlwH0quLBEEgfGrG1h50bAuOgqBlfg3v82UYL0UYr8TWYc1ufeOLi7nFOet8Bj7/lc53vteyj50U/qFXbLCKmYYw1nsPofsxY7GxkZT779wOExHR0fSOMXFxSYxsLi4WP/vbHvodXR0mIJLmpqaTCExVjQhzShqaiKVltysYeyPaIexz2RzczODg4NJywuCkOQ69Pl8xONxPUjFKPpN3TyF/yI/hJOXt+5DKuy2a0dOX07GATfWQBttfCfn5qnQKVpbW/US5UzmDaqzMhaLkUgkKCsrS5scbSeaG6/n4ZEeXpeTQMjxAyBV1OiiYzrBPZWbVvt8sTln+ki6uLi4nKUExH0c+uBfccG3v4yUl7Pc01l27AS5dCxW+rQ1UEYTHbWy02xF0LHdY3Rc16ELc/GBOKOPj1LzzRq9959xvtmmH6ci4x6KMlk7+/IuzqP52WbGdo/Rd1cf0c4oiqwg+kTkidNsncwAZUZJu39p+2EuMk7CsPDCfvxgKrNm9nVS8I7mwN1ar7sD5b1dRFnHId6P9OrTCE15uoHAf/lNSWaCpRL7rSxFYr2Li8vZxXkrPOb/2dXM/PbHHPniK1Tee+dso12XxcAqXlhFoMUQO4xCXKpxtm3bxs6dO009HjXKy8tNQk+6HnrW8YeGhgiFQvr+OfULNK4733LasbExfvOb3+ji0/j4eNIy1vJuUJ2TRvFx4M4Bs1AYVsVGv9+vr59tb0dFUZJSvrUSbVDFPUEQ8P6LmoKdScBNbm6urXjo5Nw89pZjnBpInc6t4fP5KCsrSyq7HhwcpLOz0zacxth70eqk1M6tNDVN7W+fpfjN66F0pfrZT6YofNMYhVsL0wru1j6UGlpo0kLKv53IJozJxcXFxWXx8VzeRGngAIdv/Qirvv0AvlVlyz2ls4rFFDSSAmVmnY7GstNsRM6+u/ps+0T2fqJXD+4wzjfb9ONUZNVDMUtnX6Q9Qte2LqJ7o2o696xAK0+feaIjkPZYZtoPczFJJwwnfSZKROX1zoEvW7cytv3Hs98FmdzCp7nw8ihS7ZXq595cXXS0u4brd9br7x94z4EFCfh2LGVYk4uLy9nBeSs8Cjm5+N90NZ69nRx6/2e54N++ihTIXe5pnRNYxYxAIJDy82zFDs05ZhXf7MbxeDx6T8eFYlfebXRA1tTUsGrVKgYHBxkbGzMJZ5qQZBUvfT4fdXV1KIpiGksru9ZEwGg0SjQa5ejRo47zy8/PR1GUJMHOGnRjdSfG43Hi8TiyLDsGvaTD6lDcsGGDyeHZ09ND6WulGQfcRKNRXdQ1iqnypTIn7jnByl0rUV5WmLlghpNvP8mpUGaiI6jl1Js3b6a1tTXps/379+vHamBggKNHjxKNRpnumKbkkRJyBnKorKzUS8Q1gXK46yBX/f4pKt9Zg1BTgyAITL0Kh/7Zj/yVThqebGDwZGrBfb5BSwshVT9TFxcXF5elRxBFpNqNlBUcYuhjf86Kv/l7gpsvWe5pnTUspqCRLlAmW5Ez2pmi+sJhvg1PNtB31zx6PWrP4me1qiXtoTiNOZX7DNUbMyWjfphp8FX5iA/E55yyqUPIbYVhdGFYSfpMEAX8/3IvRb8scnQmqt+FGQpW/ZIL3zuK99rrEPw5KNMyvobrAedruPob1fTd2bdkjsSlDGtycXE5OzhvhUcEL4JXRrqimdLCgxy57cOU/+sD5FxwlibHnkEYxQw7F+FCxQ6razAYDLJhw4asx7H2zEvXQ886b6u7cWhoiJaWFmRZ5sc//rHpM0EQmJmZ4fjx46b3S0pKdIHO6rTbuXNnVv0JnZyjNTU19Pb2pu0HOTFh/49/pqXUwWCQgoKCJKegdq4KKgtsy6TjlXHb3o8j/hE2btwImINhRlaNMPKhEZqamhAEgeM9xyHFrnm9Xl18LSkpoaGhAbAvbbbr2ZmqRLyiuYILxxXKn3uS4g80IYRWATD6tJfee9eiTIsw+wdFxY7M+pKeTpZD7HRxcXFxmUMsXQfDLyOuWUvJHfmM3/8F4u/8S0re/YblntpZwWIKGukCZZbMtZVA75dYuLUQT1H2f54JkoAybb5Xy6iH4nyDZc5isdFaVl3AgfT9MNMQ74/PlaxncGzshOEjhR9kPHoJJDB9FivdQMEv/5HAli3Uf9x5zInuYcou/g/WvL8Aqf4qBI+HmZMJer56Ec3Pq/exTtfwq196laC8j7Xy7HwS6zkk3k7/jhWL4khcyrAmFxeXs4PzVnjMufoWZtp+A5MjSJdeQmkwwPAnP0rh9q8QvHzjck/vrMYoZiQSCTo7Ox0/nw9Wga2goCDteHb99bJ1Xlrn3dbWZnIgaut3dHQkuQ5DoRA7d+5MErYikQitra1JPf80UWqhBAIBhoaGkoTDQCCgOx3TkanwGAgEGB8fZ3x8HEVRaGpqMp0rpzLpSH3EUdhrj7XT3NxMS0tLkkPRKqaKoojH40lKzC4tLbUNEWpsbKS7uzvtMSh5pESfm/ZTERWq/liFcuUxxv/1nyn94BW66Hj0wSCHv1+BegeK/gfQlY1XZtSX1MXFxcXl/MFfez3ykTKme59BKCml4NZrObXrOxw9+DKhL350UQPezkXmK2jYlZumC9rIVuQMNAQydi7OnJhhbPcYACd/fzKjdYwo0/NLp/YUe/Cu9DL1wlTW2zwbSS6rPsFstjfGb5qCkNwPMx1ZlqxbhWGP14MgJFAkhfFEHd3S1xAEgYZfNoCl5+LAtwZ49UuvMjMyg6fYQ9XfVlFY8p+seU8OUlO9WnnzMrzw+Q0EryjR1xP3PkNd4j/MvSwTdeSd6KBBsZSby20c2Pt/gYULj6czxMbFxeXM5LyN0BMkL/4r34VYvgEA8YILKL7jSib/+a858d9ugtZyIssybW1ttLa20tbWliTAWQXCTEq1NefdwMAAbW1tdHR00NjYSHNzM5WVlboQlQ319fWEQiF8Pp/e37GtrS3JCRkMBmlsbExK2Aa1pNg4J23fH3roIcd+kdmgjW8VQicnJzPu5ZjJHz2CIBAOh/Wk7fb29qRzpwXcTF4yycyKGSYvmeTw5w4T7FL7QRqFPZgT/Hp6evjNb37D2NhYyjnIskw8HtdFR5/PRzAYdOwxKooifr8/7b75Bny2JeIzPTMc2rWbvAoJCtQbwpE95Rz+YQjT7evsH0CZ9iXV9iXVd8DFxcXF5dzBu3YT/sYWkBWE/AA5b7uWQGwPhz7yBeSpxUs6Phep2l6l3qdordozEDS0ctPRx0f1wJfO6zsBaHiygaI3FuGr9FH0xiIanmrQy1nz6/Jt/3KaHp6ma1uXLhxqVN9XPTcvDae/vAS1J2Tn9Z0oMWcFq+y2suQxNeZxqyD6RS7+zsXZr3iWklxWPZccraHM/r9tP8ylQoLg5mDK609j4FsD9H6il5lhNZF8ZniGvk++hN87iBgqRRAE4scEuu+sIRHxzH0Xdu+m9sRfUsxe/AxTzF4a+AwFYjdVnuRycwGFtfxwUXZPC7FJt28uLi7nLuet4xHUGxN/7fXMFJYRf+lPCMUlBG+5llNPfJ+BnpdZ9aVPICxjGeT5SjYhHJpTMF1isF2gjdPy6cbS6Orq0sXBeDyu92C09rTU9smasG0lHA6bHHHp8Pl8lJSUmHpBZkq2QlZubi5TU+rT8EwdkJ2dnUnLnao+xdgXx6ipqaGjowNwFva03o+amGnE7hhbcXJ0GoXqmpoaU29N23Eck7QnqHj1ML4rS2FWwDy5Ng9FURBEQW9KLwgCa/56DW1tbbZ9SdMlZVu/A7Is69eJlhgvimLG162Li4uLy5mHVLIa39ZbiT/zMwSfD8/Vl1F64AUO3foxKr9zP77y4uWe4hnJfFJ505VMG0tLx3aP0bWti4nuCTyFHltxT4kpjD4+atsTL7g5qPd6DDQEqL6/mv037VdDWYzIak9Ix/srAVbftZojDxxZlNRrfbMxmQO3HEDMPzMTqRcb+zRpkl7HKdT7YS554rVBLC/ckj7V/dUvvZr0nie/h8IaD0LhCgAm+/NY8bpi83dhxw4QQFCMvSwFauV78CoRh3Lz5G3Nl/kk1ru4uJw7nNfCo4bngo0IgSLie3+tPml+6zV49nRw6EP/Hxd8awdSXs5yT/G8Il3qtV2pdltbW0qx0i4Yxmn5dMKn07w0rA67SCRCW1sbjY2NRCIR27RmUENfsnE51tXV0dzczI9+9KOshcdsSCQSuugIyeE02bwH6vERBIGKigoGBwcdhT1hvZCUlm0cQ0NL7U6Fsf9kfX09bW1teg/SpqYmUw9JjVAohCiKlH6mlFMfP6UW4sizcxOmWFv2I9a8cQVSfS2C5CE2I/Ps5Kt471L7VQaOBRCrRaLvjPKn0T8RfiFsmo/Wl9Tuekv1HTAK3lqpf3Nzc8bXrYuLi4vLmYmUV0jOdXcQe/Z/IDaOtKmOlQX9DH34wxR9+R8I1Ncs9xTPSLIVNDItmU4K4hhIca9hES+t6yJBtC0KipqSPfr4aFJ5uDaOFcEv0PC7Bvo+a5OSvUBmRmbO6n6N2WKfJm11PIpEuAg4PYnXRW8sUl2JCrrI7V+tPtCOHYmZE6Z37+aS4bt0EbSf9zFTMsqF7+4mb9vrEQJBUBTK/vxa8q4toP/eOUG+bm8Xomy+gAQUvIwhKDbHQZQQN7tCoYuLy+LgCo+zSEWr8F/9XmLP/BTBC54tl1G64kUO3/rnrPr2A/hWlS73FM8b5pN6nU6stAbe9PT0OC6faiyjqyxb1+ALL7zAxo0bk3oTSpJEXl6eoyAJ6I42DUEQOHr0KPX1S3NDEAqFGBkZIRZbmhKvoaEhJEm9y7br/SgIAsFPBG1FRyt+v5+6ujrC4TCKoujHyiriOrkJtR6SqRyDYxeP0X9vPyfbTyKHhlhb/mPK31WDcOGFCIJALCGyZ6aChDJIovoUA3cOmEVTi55s7Etqd72l+g44XZ/pvgMuLi4uLmc+gseHf8t7iO97HPnEIcSqKkruyGP8K58j/t7PUHzT9cs9xbOeTPtCJjkj02EQL1O5Kqu2V6nCo4VAQ0ANmbFsTwpKoKRJyc4WD6rgeB6JjmCXJq0mwigICCgoiCh6uvRsaXaSSzC7xOtUBK8I2grVRpFbS5hu/sYpAne+jWJkBGQ8nKR0jcKK2y/Fu/U6BL8fJZ5gJu964gcLktKrRxMXUCweQ0gSH80/AZAktYXBPffob1n7ol7whQvAzYZxcXHJEFd4NCDmBsm59nZiz/0Cpk4i1W6krOAQQx/7CEV/+zUCTRct9xTPC+aTep1OrDS6JNva2pJEPmP6tnWswcFB/vu//5tgUO1FaHXFaaXH6UqeY7EY7e3t5Oeb/5VOJBJpE6e9Xq9JBNTckY888gh5eXlp17didRIGAgFkWWZmZkZ//9JLL9XLoRdCfn4+giAQjUb19GrNDXji6hN678dVv12FeEhEXitz8u0nGUkk98R0wurs00TEnp4evVRbCwOy9trcv38/QEoRt3BrIfWP1nPy8T1Mfvu/WPGuzQjl6jV2bEpkP+XIFoNnKtHUWGJtV36d6jtQUVFhG2o0H8H+TMItFXdxcXFREUQRf8ObmX61nemXn0coXUnBe69laue/EO55hYrPfcgNnVkAmQZd2DojU2EQL1O5KqP7orbjVnyggmhbVA3fMwiCMyMzag/KxTrlEnhWeNQegQtkMcqQl7yU2YBdmvQwWyjlacP272BcrCV4WZAVL72GMGYV6rJLvNaw3c/n6njS96R6vp2utVnRWv7S34GiOi+nRR9HNl5J2QdqEetqESSJ6RMJXvir9cSOHiPQPJkkfB8Sb6dYaQNJglQP9kUR3vhGVXTcsgWwcf8Oxhl9YpTcb+dCQ9aHwsXF5TzEFR4tCB4f/qveTbz7d8jHX0Fcs5aSO/IZ/4e7id38l5S86w3LPcVzHlEUdWea1osxnQiRjViZzgmmraslHicSCaLRqK0jURRFWlpaAHO5dyomJuzTD0EtG/b7/UlColN/yOPHj5OXl5d2m9ZyZE1k6+3tBaC6upre3l59GW1boVDItF1BENTy49JSQqEQXV1dafs9njp1irKyMtZPrmfqvin1mbKskBhJsOa5NQxvH2a6cZoV71kBkLbnopVYLMbevXtpamrSrxFNaB4cHDQdS7tjGIvFdFFS+9xaqqwoCse+9RDi3p+y4vZrEAoKURSFfcMJ9o170CyNqZyioVBIv4YURaG9vd20r8by61TJ7/X19YTDYQRB0Hs8wvwE+zMJt1TcxcXFxYx3XRNCoITpzp0IgSC5b78Wz+4/cPjjr7L6G19C9HuXe4pnJZn0hRzbPYYcy8IOaBEvnVyV/tV+ej/Rm7y+AsO/GqbhyQa639FtFgVlUAQFKV8iMZaNEmpBVOcQbFIfpEdGk92V2bAYZcino5TZijVNGiDMTeaFZIg8F+GksoZijllKs8XME68FEHwC5Rf2cdGLnwZFRgB8s+EuHcrXGZ/OYD8T4B/pATnBhCfIiS1XsvL2JoR16xAEgcmD8MLdG0hEJZAU1R1rObfjch37S/8vdZt/Cd3dEIvByAjI5n2LFF+Jsv3Hpu+DnYMXCeLfizNWM8bhvz9sSog39jldUnbvVntXdndDXR1s3w5bt56ebbu4uGSFKzzaIAgi/k1vYLq/i+m+ZxFKSil477Wc2vUdjh58hdAX/tx90rzEZCtCGIWadM4pqzMMVAFOE660sTQnXCqM5c9G4ceu1DcT/H4/BQUFJrEsGAyybds2Ojs7bUW5yclJ02u78JfS0lLKy8s5cOAAiUSCo0ePEgqF9O3YORtHRkbw+Xym9xRFIZFIMDQ0hCiKGYXMJBIJBgcHyfu3PDyCx3zTIkLuz3IZuXOE9vZ23VWaikAgYAqOicfjtLe3Ew6HEUXRdM7tzrWG9ThZnZDaeWx/fi/yAz9kw5pRfO+6FiEnFzmR4A9DcHjK/CtUFEU2btyYdJ6CwSChUEh/325fjeXXqRBFkVWrVtHQ0KCXq2vvn81CnVsq7uLi4pKMp2wtwpZbiD/zMILfj/e6Kyju3s+hWz/G6u/ej7d0xXJP8awkVV9I3d1lLWWwQSqUkAIS+XX5lN5UqvfU03r0IWFyVToiQ3RvlMKthYh+mwftCRC8wtx4+gSg5v/W8Oo9r6Z3MArANGo5N2jxzfMmOSE6+zLkxRhjyVDsSrPNpdjpaPxToyrgXXk3KIaWSYCCzIV8iw7+Nf1AEsSKNjB5ysepNzZSevMVCCvVaq2Z3/aw/x9aUBKz11cC9S98m2tF3nwV7Py4+nr3brj+erXMXE7o+9Y3chuR6ztNQUlODt7Eiwn23bBPvZYSc2Xh1pClJWF2/iiK6uAcHIQnnoAnn3TFRxeXMxC3ji0F3qp6/I0tICtq6MzbriFw6mle+8gXkaeWpvfdYqAFp7S2ttLW1pZ1L8IzgYWIEJpoOTAwQFtbW5Ko1tjYSCgUMr0XiUSSlisuTp8gabyJ1JyaFRUViKJIKBRKEu7SkZ+fn1R6GwgE2LVrl62QmUgkkkp67cTAUCikBrnMOjgHBwfTCqvp9v/YsWMpP0/iFZJvWmT09OpMEQTBtqQ9HA4nnfPGxkaam5uprKxMKj02ltdD8v5WVFTQ/senEbbfxyUN0/hu2IKQk8vM9AytAyKHpySsOJU3BwIBhoaGUu7X2VYavdhY9/98Px4uLi4uGlJ+ETnX3YHgy0eQJMT6Tax860rCH/wwEweyL/l0SY3u7kp3+yzApkc2seXIFqq2V9H3qT5GHx8lPhDXxb3g5iC+Sh9Fbyyi+pvVKfs0Tg9P03ZlmypaJt9ikHthLo1PNVL0liJ1zLcUUfN/axj+5TCCVoedyhdhfPCbADF3YX8G2idEZ16GXEA3K+hY0BhLjVaaPcJmYpQywmY6+bqeeJ0W7Za8szPpIwEI0JfRMIIAY295M4lbr6TwjusQVpajKAqe7/4PvV+tQkkIhPglW3gH13EDWxLvYJXyq7nryK6dwNat8OSTRIqvMO+bXIuiqP1INfLr8pOvSe31rOgI6k/rukvGjh1zoiOoPxVFfd/FxeWMw3U8pkEqWY1vy63En/0Zgs+P5+orKNn/Aq/d9jEqv/MA3pVFyz3FJM6FksWF9KvLJBW7paWFhx56yOQstC63bds2du7cycjICF6v17bHo6Io/OhHPwJU0XBiYsI0prVUOZu5B4NBAoFAxutbHXyBQEAXRhVFSRK+pqenHcfy+Xxs27aNjo4Oxz6P6YJfkhKp1wNdmMVHEeKVcyJiLBbT+2ZqvRmtpCpV19COo7Fs3xooFAqFqKys1AOHFEXRS6FlWebg755m82O/pfKd1Qg1NWopS0zmcFkTJ1/bp48TCAQoKCjQy5537tyZNB8txdt4TdfMjpltabQsy3pZuLbNc6EX4tleKu7i4uKylAheP/6ttxHvfBR59AjC+vWUvi+fsb/5NPGPfJ6it2xZ7imeM2Ta29FT4tHLUZ1KUT1FHpqfbZ5zUc6kthlG9kRUQcdG9NTETM2pmZScLdqv54Q8sTBjgn1CdGZlyHMl1skHOqtS5tOAXWm2kVQ9Kjuu6UDwCVwTl9O6fZzGEfwyq9/5JAWVr+K99joEfw7Ep/H9+jlGV/8F40ohIX7JBr4OqIKmZ+YkNTxA7qW5HB5rMbcTsJQnH+IOTnCxeTKWlHe7vqi6yJ1BQvyS0N2d3KsykVDfd3FxOeNwhccMkPILybnuDmLPPgyxCFJ9HWWFrzL44Q9T/JV/IL+uermnaOJcKFlciAiRTrTUSrHt1jPi8Xi48cYbbde1K6e2E8lGRkYIhUIMDw+nFPrsKCgoyGr58vLypHOtzcmuRNuuJNvIT3/606QgHCtJ4qKBuro6hoaGGBkZobi4mKb7m+h+Q3dSM3feP7dOPB4nHA7T3NxMKBSy7ZlpdfBqrlKjC9LoZjQK8Ub6+vq45ZZbEEWRvXv36tdEeV8ftb/8PTnVpRR94HKEUCUAAyfjjK+9goamZhKiN6tSfmMvxoWGp3R1denXnRYys5gPFpYr5OVsLxV3cXFxWWoEUcTXuI2Zl/cy3d+OsLKcwvddw+TD9zF48BXK73yf2wpoEbDtz2hFUt2MGqnCZMAgTGaC03YVdRxNeOzf0a+Wg2u3Rae5wGkhZchzJdZmFMiqlHm5SdujUgElphChmgJeNO2vAkSpTjlOh/AP5NfvY2V9DlLDVQgeDygCvmtuQ9r2SY5u6wJxlHXyfwDJCdUXHPsOFxz/8txGbcqTa+XH6RAfYFw29Jq0pLzb9UVd88U17L97P4nnEmkT4peEujq1vNr4d4gkqe+7uLiccbjCY4YIHh/+LbcQ3/c48olDiFXrKHlfPuP33kXsjrsovvHa5Z6iztmQbptO3FiICOEkWlqTjjWMoR7ZYBc2YyUWixEOh2lsbGRwcJDBwcGMbzw1cTNTNKegJkqlm19eXp6je1DroZguLTuV6/HFF1+ktraWbdu20dXVxTODz1D67VL8P/EzsneEU6tOodyhoFyqwFHzuj09Pdx8883IskxnZ6ftMfP7/dTW1jIwMJAkuCqKQltbG4ODg0ml6xqRSIT29nY2b96sh+yU9/Xxtvvu55VLX8eKt16ki46DR6KMbbyWxtk+oKmuzcbGRhRF0cesqalJGxiTDakeLCyGaHguOKZdXFxczlUEQcBbfRlCsITpfY8hFBSS92fXMf2Hxzj8qVdYff8XEH1u6MxCSHJ3aU5C7adN2apTmEzKlOtskc1OssjeyGkXG43YJUQf4o6MypDtyrQBZLx0cX/mpcyLwEJStTPtUfkyf0EDnwbk2f6OqrPzZT5hGEdGmK3N1sYrLf4hhZetQ2q4XBUdpyHnO79B+ODfQl0d4t6bQL4YLxH7KntL/3Lb8mRRYq38IN3S11KmvFv7oiYSCXwf9jH1/FRSL1PrukvC9u1qT0ctpVuS1Jr0e+5Z+m27uLhkjSs8ZoEgivgb3sz0K+1Mv/I8QtlKCt53LZOt3yB88FUq7nr/GfGk+UwpWdREkN7eXhRF0cNbZFmmtbXVMUF4oTgJPE7ON7tQDzsBBzDNOxVWJ+CxY8e48cYb+fWvf51x6bRxfUmSyMvLSykE9vX12fY+dGJiYoL8/Hymp6ezWi9TtLTogwcP6iLoAAMEPhAg+q45UTQwHkhaNxKJ8P3vfx+Px+Mo1BYXF1NfX0+nTd+c3t7ejITh3t5eNm/erL9ueuQRZEFEyhNgNi1c2NfDuscOsG7nZ9OOB+r1t3nzZn3cxXYQVlRU6E5H7bXGYoiGVmGzp6fnnCnndnFxcTlX8JSvR7jqPcSffRjBn4P39VdS1NnNa+/7JKu/8094irKrmjgbGds9Zk6mXqQ0XTt3V+lNpQz/ctgxBbtqexWjj48mjZUy5XoeTA9P07Wti6rtVSjTC0yHWQTSlSE74VSmfZLGJRMd7QRGYEGp2pn2uVRF2q87irRBDuqi49w4kMjxIwZyVNERyPmzOxGmZ5LcitNyEC9jyeKjtV+7TXmyICcoKj1M0eYix+vbCU+Dh02/3WROtc5w3QUz26PSlGp9zz2wxb7txFL9vnBxcckMV3icB971TeqT5s6dCIEgeW+/jundv+XwJ15m9dfvQfQv75PmM6VksaOjw5TiKwgCzc3NdHR0JIlvCykHz1TYcdqGnSPUTsABMhINQ6GQKcFYm2NraysnTpxIu75d+XIikSAQCKQUHtO5E+3IpF9iqnLqTLAKgNbXExMTVFRUMDQ0ZBIZZVlOKYiGw2F27txpOze79VKVltfU1NDe3k7RwFHCq+oovaECoVy9LsRDYdt+Mdbrrr6+nq6uLr1nJMDQ0JCpJH+hIrssy8iyrKdZr1y5kvr6uafPC26zsHs3V3/5y3hefJGRykra3/pWhqqr6ejoOCN+p7i4uLi4zCEFism59g5OPfMzBCaRmhooK3yZgds/TNnX7yev5oLlnuKSYe1vuNhpunap15Ufr8x+oNnbjiQX5TxRYgqjj4+qIudCHZTLyELTorPFqZQ5woYFpWpn0+cylUgrMIOCORtoJH8V+VtK8TReqr5xKjYnOsLsT5G1yoO8yofYwNf1MfSxduwwCW61sbUExUEE2VyeLG6uV6/33bthx+fhPbNC3vbtaROiC7cWUrwzfSDnkrB1K9j0Vrey1L8vXFxc0uMKj/PEU7YWYcstxJ95GMHvx3vdVRTt289rt32cyu/ch7d0xXJPcdlxEkHsxJCFlIOncnlZezIasSux1pa3Jj5nIuBYx9OCQ6y9INPhJPSdOHGCxsZGXnjhBWKxpU1VFwQBURRtU7ON+P1+Nm7ciCzLvPDCCyQSCXJycjISNDUURWFwcHBeAueIpYREEAQaGhps3Z92omNNTQ0ATU1NEJlicH0z5bfWINXXIkgeGBnD89PHYVNqB+3AwIAe+KK9dmIhIntHR4fJ4RkOh+nq6tKv9wW1WZjt+1OgKAiJBLnj41S++CK/vusuBivn8ceWi4uLi8uSI/hyyLnmNuLtjyCPhRGqqyl7bz4n7/4k8U9uZ8UNly/3FJcEuzAXRVJMPRBP93yc3q/fWW9yUY4+NrqwEumzWHDUmG+Z9nzLop1KogP0zS9V2wtMOwuow2yljrszmmcB3XiY0EVHBRgsuQjfu+sIbrsSIRBEkWV8//qTZLciMkEOApAQAoicAhIIJSWq6Fh7q0lw6xNvpUHeA6Kkio/G8uTdu+G66+a2MTAAjz8OTz2VVnw80znTfl+4uJyPuMLjApDyi8i57nZizzwMTCA1bKKs8BXCH/wIpf/wj+Rdum65p7isOIkg1veNwRvzIZXLy1peHQqFEEXR0RnpVI6tzd1JUNJcjoODg3R0dNDY2KiLQa2trVntj5PLTwteKS4uzkrInA+KotiKgFZx0OfzIQgCgiDo885GdMyEVE5F67FobGxk8+bNCIJgG6gDqkBcUFCgXwOyLNP+i0dZ8W//RuijjQgXXqi2TOh7Dd/d30CcmLLtFzNfd2EqMVCWZdrb2039IbUWBU7bML63oDYLs31/hNnzK8oysijS9MgjHLvllszHWQKWK/DGxcXF5WxAECV8zW9juudZZg7vQ6gIseL2q5n4r69xrOc9rPyL5f0dvhSkC3M5E+ejuSi7tnUlOxazTKReShbS8zAbsi3TThvk4rDOWh6kmL22AiNIKLOioUZGqdrTc/tgFVCH2UoN30ia54tV/8rxQxuwVFSzlgf1/5YRObK2icL3bcS7tRnB74dYDN//+Tc8rw7N9TPU5yrgZUzdP0WeFRIl+MUvYOtW+rd1mQS3cbmOTvEBqot/TIH/kLk8+cor7VOi77oLnn029fE4wznTfl+4uJyPuMLjAhG8Ofivvo14x07kkwMI6y+k9H35nPzS/yb2kc9T9Bb7PhPnA8aQDS1gQ3sfFp7uq5HK5WUVakRRpKWlxXEs6/JagIk2Z6OrDVThrbZWfTqrCV2a+00TOMvLy5MES0mSkCQp696K1nLk001paSmiKHLs2DESiQSRSIS2tja99Hch2DklA4EANTU1phRyTTyWZdkxOKapqQlQezjGYjHTcd6wYYOpbLjt2/9NaNePKPrAZXp5daz9Jbz/8J9EL62l8J/+ybZfjPW6S3VerIK3E8b2BGBuUWC3Te09jQW1WbDp+yPKMuXHjlG5TH1iNdzAGxcXF5fUCIKA76KrEAvKiO9/AqFwBfnvupb4k7/i8GdfofJrf4XoPXdu+9OFuZxu/Kv9xAcs93Si/XySyq5nAzl8a3zE+pMrWqRCiUQ0cVqcjvMR904XmQa5aFj3xVrKrAqM1QTpYSEl31YBtY67bedZ0f89jtvMU+0TCdOijyMbr6TsA7WIdbUIkgQnTuL97P1IA8Mcqvor1gz/o2muqlotzAmnWsjKjh2Mbf8xJ39/Mum6GZfr2O9vZssRy72tTc/0lO/bMLZ7jGN3/ZzSzm+Tz6sIDXV47/vbZXdMnmm/L1xczkfOnTuQZUQQRXxNb2Xm5eeZ7u9AWFnBivddw+TD9zHY20/5X952RoTOnG5EUaSxsVEvf9XExcXuQWkUOGOxGD09PXqYTbalp9bli4uLTcJoS0uL3qNSURREUTQlSWsYS26bmpoIhUKmZYwlzF6vl+np6aR5TExMJPVtTCVuSZJEbm4ugUCAEydOJI2ZDrt5WBkZGbFdZiE9IDUKCwu56KKLktx+oF4z2jEXBIGxsTHb8JjBwUE9zbqiooKbb76Zzs7OpIRpUI/lsW89xJq9PyP//dciFBSiKAr7hhN0r7iYpkd3qcs6iOLaOPv37zeVvmvl56AKxUaxsb29nYceegiA/Px8RFHUHb+iKGbkaJRlmQMHDuD3+6mpqaG+vt60z/MW8uvqYHDQLD5KEr7mZsdjcLpYcO9KFxcXl/MET6gaIVBIfM/PEXJy8b1hKyvau3jt9jtZ/Z1/wFOYHOh2NuIk3p2WNF0LY7vHiDxv02dbhlOvneLp1U+rATVvL2X4V2pATaBZPQ+xIzE9vOaVz9uX93qKPMgT8oL7Q2ZCtuLe6STTIBeN5H3B0ANRFRjVVGllXsnc85qnNgnm3JgexpjwBDmx5UpW3t6IsG69+nfjwUMId/8nY9G1HGI74/21nGCVaa5BDuJjzDyBRAJ5b5daYj2jmLalrTdZ+AbYdu9cKMv27c47JMuwbZt5WRshcWz3GK9c90PqE5+eE3v3/B7luicRlrlc+0z6feHicr7iCo+LhCAIeKsvRwiWMr3vMYSCQvLecR3Tf9zJ4Tv7WH3fFxB9yxs6c66iiX+aSBePx3WnWLalp42NjSZXYzgcNgVraKJpW1ubyYEVCoUcxxwaGtIFy8HBQcbHx02CYk5OjknMCwQCtqJjOhKJBNFoNKM0ZzuRURAEfD6fyR2oOQs1ZmZmsppTKgKBgGmuoVCI5uZmU8o0oG8/EomkPSaKojj2XYS53pXy9AxHPvc1CnJexPeu6xBycpETCf4wBIenPEiSpJ/zmZkZdu7cycjICMXFxWzbtg2Px2MS0I3l+bW1tbbCeltbm8nNqO2LllCtiYpWrI5GrfS6oaEBSZKSrkWYpxtw+3Z44om5Mh5j359lZkG9K11cXFzOM6RgGTnX3D4bOnMK6bImygp7GHjfh1n5z/eTe+HZ37fXLnl6MdN07RJwAdtU3P4d/Y5l0lMvTAEQD8cZfXRUL6mOD8bVB/NPNgCYRCIrsf4YNf9ao4uW08PTKLGFV78ErwjiKfIw+ttRvXQ4W3HvdJJNkAs47Yu6zgibTQLjfEVVu7L0U5ThY9jGXbmeAkVdPshBvIwBAifzyjn15mZKb74CYaUaTig8sYcX/rGR8cQPTduzc1falZFPTZfoZoVkF+sJil94Dl4SVVFxcFC9/9uwAV54IXknp6fVXo+zSdo88YSaJn3llabF+nf0sybxwyThWkmIajsfuxCY3bvNqdQZhNnMh6X+feHi4pIeV3hcZDzl6xGuvJn4nv9ByMnB+7qrKOrcx2vv/UtWf/cf8RQVLPcUz0mcnGLzcVdahbt0LjSYE4TsSnsrKiqSRCq7PpJO219MBEGgoqKCN7/5zTz88MMmIc84Z809qSiKqfzZ6/VmXR7uhBbGox2zgwcP6k5Vo2PPqe+mFa2cWSOnLwfpmxLrjqwjXhnnxFtP0O3rZmPVhQz+xRcoaVKQGrcgeDzEY9PsGvJwclq9TVy5ciWgip4/+clP9HOiJWnfeOON+nYyFbdTufS03qB2ZfzpxPLY737Hth/8gOKBAUYqKzn8gQ/AfITHrVvVG0njDaDW92eZWVDvShcXF5fzEMGfR8417yXW9huIHEO46CLKggFG7voEgc/8DYXXNS33FBeMXfL0YmCXgGsNhImH51JxnfrEmUQpebZXojxbrpwABYW+u/rwFHnSttEZ/tWwvq9d27oY3TWa1CswW6rvr6ZwSyFPr35aLxPPRNw7XT0grWSbhO0kAI6w2STezXd/7MrSi9mLYjkx2qthtpiWl4FjxdV43llH4Vuv1CtvEv/+R3ofujIj1+Uh4XaKlb1JZeR5Yy9QQDfj1Nk4P2dnJFvKs4NBUw/Jub0Q9f7fxlJufvMb01wmuicchWu6u5MnPxtqiKKYRc1vfAN+9aslFyMX+v1xcXHJDld4XAKkYAk512pPmqeQmhspK+xj4I4PU/bA/eTVXLDcUzznSNf7LlM6OjqSXHV241i3l0gk2L9/v0mU04Q1aylsfb1646iVDi+l0GhFURTC4TAPP/xwypvcvLw803HQRDBr2rcTgUCAeDyOz+fTnY0TExNJ20zlVNVCViYnJzPapvE45vTlcMF96vdMkAU84x7yXsxj6CMvcPi/PsSqd16IUFOjbn8izqPHfciSD79f0F2NoF4P1vNjTNJOF3qSKlXdyPj4eFK/yrKysiT3pzam5uSsHhriqi98QS37l2Vyx8dZ/YUvqGJhips047zKy9Wn63pZeGvrGRfcstjtGVxcXFzOBwTJg/+ym5h+aTeJoy8grKqk6I48ov/vXo73vZ+yD//Zck/xjMQuATcJWRUO+3f0q/3jLP0dM+2VGNkTwVvqTVtCbRQ3S99eqronF0DepXm68GLsf5dO3FvOHpDZJGEX0E3BbNqzhoJ6zjxEuIqbZ4NgtlDDN7Pbn1nXql1ZuiYAWhtsjXMRpTxtEB0FjlzQSOF7N+K9djOCPwficXx/+2+M7cljnI9kdEwmSxpJrGzC88LepM+08ng7MTCJRILY8y/z2mX/zgWRHyC8sD9lKTe//z3imjVUr10LX/0qXHst+XX5RAfshWuhzuZYzoYaYhQ1RRE++Un1p0GMjH7jN7z8q4okt3Gm2D1M0B4cZDOOi4vL/HGFxyVC8OWSc817ibe1Io8PItTUUHZbgJOf/yTHVzaB5CHY8nqKty2/m+hcwNjnEcy9/NJhFGGs4o/P59OFQuv2QHVgJRIJRzfb4OCgqdzXGDyjiYCpsKZIp0p4zgaruGote7YSj6slQSUlJWnn7PV69bHi8bj+PyvRaNT2uLW1tfHSSy+lTce2loUb96l0ZykCgu5OEGQBKfdVrh54lOIPNCOEVgEwcDLOkyM+ZAWaG+p0cUuWZdra2myF1uLiYv2/04WepHJraj0enUrInYTzrq4u/RzUf+MbMCs6ghoGo2hPou1KWlLMW/tvRVFsBU8XFxcXl7MPQRDwXXI1MwWlxF94EmFFEYGbryP+u5/S/74nEVaU4l27hopP3YqY61/u6Z4R2Cbg2iGry258aGNSSnU2vRKnx6ZNvf+SsIRgDP9qeMEp2JMvTdJ5fScNTzZQtb1KnT/pxb3l7gGZaRK2lhRtFQAFFAo4aHAoPocazqLMfp5mfwT04+5Uym23Sg7HgeMIyMyIXo5cciUl79+IVF+H4PHAyXF8n70f6bUwQTIXwmaGZ0gM9yf9Qa+Xx0sQTSSLgVYURKLyegb2VjEg/41+fTmVchOLIRw9SsHgINxwAzz5JFXba3nl8TsoSpiFaySHtj02oYYmF+bsTwXI/cSNrKaRQ9zO6GBd1qKh3cMERVIfHCyFa9rFxSUZV3hcQgRRwrf5RqZ7nmHmcDdCRYgV77sa+ZV+UBRiP/8nBva8nlVf+gTCGeYwOluwOs5uueWWrN1aqcSheDxOV1dXktvK6MD60Y9+ZLuuk6CUTrjTCIVChEIhU1/ApUq0DgaDBINBBEEgFAqhKIppu6AKgvn5+ZSXlzM6OorP52NycjLJyWftHelUmh2JRBz3J53oCKojsKKiwrZvpveI13RD7i/cy4U37Sbw9qsRVhQBsH94hsG8NYRWSZSXl6MoCq2trVRUVNjuP6gCreaGhPShJ6nKq1esWAGYBdNgMEhBQUHGJdvFAwMIluMvJBL2JS0Zzqu3t9cVHl1cXFzOMTyVFyMEiok/9wuE3Dx8b9pKWV8fylQYeayXQ7f+nsrv3I+vvDj9YOc4tgm4KZYt3FpI41ON9N3VR7RTffAaTLyKMJNhr8Q0WYDWEIyJ7okFiY6AybGp9a/USCXunck9II0493eEZIeipRrHYX8K6GatMifIqqXcVnff3Lbm3psrVU944hy/4nLK7mhEuPBCNUTmlcPkfO4BhPEJFMDLGCF+SZib5gYRIXhZkMmXJkmMmS9MtTz+hHk/RBHxsnqKiooYeOaDFI+1qc5DZBRRVO8dRbXHo8nVqg09O5TVAWtFkGUUQYAdOyjcuZP1T93By3cFzKnW9/+dfdseu1BDGwRAYppi9qpu1MQDjEt1WYmGtg8TEji2SXBxcVl8XOFxiREEAd9FWxALyojv/y1C4QqkxgYAcuviePd0cOhD/x8XfGsHUl7O8k72LCSd4ywTrCKM1WVoJ9IYBU9jorHGYjkTGxoaEASBnp6erMNmjFjdgXasWrVKDyyRZZlwOJwkkk5MTCAIAnV1dRn1XUxHNBrNaG52VFRUOPbNjFfG8Yx7EGSFQKiV6tsG8b3uOoTcPJREgj8dg/5JD5UBiYqKCtPxHRgYIBgMmrbl9/v1fotGYTtd6IldCwDrssbPN2zYkPb6raio0ANpRioryRsfN4uPkqTezFnItOzbxcXFxeXcRCpcSc617+PU0z9F8IJwySXq+8DKdf0MffjDFH35HwjU1yzvRJeZpARcJwR0QbBwayHNzxr+/d7WjPLY4wjy3ACpglAcN+EXaPhdgykEw0kY9ZR6yL0wV03YzuSf+VnHZv+O/oznk23Ay3JhJ8ZZ+yCCOel6brnk/bErMVcMy+vuPozio0XUyx2i4g0llN1yBUKFGkop/GEvvq/8P4SZhGk+G/g6E6xXy70lKHpjEVXbq+i8oTNpXyeoopjnzPshy3ivbqDqz6rovP4kHeIDrJXn+o3m3nUreQceI/bY3tn+o/Yl60YHbNDfr5ZdW/7uMT7wLmQ/hUUPQekRqGtS+zM69Qq3CzXUyq1t7lNNbtTE17ISDW2/MxYnsYuLy9Li2uxOE55QDf4r34WQuwI8OaCA4PXh2XIZpU3THL7tz4kfHV7uaZ51ZOMwc8IqFmnBIk6fw5zgOTAwYCuaLUaPvHA4rLstCwoWFkrk92dXPiWKIi0tLbYiWDQazbjXo5FgMGib/u0kOmop20ZCoRCVlZU0NzebHIGNjY2msU+89QQIMUo2/JCLPhnB96YtCLl5zJya4ZEBkf5JCZgrqbaKulYxWUuqtp7XxsZGmpubbecEUF9fTygUwu/3EwqFaGxsNC2bbn07tDFXrVrFxGc+o96gSer+pEqiNl6z4XBYP5bW67um5vz+g9PFxcXlXEbw55Nz7e1IZevU+1HRC4BYVUXJHZuJfuVzjPziyeWd5GlibPcYXdu6eHr103Rt62Jst9rLTkvALXpjEb5KH8Ergqo6a7m1q/lWjXMq7vbtCKKg//ucLgjFiUBDgP57+01zrNpepTrlLPNZd+86qu+rVrebIfl1+ZmXlqM64BQEg8g2v/1aaobZAoaYF+tP9NfC7M/k/ZEKJX05uxJzAZjgAqYJoiAyTZAe7qSTrzPCZmKUMsJmermT4qKfccEtB1jxwesRKtTKIun7v8T3d99FnDEffMGwTST1frj0plK1R6FNmnkFu0zr6fzgB3qJ8bisulif4ad0S1+j98DrYedOXnrTE3RLXzOLjqIqtNZxN1dxM2t5kNekO5j6XQ+87nVz95zaMdQeeO/eDdddB48+CgMD6s/rrlPft0MLNXzjG6GyUv35rW+Z72stGEvIsxEN9e+MNqyU7CR2cXFZWlzH42lECpYhbXkPAMpMnNhzv4Cpk0i1GykrOMTQxz5C0f/5KoHmi5d3omcR6RxnmWBNzK2vr6erq0t3hoXDYdra2nS3myzL9PT0mMawuvYEIfObvlRoQmoq51wm7srq6moOHDiQ0lnY09NjSpXWyskPHjyY1P/RKsxpAqHf7ycQCJicklrITl1dHbt27crYDaooCrW1tQiCkJRm3NHRwc6dO02BLqFQSN+uXHyC1df+gtC7qhA3bEAQRSbGptk56mUqofahrKurSzqPGsbjpAmGRqzuQW2f2tra6OvrA+YEPG1O4XCYVatW0dLSYhorW4euKIomdyoXX5xRErVdEntLS4ttQI6Li4uLy7mLIHnwbXqj/nr61XamX34eobSMgvdey9TOfyHc+woVn/vQot3PnGmkC5uwJmaP7R6jf0c/kb3qg0oBgeFfDBOoDdj3mdNElR070rrKUmF0L8YH4ow+PkrjU41Uf6Oa3k/2zi0oQt+n+mh4skH97C97M3I9zozOMH0sTa23gWwCXpaTUp7G3LsRR4fiFCvJ5RgKMEMur/Dn6v5E5gRBpxLzfA6hlSF7iVDDN+nkAb1UPUgXK1d9n+B7L8V3/eUIObko09N4v/zveP/UOTsfeydmQHxFdTreU8Wxz/6c2plv2SZve4nY9pZkeJgLfvtRchJbKOXpuXUTt3Py95t0Edvk7pVU12KD+BmQjWndbQhKY5JLURHFuQfen/1sctl0IgF33QXPPmt/orZuTe5JXlen3tf+/vdJ7krNjZpSNNy923xfvH07hVu30vBkA/07+ucCau6pcn5w4OLisuic0cLj5z//eX7+85/bfrZu3ToeffTR0zyjxUPw+PBf9W7i3b9DPv4K4pq1lNyRz/h9nyf2zr+k5N1vWO4ppiRdmu/pwioaNjY2Zj03u8Tc5uZmU/muVtra3NxMe3t7kkPOKjzOzMwAqugWi8UyKiUOhULIsszQ0JD+XiKRoLW1lZUrV+LxePRxtW36fL6UoTCa6KcoiuMcvF6vLo4ZU6W1Y1hdXc0LL7zguH4oFKKlpUU/xnbHX5ZlHnzwwaxLqoeGhti2bZs+XkdHh6n/orG8fnjfQYIvH8c7GeOy/nbKPtiEULkagPBYnN+f8JGYvevMycmht7c36dhpJdbG8zsyMkJHR4fpOrLrC6pdIxrt7e1JJdtW8W9Rvkd2N202OIn0bmK0i4uLS3rO5XtS77omhEAJ052PIgSC5L79WrxP/4HXPvYKF3zjS4g5vvSDnGVkEzZhFB1nTszoASOjj4+mDrmY/ff5pW1dSeEzmSDmi8gTFvUwAS999CVy1uSojkdtTBkUWeHgRw8y1TOVWam1SOZl2QYyDXhZagrotgigc2KcKhRaezdCnEIiXESAVzhFGQW8RC5DunDnYYINfJ0KdtEf/EtGxy4FnErMtXHNQTsXCP/FS75PAAor1v2aFe+/HKmpXg2RGY/g+9wDeF6Zux+zK/cG8Hsj1PN56Ho7BXs+BcgIKPgYppjn6OHThLmJaYJ4GbMVH4umn6fIEKCjp3bHHqDzemh4siFJkLt09BcIewHTfhmCC2cFdWXfPsbXrkW4/Uu8em8+tXvasfMpJva0s39bV+ZJ1Fu3qgLn6Cjs2WM43iIgMHLFJ2i4v8FeNNy9G66/fi4tezYVmyefpHDrVjdIxsVlGTmjhUeN97///UmlpkVFRcs0m8VDEET8m97AdH8X033PIpSUUnDrtZza9R2OHnyZ0Bc/esY+aV6M3oqLgZ1oYhQM7eYmyzLt7e2mBGzN5WfEKhL19PQwODjI8ePHTe9LkuQo/sViMVO/SCuBQEAPEwH0OVnnYOd2nJmZcRTyrD0JW1tbTZ8bXYfWMBhNhDQew2Aw6LitaDSaJJ41NzfrotojjzzC8PDwvPo4Hj9+nB//+Mf68bXrvzgYDnP0q9+l/tlf4A2KSEEP/g9cjVCkNsgfFot4YnjUtI5dv8xgMMgtt9ySJCrGYjH9tXYdzaekH5Iduafze2Qn0juxGILomfJwwsXFxWUxOVfvST1laxG23EL82Z8h+P14rr2Cku79HLrt46z+7v14S1cs9xRt0URB3cWUobiRadiE1RkJzClOGSbjGlOjM0IAQRKQ4/aK4NQLU8wcm7EVMidfmEw7vN4Lcm8kazHUkVSp3PMglaiofW7tuVhEG508wDh1jr0oI1yki6Z13M1csfXcbqjjv0jd2J36eNaQFWU29tn6V1rUV8jE5YVcUvVTBAFyrmpAqKlR/547NEDOXQ8gnEy+B7WKjwogxGIojz6mliwbPrP2gXyVD7GBrzs4JxVTgI6xT+Ih+XaEd3yRAv8h6uvq4KHtsLUeVr9k71zUggtnBXU5keCl7+9l6uNToKS+vtOK9EaM4qFxX664DO6/nxqnnpGgiqOa6KjNWzKIpi4uLsvGWSE8fuADH2D16tXLPY0lw1tVjxgsId7eipAfIOdt1+J55lkOvf8gvsZmpEA+JTffgKcomH6w08Ri9FacD5mIGXZzs5bGGkuB29vbCYfDiKJoGtPqEHNKqU4V1GEU26yhNaCKfk4p0ulItd2NGzeaBCzrvqQqdVYUJSlUJlWwjVGYGxgYoLOzk5UrV1JRUUFHR0fa/dCwOz7xeDylYCnMJFjzw10EaiJ4/tcN4M8BQUCQJBRZ5mjuWqqufCNNwU6TqGu3PzU1NYiiqAty+/fvN5WUG6+rVKXv1jHtSsXtxrR7vZhk42xcDEH0THk44eLi4rKYnMv3pFL+CnKuvYPYsw9DPIpYv4mVBa8y+KH/hXTdO0GSKLzhMvI3VS/3VIH05dKpyDRsIskZaSWDZNzCrYUENweJ7LERnHIElFOWezJFdTsmxp1VQWU+Kp8IgihQ98s6DrzngO0+pRP8bFkC0dEsKp6gmOeYIR/F8KerMOsA1P5bDx7ha7ZCobUXpeqKdN4lUPTx7ErMPUQo4KAubp4IXMBMSwMrb7oMiosBQXU5AsIznfj/7rsI0zO221MAOSeIpMRRYjGDyCg7CIrqOhcW/ogDgX/iSGEelQPfRhgbcdgX42uZIAdpkD+DMKwAMgwOojz+OH2b/53S4dWsIGwuLXcILox/L65OJAFTrCKfQ5agHvX9TEV6IFk8RBWNT3bCa/fmU7V9zPn73d2dWjR1cXFZNs4K4fF8QCpZjW/rrcSf+RmCz4fn6sspKz1IYuhR5IFpBu74L8oeuJ+8mguWe6rA4vRWdCKVuJiJmGGdW3l5Oa2trUlimhHtM+OYRofY+Pi4o/iWaXq1x+Nh5cqVpnloop3VxbfYZLovoDoY8/Mzb9hs3f9EImGbiG1EkiRKSkp092h5eTlvectb6O7upr29PeUxDQQC6hiRUzQ8/Bir3lqOWHcFgqER9fT0DE8MSgzHD9Oc28XmzZvZvHkzkJyAbcUo0BmXM17jxuOpCcCKojAxMUEsFsPv9+tOWsBUKm68nq3XqizLyLKs9xJdTMegcbzy8nJALWW3G3sxBNHlejjh4uLi4jJ/BK8f/9ZbiXfuQh49jLB+PSXvzWdm/y5QFKI7/ovJN3+Ysg//2XJPNatyaSt2ve3s+salDV7JMOQidiRm+75ySmHWPGciMbZYVsRZBAheFqT6/moKtxTaCq/pXIRJeFHXz6ZU22ZfrSQHuagyq5cJXYSzF+Nmg0fIrBel6oocTiE+zo0HMC7U0a18TRdnczkKyMgIDJZdQs7NGwm++UqE/MDcILKM9OOdeP/fr0xuRmzmHz21mmDpScSY+f7ZeX8hON5Gc+QmYrENTP79fxP41dfh8cctop01tRu8jGNyeyYSgMDaPZ/WJo6i9cg0Bhca+ieKtbUEXnwbYwn1mCbIsz2O+vsZiPSArXgoIJMXezm9c7KuTi2vNq4vimqvyNWr9Z6PbN2afh4uLi6LylkhPD711FNMTEzg8/m46KKLuPzyy9VQhXMMKa+QnOtmnzTHIggbL0XcqH5W1hTm5N2fJP6X97Di9Zct70TJrmwzW1KJi5mIGda52Tn4UqElNmslw5BerMqE4uJiWlpa6OjooLu72+Tks4a1ZIvVLWjsE2kVsMrLy03uykAgYCoVTyVKagSDQb1E/ODBg0nl2ukQRZFjx47prwcHB9m1axctLS0cPXrU9nz5fD6Ki4sJh8PkDo5x5R+fZOVtdYjr1qsLHHwV7zd+zO9vfS+HVq3V72ut10hdXZ1tYE5vby8NDQ16sFB5eTlNTU0mcc44f2MfTFmWTdupq6uzvXas13NjY6Npf8PhMB0dHXovUWMvS0VRdPF0Pth9r+zmBPaCaGtra1YC6FI+nHBxcXFZLs6He1JBFPE3bWO6by/T/W0IK8vxvl59YOXZMkn8dz/j8N0vs/ornzE99DvdZFoubYeWXJ0ubMLWGamRJhnXWAYux1KobVn2WESE4OYgM6Mzti5KWwSItkV11UsXXg1WRbvkZqOLMInsbv1U1CFT7rN9kEvyz2RBTQ0e0dB6UWpC4Ub+1uTiPMTtFPOc4zys40GyOJtA4vC6Zorv2IjnyiYEnw+mTuH9p/9EfPkIRCYRxiKGMc37Ydy/HI4TZQNBhpJ6SdrvLwhKHL8yjG94BOUTLUze9Q/kGcNfZtfURMS57Sc/4BdQ9F6R2noz3hV4brhSFR0VJal/Yn3iCTrFBxiX68jhuON+AZknUduIh/q5SPdwwRJ+gyCALMPwsPp5OKz3fEwSH21CaVyB0sVl8TgrhMe/+7u/M72uqqri/vvvZ+PGjfMeM1XfvWVFkPBc8W5mXnwK5firaP9ECRUhVtx+NRM//HsGD95K2UfftbzzBBoaGvT/VhQl6ZhqgtfLL79MIpGgvr6e7u5uU3q0nYBhFZ3C4bA+dnl5eZIgMj09nTSOcW47HXp6SJJEXl4e+fn5JtFIcyEqiqKLTZs2bXIUxNIhSRIrV67kTW96E4qi0NDQkDRWuv6HVmFRkiRyc3MRBIH8/HxGRkZMn8uyrL/u6OgwCViNjY00NTXp56Guro6HH37YJMSlE0Jramr0Y6Od52ywEyrD4bAepGN3nOPxOENDQxS9eJStr7Wz4n9dibBS/UNIfPxpfP/4QxTg4od/xauf+pTpWPzmN7/Rr7ldu3bZ9uSMRCKmABytn2RNTQ2bNm1KusaNx9VuX7RlU13Pdhw9epSGhoakxO2enh4aGxv1daenp02CstP3ybjdVJ8Z56Tt7+DgoEm41wTQTB40GMeoqKhg06ZNi/J7V5ZlXRzOZL+XC21fz9h/a1x0zsZzdTbN9Vxjse9Jz+RzKa5rxJNfROLFp0BJAApCbh6+N21hxd5O+m//NJXf+gpS0N7ptNTk1zqUS9fmJx1Xu+954MoAtb+ptV1O44IvXMDoE6MgoW5nVjTzlHoINgdZ89drCFwRSFpvbPcY+27Yp5ehspj/TAmw7saj5Pzgn1DYl1lJ9Gz4TPdN3Vz6P5dSuLWQut/W8cpfvUL0OfWeyCm52ej6WyjacRt9bNSxPNuuP6MdRjHOrpQa0rs441UN+Po7kwQzBZLH88Da6TlxNi7mMLDpSsreX4u48VJVhD9+At9n70cKD+urTZPPOBsJchAvY7b7oglrR5U7qBX2oChaibi92GoVMLVjpfz7f5D47W8Rv/IV6O5mevXFDEWuJPDKbymMtyMo044OT/O2FLUnpngRBb/5DQBiSwsoCsLstS4kEiCKrJUfpFv6GtGEfV/NKOvV748Aa764Jv3vvC98AXFWPBQSieRzm4CJfRPqOLt36/tKXR3yF78I2v7v3QsnTpiOE7J6TLn3XmRj//vduxFvuEHfP2U2lEb+7W/PevHxbLzHOV85W89VpvMVlEzrRJeBhx9+mGAwyKZNmygqKuLIkSM89NBDPPjggwSDQX71q1/pJYOZkkgk6OzsXJoJLxHB2DCro68iSCLKqSniTz7H8LNjKLLA1Npq4p98D8IZmDhoFdeszrpQKMSqVavSrmdcTlEUenp6MhrHaTzrepqwcuzYMdMXR0uE1lAUha6ursy/XIJARUUFoVAIQRCQZZne3l6mpqYA5y+pllatjREIBBgeHjaJdT6fj7q6Osd9E0WR8vJyQqEQvb29Jhejdb8AWwegEz6fj9raWj34SDt+8xFl7bDr9Ti7IVb/6SUuzz1M3luvRAgWoMgy3u8+jPenT+iLxcvK2PW97xGNRlEUxbRf1mswU3w+HyUlJfq5BFUIdHKHGq/JVNczJB/7QCDARRddRGdnZ5LYbBTU041rJZVwnmpd637aXT+nE7v9BrVFQCAQMJ0jF5dznYaGhnPObXemstj3pGfj/ahHjlM10o3PA4osIx88yMgvDhKbkpjJCTDx57ch1FSetvnMdM4w9bGp2QZ5MBt6S9538pDqs/tezHTOEP9eHLlPRqwW8X3Yh6fBY/uZ5zoPM0/N2C6rMfmpSRJ7EundjJr7L4MSZI0V6w5Q/9r/VkUSea5/obEkOmWvRgly/y0XT4NHPYYfUe9L67ibYvYmCUcjbF68FOsVkPtPucS/FyfxbMJWfLSKhXZlxurcBKYpQMFrW0qddp88X6Pi2y9z0Uc/BvLctgDGuYSX+YR5vABcFb0ZP8NEvYWMXn05xe/bjFhVBYCwvxffF/8v4uQpw7ZgmkKe5he2c9GWUZDoFL7OxJX1FF/7IhVf+57tstryOB4TeO3uu5mqqSH0ve+R29fHVHU14Q9/mAs/9zm8J0/arGVfyg0Q85Wy/2k13KZu2zZ8loBNgPiKMvZc8jD53Z00RI3nbfa6DHydibp6/B/xZ/y9zO/sJPS975HT1ks0bjm3IkhXSJR9uIeLPvaxue+BKIIgcPDf/o2JhgaqP/UpCp55xna/4mVldBuMKdWf+hQFe/YgGPrnK6LI+BVX0PfNb2Y0ZxeX851096RL7ni84oorOOnwS86O//zP/+SKK64A4F3vMrv6LrzwQr74xS+Sm5vLt7/9bb7//e9z9913z2tedXV1Z9XNuhwZZub5XyLk5OJ7w1ZWNQ2DoiAfHWL4q/9C+bfuxxcqWe5pmrCKHFZXnyAIJiFFY9OmTSkdTYODgyahxmkc43iPPvpokljxlre8RR+3vr6enTt3mpyPiqJQW1uLxzP3Ndm/f7+jYGhMiga1jLa+vp6uri7C4TDj4+MZiV5aGrWR9vZ2k6vQ5/PR3d3tOBdrgI6Rmpoa0/GSZZmXXnop7bw0SkpKks5NfX09P/3pT+cl6lkx7ZOi4BtT/6i48I9dbKpL4L3mWgR/Dkp8Gu/ffhvvnv1z+yKKeBobCYVCDA4OMjw8bBp7vvOLx+OEw2FCoZB+7KyBQJrgpR0XgK6uLkAVE6emppAkifLycjZt2qR/bv1eFBQU6I5Ho+CXl5dHQ0MDiUSCbpsm2Zl8D4xl5DDX4zGVa9C6n9br53Rjva6j0ah+nCKRiOkcLSfaeTrb/q05Hzkbz5XT7wGX1JyJ96Rn03UHoCSamGn7DUyeQLrkEkrLV8LMNMrkFJGf/zveWz7NipuuOz2TaYCxmjEOf+WwXi695q/XULClIGnRVN/zsd1j7Pv4nDsxMZJg6vkpNv12k9pHrgH4oGHZG1IsO8ueQ3tIyA4PqjX35KwLrPLTlQzcnz6wTmPt0R8C6CKJtSQ6ba/GBEjfkWh4uoH9f72fKXEKZDIKZFkwJ1GFThFHx6OxP2MR7QgkB7Ios///Kv+LMG933FwqF6cgCdR88INETq2Cv9mBf7SHWNEGDgc+yPFDNeaBRPD4Y5ycrsHjzWH6LfWUvPsqhNIy9eNH/ojv6/+FIFuSmFH7KdZxN0FDEI0RGS9d3M+4WEv912op2LKFoxdsg798t634qDkencTCNV/7mlpqjOpK9I6MUPDcc7Ol18nl2iCQwI/EqaTPfIlRmt78ZpiZgcnJ5PVFEc/ljWx5ZAv7WwrofPwB1soGwVu8A2nrNWxpNQvCaWlogA9+kLHdY3QbncOz35nar9Wy4stfVmevfQ9kGUWSuOinP0X+4AcRDx1yFGe9TU2me0Xx0CGT6KiNV3Do0BlxT7kQzsZ7nPOVs/VcZXpPuuTC49ve9jYmJjJoJDtLaWlp2mXe/e538+1vfzvr8k4jkiSdVSdUWlGO59rbOfXMT9VfoivVfmlSeYiykkMM/8VHKfo/XyXQfPGibG8xgi1CoRBHjx7VX5eUlCSJf3bnQJKklL3srOM6jWMcT+ut6LQ/nZ2dSb0Ao9Eojz32mGndVHOqqKigr68PQA8WSVWOC6qAaBSeQqEQTU1NSeEiWkr06OhokosvFcbjrTnV7PY93XdUE8yMZbea86ylpYWurq6kOQmCgNfrTVlGHgwGk0rdNXwjE2ze+QeKC2MIIgSvq0Ksr0WQPMRi0zz//AA3PP8CsigiyjLy7D713HJL1gnhmTI0NETv979P8b/+K5sOH6amupoDf/Zn+F//+qTj2tbWljQPzeGiXa9281QUBUEQqKmpSRL8JElClmWOHj2adLw14dPpOk/3vXKiqakpKZl7sUJu5jOe9ftvZWho6Iz63X62/VtzPuOeq3OfM/Ge9Ky77iQJ6cp3En/hD8iDBxGK1YfeAlDw3lKmHv02x/pepeKv/tdpcZ8XX1tM8bXFGS9vd7wP//3hOWEDdIHj8N8fpnhn8byWzd+UT3wouQw8uDmIp8hj6ivZf2//nBiZdgcgn1f1clcNY0l0Jr0ao89FiT4bZWL/hO60zCSQJRtSui7TuDu1/oxXoToMrWji2wb+GVAo5Wnb7diVbWvlv4GGANFno3R+Og9F+bI6p5Oz/9MukQQgJgiWt1Je/xIJ3wq8ayopeMOVCIGgWnnzrZ/g/fnvbfdDFeoUitmLKbDFMJeTNDJOLcHNQYquKWJs9xivfPoV1lFFMc+lTLW2Oy7qvOeuD+u1Yp6b+lPilO0yQiKhlysnrT/rMFS2b0eSJCb2TxCX68zuWBl8+yey/x0322+xuLubrc0X08/tHD+ywdyLdf/+5BCaRAL271e3t2mT2ivSKigKAnzpS+Y5bdoEQ0Pm8SQJYdOms+v3cwrOun9rzmPO1XO15MLjPffcs+hjFhUVAeglq+cLgj+PnGvex8zACyhTE8jjx1DGhxDXrKXkjnzG7/s80a3vxVNZQf/4CYaKvVSEQvMSCjJJj05HY2MjiqLQ29uru6SMTsb5BtLMJ9jGmFRsh5OoODIyYgr5sKKVHYNZRAqHw+zcuZPx8fGU84rH44RCIURRzCjBeyEUFBTQ3NyMLMs8//zzHDhwgEQikdEvtoaGBpqbm2k19kNhri/jCZubEkVR0vau1ITQf//3fze9H3h1mKv3P03JBzYhaH/45eUjCAIno3F2HfcRD1Xx67vuoumRRygeGGCkspJ9N93E8QWIYoFAgOnpabxer624633uOTbs2AGAKMt4T5xgy/PPq02qLdtNJVQ7fVbe10fDN77BzIc/TE11NaNvehPDF11kSsjWHLQaRkHZ9nt76tSCmmWn++5ky0J/t9iFRxm/e26IjYuLixPuPeniIAgC/o3XMVNxIfLwYUjESQy8hBAIknvjNXif/iOvffQVgm97C4LPS8E19UiB3OWeNjOdM+z/6/1M7J8V/bZXUbi1MKuQmkyXdUrN1lKl047pgCAICA11sPdJ+/ANMu/V2HdXX1LojSb4LZRsE7KdRMpU/R5V0UxmA19Hc2lat5PKxZmIJOi8oZPgzL65bSfUbU8UNpB3cR6xI2MUFv2QNe/1I138OtVJ6PMjeL0Qi+G751t42l90PA7GHoyaS1NxcJROvjRJ17YuTv7+JBUzv+ACfmLYz+QgnYSUh5SIOvZsTIe5n6O9uJkSSWImPx/Pl78M99xDfl2A+GCcgoT5XI6s/gtgS+YT273bFGLjHRykRniKmiefhK2GQBm7BGtJUt+HuaAZMIuP3/oWbLHMxxpKY0zydnFxWRTOinAZK1r5YmXl6esjc6YgSB68azbpr6cP7WO69xmEklIKbr2W6T/+nETnBGsnZCYjK2l/6+VA9qJhJunR6dCSf7USUEmSFkXAWGwhBFQXlh3FxcX09vY6rldbW8vmzZttBblMEUWRlpYW01w6Ojr0dO3F4vjx4+zduxfA5MxI17PS5/OhKAqyLCeF+0B2+wqqMGR0UO7cudPk/FzZ9ipXTb5I8ANXIxSZnQavnYzzhxM+/SnvUHU1O++807wBB7EzGAwCzqndoVCIlpYWRFGktbXVVni85OGHAVV0hNnyDkFQhT1LiJE11dn6GZgF5fK+Pm687z59fM+JE9ywZw+/vusuhA0bdEHa+l0sKCjQRUfrNRP73e/gi1/Ub96UwUF4/HGe/spXGLnkElvBe6lZ6O8W6/dfluUkR6aLi4vL6eJ8vif1lKyGktUAJNbWE3/2Zwh+P55rr6Bk/wHiv/lH5AQc/mYu5d+8n9wLl+8Yje0eY+pjU0wxBQmID8Y5+cRJGp5ssE+udkjgzXTZTFOz9TEHUj+oBRC8AoGmAC+9/G5qE0/iVBKdyuVnJLInsrihNwbsXZdQyz3s516T+JhKpJwTDu2FsDlRzt7dmdLF+cIkBXTTyKcBGQHwMUwxe+kY+zqRjkrWvO7HrLxpDUJNjdnBe2IU72cfwDMw5Fjy7DTXcS4ih+OcQi3T1tO2x25n9HG1FH4d/2Ha5+RgGZmZhBcJ55LrbLATN9MyPY335EmUXbtg1y42XrqZV5RrqOYbpnNZvPcjsLsm84feO3bMJWfDnBBovddOJxZu3aoaA4wP3++5J1l0zHZZFxeXeXHGCo/Hjx9namqKNWvWmN4fGhpix6zj6G1ve9tyTO2Mwrt2E2KgmHh7K0J+AN9bXgeAEo/T2H2Agod/x9HiMshSqLOKJue6i8iuHCgUCrFt2zYefPBBx/U00SSVyOTz+SgrK3PsuyjLMq2trbpoYnSEOeHz+RAEgZmZmZTCoVHQi8fjtLe36wJcpmjrLVbJ1KpVq2hqaqK1tZVwOIwwk6D8uVcIRKfIjY5z8cXT+N92PUJeHooss29E4cS0xFQCRmLzD1EKBAJAsvDo9/tNfTXb2tocnarFAwO66KiTSKDs25d0s6aNFw6HTeXxxkRwUPuGxmIxmh55BJgTNbXy8aZHHmHfdXP9sioqKkylxhUVFY7XzKX/8z+mmzchkUAWRdb8539yYFawna+jeb4s9u+WpXgQ4eLi4mLEvSdNj5S/gpxr7yD27MMQjyLVbyK3fhOKLJM7eJSRuz5B4DN/Q+F1Tcsyv8NfOTwXQgOQAEVS6N/R7+hOrLqnKmmcbJYt3FpI/c76pPftxhx9dDT1QgIo0wqRvRFIXExHipLoZJefAMgEOUgdd2dV8jxf7F2X4GWMBj5jcj6mKw3v5AFquQcvY7bp08lOvTl3p+akDHIQgCAHWcsP9WNwId9CEx0BxvxlRApCFIo/Y2VzAcW3NSGEZgXzth5ivzjEUPw6JvfnUa2UkM8JBGZMomC6u+UZghzgL+zF1oR6XLxEHMurtZ9+RhcsOGoos6POuTHT74dg+el5YS817EW77tTPZFBEeMc7wO/PrPKmuzuphJpEQn3fSCZi4db/n713j4+jvO/9P8/MXnTZXVmyZGltg40tyYAlr26Ei5MA5UCiKIQkJZCkkNDTNA2kpKH0ktMCTYPTNM0h4SQ9oT35NVdOUy45LRBhjIGYJE4g6GrJgCUDNljalS1LlnZlay8z8/tj9pmdyzOzs9LKluzn/XqBpNmZZ565rDT+7Of7/Wy3GANsoetmy7xx000LqhTicDhslq3w+Oabb+LTn/402tvbsWnTJlRUVGBsbAx79uzByZMn8ZGPfASdnZ1neprLAnH1evi2fxyp3/0XICUBAMTng9jWgobQQVT88P/iZNu7UNZwnusxF1LOvFxYSA85c9+49vZ2Tcww92HUQ8Nk9Ofr2LFjhvX9fj+6uroM86IuLX3PxLGxMYyPj2NqairvMdbU1KCrqwu9vb2OIqXf789b7pzvGCnRaLQo4uPExAT6+/sRjUbhSSTR0b0HG9p9EBrKQcpCEC66SC1hkRX0pmrw2gy7twyFBrfkc27Ozs4ye3tVVVUhFouhv7/fUrZrPi9T69ahdHbWID7KgoBYdTWivb2Ge82NIEZf7+3tZYqagiyjamzMIM5FIhHtWoSzrRR22jxU+UdGLA9vdEw9VEAvRm/XfKzk3y0cDufchD+TuoN4/fBv/zhS+3ZDnjwEEAIiCMDa9ai8tRyJH9yPYwc/hZo/+shpn9vc0JxVZMuWSBfiTixkXbdUbK9A8NKg6kC0gypB2T/pTiXRepdfEAfgxQwAAh9mUIUex5LnYmFXIk2yB6PvN5mvNHwWzRjG/WjRORPVUehXASx3ZxhPZMuwjaJdFV7RzkEAB7XXojUXw/fBBqzaXA2AQLywHmSV2kpB/Pen4f3+EygBQQUeRwbl8GAOADGEvQBwFCEJqPjpLLamEbQIrfrxitk9lZaAj5d/AsHSwwikD0CYOa66B3WhmW5Q52V6o8kyQMMeYzHVpbhnj72Yl6+EWk8hwqIbTGXerubL4XBcsWyFx/PPPx833ngj9u3bh127dmFubg6BQACtra248cYb8YEPfOBMT3FZIZZVoOTKTwGZJORMBsf3/ieC5BRIQwNqbwlg5kufRyxVA3i8qPjk72P1x651HG8lu4gW0kMuEolool9VVRWam5vR29uLWCyGQCBgG+ZChTj9+erp6bGEgpjXoSy0RJsKUVS0oa45PYFAAPX19ZaG98lkEqIo5hXqzExOTsLv9xuW5StfZiHLMoaHh1EancH23/wStZ/YCrLxAqOoSbwoec/HULb/ADDGFh5pgjR1/OUjnU5blgUCAYPw6/MZHZVmofX1G2/E+q9+VX081AXavPL+92OitxeKohQc4EKv4dymTSgbGDCk6smCgMxFFxnEOUEQsHbtWq19AWDvuD2+di3Wz8wYHt5kQcCUqSSQ3k/F6O2aj5X8u4XD4Zyb8GdS9xBBgL/lfVAyKUCRIcXeQOr1X4GsqkTgxiuR+sXjeOsD/w+K6If3oouw9u//FGKpP//Ai0QrkdZrIroSabfuxELXdUv9A/Xof3eeZ5kCNCAqTDbjrw3JyFTg2lzxU/Qnml33liwUpxJpc79JN6Xhqpj6IDbjIQRwMLtdPWJ4PxrwbRjLzgE/Jgyio/GrKhNugFrRJBER72xsR9WtW+G5rA1E9yyoZDLw/uP34d1DP+RX+yF6MacFx9CxFQiYw3nw4QS8iGddhJJFPPRihplwrT8vb+EP0YgHC3JS5sNuDAIAgoB1yceAXXtUgY26/p591hLOsijsyqb15CuhpnNbYO9yR9yWeS83lvKccDhFYtkKj+FwWCtf4biDEAJ4SyB6gZprbkF65CVk3tkHUhdGxS3vQWhyEpBlJPd8D2NDr2Ptlz+vfhK9BFDnFC0z3XYaU8Hy9ZBjubr0gR3RaBS7du2yJHALgoCZmRmDCDk7OwtZlg2uMFYKsB1OJdqiKKK0tNQieoqiqPVc1Is4ZudjIpEAIQStra3Yv38/0um0beALXebkfEylUtprdoEmTvj9flRWViIajaLytXFsf7sPq/7wUpCaNQCAdEaCAgJ/9Xnwt1wHInoN7jhzqTp1i7pJ+LYTWs1hAOZj93q9mqBbe/Ag3vXrX4OsWoVMJoNkJoPJDRvQ19WFic2bAQAjIyPata+trQWgOjyd3IPaNfz2t9VPWQnRHnQIIYh+5jP49c6dhntJURT09/drY0ci6j+AhoaGDMdw6JZbsP6ee7SHN0UUQQC8/elPW0KN6HnWMzIysqTuRw6Hw1kJ8GfSwiEeVbzxnLcVJFSD1O/+C6S0DL7rrsCarUcASYZ89HW8/fHPYt2/fgu+OvfJ1AvhvL85D9PPTefSox1KpM8EFdsrIFaIkGYKVwKd0qPt3IRB7yG18qYQNbMAqOuSVSJtFhWdAmDMY/bju8YdicBJYRPOT/8EAbyJedQghAMox2FHoY6KfCeELZiNVKPm1iYITVvVfxdlMsBMAmQmDu83fgzP6NumbY1f9WN6MYff4L8AAQjJQ2jFFyxORUXzfZqdmtD6PkbFG0AUgvrgj0DiJ0BEEUomA1KgA9E8Q0Xbuwlzz3LqJOzsBHbvtpY+YxFiKKtsWo9TCbWdI/Hb3waefJItvBUiyrkt815OcJcmZ4WwbIVHzuIghMC35XIIoRqkhp8DCVWAhNQykJING+B5uR9vX/MBKDKBUrsJ67/7VXirVxVt/2YxanBwsGAn2ELJ10OO5eoyCy7mlGZCCDo7O/Ef//EfhuWJRAL9/f15HVx2JaxOJdqlpaVoaGjAvn37DKKZJEmao1IvcoXDYYtjcnBwEGvWrHFVbl0I+kCTWCyGcDiMeDxuLwLKMtY/+RIuOHoIzYKC0EUBlN76XpBgSBXRjknYH1d/HYVTMq5v9wLIBRRRETscDmNqasri7syHnbvTyfVJCNGOhwa/kOyxeAQBHkLQrxMdAVXIZCWRj42N4cCBA9q4+pRqw33xwgsQ/uEftIejAx/7GH6ZyQBjY9p4LS0tiEajlhJ9QRCwdetWxGIxzbl72X//78C73609cJHsw9t2m2bZ5vdOPB5HPB4/7X0gORwOh3P2IFasQcl7b8H8bx4F8QBkwwUAAGHTZqwJH8LkH9+C1KwCWSxF1Zf+Cquuu6zoc6jYXoHSfy1FyWMluVTrRZZIu2Vm74yxNDubpm2GeB1kHAGqW5MKp1nypUczS55FEUJHBC33tKD/yv4lcz0CwCmshRczOueeVVR0DIBhoBda56UaiCUCvOkJJLAJHqgVOE6C2InSNZi6qBlCuQe+CgFrPtICYcNGdbvhUfj/5p9BTs4DKMhkqgmqDQ81YPKJSQg9XmCSJVAqum2Mr4dwAKurX4fccTlq7/07CFd8U33hoYeAO+4wBczktjX/zJrbLLYghNfsBUNJQuoXfehZ/5vcfUrdh4JgcT6y5mFAEICqKmBqyritXdm0HrsSapYjURCAO+7IOST1whtQmChXSJn3cmGlujQ55xxceDzL8YTrQQKVyLzxCpBJQZ45CuL1wXPFJai5eDOgAMrkcURv+yOE7v4beCtD8K2rgbdm1aL2u9jk2sX0msvXQ441N7PgYnb+zc7O4pFHHmEKazRJmM7RLGxSZ55eKAJUEYe63WjAjF44DAQCjiXEg4ODmnA2NjYGQojWN5IiSVJBqdOrV6+2zCGdTsPr9RqOvaamxjJfs6OVpCWUHo0DCnDhb/ux5cpyiA3bASIAgSCI3w85I+EXEwTj87lfRfoel6zzwhJYw+EwEokETp48mbeEXBRFlJWVGQJf6HL9tvrzSINfaBk0yZZZtz79NHbeeafj/ij6ffX19WF0dNRS6j0eDqOru1u719/o7gZ09yW9d833oX6M9vZ2XH/99bkXC+h/Q98rIyMjlvL5hSTbLwdOR99KDofD4ThD/GUoee8tSI++DCVxHEryJJT5WQgbNmLVH1UBqRSQSuLko/+E2KsfRfCqSyGU+lHSeF7Rwu08LR403da0pBU4ZpGx+kPVOPiFg+ozhSlNWxMfs46sd8X7EMdGY/gLhQANDzUg9sOYoRdkvl6BZjchRBEKgIPTH8fEh4eWTHQ0CqK5Hoiz2II3cIdFVHTqWWk/rgwfJoE5VfjyYQr6HpAUBcC8JwiJiEgEayDe0IS632sGfH7A5wMJhgAAwtO/gu/B/wsiK9p2bu88BQAIgf+h++FpCmDyiUmsj//Qdt1TWItTAEJ4TVtOAEAkaO54AjP3fAKH7lfvo5r1I6j/3Z9q69Cn01OoRalnGnJGgYC0/VxFEZCAN3AHmnAPfJixmZeAeHIjUmMp43367W8Dn/88cxvH83Pddaq78Kqr1J+p+CjLwA03OG1pD8uRSMdlCW9AYaJcvjLv5chKdGlyzkm48HgOIAZXQ2x5PwBAyaSR/N1/AqdOAFXVAACyuhrVlatw6sdfQeqkhOlZGf4b/3hRzb8Xm1y7mF5z+XrIyaZP7GRZtoiV5hJep3LeZDKJ3t5ejIyMoKGhAaOjo4bXR0dH84o4fX19FnEtXwmxWWBTXJZf+Hw+rZehfh+BQADXXXcdhoeHLaLtT3/6U8sxmYNa9PMpG5vGpb/8NSrWKCACUPbhLSCNDYbS/mQyjWdiHsxmjI8tVVW5civqdNRDCEF7e7smjtH/3NLS0oL29nZLMI/T+bMNfjlyxLCspqbGtUDHmnc0GjU4aO3eR4FAwPaYF1MeTd87sVjMMn6+9/ByFfhOR99KDofD4eSHiB74Lsy5jNJv9SPzxu804QcAyj5ShfSvd2Huaz+FnAEmyrfgvIe+CrG89ExM2bVbka47cNWAQWSc3jWNbKi0ii5NO7IzYiiT9EkSqjDJDH8RAyICzQF4Kj0G16ObYJYBfAsbyMMIkDcxH2jAG/FPYrZnAyBlinuydFgFUVXYyiBo62TMRwhDaMK9ILq+ifonSJrGrBcMJSLinU2XoCRSBcEDlG6qgvfdHSAluftJkRUc/Zckzv9/P9VmavdEaNsn0e8HXngBkrJVvQdkBRfKb9gKcyG8jjRC1tclCcrzv8Cbu3+CGaUJkIE1Y/8EvaBKxcc0qtC36nFkpjN4j3QdRFh7mQMArr0WB6c/jtmeDYhLWww9P/XHBcjwII4QhjArNefuUzypugoLKbemYt0VV6hl0HfcYXztzjtVF2GhpcAsRyILvfBWiCjnJil7ubESXZqccxIuPJ5jEI8X/ss/BvnYW1CSJyHPHEUmNgqyphalN1+rfmqUnEfqV4/h7S+8ipLWFojBMlR2XQGhgObfVLCiPR5pDzq3LNYx6YRZUKFl1frSYTcintkhF4/HDaEyTsiybOgNaRYr3fQtLATqXKyqqkJnZycGBwcNols4HNZ6/imKgtnZWczOzkJRFCiKYhEZWenQlLrXY7hkrAcVf3wJsGoVAID4SwAAk4k03pr3IiMDb895kWL0q1YUBd3d3ZoAbCYcDtuKY/kIh8OIRCLM4CCzIE3x+XyYOf98Zpr11Lp1IIRg7dq1Wq/FnTt3FuQyNaN30LLcu4qiaNdrYmLC0vuyGOXRZsGTpmc7sVwFvqX8XcLhcDicheO9oBVi9fmQT0ShZFLIvNEDUlIK79VXwPueNCDLCLz5Ft75+GdQ+pFPgIgCQle2omRj+LTMjyUkWtyKOg7tOKStCyD31fxImU3TBmApkzQ7FrVNZiQMXDUAzyqPwaXoNphlSPm6Og+22c0KLe1eIPkE0ULJOR0lR5ddzl0pICX6EW25DNWfaoZwwQWAKAAeL4goQopLGH90DaRTAuL7ynDyTT+SuBMX4AfwIg6Wc5JiFtsUCDiBFrx9fzky0wehyAogOyd7K1AgeCRAEa3CWDqJCL6oic80eds8RgAHkZnKZPdVjxBeY8/5+edRj19gjbQJMbzP1E/TOGYIr6EVX0Q/HsSs1Jy9TxmOOsZ5MPDQQzmx7skncw5CwNpPshBYjkQ6nl05d6GiXLGTspealejS5JyTcOHxHIQQAnFN9oHkPECouQDpod0g3myKm78Evuu2o2pwGNLQPsjzaRz+yY+w7l+/6br5N3VOSZKEgYGBgp1Pi3VMOmEu2UmlUlpJs1mMEwTBIuzQYBVFUfIKjcFgkJksbXa2sWhoaGCOby4Dp3N0gopr0WgUP/rRj1BaanQO0DLtgYEBw1z7+vosSc+2KAo2vLgfHauiKP3klSCBoOHlVyfT6J3x5h2GCkNjY2MIh43/uAgEAohEIppw64ZAIICKigpNuHMbhlNeXq71eXzlfe/D9cPDkAXBkGbd19UFr9eLrq4ubbuuri5LeTigXrdMJqOJuXZQBy2gCnfme0SSJBBCtFRrvdNwdnbWIMYuVGRjCZ753sPLVeBbyt8lHA6Hw1kcQnA1hOBqAIBn3UVIvvQ4gFPqP54BiFu3oib0NjLDP4EiyTj+s++i7E++hMqudy94n25djCwhUYGCoQ8Pofm/mi3bzA3NuStd1qVps8ok7QQ6JaNAOmVc120wS0F4AM8qDzKTC3dEuhFECyHnoHRGAZBBOY76WiC/J4CaWzognHe+YZ3kW0lIf/k4Npx4FQlswincghCABnxHc2manZMUfdl4LihGRnnydax/5rM4jFsANCOEoWy/Sdl2HFGZVwUixms0dTtv+Xn2cfIN3G4JstFIpzVRMYQDGMEXUI3fIIA3IeAUPJgzuSllbMZD6Be+m71P2S5D5rXIOj8NDsFilgKzHIk33KA6KHXhjJrwpihnvyi3El2anHMSLjxy4Km9AGLVp6GcnIGSSSK173kQLyB2tEIEoMgy1rz9No7+8X+HtHYb4PGi8g9uQOiKbUs2p3x9GhcDS9BjiSSCIKCrq8uS0E0FmJaWFhBCmP3wKFSgZDEyMqIJOuY51dfXA1CFy2QyaRAam5qaDKnZVNyl6F18LCRJsrwej8ctPQ/165vxer3w+/04dWwK5/3qdZTMzSGYOonNV5TCc8V7QXx+SJkMXj4uYCYt4JQEzGWMomMgEADg7O4khBiOJ5FIYHBwEAAMwl5dXZ2aAM0oy25oaND6aQLuBbFQKKSNN1Ffj6fuvhuXP/88Vr3zDibWrNHSrH1QS9H1gTG0VD6ZTMLn8yEQCBQsxNH1zSXM27YZ33fmZHO9qFqoyGbeV2dnp+sPDZarwLeUv0s4HA6HUzyIrxT+9/wBlMQUFFlC5tA+yJNvQTjvfPiy4pFvdgYnn3wQhx/9Lygl5Shpvhi1n7sRxOOub+PM3hkMXTPkysVoJyRmJjMYuGrAsk15czlSsRRbfNSFwxjStBllkk4CnTxn/NC10GAWV2QAsrC8YgBgim6LFURZDko9CoDjgQ1IrKoBRC9KLl+Nyo9eCpJtKzX5TCkmuqtRmn4DF7755xBk2RDGE0ejpTTcDgJAghcSyuDFDAACH2ZQhR5UohejuFMnYtoH1BApA2zcCBw6xNiHjCDUUEKWm1HJLqeDz6IZaVTY9m+k81Ygoxq/wZD4dUAC3oPrbN2UkIG1TW8Bv5rOX9pMCQZVsU9PsUuBWY7E5mbg7rsB+u+hlhZ1HoWKcm4TsAtJyj4drDSXJuechAuPHAAA8fpBKtYAAEreewtS/U9DPhEDCEAEAWTjRlTdUg75yDggyzj5L/dhfvATWHP7zUsyn3x9GhdDW1ubIewFUAUXswBGhRM6F72oQ0NjCCEIhUIIBAIghKC2ttaQKhyJRPDMM88w5xGPxzXXY1tbm0FMNLspqfuS5T7r7u42jFtRUYFUKpU3yZr2ekwkElp5LqvhemlpqeXcpNNpCONTeM+eXyL8nmqQ8jKQ8tUgmzaDiCLm59PYGfMgIdk/uiUSCQSDQdvXAfZ1YQl4U1NTWL16tUV0VRQF/f39hvvJ7JSkjkhzqrg+5AZQxcd3br4Z1a2tONrfj5MjI0A8rp1r2qczHA4brl1zc/OC3H+1tbUArCXM9L5jsViRbTHl0stV4FvK3yUcDofDKS6ECCBBVSwSI9ci8/YQ0qMvgSosJFSBshvei9LRg1AypyC98yQO3fJrnPd//hGeUHne8d/5h3esLkZ9z0UdTkKioli32XjPRpx47gQUQTGWKWd7PHqrvQh0BIxp2qwySQBHAre5LoueRTOG/f8Eb7UX/vVqWyTfkSTKm8uRmc4g3hMvOEQmPW3TLzAPhYbKuIXtoKRfCd45rxWhj2xG9fk1ACEQ6jeBlAegSDIO/a8aHH1addVegJ9AgGwJ41HLmd1V0iggOAH1GUffL5F+bcSD2Z+hfbUtS2aIjvTYvJjBFfgwTmGtdjb1peRv4A7DNnGyBVWKtX+jHgKgsvodVHZUYm5oDmSc2CqjITKE6gfuUkVzGyzHNTWl9iz99rfVEuuhIWD9evW1pXYd9vbm2hb09KjzoOnVbkQ5Xb9VxwRst+txOBwDXHjkWCCiB/6OD2k/p9/qR/qN34FU10CsrgEABC6+EKkXn8Kbv/coFHjgvbgZ675+9xlr/l0I1MlInV12pdT50rDNoTFUPKRjRaNRDA4OOpbV0jHN4ohZTKRzZsFymtXW1hrEL3N5NgCmMMlyNybicWzsPYzw/ldBlNxjXtUaCas+fQlIeK1h/alECs8e8yG9iN5AlKNHj1qWUWFWf8ypVEo77+FwGFNTU0gmk9rr+mvHEu0kSbKcj6qqKkvCdyQScQxgMYcSAdBCh/TzdUM0GkV3dzdmZ2cNy2OxmKUEnbJYkW0x5dJc4ONwOBxOsfGc3wzP+aozSkpMI/XS4yD+EpAmVcASZBk1I6MYv/HjSGfKQIIVWPP3f4FASyNzPKaLUd9zUYcmJLKUGcY2Fdsr0LKnBUMfHjKWKSsARCDQEbCImyxHFrn3XmxUtmL63cY2PU4EWgJof8n6N1jrUylmxVZdMI0jC0y7tguVUV/7CUKlhzB7yia52wFaUp7wVuLYxq1Q/Ll/worlIlb/fiPESBOImFsun5Lw+t+cj/hQTpC26z0JiFBo8ncWRXsdpmUKDuNWbMXf2/RvZJdWFwIdx4eZrKtSLSFX4EGcbMFh5VYACprx15rTdVK5AlX4Xd40bqEjkrsPL2sFXn7Z8Dp1U25QHgYgAxL73zGKIACyqZRcltX/7rgjJzTSZ8mODuDIkYWVAudzGJp6pdqmVzuN43YMt+utVJabm5Nz1sCFR05evBe0ggSrkTmwF5AyUFInQUpK4bvmCtQ1xwBFgRwbwzsf/wzqHvwneKpy6YSKb3neYnqRxCzyhUIhpoBiFvj0whagCpGhUMiwLBaLOZaq2pWjFlK2GolEMD4+rrksm5ubsW/fPs1N2NDQgG3btmHXrl2WUmSW0AgAUBSI82kQWUHjc31obsrA88dNIILuUSYYAgmpn9jPzWcgKQqOnCToO+GzLSsxU19fj+HhYaTT7E/Wze5EGnLi1FszkUjA5/MZro8sy1pgTV1dHcbHxw3rs8q9ZVk2CLaJRAI7d+7UnKe1tbVMMdF8X1Bxsr29HQMDA/bn3IRdQI35XihmmvRyLZfmcDgcDkcMVKLkyluR2vcclLkTUKQUCDIQL9yC6poqYH4eynwS8a/9BZIf+wIqrrlU21bOPr6UN5cjNWFyMep7LmahfSDFVSIyMxlYAoMZ2wCwTby2EzcBMB1ZFQDKLi7DyVdPsrcpgEB7APG+OKBAfY4TACXt9kktRwhDppJuq3hoJ+yF8BoAAeSUbJvcbUeQ9GM9HsFk+SbI79+C2msvAinRBV56vMCaWhBCICUkpI97kJr04I1vbkRqwtin3L73ZD2CGIG+VyYrYIYASKEC5XgDXpxwLTLmEwNZmJO7PZiDAhHHLvos8PpJtMh3aSIvLRmX4IMH7IonTUidnlbFpe3bgQceAK68EookGcrCY3gfLsAPQJye6LdsAV6zCbQBrMJcZaW6vx07gJtucidq7d2rllDrxVGWw9BNH8l8TkW3vSiL2bNyucHdnJwlZHmqQpxlh6f6PHiqPw4AUJInMf/bx0EwD6xV7fPiuvNQs+ZtnPjLP0Z6LvdHSkqLIFe+T+21sQxhhZSYE6cp5lLSAwcOGFxyyWTSIkaxSoUB1YHY3NyM1tZWpnBk3pc+idksLg0ODhpclmaBkRACn8+H66+/3tIDsKamxuJq8x1PoG3nr1BZOg9BBCquvgBCpBmEUYYtSxJ+fRQ4fNL9rxJRFFFaWoqGhgbEYjFb0ZEiCIJWdkwIQXd3t5ZEzkLvQgwGgwgEAtr5GBsbQ1tbG4LBYN5E7ImJCcsy8zhtbW0YHh423AcsJ+nExAS6urosJfTmZHQ7gsEgQqEQ6urq0NTUhGeffVYr69aPOTY2hvHxcc0dS+8rev4mJiYMZdB29x3tZxqLxdDb27soMZPD4XA4nGJBvCXwt38QgFrunH7tl5CiB0BWqxU5BECothbzu/8V0e89kNtQBvyhjai76x6ceP6EwQFo6LkIa5q1Vmpq16dRx8zeGWSOM0JZBLZQacfM3hmcfM296Jg8krQs045DzpV+K3LhgiNgLqHOCV1m8dCpJNpc3pwvPCWIQVSG/x88F5Ui6alEecN5KLn2Mkt4IWVqjw8H/3EDlAxbCnPqPamWLSuasDqPGpThbUPwCrLrp7DKUE6dT1RUdF8X3jmTbithy+jnkZZLQCBrwqB6TglESIzUbdMYtAyZlkMHAsDMjO6cqOXi6rlxmLPuQ/y86Muf3YpaVATLZKxjmR2GbvpI5nMquu1FWeyelcuJs93NyTmjcOGRUzDEX4aS93wSmcODUOZOQD45AyUxCeG88xH6w9VARickpTNY9fJLGPurOVR0XZtbLgoIdFwIUuq3dWsV08llBw2N0WOXOG0uJTWLSFRwomW45hJuPYQQLWFZH06j76un35e5v+TIyIhWDm4WDs3lyfrX9YJmbW0tlIPjODmaW997MolL3u7H6tu2gVSuAkBUZyMhmDuVRnQ+9/ghKQQHEiJmTLqhIAjqp842gpokSQgGg8wwGBayLGNiYsJVijUhxFDazhKQR0dHbRPDC4GKiW1tbZbraIY6B/W9PGtray29Ru2S1BsbG7X7oaenR3ttfHzckjpO718Aln6N5u9Z/RxZ/Uzpa4VwOt6/HA6Hwzl3IYTAd/GVyKy5AHLsIBQpA/noWyCBIEo+eCVKTumEO0VB5TvjmPzff4n6Bz6Lo49OYv7QPEo2luC8uyO5notgpFnTxw8R8FR5EOwIGvs06ji04xAM1jGKDKZQacfrn33dPpXEjI2oqR1HEVrfWEuo2eLhYXILKhVjyjbbOWhM7ibCHARv7nm0DIewetMLWH3rxRAbLwAEASgpA/H5gFQKmV8ewlQy1xJpdjCA4y+EYJbJQhjCZjyEAEYgZC+opfekeAdmJbV0fwhfRwhDaMUXtXnrE6wVEPgxqY2j/2qH/nbQi3sEUI8LAEpLoczN5R2PAEA6CS+SjHOqOCZxa8vp8/kdd6j7l43XJ/e99boZmJkpTEg9dcooItJ5XHMNcPXVqvsRyIXEpFLWoBr9tnqHIatXqrmPZD6nopsxCllvJXI2uzk5ZxwuPHIWBBE98G7KCRGZw/uQHv0tSJn1wcd33RWo7B1E8kdfzi1UgHe+VoLJz/539E2+A8AqcCwm6IIFSwix62HnprddW1ubpc8jFaMAawm3nqqqKsPx5du3eVk8Hkdvby+GGH8IzIKfvlyWiqdyKo0jd/8j/BMv44LS3GODJ+iF77Z3g6yqMoxxeDqFX025K6GWZTlvsnY0GrX0Lsw3phvM/TRPnjyJCy+80CC26Uufh4eHLaXRbqHnVZZljI+P2zpbfT4fDhw4gKGhIaxevRqdnZ2auGcWHcPhMCYmJgzf03uV3r/Dw8OGfbAclvnu33z3GKvXY6FCYrHfvxwOh8PhsPBUnw9Uq6nX0tyM2gfS6wO8xg/mxIpK1FS8g+QvH8B5mwFsVpenvi/j6LE/xJrP3gjAPs0aaUA6IWHjPWzRUduW8cgiVog4dP8hzA3Noby5XB3DriwbwKnXTuU9bgCAoJZPs0RN2+PIA6uk2q6EWi8eAuyUbQ/iCOEAo7xZTe72lL2O8694CmVrc88UhAAll10KUt9g7M09OQXfn38TwriCt/BBba51urkCqlAaxAGtPyJbjCMoxTi2yn9vKB3fjIegF91yQiXBKL6ARvyvBfdsNGjSFRXAhReqTsD5eaZe7TSeGTt3oqNr0eH5Oq+bkxAohIC4fEbHnE2rgWQS2L1b/U9RHOdkgIbWAO7Sq9evB8wtkvRORbcJ2IUmZa8kzmY3J+eMw4VHTlHwbNgGsvo8vDnUg5kTJ1CxahU2nr8emZGXQDyA+K52lHXofokpQNmxo/A9/F0c91wAKVvGO9dzBMc7E6j68HsXFXTBgiWEmHvaUdz0thMEAY2NjQbxUL+deexAIIB0Oo2qqip0dnZi165dzHFpWax5Pqx5OiVX05CcLeWr0fuX/xNzM7MoLy9HbW0tMr/7NVZf6oH4/usAr+7XABFABAGKJGP4hIITGREnM8DxdAmUAj8yr6urw/T0NGRZZpZTz8/PFzQeC1Zojh5FUdDa2mpxI+oFYpb46wQhRCt/B4CdO3faOjfN6eLRaBSPPvooQqEQJicnDesmEglDyTR1P46Pj2ulz24cokDuPrQLtGG97nTv1tXVMd8/1LXLEiOL/f7lcDgcDicfYnkFSq78FOSpI1Dk3HNnJjoKZeodCOedh5KPr4Ve4ik7dQqpX/0nDv9xPzz1jSitPQrh1DzkjB+pRDMg54ITWWnWephJ2AIgzUiY3j0NSEAqlsKJ506gZU+LvfjooEC1/roVh3boREzqvjSFQtSsvxljsY0FiY92JdVxNNr0RtxkHMADzKabDS5IOqZEvJgqX4+0pwQKCCZwKYIlT2HDhw6j7Lr3AkF9CTXRWvyQvlfheea3IKk0hJ5Xgfk0EuhgzrUKPVA0b6KzcEagwIsZEAWG0nE14dq8LgDIaMS3ssdeWNm0fn0CqGLO5ZfnVpBybsyFYic6mve/2DG1cc8/H3jnnUWXkAOwuuwWglN69d69qsDLQu9UdJuA7Xa9lcbZ7ObknHG48MgpGgMH3kTv0FvqD+9Mo91Xhcj2T2L6l48gQOYB0XS7hddi1a3luHxwPyDRB5njyOz6X3i7exdq/+gGS79EGhBSSNmmnVMsFouhs7MTgFqyGo/HNWGQikr5MPdi1Cdhs17Tz9lOTBwZGQEhBJFIBIODg1pZLsth6UQoFMIFYwnM/NvfoaGpEqjNPhbM7Yf4/jqQTZuZCc+pVAbPTYg4ntKfX7bo6Pf74fP5LHNKJBLYsmULPvShD6G7u5t5nG5DVpzYunUrBEHQzrE5vEXMPrQGAgHDHGtrazXHYT7x0gwVAAcHB9He3u7Yb5KFXZiNmXwioyiKEEXRMHdWIrtTj0f6upt7d6fpAWtkZMS2TQDAg2o4HA6Hc2YgHi/ENRcYl9VcgEO/fQZr549Ye1YHgvBdux2rh1+FfOJ5BD+gLlaSGRz/7W9w5KVbIGeq1YVOITHQJWHTHpJA7hFKyn1VRGcBU6wQIc1Yn5PEChEV2yuw8Z6NOLTjEISe34LccAfk9AEIs1OqSCDLQCyGeuxGAg9iRmgyPsZRRY72rNRhV1INICvl5UqoFRAcxq3GARhtu2fRjH7ha6iMPI+qq0IoKS8BAIRwAqSsBGLkvSD+EuuGsgzx35+G94dPacKW6jwUcRi3YgN+YpkrFcHclEEbxcBc6bgdZteipWzaxX409OWrC30eFgRVrJ2Zsd0vZaHCoOOxHTmCUxs2oPSttxY4+iI5csT9ujt2sJd3dJwdTsVicTa7OTlnHC48cooGy+HU0tKCtyu3InJRAwwy1tQRpF77JUioAt73GH+ZeSQJvqH9UO5/AFeIIdUtpwCprGsuLQjo+/0PoOP2T7qal11Jc11dnaFvI11HLyrlw9z3EcgJndSllkgkMDs7C0VR0NbWpomPVNwxl/smEgn09vZqTjdAFXXa29tx8803G/oJeuaS2PTCPpTOzUEUBUhS7gkyWOKDfH4ClX94FUjQmLatzT9UC+/F78XQ8H7s3/8qAOBkxuPa21hZWYk5m9KJ4eFhKIriWmDMV55NIYRopchUzKXnvLS01DBGdXU1fvzjHxvEuXA4DKBwp6MZWn5cDILBYMF9JyVJ0s6tXnDUi9tmR2JnZ6fhdbt7nHVfm4VElgBu10/ULGxyOBwOh3O6OVFahw2X/B4ESd+LfB7J/p0gAMSWbTDH6NW1xFBS/SNMDlUDCgEIIIZEvHXzIwAA37ZmhP/y0xB8XgBqqnXLnhYcvPsg4i87fFCcR8AMfyaMIw9YhZVNX9+khcYE5X1o1iUbKwAIbTkjqak4F138Mxw4/z2I96hzUdIKiJcYvgKAfFIGBCAovwWStpZUl+CYpYT6MG7FLJqyaynwV7yCstWvM4QqBas2TWL1J9tBzjuf+aF3ZlrC6FfPh3fiTTTiW/AgDiFxEiR+MjuCyiwuwhu4A7Nosin/dge7F6KcPbZ6hMBOa2YJmgWLjoCxfNVc2uoGQVBFZofnZjei6EKhY5ccObIk4+el0PJfVu9CoDDx8lzhbHVzcs44XHhchqzUUAYnhxPxl0PQfcIslF0MUrEGqf6dQFpfcquAiCLElm1YU/0OahKMhzJZxqmexxF9II26P/8U8wFGjyW12efD6tWrDYm9xSwLtRM6+/r6QAjRBB2W6KnH7KSLxWLaNq2trej72U5U/uxfUft7a0ECDDeZQEA2tIP4/QCATIb+wSXweL0Q12+Ft+FSEEKQEvxImELjfD4fampqHENynM5TMpm0CGmiKEIQBEPpNb0e+u38fr+tCCkIAj74wQ9qP1MnrH6OdEy7ebMSq51guSJp+bEbt6Q59MaMoijYv38/AoEAgsEgjh8/XpALMxQKMUXEhfZZ1P8OkmVZKy9va2vDxMQEZmdnmcIjq58oh8PhcDjLBeLxQfCX6paEUPKeP0Bq8FnI02OQkzIUSdV0hFICUluHVZ96LyrG2c8TUuxXePuTv8P67z0AT6VaKlyxvQKeSg8gwlDmbO6dOLX+dgBWJ9HM3hkcedAqiKz/i/VY9yfrMNg5CEVRsEE2uxNNxwoZ5NVhbPw/aj9JZlq3DIPzMY4LUIXjzJLqWTRbU6gJACWDVRc8ho0fjcN7QS1jJgCpaQBZrbpG5ZQCRffMOfe6F6M7NqNs9lVsxV0gkJilzhJElGIcTbhHNzcCAvvnKzN6IY6V/jyPGhwq/1NsO3knFCVPuIoLbEVHAJieBt54Y2GOR1qWbuN2dIIlRtoJlI5BN5IERRShiCKI/hgEASgtVcNkZFntZVlZCRw6ZD8YPSesHo9UZAVy5b+Aev7Wr1cFyHvuYSdjU1i9CwFjn0gOh7OkcOFxGbJSQxlYDicnsUUMVqP0vcYSDUWW1Ye/qbdB1p9n+wevbPMmpPc+j0NXPQZZcX4suFCWsVEW8XpHBMebzjMIUna9HmdnZzVRslDR10mM078myzL6+vowOjoKn88HRVGQTqchJNO46OnfYc3sMUOYGyHAG1//F+3n9bVA6LZ3gayx9oTUk5xPY+eEB/FMruz4k580ukVZQlwqldKuIxWh7AQnt0iShNLSUoPwyBII0+m0rQPSnxVSKaxk8lQqZStcxuNxbNmyxVL+nU8c1EPdlubyYzu8Xq9FSAwEAgiFQpidndXmmkwmEQgELOckEAiAEJI3NdvMQgV1lng+Pj6O9vZ2dHV1GVKvAXaJN4fD4XA4KwEieuBvU+urf7P+N0iNqX+vKy+fRcO9YyChCpAQuxcj2aKgZt1BxD5xM5Incx+wl8/LKNf9SVSFvAxOKCGcHF+PtdE+VF521zIAAQAASURBVPV8BtjbgBk0GXo2zr89z+zLOPMrVWSioTEsx58eKhgeyZZ026Z164Y4jFtQiVwq9dGKzYhfsAHw+LAe32CcAMBToqD6w5shNL3HWsaun48s4/A/V2PiyWrm67kyb9axAAIkiJixhLS4cfXRdc2BMSykOQmz2IKQOApFyhi2KwodHWq/wZ4eR9HR8bhcCo5uxcSFHJ8CYH7dOpS+846xJyAAzM/nxMJEQv0vm6CtIQjAJZeorkNa0qsouVRrAGhpAb75TXU5Lf9dv954/mIxtS/hnj1W8ZH2PbU71z096jpOoiWHwykKXHhchqzUUAaWw6nQPn5EEOBvfT8y77yKzJFXoT0WKArmTp5EOp1G0CND8JfAe+XlqG2eBNyIRZkM6n77OvbtPYnj7YBfVx58bPAA3nvle6GEN+LQW4cwNzeH1PE5DB+KQRk/josvvhivvvoqJo9NorqmGhdffDEEYi9G1speTB5nl8/Uhr2Yf3McADC8fxj7h/erx5397/xACJue2oW17w9DCG92PqbyAEh5QN2+JAQIIk6cOGEQuObhw2+OeZHS/Z2fm5vDz3/+c0Opcl1dHcbHxy270LssAVgEp4WQSqXQ3t6uCdROwSws8VEURYMjr5B0bDpua2uroZQdsCZim7eh+16zZo1WsmzXp9MNiUQCwWDQErwzMTFhmEtdXR3Wrl2L0dFRyxjmoBszC+2zmC/tPV//Ug6Hw+FwViL6cJjp34YwdLsP538mBv86grILywzrKqlTIJl5kIYGVP3xasBlpYJ0eAzv/HsIa0b2Qf7ClzG4//OaIHjiGAAJIAz9bm7fCcy/GUZZ4zzSx2YwLTWgAkmTO5GKamoPxkP4fSSH3sH8mzWYG3oHBGlY6sl1xLEe/fgqzif/jlM1IkKfvAjhlgZAdPgbL3o0N2P6uILkuAcQCSAr2mO8lBRw5OE1SAyXA3CfnE2PCbCWOS82BZrlqizFOFrwRdUtKtmPr59TQeXMhKjuPyCv03EpSpjN55IuW+i+5PJyyM8/D/FrX8v1BJyeNgp9kpTrR0mDJamgyOod+NJL7J3RD/uz/fkN44uiKjDSdfbuVQXMl1/OfxD67TgczpLBhcdlCA9lADznXQzPeRcbltG200p6Hsnf/gzAHFDj7PbTU3r9GrT/tgdzv/gvmP/Ezjz1f7EOwDrzRr97DjPZ5fS1fJ8xMsfRjTftsJ6nFCj/gzaQ9efl2YuKnJFwJFiPLVdcCwA40tNjKG+uq6uFryyBlE68UxQF4+PjmtDY3t6OSCSC4eFhiytPn7AtyzIURUEwW95RX1+PaDRqK1KJoohIJIKhoSGDuKYoiiasKYqCGZtPbWkitCiKFgHbrpxdTyCgirJml6DP54MgCOjq6rKUaFPs3I+SJGk9QKmj1004DcvxCKj9RAOBgKHHp3m/c3Nztr0fzUE3eszXq6GhwdGRaC6vZkF/Fy1lGfVKbTXB4XA4nJWPORzm1JESjPz9BWh5sQUllxtdj4qiID3yEjLv7ANZVeV6H2JNLWpWVyK+uxxymqDh/O+53nb67u+htgKo/QCgoBIn8B7H9dfiRQAvYvpu4IJLXO8GGbIOlR3nQWyPgHjc/XPx2M4SvPmt8wAQVF5XqQXgSM/8EhvwMJqzIuMkrkADvuMyOVvFPpnanfiYbxy6jpAVcvOF05gDZgoij9NxKSmW25Fu55uYsPYEXL/eenyynHNpiiLQ2+vOOMKC1a9RH9azdy9w1VVAJmPZ1IJ+Ow6Hs6Rw4XEZwkMZnCHeEvjf/Qlkxl8HTuUv+1UUGfNvDsDr88Hz7ktRccl83m3OGIIIUqJKrEdmM5hKC1mXXQ3qautACMHBgwcxG49DBvBWQkRoTRKJ3l7EYjGLQBeLxdDa2op9+/Yx3adUNBQEgVnyPDo6CkKIVm6tF8BisRg+8IEPaMnb5l6QZWVlIIRo/TQp6XRaG4flFjSLfuZ5l5eXWxLKWRBC0NjYaBEoQ6GQdsx2gpbH47E4EfXEYjHL+XAiFArZhvAEg0EEg0FMTU0hk8lYjlcvSjrNxyzYKYpimB8hxFHAM4u54XBYC+6hgT6n43fRSm01weFwOJyVDw2H0Zc+b7x3IyqusJZaE0Lg23I5xDUbIU++bXl9/kgSM78+gfTRNGqk5+E7NQ556wVA60UgmzYh+Km6hYsvp4OSUhBBAGKTEJ//HeZJHY6XXQtFUtQwGh2J18tw4uVsFY6HaOcsck8Cyq67ACUnMlbhd4CuN6N9cjayr9tjJ/yZeznmG4ciYt61ELcg8VFRgMlJa9nxCkQBQNJpCOefD2zbluuzyOinaDhHLIdiIbD6NerDZnbscP++EgQgmXTfK5LD4SwYLjwuQ3goQ36IIMC7/uL8K2bZPyui5sjvsDroA8rKl3Bmi0eRFfz2qIw35tS3Z3t7G87X3Q8nZz0YfCcnEKUmJ5ll0pSjR4+irKyM2R9Q72gMh8NIJBKG9eLxuCYCmZ2N0WgUAwMD6Ojo0PpVJhIJJJNJpFIpbVuaIu0Wp/Jr1jzsmJ2dxXXXXWcpqdbPp7a21iB+BoNBlJeX592HLMu26/h8PkPiNJBL4rY7ruuvvx4A8NOf/tRyndyEzNCgG71gR52OFP2+Wa5C8/FQV2gxKMTFuFJbTXA4HA7n7KBiewUiO9ktTFiIlWGIldZnHW8DELw6+8PeOuCqq6AoCjK//3vIfOb3QUrLLNssN8hLg/D//f8BSWcAbw2qfvF17L95v9YH07K+n6DlhZacULtjB0AAotAAnGz6tsmnyErO9mAGIuw/BFa3Y4fESCgBgQRAhowSiEgCyDiHpcB96bZ+G7pP/faOQiQhRREdC9rnEuGZmQE5cUIVAp95BqiuBjZnW0Vl+z4yhdl8TkPam5GWb+sFwXvuUXs66vtKEqL2iATsE6zNUPF3akr96tQrksPhLBouPHLOCSJtHeiHgLeOvo2aqlWo31wPIrD/RCuygoNvHMT09DQqKyuxadMmvPnmm7Y/07FGR0cxOnpQG6ehoR4NDQ3az/le1yhdhVWvjWCdjeOV/jwyMoJ4PJ5XmKqrq0NtbS3TnReNRrWyWkIIGhoamOtRwcjsUBwdHUVHR4ej+08QBEfRTY/P50Ntba0mYNLAnYWQSCSwa9cudHV1GUqIo9GoFhxkpr6+Hvv27cs7djQatQiqwWAQgUCAeZy0JJqFPpXd7vxTEVEvStbV1WFubk4rnZ+amjJsY3ZK6l2kLFehWYTVi9JmCi2HLsTFWEirCV6WzeFwOJwzxczeGaMz8h41PZrJ9u3Anj0gO3bAu3cIIglB+fwfY07ZgDf/6k31b3TW+EcIwdo71mLmtzOYf2se0qwEJW2VxDyrPdjwN9ntdf0UAahin0AglAuQZq0iDPESbPrHTSjfqn4YP7d/Dm/d9xbkORkb8W8IYgRCPAFy4LDWMzKevgDDVw0g0B6wFR5XXb3K6A4dGgKRjftni4XEkpzdjL9GFXocA3TM41EP5TxqUYYxEEgQMGdxJy4kxbmwOTigex4rRDQ09pVU/59CBU5hLUI4AAWLT+EuFEKPhQqpk5Nqj0dFAYJBKDPx7Fwl0/UWQKhD0QwtlVYUVUCMRnOiZkeHKjzu2WMUJmkwTWenOgc7RFEd48gR1elIRUdg8U5MDofjCBceOecEgiCgvaMDQEfedXt7e9G7LysQvnMcc94KtF/2e86vt7ejsXId5rwViMViqngG4JmX9mmCyBvH9yF6Sjen46dw4WXsXo5OjlfqiI3FYkwXI3UuAsa+foQQDA8PGwSpaDSK/v5+tLS0AAAikQgIIZqoSaHHMDQ0xBQ6nVxptbW1aGtrs/RTZIlpqVQKAzTJrgjQebW3txuCccbHxzEyMmJZf//+/ZZSZ0EQmMc+OTmplSPT82NOufb7/WhqasKBAwds56goCmRZhiAIaGtrY57/ZDIJn8+HQCCAVCoFn8+Huro67VzZpX/r56sX5FiuQieh0Uyh5dCFuBgLaTXBy7I5HA6HcyaY2TuDgasGtFCYVCyFE8+dQMueFmfxMfucQP8ihwBc8ECYWdq95lPqOoOdgzixe9qYdC0ClddW4q2vJXGip4yZgg0R8FR6kJnOMF/vv2ZCm2/ovcDGr4YxcNUA3pKvRov8pJYwTYNqDuNWKBkFJ18/qR6AbA2J8d/wFQA5t2h6/YXwjEWZATj6nwEFQRxAM/4ah3ELZtGsS9guVBBUUI7DzPAYAIDXC1JRAWV6BpDSRRPr8vWFtNvGbbk2XVeCFyfQisO4FbNoAgCEhCFsE/4Gnoz1eXCpsJ0vfY6embEtgweQcyiaoaXSdBy9qLl7d86VqH/mNouVLC691Bhos3691XnKez5yOEsGFx45K5JiOZ3clJzm+3lkZETbPyv9mQoixQ4NYjkQw+Ewurq6tN58/f392Llzp0HAMfc8HBoawvj4OOLxOBRFQUtLCxRF0VKUqXgpCAKampoMjjzq2HST7qwXROvr60EIYSY1s/B6vVizZo2lj2Q+FEVBT08PJiYmLNeNJdqyRNXa2lq0t7dbSrbT6bTmfKTnx+wa3Lp1K9rb25kiJyUajaK7u9sgYNKemnpXq35uqVQKb7zxBnM8URS1a2gMGqozfG++F83nZ2JiwnbOhZZDF3LvF9JqgpdlczgcDudMcGjHISiKgpCUFd4kVXg7evftqHjptoLGylfarQXeCFlXJADIQPUN1Ti84zBbdATUdGwQtXc2w4enyAoO7Tik7TvX33IV9vf8M9Ye/wECCk2dVkWuEIawYUYVGlMltQjMvwZALZX2CdMgd34QaN6jlaq+Ef8EGrEH+r6NLEFQAeDDDKrQg0r0YuSif8XksVYMTH4LEdztquRaP5ajiLdmDWYe2Y83r/wJIvgikA25oTLraXcNorB07gwqNFcoAEAE4mQbROJ8jopdmu22tyVrHclTBo++D6O+tHpy0l48tHMlmsVKit8PXH21KnKaE7Tz9YrkcDhFhQuPnBVJsZxOrHHyiSTm1+PxOPr7+w37ZwkinZ2d2vfFCA1qbW21OOP0gSmsY2ttbbUIaKlUSvu5r68P0WjU8DotBe7p6cHo6Ch8Ph98Ph8aGxvR1tamjUuPbXZ21jCn0dFRS2J2LBYrSEAkhKCrqwuZTAaPPvqoweEXCATQ0NCA/v5+5rZDQ0PMYB09giCAEGJZTxRFXHvttdo6LKhr1O7+k2UZ5eXlluukT46m52JsbEwTgVOplOO8WanbdM7Uwdja2orR0VGkUimMjIxgfHwchBDU1dWhra0NExMT2r3Y39/vWhx0KyTqhf1wOFz0kJpii/kcDofD4bhhbmgOIWkILbjLkM5c9fJngL0NRe0RV7G9AvXfrsfoHboPawlw8M6DatlzLGUQH/UuxCQaIXz7PvT8mR8W7U4G4j3GD2FzImgEg52XY1rntAzBdLzzkwZRicgSQHKi0MzeGcRe3YyT+BY24yGE8Brz+PQCFg2aWXPw/+B4xTcxi2YkUI8QXrO4JJ0Sp+1QBBHx5AYMXDMARWoy9JQkSMOLGftt84xti4sgGbfjKgDmUaM6ThW13D7YEcTmG2Igdzi3XjI7MvOVnedjMWXpYiahOhT37FEX5nMr6pEkNRm8szNXam2XFF5dbV82na9XJIfDKSpceOSsSIrldFqIQMgS/MzjsASRYocGCYJgSW2WZVkr22UdGw0M6e/vx8DAAFPYOnr0qGW7vr4+g3sulUoZEq/psVFhUA/LWWjuR5gPv98PABgcHDSIjuFwGJ2dnRgYGEAwGMTJkyctx5RPdARgEAHN2+7evRtr167F7Oys7fYjIyOIxWI4duyYYXksFsPPf/5zw7Woq6vD2rVrbXtiuhVkk8kkwuEw4vG44ZykUimMjY1hbGzM4DKlgT+AWmre1tZmCI+xK3FmuYLdlkObk7Lb29uL+h4opCybw+FwOJxi4V/vx4axhzURDqDBKYLrHnGF9IicfHISEJETGGVAIdmOhoRobkiLODg1DdzZhRC+hVkU5uTSnJZZj9wGmI+XgSRB7hnEUOcgTvziBAAY9mvehu2AlFGefhPpyTRCGEIQByzbqF/VZGxW6bZtia8soWRyP5rwV1pJN3UPXo6P2Yppiu5rwWJdMAjM2Aua+eZtJoTXcUnwTpR6j0PoiAAf+hBw5xcKTkhfjOi4WAigirE7dqgL3IqOlOPH1bJrSVJdi7JsFXjzuRezfVctvSLNzkgOh1MUuPDIWZEUy+m0EIGQJfiZ9x+JRLTAD6/Xq6VOm0vCF1Iyrt+mtrbWENyid9/ZnSN6fGbxlGIW6mpra5kl0TS1emhoCE1NTWhra8POnTsNIhghhOnMq6qqKsjxWF9fj1deecXS//H48eMWB6SZ8vJyzM3NGX4OhUKu9292gIqiqPVlpMTjcea5nJ2dtcxtamoKH/zgB0EIQSwWw8zMjOP87aCl3rQvJBU+9c5Ss4ishwYDUeh9oS/Rr62tNRy/3l3s9B6hYwwPDxuWF7sUuthiPofD4XA4+ZjZO4N4TzzrkjN+cEkgu+oRV2iPyLmhOWtJtQTMvzGPQHsAiYEEIAMblYdBMjpxUJagQMAGPGwsz9Xmay870dLroQ8PoWyyH6vQnzfoRRFETE+eZ3FKmh2L+hmYU641Vx+o2GkVx+awAUnUIogD8GLGIEJa5mTan76ke0AnyCawCT5MMsVRCSWQ4c+OkIEHc+5EO0IAhw+ujTNzu46C8pns89Xuo8CuXep+FsCZEB01ZN17pRDREVCPl24jSTnRsVD3oq7vKofDWVq48MhZkRTD6ZTJZDA+Pg5RFCGKIrZu3epqHFmWoSiKFo6iD3ChDA4OamJNMplEIpHQEqQvueQSbb2FlIybt6HzoFBxJ985sktQLpRUKoW+vj4QQixORpboSF2Kg4ODtuInAK0sNxwOW/oV6vftlOodCARw44034vHHH9fEvbm5OWzZsgVr1661dX06Ucj6LEExlUqhv79fE5m7u7vzCo8+n8/2OCcmJtDV1QVZlvHjH//Y8Jooinnnaxa/9eea1beTpoI7ieVmpyNlxZdC63sQNTerZTpFLKfjcDgczvLn0I5DAKhQNWUU41z2iKM9IjUxUQIU0dhzUU95c7mlpBoCkJ5MIz2dVpeLQLnEFkMDeNM6CQEIdAQc51mxvQItX5lD2R13gdg2k1RRBBGQgcO41TDPDXiYvT6AWVyYdTQaeyuGcAAhDNmIu4AXc+jJCqn60nIPZiz9IAkAGR4QyAZ3KrKC7GHcgg142OKs1CNiHh7Ma0E77+AmnIdH84uPBboQC4Y+4y31fhi4El7zlZnT9wqr12JlpZqQbX6O9XqBtKlvgCznUq+5e5HDWZZw4ZFTdMyOvELWd+v6K4bTaefOnZo4KEmSVoqcj/7+foMIRgixbGfn7Nq/f79BeFxIybh5HX1KNZArG853jvROOXNfRj2jo6O2/QT1jIyMWNYLBAKWfoydnZ3weDxob2/XegvGYjFLcIyiKFo/wEceeSTv/lkoioJ9+/YhbXpAoWKdnaC51PT29mJkZASNjY2WQBrA6hR1ElfHxsbw7//+76ivr7est3XrVgDqfZdOpw1j1tfXa/Og154lZJtRFMUgfI+PjxuCcVhl/jTde0WXQpsTE2OxXLIiFx85HA7nnIG6D3OpyzQ4Re0X7aZHnJ2DcW5ojrm+VvYsKprImNXODOIlSwxVICCBTZYxiUCw8d6NAJzLvv0/+oaWcG1BFIGODshvvI3pyfMMScsUVTxk8wbuwGZ819D/kZYAb8DDNscDEKhl2LNoNpRLN+OvUYUey/ErIBAYgmwl+lCFV0CFT1bCNDFtAxDUYReQdVkuB85UyXReqEhoJz7ee6/6XMXqtXj//cCdd1qXNzQAr75qHCd7H3L3IoezfCk8BpjDyQN1O42NjWlhJW7X7+3ttQ0JKTZmd57bvoNuxEI7Z5fZfcYKrtEjyzJ6e3vR3d2N3t5eyLJsWcfn8xl+Ji7LLagw2dXVhUDA/hNvcw9Bp/XMwlcgEDDMN5FI4LHHHkNPTw96enqwM/uA0NnZia6uLovoRUvH7UTRfMzNzaGvr48pznZ3dwMonguPhu64hZaqA6oLVI/X6y1o34lEAkOm0q5gMIj29nYIgoBUKqWJjnQ5IQRHHnkE7/7qV/EHf/3X6Pz2t1F78KDjfsLhsEVkj0ajlveu+Zw2NTVpc1mxmBMTJUn9mfYn4nA4HM45QXlzOSCqvQsH8C1MoQNJVCNefRnw4ouuXFZ0DANidjkDWvZceW0lfOt8qLy2Ep7VHpgrnw/jFqiFy+rfWyq6HcathvU81R60vNiCiisqtLLv6d3TSI2lML17GgNXDWBm7wxm9s5AfnmQXWLt9wO//CXw0ksY6tiJIfHrFtERUMVQxfRPTgVqufQG/AQhHGD2eQzgTRzGLVB0sicV2LyYRQvuQgi5Z58QhuDHBJBNz1bXV7c9hbVMiZAgA73b0l25swIvZpeV6Kj/uthx3OLqXxvJpL3oePHF6nuF9lq89lpg3Tr164svAp/7nHX5d74DHLBxpi42FGbvXjWwZv169evevYsbj8PhGOCOR07RMQtx+USrYgXFFIq5z2BVVZWr7dz0l6TOrqGhIYMYV1NTY1hP3wuyqqoKkYixvMYumRoAszQWsIpYC4UQAo/HY3ELstbzer1MV14sFrOIifF43DDfsbExKIoCRVEs98rs7CyOHz++iKNgz1Xfs7AQsdCJqqoqx3vX6/UyzyV1X9o5P91iFrUbGxuZ7sNQKIT29nb85hvfwPUPPAAAEGQZpbOzWPfaazjwr/+Kg+Gwdk/W1dXh6NGjtunXemjIDk3UPpgVMmlPzBUtPA4NWct9JMlVLy8Oh8PhnD3o3YezUjOGxK+DEIKWJ1qAK9jhME5jUAcjITkHIotc4rTKYOegoZciAMyKzTjY8f+h9o3vwT85ggQ2MV2IF9x/ASqyc3Uq+waA9TYuSnL11ZrIynRwZmE5QxUA5XgH5Xgnu8wcEKO6NKm424R74cWMTiBUOy824V4M436U40004sHsa3QM9f9HcSVq8QJzbizxLF/oiuqKVJN+lkp8dOtgpHtfrNvxtDsmRRH43vfU7x96CLjvPmBqCqiqUsNyqHhv7sGYDQC10NGxuLJqc1VLNKr2zly9Wh2bt9bhcBYNFx45RccszDm56VjrF+JAW0iZNqWzsxM7d+7UBJZOuz9mJtz0lzQHdVCoKEiX68tco9EoBgcHDeXRdsnU+nVkWdZKpqlo1dvbW9C50AfUUBRFcRQdaTmwoiiOpcAnT57Mu/+RkRGmQM1a1traCkIIhoeHmft16ofImqvT3Athenqaudzr9aK5uRnj4+O27lj9NaVOTIooihAEIa8AvHFsDJfu3g3fyAhSjY0IXnSRNj7r/bX1P/8TgCo60q+KIGDt97+PX912GwD1nly7dq3WQ7K/vx/RaFRzPppFUhqyQxO16b1Ne4Cu6CCY5mZ2DyIXvbw4HA6Hc/ZA3YeHdhxCoiehRZocuv+QYzK13RhaefO9GzUx0A124uWab34EivIRvHTVAJQMQxgTgMknJrHuc+sA5C/7ZgmHgLGkvLy5HKloyuLABHLOUNqHMYFN8CCedTrmErJzidFGl+YsmqHAy3BFAl7MoBVfMCzTf68AmuhYLGFNHSdTpNGc9lG89ZxwFB2rq4HJySLsBWrZ9Zo1xv6LDz0E3HFHbp3JydzPt99uHYP1ITAAHDmyuLmZq1qoS3NyUk3P5q11OJxFw4VHTtHRC3NuejwuJihmIeEsFI/Hg+uvv971viiF9Jc0pwrTn+3CN8zClFk0qq2tRU9Pj5Yy3dDQgLa2NrS3t6O3t1cbk6Zou5knDcuxE+zslpeXl7sqwZYkCYFAAIQQ25LpQsU/QojtNqtXr8batWstbtNCCQQCCAaDmlg8MTFhSXnWY5fUnU6nQQiBKBprqmjfw0gkYrim5eXGMitJkvIGxNQePIj/pnMvlrz8MvB7vwfs2YPWyy8HYHx/ybKM0oMHNdGRQmQZvpERwzJ6T5rvWXOPTnOfUHPrAiqM5/ugYDEfJiwp99zD7kG02NIeDofD4aw4KrZXYOM9Gw3J1NO7px2TqVljsIJkKE59F+n2TuJly54WDFwzACVpEh9lYy9JZnCNrux7OtaMAckoHE5degcadA6z6g9VY/qZ3AewWuALeRMJZRMO4xZDqvbl+BgzNEaBgCl0WFyazCAf5MRF+r2ZfO5FFm7WX5b9FBeI7bF4vcACWx0xqaiwCoT33cde97772MJjRQVgrrqhHwIvJgDQTtAEcs98O3bwHpIcziLgwiOn6OiFOUmSMDAw4Hr9QjlTZdpusXOb2c2ztrZWSwyura21pGcDMJQp651kCz0X/f39jn01/X6/RcDz+Xyue0kCqnORHk86ndZKeCcmJqAoikWgdeLgwYMIhUK2r9P7KRaL2ZYEu50zPfcTExMGUfznP/85UyQ+fvw4U+wcMYl5QK7vYW9vr+GaxuNxR9cmi7annwaQcy8SOdvfaMcOCDt3Wt5fvb29WLNmDdYdP24UH0URqcZGw7qzs7PaPanH7L7VC9+AVYitq6tz9UHBYj5MWFJoDyL9Qy1PTORwOJxzlkKTqQuB9l2k46diKaao6SReVmyvwKqrV1nKsc29JB3LvhXgxHMnMCs2Y0j6uvZa+23zatlr9u/hyembAWEjIKuiYwvuUrsrKjJ8mEIlejGAb2EWapUAMzRGEBGvvBRD019l9q5UXZdWoczpaTSfiMh6fbmIinZzzzlDVVzNl5DCk6/zVNoUpTzbrr8+a/lDD1lDZQD1uG64YXEBgKyqFj28tQ6Hs2i48MhZ0SymTPt0YOfmNM87GAyisbHRkhish5ZTm6F99WSTe40KRnSffX19Fqckqwegz+eDJEkQRRFbt24FIcSS/JxKpTRhTBRFrFmzBoqiOIqdExMT2ve0XDccDjOdnxSv14tMJmNIY04mkzh27JjtNvQeYKVFF4re3ahPcF67di3m5uYMDr+DBw+isrLScJwU/XrBYBANDQ1QFAXd3d2YnZ1d1BwBoGpsjOletHtIisViOPKBD2Dda69BFgR126yDL/hP/4T20lKtDQANwTH3DjW/18z3eiQSweDgoOHe32n6pJh1vyzrDxPMvYY4HA6Hc85SaDJ1IRRL1GSmYQPITGfwm/W/0ZyU+ZyT+tc23xBD4M4PGkSeemk34llhcQMezka60DJqNX57Ax7WXI/Mvo8ycOK/3Qk8kpu/5pzEm4ij0ZB+nY98wh2wMEfk6cI8J7PQaJfCzcTjUcuH81TQLGZ+jgiC2ivRTFUVu5Sb1Xffzh0ZDAJPPGENACzEpWiuajHDW+twOIuGC4+cFc1iyrSXAlaZKMutxZq3IAiW/n566LpmMY2KQ4DaqzGRSBgEIyra2TklzQJdU1MTOnQPB1TQtOupKEkSotEo6urqEAwGkUgkDEKhHaOjo47ORQDMvoZOTkCfz4fx8XGMj4/bCnqFugn16EVIfQ9DwHgd6H5Wr15tcUHShG2zmLvQOfp8Psxt2oTSgQGD+KgIAkj2Icl8X0qShIn6ejx1991oe/ppVEejKH3Xu4B774VwxRVoh3q/6Y9H76xlvddYzmXzz24+KFjuHyZwOBwOhwPkL1FeDMUSNc3l2P71fsR74oj3xC1OSifnpOG1zi9ZRR6dsBjAm4ySaBmr0I8QhjCLZmbfx8O4FbOP1gECEJKHsBkPaUIjAeCD6oKzBtFYfwbsRUfzNizxkeUqXA4CJcud6crH6PMByeSZOQbamuaGG1SXbE9P7rU1a9jC444d1mV27sh4fPEBgPqqlp4edU6CoIq1vLUOh1MUuPDIWdEspkx7KXBTJurUw44lLFLouoqiYHR0FMlk0tL/j9ULj7oczbh1kgmCgI6ODkxMTDg6CBfiTHPrShRFEWVlZUgmk46CXCqVypsInU/Qs0ufNkMIcRQIU6kU1q5di0QiYVgnlUpZronP59PK1+vr6xGLxVz1z6TzqH7wQZCrr9bci4ogqA9M2Yck832plZDX12PnF74An8+Hpia1l9JEdzfq6uos1yYcDi/6vebmg4Ll9mECh8PhcDgsFpJM7ZZiipp64XCwc1BduBgnJUPkIZARwJuACMxLNfBh0iJwCUijBXdpJdezaDb0fQQAKEBIoaXakiksRrYIh3al0nZOQKdtdFOw7ONMi45O+3c9r/Z24OWXizMhN/j9ajhNc7MqOt55pyrk6St0jh9Xn1eDQVVArKpSxb8/+RPreE7uyGIEAOqrWsz9InlrHQ5n0XDhkcPJQyFhF3Zlovox9EnAZnGytbUV4+PjBvGMlmHT/XZ0dIAQwixRXrNmjevSXeokM5cGT0xMQJZlS2m2WYhajHOQjmmGJiWbkSTJNpim2Pj9fjQ3N2vnwU7IzJfmDajXv76+3tJDc27O6FhIpVKa07S3t9ewT+qcnJ2dtWwHqL0U+8vKkPza17D1P/8TpQcP4sR552Hq859H42WXQUB+UTiVShkcmGNjY1po0WIFwELDYpbbhwkcDofD4bBYSDJ1vsAYSrFFTbrf6WenrcnThTopbUQeoSOCyspKkOcJwPj8VhXIFEPJNYtcqbbdGPY/m5cvtIejOR37TFIU0XNuDnjlldPr3Lz66pyQ19lpFR0B1TlLCHD55UbRT9c/VAuJ+cpXjAnYlB07gKYma6m0JAHT0+p4haZR89Y6HE7R4cIj56ykmMm4hYRd2JWJ2qVYA9a0X7PTLRQKWfZnJyRFo1E0NDQYRCRWKE1dXZ3WY9As9NEQEHNpdltbG9ra2jQxsr6+HoQQWyeknYhI3XVtbW2Wnn9lZWVobGzE6OhoXqFRFMW8ac8LIZFIgBCCrq4ux9J3s2DLckoePXqU2Y+SdV5GR0fR0dFhubbUxUnv4fHxcRw/fhyAmuBNA4lQUYHh227LbZjJoP+RR9DY2GgRjRsaGkAIwfDwsFb6zTq+rq4u2+N3S773z7JNseZwOBwOJw/5kqn1uA2MoeMWKmq62q/18QMAkJ5MY7Bz0FYINZDth6cIIogsQYEAyEDytr9C5HMRyDXTIAxjGqBzRjrAKtVeKAsR2s600MiiKGIhDSAs1nj50JcmDw1ZRUf9vJ59FrjsMtX1qA+Q0YfE0JTr++5Ty66rqoDbbgP+67+A++9XHZ3m7Xt61NAZtyEzHA5nyeDCI+esZCHJuHYCSCFhF3Zlok7bmNN+zdTW1lrmyRKuAGB6ehof/OAHtSAa/Rz0yxRFMQiLtDdkQ0MDMwQEyDkhqSDY39+P9vZ2dHV14fvf/z4ymYxlnixqamq0HpJmoZaKfm5YKuERyF0vp9J38/H5fD6L8OimZJtC+2LalZ8fPHgQn/jEJ9DS0oKBgQG0tLRAFEX89Kc/tR2T9vkMBAIIh8MQBMEi7tndd8XqrZjv/bNsU6w5HA6HwykihQbGFCJqFrRfBkpSwfTuaVsh1MD27Uh8++dI3nFfrj8juRXxO/2oV8ZQMnkeqjDBFA8VCEhgk+N8WYnXi6HYQtvpLrtein0tufh46aXG0uTmZsCptZIss8vAzSExt9+eEyD37rUmWctyrjcj3R4A7r4beOkl9r7NZdXUYcnhcIoKFx45ZyWFJuPKsozu7m5mCXQhYRd2ZaLmMfQiUCQSwWOPPZb/oLL09/fblv9WVVXZzkG/zOzkI4SgsbERLS0t2rzM4her7Ji6Nf1+v0V4tKOurk4TecfHxy0C4sjIiK0LT89iyrwBZ+FSlmUtTTsYDOLkyZN5RU5WGXQhBINByLKM8fFxx/UymQwOHDiAoaEhrF692lbg1ZNIJJBIJNDe3m64D5xK+yORCHp6ephJ6IWQ7/2zrFOsORwOh8MpEkuZgm1GX9Kdnkw7io76ubjt9/jGk3WYFr+OkKSmTm+V/x4JeROO/I9PQxJuQaXcC4CAQNH1ShSggOAwbmWOSROsg+QAoMhFE8ZYgTLLYSzW2HZjLnZ/+QJ5is4bb6gORgA4cgRYv37hY9mFxOzYwQg5grrMzMsvs0uuWeIldVhy8ZHDKSpceOS4YqWVQxaajMsS86gAUoywC7sUa0B1nDmVFY+OjhoEH7MwQ0NJqqqq0NnZCSD/9WKdH0VR0N/fj4mJCdTW1qK1tRUHDx4EoIpOLEGI9oJ0K7p5vV40Nzc7OjxPVy9HJyExGo1i586deYNqCiUcDqOurg6jo6OYm5szpH8LgqBdMxbz8/P46U9/CkVRtHL8aDQKn89nWC8QCNgG05jHFgQBnZ2d2LlzJ6amprR7yOPxoLe31zYJvRDyvX94ijWHw+FwzgWWMgVbj7mkm4kIEA+BkjSJNCwhlOEImxsiCEk0BEYBgQwfplA504sBfAujuBMX4AfwYhYKREikBHHfVryVvAWzaLJMJwTdWIoMhRAQRbGkSuu/d0qtzvV4FAAQHLn4S6gLvgRv3y+BAqpRzOOa51JMAc/puBa7j4X0uVwwgqCGwOiDYGIxoxOxEERRFS7NfR9ZSdZOUNekeZlZvNQ7LDkcTtHgwiPHFSutHLJQsZAl9lABxCnswq0g6zRGPodXPB7XyprpvPRCzerVq9HV1WXYb77rZT4/27ZtwzPPPGNwfLa3t+MTn/iEdpysfofRaJQpcgWDQQQCAUxOThrKjdPpNHbt2rXsRGsq3uldlFNTU4set6ysDKIoAsj1xBwdHWWes7q6Oua9QAiBoihIp9PM0m39nMPhsKNwqxf16L07MjKibRONRjE4OKiFypgZGRkp+MOHfGExPMWaw+FwOOcCS5mCrSdvaXV2v4GWAMgrv8EG+eFcybRwC8Tm9+bExp4eVUDKikZKNAbs2o1Sz4M4XwuBob0DZQACNuMhBDGSfU0BIEPEKUy2fA6zPRut8/ICG/EwSFo3VvaDWX2q9Bw2QEIZQng9O64RuuQkNsB/cTU8MzGQbCLxebTsd+9e4N3vZp6WQpKjie5rscXHFQ9LXKSC3qWXApWVak/HQkTInp7cONSV2N5uDTlyEjdZrkmWeGnnsORwOIuCC48cV6y0cshCk3FZpdA0fMVJZClGcIZTH0GK/nyby2Oj0agmTNL9DQ8P224PWM+PJEkWMUy/jVN5txmfz4eGhga0tLTgscces4hlsVjM0rfSLbSPosIoo7ALswHYwS96Vq9ebTk+t6XjTlx44YVaP8ve3l6my1MURZSVlWFsbIzpHA0EAq5doIIgWErQCSEIBAKor6833NPmPp+UkZERtLa2Mu/LeDyOeDxe1A8feIo1h8PhcM4FihkY4wSzpBsA8RN4q73afsXBl1D2ssmxKPdivumfgKv+2ugEo8Ek2TCZ89M/YYbAEMgI4bXs97llChGxEQ9jnNxrEV5b9rSg4oY3gUn2Mxwt006iFofJLWhVvsAsHabrluEd4NUjwK9fVMtlzSnJF19sDCDRbWtHIaIkxwZJUsuuX3pJvR5uxMdLL1W/9vRYXYmAmoitT7KWZaC8XE3x1iOK6rU3Y5PQzlyXw+EsCi48clxxpsshl7rU2+y60osyTiJLMYIz9Ptm9VEEjOdbEATLsdP92pUwu7leZjFPL+I5Cc00NXt4eBipVAqpVAp9fX2IRqNMwUxRFMt4gUAAAGxLhCmpVIoZPkOTsllCGmAf8iKKIiKRiCWhGnAuxXbL8PAwtm3bhqGhIYsYrN8PFfQoPp8Pfr+fmUjuxMzMjEV4VBQF8Xgc+/fv114bGxtDMBhkjkEdtq2trVAURevxSF+jLPcPHzgcDofDWW4UKzDGCbuS7lVXr9L2PbN3BvJ9X7E6FgURZT/8mlF0NEGTqVkhMLalwrIE75HXLcLr5htiCPz5+4xluXb7FN5EfdV/AMeJ5oik+wRMQicEpO/+O3gf+HtrDz+X6I+lUGejeU52y1Y62jmhz+as/op6kklVCL7nHmDXLvY6Xi9QkRXjKyuNoiOFiph79qjBMfpgmlOn1K/U/SiK6vz0KduUbEK7Jl46rZsPHlLD4TjChUeOK850OeRSl3qbXVfmsmI7kaUYwRn6fcuyjB//+McG8cjn82nnmwqws7Ozlnmwxvf7/WhqalrQ9dILfOakZRqOQ52Lo6OjFsHr6NGjrvdVUVGBzs5Oy7GzEATBIgr6/X60tbVpyd12Ai6Ljo4O9Pb25nWdArnzfPz4ce38rF69GnV1dZiYmMDs7KxBPE2lUnj88cfzCqpmqqurEQ6HNXdoS0sLXn31Vea5odci3zGbt3UK8InFYhAEAR0dHbaOTd6LkcPhcDic048+OKa8uRwb79loSKHOV9JNe0BelhmxOhZlCZiacnSiKQA8mIEH8ezPQlbscxDVsi4yg/C6dy9w1QcBRoWJZSxRhP/aDviHhiziFrsnogxlYMi+h5/Hw9yv07iFiI5L0adxuaEAkAIBiCUlIJs3A/E400lqYGpKFYL37AFWr2YLzul0bvnu3eq9SIjxuguCKu5t366Kk2bXoyAAVVWA36+ud++9xpRtyvbt6lz0gqHduk7wkBoOJy9ceOS44kyXQy5Vqbedk9Ktw1MvyNbW1mqlrFSQMwuEtFeinWtTEASLc6+pqUlbz+xopAnEdB7meTc1NVmuG+uY6Vh6gSwcDtuet3A4rAl2diExhTgG6+rqmMfudtyGhgaLgEvLwycnJ23FTNp/MRKJYHx8HFNTU/B6vbZCoSiK6OrqMuwjFoshFotpyeCDg4OGOZrLp2nPRidmZ2e1dOuxsTH4fD7bYxAEAV1dXcwenE6kUilb0ZJ1v5s/fGhubsZTTz1lCaXhcDgcDoezNJiDY1KxFE48d0ItV86Kj/lKug/efRBKRmE6FiGKqpAzPW1wmeWSqbOrIY0QDkABkPBciGDmdYuIaRiT5SKjoiADs+iobX///YCLD4oVCJjDBfDZ9PBbSvfhchMYlyzRuqICBx94AA0NDRCvuSa/2xHIiYh33+1uH5LE7tsoy8ANN6jfs66xLKui45Ej+fexffvig2R4SA2Hkxf+r0TOimCpSr3tnJRuHZ56sUsvwpndczS8RB/eMj4+bgmFAWBw7pn3bRZcQ6GQQVjUC2hVVVWIRKzlPOZjHh8f19x7ra2tOHr0KOrq6hCJRNDb24tYLGYRUPfv3w8AhjLcQgiHwwiHw5iYmDAcY1tbm1ayzYIl2gUCAbS1tRmW0evS09OjCXgstm7dCgAYGBjQrk0ymbQNejl27Bh6enrQ0tLCTL0eHx+3pEqXl5cbfvZ6vczjCwQCCIVCUBTFMq6TC1SWZaRSKczMzBiWO/W8pExNTaGpqQmRSASDg4OO97v5w4ennnrK0Gd0586duP766x33x+FwOBwOx558bkZLcIwEKKKCQzsOGUq47Uq6Z/bOIP6y6lQ8jFtQiV5AcywK6vPg/fcDd94JRRCzPR1VydEsWNEwGV/jGky9GkAVeqxl134/cPXVOReZvhx1ctK2nFvbV3U1sHmzuvCmm9R04zzQp8TJlttRiYdshUo34lsxg2OKOZZrSkpAUikoslz0IBzE49jy2c8CgUBe96gBSVJLo922zLJ7lv3Sl1SH4nLo08hDajicvHDhkbMiWKpSbzsn5UIcnk4uTJZwpA+F0eO073wCrF5Ai0ajeOyxxzRHJBU4zfPUi1y1tbWQZRnDw8M4cOCArfMvmUy67jtI8fl88Pl8CAaDEAT14bazs1ObF3UQFhrqQsfTj0Hvk3zCKBVmR0ZGDMsTiQTC4TBTAKT9K+3KmpPJJHw+HyRJQk1NDd7//vdj165d2vr6e4EGywQCARBCmPvMRzQatZRzsxySoihizZo1hvGTyaQmQtN7LpPJoLu7O6+T0VxKX0hpPYfD4XA4HCNu3IzM4Bgpu9wFh3Yc0r6fRTMG8C1sgJpqnaxuROiJbwBXXIGEcgFSf3YfyuU3QZCGF7PMJGkCGSUzo8h899+Az3dBUbIipiCCCAR44YVc2aq5HNUBAqjC1ObNQG+vsYTVKblYO7YtCN9WB/xpj/34LmCJdU5uSTt3oZ3gt+Ri5Pw8QIihV2WxILJaXg+TOcE1haRas5iZAa68EvjOd4rXp3GhLAfxk8NZ5nDhkbMiWKpS72I6Kd2kU5sZGRlxHZgjyzIURdFCQRoaGiwCrFloi8fjFmHJaZ4DAwPa9+YegMFgEKlUyrE3oB5RFFFaWopTp05BkiQteIYKZGNjYxgZGdGEUbtgHD2sEuVEIsFMaqYlyk7s2rULa9eutZRDnzp1CqFQCOXl5cykaSeRWR9ks27dOng8HlsB1xwsMz4+7ljiTjG7Gc1zZIXpSJJk6AWqP5f649E7OZ2cjKIoGkrKadk6h8PhcDgrmXyuw6XCjZvRLjimvLnc1T7MAuUsmjGErwMAWp9oBa6oUAXQL5RAyajLL8fHmKIjAFUETCYR+OofAe9Se0LjyBEQVq88czlqPmQZGBhgl7BWVKjCEwMCIFAxDfGJB92V/+ahkH6NZpFRX57OEhntximqIFmEc2DHaXFwmvs76pEk4L77gFWrcss6OhbWp3ExFDOkhsM5S+HCI+ecpphOSnO/R0AVAlnJzhQqOunLvO36Tvb39xtchoQQg1Apy7KtKKgXltykaLNobGwEgLziIEWSJEvfSDN6YXShfTv15zCf0Gjm6NGjzOOXJMmxRDtfj0ZKLBZDf3+/4z1ghnW+gsGg5opklWKbA3fM5d2UgwcPMueiF9ynpqYMr5l/pmzduhX9/f2Gn4GlT6DncDgcDmepcOM6LAqMBNy5IZLXzZgvOCYfTOESQPDSoNYDUhNAszB7QVJkORdGMzamii3/+38D27apJdv6hF9WOSocRDb6gSarhBWwFaQUCDgxcz4qf/sKhMW66hjkE9tY4mKhidhFL4teqVx6KXDbbcDtt9uvQ4NoqNh3zz2nV3QEihdSw+GcxXDhkXNOsxgnJUtgMY81MTHBFHqoO0wvFlHhza7vpFmYGx4eBgCDMGnXC1AvLJlDWB555BFHYcwcYEPnWltbaxFWzS44t+W39BwW6hg1Yz7+fAJhIQE4djj1UqRl64sllUph7dq1iEQieOyxxyyvm4+jvr4egiA49ssE2KnnVVVVBmGzqqqKuW17ezsEQbCI9kudQM/hcDgczlLhtofiorBJwK1p/x7GYhsd3Yz5gmPyYSdc1n+zXlvHXM5t7QWZFcQqKtQkY/0zkKIAd9xhFA1pwm97u6UcVcmKh2axTcm25EFLC9DTYxUfZ2ZUt2V2W2jbC1BAcFi4FaGT92K5fOxZiIBodkues+LjpZcCL72kfv/DH6p9IZ0oVqAL40MBV8nUxQip4XDOYrjwyOEsEJbAQkuGqRhTW1vLFNNYgldtbS16e3stQhUVHM3CnLk/n1mYJIQgEAgwS7L1omkgEHAUHs0BNvrvCSEGB6S5h6CdsGfuQUiFq4GBAUv5biQSKbifZDAYhKIojm7LYlFeXm45f4QQlJeXu3aT1tXVaeXSrOtBr/X4+Lgr9+Qbb7wBwCjE0kAfc2K6WRTs7OzEzp07tR6P73vf+7SQIb2D0Szay7LseP9yOBwOh7PcWWwPRVfYJOBuxMMYJ/caRMEKDOPi6f8C1r+uiSAV27cvWAR1I1yaXZG0F+RG78NYVfEOhI6I6ua66SbbcmeDUEgFIUB1pNFyVF2vRn1JchrlOFUZQejJb6jn6cor2fswbSvBixNoxWHcilm5STdi8TjdQuA5KzoCxkTqBx5Q74N8hoHFBrrYfCiAPXvciY/LAbNw+j/+B1DurhUDh7OUcOGRw1kgrGAasxjZ1taG9vZ2jIyM2ApG1HWmKAqzjJm6Fal4ODw8bCipthMmFUVBPB63lGQDsPRTrKurw7Fjx5hCoVPfS3OpeiQSYaY9A6rYWFNTg7q6OjQ3N2PXrl2G9G1BECzC5Zo1awCoYhztFemGZDLJdPqZHZl2CIIARVFclVSzxM1CRc+pqSltvvF4HOFwGJOTk5ZejW4dpKx7TRAELf17dHQUyWQSBw4cgKIoaGtr0+4Rj8dj6OnISmtnORjtenQWK4Gew+FwOJylZrE9FF1hk4DrPfK6QRSsWT+C+p4vgvSgqCKIJfF6716gMydUbP7QF9H7XIlBAI2TbRD3PAtB76xcv942MdqCJKlCkr4cNZkEJo9r/SOpY3EWW3HA/w1cQctUOzryut0IABk+rV8lROBU5VZ4p15afIhJlnPafegWWmr/Z38GMPqNF4Q+mGX7duDFF4G771b7fgJASYnVcbvYQBebDwUW7aI8XTCEU+G551D+L/+iuoc5nDMIFx45nAXCCqYxi5ETExPo6uoyOCHNfRWp66y7u9uwrbkMVu8wM4uGQH5hUo95mZ3o6PP5HPte0jllMhns3LkTw8PDtqnUPp9PS7Hu6ekxBJj85Cc/QUlJCTZv3gwAmiBZV1dXsNsRYKeIF4Jd6TRF79h02+/RCfN8CSHMOeQTTWnwkF0fR5omTl/Xp3QLgsDsyWiX/K5HlmVLMjirjJvD4XA4nOXMYnsousIhAdcgCnber35dShGEIVQEnnsO7d/+Od54sk5zRVbfUI1D9+dckps/FEOgh50YzYQKQvpy1PXrLaE1BDICeBNyUsZQzb9gA36C4NQreQU/BYCI7LOvAEACDqVvQbPyMiCIIPLiW+sULDr6/aq4epbCFGIVBfjRj9wHCDkxPa2K2/pyZ1p6DeTuXUKKF+hi86HAolyUpxMb4TT8b/+m9srkcM4gXHjkrHjOVJgFK5imv7+fmZJt7qtoni9dV78tqwzWvN/a2looiqKlOtPXWMKkHvO+7AStpqYmV+fSzuWoJ5FIoL+/H+3t7Zb07XQ6jXQ6jYGBAbS1tWHt2rWIxWI4ePCg7XiBQMDiKnQS3gCgpKSEmVJdDGh5dSFOR7/fD5/PZ5nvzMyMY5m6JEnM10OhEOrq6gzXX9+jkyUQAtCuHcvRaBZAWYIoK0DH7v7lcDgcDme5stgeiq5wm4C7CBHEdTK3jVARePJBRLICIStwJ/nMfSgX8ohx+Y6vuRlKNGYQBRUISGATyqb6sVW5CwSKsa+kDeprGbSJd+CgdDtmhWZMzVyEfuFb2CA/jCryCkiBHxQv2uFIzmJ/ZLa/JjNtemAAqKrKhb4sFOpyjUbZTt+lCHRx+FBgRcD4nUEkCaUO/57icE4XXHjkrHjOVJgFK5jGTUq2XaCN24Rts/OR1Wcy3zitra1QFAWDg4NMAYsVKOOEXfKxmZGREcRiMczPz9uuYzcnPT6fDzfddBMGBgY0EbOhoQFtbW22Jb8ADKKjz+cDIQRer7fgXpAsR+VCeko2NTUBsCaFO52fVCrFFF0BtTR9fHwcoihCFEVs3bpVC4GRZRnd3d15e0SyeoU6/czaJhgMcqcjh8PhcFYkllLkYuNWMFmgCFJQMrcLcZMVuBPAm/YuQlEE/vmfgSeecD6+e+4Bee45KBBAZDnrfZQxiSuwQXkYBLKhDDsfBEBQeg2t+ALm5A2QUIYS+RgS2ITp2utQFdvlYhTjeEy8XiiZDKAozvNyeJZb8cgy4PEANlVO+MpX1JChYu0LYDt9qYOW9jW86abCAmHMfOhDwC7dfSIIi3dRnk4YvzMUUcSp+noEzuC0OByAC4+cswA3paCni8WkZC9kW9axuxmHltyaBT6z4OjWSWpOQrYjHo/nFb7c9GBcvXq11rOQEIJYLIZoNOpKWKNQ8TC5iDIYQsiCS631orBTD1A7wuGw4ZwHAgHs379fOy5JkrT7AVCvpfkaiaJo6atpdsiGw2GMj48bfqZQ9+7s7Kxhm8bGxtPiOuZwOBwOZ0XiJgHXrTPSREHJ3C7ETVbgTgKb4MMUCExVENXVquB4xRXA5z5nnZw5+OLP/gzkgQcA0B6PBA34DiSUWMqw3UCFwHIc1n72YRIo4j8NlHRaC7RZ8X0fS0oWLpBmMuzjb2kBbr9d/b6Y4qOd07dYgTB79wJf+IL6HqPP9rKs9qxciItyoenYi8Hmd0b0M59Bw9LumcPJCxceOSseVq/FcwWnY89Xgm4WLX0+H2688UZ4vV4AzqEi+rFra2uxZs0aHD161FE0dBLpRFFEWVkZTp486Up4jEajeOSRRxAIBFwnRy8WlstwMf0dCSHYuXPngns5mp2HLAfk0aNHIcsyBEFgnqeWlhZLErvZqejkoDW7Swt1ynI4HA6Hw7FhgaWkBSVzO4mbWeGkY7IPcWzEYdyCWaiC5GHcgkr05von0u3uv1/9jyW2PPQQ8PnP50SdaFR1lxnSrVU5T0RyUaIeMX1fzHxrovta/Nzs04yT6FhRYZ9arsNynWgvwdtvB+67b/El15T164HOTkDfW7SjQ+0FWYxAGNp2wBxW88QTbBHdiTOVjs34nSH/zd9grqxs6fbJ4biEC4+cFY/bEuWzEbeikL4MWx9yo4e6CAF2WIheqGSNnQ8nka6lpQXt7e146qmnDAKZPsTFjBv3ZKE4pV4TQmxLnBcCSwjM16PS7/ejqqoK8XhcW9cJSZLQ39+P1tZWzJgeHsvLyx3fK2bhmgYD6TGL16FQiPd15HA4HA6nWLhxRpooKJnbTtxUFE048UkSqjCJSvRiAN/CLJoxi2YMkG+hvuo/EPIfVre74QbgzjvZYgtgdb/R51DT86HqopSL6iRcKlfiinY75sPrdSynpsKr5Rzohbpillz39FiFwWefZaeWLyQQppjBMmcyHdv8O0OSckngHM4ZhAuPnBXPYsqbzzSLDcZxOnZWGbbZoRYOhyEIAmpraw3rssJC9G7KYpWzi6Koue4A4H3vex8ef/xxzM3Noby8HB/96EfxH//xH4tOqXaLIAi2wuPJkydRWlq65HNoaGiwTfL2er2aYJlIJLTrZ05K10OXm0N1BEGAIAi2zlY3vVPPZbcxh8PhcDgLYolLMAtO5mb1yUsmVUFHcyLKAARswMMYwtcBALNKM4b97bjiSNaB2dlpL7YUABWzVnwZ80onHgfa29Wvr75qedn2+uiFuttvV/t9MrZ3DSHARRcBBw5YRUaW6AgsLBBm/XrAbKZYaLDMSk/H5nCWAC48cjgMljopm46v7+1XjGAc/bzNjsa6ujqLYCgIArq6uiBJEgZ0n4blCwthlQcvhEgkYjjeoaEhzVGYSCSwe/fuJRMdRVFEJBKBoig4ePAgFEXBqVOnbNeXJMnidgwEAjh16pRBrFxM38d4PA5FUdDe3o5oNGoIrCkvL7dcl6mpKTQ1NSESieDhhx+2Db1xEorNr9EAoGPHjlnWM78vIhG1VxSdaywWQ29v72lLludwOBwOZ0VxGkowF5TMbZ4XAwIZAbyZW2B2US5GbMmWeuvFLIOopSvHXi7QJ72zVhxNJlWXISHAxo3AoUOGl22Pmwp1VMg+erSw/QqCmort9+ccuDfdZHtfahTYC9XA3r3GEm49CwmWWenp2BzOEsCFR85Zy2LEw6VOyrZLXrYTiNwei52jkW7T39/vyqFmdrLRsBA6j+PHj7s+VjuCwSDa2toMy8zH77Z/o12JtFOpdk1NjZaCvZCSbZ/Ph1AohGAwaJjnYoRHADh48CA+8YlPWK4561wkk0n09vZibGwM6XSaOR51tJpL4uvr69Hb22sJhrErYZdlGY888ohBKFcUBR0dHY79QFkstbDP4XA4HM6y5DSVYDomc7Mcl+Z5MVAgIIFN6g8sF2U+sSUatYqHhADf/a5anvvssyAscVEQ1HGKKTx6vQB9Bj1yRHW7vfxywcOctaIjhd6fLtsqAcj1B80jZDOhoiENKKI0N7PvH7pNRwdQWVlQL1QDdq7cjo6FBcssMBiKwzmb4cIj56xlMeIhq0y5t7e3aEKJncBoJwS6PRbzuMePH8fq1as10Yo61Mw9IWVZxvj4OKLRKMLhsO16doLpQmAlH5sFT7eYk5kpetGxrq4OhBBtvVgshu7ubkxNTRW8Pzq2Pu2Z4iQ6iqIIURTh8/lACGEKfMlkEt3d3Yby6bGxMfh8PttxnRyNdXV1ljmFw2EQQizBMAC7v6TP52Oe39HRUXR0dDBdk07vkaUW9jkcDofDWZac6RJMO8flqlXOApEoAgCmOu6A74iP7aJ0ElsURX1NUYw9He++W+0H+LnPAZ2dUHbvBtHPQxDU9W0+XF0wa9YAL71kXFZTU1AQylkvOlIkyb14WFWlXi8XQjaTLVuA730vJ/ZRkfy3v2WLjoSo/33zmwsTCCms9yWgitILYYHBUBzO2QwXHjlnLSzx0C1mAUyW5aIKJebx86UBuz0W87ipVEoTjMbHxzWHmpnBwUHDeiMjI2hsbLQEirBKtUtLS5FOp5FOpw0CFxXZ9OJfeXk55ufnIYoiZFnWSrb7+vowOjqKZDIJr9eLkpISZmkxi2AwiM7OTgwMDGBgYMC2DNxcOgw4OyqpW/TYsWMFlXvTc0BTp/XnRJIkSJKE5uyn/ywRN5VKMcXXQuYgiiJqa2sRDofR2tqKnSYXhSAImJiYMCwLhUKoq6tbkLBsvu/i8Tj6+/sL6j/KXZAcDofDOespcgnmzN4ZY0n1PRtRsd2hpNrOcUnnYRb9dCWv5N570XDFFWiwG9tJbNm7F2hsNPb6EwTgwQeBD39Y3TYrXCqCoDofF1Fere8TCTBEwvXrjT8/9BCwwA+iOTqmpoArr1Tdh4WKjgDw2ms5YdqNa3L1aqs7ciGw+jvS5QtlAcFQHM7ZDBceOWctiwm+MKdFmwWqxYarsNKonUQWt8dCxx0eHkYymbS8Th1qZszHE4/HNQFKLx6xBFlzaAmlrKzMEpRC16Vpy7FYDIlEwuKyS6fTkGUZgUBA20YURWQYyXqNjY3weDwghDj2nrQLjaH4fD6sXr1aK5Wm4y20x6TX67XdNhaLobOz09DjE3BO1TYTCASQTqfh9XqZSdvvf//74fGov+Lt7h/ztdQ7XWVZ1s6FnUDb0KD+86O1tdVyLPlcmOb5cBckh8PhcM56iliCObN3BgNXDagfcEpAKpbCiedOoGVPi734aOe4BNR5mOdlI+rYCp4ssYUKSOZnOFlW90HLzLdvh/z880h86UsIjYyALEII1IuOTOJxNQxnaAioqFhc+AnHCL2fzEK2G6hbcudOd65Jv5+7CDmcFQK3k3DOWlpbW9He3o5169ahvb3d1k3IgqZFd3V1ob29HeFw2PD6YtN7zePnc3a5PRY6blNTU0HzsTueaDSK3t5edHd3o7e3F5FIRCvJzUd9fb3FVcca366/4tzcHBKJBBRFgaIoFtGREGI4F4sVg5ubm3H99dcjHA4jGo1qpedOiKJouTcoToKlLMsQBAGNjY2G5ebU7EAggHXr1ln24fP5kEgkkEwmkUgkEAgEDK9LkmRwOZrvHxqqoy/fjkajGBwcRGtrK+rq6iAIgub6NO977dq1aG9v13p0so7F6T3S2tqKtrY2BINBBINBZgBOsZLTORwOh8NZNlBX4LXXAuvWqV9ffHFB4smhHYc00REAIKlVFod2HGJvsHevGhhihvbIczmvxEO7kHn3dbjwmf+GLWN3QXr2lxi4agAze2fY+6UCEgtzmfn27Tj4ne+o81lk1YPqchTYJdGvvgo884zqcuOi4/KChrzYlT/rmZwELrtM/W/9elVM3ru38H3alVQvpNR67151HouZD4dzFsIdj5yzFirCFQOWQ/F0Uuix0PmZXWjUoWYmEokgGo1a3IeKolhcaI2Nja7KcQkhzFCTYuH1ehGJRAxl2gvB5/OhubkZra2tkGUZIyMjrreNRCJoa2szhK4A+QNmaBm2+b4aHx+3uBc7OzsBQHOI1tbWYnR01CBsVlRUWNK19b0rzfdPb2+vwYlKicViFuehWfRsbm5m3ov6Y6mtrYWiKOju7mY6egVBMPS47OvrK7q4z+FwOBzOsqRIJZhzQ3M50ZEiZZeboa5Dc2WIIOQcl1dckX9ee/ei/PNdKIcCAhk+TKFS7sUAvoVDO1apgTbm8JqeHnsBya7MvLfXfhuPB9L6egiHXs/bZ5FUBIFEYmFlv0uF369eh2L3rTzN6BPILWzebJ8SnQ8qJlZU5A+1SSaNoUD6lHjAGqJklxxfrBYIpyG1nsNZqXDhkcNxQTFFzNMBnS9Nss4nmAqCgLVr12Lbtm3Yt2+ftj7LhUaFMLOoaWZiYgK1tbXFOygTqVQKO3fuLCj5mhDCLNemYyiKYjkm6vqbmZkxiIKBQADbtm1Df3+/ZTyz6GhO156dndVcj+b7Sn88iURC65VI15MkyeIUlWXZErBTVVVley6c0tPNr1FnqZt7iM7RTcr1QvfD4XA4HA4HKG8uRyqWMoqPorrcAnUdmoXHqqrCeuRlxyFQx1G/CtggP4wDQ+1s4UWS7Ps1ShIwPa1ulxVmygcG7ENeBAFob8d4/Bqsxz/kn288bi0hP9Mi5NVXqyIYq/x8BUHL2S3iI+0ZuhgWkDAOIHeN775bFa/dCoDFaoFwmlLrOZyVCBceOZwisRzDMewEU/Nct23bxly/t7fX0ouPrhOLxRyFR5ZwmQ8x+7BSUlKCYDCIRCKBU6dOQZZlpoOwkPElSUJbWxui0ahBoKPp1OPj45Yy8mAwiK6uLvT391ucm4lEArt27bIVPoPBIEKhENOhqBcU9bB6JQ4PD2uv0fuJugPpvqPRqCbUTU1NoaqqCu973/vQ29uLaDQKRVEgCIJ2X9qlh9NUcz3hcNiV6K6/p2ZnZw2vsa6TeQ5u98PhcDgczjlN1lHY3DOIaek8HBZuwazcDIjqh3gb791o3caubLXQHnlDQ5roSCGQsQr96Jj8CPBhWRUYqchIRUdFsRf9enpUEW7PHuCyyxD+t3+zFyplGcorPVgn92AOG1COwwbhyyKEEaKWbVdW5hx4BSRXFx29u3TPHuCaa9jl7ysEi+hYUQE8/TRw001nTuCVJGBgoDABsFgp1E6p9WYnsJMDk8M5C+HCI4dTJJYqHGMpBE3zXGmYihmnEnM78Uqf0G0W7ILBoFbuTV17p06dgiiK2Lp1K1pbWzE4OKiFm7BCU/SwxMhAIIBUKqW5DPWC38TEBLq6uvDjH//YVWhMY2MjBEGwFTidelg2Njaivb0dvb29TIGWNSbtlagvZU8mk8ygH/O5OXr0KK6//nrtZ73rkDI2Nobx8XHNtUpFQnOZ+EKch/p7ygxNMNfft2e6fQGHw+FwOCsOnaNQkCRUCUdRpfRiuPqfIXdcjo33bkTFFYxgmWKVkjY3Q4nGQOTcOAoAAWmIyaMAS0OTZaC6WhUAh4ZUoW1qyihOUlHo5z9H6cGDaqq1Deq+BUgoAyBAgawJYJYnWUlS3XMVFTn345mkrAy4//6c6NTSsnB3X6GUlwM2gZBFY35eFfxY99vpgjou7QRAO4rRAsHufbZ+PS/B5pzzcOGRwykSSxWOsRSCpnluo6OjAIDx8XEQQhAOhzWBs7W1FX19fRgZGcHIyAgaGhrQ1tZmEI70Cch6AdNOXOrv78fx48c18U+SJMRiMQwODjr2j6QuSL3gKAgCPB4PJElCaWmpJsilUiktKIYyMzOD7u5ux+TocDhsOAeAvchql6IdCAQMCdEs7MrQ7ZLJ9eOwQnnMPRHt9ktDZFhl0cDCnYfm/enLy6PRqMXhudLaF3A4HA6Hc8YxlXISWRXtmjueAHZ+zn67YpWS3nMPyHPPQYEIIktacrSjnEfDa6ios3691c2oE4VO1dfDOzUF4vCsRiCjBMcwiy0I4bX8856xCb5ZLITYB+ewmJtTQ22eeQb47neLP5+KrOjMOt75+eLvz0wyqQps3/628X5bCNQpKwjuy+Tpfb15szU0aCFCe6HYvc8AXoLNOefhwiOHUyTM4lSxwjHcCJqFuiLNc6UiFv06Pj6uiYzm0uS+vj7NFdfe3q7tW18iPD4+DgCWPpP9/f1QFIUZbDIxMZHX4RgKhRAIBAzzKSsr07Yzb0/nSeeWSCQc9xGPxxGPxw09FQFVDFQUBYODg46iJSWRSGjinp1oaRc+Y+6VSDl27Bh6enoQiUQsxxAMBhGJRNDb26vdA07BPvp7yCwO03FYJdqF3FNO+yw2y7HNAYfD4XA4RceplNOJRZSSzuydwaEdhzA3NIfy5gA2f/vnCDz5oFp2PT7uLLyxBM487svoH/0RQr/7neOcFAhIYBOCOJA3YCYfrD6FjsEpFI9ncT0a77hjYcndhKj/sT78nptjLwcW5z7cuBE4dMiwyFZ0VhTgySdz99svfuFcTv4XfwH86ldG5ye9b77zHeCHPwT6+tRzbSf0lpcDq1ap99ANNwB/+qfsfRUqtBeK3fuMVXru5n3L4ZxFcOGRwykSS1U66kbQLNQVqZ+rudSWEo/HmQIh3Y61bz0jIyOaG5IKhWNjY5Y+ihR9yjElEAgYRLZjx45ZQlNOnjzJHA9Qz1W+fpQ+nw8+n8+wn2g0qol4ejenG9GRNYYoipZtDx48iEsuucR2+9bWVoyPj2vnLpVKadcjEAgYjicQCOCxxx7Tlo2NjaG1tRXt7e2IRqOYnZ01HJ++9JnV15NVok3drHbintkBa+59Kcuybcr1YlmqNgccDofD4SwrFlMyzSolzdN3bmbvDAauGlA/LJWAVCyF3udK0LLnP1CxvQIoKWGLSoIAhMNsgTOP+3KupQVobwdsxEdVdpLhxwS8mHEnEuZBP4br8YoRDONQUm6LotiLvfr+msXk8GH1Om3ZArzxhrps82YoIyMg5vNABTV6v9H2AKzzJYrA8DDw0kvWe/Hee9XjdEpFpzQ1qWMAQLadkIWOjsJ7NrqB9R4yv8+K1eqAw1nBnFbh8ZVXXsELL7yA4eFhvPrqq0gkEvjIRz6Cf/zHf7TdRpZl/Pu//zseeeQRHD58GGVlZbj00ktx1113YePGjadv8pyzjmK7pJaqdNSNoFlombddArFb9CKS3b6oe9AtZWVlhvWDwSA+9rGPGZKrU6mUZX925c6A6irs7e21hJ3oSaVSWL16tUGYm52d1Vyb+SgvL8cco2dOIWOwoKKgmVgshnA4jHA4jImJCabIBwD79+/Hpz71Kc2V2t3dbQijYYXb0PFZjI6OGoRNALal093d3YZtfT6fQXw2b7tYlqrNAYfDOTvhz6OcFUuxSqYBdgK1qe/coR2HNNERACABiqjg0I5DiOyM2PcovOSSnBBkZvt2tRT3vvvUXo+VlcBttwH33w9h3z5sqaoCDhxwnDoBUI7D2vfGF3WlrS6g6cxK9rsz3AVycSxUdBRF4ItfBB54gP06PZfnnw/s36/uSpKQeM97EPrd74xl8WZBjboAWUE6kqQ6ItevZweudHa6c2oeOZL73i5ISb9OsXDxHgJQ3Pcth7NCOa21aD/72c/w/e9/H0NDQ1izZo2rbf7u7/4O999/P2RZxi233IIrr7wSL7zwAm688UYcPHhwiWfMOZuhLqmxsTH09vaiv7//TE+JCRV0urq60N7ezhSjzC7IQsq8W1tb0dbWhmAwiHA4bOtIBFQBqa6uDtFoVDtvZuEvGAzC5/PZjlFeXo5wOAy/349AIKD1FKyvrzes19DQAI/Hsygx+ODBg4ZwF7o/8/xoT0dKvpJvSm1tre35yhdeQ49XlmX09vaiu7vbcj5Z17Gurg6EELS2tqKrq8v2/KRSKe2eZomYenFOlmX09PTgpz/9KY4dO+Y4b9b2rDnq8fv9rrddCIu5/zkczrkHfx7lrFioiHPttcC6derXF19cmJPL1C8SkqT+vGOHtsrc0FxOdAQQwhCapb/Ghc/+N1UU+vSnc2EeFFEEvvlN47K9e9X1168HLrsMuPNOYHpaFcqmpoD/+T+BZ58FGR9H+fAwkE7bTlsfJMMUCVevBi66yO1Z0MZKIwQgV0J8TqEoqqDoFL6jT2fu7IRw/vkQ6Qf79B4wC2r0ut98MxAMskvLk0lgbAzYvVsV8fbuzb3mphTZLHQ2N7PvyaVwF7p4DwEo7vuWw1mhnFbH4x/8wR/gj/7oj7Bp0yYMDQ3h5ptvdlz/pZdewqOPPoqOjg784Ac/0MSCD3/4w/jDP/xDfPnLX8bDDz98OqbOOQs5m1xSiynzpgEyhBC0tLSAEKI5QWkAysTEhDbuTlP5gDkFmTpJ9ehLjfXnOZlMIpVKIZFIoLy8nDk/Vu/AcDiMRCKR11FpLsOuqKhAZ2enwf0HqM5IN2KjPjAFACYnJ23Lr1evXm3Yh7lsHFDdpvremPQ4aV/MaDSqHSugirGRSAT79u3TxnDqrag/1+b1amtrDeXkZtek1+sFIQR+vx8NDQ1QFMVwXe3Ccej86f7r6uosfT2LLQzyhGwOh1MI/HmUs6IpRvou4KpfZHlzOVKxFCCpomML7gKBoqZO796turi+8x21p59d70izK8z8zEI/cM1+XbTjcPNm1bn37ne73kQB4MVMcfZ/plhMkIssqyXNHo+96GtKZyaShHL6nBkMqqnhlZVqavcVVwAPPQR8/vM5t6QgqPuhX82wAleam633i3lOZufg6XQX2r2HWC5Ot+/bPO0POJyVymkVHpsL/KThscceAwB88YtfNDiULr/8crz73e/Gr371K7z11lu44IILijpPzrnBUoXBFBO35eDFLPPONxYrmCYcDqOzsxOCIOCnP/2pZRun3oipVAqpVMoiIk5MTADIBbuMjIzg1KlTAFShcNOmTXjttdeQTqchCAJkWbYEtpj3W1dXpwl6eqLRqKNLE1DPi3k81nGJoohIJIKWlhYMDg5qwt7x48cN6+3fv5/pihweHsbrr79uKN9ua2tDR0cHc5960W1mZsYgburvaZYY6FRin84+eKZSKUNSuRvM9xDtk7lUwiBPyOZwOIXAn0c5HLjqO7fxno048dwJKKKCDdLDquiIrGhERZ0nn3QWVMyusKWmp0f9+t3vGoUvB2i5dUFPO4UmWi8lgqD2MGSVvRdCWZl9AjgjnZnIsuoQpdtMT6tuVkVRw3P0UNGxqgrw+4HJyfyl1x/6kCpws+6d6mr1mM1C9yKClAqG9R4Cci5Ou9JrO9yWbnM4K5BlHS7z8ssvo6ysDG1tbZbX6IPeK6+8wh/0OAtiJbikzlRohpPgSc8TderF43FtjsWcGxXNBEFAR0cHotGoJqrFYjGDm89N6Es4HEZzczN+9rOfMV83uxkpVNQ0l5Tbrd/S0qKdh/b2dvT09DBDeuxKsZPJJJKmB7HBwUHt+1gsBkVR0NTUhIGBAe0adWabaZuvm/449NfH3IfRCZYbmArDbuDCIIfDWcnw51HOWcmHPgTs2pX7WRAszrCK7RVo2dOCQzsOIfDsm6rTUY+bZF67nntuEQRViLFLcmahd82ZBTAbCnY6CsLpE1PzEQwCAwOLG+P4cbVMnSWoer1ARYW6D9MxG84bFaPvu4+9D1lWRccjR9QSbJaoaBbtvvMd4Ec/yh1fS4tayu8kJBbLFZwPs7vSDMvF6QSrdLuQ7TmcZcyyFR5PnjyJY8eOobGxEaK5TwOgNfI+dOjQgsYvJJ2Ws3DoeV6u57ulpUX7vtDU4tMBy5lnnqMsy5qzrq6uDpFIpOC+iHTMdDqN/v5+S5CI2bEWiUQQjUYNLkU6t/r6ett+mcFgEOXl5UgkEprTUY/P50N1dTXq6uqwbds2bV6yLOPo0aMFHZOZaDSKXbt22ZZnBwIBEEJw8uRJwzk2uygpfr/fMH9RFNHc3GyYN6CGsriBlXxNkSTJIl4+88wzmvhHr1FbW5vre3rNmjUWxy91WZaXl1t6QLJKtZfb+2U5sdx/93FyrMRrtZLmutLhz6NnByvxfb6k7N0L4QtfAAgBURTVtSbLkL/zHeDSSw0iSuCyAJp+3gShqx3Kc88ZgkQUUQSamiA7nFehqQmIxYzbZb8SAIquBFdz0NHXsmWy8v/6XxCefBJ44QUgnXYWCSUJyr59kCUJwhNPaGOZWWwatiJJp6UsWwFUsU6WQRhl0NRxuKhjAdT7YGpKFb7otaAiZDoNMjlpuDa2SBKUyUnbc67dL//jf0DIinZEkqxjS5J6/Z94ArK+76Pu9TPOZZcBzz8P4R/+QRXYjx8HYbg4lWefBd7/fsh/8zeOzkVh3z5jUA/dPns/LwT+u2/lsFKvldv5LlvhUR8GwYIudxsCYWbITbNaTtHg53thmEUvRVEwkP3ET1EURKNRHD9+XBPAxsfHEY1GsXbt2gXtb/fu3cyE5H379mm/VOg+WHMdGBjQglr08wLU96xZ0DJDw2sIIYY+huPj40X5JWwWL0VRRFlZGRRFsZ2XnfA4Pz+viZU0tMY8b0VRLH0m9ei3B6xCcyHHsn///oIEZ9a+GhsbAeR6XtLfr9FoFIqiaP0m6XwHFvDpuizLGB0dxalTp1BaWoqGhoZFBQgtd/jvvpUDv1YcFvx59OyCn2+V+i99CSFZ1hyMVABMPPwwDl56KXOb8o99DFueew4KFaWyf7sP3HQT5hyeB+y2m7v4YvgmJnCqvh4nrrwSq158EaUHDyKV7SHtm5hAas0agBD4vvxlJOrrceLP/xznf/3rjqKhIgiYq6yE9J73IPTyy7brFUM0XKx46WZ8AHj7rruw6sUXEXrpJRDTc+lC90/nrj8Gen0yITVox3PihGEfdH3WOHbj638GgFMjI3j7hz/EXEsLyv/lXxD+t39D6cGD8MzMQDAZEogkIdXXh6HFujmXkvJy4KtfBQDU33mnes/pnLkKsud1924Izz2HA//6r5jTmQT01G/YgFAsZtxeEDC7YQMOLvIc8N99K4ez9VoVLDxeeumlOJH9JeSGH//4x7jU5g/YmaS5uZn5yTWnuEiShKGhIX6+F8i2bdts3YysXoUAtJCYQqDXyel18z7e97732c6ttbVVc2Lq52juc2iG/sPNPH87QU4URe2+ypciDaguP/1YkUgEkUgEjz/+eN5tKbT0Op1OI51Oo62tzbZMv7+/n9lnUhAETdAMh8OIRCIAYOgJaecKpXi9XsNrfr+fed31jlj9Ps1inyAIhu1jsZjhH9KCIGjl3Ivh6aef1sZNJBKIxWL4wAc+sOhxlxv8d9/KYSVeq3y/s88F+PMopxBW4vt8KREOH7aUTRNZRujwYftnyJYWyA0NEP7hH6Bke+fJf/u3aMjXO89mu9LsdoHsf4B6nQ7Q6/TSSyi/5hotyMQ7NYXQK69AvusuCA8+CEVRDEKY5pAEUP7669oxLUQcZIlm5jGI6bVC9+NmfTru+f/zf0J+8EHglVegZDKLFjsVACAECiHM+8BTVqb2Wfzd72yP2zxHwljGOjelb72FLX/yJ5BfeAG47Tb1PwCkq4vpqPWaqnmWNf/4j8A116jnNeviNIi6oogtjz0GOXvMebfPOn4DX//6gs8B/923clip18rtM2nBwuMHP/hBQ+hBPqqrqwvdBQC1JBOw/wSZLrf7BDofesGCs/Tw870wRFHUQkXM2PXYC4fDCz7X4XDYlesuHA7D6/Xazg3Izb23t9cxxMTMxMSEZf7hcBjj4+OWdWk/xUwmg0cffdTw+4K685LJJHw+n5bMfPz4cUiShJqaGi0Axlx+bde/kf5e0q/Pmq/+NTNr164FIUQ7J9FoFKOjo2hsbERbW5tBENT32qQp0lRArK2tNTgOGxoamPMYGBiwlGnTtGw95vvGfM4Xc1/pmZqasvx8Nv9u4L/7Vg78Wq0s+PMoZyHw851l2zZgYsISLEO2bWOfH3PS7qOPAtu3w/WZpMnC2f9EQVCXMSgfGID3b/8WZM8eIJPRlpNsvzvxtdeAX/1Kmw+pqFB7As7OgtB+kPrt3M5RB6FzpiEq+dZdwH7crk8AIJOBePfdQGMjMDJiOL6FQCoq1L6NADA1ZemdSWIxgPHc7ThH1rJsqbZZlIQkQfza19QeifS+Wr9eXUGXRk0A4MQJiBs2FJbwfKaSod/73lywzbPPWkVdSQKGh+1/B+m3HxoCyQbjiEUIxuG/+1YOZ+u1Klh4vHcpougZlJWVoaamBkeOHIEkSZaTT3vp0N46HM65hrnnXjAYRGNj46JCciKRiNbLUZZlgwhJXXLU3djb25s3bRtgB5MA6j/SgsEgjh49anAFstLF6THRkl86D7p8cHDQIjp2dXUZ5mQWQGOxmOYENJNKpTThUi8yBgIBizBbW1trey7MgTQAW4y0C+hhhbJIkoSBgQFsy/7jIF84kt35J4Sgvb3ddvulCl+qqqoynMOqqqqijMvhcM4t+PMoh7MIzKEYVBi8916raPOhDwFf+MLCk3YLSerduxdb/uRP1O/twjqGhnLhIXRsWdZ6ES4WzaXW0QG88or7QBtADZwpZP1CSCaBV191P49LLgHeeENNjzYTj+dSplnzLcYxiKI6vt016emx3heAet6PHFGFyJ4e9b9C7rsznQxN701WeI4pNd5xew7nLGPZ9ngEgHe9613o7u5GX18fLrnkEsNrv/71rwHAspzDOVdgCUOF9Mpjuen0QpdTsrVexNOnbbO2MQuklGAwaBCgnIRTOi/9+HrMPwuCYHEOjoyMWMal82TNTxAE3HzzzYZzZB6DOmHskscJsX4GTIVV1j6d+l+y5ucmKdru+MLhsOP2S5VE3dnZiZ07d2JqagpVVVVFKd/mcDicpYQ/j3LOOrZvNzirkHVWQVGsos0zzxgFKkmCIoiIf/ivMOz/Bsqby7Hxno2o2F7B3lcBSb3CX/4l4BTaYhZu7r570e4/MwSAQgSQykrguuvYyct2OIl5pxNCgMpKVcRjzZ/ObyHz/Iu/AH74Q9sAGQ03QjDrvqisBF56SRXu6HL96/kSnpdLMrSTuM/hnIMsa+HxpptuQnd3Nx588EH84Ac/gM/nAwD89re/xa9//WtccskluOCCC87wLDmcM8NihaG+vj6tBHdsbAzhcNgg+jmNbyf89ff3G0S4AwcOIBgMagJdeXm55lY0pz2HQqG8x2MeH1BFPrO4JssyZFk29MNkpVlTcZQVmEN7MdI59fb2WkrtAoGAxcFI3aJ9fX2YNH3KrD/HiqJgeHjYUNItyzK6u7sLEpKdBGLAKFDTdHLztS6UfPt0wuPx4Prrr1/wvjlGFnMtOByOO/jzKOeMsZQloyxnVWenVbQBrKW4sgT/5AhSSCEVS+HEcyfQsqeFLT4ODVmFL+pc1LN3L7OnoIZZuNm7F3j55byHuRCIIgO7dgF//ueqeOSW6mpV7OvpUUW3kyeL4sIsGEkCnn1WLacuZkLupZcC3/gG8OEPA1ddpSZ724QwIhjMOStZzMw43xdu7xszC92u2NiJ+0Uom+ZwViKnVXjs6enRQhxon6/e3l586UtfAgBs2rQJn/3sZ7X1L7vsMnzsYx/DY489ho985CO48sorcfz4cTz99NMIBAL48pe/fDqnz+GcVZiFv3zBL3rshD6zIKlPRgbU1OT29nb09vZahEBWibUZO8HTLB5Go1F0d3ejs7MTg4ODGB4eNmwniiIikYgm0nR1daGvr087Jw0NDWhubsZTTz2Fo0ePQhRFeGkvHB2sXol1dXXo7++39FU0l38TQiyp33T+Y2NjGBkZ0Ryg+tLt/v5+jI6OQlEUtLW12YqxlKVwLubbJ+f0wa8Fh1M4/HmUsyI4EyWjLNGGgQIBCWxSf5AARVRwaMchRHZGrCs3N6tzz1dyumOH804rK4H7788JN/nWB7QegwtCUYAHHgCuuQZ4/vn864uiKjrqS8AXuu9iIMtqeXYx+eY31a/bt0N+/nkkvvQlZtI2AGfREWALsqKollh3drJLxN2UKru9304HvGyaw9E4rcLj22+/jf/8z/+0LHv77bcBqKUs+gc9APjKV76CLVu24JFHHsFPfvITlJWV4eqrr8Zdd93FP13mcM4QLKGvv7/ftqyXQoVCs4AYDAZt+0bqHV3mnon6/opmN2I0GsXOnTuZYTk0lIYiCAI6OjoMYTlPPfWUtq0kSbbp0oQQtLW1aaKloijMkulEImFwopnXOXXqlOFnVt9HvUuVfjU7LkdGRhCJRAyJ48V2weUrdeecPvi14HAKhz+PclYEZ6JklCXa0MAWQVDLrCFAAcFh3JpbRwLmhmzCntyWnA4NOZfuTk8Dd96pznH7dncOtsUIjxQn0ZGWVZuPyXztCqWiIr9wd7rxeo1uve3bcfA730Hb3/6tWs6tn6sgqI7HmRn349P+uT096lfzuXNbquzmfmP1MX3yydMfRsPhnEOcVuHxox/9KD760Y8WtI0gCLj11ltx66235l+ZwznHKaTssqGhweDKKyTkw9xDEVAFD9qvb2RkxLa0mX7VC5SNjY0YHBxkOrf0ji7AGHKjKIpjYrY5QVnvdMyHWweooiiQZVk73r6+Pq1nphPmcyDZPJyOjIxo19HsUh0dHbUkqcbjcYPguhQuOPPc7dyqvAx46XF7LTgcTg7+PMpZEZyJklE70eY73wGeeAIYGkI8uQEHpz6BWbkpt50IlDeXs8c0l5zS9OKbbjKKPM3NUGIxNfmXBV1+991qD8DmZjXN2glZZouP2WVakAxg+N41dFxZBi66KPezS+eoLYmEOkddsjYAYONGIBtoVTQuvhg4cCD/fNvact/v3Qvh/vvR3NenlpebBVJZVh2qboRHQoC1a9XrOT2dC5PR4/cDV1/trlQ5X4mz2UkcjRr7mJ7uMBoO5xxhWfd45HA4hVFI2WVb9gGCilnxeBxPP/001q5d60ogYpVb0/21traiv7/fkEJdW1sLRVHQ3d2N2tpatLW1YWJiQhOkdpo+vbdzR9LSaADo7u42vObz+QzORHOCsiRJTAckC/NYdkSjURw9etSw7OjRo/B4PMjoGp43NDQY1mltbbUItMFgEMlk0rDfeDyO/v5+2+vICrAxC67FdsG5TbzmZcBLz1Klj3M4HA7nDHMmSkadRJvPfQ4AoOydQfyqAYAogARAVJ9FNt67MTcOqzeluQTZXD5+zz3A7t35BcCXXwYeekgVqdxgFh11Yp55PwWLj3RsRVETp9/7XuCXv0R6/YXwjEVBsEDHoiSpguD55+ccgOm0KkhWVBTmJMzHzAzw4otGYZiV5v3GG2oJtC7l3CdJUI4ds44pCKqg55YjR9Sv69ezBdDq6sJcvk4lzmY3qjlo50yF0XA4ZzlceORwVjh6V9ns7KzhNSfBSRAEEEIMwtfc3JwmzNmlVFNB0q7cur29ndlX0JyE3d7ergmIgFo2rRcya2trtd6RevTl1ebXUqkUfD4ffD4fCCGoq6tDIpEwHKN+nk6EQiFD+TYt+2ZhdisqiqKJjqy0bnpezTQ0NGBkZMQieNLraHapNjQ0gBCC8fFxw/pmwbXYLjhzyvjOnTuZjkZeBrz0LFX6OIfD4XDOMIWm4hYriCZPX7qK7RVo2dOCQzsOYW5oTk21vncjKq6oyM3DTlx0Kh+/5x73c/z851Vxq1C8XlW4Y/QPLNjtyEKWgfe9D0h5AcgLc1FSXn0V+NM/Vc+dLC9N2bUgqH0gb75ZvWceeUS9/vRe6ulRz5UgqF9371ZDdwgByc6HeXx0rmbHJguPJ7e/hfZ1LAQ3btQzEUbD4ZzlcOGRw1nhmEuR9eQTnOyEILuUaiDnWLMrt3a7LzciFHVNUmiQi/54zc7EVCql/dzf349wOGwp+2bt2yyy1tXVGQQ9WZa1Mm9Zlg3zCgQClh6TesyCnPma+Xw+NDWpJUusceh13LZtG0ZGRpBIJBAIBLBt2zZ4PB4oimIIxmlpabH0eFwK8jkaeRkwh8PhcDgLpJBU3NMcRFOxvYIdJAM4i4t25eO/+IXmYHQl1C20f2I67d4puVDm5uAFoIAAUBYnPt53n3qsSyU6yjIwNcUuMd65U3U47t5tTTnP1zdTEICSEnfOzHXrgHe/m/2a276OhcByErP2eybCaDicsxguPHI4KxxWUEsoFHIlONmFwVCBKJ9YmE9YcgqGoevSdfbv32943RyaAqglzGZhLl85tCAICIfDBqFQ75qk58ksorW1tSEYDBpES1rmbRYpm5ub8fjjjzNFQ1aptPk8plIpEEIsy809KXft2qXtI5FIYNeuXbj++ustwTjA6Slpznd/FKMMmPeJ5HA4HM45i9tU3DMRRGOHU29KO9EnmQRefnlxrkO3QTL5BEs3Lj0304ECBQIyKIUHcws7NioKFhu/Xw1/0Y9vdp/u2AE8+2zh+6eCJqPXOxO7npWF9HUsBLOTmM7XLiiIw+EUBS48cjgrHFZQi1vRqbW1VXPLnTx5EqWlpYay4HzCYj5hySkYhq5r59ik+zIHsLBCa5yYnZ1FQ0MDwuGw1lNSH0pDxzeLZhMTE2hsbDTMzc6x5/F48PGPf1wTyI4dO2YQRPMJtnQd8/KWlhZNFI3FYpZekuZejqebfPdHMcqAeZ9IDofD4XDycCaCaOxw6k1JRR8b8roDzSKRYWOFvdwtogj88z9rITo4elR1SC4CAhkikur0UKDzURTVgJbp6aIIoQaqq9Wv5nMlSWp59ZVX2u/TFMyjHdfFF6sOx2TSvWDq8QC6fuiWOS6FaM5yEt9wQ+66OzmLORzOguHCI4ezwlmMq8zc5zGRSGhhJdQRGA6HQQhBOBy2jJ1PWHIKhrFbx+/3o6mpCZFIBAMDAxBF0Tbx2Qm6XTweR19fn6HXIivIhiWisc6tLMvo7u42pEYriqI5Fuvq6lBbW2voxcgSbPX9MZ3251RKr08iPxPOwNMRbML7RHI4HA6Hk4czEURjh1NvyiuuUEWfa65RBSoTTGGuokLtzQgAHR2qSHTHHex9L0R0JETty2gK0UFnp9rPkOWiFASgtBSYm3McWhXlMppA5xpRVL+uWcPue7gYBCF3X7DumXTaXnTUCb+GHo+CoAbh7NypBsS4vQ52oiOw9CFKZlGTXncOh7MkcOGRw1nhLNZVxhJ2zGJXe3v7gvZhLq+emZlBd3e3QRgzC35NTU1ob29Hb2+vQbzLh1mgLCsrM7gj4/G4dkx2IqO+V6KSfdBkheSYk7FHR0e1fdEy7ba2NsNYsixrQiAVYKlQSBO/aUhLZ2entq75+vh8PkiShDVr1qCzs1MTHPUJ2fTY9G7JQsVIN0Lm6Qg24X0iORwOh8PJQ6FBNG5YaFiNXW9KRVHFvKEhtcw3nc4vUBECXH65dd/33ls8Qc7jUed0//3G/dxzD/DMM+xtFEUtQ/7ABxz7GBKb7x3x+4GWFtV5eOCA262yO8nuRRDsxUNZVl2Un/40+545edJ+fFlmp2rLcs5d29ysJlovtkSclzpzOGcVXHjkcM5xWMKOWewaGRlZkHhF3ZOURCKBRCJhKJmlLrloNApFURCLxZjiXj4ikYjBdagoClO4jMVi6Ozs1L7XH5Pe/dnX1wdCiEVYczMvKjjqxxodHUUgEDC4R+nY5sRvem4A6/VpamoCIQQtLS0ghBjcl+bjXEyZ8nIpcT4drkoOh8PhcFY0hQTRuGGxYTVmR5l5PKeSaT2Koop/zzwDfPe7wO23q8s7OoyhJ8DCy6zTaWBszHqM27er5b4sgXP1avXcXn45uw+i369+Zbg6HfF4gBdeUEVQp1AZ+hzOKjevrlbPj1N/xp4eoLcX+Pa3gSefNN4zv/d7+edp7oOpd9fec4/qFC0E/bUjBHjoIV7qzOGcZXDhkcM5i1hIua3e6dfQ0KC55PRiVzweRzweZwpQTvsMh8OGZGg9VNykrjmz+EYTrFkEAgE0NjYCgNa30XyssiyDEGJwAgJqsIzdfM2C6/DwsHaO6DqKqeQmEAigoaHBIHKy+lDScwhAOyf0PDqVE9s5MQFr6rceloBcSJnycilxpvcHvc+oK5SHzHA4HA6Ho8NtEI0bih1WYx6Pio5VVapIt3490NOjliZLErsf4uc/D2zbph6nncPzwguBV19d2DGzjpElcIqiuvz/Z+++w6Oo2jaA37ubAqkkBpKQAAGSAEJIoyigAgKKNEEBC6KvIDawfwqKFV5BLCjoa8VeQBQEQTqCEjCQkIQgYACpKdSQCim78/2xzLJltmayLffvurxw28yZmc3m5N7nnANo27Fhg+F2VKor4aHxay25+mptRaiVKkoA2vOnkKihFNsmtSK11LGuXKl97ocfalfQvu66K6GmOdXVgEIBQaW6cq3Uam0VZUaG9vpcdZVtFalie8PCOL8ikZdj8EjkRRypUlMqlUhNTdVV0Ym3AW3YVF5ebhCkGQdQxvssKirSDaFOTk7WvUaj0ZjMaahPaj7I9PR0yTaEhoaarOJs7rj0Q7uEhAQAsLm6sKamRvdc8TnGYVdoaCjS0tJ01ZZlZWWSq1sb0z9eS8OJjSsxc3JydBWTUmGgSqVCq1atdOfe0WHK7jbE2V0qMImIiLye3IvVSG1Po9GGjidPam9nZACzZkHYsEE3f6ABQbgSCloazq1fWSnOlah/DJboH2NGhunCLrYOYReEK+GotUrMwEDg7be1zzE3d6W5fehTKg3bZhzOGhOP9cMPDfdrrWpUqQQ2bQKeegrCzp1X7t+1SxtcXnXVlefpb0upvLIAkH5Y/M47DBqJmgAGj0RepDGq1IKCggxCP2uBof6iK8CVcEiqMlKfVNAlNRRZqg3m5OTkGFQiiuGgPv1h5GJYt3fvXtToDY+xFhLqz3X466+/GgSP5hbH0T8Ga8OJjdssbl9qdWy1Wo3i4mLk5eUZbFecR9J4jk1zLLXJFQvZuEsFJhERkdeTe7EaW7bXty80q1ej8rrrELJjh/SciPrBp7kKT3OB5JQp1qshlUrt8OiWLbUVe8Z9mx49DIOy2bOltyMGpAsWaCs1RZdXhDbZX7duwK23Wm6bNeHh2pWZxbbph7O//2467Fs8/y+9ZN9+UlK02w4LM1hkRhcyiudNfyi9GAB37gwcPqwdUp6SwtCRqAlh8EjkRWytUjMOjrp3727wuPHiMtHR0boqRmuBoT6x0lF/X/oLp4htEedA9PPzg5+fn271aZEt8/zpbwfQVjeeOnXKpD3G7TU3jNw46BSPo7i4GEFBQaipqYG/vz+Ki4uRnZ2tC9+kAjjxuARBQF1dHa666ipdyAlYX6TFuM1BQUEm58W4KlQMgKXmvJRaids4PLTUJldUH7pbBSYREZHXkmOxGv3FaWJjtfcZb2/UqCsLziQlATNmoHjSJITs2GG6Pf3VmC2RCiQzMoD9+62/VqMBzp27Eg7qV+ypVNqwTT8os1YZunKl4UIvxlWK4vZnzwbOn7fePl/fK2GllFmzTBcDWrPGdI5N/et53XXW9ytSqbRhIQDk50tXporHpVRqFxG6dEl7u64OOHDgShCZnS29YjgReSUGj0RexNaFOIyDIzGEEkkNex42bJjFfRrPpQhowyFrIZVxVWJtba3JvIW2rJ5svJ3du3ebzBOpf04sDSOXOo/GYSwA1NXVobKy0mDORuOATK1WQ61Wo7a2VnefWJFoa1hnXLko0j8vxlWhZ8+e1bWrsLAQwcHBBts0XonbWhCpr6HVh47ORSrui4vMEBERNaKGLlYjtTgNoK0YPHlSu71Ro4Bp0wyeo9y4EfjoI2iefBKq+fOvbE+p1P5nKfi0tAq3OMekLcw9T63WLsqiz1olp1QwaUyj0W43PNz6vIh1ddJzOyqV2sBUnNNRaqEcc9fTlv36+wMDBhi+B5KSIJSUWA4fy8oMh3qLz23onKFE5HEYPBJ5EVsCOkA6ONIP6eypLtOfi1E/xAsODkZqairWGHUobAmtiouLsXjxYoSEhOj2rb+IDACT4EpqOxUVFbq2iUONxcVJhg4dahImRkZGIjs726Q6U6PRoKCgwOw50D8OsX3Gw7XNPd8W+tdVrVYjNzcXgGGAFxkZibS0NF2gqB90AqaL4hjfNg4iAfNVjA2tPnR0LlLO6UhEROQkDVmsxtziNGFhwF9/ae8bOlTyObHz50P5zz+GcwRqNMAHH5gPPq2twu3o3JTGzp27soCKLXNASgWT5rz2mm1zPEoFo2KFoaXFgMxdT1v2GxFh8lrN889DuXEjBP3h1lLMHbtUkEtEXovBI1ETZC04klpJWaPRmFSl6QdfGqNOR2Jiom54tqV9mRuqXVlZaVBNCGhDqoKCAgQFBZnMJSm1HYVCoatW1K/IFJ9nXElYXFwsOUdlTk6O5ErVxscBmFYhWnt+QxgHeOnp6QgJCZFsa3BwsMHck8bBpDFxCLl+laUY/uovGuRI9SHnayQiIvJitixOI/EchVqNgIICbbhmPMx5xQrgoYek92dtFe6kJKC42PrCKdYIAnDjjdr5CaVCM+M5IK0t8KKve3ftytb79zs2BNn42GxdDOjhh7X/vvSS+crH06e1QbF+FWnfvjj+zDNo+8Ybps+3tqCO6OzZK0EuEXk1Bo9EHqohC3wYD1vt3r079uzZA41Gg9zcXF2QKAZYu3fvhkKhMKk4s2UuSGtDZJOTk1FYWGhz+CTOyaivpKQEQ4cORVFRkcEw7YSEBMkh0uJr9M+fIAgmQ7zFNhm3TaFQIDAwEMHBwWbnvjQOb+Pj46FQKEwqNxtCKsAzDmCDg4ORkJCga4dIDB6Dg4ORmJhoMAckoA2bjasS9f+/IdWHnK+RiIjIiKWhwp7GlsVkJJ4jXK4YVNi7ora1oFMMAIGGh481NUBmpun9UnNAGg9xrqkxnEMS0IZ0HTteqdgUhCtBpa0BnhRxLsjYWOvvp4cf1v53zTXSx1ZXpx3GrV9FCqDFH39Ih6ri9D5lZdbbactwa2/62SBqohg8EnmohizwYTxsVVx1OS8vzyB80icVDNoyF6S5IbJicCo1N6S9NBoN1qxZg+joaERHRxuEe8ZDvfVfo3/+jOdABK4MvS4vLze4XxAEVFZWolOnThaP7dSpU7qFchpj1WepAM/c/JTmznFISAjS09Oh0WgM5ni0FAQ3tEKR8zUSERHpsTZU2NPYsjiNmedUJyYicP9+w/DR2ora1oJO4wAwNlZbsWhcWSmuOh0Rob19/rztwZ9UOGocmI0cCTz2mOkiL4BpxaZSaRhC2sI4sBTbr/9+AsyHeCdPWj4+o+HbzQ8dMg2JAW3gaGu/11pVprf9bBA1UQweiTyUPcNVLVVHio8ZV8QZk6pKa0jlmrlKRABQqVRQqVTw8/NDQkICFAqFwRyEwJXqSo1GYzA8Oj093SD8NB4CDmir/BRGk3NXV1cb3BbnvNRvo0ql0oW0gPlzbm7xHkeqUy2RCvCkgl5L7w2pIeKA9rjNrVbe0ApFztdIRESkx9pQYU9jy+I0Es/RPP88ThYUoNNDD9m3orYtQafxHIdiKCgOma6r064aDWiHTIshoUJhW/BnHI6aC8wWLNCudq1/XsaNM92HRnNlFWulUts+S3x9tcPAxcpK/dBUDCOHDTOsQjQO8azNSWkUrta2agXfM2cgsdyN7YGttZXKve1ng6iJYvBI5KHsCf0sVUcarwatT2rotD5rlWuWAk9LYZj+StBiSJWWlia5rdWrVxu8tqCgwOA5xgEjoJ1/EoDB/JH6gWJQUBBuuukmbNiwweB1AQEBBuGn8WI0YpuMj82ehVsag3H4GhQUhJCQEAiCgJKSEmRnZ5uEoVIracs5TJyIiIgus2VORE9jy+I0xs9Rq1EVEADNpk1QzZljGlqaG3LryCrc+vs2DgnFYcViSPj779owzxypoNNcYLZypel5MRf4iWGjSqX9r1Mn83NAJiRc+f+KCtPgT1xlWp9xiGdtTkr9cDUjA4H790ufD3tYCpQB7/zZIGqCGDwSeQCpAM+e4aqWqiONHwsODtatJm2tMs9a5ZqlwNPcojLm2m5uX8bbEeeAFO+Ljo42CBijo6MNzpXU6tOVlZVYt24dWrdubbBtsfpSf15IqeMzbpPx9gsKCpCcnIy8vLwGVUEan9+CggLJod3G4WtISAiio6MtDtVnVSIREZGT2DInoqs5c549qdDS1grCJUvsb5e1kNB43yqV9nk9emiHJ0sFnbYGZlKrYxsT99m2LfDJJ8ANNxg+X6kE/vlH+5+tw7Kl2qQf4GZlaRd/EYdti6tmZ2UBQ4dCef48AJhWO4aGApWVtrXjo4+unDNz7y9P+NkgIqsYPBJ5AHMBnq3BkKXqSOPHEhMTZQucLAWe+sGp/nBpqbYD5qsn9bdTXl5uUJEoLjoj/r9xwGdp9enz58/rhmybCweNqy3F40tNTTVY6MZ4BemKigqsWbNGcgVtexif34qKCt2x6G9LKnyVe2Xphix2RERE1KTZMlTYlVw1z55+GFVTow3AjIcPP/rolVDM0XZZCwml5ogEroSOM2eaVlfaEpjpn1drxPb07Qts3WoY0pWWagNBe0NHqTYZV4KKIeS5c9rzfPastiJUrZYeYu3rq33vWpqbsndvw9W/Lb2/3P1ng4hswuCRyAkaGso0NCSyVB2pv/pyQkKCrMNozQWexudDv/rP3LBec+GrfmVedna2QYgYFRVlUrknLiqjv28AyM/PNwgIw8PDrVb9mTs+pVJpcn2N54c8ffq0weOOBH/mqkaNt2VuwRk5V5ZuyGJHRERETZojQ4WdyRXz7BmHUVL0Q8iGtCs2FpAahSMGjMCVQM7WENZaYJaRAdx6K1Bfb1sbjRfL0T++2FjHQkfAcogn7mfoUF3YCED3rwCjikeVSlsFOnOm+ZBW6n1t7f3lzj8bRGQTBo9ETtDQUKYhi7gAlofNilWDCoUCKSkpslapmQs8HTkftoSvtgw/N7fv5ORkrFmzBufPn0d4eLiuUtKR4wNMr1mrVq0MqjrVRh1Ec/NF2rJ/45XBjd8fUtdf7pWl5a6gJCIialJsmRPRVZw1z15GBuKnT4fy2DGgttawwtFW+u1qjOHhtoawlsJkMby0NXQELAeE1haFMce48tAcieuvgDZ4FFQq7crW+sFqnz72vZdtqTh1158NIrIJg0ciJ2jMikV3Ya6qUypQdOR82BK+2jIvobl9+/j4YMSIEVbbYev+jK9ZcnIyli5dahAQ6s+naW6+SFv2L1Yw2vP+kHsOR1vDcQ7JJiIi8jDOmGcvIwPKG29EiEYDhb1hoz6xXfYMDz95Unpb4v36Q471V4sW2RrCCoL9lY6A9YDQ2qIwgHaYdHg44O9vf9WgxPUXVCpUde6MwNhYYO/ehlUich5HIq/H4JHIQfYEKI1Zsehom+xhy3btqWJ05Hw0JHzVb7/xCs8NHWJsjtQ1S0xMNBgKrj+fprn5Ih3dl7PZen04JJuIiMjDOGOevcuVhBZDR6USCA42XZ1ZpN+uWbOsVyaKgeLZs9Lb0g8wLVVfSs3d+PTTQGbmlftKSrTDlcW2mCMOVz550nCY8lNPXfl/4+pNqTkos7IMj1uhAFascCwYNHP9Tz71FBLuvRcqcbEdR3EeRyKvx+CRyEH2BCjOqlhsrFDHlu3aU8XoyPkwF67ZG4oC2sVVlEql06tH7Rma3ViBqCNsOce2hp8ckk1ERORhnDEHZX6+dsiuOWIY1bmz9EIq/v7AgAFX2mVt+K6lOSSlAkxLgajx3I1Sw6htGQYdEXElHDRun/4clFLVm8bDkY2HmTfkevXtq109/KWXtBWfYWHQvPoqqi7Pk95gjfX+cuZK7ERkEYNHIgfZE6A4qyKtsUIdW7ZrT3Am5/kwF4rqh2Xl5eUm+7/pppuwZs0a7N27Vzeno49P434k2jM0252G08sZaLtzwEpERERmNPY8e0lJEEpKDMNHqeHB48ZJh3gREYbtMzfvoVhFaDxXo8iWANP4+Zs3XwnJxO3ay8fHsCJx9mzzVZa2LKIj5/XKyAAee+xKAFtaCuXjjyPwo4+AlBR59iH3+8tVK7ETkSROrEXkIOPAxB0ClMZqky3bTU1NRXp6OmJiYnTzDspNXJF69erVyM7OhkajMRuKimFZYWGhwbyKYvvXrFmD4uJi1NTUoLi4GGvMdHak9tkYxFBy2LBhutW63YWcgbYz3idERETkYWbOBBQKCGL/R6XSBo8rVmiHF69Zow3lkpK0j+mTmg9w5kzp/WRlaUMpc4GiGGCKAaDU/vT3O2CAYWWeVDWmNRERwNatptux1Oc0nlcyI0O7+nRsrPbfjAzbHrOF1II6goDoRYvs244zmWkzZs92bbuImihWPBI5yB0r1BqrTbZs1xlVnVKVd+Yq6IzDMf2FXFJTU7F3716Dx8+fP2/zPpvanIRyVim6w3yURERE5Gb69oVm0yZUTp+OkGPHoOjeXXq4ra3zAfbtq50rUX+eRdHs2bYvaCLuT6k0DAKVStP9ZmQA586ZP0b9ALOhcy/qt9VSdR/Q8Mo/qVWt1Wo0P3TIvjY7k7NWYicimzB4JHKQOwYojdUmdzlW4zCxoKAAISEhiI6OhkKhQHR0tC4UNQ7L9BdyAYDw8HAUFxcb3LZln01xTsLGCLS5ujUREREZ6NsXhxYuREpKivkFS+yZD1BqtWoxfFqyxPYAU9yfuGBLXR3g66v9/1mzrswdaKmaTlyZWqy6a8hchsZtlaruE4diA9YX2TFmPDdibKzkqtYX4+MRZF/LnYcrZRO5FQaPRA5gaOIaxmFiRUWFbhh1enq6QbBoLSwbOnQo1qxZg/Pnz+vmeLRln+4wpN7ZGiN4ZiUpEREROcTW+QDNhU+xsdpgrUWLK/f36GE+BNTfn3F14fr1wNq12iCyrk66HaGhwF9/XbltS9t79NBu23i4tfEclID16j57Kv+kqidFRiFt8eTJSLB+JNY1xiIwXCmbyK0weCRyAEMT19APE8vLyw3mbiwpKUF2drZB0Gjpmvj4+GDYsGG6ADkvL08yQHbHIfXegJWkRERE1KikwifgSuWifiA1c6ZtlYfG1YViMGgudASuVEc60naFwjA4TEkxbau16j57Kv/MVU/26AGEhenCQc3zz6MqIMD+4zLWWIvAOGMldiKyGYNHIgcwNHEN/cq77OxsXfgLXFkEBrA9DLYlQJaj2o8VsqZYSUpERESNSip8Ki01XADGlqHH+qytci2lrk67qIu9FX3p6cDu3Yb7y8wE+vXTDt1++23tdqTmodRogFGjtPuzp/LPXPXkyZOGVZtqNZCba9dpkGRpmHhDV7lu7JXYichmDB6JHMDQxPWSk5NRVFSkGyptzJYw2BkBskajwerVq3XzSTalCllLgSsrSYmIiKjRGYdPsbENW3REqrrQmrIyYMMG2yv6jKsApWRmap8jbmfBAuCRR648rlAA06ZpH7en8s/ZcyNyERiiJqFpl9wQOUgcxhsTE4P09HSGJi6Ql5eH4uJi1NTUoLi4GIIgGDweGRlpdRvGgbG1AFmsqly9ejWys7OhMZ53R0JOTo7BIjZA06mQFStKCwsLkZ2djZycHN1jYiXpsGHDkJ6e3uQrQImIiNxORoa2Ui82VvtvRoZ7bKshkpIMV5cGtJWCNTW2tW3mTG2oZ27xG3P0K/rEBWbMMa4CNKe+HrjxRm2bv/rKsE0azZX9iOHryZPafy0NNzY+vsaeG1HqenARGCKvw4pHIge4yyrPTZlxeFdVVWX3NuytunNkbk+pkLExKmTNVRe6cpg3pyQgIiLyUHLOvddY8/g5wnjeR3F48vnz2n+ttc14leuzZ+1vg7WKPnuGc9fUXKmmtHc/Upw9NyIXgSFqElhiQtQEOFKp5+5tshbenTp1yuo27K26cyRIM25ndHR0o1TImqsutFR12NjsrSglIiIiNyE19561Sj1nbKuhxGBt8GAgJgYIDzecG9GWtokVhGfOANu2aedb9PfX/mfLQjLiytrmKkClqgAtMRdSOlo5aE+FZEMZX4/Bg4GtW7kIDJGXYcUjURPgjqtwN7RNxtWKgiBg9+7duscbI+RyZG5PqarKxqg4NBeKurLqkPM4EhEReSg5595zt3n89Od9jI29EjqK7Glb376Gi64MHWq+AhGQXlnbuMrSuApQodCGobbwxMpBLgJD5PUYPBI1Ae445LWhbTIe7q7RaKBQKBo15HIkSHPWsHxzoagrF0LilAREREQeSs5FRswtyBIb27A2ykHuxVSkhg4DQI8e2gpCW1bWFheLeekl7RBwcVuWRgepVNp9hIU5Z4g0EZEdGDwSuTG55udrrPCpIe2Tu03OCLmcsQ9Hz6m5UJRVh0RERGQ3OefemzlTWwVoLCtLO8TY2fM86pN7jkFb5ki0trJ2Rgbw2GPaoFH8zxKxze+8w6CRiNwSg0ciN9aQ4cj6AVZkZCTS0tJw6tQpWcOnhrSvqQdi5gJGR8+puVCUVYdERERkNzkXGenbV1uNl5lp+tjTT+uq9JTduiFw7FggJaWhrbevbXIvpmJt6LC1KsvZs60Hjkqldn5Kf39WNxKR22PwSOTGGjIc2TjAEhdRacz2FRQU2FypJ3cg5srVmx1hLmB0x2HxRERE1ATJOffeyZOm96nV2jBSrDYsKUGnjRuhSUgArr9env3awtlzDFqrsszPtz6sWqEAVqywP2zMyLiyIreoRw9tm1xZeUpEXs19/yonogatCuyMAMu4PRUVFS5ZPRlw7erNjjB3fbgSNBEREXkdSys1X678U1xeUVr5+utObJgLWFvJ2dL8kkql4ys/Z2QA/fsD69cDZ89e+W/9eu39+itrExHJiBWPRG6sIcORnbGoiH77ysvLUVFRoXvM2ZV6nlYpaO76NPUh6EREROSFpKr8JFZ+Vmg0EFy12rUzWaqynDkTWLvW9H6lEhgyxPHqzNmztatjG1dTajTaCkpxcRsiIpkxeCRyYw0ZjuyMAEu/fdnZ2bqhw4DzK/VcuXqzOZaGf5u7PpyTkYiIiLyO1FyKxqs7AxCUSsdXlPYGGRnaeS+lNGTRG0B73iXCXgCGi9sQEcmMwSORl3J2gOXqSj1X71+KpYViGDASERFRk2Jc5ScO/b1c/ShcHoqteeEFmBmU7d3E81FfL/14jx4NW0BGalEbkf7iNkREMmPwSESycHWQ1tj7d2TxGk8b/t2YPG3xHyIiImpkxlWQ3brhn3HjkOCtqzOLC7uIFZ/GC7qIQ6HNkVqgx559xsZq71MqDYdbK5UNr6Z0pD1S54CIvBKDRyIiG1iqXjTH3PDvphjCOXL+iIiIyMvpVUFq1GpU5ea6tj2NRaxmFATdCt7YuBFYsABYuVIbxJ09a34otCMViVL7BICePYHDh688r0cPbejY2IGvuXOwZQvDRyIvx+CRiMgGjlQvmhv+3RRDOFZ/EhERUZMlVjOKwaJara00fOQRswvtGHCkIlFqnyoVEBYGnDlj/zE0lLn2cFEbIq/n3SU2RF5Mo9EgOzsbq1evRnZ2NjTGK9SRrIwXq7Fl8Rpx+PewYcOQnp6uq2psiiGcI+ePiIiImriMDGDoUO0w4aFDtbc9kdTCLmLf3Vro2Ls3sHWr/RWJUvt05SIy7tYeInIaVjwSeaimWDXnSnIuXuOOK3A3Nndc/IeIiIjcmDcNzbW0sIsxf38gIkL7moYMgZbapysXkXG39hCR0zB4JPJQTbFqzpXkXLymKYZwrl58iIiIiDyMNw3NnTlTG5qKw6pVKm3Fo0JhuNCLSgUMGCDP8Unt01mLyHhCe4jIaTjUmshDceiqc8k5tN3cEGwiIiIiusybhuaKK3gPHgzExGj//d//tPM8qlTa58gdxEnt05Eh23Jxt/YQkdOw4pHIQzXFqjlX4tB2IiIiIifypKG5GRnaSsz8fG37Zs40HQ6ut4K3TlKS4evkXl1aap+u5G7tISKnYPBI5KE4dNW5OLSdiIiIyIk8ZWhuQ+aiZBBHRE0Ax/cREdmAQ9uJiIiInMhThuZKzUUpCNr7iYiIFY9ERLbg0HYiIiIiJ/OEikBvmouSiKgRMHgkIrIBh7YTERERkQlPmouSiMgFONSaiIiIiIiImraMDGDoUCA2VvtvRoZtr5s5Uzv3ZGOtTk1E5OEYPBIREREREVHTJS4Qs2EDUFio/bd/f9vCR0+Zi5KIyEU41JqIiIiIiIiaLqkFYlQq7f22zDHpCXNREhG5CCseiYiIiIiIqOniAjFERI2GFY9EZJZGo0FOTo7BSs5KJb+vICIiIiIvwgViiIgaDYNHIjIrJycH2dnZAIDCwkIA4MrORERERORdZs4ENm7Uho3iMGsuEENEJAuWLhGRWSUlJRZvExERERF5PE9cIMbRVbiJiJyMFY9EZFZUVJSu0lG8TURERETkdTxpgRhxFW5xQZySEm3F5pYt2uMgInIjDB6JyKzU1FQAMJjjkYiIiIiIXKihq3ATETkRg0ciMkupVHJORyIiIiIid8JVuInIg3CORyIiIiIiIiJPkZSkrXDUx1W4ichNMXgkIiIiIiIi8hQzZ2pX3RbDR67CTURujMEjERERERERkafwxFW4iajJ4hyPRERERERERJ7Ek1bhJqImjRWPREREREREREREJDsGj0RERERERERERCQ7pw613rVrFzZv3oy9e/di3759qKysxOjRozF37lzJ52dmZmLixIlmt7dkyRKkpKQ0UmuJiIiIyNuwP0pERETkPE4NHn/++WcsX74czZs3R3R0NCorK216Xa9evdCrVy+T+6OiouRuIhERERF5MfZHiYiIiJzHqcHj3XffjUmTJqFDhw7Iz8/H+PHjbXpdr169MG3atEZuHRERERF5O/ZHiYiIiJzHqcFjUlKSM3dHRERERGSA/VEiIiIi53Fq8Oioo0eP4uuvv8alS5fQunVr9OnTB+Hh4a5uFhERERE1EeyPEhEREdnPI4LHVatWYdWqVbrbzZo1w7Rp0zB58mQXtoqIiIiImgr2R4mIiIjs59bBY3h4OJ599ln0798frVu3Rnl5OTIzM/HWW2/hzTffRFBQEO644w6Htq1Wq2VuLUkRzzPPtzw0Gg3y8vJQUlKCqKgoJCcnQ6lUNni7vE6eg9fKM/A6eQ5PvFae1FZvwP6o5/PEn/OmiNfJc/BaeQZeJ8/hqdfK1vYqBEEQ7Nlw7969ceHCBZuf//XXX6N3794m9+fm5mL8+PEYPXo05s6da08TUFBQgDFjxiA0NBR//vmnXcGLWq1Gbm6uXfsjchdFRUUoLi7W3Y6Ojkbr1q1d2CIiInKVlJQUqFQqVzfDJdgfJSIiInIP1vqkdlc8Dh8+HFVVVTY/PyIiwt5dWJWYmIjk5GRkZWXh2LFjaN++vd3bSEpKarKddWdSq9XIz8/n+ZaJfugIAAqFAikpKQ3eLq+T5+C18gy8Tp7DE6+V2OamjP1Rsocn/pw3RbxOnoPXyjPwOnkOT71WtvZJ7Q4eX3zxRYcaJLewsDAAwKVLlxx6vUql8qgL6ul4vuURHR2NoqIig9tynldeJ8/Ba+UZeJ08B6+VZ2F/lBzB8+0ZeJ08B6+VZ+B18hzeeq3ceo5Hc+rr67Fv3z4oFApER0e7ujlETpOamgoAujkexdtERETkXOyPEhEREVnn1sFjTk4OUlJSoFAodPfV19dj3rx5KCwsxHXXXYcWLVq4roFETqZUKpGenu7qZhARETUZ7I8SEREROc6pwWNWVhZ++uknAMD58+cBANnZ2Zg+fToAoEOHDpgyZYru+U8//TQAbZVXZGQkKioqsGvXLhw5cgStW7fGq6++6szmExEREZGHY3+UiIiIyHmcGjweP34cy5cvN7nv+PHjAIBevXoZdPTuuOMO/Pnnn9i5cydKS0vh4+ODtm3b4qGHHsL999+P0NBQZzafiIiIiDwc+6NEREREzuPU4HHMmDEYM2aMzc+fMmWKQcePiIiIiKgh2B8lIiIich6lqxtARERERERERERE3ofBIxEREREREREREcmOwSMRERERERERERHJjsEjERERERERERERyY7BIxEREREREREREcmOwSMRERERERERERHJjsEjERERERERERERyY7BIxEREREREREREcmOwSMRERERERERERHJjsEjERERERERERERyY7BIxEREREREREREcmOwSMRERERERERERHJjsEjERERERERERERyY7BIxEREREREREREcmOwSMRERERERERERHJjsEjERERERERERERyY7BIxEREREREREREcmOwSMRERERERERERHJjsEjERERERERERERyY7BIxEREREREREREcmOwSMRERERERERERHJjsEjERERERERERERyY7BIxEREREREREREcmOwSMRERERERERERHJjsEjERERERERERERyY7BIxEREREREREREcmOwSMRERERERERERHJzsfVDXA2QRAAAGq12sUtaRrE88zz7d54nTwHr5Vn4HXyHJ54rcS2in0a8jzsjzqXJ/6cN0W8Tp6D18oz8Dp5Dk+9Vrb2SRVCE+u11tbWIj8/39XNICIiImqQpKQk+Pn5uboZ5AD2R4mIiMhbWOuTNrngUaPRoL6+HkqlEgqFwtXNISIiIrKLIAjQaDTw8fGBUslZczwR+6NERETk6Wztkza54JGIiIiIiIiIiIgaH78mJyIiIiIiIiIiItkxeCQiIiIiIiIiIiLZMXgkIiIiIiIiIiIi2TF4JCIiIiIiIiIiItkxeCQiIiIiIiIiIiLZMXgkIiIiIiIiIiIi2TF4JCIiIiIiIiIiItkxeCQiIiIiIiIiIiLZ+bi6AeR9du3ahc2bN2Pv3r3Yt28fKisrMXr0aMydO1fy+ZmZmZg4caLZ7S1ZsgQpKSmN1Nqmzd5rBQAajQbff/89lixZgmPHjiEgIAC9e/fGk08+ibi4OOc1njB9+nQsX75c8rH27dtj7dq1Tm4R7dmzBwsXLkRubi7q6uoQHx+Pe++9FyNGjHB100jPwIEDUVhYKPnY+PHj8dprrzm5RUQkN/ZHPQf7o56PfVL3wv6oZ2hK/VEGjyS7n3/+GcuXL0fz5s0RHR2NyspKm17Xq1cv9OrVy+T+qKgouZtIlzlyrV5++WX8+OOPiI+Px4QJE3Du3Dn89ttvyMjIwOLFixEfH++ElpO+iRMnIiQkxOC+sLAwF7Wm6crMzMSkSZPg6+uLYcOGITg4GOvXr8czzzyDwsJCPPTQQ65uIukJDg7Gvffea3J/t27dXNAaIpIb+6Oeg/1R78E+qeuxP+pZmkp/lMEjye7uu+/GpEmT0KFDB+Tn52P8+PE2va5Xr16YNm1aI7eO9Nl7rf766y/8+OOP6NGjB7744gv4+fkBAG699Vb85z//wSuvvIJvv/3WGU0nPffeey9iY2Nd3Ywmrb6+HjNnzoRCocB3332Hq6++GgDw6KOP4o477sDChQtx8803swrDjYSEhPB3DpEXY3/Uc7A/6j3YJ3Ut9kc9T1Ppj3KOR5JdUlISEhISoFKpXN0UssLea7V06VIAwBNPPKHr5AHAtddei379+mHXrl04cuRIo7SVyJ399ddfOH78OIYPH67r5AFAUFAQHnnkEdTX12PZsmUubCERUdPC/qjnYH+USB7sj5K7YsUjuY2jR4/i66+/xqVLl9C6dWv06dMH4eHhrm4W6cnMzERAQADS0tJMHuvXrx/+/PNP7Nq1C+3bt3dB65qurVu3oqqqCn5+fujUqRN69erFP7ScbOfOnQC0PwfG+vbta/Accg+1tbVYvnw5Tp06hZCQEKSlpaFz586ubhYRuRj7o+6P/VH3xT6pa7E/6nmaSn+UwSO5jVWrVmHVqlW6282aNcO0adMwefJkF7aKRNXV1Thz5gwSExMlOxBiyf7Ro0ed2zAymXg4Li4O77zzDrp27eqiFjU94vu+Xbt2Jo+FhoYiLCwMx44dc3KryJIzZ85g+vTpBvddd911mDdvHkMGoiaM/VH3xv6oe2Of1LXYH/U8TaU/yuCRXC48PBzPPvss+vfvj9atW6O8vByZmZl466238OabbyIoKAh33HGHq5vZ5FVUVADQlupLEe+3dfJ2ariePXti4MCB6N69O8LCwnDy5EksWbIE3377Le6//36sXLkSkZGRrm5mkyC+74ODgyUfDwoKQklJiTObRBaMGTMGvXr1Qnx8PPz8/HD48GG8//77+OOPP/DII4/ghx9+gEKhcHUziciJ2B/1DOyPuif2Sd0D+6OepSn1Rxk8kqTevXvjwoULNj//66+/Ru/evR3aV0JCAhISEnS3mzdvjpEjR6Jz584YM2YMFi5ciHHjxkGp5JSkUpx5rUh+Dbl+t912m8FjHTt2xPPPP4/mzZvjo48+wpdffonnnntOzuYSeYWpU6ca3E5OTsbHH3+MCRMmIDs7G1u3bkX//v1d0zgi0mF/1HOwP+r52Cclcq6m1B9l8EiShg8fjqqqKpufHxERIXsbEhMTkZycjKysLBw7dozztJjhrGslfnNm7htk8X5z30CTtMa4frfffjs++ugj5OTkNKRpZAfxfS9WYhirrKw0++0zuQelUokxY8YgOzsbu3fv9pqOHpEnY3/Uc7A/6vnYJ/V87I96Pm/tjzJ4JEkvvviiq5sAAAgLCwMAXLp0ycUtcV/OulYBAQFo2bIlTp48CbVabTKvjjiniDi3DtmmMa6f+HNz8eJF2bdN0sT3/bFjx9CtWzeDx8rKylBaWorU1FQXtIzswZ8dIvfC/qjnYH/U87FP6vnYH/UO3vhzw7EC5Lbq6+uxb98+KBQKREdHu7o5BKBXr16orq7G7t27TR7btm0bAO0cL+RaeXl5AICYmBgXt6TpEN/34s+BvoyMDADanx9yb3v27AHAnx0iuoL9UffD/qjnYJ/Uudgf9Q7e2B9l8Egul5OTA0EQDO6rr6/HvHnzUFhYiH79+qFFixauaRwZGDduHADg3XffRW1tre7+HTt2YNu2bejZsyeHIDnJmTNncPz4cZP7T506hdmzZwPQDpkh57j22mvRpk0brFq1Cvv379fdX1lZif/973/w8fHB6NGjXdhCEh06dAjl5eUm92dlZeGLL76An58fhgwZ4oKWEZErsT/qOdgfdS/sk7oP9kc9R1PrjyoE49+wRA2UlZWFn376CQBw/vx5bN26FW3btkV6ejoAoEOHDpgyZYru+QMHDgQApKamIjIyEhUVFdi1axeOHDmC1q1b49tvv/WqtN+d2HutAGDmzJlYunQp4uPjccMNN+DcuXP47bff4O/vj8WLFyM+Pt7px9EUZWZm4t5770V6ejo6dOiA0NBQFBYWYsuWLaiursbo0aMxZ84cr1kJzRP89ddfmDx5Mnx9fTF8+HAEBQVh/fr1OHnyJJ544gk8/PDDrm4iAVi4cCE+++wzXHvttYiJiYGfnx8KCgqQkZEBpVKJV199FWPHjnV1M4mogdgf9Rzsj3o29kndC/ujnqGp9UcZPJLsli1bhhkzZph9vFevXvjmm290tz/55BP8+eefOHr0KEpLS+Hj44O2bdtiwIABuP/++xEaGuqMZjdJ9l4rANBoNPjuu++wZMkSHDt2DAEBAejduzeefPJJfrvsRMXFxfjggw+wZ88elJSUoKqqCkFBQejatStuv/123HLLLa5uYpO0Z88eLFiwALm5uairq0N8fDzuvfdejBw50tVNo8t27tyJ77//Hvv27cPZs2dRW1uLq666Cunp6bjvvvvQvXt3VzeRiGTA/qjnYH/Us7FP6n7YH3V/Ta0/yuCRiIiIiIiIiIiIZMc5HomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHskmCxcuRKdOnbBw4UJZtpeZmYlOnTrhnnvukWV7RLY4efIkOnXqhIEDB7q6KV6vU6dO6NSpk6ubIUnuz7OmYtmyZejUqROmT5/u1fskIiIC2G90JvYbvQ/7jaTPx9UNIPMc+fDt1asXvvnmm0ZoTdN0zz33YOfOnQb3BQQEICgoCO3atUNSUhKGDh2K7t27y75v8ZfbtGnTZN+2o+rr6/HTTz9h9erVKCgoQGVlJUJCQhAREYHOnTujV69eGDJkCEJDQ13dVCJZZWZmYuLEiSb3q1QqhISEoEuXLhg9ejRGjBgBhULhghYSEXkWd+znbty4Efv378egQYPQpUsXu1/PfqMh9hupqWK/kcgQg0c3lpaWZnJfZWUlCgoKzD6emJjYKG0JCwtD+/btERYWJsv2mjdvjvbt2yM6OlqW7TW26OhoXVvr6upQVlaG7Oxs7Nq1C59//jl69eqFuXPnIiYmRrZ9vv/++wDcpwNZWVmJyZMnIycnB4D2PZGYmAiNRoPjx4+joKAAK1euREREBAYMGODi1krz9fVF+/btERkZ6eqmeL327du7ugmNRv+zt6amBidPnsT27duxfft2bN26FW+//bYLW+ddgoOD0b59e7Rs2dLVTSEimblTP1e0ceNGLF++HDExMQ4FjyL2G9lvJPuw30hyYL/RfTF4dGM//PCDyX36355IPd5YJkyYgAkTJsi2ve7du2Pt2rWyba+x3XbbbSYducrKSqxfvx7vv/8+du7cibFjx+Lnn3/2mDDVXvPmzUNOTg7CwsIwb948XH/99brH1Go1du/ejWXLlsHf39+FrbQsMjLSo953nsybz7PxZ299fT2++eYbzJ07F6tWrcLIkSNxww03uKh13mXw4MEYPHiwq5tBRI3Anfq5cmO/kf1Gso83n2f2G52H/Ub3xTkeiRwUFBSEMWPGYNmyZUhMTMS5c+fw7LPPurpZjaK+vh6//vorAOD555836DwC2mEDPXv2xJw5c9CnTx9XNJHIZXx8fPCf//wHSUlJAIDt27e7uEVERORu2G+8gv1GasrYb6SmiMGjF9Gf+Pb8+fN47bXXMHDgQHTt2tVggtWMjAy89tprGDlyJHr16oWkpCQMGjQIL7/8MoqKiqxuW5/+BK61tbVYuHAhBg8ejKSkJNxwww2YM2cOqqurTbZnbnEZ40mcV6xYgTFjxiA5ORm9evXCY489hhMnTpg9B/v27cNDDz2Enj17IjU1FePGjdN9g9ZYkxa3aNECb7zxBgBg586dyM3NNXj8zJkz+OabbzBp0iQMHDgQSUlJ6NmzJyZMmIBffvnFZHviuRaJ7Rb/O3nyJADtt8UbN27EjBkzMGzYMKSnpyM5ORlDhw7FvHnzcP78edmO8dy5c7rr6OjQo8OHD2PGjBkYOHAgunXrht69e2PKlCnYsWOH5PMHDhyoO96dO3fivvvuQ48ePdCrVy88+uijOHr0qO65mzZtwl133YW0tDT07NkTTz31FE6dOmWyzYZMEl5aWoo33ngDN998M5KSkpCSkoKBAwdi0qRJ+O677wyea21iY3Pvf/376+rq8P777+Omm25CUlISrrvuOrz66qu4cOGC2TZevHgRn3zyCcaMGYO0tDQkJydj1KhR+Oyzz1BbW2vyfGufGd9++y06deqEBx980Ow+L1y4gG7duqFr164oLS3V3W/u582e86i/j/nz52P48OFISUnR/Wz/+OOP0Gg0kq+pr6/Hp59+qtvPddddh5kzZ+Ls2bNmj6WhWrduDUA7rE5KUVERXn75ZYOfgcmTJ2Pr1q2Sz58+fTo6deqEZcuWST5u7nNZ//6Kigr897//Rf/+/dGtWzcMHjwYH3zwAerr6yW3KQgCli5dilGjRqF79+649tpr8eSTT+LYsWNmj9vRz6J77rkHnTp1QmZmJvbv34/HHnsMffr0QefOnXXHbO1nyd73Rn19Pb766ivcfvvtSE1NRbdu3dCvXz/ccccdWLBgAcrLy80eJxG5Xn19PX744Qfceeed6NGjB5KSknDzzTdj/vz5qKyslHzN5s2bMWnSJPTu3Rtdu3bFNddcgxEjRmDWrFk4fPgwgCv9g+XLlwMAZsyYYdD3knNRCfYbbcN+4xXsN7LfyH4j+42ejkOtvdD58+dx22234dSpU4iPj0dQUBCUyisZ8wMPPACNRoPw8HC0bt0aarUaJ0+exOLFi7F27Vp89913iI+Pt2ufdXV1uP/++5GVlYX4+HjExMTg2LFj+PLLL3Hw4EF8/vnndh/H22+/jU8++QQxMTGIi4vDv//+i3Xr1mH37t1YuXIlwsPDDZ6/fft2PPjgg6itrUVQUBA6dOiAoqIiPP7445gxY4bd+7fH1VdfjeTkZOTl5WHLli1ISUnRPbZ06VK89957aNasGVq1aoXExEScP38eu3btwq5du5CTk4NXX31V9/zo6GikpaVh9+7dAEznOBKHpJw5cwaPPvoolEolrrrqKrRr1w4XL15EYWEhFi1ahLVr1+LHH39EREREg48vMDAQCoUCgiBgz549SEhIsOv1v/32G5599lnU1dUhMDAQ8fHxOHv2LLZu3Yo//vgDL7zwgtkVzjdu3Ih58+ahRYsWaNu2LY4cOYKNGzciLy8Py5cvx+rVqzFnzhxERUWhTZs2+Pfff7F69Wrs27cPK1askGUIT0VFBcaNG4fjx4/D19cX7dq1g7+/P0pKSpCRkYG8vDzcfffdDd6PSBAETJ06FVu2bEFcXBw6duyIgwcP4vvvv0dGRgZ++OEHXHXVVQavOXXqFO6//34cOnQIPj4+iImJgY+PDw4dOoQ333wTmzdvxueff45mzZqZ7M/cZ8Ytt9yCOXPmICMjAxcuXECLFi1MXrtu3TrU1dXhhhtusDoHrCPn8eDBg5g0aRJOnTqle01tbS327NmDvLw8bNu2De+9957BxNxqtRpTp07F77//DgCIi4tDs2bNsGzZMmRkZDTK6pT19fU4cOAAAKBDhw4mj+fl5WHy5MkoLy9HQECArtrlzz//xJ9//olHHnkEjz/+uKxtqqiowPjx43Hs2DEkJCRAqVTi+PHjWLBgAYqLizF79myT17z66qu6IUExMTFo0aIFNm7ciG3btuGuu+6S3E9DP4t27dqFjz/+GD4+Pmjfvj0CAgJsOj5H3htPPfUU1q1bBwBo27YtQkNDcfbsWezZswc5OTkYPHgwQkJCbNo/ETlXZWUlHnroIezatQtKpRLR0dEIDAzEkSNH8NFHH2HDhg345ptvDH4/fvvtt5g1axYAoGXLlujcuTMqKytx7NgxFBQUoE2bNujYsSP8/f2RlpaGY8eO4dy5c4iLizPoZ8o9HJr9RsvYb7QP+41XsN/oOPYb2W9sVAJ5lL/++ktITEwUEhMTTR5bsGCBkJiYKHTp0kUYP368UFxcrHvs0qVLuv9fvHixUFJSYvDaixcvCh9++KGQmJgoTJgwwey2FyxYYHD/zz//LCQmJgpdu3YVbrnlFuHff//VPZaTkyOkpaUJiYmJwtatWyWPw3hfJ06cEBITE4Wrr75aSEtLE7Zs2aJ77PTp08KIESOExMRE4c033zR4XUVFhdC3b18hMTFRmD59unDx4kVBEARBo9EI3377rdCtWzez582SCRMmSB63lLlz5wqJiYnC/fffb3D/rl27hB07dgj19fUG9+/fv18YOnSokJiYKGRmZppsz1p7y8vLhWXLlgmlpaUG95eVlQmvvfaa7lzI5Y477hASExOF1NRU4eOPPxaOHj1q0+v2798vdOvWTUhKShKWLFkiqNVq3WObNm0S0tLShC5dugj79+83eN2AAQN0763PP/9c97qysjJh3LhxQmJiojBlyhQhOTlZWLlype51RUVFwo033igkJiYK3333ncE2xffXgAED7Dr2RYsW6a6t8fkuLCwUvvjiC4P7xJ+L5557TnJ75t7/4v3i+3/Hjh0G+xk5cqSQmJgoTJs2zeB1arVaGD9+vJCYmCg8+eSTwpkzZ3SPFRcXC3fddZeQmJgozJ071+B1tnxm3H///UJiYqKwePFiyWMRf0ZWrFhhcL/U+9fe81hVVSUMGjRISExMFGbNmiVUVFToHjt48KAwbNgwITExUfj2228NXvfVV18JiYmJQs+ePYVdu3bp7j9x4oQwfPhwoWvXrjb/XIvMffZeunRJ+Oeff4Qnn3xSSExMFK6//nqDdgqCIFRXVwv9+/cXEhMThccff9zg8WXLlgldunQREhMTDT7vBEEQnnvuOSExMVH4+eefJdtk7nNZvL9r167C3XffbfB5v2nTJt3+Dh06ZPC6jRs3ComJiUK3bt2EdevW6e4/d+6cMGHCBN15M35fO/pZJL53unTpIrz44otCdXW17jHxM9zcz5Ij7438/HwhMTFRuOGGG0yOvaKiQvjxxx+FoqIik3YSkfNY6ueKn7P33nuvcPz4cd39Fy5cEKZOnWry+7Gurk7o2bOncPXVVwsbNmww2FZdXZ2wefNmYefOnQb3W/vctYb9xivYb2S/UQr7jew3st/YNHGotRdSqVR47733EBUVpbtP/9u78ePHm6zO1qxZMzz00ENIT0/Hzp07JYcbWFJfX4+5c+carEiWkpKCsWPHAgD++OMPu7c3depUg4l2W7ZsiSeeeEJye6tWrcKZM2fQoUMHzJo1S/ftnEKhwN13341hw4bZtX9HiOfbuDy8R48euOaaa6BSqQzu79y5M1588UUA0M2DY4/g4GCMHj3a5NvEkJAQvPjii4iOjsaaNWvMlsbb6+WXX0aLFi1QVVWFt99+G0OGDME111yDBx54AJ9++imKi4slX/fBBx+gtrYWzzzzDMaNG2dQfTtw4EA8+eSTUKvV+PrrryVff/311+M///mP7nUhISG6Cdu3bNmCsWPHYsSIEbrnR0dHY/LkyQCAP//8U5ZjF4fn3HXXXSbnu3Xr1rjvvvtk2Y+ovr4e06ZNwzXXXGOwH3Fo1vr16w2mHNiyZQtycnKQlJSEefPmGXxDGBUVhfnz5yMgIACLFy/GpUuXTPZn6TNDPLerVq0yed2pU6eQlZWF5s2b48Ybb7R6XPaex59//hnHjx/H4MGDMXPmTAQFBekei4+Px1tvvQWFQoEvvvhCd78gCLrbjz/+OHr06KF7LDY2FnPnzjU7pMVW+kPYunfvjhEjRmDNmjUYP348fvzxR4N2AtpzV1RUhIiICLzxxhsGj48ePRrjx48HAHzyyScNapcxlUqFt956y+DzfuDAgbprZfzzsWjRIgDaoSxDhgzR3R8eHo533nnH7H4a+lmUkJCAV155Bc2bN9fdJ1Vhoc+R94Y47Oemm25Cx44dDbYXFBSEsWPHeu0iD0Se7sCBA1i9ejViYmLw/vvvo02bNrrHQkNDMW/ePERHR2P9+vUoLCwEoB2iWVZWhsTERAwaNMhgez4+PhgwYAB69uzp1OPQx34j+41yYb9Ri/3GhmG/kf3GxsSh1l6oT58+JsGisfz8fKxbtw6HDh1CZWUl1Go1gCs/YAcOHLC6DX1dunTRTZCrT7xPnF/GHrfffrvZ7RnP8yhOyjtq1Cj4+Ji+rceMGaObt6exiGXeVVVVJo9VVlbit99+Q3Z2Ns6cOYNLly5BEATd/Cliqb0jduzYgd9//x1Hjx5FVVWVbn6KiooKXLx4EceOHTP5sHRE586dsWrVKnz22WdYtWoVzp49i9LSUvzxxx/4448/8N5772HSpEl4/PHHdZ292tpabN26FSqVCmPGjJHc7sCBAzFr1izs2rVL8nGp94H+fEFSj1999dUAHHvfSRF/qWzcuBE33HCD5HtMTr6+vpLH1blzZ6SnpyM7Oxvbtm3DnXfeCQDYsGEDAG1nRKptrVq1QlJSEjIzM7F3716DThVg+TNj0KBBaNasGbKysnDq1CmD561ZswYajQYDBgxAYGCg1eOy9zyuX78eAHRfYBjr3LkzYmJicOLECZSUlCAqKgqHDx9GUVER/P39Jd9zXbt2RUpKismcWvbQH8am0WhQXFyM06dPY+3atejQoYNJR3jbtm2645AawjVx4kR8//33yMnJQXV1tc1DRqy57rrrDP4oECUlJZn8EVJVVYWcnBwA0L2v9LVs2RJDhgzB6tWrze7P0c+ikSNHGvxhaQtH3hviudixY4fZIWBE5J42btwIALj55ptN/kgHgObNm+Paa6/FsmXLkJWVhZiYGISHh8PPzw9Hjx7FgQMH0LlzZ2c32yL2G9lvlAv7jVrsNzYM+43sNzYmBo9eSGqeCJEgCHjttdfw/fffW9xGWVmZXfvU/+ZZnzg/jlSnypKwsDAEBweb3C/OT2K8YI34jZi5xWMaY1EZY+IxGneI9+3bhwcffBCnT582+1p7zzeg7Zw9+eSTus64OZYmlbZXy5YtMWPGDMyYMQOHDx9Gfn4+duzYgc2bN6O8vBwfffQRfH19MXXqVADa61JTUwNfX1888MADktsUBAEAzFbZtm3b1uQ+/XmXpB4X54yx931nzpgxY7Bo0SIsW7YMf/zxB6677jqkp6fjmmuuMfveb4ioqCjJP6wAoGPHjsjOzjaYJP2ff/4BACxevFjyG2bgys+I1PvQ0mdGUFAQ+vfvj7Vr12LNmjUGnSNxX7ZWFNt7HgsKCgAA7733Hj766CPJbYoTk586dQpRUVG642zdurXBN6H6OnTo0KAOpDiXjb78/Hw8+eSTmDNnDlQqlcHcU2KbzM2dGxcXB19fX9TV1eH48eOy/XFs7XNZ/3P0+PHj0Gg08Pf3N/s6c++Thn4WOfIHriPvjdTUVN2cav3790efPn3Qs2dP9OzZE127djWY04eI3Iv4M79x40bdH7vGxAUSxf6E+Fm8aNEijB49Gmlpaejduzd69OiB9PR0Webyawj2G9lvlAv7jVrsNzYM+43sNzYmBo9eyNK3HitWrMD333+PgIAA/N///R/69u2LyMhIXXnyM888g19//dXuYRbm9mnvtxGObu/ixYsAYPbbM1u+VWsocciIfudGrVbjiSeewOnTp3HDDTfggQceQHx8PEJCQqBSqXDs2DEMGTLEoWEtn3zyCTZu3IiWLVvimWeeQc+ePdGyZUv4+fkB0H77tHv3btmGzBjr2LEjOnbsiFtvvRWlpaV44okn8Ndff2HRokWYMmUK/Pz8UFFRAUC7+JA46bk5NTU1kvdLlc7rf9BLdRLs/UXw2GOP4cyZMyb3ix2FyMhILFmyBO+99x62bNmC5cuX6ypoU1JSMH36dKSmptq1T0uMJwCXeky/cyyu5Cn+UrVEasiMtW9KR4wYgbVr12LVqlW6DuTx48eRn5+PkJAQXH/99Vb3C9h/HsXj+vvvv20+LvG8GC8+pU+OifONJSUl4YUXXsBDDz2EDz74AHfccQd8fX0BXOmombuuCoUC4eHhOHXqlGx/9ADWP0fFP96AK+fN0kTv5s5bQz+LzHX0LXHkvaFUKvHpp5/i/fffx8qVK7Fp0yZs2rQJgHZC9KlTp5qtsCEi1xL7E8eOHbO4Wipg2J945plnEBkZie+//x5ZWVnIysoCoA1H7rrrLkybNk33WeVs7Dey3ygX9hsNj4v9Rsew36jFfmPjYPDYxIhzwjz33HO44447TB4vKSlxdpNkIX4AGVdCiuT8UDYnOzsbANC9e3fdfXv27MGxY8d0cxIZd27NzW9jC/FazpkzB9ddd53J4868lmFhYXjxxRcxbNgwVFdX49ChQ7j66qt1gW9kZKTd83w60969e3VzQpnTsWNHLFiwALW1tcjJycGuXbuwevVq5Obm4v7778evv/6K2NhYAFc6sPq/oPWJQbk5xvM9ST2mH6aLHYUvvvgCffr0sbhtR1x//fUICQlBfn4+jh07hnbt2um+tR4yZIhdf7TZcx4DAgJQXl6O9evXo127djZtXzwvls7huXPnbG6vPcTOb2lpKU6ePKmb81a8Pub2KwiC5HW19j4y93nnCHG/4re9Usy13xWfRY68NwDtXHAvvPACnn/+eRw4cAC7du3Cxo0bkZmZiRkzZiAgIAA333yz7O0looYRP0dnz55tdqicFKVSiXvvvRf33nsvTp48iaysLPzxxx9Yv349PvnkE1RVVeGll15qrGZbxH4j+43sN1rHfqMp9hvtx36j63FxmSZGnLtE6lu2uro6HD582NlNkkVcXByAK0MHjNnyjV5D/P3338jPzwcA9O/fX3e/2Cnp2rWr5C/ZhszRI25b6lqWlpbavUBQQ+mX2YuTMLdr1w6+vr44c+aMrEN35LZ582b8888/Jv9J8fPzQ+/evTF16lSsWrUKaWlpqK6uNpjDRAzCzXVirFVrFBcXmw3LxZ9R8T0PXBly0Fjvcz8/PwwePBjAlWEy4vEOHz7c4W1aO4/icR08eNDm7Yrnpbi42GxH/d9//3WozdaIc9MAhsPgxDYdOnRI8nVHjx5FXV0dVCqVwRAwa++j48ePN7TJOm3btoVSqURNTY3ZOa7MnTdXfBY58t7Qp1Ao0KVLF0ycOBFff/01pkyZAgBYunSpbG0kIvmIQw4b8nsuNjYWt956K9555x18+OGHALQLDuh/djtr6Bz7jew3st9o/zbZb9Riv9F+7De6HoPHJkYcfiD1DcSyZcssftvjzvr27QsAWLlypW6hHH3Lli1rtH1fuHAB06dPBwBce+21Bt9ci+f77NmzJq+rq6szuyKf/mulhjjoPy51Lb/44gvJ8+Co+vp6q/MJiUNilEqlrjPZvHlz9OvXDxqNBt98841s7XEXKpVKt+CR/hw44vHv37/fZJiARqOx+n6sq6vDTz/9ZHJ/QUEBsrKyoFAodO95ALqV5JYsWWJ26FFDiasUrl69GgcOHMChQ4fQsmVL9O7du8HbNncexeP6+uuvzX57a6xDhw6Ijo7GpUuX8Msvv5g8vn//frPzgzWUuF2FQqH79h0A+vXrB0DbOZG6PuLPRlpamsEwF/F9JP5xqq+kpEQ3+bgcAgMDkZKSAkA755Oxs2fP6ibmNubMzyKRI+8NS5KTkwFIz2VFRK4nrkq9cuVKixU2thI/7y5dumTQvxHnfTTX95ID+41a7Dey3+go9hvZb7QX+42ux+CxiUlPTwcAvPvuuwYh4x9//IF58+a5fKJtRw0bNgwtW7bEoUOH8PLLL+s+pAVBwPfff2924uSGqKysxPLlyzFmzBgUFBSgZcuWmDt3rsFzkpOT4ePjg927dxv8MquoqMAzzzwj2bEUib88du7cKfm4eC3nzp2r+5ZTEAT88ssv+Pzzz81ey5MnT6JTp07o1KmTzav3VVdXY+DAgZg3bx7++ecfgw9sQRDw+++/6zrR/fv3N5gn5fHHH4efnx8+/PBDfPLJJyYd4tOnT+Orr76SnHjZXcyfPx9Lly5FeXm5wf0FBQVYs2YNgCsrIgLaldFatWqFM2fOYOHChbrzVVNTg9dff91qZbGPjw8WLlxocO1LSkrw3HPPAdD+8tT/hnPw4MFISUnBv//+i4ceesjkm/Ha2lps2bIFM2bMcODotXr37o2WLVvi8OHDeOuttwAAt9xyi13zuNp7HsePH482bdogMzMTzzzzjMkv96qqKvz222+YM2eO7j6lUqmbT+jdd981mCOqsLAQzz33nG4OHTnt2bMH//3vfwFovwjRn9dm+PDhaN26Nc6ePYvp06cbVCWsWLECS5YsAQCTifTFOZA2bdqErVu36u4/ffo0nnnmGdk7ZpMmTQKg7ZTpT/h9/vx5PPPMM2Y7ao5+FjWEI++NlStX4oMPPjD53CstLdV14vXff0TkPpKSkjB06FBcuHAB999/P/bt22fwuFqtRmZmJp5++mndys+HDh3CSy+9hD179hh8ftXW1uoqHmNiYgzmKBP7XllZWbL8caqP/Ubo9sl+I/uNtmC/kf1GubDf6Hqc47GJmTx5MlavXo28vDwMGDAA7du3R3l5OQoLC9G7d2+0atVKN++CJwkKCsK8efMwZcoULF26FGvXrkVcXBxOnTqF06dPY/r06Zg7d67Di938/PPP2L59O4Ar3+KeOHFCVyLfu3dvvPHGG4iKijJ4XcuWLTFx4kR8/vnneO655/Dee+8hLCwMhw8fhlqtxgsvvIBXXnlFcp9Dhw7FwYMH8dBDD6FTp0661ereeecdtGzZEtOmTcP27duxefNmXH/99WjXrh3OnDmD06dPY9SoUSguLjbb+bSXQqFAZWUlFi1ahEWLFiE0NBQxMTHQaDQoLi7WfaudmJiI1157zeC1Xbp0wTvvvIP/+7//w9tvv433338fHTp00A2lEecrMrd6oTs4ePAgPvroI7z00kto06YNQkNDUVZWpuuo9e7dG6NGjdI9X6VS4ZlnnsGzzz6Ljz76CD/++CNat26No0ePQqPR4KmnnsIbb7xhdn+pqakIDAzEPffcg7i4OAQEBKCgoAD19fVo06YNXnzxRYPnK5VKLFy4EA8++CC2b9+OIUOGoF27dmjRogWqqqpw7Ngx1NXVNWhybKVSiVtuuQVfffUV/vzzTwD2D5ex9zwGBgbi448/xpQpU7Bq1Sr89ttvaN++PYKCgnQ/g2q1Wveto+iee+7B9u3bsXXrVtx5553o0KED/P39cfDgQbRq1Qrjx4/Ht99+6/C5uPPOO3X/r9FoUFJSopuPpk2bNpg1a5bB85s3b453330XkyZNwm+//YYtW7agQ4cOOHfunO79//DDD+OGG24weF3Hjh1x++2346effsKUKVMQGxuL4OBgHDx4EG3btsWdd95psfrFXoMGDcL48eOxZMkSPProo4iNjUVoaCgOHToEf39/TJo0SXIlQGd+FokceW+cP38eCxYswIIFCxAZGYlWrVqhpqYGR44cQV1dHSIjI/H444/L2k4iks9///tflJeXIyMjA6NHj0br1q3RsmVLXLx4EcePH9cFVK+//joAbRXYkiVLsGTJEoSEhKBNmzYQBAEnTpxARUUFfH198fLLLxvsY/DgwZg/f75uDrno6GgolUqMHj3arkUE2G9kv5H9RvYbRew3GmK/sWli8NjEtG7dGosXL8Y777yDHTt24N9//0VMTAymTZuGKVOmuGyCbTn06dMHS5YswYIFC5CdnY3Dhw+jY8eOmD59OgYMGIC5c+c6vLp1cXGx7oO+efPmCAoKQlpaGrp3746hQ4caDJMx9uyzzyIqKgqLFy/GiRMncPHiRVx77bV4+OGHLa5CN2XKFGg0GqxevRqHDh3SfYMvVnN269YN3333Hd59913k5OTgyJEjaNeuHaZMmYIJEyZg4sSJktsVvy2/6qqr0KpVK5uOPzg4GOvWrcPWrVuxfft23aqStbW1CA0NRd++fTF48GDcdtttknMSDR48GKtXr8aXX36Jbdu24ciRI1AqlYiMjMTgwYMxaNAgDBw40Ka2uMLDDz+Mjh07IjMzE0VFRSgqKkJ4eDh69eqF2267DcOHD4ePj+HH6ahRo+Dn54dPP/0Uhw4dwsmTJ3HttdfiiSeesDpJtUKhwPvvv4+PP/4YK1euxKFDhxAWFoZBgwbhsccek1x5r1WrVliyZAl++ukn/PbbbygoKEBRUREiIiLQvXt39OnTB0OHDm3QeRg+fDi++uorANq5XSy976U4ch47duyIFStW4Pvvv8fGjRtx+PBhnDhxAi1btkTPnj1xww036IZPiFQqFT744AN88cUX+Pnnn3HixAm0aNECt956K5588skGV0nofxuuUCgQGBiIpKQkDBo0CBMmTND9sacvOTkZK1aswMcff4xt27bhn3/+QUBAAPr164eJEyeadB5Fr776Klq3bo1ffvkFxcXFqKurw/jx4/HEE0/oroWcXn31VXTt2hXfffcdjhw5oqtaefLJJ3ULIRhz9LOooex9b9x0002oq6vDjh07cOTIERQUFKB58+ZITEzE4MGDcffddyMkJKRR2kpEDRcYGIjPPvsMq1evxi+//IK///4b+/btQ4sWLdCpUyf06tULQ4YM0VXLtGvXDrNnz8a2bdtw4MABHDlyBIC2Lzxs2DBMmjTJoAoM0P5u++ijj/Dxxx9j3759KCoqgiAI6NWrl11tZb+R/Ub2G9lvFLHfaIj9xqZJIcg9joDIDe3duxe33XYbOnfujBUrVri6OS71xRdfYO7cuZg2bRqmTp3q6uaQnszMTEycOBG9evXyyrmNiIiIyLOw3+i+2G8kIk/BOR6pSRAnZU5LS3NxS1xv9+7daNasGe666y5XN4WIiIiI3Bj7jURE1FAMHslr/PXXX1i9erVuaAmgnd/niy++wA8//AClUolx48a5sIXuIScnB6NGjZIcdkFEREREJGK/kYiIGopzPJLXKCoqwowZM+Dr64uYmBgEBQXh6NGjqKysBAA8/fTT6NKli4tb6Xrbtm1zdROIiIiIyAOw30hERA3F4JG8Ro8ePTBhwgRkZmbi9OnTOHnyJEJDQ9GzZ09MmDAB/fr1c3UTiYiIiIiIiIiaDC4uQ0RERERERERERLLjHI9EREREREREREQkuyY31Fqj0aC+vh5KpRIKhcLVzSEiIiKyiyAI0Gg08PHxgVLJ75A9EfujRERE5Ols7ZM2ueCxvr4e+fn5rm4GERERUYMkJSXBz8/P1c0gB7A/SkRERN7CWp+0yQWPYgqblJQElUrl4tZ4P7Vajfz8fJ5vN8fr5Dl4rTwDr5Pn8MRrJbaZ1Y6ei/1R5/LEn/OmiNfJc/BaeQZeJ8/hqdfK1j5pkwsexeEsKpXKoy6op+P59gy8Tp6D18oz8Dp5Dk+8Vhyi67nYH3UNnm/PwOvkOXitPAOvk+fw1GtlrU/Kr8qJiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdgweiYiIiIiIiIiISHYMHomIiIiIiIiIiEh2DB6JiIiIiIiIiIhIdj6ubgAREdlOo9GgqKgIxcXFiI6ORmpqKpRKfodERERERERE7ofBIxGRB8nLy0NxcTEAoKioCACQnp7uyiYRERERERERSWKZDBGRBykpKbF4m4iIiIiIiMhdMHgkIvIgUVFRFm8TERERERERuQsOtSYi8iDJyckoLi6GQqHQzfFIRERERERE5I4YPBIReRClUonWrVsjJSUFKpXK1c0hIiIiIiIiMotDrYmIiIiIiIiIiEh2DB6JiIiIiIiIqMnIKCvD0Lw8xG7fjqF5ecgoK3N1k4i8FodaExEREREREVGTkFFWhv65uRAEAWoAJbW12HjhArakpKBvaKirm0fkdVjxSERERERERERNwuyjR3WhIwCoAQiCgNlHj7qwVUTei8EjERERERERETUJ+VVVutBRpL58PxHJj8EjERERERERETUJSYGBUBndp7p8PxHJj8EjERERERERETUJM+PioFAodOGjCoBCocCLcXEubBWR92LwSERERERERERNQt/QUGxJScHgsDDE+PlhcFgYtqakoA8XliFqFFzVmoiIiIiIiIiajL6hoViTnOzqZhA1Cax4JCIiIiIiIiIiItkxeCQiIiIiIiIiIiLZMXgkIiIiIiIiIiIi2TF4JCIiIiIiIiIiItlxcRkiIvIqGo0GOTk5KCkpQVRUFFJTU6FU8ns2IiIiIiIiZ2PwSEREXiUnJwfZ2dkAgMLCQgBAenq6K5tERERERETUJLEEhIiIvEpJSYnF20REREREROQcDB6JiMirREVFWbxNREREREREzsGh1kRE5FVSU1MBwGCORyIiIiIiInI+Bo9ERORVlEol53QkIiIiIiJyAxxqTURERERERERERLJj8EhERERERERERESyY/BIREREROQCly5dcnUTiIiIiBpVkw0eX3rhDQiC4OpmEBEREVETNWLgnTh9+qyrm0FERETUaJps8Fj4cxbGDJuIixcvuropRERERNQEXVMajJvTb0Ve3t+ubgoRERFRo2iyweM1ilBE51diQM9R+OefQyguPoWamhpXN4uIiIiImog4+ONWxGLKTQ9iyeJfUFx8ChculLm6WURERESyabLBoxIKdEcgbigLxYTr7sVNSSOQEtcPv/22ydVNIyIiIqImQADQCj64zbcNvnzyA9yUNALXdrwRDz7wDNRqtaubR0RERNRgPq5ugKu0G94LR5ZuQ3v44w7/dlADuAgN3rp/FjIfyEZaj+4IC2+Bfn17QalssvksERERETWSQR88inUPvIsQtQpDfVrhkk9LaCDgnzUFuLn/OEx95gEoVUpc1683WrQIdXVziYiIiOzWZIPHQW8+gNzEWOz872IEXi78DIESI3xb468vtuKPz9aiVlAjtGs0lq78HIGBAS5uMRERERF5k7iBKbhj3Rz8NOZV+JVfhB8UAICeimCEHL2E9x56ExoImKm6hEW/fIgePZJd3GIiIiIi+zTZ4BEA0h8ajo5D0nH+wAlcPF+BP2d9j+bVNeivaAHBpwXqARwsuIgB6cPx84Zv0KZNjKubTEREREReJLxTLO7LXICi7ftQX1OH3Z/+hvM5/6ILmqOTTzMIAM5BjWnDp+Kxd57EnXeNcXWTiYiIiGzW5McQt+gQjQ639ELXCTdi4p9vI7BjFBRQQAkF/KBAVwRgUFUERl4zDjv+ynJ1c4mIyAk0Gg2ys7OxevVqZGdnQ6PRuLpJROTF/IKaI25IOuJHXIOxK15F5/8MhqDQzkmugkI3D+RXT/8PL8x4HYIguLrJRERERDZp0hWPxgJatcCE399E9akL0KjV2PHWUvz7Uwbawg+3K9vgmVufgrJtMJQ+Ktx+50hMnToJCoXC1c0mIiKZ5eTkIDs7GwBQWFgIAEhPT3dlk4ioiVAoFOj/2r249unbUVd9CcVZB7Hxsf8hqB4Y6hOJv77OQI9fbkRgaCA6JLTD/AWzERbWwtXNJiIiB2SUlWH20aPIr6pCUmAgZsbFoW8o5/Ql7+L04HHFihXIzs7G3r17UVBQgLq6OsyZMwdjxkgPG6msrMTChQuxfv16nDlzBi1btsSQIUMwbdo0BAUFyd4+hUKBwKgwAMCQ+Q8jL7kjtr/4Na6CD0b7xqK4uBYCgE1zlyJzWxY+/2YB/Pz8ZG8HERG5TklJicXbROT53L1P6h8aCP/QQCSMuAotu7bDj6Negf+FKvRTtkDbqkDUV2pQVngSg9JG4od1XyAxsaPsbSAiosaTUVaG/rm5EAQBagAltbXYeOECtqSkMHwkr+L0odbvvfcelixZgqKiIrRq1cric6urqzFhwgR8+eWXaN++Pe677z507NgRX375JSZMmIDq6upGb2/yfUMwYvEMCL4qBEGJBDRDIpphkDICzbeXIKn1tegYkYo+abfgyJHjjd4eInJPHJrbcO50DqOioizeJiLP50l90hYdonHvtncQ3DkWKijQXvBDApqhB4IwrD4ad/W7Bx0jUtEltje++mJJo7aFiIjkMfvoUV3oCABqAIIgYPbRoy5sFZH8nF7xOHv2bLRr1w4xMTH45JNP8Pbbb5t97meffYb9+/dj8uTJ+L//+z/d/QsWLMAHH3yAzz77DI899lijtzm2b1fctXkeMub8gIvnKlBaUAiUViINgYgLSIQGAsrPqHF73zswf/E7uP76axq9TUTkXjg0t+Hc6RympqYC0FY6RkVF6W4TkffwtD6pf2gg7vhtNnbOX4ainf+gtrwaZftPoDV8cYd/HC4qNKgTBPz4/KfI37MP895+GUplk5/OnYjIbs4a/pxfVaULHUXqy/cTeROn90b69OmDmBjrq0MLgoClS5ciICAAjz76qMFjDz74IEJDQ/HTTz85bXLt0LhI3PLxE7jtpxfxn6z3EX1jMhRQ4CpBhZaCDzrCH7ep2uKFsc/h00++dUqbiMh9cGhuw/EcEpEzeWKfVOXrg2ufHYfbfnoRd66fgwELHoagVCAISrQUfNAavrjJJxIlS7MxaugEVFdfbPQ2ERF5E3H484bSUhTW1mJDaSn65+Yio6xM9n0lBQZCZXSf6vL9RN7EbReXOXr0KE6fPo1+/fohICDA4DF/f3/06NEDmzZtwrFjxxAXF+fUtqn8fDDyi2dwdH02zhcUovzkWRz44XeECz4Y7ReDX1/5Gpk7stHn+l4IDQnG8OGD4e/v79Q2EpFzRUVF6ar0xNty02g0yMnJwcGDByEIAtLS0ryqmsUZ59BW7lR9SUSu5c590k6j+yKye3scWZeN+po65H6+Dn4XqtBHEYq/913EwJ4j8cDT/4FKpcLAAf3Qtq31oJWIqCmTGv6sujz8eU1ysqz7mhkXh40XLkB1eX8qaNeceNHJv0uIGpvbBo/Hjh0DALMduHbt2ume50gnT602Lmq2X9tBqWg7SDv8LmFMH/x69xsIqKnHYFVL5Gz8Fz+v24daoR5vv7oQP6/7Gq1aRTR4n55GPM9ynG9qPLxODde9e3cIgqAbmtu9e3fZz2dOTg52794NALp/vWkIsDPOoSUajQZ5eXkoKSlBRUWFwWPFxcV2tYU/U57DE6+VJ7XVGzRmn1SOaxkcF4nuD94CAOj2nyFYftcclOcfQxICEFKuwvIXv4ZGUGO++l289snLGD58cIP36Wk88ee8KeJ18hzefK32mBn+vKeqSvbjvSYoCJuSkvD6iRO6Yd0vtG2L3kFBsuzLm6+Tt/HUa2Vre902eBT/6DO3SqB4v/Efh7bKz893rGHm+ADJ79+LPc/+AN/SavRCMKAKhgYCjpbW4ub00WibEgeVjwqjRt+E7t27yLt/Nyf7+aZGwevUMAqFAtHR0QCAPXv2yL79gwcPmtxWKBSy78eVGvscWlJUVITi4mLJxwRBQG5urt3b5M+U5+C1InMas0/aGO+7xFduxcH316Hs9wNoB3+0U2pH3VxQRWDBg2/g/c6foFlAc3S6uiPGjx/hVZXz1vDn3DPwOnkOb7xW7dRqlADQX+JQefl+R/qC1gQC+C8A+PsD9fXILSjAc7W1OKTRIF6pxCQ/P6T4NCy28cbr5K289Vq5bfDY2JKSkqBSGc+o0HBp23ph9QPv4sz2/QAAJRTocHn+xxP51RAAfJb5CcY/fw8enXq/7Pt3N2q1Gvn5+Y12vkkevE6eQRAEXaUjACQkJCAlJcV1DfIyxqFjcHAwgoODERUVheTkZLv+OOfPlOfwxGsltpk8X2O971K/SEPuorXYNfdHoE5bjdACKozwjcY/hy+iHlU4nLcTL2btx5IVixAU5N3ziXniz3lTxOvkObz5Ws0tK8ONe/ZAAVwZ/gzgjW7dkBIS0qj7zigrw0N79kC4vO/zajV2XbyITd27O7S4jTdfJ2/jqdfK1j6p2waPwcHBAIDKykrJx8X7xefZS6VSNcoFVYUE4rYlL0BdUwdBI2D3x6uR/fbPaAUftIL2G/GufgHY/MbP2Jt/AB9+PM+j3liOaqzzTfLidXJvaWlpALSVjgkJCV43x6OrRUdHo6ioSHc7MTGxwfM68mfKc/BakTmN2SdtzPdd+pRhSL3/Zmjq1DhXcALLx7+OZlU1SIY2ZNQoA7H/8CUM7jUKP234tknM/8ifc8/A6+Q5vPFaXR8eji2pqQarWr8YF4c+jbCqtbE5J07oQkfgSvA558QJrAkPd3i73nidvJW3Xiu3/YtVnC/n6NGjko+L8+2Iz3M3Kn9f+DT3Q68nRuPmz59CUHw0mrUOh6BUoDmUuFF1FerWHsTN/cfh7NnzuHjxIjQajfUNE1GTpVQqkZqaisTERKSmpjJ0lFlqairS09MRExOD9PT0Bs2fmVFWhmnV1WibmYmheXmNshIiETmHJ/dJlT4q+DT3Q2RyR9y77R1EXtcVzVqHQxXYDEoo0BXNMbi6JUZdOw5/bvsLFy9eRF1dnaubTUTkUn1DQ7EmORkn+/TBmuRkk9Axo6wMQ/PyELt9u6z9vHwz80vmV1XJsn0iV3Hbise4uDi0atUKu3fvRnV1tcEqgjU1NcjKykKrVq3cspNnrP3gNLQfrK1UqiopxZJRLwNF59FTEYyQo5cwoPPNqNXUwy+kOb746X/o0UPe1bKIiMg6pVIpy8rVGZeH6GgAaNRqnKqtxcYLF7AlJcWhYTJE5Fre0idtHhGK0d/PAAAIGg02v/AFDn77O9rAD7cr22Dm7dNRUlsOjRK4Z+pdePHlp71uHmEioobKKCtD/9xc3crXJTL285ICA1FSW2sQPqou30/kydy2XEahUGDs2LGorq7GBx98YPDYxx9/jLKyMowdO9bjOkSBUWG4Z8ubiOjdCUoo0AXNMaF5R9wX2Amj1LGYNnwqPvzwS2zZuh1///0PBEFwdZOJiOyi0WiQnZ2N1atXIzs7u8lVc88+ehQCrkxKroZ2fs7ZZqqliMi9eWOfVKFU4sY5k9D39fsgKICr4INbfVvjvsBOuDegE/7+dDPuvO0BbNm6HdsydqKmpsbVTSYiMquxKhClzD56VBc6AvL282bGxUGhUEAcaKuC9nfQi3FxDd42kSs5veJx6dKlyM7OBgAUFBTo7tu5cycAYNCgQRg0aBAAYPLkydi8eTM+++wz7N+/H127dsWBAwfwxx9/oEuXLpg8ebKzmy8L3+b+uO3HF7D15a9x4MuNCL380RIGFW7zbYO1sxfjO/VF1Gjq0XVIKj79Yj58fX1d3GoicicajQa5ubkoKSlBVFSUWw29zsnJ0X3OFxYWAoAslYSegsNkiDwD+6RA0j2DEBYfg1X3vIHmNfVoDgACcL0yDHt2ncXM8c9DgIDqQAE/rf8aHTvGubjFRESGGrMCUUpj9vP6hoZiS0qKS+aXlFtGWZnBccyMi+PInybM6cFjdnY2li9fbnDf7t27dSu1xsTE6Dp5AQEB+Oabb/D+++9j3bp12LlzJyIiInDfffdh6tSpBkNdPI1CqUT/Wfehy+h+OF9wEpXFpchasBxB9cAQ5VXQKIE6CPh76wkM6Xcblq39GmFhLVzdbCJyE3l5ebrPTXcL90pKSize9nYcJkPkGdgn1Yq9tgsmbn8XJ7bugbqmDrs+WoWLx84gBYHo5hsIAcCp2jqM7Xc33v5+HgYM6OvqJhMR6UhVIKouVyCuSZZ/CrPG7ueJ80t6MmeHweT+nB48zp07F3PnzrX5+cHBwZgxYwZmzJjRiK1ynci0eESmxQMAEkZdg59uew04WwEVAF8o0ANBCC2qwaC0kfhh3RdITOzo2gYTkVtw53AvKipKF4aKtzUaDXJyctyyQlNuM+PisLG0FEpoh1tzmAyRe2Kf9IqAVi3Qaez1AIBO427AmkcW4OS63RDH27SBH8b6tMUrdzyPf175Dx56+D6XtZWISJ+zR5rMjIvDxgsXoLocqrGfZ8rZYTC5P7ddXKYpatEhGvfveh8XDhdDXVOHP1//Hqcz9iMRzRBUH427rp+IyKS2UPmocO+kO3Db7cNd3WQicpGoqCgUFRUZ3LZXY4WB4mrQ+tttSsOv+4aGYlP37pj+9984plKhuwcPkyGipkfl54Phnz2FisKzqKu4iGN/5GPH7O8RJqgwyi8Ga2b9gMVfLUdgSCCu7t4Js2Y/h2bNmrm62UTURDl7pIk3DYduLJx2iIwxeHQzSh8VwjvFAgBG//A8tv33B/z98W9oDV/c7tsWhQdqIAD4eNp8bM/YhTffftlrq4aIyLzk5GQoFAqDcM9ejRUGSq0O7c4Vmo2hb2goFgYEICUlBSqVyvoLiIjcTHBMBAAgvHMbRPdIwPLxryPgUh0GqSLwb2EN6gsvoWhfFgasG4nlG75FVFQrF7eYiNxVY87354oKRG8YDt2YOO0QGWNi5cYUCgWum3kX+r/3MDRKBVpAha4IQDcEYLhPFE4tzcboW+5BdfVFVzeViJxMDPeGDRuG9PR0u7+A0Gg0usUURI0ZBhpXZDpSoUlERK4RlZaAe/54C75RLeALBTqhGboiANcpQnH9hVAM7TkGOTn5rm4mEbkhcb6/DaWlKKytxYbSUvTPzZVt5WmxAnFwWBhi/PwwOCwMW1NSWIHoQlydm4yx4tEDdB7TF+Hx0fjzte9QU16FiiOn4HepDn0Uofj772oM7DkSi358HyEhQWjZ8ioOdyEiq3JyclBRUWFwX2OGgVLDrz2ZI8PUm9I8l42B54/ItYKir8LErW9h64tf43T+v6i9UIVLxaVoD3+MRiweuvkhPP7OU7ju+msQENAcV10V7uomE5EbcMZ8f86sQHTmas2eujI0h6OTMQaPHqJV9w647acXAQC1FdX4efzrKMs/iiQEIqTcB/8ZMAk1mjrUqDR4a9HrGD58sItbTETuzLi6MTg4WBcGNkbAIzX8uiFcHUI5Mky9Kc1z2Rh4/ohczzegGQa9PUV3O+uDldg190e0gg9u92uLb5/5CPPq56FOo0GfUf3w4SdvwseHf24QNWXeNN+f3Ks1WwoWPX1laA5HJ30sFfBAfsEBGP/ra2h/W18AQDv44w7/tpjQvCPu8uuI+ZNfx7y570MQBBe3lIgAbUiWnZ2N1atXIzs7GxqNpkHPk4NxdWNiYqIuuBMDnsLCQmRnZyMnJ6dB+2qM45K7jfZyZM5KZ8xz6cz3kLM1tXlCiTxBj0dHYugXT0NQKREMFW72aYW7m3XExIB41G/4FzddPxZlZeWubiYRuVBSYCCMZ7v21Pn+pKo3hcvVm/ayNgRdzn0RuRqDRw+lVClx07sPo9eLd0FQAAFQIhhKtIIPRvhGY+eC1fjPhKmoq6tzdVOJmjxbQzJnhmmpqalIT09HTEwM0tPTDYY+yx3wNMZxuTqEcmTOSmfMc+nqQLYxcZ5QIvcUNygV4zfMgbJFAPygQDCUCIUKPRGEpBNKDEwbgUOHjri6mUTkIt4035+56s2sigoMzctD7PbtGJqXZ9P8ldaCRUuVohllZXbvzxN463ERh1p7vLQpt6DjkHSc/+ckLp4rxx+vfYtmVTXorwpH7h8ncUOvEeh5XTqCgoPw8MP3Ija2taubTNTk2BqSOTNMMx76LFbKlZSUmFTJNTTgaYzjioqK0g23FW87kyNzVjpjnktXB7KNydvmCSXyJuEJMfjPXwtQlHkA6po6ZH+yGueyDqEzmiO4Ngp3XDcBvUdfBx8fFYaPHILBg25wdZOJyEm8ab4/qdWalQDO1ddjQ2mpXUOirQ1BN7cydKy/v0cPwTbH04eWk2UMHr1AaFwkQuMiAQDth6Rhya2v4NKxM0hHEMLO+uHU8nycFjQY8eUqvL90Pvr26eXiFhM1LbaGZK4M0/TnzwOA6OhoKJVKWQKexjguV4dQjsxZKfc8l1JcHcg2JmecPyJynG9gM7QbmAIAaH9zD/zx6jfYv2g9YuCL23za4p9f90ED4L8/ZmDTPTdizryZUCgULm0zETmHt8z3NzMuDhsvXIDqcjimgjYsVF7+F7B98RxzwaI4BF1qX+JnptyL9bjDIjbOWISIXIfBo5dpHhGKCRvfwK+T38GprXvREf7oCH9AAXRTBOG5Mc9AExMIpUqF2+8cgcefmMJOH1EjszUkc2WYZlwZp1QqMWzYMFm23RjH5coQypkL29i7r4aca1cv2ENE3kOhUOCGVyai1dVx+P2ZTxAmqHANQgAAPXyD8df3fyFtxQAEhASgfUIcFnzwX4SHh7m41URElklVb2ZVVuKs0fRmtiyeYy5YFIegm6sUHff337Iu1uMulYbetAgRmWLw6IV8mvnh1m+eQ+Y7P+PvbzZBU6eGurwaV8EHo31jUXy6DoCAP95ajsyMLHz1/Qfw8/NzdbOJvJatIZk9YZpGo0Fubq5sIVFjVsp5W6WaM1dXtndfDTnXXDWaiOTWZdz1CIuPxvrHP0JtaQXqyy/CTwD6Klug3aVA1F0UUH6qCIPSRuH7tYvQuXOCq5tMRGSRcfXm0Lw83TBrkS2L59gyBF2qUtRapaQ9MsrKcGt+Pur1FqV1VaWhnMdF7ofBo5dSKBS45unbcc3TtwMATu7Yj18nzEVgLRAPfwBAe6U/9mSewcDet+KXDd8iIiLclU0mIjvk5eVh9+7dAOQJiVw9dNmTqu2cOY+it+6LiJqOqLQETPzzbQBATVkVfho3GxX7TqCdIH7p7Y9otT8mDLgPsz5/DUOH3ui6xhIR2UB/aHKsv/Zva3HYtT2L5zgyBN1apaQ9x9A/N9cgdBS5otJQruMi98TgsYmIvbYL7t7yFrbPXYyL5ypw/sAJ4FwFUhCI4LM+GJI2Cm9++TquCg9DbGxrhpBEbk7ukMjWSrnGCgidUW0nV9udOY+it+6LiJom/9BA3Ll6Nna9txxFuwpQU1aFC3uPIRq+uN2nLd78zyzseXwfbho6AAEBzZGQ0IFTAhGRW5EamgwAPYKDcbKmxu7Fc+ydX1GuxXrEORWluKLS0JsWISJTDB6bkJA2LXHzB9MAAOraevz28HsoXJ+DeDRDsBCDWXe/hIvqOlQKNZj22qN46OH7XNtgIjIrKioKRUVFBredobECQmdU28nVdmdWh7rjvjypOpWI3I/SR4Xel0fkAEDByh3YOO1/aKFRYYRva2x/fw2WzV+CekGD6NR2WLJ8EQIDA1zYYiKiK54+dMh0aPLl/08KDER+VRVmHT1q0wItjs6vKMdiPVJzKopcVWnoLYsQkSkGj02Uys8Hwz97Cpnv/Iycd39BJHwwxqc1ND4CLkHAmlk/ID/vABZ88F+oVCrrGyQip0pOToZCoXD60OjGCggdqbazJwDTaDQoKCgwuM/Rtjtzzkp33BfngiQiOSWOvBYt2kdh2e2z0Ly6Fv2VYajzbwE1gCP7L2FgjxH4ecM3iI1t7eqmEpGTuMMqy+balVlRYXK/GkBmRYVuuLWtAeLso0ehEQRo9LajdNL8ilJzKgJAhI8PViQlsdKQZMXgsQkT54GM6NIWGx99H371GgAKNAMwSBWBrFX7MOzAHfhp1ZcICuKkrkTuRCokcrQSzZ7XNdZwXEcq++wJwHJyclBh1FHkUGLHcC5IIpJbq6T2mPjnO/hx9Cu4dPwsVNAOr+6GAARX+mBE77H4aNlC9O6d5uKWElFDWQsV3WWVZam2ltbXW3y+Wu9fcwu0ZJSV4elDh5BbWYkaiaHOGgBZEuGm3MzNqagfOrprAEyeh8EjIf6WXojd/QFKDxahpqwKm2Z8Dpy6gN6KYBw4fAnXd78FnXt0RvPA5njiqQeRlNTF1U0mIgmOVqLZ87rGGvrrSGWfceBVXFyM7OxsyQDV+LnBwcFOX0DHW3AuSCJqDAGtWmDi1rdxJv8o1DV1yPt6A479mol28MNtyjZ4ctQTiLk2Ab6+Prhp2EBMnDiO8z8SeRhbQkVx7kFbQjxntrXw8lyOtlIDWF9aiqF5ebrALqOsDDfk5Jgd4uxM1uZUdKcAmDwfg0cCADQLC0Z0r04AgIl9r8byu+fifNYhXI3mCK2LxOkdp1EPDSb9NhnPfTADt90+3MUtJiJjjlai2fM6Zw79tcY4ABMEwSRATU1NRU5ODsrLy01en5OTI/v8hGL1aHFxMQRBQPfu3WWbrsKWylRnzL/o6hXQich7KX1UiEztCABofU1n5PZIxI6Xv0EEfDDGNxaHss5DAPDjtkXYtGYLFn2zAL6+vq5tNBHZzJZQUWruQXtWWba3Ss/c843bakmoSoVKtdrkuRoAG0pLdYHd7KNHbdpemVqN2O3bG73K0NKcinIHwLZUutpbXcmKTM/B4JFM+AY0w9ifX8Lm57/Awe9+Rwz8EAM/AEBnvwB8PHU+9uYfwEuvPM1vmsmjeMuiGIIgICcnB6dOnTI4Dkcr0ay9zp3Om35bIiMjkZaWpjsPUgGqfjUnAPj5+aG2thYVFRW6+8UgVY7jNN5fXl4eevTo4ejhmt22ucpUZ8y/6E7hMxF5t5T7b8JViTFYNfFNBNUBKdBO/ZOkCkBeRhFu7DMav6z7BuHhYS5uKRHZwpZQUWruQVtXWba3Ss/S8y0tviJSAlAqFJjboQOmHTqkG7ZsfHxiYGdreFonCCisrZVsv71hW259PV7Yuxd77QznzF2r3y9cQEZZmV0Bn7Xr4kh1JSsyPQuDR5KkUCpx49xJiErtiN3/WwV1bR0unjyHYKgwzDcS2z/bjLv2/oP/ffYmfHx8EBQUyBCS3J63LIpRXFyM4uJiAIbH4WglWmpqKgRBwMGDBwFog02NRqML3eQ4b3KFl8ZtSU9Px7BhwwAA2dnZJgGqcRhp/Dml/7g9x2nueKTCT+OwFIBJaGzL+bGlMpXzLxKRt2nTrxvu3PQGNj71MapOleLS2XL4XKxFGoIQUlKDQWmj8OXKj9C+fVs0a+bPCkgiN2ZLqDgzLg4bSktNXmvLKstSVXoQBDx96BD+kujTWarqM7f4ij4NgA/i4/FQTAySgoIw++hRrC8t1S0WIxLD1aTAQLuGbBtXGX5YWIhHLvfXAaDYhmD1wYsXgYsX7Q7nzB1/jSCgf26uXQGftepJR6or3WVIPtmGwSNZ1HV8f3Qd3x8AcP5gIZbe+gr8yy/iemUY9uw8g+vih0AtqBEYFYolv36Ojh3jXNpeIkvEsM7c7cYmV/hWWVlpcFsMlxytRFMqlVAoFLrFV3bv3g2FQqHblhxhllyhr6W2SAWvOTk5BmFkeHi4wXXXr+605zjNHY9U9ajUc41fZ8v5saWilfMvEpE3atE+CrcvfxkAoK6pw6oH5qP49z1IQDMEqaPxwKApKK+/CI0P8Ox/n8KkB+52cYuJSIq5BU1sCRVNl2ExZa5KMbOiQrJKz1xVX1ZFBX5JSsLGCxcAiQVgRCoAK86exUMxMbr7fBUKk0VjxHBVDFWl2hjh64uK+nqT14qhZUZZGR7VCx0BbfAJC2Hb6ydOQBCfB/vCOfFaSR2/YGfAZ63S1ZHh9Q0dkk/O5XljDMllwhNicO+2dxAYHw0VFEhBIO4J6Ih7AxMxqDICY/vdjc2bt7m6mURmCUa/OI1vy0Wj0SA7OxurV69GdnY2NBrtr3sxXCosLER2djZycnIc2n5QUJDBbTnCJUuhm/H2re1P6vjlqsSz1BYxeB02bBjS09OhVCqRmpqK9PR0xMTEID09HUOHDtXdTktLgyAIunaK1Yi2HKe54xH317p1a0RHRyM5OdnisYqP2XJ+jI9FqqLVlucQEXkylb8vRn71f+g+dQQEANHwxXj/trg3MBET/BOw/OUv8cS0F3S/e4nIfYgLmgwOC0OMnx8Gh4Vha0qKbkETQFvJJsXc/fosDceWen1SYKBkIHLu8urVW1JS0Ds42Ow29UPB/rm5WFdaKhk6iuFq39BQbE1NRe/gYPgrFPBXKNA7OBgZqak407cvBrRoAeOZwcXQcvbRo5Lhqwbmw7b8qiqz1ZfWiNfKX2JUo70BX1JgoNnjyigrQ43E57W14fWWtknuhxWPZJdmYcG4a90c/Pbweyhcn4PQyz/uLQQVxvq0xat3voB/Xv4PHn7kPtc2lEiCcXVhY81TaK56Ta7wLTo6GtHR0QbDdRvKUqWctSHcxpWcgiBg9+7dAK4cv1zzSNo7nFyqClS8nZ2dbXCd0tLSdNfJ2rbNHY+4P7VajdzcXMm5N423Y2l71o7FkecQEXk6hUKBPs+NR0SXttj02P8QoFYi4PJjQ1StsGv5HozYfzd+XLEIgYEBFrdFRM5laUEToGGVbDPj4rBWYpi2uF1bn68AdBV9b8fH4+lDh7CzosIk+FMCqNFocGNuLurNFDR0at4cn3burAtX+4aGSg77FttjriJ03N9/mzlqbRukKjrF4dL6sZ494Vzf0FAMaNHCpErT3oDP3HGNiohA/9xcaCTOnRrAqIgIu7dpS/UsOR+DR7Kbys8Hwz97CkU79qOy8CzOHyxCzkerECaoMMovBmtn/4A/f9+OLt07ISLiKiQnd3J1k4kAOG8YqrmA0dz+3WHxFkuBnrUwyzho9fPzM3i8pKQEQ4cONbt9qW0A8i76Ykyj0aCgoMDgvoMHDyIkJMSmfdgTgOo/V6yq/P3MGSwPCsKrNTXonpeH5zt0QLqN2yMiIq3EkdciKjUexZkHUH+xFjve+Qk4W4FrFSHY/89FDEgfgRF33wKVUoWru3ZESkqKq5tMRFY0ZHGZvqGh6B0cjMzL0wdZe33f0FBE+PribF2dwf1iFaHxnIr6lJefd76+3qSqUN/pujqDik5r7RdXvxbnhHwxLg59QkORFBiIYqMQUXS+vl5y3sXn27TBxtJSKHBlqLoaQFcZQkN7Aj5zxzXr8jyNUsekBDDt0CEkBQVJziVp6VyR+2HwSA5RKBSI6XO17nb7m9KxfPx/EVBTj0GqCOT/dQZ7dxSiWqjHp4GX8OvvixETE+3CFhPZXy3nKHMBo7n92zv/obnFZRqiIZVyxkFrrdGk2VFRUVa3b6katDEWBcrJydHNaSmqqKhARUWFTfuw53wZPzejrAzPV1VBUKuhVqtxSm+i72GsViQisktIm5YIadMSAJAwug+W3fk6LuQeQVcEILjKB3s/3gwNBCytK4VGo8SYMcNc3GIisqShQdfb8fEGqx1ben1GWZnkHIYqALH+/iZzKor8FQoEq1RWQ0dAGwraw1xFqP6ci8b71ABQSMy72Dc0FHf4+OA7oza8ffIkOjZvjof15qa0JD0oCLmVlfABkBIUhHfi4+0O+KSOy9LK4eaOydo2yT0xeCRZRKUn4J4/38aSkS8DJReQhkBAEQhBIeDoxVoM7z0Wn//6IVJTk1zdVGrCnDUM1VzAaG7/9g7BNre4jKtIDSUODg42qB60JjIy0mAb+vMtGh/f3r17AcDuykf9ysny8nKDx1QqFdTqK10f/X2KrysuLoYgCFAqlVZXpxaf2717d6hUKoN9/zckhKvwERE1Ar+g5hj3y6vY9NxnOLzkD7SFH9oqtFX4Pf1C8eEjb2P/vgI8/8ITUEjMW0bkyTLKygyqv2ZenlPQXdtj7vGGVrLZ+npxXkbjYb5KQPf5YG42+AhfXwCwGjoCQLiPj0PXRuo14nGZWzl7bWkprsnOxtvx8brtrzYTfL505IjV4FE8R/ohbnZlpU0L/dgi1t/f4irfXCzGezB4JNkERV+FiVvfwppHFqL4z78h1Kuh0ADt4Y/Rilg8dPNDePaDGbjt9uGubipRo7I34LR3CHhQUJBBtZ49Q8YbY9hyamoqioqKDFaLTkxMlC3kNT4/NTU1ugpI/X1YOzb9ykljrVq1MrvatdTrjFenLigoQGJiosH8lgCQl5eHHj16GGxjv58f1Jc7rCJbO1buMCyfiMidKVVKDH5rClp1bYedb/4ETU0dhNp6hECFYb5R2P7hBkzML8Cib94zmRqEyFMZB0QleqMpXBE+WmuPtcfNVbLZGuDZUgk328ww33AfH6xISrI4p6I4bNvc0Gd990VFWb02xsc1MiICjx06BM3l9hXW1mJdaSk+SEjAmuRkDM3LM7s6dmZFBW7IycHW1FRcExSEconnALZVYornqDG+LM8oK0OW0egjY1wsxnsweCRZ+QY0w8gv/093e+f7vyD7jZ/QCj643a8tPp46H/l79uPlV5/hN81El9k7BLwhi8s0xrBlpVKJYcOGmQRi9jh16pTZ2+K29u7di5qaGt39xpWQu3fvNljURhAE9OjRw+zz9asyk5OTkZeXZ9J+qbkgpVRUVCA7OxvBRisfSq1aHVNbi3IfH2j0PgNt7Vg1xvUjIvJGyf+5Ccn/uQkAcGb/MSy99RU0q67D9cow5G0vwqA+o7F83Te46qpwF7eUqOEaMyBqjPY40l65w1VLw3ytzan4YlwcBADrzCxkAwC+AB6PjcXeqiqLxyp1XGtLS3VzSIoEAI8cPIj3T54EFAqzbRf3MfvoUazq1g0hAC5IPCfcx3IUlFFWht8vXJBc6MdaYGgLa6uUc7EY78LgkRpV+sMjUOZbh0NzfkWwGtpvmhf9jjv2HsCct16CUqlE27YxrNihJs3eCkmFQoGUlBSoVCq79yXHytrmqu6sHYOlaj3jqkaNRgONRgOlUqnbtnFVpUZj2BU8aDQPz8GDBw2CR+N9JCYmIjU1FTk5OVi3bh2ioqIwdOhQkypJ47kg7aG/gJDolnPnsD8gACpoO29KAIIgYGxNje6YzZFrZXQioqYkPDEWaR9Nwj8vL8PFI6eRhiCEnKrB4LRb8b8f5yOyVUtERIQjODjI1U0lckhDVoJuDNba40h7pcJKCAKePnRIt0q0fuVgrL8/AOBkTY1kdaS5Yb5n6+uRUVYmOaeiAsCHCQm6YdtX+fjgrJnKQQ2AdwsL0UKlsniskscF88O49128aOYRQ+L2H/TzwxsSxzm7fXuzrxXDUHMrdZ+7fI4aUk1rLvj1VygQ4evLxWK8DINHanThPTpg7LrZ+HnMLPiXX8T1yjDs2XUOt/e+AxoIUIb5Y+mar9CxY5yrm0pNiDsMWXVFGywN65ZqDwCT+xyturP0OuPh2sXFxcjJyTHYrnGVtP5tjUZjUA0pJTU1FYIg6AJKcVi0fpWk8bEYB3t+fn6IiIiAIAiorKxETU2NwWI6giAgOjoaCoUCgiAg+fK39vptjb90CU+fOIFt7dvjkEaDVpWVGHbuHOovXUKOSmXxXDprZXYiIm/jG9Icd659HWseXoDizXuQgGYI0kTj6ZFPolpTi0uox9P/fQKTp0xwdVOJ7NaQlaBd0R5H2msuqMqsqNAuEgPo5mwUhyeL7K2OFMNMa3NF9ggONjvkWaxsFI/N3LFaqrxsCHH7Y/390aZNG7xy7BjO19cj3McHs9u3x4MW5ncUw1BzFJefY1ydas9clubeAwNatOCc516IwSM5RVh8DO7dNh9Lb3sVVQeLkYJAJDTTfsty/lI9xvW7G29+9wYGDuzn4pZSU+EOQ1Zd0QZLw7ql2gPA5D5Hq+6Mn1dQUGAxdDV+fnR0NIqKigxu67fdeDXthIQEg9tKpRIKhUJXwbh7926TodEFBQUWKzGTkrQLZOnP+RgdHY3KykpUVFSgsrISlZWVuuHw4naM2x5/6RJuuLzAjf72LZ1LjUYDQRB0bU5ISGi0ldmJiLyRyt8XI7/8P+yYtxR5769ENHwx1i8W9QBqIWDFK18jf88+zF8wm6NxyKM0dCVoZ7fHkfYmBQaaXYjk6UOHcPjiRbMVelJDuU9a+MJaP8zUZ7x14+OQ2i8UCigUCrPHKhXAKST2ZQ8VtMPBM8rKML26GsdOnECP4GCbFxzKqqy0GIZqYFqdau9QeHd7z1Lj4m9UcppmYUG4a90cxNyUBgUUCIISQVCireCH233a4tU7X8CH//vS1c2kJsIdhqxaaoNGo0F2djZWr16N7Oxs3dDjnJwcFBQUICcnx2SosS3EYcvDhg3ThZzifoznMiwpKZEMC41XhLa16s74eRUVFSgsLER2djZycnJMHje+nZqaivT0dMTExCA9Pd0gdJOavzEtLU13Wzyf4orYourqapM25eTkWNyn8b4qKytNQs/i4mKDYeGpqakGQal4fMbHGBkZaXLdRTk5Odi9ezcqKipQUVEBhULBP4yJiOykUCjQ57lxGPS/qRBUSjS73B8NhwqDVS1R+ks+Rgy+G1VV1dY3RuQmxJWcB4eFIcbPD4PDwrA1JaVRhqlmlJVh2N69GFpZiWF790oGdNba40h7Z1oIpDIrKswOeRYZD+W2Vg369KFD6J+biw2lpSisrcWG0lL0z801OF794/CXWL9ABaBHUJDFYx0ZEWEQ8ilhf+gYqlLBX6GAv0KB3sHB+CM1FQKAG/fsQaZajSIz7ZeSUVaGs3V1Fp8jVZ0qNWRcuBz2SrH3PZBRVoaheXmI3b4d12Rn45rsbMRu346heXlWj4lcjxWP5FQqXx8M//RJnNlzBBfPluHUniPInr8MYYIKo/xisHb2D1j760bExMWgXVwsHntsMpo3b+7qZpMXcochq5baYK76UBwWvHv3bigUigZXSFpa6Vlsj/7+9ec7DA4O1s2TaAv9asvy8nKDbZWUlGDo0KG6/xerIG0djm58LsVjE59v7jjVatPvc/WrHvXnrhTbYhy8mpsDsrKyUvf/1hbgEe8TBMFsFaw7hOVERN4iYcQ1aN2rE87uPYraiovY+tq3wJlyXKMIwf6Ci+ifcgt6DuqNZs2aYcqD96Bz53hXN5nIIltWcm4o46q2jaWl2GSmqs1ae+xtb9/QUPQODkamg3Nvq6Cd13FoXp5uDkjjBVz05VZWWl0URn9Y8fz4eDx26JDuNfoVfH30jjWjrAyz9OahzKqoMGiH/WUFQIy/Pz7p1MngGgzNy4Ogtz1bFxyaffSoxfNirjLR3Lydv1+4oJsPUmooti3vAeP3XUOG0ZNrMHgkp1MoFGiV3AEA0O7GVLS9IQnLx7+OgEt1GKSKwP691ajeux+7hHwM/PZXLN/wLaKiWrm41eRt7F1J2tltsCVkkiN4srTSs3F7jMPCkJAQk1DOUkCoH+JlZ2cbBIFRUVGSC9ToP09qOLq43+LiYoMhz+Iq0+LzjY9TnINRilj1aNwW4/DSz88ParVaMrwEgKAgw0UKzC3Ao3/f6tWrDR7Tb7c7hOVS3GHISwMLAAEAAElEQVS+VCIiRwRGhiEwMgwAEDc4DcvufB2lOf+iKwIQcskHhav2owIC7v5+A2Z+NBOjR9/i4hYTuZa9q1HbM+efLd6OjzcIoIznTrRGXI1ZHAqsABCoVKLKaBSRuHyjuUVhzA0rXhAfj5Vnz+qOd1REhC5kTAoMRNfAQLxz8qSuotHc0HF77auuxg05Odiamqo7v44uOJRfVSUZOvoCaOXnZ3bRF6kh4wBQIwjon5uLBUbBrLnAUOo9Y/y+Mz4mV67gTrZh8EguF5WWgHv+eBtLRr0EFF9AdwRoH1AARy7UYGjPMfh85YdITU1ybUPJq9i7krSz22AuZJI7eDLeT0JCAhQKBUpKSnQVg5bCQpFUhaa4EI1UIGVr8GstgDUOA43nbBSfb3ycgYGBBhWJxqTmnzTet/HwagC6eR01Go0uwExLS7M5iDMePq9/2x3CcinuMF8qEVFD+QY2w9jlr2Dz9EU4tHgr2sAPbeAHAEjyC8L/Hn4L+/b+g+dnPmGy2BlRU2FPmGXvnH+2hJTi8Fz955XW1yOrosJiANn7cv9Q/3licNktMBDZetWNYkVfSlCQyXbFIcbmAtiVZ88aVDbqH39xbS3WlpZaaKV1luZ+VMNwwRdHFvDJKCtDjcRUTioAN4aFWQz29FcBNyYIAl46csRqaG3uPdPCx8fi9XXlCu5kGwaP5BaCosMxcctb2PDkRyj+6wA0NXVQV9WgPfwxGrF4+OZH8PTCZzF23AhXN5XIKcyFTOKqzHItLGK8H0tDfe2t0LQUSImhq1gtt2bNGsmVtI2DOOOw1VrVp/h841WzxQVgxJBQfz5GALqqSf0Q1dKcmiqVCikpKSarfts7JN542Lb+bTnDcqkqxR0VFQ5VJXAIOBF5C6VKiUFvPoDIpPbIWrgC6po61JdWIgQqDPONwvaPNuCevf/g828WwM/Pz9XNJXI6e8Ise6oj7QkpjYdoi68VFykRhwlH+PqiR1CQrjqvZUaGZGh6sqZGcvVqATDYrv4Q43F//201gDU+fkeGUOvzVShQZ2GlaRjtf2ZcHDaWlhoMm1YDKK2v1w191ieeR43RPpSwbdEXMRS+MTcXNUbbUAM4X19vcg6snTPdyuCCYLG61ZUruJNtGDyS2/ANaIZbPn5Cdzvrf79i15wlaAUf3OYXi0WPv4fpD74IKBUYcvtgLPzgdfj48C1M3slcyJSamqr9FjYlRZbhrMb7sTTU194KTVsCKWsraQNXqgilqvykKhkTEhJw6tQpk+cbVziK8y5qNBrs3r0bBw8e1D1mPP+kOJxbpFKpDIZYBwQENHguRo1GY1JFaUtVjSPDmIzPe259PR66dMnmqgR97joEnIjIUUkTByFp4iAAwPl/TmLp6FfQrOISrleGIW97CZKirkG9oEFE20gs/uVTtG/f1sUtJnIOe1YiNlcdub60FEPz8jAyIkI3LLlGo4FGEOyejxCQroI0HgpsbsEUJbSB1Z7KSmRVVOB8fT1O19ZiR3k5rg0JMRg6HevvDwAYlZ+PMomFbPTDr4yyMmy6cMGuYeDmKAEoFQqkSVRgGtMP3/qGhmJT9+54dO9e7NX78jyzogLX5eTgg4QEdA8K0p0342sgCvfxwYqkJJsWKuobGooBLVpgQ2mpyYI5KpiGr8aBobn3DACDlcGNt8HVsN0fUxtyWz0eGYGITrH4bfJ8BNcDQ30icV1wS2gAHF59AEP23I5la75CixacRJbk5Y1z1jm6SIutIZJUNWROTo7VbdkS0okBobn9FhYW6l5XUlKC1q1bmzw/JyfHpJpQbI9SqURaWppuiLk4TFr/ecbtCggIMHhOQkKCwfMdOYc5OTkmwaP+dvWJ13Pz6dOYcXkBLnsCQ+Pj+V9FBQS9YSz2dPgdHQIu97xPRESNIbxTLCZum4+lo19B9b+nkIZAtA/sBEEBXDhfj9v73oH5i9/B9ddf4+qmEtnM0d/BYsg36+hR7L5wAWktWuCly9WB4qIt4vbMzfmngTZ8XGtUjWfMnuGzUgvV6B9jjUYjOUxZANDCxweP6H35rAFQplZjXWmprk8FQFcNKNVexeX2ZlVWouvOndhXXW1Tu20hAFgYH4+koCD0z82VHMosMq5m7BsaimCFwuQ8CwAeOXjQ7FyW+vyVSrtWRxfDaaXeudLA9NxLVVKaq6jtERysm+tRPwQ+WVNjds5Jci8MHsmtxd2Yijs3zMXSW1+Bf1k1/AXtx+NVimCEnbyEG9NGYsn6LxEf397FLSVv4o1z1tl6TFIhkrnQ0lqYaUsgZctclhqNBqtXr0ZkZCQAGFQzKpVKVBl1Sg8ePIgePXoY3GcctPn5+SFZr4NqPFekWGUZGRkJQRBMVrIWn6NQKBAdHW1wbKmpqWaHxFs6Z1IL/aSlpZnsV7+9X8XEQBAEaC5XRtoaGBqf9xO+vlBLDIuxpcPvyBBwe+d9IiJypebhwbh7wxtYNWU+ijflIRwqQACuggphqrZ4YexzmDjrATwwZYKrm0pNmK1hoiO/g423/XybNgisr0dKt274q7LS7EIr+tWR+mxZwdm4Gs6esNT4GM0JUamw+MwZyccEaKc4evrQIRyorka9hcBPfORsXZ1kZWVDKAC8eOQI/JVKpAcFoaK+HvsuXpR8blZFBfrn5hpcy0MajcVw1xJHhjD3DQ3Fgvh4gzAXMA0eg1Uq/Na9u0FgaKmito9EuEyeg8Ejub2w+Na4N2M+/v1tJ+qqarD/lwyU5h1BJzRHcF0Uxl83AW9+9wYGDuzn6qaSl/DGOetsPSZ7Vpa2FmbaEkjph3SAtoOXcvmbZbH6UBzirB+U6c+9WFNTY3EfgGnQVltbi7y8PLPDo8UqS+MFdfz8/FBbW6ubAzI9Pd3kGJVKpdkh8ZbOmXEbExMTzVbaiu0t9PPThY4iWwJD/VBYo9GgTV0dzv0/e2ce3kZ1dvEzM1psS7Jix4kl2wkO2GaJHS8yayiEvcaQsARSKFtbvi50b7pQCGULUFoCLbTQHVpoSwhlNyYEylJMC8SWHTuE2AbSJrbkxLEjS95kSfP9Id/JzGhmNJJly07u73nyJJJmuXNnFI2Ozvseg0FyYzqd/XISTcVMFUpfWk6SpY9TKBSKEpzJgJWPfh//+2crfLv6cODTPmz/yxbk8gZcbCrEC7f9Be3bPsQvHlw/56skKHOPRMTEZJKpY7Y9OIjfZGaiSmN7L/T3CyXQrw4OJtTjUF4+m6hYqpWCLN6HMU5LmzCipcnpJAKgf7K0uycYBAdgbVERNuzZE7Os0rksYVnsC8eTGGOZSgnzC/39cRPHfeFwjBipp2yeMjehn4qUOYHZbsGxV5yBZdd/Fpe/eAeOvf48AEABjFhtWIzbr7gZD//60TSPknKoIC+NPRR61k3lmNREy6kItJFIBM3NzWhsbITH4xGEvJaWFkEQrK+v1/zyRnovKpUnk+03NDSgubkZlZWVqonXgPr8yI9J3nOxs7NTM3RGacxqj0mCeGFhIVwul2bJMhlfYTAIVt4EnOexOBzWHBcRhR0OBzweD87q7QV4XrgpmO5+OYmkYqYK8qVly+AgeoJBbBkcxIrWVjT5fNO2TwqFcmjBMAyOOKsay770WZy2/lpc9I+fgDcbkAUW53ILcOC5dlxwzhUIBGi6KmVmURL/+EkBSk6in8GK2wbwx8n7L63tkRLoc3NyhLJeNRgARkQFihyDAQ+VlAiCUyLH1+Tz4Y04/RXJfc5cJAzgDx6P6nzKz+WXTCYkeqR5RiPOycnBQyUluHPXLhS9+y7q2tp03zMpXRNKKJ0/cs3sOeUUNFZWUtHxEIE6HilzDoZhcPqtV2PhcUfgjbW/Qw7PYZWpEJvvehLPbnwJOXnzUHpMCdbd8h1kTvY+o1ASIdmedbOZqRyTWjn0VEJF5KXNYjo7O4Vx5ufnS/YhH5daebKSs7CsrEyyT/F41eZHfoy5ubmSkBm/3w+326271FhrzhIpWSbju3bvXvyYYYRflYkI+ZlPP4VbFHijBpm/krExrN29G68XFKAvK2vaf2FOJBUzVag5Mu7evRt3TdteKRTKoYzz+DJc9dZ9eGrlrcBeH05isrGjcxSnV56PoypLYLFasPaHN6C8/Jh0D5VyiJOImJjoZ7Datrsnf+DUsz15CS3pOSj/O4yDDr+vdXXhMa8XG0pKVMewNRCQ9JZcmZeHb3V3K5ZFs4gGpZhZVrjPuXPXLmweHIxx3gFQ7Ak5W/BpOBjlc19lMOA7BQV4oLdXeI5BdD6UtsICqLVasa64OOm2OGr9PeW8ceAAit59l/b6PgygwiNlznLsZacht6QAz15+F7LGJnA2l4fuT8cw/ukAPnm/CWe++Aae3fIEHI6F6R4qZY6RTM+6VDId4TZTOSY1UW4qYqaWO5K4H3t6elBTUwOXywWv16vY41EeYEPKk5WchXV1darjFc+PeP7z8/NRU1Mj7LOyshKbNm2KSb0mkHU9Hg94nseyZcvAcQd/k06VqE3G6wJwymT58Af798MxOor6/ftx1NiYLgeqWAgtGRvDmpycGbn2E0nFTBWaX8omm5RTKBRKotgK83DN2xvwzBV3Y9D9CZYiC/agAf0fDCCE/fjCq1/CTY/cjIsvPj/dQ6UcwiQiJib6GVxkNqNHVl0CAAsnHYNa2xO3OHFNtjYhgSCr8vLwvCjVeiAUiinHJgnMx2ZlxRwfi2hPRZKg3BMM4pXBQdU5YhkmJp2ZjD3M8xKR0cKy+IzdjsFQKC2l1maGgc1g0OwXqVbKLD+XraEQHurtlQTM8AC+W1SEx7xeoYybEEH03ijZtjiP9PTg30NDuhyP4zyPnmBQU9SkYYSHBlR4pMxp8qtLcNXbG7Bx1U8AzwEci0mHIwMsPjCOuuMvwR+ffxg1NcvSO1AKJQFaWlrQ0tICIOrW43k+JixFC7lwBsQGsiSCmmg5FTFT7vwjYS5DQ0MSUa+vr0810RrQ71R0OBy6xyt3S9psNpSVlQlzJ3dORiIRRCIRsCwb4+Rsa2uTnLvpELVJScrWrVvR0t0tPE/OvRbpcvemo4eP5pcy2U03hUKhJILRkoHLn7sNr//oj+h+8i0UwYQimAAAZcZMPPy1+/Bhx07ctO47c7a8kzK7SURMTNVnMLmS1bbHAzGOOYZhJOLSVwsLAQBF776r2gOSB/DhyAg4HBTbOEQFMpImHQ8zw+CfVVUxxxhvLpp8PpzuduvaRzIYcdDlSeAAnDFvHgBoCqlqbkxxiToQLYmPIDbI5749e3CizYYBv1/yGovovVEybXEe6emJCZUBgGKTCbsnxWuluVQTNWkY4aEDFR4pcx6rMxfXvHkf3vjxo/C2dCEUGEOwfwhLYMbFKMINdTfgew/+EJevWZnuoVIouuiSfWArpTRroVRmLP63mvCViNNyqq5MebgJwzBCaTURXYH45dtqQl6yglokEkFnZ6fkOb/fL8wn6b3Y29srlFx7PB6h3Dpe30uleQOQcoerXvQKodPhwl0+w+mEal/Kbl68GPjkkxkbB4VCOTRhWBZn//z/4Kwpgft3LyMSDGH4f/uQDQ71Rgfe/c0WXN2xE396/EGYTKZ0D5dyiJGomJjIZ/AelRC/PlE583K7HeuKi4X937lrFwZDIU3HnNjJNh6JSBx5Slg5DmORCAwAqqxWfDQyollyTCBCXry5IOO5fPt2FE1WQnw8Ogorx2E4HBZ6WyYDO7kuKW8m9yDfKiyMCYkJA9isITgSlOaKA/B8f78g6ALaqdZ+BZdpBED5pFM2kZL8Jp8P31YQHQEgEIngrepq4Xz3T0xgXFYOH0a09LrJ5xNExXSFEVJSDxUeKYcExqwMnPvLrwmPmx95Ce/f/SQWwoBLTYvwx2//Ets7PsJtd/yA/tJMmbUQcWdkZGRK25ALZ2K0ym/jpVRrLdvb2xs3DEYMEbzEqdG9vb2S0motwTCeEKZWOh1PNHO73RLHpRgydyzLxqxPXovX91Jp3pxOp8ThCqjPuxZ9fX2aj6dCvGtjLpTBqH0pO9FqRWu6B0ehUA4Zll5xBpZecQYAYGDnHmy6+DZk+MdwGpuDtne9OPvki/Hsq49j/vzcNI+UcqihJCam4vNZrWKgRHQvpORMU3O2tQ8Pxyyvp58iERk5AM2BACwJ/ACqVkZO5mdrIID+iQlB/FQqLdeCQzQQZzAUUi5/BnBMVha6RkcRmQzzK83MxAMKydRA8gKnkiNRK9X647ExxbnfsGcPfl1aqttFS86nWv3IQCgkuT7r2tqEEnkx4zyPFa2tgqMxHWGElOmBCo+UQxLX1y5A3tFFePlL98MWAs43OvDvP72FNe0f4YtfuxpGowGnnFxLw2coswq1wJXS0tKEtqEmnAHaDkIlt14kEkFLS4vgwiwtLUVNTU3Msh6PBw0NDQmJj0oiabzSasJURFKtZbWEWfHcqQmMRCglPR4rZV8AlOZt7969useghXxMQ0NDaG5uTolzVcvJOZfKYJS+lIV1uCUoFAolGXKPLsI17zyATRffjpFPvKiBBfa94zin5iLc8osbkZmVieOOLcPixYXxN0ahJEiqPp8VKwYAXC/qj6zkTFOCOObkyycitBHX24jOz28rxyluXz4/gLbjUguGYXDnkiX4horjL4xouThhQvY4lRTJ+lZ/yWTCf0ZHY+aA3O0pzQ0P4IX+ft0uWnI+1cg1SGUnck1BYR1e5GhMRxghZXqYmVouCiUNHHFmFT732k/B2rNgBoPPsPOQ2zyIe667A7ddeQuWLz0PXV20vI4ye5CLO2azGS6XCzU1NUlvg6Q8FxYWCmXCashFSYfDAbfbjZaWFiHwpaWlBW63W1HAJCXHciKRCJqbm9HQ0IDm5mZEJlMQlURSNWFUvg1xsrTScYvX6ejoiLus2v6tVivMZjOcTicqKiqEMfA8rzivxGlZV1eHgoKCGBFP6fjkwlci6eBiqqur4XK5YLPZABwsEVc6JwQiyvb09Gguq3RtEJS+bJCbRjlNPh/q2tpQ9O67qGtrQ5PPl9AxUigUylwjM9eGz2/5KQrOrgIDBiXIwMqIE7/++gbcc90duNB1KX7328fTPUzKIYjS53OI53FWa2tCn8GkYuCcnBwUmkw4JycH/6ysRKUoPE/JmSZH7JjTs7wWYUTDYvSIGb5wGCtaW2OOd+1k+vVUf360cxzeqqrCVwsLUTt5DzYTqB37B36/5FirDAY8dNRRMeuyDIOqycAfJdqHh4UfbPeccgoaKytjREdyX/eqgntRzPolSySPyTVlVqhEFDsa1xUXg2EYkCttJsIIKdMDdTxSDmlyjirANf+6H5tW34Hhzl5UwYJyQxZ4AH0TE/jcaVfhZ3+9F2ed+Zl0D5VCiXGslZeXJ1xyK99GWVmZ7m1UVlait7cXAwMDyM3NRWVlJTZv3hyzHEmIFvc5JLS3t6O3txcsy0qSp+WOw+rq6hi3o81mUxVG5dtwOp2S18UBL0rriNES9uS9J8V9HJ9++mkEAgFhDPLQGT3I+0MSGIYBy7LgOE7xWPRARE+v1ysRdInwqjTOeD0pxeMmr8tL4PWWwcwlZySFQqGkEs5kwIV/Wot/3/c02h58Hg4YcTHnAA9gxMDjpdsfR3vbDvzyV+tnrMcv5dBHTdwb53lsGRxM6DNYXjEQDoclbUqUnGlyrByHnx55JE6x23UtrwWHaJ/H5kAAEQ2nHSEi6y25trs7ZWnVgXBYcA2q9cOcDhgAxWYzdsn2GUFUVP2P6P7/qwUFqMrOjnEvtgUCivPAABiPRFD07ruqJfri+zo1p6gRwEOlpfhKYayre7ndjjPmzYspuRY7GtMRRkiZHqjwSDnkycix4spX7sYr3/g1dr/8AQyTGWxFMGG14QjcceU67LzlOtzw9S+keaSUw51UJAyLxUOj0Yje3l5h2/G+zLS2tkqEttbW1hghEwD27duHlpYW1NXVobGxUSKiBYNB4TFZT0ncUnI7lpWVCWOUlwDLt8GyLJxOp2LAi3g/YsxmM8rLy1FdXY0mnw937tqFlgMHsGhiAjfYbPjC8cdLekM2NDRI1ieiI0EeOqOF+HicTif8fr9kezzPIxwOIxwOw+12o6urCxMTE8jNzUVdXR0MBv0f1/n5+ZJzNj4+rjrOeD0pCVohNHrLYGiDcAqFcjjDMAxO+cFlWHDsIrz+rUfATUT/N8wGg3O4BfjghXZcsPNKbHrhT7BYstI8WsqhgJa4l+rPYHk5thK+cBjf7O5GhdUas3y8YBk5DMPg/pIS8ADOcLsxEWf5CICtgcDBXoQ6xEq9hAGc1dqKM+bNQ5HZPCVBNVF6VITOVtk9KxArHjf5fPjJp58qrs8j2peR9Lt8ZXAQJ9ps2FBSohr8IoY4E99USBIXoyeNfabDCCnTAxUeKYcFnNGA+t9+GyN7D2BieAy73mhD022PI4fnsMpYiFfvehJ/+9PTyLBmoLzyONxz7020/yNlxtGbMKxFW1ubIMaNj48jEAgIj+NtWylNe82aNeB5Hh0dHQhONtoOBoNCGIpWPxfgoHNQTCQSUSwJFwut8RyOSmKk+HEkEoFPVlKTk5MDANiweTN+nJkJHtEb0f0chy+PjAAffIAvnXiiIBIODQ1pHpvaft1ut9DjcdmyZeA4LuZ4qqur4fV6MTAwAJ7nhbklEFHS4/GgsbERF154oa6x6B0nQSx25+fng+d5NDQ0JJRcreemEdDvjKRQKJRDmdILTkLxmVUY6TuAkf4hvPzVXwJ7fTiJycaOzlEsX3oe8o5YiOxsG26764dYtuy4dA+ZMkeJJwam8jNY7Ex7dXBQVUQU9+8TO9mKzGZ84PfHrKckSDIAXFYr+Mn9npWTo7lPgm9iAmfpEB3zDAYsNBrx4ehonC0ehLhIgeSDYZIhWYFTjwArn8/3/P64wS9A9Jydk5Ojy5lIHY2HD9TLTzmsyFo4D/YlDlR+8Txc+vxtQIYRWWBxFpeHE/dmovwTYP8zrTjj+JXweFKXCEs5NFDrVTibUCuVTSawZHx8HI2NjQCibkE5XV1dcbfrcDhikuQZhlHspUhQCp1hGAYul0vSU1Gr76Db7Y5xKO7duxfNzc34cyQiKQuJTI7v4UkHJhEJiSPTZrPFCJ9ixNcBWZeUU7e1tQE4OP/dGRl4sLAQ5x44gNsyM1F84YWoqKhQ3TYADAwMaL4uRy3NWsnNSMTu+vp6MAyDlpaWuP0e5Sj1fnpL4RfuCosFnGxd2iCcQqEcjhizMmBf4oDz+DJc8/YG5NQcBRYMliILK8MFKP8EcLQO4f/O/TKeeaYh/gYpFAXEn89KvfRS/RlMnGnn5uTEfN4Twog6D+va2rBm+3YAwMalS5FjIDVpByGio3xbPKJ9DEnfxnXFxWBFfQDVmEBUINTiRJsN+049FdtPPBEnJtivkYhwNi7eSFJDGACncF4BaPZuBA72t0wUcQ/vCoslRkxiAZybk4N1xcW4c9cuoaf3Iz09qj2+4/WRpBwaUOGRctiSX12Cq97eAJMzB0YwKEUGjkEmljN2nO6bh/OPvwTNzdvSPUzKLEJvEIecRATLqYqbaqWy5Hmt7cvTs4PBIHp6eoRwGTkjKml8VqsVhYWFqKmpAc/zMevyPA+v1ysRGz0eDzZu3Ijm5mbF/TmdTrhcLpx33nno7e3FX/7yF+zcuRNWqxUmkwk2mw08zyMUCikGypBjB4Aek0kQG4XXGAa7WFbRjTk+Po7zzjtPVXwUC6vy3o3kscPhQHdGBjYsWoQdWVk4YDSileNwZlsbRo48EtXV1eBUblRzc3MVn1dDfg3YbLa4wUKA/n6PSui5aaQNwikUCiUWoyUDlz97K0quOB0AUAAjjkEmliELlxoX4ZEbNuCuOx+IW2FAoShBPp9fr6qCYYY+g8nnvRIsgP6JCWwZHERPMIgtg4NY0dqKrX5/jHsuAiDPaFQMbIngYN/G5XY7HiwpQY7BABbRvoJTgYhiG0pK4oqZcsIA/DrTtrXQU5bKAaixWhV/1L2/pER1vSafL25/SzWRSOySXZmXF+OKjABYarFgRWurcI5fHRzEDV1deFX0+FS3GwuammjQ4GEELbWmHNZYnbm4+q378M7tT2Dv9v9ifMCPkf/twxKYcQmzCN84/wZ898Ef4vI1K9M9VMosIFlhRilcRa3sOZFlxX0D8/PzhTE5nU4wDAOe58EwDJxOpyA6aW2/pqYGDMPA6/ViaGhIUWwEIGxbnsZsMplQXl6OmpoasCyL5uZmSbiLzWaD1WqNEecIpGeiTXaDaTKZEIlE0NDQAJ/PJzgZxeXJpPzb4/Gobp9QGAxiyGCQiI8sz8M5OoqWlpaYHonBYBCbN29WLTsWC33yL4Z+vx+RSATV1dX44r59AA46LCMMA5bncff//of1LBszn8QZWldXp3k8cpR6heopmdbb7zFZaDkNhUKhKMOwLM7+2f+h6KRj0f7nLQhPhDHYsQvZPId6owP//s0WXLXtIzz614dgMpnSPVzKHGQmP4OJEPjjTz6BT3RvwyEqTLFATL9n8rq8X3SthnMvgqgI1uTz4Vvd3TEhJ4n2jQSArbJy4reqq1G/bZvkOLTgAOQYDBgMhabU57HIZMIuWRseOREASzIy8NHICHzhMFgAx2Rl4fdHH615XoljUQkWwDGZmdipUmYudsn+WeV70B8m2w2R44+o/E0EaBo0eHhAhUfKYY8x04wzfvol4XHzb17C+3c9iQUw4BLTYvzx279ER/sO3H7nD1V/vaMcHsiFmfz8fDQ3N8cVeBIRLOMtG4lEhDJenudjglwILpdLUbCUb6+zs1MyfrKOXDQUY7VaY0RJq9UKm80Gj8eDl19+WRL8QsjOzlY7bE2CwaBud6mesuTz9+/HjqwssDwviH8AUL9/P7qGhmKcn2S75eXlMfMsJhKJxJR3BwIBIfTGk5kZk7wYYRi0Dw/DO9kXSExNTU1SPT8T7RUq7kvpdDolieSphjYIp1AoFHWOueRUHHPJqQCAgc492HTRbcjwj+E0Ngdt/+nD2SdfjGdffRzz5yfmhKdQgJn7DG7y+fDNrq4Y4a3WZsPHo6PoD4Ukz4cBgGGiVREK/aIvnyzJVqLCYokpGybiZq7BADPLYjwSEYJSxJgZBjaOk7wmD91ZbrfDynG6hUeGYXDnkiX4Znc3MAWX8gSAzy1YgCcnf7RWggckr0cAfDgygrZAIEZ4bPL5cM/u3WgfHkb/hHoUTwQQRMfjMjMlfS7lLlmlABsAuucKoEGDhxNUeKRQZLi+egHyjl6El7+4AbYQcL7RgX8/+jZWt+3AJZ+7EBkZZpx33hmwWmlfssMNuZOM53ld7kS5g464E5WI5zoTh8doQUqN5WKofPt+vx9+vz9m/PLQESDaO5CsLxceA4GARHTr7e2VlFIDUYGroKBAU7wDoiLmyMhIjANQD7m5uTHzQxyahJKxMazdvRsvz5+PHpMJhcEg6vfvx1FjY4DRqNgj0Wg0onLyhqijowPjohRBsrxSUjcQFXc7OzuRb7djf2ZmjNOywmKBw2yWzIvYpaqFPP1br7tRjNgFC6iL1hQKhUKZOXLLinBt0wN46uLbMfKxF9WwIHvvOM6puQjfuuMGGA1GHH98FcrKjkr3UCmzkCafT+JuXFdcnFJHWZPPhxtHRvDf997DMtn213Z3q7r9jsrMRL/CvdJRGRnYUFIiCZsBgMu3b8d4JKLqXlyVl4evycIRMbmsmWWx55RThCAVRhayU2W14uPR0ZjtykN3tNLBxZgZBv+sqgKPaPhNi98fN21bCeIq/HRsLIm1gR9/8gm+VlgoPN40Po6fbdumO/SGCL+LMzLwu2OOSdgly0DqatWzP+JcXb9rF7aS64NhUDuZgK527U73dU5JHVR4pFAUOOKMSnzutZ9i06rbYPaN4DPsPHS0+vDn5t8gzEdwd+bP8eTmR1FaemS6h0qZQeROsoYGacP3ZAJcCHpdZ3r3MT4+LohJ1dXVgji1cOFCOBwODA4OxqQpk21riVlKwS9qyJOaGYYRjqe1tVUiLHIcB4fDgUgkEldYNZlMkm1brVbY7XY4HA5UVlaisbFRsg2lvljLWBZVorJtwtjYWIxgCkSF1SeeeALl5eVYunSpkOoNHBSH1c4NESPrJibw4aJFMU7L1WNj8Pb3CyXyRHTUIyAmUpqvxlR6O1IoFApl+sjIseHzr/4UDV/9BXq3tKIEGbBGnNh4058Q5nlsCAXw1TtvwJe/cnW6h0qZRRChjZS7eoPBhMpZxWIOEQD3jI8Lwg4AnLVtW7TPYjiMPtn21ZxwrYGAZugJcWTKx09ER7H4yAB4pLQUz/X3q25vPBJB0bvvoshsRllmJrpGRxEW3RO+7/crinHy0J146eAEG8ehLRAQyr7FYzcyDCZ0OiCJq/DM1lZdy8vxhcNo8vmw3G5Hk8+He+OUbCtBxEC5S7bJ50NdWxvah4eRwbIYVzAJHJuVhc7RUWG+4pW8cwCKzGasaG1FRFYu/6pGKfZUr3PKzELDZSgUFXKOKsC17zwAa1kBODCohAWXcPm41ODA+RMOfO60q/Da62+ne5iUNKKVqixG7qBTctTJ05CHhoZ07VOM1WqNSZ/2er2SUBwiKI6Pj8cIgz6fDy+++KIQ8qIUoqPm6lNi/vz5ksdEUHW5XMjKypK8Fg6HEYlEYkqlTSYTnE6n0B/SarXGOCHLyspQX18Pl8slCLZqQS2EkZGRmF6SADAxMQGPxwOTyRSzDdJHEoiKewUFBXA6nfB6vWhublZ1spIk6987nThibAxHjI1h3sQEjh0Zwfd370a4rQ09PT2C6EyOQwsSEiQP0UlGNNR7HVMoFApl5uFMBlz4x7Wo/PYq8AAcMGIVuxCXcPm40rwEL93+OL55w00Jh9FRDl3W79ol6bEXhjSNWAsi5pBgkPf8frzn90uCYNZ2d4MHJOXJere/R1QxIqY1EBASj9eKhDuI9sMhGjbz2ZwcvFNdja8UFmKrisgJAAOhkHAMH46MxAh/SjIgqUkZDIWE8QAQ0sHzDOq+rYFQCF/v6kJENnYSAmPQ0bIrg2HwVlXVlHtvru3uBgDcvXt3UusrJZ7Lrw2lEB0OwDcLC+GaPF4zw+CYrCxV0YmUbwOI6dEJROdP7dqaynVOmXmo45FC0cA8z4IrXrkbm7/9CP774nuT1nEGhTDiMsMRWP/5W7Bz3bX4+je+mO6hUtKAUoiHEnpCO+SCEQlaAaQOtsrKSng8HqF8WOzsO/roowFAUjbrcDg0xSgiroXD4ZhyaaWxxRO2rFYrsrOzhX6HJpMJZrMZpaWlkvkpLS2VuAaB2EToeM8TxEKu2+3W3Q+SiKDy0mkg1q0ppqurC9nZ2TE9NkmfS3GZOEmyBqL9HIcmb1jX7t6NEoUSmmQCi8TIry09pdhK1zEtXaFQKJTZA8MwOPn7l2HBsYvx+rd/A348WsBpBYtzuAXY+kI76j+6Apte+BNtBURB+/BwjDNPXD6sVdIqF3Pk2+B4Hq2BgOb2q6xWxdTkKqsVOQaDYtnyOM+jJxjULGmeAHAgFMI6cbmvhoswGSme3CGRlG2xi464Mdd2dyuWUZP9yUcURlRYtbBs3P6HYzyPZ/btAw+oOgr1QFyn4pLxRAgjKr4S5yQQK/TJe2kWmc3wh8OS0ncO0b6TSsKjmWFwxrx5Qh9PtSOVl74T4l3nlNkFFR4plDhwRgPOf/ibmLjv/xCZCKO74X28deMfMY/nsNJYiC13b8S2tg/x8G/ujeuyohxa6A3x0CNQyvtAEuRCFMuyKCgoQFVVFRiGiRGVxOvl5+eD53lV9yQAXX0Uh4aG0NzcjOrq6hgRVYzT6UR9fX2MKBYMBoUQG1JGXFNToyuBWksAJIidhok4/iKRCLxer2JfSIK8rBs42BdTjpJo+/Kk61OeZP3y/Pn4lsI8ioVDLdFQfpxmsxnl5eWSa4AkgcsDiOTXrPw6pqUrFAqFMjspqT8RS851ITQyjmHvIJ698h5grw8nMtnY0TWGM10X4OktT2Dx4sL4G6PMODP1o55ST0LiYCOf8WolrfM4TrOcOAxIypXl2weADSUlON3tjtn//SUl4AHNsuV4d6XE0TZdQSRKQhZ4Hme43bg0TtiLFuM8r1tE/MWePfhlT09MIGEiBHkej/T0YHwKTuj3/H6c6nbjRJsNG0pKFIU+0ktz49KlWNHaKgn5ARDjWhWTZzQK51Grj6bcfUneR2ohOXuDQSx45x3U2mz0h/NZBBUeKRSdGLMyAABLrzwDecctwrOX3YWssQmcxeWhubETdWeswdMvPYrs7NjyTcrcJBXBHUDiKcNitMpe1barJ5laD0R0I+5L0itRLsbZbDaUlZUJ86Mk/hE3ZW9vL3ieR21trSBSKjkOk0VJGJWHywBAVlaWrpCe8vJyAFGXI0FPqTkp495rtSomWfeYTMJ4CwoKhOAesXCo1b9Rfpzl5eUx1wLpGSomnjAbiUTwg23bEIlEBLF0riQOpur9SqFQKLMZzmgAZzfAbLfgmrc34Jkr78Fgy8dYikzYRhZg1cmX49dP/wKnnHx8uodKETGTP+rJexISW8RgKISzFMQhICoMMZPPc9AfDCLmluJiQRTKMRoFN2KtzSYJJXmzqkoQYPsnJjCegMAmd7SphdWkmglAl+hI+hkmO4eYXI/hed1hMErwAG7o6kL84u74vOf3Y0VrK1xWq6qgTdyQelHroyk/bhbSJG35+0iJCQD9oZBmf0jKzEPvyCmUJMivKsFVb2+AyZkDIxicwNhw7Kc8znStxKef/i/dw6OkCHFvRHmvw1Sj1PfRZrPpSjZWI9F+f1arFU6nE4WFhaipqYFpUhwjdHV1oaWlRRAdbTYbXC4XLrvsMgBAY2OjZq9DQmdnJ5qbm9HY2Aie55GTkxMzDiW6MzLwq0WL8KMlS/BgYSG6MzJijpO4KW02mzB+pRshPUKnzWZDTU0NampqUFZWBpvNltBNldVqRbXdDrkPmuV5FE7OIcdxgggr7+2oFfpSXV0Nl8uFwsJCuFwuxetE6fzH69/odruxY2xMkrwNzI3SlZl8v1IoFMpswGjJwOXP3orSK1cAABbDhNXsIvzwou/hsT89md7BUSTMZD+65Xa70JOw0GRC7eSPoVv9fk2RLwwADAOGYWLuXeJRa7OhLRDAqW43XhkcRP/EBPpDIQzKS6NxMERmzymn4KjJezm9iAWrJp/vYLn4LIGE3pC5N+vo66jEVERHre2QxOmEtzN53YivDdKf8ZbiYkU3JEFtf0RMBKLXxIOTjlgxEQAPlZQI149WKwA5Wv0hKTMPdTxSKElidebi6rfuw3NX3Yv973fiWGTCNrYAq5d/Djc9dBMKi5wocDpoucscZibTfpWcemVlZVNybGmVRSu5FtesWQOWZYUSXaXSYTHZ2dlwuVwSZ2VPTw9qamo0e0sGg8EYJ594XKWlpWAYBn19fYJDUqlX4o6sLKzdvRtO0U00y7Kora1FbW0tGhoaVI9fD2T+4zlHSRo1z/MIBAJCKbbf78flCxfinwxzMNlvcqz1+/cD0BYCtXqD6nHRytcnZe5yxE7BoaEhFGZnY8hgkIiPSk3GZxs0nZtCoRyOMCyLs+69HguWHoGmdX/GfN6Ai02LsOnmP6CtbTvWXHkRzCYzKiuPoy7wNDKd/ejUSrhJlQIJSIkn1nCApNcjSbVuCQTiJjK3BAJ4T1QdQggDqN+2DVaOiykvb/L58OHoqO7jFAtdAFIiKDGTf1IZzXTLp5+i1mbDxqVLsX7XLmwZHEza/ZhqeCQnapI+lfMMBkUnq1apNBE75XMsH8cL/f0xTlEOwPP9/fhqYfT7tJbAqTbu2f7D+eEC/fShUKaAMdOM1ZvW4ehrzwIAFMGES7nF+O03f4HvrvwOLqy5BLfc/NOEXFKU2cNMpv2KnXrEaTcVtyPZJnHFOZ1OIfykpqZGKCEmlJaWwu1246WXXsKTTz6pWIYsdyKS+ZALPB0dHWBZVtW5KE/eFhMMBuF2u8EwDOrr64UvSUq9Esnzal+k4pWpK2EymVBQUCBxEaoJWCRxm2VZob9ldna2ZJmsTz7B3SMjOIHjUGAyoSocxg97enBsJILq6mrNcyw/fx6PB83NzbqTS+XXlNPpVFxO7BT0+/04f1IUZUUlV+Ib/dkKTeemUCiHM8uuOQcXPnkTeBMHC1icZ8hH/z9a8b2V38VXz/sqTjvhQvT3D6R7mIctFRZLjIswFT/qyZOGSfJ0k88nLKNHrGFw8LNe7Ej8j8uFs+bNi+uA1BImfeEweoJBvDI4iFPdbjwy+aNoIsIhA+CcnBxJ4nOiIpQS2RwHNklXohJhHCzzXdHaipV5eSnbdroZ53n0T0xgMBTCgXBY4mRdV1wMhmFixKXjMjNRa7MplnzLz78ecV7pfRSPIo3vHZSZgzoeKZQpwrAszlj/BSw4rhj/uvGPyOUNWMnlI8wBQfBofuxfuLxjJ5546jeaggtl9qE3tTpZ5D3pampqUFtbK3m9ublZcf+RSAStra2a/ey0XHGRSAQMwwjr8zwftx8kwzBwuVzCOhUVFXjxxRexd+9eyXLBYBC9vb2K27BarSgpKYlbBkvEvoULF8Lj8aDHZIop/yW9Eh25uYr9/ch8eTwewY04Pj4OnucxodKQ2mw2C85AMp9qztH58+fHBLfIl/X7/bD7/bgOEMRDAAgien7IPsTjJ6XqpO9jfn6+kADe29uL1lAIT2dkxG1Oz7IsGIYRelK2tLQI51BprgnVRiN+OjaGZ61W/JfjsMxikfRmmq1M9/uVQqFQZjtFpxyHK//5Mzy16jaY9vtxMpONWlM2ePDY3RfEua5VeKLxjzjuuLJ0D/WwQ6nvYip+1FMq4Zb3ZdZyo4kRl7RqjX2qfL2rC8usVmyNU1kjhgFi+kxXWCzwBINTcisaGUYxLGeqRABEeB6/2rMn5dtON0rXGCmV/rrM9frh6Khiv0slJ6LadUqEwyafD4OhUMLX4Fa/X5LOTUkPVHikUFJE+ZVnILe0AC9+/l4YRoMwADCDwWfYeWhvGcSZJ6zCc6/9FQsWzE/3UCk6mUoojB60wkOAqFBEBKeenh7wPC+IKW1tbZLX5OsmilKPSTlOpxMul0sQyf72t7/pSp0WEwgEBPFLK1SGuNXOO+88/O1vf0NhMBhT/svyPI4xm1FZWama3iwvBY8HCdIh6wOIETBZllUsJSeiIQmWGR8fl8zPwMBAzPKAevo0+TfZHhDtc7lhZATM6KikOf1vMjLg6O+Pm36t1vdRvM+ysjJc4XLhB/Ema5Yx3e9XCoVCmQvYj8jHtf/agGc+dzcObNuF6Fd2BqXIgC1SgGvP/AJu/cNtuOCCc9I80sML0ndRXBKdih/19LjE9AiHLKQlrVpjLzKb0eL3Q/kn3PjwmHS7JSD42biDPjdSWr7V759yifRgKJSyfopKJFJKnk6USqGBqOBrYpiY3qBKwuEL/f1gEFtCrSepGohep1sGB2OW3er345GeHnyruzvpKsLZHpB4OECFRwolhRQcfzS+2PYIBjt7MDEyhjfWPYZAZy8qYUH2gBHn1qzCnxt+h2XLjkv3UCmzgHiiUJfsV8Ouri7V8t9E+9nJRU+1MlwAMBqNyMjIAM/ziEQiEkE0Gfr6+pCfnx9z80DKlsVutfb2dgSDQZy/fz92ZGWB5XlEJhtbMyyLDZWVaGtr00xvjjc3xBkYDh+8NRKvoyZokfJkgs/nkzz+r82G5xcsQI/JhMJgEFczDHJEv3wTZ6NS+rQaL8+fDzCMxNnA8jwe6O/Ht3p64qZfE5FTLFBSpyCFQqEcWphsWVjz0p0Y7OxBaHQcHz33Lrb/cTMcMGK1cTEeuP5ufPjdnfjBD78OJoVlphRtxH0XU4WSS0wu6siFQ6Uk6Xi98ORj/2xbG7YMDiYt/CXad284EkFdWxtW5uXhW93diPB8Svoyzpbei+lGbS6PzcqCjePwnkKIj90glZLah4d1nxMlt+9yux21Npvivn7y6ae6Q2Xk0D6PswMqPFIoKcaYacbCyiMBAFe8cjde+cavsfvlD3AkzLgIRfi/c7+MGx+5CRdffH6aR0pJN1rhIXrWFZczJ9rPTi7GERdib28v+vv7MTExAY7jkJeXh76+PkxMTAilunJBlGC1WmG324Uybp7nFQU1Il6KIT0S5eXiZJwlY2NYu3s3Xp4/H3utVrjmzROcAg0KwqJYYMvPz9cMmVHqmahnPsWCXSQSkRxrd0YGNkxug4Th3Mww+F5GBkrGxhSPUQ1xr8y9Visisi8LEQA9ogTyzs5ORVFRPEaxQEmdghQKhXLowTAMco8uAgAsrDoKBSccjVe/9hDsEQ4XGp1455cN+EL7R/j9ow/AaDSmebSUZNEq4VYLnalra8OrMtGQRawDTW19ALhp0SK8NjgolNESP+LRmZnoGh2N64bsCQaRyFUX4nm8MjiIVwYHFV11cxkDovdyuQYDDAC8oVBC60/nfPhCIYnbVMyHIyM4qbkZe8bHUWGxoMhsRo/OSiilsv4mnw+tCuX3YQADoZCqqCm+BiOIDQuaCwGJhwM0XIZCmUY4owHn/+ZbqPnBavAA8mHApcZFePiGDTiu+GQsXbIc3//ebRKnFeUgpMdhQ0NDQqEaya4305DwkIKCAjidTni9Xsl4S0tLJcuLH1dWVgrBIy6XC5WVlarHrDQfcmFNXMZN+h+Gw2EMykoeOjs7FY/F6XRi9erVcDgcQthKXV1djJOSJEDLkfc7JOMVH0fJ2Bhu8vnwaCCA9aEQTposQZYfi9VqjfaF7OmRlE0XFhaqBt6Isdlsqq4/8dhaWloE16Y8AVwpDIfneeF54GB5u9L4q6urJaEyJCV70cSEEPpCYHkehaIbPb/fr9hDUz5GmvpMoVAohw8l55+AyxvXAxYzMsBiBZcLw1u7UXHEchxXfDLOPv1S/O9/6j/SUWYnxM14Tk4OCk0mIYCFB1RDZ1bm5cWIOBEAqyaDUJp8PpzU3IxT3W68ohJas9xux28zM3G2aL9vV1dj+4kn4qycHF1jn0qp9qHE2Tk5CK9YgX2nnopc0Q/Jepmu+SCC3R6VtkgA8J7fL1wfWxWcimo8398vefxITw8+43bHOHEB9TJwADguK0ty7T9cWgp2sjKKHEMqAxKbfD7UtbWh6N13UdfWJglxomhDHY8UyjTDMAxO+NZFyDumCK98+ZfIDnOoN+Rj/6TY+OlTW1G3dQ2efulRZGfb4mzt8CJeD8RUrzfTEKeZuAdhT08Pent7UV9fj5qaGkkATHV1tSB0kXVJv8VNmzYJISLyY1aaj+rqavT29goOOI/HA7fbHdOHUN7D0e/3w+l0CvsCIITiyI9DSaSUi18EsfgmHi9wsAQ7HA7D6/UiEAgIPS9ra2tjSoXJMoSOjo6o8yM3F6tXr0Z7e7uiS5FgtVpVU6/lfTfV0ArDER5PujLz8/MlPSMDgQBYlkV9fT0aGhok26jr70drfr5Qck5EyPrJJGoC2ZZ8LsXQ1GcKhUI5vMg77ghc+8792HjRbRj77z64YMUi7kiEwjz8n4Sw6uTL8atND2D5KSeke6iUBFAq4a5ra1MNnQFixRzS47HCasWK1laEFEqx5YEiVQYDrisvByfrv/jGgQMpPLpDn9cPHMAjPT14ob8fH46MTNt+jEhM7CWC3Z27dsV1MhLH4XGZmbr6WopLn5t8PtygUk0FaAurNo6LDR2yWlPeS5WMc0Vrq/C+In3W36yqosE1OqCORwplhjjy3Fp8bvM9YGwZyACLQhhRCCNOYew49lMeZ7pW4tNP/5fuYc4qku1jONX+hzONfHxEBCTiYn19vVASK4cIS37Zr4xaPQ69Xq+iyOj1enWVW5GybOK2rKmpUdwPcempPWcymWCz2VBTUyNxbMoFSyLCDcv6s5CSb/k8yQW1YDCI8fFxeDwebNq0SRAo6+rq4HK5YJL9uuz3+yXuULHLsb29XXVebDYbTCYTGIZBYTAY60wEUDRZwi52Zba0tMQcW2dnp6IzlZScHzsygnkTEzhudBTf370bR8nKt8l68nNis9mEP6RnJ4VCoVAOHzLz7LjqtXuRf1o5GDDIhwGFMOIYZGI1uwg/uvj7ePRPf0/3MA8LtNxTU3VWaYXOKPXii0y+RlKylQgDeOPAAdWxEGFGybVGUWeC53FDVxdeVQhWSel+oF/8YQG8VVWFU+x2rNPpFgwD8IXDeKe6GnkGbX+buPSZiOFKmBkG8zW2peTGJEL8nlNOQWNlZUpER0A5QZ4XifkUbajjkUKZQXKPLsI17zyAtt83YmT/EDxbO+Hv6sWxyIRtbAFWL/8cHnjyfpx22knpHuqsINkeiFPpnZgO5OMF9IulaqEk4mOWb18egkKIRCKqjkQxJN1aaZ9aLkA5CxYsQF1dHdxuN5566inVfRPxT874+DgikUiMICt3c4oZHh7G8PCwxBXK87yk52QgEBBclb29vQgEAjECqhJlZWWCC5X94AN8eWREcBQQEfL8/n6Ew+G480zKpYmbs7OzE36/H8FgECUAvqUyzzabDWVlZcJ68nNCBE8AQs/O2egGplAoFMr0Ycgw4aInfoSPnv4XPB90YnTQj/+90oz5MOBiUxGevvlPaN+2A/fdf5tqBQBFilY/RLXl1dxTAKbsrNIKnRkMhWIcbOQ1JcFSzDjPY0VrK16vqIC8a56WaJkoZoYBA2BsituzsCyG58iPrDMxSr37ON5mEwS75XY7jsvKiuvGJNfQcrsdz1VU4FSFtj+E/42Po+jdd1FhsWCrxj3xOM8jotHzciZ7N+pJkKeoQ4VHCmWGycy14aQfXQ4A4CMRvPmTP2Pnn19HEUy4lFuMmy/7Ea698/9w/ZevSvNI00+yabtzLaVXSSjTK5bKb/BMJhMqKiokxyzfvlz04jgOVVVVupKVyfabm5sl80uCTHieR1tbm66+pUNDQ2hoaIi7X4/Hg5aWFpSWlkoEwmAwCLfbrSic6RFQOzs7hZJrrX1rYTKZsGDBgpjrrJLjsG7/fjxnteJ/HIfCYBD1+/fHOBMJpaWl6OrqkgicXq9XcHN6vV5V8dNmsyE7O1tyLgjy94L8eMgcKK0rh5T1612eQqFQKLMXhmFw7GWn4djLTgMA7Pn3Drx41U9hCQLnGRbi/adbcNGOq/Hks39AVlZmmkc7u0mmBFPJPSUuhVZ7TW8qtlrozKq8PHxdpayVlNXKBUs5PM/jB598Am50FP997z0smxRa44mWiRBKMsFYzlwRHWcTHID7S0okz/niBN7Ieykut9thZBhMqAjHRMQk15pWQI5aeTgHpKx3ox70JMirkegPE4ciVHikUNIIw7I4Y/0XsHBpMd7+0R+RyxtwsakQz9/2F2zb9iF+8eD6w/qLfbJpu3MtpZdlWdTV1aGxsREDAwPIzc1FpcaNJc/zcLvd6OvrQ7+sObPJZIo5dnFwixKRSAQ8z8ckZSsRDAaxefNmSTpyb28vWJYVxFIl0ZHjuJjnlUqx1ejq6sKaNWsUxTm5COp2u3VtN5H9q1FeXo7a2lrJc263Gy0tLSgE8HVZObsYq9WKiYkJ5ObmoqqqCgzDSPoxarlW5agJgfL3wosvvih5ncyBnl6oc6V3KoVCoVASp+jkY/H5N36Op1bdCvT7cQpjx/YPR3Hm8SvxzJbHUVAwu6tH0omWiKgmFMZzT03VWUVCZ+S97r7X3a3oejs6M1Moq33twAFAw2kYBvB+IBCt6giH0RsM4pXJhOtEsHMc/OEwGCgf71QhaccUbY7LzITNYBDSqUlPRLFYNh6JKPYFzTUYYGZZxV6KNVYr3otznx1PdBTDATBM9k+vslpxv0Iy9nSilSCvRZPPh9PdbuFaJGE8b1VXH1bi45wQHs8880zVL1xr1qzBHXfcMcMjolBSy9IrzkBuSSGeu+JuZI2HcC63AB88144LdlyBTS88CoslK91DpEwzbW1tkqCXtrY2VVHH4/GoOvECgQCam5tjRCgt4YqUGpMehfJAGbloKO8NKRYhlVKjTSYTysvLJW7FZGBZFmVlZRJxjvRfJPvv6enBvn37Yva/YMEC5OfnA4imSQ8NDcUVHeXHzTAMrFYrLBYLAoGAkM4tL/fWKpPnOA6RSAQMwwiuTHK+tZy64tfIcRAR1u/3S9K7xXPT0tIi9MKUp6TLiVfeP9d6p1IoqYbej1IOdbIXL8Q1b2/AP9bcDV/7LlQgC9lDHOqPvxS/f/5h1Nbqc9sdbiRTghnPPZWss0qMUuhMq0pFyMeTFRlEsLyovR39cVxucgFTj8hHxBrSP7DJ58Pa7u64AlUy6BmPneMwFokcln0p7RyHY7KysGd8HIszMrChpEQQwuQuXqF1kOhvMmPEwScXATeUlGiWWxP0znwYwDnz5qXNLagm5scTP9d2dyv+/7C2uxv/OYx+wJ8TwiMQLSW79tprY54vLy9Pw2golNTjPL4MV711H55aeSuw14eTmGzs6BzF8qXnIadwPrLtNtxxz42orFya7qFSdJBoWWoiok68MmIlEUouXMmdgwAUhTiyDbHYp9W/Ry5aAkBubq6Q0E16Faqh5IwEDopmcnFu586dkuWU5m3+/PlCL0myXn5+vqoQyjAMHA4HFi5ciLa2NuF5nudjXJJKfRLVRF7xscnnUFzyXFdXF9e5CEQFVLn7UwxxXorH6nQ6FY8ZONhLU+06TUfvVFreTZlt0PtRyqGOyZaFNS/egde+/zt88vQ7OAJmXMouwrcu+AZMR+aC4zhc9vmL8JWvXC38AHe4k0wJppZ7igeSclbFo8nnUy19FYuIpEffitZWRHhe8pped5oatTZbjFOtWUd7HDkn2mzYUFIyZdGSCG/xUpsPRXzhMLb6/YrtAdZ2d0uSzYnYmGswAAyD/okJsAD6QyFsGRxUbC2w3G7Hw6WlmonVibJlcBBbBgdRa7Nhz/g4isxmABDcmtMtSiqJ+fFQE/vVnj9UmTPCY3Z2Nr75zW+mexgUyrRiK8zDNW9vwDNX3oPBlo+xFFnICRfA/78wghjGl8/7Cn708I9xySX16R7qYcFURI9Ey1ITEXWsVmtct55SCbJ4//KyXjHynoGRSAS9vb3Yu3cvwuGworhIMJvNMBqNkpRmIpQq9SqUOyyVREeSOk1EMfFxyBOwlWAYJuZ81NTUwOl0KjpHeZ6Hx+PRXYYtF/xIr8vOzk7YbDYhnEar72UiJc+EeNeMkggr7hmZn58vcc+SNHW1faejdyot76bMNuj9KOVwgOVYnPvAV+FeegT+c/tfkQcDLjEuQu/uIHjwaLzjr/jPv97H7x97AEajMd3DTTvJlGDGc08l46zSgjjY1DoeTvA8FjQ1odZqFVKMyzIzFQNFjsvMxM7R0aTKmJsDAYlwmWwgzcdjY1i/axc2lJRgWyCAH3/yCXw6+ovLafH7kcUlWiR+6CBuD8BMtgdYV1ysKOZGAKGsesvgoK7WAl8rLMQyq1W4lovMZkHsnMp4yfjEgnEyIUyUmWPOCI8UyuGC0ZKBy5+9Fa/f+Ed0//0tFMAIIHpTd4RxER65YQM+7NiJm2/5Lv2leZqZiuiRaFlqIqKO0+mE0+lEX18fFi5cCK/XK4iCBHkJsnzsRBzr6urC+Pi4RPwj6cwEt9utK3gGiIqi+/fvlzwXCAQEQUsulpnNZk0hE4i6KNUSmOWBM0o4nc6Y+e/r64srIusJqAGAffv2YevWraipqRH6aVZXV4NhGFRVVeGVV15JqJdkR0cHAMQVuuNdM/n5+THOS4fDIcxhJBLBxo0bJa8rhc3IBXglR+Z0Qcu7KRQKJX1UX1+H+aVFaLju57CGgDJkAACO4jLQ+vZunLP8Ujy7+S/IyZmX3oGmmWRLMLXcU8k4q7TQI/D1T0wIjjJAuVSZBWAzGJDsN5AQz+Oi9nY8V1GB5XZ70iJU/8QEXo0zVj1MAEkJlgR538O5DA/g30NDQsCREkVmM944cECxdPiNAweEpGqx81B+LTf5fDirtTXl5e3JhDDNBFUqvS6rFNpTHcrMGeExGAzi2WefRV9fH7Kzs1FTU4Njjjkm3cOiUKYFhmVx9s/+D4tPPg7bnngdkWAI+9s+RTbPod7owL9/+xquat+JR//6kOAGo6SeeKKHliMy0bLURAJxiKDFiX6hDYVCknAatWORj3nNmjUAIHmusrJS4pbUI/aYTCbMnz9fVaDcuXOn4E50Op1gGAZOp1PoL6kHuSBH0qjlrkmO48CyLMxmM8rKyoTAGfH5GBoaiulHabVadYuNYsTCKNmXx+MBz/OIRCIYGhqSLK9WTk4YHx9XLJeXk2iIktPplIiTSiE8Ss5LuQAvDhOa7tLndJR3Uyha0PtRyuHG4tMrcMU/f4Z37vwrRgf8ONDdC/hG4IIV2Z5xnF2zEn/f/CjKyo5K91DTSqqFwlSjN3E63jJhRMtaX1+2DF/v6EBHEqnR/aEQTne7cXRmZtw+klrMBsGP3AFN51imWt4uxgDAZbOpCr7D4TDeOHBAdX0toXic59ETDMZ1Hi6323HGvHkS12SqSDSEaSbYUFIiCZcBlJPDD3XmjPC4b98+3HjjjZLnPvOZz+BnP/uZ4pdsCuVQoOzi5Si7eDkAYKBzDzZddBsy/GP4DJuDbf/pw9knX4xnX30c8+fT90CiKAVvEMcaIZ7ooeWInOmyVHk4jbyXHxm70pjFY+N5Ho2NjZLAGK2+gIQFCxZovi4W9Px+P2pqauByuRCJRDTDcsQQQY4IX2RdOeFwGJWVlWAYBl6vF263W0gJJz0myR+HwyEpC58KXq8XDQ0NkjGJ/22z2VBWVgav16uZUC3enhJ6WgBEIhHh2ibI083l25cLouR1+XLiawOY3tLndJR3Uyha0PtRyuHIvCUOXPCntQCA8PgEXrz+fnjfbEcZMmALOXHladfgnsfvxjnnnJ7mkR4eiNOG9fa1U+pDmQykd+Vyux2PWSwYXrIE9+zejdcPHFDtH6lEGMCHo6Oqr88VJ2Hysql+UiU6sgDAMNhQUoLTVEJfQoCkt6MYA/Qdrx7nobw9AYEknSd77pMJYZpultvteKu6OqWtE+Yic0J4vOSSS3DCCSegpKQEJpMJH3/8MX71q1/h7bffxg033IC///3vCZecarlNKKmDzDOd76ljP8qJq97egH9cegdGPulDNSzI3juOs2tW4fGXf49jj9FOrNXicDxPSsEbgFSEW7ZsGXieF0SPZcuWSeZILnp5PB7J61VVVcK/eZ7XNb+RSARtbW0S96FYLFI7V/KxMAyDmpqamLErjVnsOlQSxIaGhhTTrsX09vbCIvugN5lMMJvN4Hk+xknY1dUlzHW8/7/F7kalY1Wio6NDGG9PTw9aW1uxcOHCmP6Yetyc8RyKhHA4HHd7ZL71bH9oaAhbt26NuQbE125PTw94no8R5JTcjAsXLpTsh5Rid2dk4OX58+HJzIRzdBTn79+PkrEx5OfnY2JiQjL3SsejNTfxrmc9JPM+SoS5+P/fXBrroQS9H527zMX3+azFwOKCR9fi3/c+he2/eRlOGLHauBh3XX0rtv/wCnzz29cnvWl6nuLT5PPhrG3bwAMHQ0EGB/H6smWa4uOPFy3Ca4OD4JB8WTLhpsWL8a/BQdw0MoL/fvQRKiwWfMPpxAO9vVPc8kHmgug414gg2sfxzl27kGMwYH+CbtNElg4D2DY8rPpePslqxesVFbh7925BjLt58WLwPI+ztm0DM7kNUtvlmgyTCYTDGFLZJll2IBRC4WTJ902LFim+L5p8Psm+1ZZLFSdZrXhJFkInn5u5+v+f3vEyfDLdXGcBkUgEV111FZqbm/Hb3/4WK1as0LVeOBxGa2vrtI6NQplOIhNhfHTvixje+ikAwIsJvBTcjatvugannnp8mkc3d1BKVyaONL309vZKRDBSbkxKiZNBvk2n04mCgoKUrae0HAk/SQVEbLRarcjPz0d3d7di+TLHcaisrITH48H+/fsVRU0yn0NDQylzJcYTUNVEQHI+E/nIJIJej8mEwmBQEPTIOMg8EXFba8zz588Xyt7l/TyVrlul69tqtYJhGFitVsHF+vrevbgpMxMAEGEYsJPHd/foKM5auDDGjSqfv3jXZ7LXM0Uf8pYLlJmH3o9SDmf2vf0RPnmgESwPjCKCt8MDYI/Pxw9v+joMBvp/03TwzZERvCdzhLEATuQ4PJSVpbluayiEPwaD2BEOIwRgDBAETOIwZCefU7vbKWdZfMdsxldGR8GL1okgtSXBUyUVAuuhihHA5QYD/pqA8KjmQGUBZAMYkr2udk2Sa7A7EkEJy+JLJhOqDAbNZa43m1E5ea/TGgrhy6OjMWOZxzAoYhh8OPljObkuGQC/zcyU7KM1FIq5fpWWoyRGvHvSOTuzLMvikksuQXNzM1paWnTf6BEqKirozfoMEA6H0d7eTuc7xVRvqsH79z+DtodegANGXGY6As/fsxFj35nA939wQ8LbOxzPk1JvwdLSUom7Kh7Lli1DW1sburq64Pf7EQwG4fF4hLJmNZeXmgssEonEpDSTfo4EpXMViUQQiUQQCAQwPj4Ok8kkuBzl7jIyZvG+29radPdZjEc4HIbNZoPD4UBvb69qz0SlUmm5qLV06VLU1NSgsbExZcLjxMSEpoNR7bVEf6PrzsjAhkWLAIZBBMCQwYAdWVlYu3s3SsbGEAwGMTExAYvFgnPOOQevvvoq+vr6FLdFritA2e1ptVpRVVUlua6Uks/JuSAl5jU1NVjX0QFG1GMnwjDgALxRWIjvl5fHCKJ5eXmCAKrHwajkxE3kPTYTzMX//8iYKemH3o/ODebi+3xOUFWFvStOxPNr7kbmaBBncfPR0jyIm757Dza99CfY7dkJbY6ep/j89733EJHdp0QA/Jfj4n6+VgEolTkmuck/LqsVe4JBVFgsGAyF8L7KD9IDBgM2ZWSAF4k/5O90iI5KYucJNhs+GR2dUv/IQ5kJABtDIXy3oAC/6u3FhI511ByoLIC7Skrw7e5uwaVIlg9nZWF4yRIst9vR5PPhB59+ivdF5fUD4TA+GB3F68uWAYDEgfjT0lJFB2IVotew3Cl5SnY26js6sEN8T4votb0pIwPXidyGN3d0ALLrV2m5mWau/v+n9550zgqPAJCTkwMAGNXoD6EGx3Fz6oTOdeh8p55Tfng5Fi49Aq/e8CvYIxxWGp1458GXcf32TvzuT/fDaDQmvM3D6TzV1NQAgGaPx3hwHIfa2lr09fVJRJ7u7m7hcW9vb0wac2trqyD0iV9vbW2NEYscDgdaW1slJdNk3+Rctba2wi3q1RIMBuF2uxXDR8iY5XNBxFM9aLkGw+Ewent70dvbq3ktTUxM4MMPP5Q8J9/m3r17FeckkRAYhmEkomG8Ut14Cdt6MJvNeGfJEkDkSCBuwpfnz8e3JsvZidPxtddew4UXXhjTH1LOwMCA4vMMw4DjOMl1BWjPU1dXF1iWxVafD2HZNR8G0DE8DI7j4HQ60SsqnXI6nQkH2sjXn63/xxxO//9RUgu9H5070PlOPc7qElz9rw14atWtQM8AahkbsneP4dzjL8bGVx/DUUcVJ7xNep7UWWaxoE/Wq5GbfF5pzuT9IAdDIUF0BA6KjwzDYJnFgvbhYfRPqEtRyywWbPX7p60UWm9vRwbA2qIi/GKy5UxY9tpRmZnoT1E1z3TDAYL7bqYIA/hTX58u0VENI4AHS0vx1cJCVNpsWNvdLUlvbvb7cVZ7Ox4sKcG3urtjekeSa++Hn36K5kBAOI99wSBe1winOS03F6cp9FTuUAhQEt/TJrpcujhU//+b08Ljtm3bAACFhYVpHgmFkh5K6k+E/eV8/OPSO5ExPI4VXC7cb/4P1SWnw2zNgKPQgd/88edYtIi+R+SwLIva2toYES4Z5CE0cuKlY6uFeNhsNgCQhMHwPB9Txq1Wpuv1eiXp1GoJxCzLoqysTNiPHIvFIqxXWhrtJSp3SBLxKyT6dVmrNyAQX+QLh8OSMZGS4p07dyoeg9L+qqqq4PF4dPVyTAZSviwWR8vLy/Hf8fFYRwLDoEchhX5gYCAm+EWJ3NxcRWGSlE3Lj9Fut6OsrAxdXV0ITN7QEYLBIJqbm+EoLMRgVhYiomtK3Ji7uroaPM8LAj1J6tYr0NNwGMrhAL0fpRzuWPJzcPUb9+H5a3+Gff/+CMcgE9ZgPi475UoweRkwmU347o++hsvXrEr3UOc88lAOIhreUlwcs2yTz4cVra2CoKMWLhMG8J7fH7c8mQFwS3ExVulwNyWT9mznOBgZRpdTkQHwmNcLM8NgWCZobZ28J5sLATUMgHNycjAYCuGDaRR05fAAfFPsJRgG8M3ublRYrYoCYRgAeB7f7upSPa4wgFaR6EieixdOo4RSgJJS2Ize5SipJbEO72mgu7sbQ0NDMc9v3boVjz76KEwmE84999w0jIxCmR0sWFqMa/51PzIWL4ABDGphxSWRRTjHn4cjd4xh5UmX49//2ZruYU4LkUgEzc3NaGhoQHNzc1yha7qorq6Gy+VCYWEhXC6XIM4R5GnYao/lz5eVlcWU3yoJaGrHTYS7np4eNDc3C3+U5qu6uloQOuUEg0FYrVZkZ2cLpbIul0uyPM/zMWIUz/MwmUwJh4kQ9u7dK3mcnZ0Nl8ul2D9TaQ5cLpfq8qmCYRhcdtllkvNfXV2NCosl5gOW5XkUKoitxC0lP/8Es9kMl8uFuro6uFwuFBQUwOl0wmazwWazCWKg0nVFRFG1UvHz9+8XxgbEfoFhWVbYht/vR0tLi8RdGw/iuq2vr4fL5Ur6WqBQ0g29H6VQtDFkmnDJxptx7Bej74MiGHG56Qic48/Dqf02/PE7D+LHP1qfcOsSipTldjverKrCOTk5KDSZcE5ODt6qqlJMyF2/a1eMoKNFvNcfKS2N7kfHfRUP4NelpXi4tBR2He4tFlEhbEBneXQEQH8ohGGF+78wDrrpZrvLar7BgHXFxWgJBKYkOuYZDLrmOZVEEL3XX79rF5p8PonbUcwE1AVgMmIlB2K7qM1Sk8+HurY2FL37Lura2tDk88Vsa11xcdQIIdq2kiivdzlKapnt70U0NjbiD3/4A04++WQUFhbCZDKhs7MTTU1NYFkWt99+O21UTznsyVpgx1Wv34sXvrQBe9/ejgIYJxuemOBgF+H7F30PX/7pN3DtdZene6gpxe12S9yAABIqA00V8pLmUCgEj8eDgYEB5ObmolL2a53cBVZZWSk4E0kwjdPpRHV1Ndxut8RNqSROqQlr8tLc7du3S5KegYPzpeV6nJiYEJx24vW8Xq/E6afkYGQYBtdffz1eeOGFhF2HcjExPz8fQNR1Ga8npbi8Xa1EWY7T6YTT6ZQkYsfD7/dj06ZNKCsrQ11dnSCs3bRoEbYMDER/bReFtqweGVEtga6srERvb29MeMzSpUsBAJs3b0Z+fj4cDoekNL6lpQUej0e4bliWFdyFjY2NiuM2m80IBoMoGRvD2t278c6SJfgfx6HCYsEtxcWSLzDxHLsUyuEAvR+lUOLDMAxOv/0a5B23GG//4A+Yx3OYx0e/3hcZHHjviX/j0u3X4W9P/xYZGRlpHu3cZbndrssJ1q5QUkog7kYtl6OZYZBnNAr3BjyAurY2+BNwJG71+3WFvMj7RaaCCcx+l9VRmZk43e2echDO+iVLsG7XLmCGE5GJQLh+166k1mcYBlVWa8x1InYgKjl3X1MoxSaivLi1gPyeNpHlKKll1guPJ554Ij7++GN8+OGHeP/99xEMBjF//nycf/75uO6664R+ZxTK4Y4hw4SLn7gR2594Hf99qx3BwCi8TR9iPgy4xFiEp378O7S3bcfPNtx6yLiOZqsg0tbWJgkDaW1tBcMwknJTsVBJnIgE4tQDYkXKZcuWCWV9BHkfPYK8l+GErGePfL7E+4pEIqpp02S9eCXmQPSX0K1bt6bU4VBTUwOGYRSTm8X7bW5uRnV1tWqJshiO41BfXw+WZVFVVYXGxkbs378fPM/HzJscv98vnD9y3pbb7bhl/348nZkppFrX79+PC5cuRUdHh2T9wcFBANLrBjhYWk6OBYDqfIvXE18/aueotLRUuCZdDgd+qlKGD0QFX/E2iABMoRxO0PtRCkU/S9eswIJjj4D7dw2YGAui553tMA+PYzk7Dx1tQzjjhJV4bstfkZ+/IN1DPaRRKymttdmQYzBI+j4qCT9VVquw3Pe6u4USZr1CYmsgkPZk6dleau0Ph5OaI2byT67BgPVLluArhYV41OvV7M85HXAAisxmvHHgQMLrnmiz4f6SEvAAVrS2qrYPUHLuKpViy/uZrtMQE/WK95TUMeuFxxNOOAEnnHBCuodBocwJGIZB+dVno/zqswEAe979EC9edS8sE8B5hny8v6kZF++4Bn9/5vfIyspM82injlxUUStVnWnkgp7YnabkzNQSUOVuSqVgFCIYyoW4zMxMibNOLv7J50u+L7kgKl+vuroavb29mqJeMBhMWWI2KTsn45Q7LuU0NzeD53k4HA709fVpluKzLIuGhgYhjIZhGMyfPz+uYCmmvb0dHo8HPM+D53kUBwL4lshtSVys8jkjwqL8OsjOzkZ1dTU2btyoewyA9PqRi8nEFUnSzCkUij7o/SiFkhgLly3Beb/6BgBg3DeMpy9bD/+O3ViGLGQPGvDZ2ovx6Iu/QVVV+lJkD3XU+kESsYeINEVmMwCpCxKARGjsSUH4HkUKA6ArmVAyRPtCykW3rSkI00m0L2YEUC2xVoMIjmJRUMuBqOTcVSrF1uOKpKSPWS88UiiU5Ck65Thc+cbP8NSq22Da78fJjB0fbh/GmSesxLNbnoDTObedS7M1uCLRsJmpCqhEiCOl2URkEotb8iRqm80Wd77I60RMY1kW+fn54HkeDQ0NcDgcqKurQ1tbG7xeL4aGhnQnY+tBPuZ9+/ahubkZFRUV2Lx5c0wPSCX0pnWLy8m1kKdkiwkGg4rOUyAqOhJHZV1dHRobG4WSahL0QkJiCA6HA263W3P8NpsNVqtVMvahoSG8+OKLkpJ9sZsxEolIErTjtSmQ9xmVP6ZQKBQKRQuz3YIrXl6PV771MP734ntYAjMuRhG+ct5X8MNf/xiXrr4g3UM8JFErKSUOM7FIA0SdkHvGx1VdkEqYGQYTPB8jVjGIOiYTFaUOJ3gAE0lUBIUBlFssqGtrw9ZAAOB5+EKhlLhLE3WIJjp6DkCOwaBY/qzmQNQTBqPYz5TncVF7O56rqKDi4yyACo8UyiGO/Yh8XPuvDfjHmrvga/8vKmCBzWfA+cdfgt8/9zBqa+euzVzu0JstyAVRnuclrj+5sJgqAVU8Hw0NDZLXSE8/QllZmZAETcRKUkLb19enWBIOSF2QPT092LlzJ2w2G1iWhdVq1SXyaYl3wMESY4/HIxHyiEC3c+dOxR6JQKxYmUohFIh1jeqFYRhhnh0OB+rr69HY2CgRnPfv34/q6mrs3btX6P25adMmxe2ZzWaUl5cL14rb7RYcr+QPAPT29qK3t1cQPcmycpFVq02BXBjPz8/XlZZOoVAoFAqBNXA4/+FvYuvSI/DBT5/CQhiw2rQYv/3G/dje8RFuuXVtuod4SKIk6NS1tcWWriIqCP1n8r6v6N139ZVUT4qODKQi1COlpSi3WlPSv5AFcLzNho9HR3UlXh/qMADu27MnZs7nAmKnolJptJJAqCfJXa2faX8ohBWtrdT5OAugwiOFchhgsmVhzYt3Ysv3foNPn3kXxTDjEmYRvnnBN/DtB76Hyy5fme4hHlLIBVFS4qoUJkMepwoiJMrTV8U9/cTiplJAj/jfLpdLIk7KtxsIBCQiIAk3yc/Ph8fjUXQRWiwWVeEQAMbHx9Hb26sqGmqtO1sZGhoSRNSenh50dnbGiJjBYBBdXV2wT94Ytba2qs5BeXm55BrTKj33eDxwu92CI1beYxLQdtkqCemzIdSJQqFQKHOP2q+vRN7Ri9B4/QOwhYF6oxPv/v6fuLJjJ/70+IPpHt6cRq+Qo6d0VcllpgQJcIkAMAJgJ8NCyq1WLLfb8VZ1NdZ2d6N18t7tqIwM7JwsL5Zvm5R4H52Zia7RUUwgKrJxkyGKz1VU4DNu95wT21INL/s7UQwA0iXfEqdiIqXResJgtK5XXqEfJGXmocIjhXKYwHIszvvlDWhZWoz37vwbFsCAS42L8Nj3fo32bTtw8aXnpnuIhyxavRN7enokPf+mKuSIhUQg6gA0T/buUXKmaTndyGvybWrBMAzq6+sBxLouxcuQ9G6xO48QDAY1y8TV0LucHuK5MpWWt1gsGB0dlfThVCqFBtSdmETI7enpgc1mk7zGsiwMBgPmz5+vKFZrlfh7vV7V80jKsdWQX7/y86p2DYkFa+qMpFAoFAqh+OxqrNlyDzZddBvMQ6M4jc3Btvf24ZxTLsHt9/0w3cObkyQi5OgpXVVymQHRcuzWQADjonskUp47AQA8j61+v+AyA6JOyjyjUeglmWM0ApPrH5UZ7TlPSrxJKfjpbjeAg+XI7/n9ON3tRjbHwTfDyc2HEiyiouNMuiXJvsROxTt1BsYQ4oXBkOsVCvfuclFdjF6xnjJ1qPBIoRxm1Hz5fOQdvQgN1/0c1hBQZ8jHe39pwhWP/gOc0YBjK4/Bnx7/JXJy5qV7qLOOVAkpcqFmQBRAovT6VLYdDAaFgBePxwOWZSVj1xKrIpEItm7diu3bt+vev1isk2+bCINEbHS5XHA4HHHDZ5QERY7jYoJ2UiU6AlGxTSnIRwslJ+bY2FjSYxgZGZE8jkQigijb1tYW40bNz89HTU0N+vr64PP5JONxOBwx14a4XDuR61itJ6n8/UEeA1FBned51NbW6toHFS0pFArl0Ca3tBDXvvMANl16O4a7PKiCBbZ+A759xY8QMjOwZlvxs4dux5lnnpruoc4JcUJv8i+gXboqPlaX1QpAKgqeYrej6N13NcNmyL7XdnejORAQxiVeh+xzQ0mJMJdNPh/u3LULrw8OKjrXwgAKzWb4ZPdHFH1wiIrEiQbITJVsjoOV4yTXkB7XbSIQV+RF7e0x5fgkebuurU3yHgZie53SQJrpgwqPFMphyOLTK3DF6/fiqVW3wXxgGMvZeShlbeDBo79tCGfXrMTfNz+KsrKj0j3UlJEKIUOpLFnNmai2v0gkEpOunJubK3HETSWdW0tIVHJVEqdbR0cHxsfHY5ZPJNUZiN5EAtHj53lecO2Vlpair69PMjZxX0ktRhUS/5SERzlaDki5o5FhGDgcDuF5eYCKxWLBsMbNkJpDcmJiAhMTE6rrGY1GYa7IHz0ouVF7enrgcrlQX1+veP253W7J/MvLtfW+R9R6ksrHYjKZJOt1dXXpFh4Tea9RKBQKZe7ga/Jh1/pdGG4fhqXCgvpbb0TT439Gz+YWlCADV5qPwhgiCPp53HbFzdh56xfwtRuuS9t450pabiJCTiKhMwzDxByrnjLsMLTTjsXiZI7BgK2BAPonJuI68XyhEB4uLcU3urpmVDyb6zCIulXT0SdzLBLBgc98RvKcHtdtoiy32/FcRYXkGlZKaCfvYZfVmpDrkjI1qPBIoRymzDvSiWv/dT82XXYHAh/1wDn530EBjMgLmXDFadfgp4/fjXPOOT3NI00NqRAy5I4xLWei2v7kwR5Op1OSDJ1ouIxcLKqsrBRCRvQci7iMVm85tRZDQ0NoaGiISdVua2vDggULYsaulZBMhFolgVFLzNODwWCQbMNoNArnQT4PHMcJPTK3b9+uKGbKxWQ5cmGSCKdkDE6nM0bkzcvLU50fIk6rXZNKwUvV1dXgeR5dXV3geR69vb0xwqSe94haqJN8LIk6RrW2NRUXMIVCoVBmB74mH1pXREUBhIGgN4gDrx3AZ974Ij5aegTc9z+LXHAAOIAHFpoK8cr6v6OjbQcefPhucBwXdx+pJhEnYTpJVMjRHTqjcKzriovx2uDglJ1zRJwUbyfez69FZjP+7PXOSdFxpp2GYngAzYEAXFYrBnWklU83xHXLihLRwwBW5eVNabtKoro8oZ1c162BQEpdl6miyefDPbt3z2qHdTJQ4ZFCOYwxz7PgipfvQvuft6Dr/XaYRiLwvNWBAhhxmXEx7rr6Vuz48efxrW//X7qHOmVSIWSolZgmsj/586Rvn7hstrGxUTFhWsl9piQWlZWVScQzpT6DasnaekRLLeRhM4RwOAyv1wur1Sq87vF44HQ6VbdlMBhUHYt6nIFapddy4TIYDOLll19WdDWGw2G0trbC5XLhmmuuQUNDg6ITlPTTVJo/eem23LEpL7cHgIKCAhQVFakmjgOJXZPk+iHjI+eBrB/vPRLPESkfy8KFCyXzVFpaqjo2OYkcF4VCoVDmBrvW7xJERwBAGOA5Hv+96784qfFSFJ14DP7955eRY81G13P/RlYwhLO5PGxt2IH6sz6Hp196DFZr8o6oZEh1SWg8ki3r1pP8Gw+9x7rcbsfry5bhxu3b0RKJSPo9JkMiYtzWGRLNUi0SMineXjIk0rs8lVRNluyLWW6348GSEny9q0t4jgXwze5u8ABe6O9PWniTi+pKCe1hRIUwDkip63KqtIZC+Oq2beAhdWfONod1MlDhkUI5zOGMBlR84VyEqxeiqqoKXc//B//87m8wL8JhlbEAb9z7D3Rs24FHfvfztPzSnCpSIWSolZgmsj+tcehJmJajJBbV1dUpjlMuGokhLjbifJMLkKkKbpGXTe/fvx8cx4HjOOTk5GBwcFDYTyp7Nuqhr69P86bM6/WCZVnU19fD7Xajvb1dMsZgMAiTyQSn0wm/3y8RYDMzMzXTuEMKZS979+4VgnrUSOSaBKLlzmrHFu89Es8RKR9LZWVl0k7eRI+LQqFQKLOf4fbh2Cjj8OTzAJwnHoMjzWOoqqrCSd9fjY0rbwW8B3AiY8NHH4/hjJoL8I/XnsDixYUzNubpKAlVosnnw9rubkl5ciKig57k33iolVD3T0ygrq1NIgAtt9vxUFYWPjs6ivEZKt3lMDOBKNMhEs6GJO4wov06a202zTL4VNMSCOCk5mahnycR1984cEAyLxEA4Hnc0NUlCL89wSBeGRzEw6WlWGa1JiXKq72Hq6xWNAcCUxLrU80fg0FBdARmr8M6GajwSKFQJBxzyXLkHuXAM5etR+boBM7k5qNlczc+u+Jy/KPhMWRn2+JvZBaSCiFDrcQUUC55Vtqf1jj0JEzLkYtFkUgEjY2NcDgcOO+889DW1iY81tPXkhyj1+tN2PmoJwlaLRAmHA6DZVksWLBAcjw2mw3Z2dkxYSla6On/qAf58ZD+nGSOxGnkBOL4rK6uhtfrFRK8xUErQPS4jUaj4LxUGq84oEXNZah2TSba0zQ/Pz/ueySeI1JpLMmOTeu9RqFQKJS5iaXCgqA3GGMxslTEinhW53xc89Z9ePbz92JgaxeOQyZsowuw6qTL8NCmB3Dq8hNnZMypcBLGg/SRDMnuoRIVHeIl/8ZDfqyEcZ7HlsFBRRF0JgW1ZO7s5I42PcwGkXC6qLBYps2tyyHaRxKQ9vcUp5I/VFqKb3V3S0r6xURkfxNu6OoS+jUm6gRUew/fX1ICHpiSWJ9quiORWVn+nQqo8EihUGJYWHkUrv7X/Xhq1a1AzwCOZ2zI3jWGM2suxFOv/hlHHnlEuoeYMNMtZEy1Px6gHQwzNDSE5uZmLFu2TPK8WCwS91Xs6emRCGN6+lqKBSGfzyd5TU+ydDzRMZ4gODAwgPLy8pg5cDgcMeNRgwSaJCM8Go1GyTFWV1dLAnY8Hg+efPJJ2Gw2sCyrKcxu27YNCxYswGc/+1kYjUZs3bo1ZhmlPpVEaE2076KclpYWIS1cnChdWlqqmCLe1dUFhmE0BcpUlT/T4BgKhUI5PCleV4wDrx0Az02WW3NRAaD4lmLF5Y1ZGbjsH7fgjZsfQ+cT/8QimLCaW4wbL/0BvnjXV/HFL1057WNOhZMwHqSPpBIzKTqIj/WNAwckJdRhAJgMg/nPHPrMZhkG4TSVGM9Gbikuxp27dik6W1PRs9MfDuNjhVBI8vpPPv1UVXTUs33xv/WK8vHew7PJSVjCshgIh2dV+XeqoMIjhUJRxJKfg6ve+Dmev+Zn6P/PThyLTNjGF2L18ivxwJP34fTTT073EGcVqeghKRYRSU+/rq4u+P1++P1+NDc3g+d5ITkakAqZDQ0Nku3J+wbG69nH87yiKAVEBTGGYSRi28KFC2NKirWIV26cm5sb02uSHLc8IdloNCIUCsXcqCdTnk2cjWRdm82GsrIyVFdX4+WXX5Ysq9bDUg7padna2gqGYdDW1qZrLGVlZRIRTn7OWlpaEIlE4HK5NB2M8pJqkihdU1MDhmFiUszJPAPqImCqyp+Tfa+kIpmeQqFQKOnDvtyOqjerJKnWxbcUw36KuojHsCzOvOeLWHDcYrxz82OYzxtwsbEIz9zyKDq27cB9D9w+7Z8FU3USxkOptyJhKqJDMv0iybEWvfsuehTuqd7z+9Hk8+Gkyb59R2VmYr/CD7HFJhPyzWa0BAII87zgVptaNGDiyF2khzMn2mw4xW7HuuJibBkcjHk9FeXlH46MaL4+EAqp7oebHIPeM5aIKD/d7+FU8SWTCR+MjgpO3dlQ/p0qqPBIoVBUMWaacenGm/HWrX/BR4+9hiKYsNqwCOsuvxFX3/4lfPmr16R7iLOGqbjB5IJKXV2dcBPd19cnEfu8Xq8kkEW8rjxZ2Wg0SsSleD37bDb1MvqCggIA0uRrNdHR4XBgeHhYEPOIoKcm2HEch4ULFwrHXV1djc7OTsky8h6I8+fPT0jctdlsGBkZUXRCKrkMiKg11Ubc3d3dukvWnU4nqqurNc8pz/Nwu91JO3jjpZhrzanSPpMRA5N9r1CnJIVCocx97MvtqGxMXACouPps5JYW4oXP/xSWIHAutxDv/6MVq3ZchY3P/RFZWZnTMNqZQa23IpC86EDKt4m7jPTKO9FmE3rtxRuTkvAIRB2aL5WXRx+o3CftCgbxxNKlwn6afD5c1N6O/hnqB0lgcGiXTifC/SUlAKIi3Ez3eSTkGgwYDIVirnUjALvBgAmeh09n1dKh4gQUU2Uw4PVlyySp1uku/04VVHikUCiaMCyLFXdehwVLi/HWD/+AXN6Ai02FeOmOJ7Bt2w48+Ku7qOsIU3ODaQkqiQR+AJCkRgcCATidTrAsK5RhNzc3C+JQPOGOrCs+Hp7nBTfdiMKvmiRcxeVyxYxNDYfDIQlRcbvdMWIdEeAYhoHD4ZC4PvVgtVpjtslxHCKRSIy46Pf7sXHjRpSVlSW0D72YTCYsWLAACxYsQHd3N4aHh2GxWHDeeeeBZVk0NzdL5k2pd6bX60Vzc7Oi4BeJRGCxWCTHWzJ5s0lQSzFPtHw6GTEw2fdKKlzFFAqFQpm7FJ50LD7/xs/x1EW3AfuGcAqTje07RnFG7YV4ZsvjKCx0xt3GbEStt+KJNhvuLylJSnQg5dtyCec9vx8rWlvj9sZbV1yMVxRccYDUZbZHo9LkovZ2mFkWRWYztvr9aREA050kPVtYW1goXEdNPh9adVYrpRIOwJ1LluCb3d2SfotA9DwRQVIuFrOTzxEONSegnOV2Oxpzc9M9jJRDhUcKhaKLpZ9bgdySAjz3ubuRNR7COdwCbH2hA/U7Poef/uJWsCyLo48+KqYk9nBhKj0ktQQVuUizbNkybNu2TXVded9AIhwScai3t1fYrtxNV1paCoZhNN1r8nJrOcFgEG63GwzDoK+vT/O4CfIQlaGhIdVleZ6Hx+ORuD6BqJgXCoVijgmAkDItR6sPJCk9tk6WEhH0BNewLAuDwQCe52MEQCDq1qyvr8eLL74oEYk3b96MCy+8MOacyntPAoDP5xOEPrngR+ZRjlyoFKeYa4mAWq7GZMTAZN8rqeoxSaFQKJS5S/bihbjm7Q34x5q74Nu2CxXIQrafwwUnrMY9f1qPwgIH8vMXYOHCvHQPVTekB93a7m5BEKqyWrEhSdER0C7f5nX0xltut+NEBVec3GVWYbGgV0V8JO5GNefkVLFzHPzh8KwVFzkABoaR9MpMF7/s6cHFCxdiWyCAG2TteKYbBsAJIhG9QpZOPRgKYavfL1yvPKJiY67BADPLCq4/vUEwybQYoEw/VHikUCi6cdaW4eq3N2Djyp8AfT6cyGRjR/covnzOVxABj7FMHo8//ztUVZWne6hzCi1BRS7SyEUv+bq5ubmSpGWHw6EoDrndbslyRDDWKpWNRCIxJdAmkwkTExMxjryuri6UlpZKxiZOcSZYrVaht6Raf0kl9u7dK3ms1NtRXMK9adMm3dsWMyzrHaNHeDQYDMJ4vF5vzDpkfuU9OMlj+TldunQpPB4P+vr6hHmWl62Lz7GS+Ldt2zZhDGKhUo8IOBVHbipJVY9JCoVCocxtTNZMrHnhDrz2g9/hk03v4AiYcSm7CD+77g74w0GMRiZw1feuwo9+/M2EKyTSSXMgILgUt+p0JqqhVb4dBvDGgQMoevddTWFmQ0mJpFxbyWV206JF2KzijJxuhsLhtJVRGxgGZZmZmj0Nw8CsCbaJAFjb3Y33kyivNjIMaqxWfOD3JyXyMgByDAbhXMn7LS5oaoq5TiMAzCyLPaecInk+Xp9GeYuBRNKvKdMLFR4pFEpCWAvm45q3N+CZK+/BYPPHWIosHGleDAAYjITxlc9+FT/89Y249NIL0jzSucNUBBX5upWVlWhra5Nsy+12x4hDcnEqGAyipaUFXV1dQrAKgJjwGbl7r7y8XJL8rIXZbI4RHgOBAFpaWsBxnMpaymiJf0ToC4fD8Hg8aGtri0lzFpekayEXVJXSvW02m7A9v98f87qSWAzEisS5ublC6Tfpt1laWoqqqiqwLIvBwUFJz06lbZJ/y5PB5WNIpEw5EUfudIqB051MT6FQKJS5A8uxOPf+r8J93BH4z+1/RR4MuMhQgLCBRxA8tv66Ede2f4Q//uWXMBqN6R5uXOSl0Ymk9ipByrfVejCO8zx6gkFFYUbsGHNNVn7sGR+XuMzIfcVyux0Pl5bOuIsOSF/vRgOAt6qqwAM43e1OKqF5pokAaA0EkpqzEM9jWyCgKDoaALhsNuwZH0cgHFbszxgBsGVwUFEAbPL50D8RGznEIrn+jcm8j6hDcmagwiOFQkkYY1YGLn/mVvzzx39C19/eRCaiDq5MsFhtXITffv1+bO/YiVt+8r059UtzupiKoELWJeWwmzdvjgmoURKH5GIkQZxuDEDidJOLgyaTCZ2dnYoCXmlpaUyp9ejoqOpxxHMRJoI8Pbu9vR3l5eWoqalBX1+fINA2NjbGCKZWqxU2mw0DAwOKIl8gEIDFYpE4IY866iiccMIJaGhoUC1DN5lMYBgGubm5qJy88amrq0NjYyMGBgaQm5uLuro6uN1uiUBKErGVemUq9eAEoueb53m0tbWpzmsizsREHLkUCoVCocwk1dfXIe/oIjRctwGmYAgAg0wAp7O5aHunB2efcgme3fwX5ObmpHuomiiVRieS2itHXL6tFSIiF2aUHGMMw2g6xr5WWIg/e71pCStJByEA3+vuxp7xcdTabOgbH8euaSonTyXx3Irs5DLyHos8gFEVAXuewYD/TN4Hyq8dMWoC4Ppdu4T9iuEB1f6NWkJhou8jPQ5JKkymBpoIQaFQkoJhWZx17/X43Fs/x8qnbsbyO65BhGNhA4d6owPbf/c6Pn/ZVxRLYCmph5TD9vT0oLm5GW63W3iNJEUTp6Pb7UZlZWVMn0QxHR0dMWXVchErGAzGiI5msxkulwtVVVUxy+sRF+VCtdVqTVi8lo+JuDkZhkF9fT1cLhcMBoNiSbnNZkN9fT3Ky9XbBcjLr4kwqNRfUjyG8fFxwYEJRM9LQUEB8vLy4HQ60draio6ODsl6Xq9X0Z1otVpRX18vHI/4WFiWRW1tLRYuXKg4FpKerRfSD7KwsBAulwuVlZVobm5GQ0ND3OOmUCgUCmW6WfSZCnyh5ddY+dTNqHtsLTKPWAADGNTAilqvGWfXrMJHH828Iy8RKiwWyGs/pprau9xux39cLrxTXY3P5uSg0GSCWeGeSizMKDnGSE9ILfaoVGQcqrzn96MnGMR7fj92BYNzQlSZ0Cj7ZgCcm5ODR0pLE9qmLxRC0bvvom7y3vbNqiqck5OjOB9KAmD78LCiIDrfYFDt37iitRVbBgfREwxiy+AgVrS2osnnA5D4+yje9R5vfxT9UMcjhUKZEvOOdGLekU4UnHwsCk9dik0X3Qbz0ChOY3Ow7b29OOuki/Dsq08gL2/upXNphWrMNuTi1M6dO8HzvODwI30UgYN9+rSOZXx8XLWsV6vP4dKlSwEAmzZtUnT/ydeVJzYbjUaYzWYA0SRmr9erqyRaD/I5UipJ9ng8aGlpQU1NTUzisxo8zysG0cQbh7ivpZL7lIxR6fWJiYm416L8dbPZjPLyclRWVgo9Pnmel7gmlbYpdzWKU7f1JllTKBQKhTKdmO0WFJx8LADgqlPL8eL198P7ZjtKkQFr2ImrzrgOdz22Huedd0aaR6qMPNk6lam94p56dW1t2DI4KHGFiYWZZJ2XWj0lZyvFZjP+Nz6eknCa2f4T7LFZWfhoZES11Pq8nBzB8ZpIOfYEouFBnmAQrwwOIs9oRK3ViuNtNklgDKAsACpdNxyA2smWQ3K0SqnXFRcLydjibWm9j+Jd76lugXA4Mzu/QVMolDlJbmkhrn3nfmQd5QAHBlWw4MR9WTjXtQrbt+9M9/ASRstFONuQl86S3olk7F2y3jterxf5+fmS55xOpyD6EZR6Lyo9Z7FY4HQ60dXVhebmZlXBTiw6Op1OVFVVSV4PBoPw+/3w+/3o6urS1TtSL5FIROLSq6ioUExhJ67DsrKyhLav191LxiF3N8ohzsTq6uoYUTM3N76QL78mysvL4XK5BIdmb28vPB5Pwtd3MknWFAqFQqHMFJzZiFV/+SEqvn4BeABOGLHasBj3XHs7fnH/b9M9PEVIafQ5k87Ec3Jy8FZVVdKp1mqsKy4GwzCCK4xFVEzZGgigrq0NRWZzUs5L+XZTyXQIFgyAfJMJ7GHQEurHZjP2BYOaguKqvDw0+Xw4Pc69oNr5JcJr/8QEtgwOYuvk9wCyvJoAKL9u4gmFcjETgCSMaavs+0etzab5PornkEx1C4TDGSo8UiiUlJKRY8PnX/0pCs6pBgMGJcjAykgBrjvri3jxxVfTPbyESKfAEolEEipnra6uFgJJ9KDU48/v98cIWkrluvLAFSB6k+DxeDQdgvKS6YGBATAMg5qaGhQWFsaMP1VOR4JcZHvllVcUxcJgMIjm5mYh5EUutKo1qVcSMcXYbDY4nU5hHPGESpZlhT+XX365IAw7nU7U1dVJllW6XuQl0uJen0rovb7l1850JllTKBQKhZIMDMNg+Y2fw5m/ugERlsE8cFhlLMDb9z2L67/wXYRCoXQPMQbiTNxzyilorKxMuehI9kEEzrzJpGEWiQtGSrisVhgYBmaGgZ3jpiQ0cABOtNlQaDIJJcCpjAjiAXzg98NltcIyS6uZUsVD4+PwaVzvLIDn+/uxtrtb07F6xYIFqLXZ4p4Hso1amy2ukJ6I4N7k82G/wnGQsyfvLckhmqat9T6KJ3xORwsEJZp8PtR3dKAuEEB9R8chWcpNS60pFErK4UwGXPjH7+G9+/8B9y+egwNGrDYuxi/+7x7s+E4nfvCjr8+J0BmtUA0tUlGiTdyWgL5yVpZlUVZWphhCAhwsWyZBJpWVldi8ebNkmUAggEAgIAktUQphkSdTk3XjkZWVJemPOD4+LvRezM/Ph8Vi0VXabDKZkJubi+HhYQQCgRghlOM4ZGZmwmazYf/+/YoCn9frxb59+1T30TrZaJrgdDqF1Gql43c6nXA6nZJgGCDai9FutwvXQWNjY9zjI0QiEfz9738HEA3rqa+vF64jIjR6PB4MDQ1hdHRUcJP29PSA53nU1tYqXjNKJebkeT3XrlJY0VxqS0ChUCiUw4ejV52CnCUOPHPZemSOBHEmNx8tr32Cz55+Of7x8mOw27PTPcQZhwic8rJrUuJda7Mhx2A46B5jGNw5WcqqFKohD+jgAATCYTCT/w7jYHAJ+Zs8r0atzYZrHQ680N8vuMtqbDZ84PenrKw5AqQ0EIcFYOM4xWTndBLvDj2CqINPKV2awAD4zLx5eKqrS1c5fRjRvp//idOKRym4RU0oXL9rV0zwDRk/GCYpZyIRPsVjuEU0hulsgUCQv39eGxzE6woJ4HMdKjxSKJRpgWEYnLR2NfKOXYxXv/YQ7BEOFxqdeOfBBnyh4yP8/tEHVJ1jswUlgUUPiYqGSiTjthSPl5RRi3s8EvHQ4/Fg06ZNqj0JWZZFfX298Li+vl4QlXw+X9JOxOzsbBxzzDHo6OiQ9I/keR5er1fzejCZTIKAGAwGNecjHA4LIqpSWTgAIWhHDbmYGQgEYLPZVIVRlmVRVVUFj8eDvXv3guM4Iama4zi43W40NjbGOFcdDocgxpaUlAAAuru7hSAaAhFoSSJ5vP6TXV1dqK2tVXyNXCdKPR71XLtKSda07yOFQqFQZisLlx2Jq9/egKcuug3Ysx+1sCL7f2M4s+ZCbNz8GEpKlqR7iDNOk8+HNw4cUBRr9oyPY0NJiUQM2TI4iC2Dg6i12bBnfBzlFgsuC4VQBZU+eDgoYBJBZ1VeHp6fFBIrLBYMhkKKpbNA1I34nt8vCJXeORBWGQHgC4fxuQUL8KTGj9uzkUA4jHGN8BkWwE8+/VR3D089rkA9idJi1IJoSF9Jrd6lZH9K6dTiHqjy8a3ftQvzyHcJhkGt1SoRJlPB4dJHkgqPFAplWik5/wTMa1yPpy+5AxnD41jB5aL1rd04Z/mleHbzX5CTMy/dQ1RFSWDRg5pomIgrTO5Ky8/PFxxuPM9j2bJlYBgmZntq433ppZckj0kfRY7jEIlEJEIbcXbKx1tXV4eGhoakhceCggJhfErOTLkoJ3Ze7ty5MyUJ6SaTCfPnz4fH49EMyZHj9/sxMjKi+rrD4RACW4Co+DkwMCAkWMudkISCggKJQKjVH5Mkkqu5WvWidV0n216A9n2kUCgUymzGkp+Dq//5czx/3c+x790dOAaZsAUdWPOZq/Dzv96LM888Nd1DnDGI4BNSEJqIWKMkhgAHHYLeYBCvASj1+VT74Ck53r5aWBgzDk5WIgsc7BlI/iZi5mx0FMqZa6IjgLhzGgYwoLM9gV5XYKKCm2oQjdUa15mYqMip5OJlGEbTkZksh0sfSVoHRaFQpp28447Ate/cj4wjFsAABi5YUeMx4eyalejs/Djdw0s5aj3wEgmrkffnAyAJBGlra4vZXkNDA7Zu3arYF1KpLyMQFcjIazabTdILUL79jRs3Yv/+/ZL1TSYTCgsLUVNTg5qaGsU+kxzHoaqqCjzPo6GhAZFIRNFtyfM8nE6ncMz19fVCL8PR0VHVudIiMzNT0htx6dKl8Hg86O3tjREyrVarZjK1XKRkWRY2mw01NTWorq7G9u3bJa8Hg0G0tLRohsh0dXVJzpeWYBfPpSmGuCcTJdn+jbTvI4VCoVBmO4ZMEy558iYc+6VzAQCFk6Ezt19xMx55+LH0Dm4GIYKPEkSsURJDxIQRLXm9e/fupPvgifv76RElwogvkFG0sXMc8gyGhPtlcgByDfE9a3lGo+5gpEQFN61+jPF6RSqJnPykyKlEostPhZnqI5luqOORQqHMCJl5dlz12r146foH4H2rHWXIgDXkxJWnXYO7/3IXzj13RbqHGBe9jkW1Eu1EXGFyV1pDQ0PMuvI+mR6PR3Dcyctd9fTby87OluxTPj41J97Q0BCGhoZUxa5wOIy+vr6YscmJRCLweDxwuVzCOD744ANFgdZisWBsbCyuY7GsrExwFEYiEWzcuDFmGYPBgAULFoBlWUmJOhmPGnKHqdpYtJyaxHlK+jLKXZ8mkwlmsxmlpaVCKbR8/kg5uXj/enqoKl3PybYXSHY9CoVCoVBmEoZhcPpt12DhccV44/u/Qw7PYZWpEK+s/zs62nbgwYfvVm3TcqigJiqaGQb/nBRrlNxlciIA3jxwADaOi+nfqLcPnrjf5KuDgynr3zhbYQEcb7OltLdkIgTCYbxVXY0127ejR2clETmfdy5Zgm+o9Hg80WbD/SUlCbkB1RyMaoJbvH6MaiXTQOIi50y6EGeij+RsgAqPFAplxjBkmLDq8R+i6e4n0fGbBhRMhs7cfc1t+OjHn8e3vv1/6R6iJnp7N6qVsiYbVgNES63lpdcsy6qKeIBUOJTvW9wzUbzN5uZmQTyS71OJYDAobEfLwTkwMKC5Hfm4iSjW2tqquMxwnA9+UlLd19eH5uZmQbRTEk9DoZBEFCViX0lJCRwOB7Zv3y6ZK47jsHDhQlRWVkrEu4yMjLjjYhgGDocDDMMIoiOhq6tL8pgE1vT19QlCYnV1teB6JVRVVcHr9UrOVV9fn+L+xeMVC6vi6zmZ9gLJtiWgUCgUCmW68TX5sGv9Lgy3D8NSYUHxumIce/lpyClx4tk1dyNrbAJnc3nY2rAD9Wd9Dk+/9Bis1kPLbSRGTfA5Y9481VANNcZ5HuOhkCA6kn57ifbBW1dcjFcGB5M4mrlFBMCpdnvahEcg6ubTIywDUaH0nJwc4XxWWK1Y292N1kAAEQBZLAsjwyBnMiFdjlpfxSafD4OhUMw1GE9w0xIXtUhU5Ex0+alABNU7d+1Cy4EDqJk3Dz+ZhpLudEOFRwqFMqMwDINTb74CC45bjNe/8xvMi3BYZSzAG/f+A+1tH+KR3/0cBh1W/nQw1T52el1hSk40te3JRSgxYmFTvu/Kykq0traiq6sLQDQ1GYBEWLVarZI0ZwLpvTg0NKQrhRoAcnNzNd2D8nHHK0WPB+njCBwU1fSeLyKmut1uRYE2HA4L5e6AtF8lWd5kMsFkMknSpgEIIT8ulwtOp1OzX2MgEBB6Q4qFQXHYD7k+WlpaYoRpJbR6ROqdH5pgTaFQKJS5gq/Jh9YV0V5tCANBbxAHXjuAqjer4Fheiqvfvg8bV94KeA/gRMaGjz4ewxk1F+Afrz2BxYsL4+9gDqLHYSV3lxWZzULKtZJYRZyOpN/enQpikxpNPh/Wdnen8AhnNxv27FFMZ54JiGtv49KluoTlXINBIvQtt9vxH5dL6IEYCIeF8CF5z0SyTITnEQHQEwzilcFBrC0qwi8nK33E1CbhmtRLoq7CmXYhLrfb0VBejtbWVlSVlx+SruvZ+e2eQqEc8hx98XLkHOnEM5etR+ZoEGdx89H86sc4ruhkgGOw+MhF+POTv0JhoTPdQxWYimMR0O8Kkzsre3t7Y0pnt2/fDpZlUVdXh8cffxwTExOS/YjLZtX2XVtbKwk2kZdzk2TompoaMAwjBNuQcBmLxRJXeCT9HSsrK9HW1iYkbnd2dkpCajiOQ1ZWllBS/Je//CXuPKlhMplielF2dnYmtS2tMunOzs6Y18XJ2yaTSbX82uv1Cv0riYDH87xqCA1ZDkjeXRiJRDTnQU2slG+joaFBtaSfQqFQKJTZxK71uwTREQAQBniOx671u1DZWAmrcz6uees+PHfVvdj/QReOQyZsowuw8vjVGDGEkZGZgZ/c8wOsvuzCtB5HKolXsipeTiw6id1r/RMTMSnIYQCvT6Zfk8d6QzyUgm60IA5L8vdcIx2iIxCdrwqLRXINbA0E0C/6HiFmIBRCXVtbjHisJxhm/a5dgugoZsOePTHnjQOQYzBMm8tP7zWf7PKU+FDhkUKhpI2FlUfi6n9twFOrbgV6BnA8Y8MSUxYiAA7smsAFJ6zG7577NY4/virdQwWQWB+7qbjC5M4zj8cDp1MqwAaDQSFsZv78+ZJ18vPzkxKC5MIqoa+vDw6HI6Y02O/3w2q1aqZccxwnjEU8JoZhJM67qqoqXf0S9aAkFup1ZiZCvG1qBeI4HI4YATESiYBhGFUhUl4KL76m5KXVSqXWaqXmiSBO7iZ0dnZS1yOFQqFQZiXD7cOxFr3w5POTGLMysPrpW/DGusfQ+fg/sQgmXGEqxijDYyIYwe+++Qt0tH+EW2//vq4eyrMBtRJXQjIlq+J1PtvWhi0KPRnl8lUYAMPzWOF2IwSAAXBsZiZ+d8wxWG63Y213d8KiIwCwDIPvFRbiMa8XA5Ol3voyl2cvHJTdpKkkAmBVXh4A6fk8qblZsfw7gqibccvgIGptNuwZH0eFxYKtgUDcHohb/X5VUVj+/EykOCd6zSdb1k1RhgqPFAolrVjyc3D1G/fhuWt/hv5/f4SFfPS/JQcMyGMX4VsXfhPfuv+7uOLKS9I80sScZlr9IOOJkkoCINl3e3u7RFjzeDwxN8HJCkBESO3s7JQIVOFwWLU8NxgMCqXXSmEsJpNJc19qIm5eXl6MeMZxXIwgSVK01QQ1lmVhMBgkcxZvHTJu8Trk+NQeMwwTUzIiHy+ZJzXRWo8QqXZN6XHjxiulVusLGW8bfr8fbrebuh4pFAqFMuuwVFgQ9AYhb9ZmqZD2amNYFmfe/UUsOO4IvHPTo7DzHOyTH+sLjQ68+8c3cEXHTvz577+G2WyesfHHExCVXgeAFa2tgiMtnuswGW5atAiv6ezJyOOgKMgD+HB0FKe53fhVaWnSvQ7LMjLwwJ49AKIiFoOom8/EMBhLQshUgrjyZqos2spx057azQJ4vr8fXy2UthHYUFKC091uReGTPEfOFel9qORaJD0Qm3w+7A/pl4KJE5Ny6EKFRwqFknYMmSZcuvFm7Hz6X9i3/b8IeAewq+ED5MGAS42L8Je1D+O1LW/i4kvPhdPpnBPuKqV+kMStphbqQVDq3UjEKqWejnLBK9EScAIRvkgQCxG8tMpzg8EgPB4PampqUFNTIynDBaKp0lr7IiJsY2OjRJBTchRkZWXFiIVlZWXCeOWiLIAY0ZGs4/V6VYVHq9WKyy+/HI2NjRgYGEBubi78fr/E2SnfrsPhkBy33AnqcDiEoBg5akK0nmRzgh43rpqjVTyOeKhtI9F+pxQKhUKhzATF64px4LUD4LnJcmsueo9RfEux4vIVV50FZ3UJdj7bhNBYEB89/S+Yh8dxGpuDbR/046wTL8KzW57AggXzp33spAxZTUBUe91ltcYtg5XvR0vcVGK53Y7fZmbi62NjMSXXeogA+Mmnnya8HuFDWVUJOdZUio7n5uRgVV4ebvzkk2kXBAHMyD4ikDoLyblXcjCqoSQ6EkgPxPW7diUk2PKidSmHJlR4pFAoswKGYXDMZafhmMuij//3VjsavvBzWCeAzxry8d6rH+PO1l/gmuujzkc97qp0hmDIBZpIJKI71INlWcUAEaUyVzk2mw2VlZWqJbl6ID0iyf7Hx8clrxNRUCx4dnV1oba2FnV1dRLBrqqqSnNfSv0s5WE2BBKA09XVhfHxcZjNZmEMLpcLHR0dMeuYzeYYtyPP8xgaGlIdU3Z2Ntra2oS59ng8Mc5Ns9mMiooKYY4rKiqwefNm4bgBSITH4eFhSVAMz/NCf029aelK1xQRC/Vc59XV1eB5XggUikQikhRuPeVjaq7YZMVuCoVCoVCmE/tyO6rerJKmWt9SDPsp6sJa3tIjkLf0CADAiWtXY9Olt2O4y4MqWJC934Bza1bh8cY/oLz8mGkde7w+emqvt+oogyXEEze1qDIYsGLePLw2OJhUiXA8RxwRrma6jyOHaJIzEWm/cwgF38hdieJznwhK54PHQaGxfXg4oXM2fxr7O1JmB1R4pFAos5LFp1fgitd/hqdW3Qrz4DCWs/Ng7x/BIz9/HPPuykkqpAWYuRAMuQNNSzBUEm2UyrrlAqVS6XFZWRna2tqmfNxa6cdVVVXYvn27Yi9FuWDX1tYWUz7c0tIiiF9yt6baPFmtVtTU1AjL+P1+BINBtLS0wOPxoL6+PiY522q1orS0VNIn0Wq1Sh7bbDZYrVbJek6nM66Dz2q1So6rublZctzynpxy8ZYItYD+tHS549Xj8QjJ33rON8uykkCh5uZmyTmWj1kJNVcsud5p4jWFQqFQZhv25XZUNibXqy0jx4orN9+DxhsexJ5XWnAUMmBFEb549pdw829vwapVn03xaA/SPjysKSCqvW5AbL9AseAkRk9IiBqtoRAGkXxfQjU3nJ3jYOU4VFgsWJWXh8e83qRLspNlrrnv8oxGHJWRoTlPLKTJzPJzP1UiANZ2d+M/LhcqLBb0aAQ0iuEQTbSmHNpQ4ZFCocxa5i1x4Np/3Y/H628C/rsfy5AFW7gIP/vBg1i6tAJVVeWa6+sVdKYDuXBIgmAI8fr9KSF3vC1cuBCBQADj4+MwmUxC2XFjY6NkPa3jVhOK5OuYTCbk5eXB6XSC5/kY0ZG4EePNudvt1kxujoeS69Pj8aClpSXGbVlXVweWZSV9EuXrZmdn47zzzpOsVzl5oy2ea3nPR7k7UH6cDMPA6XQKfyslYBP0pqWT8mut/ao9p0QiYUlKY1ESN9Mp9lMoFAqFMh1wRgPqf/ddvP/LZ9Gy4Rnkw4DVxsV46Cs/w47tnfjRj785LaEzFRaL0E9PGAsOCohqr1dZrWgOBMBNikocpIITcLDE9lWFgBg9QR9NPh++ohKiN1WH4svLlkncb8/3909ha4kTBnCq2w0Dw6DGasVRGRkxpd1TYTocnEdlZCDHYNAMqIkAOCYjQ+JKTHVxd+tktc+64mJsHhyMEZfJu4QFYq5NvSX/Wssl0zaAMjNQ4ZFCocxqzHYLrvvnfdh4zd3wN3XhSJhxKXcEvnLeV/DDh3+MSy+9QHVdvYLOTKAk8iTqBBOXyspdehUVFQkFjRCUhKLq6uqYfn8kRMblcsX0GrTZbIIbMd6+lUQxm82G7OxsxXAaQiAQkDgl5XR1daGmpgYFBQWCoKvUJ3Hr1q0SATg/Pz/GpdnY2CgIhmRb8oRp4g4kwq28dNvhcIBhGFRVVYFhGPT09EhKk4lQC0ivjfz8fPA8j4aGBl3BQ2R+k7nOEwlL0ks6xX4KhUKhUKYLhmFw4ncuwfyjF+HVrz2I7DCHC4wONP26Eddu24E/Pv4gjEZjSve5rrgYrx04oCogqr1+f0kJeEAiwNxSXCyIeeISWyUBTM0dKeYHn3yiKFoZGQZ2jsMEzyfVszDPaIwpuZ3utGMleAATPI/3/H6wSJ1YyCKayP3rkhJ8p7s7qf6YaugREj8cHcWK1la8WVWVkCtRL+M8j7q2NqzMy8OxWVn4cGREeI0c+0MlJXi+v19ybfLQF4ik1RoAOrdBSQ9UeKRQKLMeg8mIzz95Kz741fPYeu8mLIQBq02L8duv34/tHTtxy0++p/hL81QcXakmFSIP6b3IMEyMQJdo0IjSekC0d5+8f5/4Na/XG1PebRHdnMbbd35+vmI4icPhQGVlJdra2lT339XVpZlErSaiih2d8tJucc9DgnhuXS6XEIJDxkDWI6KjuFyZ4zhkZmZK9kP2T3A6nYJQC0ivDXH5s1rwEKA8v7PhOp9NYj+FQqFQKKmmpO54zHvlLvzj4juQERjD6Wwu2pp6cfYpl+DZzX9Bbm5Oyva13G7Hm1VVqgJivNfVSqW1SmyV3JFymnw+vC/qYy1mgufRHwqBQ7RkOlHxsdZqjXlOydmZCFMVDSMAjpOJaMli4zjB0fl8fz+2JNkfU87Ho6M4KjNTl5DIT5bSrysuxisayeTJzturg4N4ZXAQcnvF8TYb7i8pwSl2e0yqdl1bm66Sf63WAOTYkmkbQJl+qPBIoVDmDMd/YxUWHLMYL1//AGxhoN7owLu/ex1XbvsIf/77r2MCQKbD0TVbcDgcEueeWOBJ5LjlQpGWsOf3+xVf93q9cLvdcLlcMfuORCLYunWrINhlZWUpbpeIbaR/YEtLCzo6OiTlyfI+iWJKS0sV3XZyMdIm6yHT3d2tecxkm6Rkmyzb0tIilHCLCYfDCAQCcLvdwjnZvn27ZBmlkmn5/tQeq51btfM90z0XZ5PYr4TSfFAoFAqFEg9fk08SUHPR/bfhlXvux+ine1EDK7K94zi7ZhX+vvlPOProkpTtd7ndrimaxHtdCTVnHItoqIpYvFSCiDxakO1rlf7KYaDcW1Hu7EyUXIMBg6HQlAS+j0dHEzoWNXzhsFB+vK64GFs0hL/pgpTSL7fbcaLNFtMXUtxzMZnemhHZ32SbORoBMvH6mepdTm+okl4SLd2mpd7q0I7vFAplTlF8djU+t+UeMNmZMIPFaWwOst/fhzNPvAj9/QPpHt6MUVlZCZfLhcLCQkGs04Kkajc0NKC5uVlw8FVXVwvbkYtyBJvNFiPqyuno6JBsl0B6OhLRsq+vT3UbXq9XEIa6urpieiJq9UisqamJcdcNDQ2hs7NTc9wjsl+v5ccp3qaSKCg/XjEDAwNoaWmJEUzFadRy5McwVccgEV57enrQ3NwshNFMF0QYra+vF4To2cRMzweFQqFQ5j6+Jh9aV7RicMsggj1BDG4ZxEcrP8aFd9wEx5nLwIBBKTJwYdiJz6+4Fo2Nr6d7yJpUWCzgZM9xiDrSAODy7dtR19aGJp9PcX29Qs5IJAKGYWIEB/JYXqu0tqgId+7ahaJ335Xsnzg7z8nJgTmJXpp3LlkChmFijjlRUtUPkQi3y+32lIWq7A+FdIuE4lL6DSUlMIjmhrgcPx4dxcejoykTi+IJgGrXpLzkX2s5vdvQCynr3jI4iJ5gEFsGB7GitVX1fZHo8ocbs+sbAYVCoeggt7QQ175zP7KOcoADgypYcFJ/Fs6pWYnt23eme3gzQqICj5rgIt6OVVbeYjKZ4HK5sGbNGpjNZs3tj4+PKwo5ifT4czgcwjjVXIgmkymmrH5gYAAsy6KyshJOpxMcF73tUHJolpaWwuVyCSKrvGx8/vz5sNlsQt9KsaCrJApqNZOXb5tA0qiVxGCxEKxHUI4H7bkohc4HhUKhUBJl1/poeae4hpPneey+twerHvsBln3jQvAAnDBitWExfv6FO3H/hkfSOWRN1hUXS4Q48vdWv1+XaKIk8CjC83BZrTAyDIyIll7nGY04NycHj5SW4rycHBSaTPjs5ONf9PSo7p84O/MS7KNp5zh8tbAQb1ZVodZmg5lhYgTPeHAAjsrMTHAtdd44cEAQVz9OUWiN3k6R8lJ6saibZzQigqgg3B8KoT8U0iy1Nk7+0QMLbQFQ6ZpUKvnXWk7tuh4MhWLEbD0olXXzorLuqS5/uEGFRwqFMifJyLHh86/+FIXnVoMBgxJkYBVfiC+c9UW8+OKr6R7erEOP4CIXL/Py8gAAL7/8coxrz2q1wmazCSIfwePxSMS0/Pz8mP04nU7YbDZYrVY4nU6JyBZPCDKbzTHjJAIfCYlRE/xIb0WXy4Xs7OyY7TqdTng8Holg6Xa7hWNRcpmSkBkltMRgr9eLlpYWiRjc0tIiCMF1dXUAgMbGRjQ3NyMUCik6VuORagflXIfOB4VCoVASZbh9WLGGc7h9GAzD4JQfrcFZv/46IiyDeeBwobEA72x4AV+69jsIhUJpGbMWYrGp0GRCrc0GK8chDOgSTdYVF4NBfCFhAlExc3wyxGY4EsFz5eVorKzEVwsLsa64GBUWC9qHh3HLp58iokO00S16To7vZNH9HhlLPJGOm1zXyDA40WbD29XVsHFT9UseZJzn0RMMYvPgIPpn6PowMwwKTSack5ODt6qqJEFDpDQYPK+7ryOL6Pmd0Ln/CIBVk98rlJBfk/Jx6llO6boGouc9GQei3vLvZJc/3KA9HikUypyFMxlwwR++h/ce+AfcDzwHB4y41LgYv/i/n+LDb+/ED2/8hqYj7XBCKfRD3u9OHvzC87wkOEVMdnY2LrjgAkkYinydnp4e1NTUoKamRujxWFpaipqaGokoR8bR2NgYV1ArLS1Fb2+vRKBcsGABgPjuNXFvRfl8lJeXx6zf1tYmiJhKQS9AtOS9t7cXAwMD4HleUg5uMpmQkZGh6N50OBwxZeBdXV1C30hxwndPTw96e3slj5XGokQiidmHA0o9KOWBQxQKhUKhiLFUWBD0BqXiIxd9nlC28mTMW+LAM6vvROZIEGdyuWj556c477TL8Ezjn2G3Z8duOI0QByEpDw0pfBaqiSbL7Xa8vmwZbty+Hf/lOCwym/GB3x8jWLGQCpnioA95OrESYUTdgU0+n9Anj/R7RJzPbrljbm13d9xS6TyDAc9XVCj2Idyj0Wc8WWby7mPFvHl4RdYLVM85UCPR0BkWwPP9/TGhMmL09ivVWk78Wl1bGwD1azAeSqFGWqXbiS5/uEGFRwqFMqdhGAYnfW818o5ZjFe/9hDsEQ4XGh1456GXcV37R/jDn38BY4JlGYcicsGlsrISDQ0NEjGLuAHJMlpCHnH6ybcrX6evrw/19fWora1V3ZY8GdpqtUqCXAik/+JnP/tZbN68GQMDA8jNzRXcgXIxkWEYiahEeiuSdHDxuEn6tXh9uXNSaT6Iy1IJlmVRWlqKlpYWyfM2mw3V1dUxwiMpV1diYEDav1RviXAiidlKzHQ4zXSjFM6j5pClUCgUCgUAitcV48BrB8Bzk+XWXPQeo/iWYslyCyuW4Jp/3Y+Nq24F9uxHLayw7x7DmTUXYuPmx1BSsiQt4xcjD78YDIVUf4DTEk2W2+14KCsLVVVV4DguZrtbAwH0T0j9cGIhUytZW8w4z2NFayverKrCcpGrbW13t2ZPw1pRgjIAtKqkcANRUYxBtJz68u3bUWGxYGVeHv7s9QrrZbDslNOx08nNixfHPKf3HKSCCGbe+TdVB6I81Che4nuiyx9uUOGRQqEcEpScfwLmvXIXnr7kdmQExrGCy0Xrv/bg7OWX4NlX/oLc3JyYdQ41UUULueDS3NwcI5gRkVC8jFiIIzidTtXeg3LXpFYpK5n/jo4OyfOBQEAx6CYYDApp0hdeeGHM62RMnZ2d8Pv9MTfSHo9HkkbtcDhQV1cnnHOyfkdHh2KCttKxaAmAFosFlZWV8Hg8krkuKytTFCW1yrFyc3Ml20imRDiZ/obyVHBAn9OSQqFQKJRDBftyO6rerJKkWhffUgz7KbHOuKyF83D1P3+OF75wH/Y2fYijkQlb0IE1n7kKP//rvTjzzFPTcARR5A43uTtLTiKiidyFVtfWhi2Dg6ruL7VkbSVIyfW64mKJuKmVMk0SlIkgOq7hkIwgKj5u9fsRBuAJBvGKLG16XPYjJYOZdSxOhXKWxSnZsY7bRM5BoshFWjUReyop0PHWnaoDkYjc4n1oJb4nuvzhBhUeKRTKIUPu0UWo+tV1aPnBEzDsG4YLVmR7xnF2zUr8ffOjOProEsnyh7OooiQ6ycUsIsR5PB7wPA+WZWMEWvkcyl2TlZWVaG5uVhR35U7HqYxdLCJr0dXVJTgp5edc7g4k2Gw2lJWVKYqtcpelHJZlUV9fHyNwA0BVVRU8Hg/27t2LcDgcU2budDqFOa+srERbW5tkG4kK50rl9vGgYSwUCoVCoUTFx8rG+OWZAGDINOHiv/8Yb9/xBHb8YTMKJkNnbr/iZuy89Qv42g3XTe9gVVAKv1CDhMHcOSn46RWDCEruL+Bg0Md4JBIjTrGIinlyQS+MqCiYiGjaPjwsEVrjEVH5txo8YsW12QIZF4eoQPrdjAzF5ZSEuVRwXFYWOkdHwcRx/ikJ4a8dOCC4W7XQs24qHIh6y7+TXf5wggqPFArlkMHtdmPbxzvAXV+N4MYOGD85gDJkwBYuwOdPvxZ3/+UunHvuCmH52S6qKAlLqUIuQim5GJXKUuWolVYT5OW9vb29gpimVqIMACUlJfB6vRgYGIDRaERAVCKjJJhNVcQUz3V+fj5qamrQ19cXV9ATl2zv27dP0uORlEerzaNamTbHcVi4cCEYhpHsn5SDe71euN1u8DwvOCb1COdK5eXxSEaspFAoFApltuFr8kkdi+uKYV8+fU4khmFw+q1XY+FxR+DNtb9DDs9hlakQr6z/O7a1fYhfPXxPTEDfdKPlcCPuQSJahRFNNt4yOKhbDBIjd38Vmc3Y6vcLrkKyH4lIxjBwWa0x/SLJHZhe0RSIimrTXUo820THpupq8IDEcXfT4sXI+uQTxeWJMMdOhv8kggGAUp0OA+D3Rx8dMw4l55+SEK63B6OedakDcXZBhUcKhXLIQEQkxsDCdGUFMj/Yh+HNH8EJI1YbF+Pua27DjhuvxLe/82UAs19UUXJkVlVV6VpXLlrKHXOVkx/KiZaZk+329vbC7/djdHRU8rp8DuXCpLinpDwRWuzw43leWHZ8fFzymlgwUyvXttlsyM7OFlK1iYgoFuvE41VybpKelW63O2Z+5PNbV1eHjRs3SoRHrfnzer0YGhpSXCYcDgvH3tvbi97eXsE1KR6jvBxdT7iOWJiMRCKqblRCMmIlhUKhUCizCV+TD60rJp1vYSDoDeLAawdQ9WbVtIqPAHDsZach5ygnnl1zN7LGJnA2l4fmho9w/plr8PRLj8Fms07r/sWolZ7W2mzIMRjQPjyM8UgEA6GQIEQlGsghRivoIyL6mwVwdFYWfn/00WgLBGJ6N0YAjEUiugVEDsAtxcW4fPv2GelfOBv4QVGRIKiJz1M4HEaryjpEmLuovT3hdG01oXL+ZIm7fBxNPh/q2tokZdFT6cGoZ12lUmwqOqYPKjxSKLOAQ6HX4Gw4BrGQyDAMln6tDtYLzsDr3/4N5kU4rDIW4K2fPYOObTvwyO9+PutFlak4MuUiVbKpyFrbFWMymVBRUSHMIbke1MQ1INrL0Wq1IhgMwmw2A4BQDiM/VpZlUVdXJ6RfiwNhlMZTVlYWI7KR61NJxJTvT6kku7q6Gi0tLejq6sL4+LggMvb09IDn+Ziejbm5ubrnTwuPx4ONGzfGXS4R4TwSicSECwGx14Qe1yuFQqFQKLOZXet3CaIjACAM8ByPXet36S6fngqOmlJc/fZ90dAZzwGcwNjw0SdjONN1IZ7e8jiOOKJo2scAqJeeikNYit59N0ZUUhKDmnw+3Dgygv++9x6WqfTmEws//RMTqiJgBMCHIyNoCwTwQn9/TAkzAyAQiZW6WADHT/4IS0JgqqxW4XgqLBb0xPlBeK5jYVkckZGBv+3di/bhYcXz0BoK4eaODnQo9EJcbrfDnOD3NQ7RHpqDoZCiiC1HrSzaZbUm3YMxXv/GqZRxy8eebA9KihQqPFIos4BDodfgbDgGJSGRdbHIOdKJZy5bj8yRIM7k5qN5yyeoW7EGTzc8OqvneSqOTLmQlmgqspqQrLYewzCSuZQLbDabDVarVVJaLE6tDgaDwuPe3t4YN6TD4VC8xuTjMZvNQhDL1q1bAUTdjpFIRLJvl8slGW+8Xo3E+ShPqCZ0dXWhtLRUcCGWlJSAYRgA2i5H4syUj0+OPOEbAEpLS4WgnIULF6KnpwcdHR1C0rfBoP4R73a7Y/bX2dk5p3/8oFAoFApFieH24dja3PDk8zOE1Tkf17x5H5676l7s/6ALxyETttEFuPjky/HgUw/g1FNPnPYxqJWe8og6ErcGAvDJkqiBWDGoyefDWdu2IQIgEg6jT0HUkQs/evjJp5/CzLIxwqdah0YekIimclbm5cWExChxXFYWPhoZmXWl0wQjwwA8D/mZYQEMRyLYOTKiKq41+Xz4yugoMDqqukyR2ZyQQMswDO5csgTf7O7W1T9x/a5diIjKucMAWJ6HPxyOKakn25ALfivz8vBCf7/ksVhEJ9sdDIWEdZMt4yakSrykRKHCI4UyC5jtvQb1MBPHEM9VqebOWrjsSFz99gY8teo2oGc/jocV9v+O4ayaldj46mM46qjilI81FSgJqXoaZAOxQlqiqchqQrKaQCd398nPf3Z2tuBYJAKckphGIOdSfOyNjY0x+5CPR1yi3dvbq7p9+fjkc61Ukq11TY+Pj0uWZxhGEB61XI7EmSl3IKpBhEr59f/iiy8K4/N4PGhsbFRM/iYoHYvf74ff7xccsvX19VR8pFAoFMqcx1JhQdAbhNweZanQl26bKoxZGVj99C14Y91j6Hz8n1gEE1Zzi3HjpT/AF9Z/BV/6v89P+xjk4RdEXImo9PkTi0GE9bt2gQc0y7GT6a84EAohV+NHUznZHKdZOvtCf7/qa2aGQZXViq1+P3bOYtERAMIq50Y8/+RvludxUXs7zCyLCosFA6FQ3HOVCHkGA56vqIg6Sq1WXf0TtwYCMeMnLlcSKESe+3VJCXhAIviRlHHihCUC4IMlJfiz1yspzSchRPM4LukybkIqxEvKQajwSKHMAmZ7r0E9zMQxTMVVacnPwdVv/BzPX/dz7Ht3B45BJmzBfFx+6udx399+hjPOWJ7y8U4VJSE1HNZ3CycX0pRSkbVQE5LJeqTH48TEhOCwE6N0PchTo7VKjvft24ehoSGUlpYKAlt+fr5km/n5+cJ4Ojs74ff74/ZYFI9HjFL/Q+ImFJd1q7kiTSaTZN+kpJv8W75sXl6eJNCHZdkYkU++TSC2hJwgd7TKH8uRnx+GYSSitsfjgdvtntWOYAqFQqHoZ6bDVWYTxeuKceC1A+C5yXJrLvq5V3xL8YyPhWFZnHn3F7FwaTH+9eM/IZc34GJTEZ699TG0b/sQ9//yzhn90Y+IK2rCW65IaCLo6a+nFmRjZhgEeV7RxRhBVHwUw0Dd8egLh9Hk86m6z7REpn9WVeHOXbuEsc9WMhgGYzpNB0B0Dkm/RrXEavm52jM+rro9EjpEHI3ia0FvgvOEQpm8eLzifT3f34/n+/slgl9E9jcRAF/o70eOwSCMUfyaeOzi7esp4yZMpQclJRYqPFIos4DZ3mtQDzNxDFN1VRoyTbjkyZvw9m2PY8efXkUhjFhtWIyffO4mfP62L+CrX7suhaNNL0qiZSIikpqQTLYbb1vxrgfy2OPxgOd5Qfjy+/0IBAIIBoMIBoNoaWmJKeNWOk6v16vpoCTYbDaUlZXFvT6V5o84Tru6ugAAVqsVDMPA6XSqhtaQf4vnMhgMwul0xmxfvpzZbJYIjzabTXXcckdrbm6upkNYLtgqOWnnovOaQqFQKLGkM1xlNmBfbkfVm1VS4fWWYthPSd+xl3/+TOSUFOCFK38KSzCEc7mFeP/ZbVi54/PY+PwfYbFkJbzNZPrRaSVdA4CZZWNcbPH662ktc8a8efjf+Dg+HBlR3J9SmbW856OYtd3d+I/KPWKFxQJPMKi4Lo/4x54qLCyLYQ3xTYt4oqPW3GglmFdYLML10q9SXi8OHUo2EbrJ54NPp2lCLOrFW0Nr2TAATFYe6SkFV0PPdU7RDxUeKZRZwFwNcJjpQJlUuCoZhsHpt1+DvOMW460f/AE5PIeLTYV4+c6/o711Bx58+G5wHJfKYc9Jpioka13T8qCXyspKtLa2oqurC8MKvyISAayvr0/yfFdXF2pqaoSgGK0ejYTs7Oyk3muRSEQIlgH+n70zj4+jrv//c2avJtlN2jRtsk2PtCThaNJc5Wq5DyUEKLeggHgDKiB4/NSCYqugcigonqB+QQQVFSRUKAgo5ZDmalqONEChzVGaJk122ySb3ZnfH5vZ7s7O7JXdJC2f5+OhJXt8Pp85Npl9zev9fgX7K2pzA/j9fnp6eujv7yc/P5/KyspQ0nZNTU1I4NNvUzjxyr3Ly8tNP1/19fWsW7cuNL9W1m7mEE5EsA3/fE2H8CiBQCAQpMZUh6tMB/JW5k27bS0++jAue+F2HjnnZtg1xAopl9ffGuaU5Wfzt2cepLjYHX+QcVLtR2ckrmiYiSyrS0p4Jqz01UjUMQuy0dKmkyGWZPeqx0N9W5uhyLq6pISnDHo8ygSdnrG23YgCq5W5NhuvDw8nvHYgZdExHnkWC3sVBSmBkna9c3FVQYFpD06j0CEz4onda8ddpYkQfr7FOy6xXmsBljudrC4pSagU3IxY57AgeYTwKBBMIhP98j7dvvxPdqBMOl2VSz92ErNLi/n7JT8ge2SM0y0FbGx8g4ZTL+GvT/wep/PDeTdLf47V19en/RyLlbhtRFFREYqioOgu3DweT6gcWDsXNm/ezGiMkhGtl2Iin5/wfaEPf9EEwdraWpqbm9m8eXPIndjT00N7e3uox6Msy5SXl0eUlhuJ5omUe5thtVqjejom4hDWC7ZGid8wPcKjBAKBQJAa0yFcJRNkunx8MsrTXfMLuOI/d/C3S3/AntZ3qSAbl9fK2UddxC/+djdHH12b0Dip9qPTxBVZV25t1NtRY2VeHs8uW8b/27KF9ywWlhmIOmZBNlradDKCXzzWDwwYiqwr8/KYbbWGSo81FOCpgQFumD8/KqDEjAKrlV3HHQcExbbPv/kmbwwPoxIUAGdZrWyLcf2ZCUYUhTqnEwiWS+/0+fAbvM4JrJw1K5RqvaqggJvefRe/gZvSIUmcPHOmoUhnFPhybWdnTLE7VlmyZvPQi3oqRBwXTeA2Err1rw1/bkUCpeCxhNNY57AgeYTwKBBMIhP98j7dvvxPdihOup2hRXVlXP6f23nknO9A7x6Olly8+fYIJ9eexaPPPMjChcVpmytTpFuMNjvH0jlPvMRtDYvFQlVVVai/opE42dzcTHd3N/X19dTV1ZmKmHa7ndmzZ4eeC982v9/PunXr2L17N3a7PRTe0t3dHfOc3rx5M1u3bjV0DIb3eIRI0bywsBBVVeMKoBM93xNxCBsmwRusJV2f9el280QgEAg+DEyXcJV0kuny8cksT7c7s7j4H7fw7Dd+y9uP/IdF2Dlfns9XVl3PNT/6MpddcVHcMVLtRxcurmz0emFcjFrucsUUWVbm5XFPdjbV1dWmlUJmPQCNnGT6dWsOvVilxBGvNxFZl7tcPD0wYFjCfceOHdw4fz4vDg7ymscTc561ixdHbNeWoyNTyDcMDnJiS0tcl146S7tHVZWNHg+SJHF3aSnXjFfl6LFKEo0VFVgslrjrLLDZDI+ZkaM2PPAFjI+DmcicZ7EE07oBJInlTmfE+aYX/FYVFPBYWKp1rNcmKg4m4hJOtI+lID5CeBQIJpFYX94T+UKezJf/yfiCfzCE4jjds7nihdv5+yduo39jJ0eQhWt4DquOvZif/eUuVq44aqqXGJN0i9Fm51g654mXuK1RXV0dEh21smU9Woq1luKsuQz12Gw208/TunXrQvP7fD68Xm/MRGwNrQ+l2TaGYxask8kbCIk4hBMVN9P1WZ9uN08EAoHgw0BUuIoMBMC70UtbfdsBGTST6fLxyS5Ply0yp9/+eeYcsYiXv/MABVg53zafP37jV7S3v8ltP1pteo0DE+tHN9niipmTTIUosenLnZ0JlRKbiaznFBTwL4Nya43f9vSwV1Fiio5HZGdTMe4s1BPumFvucvHmvn1RPQ1l4EiXC4Bmr5exJMJiNMz6RAYAVJUvmoiOAIeHXf/e2NkZt/ejEUaOWogWhfXHQS8ya0KlJxCIcC+uNnDM6s/Jq4qNDSFGr02k36lIrZ5chPAoEEwisb68J/KFPJkv/5PxBf9gCMUBsGXP4KJHb+bf3/odW//4HAuwc6G8gG+c91U+c+vVfOrTl071Ek1Jt+vU7BxLZJ5ExW6jxO1w8Q8IJT6Hn8ex0FyTbrfbUDQcGxsz3bZ4CdDJovWt3LRpk+Hzk+UUTqdDOF2f9cl2SQsEAoEgMlzFs9GDf7cfZBjrG2Ng/cABGTST6fLxqSpPr/70R5ldXswTV/wY5xjUWwt55aFXOP/1K3jor78mKyvL8H0HWj86M7FT/1il0xkSkOY7HAC0er2M6sQ7M9Hs8b6+mK7JwUAgynGp5619+ziptTWqlFvvmOsyuRmtAMfn5fGTri7DML9EqMjJienKjDXqZ8f3GwT3nRkqmJ4viQbx6I+DXmQeVRT6/f6YLsmJkmi/U5FaPbkI4VEgmERifXlP5At5Ml/+J+ML/oEaimOEJMucettnmLt0ES9++/fMVq2cZ5/Po6vvp73tdW6/65ZpWRKabtep2TmWyDxGYrcmHurFSP15o9+3siwjy3LUeetwOKioqIgqqc7Pz49Yf2trK4GwO84Oh8N028wcl+G43W6Kioro7OwEICcnJ2Jtdrsdh8MRCp2JdWF5IDqF0/VZPxC3XSAQCA4GtHCVtvo2BtYPHPBBM5kuH5/K8vQFx1Vw6bM/5C/nfhd7v5eV8kw2b/JyylGr+Pv6Bykqmhv1noO1H52Zmy1cWIolsrbv3RvTzSiRWIJyuDimueme27PHsE+iHhn4fW+vYZBLIvyyrIw1770Xt+TciKNcLhL9VLssFtPzJVZfzlghQxB5DOe/9FJcl+RESdTJKFKrJxchPAoEk0isL++JfCFP5su/+IKfGpWXn0Z+WTGPf+I2cnzwEctc/vdoC6veuIxH/nEf2dnGd5onA81RuHXrVlRVpba2Nu2uU7NzLJF5jMRuoyCZhoaGKKHR7HzVP15RUUFdXV3IJRme4hy+fn0idFlZmem21dfX8+CDD0aUTbtcLsrKyti5c2eEYHrkkUcC8d2dgYD5pWUi+/Jg7YV4sLikBQKB4EDlYAmaiSoftwRFj5KbSiYcCjO4YRD/gD9KdNTGnwxmLi7iiv/eyaMXrWHo9e1UkUPuHiv1R57PfY/dS23tsqj3fFj60SUjssYLslnkcLB9dDThUm696JkICkQF3GjE62FpA9a89x6jSSZjayLg7UuWwDvvhB6vdjp51aA3OQTLn81YXVLCepOSdYVgb0h9n0YjJkPsS9TJeKC5hA90hPAoEEwT0v2FXHzBT53iYw7nE8/9mD+v+g70eVgh5bHljWFOXn42f1v/AMXF7viDZICWlpaQmNbc3IwkSdTV1aXkREtW2EpE9NaLhIWFhXR0dES8pqenJ5REHY5R+XVTUxM9PT2GSctGKc7h21RYWEhtbW2EcGiG1WqlsrIyoqS7vLw85vZOxAGYyHsP1l6IB5NLWiAQCA5EDpagmfDy8ZDAeFMJqEwoFCYiVCYM13IXpXeWkrdi8hyEjtxsLmlcy1PX/4L3HnuFxTg4j/lcXX8NX73nG1x08dnxBzlISVRk1cQlDJyJElBot7PD54sQn5Tx58KlPk0c07vpJoIFmGW1MuD3m443RrCEO9lbz7OsVpAkvv/++1zk91M9/vgdpaUc19Ji+J58a1AaMuuPuNzlMhUtlzudSR2PTIp9iYqbB6tLeLoihEeBYJqQ7i/k4gv+xFC3O6id82madv0RpD4qySbXY+Gsoy7k1//4OUceWR31nky71CZaPh++PkVRDBOeJ0JNTQ2qqrJ1vMF1d3e3aeKzHv35Gh7Aoq0tWbHO5XJRXl6e0HGYCqE+1vkieiEKBAKBIBPEcgpmmkSciP5WP5u/vZm9m+O7FbXy8XDa6tsmFAoTFSoDYAHrLOukio4astVC/c++RNPSEv73g4eZi5UL7Qv4zbU/YXP7G3z3e1+LGTozERIJ6JjuaOLSqa2tUX0hVWDH6KhhgnJ4qE24OHbxli1pS6aWJIk1ixfz5c5OZFWN6XzUxNBEO0RqYuYzAwM8A5QNDnJCfj4r8/K4cf587tixI+o9axcvjtkfccfoqOl8iZZKT4bYl4y4+WFxCU8HhPAoEAgEOsLvdpcGzmF7/n/Yl93JIhxcIC/g2rO/zJdvv56PX3ZBxPsy7VKbaPl8rKCWVIUtvXgGhMRGI9ERElu3mfBmJtYpihLlrvR4PKHtjXccpkKoj3W+iFYJAoFAIMgEZk7BTItqEU5CEyfi4IZBhr8wzDDDKbkVYeKl5NO1FL3u6rMoOHQ+jZ+5E5cfGmxFvHz/C1yy+S3+7+F7cYQFiKSDRAM6kh1zKoTMlXl5nDxzJusHBiIOrQyMKgof27KFypwcHlm6NLSe8FCbcHEsXul2osjATIuFx/r6uLu0lMf7+tioXTdLEoNjY4zp3qMCBVYry10untuzJ0pIDR87vL+hDPxg+3ZOyM9nw+AgW/buJc9iYV8ggB+YbbWydvFivlBcTH1bm2l/xMqcHNMAnWRKpTMt9gkn4/RECI8CQRo5WPuyJcPBsA/C73ZLyCzsP4ld/tn05b5KAVYusC3gga/9gvb2N/jBbd8O3WnOtEst3FFYVlaWtCsv1nr0wlaix9HIZWhGuAMx3lxGZdtNTU10dHSEBM1wsa6lpcVU6NRvdyzxcjLP3Vjni2iVIBAIBIJMYeQUzDRRTkIDJ+L2H2wPqiuK+Ws0zNyTEy0ln86l6ItOqebS9bfxp1XfwTE0zPHyTDZt3M2Ko87mX8/8iTlzZqdtrkQDOhIlE0JmMuhdcFpvRS1hWb+elXl5rC4pCYlXa7ZtY3VJieE4KpBrCWZjD8bokxiO1vdx/cBA1H7YMDjI8Qbl0DKw3OViXVUV8196yVAENOoZqWDcn9ICWCSJf1RWhuaO1R/xkaVLo8RbxseZbn0R44mbB4Ob90BDCI8CQRo5WPuyJcPBsA+M7nbPGarE5ZrLu/ZGnGNwhrWQVx98mQu2XMlDf/0VM2bMyLhLTZblCAFq3bp1SQlk+vUZ9U7USPQ4xhNX9XNo64xX9q0X3lRVNXRravMnI6qabdtkn7uxzhfRKkEgEAgEBxOJOAn3tu+NVk0M3Iax3JMTLSWfylJ0jViiyOtzcvjmjy7kmjWPs6hrkGpyyO23cVrtKh588jdUVh6eljWYCVAbvV7q29rYtHcviwIBbhsv4Y1HuoXMZNG74EYVJSQ6Gq0nllCqjbPR66VvbAyZoOBoSWFdAQBV5cbOTl4Zv+5bu22bYVm1wn6Bz6yPoVHPSBnj/pRGxyBWf8SVeXm8UFPDjZ2dtHq9QDCs5s7S0gPKTTjVIviHFSE8CgRpRPRlOzj2gdndbnflYRxz74n8ZdV3cAzsZaU8k81tQ5x05Nn8Y/0fJ82l1tPTk1J/RqP1mQmWiR5HvXhWVlaGJElJOSWN5tYLb42NjabzG60DwOFwUFFREXUc9NvS0dFBb28vu3btivm6dCNcjQKBQCD4sGB4bQUoowqDGwYj3Yq6VA+92zCee3IipeRTVYqusWFwkC8+0MLHH4BPvwPvLvHxxcsH+PnlNazMy2Pttm3szXHwo7UXcOXPn+HIje9zCA7OZz6fOf2zfPtXN7Fq1RkTXoeRACUDfWNjIddbL3Dqpk08X1MTV7BJNGk4k4S74Oa/9JKRxh1aTzyRbl1VFfVtbREOwES8jmZ9Gl/1eNgwOMjKvDza9+417PeYZ7GwZlw4ne9wGI6j9YwM728I8O2FC7n0jTfiHgO9o1N7zYDfH1rfKwf4jfGpFsE/rAjhUSBII6IvW/r2QSINyDNFrLvdeYvzuOK/d/LXi9bieWM7VeSQu8dK/ZHnc//jv5gUl5p3/C6jRqICWTIuukSPYzJiZjjJOBSN1mO32yNExZqaGrq7u0OCLEBFRYXh9urH8ng8hmXaqZafJ4pwNQoEAoHgw0Lo2kpWI4RFf7+f1pNaqX6+mgXfWsDAMwNBtSSG2zCee3KipeRTUYqu8bu/d3L79SCpYFEgvx9qm+B3zk5WXlm3X8Czytx/7enseKyFcx9tphArF9oW8rMv/Igt7W/yzW9fN6HQGaOADoXI/oFa4Ekigk2iScOTRbz1JCKUGr0mHnZJMu3NeGprKyfPnMl8h8NQ9B0KBEJCZ4/PZyhOVjqdEc7OipwcLh4dZUVubkLHQHOG3tjZGZFgvdHj4aTW1oPCFTgdRPAPIwdW4zWBYJpTU1NDXV0dxcXF1NXVfSgdTOnYB1oJzcD6AXxdPgbWD9B6UiuDGwYzsOJotLvds06fhb3YzqzTZ1H9QnXobrcjL4dLn1zLonOOBmAxDs5jPledcRWP/vWJjK/P6XRG/JwJgTvR46iJZw0NDdTV1SUsxClK5OWS0+k0nUtRFFRVxW63hx7zjfe1aWlpobGxkZaWFurr6xNac/i2mfWkdLlcqKpKY2MjTU1NIdGxqamJrq4umpqaaGxsjNqOdKEoSmgObf7pyoG0VoFAIDjQGNwwSFt9Gy/Nf4m2+rZJuxZK99zatZU1X+d7UUBVg27FvJV5ZP0qi1mnGV9/aeRU5hBV12rgjJzKfZcqlb/0hkRHCP4rqcHHISgShTZdknj63Fp+df1p+GWJXCw02Ipo+cVTXHHpNaFrpVTQBKjTZ82i2G7n9FmzmG21xnQJxmJ1SQmSJIXWHitpeDKIt56I/Rz2mnCRzug18ajWXcOHM6qqrB8YCIXMhK9NE3nDRV8j1m7bFnJ27lixgsaKCqrG+08megxW5uUxy2qN2LYAwc/p2m3bEtvQSWTD4CD1bW3Mf+kl6tva2DAY+3OeyLEVpB/heBQI0ohwMKVnHyTSgDzTxLvbLVst1P/8y2w8YhGv3fZn5mLlQvtCfvWlu2jf9AbfueWrE7rTHAu3243b7Wbnzp0TLtE1c/Fl+lzW75vc3FwaGhoMX9vS0kJzc3PU45s3bw5dVKfak9HpdBq6HZ1OZ2hObWy9S7Onp4eWlhZqamqi9mEixHJQ6vtNdnd3G/bKnA4cDH1dBQKBYLJJpLIjkSToTMybqbnzVuYhOwz+foW5Fa3VViqurMBiMZd0EunDmI71T0X1zZJ394uOGhYl+DgYOxG3LF/M4Y9+i87L72CGd4QT5XzaNnRz2srz+cdTD5CfPyultegDOvSlxZC4YDPdkobjrcdoP+tFOqOy5HjcWVrKDTo3YTjaXMtdLmZZraG1vTw0FDe4Ri8CbxgcZM22bTR7vdRu3sxNJSUJH4MDxRWYSr/GRI6tIP0I4VEgEMRkKlKqE2lAPl1Y/sVzKDh0Aes+exeuADTYinjpvue4dPNb/N/D90a49NKFJElUV1fHvChPlKkSjdxuN93d3RE/m2FWlq2/k59oybm+v6QWgKMoCpIk4Xa7I0q2tbGN+kj29vYa7sPq6uqk1qGJiw0NDciybChyho8/nYS9g6Gvq0AgEEwmiYpi6b4Rm4wYl6mbwMmkRpsJf4n0YZzo+jMhvCZCbqUT/3OeCPExIAcfh9iC2YoX7+TP532X4Xc/oBYnub2jnFazioeeuo/DDisLjZdqoq9RorNE4onG8ZKGJ7K2VIi1nkSEUv1r+sbGTMuoAY52uViRl8cdpaURYpmeAPD2yAjLY7gjjQgXgfWC3DMDAzw7Lsgl0sdwupXGm5FKv8bpJoJ/WBDCo0CQAZIV6zIp7hmNDUQ8tmzZMtP368URVVUTCg+ZCMlclE4HSk6r4WPrb+Uv534Xx9AwJ8iz2PRaH6ccfS7/WP8gBQXx0/6miqkSjZIJVtELfhaLBYvFEiU8Dg0N0dTUFPec1G+jLMtRbsumpqYIYVRL3nY6nRE9NouKihLeh/rPol7cDHdQxipXnm7CnuhtKxAIBMmRqCiW7huxyYhxmboJnGhqdDzhL15lykTXP1XVN9W3lNLyfAuKDLICigwWCaq/Vxp6jZlgljU7l8vW/5AnPn8XPf/eRBkzcCpuLjv5Stbc/z3q60+dUKJvuGCjpVr/sKIibYKNtjZFVVGALp+PpwYG+HlZGVcXF8d8XybEykSE0vDXGDlCNaySxJ2lpaH3aPvxuT17osTKqBAfnQBohN61N9EAlenqCtQf640eT0rOzESOrSC9COFRIMgAybrI9K/v6OigvLw8LaKe0VoAQzHRCL3IsXXr1lBpaqbcV4lelE4n8suK+eSLd/KX87/H3s4eqsnB1WflI7WreGDdb1m69NCpXqIhUyUaJVPKXVVVRXd3Nx988AGBQCD0Pz0ejyd0XscaO5FtDhdGNdFRQ3NIaoJpS0tLQvtQ/1k0cnlqDkq9KKlf/3RCpHMLBAJBciQqiqX7RmwyYlymbgLHciuG/21PRfgLd0gqo0pQwYmTkG3GVFXf5K3Mo+aFmpRTtS0OG+f8/mu8/KM/0/azf+LGxoXWhfz4U2t442sdrD9txYQEKU2wCQQCtLa2Up2bm/rG6li7bVtIdNRQgWu2bmWZ02koJk5ESDViIiKmWen10S4XVxYVhRKptXHXVVVFrd8oxMdMdJSA2VYrDlmOcu1NtFR6OroCjY61tq90H/Np58wUCOFRIMgIybrI9M8nKqCkspaOjg5ydRcJvb29pqWuepFmdHQ05vjpIJESGj1TURKuZ8YsFx9/6laevPqndD3dQikzcKrz+NSpn+am33yHs8/+yKSuJxEOBNGora3NUIiz2+1IkoSqqhHux3jnpJGoqHdKhgujjY2NEe/XOySN9qFqUGpj5LTUl3UbOSghGHaTm5s7LY+R6G0rEAgOdNLdyy/eeImKekY3YgH8A35emv9S0mtNRkzM5E3gRFKjkxX+9A7JkBqh/Zvk+qey+maiqdqSJLHiGx9j9mELePbaXzBTsXC2bR7/veNxXnv2vwRu/AyEteuZLr372vfujRmaYiSMTtTZF048ETOeKGkm1qkQc1wtRbp1vKJGUVXGTNYYFviOJEk8VllpKAamo1R6urkCjY512Md7WjkzBdEI4VHwoSQTIlX4mPoyyXgOJaPecRAUCSe6Nv3YHo8nqVTkmpoauru7Q+KIvrw1U+6rZC+6pkvAhcVu5azf3sCrd/2Nlrv+ThE2LrAt5Cefu43Xr3uLr/+/L2UsdCYVjESj6SDihpNoj0eNeOekts1NTU2hc0YrqzY6Z+I5JI32od6RqSiK4e8Fo2AavYMSoLy8XIh7AoFAkAHS3csvkfESFfX0N2Id8x14NnrwbPSktNZkxMS8lXmU3l3Kuze/i7/fj8VpwV5sZ8vFWyYlaCVZ4S/KITkuOlrzrcgOOeZNbCOh+ECsvtFz6KoV5B8yj0cv+B5Z+3ycYslnVruXx75yK7t/8BVwBvfldHGIVebk0GVybWcmjJo5+zaGtcVJlFgi5uqSkoSclUZiXX1bW1xxtMnrNe35CMaBM7EciMmWSk9mb81UMTrWCmCTJGqdTnaMjk4LZ6bAmANGeNy0aRP33HMPra2tjI2NUVpayic/+UnOPvvsqV6aIEWmUtzIhEhlFliRiENJe76joyMiYdfj8dDS0jKhtdXU1ESNK0kSdXV1ET0eN23aZPh+LeE4nOnovppOAReSJHHMDRdQcNgCnr7mHvICFs62FfHiPU9yZfub/PYPP8Fms03Z+uKRKRHX7DMf73eBXvhzuVwAEed0KudkoueM3tFYVVVFU1NTUr+79OXTbrc79D79vtUck1u3bgWgrKzMdJumm0gsEBzsiOvRg4909/JLZLxkKjvCb8S21beFxkxlrcnMO7hhkM5rO4PbokBgMMDw4DCQ+aCVwQ2D+Af8UaJjLOHP0CGpgOyQWbFjRcy5zITiZKtvpiNzKkq44r938si534Htu6nDSe6Alb9f833eu/VaLMVF08YhtrqkhKcGBtDXjMiYC6OVOTn0jJfchtM3NsaGwcGkxDMzEfO5PXt4rrUVf1g1SzLOynhlz3rB04w7S0sjBLUNg4PUt7UZioWak3LNtm0079lD7cyZ3GwiyKW7XD1TGLk4AcZUlSavd9qtVxDJASE8vvrqq3zmM5/BZrPR0NCAy+Xi6aef5qtf/SpdXV1cddVVU71EQQpMpUNNLzBs3rwZYEJf2hMJrDBDEx9qamp45JFHIgSViQposixTXl4eJYqG72ujfnnh6IWf6ei+SqRv32SLNKVnHsXMdd/n0fNvYYZ3lJMs+bT+dwenrTyffzz1ALNmzczY3BMhUyKu2Wc+3u8Co1JmvdBfVlYWCj3SAlrMjq12HgwNDUU8XlhYaPh6vTgY7pRM9HeX0e8Hs/XJsszy5ctZvnx5zDEhdjK2QCBIL+J69OAk3b38Eh0vlXLadKw10XmjBFTdnIkInqmUsPtb/Wy6ahN69cm13EXpnaWmwl+qpdHxhOJMBskkykTdaNlzZ3L5v3/M45+6nQ9efJ1DyeIKdQH/uPGnzPjeVfzkY+dOC4fYyrw8fl5WxjXjN14hKDrKMYRRTazUI2Nenm2GmbBlllSdaIl6vLJnI2HSiPBVJCIWrszLo7GiItiLs6ICS1h5fTjpLFfPJJqLE4PjoU7D9QoimfbCo9/vZ/Xq1UiSxB//+EeOOOIIAL74xS9yySWXcM8993DGGWdQMg3u0giSYyodakZ9C5uamiaU2Kwfs7CwMGlXlJFImGhSbywm2sfvQOgDmMgap0LsLjh8IVf8907+fN53Gd62izqc5PWMclrtOTz0r/s59NDS+INMMpkKnDH7zMf7XWDmCtReW1RUhKqqCR9bvWiZLKn87pqsfaolY0+3GwMCwYGOuB49eEl3L79M9gaczL6DhiJnOHEEz1RL2H33+YIKi24brbOsMd2GqZZGT1WITKKkw40WEi6/dCIXFmRx2D+amIeNS20l/Ovm+2kdU1jxxU9ldkMS5OriYpY5nRE9D6udzigXZDhWiOqJqJB830qzcBgzEi1Rj1f2bCZ46gkX1tIpFk40iGay0Fycp7a2RonB03G9gkimvfD4yiuv8P7773P++eeHLvIAnE4n11xzDV/5ylf429/+xg033DCFqxSkwlSl6cJ+0WLz5s0RYSkTSWyeiBAS7sQrLCyktrY2tJZEg2b0d5UXfmsh72S/kxZ334EQHpHIGtMpdifjnswqyOOyZ37EPz93F73PbaKMGTj9bj5x4if5/h/W8tGPnpzyOjJBpoRms898Kr8L9MdbHwDT0dFhemzMjvvOnTsntB2xmKx9qs0hEAjSi7gePXhJdy+/TPYGDI0tq/tjXBUoWFUwoXGNnImGIqcOx3yH6Xjt57aj+sPEgQRdkkqnYigEejZ6aKtvC/W6BBjdMRrx3846Z+i/Ey2NzoSYm86wookKTHrh8mcX1HBkoZPLf/0Cs1QLq2zFPPX9h2nf9AY/u/dWU1fcZBPe83Cjx8NJra1RYqu2bX6D96fSt1IfDtM3NmbqdkwmxCReQnQigmcAeHpggPq2NlaXlKRVLIznyJxO/R9X5uVx8syZrB8YmFBwjmDymfbC4//+9z8AjjvuuKjnVq5cGfEawYHFVLrowkWLWM6nZL7AxxNCYo2ld+LV1dWRm5ubcMm10V3lgfUDvH/D+4yUjmTE3ZfuBMjJIJ1id7LuSYvDxqo/fI2XbnuETfc+gRsbF9oWcusnb+GNr3dw/Q1fSHkt6SZTQrPZZz4dvwuMQpQ8Ho/hsTELc0r0fIi3Xk2U3rp1K6qqUltbm9F9Gh7+BJN7E0cg+LAgrkcPXpLpezgV4+nHLr27lK3X7C9FRYLOL3firHSmNQyn9O7SaJEzmfH8BoJNAk5CuVQm0B+IFAJl8O/2M7B+ILjGrv0BJEb/7TraFbwuTWCfp1soTndY0UQFJiPh8rXjyigpm8+Jq/9M9sgYp1kKaGp8k/qTP8ajjb/H5XLGGjLjJCq2aq8zItW+leHhMPVtbVECF4BDkjh55sykQkxiJUTrhclRRaHf74/62CnA+oEBntmzhzqnc8Kp1RqxHJnTsf9jssE5gunBtBcet23bBsCiRYuinsvLy2PWrFm89957k7wqQTqYDi46I5dic3Nz6PmJfIE3ErnMXHJGTrxkRDLD/jSyyuwnZ9N1bVdozHgoikJra2tcF1+6L6rM1pLufozpFLtTcU9KksTKb15CwRELefbaXzBTsbDKNo//3P53Nm96g1/+9nas1mn/azlEssfI7DOfjt8F4cd2aGgopmgf/lpFUZAkKRT2kgjx1tvS0hL6PdLc3BwKc8oEWi9Z/XEQCATpRVyPHtyk0m9xMscLp+/xvuA37bD0ZlVKfxhO3+N9QZHzuq2mwuPojtGox0LjGZGAk9D+GTvDrw3v30btX5nYpd9heF710HpSa0LXpekWitMdVhTPjRYPM+HymWIXI7/8DHU3/h8Fu/dxlOTirXdHOLn2LP66/gFKShYkvdZ0kajYatYb0SFJ/Lu6esJ9K80ErnSMrSdcmNTEPsnAARkAUFXe3LcPiPyYTERsNXNkJpLIPdnEc5AKpifT/huud7y3g5ZiqsfpdKZUVhYvTEOQHrT9nOz+VhSFtra2iBTZTIUlLFu2DFVV6enpobCwkJqaGnbu3BlKe071XNHGDU+Obm5uDgkSXV1dqKpKTU0NhYWFUf0hjd5vtpa9m6L700iKhL3LHjGm2fu1x1taWmhtbY1an55ta0wuqtZso6KxIpHdE5dw8SbWWpKluro69N+qqqZ8fI2OWaJjlZ51NLmL5vLYxT8ga9jHKZbZND/7Lh894SL+8sT95OXlmr431c9UJsjEMZrIZ187tuHrAuNjE34eaEzkfAgn3H2o/Zzp45Wu8/rDyHT6TCXKgbTWgwVxPXpgcyB+zs0wuuYjEHw8le0zG8/zmoeBZwYwrGMdRxlR6P9Pf4S4ZziehgQLv7Uw5vWotdpKxfoKum7rCgmBniYP/r4YCzFAVRO/LnUe46TiicjXha9xcMMg23+wPbSeBd9aYCpopvv4fHPBAp4ZGIgUmIBvLTTfj+HrvaVE4e5LYFPl/udlYLffzz8t0PjDi7nqx09yxFsfcDhZOEfmcv6KS7jroR9z3PFHm64rk5+pChOxtSInJ2I+o9cBOC0W/IHAhNd2jNPJs5WV/GD79pDA9e2FC/EHApwRlib9rQUL0ur+C593/cCAoe4/GAhgAeqcTnb4fKG1He10Rmx3osfpGKeTJyqiPwObTETgTXtTO5/Thdl6D2QO1L9Tia5XUk1vSU0PPv3pT7Nhwwaefvppw7vMp512Gr29vaFU4ngEAoGQsCKYvuhLB91uN/PmzUvrHJrYuHv3bny+/WUamZhLo6OjI8KJ5XK5KC8vD63F6/XidDpxu91IkpTwuPu+vI/Aq4HIO9Iy+Kv97PrqroTHNFufHm+9F3VX9K8OaY6Ec116yjNirSXV/eVv9eO7z4fSqSCXytg/Y8dandr9l4keMwBfv5dN3/gT6i4vCipbGeHfci/fu/ubzJ/vTmldk0mi50sypOOzn45jMxEm4/eXQABBwXm69OM62BHXo4Lpgtk1n3yEjOSSkr7GMRuPXGCI2GXWMiBB1q+yQnMZjgcwE7LvyMZSZUn6esx0zDik47rU3+pn+AvDwbnDLn3t37DjuCi6x6XZ/rQcbSH7nuyU1tDq93Ofz0enolAqy3zW4aDK5Hd/aL0qQTesDAEJbrgL2iuDh0xh/78AkqJywf9t4NRn3wSgHz9P+ro55fNnsOrcj6a05onQ6vfzheFhbRO004xfZ2dHbHer38/nh4ejTgtp/D2/ysqiOs2VRGZry8RcAF/et49XAwHDU18GjrZYuCc79nmlP38+Y7cnvFaj+ROdV/DhIt416bR3PDqdwT8W4V9uw/F6vaZ3n2NRWVkpLtYngUAgQHt7e9L7W+8YkiTJ0KE0EVpaWqLmydRcGvpS7rKystBcE3GKDd42yKZTNwX/8oXdDq37SR25K8zdcxraccrJyYn4rDmdTsN9sbl2c/AuuK7/ztiCMVRVTYtDNda+Cj92Ho8Ht9sd95gNbhhk01WbQkmJgf4Aw68Ns+zZZSmXh6fDgVn736P456fuoO/lNzmULJzKfG656lZ+9OCtnHzSyqjXp/qZygSxjlGqTOSzH+6WdLvdGXVKx2LZsmW0tLTw9ttvc8ghh6SlTYAgc0ynz1SiaGsWTB7ievTA5kD8nIOx047biL7mA5Q3xqWBJK9xzK4hrVYrfiWOy1AJvn7GX2ZQcWVFzPGqHq8id0Wu8fXY/4bJKs9i5J0RVFXFWe2k8IpC+v/Zz972vWTPz8YjeSJLzONhgZm1M6monlglzuZvb2ZYHUYfq+z7kY/Dzjwsav+abX/FDyvIrY5/TW5ENXBlMutlOKQqSgpYLXDdw1ZurpOpzMmhyeOhz7//2KqyxF+vPA7vIYWc85sXyFetnGefz/P3PcfggJfb77ol6jomk5+paqBscDDKabgiN3L/7R0cRNq0Ker96vj/vjE2hiMQSKsr8dubN0OY2Dn+EeAvM2ZwZUV6qr7CuW1wkFM3bTIUHhXgPYuF6upqNozvr43jf6MkoM7lomHmTL7y7rtA8HTsDwR4bXiYZ5ctS2h/aPPrTmd+WFFBdW5q57PAmAP171Si16TTXngsGe9T8N5771Gh+zAPDg4yMDCQ0pd/i8VyQB3QA51k97fb7aa7uzvi53QfL7ME20zMpVFbW4skSWntWwiQf0I+Nc/XJN2fRuvR19PTY9iPZ/fu3bS2tkats+SmEvY8G9aIWwYVle7Tunmn+Z209LSrra0FgknjGpIkIcty1LHbuXNn3GO2/dbtoYtcIPTXc/ut28lflz+htU4ES04WFzzybf5zywO8cd/TFGPjIutCvvfxm9j6nU9x9TVXGr9vGvwOS+R8TrYP5EQ++62trSEhtLu7O6O9FWNhsVioq6vDMn4xmMxxykRvU0FiTIfPlGD6Iq5HDw4OpP09uGGQ9lPb9/fT3uljz7PBftr6az7/gB/PRk9K1zhm15Db1mwLhbnEJAB7nt/Dq4teDYUNxromNbweA4bfGA4N6f2fF+//vCFbnm/neGjMcldUkrVjvgO/x8/w6/vfHwqIubkk7vEOD0sMH1fblr2b9xo7LdXo/Tu4YZDtt27HOjP4FVtCwrncmbZwoUTYu9m41Pvw92S6VqwAjENTLADnHMWqj57AY5feSo7Pz+mWubz2j3bOffMK/vzYfeTkRDvcMvWZOiE/nxPyY5+7t27fbvqcQrCcHGCnz8ezaQpE2WxSerx5796M7Yfna2o4t709QiyG4DFblpPDK14vp7a3o6hqxKm6fmCApwYGItytmnh46/btrIuzf8PnF/0UJ48D6e9UMkx74fHII4/kV7/6FS+++CINDQ0Rz23YsAGAo446aiqWJsggk5F4rQ9vcblclJWVoaoqjY2NGfnSn44QDTNhIpVG5uHJzLDf0aHh8/lCz4evW9+Ie1/hPrpP62bkkBEguTRwM2RZRpKkkLskPKQjlXTqve0mPXfipCtOBpIkceJ3r2DuESU899VfM0u1cK69mH+t/ROb2l7nZ/feGvMP0FSJVYmcz8mmf0/ks59K4M90I9n9JRAIJgdxPSqYbOKFlIRf8700/6UJXeMYXUMWnFPAwFMDCb1fHVXxdfkiwgbNrkkNr8fMCFdLZLDOslL3ivHfxHABMdEb8FFhieEJ2ePbMqN8BnQZvz98/+rHComfCaZrJ0vU9q4uIW9lHjmVOfh6fehVxfBQn1ipwPPy8rjshdt55JybYdcQx0q5vPHWMCcvP5u/rX+A+fOnT+sYs3AZPekMREk27GfD4GCEaLe6pCRp8XNlXh7/qKyMSJcOP2ZrxtO9jVKww//VMArqiTf/VAXJCA4epr3weOyxx7JgwQKeeOIJrrjiCg4//HAgWNJy7733YrVaOe+886Z4lYJ0MxmJ10YCR6Jf+idT6NHPFV7eOlFhQi/MjI5GpxMavQ4iL1Kbmpp4p+md0HMTSQOPNa/2cyriVCIXYlPN4RefwKxD3Pz9ku+TPeLnNEsBGxvfpOHUS/jrE7/H6TRe63QWq5IVAyfy2U9FkJ5uHAziqUBwMCKuRwWTTTI3TB3zHRGiWfjjeswEq/DnvBu9jPWNBWsqk0EnjhpheD2WCAoMPDvAS/Nfilo3xE8SN3I2elu9qH6TuIPxbTHar+HbomEkFPtllUe/3s6hT1amNXwkSjANE3xLVpew55mwqiRNAL2pJPT+eKnArvkFXPGfO/jbpT9gT+u7LCUbp9fKOUdfzC/+djdHH12btm2ZCEYioBnJim1mxBJt9Wjp1JpY2Ovz8UyKzstYxyxRAVYjmVR0gSBdTHvh0Wq1snbtWj772c/y8Y9/nLPOOgun08nTTz/Njh07uP7661m8ePFUL1NwAGIkcMT70q+JgOGhGpkWevSikr6HlLbGeGJo+POFhYUADA0NRYxVUFBg2PcynoCTqkst3prNhKRUxKlELsSmA0V1ZVz+nzt45JzvQO8ejpZcvPn2CCfXnsVf1z9gGDozncWqyRQDJ8MpnWkOBvFUIDgYEdejgskmEzdMBzcM0nJiS2hMX5ePgfUD1LwQ/HsZ4diDqL6GCRHHaRl1PZYMY0Q5KxPp0x0S6hQ1WLodQ0yMIAABj/kiw68hjYRiiwKuDj8ntbampcxXI54bNrwqycz9Gc/FZndmcfE/buHZb/yWtx/5D4uwc748n6+sup5rfvRlLv3E+WnZlomgFwE18iwWPLpAlHSJbfFE23DWjjsRIzogTMB5aXbMYgmwWpl1RCq6iVAqEGSSaS88AhxzzDE89NBD3H333axbt46xsTFKS0u57rrrOOecc6Z6eYKDiHhf+vWlyRrpFnrCBTm9OKhHW2M815vR8xoulwun08lpp53GM888w+7du7Hb7SGRs6enh6amJlNnZ6outXhrrqqqoru7m/7+fvLz86magM1fXx6eaBkOTH4ps9M9myteuJ2/f+I2+jd2cgRZuIbncO6xF/PTh+8gJ8ce8frpLFalIgaa7e94x2EynNKZ5mAQTwWCgxVxPSqYTJK5YTq6w7hiRf94542dhi7KlpNbsOZZQ8LchIgjjuqvxxzzHXhe8yQ3bwLOynC2rd2W2rZZguXd/gF/1H5zHe2KuIY0EooDMryzJBjGl44yX414blgj92csp6sZskXm9Ns/z9yli3jp5gcowMr5tvk89I1fsWnT61x8SUPM92caMxFQBU5qbUVKwJWY6rz6Y2lUUm3kREyX8zIcTYCVdeXW8vj/vu5w0JKdTZPXC+M9/dds25ZS2bdAkCoHhPAIwZTQ3/72t1O9DMFBTrwv/WYCY7qFHjOBE6C0tJTe3t4oMS6e6y2WOOpyuXC73WzZsiXkePT5fLhcrtDPWuCHJuykQ4yLt8a2trbQ/D09PbS1tU1IWEqlDyZMTSmzLXsGFz16M899+/d0PPhvFmDnIstCvnXxNzj1C/URSc/TWaxKRQw029/TuaQ8XRwM4qlAcDAjrkcFk0UyN0wN3ZEyKKNKRGmyp9k4lZ0x8PfFSbA2QiboipRJqppEfz02uGGQzhs7g6XPqooly0JgKBDbcRmAPc/tYXDDYFwBbW+7SUBMLMa3ZfGaxXR+uTNKAC69szTi5ZpQ7JdVLMr4blHgiC1w5mPQfFH6xKZk3bCxSrMTcYxWfeqj5JcV88QVP8Y5BmdYC3nl4f/xjf+18tiTD5q2ApoMzFyAiboSjUi2L6NZSXWd05lUP8hUCRdgtVRrJInlTiffWriQ7HfeoX7BAk5tbw+tcf3AQMpl3wJBKhwwwqNAMBnE+9JvFEhTXl6edqFHL8C5XC5yc3NDPR6NxLjCwsKItWnl1GZr1z9nNG9/f7/putIhAsVz6k2XEuKpWocky5xy66eZs3QRL37rd+SrVs6zzee53/ybrw7s5Y6ffA9ZljMiVk1lurLZ/p4u54NAIBAIBJlE705b+sjSmAJRlDtyvL7S3+8Plhb3+hJLqE4GGSRZovSeUvoe60u6mkSPdZYV22wbgUUBSj5RwjvXvxNZTmyAOqrSelJrXAEtpzInbnm15JBwVgdDFkOp1uPb4qx0mgrA4cfKWefk/fe9zOwJKqYS4NwLX/kJPJ1tgRVJ7RJTEnHDhq9LGVUiHZ9JOkYBFhxXwcf//SP+vOo72Pu9rJRmsuXdfZx+zHn8bf0DuN2F8QeZRFINREmlL6NZSTUEj0si/SAnitn2BgIBWoEfbN+e1rJvgSBZhPAoOChJtVQzHkbOMu396RRq9IJceXl5SFhqbGyMeK0mvqhq5G1h/c/ha9dEyZ07d1JUVMSyZcvYtGkTRUVFIWcjwKxZsyLEnXAxMx0iUDyn3nQpIZ7qdVRedir5pfN4/BO3keODj1jm8r+/tXHOG5/gkX/cR05OdtrnnEp3odn+TuU4TKWAKhAIBAJBsqTiTtO7I5VRJSQ6AqkJjpqb0QqMRT9tzbeyeM3iSNExhQTnqDToXnj7lbex5FqQbBISEjMOmYFno8dwO1R1v4BmFCAzumPUMGRHj2SVGH57GNdyF6V3lMYMrhncMEhbfRuejR78u/1BhXFc4J01btTUcnkkgj9/9Jc++H5Su8aU8OPt3ehFHbeGbluzjZLVJYBBv049SaSeh+YtKeSK/97JoxetZej191lGDq5BK2ceeT73Pf4LamuXTWCrpgep9GU0K6neMTo6IedlOpmssm+BwAwhPAoOSjJVqhnLWZZOoSaWIGcmvnR2dkaM0dnZyZFHHpnQ2gOB4J+iyspKenp6QmXchYWFMcvLJyrGxXPqhe8HRVHi9ppMN5po1dPTg9vtRpblKStlLj7mcC574Q4eOfsm6POwQsrl9TeHOWX52fztmQcpLo4OnZkI+uOu7fvJEPDMzv9USso/DOXZAoFAIDh4iBccYka4OPbS/JdS79VoA1ueDedyJyU3lbDl4i2GbkH/bj9br9kaIbolG/iybe029jy3JzJZenzdgcHA/rLmO4Jlza2ntqKO6uqvxwW0KME2bM2+Xt9+BdAEZa+Csldh4OmBmNsRJZQSNu74z/owcAlgTzrtpsHjXbK6JGItA+uDa3fWOeO6RVMNKnLkZnNJ4xqeuv5e3nvsVRbj4HxpAV+sv4av3P11Lv7Ygd3vNhmBTivJ7huLVua1kupUnZfppjInh52TUPYtEJghhEfBQUmipZrpFFP0adBG6dCx0Duzwns3trS0hNaWqPji9XrZuHEjtbW1CW9Te3t7RBm31+uNeH7nzp2h/zZbRyIOs1ivMUvf1lLE9b0mM4m+12ZdXd2Uilau+QV84vkf89C5NzPW+QEVZOPyWjnrqAv51d9/xlFHpU8Q1QvLqqpOmoBnJkinUlIuyrMFAoFAcCARLzgkEQx7ACZKAPx7/CH3oulYqu7fJMp3DcU7k7WoqLQc1wI2TIVDx3xHtGCrGydhFFAl8+2IOU8MrPnp/9ptJlJ7W71xRcdEenGaIVstfOSn1/DETBvdf3iROVg5376Q+677KVs2v8l3v/c1JEkvvx4YGCVEGwl0+pJsdK+fbsnR31qwgGfDEsCn4xoFBzdCeBQclBi58RRFQVEib/+aiSmplGfGK3WOh96Z1d3dHRIBw9dmJr6UlZXR3NwcMX9zczOSJCUs1sQTZcJdjWbrSMRhZvYaRVF44oknQusw60k5WeLRdBSt7M4sqn54Kbv/1MS7f32RRdi5QF7A9edcyxd/fB2fuPzCtMyjF5Ynui/SWfKczFjpLpMXpdsCgUAgyCTxgkMSSSc26gEYQdhjFqcl6C7U0AlvUWPFIkGBNCXxzqDcW8Oz0YNtli19PSxjBNcYCsPhjPfX1LN47eI0LS7OWgIEv+FbiAobsuZbkR3yhHpxhjP/vCOpPPlonvrsXbj8cKatiJfvf4FLNr/F/z18Lw5H/BL36YaWEB1PoNOXZGs4JImTZ86cspJqM7QAmhs7O2kdN5ZUO50x85uSIdlAHsGHDyE8Cg5KjNx4WsmshlY6G44mpiRTnqkJEfoglkR6P4Y/NzQ0FPF+/Xjx3Jm1tbVs3bo15AzUb1Mi6Hs8qqoat8Q4fBsURWH37t0Rz3d0dESt2UzE0sZJZJ1mZLLXZqKild/vZ926daGS9fr6eqzW9P26lSwyp93+OTYtXcQrt/yRAqycb1vAg1//Je2b3uDWH62e8J1mvbDc1NQ0IQEvnSXPyYyV7sRvUbotEAgEgkwSKzgkXv9HfdAJRAaloBIVkrLl4i2RwiNECIjh/QQHnh6IXcJtkKRtVK4cV7xLARXVVPRLaTyT4Jq4blIFbEU2lGGFgCcQ7IW5djHFXyhOeS3hqd8AzmonpXeUmorUzmon3iZv1DlU+VjlhMVGPYtOWsYlz9zGX1Z9F8fgPo6XZ7Jp425OOWoV/3jmj8yZMzut82Wa8IRoo76MmsD29MCA4alWYLNNi9JqM5q83pBgutHj4aTW1gknW6cSyCP48CGER8FBiZEbTy9oaWKakZiif+3mzZsBDEUsfTmufqxYQoXZewHy8/MjhNJ4pa6yLFNeXh41XqICkaqqqKqKy+VidHQUn8+H1+vF6/XGLDGOtQ0AHo8Hj8cTseZE97ueRFLEY7kpkxUkq6qq6O7uDgmIVQleSKxbty6iZH3dunWcffbZCb03GWo+W0/BofN54pO34xyDemshrzz0Cue//kn+9OivmTFjRvrmmqCAl073aDJjpTvxezq6YAUCgUBw8KAPigl3p7XVt5n2f9T3+/P1+pAkKUo405cPx3NYamuqWldFW32beTq2Pkm7y8fAvwZwHR0d1jKhUnAj9L0W00R4cI1GlDBs0DtyrHcMLFDzn5qE+l3GYnDDIC0ntkTsK8+rHlpObKHsnjJDkbr0zlJDkTkdomNI3N60l8CiAIO3DZJ/wjyu+O+d/PXC7+Ht6KaaHPL6bXykdhV/aPw1y5YdMeF5JxOzvozhApuR6DgZPRMn4ixMJThnKscVHFwI4VFw0KIXmgoLC6PELjMxRS+MjY6OhsSseIKmw+GgoqIiYmyz1+ufczqdIadaUVERbrc7lDxt1J9y48aNbN26FYDS0mDjbZfLxcjICJIk4XA4gn8cFcW0z2JPTw+qqrJ79258vujm4UbrTOQ5h8OB3W6PcGB2dHRQU1NjGhqjP0ZAlOPSTCzUtkcTifXrS8Wp1tbWFiEgtrW1JSRi6d2q+p/TyYLjK7n02R/yl1XfwT6wl5XyTDZv8nDykefw9/UPUlQ0Ny3zTFTAS2fJ81SmjE91wrlAIBAIDg5ilUzrU5Q1zEpr9zy3h9bnWiNDWhLsuRjLYalfZygdWivjHRcbbQU2VNTIJO1xPK96opyDoTnTpRRawLXcFUyZ7vMn/XbJJgX3nX45AfBu9NJW3xZxnKISxI3mDJBQv8t4bFu7zbRvZd/jfaYiNUSLzBPFKIF806mbqHk+KLBe+q8fsO6L97BjXRNLcHAu8/ns6Z/jm7/8Nuedd2Za1zIVmJVXQ2RJdqbKjifqLMxUsrVIzBYkgmhMJTho0YSmrq6uCNGwuLiYurq6kIhVV1dHQ0NDqBy7sbERVVWpra2N6k1iJLLphYf8/PwIgUz/fPjPWniKhsvlCjkEW1pakCSJhoYG6urqol47NDREc3NzxOtbWlrweDyMjY3h8/nweDw0NzfT0tJiun+0XpJmoqPRNkBQ6GtqaooqEdeoqKigvLw84jFtndp+Lyoqoqenh+7u7tBaampqcLlcuFwuamtraWhoCO2DWA5FbXtGR0ej9lNTU1NU2E8iTrVU3W35+fkxf043MxcXccV/78R1xAIsSFSRwxF7smk4/dKke41mipqamqjP33QY60CaWyAQCAQHFoMbBmmrb+Ol+S/RVt/G4IbB0OOtJ7UysH4g6AxcP0DrSa2h583IqcyJ7tdIsCw4Ku0ZEuq5qDksZ50+C3uxnVmnz6L6hWryVuRFrdOzMXgz2bXcha3AhjXfirXAinO5EwnJtMxZcw7q53Qd7Yq5toQYFz+1taXy7dY214brKIO1yDDWNxZ1nCAo6q3YsQLZYT7hnuf2RB37ZIl1/Pa27w2lW+dU5rC3fS/b1mxLea54RPXmVAg5KwEsNisNv7qemhsvQAUKsXKmfQHf+uzNtLVtyciaJhMjgQ2Cp9zps2bxQnU1KnBSayvrBwbo8vlYPzDASa2tbBic+DExchaq487CRKjMyYn69ZEOl2amxhUcXAjHo+CgRS8S7dy5k4aGBtPX6x1xdXV1VFRURJQRGwlwNTU1EUEwPT09oRRqzXHpdruRJAm32x1TqNCnSIeXeMd7bSwS6bOox2IJ/gmZO3culZWVUf0l9SXWLpcr5NgM386Ojo4I12Msx2dvby/FxcVceumlCW+b2VgaHo+HpqYm3G53xOOJONVSdbfV19dH9XjMNI68HC5tXMsDK65nuGeAOZKdnvd7GR0dTWvJdaqks+Q53eXTB8rcAoFAIDhwiNWP0SyNOGl3YgKM9Y3RVt9m2m8RzB2WRuvUFAb/Hn/ouVD5tVmPRQMBNG9lHnWv1NH1iy7evfnd/W5Jg9JlIySHhNVlZaxvDGSCrsNUejxagqnYIeEyHGV8m2Icp5zKHHxdxjfv1VEVX5cvqhdnMsQaP6cyJ27fz3Ri5rgN33eSJHH09efB2Bgtdz+OC5nZthxe29hKVdXStK5nsjFLvD591qxQSXF9W1vGyo4n6ixMNDgnWTI1ruDgQjgeBQctsZyGRuiFq46ODqqqquK6m2RZjnLidXR08Mgjj4Qclz09PaH5161bR1NTE4qisHPnzphr0kq8W1pa4r42FlqPRW0siL8/AoEAgUCAnp4ennrqqQj3qFEITG5uLg0NDbjdbnp7e0Pz6F2P4fMarSHVnnnxtkcTjJJxqqXqbrNarZx99tl88pOf5Oyzz05rsEwsZKuFuVVLAJipWijLmsMfH3x0UuYWCAQCgUCwH0Nxcdz5ZybgJOtOlGzxg+TUUTVhR6Ues3V6W73RgqSMuWCo6xmpMbhhkM5rO/EP+PeLfIkUalhg5skzcS53BlUOTWxMVHTULtvHy8pNsRmMqTtOJatLDF2o+vfoXZ+JYjq+BUpuKol5nqWbnMocQ/XAv9sfdW7NO/IwABxILLHl8ehDjzE8PJz2NU0mq0tKkCQpdDi0fwf8fua/9BL1bW1s9HozVnY8UWehFpxz+qxZFNvtIZfmRNO3MzWu4OBCOB4Fk0o6E4fjzaMoCna7nUAgwJw5c+IGg+jdbR6PJ9TTT1v3unXrDNdt9F494YnT2mv17ysrK0OSJDZv3hxRMtza2hpyIOqx2+04HA4URWFv2B81p9NJXl4eQ0NDMfss9vT00NfXF7PU2ihsR18+XFRUZNhHMbyfY2FhIaqq0tjYSFFRUSi8JbwMOtWeeXrnqZ6ioqKknWoHortt2ac+yranmpipWjjHNo+/3/x7trS/ye133ZKRz9rBzmT9zhIIBALBwUWsfoyGmIhzesLdif+d+d/oRGojdCE04T0BC84poO/xPsNek2bBM9qYEShgLbCSdUgWnlc9Ea8P7xkZjmHpbjzCxtty8ZbkA2rGxU1rgRXXclfMcSRZinaXGiR3l91TxtZrtsaeN7C/9DpW4rdR78+aF2qiU63vLCVvRV7KInasHqNmlKwuYeBfA9FPSNH9LN3HHIajaBb0DnA0LrZ07OOUI1fxt/UP4HYXRo9xAKBPvJ7vcLDR42GjxxPquWhk/E1X2XE6nIVmwTkTJVPjCg4ehPAomFRSCfhIdZ7wvoa9vb1RIqJeSKipqTEtC4637nBxTS/0mdHb2xsqwTUSNcLLmDX3oRFz5syhoaGBxsbGCOExLy+PhoYGmpqaIsbyeDw0NjYiyzKFhYUUFRXh8XhiCo/6PoGjo6P09PREBb+sW7cuahvDxbvwtWj7saGhgebm5lBIjlkYTjxkWaahoSF0bLWemFo4z4elF1/xiiM458/f5vFP3EaODz5imcv/Hm1l1euX8chj95GdnTXVSzygmKzfWQKBQCA4uDBLbjbsxRhDnDNjcMOguehoVK48XhIbUZbb44sQkrQ+hjUv1IR6BxoFzzirncHyWt30WYdkUfdKXbSoZZKobCiaGWGB7EOzGftgDBUVdUylfVV70CmZLAqhMJqIcmkDgdVZ7cTb5N2//frk7vGyZmedc3/gTgxCpdc9PgaeGsA6e1z8HBf9YpVN171ifO2RSCq5nlTLs/NW5mErsAXL28NRooVO6ww7H3/2hzx68VqGtrzPMnJwDVo588jzue/xX1Bbuyz2zpqmhAts9W1tgLHxVzsd0ll2rBc+K3NyuKmkRDgLBQcEQngUTCqphnVMdJ7wx8yEBFmWKS8vN+zpGG/dZuIaBHsfLtm3BN89PkbeGMFX7GP3mbspqisyddRpIpne+WiEtka9e3LXrl1s3LiR6urqKEFVcwXqE6TtdjtLly6lp6cnahvtdjtAhEDp9Xr52Mc+FhGkE6snotF+lGUZSZJC62tubkaSpJTEnUQdige7i634mMP5xHM/5s+rvgt9Q6yQcnn9zWFOXn42f1v/AMXFbtP3Huz7Jlkm63eWQCAQCA4uEu3HKDkkZp4801Cci+VKi1VKa51tDYpyBk7FuA7DAHTe2EndK3Wh0u4Ih+SqArru6TLcJs+rHpqOaaL0jtKEEpUd8x2m/Qv1a9r31r6gopNsD0eT8fTl0kYCa+mdpaHwlFCCdXhy97iT1NvqTc55Of5+f5+fgfUDE+r9GS+V3IhUe4wCOJc79/f01DAROh252VzyxBqe/sov2faPl1mMg/OlBVxTfw033P11Lv7YOTHnmu4Y9VxUgAKrleUuV0bEQeEsFByoCOFRMKmkGtYx0XnC54olJIQ7F8NdcomuW1EUVFXF5Qom45WVlbFk7xI2nboJVVWxKTasQ1Zy3sxhydlLTNevFzL1aGXUWrmyltrsdDpDoTM+n4/m5mZ6enooKyujubnZdD4Nn8+HLMucddZZNDY2RpQt+3w+3G53xGMej4dHHnmE8vLyiPJt/f4L329G+9HsmGRKBNOLzx0dHaFtOFhEttyFc7niv3fwt0t+wJ62d6kgG5fHyllHXciv/v4zjjrK2AEqHH6RTNbvLIFAIBAcXOhFu7G+MUO3o63ARtW6qlACdngJdOe1nRGutIH1A7iWuxjdMRrtOgtj8ZrFdH65M9KpFyBSNIuBVtKrFz4Lzilg65e2xhTZPK96aDmuBdfRLkrvKDV10A1uGDQOdDEj2ZLqWMiRQpmRwBouBGti3EvzXzLs+YiV2I7HWIE5YaJfKmXT4WsfaPPyzmKVB66AGTnbWD1YwkoDwSvV8mxIXuiUrRbOuOeLNB2xiP/94GHmYOUC+0Luu+6nbNn8Jt/93tdi99mcxpiFzSx3uYQ4KBDoEMKjYFKJJ0ylcx5VVUPlu2VlZaYiotYPUguJieVA1K9bL4ypqhoh8G3dupU9t+/BolqQlOAfVUmRwALv/+B9Zq2bZThOePm3qqq0tbVFlFq7XC4aGhpQFCVKINTT09ODqqrU1tayc+dOFEWJ+XpN9HO73XzwwQcR88qyjMvlinBPaqnR4fsJCPVb1BKute0x2o9m4o5eBOvu7o4o7U5GJAzfx0NDQxHPhW/DwSSy2Z1ZXPzYLTzztV/zzl9eZBF2LpAXcP051/Kl26/n45ddEPUe4fCLZLJ+ZwkEAoHg4CO8H2NbfVu0U2y8X+CLc17Ev9sfFKiU6BJoIPS+iP6JBriOdlF8VTHOSifb1m7Ds9ETHDvJxGejctyBpwYSC38ZX2frSa2m5buZCD8JMb6ttgIb1rlWhl/XhZooULCqIOIhrbRcEwC3rdkW1fcwbkm2yc6R7BKqP4bzdVz0S6VsWlu79+ESTm9tDSUqWwYGeGbPHp6vro4SH1OdR5ur+vlqtq3Zxp7mPcysnUnJzcal9OHUXX0WBYct4MlP34HLD2fainj5/he4ZPNb/N/D9+JwOOLOPd0Qac4CQeII4VGQETSRRxO9li1bhsVimdSwDkmSyM3NjRKp9CEkPT09tLS0xFyX2br1wpjT6Yx43uPxUPBOQUh0DKG7qxir/Hv58uURwTRAyNWo7eN49Pb2UlxcnJBYqYXEGDkki4qKKCoqMnRhaknW+ue6u7sjticZYVcveulLxPVjxXJIGq3NaBsONmSLzEfuvIqWIxbxyi1/pAAr59sW8MDXfkF7+xv84LZvR9xpFg6/SA7EgCGBQCAQTD+inGK6foHAflEvlXLi8PJg9ouehoJnHJzVTsNy3GRRFfPy3YT7O6aANd/K4jWLKb6qmLb6NobfHI7cpzL0PdZH8VXFoYcS6XtYsrokuC91aCXZ7ee24+/T9Z006hWpZ1z0Mxs/kd6fa7dtC4mOMG5GVFXWbtsW5b5LpTw7nLyVeVQ0VtDa2kpFdYVpAKaeRSdXcckzt/GXVd/FMbiP4+WZbNq4m1OOXsU/1v+ROXNmJzTOdEH0XBQIEkcIj4KMoBd52traWL58+ZTMrxepNGdjOKkKTvr3GQW0+Ip9WIeskeKj7q6ifhwtedrM0aeqKv/85z8N111UVMTOnTujAmG014aHsPT09ITSsEdHR1m6dKlhSIzFYqGqqiokCOp7RgIUFhbS0dFhuN7NmzcDmG5TuLgTLh4ODg4ajqetQT9erOOu31culwvbWzay/pqFvcuOr9hHwVci734nwoHSE7Hms/UUHDqfJz55O84xqLcW8sqDL3PBlk/yx7/8iqysYOiMcPgJBAKBQJB+9OW8yqgSdCJOsGeh5JCwFdhMQ1ySFvgsQSEtpcRoPQoMPD1AW31bYu7BNOEf8NP55U6clc7g9uv3sUEYimHfQ1ml/dx2ZIccKjU3ZPySO+uQLDx9YdfH4+Ly8NvDwQAaYOTtkWCZvOZADRf9zNykCbhMjfoNBsYf1xOvtDyTzDpkHp988S7+csEteDu6qSaHvN02PlK7ij80/pply47I+BrSiei5KBAkhhAeBRlhqss1482vd3UNDQ3R1NRkKhqZiUv6cRwOR5T4uPvM3WS/kY0qq0iKFPwXiR0n76D1D63k5+dHjePxeCJcmPoejaOjoyHXYzhutzuUEq13LIY717Sy5+7u7oh9oznfFEVhRucMZj85OyTKbbtwG5IkUVNTExXC43a7Q+s2YnR0NOFS5kScidpcLS0t1NTUmJZQh2+bfh8v2beEke+PoCpqsBxnyMbwVcO8yqv0FfUlLCKmsxw80yw4vpJLn/0hf1n1HewDe1kpz2Rzm4dTjlrF39c/SFHRXOHwEwgEAoFAR9cvunj35nfx9/uDbrrvLab46uL4b9QRXnr94pwXEy5bjoXFZWHpI0tNeykmHOBCsEy76Moitq3ZZtxDMslybQi+fmD9AANPDyBnySh7FZDAvsg+vgGkX3wcFw23rd0Ws6w4vIflWN9Y9DoUQg5GX69B+fs4nTd2GqZ8owBycAzPgAdJkqh+vhrAUPRrq28zHD+R0BezfoOVOcbl0+Hnohmxwo0mgmNmDpf+6wf860s/Y/uTG1mCg3OZz2c/8jm++Ytvc955Z054DkF8NgwORrg1V5cY9wQVCNKBEB4FGWGqyzXjza937mk9/rq7u2loaIgSi8ycdHp3mL7HI4ByhELWr7Lw3OuBd4MOyN0NuxmZOQKj+3sw6nsnhotmtbW1SJJEb2+vYY9GSZKora0NCV21tbUAhj0uw7dJP45WLj3w3wEW3LEgOLYiYR2ykr0mmy37tgBQVVVFd3c3/f39IeF0y5YtEWMZpWDHEqA1cVdzRybC5s2bI8rm9YQfd/2xsn7byrAaVnoz/m/fXX10XdsVN1hFW297e3vE4/HKwaeamYuLuOK/d/LXi9bieWM7VeSQu8dK/ZHnc//jv6CmpnKqlygQCAQCwZRgJLR4N3nZes3W0Gv8ff7Qz6mIj6liybMQ8Aaikp39/X7TXorJBrh4Nnr2v95IDJSg7Bdl9P6+F8//PIkLp+NjKXvHF66Cb5sPJHAd5WL47eGIHpdpQYGhl4dY1rgsWFYsqxHXfNaZVlqOb0l6G4we9zQbiI5h69BeF54cnXD5eYKhL/p+g8va4RMPwlHbvbRVRTtO45FI6flEsNisnPnL63jt7n/QdPujFGLlQttC7r36dt7Y0sE3v33dARs6cyCwYXCQk8J6gvb6fKY9QQWCdCCER0FG0EQeTVSrmmQLerxyUc3xpy8N7unpobm5OSTyae81c1Dq3WGKEry62Lp1K6Ojo/h8Pnw+H5vYBFeZr3fXrl1UVVVFiJZaL0ZtDdo8jY2NUe8vKiqKWIfWG9KsvF1RFMOy6KKiInp7e5n9ZLDHSnggjiqrzH5yNr0n9ob2lfavkfBXWRkUsMLdi7EEaDOno9vtRpIkVFXF6/VGiLOjo6NRc7tcrojenhr6Y/XS5pcM70zbu+yhH2MJpVPVM1JRFMPgnmRw5OVw6ZNreeq6e+l67GVOtCqU+ov41pnX8bE1n+PKz16a9nULBAKBQDCdMRNa5Bzjv7Hv3vzuhIRHCRNRRUtADk9ClmDJbUtwVjqj+wgqoErGvRSTDnCJ5zwMBNdU90odL81/KWEnpSkq7HtzH8salwGwbc02Bv49AOaB3UkRGAxuUOndpRHiMcCuh3elZxJI3LEZMC89h4mFvoT3Gxx52cNNX/EjAwTGGPhgIGnR0LD03GLeszMVJEniqOvOY/ZhC3jq8z+hVPVTap/F+l88y6Uvt/F/f/9VyMggSC/J9AQVCNKBEB4FGUETeQKBAK2trZNebmpULmqUQG1UGhwe5KK51owclGbl18uXL6e2tpZHHnnEsOejEVpydF1dHT09PQwNDUU45zo6OigvL6empiZqLU6nk/r6+qgx4wWt6Lfd6XRSVVXFpk2b6O/qjwrEkRQJe5ed93vfj5hfj8PhoKKiIkL0S6RfoF6kCx9HW3e4K3J0dNRwnPLy8oRchoYXd3LQkaphJpSaCbd6MuH0bWtrC50b4cE9ySJbLZxwTQMfbH2G2Uflogag4b2ZvHLnw9zwcht3/PZWcadZIBAIBBknU+WcyWImtGjilR5/v9/w8URxLncy8PRAVOjJrI/MouCcgkihTILOL3dS/Xw1ssPgmtrEFZeJAJet12zFucyZth6NgcEALSe2UHZPWfCBBHarNd+a8P4Pia/hZeJpKHGPIJkS9PHScyMh0CyAyLPRYypWhqP1G2z7f20MMDAh0XAi7stkWXxCJR9ZMYfZs7djLcjl+J69bN+ym08uPY+7X/oDc+Yk34NdEJtkeoIKBOlACI+CDw36cmmXy5XQ+3p7e0PCXriAFivIxEjYi8fOnTtpaGgIlXyHo5WCg7GbU5ZlFEWhubk5VF6dk5MTEvMSCVopKytDlmWqqqp4fsnzqK1qhPioyiq+Yl9IJDVDVVU6OjpQVZXa2toIUczsy4WiKCG3qMbSpUsBWLduXcR2auPpe0yG91VMBLNEvzk3zIFCYo6VyPF1uVwZCWZJV//UgX+9xMhvf0jhp5YjzS0EwA6csXs3Jb/ZyCULGxi2qjjmz+LXj9/LrFkzJ7hygUAgEAgiyXQ5ZzKYCS1mopI1f2Jfo0LXIVJ0svC2Ndsiex+GuRqTccUl098xGVpPbcVZHQxLSanvo54AbP3i1kiXZwySEX29G734Byce4mOGo8TB6Dbjm+GmmAiB4aEv3o3eUAiNv89vKlYakQ7RcCLuy2QY+2CAri/cQNHxTuSKU5EsFpzAYb5Rfrq+mR/WfooOq5+AQ+aaH19Hw9kfSev8H1aS7QkqEEwUITwKDjr0AlxZWRm1tbVxBRqXy0V5eXlUn0Yz11osASjWXFrZsNG6N27cGNUrUT+HJr5p7j9NmNOvWy+MxQpaKSsL3mVuaWlh69atjJ06xoLWBaFAHMZvru9u2G26Ng2tvFwrWdeEwlhfLjpndEaUTGthNWahLVrp/kSSpCeS6Kc/vna7HYfDEbHPy8vLM+L0LSoqihCmk3VVqqrKznsewtr+N/I+cRxS7vj2KirIEtLs2Rx23fH88tXXUUYDNLc6hgABAABJREFUDL07xDcrLuaawOscVrUU6+rVyMcfn85NEggEAsGHlMko50wUs0qIUCCKjsVrF09ovljXIWbCkWejh6xDsqLEoFAqchjJ9ndMBnVUDY3tOtKF5zWPobCnJW5b8iwMvz4cZ1Ay4kQ0DMlJI/4Bf2riq4EQGH6DXkWNHDeJz0ZOZQ6+Hl+UmzYZ0dDsBr3+PJsIe9s76f/m15lz3qHIJZGfJ8nuwFl/NDcv7GCsexD/Xh9PffXn/Lj5da775jVIkoTNZkvbWj5s6HuCWgge35tKSqZ4ZYKDFSE8CqaUWOXAqdLS0hIhwGkCmJHYpu/lqDkH9Y8buRtjBdjon0sEs16J4RQWFkZsZzIOzlhBK8uWLeNf//rX/vlLYfuN2yNSrbmCYCBOGHa7ncrKylCidCyx0/DLhazy2rWvseurkX12ZFlm586dEY9lIrQlkUQ/I/THt7KyMiJdOxnnZbJUVVXR09ODJEmhHo+JovjG2HHjreTlbMV27olIM2aAomBb9lGshYvx73wXX1MjUlY2M04K9gfNUhRuq97Eg7/J5nebA+y5+Pssv7COq3+6Ju2fXYFAIBB8uJjMcs54mJW5KsORipIlz8KSHy6h+AsTD5Yxuw4xE0H9u4PpyOG4lrsovbM06sZp0v0dk2V8bcNvDwfFR32qswWc1U6ss6zsbd9L1hFZDL85nDHnoSEq6XFkxsCsFD8uumTtcIej6XoT/GwUnFMQncCtQMGqxEuWYwnjGwYHWbNtG81eL7WbN3NTCmnI/f/8D74H7mD2ZUcizZkLgJy/EHvVR1ADY4w8dT9SlgVb5WHYxnMPL1jRy8a7/8M3f/1vRlWFviV5/OHZ+3E4HEnNLYjsCaqlWt9UUsIKESwjyBBCeBRMKbHKlVPFyG1oVi5tJJQYBcbo+/l1dHRw0UUXoaoqW7duRVVVuru7Q2NXVVWFErP15OTk4PV6426Hw+EgPz8/QoxUVZWmpiZ6enro6+uLO4YkSTidTsrKyqiqqqKpqclw+wOBQNSaRkpH6Lp2v7hmt9uRxiLdmkuXLo0ofdaHrYQH5IxuGjUMc1Hfie61WVhYiCRJpuJtJkJbksGs3H0yEqxlWWbevHlUV1djsVgSfp9/YIgdn/8qs4+0YKk6FslqBVXCfuzFWJz5AFgLFyOfdAWjL/wJVR0DSUKy23AcU82n5s9B9e4jsHeUVx/ZwmVnXMm8Zfu/dLW1vc5ll31MNAEXCAQCQcJMVjlnIuiFloA3EBSVwkUgC+Qem5sW0dGMwQ2DQRedvgZSE0N1j1tnWQ2rNdLR31F2yije2Kqdvy9MDNXWOX55EpGQ3UuwlDrDQqCGtcAaWl/aSNfax92DBasKIqqBIM74OrHSrC9q3+N90WuVoe+xPoqvKoYNG2DtWmhvh8pKWL0aVq6Mms5IGNenIT8zMMCz42nIFZuJ269VVVV67/g/bJ3/JPcTxyM5c1FVFduSI7EtqQVAkh1kNVyF7+V/EBjoCl6POmzIRUUc+c0V1HbtBEWhb8MOPn34eVz5q29gs+93Px52aClFRXMTOBAfbrSeoALBZCCER8GUkq5+deEYuQ2LioqSFoY0N6aRgOjxeGhra0OSpNBzmnCnzV1eXh4hxGml3JWVlTz11FP09/djs9lMRcj8/Hz6+/sjHuvs7DTtLVhWVhblmtQCdCRJoq2tLULkVVU15OycO3euYfl3OOFBOZrTMVzMLCwspKamhs7OTiAYVhPuUjx80eGwk4iLYK1vpB5tLS6XKxQiEz7/REJblP/+F883voG9owNfeTmuH/4w6dLhyRIZ08W+rdvZdf0NzDlnMdIhhwRDY6xZzFhxEZJtRsRr5excsuq/AIC6YAEjn66HE5Yjzw9+ybIAx5XOZ95v/kfTo2+EqqICj77Bp777EN995ueUlS+ZxK0TCAQCwYHKZJRzJoMmtAxuGKTluJboF2TYjRnRliYM13IXI2+PRJcNB2Dg2QEGNwwCkaKPJc8CyRXfRKF4FebfOJ8dd+yI/UIVsg7LwtflC4m1crYcdIuGlQpjCZZme5u9qGNpqKuWMS3Rts+1M/x2nPLuJMg+Ipt9b+5Ly1hZh2Zx2G8OY9saXTVQPBTIqciJ2xd1b/veaAFTGX98wwY46SRQVQgEoLcXnnkGnn/eUHzUY5aG/Lu/d3L557wx16WMjrHj+jXk5W/Dds4JSI5g5Y29uh7rnEUR80iShGPFeaGfx97dxNhbLyK5crEelgtAYfkSfrqwmae+8BPGwj4zz/gV5n6pnmu/cXWCO1YgEGQaITwKppRY5cqpUlNTE3IiQlCQS6XsNdyNaUQskbSjowOXy2UYetLS0oIsy1RUVFBVVUVbW1tIuNPGDU+1TgSXy0V1dTUQFED37dsXEQLT0dFBbm5uxHs2b94cEvOSLQvXejeGuxy7urqoq6vj0ksvBaCxsTHiPd7zvGS/lo0iK0iKhCoHLxCM+kZu2rTJMMRGE29TLmPesAHp5JNxqSqyouB49VWkk0+GF16IutjKRBuAyWTwxU0Mt7+NMrwPXnyEOR+vQyoK9s6U89zYa89EkmM7JqWKCrK+fz9jTa/jP2k5OGyohy5BypvJki+fwBLPftFcVVXO3/Ied59+Hbs/upQZOVl8pOEkTjvtxIxup0AgEAgOXCbSbzmTxCpTzqQbM6otDYRcjYYp2ABj0HJCS9BNCEHRJ12BMhL0/iEBU4BCZA9HFcO+mATA0+xBkqXo51LA4gpexxiVO+97PT0iocbYB2Npc2qOfTBm3sszHH3Yjgo7bt8Rs/fj4IZBlFGDhWpO4rX/b7/oCMF/LZagA3LdurhrN0tDrvyl17Bf67s3t+G+ZA+qP8Dw009QsHIGlmXHIlksoMrYj70Ii3NW3Hlti5ch57sZa1mP6h9FHd2LNMNO9ulHct7y/oj9pOwZ4uXfPs3H/vUii6rLKZ5fxNVf/hR2uz2uW1QgEGQGITx+CJlOgopRyWqq6LfrYx/7WErbpY2zefPmmK/TRFIj0c7j8YSciXV1dYblyGal5Uap1g6Hg4qKiqgAGY3y8nLa2toMn9PW43Q6Ix4LdxDqsdvtMZ/Pzw+W5sZyrOpF5bmnzGXJv5fQdH0T6jtBp+Puht2MHDKC0+mMcH6aJWfn5uam5FrVzonaNWtQx0VHAFlRUGQZyeBiKxNtACYDVVHo/u7Psb+7nmy3E2wWrJcdh5Q3E1VVsS5Yhq38mKDrMR6rV8Mzz2D71yvYGjeAxYK/fCG+H38l2B/Ssd8tKQGOEwu4oeht3nrgdfwKvPl4C1854UnuvP+2xOYTCAQCwYeOVPstZ5JYrsZMujHNel7ueW5PUGQzE74yVbqsBvtKppUxgsEpaSDl/orJIpuvOZd2FvEgTt7ByxLe4zKGqIw5nJbKbdhqQMNC8LgaJX3rj/e4EzfkmFV0b5DDnMQXt+8XHUPvDwTLrhPALA15ybtEbYfF+h6zLX9lxpvZSBYLrjMXIC1egiRJSLYcHMdeEFV5EwtL3hwsJ30cAMU/3gdyhgyzI3tXWgoKWPnN2Sx+4BX6NjThGZa44hePs/YnP6PrvPdjujIFAkFmEMLjh5DpJKiYlaymIo6ma7tiOR3tdjsFBQW43W6qqqpobW3F5XKhqioulwtZlqNCVsLFOL2L0cjVaOSkrKioCCVZb926NWJ8l8tFTU0N6+LcpdRcima9J8OZOXMm+/btY+/e4IV3eMmPxWIJ9cs0cqxqx667uxun08nw8DAWi4VAIMCLe16k5wvR26yVU8cjWUes/pyobG7GrkRercmKYnixlYk2AJkmsHeY7VevJv+QPVg//hGksH6LqqJgrzgNq7s08QFXrgyW3oT1AbLedBPy8hoC29ohsF+c9r/3JpJNwXpYKUd8dyGoKpV7Bqm6v5lVZWehzHQwa34BP73/h+Tnx7+zLRAIBALBVGEmCLmOdsV1Y07EUWU2rzqq4h9NswA4HTES2aYDCvgHo/d/Lu1U8xUkVCQU7PQziyZauSum+ChnybTVtzH08pCh6GjJs5B7bC6ejZ7EelSOuxlDjlmdMGnNt1L5WGXw3K2sDJZXh4uPFkvw8QQwS0POrXSiPr8/YMiR18QhZ7+Ic9VKpFn5kds/sxh7TT3SBIwvstVG1pmfJ9D1Jqpnf/VUwDOAMrAdKS+PeVefyrxAAMbGqH5hM2u/8CU2OxUkReYM70dZHliWcFK4QCCYGEJ4/BByIAgqqYiI6dquWO+rrKwMCYCNjY0RwuGhhx4aVX4MwaCUjRs3snXrVvbtiyz7MOqrqBfzwpOLZVmO6h1ZXl4eKueOVTLtdrupq6ujt7c3rvD4wQcfmD43d+5cnnrqKebOnUtPTw8WiwWLxcLSpUupqamhubk5ynkZCARobW01HXNsbMz0Obvdzpw5c1JyxOqP5Z4FC5izezdSmPioWixIBhdbik6g1P883fB176L7qq9QcGoB8hFH7r+YUwGrHcdRDVhcc5IfeOXKKDeoDMjlR0U8Zjv8OEZeexJlcDuSLSh4SnPncuh1J/Dbp5oZHRjBu+sDvl31Ca5pvJ3KZUeksJUCgUAgEGQes96TpXfGvnkX0aMxBUdV1LyTgCXPwrLGZbSe3JqevosTIdHptRCbycTgUnURD4ZER2D8X5lFPEg7PzQdStmrGJfNBwdB2atQsrqEbWu3RadT6wnri7rl4i2G+0V2yPsF8/FqFiyW/WXWkgQ33RR7nnG0NOQ127bRvGcPtTNncnNJCUtvIXjuWwI456zjkEt34DjlRKSs7OAbVUCSsC6qxnrI8rRUwkiShHX+4RGP2QB/fze+V/6G5LCDxQp2BzlnHMWaotcZbOsl4FN4vuVZ/vL+u1zkW5XRvq0CgSCIEB4/hGSir2K6SVZEVBQlShhKdbuMhL/wPo1GomP4GvXl42bl0RDsx6iFsyiKgiRJwZLg2lp6e3uDZcGyTEtLS8j1GT5+YWEhqqrS2NhIYWEhtbW1bNmyJcJBaLFYWLZsWeh1ExHQ9IExGoFAgJ6eHmRZDvXWTBea2JsMmutyaGgo4vGOiy+moLUVVZaRFQVVloMXPgYXW/oLoulcKuzZ+AZ7bvkmc85firww2JxbypqJ46jzkKy2OO9OHzOOPBN1dB+qbx+BPR8w1v5vpKxsXOcehwuYHQhw62ubue+cb/G9wChjssppXz6fL33185O2RoFAIBAI4hHee9K70Rsqs922ZltMB2NUj8aw/nuakBTLCanveTnWN4Y6mlkxMDAYYFPDJuzFdka36SpQ5KBbzt/vn5Qk6kSQHBLOaif73txnWGqdSumzhiXPklT5tpN3QqJjaH0oOHkn/pvN9qcKqrL/nDEUHiWwzrYiO+SIvqgJpcQbVLNw002wYkX8NWtD5OXRWFFBa2sr1RUVWCwWWAnL1h1Kz7duYsE5YFl+HJLNBoqK/chzscwsTHj8iWLNn4fljKtR9w6gBvyMbvg70gwLttoKCmorALiot5fF97Ry73s/xB9Q+fnpRdz/xK9wOByTtk6B4MOEEB4/hKSzr2KmSFYcbWlpiRACw12CyWK0f8LLvJuamgxLpLU1auKgViquF7/CGR0djSrr7u7upq6uDrfbbej6DC9PNwp3qaioiBgzEAjQ29sbtX+8Xi979+5NSojUSq+N2LlzZ8LjAKHyaz0ul4uysjJ27tyZ8PmpL83Xi71OpxOXy0Wn3c7uG2+k9sknye/qYu+SJcy95x7Diy232x3Ra9Ptdie1fZPF7r+sx//3nzP78qOQxnvcyHMOwV55ypSIpZIjG8mRjewqwDJ7PiPPPQB2C5IsI1ksOI6p4guFM/lMTz/KyBgbH3qSazZu4aa7voXFYmHu3IL4kwgEAoFAkGHyVuZRsrpkf888BQb+NcDAUwOU/byM4quLo95j1qPRs9FDy4ktoed8XT4G1g9Q80KNofiolX221bcxsH4gckyZYEmykbMtRzYMdXEd7QLA85rHUPAKDAaMBTcJFq9ZTOeXO6P7Bk4RxV8upusnXaiB6PWkWvoMgAWW3LaErVcnfgPdyxLs9EeIjyoyXpYkPIYhCng3eslbmUfZvWVs/eLW/W5QGSRZ2l86HUbCKfEG1SwTZWT7ToZ+egMLLy9EPuzQYOWNbGPGyouRZmQukMkMSbYguYLXlFlnXsXIf/+COrwbZAlJlpGLijjyGyv41eZ3QFXoa9nNpw8/n5saf0LezFxmz56FPaxlkUAgmBhCePwQYtZXcTqRrDiqd0TKshwSC5PtFxlv/xi5L/VCZ7xEbA2zEJeOjo6ox43mNXKGfvSjH6W9vT3i/f39/RGvk2WZj33sY9x3331x1xiOUWm4HqfTaVrKHb69ZgEy5eXlEfvf7/fT2NhIf38/+fn51NfXY7VG/urSl+a7XK6I5/ft2xcKr9lZWsq6a68FgkLu3PG59OdJVVXwon8yBPpUepqqqkr32l8wo+c5XJecgJTjRFVVbGXHYlu0LGNrTQY5O5fshi8CoKoKI/9+CNiHZfEiLIuDzszj6vbg/s3/+O2RVzGGymanwi//cx9z56ZQFi4QCAQCQRrZtnZbSHQMocLWa7biXOaMEg3NHGfKsGIoSHbe2EndK+bXnGZCknWmlbG+6NpfZa+CnCOj+lSQYcYhM7C6rIzuGMUx35G0azH70GyKryrGWemk/dz2xPoNZhIZen/fGzwmBpekqZY+azgrnUm5Ht/jMmbRBMhIKKjIqEi8x+VJbJQxmsu2+OpinMucCSW/T1VKvOfVLQx+/1sUXLAMecECAKTsfBxHnYtkmXq5QZIksk64GAi2Q+j704u4z3oPKTcXx4pqAOYd7eenzzXz4Ee/zh5FZbs6Rv2dX+DCj50zhSsXCA4epv43geCgRRNTtm7diqqq1NbWJpwynaw4GsshGatfpJngE0sIMprL7Xazbt06CguDZQRbtmyJWqPdbsfhcOB0OpEkCbfbbVqGbSTcGbk+9WsZGhriz3/+c5RoabVaI8qvi4qKaGlpSUhIdLvd9Pf3xw2A0bY9lssuVlK2Npde4Fu3bl3IrdnT08O6des4++yzI16jF2D1vTT1rk6LxUJ1dTVL9i2hrb6Nve17CSwM8O5x7zJSOjLpoUuJ9jQN7B1mcEM76tat7PjZn8lf8AHWs04IhsgoKo7aBiyz50/KmpNFkmSyTr0M3+b/4n+/HVQVHFakvJkc8qXjuWHnB6CoeFu2s7buSpb+v4tw5jo5+tjllJaWTPXyBQKBQPAhZG/7XlOxziiQwkgoBAxdiADeVm/M+c2EpG1rzHv/heaSYPj14aBDUgn2m0yWfa/vo+mYJkZ3jJJ1SBaegfHr08nurzhOrtLOoj7zMuoJlT6PC8GyTSaQ4AYOUUkrd+lKuy9niGA5r7bvJ0oyye+TkRKvqirejW+ibnyTD17aivzKn8i//Bik/NkAyIVl2JeeNC3bFOWtzCNvZQP+PTsZe+Ux1MBYUNC32cg+dTmfO6IH/H78fR7+dcv9XP/0Sxx50nIK3XM55ZTjEv4uKxAIIhHCoyBjtLS0hES15ubmUKpyuggXB7X+hkblubH6ReoFn+7ubhoaGmIKQbF6OMYKd5k9ezbz5s2LctBJkkRvby+Dg4MhV144DoeDiooKQ8ed9piWVG3mNNy7dy9FRUURKdWJhu/IshxVvq3Hbrdzxhln0NTUFLO0PB6SJEX9Qde7NfU/Q7QAq7kpzcq5LRYLpSOltJ6yvwG82qOy4NUFbL9xOyOlI1H7JxVXYqIYnaP6+Q7NKWD3DV/DOXeYJbKEvWoR8hFHIVksgAX7yguxZGf2jnY6sFccj73ieAD8fTvwvfp3pBlZSIuCDkjXooWsWbiFDXf/HZ8Cfxl9AOtnTuZr37l+ClctEAgEgg8jOZU5+LqMBTujQAojodA/4MfzqvH1mTqq0lbfFrNvpF5IGtwwiH8gAeehdm9ZE75SFAu1tWvCpWu5i9Edo5PSfzKcRMqoEyp9jiEGel714DraxVj/WMKC4RCVxm7K8f6YskPGmmdltGuUgCcQFKPNMxVD73Utd8V50dSgjI6x47o1zBhsZnGWjLUgB9slJyFl56AqKvZDV2JdWJHS2BNJhE8W68xCrGcEe4wr/jFGnrofaYaMVBxsoWBfBGcvLOSQe19jx3/eoCsgcUneT/jdiw+Sk5OdkTUJBAczQngUZIxkAmKMRB0gptCjFwfr6upoaGiIGjuWG1K/pp6enqh+kdrjiW6nGbt3744KZqmrqwsJmo2NjYbCY35+PlVVVYb7QnOGJpJU3d/fH3IcNjc3J9yzUJuvu7vbdD/Mnj2bTZs2mYboJIqRAzM/Pz9i3lmzZvHqfa/iudeDbbsNuVTGe54X92Fudu7cGeFuNBMeIdggPrwBvKRIqLLK7Cdn03VtV5TDNJWk9UQxOkfD5/M+30TR2xuZ8/FamFsIkhRKrZYcuTiOOR/JeuD1obEWzEc+9dOMbXoOdXQfyuAupCwb9uWVnHRYCSgKp/cP8tpvXuD8J15k5pIiFiyZz7e++xXR/FsgEAgEGadkdQkDTw1El/XKusCOMPRC4UvzX4o5x8D6gYSTrwc3DEb0ipxUxuccfnuYyn9UBhOX9f0nM0giZdRxS59lsLgsBIYCMRO0JVlClSaYLK4E06SXPrJ0f9K5QmLJ3RKRfRk3bIgMg1m9OtinMUOYCYBjuwfp+twNzF4xA8vSj4LVFrwmlaRg5c3ys7HMmpfynBNJhJ8IstVG1pmfZ+ytV1F2vY86uhdVHUWaM4cjvnEKR/hGYWyMU5/awhePuBD56MU4Zjj40je+wNKlh2Z0bQLBwYIQHgUZI5GAGE1w1Bx7EOkajCX0JCpsxuoXqV8jBN2D+rLicEFML0A5nU7DefXE69loFvLS09PDn//855AoqTkzw5O2jbYj3vxerzckWhq5Le12O5WVlSHRU5ZlnE6noTja09Nj+Hg8tLL28DUpihLRn7OoqIjdu3cTCASYM2cOljcs7PvWPixYUBUV/24/M16dwfYbt2M9whqxnQ6Hg8rKSt56662I9fl8Pna/ths5EOlYlBSJrN4s6urqohymibgSjQTzqqoq2traYjoljc7RdeNNv+e93MHR0jvkXHYcUt7M/W9SVeQ5i7EvOw1JmuZlHzEumOUZOTiOOgsIfs5Gnn8YFA+SM3inX8rN46hvzOTOR17Fu/N9Bt9+n08/8l9uf/F+3PMmLyFRIBAIBAcmgxsG2bZmG95mL5trNwd73iUoZOStzKPs52VsvSYscGQ83CMqsMOEnMocfD0+cwddAFRZpfPGTqyzrKZur8ENg2xq2DRlZc4a/j4/rSe1Unp3abCsPCElLZpk06cTKaOOW/qsELd/o+c1D64jY4fxJMR4mnRU0nkCu8u13LW/L+OGDXDSScEWNYEA9PbCM88Ek6lNxMeJOAfNBMDD/5DPyEO3MGfVIUiLl0SWUVscOFacj5yVuktTv59yA8HzI+vUbXBybcbFVkmSsB92DBx2DAD+7W/g2/JvpBkzYMYMAPIvXsmd7la6N2zHPwb/bPgazd+5jMs/dXHG1iUQHCwI4VGQMWpqalBVla1bt1JWVmZYKmwWwpJIkIqRsGlWDmvmTDNy8hk5B8OFIv06vF6vqSAXC70QG6sPin7scOekJorq3X2yLCNJEhaLBbvdHjXGvn37aG1txWKxcOihh7J582ZDx2FLSwstLS2hn91uN7IsMzQ0FNdlqUe/n6zWSKHQ4/HQ0tISOl76ub1eL3kPBC+cJEUK/as5FXcdsStivpycHOrq6qiqquLBBx+MmGvYPUz2nuzQOABYYPaRs6mqi+6NE8+VaCaYh59fZk5Jo3O0cM5ccn79d6rLR7CfdCLSjCxURcF66PG8sXOIpZVVWGccAKUeSVwwS5JE1smXEujvQRnahTr4Af6eDqTcXOZ+9jTmqir4fPz0hTZuP+aztGcrYLfw+e9ezarz66dk8wQCgUCQPtJdaqkXUQaeGWDPs8m5qJIJ9zAi1PcR1VzEUsZLmi0Yur1C2+FPc2nz+HzJovpVev/QS/Xz1SmFzqSSPp1ogrRp6XOiKMEUchh3R8YSKs3KtsPSpLdcvCXpfWx981WG5lyLo78D2eLHGlCQ1PGJAgGwWII3dA2SqSfqHIwSSgNgyenA/5d/UvCJ5Uhzg99fpDw3HcpsjqiowJLlmnA/x/BE+IjzY1SB9evjiq3pxrrgcOS5iwj0vg2BMca2bEDKdpB18nKWnKiAolD6/g6evvMhzvrBH1AtUH7CMu745fdFH0iBwAAhPAoyhizL1NTUIEkS1dXVhr+EzVyKmigXyzFp5BJLphxWEym1oJdYYlr43Ebuwry8PA499FB6e3tjCnJ2ux1JksjPz0dRFBobG0Nrd7vddHd3G74vFlu3bjWcT3MSBgIBZs+ejb/Vz+wnZ2PvsuMr9rH7zN2MlI4QCARob2+Per/P56OpqQmLxRLxuNfr5dJLL2Xjxo0RpdWlpaXIskxPTw+qqiLLcihwRuu9WVVVFREWYxQ2s3nzZiB4fI1E3jldcyLFQoLio70rGN4TPqa29ra2tqi5dp+5m+w3svdfNMpBx93oRaMRrkuNWK5EDaPzWd+TMpHSfP8eL7Nvv59Dj7ViqVmBZLWiKuA45gLIzse/qxXJdoCUGq9du190hLgXzACWfDeW/GArAHlhBb6X/oo0ww6SBDNmkH36kXxrXgfDnbsIDPt5/tu/ZM3/2rnptq9P1lYJBAKBIM1kotTSSERRLaphMIzRetIhgur7Pvo+8Jn3+DNZZyhd2wTJJmHJsySfOj2B4BPPqx46b+xEInnBKZX06UwmSEehXbKYiY4yQeei0f6TYdbps0LitGHSeQxyaadycL8oqypE7+FAIFhFohFWWSKNLsKlXMKQUhnalljnvP4892z0hK1VJWvWSxxyfjPZDccj5eahqiq2khqkklrG2tqQHDlpCZEJ30/68yORa8dMIDuykRcF96O1pIqRp38PtkCw3ZEsY1lSwhmrnRz34puoqsqOTW9wybLzue/lB3G5EquIEwg+LAjhUTCl6EU8l8tFeXl5VDiMvkQajF1iyfSV1Lst6+rqKCoqinJghictK4qCoihR7sKioqLQWpqamkyDWDTxq6enx9C16HK52Ldvn2lfwlQZ2TjCgjsWAEGRzjpkJfuN7FCQSiz0a9m3bx9/+MMfsNlshq/XhNzwkmJN5H3qqafiOkNHR0dD+89I5PUV+7AOWSPER1VWCSwMUFZWFiGGaoKx0XkwUjrC9hu3M+/Zedi22/DO9bK7YTcj/hEsLZaEXIlm7QTCH9P3qDRqORDO8NtdfHDdDcxtWIBUVoYkSXj2+uh2L6faNSft50bGaW/fLzpq6C+YY2CdVYTlzC8G++0E/Iy+8AiSQ8ZWeRi2ysMAWHXaB7T+7GW+MO8sxiQFb0kev3v6PtH8WyAQCA4gJiISmhHuogoRMA6GCSfdImh438cNczYw1hcvXSRynZ6NsUt+bcU2rNnW5IVHmQmVbpuF5sQjlfTpuGXUk0kswVYJulw1R2xU0nkcokXZoMYZIe1ZLMHWNRBVWeKih2pejXSPmpzzRue5djMeJUDu/Mc55BP92I4/MVhyrCjYl30Ea+GStF+Phu8nZyD6/Ejm2jETSLKFrDM+g+obQVX8jL31GoEP3kIqKMB17nEAHH7mKD95/FXWHvZxdqsB+mwKX3/wFlYcf9SUrVsgmC4I4VEwpRi5yMKdZvHcivr3JdJXUsNIpKyvr4/oNwmEQlwguvQXgi5GVVVDLrmamhra29sN3XxmmLkW4+F2u1FVNe57c/4WbIBuVJ7cdW3s3pB6AoEAgUAgqg9mZ2dnVJ/O8JLpWKnYRmjHI6oUfpmH7C3ZqKhIjDf/BvKvy6e2tjaUEh4uVpv1wBwpHWH4+GG6+rsitifRwKBY/UNj9XjU4+vtxz8wxMg7Oxj+zY+Zc0k1kjuYqtc96OO53Xbclt1UJ7SqaUZlZbC8OvwCNfyCOQEkSUKaEbxznFX/eXyvPEZgTxdIINlsyHPnUvP146h8ezsoKv1NvVy19EKufugWXC4nixcvxOk0DgEQCAQCwfQgVZEwFoZuM4t5MIxGJkRQDedyJwNPDyTkNgx4A7w0/yX8g7EFRd82Hz4irzvj9lCUweKMU0qcIRItm9Yz4TLqWMRIu06W9nPbWfy9xfQ93sfe9r3MKJ+Br8uX0L42FmX3i48qMiiwd9VXcEJUZYmhe9TknI8+z/3I9j2gKsw+7J8s/KQTS9WxwcobPzhWXITFNTu1nRKHcGfwvucOwT4aeX4ke+2YKST7DCTAUXUy/u75+FqeAlkCmxXJ4WDm+StZXfkO6qgP/wde/nTlWpquOYuTPnI8M2fmsmBB8VRvgkAwJQjhUTClxOq/GAuzkmq9EFRZWck///lP+vv7yc/Pp76+Hqs1eNobiZSyLFNeXh4hksVKwYagi7G5uZmenh4aGhqQZdmw5Hfu3Lkx07HjYbFYUBQlog+jLMsMDg7Gfa9th820PFmP3R58LBnhFKL7ULa2ttLR0UFOTk5UubHFYsFisaCqKmNjxnf9FUVh3bp1uN1u3G43W7ZsQdoiUfhIYVBwUse3RwXHNxwsv3K56fkUfl4oioLH40GSJJxOp+ExiedK1DCbT/+Y2TmuKgo93/8V6suPY82Wsc22M+vyFUgzZwGwpc9P82DweGhl6wccq1cH+/JYLPtLZSQJbroppeEkScJx7Lmhn/3vv4Hv9X8jOV3Yqo4AYG7lofxkSSuPffxW9ioKvw6McfT3P8VlV16Yji0SCAQCQQZIVSSMRZTbLKz3XiwyIYJGrUnavybAsHQ3MBhISRhMtIeibJMJTEFazaSWTSdKmkRHCAbwRAQSGdzjNxSGLZXslZdgH9uNFJZCoyIxRi4qtuBrpcvxfNlBdeUgeQaVJRHu0RjnfPh5Lju2U1z3F5zuAJIFck45AumQUiRJQhlzkH3KxUj2rInumpiEnMEb7hh3cUppuXbMFNZ5ZVjnlQGg+IYZfuo+5Gw71sOCj9mATx66nZfvXsfzP30Sj6ry1uH53L/ut1GtrASCgx0hPAoOSMxKqvVC0D//+c+QsNTT08O6des4++yzAaiqqqK7uzskSlZVBe9gJ5uCrdHT00NjY2Mo/TnchVhVVUVtbW3IpamJkAMDA+Tn54eCSmJRVVWFJEkRoujQ0FBCAqFZebK0JLonS/h4Ltd4ql8Cbkx9ME0gEMDj8Ri+V3NNajidTlwuV0i8zMnJiShFr6mpIT8/H/nJoPM0JDoSTJbMacmJcMqGO2LD+0wqihJT/HU4HFRUVBi6EtNNYHiU7dfcRP7CPqyfPxWsVrDakGw21ECAFz+Abfsy+yvazDmcVlauDDYDD0+1vukmWLEiLcNbFx6OlFeAb2MjjPlQFR+Sw07WyXV8rGIXKAGUXXt4+o4H+ewTz1FedxgLFhbzsUvPFc2/BQKBYBqRqkgYi5CLas029jTvYWbtTEpujh8MkwkRNGpNurCazhs6Uy5d1pNQD0WVYOBNGp1+iTKZZdPZR2Sz7619yZeUazbDDGAmDLfxE6QLz4U//S/M4Qig8i6foodVwQEUQBp34BpUlqiyhdH8cuwOe8wwJO08t2e3seSs58g9ezm4ckGSkGYERUY5t4gZdQ1I8iQKZRm+dswEsj2L7IZr8L32BMpAL6riR3JYsSxcwMrv5LFi714YHaP7iQ4uXXoudVd8hBkOO5defgFz5xZM9fIFgowjhEdB2jESfcyeT1Xs0AuAWu9F/Th6p134z21tbRGiZFtbG3V1daYuNs1t6HK5QmW5etEvXNRyOp2MjY2Rn58fCtcJ7wOpiaU9PT0UFRXhdrvZvXu34bhut5va2trQz1o5eKLl2VqQiiqroTJrgLFLY/cYUlU1LQ2jNWZ0zjAMuBkeHo5wTOrLuFtbg/1nFnctjnJuosCe5j37fxwP7dEnSSdCRUVF0g7cVM5nX28/XV/4CnNOykVeeiRS2F3PMZ+f9Tst7PZFbufOnTuTWlciJBPGNCFWrsxoM3BL3hyyTr0SAFUJMPzU/Uh2kObOBUAuclO/eg7lv36Nvj/tYGBU4tJbH+C3Lz8gmn8LBALBNMFMkEs0PTrWuBWNFbS2tlJRXRHTaaQFbYR6KmqiXIoiqFlATXjPR43RHaMmoyRPQj0UVfD3+5MWHS15FrIPyw4lP6dqmMxo2XQYw28PpyasZkh0BHNh+PBDH8W33gfBZkLjzwUdjwW8tF94hP0O3EeiK0skSSL3sR+zIo5Qt+hbC/G1PkzpRe/iOP1EpOwwYV1VsSxYhq38mLR8F0g6rCnD146ZQJJlHEefE/rZ98bL+Le3IrlykVy5ABR/roh7Gl/j9Yefwa+o3PaTxzn7D9/k5FOOm6plCwSTghAeBWlHL2aEh7MYPQ/Jix01NTURvf96enpoaWmJGkcf7JGfnx/672SCaLR1hweX1NbWRoTE6NGEtHBRUxOptORmjfD+iEaE95msq6ujt7c36vWSJEW5Du12Oz6fLxSkEi76DV80jONQB/REv16/DbEwmteIGZ0zEg640Tes1sY3c26OuEdobGwMlVEnsm4IOitHR0cJBALMmTMn5Ho1w0hkTPR81t7b9+omDnviH8y9YClySUlwf9hdbLMV8mZHJ/2jVvwGuzPR8u9kSPYzcCAQbP79WfzvtaP0d6N696CM7kEqKOCQr57KIQE/+Hwc8692vnLExewpzceRZecrt1zL8iOrp3r5AoFA8KHGSJCLR7rSp/VBG5roaCuw4VzuTFoEHdwwSMuJLSFhztflY2D9AGX3lIV6/4WvN9n041gk3ENRIWlnX/Zh2dS9UsfghkE6b+zE2+pFVVRku4yyd5Ktkwmg+tW42xe3H2aaMROGpdc344CIMmvGf44K3tEcuCurQu5AZWMbXhbzHlegrMmhZPWg6WchsG+EPb/9PodeNYD16OOQbHaUkQCK62iyK4uQZjiRs3LTsr2ZSKw/ELAffiyWeYfgf6cNAmMEdr6NNMOBa9WxHH3GCKgqR3e+zyNf+DH3zPkZ8gwrJzScwJdv+FxajR8CwXRACI+CtKMXL/QiUDrEjnAhLtY49fX1rFu3LqLHo0ZhYWGEGy5eDz39+Dt37sTtdoe2z6xfYPh7UwlZARgcHOSJJ54IiU9DQ0NRr9GXd0PQORkuPnZd2xUpFPYExUaHwxF6f7K9HVVVjUr51kq0ISjuSZKE7efBFOxEAm6ysrIMxUMz5+YHZ3zASFfsdG4Nu93OnDlzosque3t7aW1tNQyn0cTG8Pdo547+vPjg3x/Qtrot6gtFS0sL2/7vMVb0tJL3yaORCuYAIBeUYF92GuUq7LXlYRufR0MLTcpE+XcyYUwHEpIkYStZBiXLAPB3b8XX9jSS3Q7YISubmReu4MfFmxho3onP5+Wpi79D29cv5DNXT2F/KYFAIBAkRToFjaigjXGno3O5MySGJiNydt7Yadgncus1W4N9HXXrTTb9OBZJ9VBM0tnnafbQVt+Gd6M3mM49LtAqY9NPdATi7stE+2Gmk3jCcNRzsgWvsiR03kQ5cFeuZHD1w5HC+foBw8/C4IZB3v1OG9lDP2PeJ9zIRxyJJMuoYxa2/aGawZdGyKncRcnqHPJWpmd7MxnWNN2x5M3FUnM6AMrYKMNP/RY5ywZZ2QDYlh3Ox2/K47S/t6MqPt7+QyOXP/4ffvfM77DZbFO5dIEgrQjhUZB29GKG0+mM+XyyYofmHNOLb0bjWK3WUE/HiWJU3h3ugCwrK2PevHn09vYyODgYIZxpQpJepLLb7VRWVqKqasRYWtm1JgJ6vV68Xi/d3d2m68vJyUFV1SjBTh90o3cn+nw+fD4fiqKYBr3EQ+9QLC8vj3B4dnR0UPB+QcIBN16vNyTqhoupyhEKu2/azdyn5qK+reJf4GfPOXsYcScmOkKwnHr58uU0NjZGPbd58+bQvurq6qK7uxuv18tYyxizn5zNjK4ZFBcXh0rENYFSOy9mdM4g684sBhiI+EJR9VwVww88yklyJ1mfOBHJ6UJVVGylR2FbHBQUJSlDZc4xiNXP9GDCOq8My9xFBPb0gn8M32vrkLLtzDiuBvdxwc/EZ97fwfN3/43zb3uIgATuY8v5+YN3iubfAoFAMI1Jp6ARL1AmWZHT2xqj+sJkvdXPV9N5Ywq9HrV78eNaVUZ7KI4Rmco9TfXGREmoH2Yc7CV2fF2+/U7Z2CHkhsIwIWFYjXpOkiUcP1/DrMdmmbYhSOSzMLhhkE2nPcnClX+i4OpK5IWLABgbyqbtimICw/sy4kjMZFjTgYRsc5DdcA3Knl5Uvw//WxtRRvqQi+dR9KV5ABR5PRzy0Gt8bvG5DFgVlFwHdz16F6Vli6d49QLBxBDCoyDthIsZRi7CiYodetegy+WivLw86XH0PfPi9dDTr1vvbty5cycNDQ0oisLDDz8c8ZwkSfj9fnbt2hXx+OzZs0MCnd5pt27duqT6E5o5R8vKyti6dWvcfpB79xr/8U+0lNrlcpGbmxvlFNSOVW5xrmGZtK/YZ9j7sd/Rz9KlS4HIYJj+ef30f6qf2tpaJEliV8cuiLFpNpstJL7Onj2b6upqwDgoyKhnZ6wS8aK6oojzIvf3ucF0yACACoof1RJgx/U3s+yMIawrjkdyOAj4/bSOFbBi0dTe5U01Vf5ARLLasRYsBMDScA0jzz6AKo0gSRKSJGFZtIBTvp3DipZOUFW6mrbz8YrzuOeF+3E6c5gxwyHCaAQCgWCakU5BI16gTMZcWwFC/RLzVuZhnZX81zPJIqGORV6rJdRDMdVgmQNYbNSXVeeyJX4/zDj4tvn2l6wnsG+MhOEdeVcy5D0cAkQ8N1pQTu5jP8a5YgVVV5mPGeuzoIyOoSoK737tUcrOeYzcC45Bmh0MNPngn9lsf2gROftaWaSMryewhPfky9i2dmZaHImZDGs60JAkCcssNwDWOYvwdbyG/53XkGzBz73kdFH0qeP46bLXCXh9DO/cy69Pu5ajfnYdJ5+6EpvNKpyQggMSITwK0k64mBEIBGhtbTV9PhX0Altubm7c8Yx68yXrvNSvu6mpKcKBqL2/paUlynXodrtZt25dlLDl8XhobGyMCiXRwnImitPpZOfOnVHCodPpDDkd45Go8Oh0OhkaGmJoaAhVVamtrY04VmZl0p4qj6mw1zzaTF1dHQ0NDVEORb2YKssyVqs1KjG7oKDAMESopqaG9vb2uPtg9pOzQ2vT/lVllZL/lqBerLJu3TqKioqor6/nlS+8QiAQQLL0M+ewh3EWepBtKjNPPwS58mgki4WRER//2mnD499DlkFfUkHmkWSZrNM/iaoEQFUZe/NV/F2bkPLzyTr1KAAOOWGUnz7xGr+q+yyDisJ2aYyrH1jNSSenqe5IIBAIBBMmVUHDqGQ6Xqp2siKns9qZsHPRv9vP4IZBAPY8tyeh94SjjqWWTm3Nt2Kba2P49eGk5zwQiS6r3s14tjfhNTkqUnQ/zHgkWbKuF4atNiuSFEC1qAwFKmm3/BBJkqh+rBp0vUW7ftHFuze/i7/fjzXfyuLvLTb5LARwFT7G+2esRbaoLKxzMeP0E5FynKiKQu/dY7z/RDm5UivVqq7cXGliy8afARMXHjORWH+wYC8/EltZHSgKyt49jLzwEHL2DOzHVAMwQ1X5al0nT3z1Z9zsvZt9qsKMMyu54zc/EH0gBQcUQngUTDvipQSnUqptFAAyUedlVVUV3d3d7N69G7vdTk9PD01NTVFOSJfLRU1NTVSgDOwvoQ5fk1aanGhidSy08fXs27cvYWEzkT9qkiRFbHdzczOqqkbMER5w4+hyMFo8yu6G3cxuNBb2tN6PHR0d9PT0GPa1DEdRlAgRUetdadZjVJblqDJ0I+xddsMScX+HP1Qerx2/nMoclIEOSk56lFkXVCLl5YIkQ24ekiThGVV4sseOT4lci9G2TDT5XRAfSQ6WUduXrkQumIdv4zqCSQIWJLuD3FXHckP1dlS/H//OQf78+R/x0qXHs/y45RQVzmVZ1RFTuwECgUDwIScVQSNWyXSsVO2cyhx8Pb4ocW+sb4y2+raofo+ld5RGhMsA5uKgFOwJ6W3yBsNQTJhz6Rx2/XmXcd/CFO5Xyw6Zw359GC3HtST/5gOQ6LJqI9Ex+P+G/TAzhQVcy12UrC6Jm+re9YuuYJ/Qcfx9frZes5X5N86P/CxYR5hT/kcWXpSN5ZDjQZYg2xnsdz0ygv3b91LS1ske+S5KLA8ijRmVmz8AxLBZJkimEusPFiRJBouMJbeArDOuYvSFP6GOekCWkOw2rIeVseqWmZw9MIjq87P18Q4uPfYSPv29q7HZbKxYsRyHwzHVmyEQxEQIj4JpR7yUYCPBMJ5QYxRoY/b6REWftra2kNjm8/lCPRj1PS21bdInbOvp6emJSOqOh91uZ/bs2RG9IBMlWTdlVlYWw8PBu+GJOiBbW1ujXjdSOsLgtwYpKyujpSV4kWsm7Gm9Hz0eT5QIa7SP9Zg5OsOF6rKysojemobjmCVpz4vsK9nT00PRgk7KL3wB5znHIc2cFfH8IE6eHwSfsl8ILSoqSjopW1GU0HmiJcbLsizEygliLVyMteEaYLz5979+g5xtR1pSAoClHD6xuIvme17kvQdf5K0A/GiJi989fb8oeREIBIIpIhVBI17JdHhp6eCGQdrqg4Fx1jyrobinjqoMmAR5uJa7Qr0endVOSu8sZfOqzcFQlnCUYE9I0+srCebfOJ8dd+1IS+p1aNpRhS0f24KcMz0TqdONcZo0UT/7yAv1w8x44nWYWJ63In6q+7s3v2v4eO8fesM+C+/hLv0Dcy9ZglRaGmki2LUb+w13YunpQ0WiQrkJm+oxKTc3nisVUkms/zAi2+xknfbJ0M8jrzaieHYgzZmDZU4wmPKwJQu57eFX2XDVTxhT4Xf+Ub6x7i6WVhw2VcsWCOIihEfBtCNe6rVRqXZTU1NMsdIoGMbs9fGET7N1aegddh6Ph6amJmpqavB4PIYORAgGXCQqOgJUVlZSV1fHn/70p6SFx2QIBAIh0RGiw2mSeQyC+0eSJIqKiujt7TUV9qQlUlRadvgYGlpqdyzC+09WVVXR1NQU6kFaW1sb0UNSw+12I8syBV8pYOSqkeA9cYVQibh6edj2KQoFD62ntKgP+zknImVlo/oVel+czeBi2Fso8XpXf8R6tL6kRudbrM9AuOCtlfrX1dUlfN4K4qM1/x7b9CyB/h7wDaNaQZ5fTN3NedSNjqKO+jjzn2/wicNWUXxGLVlZM7j62k+xYGHxVC9fIBAIPlQkK2gkWjId5YzsinGtoRMv9e/FAt4mL6jBlOyB9QNR5eHaOHokh0T1v6vpvMEgJXuC+Pv9B3S/xmQxTpPWOx5lPBwKTE7i9azTZwUduiohkdsxP+heG90xGpmevmEDh/fdaCiC+vv95K3MY9FXR9n3898y84I6pKJgL8F972aR+/TDSLs+wPJKO9LIKBB0fNoYRFIN9oNsQV4uhMKpZsbRDfi7t+J/61VUxY86thcpO5u5VxzHeecOgaKy6o33uPesr/OzE8vIcmZz2pkncmbDaVO9dIEgAiE8CqYdqZRSxxMr9YE3HR0dpq+PNVa4qyxZ1+Drr7/O0qVLo3oTWiwWsrOzTQVJIORo05Akie7ubqqqMnNB4Ha76e/vZ3R0NCPj79y5M5QWbNT7UZIkXNe4DEVHPQ6Hg8rKSnp6elBVNbSv9CKumZtQ6yEZyzE4eNgg29ZsY0/zHvwL/OR+MZfjrzietrY2dr77PiUPPsGCIy1Ylq9AstoY843x7C47uxYMBJMNdRlB4X1Jjc63WJ8Bs/Mz3mdAkBySLGOvPj30s6/jf/i3NSHlOCHHiQS4PzWbn7k38v4rmxjzS9z751c58Zdf4YwzT5m6hQsEAoEgJon2hYxyRsYjTLyM5aosWV0SFB51OKudwZAZ3XwWlwXUOCnZyWIlKDh+iERHMEqTDibCqEjjZdcyaihderw0WwJJTT3xOhauo12GQnW4yK21Aqi7ewTntWeRj2IsgqrQevRPKT7iBWZedhxS3kxUVaXr//LoeqiQykAf+XILkhJ5gkm6fwGwWIIuyZtuCj2k74u64JsL4MOXDTMlWOeVYZ1XBoCyb4jhZ3+PnD0D8oPtqmYcX8C1Re+w9YE3UAIqbzzVzhcffIKfPXTXVC5bIIhACI+CaUcqvRfjiZXhLsmmpqYokS88fVs/Vm9vLw899BAulwsgyhWnlR7HK3keHR2lubmZnJzIv9KBQCBuP0ebzRYhAmruyCeffJLs7Oyk+0HqnYROpxNFUfD7/aHHjzjiiFA59ETIyclBkiS8Xm8ovdr5gRO5VGb3cbtDvR/nPTsP+T0ZZZHCnnP20B/ojz/4OHpnnyYiar0yNddpd3c3/f2R42q9N2OJuHkr86j61/7ntfE/aH+L0of+yrxzFiEfeiiSLOPd5+NfH9gZDpiXo4eXWOt7V4af80afgaKiIsNQo1QE++nEdC8Vt5cfhWVeGYGuN8E/hv/dNqQsB86GYzjiDD8oKhVvv8dfr/8pDf/vp2CRWHJkGXfdK9wCAoFAMJ1ItC+koTMyFmHiZSxXpXeT13Dcok8WBXs8ymqEIOjv99N6Umt0TXCqWMA604q/zz/hodJRhpzxUuYwjNKk+1hBAS+FzX85Q3IFriNdzHzzfaRBvVCXXOK1huF2/q+S5+3PB4+32bk2LlorN38PVKM+jA/Szq243E9QcsJO7CediDQjC3VMofP7RfS/OBOA9+TLyFebwGKBWDf2ZRlOPz0oOq5YARj3RR14ZoCsX2ZBddK7QjAB5Oxcss+8Bv/2LTCyD//7r4MlgLVsCYfdtABQOWJwkKrftXDeIWfhy7Vhcdn5zV9+RlHR3KlevuBDjBAeBdMOWZZDzjStF2M8ESIZsTKeE0x7r5Z4HAgETENaZFmmoaEBiCz3jsXevcbph7A/EEUvJJr1h9y1axfZ2dlx59SXI2si29atwebUpaWlbN26NfQabS632x0xryRJwfLjggLcbjdtbW1x+z2OjIwwZ84cluxbwvAdw8F7yopKoD/Awv8tpG91H2M1Y8y8eCZA3J6LekZHR9m4cSO1tbWhc0QTmnt7eyP2pdE+HB0dDYmS2vOxSpUVRaGxsRHPK+2sbHuJOZfVIhXPB6B/BJ7rdzIciBag3W536BxSVZXm5uaIbQ0vv46V/F5VVUVPTw+SJIV6PMLEw5KmmgOhVNzinIXl0GNRVRVL2dGMPn0/UpYF5GA/UusR5Vx8s4uPPPsmakDhneYOLj/+Mv7wwv9ht9unePUCgUAggMT6Qg5uGEQZTcIOqBMvzVyVjvmOiGCQECr0Pd5H9fPVtJ/bHikKKqBKKpYcC4HBZJRQHXJwDa7a4I10z0C0uzIZ0lGGPBmlzHr0adIAPayKfJECnv952KMuJJ8PdKXZcuKJ1xJIdonCQzo59I3rQVWQADt95LORFvUnDI0lsJ0BcPR3QJRbUSFLeo+CQ//AoitmYKldiWS1EhgKsOWrixl+Z8b+7VYq2VzwMyqXPwbt7TA6Cv39oERumyf/GNTVD0d8HowcvFjAd5+PwbJBtt+6PSIhPrzPaUbZsAHWrg1uT2UlrF4NK1dOztxTiGSxYisJfpezHXYso01PE+h/B0nrOV4wh9IvH89vnmnB1z+Ct2+U7x95JZ99/EdU1VRM4coFH2aE8CiYliQrQoQLNcmmYkNQgNOEK20soxRqPeHlz+HCj1GpbyI4HA5yc3MjxDKXy0V9fT2tra2Goty+ffsifjYKfykoKKCwsJAtW7YQCATo7u7G7XaH5jFyNvb390eJJaqqEggE2LlzJ7IsJxQyEwgE6O3tJftX2Vgla+RFiwxZf82i/9p+mpubQ67SWDidzojgGJ/PR3NzMz09PciyHHHMjY61hn4/6Z2Q2nHUzqXCwkLmvbAF7z/+QZnfR36ZFeeVxyHNygfgjb4xepyLOGxpUdRxcrlcuN3u0ONG2xpefh0LWZaZN28e1dXVoXJ17fHpJtQlw4FUKi5JEha7g6yGq1CHh0AJ4Nv8Ioq3B9ntJv+yYE+l/H17ufXh/3HdkvPZTYDhbJkf/v1Ojlh66BRvgUAgEHy4idUXMuTuUuJf41jyLFicFnIqcyhYVcC2NdsievRhIcJVaYoC3o1e8lbmITsMbrQHQLJJ+8cLLQDKflbGuze9G9/BKAFjBMu5QYtvTpnohOjky5DTMUbGUI1KsyNLseNR82JNUMA75hughrVMAlQUDuEXtHBv/IEsMDqrHMfAAAQCeOwz2bVkGarDii3fyuILC5DKy5EkiZH3VF7/VjljfZaoMZTlx8K68ZTqDRvgpJOCZeZKILRtnf2X4jmpNSIoyczBG3gjwKZTNwXPJV1CfMbFx/H1o6pBB2dvLzzzDDz//IdCfAzHUfcRVN8Iqm8fgcFdjLU+jTQjC+dZQcfqrECAtc2v8/sLVvN93yhjEhz3hTO5cfWXp3jlgg8TQng8CJnuJYuJMBERIpFUbH16tMfjoaWlJeJ18VKoIfIiUu/UdLvdSSdO5+TkRJXeOp1OnnrqKcOekkY9EI3EQLfbTXd3d2gtvb297N69O+Za8vPzY/ad/OCDD2K+P4p3iL5oUQilVyeKJEmG+9TIrRguBmsCqEZhYWHEz/rjXVRUFDqXJH+AmT//CznVCjO/sCxYhpKbFwyRURRe/kDl7b026krdhvvf6XSyc+fOmNt1oJVGp5sDsVRckiSk7OCF9YxjzsH3div+t14EqxXJIiNl5zD38uP4YU0H6ugYoz0eftPwVTb/4DMce/yRuFxOZs6cJFeAQCAQCBIi5O6KZ3iUYNmTy8hbkWdYigrBVGstIKRgVQGd13eaDjfWN0bTMU045jui3ZJA1iFZlN5RGuHULFhVQN9jfUhaHXZQ0TImEPnvRJOsjROiEy9DzqWdmbRMaIxMY1Sa/R6XhxKv46Idi9bWqKckwIn5+RDxWklCXnMzfPksducuxF9fReHpS5GyZoDNjjTe649XtpB3yy85Ss3mXfVTdFvOMW8nsHIlPP88nnO/jqOvY/+2KRUg7Q9KAnMHb2gbTRLiM8ratftFRwj+a7EEH1+3LrNzT0Mk+wwk+wxkZz6W2cWMPPsA2KTg9ajFgv3ISj47dyZX9uxGGfXT8tizfL7pdW66ezUWiwW3uzD2zRGBYIII4fEg5EAoWYzHRESIRFKxGxoaeOSRRyKchfrX1dfXs27dOvr7+7HZbIY9HlVV5U9/+hMQFA337t0bMaa+VDmZtbtcLpxOZ8Lv1zv4nE5n6A+IqqpRwtfY2JjpWHa7nfr6elpaWkz7PMYLfolKpF4CtBF50SKDr3i/iDg6Ohrqm6n1ZtQTq1RdQ9uP4WKwPlDI7XZTXFwccjOqqhoSWhVFob29HQCrd5TljS+w5MxC5MoKpDCXoX/Mz4ahHPx5s6k7LFj2vM7gYkdL8Q4/p8vKypAkKenSaEVRQsK5Vmp9oN1YMOJALxUHsB9Sjf2QagDGPAOM/vv/s3fm8XWU9f5/PzPnnGznJM3SJum+JG1pk2YrlFI2RYFSEFQQVBBcrguKitwrikX9CXpFL8vFBTcUkCui4gKUUsqqlrXZSEtpWqClzdamSbPnLDPz+2MyJzNz5ixpUpqUeb9eGnJm5pln5sw5nXzm8/1+7kX2Z+KtWq4vB75c9iabv3cP9/bfS6+mMHhmCT+5/1b3Zs/FxcVlkpBqb0dPvidajhqvFNWT66HmxZpRYTKS2GbY91KfLug46IGGU9EQdGKSsyXn7eIxHtER4iVEp1aGPFpi7fAAfSylzO8ATqXZZhL1qKw/rR7hE5wWUkl2pxZvHCPVPGt1Nq1NN5DODgLnnKyH3ZmQHngM793/QAIEIUq5nYxlGezrWWdtJ2ArT97LFRxiqXUytpR3p76o0Z6jKSTEHxWammJ7VSqK/vq7HCndT+a6LwAQiUQ4tOE3ZPslpHlz8M2bA8DJVT0U3f0Sv1/9JcJoNGZE+Pk/f0tRsdsH0uXo4AqPxyFTqWQxHuMRIZKJloYj1Gk7Mx6PhwsuuMBxW6dyaieRrKuri+LiYjo7OxMKfU5kZ2ePaX27g888J6cSbaeSbDN//vOfY4Jw7MSIiybKy8vp6Oigq6uLvLw8qm+rpul9TTHN3PnE6DahUIi2tjZqamooLi527Jlpd34a5eBmF6Q5LMgsxJvZvXs3l156KZIksXXr1ug1Ubh7N9WPPUZeSwsdRQtg9kwKLytDLFigz9eTziGy6B0cJlywkLPPXpW0lN/ci3G8TuTGxsbodWeEzEzkg4Vj5Zie6qXidqTMbJpnnsIJA7vRBg6DUBFpPjylCzn3pmmc0z+AFgzxxt/e4NKai1n7xYvJyEjn/A+cjd/vxkS6uLi4HCsc3V12ZN3NaJAoTAZMwmQqxNuvhsVJtufmPXo5uHFb9A4nVI+nDHm0xNqKBmMqZT7WJO1RqYEW1OijhGx2WI5XA/opSTqO/J7TCVSls/cz3yRv1gE8q09H+HygahxuLGDojTAzX/wxvoa6mITqOQd+xZyD3x/dqUN5cpm6mXrpdnpVU69JW8q7U1/UuTfMZdv121BeVpImxB8Vysv18mrz3yGyrL/uEkUIwf7ZJ1KWEUTZ06iX/PtkRHYO868+na90HARNY6BxHz886VPMv/YDBHICrD5lJUtPKD3W03c5jnCFx+OQqVCymEzcGI8IEU+0tCcdG5hDPcZCojJkg2AwSFtbG1VVVbS3t9Pe3p7yjachbqaK4RQ0RKlk88vMzIzrHjR6KCZLy07ketyxYwdlZWWsXbuWxsZGXmh/gYJfFJD2pzS6tnYxPHMY7QoNbZkGrdZtm5ubueSSS1BVlYaGBsdzlpaWRllZGS0tLTGCq6Zp1NbW0t7eHlO6btDX10ddXR0rV66MhuwU7t7NBbfeCkBP+gwyTphJziWrEDN0IVPkziGt8hxmJwk60jQtOmZpaWnSwJixkOjBwkSIhseDY3qyoEkyvtMujfbiDG7dhNL9FiIvD5Gn9wYtvWYmt/7lJepv+SMRDa79+q/50iNu828XFxeXY0WMu8twEho/HcpW45WiJky5Hiuq1UnWt7XvHRcbzYynDNmpTBtAxUsjt6VeyjwBjCdVO9UelW/wBSr5KqBGq+E1JN7gatM4KmKkNtsYr4LrCHaewd4P5TP97OlIy0/UK286u/H97WU6n3o/hzqXsoAG59BzW/9yx/JkSWaeej9N8i0JU97tfVEVRcH3aR9DrwzF9DK1b3tUWL9e7+lopHTLMgihp3G7xOBZsoq0ZXrPx0hXG6EX/oJIT0fM1R2Q/jmz+e6cHbzw60cJKoJHgn/koY+fyrd+8F/HctouxxGu8HgcMllKFg0RZNeuXWiaFg1vMVKBU0kQPhLiCTzxnG9OoR5OAg5gmXci7E7AAwcOcMEFF/DII4+kXDpt3l6WZTIzMxMKgbt37x5TP8mBgQGysrIIh8Nj2i5VjLTonTt3RkXQFlrwX+mn/8Ojoqi/1x+zbV9fH/fccw8ejyeuUJuXl0dFRQUNDn1zdu3alZIwvGvXLlauXBn9vfqxx9CAg9MW4fnQCnLWnYwIZKOpGt4FNXhLVsYfbARJkli5cmV03Il2EBYVFUWdjsbvBhMhGtqFzebm5uOmnPtYk7byHJSDbxPe9QqoEdS+g4iMDPI/eirvu2gQNI2zXnuLX33oBn60rAA5zct5H17LZR+/6FhP3cXFxWXS0bOlx5pMPUFpuk7uLqOXYrwU7Pnr59O9uTtmrIQp10dAuDNM49pG5q+fjxYeZzrMBJCsDDke8cq0D1N11ERHJ4ERGFeqdqp9LnWR9o64Im2AnVHRcXQcGPZm0hUQzLh4IdL8+frrr+0m7Rs/QQTDlKn/oF66nbAawEtPrPg48pAzikN5slAVcgv2kbsyN+71HQ9PpYcVT62wplqnuO24GelRaUm1vvFGOOUUx9WP1vfFVMSTV4z0/k8TbnoObXgQ9XA7It2Lt2o5p90yD1SVs7p7qPvVC1xU9SGyF0xn1rxZ3Pj9/yQzM/NYT99liuIKj8chk6Vksb6+3pLiK4SgpqaG+vr6GPFtPOXgqQo78fbh5Ah1EnCAlETD4uJiS4KxMccNGzYkDXQB5/JlRVHw+/0Jhcdk7kQnUumXmKicOhXsAqD994GBAYqKiujo6LCIjKqqJhRE29ra2Lhxo+PcnLZLVFpeWlpKXV0duS2t7J9VybSPL8d72kpEWjqEQvh+8hc8j33Oso39uquoqKCxsTHaMxKgo6PDUpI/XpFdVVVUVY066GbMmEFFxejT53G3WdiyhVO//308O3bQNWsWdeedR0dJSUzwksuRI0+fizx9LgDqcD9Dm3+HlJkGAb21gu/kSr4wYxr7HtyONqzx2k2/4/MPbebnf/mJK/66uLi4jOAU5jKRabpOqdezPj9r7AON3HbEuCiPEC2o0b25Wxc5x+ugPIaMNy16rMQrZe5j8bhStcfS5zKRSCuIoIFFOOzKmkno3GryL1mFKND77kmP/xvfbfcjoonrEvO0+3mLT7KYO6JjRMe6+WaL4FYWnEdAakeo1vJkaWWFfr1v2QI3fwM+MiLkrV+fNCE6Z00OeRvzEq5z1FizJqUgmaP9fTEVkXyZpNWsBfRKseF//hkih6O9Q0Ugm5pvTOPOB1+iv6ONni3tfG7Zxfzgn79mztwj+C50edfjCo8uR414IoiTGDKecvBELi97T0YzTiXWxvrbtm1LeCxO2MczgkPsvSCTEU/oO3ToEFVVVbz22msEg8GUxzsShBBIkoSiKAlFx7S0NJYvX46qqrz22msoikJ6enpKgqaBpmm0t7cfkcDZZSshEUJQWVnp6P50Eh1LS0sZ3tNG/s8e4tS2Fg4sWcn0D5cgV5QhZA909+D7rzuQl66I2dZ+3ZmT0u09Hs2MR2Svr6+3ODzb2tpobGyMXu/jarMw0vcnW9MQikJGby+zduzgkeuuo32We4NxNNCbf1+N0vEWhIOEd9UCw8gL5zPvG/MAmH+4m2X31HLZ/PMZSIO0omx+/uc7KSpym3+7uLi8e3EKc3nH0nTjzCfe6xUbKywuyu4nusdXIj2FBUeDIy3TPtKy6Hgl0X52H1mqthcIxxdQO1lDOdenNM9smvAwAAha8pcSzMtHyILsMwrJXnsywh9AU1W8v/gz3r8+HTPXADsBUIQfiWFAQeTn66Jj2WUWwW23dBmV6ksgybr4aC5P3rIFzjhj1BHZ0gKbN8NzzyUVHyc7k+37YrIhhCDjjI+gHO5A6+1E7TlIpGU7wh+g4FNnUQAQCnHHv1/l9lO/QH1aBHwSV63/DJd89KJjPHuXqYIrPLocNeKJIPbXzcEbR0Iil5e9vLq4uBhJkuI6I+OVYxtzjycoGS7H9vZ26uvrqaqqiopBGzZsGNPxxHP5GcEreXl5YxIyjwRN0xxFQLs46PP5EEIghIjOeyyiYyokciraz0VVVRUrV65ECOEYqAO6QJydnU1RURElQzKHvvJ5pr9nHmJ1ESJ9PsycpYfI7H4b3/V3Ig8Mwf/F9os5UndhIjFQVVXq6uos/SGNFgXx9mF+bVxtFkb6/oiR91dSVVRJovqxxzhw6aWpj3MUOFaBN+8EQpLxFOvN5T1zlxNsfAal4/XR9PTcPOZ/4TR+saWJSH+QgbYhfnTip7jsLzdx0qqpl/zt4uLiMhEkC3OZjPMxXJSNaxtjHYtjTKQ+moyn5+FYGGuZdtIglzjbzON+8tjqKDCCjDYiGhqklKodHj0Gu4DayRpKuTNmnjvm/5yDexdjq6hmHvcTEV5alpxE3iUlTJs9AwSIWXMQaWkQDOL77i/xvNUx2s8wOleBlx79+DR1REiU4e9/hzVr2LO20SK49arlNEi3U5L3R7LT9lrLk08+2Tkl+rrr4MUXE5+PSc5k+76YrMjTCmGaXrUlz11O8F8PIjL0EE/S0sh470quL97F0K4DKEGFf33vHm58qYmb7nD7arokxxUeXY4a5pANI2DDeB3Gn+5rkMjlZRdqJEli3bp1cceyr28EmBhzNrvaQBfeysr0p7OG0GW43wyBs7CwMEawlGUZWZbH3FvRXo78TlNQUIAkSRw4cABFUejr66O2tjZa+jsenJySfr+f0tJSSwq5IR6rqho3OKa6uhrQezgGg0HLeV68eDE1NTV0/v5Rhp+4m9wrViNyrSUiwbrX8f7oPvqXlZHzP//j2C/Gft0lel/sgnc8zO0JwNqiwGmfxmsG42qz4ND3R1JVCg8cYNYx6hNr8G4KvEmreA+achpEQig9Bwi98ggiPZ2Ms04EwK+qfHfVDh746P/j7uEIA0Jh2ZVnccMP/vMYz9zFxcXlnSNZmMs7TdrsNEIttns6yXk+MWXXI4Ecvrk+gntiK1rkHBmlX3lHnI5HIu69U6Qa5GJgPxZ7KbMuMJYQoJnxlHzbBdRyrnecZ9GeuznoME+P3Erriacz/ROViNJS/eG3waHDeL92G3JLJ3vn/xdzO39smauuVotR4dQIWbn5ZnrW/5HDzxyOuW561XK2pdVwyn7bva1Dz/SErzvQs6WHA9f9jYKGX5DFW4jKcry3/r9j7picbN8XUwE5ZzoZ674IoSE0VWH42T8ifOBZtpjAssUAnP/eTub9bCtXzzyfCBqH5vq598nf4ve759UlFld4dDlqSJJEVVVVtPzVEBcnugelWeAMBoM0NzdHw2zGWnpqXz8vL88ijK5bty7ao1LTNCRJsiRJG5hLbqurqykuLrasYy5h9nq9hMPhmHkMDAzE9G1MJG7JskxGRgZ+v59Dhw7FjJkMp3nY6erqclxnPD0gDXJycliyZEmM2w/0a8Y450IIenp6HMNj2tvbo2nWRUVFXHLJJTQ0NFjGrFyxgpb1d5DZ/xKZHzkDkZmJpmocHFSIqBpvD8nsnraU6sc36SJhHFHcEBC3bdtmKX03ys9BF4rNYmNdXR0PPvggAFlZWUiSFHX8SpKUkqNRVVW2b99OWloapaWlVFRUWI75iIX88nJob7eKj7KMr6Ym7jl4pxh378ophpA9IHvwzJiP9L5PE3z6fjTCIEsIWcZbtZzLv5vLRw/1oA2HaXz4eT553mf48ve/iscjs3z5kuPGEeri4uLiRDzx7h1J07XRs6WHvlcc+myrMPz2MM/Pfl4PqPlAAZ0P6wE1/hq9j1pwfzAaXvPmN5zLez25HtQBddz9IVNhrOLeO0mqQS4GsceCqQeiLjDqqdLaESVzH9E8jUmgC6Mz0v5E/3vLmf6xExHFI21t9rUhtR1Ea++F3z5DT/889rKe3j1lHGKmZa4BduKjxzoBRUHd2qiXWEe06L7M2w3mvA/W3jQayrJ+ffwDUlVYu9a6roOQ2LOlhzfP+D0VyldHxd6XnkE741nEMS7XnkzfF1MJIQSkZSKAjHM/Q+jlR1EO7QUhED4voqCA8v88lR++uQ9UOFzXxjXLL+Gq399IdiDAwoVzycnJPtaH4TJJcIVHlymPIf4ZIl0oFIo6xcZaelpVVWVxNba1tVmCNQzRtLa21uLAKi4ujjtmR0dHVLBsb2+nt7fXIiimp6dbxDy/3+8oOiZDURT6+/tTSnN2EhmFEPh8Pos70HAWGkQikTHNKRF+v98y1+LiYmpqaiwp00B0/319fUnPiaZpcfsuAjAcZt+nvk7e4j48p56K8HpRwhGeaJfpDI1+HcqyHH3PI5EIGzdupKuri7y8PNauXYvH47EI6Oby/LKyMkdhvba21uJmNI7FSKg2REU7dkejUXpdWVmJLMsx1yIcoRtw/Xp48snRMh5z359jzLh6V05xpLRMMtZ+FjCaf/8JIj1Is2YizZoJwMoTFlB0z0s8fdGNhNH4nhTm9n/+mtlzZh7Lqbu4uLgcNZySpycyTdcpARdwTMXdc/OeuGXSQ68NARBqC9H9eHe0pDrUHtIfzD9bCWARiewE9wQp/XlpVLQMd4bRguOvfgmsCuDJ9dD9VHe0dHis4t47yViCXCDesejbdLHSIjAeqajqVJY+zHR8dDq4KxeSrenrB9hJT04u2gUV+C9ajZiWC4D8hw14fvsoIGjgDnr5lGV/Tu5KpzLyoXB+1KwQ62I9RN5rL8Prki4qtrfr93+LF8Nrr8UeZDis93pUlNF1n31WL802sefmPcxVfh8jXGuKpLfzcQqB2bLFmkqdQpjNkXC0vy/eDQghSFt1QfT3SEszoVc3I7L8eMtPAKCgbDG3LmzgkStvYUiF+yIRyr/9UT71uY8fq2m7TCJc4dHluCCeU+xI3JV24S6ZCw1GBSGn0t6ioqIYkcqpj2S8/U8kQgiKioo455xzeOihhyxCnnnOhntS0zRL+bPX6x1zeXg8jDAe45zt3Lkz6lQ1u7Xi9d20Y5QzG6TvTkf+icyiljxE/h4GyvrJ+tPjFFw4F2npSoQkMTgUYmOHj0Gbg2DGDD24Q1VV/vSnP0XfEyNJ+4ILRv/hTVXcTuTSM3qDOpXxJxPLg08/zdp77yWvpYWuWbPYd+WVcCTC45o1+o2k+QbQ6PtzjBlX78rjCL3596WEd9cRebMeNAVNKIhAgNmfO40rurtB0/how15+tOaz+D56ChlZGZyz9j2sPLHyWE/fxcXFZUJxSp6eCJwScO2BMKG20VTceH3iLKKUOtIrUR0pV1ZAQ2P3dbvx5HqSttHpfLgzeqyNaxvp3tQd0ytwrJTcVkLOKTk8P/v5aJl4KuLeO9UD0s5Yk7DjCYBdrLSId0d6PE5l6XlsRbO9McZvBzmZuRk/RhEe2qctJPvSpfjeexIiIxMtEsF7y+/wPLOVXk7gDa5OyXW5V1xOnrY1pow8s+c1smmil3IH5+fIjFRbeXYgYOkhOXoUUrT/t7mUm0cftcxloGkgrnBNU1Ps5EdCDdE0q6h5553w8MNHXYwc7+fn3Y5n1mKknOmEXnkULTyMFgki0nykn17Nxcs6QVVQD/Xy9E//xFWP/ZPSmqXMnTuLj13x4Qlp0eUy9XCFR5fjgmS971Klvr4+xlXnNI59f4qisG3bNosoZwhr9lLYigr9xtEoHT6aQqMdTdNoa2vjoYceSniTm5mZaTkPhghmT/uOh9/vJxQK4fP5os7GgYGBmH0mcqoaISuDg4Mp7dN8HtN3pzPn1jl4Mnay4PRH8JdmICSBp2IZ0py5ABweho1tPgyDgRGUY7gaQb8e7O+POUk7WehJolR1M729vTH9KqdPnx7j/jTGNJycJR0drP7mN/Wyf1Ulo7eX2d/8pi4WJrhJM8+rsFBvIh0tC9+wYdKV6U50e4apjrekGm+J3oZAOXyA4L//iMhIRxTq31WZ5xSxfubrNN3/IhEFXvrtczz8wZV87/YEpVQuLi4uLoBzAm4Mqi4c7rl5j94/ztbfMdVeiX0v9eEt8CYtoTaLmwUfKNDdk+Mgc1lmVHgx979LJu4dyx6QY0nCzqaJ7JG0ZwMN/T3z0MdqLhkJgjmFUn4ytuMZca06laUbAqCwbdIlLcO74nWkVTV40j1kFuchVaxAeL3QP0Da1/8XuXkvGhAhkHKp92B+FcqMajyvbY1ZZpTHO4mBMSgKwVfe4O0Tf8OcvnsRr21LWMrNM88gzZ1Lybx58MMfwumnk1WeRX+Ls3Atyh3O5UioIWZRU5Lgi1/Uf5rEyP47H+WNh4ti3Map4vQwwXhwMJZxXKxI/lzS36N/N2iqytAT9yC8EcT06frywiLe/+0CSn/zMgf/2sbhIcFHf3Q/v37hfrcE+12IKzy6HBeY+zwCljCbZJhFGLv44/P5okKhfX+gO7AURYnrZmtvb7eU+5qDZwwRMBH2FOlECc9jwS6u2sue7YRCeklQfn5+0jl7vd7oWKFQKPo/O/39/Y7nrba2ltdffz1pOra9LNx8TAWP5ZOZu4VFH2wg87wzEdnWm4o3e+FNTxERbXT/5eXlUXFLVVVqa2sdhda8vNEgmmShJ4ncmkaPx3gl5PGE88bGxuh7UHHnnTAiOoIeBqMZT6KdSloSzNv4b03THAVPl8mJPG0G6ed8jsjuV9BCwygtuxBpMt4VJ1D1vQWgaazs7qbpl3VcsOwCvAV+CufP5Mc//57b/NvFxcXFAccEXCdUfd3lDy6PSakeS6/EcE/Y0vsvBlsIRufDneNOwR58fZCGMxuofLaS+evn6/Mnubh3rHtAppqEPY/7gVgBUKCRzU6TQ/Fl9HAWbWR5kuMRRM97vFJuO4PeHAZOnUnRx2sQc+cizA9397eTft1tiEM90e0DNsE0EZHOCErnnpg/6KPl8TL0K7FioB0NiX51IS1b59Oifid6fcUr5SYYRLS2kt3eDmedBc8+y/z1Zby5+QpyFatwjRynbY9DqKHFhTnyUwMyrr6A2VSxl8vpbi8fs2jo9DBBk/UHB0fDNf1uREgSGed8ksj+HahdrWj93agDnYi8POZfexbzIxEIhzhpcxNfX34ZBxbm4MtI46vf+SKrTznxWE/f5R3AFR5dpjR2x9mll146ZrdWInEoFArR2NgY47YyO7AeeOABx23jCUrJhDuD4uJiiouLLX0Bj1aidSAQIBAIIISguLgYTdMs+wVdEMzKyqKwsJDu7m58Ph+Dg4MxTj5778h4pdl9fX1xjyeZ6Ai6I7CoqCimb6ZQVAqHHqPkP/rwnnY6Ii09uo06rPLKYY3mARloj5ZnFxYWomkaGzZsoKioyPH4QRdoDTckJA89SVRePW3aNMAqmAYCAbKzs1Mu2c5raUHYzr9QFOeSlhTntWvXLld4nGJI3jR8J5wKgLbiLIJb/oYW7ESk69e+yMhgxX9l88tHXiHYHaJnz26uWX4J33n2F8xfMPdYTt3FxcVl0uGYgJtg3Zw1OVQ9V8Xu63bT36A/eA0obyEiKfZKTJIFaA/BGGgaGJfoCFgcm0b/SoNE4t5k7gFpJn5/RxwcirZqnDjHk00T87RRQVYv5ba7+0b3BdCVNZPQuVUUXHIyomDG6GCqivRiI97v340Ihi3be+mhmH/QxoWj60sQODHA4OuDKD3WC1Mvjz9kPQ5JQjqxgtzcXFpeuIq8nlrdeYiKJkn6vaOk93i0uFqNoUeGsjtg7QhVRRMCbr6ZnI0bWfjcFbxxnd+aan3b95zb9jiFGjogAJkweWzV3ajK7fTK5WMSDR0fJijEbZPgcmQIIfDOWQZzlgEQaXuTUMNGhM8LXi9kZJBz0WpumdlEd30HSijIpituovHLH+TzX/nkMZ69y9HGFR5dpjTJHGepYBdh7C5DJ5HGLHiaE40NJsqZWFlZiRCC5ubmMYfNmLG7A52YOXNmNLBEVVXa2tpiRNKBgQGEEJSXl6fUdzEZ/f39Kc3NiaKiopi+mfJgiJpHn2PR56cjV5yMkD1EuhVe+88FDLb4GFw6SMs1rdExJEmiqKjIcn5bWloIBAKWfaWlpUX7LZqF7WShJ04tAOzrmpcvXrw46fVbVFQUDaTpmjWLzN5eq/goy/rNnI1Uy75dpjZCCNJP/RDKYA8M96N2tRHe9RLC7yf3o+8BoDAc5tbnX+WnZ1xDnQgS8Uh85FtX8olPXXqMZ+/i4uJy7IlJwI2HICoI5qzJoeZF07/fa2vQntiMUEcHSBSEEncXaYLKpystIRjxhFFPgYeMRRl6wnYq/8yPODb33Lwn5fmMNeDlWOEkxtn7III16Xp0vdjjcSox10zrR919GCXd0JG/GN8l5WSfuwrhD6CpKp5f/AXP359DoICqxczLmM9i7mCAhXq5twy5789l/vr5NJzVEHOsA8wnj5etx6GqeE+tZP4H59Nw5mHqpduZp472G8247jIytz9B8ImtI/1HnUvWzQ7YQNoeveza9neP+YF3DtvIyX0QCvZDebXenzFer3CnUEOj3NrhPtXiRlVuGZNo6PiZsTmJXSYeT/FC5OmfRe09gKZECL74CFKmj7TVlRSt1g01V+1v4V//+zAX3/pnIkIl/8SF/PKPd+LxuDLV8Yb7jrpMacbiMIuHXRyaMWOGRXBzKnlNFngiSZJFvDwS2traom7L9vb2cQmPaWlpYxL3JEmKJnHbj7O/vz/lXo9mAoEAfr8/RsyMNy8hREyYjeFQtDsCq6qqOLB1GyUbHmXmJUsRixYhhGBwN+z4+mLC/frN4KHzuiz7MEqq7djF5HhJ1clCTyoqKmhtbY0mYhcVFXHgwIGYdccSmlJRUUFbWxtCCAauvRY+/3k9fTpJErX9vTTOpb1VQGlpadI5uEx+5MwcyMxBzpuFVLiQ4HN/QGT4ABBeL+mnV3Nt8ZtEWrpRhkL8+/YH+K+Xm7jxR9cjyzJZWZnH+AhcXFxcji5OydU5a3JiEnDTZqfRt7VPV4RMekjpXaXxU3HXr0c8+SQIeaRcNHEQSjz8lX723GSdY1QYlTTLfBbctAB/uV/vZaem9vA7qzwr9dJyxh7wcqzo5BSLGDcqEtpFRn2p5nA8co4cdRfGKzEfYA4+DuOljzAB3uKT9DOP7PmPMuNjs/GuqUGkpaEFQ4gb72eorheZWWTSoouPIzMwY8x3HvfTJN+CEIKCCwviJp8XsSm6nYV772XP9ivQNI1e1eRilSF3ey4VG6/l9bWNMW0CkCBbtQbuvC1fwcKnr8B302WjCdfGOZRlvYfjli1wxhmjy1pa9HWfe86577hTqOGFF8I114ze18acm9ES8rGIhjEPE+RYJ7HL0UF4vMh5swCQ113N8DN/QFP7EZKEEAIxZzanr89iVcMbaKpGe107H1/+QW596pdkZwfIysp0w2iOE1zh0WVKk8xxlgp28aiiooLGxsaoM6ytrY3a2tqo201VVZqbmy1j2F17Qjh1eRk7hiCUyDmXiruypKSE7du3JxQfm5ubLanSRjn5zp07Y/o/2oU5n08XNNLS0mLERSNkp7y8nE2bNqXsBtU0jbKyMoQQMcJcfX09GzdujL7W++TLVGx6iGmfXBkN2DhwQGb7zwvxSiqhE4Y5tO4Qw4uGAb0PZXl5ecz7aGAXO+2CoN09aBxTbW0tu3fvBkYFPONctLW1MXPmTNatW2cZa6wOXUmSLO5Uli5NKYnaKYl93bp1jgE5LscXciCPzPO/hKYqoKoMPXkfwqvgWbwIz2J9nbNXHWL2XbX89wmXo6Cxu0Dmnn/dR3Z2IPHgLi4uLlOQZGET9sRsQ6Ts2zrS1gVB59878Zf5nfvMmUSVZK6yRJjdi6GWEN2bu6l6roqSO0vY9cVdoytKsPua3VQ+W6kv+9KulFyPke4I4QNJar1NjCXg5VhSwPNYezcS16E4xAwyODAS7JLBm/yHfjx9o8JXvBLzLPZiiLBe+pgv/ZK3lq+l+MolSOVlCFmGQ4fxfe1WPC0HSLdsb8zH2Ynpl97UnY43zufA1/5GWeQux+RtL32OvSXp7GTOU58lXTmFAp4f3Va5nMPPrKBnS4+jIJfDNiqla0E1p3XXIrSqGJeiJkmjD7y/9rVYsVBR4Lrr4MUXnd+oNWtie5KXl+v3tc88E+OuNNyoCUXDLVus98Xr15OzZo3lYUJWeRbzb5wf/8GBy1FBSBIZZ12OpqqARnjXViJ76xDTckk/U2/zNP+0EHdufIW7V3+RXlVlnwhx1d3X8/5zzjymc3cZP0I7Wk3jJoBvfOMb/O1vf3NctmDBAh5//PExj6koCg0NDaN/tLscEcnSfA2O9vmOJ5qkMrdkGOW7BjU1NdTU1LB169aY/n/xwlkCgQDBYDAlt2FxcTGqqtLR0RF9raioCFmWmTFjBk1NTUQikegyn8+Hz+dLGApjiH7xehaCLsKZ+zLW1NRQVVUVPYfTp0/ntddei3sMxcXFrFu3LnqOnd4TVVW5//77x1xSPWvWLNauXWsZT9M06mpryWzpQQ6GWap4mN39Mlnnn4zIzkHTNF7tVOj0z6G4eCYNDQ0x7lOjlNruInV63anM2n5txCMQCFjGmjVrlkV4TPVzZOZIP1PxrmeXo8Nk/rdG0zRC9ZtR2nYBGiJdf3CgDQ6gtnaAptHzyn6+u7mb993yWbICWdTUrKC4uPDYTvwoMZnfq3hMxTlPdSb6ntR9D99Z7Oe70cnpNVLSau8bZxYdI4ciowEjI66pZCEXjvtKASlLQh2IVQ8zlmWQPjfdcczMZZkMNQ85OuNidzDyc4p2X8mmySaAjopxq7mENDpjtgmRQx9L8PMmw0wnm9cxuw6Ns9bLCezJ+RLdPXqvOqeQFWPdkJzBsMePIjwMnFRG3uXViAULEEKg7mwl4/ofI/UPWrazC4VOr5GWBu95D3zgA2hXXwOoCLTofpv5Km1cyClchJceR/FRi0quYmRb3dHZwO30eVZQ+WwlgEWQW9Z9Hd6tz1pFRFmG979fFwlHhD3t1VfpnTcPcfm3eeuRYsoePxHZoWGpgpdt574ytiTqLVt0wfKll0zHIgGC3avuZsZtFzmLhlu2wJlnjqZlG5VAzz7r7Lp8FzDZ/62JHHyb0CsbQFPAIyE8HjRVRdu3Dy2sEDnQw19/38rei1Zx4uknUlg4g5UrV0yYyWcyMdnfq3ikOu8p4Xj8xCc+QXa2NXI9Nzf3GM3GBSamt+JEYA55MTALLE5zU1WVuro6SwK24fIzY3eINTc3097ezsGDBy2vy7IcV/wLBoMJS679fn80TASIzsk+Bye3YyQSiSvk2cWyDRs2WJabXYf2MBjDoWc+h4FAIO6++vv7Y8SzmpqaqKj22GOP0dnZeUR9HA8ePMgf//jH6PltaWkh25tO5V/+yfz8w0heCe+caXg/dAYiPR1VUfhnB+wb8lC1SO8B6SS6OpWtBwIBLr300piS5GAwGP3duI6OpKQfYh257+TnKFlZuJkjEUSPxhguRwchBGnVZwNnAyPNv+sfQ2RmIZfofa1yF87nR/Ne5ekb76FP0/hZSGPOf32Qz33Zbf7t8u7GvSedXMQrl05GqmETdmckMKo4pZiMa06NTgkBQhaoIWdFcOi1ISIHIo5C5uBrg7Ev2oj2gtzaN2YxNC6JUrmPgESiorHc3nMxl1oauJ1eyuP2ouxjSbTkuJzrsZc6i+j4Oyjv+XJ0PKcSc1DpzFlAaM1S0vJk5HSJ/PeuRMzQH9IdejKNoh//EEmx9UR0OF57r0kNEMEg2uNPwMhDjXh9IN/ikyzmjjjOSc0SoGPuk7hXvRxx0Q1kp+2lorwcHlwPaypg9uvOzkUjuHDEpagqCq/fs5Whzw+Blvj67t7cnXoStVk8NB/LqhPhttsojdczEnSnoyE6GvOWZf11u7PSZVLgmT4Xz3lfAEANBxl+/G5Epgcxbx4AcglcOr+Ihp++zNsPvcR+RXDbrEzufeaeaMWdy9RgSgiPV155JbNnzz7W03AxMRG9FY+EVMQMp7nZS2PNpcB1dXW0tbVZegca/20W/OKlVCcK6jCLbfbQGtBFv3gp0slItN/ly5dbBCz7sSQyOmuaFtOHMVF/SbMw19LSQkNDAzNmzKCoqIj6+vqkx2HgdH5CoZDlHHp7hqh44nHmXDAXqWQVyB6QJIQkEQlF2Nguczis33Zt374dSZKorKwErKKu0/GUlpYiSVJUkNu2bZulpNx8XSUqfbeP6VQq7jSm0+8TiZNIH4+JEEQny8MJl+R4ihci5VxBqH4zhIZRBw4jMnykr6li7fIFoKlc0NnNv37xDy77+9NML5nJgpJ5fPlrn3Wbf7u863DvSScPycqlE5Fq2MSem/dYRUc7KSTj5qzJIbAyQN9LsfceIl2gDdvuyTTd7aj0xlcFtSNR+SQQkqD8H+Vs/8h2x2NKJvg5chRER6uoeIg8XiZCFprpT1cx4gA0/jsaPMItKfWi1Mun4x8SaNHx7CXmfSyktzidvMtmk3V6FWRkghAIWUbTNMSvHyfjT61IKSq7GqCmB5C1EFowaBIZ1TiCor7NopwH2O7/H/bnZDKr5ReIni7sxG6rEmAnleq1iM6RxqXt7WibN7N75W8o6JzNNNqspeVxggtDd4f0iSgwxEyy2Gvroam/nqpID8SKh+ii8eEGePumLOav74n/+W5qSiyaukxqJG8aGed/nnDTs6iHWtFCQ2iyijSzmKr12VQFg2ihEOdueI1PLL2I6WeVk56RztXXfooFC+Yd6+m7JMH9i8HliJiI3orxSCQupiJm2OdWWFjIhg0bYsQ0M8Yy85hmh1hvb29c8S3VbgUejycmuMYQ7ewpyhNNqscCuoMxKyv1hs3241cUxTER24wsy+Tn50fdo4WFhZx77rk0NTVRV1fneE79bx9iTd0WCj5eiTRnrmWZeLuN3l9tIO20M6GkBNBFS+NaWblyJStX6r1DkpVJmwU683rma9x8Pg0BWNM0BgYGCAaDpKWlRZ20MFr6X19fb7me7deqqqqoqhrtJTqRjkHzeIWF+tP4jo4Ox7EnQhA9Vg8nXI4MKTOH9DUXA6CpKsNP3gdyCDFtGgBybh5nrM9j0X0v07f9dbpffJ2P372Ru164j7w81+3l4uLyzhMjCo5B3Eg1bCJp8EqKIRfB/UHH17VhjRHznAUj1GTCEBA4MUDJbSXknJLjKLwmcxHG4EXffiyl2g7Haic2yEWXWb0MWMJinAQ1P28CqfWi1F2RnQnEx9HxAHpFOU3aLQREPTmlGyn8xHzklRUIj3d0o+Egvpt+jeelJtJHDjY20MYY30r/8GwCBYeRgtb75/jHC4HeWmr6LiQYXMzgf/8B/8N3xIa/OOzfSy8Wt6eiAIJ5L3115AUVzeiRaQ4uNPVPlMrK8O84nx5FP6cKzqF00ddTEOkBR/FQoJIZfCO5c7K8HNrbrdtLkt4rcvbsaM/Hd2vZ9VRACAnfivdGfw/trifyxguIzCzIzEIAM67I5yfFtbz9wutEwhq/PeMaTvrJ1Vxw4bnHbuIuSZkSwuNzzz3HwMAAPp+PJUuWcNJJJ02puvfjkbGUbY6VROJiKmKGfW5ODr5EGInNRskwpN7TLxF5eXnRpOimpiaLk88e1jJW7G5Bc59Iu4BVWFhocVfa+1Omkp4dCASiJeI7d+6MKddOhiRJHDhwIPp7e3s7mzZtYt26dbS2tsa8X9Mb9rD68HayP7kGkZcPQMueLhbc/FNEJILY30GxJHHBy7U8ct11dIyIj8bYZsrLyx0Dc3bt2kVlZWU0WKiwsJDq6mqLOGeev7kPpqqqlv2Ul5c7Xjv267mqqspyvG1tbdTX11NTU0NdXV30fWppaUHTtKh4eiQ4fa6c5gTOguiGDRvGJIAezYcTLkcXIUlknH0VyoG3UA8fRD3cgXJ4PyI3l9lfeh+oKoRClD/ZwHcqLueNXBlPmo+v/vdXee/7Tj3W03dxOaq496STh1TLpZ2wJ1fHC5twdEYaJEnGNZeBq8EEattYeyxKEFgZINIdcXRROiKgv7Y/qnpFhVeTVTFecrPh+othbLd+OvqQCY/ZOcgl9mesoKYHjxj0oic5Gy7O5fw/i4tzL5eTx8tx52EfDyAgv0R+zRMUXLECackShCTB/nakHz8EPYN4O/chDQdH5qiaUrOtxlAnETGdg/SzmAAdMb0knY8XhBYiTevE19mFdvU6Bq/7EZnm8Jfo/o0ej8b+Yh/wC7Ror0hju4h3Gp6zTtZFR02z9k9sb6dCeZIG6XZ61XLSORj3uIDUk6gdxMPoe5Hs4YIt/AYh9HuWzpF+n21t+nKnno8OoTSuQHns8ZVU4Zm5CKXldVDChHfXITLSyDp3FSe8LwKaxrK33uYf19/Fuht+hiYLTly7mu/+8BvHZR/IqcyUEB6/973vWX6fP38+t912G8uXLz/iMRP13XNJDaOEFXS3l/2cGoLXG2+8gaIoVFRU0NTUZEmPdhIw7KJTW1tbdOzCwsIYQSQcDseMY57bxjg9PWRZJjMzk6ysLItoZLgQNU2Lik0rVqxwFMRSwQiHOfvss9E0jcrKypixkvU/tAuLsiyTkZGBEIKsrCy6urosy1VVjf5eX19vEbCqqqqorq6Ovg/l5eU89NBDFiEumRBaWloaPTfG+zwWnITKtrY2NmzYYHWFahoLnn6VmumdpF92BiLLj6aqvHRApeT2+xFvtyGNOA6FqqJKEtUbN7Lxmmss5+LRRx+NXnObNm1y7MnZ19dnCcAxeluWlpayYsWKmGvcfF6djsVYN9H17ERrayuVlZUxidvNzc1UVVVFtw2HwxZBOd7nybzfRMvMczKOt7293SLcGwJoKg8azGMUFRWxYsWKCfneVVU1Kg6nctzHCuNYp/S/NflzkfLn6u3cD75NpG4DIs2n39B7vQQuWM3Ns7Yz0NyJMqSw6Qs/5tVPNXDN179wrGc+JqbiezWV5nq8MdH3pO57eeRklcUply7LijmvTp9z/8l+yh4tc1zPYM4359D9ZDfI6PsZEc08BR4CNQHmfmsu/lX+mO16tvTw6lmvRstQmch/pgQsuKCV9Hv/B41XUyuJVkFTNZoubGLZX5eRsyaH8qfKefO/3qT/Zf2eKF5ys9n1N16M89b9RHfc8myn/oxOmMU4p1JqSO7iDM2vxLenwTHsxT6elLmPwlOfJe9jaxCz9HYL4pVt+L77C/qCJWRwEAl7P0eNMFn0spwAO/HS43gshrDWql1BmXgJTTNKxJ3FVruAaZwr7Te/Q3nqKaQf/ACamgjPXkpH38n433yKnFAdQgvHdXha96UH0fRJS8h+9FH9+NetA01DjFzrQlFAkpin3k+TfAv9inNfzX4W6p8fAXNvmJv8O++b30QaEQ+FosS+twoMvDqgj7NlS/RYKS9HveEGMI5/61Y4dMhynlD1c8pNN6Ga+99v2YJ01lnR49Pa2+HJJ1GfemrKi49T8R4nhrQspIW6QcK7oIbQk/cgpUvg1d3GniUlfPDbAd779GugwZvPvMhHT/oIdz97D+np6YlGnlRM1fcq1flO6lTrhx56iEAgwIoVK8jNzWX//v08+OCD3H///QQCAR5++OFoyWCqGKk7Lkcfu7hmd9YVFxczc+bMpNuZ19M0jebm5pTGiTeefTtDWDlw4IDlg2MkQhtomkZjY2PqHy4hKCoqori4WE+2U1V27drF0NAQEP9DaqRVG2P4/X46OzstYp3P56O8vDzusUmSRGFhIcXFxezatcviYrQfF+DoAIyHz+ejrKws+hTJOH9HIso6jj8cYekjLzCtvwuPrDHjfUV4VlUjfD6UcITNHRIHgxIfv/56sg4fjtk+NH06m+6+m/7+fjRNsxxXvPTxpHPy+cjPz4++l6ALgfHcoeZrMtH1DLHn3u/3s2TJkpg0blmWLYJ6snHtJBLOE21rP06n6+edxOm4QW8R4Pf7Le+RywSjqfjUIJKqMLutAV92hmWx2trKC//byL1tQcKoDC/I4Rv/cy1erzfOgC7jZaolH05lJvqe1L0fHT+RhghDnxsaaZAHI6G3ZP4qE7libJ+LSEOE0N0h1N0qUomE79M+PJUex2WeMzxEnos4rmsweM0gyktKcjej4f5LoQTZYNqC7VS8/RVdJFFH+xeaS6IT9mqUIeOXGXgqPfo5/Ix+X+qc3CzRxUpnx+ORMA0y/ieD0N0hlBcVR/HRLhY6Jj6jC4NhstHwOpZSJz0mzy0U/eINlnz2c6CO7gv0VOvdfIFIXjfT5tQiZIVpy2X8H1iNyM0DQPrzE/h+9VeEZu24aXclhsnhef7uOBdjHQ2ZBnEHAydXkHf6DopuudtxXWN9+37My96+/nqGSkspvvtuMnbvZqikhLZPf5pF//mfeB3um43tnMYL+grY9rweblO+di0+W8AmQGjadF464SGymhqo7De/byPXpf8OBsorSPtMWsqfy6yGBorvvpv02l30h2zvrQTyKpnpn25myec+N/o5kCQQgp2//CUDlZWUXHMN2S+84HhcoenTaTIZU0quuYbsl15CmPrna5JE76pV7P7JT1Kas8s7i1cJIlDJO/QmuZ5B3X08gjY0SOefX+bHT/bRSYQen8onfvAflC5ecAxnfPxzzFOtV61axeE4X3JO3HfffaxatQqAD3/4w5ZlixYt4oYbbiAjI4Nf/OIX3HPPPVx//fVHNK/y8nL3Zv0oYxc57K4+IYRFSDFYsWJFQkdTe3u7RaiJN455vMcffzxGrDj33HOj41ZUVLBx40aL81HTNMrKyizhCdu2bYsrGJqTokEvo62oqKCxsZG2tjZ6e3tTEr2MNGozdXV1Flehz+ejqakp7lzsATpmSktLLedLVVVef/31pPMyyM/Pj3lvKioq+POf/3xEop6Z9I5eTvnXcxRfsAgxvVQvkcifjpAkhoZCbOzwMqDotxBds2aR0dsbdTwCqJKEp6qK4uJi2tvb6TRKK0Y40vmFQiHa2tooLi6Onjt7IJAheBnnBaCxsRHQxcShoSFkWaawsJAVK1ZEl9s/F9nZ2VHHo1nwy8zMpLKyEkVRaHJokp3K58BcRg6jPR4TuQbtx2m/ft5p7Nd1f39/9Dz19fVZ3qNjifE+Ha//1mjaKYT/9Re0YDdIekN9aeZMTrkhkxN3vg2aRscrHXz78pu44a8/JjNrVKScMb2ArCznXlDHgqn4XsX7HnBJzGS8J51K192koxJ6SnvY94N90XLpud+aS/Yp2TGrJvqc92zp4dXPj7oTlS6FoVeGWPHUCr2PXCVwlWndsxKsO8JLe19CUeM8qDbckyMusFlfnUXLbckD6wzmtf4eICqS2Euik/ZqVED+lUzl85Vs+9Y2hqQhUEkpkGXcHEYXOiXiOh7N/RlzqUMQiVlHG/n/t/gUbXwg7u4SuTiFLCi96ir6hmfCd24mrbuZYO5i9vmv4uDeBeTM/ytLP9qPd1kVyBIEshEZmWiKgu/W+/A88aJt3FgEej/Fcq4nwE5HIVHFSyO30SuVUXFLGdmnnELrnLXwpYsdxUfD8RhPLJx7yy16ZQK6K9Hb1UX2yy+PlF479ZsUKKQhMxyzzKd0U33OORCJwOBg7PaShOekKk557BS2rcumYfPtzFNNgrd0BfKa0zhlg1UQTkplJVx1FT1bemgyO4dHPjNlt5Qx7fvf12dvqnzSZJklf/4z6lVXIe3dG1ec9VZXW+4Vpb17LaKjMV723r2T4p5yPEzFe5yxsZrI29tQdvwLPDJClhEZmRR87FS+X7kLbThMqL2P391wH8H1H2XNmSdHt8zMyKCwcPoxnLuVqfpepXpPetSFx/PPP5+BgRQayY5QUFCQdJ2LL76YX/ziF2Mu7zQjy/KUekPfaSYi2KK4uJjW1tbo7/n5+THin9N7IMtywl529nHjjWMez+itGO94GhoaYnoB9vf388QTT1i2TTSnoqIidu/eDRANFklUjgu6gGgWnoqLi6muro4JFzFSoru7u2NcfIkwn2/DqeZ07Mk+o4ZgZi67NZxn69ato7GxMWZOQgi8Xm/CMvJAIBAtdZ/W3M6aN18h96oTEYXWfoCdfSE2H/QRMd2k1p13HrN27ECVJKSRMmuA5ksvHXNCeKp0dHSw6557yPv5z1mxbx+lJSVs/+AHSXvve2POa21tbcw8DIeLcb06zVPTNIQQlJaWxgh+siyjqiqtra0x59sQPuNd58k+V/Gorq6OSeaeqJCbIxnP/vm309HRMam+24/ff2tkPO/5aPS30O46Im+8iMiZhu+kaQDMrg7zk821PHD+egZMN/StWoTlX/8wn//KJ9/pSSfk+H2vXAwm4z2pe92Nj7zT88g7PS/l9Z3O977/3jcqbEBU4Nj33/vI25h3ROtmrcgi1BFbBh5YGcCT67H0ldxz055RMTLpAUAWb0XLXQ3MJdGp9Grsf7mf/hf7Gdg2EHVaphLIMhYSui6TuDuN/oyruYQ0OmOWG+LbYv4X0Cjgecf9OJVtG+W//ko//S/20/DVTDTt+/qcDoPoHaBwxd3M+UQeUvlqhOl6UQcjpH3jf/C89lbMfJzQhTqNPLZiCWwxzeUwVfRSRmBlgNzTcunZ0sObX32TBcwnj5cTplo7nRfA0h/Rfq1Y56b/lBl2XEcoSrRcOWb7EYehtn49siwzsG2AkFpudceq4Ns2MPbvuJF+i3lNTaypWcoeLufg/sXWXqzbtsWG0CgKbNum72/FCr1XpF1QFAK+/W3rnFasgI4O63iyjFix4rj5fj6e/62RF1TAAt30oQ71MfTk75Ay0/GuOAEAH3D18rd4+rY/8efvPBjdbhiN5vlZ3Pv0PdFqw8nA8fpeHXXh8cYbb5zwMXNz9QRNo2TVxcpEiIappEcno6qqCk3T2LVrV9QlZXYyHmkgzZEE25iTip2IJyp2dXVZQj7sGGXHYBWR2tra2LhxI729vQnnFQqFKC4uRpKklBK8x0N2djY1NTWoqsorr7zC9u3bURQlpS+2yspKampq2GDuh8JoX8ZDDjclmqYl7V25ePFiKisrefzT13OS/CZZV5yOyM5B0zTe7lXpiwh6I/Bmvy/mBqujpIRHrruO6sceI6+lha5Zs3j1wgs5OA5RzO/3Ew6H8Xq9juKu9+WXWXzzzQBIqor30CFOeeUVvUm1bb+JhOp4ywp376byzjuJfPrTlJaU0H322XQuWWJJyDYctAZmQdnxczs8PK5m2ck+O2NlvN8tTuFR5s+eG2JzbPCVVCPlFRJ+5TE0JQJCRfi8ZJ17Ep+utN74q4f72XLvw3z62ZdZdfZqCmbk84ELz7G4y11cjgbuPem7m0hDhG3f2sbAthHRb/18ctbkjCmkJtV146VmG6nSSceMgxACUVkOW591Dt8g9V6Nu6/bHRN6Ywh+42WsCdnxRMpE/R510UxlMXdguDTt+0nk4lT6FBrOaiAQeTW67y6xmODqPKZfvhyxYAFCCIZbBF3/zkYZkDm4KYeyQ+lkE19stM9R/6lGXZpaHEfp4OuDNK5t5PAzhymK/J05/Ml0nLFBOoqciaz0pzSPxHPT4oqbCZFlIllZeL7/fbjxRrLK/YTaQ2Qr1veya/YXgFNSn9iWLZYQG297O6XiOUqffRbWmAJlnBKsZVl/HUaDZsAqPt51F5xim489lMac5O0ypZAyAmSedzXB5/+K2ncINBWR7kVetID3fW8aZ/WbvqvDEQ489SZXnvAhzrj2Yrw+D+dfeM6kckEeT0zJu3yjfHHWrFnHeCaTk4kQDVNJj06GkfxrlIDKsjwhAsZECyGgi7VO5OXlsWvXrrjblZWVsXLlSkdBLlUkSWLdunWWudTX10fTtSeKgwcPsnXrVgCLMyNZz0qfz4emaaiqGhPuA2M7VtCFoaiDMhyh9mNf4dT5h/GefiYiPR1VUXj+kJe3+kZveYynUHYhs6OkhI1f/rJ1B3HEzkAgAMRP7S4uLmbdunVIksSGDRschccTHnoIwBJogxC6sGcLMbKnOtuXgVVQLty9mwtuvTU6vufQIc566SUeue46xOLFUUHa/lnMzs6Oio72ayb49NNwww3RmzetvR02b+b5H/yArhNOcBS8jzbj/W6xf/5VVY1xZLocGzx5s/Cc8x8AqJEww4//BpEhI2z9Q6XZcPq3Cpnz65d5646HGFTgYzfcxV3P30d+furOJReXyYB7Tzo16NnSw9DnhhhiCBQItYc4/ORhKp+tdE6ujpPAm+q6qaZmR8dsSfygFkB4Bf5qP6+/cTFlyrPEK4lO5PIz0/dS38SG3phwdl1CGTeyjZss4mMikXJUOIxfyqyZxre7OxO6OF8bJJsmqvgqoHI4swjOyWXGJSchZugtaRS1iB035hN6e7TP+ht8gUquhSQ9KOPNtZclpHOQYXRxI5q23XM53Zv1UvgF/M5yzLHBMioRxYtMrCh5JDiJm0kJh/EePoy2aRNs2sTyZSt5UzuNEu60vJd5Wz8DW0pTf+h9882jydkwKgTa77WTiYVr1ujGAPPD9xtvjBUdx7quy6RHyB7ST/tI9Pdg/VMonbsQ03IR03It6xZeOYs7Z9fyyk//hqrCrTc9yKl3fpEPfPDcd3raxz2TVng8ePAgQ0NDzJ071/J6R0cHN484js4///xjMbVJz0SIhnbR5Hh3ETmFURQXF7N27Vruv//+uNsZ5zaRyOTz+Zg+fXrcvouqqrJhw4aoaGIWjuPh8/kQQhCJRBIKh+ZS7lAoRF1dXVSASxVju4kK7JjpzaKo9i3e3vEMWW17WHh2AXLVKQiPh1AwzD/7snn/By8hb/v2aJ/DZM7JVPD7/UCs8JiWlmbpq1lbWxvXqZrX0mLpKQnogt6rr8bcrBnjtbW1WcrjzYngoPcNDQaDVD/2GDAqahrl49WPPcarZ5wRXb+oqMhSalxUVBT3mln2179abt6EoqBKEnPvu4/tI4LtkT6cOFIm+rvlaDyIcBk/ksdLxrrPE971Muqh0etVCw6ihXoR03JZ8JX3sCAUhEiEM557jW9XXsHhiiI8aV4+97VPc8qaE4/hEbi4jOLek0599v1g32gIDYACmqyx5+Y9cd2J82+cHzPOWNbNWZNDxcaKmNedxux+vDvxSgK0sEbf1j5QllKfoCQ61uUnAJUAOynn+jGVPB8pzq5L8NJDJddanI/JSsMbuJ0ybsRLj2P6dKxTb9TdaTgpA+wEIMBO5vH7kXOwnPzAH9ifXoaa5iXr3PnkrDsZEchGU1X2/yaPw9uKyPM3MZ1fWdyYDdxOqe8XZIWaEUQsomCyu+UIAbaPiJcxYquinxcvfXHLq42faXSPW3A00EZGHXVjJj8OYfvpeW0rpWzFuO70ZSpoElx0EaSlpVZ509QUU0KNouivm0lFLFyzJsYYEBdj3ZEybz7ykSOqFHKZfKRVnYVyaCnhXVtBM76XNNSuFkR6Gllnn8SZpw2CpnHG2208/M2f8+E7fk96dgY1p9Zw7dc/7wZXTgCTVnh88803ufLKK6mpqWHhwoXk5OTQ0tLCs88+y+DgIB/84AdZu3btsZ7mpGQi/rA/knLmycKRlJrb+8bV1NRExQx7H0YzRpiM+XwdPHjQsn5aWhrr1q2zzMtwaZl7Jra0tNDa2kpXV1fSY5w+fTrr1q2jtrY2oUiZlpaWkmiX6BgN2traxv2l63/7ENP//ijZJ+ZRvsyDdMYixMKFCCEYDKrkve9TXODTQyhqampob2+P61CMjjkS3JLMudnb2+vY2ysvL4/29nbq6+tjynbt5yVeoE17QQFttbWWay0VQcxYXltb6yhqSqpKXkuL5TNcUVERfS+Ki4upqqpiY5ybqrTm5pibN2NMM4aAPhFtGpIxlb9bXMaGEALf4lUxr0cOvk3olYcRaT4YcTMHLljND4q20fr0PrRBjeeuuJlX/uMcvvLNq9/pabu4xODek059BpoGYkW2kRLpsbgTx7JuquSsySGwKqA7EONhKEEj/6QnKok2u/wC7MRLDyDw0UMeWxOWPE8U8UqkxcjBmPtNJisN76WcbdxE5Ygz0bgT1aI/JZzcncX8Y6QM2yra5fEK2aKRXaUXkbNuHnK+H+HzIi0/AZGWDqEQvu/+kv6XP4uHDpaY3I0+DpHHy0TIwhMaAIQl7AVIKEIKDPEzsdgaJhAjtJrHm0gJxCgBb836KIGMvfjDO5F6DunuQVNoZiro87J90FQVjLDH9nbdpfjss/HFvGQl1GbGIiymgq3MO6X5ukwJ5PxZyPnWygQ1Embo8buRMiTI0g0qnmUBLvp2DqseqCM81E/LHx7nsj8/zb3//j3p6enHYurHDZNWeJw7dy4XX3wxr776Kps2bWJgYAC/309VVRUXX3wx55133rGe4qRlIv6wn8ouoiMpNa+oqIiKfnl5eZSXl1NbW0t7ezt+vz9umIshxJnP19atW2NCQezrGBxpibYhRBnvreGaM+P3+ykpKYlpeB8MBpFlOalQZ6ezs5O0tDTLa8nKl81Mb9jD6sPbyf7kakRevmXZ/sMh+uatIt+XYXk9kZPUSJA2HH/JCIfDMa/5/X6L8GtvLGwXWl+/+GJmf//7+u2hKdDmlXPPpaO2Fk3TxhzgYryHAwsXktnQYEnVUyWJyAknWD7DkiQxc+bMaPsCiH+eDs2cyeyeHsvNmypJdNlKAo3raSLaNCRjKn+3uEwMnulzkc/+LMqBvaCECTU+i8jw4Fu1gvmrVqCpKvPa2nnhJ0/wwV8+SsijUVixgF88cMekav7t8u7BvSed+kRLpM2aiKlEOlV34ljXTZWSW0uoPzXJvcwYNCBDmCzneksysiFwLcp5gPr+8pR7S46VRCXS9n6TqZSG62LqHSziLvzsHtmuhHbOpZQ7sZadQxodFtHR/DMoZ9BeczJzr5iJtGQxwvyAtbsH39duRdrXQSXXMshsQInph+hlIBocY4ytITHAHHwcxkvfiItQiREPvfQ4Jlybz8tbfJLF3DEmJ2Uy4o0hACSJWcE/w6ZndYHNcP098URMOMu4iFc2bSZZCbUxtyPsXZ6QVMu8JxtH85wcx0geL5nrPod6qAUt2E/k7ddR+9uRCguZ9VX9YeK8gX6W/HUrXyr5MG3pKsKfxvd/dzMVVUcWuvVuZtIKj8XFxdHyFZexMRn+sDecU0aZ6Yp3MBUsWam5k6vLHNjR1tbGpk2bYhK4JUmip6fHIkL29vaiqqrFFeaUAhyPRMKaLMtkZGTEiJ6yLEd7Lprfa7vzsb+/HyEEVVVVbN++nXA4HDfwxXgtkfMxFApFl8ULNHFE01jwVCM1RYdIv+wMxMgTpeFQBFWD5l7Y1udDOvwqLW3trF27NhoyYRbR7aXqhls0lYTveEKrPQzAfuxerzcq6Bbu3s1J//43Yto0IpEIwUiEznnzqFu3jo5FiwBobm6OvveFhXp/oI6OjoTuweh7eOed+lNWIaI3OkII2j7zGf69caPlWtI0jfr6+ujYFRX6H0BNTU2WY9hz+eXMXr8+evOmyTICePvKK2NCjYzzbKa5ufmouh9d3r0Ijw/PTP2hjDx7KcPPPICm6t9ZQpIQs2ZyyjezqHz+NVA0Ona08YllH+TO5+9hxgy36bfLO4t7Tzr1mXPDHLqf7B5Nj05QIn0syFmTg5wjo/SMXQlMlB4dz00Y8O7RK2/GomaOAcN16VQibRcVEwXA2Mes5+fWHckwKC1kbvj3+HmTYaaTzU6y2OsosvWm5dN35kpmfOwkxKzZ+otDwzA4jPTGPnw//B2i16iOUR3Hiec6FKh4GeB5/g4SZKtNVPHlGKeiFvV92p2aRPs+tskXIjRBSeBeRN9hhCyjRSKIMToQ7TPUonu3Ye9ZbjgJ166FzZtjS58ZhxjqVDZtJlEJdTxH4p13wsMPOwtvYxHlUi3znky4Ls1xIYRALtC/CzyzlhLZu43QjucQXq++PMtP/kdP5dbS7YQ7Bwh2B/m/D93Azh98io989KJjOPOpx6QVHl2mNnYxqrGxccxOsCMlWam5k6vLLrjYU5qFEKxdu5Y//vGPltf7+/upr69PKvTGK2FNVKKdkZFBaWkpr776qkU0UxQl6qg0i1zFxcUxjsnGxkZmzJgxIT0SzZgDTdrb2ykuLqavry9GBJRCEcoefYFlJ/vwnHwawutDCUfY3CFxMOiJlpsbx2WkgV9wwQX69iPnyBCxi4uL6erqinF3JiOeuzOR61MIET0eI/hFAKgqHknCIwT1JtERdCHTKYm8paWFnTt3Rsc1p1Rbrounn0b6wQ+iN0c7L7mEf0Yi0NISHa+yspK2traYEn1Jkli+fDnt7e1R5+7Jn/oUnHpq9IZLjNy8rYnTLNv+2enr66Ovr+8d7wPp8u5CCImM934cLRICVSG8ZxuRt15B5OSQtXY1AAvOCfOTzbX8ouY/aFcidEoRLv/ZV7ngQrf5t4uLS3Jy1uSQ8csM0v+cPppqPc4S6VTp2dJjLc0eSdO2I7wJZBwJ3a1pCKcjJEuPdix5lmWklRVUrq+k/oz6o+Z6BBhiJl56TM69WFExYQCMA2ahdViZjpwu4Q130M9CPOgVOE5nsjN7HsoFFeRetBqRqweZHfrTMMW/uhbJVMJtMFZZ1hBUS+8qpfMfnUhbvdDpJFBqpm2sy7PZSX7B66grV1N443eQTrlNX3DXXXD11baAmdFt7b87za2XJWSzI75gqCiEnqlj6+znR69Tw30oSTHOR6d5WJAkyMuDri7rtvHKps3EK6F2ciRKElx99ahD0iy8wdhEubGUeU8WpqpLc5LimVeGPGcZRIKowUGGn/k/pKx0fCdX4AOygKvX7GHTzffyxet+QxAV7+ml/OwPt7sGjSS4wqPLUWG8ATfj6TWXrNTcaW52wcXu/Ovt7eXBBx90dNcZScLGHO3CpuHMMwtFoIs4htvNCJgxC4d+vz9hCXFjY2NUOGtpadGdQiYhD0bFvFTJz8+PmUM4HMbr9VqOffr06THzNRyt8nCYtEMDCEWl8sWXmXfBbKRlyxCSxOBQiMcP+BiI6NtoDk9uzT0unc6Lk8BaXFxMf38/g4ODSUvIZVkmMzPTEvhivG7e1jw3I/jFKIMWI2XWVY89xsZrrkm4PwPzvurq6ti1a1dMqXdrcTHrNmyIXutvbNgApuvSuHbt16F5jJqamqhwC4yp/43xWTFCfcwcSUjVZOCd6FvpMjEIj15G7Vt8IlLBLEIv/B2ECl4Pwusl69yTuHbJXrShIEr3ABuuv4v/93w9512yluyAn8WLF7nNv11cXOLiqfRQdlXZUa3AsYuMBR8oYPeXd+v3FLY07aj4OOLIOqmvjj7mW8NfDASU3lVK+z3tll6QyXoF2t2EyDIasLv7MjouajpqoqNVEB3tgdjLEt7g6hhRMVHPyvjjqvjohAFd+PLRhb0H5JA3Gw2J7rw5ZF22nMyzViEyM9EUhbYfK+x7cgUHuCOOMzN1R58GIARpd92Ep8xP5z86md13T9x1h5jJEJDNjujrAkAWlK/8Bz3rP8qem/TraPrsZkpe/lJ0HePudIhCMjzdqBENiXD8ucoyKPAGV1PGenz0xJmXRF9wPqGWkPU6vfNO+OIXHbdJeH7OPlt3F555pv67IT6qKlx4YaIt4+PkSDTGdRLeYGyiXLIy78nIVHRpTnKEJIEvA9mXQea6qxl+9gG0YA9IEsLrQV44n7Xf8XN2WydaRGHv5hYuq76Y6361HlmWKS9bGtOezMUVHl2OEuMNuBlPr7lkpeaq7YmdqqoxYqW9hDdROW8wGKS2tpbm5mZKS0vZtWuXZfmuXbuSijh1dXUx4lqyEmK7wOYk4jnh8/mifdLM+/D7/Zx99tls27YtRrR94IEHYo7JHtSiKArTdrZxUuPLZOYLJA9kfLwCae48ADr7Qmw+6COSZJp5eXnR/zacjmaEENTU1ETFMeN/qVJZWUlNTU1MME+i8xc3+GX/fstr06dPT1mgc5p3W1ubxUEb73Pk9/vjHvN4yqONz45TqE+yz/BkFfjeib6VLhOPJ28mnnV6sIwaCTO86W5EuoS8aIG+HLhocQeNP3mZhgdfpl/V+Hahj3v/dZ/b/NvFxWXCSNWtaKzbcGaDRWTs3tTNSKi0jilNu2JjhaVM0qco5NHpGP4i+2X85X48uR6L6zGVYJYGbmeeuB+/eJNhfylv9H2M3q3zQIlM7MkyESuI6sJWhEBcJ2MysmmijBsRlp6LoxhpzBoQkdLYf8IqMk/wIyTIKStCPrEa4fWiDQyz5xsSB3bo8+ilnG3STVSqoyEy8e4I4/ZJTEuDp59G0Zbr14CqsVR9I64wl83rhMmOXa4oaE89w5ubf0+PVgYqzGj5EWZB1RAfw+RRN+0vRLojnKacjUxsL3MA3v9+dndfRu/WefQpSyw9P83HBSoe+simiV6lfPQ65WHdVTiWcmtDrDvlFL0M+uqrrcuuuUZ3EY61FNjJkeiEWXgbiyiXSlL2ZGMqujSnEEL2kHHWqEM72Pg0yoFmRH4BnvwCABYtXcTtf3uJxz9yEwrws8gwX/jL9znp5OpjNOvJiSs8uhwVDMHK6PFo9KBLlfE6JhNhF1SMsmpz6XAqIp7dIdfX12cJlUmEqqqW3pB2sTKVvoVjwXAu5uXlsXbtWhobGy2iW3FxcbTnn6Zp9Pb20tvbi6ZpaJoWIzLGpENrGrOeb+Yk71tkfXYN+P0gBMKnP+3Z3RXmxW5fSiUrmqaxYcOGqABsp7i4OOXEa6dtKyoqHIOD7IK0gc/no2fuXMc0665ZsxBCMHPmzGivxY0bN47JZWrH7KB1cu9qmhZ9vzo6OmJ6X05EebRd8DTSsxMxWQW+o/ld4vLOIHm8ZJz3OcKNT6Mc2ANKGM0rkAoLqfzm6VQMDEA4zIefbOYzSz/Eoo+dgS/dx8c/cTHz58851tN3cXGZojgJiTFuRRN7bt4TXRcY/Wm/+RlJ0wZiyiTtjsXoJj0KDWc24JnmsbgUUw1madJu0efhbHaLxSjtPkKSCaJjZdTpqCR02Qmg35NN9ymrmPHxSsSsWbrQ5fUhJIlgm8prXzuB0EGvZbtetZxdXMMCfoeXPnAovTawi20aEoep5O2bsoh070ZTNVATJ3traEgeBTQ5VhgLB6ngq1Hx2c9uxz6TfnYT6YqM7KuEbHY4z/mppyjhGWYoC2nnHFs/TeuY2eygiq9Szx30KuUj16mDo87hPFi4665Rse7hh0cdhBDbT3IsODkSjfHilXOPVZSb6KTso81UdGlOYdIq3kukbR7h1/6lPyhQhxHp6eR+ZA2XndUFaHzkjTbu/dh3+b/3LSNvRj4rV1exbt37jvXUjzmu8OhyVDCcU4qi0NDQMGbn03gdk4mwl+KFQqFoSbNdjJMkKUbYMYJVNE1LKjQGAgHHZGm7s82J0tJSx/HtZeDGHBNhiGttbW3ce++9ZGRY06ONMu2GhgbLXOvq6pKnyCoqSx57mcplIbynn4kwuY00TWPrAYXX+70JBrBiCEMtLS0UFxdblvn9fioqKqLCbSr4/X5ycnKiwl3SMJwRsrKyon0eXznnHC7Ytg1Vkixp1nXr1uH1elm3bl10u3Xr1sWUh4P+vkUikaiYGw/DQQu6cGe/RhRFQQgRTbU2Ow17e3stYuyRimxOgmeyz/BkFfiO5neJyzuHEAJf5VnR38N7mwjv+BciKwuRpafSFny8kDtm1vH6pi2oKvzuN89Q9qPPcMllHzhW03ZxcZmEpOpidBISNTSaLmqi/O/lMdsMNA2kVrpsStN2KpOMJ9BpEQ1lyLpuqsEsY8IDnmkeIp1H7ohMRRAdC6MOysR0ZRYRPKeG/EtWIWYUWpb11cu8fmMJ/uHtLLGF8QCU8pOoS9NwTjoJfuZl2oidNSv4OrMf/+zIWOVk0zTSb1KNO46sDesCkcMy0GLEZ0dGbiff4AsxQTZRwuGoqJjNTpr5MgU8j583kRjCw4DNTamyiLuol34+cp06uwwd34sR56fFITiRpcBOjsQLL9QdlKZwxqjwpmnHvyg3FV2aUxxP8SI8xXqPfzU4yNCmu5Gy0hAzZgCQNqOQTxfn8vpvmhgOwdt/3MKnfv4nfv3wXe9Y2O5kxBUeXSYlyfo0jgcnQc9JJJEkiXXr1sUkdBsCTGVlJUIIx354BoZA6URzc3NU0LHPqaSkBNCFy2AwaBEay8rKLKnZhrhrYHbxOaEoSszyvr6+mJ6H5vXteL1e0tLSGDrYRfUj/6Lk/bnIlSsRHg+hYJjnuzwMKYL+iGBYcf6a8fv1dOtEcxVCWI6nv7+fxsZGAIuwV1RUpCdAO5Rll5aWRvtpQuqCWHZ2dnS8jpISHrnuOlY/9RTT9u2jY8aMaJq1D70U3RwYY5TKB4NBfD4ffr9/zEKcsb69hHnFihWW9ezJ5mZRdawim31fa9euTfmhwWQV+I7md4nLscM7rxx5+lyUtxrRlDCRt19DZKSR+b4TqT4tCJpG1b5WHr/pt3zgx/ci0j1UnV7Ft7//9UnRAsDFxeXY0LOlh6azmlJyMcYTEiOdERrObIjZJqs8i1B7yFl8NIXDWNK0HcokEwl06oD1oetYg1lSIgLiyPKKARxFt/EKok4OSjMa0JFfiueDK8hZdzIikI2marT9MYeu53NQhySG9vrIZptjGE8fi2NKw+MhAAUvCpl46QEEPnrIYyu51LKLa0wiZqzhNTqOEoH582HPHod9qATQQwmd3IzayOvG4L2UEyYnbv9GY94aKgU8T5N8CyhwGmfHdVOiwsyyt+Bf3clLmw0CAV3sMzPRpcBOjsTycrjuOjD+Hqqs1OcxVlEu1QTssSRlvxNMNZfmcYSUlknm+VcTeasBbagXpX0viBDy/Hks+3YxqCrVA/1U/18Dl5Sej1KcTSA/mx/+7P8xe87MYz39dxRXeHSZlCTr0zgeqqurLWEvoAsudgHMEE6MuZhFHSM0RghBdnY2fr8fIQSFhYWWVOGKigoef/xxx3n09fVFXY/V1dUWMdHupjTcl07usw0bNljGzcnJIRQKJU2yNno99vf3R8tznZ7CZGRkxJybcDiM1NbFac/8k1kXlyJKShFC0Dugh8cEUzAj9vf3EwgEEq7j9L44CXhdXV3k5+fHiK6aplFfX2+5nuxOScMRaU8VN4fcgC4+7rv0UgqqqjhQX89gczP09UXPtdGns7i42PLelZeXH5H7r7BQf1LvFFYUL0BjvCLbeMqlJ6vAdzS/S1yOLVJmDtLy0wHwLj+DoU2/RaQJGHFdexYvYt2N2Zz8cCNKRKHlyRe4bOPF/G7L/WRlZR7Lqbu4uBwj9v1gX6yL0dxz0UQiIVHTYreZv34+h588jCZp1jLlkR6P3gIv/pV+a5q2U5kksN9/Vcpl0b2Usy3tR3gLvKTN1lvc+PYHySrPItIdoW9r35hDZMLdcfoFJmGsoTKp4uygNH4K9s+pIufjy/GethKRlo4aUmj+7mx6XrbeZ8YL49HLmVOrpNEQHEa/xzH3SzR+LuaOkd+J/oxbluwgOhrH5qWHU7iIIWZGz+boOZV4g6st2/SJJeRpsf0bzQggt2AfuStzGWgaQLSKuMpotmii4NZrddE8DjHH1dWl9yy98069xLqpCWbP1pcdbddhbe1o24KtW/V5GOnVqYhypn6rCROwU13P5V2DkGS8i0b+1iiDYNM/UdpeQxhVg+npzP3cafzqyTr69/cx3NvJnWs+y4X338ia01cdu4m/w7jCo8u7DsPJaDi74pVSJ0vDtofGGOKhMVZbWxuNjY0Jy2qNMe3iiF1MNObshJPTrLCw0CJ+2cuzAUdh0snd2N/fHyPo5ezuYM3rL5N3ZQ2iWH9as/9wiOcO+cbTEiiGAwcOxLxmCLPmYw6FQtHzXlxcTFdXF8FgMLrc/N45iXaKosScj7y8vJiE74qKioQBLPZQIiAaOmSebyq0tbWxYcMGent7La+3t7fHlKAbjFdkG0+5tCvwuRxLhOwhY+1/oA0cRlNCRHbXo3TtQUyfTsGn9b46M4YGue3vr/D1JR+hVSiEMyW+8/vvU13jNmB3cXm34OhiNPdcNBEVEp2UGYdtctbkUPlsJU0XNVnLlDVABv9Kf4y46eTIEjfeyHxtOd2nWtv0JMJf6afmxdh/g6N9KuURsdUUTJOQI0y7jhcqoy/7PdkZe+gdipPcnQDnknJQJB8tJ5xE/pXLkSvKELIHpTvEtutKGX47NlU2Xu9JkNGM5O8RtOhybK9p7OUKlvP/4vRvdC6tHgvGOD56RlyVECELDQ99Ygl7tSsAjXKujzpdO7VTyOPlpGnc0sqK0evw5Cp46SXLcsNNOU+7H1BBcf47RpMkUG2l5Kqq/+/qq0eFRuNecuVK2L//yEqBkzkMbb1S46ZXJxon1TFSXW+qMtncnFOQtPLT0ZaciDrUizrQQ7jucURGOlnrVpMFaKrK+m07eeCTP+DWUAhF0lj50fdww/f/81hP/ajiCo8u70rMIold5MvOznYUUOwCn1nYAl2IzM7OtrzW3t6esKwvXjnqWMpWKyoqaG1tjbosy8vLefXVV6NuwtLSUlasWMGmTZtiSpGdhEYnBgYGkIJhhKox49W9nKzsJuuq0xA509A0jW2HFBp6kvSCdKCkpIRt27YRDjs/Wbe7E42Qk0S9Nfv7+/H5fJb3R1XVaGBNUVERra2tlvWdyr1VVbUItv39/WzcuDHqPC0sLHQUE+3XhSFO1tTU0NDQkPI5jxdQY78WJjJNerKWS7u4pIIQAuHPBUCuOZfI/tcJvfoUIk3vMSsyMsm7ZA3/vXQnSu8woa5B/njZt3n16x9hweLZDAwMkp2d2IXt4uIytckqzyLUYXMxmnsujmD0gZSnyUR6IsQEBjtsA8RNvI4nbgKOjqwcIHNZJoOvDSY+oBTw1/jpq+sDDYQkQAItnErcn5Vsmmwl3bHiYTxhL5sdgIQYUuMmdyfbbwS9RY+KoFcsYZ/nAvJWvcSMy5ciFi1CCMHw7iDbv76MSK9zH7X4vSdLCNCMWdh0CpgRQIgcsngDL4dTFhmTiYFO2JO7PQygIXPwhM/C64NUqrEl4wo+PDhXPEWF1O5uXVxaswZuvRXOOANNUSxl4e2cwwJ+h0gUC7lkCeyIE2gDscJcbq6+v5tvho98JDVRa8sWvYTaLI46OQxT6SOZzKmYai/KiexZOdlw3ZwThvBlIPsykHMKkQvmMPzkvYg0/e8zIUl4V5zA5d/O5iNvtKNFFF575kWuPPtTfPKGq+juPkx+fl7cCrepiis8uryrcQopsSdOG9hLSXfu3GlxyQWDwRgxyqlUGHQHYnl5OVVVVY7CkX1f5iRmu7jU2NhocVnaBUYhBD6fjwsuuCCmB+D06dOTutqkUIQTHn2JOcoBhAyBsjx8Z56JyMhAVRT+fQD2Dqb+VSLLMhkZGZSWltLe3h5XdIzuX5KiZcdCCDZs2BBNInfC7EIMBAL4/f7o+WhpaaG6uppAIJA0EbujoyPmNfs41dXVbNu2zXIdODlJOzo6WLduXUwJvT0ZPR6BQIDs7GyKioooKyvjiSeeiJZ1m8dsaWmhtbU16o41rivj/HV0dFjKoONdd0Y/0/b2dmpra8clZrq4HCs8s5ciz1oCgBYcZOiJ3yJlpeGtWo4XSAc+XbWXZ+74C093wSMo9K2czS//+tN3dfNvF5fjmTk3zOHwU4ctDkBLz0Vi06yjpabx+jSa6NnSQ+SQQyiL5CxUxqNnSw+DO1IXHYP7gzGvRY9DHS391tSxC45gL6EeFbrs4mGikmh7eXOy8JRsmljEXSOipS7AHcyez0D5YuQsiTm5L+D/wImIQr0KpOtZH7t/WIoWcf5jPVHvSb1sWYsKq8NMJ5O3LcErjKwfYpqlnDqZqKiZfo5HRtC3VViy64uE1XQEalQY1M+pQEZxSN22jWGUIRvl0H4/9PSYzoleLm64SuPO2fQQPynm8udURS1DBItEYseyOwxT6SOZzKmYai/Kie5ZOZk43t2cxwjJl0HmeZ8fqYLUCG75O1qwE2n2LNJnzwKgelU/3/39S9x/5R08pcGOtDC3P/0L5s+fe2wnP4G4wqPLMSWRW2sinVzxMEJjzMRLnLaXktpFJENwMspw7SXcZoQQ0YRlcziNua+eeV/2/pLNzc3RcnC7cGgvTzYvtwuaqqo6Co9CCDweD3L3ADWPPc28dbOQ5i3Te7Jk+hEeD+FQmE3tHrrD1lsSSZIQQsQV1BRFIRAIOIbBOKGqKh0dHSmlWAshLKXtTgLyrl274iaGjwVDTKyuro55H+0YzkFzL8/CwsKYXqPxktQXL14cvR62bt0aXdba2hqTOm5cv0BMv0b7fzv1c3TqZ2osGwvvxOfXxSUZxtNikZ5F5vlXE/z3X1D7OkFoiDQf8vx5nPWdbN7bfRg1FKFl0x4uW/EhPvq9zyJ7ZN773lMJBPzH+ChcXFwmCqMc2pJqbe65iEOatXH7IYMnz0NgZSBmG/O2jokiKo5CZTxe/+zr8VNJ7MQRNaPHMQE9cOL1RrSLh3vF5eRq1pJoZ+egc3K3wajQOerE219YTtZly5lxShl4veD1ITIy9fY7v5tGyx9mYJfJDPHSTzPSyBsa03tSvppeRe892cQtZNNEFV+NztucYK0hSKMzOo75ZzzMl4NZ3BMAxn1RRgbawEDS8QRAOIiXoMM51RImcUdfN+7Pr75a379qfX9G/zv2fbPQ0zM2IXVoyCoiGvM46yx4z3t09yOMhsSEQrFBNeZtzQ5Dp16p9j6SyZyKqYwxlvWmIsezm3MSoN+TCtJP/RDh5q2Ed70MaOCTEX4/Mz99Gv91TitoKkM7O7jj9C8y678+ROHMGSxbtpilJ5Qe60MYF67w6HJMSRRmMZ6gCyechJB4br9UettVV1fH9Hk0xCiILeE2k5eXZzm+ZPu2v9bX10dtbS1NDv8Q2AU/c7lssl6SBpqmUdynsHTzJqZ/fAXS3HnW/Q+EePygj2EHbVFV1aTJ2m1tbTG9CxORiuhozNvM4OAgS5cutYht5tLnbdu2xZRGp4pxXlVVpbW1Na6z1efzsXPnTpqamsjPz2ft2rVRcc8uOhYXF9PR0WH5b+NaNa7fbdu2Wfbh5LBMdv0mu8acej2OVUic6M+vi8t4EZJM+umXRn8PNv0Tpf01RG4uIjcXCZi7YC7/+/DLbLn+14Q1ja8H7+TyP3znXdX828XleCdnTU5sr0UT8dKsCYNyWGH+emfRMbqtwy2LnCOz5yaT2Ll+fvyybGBox1Cyw9CR9PJpJ1Ez7nEkwamkOl4JtV08dErZ9tBHNjsdypudk7vBLHSCImT2LTqJvE8sw3NiFcLrHR0npBC8+SnmPv8ceSNzNbYPsDPaH9FZjBNk0Mpy9f9ZSscXcRdm0W1UqBTs4sss5n+PuGejRZPOyYGlS3Un4PCwo16daDw78dyJCV2LCe6vk7o5hUATApHiPToDcVoNBIOwebP+P01LOCcLRmgNpJZePXs22FskmZ2KqSZgjzUpeypxPLs5JxnexSvxLl4JgNJ3iOFn/w8pMx2xcD4AmQsXcP28Xfz753+nLyx4NKTx23UruOXn35uyJdiu8OgyYTgJE8lIFGYxnqALJ5yEEHtPO4NUettJksTixYst4qF5O/vYfr+fcDhMXl4ea9euZdOmTY7jGmWx9vk4zTNRcrURkpOoTDveuPlN+6g4+Co5n1yNyC8A4O2eCG8Pewir0DqYPESmqKiI7u5uVFV1LKceHh5OMkJynEJzzGiaRlVVVYwb0SwQO4m/iRBCRMvfATZu3BjXuWlPF29ra+NPf/oT2dnZdHZ2Wtbt7++3lEwb7sfW1tZo6XMqDlEYvQ7jBdo4LU907RYVFTl+fgzXrtO1NdGfXxeXiSat/HSU4oWEXvs3A709ZEphRFoa0z50Cuve3wtonPtGK/d/8vv8esVMMnL8rHnPKi6/8pJjPXUXF5ejyFjTrJNuK4HSo9C9uRsUCLWHOPzkYSqfrYwvPiZQoKr+XeXs2LSFQkyffSkt7fPHJD7GK6nuY3Gc3og28dADveFyiwvSGNMaDCPYyxVx5xEYESqDcgZtVSdTcMUKpBOWIiQJ2jsJ3r+DzuDJLNj2XTIOdkXnmsdWtKg3MbFwJtDw0oPQsJSO6wnX9nUBVBZz+8ixj61s2ry+AF3MWb16dAVl1I15pMQTHe37H++Y0XHnzoV9+8ZdQg7EuuyOhETp1Vu26AKvE2anYqoJ2KmuN9U4nt2ckxg5kE/GuZ8jVPcE/QfbyBQRRLoHz/LFnPHfRaAoaH0D7Lj3NT5U9SGKKhdRUJjHf33rminVm9wVHl0mDCdhorKyMuE2icIs7MvMASFjKduM5xRrb29n7dq1gF6y2tfXFxUGDVEpGfbSZbPY6rTMPOd4ol9zczNCCCoqKmhsbIyW5To5LBNhhORs3brVImhpmsbKlSstc2xqatIFMk1j3rPbODGvg/SPnYHI8qOpKq8cVNnZH/t1kZaWhs/ni5lTf38/S5Ys4QMf+AAbNmxwPM5UQ1YSsXz5ciRJip5je3iL0afN7/db5lhYWBh1HCYTL+0YAmBjYyM1NTUJ+006ES/Mxk4ykVGWZWRZtszdKZE9UY9HY3kq1+5G2w1Wc3Nz3DYB4AbVuEwN5ILZ+NZcwmsNDaxYtoTQk/cgZfpgmh5S46vJ48r10zj9vkaUgxpvvbiLT9y/gd9u/A0ej3sL5eJyPFLwgQK6N3U7L0wUEoMpCdvoIQmjDkhl9KcmJxYw5RwZpSf2PknOkclZk8P89fPZc/MepK0vIC68GjW8E6m3SxcJVBXa2ylhM/3cQY9UZnVhGoqc0bPSRLySamBEyksiHjq07XZyQe7lCnopczz2bJrw0kOvL5ee005k+uUnIs3R+5yJ+h14b/wlO4Z/xDzuQzKJocLUuzGVMmirGDhaOh4Pu2sxpmw6hf1EMZevHun9sCRBIAA9PXH3a3CkwmDCY9u/n6F588h4660jHH2c7N+f+ro33+z8+sqVx4dTcaI4nt2ckxzJm4Z35XnsbWigoqKCyCuPoQ60IQJ6cK2Ylsuyr+Vy559e4tDuZga3wdce+Ddf3/wTFi9ZdIxnnxruXbPLhHEkDqdUhTtzz7uxlm3GK2kuKiqylB4b65hFpWTYS5dhVOg0XGr9/f309vaiaRrV1dVR8dE4Pnu5b39/P7W1tVGnm3HMNTU1XHrppXH7CdrLm40ejnbBddeuXVHhUZIkKhYuRv7Jnwm+/TYZ6jDzT8vGc8rpCJ8PJRzh6Q6J9qDzV0Vubi4DcUontm3bhqZpKQuMycqzDYQQ0VJkQ8w1znlGRoZljIKCAu677z6LOFdcrDchH6vT0Y5xXU4EgUBgzH0nFUWJnluz4GgWt+2OxLVr11qWx7vGna5ru5DoJIAn6ieaigPaxeVYIvkyyFx3NUpbM9rQAJF9r4M6gDx3Nou+WQyaxuL+fsr+UMsVCy+gJ9tDRl6AW+/74XHV/NvF5d1Mz5Yedn95t3OfRoibZm1g9JDcfd1u+l5K8KA4iYBZ/Jli9t8aK6wsvGVhNDQmoL5KuSnZWAOE0XJG0VNxTlj2EDvnnkbfVn0uWlhDeIXlJ4A6qIIEAfUtRDi2pDqdg2MSD+30Up4wSEZHIzvwKNOmv8weaTWZJxaQ/8GTEXl65Y3096cY/lkTr2k/opeyOOXfqeHcC1EdObYSsnFOa3YSNMcsOoK1fNVe2poKkqSLzAnum1MRRY8UY+z0/fuPyvhJGWv5r1PvQhibePlu4Xh1c04hhBCkr/4AyuEO1M79aEO9RPZvR2Rmkf+JM8lXVVAi/HjrDn569rW84NcQHpmPfPkyrvz0Zcd6+nFxhcdJyFQNZTgSh5OTwOG0zN6LcCxlm/Z1fT4f+fn5lsTeiSwLjSd01tXVIYSIHpOT6GnG7qRrb2+PblNVVUVdXR27du0CoLS0lMrKShoaGqKvGeE3djefuQ/i0O79HPjqtSxak4t0YhGk+RBz5yFkmeHhMPXMQuTJEMd9l+g8BYPBGCFNlmUkSbKUXhvvh3m7tLS0uCKkJEmcf/750d8NJ6zZIWiMGc816JRYnQgnV6RRfpyKW9IeemNH0zS2b9+O3+8nEAhw6NChMbkwDXernSPts2j+DlJVNVpeXl1dTUdHB729vY7CY6J+oi4uUwEhSXhmLQXAW1JDaMcLRPY1IIyU62nTmPWZ0/jZkkaCnYMMHRrm16d/kbN+dz3vPevUYzhzFxeXiSBhIEuCNGszOWty8OR6QMZS5mzvndg1+wtArJOoZ0sP+++IFURm/+dsZn1uFo1rG9E0jXmq3Z1oRaAiXtvG/F/p/SQd07pVLM7HPhaQxyHHkmpH8XAsjQkTopA35/fMuXgY36KVgEDMma1X3igKvv/9P8RjL5KBnzLWm+YmEGOYgFmIc0p/HmY6e7K+xIrBa9C0JOEqKRBXdATo7oY33jgyx2NgpLwyjtsxEU5iZDyBMmHQjaKgyTKaLCPMxyBJkJGhh8moqt7LMjcX9uyJP5hxTpx6PBoiK4yW/4J+/mbP1gXI9eudk7ENnHoXgrVPpIvLJEOeVog8Ta9a8yysYviZ+xEZPv0z4fGQvqaKr07P5jP1+1HDCq/c9keu/Xc9t/32h5OyD6QrPE5Cpmoog5PDKZHYMhbGU7Zp39YsSMXr9djb2xsVJccq+iYS48zLVFWNioc+nw9N02IEObP4ZHbXSZLEypUro85FAyFEVBCqq6sjYNyYONDzzFYGfnIT0z9ahSiaaVnW1RfiiU4fK6rmcKbJNRdPcEoVRVHIyMiwHKeTQBgOh+M6INPS0iy/OyWTh0KhuMJlX18fS5YsiSn/TiYOmjHclvby43h4vd4YIdHv95OdnU1vb290rsFgEL/fH3NO/H6/5b21E+/zcKSCupN43traSk1NDevWrbOkXoNzibeLy/GA74TVeEtr0EJDqAOHCb74D6TMdDLOOpEMIEfT+MYZzTz0+f/hE4M/ICg0Fn34ZL5/x7cn5U2fi4tLYuIGskiQ+/7cuGnWycZx6p2Yt/UzsKWUHsosPRuH3x52nEPPv3osYzs5/swYguH+kZLuuGndpiH2cjm5WFOp4/VjFGkCOSAT6YzELMMDOLzsiDTEjGX/x5xPZCNXnISQTX+eDg2T9s2fIG3bDYBMT0xISyquPmNde2CME8qAQi9LyJZ3oSkRy3YTwsqVer/BrVsTio4JjytFwTFVMfFIjk8DhmfNImPfPmtPQIDh4VGxsL9f/99IgnYUSYITT9Rdh0ZJr6aNploDVFbCbbfprxvlv7NnW89fe7vel/DZZ2PFR6PvabxzvXWrvk4i0dLFZRIgZU0jY90X0Yb6QFMIbvkHyCE8ixcxbbFean32ui7m/fJlPjv7AoKo9BVlcPfm35CXl3uMZ6/jCo+TkKkayuDkcJqIPn4wvrJNQwA1nIB2Qcrc69EoYTZSo43tx+JAjde70VhmUF9fH+MILC4ujgpgdsej8UdsIkdsKtfKwMAAz33tZpZ11zHt8jWInGkAHB6MEFY12oclGnt8aFhdlkCM4HQkhEIhampqovNPFMziJD7Ksmw5B2NJxzbGraqqspSyQ2witn0bY98zZsyIliwneq+T0d/fTyAQiAne6ejosMylqKiImTNnRq9fM/agGztHKtgnS3tP1r/UxeV4Qnh8CI8PKTMH6dzPEXzqPjQRBknSHZLLl3DJd7L5YGsnWkiheVMjl59xOd/5zfeQZZkFC+a6nw8XlymCYziMrIuOiZKwk43j3DtRJnzdd2iovTEqCMYLtQHob+i3jN2vLHQIfDFEtVHBcHikpDuVlGujH+Mi7sKPLvb1U4KTTCc8wll0BOQsGXVAtQqdJgz3p+xpo+fkZRRcvgKxaJF+r9vdg9jfgejuw/PLh5A6Do2cM2J+jicF2ilAJoNWKvmq7hZV4o9vFjLHVM4shO7+g6ROx6Px6MouwBqvHem+1Kws1KeeQv7v/x7tCdjdbRX6FGW0H6URLGkIik69A1980XlnxsP+kb/ZLOPLsi4wGuts2aILmC+9lPwgzNu5uExihBCITL3nY8bZVxGs3YRyYDdIAuHxIHLzWPKV07l1x5tomkbf9k6+VfFxLrt/PTNnFlFUNINAwH/M5u8Kj5MQN5QhlvGUbUqSlNQtZozf3t5uWa+9vT1lB6q5t6NZQDSEs9LS0phQD6e5FhUVOYp7Rm/CRPMpLCy0XDtZWVmWOaCqlGyqpaJkEN+Hz0BkZKCpKvLSM9j01Esxrjxzwraq6jeQhouypKSEtra2uCKVLMtUVFTQ1NRkEdc0TYsKa5qm0RPnqa2RCC3LcoyAHa+c3Yzfr3+x2t93n8+HJEmsW7cupkTbIJ77UVGUaA9QQ9BOJZzGyfEIej9Rv99v6fFp3+/AwEDc3o/2oBsz9vfLfv3ZsZdXO2F8Fx3NMuqp2mrC5d2B5E0j49z/APTPX/CFh1EH25GKi/GNfEeXVQxw0/+9xN/P+k8iaNRKQW7e/DNKFy9MNLSLi8skICYcJsXy6mTjOLoTFQWtockqziXQorSQxvOznydttl75sVe6nFzV7E7UZbAQOfSxRO/BKJcRmJ1G49pGwp0OyS9xCNAcFUqz2Ukl19LA7fQy2ldPHYjjtpQge3V2NABHefyflhLzTk6hlJ/QkzGdwfdXM/3SVYhC/f5CPPsKaT/8HSKinwgnocxMquJjsnGMdSSCuuiY4n6PSLRL4nQ8mkyU29HYztfREdsTcPbs2ONT1VGXpixDba3uYjwSnPo1msN6tmyBM8+ESAqWW/N2Li5TjLSac4BzAIgc2Eto6yOIjEy81Xrv3bwqlf9e3MTfrvoxr0Rgvxpm4ZfX8eXrv3BM5usKj5MQN5Rh4rGLY4FAgOzs7Jjz6yT6pupAtYthNTU1CcUZJ7ec0/7S0tIoKyuzXBdm2traqK2tpb29PUaga29vp2rREt5++Tm0iML813ey5L05yDVrEB4PkXCEzFMugaw88vN3x4hwu3btQggRdX2aBbD29nbOO++8aPK2OQAIIDMzEyFEtJ+mQTgctqRs27GLfvZjysrKignMcUIIweLFi2MEyuxs/UmRJElxBS2PxxPjRDRjCNKphsFkZ2fHDeEJBAIEAgG6urqIRCIxx2sWJRPNxy7YGT0+DYQQCQU8+/VbXFwcDe4xAn3eie+iqdpqwuXdhxCC9FMuJPzWq0R2voCmquABkZlF0VWn8bnzDgAQfL2F/33/V5A/cRp5+XmctLqak1ZVH+PZu7i4OGGEw5hLn1Mtr040TjC4GF9XN0I1/RsvywywIKkLMYoGoZaQ7ooEtBNPYfsbP2Vu+D7Se3bFBr6M/JNvBMvE7Mch1RriJ1vP997P6zNuRw2qcZ2OAEIS0XNWsb4fbdO1IyKTipwmky+10pa5BN+FS5h2/mpEdo4eRvi7LWT+4Q8YMmGqYqHTcnsvx2TjGMgMpyzEHZH4qGnQ2RlbdjwF0QARDiPNnQsrVoz2WXTop2g5R04OxbHg1K/RHDZz882pi5qSBMFg6r0iXVwmKZ4Z85DO/ATBF/4GoSE0LYJI85F2cgUfWVQMoTBq7wAv/m4Tn3huKyedvZqCwnw+fPH5eL3ed2aO78heXMaEG8ow8dhFvsWLFzueYyfRt76+PiUHajKB0i4MVVRUWErADUeafX9lZWWWudqPpbOzk9bWVsc5ZbZ0U/CXW1k0XyBkge9DixClpQhJom8gRGtRDZXZ01EUheLiYvr7+y0OQXPJuZPg2dDQwMqVK6P9Kvv7+wkGg4RCoei2hlMzVRKVXzvNIx69vb2cffbZMSXV5vnYHaKBQICsrKyk+1BVNe46Pp/PkjgNo0nc8Y7rggsuAOCBBx6IcWimEjJjBN2YBTt7f0/zvp1chfbjMVyhE8FYXIxTtdWEy7sX74IVeBesAEAdOMzQ0/chZaYjZs0CIH3mTP5z1m7qfvVvhsJQe8ej/PGspdz6m/92+0C6uExCctbkjKmsOqVxtvxId2EJUy88Ieis/AJsxSoKxhEEo4w4MT25HsoPfp6eLR9l23W76a/rR4tooIHwCvzVI5UfW/tiREeRJpj2nmkUXFhA+z3tlgRu57RoFT9vsfzB5Wy/dHvcqYk0QeXTlaNC7c03gwAVwb5Fq/GvyUdOlwlMz8Zzcg0iPQMtFMZ3869Rnm+h0ZSc7aEHmcQuTadSZw1QSEegACoq6cgEgUjisBTGnpNjD6pJSeQUYkJExzHt8yjh6elBHD6sC4GPPw4FBbBI7zdn9H10FGaTOQ2N3oxG+bZZEFy/Xu/pKFs/S9x4o748XoK1HUP87erSfybqFeniMgWQMrPJOOtKADRNZfjpPwCDSNNn6MtnwZpvzWDOb19iz68eZiAi8Ylv/4b/3XIPM2ZMP+rzc4VHl3cFqbpIJUmy9HSsr6+P9s8zC4aGw9AsoiQrkXdycjkFxCSbq/G70Y8ynjCVv20fpxx4lZxPnQQF0y1/4Lb1hHj6kI9C0cmKkZsfIQSlpaWOLj5jLnaH4q5du1i5cmVC958kSQlFNzM+n4/CwsKogGkP3BkL/f39bNq0iXXr1llKiA2HqNM1UFJSwquvvpp0bKOc3kwgEMDv9zsep1ES7YT5fYl3/g0R0SxKFhUVMTAwgKZptLa20tXVZdnG7pQ0u0idrkW7CGsus7cz1nLosbgYx9Jqwi3LdplsSFnTyFj7eSI7nkcb7EXpakP4BJ6lpZz4/VmgqpzW18fOexq56IQPkDm/gLziAm6+7Vvk5k471tN3cXEZAz1beqzOyPV6erQja9bogoZZTLnxRmZoy2k9syGmtLvkZyV0/qOTgaYBwp1htKBNElP0no3RpGrVmsStKRr9tf3I0+S4jkpjvrM+P4ueLT28uu5VlB6Ffpx6R0r0hRew7cwG/DV+Qi3O957T3jPN6g5taiIkfLRXn0zBJ1YgLV6M8Jj+/OzpI+0/b0N6q40eTrQkZ5dzPXlsTRigA1bxURt5ZZhCMmlBoCAxEONOPJIU57HNIQGm+7GxiIbWvpKjZfVDzCSbnWiMP4V7rAjjWAwhtbNT7/GoaRAIoPX0jcxVsYnDEsJwKNoxSqU1TRcQ29pGRc2VK3Xh0eGzhKbp/R87O+NPWJb1Mfbv152OhugI43diurhMIoSQyDjrciL7XkNp3Y0WGkQd7EbkTGPul97D3FAIIhFO+/cOvl/zSTqWTUf2yfzH1z7Fme9x6L06AbjCo8u7grG4SJOJJOaAFfNys2BYWFiIpmls2LAhrqMsnpMr2Vzj9aM0KC4qwv/Qs1T495P+sTMQWaNNZDVV47WuCHU9PkAX0Orr66msrASgoqICIURU1DQwjqGpqclR6EzkSissLKS6ujqmn6KTmBYKhWgwkuwmAGNeNTU1lvettbWV5ubmmPW3b98eU+psiNH2Y+/s7IyWIxvnx55ybZTJ79y5M+4cNU1DVVUkSaK6utrx/AeDQXw+H36/n1AohM/no6ioKHqu4qV/m+drFuScrsVEQqOdsZZDj8XFOJZWE25ZtstkRPL48JWfGf19+OXHUHv3ITIyARBZfpZ+JYdf/OMVet/uYnBXF9+s+BjXPHYby8uWHqNZu7i4jIWo4GcKhTn85GEqn61MLD7a7hNyIG5p96zP667pxrWNdG/ujgm8ySrPGk2qtmtzKmhCi65rFx+1oEbDmQ3R+easyWHFhhU0nNnAXtXeO3I0qEaLaAy+Phh1ZRohMUb/xrQLvweMukW7p5/AwDKZgo+tRJoz1zIHsfMt0m74KfTo9zABdlLO9ezlcnopNyVsj1UQ1Mhir2N4DABeLyInB627B5TwhIl1yfpCxtsm1XJtY10FL4epspTVZ0tNrJBuwBOJvR88WsSdr3Ef3dMTtwweGHUo2jFKpY1xzKLm5s2jrkTzZ8kuVjqxapU10Gb27Fjnqdvz0eU4wzNnGZ45ywCIdLUSeuEhRHoaeHUtwL92Fd8reo32p/aiDsO//+MWXr78PXz9u1+d+LlM+IguLu8AE+V0SqXkNNnvzc3N0f07pT8bgshEhwY5ORCL86dT/o/nyZvbheeU0xE+H2pEYV92KaU1p9L4ahN1b9VbtmlqaqK1tZW+vj40TaOystKxBFySJMrKyiyOvNLS0rhzsWOUcoPuLBRCOCY1O+H1epkxY0ZMH8lkaJrG1q1b6ejoiHnfnERbJ1G1sLCQmpqamJLtcDgcdT4a58fuGly+fDk1NTWOIqdBW1sbGzZssAiYhuvW7Go1zy0UCvHGG284jifLcvQ9NL9X5ustlV6mHR0dcec81nLosVz7Y3lI4JZlu0wF0k86D2XgMFrvQdSBw0SaX0JkZDLtsjOYBmiRMD/c+hq/Pv/rfEMKo8qC8790MV/4yqeO9dRdXFziYAh+2cqI8KbowtuB675AzotXjWmsZKXd0aAaySQwqlBwYQF7b94bv0ekAgKh98528OFpqsaem/dE9z3al3Ia27f+lJmHfodfe9PSOzKbJub16EJjKL0Q//AOQC/F9kndiGvOh/JnYc0aDj3wOJGlmeR96GREXj4A0j+ewfe7h0FVEYPDo3MBfPSQx1ZyqaX5hF/SebCKhs7bqeC6lEqujZ9JRbwZM+h5cDtvnvF7KvgqjPSz1ExewneSsaZzR8iJukIBkKFPrEAWic/RRJdmp9rb0mkdxZOJx9yH0Vxa3dkZXzyM50q0i5UGaWnwnvfoIqc9QTtZr0gXl+MMT95M5HM+j9L5NqgKofqnEOkyvpoy5taUoWkac9vbeeWn/+RDv3uCiKyRUzabX//pJ6Snp49//xNwDC4u7zgT5XRyGieZSGJf3tfXR319vWX/ToLI2rVro/89EaFBVVVVujDV2wuAtz9IyUMPUHBuIdLyVQhZZng4xMZ2L/3Kmwz4cqmqrqGlrd0ioIVCoejvdXV1tLW1WZYbpcBbt25l165d+Hw+fD4fixcvprq6OjoX49h6e3stot6uXbvYtm2bRThrb28fk4AohGDdunVEIhH+9Kc/WRx+fr+f0tJS6uvrHbdtamqKcTHaMZLP7evJssz73//+6DpOGK7ReNefqqpkZWVZzokR2mIeA/Rr0BCBQ6FQwnk7pW4bczYcjFVVVezatYtQKERzczOtra0IISgqKqK6upqOjo4x9zI1lqWyrlnYN5LeJzKkZqLFfBeXo4WcNQ2ypgHgmbmE4afvQ2ToT5uFx0vayRV8YXo2n2xuRw0p1P3uYb6wpZGfPnBb0mAoFxeXd56BpgGylSYquTYaxOKji7yXPgNbSie0R1zOmhxK7ixh19Wmh7UCdl+zWy97bg9ZxEezCzHIYqQ7v83Wr6QRo92ppuAZ0750IbKCxrWrLU7LbGzHO9xpEZWEqqAJGW66mbbV55Pe+U8CH9UrbzRFxfu/9+N5bEuMEGUWsIwgmxm7f8WhnNvopZx+SshmR0wfx0SJ0/HQJJm+4DwazmpAU8poMPWUFITx0hN/2yRjxyWFIJlUx9WAYabrjlMNPPkeAisDLLqwHXF14p7gdkdmsrLzZIynLF2O9OsOxWef1V9M5lY0oyh6MvjataOl1vGSwgsK4pdNJ+sV6eJyHCI8XjxFeh9WubiU4eceRAsfRoz8LSyKiznp+ix+/cIONFWlc0cXn172YX78r7spKp6hr3OE/cld4dFlSjJRTqcjEQijgp9JSLKP4ySITHRokCRJLO6DrN8/QrpHwRcQ5HykAmn+AgD6hjU2tPkIq6NzNAJD6uvraWhocBS2Dhw4YPm9vb2duro6i3suFApZEq+NYzOEQTNOzkJ7P8JkpKWlAdDY2GgRHYuLi1m7di0NDQ0EAgEGBwdjjimZ6AhYRED7tps3b2bmzJn0jgi8TjQ3N9Pe3s7Bgwctr7e3t/Poo49aro+ioiJmzpwZtydmqoJsMBikuLiYvr4+yzkJhUK0tLTQ0tJicZkagT+gl5pXV1dbwmPilTg7uYJTLYcea9L7WBlLWbaLy2RByswm8/wvoYWDoGkM//PPIIaQFy0ga5H+/X36mYeZ9auX+frcDxJGZe80md88ezfTpxcc49m7uLgApM1OY15LbPqzhpRyj7ix9IjsfLjTWjJtKqUWQkTdkDHiYFc3XLOObG6nl7E5uaJOyxGPXGza9Shhycf++TWIOTmIsEYutXjOO02vvBlSUL75EBnbEouOBgKVrPCbhDvDZNNEgJ0x2+g/BYaXMxVRUgNQFdI7t1PG16Ml3YZ7cDWXxBXTNNPPMYt1gQD0xBc0k83bTjavc2LgGjK8h5BWVsAHPgDXfDn1JOcRxiM6jhcBuhh78836C6mKjgaHDull14qiuxZVNVbgTeZejNN3NcYZ6eJynCKEIOPMy9CUCKgKkX07CDc/j8jOJvOcVQBkvj/M/z5dx69Xf552ReGgiHDxbVfzoY9cMOb9ucKjy5RkopxORyIQSpLE4sWLLYKKff8VFRXRwA+v1xtNnbaXhB9JybixzcD9GznhcB1Zn6+BtHS9Z00gW59j/jz2RfIJt8SW2hrHZxdPDexCXWFhoWNJtJFa3dTURFlZGdXV1WzcuNEiggkhHJ15eXl5Y3I8lpSU8Morr8T0fzx06FCMA9JOVlYWAwMDlt+zs7NT3r/dASrLcrQvo0FfX5/juezt7Y2ZW1dXF+effz5CCNrb2+np6Uk4/3gYpd5GX0hD+DQ7S+0ishkjGMjAuC6M62vjxo0UFhZajt/sLk70GTHG2LZtm+X1iS6Fnmgx38XlnUR49QcqGe+7gmDjMyj7t4MAkeZD5Exj0TWn8d239oGm0d/Uzk3VV/K+n36Z6YX5VFYsP8azd3F599KzpYe+rX1x059T6RE31h6RA00DsSXVCgy/MYy/xk9/Qz+oMF+7HxExiYOqgobEPO63ludG5xtfdjJKr5suaiKzs55p1DsGvQx6AnSevIoZl5UjZhTorrGcXIQkEepQeftrEco6noqzJzEiflkDV4bRE1Z1sTNWHBtgHkEKCbATLz0WEdKO9TVhKeluMAmyeqhOp6M4qpCOStrICBE8DKQm2gkBCR5cW2eW6joaWT0j91ebD8CmTfp+joBjITpGUU2flbGIjqAfr7GNooyKjmN1Lzr0XXVxebchZA/IHrwLKxF5xYS2PARCBY+M8HjJfN+JfLn0bdThEEr3AI9/926+9Xw95192HvPmzqawMLVEbFd4dJmSTITTKRKJ0NraiizLyLLM8uXLUxpHVVU0TYuGoxg9EM00NjZGxZpgMEh/fz9tbW2oqsqJJ54YXe9ISsbrttbS94NfUVU6iO/iMxDpGdFlmqaxO+hnReU5VKkqjAhSTucoXoLyWAmFQtTV1SGEiHEyOomOhkuxsbExrvgJRMtyi4uLY/oVmvcdL9Ub9DLsiy++mL/85S9RcW9gYIAlS5Ywc+bMuK7PRIxlfSdBMRQKUV9fHxWZN2zYkFR49Pl8cY+zo6ODdevWoaoq9913n2WZLMtJ52sXv83n2qlvp5EKnkgstzsdDaZ8KbS5B1F5uV6mM4HldC7vXtIq3gMV7wEg0rmf0Et/Q6Rn4DlhMQA5S0u5adF2nrjuLnYo4P3FfyEKxt9vx8XFZezsuXkPgGP6c6o94qKhMMY/0QposrXnopms8qyYkmokCHeGCXeHo4nYWYqzGOrnzdhJSOBf6Y993UTOmhwqvzdA5tXXIhyaSR7OKGTw/TUUXLoKUWj9N76/SWLHDSUsH/qm49ga0MvSEUejtbdiNjvJpimOuAteBtg6IqSaS8s99MT0gxSAigeBanGnMiLI7uVy5nF/jLPSjMwwHoajQTv7+Ahz+FNy8XGMLsQxY9zjHe39OJCS8JqszNz4rDj1WszN1ROy7fexXi+EbX0DVHU09dp1L7q4HDGeaYV41l0NgBoJM7zpt4h0CbFgPhK6eHhBySwW/KyW7f+oY/N0P9964d7Uxj5603Z5t2IWMlJJyj0S199EOJ02btwYFQcVRYmWIiejvr7eIoI59d+K5+zavn27RXgca8l4pKcf33fvZOWpmcg1axAeD+FQhKZembAmODgsSM/PZgXJz5HZKWfvy2hm165dcfsJmmlubo5Zz+/3x/RjXLt2LR6PJ5oEbrz39uAYTdOi/QAffPDBpPt3QtM0Xn31VcK2GxRDrIsnaB5tamtraW5uZvHixTGBNBDrFE0krra0tPCHP/yBkpKSmPWWL9ddUdu3byccDlvGLCkpic7DeO9bWlqigno8NE2ziOWtra2WYBxJkmKuYyPde0qXQtsTE9vbR5MVXfHRZQLxFMxGOuuThF7ZgDY8gBYaRKT78K0sZ92iWWgRhd3t+4gUlB7rqbq4vCsx3Iejqcuj6c8ixR5x8RyMA00DjutHy55lLSoyjmhnFvHSSQzVkOhnYcyYQhLMv3E+kLjsO+3eH4+UWGMaEw7kliB/sJxp569GZOegaRo9G8N0755NuEum+3k/qGJEPHTmDa5mET8nmx2j8xoZfx73xzkeEOhl2L2UW8qly7mePLbGHL+GQHIQZHOpI49XMIRPp4RpYdsGBEVsghGX5WTgWJVMJ8UQCeOJjzfeqN9XOfVavOkmuOaa2NdLS+G116zjyLIuOrruRReXCUPyeMk477OEtz2H0v4mKBE0j4Y0Ywbl159B2cAAB+r2pzyeKzy6TDh2F1+yMImJCooZK3Z3Xqp9B1MRC+OlPNvdZ8lKxi0iruql4Je/ZdH5sxClpQhJom8gxL8Gp3GodzC6zcwUyy3MwuQjjzwSV3iM93oq6/n9fvx+f/Qc9ff38+c//zmahm2Emxh9NR988EHLOIYQmeoc7AwMDDgKi6qqsmHDBgoLCx0TnY8En08PikgkEpoxStWrq6spLi62iK5erzflcUA/r0220q5AIEBNTQ319fWWsQKBAIsXL0bTNPY/+CCnPvYYeS0tdM2aRd155zGY4LNaXFwcI7I7lWHbr+uysrKpXxJtT0yMl6zo4jIBSOl+0k+7FNDF/uFnHgCtH5GbhwDmZM7hrWM7RReXdy2G+7BXKbeEkwQLFpP9jx+n5LJydDDK+utOjCZOj4qDfVv7iHRGLOvt5XLyqNVF0BExVEOwlyss63kKPJT/o5ycU3ISln0DpL/UaBHyVAQtsyvJ/tgyvKefhEhPRwur7Pr+TLr/nR0z93ji4QDzmMfvyWanY59HP2+ynW+PiLvWfo5eeqnkWkupdDZNpNEBqKZejLpkOsRMstjrsJ/IyE+iP5NJiQINL72TSnQ0fo5HfBzr9imtGwzGX7Zs2ehnJV6vxfJy6+sXXghf+pLzeOMNhXGrWlxcYhBC4Cs/E8rPBCDy9g5Crz2NyMxEZGaSMy/1v1dd4dFlwrGLOMnKSCcqKGas2PsM5uXlpbRdKv0lDaG1qanJIvpMn27tgWDuBZmXl0dFhbW8pu4Xf2DokaeYpqkU+g6Rf2kNYuYsALqGBR0zVzEPwSGTuFZcXJzScSRDCIHH44lxCzqtF08oa29vj3HQ9fX1WcTAlpYWNE1D07SYa6W3t5dDhw6N4yic52oWywzBcLzk5eUlvHa9Xq/juTTcl/Gcn6liF7UXL17s6D7Mzs6mpqaG53/8Yy649VYAJFUlo7eXWTt2sPOXv2R3cXH0miwqKuLAgQNx06/NGCE7RqL27t27AaI9Mad0Mm9TU2y5j6Kk1MvLxWU8CCHIeO/HUDreRO3UnywHFlbCa68f24m5uLxLMbsPe5VymuRbEEJQ+Y9KOMU5HCbRGIaDUYhRB6ITo4nTOo1rGy2p0wC9cjm7V/6Gwjd+TVpnM/0sZC9X0EuZZawFNy0gZ2Suicq+AWazEE0e4kBBKZrPi5afSf6lS5GrViA8HtDg9e+U0vuy7DhvJ2eoBmSxjyz2jbxmD4jRXZq96OJuGTfipcckEOqdF8u4kW3cRBZvspg7RpYZY+j/f4AzKORpx7k5iWfJQld0V6Se9HO0xMdURUBj7+N1O77jjklZhl//Wv/vu+6Cb38burogL08PyzEESXsPxhGjQgwrV46vrNpe1dLWpvfOzM/Xx3ZFSBcXADxzT0CaPhtlTyOoKjllZ6e+7VGcl8u7FLsw5/cn7h8znqCYIynTNli7di0bN26MCixr4/1jZiOV/pL2oA4DQxQ0XjeXuba1tdHY2EhNTQ2aptH2g1+x4K3HSXv/LBAgzT0BMU0XR+WZJzBz6anMEgJVVaMl04ZoVVtbO6ZzYXfcgS4WJRIdjXJgTdMSuvMGBwfjLjNobm52FKidXquqqkIIwbZt2xz3m6gfotNcx+IsTER3d7fj616vl/LyclpbW+O6Y83u0w0bNliWy7KMJElJBeD5LS2s2rwZX3MzocWLCZxwQnR8p8/X8r/9DdBFR+OnJknM/O1v+ddVVwH6NTlz5sxoD8n6+nra2tqizke7SGqE7BhOZ+PaNnqATmnXY3m5cw+iFHp5ubhMBHLhQuRCvVxyrL1pXVxcJg6z+7B/a3800mTPTXsSJlPHGyNa3nzj/KgYmArxxMsZt30QTfsgL57ZgBZxEMYk6PxHJ7M+rz/ITlb2vSdtHYWn55L7nrmIdB8iO4CYN18vK/dkkL76YuS8ZpC6ccieiYqHhjO0n4V46BtxOo4mZI+6FK0uzV7K0fA6uBXBSw9VfNnymvm/NYiKjhMlrOnjRJKsNRH7mLj1EpFQdCwogM7OCdgLetn1jBlWR+Ndd8HVV4+u09k5+vsXvhA7htNDYID9qZd7OmKvajFKwzs79fRst7WOi0sUKSOAdMKp0d9TvSd1hUeXCccszKXS43E8QTHjKdP2eDxccMHYo+DH0l/Snips/B4vfKO9vR11KMi+L32X3FnteD58FsLkyNNUlZaMeWxt2A8Nf6S0tJTq6mpqamqora2NjmmkaKcyTyMsJ55gF+/1rKyslNKYFUXB7/cjhIhbMj1W8U8IEXeb/Px8Zs6cGeM2HSt+v59AIBAVizs6OmJSns3ES+oOh8MIIZBlqxPA6HtYUVHB1q1bo8nhWVnWMitFUZJ+oRfu3s37TO7F9Jdegve+F559lqrVq4H/3959x8dRn/kD/3xntqjsSlaztLKxjS2JYsuq2GADpiQhiinBCZBCySX5ESBHjpLLkcRwSXAuvRwkgbtLLjkgxSEJRzHGtECILhhLlowNBNmADVZzkS1pZVtlZ35/jGY1MzuzRVpptdLn/Xrxsr3anflukRl/9Dzfx/z9pSgKMvfsCYeOOqEo8LS1mW7Tw1LrZ9a6R6d1n1Dr1gV6MB7rBwUT+WHCpFq/3n4Poom29hARUdrJXZ2LResXmVqUjzxzJOpkartj2A2S0UXbd1F/fLTwsvqFarRe2Ap10BI+Kua9JKO1fau921ByTjNy1q2ByC8wHUbKKYan7mIISUbhpYU48tTYD2DDA1/E2wiqi7EPV5umap+FK2yHxqiQ0IP6iCpN20E+GAsX9d9bxapetBPP/aflforj5Phc3G5gnFsd2crNjQwI77rL/r533WUfPObmAtauG/2HwBNplXYKNAFurUOUJAweKemMwVwoFEJra2vc909Uqtq04+VUbea0zmJ3FvZ85B9Q+v4CSEtXQMgyQiEFx4ZVyN5MdPoX4f9eHQuGjJVk430tWlpaTFWZVl6vNyLA83g82k+64xQMBlFcXByuotRbeLu7u6GqakRAG82ePXuQkxO5h5BO/zx1dXU5tgTHu2a9TVzfi1IPxZ944omI17ekpASHDx+2DTvbLGEeMLbvYXNzs6n1vL+/P2rVpp3aJ58EMFa9KBStbQkbNkDavDni+6u5uRlz587FvMOHzeGjLGOoosJ0376+vvAUayN9GJN+bGPwDUQGsSUlJXH9oCBVe77GtHq18x5EREQ06yQ6mToR0fZdtIaPTufKXZ2LOefPiWjHtu4laV85CeQseg657q3IeN8aiGyte+nEuwLKCJCR7UPG9++H2Pl5oLISx45cBUiLAEULHatxq7a7oqrAgx7kodm0H6Ptvo+SjP68ldh55JsRlZNj7dqRQVm0q9FYIaLd16dLqOi09rHKUE1c6xUi8cnXMTptktKe7bS/vt3t990XOVQG0J7XZZdNbACgXVeLEbfWIZowBo+U1ibSpj0VnKo5rev2+/0ol7JR+OMfo+gjp0NadDIA4HD/EJ455MGwAtTVVdqGifq+eoqlek0PjPRzbt++PVxVp1dK2u0B6PF4EAqFIMsyli5dCiFExICWoaGhcDAmyzLmzp0LVVWjhp3d3d3h3+vtuoFAwLbyU+d2uzEyMmKaxjw4OIiDBw86Pkb/DNhNi06UsbrROMG5tLQUAwMDpgq/PXv2IC8vz/Q8dcb7+f1+lJeXQ1VVbNq0CX19fRNaIwDkt7fbVi86XSR1dXVh/4c+hHlvvAFFkrTHjlbw+b/7XdRlZoa3AdCH4Fj3DrV+r1k/61VVVdixY4fps7/Z8pNiu8/LtP5hgnWvISIimrUSnUydiGSFmrbTsAGMHBnB/83/v3AlpbFyMmupG/7s36CguA+uledAeDxQToSw+/tLIDKKseSyLmRfd7Ep5CkLPYP+0WBxIR4aHemit1Fr47cX4qFw1aPtvo8KcPR9NwMbx9YfrpzE2+hHhWn6dSyxgjtgfBWRU8W6JmvQ6DSF25bLpbUPJ3GbjoReM0nS9kq0ys+3b+W223ffqTrS7wcefXRiAwCtXS1W3FqHaMIYPFJam0ib9mSwaxO1q9bS13lo604UCC9OOpYJdcsvkHPtGRBFcwEAb/UM429HPOELDf2Y1jBND4cAba/GYDBoCoz00M4YHhorJa0B3bJly1BvuDjQA02nPRVDoRA6OztRUlICv9+PYDBoCgqd7N69O2rlIgDbfQ2jVQJ6PB50dHSgo6PDMdBLtJrQyBhCGvcwBMzvg36egoKCiCrIwdEJf3bTtsezRo/Hg4HFi5HZ2moKH1VJghi9SLJ+LkOhELrLyvD47bej9sknUdjZicwVK4A774S0ahXqoH3ejM/HWFlr971mV7ls/XM8PyiY7j9MICIiAhKfTJ2IZIWa1nZs73wv+pv60d/Ub6qkXPa/i7DwtkGoIQm9992DwjV5kE4/A0KSAOFC5gUfR/Xa0WGBDXdEhjyGYNGHt21aohXMQQtysBN9qLTd93EfrkHf70sACchRdmIJ7gsHjQKAB1oVXOQgmsg/A86ho/UxduGjXVXhdAgo7aoz46pj9HiAwcHUPAd9a5rLLtOGwzQ1jX1t7lz74HHDhsjbnKoj+/snPgDQ2NXS1KStSZK0sJZb6xAlBYNHSmsTadOeDPG0iSqKgu1NzQj96EFUh96GK0uCnJ8BzyfPhfD5oSoKmg+qeCPoNj1OD3tUVcXu3bsxODgYsf+f3V54epWjVbyVZJIkob6+Ht3d3VErCMdTmRZvVaIsy8jKysLg4GDUQG5oaCjmROhYgZ7T9GkrIUTUgHBoaAilpaUIBoOm+wwNDUW8Jx6PJ9y+XlZWhq6urrj2z9TXUfjjH0Ocf364elGVJO2CafQiyfq5DLeQl5Vh8xe+AI/Hg2XLtL2UujdtQklJScR7EwgEJvy9Fs8PCqbbDxOIiIjsjGcydbySGWoa27F3NOzQbjRUUsrZbRj49+8hu1SCkFUUfXg5pAULAQAiIxfelZdDuMb2G7cLeQQU+PA2IAMnQkXw4FBEwCVhGNW4Ndxy3YdK076PAAAVyFH1Vu2QZViMEhEcOrVKO1UCRnuMYQkR50h16Bjt/HGvq64O2Lo1OQuKh9erDaeprNRCx5tv1oI8Y4fO4cPa9arfrwWI+fla+Pe5z0UeL1p1ZDIGABq7Wqz7RXJrHaIJY/BIFEMiwy6c2kSNx1CDxxH4+R9w+vm5kKs+oG3eLIT2U2VFQctgPt4IHg0fw+/3o6KiInze+vp6CCFsW5Tnzp0bd+uuXklmbQ3u7u7WwlFLa7Y1iJpI5aB+TCt9UrJVKBRyHEyTbF6vF5WVleHXwSnIjDXNG9De/7Kysog9NAcGzBULQ0ND4UrT5uZm0zn1ysm+vr6IxwHaXootWVkY/Na3sPSRR5C5Zw+OnnQSej7/eVSceSYkxA6Fh4aGTBWY7e3t4aFFEw0AEx0WM91+mEBERGRnPJOpYw2M0SU71NTPe+Rp4+RpFZl5/4fF65qR/cGzgZzcsetRAFLRyfBUXgghLP/Pdgh5pPoq5OXlQTwnAJuf34rRcxpbru2MtWo7HcP5z9bbx7uHo3U6diolJfQcGAC2bZvays3zzx8L8hoaIkNHQKucFQI46yxz6NfQEDkk5hvfME/A1m3YACxbFtkqHQoBR45ox0t0GjW31iFKOgaPNCMlczJuIsMunNpE9WN4Dwdx5nN/wfx1SyDKy8MXdwAwHAKahkvQ3X/cdMycnJyI8zkFSZ2dnSgvLzeFSHrAZ7ytpKQkvMegNejTh4BYW7Nra2tRW1sbDiPLysoghHCshHQKEfXqutra2og9/7KyslBRUYHdu3fHDBplWY457Xk8gsEghBBYu3YtNm3a5Hg/a2BrVyl54MAB2/0o7V6X3bt3o76+PuK91as49c9wR0cHDh8+DECb4F1cXKx9PnNzsetTnxp74MgIWjZuREVFRURoXF5eDiEEdu3aFW79tnt+a9eudXz+8Yr1/TNtp1gTERHFEGsytVG8A2P04yYaasZ13vDlRwg58x/Dkk8chvvc8yAyMsYeoAKuJSvgPrna/oCj++GpkgyhhKBCAhRg8FNfQtUNVVCKjkDYFKYBhsrIKOxatcdrPEFbqoNGO0kJC/UBhMk6XizG1uSdOyNDR+O6nn4aOPNMrerROEDGOCRGn3J9111a23V+PvCpTwH/+7/A3XdrFZ3Wxzc1aUNn4h0yQ0SThsEjzUjjmYzrFIAkMuzCqU20q6sL/rcPYvVrL6PwulqI0nkAgM7eIQzMr4EqBF5u2QUgcrpzcXFxxDrtgisAOHLkCC6++GIIISLWYLxNVVVTsKjvDVleXm47BAQYq4TUA8GWlhbU1dVh7dq1+O///m+MjIxErNNOUVFReA9Ja1Crh37xmKzgERh7j+321NRZn5/H44kIHuNp2dbp+2I6tZ/v2bMHH//4x1FdXY3W1lZUV1dDlmX89re/dTymvs+nz+dDIBCAJEkR4Z7TcJ9k7a0Y6/tn2k6xJiIiSqJEB8YkEmomdF5xAoWn/RoLr82GXL0KwuXCyNEQdn9rAQY7vTh9YzUyTy50PuDq1Qje8wQGb7prbH9GcQ36b/aiTG1HxqGTkI9u2/BQhYQgFkddr93E64lIdtA21W3Xk3GuSQ8fV640tyZXVgLRtlZSFPs2cOuQmBtvHAsgGxsjJ1krytjejPrjAeD224GXX7Y/t7WtWq+wJKKkYvBIM1Kik3EVRcGmTZtMw0MALQBJZNiFU5tooPkdnNHRBN+nVkPM0Sa1vXvCi+CCWlRVV+Phhx+O74lBC2qc2n/z8/Md12C8zVrJJ4RARUUFqqurw+GUNfyyazvWp2l7vd6I4NFJSUlJOOTt6OiICBDb2tocq/CMJtLmDUQPLhVFCU/T9vv9OHbsWMyQ064NOhF+vx+KoqCjoyPq/UZGRvDmm29i586dKCgocAx4jYLBIILBIOrq6kyfg5qaGnR0dJjeV721v6qqCk1NTbaT0BMR6/tnWk+xJiIiSpLJnIJtZWzpHj40HD6vcB3G/BW/Rsk1SyBGO1eOv6Pi9S+WY6TXBcjA3m+2o2pzlOARwFuPleCI/B3khLSp00uVryOoLMb+L1+HkHQ18pRmAAICqmGvRAkqBPbhGttj6hOs/eJNQFWSFozZDZSZDseyO7bTMSd6vlgDeZLurbe0CkYA2L8fmD9//MdyGhKzYYPNkCNot1lt3Wrfcm0XXuoVlgwfiZKKwSPFJd3aIROdjGsX5ukByHiGXSjHB7H/i9/ByM5XIKBicX0OPFeugcjMgqoocJ+2BqfMPw2AVnEWra149+7dpsDHGszoQ0ny8/PR0NCgnT/G+2X3+qiqipaWFnR3d6O4uBg1NTXYs2cPAC10sguE9L0g4w3d3G43KisrTVVuVlO1l2O0ILGzsxObN2+OOagmUYFAACUlJdi9ezcGBgZM078lSQq/Z3ZOnDiB3/72t1BVNTx4prOzEx6Px3Q/n8/nOJjGemxJktDQ0IDNmzejp6cn/BlyuVxobm52nISeiFjfP5xiTUREs8FkTsE2srZ0e/yvouC05+DyjCBrHpC77gyIQCkA4Mhf3dj9zYVQh0evEe2CUJuKsIGdAjkhfQiMCgEFHvQgr7cZrfgRduNmnIxfwo0+qJAREhno9yzFO4NXow/LItacA8OxVAWqEBCqGjFV2vj7aFOrx/Z4lAAI7D/9DpT4X4Z7+1+ABLpRrMe1riWZAV605zXRc4xnn8txkyRtCIxxEExXl7kSMRGyrAWX1n0f7SZZR6NXTVpvs4aXxgpLIkoaBo8Ul3Rrh0w0LLQLe/QAJNqwC7uAb+TgUbRffxuKVmdCOmclAAHMyYNwuwFFhXfFOsi5c6Oe26i/vz/c1qyvyxjUFBQUYO3ataZgMdb7ZX19li9fjqeeespU8VlXV4ePf/zj4edpt99hZ2enbcjl9/vh8/lw6NAhU7vx8PAwtmzZMu1Caz28M1ZR9vT0TPi4WVlZkGUZwNiemLt377Z9zUpKSmw/C0IIqKqK4eFh29Zt45oDgUDU4NYY6umf3ba2tvBjOjs7sWPHjvBQGau2traEf/gQa1gMp1gTEdFsMJlTsI3GWqtVZM99GkuuehsZK6oBlwvIzILw+aGqKg49X4RD32nHMuXLYy3T0tWQK88dCxubmrQAaTQ0Uju7gC3PINP1YywID4HR9w5UAEhYgvvgR9vo11QACmQcx6HqG9DXtCiy6tMNLMJDEMOGY43+YNY4VXoACxFCFnLw99Hjmum3HMNCeE8vhKu3C2J0IvFJettvYyNw9tm2r1sik6OF4ddkh49pzy5c1AO9lSuBvDxtT8dEQsimprHj6FWJdXWRQ46ihZt2VZN24aVThSURTQiDR4pLurVDJjoZ1xrmBQKB8PCVaCGLNeBT97Sj+MFfYu7lp0FatMh036ERwHfuJyBn+qOe247x9ba2x3Z2doaDST1M2rVrl+PjgcjXJxQKRYRhxsdEa++28ng8KC8vR/VoC7k1LOvq6orYtzJe+j6Kqk0bhdMwG8B+8ItRQUFBxPOLt3U8mlNPPTW8n2Vzc7Ntlacsy8jKykJ7e7tt5ajP54u7ClSSpIgWdCEEfD4fysrKTJ9p6z6fura2NtTU1Nh+Lvv7+9Hf35/UHz5wijUREc0GyRwYE83AzgFAGUb+4t9j0bUKXCvOgTB0R6gjCkYyzkL+SV2Yr1gqFpVmnFj2XeC8fzFXgumDSUaHySwYftB2CIyAghy8Mfr7sdtUIWMRHkKHuDMieK1+oRq5l70NHLK/htPbtAdRjH3iatSoX7BtHdbvm4X3gNf3A399UWuXtU5JPv108wASw2OdJBJKkoNQSGu7fvll7f2IJ3xcuVL7takpsioR0CZiGydZKwqQna1N8TaSZe29t3KY0G57XyKaEAaPFJdUt0NOdqu3terKGMpEC1m6urrg23sYnqPH4B04gXnHn0DuNSsgCrWKxiAysefwAAZDAm8FBapfb4s4jvHcdvsoAubXW5KkiOeuh4ROLczxvF/WMM8Y4kULmvWp2bt27cLQ0BCGhoawfft2dHZ22gZmqqpGHM/n8wGAY4uwbmhoyHb4jD4p2y5IA5yHvMiyjKqqqogJ1UD0Vux47dq1C8uXL8fOnTsjwmDjefRAT+fxeOD1em0nkkfT29sbETyqqor+/n689tpr4a+1t7fD7/fbHSJcYVtTUwNVVcN7POpf0033Hz4QERFNN8kaGGNnsP0g+htfRea8d1FQvBnzri2BdPrpEJKE4cMK+t6ch+JPlkIuWYL+FgHlrpsiKxYlGVm/+pY5dLTQJ1PbDYFxbBVWQnDv/3tE8Lrksi74brvI3JbrdE7pbZTl/w44LMIVkfo5AUvQCQnDt/8r3D/4euQefnEyPpdEKxuta3K6Ld2FXxP92txuf0WjwUEtCF6/Htiyxf4+bjeQOxrG5+WZQ0edHmK+8II2OMY4mOb4ce1XvfpRlrX1Gads60YntIfDy2j3jYVDaoiiYvBIcUl1O+Rkt3pbq66sbcV2IYs6EsJJD7+IFSNvwJXrhlycAdfqNeEWFvfiM/DKG51oP3o86nGM51YUBQ888IApPPJ4POHXWw9g+/r6TMfQg0Xr8b1eL5YtWzau98sY8FknLesTkvXKxd27d0cEXgcORE7odpKbm4uGhoaI525HkqSIUNDr9aK2tjY8udspwLVTX1+P5ubmmFWnwNjrfPjw4fDrU1BQgJKSEnR3d6Ovr88Ung4NDeEPf/hDzEDVqrCwEIFAIFwdWl1djddff932tdHfi1jP2frYaAN8urq6IEkS6uvrHSs2uRcjERHR1DMOjsmuzMai9Yug9L+GYz/5FrIWuHDyGQLuutMgLVgIAOjfKeHNu8qx/KlauBfnhveAPHOkLbJiUQkBPT1RK9FUAC70woX+0T9Lo2FflFBttIrMFLw2NgLnXQzYdJhEHEuW4X1/Pbw7d0aEW/Z7IipQW3c67+HnctmeN9pxEwkdJ2OfxulGBRDy+SBnZEAsWQL099tWkpr09GhB8AsvAAUF9oHz8PDY7c88o30WhTC/75KkhXurV2vhpLXqUZKA/HzA69Xud+ed5inbutWrtbUYA0On+0bDITVEMTF4pLikuh1yslq9nSopY1V4jvQG8d7nvoSTl4cg11xkamFRRkJ4z1+OYI8SERDqeyU6VW1KkhRRubds2bLw/awVjfoEYj1YtK572bJlEe+b3XPWj2UMyAKBgOPrFggEwoGd05CYRCoGS0pKbJ97vMctLy+PCHD19vBDhw45hpn6/otVVVXo6OhAT08P3G63Y1AoyzLWrl1rOkdXVxe6urrCk8F37NhhWqO1fVrfszGavr6+8HTr9vZ2eDwex+cgSRLWrl1ruwdnNENDQ46hpV2oaP3hQ2VlJR5//PGIoTREREQ0OayDY4a6BnGiaROWXNaEvE+fDZGbZ7r/oeey0dO6FMufOjnc0r3n9j1QR1TbikXIshbkHDliqjIbm0w9ejcMIwdvQgUQdJ0K/8jfI0JM0zHtqsj0UNCGNXQMP/7uu4E4flCsQsIATobHYQ+/yaw+nG4B46RNtM7NxZ4f/ADl5eWQL7wwdrUjMBYi3n57fOcIhez3bVQU4LLLtN/bvceKooWO+/fHPsfq1RMfJMMhNUQx8V+JlBYmq9XbqZIyWoXn8bc7cOALt2Luh+ZDVFSYKgMHjg/jmQMu9I+8bTqPPrzEOLylo6MjYigMAFPlnvXc1sA1JyfHFCwaA7T8/HxUVUW281ifc0dHR/g51NTU4MCBAygpKUFVVRWam5vR1dUVEaC+9tprAGBqw01EIBBAIBBAd3e36TnW1taGW7bt2IV2Pp8PtbW1ptv0ELKpqSkc4NlZunQpAKC1tTX83gwODjoOejl48CCamppQXV1tO/W6o6MjYqp0dna26c9ut9v2+fl8PuTk5EBV1YjjRqsCVRQFQ0ND6O3tNd0ebc9LXU9PD5YtW4aqqirs2LEjakWz9YcPjz/+uGmf0c2bN+OSSy6Jej4iIiJyZlfNmLt6bA/IscExABBCTuAxLPnEYbjPPQ8iI2PsQCrgKluJky6swkmW4/dv1SoV9+Fq5KEZCFcsStr14N13AzffDFWSR/d01CJHa2ClD5PxVMxFz+s+5KMpsu3a6wXOP3+siszYjnrokGM7d/hchYXAkiXajVdeqU03jkG/SjxUfSPycJ9jUBlP+JbMwTHJPFbcMjIghoagKkrSB+Ggvx+nXH894PPFrB41CYW01uh4t8xyupa94w6tQnE67NPIITVEMTF4pLQwWa3eTpWUThWevS+1IPiDr6HoqmqI0nkAAOErgre2AU89/Qze67BvdbULjoxDYYyiVZfGCmCNAVpnZycefvjhcEWkHnBan7Mx5CouLoaiKNi1axfefPNNx8q/wcHBuPcd1Hk8Hng8Hvj9fkiSdnHb0NAQXpdeQZjoUBf9eMZj6J+TWMGoHsy2tbWZbg8GgwgEArYBoL5/pVNb8+DgIDweD0KhEIqKivDBD34QW7ZsCd/f+FnQB8v4fD4IIWzPGUtnZ2dEO7ddhaQsy5g7d67p+IODg+EQWv/MjYyMYNOmTTErGa2t9Im01hMREZFZZDXjEI4+e1QbvjIaPg7sHNBCR3EChaf9GguvzYZcvQrC5QJUAc8Zl0Hy5QFChrAJdvZu2Bv+fR8q0YofYSEegg9vY7CwAjmPfg9YtQpB9WQM/dNdyFbehsAw3OiznSQtoCCjdzdGfvYL4PNroaqjIaYkQ0gCeP75sbZVaztqFALQgqklS4DmZnMLa7TJxeHndgoCnyoB/rHJ+fhxsAvrolVLOlUXOgV+kx5GnjgBCGHaqzJZhKK118NSnBC3RKZa2+ntBdasAe69N3n7NI7XdAg/iaY5Bo+UFiar1TueSkpleARQVRx+aBPUF/8HedesgpijtbLIpafDfepqCCEwt6QU77UnFhq1tbXFPTBHURSoqhoeClJeXh4RwFqDtv7+/ohgKdoU7dbW1vDvrXsA+v1+DA0NRd0b0EiWZWRmZuL48eMIhULhwTN6QNbe3o62trZwMOo0GMfIrkU5GAzaTmrWW5Sj2bJlC0pLSyPaoY8fP46cnBxkZ2fbTpqO1upvHGQzb948uFwuxwDXOlimo6Mjaou7zlrNaF2j3TCdUChk2gvU+Foan4+xkjNaJaMsy6aWcr1tnYiIKJ3FqjqcLOZqRgAhQJVV7N2wF1Wbq6CGQsha6sXwwQ7Mr/8NSq5ZAlFWBiEEhrol5Hz0kxCezKjnGNhpvl7oQyV24jsAgJpHa4BVo3tAfiED6oh2+1m4wjZ0BKCFgIOD8H3zM8AKbU9o7N8PYbdXnrUdNRZFAVpb7VtYc3O14MmGAODLPQL50R/H1/4bQyL7NVpDRmN7ul3I6HScpAaSSXgNnExJBad1f0ejUAi46y5gzpyx2+rrx7dP40Qkc0gN0QzF4JFmtWiVlMrxQbx3ywaobU2QJBU51XnwXLEGIjMLqqLAc/p5cM071fZYxqErdpOddXroZGzzdtp3sqWlxVRlKIQwBZWKojiGgsZgKZ4p2nYqKioAIGY4qAuFQhH7RloZg9Hx7ttpfA1jBY1WBw4csH3+oVAoaot2rD0adV1dXWhpaYn6GbCye738fn+4KtKuFds6cMfa3q3bs2eP7VqMgXtPT4/pa9Y/65YuXYqWlhbTn4HJn0BPREQ0WeKpOkwKmwm4AzvFWOioC2lh4eFfP4ne/7of+dIwApfJ8F9WD1FSCgA40uhB9oWXxgwdASC7MhtDXUMR5/Gv9If3gAwHoKNs94LUKcrYMJr2di1s+elPgeXLtZZt44Rfu3ZURAnZ9B9o2rWwAo6BlAoJR3sXIO9v2yBNtKrORqywzS5cTHQidtLbotPVypXApz4F3Hij8330QTR62Ld+/dSGjkDyhtQQzWAMHmlWc6qkHOrqQfvnbkPROdmQ3neu9j8ynx/C7QYUwLtiHYS/MLwHoh6wWI/V3d1tG/To1WHGsEgP3pz2nbQGc7t27QIAUzDptBegMViyDmHZuHFj1GDMOsBGX2txcXFEsGqtgou3/VZ/DeOZLB2N9fnHCggTGYDjJNpeinrb+kQNDQ2htLQUVVVVePjhhyO+bn0eZWVlkCQp6n6ZgP3U8/z8fFOwmZ+fb/vYuro6SJIUEdpP9gR6IiKiyRKr6jApHCbgFtX9F9q7FplDQVmFL/A0xNY3UPK5esDtAbxeiKxsqKqKnv8rhv/C85C7ek5cp160fhGOPnsUqjz6HGXtB9llPywL3yfczj0qci/I0UAsN1ebZGy8BlJV4KabzKGhPuG3ri6iHVUdDQ+tYZs6uiUPqquBpqbI8LG3V6u2HH0swo+XoEJgn3QNco7dienyY89EAkRrteSsDR9XrgRefln7/a9+pe0LGU2yBrrY/FAgrsnUyRhSQzSDMXgkshh4dQ96vvLPmHv5aZAWLTJ/UfIg4+wrILzZponOesCitwzrYUxxcbFtmGYXeBUXF6O5uTkiqNIDR2swZ92fzxpMCiHg8/lsW7KNVWk+ny9q8GgdYGP8vRDCVAFp3UPQKdiz7kGoB1etra0R7btVVVUJ7yfp9/uhqmrUastkyc7Ojnj9hBDIzs6Ou5q0pKQk3C5t937o73VHR0dc1ZNvvfUWAHMQqw/0sU5Mt4aCDQ0N2Lx5c3iPx4suuigiYJckKSK0VxQl6ueXiIhourOGbgDCVYdJ4zABdxEeQoe4cywUdA2jcOGvsODiDLhWngPhNnR1KCo8yy7A/PeVJ3Tq3NW5qH6h2txKfueicLUjEFkVqe8Fucj9EObkvgepvkqr5rrySsd2Z1NQqAdCgPaDfL0d1bBXo7EleRjZOJ5XhZzHvqe9TmvW2J/D8tgQ3DiKGuzDNehTlhmOmDxTHQTO2tARME+k/sEPtM9BrIKBiQ50cfihAF54Ib7wcTqwBqdf/jKQnZ3qVRExeCQy6vnfFzD02x+h4JozIArnAgCk3ADkQBkguyEXLYKQtW8bu8E01mqv2tpa1NXVoa2tzTEw0qvOVFW1bWPWqxX18HDXrl2mlmqnYFJVVfT390e0ZAOI2E+xpKQEBw8etA0Ko00Qt7aqV1VV2U57BrSwsaioCCUlJaisrMSWLVtM07clSYoILufO1d4Dn88X3isyHoODg7aVftaKTCeSJEFV1bhaqu3CzURDz56envB6+/v7EQgEcOjQoYi9GuOtILX7rEmSFJ7+vXv3bgwODuLNN9+Eqqqora0Nf0ZcLpdpT0e7gN2ugtFpj85kTaAnIiKabLatyLJ2e9I4TMB17/+7IRTswtyT/hMlH5sP6fTTtEExB3vg/sNzwM1fgLRiDaTMnHGdPnd1rrl6s7ERaBgLKpZceguan80wVUX2i+WQX3gakiGgxPz5jhOjI4RCWpBkbEcdHAQOHQ7vH6lXLPZhKd70fg+r9DbV+vqY1W4CgAJPeL9KyMDxvKVw97w88SEmo2Z19WG89Fb7f/onwGa/8YQYB7OsXg28+CJw++3avp8AkJERWXE70YEuDj8UmHAV5VSxCU6lZ59F9v33a9XDRCnE4JEIWlDU9b3/huedLcj5xLkQPq1izr3kDLhPrrV9jN1gGmsY2d3djbVr15oqIa37KupVZ5s2bTI91toGa6wws4aGQOxg0sh6m1Po6PF4ok4Q19c0MjKCzZs3Y9euXY5TqT0eT3iKdVNTk2mAyYMPPoiMjAwsWbIEAMKBZElJScLVjoD9FPFEOLVO64wVm/Hu9xiNdb1CCNs1xApN9cFDTvs46tPE9a8bp3RLkmS7J6PT5HcjRVEiJoPbtXETERFNZ06tyIvuXJS8k0SZgJu7OhdLNnhx5Gv3IX/dUkgLFgIAxKtvwvvVn0IMjQADLmBz5NC3cbEJKnzPPou6e57AW4+VhKsiCy8rxN67x6okl1zaBV+T/cRoW3ogZGxHnT8/YmiNgAIf3oYyqGBn0f1YiAfh79kWM/BTAcgYvfaVAISAvcNXo1LdCkgyhDLxrXUSDh29Xi1cnaFsg1hVBf7nf+IfIBTNkSNauG1sd9Zbr4Gxz64QyRvo4vBDgQlVUU4lh+A08ItfaHtlEqUQg0dKe+MdZjFyNIiu7/03Rjo6oR45gPylIbgvOQfC6wUUBZ7qBriKFjo+3m4wTUtLi+2UbOu+itb16vc1PtauDdZ63uLiYqiqGp7qrH/NLpg0sp7LKdBatmxZXK+lU5WjUTAYREtLC+rq6iKmbw8PD2N4eBitra2ora1FaWkpurq6sGfPHsfj+Xy+iKrCaMEbAGRkZNhOqU4Gvb06kUpHr9cLj8cTsd7e3t6obeqhUMj26zk5OSgpKTG9/8Y9Ou0CQgDh986uotEagNoFonYDdJw+v0RERNNVPK3IE2aZgKvKMg5nL0Aw82SI6/4ZGUO7UXDNCoiCQgCA9PiL8Nz7WwhlNKSLIwSJezK3Q1Dhe+zHqAub2pMAAHmOSURBVBoNCO0G7gw+dReypRhhXKwJv5WVUDu7TKGgCglBLEZWTwuWqrdCQDXvK+lA+9oIauWbsCd0I/qkSvT0noYW6UdYqDyEfLENIsEfFE+4wlHM4PrI0f01badNt7YC+fljQ1/GS69y7ey0b3eejIEuUX4okBZsglMRCiEzyr+niKYKg0dKe+MZZnH8rXYc+KfbkL/SB1GVDZGZD3HyYghZBiDBs+pKyNlzoh7DbjBNtCnZ0R4X72Otj3faZzLWcWpqaqCqKnbs2GEbYNkNlInGafKxVVtbG7q6unDixAnH+zitycjj8eDKK69Ea2trOMQsLy9HbW2tY8svAFPo6PF4IISA2+1OeC9Iu4rK8ewpuWzZMgCRk8KjvT5DQ0O2oSugtaZ3dHRAlmXIsoylS5eGh8AoioJNmzbF3CPSbq/QaH+2e4zf72elIxERpaWIVuRkMwQmys5d2F9SCf9qPwpPdkGIQYiTz4XI9kFVFLh/8ju4H3tx7LFxhCAJTeaOo8LLbuCOD287VxHKMvCTnwCPPho9EFq/HuLZZ6FCglCU0dpHBYewCgvVhyCgmNqwYxEA/KE3UIMvYEBZiBCykKEcRBCLcaT4A8jv2hLHUczHs+V2Qx0ZAVQ1+rqiXMulPUUBXC7AocsJ3/iGNmQoWecC7Nud9QpafV/DK69MbCCM1aWXAlsMnxNJmngV5VSyCU5VWcbxsjL4UrgsIoDBI80A8bSCGvW+uB3BH30dRR+rhgjMM31NeLLhPfOjEG7vuNbiFCpO1mPtnns8x9Fbbq0BnzVwjLeS1DoJ2Ul/f3/M4CuePRgLCgrCexYKIdDV1YXOzs64gjWdHh4OTqANRggx7lZrYygcbQ9QJ4FAwPSa+3w+vPbaa+HnFQqFwp8HQHsvre+RLMsR+2paK2QDgQA6OjpMf9bp1bt9fX2mx1RUVMRVKUtERDQrrV6Nkd9sxP7r/xkF9QJy9XIIl+GfZYoKr2cR5CcbY1cOWiQ0mTuOCi+7gTtBLIYHPRCwdEEUFmqB46pVwA03RC7OOvjin/4J4gc/AKDv8ShQjnsRQkZEG3Y89CAwG/vCf/bgEJDEOXfq8HB4oE3a7/uYkTH+gHRkxP75V1cDN96o/T6Z4aNTpW+yBsI0NgJf+IL2PaZf2yuKtmfleKooxzsdeyIs1dT63xmdn/0sEhtDRZR8DB4p7dnttWg13NMHdWgERx9/Afjrg8i7ZhXEnDzti+5MCMkFqeAkuE9ZpW3gnSaiPfdYLejW0NLj8eCjH/0o3G43gOhDRYzHLi4uxty5c3HgwIGooWG0kE6WZWRlZeHYsWNxBY+dnZ3YuHEjfD5f3JOjJ8quynAi+zsKIbB58+Zx7+VorTy0q4A8cOAAFEWBJEm2r1N1dXXEJHZrpWK0ClprdWmilbJERESzSej4IEK9AxjqPozDX/0Kii5eBFFWNvr/dAnCmw3hyYRr2fmQs3LH1Uqa0GRuh6ACd94ZDk7qD21HPxZhH65GH7RAch+uRh6ax/ZP1B93993af3Zhy333AZ///Fio09mpVZeZpltrcZ6MwQmFesLy+2TOtxaGX5M/N3uKRQsdc3Odp5YbRLxP+l6CN94I3HXXxFuudfPnAw0NgHFv0fp6bS/IZAyE0bcdsA6refRR+xA9mlRNx7ZpP1e+8hUMZGVN3jmJ4sTgkdJetGAkdHwQ+2/+OqT9rZBkIPu0OfBcsQYiMwuqosBz+vlwzTslVUufsHhDIWMbtnHIjZFeRQjYDwsxBpV2x44lWkhXXV2Nuro6PP7446aAzDjExSqe6slERZt6LYRwbHEeD7sgMNYelV6vF/n5+ejv7w/fN5pQKISWlhbU1NSg13LxmJ2dHTUgtAbX+mAgI2t4nZOTw30diYiIbBz+9ZPo/8VP4c5U4c6RUPTxeoiSUgCAlFMCT91aCEk2P8g4jCVOCU3mdtonT1XDwYknFEI+DiEPzWjFj9CHSvShEq3iRyjL/x1yvPu0x112GXDzzfZhCxBZ/aZfh1quD7UqSiWplYSTVZWY1tWOsbjdUdup9eA14jUwBnXJbLluaooMBp9+2n5q+XgGwiRzsEwqp2Nb/84IhcYmgROlEINHSntOrcVDXT1o/9ytKFrjh7T2PEBIQGaW1sqiAN4V6yDnzp36BRuMdzCOLlpbtV0btrVCLRAIQJIkFBcXm+5rNyzEWE0Zq509XrIsh6vuAOCiiy7CH/7wBwwMDCA7Oxvr1q3D7373uwlPqY6XJEmOweOxY8eQmZk56WsoLy93nOTtdrvDgWUwGAy/f9ZJ6Ub67dahOpIkQZIkx8rWePZOjafamIiIaDZTFQUdX/8pso40Yu4NqwGPB3C5ITIzoaoqXCIf7vpLbPdQHo+EJ3Pb7ZM3OKgFOuFKRAWAhIV4CDvxHQBAn1qJXd46rNo/WoHZ0OActiRAD7PSvo053fX3A3V12q+vvx7xZcf3xxjU3Xijtt+nzePjJgRw2mnAm29Ghox2oSMwvoEw8+cD1mKK8Q6WSffp2ESTgMEjzUjBHbtx5KtfwtzLT4O0aJH5i5IXGWd/FMJr85PfURMNBGPRj2/c2y/ewTjxHNeuorGkpCQiMJQkCWvXrkUoFEKr4adhsYaF2LUHj0dVVZXp+e7cuTNcURgMBvHMM89MWugoyzKqqqqgqir27NkDVVVx/Phxx/uHQqGIakefz4fjx4+bwsqJ7PvY398PVVVRV1eHzs5O08Ca7OzsiPelp6cHy5YtQ1VVFR566CHHoTfRgmLr1/QBQAcPHoy4n/X7oqpK2ytKX2tXVxeam5uT/v1CRESUjkLHTuC9G9cjf/ERuD50NoTbM/bF4WF4vvVLuP5vB/BCadJaMMc1mdvaGmpDQIEPb4/dYK2inEjYok/4hrmVOczQjj1d6Fd6MzYcHRzUqgyFABYtAvbuNX3Z8XnrQZ0eZB84kNh5JUmbiu31jlXgXnml4+cyLMG9UE0aG80t3EbjGSyT7tOxiSYBg0eacXr+9wUM/faHKLhmJURhEQCgD9nIX3omJLcHUl5pZCuLxXgmZSfCafKyU0AUbxDqVNGoP6alpSWuCjVrJZs+LERfx+HDh+N+rk78fj9qa2tNt1mff7z7Nzq1SEdr1S4qKgpPwR5Py7bH40FOTg78fr9pnRMJHgFgz549+PjHPx7xntu9FoODg2hubkZ7ezuGh4dtj6dXtFpb4svKytDc3BwxGMaphV1RFGzcuNEUlKuqivr6+qj7gdqZ7GCfiIgo1YY6DqHjhltReGE+pNPP0PYQP9oP93/9CWLgOKQ33oE4fHRSWjCjTua2G3phbQ21oUJCEIu1P9hVUcYKWzo7I8NDIYCf/Uxrz336aQi7cFGStOMkM3h0uwH9GnT/fq3abevWhA8zY0NHnR7kxbmtEoCx/UFjBNm29NBQH1Ckq6y0//zoj6mvB/LyEtoL1cSpKre+fnyDZaLtnUo0SzF4pBlDVVV0fe+/4XlnC3I+sQbC54eqKGg+qOCN4ADq5hyNOzy0a1Nubm5OWlDiFDA6BYHxBqHW4x4+fBgFBQXh0EqvULPuCakoCjo6OtDZ2YlAIOB4P6fAdDzsJh9bA894WScz64yhY0lJCYQQ4ft1dXVh06ZN6OnpSfh8+rGN05510UJHWZYhyzI8Hg+EELYB3+DgIDZt2mRqn25vb4fH44m4ry5aRWNJSUnEmgKBAIQQEYNhAPv9JT0ej+3ru3v3btTX19tWTUb7HpnsYJ+IiCiV+pvewNGvfxlF65ZCWrAQACAy58B7/bcg3t5rvvNUtmA6Db2YMyd6QCRrP7Dvqb8Jnv0e+yrKaGGLqmpfU1Xzno63367tB3jDDUBDA9RnnoEwrkOStPs7/HB13ObOBV5+2XxbUVFCg1BmfOioC4XiDw/z87X3K44g29YppwD/9V9jYZ8ekv/tb/ahoxDafz/84fgCQp1dtS6ghdLj4bR36kTWSJTmGDxSWhs5GkTH136C0Lv7gMEgCmpkuC45B8LrhTISwvPdAp0ntI95IvsSWgMwRVGSGpRYjx9rGrBdEBrPcYeGhsKBUUdHR7hCzWrHjh2m+7W1taGioiJioIhdq3ZmZiaGh4cxPDxsCrj0kM0Y/mVnZ+PEiROQZRmKooRbtrdv347du3djcHAQbrcbGRkZtq3Fdvx+PxoaGtDa2orW1lbHNnBr6zAQvaJSrxY9ePBgQu3e+mug79VkfE1CoRBCoRAqR3/6bxfiDg0N2YaviaxBlmUUFxcjEAigpqYGmy1VFJIkobu723RbTk4OSkpKxhUsWz93/f39aGlpSWj/UVZBEhFRulJVFYd++Rj6n9wChELIzuxGwTUrIAoKAQBS0WJ4Ki+AqPglsO+9pLVg9jb2mluq1y9C7uooLdVOQy/0dVhDP0PLq7jzTpSvWoVyp2NHC1saG4GKCvNef5IE/PjHwIc/rD12NLhUJUmrfJxAe7Vxn0jAJiScP9/85/vuA8b5g2gy6OkB1qzRqg8TDR0B4I03xoLpeKomCwoiqyPHw25/R/328RrHYCiimYzBI6Wt42+148AXbkXBOXkQp+YA7jkQJy2AkGUAEt6eczo6941d4CQy+MI6LdoaUE10uIrdNOpoIUu8Qzz04+7atQuDg4MRX9cr1Kysz6e/vz8cQBnDI7tA1jq0RJeVlRUxKEW/rz5tuaurC8FgMKLKbnh4GIqiwOfzhR8jyzJGbCbrVVRUwOVyQQgRde9Jp6ExOo/Hg4KCgnCrtH688e4x6Xa7HR/b1dWFhoYG0x6fQPSp2lY+nw/Dw8Nwu922k7Y/+MEPwuXS/op3+vxY30tjpauiKOHXwimgLS/X/vlRU1MT8VxiVWFa18MqSCIiSkfK0DD23/4t+N2vo/jC+YAkIAKnQGT7oKoq3OVnwb1wuXbnJLZg9jb2ovW8Vu0HnCFgqGsIR589iuoXqp3DR6d9GAFtHdZ1OYQ6joGnXdiiB0jWazhF0c6ht5mvXg3luecQvOMO5LS1QUwgCDSGjrb6+7VhODt3Arm5Ext+Qmb658kaZMdDr5bcvDm+qkmvl1WERGmC5SSUlnpf3I6e229C0cdPh3xGHaTyckiLToaQZQiPDxnnXoOlZ6xCXV0d5s2bh7q6OsdqQjv6tOi1a9eirq4OgUDA9PWJTu+1Hj9WZVdNTU1cz0U/7rJlyxJaj9Pz6ezsRHNzMzZt2oTm5mZUVVWFW3JjKSsri6iqszu+0/6KAwMDCAaDUFUVqqpGhI5CCNNrMdEwuLKyEpdccgkCgQA6OzvDrefRyLIc8dnQRQssFUWBJEmoqKgw3W6dmu3z+TBv3ryIc3g8HgSDQQwODiIYDMLn85m+HgqFTFWO1s+PPlTH2L7d2dmJHTt2oKamBiUlJZAkKVz1aT13aWkp6urqwnt02j2XaN8jNTU1qK2thd/vh9/vtx2Ak6zJ6URERJNl5Egf3v3k55F3Uie8F50LqaICUlk5RLYPUFR4a9aOhY7AWFXg+98PzJun/frii+MKT/Zu2BsOHQEAIa3ycu+GvfYPaGzUBoZY6Xvkxbmu4H1bMHL2B3DqU+/DKe23IvT0X9B6Xit6G3vtz6sHSHasbearV2PPvfdq65lg14NW5SjZt0S//jrw1FNalRtDx+lFH/Li1P5sdOgQcOaZ2n/z52thcmNj4ud0aqkeT6t1Y6O2jomsh2gGYsUjpZ2DP/8T1L8+iLxrV0Hk5gEAREYO4PJCzgvAVbYCQtIuNJJVMWVXoTiV9EAxXvr6rFVoeoWaVVVVFTo7OyOqD1VVjahCq6ioiKsdVwhhO9QkWdxuN6qqqkxt2uPh8XhQWVmJmpoaKIqCtra2uB9bVVWF2tpa09AVIPaAGb0N2/q56ujoiKhebGhoAIBwhWhxcTF2795tCjZzc3Mjpmsb9660fn6am5tNlai6rq6uiMpDa+hZWVlp+1k0Ppfi4mKoqopNmzbZVvRKkmTa43L79u1JD/eJiIgm07Hd7+HgLbeh6NKTIZYs0f7fLlwQ2XkQngy4T10NKTMn8oFJasEc2DkwFjrqQqO3W+lVh9bOEEkaq7hctSr2uhobkf35tciGCgEFHvQgT2lGK36EvRvmaANtrMNrmpqcAySnNvPmZufHuFwIzS+DtPfvMfdZFLl+IBgcX9vvZPF6tfch2ftWTjHjBPIIS5Y4T4mORQ8Tc3NjD7UZHDQPBdL3LH3hBe3P1iFKTpPjkzWF2mkP1RdeSNrUeqJ0xeCR0oYaCmH/V34E/3ALPB9dA5GZBVVR4Dn9fLjmnTKp5040+Es1fb36JOtYgakkSSgtLcXy5cvx6quvhu9vV4WmB2HWUNOqu7sbxcXFyXtSFkNDQ9i8eXNCk6+FELbt2voxVFWNeE561V9vb68pFPT5fFi+fDlaWloijmcNHa3Ttfv6+sJVj9bPlfH5BIPB8F6J+v1CoVBEpaiiKBEDdvLz8x1fi2jT061f0ytL4/kM6WuMZ8r1eM9DRESUakef34ZjP7kbRZ+ogyjRfnAm5ZTAU7cWQpKnZA3ZldkY6hoyh4+ydnsEverQGjzm5ye2R97ocQS042i/SlioPIQ3d9bZBy+hkPN+jaEQcOSI9rjRYCa7tdV5yIskAXV16Oi/EPPxb7HX298f2UKe6hDy/PO1EMyu/TyN6O3sEeGjnITP/zgmjAMYe49vv10Lr+MNAJO1BYLTHqpJnlpPlI4YPNK0NtzTh95nt0EdDiH4+OMorByEXL8KwuUGFMC7Yh3k3LmpXiYATMvhGE6BqXWty5cvt71/c3NzxF58+n26urqiBo92wWUs8ujFSkZGBvx+P4LBII4fPw5FUWwrCBM5figUQm1tLTo7O00BnT6duqOjI6KN3O/3Y+3atWhpaYmo3AwGg9iyZYtj8On3+5GTk2NboWgMFI3s9krctWtX+Gv650mvDtTP3dnZGQ7qenp6kJ+fj4suugjNzc3o7OyEqqqQJCn8uXSaHq5PNTcKBAJxhe7Gz1RfX5/pa3bvk3UN8Z6HiIhoqqmKgt7nmjB84CiG9u6DZ89mzLn6bIjcOVBVFa6TlsNdcWa4o2FSjVYUVjbtwJHQSdgnXY0+pRKQtR/iLbpzUeRjnNpWE90jb+fOcOioE1AwBy2oP3Q58GFFCxj1kFEPHVXVOfRratJCuBdeAM48E4Ff/MI5qFQUqNuaME9pwgAWIhv7TMFXRBAmhNa2nZc3VoGXwOTqpDNWl77wAnDhhfbt72ki4tOemws8+SRw5ZWpC3hDIaC1NbEAMFlTqJ32UN25M7ISOFoFJtEMxOCRpq3gjt3o+fKX4F8kIGQJc89ZAFGxFEKSAMmDjLOvhPBmpXqZYZM1HGMyAk3rWvVhKlbRWsydwivjhG5rYOf3+8Pt3nrV3vHjxyHLMpYuXYqamhrs2LEjPNzEbmiKkV0Y6fP5MDQ0FK4yNAZ+3d3dWLt2LR544IG4hsZUVFRAkiTHgDPaHpYVFRWoq6tDc3OzbUBrd0x9r0RjK/vg4KDtoB/ra3PgwAFccskl4T8bqw517e3t6OjoCFet6iGhtU18PJWHxs+UlT7B3Pi5TfX2BURERPEIHTuB9274KvzyHrh9bnjzfHB9dA1ERqbWebPsfXAFyqZmMYaKQikUQr50APlqM3YV/gRK/VlYdOci5K6yGSyTrFbSykqonV0QythxVAAShiEPHgDsMjRFAQoLtQBw504taOvpMYeTeij0xBPI3LNHm2rtQDu3hBCyAEhQoYQDsIgr2VBIq57LzR2rfkylrCzg7rvHQqfq6vFX9yUqOxtwGAiZNCdOaIGf3edtqugVl04BoJNkbIHg9H02fz5bsGnWY/BI01LP/76Aod/+EIXXroAoMlc0iuwCeM+4DEKeXh/fyRqOMRmBpnVtu3fvBgB0dHRACIFAIBAOOGtqarB9+3a0tbWhra0N5eXlqK2tNQVHxgnIxgDTKVxqaWnB4cOHw+FfKBRCV1cXduzYEXX/SL0K0hg4SpIEl8uFUCiEzMzMcCA3NDQUHhSj6+3txaZNm6JOjg4EAqbXAHAOWZ2maPt8PtOEaDtObehOk8mNx7EbymPdE9HpvPoQGbu2aGD8lYfW8xnbyzs7OyMqPNNt+wIiIpp9hjoOoeOGW1B4YSGkUy+CcBmuPRXAe+ZHIPuLpm5BllZOoWihXWX9o8DmG5wfl6xW0vXrIZ59FipkCCUUnhwdNc7Th9fooc78+ZHVjIZQ6HhZGdw9PRBRrtUEFGTgIPpwCnLwRux19zoMvpkoIZwH59gZGNCG2jz1FPCznyV/PbmjobPd8z1xIvnnsxoc1AK2e+4xf97GQ6+UlaT42+T1z/WSJZFDg8YTtCfK6fsMYAs2zXrTK7mhWU9VVXR+9xfw7n0aOZ9YA+EztL6qgFx6KtynnTM1rSwJsoZTyRqOEU+gmWhVpHWteoil/9rR0REOGa2tydu3bw9XxdXV1YXPbWwR7ujoAICIfSZbWlqgqqrtYJPu7u6YFY45OTnw+Xym9WRlZYUfZ328vk59bcFgMOo5+vv70d/fb9pTEdDCQFVVsWPHjqihpS4YDIbDPafQ0mn4jHWvRN3BgwfR1NSEqqqqiOfg9/tRVVWF5ubm8Gcg2mAf42fIGg7rx7Fr0U7kMxXtnMk2Hbc5ICKi9Nbf9AaOfv3LKFq3FNKChaavCa9f+yH4VHfeRGvljGYCraS9jb3Yu2EvBnYOILvShyX3PAHfYz/W2q47OqIHb3YBZ4zqy87PfAY5r7wSdU0qJASxGH68GXPATCx2+xRGHZyic7kmtkfjTTeNb3K3ENp/dj/8Hhiwvx2YWPXhokXA3r2mmxxDZ1UFHnts7PP25z9Hbyf/4heBl14yV37qn5t77wV+9Stg+3bttXYKerOzgTlztM/QZZcB//iP9udKNGhPlNP3mV3reTzft0QzCINHSrmRo0Hs/5fvQXnnLUAZROGZ2XBdeg6ER5v65q5ugFwwH4DQ2qynqclqHY0n0Ey0KtK4Vmurra6/v982INQfZ3duo7a2tnA1pB4Utre3R+yjqDNOOdb5fD5TyHbw4MGIoSnHjh2zPR6gvVax9qP0eDzweDym83R2doZDPGM1Zzyho90xZFmOeOyePXtwxhlnOD6+pqYGHR0d4dduaGgo/H74fD7T8/H5fHj44YfDt7W3t6OmpgZ1dXXo7OxEX1+f6fkZW5/t9vW0a9HWq1mdwj1rBax170tFURynXE/UZG1zQEREs4eqqjj4H39A8NEngNAIsguDKLhmJURBIQBAKloMz9LzACGmbIBMhIm0TNu1ksbYd663sRet57VqPywNAUNdQ2h+NgPVL/wOuatzgYwM+1BJkoBAwD7gjFF9OVBdDdTVAQ7hoxY7KfCiG270xhcSxmA8RtzHS8ZgmCgt5Y5U1TnsNe6vmUz79mnv0ymnAG+9pd22ZAnUtjYI6+ugB2r6503fHsDu9ZJlYNcu4OWXIz+Ld96pPc9oU9F1y5ZpxwCA0e2EItTXJ75nYzzsvoes32fJ2uqAKI1NafC4bds2PP/889i1axdef/11BINBXH755fj2t7/t+BhFUfCb3/wGGzduxL59+5CVlYWVK1fi1ltvxaJFi6Zu8TQpjr/VjgP/dCsKzyuCOHMhhCwBJaUQsgxAgmfVlZCz50zKuZNdJTVZraPxBJqJtnk7TSCOlzFEcjqXXj0Yr6ysLNP9/X4/rrjiCtPk6qGhoYjzObU7A9o/IpqbmyOGnRgNDQ2hoKDAFMz19fWFqzZjyc7OxoDNnjmJHMOOHgpadXV1IRAIIBAIoLu72zbkA4DXXnsN1157bbgqddOmTaZhNHbDbfTj29m9e7cp2ATg2Dq9adMm02M9Ho8pfLY+dqIma5sDIpqZeD1KVsrQMPbf9m/IyWxD8RULACFBFBRAZPugqirc5WfBvXB5qpeZvJZpwH4CtWXfub0b9oZDRwBACFBlFXs37EXV5irnPQrPOGMsCLJavVprxb3rLm2vx7w84FOfAu6+G9Krr+KU/HzgzTejLl0AyMa+8O/NXzS0tsZBn86sjv5u+vVUJWC8oaMsA7fcAvzgB/Zf11/LBQuA117TThUKIXjOOch55RVzW7w1UNOrAO0G6YRCWkXk/Pn2A1caGuKr1Ny/f+z3ToOUjPdJlji+hwAk9/uWKE1NafD4xz/+EY888ggyMzMRCARitlUCwL/+67/i97//PcrKynD11Vfj8OHDePLJJ9HY2Ijf/e53KCubos2cKel6X2xG8EffQNHHaiACpaavCY8P3jM/AuH2Ttr506VKKp5AcyJt3nob8e7du8MVhtGqA/Pz800hknUKst/vx+DgoOPwluzsbPh8PvT09MDtdsPv96O0tDQcBOvKy8vhcrkmFAbv2bMnojLQ7/eb9pcEEN7TUX9e8fzdBGj7NAohbIPHWMNr9L+7ogXgdu3LJSUlEEKguroasixHhHzG8+vhol2IaQznFEXB9u3bsXv3btO+ktFEC/es6/Z6vabXI9nB4GRtc0BEMxOvR8lo5Egf3vt/X0ThChly1WrLPo4qvLVrRztvpoFkTd8FIvaLtNt3bmDnwFjoCCAHO7Ew9BB8T78NNNQD110XWZEmy8APf2g+l7EqbP78sQnTiqKFj9//PiBJEIqC7Bg/tHUcJKMrKADmzo3c4y/GMYeQk7QKyrSjqlqgGG3PSst0ZunVVyHn5WlfcwrUjO+73w8MD0eGo4ODQHu7fWgXTyuyNeicyurCOL6HACT3+5YoTU1p8PjJT34Sn/nMZ7B48WLs3LkTV111VdT7v/zyy/j973+P+vp6/PKXv4TH4wEAfPjDH8Y//MM/4Gtf+xoeeuihqVg6JdnBn/8J6l8fRN61qyBytf9pCV8hhDcLUk4RXItqJr2teiZVSU2kzVsfIKOHWUKIcBCmD0Dp7u4OH3ezpX3AOgXZGiACMLUaG19nPaAMBoPIzs62XZ9d+Kb/QzFWRaW1DTs3NxcNDQ2m6j9Aq4yM5x+exoEpAHDo0CHH9uuCggLTOaxt44BWbWrcG1N/nvq+mJ2dnaZ/FJeXl6Oqqgqvvvpq+BjR9lY0vtbW+xUXF5vaya1Vk263G0IIeL1elJeXQ1VV0/vqNBxHX79+/pKSkoh9PZMdDHJCNhElgtejpDu2+z0cvOVWzL10McSSJdoe4pIbUl4Awp0B1+JaSJk5qV6mWTKm7wJx7ReZXZmNoa4hIKSFjtW4FQKqNnX6mWe0oOjee7U9/ZwCFWtVmPWaRQ+iRn+dcOi3ZIlWuXf22XE/RAXgRm9yzp8qExnkoihaGOxyaeGg0/EN05lFKIRs/TrT79emhuflaVO7V60C7rsP+Pznx4JMSdLOo/9qZRfaVVZGfl6sa7JWDk5ldaHT95BdFWe837cxtj8gSldTGjxWJviThocffhgAcMstt4Qv8gDgrLPOwtlnn42XXnoJ77zzDk4++eSkrpMmjxoKYf+XfwD/yA54ProGIjMLqqLAc/r5cM07ZUrXkg5VUvG2gyezzTvWsewG0wQCATQ0NECSJPz2t7+NeEy0vRGHhoYwNDQUESJ2d3cDGKvIbGtrw/HjxwFoQeHixYvxxhtvYHh4GJIkQVGUiIEt1vOWlJSEAz2jzs5O098xdiRJijie3fOSZRlVVVWorq7Gjh07wsHe4cOHTfd77bXXbKsid+3ahb///e+mKsra2lrU19fbntMYuvX29prCTeNn2i4MjNZiPzx64Tk0NJTwMCfrZ0jfJ3OygkFOyCaiRPB6lADg6HOv4NhPN6DoE3UQJVr3hpQbgKf2Q6nbw3EqxVEZtmj9Ihx99ihUWcXC0ENa6IjR0EgPdR57LHqgYq0Km2x6NeXPfmYOvqLQ260TutpJdKL1ZJIkbQ9Du7b3RGRlOU8At5nOLBRF23NTf8yRI8DNN2v3uekm8+P10DE/H/B6gUOHYrdeX3qpFnDbfXYKC7XnbA26p7K60O57CIhexRlNvK3bRGloWg+X2bp1K7KyslBbWxvxNf1Cb9u2bbzQm+bUo0Ec+PljwOAwTjS+gMLlI5DrVkG43YACeFesg5w7d8rXlQ5VUqlqB48WeOqvk16p19/fH15jMtemh2aSJKG+vh6dnZ3hUK2rq8tUzRfP0JdAIIDKykr88Y9/tP26tZpRp4ea1r0kne5fXV0dfh3q6urQ1NRkO6THqRV7cHAwot15x44d4d93dXVBVVUsW7YMra2t4feoYXQzbev7ZnwexvfHqUXbjl01sB4Mx4PBIBGlM16PzgyqoqLnf1/ESPshhLq74e34M+ZcfTZE7hyoqgrXScvhrjgz4R+2pa1LLwW2bBn7syRFVIblrs5F9QvV2LthL3xPv61VOhrFM5nXac+9eEmSFsQ4TXK2Y6yaswZgDhJ+1yVp6sLUWPx+oLV1Ysc4fFhrU7cLVN1uIDdXO4flOZteNz2Mvusu+3MoihY67t+v7d9oFypaQ7t77wX+53/Gnl91tdbKHy1ITFZVcCzW6korp9ZrJ/G2bhOloWkbPB47dgwHDx5ERUUFZDnyp476Rt579+4d1/ETmU5L49e3/U0Ufv+HyDo9E8IjI2dNCUR5udZGLXngPusjgDcrZe9HdXV1+PeJTi2eCnaVedY1KooSrqwrKSlBVVVVwvsi6sccHh5GS0tLxCARa8VaVVUVOjs7TVWK+trKysoiWq11fr8f2dnZCAaD4UpHI4/Hg8LCQpSUlGD58uXhdSmKggMHDiT0nKw6OzuxZcsWx/Zsn88HIQSOHTtmeo2tVZQ6676FsiyjsrLStG5AG8oSD7vJ17pQKBQRXj711FPh8E9/j2pra+P+TM+dOzei4levsszOzo7YA9KuVXu6fb9MJ/prw9do+kvH9yqd1prueD06Mwz1DSDzW/8FufggvHMyIbIyIH90DURGJlRFgev0CyCXLIk6sG5GaWyE9IUvaBO6VVWrWlMUKPfeC6xcaQpRfGf6sOyJZZDW1kF99lnTIBFVloFly6BE+RxLy5YBXV3mx43+KgCohhbccAWd/rXRNlnl3/8d0mOPAc8/DwwPRw8JQyGor74KJRSC9Oij4WNZTXQvRzUUmpK2bBXQwjpFgbBpg9YrDif0XADtc9DTowVf+nuhh5DDwxCHDpneG0ehENRDhxxf8/Dn5ctfhjQa2olQKPLYoZD2/j/6KJTGRtvzpNyZZwLPPQfp3/5NC9gPH4awqeJUn34a+OAHoXzlK1ErF6VXXzUP6tEfP/p5Ho90vMaZrdL1vYp3vdM2eNTDAZ/PZ/t1/fZ4h0BY7Yxns1qamL/swLyX/xdzr1sBUWSuaAwqXryXezrUN9pStLj0YA29VFVF6+hP/FRVRWdnp2lQSkdHBzo7O1FaWmo9VFyeeeYZ2wnJr776avgvFf0cdmttbW0ND2qxDnDx+XwRgZaVx+MJD08x7mPY0dGRlL+EreGlLMvIysqCqqqO63IKHk+cOBEOK30+HwKBQMS6VVWN2GfSyPh4IDJoTuS5vPbaawkFznbnqqioADC256X+92tnZydUVQ3vN6mvt3UcP11XFAW7d+/G8ePHkZmZifLy8gkNEJru+P+a9MH3iuzwejT9qQd7kfvv92PhBwOQTns/hCFADo0o2DvndAx29QNdralb5BQru+MO5ChKuIJRDwCDDz2EPStX2j4m+4orcMqzz0LVQ6nR/3e/eeWVGIhyPeD0uIHTT4enuxvHy8pwdM0azHnxRWTu2YOh0T2kPd3dGJo7FxACnq99DcGyMhy97TYs+M53ooaGqiRhIC8PoXPOQc7WrY73S0ZoONmDaPQr0HdvvRVzXnwROS+/DGG5Lh3v+fW1G5+D/v6M5Gj7mrqOHjWdQ7+/3XGcjm/8MwAcb2vDu7/6FQaqq5F9//0I/OIXyNyzB67eXkiWggQRCmFo+3bsnGg152TKzga++U0AQNnNN2ufOcMPMFSMvq7PPAPp2Wfx5n/8BwYMRQJGZQsXIqery/x4SULfwoXYM8HXgP+vSR8z9b1KOHhcuXIljo7+JRSPBx54ACsd/geWSpWVlbY/uaaJU1UVB7773/DufwaZn1gD4fOPfgGAEJACpyKv4izkz5ZWlglYvny5YzWj3V6FAMJDYhIRCoWi/iVnDf2EELjooosc11ZTUxOuxDSu0brPoZX+Dzfr+p0COVmWw9/HsaZIA1qVn/FYVVVVqKqqwh/+8IeYj9XprdfDw8MYHh5GbW2tY5t+S0uL7T6TkiSFA81AIICqqioAMO0J6VQVqnO73aaveb1e2/fdWBFrPKc17JMkyfT4rq4u0z+kJUkKt3NPxJNPPhk+bjAYRFdXFz70oQ9N+LjTjf49xf/XTH/p+F7F+jt7NuD1KMUj2PwG+n5yD/KvXAZpwYKxL6gAMnORUbsWp3kyU7a+VJH27YtomxaKgpx9+5yvIauroZSXQ/q3f4M6unee8tWvojzW3nkOj8scfZxv9D9A+7vtTf3v45dfRvaFF4YHmbh7epCzbRuUW2+F9OMfQ1VVUxAWrpAEkP33v4ef03jCQbvQzHoMYflaoueJ5/76cRd8//tQfvxjYNs2qCMjEw47VQAQAqoQtp8DV1aWts/iK684Pm/rGoXNbXavTeY77+CUz30OyvPPA5/6lPYfALF2rW1FrdvSzTOtffvbwIUXaq/raBWnKdSVZZzy8MNQRp9zzMePVvz6vvOdcb8G6XiNM1ul63sV7zVpwsHjxRdfbBp6EEthYWGipwCgtWQCzj9B1m93+gl0LMbAgiZu5GgQ+2/dgNBbb0IghMJz8+G65FwIjxdKKAR3VQM8xYtSvcy0I8tyeKiIldMee4FAYNyf7UAgEFfVXSAQgNvtdlwbMLb25ubmqENMrLq7uyPWHwgE0NHREXFffT/FkZER/P73vzf9faFX5w0ODsLj8YQnMx8+fBihUAhFRUXhATDW9mun/Rv1v5eM97dbr/FrVqWlpRBChF+Tzs5O7N69GxUVFaitrTUFgsa9NvUp0nqAWFxcbKo4LC8vt11Ha2trRJu2Pi3byPq5sb7mE/lcGfX09ET8eSb/Xcz/16QPvlfphdejZEdVVRz46UYE//hHIDQC3/wQCq49E6JAe/9F0WJ4Ky+cPfs4Olm+HOjujhgsI5Yvt/88Wift/v73wOrViPuTq08WHv1PliTtNhvZra1wf/WrEC+8AIyMhG8Xo/vdyW+8Abz0Ung9IjdX2xOwr0/byklVzY+Ld40GQl+zPkQl1n3HcZ547y8AYGQE8u23AxUVQFub6fmNh8jN1fZtBICenoi9M0VXF2Bz3R11jXa3jbZqW0NJhEKQv/UtbY9E/XM1f752B8M0agEAR49CXrgwsQnPqZoMfe65Y4Ntnn46MtQNhYBdu5z/zjc+fudOiNHBOHISBuPw/zXpY6a+VwkHj3dOxih6G1lZWSgqKsL+/fsRCoUiXnx9Lx19bx1KneNv7ceBf7oNhe8rgfT+au1/MgVFo60sEt7KPR1LC09K9TJnHOuee36/HxUVFRMaklNVVRXey1FRFFMIqVfJ6dWNzc3NMadtA/aDSQDtH2l+vx8HDhwwVQXaTRfXn5Pe8quvQ799x44dEaHj2rVrTWuyBqBdXV3hSkCroaGhcHBpDBl9Pl9EMFtcXOz4WtjtFWUXRjoN6LEbyhIKhdDa2orlo/84iDUcyen1F0Kgrq7O8fGTNXwpPz/f9Brm5+cn5bhENLvwepSslKFh7L/t35CbvRv+T5+mBRj+HIisbKiKis6M+Vi09HyGjkDkUAw9GLzzzsjQ5tJLgS98YfyTdhOZ1NvYiFM+9znt907DOnbuHBseoh9bUcJ7EU5UuEqtvh7Yti3+gTaANnBmsvYJHRwEXn89/nWccQbw1lva9Gir/v6xKdN2603Gc5Bl7fhO70lTU+TnAtBe9/37tSCyqUn7L5HPXaonQ+ufTbvhOZap8VEfTzTDTNs9HgFgxYoV2LRpE7Zv344zzjjD9LW//vWvABBxO02t3heaEPz3u1H0sRqIgHlfQeHxwXXGhzH82hspWt3MZhcMJbJXnl01nTHoijbZ2hjiGadt2z3GGpDq/H6/KYCKFpzq6zIe38j6Z0mSIioH29oi9xPV12m3PkmScNVVV5leI+sx9EoYp8njdv+40YNVu3NG2//Sbn3xTIp2en6BQCDq4ydrEnVDQwM2b96Mnp4e5OfnJ6V9m4hoMvF6dPobOdKH9/7fF1G4wgW5ehWEbPgnjqLCVd2Ao+8eTN0Cp5vVq02VVRitrIKqRoY2Tz1lDqhCIaiSjP4Pfwm7vN9DdmU2Fq1fhNzVufbnSmBSr/TP/wxEG9piDW5uv33C1X9WAoAqJIi8POADH7CfvOwkWpg3lYQA8vK0EM9u/fr6xrPOL34R+NWvHAfIhMUTBNt9LvLygJdf1oI7/Xbj12NNeJ4uk6GjhftEs9C0Dh6vvPJKbNq0CT/+8Y/xy1/+Eh6PBwDwt7/9DX/9619xxhln4OSTT07xKmevgz//E9S/Poi8a1ZB5OZBVVXIefMhsudAZOfCNe90KA6DOWjiJhoMbd++PdyC297ejkAgYAr9oh3fKfhraWkxhXBvvvkm/H5/OKDLzs4OVytapz3n5OTEfD7W4wNayGcN1xRFgaIopv0w7aZZ6+Go3cAcfS9GfU3Nzc0RrXY+ny+iglGvFt2+fTsOWX7KbHyNVVXFrl27TC3diqJg06ZNCQXJ0QJiwBxQ69PJre91omKdMxqXy4VLLrlk3Ocms4m8F0QUH16PTm/H2t7Fwdtuw9xLFkMsWaL90E/2Qi5ZAiG7IZ+0FKo7E0jH4HEyW0btKqsaGiJDGyCyFVcJwXuoDUMYwlDXEI4+exTVL1Tbh487d0YGX3rlolFjo+2egmHW4KaxEdi6NebTHA+hKsCWLcBtt2nhUbwKC7Wwr6lJC92OHUtKFWbCQiHg6ae1dupkTshduRL43veAD38YOO88bbK307/1/P6xyko7vb3RPxfxfm6sxvu4ZHMK95PQNk2UjqY0eGxqagoPcdD3+WpubsYdd9wBAFi8eDGuv/768P3PPPNMXHHFFXj44Ydx+eWXY82aNTh8+DCefPJJ+Hw+fO1rX5vK5dModSSE/V/+AfzKDng+eh5EZiZURYFn6QVwlVaY75xm4+BnE2vwF2vwi5FT0GcNJI2TkQFtanJdXR2am5sjgkC7Fmsrp8DTGh52dnZi06ZNaGhowI4dO7Br1y7T42RZRlVVVTikWbt2LbZv3x5+TcrLy1FZWYnHH38cBw4cgCzLcOt74RjY7ZVYUlKClpaWiH0Vre3fQoiIqd/6+tvb29HW1hauADW2bre0tGD37t1QVRW1tbWOYaxuMioXY52Tpg7fC6LE8Xp05jj6zFYcu/+bKPpEPUSxdh0h5ZbCU9sAIRmmV6fj9WgqWkbtQhsbKiQEsVj7QwhQZRV7N+xF1eaqyDtXVmprj9VyumFD9JPm5QF33z0W3MS6PxDeY3BcVBX4wQ+ACy8Ennsu9v1lWQsdjS3gqSzAUBStPTuZfvhD7dfVq6E89xyCd9xhO2kbQPTQEbAPZGVZa7FuaLBvEY+nVTnez9tUYNs0UdiUBo/vvvsuHnnkkYjb3n33XQBaK4vxQg8AvvGNb+CUU07Bxo0b8eCDDyIrKwvnn38+br31Vv50eQoNdfXg0P88DiUYxPDrrSisE5DrVkG43IACeFeug5wzN9XLpCliF/S1tLQ4tvXq9KDQGiD6/X7HfSONFV3WPRON+ytaqxE7OzuxefNm22E5+lAanSRJqK+vNw3Lefzxx8OPDYVCjtOlhRCora0Nh5aqqtq2TAeDQVMlmvU+x48fN/3Zbt9HY5Wq/qu14rKtrQ1VVVWmiePJroKL1epOU4fvBVHieD2avlRFwaFfb8Fg29tQ+o4is3875lx9DkROLlRVhWtBFdzlK2fGPo6paBm1C230gS2SpLVZQ4IKgX24Zuw+IWBgp8Owp3hbTnfujN66e+QIcPPN2hpXr46vgm0iwaMuWuiot1Vbn5P1vUtUbm7s4G6qud3mar3Vq7Hn3ntR+9Wvau3cxrVKklbx2Nsb//H1/XObmrRfra9dvK3K8Xze7PYxfeyxqR9GQzSLTGnwuG7dOqxbty6hx0iShGuuuQbXXHNN7DvTpAi2tOHInf+C3Go/hNcN6f35WiuLJAGSBxlnXwnhzUr1MgmJtV2Wl5ebqvISGfJh3UMR0AIPfb++trY2x9Zm/VdjQFlRUYEdO3bYVm4ZK7oA85AbVVWjTsy2TlA2VjrGEm8FqKqqUBQl/Hy3b98e3jMzGutr4FSN0dbWFn4frVWqu3fvjpik2t/fbwpcJ6MKzrp2p2pVtgFPvnjfCyIaw+vR9BQaOI73bvwqcufsR0aRH6LUDWnZuRAZo503y94HV6As1ctMnlS0jDqFNvfeCzz6KLBzJ/oHF2JPz8fRpywbe5wMZFdm2x/T2nKqTy++8kpzyFNZCbWrS5v8a0e//fbbtT0AKyu1adbRKIp9+Dh6W3iQDGD6fdz04yoKcNppY3+Os3LUUTCordEwWRsAsGgRMDrQKmlOPx14883Y662tHft9YyOku+9G5fbtWnu5NSBVFK1CNZ7gUQigtFR7P48cGRsmY+T1AuefH1+rcqwWZ2slcWeneR/TqR5GQzRLTOs9Hin1Dv/peQxv/DEKrlkJUVhk+prILoT3jEvNG3hTSiXSdlk7egGhh1n9/f148sknUVpaGldAZNdurZ+vpqYGLS0tpinUxcXFUFUVmzZtQnFxMWpra9Hd3R0OpDZbfnrvVB2pt0YDwKZNm0xf83g8pspE6wTlUChkWwFpx3osJ52dnThw4IDptgMHDsDlcmHEsOF5eXm56T41NTURAa3f78fg4KDpvP39/WhpaXF8H+2qOqyBa7Kr4OKdeM024Mk3WdPHiYimk8H2g+i84RYUvr8I0mkXaD/81qmA98yPQPYXOR8gHaWiZTRaaHPDDQAAtbEX/ee1AkIFQgBk7Vpk0Z2Lxo5jtzeltQXZ2j6+fj3wzDOxA8CtW4H77tNCqnhYQ0dDmGc9T8Lho35sVdUmTp97LvCXv2B4/qlwtXdCYJwVi6GQFgguWDBWATg8rAWSubmJVRLG0tsLvPiiORi2m+b91ltaC7RhyrknFIJ60GbvVEnSAr147d+v/Tp/vn0AWliYWJVvtBZnazWqddBOqobREM1wTIzIlqqq6PzOz+F992nkfGINhE8bDgIhA0KCXHoq3BVnzoxWljRnrCrr6+szfS1a4CRJEoQQpuBrYGAgHMw5TanWA0mnduu6ujrbfQWtk7Dr6urCASKgtU0bg8zi4uLw3pFGxvZq69eGhobg8Xjg8XgghEBJSQmCwaDpORrXGU1OTo6pfVtv+7ZjrVZUVTUcOtpN69ZfV6vy8nK0tbVFBJ76+2itUi0vL4cQAh0dHab7WwPXZFfBWaeMb9682baikW3Ak2+ypo8TEU0X/dvewNFvfBlFH1kG6aQFo7cKQMgQWbnw1jTMzM6bRKfiJmsQTYx96XJX56L6hWrs3bAXAzsHtKnWdy5C7qrcsXU4hYvR2sfXr49/jZ//vBZuJcrt1oI7m/0Dk/IvGkUBLroIGHIDUMZXRal7/XXgH/9Re+0UZXLariVJ2wfyqqu0z8zGjdr7r3+Wmpq010qStF+feUYbuiMExOh6bJ+fvlZrxaYdl2vsfOPd1zER8VSjpmIYDdEMx+CRwkaO9GP/zf8KvPt3CElF3jnFcF1yLoTHCygq3DUfgqvwpFQvkyysrchGsQInpyDIaUo1MFax5tRuHe+54gmh9KpJnT7Ixfh8rZWJQ0ND4T+3tLQgEAhEtH3bndsaspaUlJgCPUVRwm3eiqKY1uXz+SL2mDSyBnLW98zj8WDZMq1lye44+vu4fPlytLW1IRgMwufzYfny5XC5XFBV1TQYp7q6OmKPx8kQq6KRbcBERJQoVVXRfe9vcOyPGyGpI8he4ELBNWdCFBQCAKS5S+BZdsHM/+F3IlNxp3gQTe7qXPtBMkD0cNGpffzPfw5XMMb1ro53/8Th4fgrJcdrYABuACoEAHVi4eNdd2nPdbJCR0UBenrsW4w3b9YqHJ95JnLKeax9MyUJyMiIrzJz3jzg7LPtvxbvvo6JsKsktjtvKobREM1gDB4JAHD8rf048E+3oegDpRCXrgYggDl5ELIMQIJn1UchZ89J8SrJjt2glpycnLgCJ6dhMHpAFCssjBUsRRsMo99Xv89rr71m+rp1aAqgtTBbg7lY7dCSJCEQCJiCQmPVpP46WUO02tpa+P1+U2ipt3lbQ8rKykr84Q9/sA0N7Vqlra/j0NAQhBARt1v3pNyyZUv4HMFgEFu2bMEll1wSMRgHmJqW5lifj2S0AXOfSCKi2UMZGsb+W7+J3Jy3kHNDvRYAZGVDZGZBVVR4Ks6Ca+HyVC9z6sQ7FTcVg2icRNub0in0GRwEtm6dWNVhvINkYgWW8VTpxbMcqFAhYQSZcGFgfM9NDwWTzevVhr8Yj2+tPt2wAXj66cTPrweaNnu923LaszKRfR0TYa0k1tfrNCiIiJKCwSOh94UmDPz73Sj6WA1EoNT0NeH1w7tyHYTbm6LVUSx2g1riDZ1qamrC1XLHjh1DZmamqS04VrAYK1iKNhhGv69TxaZ+LusAFruhNdH09fWhvLwcgUAgvKekcSiNfnxraNbd3Y2KigrT2pwq9lwuFz72sY+FA7KDBw+aAtFYga1+H+vt1dXV4VC0q6srYi9J616OUy3W5yMZbcDcJ5KIaHYY7ulD+/+7HQUr3ZCrzzLvIa6o8NZdDDl/XuoWOJ2lYhCNk2h7U+qhj4OY1YHWkMj0YNX+9njJMvCTn4SH6ODAAa1CcgIEFMgY1JaHBCsfZVkb0HLkSFKCUJNCrXo44rUKhbT26jVrnM9pGcwTfl6nn65VOA4Oxh+YulyAYT/0iDVORmhuV0l82WVj73u0ymIiGjcGj7Pcgf/6I/B/D2HONasgcvOgqirkopMh5ZVAeLIgz11s3sCbpp2JVJVZ93kMBoPh1iW9IjAQCEAIgUAgEHHsWMFStMEwTvfxer1YtmwZqqqq0NraClmWHSc+R6M/rr+/H9u3bzfttWg3yMYuRLN7bRVFwaZNm0xTo1VVDVcslpSUoLi42LQXo11ga9wfM9r5orXSGyeRp6IycCoGm3CfSCKime9Y27s4eNttKLpkMcSSJdq1iCsDrkVVEJIMuehkiAyHqcmUmkE0TqLtTblqlRb6XHihFlBZ2AZzubna3owAUF+vhUQ33WR/7vGEjkJo+zJahuigoUHbz9CuilKSgMxMYGAg6qG1UG4kHNDFTZa1X+fOtd/3cCIkaexzYfeZGR52Dh0Nwa9pj0dJ0gbhbN6sDYiJ931wCh2ByR+iZA019fediCYFg8dZSh0JYf+XfwC/sgOej5wHkZkJVVHgWXoBXKUVqV4eJWCiVWV2wY417KqrqxvXOazt1b29vdi0aZMpGLMGfsuWLUNdXR2am5tN4V0s1oAyKyvLVB3Z398ffk5OIaNxr0R19ELTbkiOdTL27t27w+fS27Rra2tNx1IUJRwE6gGsHhTqE7/1IS0NDQ3h+1rfH4/Hg1AohLlz56KhoSEcOBonZOvPzVgtmWgYGU+QORWDTbhPJBHRzHb0ma04dv83UfSJeohi7e94KbcUntoGCElO8erSRKKDaOIx3mE1TntTqqoW5u3cqbX5Dg/HDqiEAM46K/Lcd96ZvEDO5dLWdPfd5vOsXw889ZT9Y1RVa0P+0Iei7mMoHH4fldcLVFdrlYdvvhnvo0ZPMnoWSXIODxVFq6K87jr7z8yxY87HVxT7qdqKMlZdW1mpTbSeaIs4W52JZhQGj7PIUOdhHPjJbxA6cgRK+zsoXOmGXLcKwuUGFMC7ch3knLmpXiZNMbtgxxp2tbW1jSu8sm78HgwGEQwGTS2zepVcZ2cnVFVFV1eXbbgXS1VVlanqUFVV2+Cyq6sLDQ0N4d8bn5Ox+nP79u0QQkQEa/GsSw8cjcfavXs3fD6fqXpUP7Z14rf+2gCR78+yZcsghEB1dTWEEKbqS+vznEib8nRpcZ6KqkoiIpo6qqLg4C8exfGWncCJY8jCbsy5+hyInFyoqgrXgiq4y1fO/OExyZTIIJp4THRYjbWizHq8aC3TRqqqhX9PPQX87GfAjTdqt9fXm4eeAONvsx4eBtrbI5/j6tVau69dwFlQoL22Z51lvw+id3SLKpuqzqhcLuD557UQNNpQGf063K7dvLBQe32i7c/Y1AQ0NwP33AM89pj5M3PBBbHXad0H01hdu369VimaCON7JwRw331sdSaaYRg8zhLBljYcuetfMGdFPsTJXoiauRCLTtbaqCUvMs6+AsKblepl0gSNp93WWOlXXl4erpIzhl39/f3o7++3DaCinTMQCJgmQxvp4aZeNWcN3/QJ1nZ8Ph8qKrTKXH3fRutzVRQFQghTJSCgDZZxWq81cN21a1f4NdLvo1pabnw+H8rLy00hp90+lPprCCD8muivY7R2YqdKTCBy6reRXYCcSJvydGlx1j8f+udMrwrlkBkiovQTGjiO9278CubM7ULWyXmAS4JUcS5ExmjnzbL3wRUoS/Uy01O8g2jikexhNdbj6aFjfr4W0s2fDzQ1aa3JoZD9foif/zywfLn2PJ0qPE89FXj99fE9Z7vnaBdwyrJ2O6Ct45lnzMeR5bHw0PrYaE4/XasIjVFFCUB7/eyCeX1tdhOp7Z7rY49p973vPm2C9jnnjIWaTo4dA4SAKstj71UopFVRNjZq709BQXwVqfp68/K4vyLRDMfgcRY4/KfnMfz7f0fBNSshCgpNXxO+InjrLzFv4E1pazxVapIkoaamJlxFp/8Z0MKmvr4+U5BmDaCs5+zo6Ai3UFdVVYUfoyhKxJ6GRnb7QdbV1dmuITc3N2KKs9PzMoZ25eXlABB3deHg4GD4vvp9rGFXbm4uamtrw9WWvb29ttOtrYzPN1o7sbUSs6WlJVwxaRcGyrKMuXPnhl/78bYpT7cW5+lSgUlEROMz2H4QnTfcgsL3F0E6bY15D3EV8J75Ucj+QucD0NRJ9rAau+MpihY67t+v/bmxEbj7bqjPPBPeP9BEVcdCwWjt3MbKSn2vRONziMb4HBsbIwe7xNvCrqpj4WisSszsbOAHP9Du47R3pdM5jCTJvDZrOGulP9f77jOfN1bVqCQBzz0H3HYb1FdeGbt92zYtuCwoGLuf8ViSNDYAyBgW//CHDBqJZgGmTTNUaOA41JCCAz/9NbzvPYOcj58L4fNrX3RlQAgBOVABV9kKtrLMIJNRpebz+UyhX6zA0Dh0BRgLh+wqI43sgi67VmS7NThpaWkxVSLq4aCRsY1cD+t27dqFQUN7TKyQ0LjX4eOPP24KHp2G4xifQ6x2Yuua9ePbTccOhULo7OzEjh07TMfV95G07rHpJNqaUjHIZrpUYBIRUfyUwWGoQ8MYeO0t9H7zThR9ZBmkkxZoXxQyhMsDkZkDT9UHIDyZqV0sjUn2sJp4jrd6NZRNmxA85xzk/O1v9nsiGoNPpwpPp0Dy+utjV0NKktYeXVSkVexZr23q681B2YYN9sfRA9J77tEqNXWjE6EjzrdsGfDhD0dfWyz5+dpkZn1txnD2z3+ObPvWX/+77krsPNXV2rHz8kxDZsIho/66GVvp9QD41FOBt97SWsqrqxk6Es0iDB5nmJEj/Xjvhq9C7tkNIQO5ZxTDdcm5EB4voKjw1H4IcsFJqV4mTZJ4q9SswdHy5ctNX7cOlwkEAuEqxliBoZFe6Wg8l3Fwir4WfQ9Ej8cDj8cTnj6ti2efP+NxAK26sbu7O2I91vU6tZFbg079eXR2dsLn82FwcBBerxednZ1obm4Oh292AZz+vFRVxfDwMAoKCsIhJxB7SIt1zT6fL+J1sVaF6gGw3Z6XdpO4reFhtDWlovpwulVgEhGRM1VV0f2jB3HiiY2QXQoyAx4UXLsSIl+raJTmlsGz7Hz+8Hu6SsawGuNwmvnztdusx7vssrGBM5WVwJe/jM7PfAY5f/tb5PGM05ijsQskGxuBN96I/VhFAQ4fHgsHjRV7sqyFbcagLFZl6GOPmQe9WKsU9eNv2AD09MRen9s9FlbaufvuyGFAmzdH7rFpfD/POSf2eXWyrIWFALBzp31lqv68JEkbInTihPbn4WHg738fCyKbm+0nhhPRjMTgcQY5vmc/DtxyG+Y2zIcoOU/7H4rPDyHLACR4Vl0BOTs31cukSRTvIA5rcKSHUDq7tue1a9dGPad1L0VAC4dihVTWqsShoaGIfQvjmZ5sPc727dsj9ok0vibR2sjtXkdrGAsAw8PDCAaDpj0brQFZKBRCKBTC0NBQ+Da9IjHesM5auagzvi7WqtBDhw6F19Xe3g6/3286pnUSd6wg0mii1Yfj3YtUPxeHzBARTV/K0DDeu/WbmJPzNnJuWA24ZMCbMbqPowpPxVlwLVwe+0CUOhMdVmM3nAbQKgb379eOd9llwM03m+4jPfsscP/9UG69FfKPfjR2PEnS/osWfEabwq3vMRkPp/uFQtpQFqNYlZx2waSVomjHzc+PvS/i8LD93o6SpAWm+p6OdoNynN7PeM7r9QLnn2/+DFRWQu3qih4+9vaaW731+050z1AiSjsMHmeI3heaMPDvd6PoYzUQgVLT14THB+9ZH4VweVK0Opoq8QR0gH1wZAzpEqkuM+7FaAzx/H4/ampqsNlyQRFPaNXZ2Ynf/e53yMnJCZ/bOEQGQERwZXec/v7+8Nr0VmN9OElDQ0NEmFhcXIzm5uaI6kxFUdDW1ub4Ghifh74+a7u20/3jYXxfQ6EQWltbAZgDvOLiYtTW1oYDRWPQCUQOxbH+2RpEAs5VjBOtPhzvXqTc05GIaHob7ulD+/+7HQVnuiFXnWneQ1wBvHUXQ86fl7oFUvwmMqzGaThNXh7w8svabQ0NtveZ/6MfQXrzTfMegYoC/PSnzsFnrCnc492b0urw4bEBKvHsAWkXTDr5xjfi2+PRLhjVKwyjDQNyej/jOW9hYcRjla98BdKzz0I1tlvbcXrudkEuEc1YDB7TlKoo6HnkRQzu64By6DC8nX/GnGtWQ+TOgaqqkIvLIBeeBOH2Qso/ybyBN816sYIju0nKiqJEVKUZgy/FctFRUVERbs+Odi6nVu1gMGiqJgS0kKqtrQ0+ny9iL0m74wghwtWKxopM/X7WSsLOzk7bPSpbWlpsJ1VbnwcQWYUY6/4TYQ3w6urqkJOTY7tWv99v2nvSGkxa6S3kxipLPfw1Dg0aT/Uh92skIpo5jr32Nnqf2Qo1FMLInx9B0SVLIJYs0TopXJlwl58BSDLkvHkQ3qxUL5emQjzDaWzuI0IhZLW1aeGatc350UeBG26wP1+sKdyVlUBnZ+zBKbGoKnDhhdr+hHahmXUPyFgDXoyWL9cmW7/xxvhakK3PLd5hQDfeqP16113OlY8HDmhBsbGKdPVqvPvFL2LBd74Tef9YA3V0hw6NBblENKMxeExDoWMn8N6N65Gb9Q58+VkQWV7IHzkPIjMTqqLAs/QCuEorUr1MmmQTGfBhbVtdvnw5Xn31VSiKgtbW1nCQqAdY27dvhxAiouIsnr0gY7XIVlVVob29Pe7wSd+T0airqwsNDQ3o6OgwtWmXl5fbtkjrjzG+fqqqRrR462uyrk0IgezsbPj9fse9L63hbVlZGYQQEZWbE2EX4FkDWL/fj/Ly8vA6dHrw6Pf7UVFRYdoDEtDCZmtVovH3E6k+5H6NREQzw6EHH8fIo/cjuyIPEAKuT1RBFI/+IC63FJ7aBghJjnEUAhC9VTjdxDNMxuY+6mjFoEh0onasoFMPAIGJh4+Dg8DWrZG32+0BaW1xHhw07yEJaCHdkiVjFZuqOhZUxhvg2dH3gpw/P/bn6cYbtf/OPNP+uQ0Pa23cxipSAHP+8hf7UFXf3qe3N/Y642m3nknfG0SzFIPHNDPUeRgdN9yCwgvyIJ32vtH9G0cpgHflRyDnFKVugTRlJjLgw9q2qk9d3rFjhyl8MrILBuPZC9KpRVYPTu32hkyUoijYvHkzAoEAAoGAKdyztnobH2N8/ax7IAJjrdd9fX2m21VVRTAYxCmnnBL1uXV3d4cH5UzG1Ge7AM9pf0qn1zgnJwd1dXVQFMW0x2O0IHiiFYrcr5GIKL2pioKOu+5FVvBlZF33Pois7LGvqSpcC6rhLl/B4THxitUqnG7iGU7jcJ9jFRXIfuMNc/gYa6J2rKDTGgDOn69VLForK/Wp04XaECT09MQf/NmFo9bA7NJLgS98IXLICxBZsSlJ5hAyHtbAUl+/8fMEOId4+/dHf36W9u3MPXsiQ2JACxzjve6NVZU50743iGYpBo9pJNjShiN3/QuK1p0OacFCw1cERGYuvHUXs4VlFkmkXTVadaT+NWtFnJVdVdpEKtecKhEBQJZlyLIMj8eD8vJyCCFMexACY9WViqKY2qPr6upM4ae1BRzQqvys/xg6duyY6c/6npfGNcqyHA5pAefX3Gl4z3iqU6OxC/Dsgt5onw27FnFAe95O08onWqHI/RqJiNJXaOA43rvhK8iv6Ifr7LMh3O7RrwhAkuE5bQ1cJUtSusa0E6tVON3EM5zG5j7KV76C/W1tOOWGGxKbqB1P0Gnd41APBfWW6eFhbWo0oLVM6yGhEPEFf9Zw1Ckwu+cebdq18XW58srIcyjK2BRrSdLWF43brbWB65WVxtBUDyPXrjVXIVpDvFh7UlrC1aG5c+E+eBC2P16IN7CNNal8pn1vEM1SDB7TxOE/PYfhjfeg4JqVEAXaT+GkosXwVF4AIbh/42yUSOgXrTrSOg3ayK512ihW5Vq0wDNaGGacBK2HVLW1tbbH2rRpk+mxbW1tpvvYVVtUVGhbERj3jzQGij6fDxdddBGeeeYZ0+OysrJM4ad1GI2+JutzS2Rwy2Swhq8+nw85OTlQVRVdXV1obm6OCEPtJmkns02ciIjSz2D7QXTecAsKP1AE6dR6bQ9x4YZ31RWQMnypXl76imdPxHQTz3Aa631CIQxkZUF57jnI3/pWZGjp1HI7nincxnNbQ0K9rVgPCf/8Zy3Mc2IXdDoFZo89Fvm6OAV+etgoy9p/p5zivAdkefnY7/v7I4M/fcq0kTXEi7UnpTFcbWxE9htv2L8eiYgWKAMz83uDaBZi8DhNqaqKoY5DwEgIh3/9GDL2P4OcT5wL4fNDVVW4y86Ee1FVqpdJU8QuwEukXTVadaT1a36/PzxNOlZlXqzKtWiBp9NQGae1O53Lehx9D0j9tkAgYAoYA4GA6bWymz4dDAaxZcsWlJaWmo6tV18a94W0e37WNVmP39bWhqqqKuzYsWNCVZDW17etrc22tdsavubk5CAQCERt1WdVIhERAcDI0SBCvUGc2NuBvu9/HUUfqYR00gIAgMjKg3fFhyFkd4yjUFTx7ImYalO5z55daBlvBeHGjYmvK1ZIaD23vtVVfb3WnmwXdMYbmNlNx7bSz7lgAfCf/wmsWWO+vyQBb76p/RdvW7bdmowBblOTNvxFb9vWp2Y3NQENDZB6egAgstoxNxcIBuNbx/33j71mTp+vdPjeIKKYGDxOQyNH+vHu5+5AxvF3ICTAt3wuXJecC+HxAooKb+2HIBeclOpl0hRyCvDiDYaiVUdav1ZRUZG0wCla4GkMTo3t0nZrB5yrJ43H6evrM1Uk6kNn9N9bA75o06d7enrCLdtO4aC12lJ/fjU1NaZBN9YJ0v39/di8ebPtBO1EWF/f/v7+8HMxHssufE32ZOmJDDsiIqLpR1VVdP/oQQxv+R3kDMBb4DZ33hSXwbP0fO7jmAzxtAqnUqr22TOGUYODWgBmbR/+/OfHQrHxritWSGi3RyQwFjquXx9ZXRlPYGZ8XWPR17N6NfDii+aQ7sgRLRBMNHS0W5O1ElQPIQ8f1l7nQ4e0itBQyL7F2u3WPrvR9qZcudI8/Tva52u6f28QUVwYPE4zx/fsx4FbbkXxhxZAzLtQ+4s1I3N0iIwEz6orIGfnpnqZlKCJhjITDYmiVUcapy+Xl5cntY3WKfC0vh7G6j+ntl6n8NVYmdfc3GwKEUtKSiIq9/ShMsZzA8DOnTtNAWF+fn7Mqj+n5ydJUsT7a90f8sCBA6avjyf4c6oatR7LaeBMMidLT2TYERERTS/K4DDeu/WbmJP7NnI+twZwuQG3G8Ljhaqo8JyyCq4FrDhKmvG0Ck+lVOyzZw2j7BhDyImsa/58wK4LRw8YgbFALt4QNlZg1tgIfPjDwMhIfGu0DssxPr/588cXOgLRQzz9PA0N4bARQPhXFZaKR1nWqkDXr3cOae0+17E+X9P5e4OI4sLgcRrp/XMTBu69G0Ufr4UoCZi+Jrx+eM/8CITLk6LV0URMNJSZyBAXIHrbrF41KIRAdXV1UqvUnALP8bwe8YSv8bSfO527qqoKmzdvRk9PD/Lz88OVkuN5fkDkezZ37lxTVWfIcoHotF9kPOe3Tga3fj7s3v9kT5ZOdgUlERGlxnBPH9r/3+0oONMNueqs0R9+j1IBb93FkPPnpW6BM1U8eyKmylTts9fYiLI77oC0bx8wNGSucIyXcV2T0R4ebwgbLUzWw8t4Q0cgekAYayiME2vloROb919ACx5VWdYmWxuD1VWrEvssx1NxOl2/N4goLgweU0hVFBz69RaceL0NarAfmcHtmHP1aojcOVBVFa5ABeTiJYDshjSnmENk0thkVixOF05VnXaB4nhej3jC13j2JXQ6t8vlwiWXXBJzHfGez/qeVVVV4eGHHzYFhMb9NJ32i4zn/HoFYyKfj2Tv4RhvOM6WbCKi6SfY0oajf3oG6vAw1NdeQtHFSyCWLIEQAsKVBfdpqwFJhpQ7F8Kdkerl0lSbin32GhshXXghchQFItGw0UhfVyLt4fv32x9Lv93YcmycFq2LN4RV1cQrHYHYAWGsoTCA1iadnw94vYlXDdq8/6osY+DUU5E9fz6wa9fEKhG5jyPRjMfgMUVCx07gvRvXI3fOu5gzNwdijgvS0jUQmZlQFQWeZRfAFahI9TIpikQClMmsWBzvmhIRz3ETqWIcz+sxkfDVuH7rhOeJthg7sXvPKioqTK3gxv00nfaLHO+5plq87w9bsomIppdDDzyO0JP/idylc4EMAfnjVRDFo1uH5JbCU9sAIckxjkIz2lTsszdaSRg1dJQkwO+PnM6sM67r7rtjVybqgeKhQ/bHMgaY0aov7fZuvP12YOvWsdu6urR2ZX0tTvR25f37zW3Kt9029ntr9abdHpRNTebnLQTw6KPjCwYd3v/9t92G8uuugyxP8O8H7uNINOMxeEyBoY5D6LjxVhRekA/p9AsgjAGOAnhXfgRyTlHqFkhxSSRAmaqKxckKdeI5biJVjON5PZzCtURDUUAbriJJ0pRXjybSmj1Zgeh4xPMaxxt+siWbiGh6UEMhtN91D7IHXkHWJy+EyMoa+5qqwrWwGu6yFRweQ1OzB+XOnVrLrhM9jDr1VPtBKl4vcP75Y+uK1b4bbQ9JuwAzWiBq3bvRro06njbowsKxcNC6PuMelHbVm9Z2ZGub+UTer9Wrtenhd92lVXzm5UH5+tcxMLpP+oRN1udrKiexE1FUDB6nWHD7mzjyr/+ConVLIS1YOHqrACQXRGYOvDUNEN6sqMeg6SGRAGWqKtImK9SJ57iJBGfJfD2cQlFjWNbX1xdx/osuugibN2/Grl27wns6ulyT+1diIq3Z06mdPpmB9nQOWImIZovQwHG8d8NXkF/RD9c5Z0O43VrAIXsASYbn1LPhKl6c6mXSdDLZ++xVVkLt6jKHj3btwVdeaR/iFRaa1+e076FeRWjdq1EXT4Bpvf/zz4+FZPpxE+VymSsSN2xwrrKMZ4hOMt+vxkbgC18YC2CPHIH0T/+E7PvvB6qrk3OOZH++UjWJnYhsMXicZKqq4sBPf4uB3/8WkhhB1jw3Cq45E6KgEAAgFS2Gp/IC7t+YhqZjgDJZa4rnuFMRnNlV3jmFotYqR6OSkhJs3rw5POyls7MTmzdvtt3jcar2JJwO7dJOkhloT+eAlYhoJhvY9Ra6br8L8okeuLxA4SWnQDq1Xuu8EW5krL4CIsOX6mXSbDXabqtKktZu7dQeHO9+gOvXj7U2GzU1aaGUU6AYb4Cpn/f8883rs6vGjMVY6Wg8TrQqS+u+ktGq+yZa+ecwUCfwi18An/pU/MeZSqmYxE5Ejhg8TiJlaBj7b/82crPehP+mFdpfdplZEJlZUFUV7rIz4V6UpBJ1mnLTMUCZrDXFc9ypCM7sKu+cQlFrOGYc5FJTU4Ndu3aZvt7T0xP3OadrQDhZkhloT+eAlYhopjryxEs48T/fR8nHl0FkLwUkGWJOHgBAZOXBu+LDELI7xaukWW31aijPPYfgHXcgZ98+iOXL7dtt490PcPVqba9E4z6Lug0bEgswn31Wq740BoGSFHnexkbg8GHn52jcC3Giey8a1xqtug+YeOWf3VTrUAiZe/YktuapNFWT2IkoLgweJ8nIkX7sv/6fUVAPyNWrIIwtnIoKb+1ayAXzU7dAmrDpGKBM1pqmy3O1holtbW3IyclBIBCAEAKBQCAcilrDMuMgFwDIz88PVzzqf47nnLNxT8LJCLQ53ZqIaPKpqoruHz0I15uPIfeT50D4c0xfl4rL4Vl6HvdxpOlh9WrsufdeVFdXOw8sSWQ/QLtp1Xr4tHFj/AGmfj59YMvwMOAeDervvnusgnDDBufnpk+mVtWJ72VoXWu06j4g8co/a4Xk/Pm2U62Pl5Vh2tZIc1I20bTC4HESHN+zHwduuRVFFy+CKCvTLuZkL9yLawDJBblwIURGdqqXSRPA0CQ1rGFif38/+vv7AWhViMZgMVZY1tDQgM2bN6Onpye8x2M855wOLfVTbTKCZ1aSEhFNLmVoGO/d8k3MmfM23JedC+HNABQF8qIaSBnZEL4CyHmBVC+TKHHx7gfoFD7Nn68Fa3PmjN1eX+8cAhrPZ60ufPpp4KmntCByeNh+Hbm5wMsvj/05nrXX12vHtrZbW/egBGJX9yVS+WdXPamzhLSdn/0symM/k9gmYwgMJ2UTTSsMHpPs6PPbcOwnG1D08RqIklIAgJRTAk/dWgjJ4Sd3lHYYmqSGMUzs6+sLh476bc3NzaagMdp74nK5sHbt2nCAvGPHDtsAeTq21M8ErCQlIpo8w4d70X797Sg40wO56iwIWQZUAc9ZV0H25aV6eURTwy58AsYqF42B1Pr18VUeWqsL9WDQKXQExqojx7N2IczBYXV15FpjVfclUvnnVD1ZXw/k5YXDQeUrX8FAVhIGok7WEJipmMRORHFj8DhBqqLg4M//F8eadkAMH0cW9mDO1ashcudAVVW4TloOd8WZbGGZYRiapIax8q65udk0PEZRlITD4HgC5GRU+7FCNhIrSYmIkqt/2+vo+Z8/QR0ahtSxE0WXlkMsXgwhBIQ7G96zPgLhzkj1Mommjl34dOSIeQBMokNHYk25tjM8DDQ0JF7RV1cHbN9uPt/WrcDZZ2ut2z/4gXYcu30oFQW47DLtfIlU/jlVT+7fb67aDIWA1taEXgZbkzkEZrInsRNR3Bg8TkDo2Am8d+N6zClqR9Yp+YAsQypfA5GRCVVR4Fl2IVyBpBSg0zTD0CT1qqqq0NHREW6VtoonDJ6KAFlRFGzatCm8n+RsqpCNFriykpSIKHkOPfA4Qk/9HAU1pYAkQTq/GmKudm0izZkHT02DNr2aaLaxhk/z509s6Ei0KddOenu1CdvxVvRZqwDtbN2q3Uc/zj33ADfdNPZ1IYCbb9a+nkjl31TvjcghMESzAoPHcRrqOISOG25F4YX5kE5fY76YUwDvyo9AzilK3QJpUjE0Sb0dO3aEw7zOzs6I8Le4uDjmMRINkMdTudjS0mIaYgPMngrZaBWl02VgERFROlNDIbTfeQ+yj72CrI+fD2FofVRVFa6F1XCXrWDnDY1PMvfem4x9/MbDLliTJGBwUAslY63N2r4dr0Qq+qxVgE5GRoALL9T2fDxyxLwmRdHCR/088Vb+TfXeiBwCQzQrMHhMgHJ8EMqJIRxr24feDetRtG4ppAULtS8KGcLlhcjMgWf5+yC8SdjzgqYthiapZw3vBgYGEj5GogHyePb2tAsZJ6NC1ikUTWWbN7ckICJKPlVREOodgDI0jPbbv4GCUwbgOvdsCLcbUFUITzYgyXBXnAnX3JNTvVxKV8nce2+y9vEbD2uwprcn9/Rov8Zam3XK9aFDia8hVkVfIu3cg4Nj1ZSJnsfOVO+NyCEwRLMCg8c4qKqK7p/8FiceeQiyB8ic60bBNSshCgoBAFLREngqL+BPk2namo57DE50TdZqRavu7u6Yx0g0QB5PkGZdZyAQmJQKWadQNJWDkLglARFRcg3segvdt34ZbjkI2Q0UfaAC0ql1WueNcCNj9ZUQGdmpXibNBMnce28y9/FLlDVYGxwcCx3jXZt1yvXtt4/td6go0QfNAGOTtZ32fUy0ndvpfuOtHJzKvRE5BIZoVmDwGIMyNIz9t38Ludm7kXPj2YDLBXi82j6Oqgp32ZlwL6pK9TKJopqOU7gnuiZrtaKqqti+fXv465MRco0nSLOrqpyM0NcpFE1l1SG3JCAiSp6ex/+CwQd/gJJrlgN+PyAkCH8OAEBk5cO74jIIeRzTc4nsJHPvvem2j58xWJs/fyx01CWyttWrzUNXGhqcKxAB+8na1ipLaxWgEFpwG490rBzkEBiiGY/BYxQjR/qw//p/RkG9gFx9FoTL8HIpKry1ayEXzE/dAoniNB1bXie6Jmu1oqIoEEJMasg1niBtqtrynULRVFYdcksCIqKJU1UVXT98AO7djyP3E+eEw0adVFwOz9Lz2HlDyZXMvfecKvjmT4N/RyV7j0G71mEAqK/XJkPHM1lbHxZz111aNaZ+LGtAaiTL2jny8lg5SETTDoNHi2Ovv4OjmxqhhkYQ+usTKLr4ZIiyMu1izpUBd/lKQJIh55VyH0eadMlqkZ6s8Gki60v2mqYi5JqKc4z3NXUKRVl1SESUfkb6BnD4t1swcrQfI6/vwpz53XBfei6ENwNQFLiWrIDIyoGUlQMpZ26ql0szUTL33lu/XqsCtGpq0lqVUzFkRpfsPQbjaR2ONVm7sRH4whe0oFH/Lxp9zT/8IYNGIpqWGDwaHP71kxj+35/Bd0o+IADXxyshSgIAACmnBJ66tRCSnOJV0mwykXZkY4BVXFyM2tpadHd3JzV8msj6Znsg5hQwjvc1dQpFWXVIRJRejr/TgQNfuA1zTgFEpgdSbR6k086CkGVAFfCcdRVkX16ql0kzXTL33lu9WqvG27o18mu33x6u0pOWLUP2FVcA1dUTXX1ia0v2HoOxWodjVVlu2BA7cJQkID8f8HpZ3UhE0x6DR2jTATu+/lNkHW1EzrUXQmSNbcqtqipcJy2Hu+JMtrDQlJtIO7I1wKqrq8PatWsndX1tbW1xV+olOxCbjgN0onEKGKdjWzwREU2NvsYd6P/unSi6ohpinrkNVbiz4T3rIxDujBStjmadZO69t39/5G2hkBZG6tWGXV045dlnoZSXA+eem5zzxmOq9xiMVWW5c2fstmohgEcfTTxsbGwcm8itq683D7chIkqy6fuv8ikSOnYC+/7hS/BLrfA2nG0IHQUgueFZegE8p5zF0JFSwtp+nEg78lQEWNb19Pf3o729Hc3NzWhpaUn6+aLRg7xUnT9RTu/PRN5zIiJKX4f+53Gc+I+vIe+aVYbQUQCQIBedDO/ZH2foSOmrsnJsv0Or0co/EQoBqgrp3/5tCheWAnqV5fvfD8ybp/364otjIWK0/SUlKfL+8WpsBM47D3j6aeDQobH/nn5au72xcZxPiIgoullb8bj3ihuBQ51we0IovKQc0ulnQEgSIFzwrroSUoYv1UskmlA78lQMFTGur6+vD/39/eGvTXWlXrpVCjq9P7O9BZ2IaDZ575+/h9C2/4MkFOTV++G5cg1EZhZURYHn9PPgmndqqpdIlBx2VX42k5+FokBN1bTrqRStynL9euCppyJvlyTgAx8Yf3Xmhg3adGxrNaWiaBWU+nAbIqIkm7XBY9Elc+HKmA+4XBD5hQAAkTkH3hWXQ7jcKV4dkWYi7chTEWAZ19fc3BxuHQamvlIvldObnURr/3Z6f7gnIxHR7JE3rwPuM+q1f/TPyYdwuwFFhfeMyyHPKU718oiSx24vRet0ZwCqJI1/ovRM0Nio7XtpZyJDbwDtdbcJewGYh9sQESXZrA0epQWLIDD20x6paAk8lRewpZpmjKkOsFJdqZfq89uJNiiGASMREcnVy03XoxBuZJxzJURGtvODiNKVtcpPb/0drX5UR1uxla9+FbNynKf+eoyM2H+9vn5iA2TshtrojMNtiIiSbNYGj1AUyPNPhXBnQMwJwFV4UqpXRJTWUh2kTfb5xzO8Jt3avydTug3/ISKaKsJfBDl/HuDJhGveqRAyO29olrBWQS5bhjevvBLlM3U6sz7YRa/4tA500VuhndgN6EnknPNH946VJHO7tSRNvJpyPOuxew2IaEaatcGjZ8U6eHILU70MIkoT0aoXnTi1f8/GEG48rx8R0UznWlSDjCX8u5BmMUMVpBIKYaC1NbXrmSx6NaOqhid449lngXvuAR57TAviDh1yboUeT0Wi3TkB4IwzgLfeGrtffb0WOk524Ov0GrzwAsNHohlu1gaPsi8v1UsgojQynupFp/bv2RjCsfqTiCiSe1F1qpdARFNBr2bUg8VQSKs0vOkmx0E7JuOpSLQ7pywDeXnAwYOJP4eJcloPh9oQzXgzu8SGaAZTFAXNzc3YtGkTmpuboVgn1FFSWYfVxDO8Rm//Xrt2Lerq6sJVjbMxhBvP60dERESzXGMj0NCgtQk3NGh/Tkd2g130a/dYoePKlcCLLyZekWh3zlQOkZlu6yGiKTNrKx6J0t1srJpLpWQOr5mOE7gn23Qc/kNERETT2ExqzY022MXK6wUKC7XHTKQF2u6cqRwiM93WQ0RThsEjUZqajVVzqZTM4TWzMYRL9fAhIiIiSjMzqTV3/XotNNXbqmVZq3gUwjzoRZaB889PzvOzO+dUDZFJh/UQ0ZRhqzVRmmLr6tRKZmu7Uws2EREREY2aSa25+gTv978fmDdP+/VnP9P2eZRl7T7JDuLszjmelu1kmW7rIaIpw4pHojQ1G6vmUomt7URERERTKJ1acxsbtUrMnTu19a1fH9kObpjgHVZZaX5csqdL250zlabbeohoSjB4JEpTbF2dWmxtJyIiIppC6dKaO5G9KBnEEdEswP4+IqI4sLWdiIiIaAqlS2uu3V6UqqrdTkRErHgkIooHW9uJiIiIplg6VATOpL0oiYgmAYNHIqI4sLWdiIiIiCKk016UREQpwFZrIiIiIiIimt0aG4GGBmD+fO3Xxsb4Hrd+vbb35GRNpyYiSnMMHomIiIiIiGj20gfEPPMM0N6u/XreefGFj+myFyURUYqw1ZqIiIiIiIhmL7sBMbKs3R7PHpPpsBclEVGKsOKRiIiIiIiIZi8OiCEimjSseCQiR4qioKWlxTTJWZL48woiIiIimkE4IIaIaNIweCQiRy0tLWhubgYAtLe3AwAnOxMRERHRzLJ+PfDss1rYqLdZc0AMEVFSsHSJiBx1dXVF/TMRERERUdpLxwEx453CTUQ0xVjxSESOSkpKwpWO+p+JiIiIiGacdBoQo0/h1gfidHVpFZsvvKA9DyKiaYTBIxE5qqmpAQDTHo9ERERERJRCE53CTUQ0hRg8EpEjSZK4pyMRERER0XTCKdxElEa4xyMRERERERFRuqis1CocjTiFm4imKQaPREREREREROli/Xpt6rYePnIKNxFNYwweiYiIiIiIiNJFOk7hJqJZi3s8EhEREREREaWTdJrCTUSzGiseiYiIiIiIiIiIKOkYPBIREREREREREVHSTWmr9bZt2/D8889j165deP311xEMBnH55Zfj29/+tu39t27dimuvvdbxeBs3bkR1dfUkrZaIiIiIZhpejxIRERFNnSkNHv/4xz/ikUceQWZmJgKBAILBYFyPW7FiBVasWBFxe0lJSbKXSEREREQzGK9HiYiIiKbOlAaPn/zkJ/GZz3wGixcvxs6dO3HVVVfF9bgVK1bg5ptvnuTVEREREdFMx+tRIiIioqkzpcFjZWXlVJ6OiIiIiMiE16NEREREU2dKg8fx2rt3Lx544AGcOHECpaWlWLVqFfLz81O9LCIiIiKaJXg9SkRERJS4tAgen3jiCTzxxBPhP2dkZODmm2/GZz/72RSuioiIiIhmC16PEhERESVuWgeP+fn5+NKXvoTzzjsPpaWl6Ovrw9atW/H9738f3/ve9+Dz+fCxj31sXMcOhUJJXi3Z0V9nvt7JoSgKduzYga6uLpSUlKCqqgqSJE34uHyf0gffq/TA9yl9pON7lU5rnQl4PZr+0vH7fDbi+5Q++F6lB75P6SNd36t41ytUVVUTOfDKlStx9OjRuO//wAMPYOXKlRG3t7a24qqrrsLll1+Ob3/724ksAW1tbVi3bh1yc3Px0ksvJRS8hEIhtLa2JnQ+oumio6MDnZ2d4T8HAgGUlpamcEVERJQq1dXVkGU51ctICV6PEhEREU0Psa5JE654vPjiizEwMBD3/QsLCxM9RUwVFRWoqqpCU1MT9u3bh5NPPjnhY1RWVs7ai/WpFAqFsHPnTr7eSWIMHQFACIHq6uoJH5fvU/rge5Ue+D6lj3R8r/Q1z2a8HqVEpOP3+WzE9yl98L1KD3yf0ke6vlfxXpMmHDzeeeed41pQsuXl5QEATpw4Ma7Hy7KcVm9ouuPrnRyBQAAdHR2mPyfzdeX7lD74XqUHvk/pg+9VeuH1KI0HX+/0wPcpffC9Sg98n9LHTH2vpvUej05GRkbw+uuvQwiBQCCQ6uUQTZmamhoACO/xqP+ZiIiIphavR4mIiIhim9bBY0tLC6qrqyGECN82MjKC7373u2hvb8c555yDOXPmpG6BRFNMkiTU1dWlehlERESzBq9HiYiIiMZvSoPHpqYm/OEPfwAA9PT0AACam5txxx13AAAWL16M66+/Pnz/22+/HYBW5VVcXIz+/n5s27YN77zzDkpLS/H1r399KpdPRERERGmO16NEREREU2dKg8d3330XjzzySMRt7777LgBgxYoVpgu9j33sY3jppZfwyiuv4MiRI3C5XFiwYAFuuOEGfPrTn0Zubu5ULp+IiIiI0hyvR4mIiIimzpQGj+vWrcO6devivv/1119vuvAjIiIiIpoIXo8SERERTR0p1QsgIiIiIiIiIiKimYfBIxERERERERERESUdg0ciIiIiIiIiIiJKOgaPRERERERERERElHQMHomIiIiIiIiIiCjpGDwSERERERERERFR0jF4JCIiIiIiIiIioqRj8EhERERERERERERJx+CRiIiIiIiIiIiIko7BIxERERERERERESUdg0ciIiIiIiIiIiJKOgaPRERERERERERElHQMHomIiIiIiIiIiCjpGDwSERERERERERFR0jF4JCIiIiIiIiIioqRj8EhERERERERERERJx+CRiIiIiIiIiIiIko7BIxERERERERERESUdg0ciIiIiIiIiIiJKOgaPRERERERERERElHQMHomIiIiIiIiIiCjpGDwSERERERERERFR0jF4JCIiIiIiIiIioqRj8EhERERERERERERJx+CRiIiIiIiIiIiIko7BIxERERERERERESUdg0ciIiIiIiIiIiJKOleqFzDVVFUFAIRCoRSvZHbQX2e+3tMb36f0wfcqPfB9Sh/p+F7pa9WvaSj98Hp0aqXj9/lsxPcpffC9Sg98n9JHur5X8V6TCnWWXbUODQ1h586dqV4GERER0YRUVlbC4/Gkehk0DrweJSIiopki1jXprAseFUXByMgIJEmCECLVyyEiIiJKiKqqUBQFLpcLksRdc9IRr0eJiIgo3cV7TTrrgkciIiIiIiIiIiKafPwxORERERERERERESUdg0ciIiIiIiIiIiJKOgaPRERERERERERElHQMHomIiIiIiIiIiCjpGDwSERERERERERFR0jF4JCIiIiIiIiIioqRj8EhERERERERERERJx+CRiIiIiIiIiIiIks6V6gXQzLNt2zY8//zz2LVrF15//XUEg0Fcfvnl+Pa3v217/61bt+Laa691PN7GjRtRXV09Saud3RJ9rwBAURT85je/wcaNG7Fv3z5kZWVh5cqVuPXWW7Fo0aKpWzzhjjvuwCOPPGL7tZNPPhlPPfXUFK+IXn31Vdx7771obW3F8PAwysrKcN111+GSSy5J9dLI4IILLkB7e7vt16666ip84xvfmOIVEVGy8Xo0ffB6NP3xmnR64fVoephN16MMHinp/vjHP+KRRx5BZmYmAoEAgsFgXI9bsWIFVqxYEXF7SUlJspdIo8bzXv3rv/4rfv/736OsrAxXX301Dh8+jCeffBKNjY343e9+h7KysilYORlde+21yMnJMd2Wl5eXotXMXlu3bsVnPvMZuN1urF27Fn6/H08//TS++MUvor29HTfccEOql0gGfr8f1113XcTty5YtS8FqiCjZeD2aPng9OnPwmjT1eD2aXmbL9SiDR0q6T37yk/jMZz6DxYsXY+fOnbjqqqvietyKFStw8803T/LqyCjR9+rll1/G73//e9TX1+OXv/wlPB4PAODDH/4w/uEf/gFf+9rX8NBDD03F0snguuuuw/z581O9jFltZGQE69evhxACv/71r3H66acDAD7/+c/jYx/7GO6991588IMfZBXGNJKTk8P/5xDNYLweTR+8Hp05eE2aWrweTT+z5XqUezxS0lVWVqK8vByyLKd6KRRDou/Vww8/DAC45ZZbwhd5AHDWWWfh7LPPxrZt2/DOO+9MylqJprOXX34Z7777Li6++OLwRR4A+Hw+3HTTTRgZGcGf/vSnFK6QiGh24fVo+uD1KFFy8HqUpitWPNK0sXfvXjzwwAM4ceIESktLsWrVKuTn56d6WWSwdetWZGVloba2NuJrZ599Nl566SVs27YNJ598cgpWN3u9+OKLGBgYgMfjwSmnnIIVK1bwH1pT7JVXXgGgfR9YrV692nQfmh6GhobwyCOPoLu7Gzk5OaitrcWpp56a6mURUYrxenT64/Xo9MVr0tTi9Wj6mS3Xowweadp44okn8MQTT4T/nJGRgZtvvhmf/exnU7gq0h07dgwHDx5ERUWF7QWEXrK/d+/eqV0YRWw8vGjRIvzwhz/E0qVLU7Si2Uf/3C9cuDDia7m5ucjLy8O+ffumeFUUzcGDB3HHHXeYbjvnnHPw3e9+lyED0SzG69Hpjdej0xuvSVOL16PpZ7ZcjzJ4pJTLz8/Hl770JZx33nkoLS1FX18ftm7diu9///v43ve+B5/Ph4997GOpXuas19/fD0Ar1bej3x7v5u00cWeccQYuuOACLF++HHl5edi/fz82btyIhx56CJ/+9Kfx2GOPobi4ONXLnBX0z73f77f9us/nQ1dX11QuiaJYt24dVqxYgbKyMng8Hrz11lv4yU9+gr/85S+46aab8Nvf/hZCiFQvk4imEK9H0wOvR6cnXpNOD7weTS+z6XqUwSPZWrlyJY4ePRr3/R944AGsXLlyXOcqLy9HeXl5+M+ZmZm49NJLceqpp2LdunW49957ceWVV0KSuCWpnal8ryj5JvL+feQjHzF9bcmSJfjKV76CzMxM3H///fjVr36Ff/mXf0nmcolmhH/8x380/bmqqgr/8R//gauvvhrNzc148cUXcd5556VmcUQUxuvR9MHr0fTHa1KiqTWbrkcZPJKtiy++GAMDA3Hfv7CwMOlrqKioQFVVFZqamrBv3z7u0+Jgqt4r/SdnTj9B1m93+gk02ZuM9++jH/0o7r//frS0tExkaZQA/XOvV2JYBYNBx58+0/QgSRLWrVuH5uZmbN++fcZc6BGlM16Ppg9ej6Y/XpOmP16Ppr+Zej3K4JFs3XnnnaleAgAgLy8PAHDixIkUr2T6mqr3KisrC0VFRdi/fz9CoVDEvjr6niL63joUn8l4//Tvm+PHjyf92GRP/9zv27cPy5YtM32tt7cXR44cQU1NTQpWRong9w7R9MLr0fTB69H0x2vS9Mfr0ZlhJn7fsFeApq2RkRG8/vrrEEIgEAikejkEYMWKFTh27Bi2b98e8bW//vWvALQ9Xii1duzYAQCYN29eilcye+ife/37wKixsRGA9v1D09urr74KgN87RDSG16PTD69H0wevSacWr0dnhpl4PcrgkVKupaUFqqqabhsZGcF3v/tdtLe34+yzz8acOXNSszgyufLKKwEAP/7xjzE0NBS+/W9/+xv++te/4owzzmAL0hQ5ePAg3n333Yjbu7u7sWHDBgBaywxNjbPOOgsnnXQSnnjiCbzxxhvh24PBIH72s5/B5XLh8ssvT+EKSbdnzx709fVF3N7U1IRf/vKX8Hg8+MAHPpCClRFRKvF6NH3wenR64TXp9MHr0fQx265HhWr9PyzRBDU1NeEPf/gDAKCnpwcvvvgiFixYgLq6OgDA4sWLcf3114fvf8EFFwAAampqUFxcjP7+fmzbtg3vvPMOSktL8dBDD82otH86SfS9AoD169fj4YcfRllZGdasWYPDhw/jySefhNfrxe9+9zuUlZVN+fOYjbZu3YrrrrsOdXV1WLx4MXJzc9He3o4XXngBx44dw+WXX45vfetbM2YSWjp4+eWX8dnPfhZutxsXX3wxfD4fnn76aezfvx+33HILbrzxxlQvkQDce++9+PnPf46zzjoL8+bNg8fjQVtbGxobGyFJEr7+9a/jiiuuSPUyiWiCeD2aPng9mt54TTq98Ho0Pcy261EGj5R0f/rTn/DlL3/Z8esrVqzAgw8+GP7zf/7nf+Kll17C3r17ceTIEbhcLixYsADnn38+Pv3pTyM3N3cqlj0rJfpeAYCiKPj1r3+NjRs3Yt++fcjKysLKlStx66238qfLU6izsxM//elP8eqrr6KrqwsDAwPw+XxYunQpPvrRj+JDH/pQqpc4K7366qu455570NraiuHhYZSVleG6667DpZdemuql0ahXXnkFv/nNb/D666/j0KFDGBoaQkFBAerq6vCpT30Ky5cvT/USiSgJeD2aPng9mt54TTr98Hp0+ptt16MMHomIiIiIiIiIiCjpuMcjERERERERERERJR2DRyIiIiIiIiIiIko6Bo9ERERERERERESUdAweiYiIiIiIiIiIKOkYPBIREREREREREVHSMXgkIiIiIiIiIiKipGPwSEREREREREREREnH4JGIiIiIiIiIiIiSjsEjERERERERERERJR2DRyIiIiIiIiIiIko6Bo9ERERERERERESUdAweiYiIiIiIiIiIKOkYPBIREREREREREVHS/X/AlqyQGZ+pVQAAAABJRU5ErkJggg==\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"def plot_contour(X, y, Z):\n",
" plt.scatter(X[y == -1, 0], X[y == -1, 1], color='0.6', s=5)\n",
" plt.scatter(X[y == 0, 0], X[y == 0, 1], color='c', s=15)\n",
" plt.scatter(X[y == 1, 0], X[y == 1, 1], color='m', s=15)\n",
" plt.scatter(X[y == 2, 0], X[y == 2, 1], color='r', s=15)\n",
" plt.contour(xx, yy, Z)\n",
" plt.xlim(x_min, x_max)\n",
" plt.ylim(y_min, y_max)\n",
" plt.xticks(fontsize=14)\n",
" plt.yticks(fontsize=14)\n",
"\n",
"x_min, x_max = X[:,0].min()-2, X[:,0].max()+2\n",
"y_min, y_max = X[:,1].min()-2, X[:,1].max()+2\n",
"xx, yy = numpy.meshgrid(numpy.arange(x_min, x_max, 0.1), numpy.arange(y_min, y_max, 0.1))\n",
"Z1 = model_a.predict(numpy.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n",
"Z2 = model_b.predict(numpy.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n",
"\n",
"plt.figure(figsize=(16, 16))\n",
"plt.subplot(221)\n",
"plt.title(\"Training Data, Supervised Boundaries\", fontsize=16)\n",
"plot_contour(X_train, y_train, Z1)\n",
"\n",
"plt.subplot(223)\n",
"plt.title(\"Training Data, Semi-supervised Boundaries\", fontsize=16)\n",
"plot_contour(X_train, y_train, Z2)\n",
"\n",
"plt.subplot(222)\n",
"plt.title(\"Test Data, Supervised Boundaries\", fontsize=16)\n",
"plot_contour(X_test, y_test, Z1)\n",
"\n",
"plt.subplot(224)\n",
"plt.title(\"Test Data, Semi-supervised Boundaries\", fontsize=16)\n",
"plot_contour(X_test, y_test, Z2)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "acae86bb",
"metadata": {},
"source": [
"The contours plot the decision boundaries between the different classes with the left figures corresponding to the partially labeled training set and the right figures corresponding to the test set. We can see that the boundaries learning using only the labeled data look a bit weird when considering the unlabeled data, particularly in that it doesn't cleanly separate the cyan cluster from the other two. In addition, it seems like the boundary between the magenta and red clusters is a bit curved in an unrealistic way. We would not expect points that fell around (-18, -7) to actually come from the red class. Training the model in a semi-supervised manner cleaned up both of these concerns by learning better boundaries that are also flatter and more generalizable.\n",
"\n",
"Let's next compare the training times to see how much slower it is to do semi-supervised learning than it is to do simple supervised learning."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "94b6c11c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Supervised Learning\n",
"3.13 ms ± 304 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
"\n",
"Semi-supervised Learning\n",
"444 ms ± 59.3 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
"\n",
"Label Propagation (sklearn): \n",
"1min ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/jmschr/anaconda3/lib/python3.9/site-packages/sklearn/semi_supervised/_label_propagation.py:316: ConvergenceWarning: max_iter=1000 was reached without convergence.\n",
" warnings.warn(\n"
]
}
],
"source": [
"from sklearn.semi_supervised import LabelPropagation\n",
"\n",
"print(\"Supervised Learning\")\n",
"%timeit BayesClassifier([Normal(), Normal(), Normal()]).fit(X_train[idx], y_train[idx])\n",
"print()\n",
"\n",
"print(\"Semi-supervised Learning\")\n",
"%timeit GeneralMixtureModel([Normal(), Normal(), Normal()]).fit(X_train, priors=priors)\n",
"print()\n",
"\n",
"print(\"Label Propagation (sklearn): \")\n",
"%timeit -n 1 -r 1 LabelPropagation().fit(X_train, y_train) # Setting to 1 loop because it takes a long time"
]
},
{
"cell_type": "markdown",
"id": "a70a0a60",
"metadata": {},
"source": [
"It is quite a bit slower to do semi-supervised learning than simple supervised learning in this example. This is expected as the simple supervised update for Bayes classifier is a trivial MLE across each distribution whereas the semi-supervised case requires an iterative algorithm, EM, to converge. However, doing semi-supervised learning with EM is still much faster than fitting the label propagation estimator from sklearn.\n",
"\n",
"### More Complicated Setting\n",
"\n",
"Although the previous setting demonstrated our point, it was still fairly simple. We can construct a more complex situation where there are complex Gaussian distributions and each component is a mixture of distributions rather than a single one. This will highlight both the power of semi-supervised learning, as well as pomegranate's ability to stack models -- in this case, stack a mixture within a mixture.\n",
"\n",
"First let's generate some more complicated, noisier data."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "3f1e0e8b",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"X = numpy.empty(shape=(0, 2))\n",
"X = numpy.concatenate((X, numpy.random.normal(4, 1, size=(3000, 2)).dot([[-2, 0.5], [2, 0.5]])))\n",
"X = numpy.concatenate((X, numpy.random.normal(3, 1, size=(6500, 2)).dot([[-1, 2], [1, 0.8]])))\n",
"X = numpy.concatenate((X, numpy.random.normal(7, 1, size=(8000, 2)).dot([[-0.75, 0.8], [0.9, 1.5]])))\n",
"X = numpy.concatenate((X, numpy.random.normal(6, 1, size=(2200, 2)).dot([[-1.5, 1.2], [0.6, 1.2]])))\n",
"X = numpy.concatenate((X, numpy.random.normal(8, 1, size=(3500, 2)).dot([[-0.2, 0.8], [0.7, 0.8]])))\n",
"X = numpy.concatenate((X, numpy.random.normal(9, 1, size=(6500, 2)).dot([[-0.0, 0.8], [0.5, 1.2]])))\n",
"X = X.astype('float32')\n",
"\n",
"x_min, x_max = X[:,0].min()-2, X[:,0].max()+2\n",
"y_min, y_max = X[:,1].min()-2, X[:,1].max()+2\n",
"\n",
"y = numpy.concatenate((numpy.zeros(9500), numpy.ones(10200), numpy.ones(10000)*2)).astype('int32')\n",
"idxs = numpy.arange(29700)\n",
"numpy.random.shuffle(idxs)\n",
"\n",
"X = X[idxs]\n",
"y = y[idxs]\n",
"\n",
"X_train, X_test = X[:25000], X[25000:]\n",
"y_train, y_test = y[:25000], y[25000:]\n",
"y_train[numpy.random.choice(25000, size=24920, replace=False)] = -1\n",
"\n",
"plt.figure(figsize=(6, 6))\n",
"plt.scatter(X_train[y_train == -1, 0], X_train[y_train == -1, 1], color='0.6', s=1)\n",
"plt.scatter(X_train[y_train == 0, 0], X_train[y_train == 0, 1], color='c', s=10)\n",
"plt.scatter(X_train[y_train == 1, 0], X_train[y_train == 1, 1], color='m', s=10)\n",
"plt.scatter(X_train[y_train == 2, 0], X_train[y_train == 2, 1], color='r', s=10)\n",
"plt.axis('off')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "123b10ef",
"metadata": {},
"source": [
"Now let's take a look at the accuracies that we get when training a model using just the labeled examples versus all of the examples in a semi-supervised manner."
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "06b70094",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Supervised Learning Accuracy: 0.935531914893617\n",
"Semisupervised Learning Accuracy: 0.9846808510638297\n"
]
}
],
"source": [
"d1 = GeneralMixtureModel([Normal(), Normal()])\n",
"d2 = GeneralMixtureModel([Normal(), Normal()])\n",
"d3 = GeneralMixtureModel([Normal(), Normal()])\n",
"\n",
"model_a = BayesClassifier([d1, d2, d3])\n",
"model_a.fit(X_train[y_train != -1], y_train[y_train != -1])\n",
"\n",
"y_hat_a = model_a.predict(X_test).numpy() \n",
"print(\"Supervised Learning Accuracy: {}\".format((y_hat_a == y_test).mean()))\n",
"\n",
"priors = torch.zeros(len(X_train), 3)\n",
"for i, y in enumerate(y_train):\n",
" if y != -1:\n",
" priors[i, y] = 1.0\n",
" else:\n",
" priors[i] = 1./3\n",
"\n",
"d1 = GeneralMixtureModel([Normal(), Normal()]).fit(X_train[y_train == 0])\n",
"d2 = GeneralMixtureModel([Normal(), Normal()]).fit(X_train[y_train == 1])\n",
"d3 = GeneralMixtureModel([Normal(), Normal()]).fit(X_train[y_train == 2])\n",
"\n",
"model_b = GeneralMixtureModel([d1, d2, d3])\n",
"model_b.fit(X_train, priors=priors)\n",
"\n",
"y_hat_b = model_b.predict(X_test).numpy() \n",
"print(\"Semisupervised Learning Accuracy: {}\".format((y_hat_b == y_test).mean()))"
]
},
{
"cell_type": "markdown",
"id": "b8c1753a",
"metadata": {},
"source": [
"As expected, the semi-supervised method performs better. Let's visualize the landscape in the same manner as before in order to see why this is the case."
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "97d73cbe",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"xx, yy = numpy.meshgrid(numpy.arange(x_min, x_max, 0.1), numpy.arange(y_min, y_max, 0.1))\n",
"Z1 = model_a.predict(numpy.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n",
"Z2 = model_b.predict(numpy.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n",
"\n",
"plt.figure(figsize=(16, 16))\n",
"plt.subplot(221)\n",
"plt.title(\"Training Data, Supervised Boundaries\", fontsize=16)\n",
"plot_contour(X_train, y_train, Z1)\n",
"\n",
"plt.subplot(223)\n",
"plt.title(\"Training Data, Semi-supervised Boundaries\", fontsize=16)\n",
"plot_contour(X_train, y_train, Z2)\n",
"\n",
"plt.subplot(222)\n",
"plt.title(\"Test Data, Supervised Boundaries\", fontsize=16)\n",
"plot_contour(X_test, y_test, Z1)\n",
"\n",
"plt.subplot(224)\n",
"plt.title(\"Test Data, Semi-supervised Boundaries\", fontsize=16)\n",
"plot_contour(X_test, y_test, Z2)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "46ed6f4c",
"metadata": {},
"source": [
"Immediately, one would notice that the decision boundaries when using semi-supervised learning are smoother than those when using only a few samples. This can be explained mostly because having more data can generally lead to smoother decision boundaries as the model does not overfit to spurious examples in the dataset. It appears that the majority of the correctly classified samples come from having a more accurate decision boundary for the magenta samples in the left cluster. When using only the labeled samples many of the magenta samples in this region get classified incorrectly as cyan samples. In contrast, when using all of the data these points are all classified correctly."
]
},
{
"cell_type": "markdown",
"id": "bda7ac0a",
"metadata": {},
"source": [
"### HMMs\n",
"\n",
"Hidden Markov models can take in priors just as easily as mixture models can. Just as the data must be 3D, the priors also must be 3D."
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "d6444d54",
"metadata": {},
"outputs": [],
"source": [
"from pomegranate.hmm import DenseHMM\n",
"\n",
"d1 = Normal([1.0], [1.0], covariance_type='diag')\n",
"d2 = Normal([3.0], [1.0], covariance_type='diag')\n",
"\n",
"model = DenseHMM([d1, d2], [[0.7, 0.3], [0.3, 0.7]], starts=[0.4, 0.6])"
]
},
{
"cell_type": "markdown",
"id": "9a958026",
"metadata": {},
"source": [
"We can first look at what a forward pass would look like without priors."
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "ed345ec2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[[0.9398, 0.0602],\n",
" [0.9271, 0.0729],\n",
" [0.6459, 0.3541],\n",
" [0.9699, 0.0301],\n",
" [0.9812, 0.0188],\n",
" [0.9953, 0.0047],\n",
" [0.9987, 0.0013],\n",
" [0.9738, 0.0262],\n",
" [0.9782, 0.0218],\n",
" [0.9924, 0.0076]]])"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = torch.randn(1, 10, 1)\n",
"\n",
"model.predict_proba(X)"
]
},
{
"cell_type": "markdown",
"id": "fb4fdf4d",
"metadata": {},
"source": [
"Now let's add in that one observation must map to one specific state."
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "9e82defb",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[[0.5000, 0.5000],\n",
" [0.5000, 0.5000],\n",
" [0.5000, 0.5000],\n",
" [0.5000, 0.5000],\n",
" [0.5000, 0.5000],\n",
" [0.0000, 1.0000],\n",
" [0.5000, 0.5000],\n",
" [0.5000, 0.5000],\n",
" [0.5000, 0.5000],\n",
" [0.5000, 0.5000]]])"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"priors = torch.ones(1, 10, 2) / 2\n",
"priors[0, 5, 0], priors[0, 5, 1] = 0, 1\n",
"priors"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "8de4146b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[[0.9398, 0.0602],\n",
" [0.9267, 0.0733],\n",
" [0.6427, 0.3573],\n",
" [0.9620, 0.0380],\n",
" [0.9070, 0.0930],\n",
" [0.0000, 1.0000],\n",
" [0.9930, 0.0070],\n",
" [0.9732, 0.0268],\n",
" [0.9782, 0.0218],\n",
" [0.9924, 0.0076]]])"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.predict_proba(X, priors=priors)"
]
},
{
"cell_type": "markdown",
"id": "e542f0d4",
"metadata": {},
"source": [
"We can see that the model is forced to assign the 6th observation to distribution 1 even though it is trying to assign all of the observations to distribution 0.\n",
"\n",
"Using prior probabilities like this gives us a way to do semi-supervised learning on HMMs in a very flexible manner. If you have entire labeled sequences, you can pass in prior probabilities of 1.0 for each observation in the sequence, even if other sequences have no labels at all. If you have partially labeled sequences, you can easily train your model using priors on some, but not all, observations, and using those partial observations to inform everything else."
]
},
{
"cell_type": "markdown",
"id": "74708bba",
"metadata": {},
"source": [
"### Summary\n",
"\n",
"In the real world (ack) there are frequently situations where only a small fraction of the available data has useful labels. Semi-supervised learning provides a framework for leveraging both the labeled and unlabeled aspects of a dataset to learn a sophisticated estimator. In this case, semi-supervised learning plays well with probabilistic models as normal maximum likelihood estimates can be done on the labeled data and expectation-maximization can be run on the unlabeled data using the same distributions.\n",
"\n",
"This notebook has covered how to implement semi-supervised learning in pomegranate using mixture models and hidden Markov models. All one has to do is set the priors of observations consistently with the labels and pomegranate will take care of the rest. This can be particularly useful when encountering complex, noisy, data in the real world that aren't neat Gaussian blobs."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/docs/whats_new.rst 0000664 0000000 0000000 00000073071 14643672530 0022024 0 ustar 00root root 0000000 0000000 .. currentmodule:: pomegranate
===============
Release History
===============
Version 1.0.4
==============
Highlights
----------
- Added a feature-complete implementation of `.viterbi` to `DenseHMM` and
`SparseHMM`. Unfortunately, due to the lack of an efficient `scatter_argmax`
implementation in torch, the `SparseHMM` function is quite a bit slower than
it could be. Hopefully this will be fixed in the future.
- Fixed a bug where `max_iter` and `tol` were not being passed into the
underlying `FactorGraph` when creating a `BayesianNetwork`.
- Changed `BayesianNetwork.sample` to run `self.d+1` times to cover an edge
case that might arise.
- Fixed `.name` attribute of `StudentT` distribution
- Sampling with HMMs without fixed end probabilities should be fixed
- Incorporated link fix from @reachusama for Bayesian networks
Version 1.0.4
==============
Highlights
----------
- Fixed an issue with Markov Chains and ConditionalCategorical distributions
- Added more documentation to ConditionalCategorical distributions
Version 1.0.3
==============
Highlights
----------
- A fix to the 1.0.2 fix (thanks @savyajha)
- Docs API fix (thanks @FBruzzesi)
- GMM initialization sets prior based on weights (thanks @gerwang)
- Fixes normal distributions when covariance_type == 'sphere' (thanks @gerwang)
- Fixes an issue with MaskedTensor's being passed into categorical distributions
Version 1.0.2
==============
Highlights
----------
- A minor issue with Bayesian network structure learning has been patched by
@savyajha (thank you!) where, when multiple shortest paths exist, the one
returned would be OS dependent. Now, all shortest paths are found and sorted
before return.
Version 1.0.0
==============
Highlights
----------
- Minor bug fixed.
Version 1.0.0
==============
Highlights
----------
- This release marks a major milestone in the pomegranate saga.
- The Cython backend has been replaced with a PyTorch backend. Goodbye weird installation issues and segfaults.
- The API has been changed in a way that is not back-compatible, hence an increment in the major version. These changes fix issues that have hampered development, made the user experience more difficult, or were just bad.
- This codebase is guarded by a comprehensive suite of >800 unit tests, calling assert statements several thousand times.
Features
--------
- GPU support has been added for all models and methods
- Mixed/half precision has been added for all models and methods (though the benefits seem mild to none...)
- Serialization is now handled by PyTorch, yielding more compact and efficient I/O
- Missing values are now supported through torch.masked.MaskedTensor objects
- Prior probabilities are now supported for all relevant models and methods and enable more comprehensive/flexible semi-supervised learning than before
Models
------
- All distributions are now multivariate by default, supporting speedups through batched operations
- Factor graphs are now supported as first-class citizens
- Hidden Markov models have been split into DenseHMM and SparseHMM models which differ in how the transition matrix is encoded, with DenseHMM objects being significantly faster
- NaiveBayes models have been removed
- MarkovNetworks models have been temporarily removed
- Constraint graphs have been temporarily removed
Version 0.14.8
==============
Highlights
----------
- Fix an issue with saving and loading BayesModels
Version 0.14.6
==============
Highlights
----------
- Adds ICD support for features having both discrete and continuous distributions. Thanks @lmcinnes!
Version 0.14.6
==============
Highlights
----------
- Determinism added to k-means initializations through a `random_state` parameter
- Determinism added to `HiddenMarkovModel.from_samples` by passing its `random_state` parameter to k-means
- Fixed an issue where the JSON of an HMM would be updated after a call to `fit` but not a call to `from_summaries`
- Fixed an issue where independent component distributions would not be created correctly for HMM states when also passing in labels
- Separated out the initialization of distributions in `HiddenMarkovModel.from_samples` and the extraction or labeling of unlabeled examples
- Updated the NetworkX requirement to be at least 2.4.
- Force GMM models to respect its `frozen` attribute in the `from_summaries` method.
Version 0.14.0
==============
Highlights
----------
- A variety of minor bug fixes and enhancements
- Installations should be cleaner due to a transition from TravisCI/appveyor to GitHub actions.
BayesModels
-----------
- These models should now be able to fit to IndependentComponentDistributions.
Version 0.13.1
==============
Highlights
----------
- A variety of minor bug fixes and speed improvements
- Bayesian networks now support sampling using a Gibbs sampler or rejection sampling. Thanks @pascal-schetelat
- HMMs now have the option to disable rechecking the inputs at each iteration, which can dramatically speed up training for small models.
General
-------
- pomegranate will now use `numpy.asarray` instead of `numpy.array` to avoid re-copying arrays.
BayesianNetwork
---------------
- An error will now appropriately be raised when passing in constraints and selecting the Chow-Liu algorithm.
- Bayesian networks will now use 32-bit floats instead of 64-bit floats internally, leading to lower memory models. Thanks @alexhenrie
Version 0.13.0
==============
Highlights
----------
- A variety of minor bug fixes and speed improvements
- You can now pass in key sets to each model to define distributions over, even if that symbol doesn't occur in the training set
- The returns from `from_sample` uses class distributions instead of predefined ones, allowing for inheritance of distributions
- Checks added to ensure that input arrays are C ordered instead of transposed
Distributions
-------------
- JSON dtypes are checked to be numpy types instead of assumed to be
- __eq__ and __mul__ sped up for DiscreteDistributions
BayesianNetwork
---------------
- Fixed bug with constraint graphs when a node has both self loop and parent constraints
MarkovChains
------------
- Fixed an issue with sampling length.
Version 0.12.1
==============
Highlights
----------
- A variety of minor bug fixes.
Version 0.12.0
==============
Highlights
----------
- MarkovNetwork models have been added in and include both inference and structure learning.
- Support for Python 2 has been deprecated.
- Markov network, data generator, and callback tutorials have been added in
- A robust `from_json` method has been added in to __init__.py that can deserialize JSONs from any pomegranate model.
MarkovNetwork
-------------
- MarkovNetwork models have been added in as a new probabilistic model.
- Loopy belief propagation inference has been added in using the FactorGraph backend
- Structure learning has been added in using Chow-Liu trees
BayesianNetwork
---------------
- Chow-Liu tree building has been sped up slightly, courtesy of @alexhenrie
- Chow-Liu tree building was further sped up by almost an order of magnitude
- Constraint Graphs no longer fail when passing in graphs with self loops, courtesy of @alexhenrie
BayesClassifier
---------------
- Updated the `from_samples` method to accept BayesianNetwork as an emission. This will build one Bayesian network for each class and use them as the emissions.
Distributions
-------------
- Added a warning to DiscreteDistribution when the user passes in an empty dictionary.
- Fixed the sampling procedure for JointProbabilityTables.
- GammaDistributions should have their shape issue resolved
- The documentation for BetaDistributions has been updated to specify that it is a Beta-Bernoulli distribution.
io
---
- New file added, io.py, that contains data generators that can be operated on
- Added DataGenerator, DataFrameGenerator, and a BaseGenerator class to inherit from
HiddenMarkovModel
-----------------
- Added RandomState parameter to `from_samples` to account for randomness when building discrete models.
Misc
----
- Unnecessary calls to memset have been removed, courtesy of @alexhenrie
- Checking for missing values has been slightly refactored to be cleaner, courtesy of @mareksmid-lucid
- Include the LICENSE file in MANIFEST.in and simplify a bit, courtesy of @toddrme2178
- Added in a robust from_json method that can be used to deserialize a JSON for any pomegranate model.
docs
----
- Added io.rst to briefly describe data generators
- Added MarkovNetwork.rst to describe Markov networks
- Added links to tutorials that did not have tutorials linked to them.
Tutorials
---------
- Added in a tutorial notebook for Markov networks
- Added in a tutorial notebook for data generators
- Added in a tutorial notebook for callbacks
CI
--
- Removed unit tests for Py2.7 from AppVeyor and Travis
- Added unit tests for Py3.8 to AppVeyor and Travis
Version 0.11.2
==============
Highlights
----------
- Faster BSNL, particularly when there is missing data, courtesy of @alexhenrie
- GPU acceleration should be fixed
BayesianNetwork
---------------
- A speed improvement by making `isnan` an inline function, courtesy of @alexhenrie
- A speed improvement by changing the manner that parent sets are iterated, courtesy of @alexhenrie
Utils
-----
- The `enable_gpu` call has been moved to the bottom of the GPU checking code and so should not crash anymore.
Version 0.11.1
==============
Highlights
----------
- Added speed improvements to Bayesian network structure learning when missing data is present.
BayesianNetwork
---------------
- By default duplicates get merged in a data set so that there are fewer rows with larger weights, dramatically improving speed. However, because `np.nan != np.nan`, rows with missing values don't get merged. This fix changes `np.nan` to `None` so that the rows get merged appropriately.
- A few misc changes that sometimes improve speed.
- Changed the probability calculation when a node is being scored given a single row. Previously it would return 0, meaning that sometimes it will return the densest graph possible erroneously. This may change your networks in edge cases, but will reduce their complexity.
Version 0.11.0
==============
Highlights
----------
- Allowed for user specified custom distributions by implementing a Python fallback option if the distribution object doesn't inherit from the base distribution class.
- Fixed an issue with GammaDistribution update
- Removed deterministic seed being set in hmm.bake
- Made pomegranate compatible with NetworkX v2.0 and above
- NeuralHMMs and Neural Mixture Models are now possible through the custom distributions
- Many new tutorials
Distributions
-------------
- Fixed an error in GammaDistribution's cython level update step where sufficient statistics were incorrectly collected from a data set. This will only affect GammaDistributions that are used as part of a composition model rather than stand-alone ones.
- Added in support for custom distributions. This is done by checking whether a distribution is inherited from the base pomegranate distribution object. If not, it will use the python methods.
- Added in examples of using custom distributions, including neural networks, with pomegranate models.
- Made NormalDistribution.blank and LogNormalDistribution.blank return distributions with a standard deviation of 1, to avoid DivisionByZero errors.
- Added in a NeuralNetworkWrapper distribution that should handle wrapping a neural network correctly for use in pomegranate. This assumes a keras-like API.
HiddenMarkovModel
-----------------
- Removed a deterministic seed being set in hmm.bake. These lines were set because it was thought that there was some randomness in either the internal state generation of the topological sort. However, it appears that this is not necessary, and so it has been removed.
- Fixed a bug where semi-supervised learning would not work because of an undefined variable.
- Added in support for networkx v2.0 and above using their new API.
Tutorials
---------
- Revamped the tutorials in the tutorials folder, greatly expanding their scope
- Added in new tutorials about custom distributions and neural probabilistic models
Version 0.10.0
==============
Highlights
----------
- Broke distributions into their own files and placed them in their own folder
- Fixed Bayesian network failing in call to np.isnan when fitting to character data
- Added in callbacks to all models in the style of keras, with built-ins being History, ModelCheckpoint, and CVLogger. History is calculated for each model. Use `return_history=True` to gt the model and the history object that contains training.
- Added top-level Makefile for convenience in development to build/test/clean/install/uninstall with multiple conda environments.
- Added top-level rebuildconda for convenience in development to create or re-create a conda development environment for a given python version, defaulting to 2.7.
Changelog
---------
Callbacks
---------
- Added in a callbacks module, and the use of callbacks in all iterative training procedures. Callbacks are called at the beginning of training, at the end of each epoch, and at the end of the training procedure, using the respective functions. See the documentation page for more details.
Distributions
-------------
- Broke the distributions.pyx into a folder where each distribution has its own file. This will speed up compilation when the code is modified.
- Added in a `dtype` attribute to DiscreteDistribution, ConditionalProbabilityTable, and JointProbabilityTable, to prevent automatic casting of keys as floats when converting to and from jsons
- For MultivariateGaussianDistributions, added in an epsilon when performing a ridge adjustment on a non-positive semidefinite matrix to hopefully completely fix this issue.
- NormalDistribution update should now check to see if the weights are below an epsilon, rather than equal to 0, resolving some stability issues.
- Fixed an issue with BernoulliDistribution where it would raise a ZeroDivisionError when `from_summaries` was called with no observations.
- Fixed an issue where an IndependentComponentsDistribution would print upon calls to `log_probability`
HiddenMarkovModel
-----------------
- Changed the output to be the fit model, like in scikit-learn, instead of the total improvement, to allow for chaining
- Added in callback functionality to both the `fit` and `from_samples` methods
- Added in the `return_history` parameter to both the `fit` and `from_samples` methods, which will return the history callback as well as the fit model
- Resolved an issue in the `summary` method where default weights were assigned to the wrong variable when not passed in.
- Resolved an issue where printing an empty model resulted in an error.
GeneralMixtureModel
-------------------
- Changed the output to be the fit model, like in scikit-learn, instead of the total improvement, to allow for chaining
- Added in callback functionality to both the `fit` and `from_samples` methods
- Added in the `return_history` parameter to both the `fit` and `from_samples` methods, which will return the history callback as well as the fit model
NaiveBayes
----------
- Added in callback functionality to both the `fit` and `from_samples` methods that will be used only in semi-supervised learning
- Added in the `return_history` parameter to both the `fit` and `from_samples` methods, which will return the history callback as well as the fit model that will be used only in semi-supervised learning
BayesClassifier
---------------
- Added in callback functionality to both the `fit` and `from_samples` methods that will be used only in semi-supervised learning
- Added in the `return_history` parameter to both the `fit` and `from_samples` methods, which will return the history callback as well as the fit model that will be used only in semi-supervised learning
BayesianNetwork
---------------
- Modified the built keymap to be a numpy array of objects to prevent casting of all keys as the type of the first column.
Makefile
---------------
- There is a new top-level "convenience" Makefile for development to make it easy to develop with two conda environments. The default is for two conda environments, py2.7 and py3.6, but those could be overridden at run time with, for example, `make PY3_ENV=py3.6.2 biginstall`. Targets exist for `install, test, bigclean, and nbtest` along with variations of each that first activate either one or both conda environments. For example, `make biginstall` will install for both `py2.7` and `py3.6` environments. When developing pomegranate, one frequently wants to do a fully clean build, wipe out all installed targets, and replace them. This can be done with `make bigclean biguninstall biginstall`. In addition, there is a target `nbtest` for testing all of the jupyter notebooks to ensure that the cells run. See the Makefile for a list of additional conda packages to install for this to work. The default is to stop on first error but you can run `make ALLOW_ERRORS=--allow-errors nbtest` to run all cells and then inspect the html output manually for errors.
- There is a new top-level "convenience" rebuildconda script which will remove and create a conda environment for development. Be careful using it that the environment you want to rebuild is the right one. You can list environments with `conda info --envs`. The default is to rebuild the `2.7` environment with name `py2.7`. With this, you can create an alternative environment, test it out, and remove it as in `./rebuildconda 2.7.9 ; make PY2_ENV=py2.7.9 bigclean py2build py2test py2install nbtest ; source deactivate ; conda env remove --name py2.7.9`.
Version 0.9.0
=============
Highlights
----------
- Missing value support has been added in for all models except factor graphs. This is done by included the string `nan` in string datasets, or `numpy.nan` in numeric datasets. Model fitting and inference is supported for all models for this. The technique is to not collect sufficient statistics from missing data, not to impute the missing values.
- The unit testing suite has been greatly expanded, from around 140 tests to around 370 tests.
Changelog
---------
HiddenMarkovModel
-----------------
- The documentation has been fixed so that states are defined as `State(NormalDistribution(0, 1))` instead of incorrectly as `State(Distribution(NormalDistribution(0, 1)))`
- Fixed a bug in `from_samples` that was causing a TypeError if `name` was not specified when using `DiscreteDistribution` with custom labels.
- Expanded the number of unit tests to include missing value support and be more comprehensive
Distributions
-------------
- Multivariate Gaussian distributions have had their parameter updates simplified. This doesn't lead to a significant change in speed, just less code.
- Fixed an issue where Poisson Distributions had an overflow issue caused when calculating large factorials by moving the log inside the product.
- Fixed an issue where Poisson Distributions were not correctly calculating the probability of 0 counts.
- Fixed an issue where Exponential Distribution would fail when fed integer 0-mode data.
- Fixed an issue where IndependentComponentDistribution would have incorrect per-dimension weights after serialization.
- Added in missing value support for fitting and log probability calculations for all univariate distributions, ICD, MGD, and CPTs through calculating sufficient statistics only on data that exists. The only distributions that currently do not support missing values are JointProbabilityTables and DirichletDistributions.
- Fixed an issue with multivariate Gaussian distributions where the covariance matrix is no longer invertible with enough missing data by subtracting the smallest eigenvalue from the diagonal
K-Means
-------
- Added in missing value support for k-means clustering by ignoring dimensions that are missing in the data. Can now fit and predict on missing data.
- Added in missing value support for all initialization strategies
- Added in a suite of unit tests
- Added in the `distance` method that returns the distance between each point and each centroid
GeneralMixtureModel
-------------------
- Added in missing value support for mixture models through updates to the distributions
- Fixed an issue where passing in a list of distributions to `from_samples` along with a number of components did not produce a mixture of IndependentComponentsDistribution objects
- Expanded the unit test suite and added tests for missing value support
BayesianNetwork
---------------
- Vectorized the `predict_proba` method to take either a single sample or a list of samples
- Changed the output of `predict_proba` to be individual symbols instead of a distribution where one symbol has a probability of 1 when fed in as known prior knowledge.
- Added in an n_jobs parameter to parallelize the prediction of samples. This does not speed up a single sample, only a batch of samples.
- Factored out `_check_input` into a function that be used independently
- Added unit tests to check each of the above functions extensively
- Missing value support added for the `log_probability`, `fit`, and `from_samples` methods. Chow-Liu trees are not supported for missing values, but using a constraint graph still works.
Version 0.8.1
=============
Highlights
----------
This will serve as a log for the changes added for the release of version 0.8.1.
- Univariate offsets have been added to allow for distributions to be fit to a column of data rather than a vector of numbers. This stops the copying of data that had to be done previously.
Changelog
---------
Base
----
- Parameters `column_idx` and `d` have been added to the `_summarize` method that all models expose. This is only useful for univariate distributions and models that fit univariate distributions and can be ignored by other models. The `column_idx` parameter specifies which column in a data matrix the distribution should be fit to, essentially serving as an offset. `d` refers to the number of dimensions that the data matrix has. This means that a univariate distribution will fit to all samples `i` such that `i*d + column_idx` in a pointer array. Multivariate distributions and models using those can ignore this.
- A convenience function `to_yaml` was added to `State` and `Model` classes. `YAML` is a superset of `JSON` that can be 4 to 5 times more compact. You need the `yaml` package installed to use it.
Distributions
-------------
- The `summarize` method has been moved from most individual distributions to the `Distribution` base object, as has the `fit` method.
- `min_std` has been moved from the `from_summaries` method and the `fit` method to the `__init__` method for the `NormalDistribution` and `LogNormalDistribution` objects.
NaiveBayes
----------
- Moved the `fit` and `summarize` methods to `BayesModel` due to their similarity with BayesClassifier
BayesClassifier
---------------
- Moved the `fit` and `summarize` methods to `BayesModel` due to their similarity to NaiveBayes
GeneralMixtureModel
-------------------
- Fixed a bug where `n_jobs` was ignored in the `from_samples` method because `batch_size` was reset for the k-means initialization
HiddenMarkovModel
-----------------
- The default name of a HiddenMarkovModel has been changed from "None" to "HiddenMarkovModel"
Version 0.8.0
=============
Highlights
----------
This will serve as a log for the changes added for the release of version 0.8.0.
Changelog
---------
k-means
.......
- k-means has been changed from using iterative computation to using the alternate formulation of euclidean distance, from ||a - b||^{2} to using ||a||^{2} + ||b||^{2} - 2||a \cdot b||. This allows for the centroid norms to be cached, significantly speeding up computation, and for dgemm to be used to solve the matrix matrix multiplication. Initial attempts to add in GPU support appeared unsuccessful, but in theory it should be something that can be added in.
- k-means has been refactored to more natively support an out-of-core learning goal, by allowing for data to initially be cast as numpy memorymaps and not coercing them to arrays midway through.
Hidden Markov Models
....................
- Allowed labels for labeled training to take in string names of the states instead of the state objects themselves.
- Added in `state_names` and `names` parameters to the `from_samples` method to allow for more control over the creation of the model.
- Added in semi-supervised learning to the `fit` step that can be activated by passing in a list of labels where sequences that have no labels have a None value. This allows for training to occur where some sequences are fully labeled and others have no labels, not for training to occur on partially labeled sequences.
- Supervised initialization followed by semi-supervised learning added in to the `from_samples` method similarly to other methods. One should do this by passing in string labels for state names, always starting with -start, where model_name is the `name` parameter passed into the `from_samples` method. Sequences that do not have labels should have a None instead of a list of corresponding labels. While semi-supervised learning using the `fit` method can support arbitrary transitions amongst silent states, the `from_samples` method does not produce silent states, and so other than the start and end states, all states should be symbol emitting states. If using semi-supervised learning, one must also pass in a list of the state names using the `state_names` parameter that has been added in.
- Fixed bug in supervised learning where it would not initialize correctly due to an error in the semi-supervised learning implementation.
- Fixed bug where model could not be plotted without pygraphviz due to an incorrect call to networkx.draw.
General Mixture Models
......................
- Changed the initialization step to be done on the first batch of data instead of the entire dataset. If the entire dataset fits in memory this does not change anything. However, this allows for out-of-core updates to be done automatically instead of immediately trying to load the entire dataset into memory. This does mean that out-of-core updates will have a different initialization now, but then yield exact updates after that.
- Fixed bug where passing in a 1D array would cause an error by recasting all 1D arrays as 2D arrays.
Bayesian Networks
.................
- Added in a reduce_dataset parameter to the `from_samples` method that will take in a dataset and create a new dataset that is the unique set of samples, weighted by their weighted occurrence in the dataset. Essentially, it takes a dataset that may have repeating members, and produces a new dataset that is entirely unique members. This produces an identically scoring Bayesian network as before, but all structure learning algorithms can be significantly sped up. This speed up is proportional to the redundancy of the dataset, so large datasets on a smallish (< 12) number of variables will see massive speed gains (sometimes even 2-3 orders of magnitude!) whereas past that it may not be beneficial. The redundancy of the dataset (and thus the speedup) can be estimated as n_samples / n_possibilities, where n_samples is the number of samples in the dataset and n_possibilities is the product of the number of unique keys per variable, or 2**d for binary data with d variables. It can be calculated exactly as n_samples / n_unique_samples, as many datasets are biased towards repeating elements.
- Fixed a premature optimization where the parents were stripped from conditional probability tables when saving the Bayesian Network to a json, causing an error in serialization. The premature optimization is that in theory pomegranate is set up to handle cyclic Bayesian networks and serializing that without first stripping parents would cause an infinite file size. However, a future PR that enabled cyclic Bayesian networks will account for this error.
Naive Bayes
...........
- Fixed documentation of `from_samples` to actually refer to the naive Bayes model.
- Added in semi-supervised learning through the EM algorithm for samples that are labeled with -1.
Bayes Classifier
................
- Fixed documentation of `from_samples` to actually refer to the Bayes classifier model.
- Added in semi-supervised learning through the EM algorithm for samples that are labeled with -1.
Distributions
.............
- Multivariate Gaussian Distributions can now use GPUs for both log probability and summarization calculations, speeding up both tasks ~4x for any models that use them. This is added in through CuPy.
Out Of Core
...........
- The parameter "batch_size" has been added to HMMs, GMMs, and k-means models for built-in out-of-core calculations. Pass in a numpy memory map instead of an array and set the batch size for exact updates (sans initialization).
Minibatching
............
- The parameter "batches_per_epoch" has been added to HMMs, GMMs, and k-means models for build-in minibatching support. This specifies the number of batches (as defined by "batch_size") to summarize before calculating new parameter updates.
- The parameter "lr_decay" has been added to HMMs and GMMs that specifies the decay in the learning rate over time. Models may not converge otherwise when doing minibatching.
Parallelization
...............
- `n_jobs` has been added to all models for both fitting and prediction steps. This allows users to make parallelized predictions with their model without having to do anything more complicated than setting a larger number of jobs.
Tutorials
.........
- Removed the PyData 2016 Chicago Tutorial due to it's similarity to tutorials_0_pomegranate_overview.
jmschrei-pomegranate-8de2be8/examples/ 0000775 0000000 0000000 00000000000 14643672530 0020151 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/examples/Bayesian_Network_Monty_Hall.ipynb 0000664 0000000 0000000 00000017011 14643672530 0026606 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"id": "473b0cb3",
"metadata": {},
"source": [
"## The Monty Hall Problem\n",
"\n",
"The Monty Hall problem arose from the gameshow Let's Make a Deal, where a guest had to choose which one of three doors had a prize behind it. The twist was that after the guest chose, the host, originally Monty Hall, would then open one of the doors the guest did not pick that also did not have the prize behind it. Afterwards, Monty would ask if the guest wanted to switch which door they had picked. Initial inspection may lead you to believe that if there are only two doors left there is a 50-50 chance of you picking the right one, and so there is no advantage one way or the other. However, it has been proven both through simulations and analytically that there is in fact a 66% chance of getting the prize if the guest switches their door after Monty opens one, regardless of the door they initially went with."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "76bedfe3",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n",
"torch : 1.13.0\n",
"torchegranate: 0.4.0\n",
"\n",
"Compiler : GCC 11.2.0\n",
"OS : Linux\n",
"Release : 4.15.0-206-generic\n",
"Machine : x86_64\n",
"Processor : x86_64\n",
"CPU cores : 8\n",
"Architecture: 64bit\n",
"\n"
]
}
],
"source": [
"%pylab inline\n",
"import seaborn; seaborn.set_style('whitegrid')\n",
"import torch\n",
"\n",
"%load_ext watermark\n",
"%watermark -m -n -p torch,torchegranate"
]
},
{
"cell_type": "markdown",
"id": "8dccea1d",
"metadata": {},
"source": [
"We can reproduce this result in pomegranate using Bayesian networks with three nodes, one for the guest, one for the prize, and one for the door Monty chooses to open. The door the guest initially chooses and the door the prize is behind are completely random processes across the three doors, but the door which Monty opens is dependent on both the door the guest chooses (it cannot be the door the guest chooses), and the door the prize is behind (it cannot be the door with the prize behind it).\n",
"\n",
"To create the Bayesian network in pomegranate, we first create the distributions which live in each node in the graph. For a categorical bayesian network we use Categorical distributions for the root nodes and ConditionalCategorical distributions for the inner and leaf nodes. \n",
"\n",
"First, we can create our \"prize\" and \"guest\" distributions. These are each Categorical distributions because they do not depend on anything, and they are uniform distributions because they are equally likely to be any of the three doors."
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "ce8a68c4",
"metadata": {},
"outputs": [],
"source": [
"from torchegranate.distributions import Categorical\n",
"\n",
"guest = Categorical([[1./3, 1./3, 1./3]])\n",
"prize = Categorical([[1./3, 1./3, 1./3]])"
]
},
{
"cell_type": "markdown",
"id": "369339f5",
"metadata": {},
"source": [
"You may notice that there is an additional dimension added to the probabilities. This is because all distributions in pomegranate have the potential to be multivariate even when being applied to univariate problems.\n",
"\n",
"Next, we need to create the conditional distribution describing the door that Monty will open. Because Monty can only open a door that is not selected by the contestant and also does not have the prize, sometimes this leaves Monty with only one door that can be opened. Overall, the distribution is a 3x3x3 tensor, with three possibilities from the guest, three independent possibilities from the prize, and three possible doors to open."
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "2b303ce6",
"metadata": {},
"outputs": [],
"source": [
"from torchegranate.distributions import ConditionalCategorical\n",
"\n",
"probs = numpy.array([[\n",
" [[0.0, 0.5, 0.5], [0.0, 0.0, 1.0], [0.0, 1.0, 0.0]], \n",
" [[0.0, 0.0, 1.0], [0.5, 0.0, 0.5], [1.0, 0.0, 0.0]],\n",
" [[0.0, 1.0, 0.0], [1.0, 0.0, 0.0], [0.5, 0.5, 0.0]]\n",
"]])\n",
"\n",
"monty = ConditionalCategorical(probs) "
]
},
{
"cell_type": "markdown",
"id": "f693f22a",
"metadata": {},
"source": [
"Next, we can create the Bayesian network object in just one line by passing in the distribution objects and edges in the form of (parent, child) tuples. Previous versions of pomegranate required that you create State or Node objects and add them in using `add_edge` and `add_node` methods. State and Node objects no longer exist, and while those methods still exist if you would prefer to use them you no longer need to. The `bake` method has also been removed and is no longer required."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "cdd24ba0",
"metadata": {},
"outputs": [],
"source": [
"from torchegranate.bayesian_network import BayesianNetwork\n",
"\n",
"model = BayesianNetwork([guest, prize, monty], [(guest, monty), (prize, monty)])"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "ec59baca",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[0, 1, 2],\n",
" [0, 2, 1],\n",
" [2, 1, 0]])"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X = torch.tensor([[0, 1, -1],\n",
" [0, 2, -1],\n",
" [2, 1, -1]])\n",
"\n",
"X_masked = torch.masked.MaskedTensor(X, mask=X >= 0)\n",
"\n",
"\n",
"model.predict(X_masked)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "dac5d471",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([1.6111])"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from torchegranate.distributions import Exponential\n",
"\n",
"X = torch.exp(torch.randn(100, 1))\n",
"mask = torch.ones(100, 1, dtype=bool)\n",
"mask[75:] = False\n",
"X_masked = torch.masked.MaskedTensor(X, mask=mask)\n",
"\n",
"Exponential().fit(X[:75]).scales"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "6169a52f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Parameter containing:\n",
"tensor([1.6111])"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Exponential().fit(X_masked).scales"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1ea963c8",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
jmschrei-pomegranate-8de2be8/pomegranate/ 0000775 0000000 0000000 00000000000 14643672530 0020635 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/pomegranate/__init__.py 0000664 0000000 0000000 00000000026 14643672530 0022744 0 ustar 00root root 0000000 0000000 __version__ = "1.1.0"
jmschrei-pomegranate-8de2be8/pomegranate/_bayes.py 0000664 0000000 0000000 00000023331 14643672530 0022453 0 ustar 00root root 0000000 0000000 # _bayes.py
# Author: Jacob Schreiber
import torch
from ._utils import _cast_as_tensor
from ._utils import _update_parameter
from ._utils import _check_parameter
from ._utils import _reshape_weights
from .distributions._distribution import Distribution
class BayesMixin(torch.nn.Module):
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
self.register_buffer("_w_sum", torch.zeros(self.k, device=self.device))
self.register_buffer("_log_priors", torch.log(self.priors))
def _emission_matrix(self, X, priors=None):
"""Return the emission/responsibility matrix.
This method returns the log probability of each example under each
distribution contained in the model with the log prior probability
of each component added.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
e: torch.Tensor, shape=(-1, self.k)
A set of log probabilities for each example under each distribution.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2,
shape=(-1, self.d), check_parameter=self.check_data)
priors = _check_parameter(_cast_as_tensor(priors), "priors",
ndim=2, shape=(X.shape[0], self.k), min_value=0.0, max_value=1.0,
value_sum=1.0, value_sum_dim=-1, check_parameter=self.check_data)
d = X.shape[0]
e = torch.empty(d, self.k, device=self.device, dtype=self.dtype)
for i, d in enumerate(self.distributions):
e[:, i] = d.log_probability(X)
if priors is not None:
e += torch.log(priors)
return e + self._log_priors
def probability(self, X, priors=None):
"""Calculate the probability of each example.
This method calculates the probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format.
Note: This differs from some other probability calculation
functions, like those in torch.distributions, because it is not
returning the probability of each feature independently, but rather
the total probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
prob: torch.Tensor, shape=(-1,)
The probability of each example.
"""
return torch.exp(self.log_probability(X, priors=priors))
def log_probability(self, X, priors=None):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format. For a Bernoulli distribution, each entry in the data must
be either 0 or 1.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
e = self._emission_matrix(X, priors=priors)
return torch.logsumexp(e, dim=1)
def predict(self, X, priors=None):
"""Calculate the label assignment for each example.
This method calculates the label for each example as the most likely
component after factoring in the prior probability.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
y: torch.Tensor, shape=(-1,)
The predicted label for each example.
"""
e = self._emission_matrix(X, priors=priors)
return torch.argmax(e, dim=1)
def predict_proba(self, X, priors=None):
"""Calculate the posterior probabilities for each example.
This method calculates the posterior probabilities for each example
under each component of the model after factoring in the prior
probability and normalizing across all the components.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
y: torch.Tensor, shape=(-1, self.k)
The posterior probabilities for each example under each component.
"""
e = self._emission_matrix(X, priors=priors)
return torch.exp(e - torch.logsumexp(e, dim=1, keepdims=True))
def predict_log_proba(self, X, priors=None):
"""Calculate the log posterior probabilities for each example.
This method calculates the log posterior probabilities for each example
under each component of the model after factoring in the prior
probability and normalizing across all the components.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
y: torch.Tensor, shape=(-1, self.k)
The log posterior probabilities for each example under each
component.
"""
e = self._emission_matrix(X, priors=priors)
return e - torch.logsumexp(e, dim=1, keepdims=True)
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
for d in self.distributions:
d.from_summaries()
if self.frozen == True:
return
priors = self._w_sum / torch.sum(self._w_sum)
_update_parameter(self.priors, priors, self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/_utils.py 0000664 0000000 0000000 00000033613 14643672530 0022514 0 ustar 00root root 0000000 0000000 # _utils.py
# Jacob Schreiber
import numpy
import torch
import collections
from apricot import FacilityLocationSelection
from apricot import FeatureBasedSelection
eps = torch.finfo(torch.float32).eps
class BufferList(torch.nn.Module):
"""A buffer list."""
def __init__(self, buffers):
super(BufferList, self).__init__()
self.buffers = []
for i, b in enumerate(buffers):
name = "_buffer_{}".format(i)
self.register_buffer(name, b)
self.buffers.append(getattr(self, name))
def __repr__(self):
return str(self.buffers)
def __getitem__(self, i):
return self.buffers[i]
@property
def dtype(self):
return self.buffers[0].dtype
def _inplace_add(X, Y):
"""Do an in-place addition on X accounting for if Y is a masked tensor."""
if isinstance(Y, torch.masked.MaskedTensor):
X += Y._masked_data
else:
X += Y
def _cast_as_tensor(value, dtype=None):
"""Set the parameter."""
if value is None:
return None
if isinstance(value, (torch.nn.Parameter, torch.Tensor, torch.masked.MaskedTensor)):
if dtype is None:
return value
elif value.dtype == dtype:
return value
else:
return value.type(dtype)
if isinstance(value, list) and all(isinstance(v, numpy.ndarray) for v in value):
value = numpy.array(value)
if isinstance(value, (float, int, list, tuple, numpy.ndarray)):
if dtype is None:
return torch.tensor(value)
else:
return torch.tensor(value, dtype=dtype)
def _cast_as_parameter(value, dtype=None, requires_grad=False):
"""Set the parameter."""
if value is None:
return None
value = _cast_as_tensor(value, dtype=dtype)
return torch.nn.Parameter(value, requires_grad=requires_grad)
def _update_parameter(value, new_value, inertia=0.0, frozen=None):
"""Update a parameter unles.
"""
if hasattr(value, "frozen") and getattr(value, "frozen") == True:
return
if inertia == 0.0:
value[...] = _cast_as_parameter(new_value)
elif inertia < 1.0:
value_ = inertia*value + (1-inertia)*new_value
inf_idx = torch.isinf(value)
inf_idx_new = torch.isinf(new_value)
value_[inf_idx] = value[inf_idx].type(value_.dtype)
value_[inf_idx_new] = new_value[inf_idx_new].type(value_.dtype)
value[:] = _cast_as_parameter(value_)
def _check_parameter(parameter, name, min_value=None, max_value=None,
value_sum=None, value_sum_dim=None, value_set=None, dtypes=None, ndim=None,
shape=None, check_parameter=True, epsilon=1e-6):
"""Ensures that the parameter falls within a valid range.
This check accepts several optional conditions that can be used to ensure
that the value has the desired properties. If these conditions are set to
`None`, they are not checked.
Note: `parameter` can be a single value or it can be a whole tensor/array
of values. These checks are run either against the entire tensor, e.g.
ndims, or against each of the values in the parameter.
Parameters
----------
parameter: anything
The parameter meant to be checked
name: str
The name of the parameter for error logging purposes.
min_value: float or None, optional
The minimum numeric value that any values in the parameter can take.
Default is None.
max_value: float or None, optional
The maximum numeric value that any values in the parameter can take.
Default is None.
value_sum: float or None, optional
The approximate sum, within eps, of the parameter. Default is None.
value_sum_dim: int or float, optional
What dimension to sum over. If None, sum over entire tensor. Default
is None.
value_set: tuple or list or set or None, optional
The set of values that each element in the parameter can take. Default
is None.
dtypes: tuple or list or set or None, optional
The set of dtypes that the parameter can take. Default is None.
ndim: int or list or tuple or None, optional
The number of dimensions of the tensor. Should not be used when the
parameter is a single value. Default is None.
shape: tuple or None, optional
The shape of the parameter. -1 can be used to accept any value for that
dimension.
epsilon: float, optional
When using `value_sum`, this is the maximum difference acceptable.
Default is 1e-6.
"""
vector = (numpy.ndarray, torch.Tensor, torch.nn.Parameter)
if parameter is None:
return None
if check_parameter == False:
return parameter
if dtypes is not None:
if isinstance(parameter, vector):
if parameter.dtype not in dtypes:
raise ValueError("Parameter {} dtype must be one of {}".format(
name, dtypes))
else:
if type(parameter) not in dtypes:
raise ValueError("Parameter {} dtype must be one of {}".format(
name, dtypes))
if min_value is not None:
if isinstance(parameter, vector):
if (parameter < min_value).sum() > 0:
raise ValueError("Parameter {} must have a minimum value above"
" {}".format(name, min_value))
else:
if parameter < min_value:
raise ValueError("Parameter {} must have a minimum value above"
" {}".format(name, min_value))
if max_value is not None:
if isinstance(parameter, vector):
if (parameter > max_value).sum() > 0:
raise ValueError("Parameter {} must have a maximum value below"
" {}".format(name, max_value))
else:
if parameter > max_value:
raise ValueError("Parameter {} must have a maximum value below"
" {}".format(name, max_value))
if value_sum is not None:
if isinstance(parameter, vector):
if value_sum_dim is None:
delta = torch.sum(parameter) - value_sum
else:
delta = torch.sum(parameter, dim=value_sum_dim) - value_sum
if torch.any(torch.abs(delta) > epsilon):
raise ValueError("Parameter {} must sum to {}".format(name,
value_sum))
else:
if abs(parameter - value_sum) > epsilon:
raise ValueError("Parameter {} must sum to {}".format(name,
value_sum))
if value_set is not None:
if isinstance(parameter, vector):
if (~numpy.isin(parameter, value_set)).sum() > 0:
raise ValueError("Parameter {} must contain values in set"
" {}".format(name, value_set))
else:
if parameter not in value_set:
raise ValueError("Parameter {} must contain values in set"
" {}".format(name, value_set))
if ndim is not None:
if isinstance(parameter, vector):
if isinstance(ndim, int):
if len(parameter.shape) != ndim:
raise ValueError("Parameter {} must have {} dims".format(
name, ndim))
else:
if len(parameter.shape) not in ndim:
raise ValueError("Parameter {} must have {} dims".format(
name, ndim))
else:
if ndim != 0:
raise ValueError("Parameter {} must have {} dims".format(
name, ndim))
if shape is not None:
if isinstance(parameter, vector):
if len(parameter.shape) != len(shape):
raise ValueError("Parameter {} must have shape {}".format(
name, shape))
for i in range(len(shape)):
if shape[i] != -1 and shape[i] != parameter.shape[i]:
raise ValueError("Parameter {} must have shape {}".format(
name, shape))
return parameter
def _check_shapes(parameters, names):
"""Check the shapes of a set of parameters.
This function takes in a set of parameters, as well as their names, and
checks that the shape is correct. It will raise an error if the lengths
of the parameters without the value of None are not equal.
Parameters
----------
parameters: list or tuple
A set of parameters, which can be None, to check the shape of.
names: list or tuple
A set of parameter names to refer to if something is wrong.
"""
n = len(parameters)
for i in range(n):
for j in range(n):
if parameters[i] is None:
continue
if parameters[j] is None:
continue
n1, n2 = names[i], names[j]
if len(parameters[i]) != len(parameters[j]):
raise ValueError("Parameters {} and {} must be the same "
"shape.".format(names[i], names[j]))
def _reshape_weights(X, sample_weight, device='cpu'):
"""Handle a sample weight tensor by creating and reshaping it.
This function will take any weight input, including None, 1D weights, and
2D weights, and shape it into a 2D matrix with the same shape as the data
X also passed in.
Both elements must be PyTorch tensors.
Parameters
----------
X: torch.tensor, ndims=2
The data being weighted. The contents of this tensor are not used, only
the shape is.
sample_weight: torch.tensor or None
The weight for each element in the data or None.
Returns
-------
sample_weight: torch.tensor, shape=X.shape
A tensor with the same dimensions as X with elements repeated as
necessary.
"""
if sample_weight is None:
if torch.is_floating_point(X):
sample_weight = torch.ones(1, device=device,
dtype=X.dtype).expand(*X.shape)
else:
sample_weight = torch.ones(1, device=device,
dtype=torch.float32).expand(*X.shape)
else:
if not torch.is_floating_point(sample_weight):
sample_weight = sample_weight.type(torch.float32)
if len(sample_weight.shape) == 1:
sample_weight = sample_weight.reshape(-1, 1).expand(-1, X.shape[1])
_check_parameter(sample_weight, "sample_weight", min_value=0)
elif sample_weight.shape[1] == 1:
sample_weight = sample_weight.expand(-1, X.shape[1])
_check_parameter(sample_weight, "sample_weight", min_value=0)
if isinstance(X, torch.masked.MaskedTensor):
if not isinstance(sample_weight, torch.masked.MaskedTensor):
sample_weight = torch.masked.MaskedTensor(sample_weight,
mask=X._masked_mask)
_check_parameter(sample_weight, "sample_weight", shape=X.shape,
ndim=X.ndim)
return sample_weight
def _initialize_centroids(X, k, algorithm='first-k', random_state=None):
if isinstance(k, torch.Tensor):
k = k.item()
if not isinstance(random_state, numpy.random.mtrand.RandomState):
random_state = numpy.random.RandomState(random_state)
if algorithm == 'first-k':
return _cast_as_tensor(torch.clone(X[:k]), dtype=torch.float32)
elif algorithm == 'random':
idxs = random_state.choice(len(X), size=k, replace=False)
return _cast_as_tensor(torch.clone(X[idxs]), dtype=torch.float32)
elif algorithm == 'submodular-facility-location':
selector = FacilityLocationSelection(k, random_state=random_state)
return _cast_as_tensor(selector.fit_transform(X), dtype=torch.float32)
elif algorithm == 'submodular-feature-based':
selector = FeatureBasedSelection(k, random_state=random_state)
return selector.fit_transform(X)
def partition_sequences(X, sample_weight=None, priors=None, n_dists=None):
"""Partition a set of sequences into blobs of equal length.
This function will take in a list of sequences, where each sequence is
a different length, and group together sequences of the same length so that
batched operations can be more efficiently done on them.
Alternatively, it can take in sequences in the correct format and simply
return them. The correct form is to be either a single tensor that has
three dimensions or a list of three dimensional tensors, where each
tensor contains all the sequences of the same length.
More concretely, the input to this function can be:
- A single 3D tensor, or blob of data that can be cast into a 3D
tensor, which gets returned
- A list of 3D tensors, or elements that can be cast into 3D tensors,
which also gets returned
- A list of 2D tensors, which get partitioned into a list of 3D tensors
Parameters
----------
X: list or tensor
The input sequences to be partitioned if in an incorrect format.
sample_weight: list or tensor or None, optional
The input sequence weights for the sequences or None. If None, return
None. Default is None.
priors: list or tensor or None
The input sequence priors for the sequences or None. If None, return
None. Default is None.
n_dists: int or None
The expected last dimension of the priors tensor. Must be provided if
`priors` is provided. Default is None.
Returns
-------
X_: list or tensor
The partitioned and grouped sequences.
"""
if priors is not None and n_dists is None:
raise RuntimeError("If priors are provided, n_dists must be provided as well.")
# If a 3D tensor has been passed in, return it
try:
X = [_check_parameter(_cast_as_tensor(X), "X", ndim=3)]
except:
pass
else:
if sample_weight is not None:
sample_weight = [_check_parameter(_cast_as_tensor(sample_weight),
"sample_weight", min_value=0.0).to(X[0].device)]
if priors is not None:
priors = [_check_parameter(_cast_as_tensor(priors), "priors",
ndim=3, shape=(*X[0].shape[:-1], n_dists)).to(X[0].device)]
return X, sample_weight, priors
# Otherwise, cast all elements in the list as a tensor
X = [_cast_as_tensor(x) for x in X]
# If a list of 3D tensors has been passed in, return it
try:
X = [_check_parameter(x, "X", ndim=3) for x in X]
except:
pass
else:
if sample_weight is not None:
sample_weight = [_check_parameter(_cast_as_tensor(w_),
"sample_weight", min_value=0.0).to(X[0].device)
for w_ in sample_weight]
if priors is not None:
priors = [_check_parameter(_cast_as_tensor(p), "priors",
ndim=3, shape=(*X[i].shape[:-1], n_dists)).to(X[0].device)
for i, p in enumerate(priors)]
if all([x.ndim == 3 for x in X]):
return X, sample_weight, priors
# Otherwise, group together same-sized examples
X_dict = collections.defaultdict(list)
sample_weight_dict = collections.defaultdict(list)
priors_dict = collections.defaultdict(list)
for i, x in enumerate(X):
x = _check_parameter(x, "X", ndim=2)
n = len(x)
X_dict[n].append(x)
if sample_weight is not None:
w = _check_parameter(_cast_as_tensor(sample_weight[i]),
"sample_weight", min_value=0.0).to(X[0].device)
sample_weight_dict[n].append(w)
if priors is not None:
p = _check_parameter(_cast_as_tensor(priors[i]), "priors",
ndim=2, shape=(*x.shape[:-1], n_dists)).to(X[0].device)
priors_dict[n].append(p)
keys = sorted(X_dict.keys())
X_ = [torch.stack(X_dict[key]) for key in keys]
if sample_weight is None:
sample_weight_ = None
else:
sample_weight_ = [torch.stack(sample_weight_dict[key]) for key in keys]
if priors is None:
priors_ = None
else:
priors_ = [torch.stack(priors_dict[key]) for key in keys]
return X_, sample_weight_, priors_
jmschrei-pomegranate-8de2be8/pomegranate/bayes_classifier.py 0000664 0000000 0000000 00000015015 14643672530 0024520 0 ustar 00root root 0000000 0000000 # BayesClassifier.py
# Author: Jacob Schreiber
import numpy
import torch
from ._utils import _cast_as_tensor
from ._utils import _cast_as_parameter
from ._utils import _update_parameter
from ._utils import _check_parameter
from ._utils import _reshape_weights
from ._bayes import BayesMixin
from .distributions._distribution import Distribution
class BayesClassifier(BayesMixin, Distribution):
"""A Bayes classifier object.
A simple way to produce a classifier using probabilistic models is to plug
them into Bayes' rule. Basically, inference is the same as the 'E' step in
EM for mixture models. However, fitting can be significantly faster because
instead of having to iteratively infer labels and learn parameters, you can
just learn the parameters given the known labels. Because the learning step
for most models are simple MLE estimates, this can be done extremely
quickly.
Although the most common distribution to use is a Gaussian with a diagonal
covariance matrix, termed the Gaussian naive Bayes model, any probability
distribution can be used. Here, you can just drop any distributions or
probabilistic model in as long as it has the `log_probability`, `summarize`,
and `from_samples` methods implemented.
Further, the probabilistic models do not even need to be simple
distributions. The distributions can be mixture models or hidden Markov
models or Bayesian networks.
Parameters
----------
distributions: tuple or list
A set of distribution objects. These objects do not need to be
initialized, i.e., can be "Normal()".
priors: tuple, numpy.ndarray, torch.Tensor, or None. shape=(k,), optional
The prior probabilities over the given distributions. Default is None.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling. Default is True.
"""
def __init__(self, distributions, priors=None, inertia=0.0, frozen=False,
check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "BayesClassifier"
_check_parameter(distributions, "distributions", dtypes=(list, tuple,
numpy.array, torch.nn.ModuleList))
self.distributions = torch.nn.ModuleList(distributions)
self.priors = _check_parameter(_cast_as_parameter(priors), "priors",
min_value=0, max_value=1, ndim=1, value_sum=1.0,
shape=(len(distributions),))
self.k = len(distributions)
if all(d._initialized for d in distributions):
self._initialized = True
self.d = distributions[0].d
if self.priors is None:
self.priors = _cast_as_parameter(torch.ones(self.k) / self.k)
else:
self._initialized = False
self.d = None
self._reset_cache()
def _initialize(self, d):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
"""
self.priors = _cast_as_parameter(torch.ones(self.k, dtype=self.dtype,
device=self.device) / self.k)
self._initialized = True
super()._initialize(d)
def fit(self, X, y, sample_weight=None):
"""Fit the model to optionally weighted examples.
This method implements the core of the learning process. For a
general Bayes model, this involves fitting each component of the model
using the labels that are provided.
This method is largely a wrapper around the `summarize` and
`from_summaries` methods. It's primary contribution is serving as a
loop around these functions and to monitor convergence.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
y: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1,)
A set of labels, one per example.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
Returns
-------
self
"""
self.summarize(X, y, sample_weight=sample_weight)
self.from_summaries()
return self
def summarize(self, X, y, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
For a Bayes' classifier, this step involves partitioning the data
according to the labels and then training each component using MLE
estimates.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
y: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1,)
A set of labels, one per example.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
X, sample_weight = super().summarize(X, sample_weight=sample_weight)
y = _check_parameter(_cast_as_tensor(y), "y", min_value=0,
max_value=self.k-1, ndim=1, shape=(len(X),),
check_parameter=self.check_data)
sample_weight = _check_parameter(sample_weight, "sample_weight",
min_value=0, shape=(-1, self.d), check_parameter=self.check_data)
for j, d in enumerate(self.distributions):
idx = y == j
d.summarize(X[idx], sample_weight[idx])
if self.frozen == False:
self._w_sum[j] = self._w_sum[j] + sample_weight[idx].mean(
dim=-1).sum()
jmschrei-pomegranate-8de2be8/pomegranate/bayesian_network.py 0000664 0000000 0000000 00000110150 14643672530 0024551 0 ustar 00root root 0000000 0000000 # bayesian_network.py
# Author: Jacob Schreiber
import time
import numpy
import torch
import itertools
import networkx as nx
from ._utils import _cast_as_tensor
from ._utils import _cast_as_parameter
from ._utils import _update_parameter
from ._utils import _check_parameter
from ._utils import _reshape_weights
from .distributions._distribution import Distribution
from .distributions import Categorical
from .distributions import JointCategorical
from .distributions import ConditionalCategorical
from .factor_graph import FactorGraph
class BayesianNetwork(Distribution):
"""A Bayesian network object.
A Bayesian network is a probability distribution where dependencies between
variables are explicitly encoded in a graph structure and the lack of an
edge represents a conditional independence. These graphs are directed and
typically must be acyclic, but this implementation allows for the networks
to be cyclic as long as there is no assumption of convergence during
inference.
Inference is doing using loopy belief propagation along a factor graph
representation. This is sometimes called the `sum-product` algorithm.
It will yield exact results if the graph has a tree-like structure.
Otherwise, if the graph is acyclic, it is guaranteed to converge but not
necessarily to optimal results. If the graph is cyclic, there is no
guarantee on convergence, but it is thought that the longer the loop is the
more likely one will get good results.
Structure learning can be done using a variety of methods.
Parameters
----------
distributions: tuple or list or None
A set of distribution objects. These do not need to be initialized,
i.e. can be "Categorical()". Currently, they must be either Categorical
or ConditionalCategorical distributions. If provided, they must be
consistent with the provided edges in that every conditional
distribution must have at least one parent in the provided structure.
Default is None.
edges: tuple or list or None, optional
A list or tuple of 2-tuples where the first element in the 2-tuple is
the parent distribution object and the second element is the child
distribution object. If None, then no edges. Default is None.
structure: tuple or list or None, optional
A list or tuple of the parents for each distribution with a tuple
containing no elements indicating a root node. For instance,
((), (0,), (), (0, 2)) would represent a graph with four nodes,
where the second distribution has the first distribution as a parent
and the fourth distribution has the first and third distributions as
parents. Use this only when you want new distribution objects to be
created and fit when using the `fit` method. Default is None.
max_iter: int, optional
The number of iterations to do in the inference step. Default is 10.
tol: float, optional
The threshold at which to stop during fitting when the improvement
goes under. Default is 1e-6.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during fitting. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling. Default is True.
verbose: bool, optional
Whether to print the improvement and timings during training.
"""
def __init__(self, distributions=None, edges=None, structure=None,
algorithm=None, include_parents=None, exclude_parents=None,
max_parents=None, pseudocount=0.0, max_iter=20, tol=1e-6, inertia=0.0,
frozen=False, check_data=True, verbose=False):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "BayesianNetwork"
self.distributions = torch.nn.ModuleList([])
self.edges = []
self.structure = structure
self._marginal_mapping = {}
self._factor_mapping = {}
self._distribution_mapping = {}
self._parents = []
self._factor_graph = FactorGraph(max_iter=max_iter, tol=tol,
frozen=frozen)
self.algorithm = algorithm
self.include_parents = include_parents
self.exclude_parents = exclude_parents
self.max_parents = max_parents
self.pseudocount = pseudocount
self.max_iter = max_iter
self.tol = tol
self.verbose = verbose
self.d = 0
self._initialized = (distributions is not None and
distributions[0]._initialized)
self._reset_cache()
if distributions is not None:
_check_parameter(distributions, "factors", dtypes=(list, tuple))
for distribution in distributions:
self.add_distribution(distribution)
if edges is not None:
_check_parameter(edges, "edges", dtypes=(list, tuple))
if isinstance(edges, (tuple, list)):
for parent, child in edges:
self.add_edge(parent, child)
else:
raise ValueError("Edges must be tuple or list.")
def _initialize(self, d):
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
return
def add_distribution(self, distribution):
"""Adds a distribution to the set of distributions.
Adds a distribution to the set of distributions being stored in the
BayesianNetwork object but also updates the underlying factor graph,
adding in a marginal node and a factor node.
Parameters
----------
distribution: pomegranate.distributions.Distribution
A distribution object to include as a node. Currently must be a
Categorical or a ConditionalCategorical distribution.
"""
if not isinstance(distribution, (Categorical, ConditionalCategorical)):
raise ValueError("Must be Categorical or ConditionalCategorical")
self.distributions.append(distribution)
self.d += 1
# Create the marginal distribution in the factor graph
n_keys = distribution.probs[0].shape[-1]
marginal = Categorical(torch.ones(1, n_keys) / n_keys)
# Add the marginal and keep track of it
self._factor_graph.add_marginal(marginal)
self._marginal_mapping[distribution] = marginal
self._parents.append(tuple())
self._distribution_mapping[distribution] = len(self.distributions) - 1
# If a conditional distribution, calculate the joint distribution
# assuming uniform distributions for all the parents
if isinstance(distribution, ConditionalCategorical):
p = torch.clone(distribution.probs[0])
p /= torch.prod(torch.tensor(p.shape[:-1]))
factor = JointCategorical(p)
# Add the factor to the factor graph
self._factor_graph.add_factor(factor)
self._factor_mapping[distribution] = factor
else:
# Otherwise, we add the univariate distribution as the factor
self._factor_graph.add_factor(distribution)
self._factor_mapping[distribution] = distribution
factor = distribution
self._factor_graph.add_edge(marginal, factor)
def add_distributions(self, distributions):
"""Adds several distributions to the set of distributions.
Parameters
----------
distribution: iterable
Any object that can be iterated over that returns distributions.
Must be Categorical or ConditionalCategorical distributions.
"""
for distribution in distributions:
self.add_distribution(distribution)
def add_edge(self, parent, child):
"""Adds a directed edge from the parent to the child node.
Adds an edge to the list of edges associated with the BayesianNetwork
object but also adds an appropriate edge in the underlying factor
graph between the marginal node associated with the parent and
the factor node associated with the child.
Parameters
----------
parent: pomegranate.distributions.Distribution
The distribution that the edge begins at.
child: pomegranate.distributions.Distribution
The distribution that the edge points to.
"""
if not isinstance(child, ConditionalCategorical):
raise ValueError("Child distribution must be conditional.")
if parent not in self._marginal_mapping:
raise ValueError("Parent distribution must be in network.")
if child not in self._marginal_mapping:
raise ValueError("Child distribution must be in network.")
if parent is child:
raise ValueError("Cannot have self-loops.")
self.edges.append((parent, child))
p_idx = self._distribution_mapping[parent]
c_idx = self._distribution_mapping[child]
self._parents[c_idx] += (p_idx,)
# Get the respective marginal and factor distributions and their idxs
marginal = self._marginal_mapping[parent]
factor = self._factor_mapping[child]
m_idx = self._factor_graph._marginal_idxs[marginal]
f_idx = self._factor_graph._factor_idxs[factor]
# We need to keep this edge as the last one so pop it and re-add it
m = self._factor_graph._factor_edges[f_idx].pop()
f = self._factor_graph._marginal_edges[m_idx].pop()
# Add the new edge and then the previous edge
self._factor_graph.add_edge(marginal, factor)
self._factor_graph._factor_edges[f_idx].append(m)
self._factor_graph._marginal_edges[m_idx].append(f)
def add_edges(self, edges):
"""Adds several edges to the network at once.
Parameters
----------
edges: iterable
Any object that can be iterated over that returns tuples with
a pair of distributions.
"""
for edge in edges:
self.add_edge(*edge)
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution. For a mixture model, this involves first
sampling the component using the prior probabilities, and then sampling
from the chosen distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
X = torch.zeros(n, self.d, dtype=torch.int32) - 1
for i in range(self.d+1):
for j, parents in enumerate(self._parents):
if (X[0, j] != -1).item():
continue
if len(parents) == 0:
X[:, j] = self.distributions[j].sample(n)[:, 0]
else:
X_ = X[:, parents].unsqueeze(-1)
if (X_ == -1).any().item():
continue
X[:, j] = self.distributions[j].sample(n, X_)[:, 0]
return X
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2,
check_parameter=self.check_data)
logps = torch.zeros(X.shape[0], device=X.device, dtype=torch.float32)
for i, distribution in enumerate(self.distributions):
parents = self._parents[i] + (i,)
X_ = X[:, parents]
if len(parents) > 1:
X_ = X_.unsqueeze(-1)
logps += distribution.log_probability(X_)
return logps
def predict(self, X):
"""Infers the maximum likelihood value for each missing value.
This method infers a probability distribution for each of the missing
values in the data. It uses the factor graph representation of the
Bayesian network to run the sum-product/loopy belief propagation
algorithm. After the probability distribution is inferred, the maximum
likeihood value for each variable is returned.
The input to this method must be a torch.masked.MaskedTensor where the
mask specifies which variables are observed (mask = True) and which ones
are not observed (mask = False) for each of the values. When setting
mask = False, it does not matter what the corresponding value in the
tensor is. Different sets of variables can be observed or missing in
different examples.
Unlike the `predict_proba` and `predict_log_proba` methods, this
method preserves the dimensions of the original data because it does
not matter how many categories a variable can take when you're only
returning the maximally likely one.
Parameters
----------
X: torch.masked.MaskedTensor, shape=(-1, d)
The data to predict values for. The mask should correspond to
whether the variable is observed in the example.
Returns
-------
y: torch.tensor, shape=(-1, d)
A completed version of the incomplete input tensor. The missing
variables are replaced with the maximally likely values from
the sum-product algorithm, and observed variables are kept.
"""
y = [t.argmax(dim=1) for t in self.predict_proba(X)]
return torch.vstack(y).T.contiguous()
def predict_proba(self, X):
"""Infers the probability of each category given the model and data.
This method infers a probability distribution for each of the missing
values in the data. It uses the factor graph representation of the
Bayesian network to run the sum-product/loopy belief propagation
algorithm.
The input to this method must be a torch.masked.MaskedTensor where the
mask specifies which variables are observed (mask = True) and which ones
are not observed (mask = False) for each of the values. When setting
mask = False, it does not matter what the corresponding value in the
tensor is. Different sets of variables can be observed or missing in
different examples.
An important note is that, because each variable can have a different
number of categories in the categorical setting, the return is a list
of tensors where each element in that list is the marginal probability
distribution for that variable. More concretely: the first element will
be the distribution of values for the first variable across all
examples. When the first variable has been provided as evidence, the
distribution will be clamped to the value provided as evidence.
..warning:: This inference is exact given a Bayesian network that has
a tree-like structure, but is only approximate for other cases. When
the network is acyclic, this procedure will converge, but if the graph
contains cycles then there is no guarantee on convergence.
Parameters
----------
X: torch.masked.MaskedTensor, shape=(-1, d)
The data to predict values for. The mask should correspond to
whether the variable is observed in the example.
Returns
-------
y: list of tensors, shape=(d,)
A list of tensors where each tensor contains the distribution of
values for that dimension.
"""
return self._factor_graph.predict_proba(X)
def predict_log_proba(self, X):
"""Infers the probability of each category given the model and data.
This method is a wrapper around the `predict_proba` method and simply
takes the log of each returned tensor.
This method infers a log probability distribution for each of the
missing values in the data. It uses the factor graph representation of
the Bayesian network to run the sum-product/loopy belief propagation
algorithm.
The input to this method must be a torch.masked.MaskedTensor where the
mask specifies which variables are observed (mask = True) and which ones
are not observed (mask = False) for each of the values. When setting
mask = False, it does not matter what the corresponding value in the
tensor is. Different sets of variables can be observed or missing in
different examples.
An important note is that, because each variable can have a different
number of categories in the categorical setting, the return is a list
of tensors where each element in that list is the marginal probability
distribution for that variable. More concretely: the first element will
be the distribution of values for the first variable across all
examples. When the first variable has been provided as evidence, the
distribution will be clamped to the value provided as evidence.
..warning:: This inference is exact given a Bayesian network that has
a tree-like structure, but is only approximate for other cases. When
the network is acyclic, this procedure will converge, but if the graph
contains cycles then there is no guarantee on convergence.
Parameters
----------
X: torch.masked.MaskedTensor, shape=(-1, d)
The data to predict values for. The mask should correspond to
whether the variable is observed in the example.
Returns
-------
y: list of tensors, shape=(d,)
A list of tensors where each tensor contains the distribution of
values for that dimension.
"""
return [torch.log(t) for t in self.predict_proba(X)]
def fit(self, X, sample_weight=None):
"""Fit the model to optionally weighted examples.
This method will fit the provided distributions given the data and
their weights. If a structure is provided as a set of edges, then
this will use maximum likelihood estimates to fit each of those
distributions. If no structure is provided, this will use the
structure learning algorithm provided to jointly learn the structure
and the parameters.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
Returns
-------
self
"""
if self.algorithm is not None:
self.structure = _learn_structure(X, sample_weight=sample_weight,
algorithm=self.algorithm,
include_parents=self.include_parents,
exclude_parents=self.exclude_parents,
max_parents=self.max_parents, pseudocount=self.pseudocount)
if self.structure is not None:
distributions = _from_structure(X, sample_weight, self.structure)
self.add_distributions(distributions)
for i, parents in enumerate(self.structure):
if len(parents) > 0:
for parent in parents:
self.add_edge(distributions[parent], distributions[i])
self.summarize(X, sample_weight=sample_weight)
self.from_summaries()
return self
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache for each distribution
in the network. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, len, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
if self.frozen:
return
if not self._initialized:
self._initialize(len(X[0]))
X, sample_weight = super().summarize(X, sample_weight=sample_weight)
X = _check_parameter(X, "X", min_value=0, ndim=2,
check_parameter=self.check_data)
for i, distribution in enumerate(self.distributions):
parents = self._parents[i] + (i,)
w = sample_weight[:, i]
if len(parents) == 1:
distribution.summarize(X[:, parents], sample_weight=w)
else:
distribution.summarize(X[:, parents].unsqueeze(-1),
sample_weight=w)
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen:
return
for distribution in self.distributions:
distribution.from_summaries()
if isinstance(distribution, ConditionalCategorical):
p = torch.clone(distribution.probs[0])
p /= torch.prod(torch.tensor(p.shape[:-1]))
self._factor_mapping[distribution].probs = _cast_as_parameter(p)
#####
def _from_structure(X, sample_weight=None, structure=None, pseudocount=0.0):
"""Fits a set of distributions to data given the structure.
Given the structure, create the distribution objects and fit their
parameters to the given data. This does not perform structure learning.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, or None
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
structure: tuple
A tuple of tuples where the internal tuples indicate the parents of
that variable.
pseudocount: double
A pseudocount to add to each count. Default is 0.
Returns
-------
model: pomegranate.bayesian_network.BayesianNetwork
The fit Bayesian network.
"""
X = _check_parameter(_cast_as_tensor(X), "X", min_value=0, ndim=2,
dtypes=(torch.int32, torch.int64))
sample_weight = _check_parameter(_cast_as_tensor(sample_weight), "X",
min_value=0, ndim=1)
n, d = X.shape
if sample_weight is None:
sample_weight = torch.ones(n, dtype=torch.float32, device=X.device)
if structure is None:
structure = tuple([tuple() for i in range(d)])
model = BayesianNetwork()
if X.device != model.device:
model.to(X.device)
d = len(structure)
distributions = []
for i, parents in enumerate(structure):
if len(parents) == 0:
d = Categorical()
if d.device != X.device:
d.to(X.device)
d.fit(X[:, i:i+1], sample_weight=sample_weight)
else:
parents = parents + (i,)
d = ConditionalCategorical()
if d.device != X.device:
d.to(X.device)
d.fit(X[:, parents].unsqueeze(-1), sample_weight=sample_weight)
distributions.append(d)
return distributions
def _learn_structure(X, sample_weight=None, algorithm='chow-liu',
include_parents=None, exclude_parents=None, max_parents=None,
pseudocount=0, penalty=None, root=0):
"""Learn the structure of a Bayesian network using data.
This function will take in data, an algorithm, and parameters for that
algorithm, and will return the learned structure. Currently supported
algorithms are:
- 'chow-liu': Learn a maximal spanning tree that is the most likely
tree given the data and weights.
- 'exact': A dynamic programming solution to the exact BNSL task that
reduces the time from super-exponential to simply-exponential.
Parameters
----------
X: torch.tensor, shape=(n, d)
The data to fit the structure too, where each row is a sample and
each column corresponds to the associated variable.
sample_weight: torch.tensor, shape=(n,)
The weight of each sample as a positive double. If None, all items are
weighted equally.
algorithm: str
The name of the algorithm to use for structure learning. Must be one
of 'chow-liu' or 'exact'.
include_parents: list or None
A list of tuples where each inner tuple is made up of integers
indicating the parents that must exist for that variable. For example,
when passing in [(1,), (), ()], the first variable must have the second
variable as a parent, and potentially others if learned, and the others
do not have any parents that must be present. If None, no parents are
forced. Default is None.
exclude_parents: list or None
A list of tuples where each inner tuple is made up of integers
indicating the parents that cannot exist for that variable. For example,
when passing in [(1,), (), ()], the first variable cannot have the
second variable as a parent, and the other variables have no
restrictions on it. If None, no parents are excluded. Default is None.
max_parents: int or None
The maximum number of parents a variable can have. If used, this means
using the k-learn procedure. Can drastically speed up algorithms.
If None, no max on parents. Default is None.
pseudocount: double
A pseudocount to add to each count. Default is 0.
penalty: float or None, optional
The weighting of the model complexity term in the objective function.
Increasing this value will encourage sparsity whereas setting the value
to 0 will result in an unregularized structure. Default is
log2(|D|) / 2 where |D| is the sum of the weights of the data.
root: int
When using a tree-based algorithm, like Chow-Liu, sets the variable
that is the root of the tree.
Returns
-------
structure: tuple, shape=(d,)
A tuple of tuples, where each inner tuple represents a dimension in
the data and contains the parents of that dimension.
"""
X = _check_parameter(_cast_as_tensor(X), "X", min_value=0, ndim=2,
dtypes=(torch.int32, torch.int64))
sample_weight = _check_parameter(_cast_as_tensor(sample_weight), "X",
min_value=0, ndim=1)
if sample_weight is None:
sample_weight = torch.ones(X.shape[0], dtype=torch.float32,
device=X.device)
if algorithm == 'chow-liu':
structure = _categorical_chow_liu(X, sample_weight=sample_weight,
pseudocount=pseudocount, root=root)
elif algorithm == 'exact':
structure = _categorical_exact(X, sample_weight=sample_weight,
include_parents=include_parents, exclude_parents=exclude_parents,
max_parents=max_parents, pseudocount=pseudocount)
return structure
def _categorical_chow_liu(X, sample_weight=None, pseudocount=0.0, root=0):
"""An internal function for calculating a Chow-Liu tree.
This function calculates a Chow-Liu tree on categorical data which is
potentially weighted. A Chow-Liu tree is essentially a maximum spanning
tree on the information content that adding each new variable might
add.
Parameters
----------
X: torch.tensor, shape=(n, d)
The data to fit the structure too, where each row is a sample and
each column corresponds to the associated variable.
sample_weight: torch.tensor or None, shape=(n,)
The weight of each sample as a positive double. If None, all items are
weighted equally.
pseudocount: double
A pseudocount to add to each count. Default is 0.
root: int
When using a tree-based algorithm, like Chow-Liu, sets the variable
that is the root of the tree.
Returns
-------
structure: tuple
A tuple of tuples where the internal tuples indicate the parents of
that variable.
"""
X = _check_parameter(_cast_as_tensor(X), "X", min_value=0, ndim=2,
dtypes=(torch.int32, torch.int64))
sample_weight = _check_parameter(_cast_as_tensor(sample_weight), "X",
min_value=0, ndim=1)
pseudocount = _check_parameter(pseudocount, "pseudocount", min_value=0,
ndim=0)
root = _check_parameter(root, "root", min_value=0, max_value=X.shape[1],
dtypes=(int, numpy.int32, numpy.int64, torch.int32, torch.int64))
n, d = X.shape
if sample_weight is None:
sample_weight = torch.ones(n)
start = time.time()
n_categories = tuple(x.item() for x in X.max(dim=0).values + 1)
max_categories = max(n_categories)
c = max_categories ** 2
dtype = sample_weight.dtype
count = torch.empty(c, d, dtype=dtype, device=X.device)
mutual_info = torch.zeros(d, d, dtype=dtype, device=X.device)
marginals_i = torch.empty(d, c, dtype=dtype, device=X.device)
marginals_r = torch.empty(d, c, dtype=dtype, device=X.device)
for j in range(d):
marg = torch.zeros(max_categories, dtype=dtype, device=X.device)
marg.scatter_add_(0, X[:, j], sample_weight)
marginals_i[j] = marg.repeat_interleave(max_categories)
marginals_r[j] = marg.repeat(max_categories)
w = sample_weight.unsqueeze(-1).expand(-1, d)
for j in range(d):
X_j = X[:, j:j+1] * max_categories + X
m = marginals_i[j:j+1] * marginals_r
count[:] = pseudocount
count.scatter_add_(0, X_j, w)
mutual_info[j] -= torch.sum(count * torch.log(count / m.T), dim=0)
mutual_info[:, j] = mutual_info[j]
structure = [[] for i in range(d)]
visited = [root]
unvisited = list(range(d))
unvisited.remove(root)
for i in range(d-1):
min_score = float("inf")
min_x = -1
min_y = -1
idx = mutual_info[visited][:, unvisited].argmin()
row, col = (idx // len(unvisited)).item(), (idx % len(unvisited)).item()
min_x, min_y = visited[row], unvisited[col]
structure[min_y].append(min_x)
visited.append(min_y)
unvisited.remove(min_y)
return tuple(tuple(x) for x in structure)
def _categorical_exact(X, sample_weight=None, include_parents=None,
exclude_parents=None, pseudocount=0, penalty=None, max_parents=None):
"""Find the optimal graph over a set of variables with no other knowledge.
This is the naive dynamic programming structure learning task where the
optimal graph is identified from a set of variables using an order graph
and parent graphs. This can be used either when no constraint graph is
provided or for a SCC which is made up of a node containing a self-loop.
This is a reference implementation that uses the naive shortest path
algorithm over the entire order graph. The 'exact' option uses the A* path
in order to avoid considering the full order graph.
Parameters
----------
X: numpy.ndarray, shape=(n, d)
The data to fit the structure too, where each row is a sample and
each column corresponds to the associated variable.
sample_weight: numpy.ndarray, shape=(n,)
The weight of each sample as a positive double. Default is None.
include_parents: list or None
A set of (parent, child) tuples where each tuple is an edge that
must exist in the found structure.
exclude_parents: list or None
A set of (parent, child) tuples where each tuple is an edge that
cannot exist in the found structure.
penalty: float or None, optional
The weighting of the model complexity term in the objective function.
Increasing this value will encourage sparsity whereas setting the value
to 0 will result in an unregularized structure. Default is
log2(|D|) / 2 where |D| is the sum of the weights of the data.
max_parents: int
The maximum number of parents a node can have. If used, this means
using the k-learn procedure. Can drastically speed up algorithms.
If -1, no max on parents. Default is -1.
Returns
-------
structure: tuple, shape=(d,)
The parents for each variable in this SCC
"""
X = _check_parameter(_cast_as_tensor(X), "X", min_value=0, ndim=2,
dtypes=(torch.int32, torch.int64))
sample_weight = _check_parameter(_cast_as_tensor(sample_weight), "X",
min_value=0, ndim=1)
n, d = X.shape
n_categories = X.max(axis=0).values + 1
if sample_weight is None:
sample_weight = torch.ones(n)
w = sample_weight.sum()
if max_parents is None:
max_parents = int(torch.log2(2 * w / torch.log2(w)).item())
parent_graphs = []
for i in range(d):
exclude = None if exclude_parents is None else exclude_parents[i]
parent_set = tuple(set(range(d)) - set([i]))
parent_graph = _generate_parent_graph(X, sample_weight=sample_weight,
n_categories=n_categories, column_idx=i,
include_parents=include_parents, exclude_parents=exclude,
pseudocount=pseudocount, penalty=penalty, max_parents=max_parents,
parent_set=parent_set)
parent_graphs.append(parent_graph)
order_graph = nx.DiGraph()
for i in range(d+1):
for subset in itertools.combinations(range(d), i):
order_graph.add_node(subset)
for variable in subset:
parent = tuple(v for v in subset if v != variable)
structure, weight = parent_graphs[variable][parent]
weight = -weight if weight < 0 else 0
order_graph.add_edge(parent, subset, weight=weight,
structure=structure)
path = sorted(nx.all_shortest_paths(order_graph, source=(),
target=tuple(range(d)), weight="weight"))[0]
score, structure = 0, list( None for i in range(d) )
for u, v in zip(path[:-1], path[1:]):
idx = list(set(v) - set(u))[0]
parents = order_graph.get_edge_data(u, v)['structure']
structure[idx] = parents
score -= order_graph.get_edge_data(u, v)['weight']
return tuple(structure)
def _generate_parent_graph(X, sample_weight, n_categories, column_idx,
include_parents=None, exclude_parents=None, pseudocount=0, penalty=None,
max_parents=None, parent_set=None):
"""Generate a parent graph for a single variable over its parents.
This will generate the parent graph for a single parents given the data.
A parent graph is the dynamically generated best parent set and respective
score for each combination of parent variables. For example, if we are
generating a parent graph for x1 over x2, x3, and x4, we may calculate that
having x2 as a parent is better than x2,x3 and so store the value
of x2 in the node for x2,x3.
Parameters
----------
X: list, numpy.ndarray, torch.tensor, shape=(n, d)
The data to fit the structure too, where each row is a sample and
each column corresponds to the associated variable.
weights: list, numpy.ndarray, torch.tensor, shape=(n,)
The weight of each sample as a positive double. Default is None.
n_categories: list, numpy.ndarray, torch.tensor, shape=(d,)
The number of unique keys in each column.
column_idx: int
The column index to build the parent graph for.
include_parents: list or tuple or None
A set of integers indicating the parents that must be included in the
returned structure. Default is None.
exclude_parents: list or tuple or None
A set of integers indicating the parents that must be excluded from
the returned structure. Default is None.
pseudocount: double
A pseudocount to add to each count. Default is 0.
penalty: float or None, optional
The weighting of the model complexity term in the objective function.
Increasing this value will encourage sparsity whereas setting the value
to 0 will result in an unregularized structure. Default is
log2(|D|) / 2 where |D| is the sum of the weights of the data.
max_parents: int
The maximum number of parents a node can have. If used, this means
using the k-learn procedure. Can drastically speed up algorithms.
If -1, no max on parents. Default is -1.
parent_set: tuple, default ()
The variables which are possible parents for this variable. By default,
this should be all variables except for idx. If excluded parents are
passed in, this should exclude those variables as well.
Returns
-------
structure: tuple, shape=(d,)
The parents for each variable in this SCC
"""
n, d = X.shape
n_categories = n_categories.numpy()
max_n_categories = int(n_categories.max())
parent_graph = {}
X_dicts = {}
X_cols = X.T.contiguous().type(torch.int64)
w = sample_weight.sum()
log_w = torch.log2(sample_weight.sum()).item() / 2
if max_parents is None:
max_parents = int(torch.log2(2 * w / torch.log2(w)).item())
if parent_set is None:
parent_set = tuple(set(range(d)) - set([column_idx]))
if include_parents is None:
include_parents = []
if exclude_parents is None:
exclude_parents = set()
else:
exclude_parents = set(exclude_parents)
for j in range(len(parent_set)+1):
c_dims = tuple([max_n_categories for _ in range(j+1)])
counts = torch.zeros(*c_dims, dtype=sample_weight.dtype)
offset = max_n_categories ** j
X_cols_ = X_cols * offset
for subset in itertools.combinations(parent_set, j):
best_structure = ()
best_score = float("-inf")
if j <= max_parents:
for parent in include_parents:
if parent not in subset:
break
else:
for var in subset:
if var in exclude_parents:
break
else:
if j == 0:
X_idxs = torch.zeros(n, dtype=torch.int64)
idx = column_idx
else:
X_idxs = X_dicts[subset[:-1]]
idx = subset[-1]
n_params = (numpy.prod(n_categories[list(subset)]) *
(n_categories[column_idx] - 1))
X_idxs = torch.clone(X_idxs) + X_cols_[idx]
counts[:] = pseudocount
counts.view(-1).scatter_add_(0, X_idxs, sample_weight)
marginal_counts = counts.sum(dim=-1, keepdims=True)
logp = torch.sum(counts * torch.log2(counts /
marginal_counts))
best_structure = subset
best_score = logp - log_w * n_params
X_dicts[subset] = X_idxs
for k, variable in enumerate(subset):
parent_subset = tuple(l for l in subset if l != variable)
structure, score = parent_graph[parent_subset]
if score > best_score:
best_score = score
best_structure = structure
parent_graph[subset] = (best_structure, best_score)
return parent_graph
jmschrei-pomegranate-8de2be8/pomegranate/distributions/ 0000775 0000000 0000000 00000000000 14643672530 0023537 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/pomegranate/distributions/__init__.py 0000664 0000000 0000000 00000001056 14643672530 0025652 0 ustar 00root root 0000000 0000000 from .bernoulli import Bernoulli
from .categorical import Categorical
from .conditional_categorical import ConditionalCategorical
from .dirac_delta import DiracDelta
from .exponential import Exponential
from .gamma import Gamma
from .independent_components import IndependentComponents
from .joint_categorical import JointCategorical
from .normal import Normal
from .poisson import Poisson
from .student_t import StudentT
from .uniform import Uniform
from .zero_inflated import ZeroInflated
from .lognormal import LogNormal
from .halfnormal import HalfNormal jmschrei-pomegranate-8de2be8/pomegranate/distributions/_distribution.py 0000664 0000000 0000000 00000004657 14643672530 0027003 0 ustar 00root root 0000000 0000000 # _distribution.py
# Jacob Schreiber
import torch
from .._utils import _cast_as_tensor
from .._utils import _update_parameter
from .._utils import _cast_as_parameter
from .._utils import _check_parameter
from .._utils import _reshape_weights
class Distribution(torch.nn.Module):
"""A base distribution object.
This distribution is inherited by all the other distributions.
"""
def __init__(self, inertia, frozen, check_data):
super(Distribution, self).__init__()
self._device = _cast_as_parameter([0.0])
_check_parameter(inertia, "inertia", min_value=0, max_value=1, ndim=0)
_check_parameter(frozen, "frozen", value_set=[True, False], ndim=0)
_check_parameter(check_data, "check_data", value_set=[True, False],
ndim=0)
self.register_buffer("inertia", _cast_as_tensor(inertia))
self.register_buffer("frozen", _cast_as_tensor(frozen))
self.register_buffer("check_data", _cast_as_tensor(check_data))
self._initialized = False
@property
def device(self):
try:
return next(self.parameters()).device
except:
return 'cpu'
@property
def dtype(self):
return next(self.parameters()).dtype
def freeze(self):
self.register_buffer("frozen", _cast_as_tensor(True))
return self
def unfreeze(self):
self.register_buffer("frozen", _cast_as_tensor(False))
return self
def forward(self, X):
self.summarize(X)
return self.log_probability(X)
def backward(self, X):
self.from_summaries()
return X
def _initialize(self, d):
self.d = d
self._reset_cache()
def _reset_cache(self):
raise NotImplementedError
def probability(self, X):
return torch.exp(self.log_probability(X))
def log_probability(self, X):
raise NotImplementedError
def fit(self, X, sample_weight=None):
self.summarize(X, sample_weight=sample_weight)
self.from_summaries()
return self
def summarize(self, X, sample_weight=None):
if not self._initialized:
self._initialize(len(X[0]))
X = _cast_as_tensor(X)
_check_parameter(X, "X", ndim=2, shape=(-1, self.d),
check_parameter=self.check_data)
sample_weight = _reshape_weights(X, _cast_as_tensor(sample_weight),
device=self.device)
return X, sample_weight
def from_summaries(self):
raise NotImplementedError
class ConditionalDistribution(Distribution):
def __init__(self, inertia, frozen, check_data):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
def marginal(self, dim):
raise NotImplementedError jmschrei-pomegranate-8de2be8/pomegranate/distributions/bernoulli.py 0000664 0000000 0000000 00000015017 14643672530 0026110 0 ustar 00root root 0000000 0000000 # bernoulli.py
# Contact: Jacob Schreiber
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from .._utils import eps
from ._distribution import Distribution
class Bernoulli(Distribution):
"""A Bernoulli distribution object.
A Bernoulli distribution models the probability of a binary variable
occurring. rates of discrete events, and has a probability parameter
describing this value. This distribution assumes that each feature is
independent of the others.
There are two ways to initialize this object. The first is to pass in
the tensor of probability parameters, at which point they can immediately be
used. The second is to not pass in the rate parameters and then call
either `fit` or `summary` + `from_summaries`, at which point the probability
parameter will be learned from data.
Parameters
----------
probs: list, numpy.ndarray, torch.Tensor or None, shape=(d,), optional
The probability parameters for each feature. Default is None.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, probs=None, inertia=0.0, frozen=False, check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "Bernoulli"
self.probs = _check_parameter(_cast_as_parameter(probs), "probs",
min_value=eps, max_value=1-eps, ndim=1)
self._initialized = self.probs is not None
self.d = self.probs.shape[-1] if self._initialized else None
self._reset_cache()
def _initialize(self, d):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
"""
self.probs = _cast_as_parameter(torch.zeros(d, dtype=self.dtype,
device=self.device))
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
self.register_buffer("_w_sum", torch.zeros(self.d, device=self.device))
self.register_buffer("_xw_sum", torch.zeros(self.d, device=self.device))
self.register_buffer("_log_probs", torch.log(self.probs))
self.register_buffer("_log_inv_probs", torch.log(-(self.probs-1)))
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
return torch.distributions.Bernoulli(self.probs).sample([n])
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format. For a Bernoulli distribution, each entry in the data must
be either 0 or 1.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X, dtype=self.probs.dtype), "X",
value_set=(0, 1), ndim=2, shape=(-1, self.d),
check_parameter=self.check_data)
return X.matmul(self._log_probs) + (1-X).matmul(self._log_inv_probs)
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
if self.frozen == True:
return
X, sample_weight = super().summarize(X, sample_weight=sample_weight)
_check_parameter(X, "X", value_set=(0, 1),
check_parameter=self.check_data)
self._w_sum += torch.sum(sample_weight, dim=0)
self._xw_sum += torch.sum(X * sample_weight, dim=0)
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen == True:
return
probs = self._xw_sum / self._w_sum
_update_parameter(self.probs, probs, self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/distributions/categorical.py 0000664 0000000 0000000 00000020700 14643672530 0026365 0 ustar 00root root 0000000 0000000 # categorical.py
# Contact: Jacob Schreiber
import torch
from .._utils import _inplace_add
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from .._utils import _reshape_weights
from ._distribution import Distribution
class Categorical(Distribution):
"""A categorical distribution object.
A categorical distribution models the probability of a set of distinct
values happening. It is an extension of the Bernoulli distribution to
multiple values. Sometimes it is referred to as a discrete distribution,
but this distribution does not enforce that the numeric values used for the
keys have any relationship based on their identity. Permuting the keys will
have no effect on the calculation. This distribution assumes that the
features are independent from each other.
The keys must be contiguous non-negative integers that begin at zero.
Because the probabilities are represented as a single tensor, each feature
must have values for all keys up to the maximum key of any one distribution.
Specifically, if one feature has 10 keys and a second feature has only 4,
the tensor must go out to 10 for each feature but encode probabilities of
zero for the second feature.
Parameters
----------
probs: list, numpy.ndarray, torch.tensor or None, shape=(k, d), optional
Probabilities for each key for each feature, where k is the largest
number of keys across all features. Default is None
n_categories: list, numpy.ndarray, torch.tensor or None, optional
The number of categories for each feature in the data. Only needs to
be provided when the parameters will be learned directly from data and
you want to make sure that right number of keys are included in each
dimension. Default is None.
pseudocount: float, optional
A value to add to the observed counts of each feature when training.
Setting this to a positive value ensures that no probabilities are
truly zero. Default is 0.
inertia: float, (0, 1), optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, probs=None, n_categories=None, pseudocount=0.0,
inertia=0.0, frozen=False, check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "Categorical"
self.probs = _check_parameter(_cast_as_parameter(probs), "probs",
min_value=0, max_value=1, ndim=2)
self.pseudocount = pseudocount
self._initialized = probs is not None
self.d = self.probs.shape[-2] if self._initialized else None
if n_categories is not None:
self.n_keys = n_categories
else:
self.n_keys = self.probs.shape[-1] if self._initialized else None
self._reset_cache()
def _initialize(self, d, n_keys):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
n_keys: int
The number of keys the distribution is being initialized with.
"""
self.probs = _cast_as_parameter(torch.zeros(d, n_keys,
dtype=self.dtype, device=self.device))
self.n_keys = n_keys
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
self.register_buffer("_w_sum", torch.zeros(self.d, device=self.device))
self.register_buffer("_xw_sum", torch.zeros(self.d, self.n_keys,
device=self.device))
self.register_buffer("_log_probs", torch.log(self.probs))
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
return torch.distributions.Categorical(self.probs).sample([n])
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format. For a categorical distribution, each entry in the data must
be an integer in the range [0, n_keys).
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X", min_value=0.0,
max_value=self.n_keys-1, ndim=2, shape=(-1, self.d),
check_parameter=self.check_data)
logps = torch.zeros(X.shape[0], dtype=self.probs.dtype)
for i in range(self.d):
if isinstance(X, torch.masked.MaskedTensor):
logp_ = self._log_probs[i][X[:, i]._masked_data]
logp_[~X[:, i]._masked_mask] = 0
logps += logp_
else:
logps += self._log_probs[i][X[:, i]]
return logps
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
if self.frozen == True:
return
X = _cast_as_tensor(X)
if not self._initialized:
if self.n_keys is not None:
n_keys = self.n_keys
elif isinstance(X, torch.masked.MaskedTensor):
n_keys = int(torch.max(X._masked_data)) + 1
else:
n_keys = int(torch.max(X)) + 1
self._initialize(X.shape[1], n_keys)
X = _check_parameter(X, "X", min_value=0, max_value=self.n_keys-1,
ndim=2, shape=(-1, self.d), check_parameter=self.check_data)
sample_weight = _reshape_weights(X, _cast_as_tensor(sample_weight))
_inplace_add(self._w_sum, torch.sum(sample_weight, dim=0))
for i in range(self.n_keys):
_inplace_add(self._xw_sum[:, i], torch.sum((X == i) * sample_weight,
dim=0))
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen == True:
return
probs = (self._xw_sum + self.pseudocount) / (self._w_sum +
self.pseudocount * self.n_keys).unsqueeze(1)
_update_parameter(self.probs, probs, self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/distributions/conditional_categorical.py 0000664 0000000 0000000 00000021726 14643672530 0030761 0 ustar 00root root 0000000 0000000 # conditional_categorical.py
# Contact: Jacob Schreiber
import numpy
import torch
import itertools
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from .._utils import _reshape_weights
from .._utils import BufferList
from ._distribution import ConditionalDistribution
from .categorical import Categorical
class ConditionalCategorical(ConditionalDistribution):
"""A conditional categorical distribution.
This is a categorical distribution that is conditioned on previous
emissions, meaning that the probability of each character depends on the
observed character earlier in the sequence. Each feature is conditioned
independently of the others like a `Categorical` distribution.
This conditioning makes the shape of the distribution a bit more
complicated than the `JointCategorical` distribution. Specifically, a
`JointCategorical` distribution is multivariate by definition but a
`ConditionalCategorical` does not have to be. Although both may appear
similar in that they both take in a vector of characters and return
probabilities, the vector fed into the JointCategorical are all observed
together without some notion of time, whereas the ConditionalCategorical
explicitly requires a notion of timing, where the probability of later
characters depend on the composition of characters seen before.
Parameters
----------
probs: list of numpy.ndarray, torch.tensor or None, shape=(k, k), optional
A list of conditional probabilities with one tensor for each feature
in the data being modeled. Each tensor should have `k+1` dimensions
where `k` is the number of timesteps to condition on. Each dimension
should span the number of keys in that dimension. For example, if
specifying a univariate conditional categorical distribution where
k=2, a valid tensor shape would be [(2, 3, 4)]. Default is None.
n_categories: list, numpy.ndarray, torch.tensor or None, optional
The number of categories for each feature in the data. Only needs to
be provided when the parameters will be learned directly from data and
you want to make sure that right number of keys are included in each
dimension. Unlike the `Categorical` distribution, this needs to be
a list of shapes with one shape for each feature and the shape matches
that specified in `probs`. Default is None.
pseudocount: float, optional
A value to add to the observed counts of each feature when training.
Setting this to a positive value ensures that no probabilities are
truly zero. Default is 0.
inertia: float, (0, 1), optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, probs=None, n_categories=None, pseudocount=0,
inertia=0.0, frozen=False, check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "ConditionalCategorical"
if probs is not None:
self.n_categories = []
self.probs = torch.nn.ParameterList([])
for prob in probs:
prob = _check_parameter(_cast_as_parameter(prob), "probs",
min_value=0, max_value=1)
self.probs.append(prob)
self.n_categories.append(tuple(prob.shape))
else:
self.probs = None
self.n_categories = n_categories
self.pseudocount = _check_parameter(pseudocount, "pseudocount")
self._initialized = probs is not None
self.d = len(self.probs) if self._initialized else None
self.n_parents = len(self.probs[0].shape) if self._initialized else None
self._reset_cache()
def _initialize(self, d, n_categories):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
n_categories: list of tuples
The shape of each conditional distribution, one per feature.
"""
self.n_categories = []
for n_cat in n_categories:
if isinstance(n_cat, (list, tuple)):
self.n_categories.append(tuple(n_cat))
elif isinstance(n_cat, (numpy.ndarray, torch.Tensor)):
self.n_categories.append(tuple(n_cat.tolist()))
self.n_parents = len(self.n_categories[0])
self.probs = torch.nn.ParameterList([_cast_as_parameter(torch.zeros(
*cats, dtype=self.dtype, device=self.device, requires_grad=False))
for cats in self.n_categories])
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
_w_sum = []
_xw_sum = []
for n_categories in self.n_categories:
_w_sum.append(torch.zeros(*n_categories[:-1],
dtype=self.probs[0].dtype, device=self.device))
_xw_sum.append(torch.zeros(*n_categories,
dtype=self.probs[0].dtype, device=self.device))
self._w_sum = BufferList(_w_sum)
self._xw_sum = BufferList(_xw_sum)
self._log_probs = BufferList([torch.log(prob) for prob in self.probs])
def sample(self, n, X):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution. For a mixture model, this involves first
sampling the component using the prior probabilities, and then sampling
from the chosen distribution.
Parameters
----------
n: int
The number of samples to generate.
X: list, numpy.ndarray, torch.tensor, shape=(n, d, *self.probs.shape-1)
The values to be conditioned on when generating the samples.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=3,
shape=(-1, self.n_parents-1, self.d))
y = []
for i in range(n):
y.append([])
for j in range(self.d):
idx = tuple(X[i, :, j])
if len(idx) == 1:
idx = idx[0].item()
probs = self.probs[j][idx]
y_ = torch.multinomial(probs, 1).item()
y[-1].append(y_)
return torch.tensor(y)
def log_probability(self, X):
X = _check_parameter(_cast_as_tensor(X), "X", ndim=3,
shape=(-1, self.n_parents, self.d), check_parameter=self.check_data)
logps = torch.zeros(len(X), dtype=self.probs[0].dtype, device=X.device,
requires_grad=False)
for i in range(len(X)):
for j in range(self.d):
logps[i] += self._log_probs[j][tuple(X[i, :, j])]
return logps
def summarize(self, X, sample_weight=None):
if self.frozen == True:
return
X = _check_parameter(_cast_as_tensor(X), "X", ndim=3,
dtypes=(torch.int32, torch.int64), check_parameter=self.check_data)
if not self._initialized:
self._initialize(len(X[0][0]), torch.max(X, dim=0)[0].T+1)
X = _check_parameter(X, "X", shape=(-1, self.n_parents, self.d),
check_parameter=self.check_data)
sample_weight = _check_parameter(_cast_as_tensor(sample_weight,
dtype=torch.float32), "sample_weight", min_value=0, ndim=(1, 2))
if sample_weight is None:
sample_weight = torch.ones(X[:, 0].shape[0], X[:, 0].shape[-1],
dtype=self.probs[0].dtype)
elif len(sample_weight.shape) == 1:
sample_weight = sample_weight.reshape(-1, 1).expand(-1, X.shape[2])
elif sample_weight.shape[1] == 1 and self.d > 1:
sample_weight = sample_weight.expand(-1, X.shape[2])
_check_parameter(sample_weight, "sample_weight",
min_value=0, ndim=2, shape=(X.shape[0], X.shape[2]))
for j in range(self.d):
strides = torch.tensor(self._xw_sum[j].stride(), device=X.device)
X_ = torch.sum(X[:, :, j] * strides, dim=-1)
self._xw_sum[j].view(-1).scatter_add_(0, X_, sample_weight[:,j])
self._w_sum[j][:] = self._xw_sum[j].sum(dim=-1)
def from_summaries(self):
if self.frozen == True:
return
for i in range(self.d):
probs = self._xw_sum[i] / self._w_sum[i].unsqueeze(-1)
probs = torch.nan_to_num(probs, 1. / probs.shape[-1])
_update_parameter(self.probs[i], probs, self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/distributions/dirac_delta.py 0000664 0000000 0000000 00000013211 14643672530 0026342 0 ustar 00root root 0000000 0000000 # diracdelta.py
# Contact: Jacob Schreiber
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from ._distribution import Distribution
class DiracDelta(Distribution):
"""A dirac delta distribution object.
A dirac delta distribution is a probability distribution that has its entire
density at zero. This distribution assumes that each feature is independent
of the others. This means that, in practice, it will assign a zero
probability if any value in an example is non-zero.
There are two ways to initialize this object. The first is to pass in
the tensor of alpha values representing the probability to return given a
zero value, at which point they can immediately be
used. The second is to not pass in the rate parameters and then call
either `fit` or `summary` + `from_summaries`, at which point the probability
parameter will be learned from data.
Parameters
----------
alphas: list, numpy.ndarray, torch.Tensor or None, shape=(d,), optional
The probability parameters for each feature. Default is None.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, alphas=None, inertia=0.0, frozen=False, check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "DiracDelta"
self.alphas = _check_parameter(_cast_as_parameter(alphas), "alphas",
min_value=0.0, ndim=1)
self._initialized = alphas is not None
self.d = len(self.alphas) if self._initialized else None
self._reset_cache()
def _initialize(self, d):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
"""
self.alphas = _cast_as_parameter(torch.ones(d, device=self.device))
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
self.register_buffer("_log_alphas", torch.log(self.alphas))
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2,
shape=(-1, self.d), check_parameter=self.check_data)
return torch.sum(torch.where(X == 0.0, self._log_alphas, float("-inf")),
dim=-1)
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
For a dirac delta distribution, there are no statistics to extract.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
if self.frozen == True:
return
X, sample_weight = super().summarize(X, sample_weight=sample_weight)
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
For a dirac delta distribution, there are no updates.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
return
jmschrei-pomegranate-8de2be8/pomegranate/distributions/exponential.py 0000664 0000000 0000000 00000015034 14643672530 0026442 0 ustar 00root root 0000000 0000000 # exponential.py
# Contact: Jacob Schreiber
import torch
from torch.distributions import Exponential as tExponential
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from ._distribution import Distribution
class Exponential(Distribution):
"""An exponential distribution object.
An exponential distribution models scales of discrete events, and has a
rate parameter describing the average time between event occurrences.
This distribution assumes that each feature is independent of the others.
Although the object is meant to operate on discrete counts, it can be used
on any non-negative continuous data.
There are two ways to initialize this object. The first is to pass in
the tensor of rate parameters, at which point they can immediately be
used. The second is to not pass in the rate parameters and then call
either `fit` or `summary` + `from_summaries`, at which point the rate
parameter will be learned from data.
Parameters
----------
scales: list, numpy.ndarray, torch.Tensor or None, shape=(d,), optional
The rate parameters for each feature. Default is None.
inertia: float, (0, 1), optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are
frozen. If you want to freeze individual pameters, or individual values
in those parameters, you must modify the `frozen` attribute of the
tensor or parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, scales=None, inertia=0.0, frozen=False, check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "Exponential"
self.scales = _check_parameter(_cast_as_parameter(scales), "scales",
min_value=0, ndim=1)
self._initialized = scales is not None
self.d = self.scales.shape[-1] if self._initialized else None
self._reset_cache()
def _initialize(self, d):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
"""
self.scales = _cast_as_parameter(torch.zeros(d, dtype=self.dtype,
device=self.device))
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
self.register_buffer("_w_sum", torch.zeros(self.d, device=self.device))
self.register_buffer("_xw_sum", torch.zeros(self.d, device=self.device))
self.register_buffer("_log_scales", torch.log(self.scales))
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
return tExponential(1. / self.scales).sample([n])
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format. For an exponential distribution, the data must be non-negative.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X", min_value=0.0,
ndim=2, shape=(-1, self.d), check_parameter=self.check_data)
return torch.sum(-self._log_scales - (1. / self.scales) * X, dim=1)
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
if self.frozen == True:
return
X, sample_weight = super().summarize(X, sample_weight=sample_weight)
_check_parameter(X, "X", min_value=0, check_parameter=self.check_data)
self._w_sum[:] = self._w_sum + torch.sum(sample_weight, dim=0)
self._xw_sum[:] = self._xw_sum + torch.sum(X * sample_weight, dim=0)
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen == True:
return
scales = self._xw_sum / self._w_sum
_update_parameter(self.scales, scales, self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/distributions/gamma.py 0000664 0000000 0000000 00000020221 14643672530 0025170 0 ustar 00root root 0000000 0000000 # gamma.py
# Contact: Jacob Schreiber
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from .._utils import _check_shapes
from ._distribution import Distribution
class Gamma(Distribution):
"""A gamma distribution object.
A gamma distribution is the sum of exponential distributions, and has shape
and rate parameters. This distribution assumes that each feature is
independent of the others.
There are two ways to initialize this objecct. The first is to pass in
the tensor of rate and shae parameters, at which point they can immediately
be used. The second is to not pass in the rate parameters and then call
either `fit` or `summary` + `from_summaries`, at which point the rate
and shape parameters will be learned from data.
Parameters
----------
shapes: torch.tensor or None, shape=(d,), optional
The shape parameter for each feature. Default is None
rates: torch.tensor or None, shape=(d,), optional
The rate parameters for each feature. Default is None.
inertia: float, (0, 1), optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
tol: float, [0, inf), optional
The threshold at which to stop fitting the parameters of the
distribution. Default is 1e-4.
max_iter: int, [0, inf), optional
The maximum number of iterations to run EM when fitting the parameters
of the distribution. Default is 20.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, shapes=None, rates=None, inertia=0.0, tol=1e-4,
max_iter=20, frozen=False, check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "Gamma"
self.shapes = _check_parameter(_cast_as_parameter(shapes), "shapes",
min_value=0, ndim=1)
self.rates = _check_parameter(_cast_as_parameter(rates), "rates",
min_value=0, ndim=1)
_check_shapes([self.shapes, self.rates], ["shapes", "rates"])
self.tol = _check_parameter(tol, "tol", min_value=0, ndim=0)
self.max_iter = _check_parameter(max_iter, "max_iter", min_value=1,
ndim=0)
self._initialized = (shapes is not None) and (rates is not None)
self.d = self.shapes.shape[-1] if self._initialized else None
self._reset_cache()
def _initialize(self, d):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
"""
self.shapes = _cast_as_parameter(torch.zeros(d, dtype=self.dtype,
device=self.device))
self.rates = _cast_as_parameter(torch.zeros(d, dtype=self.dtype,
device=self.device))
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
self.register_buffer("_w_sum", torch.zeros(self.d, device=self.device))
self.register_buffer("_xw_sum", torch.zeros(self.d, device=self.device))
self.register_buffer("_logx_w_sum", torch.zeros(self.d,
device=self.device))
self.register_buffer("_log_rates", torch.log(self.rates))
self.register_buffer("_lgamma_shapes", torch.lgamma(self.shapes))
self.register_buffer("_thetas", self._log_rates * self.shapes -
self._lgamma_shapes)
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
return torch.distributions.Gamma(self.shapes, self.rates).sample([n])
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format. For a gamma distribution, the data must be non-negative.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X", min_value=0.0,
ndim=2, shape=(-1, self.d), check_parameter=self.check_data)
return torch.sum(self._thetas + torch.log(X) * (self.shapes - 1) -
self.rates * X, dim=-1)
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
if self.frozen == True:
return
X, sample_weight = super().summarize(X, sample_weight=sample_weight)
_check_parameter(X, "X", min_value=0, check_parameter=self.check_data)
self._w_sum[:] = self._w_sum + torch.sum(sample_weight, dim=0)
self._xw_sum[:] = self._xw_sum + torch.sum(X * sample_weight, dim=0)
self._logx_w_sum[:] = self._logx_w_sum + torch.sum(torch.log(X) *
sample_weight, dim=0)
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen == True:
return
thetas = torch.log(self._xw_sum / self._w_sum) - \
self._logx_w_sum / self._w_sum
numerator = (3 - thetas + torch.sqrt((thetas - 3) ** 2 + 24 * thetas))
denominator = (12 * thetas)
new_shapes = numerator / denominator
shapes = new_shapes + self.tol
for iteration in range(self.max_iter):
mask = torch.abs(shapes - new_shapes) < self.tol
if torch.all(mask):
break
shapes = new_shapes
new_shapes = (shapes - (torch.log(shapes) - torch.polygamma(0,
shapes) - thetas) / (1.0 / shapes - torch.polygamma(1, shapes)))
shapes = new_shapes
rates = 1.0 / (1.0 / (shapes * self._w_sum) * self._xw_sum)
_update_parameter(self.shapes, shapes, self.inertia)
_update_parameter(self.rates, rates, self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/distributions/halfnormal.py 0000664 0000000 0000000 00000017361 14643672530 0026244 0 ustar 00root root 0000000 0000000 # normal.py
# Contact: Jacob Schreiber
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from .._utils import _check_shapes
from ._distribution import Distribution
from .normal import Normal
# Define some useful constants
LOG_2 = 0.6931471805599453
class HalfNormal(Normal):
"""A half-normal distribution object.
A half-normal distribution is a distribution over positive real numbers that
is zero for negative numbers. It is defined by a single parameter, sigma,
which is the standard deviation of the distribution. The mean of the
distribution is sqrt(2/pi) * sigma, and the variance is (1 - 2/pi) * sigma^2.
This distribution can assume that features are independent of the others if
the covariance type is 'diag' or 'sphere', but if the type is 'full' then
the features are not independent.
There are two ways to initialize this object. The first is to pass in
the tensor of probablity parameters, at which point they can immediately be
used. The second is to not pass in the rate parameters and then call
either `fit` or `summarize` + `from_summaries`, at which point the probability
parameter will be learned from data.
Parameters
----------
covs: list, numpy.ndarray, torch.Tensor, or None, optional
The variances and covariances of the distribution. If covariance_type
is 'full', the shape should be (self.d, self.d); if 'diag', the shape
should be (self.d,); if 'sphere', it should be (1,). Note that this is
the variances or covariances in all settings, and not the standard
deviation, as may be more common for diagonal covariance matrices.
Default is None.
covariance_type: str, optional
The type of covariance matrix. Must be one of 'full', 'diag', or
'sphere'. Default is 'full'.
min_cov: float or None, optional
The minimum variance or covariance.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
"""
def __init__(
self,
covs=None,
covariance_type="full",
min_cov=None,
inertia=0.0,
frozen=False,
check_data=True,
):
self.name = "HalfNormal"
super().__init__(
means=None,
covs=covs,
min_cov=min_cov,
covariance_type=covariance_type,
inertia=inertia,
frozen=frozen,
check_data=check_data,
)
def _initialize(self, d):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
"""
super()._initialize(d)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
super()._reset_cache()
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
if self.covariance_type in ["diag", "full"]:
return torch.distributions.HalfNormal(self.covs).sample([n])
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(
_cast_as_tensor(X, dtype=self.covs.dtype),
"X",
ndim=2,
shape=(-1, self.d),
check_parameter=self.check_data,
)
return super().log_probability(X) + LOG_2
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
super().summarize(X, sample_weight=sample_weight)
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen == True:
return
# the means are always zero for a half normal distribution
means = torch.zeros(self.d, dtype=self.covs.dtype)
if self.covariance_type == "full":
v = self._xw_sum.unsqueeze(0) * self._xw_sum.unsqueeze(1)
covs = self._xxw_sum / self._w_sum - v / self._w_sum**2.0
elif self.covariance_type in ["diag", "sphere"]:
covs = self._xxw_sum / self._w_sum - self._xw_sum**2.0 / self._w_sum**2.0
if self.covariance_type == "sphere":
covs = covs.mean(dim=-1)
_update_parameter(self.covs, covs, self.inertia)
_update_parameter(self.means, means, self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/distributions/independent_components.py 0000664 0000000 0000000 00000014255 14643672530 0030662 0 ustar 00root root 0000000 0000000 # independent_components.py
# Contact: Jacob Schreiber
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from .._utils import _reshape_weights
from ._distribution import Distribution
class IndependentComponents(Distribution):
"""An independent components distribution object.
A distribution made up of independent, univariate, distributions that each
model a single feature in the data. This means that instead of using a
single type of distribution to model all of the features in your data, you
use one distribution per feature. Note that this will likely be slower
than using a single distribution because the amount of batching possible
will go down significantly.
There are two ways to initialize this object. The first is to pass in a
set of distributions that are all initialized with parameters, at which
point this distribution can be immediately used for inference. The second
is to pass in a set of distributions that are not initialized with
parameters, and then call either `fit` or `summary` + `from_summaries` to
learn the parameters of all the distributions.
Parameters
----------
distributions: list, tuple, numpy.ndarray, torch.Tensor, shape=(d,)
An ordered iterable containing all of the distributions, one per
feature, that will be used.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, distributions, check_data=False):
super().__init__(inertia=0.0, frozen=False, check_data=check_data)
self.name = "IndependentComponents"
if len(distributions) <= 1:
raise ValueError("Must pass in at least 2 distributions.")
for distribution in distributions:
if not isinstance(distribution, Distribution):
raise ValueError("All passed in distributions must " +
"inherit from the Distribution object.")
self.distributions = distributions
self._initialized = all(d._initialized for d in distributions)
self.d = len(distributions)
self._reset_cache()
def _initialize(self, d):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
"""
for distribution in self.distributions:
distribution._initialize(d)
self._initialized = True
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
for distribution in self.distributions:
distribution._reset_cache()
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
return torch.hstack([d.sample(n) for d in self.distributions])
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2,
shape=(-1, self.d))
logp = torch.zeros(X.shape[0])
for i, d in enumerate(self.distributions):
if isinstance(X, torch.masked.MaskedTensor):
logp.add_(d.log_probability(X[:, i:i+1])._masked_data)
else:
logp.add_(d.log_probability(X[:, i:i+1]))
return logp
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
if self.frozen == True:
return
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2,
shape=(-1, self.d))
sample_weight = _reshape_weights(X, _cast_as_tensor(sample_weight,
dtype=torch.float32), device=self.device)
for i, d in enumerate(self.distributions):
d.summarize(X[:, i:i+1], sample_weight=sample_weight[:, i:i+1])
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen == True:
return
for distribution in self.distributions:
distribution.from_summaries()
jmschrei-pomegranate-8de2be8/pomegranate/distributions/joint_categorical.py 0000664 0000000 0000000 00000022067 14643672530 0027600 0 ustar 00root root 0000000 0000000 # joint_categorical.py
# Contact: Jacob Schreiber
import numpy
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from .._utils import _reshape_weights
from ._distribution import Distribution
from .categorical import Categorical
class JointCategorical(Distribution):
"""A joint categorical distribution.
A joint categorical distribution models the probability of a vector of
categorical values occurring without assuming that the dimensions are
independent from each other. Essentially, it is a Categorical distribution
without the assumption that the dimensions are independent of each other.
There are two ways to initialize this object. The first is to pass in
the tensor of probability parameters, at which point they can immediately be
used. The second is to not pass in the rate parameters and then call
either `fit` or `summary` + `from_summaries`, at which point the
probability parameters will be learned from data.
Parameters
----------
probs: list, numpy.ndarray, torch.tensor, or None, shape=*n_categories
A tensor where each dimension corresponds to one column in the data
set being modeled and the size of each dimension is the number of
categories in that column, e.g., if the data being modeled is binary
and has shape (5, 4), this will be a tensor with shape (2, 2, 2, 2).
Default is None.
n_categories: list, numpy.ndarray, torch.tensor, or None, shape=(d,)
A vector with the maximum number of categories that each column
can have. If not given, this will be inferred from the data. Default
is None.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
pseudocount: float, optional
A number of observations to add to each entry in the probability
distribution during training. A higher value will smooth the
distributions more. Default is 0.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, probs=None, n_categories=None, pseudocount=0,
inertia=0.0, frozen=False, check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "JointCategorical"
self.probs = _check_parameter(_cast_as_parameter(probs), "probs",
min_value=0, max_value=1, value_sum=1)
self.n_categories = _check_parameter(n_categories, "n_categories",
min_value=2)
self.pseudocount = _check_parameter(pseudocount, "pseudocount")
self._initialized = probs is not None
self.d = len(self.probs.shape) if self._initialized else None
if self._initialized:
if n_categories is None:
self.n_categories = tuple(self.probs.shape)
elif isinstance(n_categories, int):
self.n_categories = (n_categories for i in range(n_categories))
else:
self.n_categories = tuple(n_categories)
else:
self.n_categories = None
self._reset_cache()
def _initialize(self, d, n_categories):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
n_categories: list, numpy.ndarray, torch.tensor, or None, shape=(d,)
A vector with the maximum number of categories that each column
can have. If not given, this will be inferred from the data.
Default is None.
"""
self.probs = _cast_as_parameter(torch.zeros(*n_categories,
dtype=self.dtype, device=self.device))
self.n_categories = n_categories
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
self._w_sum = torch.zeros(self.d, dtype=self.probs.dtype)
self._xw_sum = torch.zeros(*self.n_categories, dtype=self.probs.dtype)
self._log_probs = torch.log(self.probs)
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution. For a mixture model, this involves first
sampling the component using the prior probabilities, and then sampling
from the chosen distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
idxs = torch.multinomial(self.probs.flatten(), num_samples=n,
replacement=True)
X = numpy.unravel_index(idxs.numpy(), self.n_categories)
X = numpy.stack(X).T
return torch.from_numpy(X)
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format. For a joint categorical distribution, each value must be an
integer category that is smaller than the maximum number of categories
for each feature.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X",
value_set=tuple(range(max(self.n_categories)+1)), ndim=2,
shape=(-1, self.d), check_parameter=self.check_data)
logps = torch.zeros(len(X), dtype=self.probs.dtype)
for i in range(len(X)):
logps[i] = self._log_probs[tuple(X[i])]
return logps
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
if self.frozen == True:
return
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2,
dtypes=(torch.int32, torch.int64), check_parameter=self.check_data)
if not self._initialized:
self._initialize(len(X[0]), torch.max(X, dim=0)[0]+1)
X = _check_parameter(X, "X", shape=(-1, self.d),
value_set=tuple(range(max(self.n_categories)+1)),
check_parameter=self.check_data)
sample_weight = _reshape_weights(X, _cast_as_tensor(sample_weight,
dtype=torch.float32))[:,0]
self._w_sum += torch.sum(sample_weight, dim=0)
for i in range(len(X)):
self._xw_sum[tuple(X[i])] += sample_weight[i]
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen == True:
return
probs = self._xw_sum / self._w_sum[0]
_update_parameter(self.probs, probs, self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/distributions/lognormal.py 0000664 0000000 0000000 00000013757 14643672530 0026120 0 ustar 00root root 0000000 0000000 # normal.py
# Contact: Jacob Schreiber
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from .._utils import _check_shapes
from .normal import Normal
class LogNormal(Normal):
"""A lognormal object.
The parameters are the mu and sigma of the normal distribution, which
is the the exponential of the log normal distribution. This
distribution can assume that features are independent of the others if
the covariance type is 'diag' or 'sphere', but if the type is 'full' then
the features are not independent.
There are two ways to initialize this object. The first is to pass in
the tensor of probablity parameters, at which point they can immediately be
used. The second is to not pass in the rate parameters and then call
either `fit` or `summarize` + `from_summaries`, at which point the probability
parameter will be learned from data.
Parameters
----------
means: list, numpy.ndarray, torch.Tensor or None, shape=(d,), optional
The mean values of the normal distributions. Default is None.
covs: list, numpy.ndarray, torch.Tensor, or None, optional
The variances and covariances of the distribution. If covariance_type
is 'full', the shape should be (self.d, self.d); if 'diag', the shape
should be (self.d,); if 'sphere', it should be (1,). Note that this is
the variances or covariances in all settings, and not the standard
deviation, as may be more common for diagonal covariance matrices.
Default is None.
covariance_type: str, optional
The type of covariance matrix. Must be one of 'full', 'diag', or
'sphere'. Default is 'full'.
min_cov: float or None, optional
The minimum variance or covariance.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
"""
def __init__(
self,
means=None,
covs=None,
covariance_type="full",
min_cov=None,
inertia=0.0,
frozen=False,
check_data=True,
):
self.name = "LogNormal"
super().__init__(
means=means,
covs=covs,
covariance_type=covariance_type,
min_cov=min_cov,
inertia=inertia,
frozen=frozen,
check_data=check_data,
)
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
if self.covariance_type == "diag":
return torch.distributions.Normal(self.means, self.covs).sample([n]).exp()
elif self.covariance_type == "full":
return (
torch.distributions.MultivariateNormal(self.means, self.covs)
.sample([n])
.exp()
)
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(
_cast_as_tensor(X, dtype=self.means.dtype),
"X",
ndim=2,
shape=(-1, self.d),
check_parameter=self.check_data,
)
# take the log of X
x_log = X.log()
return super().log_probability(x_log)
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
if self.frozen is True:
return
X = _cast_as_tensor(X, dtype=self.means.dtype)
super().summarize(X.log(), sample_weight=sample_weight)
jmschrei-pomegranate-8de2be8/pomegranate/distributions/normal.py 0000664 0000000 0000000 00000024155 14643672530 0025410 0 ustar 00root root 0000000 0000000 # normal.py
# Contact: Jacob Schreiber
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from .._utils import _check_shapes
from ._distribution import Distribution
# Define some useful constants
NEGINF = float("-inf")
INF = float("inf")
SQRT_2_PI = 2.50662827463
LOG_2_PI = 1.83787706641
class Normal(Distribution):
"""A normal distribution object.
A normal distribution models the probability of a variable occurring under
a bell-shaped curve. It is described by a vector of mean values and a
covariance value that can be zero, one, or two dimensional. This
distribution can assume that features are independent of the others if
the covariance type is 'diag' or 'sphere', but if the type is 'full' then
the features are not independent.
There are two ways to initialize this object. The first is to pass in
the tensor of probability parameters, at which point they can immediately be
used. The second is to not pass in the rate parameters and then call
either `fit` or `summary` + `from_summaries`, at which point the probability
parameter will be learned from data.
Parameters
----------
means: list, numpy.ndarray, torch.Tensor or None, shape=(d,), optional
The mean values of the distributions. Default is None.
covs: list, numpy.ndarray, torch.Tensor, or None, optional
The variances and covariances of the distribution. If covariance_type
is 'full', the shape should be (self.d, self.d); if 'diag', the shape
should be (self.d,); if 'sphere', it should be (1,). Note that this is
the variances or covariances in all settings, and not the standard
deviation, as may be more common for diagonal covariance matrices.
Default is None.
covariance_type: str, optional
The type of covariance matrix. Must be one of 'full', 'diag', or
'sphere'. Default is 'full'.
min_cov: float or None, optional
The minimum variance or covariance.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
"""
def __init__(self, means=None, covs=None, covariance_type='full',
min_cov=None, inertia=0.0, frozen=False, check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "Normal"
self.means = _check_parameter(_cast_as_parameter(means), "means",
ndim=1)
self.covs = _check_parameter(_cast_as_parameter(covs), "covs",
ndim=(1, 2))
_check_shapes([self.means, self.covs], ["means", "covs"])
self.min_cov = _check_parameter(min_cov, "min_cov", min_value=0, ndim=0)
self.covariance_type = covariance_type
self._initialized = (means is not None) and (covs is not None)
self.d = self.means.shape[-1] if self._initialized else None
self._reset_cache()
def _initialize(self, d):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
"""
self.means = _cast_as_parameter(torch.zeros(d, dtype=self.dtype,
device=self.device))
if self.covariance_type == 'full':
self.covs = _cast_as_parameter(torch.zeros(d, d,
dtype=self.dtype, device=self.device))
elif self.covariance_type == 'diag':
self.covs = _cast_as_parameter(torch.zeros(d, dtype=self.dtype,
device=self.device))
elif self.covariance_type == 'sphere':
self.covs = _cast_as_parameter(torch.tensor(0, dtype=self.dtype,
device=self.device))
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
self.register_buffer("_w_sum", torch.zeros(self.d, dtype=self.dtype,
device=self.device))
self.register_buffer("_xw_sum", torch.zeros(self.d, dtype=self.dtype,
device=self.device))
if self.covariance_type == 'full':
self.register_buffer("_xxw_sum", torch.zeros(self.d, self.d,
dtype=self.dtype, device=self.device))
if self.covs.sum() > 0.0:
chol = torch.linalg.cholesky(self.covs)
_inv_cov = torch.linalg.solve_triangular(chol, torch.eye(
len(self.covs), dtype=self.dtype, device=self.device),
upper=False).T
_inv_cov_dot_mu = torch.matmul(self.means, _inv_cov)
_log_det = -0.5 * torch.linalg.slogdet(self.covs)[1]
_theta = _log_det - 0.5 * (self.d * LOG_2_PI)
self.register_buffer("_inv_cov", _inv_cov)
self.register_buffer("_inv_cov_dot_mu", _inv_cov_dot_mu)
self.register_buffer("_log_det", _log_det)
self.register_buffer("_theta", _theta)
elif self.covariance_type in ('diag', 'sphere'):
self.register_buffer("_xxw_sum", torch.zeros(self.d,
dtype=self.dtype, device=self.device))
if self.covs.sum() > 0.0:
_log_sigma_sqrt_2pi = -torch.log(torch.sqrt(self.covs) *
SQRT_2_PI)
_inv_two_sigma = 1. / (2 * self.covs)
self.register_buffer("_log_sigma_sqrt_2pi", _log_sigma_sqrt_2pi)
self.register_buffer("_inv_two_sigma", _inv_two_sigma)
if torch.any(self.covs < 0):
raise ValueError("Variances must be positive.")
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
if self.covariance_type == 'diag':
return torch.distributions.Normal(self.means, self.covs).sample([n])
elif self.covariance_type == 'full':
return torch.distributions.MultivariateNormal(self.means,
self.covs).sample([n])
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X, dtype=self.means.dtype), "X",
ndim=2, shape=(-1, self.d), check_parameter=self.check_data)
if self.covariance_type == 'full':
logp = torch.matmul(X, self._inv_cov) - self._inv_cov_dot_mu
logp = self.d * LOG_2_PI + torch.sum(logp ** 2, dim=-1)
logp = self._log_det - 0.5 * logp
return logp
elif self.covariance_type in ('diag', 'sphere'):
return torch.sum(self._log_sigma_sqrt_2pi - ((X - self.means) ** 2)
* self._inv_two_sigma, dim=-1)
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
if self.frozen == True:
return
X, sample_weight = super().summarize(X, sample_weight=sample_weight)
X = _cast_as_tensor(X, dtype=self.means.dtype)
sample_weight = _cast_as_tensor(sample_weight, dtype=self.means.dtype)
if self.covariance_type == 'full':
self._w_sum += torch.sum(sample_weight, dim=0)
self._xw_sum += torch.sum(X * sample_weight, axis=0)
self._xxw_sum += torch.matmul((X * sample_weight).T, X)
elif self.covariance_type in ('diag', 'sphere'):
self._w_sum[:] = self._w_sum + torch.sum(sample_weight, dim=0)
self._xw_sum[:] = self._xw_sum + torch.sum(X * sample_weight, dim=0)
self._xxw_sum[:] = self._xxw_sum + torch.sum(X ** 2 *
sample_weight, dim=0)
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen == True:
return
means = self._xw_sum / self._w_sum
if self.covariance_type == 'full':
v = self._xw_sum.unsqueeze(0) * self._xw_sum.unsqueeze(1)
covs = self._xxw_sum / self._w_sum - v / self._w_sum ** 2.0
elif self.covariance_type in ['diag', 'sphere']:
covs = self._xxw_sum / self._w_sum - \
self._xw_sum ** 2.0 / self._w_sum ** 2.0
if self.covariance_type == 'sphere':
covs = covs.mean(dim=-1)
_update_parameter(self.means, means, self.inertia)
_update_parameter(self.covs, covs, self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/distributions/poisson.py 0000664 0000000 0000000 00000014660 14643672530 0025612 0 ustar 00root root 0000000 0000000 # poisson.py
# Contact: Jacob Schreiber
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from ._distribution import Distribution
class Poisson(Distribution):
"""An poisson distribution object.
A poisson distribution models the number of occurrences of events that
happen in a fixed time span, assuming that the occurrence of each event
is independent. This distribution also assumes that each feature is
independent of the others.
There are two ways to initialize this objecct. The first is to pass in
the tensor of lambda parameters, at which point they can immediately be
used. The second is to not pass in the lambda parameters and then call
either `fit` or `summary` + `from_summaries`, at which point the lambda
parameter will be learned from data.
Parameters
----------
lambdas: list, numpy.ndarray, torch.Tensor or None, shape=(d,), optional
The lambda parameters for each feature. Default is None.
inertia: float, (0, 1), optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, lambdas=None, inertia=0.0, frozen=False,
check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "Poisson"
self.lambdas = _check_parameter(_cast_as_parameter(lambdas), "lambdas",
min_value=0, ndim=1)
self._initialized = lambdas is not None
self.d = self.lambdas.shape[-1] if self._initialized else None
self._reset_cache()
def _initialize(self, d):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
"""
self.lambdas = _cast_as_parameter(torch.zeros(d, dtype=self.dtype,
device=self.device))
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
self.register_buffer("_w_sum", torch.zeros(self.d, device=self.device))
self.register_buffer("_xw_sum", torch.zeros(self.d, device=self.device))
self.register_buffer("_log_lambdas", torch.log(self.lambdas))
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
return torch.distributions.Poisson(self.lambdas).sample([n])
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format. For a Poisson distribution, each entry in the data must
be non-negative.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X", min_value=0.0,
ndim=2, shape=(-1, self.d), check_parameter=self.check_data)
return torch.sum(X * self._log_lambdas - self.lambdas -
torch.lgamma(X+1), dim=-1)
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
if self.frozen == True:
return
X, sample_weight = super().summarize(X, sample_weight=sample_weight)
_check_parameter(X, "X", min_value=0, check_parameter=self.check_data)
self._w_sum[:] = self._w_sum + torch.sum(sample_weight, dim=0)
self._xw_sum[:] = self._xw_sum + torch.sum(X * sample_weight, dim=0)
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen == True:
return
lambdas = self._xw_sum / self._w_sum
_update_parameter(self.lambdas, lambdas, self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/distributions/student_t.py 0000664 0000000 0000000 00000012567 14643672530 0026135 0 ustar 00root root 0000000 0000000 # student_t.py
# Contact: Jacob Schreiber
import math
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from .normal import Normal
class StudentT(Normal):
"""A Student T distribution.
A Student T distribution models the probability of a variable occurring under
a bell-shaped curve with heavy tails. Basically, this is a version of the
normal distribution that is less resistant to outliers. It is described by
a vector of mean values and a vector of variance values. This
distribution can assume that features are independent of the others if
the covariance type is 'diag' or 'sphere', but if the type is 'full' then
the features are not independent.
There are two ways to initialize this object. The first is to pass in
the tensor of probability parameters, at which point they can immediately be
used. The second is to not pass in the rate parameters and then call
either `fit` or `summary` + `from_summaries`, at which point the probability
parameter will be learned from data.
Parameters
----------
means: list, numpy.ndarray, torch.Tensor or None, shape=(d,), optional
The mean values of the distributions. Default is None.
covs: list, numpy.ndarray, torch.Tensor, or None, optional
The variances and covariances of the distribution. If covariance_type
is 'full', the shape should be (self.d, self.d); if 'diag', the shape
should be (self.d,); if 'sphere', it should be (1,). Note that this is
the variances or covariances in all settings, and not the standard
deviation, as may be more common for diagonal covariance matrices.
Default is None.
covariance_type: str, optional
The type of covariance matrix. Must be one of 'full', 'diag', or
'sphere'. Default is 'full'.
min_cov: float or None, optional
The minimum variance or covariance.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, dofs, means=None, covs=None, covariance_type='diag',
min_cov=None, inertia=0.0, frozen=False, check_data=True):
dofs = _check_parameter(_cast_as_tensor(dofs), "dofs", min_value=1,
ndim=0, dtypes=(torch.int32, torch.int64))
self.dofs = dofs
super().__init__(means=means, covs=covs, min_cov=min_cov,
covariance_type=covariance_type, inertia=inertia, frozen=frozen,
check_data=check_data)
self.name = "StudentT"
del self.dofs
self.register_buffer("dofs", _cast_as_tensor(dofs))
self.register_buffer("_lgamma_dofsp1", torch.lgamma((dofs + 1) / 2.0))
self.register_buffer("_lgamma_dofs", torch.lgamma(dofs / 2.0))
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
super()._reset_cache()
if self._initialized == False:
return
self.register_buffer("_log_sqrt_dofs_pi_cov", torch.log(torch.sqrt(
self.dofs * math.pi * self.covs)))
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
return torch.distributions.StudentT(self.means, self.covs).sample([n])
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2,
shape=(-1, self.d), check_parameter=self.check_data)
t = (X - self.means) ** 2 / self.covs
return torch.sum(self._lgamma_dofsp1 - self._lgamma_dofs - \
self._log_sqrt_dofs_pi_cov -((self.dofs + 1) / 2.0) *
torch.log(1 + t / self.dofs), dim=-1)
jmschrei-pomegranate-8de2be8/pomegranate/distributions/uniform.py 0000664 0000000 0000000 00000015463 14643672530 0025601 0 ustar 00root root 0000000 0000000 # uniform.py
# Contact: Jacob Schreiber
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from .._utils import _check_shapes
from ._distribution import Distribution
inf = float("inf")
class Uniform(Distribution):
"""A uniform distribution.
A uniform distribution models the probability of a variable occurring given
a range that has the same probability within it and no probability outside
it. It is described by a vector of minimum and maximum values for this
range. This distribution assumes that the features are independent of
each other.
There are two ways to initialize this object. The first is to pass in
the tensor of probability parameters, at which point they can immediately be
used. The second is to not pass in the rate parameters and then call
either `fit` or `summary` + `from_summaries`, at which point the probability
parameter will be learned from data.
Parameters
----------
mins: list, numpy.ndarray, torch.Tensor or None, shape=(d,), optional
The minimum values of the range.
maxs: list, numpy.ndarray, torch.Tensor, or None, optional
The maximum values of the range.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, mins=None, maxs=None, inertia=0.0, frozen=False,
check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "Uniform"
self.mins = _check_parameter(_cast_as_parameter(mins), "mins", ndim=1)
self.maxs = _check_parameter(_cast_as_parameter(maxs), "maxs", ndim=1)
_check_shapes([self.mins, self.maxs], ["mins", "maxs"])
self._initialized = (mins is not None) and (maxs is not None)
self.d = self.mins.shape[-1] if self._initialized else None
self._reset_cache()
def _initialize(self, d):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
"""
self.mins = _cast_as_parameter(torch.zeros(d, dtype=self.dtype,
device=self.device))
self.maxs = _cast_as_parameter(torch.zeros(d, dtype=self.dtype,
device=self.device))
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
self.register_buffer("_x_mins", torch.full((self.d,), inf,
device=self.device))
self.register_buffer("_x_maxs", torch.full((self.d,), -inf,
device=self.device))
self.register_buffer("_logps", -torch.log(self.maxs - self.mins))
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
return torch.distributions.Uniform(self.mins, self.maxs).sample([n])
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format. For a Bernoulli distribution, each entry in the data must
be either 0 or 1.
Note: This differs from some other log probability calculation
functions, like those in torch.distributions, because it is not
returning the log probability of each feature independently, but rather
the total log probability of the entire example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2,
shape=(-1, self.d), check_parameter=self.check_data)
return torch.where((X >= self.mins) & (X <= self.maxs), self._logps,
float("-inf")).sum(dim=1)
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
if self.frozen == True:
return
X, sample_weight = super().summarize(X, sample_weight=sample_weight)
self._x_mins = torch.minimum(self._x_mins, X.min(dim=0).values)
self._x_maxs = torch.maximum(self._x_maxs, X.max(dim=0).values)
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen == True:
return
_update_parameter(self.mins, self._x_mins, self.inertia)
_update_parameter(self.maxs, self._x_maxs, self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/distributions/zero_inflated.py 0000664 0000000 0000000 00000020367 14643672530 0026746 0 ustar 00root root 0000000 0000000 # zero_inflated.py
# Contact: Jacob Schreiber
import time
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from .._utils import _reshape_weights
from ._distribution import Distribution
class ZeroInflated(Distribution):
"""A wrapper for a zero-inflated distribution.
Some discrete distributions, e.g. Poisson or negative binomial, are used
to model data that has many more zeroes in it than one would expect from
the true signal itself. Potentially, this is because data collection devices
fail or other gaps exist in the data. A zero-inflated distribution is
essentially a mixture of these zero values and the real underlying
distribution.
Accordingly, this class serves as a wrapper that can be dropped in for
other probability distributions and makes them "zero-inflated". It is
similar to a mixture model between the distribution passed in and a dirac
delta distribution, except that the mixture happens independently for each
distribution as well as for each example.
Parameters
----------
distribution: pomegranate.distributions.Distribution
A pomegranate distribution object. It should probably be a discrete
distribution, but does not technically have to be.
priors: tuple, numpy.ndarray, torch.Tensor, or None. shape=(2,), optional
The prior probabilities over the given distribution and the dirac
delta component. Default is None.
max_iter: int, optional
The number of iterations to do in the EM step of fitting the
distribution. Default is 10.
tol: float, optional
The threshold at which to stop during fitting when the improvement
goes under. Default is 0.1.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
verbose: bool, optional
Whether to print the improvement and timings during training.
"""
def __init__(self, distribution, priors=None, max_iter=10,
tol=0.1, inertia=0.0, frozen=False, check_data=False, verbose=False):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "ZeroInflated"
self.distribution = distribution
self.priors = _check_parameter(_cast_as_parameter(priors), "priors",
min_value=0, max_value=1, ndim=1, value_sum=1.0)
self.verbose = verbose
self._initialized = distribution._initialized is True
self.d = distribution.d if self._initialized else None
self.max_iter = max_iter
self.tol = tol
if self.priors is None and self.d is not None:
self.priors = _cast_as_parameter(torch.ones(self.d,
device=self.device) / 2)
self._reset_cache()
def _initialize(self, X):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(1, self.d)
The data to use to initialize the model.
"""
self.distribution._initialize(X.shape[1])
self.distribution.fit(X)
self.priors = _cast_as_parameter(torch.ones(X.shape[1],
device=self.device) / 2)
self._initialized = True
super()._initialize(X.shape[1])
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
self.register_buffer("_w_sum", torch.zeros(self.d, 2,
device=self.device))
self.register_buffer("_log_priors", torch.log(self.priors))
def _emission_matrix(self, X):
"""Return the emission/responsibility matrix.
This method returns the log probability of each example under each
distribution contained in the model with the log prior probability
of each component added.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
e: torch.Tensor, shape=(-1, self.k)
A set of log probabilities for each example under each distribution.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2,
shape=(-1, self.d))
e = torch.empty(X.shape[0], self.d, 2, device=self.device)
e[:, :, 0] = self._log_priors.unsqueeze(0)
e[:, :, 0] += self.distribution.log_probability(X).unsqueeze(1)
e[:, :, 1] = torch.log(1 - self.priors).unsqueeze(0)
e[:, :, 1] += torch.where(X == 0, 0, float("-inf"))
return e
def fit(self, X, sample_weight=None):
"""Fit the model to optionally weighted examples.
This method implements the core of the learning process. For a
zero-inflated distribution, this involves performing EM until the
distribution being fit converges.
This method is largely a wrapper around the `summarize` and
`from_summaries` methods. It's primary contribution is serving as a
loop around these functions and to monitor convergence.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
Returns
-------
self
"""
logp = None
for i in range(self.max_iter):
start_time = time.time()
last_logp = logp
logp = self.summarize(X, sample_weight=sample_weight)
if i > 0:
improvement = logp - last_logp
duration = time.time() - start_time
if self.verbose:
print("[{}] Improvement: {}, Time: {:4.4}s".format(i,
improvement, duration))
if improvement < self.tol:
break
self.from_summaries()
self._reset_cache()
return self
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
X = _cast_as_tensor(X)
if not self._initialized:
self._initialize(X)
_check_parameter(X, "X", ndim=2, shape=(-1, self.d))
sample_weight = _reshape_weights(X, _cast_as_tensor(sample_weight,
dtype=torch.float32), device=self.device)
e = self._emission_matrix(X)
logp = torch.logsumexp(e, dim=2, keepdims=True)
y = torch.exp(e - logp)
self.distribution.summarize(X, y[:, :, 0] * sample_weight)
if not self.frozen:
self._w_sum += torch.sum(y * sample_weight.unsqueeze(-1), dim=(0, 1))
return torch.sum(logp)
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
self.distribution.from_summaries()
if self.frozen == True:
return
priors = self._w_sum[:,0] / torch.sum(self._w_sum, dim=-1)
_update_parameter(self.priors, priors, self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/factor_graph.py 0000664 0000000 0000000 00000045256 14643672530 0023662 0 ustar 00root root 0000000 0000000 # factor_graph.py
# Author: Jacob Schreiber
import time
import torch
import itertools
from ._utils import _cast_as_tensor
from ._utils import _update_parameter
from ._utils import _check_parameter
from ._utils import _reshape_weights
from .distributions._distribution import Distribution
from .distributions._distribution import ConditionalDistribution
from .distributions import Categorical
from .distributions import JointCategorical
class FactorGraph(Distribution):
"""A factor graph object.
A factor graph represents a probability distribution as a bipartite graph
where marginal distributions of each dimension in the distribution are on
one side of the graph and factors are on the other side. The distributions
on the factor side encode probability estimates from the model, whereas the
distributions on the marginal side encode probability estimates from the
data.
Inference is done on the factor graph using the loopy belief propagation
algorithm. This is an iterative algorithm where "messages" are passed
along each edge between the marginals and the factors until the estimates
for the marginals converges. In brief: each message represents what the
generating node thinks its marginal distribution is with respect to the
child node. Calculating each message involves marginalizing the parent
node with respect to *every other* node. When the parent node is already
a univariate distribution -- either because it is a marginal node or
a univariate factor node -- no marginalization is needed and it sends
itself as the message. Basically, a joint probability table will receive
messages from all the marginal nodes that comprise its dimensions and,
to each of those marginal nodes, it will send a message back saying what
it (the joint probability table) thinks its marginal distribution is with
respect to the messages from the OTHER marginals. More concretely, if a
joint probability table has two dimensions with marginal node parents
A and B, it will send a message to A that is itself after marginalizing out
B, and will send a message to B that is itself after marginalizing out A.
..note:: It is worth noting that this algorithm is exact when the structure
is a tree. If there exist any loops in the factors, i.e., you can draw a
circle beginning with a factor and then hopping between marginals and
factors and make it back to the factor without crossing any edges twice,
the probabilities returned are approximate.
Parameters
----------
factors: tuple or list or None
A set of distribution objects. These do not need to be initialized,
i.e. can be "Categorical()". Currently, they must be either Categorical
or JointCategorical distributions. Default is None.
marginals: tuple or list or None
A set of distribution objects. These must be initialized and be
Categorical distributions.
edges: list or tuple or None
A set of edges. Critically, the items in this list must be the
distribution objects themselves, and the order that edges must match
the order distributions in a multivariate distribution. Specifically,
if you have a multivariate distribution, the first edge that includes
it must correspond to the first dimension, the second edge must
correspond to the second dimension, etc, and the total number of
edges cannot exceed the number of dimensions. Default is None.
max_iter: int, optional
The number of iterations to do in the inference step as distributions
are converging. Default is 10.
tol: float, optional
The threshold at which to stop during fitting when the improvement
goes under. Default is 1e-6.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
verbose: bool, optional
Whether to print the improvement and timings during training.
"""
def __init__(self, factors=None, marginals=None, edges=None, max_iter=20,
tol=1e-6, inertia=0.0, frozen=False, check_data=True, verbose=False):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "FactorGraph"
self.factors = torch.nn.ModuleList([])
self.marginals = torch.nn.ModuleList([])
self._factor_idxs = {}
self._marginal_idxs = {}
self._factor_edges = []
self._marginal_edges = []
self.max_iter = _check_parameter(max_iter, "max_iter", min_value=1,
dtypes=[int, torch.int16, torch.int32, torch.int64])
self.tol = _check_parameter(tol, "tol", min_value=0)
self.verbose = verbose
self.d = 0
self._initialized = factors is not None and factors[0]._initialized
if factors is not None:
_check_parameter(factors, "factors", dtypes=(list, tuple))
for factor in factors:
self.add_factor(factor)
if marginals is not None:
_check_parameter(marginals, "marginals", dtypes=(list, tuple))
for marginal in marginals:
self.add_marginal(marginal)
if edges is not None:
_check_parameter(edges, "edges", dtypes=(list, tuple))
for marginal, factor in edges:
self.add_edge(marginal, factor)
self._initialized = not factors
def _initialize(self, d):
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
return
def add_factor(self, distribution):
"""Adds a distribution to the set of factors.
Parameters
----------
distribution: pomegranate.distributions.Distribution
A distribution object to include as a node.
"""
if not isinstance(distribution, (Categorical, JointCategorical)):
raise ValueError("Must be a Categorical or a JointCategorical"
" distribution.")
self.factors.append(distribution)
self._factor_edges.append([])
self._factor_idxs[distribution] = len(self.factors) - 1
self._initialized = distribution._initialized
def add_marginal(self, distribution):
"""Adds a distribution to the set of marginals.
This adds a distribution to the marginal side of the bipartate graph.
This distribution must be univariate.
Parameters
----------
distribution: pomegranate.distributions.Distribution
A distribution object to include as a node.
"""
if not isinstance(distribution, Categorical):
raise ValueError("Must be a Categorical distribution.")
self.marginals.append(distribution)
self._marginal_edges.append([])
self._marginal_idxs[distribution] = len(self.marginals) - 1
self.d += 1
def add_edge(self, marginal, factor):
"""Adds an undirected edge to the set of edges.
Because a factor graph is a bipartite graph, one of the edges must be
a marginal distribution and the other edge must be a factor
distribution.
Parameters
----------
marginal: pomegranate.distributions.Distribution
The marginal distribution to include in the edge.
factor: pomegranate.distributions.Distribution
The factor distribution to include in the edge.
"""
if marginal not in self._marginal_idxs:
raise ValueError("Marginal distribution does not exist in graph.")
if factor not in self._factor_idxs:
raise ValueError("Factor distribution does not exist in graph.")
m_idx = self._marginal_idxs[marginal]
f_idx = self._factor_idxs[factor]
self._factor_edges[f_idx].append(m_idx)
self._marginal_edges[m_idx].append(f_idx)
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 2D
format.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2,
check_parameter=self.check_data)
logps = torch.zeros(X.shape[0], device=X.device, dtype=torch.float32)
for idxs, factor in zip(self._factor_edges, self.factors):
logps += factor.log_probability(X[:, idxs])
for i, marginal in enumerate(self.marginals):
logps += marginal.log_probability(X[:, i:i+1])
return logps
def predict(self, X):
"""Infers the maximum likelihood value for each missing value.
This method infers a probability distribution for each of the missing
values in the data. First, the sum-product algorithm is run to infer
a probability distribution for each variable. Then, the maximum
likelihood value is returned from that distribution.
The input to this method must be a torch.masked.MaskedTensor where the
mask specifies which variables are observed (mask = True) and which ones
are not observed (mask = False) for each of the values. When setting
mask = False, it does not matter what the corresponding value in the
tensor is. Different sets of variables can be observed or missing in
different examples.
Unlike the `predict_proba` and `predict_log_proba` methods, this
method preserves the dimensions of the original data because it does
not matter how many categories a variable can take when you're only
returning the maximally likely one.
Parameters
----------
X: torch.masked.MaskedTensor
A masked tensor where the observed values are available and the
unobserved values are missing, i.e., the mask is True for
observed values and the mask is False for missing values. It does
not matter what the underlying value in the tensor is for the
missing values.
"""
y = [t.argmax(dim=1) for t in self.predict_proba(X)]
return torch.vstack(y).T.contiguous()
def predict_proba(self, X):
"""Predict the probability of each variable given some evidence.
Given some evidence about the value that each variable takes, infer
the value that each other variable takes. If no evidence is given,
this returns the marginal value of each variable given the dependence
structure in the network.
Currently, only hard evidence is supported, where the evidence takes
the form of a discrete value. The evidence is represented as a
masked tensor where the masked out values are considered missing.
Parameters
----------
X: torch.masked.MaskedTensor
A masked tensor where the observed values are available and the
unobserved values are missing, i.e., the mask is True for
observed values and the mask is False for missing values. It does
not matter what the underlying value in the tensor is for the
missing values.
"""
nm = len(self.marginals)
nf = len(self.factors)
if X.shape[1] != nm:
raise ValueError("X.shape[1] must match the number of marginals.")
# Pull out the current distributions from factors and marginals
factors = []
marginals = []
prior_marginals = []
current_marginals = []
for i, m in enumerate(self.marginals):
p = torch.clone(m.probs[0])
p = p.repeat((X.shape[0],) + tuple(1 for _ in p.shape))
# Use the evidence in the data to set marginal distributions
for j in range(X.shape[0]):
if X._masked_mask[j, i] == True:
value = X._masked_data[j, i]
p[j] = 0
p[j, value] = 1.0
marginals.append(p)
prior_marginals.append(torch.clone(p))
current_marginals.append(torch.clone(p))
for i, f in enumerate(self.factors):
if not isinstance(f, Categorical):
p = torch.clone(f.probs)
else:
p = torch.clone(f.probs[0])
p = p.repeat((X.shape[0],) + tuple(1 for _ in p.shape))
factors.append(p)
# Set the original in and out messages along the edges
in_messages, out_messages = [], []
for i, m in enumerate(marginals):
k = len(self._marginal_edges[i])
in_messages.append([])
for j in range(k):
in_messages[-1].append(m)
for i in range(len(factors)):
k = len(self._factor_edges[i])
out_messages.append([])
for j in range(k):
marginal_idx = self._factor_edges[i][j]
d_j = marginals[marginal_idx]
out_messages[-1].append(d_j)
# Begin iterations
iteration = 0
while iteration < self.max_iter:
# Update the messages going into the nodes.
for i, f in enumerate(factors):
ni_edges = len(self._factor_edges[i])
for k in range(ni_edges):
message = torch.clone(f)
shape = torch.ones(len(message.shape), dtype=torch.int32)
shape[0] = X.shape[0]
for l in range(ni_edges):
if k == l:
continue
shape[l+1] = message.shape[l+1]
message *= out_messages[i][l].reshape(*shape)
message = torch.sum(message, dim=l+1, keepdims=True)
shape[l+1] = 1
else:
message = message.squeeze()
if len(message.shape) == 1:
message = message.unsqueeze(0)
j = self._factor_edges[i][k]
for ik, parent in enumerate(self._marginal_edges[j]):
if parent == i:
dims = tuple(range(1, len(message.shape)))
in_messages[j][ik] = message / message.sum(
dim=dims, keepdims=True)
break
# Calculate the current estimates of the marginals
loss = 0
for i, m in enumerate(marginals):
current_marginals[i] = torch.clone(m)
for k in range(len(self._marginal_edges[i])):
current_marginals[i] *= in_messages[i][k]
dims = tuple(range(1, len(current_marginals[i].shape)))
current_marginals[i] /= current_marginals[i].sum(dim=dims,
keepdims=True)
loss += torch.nn.KLDivLoss(reduction="batchmean")(torch.log(
current_marginals[i] + 1e-8), prior_marginals[i])
if self.verbose:
print(iteration, loss.item())
if loss < self.tol:
break
# Update the messages leaving based on the new marginals
for i, m in enumerate(marginals):
ni_edges = len(self._marginal_edges[i])
for k in range(ni_edges):
message = torch.clone(m)
for l in range(ni_edges):
if k == l:
continue
message *= in_messages[i][l]
j = self._marginal_edges[i][k]
for ik, parent in enumerate(self._factor_edges[j]):
if parent == i:
dims = tuple(range(1, len(message.shape)))
out_messages[j][ik] = message / message.sum(
dim=dims, keepdims=True)
break
prior_marginals = [torch.clone(d) for d in current_marginals]
iteration += 1
return current_marginals
def predict_log_proba(self, X):
"""Infers the probability of each category given the model and data.
This method is a wrapper around the `predict_proba` method and simply
takes the log of each returned tensor.
This method infers a log probability distribution for each of the
missing values in the data. It uses the factor graph representation of
the Bayesian network to run the sum-product/loopy belief propagation
algorithm.
The input to this method must be a torch.masked.MaskedTensor where the
mask specifies which variables are observed (mask = True) and which ones
are not observed (mask = False) for each of the values. When setting
mask = False, it does not matter what the corresponding value in the
tensor is. Different sets of variables can be observed or missing in
different examples.
An important note is that, because each variable can have a different
number of categories in the categorical setting, the return is a list
of tensors where each element in that list is the marginal probability
distribution for that variable. More concretely: the first element will
be the distribution of values for the first variable across all
examples. When the first variable has been provided as evidence, the
distribution will be clamped to the value provided as evidence.
..warning:: This inference is exact given a Bayesian network that has
a tree-like structure, but is only approximate for other cases. When
the network is acyclic, this procedure will converge, but if the graph
contains cycles then there is no guarantee on convergence.
Parameters
----------
X: torch.masked.MaskedTensor, shape=(-1, d)
The data to predict values for. The mask should correspond to
whether the variable is observed in the example.
Returns
-------
y: list of tensors, shape=(d,)
A list of tensors where each tensor contains the distribution of
values for that dimension.
"""
return [torch.log(t) for t in self.predict_proba(X)]
def fit(self, X, sample_weight=None):
"""Fit the factors of the model to optionally weighted examples.
This method will fit the provided factor distributions to the given
data and their optional weights. It will not update the marginal
distributions, as that information is already encoded in the joint
probabilities.
..note:: A structure must already be provided. Currently, structure
learning of factor graphs is not supported.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
Returns
-------
self
"""
self.summarize(X, sample_weight=sample_weight)
self.from_summaries()
return self
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache for each distribution
in the network. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, len, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
if self.frozen:
return
X, sample_weight = super().summarize(X, sample_weight=sample_weight)
X = _check_parameter(X, "X", ndim=2, check_parameter=self.check_data)
for i, factor in enumerate(self.factors):
factor.summarize(X[:, self._factor_edges[i]],
sample_weight=sample_weight[:,i])
def from_summaries(self):
if self.frozen:
return
for distribution in self.factors:
distribution.from_summaries()
jmschrei-pomegranate-8de2be8/pomegranate/gmm.py 0000664 0000000 0000000 00000026062 14643672530 0021775 0 ustar 00root root 0000000 0000000 # gmm.py
# Author: Jacob Schreiber
import time
import numpy
import torch
from ._utils import _cast_as_tensor
from ._utils import _cast_as_parameter
from ._utils import _update_parameter
from ._utils import _check_parameter
from ._utils import _reshape_weights
from .distributions._distribution import Distribution
from ._bayes import BayesMixin
from .kmeans import KMeans
class GeneralMixtureModel(BayesMixin, Distribution):
"""A general mixture model.
Frequently, data is generated from multiple components. A mixture model
is a probabilistic model that explicitly models data as having come from
a set of probability distributions rather than a single one. Usually, the
abbreviation "GMM" refers to a Gaussian mixture model, but any probability
distribution or heterogeneous set of distributions can be included in the
mixture, making it a "general" mixture model.
However, a mixture model itself has all the same theoretical properties as a
probability distribution because it is one. Hence, it can be used in any
situation that a simpler distribution could, such as an emission
distribution for a HMM or a component of a Bayes classifier.
Conversely, many models that are usually thought of as composed of
probability distributions but distinct from them, e.g. hidden Markov models,
Markov chains, and Bayesian networks, can in theory be passed into this
object and incorporated into the mixture.
If the distributions included in the mixture are not initialized, the
fitting step will first initialize them by running k-means for a small
number of iterations and fitting the distributions to the clusters that
are discovered.
Parameters
----------
distributions: tuple or list
A set of distribution objects. These objects do not need to be
initialized, i.e., can be "Normal()".
priors: tuple, numpy.ndarray, torch.Tensor, or None. shape=(k,), optional
The prior probabilities over the given distributions. Default is None.
max_iter: int, optional
The number of iterations to do in the EM step of fitting the
distribution. Default is 10.
tol: float, optional
The threshold at which to stop during fitting when the improvement
goes under. Default is 0.1.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling. Default is True.
verbose: bool, optional
Whether to print the improvement and timings during training.
"""
def __init__(self, distributions, priors=None, init='random', max_iter=1000,
tol=0.1, inertia=0.0, frozen=False, random_state=None, check_data=True,
verbose=False):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "GeneralMixtureModel"
_check_parameter(distributions, "distributions", dtypes=(list, tuple,
numpy.array, torch.nn.ModuleList))
self.distributions = torch.nn.ModuleList(distributions)
self.priors = _check_parameter(_cast_as_parameter(priors), "priors",
min_value=0, max_value=1, ndim=1, value_sum=1.0,
shape=(len(distributions),))
self.verbose = verbose
self.k = len(distributions)
if all(d._initialized for d in distributions):
self._initialized = True
self.d = distributions[0].d
if self.priors is None:
self.priors = _cast_as_parameter(torch.ones(self.k) / self.k)
else:
self._initialized = False
self.d = None
self.init = init
self.max_iter = max_iter
self.tol = tol
self.random_state = random_state
self._reset_cache()
def _initialize(self, X, sample_weight=None):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
The data to use to initialize the model.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2)
if sample_weight is None:
sample_weight = torch.ones(1, dtype=self.dtype,
device=self.device).expand(X.shape[0], 1)
else:
sample_weight = _check_parameter(_cast_as_tensor(sample_weight),
"sample_weight", min_value=0., check_parameter=self.check_data)
model = KMeans(self.k, init=self.init, max_iter=3,
random_state=self.random_state)
if self.device != model.device:
model.to(self.device)
y_hat = model.fit_predict(X, sample_weight=sample_weight)
self.priors = _cast_as_parameter(torch.empty(self.k,
dtype=self.dtype, device=self.device))
sample_weight_sum = sample_weight.sum()
for i in range(self.k):
idx = y_hat == i
sample_weight_idx = sample_weight[idx]
self.distributions[i].fit(X[idx], sample_weight=sample_weight_idx)
self.priors[i] = sample_weight_idx.sum() / sample_weight_sum
self._initialized = True
self._reset_cache()
super()._initialize(X.shape[1])
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution. For a mixture model, this involves first
sampling the component using the prior probabilities, and then sampling
from the chosen distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
X = []
for distribution in self.distributions:
X_ = distribution.sample(n)
X.append(X_)
X = torch.stack(X)
idxs = torch.multinomial(self.priors, num_samples=n, replacement=True)
return X[idxs, torch.arange(n)]
def fit(self, X, sample_weight=None, priors=None):
"""Fit the model to optionally weighted examples.
This method implements the core of the learning process. For a
mixture model, this involves performing EM until the distributions that
are being fit converge according to the threshold set by `tol`, or
until the maximum number of iterations has been hit.
This method is largely a wrapper around the `summarize` and
`from_summaries` methods. It's primary contribution is serving as a
loop around these functions and to monitor convergence.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
This can be used when only some labels are known by using a
uniform distribution when the labels are not known. Note that
this can be used to assign hard labels, but does not have the
same semantics for soft labels, in that it only influences the
initial estimate of an observation being generated by a component,
not gives a target. Default is None.
Returns
-------
self
"""
logp = None
for i in range(self.max_iter):
start_time = time.time()
last_logp = logp
logp = self.summarize(X, sample_weight=sample_weight,
priors=priors)
if i > 0:
improvement = logp - last_logp
duration = time.time() - start_time
if self.verbose:
print("[{}] Improvement: {}, Time: {:4.4}s".format(i,
improvement, duration))
if improvement < self.tol:
break
self.from_summaries()
self._reset_cache()
return self
def summarize(self, X, sample_weight=None, priors=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example. Labels can be provided for examples but, if provided,
must be incomplete such that semi-supervised learning can be performed.
For a mixture model, this step is essentially performing the 'E' part
of the EM algorithm on a batch of data, where examples are soft-assigned
to distributions in the model and summaries are derived from that.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
logp: float
The log probability of X given the model.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2)
if not self._initialized:
self._initialize(X, sample_weight=sample_weight)
sample_weight = _reshape_weights(X, _cast_as_tensor(sample_weight,
dtype=torch.float32), device=self.device)
e = self._emission_matrix(X, priors=priors)
logp = torch.logsumexp(e, dim=1, keepdims=True)
y = torch.exp(e - logp)
z = torch.clone(self._w_sum)
for i, d in enumerate(self.distributions):
d.summarize(X, y[:, i:i+1] * sample_weight)
if self.frozen == False:
self._w_sum[i] = self._w_sum[i] + (y[:, i:i+1] *
sample_weight).mean(dim=-1).sum()
return torch.sum(logp)
jmschrei-pomegranate-8de2be8/pomegranate/hmm/ 0000775 0000000 0000000 00000000000 14643672530 0021416 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/pomegranate/hmm/__init__.py 0000664 0000000 0000000 00000000205 14643672530 0023524 0 ustar 00root root 0000000 0000000 # __init__.py
# Author: Jacob Schreiber
from .dense_hmm import DenseHMM
from .sparse_hmm import SparseHMM
jmschrei-pomegranate-8de2be8/pomegranate/hmm/_base.py 0000664 0000000 0000000 00000060717 14643672530 0023054 0 ustar 00root root 0000000 0000000 # _base.py
# Author: Jacob Schreiber
import time
import numpy
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _check_parameter
from .._utils import partition_sequences
from ..distributions._distribution import Distribution
from ..kmeans import KMeans
NEGINF = float("-inf")
def _check_inputs(model, X, emissions, priors):
if X is None and emissions is None:
raise ValueError("Must pass in one of `X` or `emissions`.")
emissions = _check_parameter(_cast_as_tensor(emissions), "emissions",
ndim=3)
if emissions is None:
emissions = model._emission_matrix(X, priors=priors)
return emissions
class Silent(Distribution):
def __init__(self):
super().__init__(inertia=0.0, frozen=False, check_data=True)
class _BaseHMM(Distribution):
"""A base hidden Markov model.
A hidden Markov model is an extension of a mixture model to sequences by
including a transition matrix between the elements of the mixture. Each of
the algorithms for a hidden Markov model are essentially just a revision
of those algorithms to incorporate this transition matrix.
There are two main ways one can implement a hidden Markov model: either the
transition matrix can be implemented in a dense, or a sparse, manner. If the
transition matrix is dense, implementing it in a dense manner allows for
the primary computation to use matrix multiplications which can be very
fast. However, if the matrix is sparse, these matrix multiplications will
be fairly slow and end up significantly slower than the sparse version of
a matrix multiplication.
This object is a wrapper for both implementations, which can be specified
using the `kind` parameter. Choosing the right implementation will not
effect the accuracy of the results but will change the speed at which they
are calculated.
Separately, there are two ways to instantiate the hidden Markov model. The
first is by passing in a set of distributions, a dense transition matrix,
and optionally start/end probabilities. The second is to initialize the
object without these and then to add edges using the `add_edge` method
and to add nodes using the `add_nodes` method. Importantly, the way that
you choose to initialize the hidden Markov model is independent of the
implementation that you end up choosing. If you pass in a dense transition
matrix, this will be converted to a sparse matrix with all the zeros
dropped if you choose `kind='sparse'`.
Parameters
----------
distributions: tuple or list
A set of distribution objects. These objects do not need to be
initialized, i.e., can be "Normal()".
edges: numpy.ndarray, torch.Tensor, or None. shape=(k,k), optional
A dense transition matrix of probabilities for how each node or
distribution passed in connects to each other one. This can contain
many zeroes, and when paired with `kind='sparse'`, will drop those
elements from the matrix. Default is None.
starts: list, numpy.ndarray, torch.Tensor, or None. shape=(k,), optional
The probability of starting at each node. If not provided, assumes
these probabilities are uniform. Default is None.
ends: list, numpy.ndarray, torch.Tensor, or None. shape=(k,), optional
The probability of ending at each node. If not provided, assumes
these probabilities are uniform. Default is None.
kind: str, 'sparse' or 'dense', optional
The underlying implementation of the transition matrix to use.
Default is 'sparse'.
init: str, optional
The initialization to use for the k-means initialization approach.
Default is 'first-k'. Must be one of:
'first-k': Use the first k examples from the data set
'random': Use a random set of k examples from the data set
'submodular-facility-location': Use a facility location submodular
objective to initialize the k-means algorithm
'submodular-feature-based': Use a feature-based submodular objective
to initialize the k-means algorithm.
max_iter: int, optional
The number of iterations to do in the EM step, which for HMMs is
sometimes called Baum-Welch. Default is 10.
tol: float, optional
The threshold at which to stop during fitting when the improvement
goes under. Default is 0.1.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
random_state: int or None, optional
The random state to make randomness deterministic. If None, not
deterministic. Default is None.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
verbose: bool, optional
Whether to print the improvement and timings during training.
"""
def __init__(self, distributions=None, starts=None, ends=None,
init='random', max_iter=1000, tol=0.1, sample_length=None,
return_sample_paths=False, inertia=0.0, frozen=False, check_data=True,
random_state=None, verbose=False):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.distributions = distributions
n = len(distributions) if distributions is not None else None
self.start = Silent()
self.end = Silent()
self.edges = None
self.starts = None
self.ends = None
if starts is not None:
starts = _check_parameter(_cast_as_tensor(starts), "starts", ndim=1,
shape=(n,), min_value=0., max_value=1., value_sum=1.0)
self.starts = _cast_as_parameter(torch.log(starts))
if ends is not None:
ends = _check_parameter(_cast_as_tensor(ends), "ends", ndim=1,
shape=(n,), min_value=0., max_value=1.)
self.ends = _cast_as_parameter(torch.log(ends))
if not isinstance(random_state, numpy.random.RandomState):
self.random_state = numpy.random.RandomState(random_state)
else:
self.random_state = random_state
self.init = init
self.max_iter = _check_parameter(max_iter, "max_iter", min_value=1,
ndim=0, dtypes=(int, torch.int32, torch.int64))
self.tol = _check_parameter(tol, "tol", min_value=0., ndim=0)
self.sample_length = sample_length
self.return_sample_paths = return_sample_paths
self.verbose = verbose
self.d = self.distributions[0].d if distributions is not None else None
def _initialize(self, X=None, sample_weight=None):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, len, self.d), optional
The data to use to initialize the model. Default is None.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, len) or a vector of shape (-1,). If None, defaults to ones.
Default is None.
"""
n = self.n_distributions
if self.starts is None:
self.starts = _cast_as_parameter(torch.log(torch.ones(n,
dtype=self.dtype, device=self.device) / n))
if self.ends is None:
self.ends = _cast_as_parameter(torch.log(torch.ones(n,
dtype=self.dtype, device=self.device) / n))
_init = all(d._initialized for d in self.distributions)
if X is not None and not _init:
if isinstance(X, list):
d = _cast_as_tensor(X[0]).shape[-1]
X = torch.cat([_cast_as_tensor(x).reshape(-1, d) for x in X],
dim=0).unsqueeze(0)
X = _check_parameter(_cast_as_tensor(X), "X", ndim=3,
check_parameter=self.check_data)
X = X.reshape(-1, X.shape[-1])
if sample_weight is None:
sample_weight = torch.ones(1, dtype=self.dtype,
device=self.device).to(X.device).expand(X.shape[0], 1)
else:
if isinstance(sample_weight, list):
sample_weight = torch.cat([_cast_as_tensor(w).reshape(-1, 1)
for w in sample_weight], dim=0).to(X.device)
sample_weight = _check_parameter(_cast_as_tensor(
sample_weight).reshape(-1, 1), "sample_weight",
min_value=0., ndim=1, shape=(len(X),),
check_parameter=self.check_data).reshape(-1, 1)
model = KMeans(self.n_distributions, init=self.init, max_iter=1,
random_state=self.random_state).to(self.device)
y_hat = model.fit_predict(X, sample_weight=sample_weight)
for i in range(self.n_distributions):
self.distributions[i].fit(X[y_hat == i].cpu(),
sample_weight=sample_weight[y_hat == i].cpu())
self.distributions[i].to(X.device)
self.d = X.shape[-1]
super()._initialize(X.shape[-1])
self._initialized = True
self._reset_cache()
def _emission_matrix(self, X, priors=None):
"""Return the emission/responsibility matrix.
This method returns the log probability of each example under each
distribution contained in the model with the log prior probability
of each component added.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, len, self.d)
A set of examples to evaluate.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
e: torch.Tensor, shape=(-1, len, self.k)
A set of log probabilities for each example under each distribution.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=3,
shape=(-1, -1, self.d), check_parameter=self.check_data)
n, k, _ = X.shape
X = X.reshape(n*k, self.d)
priors = _check_parameter(_cast_as_tensor(priors), "priors",
ndim=3, shape=(n, k, self.k), min_value=0.0, max_value=1.0,
value_sum=1.0, value_sum_dim=-1, check_parameter=self.check_data)
if not self._initialized:
self._initialize()
e = torch.empty((k, self.k, n), dtype=self.dtype, requires_grad=False,
device=self.device)
for i, node in enumerate(self.distributions):
logp = node.log_probability(X)
if isinstance(logp, torch.masked.MaskedTensor):
logp = logp._masked_data
e[:, i] = logp.reshape(n, k).T
e = e.permute(2, 0, 1)
if priors is not None:
e += torch.log(priors)
return e
@property
def k(self):
return len(self.distributions) if self.distributions is not None else 0
@property
def n_distributions(self):
return len(self.distributions) if self.distributions is not None else 0
def freeze(self):
"""Freeze this model and all child distributions."""
self.register_buffer("frozen", _cast_as_tensor(True))
for d in self.distributions:
d.freeze()
return self
def unfreeze(self):
"""Unfreeze this model and all child distributions."""
self.register_buffer("frozen", _cast_as_tensor(False))
for d in self.distributions:
d.unfreeze()
return self
def add_distribution(self, distribution):
"""Add a distribution to the model.
Parameters
----------
distribution: torchegranate.distributions.Distribution
A distribution object.
"""
if self.distributions is None:
self.distributions = []
if not isinstance(distribution, Distribution):
raise ValueError("distribution must be a distribution object.")
self.distributions.append(distribution)
self.d = distribution.d
def add_distributions(self, distributions):
"""Add a set of distributions to the model.
This method will iterative call the `add_distribution`.
Parameters
----------
distributions: list, tuple, iterable
A set of distributions to add to the model.
"""
for distribution in distributions:
self.add_distribution(distribution)
def add_edge(self, start, end, probability):
"""Add an edge to the model.
This method takes in two distribution objects and the probability
connecting the two and adds an edge to the model.
Parameters
----------
start: torchegranate.distributions.Distribution
The parent node for the edge
end: torchegranate.distributions.Distribution
The child node for the edge
probability: float, (0, 1]
The probability of connecting the two.
"""
if not isinstance(start, Distribution):
raise ValueError("start must be a distribution.")
if not isinstance(end, Distribution):
raise ValueError("end must be a distribution.")
if not isinstance(probability, float):
raise ValueError("probability must be a float.")
if self.edges is None:
self.edges = []
self.edges.append((start, end, probability))
def probability(self, X, priors=None):
"""Calculate the probability of each example.
This method calculates the probability of each example given the
parameters of the distribution. The examples must be given in a 3D
format.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, length, self.d)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities).
Returns
-------
prob: torch.Tensor, shape=(-1,)
The probability of each example.
"""
return torch.exp(self.log_probability(X, priors=priors))
def log_probability(self, X, priors=None):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 3D
format.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, length, self.d)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities).
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
f = self.forward(X, priors=priors)
return torch.logsumexp(f[:, -1] + self.ends, dim=1)
def predict_log_proba(self, X, priors=None):
"""Calculate the posterior probabilities for each example.
This method calculates the log posterior probabilities for each example
and then normalizes across each component of the model. These
probabilities are calculated using the forward-backward algorithm.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, len, self.d)
A set of examples to summarize.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, len, self.n_distributions)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities).
Returns
-------
r: torch.Tensor, shape=(-1, len, self.n_distributions)
The log posterior probabilities for each example under each
component as calculated by the forward-backward algorithm.
"""
_, r, _, _, _ = self.forward_backward(X, priors=priors)
return r
def predict_proba(self, X, priors=None):
"""Calculate the posterior probabilities for each example.
This method calculates the posterior probabilities for each example
and then normalizes across each component of the model. These
probabilities are calculated using the forward-backward algorithm.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, len, self.d)
A set of examples to summarize.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, len, self.n_distributions)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities).
Returns
-------
y: torch.Tensor, shape=(-1, len, self.n_distributions)
The posterior probabilities for each example under each component
as calculated by the forward-backward algorithm.
"""
return torch.exp(self.predict_log_proba(X, priors=priors))
def predict(self, X, priors=None):
"""Predicts the component for each observation.
This method calculates the predicted component for each observation
given the posterior probabilities as calculated by the forward-backward
algorithm. Essentially, it is just the argmax over components.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, len, self.d)
A set of examples to summarize.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, length, self.d)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities).
Returns
-------
y: torch.Tensor, shape=(-1, len, self.k)
The posterior probabilities for each example under each component
as calculated by the forward-backward algorithm.
"""
return torch.argmax(self.predict_log_proba(X, priors=priors), dim=-1)
def fit(self, X, sample_weight=None, priors=None):
"""Fit the model to sequences with optional weights and priors.
This method implements the core of the learning process. For hidden
Markov models, this is a form of EM called "Baum-Welch" or "structured
EM". This iterative algorithm will proceed until converging, either
according to the threshold set by `tol` or until the maximum number
of iterations set by `max_iter` has been hit.
This method is largely a wrapper around the `summarize` and
`from_summaries` methods. It's primary contribution is serving as a
loop around these functions and to monitor convergence.
Unlike other HMM methods, this method can handle variable length
sequences by accepting a list of tensors where each tensor has a
different sequence length. Then, summarization is done on each tensor
sequentially. This will provide an exact update as if the entire data
set was seen at the same time but will allow batched operations to be
performed on each variable length tensor.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, len, self.d)
A set of examples to evaluate. Because sequences can be variable
length, there are three ways to format the sequences.
1. Pass in a tensor of shape (n, length, dim), which can only
be done when each sequence is the same length.
2. Pass in a list of 3D tensors where each tensor has the shape
(n, length, dim). In this case, each tensor is a collection of
sequences of the same length and so sequences of different
lengths can be trained on.
3. Pass in a list of 2D tensors where each tensor has the shape
(length, dim). In this case, sequences of the same length will
be grouped together into the same tensor and fitting will
proceed as if you had passed in data like way 2.
sample_weight: list, numpy.ndarray, torch.Tensor or None, optional
A set of weights for the examples. These must follow the same format
as X.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observations
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Must be formatted in the same
shape as X. Default is None.
Returns
-------
self
"""
X, sample_weight, priors = partition_sequences(X,
sample_weight=sample_weight, priors=priors, n_dists=self.k)
# Initialize by concatenating across sequences
if not self._initialized:
if sample_weight is None:
self._initialize(X)
else:
self._initialize(X, sample_weight=sample_weight)
logp, last_logp = None, None
for i in range(self.max_iter):
start_time = time.time()
# Train loop across all tensors
logp = 0
for j, X_ in enumerate(X):
w_ = None if sample_weight is None else sample_weight[j]
p_ = None if priors is None else priors[j]
logp += self.summarize(X_, sample_weight=w_, priors=p_).sum()
# Calculate and check improvement and optionally print it
if i > 0:
improvement = logp - last_logp
duration = time.time() - start_time
if self.verbose:
print("[{}] Improvement: {}, Time: {:4.4}s".format(i,
improvement, duration))
if improvement < self.tol:
self._reset_cache()
return self
last_logp = logp
self.from_summaries()
# Calculate for the last iteration
if self.verbose:
logp = 0
for j, X_ in enumerate(X):
w_ = None if sample_weight is None else sample_weight[j]
p_ = None if priors is None else priors[j]
logp += self.summarize(X_, sample_weight=w_, priors=p_).sum()
improvement = logp - last_logp
duration = time.time() - start_time
print("[{}] Improvement: {}, Time: {:4.4}s".format(i+1,
improvement, duration))
self._reset_cache()
return self
def summarize(self, X, sample_weight=None, emissions=None,
priors=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, len, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, length, self.d) or a vector of shape (-1,). Default is ones.
emissions: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, n_distributions)
Precalculated emission log probabilities. These are the
probabilities of each observation under each probability
distribution. When running some algorithms it is more efficient
to precalculate these and pass them into each call.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, len, self.n_distributions)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities).
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=3,
shape=(-1, -1, self.d), check_parameter=self.check_data)
emissions = _check_inputs(self, X, emissions, priors)
if sample_weight is None:
sample_weight = torch.ones(1, device=self.device).expand(
emissions.shape[0], 1)
else:
sample_weight = _check_parameter(_cast_as_tensor(sample_weight),
"sample_weight", min_value=0., ndim=1,
shape=(emissions.shape[0],),
check_parameter=self.check_data).reshape(-1, 1)
if not self._initialized:
self._initialize(X, sample_weight=sample_weight)
return X, emissions, sample_weight
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
self.from_summaries()
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/hmm/dense_hmm.py 0000664 0000000 0000000 00000056776 14643672530 0023754 0 ustar 00root root 0000000 0000000 # dense_hmm.py
# Author: Jacob Schreiber
import math
import numpy
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from ..distributions._distribution import Distribution
from ._base import _BaseHMM
from ._base import _check_inputs
NEGINF = float("-inf")
inf = float("inf")
class DenseHMM(_BaseHMM):
"""A hidden Markov model with a dense transition matrix.
A hidden Markov model is an extension of a mixture model to sequences by
including a transition matrix between the elements of the mixture. Each of
the algorithms for a hidden Markov model are essentially just a revision
of those algorithms to incorporate this transition matrix.
This object is a wrapper for a hidden Markov model with a dense transition
matrix.
This object is a wrapper for both implementations, which can be specified
using the `kind` parameter. Choosing the right implementation will not
effect the accuracy of the results but will change the speed at which they
are calculated.
Separately, there are two ways to instantiate the hidden Markov model. The
first is by passing in a set of distributions, a dense transition matrix,
and optionally start/end probabilities. The second is to initialize the
object without these and then to add edges using the `add_edge` method
and to add distributions using the `add_distributions` method. Importantly, the way that
you choose to initialize the hidden Markov model is independent of the
implementation that you end up choosing. If you pass in a dense transition
matrix, this will be converted to a sparse matrix with all the zeros
dropped if you choose `kind='sparse'`.
Parameters
----------
distributions: tuple or list
A set of distribution objects. These objects do not need to be
initialized, i.e., can be "Normal()".
edges: numpy.ndarray, torch.Tensor, or None. shape=(k,k), optional
A dense transition matrix of probabilities for how each node or
distribution passed in connects to each other one. This can contain
many zeroes, and when paired with `kind='sparse'`, will drop those
elements from the matrix.
starts: list, numpy.ndarray, torch.Tensor, or None. shape=(k,), optional
The probability of starting at each node. If not provided, assumes
these probabilities are uniform.
ends: list, numpy.ndarray, torch.Tensor, or None. shape=(k,), optional
The probability of ending at each node. If not provided, assumes
these probabilities are uniform.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling. Default is True.
"""
def __init__(self, distributions=None, edges=None, starts=None, ends=None,
init='random', max_iter=1000, tol=0.1, sample_length=None,
return_sample_paths=False, inertia=0.0, frozen=False, check_data=True,
random_state=None, verbose=False):
super().__init__(distributions=distributions, starts=starts, ends=ends,
init=init, max_iter=max_iter, tol=tol, sample_length=sample_length,
return_sample_paths=return_sample_paths, inertia=inertia,
frozen=frozen, check_data=check_data, random_state=random_state,
verbose=verbose)
self.name = "DenseHMM"
n = len(distributions) if distributions is not None else 0
if edges is not None:
self.edges = _cast_as_parameter(torch.log(_check_parameter(
_cast_as_tensor(edges), "edges", ndim=2, shape=(n, n),
min_value=0., max_value=1.)))
self._initialized = (self.distributions is not None and
self.starts is not None and self.ends is not None and
self.edges is not None and
all(d._initialized for d in self.distributions))
if self._initialized:
self.distributions = torch.nn.ModuleList(
self.distributions)
self._reset_cache()
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
for node in self.distributions:
node._reset_cache()
self.register_buffer("_xw_sum", torch.zeros(self.n_distributions,
self.n_distributions, dtype=self.dtype, requires_grad=False,
device=self.device))
self.register_buffer("_xw_starts_sum", torch.zeros(self.n_distributions,
dtype=self.dtype, requires_grad=False, device=self.device))
self.register_buffer("_xw_ends_sum", torch.zeros(self.n_distributions,
dtype=self.dtype, requires_grad=False, device=self.device))
def _initialize(self, X=None, sample_weight=None):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, len, self.d), optional
The data to use to initialize the model. Default is None.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, len) or a vector of shape (-1,). If None, defaults to ones.
Default is None.
"""
super()._initialize(X, sample_weight=sample_weight)
n = self.n_distributions
if self.edges == None:
self.edges = _cast_as_parameter(torch.log(torch.ones(n, n,
dtype=self.dtype, device=self.device) / n))
self.distributions = torch.nn.ModuleList(self.distributions)
def add_edge(self, start, end, prob):
"""Add an edge to the model.
This method will fill in an entry in the dense transition matrix
at row indexed by the start distribution and the column indexed
by the end distribution. The value that will be included is the
log of the probability value provided. Note that this will override
values that already exist, and that this will initialize a new
dense transition matrix if none has been passed in so far.
Parameters
----------
start: torch.distributions.distribution
The distribution that the edge starts at.
end: torch.distributions.distribution
The distribution that the edge ends at.
prob: float, (0.0, 1.0]
The probability of that edge.
"""
if self.distributions is None:
raise ValueError("Must add distributions before edges.")
n = self.n_distributions
if start == self.start:
if self.starts is None:
self.starts = torch.empty(n, dtype=self.dtype,
device=self.device) - inf
idx = self.distributions.index(end)
self.starts[idx] = math.log(prob)
elif end == self.end:
if self.ends is None:
self.ends = torch.empty(n, dtype=self.dtype,
device=self.device) - inf
idx = self.distributions.index(start)
self.ends[idx] = math.log(prob)
else:
if self.edges is None:
self.edges = torch.empty((n, n), dtype=self.dtype,
device=self.device) - inf
idx1 = self.distributions.index(start)
idx2 = self.distributions.index(end)
self.edges[idx1, idx2] = math.log(prob)
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution. Because a HMM describes variable length
sequences, a list will be returned where each element is one of
the generated sequences.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: list of torch.tensor, shape=(n,)
A list of randomly generated samples, where each sample of
size (length, self.d).
"""
if self.sample_length is None and self.ends is None:
raise ValueError("Must specify a length or have explicit "
+ "end probabilities.")
if self.ends is None:
ends = torch.zeros(self.n_distributions, dtype=self.edges.dtype,
device=self.edges.device) + float("-inf")
else:
ends = self.ends
distributions, emissions = [], []
edge_probs = torch.hstack([self.edges, ends.unsqueeze(1)])
edge_probs = torch.exp(edge_probs).numpy()
starts = torch.exp(self.starts).numpy()
for _ in range(n):
node_i = self.random_state.choice(self.n_distributions, p=starts)
emission_i = self.distributions[node_i].sample(n=1)
distributions_, emissions_ = [node_i], [emission_i]
for i in range(1, self.sample_length or int(1e8)):
node_i = self.random_state.choice(self.n_distributions+1,
p=edge_probs[node_i])
if node_i == self.n_distributions:
break
emission_i = self.distributions[node_i].sample(n=1)
distributions_.append(node_i)
emissions_.append(emission_i)
distributions.append(distributions_)
emissions.append(torch.vstack(emissions_))
if self.return_sample_paths == True:
return emissions, distributions
return emissions
def viterbi(self, X=None, emissions=None, priors=None):
"""Run the Viterbi algorithm on some data.
Runs the Viterbi algortihm on a batch of sequences. The Viterbi
algorithm is a dynamic programming algorithm that begins at the start
state and calculates the single best path through the model involving
alignments of symbol i to node j. This is in contrast to the forward
function, which involves calculating the sum of all paths, not just
the single best path. Because we have to keep track of the best path,
the Viterbi algorithm is slightly more conceptually challenging and
involves keeping track of a traceback matrix.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, d)
A set of examples to evaluate. Does not need to be passed in if
emissions are.
emissions: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, n_dists)
Precalculated emission log probabilities. These are the
probabilities of each observation under each probability
distribution. When running some algorithms it is more efficient
to precalculate these and pass them into each call.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
path: torch.Tensor, shape=(-1, -1)
The state assignment for each observation in each sequence.
"""
emissions = _check_inputs(self, X, emissions, priors)
n, l = emissions.shape[:2]
v = torch.clone(emissions.permute(1, 0, 2)).contiguous()
v[0] += self.starts
traceback = torch.zeros_like(v, dtype=torch.int32)
traceback[0] = torch.arange(v.shape[-1])
for i in range(1, l):
z = v[i-1].unsqueeze(-1) + self.edges.unsqueeze(0) + v[i][:, None]
v[i], traceback[i] = torch.max(z, dim=-2)
ends = self.ends + v[-1]
best_end_logps, best_end_idxs = torch.max(ends, dim=-1)
paths = [best_end_idxs]
for i in range(1, l):
paths.append(traceback[l-i, torch.arange(n), paths[-1]])
paths = torch.flip(torch.stack(paths).T, dims=(-1,))
return paths
def forward(self, X=None, emissions=None, priors=None):
"""Run the forward algorithm on some data.
Runs the forward algorithm on a batch of sequences. This is not to be
confused with a "forward pass" when talking about neural networks. The
forward algorithm is a dynamic programming algorithm that begins at the
start state and returns the probability, over all paths through the
model, that result in the alignment of symbol i to node j.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, d)
A set of examples to evaluate. Does not need to be passed in if
emissions are.
emissions: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, n_dists)
Precalculated emission log probabilities. These are the
probabilities of each observation under each probability
distribution. When running some algorithms it is more efficient
to precalculate these and pass them into each call.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
f: torch.Tensor, shape=(-1, -1, self.n_distributions)
The log probabilities calculated by the forward algorithm.
"""
emissions = _check_inputs(self, X, emissions, priors)
l = emissions.shape[1]
t_max = self.edges.max()
t = torch.exp(self.edges - t_max)
f = torch.clone(emissions.permute(1, 0, 2)).contiguous()
f[0] += self.starts
f[1:] += t_max
for i in range(1, l):
p_max = torch.max(f[i-1], dim=1, keepdims=True).values
p = torch.exp(f[i-1] - p_max)
f[i] += torch.log(torch.matmul(p, t)) + p_max
f = f.permute(1, 0, 2)
return f
def backward(self, X=None, emissions=None, priors=None):
"""Run the backward algorithm on some data.
Runs the backward algorithm on a batch of sequences. This is not to be
confused with a "backward pass" when talking about neural networks. The
backward algorithm is a dynamic programming algorithm that begins at end
of the sequence and returns the probability, over all paths through the
model, that result in the alignment of symbol i to node j, working
backwards.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, d)
A set of examples to evaluate. Does not need to be passed in if
emissions are.
emissions: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, n_distributions)
Precalculated emission log probabilities. These are the
probabilities of each observation under each probability
distribution. When running some algorithms it is more efficient
to precalculate these and pass them into each call.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
b: torch.Tensor, shape=(-1, length, self.n_distributions)
The log probabilities calculated by the backward algorithm.
"""
emissions = _check_inputs(self, X, emissions, priors)
n, l, _ = emissions.shape
b = torch.zeros(l, n, self.n_distributions, dtype=self.dtype,
device=self.device) + float("-inf")
b[-1] = self.ends
t_max = self.edges.max()
t = torch.exp(self.edges.T - t_max)
for i in range(l-2, -1, -1):
p = b[i+1] + emissions[:, i+1]
p_max = torch.max(p, dim=1, keepdims=True).values
p = torch.exp(p - p_max)
b[i] = torch.log(torch.matmul(p, t)) + t_max + p_max
b = b.permute(1, 0, 2)
return b
def forward_backward(self, X=None, emissions=None, priors=None):
"""Run the forward-backward algorithm on some data.
Runs the forward-backward algorithm on a batch of sequences. This
algorithm combines the best of the forward and the backward algorithm.
It combines the probability of starting at the beginning of the sequence
and working your way to each observation with the probability of
starting at the end of the sequence and working your way backward to it.
A number of statistics can be calculated using this information. These
statistics are powerful inference tools but are also used during the
Baum-Welch training process.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, d)
A set of examples to evaluate. Does not need to be passed in if
emissions are.
emissions: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, n_distributions)
Precalculated emission log probabilities. These are the
probabilities of each observation under each probability
distribution. When running some algorithms it is more efficient
to precalculate these and pass them into each call.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
transitions: torch.Tensor, shape=(-1, n, n)
The expected number of transitions across each edge that occur
for each example. The returned transitions follow the structure
of the transition matrix and so will be dense or sparse as
appropriate.
responsibility: torch.Tensor, shape=(-1, -1, n)
The posterior probabilities of each observation belonging to each
state given that one starts at the beginning of the sequence,
aligns observations across all paths to get to the current
observation, and then proceeds to align all remaining observations
until the end of the sequence.
starts: torch.Tensor, shape=(-1, n)
The probabilities of starting at each node given the
forward-backward algorithm.
ends: torch.Tensor, shape=(-1, n)
The probabilities of ending at each node given the forward-backward
algorithm.
logp: torch.Tensor, shape=(-1,)
The log probabilities of each sequence given the model.
"""
emissions = _check_inputs(self, X, emissions, priors)
n, l, _ = emissions.shape
f = self.forward(emissions=emissions)
b = self.backward(emissions=emissions)
logp = torch.logsumexp(f[:, -1] + self.ends, dim=1)
f_ = f[:, :-1].unsqueeze(-1)
b_ = (b[:, 1:] + emissions[:, 1:]).unsqueeze(-2)
t = f_ + b_ + self.edges.unsqueeze(0).unsqueeze(0)
t = t.reshape(n, l-1, -1)
t = torch.exp(torch.logsumexp(t, dim=1).T - logp).T
t = t.reshape(n, int(t.shape[1] ** 0.5), -1)
starts = self.starts + emissions[:, 0] + b[:, 0]
starts = torch.exp(starts.T - torch.logsumexp(starts, dim=-1)).T
ends = self.ends + f[:, -1]
ends = torch.exp(ends.T - torch.logsumexp(ends, dim=-1)).T
r = f + b
r = r - torch.logsumexp(r, dim=2).reshape(n, -1, 1)
return t, r, starts, ends, logp
def summarize(self, X, sample_weight=None, emissions=None, priors=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: torch.Tensor, shape=(-1, -1, self.d)
A set of examples to summarize.
y: torch.Tensor, shape=(-1, -1), optional
A set of labels with the same number of examples and length as the
observations that indicate which node in the model that each
observation should be assigned to. Passing this in means that the
model uses labeled training instead of Baum-Welch. Default is None.
sample_weight: torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
emissions: torch.Tensor, shape=(-1, -1, self.n_distributions)
Precalculated emission log probabilities. These are the
probabilities of each observation under each probability
distribution. When running some algorithms it is more efficient
to precalculate these and pass them into each call.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
"""
X, emissions, sample_weight = super().summarize(X,
sample_weight=sample_weight, emissions=emissions, priors=priors)
t, r, starts, ends, logps = self.forward_backward(emissions=emissions)
X = X.reshape(-1, X.shape[-1])
r = torch.exp(r) * sample_weight.unsqueeze(-1)
for i, node in enumerate(self.distributions):
w = r[:, :, i].reshape(-1, 1)
node.summarize(X, sample_weight=w)
if self.frozen == False:
self._xw_starts_sum += torch.sum(starts * sample_weight, dim=0)
self._xw_ends_sum += torch.sum(ends * sample_weight, dim=0)
self._xw_sum += torch.sum(t * sample_weight.unsqueeze(-1), dim=0)
return logps
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
for node in self.distributions:
node.from_summaries()
if self.frozen:
return
node_out_count = torch.sum(self._xw_sum, dim=1, keepdims=True)
node_out_count += self._xw_ends_sum.unsqueeze(1)
ends = torch.log(self._xw_ends_sum / node_out_count[:,0])
starts = torch.log(self._xw_starts_sum / self._xw_starts_sum.sum())
edges = torch.log(self._xw_sum / node_out_count)
_update_parameter(self.ends, ends, inertia=self.inertia)
_update_parameter(self.starts, starts, inertia=self.inertia)
_update_parameter(self.edges, edges, inertia=self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/hmm/sparse_hmm.py 0000664 0000000 0000000 00000064043 14643672530 0024135 0 ustar 00root root 0000000 0000000 # _sparse_hmm.py
# Author: Jacob Schreiber
import math
import numpy
import torch
from .._utils import _cast_as_tensor
from .._utils import _cast_as_parameter
from .._utils import _update_parameter
from .._utils import _check_parameter
from ..distributions._distribution import Distribution
from ._base import _BaseHMM
from ._base import _check_inputs
NEGINF = float("-inf")
inf = float("inf")
def unpack_edges(self, edges, starts, ends):
"""Unpack the edges for a sparse hidden Markov model.
This function takes in a SparseHMM object and sets of edges and adds the
edges to the model. It is designed to allow the model to be initialized
either through passing in the edges initially or created through the
`add_edge` API. Doing this is slightly more complicated than in the
DenseHMM case because we use an underlying sparse representation to store
the edges and so cannot as easily simply modify a random element in each
call to `add_edge`.
Parameters
----------
self: SparseHMM
A torchegranate sparse HMM.
edges: list
A list of 3-ples that consist of the parent distribution, the child
distribution, and the probability on that edge.
starts: list, tuple, numpy.ndarray, torch.tensor
A vector of probabilities indicating the probability of starting in
each state. Must sum to 1.0.
ends: list, tuple, numpy.ndarray, torch.tensor
A vector of probabilities indicating the probability of ending at
each state. Does not have to sum to 1.0.
"""
self.n_edges = len(edges)
n = len(self.distributions)
self.starts = None
if starts is not None:
starts = _check_parameter(_cast_as_tensor(starts), "starts", ndim=1,
shape=(n,), min_value=0., max_value=1., value_sum=1.0)
self.starts = _cast_as_parameter(torch.log(starts))
if ends is None:
self.ends = torch.empty(n, dtype=self.dtype, device=self.device) - inf
else:
ends = _check_parameter(_cast_as_tensor(ends), "ends", ndim=1,
shape=(n,), min_value=0., max_value=1.)
self.ends = _cast_as_parameter(torch.log(ends))
_edge_idx_starts = torch.empty(self.n_edges, dtype=torch.int64,
device=self.device)
_edge_idx_ends = torch.empty(self.n_edges, dtype=torch.int64,
device=self.device)
_edge_log_probs = torch.empty(self.n_edges, dtype=self.dtype,
device=self.device)
idx = 0
for edge in edges:
if not hasattr(edge, "__len__") or len(edge) != 3:
raise ValueError("Each edge must have three elements.")
ni, nj, probability = edge
if not isinstance(ni, Distribution):
raise ValueError("First element must be a distribution.")
if not isinstance(nj, Distribution):
raise ValueError("Second element must be a distribution.")
if not isinstance(probability, float):
raise ValueError("Third element must be a float.")
if probability < 0 or probability > 1:
raise ValueError("Third element must be between 0 and 1.")
if ni is self.start:
if self.starts is None:
self.starts = torch.zeros(n, dtype=self.dtype,
device=self.device) - inf
j = self.distributions.index(nj)
self.starts[j] = math.log(probability)
elif nj is self.end:
i = self.distributions.index(ni)
self.ends[i] = math.log(probability)
else:
i = self.distributions.index(ni)
j = self.distributions.index(nj)
_edge_idx_starts[idx] = i
_edge_idx_ends[idx] = j
_edge_log_probs[idx] = math.log(probability)
idx += 1
self._edge_idx_starts = _cast_as_parameter(_edge_idx_starts[:idx])
self._edge_idx_ends = _cast_as_parameter(_edge_idx_ends[:idx])
self._edge_log_probs = _cast_as_parameter(_edge_log_probs[:idx])
self.n_edges = idx
self.edges = self._edge_log_probs
if idx == 0:
raise ValueError("Must pass in edges to a sparse model, cannot " +
"be uniformly initialized or it would be a dense model.")
self._edge_keymap = {}
for i in range(idx):
start = self._edge_idx_starts[i].item()
end = self._edge_idx_ends[i].item()
self._edge_keymap[(start, end)] = i
if self.starts is None:
self.starts = torch.log(torch.ones(n, dtype=self.dtype,
device=self.device) / n)
self.starts = _cast_as_parameter(self.starts)
self.ends = _cast_as_parameter(self.ends)
class SparseHMM(_BaseHMM):
"""A hidden Markov model with a sparse transition matrix.
A hidden Markov model is an extension of a mixture model to sequences by
including a transition matrix between the elements of the mixture. Each of
the algorithms for a hidden Markov model are essentially just a revision
of those algorithms to incorporate this transition matrix.
This object is a wrapper for a hidden Markov model with a sparse transition
matrix.
Separately, there are two ways to instantiate the hidden Markov model. The
first is by passing in a set of distributions, a dense transition matrix,
and optionally start/end probabilities. The second is to initialize the
object without these and then to add edges using the `add_edge` method
and to add distributions using the `add_distributions` method. Importantly,
the way that you choose to initialize the hidden Markov model is independent of the
implementation that you end up choosing. If you pass in a dense transition
matrix, this will be converted to a sparse matrix with all the zeros
dropped if you choose `kind='sparse'`.
Parameters
----------
distributions: tuple or list
A set of distribution objects. These objects do not need to be
initialized, i.e., can be "Normal()".
edges: numpy.ndarray, torch.Tensor, or None. shape=(k,k)
A dense transition matrix of probabilities for how each node or
distribution passed in connects to each other one. This can contain
many zeroes, and when paired with `kind='sparse'`, will drop those
elements from the matrix.
starts: list, numpy.ndarray, torch.Tensor, or None. shape=(k,)
The probability of starting at each node. If not provided, assumes
these probabilities are uniform.
ends: list, numpy.ndarray, torch.Tensor, or None. shape=(k,)
The probability of ending at each node. If not provided, assumes
these probabilities are uniform.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, distributions=None, edges=None, starts=None, ends=None,
init='random', max_iter=1000, tol=0.1, sample_length=None,
return_sample_paths=False, inertia=0.0, frozen=False, check_data=True,
random_state=None, verbose=False):
super().__init__(distributions=distributions, starts=starts, ends=ends,
init=init, max_iter=max_iter, tol=tol, sample_length=sample_length,
return_sample_paths=return_sample_paths, inertia=inertia,
frozen=frozen, check_data=check_data, random_state=random_state,
verbose=verbose)
self.name = "SparseHMM"
if edges is not None:
unpack_edges(self, edges, starts, ends)
self.n_edges = len(edges)
self._initialized = False
if self.distributions is not None:
if self.ends is not None:
if self.starts is not None:
if all(d._initialized for d in self.distributions):
self._initialized = True
self.distributions = torch.nn.ModuleList(
self.distributions)
self._reset_cache()
def _initialize(self, X=None, sample_weight=None):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, len, self.d), optional
The data to use to initialize the model. Default is None.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, len) or a vector of shape (-1,). If None, defaults to ones.
Default is None.
"""
n = self.n_distributions
if not hasattr(self, "_edge_log_probs"):
unpack_edges(self, self.edges, self.starts, self.ends)
self.n_edges = len(self.edges)
self.distributions = torch.nn.ModuleList(self.distributions)
super()._initialize(X, sample_weight=sample_weight)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
for node in self.distributions:
node._reset_cache()
self.register_buffer("_xw_sum", torch.zeros(self.n_edges,
dtype=self.dtype, device=self.device))
self.register_buffer("_xw_starts_sum", torch.zeros(
self.n_distributions, dtype=self.dtype, device=self.device))
self.register_buffer("_xw_ends_sum", torch.zeros(
self.n_distributions, dtype=self.dtype, device=self.device))
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution. Because a HMM describes variable length
sequences, a list will be returned where each element is one of
the generated sequences.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: list of torch.tensor, shape=(n,)
A list of randomly generated samples, where each sample of
size (length, self.d).
"""
if self.sample_length is None and self.ends is None:
raise ValueError("Must specify a length or have explicit "
+ "end probabilities.")
if self.ends is None:
ends = torch.zeros(self.n_distributions,
dtype=self._edge_log_probs.dtype,
device=self._edge_log_probs.device) + float("-inf")
else:
ends = self.ends
distributions, emissions = [], []
edge_ends, edge_probs = [], []
for idx in range(self.n_distributions):
idxs = self._edge_idx_starts == idx
_ends = numpy.concatenate([self._edge_idx_ends[idxs].numpy(),
[self.n_distributions]])
_probs = numpy.concatenate([torch.exp(self._edge_log_probs[idxs]
).numpy(), [numpy.exp(ends[idx])]])
edge_ends.append(_ends)
edge_probs.append(_probs)
starts = torch.exp(self.starts).numpy()
for _ in range(n):
node_i = self.random_state.choice(self.n_distributions, p=starts)
emission_i = self.distributions[node_i].sample(n=1)
distributions_, emissions_ = [node_i], [emission_i]
for i in range(1, self.sample_length or int(1e8)):
node_i = self.random_state.choice(edge_ends[node_i], p=edge_probs[node_i])
if node_i == self.n_distributions:
break
emission_i = self.distributions[node_i].sample(n=1)
distributions_.append(node_i)
emissions_.append(emission_i)
distributions.append(distributions_)
emissions.append(torch.vstack(emissions_))
if self.return_sample_paths == True:
return emissions, distributions
return emissions
def viterbi(self, X=None, emissions=None, priors=None):
"""Run the Viterbi algorithm on some data.
Runs the Viterbi algortihm on a batch of sequences. The Viterbi
algorithm is a dynamic programming algorithm that begins at the start
state and calculates the single best path through the model involving
alignments of symbol i to node j. This is in contrast to the forward
function, which involves calculating the sum of all paths, not just
the single best path. Because we have to keep track of the best path,
the Viterbi algorithm is slightly more conceptually challenging and
involves keeping track of a traceback matrix.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, d)
A set of examples to evaluate. Does not need to be passed in if
emissions are.
emissions: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, n_dists)
Precalculated emission log probabilities. These are the
probabilities of each observation under each probability
distribution. When running some algorithms it is more efficient
to precalculate these and pass them into each call.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
path: torch.Tensor, shape=(-1, -1)
The state assignment for each observation in each sequence.
"""
emissions = _check_inputs(self, X, emissions, priors)
n, l = emissions.shape[:2]
v = torch.full((l, n, self.n_distributions), -inf,
dtype=emissions.dtype, device=self.device)
v[0] = self.starts + emissions[:, 0]
traceback = torch.zeros_like(v, dtype=torch.int32)
traceback[0] = torch.arange(v.shape[-1])
idxs = [torch.where(self._edge_idx_ends == i)[0] for i in
range(self.n_distributions)]
for i in range(1, l):
p = v[i-1, :, self._edge_idx_starts]
p += self._edge_log_probs.expand(n, -1)
p += emissions[:, i, self._edge_idx_ends]
# This should be something like
# maxs, argmaxs = torch.scatter_max(...)
# but that isn't implemented yet. Hopefully will come soon because
# pytorch-scatter is too difficult to install.
for j, idx in enumerate(idxs):
v[i, :, j], _idx = torch.max(p[:, idx], dim=-1)
traceback[i, :, j] = self._edge_idx_starts[idx][_idx]
ends = self.ends + v[-1]
best_end_logps, best_end_idxs = torch.max(ends, dim=-1)
paths = [best_end_idxs]
for i in range(1, l):
paths.append(traceback[l-i, torch.arange(n), paths[-1]])
paths = torch.flip(torch.stack(paths).T, dims=(-1,))
return paths
def forward(self, X=None, emissions=None, priors=None):
"""Run the forward algorithm on some data.
Runs the forward algorithm on a batch of sequences. This is not to be
confused with a "forward pass" when talking about neural networks. The
forward algorithm is a dynamic programming algorithm that begins at the
start state and returns the probability, over all paths through the
model, that result in the alignment of symbol i to node j.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, d)
A set of examples to evaluate. Does not need to be passed in if
emissions are.
emissions: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, n_distributions)
Precalculated emission log probabilities. These are the
probabilities of each observation under each probability
distribution. When running some algorithms it is more efficient
to precalculate these and pass them into each call.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
f: torch.Tensor, shape=(-1, -1, self.n_distributions)
The log probabilities calculated by the forward algorithm.
"""
emissions = _check_inputs(self, X, emissions, priors)
n, l, _ = emissions.shape
f = torch.full((l, n, self.n_distributions), -inf, dtype=torch.float32,
device=self.device)
f[0] = self.starts + emissions[:, 0]
for i in range(1, l):
p = f[i-1, :, self._edge_idx_starts]
p += self._edge_log_probs.expand(n, -1)
alpha = torch.max(p, dim=1, keepdims=True).values
p = torch.exp(p - alpha)
z = torch.zeros_like(f[i])
z.scatter_add_(1, self._edge_idx_ends.expand(n, -1), p)
f[i] = alpha + torch.log(z) + emissions[:, i]
f = f.permute(1, 0, 2)
return f
def backward(self, X=None, emissions=None, priors=None):
"""Run the backward algorithm on some data.
Runs the backward algorithm on a batch of sequences. This is not to be
confused with a "backward pass" when talking about neural networks. The
backward algorithm is a dynamic programming algorithm that begins at end
of the sequence and returns the probability, over all paths through the
model, that result in the alignment of symbol i to node j, working
backwards.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, d)
A set of examples to evaluate. Does not need to be passed in if
emissions are.
emissions: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, n_distributions)
Precalculated emission log probabilities. These are the
probabilities of each observation under each probability
distribution. When running some algorithms it is more efficient
to precalculate these and pass them into each call.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
b: torch.Tensor, shape=(-1, length, self.n_distributions)
The log probabilities calculated by the backward algorithm.
"""
emissions = _check_inputs(self, X, emissions, priors)
n, l, _ = emissions.shape
b = torch.full((l, n, self.n_distributions), -inf, dtype=torch.float32,
device=self.device)
b[-1] = self.ends
for i in range(l-2, -1, -1):
p = b[i+1, :, self._edge_idx_ends]
p += emissions[:, i+1, self._edge_idx_ends]
p += self._edge_log_probs.expand(n, -1)
alpha = torch.max(p, dim=1, keepdims=True).values
p = torch.exp(p - alpha)
z = torch.zeros_like(b[i])
z.scatter_add_(1, self._edge_idx_starts.expand(n, -1), p)
b[i] = alpha + torch.log(z)
b = b.permute(1, 0, 2)
return b
def forward_backward(self, X=None, emissions=None, priors=None):
"""Run the forward-backward algorithm on some data.
Runs the forward-backward algorithm on a batch of sequences. This
algorithm combines the best of the forward and the backward algorithm.
It combines the probability of starting at the beginning of the sequence
and working your way to each observation with the probability of
starting at the end of the sequence and working your way backward to it.
A number of statistics can be calculated using this information. These
statistics are powerful inference tools but are also used during the
Baum-Welch training process.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, d)
A set of examples to evaluate. Does not need to be passed in if
emissions are.
emissions: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, n_distributions)
Precalculated emission log probabilities. These are the
probabilities of each observation under each probability
distribution. When running some algorithms it is more efficient
to precalculate these and pass them into each call.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
Returns
-------
transitions: torch.Tensor, shape=(-1, n, n)
The expected number of transitions across each edge that occur
for each example. The returned transitions follow the structure
of the transition matrix and so will be dense or sparse as
appropriate.
responsibility: torch.Tensor, shape=(-1, -1, n)
The posterior probabilities of each observation belonging to each
state given that one starts at the beginning of the sequence,
aligns observations across all paths to get to the current
observation, and then proceeds to align all remaining observations
until the end of the sequence.
starts: torch.Tensor, shape=(-1, n)
The probabilities of starting at each node given the
forward-backward algorithm.
ends: torch.Tensor, shape=(-1, n)
The probabilities of ending at each node given the forward-backward
algorithm.
logp: torch.Tensor, shape=(-1,)
The log probabilities of each sequence given the model.
"""
emissions = _check_inputs(self, X, emissions, priors)
n, l, _ = emissions.shape
f = self.forward(emissions=emissions)
b = self.backward(emissions=emissions)
logp = torch.logsumexp(f[:, -1] + self.ends, dim=1)
t = f[:, :-1, self._edge_idx_starts] + b[:, 1:, self._edge_idx_ends]
t += emissions[:, 1:, self._edge_idx_ends]
t += self._edge_log_probs.expand(n, l-1, -1)
t = torch.exp(torch.logsumexp(t, dim=1).T - logp).T
starts = self.starts + emissions[:, 0] + b[:, 0]
starts = torch.exp(starts.T - torch.logsumexp(starts, dim=-1)).T
ends = self.ends + f[:, -1]
ends = torch.exp(ends.T - torch.logsumexp(ends, dim=-1)).T
r = f + b
r = (r - torch.logsumexp(r, dim=2).reshape(n, -1, 1))
return t, r, starts, ends, logp
def summarize(self, X, sample_weight=None, emissions=None, priors=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
emissions: torch.Tensor, shape=(-1, -1, self.n_distributions)
Precalculated emission log probabilities. These are the
probabilities of each observation under each probability
distribution. When running some algorithms it is more efficient
to precalculate these and pass them into each call.
priors: list, numpy.ndarray, torch.Tensor, shape=(-1, -1, self.k)
Prior probabilities of assigning each symbol to each node. If not
provided, do not include in the calculations (conceptually
equivalent to a uniform probability, but without scaling the
probabilities). This can be used to assign labels to observatons
by setting one of the probabilities for an observation to 1.0.
Note that this can be used to assign hard labels, but does not
have the same semantics for soft labels, in that it only
influences the initial estimate of an observation being generated
by a component, not gives a target. Default is None.
"""
X, emissions, sample_weight = super().summarize(X,
sample_weight=sample_weight, emissions=emissions, priors=priors)
t, r, starts, ends, logps = self.forward_backward(emissions=emissions)
X = X.reshape(-1, X.shape[-1])
r = torch.exp(r) * sample_weight.unsqueeze(1)
for i, node in enumerate(self.distributions):
w = r[:, :, i].reshape(-1, 1)
node.summarize(X, sample_weight=w)
if self.frozen == False:
self._xw_starts_sum += torch.sum(starts * sample_weight, dim=0)
self._xw_ends_sum += torch.sum(ends * sample_weight, dim=0)
self._xw_sum += torch.sum(t * sample_weight, dim=0)
return logps
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
for node in self.distributions:
node.from_summaries()
if self.frozen:
return
node_out_count = torch.clone(self._xw_ends_sum)
for start, count in zip(self._edge_idx_starts, self._xw_sum):
node_out_count[start] += count
ends = torch.log(self._xw_ends_sum / node_out_count)
starts = torch.log(self._xw_starts_sum / self._xw_starts_sum.sum())
_edge_log_probs = torch.empty_like(self._edge_log_probs)
for i in range(self.n_edges):
t = self._xw_sum[i]
t_sum = node_out_count[self._edge_idx_starts[i]]
_edge_log_probs[i] = torch.log(t / t_sum)
_update_parameter(self.ends, ends, inertia=self.inertia)
_update_parameter(self.starts, starts, inertia=self.inertia)
_update_parameter(self._edge_log_probs, _edge_log_probs,
inertia=self.inertia)
self._reset_cache()
jmschrei-pomegranate-8de2be8/pomegranate/kmeans.py 0000664 0000000 0000000 00000027141 14643672530 0022472 0 ustar 00root root 0000000 0000000 # kmeans.py
# Author: Jacob Schreiber
import time
import torch
from ._utils import _cast_as_tensor
from ._utils import _cast_as_parameter
from ._utils import _update_parameter
from ._utils import _check_parameter
from ._utils import _reshape_weights
from ._utils import _initialize_centroids
from ._utils import eps
class KMeans(torch.nn.Module):
"""A KMeans clustering object.
Although K-means clustering is not a probabilistic model by itself,
necessarily, it can be a useful initialization for many probabilistic
methods, and can also be thought of as a specific formulation of a mixture
model. Specifically, if you have a Gaussian mixture model with diagonal
covariances set to 1/inf, in theory you will get the exact same results
as k-means clustering.
The implementation is provided here not necessarily to compete with other
implementations, but simply to use as a consistent initialization.
Parameters
----------
k: int or None, optional
The number of clusters to initialize. Default is None
centroids: list, numpy.ndarray, torch.Tensor, or None, optional
A set of centroids to use to initialize the algorithm. Default is None.
init: str, optional
The initialization to use if `centroids` are not provided. Default is
'first-k'. Must be one of:
'first-k': Use the first k examples from the data set
'random': Use a random set of k examples from the data set
'submodular-facility-location': Use a facility location submodular
objective to initialize the k-means algorithm
'submodular-feature-based': Use a feature-based submodular objective
to initialize the k-means algorithm.
max_iter: int, optional
The number of iterations to do in the EM step of fitting the
distribution. Default is 10.
tol: float, optional
The threshold at which to stop during fitting when the improvement
goes under. Default is 0.1.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
verbose: bool, optional
Whether to print the improvement and timings during training.
"""
def __init__(self, k=None, centroids=None, init='first-k', max_iter=10,
tol=0.1, inertia=0.0, frozen=False, random_state=None, verbose=False):
super().__init__()
self.name = "KMeans"
self._device = _cast_as_parameter([0.0])
self.centroids = _check_parameter(_cast_as_parameter(centroids,
dtype=torch.float32), "centroids", ndim=2)
self.k = _check_parameter(_cast_as_parameter(k), "k", ndim=0,
min_value=2, dtypes=(int, torch.int32, torch.int64))
self.init = _check_parameter(init, "init", value_set=("random",
"first-k", "submodular-facility-location",
"submodular-feature-based"), ndim=0, dtypes=(str,))
self.max_iter = _check_parameter(_cast_as_tensor(max_iter), "max_iter",
ndim=0, min_value=1, dtypes=(int, torch.int32, torch.int64))
self.tol = _check_parameter(_cast_as_tensor(tol), "tol", ndim=0,
min_value=0)
self.inertia = _check_parameter(_cast_as_tensor(inertia), "inertia",
ndim=0, min_value=0.0, max_value=1.0)
self.frozen = _check_parameter(_cast_as_tensor(frozen), "frozen",
ndim=0, value_set=(True, False))
self.random_state = random_state
self.verbose = _check_parameter(verbose, "verbose",
value_set=(True, False))
if self.k is None and self.centroids is None:
raise ValueError("Must specify one of `k` or `centroids`.")
self.k = len(centroids) if centroids is not None else self.k
self.d = len(centroids[0]) if centroids is not None else None
self._initialized = centroids is not None
self._reset_cache()
@property
def device(self):
try:
return next(self.parameters()).device
except:
return 'cpu'
def _initialize(self, X):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
X: list, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
The data to use to initialize the model.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=2)
centroids = _initialize_centroids(X, self.k, algorithm=self.init,
random_state=self.random_state)
if isinstance(centroids, torch.masked.MaskedTensor):
centroids = centroids._masked_data * centroids._masked_mask
if centroids.device != self.device:
centroids = centroids.to(self.device)
self.centroids = _cast_as_parameter(centroids)
self.d = X.shape[1]
self._initialized = True
self._reset_cache()
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized == False:
return
self.register_buffer("_w_sum", torch.zeros(self.k, self.d,
device=self.device))
self.register_buffer("_xw_sum", torch.zeros(self.k, self.d,
device=self.device))
self.register_buffer("_centroid_sum", torch.sum(self.centroids**2,
dim=1).unsqueeze(0))
def _distances(self, X):
"""Calculate the distances between each example and each centroid.
This method calculates the distance between each example and each
centroid in the model. These distances make up the backbone of the
k-means learning and prediction steps.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
Returns
-------
distances: torch.Tensor, shape=(-1, self.k)
The Euclidean distance between each example and each cluster.
"""
X = _check_parameter(_cast_as_tensor(X, dtype=torch.float32), "X",
ndim=2, shape=(-1, self.d))
XX = torch.sum(X**2, dim=1).unsqueeze(1)
if isinstance(X, torch.masked.MaskedTensor):
n = X._masked_mask.sum(dim=1).unsqueeze(1)
Xc = torch.matmul(X._masked_data * X._masked_mask, self.centroids.T)
else:
n = X.shape[1]
Xc = torch.matmul(X, self.centroids.T)
distances = torch.empty(X.shape[0], self.k, dtype=X.dtype,
device=self.device)
distances[:] = torch.clamp(XX - 2*Xc + self._centroid_sum, min=0)
return torch.sqrt(distances / n)
def predict(self, X):
"""Calculate the cluster assignment for each example.
This method calculates cluster assignment for each example as the
nearest centroid according to the Euclidean distance.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
Returns
-------
y: torch.Tensor, shape=(-1,)
The predicted label for each example.
"""
return self._distances(X).argmin(dim=1)
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache. The examples must be
given in a 2D format. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
For k-means clustering, this step is essentially performing the 'E' part
of the EM algorithm on a batch of data, where examples are hard-assigned
to distributions in the model and summaries are derived from that.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
"""
if self.frozen:
return 0
if not self._initialized:
self._initialize(X)
X = _check_parameter(_cast_as_tensor(X, dtype=torch.float32), "X",
ndim=2, shape=(-1, self.d))
sample_weight = _reshape_weights(X, _cast_as_tensor(sample_weight,
dtype=torch.float32), device=self.device)
distances = self._distances(X)
y_hat = distances.argmin(dim=1)
if isinstance(X, torch.masked.MaskedTensor):
for i in range(self.k):
idx = y_hat == i
self._w_sum[i][:] = self._w_sum[i] + sample_weight[idx].sum(dim=0)
self._xw_sum[i][:] = self._xw_sum[i] + (X[idx] *
sample_weight[idx]).sum(dim=0)
else:
y_hat = y_hat.unsqueeze(1).expand(-1, self.d)
self._w_sum.scatter_add_(0, y_hat, sample_weight)
self._xw_sum.scatter_add_(0, y_hat, X * sample_weight)
return distances.min(dim=1).values.sum()
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen:
return
centroids = self._xw_sum / self._w_sum
_update_parameter(self.centroids, centroids, self.inertia)
self._reset_cache()
def fit(self, X, sample_weight=None):
"""Fit the model to optionally weighted examples.
This method implements the core of the learning process. For a
mixture model, this involves performing EM until the distributions that
are being fit converge according to the threshold set by `tol`, or
until the maximum number of iterations has been hit.
This method is largely a wrapper around the `summarize` and
`from_summaries` methods. It's primary contribution is serving as a
loop around these functions and to monitor convergence.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
Returns
-------
self
"""
d_current = None
for i in range(self.max_iter):
start_time = time.time()
d_previous = d_current
d_current = self.summarize(X, sample_weight=sample_weight)
if i > 0:
improvement = d_previous - d_current
duration = time.time() - start_time
if self.verbose:
print("[{}] Improvement: {}, Time: {:4.4}s".format(i,
improvement, duration))
if improvement < self.tol:
break
self.from_summaries()
self._reset_cache()
return self
def fit_predict(self, X, sample_weight=None):
"""Fit the model and then return the predictions.
This function wraps a call to the `fit` function and then to the
`predict` function. Essentially, k-means will be fit to the data and
the resulting clustering assignments will be returned.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, self.d)
A set of examples to evaluate.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
Returns
-------
y: torch.Tensor, shape=(-1,)
Cluster assignments for each example.
"""
self.fit(X, sample_weight=sample_weight)
return self.predict(X) jmschrei-pomegranate-8de2be8/pomegranate/markov_chain.py 0000664 0000000 0000000 00000023270 14643672530 0023654 0 ustar 00root root 0000000 0000000 # markov_chain.py
# Author: Jacob Schreiber
import torch
from ._utils import _cast_as_tensor
from ._utils import _update_parameter
from ._utils import _check_parameter
from ._utils import _reshape_weights
from .distributions._distribution import Distribution
from .distributions import Categorical
from .distributions import ConditionalCategorical
class MarkovChain(Distribution):
"""A Markov chain.
A Markov chain is the simplest sequential model which factorizes the
joint probability distribution P(X_{0} ... X_{t}) along a chain into the
product of a marginal distribution P(X_{0}) P(X_{1} | X_{0}) ... with
k conditional probability distributions for a k-th order Markov chain.
Despite sometimes being thought of as an independent model, Markov chains
are probability distributions over sequences just like hidden Markov
models. Because a Markov chain has the same theoretical properties as a
probability distribution, it can be used in any situation that a simpler
distribution could, such as an emission distribution for a HMM or a
component of a Bayes classifier.
Parameters
----------
distributions: tuple or list or None
A set of distribution objects. These objects do not need to be
initialized, i.e., can be "Categorical()".
k: int or None
The number of conditional distributions to include in the chain, also
the number of steps back to model in the sequence. This must be passed
in if the distributions are not passed in.
n_categories: list, tuple, or None
A list or tuple containing the number of categories that each feature
has.
inertia: float, [0, 1], optional
Indicates the proportion of the update to apply to the parameters
during training. When the inertia is 0.0, the update is applied in
its entirety and the previous parameters are ignored. When the
inertia is 1.0, the update is entirely ignored and the previous
parameters are kept, equivalently to if the parameters were frozen.
frozen: bool, optional
Whether all the parameters associated with this distribution are frozen.
If you want to freeze individual pameters, or individual values in those
parameters, you must modify the `frozen` attribute of the tensor or
parameter directly. Default is False.
check_data: bool, optional
Whether to check properties of the data and potentially recast it to
torch.tensors. This does not prevent checking of parameters but can
slightly speed up computation when you know that your inputs are valid.
Setting this to False is also necessary for compiling.
"""
def __init__(self, distributions=None, k=None, n_categories=None,
inertia=0.0, frozen=False, check_data=True):
super().__init__(inertia=inertia, frozen=frozen, check_data=check_data)
self.name = "MarkovChain"
self.distributions = _check_parameter(distributions, "distributions",
dtypes=(list, tuple))
self.k = _check_parameter(_cast_as_tensor(k, dtype=torch.int32), "k",
ndim=0)
self.n_categories = _check_parameter(n_categories, "n_categories",
dtypes=(list, tuple))
if distributions is None and k is None:
raise ValueError("Must provide one of 'distributions', or 'k'.")
if distributions is not None:
self.k = len(distributions) - 1
self.d = None
self._initialized = distributions is not None and distributions[0]._initialized
self._reset_cache()
def _initialize(self, d, n_categories):
"""Initialize the probability distribution.
This method is meant to only be called internally. It initializes the
parameters of the distribution and stores its dimensionality. For more
complex methods, this function will do more.
Parameters
----------
d: int
The dimensionality the distribution is being initialized to.
n_categories: int
The maximum number of categories to model. This single number is
used as the maximum across all features and all timesteps.
"""
if self.distributions is None:
self.distributions = [Categorical()]
self.distributions[0]._initialize(d, max(n_categories))
for i in range(self.k):
distribution = ConditionalCategorical()
distribution._initialize(d, [[n_categories[j]]*(i+2)
for j in range(d)])
self.distributions.append(distribution)
self.n_categories = n_categories
self._initialized = True
super()._initialize(d)
def _reset_cache(self):
"""Reset the internally stored statistics.
This method is meant to only be called internally. It resets the
stored statistics used to update the model parameters as well as
recalculates the cached values meant to speed up log probability
calculations.
"""
if self._initialized:
for distribution in self.distributions:
distribution._reset_cache()
def sample(self, n):
"""Sample from the probability distribution.
This method will return `n` samples generated from the underlying
probability distribution. For a mixture model, this involves first
sampling the component using the prior probabilities, and then sampling
from the chosen distribution.
Parameters
----------
n: int
The number of samples to generate.
Returns
-------
X: torch.tensor, shape=(n, self.d)
Randomly generated samples.
"""
X = [self.distributions[0].sample(n)]
for distribution in self.distributions[1:]:
X_ = torch.stack(X).permute(1, 0, 2)
samples = distribution.sample(n, X_[:, -self.k-1:])
X.append(samples)
return torch.stack(X).permute(1, 0, 2)
def log_probability(self, X):
"""Calculate the log probability of each example.
This method calculates the log probability of each example given the
parameters of the distribution. The examples must be given in a 3D
format.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, length, self.d)
A set of examples to evaluate.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
X = _check_parameter(_cast_as_tensor(X), "X", ndim=3,
check_parameter=self.check_data)
self.d = X.shape[1]
logps = self.distributions[0].log_probability(X[:, 0])
for i, distribution in enumerate(self.distributions[1:-1]):
logps += distribution.log_probability(X[:, :i+2])
for i in range(X.shape[1] - self.k):
j = i + self.k + 1
logps += self.distributions[-1].log_probability(X[:, i:j])
return logps
def fit(self, X, sample_weight=None):
"""Fit the model to optionally weighted examples.
This method will fit the provided distributions given the data and
their weights. If only `k` has been provided, the relevant set of
distributions will be initialized.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, length, self.d)
A set of examples to evaluate.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
Returns
-------
self
"""
self.summarize(X, sample_weight=sample_weight)
self.from_summaries()
return self
def summarize(self, X, sample_weight=None):
"""Extract the sufficient statistics from a batch of data.
This method calculates the sufficient statistics from optionally
weighted data and adds them to the stored cache for each distribution
in the network. Sample weights can either be provided as one
value per example or as a 2D matrix of weights for each feature in
each example.
Parameters
----------
X: list, tuple, numpy.ndarray, torch.Tensor, shape=(-1, length, self.d)
A set of examples to summarize.
sample_weight: list, tuple, numpy.ndarray, torch.Tensor, optional
A set of weights for the examples. This can be either of shape
(-1, self.d) or a vector of shape (-1,). Default is ones.
Returns
-------
logp: torch.Tensor, shape=(-1,)
The log probability of each example.
"""
if self.frozen:
return
X = _check_parameter(_cast_as_tensor(X), "X", ndim=3,
check_parameter=self.check_data)
sample_weight = _check_parameter(_cast_as_tensor(sample_weight),
"sample_weight", min_value=0, ndim=(1, 2),
check_parameter=self.check_data)
if not self._initialized:
if self.n_categories is not None:
n_keys = self.n_categories
elif isinstance(X, torch.masked.MaskedTensor):
n_keys = (torch.max(torch.max(X._masked_data, dim=0)[0],
dim=0)[0] + 1).type(torch.int32)
else:
n_keys = (torch.max(torch.max(X, dim=0)[0], dim=0)[0] + 1).type(
torch.int32)
self._initialize(len(X[0][0]), n_keys)
if sample_weight is None:
sample_weight = torch.ones_like(X[:, 0])
elif len(sample_weight.shape) == 1:
sample_weight = sample_weight.reshape(-1, 1).expand(-1, X.shape[2])
elif sample_weight.shape[1] == 1:
sample_weight = sample_weight.expand(-1, X.shape[2])
_check_parameter(_cast_as_tensor(sample_weight), "sample_weight",
min_value=0, ndim=2, shape=(X.shape[0], X.shape[2]),
check_parameter=self.check_data)
self.distributions[0].summarize(X[:, 0], sample_weight=sample_weight)
for i, distribution in enumerate(self.distributions[1:-1]):
distribution.summarize(X[:, :i+2], sample_weight=sample_weight)
distribution = self.distributions[-1]
for i in range(X.shape[1] - self.k):
j = i + self.k + 1
distribution.summarize(X[:, i:j], sample_weight=sample_weight)
def from_summaries(self):
"""Update the model parameters given the extracted statistics.
This method uses calculated statistics from calls to the `summarize`
method to update the distribution parameters. Hyperparameters for the
update are passed in at initialization time.
Note: Internally, a call to `fit` is just a successive call to the
`summarize` method followed by the `from_summaries` method.
"""
if self.frozen:
return
for distribution in self.distributions:
distribution.from_summaries()
jmschrei-pomegranate-8de2be8/requirements.txt 0000664 0000000 0000000 00000000157 14643672530 0021622 0 ustar 00root root 0000000 0000000 numpy >= 1.22.2
scipy >= 1.6.2
scikit-learn >= 1.0.2
torch >= 1.9.0
apricot-select >= 0.6.1
networkx >= 2.8.4
jmschrei-pomegranate-8de2be8/setup.py 0000664 0000000 0000000 00000001013 14643672530 0020040 0 ustar 00root root 0000000 0000000 from setuptools import setup
setup(
name='pomegranate',
version='1.1.0',
author='Jacob Schreiber',
author_email='jmschreiber91@gmail.com',
packages=['pomegranate', 'pomegranate.distributions', 'pomegranate.hmm'],
url='https://github.com/jmschrei/torchegranate',
license='LICENSE.txt',
description='A PyTorch implementation of probabilistic models.',
install_requires=[
'numpy >= 1.22.2',
'scipy >= 1.6.2',
'scikit-learn >= 1.0.2',
'torch >= 1.9.0',
'apricot-select >= 0.6.1',
'networkx >= 2.8.4'
]
) jmschrei-pomegranate-8de2be8/slides/ 0000775 0000000 0000000 00000000000 14643672530 0017616 5 ustar 00root root 0000000 0000000 jmschrei-pomegranate-8de2be8/slides/pomegranate ODSC East 2019.pdf 0000664 0000000 0000000 00012171221 14643672530 0024564 0 ustar 00root root 0000000 0000000 %PDF-1.4
%
4
0
obj
<<
/Type
/Catalog
/Names
<<
/JavaScript
3
0
R
>>
/PageLabels
<<
/Nums
[
0
<<
/S
/D
/St
1
>>
]
>>
/Outlines
2
0
R
/Pages
1
0
R
>>
endobj
5
0
obj
<<
/Creator
( G o o g l e)
>>
endobj
6
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
7
0
R
/Resources
8
0
R
/Annots
10
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
7
0
obj
<<
/Filter
/FlateDecode
/Length
9
0
R
>>
stream
xVKo0
$^nfQS{GE hDh%*Pcg8%q|IfRJceDΤ*yLq'ۉDgɩd^,8奇x=ɭG/yq<|2r ɛ0v%'_;y|թv)
8-E7cs7ȷgɉ"ՎPDM 3AǺȯ]ԃr.*$5IXcFkcme^?<T]QO &]6@d#`q= ͰAѷGICe9JR?'ڛWr?#![ [C aW_r" #
qOM
YU ^jKTHf!kwbpx,ET:k3!q~9v[]: yoƲmIvP#
m`JҼX9$4ΞxQȤ݈1lF ھ>, o}O¨#샂D-2Մӕ
.:+T&u)㆝žSJ%JV]Xu-*Ggt9״JnS` 4ͷ7k_QΣ4Z7kݥqJkxHhASTմZ |^:IomkaK@+m-r(+4݁!!5G{@#;x&I2%R]m#
>~+K uD%Sl'!_ l6Asoħ>_ GY/DfX:ۍ;# Gz
endstream
endobj
9
0
obj
795
endobj
10
0
obj
[
]
endobj
18
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
19
0
R
/Resources
20
0
R
/Annots
22
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
19
0
obj
<<
/Filter
/FlateDecode
/Length
21
0
R
>>
stream
xWMo$55#GnL.],م6쒅??rf& [3Uez.4u{6[}RXZ,>K|՞B$[̛14z! Vo?n^[}gK{(7́>ry;Lqr0xS"+!uf#0|
C:4Q܂ Fbv"Xy']n. woBpz~%>yf&=o4UՋWGBT{r=SGDwj5sD;*/=L͊z&mNsi}R3`*
x%D_ }4SX9~xѸH'6 7%csv1wX 48,$pK泉Cǒ*qӒiF M"<'Z0b@qHR'<ԧjox(tZRt.g 2QʄeTf+R;J35fA>
>>
endobj
28
0
obj
<<
/Filter
/FlateDecode
/Length
30
0
R
>>
stream
xVn0ͳ?O@]b#[Z"
-[1v]R%O<.kw #}0Ks^8ò\ׅȮu Ẽܘ92= ~8s2g~nNrlƄb%Nz?zVۊ)VIۿ89yyU,1qqX` m `
B@+:_ uT"b a8Ef'U6{.h!Oc/h~ 96;Ӆw7݇s)c߽@Åsw0_Lμm Fv $ ',\.!C ! [J,
A hQK $
pL @w٣_#{2*}Ncs@-R%j]
ԥ
E X$5<ؐ*84w!1R5aeB6>@i\($w2Р *h`&9яGjתA20#h#*f G'phA
9Ub
+|bkm`2j-T RŔJVņ( #Z
= c2k8B dj[ |
endstream
endobj
30
0
obj
712
endobj
31
0
obj
[
]
endobj
38
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
39
0
R
/Resources
40
0
R
/Annots
42
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
39
0
obj
<<
/Filter
/FlateDecode
/Length
41
0
R
>>
stream
xVR0U'o֧BL] i@&!x+%MbhXHgYɞ
~: e&R:`6OJ@gSy6` Fr l~PpTZѯr|Mu
>-2YʲXŭǍ- mr˘jF=I\\ >˂LHG2 kͮg^_Jjz;2tI .x簞c {ܺM^b3P^>H1:(U~3
z/ĩ}`]k'מI{
[@3C)Tƻ,ZmnƵKZp
Q.MP4[2M'қJq(Ξ8*eaz@
l 7Z7%o Oqh ؊iȘqU7rl3-1Hʄk]:X|LtaELr3)7 f'ŗ=0o_$ AvYQRTz KJfZ3-/
3O<; avu up^ ۊ'Uvr-o +MQhQS:CU]LRn82B0O 3L4ib-ÇrW
9ǵ(c9M5]o&ze[EK 1p' 9O{hde)oy^
endstream
endobj
41
0
obj
746
endobj
42
0
obj
[
]
endobj
44
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
45
0
R
/Resources
46
0
R
/Annots
48
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
45
0
obj
<<
/Filter
/FlateDecode
/Length
47
0
R
>>
stream
xYn 5w/ȟ (
B9RJ(M.-)<
£mN{f~ 1v'!=&!*##> r w+˦È5x$x執 ˯%?l}u)Ny03Sյؓigj7_ ƌ w)CFXf:LhSm }-ԁ)H-{3X
-v
=; y,=ʟo>߮g - C8=> p: 5:?D`ZA , \Ghq]s3) Q#Ej؛& k,l X C#S;@&5s s s ޗ1 ů#,~^_Mg ?(v=wVy)i,uYEa\"
Dp .IwLr+.gs̏F٭yw, h2#;@&7K gzVօB .ipk7`uG :Ԭ
T$f(h$GXNec2R]2?'8
j[=[e
wLn
NF9NR27
ۼKoMU|o^@vNvsszn D'sp>nwA Иk.LQ- q[@EӹUM+p" Rgz>BNC1FRaZن
`& n:V^ `t&1 -Mr}8Oǧ.ɇ(=IE/Ig M2# s,k(DZzo?*&Jd8B${d#6TH~|VǁUQZL>
>>
endobj
51
0
obj
<<
/Filter
/FlateDecode
/Length
53
0
R
>>
stream
xWnT7$> 㻷%*JKҐDy@$B'@R_AЪ >$dDљ^ WBtm
+ .*zr xMihMFO57rW 4^H~!ϥ .5u:WivHpEi>( M:kpZѾD#0(S9&VLՇo2UBECq*ϧM_քO_GE7c?Ԇ"C@g ZtWj;S $ o\$.XM9឴7YZ @ T M
\b1
Q( M*@TZbTHL'OjVom6=n5{ k
nO_>؟C /> r(*:;ju 棍"ڎV)d*[}v'sk=J_}uZ2[K A{r[i*924x
⥧%XXip)xЩbѮ[nBznZ+kzG OP[lx>vNF Z !N` Rٚo5|lxi C.WQҎn!C5jwI\̸!jj\CM[.xXݒ(hl L= ^{xľ"Hka^y' JD NZ#uν+f;V>R.WBVH\]uqry=D)`=TX
ei-ŻF\/;n_ɋL^U{qAX+]I!࿀{
2lG}˾ 2wz\ AO3(ɄgO" {0' 9pJ#fJ涙$fi2{
^"9[B Φ<
endstream
endobj
53
0
obj
1022
endobj
54
0
obj
[
]
endobj
59
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
60
0
R
/Resources
61
0
R
/Annots
63
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
60
0
obj
<<
/Filter
/FlateDecode
/Length
62
0
R
>>
stream
xYn7^)/@jď*(6
mJC+
*}O7kovO~8J3x< -n`P %Gl~w x 8'9Wn?z_.ۗ +xZ\❙X֘SF EC#- )@+^XlbOjeF/EM> rg<Ӛ!,"7?6bbON&j/ťmx-v,)oeO!)a( :@1`;V*AA{Bׂ߿/*|;UJRk#|$oEF%
Ёez?bFJVɤUjD'A;; GѸl5^sѼϟC_FS87jD6YJ;+[>k6 |h]om mXmFHlhVdkxê{ {8
2e^60" 㺵771w͜?͕?6Ad ҌMqʙNW>>Y$].[9\ꃦ|>l\`gFy_=|GR֛u`䚒:YJi+9rf
,R4B2iQofmm$]E]n@xpXPhT!JA_p}vL>!㍫_mő&%JѪ$G`fprZjem4٧S-XH 34Y0BօڨY`mEG:XL][N'RVÒicmo]S*am
&g:zd9Pd
l@Ld}ʴ
Jgj(H~iQ&QgsE$"ʘ
mX`mEXXތ ֔`Ef/`UcNÉ&j|wT9p<%]=3ephG#cݿ2vX[c=(5,wB1o5# CLn*u,yX<Ƥq8qYJ,g:C8]!
M|"iHA:
Π8|Sl 6ʠB `,'ZH! C U"XTAc SQ Fx LFiuNigD`8s Jp
#f:8\α3_HO_m4Aa) 5Cxy_)bߙEȠVΌO,E V'dr\|})|BQG#3F46mA; H&
UIJ'Lݝ %]w~* J'M,GLpsCycZJ4ֱC8*G5ȧ{0 o7Q'
lIv-eGVPgzˑ1en:_[m |ef8N ~>t7B6Ox_} 9 V))gn ʣz
endstream
endobj
62
0
obj
1829
endobj
63
0
obj
[
]
endobj
64
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
65
0
R
/Resources
66
0
R
/Annots
68
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
65
0
obj
<<
/Filter
/FlateDecode
/Length
67
0
R
>>
stream
xXo6=@!8d6l]ۚ`p% ?a )˒lʼn= t&O#s˕<]/*H_o-BJ]nv;ϛ֛$C%^K}]d/pݶdZfˬ&v'6rnyi ьwW+Ͽ_i-> 0rʋQPl4ZY,ח^C3~P9 NhEZs' 9 j&ˏ 6\{ n%A U5G,36fi{,MXW7Y=e(/ h=`#vΗ} $d뢗!FFRU PV-'6g-*$b^"rt\TzS*ZM:}v錍OBƩXs}Y`㺞:(٧M4zpE !FqSpRS u^%$7w i¾ nY
_0ҋ, 6mQ\{ D|Wߧ]~(uV>[$S̵ڸjިTQj붘Rw4dBO1oj7hqOw0eOQ#ܓ\
m*/Sʳ:|ri[v{҃ժbiꎱLyg,0Vyc
׃º /i99oPq$Y̏Ě(u4\{A}Hla)3ҡf;/K ?
0l8xC>hίɼ߀i.@,]RN{jt>_{dޮ@AoB!*|ZZPeS
P'c9oVk7qް]S^^|s?}z8Y< 8_&ȵmc__p'|#e BR~[/=+NR
endstream
endobj
67
0
obj
1179
endobj
68
0
obj
[
]
endobj
69
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
70
0
R
/Resources
71
0
R
/Annots
73
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
70
0
obj
<<
/Filter
/FlateDecode
/Length
72
0
R
>>
stream
xWnG-J<)^~Fv|60%VL
'!Nػ+!;sg/䂥cEd ! V<Rsމ|Pޤ]9;ea䒭n^?Ku:I9{vl(Iy͆Z LV#ٖm.C̫\uuoҳ䴽xeELp䗑Pkɠ!V,IFKt@Q2"AQ\K5sߧHRD`=R6^lci
Y|kIF"2E[@T^\אtA6n
|lBjkAa+ώ.mН36𠜰וϏ/R #Y1FJ:
NY`"ckn
;˘P s1 FהT7S{ ?n̅xs҇? 5vq@z
{` F!n >6j5A$@]KZbrM&D1uz!=熸5!=H']OR(N#~ӇDX' ?3`֦wG[*?xk>%(+aG˥ŔFv*Oʿʦ3%
endstream
endobj
72
0
obj
1048
endobj
73
0
obj
[
]
endobj
74
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
75
0
R
/Resources
76
0
R
/Annots
78
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
75
0
obj
<<
/Filter
/FlateDecode
/Length
77
0
R
>>
stream
xVKoGnio}C/$~1Qb'Hh bߧg1bdk ;kBr:,^k.]$ qŵɤZ|K~ߡk~[+/>X;Yo \7ƁiY.jQ( :+!Z=`Yw5{0GC *իO|1hC;Q+T3*0q soyS\ד OFε:bΪ O%q ނ{r~A xf:Z @[0 8
ڽ'vɻ|Iw{ Q̇HyiwCʧA]7y7<%l?. ʁO]o #7&h $6(ωwXj k?ЮB4F cl)ֱ
;aG/l)bkZr6gK'Z {~\iw\5Nє=*stաܠu;kf.p
`gzhbttZ
vΘ+dc 7W`r6H-ѺpfR.)P3c{_0/
+ 4* ?%pm
~f=<(.@WG^2{ T=niO |г G {h7
Z1 5voAD3`1=]>tC, Qdh
HbGV7h@
'`(C'PdۂQ;zoWIH )PQжM96EUͱl6'WOR'^~]y=*>
>>
endobj
81
0
obj
<<
/Filter
/FlateDecode
/Length
83
0
R
>>
stream
xWn7eyK9AKNX"r@46uR;pJZHKg83v` p Vı>'&~݂v;ěa
M/_7$\ItG~ `NcІgRX%-F
R3|%et`U^+ W8?9p2%m^YCҀY*SXe0n DExxI̊[F B݄ߴIe`h@Y6 jڤ?mu x/le tP8[x"~ ԧ0k`JZd GJgW>Pu,0.qˣTq dϽ╕ bЧ01 (MAVDzpHEEsUp;XT+i7}vv6Ș*:js1/k_BDZ(^OLzG%q.wE-Mla̻ D|NS:~?={$߅tǠ?@& 1n&i
8G DCZ (b 2[^P2yQwW e rsd>w;ԫlD OWvE>
>>
endobj
88
0
obj
<<
/Filter
/FlateDecode
/Length
90
0
R
>>
stream
x[n A/<"
Ȩ/շuqX!J`c ȶ |Z/ȩK=8"9KUt>zR#qBsa8I)|tr3LJz` _q 1 wȲ?oOQ yEM km)Nv;' ,*F,%Xm,Fm߲EbO# rXRb; BO1O/~nvxmϧSںѸ&Ӆo{ ߍǧ`?Yˌ?c, #DJS
ەQ D*+} z+AҢ uCU"]'k0\!@3.CWE_:d~>j#vI2 퉩)ڔ5|x:< ^ ˽xx6 ^ Y{hsw8^y1]|{mbnyh4i >,=I}1Գ<ߎOx
^W5Y;=
-|L^Y̅o?5qa' 6:_U7??{c\rݴijymMɲ
LfRNHS[ik!?%jv֭ЭWL\jkN+ yZ;MX{X
ڸM\hrgz yZ;huL|m\۵q*&6&|)Qg&Okgt ~/{qnm@{îliLTᜍzu<47H'?ƤCgPٸIS6!差`30 6EPvr X4M0 YI>a nq'I>LA"EMbhfX`El!
R UƭeM_%]NJrPOJ) oÑ$ NLFxHI&&%Y=) )UvA
dD[VFIZ4KN /T1Sb:x{w\Kv6 <܄Y$"N-()v$aR%&G:h!lZe1 I)ZLH2U0T
)BG
x!#~ K!M^ r1#" W*RHAU֡9Wɂ*il뙪JH dϱX2L~%3U TS7 S.N};*&rj1 ~1UMvLP2ZC
~Kf.h9AKꅭjj6E(
J~)VAR)6uռ_Z:` ܩZќbt&qzD^]gskvuX[yBZ! ,U;W{)TD9.&gVP밮ԊݒwZB. u.~L;U=g*2|n`xz݉Vv/;RkԾ
vb75
7=n4-Br;Y*:Y eZTPW
~ Fq/} x
11|h3okBN zͩK|wf
z S\@aHj*QAgiڹZMѠ"բOVm:Srp`kjbHOɶ1ذlYX)hI+mfW3ˍ47H,S`; C4
~gˮzu7vwp:ٱ |ʭ|g, /E(p+&06YoJ|}uW5 ;,L> \Bu@w<< I:S Htp&o +w/1j <?'d~'y$m뚋 kk>M @1_^_- Bys4In~Gf6l<hkڣo'$>=a#Z6Bu8e%]mFV6 1!|DF#BXM?yb{;1Rh^kTxy;^) YunBdaq/,m@QgS!%aOS`&oˍ7hi[ *RŸڱ#\AF"3rbsYW`{TZ2fޱ1.N)r-m<_hPB%6 k帲vmlYqm$~C4= Sv(?^/0ȹSC+ 7&*Ԭ^;ބ{7PԿ^/𱼃˧@ ^N\6*67(e]+k8%8;$!?^/>&3JrQs{ l VZy
endstream
endobj
90
0
obj
3067
endobj
91
0
obj
[
]
endobj
92
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
93
0
R
/Resources
94
0
R
/Annots
96
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
93
0
obj
<<
/Filter
/FlateDecode
/Length
95
0
R
>>
stream
x[n @/Ƽ|( _ cD)K% 0V rgz/&itWuv13mLw,ؚJ4= ѯwO1'ӆo31wП?o!7wӅ~ޫ-M.z_J-mIѕ%&Ŕp#3eyX U>5IPS>`Q1}dgw#V&m_~O_|o~%
6+kL=/~ _ܮ Ke U %ԥo*ΐjclGmaX.?!B}ÿ\K_汵䒚˹dBz[l
:rt[:𗖒JN`?p=>=Ik.WӋ||z}6Ӳ N9/oh?ѧf#h-=xS >=>?/*K> \mlS SQ^B^!R6# Og;4|{>|r@lαAQkNsKTO6p˨OYz~ZƵ ۡ;5+m`kuJ ym|X{b iT LQcم)bpA͕ Q哩 TicT_f*Bvk"F)!L1bL1P7\]V4buLuL1q`*F#
Wp`ATL62Se) /b֎LEhOoft\GjÞӊDÁ_A|p,:"m
S6"si:,հ y*А!m-]%>Id!Iϴ0I9p.8c?% wbUPeC*s)X) i<1h%,!.q,[m1N ;:\u@e
/ STVoqTrLѸ^;Gㇱ-}2
j*!Hew,s/GQ{ k+d[Wѹ,]b!fT":U%Jm˒w8p@= k1BᏀ[feBz 5Pɥ*$MQY++"oȯwzU/Gj+HPlwXd. ⦄WAS6tkqBoL ǩzb "'e'Fx]L2y]$PD@Y*n,5]v;ٍWf]q0Xs# '" ;SB8nf7̀lץVZ<(Kݞ"B V*vA'Vj)scFu䴏mƑ_̒q@#'%(0
U9B"p6zȉ.Y z]5)ʑ 9uLENql knDud9qH6ޑ#aLÌ-kOՊ;
.ڙm湚)^ӟ6\'zZNHfᕛ7oB}`'eI [L=gfb Vay*zte#Cy{ge9>aqc/xD{wq=Dm,\KmV+iX *
^f4b-A`-_gM
* ZP3
jX0!z {[5m" N xWN#Nٻ|bsneT
K %jl#3롴UM_ڛHme>"P奎 >:#TrhIէLm6jQn<4>QWqMz-#6y7WKT]?!/\d.g$U=Tu 4&l*+W;һl Uu_,$ٌJDU mv뀵b4vGC Xz`ٞi Riԟč^Σ(wǶwQ[&ՇdBv"飈>JwGQ}I E@GQ 79'q+D-B(GQꃻEE@G( $D1xcwIZ4f}BvϓD#)ݞ+PRoY0m[Vz1pJ}JܲRZVIܲRΰmY)DZV Nj ҲRT )":Ҳ#` ;v$-G
r$H=qW~#P;Rcm
ۈÆF1pH}H TH TΰjwTArN9lܣ, e>SDt;!GJpӴHݱ#iѼEE;R I4ROH
endstream
endobj
95
0
obj
3369
endobj
96
0
obj
[
]
endobj
98
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
99
0
R
/Resources
100
0
R
/Annots
102
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
99
0
obj
<<
/Filter
/FlateDecode
/Length
101
0
R
>>
stream
x[n mC/~Se m^:E= ⏳z(/_?B?=RZ0>gѹg3ѭ18QGL|RT$߁eL04`˂m,NmW٣?Dɧp\(^KX):9y| Fm'|Z;k~_uS5"[B3^"Ȥq*4
C[c`>$^Îvmi7hghSJwjp<|3: ٬b8: )9Wzxw>-Op s7}98 ?Oy]h2 _lf 8hOh1d#Y: 'x:1d|A}~x\rؗ1Z(*I oJ}`B4rBS\λU
E! 3:-<,iixƒGpnMp5 s gr }sH@&߹ nJӞ3:B=Z@&߹wpM*pb12 A> q-V oxም Gq;/=j8mh'.sw[$&,5.bxP<(9LLv [ L2vM˘E'W1-ގKg8v39K@B
= o ]\JR%nFbli)sZ_zMLZ,uc>u75LbmiKdQ1nuy Ӊ^ vd-ް "f0 5"L^1xQv[CB&K1pmڟ-~hٻɳ#<ޜ&C33w0
cp% /(HViC
h 뛕Ү!s#z&T_{$ og@i>w0<*3?-~c% !CܼMx 8w$ 6Đ*ǥ9Kzt5;6Nx2wUX(u̧ {l:;-~oNp{7 Awß.O.CtrVr!M> `oq|N}lU|6W ݾd_]܄-mqΗr /i'n}vG 9uh?AP~y R q>x>%kV Qփ: pbᆊ,Q%$x3hF 'T9+
(*R6Pb@<ԩ"rX.1ƇM@EWM2q87Ya` [7D Xm+w@a#8?綏x^Q;ȅmDh7g|C-@$Nk]>(;!)όfL$&=@Jv@rܻlsgBMklgD (ӀWßS%x>P>CPu)+v[7(e `i+x?YΏhoW{Ep̯: ] ο [?JsX
endstream
endobj
101
0
obj
3096
endobj
102
0
obj
[
]
endobj
103
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
104
0
R
/Resources
105
0
R
/Annots
107
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
104
0
obj
<<
/Filter
/FlateDecode
/Length
106
0
R
>>
stream
xn1]n.B}[{K(^T@[mK
ƣ9P6gώ#P8'Z~9JJ7R6/s k)Jt40c3o2͏c ?S-V UL>":TM!6oio>|n 㞷+Zn7t2myݽ8oӁUui4i
1h<ȷPY"5T: [B"YKyQq/j`gr?dX֕z W>AO>(ć>4}.}ވMq(ދWbO ![ѻ)j^S,? pkԷT[مP뎕+A_Y^)g( Nmx\9I
yϝq0Q
fP4n&5r^a+nVSģ+Vs$#pJTq.&+<2Dt(VhFdY7%$1 դҠ+\Mvv$jYZ 9>}Ç
lf t11Jס Q LA Y|Xs ۘa?emiS|x+{YnU eh>DCL
ֺP:< !p86'm\..l_w_CWi=tGFНBU*"ӽĝlwro7n+ɖ,s\\ ݹ
n$ݞ@ ͭ4?*\sV q
endstream
endobj
106
0
obj
806
endobj
107
0
obj
[
]
endobj
112
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
113
0
R
/Resources
114
0
R
/Annots
116
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
113
0
obj
<<
/Filter
/FlateDecode
/Length
115
0
R
>>
stream
xUN1yCK _ [5pQsYRD%P@CػnBJ MVό̜39H. >-Ap!dV(8+U0NG%9콫~\
bwN5ν lg b0n-#t' F՛ bu|op{yM:px*SD[<.)Kƪ5*S1oǃgRNVHN6&3. uR)%9) `o ʫe"r%Pk+P,6{P~~c5OX\j>/z
AK'j?Zeikay>jR+RQΖ{띥,:MT*MDK *ri1-9S ;bĴYY "bԐ B4)gwN٧
imL1;*Kr>TumΐpI 87]S՚oK$7Rz :nnN*y$
o I]X=0I̜̔}w+ikn$ i FI 6Ab4գI$ 3"%9nԭ|:קc)zd7#FnijBcLE`6Xt&R_ǰl혽za=j(C0@$Q?Q$DW
ncv2h)b6}7V7-.w ߠ+(
endstream
endobj
115
0
obj
759
endobj
116
0
obj
[
]
endobj
118
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
119
0
R
/Resources
120
0
R
/Annots
122
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
119
0
obj
<<
/Filter
/FlateDecode
/Length
121
0
R
>>
stream
xYn\=^>OK@io*n Ic#8N@_е͌gF%htmqoR Sy(TJ' ; ^s1zVI>%;ߋķ8 y"0l6q#:n =Uw- _d!1EIBGL>䵩h
;h1,`>MVbu "mIX<@.T"g̞GH
M<~/qB#n~Z& QI^Q<0R,o vZ )Og3~B[,wXAi/ٷVZ\-2ƊQ^-~o/xtĊK_'RHg: }Dy9e9
Va:cRƳ>QzEO&duAV˘G)%` k l#`@YYK6P" beC
qĦ1+2bWFlF K aiLSFg4w4/=tr
uщFD t#?03{^jռ٠\i1Lp@lqY_j8^h9BZ3*;&iZ
ڙA 8!}h Vrl$@ѪX*bQ%$h簊^kFȖ'ٮ &f
` Vm\XJ0rڌ:Ó
-M4Wy=]iq" %; SKuja`f]@>P&6%WÐqlrZ1 upvZQLp&}@}cOR6"uP-ĬmAU e 30GZ/I"H6*6ʪXSh!mG% emu:#qU>:4@̎㉴ K`óJp7F8qd.cii !RO"93L0 AXRmt#6w(eM:[.Jc=a U!..v&zm?TH^5C(@ ԈG,V0L;pV{gV7(>Z T@~A\,Y+5Ojp36c [(Q6Q$֝e\, +(X*El
2Vo%/
Iܡ \LZ_G e eb"e>vtk w&`K5YCRB6ʐPV ;y+ 0
@NaRg^ Sk ̆"YZV4TH'Ȼ4l n
ao}RH=N3d} O
@f r6Z:2s\^
9]| ϧ0hoTB5ϒxG ԼAHrﯹ̽]bg
v ؼQkvJr5X
endstream
endobj
121
0
obj
2115
endobj
122
0
obj
[
]
endobj
123
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
124
0
R
/Resources
125
0
R
/Annots
127
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
124
0
obj
<<
/Filter
/FlateDecode
/Length
126
0
R
>>
stream
xVO1o髚L,N;m 5 x
~<YC8^=n7mg: T2=jNTj5D
Nۼcq͛שDrtVhmjHOX B^#d};\ꂁ^`X| MNAlA#fyAs B 㤃9. ciN5NrtFe|Yhc%D^Vl[g80du4߳@'SɪHV?帺c-OڝxE.e6k1 K3TZ4
4S,C[bsܖu%JcYk1G1Y2eg=q *1x'Xz-FΆx:JiOHFOĚx(H~՛\Agܰ3R.gFU4 `'b' A_O ҿAG}|]05 uq4li͐i4,0\LR˦#M;AZikӔd^s?\ 8alWbby;\k >/̃,Q^*~Ә(" RΌ\*=<>ֿ{x{I[a{6f Jڅ\6FșO ` T(+-y "q[sg/aSLOnCqn z\NUSk#%Vt\ 3t
endstream
endobj
126
0
obj
834
endobj
127
0
obj
[
]
endobj
129
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
130
0
R
/Resources
131
0
R
/Annots
133
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
130
0
obj
<<
/Filter
/FlateDecode
/Length
132
0
R
>>
stream
xVn1uoV"VMCڴa|_wMSdx23slg U#aq29..Xa hv;~& \"s~]:p3咿+E-8g>.)xS&:U;V;ʺW*W2ݲ:'4bn`P]&R"V -l\ 5]<>HmAYn4AՠV}M,jpzyG/31|0G2#,b>J a٢ܷdzoۛ̇jGOv- hU6:Nt*,
s< "
h zÃ1!?EU 1NJ7و Q &M%1+}B9aS軇G`ɵqx.jܝFoz4嫼"5BTu2^iTٯ< i畕2H5 69>Icxآ*fdN䳒I*V (_:iIkD '
"FɷKGiÞj6]Ξz#T
Q}ؓ",ճ\xFa0f9RAn;>Mc's)b c'k-Rjw/l QJu@
b@wzSBZ<ᐥu;
.n/ cmu2l{uݵA_8
endstream
endobj
132
0
obj
752
endobj
133
0
obj
[
]
endobj
135
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
136
0
R
/Resources
137
0
R
/Annots
139
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
136
0
obj
<<
/Filter
/FlateDecode
/Length
138
0
R
>>
stream
xUN15ۼU"~yl EV$(m?/.!PH*xf|f|K Jϛ` ݒB&k̯&NdqPz1-
sA?s,r)WtNxn;er>Mn!IgU]D08nA%j.l6֡rE" 7E2Tg pR͛_:{Zs ,7N騞ZkZQnkP?]ˎc'X<3"Vc9z&l Vo &_7M)^d5Bvq PksPV HXs];u<c )h*JCeaERfJIF @g\Hi*흤#v6F =|{l$?_ ! رXo>vͯW6 * }d}a~(EY VtFNjCvNDzlaI*> }o.Mh DRJ J A[ `&}T^r LPgL2@$ifN:IS&I>܆2Z:%[dAU6CU<(P*o: c^ j1
q8 iAT_J_3}nܪilrs>-ϗim$] ۿ:
endstream
endobj
138
0
obj
752
endobj
139
0
obj
[
]
endobj
141
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
142
0
R
/Resources
143
0
R
/Annots
145
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
142
0
obj
<<
/Filter
/FlateDecode
/Length
144
0
R
>>
stream
xURA *ofR0ˣRܶHR63B$S&fJa2k\]d=kBYDV %7&=/hHprMo?.ṈR/l;e2>Mf!IgUg/"w9nJ(ՌYԻmrC)jK劖Mz7E2 Tgu 0R/KRsT>OR[R'tTOOJ5{UQ5pz z 0|0G?CFYT `,>\ˀ!""I\u8%` FkܲWdVk9OǠAb5Nf_@f Z{xg5V8lnF)dr-Ue4WTs ?`{鱭N)&=(ǻJ
r6 1@/'j-Rjw'A-7!m<>xɁqu
\ F2-AgZ88G{1}BFKdw8*YVy0QT .x s~z`7`
endstream
endobj
144
0
obj
750
endobj
145
0
obj
[
]
endobj
147
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
148
0
R
/Resources
149
0
R
/Annots
151
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
148
0
obj
<<
/Filter
/FlateDecode
/Length
150
0
R
>>
stream
xTmo1 oDI>($VNthڇ X+t ']6QQ{S[
yP9~~]TJG
Na(=V`yRٽ$t%ᖓaVR/:ߔa
!iAr&H9
H[`7FXkOP:HEIO"1RdrtbL}6\0~swہ7V$FMn~cq$h=lZ)Z2>ӭ&XF3J\c?I&l>ߵw}BH0i/ӽPyctqz=J
Ϗd'Uk5vkޝxLdқjҗ0)f
ӆ+T|x[Lbq)ą F✥936};1i хdYݾleb,>r쩘7pi )nAcSGև*z0XWfªe8|(
-Qr!կae;?
endstream
endobj
150
0
obj
538
endobj
151
0
obj
[
]
endobj
153
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
154
0
R
/Resources
155
0
R
/Annots
157
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
154
0
obj
<<
/Filter
/FlateDecode
/Length
156
0
R
>>
stream
xX[o6֠7uX/afAۈy(5K (ʲ& !6E pHW4!QƸ7N3Wt(|i5,nUa!{(%?o~- gmK8+7!VJ缣pgpب9e&7yR0!'d6(.Gt!*ou(oԔːݽ(O^pǨg e+lQj>{ (mS ;lZ @D!OceЕs >k)c':U,\Ut ^49gXB; BU-4HTŻFp9gXL!,akLk<*3_Xm"ZLYiߴxxx:7-]#Pq&
?ċ5pĤ ^9Tսb.#?s]s6 ~ڵ< NŠlkrKYi J%8ESw-~ݗ(̽yNt U*o֏h;hgfuEøи\f{p+XhәSi nG=/H X;~ !Fˮ%546jo T]Hn ]GK y "!߇]UZE|>H/%! ^=V\ <:/NKjD_3Kns>\BL[.{ l *2k5W-z˭x Ob>
>>
endobj
159
0
obj
<<
/Filter
/FlateDecode
/Length
161
0
R
>>
stream
xUMo1! A"mV
PQڪڶ {NP(!כK@ ]/;*,AI0@w|(-W` y{;n"oM9\s%j](8k)'Em8kYkB G:Hs[Jk{6%6:ZѲI+6
n|aؘxkLuA[y{s 4<>!$Cnj)L3|
%6Mk?YKG0|QF+K*JOsognn91wNοjon65T鈴B)C׀1xQ .xU-ߍ]{*ZL 1K3q {q4DC;7 IO[ⓘ:g7
,LKrADu>
>>
endobj
166
0
obj
<<
/Filter
/FlateDecode
/Length
168
0
R
>>
stream
x]o7Wʝ+8H8eQJZ. +rmxCBZB. %g~c_*!B]*9q4 B)b>g"y/\XRardŐph>-a{5(okc;jFYUlW0Q'۱ # cG1'%T {J$딑(NuIIv?hAt*xL=MGv(jYӢ ?`LfQ}s fߢXU4od7, )>(sԨw8J/{| tQ;cr
{#dĥwY\!\r:&92g@ij -üX~ iL>ʩ yhU7K=:A<
czQ[ǥuU%߹ s砊LϭNHU6D lwE:N46)o(Hs \ nh`"VMNZZ7ٱ\q+6Gh-L=h:BE--Eek[ Y;ҹ
[ UV5߷#x{Oz\<
endstream
endobj
168
0
obj
1019
endobj
169
0
obj
[
]
endobj
171
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
172
0
R
/Resources
173
0
R
/Annots
175
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
172
0
obj
<<
/Filter
/FlateDecode
/Length
174
0
R
>>
stream
xUn1ۼ 4p|"T"QXC4ڴbNB+vTӭ6R:R@= J5XBO*ucz 6w $>,Zz+8S^&NmrXkCAZЁI>gQW(cނcڔ؆Bj2e DH ºu1l0 a7tV-AH;Mm}#X<@fa:O=k6" \(;䒊2a,֍-'Y}:_/k/6ʷ!eLH 34z+(6t )%#pk7p0*n{yꆼ@}Bv_EY 2 v PjR19w>'K%??`B6X`"nѵB
QYe!$mbu[o0~-9
\ȏwv<*
endstream
endobj
174
0
obj
607
endobj
175
0
obj
[
]
endobj
179
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
180
0
R
/Resources
181
0
R
/Annots
183
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
180
0
obj
<<
/Filter
/FlateDecode
/Length
182
0
R
>>
stream
xRMO0 w.̉'= #R'`PNć֨8nA+fcщ}nT lJbszɩ$H
,`+"-oak)~/
$ D Shg}RHဌeJ t1ͭ!cw"0lWKpv|$@v&(Z G`݃ !xlDPhr`f\L.!}>
>>
endobj
186
0
obj
<<
/Filter
/FlateDecode
/Length
188
0
R
>>
stream
xUMO05Y\*S߱S.bU6bP@_O;ڂ`#=g{c_Q3jszEYwj uNхa~ 3:];~vK>W3us*Ji-ln
ʴ(ayjPG4L
Ar匣
P.R9Y2
ޕ?52G˯m> ˥Bp
-+t<%zFn ?fda70
\Za!f~'k^2(7x4Re,Z
k| Ë R),h-7Urw
350XtJڰEh7hʭtΥ QbOvIIFd@_dF}2!Ӆ={dd3
xgCOF=zL-}֚) +P+ p5
31&,}ÚS]d"/CP[\/C ți
&yqhϏ `n]UerڃU%$ A P nFEq>;=J¶=^Mb~,2 z+f7_PY# ]6]uh=.>K@aԸ|C<ǾAjkeO܁g}ܽU?^J[qjQn#T[e
i U/yLӦ`zB9v hMWlĐUz
endstream
endobj
188
0
obj
938
endobj
189
0
obj
[
]
endobj
191
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
192
0
R
/Resources
193
0
R
/Annots
195
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
192
0
obj
<<
/Filter
/FlateDecode
/Length
194
0
R
>>
stream
xTKOAnSFy4!h\d $<&
YE];ٙꚪ')pHb a2ƽq1Ơ8i5,ۅ`ڪ`angn2og' NG,uzgevtP ]8z0b~^U){bMY@_ >l@
ÃpJ|
endstream
endobj
194
0
obj
741
endobj
195
0
obj
[
]
endobj
196
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
197
0
R
/Resources
198
0
R
/Annots
200
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
197
0
obj
<<
/Filter
/FlateDecode
/Length
199
0
R
>>
stream
xU[OA ۉ* . \ 5ViD&Q_=3NqA۴9sܿo3\@v%@p!dLwdK8+(a Fa
w6yc$3}>~q*G%7KEmxG.cM
s
[<.e r)Pʩ[ev/mژX9e.U4Bc2IzQ[*roXkT|s#h=Ƚ!v* q2$餢^cOZ!ӸiTN!(bnh=ԯ#זōDt}RI?g}_+/TN%mˎjq
!^&D T\ :DŽ-6 61 [> -I#JxC|(,F{m"b8h?" ƉS Q7hYX<1w8P0DǃNXDV9bFxߋ"s/DWRȭVJVWLӑ%^oE4)T}oi)jNI6ɾR c
endstream
endobj
199
0
obj
703
endobj
200
0
obj
[
]
endobj
201
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
202
0
R
/Resources
203
0
R
/Annots
205
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
202
0
obj
<<
/Filter
/FlateDecode
/Length
204
0
R
>>
stream
xU[OSA^2I !aO ) Db
XO'8Sz Ͳ3ӹ|g FXѭ%><߳c mZ WBqC˳7ѳjvȇ GJ5l]W}dGf-˸H
w
<"*C#ʩCb
GDS^&_4K Єq6:j P-&gJ y*D b}mnG$g8H ,C 4hc Q~|;ULJuAr>
>>
endobj
207
0
obj
<<
/Filter
/FlateDecode
/Length
209
0
R
>>
stream
xW]O 7u/}oBH5[nSF |!)i 3c/lh,`3=+\Pz~*
#,o.BF0y>%ig| %71еN{A'NhkALϷ?ChT *jF^@9
9wNAJ!KP7JEZ"}@&m8EyzCֳ- {![v {Gl {ju$Ӕ{oN:bٵ/!yGg?Ii8%&nN*^B~"h):]f_I-Q68qa4ZTi9 1X=\TUzhk
E"GZgVHM-64X3fV
CndV Rj츣rl1{ƣs-)U
| h Nkt~.
YUaii Y
fwt\AU9 T?ZU,rv#?)I4ܥu h"2ﲸe ;*i'x[j![\ AB,
endstream
endobj
209
0
obj
980
endobj
210
0
obj
[
]
endobj
213
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
214
0
R
/Resources
215
0
R
/Annots
217
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
214
0
obj
<<
/Filter
/FlateDecode
/Length
216
0
R
>>
stream
xSn1M% 3=%HhX"ԇ
h"iI:+\u \SJ\Icvyl;Pp,v]
{0 "905V7h͉Hې|F
oo ?5
endstream
endobj
216
0
obj
517
endobj
217
0
obj
[
]
endobj
219
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
220
0
R
/Resources
221
0
R
/Annots
223
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
220
0
obj
<<
/Filter
/FlateDecode
/Length
222
0
R
>>
stream
xTn1 J8x|{K"a>T@MK
/N디(kmfh.Y
yVHY_%({<)%gS9
TSRZxb`U0R^pw |VUrƄ4
Q!z܀% e'Z$9"+ܔeb3>rN<m4w4F&YoGx=4-K.r贗^#a쑶BE.CyNuNgvkǿ֞H$1+T{#C v8D ĹW,Og&ⓘ26g1eyȹ!c9gC sxJ7]!@1qlN<wshC`WG\^:h]AmYcxzhu: 5#
endstream
endobj
222
0
obj
521
endobj
223
0
obj
[
]
endobj
225
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
226
0
R
/Resources
227
0
R
/Annots
229
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
226
0
obj
<<
/Filter
/FlateDecode
/Length
228
0
R
>>
stream
xTnA )o Эd.\ AH4"ԇ
h"iIgٝBE|gw
Z*HFAE,`
J* 0{<)XGީ
Q1) <0s s"k~-,~绔bK>3>*N7mrZkCAZ \Et[`7F=Xk/
P:hyHH.M/SӜ3*w$ ooh+mA{Ok4jfkw8ڟp,OW-_ֿ6XF=3E|A[0vw OVW o^|p3N{:U Q= 4
wީz
֎`fe1z_joĤdq!H~X|am*>c#q 3gԀ9vĞ3q es)T
t!.cخx ?>l<咥Rnf10X"k+ q{W]
4
endstream
endobj
228
0
obj
519
endobj
229
0
obj
[
]
endobj
231
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
232
0
R
/Resources
233
0
R
/Annots
235
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
232
0
obj
<<
/Filter
/FlateDecode
/Length
234
0
R
>>
stream
xUn1m> /c{}D+jPPDhӒw kwg=x-j0r5(yĶσgHΓ}ur&-'0;d
卂ŏ<,b_1s[7:lh}QF?!bvC_8o
cˈ:En_yʧ3L:Z+7sehA6Ka(IQ H6@2PDX5~Z@pw80JorHL!{'x)fc9=W|ąxv`]}:p&űJ\r \Cw
n
#i9GigG%ֿT DV |NP,=
e7#X[IRFT8 m
]:W̿ !]:1KjjŋA8۔'i1`4P_ 4ꐤc2:(fi1)cчuk5,ˮ} F [+ԪppQ #{Tz7jaih
endstream
endobj
234
0
obj
569
endobj
235
0
obj
[
]
endobj
239
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
240
0
R
/Resources
241
0
R
/Annots
243
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
240
0
obj
<<
/Filter
/FlateDecode
/Length
242
0
R
>>
stream
xVn1T!$| I%\TEM/Am)ԇ
h+iI
fwPHTxxⓌX0b}7#.*`WueYdv/kEKMJ~EIg|ϱɈΎ%?ߥ/O~O>Q#Ji6`~,Uqkv1rN醚W-=<>`%_[ޔƥjiHeH@6CS)2/mFZQ)GA R;\Qmh%_ٸ8b8yAyqҞ(x1 =;q{9fKA 5 `]"#;dU6{kdm@:d 0Xv/W,ZHkbˋ)_:p$ 4Y yJe05^Oʽ ?"Lt8W\B&&Ӧbҵb Y̯ ժ% Tm
'13wNNRhnWe!x2V-['4Zmt/r)4i7& }$GVXYc:JU
hN6G{H[3
[bb ?39h볧}u.@E}ӓgZrl:{j}E܇`?c苼kYT1=?ZYd I$jeSG jڴF7H) Ndvqh8CQ/
DO
endstream
endobj
242
0
obj
752
endobj
243
0
obj
[
]
endobj
245
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
246
0
R
/Resources
247
0
R
/Annots
249
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
246
0
obj
<<
/Filter
/FlateDecode
/Length
248
0
R
>>
stream
xTn16m /c{<"VpC4ڴcgwQb
Tb(] eX:N%6o"o&0NJW/s7+=U\ca}}"q^}z[1EeRǧ˫wR6|,|(`à3
^2/&[Ǖ&ըA' 9FE_64 7כmWuO5J{⳰HB?:G0v .7u8
u 1 6+wGDFN-(Oųσ̟⫰3*h
^3+|3P! qa,b :p?AOt N'͓/e=x
endstream
endobj
248
0
obj
530
endobj
249
0
obj
[
]
endobj
251
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
252
0
R
/Resources
253
0
R
/Annots
255
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
252
0
obj
<<
/Filter
/FlateDecode
/Length
254
0
R
>>
stream
xTn15| O|@"V@Y5PM6-)7бw7뤡@x|<xV4U%@IttkVJБw*7(6
l-pAV0~X+g^pqoy
:9oYF}_"~p0_4c{AI /H x"Ӵ = Mji R~sDmw"k6a|tuͲa@T>H|ěG+ +ı8+
(3q NIxa1eŗb"Ny~4,N@bv L|ġfC}z .1o2%Mw b)o#Unl(ct؉E,{v
mL-AܦR1n(}H)i~%xya-)zsrţ:Rz)0͐g|fm!wϠdVSa6@O=P)㹠DܚT= X^~&7.pSbZ[J| *z
q!'u
endstream
endobj
254
0
obj
588
endobj
255
0
obj
[
]
endobj
257
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
258
0
R
/Resources
259
0
R
/Annots
261
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
258
0
obj
<<
/Filter
/FlateDecode
/Length
260
0
R
>>
stream
xTQo1 7?@II8#nl Q;@kRLn@cH⺘,];FLLY1rM H YB3s5:>Ci:$gOqe>n }Ϭ81$rrLKϪ`i l(cy{ ai#E,u,hc%/n
]>f,B"J 4:fmm5յųG
k~{Qpb<2rE"i8nU\k_&'CG!{t%RJ9#wF
#.9
endstream
endobj
260
0
obj
529
endobj
261
0
obj
[
]
endobj
263
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
264
0
R
/Resources
265
0
R
/Annots
267
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
264
0
obj
<<
/Filter
/FlateDecode
/Length
266
0
R
>>
stream
xTn15<# J8GhEBWJC4ڴ3llPDX^ %s<%h^yKPR)|tfMX z]Qr9L,a>Q0˰ f;E!kޗY
&*9D
0[E%R'W}NT-9X .HW!Yzs^E 1(R
"x} c1.uK~Z ?{/ѶVFL)yhj'(މ31Hu&//@ gI:fLi_d(VG:9(
l괁khOݹ o)_TnkUo ?u1-Pޙ(}ȍ"%F
kH|KN607t q(CezR>{k=ܠ6t^a^@FI05V
} Ɨ!?=ũ̱P 66
endstream
endobj
266
0
obj
516
endobj
267
0
obj
[
]
endobj
269
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
270
0
R
/Resources
271
0
R
/Annots
273
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
270
0
obj
<<
/Filter
/FlateDecode
/Length
272
0
R
>>
stream
xUIo1vۻCrTµthzB% O'ٜi%4V2_)H. sB`:i 8+ym0NG&.(^WgN4ӥ& Қfet^u^ \Dlvrv9fJ777.uk2-mjx.-VC 1FV-oD4`9J{띵)eM|]Aq
[ۗ5?
ًGԚ{ !X(*W-
Aʀ}biJOR}&]ecBcʟdMc H !F1Y4f;CMY|GPèX:eGܼC(~Fw@>x 5T$
XvJ9Uy>|T $k\C0C@ҀĪxy&V[L-SQjџ1:h$JnX^bjv } $s22{l
Ik+ #F 0 ͪ<@FUFa}
d>Aa-vrrTKҋQpsHU* 7'= L@ҷՎ$fht1:LdVTNkI}TQ[|uf[Ũ hw-و Qo{(v܉+Nx% gƞ
k;6RJ~BwlB`/aֻKd~7Ua= tu?
endstream
endobj
272
0
obj
771
endobj
273
0
obj
[
]
endobj
275
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
276
0
R
/Resources
277
0
R
/Annots
279
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
276
0
obj
<<
/Filter
/FlateDecode
/Length
278
0
R
>>
stream
xTn1 ?? <i'qD!!mp V8&ʀ4h ǝa%@It)#6}J%wUNoc#6\&+DXur<q
]-徭s:ݖ`Ǡ VsehFͺ;bp QD2@c i 5L_]$1 47{/e ct|0T|3^z# [=\,'Q~Vdx 3z [G q̔OƘ W0mvG(Zh :uw&HO#U(c^L"m,Y:ژ&xKKDIA^knZK@ 붖S[w jOY$ÂjlEn`[c|?0 e> s;L7S̐&ZJS!fN k- ur
Vz^T "jR2-o&{Z al
endstream
endobj
278
0
obj
574
endobj
279
0
obj
[
]
endobj
282
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
283
0
R
/Resources
284
0
R
/Annots
286
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
283
0
obj
<<
/Filter
/FlateDecode
/Length
285
0
R
>>
stream
xTn0 7@!.0Eu}Æ {hc >ۚ`pڥc [NuXEpD G Ji,װ%U&[(mk gSٽ-7IhaW=_٫VG~y\ žSc" `~۟,E ޜpnޢrRg˯V|Sh\ʖvez/J[vXmKQ蛢H#CQВP Q_P?OC}{ cdk ,`*^VS1DgK1 c,*9KQ5 kBܰ xGl {6Z\~ζYTp8+Gסp_TW$Yܱ*Jk`>CD"+db$~2- uɤߒI$}@˒N.ʼn8Ο
*OL4`*X`i<GoF%g.S U<x
ati;+
endstream
endobj
285
0
obj
536
endobj
286
0
obj
[
]
endobj
288
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
289
0
R
/Resources
290
0
R
/Annots
292
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
289
0
obj
<<
/Filter
/FlateDecode
/Length
291
0
R
>>
stream
xVn 7 o"}hP'u wua!46qR=\n JsDR ~m;Z.1+opKCwӇ!yttCohE zoU| 7๛ gޛ9/+ w>}uT͝D %XSr-rQ<[Ät3$*4rhn&yHiV3b1;&ǜbhg-t=I2?G+x7YJ)>wtI *f 4/ Y\ruvдX_9h^) Vr]u
i.j.sA{qՂ}I'
M>e*o/+Dr.LT3f nu.
8o1B ې"h%q1@,3 gYr =oy|7QEwdv)i6 G &LKd# UC99XzO%8Uv;Jk*J^]/YaX' A ӈl4YC9TaLdq$GRlaYJE-JNlh ָPa-y 90APT^5 %+рY n 6ɟQG{zD%1} ;;OM߳G?"H`P%(ǘvbakt͖-WO%%f.qK.l!S9oWXJ$Iyώ>R-
"g990W|豑uiS$^ُWl]|Q[X;4YѶ{]ZFefy=cCV24]qC9]P߀]mM?ӖR1d\tZ?mv`
endstream
endobj
291
0
obj
943
endobj
292
0
obj
[
]
endobj
293
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
294
0
R
/Resources
295
0
R
/Annots
297
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
294
0
obj
<<
/Filter
/FlateDecode
/Length
296
0
R
>>
stream
xVn 7 o"5PYC I @ x ~6`i~5:'q HGDRK7|WtMXJJ݇~cHVnxh[ $״ZŽ/ zF6e)ޡy3vj 1¨W//
~}Wk/HTku> fH>Thq:!(VS}a) s'PhwodXכW̥Hm \+:nl^4;ͳ9Y.ȕ:rkki1³ Fr 9tyN2g7hߧ=wՂΩ}N7$ m j('qWT0\al)l=6K oA}~yH
ېR44o3ޘ1Mʎb mزy4A[g} :Shf=t:gn42K8*Y7ͻ CTSlEkt}NS z|86Gz @m6!bA3b)* К0n7Su$b< )c"1±>SȨ&J$
d(R2$/^LXg
3;#JPT۴YϷ9D6qsBƥN4='GoH+;lM ?ֻ˻N* VY: "BdEUȡ~CP3
ʅm2N3 hp:[q\MO4SeKVTj6b c l4wtk dXcjZ,ZUɷ?wQW_|m d䖨 A`
=[>X}
endstream
endobj
296
0
obj
941
endobj
297
0
obj
[
]
endobj
298
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
299
0
R
/Resources
300
0
R
/Annots
302
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
299
0
obj
<<
/Filter
/FlateDecode
/Length
301
0
R
>>
stream
xVKo6 {)_5P3硇u!^!469H koq *aW'p^ ~7Rz2K}"7tkKV[ߧiwL9彛31lr zLWݹb>̘"ϯ\-.y/!P%)v9t3{Fd,i(iT+bx9JbEI!t4K':|_4-Pn2~Ι9@m_\[:efټn9Y.sru״½(%/ G=gu#QsΫg\53 ]/}_!UjJ9KkMX(p^!Pb\ ض>}E].D>3 LO}0N0UML lPԎb4QuEwdK5+ J* &@EcI G98`MH9DHEUv;Nk:]]n6# V R'9@ :r1%lĀIm0QF A`h3IDm0TAd(Rf6 "J5WͰCTc5sx);m#:g)N#:x\wFStv{*-_Xzp*Mwzi^Hp=%\) [|ͅs'%Q*VRAc9ۺ-t`Av&C=g j\
!\ S['[M5Hs'FO`P̃O1W6@
w܄|yC@ :)CN^;i xYfltֹB
' fy /o{ -pS~H>8ڧ3N8PZLLurgů& M
endstream
endobj
301
0
obj
969
endobj
302
0
obj
[
]
endobj
303
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
304
0
R
/Resources
305
0
R
/Annots
307
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
304
0
obj
<<
/Filter
/FlateDecode
/Length
306
0
R
>>
stream
xUN1@ w?KZB
J {&@4GRQ~ԄU[Jq)[$-WE}8hĐ6t'#~>Wt|K>\-e.7 Ϩe:̖m)6;giN%ܶrHLeoN}qT,>Y=˲M99
k5LLlbJh6FQK27SV7+(TݹiiOSu9{ 2n.v("ĮXECɠ &*,XN &v7cl'dOpU{]- hNעp;TdT㩮0&AH!t JǪh s8ejucff}' 0.4blH@':Q2!qe3]n? ;+7Xz
j8 o DS mMY
endstream
endobj
306
0
obj
803
endobj
307
0
obj
[
]
endobj
309
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
310
0
R
/Resources
311
0
R
/Annots
313
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
310
0
obj
<<
/Filter
/FlateDecode
/Length
312
0
R
>>
stream
xTn1^l% 3=hHzHmZR1vNZkٙc@KyZ,_%x)OK@gS% FYOhag0;dōryž#౪u&__~ۭ,"v]>=*XceQ'˛w}J^sd‴bz_ CWU*[ 'QDp2J&'w K?vd.
>X|Ob*f
hdb$ދ<nj+q؈3IctnXbĻlOqkYa:
\C i7
?|b:8kt
v 2ƛ
H._]@abڜ"&>QrJrxymS\Oz zU&F cm(5VSoZ!4!䐵L wy 73ofy+7
endstream
endobj
312
0
obj
525
endobj
313
0
obj
[
]
endobj
315
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
316
0
R
/Resources
317
0
R
/Annots
319
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
316
0
obj
<<
/Filter
/FlateDecode
/Length
318
0
R
>>
stream
x\]$-i_zKAI $
<( ;b!!Y)?\\ӵLtu0g}}}.z}|p٫A)CIQz| J/Fa߿D#/_H_O=߾/k> 6ICҊJ., eL4#X,
u$_\wAXn]+>b!?o {m+oi7~pA; 2kO7?n۬T C
هL} g>:c@}HpКZ6==J,7SǝndN1E+XzYzF [, ՊyZ
X~]X6knjcN?7XB>e.q
f֠[J^jT+ eq˜Y4}H*,r:֕P 5مZq 1
z2NT:Ɖ\wϺI?>?/꾼љgr"u H1,o?CLϙHa.;WFg7}I{}ig0o_ޠ t Ƨ `JO&2;%g'a6T`yCflvss4c_rɲ0pӗ~ؠl` 簃iv.L^?sh*g`*Qhl:ϲCS2(nkD 05[s3р:l TA`9,wkn
r֒+{)0ل3, 0fe C F;C.}:j@s < y& ,*[E?o!XO
>q[8;)@p^ u[3,1Kaƅ4cu0Ut@ty>9.+th9 ۭFFsFS3+2 s@l5ߵ`PPS(k@n\V=8M>R*[CvN'H|HϾ_`NђP͘&
#
DZh>1Id9K%`yt+9{0Rr@H8Y$l`4(T =h$
Dx*@*
$5V7 6T 0&]HYae Va4]c*; yRL^
tN= RlJiF'k GADg
7I,\C)ңF,GM=GWI%=F80r0eFR
C:G\r؛ 4+O8MĂVzEB@t)Y6BF/C&m> ⣒ =5ȃK;ɃQfhƀ{J&a9Jpׂc0B@<["@K|3̦_tZA@.uzRq4,|u@5KUqlN8&̬8Xb[C]z$K~31)t }rJ3]bfW^eF8191Z\s@p-tˋ˒!j(ĶR e
e!yDfOZVK
+e,8! U<̵!_ޮ4~';+Ib9DmJ6/ d f̑ry9F|sk%L1|+[)r/I&Iʉn Okn130bn骗yv9_
VC$, ԗMalhX|}ߟˁ\9@rGiڣO^Yw TW0cp]=KGYe.{ CΤ9Z&/;7d50[<w6r/^"r ։Q:n'tNL,0R7d5 ZBYU`v->E5C7&۸["OC\r EzM z]rsz 2G XSzȨ4nCe 2IhQ$h%mSCXyJE 2 u`f?jv0i> CH!#&KIGBS0«gjƧ%67XvLI I`d!8oWU0ꅻ Jˡ:g^GjzS000ِC/;xE [tݛގ8Iܦ= gFdg.՜{/f8Mi\FkFޮ_ _^S ֑#Y76nF6""uˆPW{O}E.ڡM;:ա(umն&y֠mG厔
+!cZ
o jIFW@i+Ai A_
V=/U2)-
K i|5͈Z 2 ^^|rߊ>m:qV^/+:q:q
GwY6l3:qՄyiI'hq9t`Im:r/|'Hzz
5m*m4m;r/omK:t߫ttoLrГnttoXmT [ 9]w%tl:`Xg& 9]f+Þ w+ߤ#ð+ԴQulhv=y_E<&nxǞuoZ[/+?7㪏jTV-1ꨛ<3[؎7lpN&-OTY 2騝 ՟l, v<0y2Vg:sӗ
^tOϺY~nQMI?6CtK J>
>>
endobj
322
0
obj
<<
/Filter
/FlateDecode
/Length
324
0
R
>>
stream
x]ێ$q-a_|`غl/G Hh5;Վ )KP
t`əꖄFOWN&8`0fK?IBNNpcE
> /Oӫk?9~'?%{O >~E_47y&Vb$*s-"ׁ
*W+`됅Z?D/I7Mtq2:e}6rVoH=Ko NRϚM/vRv6N馗?7?O l' ךk|ƠJTX/:] 3#~
nIN|7baYWz8Qk֒*d iOPfY_[E,Ͽ|xf҂?\C
* ~y3fz3 D'7O^F
yBt`"l;:
t :HOzZp
"͔xuQ+ IO{xA ~{x}CF{ v}=C33ڰ:ւ6 F5|?/7'kw}$ 5DH 3`gP"?<|3"<FlԊ3RA,
;
5W3iT%/DF9&ϼc bChvv [Bc,ˊO`Xn;"[95+P /HGGJvR MeQ#WWVڃe [J'2T1*2@ElttxsTnXK 5-]k
,em(p={
ovޡPJbOa2Z
sJGrzeu֢Et;4}ln J p;Z
5P]YXGa)Z)!翡T(9S)̽XXK!~
ʚk/2 ZTu}N\
:6.W q]N$˪\ q&VZgj >UE Nf kۗ=tUV$:*d`FMU^m^e@>l;DѳVc9dϛsERD\ٱo٣(-;"ҋeu `ÆAt=2:k"ZVW O>:gO
3R(A:
,-JP(MbG6B(̽XXK!m(T+,# (Ej[ _wx>q>
Ͽy
/gO\t
3RL@:
ּtjEQX
v)TF PH}G0v^,P̆B-D]2 ZVu}vAA1 :60h`X:Z Nא˜7 :b'[)Fdfd.Qh#][3Ng5fe>z+
V :VwԐ=$yji|Avl$Qfq5lzDy tۓVc]O-4}Ze55%3uym 2 ڒ't= } N
Uױ,#+|DcS{^ʰa0c-*cPjr2Zk J1(-IgP:D`2ZemTX۱,c+|D#S48|Ԟ=8 320,e, *m0aǠ֩Ae--;s'2;q` [e Ur;8}dj;80|Î-V1>
rup\&QԞ=8D 2XlکZk`snl+5ϹP+TwX`MC d҉&yu ֢Er;8}dj|
Z5UCy7䉧wƮqFƸf㼝Uh~c2ush33pzFsmf{RYr~1XZ0Y Mo#Y}&RZ fUZ^GP.xӔk{Ur$n D~VRnvsf69\t8J >:Ⓝ~] ^ ^u`y*OHFFoEۛ<$\w4w!32#MQ q''#e~d`Ì3Un+RV1ry%B
{Um!:d*E&Ԍwц v̐ZWk]ӗm;ʠ6|N ( wwVj.PSMcF``x#F`Bt_׆{&CՏݲoіٶ5հC^mwFڵ
G֊}L#NLwUfFlzP#NQXfHF#qҪ8@ݺUj,y~ B턵kɮ4dog 5u*6.6tBz_!dq^v-ٵRWUZGֱt_! ;Utl <3"
9]j3Ը{)HCNPSGֱt_!{}6 j0NLc vRY)(d 6MH%9-kBl { f֑*
"5ί:JBmVr/xl(shW?~FSShF.p^b/-KAJX( ,nz;-}T" 9q-` -#`D]i礽'2qa8H5 |Kꌚ R4H8̭TDP2
]Dk ib4_xlSK!J>C( cxlA-iFDR=) $Q@}:d#P?pq)@O+b;ZTwhrNNy1FtX2D-4^X;T>1R.hV@tcd/{EpPP,`;UH{'7ڦ rʪZF`7e,GZv,PƆq~hԄP-{v4j'IaiG&mq} n4UFe ~`0Mήid⬊*@yhchnj#^DM) 2DqDܛD%qf Hͮ&DT8S
ʭ`/=v(? %!#ӯ
<>lFDM*R@^߰co[ ~{ߐH$.2PM6`cLag(WOt4AQ &q箷 UܵTzM !cF(#4 df8Y xl $(3I%qKuUW -_'F5I lr_۱ޑ.Eb B{QO HC oo)"9u915=Iw|ZLͮ.2<#7<)iAAI:Fb`ˋכ `)q\HӚa,`ghieG)ym#9S)Dxxn1~g5v-M){2`pccP- nw3"\m6SCŃ48ktVKidlZa;ZH^údo9A6)Z¯)_'գN:=KRebTq-^c҄c OQnЍ^課Jш|À1OVѼH/ӕJb(X h]X.ݏ AE(\Ml)49N)!e5 ^QMaPh Ri+gsb_9 ijz 7ǤRk g+p k#.B}skDC ++t[a^>*}]̈́y_ >rӛt
hx7ƾ)hHxͬŦۋaz:AwR[ro[a- *-H!XNIUrG( v (2}vnS!8~0дCETZFC+]HBoSQ'ggWM'xP%9a '9pecq]w 𐹾6n!9U>0F9gCl RMxOE}xH nCJ7Ka RDL%7 e+k|Eߏa)M}ydrt96M[Z bnlENn ^1j8hp:q8)ӛw#0f/u3_i)eѧ>b D]8|u3>Mc2͓}{uxz2xc ojʏ KV7:{k0<5
{ gf`k;A QStAܪ ׳tЄeW9y}.}F_R
_%O|O9n}^pI$ Rq~_>o*/$v ݤ >+>yDn}2,
endstream
endobj
324
0
obj
6524
endobj
325
0
obj
[
]
endobj
326
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
327
0
R
/Resources
328
0
R
/Annots
330
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
327
0
obj
<<
/Filter
/FlateDecode
/Length
329
0
R
>>
stream
x[ݶǵ7=(
A WKM _`h469ZEoUtFɡ$'{$Ɂst+jq(Re;i*EUR:ʎ{,N5Sc .~ۯo>\6%{JG~y#}^k>L:1!ЙV:G+*XWCAxT\,6!9l M?bki>y~lR ;jo6kϿy
ujמOοho6o77;k֒3Vַ ѡ~踗h{
`Q>luU'Tw{
+6|2ȐVt ´ZwFO0@FbW :m ;{t\.hkMP
uk/C(=H_!-nV :Dg|BAfcs<}wSC6ggc\(EBwdL8n%ŌNdZh *"QD5cD7N+cCe
R֒4d2ߢRć4rt( \P
ZiiPʲuX~44u4lW?m)bJ
!hv[6nG#_$>$WLY74IsDxB5B5Ԋ~CEjOP;{ղZͮV oh P I5@HKJUsтPa_!9]#
ajEI ms+ohR4.Xyxyd{hW
OS{r<.AHλixz L HnҒ~-h'#EtjY_8V .i\yM7ӰZkH5y7{ɫZ6(+6WWGk%Z9
5휕~CDĎ$bUãa_ң>P˭7` i jYR
"XfK5 lvޤK+M"hfB`:+V!,E3BmBm#BlP;zQ!L74PG!-%*hv]1~lGx /n0i! `ohR4#hS#kY!iv_! Ԋ~C! F%*hv]1~l``|)
BrW0^:Z+/YZ.smЯ%:՚X(Fv .$ 9k38kt58NGmGlYޯH65xH|O͏N͕J
hr0t^p0w
@Zz5
R]Sm~CDɄ$OؑQa O+FZ0:c 5ϭ%*h\6r^hwN I5"
MJId&Hȥ5Am=F~MP; UL74IP܂ (Ɇ%*h\6r~hC'x -ڝzA0i aA
n$XJf`,-wj`+@ Ң"oh Ps` ufjh\6r~h|%y
R h.etƎJRCy㥂\,jdZ|g ̋E3F?[|"|6H-#c =_0HI˩ 2y
hZ1t^u+M+)_4:4P,ss!(3 1L"L& DB0+FLV,E犁GFspD& DgQ۔\UW$XJf%Yy΅`sJsJJKr!s#DJs
#M'wRsx5Ooh&>]N> l4 ^ +D. FOyu$w
d5 ~fȣӖ.܀1{iYy@ ֶB6:K sK b ?)
n `˲dMX
@ 8 X]hX(`'&Zo`Phc{`. ~1S_C ԇ7_74_5͍gFV~
Q3]Û3k;~SW @o@j;gj,Bۅ \?M\7
.o5؉YF OsBsyAhzEA(čWdrY;Ρn6'k 7un)Qev}acgih\P`7kB?ߠOth:|IWk ɿxt~<䃓gA~ӳ
Z3~#>s 6
$M"Ľ6
;zv
¡ @!>rf|4Y
ViZ$! /2xlArqsrjްt'j7kŖHӪnr u'h6Z=zMD_.:iLR;qO^[)Z[tuT {]a={`G_8E߲c/4fĶxAՊ?58OA3Q? wumOzZrì BA̖Ke
Riaf q 뎜 8 ? ЉO͝֎x4;OGg~<ٲ7|UnWM"FĎ&&mMY4G
YѴp M= AioZH PaP%K
endstream
endobj
329
0
obj
2939
endobj
330
0
obj
[
]
endobj
332
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
333
0
R
/Resources
334
0
R
/Annots
336
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
333
0
obj
<<
/Filter
/FlateDecode
/Length
335
0
R
>>
stream
x][$IqվX`/&ތ ]b5wm~sDfeDduL:s 9mG}qȮhO?9ck*фCѧi31r\Ϗl?_f{7?-^.})і]9XL i/ :\v 8%HH0*,:ENz *au *ٽWw_E^}?֟|gzxt
6 _w ֥
`?6`|RS'օN%ָ.%":U~p az~mb? YH[!m7wF!hk ~v뚌bM" C_;4z|N9[/˩Do"C) )]$ҩZksH/?:xׇ@ ?s?h 27L#1_co| )ZXN>Fty\&,2?1Y
Kl`0eo-[5??50 \*S DĪ'rncxT ah%༁]$-`E^SrͤT !
" "DlDpeH:ů ~ii]Jy征IYy rYT&X#fkrr!^.6:p⼁Ia< mO#y\Ȣd:"}Sŷ'¬\80BӚ]J.y\HB[jukB+z.t (t!]V.t1[F16EtDpeo۷{U LLk"S^hzD HR;i+ݵɁ=d:p\;\M%yd5IiE5takH99ōW , w+F+Lz%Ƀ|ϙ=9>g>+LzoCf4q6yErL6}ŵڑoxrܪY7g#!xrERBPg
>m8srˣ}2C֡gr57(j^; ⣏q ءNχ=~,/wp.}9*65< :n@dS6|0
Pq-A = @=U b*)|t|tsh-yX 6flkƙ9:30/x]JE dh?`sY>C,X9ç>s>=sk>|o O%;z.%Z'%s?|\ɜNmOBK=f9bNB~&f
H'ͿGs?PPi,
z[MuA.0 4ѽ66p*
RIne= S3!lR ?|䱃?>| ~>>?|qg?;tVWfL vq*~ ù0eW?
!kaطe {SWC|J
B~-O[aqM:moPltKC=EUĉ }v3-A:Udse ? "AA*rE@VC]6$ȐRk(#虖h $4~]En
z" !5hUE[v0G}
.9$bkM`:a_sp Ij@[ݣx 4 j; ;$L m4s 6E ]IJ$2OIԌձ27cc>U2{!`2weL+y}1 kLMӰ y 9ꘙ0LZfPWfGZwq)f )2;BPs15cD#du젯B0s13c̲JfPWfOZ:LF"~*ZJ: j:&iXVܺu| kG#Y+#\=?oeL)ّ c cU2&Xc> j
^] M?7)r ,aJɠ̎d kLY ;+sk2>5cXViITݺ ຎeL+ٓ LͱԄ1
*A_8֘0GZWWfG2Ok Xmj1dRR1PmEA_OD4:fYV2s2l{`1.^
%evd3S1 *A_WJLD- $euev,1:.cZe,cJi̎acU25#LՕّ ڇ)lO0dRfG2jk|MY ;+/!:bfYV ImH|= l^i29Ckٱa kLM&Y-;+#Ƕ2&-cJɠQ̄1 *A_ յcj5jA]=iQO)O늖1PRfIPs(25"шPԱ28OiʼXc<%ኒLM0O BM L<Ϧ{9bl0|͔
!z-[ x 1}
'۴%f^?(Aɷdx[<>m[ZjS#>̋p> d|<=+) }@.=E?R{%gsiU ;?A # A >=|w=yOŁVyl;/lZ;,߿:{w>j?Ulp'Ӛ.{ۑ (IZkn]'E;wlO֓j[B%oy %qJ f#F9 mV8V
f , ;*1x=eȣ*&| rl7ы0'
kSvC 62'mŋ>l ºJ!zSs0ST
N.o^4BD) awkJ0X`3N% wWiM ?%4r/TQ쿏Ksy|&#ɵ ClzVOZB5x`,050ȶ:[Hꂝ7Qd1 <SK{!~T;٘NxV-pl]ڳ&|B e}MNyHԃm1A+3n"mHyH aJfd+$a L@*㜂$NҜ<褹nE&ˋl
&x,1(Sx<<[BJ$צ~c+M*
X\(E}q;f6M"ј+^r:,} ;of'O{̈[HV sj5K-!H^]!FiI`ΛeBCDFT[tPIy/l|7ÄFNU
Js
j _P_e#4u4'1fsJl/ "L47w7Jm qz1!͔6.lpmlJK&o
5fZ5^-(vp=jsxۡn 0`A] lPJcr) $ P5Prڅ
eCJ,
٨m*%`J$ta-cfe [á-r\yJ fGGhRZs{s 7U0p99,6_[oqҶ
Ŵ-- {~ܷ| c%H.pfz'҈mqj%? B2:cIF!=K D6F)T
פ}NKQiz )$~PUo@-0vG, kj;VۆMM"rw
>uу-
Eu'Ԫkx`%tԂTm?k/CێTBw wh[U?)d69. J%@Ql!Z8^?1IZx ř6bQ'"|mhh
"b6w_1Ol1F Vl_FNn3%~E8 ac TE"Xc!#/i,x` r{|C6An ǥ_е}gf
8bPи! z (^罦5yˏ
èKзCז 0~(ħ0,ng)Sk`-6d ] =Fk+ U`=z ձw.^9 ϟ9 s0(S?_z=LUXv M0<$.- ~%(0Z7\ lkp} X:2Kvm*Q;9
Onvk/tv0 oǶ5 X'tPm3r%EyP/0<(x$d꠨QAQMZ;ტVE_u>(rmω`ϴ es"|h aQ>'j_$79$g?nPVDxrLNڹ[xV|*$7^ߴwߍ
{SB4'!nxNJUnt(yB$kDKquy] kf. "AA*r# 2 |ju^WUdG3-9HPiŁE\\CPkЪ<>蹹ܜ |HYWV/9x@$lʍ/8m@mH
\Y'hi.bZ [Ruue ㌩#!c}enLDZ|1 *
^]=@EQ#sD#sꪮ̞d`j5&iXVܜ DZ| >2;ۗX,K]] 9֘1:vWd| kՕٓ Ծ\/gL/'Y^IXcje젯| kG#Y+#}5j_Θh_NZՕّ c cU2&Xc> j
^] E>&ۗR/uuev$XcjƈFA_[Aq1 cDzJWWfO2PrkO&ڗV/uue$Ss15aLòJvWd`>5#LՕّ ܴ\ ]MYV271D"ֈ1:vWև2YD 13,dueu-Q]IV2{҂E5aLòJvWfGZ0:b&L0ԕّܿ\F iL/'Yf: juDMӰ u$D ad̎d2H0ZβJ-ՕٱFjkDY ;+5B0#fƘe̠̞"2 nL/'Yf LĀ1 *A_g&cj5jA] iEy> _NZՕy|Zf:f&YXV H AQԄ jղ2{҂:H|Mȝ9ڪ+ L͡H4"u젯̭c>?S2oﰿ 7c
ؓp㣞;6ƟQ)
endstream
endobj
335
0
obj
7665
endobj
336
0
obj
[
]
endobj
337
0
obj
<<
/Type
/Page
/Parent
1
0
R
/MediaBox
[
0
0
720
405
]
/Contents
338
0
R
/Resources
339
0
R
/Annots
341
0
R
/Group
<<
/S
/Transparency
/CS
/DeviceRGB
>>
>>
endobj
338
0
obj
<<
/Filter
/FlateDecode
/Length
340
0
R
>>
stream
x]ێ$qm/F?_Or+Y0MR )2,, Bd_?ݞ]+jg;D%32*ꫣ=#C0> :1MO_wGbN/31r\W?~Ks.߯=OW/ކ ZNhKR&SB 8vq Z$"_o)T~AܭCE;oF7p7_ ţ'O z\GO!`Mڛ_ ?8o_ ] 3ovwXm ,5Eqb](Qb+9K]"17\G{ݱo?:w[Mv&~= LCP{kf
.4 %BV
vOq|0
PчFN%6Su֥%E~S@ 蟫8cS2?9|x |r|dĽYJ8MڦR{m8?GM? ЅT !D+ϧN)`?:ՑpO9? _~}W_ `l'X#z.% I5#09 ǘ.ap%Vζ^1f);4G*mJ6G -V/ TR9",YrEOoSA# ')hT4\ %CC^V2#DRCUur1;wy8p2mf lf= S9 WO_ I]O^CH7C >}/?u:?= ?>>ѫc}S`WXf-Ihj2f1QT~,/-'\Ibq2"Rf-!t$-"o 3&2Z3L;:UdsP*Uof.-b\CPiЪt26U-RA^C Aϴ XC1ƯȭA\ XC j
ZUmCa` ۿ2kp1̱!kN&0WR/9qɐԲ*~j4 jCK@Y68)e I5e#4BVܸ H>5cXViIBZ߂ٰ?ƴAIGCLͱcU2^ $3G 3L0Y-3+#-,D
Hޚu$L)-ّ4BV?-3G 33,dueEI#qd$6fiVZ()t uL=0aY%;+sk$8֘o`oj
^] Bdyz'˘R2h)#5SiXVܚ c&Օّ 3Y /Ǻ2 ZHAͱԌ
!c}enMDZ|1 *
^]=ɐ[c;&/ 2 JIXc1
*A_8֘o`oj
^] |;bVs]^SJ-enB"p{`EA_OD4
ju1fY%;+sk8`jǶS V>X7ie2;E)wǘe̠+A-nPLPY-;+c MQǧ K61RfG$E1wǘe젯̭6&Օّ ɶڻ)l{`61dRfG2jk|=A#du젯"3c̲JfPWfOZvl;Eb [E"cZi;F!PcYVi(5SLPY-;+#oǶ2:&ZƔAK#3G 3YXV ] j: ZvPWfOZv;EbSɧ1PRfG$9CqЈPԱ2# q1 ǟՕ~2,Oc yy$S bjo]+ɇLǥxq!&Cm>Yv@0sJz\?Vʷd'^Ot>c;w=yOŁVy;f .Ľ 벷ڽ? MX]h'>C >mDQx{ZsEZz4"P̓&'Z+x+``m Wɹ#=g[CyDS :op RT=VzMRz ^\,&` 4I [7Xw fdW%q/0 "J+')'C`b5'[XwJ/} CF2Gj
Q8O +$UԦKsy|:oi !=8H}_ B zja
k"X`"O50HZH
s&,&
u!_#L-!V
dc
91;\`pA^6 >&zb>Wf,1켉^|7%\Y|w2a0nJd
qNqXNҜPrElBrj"(Ȧ`<9o2۠Jy RQHkS̓+
E
PEmq &爥' $O5zhՕL_0¼I#z7QYHi&S@=fĒ)lZk)!H^T(DyLhh݈
aC <A켉^X\wl|olwl*9e5 =&M
9x$lnXl;*Do(#D#`|=Ӌ biMTKoJK&'\sʸlV'RD \ ?hLTa5ЯK9AT7yׇQbrP% @ T
la9mE( A0Q!WaD-UT4& ۼF\=9<悎F#\ZJ >aZ*5sIji+ Ò؉3㤴 b(DǺ%K ,#
XmAH#C=faA[XH0ښ@FgV!= M"vG r5 .|$3; )ӶOX'@ :XLa%}!8B#QQm*lCG`jV!H>9v>afo+}ɴX&,lBou[ TsXv/0~r V(dG[s۶R}pXZb`H6
~" VsmjY =N. S n{za뷯XVe cO;\K V4k;(`23Õ i'џ! 첁zzR ík`ΤMx
|7a=5 }IR [XZ!fM&;Kezƈ'idh=*3mMyӾږQos~8> ;g\B+Թ5> +VP5 5" >]W4RcJl1Lv0ja< D>/vk } !7tBoL! vӦ!X7X) "/_ESB3P')PܕvE >ݳMmOmE2r6͔ [t\oASn2xRQZ`DG"ݸ1tcX 8XB@w CQ!
n09;q)v+F=F s7MaOu7&f92z0( =$.- ~%` 7\ ,vo{' x,6ܞ΅a,<~A K^*
hPԄ`+"]N+8(/}utu;rd >rv>E
7lUoSiWxxѾדEt0 /Ƕ5 wN AT3J,_`ZyPTHAQ짃E AQu0ǰ:(A r>'i9Dw3u:'MII o>9$g?neAGNn嘈N-CF~2^ 2 ~ |{Ywc])!lx7< JUntD$h `A*=\K׀k*
ZU A
E`
ϻVuUEv=r`
1T"=sq`
.5hUE \Von> ܼKYWV/9qɐԲ*7` l l]Rmʪ?DKsc9*WWWI 9ΘA#du젯̍ 8֘1cY+'F#sk9cꪮ̞d`j5 Ӱ 9c&Օّ ܾ\h_.0n_βJՕّ c4BVܚ cc>U2{a/6ڗ3&ڗY^IXc1
*A_8֘o`oj
^] E匉CV2;APs1e젯̭ 8֘o`oj
^] E> /gY^HAͱԌ
!c}enMDZ|1 *
^]=0ڗXK|R1Ѿ|jRWWfO205SiXVܜ DZ||CVkHnZ.cMYV2714E
jձ2>4E
fƘe̠̞]eAvD!B]]=i"e젯̎`fuy`yjA] ievD!L]] Q74,d}en-707d̎d2H{`ܵeZ+c"5cFA_YD`fYV Iѿ\D]펉CV273s1e̠GSs1ղ2;҂|1ѿ|j5SWWi!9y`²JfWfGZj: ZvPWfOZN"+ xHN JmՕٱ L͡8hD(A_[w8Oiʼޫ&܌{G?7`jzb݄{?zCZ*0#HOH:ta<>pdmtp͗ 8o`ҁl; h47Ɂ,:L7,/n|n7>03ά 1@gm@a.y 8Dف GVؘr@P/فb=19⼁Ie@5L#y Ȣtjyv4^ {Xa-R쳁]$ #Z& 'D @u0Ě]@ej
e'⼁MNe`aYG? c2ō;]aҁ!2 E0企Md@ :Ǖm 7iف6>& h+T<+:[?17Ɂ,:Lk ۍ/y'
[](https://pepy.tech/project/pomegranate)  
> **Note**
> IMPORTANT: pomegranate v1.0.0 is a ground-up rewrite of pomegranate using PyTorch as the computational backend instead of Cython. Although the same functionality is supported, the API is significantly different. Please see the tutorials and examples folders for help rewriting your code.
[ReadTheDocs](https://pomegranate.readthedocs.io/en/latest/) | [Tutorials](https://github.com/jmschrei/pomegranate/tree/master/docs/tutorials) | [Examples](https://github.com/jmschrei/pomegranate/tree/master/examples)
pomegranate is a library for probabilistic modeling defined by its modular implementation and treatment of all models as the probability distributions they are. The modular implementation allows one to easily drop normal distributions into a mixture model to create a Gaussian mixture model just as easily as dropping a gamma and a Poisson distribution into a mixture model to create a heterogeneous mixture. But that's not all! Because each model is treated as a probability distribution, Bayesian networks can be dropped into a mixture just as easily as a normal distribution, and hidden Markov models can be dropped into Bayes classifiers to make a classifier over sequences. Together, these two design choices enable a flexibility not seen in any other probabilistic modeling package.
Recently, pomegranate (v1.0.0) was rewritten from the ground up using PyTorch to replace the outdated Cython backend. This rewrite gave me an opportunity to fix many bad design choices that I made as a bb software engineer. Unfortunately, many of these changes are not backwards compatible and will disrupt workflows. On the flip side, these changes have significantly sped up most methods, improved and simplified the code, fixed many issues raised by the community over the years, and made it significantly easier to contribute. I've written more below, but you're likely here now because your code is broken and this is the tl;dr.
Special shout-out to [NumFOCUS](https://numfocus.org/) for supporting this work with a special development grant.
### Installation
`pip install pomegranate`
If you need the last Cython release before the rewrite, use `pip install pomegranate==0.14.8`. You may need to manually install a version of Cython before v3.
### Why a Rewrite?
This rewrite was motivated by four main reasons:
- Speed: Native PyTorch is usually significantly faster than the hand-tuned Cython code that I wrote.
- Features: PyTorch has many features, such as serialization, mixed precision, and GPU support, that can now be directly used in pomegranate without additional work on my end.
- Community Contribution: A challenge that many people faced when using pomegranate was that they could not modify or extend it because they did not know Cython. Even if they did know Cython, coding in it is a pain that I felt each time I tried adding a new feature or fixing a bug or releasing a new version. Using PyTorch as the backend significantly reduces the amount of effort needed to add in new features.
- Interoperability: Libraries like PyTorch offer an invaluable opportunity to not just utilize their computational backends but to better integrate into existing resources and communities. This rewrite will make it easier for people to integrate probabilistic models with neural networks as losses, constraints, and structural regularizations, as well as with other projects built on PyTorch.
### High-level Changes
1. General
- The entire codebase has been rewritten in PyTorch and all models are instances of `torch.nn.Module`
- This codebase is checked by a comprehensive suite of >800 unit tests calling assert statements several thousand times, much more than previous versions.
- Installation issues are now likely to come from PyTorch for which there are countless resources to help out.
2. Features
- All models now have GPU support
- All models now have support for half/mixed precision
- Serialization is now handled by PyTorch, yielding more compact and efficient I/O
- Missing values are now supported through `torch.masked.MaskedTensor` objects
- Prior probabilities can now be passed to all relevant models and methods and enable more comprehensive/flexible semi-supervised learning than before
3. Models
- All distributions are now multivariate by default and treat each feature independently (except Normal)
- "Distribution" has been removed from names so that, for example, `NormalDistribution` is now `Normal`
- `FactorGraph` is now supported as first-class citizens, with all the prediction and training methods
- Hidden Markov models have been split into `DenseHMM` and `SparseHMM` models which differ in how the transition matrix is encoded, with `DenseHMM` objects being significantly faster on truly dense graphs
4. Differences
- `NaiveBayes` has been permanently removed as it is redundant with `BayesClassifier`
- `MarkovNetwork` has not yet been implemented
- Constraint graphs and constrained structure learning for Bayesian networks has not yet been implemented
- Silent states for hidden Markov models have not yet been implemented
- Viterbi for hidden Markov models has not yet been implemented
## Speed
Most models and methods in pomegranate v1.0.0 are faster than their counterparts in earlier versions. This generally scales by complexity, where one sees only small speedups for simple distributions on small data sets but much larger speedups for more complex models on big data sets, e.g. hidden Markov model training or Bayesian network inference. The notable exception for now is that Bayesian network structure learning, other than Chow-Liu tree building, is still incomplete and not much faster. In the examples below, `torchegranate` refers to the temporarily repository used to develop pomegranate v1.0.0 and `pomegranate` refers to pomegranate v0.14.8.
### K-Means
Who knows what's happening here? Wild.
### Hidden Markov Models
Dense transition matrix (CPU)
Sparse transition matrix (CPU)
Training a 125 node model with a dense transition matrix
### Bayesian Networks
## Features
> **Note**
> Please see the [tutorials](https://github.com/jmschrei/pomegranate/tree/master/docs/tutorials) folder for code examples.
Switching from a Cython backend to a PyTorch backend has enabled or expanded a large number of features. Because the rewrite is a thin wrapper over PyTorch, as new features get released for PyTorch they can be applied to pomegranate models without the need for a new release from me.
### GPU Support
All distributions and methods in pomegranate now have GPU support. Because each distribution is a `torch.nn.Module` object, the use is identical to other code written in PyTorch. This means that both the model and the data have to be moved to the GPU by the user. For instance:
```python
>>> X = torch.exp(torch.randn(50, 4))
# Will execute on the CPU
>>> d = Exponential().fit(X)
>>> d.scales
Parameter containing:
tensor([1.8627, 1.3132, 1.7187, 1.4957])
# Will execute on a GPU
>>> d = Exponential().cuda().fit(X.cuda())
>>> d.scales
Parameter containing:
tensor([1.8627, 1.3132, 1.7187, 1.4957], device='cuda:0')
```
Likewise, all models are distributions, and so can be used on the GPU similarly. When a model is moved to the GPU, all of the models associated with it (e.g. distributions) are also moved to the GPU.
```python
>>> X = torch.exp(torch.randn(50, 4)).cuda()
>>> model = GeneralMixtureModel([Exponential(), Exponential()]).cuda()
>>> model.fit(X)
[1] Improvement: 1.26068115234375, Time: 0.001134s
[2] Improvement: 0.168121337890625, Time: 0.001097s
[3] Improvement: 0.037841796875, Time: 0.001095s
>>> model.distributions[0].scales
Parameter containing:
>>> model.distributions[1].scales
tensor([0.9141, 1.0835, 2.7503, 2.2475], device='cuda:0')
Parameter containing:
tensor([1.9902, 2.3871, 0.8984, 1.2215], device='cuda:0')
```
### Mixed Precision
pomegranate models can, in theory, operate in the same mixed or low-precision regimes as other PyTorch modules. However, because pomegranate uses more complex operations than most neural networks, this sometimes does not work or help in practice because these operations have not been optimized or implemented in the low-precision regime. So, hopefully this feature will become more useful over time.
```python
>>> X = torch.randn(100, 4)
>>> d = Normal(covariance_type='diag')
>>>
>>> with torch.autocast('cuda', dtype=torch.bfloat16):
>>> d.fit(X)
```
### Serialization
pomegranate distributions are all instances of `torch.nn.Module` and so serialization is the same as any other PyTorch model.
Saving:
```python
>>> X = torch.exp(torch.randn(50, 4)).cuda()
>>> model = GeneralMixtureModel([Exponential(), Exponential()], verbose=True)
>>> model.cuda()
>>> model.fit(X)
>>> torch.save(model, "test.torch")
```
Loading:
```python
>>> model = torch.load("test.torch")
```
### torch.compile
> **Note**
> `torch.compile` is under active development by the PyTorch team and may rapidly improve. For now, you may need to pass in `check_data=False` when initializing models to avoid one compatibility issue.
In PyTorch v2.0.0, `torch.compile` was introduced as a flexible wrapper around tools that would fuse operations together, use CUDA graphs, and generally try to remove I/O bottlenecks in GPU execution. Because these bottlenecks can be extremely significant in the small-to-medium sized data settings many pomegranate users are faced with, `torch.compile` seems like it will be extremely valuable. Rather than targeting entire models, which mostly just compiles the `forward` method, you should compile individual methods from your objects.
```python
# Create your object as normal
>>> mu = torch.exp(torch.randn(100))
>>> d = Exponential(mu).cuda()
# Create some data
>>> X = torch.exp(torch.randn(1000, 100))
>>> d.log_probability(X)
# Compile the `log_probability` method!
>>> d.log_probability = torch.compile(d.log_probability, mode='reduce-overhead', fullgraph=True)
>>> d.log_probability(X)
```
Unfortunately, I have had difficulty getting `torch.compile` to work when methods are called in a nested manner, e.g., when compiling the `predict` method for a mixture model which, inside it, calls the `log_probability` method of each distribution. I have tried to organize the code in a manner that avoids some of these errors, but because the error messages right now are opaque I have had some difficulty.
### Missing Values
pomegranate supports handling data with missing values through `torch.masked.MaskedTensor` objects. Simply, one needs to just put a mask over the values that are missing.
```python
>>> X =