From d1959e7c9dd2bd91be735b952d5dd55cc04e278b Mon Sep 17 00:00:00 2001 From: Krishnamoorthi Jayakumar <43264985+JKrishnamoorthi@users.noreply.github.com> Date: Sat, 20 Jan 2024 14:16:01 +0530 Subject: [PATCH 1/2] Re-shaped the mod_chi2's return to match the input shape (#760) I'm merging this anyway// --- pisa/utils/stats.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pisa/utils/stats.py b/pisa/utils/stats.py index f4d0a4f9a..cba88805d 100644 --- a/pisa/utils/stats.py +++ b/pisa/utils/stats.py @@ -568,7 +568,7 @@ def mod_chi2(actual_values, expected_values): the inputs """ - + in_array_shape = np.shape(actual_values) actual_values = unp.nominal_values(actual_values).ravel() sigma = unp.std_devs(expected_values).ravel() expected_values = unp.nominal_values(expected_values).ravel() @@ -587,7 +587,8 @@ def mod_chi2(actual_values, expected_values): m_chi2 = ( (actual_values - expected_values)**2 / (sigma**2 + expected_values) ) - + + m_chi2 = m_chi2.reshape(in_array_shape) return m_chi2 def correct_chi2(actual_values, expected_values): From fef483b30c2f318c6651067e360fd6b8126e0f93 Mon Sep 17 00:00:00 2001 From: Maria Liubarska <41995542+marialiubarska@users.noreply.github.com> Date: Fri, 2 Feb 2024 05:43:37 -0700 Subject: [PATCH 2/2] adding DAEMONFLUX stage (#761) * adding daemon flux stage and pisa example, daemonflux is a dependency for the stage * update documentation to include daemonflux and list it as dependency (did not try to ad it to setup.py since MCEq is not included anyway and I don't want to break stuff); also tested daemon stage in calc_grid mode (no modifications needed for it to work) * okay add daemonflux to dependencies * move daemonflux to INSTALL_REQUIRES * resolve conflict --------- Co-authored-by: Maria Liubarska --- INSTALL.md | 1 + pisa/stages/flux/README.md | 7 + pisa/stages/flux/daemon_flux.py | 222 ++++ .../pipeline/IceCube_3y_neutrinos_daemon.cfg | 270 ++++ pisa_examples/test_daemonflux_stage.ipynb | 1110 +++++++++++++++++ setup.py | 1 + 6 files changed, 1611 insertions(+) create mode 100644 pisa/stages/flux/daemon_flux.py create mode 100644 pisa_examples/resources/settings/pipeline/IceCube_3y_neutrinos_daemon.cfg create mode 100644 pisa_examples/test_daemonflux_stage.ipynb diff --git a/INSTALL.md b/INSTALL.md index 01a887026..faf2180e1 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -184,6 +184,7 @@ Optional dependencies. Some of these must be installed manually prior to install * [LeptonWeighter](https://github.com/icecube/leptonweighter) Required for the `data.licloader_weighter` service. * [MCEq](http://github.com/afedynitch/MCEq) Required for `flux.mceq` service. +* [daemonflux](https://github.com/mceq-project/daemonflux) Recuired for `flux.daemon_flux` service. * [nuSQuiDS](https://github.com/arguelles/nuSQuIDS) Required for `osc.nusquids` service. * [pandas](https://pandas.pydata.org/) Required for datarelease (csv) stages. * [OpenMP](http://www.openmp.org) Intra-process parallelization to accelerate code on on multi-core/multi-CPU computers. diff --git a/pisa/stages/flux/README.md b/pisa/stages/flux/README.md index a7300c191..069063d4f 100644 --- a/pisa/stages/flux/README.md +++ b/pisa/stages/flux/README.md @@ -25,3 +25,10 @@ For some more information on the second of these choices, and why it is a more a [NuFlux on the IceCube wiki](https://wiki.icecube.wisc.edu/index.php/NuFlux) Since this is a link on the IceCube wiki, you will need the access permissions for this page. + +### daemonflux + +Implementation of DAEMONFLUX based on [https://arxiv.org/abs/2303.00022]. +For the example use see jupyter notebook `pisa_examples/test_daemonflux_stage.ipynb`, as well as an example config file at `pisa_examples/resources/settings/pipeline/IceCube_3y_neutrinos_daemon.cfg`. + +Important: [daemonflux](https://github.com/mceq-project/daemonflux) pyhon package is required dependency for this stage. \ No newline at end of file diff --git a/pisa/stages/flux/daemon_flux.py b/pisa/stages/flux/daemon_flux.py new file mode 100644 index 000000000..d21ef8bab --- /dev/null +++ b/pisa/stages/flux/daemon_flux.py @@ -0,0 +1,222 @@ +""" +Implementation of DEAMON flux (https://arxiv.org/abs/2303.00022) +by Juan Pablo YaƱez and Anatoli Fedynitch for use in PISA. + +Maria Liubarska, J.P. Yanez 2023 +""" + +import numpy as np +from daemonflux import Flux + +from pisa import FTYPE, TARGET +from pisa.core.stage import Stage +from pisa.utils.log import logging +from pisa.utils.profiler import profile +from numba import jit +from scipy import interpolate + + +class daemon_flux(Stage): + """ + DEAMON fulx stage + + Parameters + ---------- + + params: ParamSet + Must have parameters: .. :: + + K_158G : quantity (dimensionless) + + K_2P : quantity (dimensionless) + + K_31G : quantity (dimensionless) + + antiK_158G : quantity (dimensionless) + + antiK_2P : quantity (dimensionless) + + antiK_31G : quantity (dimensionless) + + n_158G : quantity (dimensionless) + + n_2P : quantity (dimensionless) + + p_158G : quantity (dimensionless) + + p_2P : quantity (dimensionless) + + pi_158G : quantity (dimensionless) + + pi_20T : quantity (dimensionless) + + pi_2P : quantity (dimensionless) + + pi_31G : quantity (dimensionless) + + antipi_158G : quantity (dimensionless) + + antipi_20T : quantity (dimensionless) + + antipi_2P : quantity (dimensionless) + + antipi_31G : quantity (dimensionless) + + GSF_1 : quantity (dimensionless) + + GSF_2 : quantity (dimensionless) + + GSF_3 : quantity (dimensionless) + + GSF_4 : quantity (dimensionless) + + GSF_5 : quantity (dimensionless) + + GSF_6 : quantity (dimensionless) + + """ + + def __init__( + self, + **std_kwargs, + ): + + self.deamon_params = ['K_158G', + 'K_2P', + 'K_31G', + 'antiK_158G', + 'antiK_2P', + 'antiK_31G', + 'n_158G', + 'n_2P', + 'p_158G', + 'p_2P', + 'pi_158G', + 'pi_20T', + 'pi_2P', + 'pi_31G', + 'antipi_158G', + 'antipi_20T', + 'antipi_2P', + 'antipi_31G', + 'GSF_1', + 'GSF_2', + 'GSF_3', + 'GSF_4', + 'GSF_5', + 'GSF_6', + ] + + self.deamon_names = ['K+_158G', + 'K+_2P', + 'K+_31G', + 'K-_158G', + 'K-_2P', + 'K-_31G', + 'n_158G', + 'n_2P', + 'p_158G', + 'p_2P', + 'pi+_158G', + 'pi+_20T', + 'pi+_2P', + 'pi+_31G', + 'pi-_158G', + 'pi-_20T', + 'pi-_2P', + 'pi-_31G', + 'GSF_1', + 'GSF_2', + 'GSF_3', + 'GSF_4', + 'GSF_5', + 'GSF_6', + ] + + # init base class + super(daemon_flux, self).__init__( + expected_params=tuple(self.deamon_params), + **std_kwargs, + ) + + def setup_function(self): + + self.data.representation = self.calc_mode + + self.flux_obj = Flux(location='IceCube') + + for container in self.data: + container['nu_flux'] = np.empty((container.size, 2), dtype=FTYPE) + + @profile + def compute_function(self): + + self.data.representation = self.calc_mode + + # get modified parameters (in units of sigma) + modif_param_dict = {} + for i,k in enumerate(self.deamon_params): + modif_param_dict[self.deamon_names[i]] = getattr(self.params, k).value.m_as("dimensionless") + + flux_map_numu = make_2d_flux_map(self.flux_obj, + particle = 'numu', + params = modif_param_dict) + flux_map_numubar = make_2d_flux_map(self.flux_obj, + particle = 'antinumu', + params = modif_param_dict) + flux_map_nue = make_2d_flux_map(self.flux_obj, + particle = 'nue', + params = modif_param_dict) + flux_map_nuebar = make_2d_flux_map(self.flux_obj, + particle = 'antinue', + params = modif_param_dict) + + + # calc modified flux using provided parameters + for container in self.data: + nubar = container['nubar'] + + nue_flux = evaluate_flux_map(flux_map_nuebar if nubar>0 else flux_map_nue, + container['true_energy'], + container['true_coszen']) + + numu_flux = evaluate_flux_map(flux_map_numubar if nubar>0 else flux_map_numu, + container['true_energy'], + container['true_coszen']) + + + container['nu_flux'][:,0] = nue_flux + container['nu_flux'][:,1] = numu_flux + + container.mark_changed("nu_flux") + +@jit(forceobj=True) +def make_2d_flux_map(flux_obj, + particle = 'numuflux', + egrid = np.logspace(-1,5,500), + params = {}, + ): + + icangles = list(flux_obj.zenith_angles) + icangles_array = np.array(icangles, dtype=float) + mysort = icangles_array.argsort() + icangles = np.array(icangles)[mysort][::-1] + + flux_ref = np.zeros([len(egrid), len(icangles)]) + costheta_angles = np.zeros(len(icangles)) + + for index in range(len(icangles)): + costheta_angles[index] = np.cos(np.deg2rad(float(icangles[index]))) + flux_ref[:,index] = flux_obj.flux(egrid, icangles[index], particle, params) + + fcn = interpolate.RectBivariateSpline(egrid, + costheta_angles, + flux_ref) + return fcn + +@jit(forceobj=True) +def evaluate_flux_map(flux_map, true_energy, true_coszen): + + uconv = true_energy**-3 * 1e4 + return flux_map.ev(true_energy, true_coszen) * uconv + \ No newline at end of file diff --git a/pisa_examples/resources/settings/pipeline/IceCube_3y_neutrinos_daemon.cfg b/pisa_examples/resources/settings/pipeline/IceCube_3y_neutrinos_daemon.cfg new file mode 100644 index 000000000..30120fb7e --- /dev/null +++ b/pisa_examples/resources/settings/pipeline/IceCube_3y_neutrinos_daemon.cfg @@ -0,0 +1,270 @@ +#include settings/binning/IceCube_3y_oscillations.cfg as binning +#include settings/osc/nufitv20.cfg as osc +#include settings/osc/earth.cfg as earth + +# These first few lines import other config files that will be useful here... + + +#------------------------------------------------------------------------------ +# Settings directly affecting or handled by the pipeline +#------------------------------------------------------------------------------ + +[pipeline] + +# Define order of stages to be excecuted one after another, and specify the +# service to use for each of them as stage1:serviceA, stage2:serviceB, ... +order = data.csv_loader, flux.daemon_flux, osc.prob3, aeff.aeff, utils.hist, discr_sys.hypersurfaces + +# Select the params denoted by param.. +# This feature allows a whole subset of parameters to be selected, +# in this case normal hierarchy values for oscillation parameters +param_selections = nh + +name = neutrinos + +output_binning = dragon_datarelease +output_key = weights, errors + +#------------------------------------------------------------------------------ +# 'data' stage parameters +#------------------------------------------------------------------------------ + +[data.csv_loader] + +calc_mode = events +apply_mode = events + +output_names = nue_cc, numu_cc, nutau_cc, nue_nc, numu_nc, nutau_nc, nuebar_cc, numubar_cc, nutaubar_cc, nuebar_nc, numubar_nc, nutaubar_nc + +events_file = events/IceCube_3y_oscillations/neutrino_mc.csv.bz2 + +[flux.daemon_flux] + +calc_mode = events +apply_mode = events + +param.K_158G = 0.0 +/- 1.0 +param.K_158G.fixed = False +param.K_158G.range = nominal + [-3., +3.] * sigma + +param.K_2P = 0.0 +/- 1.0 +param.K_2P.fixed = False +param.K_2P.range = nominal + [-3., +3.] * sigma + +param.K_31G = 0.0 +/- 1.0 +param.K_31G.fixed = False +param.K_31G.range = nominal + [-3., +3.] * sigma + +param.antiK_158G = 0.0 +/- 1.0 +param.antiK_158G.fixed = False +param.antiK_158G.range = nominal + [-3., +3.] * sigma + +param.antiK_2P = 0.0 +/- 1.0 +param.antiK_2P.fixed = False +param.antiK_2P.range = nominal + [-3., +3.] * sigma + +param.antiK_31G = 0.0 +/- 1.0 +param.antiK_31G.fixed = False +param.antiK_31G.range = nominal + [-3., +3.] * sigma + +param.n_158G = 0.0 +/- 1.0 +param.n_158G.fixed = False +param.n_158G.range = nominal + [-3., +3.] * sigma + +param.n_2P = 0.0 +/- 1.0 +param.n_2P.fixed = False +param.n_2P.range = nominal + [-3., +3.] * sigma + +param.p_158G = 0.0 +/- 1.0 +param.p_158G.fixed = False +param.p_158G.range = nominal + [-3., +3.] * sigma + +param.p_2P = 0.0 +/- 1.0 +param.p_2P.fixed = False +param.p_2P.range = nominal + [-3., +3.] * sigma + +param.pi_158G = 0.0 +/- 1.0 +param.pi_158G.fixed = False +param.pi_158G.range = nominal + [-3., +3.] * sigma + +param.pi_20T = 0.0 +/- 1.0 +param.pi_20T.fixed = False +param.pi_20T.range = nominal + [-3., +3.] * sigma + +param.pi_2P = 0.0 +/- 1.0 +param.pi_2P.fixed = False +param.pi_2P.range = nominal + [-3., +3.] * sigma + +param.pi_31G = 0.0 +/- 1.0 +param.pi_31G.fixed = False +param.pi_31G.range = nominal + [-3., +3.] * sigma + +param.antipi_158G = 0.0 +/- 1.0 +param.antipi_158G.fixed = False +param.antipi_158G.range = nominal + [-3., +3.] * sigma + +param.antipi_20T = 0.0 +/- 1.0 +param.antipi_20T.fixed = False +param.antipi_20T.range = nominal + [-3., +3.] * sigma + +param.antipi_2P = 0.0 +/- 1.0 +param.antipi_2P.fixed = False +param.antipi_2P.range = nominal + [-3., +3.] * sigma + +param.antipi_31G = 0.0 +/- 1.0 +param.antipi_31G.fixed = False +param.antipi_31G.range = nominal + [-3., +3.] * sigma + +param.GSF_1 = 0.0 +/- 1.0 +param.GSF_1.fixed = False +param.GSF_1.range = nominal + [-3., +3.] * sigma + +param.GSF_2 = 0.0 +/- 1.0 +param.GSF_2.fixed = False +param.GSF_2.range = nominal + [-3., +3.] * sigma + +param.GSF_3 = 0.0 +/- 1.0 +param.GSF_3.fixed = False +param.GSF_3.range = nominal + [-3., +3.] * sigma + +param.GSF_4 = 0.0 +/- 1.0 +param.GSF_4.fixed = False +param.GSF_4.range = nominal + [-3., +3.] * sigma + +param.GSF_5 = 0.0 +/- 1.0 +param.GSF_5.fixed = False +param.GSF_5.range = nominal + [-3., +3.] * sigma + +param.GSF_6 = 0.0 +/- 1.0 +param.GSF_6.fixed = False +param.GSF_6.range = nominal + [-3., +3.] * sigma + + +[osc.prob3] + +calc_mode = true_allsky_fine +apply_mode = events + +# Preliminary Reference Earth Model +param.earth_model = osc/PREM_12layer.dat +# electron densities +param.YeI = ${earth:YeI} +param.YeM = ${earth:YeM} +param.YeO = ${earth:YeO} +# height +param.detector_depth = ${earth:detector_depth} +param.prop_height = ${earth:prop_height} +# solar angle +param.theta12 = ${osc:theta12} +param.theta12.fixed = True +# reactor angle +param.nh.theta13 = ${osc:theta13_nh} +param.nh.theta13.fixed = False +param.nh.theta13.range = ${osc:theta13_nh.range} +param.ih.theta13 = ${osc:theta13_ih} +param.ih.theta13.fixed = False +param.ih.theta13.range = ${osc:theta13_ih.range} +# atmospheric angle +param.nh.theta23 = ${osc:theta23_nh} +param.nh.theta23.fixed = False +param.nh.theta23.range = ${osc:theta23_nh.range} +param.nh.theta23.prior = uniform +param.ih.theta23 = ${osc:theta23_ih} +param.ih.theta23.fixed = False +param.ih.theta23.range = ${osc:theta23_ih.range} +param.ih.theta23.prior = uniform +# dirac phase +param.nh.deltacp = 0.0 * units.degree +param.nh.deltacp.fixed = True +param.nh.deltacp.range = ${osc:deltacp_nh.range} +param.nh.deltacp.prior = uniform +param.ih.deltacp = 0.0 * units.degree +param.ih.deltacp.fixed = True +# solar mass splitting +param.deltam21 = ${osc:deltam21} +param.deltam21.fixed = True +# atmospheric mass splitting +param.nh.deltam31 = ${osc:deltam31_nh} +param.nh.deltam31.fixed = False +param.nh.deltam31.prior = uniform +param.nh.deltam31.range = [0.001, +0.007] * units.eV**2 +param.ih.deltam31 = ${osc:deltam31_ih} +param.ih.deltam31.fixed = False +param.ih.deltam31.prior = uniform +param.ih.deltam31.range = [-0.007, -0.001] * units.eV**2 + + +[aeff.aeff] + +calc_mode = events +apply_mode = events + +param.livetime = 2.5 * units.common_year + +# overall norm +param.aeff_scale = 1.0 +param.aeff_scale.fixed = False +param.aeff_scale.prior = uniform +param.aeff_scale.range = [0.,3.] * units.dimensionless + +# CC tau neutrino norm +param.nutau_cc_norm = 1.0 +param.nutau_cc_norm.fixed = True +param.nutau_cc_norm.range = [0.2, 2.0] * units.dimensionless +param.nutau_cc_norm.prior = uniform + +# CC+NC nutau norm +param.nutau_norm = 1.0 +param.nutau_norm.fixed = False +param.nutau_norm.range = [-1.0, 8.5] * units.dimensionless +param.nutau_norm.prior = uniform + +# NC norm +param.nu_nc_norm = 1.0 +/- 0.2 +param.nu_nc_norm.fixed = False +param.nu_nc_norm.range = nominal + [-.5,+.5] + +[utils.hist] + +calc_mode = events +apply_mode = dragon_datarelease + +error_method = sumw2 + + +[discr_sys.hypersurfaces] + +calc_mode = ${utils.hist:apply_mode} +apply_mode = ${utils.hist:apply_mode} + +error_method = sumw2 + +links = {'nue_cc+nuebar_cc':['nue_cc', 'nuebar_cc'], 'numu_cc+numubar_cc':['numu_cc', 'numubar_cc'], 'nutau_cc+nutaubar_cc':['nutau_cc', 'nutaubar_cc'], 'nu_nc+nubar_nc':['nue_nc', 'numu_nc', 'nutau_nc', 'nuebar_nc', 'numubar_nc', 'nutaubar_nc']} + +fit_results_file = events/IceCube_3y_oscillations/hyperplanes_*.csv.bz2 + +# DOM efficiency +param.opt_eff_overall = 1.0 +/- 0.1 +param.opt_eff_overall.fixed = False +param.opt_eff_overall.range = [0.8, 1.2] * units.dimensionless + +# hole ice scattering +param.opt_eff_lateral = 25 +/- 10 +param.opt_eff_lateral.fixed = False +param.opt_eff_lateral.range = [5, 50] * units.dimensionless + +# hole ice forward +param.opt_eff_headon = 0.0 +param.opt_eff_headon.fixed = False +param.opt_eff_headon.range = [-5.0, 2.0] * units.dimensionless +param.opt_eff_headon.prior = uniform + +# bulk_scatter +param.ice_scattering = 0.0 +/- 10.0 +param.ice_scattering.fixed = False +param.ice_scattering.range = [-15, 15] * units.dimensionless + +# bulk_abs +param.ice_absorption = 0.0 +/- 10.0 +param.ice_absorption.fixed = False +param.ice_absorption.range = [-15, 15] * units.dimensionless diff --git a/pisa_examples/test_daemonflux_stage.ipynb b/pisa_examples/test_daemonflux_stage.ipynb new file mode 100644 index 000000000..ead12b27a --- /dev/null +++ b/pisa_examples/test_daemonflux_stage.ipynb @@ -0,0 +1,1110 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "2de8885d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<< PISA is running in double precision (FP64) mode; numba is running on CPU (single core) >>\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "import sys, os\n", + "from copy import deepcopy\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib\n", + "\n", + "from pisa.core.distribution_maker import DistributionMaker\n", + "from pisa.core.map import Map\n", + "\n", + "from uncertainties import unumpy" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "e4b95472", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ WARNING] /tmp/ipykernel_19940/3777615979.py:1: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython display\n", + " from IPython.core.display import display, HTML\n", + "\n" + ] + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.core.display import display, HTML\n", + "display(HTML(\"\"))" + ] + }, + { + "cell_type": "markdown", + "id": "9b3560b9", + "metadata": {}, + "source": [ + "# Create two pipelines - one with Honda flux, one with deamonflux" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "acc19403", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
pipeline number name detector name output_binning output_key profile
0neutrinos "dragon_datarelease":\n", + "8 (reco_energy) x 8 (reco_coszen) x 2 (pid) ('weights', 'errors') True
1 muons "dragon_datarelease":\n", + "8 (reco_energy) x 8 (reco_coszen) x 2 (pid) ('weights', 'errors') True
" + ], + "text/plain": [ + " pipeline number | name | detector name | output_binning | output_key | profile\n", + "-------------------+-----------+-----------------+---------------------------------------------+-----------------------+-----------\n", + " 0 | neutrinos | | \"dragon_datarelease\": | ('weights', 'errors') | True\n", + " | | | 8 (reco_energy) x 8 (reco_coszen) x 2 (pid) | |\n", + " 1 | muons | | \"dragon_datarelease\": | ('weights', 'errors') | True\n", + " | | | 8 (reco_energy) x 8 (reco_coszen) x 2 (pid) | |" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_daemon = DistributionMaker([\"settings/pipeline/IceCube_3y_neutrinos_daemon.cfg\", \"settings/pipeline/IceCube_3y_muons.cfg\"])\n", + "model_daemon.profile = True\n", + "model_daemon" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "7a38c44b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
pipeline number name detector name output_binning output_key profile
0neutrinos "dragon_datarelease":\n", + "8 (reco_energy) x 8 (reco_coszen) x 2 (pid) ('weights', 'errors') True
1 muons "dragon_datarelease":\n", + "8 (reco_energy) x 8 (reco_coszen) x 2 (pid) ('weights', 'errors') True
" + ], + "text/plain": [ + " pipeline number | name | detector name | output_binning | output_key | profile\n", + "-------------------+-----------+-----------------+---------------------------------------------+-----------------------+-----------\n", + " 0 | neutrinos | | \"dragon_datarelease\": | ('weights', 'errors') | True\n", + " | | | 8 (reco_energy) x 8 (reco_coszen) x 2 (pid) | |\n", + " 1 | muons | | \"dragon_datarelease\": | ('weights', 'errors') | True\n", + " | | | 8 (reco_energy) x 8 (reco_coszen) x 2 (pid) | |" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_honda = DistributionMaker([\"settings/pipeline/IceCube_3y_neutrinos.cfg\", \"settings/pipeline/IceCube_3y_muons.cfg\"])\n", + "model_honda.profile = True\n", + "model_honda" + ] + }, + { + "cell_type": "markdown", + "id": "09041bc1", + "metadata": {}, + "source": [ + "See that we have different parameters for different fluxes..." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "040511d3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name value nominal_value range prior units is_fixed
K_158G 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
K_2P 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
K_31G 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
antiK_158G 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
antiK_2P 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
antiK_31G 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
n_158G 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
n_2P 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
p_158G 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
p_2P 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
pi_158G 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
pi_20T 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
pi_2P 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
pi_31G 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
antipi_158G 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
antipi_20T 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
antipi_2P 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
antipi_31G 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
GSF_1 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
GSF_2 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
GSF_3 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
GSF_4 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
GSF_5 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
GSF_6 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
theta13 8.5 8.5 [7.85, 9.1] +/- 0.205 degree False
theta23 42.3 42.3 [31, 59] uniform degree False
deltam310.002457 0.002457 [0.001, 0.007] uniform electron_volt ** 2 False
aeff_scale 1 1 [0.0, 3.0] uniform dimensionless False
nutau_norm 1 1 [-1.0, 8.5] uniform dimensionless False
nu_nc_norm 1 1 [0.5, 1.5] +/- 0.2 dimensionless False
opt_eff_overall 1 1 [0.8, 1.2] +/- 0.1 dimensionless False
opt_eff_lateral 25 25 [5, 50] +/- 10.0 dimensionless False
opt_eff_headon 0 0 [-5.0, 2.0] uniform dimensionless False
ice_scattering 0 0 [-15, 15] +/- 10.0 dimensionless False
ice_absorption 0 0 [-15, 15] +/- 10.0 dimensionless False
atm_muon_scale 1 1 [0.0, 5.0] uniform dimensionless False
" + ], + "text/plain": [ + " name | value | nominal_value | range | prior | units | is_fixed\n", + "-----------------+----------+-----------------+----------------+-----------+--------------------+------------\n", + " K_158G | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " K_2P | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " K_31G | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " antiK_158G | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " antiK_2P | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " antiK_31G | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " n_158G | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " n_2P | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " p_158G | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " p_2P | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " pi_158G | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " pi_20T | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " pi_2P | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " pi_31G | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " antipi_158G | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " antipi_20T | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " antipi_2P | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " antipi_31G | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " GSF_1 | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " GSF_2 | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " GSF_3 | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " GSF_4 | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " GSF_5 | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " GSF_6 | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " theta13 | 8.5 | 8.5 | [7.85, 9.1] | +/- 0.205 | degree | False\n", + " theta23 | 42.3 | 42.3 | [31, 59] | uniform | degree | False\n", + " deltam31 | 0.002457 | 0.002457 | [0.001, 0.007] | uniform | electron_volt ** 2 | False\n", + " aeff_scale | 1 | 1 | [0.0, 3.0] | uniform | dimensionless | False\n", + " nutau_norm | 1 | 1 | [-1.0, 8.5] | uniform | dimensionless | False\n", + " nu_nc_norm | 1 | 1 | [0.5, 1.5] | +/- 0.2 | dimensionless | False\n", + " opt_eff_overall | 1 | 1 | [0.8, 1.2] | +/- 0.1 | dimensionless | False\n", + " opt_eff_lateral | 25 | 25 | [5, 50] | +/- 10.0 | dimensionless | False\n", + " opt_eff_headon | 0 | 0 | [-5.0, 2.0] | uniform | dimensionless | False\n", + " ice_scattering | 0 | 0 | [-15, 15] | +/- 10.0 | dimensionless | False\n", + " ice_absorption | 0 | 0 | [-15, 15] | +/- 10.0 | dimensionless | False\n", + " atm_muon_scale | 1 | 1 | [0.0, 5.0] | uniform | dimensionless | False" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_daemon.params.free" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "85e3f26e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name value nominal_value range prior units is_fixed
nue_numu_ratio 1 1 [0.5, 1.5] +/- 0.05 dimensionless False
Barr_uphor_ratio 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
Barr_nu_nubar_ratio 0 0 [-3.0, 3.0] +/- 1.0 dimensionless False
delta_index 0 0 [-0.5, 0.5] +/- 0.1 dimensionless False
theta13 8.5 8.5 [7.85, 9.1] +/- 0.205 degree False
theta23 42.3 42.3 [31, 59] uniform degree False
deltam310.002457 0.002457 [0.001, 0.007] uniform electron_volt ** 2 False
aeff_scale 1 1 [0.0, 3.0] uniform dimensionless False
nutau_norm 1 1 [-1.0, 8.5] uniform dimensionless False
nu_nc_norm 1 1 [0.5, 1.5] +/- 0.2 dimensionless False
opt_eff_overall 1 1 [0.8, 1.2] +/- 0.1 dimensionless False
opt_eff_lateral 25 25 [5, 50] +/- 10.0 dimensionless False
opt_eff_headon 0 0 [-5.0, 2.0] uniform dimensionless False
ice_scattering 0 0 [-15, 15] +/- 10.0 dimensionless False
ice_absorption 0 0 [-15, 15] +/- 10.0 dimensionless False
atm_muon_scale 1 1 [0.0, 5.0] uniform dimensionless False
" + ], + "text/plain": [ + " name | value | nominal_value | range | prior | units | is_fixed\n", + "---------------------+----------+-----------------+----------------+-----------+--------------------+------------\n", + " nue_numu_ratio | 1 | 1 | [0.5, 1.5] | +/- 0.05 | dimensionless | False\n", + " Barr_uphor_ratio | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " Barr_nu_nubar_ratio | 0 | 0 | [-3.0, 3.0] | +/- 1.0 | dimensionless | False\n", + " delta_index | 0 | 0 | [-0.5, 0.5] | +/- 0.1 | dimensionless | False\n", + " theta13 | 8.5 | 8.5 | [7.85, 9.1] | +/- 0.205 | degree | False\n", + " theta23 | 42.3 | 42.3 | [31, 59] | uniform | degree | False\n", + " deltam31 | 0.002457 | 0.002457 | [0.001, 0.007] | uniform | electron_volt ** 2 | False\n", + " aeff_scale | 1 | 1 | [0.0, 3.0] | uniform | dimensionless | False\n", + " nutau_norm | 1 | 1 | [-1.0, 8.5] | uniform | dimensionless | False\n", + " nu_nc_norm | 1 | 1 | [0.5, 1.5] | +/- 0.2 | dimensionless | False\n", + " opt_eff_overall | 1 | 1 | [0.8, 1.2] | +/- 0.1 | dimensionless | False\n", + " opt_eff_lateral | 25 | 25 | [5, 50] | +/- 10.0 | dimensionless | False\n", + " opt_eff_headon | 0 | 0 | [-5.0, 2.0] | uniform | dimensionless | False\n", + " ice_scattering | 0 | 0 | [-15, 15] | +/- 10.0 | dimensionless | False\n", + " ice_absorption | 0 | 0 | [-15, 15] | +/- 10.0 | dimensionless | False\n", + " atm_muon_scale | 1 | 1 | [0.0, 5.0] | uniform | dimensionless | False" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_honda.params.free" + ] + }, + { + "cell_type": "markdown", + "id": "882b5bc5", + "metadata": {}, + "source": [ + "also check pipelines..." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "d7ac5492", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
stage number name calc_mode apply_mode has setup has compute has apply # fixed params # free params
0 csv_loader events events True False True 0 0
1 daemon_flux events events True True False 0 24
2 prob3 "true_allsky_fine":\n", + "200 (true_energy) x 200 (true_coszen) events True True True 9 3
3 aeff events events False False True 2 3
4 hist events "dragon_datarelease":\n", + "8 (reco_energy) x 8 (reco_coszen) x 2 (pid) True False True 0 0
5hypersurfaces "dragon_datarelease":\n", + "8 (reco_energy) x 8 (reco_coszen) x 2 (pid) "dragon_datarelease":\n", + "8 (reco_energy) x 8 (reco_coszen) x 2 (pid) True True True 0 5
" + ], + "text/plain": [ + " stage number | name | calc_mode | apply_mode | has setup | has compute | has apply | # fixed params | # free params\n", + "----------------+---------------+---------------------------------------------+---------------------------------------------+-------------+---------------+-------------+------------------+-----------------\n", + " 0 | csv_loader | events | events | True | False | True | 0 | 0\n", + " 1 | daemon_flux | events | events | True | True | False | 0 | 24\n", + " 2 | prob3 | \"true_allsky_fine\": | events | True | True | True | 9 | 3\n", + " | | 200 (true_energy) x 200 (true_coszen) | | | | | |\n", + " 3 | aeff | events | events | False | False | True | 2 | 3\n", + " 4 | hist | events | \"dragon_datarelease\": | True | False | True | 0 | 0\n", + " | | | 8 (reco_energy) x 8 (reco_coszen) x 2 (pid) | | | | |\n", + " 5 | hypersurfaces | \"dragon_datarelease\": | \"dragon_datarelease\": | True | True | True | 0 | 5\n", + " | | 8 (reco_energy) x 8 (reco_coszen) x 2 (pid) | 8 (reco_energy) x 8 (reco_coszen) x 2 (pid) | | | | |" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_daemon.pipelines[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "0d1bd29f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
stage number name calc_mode apply_mode has setup has compute has apply # fixed params # free params
0 csv_loader events events True False True 0 0
1 honda_ip "true_allsky_fine":\n", + "200 (true_energy) x 200 (true_coszen) events True True False 1 0
2 barr_simple "true_allsky_fine":\n", + "200 (true_energy) x 200 (true_coszen) events True True False 1 4
3 prob3 "true_allsky_fine":\n", + "200 (true_energy) x 200 (true_coszen) events True True True 9 3
4 aeff events events False False True 2 3
5 hist events "dragon_datarelease":\n", + "8 (reco_energy) x 8 (reco_coszen) x 2 (pid) True False True 0 0
6hypersurfaces "dragon_datarelease":\n", + "8 (reco_energy) x 8 (reco_coszen) x 2 (pid) "dragon_datarelease":\n", + "8 (reco_energy) x 8 (reco_coszen) x 2 (pid) True True True 0 5
" + ], + "text/plain": [ + " stage number | name | calc_mode | apply_mode | has setup | has compute | has apply | # fixed params | # free params\n", + "----------------+---------------+---------------------------------------------+---------------------------------------------+-------------+---------------+-------------+------------------+-----------------\n", + " 0 | csv_loader | events | events | True | False | True | 0 | 0\n", + " 1 | honda_ip | \"true_allsky_fine\": | events | True | True | False | 1 | 0\n", + " | | 200 (true_energy) x 200 (true_coszen) | | | | | |\n", + " 2 | barr_simple | \"true_allsky_fine\": | events | True | True | False | 1 | 4\n", + " | | 200 (true_energy) x 200 (true_coszen) | | | | | |\n", + " 3 | prob3 | \"true_allsky_fine\": | events | True | True | True | 9 | 3\n", + " | | 200 (true_energy) x 200 (true_coszen) | | | | | |\n", + " 4 | aeff | events | events | False | False | True | 2 | 3\n", + " 5 | hist | events | \"dragon_datarelease\": | True | False | True | 0 | 0\n", + " | | | 8 (reco_energy) x 8 (reco_coszen) x 2 (pid) | | | | |\n", + " 6 | hypersurfaces | \"dragon_datarelease\": | \"dragon_datarelease\": | True | True | True | 0 | 5\n", + " | | 8 (reco_energy) x 8 (reco_coszen) x 2 (pid) | 8 (reco_energy) x 8 (reco_coszen) x 2 (pid) | | | | |" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_honda.pipelines[0]" + ] + }, + { + "cell_type": "markdown", + "id": "5cddad4c", + "metadata": {}, + "source": [ + "# Get neutrino maps and compare" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "24244287", + "metadata": {}, + "outputs": [], + "source": [ + "maps_daemon = model_daemon.pipelines[0].get_outputs()\n", + "maps_honda = model_honda.pipelines[0].get_outputs()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "b9a0a499", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['nue_cc',\n", + " 'numu_cc',\n", + " 'nutau_cc',\n", + " 'nue_nc',\n", + " 'numu_nc',\n", + " 'nutau_nc',\n", + " 'nuebar_cc',\n", + " 'numubar_cc',\n", + " 'nutaubar_cc',\n", + " 'nuebar_nc',\n", + " 'numubar_nc',\n", + " 'nutaubar_nc']" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "maps_daemon.names" + ] + }, + { + "cell_type": "markdown", + "id": "1cebc63c", + "metadata": {}, + "source": [ + "first check maps by neutrino types" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "6f82f6de", + "metadata": {}, + "outputs": [], + "source": [ + "def plt_maps(maps, title=None):\n", + " fig, axes = plt.subplots(3,4, figsize=(24,10))\n", + " plt.suptitle(title)\n", + " plt.subplots_adjust(hspace=0.5)\n", + " axes = axes.flatten()\n", + "\n", + " for m, ax in zip(maps, axes):\n", + " m.plot(ax=ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "7cdf891a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt_maps(maps_honda, 'using Honda flux')" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "96e9e80f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt_maps(maps_honda, 'using daemon flux')" + ] + }, + { + "cell_type": "markdown", + "id": "6d0ceecb", + "metadata": {}, + "source": [ + "now look at combined maps" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "9882f371", + "metadata": {}, + "outputs": [], + "source": [ + "map_tot_daemon = model_daemon.get_outputs(return_sum=True)\n", + "map_tot_honda = model_honda.get_outputs(return_sum=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "dc7ebb45", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.02, 'Honda flux')" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "map_tot_honda.plot()\n", + "plt.suptitle('Honda flux', fontsize=20, y=1.02)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "c55c1b50", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.02, 'daemon flux')" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "map_tot_daemon.plot()\n", + "plt.suptitle('daemon flux', fontsize=20, y=1.02)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "f9753f7d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# ratio daemon/honda\n", + "(map_tot_daemon/map_tot_honda).plot(cmap='coolwarm', clabel='daemonflux / Honda')" + ] + }, + { + "cell_type": "markdown", + "id": "72a536ab", + "metadata": {}, + "source": [ + "# check we get a change when pulling each of parameters by 1 sigma" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "1349e6d8", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_modif_to_map(model):\n", + "\n", + " model.reset_free()\n", + " nominal = model.get_outputs(return_sum=True)\n", + " for i, p in enumerate(model.params.free):\n", + " if p.prior.kind == 'uniform': continue\n", + " # reset all free parameters to put them back to nominal values\n", + " model.reset_free()\n", + "\n", + " # shift one parameter\n", + " p.value = p.nominal_value + p.prior.stddev\n", + " sys = model.get_outputs(return_sum=True)\n", + "\n", + " ((nominal[0] - sys[0])/nominal[0]).plot(cmap='coolwarm', clabel=\"rel. difference\")\n", + " plt.suptitle(p.name+r'$+1\\sigma$', fontsize=20, y=1.02)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "2cfeeb04", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbYAAAEyCAYAAACWKPW+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAA7nUlEQVR4nO3deZhcVZ3/8fenO3tAAiQkEIQkAzqyL8OqMxoWAZUgLoiKog4TnR8wozKOgOgwCuM2LqMwIA4IoqjoSAgKGlbZDCQsIkGETEDEQAiBBAiE0N2f3x/nFlQqVV23+nbfrnR/X89zn6q695xzT1Uq9e1z7rnnyDYhhBDCUNEx2BUIIYQQ+lMEthBCCENKBLYQQghDSgS2EEIIQ0oEthBCCENKBLYQQghDSgS2EEIIQ0oEthBCCENKBLbQtiRZUt0ZBCRtJ+n/sjT/0Yey3yXp25JukvRMVs4Pekn/cKU+dbbHe8n3VknzJD0q6QVJSyT9VNJ+Ter3Gklfl3SnpKckvZQ93ibpPyXt2ep7zqPVzyWEdjRisCsQQquyH/UrgYnAibbP6kMxpwG7As8BjwJ/nSPPKuCbdfY/16CeXwb+FVgBzAGeBLYDjgDeKemDtn9Qk0fA57KtA7gT+AnwFLAxsAtwInCSpBNsn52j3q3oy+cSQluJwBY2KJIOAi4DRgFH2/5pH4v6BOmHezHwRuD6HHlW2j49Zz2nAP8CLAN2sf1E1bGZwHXA54Ha1tDngNOBPwPvtX1LnbK3AD4ObJKjHh8CvgfMtH1Djqr35XMJoa1EYAsbDElHAxcBa4BDbff5R7c6b2ok9bttSS2u26qDWuXckp4FJlXvlzSD1GJaCxxme1G9grPyTpXU7/9/+/q5SNoI+CRwJKlVulGDpJNrP48Q+lsEtrBBkPTPwDdILaDDbN89CNUYLekYYBtgNXAPcKPt7jppHyQFqL0lTbT9ZOWApL8jdSvOqcnzYdL/yUsaBbVqtrv69C76WdaC/A2p2/Ie4FxgNPBuYArwEvAI8GQEtVCGCGyh7Un6InAyKVgcYvuhQarKFODimn0PSfqw7d9U77T9lKRPA18H7pM0h3St7a+AWcDVwEdrynp99nhdf1d8gF1CCmpfAU52tmSIpK+S/s06gX2rg3sIAykCW9gQnEz6q//QQQxq3wNuAhYBzwIzgBOA2cBVkvaz/bvqDLa/Kelh4ALgH6oOLQYurNN6mZI9/qX25JKmAR+q2b3S9jf78F76jaSDgQOBW4BTKkENwPafJd0EHATsBlwzKJUMw04M9w8bgl8DI4FLJE0YjArY/nfb19leZvt52/fa/hipRTaWNOBjHZL+FfgZcCGppTYe2BNYAvxQ0ldqs1ROV6cK04B/q9k+XnO+9W5JIAVkgOvr3KZwYUsfQn3HZI/fsN1T5/iq7DF+a0JposUWNgRHAJeSuvCuk/TmNurWOhc4Cfi76p2S3gR8GbjM9ierDt0p6UjgAdKQ/XNtL8mOPUbq0ptae5JsRKOyskeQWrC1vglMqNm3G+nzuwh4uObY3Q3fVX5/C/QAv2pwfOvscXE/nCuEXCKwhbZn+0VJ7wR+CBwF3CDpINsNb4wuUaU7cXzN/rdlj+uN3LT9vKTbSSMIdye14CB1580kde1d0GpF6nVLZsP9jyB1fd7Qapm9kdRBGv35hO3VdY5PBvYCHqoK3iEMuOgeCBuEbATg+0gtjx2B30jauvdcpajMIFL7wz06e5xEfZX9a6v2XQh0Ae+S9Lp+qd3AqnSZbpwFuVr/SvqN+U55VQohAlvYgGTD6j9M+qF8DXBjNqhiQEnaUdJmdfZvC1RmPam90fqm7HG2pHW6FiUdRhoBuQa4tbLf9v8BZ5BuPr9K0v4NqjSh1fcwELKBIr8jtVbfW31M0rtI1wDvB/6r9MqFYS26IsMGJfsx/ZikF0g/nDdJOsD2g62UI+ntwNuzl5XRiPtVDah40va/ZM/fDZws6XrgIdKoyL8C3gqMIU3v9Z81p/gZaRTgQcAfJF0GPA68jtRNKdLQ+BU1+T6fHfsscIukO4DbSVNqTSANIjkoS3tjK+85jxY/l0p9fw58T9KhpBlT9srq+CDwFttr+rueIfTKdmyxteVG6upyL8fPzNI8BuzYYtmnV8pvsD1clfaNwI9IrY+VpIEby0n3on0QUINzjCQF3/nAM6RuxieAXwBvblK/15JuSL+76pxPAQuy/XvkfJ8fyt7Pm/r7c6nKcwSp5bkaeD6r86nARoP9HYpteG6y606eHkIIIWyQ4hpbCCGEISUCWwghhCElBo+EDV42G8nHcya/0PbDA1aZEMLgG+yLfMNlI80VeHe29VQ9/3ovebYG3pOj7IOAi3Ok687OeS/wU2Bctv+5OmkWkYZyfxLoaFDem+qdF9gf+PcWPptDgT+SZqc4uQ+f7TR6H/BQvb1psL8L8R3p03fkAtLAm3sH+98ptvbfYvBIybJ7mm61vW2OtMcCO9j+dJN0J5FG5tUOOa9N95ztjbLnPwTusP31mv3Vz7cgzdx+i+1/q1Pex0k/aF9v9l56qVMnaXqpg0kLXC4gLbB5X1/L3NDFd6Ruvf6OtKr3923vVKSsMPTFNbby7QT8vnqHpL+WdKOkRZKukTRR0htIE+y+S9LdkqZLepek+ZJ+J+lmSZXZK3al9Xn/biItCNmQ0+zzs4ETVH/VyV2BqZJuk7Qkmx8RST/N6o+kyySdIekmSY9nK2BX2xtYbHuJ7bXAj0nDx4ez+I6sf54bSbc7hNBUBLby7Uzq5gFA0mjgf4F/tr0j6d6oT9i+mdR6OcL2bk7LtVxve1/bu2bpjsqK2ZXUJZRLNonuYdT8eNbjNMdfB7BFncO7Ac/a3gf4GPCFbH/1D/NOpOVV/hb4f8D7a8qYSrqpt+JR6kwCPMzEdySEAiKwla/2r/G3Azfbvit7fR+v/EC8lnTtqeJDkm6X9DvSD8AaSSOBV9lenuPcYyXdDSwkrWh8fs46r/eXePbDtznwH9muu4GJksYAI22vkjQO2IR0QzGkwUorm5VN/WVbhpP4joRQQIyKLN/OvPKfGGAH1v0R25m04vLmwCrbLwFI+iCp2+4A289JupF08X4H4A85z/2C7d1aqaykGaTBArWLYu5A6kKsTOK7B6lFsCPph5fs+R1OczwC7EJVSyTzKPDqqtdbA0tbqeMQFN+REAqIFluJshnQtydNzVTxF9IPQOUH4gPA94HprPsDvzNpQMFzSku47E/6sVvn2omka2sn3S1Q30mk9cbO8vqjjHYFpksaLWkj0sKX38zqeU+WZifWva6zS9WxigXA9tn1oVHA0cDc/qj/hii+I3W/IyG0JFps5doOeNT2i1X7LgbeIun3wAvAR2yvkPQiqdvmXtLF+YuAy5VmTb8SWGJ7taRdSZPkVn4Ut6PYRfZKV9RI0tyGF5MGKNTalbQ+2q2kFaS/YHu+pHcDt2Vpdq56DulHbJ2/xm13STqBtEp2J3CB7UUF6r+hi+9InRabpB+Rbh2YKOlR4N9s5+0mDcNMDPcfQiTtRPrR+2TTxGFYiu9IGA4isIUQQhhS4hpbCCGEISUCWwghhCElAlsIIYQhJQJbCCGEISUCWwghhCElAlsIIYQhJQJbCCGEIaVtApukCyQ9kc2iUO+4JH1L0mJJ90jao+rYoZL+mB07ubxahxBCaDdtE9iAC0krKTdyGGkOve1J0wedAy8vVHl2dnwH4L2SdhjQmoYQQmhbbRPYciwkeARp9Vzbng9MkLQlsVBlCCGEKhvSJMiNFqSst3+fRoVImk1q8TG2s3PPGRuP63OFutZ2N0/Ui5FjRxbKDzBizKhC+TvGjCmU353FvkIeUfwzKLp6291/eOBJ25PqHdt09ChPHVfsMxo5vlh+jegslJ8xff+OA3SNHFvs/IDrLruXnwr+I49c82yh/AB3Ln6k4fckjz07xvsZ5/vNWMyLhc413G1Iga3RgpQtLVRp+zzgPICdNn2Vf3pAwxjY1NN/WtnnvABTdppcKD/AZq+bVij/mNe+plB+b7J5ofxrNtu6UH4A9RT7A2PTPQ78U6NjU8eN4dI37VWo/K32fV2h/CM3m1Aov167S6H8y7fatVB+gG4V+6npyBkQGpnywA2F8gOMfetHG35P8nhWPXx7o+m50h727P3F/hoZ5jakwNZoQcpRDfaHEEL7EGhk21z9GdI2pE95LvDBbHTkvqSVgx8jFqoMIWwIBB0jlGsLxbRNi63eQoKkhQyxfS5p4cS3AIuB54EPZ8diocoQQvsTaGQErTK0TWCz/d4mxw0c3+DYlaTAF0IIbUkqtzUmaQZwM7Al0A2ca/uEXtLPAQ4n9eQ9COxp+9lmZUn6e+ArwKZZUX8B3mb7d9nxG4A31pzuTbZ/U/xd1rchdUWGEMKGK2ux5dn6yfVAFzAFOBE4XtKsulWTTiUFtSOB6cAWwLycZW1Fug/51cAk4AXgmppTPGRbVduABTWIwBZCCKWQoHN0R66t+Lk0CdgGOM72MtvnAA8BpzTIMhuYb3uu7YeBM0j3CDcty/YXbJ9k+y+2VwCnAxMLv4kCIrCFEEIZBB2dyrX1gwMBbFe3uhaRWmP1TCYNxKuYC3RI2q4PZb0beK5m33RJPZLWSLok31vouwhsIYRQCqGOfBswStLqqu3iFk+2OdBTs+9poNFsASOA5VWvK5NeTGmlLEnvJM38VD1n79eAPYDRwD8B75H07eZvoe/aZvBICCEMaQJ15m5LrLU9vmFR0kpgkwaHnwE+yvoNlwnAmgZ5uli3+3Bq9vg46d7gpmVJOgC4FDjP9tmV/bavqEp2nqQjgXeQrtUNiAhsIYRQAkF/dTNie0Kv50rXxZB0kO3KQI4dSdfG6lkGVE+xMwvosb1Y0qpmZUnanzTY5Me2P9as+k2OFxZdkSGEUAbRSldkIbaXA48A50uaJOljwAzgiw2yfBfYT9LhkqYBpwG35ylL0p7Ab4Bf2X7/em9bOlPStGxyjQ8BhwC/LPwmexEtthBCKIEkOkeV2paYCdwCPEG69+xs23OzuuwL/BbYz/Z822dK2huYQ2rwLAbenKcs4KukWPJWSS+3xmxXIvQxpBGUAtYCl9me3f9v9xUR2EIIoSTqKC+w2V5CuqG63rH51Ewgb7vhcl9NyjqgST22bVrZfhaBLYQQypB1RYaBF4EthBBK0W/3qIUmIrCFEEIJFC220kRgCyGEMgg6iq6GHnKJwBZCCKWIrsiyRGALIYQSRFdkeSKwhRBCScoc7j+cRWALIYQyRIutNBHYQgihFP0zXVZorq0Cm6RDgf8COoH/sf2lmuOfAipzkY0AXgdMsv2UpIeBZ0nTvXTZ/pvSKh5CCE0oRkWWpm0Cm6RO4GzgYOBRYIGkubbvq6Sx/VXSvGRIOhz4hO2nqoqZafvJEqsdQgi5xajIcrTTlcy9gcW2l9heC/yYtGBdI+8FflRKzUIIoSi1tNBoKKCdAttUXlm1FVKrbWq9hJLGAYcC/1u128A8SXdIajhztKTZkhZKWvjUiy/1Q7VDCCEfdXTk2kIxbdMVSc1M05lGC9IdDtxS0w35ettLJW0BXC3pfts3rlegfR5wHsD2HWP80FV/rk2S26Q9JvQ5L0DXi12F8gN0v7i2UH4/91yh/Br/qkL5xzy9tFB+gBcn1J10vF/0dPew5pkXC5Wx9plin3HnuLGF8o9c1vfvOMDkNasL5Qegq9gfkS/cdVeh/A/+9v5C+ftD3MdWnnYKbI8Cr656vTXQ6FfvaGq6IW0vzR6fkHQZqWtzvcAWQgiDQzF4pCTt1OZdAGwvabqkUaTgNbc2kaRNgDcCl1ftGy9p48pz0gJ595ZS6xBCyKPEFbSHu7ZpsdnuknQC8GvScP8LbC/KliHH9rlZ0iOBebar+0cmA5dJgvSeLrH9q/JqH0IIzSiun5WkbQIbgO0rgStr9p1b8/pC4MKafUuAXQe4eiGEUIyiNVaGtgpsIYQwVMXgkfJEuziEEEpS5nB/STMkLZVkSV2SzmqSfo6k7iz9A5VxC83KknS4pNWSerJtRTaBRuW4JM2vOn6bNLBN1whsIYRQBqVRkXm2fnI90AVMAU4Ejpc0q37VdCrpNqojgenAFsC8nGXdAxxCGhsxOkt7aVXei4E9SCPV9wJ2A35Q+N31IgJbCCGUpKxRkZImAdsAx9leZvsc4CHglAZZZgPzbc+1/TBwBikQNS3L9p9s32zbpJjSDYypKnsW8BPbC23fAVyS7RswEdhCCKEEam24/6ise6+yXdzi6Q4EsF3d6lpEao3VM5l0y1XFXKBD0nZ5y5JkYA1wFHBN1aGNSa24iuuAjfK+kb6IwSMhhFAKQf7rZ2ttjy9wss2Bnpp9T7NuS6raCGB51evKdDVT8pZlW1nr7ttA7VQvj9U+l6SsldfvosUWQgglkZRry1HOymwgR71tFbCC9X/fJ5BaVPV0AROrXlfm6X28lbJsLyctLfY5STtUHZpc+3ygghpEYAshhHKo/0ZF2p5gWw22TYBrASQdVJVtR9K1sXqWkQZ2VMwCemwv7kNZI9K7ZZfs9bPAAVXHDwSKTaDaRAS2EEIog4RGdObaispaTo8A50ualM3gNAP4YoMs3wX2y4buTwNOA27PU5akT0s6WtJISVOB20hdl1dlZV8BvEfSnpJ2B95HnekS+1NcYwshhJKUfIP2TOAW4AnSSMWzbc8FkLQv8FtgP9vzbZ8paW9gDqnBs5g0527Tski3BnyeNDG9gSeBo2yvyo4fA2zHK4NTFmT7BkwEthBCKIEQUnmdZNlUg3XXdLI9n5qlwmw3XNi5SVknASf1ktfAPjmq3G8isIUQQhkExJRapYjAFkIIJYnZ/csRgS2EEMogoc5YaLQMEdhCCKEkMbt/OSKwhRBCWaIrshQR2EIIoQR5ZxUJxUVgCyGEskSLrRRt9SlLOlTSHyUtlnRyneNvkrRK0t3Z9rm8eUMIYbCVtWzNcNc2LTZJncDZwMHAo8ACSXNt31eT9Cbbb+tj3hBCGBwSxKjIUrRTi21vYLHtJbbXAj8GGt4J3495QwihFFJHri0U006f4FReWQMIUstrap10+0n6naSrJO3YYl4kzZa0UNLCVXT3R71DCKG5yswjebZQSNt0RVIzb1mmdr2eO4FtbT8n6S2kCTu3z5k37bTPA84D2L5jTKH1gLpfql17rzWdI4t3S3S/uLZY/meeKZR/xKs2KZRf/bAkU0fPS4XLaKRrdTdPLFhRqIzNpm9eKH9Hwe6rzo0LLlY8ZZti+aHwoInRb3hjofzbbfvqQvkB+OUNBQtQzDxSknb6lB8Fqr99WwNLqxPYfsb2c9nzK4GRkibmyRtCCINOyreFQtopsC0Atpc0XdIo4Ghq1uyRNEXZjSDZEgsdpNVdm+YNIYRBJVLLNc8WCmmbrkjbXZJOAH4NdAIX2F6ULWqH7XOBdwH/KKkLeAE4OlsSoW7eQXkjIYRQV8wVWZa2CWzwcvfilTX7zq16fhZwVt68IYTQNgTEiMdStFVgCyGEoStGPJYlAlsIIZRAEPeolSQCWwghlCFW0C5N/PkQQgilEHR05tv642zSDElLJVlSl6S64xOq0s+R1J2lf0DSxnnKknS4pNWSerJthaTDq47fkOWr3ordmNhEBLYQQihLucP9rwe6gCnAicDxkmbVSyjpVOBw4EhgOrAFMC9nWfcAh5BGpI/O0l5ac4qHbKtq+00/vL+GIrCFEEIZpDQqMs9W+FSaBGwDHGd7me1zgIeAUxpkmQ3Mtz3X9sPAGaQ5eJuWZftPtm/Obr3qALqBMYXfRAER2EIIoSz554oclXXvVbaLWzzTgQC2q1tdi0itsXomkya6qJgLdEjaLm9ZkgysAY4Crqkpf3rWTblG0iUtvpeWxeCREEIoS/7W2Frb4wucaXOgdjLbp2nckhoBLK96XZlUfkresmwra919G7i/6tDXgE8A9wIfBs6RtML2ifneSuuixRZCCGXpp7kiJa2sMyCjsq0iTTVY+/s+gdSiqqcLmFj1urI6yuOtlGV7OfB+4HOSdsj2XWH7LtsvZZPQzwPe0fRNFhAtthBCKEM/LjRqe0Lvp9Kk7PEg25VuwR1J18bqWQbsVfV6FtBje3EWKFspawTp5oZdgHqLPRdf0qOJaLGFEEJZSho8krWcHgHOlzQpm3N3BvDFBlm+S1rr8nBJ04DTgNvzlCXp05KOljRS0lTgNlLX5VXZ8TMlTVPyIdIIyl8WfpO9iMAWQghlkMoe7j8TGAU8QZpj92zbc1NVtG/WbbkvgO0zgV+Q1rh8iNT9+OY8ZZFuDbgIWEu6NrcVcJTtVdnxY4AlpGD3HeAy27P7603WE12RIYRQlhLXWrO9BNiywbH51CzQbPuIPpZ1EnBSL3m3zVPf/hSBLYQQyhJzRZYiAlsIIZQiVscuS/z5EEIIJbDAnZ25tgCS9pf0qez5ppLqdoXWE4EthBBKUd6UWhs6Sd8Hrgb+I9u1J2m2k1yiKzKEEMoSQSuvd5NuGF8OYPsaSePyZm6rT1nSoZL+KGmxpJPrHH+/pHuy7VZJu1Yde1jS7yXdLWlhuTUPIYTmLOXaAt22V1deSBpNCzd2t02LTVIncDZwMPAosEDSXNvVd64/BLzR9tOSDgPOA/apOj7T9pOlVTqEEPKqzO4f8lgk6ddAp6RPA/8M3JE3czt9ynsDi20vsb0W+DGwzn0Vtm+1/XT2cj6wdcl1DCGEvuvszLeF/UnTfD1BWv/tGuBv82ZumxYbadLNP1e9fpR1W2O1/p5sypaMgXnZ0gnfySbbXI+k2aS1h5ikdnr7IYShLboZW7AZ8Pe2XwKQNDLbtyJP5nb6Za/3L163T1XSTFJge0PV7tfbXippC+BqSffbvnG9AlPAOw9ge42xX+r7fJw93cXm8lTH4H/JO0aPGtTze2Tx83euebYfalKfRohRm40sVIZ7in1Perq7C+WnaP6egvmBF1+1RaH8L4zZtFgFpuxQLD8AnymWXURXZH5LgO1IrTZIQe1B4FV5MrfTp/wo8Oqq11sDS2sTSdoF+B/gCNsvR2/bS7PHJ4DLyFZ/DSGEdmF15NoCI2xXghrZ89x/YbbTJ7gA2F7SdEmjgKNJq7i+TNI2wM+BD9h+oGr/eEkbV56TJu+8t7SahxBCUznXYovuSoCXJL2v8kLS+0lrxuXSNl2RtrsknQD8GugELrC9KFsiAdvnAp8jreb630r/+F22/4a0rPll2b4RwCW2fzUIbyOEEBqK1lhuJwIXSTonez2WtPp2Lm0T2ABsXwlcWbPv3KrnxwHH1cm3BNi1dn8IIbQNCTpixGMeti+SdClp7bYO4CrbL+TN31aBLYQQhipDjIpszQdIq3CPBA6RhO2P5skYgS2EEMoSXZG5SFpCmlLrEaAyLHfDm3kkhBCGOte9qynUMRUYY7tP98rEnw8hhFAKxXD//J4gdUP2SZ8+QUmzJF0q6ceSGi4nHkIIISNwR2eurV9OJ82QtFSSJXVJOqtJ+jmSurP0D1RuoWqlLEnXZWk+VbVPkuZL6sm226SmFxs3Au6S9KSkxytb3vfe167It9k+Kqv0OcDlfSwnhBCGBWctthJdT7r3awrwDtJtUvNsz61NKOlU4HDgSOAe4G5gHrBf3rKyGaH2B3pqir8Y2IM0aYaBW4EfAO/vpe7/1sobrdXXT3mspG2yG6bHF6lACCEMGyXdoC1pErANcJztZbbPIa2OckqDLLOB+bbn2n4YOINs9qYWyrqUtDBo7XWxWcBPbC+0fQdwSbavIdvfAhYCo7PnPwR+2vydJ30NbKeTbqA7Efh8H8sIIYRhpcRrbAcC2J5XtW8RML1B+smk2Z8q5gIdkrbLU5akr5EmzKgXDzYmtfgqriN1NTZUZwXt3SlhBe3Jtj+VVWBfYHEfywkhhGFCrYyKHCVpddXrn9v+QAsn25z1uwSfBsY0SD+CbLXqTGWllSnNypI0mdTIObCX+jxW+1ySehn1OCgraB9Z9bzXJmUIIYSkhRbbWtvjq7Z1gpqkldkgjXrbKtLyLrW/7xOANQ2q1kUKJBVTs8fHc5T1S+Am2zf18tYn1z5vMpS/0ArafQ1skyX9laQZwFZ9LCOEEIYPCasz19aM7Qm21WDbBLg2nVIHVWXbkXRtrJ5lwF5Vr2cBPbYX5yhrR2BmNqKymzTX75clVaZHfBY4oCrvgcBzTd5i7QraD1HCCtqnkS42fpSCo1dCCGE4qEyplWcrfC57OWnWjvMlTcomk58BfLFBlu8C+0k6XNI00m/87TnL2pk0V+9u2dYNfINXJi2+AniPpD0l7Q68j5qVW+rYl0FYQftIYDPb/yDps8AX+lhOCCEMGyUP958J3EIKDt3A2ZXh+dnYiN8C+9meb/tMSXsDc0gNnsWk5b+alpW16l6W3aL2eNV6aseQFg2tDE5ZkO2rS1InsNp2o+uBTfU1sP0Vr1xc3Li3hCGEEJIyp9TKVj3ZssGx+bBuZWw3nGyjt7LqpB1R89rAPnnyZum7JT0mad+sni3ra2Az6V62nYhrbCGEkEPpN2hvyDYBfivpaWBtZaftKXky9zWwfQ34f6RlBU7tYxkhhDCsxLI1uZ1eJHPLgS2b4+vttk8ucuIQQhhOLNGTY8RjSDOPSNofeL3tr0raHBiVN3/Lgc22Je0l6b3AqmzflU2yhRDCsBfL1uSTzTzyTlIw+ypp5pFLgc3y5O9rh+812Qknse5NfYVIOlTSHyUtlrReizCbJfpb2fF7JO2RN28IIQy2WLYmt3cDWwAvQZp5BMg980jTFlt2T8PxpJGQT5Fmfb7C9p9ar2uv5+kEzgYOBh4FFkiaa/u+qmSHAdtn2z7AOcA+OfOGEMKgihZbbt22V1dWtxmImUcuB+7nlcCxK3CjpLOzk/WXvYHFtpfYXgv8GKgdfnoE8H0n84EJkrbMmTeEEAaNY6HRVgz4zCOdts+3fS3wlO1/ILXeHgbO60OFG5nKK/fGQWp5Tc2ZJk9eACTNlrRQ0sJVdBeudAgh5NWjjlxbYH8GeOaRaySdYPsssqag7S7gq5IeaL2+DdVro9c2PRulyZM37bTPIwvIrxk11qO3yD3QZj2jxvf1bomkY0TxEVKjN92kWAGdxerQs8nmxc7fD6sFr3lVrltb+qRjhBg3uc8TIACwdvWLhfJvVHCIuEYXq7/WNpo3N7+ukWML5X9uxIRC+Xv6PJygf9nRFdkbSU/Z3gy4xfa+fS0nzy/zJ4FTJC0EtpI0G3ietLLqir6euI5HgVdXvd4aWJozzagceUMIYRAJt0mAbWPjJf0TsLuko6npVbR9SZ5CmgY22z3AmZK+ARxEmuRyU+Be4DMtVro3C4DtJU0H/gIcTZoss9pc4ARJPyYNHlll+zFJy3PkDSGEQWNi8EgO3wY+S2qsnFNzzKTVt5vK3Zdm+3lSYGk2K3Of2O6SdALwa9KyBxfYXpTNJI3tc4ErgbeQJuh8nmz26EZ5B6KeIYTQVxHYmlpse5Kka233tnBpr4pdJOpn2Y3eV9bsO7fquUm3HuTKG0II7SQCW1NfA84lXerqs9yBTdK7gV/ZflbSacAewBm27yxSgRBCGB5Ej+MaWxM9kh4ERku6u/ag7d3yFNLKp/zZLKi9ATgEuIj1+0BDCCHUUbnGlmcbxvYk9byZtNBp7ZZLK12RlZu+3gqcY/tySae3kD+EEIa1YR60mrL9APDPkm62/dO+ltNKi+0vkr4DHAVcmc06Eu3qEELIKVpsvZP0y+zpaZLurt3yltNKi+0o4FDgP22vzKay+lQL+UMIYRhT3KDdXGXarNuKFNLScH9J/wccIukQ4Cbb84qcPIQQhgsDPcO4NZaH7c9lj7OLlJO7K1HSPwM/JC0lsAXwA0knFjl5CCEMG4Yed+Ta+oOkGZKWSrKkLklnNUk/R1J3lv4BSRu3Wpak67I0n6rad0O2r3p7Y4P8j/e25X3vrXRF/j2wj+3VWQW+DPyWdKd4CCGEJkq+fnY90AVMAd4B/LekebbXm2RD0qnA4cCRwD2k5cnm8cr9ZE3LkjSTNHlxT526PGR7Ro46/0f2+GFgc+DC7PUHSbNK5dLKnwaCdabD76b+5MMhhBDWk66x5dkKn0maBGwDHGd7me1zSEu/nNIgy2xgvu25th8GziAtB9ZKWZeSAlPuddNq2f6W7W8B021vY/tz2TYN2DFvOa0Etu8Bt0k6PRvmPx+4oJVKhxDCcNXifWyjJK2u2i5u8XQHAtSMg1gETG+QfjJpvt6KuUCHpO3ylCXpa0CX7c83KH+6pB5JayTlme9xbHV3paS/BXIvEdHK4JGvS7oBeAOppfZh23flzR9CCMNdC62xtbbHFzjV5qzfJfg00GgNoxHA8qrXlfUtpzQrS9Jk0pppjeZ2/BrwCdLE+R8GzpG0wnZvYzQ+D1wr6bns9UbAab2kX0crg0cuApZkTcX/Ah6WFC22EELIqdvKtTUjaWWdARmVbRVpSbHa3/cJQKPF9bqAiVWvKws1P56jrF+SRsnfVK9g21fYvsv2S9l6mPNI1+kasn0maRWZf8i2TW1/qbc81VoZPLKL7ZVVJ35a0u4t5A8hhGGrP2++tj2ht+PZdTEkHWT7mmz3jqRrY/UsA/aqej0L6LG9OAuUvZW1I2lux8oYjA7gy5Jm2n5Lver3VveXE9nPAn2afaSVa2wdkjatvJC0GW22OkAIIbSzsgaP2F4OPAKcL2lStvzXDOCLDbJ8F9hP0uGSppG6/W7PWdbOwK6ktTp3Iw0s/AbZsmKSzpQ0TcmHSHMNV2YYGRCtBKavAbdK+hkp4h4FnDkgtQohhCGo5OH+M4FbgCdIwebsyvB8SfuSbtfaz/Z822dK2huYQ2rwLAbenKcs24urTyoJ4HHby7Jdx5BGUApYC1xW9AbsZloZPPJ9SQuBA0gVfIft+wasZiGEMJQYevo8EL4Pp7OXAFs2ODafmtu1bB/Rl7LqpB1R83rbPPn6U0tdiVkgi2AWQggtqgz3D30j6Xnb4/KkjWtkIYRQkp6eCGx9lTeoQZssOyNpM0lXS3owe9y0TppXS7pe0h8kLcrmrqwcO13SX6qWN6g3EieEEAaR6Mm5hWLaIrABJwPX2t4euDZ7XasLOMn264B9geMl7VB1/Bu2d8u2Kwe+yiGEkJ8pb1TkhqqXe/MsKfcVynYJbEcAF2XPLwLeXpvA9mO278yePwv8gVduIgwhhLZn59uGK9vqbctbTrsEtsm2H4MUwEjL4jSU3WexO+suRneCpHskXVCvKzOEEAZbrKCdn6R/lHR+9vw12XyRuZQ2eETSNaR5x2p9psVyNgL+F/i47Wey3ecAXyC19r9AuufuIw3yzybNZM0WnSNbOXUIIfRdycP9N2SSrgN2ADYjLZk2nnRT96vy5C8tsNk+qNExScskbWn7MUlbkm4CrJduJCmo/dD2z6vKXlaV5rvAL3qpx3nAeQCvHTPOnWP73mgdvXGj+UTzGTdpk0L5AUZO3KxQ/o4pxXpzn53YaLLwfJ4cs3Wh/AAvdBf7d+iNOjsYs8noQmVsNGVCofxjt5pcKD9Ti91GtGrKXxc7P/DHnmJl/OXx3APi6nrqmcFvBZkYFdmC/YBxwGoA23dlv/+5tEtX5Fzg2Oz5scDltQmUbmc/H/iD7a/XHKu+cfBI0izSIYTQVmJUZG7d9itXGytzX+bVLoHtS8DBkh4EDs5eI2krSZURjq8HPgAcUGdY/1ck/V7SPaSpXz5Rcv1DCKGpGDyS2/WS7gNGSvo+sIReeuJqtcUN2rZXUGctH9tLgbdkz2+mwYrdtj8woBUMIYSCzPAeyp9X1jv3BVIj5Z3A64AzbH85bxltEdhCCGHIi8Ejudi2pOuzhVZzB7Nq7dIVGUIIQ16PlWsLLJF0bPNk9UVgCyGEEpjUYsuzBV4DXCjpJUkvSFoj6YW8maMrMoQQShIDQ3KbWSRzBLYQQihJBLZ8bN9aJH8EthBCKIFNXD8rSQS2EEIoSbTYyhGBLYQQStLdM9g1GB5iVGQIIZSg7PXYJM2QtDRby6xL0llN0s+R1J2lf0DSxnnKkvSGOmunXVN1XJLmS+rJttuym7AHTAS2EEIoQ87ptPqxu/J60gLNU4ATSYszz6qXUNKpwOGkuXank5YOm9diWWOq1k6rnvT+YmAPYG9gL2A34AfF3lrvIrCFEEJJyrqPLZs0eBvgONvLbJ8DPASc0iDLbGC+7bm2HwbOIAWivpRVaxbwE9sLbd8BXJLtGzAR2EIIoQSpKzJ3i22UpNVV28Utnu5AANvVra5FpNZYPZOBBVWv5wIdkrZroazns27KByW9pmr/xqQWX8V1wEZ530hfxOCREEIoSQuDR9ZmcyX21eZA7dmeBhotXjgCWF71+s/Z45QcZT0IfBC4FNgO+DVwKzCxKv1jtc8lqXppmv4ULbYQQihDP15jk7SyzoCNyrYKWMH6v+8TgDUNiuxi3UBUWYH48WZlZd2TF9t+0fYi4DBgc0nVqxhPrn0+UEGNOpUNIYQwANIK2vm2pmXZE6oGatRumwDXAkiqHsSxI+naWD3LSAM7KmYBPbYX96GsyjuoxJdngQOqjh8IPNf7OywmAlsIIZSkrFGRtpcDjwDnS5ok6WPADOCLDbJ8F9hP0uGSpgGnAbfnKUvSRyQdKqkzuyZ3FbDSdqU78wrgPZL2lLQ78D7SNbwBE9fYQgihJCXPPDITuAV4AugGzrY9F0DSvsBvgf1sz7d9pqS9gTmkBs9i4M15ygJ2B75Diic9wMPA31XlPYZ07a0yOGVBtm/ARGALIYQSuOQlaWwvAbZscGw+oJp9R/SxrBNJ97Y1ymtgnxxV7jcR2EIIoSQ9sdhaKdoisEnaDPgJMI3UjD3K9tN10j1MuhDZDXTZ/ptW8ocQwmDKMzAkFNcug0dOBq61vT1pBM7JvaSdaXu3SlDrQ/4QQihd3oEjsQJAce0S2I4ALsqeXwS8veT8IYQw4MqaUmu4a5fANtn2YwDZ4xYN0hmYJ+kOSbP7kB9JsyUtlLRwVXdXP1U/hBCaixZbOUq7xpYtYzClzqHPtFDM620vlbQFcLWk+23f2Eo9bJ8HnAfw1+PGe9RGff8Ixm02rs95AUa+qvh0aR0TG8bwXF7YcvtC+ZeN3rZQ/rv+Uu8r0ZoVKwful6BjhBizydhCZYzZfJNC+UdMntw8US9eGj+hUP6lI4r9GwM8+XSxz/DWBc8Wyn/PjfcWyt9fHM2xUpQW2GqWMViHpGWStrT9mKQtSfdK1Ctjafb4hKTLSLNP3wjkyh9CCIPFjoVGy9IuXZFzgWOz58cCl9cmkDS+svCdpPGkmwfvzZs/hBAGW0+Pc22hmHYJbF8CDpb0IHBw9hpJW0m6MkszGbhZ0u9IU7380vavessfQgjtosVla0IBbXEfm+0VZGv+1OxfCrwle74E2LWV/CGE0DYiaJWmLQJbCCEMfaYnIlspIrCFEEIJDPR0R2ArQwS2EEIog2NKrbJEYAshhJIM4KLRoUoEthBCKIGJ6bLKEoEthBDK4Jh5pCwR2EIIoSTRE1mOCGwhhFAC23THnFqliMAWQgglccS1UrTLlFohhDDk9di5tv4gaYakpZIsqUvSWU3Sz5HUnaV/oDI3b7OyJL0h21+9XVN1/IY6x9/YL2+ygQhsIYRQEtu5tn5yPdBFWi7sROB4SbPqJZR0KnA4cCQwnbSm5bwWyxpjW9lWu5rLQ1XHZPs3Rd9cbyKwhRBCCezyZveXNAnYBjjO9jLb5wAPAac0yDIbmG97ru2HgTNIy4L1paxBF4EthBBK0sLs/qMkra7aLm7xVAem87m61bWI1BqrZzKwoOr1XKBD0nYtlPV81k35oKTX1BybLqlH0hpJl7T4XloWgS2EEEpQGRWZZwPW2h5ftX2gxdNtDtQOVXkaGNMg/QhgedXrP2ePU3KU9SDwQWAcaQWWscCtVWm/BuwBjAb+CXiPpG/nfSN9EYEthBBK4h7n2pqRtLLOgIzKtgpYwfq/7xOANQ2K7AImVr2emj0+3qysrHvyYtsv2l4EHAZsLmlqdvwK23fZfsn2eaRrd+9o+iYLiOH+IYRQkv6aecT2hN6OZ9fFkHSQ7coIxR1J18bqWQbsVfV6FtBje3EWKFspq9K6a9RwGvDb1KPFFkIIZXCaKzLPVvhU9nLgEeB8SZMkfQyYAXyxQZbvAvtJOlzSNOA04PY8ZUn6iKRDJXVm1+SuAlba/nN2/ExJ05R8CDgE+GXxd9lYtNhCCKEEpvS5ImcCtwBPAN3A2bbnAkjaF/gtsJ/t+bbPlLQ3MIfU4FkMvDlPWcDuwHdI8aQHeBj4u6q8x5BGUApYC1xme3Z/v9lqbRHYJG0G/ASYRvpQjrL9dE2a12ZpKmYAn7P9TUmnA//AKxc/T7V95QBXO4QQ8it5Si3bS4AtGxybTwo01fuO6GNZJ5LubWuUd9s89e1P7dIVeTJwre3tgWuz1+uw/Ufbu9neDdgTeB64rCrJNyrHI6iFENpRyTdoD1vtEtiOAC7Knl8EvL1J+gOB/7P9p4GsVAgh9JdKV2R/jIoMvWuXwDbZ9mMA2eMWTdIfDfyoZt8Jku6RdIGkTRtllDRb0kJJC1d2dRWrdQgh5OUIbGUp7RpbNinmlDqHPtNiOaNIQ1Grp3M5B/gC6Y+iL5BuCPxIvfzZfRTnAbxu/Hh3jups5fTr1qVDzRP1YvQWE5snaqJ7s8mF8q8aX7fbPLe7ltb7J83v9jufKZQf4O7rf1e4jEY6RoxgoykTCpUxfsfXFcr/0qtrJ3FozRMTi51/xXMbN0/UrIxniv0N3aFi/9e6X3qpUP7+0X8THIfelRbY6kyK+TJJyyRtafsxSVuSRt40chhwp+1lVWW//FzSd4Ff9EedQwihP0VrrBzt0hU5Fzg2e34scHkvad9LTTdkFgwrjgTu7dfahRBCQTatTKkVCmiXwPYl4GBJDwIHZ6+RtJWkl0c4ShqXHf95Tf6vSPq9pHtI91t8opxqhxBCfnGNrRxtcR+b7RVkM0jX7F8KvKXq9fOkCTlr07U6QWgIIZQshvKXpS0CWwghDHU2uCe6GcsQgS2EEErSH4uIhuYisIUQQkmiK7IcEdhCCKEEtunpiq7IMkRgCyGEkvQ4AlsZIrCFEEIZHDdolyUCWwghlMDEPWplicAWQgglicEj5YjAFkIIZTB0d3UPdi2GhQhsIYRQAmMcg0dK0S5zRYYQwtBW8npskmZIWirJkrokndUk/RxJ3Vn6ByRtnLcsSZtLuldST5ZmZdUxSZqfHeuRdJtUcB2iJiKwhRBCSUqeBPl6oIu0DuaJwPGSZtVLKOlU4HDS6ijTSYs9z2uhrAXAxsAOwCjg+KpjFwN7AHsDewG7AT8o9tZ6F4EthBBKYXrck2srStIkYBvgONvLbJ8DPMS6CzRXmw3Mtz3X9sPAGaRA1LQsSYeSguH+tu+3/ZLtH1aVPQv4ie2Ftu8ALsn2DZgIbCGEUAKX2xV5YDqnq1tdi0gBqJ7JpFZXxVygQ9J2Oco6EngRuCLralwj6atVaTcmtfgqrgM2au3ttCYCWwghlMHQ09WdawNGSVpdtV3c4tk2B2qbfk8DYxqkHwEsr3r95+xxSo6ypgGjgWdIQexfgX+R9Naq9I/VPh/I62wR2EIIoRRpVGSeDVhre3zVts6ak5JWZoM06m2rgBWs//s+AVjToHJdwMSq11Ozx8dzlPVC9niI7dW2vwUsAz5SlX5y7XMP4E19EdhCCKEEJi1bk2drWpY9wbYabJsA1wJIOqgq246ka2P1LCMN7KiYBfTYXpyjrJubVPdZ4ICq1wcCzzXJU0gEthBCKEO20GierfCp7OXAI8D5kiZJ+hgwA/higyzfBfaTdLikacBpwO05yzobeAn4paTR2fHJwP9kx68A3iNpT0m7A+8jXcMbMG0R2CS9W9Ki7MLj3/SS7lBJf5S0WNLJVfs3k3S1pAezx03LqXkIIeSVb+BIPw73n0kaev8EcBZwtu25AJL2zbot9wWwfSbwC2AOqSW2AnhznrJsvwC8C9iH1D35X8CXbV+V5T0GuJs0OOUO4HfZvgHTLjOP3Au8A/hOowSSOkl/GRwMPAoskDTX9n3AycC1tr+UBbyTgU8PfLVDCCG/Mmcesb0E2LLBsfmAavYd0ZeysuNzSQNH6h0zKeiVpi0Cm+0/ADQZJLM3sDj7gJH0Y+AI4L7s8U1ZuouAG4jAFkJoI2mh0Zgrsgxqp9mmJd0A/IvthXWOvQs41PZx2esPAPvYPkHSStsTqtI+bbtud6Sk2aSbEQFeC/yxH9/CRODJfiyvP0XdGtvW9qR6ByQtB/7Uj+ca7Pfam3auGwx+/Rp+T/LIvkvjciZ/vsi5hrvSWmySriHdE1HrM7Yvz1NEnX0tR2Xb5wHntZovD0kLbTe8RjiYom59098/Lu38Xtu5btD+9WsmAlV5Sgtstg9qnqpXjwKvrnq9NbA0e75M0pa2H5O0JekCZwghhGGoLUZF5rQA2F7SdEmjgKN5ZcjoXODY7PmxQJ4WYAghhCGoLQKbpCMlPQrsR7oX4tfZ/q0kXQlguws4Afg18AfgUtuLsiK+BBws6UHSqMkvlf0eMgPSxdlPom7toZ3fazvXDdq/fqFNtNXgkRBCCKGotmixhRBCCP0lAlsIIYQhJQJbP5D0iWxKsHsl/UhSo6UhyqrPBZKekHRvzf4TsynJFkn6yiDVbYyk2yX9LqvHv2f7vyrpfkn3SLpM0oTBqN9AaqfvSXxHwlAWga0gSVOBfwL+xvZOQCdpxOZguhA4tHqHpJmkGVp2sb0j8J+DUC9ICxIeYHtX0hLxh2bz1V0N7GR7F+ABGq/0u0Fqw+/JhcR3JAxREdj6xwhgrKQRpJkFljZJP6Bs3wg8VbP7H4Ev2X4xSzMo9/o5qSxZMTLbbHteNvIVYD7pPsWhpm2+J/EdCUNZBLaCbP+F9JftI6SVYVfVLKHeLl4D/K2k2yT9RtJeTXMMEEmdku4m3Uh/te3bapJ8BLhqvYwbsA3kexLfkTAkRGArKFsi5whgOrAVMF7SgC7J0EcjgE2BfYFPAZeqyazTA8V2t+3dSH9x7y1pp8oxSZ8hreb7w8Go20DZQL4n8R0JQ0IEtuIOAh6yvdz2S8DPgf0HuU71PAr8POvmuR3oYd2l4EtneyVpJYZDASQdC7wNeP9ALhs/SDaE70l8R8KQEIGtuEeAfSWNy/66PZA0M0q7mUO2PLuk15AWDSx9pnSlFXgnZM/Hkn7w75d0KGmpoVm2ny+7XiXYEL4nc4jvSBgC2mI9tg2Z7dsk/Qy4k9Q9cheDPPWPpB+R1qebmE1V9m/ABcAF2fDutcCxg/QX75bARUoLx3aQpkb7haTFwGjg6qz3a77tjw1C/QZEu31P4jsShrKYUiuEEMKQEl2RIYQQhpQIbCGEEIaUCGwhhBCGlAhsIYQQhpQIbCGEEIaUCGwhhBCGlAhsIYQQhpQIbG1M0kclPSbp7qpt534sf2w22W1n9nqypEskLZF0h6TfSjqySRk3SDqkZt/HJf23pFGSbsxmsw8DIL4jIawvAlt72wU4zfZuVdvv+7H8j5DmBuzOpnmaA9xoe4btPUnrhTVbGuRHrL+u2NHAj2yvBa4F3tOPdQ7riu9ICDUisLW3nYG7B7D89wOXZ88PANbaPrdy0PafbH+78lrSMdnKxndL+k72V/zPgLdJGp2lmUaavf7mLNuc7DxhYMR3JIQaEdja247A96q6mGb3V8GSRgEzbD9cda47e0n/OtJf1a/PlhPpJs2wvgK4nVdWYz4a+EnVHIP3AoO2rtcwEN+REGpEv3abkvRq4AnbuzQ43mG7p8ApJgIrezn/2cAbSH+h70WajX5PYEE2Ae1Y0iKQ8EpX0+XZ40cq5WRdWGslbWz72QL1DTXiOxJCfRHY2tcuwP21OyV9iLSMx0JJlwEnAQL+D7gMOIP0Y3IZ8DhwOrAGuML25VVFvQCMqXq9CHhn5YXt4yVNBBZWTg1cZPuUOnWdA3xd0h7AWNu1f9WPzuoQ+ld8R0KoI7oi29fO1PnRylxl+5vA/yP9+KzI0h8PfN72SbZvBj4GfNb2ccA6qzXbfhrolFT54boOGCPpH6uSjat6fi3wLklbAEjaTNK2WVnPkRaDvID0l/nLJG0OVBbXDP0rviMh1BGBrX3tDHyg6trJXZI2yo6tyh47gB/aPt3235P+Yq7uehJQuY5Rb32ieaSuJLLrHW8H3ijpIUm3AxeRFnbE9n3AacA8SfcAV5PWzar4EbAr8OOac8wErmzpnYe84jsSQh2xHtsGJutmejJbeHFb4D+Ax4Bnge+TupUeA+aSVj/+LPA88Cvbl9WUtTvwSdsfGMD6/hw4xfYfB+ocYV3xHQnDXQS2YU7SR0jXRboHoOxRwNG2v9/fZYfyxHckbGgisIUQQhhS4hpbCCGEISUCWwghhCElAlsIIYQhJQJbCCGEISUCWwghhCElAlsIIYQhJQJbCCGEIeX/A8Vojk7vRVkMAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa4AAAEyCAYAAACiUTSiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAA3e0lEQVR4nO3de5wkVX3//9d79spyWy7LLoIKCBpBBMNF8L5ylQSQeAl+FTFKVhLwFr/+BMUbotGYaKIScA0E9Gs0JoFlo6hcRBF1BVREFxFWQERgwRVWWC7L7rx/f1QN9PZ2z1RP99T0zLyfj0c9uqvqnFOnZnv703Xq1DmyTURExEQxMN4ViIiI6EQCV0RETCgJXBERMaEkcEVExISSwBURERNKAldEREwoCVwRETGhJHBFRMSEksAVk5aknSRZ0nnjXZeI6J0Erog2JG0j6QRJF0paIelhSaslXSXpTZJa/v+RtKOkcyXdKelRSbdJ+mdJWzWlc4fLG3p4bq+U9BlJ35P0x7L8/9er8iPG0vTxrkDEGPod8Exg9Sjzvwo4C7gLuAK4HZgP/AXwb8DLJL3KDeOmSXoa8ANgO+Ai4EZgf+BtwOGSnm97VZn8Qy2O+XZgS+BfgPub9l03yvNo5TRgL+BB4A7gT3pYdsSYUsYqjGhN0kuBTYGv2x5s2L4AuBp4MvBK2//TsO9bwKHAW21/pmH7J4F3AJ+zfeIwx7wNeCqws+3bOqjrG4B/Bxba/k6F9AspAtYK4MUUgflLtl9X9ZgR4yVNhTFhNN6zkvQnkpZI+oOkNWXz3aHt0o/meLa/bft/G4NWuf1u4Oxy9SUNx9uFImjdBpzZVNwHgDXAcZI2HU19esn2FbZvdoe/XCVtJun9kn4q6YFhmjW3G6u6RyRwxUS0M/BDYBvgc8B/AfsA35D0lzXV4bHydV3DtpeWr5e0CHYPAN8H5gAHjH31eq8MRtdQNHEOUATvzwB3l0keA34N/Mj2PeNSyZgSErhiInoR8G+2X2j7VNtvAF4IDAJnS9piLA8uaTrw+nL1mw27nlG+3tQm683l69PHol41+A+Ke2H/AOxt+12230pxD+9RQMABtidkYI6JI4ErJqLVwOmNG2xfC3wJmAscM8bH/xjwLOBi299q2L5lQ/1aGdo+d4zqNWYkHQIcRHHVeGpjE6Pt3wLfo+jstfe4VDCmlASumIh+Uja9NftO+fqcsTqwpLcC76ToLXhcp9nL1656RJXd6ze4p0TRMQPgihb3m87r5niloU4bn2puBi0NBeV8p8SYS3f4mIhWttk+dK9lyzb7uyLpJIpu6jcAB9n+Q1OSoS/vdsffoindaP0zG1+17Q0cDZxP0Tmk0XVdHg+eaIr9Zpv9O5avK3pwrIhhJXDFRDS/zfYF5Wu3gWEjkt4OfAr4BUXQatX54Ffla7t7WLuVr+3ugVVi+59b1O8NFIHrvCrd4TtRPmj9VOAe22ta7J8P7AfcavuWXh47opVc1sdE9KeSNm+x/SXl6097eTBJ76YIWtdRPCfVrsfcFeXroc2japT1fT7wMLCsl/WrwVDT5uZtRgv5/yi+Sz5XX5ViKkvgioloS+D9jRsk7Qu8luJq68JeHUjS+yg6Y/yY4krr9+3S2v41cAmwE3BS0+4PUTzM/IVWVy39rOyI8TOK+r+mcZ+kV1KM9nEjRTNqxJhLU2FMRFcCJ0h6LkUvt+2Bv6T4IfZm23/sxUEkHU/Re3E9Ra+5t0pqTnab7fMa1v+WYsinT0s6CPgl8FxgIUUT4Xt7UbduSXo58PJydaiJ9cCGjhy/t/1/G7KcDlwA/Lukw4HfUjQPHkzRzf8I24+McbUjgASumJhuBU6kuBI6EZgF/AQ4val7erd2Ll+nUVxVtPJd4LyhFdu/Lq/+TgcOB46gGOvw08CHWnToGC97A8c3bdulXAB+AzweuGwvkXQM8G6KsRrFE4H407YfHOsKRwzJWIUxYUjaiSJonV8+dBwRU1DucUVExISSwBURERNK7nHVRNJf80RPs2cD15fvv23779rk2RF4vu3/HKHsg4HjbQ87koOk9cDPKf7df1nmeUjSg7Y3a0ozg2IA2fOBf241WoKklwBvaj6upOcBh9n+wHD1aUh/OEWPtGkUYxB+rEq+TkmaS/t7Vc3O62RakV7IZ2TYep0L/DnFs2TPqpInJq/c46qZpB2AH9h+aoW0xwO72373COneSfFv+Y8jpGv88vkS8GPbn2za3vh+O4qBVb/f6gumfCh3wPYnRzqXYeo0jeIm/yEU80NdA7zG9g2jLXOYY+1EcY+sikrzWo2FfEZa1utFFJNefiGBK9JUWL9nUfxafVw5t9SVkpZLukzStpJeAHwSeKWk6yTtrGK69WWSflbOPzWvLGIvOh/W53vArsMlKB+0XQScrBb9wMvj7iDpR5JuKX9dI+m/yvqjYtr7M1RMEX93+cu/0f7ACtu32F4LfIViBIies32bbVVcvjMWdagon5GNj3Ml0C89MmOcJXDVb0+KYYMAkDQL+B/gbbb3AC4F3mH7Koqrj6Nt7237VuAK2wfY3qtM9+qymL0oHhCtRMW0HC+j6cuxlXIInwGKqeib7Q08YPu5FN3SP1xub/zifRZwv+0XUjzj9NqmMnageCZoyB3ltqksn5GIYSRw1a/51/TLgatsDw1TdANPfAE8gyfGvwN4g6SrJf2M4j/4I5JmAFvYvrfCsTeRdB1wLXA7cE7FOm/0S7r8YtsG+Gi56TpgW0mzgRm2V0uaQzHKxafKNNOB+0cqmy5HT58E8hmJGEY6Z9RvT574TwqwOxt+Se0J3CBpG2C17ccAJL2eolntpbYflHQlsLzM/8uKx37Y9t6dVFbFdPTrgebx+XanaOJbW67/KcUv+j0ovlgp3//Y9vpy/dk0XEmU7gCe3LC+I3BnJ3WchPIZiRhGrrhqpGKA0t0oxnUb8juK/+BDXwDHAV+gGLWh8Qt8T4ob9g9KegXwPIovsw3uXUi6vLy534v6zqOYnv2z3rgXz17AzpJmSdoM+ADFdBt78kRvuGex4X2Vxp5yQ64Bdivvz8wEjgWW9qL+E1E+Iy0/IxEbyBVXvXYF7rD9aMO2LwJHSPo5xcjhb7S9StKjFM0qv6C4+X0+cJGKQU0vBm6xvUbSXsDV8PiX3q50dxN7qKloqKvzFyk6ADTbi2LG4R8AmwAftr1M0quAH5Vp9mx4D8WX1Aa/pm2vk3Qy8C2K7vDn2l7eRf0nunxGWlxxSfoyxej/20q6A/iA7arNmDHJpDv8JCLpWRRfai2f+YnIZyQmgwSuiIiYUHKPKyIiJpQEroiImFASuCIiYkJJ4IqIiAklgSsiIiaUBK6IiJhQErgiImJC6ZvAJelcSfeUowC02i9Jn5a0QtL1kv60Yd/hkn5V7julvlpHRETd+iZwAecBhw+z/2UUY7jtRjG8zVnw+ESEZ5b7dwdeI2n3Ma1pRESfk7SLpDslWdI6SZ8dIf0SSevL9DdJ2rxKWZLeJGmVpMFy+W05zNiY6ZvAVWGiuKMpZj+17WXAXEnbU+NEhBERE8gVFGNJLgDeApwk6ahWCSW9BzgSOIZi8ObtgEsqlvUkiguPJwPzKMbTvKzH57KBiTTIbrsJB1ttf267QiQtorhiY7a0z1NmzR51hbyuu+Gyps2a1lV+gOmzu/snnD57Zlf5B2bN6iq/Z47+7z9k/bQZXeW/fvkvf297Xqt9c6dP94IZ3f2Nuv13njajy/yzxvffGMDTu/s3YqC7v4HV/W/06355U9vPSRX7DGzqPz4+e8vwVvBoV8cqR+1/CnCY7ZXAWZLeBZxK69kXFgHLbC8t858BfLxKWbY/3FiQpA9SDK48ZiZS4Go34WBHExHaXgwsBnjGJnO8eKenj7pCa/+wbtR5AebutllX+QG22XXbrvJv/cyduso/e5edu8q/7imj//sPWbPFk7rKv2D3fX/Tdt+MmSx+2jO6Kn+rneZ2lX+LJ23ZXf6du/v7bPK0XbrKDzA4f8eu8q+fs0V3+WfM6So/wFbPWdj2c1LFAxrkM5tV+//ysgdunCtpTcOmC2wf18HhDgKw3XjVtBzYr036+cCShvWlwCck7Qrs22FZrwIe7KCuHZtIgavdhIMz22yPiOgfAs2ofOW31vamXRxtG2Cwadt9QLsmjulA4wzZQ61YCzopq5wH7miK5sQx0zf3uCpYCry+7F14AMXMr3eRiQgjYiIQDExXpWXEoqT7y44SrZbVwCo2/n6fCzzSpsh1QGPzzdBEo3dXLUvSS4GvAottnzniSXShb664Wk0URzFRHbbPppgY7whgBfAQ8FflvkxEGBH9T6AZIwelKmzPHfZQxX0pJB1se6ijxB7ArW2yrGTDpr+jgEHbK8pAOGxZkp5H0ZnjK7ZP7PB0OtY3gcv2a0bYb+CkNvsupghsERF9Sap2NdULtu+VdDtwjqR9gVcAuwDvaJPl88Dpko4Efg6cRjlr9khlSdoH+C7wTduvHcPTelzfBK6IiEmth1dcFS0Evg/cA6wHzmzoNXgA8EPgQNvLbH9E0v4UHTQGKFq2Dq1SFvAJiljyZ5Ie7xhne8xONoErIqIGEkybVV+3Atu3ANu32beMph7Ztts+/zpCWS/topqjksAVEVEHwcC0Wq+4Jq0EroiIWggNJHD1QgJXREQdBJo2kZ5A6l8JXBERNRBpKuyVBK6IiDqINBX2SAJXREQNJDFtZpoKeyGBKyKiJhpI4OqFBK6IiDqkqbBnErgiImqhdM7okQSuiIgaKFdcPZPAFRFRB8HA9O5nPY8EroiImqSpsFcSuCIiapCmwt5J4IqIqEm6w/dGAldERB1yxdUzCVwREbXI6PC90leBS9LhwL8A04B/s/2xpv3vAoamhp4OPBOYZ/sPkm4DHqCYnXOd7X1rq3hExAiUXoU90zeBS9I04EzgEOAO4BpJS23fMJTG9icopolG0pHAO2z/oaGYhbZ/X2O1IyIqS6/C3uinO4X7Ayts32J7LfAVoO1U0sBrgC/XUrOIiG6paCqssvTmcNpF0p2SLGmdpM+OkH6JpPVl+pskbV6lLElHSlojabBcVpUXFmOmnwLXDsBvG9bvKLdtRNIc4HDgfxo2G7hE0o8lLWp3EEmLJF0r6drV69b1oNoREdVoYKDS0iNXAOuABcBbgJMkHdWyXtJ7gCOBY4Cdge2ASyqWdT1wGMUtnlll2q/26iRa6ZumQop51pq5Tdojge83NRM+3/adkrYDLpV0o+0rNyrQXgwsBthNs/3giodHXeE5O80edV6AabO6//PPmDOrq/zTN5vTXQXmbtNV9kc23ba74wM3+0+6LqMdG9Y/Ojhm5dfB69d3lX/wwQe6rsPAnPu6y796VVf5Z7jdV0l96nyOS9I84CnAYbZXAmeVfQROBZa2yLIIWGZ7aZn/DODjVcqy/RvgN2XaAYp+Bt19OY6gn6647gCe3LC+I3Bnm7TH0tRMaPvO8vUe4EKKpseIiD4hBqZPq7QAM8vmt6Hlix0e7CAA241XTcsprqZamQ9c07C+FBiQtGvVsiQZeAR4NXBZh/XtSD9dcV0D7CZpZ+B3FMHp/zQnkrQl8GLgdQ3bNgUGbD9Qvj8UOL2WWkdEVNHZFdda25t2cbRtgOamgvtofyU0Hbi3YX3ots2CqmXZVnl19hngxlHUubK+CVy210k6GfgWRVvpubaXSzqx3H92mfQY4BLbaxqyzwculATFOf2H7W/WV/uIiJGoZ/evJN0PbNlm9x+BN7Nxi9pciiuiVtYBje32Q/0L7qZo/apUlu17Jb0WeEzSVxt7hfdS3wQuANsXAxc3bTu7af084LymbbcAe41x9SIiuqPe3OOyPXf4w2he+Xqw7aFmuz2AW9tkWQns17B+FDBoe4Wk1R2WNZ2iz8KzgTEJXP10jysiYtIa6pxRR3d42/cCtwPnSJpXtlztAvx9myyfBw4su7bvBJwGXF2lLEnvlnSspBmSdgB+RNG0+I2uT6SNBK6IiJrU3B1+ITATuAf4LHBmQ6/BA8pnsg4AsP0R4GvAEoorqVUUfQVGLIui6/z5wFqKe2NPAl5te3WvTqRZXzUVRkRMWlKtQz6Vt1C2b7NvGU2PINluO+DDCGW9E3jn6GvauQSuiIiaZJDd3kjgioioQSaS7J0EroiIWggykWRPJHBFRNREPeoOP9UlcEVE1EH0ssfglJbAFRFRBwllIsmeSOCKiKhJOmf0RgJXREQNhChm/YhuJXBFRNRBQK64eiKBKyKiJumc0RsJXBERdZDQtHTO6IUEroiImqRzRm8kcEVE1CVNhT2RwBURUQNJGTmjRxK4IiLqkiuunuirv6KkwyX9StIKSae02P8SSaslXVcu76+aNyJivNU1A/Jk1zdXXJKmAWcChwB3ANdIWmr7hqak37P956PMGxExPiRIr8Ke6Kcrrv2BFbZvsb0W+ArQdkbOHuaNiKiFNFBpieH1019oB+C3Det3lNuaHSjpZ5K+IWmPDvMiaZGkayVdu5r1vah3RMTIhkbOqLL04nDSLpLulGRJ6yR9doT0SyStL9PfJGnzTsuS9O0yzbt6chJt9E1TIcU/azM3rf8EeKrtByUdASwBdquYt9hoLwYWA+ym2S3TVDVjTneX/bM2m9lVfoCZm8/pKv/AZpt1lX/d5lt3lX/VJjt2lR/gt3d39zcYlsGPdfUx6dq0mTO6yz97dlf5B568c1f5AR7errsyfr/ZTt3lX7tVV/kLb+kyv+oeOeMKYB2wAPgL4F8lXWJ76UY1k94DHAkcA1wPXAdcAhxYtSxJC4HnAYNjdUJD+umK6w7gyQ3rOwJ3Niaw/UfbD5bvLwZmSNq2St6IiHEnVVu6PozmAU8BTrC90vZZwK3AqW2yLAKW2V5q+zbgDIpbMJ2U9VXgo7S5aOilfgpc1wC7SdpZ0kzgWGCDXwaSFqh8EELS/hT1X1Ulb0TEuBJFd/gqC8yUtKZh+WKHRzsIwPYlDduWA+0ufedTfI8OWQoMSNq1SlmS/glYZ/v0Dus5Kn3TVGh7naSTgW8B04BzbS+XdGK5/2zglcDfSFoHPAwca9tAy7zjciIRES11NFbhWtubdnGwbdi4ye4+oF278XTg3ob1oT4DC0YqS9J8inbUg7qob0f6JnDB481/FzdtO7vh/WeBljcFW+WNiOgbAnrUY1DS/cCWbXb/EXgzG7eozQUeaZNnHbBtw/pQ57a7KW69DFfW1ykeU/reCNXumb4KXBERk1fvegzanjvskYr7Ukg62PZl5eY9KO5NtbIS2K9h/Shg0PYKSatHKGsPYJakoW7aA8DHJS20fUQHp1VZAldERA0EtT2jZfteSbcD50jaF3gFsAvwjjZZPg+cLulI4OfAacDVFcvaE9ikoayfAv8C/ENvz+oJCVwREXWofwbkhcD3gXuA9cCZQ93XJR0A/BA40PYy2x8pO7wtobhiWgEcWqUs2ysaD1r2n7vb9sqxOrEEroiIWggG6hvyyfYtwPZt9i2j6flX221HGxqurBZpxzyuJHBFRNQlo8P3RAJXREQdpJ71KpzqErgiIuqSKUt6IoErIqIuueLqiQSuiIi69GAcwkjgioioRyaS7JkEroiIuqSpsCcSuCIi6iClO3yPJHBFRNQl97h6IoErIqIuaSrsiQSuiIha9GZ24+ivGZAjIiYtCzxtWqVlKpD0PEnvKt9vJanSWIiQwBURUZNyyKcqyyQn6QvApcBHy037AJVnrU9TYUREXaZAUKroVRQzLt8LYPsySXOqZu6rv6KkwyX9StIKSae02P9aSdeXyw8k7dWw7zZJP5d0naRr6615RMTILFVapoD1ttcMrUiaBbhq5r654pI0DTgTOAS4A7hG0lLbNzQkuxV4se37JL0MWAw8t2H/Qtu/r63SERFVZXT4RsslfQuYJundwNuAH1fN3E9/xf2BFbZvsb0W+AqwwcRmtn9g+75ydRmwY811jIgYvWnTqi2T3/OAlRQzKr8FuAx4YdXMfXPFBewA/LZh/Q42vJpq9ibgGw3rBi6RZOBzthe3yiRpEbAIYF5fnX5ETG5Tphmwiq2BN9l+DEDSjHLbqiqZ++mbu9W/aMs2T0kLKQLXCxo2P9/2nZK2Ay6VdKPtKzcqsAhoiwGePn0TT99i9H+CgRnd/TKaudnsrvIDTN9kVlf5Bzbfsqv8D2+2bVf573hoXlf5AVbcvr7rMtrRAEzfrLt/5xmbzOgq/7RZ3eWfsfXcrvI/tmX3/0a/mbN7V/m/e0N3n7NvX3xTV/l7QtTaVChpF+AqYHtgPXC27ZOHSb8EOJKiJe5mYB/bD4xUlqQXAN9rKu5y2wcPU71bgF0prrqgCFo3A1tUObd+aiq8A3hyw/qOwJ3NiSQ9G/g34Gjbj0dn23eWr/cAF1I0PUZE9A1roNLSI1cA64AFFM1xJ0k6qlVCSe+hCFrHADsD2wGXdFjWbNsql+GCFsB020NBi/J95V9o/RS4rgF2k7SzpJnAscDSxgSSngJcABxn+6aG7ZtK2nzoPXAo8Ivaah4RMaJy5IwqS7dHkuYBTwFOsL3S9lkUndtObZNlEbDM9lLbtwFnUP74H0VZVTwm6f801Pe1FIGxkr4JXLbXAScD3wJ+CXzV9nJJJ0o6sUz2fmAb4F+bur3PB66S9DPgauDrtr9Z8ylERAyrgyuumZLWNCxf7PBQBwHYbrxqWk5xNdXKfIqLhyFLgQFJu3ZQ1kOS1km6WdLTR6jfW4DzJa2WtBr4d+DEEfI8rp/ucWH7YuDipm1nN7w/ATihRb5bgL2at0dE9A0JBirfL11re9MujrYNMNi07T6g3Y316ZQPA5eGOsotqFDWzcDrga9S3Lf6FvADigeMW7J9vqSvAodRXEB9w/bDw5zPRpWNiIgxZuhZr0JJ9wPtelb9EXgzG7eozQUeaZNnHRsGmh3K17sp+hu0Lau8PzV0Rbi8fMb2ekk72P7dMKdxHPBsintbh0nC9puHSf+4BK6IiLr0qOOF7bnDHqa4L4Wkg21fVm7eg+LeVCsrgf0a1o8CBm2vKJvyOilr6Oqs7clKuoUiUN5O0UsRJuLIGRERk51bPvUzBsex75V0O3COpH2BVwC7AO9ok+XzwOmSjgR+DpxG0V9gxLIkvZGiB/ilFPe9vgHcb/u3Gx3lCTtQ9EKsHKwa9U3njIiIyU11d4dfCMykGJ3is8CZtpcCSDpAkiUdAGD7I8DXgCUUV1KrKHpnj1gW8BzgfymaG38FPAa8aIS63UPRTDgqo7riKvvvv47ikvDLti8abQUiIqYEgat3zuha2Wmt5RxXtpfRNOiD7aNbpa1Q1lsoegl2YjPgp5L+QEM3eNsLqmQebVPhn9t+NYCks4AEroiIYbi84goAPtBN5tEGrk3Kh4EBuumyGRExdWSsQgBsf1rS8yiG6vuEpG0omiIrGW3g+iBPXBqePsoyIiKmlFxxFcoZkF9BEaw+QXGf7KsUYxaOaLSBa77td5UVOABYMcpyIiKmCNXWq3ACGJcZkI9peN9y0MaIiNhQzb0K+9m4zIA8X9LTygM9aZRlRERMHRLWlJgksoquZkAebeA6DTipfN9V75CIiKmgl0M+TQIHAOez4QzIx1fNPNrAdQywte2/lvQ+4MOjLCciYsqYIs2Aw5I0DVhje9Qz6Y72r/g0nhg9ePPRHjwiYipx2UFjpGUys70euGto1I7RGO0Vlyme5XoWuccVEVFBHkBusCXwQ0n3AWuHNo71yBn/BPwtxbD07xllGRERU0rucT3ug91k7jhwSRLwctundHPgiIipxBKD6VUIjMPIGbYtaT9JrwFWl9suHiFbRMSUN9nvX1XV7cgZo21wvaw84DyGmZ65U5IOl/QrSSskbXRFp8Kny/3XS/rTqnkjIsZbHkB+3KuA7SimQKGcoLLyyBkjXnFJ2onima2nAX8ArgP+1/ZvOq/rsMeZBpwJHALcAVwjaantGxqSvQzYrVyeC5wFPLdi3oiIcZUrrsett71G5T2/TkfOqBLaLwJu5InAsBdwpaQzy4P1yv7ACtu32F4LfAVonh/maOALLiwD5kravmLeiIhx4/onkuxnzSNn3EoHI2dU+QtNs32O7cuBP9j+a4qrr9uAxaOocDs78MSzYVBcOe1QMU2VvABIWiTpWknXrvb6risdEVHVoAYqLVPA84CVbDhyxgurZq7SOeMySSfb/izlpZztdcAnJN3UeX3banUN3Xzp2C5NlbzFRnsxZcB9xqw5nrH56Hv5zNq8cieYlqbPGu3TCE+YscVm3RUws7tzWDNrq67yDz7UfdPJ6vvXjpxolDQgZm46o+syujFj0026yj+wSeVbBy09MnuLrvIDrF7b3bR9K+/p7t941R13d5W/V+z6mgol7QJcRTFz8XrgbNsnD5N+CXAkxQXNzcA+th+oUlbZK/C7wO4U38erbc9tcYw/2N4a+L7tMX0A+e+AUyVdCzxJ0iLgIeBAYNVoD9zCHcCTG9Z3BO6smGZmhbwREeNIeNT94UblCmAdsAD4C+BfJV1ie+lGNZPeQxG0jgGup+jLcAnF93yVsq4BplEErl8Dr25Tp00lvRV4jqRjaWr1s/0fVU5sxL+i7UHbHwFeBCwqK74P8AuKzhK9cg2wm6SdJc0EjgWa/8BLgdeXvQsPoIjqd1XMGxExbkx9Qz5Jmgc8BTjB9krbZ1HcRzq1TZZFwDLbS23fBpxB0XdgxLIkHQ7sDDzP9o22H7P9pTbH+QzwPoqLjbMo+k4MLZ+ten6V26psP0QRDMYkINheJ+lk4FsUkftc28slnVjuPxu4GDiCYuLKh4C/Gi7vWNQzImK0auxVeBCA7Usati0H9muTfj6wpGF9KcXtoF2BfUco6xjgUeB/Je1NMYTTZ4YmG26ywvY8SZfbPqijM2rQ/U2WHiofZL64advZDe/NE9OpjJg3IqKfdBC4Zkpa07B+ge3jOjjUNsBg07b7gHYjsk+nnI24NNTZbUGFsnYCZgF/pBh0/U3Av0j6ju2vN+X7J+BsnmiCHJXKDa6SXiVp8/L9aZIuaHwAOCIihiMGPVBpAdba3rRh2SBoSbpfktssqyn6HzR/v88FHmlTuXVsOJjEUK/suyuU9XD5epjtNbY/TdFj8I0tjjMo6WZglqTrmpc2ddtIJ3cK32f7AUkvAA6jmATsrA7yR0RMWb28x2V7rm21WbYELgeQdHBDtj0o7k21spINmxGPAgZtr6hQ1lUVTn/IPhQtYwaubrFU0klT4dBDT38GnGX7Ikkf7CB/RMSUVtc9Ltv3SrodOEfSvhTjAu4CvKNNls8Dp0s6Evg5xSz3V1cs60zgo8DXJf0ZRd+D+cC/tajXTcDbJF1l+79Ge36dBK7fSfoccDDw8XLUjCnxpFxERC/UPOTTQuD7FA/5rgfOHOq+XvbK/iFwoO1ltj8iaX+KDhoDFB3gDq1Slu2HJb0S+BJF8+Fa4OO2v9FcIUlft/1nwGmS3tu83/beVU6sk8D1auBw4B9t318OtdSq10hERGxEtT6AbPsWigeGW+1bRtPADbbbDpM3XFnl/qUUHTNGMjSs048qpG2ro+7wkn4NHCbpMOB7Td0jIyKiDQODU3yQXdvvL18XdVNO5cAl6W3AXwMXlJv+n6TFtj/TTQUiIqYEM9RjcMqSNOzYW7YXVCmnk6bCNwHPtb2mrMDHKdpIE7giIirItCZ8tHz9K4rnw84r118P/K5qIZ0ELvFEz0LK91P+XyEiopp673H1o/IZLySd3jQI7/sl3V+1nE4C178DP5J0Ybn+cuDcDvJHRExZQ89xBQCbSHqx7e8CSHohUHkahE46Z3xS0neAF1Bcaf2V7Z92WNmIiClrql9xNTgduFzSg+X6ZhTPjlXSSeeM84G32f5Jub6VpHNttxrWIyIimqxP4AKgfG7s0xSPWAF8c2juryo6aSp8tu37Gw58n6TndJA/ImLK6tWUJZNFGahGNXpGJ4FrQNJWtu8DkLR1h/kjIqa0NBX2RieB55+AH0j6b4r7jK8GPjImtYqImIRyxdUbnXTO+IKka4GXUnTO+AvbN4xZzSIiJhPDoMe7EpNDR019ZaBKsIqI6FC6ww9P0kO251RJm3tUERE1GRxM4GqnatCCPpmWRNLWki6VdHP5ulWLNE+WdIWkX0paXo6dOLTvg5J+1zCT5hH1nkFExEjEYMUlhtcXgQs4Bbjc9m4Us22e0iLNOuCdtp8JHACcJGn3hv2fsr13uVw89lWOiKjOFL0KqyyTlSQPt1Qtp18C19HA+eX78ymGk9qA7buGHn4u+///EtihrgpGRHTLrrZMVrY13FK1nH4JXPNt3wVFgAK2Gy6xpJ2A57DhZGQnS7pe0rmtmhojIsbb0EPIIy1TgaS/kXRO+f7p5XiFldTWOUPSZUCruVY2mr55hHI2A/4HeLvtP5abzwI+THE1/mGKZ85aDkUlaRGwCGC7aTM6OXRExOilO/zjJH0b2B3YmmLKrE2BrwNbVMlfW+CyfXC7fZJWStre9l2StgfuaZNuBkXQ+pLtoQktsb2yIc3nga8NU4/FwGKAZ8ya09XHSAPd/TKaNrP7P79mdBl8Z87u7vh09z/x4ce6/xvM3mQMf6FKTJvRXcPEjE26+zeaNmtmV/nZpPKg2y0NDnT/b/TY+mld5Z8+vbt/4+nd/g17wNTbq1DSLsBVwPYU01CdbfvkYdIvAY6kaIm7GdhnaPzA4cqSdCbwty2KfJ3tL7U53IHAHGANgO2flt/vlfRLU+FS4Pjy/fHARc0JJAk4B/il7U827du+YfUY4BdjVM+IiFGruVfhFRSd2hYAb6Ho0HZUq4SS3kMRtI4Bdqa4XXNJlbJsn9R0n+qcMu1/DFO39fYTd/MkzevkxPolcH0MOETSzcAh5TqSniRpqIfg84HjgJe26Pb+D5J+Lul6YCHwjprrHxExoro6Z5SB4CnACbZX2j4LuBU4tU2WRcAy20tt3wacAew/yrJeAXyvMTC1cIWkG4AZkr4A3MIwLWXN+uIBZNurgINabL8TOKJ8fxVtZly2fdyYVjAiokvubAbkmZLWNKxf0OH33EEAthuvmpYD+7VJPx9Y0rC+FPiEpF2BfauWJel5wFzgA+0qVraefZjiIuMVwDOBM2x/fLgTatQXgSsiYtLrrHPGWtubdnG0bYDBpm33Ae1uak8H7m1Y/235uqDDsk4HVtv+XruK2bakK8rzqxysGvVLU2FExKQ3aFVaRiLp/mEe5F0NrGLj7/e5wCNtilwHbNuwPvSM7N0dlvUiig50I7lF0vEjJ2stgSsiogamuOKqsoxYlj13mAd5t6QYgQhJjb2596C4N9XKSjZs+jsKGLS9ompZkk4EZgCnjXwGPB04T9Jjkh6W9IikhyvkA9JUGBFRm7pGxbB9r6TbgXMk7UtxL2kX2ndc+zxwuqQjgZ9TBJ+rOyzrbcAtQ4NJjGBhp+fUKIErIqImNQ/ntBD4PsVzseuBM20vBZB0APBD4EDby2x/RNL+FB00BoAVwKFVyirL2xL4E+BdVSpm+wfdnFgCV0REDWwq3b/q3fF8C8UDw632LaOpl7bto0dTVrl/dXN5YymBKyKiJpN5AN06JXBFRNRkfXOn8hiVBK6IiBoMzccV3UvgioiowySfa6tOCVwRETXJtCa9kcAVEVGDoqlwvGsxOSRwRUTUJJ0zeiOBKyKiDrnH1TMJXBERNShmQB7vWkwOCVwRETXJFVdvJHBFRNQkgas3ErgiImrgziaSjGEkcEVE1GQwkasn+iJwSdoa+E9gJ+A24NW272uR7jbgAYph9dfZ3reT/BER4ymdM3qjX2ZAPgW43PZuFLNtnjJM2oW29x4KWqPIHxFRO7v6EsPrl8B1NHB++f584OU154+IGHODrrbE8PolcM0fmu65fN2uTToDl0j6saRFo8iPpEWSrpV07f3r1/Wo+hERI8sVV2/Udo9L0mXAgha73ttBMc+3faek7YBLJd1o+8pO6mF7MbAY4Bmz5nT1EXEf/DTy+vXjevwBd3f86QPdN/pvOmda12W0ZwbXj++/s93l3+jRR7rKLro//27/nWfPntlV/jlbbNZV/l7ph++MyaC2Ky7bB9t+VovlImClpO0Bytd72pRxZ/l6D3AhsH+5q1L+iIjxYhdjFVZZekHSLpLulGRJ6yR9doT0SyStL9PfJGnzqmVJ+pSkR8v9j0r6+96cRWv90lS4FDi+fH88cFFzAkmbDv0hJW0KHAr8omr+iIjxNjjoSkuPXAGso2jpegtwkqSjWiWU9B7gSOAYYGeK2y2XVClL0j7A24EzKGLK3wOnSNq9VyfSrF8C18eAQyTdDBxSriPpSZIuLtPMB66S9DPgauDrtr85XP6IiH4xNK1JHfe4JM0DngKcYHul7bOAW4FT22RZBCyzvdT2bRRBaP+KZe0F2PaHXfhgebrP7/5MWuuL57hsrwIOarH9TuCI8v0tFH+gyvkjIvpGZ0FppqQ1DesX2D6ug6MdBGC78appObBfm/TzgSUN60uBT0jaFdh3hLK+CHxS0hnAh4DTgcGm8nqqLwJXRMTkZwarR661tjft4mDbUASPRvcBs9uknw7c27D+2/J1wUhl2X5M0oUUHe2GOtt9yPa9jJF+aSqMiJjUDAyud6VlJJLuLztCtFpWA6vY+Pt9LtCui+k6YNuG9R3K17tHKkvSuyj6FryeIgC+AXifpL8c8URGKYErIqIOLoZ8qrKMWJQ917baLFtSjCCEpIMbsu1BcW+qlZVs2Ix4FDBoe0WFsl4E3G37i7bX2z6fomf360Y+k9FJ4IqIqIntSksPjnMvcDtwjqR5kk4EdqHo8dfK54EDJR0paSfgNIpOcFXKuhRYMHSFJelYintm3+/6RNrIPa6IiBqY2odzWkgRPO6hGJj8TNtLASQdAPwQOND2MtsfkbQ/RYeKAWAFxSNHI5Zl+9OSXgB8UdJXKJodv2Z7zHp3J3BFRNTB9Y6cUfbE3r7NvmWAmrYdPZqyyv2vHmU1RyWBKyKiJhmHsDcSuCIiamCb9b0az2mKS+CKiKhJt+MlRyGBKyKiJh08gBzDSOCKiKhJL7q6RwJXREQtbHo58vuUlsAVEVGTXHD1RgJXREQN0quwdxK4IiJqUucDyJNZAldERE0SuHojgSsiog6ufazCSSuBKyKiBiZXXL3SF9OaSNpa0qWSbi5ft2qR5hmSrmtY/ijp7eW+D0r6XcO+I2o/iYiI4ZSdM6osMby+CFzAKcDltnejmLTslOYEtn9le2/bewP7AA8BFzYk+dTQftsX11HpiIhO1DUf12TXL4HraOD88v35wMtHSH8Q8GvbvxnLSkVE9MpQU2GVJYbXL4Frvu27AMrX7UZIfyzw5aZtJ0u6XtK5rZoah0haJOlaSdfev35dd7WOiKjKCVy9UlvnDEmXAQta7Hpvh+XMBI4CTm3YfBbwYYofNR8G/gl4Y6v8thcDiwGeMWtOV5+QwcfWd5O9Nwa7bA9/7NGusnvDueg6Nn1a9/9Ju/0TDEcDYsacGV2VMWPOrK7ye113nzOvXdtV/llrVnWVH2DBtt2Vsd22O3aVf96O87rK3xvOILs9Ulvgsn1wu32SVkra3vZdkranmB66nZcBP7G9sqHsx99L+jzwtV7UOSKil3I11Rv90lS4FDi+fH88cNEwaV9DUzNhGeyGHAP8oqe1i4jokk2tvQol7SLpTkmWtE7SZ0dIv0TS+jL9TZI2r1qWpPMkrS333yvpOT05iTb6JXB9DDhE0s3AIeU6kp4k6fEegpLmlPsvaMr/D5J+Lul6YCHwjnqqHRFRXc33uK4A1lHconkLcJKko1ollPQe4EiKH/47U/QzuKRKWZLeCrweeCWwGbCyTD9m+iJw2V5l+yDbu5Wvfyi332n7iIZ0D9nexvbqpvzH2d7T9rNtHzXU0SMion9U6wrfi+7wkuYBTwFOsL3S9lnArWzYN6DRImCZ7aW2bwPOAPavWNZxwPIy75pyfUtJC7s+kTb6InBFREx2NnhwsNICzJS0pmH5YoeHO6g4phuvmpZTXE21Mh+4pmF9KTAgadcKZalchgzFlbb9GrqVIZ8iImrSwUSSa21v2sWhtgGab5bdB8xuk346cG/D+m/L1wUVyvoKxe2aVwDfBoaC7BadV7uaXHFFRNSkV02Fku4vO0K0WlYDq9j4+30u8EibItcB2zas71C+3j1SWbb/Efgvik5zq4DbyzQ3jngio5QrroiIGthmcF1vegzanjvc/vK+FJIOtn1ZuXkPintTrawE9mtYPwoYtL2iDITDlmX7LxuOfShwGPD1yifUoVxxRUTUZNCDlZZu2b6X4srnHEnzJJ0I7AL8fZssnwcOlHSkpJ2A04Crq5QlaUtJL1fhAOCrwA/KTh5jIldcERF1cO0PIC8Evk8xoMN64EzbSwHKAPND4EDby2x/RNL+wBKKC5oVwKFVyqJoNvwyxT2vQeBHwEvG8sQSuCIiamDqHYfQ9i3A9m32LWPDnoDYPnqUZf0G2GT0Ne1cAldERE0yZUlvJHBFRNTBsL7LAZOjkMAVEVEDY9yDjheRwBURUY/6O2dMWglcERE1SeDqjQSuiIhauCfPaEUCV0RELZymwp5J4IqIqINhML0KeyKBKyKiFulV2CsJXBERNTAdTWsSw0jgioioQzmRZHSvL0aHl/QqScslDUrad5h0h0v6laQVkk5p2L61pEsl3Vy+blVPzSMiqirGKqyyxPD6InABvwD+AriyXQJJ04AzgZcBuwOvkbR7ufsU4HLbuwGXl+sREX3FHqy0xPD6oqnQ9i8BJA2XbH9gRTlKMZK+AhwN3FC+vqRMdz7wHeDdY1PbiIjOFRNJpldhL6ifRiuW9B3g/9q+tsW+VwKH2z6hXD8OeK7tkyXd3zgjqKT7bLdsLpS0CFhUrj4D+FUPT2Fb4Pc9LK+XUrf2nmp7Xqsdku4FftPDY433uQ6nn+sG41+/tp+TKsrP0pyKyR/q5liTXW1XXJIuAxa02PVe2xdVKaLFto6jru3FwOJO81Uh6Vrbbe/RjafUbXR6/eXRz+faz3WD/q/fSBKIeqe2wGX74C6LuAN4csP6jsCd5fuVkra3fZek7Slm6YyIiEmoXzpnVHENsJuknSXNBI4FhqaOXgocX74/HqhyBRcRERNQXwQuScdIugM4EPi6pG+V258k6WIA2+uAk4FvAb8Evmp7eVnEx4BDJN0MHFKuj4cxaYLskdStP/TzufZz3aD/6xc16avOGRERESPpiyuuiIiIqhK4IiJiQkng6gFJ7yiHrPqFpC9Lmj3O9TlX0j2SftG0/S3lkFnLJf3DONVttqSrJf2srMeHyu2fkHSjpOslXShp7njUbyz10+ckn5GYyBK4uiRpB+CtwL62nwVMo+jxOJ7OAw5v3CBpIcUII8+2vQfwj+NQL4BHgZfa3gvYGzhc0gHApcCzbD8buAk4dZzqNyb68HNyHvmMxASVwNUb04FNJE2neDL+zhHSjynbVwJ/aNr8N8DHbD9aphmXZ91ceLBcnVEutn1J2XMUYBnFc3qTTd98TvIZiYksgatLtn9H8cv0duAuYLXtS8a3Vi09HXihpB9J+q6k/carIpKmSbqO4kHxS23/qCnJG4Fv1F6xMTRBPif5jMSEkMDVpXIKlaOBnYEnAZtKet341qql6cBWwAHAu4CvaoRRjceK7fW296b4xby/pGcN7ZP0XmAd8KXxqNtYmSCfk3xGYkJI4OrewcCttu+1/RhwAfC8ca5TK3cAF5TNMFcDgxSDlo4b2/dTjOR/OICk44E/B17ryfeA4UT4nOQzEhNCAlf3bgcOkDSn/HV6EMXIHv1mCfBSAElPB2YyDiNtS5o31BtM0iYUX+g3SjqcYiqao2w/VHe9ajARPidLyGckJoC+mI9rIrP9I0n/DfyEovnip4zz0DSSvkwxP9m25VBaHwDOBc4tuz+vBY4fp1+s2wPnq5gYdIBi6K6vSVoBzAIuLVunltk+cRzqNyb67XOSz0hMZBnyKSIiJpQ0FUZExISSwBURERNKAldEREwoCVwRETGhJHBFRMSEksAVERETSgJXRERMKAlcfUzSmyXdJem6hmXPHpa/STmY6rRyfb6k/5B0i6QfS/qhpGNGKOM7kg5r2vZ2Sf8qaaakK8vR0GMM5DMSU1ECV397NnCa7b0blp/3sPw3UoxNt74chmgJcKXtXWzvQzFf1EhTR3yZjeeVOhb4su21wOXAX/awzrGhfEZiykng6m97AteNYfmvBS4q378UWGv77KGdtn9j+zND65JeV85Me52kz5W/wv8b+HNJs8o0O1GMfn5VmW1JeZwYG/mMxJSTwNXf9gD+vaEJaFGvCpY0E9jF9m0Nx/rJMOmfSfGr+PnldBPrKUboXgVczROz6R4L/GfDGHe/AMZtXqcpIJ+RmHLSrtynJD0ZuKecprzV/gHbg10cYlvg/mGOfybwAopf2PtRjGa+D3BNOcDpJhST/METTUEXla9vHCqnbGJaK2lz2w90Ud9oks9ITFUJXP3r2cCNzRslvYFimodrJV0IvBMQ8GvgQuAMii+LC4G7gQ8CjwD/a/uihqIeBmY3rC8HXjG0YvskSdsC1w4dGjjf9qkt6roE+KSkPwU2sd38q3xWWYforXxGYkpKU2H/2pMWX0qlb9j+Z+BvKb5cVpXpTwJOt/1O21cBJwLvs30CsMFsu7bvA6ZJGvpi+jYwW9LfNCSb0/D+cuCVkrYDkLS1pKeWZT1IMdnfuRS/rB8naRtgaPLE6K18RmJKSuDqX3sCxzXcu/ippM3KfavL1wHgS7Y/aPtNFL94G5uGBAzdR2g1f80lFE09lPcbXg68WNKtkq4GzqeYuA/bNwCnAZdIuh64lGLepCFfBvYCvtJ0jIXAxR2deVSVz0hMSZmPa4Ipm4F+X06s91Tgo8BdwAPAFyiafe4CllLMXvs+4CHgm7YvbCrrOcDf2T5uDOt7AXCq7V+N1TFiQ/mMxGSXwDXFSXojxX2J9WNQ9kzgWNtf6HXZUZ98RqLfJHBFRMSEkntcERExoSRwRUTEhJLAFRERE0oCV0RETCgJXBERMaEkcEVExISSwBURERPK/w/wpPk8EA8J2gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa4AAAEyCAYAAACiUTSiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAA1LklEQVR4nO3de5wkVX338c93Zq/sriyX5SKiQMQLoKBGBNRHEFAgAeTxEowajJcNCfjERI2gqEQhaoiaEAhkjQTk8fKQRGBVlJsogq6AisAqyLqg4nITWeS+Ozvf54+qgabpnqmZ6q3p2fm+X696dVfVOVWnZ2v71+fUqXNkm4iIiKliYLILEBERMR4JXBERMaUkcEVExJSSwBUREVNKAldEREwpCVwRETGlJHBFRMSUksAVERFTSgJXTGmSniXp05J+JOl3ktaWrz+Q9E+SXtQhz6Ckd0r6TkueuyRdJ+k/JB3SIY/HWN46gbK/TtK/SvqupN+Xx/m/E/xT9P15I3plxmQXIGIiJAn4cLkMAD8C/h/wO2AB8HzgXcB7JB1t+9Qy3yDwNeAAYDXwdeA2YFPgD4A/BZ4DLO1y6r/vsv3aCXyM44BdgQfKMjxnAseYiMk6b0RPJHDFVPVh4Hjg18AbbV/ZnkDSFsC7gY1bNr+RImj9BHiF7fva8mwEvKTbSW0fX7Pcrf6GInCsAF4BXDaRg5S1vf8E9rH97abOGzFZErhiypG0A0WtYQ1woO3lndLZvgv4gKTW63yv8vXM9qBV5nmIhr7IbT92nqIC2YyJnFfSfOBvgcOAZwLzuyTdsvy7R6w3CVwxFf05xbX7xW5Bq5XtoZbVe8rXZ62Pgm2IyprrdyiaFK8DTgdmA68HtgLWAr8CfpugFU1I4Iqp6KXl67cmkPcrwPuBIyUtAM4Ffmj7l1UySzq+w+ZbbZ85gbJMFV+kCFr/CBzjckoJSScBNwODwB62fzt5RYzpJIErpqKtytfftO+QtB3w1rbNq23/M4DtH0t6M/AvwJvLBUm/Ay4HzrD91VHO/ZEO274DnFm59FOIpP2BfYErgWPdMg+S7V9L+i6wH7AbcMmkFDKmnQSumIpGbsx0mkxuO54cXH4J/PPIiu1zJJ0L7AO8DHhB+foa4DWSPg+81R0mq7Pd3M2oDiTdCjyjy+7LOtyzOsv2W2uc8s3l62dsD3fYP3KfMI/WRGMSuGIqup2i6Wqb9h1lrzoBlJ0y1nY6gO21wEXlMtJN/rXAGcCfUTQhntfzktf3z8DCtm27AYcCZwG3tu27tub5Xg4MA9/ssv9p5euKmueJqCyBK6aiKylqS/tSBJrabK8DzpH0PIoei6+kDwPXSJNnq7I7/KEUPSW/3atzSRqgqN3dZfvBDvu3BF4M3GJ7Za/OGzGWVO9jKjoTGAJeJ+m5PT72/eXrpDYJ9omRptIFZRBr93cU3yH/3lyRIhK4Ygqy/QvgBGAW8A1Je3VJurB9g6Q3Stq/0xexpK2Ad5arl/eouFNWeY/vJ8A8ige3HyPpdRQPd99I0dElojFpKoyp6qMUtaIPAVdK+iFwFcWQTwspOmnsV6ZtDUIvAf4auEPSFcAt5fbtgT8C5gLnA/+9fosPkl5D0SEEHu8puaekM8v3v7X93kk+70cpHiH4T0kHUIxU8mKKv+3NwEG2H+l1GSNGow4dpyKmDEnPBo6kuOe1HUXt4H7gF8AVwNm2f9SSflvgEIov3p2ArYE5FA8m/5jimaUvtvegk2Toba/C8pmwTt3rR/zS9nYVjvNWxjHk03jPK+lQimffdqX4sfBz4BzgZNsPjHW+iF5L4IqIiCkl97giImJKSeCKiIgpJZ0zInpA0kKKXnZVnGn71vVWmIgNne0sDSwU3ayvLZfhlvefHiXP04A/qXDs/Sg6IYyVbl15zhuA/wI2Krc/0CHNcoqu0H8LDHQ53t6dzksxdcjfj+NvcwBwE8XoC8dM9r/VBP99t6N47qnKsneukXFfI2cAdwE3TPa/dZbJX9I5o2GStgG+Z7vbeHOtaY8AdrL9/jHSvYeio80/jZHuAdvzy/dfoBgV/dNt21vfb0HRy+5K20/qhSbp3RRfWJ8e67OMUqZBil5q+1NMbng1xcSQP53oMae6XCMdy/W/KGZs/rztXeocK6a+3ONq3i7A9a0bJD1H0uWSlku6RNLmkl4GfJpidIhrJW0v6XWSlkn6iaQrJC0qD7Er4x+T7rsUEwJ25WJupcXA0eo84+CuwDaSfiBppaS9y8/zX2X5kXSupBMkfVfSHZL2azvG7sAK2yttrwG+TDF80XSWa+TJ57mc4hm9iASuSfA8imYYACTNBv4H+GvbOwMXA39j+wqK2sehtnezfQtwme09bO9apntDeZhdKZpsKikHnz2Qti/HTlyMQTcAbNFh927A/bZfQvEs1cfK7a1fvLtQTCvycuCvgDe1HWMbiodaR9xGh8Fzp5lcIxGjSOBqXvuv6dcAV9j+cbn+Ux7/Ang2xb2fEW+VdJWkn1D8B39E0kzgKbbvrnDuuZKuBa6hmLH2cxXL/KRf0uUX22bAP5SbrgU2lzQHmGn7PkkbARsDnynTzABWj3VsOk9XMp3kGokYRXoVNu95PP6fFIrRG65v2/9TSZsB97mYfgNJf0bRrPZK2w9Iupzi5vhOwM8qnvth27uNp7CSdqC4Gd8+JftOFE18a8r1F1L8ot+Z4ouV8v0PXYy8DvB8WmoSpduAbVvWnwasGk8ZN0C5RiJGkRpXg8qBXXekGJh0xG8o/oOPfAG8Bfg8xdh5rV/gz6O4Yf+ApNdS9Mq6nrZ7F5IuLW/u96K8i4DTgVP85F48uwLbS5otaT7FEEL/XJbzujLNLjzxvsrzW/aNuBrYsbw/Mws4HFjai/JPRblGOl4jEU+QGlezngncZvvRlm1nAwdJuh54GHib7XskPUrRrHIDxc3vs4DzVYzKfQGw0vaDknalGFx25EvvmdS7iT3SVDSTYuqQsyk6ALTbFfgC8D2KgWk/ZnuZpNcDPyjTPK/lPRRfUk/4NW17SNLRwIXAIHCG7eU1yj/V5RrpUOOS9CWKrvWbS7oN+Ijtqs2YsYFJd/gNiKRdKL7U/nayyxL9KddIbAgSuCIiYkrJPa6IiJhSErgiImJKSeCKiIgpJYErIiKmlASuiIiYUhK4IiJiSkngioiIKaVvApekMyTdVY4C0Gm/JJ0saYWk6yS9sGXfAZJuKvcd01ypIyKiaX0TuIAzKWbC7eZAijHcdqQY3uY0eGwiwlPL/TsBb5S003otaURETJq+CVwVJoo7lGL2U9teBiyUtDWZiDAiYlqZSoPsdptwsNP2l3Q7iKTFFDU25kgvesbsOb0vaUUzN5pZ+xgz5s6ulX9g7txa+T1jVq38w4P1/wbDqvf76/oblv/W9qJO+zaZNdNPnVvvGhmcXe+/2eCsen+jgdn1rhHPrPdvDOCBwVr5NTxcuwx1/fimX3S9Tqp40cA8//6x2VtGt4JHa51rQzeVAle3CQfHNRGh7SXAEoDnzN3IS/7g2b0p3QRsvevWtY+x6Pk71Mo/Z5ddauVfu2jbsRON4uH5W9bKD/DQrKfUyr/9js/+Zbd9T507hy/u+YJax990h3rfP/O3rfc3mvusHWvlH97q6bXyAwzNmV8r/+CjD9YuQ13zX/rartdJFfdrmH+dv32ltAfef+NGdc61oZtKgavbhIOzumyPiOgfAs3sm7szU9pU+isuBf6s7F24B8XMr7eTiQgjYioQDMxQpSVG1zc1rk4TxVFMVIft0ykmxjsIWAE8BPx5uS8TEUZE/xNoZoJSL/RN4LL9xjH2Gziqy74LKAJbRERfklKb6pW+CVwRERu01Lh6JoErIqIBEgzOnkrdCvpXAldERBMEA4OpcfVCAldERCOEBhK4eiGBKyKiCQINpqmwFxK4IiIaINJU2CsJXBERTRBpKuyRBK6IiAZIYnBWmgp7IYErIqIhGkjg6oUEroiIJqSpsGcSuCIiGqF0zuiRBK6IiAYoNa6eSeCKiGiCYGBGvZmgo5DAFRHRiDQV9koCV0REA9JU2DsJXBERDUl3+N5I4IqIaEJqXD2TwBUR0YiMDt8rfVVvlXSApJskrZB0TIf975N0bbncIGmdpE3LfbdKur7cd03zpY+I6E5lr8IqS2/Opx0krZJkSUOSThkj/Xnld6ol/VzSgpZ950h6sNy3okPe90p6tNx/r6S9evIhuuibwCVpEDgVOBDYCXijpJ1a09g+yfZutncDjgW+Y/t3LUn2Kff/YVPljoioamBQlZYeuQwYArYC3gUcJemQTgklfQA4GDgM2B7YArioJcktwMnA8g55nwWcBJwCLARuBi7s1YfopG8CF7A7sML2SttrgC8Dh46S/o3AlxopWUREXSqaCqss9U+lRcDTgXfYvtP2aRTB59guWRYDy2wvtX0rcALFdzIAtt9v+1jg3g55PwTcb/s9tu8D/giYL+nA2h+ki34KXNsAv25Zv63c9iSSNgIOAP6nZbOBiyT9UNLibieRtFjSNZKuWb1uqAfFjoioRgMDlRZgVtk0N7KcPc5T7Qtgu7XWtJyiNtXJlsDVLetLgQFJz6xwrl2AX42s2L4beBR45XgKPB791Dmj088Md0l7MHBlWzPhS22vkrQFcLGkG21f/qQD2kuAJQA7ao7vv+mhCRd4sxduPOG8ALMXzKmVH2DmwnplYM5GtbI/Mn9RrfyrZ29RKz/Ajfd2/H3TEx42Q4+uq3UMDda7Z1H3nocferDe+e/+Ta38ALNU7zfy2ltvqZX/4TvurpW/F8b5HNca2/NqnG4zYLht271Aty+dGUDrH2mkErEV8KR7Wm02An7Xtm0NsMnYxZyYfqpx3QZs27L+NGBVl7SH09ZMaHtV+XoXcC4t1dyIiMmnnnXOkLS67AjRabkPuIcnf78vBB7pcsghYPOW9ZFfg3dU+GAPAQvats2ic7NiT/RT4Loa2FHS9pJmUQSnpe2JJG0MvAI4v2XbvJEeMJLmAa8Cbmik1BERVZQ1rl7c47K90La6LBsDlwJI2q8l284U97k6uRN4ccv6IcCw7bFqW1B81z79sY9Z3F+bDXyrQt4J6ZvAZXsIOJqiN8rPgHNsL5d0pKQjW5IeBlxku7X9Y0vgCkk/Aa4Cvm77m02VPSJibBrPPa5ayvtMvwI+J2lR+R26A/DxLlk+C+wp6WBJ2wHHUXyXFiWXZpeVhkGKe18bS5pd7j4RWCDppDLNV4EHbH+j9gfpop/ucWH7AuCCtm2nt62fCZzZtm0lsOt6Ll5ERD1q9AHkfYArgbuAdcCptpcWxdAewPeBPW0vs32ipN2B8ygqNCsoWq5GXEjR0jViNfAdYG/bN0r6O4qeiO8F7qN4rGm96avAFRGxoWp6kN3yB/3WXfYto61DnO2ujx/Z3nuMc51E8SxXIxK4IiIakkF2eyOBKyKiCVImkuyRBK6IiIZkkN3eSOCKiGhAJpLsnQSuiIhGCHKPqycSuCIiGqJmu8NvsBK4IiKaoPQq7JUEroiIJkgovQp7IoErIqIh6ZzRGwlcERENEEI1p3eJQgJXREQTBKTG1RMJXBERDUnnjN5I4IqIaIJUezbsKCRwRUQ0JJ0zeiOBKyKiKWkq7IkEroiIBkjKyBk9ksAVEdGU1Lh6oq/+ipIOkHSTpBWSjumwf29J90m6tlw+XDVvRMRk04AqLTG6vqlxSRoETgX2B24Drpa01PZP25J+1/YfTzBvRMTkkCC9Cnuin2pcuwMrbK+0vQb4MnBoA3kjIhohDVRaYnT99BfaBvh1y/pt5bZ2e0r6iaRvSNp5nHmRtFjSNZKuuY91vSh3RMTYRkbOqLLEqPqmqZDin7Wd29Z/BDzD9gOSDgLOA3asmLfYaC8BlgA8a+Zcz9p05oQL/JSnLphwXoC5m29cKz/AwIL5tfKvfcrmtfL/fk69/L95cFGt/AC/vHP9/f6yzdAjQ7WOMVBzRPDBefNq5dcmm9XK/9AznlcrP8DaGXNr5V+z0ytr5X9koN7fEIBPnF3zAMrIGT3ST3/F24BtW9afBqxqTWD797YfKN9fAMyUtHmVvBERk06qtvTkVNpB0ipJljQk6ZQx0p8naV2Z/ueSFrTsO0fSg+W+FW353i7pHknD5fJrSbv25EN00U+B62pgR0nbS5oFHA4sbU0gaSuVD0JI2p2i/PdUyRsRMalE0R2+ytIblwFDwFbAu4CjJB3SsWjSB4CDgcOA7YEtgItaktwCnAws75D9qcCZFJWHRcDDwCU9+QRd9E1Toe0hSUcDFwKDwBm2l0s6stx/OvA64C8lDVH8cQ63baBj3kn5IBERHTU3VqGkRcDTgVfbvhM4TdL7gGPp/KN+MbDM9tIy/wnAJ0d22n5/uf1lwNatGW1/rO3cxwNf6NmH6aBvAhc81vx3Qdu201venwJ0rO52yhsR0TcENNdjcF8A2621puXAi7uk35Kiz8CIpcBJkp5pe0XnLF29HnhgnHnGpZ+aCiMiNmAVexQWvQpnlfeURpbx9gzZDBhu23YvMKdL+hnA3S3rI720txrPSSW9luJRpPU6CERf1bgiIjZUgvE8o7XGdteukJJWA926Jf8e+AueXDFZCDzSJc8Q0NpFeORxojvGKmhLmV4JnAMssX1q1XwTkcAVEdGEHs6AbHvhqKcq7nEhaT/bIx0ldqboZNHJnTyxGfEQYLhqM6GkvSg6c3zZ9pFV8tSRpsKIiEYIBgarLTXZvhv4FfA5SYvKTm47AB/vkuWzFIM7HCxpO+A44KrHSi7NlrQxRee3AUkbS5pd7nsR8B3gm7bfVLvwFaTGFRHRlGYfQN4HuBK4C1gHnNrSa3AP4PvAnraX2T6xfMToPIoKzQrgVS3HuhB4Rcv6aopgtTdwEkUs+SNJjw38YHu9DQGSwBUR0QSpyV6F2F5JW9f1ln3LaBtxyHbX8V1t7z3KvnrDmkxAAldERFMyDmFPJHBFRDQlI7/3RAJXRERTejQO4XSXwBUR0YRMJNkzCVwREU1JU2FPJHBFRDRBaro7/AYrgSsioim5x9UTCVwREU1JU2FPJHBFRDSid7MbT3cJ/xERDbDAg4OVlulA0l7l5JZI2kRSx1E+OkngiohoRDnkU5VlAyfp88DFwD+Um15EMdFlJWkqjIhoyjQIShW9nmL+r7sBbF8iaaOqmfvqryjpAEk3SVoh6UkzaEp6k6TryuV7knZt2XerpOslXSvpmmZLHhExNkuVlmlgne0HR1bKKVI8Svon6Jsal6RB4FRgf+A24GpJS23/tCXZLcArbN8r6UBgCfCSlv372P5tY4WOiKiq4dHh+9xySRcCg5LeD/w18MOqmfvpr7g7sML2SttrgC8DTxhm3/b3bN9bri4DntZwGSMiJm5wsNqy4duLYtblu4B3AZcAL6+auW9qXMA2wK9b1m/jibWpdm8HvtGybuCiciKzf7e9pFMmSYuBxQBbDMysVeCIiOqmTTNgFZsCb7e9FkDSzHLbPVUy91Pg6vQv2rHNU9I+FIHrZS2bX2p7laQtgIsl3Wj78icdsAhoSwCeM2+e5207d8IFnrnR7AnnBZi5YF6t/ACat6BW/rVznlIr//3r6p3/plUT//s/doyb7qt9jG4GZgwyf4t6/06zFlS+59y5DPPq5V+36Za18t8776m18gP84v56jSPX/azeV9X1195VK39PiDQVPm4l8EyKWhcUQetmoNIXUj/9FW8Dtm1Zfxqwqj2RpOcD/wEcavux6Gx7Vfl6F3AuRdNjRETfsAYqLdPADNsjQYvyfeUmsH76C10N7Chpe0mzgMOBpa0JJD0d+ArwFts/b9k+T9KCkffAq4AbGit5RMSYypEzqiwbvrWS/nRkRdKbgKGqmfumqdD2kKSjgQuBQeAM28slHVnuPx34MLAZ8G8q/nGHbP8hsCVwbrltBvBF29+chI8REdHVNKlNVfEu4CxJp5Xrc4E/r5q5bwIXgO0LgAvatp3e8v4dwDs65FsJ7Nq+PSKib0gwMC16DI7J9lmSzgFeTdHy9w3bD1fN31eBKyJiQ2VIr8InegvwfIp7W6+WhO2/qJIxgSsioilpKgRA0kqKIZ9+BawrN1ceOSN/xYiIhhhVWnpB0g6SVkmypCFJp4yR/jxJ68r0Px/p8FbuO0fSg+W+FaMc41tlmveNUbxtgI1t72J713LZrepnS+CKiGiEmu4OfxlFT72tKDpDHCXpkI4lkz4AHAwcBmwPbAFc1JLkFuBkRhnBvXy+di9guELZ7qJoJpyQCf2FJB1SRuAvSzp07BwREdOcwAODlZbap5IWAU8H3mH7TtunUQSfY7tkWQwss73U9q3ACbQ8C2v7/baPBe7tkh/gHIppSqo0+c0Hfizpt5LuGFkq5AMmfo/rj22/AaDsznj+BI8TETEtuKxxVTRL0oMt61+x/ZZxnG5fANuttablwIu7pN8SOK9lfSlwkqRn2u7aNDhC0qcoHk/6qKQPVyjfRyqk6WqigWtu+TAwQP1xiyIipoPqvQrX2K7z3boZT26yuxeY0yX9DMq5sUoj48ZuBYwauCRtSdEUuW/Vwtk+WdJeFEP1nSRpM2BW1fwTbUw9nqKg7wI+OsFjRERMK726xyVpddkJotNyH8Vgte0HWgg80uWQQxS9/EZsU75Wab77OvBd29+tkHak/O0zIL+ABmZA3tL2+8oC7MEYETkiInrXY9D2wlHPVNzjQtJ+ti8pN+9McZ+rkzt5YjPiIcBwlWbC8rizJY10ax8APilpH9sHdckzKTMgH9byvmMvlYiIeKKmehXavpviGanPSVpUDp23A/DxLlk+C+wp6WBJ2wHHAVeN7JQ0W9LGFMPxDUjauJy1GOB5FCMX7VYu64DPMPoQTpMyA/KWkv6gPFH9OQ8iIjZ0ElajQz7tA1xJ0fV8HXCq7aVFUbQH8H1gT9vLbJ8oaXeKDhoDFK1or2o51oXAK1rWVwPfAfZur5WVY8be0Tr6ewe1ZkCeaOA6DjiqfF+rd0hExHTQ9JBP5RiuW3fZt4y2ORBtd320yfbe4zhvlbiyB3AWT5wB+Yiq55ho4DoM2NT2OyV9CPjYBI8TETFtZHR4kDQIPGi7Ww/HMU30r/gHPN5dst4UuBER00STQz71K9vrgNvL5soJmWiNyxTPcu1C7nFFRFQwrgeQN3QbA9+XdC+wZmSj7a2qZJ5o4PoU8FcUw9J/YILHiIiYVjKtyWOOr5N53IFLRZeR19g+ps6JIyKmE0sMN9ursG/VHTlj3IHLtiW9WNIbgfvKbReMkS0iYtrb0O9fVVWOnPFaimB1EsXIGecAm1bJP9EG10vKEy7iicOE1CLpAEk3SVoh6Uk1OhVOLvdfJ+mFVfNGREy2hqc16Wevp5g6ZS0UI2cAlUfOGLPGVT5FfRRFT8LfAdcCX7X9y/GXddTzDAKnAvsDtwFXS1pq+6ctyQ4EdiyXlwCnAS+pmDciYlKlxvWYdbYfLB9WHvfIGVVC+/nAjTweGHYFLpd0asuQH72wO7DC9krba4AvA+0PxB0KfN6FZcBCSVtXzBsRMWnc/ESS/ax95IxbGMfIGVX+QoO2P2f7UuB3tt9JUfu6FVgygQJ3sw2PPxsGRc1pm4ppquQFQNJiSddIumb10FDtQkdEVDWsgUrLNLAXxcC+rSNnvLxq5iqdMy6RdLTtUyircraHKCYZ+/n4y9tVpzp0e9WxW5oqeYuN9hLKgPvc+fM8OHPiF8nsBRN+8BuAGfMrN+l2t9H8WtnXDcyslf+eR+o9f76uyiTfY1h9z4NjJ5ogDcDgrIk+NVIeY0a9nmQD8+v9jR+Zu7BW/oeH61+nv3uw3nV2+x0P1cq/6he/qZW/V+zp3VQo6Xe2NwWutL1eH0D+W+BYSdcAT5W0GHgI2JNizpdeuQ3YtmX9acCqimlmVcgbETGJhCfcH26DMU/S/wFeIOlw2lr9bH+xykHGDFy2h4ETJX0G2I9i2PpNgBuAD46z0KO5GthR0vbAb4DDgT9tS7MUOFrSlyk6Z9xn+3ZJd1fIGxExaUw6ZwD/CnyIorJxWts+A70JXI8d0X6IInAsrZpnPGwPSTqaYvj8QeAM28vLeWSwfTpwAXAQxZD7D1HO99It7/ooZ0TERCVwscL2IkmX2t53ogep13jfY+WDzBe0bTu95b15fDqVMfNGRPSTBC4+BZxOcatpwioHLkmvB75p+35JxwEvBE6w/aM6BYiImB7EsKf9Pa5hSTcDsyVd277T9m5VDjKev+KHyqD1MuDVFJOAtbdRRkREByP3uKb5tCYvomgZM3BVh6WS8TQVritf/wg4zfb5ko4fR/6IiGltAw9KY7L9c+CvJV1h+78mepzx1Lh+I+nfgTcAF5SjZkz7em9ERFXTvcYl6evl2+MkXdu+VD3OeGpcbwAOAP7J9upyqKX3jSN/RMQ0pmn/ADKPD+v0gzoHGVd3eEm/AF4t6dXAd21fVOfkERHThYHhDbg2VYXtD5evi+scZzy9Cv8aeCfwlXLT/5W0xPa/1ilARMS0YKZ9r0JJd4y23/ZWVY4znqbCtwMvsf1gWYBPAt+neBI6IiLGsCHfv6roH8rXPwc2A84s1/+MYtSjSsYT/sXjPQsp30/7f4WIiGqKe1xVlp6cTdpB0ipJljQk6ZQx0p8naV2Z/ueSFrTsO0fSg+W+FR3ybibpBknDZZrVnc5h+2TbJwPb23667Q+Xy3bAzlU/23gC138CP5B0fNkNfhlwxjjyR0RMW5PwHNdlwBCwFcXUIUdJOqRTQkkfAA4GDgO2p5iduLUPwy3AyUC3ofSuBhYAO1GMQ9hxhKMWcyW9ouX8LwfmjpHnMePpnPFpSd8GXkZR0/pz2z+umj8iYrprqlehpEXA04FX274TOE3S+4Bj6Tze7GJgme2lZf4TgE+O7LT9/nL7y4Ct2851AEWwe5rtkea+L4xRxI8Cl0p6oFyfDxxX9fNVrnFJOgtYWVb1/gW4VVJqXBERFa2zKi3ArLJpbmQ5e5yn2hegref3cooA08mWFLWmEUuBAUnPrHCuw4BHga+WTYWPSDpptAy2T6SYZeSd5bKJ7U9UOBcwvs4Zz7e9uuXE90p6wTjyR0RMW+NsBlxje16N020GtE/Tei/QbfbbGcDdLesjM8pvRTEbx2i2A2YDv6doLnw78C+Svm37690y2b4fmNDoGeO5xzUgaZORFUmb0mejy0dE9LNedc6QtLrsBNFpuY9ikt/27/eFwCNdDjkEbN6yvk35Omr39dLD5eurbT9Ydr64E3hbhbwTMp7A8ynge5L+m+I+4xuAE9dLqSIiNkC96nhhe+Fo+8t7XEjaz/Yl5eadKTpZdHIn8OKW9UOAYdtj1bYArgAOrZCuZyrXuGx/HngtxQe8G/jftsfb7hoRMT0ZhisutU9l3w38CvicpEXlhLw7AB/vkuWzwJ6SDpa0HUVHicdGa5c0W9LGFBP1DkjauByvFuBUYC3w9TLdkRT3zP6j/ifpbFxNfbZ/Cvx0PZUlImKDNdIdvkH7AFcCd1E8d3tqS6/BPSgGkNjT9jLbJ0raHTiPokKzAnhVy7EuBF7Rsr4a+A6wt+2HJb2OoifhI8Aa4JO2vzGewkp6yPZGVdLmHlVEREOGh5sLXLZX0tZ1vWXfMtoGkLDdtbnP9t5jnGspRceMCasatKBPpiWRtKmkiyXdXL5u0iHNtpIuk/QzScvLsRNH9h0v6Tctw+Mf1OwniIgYixiuuMTo+iJwAccAl9reEbi0XG83BLzH9nOBPSieAt+pZf9nbO9WLhes/yJHRFRnetercKoapSekJVW+u9cvgetQ4Kzy/VnAa9oT2L7d9o/K9/cDP+PxLpsREX3PrrZsqGxrtKXqcfolcG1p+3YoAhTFOFldlb1eXsATJyM7WtJ1ks7o1NQYETHZpvsMyK0k/aWkz5Xvn1WOV1hJY4FL0iXl6MHty7j6/0uaD/wP8G7bvy83nwb8AbAbcDvFM2fd8i+WdI2ka1avHZrYh4mIGK8Gu8P3O0nfAj4CvKXcNA/oOspGu8Z6Fdrer9s+SXdK2tr27ZK2pui+2SndTIqg9QXbIxNaUg4iOZLms8DXRinHEmAJwHPnz/fA4MR/3Wig5i8j1f/dMDynzqgw8OjMevl5tF72+36/buxEYxXhoZqFGIUGBpi9oNsoOdXMmDt77ESjmVN50OyOhmfMqpV/ret/TTzwcL3/K0Nr20cvGp9HHnioVv5eMM32KuxzewIbAQ8C2P5x+f1eSb80FS4FjijfHwGc355AkoDPAT+z/em2fa1dPg8DblhP5YyImLD0KnzMOvvxu3kjI31U1S+B6xPA/pJuBvYv15H0VEkjPQRfSlGtfGWHbu//KOl6SddRPHT3Nw2XPyJiTNO9c0aLyyT9FJgp6fPASkZpKWvXFw8g276Hchj+tu2rgIPK91fQZcZl22/ptD0iol+YDbure1Vl69nHKCoZrwWeC5xg+5OjZmzRF4ErImKDN006XozFtiVdVk7bUjlYteqXpsKIiA3esFVpmQZWSjpi7GSdJXBFRDTApDt8i2cBZ0paK+nhctbkh8fMVUpTYUREQ6ZJx4sq9qmTOYErIqIhCVwF29+rkz+BKyKiATbT5f7VepfAFRHRkNS4eiOBKyKiIevqjVwVpQSuiIgGjMzHFfUlcEVENGH6DOe03iVwRUQ0ZJo8o7XeJXBFRDSgaCqc7FJsGBK4IiIaks4ZvZHAFRHRhNzj6pmMVRgR0YBiBuRqSy9I2kHSKkmWNCTplDHSnydpXZn+55IWtOw7R9KD5b4VHfJ+RtKj5f5HJX28N5+iswSuiIiGNDyR5GXAELAV8C7gKEmHdEoo6QPAwRQzyG8PbAFc1JLkFuBkYHmHvC8C3g2cQBFTPg4cI2mnXn2QdglcERENaSpwSVoEPB14h+07bZ9GEXyO7ZJlMbDM9lLbt1IEod0fL7ffb/tY4N4OeXctkvhjLhxPUcF8af1P0lkCV0REA1xxSpOyy/yssmluZDl7nKfbtzinW2tNyylqU51sCVzdsr4UGJD0zArnOhv4vaQTJM0smwmHgfPGWebK0jkjIqIhw9Uf5FpTzhA8UZtRBI9W9wJzuqSfAdzdsv7r8nUr4En3tFrZXivpXOCD5QLw97bvHiVbLX1R45K0qaSLJd1cvm7SJd2tkq6XdK2ka8abPyJiMvWqc4ak1WVHiE7LfcA9PPn7fSHwSJdDDgGbt6xvU77eUaEs7wOOAP6MIgC+FfiQpD8Z+5NMTF8ELuAY4FLbOwKXluvd7GN7N9t/OMH8ERGNq3p/q8o9LtsLbavLsjHF9yCS9mvJtjPFfa5O7gRe3LJ+CDBse9TaVul/AXfYPtv2OttnAXcBb66Qd0L6JXAdCpxVvj8LeE3D+SMi1rtx3OOqpWym+xXwOUmLJB0J7EDR46+TzwJ7SjpY0nbAccBVIzslzZa0MTBIce9rY0mzy90XA1uN1LAkHU5xz+zK+p+ks34JXFvavh2gfN2iSzoDF0n6oaTFE8iPpMWSrpF0zeqhtT0qfkTE2BruDr8PMIui9nMKcKrtpQCS9iibFfcoyuUTga9RdKi4haKp8VUtx7oQWA3sSdHBY3W5DdsnA/8NnC3JFJ01vmb7Ez37JG0a65wh6RKKG33tPthhWzcvtb1K0hbAxZJutH35eMphewmwBOA5G83zmgcnHryGHqkZ+Fz/SUMNramVf1iDtfKvG67322doqP7/0oHB9ff7y8Nm7cM1/8ZD6+oVYmioVvaBmtdIL6bieLReEVizpt7f0L16qrcmNzjKru2VwNZd9i0D1Lbt0FGOtfcY53rDBIo4YY0FLtv7ddsn6U5JW9u+XdLWFL8QOh1jVfl6V9mLZXfgcqBS/oiIyWJnrMJe6ZemwqUUvVIoX89vTyBp3sgQJJLmUVRjb6iaPyJisg0Pu9ISo+uXwPUJYH9JNwP7l+tIeqqkC8o0WwJXSPoJxU3Dr9v+5mj5IyL6xci0Jg3e49pg9cUDyLbvoXzSu237KuCg8v1KiqFFKuePiOgbCUo90xeBKyJiw2eGE7l6IoErIqIBBobXJXD1QgJXREQT3Lu5tqa7BK6IiIY4TYU9kcAVEdEA05vhnCKBKyKiGW525IwNWQJXRERD0lLYGwlcERENsM26jPnUEwlcEREN6cG42kECV0REY/IAcm8kcEVENCTd4XsjgSsiogE2Gfm9RxK4IiIakgpXbyRwRUQ0IL0KeyeBKyKiIXkAuTcSuCIiGpLA1RsJXBERTXDGKuyVBK6IiAaY1Lh6ZWCyCwAgaVNJF0u6uXzdpEOaZ0u6tmX5vaR3l/uOl/Sbln0HNf4hIiJGU3bOqLL0gqQdJK2SZElDkk4ZI/15ktaV6X8uaUG5fYGkm8pjWNJDkj7Ulve9kh4t998raa+efIgu+iJwAccAl9reEbi0XH8C2zfZ3s32bsCLgIeAc1uSfGZkv+0Lmih0RMR42K609MhlwBCwFfAu4ChJh3RKKOkDwMHAYcD2wBbAReXuOcDtwN4UrXQnAR+V9LIy77PKbacAC4GbgQt79SE66ZfAdShwVvn+LOA1Y6TfF/iF7V+uz0JFRPTKSFNhlaUuSYuApwPvsH2n7dOAW4Bju2RZDCyzvdT2rcAJwO4Atu+2vbftK2yvs/0R4BGK722ADwH3236P7fuAPwLmSzqw9gfpol8C15a2bwcoX7cYI/3hwJfath0t6TpJZ3RqahwhabGkayRds3poqF6pIyKq8rgC1yxJD7YsZ4/zbPsC2L6oZdtyitpUJ1sCV7esLwUGJD2zPaGknSlqYd8qN+0C/Oqxj2nfDTwKvHKcZa6ssc4Zki6hqLK2++A4jzMLOIQn/nI4DfgYxY+ajwGfAt7WKb/tJcASgOfM3cjr1k68PXno0XqBrye/rIbX1co/4Hr51w2rVn714KfTA6vvr3+QLjQgZsyu999kxvx59QpRc0jxgeG1tfLPGXi0Vn6AHbaqV4aVt8ysXYbJ5/EMsrvGdp0LZzOg/cK5lyLgdDIDuLtl/dfl61bAipGNkuYClwM/s/2NcvNGwO/ajrcG6FqBqKuxwGV7v277JN0paWvbt0vaGrhrlEMdCPzI9p0tx37svaTPAl/rRZkjInqpV70KJa0GNu6y+/fAX/DkFrWFFE18nQwBm7esb1O+3tFyzkHgRmAdRT+DEQ8BC9qON4siUK4X/dJUuBQ4onx/BHD+KGnfSFszYRnsRhwG3NDT0kVE1GTTs16FthfaVpdlY4pObkhqrTDsTHGfq5M7gRe3rB8CDNteUR5HFEHrKcCzbT/ckvYGivtplGkXAbN5vCmx5/olcH0C2F/SzcD+5TqSnirpsR6CkjYq93+lLf8/Srpe0nXAPsDfNFPsiIjqmuqcUd5n+hXwOUmLJB0J7AB8vEuWzwJ7SjpY0nbAccBVLftvoGg2fI7t9prUicACSSdJ2hj4KvBAS1Niz/XFA8i276G8mdi2fRVwUMv6QxRtt+3p3rJeCxgRUVtPu7pXsQ9wJcWtl3XAqbaXAkjaA/g+sKftZbZPlLQ7cB5FhWYF8Koy7V7ATuUx7ygqXwD8m+2jbN8o6e8oeiK+F7iP4pbOetMXgSsiYkNng4ebGx3e9kpg6y77lgFq23Zol7Tfa0/bIc1JFM9yNSKBKyKiIZlIsjcSuCIiGtJwU+EGK4ErIqIBthkeykSSvZDAFRHRkOGaD5NHIYErIqIJzrQmvZLAFRHRANObZ7QigSsiojHpnNEbCVwREU0wrBuqN6h1FBK4IiIaYIzTOaMnErgiIpqQzhk9k8AVEdGQBK7eSOCKiGiE8xxXjyRwRUQ0wGkq7JkEroiIJhiG06uwJxK4IiIakV6FvZLAFRHRAJNpTXolgSsiogkNTyS5IRuY7AIASHq9pOWShiX94SjpDpB0k6QVko5p2b6ppIsl3Vy+btJMySMiqirGKqyyxOj6InABNwD/G7i8WwJJg8CpwIHATsAbJe1U7j4GuNT2jsCl5XpERF+xhystMbq+aCq0/TMASaMl2x1YYXtlmfbLwKHAT8vXvct0ZwHfBt6/fkobETF+xUSS6VXYC+qn0YolfRt4r+1rOux7HXCA7XeU628BXmL7aEmrbS9sSXuv7Y7NhZIWA4vL1WcDN/XwI2wO/LaHx+ullK27Z9he1GmHpLuBX/bwXJP9WUfTz2WDyS9f1+ukivJa2qhi8ofqnGtD11iNS9IlwFYddn3Q9vlVDtFh27ijru0lwJLx5qtC0jW2u96jm0wp28T0+sujnz9rP5cN+r98Y0kg6p3GApft/Woe4jZg25b1pwGryvd3Stra9u2StgbuqnmuiIjoU/3SOaOKq4EdJW0vaRZwOLC03LcUOKJ8fwRQpQYXERFTUF8ELkmHSboN2BP4uqQLy+1PlXQBgO0h4GjgQuBnwDm2l5eH+ASwv6Sbgf3L9cmwXpogeyRl6w/9/Fn7uWzQ/+WLhvRV54yIiIix9EWNKyIioqoEroiImFISuHpA0t+UQ1bdIOlLkuZMcnnOkHSXpBvatr+rHDJruaR/nKSyzZF0laSflOX4+3L7SZJulHSdpHMlLZyM8q1P/XSd5BqJqSyBqyZJ2wD/B/hD27sAgxQ9HifTmcABrRsk7UMxwsjzbe8M/NMklAvgUeCVtncFdgMOkLQHcDGwi+3nAz8Hjp2k8q0XfXidnEmukZiiErh6YwYwV9IMiifjV42Rfr2yfTnwu7bNfwl8wvajZZpJedbNhQfK1ZnlYtsXlT1HAZZRPKe3oemb6yTXSExlCVw12f4NxS/TXwG3A/fZvmhyS9XRs4CXS/qBpO9IevFkFUTSoKRrKR4Uv9j2D9qSvA34RuMFW4+myHWSaySmhASumsopVA4FtgeeCsyT9ObJLVVHM4BNgD2A9wHnaIxRjdcX2+ts70bxi3l3SbuM7JP0QWAI+MJklG19mSLXSa6RmBISuOrbD7jF9t221wJfAfaa5DJ1chvwlbIZ5ipgmGLQ0kljezXFSP4HAEg6Avhj4E3e8B4wnArXSa6RmBISuOr7FbCHpI3KX6f7Uozs0W/OA14JIOlZwCwmYaRtSYtGeoNJmkvxhX6jpAMopqI5xPZDTZerAVPhOjmPXCMxBfTFfFxTme0fSPpv4EcUzRc/ZpKHppH0JYr5yTYvh9L6CHAGcEbZ/XkNcMQk/WLdGjhLxcSgAxRDd31N0gpgNnBx2Tq1zPaRk1C+9aLfrpNcIzGVZciniIiYUtJUGBERU0oCV0RETCkJXBERMaUkcEVExJSSwBUREVNKAldEREwpCVwRETGlJHD1MUl/Iel2Sde2LM/r4fHnloOpDpbrW0r6oqSVkn4o6fuSDhvjGN+W9Oq2be+W9G+SZkm6vBwNPdaDXCMxHSVw9bfnA8fZ3q1lub6Hx38bxdh068phiM4DLre9g+0XUcwXNdbUEV/iyfNKHQ58yfYa4FLgT3pY5niiXCMx7SRw9bfnAdeux+O/CTi/fP9KYI3t00d22v6l7X8dWZf05nJm2msl/Xv5K/y/gT+WNLtMsx3F6OdXlNnOK88T60eukZh2Erj6287Af7Y0AS3u1YElzQJ2sH1ry7l+NEr651L8Kn5pOd3EOooRuu8BruLx2XQPB/5fyxh3NwCTNq/TNJBrJKadtCv3KUnbAneV05R32j9ge7jGKTYHVo9y/lOBl1H8wn4xxWjmLwKuLgc4nUsxyR883hR0fvn6tpHjlE1MayQtsH1/jfJGm1wjMV0lcPWv5wM3tm+U9FaKaR6ukXQu8B5AwC+Ac4ETKL4szgXuAI4HHgG+avv8lkM9DMxpWV8OvHZkxfZRkjYHrhk5NXCW7WM7lPU84NOSXgjMtd3+q3x2WYborVwjMS2lqbB/PY8OX0qlb9j+Z+CvKL5c7inTHwV81PZ7bF8BHAl8yPY7gCfMtmv7XmBQ0sgX07eAOZL+siXZRi3vLwVeJ2kLAEmbSnpGeawHKCb7O4Pil/VjJG0GjEyeGL2VaySmpQSu/vU84C0t9y5+LGl+ue++8nUA+ILt422/neIXb2vTkICR+wid5q+5iKKph/J+w2uAV0i6RdJVwFkUE/dh+6fAccBFkq4DLqaYN2nEl4BdgS+3nWMf4IJxffKoKtdITEuZj2uKKZuBfltOrPcM4B+A24H7gc9TNPvcDiylmL32Q8BDwDdtn9t2rBcAf2v7LeuxvF8BjrV90/o6RzxRrpHY0CVwTXOS3kZxX2Ldejj2LOBw25/v9bGjOblGot8kcEVExJSSe1wRETGlJHBFRMSUksAVERFTSgJXRERMKQlcERExpSRwRUTElJLAFRERU8r/B8C6VtvCKsrAAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAAEyCAYAAACmpOSfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAA4NUlEQVR4nO3deZxkVX338c+3e2aYBRCBYcBBZRA0ggKKbC4xCCiSAOIKEcUt85AIUWN8RINLVKLGqHlUAmIkIBENSQTGiMoiiqADDIvIoMKERXBgwGGRfaa7v88f9zZT1FR33+pbXV09/X2/XvdVde8959Spmpr69Tn33HNkm4iIiF7XN9kViIiIqCIBKyIipoQErIiImBISsCIiYkpIwIqIiCkhASsiIqaEBKyIiJgSErAiImJKSMCKKU3SsyV9QdLVku6VtLZ8vFzSP0navUWefkl/IeknDXnulnSdpH+VdEiLPB5je9s46v5ZSRdJul3So2VdrpH0MUlbjPMjqfK6r5f0ZUk/lfSHsv7/PlGvF9EpykwXMRVJEvDRcusDrgauAO4FNgF2AfYBZgHH2D6xzNcP/A9wIHA/8D3gDmBz4Fllnqttv7Tp9Yb/o/z9CFU6x/a1bb6HNWW9bwDuBuYBewMvAlYCe9u+vZ0yK77utcCuwEMU7/2PgG/aPrLTrxXRSTMmuwIR4/RR4OPA7cARti9rTiBpK+C9wFMaDh9BEax+Abzc9gNNeeYCe430orY/XrPejTa1/VjzQUknAB8GPgT81ViFlK27fwP2tf3jCq/7PopAtQJ4OXBx9SpHTJ4ErJhyJG0PHA+sAV5te3mrdLbvBj4sqfF7/uLy8bTmYFXmeYQu/YC3ClalsygC1o4T9LpPvL+ioTo2SRsDfwMcBuwAbDxC0gXl5x7RcQlYMRW9neK7e+ZIwaqR7YGG3dXl47MnomIdcnD5eN2k1qJUtlR/QtF1eB1wMrAR8AZga2At8Fvg9wlWMZESsGIqekn5+KNx5P0O8EHgaEmbAGcDV9m+rUpmSR9vcfhW26eNoy7DZf4tRYvlKRTXr15KERg+M94yO+xMimD1j8BxLi98S/occBPQT3G97feTV8WYDhKwYiraunz8XfMJSdsBb2s6fL/tfwawfY2kI4H/BxxZbki6F7gEONX2d0d57Y+1OPYT4LTKtV/f3wILGvZ/ALzN9j01yuwISQcA+wGXAR9ywygt27dL+imwP7AbcOGkVDKmjQSsmIqGL7y0GuK6HesHlduAfx7esX2WpLOBfSlaMy8oH18DvEbSNygCxnrl26520acNtrcGkLSA4hrbZ4BrJP2Z7asb00q6FXjmCEVd3OKa1Om231ajesMjB79oe6jF+eHrgLlFJiZcAlZMRXdSdFEtbD5RjpITQDnYYm2rAmyvBc4vt+Hh7q8DTgXeStFVeE7Haz4K26uAsyVdDdwIfAN4XlOyfwY2azq2G3AocDpwa9O5a2tW62XAEEWrr5Vty8cVNV8nYkwJWDEVXUbROtqPIsDUZnsQOEvS8ylGIL6CLgeshrrcJukGYDdJWzZeGxru2mxUDms/lGLk4487VQ9JfRStubttP9zi/AJgD+AW2zd36nUjRpJmfExFpwEDwOslPbfDZT9YPna8669NTysfByexDsNdopuUwavZ/6X4Dflq96oU01kCVkw5tv8X+BTFLBbfl/TiEZJu1nxA0hGSDmj1Ayxpa+Avyt1LOlTdliT9Ufl6zcf7yhuHtwJ+Zvu+iazHaMpreL+gmIHjiMZzkl5PcVP2rykGsERMuHQJxlT1CYpW0EeAyyRdxbqpmTajGHyxf5m2MfjsBbwHuEvSpcAt5fFFwJ8Cc4Bzgf+a2OpzIPA5SZcA/0txf9gCipkntgfuYl3w7ChJr6EYYALrRlzuI+m08vnvbf9t+fwTFLcC/JukAylmFtmD4rO9CTholBugIzoqcwnGlCbpOcDRFNe0tqNoDTxIEQQuBc5oHGkn6enAIRQ/uDsB2wCzKQLGNRT3HJ3ZPCJueC7BTo0SlPQ84C8p7inbliLIPkwx2OJ7wJds31uxrLfRxtRM5b1krYbnD7vN9nYN6Q+luHdtV4o/Em6kmI3jS7YfqlLHiE5IwIqIiCkh17AiImJKSMCKiIgpIYMuIjpA0mYUo+aqOM32rRNWmYgNle1sXdgoRnxdW25DDc+/MEqebYE3VSh7f4rBBWOlGyxf83rgP4G55fGHWqRZTjGk+W+AvhHK+5NWr0sxvdDft/HZHAj8hmK2hOMm+99qnP++21Hct1Rl+5N8R9r+jpxKscjl9ZP9b51t8rYMuugySQsp7q8ZaT64xrRHATvZ/uAY6d5PMYDmn8ZI95Dtjcvn36SYpfwLTccbn29FMWruMtvrjSqT9F6KH6ovjPVeRqlTP8WoswMoFhW8kmJBxhvGW+ZUl+9Iy3r9McUKyd+w3TxdVUwTuYbVfc8Dftl4oLyJ9BJJyyVdKGlLSS8FvkAxm8O1khZJer2kpZJ+IelSSfPLInal/TnjfkqxEN+IXKxttBg4Rq1X+tsVWCjpckk3S/qT8v38Z1l/JJ0t6VOSfirpLkn7N5WxJ7DC9s221wDfpphmaDrLd2T917mE4h67mMYSsLrv+RTdLQBI2gj4b+A9tncGLgDeZ/tSitbGobZ3s30LcLHtvW3vWqZ7Y1nMrhRdM5WUk8K+mqYfxVZczBHXRzHzQrPdgAdt70VxL9Qny+ONP7jPo1je42UUy72/uamMhRQ3ow67gxaT2k4z+Y5EtJCA1X3Nfz2/BrjU9jXl/g2s+4//HIprO8PeJukKSb+g+I/9mKSZwKautnbSHEnXAssoVoj9esU6r/eXc/mDtgXwD+Wha4EtJc0GZtp+QNJcikUJv1immQHcP1bZtF42ZDrJdySihYwS7L7ns+4/JxSzLfyy6fwNkrYAHnCxDAaS3krRffYK2w+VU/osL/P/quJrP2p7t3YqK2l7iovszUuf70TRlbem3H8hxV/wO1P8oFI+v8rFTOgAu9DQcijdATy9YX9bYGU7ddwA5TsS0UJaWF1UTri6I8WEocN+R/Efe/g//lso1kFaxJN/uJ9PcSH+IUmvoxhl9Uuark1Iuqi8aN+J+s4HTga+4vVH5+wKLJK0kaSNKab6+eeynteVaZ7Hk6+b7NJwbtiVwI7l9ZdZwOHAkk7UfyrKd6TldyQCSAur23YA7rD9eMOxM4CDJP0SeBR4h+3Vkh6n6D65nuKi9unAuSpmyT4PuNn2w5J2pZj0dfjHbgfqXZwe7hKaSbGExxkUF/ab7Qp8E/gZxYSxn7S9VNIbgMvLNM9veA7Fj9OT/nq2PSDpGOCHQD/FEvXLa9R/qst3pEULS9K3KIbIbynpDuBjtqt2V8YGIsPaNyAqJlR9h+2/mey6RG/KdySmsgSsiIiYEnINKyIipoQErIiImBISsCIiYkpIwIqIiCkhASsiIqaEBKyIiJgSErAiImJK6JmAJelUSXeXd+23Oi9JX5K0QtJ1kl7YcO5ASb8pzx3XvVpHRES39EzAAk6jWHl2JK+mmGNtR4ppaE6CJxYAPLE8vxNwhKSdJrSmERHRdT0TsCos0HYoxWqjtr0U2EzSNmQBwIiIaWEqTX470kJ/rY7vNVIhkhZTtNDonzFn97mbbtfxilY1a6OZHSij3j/h7I1aLUdV3cz+elN79fcNjp1oDH0M1cq//Ppf/t72/FbnNpqzueduWm9i8xkz6/0bzZxZ7+/KWbPq/RvPqvlvDCDVK8Ou9x46MQHdil9dPeL3pIrd++b5D672fV/B47Vea0M1lQLWSAv9tbUAoO1TgFMANt1iJ+990Dc7U7tx2GbRNrXL2G6HLWrl/6Nn1fsKbLXp42MnGsXmsx+qlR9gXt8jtfI/Z4dn3jbSubmbLmS/w8+tVf6WT3tqrfxbbT2vVv5Fz5hVK/82T10zdqIxzJk5UCv/o2vrfU/rBjyAg144a8TvSRUPaogvb7yoUtpXP/jruXVea0M1lQLWSAv9zRrheERE7xCoZmt5uptKn94S4K3laMG9KVZavZMsABgRU4Ggb4YqbdFaz7SwWi3QRrFAHLZPpliQ7iBgBfAI8PbyXBYAjIjeJ9DMBKM6eiZg2T5ijPMG3j3CufMoAlpERE+S0nqqq2cCVkTEBi0trNoSsCIiukCC/o2m0rCB3pOAFRHRDYK+/rSw6kjAiojoCqG+BKw6ErAiIrpBoP50CdaRgBUR0QUiXYJ1JWBFRHSDSJdgTQlYERFdIIn+WekSrCMBKyKiS9SXgFVHPr2IiG4ouwSrbJWKk7aXtFKSJQ1I+sooac+RNFimvVHSJlXKkfTS8njjdmHD+R+3OP/ycX5CY0rAiojoCtHXX22r6GJgANgaOBZ4t6RD1ntV6cPAwcBhwCJgK+D8NsuZbVvltn/TuVsazsn2T6q+gXYlYEVEdIE62MKSNB94BvAu26tsnwTcAnyoRfLFwFLbS2zfCnyKYqX2dsuZdAlYERHdIOib0V9pA2ZJerhhO6OptP0AbDe2lJZTtKCaLaBYhmnYEqBP0g5tlPNI2V14k6RnN51bJGlI0mOSzqzyUYxXAlZERFe01SW4xva8hu0tTYVtAQw1HbsPmN3ihWcA9zTs314+bl2hnJuAtwJzgV2BOcDPGtJ+HnghsBHw18CbJH151I+hhgSsiIgu6GSXILCa9X+/NwMea5F2ANiyYX9h+XjXWOWU3YRn2H68XGfw1cAWkhaW579r+xrba22fQnFt7LVV3sB4JGBFRHSJ+voqbRVcBCCpcQDEzhTXn5qtAvZo2D8EGLK9os1yYF1rbKRKevRq15OAFRHRDR1sYdm+B/gt8HVJ8yUdDWwPfLpF8q8B+0g6WNJ2wPHAFVXKkfQOSQdK6i+veX0fuN/27eX5EyRtp8LbgFcB36vxKY0qNw5HRHRFx2dr3xe4DLgbGAROtL1E0t7Az4F9bC+1fYKkPYFzKBopK4BXjlVOee4FwFcpYsUQcCvwxw15j6QYUShgDXC27cWdfJONeipgSToQ+H9AP/Cvtj/TdP4DwJvL3RnAc4H5tu+VdCvwIMUHPmD7RV2reETEGFSOEuwU2zcD27Q4vpQigDQeO7Tdcspzx1LcmzVS3mdWrW8n9EzAktQPnAgcANwBXClpie0bhtPY/hzwuTL9wcD7bN/bUMy+tn/fxWpHRFSW2drr6aVrWHsCK2zfbHsN8G1gxL8KgCOAb3WlZhERdana9avM6D6yXgpYC1l3fwAUrayFrRJKmgscCPx3w2ED50u6StKIfaiSFktaJmnZ2sfv60C1IyKq6eAowWmpZ7oEaepzLY00RPJg4LKm7sCX2F4paSvgAkm/tn3JegUW9wqcArDxZs/xI/f/YdwVfsqCLcadF2D23Fm18gNsumm9f8LZM5vvGWzP5rMfqpX/qbp37ERjWHD7VbXLGIltBtYO1Cqjv2Y3UN38Dz9ab6Tx3X31v6dDrlfG7XfW+zf4/d2P1srfCcp6WLX1UsC6A3h6w/62wMoR0h5OU3eg7ZXl492SzqboYlwvYEVETA51dNDFdNRLbc8rgR0lLZI0iyIoLWlOJOkpwMuBcxuOzRueLl/SPIohm9d3pdYREVV0eHmR6ahnWli2ByQdA/yQYlj7qbaXlzeyYfvkMulhwPm2H27IvgA4WxIU7+lM2z/oXu0jIsaiXJ+qqWcCFoDt84Dzmo6d3LR/GnBa07GbKSZmjIjoXUrrqY6eClgRERuqDLqoLwErIqJL0iVYTwJWREQ3KKME60rAiojoknQJ1pOAFRHRBbmGVV8CVkREVwhyDauWBKyIiC5RhrXXkoAVEdENyijBuhKwIiK6QUIZJVhLAlZERJdk0EU9CVgREV0ghJQuwToSsCIiukFAWli1JGBFRHRJBl3Uk08vIqIbJNTfX2mrVpy2l7RSkiUNSPrKKGnPkTRYpr1xeP3AscqR9NLyeON2YcN5SVoqaajcLtcEjt1PwIqI6JIOL+B4MTAAbA0cC7xb0iHrvab0YeBgirUEFwFbAee3Wc5s2yq3/RuOnwG8kGKF9z2A3YB/r/oG2pWAFRHRLX191bYxSJoPPAN4l+1Vtk8CbgE+1CL5YmCp7SW2bwU+RRFg2i2nlUOA/7C9zPZVwJnlsQmRgBUR0QWSKm/ALEkPN2xnNBW3H4DtxpbScooWVLMFwJUN+0uAPkk7tFHOI2V34U2Snt1wfBOKFtqwHwEbj/pB1JBBFxER3VJ90MUa2/NGOb8FMNR07D5gdou0M4B7GvZvLx+3rlDOTcBbgbOAHYAfAj8DtmxIf2fzc0my7VHqPy491cKSdKCk30haIem4Fuf/RNIDkq4tt49WzRsRMdk6eA1rNev/fm8GPNYi7QBPDjALy8e7xiqn7CY8w/bjtpcDrwa2kLSwIf2C5ucTEaxoUdFJI6kfOJHiA9kJOELSTi2S/tT2buX2iTbzRkRMDgn6+6ttY7uoKFKNAyB2prj+1GwVxYCIYYcAQ7ZXtFkOrGuNDceOB4FXNJzfD3ioQv3HpWcCFsVFwBW2b7a9Bvg2cGgX8kZEdIXUV2kbi+17gN8CX5c0X9LRwPbAp1sk/xqwj6SDJW0HHA9cUaUcSe8oe6/6y2te3wfutz3crfhd4E2Sdpf0AuDPKa6RTYheClgLWde3CnAH65qujfaR9AtJ35e0c5t5kbRY0jJJywbWPNCJekdEjG14posqWzX7ArOAu4GvACfaXiJp7/J+qb0BbJ8A/A9wDkXLaTXwyrHKKc+9gCIoDQC/AdYCf9yQ90jgWopBHVcBvyiPTYheGnTR6l+puR/0auCZth+SdBDFP8COFfMWB+1TgFMANtn8uZ45p9U1ymo23XzTcecFeMpmc2rlB5g3p949ek+du6ZW/k37/1Ar/xa/v6lWfgDfVr+MkQuHgbUDtYrom1Hv78I5c+rN8F3za8oOW9b/w25Wf73v2V5Pr5d/o5aXdtrzpffWLUEdnenC9s3ANi2OL6XpN9H2iD1OI5VTnjuW4t6skfIa2KtilWvrpRbWHcDTG/a3BVY2JrD9B9sPlc/PA2ZK2rJK3oiISSdV26KlXgpYVwI7SlokaRZwOE19oZK2Hp72Q9KeFPVfXSVvRMSkEh27cXi66pkuQdsDko6hGOffD5xqe3l5ERDbJwOvB/5S0gDwKHB42SRtmXdS3khEREuqPE9gtNYzAQue6OY7r+nYyQ3Pv0JxUbBS3oiIniEg62HV0lMBKyJiw9XWCMBoIQErIqILBFlxuKYErIiIbsiKw7UlYEVEdIWgL4Mu6kjAiojolgxZryUBKyKiG6SMEqwpASsioltyDauWBKyIiG5JC6uWBKyIiG7JPIG1JGBFRHTD8AKOMW4JWBER3ZIuwVoSsCIiukHKsPaaErAiIrol17BqScCKiOiWdAnWkoAVEdEVWU24roT7iIgusMD9/ZW2DZmkF0v6QPn8qZK2qZo3ASsioivKqZmqbBsoSd8ALgD+oTy0O1B5dfgN95OJiOg1HQxYkraXtFKSJQ1Iarkae5n2HEmDZdobJW3SbjmSflSm+UDDsR+Xxxq3l49S7TcAWwFrAWxfCMyt9IbpsYAl6UBJv5G0QtJxLc6/WdJ15fYzSbs2nLtV0i8lXStpWXdrHhExNkuVtoouBgaArYFjgXdLOqQ5kaQPAwcDhwGLKALG+e2UI2lf4MXAUIt63GJbDdtPRqnzoO2HG8rdCPCY77TUMwFLUj9wIvBqYCfgCEk7NSW7BXi57V2ATwKnNJ3f1/Zutl804RWOiGiHOtclKGk+8AzgXbZX2T6J4vfxQy2SLwaW2l5i+1bgU8CebZZzFkU3XuXgMoLlkn4I9Ev6YPlaV1XN3DMBi+IDXGH7ZttrgG8DhzYmsP0z2/eVu0uBbbtcx4iI8evvr7bBLEkPN2xnNJW0H4DtxpbScooWVLMFwJUN+0uAPkk7VClH0ueBAdufGOFdLZI0JOkxSWeO8Qm8GFgF3E3RmrsQeNkYeZ7QS8PaFwK3N+zfAew1Svp3At9v2DdwviQDX7Xd3PoCQNJiir842Gju1rUqHBFRXVvdfWtszxvl/Bas3z13HzC7RdoZwD0N+8O/s1uPVY6kBRSBZb8R6vF54H3A9cDbgZMkrbZ97AjpNwfeaXttWf7M8tjqEdKv90Z6Rat/yZbNz7I/9Z3ASxsOv8T2SklbARdI+rXtS9YrsAhkpwA8ZcudPWfjytf71jNr9qxx5wWYM7f+xz9vTs38Mx+vlX+Tx+6tlX/Giutq5Qe49+rKg4za1tffx7ynjPa7MbZ58+p9T+bOqXfvzpabrK2Xf+bva+UHWLDqF7Xy+7orx040ijt/Wu/1O0J0cgTgatbvIdsMeKxF2gFgy4b9heXjXRS9VKOV8z3gp7Z/2qoStr/bsHuKpMOA11IEuVZuBnagaGVBEaxuAjYdIf2T9FKX4B3A0xv2twVWNieStAvwr8Chtp+IyrZXlo93A2dT9tFGRPQKq6/SVsFFAJL2bzi2M8U1oWargD0a9g8BhmyvqFDOzsC+5QjDQaAf+Kyk80Z6i2PUe4bt4WBF+XzmGHme0EsB60pgR0mLJM0CDqfoa32CpGcA3wHeYvvGhuPzhodpSpoHvJKiiRoR0SPKmS6qbGOwfQ/wW+DrkuZLOhrYHvh0i+RfA/aRdLCk7YDjgSsqlvN8YFdgt3IbBL5I0f2HpBMkbafC24BXUbTKRrJW0p8/8YlIb6ZoAVbSM12CtgckHQP8kCKKn2p7efkBYvtk4KMUfa7/ouIfdaAcEbgAOLs8NgM40/YPJuFtRESMqGLrqap9gcsoBjAMAifaXiJpb+DnwD62l9o+QdKewDkUjZQVFH/Uj1oOQNkKe0L5G3tXQyvpSIoRhQLWAGfbXjxKnY8FTpd0Urk/hzL4VdEzAQvA9nnAeU3HTm54/i7gXS3y3UzxV0BERG+SoK9z0y6Vv3vrTWtkeylNYwJsH9qcbqxyRkg7o2n/mZUquy796ZLOomiJ9QHft/1o1fw9FbAiIjZUhnZGCW7I3gLsQnHt6lWSsP1/qmRMwIqI6JYNeJ7AKiTdTDFi8bcU3Y/Qxs3ICVgREV3ilnfvTCsLgdm2xzVjxvQO9xERXaNODmufqu6m6A4cl3G1sMqJEY+kuEP6W7bPHW8FIiKmBYE7OOhiitoYuEbSvTQMZ7ddadqh8XYJ/pntNwKUwxMTsCIiRuGyhTXNfaxO5vEGrDnlTbwA9eatiYiYLqb5KEHbX5L0Yoqp9D4naQug8txl4w1YH2fdXFEjzeAbERENpnsLq1xx+HUUQepzwAsoli7ZvEr+8QasBbY/UFZgb4o7pyMiYkTKKMFixeEtKWePt32hpAlfcfiwhufrrXAZERHryyjBeisOj7uFJelZ5Qs9bZxlRERMHxLWtB8l2Lzi8HtoY8Xh8Qas44F3l89rjfqIiJgOMjUTAHsDp/PkFYePqpp5vAHrMGBz238h6SPAJ8dZTkTEtLGBd/eNSlI/8LDtVqsiVzLeT+9ZrFtmeZPxvnhExHTicuDFWNuGyPYgcGc5UG9cxtvCMsW9WM8j17AiIirIjcPAU4CfS7qPYv0sYOJnuvg88FcU08R/eJxlRERMK7mGxcfrZG47YKlYcvI1to+r88IREdOJJYam+SjBrs90YduS9pB0BPBAeey8MbJFREx7G+r1qarqznQx3g7VC8sXnE9x13JHSDpQ0m8krZC0XgtOhS+V56+T9MKqeSMiJltuHOYNwFbAWihmugAqz3QxZgtL0nYU91w9C7gXuBb4ru3b2q/rqK/TD5wIHADcAVwpaYntGxqSvRrYsdz2Ak4C9qqYNyJiUk33FhblTBcqr+W1O9NFlVB+LvBr1gWEXYFLJJ1Yvlin7AmssH2z7TXAt4FDm9IcCnzDhaXAZpK2qZg3ImLSOAs4wvozXdxCGzNdVPlk+m1/3fZFwL22/4KitXUrcMo4KjyShay7twuKltLCimmq5AVA0mJJyyQtW/PYfbUrHRFR1ZD6Km1VSNpe0kpJljQg6SujpD1H0mCZ9kZJm7RbjqQflWk+0HBMkpZKGiq3y6VRh0K+GFjFk2e6eFmlN0y1QRcXSjrG9lcom262B4DPSbqx6gtV0OpNNjcVR0pTJW9x0D6FMtBuNv957p853pH9MGdevQbmvHn1RwxtPHuwVv5+1cs/98E7a+VnsN7rAzx01/21yxiJJGbU+I4A9PXV6waaN6de/o1nPV4r/5y1D9bKD9D/h3tr5f/Dbb+rlX/l1Str5e8Uu6NdghdTrNq7NfBa4F8knW97SWMiSR8GDqaYoeg6iss65wP7VC1H0r4UwWaoqQ5nAC+k6OUy8DPg34E3N9XhXtubA5fZHveNw1VC+d8AT5G0DHha2UI5UtKJwOrxvnALdwBPb9jfFmj+lo2UpkreiIhJJExfpW3MkqT5wDOAd9leZfskiu61D7VIvhhYanuJ7VuBT1EEmHbKOQv4B9ZvCBwC/IftZbavAs6k9Qoe8yT9NfACSYdL+vPGbcw3XBrzk7E9ZPsE4I8p3vjWwO7A9RSDIDrlSmBHSYskzQIOB5Y0pVkCvLVshu4NPGD7zop5IyImjWlraqZZkh5u2M5oKm4/ANvnNxxbDixq8dILKH4jhy0B+iTtUKUcSZ8HBmy3Wqx3E4oW2rAfARu3SPdl4CMUo8tPohgTMbyN2JXZrHJfh+1HKN7ohAQC2wOSjgF+CPQDp9peLuno8vzJwHnAQRQLRj4CvH20vBNRz4iI8WpjlOAa2/NGOb8F63fP3Qe0mlh2BuWCiaXh6/1bj1WOpAUU15r2G6UudzY/lyTbja2xFbbnS7rI9mhljape53yHlTcgn9d07OSG52bdsiZj5o2I6CUdHNa+mvV7yDYDHmuRdoAn3y87PCDtLorLJ6OV8z3gp7Z/OkpdFjQ/bwpWUEzndzLrrpuNS+Xxk5LeMDyyRNLxkr7TeONuRESMRgy5r9JWwUUAkvZvOLYzxfWnZquAPRr2DwGGbK+oUM7OwL7lCMNBih6sz0oabhw8CLyiIe9+wEMt6jAk6SZgI0nXNm9jv91COwP+P2L7QUkvBV5FsQjXSW3kj4iYttq8hjV6WfY9wG+Br0uaX1462R74dIvkXwP2kXRwORHE8cAVFct5PsW9t7uV2yDwRcrLMcB3gTdJ2l3SC4A/p/Vlo90pesBcvnbzVkk7XYLD44//FDjJ9rmSPt5G/oiIaa3DM13sC1xGcU/TIHCi7SXlgLSfA/vYXmr7BEl7AudQNFJWAK8cqxyAshX2hPIWq7tsryoPHQnswLpBHVeWx57E9o3AeyRdavs/x/uG2wlYv5P0VWB/iibhRox/LsKIiGmnkwHL9s3ANi2OL6Xp3lTbI878M1I5I6Sd0bRvimnyRiXpe7b/FDhe0t+1KHe3Kq/fTsB6I3Ag8E+27y+nRPrAGHkiIgIAdfrG4alkePqly+sU0tawdkn/C7xK0qsoRo6cP1a+iIgoLt4MTdPJb21/tHxcXKecygFL0nuAvwC+Ux76d0mn2P5ynQpEREwLpuoIwA2OpLtGO2976yrltNMl+E5gL9sPlxX4LMWFvQSsiIgKpvHyIv9QPr6d4mbl08r9twKVJ4psJ2CJdSMFKZ9P208/IqI90/calu0vAUj6hO3NGk59VNL9VctpJ2D9G3C5pLPL/dcAp7aRPyJi2hq+D2uamyPp5bZ/AiDpZcCcqpnbGXTxBUk/Bl5K0bJ6u+1r2qxsRMS0NV1bWA0+AVwkaXg2jI0pbmSupJ1BF6cD77F9dbn/VEmn2n5HO7WNiJiuBqd5wCpvYv4SxS1SAD+wXXnBtXa6BHexfX/DC99XTsURERFjqDrt0oauDFDjmu2inYDVJ+mptu8DkLR5m/kjIqa1dAnW007A+TzwM0n/RXH98I3ACRNSq4iIDVBaWPW0M+jiG5KWUUwlL+C1tm+YsJpFRGxIDEPNq0RFW9rq0isDVIJURESbMqy9NUmP2J5bJW2uQUVEdMnQUAJWs6rBCnpkeRBJm0u6QNJN5eNTW6R5uqSLJf1K0vJybsPhcx+X9LuGFSwP6u47iIgYixiquEVrPRGwgOOAi2zvSLFk83Et0gwA77f9XGBv4N2Sdmo4/0Xbu5XbeS3yR0RMGlOMEqyybWgkebStajm9ErAOBU4vn59OMe3Tk9i+c/im5XIc/6+Ahd2qYEREXXa1bUNjW6NtVcvplYC1wPadUAQmYKvREkvaDngBT14M7BhJ10k6tVWXYkTEZBu+eXisbUMm6S8lfb18/uxyPsFKuhawJF0o6foW24hLN49QzsbAfwPvtf2H8vBJwLOA3YA7Ke4ZGyn/YknLJC1b89i943szERHtKoe1V9k2VJJ+BHwMeEt5aB7wvar5uzZK0Pb+I52TtErSNrbvlLQNcPcI6WZSBKtv2h5eSBLbqxrSfA34n1HqcQpwCsBmWz3PfX3jj9nqq/eXUM3sAMyeOVQr/5z+x+pXooaB+x+oXcbjDz7egZq01tcn5my8Ua0yNtqo3t+Fs2fV+wWb2Tc4dqJRzBhcUys/AA/W+3ceXDNQK//Dt03u9xzKFYczSnAfYC7wMIDta8rf9Up6pUtwCXBU+fwo4NzmBJIEfB34le0vNJ3bpmH3MOD6CapnRMS4ZZQgg/a6q3SS5reTuVcC1meAAyTdBBxQ7iPpaZKGR/y9hKIZ+YoWw9f/UdIvJV0H7Au8r8v1j4gYUycHXUjaXtLKcqTdgKSvjJL2HEmDZdobJW1SpRxJB0t6WNJQua2WdHDD+R+3GPX38lGqfbGkG4CZkr4B3MwoPWLNeuLGYdurgf1aHF8JHFQ+v5QRVji2/ZZWxyMieoU7v+LwxRS3+2wNvBb4F0nn217SmEjSh4GDKXqfrgOuBc6n6J4bq5zrgFcBl1HEi28BZ/HkRRdvsb39WJUte8k+SdGoeB3wXOBTtj9b9Q33SgsrImLD1sFBF2VX2jOAd9leZfsk4BbgQy2SLwaW2l5i+1bgU8CeVcqxfZvtS8tuvD5gEJg9rrdflHGx7c/a3tP2Hu0EK0jAiojomiGr0gbMKrvihrczmoraD8D2+Q3HlgOLWrzsAuDKhv0lFMtF7VC1nPLm3scoVum4sKn8RWV34WOSzhzjI7hZ0lFjpBlRAlZERBeYtlpYa2zPa9iaL3tsATQPEb6P1q2fGcA9Dfu3l49bVy2nvLl3K+A/KLoHh30eeCGwEfDXwJskfXmkzwB4NnCapLWSHi2D3KOjpF/vjURERBd0cBaL1azf4NiMohXUbADYsmF/eIagu4Btq5Zj+x5JbwbWSjrL9g22v9uQ5BRJh1FcBzt2hHrvO8LxShKwIiK6pIMB6yIASfvbHu6i25ni+lOzVcAeDfuHAEO2V0h6oI1yoIgZAnah9VJTo75D2z8b7fxY0iUYEdEFdlvXsMYoy/cAvwW+Lmm+pKOB7YFPt0j+NWCfcoj6dsDxwBVVypH0QUmHS5opaSHFdHhDwPfL8ydI2k6Ft1GMKKw8c0W7ErAiIrqkw5Pf7gvMopgZ6CvAibaXSNq7vB9q7+I1fQLFvU7nULScVgOvHKuc8txWFBOSr6G49vU04I22h6cuOZLiXqoh4KvA2bYXt/mxVJYuwYiILhmsN5Pak9i+GdimxfGlNN2zanvEOVtHKqc8937g/aPkfWbV+nZCAlZERBcMr4cV45eAFRHRDRvoWlfdlIAVEdElG/LSId2QgBUR0QVFl+Bk12JqS8CKiOiSTg66mI4SsCIiuiHXsGpLwIqI6IJixeHJrsXUloAVEdElaWHVk4AVEdElCVj1JGBFRHSBKy7OGCNLwIqI6JKhRKxaeiJgSdqcYmGw7YBbKSZXvK9FuluBBymWaR6w/aJ28kdETKYMuqinV2ZrPw64yPaOFOu8HDdK2n1t7zYcrMaRPyKi66rO1J7rXCPrlYB1KMUU9pSPr+ly/oiICTfkalu01isBa4HtOwHKx61GSGfgfElXSWpcc6VqfiQtlrRM0rI1j6bXMCK6Jy2serp2DUvShcDWLU79XRvFvMT2SklbARdI+rXtS9qph+1TgFMAnrLlzl7z6OPtZH+SNY+tHXde6MxfUmsH6/3N0Ue9TnUN1vsMBh9fUys/QP/Mifu7yzZrHx+oVcbgYL1/6LrT+awd6q9XQAd+Qf3Yo7XyDz5e73vmtb0RBZzmUy1dC1i29x/pnKRVkraxfaekbShWvmxVxsry8W5JZwN7ApcAlfJHREwWO3MJ1tUrXYJLgKPK50cB5zYnkDRP0ibDzymWeL6+av6IiMk2NORKW7TWKwHrM8ABkm4CDij3kfQ0SeeVaRYAl0r6BXAF8D3bPxgtf0RErxheXiTXsMavJ+7Dsr0a2K/F8ZXAQeXzm4Fd28kfEdEzEoxq64mAFRGx4TNDiVi19EqXYETEBs3A0KArbVVI2l7SSkmWNCDpK6OkPUfSYJn2xuHxAGOVI+lgSQ9LGiq31ZIObjgvSUsbzl8uSeP7hMaWgBUR0Q0upmaqslV0MTBAcbvQscC7JR3SnEjSh4GDgcOARRT3qZ5fsZzrgFcB/cBGZdqzGvKeAbyQYsT2HsBuwL9XfgdtSsCKiOgS25W2sUiaDzwDeJftVbZPAm4BPtQi+WJgqe0ltm8FPkURYMYsx/Ztti91Uak+inlcZzeUfQjwH7aX2b4KOLM8NiESsCIiusC0NTXTrLIrbng7o6m4/QBsN7aUllO0oJotAK5s2F8C9EnaoWo5kgw8BrwRuLDh1CYUra5hPwI2HuVjqCWDLiIiusFtzXSxxva8Uc5vAetNU3MfT279DJsB3NOwf3v5uHXVcmyrbI19Gfh1U/o7m59Lkqs0FduUgBUR0SUd/Alfzfo9ZJtRtIKaDQBbNuwvLB/vAratWo7teyS9GVgr6SzbN5SnFjQkW1CmnZDhkOkSjIjoAtsMDg5V2iq4CEBS45R3O1Ncf2q2imJAxLBDgCHbK9osB4pGjoBdyv0HgVc0nN8PeKjKGxiPBKyIiC7xULVtzHLse4DfAl+XNF/S0cD2wKdbJP8asE85RH074HiK2YLGLEfSByUdLmmmpIXA5RRdiN8vy/4u8CZJu0t6AfDnFNfIJkS6BCMiuqTDNw7vC1xGMdn3IHCi7SWS9gZ+Duxje6ntEyTtCZxD0UhZQTEX66jllOe2Aj4BfIti3MjvKVZ0f6A8fySwA+sGdVxZHpsQCVgREV3SyUs75XR127Q4vpSi267x2KHtllOeez/w/lHyGtirYpVrS8CKiOgCm8zEXlMCVkREl2QqwXoSsCIiumB4lGCMXwJWRESXtHHjcLSQgBUR0SUJWPUkYEVEdMO6eQJjnBKwIiK6wKSFVVdPzHQhaXNJF0i6qXx8aos0z5F0bcP2B0nvLc99XNLvGs4d1PU3ERExms5OzTQt9UTAAo4DLrK9I8XcVsc1J7D9G9u72d4N2B14BDi7IckXh8/bPq8blY6IaEen1sOarnolYB0KnF4+Px14zRjp9wP+1/ZtE1mpiIhOGe4SrLJFa70SsBbYvhOgfNxqjPSHU8xt1egYSddJOrVVl+IwSYslLZO0bM1j99WrdUREVU7Aqqtrgy4kXUixYFizv2uznFkU0+M3LgV9EvBJij9iPgl8HnhHq/y2TwFOAdh0i508ODjYzss/ycDa8ect6lIrOwB1u7uHav7NohqfH4D6NHaiMTx414StZgCI/v56n9GcOf218g8N1fuMBobq1X/NzLm18gN4++fWyj/rhhtr12HyudOT3047XQtYtvcf6ZykVZK2sX2npG0oZg0eyauBq22vaij7ieeSvgb8TyfqHBHRSWk91dMrXYJLgKPK50cB546S9giaugPLIDfsMOD6jtYuIqImm4wSrKlXAtZngAMk3QQcUO4j6WmSnhjxJ2luef47Tfn/UdIvJV1HsbbL+7pT7YiI6nINq56euHHY9mqKkX/Nx1cCBzXsPwJs0SLdWya0ghERtWXIel09EbAiIjZ0Nngo3X11JGBFRHRJFnCsJwErIqJL0iVYTwJWREQX2GZoIF2CdSRgRUR0yZATsOrolWHtEREbtg5PzSRpe0krJVnSgKSvjJL2HEmDZdobJW1SpRxJ75S0WtJQud0uadeG8z8u8zVuLx/nJzSmBKyIiC4w1YJVG/dhXQwMUEx5dyzwbkmHNCeS9GHgYIpJFRZRzNV6fsVyngacBjwdmA88ClzY9BK32FbD9pOqb6BdCVgREV3SqeVFJM0HngG8y/Yq2ycBt/DkOVaHLQaW2l5i+1bgU8CeVcqx/Unb77f9u/J+2Y8DW9b8GMYtASsiohsMgwODlTZglqSHG7YzmkrbD8B2Y0tpOUULqtkC4MqG/SVAn6Qd2iwH4A1A82zTi8ruwscknTnKJ1BbBl1ERHSBMa4+6GKN7XmjnN8CaC7sPmB2i7QzgHsa9m8vH7dupxxJr6NYu/DYhsOfp5gK73rg7cBJklbbPrY5fyekhRUR0Q2dHXSxmvV/vzcDHmuRdoAnd+MtLB/vqlqOpFcAZwGn2D7xibdkf9f2NbbXlks3nQ+8tsobGI8ErIiILulgwLoIQFLjsk07U1x/arYK2KNh/xBgyPaKKuVIejFFIPq27aPHeotVKj9eCVgREV1hhjxUaRuzJPse4LfA1yXNl3Q0sD3w6RbJvwbsI+lgSdsBxwNXVClH0u7AT4Af2H5zc8GSTpC0nQpvA14FfK/ND6ayXMOKiOgCu+MLOO4LXEax4O0gcKLtJZL2Bn4O7GN7qe0TJO0JnEPRSFkBvHKscspzn6OIE38q6YnK2x5eBvtIihGFAtYAZ9te3Mk32SgBKyKiGwxDxQjAzhRn3wxs0+L4UooA0njs0HbLKc+9Yow6PLNSZTskASsioivaGiUYLSRgRUR0gcnyInUlYEVEdEMWcKytJ0YJSnqDpOXl3dIvGiXdgZJ+I2mFpOMajm8u6QJJN5WPT+1OzSMiqur4XILTTk8ELIq7pF8LXDJSAkn9wInAq4GdgCMk7VSePg64yPaOFPcVHNe6lIiIyWMPVdqitZ7oErT9KwBJoyXbE1hRjmhB0rcppgm5oXz8kzLd6cCPgQ9OTG0jItpXLODYuVGC05F6aclmST8G/tb2shbnXg8caPtd5f5bgL1sHyPpftubNaS9z3bLbkFJiylmLwZ4DvCbDr6FLYHfd7C8TkrdRvZM2/NbnZB0D3BbB19rst/raHq5bjD59Rvxe1JF+V2aWzH5I3Vea0PVtRaWpAspJlts9ne2z61SRItjbUfbcr6rU9rNV4WkZbZHvAY3mVK38en0j0Yvv9derhv0fv3GkgBUX9cClu39x041qjsoFhEbti2wsny+StI2tu+UtA3FHdsREbEB6ZVBF1VcCewoaZGkWcDhFOu6UD4eVT4/CqjSYouIiCmkJwKWpMMk3QHsA3xP0g/L40+TdB6A7QHgGOCHwK+As2wvL4v4DHCApJuAA8r9yTAhXY0dkrr1hl5+r71cN+j9+sUE66lBFxERESPpiRZWRETEWBKwIiJiSkjA6gBJ7yunlrpe0rckzZ7k+pwq6W5J1zcdP7ac2mq5pH+cpLrNlnSFpF+U9fj78vjnJP1a0nWSzpa02WTUbyL10vck35GYihKwapK0EPhr4EW2nwf0U4xgnEynAQc2HpC0L8WMILvY3hn4p0moF8DjwCts7wrsBhxYLjh3AfA827sAN1IsCrfB6MHvyWnkOxJTTAJWZ8wA5kiaQXEn+8ox0k8o25cA9zYd/kvgM7YfL9NMyr1qLjxU7s4sN9s+vxwJCrCU4j67DU3PfE/yHYmpKAGrJtu/o/hL9LfAncADts+f3Fq19GzgZZIul/QTSXtMVkUk9Uu6luIG7wtsX96U5B3A97tesQk0Rb4n+Y5ET0vAqqlcyuRQYBHwNGCepCMnt1YtzQCeCuwNfAA4S2PMNjxRbA/a3o3iL+Q9JT1v+JykvwMGgG9ORt0myhT5nuQ7Ej0tAau+/YFbbN9jey3wHeDFk1ynVu4AvlN2t1wBDFFMJjppbN9PMbP+gQCSjgL+DHizN7wbBKfC9yTfkehpCVj1/RbYW9Lc8q/R/Shm4ug15wCvAJD0bGAWkzDztaT5w6O7JM2h+CH/taQDKZaEOcT2I92uVxdMhe/JOeQ7Ej2sJ9bDmspsXy7pv4CrKboprmGSp5CR9C2K9cG2LKe8+hhwKnBqOYx5DXDUJP2Fug1wuooFOfsoptj6H0krgI2AC8peqKW2j56E+k2IXvue5DsSU1GmZoqIiCkhXYIRETElJGBFRMSUkIAVERFTQgJWRERMCQlYERExJSRgRUTElJCAFRERU0ICVg+T9H8k3Snp2obt+R0sf045yWl/ub9A0pmSbpZ0laSfSzpsjDJ+LOlVTcfeK+lfJM2SdEk5O3lMgHxHYjpJwOptuwDH296tYftlB8t/B8XccYPldEHnAJfY3t727hTrNY21hMO3WH9dp8OBb9leA1wEvKmDdY4ny3ckpo0ErN72fODaCSz/zcC55fNXAGtsnzx80vZttr88vC/pyHIl2GslfbX8q/u/gD+TtFGZZjuK2cgvLbOdU75OTIx8R2LaSMDqbTsD/9bQ1bO4UwVLmgVsb/vWhte6epT0z6X4K/gl5bIPgxQzZq8GrmDd6rWHA//RMAfd9cCkras0DeQ7EtNG+o17lKSnA3eXy4G3Ot9ne6jGS2wJ3D/K658IvJTiL+o9KGYX3x24spx4dA7F4nqwrsvn3PLxHcPllF1JayRtYvvBGvWNJvmOxHSTgNW7dgF+3XxQ0tsolltYJuls4P2AgP8FzgY+RfEjcTZwF/Bx4DHgu7bPbSjqUWB2w/5y4HXDO7bfLWlLYNnwSwOn2/5Qi7qeA3xB0guBObab/wrfqKxDdFa+IzGtpEuwdz2fFj9Gpe/b/mfgryh+VFaX6d8NfML2+21fChwNfMT2u4AnrW5r+z6gX9LwD9KPgNmS/rIh2dyG5xcBr5e0FYCkzSU9syzrIYpF9k6l+Ev6CZK2AIYXLYzOynckppUErN71fOAtDdcmrpG0cXnugfKxD/im7Y/bfifFX7iNXUAChq8TtFpH5nyKLh3K6wmvAV4u6RZJVwCnUyyYh+0bgOOB8yVdB1xAsW7RsG8BuwLfbnqNfYHz2nrnUVW+IzGtZD2sKabs7vl9uaDdM4F/AO4EHgS+QdG9cyewhGK12I8AjwA/sH12U1kvAP7G9lsmsL7fAT5k+zcT9RrxZPmOxIYqAWuak/QOiusOgxNQ9izgcNvf6HTZ0T35jkSvSMCKiIgpIdewIiJiSkjAioiIKSEBKyIipoQErIiImBISsCIiYkpIwIqIiCkhASsiIqaE/w+WuXXNv2qTNwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_modif_to_map(model_daemon)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce8c9f0f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "analysis_pisa2", + "language": "python", + "name": "analysis_pisa2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/setup.py b/setup.py index 51addb6f8..046621851 100755 --- a/setup.py +++ b/setup.py @@ -108,6 +108,7 @@ 'scikit-learn<=1.1.2', 'pyarrow', 'tqdm', + 'daemonflux', ] EXTRAS_REQUIRE = {