From 5fd7d6820e39f6a196f2514af6dcaeadee1e7611 Mon Sep 17 00:00:00 2001 From: lorcandelaney Date: Thu, 8 Aug 2019 15:58:25 +0100 Subject: [PATCH 01/10] Add Slice Sampling Covariance Matching method. --- docs/source/mcmc_samplers/index.rst | 3 +- .../slice_covariance_matching.rst | 7 + pints/__init__.py | 1 + pints/_mcmc/_slice_covariance_matching.py | 354 ++++++++++++++++++ .../test_mcmc_slice_covariance_matching.py | 128 +++++++ 5 files changed, 492 insertions(+), 1 deletion(-) create mode 100644 docs/source/mcmc_samplers/slice_covariance_matching.rst create mode 100644 pints/_mcmc/_slice_covariance_matching.py create mode 100644 pints/tests/test_mcmc_slice_covariance_matching.py diff --git a/docs/source/mcmc_samplers/index.rst b/docs/source/mcmc_samplers/index.rst index 871b086a6..b1acab157 100644 --- a/docs/source/mcmc_samplers/index.rst +++ b/docs/source/mcmc_samplers/index.rst @@ -22,4 +22,5 @@ interface, that can be used to sample from an unknown metropolis_mcmc population_mcmc slice_doubling_mcmc - slice_stepout_mcmc \ No newline at end of file + slice_stepout_mcmc + slice_covariance_matching \ No newline at end of file diff --git a/docs/source/mcmc_samplers/slice_covariance_matching.rst b/docs/source/mcmc_samplers/slice_covariance_matching.rst new file mode 100644 index 000000000..19c6a4e08 --- /dev/null +++ b/docs/source/mcmc_samplers/slice_covariance_matching.rst @@ -0,0 +1,7 @@ +************************************************** +Slice Sampling - Covariance Matching MCMC +************************************************** + +.. currentmodule:: pints + +.. autoclass:: SliceCovarianceMatchingMCMC \ No newline at end of file diff --git a/pints/__init__.py b/pints/__init__.py index c7e085eb5..b75abb806 100644 --- a/pints/__init__.py +++ b/pints/__init__.py @@ -205,6 +205,7 @@ def version(formatted=False): from ._mcmc._metropolis import MetropolisRandomWalkMCMC from ._mcmc._slice_stepout import SliceStepoutMCMC from ._mcmc._slice_doubling import SliceDoublingMCMC +from ._mcmc._slice_covariance_matching import SliceCovarianceMatchingMCMC # diff --git a/pints/_mcmc/_slice_covariance_matching.py b/pints/_mcmc/_slice_covariance_matching.py new file mode 100644 index 000000000..c6f185d2a --- /dev/null +++ b/pints/_mcmc/_slice_covariance_matching.py @@ -0,0 +1,354 @@ +# -*- coding: utf-8 -*- +# +# Slice Sampling - Covariance Adaptive: Covariance Matching MCMC Method +# +# This file is part of PINTS. +# Copyright (c) 2017-2019, University of Oxford. +# For licensing information, see the LICENSE file distributed with the PINTS +# software package. +# +from __future__ import absolute_import, division +from __future__ import print_function, unicode_literals +import pints +import numpy as np + + +class SliceCovarianceMatchingMCMC(pints.SingleChainMCMC): + """ + Implements Covariance-Adaptive Slice Sampling by Covariance Matching, + as described in [1]. This is an adaptive multivariate method which + uses additional points, called "crumbs", and rejected proposals to + guide the selection of samples. + + It generates samples by sampling uniformly from the volume underneath the + posterior (``f``). It does so by introducing an auxiliary variable (``y``) + and by definying a Markov chain. + + Sampling follows: + + 1. Calculate the pdf (``f(x_0)``) of the current sample (``x_0``). + 2. Draw a real value (``y``) uniformly from (0, f(x0)), defining a + horizontal “slice”: S = {x: y < f(x)}. Note that ``x_0`` is + always within S. + 3. Draw the first crumb (``c_1``) from a Gaussian distribution with + mean ``x_0`` and precision matrix ``W_1``. + 4. Draw a new point (``x_1``) from a Gaussian distribution with mean + ``c_1`` and precision matrix ``W_2``. + + New crumbs are drawn until a new proposal is accepted. In particular, + after sampling ``k`` crumbs from Gaussian distributions with mean ``x0`` + and precision matrices (``W_1``, ..., ``W_k``), the distribution for the + ``k`` th proposal sample is: + + 1. ``x_k \sim Normal(\bar{c}_k, \Lambda^{-1}_k)`` + + where: + + 2. ``\Lambda_k = W_1 + ... + W_k`` + 3. ``\bar{c}_k = \Lambda^{-1}_k * (W_1 * c_1 + ... + W_k * c_k)`` + + This method attempts to find the ``k + 1`` th crumb precision matrix + (``W_{k + 1}``) so that the distribution for the ``k + 1`` th proposal + point has the same conditional variance as uniform sampling from the slice + ``S`` in the direction of the gradient of ``f(x)`` evaluated at the last + rejected proposal (``x_k``). + + To avoid floating-point underflow, we implement the suggestion advanced + in [1] pp.712. We use the log pdf of the un-normalised posterior + (``log f(x)``) instead of ``f(x)``. In doing so, we use an + auxiliary variable ``z = log(y) - \epsilon``, where + ``\epsilon \sim \text{exp}(1)`` and define the slice as + S = {x : z < log f(x)}. + + [1] Thompson, M. and Neal, R.M., 2010. Covariance-adaptive slice sampling. + arXiv preprint arXiv:1003.3201. + + *Extends:* :class:`SingleChainMCMC` + """ + + def __init__(self, x0, sigma0=None): + super(SliceCovarianceMatchingMCMC, self).__init__(x0, sigma0) + + # Set initial state + self._x0 = np.asarray(x0, dtype=float) + self._running = False + self._ready_for_tell = False + self._current = None + self._proposed_pdf = None + self._current_log_y = None + self._proposed = None + self._log_fx_u = None + self._calculate_fx_u = False + self._sent_proposal = False + + # Standard deviation of initial crumb + self._sigma_c = 1 + + # Crumb + self._c = None + + # Estimate of the density at the mode + self._M = None + + # Initialise un-normalised crumb mean + self._c_bar_star = np.zeros(self._n_parameters) + + # Define Cholesky upper triangles: F for W_k and R_k for Lambda_k + self._R = None + self._F = None + + # Un-normalised gradient calculated at rejected proposal + self._G = None + + # Normalised gradient calculated at rejected proposal + self._g = None + + # Distance between rejected proposal and crumb + self._delta = None + + # Parameter to control variance precision + self._theta = 1 + + # Function which calculates Cholesky rank one updates + def _chud(self, matrix, vector): + V = np.dot(matrix.transpose(), matrix) + np.outer(vector, vector) + chol = np.linalg.cholesky(V).transpose() + return np.array(chol, copy=True) + + def ask(self): + """ See :meth:`SingleChainMCMC.ask()`. """ + + # Check ask/tell pattern + if self._ready_for_tell: + raise RuntimeError('Ask() called when expecting call to tell().') + + # Initialise on first call + if not self._running: + self._running = True + + # Very first iteration + if self._current is None: + + # Ask for the log pdf of x0 + self._ready_for_tell = True + return np.array(self._x0, copy=True) + + # If the proposal has been rejected, we need to evaluate ``f(u)`` + # in order to find the covariance matrix for the next proposal + if self._calculate_fx_u: + # Ask for the log pdf of ``u`` + self._ready_for_tell = True + self._calculate_fx_u = False + return np.array(self._u, copy=True) + + # Draw first p-variate + mean = np.zeros(self._n_parameters) + cov = np.identity(self._n_parameters) + z = np.random.multivariate_normal(mean, cov) + + # Draw crumb c + self._c = self._current + np.dot(np.linalg.inv(self._F), z) + + # Compute un-normalised proposal mean + self._c_bar_star = self._c_bar_star + np.dot(np.dot(np.transpose( + self._F), self._F), self._c) + + # Compute normalised proposal mean + c_bar = np.dot(np.dot(np.linalg.inv(self._R), np.transpose( + np.linalg.inv(self._R))), self._c_bar_star) + + # Draw second p-variate + z = np.random.multivariate_normal(mean, cov) + + # Draw sample + self._proposed = c_bar + np.dot(np.linalg.inv(self._R), z) + + # Set flag indicating we have created a new proposal. This is used to + # store the value of the log_pdf of the proposed point in the tell() + # method + self._sent_proposal = True + + # Set flag that will be used if the proposal is rejected + self._calculate_fx_u = True + + # Send trial point for checks + self._ready_for_tell = True + return np.array(self._proposed, copy=True) + + def current_log_pdf(self): + """ See :meth:`SingleChainMCMC.current_log_pdf()`. """ + return np.copy(self._current_log_pdf) + + def current_slice_height(self): + """ + Returns current log_y used to define the current slice. + """ + return self._current_log_y + + def name(self): + """ See :meth:`pints.MCMCSampler.name()`. """ + return 'Slice Sampling - Covariance-Adaptive: Covariance Matching' + + def n_hyper_parameters(self): + """ See :meth:`TunableMethod.n_hyper_parameters()`. """ + return 2 + + def needs_sensitivities(self): + """ See :meth:`pints.MCMCSampler.needs_sensitivities()`. """ + return True + + def set_hyper_parameters(self, x): + """ + The hyper-parameter vector is ``[sigma_c, theta]``. + See :meth:`TunableMethod.set_hyper_parameters()`. + """ + self.set_sigma_c(x[0]) + self.set_theta(x[1]) + + def set_sigma_c(self, sigma_c): + """ + Sets standard deviation of initial crumb. + """ + sigma_c = float(sigma_c) + if sigma_c < 0: + raise ValueError('Inital crumb standard deviation' + 'must be positive.') + self._sigma_c = sigma_c + + def set_theta(self, theta): + """ + Sets parameter to control how fast the precision of the + proposal distribution increases. + """ + self._theta = float(theta) + + def sigma_c(self): + """ + Returns standard deviation of initial crumb. + """ + return self._sigma_c + + def tell(self, reply): + """ See :meth:`pints.SingleChainMCMC.tell()`. """ + + # Check ask/tell pattern + if not self._ready_for_tell: + raise RuntimeError('Tell called before proposal was set.') + self._ready_for_tell = False + + # Unpack reply + fx, grad = reply + + # Check reply, copy gradient + fx = float(fx) + grad = pints.vector(grad) + + # If this is the log_pdf of a new point, save the value and use it + # to check ``f(x_1) >= y`` + if self._sent_proposal: + self._proposed_pdf = fx + self._sent_proposal = False + + # Very first call + if self._current is None: + # Check first point is somewhere sensible + if not np.isfinite(fx): + raise ValueError( + 'Initial point for MCMC must have finite logpdf.') + + # Set current sample, log pdf of current sample and initialise + # proposed sample for next iteration + self._current = np.array(self._x0, copy=True) + self._proposed = np.array(self._current, copy=True) + self._current_log_pdf = fx + self._M = fx + + # Define Cholesky upper triangles: F_k for W_k and R_k for Lambda_k + self._R = self._sigma_c ** (-1) * np.identity(self._n_parameters) + self._F = self._sigma_c ** (-1) * np.identity(self._n_parameters) + + # Sample height of the slice log_y for next iteration + e = np.random.exponential(1) + self._current_log_y = self._M - e + + # Return first point in chain, which is x0 + return np.array(self._current, copy=True) + + # Acceptance check + if self._proposed_pdf >= self._current_log_y: + # The accepted sample becomes the new current sample + self._current = np.array(self._proposed, copy=True) + + # Update estimate of mode density + self._M = fx + + # Sample new log_y used to define the next slice + e = np.random.exponential(1) + self._current_log_y = self._M - e + + # Reset parameters + self._c_bar_star = np.zeros(self._n_parameters) + self._F = self._sigma_c ** (-1) * np.identity(self._n_parameters) + self._R = self._sigma_c ** (-1) * np.identity(self._n_parameters) + self._calculate_fx_u = False + + # Return accepted sample + return np.array(self._proposed, copy=True) + + # If proposal is rejected, we a define new covariance matrix for + # next proposal distribution + else: + if self._calculate_fx_u: + # Gradient evaluated at rejected proposal + self._G = grad + + # Calculate normalised gradient + self._g = self._G / np.linalg.norm(self._G) + + # Calculate distance between proposal and crumb + self._delta = np.linalg.norm(self._proposed - self._c) + + # Generate new point ``u`` + self._u = self._proposed + self._delta * self._g + return None + + else: + self._log_fx_u = fx + + # Calculate ``\kappa`` + kappa = (-2.) * self._delta ** (-2.) * ( + self._log_fx_u - self._proposed_pdf - self._delta * + np.linalg.norm(self._G)) + + # Peak of parabolic cut through ``x1`` and ``u`` + lxu = (0.5 * (np.linalg.norm(self._G) ** 2 / kappa) + + self._proposed_pdf) + + # Update ``M`` + self._M = max(self._M, lxu) + + # Calculate conditional variance of new distribution + sigma_squared = 2 / 3 * (self._M - self._current_log_y) / kappa + + alpha = max( + 0, sigma_squared ** (-1) - (( + 1 + self._theta) * np.dot( + np.transpose(self._g), np.dot( + np.transpose(self._R), np.dot( + self._R, self._g))))) + + # Update F and R + self._F = self._chud( + np.sqrt(self._theta) * self._R, np.sqrt(alpha) * self._g) + self._R = self._chud( + np.sqrt(1 + self._theta) * self._R, np.sqrt(alpha) * + self._g) + + return None + + def theta(self): + """ + Returns the parameter used to control how fast the precision of + the proposal distribution increases. + """ + return self._theta diff --git a/pints/tests/test_mcmc_slice_covariance_matching.py b/pints/tests/test_mcmc_slice_covariance_matching.py new file mode 100644 index 000000000..f058fae05 --- /dev/null +++ b/pints/tests/test_mcmc_slice_covariance_matching.py @@ -0,0 +1,128 @@ +# -*- coding: utf-8 -*- +# +# Tests the basic methods of the Covariance-Adaptive Slice Sampling: +# Covariance Matching. +# +# This file is part of PINTS. +# Copyright (c) 2017-2019, University of Oxford. +# For licensing information, see the LICENSE file distributed with the PINTS +# software package. +# + +import unittest +import numpy as np + +import pints +import pints.toy + +debug = False + + +class TestSliceCovarianceMatching(unittest.TestCase): + """ + Tests the basic methods of the Slice Sampling Covariance Matching + routine. + """ + def test_first_run(self): + # Tests the very first run of the sampler. + + # Create log pdf + log_pdf = pints.toy.GaussianLogPDF([2, 4], [[1, 0], [0, 3]]) + + # Create mcmc + x0 = np.array([2., 4.]) + mcmc = pints.SliceCovarianceMatchingMCMC(x0) + + # Ask() should fail if _ready_for_tell flag is True + x = mcmc.ask() + with self.assertRaises(RuntimeError): + mcmc.ask() + + # Check whether first iteration of ask() returns x0 + self.assertTrue(np.all(x == x0)) + + # Calculate log pdf for x0 + fx, grad = log_pdf.evaluateS1(x0) + + # Test first iteration of tell(). The first point in the chain + # should be x0 + sample = mcmc.tell((fx, grad)) + self.assertTrue(np.all(sample == x0)) + + # We update the _current_log_pdf value used to generate the new slice + self.assertEqual(mcmc.current_log_pdf(), fx) + + # Check that the new slice has been constructed appropriately + self.assertTrue( + mcmc.current_slice_height() < mcmc.current_log_pdf()) + + # Tell() should fail when fx is infinite + mcmc = pints.SliceStepoutMCMC(x0) + mcmc.ask() + with self.assertRaises(ValueError): + fx = np.inf + mcmc.tell(fx) + + # Tell() should fail when _ready_for_tell is False + with self.assertRaises(RuntimeError): + mcmc.tell(fx) + + def test_basic(self): + # Test basic methods of the class. + + # Create mcmc + x0 = np.array([1, 1]) + mcmc = pints.SliceCovarianceMatchingMCMC(x0) + + # Test name + self.assertEqual( + mcmc.name(), + 'Slice Sampling - Covariance-Adaptive: Covariance Matching') + + # Test set_sigma_c(), sigma_c() + mcmc.set_sigma_c(6) + self.assertEqual(mcmc.sigma_c(), 6) + with self.assertRaises(ValueError): + mcmc.set_sigma_c(-1) + + # Test set_theta(), theta() + mcmc.set_theta(10) + self.assertEqual(mcmc.theta(), 10) + + # Test number of hyperparameters + self.assertEqual(mcmc.n_hyper_parameters(), 2) + + # Test setting hyperparameters + mcmc.set_hyper_parameters([33, 11]) + self.assertEqual(mcmc.sigma_c(), 33) + self.assertEqual(mcmc.theta(), 11) + + def test_run(self): + # Tests complete run. + + # Create log pdf + log_pdf = pints.toy.MultimodalGaussianLogPDF( + modes=[[0, 2], [0, 7], [5, 0], [4, 4]]) + + # Create non-adaptive mcmc + x0 = np.array([1, 1]) + mcmc = pints.SliceCovarianceMatchingMCMC(x0) + mcmc.set_sigma_c(1) + + # Run multiple iterations of the sampler + chain = [] + while len(chain) < 100: + x = mcmc.ask() + fx, grad = log_pdf.evaluateS1(x) + sample = mcmc.tell((fx, grad)) + if sample is not None: + chain.append(np.copy(sample)) + self.assertEqual(np.shape(chain), (100, 2)) + + +if __name__ == '__main__': + print('Add -v for more debug output') + import sys + if '-v' in sys.argv: + debug = True + unittest.main() From 675f8fe0dbaa436f20965c673f6d67ce4f245b7e Mon Sep 17 00:00:00 2001 From: lorcandelaney Date: Thu, 8 Aug 2019 16:18:16 +0100 Subject: [PATCH 02/10] Add small fixes to covariance-matching tests. --- pints/tests/test_mcmc_slice_covariance_matching.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/pints/tests/test_mcmc_slice_covariance_matching.py b/pints/tests/test_mcmc_slice_covariance_matching.py index f058fae05..25ab58a4c 100644 --- a/pints/tests/test_mcmc_slice_covariance_matching.py +++ b/pints/tests/test_mcmc_slice_covariance_matching.py @@ -57,15 +57,18 @@ def test_first_run(self): mcmc.current_slice_height() < mcmc.current_log_pdf()) # Tell() should fail when fx is infinite - mcmc = pints.SliceStepoutMCMC(x0) + mcmc = pints.SliceCovarianceMatchingMCMC(x0) mcmc.ask() with self.assertRaises(ValueError): fx = np.inf - mcmc.tell(fx) + mcmc.tell((fx, grad)) # Tell() should fail when _ready_for_tell is False with self.assertRaises(RuntimeError): - mcmc.tell(fx) + mcmc.tell((fx, grad)) + + # Test sensitivities + self.assertTrue(mcmc.needs_sensitivities()) def test_basic(self): # Test basic methods of the class. From 34da85e32378f72f35e37414642e1e837844e30a Mon Sep 17 00:00:00 2001 From: lorcandelaney Date: Mon, 12 Aug 2019 16:53:18 +0100 Subject: [PATCH 03/10] Add Notebook. --- examples/README.md | 1 + examples/sampling-hamiltonian-mcmc.ipynb | 10 +- ...pling-slice-covariance-matching-mcmc.ipynb | 540 ++++++++++++++++++ examples/writing-a-model.ipynb | 4 +- 4 files changed, 548 insertions(+), 7 deletions(-) create mode 100644 examples/sampling-slice-covariance-matching-mcmc.ipynb diff --git a/examples/README.md b/examples/README.md index 4b52c428e..f40723caa 100644 --- a/examples/README.md +++ b/examples/README.md @@ -50,6 +50,7 @@ relevant code. ### MCMC with gradients - [Hamiltonian MCMC](./sampling-hamiltonian-mcmc.ipynb) - [MALA MCMC](./sampling-mala-mcmc.ipynb) +- [Slice Sampling: Covariance Matching MCMC](./sampling-slice-covariance-matching-mcmc.ipynb) ### Nested sampling - [Ellipsoidal nested rejection sampling](./sampling-ellipsoidal-nested-rejection-sampling.ipynb) diff --git a/examples/sampling-hamiltonian-mcmc.ipynb b/examples/sampling-hamiltonian-mcmc.ipynb index 715640a24..140917079 100644 --- a/examples/sampling-hamiltonian-mcmc.ipynb +++ b/examples/sampling-hamiltonian-mcmc.ipynb @@ -681,21 +681,21 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 2", + "display_name": "Python 3", "language": "python", - "name": "python2" + "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.14" + "pygments_lexer": "ipython3", + "version": "3.6.4" } }, "nbformat": 4, diff --git a/examples/sampling-slice-covariance-matching-mcmc.ipynb b/examples/sampling-slice-covariance-matching-mcmc.ipynb new file mode 100644 index 000000000..a89d5188b --- /dev/null +++ b/examples/sampling-slice-covariance-matching-mcmc.ipynb @@ -0,0 +1,540 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 1: Unimodal Gaussian Distribution\n", + "First, we create our target Gaussian distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "os.chdir(\"../\")\n", + "import pints\n", + "import pints.toy\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Create log pdf\n", + "log_pdf = pints.toy.GaussianLogPDF([2, 4], [[1, 0], [0, 3]])\n", + "\n", + "# Contour plot of pdf\n", + "levels = np.linspace(-3,12,20)\n", + "num_points = 100\n", + "x = np.linspace(-1, 5, num_points)\n", + "y = np.linspace(-0, 8, num_points)\n", + "X, Y = np.meshgrid(x, y)\n", + "Z = np.zeros(X.shape)\n", + "Z = np.exp([[log_pdf([i, j]) for i in x] for j in y])\n", + "plt.contour(X, Y, Z)\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we set up a sampling routine using Slice Sampling with Rank Shrinking." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Choose starting point for 3 mcmc chains\n", + "xs = [\n", + " [2, 4],\n", + " [3, 3],\n", + " [5, 4],\n", + "]\n", + "\n", + "# Create mcmc routine\n", + "mcmc = pints.MCMCController(log_pdf, 3, xs, method=pints.SliceCovarianceMatchingMCMC)\n", + "\n", + "# Add stopping criterion\n", + "mcmc.set_max_iterations(2000)\n", + "\n", + "# Set up modest logging\n", + "mcmc.set_log_to_screen(True)\n", + "mcmc.set_log_interval(1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running...\n", + "Using Slice Sampling - Covariance-Adaptive: Covariance Matching\n", + "Generating 3 chains.\n", + "Running in sequential mode.\n", + "Iter. Eval. Time m:s\n", + "0 3 0:00.0\n", + "1 12 0:00.0\n", + "2 15 0:00.0\n", + "3 30 0:00.0\n", + "1000 8691 0:02.8\n", + "2000 17048 0:05.5\n", + "Halting: Maximum number of iterations (2000) reached.\n", + "Done!\n" + ] + } + ], + "source": [ + "for sampler in mcmc.samplers():\n", + " sampler.set_sigma_c(1)\n", + " \n", + "# Run!\n", + "print('Running...')\n", + "full_chains = mcmc.run()\n", + "print('Done!')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show traces and histograms\n", + "import pints.plot\n", + "pints.plot.trace(full_chains)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R-hat:\n", + "[1.0006400909053477, 1.006546284006455]\n" + ] + } + ], + "source": [ + "# Check convergence using rhat criterion\n", + "print('R-hat:')\n", + "print(pints.rhat_all_params(full_chains))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "chain = full_chains[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pints.plot.autocorrelation(chain)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pints.plot.pairwise(chain, kde=True, ref_parameters=[2,4])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 2: Multimodal Distribution\n", + "\n", + "Having the confidence that Slice Sampling with Covariance Matching performs well on a simple unimodal Gaussian distribution, we check its performance on a more problematic multimodal exercise." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "log_pdf = pints.toy.MultimodalGaussianLogPDF(modes=[[-1, -1], [11, 5], [5, 12]])\n", + "\n", + "samples = log_pdf.sample(100)\n", + "\n", + "# Contour plot of pdf\n", + "levels = np.linspace(-3,12,20)\n", + "num_points = 100\n", + "x = np.linspace(-5, 15, num_points)\n", + "y = np.linspace(-5, 15, num_points)\n", + "X, Y = np.meshgrid(x, y)\n", + "Z = np.zeros(X.shape)\n", + "Z = np.exp([[log_pdf([i, j]) for i in x] for j in y])\n", + "plt.contour(X, Y, Z)\n", + "plt.scatter(samples[:,0], samples[:,1])\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running...\n", + "Done!\n" + ] + } + ], + "source": [ + "# Create an adaptive covariance MCMC routine\n", + "x0 = np.random.uniform([2, 2], [8, 8], size=(4, 2))\n", + "mcmc = pints.MCMCController(log_pdf, 4, x0, method=pints.SliceCovarianceMatchingMCMC)\n", + "\n", + "for sampler in mcmc.samplers():\n", + " sampler.set_sigma_c(5)\n", + "\n", + "# Set maximum number of iterations\n", + "mcmc.set_max_iterations(2000)\n", + "\n", + "# Disable logging\n", + "mcmc.set_log_to_screen(False)\n", + "\n", + "# Number of chains\n", + "num_chains = 4\n", + "\n", + "# Run!\n", + "print('Running...')\n", + "chains = mcmc.run()\n", + "print('Done!')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "stacked = np.vstack(chains)\n", + "plt.contour(X, Y, Z, colors='k', alpha=0.5)\n", + "plt.scatter(stacked[:,0], stacked[:,1], marker='.', alpha=0.2)\n", + "plt.xlim(-5, 15)\n", + "plt.ylim(-5, 15)\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KL divergence by mode: [0.00365169 0.00108024 0.00201833]\n" + ] + } + ], + "source": [ + "print(\"KL divergence by mode: \" + str(log_pdf.kl_divergence(stacked)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 3: Time-Series Problem - Logistic Model\n", + "We now try the same method on a more realistic time-series problem using a logistic model, following the tutorial notebook: [sampling-first-example](./sampling-first-example.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "import pints\n", + "import pints.toy as toy\n", + "import pints.plot\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "class ExampleModel(pints.ForwardModel):\n", + " \n", + " def __init__(self):\n", + " self.model = toy.LogisticModel()\n", + " def simulate(self, x, times):\n", + " return self.model.simulate([x[0]/1000, x[1]], times)\n", + " def simulateS1(self, x, times):\n", + " values, gradient = self.model.simulateS1([x[0]/1000, x[1]], times)\n", + " return values, gradient\n", + " def n_parameters(self):\n", + " return 2\n", + "\n", + "\n", + "# Then create an instance of our new model class\n", + "model = ExampleModel()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running...\n", + "Using Slice Sampling - Covariance-Adaptive: Covariance Matching\n", + "Generating 3 chains.\n", + "Running in sequential mode.\n", + "Iter. Eval. Time m:s\n", + "0 3 0:00.0\n", + "1 72 0:00.0\n", + "2 87 0:00.0\n", + "3 126 0:00.1\n", + "1000 27393 0:13.2\n", + "2000 54242 0:24.6\n", + "Halting: Maximum number of iterations (2000) reached.\n", + "Done!\n" + ] + } + ], + "source": [ + "import pints\n", + "import pints.toy as toy\n", + "import pints.plot\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Create some toy data\n", + "real_parameters = [0.015*10000, 500]\n", + "times = np.linspace(0, 1000, 1000)\n", + "org_values = model.simulate(real_parameters, times)\n", + "\n", + "# Add noise\n", + "noise = 10\n", + "values = org_values + np.random.normal(0, noise, org_values.shape)\n", + "real_parameters = np.array(real_parameters + [noise])\n", + "\n", + "# Get properties of the noise sample\n", + "noise_sample_mean = np.mean(values - org_values)\n", + "noise_sample_std = np.std(values - org_values)\n", + "\n", + "# Create an object with links to the model and time series\n", + "problem = pints.SingleOutputProblem(model, times, values)\n", + "\n", + "# Create a log-likelihood function (adds an extra parameter!)\n", + "log_likelihood = pints.GaussianLogLikelihood(problem)\n", + "\n", + "# Create a uniform prior over both the parameters and the new noise variable\n", + "log_prior = pints.UniformLogPrior(\n", + " [0.01*10000, 400, noise * 0.1],\n", + " [0.02*10000, 600, noise * 100],\n", + ")\n", + "\n", + "# Create a posterior log-likelihood (log(likelihood * prior))\n", + "log_posterior = pints.LogPosterior(log_likelihood, log_prior)\n", + "\n", + "# Choose starting points for 3 mcmc chains\n", + "num_chains = 3\n", + "xs = [\n", + " real_parameters * 1.01,\n", + " real_parameters * 0.99,\n", + " real_parameters * 1.01,\n", + "]\n", + "\n", + "# Create mcmc routine\n", + "mcmc = pints.MCMCController(\n", + " log_posterior, num_chains, xs, method=pints.SliceCovarianceMatchingMCMC)\n", + "\n", + "for sampler in mcmc.samplers():\n", + " sampler.set_sigma_c(1)\n", + " \n", + "# Add stopping criterion\n", + "mcmc.set_max_iterations(2000)\n", + "\n", + "# Set up modest logging\n", + "mcmc.set_log_to_screen(True)\n", + "mcmc.set_log_interval(1000)\n", + "\n", + "# Run!\n", + "print('Running...')\n", + "full_chains = mcmc.run()\n", + "print('Done!')" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R-hat:\n", + "[1.0005693708367296, 0.9998068359514151, 1.0001776044293549]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAImCAYAAACvoquQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3Xd4lFXax/HvmUkjlRZqgNCb9Agq1S7qim3taxd9bcvqqthW17VgW7ur2Na6CipFQREbWGihSy8ihBogkJBAysx5/5gBEhIgkJl5JpPf57pyZeY55znnnoB45znNWGsRERERiRQupwMQERERCSQlNyIiIhJRlNyIiIhIRFFyIyIiIhFFyY2IiIhEFCU3IiIiElGU3IiIiEhEUXIjIiIiEUXJjYiIiESUKKcDCKb69evb9PR0p8OQCDF79uyt1tpUp+MQEZFDi+jkJj09nczMTKfDkAhhjPnD6RhEROTwNCwlIiIiEUXJjYiIiEQUJTciIiISUZTciIiISEQJm+TGGHOGMWaZMWalMWZ4BeXNjTE/GGPmGmMWGGPOdCJOERERCW9hkdwYY9zAK8BgoBNwqTGm0wHVHgBGWWt7AJcAr4Y2yupv0KBBDBo0yOkwREREgipcloL3BlZaa1cDGGM+BoYAi0vVsUCy/3UKsCGkEUaAtLQ0p0MQEREJunBJbpoC60q9zwL6HFDnYeAbY8xtQAJwSkUNGWOGAkMBmjdvHvBAq7MPPvjA6RBERESCLiyGpQBTwTV7wPtLgf9aa9OAM4H3jTHl4rfWjrTWZlhrM1JTtZmsiIhITRMuyU0W0KzU+zTKDztdB4wCsNZOA+KA+iGJLkIMGzaMYcOGOR2GiIhIUIXLsNQsoK0xpiWwHt+E4csOqLMWOBn4rzGmI77kJjukUVZz8+bNczoEERGRoAuL5MZaW2KMuRWYBLiBt621i4wxjwCZ1trxwJ3AG8aYv+EbsrraWnvg0FWNkT58QoXX14w4K8SRiIiIhJewSG4ArLUTgYkHXPtHqdeLgb6hjktERESql3CZcyMiIiISEGHz5EaCr127dk6HICIiEnRKbmqQkSNHOh2CiIhI0GlYKgIc71rE1Ji/siD2OnjzVNi8yOmQREREHKPkppo73TWLd6NHUEQ0n3kGQM7v8PpAWDS2XN2hQ4cydOhQB6IUEREJHQ1LVWNJFPBY9Fssti24suheckngmpv/Ax9fCp/fALVqQ6tB++ovX77csVhFRERCRU9uqrGbo8ZRlzzuL76OXBJ8FxPqwWWfQL028MmVsP13Z4MUEREJMSU31VQqOVzr/pox3n4ssi3LFtaqA5f+z3di1+iroHiPIzGKiIg4QclNNXWB+ydiTTEvl5xbcYU66XDua7BxPnz/r5DGJiIi4iTNuamOrOXP7inM9Lbnd9v44PU6nAnHXg/TXoF2Z9C9e/fQxSgiIuIQJTfV0boZtHZt5LXiPx2+7qmPwKofYNzNPP/UdIhJCH58IiIiDtKwVHU07yPybSwTPMcdvm5MAgx5GXashR+fCH5sIiIiDtOTm+rG64VlX/GDtwcFxJUrPthp4Y9HncjEvz8NbefxwWdfBjtKERERx+jJTXWzYS7kb+FbT88jum1EyaVk5bvIWjQNrA1ScCIiIs5TclPdLP8ajIsfvd2O6LZcEqF2C9izExaX371YREQkUmhYqrpZ/hU068OO5UlHfOuM7Gi6uOLIGvV3Ti6EQmIAWDPirEBHKSIi4hglN2Gu9ByahmxnRtxCnii+9KjassAa25A0s5Wr3JMY6anEaisREZFqRsNS1cgJLt9p31O9XY/q/timHShs0pPvPD24NWocdcgNZHgiIiJhQclNNXKCaxHbbSJLbbOjur/OwKupM/Bqnii5lHj2cHvUmABHKCIi4jwlN9WG5Xj3YqZ7O2Gr+Me20qbxsedErnB/SyuzIUDxiYiIhAclN9VEc7OFNLOVX72dj7qN7DGPkz3mcQCeK7mQPcRwb9RHgQpRREQkLCi5qSb2zreZ5u101G14dufi2e2bZ7ONFF4pGcKp7jmw6vuAxCgiIhIOlNxUE8e7FrPF1maVbRKwNt/2DOYPbwP4+j7wlASsXREREScpuakmMlzLmOntAJiAtVlENI+VXA7ZS2D2OwFrV0RExElhk9wYY84wxiwzxqw0xgw/SJ2LjDGLjTGLjDE1ZrJIE7bS1Gxjlrd9wNv+xpsB6f3hh8dh946Aty8iIhJqYbGJnzHGDbwCnApkAbOMMeOttYtL1WkL3Av0tdbmGGMaOBNt6GW4lgGQWcXkJq5FRUc2GM5aNpgvYn7mzcdu5vGSy/eVaOdiERGpjsLlyU1vYKW1drW1tgj4GBhyQJ0bgFestTkA1totIY7RMb1dS8mztVhim1epndp9L6V23/K7Gy+y6Xzu7c9V7m9oQE6V+hAREXFauCQ3TYF1pd5n+a+V1g5oZ4z5xRgz3RhzRkUNGWOGGmMyjTGZ2dnZQQo3tDJcy5njbYs3iH9cL5SchwsvN0eNC1ofIiIioRAuyU1Fs2TtAe+jgLbAIOBS4E1jTO1yN1k70lqbYa3NSE1NDXigoZbMLjq41pHpbVfltjaPeojNox6qsGydbchozwAudX9PI7ZVuS8RERGnhEtykwWUPlMgDThw69wsYJy1ttha+zuwDF+yE9F6ulYCkGmrPpnYlhRiSwoPWv5Kybm48XJ11DdV7ktERMQp4ZLczALaGmNaGmNigEuA8QfUGQucCGCMqY9vmGp1SKN0QA/XCjzWMN/bOuh9rSeVr73Hcqn7O2qxJ+j9iYiIBENYJDfW2hLgVmASsAQYZa1dZIx5xBhzjr/aJGCbMWYx8ANwl7U24sdPepnlLLXNKSAuJP29XTKYFFPABe6fQtKfiIhIoIXFUnAAa+1EYOIB1/5R6rUF7vB/1QxeD91dqxjj6ReyLufYtsz3tuIv7slgLZjAbRooIiISCgF/cmOMOSbQbdZYW5aQaPYwOwCTiQFqte5Nrda9D1PL8LHnRNq7smDDnID0KyIiEkrBGJZ6zRgz0xhzc0WrmeQIZM0EfE9TAiGlz/mk9Dn/sPW+9BzPbhsDcz8MSL8iIiKhFPDkxlrbD7gc3+qnTGPMR8aYUwPdT42wbhZbbTJrbWg3Y84jnq+9x8Jvn0Lx7pD2LSIiUlVBmVBsrV0BPADcAwwEXjTGLDXGHP6xgeyXNYu53rYE6rDMTR8NZ9NHFR7bVc5oz0DYsxOWfx2QvkVEREIlGHNuuhpjnsO36ukk4E/W2o7+188Fur+IVbAdtq1grreNI91P93aChAawaIwj/YuIiBytYDy5eRmYA3Sz1t5irZ0DYK3dgO9pjlTG+tkAzLXOJDdeXNBpCCz/Bgp3ORKDiIjI0QhGcnMm8JG1djeAMcZljIkHsNa+H4T+IlPWLDCukGzed1DHnA8luzU0JSIi1UowkptvgVql3sf7r8mRyJoFDTqHbPO+CjU7DpKaaGhKRESqlWAkN3HW2n3jGP7X8UHoJ3J5vZA1G9IyAtpsQof+JHToX/kbXC7oeDas/A6KCgIai4iISLAEI7nJN8b03PvGGNML0HriI7FtBRTuDHhyk9TzLJJ6nnVkN7Uf7Bua+n1KQGMREREJlmAcvzAMGG2M2Xuqd2Pg4iD0E7myMn3f044FVgasWW+x7zBMV/QRDHW16AexybB0gi/RERERCXMBT26stbOMMR2A9vg2aFlqrS0OdD8RLWsWxKZAvbYEMrnZMvphABpdNqLyN0XFQJtTfJOKvV7fUJWIiEgYC9bBmccC6f72exhjsNa+F6S+Is/6TGja0/FEIn34BADOcTXhxZhszrv/RebatqwZcYRDWyIiIiEUjE383geeAfrhS3KOBQI7eSSSFeXD5sUBn29TFVO9XfBawwDXAqdDEREROaxgPLnJADpZa20Q2o58G+aB9fjn24SHHSSxwLakv3shL3gucDocERGRQwpGcvMb0AjYGIS2I9beIaCh7i+4Lxp6vr2d7UxwOKr9fvJ25f/c40km3+lQREREDikYyU19YLExZiZQuPeitfacIPQVcbq7VvGHtwHbSQ5424ldTjnqe6d6unJb1FiOdy0KYEQiIiKBF4zk5uEgtFljdHOtItPbPihtVyW5mWvbsMvGMVDzbkREJMwFfEKxtXYKsAaI9r+ehe8gTTmMVHJoarYF7TwpT8FOPAU7j+reEqKY7u1IH9eSAEclIiISWMFYLXUD8Cnwuv9SU2BsoPuJRN1cqwGYF6TkJnvsE2SPfeKo75/h7Uhr10bI2xTAqERERAIrGBup3AL0BXIBrLUrgAZB6CfidHetpMS6WGTTnQ6lQjO9HXwv/vjF2UBEREQOIRjJTaG1tmjvG2NMFKBl4ZXQzaxiqW1OITFOh1Kh32xLdtk4+ONXp0MRERE5qGAkN1OMMfcBtYwxpwKjgS+C0E9EMXjp5lodtPk2geDBzWxvO1ijJzciIhK+gpHcDAeygYXAjcBE4IEg9BNRWppNJJsC5tnwTW4AZng7QPYSyN/mdCgiIiIVCsbBmV7gDf+XVFJX45tMvMDbKmh9JPU4s8pt7Jt3s24GdKh6eyIiIoEWjNVSvxtjVh/4VYn7zjDGLDPGrDTGDD9EvQuNMdYYEz6HLwVAN9cqCmwsK23ToPWR0HEACR0HVKmNhbYVuKIga2aAohIREQmsYJ0ttVcc8Geg7qFuMMa4gVeAU4EsYJYxZry1dvEB9ZKA24EZAY04DHR1rWahbYkHd9D6KMnNBiAqOfWo2ygkBhp1gazMQIUlIiISUMHYxG9bqa/11trngZMOc1tvYKW1drV/pdXHwJAK6v0LeArYE9ioHeYpprNZE9QhKYCtXz7L1i+frXpDab1h/WzwlFS9LRERkQALxrBUz1JfGcaYm4Ckw9zWFFhX6n2W/1rpdnsAzay1Xx6m/6HGmExjTGZ2dvbRfITQ27KYOFMc9OQmYJr1huIC2KJzpkREJPwEY1iq9KOBEnxHMVx0mHtMBdf27Y1jjHEBzwFXH65za+1IYCRARkZG9dhfZ73vdIr5Yb5Sap80/8jjupnQuJuzsYiIiBwgGKulTjyK27KAZqXepwEbSr1PAo4BfjTGADQCxhtjzrHWVv/JHxvmssMmsNZWk42ca7eAhAaQNQt63+B0NCIiImUEPLkxxtxxqHJr7b8ruDwLaGuMaQmsBy4BLit1z06gfqk+fgT+HhGJDcCGOf4hqYoeYIUhY3xPb9bPdjoSERGRcoK1WupYYLz//Z+AqZSdU1OGtbbEGHMrMAlwA29baxcZYx4BMq214w92b7VXvBu2LGGBPSvoXSX3Pi9wjTXtCcsmwu4dUKt24NoVERGpomAkN/WBntbaPABjzMPAaGvt9Ye6yVo7Ed9uxqWv/eMgdQcFJNJwsOk38JaEZDJxfJs+gWusaS/f9w1zofXRjESKiIgERzCOX2gOFJV6XwSkB6GfyLBhLhDcnYn3Kt6WRfG2rMA01qSH7/uGOYFpT0REJECC8eTmfWCmMWYMvhVP5wHvBaGfyLBhDiQ2ZNOeQ+5zGBDbJr0MQKPLRlS9sVp1oG7rfSu9REREwkUwVks9Zoz5Cujvv3SNtXZuoPuJGBvm+p6CbK0mk4lLa9oL1vzkdBQiIiJlBGNYCiAeyLXWvgBk+VdByYEK8yB72f4hnuqmaU/I2wi5Gw5fV0REJESCsUPxQ8A9wL3+S9HAB4HuJyJsnA9YaNLT6UiOzt5JxRqaEhGRMBKMOTfnAT2AOQDW2g3+Ay/lQHuTgqY9qU5ngaYPnwBALEX8Fuvm9Q9H8UyJYc2I4C9nFxEROZxgJDdF1lprjLEAxpiEIPQRGTbMgZTmkFD/8HUDIOWESwLaXiExLLPN6GZWBbRdERGRqghGcjPKGPM6UNsYcwNwLfBGEPqp/tbPgaahm29TK717wNtc4G3FWe7plDoKTERExFEBn3NjrX0G+BT4DGgP/MNa+1Kg+6n28rfBjj9COt+maPNqijavDmib821rUkwB6WZTQNsVERE5WgF9cmOMcQOTrLWnAJMD2XbE2VB6vk1obP9uJBCgfW785nt9J5lraEpERMJFQJ/cWGs9QIExJiWQ7Uak9XMAA40DP1QUSitsU3bbGLq7lNyIiEh4CMacmz3AQmPMZCB/70Vr7e1B6Kv6Wj8b6reDuGSnI6kSD24W2pZ0U3IjIiJhIhjJzQT/lxyMtZA1C9qf6XQkATHX24ar3d9ASSFExTodjoiI1HABS26MMc2ttWutte8Gqs2IlfM77N4Oab2cjiQg5nnbEBs1wXfCeYR8JhERqb4C+eRmLNATwBjzmbX2ggC2HTHSh0/gHNcvvBgDgz/bw5JPQ/eQq/aAq4LS7lxvG9+L9ZlKbkRExHGBnFBc+uTHVgFsN+L0cK2kwMay3KaFtN+4tI7EpXUMeLubqMdGW9c31CYiIuKwQCY39iCv5QA9XCtZYFvhwR3SfvdkLWFP1pKgtD3P2xqyMoPStoiIyJEIZHLTzRiTa4zJA7r6X+caY/KMMbkB7Kdai6WIjuYP5u0dygmhHVPfZcfU4EyJmutt45tLlL81KO2LiIhUVsCSG2ut21qbbK1NstZG+V/vfV+91zsHUBezmlhTwmxvW6dDCag5ez/PupnOBiIiIjVewI9fkEM71rUcgExvO4cjCayFthW4Y2DtNKdDERGRGk7JTYhluJaxwtuUHCLrYVYhMdCkB6yb4XQoIiJSwym5CSWvlwzXMmZF2FObfZr18R0rUbzb6UhERKQGU3ITStlLSDEFZHrbO9J93ZOHUvfkocHroPnx4C2GDXOD14eIiMhhKLkJJf98lJm2gyPdxzRsRUzDIG5B1KyP77vm3YiIiIOU3ITS7z+x0dYly6Y60v3uNfPYvWZe8DpIqOc7DPQPJTciIuKcsElujDFnGGOWGWNWGmOGV1B+hzFmsTFmgTHmO2NMCyfiPGpeL/w+hZ89x1B2M+fQ2fnrx+z89ePgdpLez/fkxlMc3H5EREQOIiySG2OMG3gFGAx0Ai41xnQ6oNpcIMNa2xX4FHgqtFFW0ab5sDuHn73HOB1JcKX3h6JdsHG+05GIiEgNFRbJDdAbWGmtXW2tLQI+BoaUrmCt/cFaW+B/Ox0I7cFMVbX6RwB+8XZxNo5gS+/v+/77VGfjEBGRGitckpumwLpS77P81w7mOuCrigqMMUONMZnGmMzs7OwAhlhFq3+EBp3ZSorTkQRXYiqkdoQ1PzkdiYiI1FDhktxUNAmlwsM3jTFXABnA0xWVW2tHWmszrLUZqanOTNwtp6jAN8m21SCnIwmNlv1h7XQoKXI6EhERqYGinA7ALwtoVup9GrDhwErGmFOA+4GB1trCEMVWdau+A08htDsdftzlWBj1Tr81qO2nD58AwOmuBF6PKeCiB19kpu3ImhFnBbVfERGR0sLlyc0soK0xpqUxJga4BBhfuoIxpgfwOnCOtXaLAzEevSVfQq060KKvo2FE10sjul7wpyr96u1MiXUxwL0g6H2JiIgcKCySG2ttCXArMAlYAoyy1i4yxjxijDnHX+1pIBEYbYyZZ4wZf5DmwounGJZ/Be0Gg9vZB2UFK2dQsDL4Zz/lEc9s246BLq2YEhGR0AuXYSmstROBiQdc+0ep16eEPKhAWPMz7NkJHc92OhJyZ44BIL5Nn6D3NcXTlbujR1GfnUHvS0REpLSweHIT0RaNgegEaH2S05GE1FRvVwD6uRY6HImIiNQ0Sm6CqagAfvscOg2B6FpORxNSi2w62TaZk9w6RFNEREJLyU0wLfkCivKgx+VORxJyFhffe3oyyDVPS8JFRCSklNwE09z3oU6646uknDLJm0Gy2a3dikVEJKTCZkJxxMle7tul98QHwDhzUOaB6p99Z0j7+8V7DLtsHIlLv4C21XM+uIiIVD9KboLkoxfu4Xx3NCd8lcb2ryY4HQ4AUcmh3bG5kBh+9Hbj7KUT4ax/g8sd0v5FRKRm0rBUMORv5Xz3T3zu6c92kp2OZp/8JVPJXxLaIaJJnmMhfwv88UtI+xURkZpLyU0wzBxJnCnmLc9gpyMpI2/uRPLmTjx8xQCa7O0FMYkw/5OQ9isiIjWXkptA250D0//DV55jWWUPdbB5zbCHWOh0Liwe51saLyIiEmRKbgJt2qtQmMsLJRc4HUn46HaJb0n8stA+NRIRkZpJyU0g5W+D6f+BTkNYaps7HU34aNEXUprD7P86HYmIiNQASm4C6adnoDgfTrzf6UjCi8sFva/3LY3fqJPCRUQkuJTcBErOGpj5BvS4AlLbOx1NhVLPvZfUc+91pvOeV/nO2Jr+qjP9i4hIjaHkJlAmPwSuKBjkUPJQCe74FNzxKc50Xqu27xiKhZ/CzixnYhARkRpByU0grJ4Ci8dC/zsguYnT0RzUroXfsmvht84FcMJtYFzw/aPOxSAiIhFPOxRXUdvh4/gy5j7iSeWUr9pSGCa7EVdkb2KT2MWhoxBqN4fjboJfXoQ+N0GT7s7EISIiEU3JTRXdEjWW9q4sri36O4XEOB1OWEofvj/hS+YYfoxNYN1r13Bh0cOsGDHEwchERCQSaViqKjYu4Bb3OMZ4+vK9t6fT0VQLuSRwX/H1dHOt5s6oUU6HIyIiEUjJzdHasxNGX0UOSfyz+Eqno6lWvvb25sOSk7kp6kuY9ZbT4YiISIRRcnM0PCXw+Y2wYy03F93ODpKcjqja+WfJlXzn6QET7oCpz4DX43RIIiISIYy11ukYgiYjI8NmZmYGtlGvF8bdDPP/B2c+Q/rn4bs66kDe4j0AuKLjHI7EJ4ZilvcaB4s+h6YZMGg4tDkFjHE6tAoZY2ZbazOcjkNERA5NT26ORPEeGDPUl9gMug963+B0REfEFR0XNokNQBHRcOHbcP4bkLsePrwQnusMX/7Nd9BmwXanQxQRkWpIq6Uqa/tq+OwGWJ8JJz8E/f7mdERHLG+Ob9VSUs+zHI5kv/R7JwIJRPMkg10zODNnJv1nfUhC5tuAgcbdoN3p0H4wNO4etk91REQkfGhY6nCKdzPi4WHcFjUGD27uKh7KJG/vwAQYYps+Gg5Ao8tGOBzJoUVRQjezir6uRQxwL6CHWYHbWLJsfdKOvwg6ngPNeoPLHdK4NCwlIlI96MlNRUoKYcM8WP4VzP2Q4dFbmOzpyT+Kr2Ej9ZyOLuKVEMVs257Znva86DmfOuRyinsOp7tmkTbrTd/5VAkNoP0Z0O4MaDkQYhOdDltERMJE2CQ3xpgzgBcAN/CmtXbEAeWxwHtAL2AbcLG1ds1hGy7e7Zu7UbANCrbCrmzYtQl2bfFd27MTinb55tMU5cOeHZC3EawXjBvanc7FC3oxw3YM+GeWyskhmdGeQYz2DCKxuIATXfM43ZPJwNmjSZrzHsXWTXRaD2jcFeqkQ5z//KySQijM9f3ZWg9ExUGtupDUCGo3g5TmEF+37FCXpxh2bfZ9FeSAp9B3ZlitOo58dhEROXJhkdwYY9zAK8CpQBYwyxgz3lq7uFS164Aca20bY8wlwJPAxYdq17thPjzWqMKy3TaGbSSTaxPIJ5Y9Nob+ndJ9/2NMSYNGXaBFX0iox4z54XukQk2zi3i+8J7AF94TiKaEDNcy+rkWcot7K/z2uS85PYDHGjy4iDEVLDd3Rfv+zF1uXxJUuDMEn0JERIIpLJIboDew0lq7GsAY8zEwBCid3AwBHva//hR42Rhj7CEmDW23STxVfAE5JLHdJrHdJrOVFLbY2uQTBxwwOXX+gS1Mr8JHkmArJopp3s5M83bmlmvPAmuhMM/3ZQy4Y2n3r598q7IAF15qs4vGZjtpJpsmZisNzA6SiwowWAqJJscmsYXaZNsUcmwShcQQRQm1TT5wv7MfWEREKiUsJhQbYy4EzrDWXu9//xegj7X21lJ1fvPXyfK/X+Wvs/WAtoYCQ/1vjwF+C8FHqE7qA1sPW6vmqczPpYW1NjUUwYiIyNELlyc3Fa3vPTDrqkwdrLUjgZEAxphMrW4pSz+TiunnIiISOcJlE78soFmp92nAhoPVMcZEASmAdnkTERGRMsIluZkFtDXGtDTGxACXAOMPqDMeuMr/+kLg+0PNtxEREZGaKSyGpay1JcaYW4FJ+JaCv22tXWSMeQTItNaOB94C3jfGrMT3xOaSSjQ9MmhBV1/6mVRMPxcRkQgRFhOKRURERAIlXIalRERERAJCyY2IiIhEFCU3IiIiElGU3IiIiEhEUXIjIiIiEUXJjYiIiEQUJTciIiISUZTciIiISERRciMiIiIRRcmNiIiIRBQlNyIiIhJRlNyIiIhIRFFyIyIiIhFFyY2IiIhEFCU3IiIiElGU3IiIiEhEUXIjIiIiEUXJjYiIiEQUJTciIiISUZTciIiISERRciMiIiIRRcmNiIiIRJQopwMIhXr16ttmLVo4HYbj1qxeDUB6q1YOR1K9zJ87Z6u1NtWJvuvXr2/T09Od6Foi0OzZsx37uywSSjUiuWnWogXfTJnudBhSTTVMjvnDqb7T09PJzMx0qnuJMMYYx/4ui4SShqVEREQkoii5qUEeffh+Hn34fqfDEBERCaoaMSwlPrNnznA6BBERkaDTkxsRERGJKEFNbowxa4wxC40x84wxmf5rdY0xk40xK/zf6/ivdzDGTDPGFBpj/n6INlsaY2b47//EGBMTzM8gIiIi1UsontycaK3tbq3N8L8fDnxnrW0LfOd/D7AduB145jDtPQk8578/B7guCDGLSDUwaNAgBg0a5HQYIhJmnBiWGgK863/9LnAugLV2i7V2FlB8sBuNMQY4Cfj0wPvl8Bo3aUrjJk2dDkMkYNLS0khLS3M6DBEJM8GeUGyBb4wxFnjdWjsSaGit3Qhgrd1ojGlwBO3VA3ZYa0v877OACv9vbYwZCgwFSGvW/Gjjjyivvvnu4SuJVCMffPCB0yGISBgKdnLT11q7wZ/ATDbGLK1ie6aCa7aiiv5EaiRA9569KqwjIiIikSeow1LW2g3+71uAMUBvYLMxpjGA//uWI2hyK1DbGLM3KUsDNgQu4sj2wD138sA9dzodhkjADBs2jGHDhjkdhoiEmaAlN8aYBGNM0t7XwGnAb8DhfOWxAAAgAElEQVR44Cp/tauAcZVt01prgR+AC4/m/ppu0cL5LFo43+kwRAJm3rx5zJs3z+kwRCTMBHNYqiEwxjcHmCjgI2vt18aYWcAoY8x1wFrgzwDGmEZAJpAMeI0xw4BO1tpcY8xE4Hr/k6B7gI+NMY8Cc4G3gvgZREREpJoJWnJjrV0NdKvg+jbg5Aqub8I3zFRRW2ce0G7vwEUqEl5KT4Zv3lyT4UtLHz6hzPtNq7c5FImIhDPtUCwSZqy1I621GdbajNTUVKfDERGpdnS2VA3Sqk1bp0MQCajour6dINKHT6ABOfRwrSAKL/O8rVlPKmtGnOVwhCLiBCU3NcizL/7H6RBEAqreGbfRhK08HP0sJ7vm4Db7d3340dON44ZvYxP1yt2npEcksim5EZFq6yTXHJ6PfgUXllc9Q5js6YUHNye55nBj1JdMiL2PG4ruZI5t53SoIhJCSm5qkDtv/z9AT3AkMpzpmk7RpKe41iay+fSnWWcb7itb5ElnorcPb0Y/w9sxT3N+0T9ZbZs4GK2IhJImFNcgq1euYPXKFU6HIVJlx7kW80L0K8zdFsNXWxuVSWz2WmWbcmXxcIpx8070UyRS4ECkIuIEJTciUq2kmS28Gv08f9iGLPU2x3OIf8bW2YbcVPQ30kw290V9GMIoRcRJSm5EpNqIooSXol/GjZfriv9+yMRmr9m2PW94zuayqB8Y4NIO3SI1gZIbEak2bo0aSw/XSu4rvp4/bKNK3/dcyQWs9jbioaj3iKIkiBGKSDhQclODdO7Sjc5dym0aLVI9bFrIre6xfO7pxwTvcQDENGhFTINWh721kBgeL7mc1q6NXOb+LtiRiojDtFqqBnn0yWedDkHk6Hg98MUwdpDIP4uv3He57ilDK93Et96e/OzpzLCoz6DwMYhNCkakIhIG9ORGRMLf7P/C+kz+VXwFO0k8ykYMT5dcTF2zC2a9GcjoRCTMKLmpQW6+/ipuvv4qp8MQOTK7d8APj0GLfozz9i1TtPWLZ9j6xTOVbmq+bcOPnm7w60tQlB/oSEUkTCi5qUE2bljPxg3rnQ5D5MhMfRoKtsMZjwOmTFFJ3lZK8rYeUXMvlpwHBdt8T4NEJCJpzk01Ya3lj99Xs3LFctb+sYZNmzawbetWdu7IIXdnLjk7cyks3IPX48Ud5SYxKZkWzdJo16EjGb2PI6P3cU5/BJEjt2MtzHgdelwOjbsBWVVuco5tB81PgOmvQe8bwa1/BkUijf6rDmO5O3cyfuxnjB83njkzfyEvd+e+MrfbTe069UiuXYfEpGTiExKoXbceLpebkpJiduXl8ssvP/PZqP8BUCs+gdjYOOrXr8eWzZto0LDyy2hFHDPlKTAGBt0b2HaPvwU+uRyWfgmdzw1s2yLiOCU3YWjD+ixe+vfTfPj+fyncs5smac05+cwhdO7Wi9btOtKkWQvq1kvF7XYftq283J3MnTWNn7+fxPhRH7AjZxtd2janWXorunbtSqs2bUlLa07zFul06NSZJk3TQvAJRSph2yqY9xH0vgFSAvz3sv1gqJMO019VciMSgZTchBGPx8Mb/3mZJ/71ECUlxZx13sVccPm1dOraE2PM4RuoQFJyCgNOPoMBJ59BUnIK27K30KpdBxbMnsHChQv5euKXeEr2b2rWuGlz/nzJJVxz/U1KdMRZP/8b3NHQ746DVolt2uHo2na5oc9N8PVw2LQQGnU5yiBFJBwpuQkTO3fs4C+XX8yMn36g30mnc/c/n6Jps/SA9nHbPQ+Xu+bxeNiWvZn1a9ewdNECpk39jpefe4aRr77MX++4i9vvvIeoKP01kRDL3QDzP4FeV0NS+UMx96oz8Oqjaj59+ASSqcvM2GhGv/wwD5ZcC8CaEWcdVXsiEl60WioM7MjJ4ezTT2b29J95YMSLPP/WJwFPbA7G7XbToFETevQ+gUuvuYkX3xnNuCnz6HviqTz52D859+wz2LbtyFajiFTZ9FfBeuGEW4PWRS6JTPAex7nuX4hnT9D6EZHQU3LjMI/HwzVXXs7vq5bx/FufcN4lVx31ENTh3HXTFdx10xWHrdekWQueevU9Hnr6VeZnzuBPZ5xCdvaWoMQkUk7hLsj8r28uTJ30Q1bNHvM42WMeP+quPiw5mSSzm3Pcvx51GyISfjTe4LD333mTX6d8y32PPcfxA04Oal87c3KOqP45f76cRk3TGHbtxQwZfCoTJ/9I7Tp1ghSd7GWMGQoMBWjevLnD0Thg4SgoyuP82V2YkznhkFU9u3Or1NUc25YV3qZc6J7Kx56TqtSWiIQPJTcOyt+1iycff4Reffpx/mXXVPq+osJCfpuXybLFC9m0YR15uTtxu9wkJaeQ2qgJ6a3b0qZDZ1IbVH25d+8TBvL8Wx9z29UXctnFFzL2y6+IiYmpcrtycNbakcBIgIyMDOtwOKFlLcx6i0XeFsyxbUPQoeFTzwDujf4fLc3GEPQnIqEQ1OTGGLMGyAM8QIm1NsMYUxf4BEgH1gAXWWtzjG8s5gXgTKAAuNpaO6eCNn8EGgO7/ZdOs9ZWyzGTD997h+1bs3n29Y8qNRT127zZjHz9ZTJ//JrC3QUARMfGkpCUgrWW/NydlBQX7aufUq8B6R2OIaNHT9p06ExBQT6xcXFHHGfvvoN46KlXePBvQ/nrbbfyn9dHHnEbIpWybgZs/o0PPNdx4G7EwfK5px93R33MBe6pwPUh6VNEgisUT25OtNaWnpE6HPjOWjvCGDPc//4eYDDQ1v/VB/iP/3tFLrfWZgYx5qCz1vLWG6/TpcexdO3V+5B1f1+5nEcfHs68n78jLiGRE844j+79TqJ15+6k1EvdlxhZa8ndvpX1v69k3col/L5kIWuWLOCd6VPwejz72hvQtTl1UhtRt2Fj2rRIp1l6Kzp06U6X7hnUik+oMIYzz7uYVcuX8N//PMfAAf245PIrK6wnUiVzP4CYRMbt6Xv4ugGSTR2meLtxgfsn3+njrsPvHyUi4c2JYakhwCD/63eBH/ElN0OA96y1FphujKltjGlsrY3IZ8Xz5sxmzarlPDDixYPWsdby4Vuv8PJTjxAdG8dFtw7n1D9fRa2Eik9FNsaQUi+VlHqpdMo4ft/1osI9bPxjNePeepH8vJ00at6SnC2byMnexOTFC8jbsR2AmNg4eg48jWF3DKdth87l2r/57w+yaP5s7v7bbfTolUH7Dp2q+FMQKaV4NywaC52GUDC9ck8Y41p0C0jXYzz9OMn9MvzxC7QcEJA2RcQ5wU5uLPCNMcYCr/vnEjTcm7BYazcaYxr46zYF1pW6N8t/raLk5h1jjAf4DHjUnxCVUXpSZlqz8JuU+eknHxETE8spg4dUWL57dwF/v30o0yd/Qa+Bp3HtfSNIqZd6VH3FxMbRol0nbn/ytQrL83bksHrxPOb+9C2/fjWWSyd/wakXX8MjjzxJdKn5NW63m389/waXDu7LDVf/hW+nTtP8GwmcpROgKA+6XQLT8yp1S+2+lwak68neXuyycSQuGKXkRiQCBHspeF9rbU98Q063GGMO9a9GRQPsFU2mvNxa2wXo7//6S0WNWWtHWmszrLUZ9erXP9K4g6qkpIQxn42m74mnkpRSu1x5UWEhN119ETO+/ZKLb72XYc+8edSJTWUk1a5DtxNO5Op7HuPf437mlAuv5JuP3+aaS89hd0F+mbqpDRrx4IiXWLZ4IU8+9nDQYpIaaP7HkJwGLfqFvOs9xDLJeywsHg/F2vNGpLoLanJjrd3g/74FGAP0BjYbYxoD+L/vnQycBTQrdXsasKGCNtf7v+cBH/nbrFamfP8t27I3M/jci8qVWWv5263X8duMn7j+waf509U3B2zfm6du/wtP3V5hLrhPYkodrrrnUW565AWWzp3BLddfjqfUfB2AgaeeybmXXMmrL/ybWTOmBSQ2qeHyt8Gq76HLheCq/D9Lm0c9xOZRDwUkhLGevlC4E1Z8E5D2RMQ5Bx2WMsYkA/fiSzK+stZ+VKrsVWvtzYdq2BiTAListXn+16cBjwDjgauAEf7v4/y3jAduNcZ8jG8i8c4D59sYY6KA2tbarcaYaOBs4Nsj+cDh4PXXXqNOvfoMOHlwubKxn7zH9MlfcNEt9zDwnIvLlW/fspFZ33/FT1N+ZOemtRQV5OOOiia+dn1apjenQdPm1K7fgJi4WpQUF5Obs5WcLZvZvmUjS+bMwloPt19wMnGJKXTs2IH23Y+l54DTiDtgInG/M8+ncHcB7zxxL68//wQ33/lAmfI7HnicmT//yP/dcA1Tps0mIaHiicgilbL0S7AeOOb8I7rNlhQGLIRfvZ0hIRV++ww6nROwdkUk9A415+YdYAW+eS3XGmMuAC6z1hYCx1Wi7YbAGP9ThyjgI2vt18aYWcAoY8x1wFrgz/76E/EtA1+Jbyn4vo1fjDHzrLXdgVhgkj+xceNLbN6o7IcNB3+s+Z2fvv+aq24aVmY+C0D25o0888i9dO7dj7OvKps75u3YzgtP/JPlU8bjLSkhpXEL6jZrTWxCMp6SYgpytrJo3mymT/4C6/WWuTcuuQ6J9RriinJjTAwpDZuxe+d2fpo4hu8+fZ/oWgmcf93tDL78eqKi98d08gVXsPK3Obz9yrMMOvVMOnXtua8sITGJh55+lZsu+xP33H0XL7/yahB+WlJjLB4LdVpCo66OheDBDZ3O9a3YKsyD2CTHYhGRqjlUctPaWnuB//VYY8z9wPfGmEr9SmOtXQ2UW8pgrd0GlNuK1z8p+JaDtNXd/z0f6FWZ/sPVay89j3G5uOjKG8qVjXjin5QUF3PdfSNwlXo0vzhzGs/d838U5u+k86kX0eWsK6jdJL3C9r0eD3tyt+MpLsK4o6iVXAe3P2EZ++BVAAwe/hIA1utl07K5zB37Np+8/ATffzWeR17/H0m19+9C/Jc7H2bhtCk8cNdtjJ44Fbd7/zLZjOP7c9m1N/PhW69wwXnncuIpp1X55yM1UMF2WD0F+t4OQTp6pNKOuQBmvQHLvoaufz58fREJS4ca3I41xuwrt9Y+hm/X1KlAvWAHFolWLF/Ku2+P5NyL/kKDRk3KlG1cv46fvhjNiedeSoO0FvuuL5w+hSdv/wtxSSlc+NRo+t/wwEETGwCX2018nVSSGjQlsV7DfYlNRYzLReOOvTjz3lc4/e4X2L52Bf8YegkFu/avVIlPTOaKOx/mj2W/8flH75Rr4+a7HqR1u47cMvRatmzZfAQ/DRG/pRN8Q1KdznU6EmjWB5Ka+IamRKTaOlRy8wVQ5rAVa+27wJ1AUYV3yCENv/su4uITuOmO+8uV/e8d3zLts668ad+1DWtW8eydN1CnaUvOffR96qe3r1L/LXoNpEWvgRWWtT7uVM64+wW2rlnKc/96sExZn1POplPGCbz09CPsyNlepiwurhaPv/Q2ebk7GXrt1XgPGBITOZT04ROYPOYdsmx90l/MIn34BNKHH/o8qdJqte5NrdYBXFPgckHn82Dlt7BnZ+DaFZGQOmhyY62921pbbrKutfZra0Ny6EtEmfjFWH7+fhLX33YXdeuXXdZdkL+LMR+/x7Enn0n9xmkAeEpKePqeW4iKieXM+/5DreSqH1jZ49xr6XHutQctb9FrIN2HXMuS7z7jtxk/7btujOHKux5hd/4u/vmPe8rd16Z9J/7+0AimTf2Ol557uspxSs0RRyH9XAuZ7OnF0Ry3kNLnfFL6HNkk5MPqfC54i2HZV4FtV0RCJtj73AiQn5/P8LvuoG2HY7js2vKLzCaO+YSCXbmcdvH+wzN/GPsR2asWMeDGf5BYr2GZ+ru2bWbx5NHMG/cOS78fw86Nf1QqjuLd+WQtnM7KX78me/ViKtj7kGMvvoXkhs0Y+dTDZY5sSGvdnjOvuJGpX4xi+k/fl7vv/Muu4fQ/XcCTjz7MtF9+KlcuUpF+rt+oZYqY7A2jqXRNMyC5qW+3ZBGplnQqeAi8+drLbN6QxWPPv0FUVNkfubWWD999gxbtOtO2q+8f+JLiIkaPfJHGnXrR+vjT99Ut3lPA+Of+webMr3ynJ5eS0KQt3U8/n7b9zya+dr0y7W9YnMmvYz4ke85kSu+LmNyqO2cO+xd101rvuxYVE8txVwzjm2fv5Nevx9LvrAv2lZ1/wzBm/ziJB/9+M59O+pWU2nX3lRljuO/x51ny2zxuvPZKpkybTZ26+8tFKnKqaza5Np6Z3g5Hdf+mj4YD0OiyEYELyuWCTkNg1puwJxfikgPXtoiExCGf3BhjXMaYE0IVTCTKz8/n5eefpd9Jp9Ojd/kf5W9zM1m7YgknXXDFvs36fp00jvztm+l1wY37rhUV7OKjOy9mc+ZXNB1wET3vep/jH5tEz7veo9WQ2zHuKH5550n+e91A3rv9XCY9cwef/ONG3rr2RMY9eBXbF/9CTHI94hu3osed79D6vL9RsGk1n95zKTs3rSsTU+vjTye1VSc+evUZiov27yMSE1eLmx99kZ3btnLXX28s9+QnMSmZx198i21bt3DLzTcG+kcpkcbr5ST3HH7wdqck3H7P6jQEPEWw/GunIxGRo3DI5MZa6wWeDVEsEWnCuM/J3bmDq278a4Xlb7zxqv+k7/0rRcZ9+F/qpLWiWff9JyOPe/Z+8jf9TufrnqLVObeR0KglUXEJJDRqRdMBF9Fj2Bv0vOt9mp96Ne64RDasXELBlrUkt+xCu0vvp89D46iVmkZ0fDKJTdrSpN8F9Bj2pq/tx2/DU7x/jrhxuehz+TByN2fx3afvl4m3ZceuXHzrcGZP+YaP//t6uc/TsUsPbhx2L99NHMe4z0dX5UcnkW7DXFJNLt95ejgdSXlpvSGxESz5wulIROQoVObXpW/8G/h9XtEBlXJon48ZQ6OmzSp8apO3cwczv5vAwCEX7zvpe8OalWxesYATrr5731ObdfN+JXvuZJqfdg11Ox5frp29Ehq1JKFRy0rHFlevCe0uuZ/F79zLb5M+odvZ+49maN6jH82692X068/R98zzSSo1BDX48htYMnsazz/+ID17n0D7zmU3Xrvyxr/y/dfjuf+ev3PKaYNJSKz4FHOp4VZ8g8capnqd27jvoFwu6HAmzP/Ed1p5dC2nIxKRI1CZCcV3AKOBImNMrjEmzxiTG+S4IoK1lnmZ0zn2+AEVng/17VfjKC4qpP/Z+zcLmzZpHBhD235n7bs25YOXia3TiGYnH/pcqKNR75j+pLTpxcxRr1FcuLtMWd+r76Zodz4vPfVYmevGGIY+9CyJKbW5+/brKS4quzNAVFQUdz38FNmbN/L6Ky8EPGaJECsmMde2ZQfhsxPw3qXo6cMncOWvqVCcz3UPPX1Ey9NFxHmHTW6stUnWWpe1Ntpam+x/rxl2lZCdvYWcbVvLPdnYa9y4z2jQtDmtOu3fyHnqN1/RuGNPEur6lovv3LSW3NXzaHz8EFxRB9+QrzLqdzuJ+t1OKne9xenXUrwrh8XfjCpzvW7ztnQ583IWTx7N6sXzy5Ql1a7Ldfc/SdaqZXzw5svl2uzWqw/9Tz6D1159iYKCgirFLREobzNsmMsPnu5VaiahQ38SOvQPUFBlTfN2JtfW4nRXZlDaF5HgOWxyY3yuMMY86H/fzBhT7U7idsLaNWsASGtRfqioIH8Xi2f9SsZJg/c91cnJ3sS2P5aR3mvQvnq/z/gOgNQep1Y5niZ9z6dJ3/J7gqS06kZK6x7M+vxtPCXFZcp6X3IrtVLq8upjD5abQNyj/yn0Gngab73yb3buKLu5H8Bl193MzpztTJqoeQtHwhgz1BiTaYzJzM7Odjqc4Fjp20LrR2/VkpuknmeR1POsw1c8CsVE8YO3Bye75+BCm1OKVCeVGZZ6FTgeuMz/fhfwStAiiiDbtvn+x1Snbv1yZfNnz8BTUkyXPvt/61w061cA0rrtn1ezeNoU4hu1JK5uo3Jt7M5eR9YPH7H8kxGsGvsC66d8wo6VcyjZnVeuLoCnaA+eoj0VlqWdeBlFO7NZ9UvZ1SEx8Yn0uWwYm5bNJfOH8itHLvy/u9idn8enH7xVrizjuP6kNmzMqFGjypXJwVlrR1prM6y1GampqYe/oTpa+S0kNmSRbXH4uofgLd6Dt7jiv9OB8J2nB/VMHt3MqqD1ISKBV5kJxX2stT2NMXMBrLU5xpiqjY/UELv9wzHxCQnlypYsnAdAq877f3NdsSCT6FoJ1GvhO2bBer3krV1Mao9y54yyZe63LPvf4+ApwlUrBVtShC3eP2fGndyIOukdiG/cmqS09iS16MySd33HPnS9ufwwUp32fajVMJ1pn75F2wFnl5kj1OHEIcwd8yYfvPosGSeeUaasWZsOdMo4gU//9x7X3vL3MmUul4vj+p/E1G8n4vV6yxwGKjWY1wOrvocOZ8HWqh2UuWX0w0CA97kpZYq3Gx5rONE9Nyjti0hwVCa5KTbGuPHv/maMSQU9o62MkmLfEE9UVHS5srW/r6JOakMSklL2XfttwQJSW3fG5T95e9f2zXj27CKxSdnTLvI3rmbZh48Q06gDtU/6K+5E35MhT8EOSrb9TnH2aoq3riZnzVK2LpgCWDAuTHQt4us1rjBW43LRdMBFrBz9FBuXzKZJp4x9ZS53FD3Ou54fX32QZfNm0qFHnzL3nnDGebz56F2sXLaYth06lynr0iODLz79kPVZ62jWvGq/pUuEWD8H9uyANifDdKeDObSdJDLbtuMk1zynQxGRI1CZX6VfBMYADYwxjwE/A08ENaoa4Pe1a6nXqOm+99ZacrJWUbdZm33Xcv2b68XVb1rm3vVTPsZExVDntLv3JTYA7vjaxDbrQWLPC6hz2l00uPQVGl77PnX/9AgJ3c/FlhSSv3Elc959ssKjFxr0OBV3XCK/fP5BubK2/QYTXSuBn74ov3dN1xN8h3HO/PnHcmUtWvkSs9UrVxzqxyE1ycpvwbig1YlOR1IpP3h6cIxrDeRudDoUEamkyqyW+hC4G19CsxE411qrSRSVsPcJjKfUGU175e3MITFl/2GYBXk7KSrYRXKD/YlM/rbNAMSmNNh3zXpK2LJgKnHpvXHFHX4JrSu6FrFNOpPc+3KiG7TFFV+H/AVfsPabd8rVdcfWokHPU9i2cApFBbvKlEXHxdOi10Bm/PhNmTOnAOo2aEy9hk1YNH92uTZTG/qeFG3ZvOmwsUoNsfJbaNoL4qvH8Rzf7530vHKys4GISKVVZrXU+9bapdbaV6y1L1trlxhj3j/cfQLR0b7hKI+npFxZ4e4C4mrF73u/c/tWAOLr7J9Aujtvh6+dpP1J0O6tWdjCXcQ0PfKNz4xx4U5pTK22A1k7+b/sylperk5qj1PxFheydm75wy9b9BrAntwc1q5YUq6sebtOLFr8W7nrybV9se/YseOI45UIVLAdNsyB1uW3JAhXy2wzNtvasOoHp0MRkUqqzLBUmUkU/vk3YXSEb/iKjvHNuy59PtNeHk8J7lJzcfJzdwIQl7h/Dk6x/+lJVOz+JKhgy1rftbrNjjieWu0HEd/+RJL7XoeJiWfJF+Wf3iSnH0NUfApr55RPbpoe45trs3TujHJlTdLbsGnt73i9Zadjxcf7JlPn5+8qd4/UQL9PAeuF1uUnyR+NxC6nkNjllIC0dXCGn73H+GL3arqhSHVw0OTGGHOvMSYP6FpqZ+I8YAswLmQRVmOxMbEAFBcVV1heemVR4R7fSqeo2P3bvHtKinwTgd37530X5/n2k3HH73+aU1nx7U8ivv1JuGITiGt5HIVrZuEtKbu7sHG5SW7ZhT8Wlt+4LLFeQxLrN2LlgvLDTw3SWlBSXMSWTRvKXI+JjfV/vuAt15VqZOV3EJviG5YKgNAkN/CzpwsUbINNC4Lel4hU3UFXS1lrnwCeMMY8Ya29N4QxRYwo/7BUSUn55MYAXrv/t0Cvf+jKFbX/j8R6vZgDlk97Cn3Ly01MPAeyJYXkL5pE8ZbluOKSqNV2IDGNOuzvY7fv1AxXrWRim3Rm99Jv2bNtA/EN08u0k9ikLdsX/4qnuAh3dNlV/w3adGXxgvIrR1KbpAGwcf06Gvlfgy+Bi4qOpriCn4HUDPuPLrD8EjuR+d723Hz/pIC07SnwPfF0x6ccpmbV/Ow9xvdi9Q/QpGobD4pI8FVmWOp+7VB8dPbOuSkuLipX5nK7y03MBcquYjKm3KqmvUmQcZXPS7dMfIa86e9SuGEpBct+ZNu4B9izZta+8pzJz5Az+Rlf//4nP0V55XcWjq3bCKyX/O1bypU1aHMMuZvXkbcjp8z1+o33JzcHioqKpqS4/LwjqVlamw00Ndv4ydslYG1mj32C7LHBX7yZTR1o0EnzbkSqicokN6+gHYqPyt5N6w6chwK+yb221JMbl8u3ssqWSnjc0THg9WArmJB8oMJ1c/FunIM7/SRi+95NbL/7MElNyPn2ObxF5c92sv5dXV3RseXK3P45PsV7yt/XoK3vN9g1S8s+nq/bwLcqKvuAYSnfZ3NV+DOQmmWAy/d35qdwPAW8MloNgnUzoKT8HDoRCS+VSW76WGtvAfaAb4diQDsUV0JFJ4EfrGzvEJbXuz+RifbPvyl9ZILLP//mwIRn98qfISqOqJa+VSgmKpaoNmeAp5CiTUvL9V+S43vCUiu1/MRkr7+/qNi4cmWprToB8PuShWWux8UnEBtXi21by5+FdKifg9Qc/V0L/5+9+w6PqvgaOP6dTe+BEGqAUELvhF5EQURAeheRJmJBEEVQFJFXFBQEFAWRLkgXaYIg0hQUAtJ+oVfphBrSszvvH7uBhFQg2U025/M8PNm9d+69Z+M1Obkzc4ZTpkJc0Dl0SYniDSA+Gi4mH3MmhMhesrRCsVLqLBAOGIF4rXWwUiovsAQIBM4CXSxLOihgCtASiAR6a633pXDOmsBcwA34FRisU6pIlw0kPK1I6Ze7yWRE8WC7o2Vsi8PimUEAACAASURBVDFRF5azu7mOTXz0PRzdPAEwOJsTDh0fDc4PBh9HXz6BwbsoyvIECEC5+pqvFZm0Cwkg5sIBHPME4OSefIH3qBsXQRmSTEtP4OLhjXfBosmSGwBPnzzcvZ38WkajUZZeyOWciaOu4QhLjU/ZOpTHVnVeBP+6KL6aMZupxgf3+dlxWbNwpxDi8T1uheLPHuEaT2utq2mtE+r5jwA2a62DgM2W9wDPA0GWfwOAaamcb5plf0LbFo8Qi1XFWZZfcHBInkMa4+PvJzQADglPbhINvHWxLM0QH/lgIcyEJMcUE5HkfMrRBR0flWSbDjd3ETn6Jq1wbIy4QezlUAoHp7zS+J1T+/EoVOr+k6OH+Zcoz7HQ5MmNi7sHkRFJF+3UWhMbE42LS/LuL5F71DQcx13FZOp4G2u7gyfHdFHqGkJtHYoQIh3pPrnRWi9USu0FmmKe5NNOa528ilvGtQWaWF7PA7YCwy3b51uewvytlPJVShXSWt+vea6UKgR4a613Wd7PB9oB69O64MkTx2nfMul00TbtO9HnlYFERkbyYqc2yY7p+mIvur3Yixs3wuj/Urdk+1/uN4B2Hbtw8cJ/vDmgT7L9AwcNwclSx2bS2JF4eiZ9QhIRfgdnVzfOHfsfP04cTUyUeXzL3wuncGDNfOq8OAQ3b/Og32OLPsUp4SlOlLleTOzlUJzyBBBz4QD39q2AmFvoyNvEhEwHZcCxbDvi/9sFTh7c3b0QhcIYZZ5ZEvbLSNAm8tdqwfV/N3N518r7cRljY7j33xGqt+8PwNE/VnJ0yy9JYg+/dpHw65eIiY5i+5ql/LNpLQA3rlwk5PYNBnRtxYwl5hkys7+diMlkYuXyJez+27zquaurG4t+XgPAV+PHsmNb0kGaefLmZfYCcxHsT0ePZO/upHV1ChUuwncz5wHw4fB3+N+hA0n2lywdxMSvzbnxO2+9lmzph4qVq/Lp+IkAvN7/ZS5fuphkf83adfhw9FgA+vbsgnhyjQyHiNMO/G2qkKnn9areMlPPl56/TeXp5rAFJ+KJy9CDbyGELWS0r+AqsAPYCbgppWpk8DgNbFRK7VVKDbBsK5CQsFi+JqwtUARIPNXmgmVbYkUs29NqA4BSaoBSKkQpFZLwBMXaoiwJS0pdMrHRUbi6J5/Oben9A8Dd17xulDY+iN/gaH7aY7oXluQog7svoNGRYWCKx3h2C/rOWdxKN7jf/eXg5oPB1QtT5E2cC1XEzS/5ty76xiVQirJPvZDq50qoxXPtwtmkkWudpKsNINJSvC9hTJHInRoZDrJPBxFByk8DH5dH+cZ4lG+cqedMy9+m8ripWKqoU1a7phDi0an0hqsopf4P6A2c4sFvXq21Trd+ulKqsNb6klIqP7AJGASs1lr7JmpzS2udRym1Dvhca/2nZftm4D2t9d5EbWtZ2jSzvG9kaZP6b2KgWo2aeuM26y8/vGzRAt58tS8rt+yjWIlS97fHxcVRNygfHQe+Q/v+QwA4e/QwH/Z8nhbDv6ZkHfNTpriYKH7oEUzxFv0p1uxlwFz75q8PnsOtdCN8Gr+a5HrhexZxb9/y++8dAurh33IoSpmTK+O9MCJPbOPe7p+o9Opk8pQJTnL8jf/9SejsEdR5cQg1Ow4gNVdPHGTF8G68PXEWNZ9qfn/7kBfqUadeQ8Z89f39bSG7dvBq99Ys/eVXnnom64utZYUC3s57E3WrWlVwcLAOCUleUDEnqTFiEftcBzIhrjNTje0z9dzxd80D2B29rTNIOQ93+dd1IOPjujHNaH7im5PG3CilbHYvC2FNGXmu2gUopbVOXqwlHVrrS5av15RSK4HawNWE7iZLN1NCMZULQOKpOwHAw/OKL1i2p9Um24iIMI+LcffwTLI9/I55nSUPr/s5HvGWgcSJi+Y5ubjh6O5DzK0Hi04qgwHnQhWIPrcHbz0gyWBlz+BuOBeqSPztCzj5lcC5UPkk1721eTJx107gVKAsvkFJK8TGR0dycsVXuBcsSbU2vdP8XO4+fubPcStpjZzw2zfxzZsvybbzZ04CUKJUaUTu1NBgHp+1PQumgIetNXcvFuwxLtPPnZJbeHPSVJhgwzHzNAkhRLaUkW6pw4Bvuq0eopTyUEp5JbwGmlvOtRp42dLsZR4s5bAa6KXM6gJ3Eo+3gfvdWOFKqbqW2VW9yMZLQSSsp+T2UPdTuGUdKQ/vB1VVY2Ms068fqjvj7l+UyGtJC+MFNmqFKfIWcVeSDn1SSuESUAWPSi2TJTZgfnKDKZ5yHd5INoPr7K/fE3v3Oi0Gf5qsKvHDnNzNyVp0opXDI+/dJSYqknz++ZO0PXksFHcPTwKKFkvznMJ+NXY4xE3tyWFdwtahZIo9prIEG46hMjZpVAhhAxlJbj4H/lVK/aaUWp3wLwPHFQD+VEodAHYD67TWG4BxwLNKqRPAs5b3YJ7WfRo4CfwAvJ5wIqVU4nr/rwEzLe1Okc5gYluKtDy5cbMsHpkgIblx9/S6vy0uxlwYzME5aXITUKY8EZdOohMVwfOr1BiDqzd3//4RbcrYn4+xV45iuncd5eqNb+mkQ6aiwi5wedcvVHquGwXLpl9aPmHBz/hEY5nCLpsH5RYskrRuzpFD+ylTobJMBc+ttKaR4SB/mSphyvAQv+wtxFQWHxVJkLqYfmMhhE1kpFtqHjAeOEQG69sAaK1PA1VT2H4D88yrh7dr4I1UzlUt0esQoFJG47Cl6JhoHJ2ckv1ij7YMNHZ2fTC4MqFbyuCYdOBtoXI1CN24lIjLp/AsEgSAg7MrQR3f5tjCTwjfvRCvOi+lWSgvLuwMt34bDw7OeBYsnmz/+U3zMBgcCO48MEOfK2GcljI8uOZVy+DiosUf/HUeFxvL0cMH6Pfq64hc6toRCqjbWdIlZSt7dFkAgg3HOW5MXgRTCGF7GUluwrTWX2d5JHbIGG/E0TH5LCGT5WmLQ6JFMu8vkPnQAO+i1eqDwYGwA3/cT24A/Ks34799O4k4sArj3at41++Dg2fS8S6mmAgiQ38jPGQJBldvPAuXwuDgkKRN1PX/uLb3N6q2finFon0piY9OnpxdOXcGgIDiJe9vO33iKLGxMVStntHJdQLMM/0w13KiWLEc3p13ajNgWVXbTpzX+bmmfQk2HOMnY7K/04QQ2UBGkpu9SqnPMY+Jub+oSkrVg0VSSqkk3UkJEtaRSrxwpoubZT2nqKTF+dx985G3XB0u/72GgKd74Ojmdf/cNfqN4uK2MpxZO43os7txLlAWxzwBoBTxd64Qd/UYOj4Gl8A6VO/zEXfPHU4Wy7kNMzE4OFK9Xd8Mf67oCPPq4h5eD8YMXTp3Eh+//HglGkeUUOivclVZRflRaK1nADPAPFvKxuE8mZO/c9xUhMv4ZcnpvWtn7uyrjFGEmMpQSx2zwbWFEBmRkeSmuuVr3UTbNJDuVPDczsXFhdjYGHP9l0TdRgkJwD3LrCl4sPBkeNhlHta0z1CWvdeZ06unEtRlxP1zKaUIaNKdfFWe5srfq7hyeDdRZ8xT3h08/SlYpxUFgp/Hq5h5cLFfxYZJznvr6D9c37+Zmp0GZvipDcC96+YY/QoWvr/t0ukTFCkZlKTdiSOHcXVzp0RJmSmVK8VGwLmdbDNlXQkA99J1suzcadlrKkNLp90U4Gb6jYUQVpeRCsVPWyMQe+Tj64vWmoh74Xh6PahQnNcyo+h22LX72/IXKYaTqztXjx+g3NPtkpzHv1QFanR4hX0rZuDiW4BizfskSZZc8xYksOWrBLZMWvfmYZHXzgPgnr8YNw7/ydEFH+NeqBQ1OvR/pM9164K5gFnBYuYuKK01F8+epG2nHknanToeSsmgsjg81BUmcomzf4ExNkvH28TdMNf0dPILSKdl5tpjejDuRgiR/WSofrhSqhVQEbi/TLTWekxWBWUv8uUzPw0Ju3Y1SXKTz78ALm7uXD578v42B0dHAms9zYkd62jY74P7M5IS1On+FhfO/cf5jbOJuHyKUu3fxsUn6Rib9JxYNp74iLs4evhw9/R+PAoH0WXsHJxcU6qUnLrrp0Nx982Hj6WmzY2rl4iOuEeJ0mWTtDt76gSNGufchRLFEzq1GRzd2B1dLssuceO3qYD16twkCNXFidQu5no3QohsJ925mUqp6UBXzNWFFdAZSD7lRiRTvIT5ycaF82eSbFdKUaJ8FU4cSjpsqU3HzsRG3iN049Jk51IGAx3fn0C9Xu9y88gu9o7vzqmVk7l34ViK43oATHExhJ8P5eL2pYTOfp+7Zw4RefUM0WEXaND3fXpOWoabT95H+kxaay79bw+Fyj8YJHz+uHkhwaDyDyaxRUdHcfXyRUpK8b7c6+TvENiAGNKum5QTxePIAVMpasqTGyGypYw8uamvta6ilDqotf5EKTUR+DmrA7MHpYLKAHDm5DEaPt08yb5mzZ5j6hefEHblIvkKmtd4qtbgGYpWa8jO+RMoVCGYfIFJn4Qopajeri8l6zZj48yvuLxrFZf+XI6juzfu+Yvj6OGDUor4qHvE3L5G9K0rYJmZ5Zq3EO6+frh6+dJ5wvJkT4Yy6sbZY9wLu0LXgUPvbzsdegBlMFC2woMZMZcvmLvAEhI8kcvcPA03TkKtV8ylO+1QiC7Da4bVEHMPXDzTP0AIYTUZqaoVbfkaqZQqDMQB9lFqNIv5+eWjQKEiHDm0P9m+5i90QCnF5uU/3t+mlGL4uCm4eHizenRfrp44lOJ5fQoWo/OHk+k9cwtN3xpHUP3mKAdHYm5dIerGJbTJSEC5KtTs8ArPDZtMrxl/0HfmZnwLB+Lq5fvYiQ3AsW2rUQYHajR+9v624/v3UKx0+STFCi/+dw6A4oFyq+RKJ343fw16Nu12OdheUxkclQku7k2/sRDCqjLy5GaNUsoX+BLYh3mm1A9ZGpUdqVStJgf2/pNsxlSRooHUbtaKTUvn0rRjT/IVMg+I9M2XnzGzVzBmYA9WjepNw77vU75ZxxSL9Ln55KVskzaUbdLGKp8l8tZ1QjcupVS95vfH20RHRXLi4F669HolSdsLlro3ktzkUic3Qd6S4FcKOGrraLLEPlMQJq0wnN8FJWVsmRDZSZpPbpR5OenNWuvbWusVmMfalNNaj7JKdHagRYsWXLn4HyePhSbbN3LUWAC+Hz0UY3z8/e0Fi5bgs3mrKFCmClunjWL9uDeJuHn9iWOp2elVanZKe0ZVWv5eMAljfCyvDh1xf9vBv7YQFxtDo2eeS9L2v7OncXP3wD9/gce+nsih4qLgzA4Iap5+2yfkU78bPvW7Zfl1UnIXD47oYnBup02uL4RIXZrJjdbaBExM9D5Ga30ny6OyIy1atsbB0ZG1K35Ktq9I0UBGjJnAkb27+H7020mK+vnmy8/ns5bSY8iH/HdgJ4sHv0DopuX3lz54HEWr1qdo1fqPdeyRzT9zdMsvtOr5KoUSVSHetnoJefwLUKNOgyTtz5w6RvGSpdNcFkLYqbN/QXwUlM76Lim3wGq4BdquSORuUzm4sAeMcek3FkJYTUbG3GxUSnVU8lvqseQvUJBnnnuBXxb/yJ3byQt+vdCpB2++9zE7N/zClOGvEhXxYKVtg8FAy56vMm7RRvwCy7J12ihWjerNrQunHyuWsDNHCDtzJP2GDzmxYx3bpo8moGp9Og585/72i6ePc3DXVjr36JOklo3JZOLoof1Ur149pdMJe3d8Azi5Q2DD9Ns+odirp4m9+nj/P2SG3aZyEBcJlw/YLAYhRHIZSW6GAsuAGKXUXaVUuFLqbhbHZVfeHzmSiHt3+WHKFynu7/P6UN79eDz7tm/ikz5tufLQ1PFCxUsybs5y+o0cz42zx1jydjt2/PApkbfDUr1mfGwM/+3fya4FX7F+/Fv88tHLrPq4L79+/gbn9+3AaFmoMy2xURH8NWc8myYNo2DZaoyaMvP+Wllaa5ZMHYeLuwddeyft6joWepA7t2/RoGHjdK8h7IzWcPw3KPk0OLmm3/4J3dw8g5ubZ2T5dVKzx2Sp4SNdU0JkKxmpUOxljUDsWcVKVej4Yl8WzZlG/aeaUb9J8nL03fsMpGRQWd57ozcfvdSKgZ9MomaTB+NYDAYDT7fvQY2nmvPzjK/44+eFhP6+nJL1mlOsWkO8/AtjjIvl1sXTXDy8mwsHdhIXHYnB0RGfQsVx9fLFGBdLzL07rP30VVw8vSlV7zlKN3yeQuVq4OD0oBbJvbArHN++hgNr5xN1+waVWnTn3Y8/xTFRm12/rWLf9k28NeITfPMkrZWzac3PODg60qRZ1o+5ENnMtSNw5zw0ftfWkVhFGD7gV9qc3DR4y9bhCCEsMlqhOA8QRNIKxduzKih79OWEiRzcu5v3Xu/F13OWJRujAlCn4dMsXreDQQNeZNK7/enyxnBe6P1GknErPnnz0WfEZ7To3p/1C39g56a1nNi+Nsl5vPwL06hlB2o0fpZyNevialmU89MBndEmE61ffo3VK1dwfPtaQjctw8HJGe8CATg6uxJ5+wYRN68CEFClLq9MnkOpSkm7ly6cOsbccSMpXbkGL/Z/M8m+2JgY1q5YRMMmzfG3LDMhcpHj681frTCYONsoXh/+t8pcU8ogS40IkR2km9wopfoDg4EAYD/mBTR3IQtnPhJ3d3eWr1rLCy2a8ebLHRk1fiot2nZK1q5QQDEW/ryJdwYPYOm347l1/Sq9ho1JNjC3UPGS9P3gc3oP/5SLZ05w58Z1HJ2c8C9SHL8ChVKNQxkMVG/UjOqNmhEdFUnonr84+u8/XLtwjvi4ODzKliOwXCWqNniGwoGlkh1/7cI5vnjrJZxcXJk8bR6OjklvoV9/WcKNsGu8MWjQY36nRE4VOGIdy50X40wJ2ny2L/0D7EXJJrBvPlzaDwE1bR2NEIKMPbkZDNQC/tZaP62UKgd8krVh2acCBQuxbtMWenbrzMjB/dizaxtDP/wMD8+kPX8urq58M30ekz/7kAU/TMVkMtJ7+NgUZx4ZHBwoWrocRUs/+vo9rm7u1Gj8bJKCfGk5cXAvk97tj8kYz8zF6ygUUCzJ/qjICKZ/9RkVq9agcRPJfXObfNyhhjrBlPgOtg7FukpYatyc2SrJjRDZREaSm2itdbRSCqWUi9b6qFKqbPqHiZT4++dn7YbfGT92NFMnTWDPX9v4ZOJ0qtdOOkVbKcWQDz7FweDAvO+n4O7lTdc3RqRy1ozp8sbwxzrOZDSy9sfprJg+Eb+Chflu7nJKlC6TrN30SZ9x/epl5ixYLFPAc6FnHPZhUJpNJuv9gvdt/LLVrpUqj3xQoDKc3gqN3km3uRAi62VkttQFS4XiX4BNSqlVwKWsDcu+OTk58eHosaz+bQvKYOCVri2ZMXkcpocWwFRKMWjEJzzd/kXWzPmWdT9Of6LrlqkaTJmqwY90zJmjhxjdpy1Lp46jZpPnWLx2a4qJzaF9e/hp1nd06N6bWnXqPVGcImd61rCXCzofodp66+q6BpTHNaC81a6XqpJPwfl/zAUMhRA2l25yo7Vub6lQPBr4CJgFtMvqwHKD2nXrs33XXlq278b3kz9n2MCXiI5O+sNRKcX4Cd9Q99kXWDRlLBuXzH3s6x0/EMLxAyEZanvlvzNM+2gwo15qxY2rl/js61l898MCfHyTryJ++9ZN3h/Ul4KFAxj/xZePHZ/IwWIjaGQ4xCZjTcB6T+2iLxwh+sKj127KdCWbgDEGzu+ydSRCCNLollJKuQIDgdLAIWCW1nqbtQLLLTw8PZk1Zy4/1A5m1Pvv8lbvzkyetRh3jwerDDs4ODD529m83r8H87/8iDs3r9Px1XcwGDLy4O2Bpd+OB+DDGctS3B8dGUFoyE7+XLeCPVvW4+jkRK8Bb9Hn9aF4+fimeEx8fDzvv9mbsOtXWPPbVrx9fB4pJmEnTv2Bq4pjo+nRngw+qdvb5wFQsMc4q143meINwNHVXOOnlIw3E8LW0hpzMw/zCuA7gOeBCpgHF4tMppRiwOuD8MuXjzcH9OGdAT2YPGspLq4PiqA5OTvz3axFvDf0dVbN+ppTh/6lzwefUSAgMEPXMBmNREfcIyryHgsmjubendvExsaYa99ERXHz+hWunD+NyWjE0ycPPfu/wYv938Q/f8FUz6m15ouPh7H7r21M/u4Hqte07i82kY0cWcMt7ckeUy4djufsbn56c+xXaDEOZMyZEDaVVnJTQWtdGUApNQvYbZ2Qcq+OXbpjjI9n0MB+jBzcj/HfzU+yrIGTkxNffT2DlfUbMGHM+7zX6Rkav9CFJm27UqJC1WRPcuLjYjn67272bF7Hni0buHvTXNF4yy+L8M7jh5OzC45OTji7ulGubDmeb9WW6rXrE1y3EU7OzqRnwcyprFg4mzeHvEP3ntlgYKedUEoNAAYAFCtWLJ3W2UB8LBzbwCZjTeIzVjrLPpV93rz0xLVQKFDR1tEIkaul9ZPo/kpwWut4mf1iHV16vMSdO3f4cPhQxn4wmI/GfZNk5pFSig7de9OoaQu+HP9/bF+7jC0rF+Lpk4fiZSvi65cfk8lI2OWLnD8RSkxUJM4urlRv3IyrZ47j5eXDnJ83PfFspj82rGHKZx/RtGVbRo4e+6QfWySitZ4BzAAIDg5+/JVSreXMdoi5w3pTbVtHYltlWpi/HvtVkhshbCyt5KZqojWkFOBmea8ArbX2zsgFlFIOQAhwUWvdWin1DDABcAb2Av0syVMeYDZQCogG+mqtD6dwvrnAU0DC6uS9tdb7MxJLTvHKa29y6+YNJo4fi7OzC+998mWypzL++QvyxcRvCR81lq2bfmXv339y5NgRjh/YgzIYyJu/IO269KROw6ep3eAp3Nw9GNC1FcATJzbHQw/x0dsDqFi1JrPmzH/ksT/CzhxZBc5e/BVdydaR2JZXQShSE46shcbDbB2NELlaqsmN1jqz6ogPBo4A3kopA+axPE211seVUmOAlzHPwPoA2K+1bm8pFPgt0DSVcw7TWi/PpPiypWEfjCI6Oopvp3xFbEw074+djJOTU7J2Xj6+vNCpBy906pHuOd8Z9fkTx3Uz7Dpvv9Idbx9fflq6Ajc3tyc+p8jBjPFwdB2UeY7YkOT3Z1bL23SA1a+ZportYeOHEHYC8gXZOhohcq0s/ZNbKRUAtAJmWjb5ATFa6+OW95uAjpbXFYDNAFrro0CgUqpAVsaXnSml+GjM57wzfCSrli7grd4duXUj9VXAM6JsxSqUrVjlsY+PiY5m2GsvcSvsOguXrqRAwdSXeRC5xNntEHnD/EvdBpwLlMS5QEmbXDtFlTqBMsDBpbaORIhcLav7EyYD7wEJ1enCACelVMK0mk5AUcvrA0AHAKVUbaA45vWsUjJWKXVQKTVJKeWSUgOl1AClVIhSKuRG2JMlBbailOK9kR8zZdpM9u/5m+4tG7Jz6++Pfb5//tzCP39ueaxj42Jj+eCtfuzfs4uvp8+kSrXq6R8k7N//VoKzJ5ROvtK9NUSd3U/U2WzUK+1dyLwcw8EloLP/cCkh7FWWJTdKqdbANa313oRtWmsNdAMmKaV2A+FAvGX3OCCPUmo/MAj4N9G+xN4HymFe7yovkOKaAlrrGVrrYK11sF++fJn0qWyj24u9WP/HDjy9vBnUuyPD33iZi/+dfeTzzPpmArO+mfDIx12+cJ7XerZl68a1jP1iEu06dnnkcwg7ZIyDI2ugbEtwck2/fRa4s3Mxd3Yutsm1U1W1G9w+JwX9hLChrJy32QBoo5RqCbhiHnOzQGvdE2gEoJRqDpQB0FrfBfpYtivgjOVfElrry5aXMUqpOcC7WfgZso1KVaqxbVcI306ewOSJX7Bt06+0bNeFbr0HUqZC5QyfR6M5c/I4p46HcutGGHGxsbi4uuKTJy9++fLjmzcfrq6uREZGcO70Sf78YwPrVi7B0dGJabPm06Fztyz8lCInCByxDoCnDAeY53yLV/YGsGnPOhtHZTsJ348Ebjjxj4s73ntmQvH6qRwlhMhKWZbcaK3fx/yUBaVUE+BdrXVPpVR+rfU1S3fScGCspY0vEKm1jgX6A9stCU8SSqlCWuvLlgSoHZBsRpW9cnFxYejwkXR/qTeTvxzHooXzWbV0ARWqVOfp516gdoMmBJWrmKT4n9Fo5Oyp4+zfs4tTJ44QfucOnZrVyvA1Xd3cadPpRUZ++CEBRXNAzRVhNW0d/uKOdmebqaqtQ8lWonBlqfEp+oeugruXzV1VQgirskXFrWGWLisDME1r/Ydle3lgvlLKCIQC/RIOUEr9CvTXWl8CFiql/DFPSd+PeYmIXKVQ4SKMn/QNIz76hGWLF7JwwXy+/XIM3345BqUUefPlx93Dg7i4OMKuXSE+zlyyyMnZmbx+fnz4yVgqVa5C/gIFcXZ2ISoqkps3wgi7fp2wsOvExMTg4eFB4SIBVKlWAxeXFIc1iVzMlRieM+xhtbE+sVh/llR2N9/YnP6mDbB3Djz9ga3DESLXsUpyo7XeCmy1vB4GJCsCobXeBaQ4d1Jr3TLRa1m4xSJP3rwMeH0QA14fxJXLlwjZ/TdH/neYS5cuEhUZiZOTE/kLFqRs2fLUrFWHdwa/jsI8hicx3zx5KFS4iG0+hMiRnjXsxUPFsMrUwNahZEvndQEo8xzsmQkNhpiXZxBCWE0urpVuXwoWKkzrth1o3bZDqm0mTPnWihEJe9bW4S8u6bz8Yypn0zj8nnvTptdPS6dDtVnusoHRnwxnrrHF/e1nx7WyYVRC5A5SWjYXKR1UltJBuXRhQ5Fp/LlNE8MBVhsboG38I8TJLwAnv9QqRthWiC7HP6ZyDHBci1OKEz+FEFlFkptc5Lf1a/lt/VpbhyFyuLYOf+GoTCwzNrZ1KESe/IfIk//YOoxUfRfflsLqJh0dtts6FCFyFemWykWmfzMZgOeeb23jSESOpTWdHbaxz1SaU9r247Tu7l4JgHvpa1y1aQAAIABJREFUOjaOJGXbTFXYbyrFm46/sMLYmDj5kSuEVciTGyFExl3aR1nDBZYbn7J1JDmEYnJ8RwJUmDy9EcKKJLkRQmRcyBwitQtrjPVsHUmOsdVUlX9NpXnT8RcZeyOElUhyI4TImKjbcHgFq4z1CUemNmecYkp8B3l6I4QVSXIjhMiYg0shLpKFxqa2jiTH2Wqqyn5TKd5wWAXxsbYORwi7J6PbcpGpM+bYOgSRU5lM5oJ0hatz+HRJW0dzX77W79g6hAxSTI7vwFznL+HgYqjRK/1DhBCPTZ7c5CJFAopSJKCorcMQOdGpzRB2DOq8ZutIknD09sfR29/WYWTIVlM1DppKwI6vwChjb4TISpLc5CK/rFjKLyuW2joMkRPtmgpehaFie1tHkkTEke1EHMkp41gUU+Pbwa0z8L+fbR2MEHZNkptcZN6sGcybNcPWYYh0KKUGKKVClFIh169ft3U4cPkgnN4KdQaAo7Oto0ki/N9fCf/3V1uHkWGbTDUhfwXYPsHc1SeEyBKS3AiRzWitZ2itg7XWwf7+2aDLZfsX4OINNXvbOpIcT2OARu+Yu/iOrrF1OELYLRlQLIRIUeCIdZRX51jvsoYp8R2Y9MlOW4dkHyq2hy2fmZ/elG8DStk6IiHsjjy5EUKk6m3H5dzVbsyKb5F+Y5ExBgdoNBSuHIQTG20djRB2SZIbIUSK6hn+R3OHvXwf/wJ38bR1OPalSlfwKQbbxoPWto5GCLsj3VK5yMwfF9s6BJFTGOMZ5Tif/0z+zDS2tHU0qfJv976tQ3g8Dk7mpzdrh8DJzRDUzNYRCWFXJLnJRfz88tk6BJFT7PqG8ob/GBg7hBiy1wypxBzcfWwdwiMLHLEOACfyssUlH2E/vke72DGcHdfaxpEJYT+kWyoXWbxwPosXzrd1GCK7u3wA/hjLOmNtNphq2TqaNN079Dv3Dv1u6zAeSxyOfB3fnmqGUzQ3hNg6HCHsiiQ3uciShfNZIsmNSEtEGCzrDe5+jIzrB2TvmTw5ObkBWGFszClTIYY5LpWqxUJkIkluhBBm0Xfgpy5w9xJ0/ZHbeNk6IrtnxIEv4rsSZLgI++baOhwh7IYkN0IIuHEKZj5r7pLqNBuK1rZ1RLnGb6Za7DRWgM1jzE/OhBBPTJIbIXKzOxdh08fwXT2IuA4v/QLlWtk6qlxGMSq+N8RGwMYPbR2MEHYhy2dLKaUcgBDgota6tVLqGWAC4AzsBfppreOVUnmA2UApIBroq7U+nML5SgCLgbzAPuAlrXVsVn8OIeyCyQRXD5mnH5/8Hc7tBDRU6QbNPgbvwraOMFc6qQOgwRDYMQHKtICK7WwdkhA5mjWmgg8GjgDeSikDMA9oqrU+rpQaA7wMzAI+APZrrdsrpcoB3wJNUzjfeGCS1nqxUmo60A+YZoXPkeMtXL7a1iEIW7l+nFlTRtHS4R8KqZsAhJqKs8nUjsFDR0HekjYO8PHk7zza1iFkniYj4NQfsGYwFK4GeQJtHZEQOVaWJjdKqQCgFTAWGAr4ATFa6+OWJpuA9zEnNxWAzwG01keVUoFKqQJa66uJzqeAZ4Aelk3zgNFIcpMh7u7utg5BWNvV/8Hm/4Pj6+np4MhWUzW+NHZhh6ky18kDwKQvjmD++yPnMTi52jqEzOPgBB1nwg/PwIJO0G8juOe1dVRC5EhZPeZmMvAeYLK8DwOclFLBlvedgKKW1weADgBKqdpAcSDgofP5Abe11glzJi8ARVK6sFJqgFIqRCkVciNMBukBzPlhOnN+mG7rMIQ1RN6EtW/DtAbmrqcmH1AvZiqvxg3lZ1Pj+4lNThe+bx3h+9bZOozM41cKui+G2+dhflu4e9nWEQmRI2VZcqOUag1c01rvTdimtdZAN2CSUmo3EA4kJCrjgDxKqf3AIODfRPvunzaFS6W4MIvWeobWOlhrHeyXTyrzAqxeuZzVK5fbOgyRhUqOWMPwke9yc3xl4vfMZU58c6re+ZLADZW4ibetw8t0EUd3EHF0h63DyFzF60G3hZYZbE3h1BZbRyREjpOV3VINgDZKqZaAK+YxNwu01j2BRgBKqeZAGQCt9V2gj2W7As5Y/iUWBvgqpRwtT28CgEtZ+BmEyBlMJjixkbXOI6lgOMc/pnKMiuvNMV3M1pGJDEpYliFBBTWSb2OmUOLHdlC2FdQZAMUbgkP6P7YfPpcQuU2WJTda6/cxj6dBKdUEeFdr3VMplV9rfU0p5QIMxzweB6WULxBpmfnUH9huSXgSn1MrpbZg7s5ajHkw8qqs+gxCZGtaw42TcHQdHFgE14/ihT+DYt9kjake2b26sEhbqA6kRex4jrU4Bv9Mh2PrwMXbPNg4bylw9wMnN1AGMMZBXIR5OnnMPaY6ncGAJgoXwrQ3/+n8hJqKc87WH0oIK7HFwpnDLF1WBmCa1voPy/bywHyllBEIxTwLCgCl1K9Af631JcwJ0WKl1KeYu65mWTV6IawpLsrcLRF10zyOJvKGuYLwrbNwLdRcmwagSDC0/56nF7kRL+vh2o0YnM2zqBoMhuO/wektcOUwHFkNUbdAmx601Y5E4EokrpRT5sVOXVUs/tzBRcUBku6K3MMqPwW11luBrZbXw4BhKbTZBQSlcnzLRK9PA1I+VeQO14/Cj0lrnlzX3lzU+ThhKs9e3ZY/TZW4cCo/nLJRjCLrObmZa98krn9jMlHmg9UoNHE4Ykp1CKWmEDepYDgLfGyFYIWwPWUe42vflFLhwDFbx5FN5MM8dkmYZeT7UVxr7W+NYMA80w8YYHlbltTvXflvaSbfB7Nsdy8LYSu5JbkJ0VoHp9/S/sn3Iqmc/P3IybFnJvk+mMn3QYgHZG0pIYQQQtgVSW6EEEIIYVdyS3Izw9YBZCPyvUgqJ38/cnLsmUm+D2byfRDCIleMuRFCCCFE7pFbntwIIYQQIpeQ5EYIIYQQdkWSGyGEEELYFUluhBBCCGFXJLkRQgghhF2R5EYIIYQQdkWSGyGEEELYFUluhBBCCGFXJLkRQgghhF2R5EYIIYQQdkWSGyGEEELYFUluhBBCCGFXJLkRQgghhF2R5EYIIYQQdkWSGyGEEELYFUluhBBCCGFXJLkRQgghhF2R5EYIIYQQdkWSGyGEEELYFUluhBBCCGFXsiy5UUrNVkpdU0odTrQtr1Jqk1LqhOVrnhSOe1optT/Rv2ilVDvLvrlKqTOJ9lXLqviFEEIIkTMprXXWnFipxsA9YL7WupJl2xfATa31OKXUCCCP1np4GufIC5wEArTWkUqpucBarfXyLAlaCCGEEDlelj250VpvB24+tLktMM/yeh7QLp3TdALWa60jMzk8IYQQQtgpRytfr4DW+jKA1vqyUip/Ou27AV89tG2sUmoUsBkYobWOSelApdQAYACAu4dHzaAyZZ8scjtw9vRpAAJLlrRxJDnLgX/3hWmt/a19XbmH0yf3dMbY6h4GyJcvnw4MDLTFpYUd2rt3b4bu5SzrlgJQSgVi7kZK6Ja6rbX2TbT/ltY62bgby75CwEGgsNY6LtG2K4AzMAM4pbUek14c1WrU1Ju2//OEn0bkVvm9nPZqrYNtGYPcw+JJ2PIeDg4O1iEhIba4tLBDSqkM3cvWni111ZKgJCQq19Jo2wVYmZDYgPlpjzaLAeYAtbM0WiGEEELkONZOblYDL1tevwysSqNtd2BR4g2JEiOFebzO4RSOE6n49OORfPrxSFuHIUSmkXtaCJGSLBtzo5RaBDQB8imlLgAfA+OApUqpfsB5oLOlbTAwUGvd3/I+ECgKbHvotAuVUv6AAvYDA7MqfnsUsvtvW4cgRKaSe1oIkZIsS2601t1T2dU0hbYhQP9E788CRVJo90xmxSeEEEII+yQVioUQQghhVyS5EUIIIbKBJk2a0KRJE1uHYResXedG2FChIsl6+oTI0eSeFvYkICDA1iHYDUlucpFpM+fbOgQhMpXc08KeLFiwwNYh2A3plhJCCCGEXZHkJhf5cPhQPhw+1NZhCJFp5J4W9mTIkCEMGTLE1mHYBemWykUOHzxg6xCEyFRyTwt7sn//fluHYDckuRFCCCGsJHDEuhS3nx3XysqR2DfplhJCCCGEXZHkRgghhBB2RbqlcpFSpYNsHYIQmUruaWFPypQpY+sQ7IYkN7nIxG+m2zoEITKV3NPCnsyYMcPWIdgNSW6EEEKIdMhA4JxFkptc5J1BAwH5a1fYD7mnhT0wYCJwxDpubPgGAL8Wg+7vk+Tp8WRZcqOUmg20Bq5prStZtuUFlgCBwFmgi9b6VgrHGoFDlrfntdZtLNtLAIuBvMA+4CWtdWxWfQZ7c+rkCVuHIESmknta5FQKE10cttHFYSvV1Eku6Xw0vRXOf9rf1qHZhaycLTUXaPHQthHAZq11ELDZ8j4lUVrrapZ/bRJtHw9Mshx/C+iXyTELIYQQ6XIknmaGvXBgCZzbCVpn+NgAdY1lzmMY7/QDbsQyy9iSI7oYhdUNKhjO4U1EFkaeO2TZkxut9XalVOBDm9sCTSyv5wFbgeEZOZ9SSgHPAD0SHT8amPZEgQohhBCPoIHhEGMdZxNouAorLRv9gqDpR1C+DSiV6rFNDPuZ7PQtBjRDYwfys6kRYG4fp09RWl1iiNNc3o57I8s/hz2zdp2bAlrrywCWr/lTaeeqlApRSv2tlGpn2eYH3NZax1veXwCKpHYhpdQAyzlCboSFZVb8QliN3MNCZD+11RFmOU0gHgdeiR0Kb+6FdtPBwRmW9oKfusKts8kPjI+Fzf/HXOcvuKz9aB07lp9NjUlIbABuaG8u6ny0d/iL5w3/WO0z2aPsOqC4mNb6klKqJPCHUuoQcDeFdqk+B9RazwBmAFSrUTPjzwvtWKUqVW0dgngEcg+nT+5pYU1FuM5M54lc0P50jh3FLbwJnHAM8MaBEfRx2MDbx5djOF4Lt1ovQcV24JYHLuyBnd/AzdMsiW/CqPjexOCc7PzO+UsSRiCHTOcZ6bSQTTE1rf8h7YS1k5urSqlCWuvLSqlCwLWUGmmtL1m+nlZKbQWqAysAX6WUo+XpTQBwyUpx24VPx39l6xCEyFRyTwtrGu00H0eM9I57j1t4J9lnxIGZxlasM9ZlqOMyOv+7AEJmPWjgXx5eXMHwWTGpnj9vswEATI7fyyznibQ0/IN5NId4VNbulloNvGx5/TKw6uEGSqk8SikXy+t8QAMgVGutgS1Ap7SOF0IIITJbU8NennXYy5T4DlzQqY2ogMv4MSx+ILxzFF5aCZ1mw5sh8PouCGqWoWv9YarOcVMRBjqufaSByuKBLEtulFKLgF1AWaXUBaVUP2Ac8KxS6gTwrOU9SqlgpdRMy6HlgRCl1AHMycw4rXWoZd9wYKhS6iTmMTiJ0mKRntf69+K1/r1sHYYQmUbuaWEVWvOu4zJOmQoxy/h8xo5xzwulnoFKHSFfUJqDjBOErZlA2JoJaAzMMLamguEcnP3zCYPPnbJytlT3VHY1TaFtCNDf8nonUDmVc54GamdWjLnN5YsXbR2CEJlK7unsSSk1ABgAUKxYMRtHkwlObqa84TzvxA4kPgtHc8SHP5g4sNZYl9GO8/A8tAxKNMqya9orWRVcCCFEptJaz9BaB2utg/397aAo3V+TuaTzstpU32qXjMaFTaaaELrKPNNKPBJJbnKhbVs2M+jVvjRtXI9WzZ9h0pefE343pcloQgiRy105DGd3MCv+eeKsPAdntbE+RN+GU39Y9br2QJKbXCTi3j0O7N9H5zYtWL9uLW7uHty7F864//uYJvVrcejgfluHKIQQ2cv+n8DgxApjY6tf+k9TZfNU8sMrrH7tnC671rkRmSg+Pp7JE8Zx8MC/uLi6MvrLqbRq1xUXV1cA9u3eyfA3+9KhVXN+/X07QWXL2ThiITImuHZdW4cg7JkxDg4ugbLPc/tfryy/nEuRpD9743CEsi3h2K9gMoLBIctjsBeS3Ni5M6dPMaBvLw7s3U3rDt0YMeZLvH18k7SpUbs+c5at56X2zejY5nk2/LGDwkUCbBSxEKnTWnPp4gVOHD/GjbDrlKtQEW9vH44dDaVkqSCcnJxsHaLIwQJHrEvyvplhLzOdw+h3IMgq18/zVO/kG0s3hf0L4dK/EBBslTjsgSQ32dzNGzc4fOgA586cJjIyAmcXF/Lm9aNoseKUDiqLt49Pisddu3aV2d9/x3dfT8LJxYVx38ymZbvOqV4noHgJpv24kj6dWtC1QxvWbNiMb548WfWxhMiw8Lt32bxpA5t++5Wtmzdz/dqVFNu5urpRvnI1GjRoQI3g2lSuWo2ixYpjMKTe+240GomMiCAmJgaDwYC7hweulieaQrR1+Isw7c02k+0qYVdbEMdeF8U3079lcnynJPvOjmtlo6iyP0lusiGtNb/9upap30whZNcOTCZTqm398xcksHQZSgYWx9PLi+ioKP4XGsrBfXswmUy0eKEjQz8aS8FCRXh7wIsATJqxMMVzlatYhYnTf2RQ3y60eb4ZK9asx98/9WJVQmSVyMhIfv/tVxYuWMBf234nNiaGPHn9qNOgCdVr1yOobEX8/P0Z9/F7xMfF0aH7y4Qe/JcD+3Yz/dspxMfFAeDs4kK+/AXx9vHFyckJY7yR6OhI7oWHE373DlGRyVdf9vD0oniJ0tSqXYtmzZ/nmWefkydCuZAzcTQxHGCtsW6WTv9O7PrKzwDwb//B/W238eKALsVThoNMplNqh4qHSHKTzVy9cpn+fXrxz59bKVIskP5vvkut+o0pFlgSd3cP4uLiuHnjOhfPn+XMqeOcPnGMc2dOsm3rFqIiI3BydqZYYCn6vfEOrdp3oWTQgz7cO7dupnv9+k815etZS3j7lR40a1SXH+YuoHZd601/FLmXyWRi55/bmT1rFps3rCEqMgL//AXp3LMfzVu1o0qN2jg4JB1zEBdrniLbqn1XWrXvCkBMdDTHjxzm+NHDnDt9krBrVwm/e4e42FgcHB1wdXPHw8MTL28fPL19cHf3wNnFBZPJRFRkBGHXrnL65DGWLf6JebNmkL9AIV5/6236D3wDZ+fk6wEJ+1TPEIqXimKjyXpdQcaolGetbjNWZbDjz+ThbrJlH0TKJLnJRkL/d4hObZ7nXng4I8dOomOP3jg6Jv9PlC9/AcqUr8TTWRRHgybNmLN8A8Ne703bFs/w2qC3GTp8JJ6enll0RZGbRUZGsujHOXw/7VvOnjqBl7cPz7ftRIs2nahVr1GyhCY9Lq6uVK4eTOXqT/ZLKS42lp3bN/PT7OmMHvke8+fOYu7CJZQrX/GJzityhmcNIURoF3aaHu+/98Pjd57EDlNl3lYrqGM4ygaT1LHNCJkKnk2cPXOaTm2ex2BwYOHqLXTt1T/FxMZaKlatwdINf9KmUw+mTp5AvRqV+HXNKrSscyIySWxsLD9M+4YaFUvz/rtD8PTyYezkGWwOOcHoL6ZSt2GTR05sMpOTszNPNXue739axdS5y7h75zYtnm7I77+tt1lMwjoUJp512Ms2U9UUV++2tkO6JFHamdqGo7YOJceQ5CYbiIqK4sUuHYiLjeX7hasIKlfB1iEB4OnlzScTvmP+yk14+/jSu0cnenTpyPXrKS7mLkSGbVy/jno1KjPyvaGULluB2cvW89OaLbzQsTuubm62Di+Zxk1bsGjtdoqXLM3LPTrx145ttg5JZKHy6jwF1G02G2vYOhTAPCV8nylIkptHIMlNNjB82LucOPo/Pv96FqXKZF2NmToNmlCnQZNHPq5acF0W/7qDIR+MYceWjTSqXY2/d8pibuLR/Xf+HF07tqNnl3Y4OTsx7ceV/LBoDcF1Gz7W+R73nn4cBQoVZsbCVRQtXoKXunbg9MkTVrmusL4GhsOAuTvImlyLV8W1eMozs3abylFBncOLSKvGlFNJcmNju/7cweJ5M3ix3+s0fPrZLL3Wq0OG8+qQ4Y91rJOTE31fe5tFa7fj5eVNh9bN+WXF0kyOUNgrk8nErBnf0bBWVXbt2MKQD8aw7LddNGjSDJWB1ZJT8yT39OPwyZOX7+b/jMHgQJ9ePYiJibHatYX1NDIc4ripCNewbjkM3wbd8W2Q8prTu3U5DEpT03DMqjHlVDKg2Iaio6N5640BFCkWyKD3RqXb/tKF8xw+sI/LF84THRWFwcGAq5s7np5eeHr74OXljbunJ25uHri4uODs4oKDgyMOjg44OTnj6ub+xFNag8pVYOHqLQzu353X+vXC2dmFli+0faJzCvt28cJ/vNq/D7v/2kb9xk0ZNf5rCgfYZqVorTVxsbHExZlnWbm4uj3y2LbCAcUYM+FbhrzSg28mfcm7Iz7MilCFjbgQSy3DMRYZn7F1KEn8aypNrHagtuEYW03VbR1OtifJjQ1N+uIzzp0+yfcLV+Hu7pFqu9BD+xn3fx+yf9eT9/MbDA4UCChGwYBAqlSuTIXK1alSoxaFA4pl+C9ob988fDtvOQN6tGFAnxdZv3kHlavK/2wiuU0bfuX1V3oTFxfHx198Q4duLz/2k5rwu3e4duUyt26EEX73NpGREcycOhGTyUibTj2IjooiKjKCiIh7RNy7x73wu4TdukVk+F0i74UTce8u0ZERyQbFe3r7UiSwFPUbNOLZlu2oVK1murE80+IFWrzQkUlffk6Hzt0oWar0Y30mkf3UMJzATcXyp6mS1a99denHABTo8kmyfdG4cFiXoJaMu8mQVJMbpVRB4GPABIwCBgEdgSPAYK315bROrJSaDbQGrmmtK1m25QWWAIHAWaCL1vrWQ8dVA6YB3oARGKu1XmLZNxd4Crhjad5ba50jV3s8uH8fX3/1BS906k69xqn/hbBo7vd8+cn7ePr40vPNEVRv0ITCxUri6uaOyWQkOiqSyHvh9/9FRd4jOiqSuJgY4mJjMRrjMRrjiYuNZd2i2RiN8ZQsV4nL58/y05zviYs1P1b39fOnTOUa1KpZiwpVq1O1Ru1kyzQk5u7hydezl9ClRUP69OzO1p178PTK+rVXRM6gtWbyhHF8PmYU5SpWYcK0+RQrUSrDx8dER7P3n7/Ys2s7e/bs5uyJUO6mUadpyrjRKKVwcXXD1d0DNw9P3D28cPf0okhgadw9ze/dPDxxdnW7/wQzJjqKm9evcv7Uceb/MJU50yZTtU4jxoyfTIlSZdKMcdjH49i2eQMffjCCn5Ysz/BnE9lbA8Nh4rWBf0zlrX5tHZ92N+c+UxA9HX7HkXirFRbMqdL67swF1gEewBZgIdAKaAtMt3xNy1xgKjA/0bYRwGat9Til1AjL+4c7zCOBXlrrE0qpwsBepdRvWuvblv3DtNY5+idJbGwsr73Sl7x+/gz/eHyq7eZ9/zUTPx1J7aeaM/jTKXj5JO3/dcARJ2eXZNtTs2fbRgCGT/gBgPi4OM6dPMqxAyEcO7iX44f3s2fbRrTWGAwGylSuQaeuPWndoSvuHslr3OT182f81Nn07fw8w98bxrfTpmf0WyDsmNFo5I3XXuXnRfNo1b4ro7+Yen+R1vScOBrKT3OmsWHNz0SE38XB0ZESZSpQ9+nnKVy8JH4FCuObNx8e3t64unkw5aPBKIOB/5uxFGcX1ycavxMRfpdNK39i2cyv6d66CV9MnU3jpi1Sbe9foCB9XhvCdxPHsvvvnVLs0k7UMhzjsC5BBNlv1t6/piD6O66nnDrPYV3S1uFka2klNwW01t8AKKVe11on/Bb+RinVL70Ta623K6UCH9rcFmhieT0P2MpDyY3W+nii15eUUtcAf+A2dmLKxPGcOPo/vp69BG/flBOT5QtnM/HTkTR8rg3vjJuWJfU+HJ2cKFW+MqXKV6Zltz4ARN4L52ToAQ7v2cmuP9bz6QdD+G7yOD4Y8yXNW7VLdo6adRrwUv83mP/DVF56qSd16z/erBdhH+Lj4+nXuxfrVy2j/5vvMui9URlKOE4cDWX82FHs3vobzq5uNHi2NQ2fa0Pl4Pq4ptFl62SpGOzi+uS/iDy8vGnXayANnm3NZ0P6Mrh/d2b8tJpa9RqlekyvAYNYvmA2I0cMY+OWP58ouRK250wc1dQp5hmb2zqUFP1rMnd/Vjec5LBRkpu0pDVbKvG++WnsexQFErqzLF/TXLhIKVUbcAZOJdo8Vil1UCk1SSnlksaxA5RSIUqpkBthYY8ZbuY7cewokyeMo0WbTjR5tmWKbX5fv4pPP3ib4MbNePuzqVYtZObu6UWV2g3p8cZ7fL38D8bNXUUev/y8O/AlvvliTIpF/F5/90MKFCrCe0MHYzQarRarvcuu93BqTCYTr77Sl/WrljHk/U94a/jH6f6yj7gXzvjRw+n8XD0Oh+ykx+vDmLNpH2+P/YZajZ9NM7HJKv6FAvh05nIKFyvBkAE9uXThfKpt3d09GPj2CA7s3c36tautGKXICpXUGVxUHCGmtLskbeUSflzVvlQ3nLR1KNleWk9uVimlPLXW97TW96cDKKVKA8fTOC5TKKUKAT8CL2utE1aOfB+4gjnhmYH5qc+YlI7XWs+wtKFajZrZpqzusHfextXVjeGjU+6O2rJxHcNe702ZyjV474vvcXJ6tOqY4XducfXiee7cCCM6KhKNxsXFFS/fvFSoXgd3r4yvS6KUokKNOny5YB3Tx47gh2++xMXVjQFvDUvSzt3dg3c/+oxhr7/MT/Pn8FKf/o8Us0hZdr2HUzPmo/dZ8//snXd4VMX3xj+zNb0X0kij99BBUbGAAkpTRLCgYEOxICIWbNhRURRRVIqKgGJFBFSkSO+9BgghCQkJ6bvJZsv8/ribTTa7IcEfkPA17/PsQ3Zm7r2zy907Z855z3sWL+CRp17gvrHjaxy/ZcNannvyQbJPp3PjbXcz8tFn8AsIOq9rdrnKvXxCUUEeZzLSyM3OpMRgQNpseHh5ExoRRVRcYo2eHm9fP56f/hVPDrueZ554iK++X1qwu9UOAAAgAElEQVStoTZw2F18/cUMXpj0NNfe0LehqvhljC72NOtttuZ1cn3PxJpKKwh22ZqQJBo0lmpCtcaNlNJtbrKUMhn+dWnSLCFEhJTytN14cSt1K4TwQ+H7vCCl3FTp2uUkZpMQYg4w4V/Oo06wdvXfbFjzF0+/+CbBbqptr1jyI5MeG01ii7a8PHNBrXatZnMZ29b+xaaVv7NjywYKzmScc7zey4c1f/9B9x5X0unKa2nSugMq1bkdcRqtlkdeeheTqZQZ706hQ+dudO15ldOYPgMG8+2cT3n91RcZNHQYvn4Nxd3+S5g3exafTH+f4fc8wAOPTzznWHNZGR9NfZV5n00nonE8b837lZYdutTqOlJKTCVGJSuqqJDm7TqRm5PFD7M/Jv3kMY4cOUx26nFKiqqPYqu1WmJaJnHz0OFcdeMg9J5ebsdFNo7n3qde4pMpE/n+m9kMu8t9NF6r1fLsq+/ywIhb+GjaVJ5+dnKtPksD6h86qw5zzBZBbh0Vp/TvNqTGMTttTeir3UYg7otsNkCBuJi1guycm98qZUtNBc5WIhQHSSknVjlGBywDlkgpP6jSV24YCWAaUCqlnFTTPDp07CT/XLv5gnymfwspJTdedzXpp07y+7o96PTOEbVfF3/Li089TIv2XXjho6/w8fM/5/mKCvJYumA2vy6cS3FuNp6+ASQm9SCqeVuCo2LxCQpF56E8tC1lpRgK8sjPSudMylFOHdzF6eQDSCnxDQ7nmr43c3X/ITRtk3TOMEKp0cCTw/tiKi3ht9XbXEjG+3fvYMTN1/DwuCd5+fXqidKXG8J8tdullJeuNLAb1Id7uDpsXPcPQ2/uQ/de1/LRnO/OGUbNSEvlsfvv5Mi+ndx4292MnvCyW+NCSknaiaNsX/c3R/ftJPnoEQpyMiktKsRmcx/69A4IJrRxAqGNEwmJjicgPAq/kHD0Xj4IlYoyo4G8zDTSDu/h8Ka/yU49jm9wOGPGv8A1A251e+9LKXnxwds5sncHv/y9lUaR0dV+toljR7FyxRL++mczLVtd+jTic6Eu7+HOnTvLbdu21cWlzw82G3mvxPCHtTPPWB6o69lUi+6qAyzUvcaosqeZ+8Z/T2NJCFGre/miGTdCiAUo5OEQIAslrfxn4DugMZAK3CalzBVCdAYeklKOEULcCcwB9lc63Sgp5S4hxN8o5GIB7LIfU1zTXOrDwrD+nzUM7nc9z055lztGPejU98v383nxqYdp1/VKnv9w7jk9NoaiQn79ZhY/zpuJyWigWder6TbwTpp0vhK1+typgV+MHwnAmPfnYyzM58iWNRxYt4Ijm9dgMZcR2jiRgcNHcf3gO9xmRwEc3LWVZ+6+mVEPPc74519z6X9pwliW/LiQfzbvIrFp/Yxbny8ajJvqkZOdzTU9OuHp5cW3v63B9xxG+ZYNa3nywbuwWsyMe/l9ruhzs8sYq8XC2mU/sWjup2QcVR4BAeFRhMU2ISAsEk+/ADy8fdF5eKH38eGfhZ+j1mq5b+pXeHjXXopASsmJ3Vv444uppB3aTdve/Xn+jQ/d3veZaSd5bGhvmrbpwNeLl1Xr6Tybk82Q67sSFh7BX2s3otdXSwm85GgwbmqB7CMwowsTzffznbV3nUwh81tlr95oxFvVjvGmhL36MXxoGcKTr8++VFOrN6itcXPO1VAIoQK6Syk3nO8EpJTuNaThOjdjtwFj7H9/A3xTzTnrl2TkeWDqW28SFBLK4NvvdmpfuexXxbDp1osXps+rlguQkXqCZYvmsvyHbzAZDbS6sg/X3j2ORgn/rhaVl18AHa4fSIfrB1JSXMj+tcvZ9vt3fPHOZL75ZCq33fcog+5+EK3O+QHdskMXrh98B19/MYObh45wKfI5buJL/LH0ZyaMf4Iff62ep9CAyx9SSh4cM4r8/Fw+nrf4nIbNDwvmMuXZJ4iKTeD5D+cRGeua6bF17Z98+s5LZKceJyy2Cf0fmUyrK2/APzSi2vNuW6qUADkfwwYUPllCh248MP07/lk4i7/mTuPJu07w1qyFBIY4h4wbRcfywLOvM/3FJ5nx7mvVqokHh4TyytQZPHbf7Tz15BN8/MnM85pTA+oY6YoBtsPWtI4ncm4Y8CRZRtJOdbyup1KvcU7jRkppE0K8B/S4RPP5n8Te3TvZsHYlj0962ani8f7dO3jmsTE0a9uRFz6c62LYFOadZcNfS1n+208c37kRlVpD22v6ccWt9xHZtPUFm5+njx+d+w2jc79hpB3aw+r5n/D19DdY/vMiXp4+h5gEZw/MqCdeYPPfy3np2SeY/+MKJwMmJCycsU89z9RXJvHbrz9x88CaY8gNuDwx54tP+efvP5j06lRatG5X7bhZH77Dx+9OIalnb555dxZePs6GSE5mBlNfeYaD6/8ktHECI16eQcsrbvhXhnFZaQmnkw+QcXQ/2SeTyctKJzcvH5VaQ6OICKJbtKdFj2sJjooFQKVScfWIh4ho0pIFr47jiZH9mTrnR8IiY5zOe93A4RzcuZXPP5pKXGJTbh7qfu92zQ39GPXQ48z99EN6dOvCyHvuO+/P0IA6QtpWCqUnx2RkXc+kRuy2JdJbvQukhIYNpFvUGJYSQrwC7AF+lBeToHMRUdcu/aED+7Nr+xaWb9jn2N0W5OUyuE9PVCrB1PnLCAwOdYw/tHs7X30xgwPr/sBmtRASk0C7awfQ+aZh+IWEV3udwpxM0g7vJfvkMQqyT1NSVIDFXIZarUHv7cOxHRvQenhyzxtfEhB+7h/wkS1r+HHqJMymEia9+zmdrnR2mq1Y/A0zXp3AS+98xNA7Rjn1WSwWhvfrRXFRIeu37cHb+9Kn815INISlXJF6MoVeXTvQoVM3Pp3/c7V8lU/ee53PPnyb3jffxriX30dTqbaZzWZj+fdfMWfaFGxWK9fc+ShX3HovmhoyBKWUlBQVUJiTxXdvjMdiKiWufVeOH9hLQfoxpNUCgM7bD++waHRevtgsZoxnMzHkKIT7iPZXcttjzxEWW7FLP3VwF/OeHY3ey4epc3+iUXSs03XNZSZeGTuSfds3Mu2zb+jdd4Db+VksFh6951a2bFjD4iUr6HnlVW7HXUo0hKVqgU97sS7dyp3m5+tsCrUJSwHcqf6T17Rz4Im9EFA3ddrqCheMcyOEKEJRKbYCJSh8FymlvGzSYepyYVi18k9uH9SPJ5+fwr0PPQEoD+eH7r2DrWv+4O2vl9C0dQcAzmSc4t1XnuHQxr/x8Pal4423ktRnMI0SWlS7i806cYRdf/3MztUrKM6q0OPQ+QSg9wlApdUirRbKDEWUFlRopfg2iqXD1X1pd+0AIhLdy4wXZJ/mm8kPcebkUSZP/4qOV1TEoW02Gy+MGcqJw/v56a/NLkTLbZvWcd9tNzF+4nNMmuxaJ+VyQoNx4wwpJUNu6c/OrRv5aeUWIqJi3I6b8+kHTHt9MjcMHsEjL73rxFXJOHmcNyaNI3X/dhKSejLoySkERbo+pItyszm+axPph/Zw7PAhDDnplOSewWp2lqnX+wYSENucoLhWBCW0ITC+FZ4BoS6/G8PZ06T88ytH/1yIpdTADfeN58phYxzjMo7uZ87EUWj1et76cjHR8c4hCqOhmBcfGMaxg3uY+slcrr/JvVB7YUE+dw26jtycbFasWk9Ck7oNdTQYNzWgzAhvRvOxeQDvWm6vs2nU1rhpJ47xq34y3DYPWruKq/4vo84JxfUJdbUwGI1GrunZGavFyk8rtzgypJb8sIDnn3iAe554gaH3PQrAplXLef/5x5A2K72GP0iPwXej93Tv8TCVGNi7+nfW/vQtucf3oVJrCGvZhUZtexLcpB1+kfFoPV2JkUf++JaS/Gw8A0LJ3LOerINbkVYLgXEtuXbYvbTt3d9l12wszGfO03eTfeo4b87+iebtOjr6Tp9K4fFbr6V5+87MW7TEhWg5adxo/lr2Cxu276NxbNz/56usUzQYN85Y8vMPjL5rOBNffps7R491O2bZL4t55tF76XXjQJ56a6bj3pBSsnThbOa8PwW1Vke/h58jqc8QJyOk1FDE7pW/snHZz+QcVUrHqXUe+EUl4BMajVdQOB6BoXgFhpF74gA6nwBa9h91Xp+htDCPHV+9Qdq2lTTufhP3vfSu497PPH6Yuc+Mwmaz8vLHX9OivfN/vaGokFfGjuDIvp288cHn9Bt0m9trnEo5zp0Dr8XPP4A/Vm8gMOj8NHwuJBqMmxpwciPMuZExZU/xl63mwqkXC0U7lgLg27H/OcfpMLNXPxr9FWOhz5RLMbV6gwvpuRHASCBeSjlFCBEDREgpt1yYqV581NXC8OCY+/j5u2/4bP4vdO+leD1yzmRxS+/ORMc34c25v6BWq1n5yyKmv/QkkU3bcPvz09zuYM1lJk7s2sy+Nb+zZ80yLKVG/CITiL96EHE9+6P3rV19qcowFeeTumk5x1b9QGH6MbyCG9H33sdJ6jPEyVApzjvLZ4/dRlmJgWnfLnNy1y///is+mTKR5157n+H33O90/szT6dzcqwO9+/Tnq28Xnvf86gsajJsKFBcV0b1jGwKDglmwdC0ajStt7/CBvYwceB1NWrZjyuffOUjphqJCXpnwEIc2/k2zrlczaPzrTmHWwpxMNvwwl01LFmApNeIf3YSYrn1o1K4nAY2bo1LVXqnbWmbCmJuJqSgPhMDTPxSvkAgnI0pKycHfZrPvhxlEtO/FA2/OdMw1Jy2Fr54bTWFOFo+/Mo2r+ztzx4yGYl4bdxf7t2/i1fdmMvC2kW7nsXPrRsYMH0BSlx78/Ntyt9/XpUCDcVMD1k+HPyfTuXQmOZxbhqO+4GfdZDrER8C9S+t6KpcUF9K4mYlSGfxaKWVLIUQg8IeUsnaqW/UAdbEwzP3yMyY+8Sj3j3vaKbvioXuHs3XtX3z4/V9Exzdl48rfeWv8aBKSejDy1U/RVSIV56SlcHjTKnZuWEP2oe1Yy0rReHgT3eU6Eq4aTHCTdudFurSYSgDQ6J2Jy1JKMvduYP/Pn5F7fB8hzTpw53PvEBId7xiTfeo4sx4bhm9QKNMXLHOQQivrgPy6ajvhEc5cnhnvvc5nH7zFH2s20qFjndoH/xoNxk0FXnvpeaa//w5f/7KS9h1d1VSNRgND+1xBSYmBaYv+dHDJzmSc4tkHbudseio3PfQs3Qfd5bh3C3OyWPPtTLb+/h3SaiWmWx+a9hlBUHzrGu/vMkMRhux0DNnp5KcdJf3IQUqzjmPKOw0OYXMFGp9AEq+6haY33IFXYEVGVPLfi9nx1RtEtO/Fg2996vDgGApy+fblRzi5dxvdB93F05Nfd1IMN5UYee3xUezZ/A9vfPgF/QcPczvHX76fz+TxD/HoExN4ccqbtfiWLzwajJsa8N09kL6DuKxzh4MuNmzmUgBU2ppVrl/WzGWU1waYlArnYfhf7riQxs0OKWVHIcROKWWSvW23lLL9BZrrRcelXhj+WLaUu4cP4creN/Dhl4scomZ/L1/CE/eP4K7HnuO2MY+RmnyI8SP6ERbXlNHvfYNW74GUkgPr/uCP+Z9zNnk3AL4RcYS36kZEuysIa9kFdZX0bGNuFtmHd1CYcZzS/ByktKH19ME7JJKAxs0JSmiNRu/JqjcVz0rvZz93O28pJSnrlrB74fvYrFaGv/A+LbpXEImP7dzIvEn30aTTFbwza4HDu3P6VArjhlxDt943MuPzr53OWVxUSL8r2tKuYxcW//zbhfmCLzEajBsFp1JP0qNja/oMGMIbH8xyO+bZiY/z+8I5TPn8e9p1VYqoZp9OY/xdt2AyFjPylU+Ib98NUDKb/lk0i7WLvsBmtRDf6xZa9L8Xn9Aol/NKKTHkZJB34gD5p45SmHGMnJPHMOVUqvskBPqgSDzDE/EIi0MfFInGOwCkxJSXSdHx7RQc2oBK50n3MS8T3aVClaLcwInqdC0PvP4xao1CfLZazKyY9Q4bfpxLdIt2vPLhbEIjKvhlptISXn1kJPt3bOaj2YvodW1ft9/LlGef4PtvvmTRz7/T+zr3JSMuJhqMmxrwQVuITCJuR93xbaD2nBuAwap/mKabCWM3QZh73uT/Ii6Izo0dZiGEGpD2E4eieHIa4AZbN29kzN130KJ1e975ZJ7DsDEUF/Ha5KeJbdqSwfc8jLnMxJTxD6D18GTEyzPQ6j0oys1m7qvjydq3CZ/wGNrf/iTRna/DO9Q1s6nMUMTJjUs5vOpXjOmHlEaVCq13IKjUWEsKsZUpuwCh1uAd3QppPIvOxx8ppdsdsRCC+F63EN6qK+unj2f+5IcZPOENOvYdCkBiUg/6j32BJR+9zMKZ7zLiEUVcOiImjkH3PMx3s6ZxYM9OWrVLcpzTx9ePkfeNZcZ7r7F3zy7atutwQb/vBlw6vPrySwA8Vo3Oy96d2/h94Rz633Gfw7AxFhcx6f7bKS0uZPR73zgkDFL2bmXB6xMw5GQQ060vbYeOxSfMmZhcZizi9O51HNm4iuITOzEXnVU6VCr0QdF4hMRgM5ei0uqJG/IsHqGxqHTV73hDu96C6Ww6KT+8wYYZT5N050SaXj8cgCbX3orNUsaub99l1vOPOgwctUZLv7HPE9umEz++O4lxw27ghWmzadNZUcfQe3jy/PSveO7ewUwYO4r5v/xNk+auC83El95i++Z1PD72ATZs24OP7/np8jTgIsKQA/mp0Hk07KjrydQeu2Wi8kf69v+UcVNb1Ma4mQ78BIQJIV5HqSvVUDzFDTLS07j7jlsJDY9gxrzFeFVSGp457U1yMtN5+p1P0Wi1LJo1jayUI9z12iz8QsLJz8rg0/F3UZJ3hqQ7J5J47W0uHAMpJbkn9rNzybfk7VuFNJvwbNSEyOvH4NukM55hCQi7MSWlxGLIx5hxhOKTeyhK3kaJ3X3/64SBxHW7jujO17l1/XsFN6L3c1+yfvpT/Pjus6g1WtpfdwsAXW8ZQdqRPSyaNY3WnXvSvpuyiA0ZNZalC2bz0YdTmfnlt07nu+PeB5k9cxqzP/uEaTPc7/gbUL9x/FgyS35YwJ2jx7otQWCz2Xjl+acIDAnjzkcrKqK89dJEctJOcO878xyGzcaf5vH7J2/gHRZF72c/J7R5BYHTZrVwevc69v3xA4VHtyCtZjTeAfjEJ+ET2xbv6JZ4hMahsoeHjs5RCnR6RdWu0KE+OIqm900j5fsp7PzmHTz9Qx0enGZ9RgCw69t3mTnxfh54/RN09tIQra+6kbD4Zsx/8WFefPB2nnn3c7r1Vrw0Xt4+TP7oK54c3ofHHxjJ4uXr8KxSUkLv4cErU2dw16Dr+XTGh0yY9N+Tza+3yNip/BvVESiq06mcD07IRqD3V4ybpDvrejr1DueumAhIKecDE4E3gdPAICnldxd7YpcbpJSMvudOSoxGps9e5FQYM+X4Ub758hP6DBlJyw5dOHsmk0WzPqD1VTfSvHtvykpL+GzCPZgKc7n66Zk0vX64k2FjKs7nyIr5LJl0KytfvZv8fasJansdzR+cSYuHPyO81x14RTR1GDageGG0PoH4N+tG1A330+Lhz/CKbokuKApdQCMOL/+Gla/eza8TbuHQsq8wlzhXsdDoPbni8fcJbd6JH955hpS9Wx3nvfnRlwiOiuO9Fx7HVGIEwMvHlz5DR7Jx5e+cyTztdC4//wD6DhjMTz98T1lZ2QX/7htw8fHJdEWjZpRdzqAq/lr2K0f27uCux5518LG2/7OSXX/+xDUjx5LQoTsAq7+dydIZrxHZ8WpuePlbh2FjNZdx9K+F/DJ+AOunj8eQdpCQLrfQbMx02kz4nvjbXiC060C8Ips5DJuqkFJiM5uwlpUgbdU7l1UaHXG3TsY7phWbZk2mKLMitNWszwg6jXqBrL0b+fjxkRTnVcgnhMYk8MAHC2mU2II3n7yPnRvXOPqCwyN48o2POXX8KDPff8Ptddt36sa1fQcw86MPMBqN1c6vAZcY6TsAARGXl1dZooKoJMW4aYALajRuhBBfSykPSSlnSCk/llIeFEJ8XdNx/zUsXvQt2zevZ8KLb5DYzLkkwpuvTkan03PnOGVH+8Psj7BZrfS9XwnrLPjwTYpOp9Dz0amENK2gMpXkZ7Ny+vP8+kRfdi14D5VaR8yAJ2gz4TsaD3wKr8gK5WCLsQBD2iGKju+gJOsENourEaHS6ND5hdDk7rdpO/EHGg96Go13IHsWfcCv4/tz5M8FVOZgaXQeXDHuPbxDo/j6xUcozMkEQOfpxcDxr5Gflc7i2R85xt8weAQ2q5UVS35wuXbvPv0xGorZtmWTS18D6jfy8/L4bsF8+g++nZAwVxFJKSWfTp9KZGwC1wxQ0qKtViszp75McFQsV494GIAD6//kr9nvE9ujHz0eeQetXeoga/9mljw9kJ3fvIPOP4z44a/QZvxCom8ai3dMa0QViQGLsYCCQxs4/fdcSs6kUJx2iF1vDmHXK33Y/Vo/9rw+gF2v9mX3O7ezf87zFKXsdpmzSqsjbtiLCI2WNR8/61SMM/GaIfQc9y4Facl89PBQctJSHH1e/oGMensuoY0TefOp+zl9qqIvqcfVXDdoON988QmnUtxL448cPZaiwgJ+X/Jz7b78Blx8ZOyAkKbgcdlIt1UgqhNk7QdzSV3PpN6hRuMGcNL5t/Nv6k4IoB5CSskH702leau2DBl+j1Nf8uGDbFy5lEH3PExAcCglRgN//LSQdtfeTFBEDGczTpK88jsSe99KeOtujuNObvidpRMHkbv7L4KTbqLF2M9p/uAnhHS5GbWHsihYjAVkrf+OPR/cx963h3Dk80dInvc0hz4Zw+43B7H/y0kUJm91GCxBHfoQ1KEPABpPX4KTbqTZ6A9p/uBMvKJasGv+VFa8MZYyY4VrVuftyxWPvY/FVMK8KROw2XfE8e260uaqm/j561kYigoBiI5vQmzTlqxY7pqa2KGLsnPfvbNhl3G54defFlNaYuT2u8a47d+xZQPJB/Yw6O6HHByznRtWcSblKNfe8zgarY7S4iJ+fP9FAmNb0Pm+F1Gp1I5U7DVTH0al1ZN499s0ve8DAlpe6eSFBDDlZpC5Zj57p9/P3reHcnzBZDLXfoPNJlH7hKFr3AnPtrfg1XE4Xp1G4Nl2IJrQppgzD5I8Zzz7v5yE1eTsLdH5hRLd/zGMaQdJ/tNZqiCq4zX0nvQ5FpORTx+/g6yUo44+D29fRk75FKTknRefctoQ3DXuWYRKxdzPprv9rjp1u4KQsHD+WrGs9v8BDbh4kFLx3ER2rHnsJYBP2+vxaXt97Q+I6gQ2C5x2NeD/66iWcyOEeBZ4DvAUQhSiKBMDlAENxIlK2L9vD0cP7efFtz50EbJbPH82Or0HA+5QasxsXfMnZSUGOt10KwDbli4CIWg1sEIjJnXTcjbPegGf2HY0HjgBfbBz9oilpIgz6xaRtelHsJjQhDbFq+PtaAIbg8YDWZKP+cxhTCmbOfb1JDShTUkY9DjBSTe6nb9XZDMS73yTnC2/kLb8E/544yH6vvA5Wg+FN+AXGU+HO8azfd4bbF/2PV36KxkFvYY/wL61y1j12/cMuGM0AB26X8Xvi+ZiLitDq6sIHwQGhRAQGMSx5KOuE2hAvcaihQuIb9KMlm3du+3nzf0Cb19/ruk/1NG2eME8fIJCaXOVcs9t/nU+pQU5XPnEB6jtYaXkvxaxd/HHBLa9jsa3jHdLBjakHyJl2RzKTm0HpHKvJ92KtlErNEHxiBpSZqWljJIDyzDuXMSBLybQ+oEPnMJagW16k7f7L/b8MIOYbn3wDKgogxKU0Jrez37B6nce4osJ9/DEF0vwDghW+iJiuG7U4yyd8Rp7tqx3cM+CQsPpPeBWfln8LU9Nft2JdwdKLatOXa9g08bzrkXcgIuBwnQwnLHzbeoe52XYAETb5RhObYbG3S/8hC5jVOu5kVK+KaX0BaZKKf2klL72V7CU8tlLOMd6j80b1wPQ82rnG1NKyZ/Ll5DU8xr8ApWH4t6t69F7+RDbWnF+7Vm/itBmSY6HakleNlu+fBXv2LYk3v22k2EjpSRn21L2vT+SrHUL0cd0ImDgVAL6T8Gr3WB0MZ3QRbRGn3AFPt3vI+i2Gfj0fABrcTZHPh/HgW/eoKwg2+1nEEIQ2m0Q8cNexJhxmJXvT3DakSZcM5SQZh1Y/sV7mEoMAEQ1a0N4fHOW//qjY1yT1h0UwcFjR1yu4e3rh8FQ7NLegPqL3LNn2b55PTf0G+Q2w660pITNfy/jihsG4GFfyE2lJRzd+g+te/V1pFRv+n0xoc07ERSvVJEvykxl18Jp+DXrTuyQSS6GjaWkiP1zXuDIrEcwZx3Es/1gAm/7WLnX2w9FG94SofXAVlqIrbSw2vkLjQ6vdgPx7fUoljOHOb1qrnO/EET3exRptbJu9jsux/tFJtDryemYiguYO+Vpp77O/W7H0zeARd/MdmrvddNgykpL2Lhmpds5JTRrwen0U5SWllY77wZcIqTb06Oi6kcwwmoswGosqP0BPqEQlACnLhtN3UuG2oSlnhdC3CmEmAwghIgRQriqd7mBEGK2EOKMEGJfpbYgIcSfQoij9n/dSusKIe6xjzkqhLinUnsnIcReIUSyEGK6+Delgy8wThxLxtPL26XGTnZWJtmn0x1psQCHDh8koklLVGo1NquVwowTBCe2rTjXP79gM5cSO/BpVJqKHaa5OI/9s8Zzasn7aIJiCbjlLXyvfgxNoPu6PqCkgHs0u5bAIdPwaNkX09GV7J8+irL8rGqPCWh5JdF9x1J4ZBPHVlVwZ4QQtB/2BKaiPLYtreCTt+x5HacO7sRYrISyouObAHDyxDGXc1vMZrQarUt7A+ov1v+zGpvNRq/r3Ou3bNu0jhKjgR7X9XO0Hd23C7OplKZdegGK8nBR5kmiOlXUJju+5kektNH4lvEunBpTblOEXWUAACAASURBVAYHPnmYspNb8OpwK4G3fYx30jDU3iEu1y9cNY3CVdNq/Bz6hJ7om1zDmY2LMZ1Nd+4LiiTsimHk7VnJ2eP7XI4NjG1BmyEPc3r3P5w6sNPRrtV70OrKPiRvX+cI1wK07tgNjVbH7h3uF5zwiEiklGSfqf53eLlDCPGAEGKbEGJbdrb7DVW9QMYOUGkgvE1dzwSA7J/fJPvn8xR6jOmmeG7+A6WUzge1MW5mAD2AEfb3xfa22mAuUDUWMglYKaVsCqy0v3eCECIIeAnoBnQFXqpkBM0EHgCa2l/uYy2XEPl5eQQEBrnsbFPtC3x0QkXRPGNBrsO1XVJcgLRZ0ftV1Jw5vmUV3jGtnTw2ZkM+Bz9/AnPWQby7j8av72Q0Qc4Vi21lRix5p7DkpSJtFqc+ldYTn26jUAdEg7WMg589SmnOqWo/T0i3QfgmdmLXwmmUFpx1tAc3aUdo846s/WGew6sT27Yz0mbj6H4l5hvaSNHkyTrtvIBIKSnIyyUgsO7q6zTg/LF543o8PDxp1TbJbf+6VX+g8/CkTZeejrZjB/cAEN1cIcefPqboMJV7bQBObluNb0JHtL7BTueTVguHv3oem6kI/xsn49XhVlRaZ0XtcthKC5GmYmyGsxh3/0Tp0dVY8qq/r707DgeVhmNLPnXpC79yOBrvALZ8+5GbIyHx2ttQ6zzY/fcSp/aYVh0oLS7kTEbFdTVaLTEJTTl+9JDbc/n7K4+y/Py8aud6uUNKOUtK2VlK2Tk0NLTmA+oK6TsgvDXUQhG43iKmGxiyIe9EXc+kXqE2OjfdyhWKAaSUeUII97mYVSClXCuEiKvSPBC4xv73PGA18EyVMX2BP6WUuQBCiD+BG4UQqwE/KeVGe/tXwCDgnOy85KNHGHTTdU5ttwy5lfvufxij0ciIoTe7HDN85N0Mv/MezubkMPouV9XKUWMeZNDQYaSnnWL1yj/Jy8vjvttucvTf/cA4POylFOa+/yrf+ypM/MKcMxTl5pC8fT2NWytx3qN/fEv69lUAGDOOoPHypzh1Pz6NW1Ocup/kr59FlhlRBzbGdGIDphMb8Ol6D5rgOEr2/YZh12KwVHZxC1QhLQm49jHMZ49Rsk9RBrYackGtw1ZSwMFZ42g99jMMaQfI2er8wAaIuH4MR2c/zuZZk7FZzI72koKzGLLTST2wk9jWHck4oux0P5nyNMFhjRxGT2FBvvLZP/2QtSuXYzabKS0tYcXvSzhy+CALf1Tm9N7br/PP6r+drh0YFMyc+Yp36LWXnnfJsIqIimLmF18B8MIz49m3x5lMl9ikKe99pCxgT417yIXn06Zde157+30AHh5zN6fTnQ2xzl2788IrrwNw70j3kvqXGhf7Hn7k/lEu/Q+Pe5KdO3fROD6RB0fc4tL/wGMT+WfNSuKbt+aVsSMc7Rknj6NSq8nNOIlPYDCpBxTX/64F76PWKurapTmn8IxQjP7CY9vJWjsfAHPRWax5aagDohH27BXTqe2OexgAacWSlwFmA3ZtUYw7F1X0q3Wo/SPx7/McKg8/So+upjRZSdtW6XwwndjA4VmP0HTUe6h0HmRv+YX8/WtQaT0oSt7Kny+PRKP3cih5H1r2Fad3/YNQq9m24kcyjx9Gq/fgnje/xDdIWbjfGj8GL5+KYrV5OWcc5OoP33qJ3dsrvDgFdqPGZA9L/Vfu4XoHmw0ydkGbITWPrc+IsSeipG5WQlQNAGrnubnQCsXhUsrTAPZ/w9yMiQIqb8HS7G1R9r+rtrugslvUbDa7G3LBoNFqsVjMVHUK+tu9FJZKxoFKo8FqVtK0tXoPtF6+WM2mioOkRIiK/5aSzGRkmQGVbxhCVyEMZrOUkvv76xi2fQNWM+j9EF6hCK8Q0HljyzlE7g9PYDlbxZoXKtRBsWAt4/DXk7FZrbiDR1AUQW2v48yhbdisFZ4gvbdSVC5lt1IKQO/lAwjMdv0aIQRCCMpMznwCk/293uMy3iFdYlzKe7g6pKYcJ7pxnNu+wsJ8Th0/StPWzpVYzGVlDtIwgLRV4y4Xro8fa6kBVBqEvhoFX6sZS85xMBejCm+P8G4EnsEI/1iEbxR4BIHNijU3BdOxdS6Hq7yV36S5KMelr9yLVNlb6XSsWous8nuR9vpVVYPjKrUaU+m503Nt59DiacDFRdykpfR+fjaYCpi4SUPcpKXETbpMC1CGtgC9H5xqkNmojNrUlhoJ3A50RPG03Aq8IKX8vlYXUDw3v0kp29jf50spAyr150kpA6sc8zSgl1K+Zn8/GTACa4E3pZTX29t7AROllK7b1kq42HV5yotkLtuwj6iYinCR0Wjgqvbx9B9+L/eOVyTrF8x8l4Wfvc+zizfj5RfAx0/eg/FsJje+sRiAnx7rg29CJ2IHKxo4qb+8S+7eNQTdPhOhUXa9NlMxeUsmI4uz0MRdjTrmSoTamctiM+Zg3v8d0piN3/UT0UW1J3/ZKwAE3PQSppRNFK3+gOh+4wjtNsjt5yrJPMahmQ/Q4Y6naNa3ourx0qdvIa5Fa+546WMA3r79CnpcfQOPvvweAMO6JTDsrtFMmFwhZrbsl8U88+i9rNm8k5at6kd8u7b4r9aWstlsRAR4MObRCU7FX8ux6o+lPD56OG/N/YVWHStkDB69ox8anZ77piretX1rl7Hw1cfo8+pCAhor2kw/P9kfr8hmxA9zPu++T59AmksIGPCa2znl/vICtsJT6NqORBUQh2mnQubVJ93nGCPNRswHFmPLO4Zfn+fQRbZ1OkfR2o8oS91O26cXofbwceo7Nv95SrNPMmia60L3z7THKMnLZsLsCi/S9mXf89N7z/HZ0k1ExMQ52t98cjTpKcn8ttq1ptK6VX8y9u4hLP1rLV269XD7OS80GmpLOSNu0lIGqtbxoe4T+pre4rBsXNdTAs6vthRAylv9lT/m3wZ5KfDo1os0s/qD2taW+rcKxbUybKpBlhAiwj7JCOCMmzFpQGWmbDSQYW+PdtNep+iQ1AmVSsWubc6Lj5eXN3FNWnBgR0V7Us/eSJuNI1sVN3nHK6+hMOM4hmzlY+j8wynLz3SMzz+2B014C4dhI6Ukf8VbSMMZtG1HoInr7WLYAKi8QtB1uBfhFUrh39OwGs7i2eIGPFsoRft0sd3QhDUnY/V8pM2998azUSKejZpwdN1yp/aAmKacqpQNpfPwpLSkQkPE5qZ21el0RQU2phovQAPqH4oKC5FS4h/glvPP/t07UKlUJLZ0Nh5MhmK7R0+Bf2gEAMazFcrVXhFNK2qiVYJPSCi2UvfZItbCTGx5yWga90IVEAeAJqoLmqguTuOE1gttm+EIrxAKV32IzeScoefZegDSUkrO9t9druGb0JGyvNMYz2a69BnPZtIoytlRnJ16DI1WR1ikM7HfWFzoUGquinJPrlbbQK6vS7RXHcco9SRLt87/OoFvUj98k/rVPLAq4q+CnCNQWOfLYb1BbcJSAFnAP8AGFN2b/48owK9AefbTPcAvbsasAPoIIQLtROI+wAp7GKtICNHdniV1dzXHX1K0btsebx9ftqxf7dLXt9/NHN6zncy0kwA0a5uEf1gku/9Upt2sm5JBkr5TOTYsrgmllSodWw05qP0aOd6XndyMLTcZTWJf1MEVCsXuILSeaNsMB2ml4O+P0Mf3RB+vED+FEHi2vBGbMZfiVNcMkXL4NeuOIe2gk7Cfd2gUhpzTDn6NSq3BWil0ZbWY0VTJijqTlYmPrx8+Ps475QbUX5jKlHCpTu8+lLhrz26i4hLRV6mjVGYqQedRQQIOjooDcCpzEN+xB2X5WS6ZS56NmmArzsZqzHW5ntWghJJU/hWGhDqsLeqwti5jhVqHtuWtYDZQss+ZU6YJjkfbqDWZ675zUfL2jlE0S3OP73dqt1ktFGWmEhLjzGlIO7yXRoktHPyacuTlnCEqIsJlXgDlIUadXu+2vwGXBkmqZPbKeKyoax58ieDd8iq8W151/gfG24858c+FndBljNqUX5gC7EEpoPme/fVubU4uhFgAbASaCyHShBCjgbeAG4QQR4Eb7O8RQnQWQnwBYCcSTwG22l+vlpOLgYeBL4Bk4Bg1kIkvBbRaLVf27sOqP5ZSlRsxYMhwVCoVy79XXPQqlYobB99O8vZ15GWlExIdh19UooNQ7BediKU4D3NxnlIfx2JCVMoWMez6GeEZjDqqVtn4qDyD0MReje3sIUyntjsWCABddBIIQfHxndUe7xvfHqSN3Eopsp6BYVjLSik1KAaPEMJRy0dKidViQVNlV1qYn+fgIDXgMkM1oeu0E0eJSXA1sC1lZWh0FQu3l18AHn7BFKQnO9oi2ilGdsFRZ2+nXzMlvFV20jWNWqiU/AdpqeCoydICZDWeHpVvBKqwNpQcWIbNZHDq82x7CzZjHrk7Vzi3hyeASkVe6mGndkN2BjZLGWGxTRxtVquF9CN76dDR2XMkpSQ7M51wNwVGAYeX08PDfRZYAy4+dJhpJVLYaWtS8+BLCEthNpbCf5E6H94WPALgxNoLP6nLFLXx3AwDEqWU10gpe9tf19bm5FLKO6SUEVJKrZQyWkr5pZTyrJTyOillU/u/ufax26SUYyodO1tK2cT+mlOpfZuUso2UMlFK+aisiTR0iTBy5Ejy83JZ+5ezrRURFUPPGwawYvHXGO0Cdn2GKPyVHcsVnk3Ha/qSc2QnpqI8AmKUxaIk65idpSjATlqU5lJsBamoQlo6kY5rgjqqK6j1FK39hKK1FVn8QuuByiec0uyT1R7rGaHMJy+lIoSg91FIxcZCJetDSptDq8RqUTw4VfVsSktL8GggE19W8LQvvqVuiLFSSs5kpNGoEs+kHJayUifjBsAvKoHC9Ip6Sz5hMehDGlNweKPTOI/QWNQB0ZiOue5ANcEJoPXGmrXH0VZ28AfKDrrWMnMcE3MlWMsoPfKXU7s2sh2akCakr/rGKRtQpdXhEdKY9EN7ncYXZylep5DoeEfbmRNHMJeW0Lydc/i/IDeHEkMxMbHxuIOhWHkO+PhWQ5puwEVHS3ESvbCwq54ZNzm/vUfOb++d/4EqFcT3ghNrGvRu7KjNCrkPCKhx1H8c197Ql4ioGObPnunS9+DYxzEUFfL3r0q6amhENAlJPdj1589IKWnevTdS2sjavxn/aCU9tjQrReGtqDVKNhRgLcoCaUPlG3lecxMaD1QhLcFshCo5XSqvQIrPuqM9KdB4+qDxDaYoq8IA0noqoSVTJbXhco6NtJ9fqJw5Nxq1BovFWX+nAfUb3j4+qFQqiotcFYCLCguwmMsICHbVMDGbSp3CUgBxiU0oPpPm3Na1N8Upu7GWOt9HET0HY8k5hvmMs/dEaHSoQ1piyzmAzeg+o6kqVL4RqAISMO5d6qT/JITAq8NQbIYccnc5e2+8olpgSD/opNBtKlIMee/ACl2e8npTCS2cyu+RcVIx4hrHJ7qdU0Ge4oQOqIbL1ICLjySV4kXcZXP/f3RZIv5qKDjVoHdjR22MmzeBnUKIFUKIX8tfF3tilxs0Gg0PPTKObZvWsWenM2O9fceuNGuTxNIFcxwPzP6DbiMvM43TyQeIatYWracPZw5tx8MvELWXH6VnlUx4ofXCZlbc2LYSRTum2jTZc0Ad0gKQSLNzirZK54UsO3fKqj4gnJy0isx8rZ0sWuowboQjrVWlUuLXVQ0Zb19figrPQ1a8AXUOlUqFf2AQuWdd3eTlXkhPL2cOlc1mw1JmQlOlnIJ/WCRlhgIsZRX3X0TbnmCzUnzS2UsS1KEvQu+LcfePVIV/r9Gg0mE++IOLWGV1UMf0hLJCTMfXO7VrozqgCW1K+sp52MwV3BufmNZYjYUUZlR4msrlENSVVMPzMhVjrVG0s6BmeaXwxnHuNUeyz2Ti5x+ITlcrubAGXAR0UCVzWgaRSXDNgy8XJNoDKkf+qNt51BPUxriZB7yNwo15r9KrAVVw16gx+PoHMOcTVzn4e8Y8THpKMnu3Kg/YLlfdgBCCw5tXo1KrCUpoTd4JhcSoD4pyEC1VHr5Ie7aHtHtwELXRXnSGyl9JdZRlxiodapDus6XKofEJxlJcsVPWeNprCBmVeam1Wix2rpFarUbn4elY/MoRHhFFbk52Qz2dywxh4RGcyTrt0l5upFctnVBmD2HpqoQgPf2UUKbZUEFMD0poAyo1hlPO5F213pOIq4ZjTt9NWYaz4aPyCsS310PIojQsR2unS6IKaorwicCwbWHFbwi79yZpGDZjLmd3VGRO+SYqdYZO76kwhrT2e760uMJALysxoNHq0FYJwWWlpyKEIDLKfXrx6fRUIqOrL5vSgIuPJJH8v+W1AQhOhJBmcGR5zWP/A6iNcZMjpZwupVwlpVxT/rroM7sM4ePry+j7H+LvFb9x8kSyU9/1/Qai9/Bkw1/KA9k/KISw2Kak7lfUWxOat6Ao8yRSSoIjozEXKqEioffFVmon7toJlTUZI+4gdD4gVEirqUqHqsYYrcbLD4uxIjSh9Sj33Cjz0nv6kJ1f8dAPCAomp0rdnDh7CYrko86hhgbUb8TFxpKZnubS7uGphJ1MJc7Gcpk9w6oq50alVu5dWyVvi0bviUdIY0qyXN3ood2GoPIJw7BlnouHRh/XHc92g7Ce3o401ewNFEKgSbgBWZpHyQHn9G9tRBs04S3IWPUNNruYpi4gHM+IJiSvrwhX+YQpxkjOqYq5anR6LOYyFzG+3Ows/AKD0VbjmTmRfJTmzZvXOO8GXCQUZxOrOlPv+DYXBM1uhJR1cI5isv8V1Ma42S6EeFMI0UMI0bH8ddFndpli9EOPoFar+b5KpWBPTy/adO7B/m0VBMpWbdpx5qRiBAWERWExlWA2FuHhH4K5WAlB+QSHIO03arlCsbT8S++HRxCoqpJ6KwjL1UHj6efEi9D5KLL4JUXKHL38AjAWVNTJCY+K5WgVufjmduG+vbuqz8xqQP1DTGws6adOUpW37+sXgEqlojDfmftSrnitUmmqtFvctgfHxFGW5+oZUml1xN0yDmt+mksqN4BX0jBUoW2gNA9VYFyNn0Md1ARVcAuMO7/HWlhxPSEE3km3YyvJI3tLhapEYJveGNMOUpSpcM38IhNQa/Wc3L/dMcYnUCnkmXvGWROnuCAPv2oyA4uLCklLPUGLVq3d9jfgEuCUkqG3zXZuKY26gF/Xwfh1HfzvT9D8JrCZ4djfNY/9H0dtjJskoDvwBueZCv5fRHh4I6667kaW//qDy4LQuXNXUo8ddpQmCI2IpjAnE5vNhrf9YWgqykPnE4DNZMBmMaPxCsBmN25UngqvW5r+nVWu8mkEVXbBQqWukbug0nsirRas5bonXn4IlRpDvkKM9AsJpyC7YsGIa9qS1ORDWCtJ1ccmNMXXP8ClTlQD6jdi4+IxFBeRl+tcrkCj0RAUFkFWunOhSpVKhRACq9VZEsFsD1epq2jmeAaEYi521bQB8G/eE11sN4y7fnAySACEUBHYZwLCOxxr+tZaGfzaZgNApSV/5QeOsgkA2kYt0Ua04fTahdjsnKCg9jeASsXx1QrvR63TE9I8ib3rVzl+16GNlbBG6jFnb2SJ0YhHFe2fchzcp9SQat+hYX9YZzi1CZPUsE+6z2arS3g16YZXk241D7SjvGxE+StxZg550gcO17lCSp2jNgrFvd28apUK/l/FTf1u4kxmBqkpx5zao2NikVJy1r7T8/b1Q9psmEuN6D2UmL6l1Ogg7NpMRjQ+gUhTMdJmQeUdAkKNNP4LHQRQjq1iGAmNh5NuiDuUS9SXC/kJlQqPgBAKc5TPERQZS2lxIYV5yi6+adskSkuMJB8+4DiHSqWifceurF/vWu+nAfUX8QmK6768wn1lNIpu7BCnLIdO76FoHZmdxfFMJYrOjEbvnEWl9fLDWmpw2QiUo9mt4xFqLcWb57n0Ca0H3l3uALMBy6kNNX4WofdDk9gHWXASU7KzHohX+6HI0gJytimlFbS+wQS0uJLkNT9jMSmGWXSnaynOSiXzuCKLENlE8b4c2efsjbTZrKjV7nlxe3cpZQiSOnVx29+AS4DUzeyVCZiof4Ru89k0zGddw8C1hRU1f1g7w+Hfwfzf5jfWSixFCNFfCDFRCPFi+etiT+xyRtt2HQA4kXzEqd3PX/G8GO2ptWq7FozVYkFtF72zWS2OBcBmLrUX85PYSgoQKhXCJxxpqD51+1ywFZwEm9k5JVbvjTQZHCJ87qDxUsJQZfZQGYB3cARpqcquveoOtmUH5cG9c4uzhkm7jl04kXyE4qIiGnB5ILGJwpU66ca4admiJaeOHXEyTPSeXqg1WkqqpI/bLBaEUDm4N+XQenqBtDk8JlWh9Quh0VUjMKfvwpLrqsdUenAFaDywZe93c7Qr1I2SEH6NKd7yFbZK5Hpto5ZoG7VWvDd2wyy0+xCsJUWkrFcMnqhO1yHUGnavVJJFPXx8CYttwratzkKEKpW62qKY+3fvIKpxHMEhIbWabwMuMMylcHpXvQxJAZxd8TFnV3z8/zrHElsPMBVC8p8XaFaXJ2qjUPwpSuHMcYAAbgNiz3nQfxxh4Uq5BJcUWrsWjK1clK+8orBKhfLVKm1aD8WlbS0rQeuv6IjYipWwgD6yNbbCU05ZH7WGXfivcsaUyisQpBWLIb+6o9D4KCGzkvyK0IR3aBTFZxTjplGCQo48fkhZYMIiYwgJj2THFufddIvW7ZBScvBA9eUeGlC/0DguHo1Gw8njyS59TZu3xlBUQE5WRT0bIQQ+gSEUVtFOEio1UtqwValjVq6ZVJnTVRUhnQeASu2Syl0OlYcf0phdq9CUECq0TfuB2UjpIeeHv2e7QdhK8sjbowj+eTdug2dkMw4sm4+UEg+/QBq16c6Olb85DLrGrTuRun+HkzGj1ekwl7n3hh7at4eOHTvVOM8GXCSc3gXWMrbXU+PmQmCjrRV4hcC+6sUt/wuojeemp5TybiBPSvkK0APnopYNqIJyjRe1yrlmidGguOY9veyp1Pa0aK3eo8LQESo09hCVzWREH6gI9pVzDnSxXcBahi3X2StUGwg3xo3aVzHETOdwher8FAOrJK8iA8onvDEluVmYTaX4BofhExjCcbuqqxCC5u07sWO7s4R+rF3U7MRxVy9AA+ontFot0bHxpBw/6tLXvLVS0+nEIWevSWBENLkZqU5tPnbxu7Ji5+wmDz+l3WLIozpovPxQBzbGkpvifkB5WQaz0X1/1eG+kagC4jHuX+bkddJGtEEdGEv62u+Q9uKvoV0HUpqdSvYhhUgc0+UGjGczST+s3OuNWydRaigi7UTF9+Ph6UWJ0bncA4C5rIz0Uyk0bdaQKVVnSFU4f//Lxo0VNV8VJlGybymtJy124uT8l1Ab46Z8O2QUQkQCZqD+MbHqEc5k2bkoIc7qreWeHD/7g77EWIxao0WjrRT7FQKdlyLSZyktUowbtRZLnrJYaBu1Br0f1ox/Udq+XEW4ktdHExwHgCHtYLWHKaExKMmr8ET5hCqVdPOz0hFC0CihhZNHJr55G85knMJQXBGCCglTDKmzOf+SM9SAOkHj+ES3npvmrdoihHAYteVo2aIVZ1Kcw1X+ocr/fXGWMwHZ234fmXLPXc1YqHXVSyCUi2Gfh+y8KrwdmPKx5lcY9Uox2b5Y809hTFP4YoFteqPSe5GyXsnYiujQC4TgyFZFDSOqeTsAjh2s+A68fHwxFruS/vPzcrHZbDSKPD+F8QZcQJxcDyHNyMWvrmdyUfGLtSeeoowbVf9infgfQW2MmyVCiABgKrADSAEWXMxJXe44dlTxqsRUUSjNzjqNRqvD11+RXS8xFKOzZ1WUly/AZkPvp4SBLMV5CLUaTVAclhxlcREqNV6t+2HLO46t6HzL29uvUcm4UXkGoPJrRPbBbdUepdLqUXt4U1pYkdXiFRwO4MiSCotrSnbqMceCFhWrfPa01JSKY7yVEITB4LqrbUD9RcvmzTiVctyFR+Ll7UN0fBOS9+92ak9s2Y5SQxFn01McbZFNFfLt2eQ9TmN9G8WCSk1JpqvxVA4pJbaiM6g8qylXUO71VGvd97uByk9xPlfl8ejje4JaS94+xXhRafUEtLiCU9tXI2029D4BBDZuzj47nywkJh61VkvKkQryvK9/IMWFBS7fl9Eueull99w24BLDZlU8N7FX1PVMLjq2y2acsIVzq/q/W0jznMaNUOIYK6WU+VLKH1C4Ni2klA2E4nNg755deHp50zjOWQEz63QGIeERDkOmzFSK1p4aq7Z7b6zmMjyDwkEIyvKVMFBw885Yso85CJAeLfqA1hvz0aVOKa01QRVq19YQznWfdI3aYMk6iLRWnxKu9vDBXFJZ68ZuoNlLKgSER2IpM1Fk17vxD1K8PXm5FToo5UU11WrncF0D6jcSmjSltLSEM5muxnT7pM4c2bfTyUvTqqNSsf7E7oqwpF9II/wiE8jY7VwQU63T4xXRBENq9YRgU84pbCV5aMNbuPR5tR+CtlEr+8n0Lv3VQtjvwarSCFoPtOEtyD1UMXffxE5YS4ocVc0D41uTd/IQUkrUag1BEY0dJRdA8czarFYKC5xDbVr7b9xc5pxJ1oBLhMw9CtE27sq6nkm18O85HP+ewy/AmQSLrVfTQ32AaPHvElAud5zTuJHKyvlepfcmKWVDgaAasGXLFlq17YCqijR9WkY6gaHhjvfSZkPYeTmedmG8MmMhao0WXWAEpWdSAPBv0ROklbKTygNXpfPCp9vdyMJTWDO2U1sIDyVbq1wMsBzayDZIcwnGjOp5POUcBMe5qpCjdeUlGeyKtY6q5ZUWvYJ8u+ET0FCH9XJCs+YtATh25JBLX7sOnck/m82ZjIpwU1RcE/xDIziyebXT2M7XDyD70DYM2c5GUkz77hjSDmA1ua9xVnBYIaZrozq49Oki26L2i1DeVDHatXBHzQAAIABJREFUzwVbrsKR0YS4SvBrguKxFmYg7eRnz0ZKOnxhuqJO7BveGLOxyKHQ7R8aQVolFefAkDAAzmY7h1+D7EVGs7KcRf8acImQYiek12PPjWdcBzzjXO/zf4Mfrb2wSfGf9d7UJiz1hxBiqBDn8eSoAUKIx4UQ+4QQ+4UQT7jpf1oIscv+2ieEsAohgux9KUKIvfa+6mMpdQSz2cyh/Xto3d5VpKuoIN8RkgIlFbxcD8Q3WHkgluQqVrZXoyYY0pXFxCu6JSrfcEzHKm5SfeJVqAISsBxbjq2WqeG2QoW3Uy4GWI7ynW/xyT0ux4Bi2FhLix2ZLYDDi6O3h9VsFiXUVZ7qa7Q/+D29KgypzAxlAYiIiKrVfBtQP9DSri59+OBel772nRXBsYO7KmL7QgiuvP4mjm77h9JKnKuOfYcihIrklYuczhHR9gqk1ULRMfc/5+z9m1AHNkbt45o+bTmbgjQrRpE01U5iwFacieXE3wjfaDSBrrkRKk9/sFkdxpa2nFBfoBgrej/lN1yuyu0dEOQQtAQIClV+y9lVanJ5eHoSHhHFkUPV89sacBFxcj0EJUC5MVwPUZZ1nLKs4zUPrAVOE8w6WxtuVa9FUHsP//8KamPcjAe+B0xCiEIhRJEQ4l8XrhBCtAHuB7oC7YEBQoimlcdIKadKKTtIKTsAzwJrpJSVZUx72/s7/9t5XCwcPXKIMpOJVm2TXPrMJhP6SgUFff0DKClWYvM+gSFoPX0oPK3sDv+PvfMMi+roAvA7u3Skd1RE7F1REXvv3dh7jBpNjBpjTDRGExNbEmvsxl5jN/beS+y9YldEEFDpsLvz/biIINi+KAt43+fxYb1zd+7Z2dl7z5w5JbevPwlPg4kNvY8QAje/hiQEXUL/VFn1CiGwqzMQtGYkXFz+VmGwhuALoDFFmLxU98fCFk02V6IDU0fEgOL7Y4iLTnL+BIh8pChKDh5KccCnIUEIjQZ7R+UB9CgxuZtnsorJN64pN3U1WiRz4ejkhGfOXFw4k9pKmL9QUaxtbDl3LGVyxqoNPkEXH8f5fS9qOdm7eZLDrzY39q4hPurFLcQ5f0m0ljZJFpqX0T2+ialLvjTbIo8tIP7+GQD0j8689nPIhBh0t/cSf+ov0JphX/f7NM97vv2rMVV+Jy/84Z4XC1Wsrc9LSpiaWyYVDAVwTHSefpTWNl5pPw4e2P/KpIUqHwiDXlFuMrDVBiBs1yzCds16b/2t1Fclh3hMec2lN5+cxXibDMU2UkqNlNJMSmmb+P//4mpeCDgqpYyWUuqAfcDrimm0IxM5MN+9fRt4EfacHDNLS+JiXtwE3XN4o09I4GlwIEIIHHIXTnK49CxZBYCnlxQfBSff+orj5eUXFV+1Vo7Y1hiAjAkj/tyi1yo4+sdXQB+n5LVJA62tW6pIludEJUaOOOZ+UQ8n5OopTC2z4ZxTCZx7cPU8rrnyoTVRLDcBl85h5+iMs+uLbbhzp49jY2ePT960H1QqGZcKFSty8t9DqZxktVotJctX5eSBXSnaChT3xd2nIEfXLkzxIG/S7Ut0sVFc27406ZhGa4Jtfn+eXj2Syu9LSomMj0JY2r1SNmFijsa1OPo7+0i4tQtDTBhSGpR/sU/Qh1wi4ep64o6OR3d7NxrHPDg0HZ2mJQhAF3INrX1ONIlJNp+Xh7CwUxz9ExIzdVtY27yQIdkWtGPi1vPj4NTbTxWq1iQ4KJCLF9K2kqp8IILOQexTyF3F2JKkK9sNZXgqrWit3WtsUdKdt81Q7CCE8BNCVHn+7z9c8wJQRQjhJISwAhrwirw5ie31gOTZiCTKVtlJIUTP/yDHB+FJkl9JaiXCycWN4Icv9uZ9CirKwr3LyoqzuH8lnty9SnTYI6ydPbHOWZiwszuQUmKazRHzPJWJvb43qdYUgJlHEWyq9UdGPCD+xAz0j68k+QoASH08ursHSbj4N2hM0VilXdBPmFq+sgzD0yuH0Zhb4eCt+F4YdAk8OL0PtyLl0GpNiIuJ4vb545TxV1ZFBoOBs0cPULhUuaRVr5SSw/t341u2fCpfJJWMT9XqtQgPfczl86mtI40bNyf8cTAXT77ISC2EoHXXz3l0+xrXju1LOu6RpxDZfatzfceypHIeAIWr1EMfE0HErTSsLybmKXIzpYVD3UFonAujv7OP+H8nErfvZ+Xf0fEkXFyO/tF5NM4FsW88BsdGw9FaO6XZjy70FgkPL+Bc7IXTaXTi9rBtdmXBEhl8H42JGVb2ifXgYiIxs3hRVsLCyhoLSyvC0kh5ULVmfYQQbNn4z2s/j8r74Xl+l9FTZwJQdmnCR5XvJQ4z1ukrUl9zHFtenSgzK/I2GYq7A/uBbcDPiX9/+n8vKKW8DIwFdgBbgbPAq8J0GgOHXtqSqiil9AXqA1++StESQvQUQpwQQpwIffw4rVM+CM8f3Lo0Io9KlijFvZvXiEpMTe9TqDiWNnZcOaJUcC1apR4Ad48q1plCtVoSG3KHqDuKr4NP3c6gjyfm8rYU/Zrn8sOu7lAQGhIuLCXu0Bjijk8h7t9JxB0Yhe7mdjQOPpg4536l06Uh9hnCLHWIqj4uhieXD+BVtmZSRNeD0/uIexZG1cYtAbh0YDu6+Dgq1m4MwNVzJwkNfkjDRk2S+gm4epnAe3do1LjR2wyjCsabw2lRq47yUN67Y3Oqtup1G2JpnY0da1MaWKs1bIm9ew52L/wzhfWmaY9+JERHcGP3yqRj7sUqoDG3IvzCnhR9CCEwcfAiIejSa7dyhNYEx0bDcGgxEWv/bliWaI5l8WZY+3+GXYNfcOowB8f6g5PyOqWFPiqMZ3snISzscK3YJun4k0v7MbG2xz6nkvgt9MY57L3yJ9WPiggNxsbRNUVf2ewckhzok+Pk4krJMv78s27tK+VQef9U1FzgqiEHIXx8wQwr9NUwFwk01n5cRYvfZgndDygL3JFSVkepEv6fsrBJKedIKX2llFWAMCBtZw9oy0tbUlLKwMS/wcBaFN+dtK4xS0pZRkpZJj3ruGTPoRihHt5PvcVTtXZ99DodR3YpKwetVkvVek25dHA7MRFPcc6RG5cCvtzYvRKDXoeXf120VrYEH1YeAhYuuTDLWZrYK9tS1MUBxSnYseVEbKr1xyJvZUydcmHqmgfL4k2wa/Azjk1+eRH++hKG+Gh0IQE45i2Rqi3s7A4McdH4VGsBKBaYKxvnks0tJwX8qysWmdXzcM2VlyKl/QHYunIhltbZqFmvcVI/u7b+gxCCeg0ap7qGStoYaw6nhZOzM2UrVGHzupWplAxLSyuat+7Iwa3rk4rCApiYmtL5i294cPUclw5uTzruma8IbkX9ub59WVKlea2ZOV5+tXhycV+qqCnPSs3Rh98l/tabi2Nqbd2xLFgH61KtsfZtg2XB2pi65nttDhxp0BN38zBPNgxGxjwhX4cRmFgqW07RQTd4euUw+Wq0RGg0xISHEHrjPCUrK7WDDQYDQTevUqhQ4RR9mpqZkZCQdomUqrXrc/XSeQIf/P8FElXeHnPi8dNc4ZChqLFFMQoXpTeXDTk/uqipt8pQLKWMBRBCmEsprwD/ySNUCOGa+NcLaEEaPjVCCDugKrA+2TFrIYTN89dAHZRtrgxD4SLF0Gq1nPw3dR2c4qXKkjNPftYumJ7kn1C/TVd08XEcWbcQgDrtexD1OJC7R7ZgYm5JgdpteXr1MDFBSsmC3A26I+Miibm4MVX/QmuCubc/2cp3x7bGN9hWH4C1b1tMXZWvy7p0W6xLp86hEH1mFRj0OBRPWexd6vUEH1mJlWcBnPIomVgfnNhN+J0r1On8JRqtlsuHd/LwxmXafvYlQggeBwVyYMs6mrXqgHU25QFhMBj4Z+VSSperiJt7xo1UUHk9nbt05d6dmxw9sCdVW8fPvsAgDaye+2eK49UbtcLFy4ed88ajT2bNbNDlC2KfhXL78It57FO1OYb4GMJOb03Rh2PxWpg45yHi0Ezi76eswP2qOf0mDHGRxD84S+SxhYSv+oqI/ZPRWNpToOcUrHMq28UGXTx31/6GibU9+et2AOD6jmUIBCVqKFbJB1fOEhv5LKlY7HMS4uMxNU1boapYtRYAhw7sS7Nd5f3iq7mOhUjgkKHIm082MvZVumBfpct77lWwSl+FUpoACLn6nvvOuLyNcnM/MUPxOmCHEGI98K6pcV9mtRDiErAB+FJKGS6E6CWE6JXsnObAdill8nS2bsBBIcRZ4BiwSUqZ8k5oZBwcHfEtV5FN61akWrkJIejz9WDu3bjGng0rAMidvzAFy9fk8Kp5RIaHUrBCTRxyFeTC2hno4mPJV7sdGnMrHu5dBICVZ37MvP2JubgJfdS7bVWYuhZIUnRAybMTfXYNsZe2YFGgJlYeKR19Q09vJT4skFKf9EQIgT4hnnOrJmPr6UPJWs3Q6xLYMecPnHP6UL1RKwBWzZmMQRro3POrpH4O79vF/bu36Na9xzvJq5KxaNqiFU4uriycnbpqcY5cuanVtC1bVy4i6P6LrL9aExO6fz2UkLs3Ob1tTdJxn5L+OHgX4trWxUnFNJ3zlsDaqyiPDv2dokq40Ggp+OkYtHaePNs5lme7xxEfeB5p0Kea0y8jDXp0TwOJu32UqNMreLbrd8JW9iFsWXee7RhN7JUdaB1zkbvdCIr1nY2lm+Igb0iI59bfPxETFIB/9+GYZ7MjIugu13cuJ2e5OjhlV6IAT21fg9bUlLJV6yRdMyEhniehISmc6ZOTt0BhLCytOHfm1NsMu8p/pKLmAjqp4V9DIWOL8kYschTCIsf7l3O9vhI6qYEzS9573xmVt4mWap6Yofgn4EdgDtDsv1xUSllZSllYSllCSrkr8dgMKeWMZOfMl1K2fel9NxPfU0JKWURKOfK/yPGh6Nvvax7cvc36FYtStdVt3IKCJcowb/wIniTWmvrqu+HEx8awfc4fCCFo/tUPRIc+5NrWxZhns6NgvY48vXyAqPuKY2PeZoriELHvz3eqDp4QfJX4R1fRPwsi5sp2nm4aSvTpFZj7VKBAy69TnKuLieDh7rlYexXF07caANe2LSHy0T2a9x2KRqvl6LrFhNy9Se9BP6E1MSHwzk22rV5My/afkj3nixDwxX9NxcXVnSbNW77TOKpkLMzNzenZuw+H9u7g6qXUOW++/X4YGq2WBRN/TXHcv0Z9chYqya4Fk5NCpoUQ1OnYi4igOzw4+cIS5NehPwnPQni4L+VvxzSbI0V6T8G9akcSHl3m2faRhC3rTvg/3/N0xxgijy0k6sRSIo8tJOLQDJ7uGEP4uoGELu7Ck7UDiNg7kZhza9E/C8I2dzE8anUnT+ffKD54LUV7/IF9wYpJId5xoQ8IWPANz64fo3SXIXiWqoo+Po5/Zw1FY2JK2/4/APDkUSCntq2mVJ0WZLN9Ec11/cIZdAnxFCmRdvVvrVaLq5sHj4LUZH7pQRXNOU7JfERi9eaTjUzs/cvEvqbO3//LY+zYaygB51YoYfEfAa9UboQQFkKI/kKIKUKIz4UQJlLKfVLKf6SUav7w11CnfkN8/SowfuSPKWorgeJwPPKPqURHRjLtl0FIKcnpk59mnT/n1NZV3Dh9BJ+S/uQoU4vLG+YQGXyPAvU6YWJtz4Nt05FSYu7gjnezgeiCrxKxdyKG2LSTlxkSYkgICSA2YB9RJ5bwbOdvPNs6gvA1/Yk6OhepjydXi+8p1PlnNGYv8u9IKbn3z3h0Mc+o8NkQhBBEhQRy6Z/ZZPetTr4ylYkIDWb3wknkK1uFMlVqAzBv/AjMzMzp1f9F/pBL505zeP8uevbug5mZWSoZVTIXn3bvRTYbW2ZMHJOqzc3Dk8+++JpD2zdw/viLbVkhBF8M+omI0EccWbsw6XiRynWxcffm4toZSdYblwK+OJVuSPDB5YRfTLltozWzxKPGpxT/dgXerYfhWLwG+ohHJDy8QOy1XcRc2kLstV0kPDiLIfYp2dy9cC3fAq/mgyjw+XRK/LCJ4gMWkrvVUNwrt8M2T2m0Zi+inBIiwniwfRaXp3UnNuQO5XuPIU/1luh1CRyeOoiwmxdoOXAUts7uGAwG1o4bjFZryud9vkkh5/bVizG3sKRchVcHlRoMBjVqMB1w5BlFxW3264sbW5S34sn+BTzZv+CD9L1aXwUiHsLNvR+k/4yGyWvaFqBUAD+AEplUGMW5WOUNCCGYNXcB1SuU4atPWzF/1TbsHF6EYOcrWJivBv3IhJE/sm3VIuq16ky7Xt+wb/tG1v4xmD4zN9B+4HDGd63LqYVjqPzNFEq06sPJ+b8Sfm4njiVq41CsBrqop9zfOo3wNf0x9SiKNpszUhePPjIY/ZMHGJJvW2lMQaPBxMoW96odsfEphbmzV4qSCqAoNg93zuHJpf0Ub90Ph1wFkVJyYv4vCI2Gdt/8BMCmaSPRJyTwzfCxCCE4fWQf/+7ZSt/vhqcwx8+YOAYbWzs+7dELlcyPvYMDvfr044/Rv3Dl4jkKFkn50Pi0V39WL1/IrNE/MHHFzqS8R0VK+1OwfA32L5tB6XotyebghEarpVHPb1g24itu7FpJvtqKobZarx/Z8vNNbq8aiT4mEucyDVNcQ2NqjkORqjgUqUpcqOKUm+/T8e/8WaTBQOzju0TeOsPTa0eJuHkSpMSheC0qdv0GKwdXYsJDODL9Ox5fO0OTfj9TpEo9pJRsnTmGG6cO88WPv+GW3Supz4BLZ9m7aTVtO/fANo10EADR0VE8CnqAZ/Yc7yyzyrtRSXMejZDsN2QO5eZDssvgCxZ2cHY55K1pbHE+OK9bOhSWUnaUUs4EWgKV00mmLIFXLm8WLl/N3ds3+aLLJ0Q8S1mSq0vPvpSqUJ3ZY3/k1rVLmFta8d2YqTwNecimab9g6+xO3c++IejCEe4e2UzuKk2xylGI+1umkhChFKN08W9Owd4zsS9UAV3oTWKu7iTu9hEMMU+x8ymOR41u5G77M4W+mk/JoZvIlqMgFi5euJRrhoVLrlSKTUJkGHdWj+bRwWU4lW5IgfqdAQjY+TePLv5Lg17fY+/myZWju7mwbzOte/bH0ys3uoQE/ho7FPec3nTq3iepv0vnTrN3x2a+7DcAW7tXJ2FTyVx8/kVfstnYMvvP31O1WVhaMvinsdwJuMLmv+enaOv7/QgS4mLZMTepXB2FK9fFvWh5zq+eQkRi1mutqRl1hszAxseXexvGc3P5cGJD7v7f8hp08cQE3+bJpQME7V/KnbVjuTq7D+dGN+HK1M+4v/lP4kLvU7B+F+qPXkPtr8diae/CnSNb2D68HeG3r9BqyHj8GrfHYDCwY844Dq+eR/kWXajbslPSdSKfPWH84D7YO7nwxYAhr5Tn4J4dJMTHU61m7f/7M6m8HVW15wiT2bggcxtbFKMTjykU/QQub4DY/7vIQKbhdZabJGcOKaXuPZaW+mioWLkqs+cvpXuXdvRs14SZS9YlreY0Gg3jp/zFJ3UrMPab7oxfto2CJcrQukc//p45gfx+1SjXpANHt67j9NJxuBUtT5UvfmXb8PbcWTuWPB1GI7RaLN188G6Rdhr5N2HQxRP/5BExj24SEXCcsHO7kAYdRVt8QaHGnyGEIOTqKc4sH49HicqUbdiWmMhnrJ8wDDfv/HzSTVFkNi2fy72b15k89+8U5SWmjR+JrZ0DPXr1eZUIKpkQO3t7un/+BZPGjeXWjWvkzpM/RXuNeo0pVaEaS6aOpVK9pjgkFozMkTsvTTv2YO2C6ZSq0xzvYmURQtBx8Bgm92zCoUlfU+OHeZhZ22JmZUPdwVO5umUhF//5i8uXD5Itd0nsClTAOmcRzJ2yo7VQap1JKdHHRaOLDCf+aTBx4YHEhd4n9vE94h7fJS7sIcgX2ZNNbJywcM6JT+UmOOYujFO+Eti4eSX1FXThCBfXzSQ04BwOuQvTaegfuObKR2xUBOvGD+XCvs2UadiG74aNTlogREdFMqJPJ4Lu30nxO38ZvV7PzIljyJnLh/IV1fXiB0VKKmvOc9BQDMPb5avN+pRoDyfmwqX14NvpzednYsSrEmMJIfTA80glAVgC0Ymv5X8swZCulPQtLXfs/9do19+2eSPdOrUhT/5CzFyyDgfHFzlLTv57iM/aNKRi7UYMHDsDvU5H3w6NCH1wm69mbyI26hlTPm+KZ8mqVOjzGzf3reXEvF9wLFkHr6bfpkj7nha66KdE3b9CTFAAIUfXYtDHY5rNCV1UOPqYF746GnMr7AtXoVybz7FxV5yBQ2+cZ/+4PljYOtJ3xhosrG1YMeprLu7byu9LNpGvSEnCHwfTu0lFxUl62fqkm/350yfo0KQ6g4eN4OtvB3+AUU0/XG1MTxq7jpmx5/DLhIQEU6qQD83bdOaHkam3hG7duMYntfypVK8pA0a9iK6KjY6iZ7OqCODLGf9gkZgu4OaZf5n/XVfscuSl8oA/sbB7kUE49lkYN/et5fre9UnbUABoNIn1nlLfw4TWFHOn7Dh75cXWMzc27rmw8fTGxi0Xppapk1VGhwZx99h2bu1fR8TD21g6ulG3a198636CRqsl4ORB1k34kafBgXTp9wPNu36RNNcfBwXyS9/O3Ll+md+nLaB2g6avHLeJo4cxd9oE5ixaTuNmn7xhlN8fxpzDZcqUkSdOGKHG8cOzMLMKAxM+Z5W+avpf//8gaKmyUHVvn9qn7X1we3QDmFIWrF2g25YPco0PjRDirebyKy03Usq0M76pvDN1GzRi0fI1dGnXkt4dWzB7+QZsEqMrSperyJff/MCfv42guF9l6rbsyA+/TaNvq5qsHTeEzqP+okbnr9g5dzx3j27Fp2pzYp6EcHHtDBIiw/Fq/DVm9i98XKReT9SDKzy7dpRn148RExSQ1GZibY+ZvTvOOXJjbuuApb0LVk7u2Hh4Y+9VAG1iLR0pJXcObeTUojFY2DnR84/5WGaz5djGZZzfs4mOfb4nX5GSAMwd9zPxcXH8PHp8im2uWZN/w85etdpkVVxcXKnbuAUb1yxnwNBfsbRMGYmSO09+un3xNbMm/0aNJq0p6a8411pYWTP4t+kM7tqMVWO/pf1PU9FotfiULEeHn6exdERfdo7oRLmev+JSwFd5j60jhRt/RuHGnxH1OJAnd68RGXyf+KinRIcHoxEabDy8sbBzwtLBFWuX7Fg5uaPRvPoWFvssjLAb5wm5eopHF//lyb1rADj6FKXFt2MoXr0RJmbmhNy9wY6547l0cDtO2b0ZM399ipw2p4/sY8KQPsTFxvDnvBVUrl7nVZdk0ewpzJ02gVYdu6WrYvPRcl1JHLlXX9LIgrw9jjU/cEUhIaBke9j1M4TdVKqkZ1FeabnJSmSUVe/ObVvo3LYFxX39mLX0H8zMlarDBoOBLm0ac/nMcSb+vYMcufOyaflcZo4aQrMBIylVtwWTv2zDswc3qfPLcqycPLixeyVnlk/EoIvDOmcRTG2c0EU9ISYoAH1sFGg0ZPMqhrdvRZzzl8IhV8E0V6zJ0cXFEHThCNe2LebxtTM45yvJZ79OxcbJlYCTh1j0Qw98Svrz2+zlaLVaTh/ey/Bebfm833d8OXBoUj/Xr1zik9rlGPTDcAZ+P/TVF8wkqJabtDm4fy8tGtbmt6nzqdck9cM6NiaG5rXLk5AQx+TVe7GyzpbUtnHZHGaN/oGyjdrSuO/PSZFDD65dYOHwPkSFPMCnanMKN+2JlWPa+WLeBiklMeHBhN+5Qvjtyzy5e40nd64QHaaEYWtMTHHKU5xSlatTpHK9pPw1gdcvcnDFX5zftxlTc0tadvuSFl2/wMxc2XaNjoxg4aSRbP57Pjl98jFp1hLyFkg7P4lOp2PSmOEsmDmZWg2asmDxslcm+PtQpPccTqz71xPAy8ur9J07d97wjg/AnDqcvRNC0/hf33zuR8LtMQ3h6QOYUASqfAs1fjC2SO/M21puVOUmnVm76m8+/7QjTVt1YMS46UnWjuCghzSv7Y+bZw5+W7QJjVbL112aE3j9Il/9tRmDLoE/P2+KtUt2qg+Zg6mFFVEhgdw6+A+3Tx5AHxuF1sIa97yFcCvsh1sRf8ysU+4cPji9j+iwR1jYOhL7NJT4yCfERTwh9mkokSH3eXo/AKnXYenoRu1OX1CmYVs0Gg0BJw+yZFhvHD1zMWHRP2SztSMq4hl9W1bHzNySdTuOpPC1GdKvB7u2buDM5Zs4OKZdqDMzoSo3aaPX6ymWPxe+fhX4Y/rCNM85ffwIn7asR+X6zRkwakoK696CSSNZPedPStZqRrNvRmKSWLssPiaaXQsmcXjtQoQQ5CxbG+/KjXHJ75tUqfs5jy4qY+JWpJyiyDwJ4cnty4TdvkT4LeVv3DOlNJ0QGmw8cuFdoAie+YuSo2AJsucvimmiwhIXE8XFA9s4sWkFdy+exMzSmoatO9O86xfYJ/oN6fV69mxYweI/xxD+OJgO3b6g73fDsbC0JC2CAu8zpF8PThw9SOtO3Zk4+U9MTF7n6vhh+Oi2paLD4Pc8TEpoxgRd5smvFXNbKRxr6f1hrE23xyRGHi7+BIKvQP9z8BoLZ0bkP29LqXwYmrdsw/VrV/lj9C8UKVGatl2UrL2u7h78NHYy33zekdXzptCm59cMHj2ZL1tUY/34H+g8eg7tfpzIoh96cmTqICr0+R1rF0+KNu9F0eZph1lLKQkNOMuDk3sIuniUp/dSl/AytcyGhZ0T1i7ZKdayG3l8y5O7pD9arQkGvZ6DK/5i+19/4JIrL7/PXUU2WzuklEz7ZRChwUEsXLsjhWLz8ME9tqxfSfdefbKEYqPyarRaLfUbNGLNKiUbd1rWiFJly9P76yFMHfcrufMXpsWnXya1de47BEtLaxZPGUPog9u0/mECDu45MLO0on6vwfg368TBlXM4tX0dd45sxsTCGsfchbDxyI25jQMarQk39q7d5fJSAAAgAElEQVTBoE/A1j0XTx/cJD7yCZCoyHjmpnD5amTPXwzPfEVwz10As5e2zxLiYrl8aCfn923m8uGdJMTG4JTdm24Df6JWs3ZJyfn0Oh0Htq1nxayJ3L91nfzFfJky92+Klkw7UZ+Ukn9WLuG3EYPR63T8OXMubdpnbQfODMWN3SAN7MlEW1IATw8vBz6ccpOEb2dY0VkZp3xZM2pPVW6MwMDvh3LkyFHG/TKEMv6VkszZtRs0pXK9pvw9cwLlazbAK08Bug34kZmjhnB803L8GrWj6YBfWT9+KHtGfYZfjxHY5cibqv+ox4HcPrSR2wc3EhVyH43WBOcCvti7ZcfMwopWg//AxskVS1v7pMrGyTHo9Vw+vIvdCybx8MZlCleqzbDfpmGV6Py58q/JHNi6jq8GDaN4qZQ1dRbOVlbnvfqoKZE+BmrWqc+i+XM4e+JfypSvlOY5Pfp+y5nzZ5k/4ResbGyplxg+LYSgdc/+ZPfOw8Rh/fmzRyPqfPYNZRu3Q6s1wcE9B42/Gk7d7t8ScPIgAScOcv3iWe4d25GkxIBSU00aDBSrXAd3n/x45iuKR55CqRSZ5zwJfsi1Y3u5enQPN08fISEuFksbe2o0akn1Ri0pVMovycL0LDyU7WuWsnn5PB4/CiRXvkKMm7mYWvWbpEql8Jx7t28y8ocBHN6/i1JlyzPjr3nk9snzX4ZZ5V25thWsnDkXm3V9Sv4T+euDlTOcnK8qNyrvD41Gw8w586jsV5Ih/bqzZMPepFXvL2Mm0LjaAab8PJAx89dTv3VXdm7dyJYZo/Eq7EuZ+q2wcXBm+cgBbPuxDe7FKuCctwRacwuiQ4N4fP0M4bcuAeBa2I963fpRqEJNLKxt+GuAUvzPI++LCsYJ8XFEhAbzNOQhj+/e5P7Vc1w/vp9njx9h5+rJoD9mUbF246Qb+fpFs1j852iqNmhB9z4DU3yu0MchrF4yj/rNWiVVR1fJ2lSuWh0TU1MO7Nn2SuVGo9Ewado8Pu/ammkjvuXJ42DafD4gaU5VrNOYfEVLMvqH/mycMoJjG5ZS69OvKVihFhqNBjNLKwpXqkPhSi+cdQ16PVIamDeoKwDdx7+6Zk5cTBS3zx4j4NQhbpw8RPAdxcne3j0HdVq0x69aXYqVqYCJ6QuH+gsnDrN9zVIO79hIfFwsxf0qMWz0BKrUrPfKzMLRUZHMmTqeBbMmY2pqxuhxk/i0ey81E3F6o09QnIkLNsJwVB37NDExg5Lt4Oh0iAgCG3djS/TeUZUbI+Hq6sb4ydP5tEMr5k2bQM9+gwBwdHJh0LBR/DigF1tXLKBB208Z9scM+rSqxZJhvfj8z5UU8K/Ot0v2cGjVXE7t3kzQOSXVvdbMAodcBanTfSBFqzbA0eOFgiGlJD4mitjICFaMGsDjezd58iiQ6GfhKeSysLYhj28FGjVtiX+N+kkZZhPi45jzx09sXj6PCrUaMn7KX6lWrn9N+YP4+DiGDMn8TsQqb4eNrS1l/Cuxa8sG+g8e8Uprhpm5ObMWrGRg/14snfY7186f4svh43ByVW6qrp45GT93FUd3b2HWHyNY+tOXuHj5UK5JR4rXaIyVrX2K/jRaLZC2r4Bel8CDq+e5cfoIN04d5t6l0+h1CZiYmZOrWBkaftKe0pVqkDNPgRTyhoeGsOefFexYs5QHd25glc2G5m060bpTd/IVLJzmtUDxw9m4ehmTx/5MSHAQDZq1ZvTY3/DwzP6Oo6nyXrh7FGKfQoH6cNTYwmQsvL/f9OK18GavuY7xY35gwMg5RpPpQ6E6FBuZzu3bsnPrPyzfdID8hYoAiiLStW0TLp8+xqRVu/HI6c2186cY3K0F9m7Z6TJ6LvZunkl9xMVEYdDrMbe0Trzpv+Dx/Vuc3LKSs7s38CxEiRCxc/HA1Tsfeby9cXLzwMHZDRd3Tzy8cuOWPXVJhkun/mXaL4O4e+MqnXv04esffkX70nXu3AqgeU0/mrbqwPSZsz/EUBkN1aH49SxbNJ9+X/Rg/upt+PpVeO25UkqWL5jFuF+HYmpmRsevvqdey85JSjS88G/5e94MHlw7j9bEFJ+S/viUKo9n/qI4eebCys4BjUbD3G87o0uIp0rbnjwMuMy9y2e4d/kMCbExCCFwz1OI8pWrU6p8NQqVKpsU7fQcg8HA6UN72LJyIScO7MSg11OolB8dOn9G7YbNUoW4v/ze7RvXMn3CKG4FXKNYqTKM+X08ZcuV/28D+gH4qByKtw6B43/BoJt4D9/35vMzEB86z83LzDcdSyHNHdyGBYA2fSP4/l/UaKlkZOQHQ+jjx1QoXZTsOb1ZuG5nUiTFwwf3aFHbn+y58jBmwT+YmJpy4cRhRnzVBY3WhLo9vqVkneZp+szEx0Rz6fAOTm1dzc3TR9BotOQvVxW/sv4ULOVH0dL+b5TruWl+3YIZHN+/A2c3T37+/c8083gYDAZ6tm/CxbOnOHr6Im7uHv99YDIQqnLzeiIjIylVyIciJUozY/Hat3rPnVsBDPmmD+ePHyJnnvy07/0t5Ws1TLWFc+PSOfZvWcvBPdsJuXvjtX1qNFrcfArgW9afoqXLU6xsBWwdnNI8NyToAbvWLWfnumUEB97HztGZFm060qx1R3LnLfDa68TFxrJp3d8smj2FG9eukCd/IX4Y9jMNGjfNsFtQH41yIyVMLgXO+aDDyhSWisxAQmKSSlOn9Kk7Vl1zmnlmv0PLuUpphkyAqtwkIyM/GOBFePhXg4bR46tvk45v37iWgb0706BNVz4foqR6v3/rOmOG9OfuxZNkc3ShQLnquOTMjUarJSLsMQ8DLnH7/HF08XHYu+egUatO1GrWFkeXN+cKiY2OIuDSWc4c2c+Bbet5ePcWNvaOdOnRh049vnzlKnb6hNFMHz+KcZOn0+nT7u9tXDIKqnLzZmZMmciwwd8y5s+5NGjW6q3eI6Vk99YNjBv9E/dvXSdH7nw069Kbqg2aY26ROrQ6PDSE21cvEhx4n4in4RgMBiytrHFwdsEjZ25y+ORL833PSUiI5+SBXexcu0yx0hgMlPCvQsfOn1GjbiNM31C1/uGDe6xbsZi/F84m7HEIBYsU5+uBg2jSvGUqS2ZG46NRbh5dhOkVoNEEKNMt0yk36Y0GA3vMBpDLKxd8tkNJ8pfBydDKjRCiH9ADpZTDbCnlxJfaqwHrgVuJh9ZIKUckttUDJqFsuP8lpXyj/S6jPxiklHTp0I6dW9azaN0uipTwTWobP3Io82dMouNXg2ndQ4lAMhgMHNu7jbUrl3Ln/IkkvxmtiSnOOX0oV7Eq/jXqUdjXP8VK8theJWNnmSq1eHA7gFtXL3E34Ap3b17jXsBVHt67hcFgQKPRUKR0eVq16UC9Ji1fmcMDYNXSeYz4ri9NWrZn9tz5r/S5yMyoys2b0el0NKhdjWuXLzJt4eo3bk8lR6/Xs23DGmZOHc+tKxewsXOgWqOW1GreDu98hV47p57Pab9qaWcGToiP48KJIxzavoHDOzcR+ewJDs6utGjTiU/adyWHl/drZYuOimT3to2sW7GY44f3I6WkUvU69B/wDZWrVs808/2jUW72jIZ9Y2HgNcjmmumUm+gA5Tdulbdcul2zs3YbI0wXwKdbIVfG21J9mQyr3AghigLLAT8gHtgK9JZSXk92TjVgoJSy0Uvv1QLXgNrAfeA40E5Keel118zoDwaA8LAwqpYvjUarZcXmA0mF9wwGA/16f8q+zWto3L473Qb+lMI/ASAq4hlSGrC0ypaq7TkhD+8ztHtLIp89xWDQExWhVIXVaLV45MxNwUKFyVewCIWLlcTXrwK2dvZp9vOchIQEZkwYzew/f6ditdosW7kGCwuL174ns6IqN29H0MNAmtSvReD9u3w/4ndatO3yTts0UkpOHj3E3DnTObprCzpdAjl98uFXvR4l/atSsLgv5i9ZD4d0aw7AqLnKdlhsdBQ3r17kypnjXDh5hIsnjhATHYWllTV+1evRuk17/CtVf22G4Pi4OPbt2srWf1ZxYPd2YmOiye7lTfuOnWnTvhNeubzffXCMzEej3EwrD5YO8OlmgEyn3KS3zw2AJbFcdvgGvMpDu2Xpdt3/l4ycxK8QcFRKGQ0ghNgHNAd+e4v3+gEBUsqbie9dDjQFXqvcZAYcHB2Zt3g5jetW59svujJ14WpMTEzQaDRMnDaXcb94sHjOVC6dPsbnQ0ZRsMSL79baJnUNUyklt69d4vi+HRzdvZmAS+cAMDO3oEnLdpTw9aNQsZLkzpP/jeb4lzlx9CC/jxjM5fNnaN6mE1Omz0z3dPIqGQ93D0+27jpA5w5tGPFdX1YtnkfXXv2oWa/xW80xIQRlyleiTPlKhIWGsH3jOjasX8W6BdNZPefPJEXcI2cu7JxcMLewJPDOTfR6PT/2aEXQ/TsEB97j+YIte648NP6kHVVq1sWvQtXXWiABbt+8zqol89iwainhYaE4ubjStkMnWrRqi59/hQzrT6OSyOMACL4E9dJPMcgKxGABZXvA/t+UrMWuBY0t0nvBGMrNBWCkEMIJiAEaAGmp9eWFEGeBQBQrzkUgO3Av2Tn3gTTtd8lrm+TI6fX+pP+AlC5bjj8mTqX/lz0ZNXQAP46ehBACrVbLoJ/GULJMOUYN+5ZBnRqRr2hJylatQ56CRbGxd8Jg0PM07DGBd24ScOksF04c4WnYYwDyF/Ol/5AR7Ny8HgsLS4aNmfx/yXf25L9MnzCGw/t24urmwZzFf9O4aYv3OQQqyciMc9jRyYl/Nm9nxbLF/DFmFIO+7IqtnQNVa9ejSo16+FWsgoOj81v040LbLj1o26UHkRHPOH38CGdPHiPg6iVu37nDzasXSYiLIzoqAo1GS2xMNL5lyuGdpyMFixSnuK8fTs4ub7yOlJLjRw4wd9oEDu9THPqr1WlI9+49qFqjVob3pVFJxqV1yt9CjY0rRyak1HYfDpqbs+PPr+mf8KLYcVK5hkxIuis3UsrLQoixwA4gEjgL6F467RSQS0oZKYRoAKwD8qH46KTq8hXXmQXMAsWk/57E/+C07/wpt27eYNK4sdjZO9L3u+FJ+/p1GjWnYrVarFuxmJXLFrFs2u+kta3o6pmTSlVrUq5iVSpVr4Ozq+JMfHD39neWR0rJob07mTttPCeOHsTB0YkfR4zms8+/wMrq1WGyKv+dzDqHNRoNbTt0pnW7juzZuZ0lS5eyf+dWNqxSTN75CxWljH8lSvtXonS5Cjg6vV4JyWZjS+Uadalco26qtm6t6gMwd+WWd5JRp9OxfeNaFs2ewsVzp3ByceX7H3+mQ5duuLllvYRmWR3v7zey3WwuT8lPq9FnUR4rKm9LOLYs0tehh3Yjk8Qn3JKZP+LVKEn8pJRzgDkAQohRKBaY5O3Pkr3eLISYJoRwTjwveerbHCiWnSzFkOG/cP/hI+ZMHYfBoE+RHM06mw0duvWmQ7fePHsSzu1bATwND0OrNcHewZEcXt5J/jr/Bb1ez66tG5g/fSIXzp7EzSM7I0b/Tseu3cmWLdubO1D56NFoNNSsU4+adeqh0+k4ffI4B/btYc+ePaxZtoCl82YAkCd/QXz9KuLrV54SpcuRPWeuD+ao++hhIBtWL2XVknkE3r+Ld558/D5pKm3ad86yPmMfA4XEXfJrHjA04VNji5Jpma1rQBftNr4yWcuAhC+MLc5/xijKjRDCVUoZLITwAloA5V9qdwceSSmlEMIP0AChwBMgnxAiN/AAaAu0T1/pPzxCCKZOn4lGo2Xe9ImEhgQzbMxkzMzNU5xna++QqrbT6xg16c3J9UIfh7Bx9TKWLZhF4L075Mzlw7jJ02nToTNm7+ibo6LyHBMTE8qWK0/ZcuUZMGgI8fHxnD19kiMHD7Bn7142r1vBysVKllRXd09KlfGnRJlyFC5WknwFi2CTWMDyZd40p2NjYrh6+Twnjhxg/65tnD5+BICy5Ssz5o+J1KmfOreOSuajqfYQCVLLJn36RRl9CJwbfWO0a4dixwJ9XXpqNzJdNOG6TJ9cOx8KY5VfWJ3oc5MAfCmlDBdC9AKQUs4AWgK9hRA6FL+ctlLZf9EJIfoA21BCwecm+uJkOTQaDVOmTSdXTk/+GP0LNwOuMWrSLLx98v3ffbp7pp6s8XFxBFy9xPEjB9i/exun/j2EXq+nVNny/Dr6d+o3aqL6Hai8d8zMzJKUnb7fDEKv13Pp4nmO/3uEY0cOc/jQQbZtXJN0vqubBzly5cbNIzuOzi7Y2TtgZWWd5KicEB9PTHQ0Ec+eEBYWSsijhwTeu8uDe7cxGAyAsh323dCfaP5Ja3zy/v+/I5UMhkFPE+1h9huKE07q4IrMhIntm/3EPiQzdI1or93JAJOV9E742qiy/FeMtS1VOY1jM5K9ngJMecV7NwObP5x0GQchBIOGDKNwkWL0//JzWtWpQKcefejY/Ys3+imEhz3m7q0bBN6/x+PgIMLDQrl0/jRxsbHY2Tvw9Ek4wUEPCbx/B71eDyjbA1/2+4ZW7TpQ4DW1dFRU3jdarZZixUtSrHhJuvXoDSih5efOnObyxQsEXL/K9YAbnD99gvCwx0RFRqTZj4WlFQ6OTri4ueNbujSt2rajeIlSlPYrp/rSZFVu7MZThDFS39HYkvxnoi7vB8C6UBWjXP8JNvyla8gA01WU1AUYRYb3hVo4MxPQqGlzypbz59sBXzNn6jjmz5hI+So1KFHaH3fP7Gi1Wp6EhxF47w43rl/l2uXzPA5+lKIPjUaDEBq0Wi1eufNgZ+9AmbJl8W7dhsJFi1GufEXcPTxfIYGKSvrj7uGJu4cndeqnjtjQ6XRER0XR7hMlMmbpqn+wsrZWUxJ8jJycT4i0ZbvBqKmo3gsRp5V1u7GUG4C/9A3oZLKDIaZLQPbNFFmL00JVbjIJbu4eLFy6nOtXr7Bk4Tw2rF/HgZeinywsrfDOk4+atepQqEgx8uUvQM5cuXB398TO3p7mDWoBsG7LLmN8BBWV94aJiQm2dnZJyoyd/euTTqpkUZ49hKtbWKVvQIL6OHsvRGPBBF1LRpnOgSsbM21ovTobMhn5ChTkp5Fj+WnkWCIjIggOfoRBr8fB0QkHR0fVOVJFReXj4eR8kHqW66sbW5Isxd/6anTVbiX/9qGQtzaYZr5IQvVJmInJZmODT5685M1fACdnZ1WxUVFR+XiIj4Jjs6BAA+5I1Z/qfaJHy8+6zhB+G46k6f6a4VGfhioqKioqmY/TSyAmDCr2M7YkWZJDhmLKltSBcRB+x9jivDPqttRHxJxFfxtbBBWV94o6pz9SdHFw+E/I6Q9e/kDmKpD5KlyaDTa2CCmpOxpu+MPGr6Hj6kzlXKxabj4inJydcXJ+c10fFZXMgjqnP1KOz4Gnd6HqIGNL8l7RWtmhtUo7YaVRsM8JNYfDjV1wNuNXDE+Oqtx8RCxfvIDlixcYWwwVlfeGOqc/QmKeKBWsfapD3prGlua9Enl+J5HndxpbjJSU7Q5eFWDztxB209jSvDWqcvMRsXzJQpYvWWhsMVRU3hvqnP4I2TNSUXBq/2xsSd47GVK50WigxSzQaGHVZ8qWYCZA9blRUVFRUckUtB78ByvMZzFPV5efJ93npZrLKh8K+5zQdCr83RE29INm0zO8/41quVFRUVFRyfjEhPO76UzuGFz5TdfG2NJ8fBRqDNWGKL43e8cYW5o3olpuVFRUVFQyNgY9rO6OhwilbfyPxJD5ksplRry/fzkKrQi/m1Sh1b4xoDWBygMzrAVHtdyoqKioqGRcDAbYNAACdvKTriunZH5jS/QRI/hO1xOKt4Hdv8LmgaDXGVuoNFEtNx8RS1dvMLYIKirvFXVOZ3F08Ypic3oRVPqapTvLGluiD4prq5+MLcIbMaCBZjPAxh0OTYKg89B8Bjj6GFu0FBjFciOE6CeEuCCEuCiE6J9GewchxLnEf4eFECWStd0WQpwXQpwRQpxIX8kzN1ZWVlhZWRlbDBWV94Y6p7MwYbdgfkNFsanyrZJvJYujMbVAkxnqOGk0UHsEfDIHgq/AtAqKJSf2mbElSyLdLTdCiKJAD8APiAe2CiE2SSmvJzvtFlBVShkuhKgPzALKJWuvLqV8nG5CZxHmzp4OQLcevY0siYrK+0Gd01mQJ3eVmlH/zgKtKbScB0VbGFuqdCHilOLjYuPb0MiSvCXFWoJXedjxI+z/Hf6dCaU6QvHW4FHSqP44xtiWKgQclVJGAwgh9gHNgd+enyClPJzs/KNAjnSVMIvyz5pVgPogUMk6qHM6CxDzBB6egXvHIGCn8lcIKNYaag0HW09jS5huRF05AGR85Sa1o/EnFBWl6KnfRJNjs+HoNLDxAO/KkKMseJQAtyJgni3dZDSGcnMBGCmEcAJigAbA67aXPgO2JPu/BLYLISQwU0o5K603CSF6Aj0BcuT0eh9yq6ikK+ocVslyJMRA4Gm4fxwenIKHZyH81ot2jxJQ7XsqbPUg8JgzHDsNnDaauCpvzwXpQ9+Er2gyuDxc2aSUbLi1D86vAMAgBbelG+elD6cNeTluKMhl6cXNMY0/iDzprtxIKS8LIcYCO4BI4CyQpru1EKI6inJTKdnhilLKQCGEK7BDCHFFSrk/jevMQtnOoqRvafmeP4aKygdHncMqWYHbDx4ybWgn/DRXKC5uYCb0ANw1uHBe5uaioSwXZG7OGPLw7FY2xSlBJdPiPeII4Ai0AlriThhFNLcpIu5QRHMbP80VmmqVzZkn0hqWL1csPLkqKNYdjfa9yGGUaCkp5RxgDoAQYhRppJkUQhQH/gLqSylDk703MPFvsBBiLYrvTirlRkVFRUXF+HiLIHpoN3Fe5mauvgHHDfk5bchHGLbGFk3lgyMIwokggxO7KA2KXosHofhpLlNBc4k2QefhykalwdRKUXCc84N9LrBxAwt7MLdR2t7B2dooyo0QwjVROfECWgDlX2r3AtYAnaSU15IdtwY0UsqIxNd1gBHpKLqKioqKyjtwS3pQLG4ysZgbWxSVDMJDnFhvqMR6QyW+C4IcIoTS4ioldTcodPcu3vc24y7C/9M1hJTpb+0WQhwAnIAEYICUcpcQoheAlHKGEOIv4BPgTuJbdFLKMkIIH2Bt4jETYKmUcuRbXC8CuPq+P0cmxRlQI81e8DbjkUtK6ZIewrwKIUQIL34PyVG/T3UM4M1jkK5zOLm/GFCA9L3/Zvb5oMr/et5qLhtFuUlvhBAnpJRljC1HRkAdi5Rk9vHI7PK/D9QxUMcgOZl9LFT53w9q+QUVFRUVFRWVLIWq3KioqKioqKhkKT4W5SbNXDgfKepYpCSzj0dml/99oI6BOgbJyexjocr/HvgofG5UVFRUVFRUPh4+FsuNioqKioqKykeCqtyoqKioqKioZClU5UZFRUVFRUUlS6EqNyoqKioqWYbE7PUqHzkfhUOxEMIWkIllGzRSSoOxZTImQggzACllvLFlyQgIIUxQynrEZ7b5IYSoCjgAplLKlcaWxxgIIaoBroCJlHKpkcUxCkKIHECElPKpsWUxJkKIWkA1YKSUMsbI4vwnhBAuKL/rwGTHhMwkD+3EwtdSSrnXGNfP8pYbIUQTYDmwWwhRKzM9uD4EQohPgKXARiFEQyGEg7FlMiZCiAbAfGCDEKKalNIghMgUv4vEG/kslHTnvYUQc4QQzkYWK11JvIEuA7yAAUKIaUIITyOLla4IIZoBO4HPPrbvPzlCiPrAWGBHFlBsWgKbgPVCiF+EEJVB0RSEEMK40r0ZIUQdYCJgtAV0lrbcJE6IyUB3oCjQFaj7sVoshBD5gfVAN8AbaAfsAjZKKW8YUTSjkOxm+C3Kw3EEyvw4Z1TB3gIhhCmwENgkpVwshMgGXAM2A4OklGGZaZX3/5B4kx8LPJRSThBCWABzUOrajJJSPvoIxsAFZfF2F7gPPAKWSykzc22id0YIUQA4C3wmpVwihHAFrIBsUsoLxpXu3RBCOKHcp79E+T77ABbAYSnlGmPK9jYk3ldnA7WklFeEEJYoukZ0esqRKVao/4GCwB4p5UlgB2AAxgghmiQO+MeGI/BISnlESrkMGI2i9DUQQtgYV7T0JXFfvgEwVEq5TUo5G5gJFDOuZK/n+apNSpkAXE88ZimljARWAEVQlDSy8kMdkj7fKaCAEMJNShkL9ADcgOHJzsnKPAX6A72AM0A+oF3iw53MsMp/T0QAU4ByQogKKNbpocAuIURvo0r27mgBcyBWShkETEBRXssLIfyNKtnbYQN4AsFCCC3KImylEGKsEKJUegmR1ZWbB4CnEGIUsA84BJxHuRk0NqZg6YkQwirx5THglhCitRDCREp5BJiH8pAvbzQB05lEZSAKmIty83v+O9AAFYwn2VuRvBruaaAN8KMQYh5gD9QBCgohShhDuPRACJFTCGGeuEA5gnIzLZ74vUYDn6I85JoYVdAPiBDCK9F3zkRKeV5KGSelXA3sR1Fw2iSemmXnQXIS/VImAZHAXmC9lLI70BD4NZMoBQBIKYOB1SjbjJ5SylAUZQ2Ue3WGRkq5AmV34CFKNfidwPdANqBjeslhkl4XSi8STWIuUsqFKAqNFeAOXJRSDks8JxLoLoRYL6WMM560Hx4hRF2UG/8UIA44CfihaNWHpJSHhRDLUcZjt5RSZ0x5PzSJ41FCCDEOOPPSyv484Jt4XjvgrpTykBHETJPEuT1QCHES5SY+EQhEsVCGAVOllDFCiFtApvY5eBVCiIYoW1GHUZSaASg+N/2VZnFeSvlQCLEL0BtP0g/HS2NgJ4QYLqW8AiClXJ1orCkhhFgH1BRCFEjulJrVeL71KKW8J4SYBuyXUm5NPH5CCLGMzDcX9gCfAG2FEMullIFCiEnAMiGEc0bddkz2XcwXQiQABaSUMxPbRgJLhRAuUsqQDy1LllJuEvfcewO1hRCRifuTq4QQds+HISoAAAxPSURBVEBuIUReKWVA4ulPgCxtsk58GI4B+j13sBNCzAcGAk2BnMAilHGI5eMaj7Rudk+BKCFEK+AnoFk6ivdahBBFgD9RrBIRQHtgHdBFSvmvSIzyEkJ0A0oC6bq//aFJ3F7JgfL99QEuA12Af1GsjtNJXBUKIR6gjM9fRhH2A/GKMeiIEixRW0p5EZIUnOYo86BCVlRshBD5ADsU6yUkKi9SyvtCiKDE11II0R6oDPxmFEHfESGEVkqpT/xNOwNVge+EELOAwoBAuVdnVIQQgkQFZ8lLbZVQXEPSRf4spdxIKWOFEBtQbuzjhBC2Usr5gA7lhzBMCGFA8av4NCs7FgshCgPTgNFSyr2JTmpuQLSU8ichREegnhDis/+1d+4xdlVVGP99beVlFQUkQa0iAvUBSCxVCqiUIqChPBRUnj5QHmqbGCrvKFLxRRTlkQDGGIQiBQQEiVg0VoooFqRSChQQra1BUQJiLZRSPv9Y+9LLdOZOp8zMOffM+iXN3HvOunO/u3pn77XXXntvYHPg6D46/EbQhz+2ADawvbCYbULUatwNHGT7/mrU9soY4Dbb8yCmJYDdgR9JOqo06u8CpgGfsL2sQq2DTsmwLZX0O6Jw+jHb3yqjw9uBXYn6m4nEVMwU2w9WJngI6MMH3y4+mCNpsu0HJW1FZCAPavtuNwbF6rCvAA8TRdSLJV1q+38lyH+uTNkdCJwGfNT23yqU3CeS3k0UC6+wPd/2akkvs73K9k2SHgX2IoL3VcD0Ul9XC3rR/3yps1ndw+4YYDpwhO3/Dou2ptTbtb4Qkg4ENgAeIVYRXA/8jxj1vofoyG+1/VBlYocBSROAY4gGfxmRrXmcqNmYb/vkYrcjUWT8WFVah4MO/tgMeMD2NEnbEKttPluXwEbSHkSG7QZi2uz8sjLoa8A/CP332b5KsZ/TaNtPVKd48JE0FdiWKBi9DLjH9tfa7p9K1Jmc0NRp5nXwwUnEyP6EMjU5tk6d4GBRBiWXAyfavq9kKk8gVhedZ/upNttJxEq6v1Yith9KJvk8YgpqS+Bx28eUexu2f5dLFufpUitYC/rRP6ZV4qBYyfkZYE4ruzgs2O7qf8D2PZ6/CfhxeTyDWGd/UdU6q/AHMbI/F/gzsZpCREf5K+C9VWutkT9+We5tCGxeteaidRRRgLeIGKUfAownCvSuJFb/jSEa9q9XrXcI/bAPsQpo3/J8a2LlyMltNlsT+/2oar3pgyH3xabAPGCvtmvXEMXEh5XnuxHLkCvX2+FzjC5/x0eV568EbgOu6WG3B7Bh1Xpfgv5JxEaEw66xq6elJO0PXCXpetuHl8tPAv+S9BGiYvss4AuSfm17dlVah4M2f9xg+2O2f1tS1rfavq6YLZW0lAo3VxouBuCPZQCOkVItRv6OzSaXS7qUSPEeRDQS4yVt6rITbZlmHdM+UmoKiiW9lwFTbf+hjF6XEb64qfxf/ozozN5JrBZrWtZqxPugHdv/kTQL+KSk1xHF9M8A9xFBYGtDx99Up7J/HNNPd7c9fwrYQ9I8SRfbPk6xXcWewF+Ilb+1YQD69waWEAsfhpWuDW6K4z5PrJLYTdLlto+0/YSkFUSDcLijuG4eNftyDDa9+OMK24eXBnHjNrsPE3uhPFqR1GFhPfxR1xqV54jG+ofAsZImAislnU6ker9I1FY0KrApPE7UGWxVpiOuJvyxiCgWnkBMR+1C1NA1sVNPH6zNj4mi+r2BJ223CskPUBylMtslbVA3JG3vNbVgfwdOkfQbr6kJOhi4SNJbgQeAb7lGtaHrof+blemvOr31ElNjryVS91sQqckryvVRlOkIGp6m7ccfs3rc/zgwH9ihaq3pj3X+DG8GTimPTySK5S8oz6cTSy0r1zmEn/8dRP3cMiKYGwUcC1wIjCs2r65aZ/qgEr+Mant8NFFYPrZqXR307l/+fq9suzYTWAq8oe3alcCuVevtdv1NKijenJhzftr2kZJ2Bla6JoWhw00v/ngrMBm42fYj1aobfrrVH4pzks4mGu6TiIzku4gG5vIqtQ0XZaXbZNsXtl37BXCq7T9KzT5iAdIHnShFxTOIVVG1XB1WMsk/Aa4lphA3tH1YuTcTOIBYzbkFsbz/g7b/UpHctehG/Y0JbuCFivJziCKm0URjUNfphiGnzR+7EcWz77Pd6OmoTnSrPySdRZyL9jnbNyoOi3zY9tJqlVVDmUo8jWhA/1m1nipIH6xB0huJerSH+zWukDJQeYpYOn0RsKotQDiY2Gx2AvBd1/A8rG7T36jgBkDSF4CTgffXNYofTtIfL6Yb/SFpHLCl44w0yl4eI+50e0kiNjGcARzq4VxWWhPSB82gLZP8rO3DFJt0Lre9pGJp60Q36G/U2VKSXk2cvbFPt3RcQ0n648V0qz9sL7V9V+nYGImBTRuPAB8a4Z16+qDLcZwXdRzwjKTFxD49XbOJajfob2LmZiPH6cAJ6Y+epD+SJKkL3ZhJbqfO+huVuYE4gqFqDXUi/fFi0h9JktSBbs0kt6i7/sZlbpIkSZKkG+j2THKd9WdwkyRJkiRJo2jctFSSJEmSJCObDG6SJBk0JK2WtEDSvZKulrRJ1ZoAJJ02CL/jHEkPSLpH0nWSXjUY2pIkGXwyuKkRDe8YDpW0SNLzknYZDF1JLXna9s62dyAOZz1+XV8oafTQyWLA3+Fe9NxCHNWxE3FS+6mDISxJksEng5t60eSO4V7gQ8Ctg6Io6QbmAdsCSLpe0l0lwD22ZSBpuaSzJN0BTJL0JUnzS4B/SWtvH0lzJZ0r6VZJ90uaKOlaSQ9J+mrb7ztS0h/KIOFiSaMlfQPYuFyb1Zddb3raP4ztOV5zQOnvgdcPneuSJHkpZHBTX5rWMdxve/FQOy2pB4rTmT8AtJaIfsr2BOL06ullh1OAlwP32n637duIQ0EnlgB/Y+KwvhbP2n4vsfX7T4HPATsAn5C0ueK8sI8Cu9vemdhU7Ajbp7Bm4HBEX3Z96OmLTwE/X28HJbWl4Rn0mWVadYGkOYojFRpJBjc1ZAR0DElz2VjSAuBO4G/AD8r16ZL+RGQ8xgHbleuriQP5WkyWdIekhcBewNvb7t1Qfi4EFtl+1PZKYsfeccAU4myb+UXDFGCbXjR2suupZy0knQ48B8zqZJd0LU3OoJ9je6fSdv8M+NKgKKshY6oWkLyIVscAkblp7xgOLo9bHcPj9N4xnARsAmwGLAJuLPfW6hgAJLU6hj1Y0+BDBEeP9aJxSge7fjuGpPE8XRrOF5C0J7A3MMn2CklzicP3AJ6xvbrYbUScLLyL7aWSzmyzA1hZfj7f9rj1fAxxGOqltvurhelk94KeXl8ofZwYNEwZqadwjzDmATtBZNCJtnIj4Hu2LynXlwPfAfYFTpS0FzCVaBtvB46z7fK9v5toP18DHE3Ube0IzLZ9Rvl9RwLTgQ2AO4DPAmezpn9YVAaaa9nZXt1TD/DCQNP2U22f7eVAY7/DmbmpF60Rw862p9l+tkfH8A7ij6NTx3CI7R2B77N+HUPr/cfbPrMXjZ3sOnYMyYhlU+CJEti8Bdi1D7vW9/XfksYChwzwfX4FHCJpSwBJmylOjAZYJell62DXJ5L2I7aaP8D2igFqS7qMpmbQJZ0taWmxb2zmJoOb+tOIjiEZ0dwMjJF0DzCTmJpaC9tPEkH5QuB6YP5A3sT2fcAZwJzyXrcAW5XblwD3SJrVj10nLgBeAdxSahYuGoi+pGto9NSq7dNtjyOmVT/f0RNdTE5L1Z+bgeNLI7yYDh2DpFbH8FfWo2OQ1GrwRwGriFHFEtZ0DH8so4a+7PqkTKudT6Rjb5K0wPa+A9GY1B/bY3u5tpIYAfdrX1LzZ/Rit2fb47nA3D7uzQZm9/L6k4msS392a+lvu7dtX/eSRtHoqdU2rgBuAr68DrZdRx6/kCRJkiQFSct7BrmSDgQ+bXtqyaAvAPazPbfdXrGx42Jga2A0MRi9xvaZJSCaYfvOEizNsL1/ed1cYAawgpiu2t32Y5I2A15he4mkJ4Atba+S9LYOdmvpb/sc29l+qDyeBrzP9kCz/F1BZm6SJEmSpDONyKAD35A0nsgULWEAK8G6jczcJEmSJEnSKLKgOEmSJEmSRpHBTZIkSZIkjSKDmyRJkiRJGkUGN0mSJEmSNIoMbpIkSZIkaRQZ3CRJkiRJ0igyuEmSJEmSpFH8H2JbLNOiQlQuAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show traces and histograms\n", + "pints.plot.trace(full_chains)\n", + "\n", + "# Discard warm up\n", + "full_chains = full_chains[:, 200:, :]\n", + "\n", + "# Check convergence using rhat criterion\n", + "print('R-hat:')\n", + "print(pints.rhat_all_params(full_chains))\n", + "\n", + "# Look at distribution in chain 0\n", + "pints.plot.pairwise(full_chains[0], kde=True, ref_parameters = real_parameters)\n", + "\n", + "# Show graphs\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/writing-a-model.ipynb b/examples/writing-a-model.ipynb index 65dc3bafc..b897d7829 100644 --- a/examples/writing-a-model.ipynb +++ b/examples/writing-a-model.ipynb @@ -265,9 +265,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 2", + "display_name": "Python 3", "language": "python", - "name": "python2" + "name": "python3" }, "language_info": { "codemirror_mode": { From 26d1e0ff96ee410427cb970d91b1a1895137a97d Mon Sep 17 00:00:00 2001 From: Ben Lambert Date: Thu, 13 Feb 2020 14:39:16 +0000 Subject: [PATCH 04/10] started to update docstrings --- pints/_mcmc/_slice_covariance_matching.py | 38 +++++++++++------------ 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/pints/_mcmc/_slice_covariance_matching.py b/pints/_mcmc/_slice_covariance_matching.py index c6f185d2a..7b329284d 100644 --- a/pints/_mcmc/_slice_covariance_matching.py +++ b/pints/_mcmc/_slice_covariance_matching.py @@ -14,33 +14,33 @@ class SliceCovarianceMatchingMCMC(pints.SingleChainMCMC): - """ - Implements Covariance-Adaptive Slice Sampling by Covariance Matching, - as described in [1]. This is an adaptive multivariate method which - uses additional points, called "crumbs", and rejected proposals to - guide the selection of samples. + r""" + Implements Covariance-Adaptive Slice Sampling by Covariance Matching, as + described in [1]_. This is an adaptive multivariate method which uses + additional points, called "crumbs", and rejected proposals to guide the + selection of samples. It generates samples by sampling uniformly from the volume underneath the - posterior (``f``). It does so by introducing an auxiliary variable (``y``) - and by definying a Markov chain. + posterior (:math:`f`). It does so by introducing an auxiliary variable + (:math:`y`) and by definying a Markov chain. Sampling follows: - 1. Calculate the pdf (``f(x_0)``) of the current sample (``x_0``). - 2. Draw a real value (``y``) uniformly from (0, f(x0)), defining a - horizontal “slice”: S = {x: y < f(x)}. Note that ``x_0`` is - always within S. - 3. Draw the first crumb (``c_1``) from a Gaussian distribution with - mean ``x_0`` and precision matrix ``W_1``. - 4. Draw a new point (``x_1``) from a Gaussian distribution with mean - ``c_1`` and precision matrix ``W_2``. + 1. Calculate the pdf (:math:`f(x_0)`) of the current sample (:math:`x_0`). + 2. Draw a real value (:math:`y`) uniformly from :math:`(0, f(x0))`, + defining a horizontal "slice": :math:`S = {x: y < f(x)}`. Note that + :math:`x_0` is always within :math:`S`. + 3. Draw the first crumb (:math:`c_1`) from a Gaussian distribution with + mean :math:`x_0` and precision matrix :math:`W_1`. + 4. Draw a new point (:math:`x_1`) from a Gaussian distribution with mean + :math:`c_1` and precision matrix :math:`W_2`. New crumbs are drawn until a new proposal is accepted. In particular, - after sampling ``k`` crumbs from Gaussian distributions with mean ``x0`` - and precision matrices (``W_1``, ..., ``W_k``), the distribution for the - ``k`` th proposal sample is: + after sampling :math:`k` crumbs from Gaussian distributions with mean + :math:`x_0` and precision matrices :math:`(W_1, ...,W_k)``, the + distribution for the kth proposal sample is: - 1. ``x_k \sim Normal(\bar{c}_k, \Lambda^{-1}_k)`` + ``x_k \sim Normal(\bar{c}_k, \Lambda^{-1}_k)`` where: From 3b267b183af2ef40e98e0e554142c300becab6a4 Mon Sep 17 00:00:00 2001 From: Ben Lambert Date: Thu, 13 Feb 2020 15:01:45 +0000 Subject: [PATCH 05/10] addec cached variables and corrected docstrings --- pints/_mcmc/_slice_covariance_matching.py | 70 ++++++++++++----------- 1 file changed, 38 insertions(+), 32 deletions(-) diff --git a/pints/_mcmc/_slice_covariance_matching.py b/pints/_mcmc/_slice_covariance_matching.py index 7b329284d..8ab0c483a 100644 --- a/pints/_mcmc/_slice_covariance_matching.py +++ b/pints/_mcmc/_slice_covariance_matching.py @@ -40,30 +40,31 @@ class SliceCovarianceMatchingMCMC(pints.SingleChainMCMC): :math:`x_0` and precision matrices :math:`(W_1, ...,W_k)``, the distribution for the kth proposal sample is: - ``x_k \sim Normal(\bar{c}_k, \Lambda^{-1}_k)`` + .. math:: + x_k \sim Normal(\bar{c}_k, \Lambda^{-1}_k) - where: + where: :math:`\Lambda_k = W_1 + ... + W_k` and + :math:`\bar{c}_k = \Lambda^{-1}_k (W_1 c_1 + ... + W_k c_k)`. - 2. ``\Lambda_k = W_1 + ... + W_k`` - 3. ``\bar{c}_k = \Lambda^{-1}_k * (W_1 * c_1 + ... + W_k * c_k)`` - - This method attempts to find the ``k + 1`` th crumb precision matrix - (``W_{k + 1}``) so that the distribution for the ``k + 1`` th proposal + This method attempts to find the (k+1)th crumb precision matrix + (:math:`W_{k + 1}`) so that the distribution for the (k+1)th proposal point has the same conditional variance as uniform sampling from the slice - ``S`` in the direction of the gradient of ``f(x)`` evaluated at the last - rejected proposal (``x_k``). + :math:`S` in the direction of the gradient of :math:`f(x)` evaluated at the + last rejected proposal (:math:`x_k`). To avoid floating-point underflow, we implement the suggestion advanced - in [1] pp.712. We use the log pdf of the un-normalised posterior - (``log f(x)``) instead of ``f(x)``. In doing so, we use an - auxiliary variable ``z = log(y) - \epsilon``, where - ``\epsilon \sim \text{exp}(1)`` and define the slice as - S = {x : z < log f(x)}. - - [1] Thompson, M. and Neal, R.M., 2010. Covariance-adaptive slice sampling. - arXiv preprint arXiv:1003.3201. - - *Extends:* :class:`SingleChainMCMC` + in [1]_ pp.712. We use the log pdf of the un-normalised posterior + (:math:`log f(x)`) instead of :math:`f(x)`. In doing so, we use an + auxiliary variable :math:`z = log(y) - \epsilon`, where + :math:`\epsilon \sim \text{exp}(1)` and define the slice as + :math:`S = {x : z < log f(x)}`. + + Extends :class:`SingleChainMCMC`. + + References + ---------- + .. [1] "Covariance-adaptive slice sampling", 2010. Thompson, M. and Neal, + R.M., arXiv preprint arXiv:1003.3201. """ def __init__(self, x0, sigma0=None): @@ -74,7 +75,7 @@ def __init__(self, x0, sigma0=None): self._running = False self._ready_for_tell = False self._current = None - self._proposed_pdf = None + self._proposed_log_pdf = None self._current_log_y = None self._proposed = None self._log_fx_u = None @@ -109,6 +110,13 @@ def __init__(self, x0, sigma0=None): # Parameter to control variance precision self._theta = 1 + # Cached mean and covariance of z-variates + self._mean_z = np.zeros(self._n_parameters) + self._cov_z = np.identity(self._n_parameters) + + # convenient cached + self._identity_m = np.identity(self._n_parameters) + # Function which calculates Cholesky rank one updates def _chud(self, matrix, vector): V = np.dot(matrix.transpose(), matrix) + np.outer(vector, vector) @@ -142,9 +150,7 @@ def ask(self): return np.array(self._u, copy=True) # Draw first p-variate - mean = np.zeros(self._n_parameters) - cov = np.identity(self._n_parameters) - z = np.random.multivariate_normal(mean, cov) + z = np.random.multivariate_normal(self._mean_z, self._cov_z) # Draw crumb c self._c = self._current + np.dot(np.linalg.inv(self._F), z) @@ -158,7 +164,7 @@ def ask(self): np.linalg.inv(self._R))), self._c_bar_star) # Draw second p-variate - z = np.random.multivariate_normal(mean, cov) + z = np.random.multivariate_normal(self._mean_z, self._cov_z) # Draw sample self._proposed = c_bar + np.dot(np.linalg.inv(self._R), z) @@ -246,7 +252,7 @@ def tell(self, reply): # If this is the log_pdf of a new point, save the value and use it # to check ``f(x_1) >= y`` if self._sent_proposal: - self._proposed_pdf = fx + self._proposed_log_pdf = fx self._sent_proposal = False # Very first call @@ -264,8 +270,8 @@ def tell(self, reply): self._M = fx # Define Cholesky upper triangles: F_k for W_k and R_k for Lambda_k - self._R = self._sigma_c ** (-1) * np.identity(self._n_parameters) - self._F = self._sigma_c ** (-1) * np.identity(self._n_parameters) + self._R = self._sigma_c ** (-1) * self._identity_m + self._F = self._sigma_c ** (-1) * self._identity_m # Sample height of the slice log_y for next iteration e = np.random.exponential(1) @@ -275,7 +281,7 @@ def tell(self, reply): return np.array(self._current, copy=True) # Acceptance check - if self._proposed_pdf >= self._current_log_y: + if self._proposed_log_pdf >= self._current_log_y: # The accepted sample becomes the new current sample self._current = np.array(self._proposed, copy=True) @@ -288,8 +294,8 @@ def tell(self, reply): # Reset parameters self._c_bar_star = np.zeros(self._n_parameters) - self._F = self._sigma_c ** (-1) * np.identity(self._n_parameters) - self._R = self._sigma_c ** (-1) * np.identity(self._n_parameters) + self._F = self._sigma_c ** (-1) * self._identity_m + self._R = self._sigma_c ** (-1) * self._identity_m self._calculate_fx_u = False # Return accepted sample @@ -317,12 +323,12 @@ def tell(self, reply): # Calculate ``\kappa`` kappa = (-2.) * self._delta ** (-2.) * ( - self._log_fx_u - self._proposed_pdf - self._delta * + self._log_fx_u - self._proposed_log_pdf - self._delta * np.linalg.norm(self._G)) # Peak of parabolic cut through ``x1`` and ``u`` lxu = (0.5 * (np.linalg.norm(self._G) ** 2 / kappa) + - self._proposed_pdf) + self._proposed_log_pdf) # Update ``M`` self._M = max(self._M, lxu) From ceca654e75301b7552191f8db5344ca0df1d5e5a Mon Sep 17 00:00:00 2001 From: Ben Lambert Date: Tue, 17 Mar 2020 21:24:49 +0000 Subject: [PATCH 06/10] updated docstrings --- pints/_mcmc/_slice_covariance_matching.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pints/_mcmc/_slice_covariance_matching.py b/pints/_mcmc/_slice_covariance_matching.py index 8ab0c483a..080bf36ff 100644 --- a/pints/_mcmc/_slice_covariance_matching.py +++ b/pints/_mcmc/_slice_covariance_matching.py @@ -15,7 +15,7 @@ class SliceCovarianceMatchingMCMC(pints.SingleChainMCMC): r""" - Implements Covariance-Adaptive Slice Sampling by Covariance Matching, as + Implements covariance-adaptive slice sampling by covariance matching, as described in [1]_. This is an adaptive multivariate method which uses additional points, called "crumbs", and rejected proposals to guide the selection of samples. From 12fbf1102e9defe8c13d3521364fca4b6c05ecab Mon Sep 17 00:00:00 2001 From: Ben Lambert Date: Tue, 17 Mar 2020 21:26:09 +0000 Subject: [PATCH 07/10] further docstrings work --- pints/_mcmc/_slice_covariance_matching.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pints/_mcmc/_slice_covariance_matching.py b/pints/_mcmc/_slice_covariance_matching.py index 080bf36ff..a6a990eac 100644 --- a/pints/_mcmc/_slice_covariance_matching.py +++ b/pints/_mcmc/_slice_covariance_matching.py @@ -53,7 +53,7 @@ class SliceCovarianceMatchingMCMC(pints.SingleChainMCMC): last rejected proposal (:math:`x_k`). To avoid floating-point underflow, we implement the suggestion advanced - in [1]_ pp.712. We use the log pdf of the un-normalised posterior + in [2]_ pp.712. We use the log pdf of the un-normalised posterior (:math:`log f(x)`) instead of :math:`f(x)`. In doing so, we use an auxiliary variable :math:`z = log(y) - \epsilon`, where :math:`\epsilon \sim \text{exp}(1)` and define the slice as @@ -65,6 +65,8 @@ class SliceCovarianceMatchingMCMC(pints.SingleChainMCMC): ---------- .. [1] "Covariance-adaptive slice sampling", 2010. Thompson, M. and Neal, R.M., arXiv preprint arXiv:1003.3201. + .. [2] "Slice sampling", 2003, Neal, R.M., The annals of statistics, 31(3), + pp.705-767. https://doi.org/10.1214/aos/1056562461 """ def __init__(self, x0, sigma0=None): From 1f87900432d4012da3eaf059fc10b3f65eb27da7 Mon Sep 17 00:00:00 2001 From: Ben Lambert Date: Tue, 17 Mar 2020 21:27:27 +0000 Subject: [PATCH 08/10] updated docstrings --- pints/_mcmc/_slice_covariance_matching.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pints/_mcmc/_slice_covariance_matching.py b/pints/_mcmc/_slice_covariance_matching.py index a6a990eac..898766e1e 100644 --- a/pints/_mcmc/_slice_covariance_matching.py +++ b/pints/_mcmc/_slice_covariance_matching.py @@ -16,13 +16,13 @@ class SliceCovarianceMatchingMCMC(pints.SingleChainMCMC): r""" Implements covariance-adaptive slice sampling by covariance matching, as - described in [1]_. This is an adaptive multivariate method which uses - additional points, called "crumbs", and rejected proposals to guide the - selection of samples. + introduced in [1]_ with pseudocode given in Fig. 4. This is an adaptive + multivariate method which uses additional points, called "crumbs", and + rejected proposals to guide the selection of samples. It generates samples by sampling uniformly from the volume underneath the posterior (:math:`f`). It does so by introducing an auxiliary variable - (:math:`y`) and by definying a Markov chain. + (:math:`y`) which guides MCMC sampling. Sampling follows: From 76f3d96cbb0f0fdffa578c9b0cb71c51aac0dcc7 Mon Sep 17 00:00:00 2001 From: Ben Lambert Date: Tue, 17 Mar 2020 22:04:20 +0000 Subject: [PATCH 09/10] simplified notebook --- examples/README.md | 1 - .../slice-covariance-matching-mcmc.ipynb} | 0 2 files changed, 1 deletion(-) rename examples/{sampling-slice-covariance-matching-mcmc.ipynb => sampling/slice-covariance-matching-mcmc.ipynb} (100%) diff --git a/examples/README.md b/examples/README.md index 696629854..7e732364e 100644 --- a/examples/README.md +++ b/examples/README.md @@ -56,7 +56,6 @@ relevant code. - [Relativistic MCMC](./sampling-relativistic-mcmc.ipynb) - [Slice Sampling: Covariance Matching MCMC](./sampling-slice-covariance-matching-mcmc.ipynb) - ### Nested sampling - [Ellipsoidal nested sampling](./sampling/nested-ellipsoidal-sampling.ipynb) - [Rejection nested sampling](./sampling/nested-rejection-sampling.ipynb) diff --git a/examples/sampling-slice-covariance-matching-mcmc.ipynb b/examples/sampling/slice-covariance-matching-mcmc.ipynb similarity index 100% rename from examples/sampling-slice-covariance-matching-mcmc.ipynb rename to examples/sampling/slice-covariance-matching-mcmc.ipynb From c7344e658dfed9b1d9e28d3deb93243ab64df810 Mon Sep 17 00:00:00 2001 From: Ben Lambert Date: Wed, 18 Mar 2020 00:12:43 +0000 Subject: [PATCH 10/10] No idea why this isn't working but something is blowing up the proposal --- ...pling-slice-covariance-matching-mcmc.ipynb | 447 ++++++++++++++++++ pints/_mcmc/_slice_covariance_matching.py | 91 ++-- 2 files changed, 502 insertions(+), 36 deletions(-) create mode 100644 examples/sampling/sampling-slice-covariance-matching-mcmc.ipynb diff --git a/examples/sampling/sampling-slice-covariance-matching-mcmc.ipynb b/examples/sampling/sampling-slice-covariance-matching-mcmc.ipynb new file mode 100644 index 000000000..7c6f2057d --- /dev/null +++ b/examples/sampling/sampling-slice-covariance-matching-mcmc.ipynb @@ -0,0 +1,447 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Slice sampling with covariances matched to slice covariance\n", + "This notebook describes how to use a method of slice sampling introduced in [1] to generate MCMC samples from a given target distribution. Unlike most other variants of slice sampling, this approach uses sensitivities to guide the sampler back towards a slice (an area of parameter space where the target density exceeds a given value).\n", + "\n", + "[1] \"Covariance-adaptive slice sampling\", 2010. Thompson, M and Neal, RM, arXiv preprint arXiv:1003.3201." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 1: Multimodal Distribution\n", + "\n", + "In experimenting, we found that this type of slice sampling was surprisingly effective at sampling from multimodal distributions. Here, we demonstrate this. First, we plot the multimodal target." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "os.chdir(\"../../\")\n", + "import pints\n", + "import pints.toy\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Define target\n", + "log_pdf = pints.toy.MultimodalGaussianLogPDF(modes = [[0, 0], [10, 10], [10, 0]])\n", + "\n", + "# Plot target\n", + "levels = np.linspace(-3,12,20)\n", + "num_points = 100\n", + "x = np.linspace(-5, 15, num_points)\n", + "y = np.linspace(-5, 15, num_points)\n", + "X, Y = np.meshgrid(x, y)\n", + "Z = np.zeros(X.shape)\n", + "Z = np.exp([[log_pdf([i, j]) for i in x] for j in y])\n", + "plt.contour(X, Y, Z)\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we use this method of slice sampling to generate MCMC samples from this distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running...\n", + "Using Slice Sampling - Covariance-Adaptive: Covariance Matching\n", + "Generating 4 chains.\n", + "Running in sequential mode.\n", + "Iter. Eval. Time m:s\n", + "0 4 0:00.0\n", + "1 24 0:00.0\n", + "2 84 0:00.1\n", + "3 88 0:00.1\n", + "20 612 0:00.6\n", + "40 1132 0:01.2\n", + "60 1628 0:01.7\n", + "80 2220 0:02.3\n", + "100 2836 0:02.9\n", + "120 3412 0:03.5\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0;31m# Run!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Running...'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m \u001b[0mchains\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmcmc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 21\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Done!'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Volumes/Samsung1.5TB/Github/pints/pints/_mcmc/__init__.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 613\u001b[0m \u001b[0;31m# Get points\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 614\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_single_chain\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 615\u001b[0;31m \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_samplers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mask\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mactive\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 616\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 617\u001b[0m \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_samplers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mask\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Volumes/Samsung1.5TB/Github/pints/pints/_mcmc/__init__.py\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 613\u001b[0m \u001b[0;31m# Get points\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 614\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_single_chain\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 615\u001b[0;31m \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_samplers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mask\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mactive\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 616\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 617\u001b[0m \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_samplers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mask\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Volumes/Samsung1.5TB/Github/pints/pints/_mcmc/_slice_covariance_matching.py\u001b[0m in \u001b[0;36mask\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 153\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 154\u001b[0m \u001b[0;31m# Draw first p-variate\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 155\u001b[0;31m \u001b[0mz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultivariate_normal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mean_z\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cov_z\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 156\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 157\u001b[0m \u001b[0;31m# Draw crumb c\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32mmtrand.pyx\u001b[0m in \u001b[0;36mnumpy.random.mtrand.RandomState.multivariate_normal\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mallclose\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/site-packages/numpy/core/numeric.py\u001b[0m in \u001b[0;36mallclose\u001b[0;34m(a, b, rtol, atol, equal_nan)\u001b[0m\n\u001b[1;32m 2157\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2158\u001b[0m \"\"\"\n\u001b[0;32m-> 2159\u001b[0;31m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0misclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrtol\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrtol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0matol\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0matol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mequal_nan\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mequal_nan\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2160\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36misclose\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/site-packages/numpy/core/numeric.py\u001b[0m in \u001b[0;36misclose\u001b[0;34m(a, b, rtol, atol, equal_nan)\u001b[0m\n\u001b[1;32m 2257\u001b[0m \u001b[0mxfin\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0misfinite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2258\u001b[0m \u001b[0myfin\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0misfinite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2259\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxfin\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0myfin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2260\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mwithin_tol\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0matol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrtol\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2261\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mall\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/site-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36mall\u001b[0;34m(a, axis, out, keepdims)\u001b[0m\n\u001b[1;32m 2396\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2397\u001b[0m \"\"\"\n\u001b[0;32m-> 2398\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_wrapreduction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlogical_and\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'all'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkeepdims\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2399\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2400\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/site-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36m_wrapreduction\u001b[0;34m(obj, ufunc, method, axis, dtype, out, **kwargs)\u001b[0m\n\u001b[1;32m 72\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_wrapreduction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mufunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 74\u001b[0;31m passkwargs = {k: v for k, v in kwargs.items()\n\u001b[0m\u001b[1;32m 75\u001b[0m if v is not np._NoValue}\n\u001b[1;32m 76\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "# Create an adaptive covariance MCMC routine\n", + "x0 = np.random.uniform([2, 2], [8, 8], size=(4, 2))\n", + "mcmc = pints.MCMCController(log_pdf, 4, x0, method=pints.SliceCovarianceMatchingMCMC)\n", + "\n", + "for sampler in mcmc.samplers():\n", + " sampler.set_sigma_c(5)\n", + "\n", + "# Set maximum number of iterations\n", + "mcmc.set_max_iterations(2000)\n", + "\n", + "# Disable logging\n", + "mcmc.set_log_to_screen(True)\n", + "mcmc.set_log_interval(20)\n", + "\n", + "# Number of chains\n", + "num_chains = 4\n", + "\n", + "# Run!\n", + "print('Running...')\n", + "chains = mcmc.run()\n", + "print('Done!')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Overlaying the samples on the modes, we see good coverage across them." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "stacked = np.vstack(chains)\n", + "plt.contour(X, Y, Z, colors='k', alpha=0.5)\n", + "plt.scatter(stacked[:,0], stacked[:,1], marker='.', alpha=0.2)\n", + "plt.xlim(-5, 15)\n", + "plt.ylim(-5, 15)\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And a low KL divergence from the target at each mode." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KL divergence by mode: [0.00070219 0.00122926 0.00132544]\n" + ] + } + ], + "source": [ + "print(\"KL divergence by mode: \" + str(log_pdf.kl_divergence(stacked)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 2: Simple harmonic oscillator\n", + "We now try the same method on a more realistic time-series problem using the [simple harmonic oscillator](../toy/model-simple-harmonic-oscillator.ipynb). model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot model solutions with additive noise." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import pints.noise\n", + "model = pints.toy.SimpleHarmonicOscillatorModel()\n", + "\n", + "times = np.linspace(0, 30, 500)\n", + "parameters = model.suggested_parameters()\n", + "values = model.simulate(parameters, times)\n", + "values += + pints.noise.independent(0.1, values.shape)\n", + "\n", + "plt.figure(figsize=(15,2))\n", + "plt.xlabel('t')\n", + "plt.ylabel(r'$y$ (Displacement)')\n", + "plt.plot(times, values)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running...\n", + "Using Slice Sampling - Covariance-Adaptive: Covariance Matching\n", + "Generating 1 chains.\n", + "Running in sequential mode.\n", + "Iter. Eval. Time m:s\n", + "0 1 0:00.0\n", + "1 2 0:00.0\n", + "2 13 0:00.0\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[0;31m# Run!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Running...'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 37\u001b[0;31m \u001b[0mfull_chains\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmcmc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 38\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Done!'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Volumes/Samsung1.5TB/Github/pints/pints/_mcmc/__init__.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 613\u001b[0m \u001b[0;31m# Get points\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 614\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_single_chain\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 615\u001b[0;31m \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_samplers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mask\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mactive\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 616\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 617\u001b[0m \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_samplers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mask\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Volumes/Samsung1.5TB/Github/pints/pints/_mcmc/__init__.py\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 613\u001b[0m \u001b[0;31m# Get points\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 614\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_single_chain\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 615\u001b[0;31m \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_samplers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mask\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mactive\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 616\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 617\u001b[0m \u001b[0mxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_samplers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mask\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Volumes/Samsung1.5TB/Github/pints/pints/_mcmc/_slice_covariance_matching.py\u001b[0m in \u001b[0;36mask\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0;31m# print(c_bar)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0;31m# Draw second p-variate\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 172\u001b[0;31m \u001b[0mz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultivariate_normal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mean_z\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cov_z\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 173\u001b[0m \u001b[0;31m# print(z)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[0;31m# Draw sample\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32mmtrand.pyx\u001b[0m in \u001b[0;36mnumpy.random.mtrand.RandomState.multivariate_normal\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/site-packages/scipy/linalg/decomp_svd.py\u001b[0m in \u001b[0;36msvd\u001b[0;34m(a, full_matrices, compute_uv, overwrite_a, check_finite, lapack_driver)\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m def svd(a, full_matrices=True, compute_uv=True, overwrite_a=False,\n\u001b[0m\u001b[1;32m 17\u001b[0m check_finite=True, lapack_driver='gesdd'):\n\u001b[1;32m 18\u001b[0m \"\"\"\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "# Create an object with links to the model and time series\n", + "problem = pints.SingleOutputProblem(model, times, values)\n", + "\n", + "# Create a log-likelihood function (adds an extra parameter!)\n", + "log_likelihood = pints.GaussianLogLikelihood(problem)\n", + "\n", + "# Create a uniform prior over both the parameters and the new noise variable\n", + "log_prior = pints.UniformLogPrior(\n", + " [-10, -10, 0, 0],\n", + " [10, 10, 10, 20],\n", + ")\n", + "\n", + "# Create a posterior log-likelihood (log(likelihood * prior))\n", + "log_posterior = pints.LogPosterior(log_likelihood, log_prior)\n", + "\n", + "# Choose starting points for 3 mcmc chains\n", + "num_chains = 1\n", + "# log_prior.sample(num_chains)\n", + "xs = np.array([[ 2.70601259, -3.76849432, 0.04782399, 0.53750962]])\n", + "\n", + "# Create mcmc routine\n", + "mcmc = pints.MCMCController(\n", + " log_posterior, num_chains, xs, method=pints.SliceCovarianceMatchingMCMC)\n", + "\n", + "for sampler in mcmc.samplers():\n", + " sampler.set_sigma_c(5)\n", + " \n", + "# Add stopping criterion\n", + "mcmc.set_max_iterations(1000)\n", + "\n", + "# Set up modest logging\n", + "mcmc.set_log_to_screen(True)\n", + "mcmc.set_log_interval(1)\n", + "\n", + "# Run!\n", + "print('Running...')\n", + "full_chains = mcmc.run()\n", + "print('Done!')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.1257482, 0. , 0. , 0. ],\n", + " [0. , 0.1257482, 0. , 0. ],\n", + " [0. , 0. , 0.1257482, 0. ],\n", + " [0. , 0. , 0. , 0.1257482]])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "R=np.diag(np.ones(4) * 2.82)\n", + "np.dot(np.linalg.inv(R), np.transpose(\n", + " np.linalg.inv(R)))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R-hat:\n" + ] + }, + { + "ename": "ZeroDivisionError", + "evalue": "float division by zero", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mZeroDivisionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;31m# Check convergence using rhat criterion\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'R-hat:'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpints\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrhat_all_params\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_chains\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0;31m# Look at distribution in chain 0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Volumes/Samsung1.5TB/Github/pints/pints/_diagnostics.py\u001b[0m in \u001b[0;36mrhat_all_params\u001b[0;34m(chains)\u001b[0m\n\u001b[1;32m 113\u001b[0m \"\"\"\n\u001b[1;32m 114\u001b[0m \u001b[0msamples_all\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mreorder_all_params\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchains\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m \u001b[0mrhat_all\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mrhat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msamples_all\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 116\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrhat_all\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Volumes/Samsung1.5TB/Github/pints/pints/_diagnostics.py\u001b[0m in \u001b[0;36m\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 113\u001b[0m \"\"\"\n\u001b[1;32m 114\u001b[0m \u001b[0msamples_all\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mreorder_all_params\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchains\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m \u001b[0mrhat_all\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mrhat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msamples_all\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 116\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mrhat_all\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Volumes/Samsung1.5TB/Github/pints/pints/_diagnostics.py\u001b[0m in \u001b[0;36mrhat\u001b[0;34m(samples)\u001b[0m\n\u001b[1;32m 102\u001b[0m \"\"\"\n\u001b[1;32m 103\u001b[0m \u001b[0mW\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwithin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msamples\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 104\u001b[0;31m \u001b[0mB\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbetween\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msamples\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 105\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 106\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mW\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1.0\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mB\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mW\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mW\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Volumes/Samsung1.5TB/Github/pints/pints/_diagnostics.py\u001b[0m in \u001b[0;36mbetween\u001b[0;34m(samples)\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[0mm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msamples\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 75\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mm\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmu\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mmu_overall\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m**\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 76\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 77\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mZeroDivisionError\u001b[0m: float division by zero" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import pints.plot\n", + "\n", + "# Show traces and histograms\n", + "pints.plot.trace(full_chains)\n", + "\n", + "# Discard warm up\n", + "full_chains = full_chains[:, 200:, :]\n", + "\n", + "# Check convergence using rhat criterion\n", + "print('R-hat:')\n", + "print(pints.rhat_all_params(full_chains))\n", + "\n", + "# Look at distribution in chain 0\n", + "pints.plot.pairwise(full_chains[0], kde=True, ref_parameters = real_parameters)\n", + "\n", + "# Show graphs\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pints/_mcmc/_slice_covariance_matching.py b/pints/_mcmc/_slice_covariance_matching.py index 898766e1e..9f6eaa23a 100644 --- a/pints/_mcmc/_slice_covariance_matching.py +++ b/pints/_mcmc/_slice_covariance_matching.py @@ -156,19 +156,23 @@ def ask(self): # Draw crumb c self._c = self._current + np.dot(np.linalg.inv(self._F), z) - + # print(self._c) # Compute un-normalised proposal mean self._c_bar_star = self._c_bar_star + np.dot(np.dot(np.transpose( self._F), self._F), self._c) - + # print(np.dot(np.dot(np.transpose( + # self._F), self._F), self._c)) + # print(self._F) + # print(self._c_bar_star) # Compute normalised proposal mean c_bar = np.dot(np.dot(np.linalg.inv(self._R), np.transpose( np.linalg.inv(self._R))), self._c_bar_star) - + # print(c_bar) # Draw second p-variate z = np.random.multivariate_normal(self._mean_z, self._cov_z) - + # print(z) # Draw sample + # print(self._R) self._proposed = c_bar + np.dot(np.linalg.inv(self._R), z) # Set flag indicating we have created a new proposal. This is used to @@ -181,6 +185,9 @@ def ask(self): # Send trial point for checks self._ready_for_tell = True + # print(self._current) + # print(self._proposed) + # print(-2) return np.array(self._proposed, copy=True) def current_log_pdf(self): @@ -321,38 +328,50 @@ def tell(self, reply): return None else: - self._log_fx_u = fx - - # Calculate ``\kappa`` - kappa = (-2.) * self._delta ** (-2.) * ( - self._log_fx_u - self._proposed_log_pdf - self._delta * - np.linalg.norm(self._G)) - - # Peak of parabolic cut through ``x1`` and ``u`` - lxu = (0.5 * (np.linalg.norm(self._G) ** 2 / kappa) + - self._proposed_log_pdf) - - # Update ``M`` - self._M = max(self._M, lxu) - - # Calculate conditional variance of new distribution - sigma_squared = 2 / 3 * (self._M - self._current_log_y) / kappa - - alpha = max( - 0, sigma_squared ** (-1) - (( - 1 + self._theta) * np.dot( - np.transpose(self._g), np.dot( - np.transpose(self._R), np.dot( - self._R, self._g))))) - - # Update F and R - self._F = self._chud( - np.sqrt(self._theta) * self._R, np.sqrt(alpha) * self._g) - self._R = self._chud( - np.sqrt(1 + self._theta) * self._R, np.sqrt(alpha) * - self._g) - - return None + if np.isfinite(fx): + self._log_fx_u = fx + + # Calculate ``\kappa`` + kappa = (-2.) * self._delta ** (-2.) * ( + self._log_fx_u - self._proposed_log_pdf - self._delta * + np.linalg.norm(self._G)) + + # Peak of parabolic cut through ``x1`` and ``u`` + lxu = (0.5 * (np.linalg.norm(self._G) ** 2 / kappa) + + self._proposed_log_pdf) + + # Update ``M`` + self._M = max(self._M, lxu) + + # Calculate conditional variance of new distribution + sigma_squared = 2 / 3 * (self._M - self._current_log_y) / kappa + + alpha = max( + 0, sigma_squared ** (-1) - (( + 1 + self._theta) * np.dot( + np.transpose(self._g), np.dot( + np.transpose(self._R), np.dot( + self._R, self._g))))) + + # Update F and R + # print(-3) + # print(self._log_fx_u) + # print(self._proposed_log_pdf) + # print(kappa) + # print(self._current_log_y) + # print(self._M) + # print(sigma_squared) + # print(self._theta) + # print(alpha) + # print(self._g) + # print(-4) + self._F = self._chud( + np.sqrt(self._theta) * self._R, np.sqrt(alpha) * self._g) + self._R = self._chud( + np.sqrt(1 + self._theta) * self._R, np.sqrt(alpha) * + self._g) + + return None def theta(self): """