From 92c1786ff105539b7354ea809760ea7a2c97abe0 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 11:19:33 +0100 Subject: [PATCH 01/72] MLE API --- src/pyhf/infer/test_statistics.py | 13 ++++++------- src/pyhf/infer/utils.py | 11 +++-------- src/pyhf/optimize/autodiff.py | 23 ++++++----------------- src/pyhf/optimize/opt_minuit.py | 22 ++++++---------------- src/pyhf/optimize/opt_scipy.py | 18 +++--------------- tests/test_optim.py | 9 +++++---- 6 files changed, 29 insertions(+), 67 deletions(-) diff --git a/src/pyhf/infer/test_statistics.py b/src/pyhf/infer/test_statistics.py index d6d216b4ca..3418193be4 100644 --- a/src/pyhf/infer/test_statistics.py +++ b/src/pyhf/infer/test_statistics.py @@ -1,6 +1,5 @@ from .. import get_backend -from .utils import loglambdav - +from .mle import fixed_poi_mle,floating_poi_mle def qmu(mu, data, pdf, init_pars, par_bounds): r""" @@ -30,13 +29,13 @@ def qmu(mu, data, pdf, init_pars, par_bounds): Float: The calculated test statistic, :math:`q_{\mu}` """ tensorlib, optimizer = get_backend() - mubhathat = optimizer.constrained_bestfit( - loglambdav, mu, data, pdf, init_pars, par_bounds + mubhathat, fixed_val = fixed_poi_mle( + mu, data, pdf, init_pars, par_bounds,return_fval = True ) - muhatbhat = optimizer.unconstrained_bestfit( - loglambdav, data, pdf, init_pars, par_bounds + muhatbhat, float_val = floating_poi_mle( + data, pdf, init_pars, par_bounds, return_fval = True ) - qmu = loglambdav(mubhathat, data, pdf) - loglambdav(muhatbhat, data, pdf) + qmu = fixed_val - float_val qmu = tensorlib.where( muhatbhat[pdf.config.poi_index] > mu, tensorlib.astensor([0]), qmu ) diff --git a/src/pyhf/infer/utils.py b/src/pyhf/infer/utils.py index 70097446b5..d6eae7d806 100644 --- a/src/pyhf/infer/utils.py +++ b/src/pyhf/infer/utils.py @@ -1,14 +1,9 @@ from .. import get_backend - - -def loglambdav(pars, data, pdf): - return -2 * pdf.logpdf(pars, data) - +from .mle import fixed_poi_mle,floating_poi_mle def generate_asimov_data(asimov_mu, data, pdf, init_pars, par_bounds): - _, optimizer = get_backend() - bestfit_nuisance_asimov = optimizer.constrained_bestfit( - loglambdav, asimov_mu, data, pdf, init_pars, par_bounds + bestfit_nuisance_asimov = fixed_poi_mle( + asimov_mu, data, pdf, init_pars, par_bounds ) return pdf.expected_data(bestfit_nuisance_asimov) diff --git a/src/pyhf/optimize/autodiff.py b/src/pyhf/optimize/autodiff.py index 8e8a91a131..3b6bce5903 100644 --- a/src/pyhf/optimize/autodiff.py +++ b/src/pyhf/optimize/autodiff.py @@ -3,7 +3,7 @@ class AutoDiffOptimizerMixin(object): - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None): + def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None,return_fval = False): tensorlib, _ = get_backend() tv, fixed_values_tensor, func, init, bounds = self.setup_minimize( objective, data, pdf, init_pars, par_bounds, fixed_vals @@ -12,19 +12,8 @@ def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None) func, init, method='SLSQP', jac=True, bounds=bounds ) nonfixed_vals = fitresult.x - return tv.stitch([fixed_values_tensor, tensorlib.astensor(nonfixed_vals)]) - - def unconstrained_bestfit(self, objective, data, pdf, init_pars, par_bounds): - return self.minimize(objective, data, pdf, init_pars, par_bounds) - - def constrained_bestfit( - self, objective, constrained_mu, data, pdf, init_pars, par_bounds - ): - return self.minimize( - objective, - data, - pdf, - init_pars, - par_bounds, - [(pdf.config.poi_index, constrained_mu)], - ) + fitted_fval = fitresult.fun + fitted_pars = tv.stitch([fixed_values_tensor, tensorlib.astensor(nonfixed_vals)]) + if return_fval: + return fitted_pars,tensorlib.astensor(fitted_fval) + return fitted_pars diff --git a/src/pyhf/optimize/opt_minuit.py b/src/pyhf/optimize/opt_minuit.py index bba205e2a2..654a93df65 100644 --- a/src/pyhf/optimize/opt_minuit.py +++ b/src/pyhf/optimize/opt_minuit.py @@ -45,23 +45,13 @@ def f(pars): ) return mm - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None): + def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, return_fval = False): mm = self._make_minuit(objective, data, pdf, init_pars, par_bounds, fixed_vals) result = mm.migrad(ncall=self.ncall) assert result - return np.asarray([x[1] for x in mm.values.items()]) + bestfit_pars = np.asarray([x[1] for x in mm.values.items()]) + bestfit_value = mm.fval + if return_fval: + return bestfit_pars,bestfit_value + return bestfit_pars - def unconstrained_bestfit(self, objective, data, pdf, init_pars, par_bounds): - return self.minimize(objective, data, pdf, init_pars, par_bounds) - - def constrained_bestfit( - self, objective, constrained_mu, data, pdf, init_pars, par_bounds - ): - return self.minimize( - objective, - data, - pdf, - init_pars, - par_bounds, - [(pdf.config.poi_index, constrained_mu)], - ) diff --git a/src/pyhf/optimize/opt_scipy.py b/src/pyhf/optimize/opt_scipy.py index 306f16c81c..b454653b9d 100644 --- a/src/pyhf/optimize/opt_scipy.py +++ b/src/pyhf/optimize/opt_scipy.py @@ -8,7 +8,7 @@ class scipy_optimizer(object): def __init__(self, **kwargs): self.maxiter = kwargs.get('maxiter', 100000) - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None): + def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, return_fval = False): fixed_vals = fixed_vals or [] indices = [i for i, _ in fixed_vals] values = [v for _, v in fixed_vals] @@ -27,19 +27,7 @@ def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None) except AssertionError: log.error(result) raise + if return_fval: + return result.x, result.fun return result.x - def unconstrained_bestfit(self, objective, data, pdf, init_pars, par_bounds): - return self.minimize(objective, data, pdf, init_pars, par_bounds) - - def constrained_bestfit( - self, objective, constrained_mu, data, pdf, init_pars, par_bounds - ): - return self.minimize( - objective, - data, - pdf, - init_pars, - par_bounds, - [(pdf.config.poi_index, constrained_mu)], - ) diff --git a/tests/test_optim.py b/tests/test_optim.py index e96437ad7a..a734b3e6a4 100644 --- a/tests/test_optim.py +++ b/tests/test_optim.py @@ -67,12 +67,13 @@ def test_optim(backend, source, spec, mu): optim = pyhf.optimizer - result = optim.unconstrained_bestfit( - pyhf.infer.utils.loglambdav, data, pdf, init_pars, par_bounds + result = optim.minimize( + pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds ) assert pyhf.tensorlib.tolist(result) - result = optim.constrained_bestfit( - pyhf.infer.utils.loglambdav, mu, data, pdf, init_pars, par_bounds + result = optim.minimize( + pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds, + [(pdf.config.poi_index,mu)] ) assert pyhf.tensorlib.tolist(result) From abc8afe3c33eaf9e20196b719485ee24428ce764 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 11:20:44 +0100 Subject: [PATCH 02/72] MLE API --- src/pyhf/infer/mle.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 src/pyhf/infer/mle.py diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py new file mode 100644 index 0000000000..15f2ae708b --- /dev/null +++ b/src/pyhf/infer/mle.py @@ -0,0 +1,30 @@ +""" +Module for Maximum Likelihood Estimation +""" +from .. import get_backend + +def loglambdav(pars, data, pdf): + return -2 * pdf.logpdf(pars, data) + +def floating_poi_mle(data, pdf, init_pars, par_bounds, **kwargs): + _,opt = get_backend() + return opt.minimize( + loglambdav, + data, + pdf, + init_pars, + par_bounds, + **kwargs + ) + +def fixed_poi_mle(constrained_mu, data, pdf, init_pars, par_bounds, **kwargs): + _,opt = get_backend() + return opt.minimize( + loglambdav, + data, + pdf, + init_pars, + par_bounds, + [(pdf.config.poi_index, constrained_mu)], + **kwargs + ) \ No newline at end of file From 862364ea992df881da13bc18c940f2040d8ad620 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 11:30:12 +0100 Subject: [PATCH 03/72] remove example dir --- src/pyhf/optimize/opt_minuit.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/pyhf/optimize/opt_minuit.py b/src/pyhf/optimize/opt_minuit.py index 654a93df65..892e379202 100644 --- a/src/pyhf/optimize/opt_minuit.py +++ b/src/pyhf/optimize/opt_minuit.py @@ -45,11 +45,14 @@ def f(pars): ) return mm - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, return_fval = False): + def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, return_fval = False, return_uncertainties = False): mm = self._make_minuit(objective, data, pdf, init_pars, par_bounds, fixed_vals) result = mm.migrad(ncall=self.ncall) assert result - bestfit_pars = np.asarray([x[1] for x in mm.values.items()]) + if return_uncertainties: + bestfit_pars = np.asarray([(v,mm.errors[k]) for k,v in mm.values.items()]) + else: + bestfit_pars = np.asarray([v for k,v in mm.values.items()]) bestfit_value = mm.fval if return_fval: return bestfit_pars,bestfit_value From d8d1f60909a66c36cce97e7d90eb0b0d5fb5dfdb Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 11:33:54 +0100 Subject: [PATCH 04/72] remove example dir --- src/pyhf/infer/mle.py | 8 ++++++-- src/pyhf/infer/test_statistics.py | 6 +++--- src/pyhf/infer/utils.py | 4 ++-- 3 files changed, 11 insertions(+), 7 deletions(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 15f2ae708b..6db3c2fbb3 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -6,8 +6,10 @@ def loglambdav(pars, data, pdf): return -2 * pdf.logpdf(pars, data) -def floating_poi_mle(data, pdf, init_pars, par_bounds, **kwargs): +def fit(data, pdf, init_pars = None, par_bounds = None, **kwargs): _,opt = get_backend() + init_pars = init_pars or pdf.config.suggested_init() + par_bounds = par_bounds or pdf.config.suggested_bounds() return opt.minimize( loglambdav, data, @@ -17,8 +19,10 @@ def floating_poi_mle(data, pdf, init_pars, par_bounds, **kwargs): **kwargs ) -def fixed_poi_mle(constrained_mu, data, pdf, init_pars, par_bounds, **kwargs): +def fixed_poi_fit(constrained_mu, data, pdf, init_pars = None, par_bounds = None, **kwargs): _,opt = get_backend() + init_pars = init_pars or pdf.config.suggested_init() + par_bounds = par_bounds or pdf.config.suggested_bounds() return opt.minimize( loglambdav, data, diff --git a/src/pyhf/infer/test_statistics.py b/src/pyhf/infer/test_statistics.py index 3418193be4..c14a44dca8 100644 --- a/src/pyhf/infer/test_statistics.py +++ b/src/pyhf/infer/test_statistics.py @@ -1,5 +1,5 @@ from .. import get_backend -from .mle import fixed_poi_mle,floating_poi_mle +from .mle import fixed_poi_fit,fit def qmu(mu, data, pdf, init_pars, par_bounds): r""" @@ -29,10 +29,10 @@ def qmu(mu, data, pdf, init_pars, par_bounds): Float: The calculated test statistic, :math:`q_{\mu}` """ tensorlib, optimizer = get_backend() - mubhathat, fixed_val = fixed_poi_mle( + mubhathat, fixed_val = fixed_poi_fit( mu, data, pdf, init_pars, par_bounds,return_fval = True ) - muhatbhat, float_val = floating_poi_mle( + muhatbhat, float_val = fit( data, pdf, init_pars, par_bounds, return_fval = True ) qmu = fixed_val - float_val diff --git a/src/pyhf/infer/utils.py b/src/pyhf/infer/utils.py index d6eae7d806..ca441716ec 100644 --- a/src/pyhf/infer/utils.py +++ b/src/pyhf/infer/utils.py @@ -1,8 +1,8 @@ from .. import get_backend -from .mle import fixed_poi_mle,floating_poi_mle +from .mle import fixed_poi_fit def generate_asimov_data(asimov_mu, data, pdf, init_pars, par_bounds): - bestfit_nuisance_asimov = fixed_poi_mle( + bestfit_nuisance_asimov = fixed_poi_fit( asimov_mu, data, pdf, init_pars, par_bounds ) return pdf.expected_data(bestfit_nuisance_asimov) From 50ae5dcc573a5da8155b7ae2a671ff3390ce6713 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 11:48:50 +0100 Subject: [PATCH 05/72] remove example dir --- src/pyhf/infer/mle.py | 36 ++++++++++++++----------------- src/pyhf/infer/test_statistics.py | 9 ++++---- src/pyhf/infer/utils.py | 5 ++--- src/pyhf/optimize/autodiff.py | 19 ++++++++++++---- src/pyhf/optimize/opt_minuit.py | 19 +++++++++++----- src/pyhf/optimize/opt_scipy.py | 12 +++++++++-- 6 files changed, 61 insertions(+), 39 deletions(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 6db3c2fbb3..1eac0fab21 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -3,32 +3,28 @@ """ from .. import get_backend + def loglambdav(pars, data, pdf): return -2 * pdf.logpdf(pars, data) -def fit(data, pdf, init_pars = None, par_bounds = None, **kwargs): - _,opt = get_backend() + +def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): + _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() - return opt.minimize( - loglambdav, - data, - pdf, - init_pars, - par_bounds, - **kwargs - ) + return opt.minimize(loglambdav, data, pdf, init_pars, par_bounds, **kwargs) + -def fixed_poi_fit(constrained_mu, data, pdf, init_pars = None, par_bounds = None, **kwargs): - _,opt = get_backend() +def fixed_poi_fit(constrained_mu, data, pdf, init_pars=None, par_bounds=None, **kwargs): + _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() return opt.minimize( - loglambdav, - data, - pdf, - init_pars, - par_bounds, - [(pdf.config.poi_index, constrained_mu)], - **kwargs - ) \ No newline at end of file + loglambdav, + data, + pdf, + init_pars, + par_bounds, + [(pdf.config.poi_index, constrained_mu)], + **kwargs + ) diff --git a/src/pyhf/infer/test_statistics.py b/src/pyhf/infer/test_statistics.py index c14a44dca8..ca5647ba75 100644 --- a/src/pyhf/infer/test_statistics.py +++ b/src/pyhf/infer/test_statistics.py @@ -1,5 +1,6 @@ from .. import get_backend -from .mle import fixed_poi_fit,fit +from .mle import fixed_poi_fit, fit + def qmu(mu, data, pdf, init_pars, par_bounds): r""" @@ -30,11 +31,9 @@ def qmu(mu, data, pdf, init_pars, par_bounds): """ tensorlib, optimizer = get_backend() mubhathat, fixed_val = fixed_poi_fit( - mu, data, pdf, init_pars, par_bounds,return_fval = True - ) - muhatbhat, float_val = fit( - data, pdf, init_pars, par_bounds, return_fval = True + mu, data, pdf, init_pars, par_bounds, return_fval=True ) + muhatbhat, float_val = fit(data, pdf, init_pars, par_bounds, return_fval=True) qmu = fixed_val - float_val qmu = tensorlib.where( muhatbhat[pdf.config.poi_index] > mu, tensorlib.astensor([0]), qmu diff --git a/src/pyhf/infer/utils.py b/src/pyhf/infer/utils.py index ca441716ec..5fdb598192 100644 --- a/src/pyhf/infer/utils.py +++ b/src/pyhf/infer/utils.py @@ -1,10 +1,9 @@ from .. import get_backend from .mle import fixed_poi_fit + def generate_asimov_data(asimov_mu, data, pdf, init_pars, par_bounds): - bestfit_nuisance_asimov = fixed_poi_fit( - asimov_mu, data, pdf, init_pars, par_bounds - ) + bestfit_nuisance_asimov = fixed_poi_fit(asimov_mu, data, pdf, init_pars, par_bounds) return pdf.expected_data(bestfit_nuisance_asimov) diff --git a/src/pyhf/optimize/autodiff.py b/src/pyhf/optimize/autodiff.py index 3b6bce5903..acaff748b1 100644 --- a/src/pyhf/optimize/autodiff.py +++ b/src/pyhf/optimize/autodiff.py @@ -3,7 +3,16 @@ class AutoDiffOptimizerMixin(object): - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None,return_fval = False): + def minimize( + self, + objective, + data, + pdf, + init_pars, + par_bounds, + fixed_vals=None, + return_fval=False, + ): tensorlib, _ = get_backend() tv, fixed_values_tensor, func, init, bounds = self.setup_minimize( objective, data, pdf, init_pars, par_bounds, fixed_vals @@ -13,7 +22,9 @@ def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, ) nonfixed_vals = fitresult.x fitted_fval = fitresult.fun - fitted_pars = tv.stitch([fixed_values_tensor, tensorlib.astensor(nonfixed_vals)]) + fitted_pars = tv.stitch( + [fixed_values_tensor, tensorlib.astensor(nonfixed_vals)] + ) if return_fval: - return fitted_pars,tensorlib.astensor(fitted_fval) - return fitted_pars + return fitted_pars, tensorlib.astensor(fitted_fval) + return fitted_pars diff --git a/src/pyhf/optimize/opt_minuit.py b/src/pyhf/optimize/opt_minuit.py index 892e379202..29c874d36c 100644 --- a/src/pyhf/optimize/opt_minuit.py +++ b/src/pyhf/optimize/opt_minuit.py @@ -45,16 +45,25 @@ def f(pars): ) return mm - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, return_fval = False, return_uncertainties = False): + def minimize( + self, + objective, + data, + pdf, + init_pars, + par_bounds, + fixed_vals=None, + return_fval=False, + return_uncertainties=False, + ): mm = self._make_minuit(objective, data, pdf, init_pars, par_bounds, fixed_vals) result = mm.migrad(ncall=self.ncall) assert result if return_uncertainties: - bestfit_pars = np.asarray([(v,mm.errors[k]) for k,v in mm.values.items()]) + bestfit_pars = np.asarray([(v, mm.errors[k]) for k, v in mm.values.items()]) else: - bestfit_pars = np.asarray([v for k,v in mm.values.items()]) + bestfit_pars = np.asarray([v for k, v in mm.values.items()]) bestfit_value = mm.fval if return_fval: - return bestfit_pars,bestfit_value + return bestfit_pars, bestfit_value return bestfit_pars - diff --git a/src/pyhf/optimize/opt_scipy.py b/src/pyhf/optimize/opt_scipy.py index b454653b9d..f9e4f8360e 100644 --- a/src/pyhf/optimize/opt_scipy.py +++ b/src/pyhf/optimize/opt_scipy.py @@ -8,7 +8,16 @@ class scipy_optimizer(object): def __init__(self, **kwargs): self.maxiter = kwargs.get('maxiter', 100000) - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, return_fval = False): + def minimize( + self, + objective, + data, + pdf, + init_pars, + par_bounds, + fixed_vals=None, + return_fval=False, + ): fixed_vals = fixed_vals or [] indices = [i for i, _ in fixed_vals] values = [v for _, v in fixed_vals] @@ -30,4 +39,3 @@ def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, if return_fval: return result.x, result.fun return result.x - From 8c47be58f64975cc3ae808f63e8adb045bd5e4f2 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 13:21:22 +0100 Subject: [PATCH 06/72] remove example dir --- tests/test_optim.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/tests/test_optim.py b/tests/test_optim.py index a734b3e6a4..d611f56cfe 100644 --- a/tests/test_optim.py +++ b/tests/test_optim.py @@ -67,13 +67,15 @@ def test_optim(backend, source, spec, mu): optim = pyhf.optimizer - result = optim.minimize( - pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds - ) + result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) assert pyhf.tensorlib.tolist(result) result = optim.minimize( - pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds, - [(pdf.config.poi_index,mu)] + pyhf.infer.mle.loglambdav, + data, + pdf, + init_pars, + par_bounds, + [(pdf.config.poi_index, mu)], ) assert pyhf.tensorlib.tolist(result) From 0211808cab7f0303c2cc3429923b870efe9eee11 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 13:54:20 +0100 Subject: [PATCH 07/72] adapt notebook --- docs/examples/notebooks/ImpactPlot.ipynb | 56 +++++++------------ docs/examples/notebooks/ShapeFactor.ipynb | 5 +- .../binderexample/StatisticalAnalysis.ipynb | 5 +- docs/examples/notebooks/multiBinPois.ipynb | 4 +- 4 files changed, 26 insertions(+), 44 deletions(-) diff --git a/docs/examples/notebooks/ImpactPlot.ipynb b/docs/examples/notebooks/ImpactPlot.ipynb index ee89da38c0..c08b5ce1e5 100644 --- a/docs/examples/notebooks/ImpactPlot.ipynb +++ b/docs/examples/notebooks/ImpactPlot.ipynb @@ -30,10 +30,7 @@ { "name": "stdout", "output_type": "stream", - "text": [ - "RegionA/BkgOnly.json\n", - "RegionA/patch.sbottom_750_745_60.json\n" - ] + "text": "x RegionA/BkgOnly.json\nx RegionA/patch.sbottom_750_745_60.json\n" } ], "source": [ @@ -82,18 +79,14 @@ " _, model, data = make_model([\"CRtt_meff\"])\n", "\n", " pyhf.set_backend(\"numpy\", pyhf.optimize.minuit_optimizer(verbose=True))\n", - " minuit = pyhf.optimizer._make_minuit(\n", - " pyhf.infer.utils.loglambdav,\n", + " result = pyhf.infer.mle.fit(\n", " data,\n", " model,\n", - " model.config.suggested_init(),\n", - " model.config.suggested_bounds(),\n", - " constraints,\n", + " fixed_vals = constraints,\n", + " return_uncertainties = True\n", " )\n", - " result = minuit.migrad(ncall=100000)\n", - " bestfit = pyhf.tensorlib.astensor([x[1] for x in minuit.values.items()])\n", - " errors = pyhf.tensorlib.astensor([x[1] for x in minuit.errors.items()])\n", - "\n", + " bestfit = result[:,0]\n", + " errors = result[:,1]\n", " return model, data, bestfit, errors" ] }, @@ -173,27 +166,12 @@ { "cell_type": "code", "execution_count": 7, - "metadata": { - "scrolled": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", - "text": [ - "0\n", - "5\n", - "10\n", - "15\n", - "20\n", - "25\n", - "30\n", - "35\n", - "40\n", - "45\n", - "50\n", - "55\n" - ] + "text": "0\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/tensor/numpy_backend.py:252: RuntimeWarning: invalid value encountered in log\n return n * np.log(lam) - lam - gammaln(n + 1.0)\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4p.py:57: RuntimeWarning: invalid value encountered in greater\n alphasets > 1, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4p.py:61: RuntimeWarning: invalid value encountered in less\n alphasets < -1, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4.py:171: RuntimeWarning: invalid value encountered in greater_equal\n alphasets >= self.__alpha0, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4.py:182: RuntimeWarning: invalid value encountered in greater\n alphasets > -self.__alpha0, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4.py:201: RuntimeWarning: invalid value encountered in greater_equal\n exponents >= self.__alpha0, exponents, self.ones\n10\n15\n20\n25\n30\n35\n40\n45\n50\n55\n" } ], "source": [ @@ -225,10 +203,9 @@ "outputs": [ { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "image/png": "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\n", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "text/plain": "
" }, "metadata": { "needs_background": "light" @@ -274,6 +251,13 @@ "plt.yticks(range(len(slabels)), slabels)\n", "plt.grid();" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -292,9 +276,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.5" + "version": "3.6.6" } }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file diff --git a/docs/examples/notebooks/ShapeFactor.ipynb b/docs/examples/notebooks/ShapeFactor.ipynb index 1eab8aad56..502c653a4a 100644 --- a/docs/examples/notebooks/ShapeFactor.ipynb +++ b/docs/examples/notebooks/ShapeFactor.ipynb @@ -181,8 +181,7 @@ "source": [ "print('initialization parameters: {}'.format(pdf.config.suggested_init()))\n", "\n", - "unconpars = pyhf.optimizer.unconstrained_bestfit(pyhf.infer.utils.loglambdav, data, pdf,\n", - " pdf.config.suggested_init(), pdf.config.suggested_bounds())\n", + "unconpars = pyhf.infer.mle(data, pdf)\n", "print('parameters post unconstrained fit: {}'.format(unconpars))" ] }, @@ -284,4 +283,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file diff --git a/docs/examples/notebooks/binderexample/StatisticalAnalysis.ipynb b/docs/examples/notebooks/binderexample/StatisticalAnalysis.ipynb index 6b8c5c09e1..aac70b0468 100644 --- a/docs/examples/notebooks/binderexample/StatisticalAnalysis.ipynb +++ b/docs/examples/notebooks/binderexample/StatisticalAnalysis.ipynb @@ -1072,8 +1072,7 @@ "nominal = pdf.config.suggested_init()\n", "background_only = pdf.config.suggested_init()\n", "background_only[pdf.config.poi_index] = 0.0\n", - "best_fit = pyhf.optimizer.unconstrained_bestfit(\n", - " pyhf.infer.utils.loglambdav, data, pdf, pdf.config.suggested_init(), pdf.config.suggested_bounds())" + "best_fit = pyhf.infer.mle.fit(data, pdf)" ] }, { @@ -9051,4 +9050,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file diff --git a/docs/examples/notebooks/multiBinPois.ipynb b/docs/examples/notebooks/multiBinPois.ipynb index ab43a30a88..7f7fd744b2 100644 --- a/docs/examples/notebooks/multiBinPois.ipynb +++ b/docs/examples/notebooks/multiBinPois.ipynb @@ -200,7 +200,7 @@ "\n", "print(init_pars)\n", "\n", - "bestfit_pars = optimizer.unconstrained_bestfit(pyhf.infer.utils.loglambdav, data, pdf, init_pars, par_bounds)\n", + "bestfit_pars = optimizer.infer.mle(data, pdf, init_pars, par_bounds)\n", "bestfit_cts = pdf.expected_data(bestfit_pars, include_auxdata = False)" ] }, @@ -371,4 +371,4 @@ }, "nbformat": 4, "nbformat_minor": 1 -} +} \ No newline at end of file From bb315db1d1f5d169bc1b6b944968cbe40c56e4ac Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 13:55:58 +0100 Subject: [PATCH 08/72] adapt notebooks --- docs/examples/notebooks/pullplot.ipynb | 111 +++++++++++++------------ 1 file changed, 56 insertions(+), 55 deletions(-) diff --git a/docs/examples/notebooks/pullplot.ipynb b/docs/examples/notebooks/pullplot.ipynb index 7c4a922821..cb9d6c22a9 100644 --- a/docs/examples/notebooks/pullplot.ipynb +++ b/docs/examples/notebooks/pullplot.ipynb @@ -1,10 +1,6 @@ { "cells": [ { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], "source": [ "import pyhf\n", "import json\n", @@ -12,24 +8,26 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline" - ] + ], + "cell_type": "code", + "outputs": [], + "metadata": {}, + "execution_count": 1 }, { + "source": [ + "!curl -sL https://doi.org/10.17182/hepdata.89408.v1/r2 | tar -O -xzv RegionA/BkgOnly.json > lhood.json" + ], "cell_type": "code", - "execution_count": 2, - "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", - "text": [ - "RegionA/BkgOnly.json\r\n" - ] + "name": "stdout", + "text": "x RegionA/BkgOnly.json\n" } ], - "source": [ - "!curl -sL https://doi.org/10.17182/hepdata.89408.v1/r2 | tar -O -xzv RegionA/BkgOnly.json > lhood.json" - ] + "metadata": {}, + "execution_count": 2 }, { "cell_type": "markdown", @@ -39,10 +37,6 @@ ] }, { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], "source": [ "def make_model(channel_list):\n", " spec = json.load(open(\"lhood.json\"))\n", @@ -62,27 +56,28 @@ " return w, m, d\n", "\n", "\n", - "def fitresults():\n", - " w, m, d = make_model([\"CRtt_meff\"])\n", - " d = w.data(m)\n", + "def fitresults(constraints=None):\n", + " _, model, data = make_model([\"CRtt_meff\"])\n", "\n", " pyhf.set_backend(\"numpy\", pyhf.optimize.minuit_optimizer(verbose=True))\n", - " minuit = pyhf.optimizer._make_minuit(\n", - " pyhf.infer.utils.loglambdav,\n", - " d,\n", - " m,\n", - " m.config.suggested_init(),\n", - " m.config.suggested_bounds(),\n", + " result = pyhf.infer.mle.fit(\n", + " data,\n", + " model,\n", + " fixed_vals = constraints,\n", + " return_uncertainties = True\n", " )\n", - " result = minuit.migrad(ncall=100000)\n", - " bestfit = pyhf.tensorlib.astensor([x[1] for x in minuit.values.items()])\n", - " errors = pyhf.tensorlib.astensor([x[1] for x in minuit.errors.items()])\n", + " bestfit = result[:,0]\n", + " errors = result[:,1]\n", + " return model, data, bestfit, errors\n", "\n", - " return m, d, bestfit, errors\n", "\n", "\n", "m, data, bestfit, errors = fitresults()" - ] + ], + "cell_type": "code", + "outputs": [], + "metadata": {}, + "execution_count": 3 }, { "cell_type": "markdown", @@ -92,10 +87,6 @@ ] }, { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], "source": [ "pulls = pyhf.tensorlib.concatenate(\n", " [\n", @@ -127,26 +118,20 @@ "labels = labels[order]\n", "pulls = pulls[order]\n", "pullerr = pullerr[order]" - ] + ], + "cell_type": "code", + "outputs": [], + "metadata": {}, + "execution_count": 4 }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], + "source": [] + }, + { "source": [ "plt.hlines([-2, 2], -0.5, len(pulls) - 0.5, colors=\"k\", linestyles=\"dotted\")\n", "plt.hlines([-1, 1], -0.5, len(pulls) - 0.5, colors=\"k\", linestyles=\"dashdot\")\n", @@ -162,7 +147,23 @@ "plt.xlim(-0.5, len(pulls) - 0.5)\n", "plt.title(\"Pull Plot\", fontsize=18)\n", "plt.ylabel(r\"$(\\theta - \\hat{\\theta})\\,/ \\Delta \\theta$\", fontsize=18);" - ] + ], + "cell_type": "code", + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "metadata": {}, + "execution_count": 5 } ], "metadata": { @@ -181,9 +182,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.5" + "version": "3.6.6" } }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file From 7b871420e2bec8c27d0e5343fb86ca1fe05163fb Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 13:57:17 +0100 Subject: [PATCH 09/72] adapt notebooks --- .../multichannel-coupled-histo.ipynb | 46 ++++++------------- 1 file changed, 13 insertions(+), 33 deletions(-) diff --git a/docs/examples/notebooks/multichannel-coupled-histo.ipynb b/docs/examples/notebooks/multichannel-coupled-histo.ipynb index 98776b5f95..7061864644 100644 --- a/docs/examples/notebooks/multichannel-coupled-histo.ipynb +++ b/docs/examples/notebooks/multichannel-coupled-histo.ipynb @@ -127,39 +127,19 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": { - "scrolled": false - }, + "execution_count": 1, + "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pyhf.pdf:Validating spec against schema: /home/jovyan/pyhf/src/pyhf/data/spec.json\n", - "INFO:pyhf.pdf:adding modifier mu (1 new nuisance parameters)\n", - "INFO:pyhf.pdf:adding modifier coupled_histosys (1 new nuisance parameters)\n" + "ename": "NameError", + "evalue": "name 'json' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msource\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalidation_datadir\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'/2bin_2channel_coupledhisto.json'\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 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprep_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msource\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'channels'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'json' is not defined" ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[170.0, 220.0, 110.0, 105.0, 0.0]\n", - "parameters post unconstrained fit: [1.05563069e-12 4.00000334e+00]\n", - "parameters post constrained fit: [0. 4.00000146]\n" - ] - }, - { - "data": { - "text/plain": [ - "array([ 1.25000007e+02, 1.60000022e+02, 2.10000022e+02, -8.00631284e-05,\n", - " 4.00000146e+00])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -172,10 +152,10 @@ "init_pars = pdf.config.suggested_init()\n", "par_bounds = pdf.config.suggested_bounds()\n", "\n", - "unconpars = pyhf.optimizer.unconstrained_bestfit(pyhf.infer.utils.loglambdav, data, pdf, init_pars, par_bounds)\n", + "unconpars = pyhf.infer.mle.fit(data, pdf, init_pars, par_bounds)\n", "print('parameters post unconstrained fit: {}'.format(unconpars))\n", "\n", - "conpars = pyhf.optimizer.constrained_bestfit(pyhf.infer.utils.loglambdav, 0.0, data, pdf, init_pars, par_bounds)\n", + "conpars = pyhf.infer.mle.fixed_poi_fit(0.0, data, pdf, init_pars, par_bounds)\n", "print('parameters post constrained fit: {}'.format(conpars))\n", "\n", "pdf.expected_data(conpars)" @@ -291,4 +271,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file From bec1b14e27e3dd893927df184bc272730817f419 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 14:48:09 +0100 Subject: [PATCH 10/72] adapt notebooks --- docs/examples/notebooks/ShapeFactor.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/examples/notebooks/ShapeFactor.ipynb b/docs/examples/notebooks/ShapeFactor.ipynb index 502c653a4a..3cf4d823db 100644 --- a/docs/examples/notebooks/ShapeFactor.ipynb +++ b/docs/examples/notebooks/ShapeFactor.ipynb @@ -181,7 +181,7 @@ "source": [ "print('initialization parameters: {}'.format(pdf.config.suggested_init()))\n", "\n", - "unconpars = pyhf.infer.mle(data, pdf)\n", + "unconpars = pyhf.infer.mle.fit(data, pdf)\n", "print('parameters post unconstrained fit: {}'.format(unconpars))" ] }, From fe82b4632c471e7087131388288b37e7b8c052cc Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 14:59:03 +0100 Subject: [PATCH 11/72] adapt notebooks --- docs/examples/notebooks/multiBinPois.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/examples/notebooks/multiBinPois.ipynb b/docs/examples/notebooks/multiBinPois.ipynb index 7f7fd744b2..225660f45f 100644 --- a/docs/examples/notebooks/multiBinPois.ipynb +++ b/docs/examples/notebooks/multiBinPois.ipynb @@ -200,7 +200,7 @@ "\n", "print(init_pars)\n", "\n", - "bestfit_pars = optimizer.infer.mle(data, pdf, init_pars, par_bounds)\n", + "bestfit_pars = pyhf.infer.mle.fit(data, pdf, init_pars, par_bounds)\n", "bestfit_cts = pdf.expected_data(bestfit_pars, include_auxdata = False)" ] }, From 55f7e439f970cb0f52957ff7e1c5246b2d0a026c Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 17:02:48 +0100 Subject: [PATCH 12/72] adapt notebooks --- docs/api.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/api.rst b/docs/api.rst index 41c887ec61..a3b366aca1 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -119,7 +119,7 @@ Inference hypotest test_statistics.qmu - utils.loglambdav + mle.loglambdav utils.generate_asimov_data utils.pvals_from_teststat utils.pvals_from_teststat_expected From 628cf510515d37533827883d1cd7cb9991e92e50 Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Mon, 16 Dec 2019 11:52:28 -0600 Subject: [PATCH 13/72] Try: Allow coverage drop of up to 0.2% c.f. https://community.codecov.io/t/threshold-confusion/88/10 --- codecov.yml | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 codecov.yml diff --git a/codecov.yml b/codecov.yml new file mode 100644 index 0000000000..914f860929 --- /dev/null +++ b/codecov.yml @@ -0,0 +1,5 @@ +coverage: + status: + project: + default: + threshold: 0.2% From 4567aa82acd46dfdf474b73ea720a083c18a4ec1 Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Mon, 16 Dec 2019 11:58:00 -0600 Subject: [PATCH 14/72] Add codecov.yml to MANIFEST ignore --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index c5009fc4b0..5b92b1a54f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,6 +28,7 @@ ignore = [ '.*', 'pyproject.toml', 'pytest.ini', + 'codecov.yml', 'CODE_OF_CONDUCT.md', 'CONTRIBUTING.md', ] From 0e10a158c08c1e659b61696abdc4317af57a45e4 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 19:42:16 +0100 Subject: [PATCH 15/72] coverage --- tests/test_optim.py | 50 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/tests/test_optim.py b/tests/test_optim.py index d611f56cfe..a729587b0e 100644 --- a/tests/test_optim.py +++ b/tests/test_optim.py @@ -79,3 +79,53 @@ def test_optim(backend, source, spec, mu): [(pdf.config.poi_index, mu)], ) assert pyhf.tensorlib.tolist(result) + +@pytest.mark.parametrize('mu', [1.0], ids=['mu=1']) +def test_optim_with_value(backend, source, spec, mu): + pdf = pyhf.Model(spec) + data = source['bindata']['data'] + pdf.config.auxdata + + init_pars = pdf.config.suggested_init() + par_bounds = pdf.config.suggested_bounds() + + optim = pyhf.optimizer + + result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) + assert pyhf.tensorlib.tolist(result) + + result,fval = optim.minimize( + pyhf.infer.mle.loglambdav, + data, + pdf, + init_pars, + par_bounds, + [(pdf.config.poi_index, mu)], + return_fval=True + ) + assert pyhf.tensorlib.tolist(result) + +@pytest.mark.parametrize('mu', [1.0], ids=['mu=1']) +@pytest.mark.only_numpy_minuit +def test_optim_uncerts(backend, source, spec, mu): + pdf = pyhf.Model(spec) + data = source['bindata']['data'] + pdf.config.auxdata + + init_pars = pdf.config.suggested_init() + par_bounds = pdf.config.suggested_bounds() + + optim = pyhf.optimizer + + result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) + assert pyhf.tensorlib.tolist(result) + + result = optim.minimize( + pyhf.infer.mle.loglambdav, + data, + pdf, + init_pars, + par_bounds, + [(pdf.config.poi_index, mu)], + return_uncertainties = True + ) + assert result.shape[1] == 2 + assert pyhf.tensorlib.tolist(result) From 554c1a263cec56c406fd299ecd7970ad4c77dbba Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 19:42:23 +0100 Subject: [PATCH 16/72] coverage --- tests/test_optim.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/tests/test_optim.py b/tests/test_optim.py index a729587b0e..5b8aa48729 100644 --- a/tests/test_optim.py +++ b/tests/test_optim.py @@ -80,6 +80,7 @@ def test_optim(backend, source, spec, mu): ) assert pyhf.tensorlib.tolist(result) + @pytest.mark.parametrize('mu', [1.0], ids=['mu=1']) def test_optim_with_value(backend, source, spec, mu): pdf = pyhf.Model(spec) @@ -93,17 +94,18 @@ def test_optim_with_value(backend, source, spec, mu): result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) assert pyhf.tensorlib.tolist(result) - result,fval = optim.minimize( + result, fval = optim.minimize( pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds, [(pdf.config.poi_index, mu)], - return_fval=True + return_fval=True, ) assert pyhf.tensorlib.tolist(result) + @pytest.mark.parametrize('mu', [1.0], ids=['mu=1']) @pytest.mark.only_numpy_minuit def test_optim_uncerts(backend, source, spec, mu): @@ -125,7 +127,7 @@ def test_optim_uncerts(backend, source, spec, mu): init_pars, par_bounds, [(pdf.config.poi_index, mu)], - return_uncertainties = True + return_uncertainties=True, ) - assert result.shape[1] == 2 + assert result.shape[1] == 2 assert pyhf.tensorlib.tolist(result) From 0757a723ca9fa389b9696b90d798413693d171aa Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Mon, 16 Dec 2019 16:08:11 -0600 Subject: [PATCH 17/72] Black notebook cells and remove empty cell --- docs/examples/notebooks/ImpactPlot.ipynb | 38 ++++++++++++++---------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/docs/examples/notebooks/ImpactPlot.ipynb b/docs/examples/notebooks/ImpactPlot.ipynb index c08b5ce1e5..f0d3be0c0e 100644 --- a/docs/examples/notebooks/ImpactPlot.ipynb +++ b/docs/examples/notebooks/ImpactPlot.ipynb @@ -30,7 +30,10 @@ { "name": "stdout", "output_type": "stream", - "text": "x RegionA/BkgOnly.json\nx RegionA/patch.sbottom_750_745_60.json\n" + "text": [ + "x RegionA/BkgOnly.json\n", + "x RegionA/patch.sbottom_750_745_60.json\n" + ] } ], "source": [ @@ -80,13 +83,10 @@ "\n", " pyhf.set_backend(\"numpy\", pyhf.optimize.minuit_optimizer(verbose=True))\n", " result = pyhf.infer.mle.fit(\n", - " data,\n", - " model,\n", - " fixed_vals = constraints,\n", - " return_uncertainties = True\n", + " data, model, fixed_vals=constraints, return_uncertainties=True\n", " )\n", - " bestfit = result[:,0]\n", - " errors = result[:,1]\n", + " bestfit = result[:, 0]\n", + " errors = result[:, 1]\n", " return model, data, bestfit, errors" ] }, @@ -171,7 +171,20 @@ { "name": "stdout", "output_type": "stream", - "text": "0\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/tensor/numpy_backend.py:252: RuntimeWarning: invalid value encountered in log\n return n * np.log(lam) - lam - gammaln(n + 1.0)\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4p.py:57: RuntimeWarning: invalid value encountered in greater\n alphasets > 1, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4p.py:61: RuntimeWarning: invalid value encountered in less\n alphasets < -1, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4.py:171: RuntimeWarning: invalid value encountered in greater_equal\n alphasets >= self.__alpha0, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4.py:182: RuntimeWarning: invalid value encountered in greater\n alphasets > -self.__alpha0, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4.py:201: RuntimeWarning: invalid value encountered in greater_equal\n exponents >= self.__alpha0, exponents, self.ones\n10\n15\n20\n25\n30\n35\n40\n45\n50\n55\n" + "text": [ + "0\n", + "5\n", + "10\n", + "15\n", + "20\n", + "25\n", + "30\n", + "35\n", + "40\n", + "45\n", + "50\n", + "55\n" + ] } ], "source": [ @@ -251,13 +264,6 @@ "plt.yticks(range(len(slabels)), slabels)\n", "plt.grid();" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -281,4 +287,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} From 6145a6be92b7bad0eacae60c6c19d6e4e1675d67 Mon Sep 17 00:00:00 2001 From: Lukas Date: Tue, 17 Dec 2019 02:10:43 +0100 Subject: [PATCH 18/72] Update src/pyhf/infer/mle.py Co-Authored-By: Giordon Stark --- src/pyhf/infer/mle.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 1eac0fab21..728e892672 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -15,7 +15,7 @@ def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): return opt.minimize(loglambdav, data, pdf, init_pars, par_bounds, **kwargs) -def fixed_poi_fit(constrained_mu, data, pdf, init_pars=None, par_bounds=None, **kwargs): +def fixed_poi_fit(poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None **kwargs): _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() From 482103e4208371835486782d284cf75cf1dd7800 Mon Sep 17 00:00:00 2001 From: Lukas Date: Tue, 17 Dec 2019 02:11:49 +0100 Subject: [PATCH 19/72] Update mle.py --- src/pyhf/infer/mle.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 728e892672..06d9093b00 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -25,6 +25,6 @@ def fixed_poi_fit(poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index pdf, init_pars, par_bounds, - [(pdf.config.poi_index, constrained_mu)], + [(pdf.config.poi_index, poi_val)], **kwargs ) From 82618973461773fb1b49286874df95d2595c82a1 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Tue, 17 Dec 2019 03:07:56 +0100 Subject: [PATCH 20/72] fix --- src/pyhf/infer/mle.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 06d9093b00..8a59eb6ed9 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -15,7 +15,7 @@ def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): return opt.minimize(loglambdav, data, pdf, init_pars, par_bounds, **kwargs) -def fixed_poi_fit(poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None **kwargs): +def fixed_poi_fit(poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None, **kwargs): _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() From 3303a6bb199a67dc0710a494b90b664270ecb8ac Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Tue, 17 Dec 2019 03:48:17 +0100 Subject: [PATCH 21/72] fix --- src/pyhf/infer/mle.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 8a59eb6ed9..1db0fd2990 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -15,7 +15,9 @@ def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): return opt.minimize(loglambdav, data, pdf, init_pars, par_bounds, **kwargs) -def fixed_poi_fit(poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None, **kwargs): +def fixed_poi_fit( + poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None, **kwargs +): _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() From be33c3065e57fc0c22e7521eca7f6c8d5a5f166e Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Tue, 17 Dec 2019 17:31:38 +0100 Subject: [PATCH 22/72] add docstrings --- src/pyhf/infer/mle.py | 45 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 39 insertions(+), 6 deletions(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 1db0fd2990..c842a16614 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -1,28 +1,61 @@ -""" -Module for Maximum Likelihood Estimation -""" +"""Module for Maximum Likelihood Estimation.""" from .. import get_backend -def loglambdav(pars, data, pdf): +def twice_nll(pars, data, pdf): + """ + Twice the negative Log-Likelihood. + + Args: + data (`tensor`): the data + pdf (`pyhf.Model`): the statistical model + + Returns: + Twice the negative log likelihood. + + """ return -2 * pdf.logpdf(pars, data) def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): + """ + Run a unconstrained maximum likelihood fit. + + Args: + data (`tensor`): the data + pdf (`pyhf.Model`): the statistical model + kwargs: keyword arguments passed through to the optimizer API + + Returns: + see optimizer API + + """ _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() - return opt.minimize(loglambdav, data, pdf, init_pars, par_bounds, **kwargs) + return opt.minimize(twice_nll, data, pdf, init_pars, par_bounds, **kwargs) def fixed_poi_fit( poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None, **kwargs ): + """ + Run a maximum likelihood fit with the POI value fixzed. + + Args: + data: the data + pdf (`pyhf.Model`): the statistical model + kwargs: keyword arguments passed through to the optimizer API + + Returns: + see optimizer API + + """ _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() return opt.minimize( - loglambdav, + twice_nll, data, pdf, init_pars, From d263c88555942b3326179deb1638170bac475a5e Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Tue, 17 Dec 2019 17:31:55 +0100 Subject: [PATCH 23/72] add docstrings --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 23a1c53d47..81722b3b7c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -99,7 +99,7 @@ jobs: - name: Check docstrings run: | # Group 1 is related to docstrings - pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py + pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/mle.py - name: Test and build docs run: | python -m doctest README.md From 6b8e14ac49ce98940122ca6e9a092ec59e1cadf7 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Tue, 17 Dec 2019 22:18:40 +0100 Subject: [PATCH 24/72] add docstrings --- .github/workflows/ci.yml | 2 +- src/pyhf/optimize/__init__.py | 2 ++ src/pyhf/optimize/autodiff.py | 10 ++++++++++ src/pyhf/optimize/opt_minuit.py | 18 ++++++++++++++++++ src/pyhf/optimize/opt_pytorch.py | 17 +++++++++++++++-- src/pyhf/optimize/opt_scipy.py | 12 ++++++++++++ src/pyhf/optimize/opt_tflow.py | 22 +++++++++++++++++----- 7 files changed, 75 insertions(+), 8 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 81722b3b7c..f1df186a70 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -99,7 +99,7 @@ jobs: - name: Check docstrings run: | # Group 1 is related to docstrings - pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/mle.py + pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/mle.py src/pyhf/optimize - name: Test and build docs run: | python -m doctest README.md diff --git a/src/pyhf/optimize/__init__.py b/src/pyhf/optimize/__init__.py index c3169eb4b8..f61150f949 100644 --- a/src/pyhf/optimize/__init__.py +++ b/src/pyhf/optimize/__init__.py @@ -1,3 +1,5 @@ +"""Optimizers for Tensor Functions.""" + from .. import exceptions diff --git a/src/pyhf/optimize/autodiff.py b/src/pyhf/optimize/autodiff.py index acaff748b1..ae97da5584 100644 --- a/src/pyhf/optimize/autodiff.py +++ b/src/pyhf/optimize/autodiff.py @@ -1,8 +1,11 @@ +"""Helper Classes for use of automatic differentiation.""" import scipy from .. import get_backend class AutoDiffOptimizerMixin(object): + """Mixin Class to build optimizers that use automatic differentiation.""" + def minimize( self, objective, @@ -13,6 +16,13 @@ def minimize( fixed_vals=None, return_fval=False, ): + """ + Find Function Parameters that minimize the Objective. + + Returns: + bestfit parameters + + """ tensorlib, _ = get_backend() tv, fixed_values_tensor, func, init, bounds = self.setup_minimize( objective, data, pdf, init_pars, par_bounds, fixed_vals diff --git a/src/pyhf/optimize/opt_minuit.py b/src/pyhf/optimize/opt_minuit.py index 29c874d36c..62f3bd38f9 100644 --- a/src/pyhf/optimize/opt_minuit.py +++ b/src/pyhf/optimize/opt_minuit.py @@ -1,3 +1,5 @@ +"""MINUIT Optimizer Backend.""" + import iminuit import logging import numpy as np @@ -6,7 +8,16 @@ class minuit_optimizer(object): + """MINUIT Optimizer Backend.""" + def __init__(self, verbose=False, ncall=10000, errordef=1, steps=1000): + """ + Create MINUIT Optimizer. + + Args: + verbose (`bool`): print verbose output during minimization + + """ self.verbose = 0 self.ncall = ncall self.errordef = errordef @@ -56,6 +67,13 @@ def minimize( return_fval=False, return_uncertainties=False, ): + """ + Find Function Parameters that minimize the Objective. + + Returns: + bestfit parameters + + """ mm = self._make_minuit(objective, data, pdf, init_pars, par_bounds, fixed_vals) result = mm.migrad(ncall=self.ncall) assert result diff --git a/src/pyhf/optimize/opt_pytorch.py b/src/pyhf/optimize/opt_pytorch.py index 270b1e643d..869da4489b 100644 --- a/src/pyhf/optimize/opt_pytorch.py +++ b/src/pyhf/optimize/opt_pytorch.py @@ -1,3 +1,5 @@ +"""PyTorch Optimizer Backend.""" + from .. import get_backend, default_backend from ..tensor.common import _TensorViewer from .autodiff import AutoDiffOptimizerMixin @@ -5,12 +7,23 @@ class pytorch_optimizer(AutoDiffOptimizerMixin): - def __init__(self, *args, **kargs): - pass + """PyTorch Optimizer Backend.""" def setup_minimize( self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None ): + """ + Prepare Minimization for AutoDiff-Optimizer. + + Args: + objective: objective function + data: observed data + pdf: model + init_pars: initial parameters + par_bounds: parameter boundaries + fixed_vals: fixed parameter values + + """ tensorlib, _ = get_backend() all_idx = default_backend.astensor(range(pdf.config.npars), dtype='int') all_init = default_backend.astensor(init_pars) diff --git a/src/pyhf/optimize/opt_scipy.py b/src/pyhf/optimize/opt_scipy.py index f9e4f8360e..d2064609f4 100644 --- a/src/pyhf/optimize/opt_scipy.py +++ b/src/pyhf/optimize/opt_scipy.py @@ -1,3 +1,5 @@ +"""scipy.optimize-based Optimizer using finite differences.""" + from scipy.optimize import minimize import logging @@ -5,7 +7,10 @@ class scipy_optimizer(object): + """scipy.optimize-based Optimizer using finite differences.""" + def __init__(self, **kwargs): + """Create scipy.optimize-based Optimizer.""" self.maxiter = kwargs.get('maxiter', 100000) def minimize( @@ -18,6 +23,13 @@ def minimize( fixed_vals=None, return_fval=False, ): + """ + Find Function Parameters that minimize the Objective. + + Returns: + bestfit parameters + + """ fixed_vals = fixed_vals or [] indices = [i for i, _ in fixed_vals] values = [v for _, v in fixed_vals] diff --git a/src/pyhf/optimize/opt_tflow.py b/src/pyhf/optimize/opt_tflow.py index 3ebc7ef7dd..5d29463822 100644 --- a/src/pyhf/optimize/opt_tflow.py +++ b/src/pyhf/optimize/opt_tflow.py @@ -1,10 +1,11 @@ +"""Tensorflow Optimizer Backend.""" from .. import get_backend, default_backend from ..tensor.common import _TensorViewer from .autodiff import AutoDiffOptimizerMixin import tensorflow as tf -def eval_func(op, argop, dataop, data): +def _eval_func(op, argop, dataop, data): def func(pars): tensorlib, _ = get_backend() pars_as_list = tensorlib.tolist(pars) if isinstance(pars, tf.Tensor) else pars @@ -18,12 +19,23 @@ def func(pars): class tflow_optimizer(AutoDiffOptimizerMixin): - def __init__(self, *args, **kargs): - pass - + """Tensorflow Optimizer Backend.""" + def setup_minimize( self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None ): + """ + Prepare Minimization for AutoDiff-Optimizer. + + Args: + objective: objective function + data: observed data + pdf: model + init_pars: initial parameters + par_bounds: parameter boundaries + fixed_vals: fixed parameter values + + """ tensorlib, _ = get_backend() all_idx = default_backend.astensor(range(pdf.config.npars), dtype='int') @@ -53,7 +65,7 @@ def setup_minimize( nll = objective(full_pars, data_placeholder, pdf) nllgrad = tf.identity(tf.gradients(nll, variable_pars_placeholder)[0]) - func = eval_func( + func = _eval_func( [nll, nllgrad], variable_pars_placeholder, data_placeholder, data, ) From 884ba98c92b597970deab0d4e061e8fe2c2dcafd Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Tue, 17 Dec 2019 23:40:32 -0600 Subject: [PATCH 25/72] Apply Black --- src/pyhf/optimize/opt_tflow.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyhf/optimize/opt_tflow.py b/src/pyhf/optimize/opt_tflow.py index 5d29463822..a897d8e3ff 100644 --- a/src/pyhf/optimize/opt_tflow.py +++ b/src/pyhf/optimize/opt_tflow.py @@ -20,7 +20,7 @@ def func(pars): class tflow_optimizer(AutoDiffOptimizerMixin): """Tensorflow Optimizer Backend.""" - + def setup_minimize( self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None ): From 9973b59033687b0b3d10409b0f1c72c50c45170f Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Tue, 17 Dec 2019 23:51:37 -0600 Subject: [PATCH 26/72] Crossreference the Model objects in the docs --- src/pyhf/infer/mle.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index c842a16614..4976b33250 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -5,14 +5,14 @@ def twice_nll(pars, data, pdf): """ Twice the negative Log-Likelihood. - + Args: data (`tensor`): the data - pdf (`pyhf.Model`): the statistical model + pdf (~pyhf.pdf.Model): The statistical model adhering to the schema model.json Returns: Twice the negative log likelihood. - + """ return -2 * pdf.logpdf(pars, data) @@ -20,15 +20,15 @@ def twice_nll(pars, data, pdf): def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): """ Run a unconstrained maximum likelihood fit. - + Args: data (`tensor`): the data - pdf (`pyhf.Model`): the statistical model + pdf (~pyhf.pdf.Model): The statistical model adhering to the schema model.json kwargs: keyword arguments passed through to the optimizer API - + Returns: see optimizer API - + """ _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() @@ -41,15 +41,15 @@ def fixed_poi_fit( ): """ Run a maximum likelihood fit with the POI value fixzed. - + Args: data: the data - pdf (`pyhf.Model`): the statistical model + pdf (~pyhf.pdf.Model): The statistical model adhering to the schema model.json kwargs: keyword arguments passed through to the optimizer API Returns: see optimizer API - + """ _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() From a6c25b2b7626351904591b787089853ab3f7c604 Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Tue, 17 Dec 2019 23:55:20 -0600 Subject: [PATCH 27/72] Add mle functions to the API docs loglambdav is removed as it no longer exists --- docs/api.rst | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/api.rst b/docs/api.rst index a3b366aca1..d2665483f7 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -119,7 +119,9 @@ Inference hypotest test_statistics.qmu - mle.loglambdav + mle.twice_nll + mle.fit + mle.fixed_poi_fit utils.generate_asimov_data utils.pvals_from_teststat utils.pvals_from_teststat_expected From ae4ace51740f66c44341f9835be17667a798d6ae Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Wed, 18 Dec 2019 00:05:41 -0600 Subject: [PATCH 28/72] Fix path for pydocstyle --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f1df186a70..2164e0afbc 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -99,7 +99,7 @@ jobs: - name: Check docstrings run: | # Group 1 is related to docstrings - pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/mle.py src/pyhf/optimize + pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/infer/mle.py src/pyhf/optimize - name: Test and build docs run: | python -m doctest README.md From 1867bac383b7074635928211532be0931857ef4e Mon Sep 17 00:00:00 2001 From: Lukas Date: Wed, 18 Dec 2019 09:17:14 +0100 Subject: [PATCH 29/72] docker: entrypoint (#700) * Add ENTRYPOINT to the pyhf Dockerfile to run the pyhf CLI by default --- docker/Dockerfile | 1 + 1 file changed, 1 insertion(+) diff --git a/docker/Dockerfile b/docker/Dockerfile index f362c36dc0..1861dd4ebb 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -6,3 +6,4 @@ RUN cd /code && \ python -m pip install --upgrade --no-cache-dir pip setuptools wheel && \ python -m pip install --no-cache-dir -e .[xmlio] && \ python -m pip list +ENTRYPOINT ["/usr/local/bin/pyhf"] From 48eebe008c2f0383ec9e8272f2becf31af08f2bb Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Wed, 18 Dec 2019 09:32:36 +0100 Subject: [PATCH 30/72] rename objective --- tests/test_optim.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/test_optim.py b/tests/test_optim.py index 5b8aa48729..df2bc7aaeb 100644 --- a/tests/test_optim.py +++ b/tests/test_optim.py @@ -67,11 +67,11 @@ def test_optim(backend, source, spec, mu): optim = pyhf.optimizer - result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) + result = optim.minimize(pyhf.infer.mle.twice_nll, data, pdf, init_pars, par_bounds) assert pyhf.tensorlib.tolist(result) result = optim.minimize( - pyhf.infer.mle.loglambdav, + pyhf.infer.mle.twice_nll, data, pdf, init_pars, @@ -91,11 +91,11 @@ def test_optim_with_value(backend, source, spec, mu): optim = pyhf.optimizer - result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) + result = optim.minimize(pyhf.infer.mle.twice_nll, data, pdf, init_pars, par_bounds) assert pyhf.tensorlib.tolist(result) result, fval = optim.minimize( - pyhf.infer.mle.loglambdav, + pyhf.infer.mle.twice_nll, data, pdf, init_pars, @@ -117,11 +117,11 @@ def test_optim_uncerts(backend, source, spec, mu): optim = pyhf.optimizer - result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) + result = optim.minimize(pyhf.infer.mle.twice_nll, data, pdf, init_pars, par_bounds) assert pyhf.tensorlib.tolist(result) result = optim.minimize( - pyhf.infer.mle.loglambdav, + pyhf.infer.mle.twice_nll, data, pdf, init_pars, From 6651743a72728fb43acfd417e67284b582aa2e61 Mon Sep 17 00:00:00 2001 From: Lukas Date: Wed, 18 Dec 2019 10:12:06 +0100 Subject: [PATCH 31/72] add docstrings (#698) * Add pydocstyle compliant docstrings to the infer module --- src/pyhf/infer/__init__.py | 5 +++-- src/pyhf/infer/utils.py | 8 ++++++-- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/src/pyhf/infer/__init__.py b/src/pyhf/infer/__init__.py index 562989963e..462eb8dd32 100644 --- a/src/pyhf/infer/__init__.py +++ b/src/pyhf/infer/__init__.py @@ -1,3 +1,5 @@ +"""Inference for Statistical Models.""" + from .test_statistics import qmu from .utils import ( generate_asimov_data, @@ -11,7 +13,7 @@ def hypotest( poi_test, data, pdf, init_pars=None, par_bounds=None, qtilde=False, **kwargs ): r""" - Computes :math:`p`-values and test statistics for a single value of the parameter of interest + Compute :math:`p`-values and test statistics for a single value of the parameter of interest. Args: poi_test (Number or Tensor): The value of the parameter of interest (POI) @@ -75,7 +77,6 @@ def hypotest( - :math:`\left[q_{\mu}, q_{\mu,A}\right]`: The test statistics for the observed and Asimov datasets respectively. Only returned when ``return_test_statistics`` is ``True``. """ - init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() tensorlib, _ = get_backend() diff --git a/src/pyhf/infer/utils.py b/src/pyhf/infer/utils.py index 70097446b5..514d50ea5f 100644 --- a/src/pyhf/infer/utils.py +++ b/src/pyhf/infer/utils.py @@ -1,3 +1,4 @@ +"""Utility Functions for model inference.""" from .. import get_backend @@ -15,6 +16,8 @@ def generate_asimov_data(asimov_mu, data, pdf, init_pars, par_bounds): def pvals_from_teststat(sqrtqmu_v, sqrtqmuA_v, qtilde=False): r""" + Compute p-values from test-statistic values. + The :math:`p`-values for signal strength :math:`\mu` and Asimov strength :math:`\mu'` as defined in Equations (59) and (57) of :xref:`arXiv:1007.1727` .. math:: @@ -36,6 +39,7 @@ def pvals_from_teststat(sqrtqmu_v, sqrtqmuA_v, qtilde=False): Returns: Tuple of Floats: The :math:`p`-values for the signal + background, background only, and signal only hypotheses respectivley + """ tensorlib, _ = get_backend() if not qtilde: # qmu @@ -66,7 +70,7 @@ def _false_case(): def pvals_from_teststat_expected(sqrtqmuA_v, nsigma=0): r""" - Computes the expected :math:`p`-values CLsb, CLb and CLs for data corresponding to a given percentile of the alternate hypothesis. + Compute the expected :math:`p`-values CLsb, CLb and CLs for data corresponding to a given percentile of the alternate hypothesis. Args: sqrtqmuA_v (Number or Tensor): The root of the calculated test statistic given the Asimov data, :math:`\sqrt{q_{\mu,A}}` @@ -74,8 +78,8 @@ def pvals_from_teststat_expected(sqrtqmuA_v, nsigma=0): Returns: Tuple of Floats: The :math:`p`-values for the signal + background, background only, and signal only hypotheses respectivley - """ + """ # NOTE: # To compute the expected p-value, one would need to first compute a hypothetical # observed test-statistic for a dataset whose best-fit value is mu^ = mu'-n*sigma: From c5c6ee3c0f61a149ea28627e8f15484f76433334 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Wed, 18 Dec 2019 10:13:57 +0100 Subject: [PATCH 32/72] rename objective --- .github/workflows/ci.yml | 2 +- src/pyhf/infer/utils.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2164e0afbc..31b68c4489 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -99,7 +99,7 @@ jobs: - name: Check docstrings run: | # Group 1 is related to docstrings - pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/infer/mle.py src/pyhf/optimize + pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/infer src/pyhf/optimize - name: Test and build docs run: | python -m doctest README.md diff --git a/src/pyhf/infer/utils.py b/src/pyhf/infer/utils.py index d6fa1d850f..1a77763ec2 100644 --- a/src/pyhf/infer/utils.py +++ b/src/pyhf/infer/utils.py @@ -4,6 +4,7 @@ def generate_asimov_data(asimov_mu, data, pdf, init_pars, par_bounds): + """Compute Asimov Dataset (expected yields at best-fit values) for a given POI value.""" bestfit_nuisance_asimov = fixed_poi_fit(asimov_mu, data, pdf, init_pars, par_bounds) return pdf.expected_data(bestfit_nuisance_asimov) From a38ea64b02a487ba38c4262658c5615614b1f214 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Wed, 18 Dec 2019 10:37:28 +0100 Subject: [PATCH 33/72] rename objective --- src/pyhf/optimize/autodiff.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/pyhf/optimize/autodiff.py b/src/pyhf/optimize/autodiff.py index ae97da5584..5f0d3cec76 100644 --- a/src/pyhf/optimize/autodiff.py +++ b/src/pyhf/optimize/autodiff.py @@ -6,6 +6,10 @@ class AutoDiffOptimizerMixin(object): """Mixin Class to build optimizers that use automatic differentiation.""" + def __init__(*args,**kwargs): + """Create Mixin for autodiff-based optimizers.""" + pass + def minimize( self, objective, From 3cb5a9610f714c3bfc009101fc0b244364b01b26 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Wed, 18 Dec 2019 11:35:10 +0100 Subject: [PATCH 34/72] double precision for ML backends --- src/pyhf/cli/infer.py | 4 ++-- src/pyhf/optimize/opt_tflow.py | 4 ++-- src/pyhf/tensor/numpy_backend.py | 1 + src/pyhf/tensor/pytorch_backend.py | 13 +++++++++---- src/pyhf/tensor/tensorflow_backend.py | 26 +++++++++++++++++--------- tests/conftest.py | 3 ++- 6 files changed, 33 insertions(+), 18 deletions(-) diff --git a/src/pyhf/cli/infer.py b/src/pyhf/cli/infer.py index 886b0f689d..1ff0c8f5db 100644 --- a/src/pyhf/cli/infer.py +++ b/src/pyhf/cli/infer.py @@ -66,11 +66,11 @@ def cls( # set the backend if not NumPy if backend in ['pytorch', 'torch']: - set_backend(tensor.pytorch_backend()) + set_backend(tensor.pytorch_backend(float = 'float64')) elif backend in ['tensorflow', 'tf']: from tensorflow.compat.v1 import Session - set_backend(tensor.tensorflow_backend(session=Session())) + set_backend(tensor.tensorflow_backend(session=Session(),float = 'float64')) tensorlib, _ = get_backend() optconf = {k: v for item in optconf for k, v in item.items()} diff --git a/src/pyhf/optimize/opt_tflow.py b/src/pyhf/optimize/opt_tflow.py index a897d8e3ff..4dc5767008 100644 --- a/src/pyhf/optimize/opt_tflow.py +++ b/src/pyhf/optimize/opt_tflow.py @@ -50,10 +50,10 @@ def setup_minimize( variable_bounds = [par_bounds[i] for i in variable_idx] data_placeholder = tf.placeholder( - tf.float32, (pdf.config.nmaindata + pdf.config.nauxdata,) + tensorlib.dtypemap['float'], (pdf.config.nmaindata + pdf.config.nauxdata,) ) variable_pars_placeholder = tf.placeholder( - tf.float32, (pdf.config.npars - len(fixed_vals),) + tensorlib.dtypemap['float'], (pdf.config.npars - len(fixed_vals),) ) tv = _TensorViewer([fixed_idx, variable_idx]) diff --git a/src/pyhf/tensor/numpy_backend.py b/src/pyhf/tensor/numpy_backend.py index c2dabbb08a..17147d5db4 100644 --- a/src/pyhf/tensor/numpy_backend.py +++ b/src/pyhf/tensor/numpy_backend.py @@ -1,3 +1,4 @@ +"""NumPy Tensor Library Module.""" import numpy as np import logging from scipy.special import gammaln diff --git a/src/pyhf/tensor/pytorch_backend.py b/src/pyhf/tensor/pytorch_backend.py index 56e83fda86..bf16b6b754 100644 --- a/src/pyhf/tensor/pytorch_backend.py +++ b/src/pyhf/tensor/pytorch_backend.py @@ -1,3 +1,4 @@ +"""PyTorch Tensor Library Module.""" import torch import torch.autograd import logging @@ -10,6 +11,11 @@ class pytorch_backend(object): def __init__(self, **kwargs): self.name = 'pytorch' + self.dtypemap = { + 'float': getattr(torch,kwargs.get('float','float32')), + 'int': getattr(torch,kwargs.get('float','int32')), + 'bool': torch.bool + } def clip(self, tensor_in, min_value, max_value): """ @@ -100,9 +106,8 @@ def astensor(self, tensor_in, dtype='float'): Returns: torch.Tensor: A multi-dimensional matrix containing elements of a single data type. """ - dtypemap = {'float': torch.float, 'int': torch.int, 'bool': torch.bool} try: - dtype = dtypemap[dtype] + dtype = self.dtypemap[dtype] except KeyError: log.error('Invalid dtype: dtype must be float, int, or bool.') raise @@ -141,10 +146,10 @@ def abs(self, tensor): return torch.abs(tensor) def ones(self, shape): - return torch.Tensor(torch.ones(shape)) + return torch.ones(shape,dtype = self.dtypemap['float']) def zeros(self, shape): - return torch.Tensor(torch.zeros(shape)) + return torch.zeros(shape,dtype = self.dtypemap['float']) def power(self, tensor_in_1, tensor_in_2): return torch.pow(tensor_in_1, tensor_in_2) diff --git a/src/pyhf/tensor/tensorflow_backend.py b/src/pyhf/tensor/tensorflow_backend.py index 9ebdf08920..be9fac81dc 100644 --- a/src/pyhf/tensor/tensorflow_backend.py +++ b/src/pyhf/tensor/tensorflow_backend.py @@ -1,3 +1,4 @@ +"""Tensorflow Tensor Library Module.""" import logging import tensorflow as tf import tensorflow_probability as tfp @@ -11,6 +12,11 @@ class tensorflow_backend(object): def __init__(self, **kwargs): self.session = kwargs.get('session') self.name = 'tensorflow' + self.dtypemap = { + 'float': getattr(tf,kwargs.get('float','float32')), + 'int': getattr(tf,kwargs.get('int','int32')), + 'bool': tf.bool + } def clip(self, tensor_in, min_value, max_value): """ @@ -158,9 +164,8 @@ def astensor(self, tensor_in, dtype='float'): Returns: `tf.Tensor`: A symbolic handle to one of the outputs of a `tf.Operation`. """ - dtypemap = {'float': tf.float32, 'int': tf.int32, 'bool': tf.bool} try: - dtype = dtypemap[dtype] + dtype = self.dtypemap[dtype] except KeyError: log.error('Invalid dtype: dtype must be float, int, or bool.') raise @@ -198,10 +203,10 @@ def abs(self, tensor): return tf.abs(tensor) def ones(self, shape): - return tf.ones(shape) + return tf.ones(shape,dtype = self.dtypemap['float']) def zeros(self, shape): - return tf.zeros(shape) + return tf.zeros(shape,dtype = self.dtypemap['float']) def power(self, tensor_in_1, tensor_in_2): return tf.pow(tensor_in_1, tensor_in_2) @@ -443,9 +448,9 @@ def normal(self, x, mu, sigma): normal = tfp.distributions.Normal(mu, sigma) return normal.prob(x) - def normal_cdf(self, x, mu=0, sigma=1): + def normal_cdf(self, x, mu=0.0, sigma=1): """ - The cumulative distribution function for the Normal distribution + Compute the value of cumulative distribution function for the Normal distribution at x. Example: @@ -472,12 +477,15 @@ def normal_cdf(self, x, mu=0, sigma=1): Returns: TensorFlow Tensor: The CDF """ - normal = tfp.distributions.Normal(mu, sigma) + normal = tfp.distributions.Normal( + self.astensor(mu,dtype='float'), + self.astensor(sigma,dtype='float'), + ) return normal.cdf(x) def poisson_dist(self, rate): r""" - The Poisson distribution with rate parameter :code:`rate`. + Construct a Poisson distribution with rate parameter :code:`rate`. Example: @@ -505,7 +513,7 @@ def poisson_dist(self, rate): def normal_dist(self, mu, sigma): r""" - The Normal distribution with mean :code:`mu` and standard deviation :code:`sigma`. + Construct a Normal distribution with mean :code:`mu` and standard deviation :code:`sigma`. Example: diff --git a/tests/conftest.py b/tests/conftest.py index 3208513b87..7d44cf0620 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -44,13 +44,14 @@ def reset_backend(): params=[ (pyhf.tensor.numpy_backend(), None), (pyhf.tensor.pytorch_backend(), None), + (pyhf.tensor.pytorch_backend(float = 'float64', int = 'int64'), None), (pyhf.tensor.tensorflow_backend(session=tf.compat.v1.Session()), None), ( pyhf.tensor.numpy_backend(poisson_from_normal=True), pyhf.optimize.minuit_optimizer(), ), ], - ids=['numpy', 'pytorch', 'tensorflow', 'numpy_minuit'], + ids=['numpy', 'pytorch','pytorch64','tensorflow', 'numpy_minuit'], ) def backend(request): # a better way to get the id? all the backends we have so far for testing From fc5d10d0e3c35d424c831f068754a676b7ebbb16 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 11:19:33 +0100 Subject: [PATCH 35/72] MLE API --- src/pyhf/infer/test_statistics.py | 13 ++++++------- src/pyhf/infer/utils.py | 11 +++-------- src/pyhf/optimize/autodiff.py | 23 ++++++----------------- src/pyhf/optimize/opt_minuit.py | 22 ++++++---------------- src/pyhf/optimize/opt_scipy.py | 18 +++--------------- tests/test_optim.py | 9 +++++---- 6 files changed, 29 insertions(+), 67 deletions(-) diff --git a/src/pyhf/infer/test_statistics.py b/src/pyhf/infer/test_statistics.py index d6d216b4ca..3418193be4 100644 --- a/src/pyhf/infer/test_statistics.py +++ b/src/pyhf/infer/test_statistics.py @@ -1,6 +1,5 @@ from .. import get_backend -from .utils import loglambdav - +from .mle import fixed_poi_mle,floating_poi_mle def qmu(mu, data, pdf, init_pars, par_bounds): r""" @@ -30,13 +29,13 @@ def qmu(mu, data, pdf, init_pars, par_bounds): Float: The calculated test statistic, :math:`q_{\mu}` """ tensorlib, optimizer = get_backend() - mubhathat = optimizer.constrained_bestfit( - loglambdav, mu, data, pdf, init_pars, par_bounds + mubhathat, fixed_val = fixed_poi_mle( + mu, data, pdf, init_pars, par_bounds,return_fval = True ) - muhatbhat = optimizer.unconstrained_bestfit( - loglambdav, data, pdf, init_pars, par_bounds + muhatbhat, float_val = floating_poi_mle( + data, pdf, init_pars, par_bounds, return_fval = True ) - qmu = loglambdav(mubhathat, data, pdf) - loglambdav(muhatbhat, data, pdf) + qmu = fixed_val - float_val qmu = tensorlib.where( muhatbhat[pdf.config.poi_index] > mu, tensorlib.astensor([0]), qmu ) diff --git a/src/pyhf/infer/utils.py b/src/pyhf/infer/utils.py index 514d50ea5f..e3c9a5e8e7 100644 --- a/src/pyhf/infer/utils.py +++ b/src/pyhf/infer/utils.py @@ -1,15 +1,10 @@ """Utility Functions for model inference.""" from .. import get_backend - - -def loglambdav(pars, data, pdf): - return -2 * pdf.logpdf(pars, data) - +from .mle import fixed_poi_mle,floating_poi_mle def generate_asimov_data(asimov_mu, data, pdf, init_pars, par_bounds): - _, optimizer = get_backend() - bestfit_nuisance_asimov = optimizer.constrained_bestfit( - loglambdav, asimov_mu, data, pdf, init_pars, par_bounds + bestfit_nuisance_asimov = fixed_poi_mle( + asimov_mu, data, pdf, init_pars, par_bounds ) return pdf.expected_data(bestfit_nuisance_asimov) diff --git a/src/pyhf/optimize/autodiff.py b/src/pyhf/optimize/autodiff.py index 8e8a91a131..3b6bce5903 100644 --- a/src/pyhf/optimize/autodiff.py +++ b/src/pyhf/optimize/autodiff.py @@ -3,7 +3,7 @@ class AutoDiffOptimizerMixin(object): - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None): + def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None,return_fval = False): tensorlib, _ = get_backend() tv, fixed_values_tensor, func, init, bounds = self.setup_minimize( objective, data, pdf, init_pars, par_bounds, fixed_vals @@ -12,19 +12,8 @@ def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None) func, init, method='SLSQP', jac=True, bounds=bounds ) nonfixed_vals = fitresult.x - return tv.stitch([fixed_values_tensor, tensorlib.astensor(nonfixed_vals)]) - - def unconstrained_bestfit(self, objective, data, pdf, init_pars, par_bounds): - return self.minimize(objective, data, pdf, init_pars, par_bounds) - - def constrained_bestfit( - self, objective, constrained_mu, data, pdf, init_pars, par_bounds - ): - return self.minimize( - objective, - data, - pdf, - init_pars, - par_bounds, - [(pdf.config.poi_index, constrained_mu)], - ) + fitted_fval = fitresult.fun + fitted_pars = tv.stitch([fixed_values_tensor, tensorlib.astensor(nonfixed_vals)]) + if return_fval: + return fitted_pars,tensorlib.astensor(fitted_fval) + return fitted_pars diff --git a/src/pyhf/optimize/opt_minuit.py b/src/pyhf/optimize/opt_minuit.py index bba205e2a2..654a93df65 100644 --- a/src/pyhf/optimize/opt_minuit.py +++ b/src/pyhf/optimize/opt_minuit.py @@ -45,23 +45,13 @@ def f(pars): ) return mm - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None): + def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, return_fval = False): mm = self._make_minuit(objective, data, pdf, init_pars, par_bounds, fixed_vals) result = mm.migrad(ncall=self.ncall) assert result - return np.asarray([x[1] for x in mm.values.items()]) + bestfit_pars = np.asarray([x[1] for x in mm.values.items()]) + bestfit_value = mm.fval + if return_fval: + return bestfit_pars,bestfit_value + return bestfit_pars - def unconstrained_bestfit(self, objective, data, pdf, init_pars, par_bounds): - return self.minimize(objective, data, pdf, init_pars, par_bounds) - - def constrained_bestfit( - self, objective, constrained_mu, data, pdf, init_pars, par_bounds - ): - return self.minimize( - objective, - data, - pdf, - init_pars, - par_bounds, - [(pdf.config.poi_index, constrained_mu)], - ) diff --git a/src/pyhf/optimize/opt_scipy.py b/src/pyhf/optimize/opt_scipy.py index 306f16c81c..b454653b9d 100644 --- a/src/pyhf/optimize/opt_scipy.py +++ b/src/pyhf/optimize/opt_scipy.py @@ -8,7 +8,7 @@ class scipy_optimizer(object): def __init__(self, **kwargs): self.maxiter = kwargs.get('maxiter', 100000) - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None): + def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, return_fval = False): fixed_vals = fixed_vals or [] indices = [i for i, _ in fixed_vals] values = [v for _, v in fixed_vals] @@ -27,19 +27,7 @@ def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None) except AssertionError: log.error(result) raise + if return_fval: + return result.x, result.fun return result.x - def unconstrained_bestfit(self, objective, data, pdf, init_pars, par_bounds): - return self.minimize(objective, data, pdf, init_pars, par_bounds) - - def constrained_bestfit( - self, objective, constrained_mu, data, pdf, init_pars, par_bounds - ): - return self.minimize( - objective, - data, - pdf, - init_pars, - par_bounds, - [(pdf.config.poi_index, constrained_mu)], - ) diff --git a/tests/test_optim.py b/tests/test_optim.py index e96437ad7a..a734b3e6a4 100644 --- a/tests/test_optim.py +++ b/tests/test_optim.py @@ -67,12 +67,13 @@ def test_optim(backend, source, spec, mu): optim = pyhf.optimizer - result = optim.unconstrained_bestfit( - pyhf.infer.utils.loglambdav, data, pdf, init_pars, par_bounds + result = optim.minimize( + pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds ) assert pyhf.tensorlib.tolist(result) - result = optim.constrained_bestfit( - pyhf.infer.utils.loglambdav, mu, data, pdf, init_pars, par_bounds + result = optim.minimize( + pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds, + [(pdf.config.poi_index,mu)] ) assert pyhf.tensorlib.tolist(result) From ce6a2da88b6d3408b1e8ad4c10c7c9e3546018d7 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 11:20:44 +0100 Subject: [PATCH 36/72] MLE API --- src/pyhf/infer/mle.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 src/pyhf/infer/mle.py diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py new file mode 100644 index 0000000000..15f2ae708b --- /dev/null +++ b/src/pyhf/infer/mle.py @@ -0,0 +1,30 @@ +""" +Module for Maximum Likelihood Estimation +""" +from .. import get_backend + +def loglambdav(pars, data, pdf): + return -2 * pdf.logpdf(pars, data) + +def floating_poi_mle(data, pdf, init_pars, par_bounds, **kwargs): + _,opt = get_backend() + return opt.minimize( + loglambdav, + data, + pdf, + init_pars, + par_bounds, + **kwargs + ) + +def fixed_poi_mle(constrained_mu, data, pdf, init_pars, par_bounds, **kwargs): + _,opt = get_backend() + return opt.minimize( + loglambdav, + data, + pdf, + init_pars, + par_bounds, + [(pdf.config.poi_index, constrained_mu)], + **kwargs + ) \ No newline at end of file From 7285f3d7ab162f4fa0f51fb2dc1ad438adefdc83 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 11:30:12 +0100 Subject: [PATCH 37/72] remove example dir --- src/pyhf/optimize/opt_minuit.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/pyhf/optimize/opt_minuit.py b/src/pyhf/optimize/opt_minuit.py index 654a93df65..892e379202 100644 --- a/src/pyhf/optimize/opt_minuit.py +++ b/src/pyhf/optimize/opt_minuit.py @@ -45,11 +45,14 @@ def f(pars): ) return mm - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, return_fval = False): + def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, return_fval = False, return_uncertainties = False): mm = self._make_minuit(objective, data, pdf, init_pars, par_bounds, fixed_vals) result = mm.migrad(ncall=self.ncall) assert result - bestfit_pars = np.asarray([x[1] for x in mm.values.items()]) + if return_uncertainties: + bestfit_pars = np.asarray([(v,mm.errors[k]) for k,v in mm.values.items()]) + else: + bestfit_pars = np.asarray([v for k,v in mm.values.items()]) bestfit_value = mm.fval if return_fval: return bestfit_pars,bestfit_value From d1f3a7dd983d7c3b87ecd890e195431b861ce74b Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 11:33:54 +0100 Subject: [PATCH 38/72] remove example dir --- src/pyhf/infer/mle.py | 8 ++++++-- src/pyhf/infer/test_statistics.py | 6 +++--- src/pyhf/infer/utils.py | 4 ++-- 3 files changed, 11 insertions(+), 7 deletions(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 15f2ae708b..6db3c2fbb3 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -6,8 +6,10 @@ def loglambdav(pars, data, pdf): return -2 * pdf.logpdf(pars, data) -def floating_poi_mle(data, pdf, init_pars, par_bounds, **kwargs): +def fit(data, pdf, init_pars = None, par_bounds = None, **kwargs): _,opt = get_backend() + init_pars = init_pars or pdf.config.suggested_init() + par_bounds = par_bounds or pdf.config.suggested_bounds() return opt.minimize( loglambdav, data, @@ -17,8 +19,10 @@ def floating_poi_mle(data, pdf, init_pars, par_bounds, **kwargs): **kwargs ) -def fixed_poi_mle(constrained_mu, data, pdf, init_pars, par_bounds, **kwargs): +def fixed_poi_fit(constrained_mu, data, pdf, init_pars = None, par_bounds = None, **kwargs): _,opt = get_backend() + init_pars = init_pars or pdf.config.suggested_init() + par_bounds = par_bounds or pdf.config.suggested_bounds() return opt.minimize( loglambdav, data, diff --git a/src/pyhf/infer/test_statistics.py b/src/pyhf/infer/test_statistics.py index 3418193be4..c14a44dca8 100644 --- a/src/pyhf/infer/test_statistics.py +++ b/src/pyhf/infer/test_statistics.py @@ -1,5 +1,5 @@ from .. import get_backend -from .mle import fixed_poi_mle,floating_poi_mle +from .mle import fixed_poi_fit,fit def qmu(mu, data, pdf, init_pars, par_bounds): r""" @@ -29,10 +29,10 @@ def qmu(mu, data, pdf, init_pars, par_bounds): Float: The calculated test statistic, :math:`q_{\mu}` """ tensorlib, optimizer = get_backend() - mubhathat, fixed_val = fixed_poi_mle( + mubhathat, fixed_val = fixed_poi_fit( mu, data, pdf, init_pars, par_bounds,return_fval = True ) - muhatbhat, float_val = floating_poi_mle( + muhatbhat, float_val = fit( data, pdf, init_pars, par_bounds, return_fval = True ) qmu = fixed_val - float_val diff --git a/src/pyhf/infer/utils.py b/src/pyhf/infer/utils.py index e3c9a5e8e7..25d44a3cae 100644 --- a/src/pyhf/infer/utils.py +++ b/src/pyhf/infer/utils.py @@ -1,9 +1,9 @@ """Utility Functions for model inference.""" from .. import get_backend -from .mle import fixed_poi_mle,floating_poi_mle +from .mle import fixed_poi_fit def generate_asimov_data(asimov_mu, data, pdf, init_pars, par_bounds): - bestfit_nuisance_asimov = fixed_poi_mle( + bestfit_nuisance_asimov = fixed_poi_fit( asimov_mu, data, pdf, init_pars, par_bounds ) return pdf.expected_data(bestfit_nuisance_asimov) From 74a52b95c4988d4486d198d3af945dabf3e59fe4 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 11:48:50 +0100 Subject: [PATCH 39/72] remove example dir --- src/pyhf/infer/mle.py | 36 ++++++++++++++----------------- src/pyhf/infer/test_statistics.py | 9 ++++---- src/pyhf/infer/utils.py | 5 ++--- src/pyhf/optimize/autodiff.py | 19 ++++++++++++---- src/pyhf/optimize/opt_minuit.py | 19 +++++++++++----- src/pyhf/optimize/opt_scipy.py | 12 +++++++++-- 6 files changed, 61 insertions(+), 39 deletions(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 6db3c2fbb3..1eac0fab21 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -3,32 +3,28 @@ """ from .. import get_backend + def loglambdav(pars, data, pdf): return -2 * pdf.logpdf(pars, data) -def fit(data, pdf, init_pars = None, par_bounds = None, **kwargs): - _,opt = get_backend() + +def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): + _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() - return opt.minimize( - loglambdav, - data, - pdf, - init_pars, - par_bounds, - **kwargs - ) + return opt.minimize(loglambdav, data, pdf, init_pars, par_bounds, **kwargs) + -def fixed_poi_fit(constrained_mu, data, pdf, init_pars = None, par_bounds = None, **kwargs): - _,opt = get_backend() +def fixed_poi_fit(constrained_mu, data, pdf, init_pars=None, par_bounds=None, **kwargs): + _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() return opt.minimize( - loglambdav, - data, - pdf, - init_pars, - par_bounds, - [(pdf.config.poi_index, constrained_mu)], - **kwargs - ) \ No newline at end of file + loglambdav, + data, + pdf, + init_pars, + par_bounds, + [(pdf.config.poi_index, constrained_mu)], + **kwargs + ) diff --git a/src/pyhf/infer/test_statistics.py b/src/pyhf/infer/test_statistics.py index c14a44dca8..ca5647ba75 100644 --- a/src/pyhf/infer/test_statistics.py +++ b/src/pyhf/infer/test_statistics.py @@ -1,5 +1,6 @@ from .. import get_backend -from .mle import fixed_poi_fit,fit +from .mle import fixed_poi_fit, fit + def qmu(mu, data, pdf, init_pars, par_bounds): r""" @@ -30,11 +31,9 @@ def qmu(mu, data, pdf, init_pars, par_bounds): """ tensorlib, optimizer = get_backend() mubhathat, fixed_val = fixed_poi_fit( - mu, data, pdf, init_pars, par_bounds,return_fval = True - ) - muhatbhat, float_val = fit( - data, pdf, init_pars, par_bounds, return_fval = True + mu, data, pdf, init_pars, par_bounds, return_fval=True ) + muhatbhat, float_val = fit(data, pdf, init_pars, par_bounds, return_fval=True) qmu = fixed_val - float_val qmu = tensorlib.where( muhatbhat[pdf.config.poi_index] > mu, tensorlib.astensor([0]), qmu diff --git a/src/pyhf/infer/utils.py b/src/pyhf/infer/utils.py index 25d44a3cae..d6fa1d850f 100644 --- a/src/pyhf/infer/utils.py +++ b/src/pyhf/infer/utils.py @@ -2,10 +2,9 @@ from .. import get_backend from .mle import fixed_poi_fit + def generate_asimov_data(asimov_mu, data, pdf, init_pars, par_bounds): - bestfit_nuisance_asimov = fixed_poi_fit( - asimov_mu, data, pdf, init_pars, par_bounds - ) + bestfit_nuisance_asimov = fixed_poi_fit(asimov_mu, data, pdf, init_pars, par_bounds) return pdf.expected_data(bestfit_nuisance_asimov) diff --git a/src/pyhf/optimize/autodiff.py b/src/pyhf/optimize/autodiff.py index 3b6bce5903..acaff748b1 100644 --- a/src/pyhf/optimize/autodiff.py +++ b/src/pyhf/optimize/autodiff.py @@ -3,7 +3,16 @@ class AutoDiffOptimizerMixin(object): - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None,return_fval = False): + def minimize( + self, + objective, + data, + pdf, + init_pars, + par_bounds, + fixed_vals=None, + return_fval=False, + ): tensorlib, _ = get_backend() tv, fixed_values_tensor, func, init, bounds = self.setup_minimize( objective, data, pdf, init_pars, par_bounds, fixed_vals @@ -13,7 +22,9 @@ def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, ) nonfixed_vals = fitresult.x fitted_fval = fitresult.fun - fitted_pars = tv.stitch([fixed_values_tensor, tensorlib.astensor(nonfixed_vals)]) + fitted_pars = tv.stitch( + [fixed_values_tensor, tensorlib.astensor(nonfixed_vals)] + ) if return_fval: - return fitted_pars,tensorlib.astensor(fitted_fval) - return fitted_pars + return fitted_pars, tensorlib.astensor(fitted_fval) + return fitted_pars diff --git a/src/pyhf/optimize/opt_minuit.py b/src/pyhf/optimize/opt_minuit.py index 892e379202..29c874d36c 100644 --- a/src/pyhf/optimize/opt_minuit.py +++ b/src/pyhf/optimize/opt_minuit.py @@ -45,16 +45,25 @@ def f(pars): ) return mm - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, return_fval = False, return_uncertainties = False): + def minimize( + self, + objective, + data, + pdf, + init_pars, + par_bounds, + fixed_vals=None, + return_fval=False, + return_uncertainties=False, + ): mm = self._make_minuit(objective, data, pdf, init_pars, par_bounds, fixed_vals) result = mm.migrad(ncall=self.ncall) assert result if return_uncertainties: - bestfit_pars = np.asarray([(v,mm.errors[k]) for k,v in mm.values.items()]) + bestfit_pars = np.asarray([(v, mm.errors[k]) for k, v in mm.values.items()]) else: - bestfit_pars = np.asarray([v for k,v in mm.values.items()]) + bestfit_pars = np.asarray([v for k, v in mm.values.items()]) bestfit_value = mm.fval if return_fval: - return bestfit_pars,bestfit_value + return bestfit_pars, bestfit_value return bestfit_pars - diff --git a/src/pyhf/optimize/opt_scipy.py b/src/pyhf/optimize/opt_scipy.py index b454653b9d..f9e4f8360e 100644 --- a/src/pyhf/optimize/opt_scipy.py +++ b/src/pyhf/optimize/opt_scipy.py @@ -8,7 +8,16 @@ class scipy_optimizer(object): def __init__(self, **kwargs): self.maxiter = kwargs.get('maxiter', 100000) - def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, return_fval = False): + def minimize( + self, + objective, + data, + pdf, + init_pars, + par_bounds, + fixed_vals=None, + return_fval=False, + ): fixed_vals = fixed_vals or [] indices = [i for i, _ in fixed_vals] values = [v for _, v in fixed_vals] @@ -30,4 +39,3 @@ def minimize(self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None, if return_fval: return result.x, result.fun return result.x - From d55414f8d9b11598aed380bd5133bff30850836d Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 13:21:22 +0100 Subject: [PATCH 40/72] remove example dir --- tests/test_optim.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/tests/test_optim.py b/tests/test_optim.py index a734b3e6a4..d611f56cfe 100644 --- a/tests/test_optim.py +++ b/tests/test_optim.py @@ -67,13 +67,15 @@ def test_optim(backend, source, spec, mu): optim = pyhf.optimizer - result = optim.minimize( - pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds - ) + result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) assert pyhf.tensorlib.tolist(result) result = optim.minimize( - pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds, - [(pdf.config.poi_index,mu)] + pyhf.infer.mle.loglambdav, + data, + pdf, + init_pars, + par_bounds, + [(pdf.config.poi_index, mu)], ) assert pyhf.tensorlib.tolist(result) From b0b5fe2cf7d8161688772d6bad119a73ed6d0d3e Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 13:54:20 +0100 Subject: [PATCH 41/72] adapt notebook --- docs/examples/notebooks/ImpactPlot.ipynb | 56 +++++++------------ docs/examples/notebooks/ShapeFactor.ipynb | 5 +- .../binderexample/StatisticalAnalysis.ipynb | 5 +- docs/examples/notebooks/multiBinPois.ipynb | 4 +- 4 files changed, 26 insertions(+), 44 deletions(-) diff --git a/docs/examples/notebooks/ImpactPlot.ipynb b/docs/examples/notebooks/ImpactPlot.ipynb index ee89da38c0..c08b5ce1e5 100644 --- a/docs/examples/notebooks/ImpactPlot.ipynb +++ b/docs/examples/notebooks/ImpactPlot.ipynb @@ -30,10 +30,7 @@ { "name": "stdout", "output_type": "stream", - "text": [ - "RegionA/BkgOnly.json\n", - "RegionA/patch.sbottom_750_745_60.json\n" - ] + "text": "x RegionA/BkgOnly.json\nx RegionA/patch.sbottom_750_745_60.json\n" } ], "source": [ @@ -82,18 +79,14 @@ " _, model, data = make_model([\"CRtt_meff\"])\n", "\n", " pyhf.set_backend(\"numpy\", pyhf.optimize.minuit_optimizer(verbose=True))\n", - " minuit = pyhf.optimizer._make_minuit(\n", - " pyhf.infer.utils.loglambdav,\n", + " result = pyhf.infer.mle.fit(\n", " data,\n", " model,\n", - " model.config.suggested_init(),\n", - " model.config.suggested_bounds(),\n", - " constraints,\n", + " fixed_vals = constraints,\n", + " return_uncertainties = True\n", " )\n", - " result = minuit.migrad(ncall=100000)\n", - " bestfit = pyhf.tensorlib.astensor([x[1] for x in minuit.values.items()])\n", - " errors = pyhf.tensorlib.astensor([x[1] for x in minuit.errors.items()])\n", - "\n", + " bestfit = result[:,0]\n", + " errors = result[:,1]\n", " return model, data, bestfit, errors" ] }, @@ -173,27 +166,12 @@ { "cell_type": "code", "execution_count": 7, - "metadata": { - "scrolled": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", - "text": [ - "0\n", - "5\n", - "10\n", - "15\n", - "20\n", - "25\n", - "30\n", - "35\n", - "40\n", - "45\n", - "50\n", - "55\n" - ] + "text": "0\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/tensor/numpy_backend.py:252: RuntimeWarning: invalid value encountered in log\n return n * np.log(lam) - lam - gammaln(n + 1.0)\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4p.py:57: RuntimeWarning: invalid value encountered in greater\n alphasets > 1, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4p.py:61: RuntimeWarning: invalid value encountered in less\n alphasets < -1, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4.py:171: RuntimeWarning: invalid value encountered in greater_equal\n alphasets >= self.__alpha0, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4.py:182: RuntimeWarning: invalid value encountered in greater\n alphasets > -self.__alpha0, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4.py:201: RuntimeWarning: invalid value encountered in greater_equal\n exponents >= self.__alpha0, exponents, self.ones\n10\n15\n20\n25\n30\n35\n40\n45\n50\n55\n" } ], "source": [ @@ -225,10 +203,9 @@ "outputs": [ { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgYAAAPmCAYAAACfDFeWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdeZhUxdXH8e+PTVkUBMYFiaIERg0aMGjEoIHEqDHEaMQYTKKoCRq3qGg04quiYFwyrvFViFEwKi64RInGGJ153RWQTUUkLom7ggQYNmE47x9VPXNpu2fv6Zme83meeaZv3bpVdXvQPn1v3ToyM5xzzjnnANrkewDOOeecaz48MHDOOedcJQ8MnHPOOVfJAwPnnHPOVfLAwDnnnHOVPDBwzjnnXCUPDJxzzjlXyQMD55wrYJLKJC2TtFm+x+JaBg8MnHOuQEnqA+wBLAQOzetgXIvhgYFzzhWuY4AHgSnAsanCeBXhl4nt0ZKebfrhuebIAwPnnCtcxwDTgOnAdyRtk+fxuBbAAwPnnCtAkoYCnYFSM/sceBI4Or+jci2BBwbOOVeYjgXuNbOKuH0XidsJzmXjgYFzzhUYSR2BnxCCgZSHga9K+nrc7pjY17WpxuaaPw8MnHOu8BwGfA7Mk7S5pM2BCuBRwrwDgCMlbSmpiHAloYuk9vkZrmtOPDBwzrnCcyzQB1iT9nMk8DOgHfAfYD4wE7gZ2Ba4IA9jdc2MzCzfY3DOOdeEJJUBd5jZLfkei2t+/IqBc8455yp5YOCcc865Sn4rwTnnnHOV/IqBc8455yp5YOCcc865Su3yPQDnXMvUrVs3++pXv5rvYeTEqlWr6Ny5c76HkTN+fi3b7Nmzl5hZUa7a98DAOVcv22yzDbNmzcr3MHKirKyMYcOG5XsYOXPr1X/lprO3r9zeYfNPWN12S5asqloM8SttP2BZlx3YbMVnLLXuAHRiNW26bkHPVf/m3Q29K+v26rQMgA9Xb1VZ1qfd+yzpvCM9Vr/P0o3dAOjX/t9M/uafKVlwIDOWD62sO33P37No2daMe+eEyrKxve5mxM6vM/zZSyrLhnSax2V73s/5rxzBC6u/XlleOvRCZry9GyUf/hSAMVcsZ8DN0yne6lNGvvK7ynojuj7L2N3/wZiXTmDx+h0B6NHmv0zf92qmvLEPU5ccUll30q7XAXDiwt9Ulh3b81FG7/IiI58/q8nPCWDiTn+meKtP6Qn/Jod88qFzrl6Ki4tt0aJF+R5GThR6YDD52seYNn7bJumrdOBZTdJPUtmoUQybNq3J+20qKiubbWaDc9W+zzFwzrlWpqLCvxC67DwwcM4551wlDwycyyFJ3SSdHF/3kXR0Yt9oSX/MQZ9lkhZJmht/RsbycZJekzQ/ln8zrf48STMlDWzsMTnnWg4PDJzLrW7AyfF1H+Do7FXrRlLbanb/zMwGxp/pkoYAI4A9zWwP4ADgvbT6Xwf+F7iqscbomqf2rM/3EFwz5oGBc7l1OdBX0lzCB+5+8dv6mXH/V+I39sWSLkodJOkhSbPjN/wxifJySSWS5gFD6jCO7YAlZrYOwMyWmNmHGeq9AGyfodwVkI1tO+R7CK4Z86cSnMshSX2AGWY2QNIw4GwzGxH3jQZ+DwwAVhPS3442s1mSupvZ55I6xvJvm9lSSQYcZWb3VtNnGSEQWBOLvgusA54FOgH/BO4xs/9L1D879nsGsLWZnZ+l7THAGICioqJv3Htv1mG0aOXl5XTp0iXfw8iZJZ8s5/OPmiY46N/pvZorNbLy7t3p8vnnTd5vUxl+4ok5fSrB1zFwLr+eMLOlAJIeAIYCs4DTJR0e63wF6AcsBSqA+2vR7s/MbJNFBiR9A9gPGA7cI+k8M5sSd98pqQPQBcg6x8DMJgOTITyuWKiP9BX644o3lTzKvROa6nHFK5ukn6RCf1wx1/xWgnP5lX7JzuKVhQOAIfG+/xxg87h/rZlV1KsjswozKzOzi4BTgSMSu38G7AxMBW6oT/vOucLggYFzubUS2CLD65TvSeoebxkcBjwHdAWWmdlqSbsA+zR0EJKKJfVLFA0kbfU0C/cV/wfYJ/brnGuF/FaCczkU5wU8J+lV4AmgIk4cnAIsA14m3BroDdwR7/MvAE6StBBYBLzYCEPpAtwgqRuwAfgXca5A2njXSCoBzgFOSN/vCkPbtsr3EFwz5oGBczlmZtU9ojglQ/11wPeztFXjjDgzG5ahbDawb23qm1lJTX24lq3dxi/yPQTXjHlg4JxzrcyGNps+kTDp7pAQ6MSf/rey7NgjVjH6lqGM7P0CS1eFKS79tl3J5IX7U/LDMmY827Wy7vSXd2TRUx8w7rwNlWVjT1vPiEv2ZvhWV1eWDdl1OZc9P4zz9y3jhYVVx5cuG8SMC1+m5Ib2lWUTL29H8Xe2Z+TeVXe8RgxdzthHhjFm16dZ/HG4K9ej81qmvz+EKb98lqn3h4yKo370Mb3OuzWH5zSnyc8p+XeibGdyyR9XdK6FkvQgsFNa8blm9nhT9O9JlFouP7+WTZI/ruic+zIzO7zmWs45Vzf+VIJzzjnnKvkVA+eca2UWzl7N+MOr7pMzcFD+BpMDo0bB+PH5HkXL5VcMnHPOOVfJAwPnnGtl2rAx30NwzZgHBs4518q0U71W1XathAcGzlVDUjdJJ8fXfSQdndg3WtIfc9BnmaTB8fXxkhZImi/pVUk/iuVTJL0TUzjPk/TdGtp8V1LPxPYwSTMae+yuZfjC2tdcybVaHhg4V71uwMnxdR+gulUM60RS2xr29wbGAUPNbA9CzoT5iSrnmNlA4Azg5sYal3OudfOnEpyr3uVAX0lzgfVA//h6KiHXwVcklQHbE3IdjAeQ9BAhXfLmwHUxXTGSyoFJhOyJpwDPVtP31oTES+UAZlaeep3mhdh/vUi6GOgLfBXoCVxpZn/KUncMMcdCUVERZWVl9e22WSsvLy/YcwPo2XsDoy76uKqgU1nexpIL3buXM2pUWb6HkTO5/qfpgYFz1TsPGGBmA2M65LPNbASEWwnA3sAAYDUwU9LfzGwWcLyZfR6zJs6UdL+ZLQU6Ay+Z2dha9D0P+AR4R9KTwANm9kiGegcDDzXsNEldkegMzInn8WF6pRjgTIaw8mGhri5X6Cvn3VTyKPdO2LaqoOAeVyxj2rRh+R5Gi+W3EpxrmCfMbKmZrQEeAIbG8tNjFsUXCVcOUimPKwjZFGtkZhWED/2RwJvANfHbfcpVkt4E7gKuqKm5Gsr+amZrzGwJUEoIeFyB2kyeRMll54GBcw2T/oFr8crCAcAQM/s6MIdwSwFgbfzAr13jwctm9nvgp8ARid3nmFl/4Fzg1hqaWgpsldjuDiyp7jxqO0bX8qyzDjVXcq2WBwbOVW8lsEWG1ynfk9Q93jI4DHgO6AosM7PVknYhXKKvM0m9JO2ZKBoI/DtD1T8CbSQdVE1zZcAvYrttgZ8Trgyk/EjS5pJ6AMOAmfUZs3Ou5fM5Bs5Vw8yWSnpO0qvAE0BFvEUwhTD58GXCrYHehMmHsyQtAE6StBBYRLidUB/tgT9I6gWsBT4DTsowRpM0AfgtkC2z4qXATXHsAv4O3JHYP58QKPQELs00v8A51zp4YOBcDcysukcUp2Sovw74fpa2utSiv2GJze9kqTM6bft+qpm7YGbLqf5Ry/lmdkxNY3POFT4PDJxzrpXZuudGSpcV1pMISWVlUFpaY7UWS8pt+x4YOJcnkh4EdkorPtfMst0OyEmbZnZxfftzLVOPHWu8cOVaMQ8MnMsTMzu8JbTpnGtdPDBwzrlWZuHs1Yw/fE6+h5Ezoy5ak7/zSywW1VJvZ/jjis4555yr5IGBc861Mm3YmO8huGbMAwPnnGtl2qnWi2+6VsgDA1fQJJVL6iNpjaS5iZ9jJL0UX/9H0meJfX2ytPWupJ7V9NVH0tGJ7WGSlqf1e0Dcd7qkhZLulLSZpH/G/UdJukXSbtX0c6ik8+r/rrjW7gtrn+8huGbMJx+61uItMxuYVnY7VGZJHGxmpzawjz6ERYTuSpQ9k8rGmOZk4AAze1/SPgCJ8d1TXSdm9jDwcAPH6pxzGfkVA+fqSNLlkk5JbF8s6WzgcmC/+M3/zGqOvxnYGXhM0rmEpYn3isf1lVQmaXCse7CkVyTNi6mXkTRa0h/j6yJJ90uaGX++lRjTrbGttyWdnuj/GEnzY5t/kbSFpHcktY/7t0xuO+daF79i4FqLvpLmJrZPM7Nn6tnWPcC1wI1x+yfAQcAs4OzUFYKYZXG/tH6PMLOTJB0MDDezJZJeSjuO+LsI+BOwv5m9I6l7hrFcB1xjZs9K2oGQK2HXuG8XYDgh8dMiSTcB/YELgH1j393NbKWkMuAHwEOELI4PmNn69M4kjQHGABQVFVFWVlaX963FKC8vL9hzA+jZewOjLvo438PIme691ufv/DqVVb5sqf+EPDBwrUWmWwn1YmZzJG0dkxsVETIpviepb4bq2W4l1MY+wNNm9k7s9/MMdQ4AdlPVGqlbSkota/e3mLdhnaRPgW0IuRfuM7MlaW3eQkjC9BBwHPCrTAMys8nAZIDi4mIbNmxYPU+teSsrK6NQzw3g1qsfYtql2+Z7GDkz6qKPmTY+T+dXAOsYeGDgXP3cB4wEtqWGOQE51gbYx8zWJgtjoLAuUVRBNf+9m9lzcfLkMKCtmb2ag7G6ZmKddcj3EFwz5nMMnKufewiX3EcSggSAlYTL9o3lRWB/STsBZLmV8A/gtNSGpJquijwFHCmpR4Y2bydMnLytIYN2zrVsHhi4giWpHVXfmvumPTZ4enXHZlHZnpm9RggCPjCzj+L++UBFnNSXmny4X1q/I2vbmZl9Rrif/4CkeWS+MnE6MDhOJnwdOKmGNl8DJgL/F9u8OrH7TmArYFptx+icKzx+K8EVsq8R5ha8C3TMVsnMpgBTqmsoTgSUma1MHLd7WjvrCffwk7pm6bNP4nUZUJbYHpZ4/RjwWLbxxrkCR2Vo/+K07QGJ11OBqRmGNRSYbmb/zTRm51zr4IGBK0iSTiJ8mz6jEdo6FLgS+F1D22quJN0AfB84JN9jcbm3dc+NlC4bVHPFFqqsrKygzy/XPDBwBcnMbgZurs+x8fHBzdKKjzSzBQ0eWDNlZqfVXMsVih47dqm5kmu1PDBwLo2ZfTPfY3DOuXzxwMA551qZt+as5JoRT/Dh6q0qy07Z5n5G7/IiI58/i6UbuwHQr/2/mfzNP1Oy4EBmLB9aWXf6nr9n0bKtGffOCZVlY3vdzYidX2f4s5dUlg3pNI/L9ryf8185ghdWf72yvHTohcx4ezdKPvxpZdnEnf5M8VafMvKVqjt2I7o+y9jd/8GYl05g8fodAejR5r9M3/dqpryxD6N3eTHzCY4aBePH1/PdqYOWulBBDWRm+R6Dc64FKi4utkWLFuV7GDlR6Asc3VTyKPdO2G6TstKBZ+VpNPUz/NlLKB16YcZ9ZaNGMWxaEzxck6fAQNJsMxucq/b9cUXnnHPOVfLAwDnnnHOVPDBwzrlWZjN9ke8hNNikXa/L9xAKlgcGzuWApG6STo6v+0g6OrGvMm1yI/fZTtJlkhYnVloc19j9uJZvQ5v0p3Gdq+KBgXO50Q04Ob7uAxydvWrdSGqbZdcEoBewe8wkuR/QvrH6dYXDKiryPYQGO3Hhb/I9hILlTyU4lwOS7gZ+BCwC1gP9gXcISxEvAw4nLJe8PXCHmY2Pxz0EfAXYHLgupjlGUjkwiZBm+RQzezatv07Ae0Cf5LLNaXV+TlgNsgPwEnCymVXEtq8DRgBrgB+Z2SdZ2hhDyN9AUVHRN+699966vzktQHl5OV26FO4iQJ99soJlH20aM/bv9F6eRlM/b5b3on+XDzPuK+/enS6fZ8pS3sj69899HxkMHz48p08leGDgXA5I6gPMMLMBMZXx2WY2Iu4bDfweGACsBmYCo81slqTuZva5pI6x/NtmtlSSAUeZWcZPYkl7AFPNLOM6sJJ2JSzr/GMzWy/pf4EXzez22PahZvaIpCuBFWY2oaZz9McVWy5/XLGR+OOKzrlG9ISZLTWzNcADhARGAKfHrIcvEq4c9IvlFcD9tW1c0nFxjsF7kr4CfBf4BjBT0ty4vXOs/gUwI76eTbj14QpYOzbkewgNdmzPR/M9hILlKx86lx/pl+osXlk4ABhiZqsllRFuKQCsNbPqbgz/C9hB0hZmttLMbgNuk/Qq0BYQ4YpCpkRQ663q0mEF/v+FgmdtW/7Uk6yrHroG8ysGzuXGSmCLDK9Tviepe7xlcBjwHGHOwbIYFOwC7FPbzsxsNfBn4I+SNofKSYodYpUngZGSto77ukvasX6n5lq6thtb/uOKI59vWbc+WhL/ZuBcDsR5Ac/Fb+xPABXxFsEUwuTDlwm3BnoTJh/OkrQAOEnSQsKkxbp+JRoHXAq8KmklYSLhVOBDM/tC0gXAPyS1IUyIPAX4d0PP1bU8X1jLv2KQyufgGp8HBs7liJlV94jilAz11wHfz9JWjVPkzWw9cF78ybT/HuCe6to2s+nA9Jr6ci1b27baZHvS3d14k1s58af/rSw79ohVjL5lKCN7v8DSVeGOVr9tVzJ54f6U/LCMGc92raw7/eUdWfTUB4w7r2ruwtjT1jPikr0ZvtWcyrIhuy7nsueHcf6+ZbywsOr40mWDmHHhy5TcUBWwTLy8HcXf2Z6Re1fFriOGLmfsI8MYs+vTbLNd2+yT/8rKCjbBUVPwpxKcc/XiTyW0XH5+LVuun0rwKwbOtTCSHgR2Sis+18wez8d4nHOFxQMD51oYMzs832NwzhUuDwycc64VKSmB9tpA1+/tVVk2aMdl8JWvwKJFsGZNKGzXDgYMgI8+gk8SC2GmVvt7882qsm22ge22g1dfhQ1xnkHHjlBcDO+9B0uXVtX92tdg9Wp4552qst69oWdPmDu3qmzLLWHnneHtt2HFiqrygQNhyRJ4//2qsr/9LfQ1cmTYHjUKZs+GsWNhzBhYvDiU9+gB06fDlCkwdWrV8ZMmhd8nnlhVduyxMHp0aDM1/n79YPLk8CbOmFFVd/r08N6NS6QmGTsWRoyA4cOryoYMgcsug/PPhxdeqCovLQ3tlZRUlU2cuOk5QWhv7FhyzecYOOfqxecYtDxjxoTPtetLnuDBCT0ry1vaqodfkjbRsFD/fim+8qFzzrlGkfri3J71+R2Ia9Y8MHDOuVamN+/XXMm1Wh4YuJyRdEbM+tco9XJN0vclzZL0uqQ5kkpi+cWSPoi5B16XNCpxzGhJvRLbOT8XSVdJei3+LpL0UhzvfpIq4jh7xbrfkLRA0r8kXS9JsfzI2MZGSYMTbe8Xz/HVXJ6Dy48ePcLvL9gsvwNxzZoHBi6XzgBq8yFZ23qV4nK/ye1aTaTNVk/SAOCPwM/NbDdgMCH/QMo1ZjaQkEp5kqTUSiyjgV6JenU+l3oYA+xhZucQkiEtMLNBZvYMsMbMBppZKh/tTcCvCMmY+gEHx/JXgR8DTycbjm0ckuPxuzyZHpeu+nCTf7LObcqfSnCNQlJn4F7CEr9tgfsIH5ilkpaY2XBJNwF7AR2B6WZ2kaTTM9Q7EBgPbAa8BRxnZuWS3iWs3Pc94EpJJwFzCZkJp0m6H7gV6Al8Fo/7j6QpwFpgECEnQaaZVr8FJprZGwAxYdFN6ZXMbLGk1cBWkvYnBBB3SloD3JZ+Llneq/LY9iHAR8D5hJTIOwBnmNnDMfC5HBgW34cbzWySpIeBLsBsSdMIyxp3jN/6h6T1sx2wpZm9GLdvJ+RleMzMFsayTEPMStIYQmBCUVERZWVldTq+pSgvLy/Ic1u6NFw12Kb3WkZd9HFleVmnUdUc1QKk/a0K9e/XVDwwcI3lYMKa/D8AkNQVOA4YbmZLYp1xZvZ5/NB7UtIeZna9pLNS9ST1BC4ADjCzVZLOJXyQXxLbWGpme8Y+TgI6pGbnSnqEkEFwqqTjgesJH4QQApZ9q8lQOAAoybKvkqQ9gcVm9ikwXdKpwNlmNivuPzPtnDPpDDxlZufExYomEIKd3Qi5DR4GTgCWm9lekjYDnpP0DzM7VFJ5vHqBpE+AwWZ2atxO9rM9bHIz+f1YVm9mNhmYDOGphEKd+V2os9qHDw8T+G8qeZR7J2xbWV468Mo8jqoRtLKnEnLNbyW4xrKAkDHwCkn7mdnyDHV+IukVYA7wNcIHYbp9YvlzkuYCxwLJLIDpa/0nt4cAd8XXfyFcSUi5r4a0xTU5U9JrwEvAxAa0A/AF8Pf4egHwfzHPwQKgTyw/EDgmvgcvAT0ItwKca7AefJ7vIbhmzK8YuEZhZm/Gb9OHABMkPZncL2kn4GxgLzNbFi/vb56hKQFPmFm2a5uratjOpqZ6rwHfAOZl2X+Nmf1B0qHAnyX1NbO1tew73XqrWkBkI7AOwMw2JuZACDitgcscf0C4UpLSO5a5Vm4Lrcz3EFwz5lcMXKOIs+BXm9kdwFXAnsBKYItYZUvCh/NySduwaRbBZL0XgW9J+mpst7Ok/rUcxvPAT+PrnwHP1OEUrgLOT/UlqU28VbEJM3sYmEW4kpE+9kzb9fU48OvUJEdJ/eM8jlozs4+AFZL2iU8jHAP8tRHG5lqo1AJ/b1t6qg3nqvgVA9dYdgeukrQRWA/8mnBp/++SPoyTCucAbwDvESYBpkxOqzeaMJkw9UzVBUBi/dWsTgNuk3QOcfJhbQdvZvMlnRH77QQYMCNL9UuAuyT9iZA++eY4+XBI+rnUtv8MbiHcVnglfqh/RtV8ibo4OY6xI/BY/EHS4cANQBHwN0lzzeygBozXtSDr1SHfQ3DNmC+J7FwBiRMTuzSwjT7ADDMbUF09XxK55UlNPryx5O9Mn7BNZbkvidyyyJdEds7VwYrkAkd1JWk/4BGguqcqXAu1zTYhOGjf1igdeFblD5MmVd1nSDn22PCBm1oVCUISodLSkMwnafr0kPQnaezYL31gM2RIKBsyZNPy0tIvJweaOLFq4YWUESNC3X6Jebip8U2ZEk5u+PCQ4Cn1kyobPjzUgZCYKFU2ZkwoKynZtO7SpfD885uWpRInJcvOPz+UnX/+puUQ6ifLnn8+tJssSyVOGjOmqiyVOCl5TsnzyjG/YuBaFUnHAb9JK37OzE7JQV8vwZeWmPuFmS1o7L7ywa8YtFx+fi1brq8Y+BwD16qY2W2EhYiaoq9vNkU/zjnXmDwwcM65Vmbh7NWMP3xOvodRrdJlg/I9hFbL5xg455xzrpIHBs4518q0YWO+h+CaMQ8MnHOulWmnhqwO7gqdBwauyUgql9RH0pr4SF3q5xhJL8XX/5H0WWJfnyxtvRsTLiGpIq2982J5maRFkuZJmilpYA3je1fSgkQ718fyXeL2HEl9JZ0uaaGkO+vxHpwRF1BKbT8qqVtd24nHmqSSxPbZki6Ory+W9EEc96txKeds7ZyUOO9nJWXKYeEKyBfWvuZKrtXyyYcuH95KZQdMuB0grnpYmS2wltZkaC/lZ2Y2Kz6meBUhi2F1MmVGPIyQJnpCHOPJhOyP73/p6JqdAdwBrAYws0Pq0UbKOuDHkn6fJZtjKr/DrsAzkrY2s0zXkO8ys5sBYgBxNSFbpnOuFfIrBq61eIF6pByWdAjhw/zXkkol3QzsDDwm6cyYy+FWSS/HKwo/ise1lfSH+G19vqTTJJ0O9AJKJZXGeu9K6inpckmnJPq9WNLZ8fU58YrHfEnjE8PbQFiC+czqzsHMFsa6PbPsX5HY7ExYDto510r5FQOXD30V0gmnnGZmdUl4lK5jWnu/N7P09MwHAw/Voq1SqfIG7FQzuyYGA+Vm9gcASQcTryxIugx4ysyOj7cEXpb0T0LCoj7AQDPbIKm7mX0u6SwyX5W4B7gWuDFu/wQ4SNKBhHTLexMyLj4saX8zezrWuxGYL+nKbCck6ZuELI6fVVPnFOAsoAPwnWrqjQHGABQVFVFWVpataotWXl5esOcG0LP3BkZd9HG+h1Gthrz/hf73yzUPDFw+ZLqV0BDV3Uq4U1IHoAtQmz4zfWhX50Dg0NS3e0Iq6R2AA4CbzWwDgJl9Xl0jZjZH0tZxKeMiYJmZvSfpN7GP1EPnXQiBwtPxuBWSbgdOB9akNXumpJ8TMj4elUj1nKn/G4EbJR1NSFp1bJZ6kwlXKSguLrZCXV2u0FfOu/Xqh5h26bb5Hka1GrKOQaH//XLNAwNX6H4GzCbML7gB+HEjty/gCDPbZG3gkBCxzu4DRgLbEq4gpNr/vZlNynpUuNLwCl9e0fGa1FWOOrgbuKmOx7gWZp15dkWXnc8xcAUvflP+H2AfSbs0cvOPA6fF1MhISn3NeQI4UVK7WN49lq8EtsjS1j3ATwnBwX2J9o+X1CW2s72krZMHxasR9wIn1OcEJCUy0vADYHF92nHOFQYPDFyTiB+Q6+Jm37THC0+vR5PJ9jqmtXd5emUzWwOUAOfU0G5pop3bazGOS4H2hPv8r8VtgFuA/8TyecDRsXwy8PfU5MO0Mb5GCBo+MLOPYtk/gLuAFyQtAKaTObAoIcvkwlo4VdJrcZ7GWWS5jeCcax38VoJrKl8jzC14F+iYrZKZTQGmVNeQpCJCZtCV8Zi2WdoalrZdkqleYn+fLOUXZ6sXA44TMxyzgfAhe1Za+Q2EWxoZ+zSz3TO0dR1wXYbyLonXnwCdEtsXp9fPxszSs00651oxDwxczkk6iTA57oxGaOtQ4Ergdw1ty7nWauueGz1JkcvKAwOXc3HxnJvrc6ykl4DN0oqPNLMF9R1PljZ/0ZA2WwJJ44Aj04rvM7OJ+RiPy58eO3apuZJrtTwwcM2amX2zJbTZEsQAwIMA51y1fPKhc8455yr5FQPnnGtlFs1dwznfmVW53b/NW3y4RX+0YgUrrTNd2q6hhz5n+reuZcribzH1k4Mq607qVwIdO3Li/JMry47d6hFGf20mI18cy9INXQHo1/YdJg+5jZLXDmbGsn0r607f/RIWrd2RcYurHn4Zu82djOi3iOHPXQpxHa4hA1Zy2ZxDOP+7L/HCK1XrLpT+awdm3PopJZetrSybeP5qio//FiO/GtYBG3XRGmZf+ihjnzyEMYNeZvG7IWlUjwMu+aQAACAASURBVHYrmP7Zt5lyxlymTq1a72vSTQY77cSJB79bdU4HfcLouw9m5M6zWbosfIfu120Jk9/5HiU/ncmMx6s+Pqf/fQsWvdOBcb9eWnVOxy5lxLUHMHzrV2H9+nBOfT6q9zkBjNjzI8Y+2ZD0KrWjahZDc865rIqLi23RokU1V2yBCn3lvNuufpDbL+2TdX/pwLOy7msypV96orfWCv3vJ2m2mQ3OVft+K8E551qZtZY+99a5Kh4YOOecc66SBwYuZySdIalTY9XLNUnflzRL0usxhXJJLL9Y0gdxNcTXJY1KHDM6Jj5Kbef8XCRdFVcqvEpSkaSX4nj3k1QRx9kr1v2GpAWS/iXp+sTSzd0lPSFpcfy9VSw/KtadkctzcM41Xx4YuFw6g8RqfI1Qr5KktmnbtZpIm62epAHAH4Gfm9luwGDgX4kq18QMjj8CJklqH8tHA70S9ep8LvUwBtjDzM4BvgssMLNBMXX1GjMbaGYfxro3Ab8iZGTsR0g/DXAe8KSZ9QOejNvEdNW/zPH4XZ61r8ws7tyX+VMJrlFI6kxI5NMbaEtIAtSLkHtgiZkNl3QTsBdhSeTpZnZRzJOQXu9AYDxhEaK3gOPMrFzSu4REQ98DrowrKs4FhgLTJN0P3ErIGfBZPO4/kqYAa4FBwHOkLVMc/RaYaGZvAJhZBRmyDJrZYkmrga0k7U8IIO6UtIaQ3XCTc8nyXpXHtg8BPgLOJ6zmuANwhpk9HAOfy4Fh8X240cwmSXqYkHp5tqRpwCmEXBGDgSFp/WwHbGlmL8bt24HDgMcIAc6wWHUqUAacm2m8aW2OIQQmFBUVFWzO+/Ly8oI9N4BuvTcy6qKPs+4v6zQq674m04D3v9D/frnmgYFrLAcDH5rZDwAkdQWOA4ab2ZJYZ5yZfR4/9J6UtIeZXS/prFQ9ST2BC4ADzGyVpHMJH+SXxDaWmtmesY+TgA6p2bmSHgGmmtlUSccD1xM+CCEELPvGD/xMBhASEVVL0p7AYjP7FJgu6VTgbDObFfefmXbOmXQGnjKzcyQ9CEwgBDu7ET6kHyZkSlxuZntJ2gx4TtI/zOxQSeXx6gWSPgEGm9mpcTvZz/bA+4nt92MZwDapRE3Ax8A2NZ07gJlNJiSCori42Ap15nehz2q/qeRR7p2wbdb9pQOvbMLRZBuEP5WQLx4YuMayACiRdAUww8yeSfuQAvhJ/MbZDtiO8EE4P63OPrH8uXh8B+CFxP570uont4cAP46v/0L4Fp5yXzVBQW2cKek4oD/wwwa0A/AF8Pf4egGwzszWx+yJfWL5gcAekkbG7a6EWwHvNLDvLzEzk+TPLTvnAA8MXCMxszfjt+lDgAmSnkzul7QTcDawl5kti5f3N8/QlIAnzCzbtcxVNWxnU1O914BvAPOy7L/GzP4Qkzj9WVJfM1ubpW5N1lvVAiIbiemjzWxjYg6EgNPM7PF69gHwAeFKSUrvWAbwiaTtzOyjeMvh0wb045wrID750DWKOAt+tZndAVwF7AmsBLaIVbYkfDgvl7QN8P3E4cl6LwLfkvTV2G5nSf1rOYzngZ/G1z8DnqnDKVwFnJ/qS1KbeKtiE2b2MDALSC3blhx7pu36ehz4dWqSo6T+cR5HrcVbBSsk7ROfRjgG+Gvc/TBV53Bsoty1Au3wyYcuO79i4BrL7sBVkjYC64FfEy7t/13Sh3FS4RzgDeA9wiTAlMlp9UYTJhOmVmG5AHizFmM4DbhN0jnEyYe1HbyZzZd0Ruy3E2BAtkf2LgHukvQnYApwc5x8OCT9XGrbfwa3EG4rvBI/1D+jar5EXZwcx9iRMOnwsVh+OXCvpBOAfwM/acBYXQtjbf1//S47XxLZuQISJyY2KKeupGGECZUjqqvnSyK3XLeWPMRfJuyYdb8vidy8KcdLInvY6FxhWSFpLnBIYi2DWpN0FHARMLvRR+aajQ1tN10SedLd3QA48af/BWD43Ks59ohVjL5lKCN7v8DSVWE6UL9tVzJ54f6U/LCMGc92rTx++ss7suipDxh33obKsrGnrWfEJXszfKuqJEBDdl3OZc8P4/x9y3hhYdXxpcsGMePClym5oX1l2cRJCyj+zvaM3PvflWUjhi5n7CPDGLPr0yz+ONyx69F5LdPfH8KUXz7L1PvD3bZRF62h17p3NjknIP/ndHm7ep9T8u+Ua37FwLUq8cmC36QVP2dmp+Sgr5cIaxAk/cLMFjR2X/ngVwxaLj+/ls2vGDjXiMzsNsJCRE3R1zeboh/nnGtMHhg451wr8+bcNVz+3X+wbsui+jcycFDjDSihAVMLXCPxxxWdc66VabvxC5Za93wPwzVTHhg451wr84W1r7mSa7U8MHDOuVaoE6vzPQTXTHlg4PJGUoWkuYmfExOvyyUtiq9vz3L8MEnL09o4IEvbfTLU/2cjnsthknZrrPaq6aePpFdrUefoxPZgSdfnemyuZWnTtTEW6HSFyCcfunxak8oSmDAJQFIZiayF1Xgmy0I8X2pbUp9q6jfUYYSVEl9P3yGpnZlt+PIhOdMHOBq4CyC+hzW9j64VaddmIz1X/ZslnbMvcuRaL79i4FwGkook3S9pZvz5Viy/TtKF8fVBkp6WtC9wKGFJ6LmS+koqk3StpFnAbyT9UNJLkuZI+mfMF4GkiyX9RdILkhZL+lUsl6SrJL0qaUFceCh9jH0kPSPplfizb9x1ObBfHMuZ8UrJjHhMd0kPSZov6UVJeyTGcWsc99uSTs/xW+zyqA0VvLuhd80VXavkVwxcPnWMq/QBvGNmh9ejjf0SbQAcYWZvVdN2sv59ZjYxS7vXETIqPitpB0JSo12B3wEzJT0DXE9YYfAtSQ8T0k1PB1BMGZ1ahETSVsA+McXxL4HfAmNjX3sQ0k13BuZI+hsh78JA4OtAz9jn02lj/BT4npmtldQPmAYMBs4jsaRxXOI4ZTwwx8wOk/Qd4PbYD8AuwHBCEqhFkm4ys/XJDhXSZo8BKCoqoqysLMvb17KVl5cX7LkBbNlLHH/Vp7Rt+6XU6LXXqazRxpPUGG97of/9cs0DA5dPmW4l1FWtbyXUUD/dAcBu8QMeYEtJXcysPH6rfxo4MwYh2dyTeN0buEchxXEH4J3Evr+a2RpgjaRSYG9gKDDNzCoIKZL/D9gLmJ84rj3wR0kDgQqgNlkohwJHAJjZU5J6SNoy7vubma0D1kn6FNgGeD95sJlNJiSKori42Ap1dblCXznvppJHufWcrenStW39G2nG6xgU+t8v1zwwcC6zNoRv+Gsz7NsdWAr0qqGNVYnXNwBXm9nD8Rv8xYl96euS13ad8jOBTwhXFdoAmcZaF+sSryvw/z8UtF6dlrGCnvkehmuGfI6Bc5n9g5DGGYD4rRxJOxJuAQwCvi8ptezxSsIl+Gy6Ah/E18em7fuRpM0l9QCGATOBZ4CjJLWVVATsD7ycoc2PzGwj8Asg9fWvurE8A/wsnsswYImZrahm3K4Abab1NVdyrZYHBq6lS02yS/2MbKR2TwcGx0l6rwMnKdxX+DPh/v2HwAnALZI2B+4GzomTC/tmaO9i4D5Js4ElafvmA6XAi8Clse0HY/k84Cngt2b2cdpx/wscK2keYX7AqkR7FZLmSTozwzi+IWk+YZJiepDiWoENbTrw4eqt8j0M10z5pUKXN2bWpZp9w2pxfBnhW3Ot2o71y2o5tiXAl54EIMw9SNWZTbitAPAckFzHYFhae38F/pqlu/lmdkxafQPOiT/J8neBAfH1YsLExZRzY/l64DtpfZTFfZ8THq3chJldnLY9IMtYXQGoqPCsui47Dwycc66VadtW9O39BXf/Z9+aK7tWxwMD1+xJOgi4Iq24vo83prc9Djgyrbi6xxgbVfo3deeaQv+BHRnjQYHLwgMD1+yZ2eOEdQRy0fZEoEmCAOecawk8MHDOuVZi+PDw+6JRbzLmkPeZ/M0/53dASY2xgIFrFB4YOOdcK/PJmi1ZvH77fA/DNVP+uKJzzrUyyyuyPhDknAcGzjnXGvVo8998D8E1Ux4YOOdcKzR936vzPQTXTHlg4JqEpIq0FQpPTLwul7Qovr49y/HDJC1Pa+OALG33yVD/nzWM75hEiuM5ks7OxfsQ+xoo6ZBctZ/o5zBJuyW2L0m9Z65169vpY6a8sU++h+GaKZ986JpKpmyHkwAklRGWGZ5VQxu1zqQoqU819Tch6fvAGcCBZvahpM2AY2o4rCEGEtIjP5rDPiCscDgDeB3AzC7McX+uhVi7oR1TlxzCaF7M91BcM+SBgXPwO6ryHxBTD/8pW2VJpwMnARsIH7pHA4uAfc3sM0ltgDeBIYSlkS8iZCtcTlhS+RKgo6ShwO8JH943EJY6bg9cbGZ/lTSa8OHeGegH/IGQsvkXhEyIh5jZ5zEN9Ji4719x/0DgUODbki4gpFr+H2CGmU2XtBdwXWx7HfBdYAfgtthOG+CIuOxy8tzHxL4oKioq2Jz35eXlBXluo0aF32u6bsWoK5ZT1mVUfgeU1Ijvd6H+/ZqKBwauqXSUNDe+ru+qhfsl2oDwwfVWNW0n61e3muEAYHYdxnEesJOZrZPUzcw2SrqDkLXwWsKH/7wYJFwIHGRmH8S6X8SywWZ2KoCky4CnzOx4Sd2AlxO3PgYQMjluTvjQP9fMBkm6hnBV41rgATP7U2xrAnCCmd0g6WFiIBD3EX93AO4BjjKzmZK2BNYQgp3rzOzOWCeVrbGSmU0GJgMUFxdboea8LysroxDPbfz48HvUD2cw7dyulA4tye+AkhpxHYNC/fs1FQ8MXFPJdCuhrmp9K6GG+g01H7hT0kPAQ7HsVkKSpGuB4wnfvCEkV5oi6V7ggSztHQgcmpjXsDnh2ztAqZmtBFZKWg48EssXUJVAaUAMCLoBXah5lchiQrrmmQCptMuSXgDGSepNCDYWV9OGa+Em7XpdvofgmimffOgcvAZ8ow71fwDcCOwJzJTUzszeAz6R9B1gb+AxADM7CbgA+AowW1KPDO2JcPVjYPzZwcwWxn3rEvU2JrY3UhXYTwFONbPdgfGEwKLOzOwuwu2HNcCj8VxcAdqm/ef5HoJrxjwwcC7c579K0rYQLrVL+mWminH+wFfMrJSQ5rgr4Vs6wC3AHYTbFhWxfl8zeylO/PuMECCsBLZINPs4cJritX5Jg+o4/i2AjyS1J9zOSEnvJ2URsF2cZ4CkLSS1k7Qz8LaZXU+4+rFHhmNdAei62VpOXPibfA/DNVMeGLiWZL+0xxJHNkajZvYo8Efgn5JeA14BtsxSvS1wh6QFwBzgejNLrRTzMCFIuC1R/6r4COSrwPPAPKAU2C2ew1HApYRJh/Nj/5fW8RT+B3iJcNvijUT53cA58fHLvonz/QI4CrhB0jzgCcJVhp8Ar8Z5GQOAjI+OupbvzfJe+R6Ca8ZkZvkeg3MFQdJg4Boz2y/fY2kKxcXFtmjRonwPIycKffLa5Gsf46mru3J3gaZeLvS/n6TZZjY4V+37FQPnGoGk84D7CY8+Otes9R/YsWCDAtdw/lSCa1YkHQRckVZc38cb09seBxyZVpz1MUZJNwLfSiu+zsxuS69rZpcDlzd0jM45l28eGLhmxcwep+bH7erb9kQg21oGmeqfkotxOOdcc+aBgXPOtSLDh8OoH5YzbPzwfA+lSiMubuQazucYOOecc66SBwbOOdfKtKMi30NwzZgHBs4518p0brsm30NwzZgHBq5JSKpIW5zoxMTrckmL4uuMi+pIGiZpeVobB2Rpu0+G+v/M1G48/mJJH8R6b0i6Ka5wmKv3YqCkQ3LVfqKfwyTtlti+JPWeudZteUWXmiu5VssnH7qmkinR0SQASWWEtMezamij1kmUJPWppn4m15jZH2JA8DTwbcIKhbkwEBgMPJqj9lMOI6R0fh0gLsvsnHPV8sDAuU11ICwPvCxbBUmnE1IUbyB86B5NyD+wb0y13AZ4ExgCDAMuAiqA5YSUzJcQUkUPJeRpmAHcQFiGuD1wsZn9VdJowod7Z6Af8Ic4vl8QkikdYmafS/oVMCbu+1fcP5CQEOnbki4AjiAsnTzDzKbHPAnXxbbXAd8lZHS8LbbThpDYaZMMi5LGxL4oKioq2Jz35eXlBXtuo0ZB964VlI0ale+hVGnk97qQ/35NwQMD11Q6xjX4of4LFu2XaAPCB9db1bSdrJ91IaPoTEk/B3YEHjOzudXUPQ/YyczWSepmZhsl3UFIYHQt4cN/XgwSLgQOMrMPYt0vYtlgMzsVQNJlwFNmdrykbsDLiVsfA4BBhGDlX8C5ZjZI0jXAMbG/B8zsT7GtCcAJZnaDpIeJgUDcR/zdAbgHOMrMZkrakpBR8STCAk53xjpt00/czCYDkyEsiVyoy84W8pK648fDqB/OYOQj0/I9lCqN/LhiIf/9moIHBq6pZLqVUFe1vpVQQ/1MUrcS2gPTJf3UzO7OUnc+cKekh4CHYtmthIyE1wLHU5VI6TlgiqR7gQeytHcgcKiks+P25oRv7wClZrYSWClpOfBILF9AVfbDATEg6EZI4lTTAlHFwEdmNhPAzFYASHoBGCepNyHYWFxNG64F69Fueb6H4Joxn3zoXIKZrQf+DuxfTbUfADcCewIzJbUzs/eATyR9B9gbeCy2dxJwASHd8mxJPTK0J8LVj4HxZwczWxj3rUvU25jY3khVYD8FONXMdgfGEwKLOjOzuwi3H9YAj8ZzcQVo6Yau+R6Ca8Y8MHAuQeF6+7eAt7LsbwN8xcxKgXOBroRv6QC3AHcQbltUxPp9zeylOPHvM0KAsBLYItHs48BpsW8kDarjsLcAPopXO36WKE/vJ2URsF2cZ4CkLSS1k7Qz8LaZXU+4+rFHhmOdcwXOAwPXkuyX9ljiyEZs+8w4H+FVwr31/81Sry1wh6QFwBzgejP7b9z3MCFISCZZukrSAkmvAs8D8whPO+wWz+Eo4FLCpMP5kl6L23XxP8BLhNsWbyTK7wbOkTRHUt9UoZl9ARwF3CBpHvAE4SrDT4BX4/swAMj46KhzrrDJzPI9BucKgqTBhLkK++V7LE2huLjYFi1alO9h5EQhT14LuRJmMOaRknwPpYpPPqwTSbPNbHCu2vfJh841AknnAb9m00v5zjU7paVw/1Q8cZHLygMD16xIOgi4Iq24vo83prc9DjgyrTjrY4ySbiTMN0i6zsxuS69rZpcDlzd0jM41hR47+sqHLjsPDFyzYmaPU/PjdvVteyJQ3VoG6fVPycU4nHOuOfPAwDnnWpm35iznih8+w5JVHQHoQjl0bcJHGAcO8jsZzZg/leCcc63MFxvbs7ZdF7p0bUuXrm3Zqq0veOSqeGDgnHOt3LIuO9RcybUaHhg451wrt9mKz/I9BNeMeGDgspJUkbag0ImJ1+WSFsXXGRfCkTRM0vK0Ng7I0nafDPX/mandePzFidwCyfLna3Fe70rqmWW8+9Z0fEPE8zw6l33EfjY5F0knSTom1/26lmEzrd9ke6l1z9NIXHPkkw9ddTIlJ5oEIKkMONvMZtXQRq0TH0nqU039WjGzhnywDwPKCSsU5kofQprmu3LYB6Sdi5ndnOP+XAuyoU2HfA/BNWN+xcAVFEnl8XcbSf8r6Q1JT0h6NG0J5dMkvRKXK94lBiUnEZdGlpRx9UJJR0p6VdI8SU/HsqclDUzUeVbS1yV9O3H1Y46kLQhrHaSWdj5TUltJV0maKWm+pBNjG8Mk/Z+kv0p6W9Llkn4m6eU45r6x3g8lvRTb/6ekbTKdS/IKi6Svxrrz4nvQV9J28TzmxvNrFas3tlYVFZuueNuJ1XkaiWuO/IqBq07HuG4+1H+Rof0SbUDIIvhWNW0n62ddfKgWfkz4dr4bsDWwkJAaOWWJme0p6WTClY9fSroZKDezP1TT7oXAQWb2gaRusezPwGjgDEn9gc3NbJ6kR4BTzOw5SV2AtcB5sb8RAJLGAMvNbC9JmwHPSfpHbPfrwK7A58DbwC1mtrek3wCnAWcAzwL7mJlJ+iXwWzMbm34ukr6bOIc7gcvN7EFJmxO+IPwaeNzMJkpqC3TKdPJxvGMAioqKKCsrq+atarnKy8sL9twAevbewKiLPk4rXdV0A+hURi7f3kL/++WaBwauOpluJdRVrW8l1FC/roYSAouNwMeS0p+afiD+nk0IImrrOWCKpHsTbdwH/I+kc4DjCWmQU3WvlnQn8ICZva+QQDHpQGCPxNWMrkA/4Atgppl9BCDpLSAVMCwAhsfXvYF7JG0HdADeqW7w8arF9mb2IICZrY3lM4FbFTI0PmRmczMdb2aTgckQciUU6nr0hb7W/k0lj3LvhG0rt3uu+jdLOu/YdAPI8ToGhf73yzW/leBaq3XxdwV1CJDN7CTgAkL65NmSepjZakKGwh8RMhTeGeteDvwS6Ei4ErBLhiYFnGZmA+PPTmaWCgDWJeptTGxvTIz5BuCPZrY7cCIhS2KdmdnTwP7AB4TAxycqFrD2bDr58N0NvfM0EtcceWDgCtVzwBFxrsE2hMl4NVkJbFFdBUl9zewlM7sQ+IwQIADcAlxP+Ja/LFF3gZldAcwEdsnQx+PAr+M3dST1l9S5tidJuMLwQXx9bE3nYmYrgfclHRb720xSJ0k7Ap+Y2Z/iuexZhzG4FmZjW5986LLzwMDlWmqiXepnZM2H1NoFkt5P/aTtux94H3gduAN4BahpebdHgMOrm3wIXBUn/71KmPE/D8DMZgMrgGSCpTPiRL75wHrgMWA+UBEn/p1J+BB+HXgltjmJut3iuxi4T9JsYEktz+UXwOlxXM8D2xICp3mS5gBHAdfVYQyuhWlT8UW+h+CaMZlZzbWca4EkdTGzckk9gJeBb5lZ+oyrxuqrF1AG7BLnNRS84uJiW7RoUb6HkROFfo86zDHYrnJ7y/VLWNH+S0t75I7PMWgQSbPNbHCu2vfJh66QzYhPDnQALs1hUHAMIWvjWa0lKHAtW9u2m06Cver+r9L/oJ3yNBrX3Hhg4BpM0kHAFWnF9X28Mb3tccCRacW1eozRzIY1Rb9mdjuQcfVH55qj/gM7UrpsUL6H4ZopDwxcg5nZ44RJdLloeyLh23iTyle/zjmXbz750DnnnHOV/IqBc861Motnr+Dw762kY5t1FHd6j/fWbs3SDVtW7v9ap3dYvXFz3llbNUGx92af0nOvvsxNLH215Zaw887w9tuwYkVV+cCBsGQJvJ94Vuhvf4PiYhiZeC5pxAgYOxbGjIHFi0NZjx4wfTpMmQJTp1bVnTQp/D7xxKqyY4+F0aNDm0uXhrJ+/eDoo6GkBGbMqKo7fTosWgTjxlWVjR0bxjB8eFXZkCFw2WVw/vnwwgtV5aWlob2SkqqyiROb7pwmT/7yOeWKP5XgnKsXfyqh5Zpc8gjTJtRjUaOB9Z+XkMunENIV+t8v108l+K0E55xrZXrpo3wPwTVjHhg451wr8xlNuGaBa3E8MHA5I+kMSRmz9NWnXq5J+r6kWZJej2mMS2L5xZI+iKsIvi5pVOKY0XFxo9R2zs8lpml+Lf4uSqRd3k9SRRxnr1j3G3Glxn9Jul4xi1M89g2FVM8PpjJFxjZej6swugK11uqVUsO1Eh4YuFw6gyzpe+tZr1JMDZzcrtVE2mz1JA0A/gj83Mx2AwYD/0pUuSZmg/wRMCmV24CQbrlXol6dz6UexgB7mNk5wHeBBWY2yMyeIWatNLMPY92bgF8RMjb2Aw6O5U8AA8xsD+BN4HcAsY1Dcjx+51wz5k8luEYRE//cS0gD3JaQirgXUCppiZkNl3QTsBch2+B0M7tI0ukZ6h0IjAc2A94CjotLG78L3AN8D7hS0knAXEKK5WmS7gduBXoSEhwdZ2b/kTQFWAsMIiRXOivDKfwWmGhmbwCYWQXhQ3UTZrZY0mpgK0n7EwKIOyWtIeRJ2ORcsrxX5bHtQ4CPgPOBK4EdgDPM7OEY+FxOyGGwGXCjmU2S9DDQhZDZcRpwCtBR0mBgSFo/2wFbmtmLcft24DDgsUQGR4AXgVrlsJA0hhCYUFRUVLA578vLywv23AB69t7AqIvqsRBop7J699mUb2eh//1yzQMD11gOBj40sx8ASOoKHAcMN7NUcp9xZvZ5/NB7UtIeZna9pLNS9ST1JKQ1PsDMVkk6l/BBfklsY6mZ7Rn7OAnokJqdK+kRYKqZTZV0PCHb4WHxuN7AvvEDP5MBQEmWfZUk7QksNrNPgemSTgXONrNZcf+ZaeecSWfgKTM7R9KDwARCsLMbMBV4GDgBWG5me0najJC2+R9mdqik8nj1AkmfAIPN7NS4nexne0IiqZT3Y1m64wkBV43MbDIwGcJTCYU687vQZ7U/VPJnpk2oRwJNfyqhVfDAwDWWBUCJpCuAGWb2TNqHFMBP4jfOdsB2hA/C+Wl19onlz8XjOwCJp4m/9AGW3B4C/Di+/gvhW3jKfdUEBbVxpqTjgP7ADxvQDsAXwN/j6wXAOjNbL2kB0CeWHwjskchG2ZVwK+CdBva9ibj08wbgzsZs1zVv5ao2u7hr5TwwcI3CzN6M36YPASZIejK5X9JOwNnAXma2LF7ezzQDSsATZjYqwz6AVTVsZ1NTvf9n78zD7BzPP/75JrEkQpAMbShTEUMFQYr6oRlFVYMgylCEaqhaYiutthKl1thrSTVCqYbYU2qdaUIJIhuJBE1stcZSQxLJ5P798TwneZ0558yZycycOefcn+s617zvs9zP/ZyXvPd5tu/LwPZEGeUMXGFml0naD/iLpD5mtijPttNZYisOEFkGLAYws2WJNRACTorHTbeUdwgjJSk2jGmhAWkoMAj4QcIfpwz43LoX2gWnA+OLD51WIa6C/9LMbgMuBbYDPgdSP03WIrycP5O0PvCjRPVkuWeB/5O0abS7hqTN8nTj38Ch8fpwYFIzunAp8JtUW5I6xamKr2FmDwAvAEdl8D3TnH0v9AAAIABJREFUfUt5BPhFapGjpM3iOo68MbN3gf9J2inuRjgSuD/a25uwrmI/M/uyFfx1HKdE8BEDp7XYCrhU0jJgCfALwtD+PyX9Ny4qnAq8ArxFWASYYnRauaGExYSrxfzfElbON8VJwM2SziQuPszXeTObIWl4bLcbYEC2w0fPA/4m6c/AWOCGuPjwe+l9ybf9DNxEmFZ4Mb7UP2TFeonmcEL0sSvwcPxA2IGxGvBYnLJ51swaBUKO45QffiSy45QQcWHiSo0TS6okrBPpl6ucH4lcvNwx6g5Gn7958yv64sMOgdr4SGQfMXCc0uJ/kqYB+yTOMsgbSbsC1wG5dlU4Rc6qvdb82kt+ZcV88hEoqq5uP4Gimhro3bvt+wSFEV1qa3zEwCkr4s6CU9KSnzazX7ZBW5MJw/VJjjCzma3dViHwEYPixftX3PiIgeO0ImZ2M+EgovZoa8f2aMdxHKc18cDAcRyn3Jg7l2H7vM3oHf/SchvtuWjAaVc8MHAcxykz3l+4Fq8uyXQIpuP4OQaO4zhlx2cNfsCRkx0PDBzHccqQnp0+LbQLTgfFA4MCIKlB0rTE57jEdb2kOfH61iz1B0r6LM3GHllsV2Yo/3gr9mWwpO+0lr0c7VRKeimPMocl7gdIurqV/ThZ0mxJBdMWiM8z2+FLjpMX43e+vNAuOB0UX2NQGBam1PES3AggqY6EWl8OJpnZoHxsxwNrspVfWQYTTgiclZ4hqYuZLW2DNrNRCRwG/A0gfodNfY/N5QSC8mNStbAQfW0xxeSr0zb06fYeY1/ZiaGbP1toV5wOiI8YOF9DUoWkuyU9Hz//F9OvkvT7eP1DSRMl7QzsRzgKeZqkPpLqJF0p6QXgFEn7Sposaaqkx6NOApJGSPqrpGckvSrp5zFdki6V9JKkmZIOyeBjpaRJkl6Mn51j1kXArtGXU5O/rCWtK+k+STMkPStp64QfY6Lf/5F0co7v5gZgE+DhaD/Vh6eBv0paXdLN0e+pkqpjvaGx7cckzZd0oqTTYplnJa2bo81N4/c2Pfa1T8zqLmm8pFck3S6Fc40l/T4+t5ckjU6kpz+XsZKuj+3/J35XY+JoyNg8/lNxiphFS7twy0f7FNoNp4PiIwaFoavC6XQA88zsgBbY2DVhA+AgM3s9h+1k+bvM7IIsdq8iKAk+JWkjgpjPFsCvgeclTQKuJpys97qkBwjH544HiO+hVVOHb0haB9jJzEzSsQThntNjW1sTZJbXAKZK+gdBb6A/sA3QK7Y5Mc3HD4A9zWyRpL7AHcAA4GzCaMug2PbARJ2RwFQzGyxpd+DW2A7A5kA1QfxojqTrzWxJ+hdjZscriA9Vm9lHkkYQJKJ3MbOFkk4PxWwrSZsDj2qFAFQ/YFuCouRrwFlmtq2kKwjiRldmeR63AxeZ2b2SVicE89+KtrYE/kvQnfg/4CngWjM7L/b/rwT1xAejreRzGQusE7/v/YAHoo1j43fe38yS/30R6w0DhgFUVFRQV1eXxe3ipr6+vmT7BrCwYh1qLv6Muu7ZREzzoAN/P6X+/NoaDwwKQ6aphOaS91RCE+XT2QP4TnzBA6wlqbuZ1cdf9ROBU2MQko1xiesNgXGSvgmsCsxL5N1vZguBhZJqgR2AXYA7zKwBeF/Sv4DvAjMS9VYBrpXUH2gA8lFf3AU4CMDMnpTUU9JaMe8fZrYYWCzpA2B94O0sdtJ5IPYh1cY1sY1XJL2R8K3WzD4HPpf0GSte1jMJAVIjJK0JbGBm90abi2I6wHOp6YwY8FUSAoNqSb8CugHrEuSkU20lnwvAgzFgmwm8nzqRUdLL0V6jwMDMRhOEoqiqqrJSPV2u1E/OG335BO44qwe1u4xqunA2OvA5BqX+/NoaDwycdDoRfuEvypC3FbAA6N2EjS8S19cAl5vZA/EX/IhEXvp53Pmez30q8D5hVKETkMnX5rA4cd1A8/6/+KLpIo3aWJa4X9bM9jLZawC6xBGF64ABZvZWHNFYPYevSR/S/fN/G0qcG7e4qtAuOB0UX2PgpPMoQb4YgPirHEkbE6YAtgV+JCl13O/nhCH4bPQA3onXR6Xl7R/n5XsCA4HngUnAIZI6S6oAdgOey2DzXTNbBhwBdM7Dl0nA4bEvA4GPzOx/OfxuCck2NgM2AlosJhBHGN6WNDjaXE1BEjobqSDgI0ndgSE5yjplzPqrfFxoF5wOjAcGxUtqkV3q01ovgZOBAXGR3izg+LiA7S+E+fv/Aj8Dboq/UP8OnBkX0vXJYG8EcJekKTRW7JsB1ALPAn+Itu+N6dOBJ4Ffmdl7afWuA46SNJ2wPuCLhL2GuFDv1Ax+bC9pBmGRYnqQ0hpcB3SKQ/PjgKFximJlOAI4Ofr9b+Ab2Qqa2afAn4GXCGtDnl/Jtp0SpcdqizhudrqWmOMEXF3RKQhxmLvezC4rtC9Oy3B1xeJlxRqD37fciK8xKBhydUXHcRynVenUmfW/2blDv9ydwuGBQQdG0g+Bi9OSW7q9Md32OcDBacm5tjG2KmY2oj3aaQlxzcMTGbJ+YGYL2qjNPxG2Cya5KspEO06rsln/rgx7c+emCzpliQcGHRgze4QwV9wWti8A2iUIKDbiy39lt5M2t81ftmd7juM42fDAwHEcp0yorg5/z62Zy7B93mb0jn9pupJPN5QdHhg4juOUGe8vXItXl2xQaDecDopvV3QcxykzPmvoXmgXnA6MBwaO4zhlSM9OnxbaBaeD4oGB4zhOGTJ+58sL7YLTQfHAwCl5JK0t6YR4XSnpsETeUEnXtkGbdZJSSobHKEgxz4hyyPvH9LGS5sWTK6dL+kEeNudEO69IulbS2q3tu1P69On2HmNf2anQbjgdFA8MnHJgbeCEeF0JHJa9aPOQ1LmJ/A2BcwjSzCmZ6aRS5JlRDXM4cEMeTR4e7WxNED66v0WOO2XNoqVduOWjfQrthtNB8V0JTjlwEdAnyhMvATaL17cAnwDfklQHbADcZmYjASTdB3yLIE50VZQcRlI9cCNBovqXBLnjbKxHEHeqBzCz+tR1Gs/E9vPCzL6K8sqvSdrGzKZLOg04Jha5ycyulHQmsNjMrpZ0BbCNme0uaXfgZ2Z2eOzPVcAgYCGwv5m9n6ldScOAYQAVFRUlq3lfX19fkn2rqQl/F/ZYh5qLP6Oue03TlYrweyjV59deeGDglANnA/3MrH9UVjzDzAZBmEoAdgD6AV8Cz0v6h5m9ABxjZh9L6hrT746HH60BTDaz0/NoezpBInqepCeAe8zswQzl9gbua06nzKwhJSQlqQtwNLAjIGCypH8RFB9PB64GBgCrSVoF2BWYGE2tATxrZudIugT4OXB+ljZHA6MhaCWU6nn0pXrW/siR4W/NvimthFFNVyrCcwxK9fm1Fz6V4DjwmJktMLOFwD3ALjH95PjifZYwctA3pjcAd+dj2MwaCC/9IcBc4IooIJXiUklzgb/R+PjrfFD8uwtwr5l9EUcl7iG8/KcQVCXXIkw9PEMIEHYlBA0AXwET4vUUwnSLU+LcuMVVhXbB6aB4YOA4kC4xanFkYQ/ge2a2DTCVMKUAsCi+8PMzHnjOzC4EDgUOSmSfaWabAWcBY5rjdFzfsBUwO0fbS4B5wFCCbPMkoBrYNFFvia2QWW3ARxJLnvVX+bjQLjgdGA8MnHLgc2DNDNcp9pS0bpwyGAw8DfQAPjGzLyVtTlg02Gwk9Za0XSKpP/BGhqLXAp2icFY+dlcBLgTeMrMZhBf+YEndJK0BHMCKEYFJwBmEqYNJwPHA1EQw4JQZPVZbxHGzTym0G04HxX8ZOCWPmS2Q9LSkl4DHgNTc/FjC4sPnCFMDGxIWH74gaSZwvKTZwBzCdEJLWAW4TFJvYBHwIeHFnO6jSTof+BW5hbNul7QYWA14HNg/1n9R0tjYFwiLD6fG60mEnRHPmNkXkhaxImhwypC59b0L7YLTgZH/aHAcpyVUVVXZnDlzCu1Gm1Dqi9dGX/kwT17eg7+XqPRyqT8/SVPMbEBb2fepBMdxnDJjs/5dSzYocFYen0pwnJVA0r3At9OSzzKzXNMB7W7TcRwnXzwwcJyVwMwOKAabjuM4+eKBgeM4Tpkxe8qXjDxgas4ytZ9s207eOB0NX2PgOI7jOM5yPDBwHMcpMzqxrNAuOB0YDwwcx3HKjC7K++BOpwzxwMApKiTVS6qUtFDStMTnSEmT4/Wbkj5M5FVmsTVfUq943ZBm7+yYXidpjqTpkp6X1L8J/+ZLmhk/sySdL2n1JuqsLemEXGViudr0kxElDZd0fRP+TEpLmxYPe0rd7yBpYuznVEk3SerWlD9O8fKVrVJoF5wOjC8+dIqV180s/SV9KyxXTBxgZic2w97CDPZSHB5PQzwauBTYswlb1Wb2kaTuBCXCG4GjcpRfGzgBuK4Ju3cQtBaS2xYPJZyWmIs1JX3LzN6StEUyQ9L6wF3AoWb2TEwbQjg2+ssm7DqOU4J4YOA4+fMMcGa+hc2sXtLxwFuS1iWoGN4PrEM4Kvm3ZnY/cBHQR9I0wpHNI7OUGw+cL2lVM/sqjoT0BiZJ+iYwDliL8P/1L8wsNVJwJ3AIcBlQQwgwjoh5vwRuSQUF0e/x2fokaRgwDKCioqJkNe/r6+tLtm8AvTZcSs257+UsU8z9L/Xn19Z4YOAUK6kXaYqTEi/CltA1zd6FZjYurczewH3NMWpm/5M0jyDZPAU4IKb1Ap6V9ABwNtAvNWIhqUumcmb2saTngB8RAodDgTujzsJhwCNmdkFUXUxOBdwN3EwIDPYFDmdFYNAPuKUZ/RlNGAWhqqrKSvXY2VI/Uvf6UQ9x5/nfyFmmmLcrlvrza2s8MHCKlUxTCStDrqmE2yWtCnQnqCM2FyX+/lHSbsAyYANg/SzlM5V7jxXTCanA4GexzvPAmKi6eJ+ZJYOcBcAnkg4lSC37FEGZs5q+KrQLTgfGFx86TtMcDmxC+GV9TXMqSloTqATmRjsVwPYxCHkfyLQwMVe5+4EfRCnnbmY2BcDMJgK7Ae8AYyUdmWZzHPAnQmCR5GVg++b0ySl+FtuqhXbB6cB4YOA4eWBBhvR3wE6SNs+nTlx8eB3hF/wnQA/gAzNbIqka2DgW/Zyw2C9FtnKYWT1QC4wh8ZKXtDHwvpn9GbgJ2C7NnXuBS2gs6XwtcJSkHRO2DoyLEh3HKUN8KsEpGuLc++J4m77GYIyZXd1Mk0l76WsM/mlmZycLm9lCSaMICxB/RnZqJYkQeN8L/CGm3w48KGkm8ALwSrS7QNLTcQvhw8DFmcoluCPaPTSRNhA4U9ISoB742oiBmX0e7RJcW57+fpxiuEzSeoSpi4nAP3P0z3GcEsYDA6eY2JKwtmA+0DVbITMbC4zNZUhSBaD4wsTMOmexNTDtflQuu2ZWmSPvI+B7WfIOS0vKWC6WvY8V6xZSabeQYRFhJn/i99cvcf8MsGu29hzHKS88MHCKgrjt72RgeCvY2o8wrP7rlbXlOMXIer2WFfWuA6dt8cDAKQrM7AbghpbUlTQZWC0t+WAzm9lSf7LYPGJlbDpOe9Fz4+6FdsHpwHhg4JQ8ZrZj06UKb9NxHKcj4IGB4zhOGVFdDUfs+ylThlzI6Vs9+vXM2trCOOV0KHy7ouM4TpmxlC6cvtWjDJuca3ONU654YOA4jlOmvLpk46YLOWWHBwaO4zhlRp9uuQWUnPLGAwOn6JFUL6lS0kJJ0xKfIyVNjtdvSvowkVeZxVZ3SddLel3Si5KmSPp5+/YoO5LqJA2I1/Ml3Z3IGyJpbLwemujvrFx9kHS4pBmSZkr6t6Rt2rwjTkFZtDQsL+vZ6dMCe+J0RHzxoVNKZBJWuhXCixIYYGYnNmHjJuA/QF8zWxYPQjomvZCkLma2tBV8Xlm2l/QdM5uVIW+cmZ0YTzR8OSo0vp+h3Dzg+2b2iaQfEdQTfddFCfPOV70AGL/z5QX2xOmI+IiB40Qk9QF2AH5rZssAzOxDM0sdJTxQ0qQolTwrpp0m6aX4GR7TKuPxxim7Z0gaEa/rJF0Vf8m/JGmHmL6GpDGSnpM0VdL+Mb2rpL9Lmi3pXhqf+DgKOCdXv8zsA+B1EpoLafn/jloOAM8CG+b5lTlFzthXdiq0C04HxEcMnFIiXT/hJDOb1Iz6WwLTU0FBFrYD+pnZPEnbA0cTfl0LmCzpX8AnOepDUEXsH2WVxxCOJz4HeNLMjpG0NvCcpMeB44AvzWwLSVsDL6bZuhM4QdKm2RqTtAlBHfK1JvyCoAHxcA5bw4BhABUVFdTV1eVhsvior68v2b7V1MC6PRqoq6nhq/re1HX/9orMEulzKT+/9sADA6eUyDSV0GIknQMcDKxnZr1j8nNmNi9e7wLca2ZfxPL3EDQHHmjC9B0QpJIlrRUDgb2A/SSdEcusDmxEkFK+OpafIWlGmq0G4FLC8c7pL/RDJO1CEIo6zsw+bqK/1YTAYJdsZcxsNGGqgaqqKhs4cGATXS1O6urqKNW+jRwJww+8lYH33MHIp86jdpeE/EeJnGNQys+vPfDAwHFWMAvYRlInM1tmZhcAF0iqT5T5Ig87S/n6NN3qafmW4V7AQWY2J5mRVELMwV8JgcFLaenj8lhTkWpna8L6ih+Z2YJ86jjFS4/VFhXaBacD42sMHCdiZq8RZI7Pl9QZQNLqpCkZJpgEDJbUTdIawAEx7X1gPUk9Ja0GDEqrd0i0vQvwmZl9BjwCnBTlmpGUUriZCBwW0/oBW2fwewlwBXBqS/otaSPgHoLWw9yW2HCKi7n1YQDsxi2uKrAnTkfERwycokZSF8JQOTReYzDGzK5upsljCUPzr0laACwEfpWpoJm9GLcHPheTbjKzqdGv82L6O8AraVUXSZoKrMKKHQ9/AK4EZkjqRNgpMAi4HrhZ0mxgNjAli99/AX7bvK4u5/dAT+C6GJcsNbMBLbTlOE6R44GBU+xsSVhbMJ/GK/aXY2ZjgbFNGTOz/xEW/GXKqwPq0tIuBxrt+YoBSbag5DYzG55WfmGmdmP6oVn8qUxcLwZ6J+7Hkkd/Y9ljCQGRU2YcN/sUanf5faHdcDoYHhg4RYuk44GTgeFNlXUcJ1BbC6Ov7Ez1tMtZ/5sLS2bBodN6eGDgFC1mdgNwQ0vqSpoMrJaWfISZzVxpx3JgZgPb0n4uJB0NnJKW/LSZ/bIQ/jiFY7P+Xan9ZNumCzpliQcGTlliZmV3sp+Z3QzcXGg/HMfp2PiuBMdxHMdxluMjBo7jOGXG7ClfMvKAqY3SfXrBAR8xcBzHcRwngQcGjuM4ZUYncsmBOOWOBwaO4zhlRhc1FNoFpwPjgYHTbkiqj5LEC6PscOpzpKTJ8fpNSR8m8iqz2JovqVe8bkizd3ZMr5M0R9J0Sc9LyimwFG3OTNi5OqZvHu+nSuoj6eQog3x7C76D4ZK6Je4fiiJKzUaSSRqVuE/KO4+Q9E5C3nm/HHZ2k/SipKWShrTEF6e4+MpWKbQLTgfGFx86hSCTCuKtAJKGAgPyFf+JLMyhqni4mb0Q9/BfCuzZhK1qM/soLW0wMN7Mzo8+ngDsYWZvN8PHFMOB24AvAcxsnxbYSLEYOFDShRl8BrjCzC6TtAUwSdJ6WSSl3wSGAmdkyHMcp8zwwMApF54BzmxuJUn7EF7mDZJ+AMwBNgEeljSGIEF8DdCPoH0wwszujyJMFwN7A8uAPxPEmHoDtZI+MrNqSfOBAYSX8ltm9qfY7gigPr7YzwR+QjiQ6V4zOze6tzS2fypwTrY+mNlsSUuBXsAHGfLnxzabnHiWNAwYBlBRUVGymvf19fUl2zeAXhsupebc9xqll0qfS/35tTUeGDiFIF3s6CQzm7QS9rqm2bvQzMalldkbuC8PW7XS8gnYW8zsCkk3EF/SAJL2Jo4sSPoj8KSZHROnBJ6T9DhwJFAJ9DezpZLWNbOPJZ1G5lGJcQQRpT/F+58AP5S0F9AX2IEQWDwgaTczmxjL/YkgvHRJtg5J2pEQnHyYR/9zYmajCcEIVVVVVqqa93V1dZRq3wCuH/UQd57/jUbppbJdsdSfX1vjgYFTCDJNJawMuaYSbpe0KtAdyKfNTC/tXOwF7CcpNQy/OrARsAdwg5ktBTCzj3MZMbOpktaT1BuoAD4xs7cknRLbSG06704IFCbGev+TdCtBM2JhmtlTJf0U+Bw4xMysGf1ySpjV9FWhXXA6MB4YOKXO4QSp4ksJQ/4HtrJ9AQeZ2ZyvJQb54uZyFzAE+AZhBCFl/0IzuzFHvSuBF2l83PEVqVEOx0my2FYttAtOB8Z3JTglT/yl/DtgJ0mbt7L5R4CTFCMBSamx2MeA4yR1ienrxvTPgTWz2BpHkFgeQggSUvaPkdQ92tlA0nrJSnE04k7gZ63SI8dxyhoPDJx2Ib4gF8fbPmnbC09ugcmkva5p9i5KL2xmC4FRNL0AsTZh59Y8/PgDYdHhDEkvx3uAmwir/WdImg4cFtNHA/+U1Ejr1sxeJgQN75jZuzHtUeBvwDOSZgLjyRxYjCIsLmw2kr4r6W3gYODG2A/HccoUn0pw2ostCWsL5gNdsxUys7HA2FyGJFUAMrPPY53OWWwNTLsflalcIr8yS/qIbOViwHFchjpLgdPiJ5l+DWFKI2ObZrZVBltXAVdlSO+euH4f6Ja4H5FePhtm9jywYb7lHccpbTwwcNocSccTFscNbwVb+wGXAL9eWVuOU66s12tZyexAcFofDwycNsfMbgBuaEldSZMJ+/eTHGxmM1vqTxabR6yMzWJA0jmE6YIkd5nZBYXwxykcPTfu3nQhp2zxwMDp0JjZjsVgsxiIAYAHAY7j5MQDA8dxnDJj9pQvGXnA1EbpPr3ggO9KcBzHcRwngQcGjuM4ZUYnmpTFcMoYDwwcx3HKjC7L5UAcpzEeGDjthqR6SZWSFqYdSHSkpMnx+k1JHybyKrPYmi+pV7xuSLN3dkyvkzRH0nRJz0vKqZUQbc5M2Lk6pm8e76dK6iPpZEmzJd3egu9guKRuifuHovhSs5FkkkYl7s+IqoxIGiHpnej3S3GbZzY7p0maJWmGpCckbdwSf5zi4StbpdAuOB0YX3zoFIJMIkq3AkgaCgwwsxObYS+XiNLhZvaCpKMJegl7NmErk4jSYGC8mZ0ffTwB2MPM3m6GjymGA7cBXwKY2T4tsJFiMXCgpAuzCD9dEWWbtwAmSVrPzDKNIU8lfOdfSvoF4ZyIQ1bCL8dxihgfMXDKhWeADZpbSdI+hJf5LyTVRgnmTYCHJZ0qaQ1JYyQ9F0cU9o/1Oku6LP5anyHppHj0c2/Cscu1sdx8Sb0kXSTpl4l2R6QUGyWdGUc8ZkgamXBvKeGI5VNz9cHMZseyGY9MNrNaM/sy3j6Ln4LoOGWNjxg4haCPpGmJ+5PMbNJK2OuaZu9CMxuXVmZv4L48bNVKyydgbzGzK2IwUJ9SKpS0N3FkQdIfgSfN7Jg4JfCcpMeBI4FKoL+ZLZW0rpl9LOk0Mo9KjCOoJP4p3v8E+KGkvQgyyzsQlBYfkLSbmU2M5f5E0GO4JFuHJO0ILAM+zKP/PwMezmFrGDAMoKKigrq6ujxMFh/19fUl2zeAXhsupebc9xqll0qfS/35tTUeGDiFINNUwsqQayrhdkmrAt2BfNrM9NLOxV7Afqlf98DqwEbAHsANUTMhpYCYFTObKmk9Sb2BCuATM3tL0imxjdSm8+6EQGFirPe/KPZ0MrAwzeypkn5KUHQ8JKpMZiWWHQB8P4efowmjFFRVVdnAgQNzmSxa6urqKNW+AYy5/D7u+MM3GqWXyjkGpf782hoPDJxS53BgCmF9wTXAga1sX8BBZjbna4lBhbm53EWQXP4GYQQhZf9CM7sxR70rgReBm9PSr0iNcjSFpD2Ac4Dvm9nipso7xc1iW7XQLjgdGF9j4JQ88Zfy74CdJG3eyuYfAU5SjAQkpX5yPQYcpyA3jaR1Y/rnZJZNhhAMHEoIDu5K2D9GUvdoZwNJ6yUrxdGIOwnTAM0m+nwjsJ+ZfdASG47jlA4eGDjtQnxBpn6J9knbXnhyC0wm7XVNs3dReuEojzwKOLMJu7UJO7fm4ccfgFUI8/wvx3uAm4A3Y/p04LCYPhr4Z2rxYZqPLxOChnfM7N2Y9ijwN+AZSTOB8WQOLEaRZXFhHlxKmKK4K/b7gRbacRynBPCpBKe92JKwtmA+0DVbITMbC4zNZUhSBSAz+zzW6ZzF1sC0+1GZyiXyK7Okj8hWLgYcx2WosxQ4LX6S6dcQpjQytmlmW2WwdRVwVYb07onr94FuifsR6eWzYWZ75FvWcZzSxwMDp82RdDxhcdzwVrC1H2Gf/a9X1pbjlCvr9VpWMgsNndbHAwOnzTGzG4AbWlJX0mRgtbTkg81sZkv9yWLziJWxWQxIOgc4OC35rijH7JQRPTfu3nQhp2zxwMDp0JjZjsVgsxiIAYAHAY7j5MQDA8dxnHKhuhqA2fv+ipEjv55V22g5rFOu+K4Ex3Ecx3GW44GB4zhOmdGJTFpajhPwwMBxHKfM6NI55+nYTpnjgYHjOE6Z8VVDxqM/HAfwwMDJE0km6bbEfRdJH0qaEO+XywQnysyX1CtebyjpfkmvSnpd0lVR3AhJA6P9fRN1J0gamMOfQVHmeLqkWZKOS8ufJunvGeqdJukVSTNj3cslrZLwd/3EyYfvSXonXs+M7aSnT0v0Y3DsR85jlyVVSloY686SdGvCh4GSPks7yXGPmHeOpJej/PK0qJqIpDpJc2La7KiA2OgZZPNRUidJVytIRM9UkHj+dq4+OI5TuviuBCdfvgD6SeoaT/vbE3gnn4pRR+Ae4Hoz219SZ8LRwBew4ojitwkiPg/mYW+VWH8HM3tb0moEieNU/hZAZ2BXSWuY2Rcx/XiCUuFOZvZpfKGfRjiJcUms3pBSapQ0goTccsJ+xnSgBngq/j23iW68bmb943fxGEHmHs8PAAAgAElEQVRm+faYN8nMBqW1+T1gELCdmS2OL/ukEs7hZvZC1GR4XdJYM/sqQ7uZfDwE6A1sbWbLJG1IeN6O45QhHhg4zeEh4MeE8/prgDuAXfOotzuwyMxuBjCzBkmnAvMkpV5O04FVJO1pZo81YW9Nwn+7C6K9xUBS3bAG+CuwBbA/QWsAQuCxm5l9Gut9BTTSVWgJCiJHuwDVhOCmqcCA6EODpOeADZoo+k3go5TyYQ5p6O6El3pDM3z8JvCumS2Ltt/O5kQcjRgGUFFRUbKa9/X19aXZt5oaAHr1WEJNTd3XskqpuyX7/NoJDwyc5vB34Pdx+mBrYAz5BQZbEqSPl2Nm/5P0JrBpIvkCgghRzsDAzD6OQj9vSHoCmADckXqxEX4B7wlsDpwE/E3SWkB3M5uXh78tYX/gn2Y2V9ICSdub2ZSmKklaHdgROCWRvKukaYn7g4BHCd/9XOBxYJyZ/StR5nZJi4G+wHAzaxQY5PDxTuApSbsCTwC3mdnUTP6a2WjCaA1VVVVWqpr3dXV1lGTf4uEFYw44nTvuHfi1rFI6x6Bkn1874WsMnLwxsxmEIfsawujB17KzVWuG/YkAknbJo+yxwA+A54AzCEEKkgYQflm/SXjJbasVksfLkfTDOCc/X9LO+fqYgxpC4ET8W9NE+T7x5f8+4df6jETeJDPrn/i8bmb1wPaEX+sfAuMkDU3UOdzMtgY2As6QtHG+PsYRgiqC/sQy4AlJP8ir105RsnipLz50suMjBk5zeQC4DBgI9EykLyAMSSdZE/gUmAUMSWbEX/AbAa8BOySyLgB+CyxtypGobTBT0l+BecBQwstuc0nzY7G1gIPM7M+S6iV928zmmdkjwCNx9GPVDObzJgYeuwNbSTLC+gaTdKaZZQuMUmsMegFPS9rPzHLKHcdRgDqgTkGC+SjSlCjN7ENJLxJGId7I18c4RfEw8LCk94HBhMDKcZwyw0cMnOYyBhiZQXBoIrCfpDUBJB0ITI8vsyeAbpKOjHmdgVHAWDP7MmnEzB4F1iFMVWREUnd9fcdCf8K0QifCIr6tzKwyShrvz4pf7xcC10taO9oRsHoz+5+JIcBfzWzj2O63CIFKk9Msca3A2TShFimpSlLfRFJ/Ei/+RLluwLbA6/n6KGk7Sb1j/U6E776RbcdxygMfMXCaRRx2vjpD+gxJ1xLmqg34ADg25pmkA4DrJP2OEJA+BPwmSzMXAPfncEPAryTdCCwkLLYbSngRv2Nm/02UnQh8R9I3geuBNYDJcT6+HngayDif3gxqgIvT0u6O6RPzqH8fMCLO8UPjNQbnE17i18SgZilhpGVYosztkhYSVCPHZljfkMvH+4E/x90dEKZnrs3Db8dxShBlH+l0HMfJTlVVlc2ZM6fpgkVIqS9eu/uWCRx01KCmCxYppf78JE0xswFtZd+nEhzHccqMnht3L7QLTgfGpxKcDo2ke4H0U/jOiosHOzSStiKcp5BksZntWAh/HMdx8sEDA6dDY2YHFNqHlhIXaPYvtB+O4zjNwacSHMdxyoTq6vCZ+2L9ihvHScMDA8dxHMdxluOBgeM4TpnRpbGUhuMsxwMDx3GcMmONzgsL7YLTgSn5wEBSQ5q2/dkxvS6eq99U/YGSPkuzsUcW25UZyj+ew/YISWe0Qh+PTrT3laSZ8fqimD9Y0gxJs2Pe4Jj+p1hulqSFCRtDYn4XSR+m7CTay/e76ympNh5FfG1a3nxJdyfuh0gaG6+HxnZTvv08Ue5Hkl6I6VMljUrkDZP0Svw8p4TmQvR5jqTpkp6XlHNRYPRvZvzeHpX0jUR6r7SyjZ5jspykcyS9HG1Nk5R1V0K6/fjf04TE97JM0taJ/JckVcbr7pJulPS6pCmxzzvGvA0l3S/p1Zh/lYLsdPp/469ISpeTdkqMzxp8u6KTnXLYlbDQzFZ2ZfgkM8t0Gkgj2/Ef6Wzl24QoZ3xzbH8+UJ2S5ZW0DUHbYE8zmyfp28Bjkv5jZr9M+Dwhw/e0JzAXOFjSr3Oc+5+NRcDvgH7xk872kr5jZrMy5I0zsxMlrQe8rKCmWEE4ke/HZvaKwtHKw2IfBgHHAbuY2UeStgPuk7SDmb0XbR5uZi9IOhq4NPYvF9XR1h8JpzSe3KzeB7++BwwCtjOzxfGlvzLaDG8T5KMPyZB3E+GExL5mtiw+6+9IEnAPcL2Z7R+/t9GEEybPjHUnmdkgSV2BqZLuNbOnV8JPx3GKlHIIDIoCSScDxxOOu51lZocqCN+MATYBvgSGpanw5cMZwB9TcsMxOLiQ8EI4oom6NcBVwC+A7wH/bk7DZvYF4YjkTbMUGUV4yR2ew8YHkl4HNgZOBC4ws1diXgPhmGOAs4AzUwGRmb0o6Rbgl4TgJMkzrHgh5sNEWhAURL5JUHtcHP36qIV2UkwAdpNUZWbLjx2U1IcgnHR4Sn46PvN5CkqJi2IAiZk1SDo15p2bNG5mCxWOY94gU+OShhGDsYqKipLVvK+vry/JvtVE1ZB1ezRQl7opwX6W6vNrL8ohMOiqr587f6GZjWumjfSz6w8ys9fTbM9L7LlPlr/LzC7Io42zgW/HX5Vrx7SRwFQzGyxpd+BWmr8vfkvCiEGSFwgvzKxIWh3Yg/ArfG1CkNCswCAP7gROyBE4IGkTQmD0GmHUYVSWolsC6foALxAUCNPZm6BPkC+DgHTRqHx5FPi9pLnA44SRkH+10BYEWeRLCCMYyb5tCUyLwVI6jb4bM/ufpDeBr333ktYB+pJF48HMRhNGG6iqqrJSPXa2VI/UHTky/K3ZdwJDHrwj3NTWFs6hNqJUn197UQ6BQbtOJTRRPhczCEI497HipbULcBCAmT0Z5+zXMrP/NdN2SxgE1MZfkHcDv5M0PMuLp6U0EIb0f02Q/E1ySFwjsBg4zsw+DiPiK8XtcV69O/kFWLWSGgjP5rc5ymWbYjEzq5e0PUHgqRoYJ+lsMxvbDFvpaX8DzolTBa3FrpKmE4KCKxPTL04J0rPLZ4V2wenAlPziwyLix8CfgO2A5yW1VtA2C9g+LW174OUm6tUAe8Q1C1OAnsDureRTkr8CuwHfSksfZ2b9zWxHM7s3pr1M476kyKefhxNGH24BrsnDt+row5Fm9mmOcgsIUtFJ1gQ+hTB0b2Z1ZnYuYTrkoGbYWhf42vSDmS0ljJyclUh+Gdgmrh9Ip9F3I2ktYCPCSAyEYHYbwujCz5panOkUNwuW9ii0C04HxgODDoCkTsC3zKyW8I99D8Kv2knE+XdJAwlz1c0dLbgM+HVi5XolYRg625B86qWxK7CRmVWaWSVh6qGmmW03iZktAa4ATs2j+KXAbyRtFv3sJOn4mHcJcLGknjGvP0GK+bq09oyw5mAnSZu3SifCsPt+ktaMbR8ITI9z+VWS+ibK9gfeyGGrjrj2I77kfwpkGusdS5jqqQCIU1svACPjYkMUdsn8GHgC6CbpyITdUQR55i+TRuO6hIv4etDhOE4ZUQ5TCelrDP5pZmfH639IWhKvnzGzg7PYSF9jcL6ZjW9FHzsDt0nqAQi42sw+lTQCGCNpBmHxYab58pyY2TRJZwEPSloFWAL8ysym5ah2APBkasFc5H7gEkmrxfu8vrs44rAWsKrCNsm9MuxC+Au5h+pTfZkhaThwh6RuhCH2CTHvAUkbAP+WZMDnwE/N7N0MdhYqbHM8E/hZU+1mYIakZfH6TjM7TWE75lOx7Q+AY2N+d+CauG5kKeEX+rActv8AXB+H9QX8E7gtQx++knQ1YXFoimMJL/zXJC0kjDScaWYm6QDgOkm/I/wgeIgQIGbiBuAMSZVmNj/nN+E4Tsmh5u9AcxzHCYsP58yZ03TBIqRUF6+lpBFq9p3AsAfjoKEvPiw6JE0xsybPkmkp5TBi4DiO47AiBrj7FkoyIHBaBw8MIpJ+CFyclpzcgrgyts8B0ofa893GmG7raOCUtOSnU4cVFYK2/O7aGkmTgdXSko+Ikslt2e69QPqugrPM7JG2bNdxAHpu7CcfOtnxwCAS/0Fuk3+UYwDQ7CAgi63lpxx2FNryu2trzCzr8cRt3G6HD5ocxylPfFeC4zhOmVBdHT5zX6xfceM4aXhg4DiO4zjOcjwwcBzHKTO60JoHmDqlhgcGjuM4ZcYanRcW2gWnA+OBgVM0SDJJtyXuu0j6UNKEeD803k9LfLZJXH8saV68fjxLG50kXS3pJUkzJT3flCaBpIMlzZZUK6m/pH1i+tGJtr+K9qZJuiiDjWMlXZnn97CFpH9FW7MlXd90rYx2bouHTjllxmcNvivByY7vSnCKiS+AfpK6mtlCYE/gnbQy48zsxLS0/gCSxgITmji18hCgN7C1mS2TtGFsNxc/A35uZk9JGgoMAB5K7iCJJ0BWZ5JdboEuxrXAJWb2j3j8cb9m1nccx8mKjxg4xcZDBMEpCNoNd7Sy/W8C75rZMgAze9vMPgGQVBN/9b8k6eKY9nuCCuZfJF0BnEdQhpwm6ZBsjUg6X9Ktkp4m6B4k8/aT9LSkdXP4+Hb0z1JnLsQRlCuifzMknRDTR8aRj5ck3ZDSUkhr87txFGKKpIclrd+M78xxnBLCRwycYuPvwO/j9MHWwBiC4FOKlFxziu/F0YV8uZOgebArQXzoNjObKqk34RCn7YFPgEclDTaz8yTtDpxhZi9EjYMBGUYtMrE5sJuZLZJ0LICkIcBJwD5mlk0b93JgYgwqHgVujmV/QRjt2CYKOKUCi6vM7NwYEPwN2JuEzHXUv7gK2M/MPpJ0OEGzoZGmg6RhqfSKigrq6ury6GbxUV9fX5J9q4kyaOv2aKAudVOC/SzV59deeGDgFBVRSKmSMFrwUIYimaYSmmP/bUlVBInp3YEnJB1MEEOqM7MPASTdTpCLvq+lbQH3m9mixP2ewA4Eoan6HD7eJOlh4IcEwathCmqSewBXmllDLPdxrPIDSWcCqwO9CDLaDydMbkGQW348DiZ0Jo5IZGh7NDAaglZCqZ5HX6pn7Y8cGf6eeMDtDLw3DraV4NHIpfr82gsPDJxi5AGCnPRAoGdrG4+qkg8DD0t6HxgMZFysuJKkr114DdgU6AtMbcLHdwijJWMkvUJ4uTdCQYXyWmA7M3tH0vmEAOFrxYAZZrZrIwNOSbJgaY9Cu+B0YHyNgVOMjAFGtoWegaTt4rQBkjoRpiveAJ4Dvi+pl6TOhBGLf2Uw8TmwZgubn0fQ1LhdUsYXffRr79SCxejrOsB/gceA46N/xKmErsAy4CNJawIHZTA5C9hA0g6x3qqStmxhHxzHKXI8MHCKjrgg8Oos2amFf6nPzs00vx7woKSXgBnAUuBaM3sXOBuoBaYDU8zs/gz1a4HvNLX4MBtmNgs4Arg7xzbJHwEvx/UMDwHD4xTHjcB7wIyY9xMzWwDcQnj5PwxMztDmYmAIcLmkGYTRioJoSDiOU3hkZoX2wXGcIqSqqsrmzJlTaDfahFKdo05JI9TsO4FhD44KN77GoOiQNMXMBrSVfV9j4DiOUyakYoC7b6EkAwKndfDAwClLJG0F/DUteXGhZJgzEc9IODAt+e9m1ujkRMdpDj039pMPnex4YOCUJXHhYv9C+5ELMzuPcGCS4zhOu+GLDx3HcRzHWY6PGDiO45QJ1euE4zGGX/IB1SOBt96EBQu44Nt/oarbWwxhPLWXPA/nnLOi0umnw6BBK1YuAnzve/DHP8JvfgPPPLMivbYWJkyAUaNWpF1wAVRVwZAhK9IGDQp2hw2DV18NaT17wvjxMHYs3HLLirI33hj+HnfcirSjjoKhQ4PNBQtCWt++MHp0aHvNNVec5jR+PMyZ0zH7tNlmdER8V4LjOC3CdyUUH6nA4NyLn2fgsEYnXlNdXRprEovi+a3El93WuxJ8KsFxHKfMmPvltwrtgtOB8cDAcUoESVn1FZppp7ekXNLUTrHTWGATCKPhjuNrDBzH+Rpm9l/CSYhOqdI1XS4jcPrp7exHOXPUUYX2ICs+YuA4JYakgVGWOnV/raSh8Xq+pAvjkc0vRG2IRyS9Lun4WKYyHgntlChrdMqsRJ5h2YHTVgwdWmgPsuIjBo5TfrxpZv0lXQGMBf6PoLj4EnBDroqShgHDACoqKkpW876+vr4k+1ZzbggIeqz9Rcb+DRgApdDtonh+//kPbLJJob3IiAcGjlN+PBD/zgS6m9nnwOeSFktaO1dFMxsNjIawK6HDr/xuIUWxqr0FjDwg7Eo49rx5DBoysHH+SN+V0G504C/bpxIcp/RYytf/306fUF4c/y5LXKfu/cdCGfBFQ9eM6T17trMjTofEAwPHKT3eIEg/rxZHAH5QaIecDsbqq2VMHu97UdqPvn0L7UFWPDBwnBLDzN4C7iSsGbgTmFpYj5xiYezYQntQRoweXWgPsuKBgeOUCGbWPXH9KzPra2Z7mdmBZjY2plea2UfxeqyZnZioU2lmH5nZfDPr1+4dcNqNzTq9ljE9eWqv08Ykj1juYHhg4DiOU2Z8tnSNQrvgTJjQdJkC4QuNHMdxyoTaT7YFYPSV7y3XTQC48e9xM8q0T6H6tHDdlFBR8sXW0YSKamqgd+9w3Rzxpfbs0/rr01FxESXHcVqEiygVL96/4sZFlBzHcRzHaTc8MHAcxykXqqupXmcqc6dlPhLZccADA8dxHMdxEnhg4DiOU2Z06bSs0C44HRgPDBzHccqMNbr5onMnOx4YOE4rImltSSfE60pJhyXyLohyx6nPXEkNkrpnsTVQ0s6J+7GShmQq6zjN4bP6zoV2wenAeGDgOK3L2sAJ8boSWB4YmNk5ZtY/9QGeBy40s/ostgYCO2fJaxUU8H8HHMdZjv+D4Dity0VAH0nTgEuBXePowKnJQpJ+CmwKjMhkRFIlcDxwaqy/a8zaTdK/Jf0nOXog6UxJz0uaIWlkIv00SS/Fz/CUbUlzJN1K0FP4naQrE3V+LumKlf4mHMcpSvyAI8dpReILfYKZ9ZM0EDjDzAZlKPMUMNDMMh9aH8qNAOrN7LJ4PxZYAzgE2Bx4wMw2lbQXMAQ4DhDwAHAJ8AUwFtgppk8Gfgp8AvwH2NnMno1TGdOBzc1siaR/A8eZ2cwMPg0DhgFUVFRsf+eddzbr+ykW6uvr6d494wxPcTN3LnO//Bbr9l5Cr/XWKrQ3bUbJPr9IdXV1mx5w5EciO047IqkzcBvwu1xBQQ7uM7NlwCxJqTNV94qf1Bm33YG+8e+9ZvZFbPseYFdC4PCGmT0LYGb1kp4EBkmaDaySKSiIZUcDoyGcfFiqp8uV7Ml5I0cyctrlnHjlO6XZv0jJPr92wgMDx2lffgu8a2Y3t7D+4sS1En8vNLMbkwUlnZLDzhdp9zcBvwFeAVrqm1MkLPjEFx862fE1Bo7TunwOrJnhGkk7AUOJQ/HNtJWLR4BjUrsbJG0gaT1gEjBYUjdJawAHxLRGmNlk4FuExZJ35Omf4zgliI8YOE4rYmYLJD0t6SXgMaBB0nTCXP/eQDegVlKy2kFm9noGcw8C4yXtD5yUo81HJW0BPBPt1gM/NbMX47qE52LRm8xsalzjkIk7gf5m9klenXUcpyTxwMBxWhkzOyxLVrNW+pvZXGDrRNKktPzuieurgKsy2LgcuDwtbT7QL0OTuzTXR8dxSg+fSnCcMiceyjQXWGhmTxTaH6cNqa2l9pNt6blOQ6E9cTowPmLgOAVG0tFA+kLBp83sl+3Rvpl9CmzWHm05HYOeG5fuVj5n5fHAwHEKTNyh4DsBHMfpEPhUguM4TplQXR0+b0z9OFw4TgY8MHAcxykzFtuqhXbB6cB4YOA4juM4znI8MHAcx3EcZzkeGDiO4ziOsxwPDJw2Q5JJui1x30XSh5ImxPuh8X5a4rNN4vpjSfPi9eNZ2ugk6eooKzwzSg9/uwm/DpY0W1KtpP6S9onpRyfa/iramybpogw2jk1KFTfR3vmS3om2Zkn6ST718kXSHpI+i/ZnSzqnNe07jlNe+HZFpy35AugnqauZLQT2BN5JKzPOzE5MS+sPy2WGJ5jZ+BxtHAL0BrY2s2WSNqSxQFA6PwN+bmZPSRoKDAAeSm4blDQfqDazj9IrS2rJ/zeXmtmVkjYHJku628xa85SZWjMbHPUSZkiaYGbTm6okqYuZLW1FPxzHKXI8MHDamoeAHwPjgRqCQM+urWj/mwS1wmUAZvZ2KkNSDUExUMA/zOwsSb8nHP37F0kPAQcBXSXtQlAoHJepEUnnAxsBfYB5QF0ibz/gLGBfM/s4l7Nm9oqkJUAP4GNJfYFrgV6EgOZYM5sr6VCCEmMD8LGZVUvqCtwAbAcsAYab2cQ0+/WSXgT6SHoZuCT2d3XgajO7SdIe0XZ9LLcvcD8wE9gm/j0qBnPp38MwoghURUUFdXV16UVKgvr6+pLsW01N+LtujwbqamqgBPsIpfv82g0z849/2uRDePFsTQgKVgemAQMJowAQlAY/jOmpT9dE/bHAkCba2BCYH+uOAraN6b2BN4EKQgD8JDA45tUBAxI+XJvB7nygV+L+fIIY0erx/ljgSmAI8C+gRw4fzye8xAG+C9Ql8mqBPvH6/4BH4/VsYP14vXb8exYwOl5vCbwBrArsAdwX0ytiv6uAE4CzY/pqwFRCcLNHfDYbxbxNAQN2ive3pvzN9dlss82sVKmtrS20C23CwIHhc+OoB8NFiVKqzy8F8IK14b/dPmLgtClmNiOq+dUQRg/SyTSV0Bz7b0uqAnaPnyckHQx0J7yAPwSQdDuwG3BfS9sC7jezRYn7PYEdgL3MrL6JumfGX9t9gdSahrWBnYC7E2qLqf8nnwZulXQXcE9M2wW4FMDMXpb0X8JLHaBa0lRgGfAHM5sj6WJgizj6AGGUom+8fsbM3kz4N8/Mno3XtxFGBfJaQ+E4TmnhgYHTHjwAXEYYLejZ2sbNbDHwMPCwpPeBwUDGxYorSfrahdcIL+a+hF/juUitMTiQMI3RlzDF8ZGZ9c9Q/ufAjsAg4EVJ2zZhv9bMBqelCTjB0oSR4lRCel+siXvHccoE35XgtAdjgJFmNrO1DUvaTlLveN2JMHXxBmHY//uSeknqTBix+FcGE58Da7aw+XnAwcDtkrbIp4KZ3UOYw/+pmX0CvCvpgJT/kraJRTeJv+B/B3wCbECQXT48lt2CsL7itRzNPQKckFosKakqrlPIxLclfTdeHwY8lU9/HMcpPTwwcNocM3vbzK7Okn1I2nbFnZtpfj3gQUkvATOApYQ1A+8CZxPm8KcDU8zs/gz1a4HvxLYPaWbbmNks4AjCdEDObZIJzgNOV5g/OBQ4XtJ04GXCCAHAFZJmEoKIWjN7CbiGsFByJnA7cKSZfZWjnRuBV4Fp8fu5nuyjhLOB0yTNBroBo/Psi+M4JYbCOgbHccoVSZsC47NMaWSlqqrK5syZ00ZeFZa6ujoGDhxYaDdanZRuUs2+Exj24CiorS2sQ21EqT6/FJKmmNmAtrLvIwaO4zhlQm1tjAU6dS7ZoMBZeXzxoVMUSNoK+Gta8mIz27EQ/mQinpFwYFry382s0cmJHQkze414qJRTHmzWP9tSE8fxwMApEuLCxQ798jKz8wjrBxzHcYoWn0pwHMcpE6qrV6wzGLbFxNyFnbLFAwPHcZwy4/3X6nn1vZbu0nVKHQ8MHMdxyozP6jsX2gWnA+OBgeM4ThnSc41FTRdyyhIPDJyiR1K9pEpJC9MOSzpS0uR4/aakDxN5lVlsdZd0vaTXJb0oaYqkn7dvj7IjqU7SgHg9X9LdibwhUaoaSUMT/Z2Vqw+S9pc0I5Z9ISpNOiXO+Le/V2gXnA6K70pwSonXMxzScyuEFyVBUbEpwaabgP8Afc1smaQK4Jj0QpK6mNnSVvB5Zdle0nfiCYzpjDOzEyWtB7ws6QEzez9DuSeAB8zMJG0N3Als3pZOO4WlzxarMvbYpxh6k8eATmM8MHCciKQ+BLXEw8xsGUBUZ7w45g8E/kDQLtgc2EzSaawIHG6KQkmVBGnpfrHeGUB3MxshqY5wRPP3Cf//HWNmz0lag3DkcT9gFWCEmd0ftQ1uBrYBXgHSN6CPAs4haihkwsw+kPQ6sDHQKDBIU4ZcgxwCSlEhchhARUVFyWre19fXl2TfamrC3/ovv+Crfl+VZB+hdJ9fe+GBgVNK9JE0LXF/kplNakb9LYHpqaAgC9sB/cxsnqTtgaMJKogCJkv6FyFwyEU3M+svaTeCwFQ/wsv9STM7JsoxPyfpceA44Esz2yL+mn8xzdadBKGkTcmCpE2ATcghuBSFnC4kaE/8OFs5MxtN1FGoqqqyUj12tlSP1B05Mvyt2f9h7hj5DWo/aUq0szgp1efXXvgaA6eUeN3M+ic+zQkKGiHpnDjv/t9E8nNmNi9e7wLca2ZfxF/d9wC75mH6DgAzmwisFQOBvYCzY2BTB6wObATsBtwWy88gCEUlaeD/2bv3OCnL+v/jrzfgAcSUw6KiKYm6mqhoJJmHdkvNTM0TKnkID6Ff84RpWVpialqKeCwkUzRNyfMh81Q7gf4MT8uZ8BCIkGdIXQWE5fP747oGboaZ2dlld2d25vN8PPbh3Nd935/7umfU+cx1X/f9gauAn2U5ztEx3t3AqWa2MFeHzOxBM9ueULL60gLOwTlXpnzEwLlVZgK7SOpkZivM7HLgcknJofZPC4iznNWT7vUz1mcO1RthxOEIM1utKlEowNikPxESg+kZ7eMLmFOxekfMJkjaWlJvM/ugOfu6juXmezYudhdcifIRA+eiWDPgJeAySZ0BJK1P+NLOZiJwqKRucY7AYbHtXaCPpF6S1mNVKeW0o2PsvYCPzOwj4EngzFiKGUnpMd4JwPdj2wBg5yz9XgaMBka05LwlbZM47m7AesCHLYnlOoZN+nhVXZebjxi4Dk1SF2BpXMycY3CrmV3fzJCnEIbmX5f0IbAY+Em2Dc3slXh74Aux6RI1oO8AACAASURBVBYzq4/9+lVsX0CYNJi0RFI9YZJheuLipcC1wFRJnYA5hITi98BtkmYBs4CXc/T7j8BFzTvVlY4ATpC0jHC+R5vXYy9rG/XtxqmH/Y+6pmbDuIrkiYHr6HYkzC2Yy5oz9lcys3HAuKaCmdnHhAl/2dalCNf/k23XANdk2fZ6IFdScqeZnZOx/eJsx43tx+ToT7/E66VA38TyOAo437jtb4h3XrjK8OrkxcBGxe6GK1F+KcF1WJJOI0ysa+kvZecqSl1d+APYZMPFxe2MK1k+YuA6LDMbA4xpyb6SJhGupScdH8s7txkzq2nL+PlIOhE4O6P5OTP7UTH644pnu4FdGT7v68XuhitRnhi4imRmg4vdh/ZmZrcRHpbknHM5+aUE55yrFLW1HL7Ow/xnWiF33bpK5YmBc85ViOGTTmZR9y1Z3uj/63e5+b8dzjlXIV5btlWxu+A6AE8MnHOuwvTfYd1id8GVME8MnCsCSRtLOj2+7ifp+4l1wyTd2AbHTEmaLWmKpOckVcf2gyTVx/aZkrI+x8F1fL06/Q+AJZ98XuSeuFLmiYFzxbExcHp83Y/42OPWkH6ccw7HmtkuwO3AVZLWIVRLPDi270rGQ5xc+bjv6+FZXAvmF7kjrqR5YuBccVzJqkc4XwXsHSs5pusdfDH+wn9N0sXpnSQ9JOllSTMkDU+0N0gaJWkKsEcBx58AbANsSLht+UMIT1DMLOTkyse4f3+t2F1wHYA/x8C54rgAGGBmAyXVAOeZ2UEQLiUAuwMDgM+AFyX91cxeAk4ys4WSusb2+83sQ2ADYJKZ/bjA4x8MTIuxHgHelPR34DHgbjNbkW2nmIwMB6iqqiKVSrXo5EtdQ0NDWZ7b5+fvydBO79Cz77KyPL+0cv382osnBs6VpqfjFz6SHgD2IlR+PEvSYXGbLwLbEn7tNwL3FxD3LkmLgbnAmQBmdoqknYB9gfOA/YBh2XY2s7GESw9UV1dbTU1NC06t9KVSKcrx3C7ZbyJ07845N71dlueXVq6fX3vxxMC50pRZ3dDiyMK+wB5m9pmkFLB+XL/EzBoLiHtsHHlYPXh4FPQ0SX8iVHYc1tKOu9K3Ud9uxe6CK2E+x8C54viEcH0/83XafpJ6xksGhwLPEcrhLYpJwfbAWl8wltQ9JhxpA4E31zauK00373AdkK6u6Fx2PmLgXBGY2YfxlsHpwNNAY5w4OA5YBLxAuDSwBaFM80uSpgGnSZoFzAb+1QpdEfATSTcDi4FP8dEC5yqaJwbOFYmZ5btFcVyW7ZcC38kRq3sBx6vJ0vYJcGBT+7rycOqss6HJf1NcpfNLCc45VyE22SzfIy6cC3zEwLkyI+lB4EsZzT81syeL0R9XOu6Z93UAv5XP5eWJgXNlxswOa3or55zLzi8lOOecc24lTwycc65S1NZS26Peb1d0eXli4JxzzrmVPDFwzrkK06VT1lIYzgGeGDjnXMXZoFvmE7edW8UTA9dmJJmkOxPLXSS9L+mxuDwsLk9O/O2SeL1Q0pz4+pkcx+gk6XpJ0yVNk/SipMxb9TL3GSJplqQ6SQMlHRjbT0wc+/MYb7KkK7PEOEXStQW+D5dJWhBjzZR0VCH7FUrSvpI+ivFnSbqwNeO78vNRgz/PwOXmtyu6tvQpMEBSVzNbTKjatyBjm/FmdkZG20AASeOAx8zsvjzHOBroC+xsZiskbRGPm8/JwA/N7NlY4ngQ8LiZ3QbcFo89F6g1sw8yd5bUkv9urjKza2ONg0mxXHIhRY8KVWdmh0rqDkyV9JiZTWlqJ0ldzGx5K/bDOdfBeWLg2trjwHeB+4ChwN3A3q0YfzPgbTNbAWBm89MrJA0Ffk6oB/BXM/uppF8SShj/UdLjwBFAV0l7AVeY2fhsB5F0GbAl0J9QfTCVWHcI8FPgYDNbmK+zZvZvScsIBZEWStoWuBHoTUhoTjGzVyUdA1xEKKe80MxqY0GlMcBuwDLgHDObkBG/QdIrQH9JDYRHK3cHVgCnm9kkSfvG2A3xfHaQ9CghwVofGG1mt+R4H4YDwwGqqqrK9kE5DQ0N5XluQ4cy9Hvv0LPvsvI8v6hsP7/2Ymb+539t8kf44tmZkBSsD0wGagijABCK9bwf29N/XRP7jwOObOIYWwBz476jgF1je19gHlBFSID/ARwa16WAQYk+3Jgl7lygd2L5MkJho/Xj8inAtcCRwD+BjfL08TLClzjAV4FUYl0d0D++3hN4Kr6eBWwSX28c//lTYGx8vSOhCuK6hFLMD8X2qnje1UC3RH+3BybF1/vGz2bLRD96xn92A2YCPZr6fLfbbjsrV3V1dcXuQtuoqbGajV+xm0c/XuyetKmy/fwi4CVrw/93+4iBa1NmNlVSP8JoweNZNsl2KaE58edLqga+Gf/+LmkI4VdyyszeB5B0F7AP8FBLjwU8bGZLEsv7AbsD+5tZQxP7nh9/bW9LLFokaWNC6eT7JaW3S/83+Rxwh6R7gQdi217AVQBmNkPSf4Ft4rpaSfWEkYFLzWy2pB7AjZJ2AZYTRgfSnjezeYnlEXHkA0Ky1R94qYlzch1Urx6teRXLlRtPDFx7eAS4mjBa0Ku1g1uoOvg34G+S3gUOBbJOVlxLmXMXXid8MW8L1Dexb3qOweGEyxjbEi5xfGBmA7Ns/0NgMHAQ8IqkXZuIX2dmh2a0/Rh4CzgOWIcwSrDGucRLC/sAXzOzxZKeJYzwuDL14SKffOhy87sSXHu4FbjEzKa1dmBJu0nqG193Ily6eJMw7P8NSb0ldSaMWPwzS4hPgA1bePg5wBDgLkk7FLKDmT0ATAOOM7NFwNuSDkv3P/66B9jazP4F/AJYBGwOTASOjdvuQJhf8Xqew21EmH9hwA8IiUiu7RbGpGBHwuUO51yF8sTAtTkzm29m1+dYfXTG7Ypfb2b4PsCjkqYDUwlD5jea2dvABYRr+FOAl83s4Sz71wFfjsc+upnHxsxmAscTLgfkvU0y4VfAjxWuHxwDnCZpCjCDMEIAMFrSNEISUWdm04EbCBMlpwF3ASeY2ed5jnMjcEqM/SVgaY7t/gp0kzSTMB9iUoHn4ZwrQwo/Jpxzrnmqq6tt9uzZxe5Gm0ilUtTU1BS7G62vtpbaydcw9OJ3GH7Od4rdmzZTtp9fJOllMxvUVvF9xMA55ypFXR11i3b1yYcuL5986DoESTsBf8poXmpmg4vRn2ziMxIOz2i+x8zWeHKic8XUa6vuxe6CK2GeGLgOIU5czDZ7v2SY2a8I8wecc67D8ksJzjlXIWp71FPbo55XJy8udldcCfPEwDnnnHMreWLgnHMVpkunFcXugithnhg451yF2aCb36bucvPEwLUbSQ2S+klanPFQoxMkTYqv50l6P7GuX45YcyX1jq8bM+JdENtTkmZLmiLpRUl5Jy/GmNMSca6P7dvH5XpJ/SWdJWlWrL/Q3PfgHEndEsuPx5oJzSbJJI1KLJ8naWR8PVLSgtjv6Yk6CLliHSVppqQZkv7ckv64juOjBn8kssvN70pwxfBGlvoAdwBIGkaofNicwkqLc9QbADjWzF6SdCKhANF+TcSqNbMPMtoOBe4zs8tiH08H9rVEiedmOAe4E/gMwMwObEGMtKXA4ZKuyNJnCOWTr46PT54oqY/F8tRJsW7Dz4A9zWyRpD5r0SfnXAfnIwauUjxPqDfQLJIOJHyZ/5+kOkljgK0JBZtGSNpA0q2SXogjCt+L+3WWdHX8tT5V0pmSziKUg66TVBe3mxvrOVwp6UeJ446UdF58fX4c8Zgq6ZJE95YDY4ER+c7BzGbFbXvn2OSHwE2xdgNm9l5z3yfnXPnwEQNXDP0lTU4sn2lmE9ciXteMeFeY2fiMbQ6gsJLLdZLSj4W73cxGx2SgwcyuBpB0AHFkQdKvgX+Y2UnxksALkp4BTgD6AQPNbLmknma2UNK5ZB+VGA9cC9wUl48Cvi1pf0L1xt0JRZAekbSPmU2I290ETJX021wnJGkwoRzz+zk22S5u9xzQGRhpZk/kiDUcGA5QVVVFKpXKddgOraGhoSzPbejF4TbFnn2XleX5pZXr59dePDFwxZDtUsLayHcp4S5J6wLdKewBSdm+tPPZHzgk/eueUK54S2BfYIyZLQcws4X5gphZvaQ+CpUiq4BFZvaWpLPjMdJlnbsTEoUJcb+PJd0BnAVk3pw+QtJxhAqSR1vuwihdYswaYAtggqSdzOx/Wfo5ljBKQXV1tZXr8+jL9Vn7lxwW/jU649oFZXl+aeX6+bUXTwxcuTsWeJkwv+AG1nxk8doScISZrVZNKBRObLZ7gSOBTQkjCOn4V5jZzXn2uxZ4Bbgto310epSjCfOBSWa2DJgj6VVCovBiczrvOo4PF/nkQ5ebzzFwZS/+Uv4F8DVJ27dy+CeBM2MJZSTtGtufBk6V1CW294ztnwAb5og1nlCG+UhCkpCOf5Kk7jHO5pmTA+NoxF+Ak1t4Dg8RRguId3psB/ynhbGccx2cJwauXcQvyKVxsX/G7YVntSBkMl7XjHhrFC0ys8XAKOD8JuLWJeLcUUA/LgXWIVznnxGXAW4B5sX2KcD3Y/tY4In05MOMPs4gJA0LzOzt2PYU8GfgeUnTgPvInliMIvfkwqY8CXwoaSZQB5xvZh+2MJZzroPzSwmuvexImFswF+iaayMzGweMyxdIUhUgM/sk7pN1XNTMajKWR2XbLrG+X472kbm2iwnHqVn2WQ6cG/+S7TcQLmlkPaaZ7ZQl1nXAdVnauydevwt0SyyPzNw+lziiskZfnXOVyUcMXJuTdBpwN3BRK8Q6BJhIuO/eOdcMdYt2pW7RrvTq0dj0xq5i+YiBa3NmNgYY05J9JU0C1stoHhLLMLdIjpjHr03MjkDShcCQjOZ7zezyYvTHFU+vrbo3vZGrWJ4YuJJmZoM7QsyOICYAngQ45/LySwnOOVchanvUU9ujnjdnNBS7K66EeWLgnHMVZukyf46By80TA+ecc86t5ImBc84551byxMA555xzK3li4NqNpAZJ/SQtznhS4QmSJsXX8yS9n1jXL0esufHxvUhqzIh3QWxPSZotaUosW5y3iFKMOS0R5/rYvn1crpfUX9JZkmZJuqsF78E5krollh+PVRmbTZJJGpVYPk/SyPh6pKQFsd/T4/MfcsUZlvGen9KS/jjnyoPfruiKIVt1xTsgfEkBg8zsjGbEy1dd8Vgze0nSiYRCSvs1EStbdcVDgfvM7LLYx9OBfc1sfjP6mHYOcCfwGYCZHdiCGGlLgcMlXZGjIuRoM7ta0g7AREl9zGxFjljjm/meO+fKlCcGrlI8T9N1EtYg6UDCl3mjpG8Bs4Gtgb9JupVQ++AGYAChZsJIM3tYUmfgN8ABwArgD4RKiX0J9Rg+MLNaSXOBQcB5wFtmdlM87kigIX6xnw8cRXgo04NmdnHs3vJ4/BHAhbnOwcxmSVpOqKXwXnPfg4z3YzgwHKCqqqpsa943NDSU5bkNvThU5u7Zd1lZnl9auX5+7cUTA1cM/SVNTiyfaWYT1yJe14x4V5jZ+IxtDiBUEWxKnaT082JvN7PRksYQv6QBJB1AHFmQ9GvgH2Z2Urwk8IKkZ4ATgH7AQDNbLqmnmS2UdC7ZRyXGE8on3xSXjwK+LWl/Qgnk3QmJxSOS9jGzCXG7mwiFmn6b64QkDSYkJ+/nOe8jJO0DvAqMMLO3sm1kZmMJyQjV1dVWrjXvU6kU5XhulxxWD8DQi9/hyKNqituZNlSun1978cTAFUO2SwlrI9+lhLskrQt0Bwo5ZrYv7Xz2Bw6RdF5cXh/YEtgXGBOLKaVLI+dkZvWS+kjqC1QBi8zsLUlnx2PUx027ExKFCXG/j2MVyLOAxRlhR0g6jlDq+ehYLCmbR4G7zWyppFOB24FvFnj+zrky44mBK3fHAi8T5hfcABzeyvEFHGFms1drlFoS617gSGBTwghCOv4VZnZznv2uBV4BbstoH50e5cgno8TyLUDO0QfnXPnzuxJc2Yu/lH8BfE3S9q0c/kngTMVMQNKusf1p4FRJXWJ7z9j+CbBhjljjgWMIycG9ifgnSeoe42wuqU9ypzga8Rfg5JacgKTNEouHALNaEsc5Vx48MXDtIn5BLo2L/TNuLzyrBSGT8bpmxLsyc2MzWwyMoukJiHWJOHcU0I9LCZMOp0qaEZch/PKeF9unAN+P7WOBJyTVZenjDELSsMDM3o5tTwF/Bp6XNA24j+yJxSjC5MKWOEvSjNjPs4BhLYzjnCsDfinBtZcdCXML5gJdc21kZuOAcfkCSaoCZGafxH2yPvjdzGoylkdl2y6xvl+O9pG5tosJx6lZ9lkOnBv/ku03EC5pZD2mme2UJdZ1wHVZ2rsnXr8LdEssj8zcPhcz+xnws0K3d86VNx8xcG1O0mnA3cBFrRDrEGAi/kXmXLPVLdqVukW7Nr2hq2g+YuDanJmNAca0ZF9Jkwj37ycNMbNpLe1PjpjHr03MjkDShcCQjOZ7zezyYvTHFc92A3MO2jnniYErbWY2uCPE7AhiAuBJgHMuL7+U4JxzlaK2FmprmfVK5iMvnFvFEwPnnHPOreSJgXPOVZhO5Kql5ZwnBs45V3G6dM71dGznPDFwrtVJMkl3Jpa7SHpf0mNxeWSitkJ6m7mSesfXW0h6WNJrkt6QdF2s94Ckmhj/4MS+j0mqydOflKR56aczxraHJDXE150kXS9puqRpkl6U9KVWejtcCfq8MeujP5wDPDFwri18CgyQlL4nbD9gQSE7xi/vB4CHzGxbYDtC4aTk3QTzyVNmOYf/AXvGY2wMJB+DfDShHPTO8QFLh8XtnXMVyG9XdK5tPA58l/AI46GEBzztXcB+3wSWmNltAGbWKGkEMEfSxXGbKcA6kvYzs6cL7M89hDoMzxIKST1AeBolhCThbTNbEY85P1cQScOB4QBVVVVlW/O+oaGhPM9t6FAAem+0rDzPLyrbz6+deGLgXNu4B/hlvHywM3ArhSUGOxKqQa4USyvPA7ZJNF9OqMtQaGLwd+APkjoTEoThhMJSEAowPStp77jdnWZWny2ImY0l1HugurrayrXmfSqVoizP7ZJLAPj9wT9hyNE1xe1LGyrbz6+d+KUE59qAmU0F+hFGCx7PXJ1rt2bEnwAgaa8Cd2kkjBYcA3SNNSvSseYD1YTHTK8A/i7pW4X2xXU863VpLHYXXAnzxMC5tvMIcDXhMkLSh0CPjLYNCdf1ZwJfSa6Q9AVgS+D1jH0up3n1J+4BrieMEKzGzJaa2d/M7Hzg18ChzYjrOpily33yocvNEwPn2s6twCVZajBMAA6RtCGApMOBKWbWSBjK7ybphLiuM6Gk8jgz+ywZJJZk7kG4VFGIicAVZCQqknaT1De+7hTjvVnwWTrnyoonBs61ETObb2bXZ2mfCtxIuK4/GTgNOCWuM8JdAUMkvQa8CiwBfp7jMJcDXyywP2ZmV5vZBxmr+gCPSpoOTAWWx/455yqQTz50rpWZWfcsbSkglVi+Gbg5x/5vAQfnWJcZ5xFA2bZNbFOTr59m9gTwRL4YzrnK4SMGzjlXKerqoK6OPr188qHLzUcMnCsTkh4EMp9Y+FMze7IY/XGlq9dWawxqObeSJwbOlQkzO6zYfXDOdXx+KcE55ypEbY96anvU859pnzLq4FSxu+NKlCcGzjlXYZY3duLHj9YwfIcJxe6KK0GeGDjnXIV67Z0Ni90FV4I8MXDOuQrTf4d1i90FV8J88qErOkkNwABgFjA7seoa4EfAekBPoCuryhcfmnzefyLWXOATQm0AgNOB/wKPmdmANuh+TpL6seqc1gVeAk42s2Xt2Q/nMi355HMAem2wpMg9caXIEwNXSt4ws4EZbXcASBoGDDKzMwqIU5t8ul/8gm4zkrqY2fIcq98ws4Hx0cZPA0cBd7Vlf5xryoJYWPu++XsUtyOuJPmlBFdRJPWTNFHSK/Hv67H9HknfTWw3TtKRktaXdJukaZLqJdXG9cMkPSLpH4T6BnnFOggvAJvH/TtLukrSi5KmSjo1tm8maYKkyZKmx1LISGqQNFrSDEl/l1QV2wdK+leM8aCkHrE9Jek3kl6Q9Goizo6xbXLcZ9vYflyi/eaYyLgyN+6UZ4vdBVeCfMTAlZL+sXZA2plmNrEFceokNQJLzWxwxrr3gP3MbEn8UrwbGASMJ/ya/6ukdYFvAf9HuJRhZraTpO2BpyRtF2PtBuxsZgub6pCk9YHBwNmx6WTgIzP7qqT1gOckPQUcDjxpZpfHL+ducfsNgJfMbISkXwIXA2cQRlTONLN/SvpVbD8n7tPFzHaXdGBs35dQl+E6M7srnmdnSTsARwN7mtkySb8Djo2xM89jODAcoKqqilQq1dSpd0gNDQ1leW5DL14MQM++y0ilUnw+YHFZnme5fn7txRMDV0qyXUpoidUuJWRYB7hR0kDCPIT0l/zfgOvil/QBwAQzWyxpL+AGADP7t6Q3E/s8XUBSkE52vgT8NRZQAtgf2FnSkXF5I2Bb4EXgVknrAA+ZWTpRWkFIXgDuBB6QtBGwsZn9M7bfDtybOPYD8Z8vA/3i6+eBCyVtATxgZq9J+hah1POLkiDM5Xgv28mY2VhgLEB1dbXV1NQ0cfodUyqVohzP7ZLD6gE456a3qamp4ZLD6qlbtGuRe9X6yvXzay+eGLhKMwJ4F9iFcCltCUAcQUgB3yb8er6ngFifFrBNeo5Bb8KowCGJwkdnZntcsaR9gO8C4yRdY2Zr/HIHrIBjL43/bCT+t25mf5Y0KcZ/PF7CEHC7mf2sgJiuDGzUt1vTG7mK5XMMXKXZCHjbzFYAxwPJa+njgROBvVlVbXAiYVideAlhS1a/c6IgcQTjAiD95fsk8H9xZABJ20naQNJWwLtm9gfgFsLlCgj/raZHF74PPGtmHwGL0vMH4vmkRw+ykrQ18J9YDvphYGfCHIkjJfWJ2/SM/XBl6tXJ4ZLCzfdsXOSeuFLkiYErKkldWPXLtn+c/Jb+O6sNDvk74AeSpgDbs/qv/qeAbwDPmNnnie07SZpGSByGmdlSWuYhoFv8Ir8FmAm8Imk6oQRzF6AGmCKpnjBycV3c91Ng97jtN4FfxfYfAFdJmgoMTLTnchQwPV7eGADcYWYzgYsI8yemEu6e2KyF5+ic6+BkVsiIpHNtQ9IuwB/MbPdi96WUSWows5IqiVddXW2zZzd78KRDKNdr1LU9whyDoRe/w/BzvkNtD59j0BFJetnMBrVVfB8xcEUj6TTCXQEXFbsvzlWCukW7rkwEanvUs8mGi4vcI1eKfPKhKxozGwOMacm+cQLdehnNx5vZtLXuWPP7shPwp4zmbLdKtlipjRa4jm27gV3LcqTAtQ5PDFyH1JpfumsrJiOtcZulc84VnV9KcM4559xKnhg451yFqO1RT22P+pW3KzqXjScGzjnnnFvJEwPnnKswXTqtKHYXXAnzxMA55yrMBt38+TUuN08MOqhYhrefpMUZTws8QdKk+HqepPcT6/rliDU3PssfSY0Z8S6I7SlJsyVNiaWC887CjzGnJeJcH9u3j8v1kvpLOkvSLEl3teA9OEdSt8Ty45Ja9IxXSSZpVGL5PEkj4+uRkhZoVSnkQ/LEGZ0451cl/a8l/ckSd5ikvvH1gzH+65I+Shzv661xLFf+PmrwqtouN79dsePLVpHwDghfJsAgMzujGfEW56lweKyZvSTpROAqYL8mYmWrcngocJ+ZXRb7eDqwr5nNb0Yf084hVBr8DMDMDmxBjLSlwOGSrshRmXG0mV0dSxRPlNQn1ltYjZmNSL+WdCawxs3ikrqY2fJm9m8YMB34r5kdFuPUAOeZ2UHNCdTC4zvnKoQnBq4lngfOb+5Okg4kfJk3xlK/s4Gtgb9JupVQzvcGwjP81wFGmtnDkjoDvyGUQ14B/IFQEbAvUCfpAzOrlTQXGAScB7xlZjfF444EGuIX+/mEegHrAQ+a2cWxe8vj8UcAF+Y6BzObJWk50JscpYkThgIXxz7UAJcCiwg1GraTdBxwFrAuMAk4Pe73x3geBtwKvBWX75K0GNjDzLJOK5f0VeBqoHvs3zAze1fSs4SSznsDd0oaBHwU4/YmFI86GRgMPGdmJ+eIPxwYDlBVVVW2Ne8bGhrK8tyGXhz+tenZd1lZnl9auX5+7cUTg46vfyyIk3ammU1ci3hdM+JdYWbjM7Y5gFAQqCl1khrj69vNbLSkMcQvaQBJBxBHFiT9GviHmZ0ULwm8IOkZ4ASgHzDQzJZL6mlmCyWdS/ZRifHAtcBNcfko4NuS9ge2BXYnJBaPSNrHzCbE7W4Cpkr6ba4TkjSYkJy8n+/EY3XCLwH/SDTvBgwwszlx5OFoYE8zWybpd4QqjjOAzc1sQIyzsZn9T9IZhNGBl/Iccz1C0aVD4vt5LCEZGR436Zx+vrqkO4GNzGywpCOAR4E9gH8TCjsNMLPpmccws7GEBIrq6mor1+fRl+uz9i85bFWthCOPqiluZ9pQuX5+7cUTg44v26WEtZHvUsJdktYl/Bot5JjZvrTz2R84RNJ5cXl9QpnjfYEx6eFvM1uYL4iZ1UvqE6/JVwGLzOwtSWfHY9THTbsTEoUJcb+PJd1B+BWf+Yt8RPyF/wlwtDVdfewYwiWTxkTbC2Y2J77+FvAV4EVJAF0Jv/AfBbaWdAPwV0LFx0LtAOwIPBNjdgaSl2gyE7xH4z+nES5RzASQNJOQiK2RGLjy0KtHY9MbuYrliYFrjmOBlwnzC24ADm/l+AKOMLPVSvbFL7nmuhc4EtiUVV+IIoyA3Jxnv2uBV4DbMtpHp0c5CnQM8KOMtmSJZxFGUX6WuaNCxclvA6cRRjtOKvCYAqaa2d451n+asZwuH70i8Tq97P9vKGMfLvLJhy43vyvBNUv8pfwL4GuStm/l8E8CZypmApLSE/eeBk6V1CW294ztsDWBmQAAIABJREFUnwAb5og1nvDlfCQhSUjHP0lS9xhnc0l9kjvF0Yi/EK63t0h8X3oQ5mLk8nfgyPTxJfWUtFW8O6STmd1PqDq5W9w+37mmzQQ2l7R7jLmupB1beh7OucrkiUEHFL8g07/w+mv12wvPakHIZLyuGfGuzNw4TnwbRdMTEOsSce4ooB+XEiYdTpU0Iy4D3ALMi+1TgO/H9rHAE5LqsvRxBuGLdIGZvR3bngL+DDwvaRpwH9m/bEcRJuS11DHAPfkuN8Rh+4uApyRNJSQ/mwGbA6k4z+NOID2iMA4YE9/LrjliLiUkQtfEmPWEyYTOOVcwNX2p1JWaONT8BzPbvRViVQGTzWzzte+ZqyTV1dU2e/bspjfsgMp18lptj1WTD4ef850i96btlOvnlybp5fRE4rbgIwYdjKTTgLsJvzbXNtYhwERW/Sp1zpWxukW7UrdoV5986PLyCUYdjJmNAca0ZF9Jkwj37ycNMbNpLe1PjpjHr03MjkDShcCQjOZ7zezyYvTHuebotVX3YnfBlTBPDCqImbX69ea2iNkRxATAkwDnXNnxSwnOOVdBamvh1clZH5zpHOCJgXPOOecSPDFwzrkK06XTGvW/nFvJEwPnSpCkCyXNkDQ1PrtgsKRbJH25if2SJaJnShragmM3tLznriPYoJvfpu5y88mHzpUYSXsABwG7mdnS+DTEdc3slAJDpEtEbwu8LOk+M1vWZh12Hc5HDf5IZJebjxg4V3o2Az6ITzLEzD4ws/9KSsVyyUg6WdKrkl6Q9AdJN2YGMbPXgM8Ij2dG0g8lvShpiqT7JXWL7V+S9LykaZIua7ezdM6VJE8MnCs9TwFfjF/8v5P0jeTKWDXyF8DXgD2BrDUrJO0GvGZm78WmB8zsq2a2CzCLVfUgrgN+b2Y7AW+3/uk45zoSv5TgXIkxswZJXwH2BmqB8ZIuSGyyO/DPdPlpSfcC2yXWj5B0Ymw7ONE+II4IbEwoOf1kbN8TOCK+/hPwm1x9kzQcGA5QVVVFKpVq0TmWuoaGhrI9t6FDoefGy8r2/KC8P7/24ImBcyXIzBqBFKGg0jTgB83YPT3H4BDgj5L6m9kSQiGmQ81siqRhQE3ykAX2ayyheBXV1dVWrs+jL+dn7V9yCZwx7LGyPT8o78+vPfilBOdKjKTqOHEwbSDwZmL5ReAbknrESptHkIWZPQK8xKqkYkPgbUnrAMcmNn2OUBGSjHZXpj5c5JMPXW6eGDhXeroDt8fbDacCXwZGplea2QLg18ALhC/1ucBHOWL9CjhXUifCvIRJcZ9/J7Y5G/hRHJnwKpvOVTi/lOBciTGzl4GvZ1lVk3j9ZzMbG0cMHgQeivuOzBKrOi7+Pv5lHm8OsEeiaa0rdzrnOi4fMXCuYxopaTIwHZhDTAycc25t+YiBcx2QmZ1X7D64jqmuDu6/vbHY3XAlzEcMnHOuwvTaqnuxu+BKmCcGzjnnnFvJEwPnnKsgtT3qefd1r5PlcvPEwDnnKsxHDZ0ZvsOEYnfDlShPDJxzrgK99s6Gxe6CK1GeGDjnnHNuJU8MnHOuwvTfYV16bbCk2N1wJcoTA9fhSWqQ1E/SYkmTE38nSJoUX8+T9H5iXb8csbpL+r2kNyS9IullST9s3zPKTVJK0qD4eq6k+xPrjpQ0Lr4eljjfmfnOQdL2kp6XtFSSPx+hAiz55HPum79H0xu6iuQPOHLl5A0zG5jRdgeEL0pgkJmd0USMW4D/ANua2QpJVcBJmRtJ6mJmy1uhz2vrK5K+bGYzs6wbb2ZnSOoDzJD0iJm9m2W7hcBZwKFt2lNXMhbMh3GnPMuwW/YqdldcCfLEwLlIUn9gd+D7ZrYCwMzeB34T19cAlwKLgO2B7SSdy6rE4RYzuzaORjxmZgPifucB3c1spKQUMAX4BuG/v5PM7AVJGwA3AAOAdYCRZvawpK7AbcAuhMJHXTO6PQq4kDxVEc3sPUlvAFsBayQGZvYe8J6k7xbwHg0HhgNUVVWVbc37hoaGsj23oRcvpmffZSzkk7I9x3L+/NqDJwaunPSP9QPSzjSzic3Yf0dgSjopyGE3YICZzZH0FeBEYDAgYJKkfxISh3y6mdlASfsAtxKSgQuBf5jZSZI2Bl6Q9AxwKvCZme0gaWfglYxYfwFOl7RNroNJ2hrYGni9iX41yczGAmMBqqurrVxr3qdSKcr13C45rJ6hF7/D3ZdsSt2iXYvdnTZRzp9fe/DEwJWTbJcSWkzShcAQoI+Z9Y3NL8RqhAB7AQ+a2adx+weAvYFHmgh9N4CZTZD0hZgI7A8ckrjGvz6wJbAPcH3cfmosw5zUCFwF/Az4W8a6oyXtBSwFTjWzhQWeuitzm/SxYnfBlTBPDJxbZSawi6ROZrbCzC4HLpeUfEzcpwXEWc7qE3vXz1if+X9lI4w4HGFms5MrJBXS7z8REoPpGe3jC5hT4SrQRn27cfM9Gxe7G65E+V0JzkVm9jrwEnCZpM4AktYnfGlnMxE4VFK3OEfgsNj2LtBHUi9J6wEHZex3dIy9F/CRmX0EPAmcqZgJSEqP8U4Avh/bBgA7Z+n3MmA0MKJFJ+4qzquTFxe7C66E+YiB69AkdSEMlcOacwxuNbPrmxnyFMLQ/OuSPgQWAz/JtqGZvRJvD3whNt1iZvWxX7+K7QsIkwaTlkiqJ0wyTE9cvBS4FpgqqRMwh5BQ/B64TdIsYBbwco5+/xG4qHmnGkjalJAQfQFYIekc4Mtm9nFL4rmO4dRj/kddU7NhXEXyxMB1dDsS5hbMZc0Z+yuZ2ThgXFPB4pfhqTnWpYBURts1wDVZtr2eODcgizvN7JyM7RdnO25sPyZHf/olXi8F+iaWx1HA+cZt3wG2KGRb51z580sJrsOSdBphIl+Lfik7V4nSdyJssqFfTnDZ+YiB67DMbAwwpiX7SpoErJfRfLyZTVvrjuVhZjVtGT8fSScCZ2c0P2dmPypGf1zxbDewK8Pnfb3Y3XAlyhMDV5HMbHCx+9DezOw2wsOSnHMuJ7+U4JxzFWbWy58VuwuuhHli4JxzzrmVPDFwzrkK04l8T/12lc4TA+ecqzBd1FjsLrgS5omBazeSGiT1k7RY0uTE3wmSJsXX8yS9n1jXL0esuZJ6x9eNGfEuiO0pSbMlTZH0oqS8dRRizGmJONfH9u3jcr2k/pLOkjRL0l0teA/OkdQtsfx4rJXQbJJM0qjE8nmSRsbXIyUtiP2eLumQAuIdEWMOakl/XMfxua1T7C64EuZ3JbhiyFbs6A4AScOAQc18xv/iPMWTjjWzl+KtelcB+zURq9bMPshoOxS4z8wui308HdjXzOY3o49p5wB3Ap8BmNmBLYiRthQ4XNIVWfoMMNrMrpa0AzBRUp9clSMlbUi4lXHSWvTHOVcGPDFwleJ54Pzm7iTpQMKXeaOkbwGzCSWM/ybpVkIJ4hsIpZPXAUaa2cOx1sJvgAOAFcAfCDUX+gJ1kj4ws1pJc4FBwHnAW2Z2UzzuSKAhfrGfDxxFeO7Cg2Z2ceze8nj8EYSyzVmZ2SxJy4HewHs5Nrs09jfveyRpODAcoKqqqmxr3jc0NJTtuQH03mJ5WZ9fuX9+bc0TA1cMmTUNzjSziWsRr2tGvCvMbHzGNgcADxUQq05aeQH2djMbLWkM8UsaQNIBxJEFSb8G/mFmJ8VLAi9IegY4AegHDDSz5ZJ6mtlCSeeSfVRiPKFWwk1x+Sjg25L2B7YFdickFo9I2sfMJsTtbiLUV/htrhOSNJiQnLyfY/1uwBfN7K8xCcnJzMYSkhGqq6utXGvep1IpyvXcAH4/6nGGHF1T7G60mXL//NqaJwauGLJdSlgb+S4l3CVpXaA7UMgxs31p57M/cIik8+Ly+sCWwL7AGDNbDmBmC/MFMbN6SX0k9QWqgEVm9paks+Mx6uOm3QmJwoS438eS7gDOIhR8Shoh6TjgE+BoM8ss90ws2HQNMKwZ5+w6uPX0ebG74EqYJwau3B1LqEh4FWHI//BWji/gCDObvVqjclVqzute4EhgU8IIQjr+FWZ2c579rgVeYc2nGo5Oj3LksSHhMkgq9nlTwqjEIWb2UjP77zqIpbZusbvgSpjfleDKXvyl/Avga5K2b+XwTwJnKn6rSto1tj8NnBrLQiOpZ2z/hPBlnM14QiXFIwlJQjr+SZK6xzibS+qT3CmORvwFOLm5nTezj8yst5n1i9Ua/wV4UuBcBfPEwLWL+AW5NC72z7i98KwWhEzG65oR78rMjWP54lE0PQGxLhHnjgL6cSlh0uFUSTPiMsAtwLzYPgX4fmwfCzwhqS5LH2cQkoYFZvZ2bHsK+DPwvKRpwH1kTyxGESYXOufcWvFLCa697EiYWzAX6JprIzMbB4zLF0hSFSAz+yTu0zlHrJqM5VHZtkus75ejfWSu7WLCcWqWfZYD58a/ZPsNhEsaWY9pZjtliXUdcF2W9u6J1+8C3RLLIzO3L0Qxqz8650qDjxi4NifpNOBu4KJWiHUIMBH42drGcq5S9entj0R2ufmIgWtzZjYGGNOSfSVNIty/nzTEzKa1tD85Yh6/NjE7AkkXAkMymu81s8uL0R9XPL226t70Rq5ieWLgSpqZDe4IMTuCmAB4EuCcy8svJTjnXIWZ9UrmIy+cW8UTA+ecc86t5ImBc85VmE745EOXmycGzjlXYbp0XuPp2M6t5ImBc+1Akkm6M7HcRdL7kh6LyyMT9RbS28yV1Du+3kLSw5Jek/SGpOtiDQgk1cT4Byf2fUxSTZ7+pCQNShxnWvybKekySeu36hvgSsrnjVkf/eEc4ImBc+3lU2CApPTDnfYDFhSyY3zc8gPAQ2a2LbAdoZhS8g6D+eQpvVyA2vhwpd0JZaXz1WZwzpUxTwycaz+PA9+Nr4cSHvpUiG8CS8zsNgAzawRGEGoopJ92OAX4SNJ+a9NBM2sATgMOTdR3cM5VEH+OgXPt5x7gl/Hywc7ArcDeBey3I6FC5Eqx3PI8YJtE8+WEWg1Pr00nY+w5hPLOk5LrJA0HhgNUVVWRSqXW5lAlq6GhoWzPDaD35svK+vzK/fNra54YONdOzGyqpH6E0YLHM1fn2q0Z8SdIQtJeLevharLWjTazsYRCUFRXV1tNTU0rHKr0pFIpyvXcAG69/jGGHF1T7G60mXL//NqaX0pwrn09AlzNmpcRPgR6ZLRtCPwPmAl8JblC0heALYHXM/a5nLWsSSFpQ6Af8OraxHGla+lyn3zocvPEwLn2dStwSZa6DBOAQ+KXMpIOB6bE+QR/B7pJOiGu60woszzOzD5LBollmnsQLlU0m6TuwO8IEx0XtSSGc65j88TAuXZkZvPN7Pos7VOBG4FnJU0mTAA8Ja4z4DBgiKTXCL/klwA/z3GYy4EvNrNrdZKmAy8A88hSSto5Vxl8joFz7cDM1ihnZ2YpIJVYvpkctwma2VvAwTnWZcZ5hBxzBBLb1CRe98u3rXOusviIgXPOVZg+vRqL3QVXwnzEwLkyJulB4EsZzT81syeL0R9XGnpttcYAlnMreWLgXBkzs8OK3QfnXMfilxKcc845t5InBs45V0lqa3l18uJi98KVME8MnHPOObeSJwbOOVdhunRaUewuuBLmiYFzzlWYDboVXILDVSBPDFzFktQoaXLi74LY3kXSryW9llh3YROxLpQ0Q9LUuP3g2L6OpCtjrFckPS/pO4n9BkoySQdkxGvIcoyRkhZk9HnjJvp1bdynU6JtmKQbs2w7V1LvfPFcefiowWsluNz8dkVXyRab2cAs7ZcBmwI7mdmSWL/gx7mCSNoDOAjYzcyWxi/XdePqS4HNgAFx3SbANxK7DwWejf98ooA+jzazqwvYjpgMHAa8FY9ZV8h+zrnK5omBcwmSugE/BPqZ2RIAM/sEGJlnt82AD8xsadz+g4xYX0qsexf4S1wvYAiwHzBR0vrpY7aSGmAGMJ6QeKx1YiBpODAcoKqqqmxr3jc0NJTtuTF0KD03Xla+50eZf37twBMDV8m6xoJFaVcAs4B5MRko1FPALyW9CjwDjDezfwLbxFgf59jv68AcM3tDUgr4LnB/E8caIem4+HqRmdXm2XYoobzzw8CvJa1jZssKO6XszGwsMBagurrayrXmfSqVolzPjUsuYez3fsKRR9UUuydtpqw/v3bgcwxcJVtsZgMTf+MzN5B0YryW/5akrBULzawB+Arhl/T7wHhJwwo4/lDgnvj6nrjclNGJ/uZMCiStCxxIKJ/8MTAJ+HYB8V0F6NXDayW43HzEwLnVvQ5sKWlDM/vEzG4DbosliXPO2DKzRkKFw5SkacAPCJcMtpT0hcxRA0mdgSOA78WJjQJ6pY/bCufxbWBjYFq4YkE3YDHwWCvEdh3ch4t88qHLzUcMnEsws8+APwI3SlofVn6Jr5trH0nVkrZNNA0E3kzEui7+gkdSlaQhwLeAqWb2RTPrZ2ZbES4jtFZtg6HAKTF2P0Ihpf3ivAfnnMvJEwNXybpm3Pp3ZWy/EHgbmC6pHpgI3A78N0ec7sDtkmZKmgp8mVWTFS8iXF6YGUcdHgM+JnxxP5gR535WXU7oJml+4u/c2D4io8/9MjsTv/wPAP6abjOzTwl3Pxwcm4ZlxN8itk9NtF2T641zzpUvv5TgKpaZZR1PjRP0Loh/hcR5mTCRMNu6z4GfxL+kNcoem9kjwCPxda6kfWQB/fkM6Jml/fDE4rgsu/ZrKrZzrvz5iIFzzlWSujqffOjy8hED5wokqRfw9yyrvmVmH7Z3fwAkfRv4TUbzHDNrrbkKrgz12qp7sbvgSpgnBs4VKH75Z3tSYtGY2ZNkuSzhnHMt5ZcSnHOuwrz6yhqlOJxbyRMD55xzzq3kiYFzzlWYLvjkQ5ebJwbOOVdhNui8uNhdcCWsohIDSY0ZD4e5ILanJA0qYP8aSR9lxNg3R+x+WbZ/Jk/skZLOi6/HSZojaYqkVyXdkXgATbZ9J8X48yS9n9GHjeL+r0t6I77eSNJOie0WxuOt1kdJ50haImmjjPegoMfqSjojHtdiKeJ0+zBJKyTtnGibnn5Yj6S5kqZJmirpKUmbxvbukm6O5/Fy/NwGx3VbSHpY0mtxffJpg8nP4d+S8pYtjv1Lv48zJf0w0X5jlu0bsux/Y3xdHfs5WdIsSWObOO6NGW0r/92M78v9iXVHShqXWP6OpJdin+sljUqsGx7P/d+SXpC0V8YxZsd/316UVFITLF3r+6jR70pwuVVUYsCaRXOubHqXNUzMiJH+Is2MPTfL9vs24zjnm9kuQDVQD/wj/UWXycwGm9lA4JeEyn7JPvwR+I+ZbWNm/YE5wC1mNi29HeGhOudn6eNQ4EXgcFrmOWBf4M0s6+YTnjCYS62Z7Qy8BPw8tt0CLAS2NbOvACcCvSUJeIBQMGhbYDvC0wgvT8SbGM91V+AgSXs20ffxcfsaQmXCTZrYPpfrWVX4aAfghhbGSfuKpC9nNkoaANwIHGdmXwYGEeo+IOkg4FRgLzPbHjgN+HM64YqOjf++/Q64ai376JzrwCotMehwLBgNvAN8pzn7StqGUPXv0kTzr4BBkvo3sW9/wpfrRRRW9W8NZlafSJAyPQbsKKm6iTATgG1ifwYDF5nZihh/jpn9FfgmsCQWPEoXNBoBnKSM2gBmthiYDGxe4Dm8B7wBbFXI9llsRkiC0vGmtTBO2iiyJ1Q/AS43s3/H4zSa2e/jup8SEr8P4rpXCI94/lGWOM9T4HvjnCtPlfYcg66SJieWr8hWarcJe2fEOMLM3siInXzATHL7e80s+Su2OV4BtgcebsY+XwYmxy9KIHxhxP7sSPjCy+UYQingiUC1pE3M7N3mdzunFcBvCaMBP8iz3UHANEJ/VzuXhB2Bl5MNZvaxpHnANsl2ST2AbQkJR5MkbQ1sTfj1vcYv9QKMJoz2/D/gKeA2M/tfC+Kk/QU4PSZ9SQMISUM2a7w/hJGYbO/7AcBDuQ4uaTihvDRVVVWkUqkCutzxNDQ0lO25AfTcvLGsz6/cP7+2VmmJweI4PLw2JprZQc2InWv75lIrxGiOocBhZrYiXtceQhiqbk1/Bi6U9KUs6+okNQJTCaMW+6zlsfaWNIWQFFxrZu80sf3R8Tr8UuBUM1sYrlgUzADM7DZJTxK+cL8HnCppFzNbmmufJtobCUP9PwP+1pwONeGueKmqO3ke4mRmY4GxANXV1VZTU9OKXSgdqVSKcj03gPuvv4uao79X7G60mXL//NqaX0roOHYFZjVzn5nAQEkrP+f4emBcl5WknQhfoE9LmksYPWjR5YR8zGw54VfuT7Osro3X5U+Iv7BnALsolEDONJNwyWQlSV8AtiReZyckaLsQfj2fXMAEu/RcjcFmllkFMdPijPkfPYEP0gtm9l8zu9XMvgcsJ/y6z+ZDoEdG22qxoj8REqUvJtpmkPEeJKzx/sTlGYnlYwkjI7ez9vMgXIn7cPlGTW/kKpYnBiVOwVmEa9VPNGdfM3udMHHxokTzRcArcV0uQ4GRZtYv/vUF+kpq6XX2fMYRJihW5dsoXq55CbgkTjZE4a6L7xLqF3STdEJs70xIOMbFSoPJOHOAK8mejLTUP4Hj4rG7AkcBdXH5AEnrxNebAr2ABTnivAjsmbgLYxCwHvBWxjksI1yiGJFovgr4uaTt4r6dJJ0W1/0W+I1CrQdiUjSMMNEwGdeAXwBfk7R9894C51y5qLTEoKtWv6UweVfCX7WqDv29eWLsnRHjyDbq61Vx6PtV4KuEX9CftyDOycB28Ra+Nwgz9k9uYp9jgMxfyQ/GdoBvJd6r+ZL2yBZE0lmS5gNbAFMl3ZK5TTyn64E+BZzLKcAmwOuSphOSivfiF9phwBBJrxHesyWsupsh0xhgH8XbI5tpWMa5bwGcDRwe5278izCXJD2HYX9gevwsnyRMAsx6GSPO4TgbeDzGuhYYmp5smeGPJC4FmtlU4BzgbkmzgOmEEYB0Oedbgf8n6d/AHwh3L7ydpQ+LCUnV+c17W5xz5ULh/6nOOdc81dXVNnv27GJ3o02U+zXqsdc8xvBzW2PqU2kq989P0stm1uSzd1qq0kYMnHOu4vXqVeweuFJWaXclFERtWONe0oWEGf5JBd/GKGkS4bpz0vGtcH98i0l6EMi8s+CnsSRwyZJ0ImHoPuk5M8t2f39rHrfN/v1yrhC9tvInH7rcPDHIoi1r3McEoKXPMsDMBrdid1pFR/1Ciw9Euq0Ix22zf7+cc25t+aUE55yrMG/WLyx2F1wJ88TAOecqzFLLWnbFOcATA+ecc84leGLgnHPOuZU8MXDOOefcSp4YuHYhySTdmVjuIul9SY/F5ZGSzsvYZ66k3vH1FpIelvRafIrjden6BJJqYvyDE/s+JqkmT39SkmYnnmB5X6IfCzKfjpll+5xPvJTUGLeZLulRSRvH9n6SFmc8OTP9GOfukm6O5/ZyPN7gps49x/G7SbpL0rTYh2clbRj/+Z3EdkMkPRFfXyhphqSpsV8ld/eLc659+O2Krr18CgyQ1DU+dnc/ctcMWI0kAQ8Avzez7ynUQhhLuO0z/eje+cCFwKPN6NOxZvZSlvbRZnZ1M7bPtLLSpqTbgR+x6hbVN3JU4bwFmANsGytafgn4coHnnuls4F0z2yn2oRr4HDgNuFdSHeG//V8DB8RHWh8E7GZmS2My5rPTnKtQnhi49vQ48F3gPkKhpruBvQvY75vAkvjcAcysUdIIYI6ki+M2U4B1JO1nZk+3ftdb7Hlg53wbSOoPDCYkHitgZbGnOZK+RZ5zzywSFW0GvJleMLP0c4unS3qUUEBqA+AOM3tD0i7AB+lS0GaWWc0x2dfhwHCAqqqqsq1539DQULbnBtBz88ayPr9y//z+P3vnHm9lVe397w+Q5OYFJE+kgqHsjleO+moX7GwvZGZqmqakeSlfUksTo+xVU6xDN+9oqeRB8JKad+VoisQWtbyhsEF0gxzQsCwlRbcBKYz3jznX5uFhXTd7sfZ+1vh+Puuz55rPnGOOOZ8Fz3jmZYxq44aBszG5DbggLh/sRgjsU45hsDMwK5lhZu9Keg3YIZE9HvgJUK5hcIukFTE9zcxyb+BjJB0f00kPjsnyB5jZsmLC49v9AYSARzmGxgBJOc4ghFqebWar84gp1ffmPHUmAY/E5Y7pwBQzWxivXQQ8T5hByPlaf4RwXxYAjxJCTj+Wr09mNpEwY0FDQ4Nl1R991n3tT7xsKkcd01hrNapG1u9ftXHDwNlomFlzjGg4ijB7sM7lQtUqkD9TEpJGlFmlWksJveLD/+PAS6xrqKy3lCDpsDL1LQszmy3pE4TIjgcCz0r6tJm9ZGbvS7odaE3MELRK2pNgpO0H3C7ph2Y2uSP1chyna+CbD52Nzf3AJYRlhCTLCG/OSfoB7wDzgT2TFyRtBmwHvJKqMx44v6OUbSe5PQaDARH2GBTjRWD3OMOQppK+t2FmrWZ2t5mdDtwMfDFxeU38JMuvNrMmM7sQ+A7wlRI6O46TUdwwcDY2k4CL8gR9mgkcJqkfgKQjgTlxen060Duxg787cCkwOb3GbmaPEAyMouv6G4Oo25nA9yQVnJ0zs0XAc8BFcbNh7gTDIVTQ9xySPitpy5juCexEYs9BnvINknZMZA0vVt5xnGzjhoGzUTGzpWY2IU9+M3A18ESchj8VOCVeM+AI4GhJC4EFwErg3ALNjAe2LUOdWxLHBh+tvDelMbMXCPsARsWsoanjimfG/FOArYFXJM0DJgN/b0ffAYYCj0maC7xAMDruKlK+LzBF0nxJzQRDYlzlvXUcJwso/L/jOI5TGQ0NDdbS0lK6YBck65vXJl42ldFnf6nWalSNrN8/SbPMbK/SJduHzxg4juPUG93ybWdxnICfSnAyjaR7gO1T2ckjiO2VO4Cw/p+m5DHGjkLSQcAvUtmLzeyIjdG+03UZNrxXrVVwOjErGhWzAAAgAElEQVRuGDiZploPyfjwz+fBcKMRjZsNMnAcx3HS+FKC4zhOnbHg+dZaq+B0YtwwcBzHcRynDTcMHMdx6owe5PO+7TgBNwwcx3HqjD7dV5Qu5NQtbhg4NUPS6pSznx/G/B6SfippYeLaeWXKmifpAUlbxPwhklak2sl5EfyGpLmSmmO9w2O+JJ0f218gaYaknRNtLYmhiZPtj5M0NpW3RNLWiXbfkPR64ntPSa2J8jtL+oOkltj2jxKeEE+StEbSbony82LsiWLjMlySSfpCKn+9ReZ8fXCyyfLVfWutgtOJ8VMJTi3JxRRI81/AvwG7mtnK6Cb5e+XKkjSFEJ9gfLyWL3DRNsB5wB5mtlxSX2BgvPxt4DPA7mb2T0mfB+6XtLOZraywj6sTeo0jBC9qC9AUn/tI6kWII3GamT0iqTfBW+HpwK9i8aVR52MqaH8U8ET8+/sKdXccpw5xw8DpVMQH4v8FhuQewmb2HpW56P0TpWMlfBR4D2iNbbTm0sA5wH/mYhHEB/UfgeNYN4RyR/I14MkY64FokHwHaGKtYTAV+JykBjMr6XIwzjYcDYwEHpe0aTsMm7TM0cBogIEDB2Y25n1ra2tm+wbQ/+OrM92/rN+/auOGgVNLcuGJc/yMEKb4tWgMVEwMMnQA6z7Ah6baOQP4I/A3YLGk6cDdZvZAjFzYx8z+NyX6OWBnqsfOwKxkhpktktQ36gQhIuIvCXESTixD5mcIDo8WSWoCDqF4zISSmNlEYCIEl8hZdTubdZe6Ey+bylHHNNZajaqR9ftXbXyPgVNLVpjZ8MTn9nQBSSfH9fg/SyoWGClnZLxBCEY0LXFtUaqdx2PUxi8ARxECE10ep/rbS6GgIx0djOS3wKckpb055mMUcFtM38baQE5OnTOgx/Jaq+B0YtwwcDobrwDbxX0FmNkNcY1+OVDMwXtuj8FgQIR9AkWxwDNm9jPgWOArZvYu8L6kT6SK7wm8WETcMkK45yT9gHdK6RGZH9toI+rQGnXK6fwhIezyOcWExZmTrwAXSFoCXAV8ITeuTn2z7MPNa62C04lxw8DpVMR1/f8Grpa0KbQ95HpWUP9M4HuSCi6VSRokaY9E1nDg1Zi+GJgQNwQi6UBgBOFtvRAzgcNyD15JRwJz4sxEOdwCjIht5TYjTiAsHaSZDBzI2s2S+TgAaDazbc1siJkNJiwjeBwFx3GK4nsMnFqS3mPwezP7IWHn/U+AeZLeA1YAU4C/lCPUzF6Q1EyYOn+c9fcYTALuAy6RNAhYCbwJnBqvX0V4+58raTVheeJwM0se/m6WtCamf2dmZ0u6GnhCkgF/B04pbxjAzFbE45JXSfoVYXbkJuDqPGX/JWkCcGURkaOAe1J5dwGnATcCvSUtTVy7LP49X9JZiba2KbcPjuNkA5l19BKo4zj1QENDg7W0lDwc0SXJ+ua1iZdNZfTZX6q1GlUj6/dP0iwz26ta8n0pwXEcp84YMKDWGjidGV9KcLoMkgYA0/NcOiCGQa5LJD0NfCSV/XUzm1sLfZzOz4DB7vnQKYwbBk6XIT7883lKrGvMbJ9a6+A4TnbwpQTHcZw646XnPYiSUxg3DBzHcRzHacMNA8dxnDqjG2tKF3LqFjcMHMdx6owe3f2YulOYTBkGklolDZG0IhHzfrakEyQ9HdOvSXozcW1IAVlLJM1NlJsQ80+KTnFK6TJZ0lElyjRK+kx7+loJSV0kXS9pp5huLV6zpNx19Jd0qqQTNkzb9eSbpEMTeVMlNW6AzIMlPSdpvqQXJF0a88dJGtsBanca4vgtT/1bOFDSFpJOr7V+Tu341+pi3sWdeierpxIWRb/5SW6E8GAH9jKz75QhZz8zeyuVdxIwjzK98JWgkRDq94/lVpDUI/rLbxdmVrY3vjLaayShv5ld2169irCU4AnxgQ0VJGkXgifBQ8zs5ehqefSGyi2jXRGcidVi/vZxM1vHk000hk8Hfl0DfRzH6eRkasag2sS37r2AW+LbVy9JF0h6VtI8SRPjQyBdb4mkiyQ9H2chPhn/cz4VGBNl7StpoKS7orxnJX021h8n6SZJTwI3Seou6ZLYZrOkM2K5cnRpkrRX4vvlkl6UNF3SwESZKyQ9B3xX0qFxxuUFSY9K2rqA/m1v3ZKGS3oq6nePpC0Tsn8h6RlJCyTtW2LY5wDLJY3M05cDok5zJU2S9JFC4x2r/AAYb2YvA5jZajO7Jo/cQrqfGWcamiXdlrg3YxN15ynMWg2R1CLpRoIhua2kz0v6U9TrDkkFD5PHPvwy6v+MpB1i/hBJf4g6TJe0Xcw/OrY9R9LMEmP6c6KbaEkXK4R2np4Yr8NL1HccJ8NkdcYg7Rv/DDN7vB1yZij4ygeYYmaXS/oOMNbMngOQdLWZ/TimbwK+RP6327fMbA+FKdyxZnaKpGsJ0fMuifV/C1xuZk/E//AfBv491t8JGBF96p8GDAGGm9mHkvrHMuXqkqMP8JyZjZF0AXAhkJtJ6ZlzuRkfjJ8yM5N0CvADM/teHv0PSMi+kTDuj0n6cZSd88Hfw8z2lvTFmH9gER0BxhNiJ7SFUlYIsDSZ4NxoQXwAnwZcEYusM96EuAW7ECITlqKQ7j8EtjezVZK2KEPOjsCJZvaUpK2A84EDzex9SecAZwM/LlJ/uZntqrA8cwXhfl5F+C1OkfQNQqClLwMXAAeZ2esp3fZN/Vv4SuzHLrlZNYVgU0eY2btRz6ck3W95/KVLGk2cZRk4cCBNTU1lDEPXo7W1NbN9A9jq4x9kun9Zv3/VJquGQb6lhPaQbylhvTKSfgD0BvoTQvPmexjfHf/OAo4sIOtAYKfEi/5mibfK+xNBfA4Ers1N8ZvZPyrUJcca4PaYvjmhI4l8gG2A2yV9jBDlcHERmUjaHNjCzB6LWVOAOxJFkmMxpJgsADObKQlJIxLZDcBiM1uQaOPbrDUMyhnvSnVvJswW3QvcW4a4V83sqZj+FMG4ezLe357An0rUvzXx9/KY/jRr+3MTa6MvPglMlvQ71r2PhZYS1skCfirpc4TfxMeBrQnBo9bBzCYCEyHESsiqP/qs+9qfNGEqRx/TWGs1qkbW71+1yaphsFGIb62/JuxZ+LOkccCmBYqvin9XU3jcuxHezFem2gF4vwN1KUTyDTHZ3lXAZWZ2v8LGv3EVyk1TzlikGU944y53f0W+Nl4E9iQsT7SHQ4DPAYcC50naNeqTXJJLjnlyDAVMM7NRFbRnBdLrFzQ7VdI+UcdZkvasoJ3jCCGc9zSzDyQtofLfjtOFWPWhbz50CuN7DCrnPaBfTOf+83wrvtkXPYVQQhbAI8AZuS+SCs16TAO+FaeAiUsJ7dGlW6Lc14AnCpTbHHg9pk8soj8AZrYceDuxf+DrwGPpcpVgZo8QQiHvFrNagCG5tfcy27gYOFfSMABJ3SSdmixQSHdJ3YBtzWwGcA5hTPoCS4A9orw9gO0LtP0U8NnEXoE+OT2KcEzib2524Y/AsTF9HCGsNJKGmtnTZnYBIYT0tkXkpu/b5sDfo1GwHzC4hF6O42SYzMwYxIdk7i0xvcdgkplNaIfY5B6DZjM7gbCufa2kFYRp3d8QNpe9ATxbofwHgDvjZq8zgDOBX0lqJtybmYQNfmmuB4YBzZI+AH5jZldLqlSX94G9JZ0P/J21D6I044A7JL0N/IG1D7+0/klOJIxTb+B/gZPL0KcU44H7AMxspaSTo149CP0teirCzJolnQXcGvUyYGqeovl07w7cHJcaBEwws3ck3QWcIOlF4GlgQR55mNmbCidiblXcJEmYAclbPrJl/C2sAnIzDWcAN0j6PsEAyI3rxZJ2jLpNJ8yK/Cfr7zH4LzO7U9KTkuYBDwG/AB6QNBd4Dni5iE6O42Qc5dlf1CWRtDvhAbl3rXVxnA0lTufvVcYel5rR0NBgLS0ttVajKmR9jfqayx7itLMPrrUaVSPr90/SrNzm8GqQiaWEOB18K+ENzHEcxynCRwesLl3IqVsysZQQHeu0y7mOPJZ9zZF0EGE6O8liMzuiFvpsTCTdw/r7Es4xsyE1UMepEwYMLuhCw3GyYRhsCB7LvvaY2cMEnw11Rz0YP47jdC0ysZTgOI7jOE7H4IaB4zhOnbHg+Q2Kn+ZkHDcMHMdxHMdpww0Dx3GcOqMHfirBKYwbBo7jOHVGn+4rShdy6pbMGAaSWhVC0q6I4WRznxMUQgbPlvSapDcT14YUkLVEIfxsrtyEmH+SpEFl6DJZIURzsTKNkj7Tnr5WQlIXSddL2immN2iRMa2/pFNjFMAOIco3SYcm8qbGWA3tlXmwpOcUQie/IOnSmL9O6OQssaG/ZSebLF/txxWdwmTxuGK+yIo3QvjPkOBN7jvr1VqffJEVTyK4HP7LhioJNAKtBN/3ZSGpRy6iYnsws1MqKV+ivUYS+kdfEh3NUuA8ikeILAtJuwBXA4eY2cuSuhPDB1cThQhYMrM11W6rCNX+LTuOkyGyaBhUhfjWvRch7G4uTsL3CZH2ehEekN9Kx7CPrm2nxHKbAEcDKwkxEFZLOp7g//5lgpOm7WLVs8zsyRglcSjwCeC1WP4XwBcIIXJ/Y2ZXSbqgDF2agLFm9lz8fjnweUJshWOjP/8mYDYwguDXfwHBo2RPYBkhcE+vPPofALSa2SUx+NO1hPDPi4BvmNnbUfbTwH7AFsA3zezxIsM+B9hE0kgzm5bqywHAJYTf8LPAaWa2Kt94m9nLwA+A8TGNma0Grkk3WET3M2OfPwTmm9mx8d60mtklse48IBfi+OHY1z2BL0pqAC4iONNaBJxsZnlnbQr1QVIfQqTLXWL+ODO7L8Z0mBzzW4BBwLdz9zmP/Hb9lmPd0USDauDAgZmNed/a2prZvgH0//jqTPcv6/ev6phZJj6Et9chwArCgy332TdR5iTg6jJkLQHmJmSMiflNhBmHXLn+ifRNwKExPRk4KiHrjJg+Hbg+pscRHtK5+r8FRsT0dsBLiXKzgF7x+2nAnUCPpA5l6tKmPyGA0HExfUFuXGKZXydkbcnamBqnAJcW0L/tO9AM/GdM/xi4IiE7V/+LwKNF7kEjIcDR54DHYt7UmL8p8GdgWMy/kWBIFRvv54HdC7RVju5/AT4S01sUGIN5hN/gEILR9qmYvxUhIFaf+P0c4IISv798ffgpcHxOB0IApj7AWOC6mL8LwXjZKyGr3b/lYp9hw4ZZVpkxY0atVagq1136QK1VqCpZv3/Ac1bF52kWZwzyLSW0h3zTr+uVkfQDwttlf+BF8k973x3/zgKOLCDrQGCnMPMMwGYK4ZMB7jezFYly11qc4jezf1SoS441wO0xfXNCRxL5ANsAt0v6GGHWYHERmcTog1uYWS4E8hTgjkSR5FgMKSYLwMxmSkLSiER2A8Flci4y4RTg28AVedooNN6V6t5MeMO+F7i3DHGvmtlTMf0pYCfgyXh/e7I2jHIh8vXh88Bhif0QmxKMyBHAlQBmNi9GZEzSkb9lJwMM6LG81io4nZgsGgYbBUmbAr8mvHX9OU4rb1qgeC4c9GoKj3k3whvmylQ7EMIjd5QuhUhOGyfbuwq4zMzujxv/xlUoN005Y5FmPGE5o9z9FfnaeJEwrT+nTBlpDiHMXhwKnCdp16hPcgNvcsyTYyhgmpmNonzy9UHAV8xsnZCGCWOyXXTQ78fpQiz7cPNaq+B0YjJzKmEj8R7QL6Zz/3G+Fd/si55CKCEL4BHCWj3Qttadj2nAtyT1iOX6t1OXbolyXwOeKFBuc+D1mD6xiP4AmNly4G1J+8asrwOPpctVgpk9QljS2C1mtQBDJO1QQRsXA+dKGgYgqVuMyllSd0ndgG3NbAZhGWBzoC9hmn6PKG8P1g+GlOMp4LM5fSX1yelRIQ8DZ8QNjUj6j5j/JPDVmLcTsGsZsjryt+w4TobIxIxBfEjm3rCGSpqduDzJzCa0Q+wMSTkvIM1mdgJhvf7axIat3xDWld8gbICrhAeAOyUdTjAIzgR+FaeBexDWpE/NU+96YBjQLOkDwubDqyVVqsv7wN6Szgf+DhxToNw44A5JbwN/YO3DL61/khMJ49Qb+F/g5DL0KcV44D4AM1sp6eSoV27zYdFTEWbWLOkswobK3oQZkql5iubTvTtwc1xqEDDBzN6RdBdwgqQXCRsNF+SRh4VNnSfFtnORPM8vVL4IPyEslzRHY2UxYbPjr4EpkuYTNrG+CCTniqv9W3YcJ0PkNpV1aSTtTnhA7l1rXRxnYxOPXm4SDaahwKNAg5n9q5rtNjQ0WEtLS+mCXZCmpiYaGxtrrUbVmHjZVEaf/aXSBbsoWb9/kmaZ2V7Vkt/lZwzidPCZwFm11sVxakRvwqzAJoQZjdOrbRQ4XZsBA2qtgdOZ6fKGgQXHOu1yriPpacK58iRfN7O5G6yYUxaSDiL4ZUiy2MyOqIU+GxNJ97D+voRzzOzhSuSY2XsEvwSOUxYDBrvnQ6cwXd4w2BDMbJ9a61DvxIdgRQ/CrFAPxo/jOF0PP5XgOI5TZyyY7UGUnMK4YeA4juM4ThtuGDiO49QZPbrVMqaX09lxw8BxHKfO6NO76x9Td6qHGwZOp0OSSbo58b2HpDclTY3fxyXiBeTKLJG0VUxvI+k+SQslLZJ0paSe8VpjlH9oou7U6O65kD5NklokzY6fOxN6vJ7I/3mB8gU9CUpqjX+7SZogaZ6kuZKelbR9vLa5pBslvRL7c2N0tlRIZl5Zkm6RdFqi3D6SmiVtIukbsWxzrHd4IflO12d5a/daq+B0Yur6VILTaXkf2EVSrxg8aiRr3TIXJboLvhu4xswOj85/JhI8J34/FlsKnEdlQYKOs/xhjC+3GHa5zPKFOIYQLnk3M1sjaRvWxlv4b2Be9FiIpIsIHjCPrlDW2cCfomGzDLiaEL1xa8J47GFmy6Nb5IEV6O44TobwGQOns/IgIXARwCjg1jLr7Q+sNLMbAMxsNTAG+EZ0cwwhkNJySSM7UN8N5WPAX81sDYCZLTWzt2N8hT0J7pBz/BjYK3o5LFuWmf0NuAT4JcHddrOZPQF8lBA7oTWWbzWzolE0HcfJLj5j4HRWbgMuiMsHuwGTgH2LVwFgZ0Ko4jbM7F1JrwE7JLLHEx6208rU55YYVwBCpMTc7MMYScfHdNI5UbL8AWa2rIT83wFPKARwmg7cbGYvEMI1z44GTq4/q2M8kJ2BRRXIguAM7ESgkbVOkeYAfwMWS5oO3G1meWdTJI0GRgMMHDiQpqamEt3qmrS2tma2bwD9B32Q6f5l/f5VGzcMnE5JDHo0hDBb8GD6cqFqFcifKQlJI8qsUtWlBDNbKqmBMOOxPzBdUqGlgnbJMrPpcWnhOkKI5WWx/GpJXwD+D3AAcLmkPc1sXB7ZEwlLMzQ0NFhW/dFn3df+XVOmZrp/Wb9/1cYNA6czcz9h6rsRSHp3X0aYLk/SD3gHmE8qbLCkzYDtgFeAZKCt8YQohx92pNLtxcxWAQ8BD0n6G/Bl4EpguKRuuaWBGFlxOKGvlciaHi+viZ9keQOeAZ6RNA24gRBZ08kgy972zYdOYXyPgdOZmQRclCd2xUzgMEn9ACQdCcyJ0+3Tgd6Schv1ugOXApPN7J9JIWb2CLAlYamipkjaQ9KgmO5G0OlVM3sFeIFgwOQ4H3g+XitbVpG2B0naI5E1vFh5x3Gyjc8YOJ0WM1sKTMiT3yzpasI6ugF/B06J10zSEcCvJf2IYPw+CJxboJnxwH1lqJPcM/CWmR1YWW9K8lHgN5JyQb2eIZwaAPgmcJWk3H6CP8W89sjKxybAJdGYWAm8Sdic6DhOHeKGgdPpMLP1Qr+ZWRPQlPh+HXBdgfp/Bg4tcC0t535CqOJi+jQWyB9XSfkCZfvGv78Hfl+gzNvA8fmuFShfUFa8PhmYnPj+KmEvguM4ji8lOI7j1BsDtlxdupBTt/iMgeNEJN0DbJ/KTh5BbK/cAazd+JeknGOMxeTuCtyUyl7l4cSdUgwYvN6knOO04YaB40TM7IgqyV1G2NDX0XLnVkOu4zj1jS8lOI7j1BmvvthaaxWcTowbBo7jOHXGqg/cj4FTGDcMHMdxHMdpww0Dx3Ecx3HacMPAcRzHcZw26sIwkNQqaYikFZJmJz4nSHo6pl+T9Gbi2pACspZImpsoNyHmn5RzQ1tCl8mSjipRplHSZ9rT10pI6iLpekk7xfQG7UxK6y/p1JyL4o4gyjdJhybypkpq3ACZB0t6TtJ8SS9IujTmj5M0tgPU7hDi72+rPPmHSfphibqNMVplvmtNkloSv+s7O0pnx3G6FvV2XHGRmaWPd90I4cFOiDj3nTLk7Gdmb6XyTgLmAX/ZUCUJQYNagT+WW0FSDzNrdzAgMzulkvIl2mskob+ZXdtevYqwFDgPyBseuBIk7UJwGXyImb0c4yuM3lC5ZbQrQLngSBtC9OB4/waKqSgipOM42aTeDIOqEN+692KtP/1PA98nuOXtRXhAfitGsEvWWwJMieU2AY4m+Ko/FVgt6XjgDOBl4FpChECAs8zsSUnjgKHAJ4DXYvlfAF8gRM/7jZldJemCMnRpAsbmHgySLgc+D7wBHGtmb8Yys4ERwK2SFhAC+vQkRDw8LraR1v8AoNXMLpE0PPalN7AI+IaZvR1lPw3sB2wBfNPMHi8y7HOATSSNNLNpqb4cQIjK2AN4FjjNzFblG28zexn4ATA+ponBmK5JN1hE9zNjnz8E5pvZsfHetOZCMkuaB3wpino49nVP4IsxRPJFwEei3JPNrNiszRlxtqStD0nDVtJQ4BagDyEOxFkJN9N942zALsAs4Pj0b6EYkkYTjaaBAwdmNuZ9a2trZvsG0H/QB5nuX9bvX9Uxs8x/CG+vQ4AVhAdb7rNvosxJwNVlyFoCzE3IGBPzmwj/MefK9U+kbwIOjenJwFEJWWfE9OnA9TE9jvCQztX/LTAiprcDXkqUmwX0it9PA+4EeiR1KFOXNv0BI7w9AlyQG5dY5tcJWVsS3nghBDG6tID+bd+BZuA/Y/rHwBUJ2bn6XwQeLXIPGoGpwOeAx2Le1Ji/KfBnYFjMv5HwYCw23s8Duxdoqxzd/wJ8JKa3KDAG8wi/wSEEo+1TMX8rQrTIPvH7OcAFJX5/+fpwUuI+TQVGxfSpBAMlN27LgW0Iy4h/Yu3vqgloYe3v+uJS/xaGDRtmWWXGjBm1VqGqXHf5g7VWoapk/f4Bz1kVn5n1NmOQbymhPeRbSlivjKQfEN4u+wMvkn/a++74dxZwZAFZBwI7hZlnADaTlHsDvN/MViTKXWtxit/M/lGhLjnWALfH9M0JHUnkQ3jA3C7pY4RZg8VFZCJpc8KD87GYNQW4I1EkORZDiskCMLOZkpA0IpHdACw2swWJNr4NXJGnjULjXanuzYTZonuBe8sQ96qZPRXTnwJ2Ap6M97cn4YFdjFJ9+DTw5Zj+LWH2JMczFqJWImk2YZyfiNd8KcFxnLozDDYKkjYFfk14A/9znFbetEDxVfHvagrfj26EN8yVqXYA3u9AXQqRnGpOtncVcJmZ3R83/o2rUG6acsYizXjCcka5+yvytfEiYVp/Tpky0hxCmL04FDgvxjD4kHU39ybHPDmGAqaZ2agK2mvPOKXrtre+4zgZpy5OJWwk3gP6xXTuIfBWfLMvegqhhCyARwhr9UDbWnc+pgHfktQjluvfTl26Jcp9jbVvlGk2B16P6ROL6A+AmS0H3pa0b8z6OvBYulwlmNkjhCWN3WJWCzBE0g4VtHExcK6kYQCSukk6tRzdJXUDtjWzGYRlgM2BvoQp/z2ivD1YPzhTjqeAz+b0ldQnp8cG8BTwlZg+dgNlOY5TZ2TeMIgPydxb0tDUccUz2yl2RkLGjTFvMnBtnJ5dBfyGsK78MGEDXCU8ABwR5e8LnAnsJalZ0nzCunE+rgdeA5olzQG+ZmbvtEOX94G944a5/Qnr6fkYB9whaRaQXFpJ65/kROBiSc2EAECFZFfCeGBbgDircnLUay5hWaToqQgzawbOImyofIkwVp/IUzSf7t2Bm2NbLwAT4pjfBfSX9CLwHWBBHnmY2ZuE/QG3Rrl/Aj5ZftfzchZwdpS3A2FfQTnckvhdP7qBOjiO00XJbRzLLJJ2J+zO37vWujjOxkBSb2CFmZmkYwkbEQ/v6HYaGhqspaWlo8V2CpqammhsbKy1GlVj4hUPMfqsg2utRtXI+v2TNMvM9qqW/EyvL8bp4DMJb1COUy/sCVwd/SS8A3yjxvo4jtOFyLRhYMGxTruc60h6mnCuPMnXzWzuBivmlIWkgwh+GZIsNrMjaqHPxkTSPay/L+EcM3u4VF0L/h92r4piTiYYNrxXrVVwOjGZNgw2BDPbp9Y61DvxIVjyQZhF6sH4cRync5L5zYeO4zjOuiyYvaJ0IaduccPAcRzHcZw23DBwHMepM3p02+C4XU6GccPAcRynzujTO9vH1J0Nww0Dx0khySTdnPjeQ9KbkqbG7+MkjU3VWSJpq5jeRtJ9khZKWiTpSkk947XGKP/QRN2p0aV0IX2+JOkFSXMkzZf0rcS1EyTNkzQ3lhmbuJbT++cpeU2S9krlNUpannIAdmCFQ+d0EZa3dq+1Ck4nxg0Dx1mf94FdJOXOdI1krevnokTfAXcD95rZjsAwgovk8YliS4HzypS3CTCREBFzd+A/CJEQkXQwwUfH581sV0JApqSXw5EEj4tHKxGBqwiPm9nwxMe9HzpOHeLHFR0nPw8SgiPdCYwCbgXS7p3zsT+w0sxuADCz1ZLGAIslXRjLzAE2kTTSzKaVkNeP8O90WZS3ihAPAuD/EUI7/yVx7TeJuqOAKwnhuD8N/LEM/YsiaTQwGmDgwIGZjXnf2tqa2b4B9B/0Qab7l/X7V23cMHCc/NwGXBCXD3YDJlGeYbAzIRxyG2b2rqTXCHELcowHfkIIfFUQM/uHpMt2WHAAACAASURBVPuBVyVNB6YCt5rZGmCXdFs5YlTNA4FvAVsQjIRShsG+MdZHjq+Y2aKUPhMJMxg0NDRYVt3OZt2l7sQrHuKorzbWWo2qkfX7V218KcFx8hADKw0hPFAfTF8uVK0C+TMBJI0oo+wpwAHAM8BYgpFSii8BM8xsBSGg05cllVpYTi8lLCpR3umiDNhyda1VcDoxbhg4TmHuBy4hLCMkWUYI9ZykHyEuwXxCrII2JG0GbAe8kqozHji/HEXMbK6ZXU7YN5ALqfxiuq0Eo4ADJS0hzCoMICxzOA7L3vbNh05h3DBwnMJMAi7KEx9jJnCYpH4Ako4E5pjZamA60FvSCfFad+BSYLKZ/TMpxMweIRgYuxVSQFLf1ImF4cCrMf0zQhjof4tle0o6JRoi+wLbmdkQMxsCfJtgLDiO4xTF9xg4TgHMbCkwIU9+s6SrgSckGfB34JR4zSQdAfxa0o8IxveDwLkFmhkP3FdEDQE/kHQdsIJwYuKk2NaDkrYGHo2nDoxgzBwB/CFuRsxxH/BLSbnAYP8j6YOY/hPwK9bfY/BfZnZnEd0cx8kgbhg4Tgoz65snr4l4TDB+vw64rkD9PwOHFriWlnM/4eFfSJf3gC8WuX4DcEOeS1NS5f4BDIxfGwuI27xQO47j1A++lOA4jlNn+OZDpxg+Y+A4nQRJ9wDbp7LPieGnHafDGDB4vUkxx2nDDQPH6SSY2RG11sFxHMeXEhzHceqMBbNX1FoFpxPjhoHjOI7jOG24YeA4jlNn9Oi2ptYqOJ0YNwwcx3HqjD69y/be7dQhXdYwkLQ6FTv+hzF/vVjzBeoXjD+fR/aQPOULhqSVNE7S67HcfElV9TgnaUBCrzcSbc+O3vC2kXSfpIWSFkm6MuYflCjXKqklpm9MyL4iyuuWyDspOvgpR7fxkv4sqTWVP07SPyV9NJHXmkjn7sE8SXdI6h3z/03SbbEfsyQ9KGlYvLazpD/EfiyU9KNcuOGo85tR5ssx4mExvZP3cJ6kwxL5Y1Nlh0ial6f+2Jj+lKSno6yXJI0r0W5a/hJJW8W0Sbo0cW1sUp6kE6K+cyW9kNBBks6P47JA0gxJO6famCupWdJjkgYXGx+na7O81V0iO4XpsoYBsCIV8OXn7ZBRKP58WvaSPOUPLCH7cjMbDhwOXCdpk3boVxZmtiynF3Btru34/QPgbuBeM9sRGAb0Bcab2cOJcs8Bx8XvOXe+3Qhe9P4M/Gc71XsA2LvAtbeA7xW4lrsHuwD/Ak6ND/l7gCYzG2pmexJCD28tqRchtsHPzawB2B34DHB6Qubtsa+fBc6TtG0J3XP38GhgUtI4qpApwOgoaxfgd+2UA7AKODJnKCSRdDBwFvB5M9sV+BSwPF7+NmE8djezYQR3yvcrRGHMsZ+Z7UZwwFRWDAfHcbJHVzYMugRmthD4JzHojqShkn4f33Yfl/TJmL+1pHskzYmfz8T8s+Mb4DxJZ7VDhf2BldFDHtGf/xjgG7m38CI0EgL1XEM7/eyb2VNm9tcClycBx0jqX0LM44SQxfsBH5jZtQn5c8zsceBrwJMx/gAxLsF3gB/m0WkZIaDRx8rsw0vAh8B6D+My+Sjw1yhrtZnNb6ccoh4TCfcwzf8DxprZX2Jbq8zsN/HaOcB3cvEa4jj9ETguj5w/AR/fAB0dx+nCdGU/Br20rl/3n5nZ7RXKKBR/Pil7ceJ8ebL8HWY2vlQDkvYAFprZ32PWROBUM1soaR/g14SH9wTgMTM7QiHwTl9JewInA/sQ3OY+LekxM3uhgj7uTIiu14aZvSvpNcLDtrlI3VGEyIL3AT+VtImZfVCkfKW0EoyD7wIX5isgqQdwMPB7wtv2rHzlyN/PRQpBiDZLydwO2JTifU+W3wdYA7xZTvk8XA60SGoi9GOKma1spywIcQ2aJf0ylZ93fGL/+5jZ/6YuPUcYtzRfAO7N17Ck0cBogIEDB9LU1FSZ5l2E1tbWzPYNoP+gDzLdv6zfv2rTlQ2DFXFqdkN43My+VIHsQuXzMUbSyYSp+0MhRMojTOfeEZe+AXJBbfYHToC2t/rlkkYA95jZ+7H+3YSoeZUYBu1CUk+Cj/6zzew9SU8DBwFTO7ipCcBsSZek8pPG2ePAfwOnbmBbx0j6HPBJwttzqYfzGEnHA+8Bx8QASfnKFdrJZQBm9mNJtwCfJ8xsjKJwvIKisqK8dxX2gZxJCKzUUcyIszetwI/yKmE2kWDc0tDQYI2NjR3YfOehqamJrPYN4K4pUzPdv6zfv2rjSwnV43Iz2xn4CvDfcS23G/BOav/Cv1dZj/nAnsmM+Aa5HWE6vRAHAVsAcyUtAUZQhbC9ZvYO8FvCGniS5D6PM8zsX4RljT3XExLI189PAK1m9m7Muj2uoX8G+LliuOIi5PZq7BuXKwqxjLhUlKA/YQ8FEGYvzOwa4ABgd0kDKpDVD3gnlXcF8E2gTyIv7/jE/r8fxyPJnrFOjv2AwcBs4KIC+jkZYNnbvvnQKYwbBlUmRs97Djgx/ge9WNLR0LZTfPdYdDpwWszvLmlzwpvylyX1ltSHsBGw2AMqH9OB3pJyGwq7A5cCk3PrzQUYBZxiZkPMbAjBh//IMvYltIfLgG9RegbrD8BH4nQ2AJJ2k7QvcAswQmtPlvQizEakp9sxs+eAmwhLGBuMmbUCf5W0f2y7P2E6/on4/RCtnWrYEVjN+g/6HDOBwyT1i3WPBObEWaRkm/8gbGL8ZiL7Z8DFOYNH4eTJKfHaxcCEOC7EcRpBMMqScj8kbGA8oYy9H47jZJCubBj00rpHCpOnEv5H0tL4uaOIjH1TMo6qkq4/Bs6Ou9qPA74paQ7hbe3wWOa7wH6S5hLWiXcys+eBycAzwNPA9RXuL8DMjGBQHC1pIbAAWAmcW6hOfPh/AfifhJz3CQ+6XDjhkxJjvFTSNgVk/VLSUoJxslR5juqZ2VuE0wYfSV8r0JcDFY4rvkh4GL5hZisIY3m+pBZgLvAsUOhY5S+Ak3MP4Ao5P9n3mHcC8KO4/PEH4KK4XwXg64Q9BrMJBslx6Qd9oo/NUecnYvlTgVPylSUYeFsl6j4Y6z4ax+Z5ILe/4irCeMyN4/Mj4PA4bmkd/krYW5KexXEcpw5Q+L/WcRynMhoaGqylpaXWalSFrK9RT7ziIUafdXCt1agaWb9/kmaZWUl/Pe2lK88YOI7jOO1gwJZ5J6wcB+japxLKQtJBhGnjJMkjiBsi+zyC85skZR1j3IA2BxD2DaQ5IJ7Prwnx1EJ6KeDrZja3FvqUSy3uYWz3ZNbf4/Ckmfn0vVN1BgzuW2sVnE5M5g0DM3sYeLhKsscDVX2A5GlzGbChxzQ7HDPbp9Y6tIda3MPY7g3ADRu7XcdxnFL4UoLjOI7jOG24YeA4jlNnLJjdkX6xnKzhhoHjOI7jOG24YeA4jlNn9Oi2ptYqOJ0YNwwcx3HqjD693X+NUxg3DJwORZJJujnxvYekNyVNjd/HSRqbqrNE0lYxvY2k+yQtjN4Nr4wBnZDUGOUfmqg7VVJjEX2aJLUkvFvemdDj9bTnzDzlC3rDlLQ6lpkn6QFJW8T8IZJWpLxq5lxS95V0XezbrNjePqX6XqD93pJukTQ36vCEpMGJNt9I9TE3jl+O45gL+b1rosw/JC2O6UcLte10bZa3eqwEpzCZP67obHTeB3aR1Cu62x0JvF5ORUkC7gauMbPDFeI6TCQcJ/x+LLYUOA94oAKdjovxEdJcbmbpqI7Fyqdpi8IpaQrBhXDu6OOiAhE6rwcWAzua2RpJ2wM7ldn3NN8F/mZmu0YdGgjuoXM6jSMEkUr3cRTBvfUo4MLoayJXZzIw1czuLKP/juNkEDcMnGrwIHAIcCfh4XMrIVx0KfYHVsYz/pjZakljCIGnLoxl5gCbSBppZtM6XvV28ydgt2IFJA0F9iEYHmsAzGwxoX8HUKTvBQJefQx4NffFzEr6J1YI/T2CEEnxAeDC4jXWqz8aGA0wcODAzMa8b21tzWzfAPoP+iDT/cv6/as2bhg41eA24IK4fLAbMInyDIOdCQGk2jCzdyW9BuyQyB4P/AQo1zC4RVLufNY0M8u9gY+RdHxMnxOdYaXLl/QoGd/uDwD+O5E9NAZBynEGIZzy7AIBlEr1vTlPnUnAI3G5YzowxcwWFtOVEGjq92a2QNIySXua2awSdZI6TSTMZNDQ0GBZ9UefdV/7E694iKO+2lhrNapG1u9ftXHDwOlwzKxZ0hDCbMGD6cuFqlUgf6YkJI0os0q1lhJ6xYf/x4GXWNdQWW8pQdJhZepbFmY2W9IngM8DBwLPSvq0mb1UpNoo4MqYvi1+L9swcLKBx0pwiuGbD51qcT9wCWEZIckywptzkn7AO8B8YM/kBUmbAdsBr6TqjAfO7yhl20luj8FgQJQOU/wisHucYUhTSd/bMLNWM7vbzE4Hbga+WKispP6E5ZrrJS0h7F34atzf4NQRy972zYdOYdwwcKrFJOCiPEGUZgKHSeoHIOlIYE6cXp8O9E7s4O8OXApMTq+xm9kjBAOj6Lr+xiDqdibwPUkFZ+HMbBHwHHBR7mEcTzAcQgV9zyHps5K2jOmewE4k9hzk4SjgJjMbbGZDzGxbwkbIcpZ5HMepE9wwcKqCmS01swl58puBq4En4jT8qcAp8ZoBRwBHS1oILABWAucWaGY8sG0Z6tySOI5XlSN4ZvYCYR/AqJg1NHVc8cyYfwqwNfCKpHnAZODv7eg7wFDgMUlzgRcIRsddRcqPAu5J5d2V0NlxHAeF/48cx3Eqo6GhwVpaSh6E6JJkffPaxCseYvRZB9dajaqR9fsnaZaZ7VUt+T5j4DiOU2f45kOnGH4qwckEku4Btk9lJ48gtlfuAML6f5qSxxg7CkkHAb9IZS82syM2RvtO9hgwuG+tVXA6MW4YOJmgWg/J+PDP58FwoxGNmw0ycBzHccrFlxIcx3HqjAWzV5Qu5NQtbhg4juM4jtOGGwaO4zh1Ro9ua2qtgtOJccPAcRynzujT24+pO4Vxw8CpGZJM0s2J7z0kvRmDLyFpnKSxqTpLJG0V09tIuk/SQkmLJF0ZPQAiqTHKPzRRd6qkxiL6NElqSTglujOhx+uJ/J8XKH9UEdmt8W83SRMkzZM0V9KzMfQykjaXdKOkV2J/bpS0eRGZeWVJejrq81ocz5x+Q2K94XFsvhC/D0iUeSPV156F2ne6Lstb3SWyUxg/leDUkveBXST1MrMVwEjg9XIqRpfCdwPXmNnh0YXwRII3xFz0xKXAeYTwwuVSrYBLOY4BBgG7mdkaSdsQxgFCdMZ5ZpZzi3wRcD1wdCWyzGyfWP8kYC8z+06q3ijgifj398mTF5LGAa0F+uo4Th3gMwZOrXkQOCSmR7F+0KVC7A+sNLMbAGKshTHANyT1jmXmAMsljexAfTeUjwF/NbM10OY6+m1JOxCCKP0kUfbHwF6ShlYiq1jj0aA6GjgJGClp0w3qjeM4mcNnDJxacxtwQVw+2I0QfKmcoD47kwoXbGbvSnoN2CGRPZ7wsE2GRC7GLZJyZ7mmmVlu9mGMpONjOuk4KVm+HKdHvyPEidiX4Djp5hhnYSdgdjRwcv1ZHeNJ7AwsqkBWMT5DcI60SFITwSgrFl9hHSSNBkYDDBw4kKampnKrdilaW1sz2zeA/oM+yHT/sn7/qo0bBk5NMbPmuPY9ijB7sM7lQtUqkD9TEpJGlFmlqksJZrZUUgNhxmN/YLqkQksF7ZJlZvk8NeYYRTDGiH9PoALDwMwmEpZsaGhosKz6o8+6r/27pkzNdP+yfv+qjRsGTmfgfuASoBEYkMhfRpguT9IPeAeYTwgj3IakzYDtgFeAvROXxgPnAx92pNLtxcxWAQ8BD0n6G/Bl4EpguKRuuaUBSd0Ia//zK5SV1zCI+zC+Ahwu6TxAwABJ/czsvQ7roNPpWfa2bz50CuN7DJzOwCTgIjObm8qfCRwmqR+ApCOBOXG6fTrQW1Juo1534FJgspn9MynEzB4BtiQsVdQUSXtIGhTT3Qg6vWpmrxBCJ5+fKH4+8Hy8VrasIs0fADSb2bZmNsTMBhNmCzzmguM4bbhh4NScuGluQp78ZuBqwjr6bOBU4JR4zQgPtKMlLQQWACuBcws0Mx7Ytgx1bkkc1Xu08t6U5KPAA5LmAc2EWYyr47VvAsPiUcVFwLCY1x5Z+RgF3JPKuyvmO47jAKDw/6vjOE5lNDQ0WEtLS63VqApZX6OeeMVDjD7r4FqrUTWyfv8kzTKzvaol32cMHMdx6owBW64uXcipW3zzoVN3SLoH2D6VnTyC2F65A8i/8a+cY4zF5O4K3JTKXpVzZOQ4lTJgcN9aq+B0YtwwcOoOM6vKZrukB8EOlju3GnIdx3Hy4UsJjuM4dcarL7bWWgWnE+OGgeM4Tp2x6gP3Y+AUxg0Dx3Ecx3HacMPAcRzHcZw23DBwHMdxHKcNNwycqiDJJN2c+N5D0psxiiKSxkkam6qzRNJWMb2NpPskLYyeAK+U1DNea4zyD03UnSqpsYg+TZJaEl4N70zo8Xoi/+cFyh+VR+aAxPU3EnLmSpqfJ3+2pBmSDkrJOUvSNanvKyVtXmKMe0u6JbY3T9ITkgYX0Gl2Yvy+HMfvk/H7roky/5C0uIqeHx3H6eT4cUWnWrwP7CKpl5mtAEYCr5dTUZKAu4FrzOzwGAdhIsGtcS4M8lLgPOCBCnTq0MiJyeOJksYBrWk56fwYtvhYIOkz4VjgB4nvo4BngSOBG4r057vA38xs1yi7AXjDzIrqFOU/Ef9emDwOKWkyMNXM7izSruM4GcYNA6eaPAgcAtxJeAjdCuxbRr39gZVmdgOAma2WNAZYLOnCWGYOsImkkWY2reNVrxp3Av8lqaeZ/Ush5PQg4HEASUOBvsDpBMOnmGHwMRJBk8yspH9iSX2BEcB+BKPqwuI11qs/GhgNMHDgwMzGvG9tbc1s3wD6D/og0/3L+v2rNm4YONXkNuCCuHywGyGKYjmGwc7ArGSGmb0r6TVgh0T2eOAnQLmGwS2SVsT0NDPLzT6MkXR8TCc9ICbLb5D3whxm9g9JzwAHA/cRZgt+Z2uDlhxLGLfHgQZJW5vZ3wqImwQ8Epc5pgNTzGxhCRUOB35vZgskLZO0p5nNKlEnqf9EwuwNDQ0NllV/9Fn3tT/xioc46quNtVajamT9/lUb32PgVI0YHXEIYbbgwfTlQtUqkD8TQNKIMqscZ2bD4+f7ifzLE/kPFyi/wUZBglsJBgDx762Ja6OA28xsDSHy4dGFhJjZbOATwMVAf+BZSf9eou1RBMOD+NcjKzqOsw4+Y+BUm/uBS4BGYEAifxlhKjxJP+AdYD6wzmY/SZsB2wGvAHsnLo0HzieEHO4q3AdcLmkPoHfujT3GRNgRmBa2WdATWEyRUMpm1krYj3G3pDXAF4GX8pWV1J+wTLOrJAO6Aybp+4kZC8dx6hyfMXCqzSTgorjBLclM4DBJ/QAkHQnMMbPVhGnx3pJOiNe6A5cCk83sn0khZvYIsCVhqaJLEB/mMwhjk54tGGdmQ+JnEDBI0uB8ciR9VtKWMd0T2InEnoM8HAXcZGaDo/xtCYZHOcs7juPUCW4YOFXFzJaa2YQ8+c2EN+EnJM0GTgVOidcMOAI4WtJCYAGwEji3QDPjgW3LUOeWxLG8Wh/FuxXYnXUNg2OBe1Ll7mHtskOaocBjkuYCLwDPEZYfCjEqj/y78OUEx3ESyGcQHcdpDw0NDdbSUvIgRJck65vXJl7xEKPPOrjWalSNrN8/SbPMbK9qyfcZA8dxHMdx2vDNh06mkHQPsH0q+5zUaYP2yB1A2PuQpkOOMZZo+yDgF6nsxWZ2RDXbdbLLsOG9aq2C04lxw8DJFNV6WCa9HG5solGzQYaN4zhOufhSguM4Tp2xYPaK0oWcusUNA8dxHMdx2nDDwHEcp87o0W1NrVVwOjFuGDiO49QZfXr7MXWnMG4YOBsVSSbp5sT3HpLejIGWkDRO0thUnSWStorpbSTdJ2mhpEWSroxe/5DUGOUfmqg7VVJjEX2aJLUkHB/dmdDj9UT+zwuUPyqPzAGJ628k5MyVND9P/mxJM+Lpg6ScsyRdk/q+UtLmJca4t6RbYnvzJD0hqV/8e3Ci3NGSfh/T50l6UVJz1GefYm04XZvlrd1rrYLTifFTCc7G5n1gF0m9zGwFMBJ4vZyKCgEE7gauMbPDo6vkiQTPh7mgSEsJ4YofqECn48zsuTz5l5vZJRWUB9Y9wSBpHNCalpPOj+GMj2Xd0wfHAj9IfB8FPAscSfFwzN8F/mZmu0bZDcC/CN4l75A0g/Bv/6fAFyR9GvgSsIeZrYpGWM8i8h3HyTBuGDi14EHgEOBOwsPuVsrz178/sNLMbgAws9WSxgCLJV0Yy8wBNpE00szKDcfcGbgT+C9JPc3sX5KGAIMI4ZeRNBToC5xOMHyKGQYfIxEzwcxy7gnnSXoAOAfoA9xoZosk7Q68ZWarYvm3CgmOBsxogIEDB2Y25n1ra2tm+wbQf9AHme5f1u9ftXHDwKkFtwEXxOWD3QjBhMoxDHYGZiUzzOxdSa8BOySyxwM/Aco1DG6RlDu/NS0RknmMpONjOukkKVm+Qxwcmdk/JD0DHEyIvngs8LtE1MNjCeP2ONAgaWsz+1sBcZOAR+Iyx3RgipktjNcuAp4nzCDkXKo+QrgfC4BHgdvN7LECek4kzNLQ0NBgWXU7m3WXuhOveIijvtpYazWqRtbvX7XxPQbORicGUBpCmC14MH25ULUK5M8EkDSizCrHmdnw+Pl+Iv/yRP7DBcp3pNfDW1kbMOlY1o+8eJuZrSEEPjq6kBAzmw18ArgY6A88K+nf47X3gdsJURZzMwStwJ6EmYA3gdslndRx3XI6GwO2XF1rFZxOjM8YOLXifuASoBEYkMhfRpgKT9IPeAeYTwgd3IakzYDtgFeAvROXxgPnAx92pNJV5j7gckl7AL3NbBaApF2BHYFpYZsFPQnhkq8uJCg+7O8G7pa0Bvgi8FK8vCZ+kuVXA01AU4zWeCIwuaM65nQulr3tmw+dwviMgVMrJgEXmdncVP5M4DBJ/QAkHQnMiQ+u6UBvSSfEa92BS4HJZvbPpBAzewTYkrBU0SWID/MZhLFJzxaMM7Mh8TMIGCRpcD45kj4racuY7gnsRGLPQZ7yDZJ2TGQNL1becZxs44aBUxPMbKmZTciT30x4E35C0mzCTvpT4jUDjgCOlrQQWACsBM4t0Mx4YNsy1LklcWzw0cp706HcCuzOuobBscA9qXL3sHbZIc1Q4LH45v8C8Bxh+aEQfYEp8ShlM8GQGFe56o7jZAGt3dvkOI5TPg0NDdbS0lK6YBck65vXJl7xEKPPOrh0wS5K1u+fpFlmtlfpku3DZwwcx3HqDN986BTDNx86dYGke4DtU9nnpE4btEfuAMLehzQdcoyxRNsHAb9IZS+uVuhpJzsMGNy31io4nRg3DJy6oFoPy6SXw41NNGo2yLBxHMdJ40sJjuM4dcaC2StKF3LqFjcMHMdxHMdpww0Dx3GcOqNHtzWlCzl1ixsGjuM4dUaf3n5M3SmMGwZOzZBkkm5OfO8h6c0YXAlJ4ySNTdVZEsMCI2kbSfdJWihpkaQro6c/JDVG+Ycm6k6V1FhEny9JekHSnOjs51up67Ml3Zan3tmSXpY0N9a9TNImCX23TjhQekPS6zE9N7aTzp+d6MeXYz8+WWIsh0haEevOl3RjQofG3Jgmyk+OQZaQ1FPSFZJeiWN5n6RtirXndG2Wt7pLZKcwbhg4teR9YBdJveL3kcDr5VRUCBpwN3Cvme0IDCN48BufKLaUEKK4HHmbEKIGHmpmuwP/QYgdkLv+70B3YF9JfRL5pwKfBz5lZrsC/wf4O9BrrXRW54IuAdeyNjjTrma2U5784Wb2r1h3FPBE/FuKRVHWrsA2wFfL6TvwU0I8ioY4lvcSYiyozPqO42QINwycWvMgcEhMj2JdV8DF2B9YaWY3QFsQoDHANyT1jmXmAMsljSxDXj/C8d1lUd4qM0u69RsF3EQIUXx4Iv884DQzeyfW+5eZ/dzM3i2zHwWR1BcYAXyTwu6P1yOOxTPAx8toozdwMjAm1iOO6SrCGDuOU2e4HwOn1twGXBCnuncjBBDat4x6OwOz/n97Zx5vVVn9//dHcEKcQDKHFMdrTpGYmmlfnEVLxSlRv0pmVFam/TRNLbUkNU3JzIGvOZc4TwjOIGqmAiIgehnSDBxBRa+CGa7fH886l83mnHPPvdzDvffc9X69zuvu/Qxrr2fvc8+z9jOslU0wsw8lvQ5smkkeAvwWeKScMDN7T9J9wL8kPQaMAG7xMMcA3yGNaGwB/BT4m0d27G5mr1agb0s4EHjQzKZJmiupbyHiYjkkrQTsCPwsk7yrx54osAGpjZsCrxcxZMaR7vFizpskDSaFZ6ZXr16MGTOmmU3qGDQ0NNRs2wB6rPtZTbev1p9ftQnDIGhTzGySpN6kN/KR+exS1Zohf6wkJO1SQdnjPcTxnsApJENgkKTtgTlm9rqk2cC1knqQC+mc8US4BnCkmf29Uj1LMBD4ox8P9/NyhsEm3vlvBDzgAakKPGlm38roen1LFDKzYaQpF+rq6qxW/dHXuq/9O28YUdPtq/XnV21iKiFoD9wHXMyS0whzSaGTs6wKfABMBfpmM/wNfgNgRq7OEOCsShQxs8lmdinJKDjEkwcCW0h6DZgJrAYc4m/ZDZI28roP+Rz/FGCFSq5XCjc8dgeu8eueChzexLx/YY3BJkBfSQdUcKmZwAbyMNcZ+gIvNV/zoCMw9/1YfBiUJgyDoD1wLXCumU3OpY8FDih0WpIOBl70ufDHgG6SjvG8LsAfgOvN7JOsEDN7mGRgbFtKAUndczsW+pCmFZYjLeLbxsx6m1lv0hB/YTHg+cCVktZwgUpNKAAAIABJREFUOQJWamb7i3EocJOZbejX/RLwKhVMs5jZHOB04JcVlP0YuAG4xO8hfk+7AY8vhf5BEHRQwjAI2hwzm2VmlxVJnwRcDjzlQ+Q/BI73PAMGAIdJmg5MAxYAZ5S4zBDgS2XUEPALSfV+rXOBQaSOeLaZvZEpOxbYUtI6wJUkI+VZSZOAp4EX/LM0DATuzqXdSWW7EyDtLOgmqZL1Gr8k3btpfi8PAwZYxGQPgk6J4n8/CIKWUFdXZ/X19U0X7IDU+hz1sKGjGHxS/7ZWo2rU+vOTNN7Mtq+W/BgxCIIg6GT0XHNhW6sQtGNiV0LQ6ZB0N2nlfpbTPIxxu8Z3TdyUS/7UzHZsC32CjknPDbu3tQpBOyYMg6DTYWYD2lqHluILNPu0tR5BENQuMZUQBEEQBEEjYRgEQRB0MqZNnN/WKgTtmDAMgiAIgiBoJAyDIAiCTkbX5T5vulDQaQnDIAiCoJOxSrfwXxOUJgyDAEkm6ebMeVdJ73rEQySdI+mUXJ3XJK3lx+tLulfSdEkzJf1R0gqe18/lfztTd0TO/XBenzEFD4T+uSOjx+xM+gUlyh9aRvZCL/OipAmSds7lnyRpgaTVM2n9JM2T9IJfZ6ykbECic7yNm+bkmAdgQlJD7jqDJF2eOR8s6RX/PJcN+uTtG5c5317SmDJt7Cbpr5ImS5oi6SlJq/rf/plyh0l60I/PlPSSpEl+f2L7Yw0zryFiJQSlie2KAcDHwNaSVjaz+aQAQrMrqeixAe4CrjSzA93f/jCSC+JTvdgs4Ezg/mbodJSZjSuSfqmZXdyM8nnme6ChQjTE84H/yeQPBJ4HDgauy6Q3RieU1Ae4R9J8MyuEJZ4MHAGc5+eHUWEQIjcyfgDsYmZzJG3n8ncws7e82Bck9TezURWI/Bnwtplt4/LrgP+QXErfLmk06X//d8C+kr4OfAvYzsw+dYNvqYJABUHQcQnDICgwEtgfuIPUOd5CBQF7SBEAF5jZdQBmtlDSycCrks72Mi8Cy0vay8weaX3VW8xqwPuFE0mbAN2BE0iGzHXFKpnZREm/AX5CipMAKTbBgcB5Lmce8FmFepwGnOrBjzCzCZJuAH4M/MrLXOQ6VWIYrAP8K6NvwW/xFEn3+/VWAW40s5mSvkIKK/2pl59TSrCkwcBggF69etVszPuGhoaabRtAj3U/q+n21frzqzZhGAQFhgO/9umDbUkRDysxDLYCxmcTzOxDSa8Dm2aShwC/BSo1DP4qqbCn6hEzK4w+nCzpaD/OeivMlt/DzOaWkLuyB0laidSB7p7JO4J0H54E6iStbWZvl5AzgUUjIgAfAv+WtDXJQLgV+G7TzQSK3ENgHHBs5vwZYICk3YCPmpB3LfCwT6k8BtxgZtM971zX/T9Awdf6w6RnPw14FLjVzJ4oJtjMhpFGhKirq7Na9Udf6772hw0dxaGH92trNapGrT+/ahNrDAKgMZJhb9Jowch8dqlqzZA/FiA7d94ER5lZH/9kO+BLM+kPlShfyigAn0owsy2AfYEbfToEUtuHm9nnpEiGh5WRoyJpw0nGxUEsGRmxGM1dAXYecFaTQs0mAhuTRhl6AM9L+rLnfUwyWm7KjBA0AH1JIwHvArdKGtRM3YIORMRKCMoRhkGQ5T7gYtI0Qpa5wJq5tFWBD4CppE6lEUmrARsAM3J1hlBBx7asMLNngLWAXh6DYDPgEUmvkTr4ciGOvwq8nEsbAfwv8LqZfZjLm19YkOn0AApD9kvcQz9fbI2CmT0OrAzsVEavQtkGM7vLzE4Abgb2y2R/7p9s+YVmNsbMziZNkRzS1DWCjsvc92PxYVCaMAyCLNcC57o//ixjgQMkrQog6WDgRTNbSBqq7ibpGM/rAvwBuN7MPskKMbOHSQbGttVtRmVI2gLoQjJ8BgLnmFlv/6wLrCtpwyL1tiXN/f85m+7tPY1kAOV5Ajja668MHA6M9rzfAxdK6un5fYBBwBVF5JwH/KKJdn1D0pp+vAKwJZk1B0XK10naLJPUp1z5IAhqm1hjEDRiZrOAy4qkT/KtdU9JMuAd4HjPM0kDgCsk/YpkbI4EzihxmSHAvRWok10zMMfM9mxea0pSWGMAaTrgWF8weQSLv1VDmg44AngW2FXSC0A3UvtPzOxIaMTMhpe47s+AqyWd6Ne9sTC9Ymb3SVoP+Lvf34+Ao83szSLyR0p6t4k2bgJc6VMkywEPkKZGStEd+JOkNYD/kkZ6BjdxjSAIahSZhaOLIAiaT11dndXX1zddsANS64vXhg0dxeCT+jddsINS689P0ngz277pki0jphKCIAg6GbH4MChHTCUEbYaku4GNcsnZLYgtlduTRf4FspTbxtjhcAdNF+aSXzWzAW2hT9Bx6Llh97ZWIWjHhGEQtBnV6sC88+9TDdntCTeglsqICoIgyBNTCUEQBJ2MaRPnN10o6LSEYRAEQRAEQSNhGARBEHQyui73edOFgk5LGAZBEASdjFW6xTb1oDRhGHQiJJmkmzPnXSW964GTkHSOpFNydV7zMLxIWl/SvZKmS5op6Y8FN7+S+rn8b2fqjpDUr4w+YyTVS5ronzsyeszOpF9QovyhZWQv9DIvSpogaedc/kmSFkhaPZPWT9I8SS/4dcZ6SORC/jnexk1zckzS9n7ekLvOIHcOVTgfLOkV/zyXjR3h7RuXOd9e0pgybewm6a+SJkuaIukpSRtm7s9buftYeFYHuc5b+Pk2mTLvSXrVjx8tde2gYzOvIVwiB6WJXQmdi4+BrSWtbGbzgb2A2ZVUdC96dwFXmtmB7vp4GMmTYSHI0SxSaOD7m6HTUWY2rkj6pWZ2cTPK55lvZn1c932A84H/yeQPBJ4HDmbx8MpPmtm3vF4f4B5J8zNeDieTvCGe5+eHkYtpUAo3Mn4A7GJmcyRt5/J3MLO3vNgXJPU3s0rCK/8MeNvMtnH5dcBbmXafAzQUuY8Dgaf879nuArtQ53pghJndUUmbgiCoPWLEoPMxEtjfjweyZMCkUuwOLDCz6yAF3QFOBo6T1M3LvAjMk7RXK+rbGqwGvF84kbQJyQ3wWZQJlORRCn9DCipU4B5SWOWCnHksCobUFKcBp5rZHJc/AbgB+HGmzEUk46oS1iFj2JlZfSFiYikkdQd2Ab5HMnCCIAgWI0YMOh/DgV/79MG2pMBJu1ZQbytgfDbBzD6U9DqwaSZ5CPBb4JEK9cnGRHgkE2L5ZElH+3HW6VG2fDmHRYWYCCuROtDdM3lHkO7Dk0CdpLXN7O0SciawaEQE4EPg35K2JhkItwLfbbqZQJF7CIwDjs2cPwMMkLQbKWZCOa4FHvYplceAG8xsehN1DgQeNLNpkuZK6mtmeZ1KImkwHkehV69ejBkzptKqHYqGhoaabRtAj3U/q+n21frzqzZhGHQyPCBSb9Kb8sh8dqlqzZA/VhLZufMmWBZTCV8HbpS0taXgIAOBAWb2uaQ7SdMBl5eQoyJpw0nGxT7AHjRtGDR3pdd5pNGM08oKNZsoaWNgb2BP4HlJXzezfDjoLAOBP/rxcD+v2DAws2GkKSTq6uqsVv3R17qv/TtvGFHT7av151dtYiqhc3IfcDFLTiPMJYVFzrIq8AEwFeibzZC0GrABKRpfliGkjq1dYGbPAGsBvSRtA2wGPCLpNVIHX3I6AfgqkO9oRwD/C7xuZh/m8uYXFvk5PVg01bDEPfTzxdYomNnjwMrATmX0KpRtMLO7zOwE4GaWjBDZiKQepJGTa7ztpwKH+/qRoBMx9/1YfBiUJgyDzsm1wLm+6CzLWOAASasCSDoYeNHXEzwGdJN0jOd1Af4AXG9mn2SFmNnDJANj2+o2ozJ89X0XkuEzEDjHzHr7Z11gXUkbFqm3LfAr4M/ZdG/vaSQDKM8TwNFef2XgcGC05/0euFAplkNhceMg4Ioics4DftFEu74haU0/XgHYEvhXmSqHAjeZ2Ybe9i8Br1LZVFIQBJ2EmErohJjZLOCyIumTfGvdU5IMeAc43vNM0gDgCkm/IhmVI4EzSlxmCHBvBepk1wzMMbM9m9eakhTWGECaDjjWzBZKOoIl36rvJo0cPAvsKukFoBup/SdmdiQ0YmbDS1z3Z8DVkk70695oZmO9zn2S1gP+7vf3I+BoM3uziPyRkt5too2bAFf6G/9ywAPAnWXKD2TJoEt3evrYJq4VBEEnQWnKNQiCoHnU1dVZfX19W6tRFWp9jnrY0FEMPql/W6tRNWr9+Ukab2bbV0t+TCUEQRB0MnquubCtVQjaMTGVEFQdSXcDG+WSs1sQWyq3J2ntQ55y2xg7HO6gKT8F8Gq1wlYHtU/PDbu3tQpBOyYMg6DqVKsD886/TzVktyfcgFoqIyoIgqBSYiohCIKgk/GvlxqaLhR0WsIwCIIg6GR8+ln4MQhKE4ZBEARBEASNhGEQBEEQBEEjYRgEQRAEQdBIGAYdBEkm6ebMeVdJ73qURCSdI+mUXJ3XJK3lx+tLulfSdEkzJf2x4NNfUj+X/+1M3RGS+pXRZ4ykekkT/XNHRo/ZmfQLSpQ/tIjMnpn8t3JyVihS/qGC++Yyen5D0rMu42X32tgsJG0nad/M+XmSTsqVmSVpjebKboYOy0k6vcKyldyX4yR9sXW0C4Kglojtih2Hj4GtJa1sZvOBvYDZlVR0l7l3AVea2YEe52AYyW1xIaTwLOBM4P5m6NSqkRGz2w8lnQM0FJPj7ZGZ7VOBjjcAB5nZFG93XQV18mwHbA082IK6S423tytwOnBBU+UrvC/HkUJKv7V02gVBUGuEYdCxGAnsD9xB8m9/C5UFwNkdWGBm1wF4zICTgVclne1lXgSWl7SXmT3S+qovHZI2JUWFfIEU8XAvSc8CW5vZB5LOJcU7eAd4A3jGzIYCvfDOz4NBTZW0HDAN2MHM3nODYTqwPSmE8VnAQuA9UlyFX5NiL/QjBTdqSs97SHEXdgJeJ4V4XiBpc+AqoKfLP9jMXvORgIOBlYA7zOw3Rdr7LLCqx3+YZGbHSLofWNfrXWpm17gOs0iGzFrFdAEOJBlgt3qcil8Ag83sUK/fHzjOzA4r0r7BwGCAXr161WzM+4aGhpptG0CPdT+r6fbV+vOrOmYWnw7wARpI0QrvIHUEE4F+wAjPPwc4JVfnNVLncCKp48jLfMFl9iOFEv4m8ITnjQD6ldFnDFDvekwELsroMTuTvk+J8j2baO9i7QE2BT4Hts+kzQLWIHV644EVgdWAfwIneZlzgfdJIybfB1b09N8CP/Hj/YBb/fhlYG0/XsP/Hg8MzVz3vIL8IrpsCnwGbOPpdwFH+PF44Nt+vBIpUNN+pOiKhUBIDwI759tLMuI/yF2zh//tRgrpvGYzdHkK6OPHBUOpp5/fBvRv6ju5+eabW60yevTotlahqlx96ci2VqGq1PrzA8ZZFfubWGPQgTCzSUBv0mjByHx2qWrNkD8WQNIuFVY5ysz6+OfUTPqlmfSHSpRvicvimVZ8KmIX4B4z+9TMPiQZNQCY2dnA14BHgWNIEQgB/gIc68fHAdf58dPAjZKOp/QanKbu9QxbFNJ6PNDbwyOvZWb3u14LLIVv3hvoTzLSJpA6882baG+BkyW9CDwDrE+KtphnCV2WUNrsc+CvwJGSegB9gYfLXDcIghomphI6HvcBF5Pe8ntm0ucC6+TKrgp8QHqbXGyxn6TVgA2AGcAOmawhpKH0/7am0q3Exy2pZGYzgBmSrgHmSFrd0hD++5J2Iw3VFzrC7wM7At8CJkj6ahGRc4E1c2mrkMIo9wI+zaQvpPz/mYDzzOwviyWmqYSS7ZW0J2mEZyczmy/pKdIoRJ5KdbmWRSGbb7U07RIEQSckRgw6HtcC52beAguMBQ4orEaXdDDwov/APwZ0k3SM53UB/gBc72+tjZjZw6ROb9vqNqNVeZrU9hW9/fsVMiTt74v3ADYjdZQf+flfSG/Kw/2tGWBjM/sH8CvSFMR6Xj67yn8scJCk7n6Nw4HnMzKWwMzeB94t7PyQtJKkbqQYCN+TtIqnr1/YSZKr/1/PL3TsqwPvuVGwFWlUpDks1iYz+zcwh7TA8fpmygqCoIaIEYMOhpnNAi4rkj5J0uXAU5KMtAjveM8zSQOAK3y73nKkqYgzSlxmCHBvBer81RevAcwxsz2b15rWwcyekfQgMBl42//O8+xBwCWu52fAkZkO/G6SoXV9RtylkjYivck/bGk3w9vAqZJeAIaY2R2SrgKe9nv9Nr4grwmOAq6WNAT4D3CImY2UtAXwD7dfPgKOLFH/L8AkSeP8eoMlTSWt3Xi2gutnuQ64xu/LDmb2H+BvwGpmNq2ZsoIgqCGU1jEEQcdGUncza/A376eAY31NRrk6OwHnm9luy0TJdo4bO8+Y2Q2VlK+rq7P6+voqa9U2jBkzhn79+rW1GlVj2NBRDD6pf1urUTVq/flJGm9m21dLfowYBLXCXyTVkebZr63AKDiT9NZ9xLJQrr3j2yDfJ+1gCYKgExOGQVAWSXcDG+WST8vtNmiJ3J6ktQ959mjJjgUz+04zyw8hTZkEgJn1aWsdgmXH5n1WbmsVgnZMGAZBWcxsQJXkNno5DIIgCNoPsSshCIKgkzFt4vymCwWdljAMgiAIgiBoJAyDIAiCTkbX5Uq63AiCMAyCIAg6G6t0i23qQWnCMOhgSDJJN2fOu0p6V9IIPz9H0im5Oq8VvOm5Z717JU2XNFPSHyWt4Hn9XP63M3VHeFTBUvqMkVQvaaJ/7sjoMTuTfkGJ8ocWkdkzk/9WTs4KRco/VPD4WEbPb0h61mW87I6ekLS7+zMoS76cpJslHZQ57yrpg6bkLA2Sekj6YQXlukh6soJyP5dUzI1yUOPMa+jS1ioE7ZjYldDx+BjYWtLKZjYf2IsUzbBJ3DXwXcCVZnagu0YeRtq2VwiCNAs4E7i/GTodVSLYz6VmdnEzygOL71iQdA7QUEyOt0dmtk8FOt4AHOSeDLsAdZ6+O8kV8D+aqF9puargrpB7AD8khW4uibvBriQc989Jnh8XLLWCQRDUDGEYdExGAvuTQjAPBG6hso5gd2CBmV0HqQORdDLwqqSzvcyLwPKS9jKzR1pf9aXDgwvdR4pG+FVgL0nPAlub2QeSziU5LXoHeIPkyW8oKbjRW9DYcU6VtAnJbfRCSYOAE7zcGcAKwLvA0aSYAvly5XTcE/glyS3zVsCzZlaIU7EjMJQUKnkBsBvJPfLvSVEiVwIuM7NrXM5ZpJDbmwAvAXXujOhB4HfAPaQQy12BM8xshBsRc8xsjVK6+HP/AvCku3y+DdjczE5xPX9EihuRjZqJpMG4++devXrVbMz7hoaGmm0bQI91P6vp9tX686s61YzpHJ/W/5A6iW1JRsFKwERSpMURnn8OcEquzmvAWiSvdpcWkfmCy+xHCln8TeAJzxsB9CujzxiSr/6J/rkoo8fsTPo+Jcr3bKK9i7WHFJb4c2D7TNosUue4Eym08IrAasA/gZO8zLkkz353kSIorujp5xXK+PmaLHIV/kPgwhLlbiaNQBTOuwIf+PGefq11gS7A867bSsCrwHZebnXPPwE43dNW9OexgctpADbItH1i5prLk2IbQOrkp1eqS/a++fFqwEygq58/B3y53LPZfPPNrVYZPXp0W6tQVa6+dGRbq1BVav35AeOsiv1MjBh0QCwFTOpNGi0Ymc8uVa0Z8sdKQtIuFVZp1amECphZov4uwD1m9inwaWHdBYCZnS3pJmBv4BjgO6ROM88GwG2SvkjqpEsFFCp2P7Np/zCzN6DR3XBvUmTH181sgus0z/P3Br4sqeCeeXVSJEhIIx6vl9BBwAX+nD4HvuRrSfJrHYrpstiUiJl9KGks0F/SP4GFZvZyiesGHZyea0ZU7aA0YRh0XO4DLia95ffMpM8F1smVXZXUWUwFFlvsJ2k1Umc4A9ghkzWENIz939ZUupX4uCWVzGwGMEPSNcAcSasXKfZn4HeWoh7uSQpDXIy5pNGFAj1IaxAKfJo5Xkj5/zUBJ5jZYi6i/frl2noMyYjYzsz+K2kWaVQiT6W6XENad/AaKfpiUKPMfT8WHwaliV0JHZdrgXPNbHIufSxwQGGVvqSDgRctzas/BnSTVJjv7gL8AbjezD7JCjGzh0kd37bVbUar8jSp7St6+/crZEja3xcrQnob/5QU4vgjkuFUYHVgtpc9NpOeLzcGOELS8n4+CBjdhH5TgQ0kbec6rebP4CHgBF8bgKQ6ScWc2RfT9R03CvYC1mvi+mXlmdnTpLUMhwG3NlNWEAQ1QowYdFDMbBZwWZH0SZIuB56SZKRFeMd7nkkaAFzh2/WWI01FnFHiMkOAeytQ56+SCj5W55hZsSH6qmNmz0h6EJgMvO1/53n2IOAS1/Mz4Egz+1zSvcDtbkD9mLSm4W7gPVLnXxh9Waycmd3jHfx4SZ8D00lrEsrp96mkgcCVvk1wPmlB6NWkUZuJbru8AxxYpP7bksZLmgw8AFwC3O/nz7kOzWEY8Kikf2ee2R3AFoVpjiAIOh+FRVZBUBNI6m5mDZJWAZ4CjrUmQjAHi3DD6nwze6KpsnV1dVZfX78MtFr2jBkzhn79+rW1GlVj2NBRDD6pf1urUTVq/flJGm9m21dLfkwlBLXGX3yB3XjgljAKKsOdSk0H3q/EKAg6NrH4MChHTCUEFSHpbmCjXPJpZvbQUsrtSVr7kGcPS46OmoWZfWdp9Oms+L3erMmCQU3Qc8Puba1C0I4JwyCoCDMbUCW5jV4OgyAIgrYnphKCIAg6GdMmzm+6UNBpCcMgCIIgCIJGwjAIgiDoZHRd7vO2ViFox4RhEARB0MlYpVtsUw9KUxXDQNJCj3tf+Jzu6WMkNbn3UlI/SfNyMvYsIbt3kfKPlpB7ZqZMVs6JRcoOkHRqMTmtiaTzJM3OtWlVJW6TNEnSiZK2lPSipBc8TkJWxhcydd/Kyesi6UuS7pM0XdJMSZdIWl7SfplyDZLq/fi6jOzLJb2e8RqIpOMlDa2wfRdImiXpg1z6eX7NtTJpDf63a+b5TJF0a8EToKR1/b7McGc/DyhFXETSNv4dq/e2npGRfbykd13mK8WeeZnnMlnS/pn0k3JlN/Utkvn6J/nxNyQ967JeVnIuVe66efmzJK3h98UkXZjJO13SWZnzQX7PJkuaoBRFEf8+ne33bZqkxyR9OXeNyf59Gy3pS+XuT9CxmdcQLpGD0lRrV8J8M1valeZPmtm3KpHtHWWp8o2Y2RCSNz8kNZTSUVJXM7u7RVo3A7kLXFJEwqG5vPWBbc1sCz8/i7Qv/4K8HDN7B1/ZL+k8kvfBoX4ukte+S83sJr/mX4DfmNkv8SBMkp4CfmJmjR2ckrveA0nhi3cBnmxBM+8FLgemFMl7DzgZOLNI3kdm1sf1Hw58X9KfSGGGh5nZ4a7jV4G1Jb3h1/q+mT2m5ODobklzzexql/lXMztJUi+gXtLtZvZmGd0vMrOhkrYGRkv6QvObD8ANpEiMU/ye1rVQDiRviYdLutDM3stmSPoW8BNgTzN7S8m74tGe/TPga8A2ZjZfUn+S18StPOgUwK6WQlcPIXnD/NFS6BkEQQclphIcSTdLulLSc8Dvsm/FkjbzN77JkoYU3n6V3sav8jfQhyU9KOkgz/uapCf8rXaUpLU9/SlJl0oaR/oRL8XDwIb+lvlrL/tTlRgNKcPepBC8NwGY2X9JncRg7zjKsQcpBPAwUiTHZmNmzwBvlci+BjhKxYMZFeobySDZFNgLaDCzazL5L7iP//8FxhQCEZnZx8BPKRIEyczeJYVkzgebKqXDFFKgozWbKluCXvg9MLOFZja1hXIA/kOKk/GzInlnAD83s8K1FmTu1WkkV87zPW8UKQTzEUXkPEPz4y4EQVAjVGvEYOXc0Or5ZtbcoCy75mQcYmYzc7Jfzeyvz5a/3UcHmss6pFj1n0s6PpP+J+BiM7tdUrYzP4z0A7ol8EXgZeAqSSsCfwQOMLM5ko4CfgsM9npdCu4s/Q3/VEmDPK8Qa+AA4I7CqIakFciMBDSDrUheABvxt8I3gI1JgX1KMRC4BXgQOFfSiW5YtBYfAjcCJ5LuzxIoBSnalzQasDW5tmQo1s56JY9+3XIyewNdKD6KUUyHnYEFZvaeFs2oNIehwHRJo4FRwI2Zt/SW8CdSXIV8SOsl7gGApB5AVzP7Vy5rnNfJsw9pZGYJJA3Gv8e9evVizJgxzdO8g9DQ0FCzbQPose5nNd2+Wn9+1aYmphKaKN8cbjezYst1d2RRpL6/Aef58S7AbV7nDUkFV7JfJv3gPuodSRdgVkZe3khaYiqhrXHjZh/S9MLHkiYAe5KMhNZkKDBB0qW59FUzht4TwPWkEYCl4ShJewBbAD8ws/80Ub5gsH0ElPOoWGollwGY2dmSbiKN3hzjskoFmiory+V9IOlvpFGk1lxF9qSSJ8oPKBFu2syGkUaQqKurs1r1R1/rvvbvvGFETbev1p9ftQnPh4vzcSvJETDJzHat8nUqYSqwmMEkaQ3SSMc/y9TbjxTW9yU3blYB3qeVDQN/C7+NJSMTflRkLclL5NqSYSqwQ6785sBcM/vE21BYY7AjMErSCF+fUYpKDba5LDnN0IM0ggSAmc0AZki6BpgjafUSEQyLyVqFZJxkp/4uIU0F3ESaXoB0D/qSQm834vf4v5I2MLPXM1l9SSGfC+xK+m7eApwN/KJ4c4OOztz3Y/FhUJpYY1AZzwGFKYvsnOzTwKG+4nsd4JuePhVYT9IOkKYBJBUbsl0WPAys6dMZhQWPlwD/Z2YLytQbCAwys95m1ps07dC/gnUJLeEPwAk0/X18GFhN0nGFBElfkfQNUge5m6TdPL0bKSz17/NCzOxZUue3tCMQBXkfAO9L+h+/dk/S6MDTfr6/Fs1BbAZ8SuroizEWOEhSd697OPB8fiTLzOaQwkNfREBBAAAXf0lEQVQPyiSfD1ycWc+yoqTved5FwJ8Kz0/SPqSRsMVGr8zsM+Ak4Dg3IIMg6GRUyzBYWYtvv8uupH9AaWvULEm3l5Gxa07GoVXStRJOBE6TNIkUSKjwpncb8A7pzfB60kK9eT5/fChwidd5gfQjXIpTc21tta1i3qEcBAxUip5XT+qUym2Z604a6h6VkfMR8A9gf0/6XuY5zpL0xRKyLgFeI3Xos5TZWpeR/TYwAlihibYYaZfEfkrbLl8iTeu85YsNDwLOkVQPTCKFXb6qhLgLgOOVdi80l3My7X7N044GfuPTH48BZ5lZIW8Q8IrnXQ8cWWLKCjOb4Do/7eW/x6K1KXkuAr6QqXsfcDXwuN+b8UAhWs5QYCIwRdI00lTBAcWMQzObBdxO7EoIgk6J0m9tUA7vPD4xM5N0NDDAzA7xvO5m1qC0Be5ZYEdf9R4ENU1dXZ3V19e3tRpVodbnqIcNHcXgk/q3tRpVo9afn6TxhQXs1SDWGFTG14ChkpYjzbN/N5M3StJqwPLA2WEUBEHQ3um55sK2ViFox7SpYeDznBfmkrNbEJdG9pmk7YRZWrSN0czGUCI0cJkFhlVBycnOw0Wy+vlcd5ug5Jch/306cin37FcdJR8RB+eShxdzJNXK1z2eJf1YjDWzsh4Zg6A16Llh96YLBZ2WNjUMzOwhFl8V3ZqyG70c1hJZL4ftiWoOa1UTM/sN8Js2uO41JAdPQRAE7YrYlRAEQRAEQSNhGARBEHQypk2c39YqBO2YMAyCIAiCIGgkDIMgCIJORtflirrRCAIgDIMgCIJOxyrdwn9NUJp2YxhIWpjz/ne6p4+R1OSKd0n9JM3LydizhOzeRcoXDWcs6cxMmaycJbaVSRog6dSlvRfNRdKvS+j4Y8//kVJo6FeUwkfv7On3ebkZuXuxo+evreRj//jc9WZV4i5X0laSnpH0qaSTMuldJZmkCzNppxe8Iko6T9Js12WypP0z5QZJmuLpEySd7OmSdLa3ZZqkxyR9OafzZEmTJI0u513S9SvcxymSbpW0sqcvsSVUKWT3Qbn62dDcf87o/JykDctc94NcWjb893mSGiStlclvyByvK+k2vwfjJT0gaVPP28b/l+olTZd0Ru4a73p7Xyn23Q5qi3kNESshKE17cnC0TCMyKoXebTIiY3bbo6SGUjpK6mpmd7dI62bg11ks9HFhy51SHIQ5WR29w/ousLMH09keuEtSXzM7wMvsSYqieBCLczjwDCluQku21s0hxSMo5s56PnC4pAvN7L0i+ReZ2VBJWwOjlfw37E/a+7+nmb2l5Pf/aC//M5Ijqm3MbL6k/sD9krbKhDje1SMTDgHOoLzL34/MrI8kAcOB7wNXNKv1iSOBnsC2Hs57A1K46ZbyHnAycGY20fW8BxhmZod72leBtZVCbN8LfN/MHlPy5Hm3pLlmdrWLKASY6gXUS7rdzN5cCj2DIOigtCfDoMMh6WZS3IG+wBglH/Rb+w/sZsDNQDfgPuDHZraGpC7An4F+wOvA58BVZnaPpK8BF5P8279DCmL0tqSnSJH0dnWZzQnRfBpwSqHzNbNxkv5KClp0bhN1B5I69jskrdPcjsJjILydfZvO8B/gWlKHfnYZGVO801uT1Jn/3Mze8rwFLDJYTgN2MrP5njdK0vOkoFc35MQ+Q+n4A/nrm6Qngc0rKV+EdYA3C7ERctENW8I1pABHv89FZ9wLaHD/CPi1XgCQ9ANgjJk95ukfS/opKVLm1RkZmNm7kv5Z0Dt/cUmD8XvXq1evmo1539DQULNtA+ix7mc13b5af37Vpj0ZBisrBY0pcL6Z3VqydHF2zck4xMxm5mRnPStmy7fIKyLpB3QnfxvMDrn/CbjYzG6XlPVwdxgp5PGWwBdJAZiukrQi8EdSYJs5StEQf8uiDqxLC50IbUkKppNlHPCdcpV8RKWHmY1XCnZ1uOvXmvwJmCjp4jJ67Aws8NGOrViyLUjqAXQ1s3/lssYBxaJa7kN6u24SScsD+5LeuFvCcOBJSf1IwZVuNrOJ5auU5UPgRlJgr99m0remyL1xlrhvZlYvqadSFMpG/Ll3AaYUE2Rmw4BhkGIl1Ko/+lr3tT9s6CgOPbxfW6tRNWr9+VWb9mQYLNOphCbKN4fbS0TK2xHYz4//RooCCLALcJvXeUPSE57+ZdIP+KPpBZkuwKyMvOYaSQXUdJGiHJG55nDSMHqrGgY+rP830vRAfjXUqZIGkUZkyhoxzeBJpZDIH5CiC5Zj1YzR+AQpKmIpiq3kMkgjBJLqgN39M1rSAHezXYmcYulDgQmSLi2jU3M5StIewBbAD8zsP60oO2hnRKyEoBztyTDoqHzcSnIETCoTe6Gl15lKmuoYm0nrC7zURL2BwFqSjvXzdSVtbGb/bKEepbiENE1yE2l6ocBFZpafMinWFnw04b+SNsgN1fdlcZfbu5Lu4y2k6YtflNHroyLrUkr9v8wlTXUU6EFaX1HQbwEwEhgpaQ4pdPSYvBAzWyjp89w6ksVkebn3JN0G/DCT/BJQysidCuyQa8vmwFwz+8QN0cIagx1JgcFGuPvtoAaZ+34sPgxK0252JdQgzwGFKYsjMulPA4cqsQ7wTU+fCqwnaQcASSv40PnS8nvg95LWdLnbkRbsXVmqgqQtSUPz65lZbzPrDVyUa0erYGZzgLuBQRUUPx+4WNLarueKkr7neRcBf/IFiYUAXTuSG2kxs8+Ak0jz9E3urKiQMcARPu0AqS2jXY++/pxRis65DZCf8sgylrRgER/mP6wgK8cfSOtECv/DDwOrSTquUEDSVyR9g2R07SZpt4zcy0jfjcUws2dJhtNPm2p0EAS1SXsyDFbW4lsKs9HtHlDabjbL57tLsWtORrHV8MuKE4HTJE0CNgIKC8VuIy0sfJk0PP0CMM9Xzh8KXOJ1XiB1bEuFmd1FWrD4D0mvAFeRoh6WexscSOqss9zp6QVeyjyTJToYAEnrS5pFuhfneNluRYpeBHyhgrbcR1os97ikl0jz5oUwcUOBicAUXwR6Omm9xoIicmYBt1N+V0IpVsu0e5akE83sHuBZYLxPP3wN+KWX/yLp+zsFmEzajVHSKCN1yEe4nH+Q3uT/XqQNbwMjgBX83EgjEftJmun35zzgLTP7GDiI9AzqgUnAU6TvQjEuAI733QtBEHQylH5PgtbGf1Q/8VXtRwMDzOwQz+tuZg2+NexZYEcze7ct9Q2C5lJXV2f19fVtrUZVqPXFa8OGjmLwSf3bWo2qUevPT9L4aka0jTUG1eNrwFAfPn6f5EugwChJqwHLA2eHURAEwbIkFh8G5ehwhoHPHV+YS85uQVwa2WeS5nSztGgbo686L7rLoswCwyaR9Gvg4FzycDO7oFj5ZYFv0/xJLnmsmbVrD3pKTpMeLpLVz8yW8HDYytcex5L/f0ea2dRqXjcIAHpu2L3pQkGnpcMZBmb2EIuvNG9N2Y1eDtsrBS+Hba1HFneq0xLPiG2Kr7NY2i2yLb121YYBgyAIlob2tPgwCIIgWAZMmzi/rVUI2jFhGARBEARB0EgYBkEQBJ2MrssVc9YaBIkwDIIgCDoZq3SLbepBaZo0DLQoLn3hc7qnj1EK4dtU/X6S5uVk7FlCdu8i5R9tQv4xWhTr/gVJpzRHv9ZE0jmZ618v6VVJL0qaJulGSetnyh7nOk9y/Q+sVHaRvD/7vZoqaX7WwZN7WDxL0nTXY3TBo6KkZ73c65LezT4Hz+8jySTtm7teQ4X345uSJii5Kz40k97b5f40k3a5UmyE7L2b6PW/nil3iqRXPO95Scd4+gqShkqa4W29N3e/C9+1KZLuVxmvh65f4T5OlXSVpOU8fYngQvnvWracpG6S/urPeoqkpyQVXRJeTH6R79RspYBbSFpL0muZsptLGuntnyDpNi3yErmLpOf83r2iFCUxe43ZmfZmHVkFNci8hnCJHJSmkl0JyzS4kXdKFQU3ktSf5N52bzN7w38wj1lKXdHivuqXhlPN7A5JIun5uKStSV7+zgS2M7N53lH0aulFzOzHrndvYET2nipFdtwZ+Ir7xd8buE/SVma2o5cZBGxvZvkthwNJHvIGkkL0NpfXSe6Bixk07wA/k3R1iYA9hXu3N8nb4baSfkgKL7yDmX2o5AuisE31d8CqQJ3HHPgucJekHd0rYON3TdINwI8pvwNlppn1UYqP8DjJc+CE5jUfSGGl3zazbfzadcBnLZBTYCFwHDnviUquoB8ghaW+39P6Ab38+/c34CAzmyBpLeAhSbPN7AEXcamZXawULny8pDvcfXQQBJ2Mjj6V8EvgFDN7A8DMPjWz/8vkH+ZvSdMk7QqNb2VP+hvVBKWwvoWRjScl3UeKW4CkX0mq97e8WzJvbptIelDSeK+zRTklLXEp8BbQn2QYfAQ0eH6Dmb3aEtkVcBrwEzP7xK/1MPB34KhylbwzOYzUse/lHU+zMLPXzGwSUGxC811SGOJji+RlGQts6sdnAD8ysw9d/odmdoOSm+XvAieb2ULPuw74lBTRMM8zpNDXlbThv6T7tWlTZUuwDjA7I6/e3V+3lKHAyVoyoNORwDMFo8CvNcbMppCMoOvNbIKnzyEFkFoiwqSZTQc+YfGgUEEQdCIqGTFYWYvCzwKcb2bNDQG8a07GIWY2Myc766QoW76cg6FyMeghBQLaQdJ+pGh6e5LeVPcyswX+dnQLUBgG3g7Y2sxelfQ14BDgKyQPhRMy1xoG/NDMpitFo7uC4h1QngmksLYjgLeBVyU9BtyV+UFvqewl8DfqVYpERBxHCvFcjp1Jz2SmpDHA/qR4Ca3JhSQvkNeWKfNtYLK3ZdUS0R03BV4vGAwZCu18rJAgqQuwB/CXShR0o2MP4NeVlC/CtcDDSlMpjwE3eOfbUl4njeL8L3B/Jr3c/8JWwA25tKLfAaUgW9NLxdLwKYjBAL169WLMmDHN0b3D0NDQULNtA+ix7mc13b5af37Vpt1NJTRRvrnc5X/HA739eHngckl9SMOym2fKP1d4cwe+AdzrQXgWSCoMz3YndZq3p5dqAFasUB9BY3jdfUluk/cALpXUF7h4KWS3NgOB4X48nDRF06qGgZn9U9KzeDTBHBdJOos0svC9IvnNpWCErkcKYPVIE+U38fJG+h6M8qmaYhRbyWUAZjZR0sbA3iTD9HlJXzezlyuUUyz9fOBe0tRBa3GyT79sTjLGiitiNoxkvFJXV2e16o++1n3t33nDiJpuX60/v2rT4Twf5ngJ6EuaAy5GYch2IYvaejLpbf0rpKmUbPS9jyu45nLABy00lr6Kv736vPdzwHOSHgGuAy5ZCtlL4PPwH0vaOPem3Rd4olQ9f6s+BDhQyU20gJ6SVjWzj1pDtwy/A+4oos+pZnZHTq+GIm0BmAlsUES/vqTRGXAj1EcAHiINr19WRq+ZzXgOc1l86L0HMKdwYmYNJCP1LkmfA/uRjJOm5BRkvZpN8NGkicDhmeSXgP8pod9U0r24N5PW1+sUKKwxOAD4i6RNrEhkyqA2mPt+LD4MStPR1xicT3qz/CI0rkw/vok6qwNvmtnnpOHYUv8hTwPflrSSjxJ8C1JnS5oCOMyvKUlfKXdBL3Miab75QUnr+pBtgT7Av1oiuwIuAi6TtLLL3BPYhbQYrRR7AJPM7Etm1tvMNiSNFix1PIo8ZvYKqeMq+Zaa4Xzgzz6tgKTuko6xFFb4BlLI6i6edwzQjZzR6GstTgT+X5F5+pYyBjhai4Z5jgVGux7fkLSmH68AbAn8q5gQNyDelLS7l+8B7EuaOsgzhMUXdf4N2FnS/oUEpV0hWwN/Bgb5KBmSepKmcZYIl20ptPU4ml77EQRBjVKJYbCyFt9SmA3W84AWxaW/vYyMXXMyDi1TtmLMbCRwOfCoUvz5CcBqTVS7AjhW0ouk+f6iowRm9jxwHyl2/ShgMjDPs48CvucyXgJKbTW8yMtMI00b7OYr8JcHLpZvuwO+Q1q93hzZlfIn4HnSPH098CvgQDMr5xN1IHB3Lu1OTwfolnnusyT9vJgQSV+TNIu0iPFqf0bFGAKsXyIvy5WkDvd5pW19T7JoYeMvSaM/0yRN92sO8JGZxTCzF0jPtSXb8upybT+MNLT+EfCiP7fupGkhgE2AJyRNBl4gdbrlpmSOAX7l34vHgXN9PU6+DYXve+F8Psl4/anSdsWpwAnAu2b2JnA08H+SXiEtprw2u1Axx2+AnytFBg2CoJOhIr+bgSOpu5k1+PDzWGBwYWV3EHR26urqrL6+vq3VqAq1Pkc9bOgoBp/Uv63VqBq1/vwkja9mILaOvsag2gyTtCWwEmk1eRgFQRB0eHquubCtVQjaMa1mGEjahzRvmSW7BXFpZJ9JGhrOUm4bY6tgZsVWy7cpkv5M2jGR5Y++b79NaKvns7RI2ga4KZf8acHxUxWv25PMFsoMe5jZ3GpeOwgAem5Y1PlmEAAxlRAEQQuR9BFQm3MJsBaZnSU1SLSvY1NnZqtWS3hMJQRB0FLqqznP2ZZIGlerbYNoX0dH0rhqyo9Vx0EQBEEQNBKGQRAEQRAEjYRhEARBSxnW1gpUkVpuG0T7OjpVbV8sPgyCIAiCoJEYMQiCIAiCoJEwDIKgkyOph6RH3JXyI4XYDkXKHetlpks6NpPeV9JkSTMkXVaIGSHpMEkvSfpc0vY5Wb/08vXuA6Ujtq+oXEn9JM3LuIBvacjuptq1r9+/GZJOL5K/oqRbPf9ZZaKDlrr/pWRK2shlzHCZK1SjTW3UtuslvZp5Xq0SxK4N2netpHeU3MVnZVX0/V8MM4tPfOLTiT+kYEqn+/HpwIVFyvQA/ul/1/TjNT3vOWAnUhTOUUB/T/8yUEcKMrV9RtaWwIukkOIbkaJjdumA7SsqF+gHjKjyM+vi921jYAW/n1vmypwAXOXHRwC3lrv/5WQCtwFH+PFVwI9qqG3XA4cuw/+3Vm+f530T2A6Y0tzvf/4TIwZBEBxIik6J/z2oSJl9gEfM7D0zex94BNhX0jrAamb2D0u/PDcW6pvZy2ZWzAHSgcBwM/vUzF4FZgA7tG6Tlrheq7evQrnVYgdghpn901JgtuEsGXAtq98dwB4+2lHq/heV6XV2dxlQ/bYus7ZVsQ3lqEb7MLOxwHtFrtfs72kYBkEQrG0pAiPAW8DaRcqsB/w7cz7L09bz43x6OUrJqhbVal85uV+X9KKkUZK2WtoGNEPfomXM7L+k6LA9y9Qtld4T+MBllLpWa7Is21ZgiKRJki6VtGJrNKIM1WhfOSr5/i9GeD4Mgk6ApEeBLxbJOjN7YmYmqcNtVWrr9uXkTgA2tBSZdT/gHmCz1r5m0Gr8ktRhrkDaBngaKfR4zVHp9z8MgyDoBJjZnqXyJL0taR0ze9OHzt8pUmw2ae68wPqktQOz/TibPrsJdWYDX2pmnbK0UfuKyjWzDzN6jZR0haS1zKw1ffdXcg8LZWZJ6gqsDsxtom6x9LnAGpK6+tvrUj+vJliWbSPzNv2ppOuAU1qhDeWoVvtKUcn3fzFiKiEIgvuAwir8Y4F7i5R5CNhb0pq+qnlv4CH/Uf1Q0k4+B3pMifr56x3hK683Ir1NP9caDSlzvWq0r6hcSV/0skjagfQ729pRM58HNvPdAiuQFqjdlyuT1e9Q4HFfJ1Hq/heV6XVGu4zF2lolllnbALyzxJ/ZQcBiq/qrQDXaV45Kvv+Ls6xWYsYnPvFpnx/S3OVjwHTgUaCHp28PXJMpdxxpsdMM4LuZ9O1JP6YzgctZ5DhtAGkO9FPgbVJHW6hzppevx1f5d8D2lZL7E+Al0urxfwA7V6ld+wHTXK8zPe03wAF+vBJwu7fnOWDjpu5/MZmevrHLmOEyV6zyM1uWbXscmOzP+Gag+zL4n6tG+24B3gQ+8/+775X7npb7hOfDIAiCIAgaiamEIAiCIAgaCcMgCIIgCIJGwjAIgiAIgqCRMAyCIAiCIGgkDIMgCIIgCBoJwyAIgiAIgkbCMAiCIAiCoJEwDIIgCIIgaOT/A/Ign6Jy5F+2AAAAAElFTkSuQmCC\n", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "text/plain": "
" }, "metadata": { "needs_background": "light" @@ -274,6 +251,13 @@ "plt.yticks(range(len(slabels)), slabels)\n", "plt.grid();" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -292,9 +276,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.5" + "version": "3.6.6" } }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file diff --git a/docs/examples/notebooks/ShapeFactor.ipynb b/docs/examples/notebooks/ShapeFactor.ipynb index 1eab8aad56..502c653a4a 100644 --- a/docs/examples/notebooks/ShapeFactor.ipynb +++ b/docs/examples/notebooks/ShapeFactor.ipynb @@ -181,8 +181,7 @@ "source": [ "print('initialization parameters: {}'.format(pdf.config.suggested_init()))\n", "\n", - "unconpars = pyhf.optimizer.unconstrained_bestfit(pyhf.infer.utils.loglambdav, data, pdf,\n", - " pdf.config.suggested_init(), pdf.config.suggested_bounds())\n", + "unconpars = pyhf.infer.mle(data, pdf)\n", "print('parameters post unconstrained fit: {}'.format(unconpars))" ] }, @@ -284,4 +283,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file diff --git a/docs/examples/notebooks/binderexample/StatisticalAnalysis.ipynb b/docs/examples/notebooks/binderexample/StatisticalAnalysis.ipynb index 6b8c5c09e1..aac70b0468 100644 --- a/docs/examples/notebooks/binderexample/StatisticalAnalysis.ipynb +++ b/docs/examples/notebooks/binderexample/StatisticalAnalysis.ipynb @@ -1072,8 +1072,7 @@ "nominal = pdf.config.suggested_init()\n", "background_only = pdf.config.suggested_init()\n", "background_only[pdf.config.poi_index] = 0.0\n", - "best_fit = pyhf.optimizer.unconstrained_bestfit(\n", - " pyhf.infer.utils.loglambdav, data, pdf, pdf.config.suggested_init(), pdf.config.suggested_bounds())" + "best_fit = pyhf.infer.mle.fit(data, pdf)" ] }, { @@ -9051,4 +9050,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file diff --git a/docs/examples/notebooks/multiBinPois.ipynb b/docs/examples/notebooks/multiBinPois.ipynb index ab43a30a88..7f7fd744b2 100644 --- a/docs/examples/notebooks/multiBinPois.ipynb +++ b/docs/examples/notebooks/multiBinPois.ipynb @@ -200,7 +200,7 @@ "\n", "print(init_pars)\n", "\n", - "bestfit_pars = optimizer.unconstrained_bestfit(pyhf.infer.utils.loglambdav, data, pdf, init_pars, par_bounds)\n", + "bestfit_pars = optimizer.infer.mle(data, pdf, init_pars, par_bounds)\n", "bestfit_cts = pdf.expected_data(bestfit_pars, include_auxdata = False)" ] }, @@ -371,4 +371,4 @@ }, "nbformat": 4, "nbformat_minor": 1 -} +} \ No newline at end of file From ba13a97cf0adb754928e870b8b2315648950cf88 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 13:55:58 +0100 Subject: [PATCH 42/72] adapt notebooks --- docs/examples/notebooks/pullplot.ipynb | 111 +++++++++++++------------ 1 file changed, 56 insertions(+), 55 deletions(-) diff --git a/docs/examples/notebooks/pullplot.ipynb b/docs/examples/notebooks/pullplot.ipynb index 7c4a922821..cb9d6c22a9 100644 --- a/docs/examples/notebooks/pullplot.ipynb +++ b/docs/examples/notebooks/pullplot.ipynb @@ -1,10 +1,6 @@ { "cells": [ { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], "source": [ "import pyhf\n", "import json\n", @@ -12,24 +8,26 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline" - ] + ], + "cell_type": "code", + "outputs": [], + "metadata": {}, + "execution_count": 1 }, { + "source": [ + "!curl -sL https://doi.org/10.17182/hepdata.89408.v1/r2 | tar -O -xzv RegionA/BkgOnly.json > lhood.json" + ], "cell_type": "code", - "execution_count": 2, - "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", - "text": [ - "RegionA/BkgOnly.json\r\n" - ] + "name": "stdout", + "text": "x RegionA/BkgOnly.json\n" } ], - "source": [ - "!curl -sL https://doi.org/10.17182/hepdata.89408.v1/r2 | tar -O -xzv RegionA/BkgOnly.json > lhood.json" - ] + "metadata": {}, + "execution_count": 2 }, { "cell_type": "markdown", @@ -39,10 +37,6 @@ ] }, { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], "source": [ "def make_model(channel_list):\n", " spec = json.load(open(\"lhood.json\"))\n", @@ -62,27 +56,28 @@ " return w, m, d\n", "\n", "\n", - "def fitresults():\n", - " w, m, d = make_model([\"CRtt_meff\"])\n", - " d = w.data(m)\n", + "def fitresults(constraints=None):\n", + " _, model, data = make_model([\"CRtt_meff\"])\n", "\n", " pyhf.set_backend(\"numpy\", pyhf.optimize.minuit_optimizer(verbose=True))\n", - " minuit = pyhf.optimizer._make_minuit(\n", - " pyhf.infer.utils.loglambdav,\n", - " d,\n", - " m,\n", - " m.config.suggested_init(),\n", - " m.config.suggested_bounds(),\n", + " result = pyhf.infer.mle.fit(\n", + " data,\n", + " model,\n", + " fixed_vals = constraints,\n", + " return_uncertainties = True\n", " )\n", - " result = minuit.migrad(ncall=100000)\n", - " bestfit = pyhf.tensorlib.astensor([x[1] for x in minuit.values.items()])\n", - " errors = pyhf.tensorlib.astensor([x[1] for x in minuit.errors.items()])\n", + " bestfit = result[:,0]\n", + " errors = result[:,1]\n", + " return model, data, bestfit, errors\n", "\n", - " return m, d, bestfit, errors\n", "\n", "\n", "m, data, bestfit, errors = fitresults()" - ] + ], + "cell_type": "code", + "outputs": [], + "metadata": {}, + "execution_count": 3 }, { "cell_type": "markdown", @@ -92,10 +87,6 @@ ] }, { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], "source": [ "pulls = pyhf.tensorlib.concatenate(\n", " [\n", @@ -127,26 +118,20 @@ "labels = labels[order]\n", "pulls = pulls[order]\n", "pullerr = pullerr[order]" - ] + ], + "cell_type": "code", + "outputs": [], + "metadata": {}, + "execution_count": 4 }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKgAAAI5CAYAAACFNwL5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdfbwcZXnw8d8lIAoqKqCoqBEL1jeKGl/Atq4FFSwvCqhY0YLSWMUqViiifZBqVXwMIr6ggkJEWg0VLEQRJGroo6AQNEIQg5iKgEQJalDiS9Dr+WNmk81md8++zMnsOfv7fj77OXvP3nPNvXOuMzN77cycyEwkSZIkSZKkutyr7gFIkiRJkiRpslmgkiRJkiRJUq0sUEmSJEmSJKlWFqgkSZIkSZJUKwtUkiRJkiRJqpUFKkmSJEmSJNXKApUkSdIYiYiMiAVt034cEUsqXs6cclknVRlXkiRpGBaoJEmSBhQRjbK40/r4TURcExFviogtahxb+7h+FxE/jIgPRMSDK1zOAyPipIhoVBVTkiRNri3rHoAkSdIM9lngYiCAhwNHAB8EngjMq29YLANOKZ8/GHgh8GbgeRHxtMz8QwXLeCDwjvL5kgriSZKkCWaBSpIkaXjfycxzm42I+BhwA3BURPyfzPxZTeO6rXVcwIciYhGwP3AQ8F/1DEuSJKkzL/GTJEmqSGbeBVxJcUbVLgARsSAislP/TvebmkaXlj//rFeniNgyIo6PiO+XlwfeGRFfiIgnt/RpAP9bNt/Rcjnhj6dl5JIkadbzDCpJkqSKRESwoQC0us6xdLBr+XOqcf0H8FLgMuBjwE7A0cCVEfFXmfldirPE3gycCnwBuKCc9zdVD1qSJE0GC1SSJEnD2yYidqA4Y+phwD8BfwF8KzN/WOO4tirHBfAgikv7XgesAS7sNlNEPI+iOHUecFhmZjn9POAa4EPAX2XmzyLivykKVNe2XU4oSZI0MAtUkiRJw/u38tH0J+Ai6r1BOsDzgTvapn0PmJeZP+8x34vLn+9uFqcAMvN75T2sXhQRO2Zme2xJkqSRWKCSJEka3hkUNxxP4G7gxsz8Rb1DAuDbwL+Wz38P3JyZP+ljvsdQFNlu6PDa9cCLyj4WqCRJUqUsUEmSJA3vh5m5eIo+3W6QPp3HYav7GJckSdLY8L/4SZIkTa9fAETEg9um71LDWKaykuL48PEdXntC+bP53/s6Ft4kSZKGYYFKkiRpet1Y/tynbfpbNvdA+vDf5c8Tyv9ICEBEPAk4EPhGy/2nmv+xr73wJkmSNDAv8ZMkSZpenwXeA5wREX9OcUbVvsAOPeeqQWZeVv7HvsOAB0XEF4GdgKOB3wFvbOl7Z0TcBBwWET8CfgbcnZmLahi6JEma4TyDSpIkaRpl5l3ACyluMv424CTgpxRFqnH0CuCtwKOBU4DXA5cDe2bmdzv0/SFFAe6zwIc34zglSdIsEi3/QViSJEmSJEna7DyDSpIkSZIkSbWyQCVJkiRJkqRaWaCSJEmSJElSrSxQSZIkSZIkqVYWqCRJkiRJklSrLesewDjaYYcdcs6cOXUPQ5IkSZIkada45pprVmfmjp1es0DVwZw5c1i6dGndw5AkSZIkSZo1IuLmbq95iZ8kSZIkSZJqZYFKkiRJkiRJtbJAJUmSJEmSpFpZoJIkSZIkSVKtLFBJkiRJkiSpVhaoJEmSJEmSVCsLVJIkSZIkSarVjC5QRcQjI+LrEfH9iLg+It7UoU9ExIci4qaIuDYinlrHWCVJkiRJktTZlnUPYET3AG/JzO9ExP2BayLissz8fkuf/YBdy8czgY+VPyVJkiRJkjQGZvQZVJl5e2Z+p3z+a+AG4BFt3Q4CzsnCt4AHRsTDesVdsWIFCxYsAGDdunU0Gg3OPfdcANauXUuj0WDhwoUArFmzhkajwQUXXADA6tWraTQaLFq0CIBVq1bRaDS45JJLALjllltoNBosXrwYgJUrV9JoNLj88svXL7vRaHDFFVcAsHz5chqNBldffTUAy5Yto9FosGzZMgCuvvpqGo0Gy5cvB+CKK66g0WiwYsUKAC6//HIajQYrV64EYPHixTQaDW655RYALrnkEhqNBqtWrQJg0aJFNBoNVq9eDcAFF1xAo9FgzZo1ACxcuJBGo8HatWsBOPfcc2k0Gqxbtw6ABQsW0Gg01q/LM888k3322Wd9+/TTT2e//fZb3z7ttNM48MAD17fnz5/PIYccsr598sknc9hhh61vv+td7+Lwww9f3z7xxBM58sgj17dPOOEE5s2bt7597LHHcvTRR69vH3PMMRxzzDHr20cffTTHHnvs+va8efM44YQT1rePPPJITjzxxPXtww8/nHe9613r24cddhgnn3zy+vYhhxzC/Pnz17cPPPBATjvttPXt/fbbj9NPP319e5999uHMM89c3240GuaeuQeYe+aeuQfmnrln7pl7BXPP3DP3Cuaeudc0k3Ovl5l+BtV6ETEHeArw7baXHgHc0tK+tZx2e9v884B5AFtvDXBk+Wi6HHhlW/uwtjYjtBtt7We3tZ/R1n5KW/vJbe0/b2s/tq39qLZ2e81ux7b2A9va27a1793WjorbC9va/9HWXtDWPrOtfXpb+7S29ilt7ZPb2u9qa5/Y8nwhcEJL+wLguJb2IuCYlvYlwNEt7a9Spl7pcsy9Vubexsy9Dcy9jZl7/bcbbW1zb2Pm3sZtc28Dc28Dc29j5t7GzL0NGm1tc29jk5x7m4rM7NlhJoiI+1G823dn5gVtr30RODkzv1G2vwocn5lLu8WbOzdyaddXJUmSJEmSNKgIrsnMuZ1eu9fmHkzVImIr4HzgP9qLU6XbgEe2tHcup0mSJEmSJGkMzOgCVUQE8Cnghsz8QJduFwGvKv+b37OANZl5e5e+kiRJkiRJ2sxm+j2onk1xwex1EbGsnPY2ygtPM/PjwMXAC4GbgLVMddGjJEmSJEmSNqsZXaAq7yvVfpex9j7JxnfqkiRJkiRJ0hiZ0Zf4SZIkSZIkaeazQCVJkiRJkqRaWaCSJEmSJElSrSxQSZIkSZIkqVYWqCRJkiRJklQrC1SSJEmSJEmqlQUqSZIkSZIk1coClSRJkiRJkmplgUqSJEmSJEm1skAlSZIkSZKkWlmgkiRJkiRJUq0sUEmSJEmSJKlWFqgkSZIkSZJUKwtUkiRJkiRJqpUFKkmSJEmSJNXKApUkSZIkSZJqZYFKkiRJkiRJtbJAJUmSJEmSpFpZoJIkSZIkSVKtLFBJkiRJkiSpVhaoJEmSJEmSVKsZXaCKiLMi4ucRsbzL642IWBMRy8rHiZt7jJIkSZIkSepty7oHMKIFwEeAc3r0+X+Zuf/mGY4kSZIkSZIGNaPPoMrM/wF+Ufc4JEmSJEmSNLwZXaDq054R8b2I+HJEPLHuwUiSJEmSJGljM/0Sv6l8B3h0Zv4mIl4I/Dewa6eOETEPmAfwqEdtvgFKkiRJkiRNull9BlVm3pWZvymfXwxsFRE7dOl7RmbOzcy5O+64WYcpSZIkSZI00WZ1gSoidoqIKJ8/g+L93lnvqCRJkiRJktRqRl/iFxGfBRrADhFxK/AOYCuAzPw4cCjwuoi4B/gtcFhmZk3DlSRJkiRJUgczukCVmS+f4vWPAB/ZTMORJEmSJEmaFo1G8XPJkjpHMX1m9SV+kiRJkiRJGn8WqCRJkiRJklQrC1SSJEmSJEmqlQUqSZIkSZIk1coClSRJkiRJkmplgUqSJEmSJGkaNBob/vueerNAJUmSJEmSpFpZoJIkSZIkSVKtLFBJkiRJkiSpVhaoJEmSJEmSVCsLVJIkSZIkSaqVBSpJkiRJkiTVygKVJEmSJEmSamWBSpIkSZIkSbWyQCVJkiRJkqRaWaCSJEmSJElSrSxQSZIkSZIkqVYWqCRJkiRJklQrC1SSJEmSJEmqlQUqSZIkSZIk1coClSRJkiRJkmplgUqSJEmSJEm1mvEFqog4KyJ+HhHLu7weEfGhiLgpIq6NiKdu7jFKkiRJktSvRqN4SJNkxheogAXAvj1e3w/YtXzMAz62GcYkSZIkSZKkPs34AlVm/g/wix5dDgLOycK3gAdGxMM2z+gkSZIkSZI0lS3rHsBm8Ajglpb2reW027vNsGLF1KdT7r8/HHts8bzRgCOOKB6rV8Ohh049qPb+b3kLHHBAsezXvnbq+dv7v+c9sNdecMUV8La3TT1/e/9PfAIe9zhYtAhOOWXq+dv7f/7zsMMOsGBB8ZhKe/8lS4rp8+fDF7849fyt/a+8Es4/v2ifcELR7mX77Tfuf+edcMYZRXvePLjxxt7z77bbxv233x7e+96ifcghRbxe9txz4/577rlxLk3F3Oude8uWFf322KPz/Obehv7mnts9MPfMvannN/c29Df3zD0w94bJvbVrYZttirjmXu/5W3PvxhuLGObezN/u3XJLf+t/qtxrftbpFGumb/cAIjP76znGImIO8MXMfFKH174InJyZ3yjbXwWOz8ylbf3mUVwCCFvwNHaeYqF3AQ8AjgTOBvYAngLcDZzXx6Bb+38I2A54PbAaWNTH/HsBj2vpvzfwKODjwC+BnaaYv9n/J8BXgQOAHYAVwBUt/VaVP9vjtfd/KbAt8F1gWR/jb+9/ZDn9m8AUfzgb2Y2i5Piysr2YjcuRnWzT1n8ZsH05houAKf7w2B44sHx+URlvn7K9EFhZPu/2O3hkW/+dgWeX7bPb+nZa/7u19R8l985j01yaSrfca+bSVPrNvW6myr1uOds0SO51itXaf5DcWwVsAfxLS/+1bJxLg+TefIpzYP+5bC8s4/UySO510k/u9Vr/g+Zee6xxyr0LgIcAr2HzbfeGzT3YdLs3Su512u6NQ+71Mtu3e1MZ59y7vnzebZs9aO61bzdGyb1V5fLe1NJ/2Nz7FPBz4GBGz72vAr8Htu5j/n5yr9d2e9Dca481Su6tKuMcyei59wHgT0D5QWnk7d7/Bf5I7+PtfnOv2/qve7v3W+C+FDlQxXZvHbBVOY5Rt3uXlH16rf9+c6/b+h9mu9eMtQvV7HPPLvvuwezd53Za/8Puc5uxXsH47XPPZkP9YCpT5V6vbfZMOd67mWsyc26nEJNQoPoEsCQzP1u2VwCNzOx6BlU8PJKpqrvNFXxkz179GddY0xGvKpOyzsY11jgb13U2znlWpXFeZ1Ua57GNK9fZ7DHOf+fjOrZxjVV1vEmIVXW8SYhVdbxJiDUd8cbROK//Kk3K++zXSd0LVDP+HlR9uAh4Vfnf/J4FrOlVnNI0Opv+qvaSpPpNyjZ7Ut6nJEnSmJvx96CKiM8CDWCHiLgVeAfFCaRk5seBi4EXAjdRnJQ2k2uNkqTZZjZ8E6bxZ55Jkqrg/kTTaMYXqDLz5VO8nsDRm2k40mRwxyRJm3LbKEkaR+6fNENMwiV+ksadl9jUy/U/e/i7lCRJ0gxlgUqSNBks3swe/i4lSZJmHQtUkiRJkiRJqpUFKkmSJEmSJNXKApUkSdI48lJGSZI0QSxQSZIkSZIkqVYWqCRJkiRJkqp2LXArcDNwatlWVxaoJEmSJEmSqnQtsAj4Y9leU7YtUnVlgUqSJEmSJKmpivtAfhVY1zZtXTldHVmgkiRJkiRJqtKaAafLApUkSZIkSVKlthtwuixQSZIkSZIkVWpvYKu2aVuV09XRlnUPQJIkSZIkaVbZvfx5IcWN0rejKE7t3nWOma15z64jhw8xcoEqIu4HPIlidf8aWJmZq0aNK0mSJEmSNGPtDlxTPh+hcDMtKigoVW3oAlVEbA18EDgCuHfba6so7k2/ELg4M3OEMUqSJEmSJGkWG+UMqvnAa4FLgSXAH4CdgOOA+wCHA68AfhARb8xM/5miJEmSJEmSNjFKgeplwFmZeVRzQkRsT1Ggegmwsvz5OuDSiDguM08dZbCSJEmSJEmafUb5L373Ba7s9mJm/jgz3w88DjgVmB8RzxtheZIkSZIkSZqFRilQLQWeO1WnzFyXmcdR3Lv+7SMsT5IkSZIkSbPQKAWqk4G/i4g399n/YuBpIyxPkiRJkiRJs9DQBarMvJTiflPzI+KqiDgcuH+PWZ4DrB12eZIkSZIkSZqdRrlJOpl5SkR8DzgNOAe4B0jg9RHxdODXwAOAFwB/XfaTJEmSJEmS1hupQAWQmYsj4knAvhT/2a8BHFw+mtYCHwaOH3V57SJiX4rC1xbAJzPz5LbXjwDeD9xWTvpIZn6y6nFIkiRJkiRpOCMXqAAyM4Evlw8iYntgF+B+wF3A9zPztxGxdRXLa4qILYCPAs8DbgWujoiLMvP7bV0XZuYbqly2JEmSJEmSqlFJgapdZt4J3NlsR8TTIuI1FGdYbV/hop4B3JSZK8vlfA44CGgvUEmSJEmSJGlMjfJf/HqKiAdHxBsjYhlwFfCPwAMrXswjgFta2reW09odEhHXRsTnI+KRFY9BkiRJkiRJI6i8QBURL4iIhRT3fPog8BhgAfCfVS+rT4uAOZm5O3AZ8OlOnSJiXkQsjYil/q9BSZIkSZKkzaeSAlVEzImId0bEzcDFFDdIXwK8AnhoZr4GuK6KZbW5DWg9I2pnNtwMHSguN8zM35fNTwJP6xQoM8/IzLmZOZdtpmGkkiRJkiRJ6mike1BFxCuAVwPPoSh2LQc+BPxHZq4afXhTuhrYNSIeQ1GYOgz4u7YxPiwzby+bBwI3bIZxSZIkSZIkqU+j3iT9M8DvgNOAz2TmstGH1L/MvCci3gBcCmwBnJWZ10fEO4GlmXkR8MaIOBC4B/gFcMTmHKMkSZIkSZJ6G7VA9XvgPhRnJv0qIn6ZmTePPqz+ZebFFJcVtk47seX5CcAJm3NMkiRJkiRJ6t+o96B6GPBG4NfAvwErI2JJRLw6Iu4/8ugkSZIkSZI0641UoMrMX2XmRzLzqcBc4OPA7hQ3I18VEf8ZEftGROX/LVCSJEmSJEmzQ2WFo8z8TmYeTXFW1eHAt4CXAV8CbgVeWtWyJEmSJEmSNHtUfmZTZv4+M/8zM/cGHgu8G1gHPKXqZUmSJEmSJGnmm9ZL7zLzx+UNy+cALwTOn87lSZIkSZIkzTrXUlybdjNwatmeZUYqUEXELRHx4YjYOyK26NYvC5dkppf5SZIkSZIk9etaYBHwx7K9pmzPsiLVqGdQXQi8CLgM+HlEfCYiXhwR24w+NEmSJEmSpAn3VYobJ7VaV06fRUb9L35vyMxHAs8CzqD4T37nA3dExIURcUREbF/BOCVJkiRJkibPmgGnz1CV3IMqM6/KzBMy8/HAE4B/B3YCPgWsioivR8QbI+JRVSxPkiRJkiRpImw34PQZajr+i98PMvO9mflM4FHAmymulJwP/G9EfCci9q16uZIkSZIkSbPO3sBWbdO2KqfPItP9X/xuy8yPZOY+wEOBI4EfA0+azuVKkiRJkiTNCrsDBwDNf023XdnevbYRTYstN9eCMvOXwDnlQ5IkSZIkSf3YHbimfH5knQOZPtN6BpUkSZIkSZI0FQtUkiRJkiRJqtVmu8RPkiRJkiRposzSy/GmQ6UFqojYDXgi8BAggTuA5Zn5wyqXI0mSJEmSpNlj5AJVRDwe+EfgUGCn5uTyZ5Z9fgacB3wiM28YdZmSJEmSJEmaPYYuUEXEY4H3AS8Gfgv8P+ATwI+AOymKVA8G/gx4FnAU8E8RcQFwfGauHG3okiRJkiRJmg1GOYPq+8B1wBHABZl5d6/OEbEtxVlWbyrnvc8Iy5YkSZIkSdIsMUqB6iWZeVG/ncsC1qeBT0fEQSMsV5IkSZKk2ela4Fbgj8CpwN7A7rWOSNos7jXsjIMUpzrMe+Gw80qSJkDzwOxmigOza+sdjiRJ0mZxLbCIojgFsKZseyykCVDFTdLvBzwJ2A74NbAyM1eNGleSNMNU9W1ftwMzhownSZI0U3wVWNc2bV053eMgzXJ9n0EVEQ9sa28dER8D7gC+CVxMcaP02yLitog4JyL+NiKiQ7jKRMS+EbEiIm6KiLd2eH3riFhYvv7tiJgz8kL9Zl/SIKreZozjNqjKb/t6HZhJk2Ic/86rNgnvUZIGtWbA6TNVlfsA9yezRl8Fqoj4e+CGtsnzgdcCS4C3AceW04LiBuiHAxcByyNi74rG2z6uLYCPAvsBTwBeHhFPaOv2GuCXmflnFOn6vpEWWvUpl+P8hzmuf+iTss7GNdakqGqdTcc2YxxP+66yqDTuB2bj+rc5rrHGeWzjHGu2H2tMx7ZsHN/nOMca57GNa6xxHtu4xhrnsY1rrO0GnD4TVbkPGNdjYw2lZ4EqInaLiCXAvwOvanv5ZcBZmblfZr4vM08F/m/52kuAXYC3AvcFLo2IN1c68sIzgJsyc2Vm/gH4HNB+A/aDKG7ODvB5YO+Rzuqq8kPYOP9hjuvB8aSss3GNNSnG+WygcT27qMqi0jgfmI3r3+a4xhrnsY1rLJiMY42qt2Xj+j7HNdY4j21cY43z2MY11jiPbVxjQXGLhK3apm1VTp8tqtwHjOuxsYYSmdn9xYh3AG8G9sjMH7e99mvgmMz8VMu07Sku+dsnM79WTtsKeA/wz8C+mXlZZYOPOLSMeVTZfiXwzMx8Q0uf5WWfW8v2j8o+q7vG3TqSh7VNfCJFOeykHgM6CbgbOK/Da0+nuFPXGuCCclrzXi3ttgB2bpv218BjgduBSzrMs7pcdrdY+wIPA34E/E+HfgcAOwArgCt6jO2+wEM6TH8psC3wXWBZ22t3A78C7mmZFsD25TwAR5Y/vwnc2Db/VhTn4wG8F/h9h+VvR5Gpi4Fb2l57AHBI+fzLQPMOaf2u/50oztEDOB+4q63/I4F9KApvnT6Mbw2cUD4/l003oLsBzy6fnz3g2AD2AJ5C99z7OfDbHrH2Ah5HkUOLOvTrlHvNdbgTxc7yUcBP6Lwj6Cf3FpVjvG+H1w+m+P0uB67u8Hpr7n2zfB/N9/cgYB5wb+Aq4PoO83fKvX7X/zYUpXronnvXdYjT9FTgwPL5RcCdba93yr2be8R7dFt7F+A55fNuuXd/4EKK99tcZ82/y+Z27w/Af3RYXmvufYDO62w74NVs2O616pZ7d1Osi9bdU/s2AwbPvda8hU23e+065d4gf5uvoHfu/YrO24wtgMewYbt3ObCyrU977l3ZZVzbAX/OhvfetD3dc6+f99jc7gEsBNa29W3NvX9n4+1/69jezIbtXqtuudfv+u+0z221F8WNCbqt/7+j9z63Pfe6jWtbihxrN1XuTfV33mufCxvn3qVdxrYdxTrutc9tz71+1n+3fW5TM/dO6hCnqflar30ubJx7/eZGp31uqydS7A+65cb+9N7ntudet3Hdj2JdtOt1vNfPexzkeO+8LvG2A57H1Pvc1tzrd/33c7zX7XhqS+Bfy+f9Hu91G9dWwMPbpvVzvHddl7FtQfG7m2qf25p73cb2AIp9cbtex3v9rP9+j/fmA7/p8Pq2wHEMfrzXb270c7x3Bt3X//EMdrzXbVxbs+E4oWmq472fsunvuzmunem9z4XOuXc3G45ptwb+luL+U1Ptc7vlXvvfW6tBjvfOY9PjqX72ue25N8jx7FTHe1PFGuZ4Dza8zzfS/z63388aTb32udA591rXf7/7XOice78AHlyOcZB9blN77jX/Npq50W2fezPXZOZcOpjqEr/PUvyq/ici/qbttaXAc6eYn8xcl5nHUXwEevtU/esSEfMiYmlELO24sWp6QJfpnT5YT6Xbcnotv5tOxalhY/War1OhYyq/ZNMPJ1lOH1Sn4hQMd5ZGleu/1xi6jbmXKsfW7Xc27Pu8m+I9/Z5i5/6jIeNU7VY23uj+sWwvHyJWleu/21k/WwwRq9d8w/zLi9vZ+Bu/5jrrtj3p5UEURaRWWzDct33bUuxQm3uo5ge5bbvOMbX2vB3mPUK1udFtmzFMrG7zjMO2sVNxCuof2+ZY/8Pm2f27TB9muzGuudFt23jvIWL1GsO45kanAsCwsao+1qs7N7otv9u2pJduy+9UTOjH5siN9g+Io8QaZlzdcnNS9pvDHLd3y6dh/zahOObZunw8ndFujn47G65kGeUYCKo7nuq2PxtmP3e/CmM1tb7Pj+OVJ5tRzzOo1neKOAp4d2Y+tGXaCyjqdG8pL+/reAZVW4xTM7PbYdfgg4/YEzgpM19Qtk8AyMz3tvS5tOxzZURsSVFX3DF7vPF4eCSv7fJi8xTO1g3RVhSV2UE3HN2+IWp+q1xXrKrjnTTka51Myjob11hV5n9rzOYZPNsx/H9+m5R1Nq7boObYqvhdNjW/aTmyZ6/+xjWO62wSYlUdbxJiwWTkbNXbxnF9n+Maq+p4kxCr6niTEKvqeJMQq1UVx0FVbmsnIdZ0xKtaVcfHVcca5HPAScOfQQVAZn6S4ibkrdMupTjRc35EXBURh9P9Oz8oTv5qPylsVFcDu0bEYyLi3sBhFCevtboI+Pvy+aHA13oVp6a0O0VyNiuy2zF8slZ5fXHV1ypXGa/K+8lMyjob11jjfM+Qbt+qDfNNcJXrrMptRtXxqlxnlGPYmeJ06jcPOabpUGXejuvf5rjGqjreJMSCyTjWqHrbOK7vc1xjVR1vEmJVHW8SYlUdbxJiVW1c7/VU5T6g6v3JpNzTqup/ElDRZ7q+LwrJzPYrFsnMUyLie8BpwDkUJ98m8PqIeDrwa4qL4l5AcWXzaYMPseeY7omIN1DcYWELipu2Xx8R7wSWZuZFwKeAz0TETRRXWR428oJ3B64pn49SbWz+0VRxxkGVsaqOtzedq9DDHtBWNa5xXmfjGqvqgkavHcCg49uuyziGKYROR25Usc2oOl6V62ycVZm34/q3Oa6xxnls4xqrNeYkHGtUtW0c1/c5rrHGeWzjGmucxzauscZ5bOMaq2pVHgNNxxebVe4DqopV9fscR90KSjBc3lb4mW6Yu5ZsJDMXR8STKG6N9zKgQXGrsYNbuq0FPkxx+7pKZebFFLc6bZ12Ysvz31H8V8HxNK5/mFXGG/cD2nFcZ+Maq+qCRtVnPVVVCIXqc2McVb3OxlXVeTuOf5vjHKvqeJMQq2q+T2NtjniTEKvqeJMQq+p4kxCrSlUeA03KF5uT8D6rPEkAKv1M1/j2yTcAACAASURBVNclflPJwpcz84jMnAPsCDyT4mPO0ynu+XRMZg57S0LNdLsznpf+aDBVn8Jc5eWfVZ/eOwkmZZ2N86n3kiRJ02VSLmWs0iS8z6rPEqvwM93IZ1B1Ul4OuMklgZJmuKrPhvOsp/pNwjob51PvJUmSpsukXMpYpUl4n1WfJVbhZ7ppKVBJmsXG9Z4hUi+TUIiTJElqNwmXMlZttr/P6ThJACr5TGeBSlK9ZvsOQJIkSZLGxRj/cxcLVJIkSZIkSZNiTE8SqOQm6ZIkSZIkSdKwpqVAFREPjIhdpiO2JEmSJEmSZpfpOoPqTcAPpym2JEmSJEmSZhEv8ZMkSZIkSVKtLFBJkiRJkiSpVhaoJEmSJEmSVCsLVJIkSZIkSaqVBSpJkiRJkiTVygKVJEmSJEmSamWBSpIkSZIkSbWyQCVJkiRJkqRaWaCSJEmSJElSraarQBXlQ5IkSZIkSeppugpUpwKPmabYkiRJkiRJmkW2nI6gmbkGWDMdsSVJkiRJkjS7eA8qSZIkSZIk1coClSRJkiRJkmo1YwtUEfHgiLgsIn5Y/nxQl35/jIhl5eOizT1OSZIkSZIk9TZygSoi7hcRz4qIF0TEXhGxUxUD68Nbga9m5q7AV8t2J7/NzD3Kx4GbaWySJEmSJEnq09A3SY+IrYEPAkcA9257bRVF0WghcHFm5ghj7OYgoFE+/zSwBDh+GpYjSZIkSZKkaTTKGVTzgddSFIbeBhxbTgvgPsDhwEXA8ojYe7RhdvTQzLy9fL4KeGiXfveJiKUR8a2IeFG3YBExr+y3lLWVj1WSJEmSJEldDH0GFfAy4KzMPKo5ISK2B44DXgKsLH++Drg0Io7LzFMHWUBELAY6XTL49tZGZmZEdDtL69GZeVtE7AJ8LSKuy8wftXfKzDOAMwDi4V1jSZIkSZIkqWKjFKjuC1zZ7cXM/DHw/oj4IPAeYH5ELM/My/pdQGbu0+21iPhZRDwsM2+PiIcBP+8S47by58qIWAI8BdikQCVJkiRJkqR6jHKJ31LguVN1ysx1mXkccCFtZz6N6CLg78vnf1/G30hEPKi8VxYRsQPwbOD7FY5BkiRJkiRJIxqlQHUy8HcR8eY++18MPG2E5XVa/vMi4ofAPmWbiJgbEZ8s+zweWBoR3wO+DpycmRaoJEmSJEmSxsjQl/hl5qURcRzFpXsvBz4EfKPHLM+B6m4/npl3ApvcfD0zlwJHlc+vAJ5c1TIlSZIkSZJUvVHuQUVmnlKenXQacA5wD5DA6yPi6cCvgQcALwD+uuwnSZIkSZIkrTdSgQogMxdHxJOAfSn+s18DOLh8NK0FPgwcP+ryJEmSJEmSNLuMXKACyMwEvlw+iIjtgV2A+wF3Ad/PzN9WsSxJkiRJkiTNLpUUqNqV94e6czpiS5IkSZIkaXYZ+r/4RcQmNygfYN59hp1XkiRJkiRJs8vQBSrgkoj4WkTsHxFbTNU5IraKiBdHxOXAxSMsV5IkSZIkSbPIKJf4PQX4AHARcEdELAauAn4E/AII4MHArsCzgL2BBwJfAfYYYbmSJEmSJEmaRYYuUGXmcuD5EbEn8HrgIODlQLZ1DYobpV8AfCwzrx52mZIkSZIkSZp9Rr5JemZeCVxZXub3NOAJwI4Uhao7gOXAdzPzT6MuS5IkSZIkSbNPZf/FLzP/SHGJ31VVxZQkSZIkSdLsN8pN0iVJkiRJkqSRWaCSJEmSJElSrSxQSZIkSZIkqVYWqCRJkiRJklSrym6SLkmSJEmSpGlyZN0DmF6eQSVJkiRJkqRaeQaVJEnSOJrl35JKkiS18gwqSZIkSZIk1cozqCRJkiRJkjS8Cs78tkAlSZJmFi99kyRJGs0YHk9ZoJIkjacx3GmOPdeZJEnS6DymqoUFKkmSpCp4MCtJqor7FE2gGXuT9Ih4SURcHxF/ioi5PfrtGxErIuKmiHjr5hyjJElTOhIPQiVJkjTxZvIZVMuBg4FPdOsQEVsAHwWeB9wKXB0RF2Xm9zfPECVpwlhomT0m5Xc5Ke9TkiRpzM3YAlVm3gAQEb26PQO4KTNXln0/BxwE9C5Q3QmcPcUA7gIeUD4/G9gDeApwN3DeFPPS1n8VsF05fTWwqI/59wIe19J/b+BRwO+BX/Yx/mb/nwBfBQ4AdgBWAFe09FtV/myP197/pcC2wHeBZV2W2RqrvX/zA8I3gRunGHurb1KUHl9WthcDt0wxzzZt/e8Eti/bF5XtXrYHDmzpvw2wT9leSPd11vTItv47A8/uMk+nWLu19e8395qxvtvWvz2XprJX+XNdufz2XJpKp9wD+C1T5y1MnXtTrf9Bcq9TrNb+g+TeKmCLlvZiYC0b59IguXcnG58Du7CM10uv3FvF1Ot/2Nxrau8/TO512u71m3u/B7Zm6u1eN639VwEPKaf32u61GnW7N2zuwabbvVFyr9N2r5/ca45/qu1eJzM99/rd53YzzD631Usp1v93KdbfqLnXbFeRe03d8mDQ3Gvfbg+yz223qlxe6xiHzb0/AT+n+B2OmntQbM/6+dvpJ/d67TcHzb32WKNs91YBO7X0H2W790uK30HTqNu9O4A/0vt30G/udVv/w2z3VvXoP+h277fAfaluu7cO2IpqtntTHetB/7nXLdYw+9xmrIXUv89tz72mKva5U63/YXKvNdaw+9zmuH5C/fvcST7eG3afW5qxBao+PYKNf423As/s1DEi5gHzALbeGp41p3fg/feHY48tnje+Dke8CI44AlavhkOvmnpg7f3f8hY44ABYsQJee93U87/l5Rv3f89rYK+94IrnwdveNvX86/tfAW/7EXziDfC4x8GiRXDKT1s6zuk8f3v/z/8L7LADLFgAC37VeZ5l5fQ95mzaf8k7itfmz4cv/mHq8S9ZsqH/lVfC+eX8J/yuaPey/fYb97/z8XDGGUV73m1w4xQbjt12gzPesaH/9tvDe8v2IdfCnQ/pPi/Anntu3H/PPTfOpY3M2XT+/Z8/ZO6VsTbJvZcPnnun/BTWroVtttk0l6bSKfdeex3ceWexLqcyVe615lknA+Vehxit/QfKvTkdcu/OjXNp5NybYqfTLfcaXy/WW7d11jR07pWqyL2O270+c++uu+ABDyjm67nd62KT3Pv81Nu9ViNv94bNPcY396DDdq+DmZ57fe9zuxhmn9tqonJvzsbNkXJvToXHe0fDoYdWlHufKnOpquO9Od3nHzj32mKNlHtzKj7eG9ft3pzO8w+13WuJNep2r3lc1jxOG3W71zxubB5HTmWzbffmdJ5/qO1eGWscc6+fbX3TVLk31bF2bfvccjzuczf0H4fc67Tdu/zm7jEiM3svpUYRsZgN3520entmXlj2WQIcm5lLO8x/KLBvZh5Vtl8JPDMz39BruXPnRi7dJJpG1WgUP5sHG5q5qv5dVhnPPJMkSRovHp/Vy2NtjZMIrsnMjvcRH+szqDJzn6l79XQbxYlmTTuX01QDN2Kzh79LSZIk9ctjR0n9GOsCVQWuBnaNiMdQFKYOA/6u3iFJkiRJkrR5VFkgtNio6XSvqbuMp4h4cUTcCuwJfCkiLi2nPzwiLgbIzHuANwCXAjcA52Xm9XWNWVJnS5a4s5MkSZKkSTZjz6DKzC8AX+gw/afAC1vaFwMXb8ahSZIkSZIkaQAztkAlSZ14JpYkSZIkzTwz9hI/SZIkSZIkzQ4WqCRJkiRJklQrC1SSJEmSJEmqlQUqSZIkSZIk1coClSRJkiRJkmplgUqSJEmSJEm1skAlSZIkSZKkWlmgkiRJkiRJUq0sUEmSJEmSJKlWFqgkSZIkSZJUKwtUkiRJkiRJqpUFKkmSJEmSJNXKApUkSZIkSZJqZYFKkiRJkiRJtbJAJUmSJEmSpFpZoJIkSZIkSVKtLFBJkiRJkiSpVhaoJEmSJEmSVCsLVJIkSZIkSaqVBSpJkiRJkiTVygKVJEmSJEmSajVjC1QR8ZKIuD4i/hQRc3v0+3FEXBcRyyJi6eYcoyRJkiRJkqa2Zd0DGMFy4GDgE330fW5mrp7m8UiSJEmSJGkIM7ZAlZk3AERE3UORJEmSJEnSCGbsJX4DSOArEXFNRMzr1iki5kXE0ohYescdm3F0kiRJkiRJE26sz6CKiMXATh1eentmXthnmL/MzNsi4iHAZRHxg8z8n/ZOmXkGcAbA3LmRQw9akiRJkiRJAxnrAlVm7lNBjNvKnz+PiC8AzwA2KVBJkiRJkiSpHrP6Er+I2DYi7t98Djyf4ubqkiRJkiRJGhMztkAVES+OiFuBPYEvRcSl5fSHR8TFZbeHAt+IiO8BVwFfysxL6hmxJEmSJEmSOolMb7fUbu7cyKVL6x6FJEmSJEnS7BHBNZk5t9NrM/YMKkmSJEmSJM0OFqgkSZIkSZJUKwtUkiRJkiRJqpUFKkmSJEmSJNXKApUkSZIkSZJqZYFKkiRJkiRJtbJAJUmSJEmSpFpZoJIkSZIkSVKtLFBJkiRJkiSpVhaoJEmSJEmSVCsLVJIkSZIkSaqVBSpJkiRJkiTVygKVJEmSJEmSamWBSpIkSZIkSbWyQCVJkiRJkqRaWaCSJEmSJElSrSxQSZIkSZIkqVYWqCRJkiRJklQrC1SSJEmSJEmqlQUqSZIkSZIk1coClSRJkiRJkmplgUqSJEmSJEm1mrEFqoh4f0T8ICKujYgvRMQDu/TbNyJWRMRNEfHWzT1OSZIkSZIk9TZjC1TAZcCTMnN34EbghPYOEbEF8FFgP+AJwMsj4gmbdZSSJEmSJEnqacYWqDLzK5l5T9n8FrBzh27PAG7KzJWZ+Qfgc8BBU8VesQIWLCier1sHjQace27RXru2aC9cWLTXrCnaF1xQtFevLtqLFhXtVauK9iWXFO1bbinaixcX7ZUri/bll29YdqMBV1xRtJcvL9pXX120ly0r2suWFe2rry7ay5cX7SuuKNorVhTtyy8v2itXFu3Fi4v2LbcU7UsuKdqrVhXtRYuK9urVRfuCC4r2mjVFe+HCor12bdE+99yivW5d0V6woGg3nXkm7LPPhvbpp8N++21on3YaHHjghvb8+XDIIRvaJ58Mhx22of2ud8Hhh29on3giHHnkhvYJJ8C8eRvaxx4LRx+9oX3MMcWj6eijiz5N8+YVMZqOPLJYRtPhhxdjaDrssGKMTYccUryHpgMPLN5j0377FeugaZ99inXU1GiYe+Zewdwz95rMPXPP3CuYe+Zek7ln7jWZe+aeuVeYSbnXy72m7jIjvBr4cofpjwBuaWnfWk7bRETMi4ilEbF03bqtgbOBBP4APAf4TNm+u2x/rmz/qmyfX7bvKNsXle3by/aXy/ZPyvZlZftHZXtJ2f5B2f5m2b6ubF9Vtr9btr9btq8q29eV7W+W7R+U7SVl+0dl+7Ky/ZOy/eWyfXvZvqhs31G2zy/bvyrbnyvbd5ftz5TtP5Tts8t2lo8zgL1b2h8F9m1pfxA4oKX9fuDglvZ7gZe1tN8JvKKl/X+AI1rabwX+oaX9FuD1Le03lY9m+/Vln2b7H8oYzfYR5TKa7VeUY2i2X1aOsdk+uHwPzfYB5Xtstvct10GzvXe5jprt52DumXvmnrln7pl75p65Z+6Ze+aeuWfumXuzM/e6i8zeHeoUEYuBnTq89PbMvLDs83ZgLnBwtr2ZiDgU2DczjyrbrwSemZlv6LXcuXPn5tKlS6t4C5IkSZIkSQIi4prMnNvptS0392AGkZn79Ho9Io4A9gf2bi9OlW4DHtnS3rmcJkmSJEmSpDExYy/xi4h9gX8BDszMtV26XQ3sGhGPiYh7A4dRnNsnSZIkSZKkMTFjC1TAR4D7A5dFxLKI+DhARDw8Ii4GKG+i/gbgUuAG4LzMvL6uAUuSJEmSJGlTY32JXy+Z+Wddpv8UeGFL+2Lg4s01LkmSJEmSJA1mJp9BJUmSJEmSpFnAApUkSZIkSZJqZYFKkiRJkiRJtbJAJUmSJEmSpFpZoJIkSZIkSVKtLFBJkiRJkiSpVpGZdY9h7ETEHcDNfXTdAVhd0WLHNVbV8SYhVtXxJiFW1fEmIVbV8SYhVtXxjFVvvEmIVXW8SYhVdbxJiFV1vEmIVXW8SYhVdbxJiFV1PGPVG28SYvUb79GZuWOnFyxQjSAilmbm3Nkcq+p4kxCr6niTEKvqeJMQq+p4kxCr6njGqjfeJMSqOt4kxKo63iTEqjreJMSqOt4kxKo63iTEqjqeseqNNwmxqojnJX6SJEmSJEmqlQUqSZIkSZIk1coC1WjOmIBYVcebhFhVx5uEWFXHm4RYVcebhFhVxzNWvfEmIVbV8SYhVtXxJiFW1fEmIVbV8SYhVtXxJiFW1fGMVW+8SYg1cjzvQSVJkiRJkqRaeQaVJEmSJEmSamWBSpIkSZIkSbWyQCVJkjQmImKLuscgSZJUB+9BJU2jiLhvZv627nFoahFxXma+tHz+vsw8vuW1r2Tm84eM+7fAE4H7NKdl5jtHHOtD2uL9ZIgYAbwC2CUz3xkRjwJ2ysyrRhlbS/z7ZeZvqohVhYh4cGb+Ysh57wPcPzPvaJu+I/DrzPxdFWOc7SLiqZn5nbrH0SoiHgDsCqzMzF+OEOcJwBxgy+a0zLxoyFgrgfOBszPz+8OOSfWLiC0z8566xyFJ0kyx5dRdNJWI+ElmPqrCePMz89gB59kCeFBmri7b9waOAN6cmY+vYEy7Acdl5j+MGquM96hhPlR3ifVA4OjMfHcFsR4AvC4z3zfgfA8FHgYsz8x7ImIH4I3Aa4BHDDGOxwK3ZubvI6IB7A6ck5m/GjRW1fEi4tnAssy8OyIOB54KnJaZNw85ti2Ah7LxB7uhciMidmfTD4kX9Dn7ri3Pnwcc39LeccjxfBzYBngu8EngUGDoAlBEHAicAjwc+DnwaOAGigLYoE4H/gT8DfBO4NcUH4qfPuz42nwf6Hu7GBFPBs6k+Hv5MnB8s2AQEVdl5jMGiPVsivX9J+DVwL8Du5TbxZdm5pV9v4vCh4BLgPZc+kvg+cDrBozXUURcl5lPHqD/I4H3s2GdvT8z15Wv/XdmvmiAWH8OnEqxzt4I/B/gRcCNwN9n5g19v5Ei3lPbJwEXRsQBFF+O9V2oiohXZ+ZZ5fOdgU8DT6PIsSMy88YBYp0LHJOZqyPiBRQ5dyOwa0Qcm5n/1W+slphnAnPL8fypnJzAUAUq4C+Aw4BPRsS9gLOAz2XmXUPGIyK2Ax7LxoXtK4aMtTXwWor8T+AbwBmZ+fshYu1I8ff5iMzcvyz0PSMzFwwQY+gvEDrEejpwS2auKtuvAg4BbgZOGqLIfRXFPrKKsR0AXNvc10bEiS1je1Nm/u8AscZ2nY3z2MoY7wPOyswVFYxvIcXf91eygjMGyuPh5rHMjZm5ZogYjwZ+1Zw3Ip5LsS+4GfhIZv6hjlgtMZ/LhmOe6zPz64PGKOP8TWZ+rXz+mNa/n4g4eIBjx0pFxD/30e3uzPxEH7E+1EesuzLzXzdnrJaYT87M6/rtP0WsUyj+Lq+vIl5b7Eo/A484lh2Bf2DTzzqvHjLeTsAzKPblVze3lXXzEr9qRMXxXjrQwiMOA34BXBsRl0fE84GVwH4UZ0gMEmv3iPhKRCyPiH+PiIdFxPnA1ygOvgcSEXtGxKHlGR/N+P8JfHOIWI+MiDMi4osRcVREbFtukG4EHjJgrEdExEcj4r8j4oiIuG950PEjBvhQXcb6J4p1cybw7Yg4AlgBPAh45iCxWpwP/DEi/oziX3U+EvjPIWNVHe9jwNqI+AvgLRTr7JxhApXr7mfAZcCXyscXh4x1FsWB3iHAAeVj/wFC9Do4HPbAca/MfBXwy8z8N2BPYLchYwG8C3gWxYHnY4C9gW8NGeuZmXk08DuAshh070ECRMQ/d3m8BbjfgOP5GHAS8GSKv+lvlIVVgK0GjHUqxXb0KIqc+rfMfCxwEDB/wFgAT+t0sJqZXwD+epBAEXFwl8chwE4DjussYAnwTxQF8ssjYvvytUcPGOsMiqLluRTb+0sotmHvAj4yYCyApeV8p5SP+cD2wAcY/HfwhpbnHwAWAg+mKM59bMBYf9H8Igd4B/DXmbkPRcGr7wPrNn8JPDUzX5GZrywfrxoyFpn568w8MzP3oiiUvwO4PSI+XW7DBxIRrwauoPi9vq/8+Z5hx8eGAuGZFIXgp5bThrEAuJxinwTwQ4r9yiCG+gKhi08AfwCIiL8GTqbYv61huH+bXeXx4buBOwAiYn/gcIoC/EXAxweMNc7rbJzHBvC/wDkR8c3yWPT+I4zvbIrf4Y3lMffAf99QFI0jYgHwY4r3dSbw44g4q/xiZhDnAduWcfcA/gv4CUXh/PS6YpXH7d+mOE7YpXycFBFXRcTAXwSz8X7o/LbXBimynFf+vC4irm15XBcR1w4xruMojp/u3+PR7zbyIOCaKR6H1BCr6fTy9/f68kuUUdwAnBER346IfxwmXtWfgVvi7hgRbys/w57VfAwZ7kJgO2AxGz43fWnIcR1F8SXKwRRfoH+rPF4YJMY/RMSu5fOIiLMj4q7yb2DoL2c8g6oaVV8nOegBzb9SfIC6qUyGK4FDM3PREMs+k+KA/0pgX2AZxYHnKwa9jCUi3k9RIFgGHB8Rl1J8YHwvxQ55UOdQHMieX45taRl79yEqvudQvMeLgRcAx1JsfPbIzNsGjPU64HHlN/JzKIpTfzXipVJ/Ks/EejHw4cz8cER8d0zi3ZOZGREHUXwD9qmIeM2Qsd5Ese7uHHL+Vs/KzCeMMP82EfEUisL9fcvnUT7uO2TM5uWdayPi4cCdFIWEYa3LzDsj4l4Rca/M/HpEfHDYWFGcvZaw/luZP/WeZRPvoSgSdLqEZdAvQO6fmZeUz+dHxDXAJRHxSgbfxm7V/FYuIu7IzG8AZOZ3ImKY3+U2PV4b9H3+f/bOPN66sfz/7495CFGkQiTyDRkiSn0TSZGIyjw00CChpDKGJiQiSua5kplEZpk9PMYUGSrDV5Qh8/D5/XHd6znr7LPPPuu+9zrPsx+/53q91uvstfZZn3XvNd33fV2f63P9BjiJ7r9pli7betm8tquJ6XYKRuMVCqZd7jmbo+ozJO1j+9dp+zmS9srEAvgMwcTaz/b5Cfc+2x8uwKrb4lUqLnCGgkWSY9NJmjOxkV4lJkuk93fpmOg6wvHcN6MCJrFK1wY+R0RJDyDumQ8SfVauk3tHguF1je0PSlqSYE2W2rs73rV/lFQ6eJ/P9smSvgVg+yVJue+huSStP9qXmUyI6Wusmg0JZthpwGmSJma2C2Be9WBE2P5pBpZtP5s+rw8cZXsCMEHSVzPbNcjnbJDbRnrn/lLB9vs8cJukK4AjbF+ZifUHop+bmwgoXyrpPmIsfoqbp4fuSgRyFrT9NEBynB1KsGF3z2jWrLYfSp83I1gpByjYnLnnrE2snwO/6GRXKlhxhxEOlBzTKJ+7rfey7dPfnIBoLzvBY8hASJq9IdaBtnsGD9K9N7mxAEj90WLEczRB0vVEavsfc3AS1pEE6/idRN95q6SriOeyKcuutTlwh50FXEk4lV7pAwdgNtckSPq0bwHLVXOwFOC8mgh+NrXtiUATwMZEhs4iwHLAz4hxS7ZNc1A1tB4DDJHPFEDSPD3wch1UL9q+ByZNwO4udE4BzFx7+f9F0va2dy7EWpu48Z9PL61/AEvZvr8Qbx7b30ufL5D0GeKlkTuYBXhjjYZ6nqQHgY1tl7w4nq8i8rbvl/SXPp1TEM6DjYEtCSYQ5LNIxgvvaUnfJQYb/5sGGqVY/yAimW3YNZLe5XLNlocJdgbAI7XP1XqJnaug3O8P3EQ4DY4sxAJ4QtLrgCuAkyQ9CjxTiHUwcAYwn6QfENGTXAbJTcCZaZI0zFJkJsskzVWlAiTn2waEQ3q09+VoVncafbfju9xoMsCjkt7b+Vwr0kf+Nco+o9mtwE9s3975haSPZGLNKGmWauBk+0RJjwAXkKLWGVYX5u6cNGefM9unpaDEPiki903KgzkLKNILREz4Z3RKZST/3bMXMQk8lGDynirpbCIN9w899xzdjiLYsw8CL6R22nZp9PBu4FIiZbOehvc7BQsk1563/ZwkJM1k+440iC+1WyStaPsGAEnvAUoDHs+k8VDlKF8RyE1lnIuYHHYbO5mRqbm9bHoN6UatDmxT+65kzDw9MUZsg0ml9P5/NrWtzkDJdW4P8jkb5LYBkMY9ixAO5P8QzuldJD1ue7NMrLmBTYDNif7hZIKVuSXQtE9Yn0iNrRyY2H46OS6vJc9BVT/vq5H6UNuvStm3cZtY77L9qc6Nto+XtGsuGMP7o86+qXFfZfvh9LdKvZ2TPu6tJnOupvMy22MGMJv8T9tYHfvcLWk3gnRwMLCc4ubYJdMZXQV3lkjLY8AtwDckfcn2Rg0g2pwD161Np9K5ktay/fsWsB4n5D0qezpty7GXa+OxTxDyMY8DF0nar7Rh0xxUza0XhfdnBXgTiBdgtzf0S1229bL5Ohxor6+vZ0boZqkxRwBeqK87T+D2+drE6T/JcXZ/xv4jLHXkVdseJyJtVdtydQ7mqGE9RjBoKqycAfICkurneP76uu0m+eSd9jngy8APbN8naRHghAKc8cDbkBhMfcH2Iwpx7f0Lse4FLpN0HjGxA7Lv2cqOJ5xUjzB8kvjuJju3wOzoZvs5dFlOk3QuMYnoJwqzLsHK2pGIts5FTLizzfZJiaW0OnGu1nOmzhBxX43Wma2QibUv8D/UUhZt3yppdfIG1wC7S5rN9rO2z6w2KlIGS9JRvwX8VpFCUTnjVgC2ILSCcmwHRp+Ajxh8j2FHEmnEl1cbbF+UnPe5A4NDlYTtbU+a+CpSTi7KxKra8l9gx9SHHEdBMCfZt2qfb0w4/1FoJ2TpPNn+raSbCA2HxYlx0MoEW+GCwvYdTWJSkM9C7Gbv9igFBmx/vQDv4eQoP4cI7vwbq2RrSAAAIABJREFU+Gcf7VuaSAWoNFsWAf6sYOXmOuZ2Su16u6TLCT21T2e25wEX6m90sVOIVNnHiHftlTDpOSgJpjw8Fhsiww4iIvpPAX+2fWNq23JEgCXHBvmcDXLbquyA9YhA0U/rTmRJjfXw0v+fSjxPJwEb2K6ey5OUx3J/te6cqsz2fyXlBgYuUaStPUykeVc6TW8mpUtOIayubOXkLCypfPr2FJxQ7TNpfZFcMElfIsZjzzPk4DKRipiLtSZxj1Wpiw8CZ3mIZd63Sdoj992U2rUAcHF9PqeaTmQm3ruJceTahNTHOolo8RaCxdTYQSXpQMJBcgnww1pAcV9JTdnNbc6B69amU2l7whn+AuEvqOY6cxZg3UME184i7tV1CebZN6DxXOzV9Dz/h5hP1PWgS7NPplXxa8Mk7VDiNe6B91ZnpJlJ2rPX9w7tm6ZYvWiQtr1aBtYTRAcO8QB9sLaO7U82xUp49xOD/65RNduNOwFJ/xwDK0fcuWd6m+2jmmLVMGcnHHyvpPXpCc/+iAHI5MZLzq1HnKoTKlKm3lTifBzt3s25Z2tY9wDfoGOS6ALxdknvZ6QAYbZjQ9JNnZO1btsy8IZVFxxtW0OsVoX4xzjWIba3m5qxFIUQvgoslTbdQaS4PtpGW7oc77u2f/RawUrO/zk6nf+D0LZ+sSRda3vlNo6b8I4jRK+fSOtzAwe0MWlPDt+5gPNcIGqeMBbt9b3tv2XizUQ4pwXc6UzhZEk3214uZ58x8FYmUrEvtP1M2rY48LrcCUqbbUv99vyE5uYtTuzxNDmY0RnFRf5/OWdtty3tuzVRtODpLt9lVYuVtAZwkWuTMRVUfpR0C7Aq3ce0l9peJgNLRCDyzcBvq/lImqjPl+PIHwNrXtsXZmAdSAQndqhdx9kJzcnnc533kj7U63vbl/f6vgve3cD7PKRxWGQK2YbFiWBa5bBcgAiI3W17+9H2zTxOVoEvST8CViGY8+sAB9k+JH1XNK5NQYkjgd+5o+K5pM1tNwqkp/tsN8JhPCKrQDV2/hg4lzE6ey5rDtyB+zTBan8xLf04lVqzNvwHCj3Ewwkn8TlOQvLp+drZ9tpFbZvmoOrfch/yyY03paztl//UYIpy9LjPsvOSrgU+UkXRFbT+Cx2iuVMUT9KNhPh3JTw6E3CV7eLqb6k9FeOiFOMa2+8r3b+GcwJR7WoiQ7nizhn8KJgdbyUEpzdhaNA4J/BL20sUtq2bw+tWN2SJdew3kWABLUwILJ4NLGl7rZK2jXGsYqfc1ILVtg3q72z7nA1q23KwJP2ceLbPYTgTtKiKX7cJeumkPTk1brVdUulz3PAUOmmjWs65k7SUu6fMfoBI3d82A+v3wFdLAi6j4I1wWKRJ9frARjmD9/TO/orzq5B2wxrkczawbUuYI6oMdtvWEKuVIFabAdzJYZI+SNz/OddyRkLDdiuiCqCI4grHEelg2RUBexzrN7Y3zNznD8D6pYHkGs5fbY/QGUxOmL/aXqzLbqNhjcbWFqEP1jiTStJthGzLywpG7snAX2zvWNI/pb7kBNub5OzXq33OqII8tVqao1wBXGn7rindHginOhGA/E9t2+yEn6loXjctxa8da7uKX36St/RxIre7Ei69A9jXBXRCRcW9bamVcQUOzWUKVA6o5LSpKpPc04/zJjlDNu1o28klkeDU2W3UgfWbkk4uRdS+S9LKkfQ4cf5Lq8TMUn+oHTTtXkLNkxNvhvo5sv2i8qvEADEQJVINq/P2GLCFy8rE3qyoENk5ScwtFbwCoXXQj/d+TWIQtQDD9XyeAnbJBZP0FYK983YNrwozByFoWGKVcP76BBOoXyH+16xp9Eo8WWmkuYf9/wCrbbwphVVVC6o7XUxm+mHNppM0dzXYU2g0FY3XbL8i6V5lMrMnA95neh2GjHNXd2YkZsYmCf8+8vSKIKqqXahgse3nIW2NIqucU6mPXDu1bU1CWy+38t6XgEMSW2bn+mSgoF2DfM4Gsm3pGs4CvEnDJSLmJL/683wEq2hWSUt3YGWPzWwvnLtPj7Y9zXAWiRiSJClmfXS5lp2V83paunY7SdqdoTnF3/p1CI1iJcHO7wJXKyoN1seguWnZz6um8VezFcmXiHgCWNH2/3V+IekfmViTmH22n5C0DlE171TKdCpfUVRnn6kl5+JNo5y3xqbQQPyHU+EthQD/BoRD9HudwYYMXBFz10Vs7yNpQeDNLtMrPprISDpEwWa+GbjCdmO5IUnnMFKD7TGCbXliTmMUIvf7A+9ITsydbD/oLky2HJvmoGrH2qahZeEl58iXgJ0JfQ6ISfaPJS2Q4ySRtArhFT+WIa2W9wDXS9rU9lUZWDMQVb4+Ty3aIekYYNfcgYKiYsrZhLBtpQOzKrCrpHVznBqSliAcGdfXsD4G7CHpk87Q4lEIhq8KfMz2X9O2xYGfSXqDy1JOnpG0vBP9XCFC+9wY+0wuvH+lc3R2wlqXeLGV2K+AbzhV2FCkmh0BlDDFZiUGBfUoZq6gKsDtRBpFrqbH0EGj0slxkjZwVAzq104Gzieih9+pbX+6tMNkSDh/C9oR4n8t26vEvVQ5QPt5Fptam/3KoGK1jTfZsVIU+AbbB7d47AMIPb1TiX7z0wzXdci11xEaUddQK6pge9RKaeONZ3vzwmOPsNTfbpyWx4hKmXKBrqDtUyWdT+je3Zii1fWU8Sx9REkfTe36KCF8fzwxYfxcQduuk7QSoSd5Y2pnvW05LN9BPmeD2rZtCRmB+YiAZuVUeop8Z+PaxNh4AYaL3T9NvuYiGqOcu/NSGS8mxkCnE6mMjVNHu7SrtWup7pUdF1MSWy8IRrZthxP6R/1qEX4OOCw5QasUvwUJzbStMrGOB94GjHBQEeOZHPubpA9V5AOHZMgXJH2fcOKU2H3AVQr9r3pfUqJDuxKwqaQHElZJAPFwUmECRUGSHwPbAcsS85VcfcTKDiPuidWAfYD/EhU2szNPHAWErkj7fpjoD5YkTw/7J122zQNspmCwfqfL96PZ0cR9dgURpDuEYAj3ZdMcVA2tS0Rh0lcURDskHdID7/WZcDsCH+iYqF6SWFV/Ih6qpnYAIZZcZ1KcLekM4sFdKQNrf4LhsYiHyt7OSTwYP2GoNGtTO4Sgtw8rP6qofPVz4kHNwdrOHYKDCgHAnxNCb01tK2BZ1/Knbf9VUYFsIuFUyLUdiOpSDxH3xPxEHn+ptYn3ZULA8+cJ6x+Ek6PEZnet/Kvty9S8fO4k01DayYGF7ahHFOYA7lSUu61HwRprpkk6yPYOjkpm29cjG5KOtb1VZvPeY/sSYGNJi9iuxImRtH7hwKxtIf5eNlWzZGwvm5zaGxODujvT3wudqRXSdtumcqy28abEvfGKpM2I6kOtmKMq1QSG+rT1XV6dFOD7LTRr3PBSv7sktUp0tn+YAXEXIX79CaeKxpJ27KNJLxITnJmJ/qCfyeYfUts+UL23JZUU1qlsHmJi8i8iuFbatkE+ZwPZtjS+OFAt6M7aPgY4RtJnbf+2H6xkB/Q6HDExbmS215M0FzHJPEKRBfEbwlmVGxBr81qu0/G5Xq08OxjZw6knyoJ1M7qsKNIwc1RFXklDUhEAD1asnkysUSszO1+7tCvr1fZukn6RiVXZ39IyHb2LkTWxNfvcH2D62j2+IfCrFGQ+TZFiXWor2V5eKUvBUTisNPPkYkLP6hri2VrRhRlOXbDPJvqVHAfVHLaPSJ/3VxSh6dumOagamu1+H5xOu7Hwu26mbp2G7ceVX8Z1zg7nVIU1MXnzc+wTwOL2UKqU7acU6Up3ke+gemuncyphXpQcfjm2YKdzKmFdUDB4tDvE/dLGZyWVDoRuSBPiqhT4X3IZZ+OF5xDAXVkt6EYB9ya6duUY2Yyo7JfbplcSG6jYQUX3iEKp1UvBb8nwyEZJOthPgGowdVrtM4QwZLaDKk14v15bv4+opJdlkuYlInT3eHSB9UbP1KBiAThy/fcE9pS0IREx2pfCCpaS3ujeYqqnTu1YbeMNKhbwJ4Ww7W8YHgUeLTW0id1FVMWZAUDSQqVMBtsX99GOrniSFgAWS9HcWSirooWkw4ig3P8S6VgbUKvk2dDWJ9L1L1XowPyaQmelpI8RadlnA8u7//Sh5VPbLpJ0b2pb6bn6MlHRcn+iim4/jMFBPmeD3DZsHyTpvYwspJLLSAE4U9Jnu2DlOGgbVyGWtEa3cXQXvCcJB9pxxLU4mHAg5zJbWruWddahQvMom4XYYb2ceiXaPudL2oaRMhO5Fcbnt/1Ickh1dUpV/9MUq9//STbXaP/nIfH7pljVfnul/fqeT9h+QNIyRPobhEbTLZkw02uoSMHqwDa17/rxmbyUAumGSePTUif+rURm01IEq+4JhQZv38z+NJfK3a2z8uGsaqPyoe1pS+FCeDA3I6rhtIU5C/CZzH2uA5bpsn0Z4PpMrD8Dc3fZPg9wVybWX0u+67UPUXmu2zm7OxPrbmCmLttnLsC6FFi1y/YPAZdlYq2W/q7fbSk4Z63hAZulv9/otuS2LWHNTQx8bkrLz7rdfw2xDiTYbx8kJgXLEwPSbKx+F+Dmbp/T+k0t492ci5f2W4Uo6/tXwil4H3BvJsYXgUeJSM4jwCf7OGcDiVXDfCvwTYKVeg6wOVEFKhdnHYL98DBB339/H20aSKxBblvbvzNhXtlluaIPvO2IdJg7iMHobQRDtBRvRcLp8yShYfIC8FQfeJ9P7+u/pfXFiUpkJVi3pr+3pL9zlJ47Yky2SXo+nwF+AXy04Fou2e89MQr2+wn29kNEyvY2mfufSFRRa7NNA3vOBrVthATG9UR2wi/Sclgh1nlE0GkX4NvVMh73Xzpeo/FH7V6dSBpXTelrWfI7+sCfsWCf+7osWWOqpr8t4zoOJFbt/5ciNJQeSMuE0ueVID3cDuydltuITJkcjF0JGZmzUruqYnLvIIpBld5PmxJO8n8S6fp/IXOu3wVzDmKs8ADwQua+83RZFgX2Ak7KxLq0x3JJ8e/r5+T8/7gQQnCfIqKrTxERv3X6xJweWItgkfwfUW4zZ/8PpBv0e8Tge510k91P0MpzsLYBbiCcK3OkZVXCCfalTKwzCcHrzu2bAWcXnKfdgHOBt9W2LZwe+j0ysfZM+y1Q27YAcAYhhJeDtTRBUT0S+Epajkrbls7E2iv9PabLcnTBOWsNr7r+6dx1LlnnfzyWtl6OhAbEUx3LP9K98faGGLcQzrc31D5XncAtBW26qdvnbusZmHcBHyf0NN5QLZkYtxOlogHeDlzTx/UbSKyEcTkxIf8OsBgdHXsm1q3AEunzSsDlfbRrILEGuW1t/87xWIB7cp/FMfBuINizNxOpK1sD3+8DbyIxFqo7zm8rxLqu+kukns9IsB5zMGbosm1uYjxzcSbW66hNTtN525GCAFHaf6Eu26YjNKly++CFCRZDtf5hIqjzDboE3KbiczawbUsYdwHTle7fgXV7GzgZxxszoEXMHSYS/d17qQX8aCHoV3otOzBad1ARjI/VifH7/03O69LRjleIcWe3sWi1/cGpGauGeTXw4dr6qsDVheftVkI2pFqfnYLADrAyMc+vYy3e770PLEHo2H0N+J8+cL5GsLXvAS4i5mCrZWLcx1Bguvp8PbAfkUk1Hvf1Gjn/X3kGp9kY1kXo8jfAIe6jcoakDxERhbWIG2MVYgKcTUGW9CaGV967k6i8l52zLOkThOD6kgQd8U5gf9vn9NxxJM5bidSj5xgSIl+BELP+lAsqAEn6Wmpbpfv1DPAT27kpfkjaIWFVdPuXiVSqg5z5YEialWBU1M//CSXXMuEN0xkabduUwJO0ijvE8rttGwPjINs7aGQlCSBP76ltk7QPEeU4mRiwbEREFm4iNNBWbYBxPy2WfJb0BCFAKIIhdkX1FeGEnjsHL2FeZztHU64bxrBy2J3rrwWstP/9DN2n1d/q2mZdz0H9neNwzgaybW3/zoQxL6HL9Fbbn1AU9Hiv7WML8S4lBnOt6JtJmmD7PaqV4VZBWfAa3rW2V64wUurCRBeU+Jb0PeAgYA2CsfEKcLzt72Zg9H0Na1hXEOlzd0t6BzE2O4mokHx9TrvGoW3XEWOnhyQtS0xOfkSkjb9k+4tTqF2DfM5abVvCPA34qrtURivAOhL4qfvTmMs53pjnVtJlDO/v6uMY226sZ6WoQDqqOSP9rWO8+L8MjYMqrKJxo6SVibnYekTQaVsiiJ5VJVNR8W2E2T6+2/YeOB+w/SdJs7iPqueDjFXDvMX2MmNta4h1G6HH9Hxan4UoYNK4X1JN01W1SrptWZoXV3POh0r6eEk7EczQCW2NEXocq1FKcEOsrPf6NAdVQ1NoCV0JbOUhoct7cyeaNbx/An8naK5n2n5a0n22FynAmpdgC9zZsf1dwL9s/6ukjW2ZpNWoOW7cgh6Gkh6Wk/h6n1hzJ6yiF5GktwNvsn1Nx/b3AY8UOoFGPMjVJKOwja3hjYKV9+KR3mN7QnLSjjCPIuDXAHdtRort7p2J0a3DnOgQyi7qOPu10c5TZSXnS9KPiY7ydIbrJTTOF5f0KKEpUdlG9XXnVZUaSKy2Lb376zoe36ivO6N6zaBiDXLb2v6dCfM8YtL7bdvLSJqRiPBnO2wS3lEE0+M8hj+bJZWNqkn6R4hqO38n0hu3dl51ozreAQTb+3PAV4kJ3d0lk/0O3FmBWXMmrWm/YmdbF6y6E28fgiG5rULQdkLuNW25bbdW10zST4BXbe8saTrCQdj4ev5/dM5abVvCuQhYjkibrT+f2ZWr0qR6cYIN8QJMqjzWioOuy/HadP6NOXmVdB8jnVyV5QZ3Wh0HSfohIfz9d+AUgiV/Y8k8LOHVA+WzEGysm2xnVX6rBRTaCJ4MJFYN8wwi+FvXoX2P7U8VYH2D0Hw9I21aDzjWGQUN6r+tpXP2XYLBuXdaf4BItZ8JOM5lVd5R/1pbTY/T5rXOeq9PE0lvbq0JXSb7HfHwbAi8IuksyktkH8LwMrWVvYFIi9ukKZCk/Ql6/eEd278ELOKM0pOSVgTeaPt8ovRqtf3jwKOOShWNLb18nrR9VN0xJekLRBWBnJfQ9sDTto+uO6YkfZ6gdeYwsn5GnOdOe4aIDK+b0a4lCAfLXBpeUndOak6XKYGXHG7vB+ZN16KOlfUs1K79sq5VuEvH2Z5IqcoySb8kmHUfJtItP01ES3PtWYVo6e/S+qcJ3RbIfEbVvUrMk8ADOZGPbgOv5Fhd0OVCzBV7aoX6ocio9kMI9tYt65meSrAmmaRViIngM4rKbcsTjMsc8eojGF6tpnM9xwYVq228QcWqbD7bJ0v6FoDtl1RYICPZ39MyU1r6ta2ItLKvETpqi1FeLhuCebwNQ8VOLiCq/GabQvj717afsP2cpFkkbWM7p/pwZ580zDIde/V3/GqkIgi2Xyy8pm+VdHCPtuU4y+uT/NWA7yaMV5UvbDvI52yQ2wZllZlHs/VaxGpi97eItS+hYzmqlTp7RsEadVyY+uZc+yKhwfkL4BzbL0gqZm3Y3q6jTa9neKCsqb0k6VfAAt3eHZnvjEHFquzzhCTN6cSzemXalm22f6pg/30gbfqcuxT9GsM0yudS+wxDjiSAf3uIdXw5Be8SSV8n+t+qONKJkn6VOW9tfLgWsbKerWkOqoZmeyIpJ1vS+4l0vxklnQ+ckTmYwpHetCORb7sxkfc5V5oY/955lQzeYfuKzo22r1R+6c/ViMFnpx1B5PfmlJ7cl4iwdtqdhAZSzkQYQmRu5S7bTyAqH+aU/d2ccLZ02kmEXkfOgz5/N++17VsTuyrH3klUP3w9w0vqPk3ohuRam3gzEXoOMzB8QvcU5ZOdLRlZSW2rLtua2PttvztFmfdKUf7zC3A2Tcc/jHihXgtslqL7X8vEOoxwYtxKvOiXJvSR5pL0FdsX5oClzveTxDWYADwq6SoXlDZ2w6o/Y2Ac1y/GoGN12C+AZVL06puEI/QEQrOvadv2aqsxg4rVNt6gYtXsGUUqSwiZRHDmqVIwD1U2ms19Vh2TtDSRojy97buB3VvCu8h2aWnxun3Z9i+rFUf57a8QAtRNbXqib2pjMH1rYic9SAjjXgiTJpslVpc46NcukfRbggE3NynwJ+nNwIuZWIN8zga5bbidLIDZbT9DFGzo2yT9b6/vqzlCCcur12Eb/ZM0A/CKbUtakAiO3ZPmVc0PFpP6zxIFS/5g+3aFJMkuhHRILuvuzURq8cbAQYrU6lk1VMWtX3sGKHHQfYJgvK5J/++OQcUCJmWufL32PPRrsxHkg2Mkzat8KZOqAt10jKxOl5VhUNun/rt+lra9kuYUJfZFYKUKV9K+REGg8XBQTbE0u2kOqgKzfTVwdWJ6fIRgVv0KQNKStu9oiGOSmLMiJWBN4kV5GPDGjCb1iv7OmIEDUSWvmybQq8oP0c1h+4EuWA9Iyvl9lc1g+6UueC8WtG1G2yMGdCmCkos1V4/vsl5Ats8CzpL0PnekDJZYm3gpenW5pGO7Xdcck7QxwexbRNLZta/mALLSO2pWlVh9VtJbgMeJAUiW2b6X4c68uv0pE+4hQv/iDpiUdrs34QQ+nTRYzrC5bD8l6YuETsuekooYVJLmIsQVq4Ht5cDejvLSTTGOYfQOzLa/MLVjddjLaZC9LvBz20clBmdjk7RHj69te5+pHattvEHFqtlORHWqt0u6nJhAFTOUElv1KGKSvlByiH7J9lczcXYBvkCkUKwoaW/bR/fRrlbxkg1j3yrS1XLHLQ87M5W7h21NsMIWJqqMVQ7CdxEalbn2eIsO8x0I1v2bCe3Bajw0P1F9KscG+ZwNZNskXW77Q5L+w/D+pUrL66m31GG/I4qU3EEXnSdgoZy2MZI1XOG8G1iQ/jI+RrMxJ6+StiaC1f9VpFh+i3h/LCfpaNv7ZhzvKOK3XA8cLOkhggH+HdtnZjfefgX4A/AHSTMTDphZgQclXWy7cfYJgIZrZE1H3GO/zW0X8C3b35a0UAvvjkHFAiARPo6kz74uYe1J3A/vJEgQMxKVT3PYdQ8zlPL/CMPlAHIzDABeJ2nG6l3tpEuZ7rc5M7EqE6HVWNkrtMt0yrbUb6+c/COj2f05mNMcVH2Y7VeJCWZ9knkCwZjIxXqJqFB3bt2rKuk02xuMsfs9ktay/fv6RkUq3b2ZTXlO0mIp0lrHWowhB0BT6yXcPFuP70az6SS9yR3ClAqB+BKsed2hzyVpPvIf9Jslfc72MR1YWxFVk0rsZkmV6H1dT6mI+toy3rOKVNBOrJwX99VER/BG4IDa9qcJtlGJnZuiovsTAyATHV8jk7Sz7f0UOgLdnLQl9OXF6w5r23dKWsL2vfl+UABmSNHyz5I/Iem0owk212fT+uZEp54TYT23y7YFiSpJuQPiQcWq29MKTYHNgP8tnEx3ixLOTkz83wDkOEgGFWuQ29YalqSVbV9r+0ZJHwb+h+g/7uwWAMmwg4iA1dkAtm8ZiyExim0KvNuRkjov8HviuS+1tvEA/ijpFKBiUX2ZEP/OsdYG57afA37cZfvVRL8VB2w2NoN8ZlOvtpkuKUPuSGORdI3t940BN8jnbFDbVrGOSwKsncf/ePq7YL9YCWdYUE2R8rYbMcnerutOk8d2IBiXcwB/JqpwPyZpNiJbIcdBtQLx/nlVIYD9CLCo7cf7baTtF4DTgNMUGrfZGkgMd3i+TEg5/LMAZy1J3yHID/sV7D81YFV2IO30dRDXbDli/I+jmERW+r4bZhaouXj474DDJX2tco5Lmh34OUMyIrl2DHCdQr8LIk34qEKssez+Jv+UnslD6cFidCZ7c5qDqn3ru2NNHWplTVLEdgDOU6QH1qvlvY+ICOTYHsD5kr7fgfXddJwcu0jSD4DdKlZWYiftRU2TKsP2J37nN0kvIOA9aXtulO6AhLVjB9ZPGO4waWI7AGdK2pTh52wOMvSnOuwEQt9jTYJxsynRuZdam3gnEVUsP0FMJrYkk6aeGFgPEPdoK1ZjPpwm6Vxglhw2EEPn48a22gTcoUizrSYVGwJ3pujJCDZgA9ub0Hu5yvYNihTSu8fYZzRbtGNAvpekLMq97dOqz6ktuxCMrB+T2WEOKlaHbUgw/75g+xFJC5E0TTLaNun9kgZP2xOp0L8m890zqFiD3LaWf2eVwktySLUmVGr7Hx1O7FdG+98e9oJTGoDtfyWHaj/WNh4Eo+IrhPMYQtMmV89q3XqUWtI7ierIDzhVZBoHa5q+v5Gkuaq+KDky1yP6v5/36cgczZroSw7yORvItqWgdMW8QZHWWz/XD5UcOLGZF2V4wK8XE6EX1upEGq+BHzacRJfa/Q3+50VHGtd/JN1j+zEA289Kyr33X6xdg+cVhaqKnVOq6dp2fPVZCnQJXVjcp4v9AfgPwb55isTQq/7azmHeDCrWJGupr4O4P6ykI5YcQeNlY+qvJdsd+AHwd4VAOgQ78igK0+3djtZWV5O0BrCz7TXSsXKcShdL2gA4vZrz92W2py0tLkTFhsmOB8xMDLIPSMvniQl6yTGXAo4jnC0TgOOBpQtwZicqY/yNFJkgKpX8GnhdYds+TqQiPZ6Wy4GPF2J9ArgKeCItVwHr9HGt1iAG2TsSVPJ+rvvN6e+t6e+MwLWDgEdUvpmElT7fUIi1MhFF+y8RaX4FeKqP3/l+woGwRbX0cx36XQi6+DeJqiJnEKlAsxH076JnoMW2XUOkiVTrqwDXFOAsQdCo7yD0w2boo02DinUosEqL534e4PvAfcD3gLlfa1iD3La2sGi5v6/h/i69y25K7+qdCCHxXJwniFTi09P7p75++pTG68CekdDoe0PBvlcAi6XP7yDSxA8BLgZ+NE7XqOnY7DrgLenzssBjqU84DjhySrVtwM/ZwLYt/e/ahLj2s8A/gFeBuwqP+wWij3qCEIh+HrisAGfvXgDNAAAgAElEQVRtghF2PrV+vbBN/9trycS6i2BVvIcIAi5HOPXfA/w5E+tZgmF/K3Bbbf02auPRDLwJhNxH5/aZcvAI5v9TXZan6W88e1a/9/VUgNVKX5ewdiKCG/cSqb3XANu11daOY92c+f+zEv3b0kSl2s7v18jAWpoQX/8MsFRh+1dL77D/EuPkpYng/ARg/ULMp9O78MU27n8l0GnWkqnFkozjgTclLDEYlkyrdzg0fqZZD5N0ve33KsqDf5WgMl/vjJK844Un6VrbK0u6ADiYiBr+zvaiBVg3EnThUwnW2RZEWlx2uXJJJxBRyIkMRWDszNQ8SYsTHd3C1FimzkthrOPNCixk+y8l+3dgLUAM1Kuc+iuB7V1AI5e0LDFJmouIgP0b2NIZVQElnUoMNA8gtBaGRb6cUS5+ULES3vbEffrmhHeKCyNWKT12fUK38FDnFcSYKrAGuW0tYz1BTKa7mu1PFuK+kRBT/QjxbF5IPOdZbIHEphjVnCn23CZeSgc4zPYdkuYkJtfTEwU9trfdWLtF0m22l06f9wHmsb2tpJmIgMrSTbEyjtlobKYo2vHu9PknwKu2d07ss4nVd5O7bQN+zga2bel/JxIByQsdFbnWAD5rO7uQjaTbgPcSwaFlJS1JaEE2SYWs47wK/JNgcXaTKGj8LlJoKY2AIOlZ2W6cJp+YHqNONJ1RrEXS23p970xtVEm32F5mlO9uG4/7LNfSb17M9kVpLDmDa1XMp3astvq6Gt4awEcT1gUeJwbhlJjrJ6blWYRcRb3w0t+BdW03Lswi6WaCTHENQfw4kdBy+3nZL2jfpjmoWrZq8t4i3s22e1amkHQfvQWBGzsO1K5QcU+RR+eVZm9bKHeXMbAal/6U9DTdz9l0RHRm5qZYNcwvEoyzdxP5xq8D9nCt2tGUwlNUTbmSeEkeQgj97WX77J47dse60fYKHYP4Me/5UbD+DLzLfb7UJN1C6KFMoObYsJ1dtUTSJ4kUsJlsL5KcQnv3MXH9I3AykbIJoYW0qRMdtxBzToCczq227/0M3fsjhF5zHKCDitWB+zbCUbURERE7hXBW/TUD41XgBUKjopvQbmOa/KBiDXLbWsa6m6io09XcXspH36aopPWOtHqP+6xS1S+epDtsL5k+bw+sbvuTigIX5+YM/jv6j6uA/Z1Ek3tNQvuxpv1Uh7PlJuC7ti/obPfkbtuAn7OBbVv632rccguwrG2XtkvSDbZXTE6v9zqK/txue6lMnA/1+r6fd5GG9KzmBn5gu5sDa2BMzTTYKufgR9xd1/aiKe2gUgjMb0M4aBdVaAH/0nbPQMHUhDW12jg4qJq8sw8m2Ek7O6W6Kipb/ohgZTXWmutsv6S/2H5nWeuH4c4NLMbwdOVRg3i9bJoGVUNr6mxp6pySNOdoE0JFhYTKefPtBnArdKxPR+RQ70S+SHeb4sLn0b06ybzAfAV4bQrldstxnpVIk5yXeOAbme1hueqKvOcvE0ylbuezCWYl7n05zXUbJgue7eo3PcmQaGipPZuiohMl7UcIp5fqmtxOVDN6uM82vex2yqdDVMl7L3AZgO2JkkrKDlc2r4eL8R8rKVcbDgBJb0jt+wBgSX8inGeNI1e2Fy459tSE1YH7AKE9sK+i/PDRhG5f43eZ7TZ0ewYaq228QcUiylm35oTS+BRqQNIHCaf2g0R/PL+kzW1fNQXx6voza5AEYx3Ctrlanrcq2EkPEk6zC1M7X5+Jk2NNxmYAl0j6LdEvzU3S31QUuyjSn0p9SMVKv9MjWembN4Bp/ZwphKvrTsvnO/6l6Tkb9+spaUFgI9uVhmDTtgE8Kel1RFXf4yU9Sn4RocoeTr/rHOACSf8mmFBZVr2HGlyDxqYW9KwkrQj8w/YjaX0LYANCg+17zmQzN7QmGmzQrq7teNi2xPjxOgDbdysKOb1msBTFNrZmZMZCdgEnSesT47Oq2FVpcK31inQNrElg/SOkIgGTdrJfSYSL2zKP9/p0viqbob7uAq2/RITYHliAyGRZmWBoFWWfTHNQNbe2nS2XkcRVFeVM657nMxkSXh2zDH01oUwP1eaE6OhEYG3bd+Y0yu0KFQ+LPkhamBgEfAT4YQ5WwmtTKHdS5ZDkUNqOSC/7HZmix13a9HkiDeh9th8txHp9as/CDH9pl05QWsNLg+PtumCVsII2J56drxFO0AWJwUtOe6rSvnMQAuTXEwyJrHYpBE8BzpH0VUJjpY5TMpB6yfaTHfOtfhhej0vajGDuAGxMaLGV2K+J9KTqfG9KiN9/pCmApJ4RJNs39fp+asDqwJ2BoENvBKxOvMe/V4KV8D5A0OSPUVDd57B932sJa5Db1gLW/QlnZkcVqDr2iG0NbDwKNUBUSlqrGg9I+h/CwdQZ3JqceE9K+hjhhPgAMUmpIsKz9tqxi21N9L0LE/qPz6bt7yJzoinpUnqzyFdPH8YcmyXbgSiu8GZCG6gqjjE/mZVYFWzXI4nzXBW0WFbSBKJww1Opbbc3gGvznM1AjOk+TzgeBCyoYOTv6qES603PWWtt62jnvIRuy8bAW4g+nsy2QYjcP0dc2y2INPncgkTVcavxye7JITQXBYHNptegIdbaxL35JFHk6E+57anZ4aQxhaI624+J8eOyRJr1p/vAHs0ajbFsHy/pX0TxmYqxdjuRXXD+OLQr115IjDpg0jUuHT8OKtZZREbGRZSLo1e2H6Ej3E9BKTwOFelashfdhals+2VJuWONy4F65c8rausmdCVzbXtgRULf+MOSlqBgrl/ZtBS/Qutwthxs+5DM/SfR+TqpfU2ofh1YMxKd0o5EROfHtu/JaU8H3hIEnXc5wllzYreHIgNvMaKzW4lwJB2X01l2YM0DfIOYTB8H/MxRIaQE6/XEAGNLojLdgTnskY427ZjadHw/baphXg1cS3jF697y46Y0noLWflQXrCmSzqKWqO0aSpXtFr23y/S6jiKEXb9DOIK+TqR9fjkXK+G9jUirrOjrVwFfd2a6bMIakUagTN2FNJmDiFiuQOhfiEglvdENaPaDjpXw1iAmNWsB1xPOvbOcKpqVmKQ9U9veaXtxRWrTqbZXGWPXqQZrkNvWMtYIun+3bVPK1CWVrNu2yYmXxhk/Jxw1BzpV0pK0JlH4pIgZOsYxT/MY2j6S3tNl88rAzsCjtldsu13puGOmJUk6lnCK7u2hFA8RLJd32N5iHNrV5JwdSASIdnTSoUnOtJ8Az9nevu12ZbRtDkJzbhNgcWLitaHtBfo47g9t7zLWtoZYx9reaqxtDXBauwZqV89qUupjmvT/y/b30vpE28s2xco45sC8e/sxRVbBE4QTdDsiK+NO21mO7QHHau0ekHRV6TilC9ZPCPZP3xXp1ICRJen0sZxeku4ixqGdcxQR8/T/6aed/ZqGpyuvZPsF1VL5s/GmOajyrC1nS/0F2vkyzX25SvonoadxECGWNsycQdVTu0LFSxHnaknCs32KU3neElO74rY/ItIgjwYOcYH+Tg3raYLFchQRcRpmtg8uwBxYsX1J19leqU+M2+gtnJk9cVIwux52orQrhBvfZPv+0naOcpw13JDqLmk24hmYJNoI7OM+aPdtmaSfEs6WSoz404QGxk4FWKcDe9q+La0vRdD3s6Ojg4gl6RJC++u0fp3PNcyJRBDgplqwoshpMKhYg9y2NrAkzQ+8lRAY3YShgeOchCbHErntSrh/BD5j+4m0PjdR2WjNQrxjiepgJ6ZNmxGaFVsOAt4Yx9rZ9n4tYeUG/z5EOH9mIbR3xo1V0aRtku62vVjud5OjXURxE3dsn56obtd6uzLa9hzRz+0G/Mm2Jd1bEnCqYXZzSJdqUHWO/6cDbsud1LV5DdoK+iWs2wmdrpfTBHsbJ02abkGyNqzpc67QUrrM9t1p/WiG0g+3ciHTui1L98IXGD5+PLLEYTLAWN8Hrrb9+9x9axiVY+dDRMDjTIZnP5Skqz1NSMi8TPR1RemCNbwibd0OjEt7fe+8ggPrEJUqH0jrezB072/vAla6pDOIrKYdiLS+/xAB+bVysWCag6qxjYOz5Z/AT4mbfsf0mbS+g+0FM7COpTclvXEur9oVKn6FKMF7Hl2om86vrta2UO5zhAZEN6x5uu7YHev79Ha27N4Uq4a5I1H+81z6TzNrFU/SJoQI3oUdWDkpWK1WY0mYNwLvt/1iWp8JuMotR7ynZHROkXb7MyKibyLCs6MLKmPWOuBXiPt+OoZ03nKfpxFRktLIyaBidWDMx3ARyBIGW1VZ8ybbyytSja8pdLYMJNYgt60NLElbAlsRTKwbGOovnwaOLRkYJ9wRUeV+BrgKXZqvE6l0ECkVh5Q6ytvGG+NYbQZXmlaRW5NwaLxAOKZ6TgwmV9vGcFDdY/sd3b6bDO36q+3Fc7+bTG3bgUjJnp1Ijf8N8McSB5WkLxH6ou8E7qp9NQdRXXCjDKxvE8zqOYiS7JDGn8BRtr+V2bbWr4Fa0LOStCvBPH4MWAhYPjkJ30EE+PtmvChStTe2vW1aX8oN0lyT82w52y+lce03CafLckRg64P9tm2adTcNFZcS8Wy+ALxE2XzumB5fZ82Bx8vUIiOrwbHGDKJLupVgdT2rKHz1U4KdtRwRHCsKhtXwP0SkK/+hmpPl2jQNquZ2C0POlvcC71VNVybX2QIcQXRMnZ8hNAYamzOpwGNgLdwWFuFhb+1BdLvitjO2BWR7t7awavYikV65K8MdhqVRvzbxlia0o1ZjKMXPZAjh1R1QiooplRPpehfqdhFlbie9CB058jMVYvWyxgK+khYnihUszHC9riLRQILFcyjwqbS+ETHozma0uUPcv0+7VdKRDDEqNiXK4L6WsFBUZTyA0C95FHgboRtU4vD6raTDCbHKrYk07SMKmzaoWIPctr6xHCnSx0nawDX9xhbsFdWKpSSHfnFfmiaW+wH7KVLb39KPM6ltvDEsVzC9v4NJNxDaovsTEwpU07SbwqyKq1Oke5/6JEfS7qS2TiG7U9IWto+vb1ToJd41yj6TxWwfBByUgjsbEeyKtyQH0RnOqMBKsI0vJorofKe2/emCcct+hJbbL0n6a6m9pYHv1q6BWtSzsv0DSRcTGmwX1u7b6Yj0sCJTFCnZhNAUu4+aZk4T51Syl2u/5RPA8Q6Zj4sUaWxT1JLjYB9inDEDfbB4Bg2rzfGn7c+ldq3ijkIdigqURaYWK9IBXyLkaV6W1DcjawzbFxgry8Me0vZbn3CKTwAmKDR4iyz1lR8gxitXlTqnYBqDqrGlSOmo5kJtoFGOtUPqVJv+/zc6m0NEK/7kTJqeRooLG3jM9j9ycMbDNCRiXZmBJ0q80Yrc/GFYTnn7BVg/7dhUnf9LbV9biHkvkW71WMn+44kn6R7gXf28eGpYnyUmApcRL+wPAt+y/bsCrD8SUfyz0/q6hD5Tq6VvcyL6Cr2uXwITqLEIU0dQcuxu2i+lqQWrABNtP5MGscsDB7mMDTQL8BWioAKE4OIvCiOuA4mV8G4hHLEX2V5O0oeBzWx/oRBvDWo0+bGiXlMj1iC3rS0sSdsDxxDMqSOIZ+k7zhNeruN9jEhlv5yh9+I2ti8oxLuYcGpPT1Sr+jdwSS5LY7zwxjhWmwyqJilhl9GbkV4aXOhpDds2JyElsDxDIunLEdfgC7ZHSAxMpna9lXAQPEf0dRCswlmBT9l+sO12NW3bKPstRbAFNsxlnSlS5m51nyzcGl4raW5tXgO1q2e1mu2qcuUi9TmJpPWdJ0GyOHHdNibG2L8BdrLdk5HfA+8mYG0iFekBYDXbd6Tv/uwpr+lzD+E8uK1f1s0AY3UWCeu6rSFWa1qQGqUi3Xi9/9u0hu/sW4H3A88SDt4NbN+YvrvT9rsKjrsH4TCunun1CF3P7+diwTQHVZEpysviPjSQxsD/u+2FMv5/zy6b5wHWJPRWfp2B1Y3KPg8wE0Ghndjl+9GwqupqldUdNyd236snXjcR6zmIl8cXnaE1JOkfXbBmI9I0tsmZpEvqNjmdh3hQT3CmgH7CvBBYr+bh7svaxJN0JnGOSplOdaxbgDUqLEWVnYsKHS6LEmL3b0mb/glsbvtv/baz4zg5DqoJtruJ7pYee19iMPVr4v7dkChdvj9ka8TdCixDCIcfSzA3P2u7p/5ED7xZgYVs/6Vk/6kE60bbK6T7djlHtZdSB+E3gN+0MXkbVKy28QYY6xbbyyhSw75MpIed0I9jRVFVcOW0em0/wYVqwJr6qoVt797N2T2l8JocqyWsj5Y6DVs49iIMMS3vdEdathqmJaX/XZSoaFdhFfdxGiONK+ecSVqN4b/x4tJ2jYK/ILCR7f2btk0hzH2K+6tE14l5DvDllt4dJwIH2L65/5a1cw3Urp5Vm3q7rxLpxF9wKgSlPvTEFEygwwlH+zm2q0qiHwJ2tr12CW5bluZjqzsVRHgtYaX3zuzAJcCqDM3F5iTSwhrrN0p6H+Fs2YFgJVY2J+GcLRmf3cZQRbpllSrSuY/qfWqXkdXrOE1Snz8P7EKkFz9q+2Np+3LATwodhH8BlvFwHeCJtt+ZiwXTUvyyTNJXgO8SDxWS/gvsa/uwtg+V88+29+oKEoyji4jJbFOsriJrklYADmaIidDEupUDngfYLA3GvtPl+15tW2SUtq1PsFQ+loHVVeNLweg5nCgl3xTrqFGwDgWuJqqu5dozwMTUEdR1nnJTSccD7/XAXYpUiDpW48ouNZuuw9H1OEH9zrY0SF95NAeypC3dDtPx/oz/PUdBlz2DFrTECGF/CLpw3TYiP2XzZdtWMM1+bvuoUZytY5oi9W1/wpG9iKRliUpT2ffEoGIleyLdX1cAJ0l6lCHdrlybA7hQ0r+JSPCptv/vNYY1yG1rE6vqs9ci0kTukJSdmiZpCdt3aYjJ/FD6u5Ai5a80vWyG5Pz/DLBHIca44El6vZMYfG3b2zyUBj4mwyL1a71YT6unD00dLfMB2zI00b+DKMySHZRRME+OJNgsVYBvWUkTiIn2U6ltTTRz3kawxv8G/E3B4Py6pAeId3hjVrMapnE1OWeSVgTe6BCRv6S2/ePE5KeIMZwwqvtsYyL4dEb1XcPr+Vdgf0lvJlL0TmnBGfQ64M+SrqH2/i+cvC4H3CDpbwmrSv3Jcm5rKMNgYlpMVForMXc6p9LGVyTlsho0yudu62PZ+sRY51JJfyDmNsUpwLbPTc/UHB5e/ORGIvgXjcwojNOy7Qz8XtLlDB8/dmZtTI1YXyIcSm8hGH/VdXyKqO6aYzMRz+QMDJfLeYoo/lNiz9t+XhKSZk79cpGjBUZnZJEhjdKm2T5a0gXAfISEUWWPEELnJfYQ4XyrghwzA8VO/GkMqoYmaTfCQ/u1KvKlIcHi61xIYRvlWFkMqjGw2ow+tkK1T1GYCW6xvGxbbRsHrFIKeteU0lIHS5t4GqXCizMqu9Sw9icYPKekTRsS9Plv52I1OFZTgdzZCLHMhWxvrajc+U7b5xYcs1uKrUsjfg2Ol1Nh8HLgD8QE5YOEptIttpcuOO4EoqO9zEMV0W57LWGlfWcnUiimI/Ss5iLK+5Y6HJH0buK+3wD4p+2PvNawBrltbWClSf1bgUUIVuL0xD2XxZ6U9Cvb26g7k9kuTC+QtBHhSPpTwn87cKDtdac0nqQrgY9XAYUUqf6dM9KeJHU7zysTE6lHnVEoQ5H6fDLBKq0cK+8BtgQ2dYfGSQO8Y4mgxt4V4yA5L3cH3mF7iwys6whGwEPJ2X4RoYf0buAl21/MwGozjesS4HPuKG6SJv/H5N63kuYgnBGbAIsTTsoNbS+Qg9OlLRulZVZizHGK8zSoKqyu7AKXsZUWHQUrixWn4RkG1d/XEZPP3AyDMwkx5256Vp/NCfCoRQZVbb/ZgXUJp+VqwPGEnti4sCPbnBNkHvdCorjRbQzpvY5KSphKsbZzjyyTzDHt2zrfQR3fH2K7ke6Z2q5INw6MrB7HOn0sXI2U8xlmOcEwSYcQ75yFiN/4x7S+BqErXPQbpzmoGpo6qGu17bMSk7qsChkaqmAw4itgNtvTFzd26BgfBnYvHdR2YL0J+H3ugLsH3ogqRX1gvY4YKPeNlzq+q/rFUpRh3ZSgoxfRhNVialLbeGmwt5jti5JDZ3qXa3itT60alO0zev1/qTV1Fkr6DTEx2cL2Uun3Xd2mQ7V2rFYjczkDKUnzExOAG2xfKWkhYNXOQWlDrGttr1w/xypM+RlUrLTvvp3O027bMjHnJxgCGxGR3OI0qUHFGuS2tYGV3vfLAvfafkLSG4C32s4S5Jf0GdunSnq7CypzTo2mYDnuSGjBLE6kaW+eM0DuwPsQ4fyZhajAd37m/tcCX3EHyyY5hA63nVWQQr0r74363Sj/P+ndpagK9artndP9NzHn3lW7aVw3jOYELHnfSnoOuJ5Ilf2TbauPVK4u+MsBRwPvLh1rS1qAGANdqkhXmt52EZtW0srEtTg+vTtmd4EW5CjY6xOSDI0zDNSuntUTBOO40tKrUpoEfMD23BlYM9h+uWPb3MT7e0O3rDdaO0Zrgf7M47aiTzbIWA2ONcXJB2qhIl31jpQ0EVjJ9gtqoaJ0wl6DSEldI2OfXpVps4Jh6q3R7ZI5BUxL8csxdzqn0sbnFHnRuWCtVTBIntlOZ9c8BN2ucXQuYVWe0E6s9xP0xBysTlFzCL2cLQjKfJZppBh8hfdJMimhkrqlts1NiLr9IhPrP4w8Z68SHXFnKlZTzHWISGYrqUlt4ikqXm1D3BeLEsyBXwKlg4OrCQHxVwkNsPGypt74RW1vKGljAEcZ1vGqJNWk2kaONW6n7UcknUbkxEPow5U6B+9QlGmeXsE4+zpxXV9LWBARoU5n1Me7bBvTFKmfnyUqhp0KbG37zpJGDSrWILet5d9pQhPoE8DehAzALD336G7fTW35HSGE3YopSrofCszv0Mp6N7C27R9NaTzbZ0uaEbiQmARsYDu78ptC/2s3IuXkB7Z7DcB72ZydzqnUzokKZk+bltuv1P9/NeJ+waGFl3tsdzqn0saSNK5eTobZMrEgftdGwGHAKSlo1JcpUho/nnBXJwqzfK8Q6/PA14j7dVGCOXAYUMK+3A1YJeEcT7w3TmYoaNeX2T49HSNnnweBlTRcz+r3LtMUq7MqO2U/usmA9LLr6XgvOlLzfpWW8bIpxeT4vdrTzRtUrLFsslZxHXbgFivSAf9UVLw9E/hjmjeOyvYapT2rEXOttyScfYniLAJ+kIPlUeR8uhxzzCC6UyaOpO1t/6xj/yy/Qd2mOaia24OSVu98Qacb5uE2DqBg73yKECPPYd18omPdwOOd0RxJc3t4nnU3u7EbFvAN5+svTGC4EHklkn4ZUVkr1zoHhybyZTezfVsm1rxdsB4HPt9tcDqGvbETy13EA5X0RRpifg94L3GuqsFxP9HDNvG2TVjXJay7FZod2abIy96D0K0QcIikvW0fXdi2nodr+H8vKthmTm1clFqe/RRqU1NrPJBq2dG4HbArcZ5OAS4gyhCX2MBhKfQHvwq8XSEuX9kcQFbKT80WBHZwRuGJqRCrbbxBxTqMcLCvRjiongZOI+juOfZvRfrE2yWd3fllaYCC0EDahXAqQaRmnEKkh00RPEWKWfW+EqFteA+wjSRsdwtIjYZ1A9Gn70/oegxLYchkY6nbWCkF3Er0Ea9WVDfap+4QkrR71dYMu0TSb4kx59wkvSeFvlLu5OlOSVt0RrcVaVy5DsKLJP0A2K36jSmosxc1Taqm5qhifVAao2xETMbeIunbRCpX47S8xC7YmNCHu57QLdqmlO2U7OsMHwP9VZFlUGKfZqgSI7Yf1Mgq08WmyDDIum/Vop6Ve0g/KNJps5pW0oap2L4C7CTpBeAlmKRPVnJ/DCrWWDZFnIMaWZHuGEnFFelsfyp9/F5iL81FSGzk2AHEmP0awtl+DVEtOFezK8dyguhbErJHdduqy7ZGNs1B1dy+Dpwl6U8Mp7yuwvAIQZZJmomgtm9CVN07jZgkNjb3yLntsIsZIyrrhppEkk6zvcEYWF1FzbtgNUpzcsP8ZjXIM7a9e0Osg2zvMAbWK02wiKhY06j4S7af7IiK9lN9o028F2y/WGGlyGRpJ/Itohra4wnrDQTDZTwcVE0dCXsSHceCkk4invGtxqE9MOUic9Cio9FRHXJXRZVBuzDdc4CxTgbOJybg9eIOTztTf0rSnA5h5KoS1TCmaQ7eoGINctva/p3JVrK9vKSbE8Z/Ut+ea2sRfcQJxGC0LZvd9tXVO9u2Jb00hfE6RcEbVbAbxZ4hNFE+zUhRXJMnRHsgIZ6/E8lpQGhQ7cvwClFNbTvgKOAeRXoHDDkkcotS7EDopb2ZSI+qzvn8hCM+x7YFTk9soBFpXJlY3ySclvXfuAwR8Nw6E2uSOdJcfwj8UNJShKPp9wxVHWxi3yGcp99sEKBtas93jIH6keR4IT0/lWOvhHHWaoYBw4PLk/SsFNVrc/WspieYqm8lUqRuV1TP24W413JS5+Yd5XcCxYLfTez+ccLtaR4j00bSkrYbZaMMKtZkthwH56YMr0j3Y8JZW6w33QIjy7YvS5/PlPTgODunoME5U2SbbMLIwNocBPGjyKY5qBqaoyrPUsRFqCivVwBfcpfUv7FM0keJzvajwKUEtXdF26Xq+Y0O2yJWmyLPbac55UZlellO1cKxLOf8t52a1Cbe5ZJ2AWZN0cmvAucUYj1OsA0qe5rCF1qiz24BLEzt3eZUqdD21xpgiIger0+I7ArY3n2UeJ/Mdn/G/7bmaFRUcTqaxHKU9CTBRsyu3jSIWLafBJ4k3tkkR94sxKD9dc7TCzmZYL12MkwhvxLjoGINctva/p0AL6WJWDXJnJeyAMBRtjeXdEQv5kGBPS5pkVr71iPYx1MMz1E1dHpCRDtLiqAL1qr97N+B9StJD2RCh+QAACAASURBVBFMy3oVv+/bzu7nkjP0M4mJ+660eWdnimAnLNOlKnMB67vVNK7ERto4MZ4mnTMX6qgpKiCfYvtPtWPcTjjhch1x89g+sqQdPewqSTsDsyi0XrcFsouoJDs9/d65JH2OcFqWBOhayzAYLbisgorZhHN2QYK9dnB6tlYgmB9n5rSLKD7xOlqay0jqOb63fUX627qQdUt2Au2lgg8q1v1j/YOk2VIwstt3i9iuihXlMHnarUjXDiPr9ekZrGyG+rrtMSveFliTOcHVBKv3TQwPrP2X8JkU2TSR9ClkCt2qK4GtqodHLYpAjnLMKS42NwpWqwKEA/w7cwSsZyMGYh9Nmy4gUgSKUs3axFMIsn4hYQm4wPYRhe06HlgaOIt4Ea4L3JqWrIiYpKuBaxlZWSSrUqH6qPKWa2pQbaPj/9usMLgfQdvfgojyfxW403buBABF2tu2tq9M6x8ADnOZ4PRAYqX91wF+SmgAPAq8DfizWxC6nGZTr0nalGC2LA8cR7B4drN9aibOnYSOzfnAqnRMxArZXZVm1K8Ip/u/iMHkxrWB+xTDU7DSP1xjAxVZchpvy3Cn0qHOlyZo1RQFRZ5ITm6SQ2M9Qn/k5zlRdPUurmNnpNgk5/0b3SEiL+njROXDxk58SZvZPjF9XsW1SoeSvpYb5VfolmxEMMV+Szirsp1wCav1CmzJsboNtTEQIaBfxEpP57w+nsoS9p+clns+Jd1OiNG/qhCTf4TQ+cwORI7DXKGbw9lEVcwF3UKxqvG0Ns/H5MbqcLSMsBxnS2Lv/hDYq/MZLLhfx6ciXUehNYWMyETb78zAOKbH17b9+ZK2jXHMnHnriP9VH0WJpjGoGlqbA4NkyxMd8EWS7iWiYgP9MhxHm+YlHWlrJ0fBJGeBpM8QArpTGm87hxDeJKeUuojjNbS/paWys9LfEjHaWZyhW9LDbpK0ou2+BdvHcigVdHbHEMyP96X1B4lrWBK9/Q7haLyNEPP/PZGmUWKvVE4gANt/kvRyrx2mQiwIevfKwEW2l0uTzc1KgCRd7I6qQ922Tc1Yg9y2NrFsnyRpAqHfJmA923/OxSHYCRcTLK4JtMPuwvY9wGqS5iICk0V6MuOE9zfgSklnEal61TEObgqg0LI5GTiWYKNDpOVdL2nTusOkAVZnoZhKO/PSOqMnw35LpMw9qShOciqRKrwMoV32xaZAblhcR830Rvclyqh32p1EP5OTFvkN4MT0+RCGsyc+T2aKWRpL/Cw59zYCjk4TulMIZ1VjDSpgPrWfFjYj4ZD6BUwK2s3EENuisSmq515WOaUkzSppQdv/yMQZoVlXN5fr19WPka1nBbxYOQ1sP58C8aVpPzMW7tfVbK9TX0/vkd0IJ1pPmZABsTbnTpMba52Oz3VnoRliGjWxewkd1askbdIRKMll21U6zBMYXjToMvo7R30zstxyhlV6b61su1c2zf0NcHpptBZn/kxzUDW3efqN8NXNIcw6EfiOpPcTqSMzSjqfEIEcj4oUbab4DbJY4aD+zqZaVTBUzWmsbVMCrzUhPDfUFWtoJyiEv8+lJmpewDpYCdhU0gPEhKlyQpdEAdp0KEGLFQbToPEIhjsaV6FM9PtySYcTEwgTbJLLlISKnSdSPKhYEFpuj0uaTtJ0jhLjB+UApCjybMAbFSWyq+s3J6HTMdVjDXLbxuF3Tk+kMy1Bvrj0MEtOmYMl/cJ2SSGRbu0TMJftJxw6hDMqUom+6YJS4W3jAX9Py2yUVXyDSCtYr4Nlc7akM4DDiXd6U+ssFANRSGJ/Sb9xCHjn2Ky2H0qfNwOOtn1Amhy0VYig08bUGwXmcBf9UtsPSOos/DKWaZTP3dYbW2rfvsC+kpYjUt/2IC+Y22paWLJLCcZTJU8wO8Gien8B1ukd+71KaNG+NxPnfcA/iL7uOvr4vaM49Er1rJaoTVoFLJrWS8ZV/eiwjmqSVgd2J8YIP3QDTdxp1p/VnS2JcdWP8+UZ25spCjxcIWlXDxV/yHIqueWKdLWAx5OE1MowRlYm1jrArdV7W5E2uAHBxt3emQzmxGo8lB46cA2D6K1ptNZtmoOquV1Hi2Wf65a8l1enm391ImLU2EGVWBovVQ40Se8kxFYf6KBJlkSZZwSWAh70cKp8dln1HnZ/6Y5pgvGEPSxXtahigKQ5PFJEeczOWNKCwJMOrYkqr31d4qXxi+q62B6zopOC6r0W8FZJ9QjynEA286NNPA0J4S3SEa2bEyhNPZkX2JlIy5hUlt12TvS2shcJ4eNdGeqUSlgHaxYcezRrzaGUrO8Kg2pXtLSyZdLfPTu2L0e+SPGgYgE8kaLIVwInSXqUGuujoX2JEDt+C8NZMk+RP/gfVKxBblurv9P2K5L+Imkh52mRjTBJq9m+xPZXNFw7A0nrO1NjQsGSPYJ4b9xOlKI+mkihzk4HaBNP0g9t7+KGBUvGsDndJQXMUa02i43rUVLCJf2SiAbnOqjq7/vViMBQNTnIhCo65mg2d4/vch2FnYyz0b7LMoUu4seJMfHqBIvhe5kwj9jeu7QNo9is9bGi7adVKG4OzOBamqftFyTNXIAzPzHprcZp5xFssxKx6jYrZv9PwfFHs37YzyNM0trEePFJIiW7hCE5JS1XZHtQsVphb9k+UZEyfoKktYi+vtTaCsS3ycj6AcHgJ43ZNyOe9+UI9nXJ3OViSRsAp3fMoxubOzRaWzPb05YGC3Bzy3hrAp/usv3TwBqZWFcAi6XP7yCcBYcQUbQfZWL9ElgyfZ6LoHvfRjA/Ns7EWhGYv7a+BZHCdTDBSMs9Z3sAS6TPMxNRrH8TWjAfycTatYY1E5Fn/CTwf8BqmVjXAgukz8sQIt/fJijvv8rEWoZ4MT6Q/lbL+sDcBeesNTxCb2dVorTph2rL8sQgq+Q5uJBIM/tzwjoa2LcQ615CUyN73w6chbothVhXE06fm9L6okQee2nb1gAuJ3RfTiKcu6tmYhxbvRuIEuAnEsyP9fo9d6/1hYiUT0cEd7Ykig28oRBruxbbNZBYg9y2lrGuINgUFwNnV0sBzk3dPndbb4h3O5FSDNEfvwB8qo/f2Rpeye/pgfXnbv0ZwXy6q8XjZI8DiQnNb9Pf+4AZ0/Y3Aze21bbcc0uM9X5ApGhW2wTsTf645VnCSXlb7XO1/kxB+9dIY4FH0rO0CVE5suieHYfzezWhJ1OtLwtcW4h1MbBWbf0TRDppP+2bmZhM/wv42njcY+NwTq9p8D//JNJJuy4Fx3yVYG+eU39vl76/x+GcXNxk29SMlfbtqy/ofC8TY7Q9iTnBw5lYG6f74YmO++FSQtqhtI3bN9k2BsYttc9HA9/u9xwS45ZXCafiU2n9qX6uR1vLNAZVc2u7vOkehFBmp11GPBw5FNO5bd+dPm9JRE22U5S5nkCK2DW0D9r+cvr8OeCvtteTND9B4TslA+twQvC1YhX9mMjrXpZgiHWWgx7LNiQq60D8ToB5gcUJYdqLMrA2IUT1IBxnMwFvTFhHk5cSMJvtf6bPFYV/30ThvyUDB9u3ALdIOtlDjLi5CcHG7BLJbeI5aKUPSPoI8JwjArw4sAQxEC2xNziqOW3vqFp1uaRS7ad7iMFxv3YeQ9W9ZgEWAf7CkPhuju0J/AFYUNJJRIXJrUoalZhXbVQYXIGWREtrbduj23YXRK4HFSvZjAxV4jrTSfi40F6V9Hon/Z70XG5s+7DXENYgt61NrDZYQNB+qtSLtv8CYPsGSffYPmOsnSYT3vQdKZbDzHmpAQcCF0raCajSdt9DpIcdWNi+SZaYPJsTE+Rc24EYu7wZ+ICHpCLmJ78iXZv2TUJz8B5JVarhMkTEf+tMrDZZMhBpIqcQaaPZ454OG4+0sB2BMxQyACKq1JWyB74MnJJSbUQEXEt1DWcG1k5tWZgIBmc/n5oMelZdbJax/6X1dM0Pt4TTqg1qSnvLWOcwNM5+e+c9l3mPndex76vAXpIuIJ9xOS4V6WiHkaXE4H+WYJTWxypNnp8R5oa6hlPCpjmomlvbL8aZbf+rc6PtxyTNnolVp+WtRqQ54Sghn9s516mZa5A0imw/UkBHn742yNyQiMqdBpxWGxBltc3J5Usw0H5t+xXgz2kAWYr1McKp9xKRI5wrxNhJ4d8VJlH4S6mrf5T0SeIZnQA8Kulq2zsOAN4VwAdTB3UhcANxfTctwKoG6w8nuvVDRNS7xJ4BJkq6lOEaVF/PAXFHBT+FXtFXcxvTokOpapcl/T6177wxdxjd2hQtraye5jYLEQUuEYkeSKw08D+cCCrcR1zLtyk0br7sjEpcNdva9qHViu3/KDTUShwkg4o1yG1rDSs519uwtlOl5pNUf//NVV93hhD5OOAtwUgh+ElQZKRm2/6Vonz9Pgyv4vf/2DvzuOvGev+/Pw+ZH6IRIYoUhZ8KpVKOTppO6aTQIGmQsVGGlI406ZQmOmSsHEMaVDRLimSeRaJSjlKiSOHz++N7rede93723ve61r72c6/7aX9er/2617DX57r2utdwXd/h8z3Edr9KXQOh/gVx7iEiV7NTRtI443/7bG9Vla4hZhys2f4bsIOkdaidM9s35jbmPlpWsECEdwcigjsHq9huW7CjF0XTwgBs/0zS45kyzF3d8h1Aci4/WdKD03qrggOKisgbEsVODrZ9ZRuehGJ6Vhlo8nz7/QjOpYUbTM/tZHh5bNp8g1OltVlEV1PaS3IdNmA5G7YPhIV1o2yfr9B1zuGqHPFL9r7XNbyKXl9oShql1wg3n8i2ycEnCN3CO4nq0RemNjYhjGqtkOZy6zJdZuWctnylMDFQNUfRByOwYroBpr08k3Fk2UyuyyUdRqThPZYwGlC98DJxR8ptvYWI9nh94lqyRb+WqP3GrYmyvBXaXHv3StqQSMN7NvCO2r7c/P970wDjNsKo9K7avtzf+SNJXyIeEA8h0qZIUWdthfVXsn2npF2BE2y/V9OrI8wmnxxaSq8HPmv7Iy0NjgCHKCpBvZ1IS12R8E62wVfTpyhsXywpJ6KuOq6UQamOEhUGS4qWQhxU9zSRnkffbtO5jnIdQERPreGkPaLQtvkMET3TJoJmCUmqDOUKbbClWvB0mavLfRuZS9KfCJHjk4Af1JwebVENYnu9yiIiOXNxLBFlPGh9NvmudsGS8Y7KqG2LT9R5inqUBxi8YOp527gCtGo6ZBpeqW9GvVFJr7L9Bds3SlrVtUqHkvaw3XjCKWlFYHciiuLrRAbAHsR7/TIiHT0Ho95HdYyjih9EtNmjibHsEyRh+0u5JIpMh5dUXJUj2PahQw7rh1cRDpm9gb1qDuU2lcZL6lmVRFFDWZrXHEro5y2IhkuGiANcsDBWDjxVxXKvXqO/MvXJOsxVGQcHiZG3cfqMHKWk8hXpikVk2T4mRYU9nOnZObfSvyLrjEhzwr2BRxHGr80JGZc2OsBFMTFQNUdpD8LpwFFpIPA3oCrhejh55TUhwrH3Jl5wz7VdpTk9gXzL9JuIsOBHAvvYvjVt35r8SfZJhPHmj4QH8scAkh5L6D3lYh/gNGJA/HEnAVmFGF6uN/LtxEDqocDhldcwceWmq+1FPGhWJVIkK0/aarRP/VhS0qqEmHWJNICSfJK0BREx9fq0LaeqTkWyBKGd9g3iehgp3Nr28Wmwt17adF2bAUbPYHYekSryuwFfnwklDEp1lKgwWDodox+WI154iwvXdsBTa89WHMK4byE06Nrc52cBJyuqDEI8e89qwdNlri73rQTXH4hB3fuBEySdRkzkzm/Zp/+oLfe+u7O9zG4oQC7pXbY/sqj5SkFTlZIqGPgjoeWTJXysVOFzEJxZ+bOpwWsGg1OFA5kaHw6s1Odm6ZFvI/QHIZxDda5dyIuIOBH4MzGx2ZUouCFC17CN86qkUal4FT9JxxHj60uZqs5soppVLr5ClJ6/iLxKz9Nge17bY/tw3U88C89KhocdiOq3B+cYLjPR5P/zXEkDI+wbXvd1fJQwPKxdczytSDxrDyPmVbOJnYn5WB3n0a5gV1e5ShiVSkYpFa1IVzIiq+fdtLEWzmpqU6Rlb0JP8nzbz5a0PlPyN7MKje7w+9eAotpY/eVhFq4el8O3JHAI8TKv57F/HnjPbFnuS0PS5oTh5js1Q9x6wAq5A71/JSiqJb0HONf2WxRh+B+1/bLZ5lPoib0D+IlDa2sdwpiZlUqXuC6wnVtOeRDXVoQW2U1M3U+vzQ1VlfTe2up9ie/LbcK+JV1LRDWOYlCq863Vb7sHpFiMAknn2d6i4XevYGqCuARhRH5/m8FsF7kkXT7ofybpCvekhTbknEcYRapoh+8CR6fJwWLB1eW+leCSdLHt/5eW1ySqjb0SeDCRgr5/br8SV1+vcu+2Uqj/jkXFJ2ln28dJerntU3v2LbRtBq7X9tm8CuGQOdl248p7ClmEKwkDF0yfONvtKsw2abfJObukijqrL7dsbyBXLnf9GZgcT78nCou0SpWS9HvgCAYYLWwfnMFV9NpOnNcCT3BKlR+R60rbGxboVlFoYT2rrxP6qrcU4t+S0PzbPa1v6BnSEiX9iindol7YdlbFZknXA+v1zuPSNXyt7XVz+EpBkX2xOmFA3pGp37sicKTt9RcDrsqo9AxCNqTCfOB+2/+WwbUWEWH8EeCdtV1/BXa0/famXKVRj8gCflnbNR/4qe3G0igK+ZJBaPVukvRz209RZMFs5qgiepXtNpq7RTExUDXEgAfjCkSY3a62b2rJuyzTc5/vacFRn4RBzXsIHJYzSCjsiez1dIxq1Ov1qFV9O9e1ctwNuXqNKRXXT5xZKlzSnxl8/vdr4BXtx/kQj64LNBY+SU90fqnhQVwfJ1KnTqamF9TGeCnpIuJldF1aX4+IZth0hP7NI4ypd7Y8vqhBKU2C+/GNVN5+QFuNJyk9v/M+4P/ck76c0W7nuCRdRlSw7Dcw/qHtjVr2b1liInddm+PnAldpvi5xDbpHkhfyFTkT6Z7jF5pUj2qQmKG9otyZz45+v7WIUSH9f3+aaWzZhyjg8hdCO+ortv86al8atDvjOUuGkR2IyN7eSWLWe7PHuDrtfOee/1GP78NX7HpsyqVmEWzVd78MvMX2/xXo39HAf9u+elSuUtB0Pav/nclwlMG7CXHNvpzQcjzd9qdKcLfszy9sr5e7b9xIBvediYI2P2fqHr8LOM4pzXeOcxU3Kg14lwx0Li4KKCRMVqZQRFbDNrex3ajQmkJH9XVEhtJziEjYB9l+/jj6loOJgWpESNoOeKPt52Ue9xTgN04pdJJeA7yMiLR4X86FO2ASvAoROrm87cYVWQp7IiujHkw9yFob9XoiW+p9+3finC0kRDqE67/6bF6FyLs/INN72y+9bRXSg9z2K5py1TivJ8LHjwXObGvUGwefpB8TZYyPA77oESqZDfAItPUELPQiavNyUuiJvZmImPw54R063PZHW/SpqEGpZoyeVmFwHN6OFpOUjQhvGMA5tltrpnWNS9JNRDWoIp7bxPliIsVgKdtrS9qYiO7KrpDUVa4u960El6T/tj0wFalFnyqv8paklPiE+cADtmfUFmrZ7mxEUG0LPJ80tqjtWpGITikVWdvK2KGIDH4lkXZ5M3Co26WrNW2vyTk7m8H6TFnvTUl3E5VvBTwmLZPW17HduFiPpPuZcjCJ0PG8Oy3befpHRaOKJK3SZDydcw9I+h6wCZHeXS/Isl2L/l1ByBLckLiqc1Y06iuzTw8w9f+sX29tdNPWI4yqOxCO25OBd9ju67ybgWsJYNnKYKzI0Kh0Ay9xStPL4PsqYSQ7oWf7q4Dt277zSkHSyxyFpRZnrpGNSioYpbQ4oO37XNKzgJWAs9yy6ENJTAxUBdDmYpB0MfBvtv+kSJn6X2BPYGPg8bb/s1Dfinii2ngih3C1MuoN4VsF+F4hj+tDgO+WGhyM8KAQ8G+EFsRTgFMID8UvWvajNN96hNX95cAFies7LXjWcU/VoH7bGnIdQxgRKl2NnYhKkrtk8lxqe2NJOxE59e8GLmrjhRm3QUmpwqDtXUvw9XDnDNj3JrTwKg/aS4mqndne0a5yNWxvAzcUklVE/D0HONtTqTZt0wU7ydXlvpX+nTO0tZ/tDzb4XuVVXsjbClzulpGEDdpd5BFUkp5ETPLfDxxU23UXEZWYHXncw78k8GpgO9svasmxAWGkejXwLtunjNKnGdoqnoo2Q3tDDQQeT9p4oyil2Yh6yLkHJPU1FNv+fot2HzOA65f9ts81JGPXj4HX274hbbuxpVPnMOA2J3275AS/khhbXWx730y+1YmxwT2EBhhEdNCywEtdKJ2xDZIxbmWnqs8KfdXXAm+znaUj2kWukkYlzUKUUpeR+z5P84gtibnKT9wV+R3bk88IHyIi6NIWx11WW/4MEQFUrWfzNWmnANclBbkuLvx/KNm3IlxEEYKRzz8hHn4LcAdR2WKLLvARmj4vS1zXANcSk4GRrgPCGNSmP0sTwq+np89bgaVb8FxFpB2eCjwrbStyHxEGr6NLcNU4ryjJV+NtfB8AlxPRmtX68sSEuk27neRq2F7j5xohSjntPI/wOzvJ1eW+lf6dpa6L9P23A6sXbP/BfbatVVt+z6LmA76f/v53gd93F1F6u/75P8IRs1om1zqEyPfPiKIs/0lEbRS/LnranfF5S0RxVcvbjKkf84CdxsTd6D7IvV8WZd8Ktrdiz2f+ov7Ni+h3voRwwP8GOIrQ/PtVS65LgCXr6+mvCKmPtn18DhEgsCewdQfO2SuJFOPfEWP05wK/JQT1/99iwrUSoW12ErBW7bPKbJ//uf7JeZYRzqErgIPT5zLgwNn+DbYnVfyaQv0riqwMvJgwMOViCYWq/33EA/uNtX1Z/xf1rzqzMlF2NksgegB/5Yn87ahciW8FYhBUBJKeTeTNluB6JpkVBlOqSC9WJh7mX23Zj4cQ/79XEwPtPQmRyo0Jw0lWyfGSfMnz/TpCQPO7wItsXyxpNaKSx4x56AqNlg2AlVJEXYUVCW9YFpJX5xiH16Vt2egKnyOE0S8Dzkme5lYaVL1I52mztserUIXBdL6+Z3tY5cRX51AyvYjE/fRPh5vLXE3ba4qrJO1IvAvWJaqBtilj3GWuLvet9O8chtxrbgXgO5L+RKTEnOrR9G7OkLStp1Jj1ieMLxsC2O6X8j5uvlUlPQ3YVtKJ9JwjZ3hx3bBSXkPcQBi2v0Y899cEdlOqmOS8CnJI2s5Jm2WGCKIm6ZvPI4xnAB8m3r+toKhWtjshevz1xLUHYRy9DPhiW+5hzTb8XskqfsWgsnqjV9GjaytpOUJW4I0eg67kbMD2V4GvSlqeSJfdh/j/HkHou+VE3s/z9CjSfVMbTvOKLGhKJ/fS9DHhuJ1tHAhsavuGNL87D/hP22csLlwOaZC/EKmfE8wedgI2ctKqlvQh4l44ZFZ7RaYh5F8cvQMgA7cCr3I7weiTgB9J+iMRXvpjAEmPJdNAAnysT99uB84mJtuNIekuFtY4uIewlr8pk6uoUU8Li8FDaD39jggxzeG6ZADXn8ibmEOkudVRnf8jbX8tk6vCeUTp5pfYrhsGL5R05CzzfQo4GtjfNVF/27+TdGBDjscBLySqXdXTL+4iUrKyYPt+SWtJWsoj5k7b/iTTS+jenIyg2ShlUKqh/hy6D/gGkK0FkM7XA5JW8gANMecJox4L/EwhuAjhNf18br86ztUEOTnzewIHELojXwK+TftBQVe5uty30r9zGLK0FBzi6gcnZ8AriLHCb51R2agHHyWMSi8g9G6+SP57rjTfQURl2UexsFPBRFRDIwxw0k2R5aUsvJ+p/1f2pLcPDmTKafN9BpRi96JPRTmRcOydR1ST3p8wlrzE49PaanofLEGc+3E6E3rRpK2H9tlW6Y0eSdyrjWB7jb6dkLYnxu3bNuXqMipHvKOK95eAL0lamRg37wvkGKiWkjTfSWuqMm6lFK9sxyaR1lcZCau/KyiKorQuflUA/3BKh0xOzetbGpS6zDVBCygKN21ue5gz7aYMyt8R905VTG1pIitm1jHRoCoASYfZfkeL4zYHVgW+kx7elbbPCtWAqmnO/pA2SorZrWa78eRaC4uaV4abc9oY9fpoJhi4vTp3mVy9ef8VV2vB7wHt7OHMkvbpODndnBqxktw4+Gq8KwNruKWItaQtbJ/Xs62VkUlReebxhDe4XhEw1+O9EvBe4Jlp048I8eTsa6PnHriPeHF82S3Lb/dwj1ph8GuEBsx3mX6+eitcNuWr8tgBfmz7kjY8XeZq0FYToeMTbb9a0t62Dx+xvU5ydblvpX9nwzbbCnU/kpjIvZJIAWqtyyPpZUTa80rAy21f25arJJ+k97SI4OrleIDQovljtam2225RdKMU6v/7ttdBjeu3hDFPxLmf9m7LedeppreWImp/T1S0HPndNKTNRjpbTb/XsM1GEWxqKKY+pJ2SfV6kemTjROHz8jZCS/XNVYRZmhccAfzA9mGF2imqk9ui/eo+r/C2+nrmfd5JrgnaY9T3SOL4FDHvXZPQJf5uWt8GuMAtCj6UxsRAVQCSfm27b7WuAtyjlust1rfCXK2MekP4SvatlYDjAK5W/VLBSnKl+RSVhF5MRGBeBNxGCOtlV7NKXDtXnipFdcujbW/UgqvXIAosiEbI4fkyMdk5Pm16NRECO9IDu5ChseT/sW/Uoe3j+20fwrMEcJXt9XP7MFe4Mto83/bmM3znamKQfSawFQunNuVUcO0kV5f7Vvp3Js6HOonGDti/v+1DM/jeQlS3exiRgn2KW5Shl/RxplfS3YZIYbsRIPeZXZqvxvtiphwCZ9v+Rubx+xBaUX8h9G6+4pR+2LI/zybS3apnxzXAp22f3YLrWiKNZR5RwGNHatdcTnTXoHdcjavxu653bLkojCJNJ1YZ35vRgVv/XeP6jPBAIgAAIABJREFUjQoZjIvajFv6cC1PjKc2Hr1ns48Sk+kevjcT0X5Vlcm/Ah+yfUSpNlI7s2YkLHyfd5JrgvZQFAs4j6hA2cqIM2j8n2D3VLacDUwMVAUg6TceEK5bgHtUj1uxvhXmKmrU6/DvbMWlgpXkSvNV16SkXYnoqfeqZdUdSf8OHE6k1K1OlB1/feagvXTkx6W9g8N+2xpylTY0lr4uliJSdCCqC/6zJc/XgD1dQDejq1wD+NcD3mm7cVqqpL2A3Qgx5ltYONqjsXG8q1xd7lthrhcBxxDRkfcTpclH1rGS9EHgZI+YaiXp9cP2285Kdy3Nlzg/CDyVKc2jHYCf295/8FEDudYhos3+A7iZEBXPOoeKtMVPE6l+FxPXx/8jUvX2sP2tTL6zGZzaZs9SdJek+5mKnBVRuezutGzbK2ZwFY1Syvhek4jVkhFsw/RGL7A9dALfw9UvUnllIg39SNtZ8hxdRZ+om2loG3UjaX46/q60/giPptNX516BEF1fLIyEEyxeUEjxLE+MO/5Oi2d2jWuheVOpudSomGhQNYSmxPQW2gVjzZMf1YJY0gJZkqv0Oevq72zL9SBJDyIGK5+2/U9Jo/SrJN+SklYlPPwHjNAnbH87ecS+S6RnbGL71kyaTRUC7bso0vxGjYi4R9KWts8FkPR0QoetDZ5g+85kUDqTZFAiNFzaoNj/UdJWRJTYTcQ5W0PSa223KaywMiE6fQHT0wX7DejnHJdCC+gwYDWi8MFniEnsZiysATgTzrD9SUlH2N4t89i5wtXlvpXk+gDwDNvXKooffAR4Vluy2jjjoz3rAPc6M53d9udTJOGxtl/Ttl/j4kt4AbCx7QcAJB1PVOvKNlDZvjEZpZclIl/XIwRfc/BOQofpstq2SyVdSOgvZhmobG+V2f5ASDrF9vZp+cO2963t+47t52b0a4mGbTaRmSiqs5Xxzm4yjlxW0iZEBNsyablVBBtl9UYfNoBrF48xDX0WMBY9Mdt3SXpwMprvSMg7rJbDoeE6udnSHKUg6aPADb1GSklvAta2/e65zjVBe7hsUZDXEkECdezcZ9six8RA1Rx1Mb1ejCTKPCrUXzwcoq+PyOSq8lL7cT04k6uoUW/Ay6TiyxIzHeC9astVVXapflM9BaLtg6R0JbmSfO8nBIXPtf3z5LW+vg2RpPcQhq5nAk8Czpb0dtvfzKA5khgUr0Pcp9MiItL2HOwGHK/QohIhnL9zJkeF0obGkv/HjwHPtX0dLIgGOokQcs/Fe1r2Ya5wHUXoXJxHVNK6lDDu7eR8zZbTiHO83kxfnMNcpfm6ynWfk/aS7Z9VXv0RUI0zYOF35JKKSnLvtt24wpqjIMI6kh7UNkJynHwJDyaesxCaVlnoiZz6DZHmd6hrRTwy8Mge4xQAti+XlDWeSn07tIoGk7SN7daV94B1a8vbkKqYJfQaPEphoMGpBg1YHjeavEtvZSqCp75cHd84gs32qwEkbW77/Pq+fttm4HpPOm5B9FmNa6Ftcxi32n5/KTJJyxL3+Y6EhuZ8YnzVxrFWuvhVKTwHeFef7UcRFUZzDEFd5ZpgBCj0f9elVhwgx7ksaQfiHlpH0tdru+YThvJZx8RA1RC2156lppu87F9YsL0LW+7rh9JGvWGD/1xr77DBXG6FwX6VXUaCeyrJSfo18Oza+mudoRVUks/2qYQuSrV+I/CyGtd+tj/YsGsPAZ6aJhLnSTqLqBDY2EBV/baZIiIaeoJJKSEbKcpw49HE5IsaGnv/j4xQYRB4UGWcSty/SMa0Nv36Ucs+zBWupW0fl5avSyHQ/QZqTTBP0v7Aev2M7pkpD13l6nLfSnI9vIdj2nruOZtpnCHpYcRz5BLnaVL9Evhxii6qRxJ+cvAhi4zvg8Alkn5IjBWeSf5E5wZigvQ14vm6JrBbMujl/h+GRallF2QhDNpVNNiHiWjhthhmkBmXXseijlIqipIRbDV8loWNdp+hnXOnHn1W4YA+2+YqWo0p+kEhmfAMovLfp4AfEBE9Z7fhc3c1k5a2F9bfsf2Aqofa3OeaoCUU8ip7ExVwLwU2J5ynOeniPyUKYzyC6VkAfyUMV7OOiYEqAwq9lp2ADdKmq4Av2b63APfqRCgswO9s35eWt57pWNs3S3oJ8FjgCtvfbtsP28enQfBaxIP/jhG4ihr1qpeJZhCkbchVea8ePMpvTFgSeANx/i8Hjrd9/4ic05BeCvfVNu3NlIj3rPP14OXEpKNJP/YBkLSc7btt30x4hrPRIF1nqCd4UIRey0lOdUxJgxIaUGGQEAfOxYWSjiaEeyGebVlG6BRev4qTppZCb2JFYnLyTttHznWuhN5J17319cwJ2CsJj++StI+w7DpXab6uch3Vw9G7XhS2/yBpX+KezRHw/XX6LJc+o6IYn+2TFDpNTyGMLPs6P837/UwZaLIioPvgMT0e5QoiPxq3NJarGYKWrT2DKg2pcWCRRillYsZJcckINkUa7+bAw3qi8Fck0xCj0N98HrC6pPr5WhF4oG0fO4iSv+UJwJ+JogXXpGjO1obZAff5AridrEAJ3CNpXdvTMhMkrUu+3ERXuSZoj72J9+X5tp8taX2gcREWCLsBMR9ZsteRK+nYcl1tj4lIekNIegJRvv4nRGQQhLfk6cB/2L4qk28/IoLh/Wn918AdwFKEgaNpBAqSPksYzX5KGLTOcMuyzckyeyjhIV2bKLU69CE+hOvhhOewMtx8aJRoFEkvBI4F/km89FoL0kralimDzN8TV+Pw7B6uk4iB0o+JAccNtt/ahiujzdKVUYrx5XBJ2gL4PFHdbk1JGwFvsv2WEn3J6ZfGUKFkkEHJdhuDEipYYVDS0sDuwJZp04+Bz+YY3CX9HHie7dvTeiWgvwzwbduN9Xi6ypWOP5vCQseStrV9Zu5xc4mrNF9XuRY1mj5j65PzQu0W40vRpHdUz8JkuH8JIW7+aduzIp0gaeizITcqU1Mi0QLeSo9gdI7jI0WZDetba+fHkDYXeTUzFRRdV8EqfukafQ6wKxHpXeEu4Gv1iOQGXJsQRuaDCANrnesHozphu4LS10+ajO8AvILQLX0csKFbCKRL+gOREnwS8DN6DJ4lo7kz+7UtESF2CFPzzScD+wH7OKNQQ1e5JmgPST+3/RRJlwKb2b5X0lW2N5jx4CmO3YC3EE6XX9Z2zQd+anunsr1uAduTT4MPEX2xTZ/t/wb8sAXfxcDytfVL0t8lCG2fHK4rgSXS8nJEVa+2v/NK4GFpeR3gvBG4ziJEZP+deKgdN+L/4HJg/bS8GfCjEbguAzZIy08bkeuK2vKDgItLX3/9rp+u8uVwEYOCNarrP227ci6cs4Ztfhk4ON1L6xDGqtNH4Lu0ybaGXNsRIduj/L4Le9b3ry1fsDhwjeGa+ERtee+efcctDlxd7lthroOGfN4zxmuo0bOs4++JnwGrpeWNicnm2wnj+9Et+J6dnrdXpc9pwFYF+7sGEX2Ze9x7h33GdH0sNFYdgeuSBt85tGTb9ets1GuuJFeNZ52C53eZ2vJKRGGV4tfEbH2A3wJvG/QZkXtTIj3p18SkOvf4JQinclWY4RDSvGC2P8CGqV8Xpc/xwBMXJ67Jp/W18RVCt/F9hPba14BvZXKsBDyaMM6uVfusMtu/r/pMUvyaY3X3CQ22/T2FsHg2PL0iz+Fp2/0KEcAc/MMppcz23SPmAv/D9h8S140pyqItVrVdVXn7tqRRdQhKCtLe7xT1ZvunI3ItEIp1iGCPQNUYpRspyZfFZfs3PeesaHpkU2g8FUoeY/tltfWDk9ejLUpWGHwR8HFJ5wAnA2d5KrW4KaYVTrB9aOrXPPK12brKhaR32f5IWn65Q4et2pcbVfLM2vJrma6f96TMrnWVqzRfV7n6aRItD7ye0NdrFclcEEsoxFT7PpOdX+G0JN+ytn+Xll8FHGP7Y+kezXpGSnoBUXXr/ekjIjrlGEl7uKVnXyF38HIiYmM1YmKQBc+Ozs2MWldNo5RoIDNBWZ0toKjoeqULJxbWjMMtUveBOyV9kMhcqIsUN66iWMM3Jb2UMJZcDPxJ0g9sv7MFVxcxlip+ALYvAi6S9A5Cmyr3+PsJR/pZaa6zA1Go52Dbs1bFL/XtSuL9NBCSPmV7z7nKNUE72H5pWnxfiqpdibiOczj+QkiD7FC4e8UwMVA1xzxJS7sn/SWljLQ5jyuoVgXHSYA3PSRXzORaX9LlVZcIDYXL07Jt5wy6HyXpk4PWbQ+qftcXPYPZaYPbFoPjkoK0D9d0DYFp684Te91IUvVbBMxP69X5H1TNcBT8ZLb4JD3d9k+GbDu1z2GD8BtJTwOsEOjem9AXGAdmGiCNo0JJSYMSFKwwaPt16ZxvS7ykPiPpu7Z3zaD5jqRDbB/Ys/39hJBpDrrKBaFb9JG0vB/Tr/H65KwJSk6+uspVmq+TXLYXiIsmJ8fewOuIKnIfG3TcwI5Ja9r+dYOvNk1/W5+FK5tWMPmaSiX56hzPIe4rHIK7md3incBLPL363qWSLiSit3PSWOYT0aU7EpUeTyccFI/K7VTiO8X29mn5w7b3re37TkujxozNNvhOXZx7oD5ji3FaCZQUXa/rwpXSiPsCYax8KZEm/1pCe6sNVrF9p0I38Qu235PG74uLger3LlTFT9IbgLNtX58c8ccQ9+rNtBwHpTnXC4gx0KMJzdBsQ/Qs4en/AlwT9IGk/0fIcxj4iWcpJX6cmBiomuME4MuSdneIiyHp0cTD7MQWfKcBn0vevbsT3/KEF/C0TK7Ht2h/EHpfihf1/VYzrMTCg9lqYNFmcFxSkPZYplfy613PwVJNviRpRTfQ4EoaGH92lLXenvD4/5KaPpDtPRq2+TbgL7Y/37P99cB825/I4Uv4FAsPZhdsq6JVGuLNRATD6sAthPFg94zjp0HSEkRVigXPttqEbyZP8DgqlBQzKKW+lKwwWEX8nUncj8sSGjA5Bqp3AkdLuoFImwXYiBBbz+HpMhcMN2rkXhvzkqF+Xm15gRF/MeHqct+K/k5JqxDpKjsR6Q7/b0g0ykz4Kg3Ez21v3pDvahfUKizM9wNJpxCVhFYmKnIhaVXyq/w+ssc4BUB6hz4ik+s24ALCgHOubacIl7ZYt7a8DbBvbb3tmGMmNBGX7XKUUjHR9TFFsD3M9ufSfOD7kn5ApKy2wZK1SL2DynWxMygZObU3cFxa3oGIeF0H2IQYR2ZFUUk6gUhZ+xZwcIoOmmCCTkPSQcTzonIwHCvpVNuHzGK3imNioGoI24dI2oMorbwc8dD9K3CY7TYpfu8h9Jl+LenmtG1NQjD6PZl9u3nmb4Gk82xvMQNXo0puTUI4bT+6IdcGbiAy33SgIWk/zyAy71TFrwHXgtSeIVxNU9LOZobJh6TPEC/dpSX9ggiNPovwSBxDTIJysBNRdaYXJxKT9U80JVIImj+NqGBTH4CuSLsJLA4h0IG/qcn/svbdPQldj/9jqnKMSWk7DTzBxSuUlDIo9Q74a9urdrLTFBSCl68AtiKuzaOB7XM4HGnKO0hah6nqplfbrosuNrrHu8pVUQ5Y7rc+E3oN9/VogMWFq8t9K8alSAveDvgfQofjr5l9WYhyxOPnEvYhnj+rAltW0eTAI4EDBh7VH/1SLZvs64f9iIjJzwInSTo58/heDLum2txXpdDZKCXbW41yfB1jimCrrtVbFdX4fkek9LbBB4jiKefaviC9s37VkquLeG4y4vdFZoTefbXnxAuBExyFUL6XnsW5eBXxfNgb2Kvmh6yyH3KzWSaYYFFgJ6I40t8BJH2ISItfrAxUkyp+LZBCwLF9VwGuZYkqdxD6N2Mr1amyldqKVeYoyVWarzDXjOdf0tW2n6BIHb0FeLhDl0zA5bafmNnmZbY3GrDvihy+FNm1FRH1dGRt111E5cjr+x03CnLOf4qW2SwNWNq0VbLaSV+DUoVcg5LGU2HwJEJ76sze1OXS6PA92YhL0v3EQLYq5353tYsQuc0qMd6wb02NZ3OWqzTfouaS9ABwL3Af040NrSY4km4j0gP7wvkp9jvbPk49umlp30LbFjVfwzZndKxJuoMQi11oF2H8WrlFu+sQhqodiCio9wJfsf2LTJ5rE8c8IjVsx9QvESldJSPgqzZP9wyVXTWGyqSloJqun6Rt3Ef/NYNrwbir93nfdkws6cWEUWkt4DOEk+59trNTwyQ92PYducfNFUj6FXGd9U0Ltt04k0KhY/sC4M9EWt9zqme0pGvGcS91GYXndJ3kmmBhKHSnXlo9NyQ9mCi+NGvP7HFgEkHVEJJeRBgIbrZ9l6SDJL2MeEjubTvL41FF5ti+R9L6Hk10tym6ao1cbAS/Z0CT8/93ANt/l3Szp8TvLemfww/ti3mSHuGeErwt0h5wlNz9kaTjmkbtFUDO+f8NIfrXCrbPlPQSIj2sig68CniZ7Ssy6UroXNT7VjxNwfaiFEfs6j3ZiMt2qwjBEXEiDdK95jhXab5FymV7XqG2KtzDaGn10+CkbcnCummDti1SvoZYZuav8B9D9h3WplHbNwKHAodK2pAwLH2LKYdiU/yewelqWbpFkp45bL/tc9Lfocap9J2tctoehjFEKZUUXR9HBNttDpHhy0lpZZKapt324iJJFwDH2m6jj9hp2F67IN1BROT/EsDXa8apZwE3Fmxn1qGQq/iw7XcM+drhQ/Z1nmuCPCgKspmY51wl6btpfRsiLX2xwsRA1RwfIKVKSXohERq6A5H7fCTw75l8JUV35zpKG85K8i1qo94gLQfRTq/io0SVmLczlcqyadreauBOpB/+DyEoWdd6Gof1Puf830hUYPkmEdUQBBnRSm5QoaQhT1GDksZQYTANqD9FaNgtRQz6/jamsPau3pONuIalKAD3enpF1lKY00a9WeKbNS5JWwLr2j5W0kMJjb/cVJ3b3TDNvmGftgWeD6yu6cVPViSivmaVryFmvEeT82QhSFqDGGv13Z+BW4ED2jgObT+7yfcaRgr1E86u0tjXICPVvmSUErOjs9UUy9VSGau0xiqCLbdidoXPsrDx+jPE2CoX6xLzhzcoJB5OAo53Tzr6XEUyaCzrlP6cxh2VbuslOZkotr8haS3i2VrX+buQSBeu2hz1ep51pMyJLWf4znFzmWuCbFyY/l7EdCH/s+luAEprTAxUzWEnMXNCc+Lznipx+pYWfCVFd9u02SWu0ujq72zCNUzL4ejcBm2fIOkPRPWyDYmH2FXAQbbPzOVLOJUwyh4NNNXfaouc8//r9FmKhsL1fRuU1gPewQgGuDEYlMZRYfDTxOTtVCKV8TVE1aoJFsZFDE5TWDJpV7zb9hcLtjmnjXqzxDcrXCkF98nA44iCG0sR6Vy51YxKV+K5hRjUvpjpkVl3AW/tAF9xaEpwegdgNTIrcqUJ9IeIghb/RUTSPZSIRn6N7axy3hmYMVLI9ot6+vp0Qsz9Vqaifpuiy1FKJUXXS0awPRXYgtDhrKfbrgi0SvO2/QBwJnCmpK2ALwJvTVFV+9me65ERHyYKD1QO+ZOAK4nIyIuZbsycEbbvI1L86tt6HUSjXs9dwSWSvk6M0Rb8RtunDz5kznFN0BCV80rS3ranRalJ2nt2ejU+TAxUzSFJKxDaI1sTHpQKTULQe1FSdLcvJM0DdqhNml49Il+9BHbJEM6RB+WSlq+9pEZKM5C0rKe0wFo/cBXC2LvZ/nDaNGOYe9PIG2WIhydD1FBjVA4fIVR5RMPvjorG/8vq3KX7FLcXLC5hgCttUBpHhUFs3yBpiZRKeqykS0jl3pug55kwDDPe413lgpnTFNKk+JykvXB1E84JFiu8lIimvhjA9u+UtCoz8elqQdLTbf+ktr6H7U/3P2wgPm57a0kbFYrMKs3XBDM+39K53o5Iw1uPeG+vbftRLdr7NGG4WYmoLLit7fMlrU9MrsdloGr8HJe0NVFMx8ChHYgWKR2lVEx0vXAE2/KEsXJJpkeG3UUYRbOR9GN2IhxEfyYMvV8horFOBkqmyM0GtgaeUlu/w/aL0rjlx2Nqs8sO9BwsA9zO9KqVpt28pKtcE+TjtSw8B9+5z7Y5jYmBqjk+Qajk3wlcY/tCgPQi/n0Lvo0k3Ul6gadl0nqWwSsZQnYHVge+TngO9gDeTpRY/yIsSF9qwrdF4jrH9m2SnkRMqJ9BhJGPFMKZIlTeafsNiatx7r6k1YmqP5fb/oekhxPVgHYmvKXYPrQh1yMS15W270tpGXsBryd+P7b/q2Gf9k/HfJUYVLwP2AU4pfqe7T80+pHN8HKgqUGpCF8tzemMFDX4Faan0jWuxlLXpRhmHGv6v0w8GxLe7lXS+h+B1zhfNLmEAa60Qal4hUHgbklLAZdK+gjxHMvV1PkqDTR/Gt7jXeWaEbb/IGlfImqmlAZSyWiarnKV5pstrn/YtiRDOExatvk24hqCSL+tX0u7UDNgNcSqkp4GbCvpRHombs6r1FaUL0ObqIlj7TZCg+NAohqaJb20aV96sGSlBSTp/bbPB7B97Qi+gCaY0TEp6QVEhcO/AAfaPneE9joZpZTaLq652ABNIth+CPxQ0rEOjTIkzc9JU+uDnwNfArb3dG3P8yUdNQJvVzAvRT1V2BcW6KquMKY2F4t0J9uvW9y5JmgOSTsQTph1UgRbhfmEwXCxQmmBz8UWto8BnkUYL55f23UrkH2z2l7C9oq259teMi1X67mhwicSqQVXALsCPwT+E3iJ7WHioQshpSYdA7yM0C46BPgO8DOm6ww04XqSpO9IulLSIZJWlfRlwiuZHWUgaR/CSPgp4uW9K3AN4aHLyv2XtGfqw1HAzyTtDFwHrAxsltm1EwjP11HEhOLnhNdrY9u7Z3I1xWzowFxEpHe8ltDC+GnaVm3PQd372Mrz2Af/A7zN9lq21yIMtG0GeGdIeku6XlepPpkc9yTj0TSMYFA6iEgB2FnSE9PndcA30742eDWhWbIHEaa9BnHf52Aup9MWhe2vj9KupPXqE5JRjGdd5epy30bkOkXS54AHS3oD8D3aPXtKp/4fRETaPIowGnys9mmjQViSr5E2UUPH2n7A0kRk+36SHpPZlzoeqC33Pqtne+J7BnHu7wPeJenr9U8mVxWZtEJtuf5pDNvPHvapvidpmyZ8kk6pLX+4Z9+4hMSbROodoChqdKOkpVJffivp/yS11eBcz/Z7bd/cG3WZ46DrMJaq/66a8Xcl2mWf/MtA0qMkfUXSbenzZUltokI7yzVBFn5KvGt/wfR37zuIYJTFCpMIqoaQ9CrbXwBuUeT9/wTA9u8l7UG+Z7Mk1rH9xNTPowlv1pq2/96C6wXAJo4qcisTldE2tH1TC66jgCOA8wi9g0uB44GdWvbtjcDjbP9J0prETfp0hxZYLnZLXH+U9GjCOPUMt8v3f6jtA9PyNyXdQqRWjlOfaZHrwMyU5lS6vRZYPnk4owH77JaRDJVIel2Q1kDjcshMGZQOYUqr5cnERGqf3A65bIXBirPy1t4DtPVY94ol97ax16B9c4grB02iIJ5ETOZXIyK9PkO8PzYjBhuN0VWuLvet9O8EsH1YmnzfSTiLDmqZdlU09d/2acBpkt7TJBp4EfOtJGlgtTln6JnY/gTwCUnrELp6XwVWS1GNX7H9i4x+FYtuz8RNDb7TKF2tCboapZQwG6LrTe6vHYnKjhApeUsTKX/rEY7dxs5NSQcAX06ReUsRzqanSvo7MX78QU7nO4yjgJMlvdkp7V4hdH4ELXRVG+KmMfEuahxLRNdVTtxXpW2NDL1zhGuChkhj9pslLemewiCSjp2lbo0NEwNVc5QOvS+Jf1YLjgoLv21pAAL4e3Ws7T9Lur6lcQoizem4tHydQtitny5PTt/+lPr2a0nXtTROVVx/TFw3Ja7WYpTJQ1R54P5IaDIo8d858MD2mLVKWgMmFX8BrrB9W0OaKkRVLByuiu0XN+1PDTdKeg8RUQjx0swuPVzCEDcmg1KRCoOSrmDIYNz2kzLo7mG6WPIo6CpXaZQ03HeVq8t9K/07UaRHndzSKFXH4yVdTjwXH5OWSes5BvJpsP1fkl4MPDNtOtv2N2aZbyXghfR/97TSM0lpV4cChypSvncEvgU8NoOjUSU8SSt7eiWxQd975rD9ts9Jfwca62rf/VHiXIap33RDm+tW0im2t0/LH7a9b21f0/TL7GYbfq+06Hop/MNekLr/POAk2/8kSr7nZj70GruWoqWxq8uw/d+S7gbOrTkM/wp8yJlSCiXvpTmCh9muGx6OU2SSLE5cEzSEpN2AtxBzpstru+YT0VWLFSYGquaYjap7TVH3+MGU109EqndO2fi6sUDA2nXjQabhYBlNiWUC3Ftfd77+xaN6oiJWra9nRkU8SlJdJ+GR9XXbb+tzzCA8hDA+1K+DKoXRwJoZXE0xkhD8iHyvJyrZVNFKWxHGgLUVmh0nDjqwhnrqaZtUk37YhYgEqiY2P07bspAGmrtRm3wBn0sD0cYoZVDq6dvIFQaJSWEp3O5yYsld5Sotul7ScN9Vri73rfTvhBggfkfSnwgNwlNt/18LnvUZwwRc0geBp5L0KIG9JT3N9v5DDhs33822s5/PGbgVOKDtb2yA79NMb+6dfbYZeBKRVt3IIAYgaUnCqLELcDMx5lgjec8PyHxHdTVKCcqLrjfBTQ2+c6+kxxOaZ72FUHL7VdLY1WnYPhI4skr1c9LskvSIzOdksXtpjuB2Sa8iijNAVCZtqzXUVa4JmuNLRMGrDzK90NJdztAAniuYGKiaY+xV99qiqcevIXo1q0YxHtSFM2G6eKaZXgGiCXpfTqNESPRWKmtcuawXblcpqC9UWDy8NF/CksDjq4GFQmz+BMLjdw5TEUzD8KuGE/7GSN7sEqlbRxAlo6tKna9O23bNJSpkUKqjRIXBVZ2EfwtgcRC4boKSouuhnvspAAAgAElEQVQlDfdd5epy30r/zipd6uCUPvgK4EcpkvnfMqmuZPB44l5JvyQMEd/P5H0BoYn4AICk44FLiOIebVCCr5hjT9LmwIeAPwH/RbyDHgrMk/Qa2+OovNeo/7ZfNO2gkIg4kBgP7dn3oMH4KGEMXbs2yV+RGKcdBuSUGu9qlBIUFF0vHHXzdqIQ0UOBwz0llP58QgM2ByWNXXMCtu+S9GBJryciyB5PKm7U8PiS99JcwC5Exs7HiXvyp7TQPO441wQNYfsvRLbKDrPdl0UBeeFCUxP0QQpRvYEUep+WSevr2G5btacYJD0b2CCtXmn77BG4Rg4hHyeUqn/Y/msBrmUSV+vfmDxer2Tq/F9FpHxkTZQVZeo3ScsX2x6pIlhpvsRzte0n1NYFXGX7CfX2ZuBY0BdJX7adK85d5/qE7X0knUGfgXVuuqCky2xvNNO2plyEQekiagYlt0xNlXSR7ayCAH046uf+PNtbjMBVafMh6em2f1Lbt4ftxqnPXeVKxzS6rhtync3gCaBzjJdd5epy30r/zh7uRxK6HK8E5jsvXXYm7iWADYEv2t4w89jLga0qL6ui6MPZbftXgk/Sk2xfnpaXtn1vbd/mOUZ0SRcSxrGViGIZ29o+X9L6RGRKkXu3p82s96mkrQmBeQOHukU6qKTrCVFt92xfArjWduNCNpKuJSY68wj5ih2ZilL6gu3H5/avQZunNzQENeXbZqbzmMYFvVgQdVPYwdsYybhyHFPGrvel7c8HdnZKv1wcIGlZwvm9I7AJYWR9CVEp/IFhxw7gG/le6jrSPb2X7Y8vrlwTTDAMEwNVQyhE/QbC08vDLlJIWp1Ia/o7U1FFmxJemJfaviWDq28IOSGAlxtCjqSHA7sz3XDzGTfXKurl242Idqrnsn/Y9mcHHzWQ6w2Jq6rQdnvi+p9MnvWJ6joXMP38PxV4se1rMrjqxoMSBqqifInns0TaYpUW+DLgt0SE2zdcq9ozhKNuOBtp8i9pU9sXSXpWv/3uERNswHcx8HLbv0zr6wCntTl3JQxKPXzvIzyuXwEWTOicEd5b+NwPvL5aTOA6yZWOuQ3430H7PT7R9QnmACS9BdieSI06FTjFdnal2oZtvcn25zKP2YGIMPoh8U5/JvBu2ye37MPIfIXv90ttb5yWr6kbV0oal3vabNRHSS8ADiA83x+wfe4Ibf7C9nq5+wZ8/4fD9jd5j9e4GkUplUbLZ3kVdbMy8f/oZ8CaiaPf8/4vwEVuVnXyXwaSvgQ8g6gG/r9EFe8b3ELrs+S9NBcg6QLbT12cuSaYYBAmKX4NMcgAJWke4YWaNQMVIdB+hKd0NQCQ9BoiTak3bW8YioWQp4HAlwgv0Qlp86bABZJ2qkc1NOQ7EHga4bmtQqvXAQ6XtIrtQzK49iO0k57nVOFHkY51uKSHeEAq3AB8CtjTPWkEkv6d+N9sncFVWjx8HGLkuxNGqaen9ROIajSmeZWhYSmzWahFI21s+/D6Pkl7A1kGKsLQ9kNJNxLnbS3ahy+fkSavrQ1KPShRYXCeokLnvNrygnSVzL6V1ObrKhcUFF2X9C7bH0nLL7d9am3foc7QzOkqV5f7Vvp3JqwB7GP70hbHZiHXOJWOOSlFjj2FeF7sazsrVWoMfCXv0XoUxj09+8blhW3axzMIB87twLskTdM7y3wHX61IWTyhvlGhB3NtBk9jA1STKCVmTxsop7hLyaibpxHXflUY4PnA5YQW2xdtN64G+i9g7HoC8GfgGuAaRyGntvdkyXtpLuAnkj5N6Br+rdroFmnoHeaaYIK+mERQNUQy0uwOrE7koH8X2IPISb/Mdo4RqHTfrrP9uNx9A75fMoT8fGA325f0bN+YEJ3OqlIi6TpgI/ek4qXw4csyvYfXEQaNe3q2Lwdcmsl1re31c/cN+H7fKKAKLaKBivKVgqT7iRdbJXp6d7WLfGH/inMhb2pb77mkpYly8QDXuZZ+ksnzqz6bbbt1Ra5RIekmYkLXt3pWTt+6GvU0hgiqItGHpfvWVa4u960w14q271SkuC2EEQzRRaCI/L7DoV2BQgbgJYRD7dPOT0Evxlf4/zDsfbKM7cai05K2s316Wh5YqS85xWb8/5Z8B2sqWr5uMH8yLaLlM9qclSilUn0bR9SNpB8BL6w5cecTxqptgQtdk0BowPW/9Dd2rU2k8zY2dnUViiyDHQh9vj8SY6sNnVlIoqvj2XFB/aMc7RZp6F3lmmCCQZhEUDXHiYQX4DxCLHl/YvDzkkXhNZ0B8/ptVER35Xqu3GucShvbeD1W7DVOJa5L0ws9F+41TqWN90jKzWN3r3Eqbby7BdcSkpbqHZwnI0fu+f+Vy4qHF+OTdK7tLSXdxXSvdLZRyQV1HxTpJjsCa/dEiM0nRHOb8gxKU9hMUqs0BbcIYx8GFagwaPvRDdvawPZVM3zt8Qo9GgGP0VTpW5EX1dVlLigrut7VSLHSUWdd7VtJri8RVTEvIp6J9eNzIxvHgVOAlwJ/SY6hU4kKQBsR0dW5hR9K8lVVecX0Cr0iHIGN0fR9MszgVMOBTFWCHVipr6nxsZo0q4CuZzJAbSbpOUzJJnzL+aL5OZitKKVSGEfUzSOYHql3L/CINH7MdWatSjhLK2PXgYSxakvgQmDOG6hsXwu8F3ivpE2J8drPFYUknpbBU+xe6jrS/O0I26csrlwTTDAMEwNVc6xj+4kAko4mqoys2ZEH4zckHUWkGPwNQNLyRIWFb2VyFQshj8MWHhAmb3Nfo9oMuEXS1r2DsTRY+30m1+8lbeUeIfnkoclNVfgCcJqkt9j+beJ5FJH698WhRy6MBdXCNKJ4eGk+21umv22Mi9Mg6Tm2f5CW17b9q9q+BR7shvgp8f9/KNMHc3cRnsimKJ6mUMKg1INiFQYb4ERmrly3PuVSaLrKBZGqC0R0gEcTXS9ZEbarXKX5Osll+4Xpb1FDdEEsa/t3aflVwDG2P5YmGW0cayX56s/bC3v29a6XwkCDUw3DDJjZ0ABdT0nZup61SL1L08fAHaP2cQbMeE/0RCkdWCJKqSFuavCdxlpaGTgZOE/SV9P6i4GT07j7ukyuksauzsMhyXCRpHcQ2lSNUfJe6jpsP5CMqSMbgrrKNcEEwzBJ8WuIEikP40KaBH8Q2JkpLaw1geOB/TPD7ouFkEt6I/AG4B1AlZu8KfBhYmCbK/S6AfA14Nyevj0d+I8G0R51ricSxpsf9nBtRUTFZZUMlrQPUSa4MmLcR2h2faJfRNoQnmIC1uPgG9LOr22vmfH9oulE40CJNIVkzH4QcS9CGJTut93KoKSCFQYbtDXj9dInmq6Oe4FfEgPHGT38XeVKfF1NR+okV5f7Vvp3Js7v2956pm2LGpKuqDnWLgb2s/3ttH65M6v4leZb1Gj4TBtU3Q7I11mR9HEimvetXljX8x7bObqev2IqUq/6uwJwGbCr7Zty+tawzSZpdA8QUUqXUaaSbnHR9dJRN5I2I6KcAH7ijKqTPTwHE2l9dWPXWcBHgM/bfuUo/ZxtKIoRnW37ekkCjgG2I+YqO+fcTyXvpbkASR8iUiJ7tZ6yU8e7yjXBBIMwMVA1RG1QC9MHtq01c0pDocVUvYB/afvuYd+fgaseQn512xBySS8kDDcbEAOXq4GPtpnsJ75liAHjgr4RefrZg410vl7dw3XiiOdtZYAGaQSDju98Fb8B7fzG9hoZ3x9oOGtrSJO0ORG19nhgKcJY+Lfce7NkmkJpg5IKVhhs0tYovArdug2J+3PDEfsyq1zjuF4nmPtI76PlCEfHVkwZMlYEznKG/uA4IOlwIoXo98TEdz3b/5S0KnCG7SfPFp96Cnb0Iteo0bDNJsaWsxls3LYzdVZUUNdzSBvbAW+0/bxRufpwn257uxm+U1o7s9/4cEE0szMkAgZF3dCiMrWk5W3/LRlFFu6gfWdTrh7eIsauLkLSlcAm6TmxI6Hb+1xgE+C9thtHUS2Ke6lLUEEN065yTTDBIExS/Bqi6QtRzTQOikKRfifbJwJX1LZX0RpfyuB6CvBQ22cS5WCr7dsCt3mqYloj2P4GU+KPI0HSY4nQ52N6tj9d0q3VpL0h1zqJ6396tm+RuPo9gAdx7Q3cZfuY+v9e0i7A8rY/1ZQL2EjSnSQjaFqG9obQ0nyDMNvpRBBpWK8kdFGeDLwGyBG7H0eawv2SHtNjULp/BL6SFQbHCtv3A5dJyrn+u8pV7HrVAEHthHud0rTnMldpvq5yAW8C9gFWIyJxKwPVndTSQmcR+xDCxKsCW9Ym448knnWzybcF8BvgJOBnMHo6XQnY3qo8ZTFdz0ENnK7QLmqMplFKMxmn0neKagPZflFPX6to5luBPTPpilWmBk4jhNCvoo8OJ5G50Ag9xq5r0qfat2JbY1cHcV/tOfFC4ATbtwPfk/TRTK6x30tdggumjneVa4IJBmESQVUY44xSGdLmz4Ctbf+1Z/vywDm2N83g+gHwOts392xfCzg2x3uYXj43uCeVT9KbiMHCu5typeO+QaQUXNGz/YlEpMuL+h/Zl+sMwghxWc/2JwH/5YyqjJIuBJ7m/iLpP3fH0x6aQtLbBu0iPJHDJn69XHcA56Rjn5GWK64tba/con8X2n6yaqkmOdEtpdMUEufWhKd2mkHJdr8qKE05R6owKGlNNxDOl3S+7c3b9HFxg6R7gOuJ/+FjgBuqXYQ+4fIZXPU0nV5UTqN3255Rv66rXF3uW+nfmTj3zHREdAqSzrO9xaLkS1EP2xDpdE8Cvgmc5IxU/Rb9apLid6jt/dPyNh5R6FuhU3S6++t6bl8iUkzSCsC5tjfOOKaTUUo9vCNHM5eOupEkYFVPabG1gqQzbW8r6Tf0LzrT2NjVZaSo7xcQRaZuBp5T3eOSrrH9+Ayusd9LXYKiqvjbCL3jN0paF3hccvwvFlwTTDAIkwiq8pgNL+CDeo1TAMk7k6unMb/XOJW4bpb00Eyu5xDpfb04ihCvzjJQERFPC2lD2b5C0qMzuR7Za5xKXJenKJccPKjXOJW47k2DmcZQWfHw0nzDxNEPz+kXUDcAHtazr3e9Ke6WtBRwqaSPEGkoOWL8xcVUbX+/enmnTdkGJRjq7W5TYXCBcP4wTIxT01BMdH0m76OkhwHnpMn01XORq8t9K/07Ex6Q9GDbdySOlYEdbH92huO6gmUWNV+KZDwLOCsZ3XcAzpZ0sPOKDkx7l2l4FHsTTbDnEVWaIfQyR61EtztweoqoXkjXM4dogJNoZSLdMuucdThKqXQ0c9GoG9uW9B0iTXyUTm2bxoebjWrs6jgOIooeLAF8vWacehbhuMtBsXtpjuBY4ndWlQ5vITIE2hiCuso1wQR9MYmgKoxZiqC6Bniye1ITJM0nInga62BIusH2Y3P3Dfj+lR6g8SLpKtsb9Ns3hO/6Qd6uFn37he2+6V8tuK4gvEJ/6Nn+cOAHg87BAK6i4uGl+Rq2uZ/tDxbialx5MEX53UaIkr8VWAn4rO0bhh44hj4NMSgB+SKvhb3dE82kTKiw6HqD9l4MvK/E/dlVrtJ8s8kl6dLe6JW5dJ+Vfhc05UuGqRcQxqlHA18nCqg0LsbS296ov6UkVw/vyLqekt7bs8nA7USkfFZhlxpnF6OUikUzjyPqRtIXgI/ZviT32D5cA8fJiwtShN18T5fAWJ6Yg/41rTeOVixxL80FaCoroK6B2UrDtKtcE0wwCJMIqsUDnwdOk/TmKvopRRR9Ju3LwfckfYDwWjlxCTiYmiZVQ9wjaV3b19c3poiSewYcMwwXSnqD7aN6+HZlypvSFJdIep3tY3u4dgZyBx0fA74p6a1Mr1Z4WNqXg2ElrttE55Xma4KXE1UlS6BxNFst8u8e4nodF5r06Z19ti0wKDFV7bERCnu7V5f0ySFt7ZXJt9jD9sDoQdVE1xnRq15r7+uK6k6LLVdpvlnmWkKSau/MJYhCDRMMgKQTiPvlW8DBtq8chW7Achs8PEUqqba8ALb/O6tjU5pnl6aPgTvadMx2sXuvy1FKlI1mHkfUzSbAzyX9kqmKoG5pzLxU0iYljF1dhe37iBS/+rZerb8ZoxVL3ktzBP9QFHOq3iuPIRxiixPXBBP0xcRAVR6LPMXP9mGS/kqkJayQNv8V+JDtIzLp3k4YtW6QdGnathERortrJtdBwJmSDmH6wGA/Qmw1F/sAX5G0Uw/fUuQPNPYBvtqHaz7T089mhO3jJP2RKAtcr1b4AedXKywtHj4OMfKZUPIemLGPKYJt4PdcXgNsxj4VNijVeUpUGLyHfIPuBAPgggLuvdT/Alyl+WaL6yzgZEmV3uKb0ra5gtLjliZ8ryIm93sDe2kqG75NAY9lJW1CpHQvk5YXEDqjlD0hQTC/z3JbXMSU5ln1dwVJlwG72r6pKZHKVj48g4hSuh14l6RpcgyZXFdLes2AKKVrM3iqtouJrqdovM16om6+1TKCbclkbCmpdVTS2DWX0eSZUexemiN4H/EeWUPSF4Gn074oTle5JpigLyYpfi0haXWmoiB+l15aSFrF9p9msV/zAZx0AEbgWYepl/lVtnNzxSueDYlokiqy4ErgsLbh6Inz2TW+q5w0llpybdPD9Z0RuBZokIzAUVQ8vDRfwzZLpkU0KQu+1rD97qOpNu4+1b5bwqDU6+3+wCje7tLpPBOMB4v6PpoNrtJ8s8UlaR5hlKo0jr4LHJ2Ml7MGSd+x/dwG39uwSQRTab5SkHQ2gw2KdkZxl0UFSdsBb7T9vIxj/sCQyoeVYach17OG7c/kWh04nenOjwVRSi1SNouJrmvhqp0G7ugX8dWAq+TzZUnb96Xok4XgjKrUiwNGObdt7qW5AkkPATYn7oHzbf9xceOaYIJ+mBioGkLSfoQY9vvT+q+J0NKlgONdSHOnZd82Bz5HVJe6AtjF9jXDjxrI9XBCIPSxieuDHqHcrUJwdi3C+zWq8WYZ4M21vn2+Mgy24FoaeEON67i2kwlJzweOS6t/J3QNzm/JVWzQOA6+hm0W017J5ZL0COApafUC27eV6Edun0oalBJfSU2OSXW+WYQKVlHsKleX+1b6d9a+vyxR1ei6pseMGyWfxePg6yIknWJ7+7T8Ydv71vY1MtBltJU1KdcYKh+WiFKqcRXRBpL0cSJy7a1eWHT9HtuNRdc1vWrngqgb4l2aG8FWcmwzcRTVMOr5WBzPp6Tv2956pm1zmWuCCQZhYqBqCEWp1GdUedPViyoNGH5ke8tZ7NuFRNrcOUTo8a62/70l11mEB+wc4IWEsOHOLbl2JbxgvwTWJjwcQ0PUZ+A7Gfgn8GNgW+Am221SBZF0EjFQ+TFRted62/0q5DThugzY0fZVkp5GGPWGGoZGhTLEwxc1n6T9bR86w3eOa3JdSXpu06g2SdsT1YTOZipi7J22T2tyfFM06VNJg1LiK+ntfpXtL6Tlp9v+SW3fHs6soDVBHhaHiKFFzddVrhrni4lnz1K215a0MfD+3Pu8NCTdCLxj0H7nV4UtylcKkg61vX9abiy2PICrLvzbW1ikpIFiBeBc94jrZxxfVT78KKHhlVv5sJNRSomvqOj6gDbaRLD9FhioQeYMfbJ/BWNvDiSdbnu7lseOdC91DclovBzwQ2ArpiIlVwTOcl7hq05yTTDBTJhoUGXA00X9Dk/b7k+e09nEvNqA7NQU7dUWq9o+IC1/Oxnm2mIfYAPbf1CkDH6RqNLTFk+w/UQASZ8HLhiBa8Ma1/8Q4fJtcX/lwbT9U6U0yzGjsXh4Kb6691hDKvXNZJxKaKQL1dQ4lXAA8JQqaipF730PyDJQKfSi3kdE/i0JCzQh1snoU0mR18YGqIaGxrcBX0jLnwLqk/VdyCxXPkE2Sur9dJWrNF9XuSq8F3gqYRzH9qWS1h5DO7lYiXA09fvNJtKyZpOvFJ5HRH5DA7HlGTDMqNImLayf42tlwpmY/azVwpUPPwl8JZeHMGzNB9buE6V0GKEN1hSltYHcz7jl9qLr/Ro4XdKBmYctQURflXiGPGzAtQHki/F3FWpY0biJcar0vdRhvImYP61G3FvV9XYn+b+zq1wTTDAUEwNVc6wg6UGVV8n2cbBgsJAj5jkOPDh5g/qut/CSrszUg2eJ+rrz9LX+YfsP6bgb07kaBQs8eo7c/VJc/xyR6+GS9hq0bntgxbQRMBtCxQ+rLY9aqW859QjZTutMnqhthXmentJ3OyGam4vPA28lXsCt0j4LG5Ry0MRwORuVHSeYQskqil3lKs3XVa4K/7T9l573SBfC02+2vUuH+bqI6t00jynxdaVPG2dkr8PKRLGMVzlTi1NlKx++kJ4oJdt3StqNEDZvbKCy3dcYm8ahRxIGxBwUFV0f0LcVyB8f/N5J5qMAShq7uoySFY2L3Utdhu3DgcMl7Wl7pOIrXeWaYIKZMDFQNcdpwOdSCszdAJKWJ6zGRVOIWuBHwIsGrOd6NVdiumUcoDIWmLzInUf1TASmrbeYCGwkqdLDEjF4vJOpCJccQ+FGkipjm4D5ab3i6g1ZH4ZjmW686V1fXFBywrU68DEGe+LbiNqeJenbhIAswCuIgXwu/mL7zBbHtUHpSLgm/6PZqOw4wRRKVlHsKldpvq5yVbhK0o6EQ2ddYC/gp4XbaIMuR8WVxMNTdIVqywuQGY3ye6bSuG5lekrXrbkds31w7jFDULLyYVejlAB2B06XtAt9RNdziApH3TS6/iWtbPvPM3ytpLGrs3DBisaF76XOw/anFIWmngAsU9t+wuCj5hbXBBMMwkSDqiFS7vsHgF2JfH2ANYloiwPdUqx7cYak1w7bb/v4RdWXXqT/50B4lqsvzYTS+gVN+DS4IiCQLdQ9Fv2F5LGt9OB+bDs79UHShwiv3unAvdX2llFdM7W1yHV/JN0DXE/8Hx8D3FDtAtaxvXyp/kywMLqqpzTRoBqJczkixbgS0P42cIhHEJwuAUlPsn15Wl7a9r21fZs7s5hHab5SkPTeYfvHMbFtqnUlaaisQc57syQkfRU4fUCU0vYl+lVAZ2tk0fU+14aJ6OpzWkSwNarS3fA93GgM1NDY1XmoQEXjrt5L40K6drciDEHfIrR3z7X9n4sL1wQTDMLEQJWJpDdVr3hyz2z2B0DSa4bstu0TM7jWHLbfDaof/atB0v5DdtsZFR5VWDy8JJ/KCnWPy0D1SGAz4AHg57azPd6Sfthnsz2GUuVjMAo0MTSuxZBIqck9Pl6oYBXFrnKV5usw14m2Xy1p75T+0CnUny+9z5o2z57SfHMZTX+vpD8AvyEie39GTxROznuzJCStTjhh6hGFC6KUbN+SwTU0Ssn2UZl9Kyq6vqjR8D1czNjVZahgReOu3kvjgqQrgI2AS2xvpKhS/QXb2ywuXBNMMAiTFL+GkPQu2x+xfY+k9W2fWtu3oILMLOEpA7a/mEilamygIsoWVyKXFUykrD2cjHxxSccyeCJs26/P6BeS7hrQtyWJ6kmNr+chXPOAB9nO0cvqF221LPA64rzlaDWVFg8vyfergsaLIwrxLICiauRBwA+I/+unJL3f9jE5PLaLCpzPgNIpM/vO/BWuZPB9ea+kXxJVnFqVCJ9gRixIK9HoVRS7ytXlvpXk2lTSasAuCn2g3glTjmbjOFBab66T+nWSTrG9fVr+sO19a/sWFPco3WzD7z0S2IYQNd+RGGOd5FRYZbaQDFCb9UQpfavlc7+0NlAx0fVZirqZ0ZCW8WzoalptU5xBVDS+HXiXpHfVd2ae/07eS2PEPbYfkHSfooDBbYRu1+LENcEEfTGJoGqIueI5lCRgJ2KiejXhsbh8BL5HJ65/Az7pDGE8Sf3En9cgBKiXsP2otv1K/CsQWgVvAr5i++0jcC0PvBl4C/AN2zkVbHp59gTeSFTW+WhOFI+ka4mXbxHx8JJ8PffASOLeJblqnNcBT7N9e1p/CPBT24/L5FmJqMpVVZ/5EVEy/i+j9rFPW40i4WrfH1phsEB/liBEeL9oe8MSnBNMR8l3SVe5uty3wlx7AbsRWnK30OPwKHVftkWX/6clUY9Y6dOvcUXrtjl/SxPv448SIuezVvlqLkYpKVL432i7sej6bETdlLwXujS/aAMVjLzv4e3MvTQuSPosUZ30lcDbgb8Cl9p+3eLCNcEEgzCJoGqOTnoOF3RAWhLYGXgHcD7wn7avG4FvXSIsdzNCzHovpwqGTWH7yzW+dYgH2jOBDxHaXW379mCi1OlrgC8BT6mMEi245hOCo7sApwBbeHoluNw+vRb44gh9Ki0eXpKvzjHqxKskV4Xbgbtq63elbbk4hogy2j6tv5oQvp+xDHIvZjIo5RinEkauMDgMDu21yyRNKrSMDyXfJV3lKs3XVa4zbH9S0hG2d8s8dlGgKkwiphcpEfFumG2+UhhmVJl1g0uaTL+AmFA/Gvgk4cCaTcy5KCW3E12fjaibWZ8TdAWVAUrSMkyXR2mlz9fRe2kssP2WtHikpLOAFdsGHHSVa4IJBmFioGqOzla+krQ7YWT5PvC8nIFFH64NCcPUBsBHgNd7BMFwSesTFTs2ITwdb3ZLQXlJDyWs9a8gjAibtI1qSd7DtxLRZicAm7qlEKWkDxLGjGOAjWzfOcMhw3CDy2odleQbdg/MJleFG4CfSfpa4vwP4HIlfQw3r+T0mJ6IroMlXdqyT6UNSoukwqDtz427jX9hlHyXdJWrNF9XuU4DNgXWyzxuUaFe4v3Cnn2967PBVwrLSdqESNFfNi0rfZYdU5s3NflSSv3ckBATPtj2lWPqTxZsr91ve4pSOhJoHKUEbMGQKKVSSFHz83KOSePXs4gqv1XUzdmSsqNuJG1n+/S0PEy8fOsc3pmaLci1yJGc54cSTuCbid+zhkIC5IAcx3dX76VxQdL3bW8NUM3r6tsWB64JJhiESYpfQ0i6nyjvWw147q52AcvYftAs9uqW3zQAACAASURBVO0BIgf4D0wfYFfRGo10iBLX/cRA45v0mVDb3iuD61Ri8P4xIjppGp8z9Tkk/Y34jf+/vTuPk6wszz7+uxhAQBglEY0SQHAJKIIgCogbqGhcQFkUFMXgEhUDihFFwYhRfF8BRSHuC/JGFMkggusYF1CjINsgIFHjAGo0USJCABHxev84p2Zqaqqqzzl1qqu6+vp+Pv3ps1Td5+me7umq+zzPfX+cNWfKdOJVbiWtogbVjRQJhLWSXLbfu9aTBsf6E0Wh0T/Q//vfO5V+WKx5785XI9aw3wG7RovrNmN1xWylk5Ok7wKvc1nMs5wFdZLt3RuM6SLbu9Z93pB489ZhMMZDLXZRnNZY0zy2lmNdDpxNsczv3b3n6/xNiubUv7HFKq5RV1DS44adt33hsPN94v2J4m8d9H99UPtv3bg1WOq6hNWzlHZgxFlKar/oeu+sm/OAj7lGIfgyzsAlrnVVTXapYjH1aSXp3RQ1yl5j+5by2FLgJIpaRpXLaSzE36UmytlmGwHfoOiW10lSLgW+bHvbhR4rYi6ZQVWR7crFwSeg752whg5rMdYjKf6I/D3FzCdY/R+aqb+060RW/1HqLcpZ13vKWOtTFDIfRZvJybaLh7cWr83fgXH8PlVNQFXwCuATKmpRCfgfiuWzTXxD0om0l1DqJLt26TrWZOlnTM62tDdrcFpjtR1vWmMdBDyL4rXUqH+TWtf20qv5WspVV9UElKQne+729q/rc8wUiZctqNEophxbrRk/kzbpWUql1oqutzzrZtjy4LqOpXhdAMXqh77JroWcnCo9A3hwd20z2zdLegVwLcXqj0oW2u/SCP6WomTI/Shm33eW4d4C1C2/MK2xIobKDKqIMZK0QZ219mq5eHib8STtZfvr5fbWtld2nVt1N3BSJG0GHE2xPHWDzvGmSxzLu3yMsmRzwJ19t7yMMxYQre4g2s8dQOUuitMaa5rH1vbXWcb86/lYeltX2wWi244335rMeiln0B5LMYPn7bbPH8vg5tm0zlJqW5uzbrS66cw6wD9T1LRa9TtQ58aT1izsP5ZC/tNA0o9s910CPexcgKQ3A6eUCb3jKJKY/9jkBue0xooYJDOoZpykH9h+WEuxPmT7ZS3F2tb2tW3EKuO92fZbW4r1RtsntBEL+BGwZZ3Ld223UTy8zXgnsfou3zLWvOPXfTdwUj4JnEVxx+7lFAXrf131yZIOsf3PvS/cpeJb2GS5Tp2lJVVoHjsMxnjYHjjTRl1dFMvPCzLWNI+tzViSTrH9attfknSk7fd0nTvd9ovmijFmbReIXuht3ivPepH0ROA4iqTGCRVmXi000zpLqdWZei3PuvkV8K4+21B/JnOnVto6wAZdddOKYLPzZv8aSS+0fUb3QUmHUMygisEOsP1WSY+h+Nk6iWJVRJOyEdMaK6KvJKhmgIqiln1PUbygrBNrUL0kAU+rE2sOy6mXuJnLS4BWElQUyY3KCSoVrcb7ngI2rnnttouHtxlvqjtZAn9u+6PlG8ULgAskfb/G8zu1Z/q9gW30vRtDQqm1DoMxfdxiF8VpjdV2vAnH6q5XdCjF0vGOyrUfx6XtpVdjWMo13+b8f1zS0ykaxfwOONZlLcJZ0+KSeIBDKGYpHQkc0bmpQ/PaQPNSdL0u209oMVybya5pdjhwjqTDKJaFQVGiYEPg2RMb1cLQqdv7dODDtr8g6W0zFiuiryzxmwGS7qS449vvH/OAYXeM+8S6i9WdNjo6LYg3t71+jViDCo0LOLTuixZJg5ZaCdjQduWEq6RB6/oFbFIz1u8pXlz069L2d7bvWSNWq8XD24w3rEDoqAVD2yDpe7Z3k/QVitbD/wn8i+0H1Iyzh+3vzHWsYqxlFAmlT5SHXkDR6bFRQknSFbYfPtexiBi/Yct0puH/xHIcrS69mtalXFVU+Tcpl4T9HFhBn9dUdWbvTLNprScGq2YytlZ0vcVxnWD7jeV2lXpmUZK0F0X5BYBr6iyhXqwkfR74BcXvws4UzZgutr3jrMSKGCQJqhkg6VKKhM9a06ol/cz2FjVi/Rh4ou0bWoh1C0Vx9Dv6nD7Z9r2qxirj3QA80vZ/tTC2n1FMR+2NJWBlzVj/Bryq35TsuuOaZpJuAi6k+B49ttym3H+M7U0nNTYASc8AvkVRyPZUis4ix9se+kK8T5y13sQ0fbPZdkJJLXYYjIjRSFpB0c1oHeDrrNnZ6BuTfsHes/Tq0y0svWo13nyTdM5cNwckPX7YeU95na2qFko9sa6ZeidS/D2f2Ey9YTfpGsRaFMmuPqsyDNzkvPmck6SNgKcCP7D9Y0n3BR5me/msxIoYJAmqGSDpscD1A5JKu9i+pEasw4Fv217R59zf2a68jELS1ymmyP9bn3MrbdfqPlhOIT3P9sV9zv1f26+vEesdwLm2L+pz7mTbr+3ztEGxHgL82vZa9Y4kbb4Q7ixXMc0v3Ms7rkfYXqvVe40YuwOPpuhS0h1nKfDshneaWk0oSXo4xWysNToM9vt9jYjxknQd8Cf6L0Gy7TbqCDamltuytx2vLZIeN+y87QuHnR8QcwPggeXuT1yj2clCMK2zlDqmcaZeywmq1mJNM0krWb0Ko/N5Y4oZii+xfd3kRhcR0yoJqkVE0jG239FSrDnv+JR3Tn5v+7Zhj2ubpIe29SJLLRZzV1lQt41Y00wtdB9seN2LbT9qhOc/nmIGxMuBD3SdugU43/aPG8QcS0JJLXQYjIj50ebfpFibpH6d9UyReNnC9pIasdalqEF5GKvLHWxBUevvTbbvHH3E02WaZimV45nKmXqSfk5RzkHAa1izblStRiqLJUE1iIrauS+z/dRJjyUipk8SVItIm38EW47VakJjir/ORfEipLcWyzxe993AehSd/Dp3+Wt3w5G0le3rWx7bSAklDegw2FHnhXFEzK/F8n//tChnqh4LbAq83Xa/BNag576bolHGa2zfUh5bStGp6nbbR45hyBMxjbOUynFN60y9fxh23jUKz7eZ7Fqo8v9iRAySLn6LS5udUNqM1fYyiGn9OheLSWW9O3Wdurs5NumGc5ukEykKem6wKpBdOc6ghJLK7kYNXny23mEwIuZN/o7MA0lPBI6j+D/xhIZ1fZ4BPLi7Ro7tmyW9AriWolPdgtczS+n4aZmlBGB7nUmPoZ86CagKPszqv+fd24uCpI0pavdFRKwlCarFpc03stMaq+14efO/cLzY9k+7D0hqkvz8JMUsrGdQLPc7FFirvtgcWk0o2f5gufmv7tNhsG68iJhX+TsyRpKeDrwJ+B1F3ctvjxDO/Qo4275L0iz9Ox5CMUvpSOCIzs0TJjxLaZpJ+ozt55Tba9Q9lbTc9t5VY7Wc7JpaA2Z9bwrsA0x0KWlETK8kqBaX3MWdrMXy/Z/U1/kvFC1vu50NPKJmnD+3/VFJR5aF3y+Q9P06AcaYUDqVtb/GfsciIhaL84GfAzcCR0s6uvuk7X1qxLpG0gttn9F9UNIhFDOoZsK0zlKacg/q2n4y0N2YZ7M6gdpMdk253pt0Bn4FHGL7BxMYT0QsAElQzThJr7Z9Srl79oixdu3qenfdSAPrCT1yAOl+tv+z3P3DiLHubfu/y927Roz1f2y/odxd0HeLJJ1u+0UVHlq5m2IbJG1LsRzvHmXhzY6ldC3Rq6FTBPeX5Z35/wR6WyVX1UpCqavD4GY9dySXApULAEfERIz0NynmtGeLsQ4HzpF0GHBpeWwXYEPg2S1eJxaeYTPo6s6uay3ZNc0Wy0yxiGhXElSz7yjgFADbJ4wY62xgyzLWfnM8dihJZ9l+brnbRkLje6we224jxrqkK9YjR4z1POANZayPjhhr0nao8iDby8c9kB5/RbEc757AM7uO3wK8tEG8t0m6B/BaimTSUooippWNIaG0PkVr5nVZ847kzcABDeJFxJhIejDwOtsvhVb+JsUQ5UxXJG0APLA8/BPbv28Q6xfArpL2orjxAfBF219rZbCxkG0kaSeK2kkbltsqPzasGavNZNfUknTesPM1ZzdGxCKRBNXsm9aC4bt3NlpKaEzr1zlLy/o26npBtpa63fLaYvtzwOck7W77u93nJK1fJ5akJcCDbH+eop5J0zvzrSaUupYant52h8GIaEbSDhTd3e4HnAv8E8VM2V2Bkyc4tEVF0rrACcBhwPUUf6O2kPRx4E227xz2/J5YndmyV5QfBm5qd8SxQP2S1d32fsWanfd+VTNWm8muabY78DPgU8BFzNZr4ogYE/WpBRkzRNINtrec5Vhtx6sbq2xB3fcUcJXtLdoY16RJugX4Pv1fYLhOl7txkPRN4EW2ryv3Hwl8xPaONeNcbPtRLY1pqzYTSpI2A45mhA6DEdEOSRcB7we+CzwVeCPwCeDNTWbvRDOS3k1xI+A1tm8pjy2lSB7ebrty5z1JKymSUur6vDGwAnhJ5+9LxCCSnjxXB0lJ3xh23naby1Ynprzp92TgYIpZ+F8APmX76okOLCKmWhJUM6BMHPT7hxSwke3KS4oknT8k1l62797n3KBYg+rsCPi87ftWjVXGO3XI2A6t03WmfEE7KNZhtu9RI9bPWP1Cdi0zlKC63PZOkx7HIJKeArwHeC+wOfA0is5+tWZ2lT8b61F08ru1c7zJDLG2E0qSlpfj+nu6Ogx2F1iNiPkh6QrbD+/a/6ntJp1DYwSSfgw8uLf7Xvnm+FrbD+r/zFrX2A94me2njhorZpuky2y30rikSrJroZB0N4pE1YnA8bYXdF3WiBifLPGbAbb7tbJv6qSG5/oZtsShSTecSxqe6+eqIef6tcUdaFYSUAud7a9IejnwVeA3wE626067B+i84Xxrd3igSVLpkxQJpWfQlVBqEKdj5A6DEdGaDXqWPd/RvT+pZc+LkHuTU+XBuyS1chfW9jmSjm0jVsy8Npex/V+K1zQLVpmYejpFcur+FDcRPzvJMUXEdEuCakZJujtFx5mDbT+96vM6xUb7xNsCOAjoe35ArIFTlCWtVzVOV7xPDIi1AWsWx64Sq2/B8rJmUeXv1yCS7k/x/Tq47hKzKfb+SQ9gGEnHAc8BHkcxlfybkl5r+wt14rQ8tb7thFKbHQYjYjT96tB09psmtaO+ayS90PYZ3QclHUKzm2FrkbQxRb2giLm0uTRlQddsknQGsD3wRYpZU8NuDkdEAElQzZSu5MrzgKcAy4APjBBvM+BAirse92PEOx6SRPGC/XkUM0ruM0KsJRRf48HA3sC3KLoMNom1DvCkMtbTKOqJ1P5aJd2HIkHyPGAnimnML2oypin1cuBDAJKW2d5/wuPp9efAo2zfDnxX0peBj1DUPKhM0p8D/wA8huKF5reBt9q+scGY2k4ojdxhMCLaYfsJkx5DAHA4cI6kw4BLy2O7UBSbfnadQD1dVzs2BfahKIAfMZ8Weh2WQyhKJRwJHFG8DQDKGm91SnNExOKRBNUMkLQ3qxM13wDOAB5p+28axNoE2I8iyfJg4Bxga9t/OcL4divjPYvizfnhFDV0msR6fBnracDFwB7l+G5rEGuPMtYzgcuB3YAH2P7fmnEOo/j+b0ORJDscWGb7uLpjmnLdd/Kmrs6K7VcDSNrI9m1lcfInNwj1aeBCoJOAez7FMr0nNYjVWkKpxQ6DEdECSUfbfme5faDts7vOnWD7jZMb3eJh+xfArpL2oqj3B/BF219rEK63ZIIpZsYdYvsHIwwzFo/rJj2AaWE7sw4jorYUSZ8Bkv5EMYPoRbZXlscaFWuVdDtF4udY4Nu2PUKsEyhmYN1A0WL2s8AltreuG6uM9/My1vuBc23fImllk3iSrqeYzfIh4LO2bxoh1p3AvwGvtn15eWzmiuV2F/5sswhoWyTtDnwU2Nj2lpJ2BP7W9itrxrnK9vY9x35g+2E14ywBjrD97jrPmyNmax0GI2I0w/5PnMb/I2eVpN5ZqQZu6leXKqIpSY8bdt72hWO45jm292s7bkTENMsMqtmwM0W9o3+V9FOKGSCVO/f1OKaM9T7gU5LOGmFcLwF+RJFQOt/2HSMWLP0XillYzwXukvQ5mk9/Pp9iyv6+wK1DuhdWsTnF0r7TJG1KMdumdo2tBWBHSTdTzKTasNyG6ZmqfQrFss/zAGyvmOsF5QDLJR0EfKbcPwD4St0gZYHeg4HWElTAdySdRgsdBiNiZBqw3W8/xudSVnfS7XzeWNIK4CW2r6saSNJ5w87b3meEccbC9ro+x0xR83ILarzurprsSnIqIhajzKCaMZIeTbHcbH9gBcXsoA81iLMNZZFv4EEUNXk+a/tHNWIsoVhidTDwRIrlh08CtrD9x7pjKmMKeAKr60XdA3gxxXT+ukvz1inHdTBFYmMpRZe1LzdZMljG3IrV37clFN+zNzeJFfVIusj2rpIut71TeWxF1SL1km5h9ZubuwN3laeWAP/bJAEn6d0UycpWEkqSvtHnsG2nGHPEPMsMqukmaT/gZbafWuM5vwZ+RjHr+yJ6Eo2DGsnE4lOWiTiWokbZ222fX+O5/R67Ktllu+lN5oiIBS8JqhkgaUvbN/Qc6xT+Psj2YSPG354i4fJc2w9sGONuFIXRDwYeC3zN9vNGHNd6rC6U/hTb9xoh1voUCa+DgSfWiSXpkbbX6swm6SEU3/8kqOaBpH+h6KB1GrArRVHOXWwfNMExJaEUMaMk3UWReBZFQe7OjQ0BG9iexZm0C0rdRGHPjbUdKJpsfMr21WMaYiwwkp4IHEeRUDrB9ldbiNk42RURMWuSoJoBbd6plbTc9t4txdrP9jl9ji8FntXbErpCvNNtv2jAuQ3L7m1VY33U9osHnLu77Vv7nRvw+NwpnwKS7gW8hyIxK2A5cGTV7nuStrV9raS+/5bTsIyu5Q6DEREzS9LGFLU0H97w+XejSFSdCBxvO138FrGyE++bKJqUvN32t1uI2XqyKyJioUuCagZ0L2maslitJm5aTsRNZawYH0nH2H7HkPMftv3SNmc9tZ1QkvRVig6D/1weej7wBNtNOgxGxAj6FOfudkedGx3RnKSj+hzelKLO5Gm2P1wz3t2Ap1Mkp+5PUdfwY2W3wFikyoZEP6con7HWm6c69cnGkeyKiJgVSVDNAEn/TVEYvS/bR9SI9VPg74fEWmtG1JBYbSeorqV4wdi3+GydGS5lrAOHxLqyRqybgK8POp8il9NhEonEthNKbXUYjIjRSVrJ6rp1vTpNaN5g+5PzN6rFR9I/9BwycCNwoe0f1Ix1BrA98EXg07avameUsdBJevyw83Xqk7WZ7IqImDVJUM0ASdcDA+sc2f5EjVg3Ap+j/wtu16lnJek24Cf9TpWxdqgaq4x3C/D9IWOrPMOljHX5kFiVu79J+jHw8kHnbX+taqwYn7lmB5YFdQeqk5ztitlqQknSu4CLWbPD4KNsD0wqR8RkSNqMIkG9v+1rJj2emFuZOOjMfOt+gTwt3WpjwiRtAHTqsf7E9u8bxGgt2RURMWuSoJoB07pcTdLVFIXH+7J9fc14i2IpY4zHXP9Okj4+5Om1krNdMVtJKI2jw2BEjJ+kfYC35G/E+Eg6b9j5zEaJNkhaFzgBOAy4nuLv8RbAx4E32b6zQcyRk10REbNm3bkfEgvAH1qM1XfJW0N/qJuEWqB+NukBRCVDf7Zt/01rF1ozofRq4P+Vp5YA/8uQZbQDxrZJW2OLiPlj+zxJx096HDNud4q/w58CLqLd1zERHScCmwBb274FVjX9Oan8OLJqoEHJrvJGWaNkV0TErEiCagbY3k3S+hT1bR5aHr4aONP2HTXDvQBA0tZdsa6x/dMGQ/tOg+cM83po7Y7TG8tY6wPblMd+art2ss/2vmUx7Fey5vf//bZ/02BsMR5nV31gWcD0ocAGnWO231r1+W0nlBZCh8GIGChT1cfrL4AnU9SofB7wBeBTtq+e6Khi1jwDeLC7lp7YvlnSK4BrqZGgosVkV0TErMkSvxkgaTvgfIqE0KXl4UcAewD71Kl9Uf6B/AiwC3BFefjhZdwX27655ti2B44GHlIeuho4uU4R8q5Y6wFvp4Xp1eXdq7cCLwN+Uca6H/Ah4M22/1gj1u4URer/mTW//88HDrb93aqxoj5Jy23vXW4P7dRXMd4HgI2APSl+Fw4ALrb94hoxWk0ojaPDYETMjywDnz9lB76DKRIAx9s+bcJDihkh6Ue2H1z33IDH/5ieZFd5fAlwre0HjTbaiIiFKwmqGSDpa8D/sf3VnuNPokjc7Fkj1unAdcBbbf+pPCbgOOCBtl9YI9a+FHeC3gFcUh7eBTgG+Hvbn6saq4z3boo7Tq/pc8fpdtt1plefBNwLONL278pj9wROBm62/Zoasb4LvMr2pT3HdwbeZ3u3qrGivu56Ym28EZR0pe0duj5vDHzJ9mNrxEhCKWLGSdrS9g0VHve9/B0YrzIx9XSK5NT9gfOAj9n+xSTHFbND0rnAObbP6Dl+CPCcOrXO2kx2RUTMmiSoZoCka21vO+DcD21vVyPWjwfduRl2bsDjVwD72r6u5/j9gc/Z3rFqrM71aemOUxnrrzpJuK7j6wI/rBnrGtsPqXsu2tGdlGopQXWR7V0lfQ/Yj6Jd+dW2HzjHU8dmHB0GI2I0mRk1HSSdAWwPfBH4tO2rJjykmEGSNgfOAW5n9Wz5XYANgWfXSYa2meyKiJg1qUE1G9aRdLfeelNlraY2/43rFh5dtzc5BWD7unK5Xl3uTU6VB++SVDfT6t7kVHnwjw1iSdI9OjOxug7eE1inZqyob5uyi5O6tldp8ELv8+W/3YnAZRT1Yz5SJ8AYEkrPHBaO4kVzRMyvFOOeDocAt1LU7TmimPQNFP8+TpfTaEOZgNpV0l6srjf6RdtfaxDucOAcSYfRJ9k18mAjIhawJKhmwxnAMkmHd7rmlbOU3svq7mFV/ZukNwP/2J0MknQcULeW0h/7LYGQtBVQucZTl2skvXDAHadra8b6oaTn2T6zJ9bBwL/XjPVe4CuSXkuR0ICiBtU7y3MxXvt2bZ80ajDb/1huLpP0eWCD3uRjBa0mlNrsMBgRrdlc0sD/420fMZ+DWaxs50ZQjJ2kPys3ryg/DNzUJFbLya6IiJmSJX4zQtKrKIqRb1QeuhU4yfapNeMsBT4K7MyaRdIvpyiSXvmNuqRnUSRpTmDNO0RvAF5v+9yaY2tzevUWwLnAb3ti3RN4lu2f1Rzbs1izGPw1wIm2P1snTtRXtQ5MjXiHA5+0fVO5vylFsfv3tXWNUYzaYTAi2iHpeuDNg87b/sQ8DicixkjSSoqklLo+bwysAF7Sb8XAkFh/1nPIwE39VglERCw2SVDNAEn7dZYMSdoEoFNEvEGsLW3fIOkBdCVbbP9Hw3g7Aq9l9R2iThe/FQ1irVsuweu+43RNkztOkmTbkvbujgUsr/sCQdIrbL+/7hiiHT01qJbZ3n/EeFfYfnjPsVWF2BvEay2h1EaHwYhoR2pQRUS5pP9ltp9a4zmtJbsiImZNElQzoM0XyS3HOsH2G9uIVcab1q8zb1ImqKeLX+NEUle8HwA7dBKVZRH+K20/dPgz+8ZqNaHURofBiGhHuvNFBLT3OrBJsisiYtZk3X70arPoa9t/YNscW4rbzg4P2G7qK8BZkp4o6YnAp4AvN4z1aNsvBH5r+3hgd2CU9tG3l59vk3Q/4E7gviPEi4jmTutsSNqj+0S57D4iZlx5o6iV91Plaoh7txErImKhSpH02bCtpCv7HO90sNmhRqw2i74uKev39E0G2f6fGrEANpN01JCxvatmrIFfi+06xc13kNTva+l8/3trDUS7dpR0M8X3e8NyG5p3cDoaeBnwinL/q9Ts4telN6F0I6MllEbuMBgRrTkK+Ody+1SK2o0dh9GVwIqIhW3A689NgX1o6Xe9zWRXRMRClQTVbFjJ8K5hdXQXIB/VtmWsfgkqA9vUjLeEYo1+G7OflgD3ainWDygKrMcE2F7SVqxyOd8Ztp8PfKCFkK0mlFrqMBgR7dCA7X77EbGwbdKzb+BXwCG2f1An0HwkuyIiFqokqGbDH2xf31KsG1vsPHTNqPWAevyyxW5lv7Q9sPtSXbbvaitW1CNpL9tfL7e3tr2y69yqBgJV2L5L0laS1rf9h1HH1nZCqbvDoO07JG0k6ZXT0mEwYpEZtrw4BT4jZki5TL8trSW7IiJmTRJUs+E7VR4k6dAKyadKb8olPdT21VUe26JKd6QlbWr7ty3FWmr75jkeVikBIulo2++s8tio5SRWL61ZxprLbI6l4r9Pl58C35F0HnBr52DNJaTAWBJKL7X9T11j+q2klwJJUEXMv+3K5fUCHtC11F7UnyEcEVOsfE0wkO19qsZqOdkVETFT0sVvEZnvznWSXmT79AqxTrX9dxUe92dV6lZVHNtmtn/dRqyq0u1vPIZ18WvS1U/SP/Q73uQFpaQrbD980HgbxGutw2BEjEbSVgyZKWX7hnkcTkSMkaRfAz+jaJxyET03Om1fUCNWa8muiIhZkxlUi8u8dsGrkpwq7TH3Q2oVVa8ytjmTU1Vj1ZCaJOPR6jKbTiJK0ka2bxtlYBSNAtSTUFp/hHidDoMfLPf/luYdBiNiNFcx+P+YOyT9B/Am21+bxzFFxHj8BfBk4GDgecAXgE81XE2wO0OSXRERi1kSVItLm9Plpnnq3bR+ndP8PVvItinvRqprm3J/67rBJO0OfJSiIP+WknYE/tb2KxuMre2EUpsdBiNiBLZ768isUiajtwc+WX6OiAWsrDX6ZeDLku5Gkaj6pqTjbdctbN5msisiYqYkQbW45A7NZOX7Px77dm2f1HOud7+KU4CnAOcB2F4h6XENx9ZaQmkMHQYjYkzKN7MrJJ066bFERDvKxNTTKRJL9wfeC3y2bpyWk10RETMlCarFpVIx9YpG7nDWpe3EzZzxJG1ZsT5I1WLqS4DDl8Y+8gAAG35JREFUbb93yMPqFuuOCqrWfZC0zPb+FWP+TFrjn752l8a2E0ptdxiMiPGz/cG5HxUR007SGRSzIb8IHG/7qhHjtZLsioiYNSmSPgMkHTXsfN3uY5LWBf4a2LY89EPgy7b/2GyEq+JuXI7nf3uOVyqm3vOcHYHHlrvfsr2i69ycxdQlXWr7EZKW2957yOMqFVMvH3ux7UdVeWzMv6rFySX9C/Au4DRgV+BIYBfbBzW45reBvdpKKJUvkLejmN01UofBiIiIqEbSn1j9d7f7zZMA215aI1Z3suvToya7IiJmSRJUM2BQ17GOOt3HJG0OfB34JXA5xR/enSjWy+9p+z8bjO9hwBnAn5Xxfg0c2vQPsqQjgZeyekbSs4EP2a68lELSFcCZwN8BJ/aen2Mm1KCY7wLWAc5izeTBlQOfFPOmahdFSfcC3gM8ieLndTlwRI0i/d2xWk0otdlhMCIiIuZfm8muiIhZkwRVrEHS6cAVtk/pOX4E8AjbhzaI+W8UnYy+Ue4/ATjB9qMbjvFKYHfbt5b7dwe+a3uHGjG2A/YDXkWfmkC2j2swrm/1OWzbTesXRYtqJKj2sP2duY5VvOZYEkotdRiMiIiIiIiYGqlBNUMkPRh4P3Af29tL2gHYx/bbaoTZzfaLeg/afq+kf284tLt3klNlrG+WSaWmxJo1ge6ifh2rJ9p+u6R1bP/jCGNZxfZj535UTFDVn5FTgd5EVr9jc+okotpKKLXcYTAiIiIiImJqrDPpAUSrPgwcA9wJq5aW1a2bc/uQc03fYP9U0nGS7l9+HAv8tGEsgI8DF0l6i6S3AN+jeNNex0vKz88eYRxrkLSZpA9K+ny5/xBJL2orfvRXzvqr4vVzxNld0muBzSQd1fXxFmBJw7HtLuka4Npyf0dJ72sSq9TpMHgjFB0GgczQi4iIiIiIBS8zqGbLRrYv7uk+Vrew+T0k7dfnuICma+IPA45ndc2oC8tjjdh+l6RvAo8pD/2N7ctrhvmRpB9SzEK5rOt4Z/1/7dkywOnAJ1mdCPkxRT2q0xvEiuoqLe20vXyOh6xPMTNpXWCTruM3Awc0G9qqhNJ55RhWSBopodRGh8GIiIiIiIhpkwTVbPmNpAdQFlyUdABFsfM6LgCeOeDchU0GZfu3wBHlmJZQLPm7uUmsMsZuwNW2Lyv3l0ra1fZFNcb0HEl/CXwFOLDpWHrc2/aZkl5XXuPOshBmjNdGknZiwBK+zs/JXGxfAFwg6XTb17c1uJYTSj+T9GjAktaj6DD4w1HGFxERERERMQ2SoJothwMfAraV9AtgJfD8OgFs/03bg5J0JvByijfm3weWSnqP7bW651X0ftasB/S/fY7NNaa72/458NA+5zZvOK5bJf0ZqxOEj6SYfRPjtTlwMv0TVAb2qhnvbpI+BNyfrv8jbdeNA+0nlF5O0WFwc+AXFB0GU38qIiIiIiIWvHTxm0FlAfJ1bN/S4LlHDTtv+10NYl5h++GSnk+RRHoDcGmdrnv94vUcu7JmF79VHd0kLbe9d79zNce1C0Xy4KHACookwgG2r6gbK6qTdLntnVqMtwL4AHApXbOdbF/aINa9KH4mnkSRQFsOHGH7fxqOrbUOgxEREREREdMkM6hmgKRnAld2LUt6LbC/pOuBI22vrBFuk7kfUtt65eyRZwGnlUvfRsmM/lTSERSzpqCYQVK36Hr3bJvNhpyrzPYlkvYEtitjXGP7D01ixUT90fb7535YJX9le41ZjJL2AJomlFrrMBgRERERETFNkqCaDW8HdgOQ9AzgEOBgYCeKmSBPqRrI9vFVHifpGNvvqBj2g8B1FLOKLpS0FaMtfXs58F7gWIolXF8DXlYzhgds99uvRNI+PYe2lPQ74CrbNzaJGZW0lUzqOF/SK4HPAnd0Djac9dRKQknS7sCjKTsMdp1aSsMOgxEREREREdMkCarZYNu3ldv7AR8tlyNdWr7RHocDgUoJKtvvpUgodVxfzjRqxPZ/Awc1fX7p3uUsLHVtU+73zqiq6hXA7sA3yziPAy4DtpL0ZttnjjbkGODlFLXXkLTM9v4jxju0/Py6rmMGtqkaYAwJpXF0GIyIiIiIiJgaSVDNBknaGLgNeCLwvq5zG4zrmhUGNbSeFVC7nlUZ98EUs2buY3t7STsA+9h+W40wH2d1Iqp7G+D0JuMC1gG2s/3Lcpz3BT5GMbvtm0ASVOPR/bNYOYk0iO2tR41BywmlcXUYjIiIiIiImBZJUM2GU4ArKN78/tD2JQCSdgJ+OaZrVlkGN456VgAfppjd8kEA21eWnQIrJ6hsHydpCXB4OcOrDVt0klPlNX4paSvbv5H0x5auEWsbtlyzMkn7Db2IfU7lAY0vodRmh8GIiIiIiIipkQTVDLD9MUlfAe5NUeep41fA34zpsnPOoBpTPSuAjWxfLK0xhNoJINt3STqENZcfjuJCSZ8DPlPuHwB8q+yqOErNrRhuR0k3U/xMblhuU+7b9tKKcZ455JyBygmqLm0nlM6mqCv3Ebo6DEZERERERCx0SVDNjv+iKLz8pDJx80Pgy7bHNXPn7BZjVa5nVfqNpAdQzpaRdADNZ4p9W9IpwFnArZ2Dtq9sEOuVwHOAPcr9s4DP2P4TRT2qGAPbrRQJtz2OZG7bCaU2OwxGRERERERMDdmNV8TElJC0OfB1iiTN5RQzR3YC/gLY0/Z/1oi13Pbe5XbdmU2NSLrc9k41Hr8NRVHsRwO/BVYCh9i+rsG1v9XnsG0nobSISXo68FC6arjZfmuDOJfafkSL43oL8N+002EwIiIiIiJiaiRBNQMknQ5cYfuUnuNHAI+wfWjfJ/aPtSpZJOky2zu3Otj+12x0nXLp3Dq2bxnDsGqT9FvWroH0O+AS4HVNEmgx/yR9ANgI2JNi5tMBwMW2X9wg1ltoMaEkaWWfw7Y9cnH4iIiIiIiISUqCagZIutb2tgPO/bvtv6oRa1WyaB4TVJVnUJWFzTe1/Ztyf33gUOAo29s1uPZmFMXVN7f9DEkPAR5l+/QGsd5GMYvtTIpZbAdR1B5aAbzE9p51Y8b8k3Sl7R26Pm8MfMn2YxvESkIpIiIiIiKigtSgmg23Dzl3W81Y20g6jyLB0tlexfY+dQdXQaV6VpIOoujcd6ukHwNvBz4GfB94fsNrnw58Enh9uf9jitpRpzeI9UzbO3btv0/SFbaPlnR0w/HF/Ov8Pt0m6X7AjcB9mwSyvXUbA2qzw2BERERERMQ0SoJqNtxjwBtYAVU7mHXs27V9UvMhVa9nZfuEiiGPpViy+BNJOwPfBQ6wff4Iw7y37TMlva4cy52S/tQw1u2S9uskC8p/k86yrqYxY/59XtI9gROByyiWbX6kToAxJJTG0WEwIiIiIiJiamSJ3wyQ9PFh5+t0J5O0pe0bRh9V+/WsemNIusr29iPG/CawH/CvtneW9EjgXQ2Xcz0QOBXYlSJpcDFwJPBz4JG2LxhlrDE/JN3N9h2dbYpC6b/vHKsYY9jvpG0fNuIwIyIiIiIiZkoSVLGGnhpUy2zv31KsNhJUPwfe1XXoqO592+9a60lzx9wFeA9Fx7YVwOYUs7KuGGWssXD1+1mdr3psVbTVYTAiIiIiImKaZInfDJB01LDzNRM36toetZBz2/WsPgxsMmS/NtuXSNoT2K4c5zW2/1AnhqTX2j5Z0rtZu4sftof++8R0kPQXFAnKDSXtxOrfhaUUXf2axm0toTSow2DTsUVEREREREyLJKhmw0hJmh4esN1Ea/WsAGwfX+Vxw+pd9Xlsb5JsS0m/A66yfWPFof1H+fmqio+P6fQU4EXAX7LmTL2bgTc2CTiGhNKjuzoMHi/pZOBLI8SLiIiIiIiYClniF2uQdBdwK8XskQ1Z3QVQFLVzKhddb7OeVR11lmNJ+hKwO/BNiq/xcRSFsbcC3mz7zIpxlgBvt/2GRoOOqSFpf9vLWop1ZVdCaQdJGwNfalLjrIx3ke1dJX2PonbajcDVth/YxngjIiIiIiImZZ1JDyDaI+nBkr4m6apyfwdJx9aJYXuJ7aW2N7G9brnd2a/bEfDcrrG18oa/Is39kFXWAbaz/Szb+wIPAf4A7EaNWTO27wKeUGeQMV0knQJge5mkI3vOnd4w7O3l59sk3Q+4E7hv40Gu3WHwOuBTI8SLiIiIiIiYCklQzZYPA8dQvAnG9pXAQXUCSNqra3vrnnP71RxPm/Ws6qgzLXAL279c9cRieyvbvwH+WPO6l0k6R9LBkvbpfNSMEZPzuK7tQ3vO7dAwZtsJpXfavqmc4bUVsC3wthHiRURERERETIXUoJotG9m+WFpjAlHdJMtJQGd53LKubYBjgXNqxGqznlUddWZQXSjpc8Bnyv0DgG9JujtF7aE6NqFYHvm0rmMGzuv/8JgyGrA9infavgNYJunzFIXSfz9CvO9S/k6Wce+QdBlr/p5GREREREQsOElQzZbfSHoAZTJI0gHAL4c/ZS3D3qTXfdO+o6Sby+dtWG534tSqZ1XT2TUe+0rgOcAe5f5ZwGds/4k1Z9QMJOlVtk+z/YJ6w4wps46kTSlmlna2Oz/zSxrGbCWhNK4OgxEREREREdMiCarZcjjwIWBbSb8AVgKH1IwxbNZTrVlQtpu+qe9L0nLbe5fbAzv12T6haswyEfXp8qOpw4DTRnh+TId7AJeyOvlzWde5Wj/7Y0gotd5hMCIiIiIiYpqki98MKpenrWP7lgbPvQm4kOIN9WPLbcr9x9jetEasvWx/vdze2vbKrnP72a6zXBBJl9veqdyu3Klvjpi/Ze3kw++AS4DX2b6uQoxWxhILg6SH2r56jsccSpFQ2oXiZ6njZuATdX/2u+K21mEwIiIiIiJimiRBNUMkHdXn8O+AS21fUTHG44edt31BjfGsStz0JnGaJHWGxWtK0tsolkGeSZGEOwi4P7ACeIntPSvE+CNwW79TjHcpY0xAnZ+9thJKkk6x/epy+0jb7+k6d7rtF416jYiIiIiIiElKgmqGSDqTYsbG+eWhZwBXUiRczrb9zhavtcz2/nM8pnvG06rtfvsVrzlodhcAtmt3zJO0wvaOPceusP3wfucGxKj9tcTCVeXfu+2EUtvJ3oiIiIiIiGmTGlSz5S+BnW3/L4CkfwC+QFHs+1KgtQQVsE2Fx7RWz6q0b9f2SQ2e38/t3csNJe0H3FGe+1NL14jZUuVnt7vA/qHAe7r2d2hwzXF0GIyIiIiIiJgaSVDNlnuzOrkCcCdwH9u3S7pjwHOaqvImfRtJ51G8oe5sU+5v3eCaK23f0OB5wxwCnCrpIxRf08XACyRtBLy6YoxKXQOHFXaPmdN2QmkcHQYjIiIiIiKmRhJUs+WTwEWSPlfuPxM4syyafs0ExjNsxlOTGVDnAp1lTnMuMazC9k+Avx5wulK9rRpdAw8EkqCaUpK2rJgA/UOFx7SdUGqtw2BERERERMQ0Sg2qGSNpF2CPcvc7ti8Z9vgRrtNa3aWqyaZhNa0aXPO1tk+W9G76vMG33a/g/EhSq2q6tVnLSdJ1FEtE+82esu0qS2SbXHfODoMRERERERHTKDOoZoSkJcDVtrdlzbb2bV7jLNvPLXdf32Loqm/Wh9W0qus/ys9XjRinjmSDp1trtZ1s37/SBdtPKP0/ylmGERERERERC0kSVDPC9l2S/r3GMqUmdu+63vIW41ZN3Owo6WaKRMKG5Tblvm0vrXxB+9wyqfcg22+oN9zGUtx6um0u6b2DTto+YgzXbDuhlJ+xiIiIiIhYkJKgmi2bAldLuhi4tXPQ9j6TG1J7bLdaDLpM6j2hzZhzqFRMPSbmdoo6T/Op7YRSZulFRERERMSClATVbDlu1ACSBs3mELDeqPGHxJ77QdJetr9ebm9te2XXuf1sn9Pg2pdJOociedSd1Dtv8FPWGtdy23uX2wM79dUoph6TcaPtT8zzNZNQioiIiIiIIAmqmWK7Ute5OZw85Ny1LcQHGtezOonVy6GWsebSqGOBJgmqTSgSU0/rOmagcoIK2KxrO536Fq4q3fkmouUOgxEREREREVMnCaoZImk34FRgO2B9inb2t9aszbTnmIbXq0k9Kw3Y7rc/PJD0Ktun2X5BnecNkFkws+G0zoakPWx/p2v/VbZP6/+0tY0hoXQuFWpV2d6tYryIiIiIiIipss6kBxCtOg04GPgxsCHwEuCf6gSQdHTX9oE95ya9RG1YF7+6SaLDRhxLt20knSfp/K7tVR8tXifG66iu7VN7ztX9eTm3yoNqJJRS/DwiIiIiImZaZlDNGNs/kbTE9l3AxyVdDhxTI8RBwDvL7WNYs7D3U4E3Vg00hnpW25QJH3Vtd+Jt3SBeW/bt2j5pYqOIUbU2Q6/B4+cyiQ6DERERERER8yYJqtlym6T1gSskvRP4JfVnybX5Jr3telbDEkF1E0M7SLq5z3EBrrMsElhZcTlXTLc2Z+i1nVCaRIfBiIiIiIiIeZME1Wx5AUVC6lXAa4AtgP1rxmjtTXrb9ayqFoGXtMz2XF/3D2zv1MKwoKs+UMVrx3TaTtKVFEnKB5TblPvb1IzVdkJpEh0GIyIiIiIi5k0SVDPE9vXl5u+B4xuG2bGcWSRgw65ZRgI2qBNI0tG231luH2j77K5zJ9iuvFywprrJhFF1zyyb72tHe7alvYL3bSeU0p0vIiIiIiJmWoqkzxBJe0j6qqQfSfpp56NODNtLbC+1vYntdcvtzn7dulEHdW331sF6as1YdVRJMpw990NAUpX6XcNmncXCcdWQj0slfU/SEyvGajuhtEaHwe4Tkl7V8rUiIiIiIiLmXRJUs+WjwLuAxwCP7PqYlDbrWbXKdtWOhAfO/ZBi1pmkWyhrW3X2B9S5iilUJmGX9vsA/gL4W+A9FcO1nVBqs8NgRERERETE1EmCarb8zvaXbP+37Rs7HxMcT5tFp+toM/k1Z6w5Zp3VKbYeU8r2XbZXsHZyaJC2E0pTm+yNiIiIiIhoQxJUM0DSzpJ2Br4h6URJu3eOlccnZeDMIuBhbV5I0lldu69vMfSciTRJe3Vtb91zbr8WxxITZvuDFR/adkJpUsneiIiIiIiIeZEi6bPh5J79Xbq2DezFBNheMo+X273rustbjFslmXASZRc/YFnXNsCxwDktjicWhrYTSm12GIyIiIiIiJg6SVDNANt7TnoMM6xKMfUsv4pebSeU2uwwGBERERERMXWSoJoBko6iqD/10Z7jLwY2sX3KZEbWriHLFQXU6jAoabntvcvtY2y/o9/jKhZTz/Kr6NV2QumqIfHukPQfwJtsf63Fa0ZERERERMwb2Xn/vNBJuhTYzfadPcfXBy6xvcNkRtYuSd8Ydr7OTDJJl9veqdy+zHbjWl2SbgIupEiUPbbcptx/jO1Nm8aOhamsszYwoQS0llCStATYHvik7e1HjRcRERERETEJmUE1G9btTU4B2P6DpJlZYtbyUsY2M7P7dm2f1HOudz8WAdubDDrXnVAqP496rbuAFZKqdhiMiIiIiIiYOklQzYZ1JN3H9n91H5R0n0kNaBwkHW37neX2gbbP7jp3gu031gi3jaTzKGsCldur2N6naiDbF1R5nKRltvevMcaYQeNKKNXoMBgRERERETF1ssRvBkh6IXAE8FrgsvLwI4ATgdNsf2JSY2tT91K83mV5dZfpSXr8sPNVk051dC8rjIiIiIiIiIjVMoNqBtg+Q9KvgbdSLBkycDXwZttfmujg2tVmt7yVtm8YcTx1JRscERERERER0cc6kx5AtMP2l2w/3vaf275Xub1GckrSMZMaX0va7JZ3bmdD0rLGI4qIiIiIiIiIkSVBtbgcOOkBjGhHSTeXHdJ2KLc7+w+rGat7xtU27Q2x8jUjIiIiIiIiopQlfovLgk6Q2F7SZrgB262SdJbt55a7rx/XdSIiIiIiIiIWshRJX0TqFhKfZZLuAm6lSNptCNzWOQXY9tKWrnOD7S3biBURERERERExqzKDanFZ0DOo2tTybKyIiIiIiIiIGEESVIvL2ZMewLSQtJftr5fbW9te2XVuP9vn1Ig1aFaagPVGG2lERERERETE7MsSvxkgabntvcvtY2y/Y9Jjmnbdyx17lz7WXQop6RvDztves/lIIyIiIiIiImZfZlDNhs26tg8EkqCamwZs99sfKgmoiIiIiIiIiNGsM+kBRCsyDa6+YV38an0/JR3dtX1gz7kT6g8tIiIiIiIiYnHJEr8ZIOkm4EKKmT+PLbdXsb3PJMY1zYZ8zwQ8xvamNWK1tlwwIiIiIiIiYjHKEr/ZsG/X9kkTG8XCMux7Vvd72NpywYiIiIiIiIjFKAmq2bDS9g2THsRCYvuCKo+TtMz2/nOFG7Ddbz8iIiIiIiIieqQG1Ww4t7MhadkkBzKDtqnwmB0l3SzpFmCHcruz/7Axjy8iIiIiIiJiwcsMqtnQvYysSkIlqptzBpTtJfMxkIiIiIiIiIhZlRlUs2HYErOIiIiIiIiIiKmWGVSzYUdJN1PMpNqw3Kbct+2lkxvagpci5xERERERERFjlgTVDMgSs3ZJOsv2c8vd1090MBERERERERGLQJb4zQBJe3Vtb91zbr/5H9GCt3tnw/bySQ4kIiIiIiIiYjFIgmo2nNS13dvF79j5HEhERERERERERF1Z4jcbNGC7334AknYedApYbz7HEhEREREREbHYJUE1G4Z18UtXv/5OHnLu2nkbRUREREREREQgO/mLhU7STcCFFLN/HltuU+4/xvamkxpbRERERERERMRckqCaAZIeP+y87QvmaywLhaSjbb+z3D7Q9tld506w/cbJjS4iIiIiIiJicUmCahGRtMz2/pMexzSQdJntnXu3++1HRERERERExHili9/iss2kBzBFUlg+IiIiIiIiYkokQbW4ZLrcaiksHxERERERETEl0sUvFqsdJd1MMVtqw3Kbcn+DyQ0rIiIiIiIiYvFJgmpxydK1ku0lkx5DRERERERERBSyxG/GSTqra/f1ExtIRERERERERMQA6eI34yTdYHvLSY8jIiIiIiIiImKQzKCKiIiIiIiIiIiJSg2qGSBp50GngPXmcywREREREREREXVlid8MkPSNYedt7zlfY4mIiIiIiIiIqCsJqoiIiIiIiIiImKjUoJoBko7u2j6w59wJ8z+iiIiIiIiIiIjqkqCaDQd1bR/Tc+6p8zmQiIiIiIiIiIi6kqCaDRqw3W8/IiIiIiIiImKqJEE1Gzxgu99+RERERERERMRUSZH0GSDpLuBWitlSGwK3dU4BG9heb1Jji4iIiIiIiIiYSxJUERERERERERExUVniFxERERERERERE5UEVURERERERERETFQSVBERERERERERMVFJUEVERERERERExEQlQRURERERERERERP1/wHQ+WcAH60pWQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], + "source": [] + }, + { "source": [ "plt.hlines([-2, 2], -0.5, len(pulls) - 0.5, colors=\"k\", linestyles=\"dotted\")\n", "plt.hlines([-1, 1], -0.5, len(pulls) - 0.5, colors=\"k\", linestyles=\"dashdot\")\n", @@ -162,7 +147,23 @@ "plt.xlim(-0.5, len(pulls) - 0.5)\n", "plt.title(\"Pull Plot\", fontsize=18)\n", "plt.ylabel(r\"$(\\theta - \\hat{\\theta})\\,/ \\Delta \\theta$\", fontsize=18);" - ] + ], + "cell_type": "code", + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "metadata": {}, + "execution_count": 5 } ], "metadata": { @@ -181,9 +182,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.5" + "version": "3.6.6" } }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file From cc70011f09be97a97af9bea5b3f73ea1ca9128cd Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 13:57:17 +0100 Subject: [PATCH 43/72] adapt notebooks --- .../multichannel-coupled-histo.ipynb | 46 ++++++------------- 1 file changed, 13 insertions(+), 33 deletions(-) diff --git a/docs/examples/notebooks/multichannel-coupled-histo.ipynb b/docs/examples/notebooks/multichannel-coupled-histo.ipynb index 98776b5f95..7061864644 100644 --- a/docs/examples/notebooks/multichannel-coupled-histo.ipynb +++ b/docs/examples/notebooks/multichannel-coupled-histo.ipynb @@ -127,39 +127,19 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": { - "scrolled": false - }, + "execution_count": 1, + "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pyhf.pdf:Validating spec against schema: /home/jovyan/pyhf/src/pyhf/data/spec.json\n", - "INFO:pyhf.pdf:adding modifier mu (1 new nuisance parameters)\n", - "INFO:pyhf.pdf:adding modifier coupled_histosys (1 new nuisance parameters)\n" + "ename": "NameError", + "evalue": "name 'json' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msource\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalidation_datadir\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'/2bin_2channel_coupledhisto.json'\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 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprep_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msource\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'channels'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'json' is not defined" ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[170.0, 220.0, 110.0, 105.0, 0.0]\n", - "parameters post unconstrained fit: [1.05563069e-12 4.00000334e+00]\n", - "parameters post constrained fit: [0. 4.00000146]\n" - ] - }, - { - "data": { - "text/plain": [ - "array([ 1.25000007e+02, 1.60000022e+02, 2.10000022e+02, -8.00631284e-05,\n", - " 4.00000146e+00])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -172,10 +152,10 @@ "init_pars = pdf.config.suggested_init()\n", "par_bounds = pdf.config.suggested_bounds()\n", "\n", - "unconpars = pyhf.optimizer.unconstrained_bestfit(pyhf.infer.utils.loglambdav, data, pdf, init_pars, par_bounds)\n", + "unconpars = pyhf.infer.mle.fit(data, pdf, init_pars, par_bounds)\n", "print('parameters post unconstrained fit: {}'.format(unconpars))\n", "\n", - "conpars = pyhf.optimizer.constrained_bestfit(pyhf.infer.utils.loglambdav, 0.0, data, pdf, init_pars, par_bounds)\n", + "conpars = pyhf.infer.mle.fixed_poi_fit(0.0, data, pdf, init_pars, par_bounds)\n", "print('parameters post constrained fit: {}'.format(conpars))\n", "\n", "pdf.expected_data(conpars)" @@ -291,4 +271,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file From dceaf82c039b4f75576eb0e81501a03b186b3543 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 14:48:09 +0100 Subject: [PATCH 44/72] adapt notebooks --- docs/examples/notebooks/ShapeFactor.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/examples/notebooks/ShapeFactor.ipynb b/docs/examples/notebooks/ShapeFactor.ipynb index 502c653a4a..3cf4d823db 100644 --- a/docs/examples/notebooks/ShapeFactor.ipynb +++ b/docs/examples/notebooks/ShapeFactor.ipynb @@ -181,7 +181,7 @@ "source": [ "print('initialization parameters: {}'.format(pdf.config.suggested_init()))\n", "\n", - "unconpars = pyhf.infer.mle(data, pdf)\n", + "unconpars = pyhf.infer.mle.fit(data, pdf)\n", "print('parameters post unconstrained fit: {}'.format(unconpars))" ] }, From 1d043466f1da4ba22e8fb9c16084a8205d3d3d16 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 14:59:03 +0100 Subject: [PATCH 45/72] adapt notebooks --- docs/examples/notebooks/multiBinPois.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/examples/notebooks/multiBinPois.ipynb b/docs/examples/notebooks/multiBinPois.ipynb index 7f7fd744b2..225660f45f 100644 --- a/docs/examples/notebooks/multiBinPois.ipynb +++ b/docs/examples/notebooks/multiBinPois.ipynb @@ -200,7 +200,7 @@ "\n", "print(init_pars)\n", "\n", - "bestfit_pars = optimizer.infer.mle(data, pdf, init_pars, par_bounds)\n", + "bestfit_pars = pyhf.infer.mle.fit(data, pdf, init_pars, par_bounds)\n", "bestfit_cts = pdf.expected_data(bestfit_pars, include_auxdata = False)" ] }, From d0cebe34ec219a4465ed92b4d88edb1e8446071c Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 17:02:48 +0100 Subject: [PATCH 46/72] adapt notebooks --- docs/api.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/api.rst b/docs/api.rst index 41c887ec61..a3b366aca1 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -119,7 +119,7 @@ Inference hypotest test_statistics.qmu - utils.loglambdav + mle.loglambdav utils.generate_asimov_data utils.pvals_from_teststat utils.pvals_from_teststat_expected From a0ce42a28385dc8492a6815ef63bef41284c3c02 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 19:42:16 +0100 Subject: [PATCH 47/72] coverage --- tests/test_optim.py | 50 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/tests/test_optim.py b/tests/test_optim.py index d611f56cfe..a729587b0e 100644 --- a/tests/test_optim.py +++ b/tests/test_optim.py @@ -79,3 +79,53 @@ def test_optim(backend, source, spec, mu): [(pdf.config.poi_index, mu)], ) assert pyhf.tensorlib.tolist(result) + +@pytest.mark.parametrize('mu', [1.0], ids=['mu=1']) +def test_optim_with_value(backend, source, spec, mu): + pdf = pyhf.Model(spec) + data = source['bindata']['data'] + pdf.config.auxdata + + init_pars = pdf.config.suggested_init() + par_bounds = pdf.config.suggested_bounds() + + optim = pyhf.optimizer + + result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) + assert pyhf.tensorlib.tolist(result) + + result,fval = optim.minimize( + pyhf.infer.mle.loglambdav, + data, + pdf, + init_pars, + par_bounds, + [(pdf.config.poi_index, mu)], + return_fval=True + ) + assert pyhf.tensorlib.tolist(result) + +@pytest.mark.parametrize('mu', [1.0], ids=['mu=1']) +@pytest.mark.only_numpy_minuit +def test_optim_uncerts(backend, source, spec, mu): + pdf = pyhf.Model(spec) + data = source['bindata']['data'] + pdf.config.auxdata + + init_pars = pdf.config.suggested_init() + par_bounds = pdf.config.suggested_bounds() + + optim = pyhf.optimizer + + result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) + assert pyhf.tensorlib.tolist(result) + + result = optim.minimize( + pyhf.infer.mle.loglambdav, + data, + pdf, + init_pars, + par_bounds, + [(pdf.config.poi_index, mu)], + return_uncertainties = True + ) + assert result.shape[1] == 2 + assert pyhf.tensorlib.tolist(result) From cd11db8b7de1579adaeec461e7cbb62f700bdd2e Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Mon, 16 Dec 2019 19:42:23 +0100 Subject: [PATCH 48/72] coverage --- tests/test_optim.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/tests/test_optim.py b/tests/test_optim.py index a729587b0e..5b8aa48729 100644 --- a/tests/test_optim.py +++ b/tests/test_optim.py @@ -80,6 +80,7 @@ def test_optim(backend, source, spec, mu): ) assert pyhf.tensorlib.tolist(result) + @pytest.mark.parametrize('mu', [1.0], ids=['mu=1']) def test_optim_with_value(backend, source, spec, mu): pdf = pyhf.Model(spec) @@ -93,17 +94,18 @@ def test_optim_with_value(backend, source, spec, mu): result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) assert pyhf.tensorlib.tolist(result) - result,fval = optim.minimize( + result, fval = optim.minimize( pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds, [(pdf.config.poi_index, mu)], - return_fval=True + return_fval=True, ) assert pyhf.tensorlib.tolist(result) + @pytest.mark.parametrize('mu', [1.0], ids=['mu=1']) @pytest.mark.only_numpy_minuit def test_optim_uncerts(backend, source, spec, mu): @@ -125,7 +127,7 @@ def test_optim_uncerts(backend, source, spec, mu): init_pars, par_bounds, [(pdf.config.poi_index, mu)], - return_uncertainties = True + return_uncertainties=True, ) - assert result.shape[1] == 2 + assert result.shape[1] == 2 assert pyhf.tensorlib.tolist(result) From 98045ee340385359e1c7294aa8df939a62714c83 Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Mon, 16 Dec 2019 16:08:11 -0600 Subject: [PATCH 49/72] Black notebook cells and remove empty cell --- docs/examples/notebooks/ImpactPlot.ipynb | 38 ++++++++++++++---------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/docs/examples/notebooks/ImpactPlot.ipynb b/docs/examples/notebooks/ImpactPlot.ipynb index c08b5ce1e5..f0d3be0c0e 100644 --- a/docs/examples/notebooks/ImpactPlot.ipynb +++ b/docs/examples/notebooks/ImpactPlot.ipynb @@ -30,7 +30,10 @@ { "name": "stdout", "output_type": "stream", - "text": "x RegionA/BkgOnly.json\nx RegionA/patch.sbottom_750_745_60.json\n" + "text": [ + "x RegionA/BkgOnly.json\n", + "x RegionA/patch.sbottom_750_745_60.json\n" + ] } ], "source": [ @@ -80,13 +83,10 @@ "\n", " pyhf.set_backend(\"numpy\", pyhf.optimize.minuit_optimizer(verbose=True))\n", " result = pyhf.infer.mle.fit(\n", - " data,\n", - " model,\n", - " fixed_vals = constraints,\n", - " return_uncertainties = True\n", + " data, model, fixed_vals=constraints, return_uncertainties=True\n", " )\n", - " bestfit = result[:,0]\n", - " errors = result[:,1]\n", + " bestfit = result[:, 0]\n", + " errors = result[:, 1]\n", " return model, data, bestfit, errors" ] }, @@ -171,7 +171,20 @@ { "name": "stdout", "output_type": "stream", - "text": "0\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/tensor/numpy_backend.py:252: RuntimeWarning: invalid value encountered in log\n return n * np.log(lam) - lam - gammaln(n + 1.0)\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4p.py:57: RuntimeWarning: invalid value encountered in greater\n alphasets > 1, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4p.py:61: RuntimeWarning: invalid value encountered in less\n alphasets < -1, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4.py:171: RuntimeWarning: invalid value encountered in greater_equal\n alphasets >= self.__alpha0, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4.py:182: RuntimeWarning: invalid value encountered in greater\n alphasets > -self.__alpha0, self.mask_on, self.mask_off\n/Users/lukasheinrich/Code/pyhfdev/dev/pyhfsrc/src/pyhf/interpolators/code4.py:201: RuntimeWarning: invalid value encountered in greater_equal\n exponents >= self.__alpha0, exponents, self.ones\n10\n15\n20\n25\n30\n35\n40\n45\n50\n55\n" + "text": [ + "0\n", + "5\n", + "10\n", + "15\n", + "20\n", + "25\n", + "30\n", + "35\n", + "40\n", + "45\n", + "50\n", + "55\n" + ] } ], "source": [ @@ -251,13 +264,6 @@ "plt.yticks(range(len(slabels)), slabels)\n", "plt.grid();" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -281,4 +287,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} From 45cde0783cff68a5207ed10ada59783bf120b313 Mon Sep 17 00:00:00 2001 From: Lukas Date: Tue, 17 Dec 2019 02:10:43 +0100 Subject: [PATCH 50/72] Update src/pyhf/infer/mle.py Co-Authored-By: Giordon Stark --- src/pyhf/infer/mle.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 1eac0fab21..728e892672 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -15,7 +15,7 @@ def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): return opt.minimize(loglambdav, data, pdf, init_pars, par_bounds, **kwargs) -def fixed_poi_fit(constrained_mu, data, pdf, init_pars=None, par_bounds=None, **kwargs): +def fixed_poi_fit(poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None **kwargs): _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() From f86edabe7026252493c6ab9436e65daca28be735 Mon Sep 17 00:00:00 2001 From: Lukas Date: Tue, 17 Dec 2019 02:11:49 +0100 Subject: [PATCH 51/72] Update mle.py --- src/pyhf/infer/mle.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 728e892672..06d9093b00 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -25,6 +25,6 @@ def fixed_poi_fit(poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index pdf, init_pars, par_bounds, - [(pdf.config.poi_index, constrained_mu)], + [(pdf.config.poi_index, poi_val)], **kwargs ) From 735936d165186f78f818a56f40197ff57255a93e Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Tue, 17 Dec 2019 03:07:56 +0100 Subject: [PATCH 52/72] fix --- src/pyhf/infer/mle.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 06d9093b00..8a59eb6ed9 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -15,7 +15,7 @@ def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): return opt.minimize(loglambdav, data, pdf, init_pars, par_bounds, **kwargs) -def fixed_poi_fit(poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None **kwargs): +def fixed_poi_fit(poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None, **kwargs): _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() From e0d8bdc98d30c785cfffa33d516001abf9b434bd Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Tue, 17 Dec 2019 03:48:17 +0100 Subject: [PATCH 53/72] fix --- src/pyhf/infer/mle.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 8a59eb6ed9..1db0fd2990 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -15,7 +15,9 @@ def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): return opt.minimize(loglambdav, data, pdf, init_pars, par_bounds, **kwargs) -def fixed_poi_fit(poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None, **kwargs): +def fixed_poi_fit( + poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None, **kwargs +): _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() From 788279e7e83ddaff9e5e80edb05bcfb2abedf5aa Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Tue, 17 Dec 2019 17:31:38 +0100 Subject: [PATCH 54/72] add docstrings --- src/pyhf/infer/mle.py | 45 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 39 insertions(+), 6 deletions(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 1db0fd2990..c842a16614 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -1,28 +1,61 @@ -""" -Module for Maximum Likelihood Estimation -""" +"""Module for Maximum Likelihood Estimation.""" from .. import get_backend -def loglambdav(pars, data, pdf): +def twice_nll(pars, data, pdf): + """ + Twice the negative Log-Likelihood. + + Args: + data (`tensor`): the data + pdf (`pyhf.Model`): the statistical model + + Returns: + Twice the negative log likelihood. + + """ return -2 * pdf.logpdf(pars, data) def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): + """ + Run a unconstrained maximum likelihood fit. + + Args: + data (`tensor`): the data + pdf (`pyhf.Model`): the statistical model + kwargs: keyword arguments passed through to the optimizer API + + Returns: + see optimizer API + + """ _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() - return opt.minimize(loglambdav, data, pdf, init_pars, par_bounds, **kwargs) + return opt.minimize(twice_nll, data, pdf, init_pars, par_bounds, **kwargs) def fixed_poi_fit( poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None, **kwargs ): + """ + Run a maximum likelihood fit with the POI value fixzed. + + Args: + data: the data + pdf (`pyhf.Model`): the statistical model + kwargs: keyword arguments passed through to the optimizer API + + Returns: + see optimizer API + + """ _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() par_bounds = par_bounds or pdf.config.suggested_bounds() return opt.minimize( - loglambdav, + twice_nll, data, pdf, init_pars, From d8db6ee5ce1fdedcc89396366a0725b1f44ad5fd Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Tue, 17 Dec 2019 17:31:55 +0100 Subject: [PATCH 55/72] add docstrings --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 23a1c53d47..81722b3b7c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -99,7 +99,7 @@ jobs: - name: Check docstrings run: | # Group 1 is related to docstrings - pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py + pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/mle.py - name: Test and build docs run: | python -m doctest README.md From 061a0abddfddd0cdc45bb9a43890738b1b78282e Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Tue, 17 Dec 2019 22:18:40 +0100 Subject: [PATCH 56/72] add docstrings --- .github/workflows/ci.yml | 2 +- src/pyhf/optimize/__init__.py | 2 ++ src/pyhf/optimize/autodiff.py | 10 ++++++++++ src/pyhf/optimize/opt_minuit.py | 18 ++++++++++++++++++ src/pyhf/optimize/opt_pytorch.py | 17 +++++++++++++++-- src/pyhf/optimize/opt_scipy.py | 12 ++++++++++++ src/pyhf/optimize/opt_tflow.py | 22 +++++++++++++++++----- 7 files changed, 75 insertions(+), 8 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 81722b3b7c..f1df186a70 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -99,7 +99,7 @@ jobs: - name: Check docstrings run: | # Group 1 is related to docstrings - pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/mle.py + pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/mle.py src/pyhf/optimize - name: Test and build docs run: | python -m doctest README.md diff --git a/src/pyhf/optimize/__init__.py b/src/pyhf/optimize/__init__.py index c3169eb4b8..f61150f949 100644 --- a/src/pyhf/optimize/__init__.py +++ b/src/pyhf/optimize/__init__.py @@ -1,3 +1,5 @@ +"""Optimizers for Tensor Functions.""" + from .. import exceptions diff --git a/src/pyhf/optimize/autodiff.py b/src/pyhf/optimize/autodiff.py index acaff748b1..ae97da5584 100644 --- a/src/pyhf/optimize/autodiff.py +++ b/src/pyhf/optimize/autodiff.py @@ -1,8 +1,11 @@ +"""Helper Classes for use of automatic differentiation.""" import scipy from .. import get_backend class AutoDiffOptimizerMixin(object): + """Mixin Class to build optimizers that use automatic differentiation.""" + def minimize( self, objective, @@ -13,6 +16,13 @@ def minimize( fixed_vals=None, return_fval=False, ): + """ + Find Function Parameters that minimize the Objective. + + Returns: + bestfit parameters + + """ tensorlib, _ = get_backend() tv, fixed_values_tensor, func, init, bounds = self.setup_minimize( objective, data, pdf, init_pars, par_bounds, fixed_vals diff --git a/src/pyhf/optimize/opt_minuit.py b/src/pyhf/optimize/opt_minuit.py index 29c874d36c..62f3bd38f9 100644 --- a/src/pyhf/optimize/opt_minuit.py +++ b/src/pyhf/optimize/opt_minuit.py @@ -1,3 +1,5 @@ +"""MINUIT Optimizer Backend.""" + import iminuit import logging import numpy as np @@ -6,7 +8,16 @@ class minuit_optimizer(object): + """MINUIT Optimizer Backend.""" + def __init__(self, verbose=False, ncall=10000, errordef=1, steps=1000): + """ + Create MINUIT Optimizer. + + Args: + verbose (`bool`): print verbose output during minimization + + """ self.verbose = 0 self.ncall = ncall self.errordef = errordef @@ -56,6 +67,13 @@ def minimize( return_fval=False, return_uncertainties=False, ): + """ + Find Function Parameters that minimize the Objective. + + Returns: + bestfit parameters + + """ mm = self._make_minuit(objective, data, pdf, init_pars, par_bounds, fixed_vals) result = mm.migrad(ncall=self.ncall) assert result diff --git a/src/pyhf/optimize/opt_pytorch.py b/src/pyhf/optimize/opt_pytorch.py index 270b1e643d..869da4489b 100644 --- a/src/pyhf/optimize/opt_pytorch.py +++ b/src/pyhf/optimize/opt_pytorch.py @@ -1,3 +1,5 @@ +"""PyTorch Optimizer Backend.""" + from .. import get_backend, default_backend from ..tensor.common import _TensorViewer from .autodiff import AutoDiffOptimizerMixin @@ -5,12 +7,23 @@ class pytorch_optimizer(AutoDiffOptimizerMixin): - def __init__(self, *args, **kargs): - pass + """PyTorch Optimizer Backend.""" def setup_minimize( self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None ): + """ + Prepare Minimization for AutoDiff-Optimizer. + + Args: + objective: objective function + data: observed data + pdf: model + init_pars: initial parameters + par_bounds: parameter boundaries + fixed_vals: fixed parameter values + + """ tensorlib, _ = get_backend() all_idx = default_backend.astensor(range(pdf.config.npars), dtype='int') all_init = default_backend.astensor(init_pars) diff --git a/src/pyhf/optimize/opt_scipy.py b/src/pyhf/optimize/opt_scipy.py index f9e4f8360e..d2064609f4 100644 --- a/src/pyhf/optimize/opt_scipy.py +++ b/src/pyhf/optimize/opt_scipy.py @@ -1,3 +1,5 @@ +"""scipy.optimize-based Optimizer using finite differences.""" + from scipy.optimize import minimize import logging @@ -5,7 +7,10 @@ class scipy_optimizer(object): + """scipy.optimize-based Optimizer using finite differences.""" + def __init__(self, **kwargs): + """Create scipy.optimize-based Optimizer.""" self.maxiter = kwargs.get('maxiter', 100000) def minimize( @@ -18,6 +23,13 @@ def minimize( fixed_vals=None, return_fval=False, ): + """ + Find Function Parameters that minimize the Objective. + + Returns: + bestfit parameters + + """ fixed_vals = fixed_vals or [] indices = [i for i, _ in fixed_vals] values = [v for _, v in fixed_vals] diff --git a/src/pyhf/optimize/opt_tflow.py b/src/pyhf/optimize/opt_tflow.py index 3ebc7ef7dd..5d29463822 100644 --- a/src/pyhf/optimize/opt_tflow.py +++ b/src/pyhf/optimize/opt_tflow.py @@ -1,10 +1,11 @@ +"""Tensorflow Optimizer Backend.""" from .. import get_backend, default_backend from ..tensor.common import _TensorViewer from .autodiff import AutoDiffOptimizerMixin import tensorflow as tf -def eval_func(op, argop, dataop, data): +def _eval_func(op, argop, dataop, data): def func(pars): tensorlib, _ = get_backend() pars_as_list = tensorlib.tolist(pars) if isinstance(pars, tf.Tensor) else pars @@ -18,12 +19,23 @@ def func(pars): class tflow_optimizer(AutoDiffOptimizerMixin): - def __init__(self, *args, **kargs): - pass - + """Tensorflow Optimizer Backend.""" + def setup_minimize( self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None ): + """ + Prepare Minimization for AutoDiff-Optimizer. + + Args: + objective: objective function + data: observed data + pdf: model + init_pars: initial parameters + par_bounds: parameter boundaries + fixed_vals: fixed parameter values + + """ tensorlib, _ = get_backend() all_idx = default_backend.astensor(range(pdf.config.npars), dtype='int') @@ -53,7 +65,7 @@ def setup_minimize( nll = objective(full_pars, data_placeholder, pdf) nllgrad = tf.identity(tf.gradients(nll, variable_pars_placeholder)[0]) - func = eval_func( + func = _eval_func( [nll, nllgrad], variable_pars_placeholder, data_placeholder, data, ) From 726f7aab64c5a06e8b4f8c6c3df3e8ebf30247ac Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Tue, 17 Dec 2019 23:40:32 -0600 Subject: [PATCH 57/72] Apply Black --- src/pyhf/optimize/opt_tflow.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyhf/optimize/opt_tflow.py b/src/pyhf/optimize/opt_tflow.py index 5d29463822..a897d8e3ff 100644 --- a/src/pyhf/optimize/opt_tflow.py +++ b/src/pyhf/optimize/opt_tflow.py @@ -20,7 +20,7 @@ def func(pars): class tflow_optimizer(AutoDiffOptimizerMixin): """Tensorflow Optimizer Backend.""" - + def setup_minimize( self, objective, data, pdf, init_pars, par_bounds, fixed_vals=None ): From a9f0e3633259b2ed66533439c29030b6d8282b9d Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Tue, 17 Dec 2019 23:51:37 -0600 Subject: [PATCH 58/72] Crossreference the Model objects in the docs --- src/pyhf/infer/mle.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index c842a16614..4976b33250 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -5,14 +5,14 @@ def twice_nll(pars, data, pdf): """ Twice the negative Log-Likelihood. - + Args: data (`tensor`): the data - pdf (`pyhf.Model`): the statistical model + pdf (~pyhf.pdf.Model): The statistical model adhering to the schema model.json Returns: Twice the negative log likelihood. - + """ return -2 * pdf.logpdf(pars, data) @@ -20,15 +20,15 @@ def twice_nll(pars, data, pdf): def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): """ Run a unconstrained maximum likelihood fit. - + Args: data (`tensor`): the data - pdf (`pyhf.Model`): the statistical model + pdf (~pyhf.pdf.Model): The statistical model adhering to the schema model.json kwargs: keyword arguments passed through to the optimizer API - + Returns: see optimizer API - + """ _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() @@ -41,15 +41,15 @@ def fixed_poi_fit( ): """ Run a maximum likelihood fit with the POI value fixzed. - + Args: data: the data - pdf (`pyhf.Model`): the statistical model + pdf (~pyhf.pdf.Model): The statistical model adhering to the schema model.json kwargs: keyword arguments passed through to the optimizer API Returns: see optimizer API - + """ _, opt = get_backend() init_pars = init_pars or pdf.config.suggested_init() From 3b21104449f75605d75e7c9d5e6a9a3538adba9a Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Tue, 17 Dec 2019 23:55:20 -0600 Subject: [PATCH 59/72] Add mle functions to the API docs loglambdav is removed as it no longer exists --- docs/api.rst | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/api.rst b/docs/api.rst index a3b366aca1..d2665483f7 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -119,7 +119,9 @@ Inference hypotest test_statistics.qmu - mle.loglambdav + mle.twice_nll + mle.fit + mle.fixed_poi_fit utils.generate_asimov_data utils.pvals_from_teststat utils.pvals_from_teststat_expected From 3ad1432c48a3d6380ee86eb7bcdc66e759ab1f91 Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Wed, 18 Dec 2019 00:05:41 -0600 Subject: [PATCH 60/72] Fix path for pydocstyle --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f1df186a70..2164e0afbc 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -99,7 +99,7 @@ jobs: - name: Check docstrings run: | # Group 1 is related to docstrings - pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/mle.py src/pyhf/optimize + pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/infer/mle.py src/pyhf/optimize - name: Test and build docs run: | python -m doctest README.md From 644beadf429361af0b48853168e18cf5578606d4 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Wed, 18 Dec 2019 09:32:36 +0100 Subject: [PATCH 61/72] rename objective --- tests/test_optim.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/test_optim.py b/tests/test_optim.py index 5b8aa48729..df2bc7aaeb 100644 --- a/tests/test_optim.py +++ b/tests/test_optim.py @@ -67,11 +67,11 @@ def test_optim(backend, source, spec, mu): optim = pyhf.optimizer - result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) + result = optim.minimize(pyhf.infer.mle.twice_nll, data, pdf, init_pars, par_bounds) assert pyhf.tensorlib.tolist(result) result = optim.minimize( - pyhf.infer.mle.loglambdav, + pyhf.infer.mle.twice_nll, data, pdf, init_pars, @@ -91,11 +91,11 @@ def test_optim_with_value(backend, source, spec, mu): optim = pyhf.optimizer - result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) + result = optim.minimize(pyhf.infer.mle.twice_nll, data, pdf, init_pars, par_bounds) assert pyhf.tensorlib.tolist(result) result, fval = optim.minimize( - pyhf.infer.mle.loglambdav, + pyhf.infer.mle.twice_nll, data, pdf, init_pars, @@ -117,11 +117,11 @@ def test_optim_uncerts(backend, source, spec, mu): optim = pyhf.optimizer - result = optim.minimize(pyhf.infer.mle.loglambdav, data, pdf, init_pars, par_bounds) + result = optim.minimize(pyhf.infer.mle.twice_nll, data, pdf, init_pars, par_bounds) assert pyhf.tensorlib.tolist(result) result = optim.minimize( - pyhf.infer.mle.loglambdav, + pyhf.infer.mle.twice_nll, data, pdf, init_pars, From 962cdc302bcb89457d124d0abdb948577b7f0162 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Wed, 18 Dec 2019 10:13:57 +0100 Subject: [PATCH 62/72] rename objective --- .github/workflows/ci.yml | 2 +- src/pyhf/infer/utils.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2164e0afbc..31b68c4489 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -99,7 +99,7 @@ jobs: - name: Check docstrings run: | # Group 1 is related to docstrings - pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/infer/mle.py src/pyhf/optimize + pydocstyle --select D1 src/pyhf/pdf.py src/pyhf/probability.py src/pyhf/infer src/pyhf/optimize - name: Test and build docs run: | python -m doctest README.md diff --git a/src/pyhf/infer/utils.py b/src/pyhf/infer/utils.py index d6fa1d850f..1a77763ec2 100644 --- a/src/pyhf/infer/utils.py +++ b/src/pyhf/infer/utils.py @@ -4,6 +4,7 @@ def generate_asimov_data(asimov_mu, data, pdf, init_pars, par_bounds): + """Compute Asimov Dataset (expected yields at best-fit values) for a given POI value.""" bestfit_nuisance_asimov = fixed_poi_fit(asimov_mu, data, pdf, init_pars, par_bounds) return pdf.expected_data(bestfit_nuisance_asimov) From e4b8e2f5df6569cb38f0088336d15e3e3d7e0dbe Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Wed, 18 Dec 2019 10:37:28 +0100 Subject: [PATCH 63/72] rename objective --- src/pyhf/optimize/autodiff.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/pyhf/optimize/autodiff.py b/src/pyhf/optimize/autodiff.py index ae97da5584..5f0d3cec76 100644 --- a/src/pyhf/optimize/autodiff.py +++ b/src/pyhf/optimize/autodiff.py @@ -6,6 +6,10 @@ class AutoDiffOptimizerMixin(object): """Mixin Class to build optimizers that use automatic differentiation.""" + def __init__(*args,**kwargs): + """Create Mixin for autodiff-based optimizers.""" + pass + def minimize( self, objective, From d6854d4589b3700efb9c2fecb70e381605ea27c3 Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Thu, 19 Dec 2019 00:23:35 -0600 Subject: [PATCH 64/72] Apply Black --- src/pyhf/optimize/autodiff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyhf/optimize/autodiff.py b/src/pyhf/optimize/autodiff.py index 5f0d3cec76..0d717a78f4 100644 --- a/src/pyhf/optimize/autodiff.py +++ b/src/pyhf/optimize/autodiff.py @@ -6,7 +6,7 @@ class AutoDiffOptimizerMixin(object): """Mixin Class to build optimizers that use automatic differentiation.""" - def __init__(*args,**kwargs): + def __init__(*args, **kwargs): """Create Mixin for autodiff-based optimizers.""" pass From fd4c9cd2dada9c271447ff09246d60e68044ccb9 Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Thu, 19 Dec 2019 00:40:50 -0600 Subject: [PATCH 65/72] Apply Blackbook to mutlichannel coupled histo notebook --- .../multichannel-coupled-histo.ipynb | 244 ++++++++++-------- 1 file changed, 135 insertions(+), 109 deletions(-) diff --git a/docs/examples/notebooks/multichannel-coupled-histo.ipynb b/docs/examples/notebooks/multichannel-coupled-histo.ipynb index 7061864644..8c1b0eb1e1 100644 --- a/docs/examples/notebooks/multichannel-coupled-histo.ipynb +++ b/docs/examples/notebooks/multichannel-coupled-histo.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Multibin Coupled HistoSys" + "# Multibin Coupled HistoSys\n" ] }, { @@ -36,7 +36,7 @@ "import pyhf\n", "from pyhf import Model\n", "\n", - "logging.basicConfig(level = logging.INFO)" + "logging.basicConfig(level=logging.INFO)" ] }, { @@ -46,68 +46,73 @@ "outputs": [], "source": [ "def prep_data(sourcedata):\n", - " spec = {\n", - " 'channels': [\n", + " spec = {\n", + " \"channels\": [\n", " {\n", - " 'name': 'signal',\n", - " 'samples': [\n", + " \"name\": \"signal\",\n", + " \"samples\": [\n", " {\n", - " 'name': 'signal',\n", - " 'data': sourcedata['signal']['bindata']['sig'],\n", - " 'modifiers': [\n", - " {\n", - " 'name': 'mu',\n", - " 'type': 'normfactor',\n", - " 'data': None\n", - " }\n", - " ]\n", + " \"name\": \"signal\",\n", + " \"data\": sourcedata[\"signal\"][\"bindata\"][\"sig\"],\n", + " \"modifiers\": [\n", + " {\"name\": \"mu\", \"type\": \"normfactor\", \"data\": None}\n", + " ],\n", " },\n", " {\n", - " 'name': 'bkg1',\n", - " 'data': sourcedata['signal']['bindata']['bkg1'],\n", - " 'modifiers': [\n", + " \"name\": \"bkg1\",\n", + " \"data\": sourcedata[\"signal\"][\"bindata\"][\"bkg1\"],\n", + " \"modifiers\": [\n", " {\n", - " 'name': 'coupled_histosys',\n", - " 'type': 'histosys',\n", - " 'data': {'lo_data': sourcedata['signal']['bindata']['bkg1_dn'], 'hi_data': sourcedata['signal']['bindata']['bkg1_up']}\n", + " \"name\": \"coupled_histosys\",\n", + " \"type\": \"histosys\",\n", + " \"data\": {\n", + " \"lo_data\": sourcedata[\"signal\"][\"bindata\"][\"bkg1_dn\"],\n", + " \"hi_data\": sourcedata[\"signal\"][\"bindata\"][\"bkg1_up\"],\n", + " },\n", " }\n", - " ]\n", + " ],\n", " },\n", " {\n", - " 'name': 'bkg2',\n", - " 'data': sourcedata['signal']['bindata']['bkg2'],\n", - " 'modifiers': [\n", + " \"name\": \"bkg2\",\n", + " \"data\": sourcedata[\"signal\"][\"bindata\"][\"bkg2\"],\n", + " \"modifiers\": [\n", " {\n", - " 'name': 'coupled_histosys',\n", - " 'type': 'histosys',\n", - " 'data': {'lo_data': sourcedata['signal']['bindata']['bkg2_dn'], 'hi_data': sourcedata['signal']['bindata']['bkg2_up']}\n", + " \"name\": \"coupled_histosys\",\n", + " \"type\": \"histosys\",\n", + " \"data\": {\n", + " \"lo_data\": sourcedata[\"signal\"][\"bindata\"][\"bkg2_dn\"],\n", + " \"hi_data\": sourcedata[\"signal\"][\"bindata\"][\"bkg2_up\"],\n", + " },\n", " }\n", - " ]\n", - " }\n", - " ]\n", + " ],\n", + " },\n", + " ],\n", " },\n", " {\n", - " 'name': 'control',\n", - " 'samples': [\n", + " \"name\": \"control\",\n", + " \"samples\": [\n", " {\n", - " 'name': 'background',\n", - " 'data': sourcedata['control']['bindata']['bkg1'],\n", - " 'modifiers': [\n", + " \"name\": \"background\",\n", + " \"data\": sourcedata[\"control\"][\"bindata\"][\"bkg1\"],\n", + " \"modifiers\": [\n", " {\n", - " 'name': 'coupled_histosys',\n", - " 'type': 'histosys',\n", - " 'data': {'lo_data': sourcedata['control']['bindata']['bkg1_dn'], 'hi_data': sourcedata['control']['bindata']['bkg1_up']}\n", + " \"name\": \"coupled_histosys\",\n", + " \"type\": \"histosys\",\n", + " \"data\": {\n", + " \"lo_data\": sourcedata[\"control\"][\"bindata\"][\"bkg1_dn\"],\n", + " \"hi_data\": sourcedata[\"control\"][\"bindata\"][\"bkg1_up\"],\n", + " },\n", " }\n", - " ]\n", + " ],\n", " }\n", - " ]\n", - " }\n", + " ],\n", + " },\n", " ]\n", " }\n", - " pdf = Model(spec)\n", + " pdf = Model(spec)\n", " data = []\n", - " for c in pdf.spec['channels']:\n", - " data += sourcedata[c['name']]['bindata']['data']\n", + " for c in pdf.spec[\"channels\"]:\n", + " data += sourcedata[c[\"name\"]][\"bindata\"][\"data\"]\n", " data = data + pdf.config.auxdata\n", " return data, pdf" ] @@ -122,30 +127,39 @@ }, "outputs": [], "source": [ - "validation_datadir = '../../validation/data'" + "validation_datadir = \"../../validation/data\"" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 5, "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'json' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msource\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalidation_datadir\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'/2bin_2channel_coupledhisto.json'\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 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprep_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msource\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'channels'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'json' is not defined" + "name": "stdout", + "output_type": "stream", + "text": [ + "[170.0, 220.0, 110.0, 105.0, 0.0]\n", + "parameters post unconstrained fit: [1.53170588e-12 2.21657891e+00]\n", + "parameters post constrained fit: [0. 2.21655133]\n" ] + }, + { + "data": { + "text/plain": [ + "array([116.08275666, 133.24826999, 183.24826999, 98.08967672,\n", + " 2.21655133])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "source = json.load(open(validation_datadir + '/2bin_2channel_coupledhisto.json'))\n", + "source = json.load(open(validation_datadir + \"/2bin_2channel_coupledhisto.json\"))\n", "\n", - "data, pdf = prep_data(source['channels'])\n", + "data, pdf = prep_data(source[\"channels\"])\n", "\n", "print(data)\n", "\n", @@ -153,10 +167,10 @@ "par_bounds = pdf.config.suggested_bounds()\n", "\n", "unconpars = pyhf.infer.mle.fit(data, pdf, init_pars, par_bounds)\n", - "print('parameters post unconstrained fit: {}'.format(unconpars))\n", + "print(\"parameters post unconstrained fit: {}\".format(unconpars))\n", "\n", "conpars = pyhf.infer.mle.fixed_poi_fit(0.0, data, pdf, init_pars, par_bounds)\n", - "print('parameters post constrained fit: {}'.format(conpars))\n", + "print(\"parameters post constrained fit: {}\".format(conpars))\n", "\n", "pdf.expected_data(conpars)" ] @@ -164,26 +178,65 @@ { "cell_type": "code", "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_results(test_mus, cls_obs, cls_exp, poi_tests, test_size=0.05):\n", + " plt.plot(poi_tests, cls_obs, c=\"k\")\n", + " for i, c in zip(range(5), [\"grey\", \"grey\", \"grey\", \"grey\", \"grey\"]):\n", + " plt.plot(poi_tests, cls_exp[i], c=c)\n", + " plt.plot(poi_tests, [test_size] * len(test_mus), c=\"r\")\n", + " plt.ylim(0, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def invert_interval(test_mus, cls_obs, cls_exp, test_size=0.05):\n", + " crossing_test_stats = {\"exp\": [], \"obs\": None}\n", + " for cls_exp_sigma in cls_exp:\n", + " crossing_test_stats[\"exp\"].append(\n", + " np.interp(\n", + " test_size, list(reversed(cls_exp_sigma)), list(reversed(test_mus))\n", + " )\n", + " )\n", + " crossing_test_stats[\"obs\"] = np.interp(\n", + " test_size, list(reversed(cls_obs)), list(reversed(test_mus))\n", + " )\n", + " return crossing_test_stats" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "poi_tests = np.linspace(0, 5, 61)\n", + "tests = [\n", + " pyhf.infer.hypotest(\n", + " poi_test, data, pdf, init_pars, par_bounds, return_expected_set=True\n", + " )\n", + " for poi_test in poi_tests\n", + "]\n", + "cls_obs = np.array([test[0] for test in tests]).flatten()\n", + "cls_exp = [np.array([test[1][i] for test in tests]).flatten() for i in range(5)]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, "metadata": { "scrolled": false }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pyhf.pdf:Validating spec against schema: /home/jovyan/pyhf/src/pyhf/data/spec.json\n", - "INFO:pyhf.pdf:adding modifier mu (1 new nuisance parameters)\n", - "INFO:pyhf.pdf:adding modifier coupled_histosys (1 new nuisance parameters)\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "[170.0, 220.0, 110.0, 105.0, 0.0]\n", - "parameters post unconstrained fit: [1.05563069e-12 4.00000334e+00]\n", - "parameters post constrained fit: [0. 4.00000146]\n", "\n", "\n" ] @@ -191,21 +244,21 @@ { "data": { "text/plain": [ - "{'exp': [0.37566312243018246,\n", - " 0.49824494455027707,\n", - " 0.7023047842202288,\n", - " 0.9869744452422563,\n", - " 1.3443167343146392],\n", - " 'obs': 0.329179494864517}" + "{'exp': [0.3654675198094938,\n", + " 0.4882076670368835,\n", + " 0.683262284467055,\n", + " 0.9650584704888153,\n", + " 1.3142329292131938],\n", + " 'obs': 0.3932476110375604}" ] }, - "execution_count": 6, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -217,34 +270,7 @@ } ], "source": [ - "def plot_results(test_mus, cls_obs, cls_exp, poi_tests, test_size = 0.05):\n", - " plt.plot(poi_tests,cls_obs, c = 'k')\n", - " for i,c in zip(range(5),['grey','grey','grey','grey','grey']):\n", - " plt.plot(poi_tests, cls_exp[i], c = c)\n", - " plt.plot(poi_tests,[test_size]*len(test_mus), c = 'r')\n", - " plt.ylim(0,1)\n", - "\n", - "def invert_interval(test_mus, cls_obs, cls_exp, test_size=0.05):\n", - " crossing_test_stats = {'exp': [], 'obs': None}\n", - " for cls_exp_sigma in cls_exp:\n", - " crossing_test_stats['exp'].append(\n", - " np.interp(\n", - " test_size, list(reversed(cls_exp_sigma)), list(reversed(test_mus))\n", - " )\n", - " )\n", - " crossing_test_stats['obs'] = np.interp(\n", - " test_size, list(reversed(cls_obs)), list(reversed(test_mus))\n", - " )\n", - " return crossing_test_stats\n", - "\n", - "\n", - "poi_tests = np.linspace(0, 5, 61)\n", - "tests = [pyhf.infer.hypotest(poi_test, data, pdf, init_pars, par_bounds, return_expected_set=True) \n", - " for poi_test in poi_tests]\n", - "cls_obs = np.array([test[0] for test in tests]).flatten()\n", - "cls_exp = [np.array([test[1][i] for test in tests]).flatten() for i in range(5)]\n", - "\n", - "print('\\n')\n", + "print(\"\\n\")\n", "plot_results(poi_tests, cls_obs, cls_exp, poi_tests)\n", "invert_interval(poi_tests, cls_obs, cls_exp)" ] @@ -266,9 +292,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.6" + "version": "3.7.5" } }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} From bdbe49129271a16893414d72ed7695f6ef979ac8 Mon Sep 17 00:00:00 2001 From: Matthew Feickert Date: Thu, 19 Dec 2019 00:47:17 -0600 Subject: [PATCH 66/72] Apply blackbook to pull plot notebook --- docs/examples/notebooks/pullplot.ipynb | 152 +++++++++++++------------ 1 file changed, 78 insertions(+), 74 deletions(-) diff --git a/docs/examples/notebooks/pullplot.ipynb b/docs/examples/notebooks/pullplot.ipynb index cb9d6c22a9..94c7bed297 100644 --- a/docs/examples/notebooks/pullplot.ipynb +++ b/docs/examples/notebooks/pullplot.ipynb @@ -1,6 +1,10 @@ { "cells": [ { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], "source": [ "import pyhf\n", "import json\n", @@ -8,35 +12,37 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline" - ], - "cell_type": "code", - "outputs": [], - "metadata": {}, - "execution_count": 1 + ] }, { - "source": [ - "!curl -sL https://doi.org/10.17182/hepdata.89408.v1/r2 | tar -O -xzv RegionA/BkgOnly.json > lhood.json" - ], "cell_type": "code", + "execution_count": 2, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", - "text": "x RegionA/BkgOnly.json\n" + "output_type": "stream", + "text": [ + "RegionA/BkgOnly.json\r\n" + ] } ], - "metadata": {}, - "execution_count": 2 + "source": [ + "!curl -sL https://doi.org/10.17182/hepdata.89408.v1/r2 | tar -O -xzv RegionA/BkgOnly.json > lhood.json" + ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Create the Model and Fit it" + "### Create the Model and Fit it\n" ] }, { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], "source": [ "def make_model(channel_list):\n", " spec = json.load(open(\"lhood.json\"))\n", @@ -44,71 +50,79 @@ " spec[\"channels\"] = [c for c in spec[\"channels\"] if c[\"name\"] in channel_list]\n", " spec[\"measurements\"][0][\"config\"][\"poi\"] = \"lumi\"\n", "\n", - " w = pyhf.Workspace(spec)\n", - " m = w.model(\n", + " ws = pyhf.Workspace(spec)\n", + " model = ws.model(\n", " measurement_name=\"NormalMeasurement\",\n", " modifier_settings={\n", " \"normsys\": {\"interpcode\": \"code4\"},\n", " \"histosys\": {\"interpcode\": \"code4p\"},\n", " },\n", " )\n", - " d = w.data(m)\n", - " return w, m, d\n", - "\n", - "\n", + " data = ws.data(model)\n", + " return ws, model, data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ "def fitresults(constraints=None):\n", " _, model, data = make_model([\"CRtt_meff\"])\n", "\n", " pyhf.set_backend(\"numpy\", pyhf.optimize.minuit_optimizer(verbose=True))\n", " result = pyhf.infer.mle.fit(\n", - " data,\n", - " model,\n", - " fixed_vals = constraints,\n", - " return_uncertainties = True\n", + " data, model, fixed_vals=constraints, return_uncertainties=True\n", " )\n", - " bestfit = result[:,0]\n", - " errors = result[:,1]\n", - " return model, data, bestfit, errors\n", - "\n", - "\n", - "\n", - "m, data, bestfit, errors = fitresults()" - ], + " bestfit = result[:, 0]\n", + " errors = result[:, 1]\n", + " return model, data, bestfit, errors" + ] + }, + { "cell_type": "code", - "outputs": [], + "execution_count": 5, "metadata": {}, - "execution_count": 3 + "outputs": [], + "source": [ + "model, data, bestfit, errors = fitresults()" + ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Normalize to natural width and order results" + "## Normalize to natural width and order results\n" ] }, { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], "source": [ "pulls = pyhf.tensorlib.concatenate(\n", " [\n", - " (bestfit[m.config.par_slice(k)] - m.config.param_set(k).suggested_init)\n", - " / m.config.param_set(k).width()\n", - " for k in m.config.par_order\n", - " if m.config.param_set(k).constrained\n", + " (bestfit[model.config.par_slice(k)] - model.config.param_set(k).suggested_init)\n", + " / model.config.param_set(k).width()\n", + " for k in model.config.par_order\n", + " if model.config.param_set(k).constrained\n", " ]\n", ")\n", "pullerr = pyhf.tensorlib.concatenate(\n", " [\n", - " errors[m.config.par_slice(k)] / m.config.param_set(k).width()\n", - " for k in m.config.par_order\n", - " if m.config.param_set(k).constrained\n", + " errors[model.config.par_slice(k)] / model.config.param_set(k).width()\n", + " for k in model.config.par_order\n", + " if model.config.param_set(k).constrained\n", " ]\n", ")\n", "labels = np.asarray(\n", " [\n", - " \"{}[{}]\".format(k, i) if m.config.param_set(k).n_parameters > 1 else k\n", - " for k in m.config.par_order\n", - " if m.config.param_set(k).constrained\n", - " for i in range(m.config.param_set(k).n_parameters)\n", + " \"{}[{}]\".format(k, i) if model.config.param_set(k).n_parameters > 1 else k\n", + " for k in model.config.par_order\n", + " if model.config.param_set(k).constrained\n", + " for i in range(model.config.param_set(k).n_parameters)\n", " ]\n", ")\n", "\n", @@ -118,20 +132,26 @@ "labels = labels[order]\n", "pulls = pulls[order]\n", "pullerr = pullerr[order]" - ], - "cell_type": "code", - "outputs": [], - "metadata": {}, - "execution_count": 4 + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], - "source": [] - }, - { + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.hlines([-2, 2], -0.5, len(pulls) - 0.5, colors=\"k\", linestyles=\"dotted\")\n", "plt.hlines([-1, 1], -0.5, len(pulls) - 0.5, colors=\"k\", linestyles=\"dashdot\")\n", @@ -147,23 +167,7 @@ "plt.xlim(-0.5, len(pulls) - 0.5)\n", "plt.title(\"Pull Plot\", fontsize=18)\n", "plt.ylabel(r\"$(\\theta - \\hat{\\theta})\\,/ \\Delta \\theta$\", fontsize=18);" - ], - "cell_type": "code", - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {}, - "execution_count": 5 + ] } ], "metadata": { @@ -182,9 +186,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.6" + "version": "3.7.5" } }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} From ff9254d515a538aa7198ef04cbf50a340855237d Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Thu, 19 Dec 2019 17:31:24 +0100 Subject: [PATCH 67/72] remove unsed poi_index --- src/pyhf/infer/mle.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 4976b33250..9a9e8686d9 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -37,7 +37,7 @@ def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): def fixed_poi_fit( - poi_val, data, pdf, init_pars=None, par_bounds=None, poi_index=None, **kwargs + poi_val, data, pdf, init_pars=None, par_bounds=None, **kwargs ): """ Run a maximum likelihood fit with the POI value fixzed. From d9e223aee55053c107a3c2dd14253107a688e6fc Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Thu, 19 Dec 2019 18:09:21 +0100 Subject: [PATCH 68/72] appease giordon --- src/pyhf/infer/test_statistics.py | 4 ++-- src/pyhf/optimize/autodiff.py | 8 ++++---- src/pyhf/optimize/opt_minuit.py | 4 ++-- src/pyhf/optimize/opt_scipy.py | 4 ++-- tests/test_optim.py | 4 ++-- 5 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/pyhf/infer/test_statistics.py b/src/pyhf/infer/test_statistics.py index ca5647ba75..13749e13b3 100644 --- a/src/pyhf/infer/test_statistics.py +++ b/src/pyhf/infer/test_statistics.py @@ -31,9 +31,9 @@ def qmu(mu, data, pdf, init_pars, par_bounds): """ tensorlib, optimizer = get_backend() mubhathat, fixed_val = fixed_poi_fit( - mu, data, pdf, init_pars, par_bounds, return_fval=True + mu, data, pdf, init_pars, par_bounds, return_fitted_val=True ) - muhatbhat, float_val = fit(data, pdf, init_pars, par_bounds, return_fval=True) + muhatbhat, float_val = fit(data, pdf, init_pars, par_bounds, return_fitted_val=True) qmu = fixed_val - float_val qmu = tensorlib.where( muhatbhat[pdf.config.poi_index] > mu, tensorlib.astensor([0]), qmu diff --git a/src/pyhf/optimize/autodiff.py b/src/pyhf/optimize/autodiff.py index 0d717a78f4..8810395041 100644 --- a/src/pyhf/optimize/autodiff.py +++ b/src/pyhf/optimize/autodiff.py @@ -18,7 +18,7 @@ def minimize( init_pars, par_bounds, fixed_vals=None, - return_fval=False, + return_fitted_val=False, ): """ Find Function Parameters that minimize the Objective. @@ -35,10 +35,10 @@ def minimize( func, init, method='SLSQP', jac=True, bounds=bounds ) nonfixed_vals = fitresult.x - fitted_fval = fitresult.fun + fitted_val = fitresult.fun fitted_pars = tv.stitch( [fixed_values_tensor, tensorlib.astensor(nonfixed_vals)] ) - if return_fval: - return fitted_pars, tensorlib.astensor(fitted_fval) + if return_fitted_val: + return fitted_pars, tensorlib.astensor(fitted_val) return fitted_pars diff --git a/src/pyhf/optimize/opt_minuit.py b/src/pyhf/optimize/opt_minuit.py index 62f3bd38f9..dbcc5766f0 100644 --- a/src/pyhf/optimize/opt_minuit.py +++ b/src/pyhf/optimize/opt_minuit.py @@ -64,7 +64,7 @@ def minimize( init_pars, par_bounds, fixed_vals=None, - return_fval=False, + return_fitted_val=False, return_uncertainties=False, ): """ @@ -82,6 +82,6 @@ def minimize( else: bestfit_pars = np.asarray([v for k, v in mm.values.items()]) bestfit_value = mm.fval - if return_fval: + if return_fitted_val: return bestfit_pars, bestfit_value return bestfit_pars diff --git a/src/pyhf/optimize/opt_scipy.py b/src/pyhf/optimize/opt_scipy.py index d2064609f4..408754f6d2 100644 --- a/src/pyhf/optimize/opt_scipy.py +++ b/src/pyhf/optimize/opt_scipy.py @@ -21,7 +21,7 @@ def minimize( init_pars, par_bounds, fixed_vals=None, - return_fval=False, + return_fitted_val=False, ): """ Find Function Parameters that minimize the Objective. @@ -48,6 +48,6 @@ def minimize( except AssertionError: log.error(result) raise - if return_fval: + if return_fitted_val: return result.x, result.fun return result.x diff --git a/tests/test_optim.py b/tests/test_optim.py index df2bc7aaeb..c344c3a318 100644 --- a/tests/test_optim.py +++ b/tests/test_optim.py @@ -94,14 +94,14 @@ def test_optim_with_value(backend, source, spec, mu): result = optim.minimize(pyhf.infer.mle.twice_nll, data, pdf, init_pars, par_bounds) assert pyhf.tensorlib.tolist(result) - result, fval = optim.minimize( + result, fitted_val = optim.minimize( pyhf.infer.mle.twice_nll, data, pdf, init_pars, par_bounds, [(pdf.config.poi_index, mu)], - return_fval=True, + return_fitted_val=True, ) assert pyhf.tensorlib.tolist(result) From acd97fc3b418de8ff352a73db3998e522656d3c4 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Fri, 20 Dec 2019 23:34:43 +0100 Subject: [PATCH 69/72] name --- src/pyhf/infer/test_statistics.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/pyhf/infer/test_statistics.py b/src/pyhf/infer/test_statistics.py index 13749e13b3..35d982996d 100644 --- a/src/pyhf/infer/test_statistics.py +++ b/src/pyhf/infer/test_statistics.py @@ -30,11 +30,11 @@ def qmu(mu, data, pdf, init_pars, par_bounds): Float: The calculated test statistic, :math:`q_{\mu}` """ tensorlib, optimizer = get_backend() - mubhathat, fixed_val = fixed_poi_fit( + mubhathat, fixed_poi_fit_lhood_val = fixed_poi_fit( mu, data, pdf, init_pars, par_bounds, return_fitted_val=True ) - muhatbhat, float_val = fit(data, pdf, init_pars, par_bounds, return_fitted_val=True) - qmu = fixed_val - float_val + muhatbhat, unconstrained_fit_lhood_val = fit(data, pdf, init_pars, par_bounds, return_fitted_val=True) + qmu = fixed_poi_fit_lhood_val - unconstrained_fit_lhood_val qmu = tensorlib.where( muhatbhat[pdf.config.poi_index] > mu, tensorlib.astensor([0]), qmu ) From f638adfe6570cc96996ba149ab6d890f2f101a81 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Fri, 20 Dec 2019 23:55:26 +0100 Subject: [PATCH 70/72] name --- src/pyhf/cli/infer.py | 4 ++-- src/pyhf/infer/mle.py | 4 +--- src/pyhf/infer/test_statistics.py | 4 +++- src/pyhf/tensor/pytorch_backend.py | 10 +++++----- src/pyhf/tensor/tensorflow_backend.py | 13 ++++++------- tests/conftest.py | 4 ++-- 6 files changed, 19 insertions(+), 20 deletions(-) diff --git a/src/pyhf/cli/infer.py b/src/pyhf/cli/infer.py index 1ff0c8f5db..7e2c5d6e47 100644 --- a/src/pyhf/cli/infer.py +++ b/src/pyhf/cli/infer.py @@ -66,11 +66,11 @@ def cls( # set the backend if not NumPy if backend in ['pytorch', 'torch']: - set_backend(tensor.pytorch_backend(float = 'float64')) + set_backend(tensor.pytorch_backend(float='float64')) elif backend in ['tensorflow', 'tf']: from tensorflow.compat.v1 import Session - set_backend(tensor.tensorflow_backend(session=Session(),float = 'float64')) + set_backend(tensor.tensorflow_backend(session=Session(), float='float64')) tensorlib, _ = get_backend() optconf = {k: v for item in optconf for k, v in item.items()} diff --git a/src/pyhf/infer/mle.py b/src/pyhf/infer/mle.py index 9a9e8686d9..f0f5d5901e 100644 --- a/src/pyhf/infer/mle.py +++ b/src/pyhf/infer/mle.py @@ -36,9 +36,7 @@ def fit(data, pdf, init_pars=None, par_bounds=None, **kwargs): return opt.minimize(twice_nll, data, pdf, init_pars, par_bounds, **kwargs) -def fixed_poi_fit( - poi_val, data, pdf, init_pars=None, par_bounds=None, **kwargs -): +def fixed_poi_fit(poi_val, data, pdf, init_pars=None, par_bounds=None, **kwargs): """ Run a maximum likelihood fit with the POI value fixzed. diff --git a/src/pyhf/infer/test_statistics.py b/src/pyhf/infer/test_statistics.py index 35d982996d..6efb12cef0 100644 --- a/src/pyhf/infer/test_statistics.py +++ b/src/pyhf/infer/test_statistics.py @@ -33,7 +33,9 @@ def qmu(mu, data, pdf, init_pars, par_bounds): mubhathat, fixed_poi_fit_lhood_val = fixed_poi_fit( mu, data, pdf, init_pars, par_bounds, return_fitted_val=True ) - muhatbhat, unconstrained_fit_lhood_val = fit(data, pdf, init_pars, par_bounds, return_fitted_val=True) + muhatbhat, unconstrained_fit_lhood_val = fit( + data, pdf, init_pars, par_bounds, return_fitted_val=True + ) qmu = fixed_poi_fit_lhood_val - unconstrained_fit_lhood_val qmu = tensorlib.where( muhatbhat[pdf.config.poi_index] > mu, tensorlib.astensor([0]), qmu diff --git a/src/pyhf/tensor/pytorch_backend.py b/src/pyhf/tensor/pytorch_backend.py index bf16b6b754..c3349ad013 100644 --- a/src/pyhf/tensor/pytorch_backend.py +++ b/src/pyhf/tensor/pytorch_backend.py @@ -12,9 +12,9 @@ class pytorch_backend(object): def __init__(self, **kwargs): self.name = 'pytorch' self.dtypemap = { - 'float': getattr(torch,kwargs.get('float','float32')), - 'int': getattr(torch,kwargs.get('float','int32')), - 'bool': torch.bool + 'float': getattr(torch, kwargs.get('float', 'float32')), + 'int': getattr(torch, kwargs.get('float', 'int32')), + 'bool': torch.bool, } def clip(self, tensor_in, min_value, max_value): @@ -146,10 +146,10 @@ def abs(self, tensor): return torch.abs(tensor) def ones(self, shape): - return torch.ones(shape,dtype = self.dtypemap['float']) + return torch.ones(shape, dtype=self.dtypemap['float']) def zeros(self, shape): - return torch.zeros(shape,dtype = self.dtypemap['float']) + return torch.zeros(shape, dtype=self.dtypemap['float']) def power(self, tensor_in_1, tensor_in_2): return torch.pow(tensor_in_1, tensor_in_2) diff --git a/src/pyhf/tensor/tensorflow_backend.py b/src/pyhf/tensor/tensorflow_backend.py index be9fac81dc..957a8c79a7 100644 --- a/src/pyhf/tensor/tensorflow_backend.py +++ b/src/pyhf/tensor/tensorflow_backend.py @@ -13,9 +13,9 @@ def __init__(self, **kwargs): self.session = kwargs.get('session') self.name = 'tensorflow' self.dtypemap = { - 'float': getattr(tf,kwargs.get('float','float32')), - 'int': getattr(tf,kwargs.get('int','int32')), - 'bool': tf.bool + 'float': getattr(tf, kwargs.get('float', 'float32')), + 'int': getattr(tf, kwargs.get('int', 'int32')), + 'bool': tf.bool, } def clip(self, tensor_in, min_value, max_value): @@ -203,10 +203,10 @@ def abs(self, tensor): return tf.abs(tensor) def ones(self, shape): - return tf.ones(shape,dtype = self.dtypemap['float']) + return tf.ones(shape, dtype=self.dtypemap['float']) def zeros(self, shape): - return tf.zeros(shape,dtype = self.dtypemap['float']) + return tf.zeros(shape, dtype=self.dtypemap['float']) def power(self, tensor_in_1, tensor_in_2): return tf.pow(tensor_in_1, tensor_in_2) @@ -478,8 +478,7 @@ def normal_cdf(self, x, mu=0.0, sigma=1): TensorFlow Tensor: The CDF """ normal = tfp.distributions.Normal( - self.astensor(mu,dtype='float'), - self.astensor(sigma,dtype='float'), + self.astensor(mu, dtype='float'), self.astensor(sigma, dtype='float'), ) return normal.cdf(x) diff --git a/tests/conftest.py b/tests/conftest.py index 7d44cf0620..579484c78a 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -44,14 +44,14 @@ def reset_backend(): params=[ (pyhf.tensor.numpy_backend(), None), (pyhf.tensor.pytorch_backend(), None), - (pyhf.tensor.pytorch_backend(float = 'float64', int = 'int64'), None), + (pyhf.tensor.pytorch_backend(float='float64', int='int64'), None), (pyhf.tensor.tensorflow_backend(session=tf.compat.v1.Session()), None), ( pyhf.tensor.numpy_backend(poisson_from_normal=True), pyhf.optimize.minuit_optimizer(), ), ], - ids=['numpy', 'pytorch','pytorch64','tensorflow', 'numpy_minuit'], + ids=['numpy', 'pytorch', 'pytorch64', 'tensorflow', 'numpy_minuit'], ) def backend(request): # a better way to get the id? all the backends we have so far for testing From 4bc57f5548c5028ce923d3fbd5af74f922429662 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Sat, 21 Dec 2019 00:37:19 +0100 Subject: [PATCH 71/72] doctest --- src/pyhf/tensor/tensorflow_backend.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyhf/tensor/tensorflow_backend.py b/src/pyhf/tensor/tensorflow_backend.py index 957a8c79a7..a4c86e3601 100644 --- a/src/pyhf/tensor/tensorflow_backend.py +++ b/src/pyhf/tensor/tensorflow_backend.py @@ -478,7 +478,7 @@ def normal_cdf(self, x, mu=0.0, sigma=1): TensorFlow Tensor: The CDF """ normal = tfp.distributions.Normal( - self.astensor(mu, dtype='float'), self.astensor(sigma, dtype='float'), + self.astensor(mu, dtype='float')[0], self.astensor(sigma, dtype='float')[0], ) return normal.cdf(x) From 2d1b8807b0bc4aa3b65e74660e4e8041799e8129 Mon Sep 17 00:00:00 2001 From: Lukas Heinrich Date: Sun, 22 Dec 2019 16:25:03 +0100 Subject: [PATCH 72/72] codefactor --- src/pyhf/optimize/autodiff.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/pyhf/optimize/autodiff.py b/src/pyhf/optimize/autodiff.py index 8810395041..bf499bb8a6 100644 --- a/src/pyhf/optimize/autodiff.py +++ b/src/pyhf/optimize/autodiff.py @@ -8,7 +8,6 @@ class AutoDiffOptimizerMixin(object): def __init__(*args, **kwargs): """Create Mixin for autodiff-based optimizers.""" - pass def minimize( self,