diff --git a/explauto/sensorimotor_model/inverse/cma.py b/explauto/models/cma.py similarity index 100% rename from explauto/sensorimotor_model/inverse/cma.py rename to explauto/models/cma.py diff --git a/explauto/models/gmrinf.py b/explauto/models/gmrinf.py new file mode 100644 index 0000000..06b197b --- /dev/null +++ b/explauto/models/gmrinf.py @@ -0,0 +1,113 @@ +import numpy as np +import numpy.linalg +import gmr as fabisch_gmr +import cma + + +from numpy.linalg import inv, eig +from numpy import ix_, array, inf, sqrt, linspace, zeros, arctan2, matrix, pi +from .gaussian import Gaussian + + +class GMR(fabisch_gmr.gmm.GMM): + def __init__(self, n_components): + fabisch_gmr.gmm.GMM.__init__(self, n_components) + + def probability(self, value): + """Compute the probability of x knowing y + + Parameters + ---------- + value : array, shape(n_samples, n_features) + Y + + Returns + ------- + proba : float, + X + """ + + proba = 0. + pmc = zip(self.priors, self.means, self.covariances) + for p,m,c in pmc: + proba += p * Gaussian(m.reshape(-1,), c).normal(value.reshape(-1,)) + return proba + + def regression(self, in_dims, out_dims, value, regression_method="slse", **kwargs): + """ Compute a prediction y knowing a value x + + Parameters + ---------- + in_dims : array, shape (n_input_features,) + Indices of dimensions of the input + + out_dims : array, shape (n_output_features,) + Indices of dimensions of the output + + value : array, shape (n_input_features,) + Value of the input + + regression_method : string + + Returns + ------- + y : array, shape(n_output_features,) + Value of the output + + """ + if regression_method == "lse": + return self.predict(in_dims, value)[0] + elif regression_method == "slse": + return self.regression_slse(in_dims, out_dims, value) + elif regression_method == "optimization": + return self.regression_optimization(in_dims, out_dims, value, **kwargs) + elif regression_method == "stochastic_sampling": + return self.regression_stochastic_sampling(in_dims, out_dims, value) + else: + raise NotImplementedError + + + def regression_slse(self, in_dims, out_dims, value): + """ + SLSE is the Single component LSE and computes the most probably value of the most important gaussian + knowing an input value. + """ + conditional_gmm = self.condition(in_dims, value) + max_prior = np.max(conditional_gmm.priors) + max_ind = np.where(conditional_gmm.priors == max_prior)[0][0] + return conditional_gmm.means[max_ind] + + def regression_optimization(self, in_dims, out_dims, value, x_guess, + optimization_parameters={"sigma":0.1, "maxfevals":200, "bounds":None}, + optimization_method="CMAES"): + """ + This sampling is the obtained by the minimization of the error x knowing y by using an optimization method + as CMAES or BFGS + """ + conditional_gmm = self.condition(in_dims, value) + f = lambda x: - conditional_gmm.probablity(x) + + if optimization_method=="CMAES": + res = cma.fmin(f, x_guess, optimization_parameters["sigma"], + options={'bounds':optimization_parameters["bounds"], + 'verb_log':0, + 'verb_disp':False, + 'maxfevals':optimization_parameters["maxfevals"]}) + + elif optimization_method=="BFGS": #TODO + raise NotImplementedError + + else: + raise NotImplementedError + # ....... + + return res[0] #index to check, it might be 1 + + def regression_stochastic_sampling(self, in_dims, out_dims, value): + """ + This method returns a random value according to the conditional probability + """ + conditional_gmm = self.condition(in_dims, value) + return conditional_gmm.sample(n_samples=1)[0] + + diff --git a/explauto/sensorimotor_model/ilo_gmr.py b/explauto/sensorimotor_model/ilo_gmr.py new file mode 100644 index 0000000..5d3e06b --- /dev/null +++ b/explauto/sensorimotor_model/ilo_gmr.py @@ -0,0 +1,101 @@ +import numpy as np + +from numpy import array, hstack + +from ..exceptions import ExplautoBootstrapError +from .sensorimotor_model import SensorimotorModel +from explauto.models.dataset import Dataset + +from .inverse.cmamodel import CMAESInverseModel as CMAES +from ..models.gmrinf import GMR +from sklearn.linear_model.sgd_fast import Regression + +class IloGmr(SensorimotorModel, GMR): + """GMR adapted to sensori motor models""" + + def __init__(self, conf, n_components=3): #choix methode dans init + SensorimotorModel.__init__(self, conf) + GMR.__init__(self, n_components) + self.n_neighbors = max(100, (conf.ndims) ** 2) # at least 100 neighbors + self.n_neighbors = min(1000, self.n_neighbors) # at most 1000 neighbors + self.min_n_neighbors = 20 # otherwise raise ExplautoBootstrapError + self.m_dims = conf.m_dims + self.s_dims = conf.s_dims + + def infer(self, in_dims, out_dims, value, method="direct", regression="SLSE"): + if method=="direct": + res = self.infer_direct(in_dims, out_dims, value, regression) + elif method=="undirect": + res = self.infer_undirect(in_dims, out_dims, value, regression) + else: + pass + return res + + def update(self, m, s): + self.dataset.add_xy(tuple(m), tuple(s)) + pass + + + def infer_undirect(self, in_dims, out_dims, xq, regression = CMAES): + + cma = CMAES(in_dims, out_dims, fmodel=None, cmaes_sigma=0.05, maxfevals=20) + + def infer_direct(self,in_dims, out_dims, xq, regression = CMAES): + pass + + + #=================================================================================== + #BROUILLON + def predict_direct(self, in_dims, out_dims, xq, method): + """dire ce que fait la fct et d'ou elle vient""" + + #local_gmrinf = (3, local_gmm.priors_, local_gmm.means_, local_gmm.covars_) + + #conditional_gmm = local_gmrinf.condition(xq) + + #def infer_direct(self, in_dims, out_dims, xq, method == 1): + """utilise directement methode sur modele inverse""" + + + + #manque optimisation + + + #faire des fonctions pour chaque méthode i), ii), iii), iv) dans GMR + #faire update et infer ici + #toutes les méthodes (inverse direct et 4 étapes) + 4 méthodes i), ... fonctionnent avec GMM classique et GMM local donc les mettre dans classe GMR + # => mettre les fonctions une classe GMM mais différent de GMMinf avec seulement ce qui est utile (appelé différent : GMR . GMR dans models + #Mettre classe GMR dans models + # sciopt et optimize à aller chercher pour implémenter méthode iii) + #CMAES prend f(x) en entrée qu'on va définir avec GMM(x,y) ou | + #Récupérer code de infer de CMAESInverseModel dans classe GMR après avoir construit le f(x) = GMM(x,y) + #pour l'instant faire que avec CMAES et pas avec BFGS, etc. + #dans inverse, sciopt, sciopt.optimize.minimize de infer_x , on pourra changer algo (plus tard) + + #GMR doit pouvoir faire des GMM conditionnelles (infer ou + #robuste inverse/direct + #CMAES fmin utilisé dans méthode optimilisation (iii) ) + + # Paramètre nombre de gaussienne de GMR + + #ILOGMR + #il faut écrire une fonction par méthode ( 1) 4étapes ou 2) inverse directement. Je sépare comment pour faire inverse et direct ? + #GMR + #j' ai encore du mal a voir différence entre ii) et iii) : + + + + + + + + + + + + + + + + + diff --git a/explauto/sensorimotor_model/inverse/cmamodel.py b/explauto/sensorimotor_model/inverse/cmamodel.py index 49ea87f..87251ef 100644 --- a/explauto/sensorimotor_model/inverse/cmamodel.py +++ b/explauto/sensorimotor_model/inverse/cmamodel.py @@ -1,6 +1,7 @@ +import explauto.models.cma from .optimize import OptimizedInverseModel -from . import cma + class CMAESInverseModel(OptimizedInverseModel): diff --git a/explauto/sensorimotor_model/non_parametric.py b/explauto/sensorimotor_model/non_parametric.py index da03e35..2b43674 100644 --- a/explauto/sensorimotor_model/non_parametric.py +++ b/explauto/sensorimotor_model/non_parametric.py @@ -15,14 +15,14 @@ class NonParametric(SensorimotorModel): Original code available at https://github.com/humm/models Adapted by Sebastien Forestier at https://github.com/sebastien-forestier/models """ - def __init__(self, conf, sigma_explo_ratio=0.1, fwd='LWLR', inv='L-BFGS-B', **learner_kwargs): + def __init__(self, conf, sigma_explo_ratio=0.1, fwd='LWLR', inv='L-BFGS-B', mode = 'explore', **learner_kwargs): SensorimotorModel.__init__(self, conf) for attr in ['m_ndims', 's_ndims', 'm_dims', 's_dims', 'bounds', 'm_mins', 'm_maxs']: setattr(self, attr, getattr(conf, attr)) self.sigma_expl = (conf.m_maxs - conf.m_mins) * float(sigma_explo_ratio) - self.mode = 'explore' + self.mode = mode mfeats = tuple(range(self.m_ndims)) sfeats = tuple(range(-self.s_ndims, 0)) mbounds = tuple((self.bounds[0, d], self.bounds[1, d]) for d in range(self.m_ndims)) @@ -92,8 +92,8 @@ def size(self): sensorimotor_models = { - 'nearest_neighbor': (NonParametric, {'default': {'fwd': 'NN', 'inv': 'NN', 'sigma_explo_ratio':0.1}, - 'exact': {'fwd': 'NN', 'inv': 'NN', 'sigma_explo_ratio':0.}}), + 'nearest_neighbor': (NonParametric, {'default': {'fwd': 'NN', 'inv': 'NN', 'sigma_explo_ratio':0.1, 'mode':'explore'}, + 'exact': {'fwd': 'NN', 'inv': 'NN', 'sigma_explo_ratio':0., 'mode':'exploit'}}), 'WNN': (NonParametric, {'default': {'fwd': 'WNN', 'inv': 'WNN', 'k':20, 'sigma':0.1}}), 'LWLR-BFGS': (NonParametric, {'default': {'fwd': 'LWLR', 'k':10, 'sigma':0.1, 'inv': 'L-BFGS-B', 'maxfun':50}}), 'LWLR-CMAES': (NonParametric, {'default': {'fwd': 'LWLR', 'k':10, 'sigma':0.1, 'inv': 'CMAES', 'cmaes_sigma':0.05, 'maxfevals':20}}), diff --git a/notebook/GMR class test.ipynb b/notebook/GMR class test.ipynb new file mode 100644 index 0000000..2651861 --- /dev/null +++ b/notebook/GMR class test.ipynb @@ -0,0 +1,467 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy as sp\n", + "import time\n", + "import sys\n", + "sys.path.append('/usr/local/lib/python2.7/dist-packages/gmr-1.1_git-py2.7.egg')\n", + "import gmr as gaussian_regression" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#Environment definition\n", + "from scipy import spatial\n", + "from explauto.utils import rand_bounds\n", + "from explauto.environment.environment import Environment\n", + "from explauto import SensorimotorModel\n", + "from explauto.sensorimotor_model import sensorimotor_models" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from explauto.models.gmrinf import GMR\n", + "from explauto.sensorimotor_model.ilo_gmr import IloGmr" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "environment = Environment.from_configuration('simple_arm', 'mid_dimensional')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "model = sm_cls(environment.conf, **sm_configs['default'])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#Creation of the total dataset\n", + "def generateFwdDataset(_environment, _model, _n = 1000):\n", + " random_motors = _environment.random_motors(n=_n)\n", + " \n", + " for m in random_motors:\n", + " s = _environment.compute_sensori_effect(m)\n", + " _model.update(m, s)\n", + "generateFwdDataset(environment, model)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data_list = model.model.imodel.fmodel.dataset.data" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data_np = np.array(data_list).T" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data = []\n", + "for i in range(len(data_np)):\n", + " data.append(np.hstack(data_np[i,:]))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "gmr = GMR(n_components=3)\n", + "gmr = gmr.from_samples(np.array(data))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "x_wanted_list = [-0.76151596, 0.85728845, 0.0987334 , 0.46247676, -0.16366163,\n", + " 0.27212757, 0.08281898]\n", + "x_wanted_array = np.transpose(np.array([[-0.76151596], [0.85728845], [0.0987334], [0.46247676], [-0.16366163],\n", + " [0.27212757], [0.08281898]]))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "conditional = gmr.condition([0, 1, 2, 3, 4, 5, 6], x_wanted )" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 1.37649826e-04 2.95463259e-02 9.70316024e-01]\n" + ] + } + ], + "source": [ + "print conditional.priors" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "prediction = gmr.predict(np.array([0, 1, 2, 3, 4, 5, 6]), x_wanted_array)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.83352573 -0.06368539]\n" + ] + } + ], + "source": [ + "print prediction[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "reg = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), x_wanted_array, \"lse\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.83352573 -0.06368539]\n" + ] + } + ], + "source": [ + "print reg" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "slse = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), x_wanted_array, \"slse\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.82906377 -0.07093158]\n" + ] + } + ], + "source": [ + "print slse" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "stoc_samp = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), x_wanted_array, \"stochastic_sampling\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.79811269 -0.01681426]\n", + "[ 0.80222399 -0.03754475]\n" + ] + } + ], + "source": [ + "print stoc_samp\n", + "print conditional.sample(n_samples=1)[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "ename": "TypeError", + "evalue": "regression_optimization() takes at least 5 arguments (4 given)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m optim = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), np.transpose(np.array([[-0.76151596], [0.85728845], [0.0987334], [0.46247676], [-0.16366163],\n\u001b[1;32m----> 2\u001b[1;33m [0.27212757], [0.08281898]])), \"optimization\")\n\u001b[0m", + "\u001b[1;32m/home/roxane/Logiciels/anaconda/lib/python2.7/site-packages/explauto-1.2.0-py2.7.egg/explauto/models/gmrinf.pyc\u001b[0m in \u001b[0;36mregression\u001b[1;34m(self, in_dims, out_dims, value, regression_method, **kwargs)\u001b[0m\n\u001b[0;32m 61\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mregression_slse\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0min_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 62\u001b[0m \u001b[1;32melif\u001b[0m \u001b[0mregression_method\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m\"optimization\"\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 63\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mregression_optimization\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0min_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 64\u001b[0m \u001b[1;32melif\u001b[0m \u001b[0mregression_method\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m\"stochastic_sampling\"\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 65\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mregression_stochastic_sampling\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0min_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mTypeError\u001b[0m: regression_optimization() takes at least 5 arguments (4 given)" + ] + } + ], + "source": [ + "optim = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), x_wanted_array, \"optimization\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.76151596, 0.85728845, 0.0987334, 0.46247676, -0.16366163, 0.27212757, 0.08281898]\n", + "[-0.46137381 0.43977351 0.18866761 0.39337473 0.04888891 0.60912177\n", + " 0.15361874]\n" + ] + } + ], + "source": [ + "#1) get x the nearest neighbor of xq in the dataset\n", + "dist, indexes = model.model.imodel.fmodel.dataset.nn_x( x_wanted_list, k = 1)\n", + "x = model.model.imodel.fmodel.dataset.get_x(indexes[0])\n", + "print x_wanted_list\n", + "print x" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.87630398 0.01291787]\n" + ] + } + ], + "source": [ + "#2) get the y associated to x\n", + "y = model.model.imodel.fmodel.dataset.get_y(indexes[0])\n", + "print y" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "#3) Creation fof a local dataset depending on x_g\n", + "_, l_index = model.model.imodel.fmodel.dataset.nn_x(x, 100)\n", + "l_nn = []\n", + "col1 = []\n", + "col2 = []\n", + "for index in l_index:\n", + " l_nn.append(np.hstack(model.model.imodel.fmodel.dataset.get_xy(index)))\n", + "lnn_nparray = np.array(l_nn)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "#4) find the number of gaussians\n", + "from sklearn.cluster import AffinityPropagation\n", + "af = AffinityPropagation(damping=0.988)\n", + "af.fit(l_nn)\n", + "n_clusters = len(af.cluster_centers_)\n", + "print n_clusters" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "#5 ) create ilogmr\n", + "local_gmr = IloGmr(environment.conf, n_clusters)\n", + "local_gmr = local_gmr.from_samples(lnn_nparray)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.26908044 0.46998805 0.26093151]\n" + ] + } + ], + "source": [ + "print local_gmr.priors" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/notebook/comparing_sensorimotor_models_non_parametric.ipynb b/notebook/comparing_sensorimotor_models_non_parametric.ipynb new file mode 100644 index 0000000..6d547a0 --- /dev/null +++ b/notebook/comparing_sensorimotor_models_non_parametric.ipynb @@ -0,0 +1,7698 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Comparison between learning sensorimotor models \n", + "## Part 1 : non parametric models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook, we compare the different sensorimotor models used in explauto in order to help the reader to use the most appropriate model depending on his aim. The notebook is split in two parts : non parametrics models (this notebook) and models based on gaussian mixtures (coming soon). There is also a tutorial explaining how to use the [SensorimotorModel abstract class](http://flowersteam.github.io/explauto/explauto.sensorimotormodel.html#explauto.sensorimotor_model.sensorimotor_model.SensorimotorModel) ([learning_sensorimotor_models](http://nbviewer.ipython.org/github/flowersteam/explauto/blob/master/notebook/learning_sensorimotor_models.ipynb)).\n", + "\n", + "As explained in the [Explauto introduction](http://flowersteam.github.io/explauto/about.html), an important challenge in Developmental Robotics is how robots can efficiently learn sensorimotor mappings by experience, i.e. the mappings between the motor actions they make and the sensory effects they produce. This can be a robot learning how arm movements make physical objects move, or how movements of a virtual vocal tract modulates vocalization sounds." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sensorimotor models introduction\n", + "\n", + "In Explauto, a sensorimotor model implements both the iterative learning process from sensorimotor experience, i.e. from the iterative collection of $(m, s)$ pairs by interaction with the environment, and the use of the resulting internal model to perform forward and inverse predictions (or any kind of general prediction between sensorimotor subspaces). \n", + "\n", + "Learning sensorimotor mappings involves machine learning algorithms, for which Explauto provides a unified interface through the [SensorimotorModel abstract class](http://flowersteam.github.io/explauto/explauto.sensorimotormodel.html#explauto.sensorimotor_model.sensorimotor_model.SensorimotorModel). \n", + "\n", + "Using the simple arm environment above, it allows to iteratively learn a sensorimotor model which will be able to:\n", + "* infer the position of the end-effector from a given motor command, what is called *forward prediction*,\n", + "* infer the motor command allowing to reach a particular end-effector position, what is called *inverse prediction*.\n", + "* update online from sensorimotor experience" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from scipy import spatial\n", + "import numpy as np\n", + "import time\n", + "\n", + "#Environment definition\n", + "from explauto.environment.environment import Environment\n", + "environment = Environment.from_configuration('simple_arm', 'mid_dimensional')\n", + "\n", + "from explauto import SensorimotorModel\n", + "from explauto.sensorimotor_model import sensorimotor_models\n", + "from explauto.utils import rand_bounds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Non parametric or gaussian mixture models ? \n", + "\n", + "Each of non parametric model is currently based on the nearest neigbhor look up. They are non paramtric models because they don't rely on assomptions that the data are drown from a given probability while gassian mixture models (GMM) assumes that the data points are generated from a mixture of a finite number of Gaussian distributions with unknown parameters. Readers in this case should refer to the follwing tutorial : *coming soon* .\n", + "\n", + "Available sensorimotor models in Explauto can be accessed using: " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Available sensorimotor models: ['LWLR-BFGS', 'nearest_neighbor', 'WNN', 'LWLR-CMAES']\n" + ] + } + ], + "source": [ + "print 'Available sensorimotor models: {}'.format(sensorimotor_models.keys())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Presentation of the different non parametric models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These 4 non parametric models, which are a combination of a forward and an inverse model, are:\n", + "* the **nearest neighbor** model searches the nearest point of a given input ($m$ or $s$) in the dataset and returns its corresponding value (respectively $s$ or $m$)\n", + "* the **WNN or weighted nearest neighbor** model searches the $k$ nearest points of a given input ($m$ or $s$) in the dataset and returns the average of the $k$ corresponding values (respectively $m$ or $s$)\n", + "* Both **LWLR-BFGS and LWLR-CMAES** use **the Locally Weigthed Linear Regression (LWLR)** for their forward models. It computes a linear regression of the $k$ nearest neighbors of $m$ and find the requested $s$ with the given $m$ based on that regression. Both inverse models are optimisation algorithm that minimize the error $e(m) = ||LWLR(m) - s_g||^2$ where $s_g$ is the goal, $LWLR$ is the forward model LWLR, and $m$ is the motor command to be infered. BFGS and CMAES are inverse models which are going to be explained later." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating models or changing their caracteristics (k, sigma, ...)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, it is possible to change its caracteristics like sigma exploration ratio for nearest neighbor models or the number $k$ of nearest neighbor in WNN models and so on. For instance, in order to create a model using LWLR forward model and Cobyla as inverse model : " + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from explauto.sensorimotor_model.non_parametric import NonParametric\n", + "custom_config = {'fwd': 'LWLR', 'inv': 'COBYLA', 'k': 10, 'maxfun' : 50}\n", + "sensorimotor_models['LWLR-COBYLA'] = {}\n", + "sensorimotor_models['LWLR-COBYLA'] = (NonParametric, {'default' : custom_config})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Whether changes are made or not, in order to know the caracteristics of the different models:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "# or 'WNN', 'LWLR-BFGS', 'LWLR-CAMES', 'LWLR-COBYLA' (if the previous lines have been executed)\n", + "model = sm_cls(environment.conf, **sm_configs['default'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Eploit or explore mode ?\n", + "\n", + "All the non-parametric sensorimotor models have two operating modes: \"explore\" and \"exploit\".\n", + "\n", + "In the \"explore\" mode, when the agent asks for the exact inverse prediction $m$ of a goal $s_g$, $m$ will be perturbated with some gaussian exploration noise in order to allow the agent to explore new motor commands. The sensorimotor models thus have a common parameter: sigma_explo_ratio=0.1 (default), which is the standard deviation of the gaussian noise, scaled depending of the motor domain size: if a motor value is bounded in [-2:2], then a sigma_explo_ratio of 0.1 will induce an exploration noise of (m_max - m_min) * sigma_explo_ratio = 0.4\n", + "\n", + "In the \"exploit\" mode, no exploration noise is added. This mode is used for instance when evaluating the inverse model for comparison purposes.\n", + "\n", + "The default mode is explore, in order to switch to exploit mode:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "model.mode = 'exploit'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Forward and inverse model distinction\n", + "\n", + "The forward model uses the dataset for the forward prediction computation, and the inverse model uses the forward model, or directly the dataset to perform inverse prediction. In other words, forward models predict $s_p$ given a $m$ that might have never been observed, using the dataset of observations $(m,s)$ and inverse models infer a motor command $m$ that should be able to reach a given goal $s_g$. \n", + "\n", + "For each of these models it is necessary to load the mode with the appropriate model chosen as explained earlier and then create a dataset of n $(m,s)$ couples which is going to be tested later." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#Creation of the dataset\n", + "def generateFwdDataset(_environment, _model, _n = 10000):\n", + " random_motors = _environment.random_motors(n=_n)\n", + " \n", + " for m in random_motors:\n", + " s = _environment.compute_sensori_effect(m)\n", + " _model.update(m, s)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + " \n", + "# Distance between the predictive and effectiv value\n", + " \n", + "def generateFwdTest(_environment, _model, _n = 100):\n", + " #Test of the model\n", + " %pylab inline\n", + " test = _environment.random_motors(n=_n)\n", + " distance = []\n", + " timer = []\n", + " \n", + " \n", + " for mTest in test :\n", + " start = time.time()\n", + " sTest_pred = _model.forward_prediction(mTest)\n", + " end = time.time()\n", + " sTest_eff = _environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", + " timer.append(end - start)\n", + " figure(1)\n", + " plot(sTest_pred[0], sTest_eff[0], 'ok')\n", + " figure(2)\n", + " plot(sTest_pred[0], sTest_pred[1], 'or')\n", + " plot(sTest_eff[0], sTest_eff[1], 'ob')\n", + " plot([sTest_pred[0], sTest_eff[0]], [sTest_pred[1], sTest_eff[1]], '-g')\n", + " \n", + " figure(1)\n", + " axis([0,1,0,1])\n", + " plot([0,1], [0,1], 'r-', lw=2)\n", + " title(\"Fwd - Comparison between x of s effective and predicted\")\n", + " xlabel(\"x predicted\")\n", + " ylabel(\"x effective\")\n", + " \n", + " figure(2)\n", + " title(\"Fwd - Distance between effective and predicted\")\n", + " xlabel(\"x\")\n", + " xlabel(\"y\")\n", + " \n", + " return {'mean distance' : np.mean(distance), 'std distance': np.std(distance) ,'max distance' : max(distance),\n", + " 'mean time': np.mean(timer), 'std time': np.std(timer), 'max time': max(timer)}" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + " # Distance between the predictive and effectiv value\n", + " \n", + "def generateInvTest(_environment, _model, _n = 100):\n", + " #Test of the model\n", + " %pylab inline\n", + " test_cases = rand_bounds(np.array([[0,0], [1,1]]), n=_n)\n", + " distance = []\n", + " timer = []\n", + " \n", + " for sTest_goal in test_cases :\n", + " start = time.time()\n", + " mTest = _model.inverse_prediction(sTest_goal)\n", + " end = time.time()\n", + " sTest_eff = _environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([sTest_goal,sTest_eff])[0])\n", + " timer.append(end - start)\n", + " figure(1)\n", + " plot(sTest_goal[0], sTest_eff[0], 'ok')\n", + " figure(2)\n", + " plot(sTest_goal[0], sTest_goal[1], 'or')\n", + " plot(sTest_eff[0], sTest_eff[1], 'ob')\n", + " plot([sTest_goal[0], sTest_eff[0]], [sTest_goal[1], sTest_eff[1]], '-g')\n", + " \n", + " figure(1)\n", + " axis([0,1,0,1])\n", + " plot([0,1], [0,1], 'r-', lw=2)\n", + " title(\"Inv - Comparison between x of s effective and predicted\")\n", + " xlabel(\"x goal\")\n", + " ylabel(\"x effective\")\n", + " \n", + " \n", + " figure(2)\n", + " title(\"Fwd - Distance between effective and predicted\")\n", + " xlabel(\"x\")\n", + " xlabel(\"y\")\n", + " \n", + " return {'mean distance' : np.mean(distance), 'std distance': np.std(distance) ,'max distance' : max(distance),\n", + " 'mean time': np.mean(timer), 'std time': np.std(timer), 'max time': max(timer)}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Getting started with forward models\n", + "\n", + "The predicted sensorimotor effect $s_p$ of a command $m$ depending on a given model can be obtained this way after defining the model: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "s_pred = model.forward_prediction(m)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to test foward models, we are going to generate randomly n $m$ and use one of these models to find out $s_p$. The distance between $s_g$ and the real s plus the time processing are saved in $fwd _ model$ dictionary. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Nearest Neighbor forward model\n", + "\n", + "To perform a forward prediction, the Nearest Neighbor model looks in the dataset of tuples $(m, s)$ for the nearest neighbor of the given $m$ motor command, and returns its corresponding $s$.\n", + "The algorithm comes from scipy library : [scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html) (with x = $s$, k=1, eps = 0, p = 2, radius = +inf). It returns distance of found nearest neighbors $s_p$.\n", + "\n", + "Let's see how to use it : " + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEZCAYAAACAZ8KHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXm8HVWV778rIUDCJBAFEgIoiTREoFEBFdAAPow0gkMj\n", + "DxGawQalIfHJU3AiEXCgbQfAbgRUUJBJxRbavKAfJUgDMiiTTC8JICEJaEgUNAETWP3H3uem7knV\n", + "OXXOPXWGqt/387mfe6pqV9WqXcPaa6+19jZ3RwghhMjLqF4LIIQQYrCQ4hBCCNESUhxCCCFaQopD\n", + "CCFES0hxCCGEaAkpDiGEEC0x8IrDzF42s9f0Wo6yYGZHmdmNXT7nE2Z2YDfPOYiY2VZm9isze87M\n", + "vlzgefYxs/lm9ryZHVrkec3sd2b21k4es9OY2TwzO6FH555tZpfH39vFe2JdOG/Dd7KriiMKszJe\n", + "/PPxQdy6wPPNM7NVZrZtYt3bzezxOpmeMbNxiXUfMrObRnjuD5jZ3fE6l5jZHDPbZyTH7Abu/n13\n", + "f0e3Txv/WibevwM6LE+/ciLwB3ff1N0/XuB5zgLOd/dN3P36Tp3XzC4zs7OT69z9de7+qxHKWzRt\n", + "P58dOnf44f5kvCcNZTGzaWa2qAPnzTxPty0OBw6JF79JfBCfLvicfwU+26TMKGBmp05oZh8Dvgac\n", + "A7wKmAT8O3Bop85RBGY2utcytIEDhbfA+oTtgYe7cJ7tgId6cN5SY2br9VqGjuHuXfsDHgcOSFn/\n", + "XeBj8fdE4GXg5Li8I/BsouzHgSXAU8DxsexrMs53E3Am8FytDPB24PE6mU4HngU2i+s+BNzU5jVu\n", + "BjwPvK9BmQ2ArwOL49/XgPXjtmnx2j4O/CFe67uBg4H/H+U8I3Gs2cAPgavjdf4G2C2x/QxgQdz2\n", + "IPDuxLZjgVuBrwLLgLPjulvidouyPQP8GbgfmJq4zu9FGZ8APg1Y4rj/DXwZWA48Bkxv8lycEeVb\n", + "DnwH2CCx/RDgXmBFlHfXuP5y4CVgZazzjwOXtfAspR43bpsA/Che32PAqXV1fi3huX0O+B3whoxr\n", + "ewvwR2DbuLx7vMbXNih/F/An4E7gzXH9ZcDfgBfjtaa9RwfHOnyO8Ayd1qDOjycoh+XAXGC7uH5h\n", + "XZ1eWX/e+FzUnqtlwDXA5olj7wvcFuv1SeCfgH+uO85PYtkn4jEnxHMmj7NHrLvRjWTOuL4fAEtj\n", + "Pd4M7JLYdhmhIfdfsa5+TeIbAvwv4JG47wXAPOCEjPPMpvH79wTwCcK7s4rQSH1Ton7uBd6WKP/q\n", + "KO9zwM/i+S+P23YgPM+j4vIWwKWEb8hy4DpgXDzPS7GenwO2znHPjgZ+H7d9ioxv9VD5dj6O7f5F\n", + "YQ5MWX8ccH38/YF4cVcnHpYfx9/TgaeBXWIFXUlzxXEC8JVE5acpjgMJH4mz47qRKI7pwOrazc0o\n", + "c1Z8cMbHv1uBs+K2aXH/zwCjoyzLgO8DG8VrXwlsn3hw/wa8N5Y/jfChq71s/whsHX+/H/gLsFVc\n", + "Pjae61/iA70hwxXHO4C7gU3j8k6JY30P+HGUaXvgUeD4xHH/FuvegA8DixvUxxOEF2sisDlB6dTu\n", + "xR4ExbVnPNYx8Z6NSdy/AxLHyvssZR431sVv4j1Yj/AyLwQOStT5qnivDfgCcHuD6zsH+AUwFniA\n", + "qMhSym1B+JgcFWX434QPwuZx+6XE5yRj/6XAPvH3ZsAeGeUOA+bH+zmKoPRvrXsnknU67LwE6/w2\n", + "wsd+DPBN4Mq4bXvCx+oIwvO4BbB7lvzJc8U6+lBi25eB/8gjc8o1Hkt4NscQGj/3JLZdRnin3hhl\n", + "vAK4Km4bH+WvvU8fJbwjx2ecZzaN378ngN8Snu0N4v9lxIYU4Xu0DNgyLt8O/FuUe78oy/fith0Y\n", + "rjh+ClwV7/V6wH5x/duARXVyNrpnuxCUzL7A+oTv5Wr6SHE8EQVcEf+ui+t3JLwgBlxI6FNdFLd9\n", + "F/ho/P0d4AuJ402hueI4Pj4Mf4oVlKY4DgCmxjLjGZniOApY2qTMAhItcOCgmkwExbGSta33TeI1\n", + "7pkofzdwaOLBvS2xzQhWyr4Z574nse+xwO9TXria4jiAoBD2JqEICS/Ii8DfJdadWKuzeIz5iW3j\n", + "4jW8KkOmx4ETE8vvBBbE3xey7sfmEda+JPUfubzPUtZx3xqvt75ePgl8J1HnP0ts2wVY2eB+rxfv\n", + "2QPAnAbljgZ+XbfuNuCf4u9LiQo1Y//fx+vdtMnz9/9IfAgJH+K/ApMy6nTYeQmt/uT2bQgfz9Gx\n", + "nn6Ucd515Ge44jgB+EXiOX6y9hw3k7nJ9b4iPn+bJOS4uO55ezj+PobE+xTXLaKx4kh7//ZJXN+x\n", + "ie2nExVBYt3ceN7tCB/ssYlt3yfF4oh1/hKxl6TueNNYV3E0umdnEpVI4n19kQaKoxc+jsPcffP4\n", + "914Ad19IeAj+nqBl/wtYYmavJbzIN8f9tyHcxBpP5jqp+zLgG4SWvmeUeTCe94ysMgBm9s2Ec/+M\n", + "lCLPAuPNrFHdTiC85DWejOuGjuHxDhJathBaxyTWbZxYfipxHR6Xt4nyHmNm95jZCjNbAbwO2DKx\n", + "b6YTzd1/Sai3fweeMbOLzGwTgnIdk3INExPLTyeOszL+TMpcT/19rdXH9sBpNfnjNWzL8PpKypz3\n", + "Wco67jZx24S6bZ8k+KtqJO/HSmDDrHvu7msISmsqoTWXxQTWfaZ/n3WtKbyP0F31RAwMeVNGue2B\n", + "8xLX9mxcPzGjfD07AD9O7P8QsAbYilCHj+U8Tj3XAW+OATNvBV529/9uVWYzG2VmXzKzBWb2Z8LH\n", + "G8JzWyPrfZpA4n2KNHM0p71/yXuW3H974PC6Z2sfQnfSBGCFu69KlE++Y0kmAcvd/c9NZKuxA9n3\n", + "bJu6a1jJ2vpNpZ/CcW8GDid0QSyJy8cSui7ujWWWErRyjeTvZnwZ2B94Q4Myswh9sZkvkLt/2Nc6\n", + "97+UUuR2grZ+T4PzLCHcyBrbxXXtMqn2I368tiV8LLcHLiZ0RW3h7psT+uOTzuRMJQng7he4+xsJ\n", + "rerXEvwIfyS0jOqvof6Fa4X6+7o4/n4S+HyisbG5u2/s7tc0kD/Ps9TouE8SLMDktk3d/ZAG58zE\n", + "zCYSWnXfAb5qZutnFF1M+LAk2Z61ddEQd7/b3d8NvBL4T4IfJo0nCRZe8vo2cvdf5zlP3H963f7j\n", + "Yl0vIlh9qSI2kX8FoV//CEI341VtynwUIRDlQHffjNDVCPmCKJYw/H2y5HIGqe9f8tLqruPyuuvY\n", + "xN3/lfB92zwZ4Um4/2n1tgjYwsw2S9mWVr7RPVtadw3jGN64XId+UxynALXQvHlx+ZZE6/ta4Fgz\n", + "2zle3KwcxzWAqJm/QjAVU4mt1WsYQYRVPM+ZwL+b2WFmNs7MxpjZO83s3FjsKuAzZjbezMbH8pe3\n", + "e07gDWb2nhi18VHgBYLDbyPCQ7QMGGVmxxEsjlyY2RvNbG8zG0NoVb8AvOTuLxPuxefNbOOooP4P\n", + "oa+4HQz4FzObaGZbEPqva4rhEuDDZraXBTYys38ws1oL8RnW/VDleZYaHfdO4Hkz+4SZjTWz0Wb2\n", + "OjN7Y0LefBcWPjyXAd9y9w8RXtKzM4rPAV5rZkea2XpmdgTwdwSrqeF54zN2lJlt5u41x+hLGcW/\n", + "CXzKzHaJ+25mZoc3uoyU/b9gZtvF/V9pZrWIwe8Dbzezw+M1bGlmu8dtzwDNcq6uJDjT3xd/tyPz\n", + "xoTG23Iz24jgg2p0PUnmAFMT79MMgjXQiKz3L40rgHeZ2UHxudowhs9OdPffE7o0Pxfv576EAI51\n", + "cPelhO67/zCzV8TytXyYZ4AtzWzTxC6N7tkPgUMs5O+sT+iZaagb+klx/Ipww2sv+60EZ+JQjLe7\n", + "zyVEI/2SEGH0C5q3/pLbzyOYZ432OYvQx9dSq3LYCd2/CnyM4Fz9A0Hbn0xwJkNwlt5NcAjfH3+f\n", + "kyFz2nL9tp8QWmnLCa2t97r7S+7+EEFZ3k7oOnodwfGc3DftXLV1mxIsluUE/9QyguUGcCqhS+gx\n", + "4BbCB+PSJsdtdA3fJ7Q2FxKcoOcAuPtvCFbgN6Ic8wn9wTW+SFDCKyyEQUO+ZynzuFExHkLo7nqM\n", + "YGFdHOuj1eubQegiqYWEHwccZyk5Pe6+PJ73NEJd/19C+PryBudN8kHg8dg9cyLhWVgHd/9P4Fzg\n", + "6lj2AUIgRBb15z0PuB74mZk9R3i+9orHXkToLjuN0N1xD7Bb3O/bwC7xXl2Xca7rgckEP+EDbcr8\n", + "PUIXz2KChX17nfyZ9y92ax8OfIlwDyYz/J2pJ/P9Sy3s/hTB0f8p1n4bTmPtt/gDBB/bckKD8rtp\n", + "ckaOJlj+jxCUxYx4jkcIjdPHzGx57PprdM8eIvRKXEmwlJbTpHvO1jbAOo+ZfQf4B0Ly0K4ZZc4n\n", + "OKdWEpxI9xQmUAkxs1nAZHc/uteyCFE1qvr+FW1xXEoIWUzFzA4mVPoUQgvpwoLlKSNVSX4Toh+p\n", + "5PtXqOJw91sIYbdZHEo0xdz9DuAVZrZVkTKVkGbdF0KI4qjk+9frFPiJDO9Le4oQkfBMenFRj7t/\n", + "rtcyCFFVqvr+9YNzvN7Uq5z2FkKIQaLXFsdihsdIb0tKzLqZSZkIIUQbuHvH/TC9VhzXE+Lrr7aQ\n", + "5fond0/tpiri4gcRM5vt7rN7LUc/oLpYi+piLZWsC7MphATTfeOaK4CZ1iQDvF0KVRxmdhVhwK3x\n", + "FsaHn0UYqgJ3v8jd55jZwWa2gJATcFyR8gghxCARI09nEAYgfYEwT8qcRIFRcfsXCLlKTwMnEeZR\n", + "gYLmfCpUcbj7kTnKnFKkDEIIMYhEpXEeIQmxxo5mhrvPybIyWJswWhi97qoSrTOv1wL0EfN6LUAf\n", + "Ma/XAvQR83otQIeYwXClATB5FJxKGLQz3croAoVmjncKM3P5OIQQ/UjT7qT2jzuP0NU/xGTgWvjz\n", + "HmEODmhiZRT17ZTFIYQQbdK0O2lkvDB0HtY6MsYFpdF1KyNJP+RxCCHEoJLanUQYBHSknA8smEwY\n", + "7vnrhNFX54dBXqf2SmmAFIcQooLEaM65Fia8mhsth3bYMGP92HZlq+Ew90b45QPw8n7As/DixXDW\n", + "FPcDu+EAb4S6qoQQlaLD3UsvZKxflbE+n08kRkwdlIiY2hJmnthjhVFDikMIUTUadS+1qjjOJ0wk\n", + "ljzeQuCCtMIZSms/M1sILFkfLngRptDDiKk8SHEIIapGx7qXYhIzBKUzkTB/90pgRs2CqbMwpjJ8\n", + "7nMIrotdJ8Ou3w9RVDX5upaX0SpSHEKIqpHVvTQ1hsC2FFKbUB7nEZTCeGBXQvfXnoSZGestnCHq\n", + "IqY2fBZe3BLe329WRhLlcQghKkVGd9Fq4nBIkQXAzLzKw8zmkj6V7TLWtTCGmExI/d4vLl8OfBxu\n", + "fdp936x9WkF5HEII0QHqupfGkt591KrPI6v7a0zayjorg6XAScANYfPzOc/ZM6Q4hBCVI1oScwDM\n", + "7H7SrYKJLRwyq/trdf2KycB34aW3wGgIVsZMhqZKzXSs9xPK4xBClJac+RrbZOyetT6N8wndW0kW\n", + "At8gGBQYQUHcB7wFRv8R1hwFC4+Bu1eEHL+5wIxODFdSNLI4hBClpIV8jaWkWxxL854rpftrFXBB\n", + "XP+uybBNvS9jJqy3IoTyLgBmDYLCqCHnuBCilDRwWM9193e2Wi6WbW1AQ7NRn4WnPgnbpPgykiwH\n", + "7mp6vBaRc1wIIVojb75GriS+ljPOY/b32bHLq86XUc8WBOXVqQESC0WKQwgxkORo/ecaDqRRN1Pd\n", + "fvkyzutm5fsjrDkB1kuxMtJoN4O9q0hxCCEGjpyt/9zDgSSjrBqQacHUlNhusPn3YMrusHncdsVu\n", + "MOFpOKDJsYcdr4WyPUGKQwgxiDRt/bdgSWSSMlxIGhNHwQ9OhXG1vIw/wEv/CZ8/0X3W0+EYb4qb\n", + "8pA5QGK/IMUhhBhEcvkvcloSqd1ecVOzDPOlU2DSt2GDuoip0StgrxMZUmALCcOQNGMg8jikOIQQ\n", + "g0jLw5lnkdXtBTzHulbNGMIwIg+OglWfhqlnwAYZEVNJJbaExorjZeAxWhjmpJcoAVAIMYhkJdy1\n", + "01rP6vbaIaP8gw7//BJsfBZMGkewMqayTphtUomlyZvMhRiob7EsDiHEwNEJ/0WCrG6vdfIfDDgb\n", + "XkVIAB/7LLx4HGyQEjH1MvBKMzvY3ecUND5Wz1ACoBCi0jRIALwbeAXRGpkMXAEv7J2YL2NPuOFu\n", + "+DzZw6anjrIbh29/W0r5m919WssXkUFR386BMo+EEKIAsrq9ZgEzR8Hcz8HCB+DlqDSeBg7D/ei7\n", + "3K8l5PXNJT23r2ZF1LNxhix9H1EF6qoSQlScht1eIft7Y4KzHBKz8qVEYj3F2vyNJMMiveJ+E1LK\n", + "LWUAIqpAikMIIdYN2zUbhdlHyZj7OyMSa2XG4eutiBmkj7y7ZBAiqkCKQwghhhPHmAJqs/Clzf2d\n", + "Fok1jqA8kol+aZFeWc74v7Qlbw+Q4hBCDCx5RqvNPaJt3RhT1FkZdWR9/BcCi2kc6dWxHJReIcUh\n", + "hBhIGo1XFZlB8CXsyHAr4K1m9hBw5tBHPZ+VkSTr47+4fij2FHKPodWvKBxXCDGQ5A2jbcCC9eGj\n", + "L8IU8lkZyXOnKa2F5JzBL+7fiRyUZucp5NspxSGEGEga5EKsID26aRiTgR/CiuRItjS2MurP35WP\n", + "/0jQRE5CCDGcrO6ihq1hY60jY1xQGrmsjHVOknMAxTKiBEAhxKCSlbj3RNYOk4Gbga8TnB5zwuCD\n", + "U9OUhpkdbGZzzWxe/H9wxyQfcGRxCCEGkqzEvbh5mP9hFLw4E0afA+vVRrL9KCy9Fv7ZU7qmWp4m\n", + "tmLIxyGE6Bh1oa8bE3qGnqdRGGxxcpwKjP17sBthy1fFiZhugGdOhN89DV/NkqeB431ujqipvmEg\n", + "fRxmNp1gFY4GvuXu59ZtH09wSG0dZfk3d7+sSJmEEMWQ0UpP0laLPSsPI7F+AiETeymh6+n8OFzI\n", + "XFLyMt7lfv3S5qfNNVFUVSnM4jCz0cCjwNsJCTF3AUe6+8OJMrOBDdz9k1GJPAps5e5r6o4li0OI\n", + "PqdBKz1JSy32DGW0gNDg/CDpSmrlNPjWTfB68udl1J9XFkcDinSO7wUscPcn3H01cDVwWF2ZpcCm\n", + "8femwLP1SkMIMTBktdKTtNpiz5pk6ZSU9RgwE8b9NOy3L4mRbPMqjUgnJ4oqHUV2VU0EFiWWnwL2\n", + "ritzCfBLM1sCbAK8v0B5hBDFkhUem6TVYTWylNGY+hWTCanftbm/58CSg2HXFhUG0PGJolLJPRRK\n", + "H1Kk4sjTB/Yp4F53n2ZmOwI/N7Pd3f35+oKxW6vGPHef1xkxhRAdIm0ojSTttNizlNHq2o+6vIzk\n", + "3N/z0yKm8lJknkZRUVtmNg2YNjLpmlOk4lgMTEosTyJYHUneQpg9C3dfaGaPAzsRhgwYhrvPLkZM\n", + "IUQnSGmlb0T4rv+F9lvsWeM6XQ6cPhnGJq2MywmzKsUZlfp50MCsLrgRTR0bG9TzastmNqvdYzWi\n", + "SMVxNzDFzHYgRDocARxZV+YRgvP8VjPbiqA0HitQJiFEgXS6lZ7ZZQRzz4QPnQHb1lkZNfrWHxGt\n", + "jb0yNg9E1FZhisPd15jZKcCNhHDcb7v7w2Z2Utx+EcG6vNTM7iM46j8xEtNSCJGPQepfT5lkaQpw\n", + "81mwLaRaGQ8Cs/rxehJdVFljafWzlTSEEgCFqBgNQlxn9uPHdoiU+TIuhotPCq33dRzY/agcm4Qs\n", + "5x5dt4XzaXTcXsshRBloJ0eh5x/hFufL6Ffl2GBE3+XA0Z2WbRDzOIQQ/UlLWdGJj/A7CB+9dwDn\n", + "dWXQv7Vzf98H7PsCrDgOfmswyeDKBjI0cj73kqwosTt7bQ21ggY5FKJ6tDp1aSERQE2pszLmwy/f\n", + "AjssCxnhNbJCWPt1yJCBn/0PZHEIUUVuB1bWrWv08eruR7jOyiBmf78WVi+D19SVzrIi+nJe76jg\n", + "ZgJzCSO8z6XDfo1uIItDiAoRu3Y+yPA5uFcClzf4eHXvI1xnZVwHfzoRxjwL5xCjqFJIU2Bdb9nn\n", + "9QOVYQIoKQ4hqkVat9M44E0N9in+I1wXMfUHeOlDMPqGMHc4wJYN9l5HgXVjyJAkVZu/Q4pDiGrR\n", + "crdT4R/hOivjp7DkaJiwIt/emQqsyy373viBeoQUhxDVoq1up0I+wil5GcBJh8DHCHNsZLEceIAw\n", + "URTAJ8xsBr3N0+hXZ3whSHEIUS36I6qnUV6G2clN9r6TIG8/dQ31pTO+KKQ4hKgQ3e77X4cMKwP3\n", + "6xOlGo2yW1Ny/dY11B8KuUsoc1wI0R1ayP5OzBk+kbXTwi4mKrkGGdg3u/u0zgvfnOQ853RbIWfL\n", + "pCFHei2HEKIN8lkZLR5yZFO79nwIlS5R1LdTXVVCiOJocYypFmi7a6hqobNFIItDCJGLllrpBVgZ\n", + "GfK03DU0UmtlkJDFIYToGS210ouzMoYxghDhSoXOFoEUhxAiD82jmFq0MtIsmMS5ivQ9VCp0tgik\n", + "OIQQeWjcSu/MfBm7Ac7w5L9hVs1InNqJfScQxudKjtdV2tDZIpDiEKJHDFhkT2orfRSsiiPZturL\n", + "SLNgtkkpN2TVtOrUrqvfTYCtGa6UVhIUxlCYbxOZ12HA7mHHkOIQogcMYGTPOlFMO8OT82AS8LW4\n", + "qhVfRpYFk0bN95A76S+jfusZByxu1yE+gPewY2g+DiF6Q7/OUJdKch6JUXDzOfDwA7DVq2Aqcb4M\n", + "3I/GfbmZHWxmc81sXvyfNktflp8hjZrvoRWndlr95t03LwN1DzuJLA4hesPARfa4+xzM5hN8GTvH\n", + "1cOsjBZa4Wl5GEtZ18eR9D204tTOa9GMxCE+cPewU0hxCDFC2uznHqzInvwRU7m6k7LGzIqbs3Iz\n", + "Wkn6y2PRjNQhPlj3sINIcQgxAkbQzz04g+K1FjGVuxXeIA8jtd5aHKAxy6JZDPy1yb55GZx72GGk\n", + "OIQYGW2N0trzUWrz0F72d6Gt8LxJf92o34G4hwWhIUeEGAH9OEprR2gz+zvDAlsIzKjCB7Xf0JAj\n", + "QvQn5ernHuEYU1VuhVcJWRyiY1QxGarbLexC67hLY0yJ7iGLQ/Q1VU2G6mYLu7A67sJItqJcyOIQ\n", + "HaFKQ1X3ilbrOJd1Iiuj1MjiEP1OZZOhukjuOm5mnWxg9g9nwr+dBq/dEEa9ACs2hGNlZTSnil2y\n", + "9UhxiE5RLidxf9JKHWeGCf+T2YRb4IK9oiK6HPgYrFgGa/q//6G3VLVLth6NVSU6xfnAgrp1lUiG\n", + "6iKt1PE61okBn4MpF8FFe8GGS4FDgWOAZfAaKjDGUgeo7PhUSWRxiI6gMMziabGOh1knkwmOjP1C\n", + "pjOXE0YsXDF8n5a7FSvYbaMuWaQ4RAcZwVSeIict1PH5wI4Gk2vhUuOAF2DFR+Dxy+D1Kfu01K1Y\n", + "0W4bdcmiriohSom7zzkGzr0HVnydoDTmwy83hMmXwWfpTLdiFbtt1CVLwRaHmU0Hvg6MBr7l7uem\n", + "lJlGmAhmDLBsoIdpEKIfiHkZ363Ly5gSI6Y8zKYHI+9WrFy3jbpkA4XlcZjZaOBR4O2EESnvAo50\n", + "94cTZV4B3Aq8w92fMrPx7r4s5VjK4xAiD13My1DuTv9T1LczV1eVmY0zs51aPPZewAJ3f8LdVwNX\n", + "A4fVlfkA8CN3fwogTWkIIXJgNirO/X0fQWkMm5WvoLOq26aiNFUcZnYocA9wY1zew8zyJAlNBBYl\n", + "lp+K65JMAbYws5vM7G4zOzqf2KKK5JyStHoEK+NmQpfvWIKVMTVvMl+79ZqcTjaefy4aBbcS5PFx\n", + "zAb2Bm4CcPd7zOw1OfbL0wc2hhDdcSDBf3e7mf3a3efn2FdUiIpG8DSmA2NMjbReFUlXTfIojtXu\n", + "/qfoEKrxco79FgOTEsuTCFZHkkUEh/gqYJWZ/QrYHVhHcZjZ7MTiPHefl0MGUR7amjCptHTOl6F6\n", + "LREx2Gha0efJozgeNLOjgPUsPKwzgNty7Hc3MMXMdgCWAEcAR9aV+QnwjehI34Bg2Xw17WDuPjvH\n", + "OUV5qVwETyqdH8m2Y/VawWTAviM2qOfVls1sVhHnyaM4TgU+DbwIXEXwdZzdbCd3X2Nmp8Tyo4Fv\n", + "u/vDZnZS3H6Ruz8SIzPuJ1gxl7j7Q+1diig5SrxqYGWM4KPdkXpVV2K1aBqOa2avd/ffdkmeLBkU\n", + "jltxKj0laRMrI6NuFgAzs+omoWgmEIYhGZfY3HK9KjS3P+nlsOpfNbOtgR8A17j77zothBDNqGzi\n", + "VT5fRkt+igxFs5KgMBajZEDRhKaKw92nmdk2wPuBi8xsU+Bad2/aXSVEJ6lUBE9rvoxWP9ppimYc\n", + "sHgE1oG6EitErgRAd1/q7ucBHyYkGJ1ZqFRCVJnW8zJa/WgXYR0oGbBCNLU4zGwXgrXxj8CzwDXA\n", + "xwqWS4jq0X7E1PkEP0W9/yfro91x66CyXYkVJY9z/NeE4UJ+4O6LuyLVujLIOS7KzQjzMqLfItdH\n", + "u9KBBhWjqG9nYYMcdhIpDlFaOp+XkfO02YpG+RjloeuKw8x+4O6Hm9kDKZvd3XfrtDBZSHGIUtLF\n", + "kWzzi9R6aK/oX3qhOCa4+xIz254wXXESd/ffd1qYLKQ4RKnokZWRB+VjlIuuD6vu7kviz5Pj0OhD\n", + "f8DJnRZEiEowwpFsu4DyMURT8oTjHpSyTsNZC9EKvZkvox2UjyGakhmOa2YfIVgWO9b5OTYhzNon\n", + "hMjDCHwZPXBUtxraKypIIx/HZsDmwJeA01nr53je3Z/tjnhDssjHIQaPEfoyeuWobiW0V/Q3PQvH\n", + "NbM3Aw+6+3NxeVNgZ3e/o9PCNJBBikMMFh2ImJKjWoyUXs45fiHwl8TyX4FvdloQIUpBZ30ZclSL\n", + "viTvWFUvJ36/RJhfQwiRpPMRU11zVGs+d9EKeYZVf9zMZhAsDwM+AjxWqFRCDBLF5WU0dFR3ynGu\n", + "SZhEq+RRHB8mPMCficu/AE4sTCIhmtBXQ2IUn/39Z2A5odH2GHBmHFCwkx97zTsuWiLPfBzPEOYL\n", + "F6Ln9E0jg0nbAAARU0lEQVTruODs74zr3Czxu5Mfe/lSREs09XGY2U5m9gszezAu72Zmn2m2nxAF\n", + "0eiD2R26k/3d7Do7+bFX0p9oiTzO8UuATwF/i8sPAEcWJpEQjeld67i72d/NrrOTH3tNwiRaIo+P\n", + "Y5y73xEnacHd3cxWFyuWEJn0pnXc/ZFsm11nxzK8NQmTaJU8iuOPZjb0cJrZPwJLixNJiIZ0d0iM\n", + "3o1k2/A6O/2xr9R87mLE5Mkc3xG4GHgz8CfgceCoOEpuV1DmuEjStSExejxfhob+ECOlF/NxzHT3\n", + "88xsX3f/bzPbGBhVG3qkm0hxiK7Sx/NlCNEKvVAc97n77mZ2j7vv0ekTt4IUh+gafTgrnxDtUtS3\n", + "s5GP4yEzmw9MTJk+tqtTxwpROBW0MvoqkVIMFJmKw92PNLOtgRuBQ1l3+lghykEFrYy+SaQUA0mj\n", + "iZx+4e4HmtmN3ZxfXIiuUUErI4GGGRFt06irahsz2wc41MyuJlgcQw4Rd/9t0cIJURgVtDLq0DAj\n", + "om0aKY5ZwGeBicBXUrbvX4hEQhRJta2MJBpmRLRNnjyOM939rC7JkyWDoqrEyJGVMUSGj2MhMEM+\n", + "jvLQy6ljRwFHAa9297PMbDtga3e/s9PCNJBBiqNCdDzaR1ZGKkowLD+9VBzfBF4GDnD3vzOzLYCf\n", + "ufsbOy1MAxmkOCpCRkt4ATCzrY+arAxRYXo55/je7n4yse/Twws3ptOCCBHpzLDp3R3JNp5S06+K\n", + "apBnkMO/mdnQHONm9kqCBSJEEYw82qcHVobyIkSVyGNxXAD8GHiVmX0BuBX4YqFSiSrTfrRPD6yM\n", + "BL2fYEqILtFUcbj7FcDpBGWxBDjM3a/Nc3Azm25mj5jZfDM7vUG5Pc1sjZm9N6/gorS0N6lQd2bl\n", + "a4TyIkRlyNNVhbs/DDzcyoFj99Y3gLcDi4G7zOz6eKz6cucCc9GwJpWn5Xkm+idiSnkRojLkUhxt\n", + "shewoDZvR8w+P4x1FdCpwA+BPQuURQwQuScV6q+Iqe5OMCVEDylScUwEFiWWnwL2ThYws4kEZXIA\n", + "QXE0jg0WAvrJyhhC06+KKtFUcZjZLu7+UN26ae4+r8mueZTA14Ez4jzmhrqqRDP6y8oYhqZfFVUh\n", + "j8VxrZldDvwroSV1LsE6eFOT/RYDkxLLkwhWR5I3AFfHltp44J1mttpTWo5mNjuxOC+H4hJlog+t\n", + "DCH6DTObBkwr/Dw5Msc3IiiLNwIbA1cCX3L3hrkcZrYe8ChwICEa607gyHrneKL8pcAN7n5dyjZl\n", + "jleZPrYyhOhnepk5vobQXzuWEHL4WDOlAeDua4BTCBNBPQRc4+4Pm9lJZnbSCGQWVaG3eRkDhbLW\n", + "RTfJY3HcB1wPnEXoTroIeNHdDy9evCEZZHFUDVkZuen4+F6iNPRykMM93f2uunXHuPv3Oi1MAxmk\n", + "OKpCl3wZZZpv28zmAu9I2TTX3d/ZbXlE/1DUt7Opc7xeacR1XVMaokJ0ycoo4bhSyloXXSWPj0OI\n", + "Yum+L6Ns40opa110FSkO0Vt6M8ZU2Vro7Y3vJUSbFJk5LkQ2vc3LKFULXVnrots0dY73A3KOl4we\n", + "R0xl+DhWElrpSxhgR7kQSXrmHBeiY/RJ9nddC30iYXDCccCu8W+QHeVCFI4sDtEd+jQvQ6Gsosz0\n", + "MnNciPbp/+zvsjnKhSgcdVWJ4uhTK6OOUjnKhegGsjgqSOHjGvW/lZFEoaxCtIgsjopReNb0YFgZ\n", + "QyiUVYjWkXO8YhTmDO6TiCkhxFoUjis6ReedwQNmZQghRoZ8HNWjc87gwfJlCCE6hBRH9eiMM7g3\n", + "Y0wJIfoAdVVVjBE7g+XLEKLyyDku8iNfhhADhTLHRe+QL0MIkUCKQzRGvozKUXiCqBh45OMQ6ciX\n", + "UUlKOK2uKABZHC1SidaYrIwqU7ZpdUUByOJogdK3xmRlCI0WLHIgi6M1ytsak5UhAhotWDRFiiOS\n", + "swuqfK0xRUyJ4Wi0YNEUdVXRUhdUuVpjBeZlxDqdQVC2L6B5vAcCjRYs8iDFEWjUBZV8Yc4nzE+d\n", + "LDt4rbGCfRml9wWVnHiPdJ9EJlIcgVxdUKVojXUn+zuvIhZCDCBSHIHcXVAD2xrrbsRU+XxBQogh\n", + "5BwPlNsh2P2IqXL5goQQw5DFQUm6oNLoXV5GOXxBQohUNDpuWenxSLbRQV4uRSzEgFHUt1OKo2wM\n", + "UPZ3ImR3ArANsBRYQg9CdxU+LMqI5hwXzRmg+TIyQnbHA7vS5dBdhQ8L0RpyjpeBwcz+TgvZrdHt\n", + "YVzKO5SMEAUgi2PQGSAro46skN0a3QzdVfiwEC1QuMVhZtPN7BEzm29mp6dsP8rM7jOz+83sVjPb\n", + "rWiZSsFgWhlJskJ2a3QzdFfhw0K0QKGKw8xGA98ApgO7AEea2c51xR4D3uruuwFnAxcXKVMpKMdI\n", + "tmm5MzW6Hbpb7jweITpM0V1VewEL3P0JADO7GjgMeLhWwN1vT5S/A9i2YJkGlwGKmKonLWoJmEnw\n", + "I0xkbVTVYroculvaPB4hCqJoxTERWJRYfgrYu0H5ExjE4TxyMOJwz8H1ZWRGLQEz3f2dvZFqOAM7\n", + "lIwQPaBoxZE7ScTM9geOB/bJ2D47sTjP3eeNSLIuMqJwzwG2MhJo0EMhuoCZTQOmFX2eohXHYmBS\n", + "YnkSweoYRnSIXwJMd/cVaQdy99lFCNgl2vtwDrCVUYeiloToArFBPa+2bGazijhP0VFVdwNTzGwH\n", + "M1sfOAIY1lI2s+2A64APunuWs3TQae3DOfgRU/UoakmIElGoxeHua8zsFOBGYDTwbXd/2MxOitsv\n", + "As4ENgcujA7K1e6+V5Fy9YD8H87yWBlJNOihECVCY1V1gQwfx0JgxpCPoxy+jEw06KEQ3UeDHA6w\n", + "4oAmH85yWhlCiB4jxTHgiiOVklsZQojeotFxy4asDCHEgKLRcbtN+SKmhBAVQxZHN5GVIYQoAbI4\n", + "uoGsDCFEiZDFUTSyMoQQJUMWR1HIyhBClBRZHEUgK0MIUWJkcXQSWRlCiAogi6NTyMoQQlQEWRwj\n", + "RVaGEKJiyOIYCbIyhBAVRBZHO8jKEEJUGFkcrSIrQwhRcWRx5EVWhhBCALI48iErQwghhpDF0QhZ\n", + "GUIIsQ6yOLKQlSGEEKnI4qhHVoYQQjREFkcSWRlCCNGUUlscZnawmc01s3nx/8EZBWVlCCFETkpr\n", + "cUQlcR4wObF6RzPD3eckCsrKEEKIFiizxTGD4UqDuHwqICtDCCHapLQWB7BhxvqxsjKEEKJ9yqw4\n", + "XqhfYcDZ8CqClTGWYGWchPv1XZZNCCEGljJ3VZ0PLKgtTAZuhxc+DTsTlMYVwFQpjbXkDiYQQlSa\n", + "0loc7j7HzBgFp86CKZ+AV28Yuq9kZaSQO5hACFF5Sqs4ABzmAxsDO8ZV8mVk0yiYQIpDCDFEObuq\n", + "FDHVDtnBBEIIkaB8FociptplnWCCyKquSiGE6HvKY3HIyhgpw4IJIguBC3ogixCijymHxSErY8TU\n", + "ggkIPo2xBEvjAjnGhRD1mLv3WoammJm7u6VsGEVw6n4B5WUIIcQwMr+dI2RwLQ5ZGUII0RMK9XGY\n", + "2XQze8TM5pvZ6Rllzo/b7zOzPXIcVL4MIYToIYUpDjMbDXwDmA7sAhxpZjvXlTkYmOzuU4ATgQub\n", + "HHQKcDPwNSqa/W1m03otQ7+guliL6mItqoviKdLi2AtY4O5PuPtq4GrgsLoyhwLfBXD3O4BXmNlW\n", + "qUeTlVFjWq8F6COm9VqAPmJarwXoI6b1WoCyU6TimAgsSiw/Fdc1K7NtxvEqa2UIIUQ/UaRzPG+4\n", + "Vr3HP2s/RUwJIUQfUKTiWAxMSixPIlgUjcpsG9etg8HWwE+wjkeWDRxmNqvXMvQLqou1qC7Woroo\n", + "liIVx93AFDPbAVgCHAEcWVfmeuAU4GozexPwJ3d/pv5ARcQhCyGEaI/CFIe7rzGzU4AbgdHAt939\n", + "YTM7KW6/KGYrH2xmC4C/AscVJY8QQojOMBCZ40IIIfqHvhrksJCEwQGlWV2Y2VGxDu43s1vNbLde\n", + "yNkN8jwXsdyeZrbGzN7bTfm6Rc73Y5qZ3WNmvzOzeV0WsWvkeD/Gx1ks7411cWwPxOwKZvYdM3vG\n", + "zB5oUKaz301374s/QnfWAmAHYAxwL7BzXZmDgTnx997Ar3stdw/r4s3AZvH39CrXRaLcL4H/At7X\n", + "a7l79Ey8AngQ2DYuj++13D2si9nAF2v1ADwLrNdr2Quqj/2APYAHMrZ3/LvZTxZHZxMGB5umdeHu\n", + "t7v7n+PiHWTnvww6eZ4LCKP6/hD4YzeF6yJ56uEDwI/c/SkAd1/WZRm7RZ66WApsGn9vCjzr7mu6\n", + "KGPXcPdbgBUNinT8u9lPiqPTCYODTJ66SHIC5Z3etWldmNlEwoejNmRNGR13eZ6JKcAWZnaTmd1t\n", + "Zkd3TbrukqcuLgGmmtkSwogTM7skWz/S8e9mP42O2+mEwUEm9zWZ2f7A8cA+xYnTU/LUxdeBM9zd\n", + "LUwqUsbw7Tz1MAZ4PXAgMA643cx+7e7zC5Ws++Spi08B97r7NDPbEfi5me3u7s8XLFu/0tHvZj8p\n", + "jo4mDA44eeqC6BC/BJju7o1M1UEmT128gZALBKE/+51mttrLNcpAnnpYBCxz91XAKjP7FbA7UDbF\n", + "kacu3gJ8HsDdF5rZ48BOhPyyqtHx72Y/dVUNJQya2fqEhMH6F/964BiARgmDJaBpXZjZdsB1wAfd\n", + "vX7K1zLRtC7c/TXu/mp3fzXBz/GRkikNyPd+/ATY18xGm9k4giP0oS7L2Q3y1MUjwNsBYn/+TsBj\n", + "XZWyf+j4d7NvLA5XwuAQeeoCOBPYHLgwtrRXu/tevZK5KHLWRenJ+X48YmZzgfuBl4FL3L10iiPn\n", + "M/EF4FIzu4/QQP6El3QkbTO7CngbMN7MFgGzCN2WhX03lQAohBCiJfqpq0oIIcQAIMUhhBCiJaQ4\n", + "hBBCtIQUhxBCiJaQ4hBCCNESUhxCCCFaQopDiA4QhzO/If5+V5Ph3zczs4+0cY7ZZnbaSOQUohNI\n", + "cQjRADNr+R1x9xvc/dwGRTYHTm5DHCVdib5AikOUjjih031mtoGZbRQn8tmlrswOcSKgK8zsITP7\n", + "gZmNjdueMLMvmdlvgMPN7CAzu83MfmNm15rZRrHcdDN7OJZ7T+LYx5rZBfH3Vmb24zih0L1m9mbg\n", + "S8COccKlc2O5j5vZnVHu2YljfdrMHjWzWwjDZgjRc/pmyBEhOoW732Vm1wPnAGOByzOG3ngtcJy7\n", + "325m3yZYAV8htOyXufsbzGw88CPgQHdfFbugPmZmXwYuBvaPg+hdQ7pFcD5wk7u/J1ovGwOnA1Pd\n", + "fQ8AMzsImOzue8UyPzGz/YCVhHGYdicMIfFbqjlIn+gzpDhEWTmL8JFdRZjkKY1F7n57/H0FMIOg\n", + "OACuif/fBOwC3BbHBFsfuI3Q+n/c3Rcm9j8x5Rz7Ax8EcPeXgefMbIu6MgcBB5nZPXF5I8LcGpsA\n", + "17n7C8ALURmWcch4MWBIcYiyMp7wAR5NsDpWppRJWghWt/zXxO+fu/sHkjua2e51x2r0Qc/zsf+i\n", + "u19cd46ZdftKaYi+QD4OUVYuAj4DXAlkOaq3i8NMQ5h29ZaUMncA+8TJgIg+kymEYbt3MLPXxHJH\n", + "ZpzjF8BH4r6jzWxT4HmCNVHjRuD4hO9kopm9EvgV8G4z29DMNgEOQQ5y0QdIcYjSYWbHAC+6+9UE\n", + "R/SeZjYtpeijwL+Y2UPAZqRMPevufwSOBa6KQ3TfBuzk7i8SuqZ+Gp3jzyT288TvmcD+ZnY/oets\n", + "Z3d/FrjVzB4ws3Pd/ecEBXd7LHctsLG730PoMruPMDXwnSOsGiE6goZVF5XEzHYAbnD3XXssihAD\n", + "hywOUWXUahKiDWRxCCGEaAlZHEIIIVpCikMIIURLSHEIIYRoCSkOIYQQLSHFIYQQoiWkOIQQQrTE\n", + "/wAmaRXA5XjUcAAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEACAYAAAC08h1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4VUXegN9JryR0SEgoCT30jkoRISSosKjBrijYDbvu\n", + "qp/r6s3Vdd1V1xVwVURR1grYlSSISCjSpSYQSmgJNRDSezLfH3Muubmk94R5n+c8N/ecOXPmnAu/\n", + "mfOrQkqJRqPRaK4e7Bp7ABqNRqNpWLTg12g0mqsMLfg1Go3mKkMLfo1Go7nK0IJfo9ForjK04Ndo\n", + "NJqrjFoLfiHEEiHEOSHEvgraLBBCHBZC7BFCDKntNTUajUZTc+pixf8RMLW8g0KIUCBQStkTeAh4\n", + "tw6uqdFoNJoaUmvBL6XcAFyqoMnNwFKj7VbAWwjRsbbX1Wg0Gk3NaAgdvy+QaPU9CejSANfVaDQa\n", + "TRk0lHFX2HzXeSI0Go2mkXBogGucAvysvncx9pVCCKEnA41Go6kBUkrbxXWFNITg/wF4AvhSCDEa\n", + "SJVSniurYXUH35QQQkRIKSMaexw1oTmPHfT4Gxs9/salJovmWgt+IcQXwHignRAiETABjgBSykVS\n", + "ykghRKgQ4giQBcyu7TU1Go1GU3NqLfillHdUoc0Ttb2ORlNXBAkR6gfhnuCSAbmJsCBWysjGHpdG\n", + "01A0hKrnaiGmsQdQC2IaewC1JKaqDYOECB0D8xdDoGXfXAgIEoJGFP4xjXTduiKmsQdQS2IaewAN\n", + "jWgqhViEELI56/g1zYMQIaKjIHhzFzjWGu7Yp1zOQiE6UsqQxh6fRlNdaiI7da4ezVWFJ7gAuBTC\n", + "q9fCH26HMx7gAa6NPTaNpqHQgl9zVZEBuQBDzsKO92HAORj0KOwbTWthFvqNU3NVoAW/5qoiERbM\n", + "hSMAzkXw8loY/QVJhybgCfwozMK3kYeo0dQ7WsevueoIEiLUH570ANdMyDkJC+Mi+AV4DngceBb4\n", + "WJqayH8OjaYCaiI7teDXtDiECAoFv3DwdIGMXEhcIGVslTx2hFkMAj4GzgIPSZNMrPgMjaZx0YJf\n", + "c9WjhP6Y+bA4sGTv3COweV41hL8jatU/D/UW8KFe/WuaKlrwa656hAiJhqhgxr4Bl3rAmSGQ2g2Y\n", + "Fi1lZLXcNYVZDEDVm0gB5kiTPFkPQ9ZoaoUW/JqrHiHCYmDZeCaaoPNO6LQLnLIgxS4Nn0sfAbuM\n", + "LV6aZEGl/ZmFA/A08BTwN8z9EpH+NVIjaTT1gRb8mqueyyt+a9zPQ/cp27l1z9fAEGAw4A/sp2Qi\n", + "2A3skSaZVWa/ZtGPbPtvuNDOn282u5La3ThSPTWSRlPXaMGvqVeaQ46bsnX8cxJgS7i1cBZm4QEM\n", + "RE0ElsmgH3CS0pPBLmmSyQDCPngVo2+YwjWvwddfwNEbjN5Cq61Gag7PUtM8qIns1Ll6NFWiiea4\n", + "uQIpYyOFCAJCnwQPV8jMgZMLbVfk0iQzgU3GBlw26valZDIIBQYLs8gEduE9tTebnoZDN0FWB6ve\n", + "PKoV9dtcnqWm5aJX/JoqESJEdCQE/28Q3LYf3AzteEvPcWNE83YHhvD2ta9xYUOPKxp5TdjHn9bd\n", + "RRXtBpZ8QQfaQde0q+dZauoHveLX1BuWHDerAmFLF3h3pdrf0nPcGG6cR4GjIiIoB+aWViO53HOR\n", + "8XsuAV8BfsIsrO0Gu4C9tnYDy7N8Yyx81Q+uPwbTD4L9EVo10G1prnL0il9TJSyr1DRnGPIIvLkK\n", + "ZsRffatUZUPwL1ONVIbdYAhKdWRtN9g15WWeW1XERIAUV1jZE77vA98FUliUbx/Prq6O7AtM5bxd\n", + "al15DWmbQstFG3c19Ya1XnpzF5hxO0z4gONxqTyuBUj5lGE3GOIRz7Bp0Th/mVryxv2AHSciHb0+\n", + "Oddj+AME9vCh9w+Q1R4SSCHrvJnJ5xfWNIisHJvCkc0wT/92zR8t+DX1inWOm21T8UkKIqfIg6HS\n", + "JIsae2zNCWEWotsSZndL5QkXB9qmuuIady12GT3svTh9nQOOWWBXCEWO4JwB3ocKcSrKQyWXiweO\n", + "tN2IX7+djPYswi7Tjvz4/vx8/ga2A/lAntVn3pC3+fC6NPo6S5DFcFMxjOPqe1trqWjBr2kwhFnY\n", + "A79y3O0YH4/rpAOaao/wuvE32j85lt7fQcd90OYouF6EHLtcPHP3A05Ae4po438Y+do+nEKOQKs8\n", + "uNudjJXX83vqMFIAZ6Otc6t9dAhdTe8v0rn8f+t5IBh4G9Ytl3IC1C6/kaZx0cZdTYMhTbJI9PH/\n", + "kOnnl+AbYc+pUcaRuQFCBKGFRg1IL8ogPRgSrOLPnDKg68Td3PX7Z6hYgyFC0j7fF7unfODB6XDt\n", + "SZgej2fib8h1P8hbrLsMESL6C+hz1gP2dYCB5+CVLHgByIQcKDe/kf4dWzB6xa+pMUKERNN3TjCT\n", + "n4FFuyDP4pRS/YCm5oStoXQrnTdfYtCY2q6Wqxp8douDWPdiO8bt7gQjTsH+DvBdH1jWm8JCZ3YB\n", + "3/FT5xR2DJwxia2jfyHVa6svPDtZCX97CeI8xWmu/JDXiR/516S55Pwymm4x4HlKBaZldaQmv6N+\n", + "c2h49Ipf08B4unDgFghcBX2/ht2zjf3VC2iqS+pb8NgaSlfiwUbGXw9fOJa0qtlquarBZ9lF5Aw6\n", + "B4POqe/9LsCt++GCPWtWvcDrnHMOZ1xaKGOPOMTGe7EhPpWxiRDzMUjgtCeE+pFwPoxNwETayAGc\n", + "AuzzoN9XMO1xSPOHM2mDhVlMA2LKS2VhjX5zaEZIKZvEpobS+OPQW3V+s6nRICWiUIK02kKiGmc8\n", + "/UNhzuHSY5lzGPqH1tU1pkK0BGmagFw8FDnGabi6jkuKZMZ9kmGLJB32yVZiVPJtEDMVovtDnV1f\n", + "Skl/CJ0Dh60f+oNwxHId9bsUS8a8Lh3v7iq9H7WX7Z9Gzp6O/L438l5HEqzHdPl3tGx2BZIumyXT\n", + "ffKJoAgTxQ7PkNduNhcCxhPn34M7K/z34HpR0nOlxC25Uf89XC1bTWSnXvFrakHiApgbgLRVTZxc\n", + "2Djj8QuHxYE45MCQJVDsAMVjAnHZ+KowCy+gECgwPq3/ruzz8t+3CNyQ0D4LNvjD7jPucAaQ9pA4\n", + "Fvw2wdjXyXY73i4jifFjE+G30wT1bCvCD1+U39TFXcZKGRkkBKE2VcRKXDM9XUBA/EwKsttTWByF\n", + "X84aNvS4WPzVRCkywuiBPZ8Ks4gHNjK24162PdCfwiVdAPXckj5IIKl1eMDm024BXrzVMxDfjf60\n", + "PXwNbbMd+Uy8KJaS4ZLHmTYZnPRIRqQtRlznhgQ8zsCYf4PPDshuDxeyhgqzmAdsBXZLk8yti+eg\n", + "qTlax6+pFRUFNDX8WMJiYPl4nNNh0nNgX6DcIt2iz9H7zFrAEaXetHw6lLGvwjbD/4fb9qMltaqD\n", + "Gc7PbL9yMP0H4zp9Dz1TIMsJjraiWDqwF9hISY6gk/VR4KXMDKUAhEYTERUK9ATuQuUiGgCks98T\n", + "dvRpTYE7iJwsBh3cxbDU9X2imfFREgN7XoQ2OSCATzxcmd2/T35Rr7ZO+G5Tz7i4oJhtXQRbt4jL\n", + "eYxEEbSLh14zY5l86DdgFNALiAO2AVv5zseFPQNuQbYqpZrTAWdVR7tzaq5qKhJ4dWVsLkvHP4tp\n", + "hVl8efnt2V+E8XSrKDr6ZnLWA373gRX+ZGW3wQFIRr09tAVygQ3Gtgm1Gq40109lVNVIDCDMwhWY\n", + "BEwHbgYuAluA44BDp0M83MWdDofbwlvRcP9uq8lu5t1weigcmwhdf4M+f0vFN9uLS30FRycrI/Gl\n", + "xYVM+bmA3pl7gH2oOISCthsZ0TOOG53thHeWo72I7zaATHEjnN10uv357Z9Ov5g+UwecVQ0t+DWN\n", + "SmOv0qoj8GqDbbH2LXTeconBo8HD1YvE/p8R224amaXOCYXoqAhuBQYBw4xtNCoBXDpgB7ijVsO/\n", + "oCaDzdIkL5Y3hoqedU3exIzYjFHADGNz7RRL8f924j/uBDgUK4+gCYxnHS+B01fQ6gy4nwb3QXD8\n", + "1G8UHvon/h7PE5DWiW5nveiY4YIdvwMHgEuAd6t9XBuyhj5fppa8Oc1ybkdk74lkDrqEve8v0j8H\n", + "MSoJ7t4L0w6XPEMdcHYlWvBrGo2mkhagsVVPZT2HOZCwBcLLeg7CLNwomQxGA2MBP5SPvQtqBb4N\n", + "WAmsBw72jyCkvp+1kZW0j9txnnF15vYib1xCjsD0eHj4yKDctLxpLvBKyQnuc2DqV4UMSHsNeOty\n", + "DQOVv2gccAMwGfBtc4z8v8fR8YajEJjC5ciyEQSzg2iuF95pb7dN89rmCz4ZMPmoOh5mFXCmKUEL\n", + "fk2jYUnidv8McC6ETpnQMQveKWZX3E08CZwztsyWXrjc9o2gtOG1cozJYCAwAqWGGQF0BIoA6X2S\n", + "gmcO4TE2EcYkgZORMKO+VsRBQoS28+YvF4PwTepN69SOdu04OVkQPx0O3FJSm8DxhlieX7MRmAUs\n", + "Bd6QJnnK5t46D45kzSAf+q7uAf9YA/ftUcfUm0QMo/G+sJm0drbj0Cv+stGCX9NohAkRsxzGf99b\n", + "+Ymf84CzHvBNWy4kd+cw0AklvARwlpKJoNy/jWIpGi7r4gcB1w/4macne+D9mz+s/Aza5qg2M5zZ\n", + "+f1zXFPfXjPCdcYGetx1LX2+h50PwvGJxpGwdVIunyDMwgf4MzAbWAH8S5rkUYt6yh5G/gStJVBk\n", + "p1RIYFnxd0nozDefTOPS3VV9a7ra0YJf02hYVvy2+21Xacarv2USsGydyvi7EyreqLIJotqTRHOP\n", + "Li3vWY/2J2PrAzgAB4Hfrba9dTkZVNWILsyiHTAPeNTpInumLSfwm3P4rwdWUUpRxB245kQRGJdG\n", + "scni1VObt6arCS34NY1GdXXblWHomD2ofIKwnSQqfptYEDiIlAn/sokubVYF0yt61nERrEWpiYZZ\n", + "bb2AQ5SeDPbUdDKorhFdmIVXt81szx5Az2tPwuurIekSrAb2Q0oObNOCveZowa9pVBprlVbGJFH+\n", + "BFFo50+xix2ZneBCX/j8J6OX5pVfqDrPWpiFC1dOBr25cjLYK00ypyrXr64RPUyImI8dGb94KMw8\n", + "AH7pxn5tsK01WvBrNJUgxG0xOC0Zj8dZlev+zFDjiNJPN+bYGhJjMhgADKf0ZHCYK98MqjQZVERV\n", + "VYGa6qOTtDUDyvK/jqM/zVnn3LzIzCXfE1I8bffXWrg1Jww1z3ZjA0pNBpaJ4EGgjzCLI5RMBDuo\n", + "wWSQCAvmQoCteuokNFJ6j6sbveJvQMrSzd6POPMN18sMfvEpadm8dM7NiYYK8mopCLNwpvRkMAxV\n", + "StJ6MrC8GWSX248ICnWgw8uu2HdzJFP4ciChmDST1uvXHq3qaeJYXnd/6gU3HAWXQrV/BMHs8PwQ\n", + "8rwg38No3bx0zs2JhgryauxI5rriCi8o92Pv8PTB01w5GSRQejLYLU0yu5x0zVVa3LSUZ1ifaFVP\n", + "E8cTXFb2hEduhB3vqyAnAHdyIfjPcDgE9txntG68nPYtHUPY1KvwKCeSOSBICJqT4CoR2u8HXo6x\n", + "zZobQITDPCljF11up94MgiiZCO4D+gmzSOCO9m1IGOjDmU1wdjAUuKEmgdAnqeB3aCnPsCmiBX8D\n", + "cqojdg9Mh2+XlQh9gCxcwGc7xJisWl9dOueWhh+Evw+BpzzBN0PtWwyBoVChsGt6GKmux7wJnXbB\n", + "2pchdXEgTHkJq/uQJplHyUofAGEWTkAQiZ2+oEMsDF4KB2bChr8aLa5c3AizcABaAV4j/Xn+HkHg\n", + "j87QLltFKTfPZ9j00IK/gRBm4W43G7/h60gem0h7y/77EUUpTqn2uCfDxd6qLfedkY2W015TE4RZ\n", + "eKNWvAOAAd4PM7qNNzgXwcGF4JWn2nlAM3uT83QB4Pe5MPYNeGgY7L4fNrj3EyIo1FpVYwh6ryu2\n", + "fW3ySVt0Zde+if2FWWzBEPTG5gpkAGlx02n7fKYqJn/DUSX4oTk+w6aHFvwNgOFnvrjYhXWZW1hu\n", + "KaCRAf2fQ7br4b+H+acdGSCvx4UsTnP41F6Zqlc0TRBDpdEXKyFvbN6ozJqxwL5u6zn08wlGtLcx\n", + "d1oKnDcfMlSQV74nxJhhx6Mw3gzhK10p5mvP28XFvltp71aM43AHODiCjIy+XATSLm/j9pxnzd1p\n", + "ZH/qdblbp/vO0enEO6hMpGmoDKVpqFxOxVC+C2jze4ZND23cbQCEWfwRuBe4xtoNzpLf5rQnJLWC\n", + "kUY6Kx3U0vgIs7BDpUweQGkh3x04isotH2t87gOOWwQW1H0kc2OhdPyjvoIPS1bZjuHQwwOHsQuy\n", + "HNtkufx3Dfb37lEpm8vLElpVg7q1IdmLeI8ZxPp8jOxsOd4cn2F9o716miDCLMYDy4DR0iSPWx/T\n", + "QS31Q3Vz8Qiz6ECJYLcI+f5ACiWC3SLo4w19dqW0lHwzQozbAeOHgT0qQehkYByj8b7wZpe0ds9M\n", + "hsFnYWGUal/Tf79lef94csPp4aw7047CzOb8DOsT7dXTxBBm0QX4ArjXVuiDDmqpD8pxHQwQIggi\n", + "4tahBLq1iiYIcKJEuO8APgLipEmm1mYshoBqAUIq5UU4e0XsQ3sys8ck0W79R5DpVHKk5jp4w5Ds\n", + "lAFeiZDcjwx+8VlL6F7t2ly3aMFfTxi64K+AhdIkfy6rTeVFszXVxy8csSiQtgeg4z7osA86Jgfi\n", + "c+Qro0E8Jav3aOPv041RI6C5+KhLGRspRBDK/bJEVVNAUTgwQACe+SXta66DNwzJnXdB2C2w6WnY\n", + "9GeQ2rW5rtGCv/6YD5wG/llRo5azKmwqeLqAhLDb4GIvODcA9t4F67JiefiXsdIkCxt7hND8fNTL\n", + "in0IEoK6fWM1DMknxsHi7TD9AejzLUTa2VVyoqaaaB1/PSDM4kHgaWCkNMn0xh7P1URDFFyvCyz2\n", + "nXx7yLcH93wVHlVX9p2GqjlQl3aMK9R0ohjGjL7A9TuccJARwAJpkkW1HW9zeMuqDo2i4xdCTAXe\n", + "Qll+PpBS/svm+ATge5QnBMDXUsq/1/a6TRVhFiNQq/xxWug3BokLYG7Albl4Gj4uoiLh66nq6bLV\n", + "F4LvUe3bZ8GlAq4RZrESSAbOW23W35MryqVfkZ2jroV/Xb6xXqFSkpk5bMpeyBR5EGV3mSnMYrY0\n", + "ySPV6dfyO3iR4hOKc8Dn5LlZjjXlt6z6pFYrfiGEParazw3AKVSmvzuklAes2kwAnpJS3lxJX81+\n", + "xS/Moj3KOPgnaZLfNPZ4rlYau+B6yRjKz09j69GV5QjJ7hDWhs3b7+UfQAegvfFZ1t95lDEhAOeJ\n", + "6jub5AUDyWoPGb6QbSlfW7O3nqawSjbca58EXgDMwH+t3WfLPc/qdxhOMNv5mcdD4a8bSiKqm7sX\n", + "XWOs+EcCR6RUHitCiC+B6cABm3bNWqBXBSPU/Evgcy30G5eGyMVTOYaHSod90CoJEqaALMlPY+vR\n", + "5V4A81JJyE7l79JUsVA1AgJbUfak0J3AS53o/Sq4J8PJa2HlO8aZ1TeSNhVbhCHk5wuziEKt/m8R\n", + "ZvGANMmjFZ9p/A4Bq3BP3Q0XVT3oX7vDPXtVi6sxEri2gt8XSLT6ngSMsmkjgbFCiD2ot4K/SCn3\n", + "1/K6TZF/AMXA3xp7IJqmgOGh4nYBJr4INz0Mux6AfdIbaufRZXggWSJjD9seFyKkd9l2jurnf/KD\n", + "8L+0JTBigHoreX114+bLkSZ5SJjFOOCPwFZhFi8Ci8pf/Ru/w8nryGqrmkw6Cmt6lAj+qzESuLaC\n", + "vyp6op2An5QyWwgRAnyHqgF6BUKICKuvMVLKmFqOr0EQZnEbEAYMr63xSdNSMDxUjk9UHiqddsOQ\n", + "D+Gh1cOMVesHRPBjbCWr+5pRezuHMAs/YJbnE1wzwRlmxcFde0uOV3WVXB9GZuP/2L8NW8hS1Or/\n", + "QWmSJ65sbfwOBW7En/2AWe5389KxTF69Tgmvuc0wbsZQn0+oVR+11PGPBiKklFON788BxbYGXptz\n", + "jgHDpJQpNvubpY5fmEV/IAYIlia5s5GHo2kilFvwpdWGv/DUIQ9gLqrU4f+AD6RJHqr765dt5yhP\n", + "GAuzaAfcCtyJCnT7ZvAyBu2IZ4S9jZioil68Nnn4q3yfSsX6F+DPwF9Rz/LyaG3H4MGP9Gk3q3Dv\n", + "7ByHYZ+xJf00Lzd3w26Dp2wQQjigjLuTUD7r27jSuNsROC+llEKIkcByKWW3uhh8YyPMwgtl0H5F\n", + "muTSxh6PpmlRmZFZmEVvVHnD+1CBZYuBr+uixm3FY7ISxk4ZMCDkHOO3JtKqsCcQhYo2XyVNMq82\n", + "OYeECIlGrAzm9hlw6EbYcw8UulIfrrXCLIKAj4ELwFxpkomgbBQdcHjZHtdumTiKA/gmpIkiE6b9\n", + "rwKdgFFlRdVXfF8N4ypb9fE0Qq4eQ31jcef8UEr5qhDiYQAp5SIhxOPAo0AhkI3y8NlSF4NvDC7/\n", + "6MLDhfvW9MU1e5t8J/emxh6XpvlipDO+EfUWMBIleBdLk9xT59cSIdHY/RhMrx9hwBcQsEoFTCUk\n", + "7CH0wLXSJDNtz6mpr74QYTGwbDxd16uUzr7bYdvjsHPbJpnx4zV1fm9m4Qg8C8wDnulr5tw18grD\n", + "9JHNMC8ugg5AOMowHixNVbM7NsRbTHXRSdrqmVI/+ri/Q89I+LjPEYq26fq4mjpBmIU/8ICxnUO9\n", + "BXwpTTK9LtwqhQiLQXwxnttmwZFgOHAL5LQBwtZJuXxCnd6LbTBd+/0w5k3o/3EhzkXvA/+prk9+\n", + "la5rFoOAj0cvxnfzKdrvb69y+ncxompCIToqgodRRWOeAl4HbpYmua3yexq3A64bhks65LZCeeSO\n", + "ozEDBGsiO3UodLUwXMMCo2D4u7D8KyhaEqhe5zWa2iNN8qQ0yQhU+ucXUZLlhPOTYlXXbiyKhODl\n", + "MD4KgsfA/CAhQqt3hYxcpL36t7tzriH0oX4qviUuUKthg+R+8AMJfNnlfuASsFmYxdfCLEbX5VWN\n", + "N6VR3jlkA2zuAkMehgWjoEgow7Q0yZNAKrAH9ab1kzCLSRX1qxZ+PfvBK5C7EHgFWAWsp7mVStWC\n", + "v1oYrmGDP4avvoQMH2N/8/rRNU0faZJF0iSjpEneAvTxOUi3wzfRZcBj8KPhE7cYAv2VW2U1sBHG\n", + "QH1FNqu34M3zIDQawtapzy3h8ujxz6RJ/g3ohnKM+FyYxUZhFjOEWdjXybVNMp8U4gEe3AUbl8C3\n", + "fWDUXDjRHUej2RpgkjTJH1FG7S+EWcwsv1e/cPjQFffzYG/JzP0KsJrmVipVq3qqQcmrq6R0TFrT\n", + "ygOjaXmECRGzDMav7woe+TDsjLG/BkV7mkJkc6nxKM+cP6DyW3kDbwJLa2vktjVMS2DsSNK2TkFK\n", + "Bz4GdrHb63G+G3MJPF1wSXFi+rbe9M14WprkElvV2mpu8inihwE8cA38+gocn2BcaVYuxN3SnHT8\n", + "OjtntWg6eWA0VxcZkCuA8Tae6jUJPmoakc0lGBlTVwiz+Aq4FjUBmIVZvAO8I00yuSb92gbJpbji\n", + "FOePr3RgD9CJAvEmJ4NaQ5TSfOQCKx48ya0rXm0/SYydAeOtDcOdOZd9FuDMUOi8s0Twtz+VLs83\n", + "MxuflLJJbGoojT+OysfZPxRCouC2GPXZP7Sxx6S3lr/1h9A5cFiCtGwPwpH+0CL//THE5yHCOiby\n", + "nEMBt3U8ySDfOXXRbx8XZlzbnqMT/Mgf6e6e5THNR3L7dInLpZJH6zh57Uh/MotBLhiJzHRUB37C\n", + "QzpzRxaDl0hm3qXaigeOEuaZTAQ3NNqzqoHs1KoejaaZ0FJKOVZGKe+5VokwbDGMeK2I/OKteBc8\n", + "LU1yk3X7qno7lRWTMIseRPacQmbCQii2KEDC1s20X+H4dRFj7/kDtM6FBUZZyVF47dvm3yedP+wb\n", + "wvzx6+HkQiLiCoEPgUHSVDowtSHQ7pwajabZc9mW1uYw3BMM33wCZwfDNYP3M+GIC8rN9Q3g+/4R\n", + "yrupLF99W+FvyYia2Ar2doRpRpajEQSzg2irlqHRU4kSURB8yQUGPAaffAMTj192Bb0ZlSepvTTJ\n", + "LABhFgtQSfLuaOhqbtqdU6PRtAAM77mUnhA1H2bdAqPnw7pByag8X/8GngHi88bx+kvuBN4aBqc8\n", + "1dnleTtZaiBkOcH9MyBVXQV3rEsbzCmEk1uM7KlHWufC+z/CA9PhHmeOnVSlVAuAOGCQ1YnPAgNR\n", + "6S6aPFrwazSaeiNIiNAQIaLDhIgJESK6anEHGSWS+NBN8P4OFWE8Z3UQ0EGa5NfAGGD2pUA6+T8F\n", + "J1uBvVV+zrKSyGUo8y19LsDNB+H1sWp/lnMsOM9Dpfq/1wHPDjfFShm5GeaFQvRHh1mfmUz2skdo\n", + "HReBJevATmCopW/DA+lu4C0jCK9JowW/RqOpFyw69ahqB53ZxBqkd4GlAQkUFUQDO4VZTDXUKUlZ\n", + "Xrg8vAOGnIW+T8DDN8LBtmV7O1lW8QCmdfDecLjZoyvxXk+B2zzgZWAceNFfmMVHcRFsipQyZIWU\n", + "4y/0wqegNXbA78IsfLAR/ABGksY3gaVG4ZgmS5MenEajab74QfhiCExzhq/7qn1VCTorM/BLbguX\n", + "H2bfDdwOLBZmsQTYYJ/MJ3lRHFn0Exx8GzplwqAHKVr9J7yFWVxrFK0BlHunZRX/lzTWOe5zyoke\n", + "F0Tm+b/CpR4lAzjttAGVV2yfMIupANIk01BBXq2B31B2hlKC3+A1lJv8UzV8bA2CNu5qNJp6IUyI\n", + "mOUw/pg3TLgf/m8jPLqjZkFn1gizmAz8iCrsNLl/BH2svZ2OePH+4T/RCZWq+QLKEPytba0M0bX7\n", + "7dxx+jMWxduR2t3YOycBtoQbaaonobx1VgN/liaZLsziXZQuvxvQBmhtW/9YmEV3VKbiSdIk91LP\n", + "aK8ejUbTZLCuK3y0NVx/Hzz9G6zcXvMat8IsbkBlL30A6IGqePeENMllZbS1R5WCfRrlcfMm8LHF\n", + "EwdAPOj2KbkeE/l8wuFyUme3QiVxm4pKob0F2AssR00sj0iT/LCMa99vHB9hOzHUNVrwazSaJoOt\n", + "3/xxbwjyDe93AAAgAElEQVSaTSHJfJj5iXykuv0ZeXTeA26VJrne2DcMVes6BpgnTTK7nHPHogq2\n", + "XGf08bY0yXPCLDxR5StvkCYZW8G1g1GZUn9CvW18gKpFMhwIkyYZbdNeAF8Bx6VJ/rm691odtODX\n", + "aDRNCtugs9i+LEucxYsot8j/lHfeFcVOZv0WT9+MMGCaNMldpdoq4f0uMKRTJG8P3sZ0SzDXVjpv\n", + "vsSgMZf7Gbz3a2acHoqyFaxAvQWEABOkSU6v6F6MwktvAhNRxl1/lLppLGrS+dKmfTtU9s97pEn+\n", + "Wp3nVh204NdoNE0ew93xV+A9aZJvXHHcttjJ2NdhdEQhv3o/JnedWlxOn6JVHG/kdWfe/DXYP/Q7\n", + "ROLB7dxYkMkXjiUtVdEUIuK2A48Z23ZgBDBDmuTmKox/GvA+4AmcRyWYi0JV4nvXpu1Uo+0gaZKX\n", + "Kuu7JmjBr9FomgXCLLoAa1E1ckvV6C6VBXfSX6HP9/DJz5D+UIVZcEOEiH6rLcGzboNhpyHph+H8\n", + "zDa4bRasewHODzBalmTTFWbhiip9GUERrfpGcbDfTtKzismpqNCNMIvWwDJgMjAD2IcyAi/pa2ZX\n", + "V1mSQmJrCAWXRpEhTbJKwV3VLbijs3NqNJpmgTTJJGEWE4BfhVnYS5P8R8lRI3LX7SK0OwgfrYfs\n", + "dlRW98ITXHpfhC0fqJQMz+AOCIifAXdMh8VbIbt9qX6MwKv3enuI04mP8LUYyeCd18CfNsPvuwkM\n", + "EoKyhK6xep8izCIdNQG8A9zgtZvNQ11o+2lOiWydE0XCcg+chFncIU3yi4ruoax8QnMhoLxx1BTt\n", + "x6/RaBoFaZKngAnAvcIsXig5YkTuZreDZd8YQh8qK3Ziicx1KYSRp8AZw3ln350QezuE3Qr2+WX2\n", + "0yOLx5ZG4SAFfPI1xHSDlfMISL+RBcIsOlVw2Z9Q1cRG2uWxYfQqvD7NwaHQTuX/B/gAAkb+RCIw\n", + "X5iFn+VEIYJChQiJFiIsRn0GhVpiH5JaKU8oqGnBnYrRgl+j0TQa0iTPoIT/HcIsTGpvzaqEWUfm\n", + "AoQTjzt3FADw698hzwtuCkovqx9PcJl2CA63gS1+8PVy2Pwh4IwrcECYxQfCLPqWcdkdwDqgZ+B6\n", + "LhW3VfmAAsLhhHdJozY5FADzMaJ6S+wYUcGwfLz6HDPfEXsfgBX94I2xJeeXlYKiNmhVj0ajaVSk\n", + "SZ4VZjERWCPMwp4ITEQAhFarSpht4ZVMMnOcWLcli9DRSA9XvsvOZ15CbyKKu9memwG5boUwexeY\n", + "J8C8rRCYAkFfszdxAPcAjwJrhVlsRwWErTfSRuwEZgIfXArk4Zs3w0o8SMkr4laXfrRFEE48meot\n", + "419AKPBH8JuC26uBXP8wrDMZZVwXByaz4gKkMToJPrFKAVeTgjsVoY27Go2mSSDMogPwC8pP/m/1\n", + "kd5YmEUAsAmVPvmyi6VFt/4fRwLbPAt/Ww8n15OwBcItunXDEHwPKjArHTUB/OJxkMRrvuS3gs5M\n", + "dEu2s99eMJZzs1FvGSfG4y5m4eC87rXUnLPPCrPoAWxlY+90Bqf2YN+dsPYlyPcAwItR+25jm+tC\n", + "BzWO5NdgXkHpcVxxT9qrR6PRNGcM3/c1KPfI5+pJ+F8PfA6MlSZ51LLfEnMQO5MBp/rROfAtZh7M\n", + "kN+Xcb4dcCPwF5FPr8GbaLd+E/Ye+er4LAKIHNeazHMvwMGb1c6uo7KYva0vqlj3j3bZDBj89gjh\n", + "me1GFs7EE04m04AbU7w4eWwoB/j9scJegWvYn3eQl+raq0cLfo1G06QQZtEWtfL/BXimnoT/4yj1\n", + "zRhpkhk2xzyAi8B/pEn+X0X9jAgUm7sNZfTa7vDQ72BeC47FMMJ9MDvcPoPkfqpPr+Az8k8/uwCi\n", + "zUZ+cO1A2B3JuLy+WvUziwAiGUImTwLjgLlHeOST/XTK+02a5GsV3osuxKLRaJo70iQvApOA64F/\n", + "W2fYrEPeQWXZ/NQ2hbI0yUxUJPA8I1dPuXRPIG/FCti6GLxzwcGoCeCe5XVZ6APYe6R0FHlkAQWD\n", + "NjJi13e4fDYQtvqq48tIoI/LbnAYaZyxOJCdPboCo+viZm3Rgl+j0TQ5jNq1N6By6/ynroW/8Rbx\n", + "JCrN8stlNHnR+Hylon4sLqQBl+CZ35QeByALl8tt7LzDmOsabxf8T2K9d/Ie7ejbPhvWfQTDT5f0\n", + "5d7uhFXdX+CYXy4wpj4mPi34NRpNk8QIkpqMqra1oB6Efz5wi8jnwX6jxB7rKmHSJNOB/wJzhVm0\n", + "tz3XUlmsCHwesPK4WQ9Mh+J2Yh0jndvg692TJXlRvHMkE0+J6+gfGNn7gmrbMwXsrZRYWTldSgv+\n", + "ZLtLKBntRx2j3Tk1Gk2TRZpkqjCLKUA08F9hFk9Ikyyu7LyKsE4A58UAj+s677PbcjcDn0lSK3BL\n", + "pCwRvIzK5fMvVBpo4Mro2vXATQ7I7CJOdZW0+R7ckLmQl8vjXOJsngfBDGcz3gMcyRQTcmN5VmTy\n", + "Lyuhf589xOc9azXKOQmQuBB4GKXuOVmbe77iGWjjrkajaeoYuvYoIBZ4tKbC3zYB3HCC2c7PfNMX\n", + "ngqG+LdV5G8oqmaAMIvXgHCgtzTJE1BSZyDTCdzzS9Q7wfakryqiVYYTmCbC6z9DtPTgLkJJo6Rc\n", + "QACzmEskmWRiDxQBkW3J2XkxZJ1t3IIwi+eA9tIky63opY27Go2mRWKoXqYC/YBFNa9p6xcOiwO5\n", + "5jW45l+4u6mF9MwD8OtSJfShVKTsP4BilM8+oKJ8AXrMg3MeJT27gzOAR74y2n46EBbQRwl9x2zw\n", + "3wBAAstYSx9eBiKABA+ykvqySMrIECmXT1Cfl4PVtlAPBl4t+DUaTbPAcLsMAXoBHxgVtqqJkQAu\n", + "uy24J5PlWZIpuYdV0uQkH/oIs3gLVXVrNXCzMIsJwiwcLAbdrqlwwqvknHR7tfgXwGur4YXrIRt3\n", + "ddAxC+68EezzANiEd0oYrJviwNqfbkSev+GyMdmWHcAgYRbO1b/X8tGCX6PRNBsMV8tQoDuwpPrC\n", + "30gAt+tB+PkN4s99yCwCSrW434Gko/58BCSiDKsCZQ+NBrJ/C2Pona3I7ZqmqooB3OtM8t6RFM0R\n", + "HAe4JlHZC3Z7Z6tcQdnt4UJf8N8IQA5FxzIg18GDrgNiSOsfwXXl3G8GKv/QoLKO1xSt49doNM0O\n", + "YRZuqNQOp4H7bQupl3uebZEXwJNJZ4az/nQ7CjMzIeckLLSNlBVm8U/gCZSX0Rnfb7itOJCn3bOw\n", + "77ibjNjRnEkbwnDPA2T33oGHZx75F1uTt7evhzs/Tc8i+1Mvxr8EzmmI1RfOTZTfFq1RCXoAmAtH\n", + "NsO8siJ0hVksAuKkSS4o+5505K5Go7lKMIT/90AycK80ycIqnSeCQsH/igRwV5R7JHGBRdduRBOf\n", + "AHZJk7zO2Pck0Eea5OPG90hgEbAK8EW9LfyNva068duAVvjk+DBhv51IdChy7p3p0CUdwuLgFSNj\n", + "kMWgXMZ9zgYml1fIRRdi0Wg0Vw3SJLOFWdwMfAd8Kpz7fkp+tyfKEtylzlP7Sq/oy3gTgLkBQgQh\n", + "ZWykNMmLwiz+CzwszOJ6I8HbCZTB2cJOYKg0ye+BBCBBmMUBBqbvZ+BvI1Ap+hNGRpG45nu6J9nE\n", + "BJebevl7H0euvzhDiLCYiu6rOmgdv0ajabYYFbSmk+4QwC1ZX2D3Q6n89kqgVwXD28flElz/PDhl\n", + "oiYBf+sCKK+jFsuWNBLHga5Wx3cCQ23Gdw6Vh/8VaZLH7LOJ3zOVbk5F0Pui2iyUlXpZiKBQdoc8\n", + "jYOrK+4La3BfZaMFv0ajadZIk8xlwcQUxEAPbr3dqLIFZQjuCjC8fYSEVknweD/o8x02ZRovoHL8\n", + "dEHV2T0BdLNEFHdZTivHbCZbRwAbp74JjBdmMaLXWvKdHRHXjS999dmQfRLKKDTjF478IJBTo8B3\n", + "Ww3uq2y04NdoNM2fQm9nln0N9gUw9AOrAxXX6S3B8PbJaQPfLYVvl8INz8LsX/oKs/C3avgGyo//\n", + "n0AmUAC0CRIiNHg/z3uC8wIPxkdB8BiYb6R/yES57L8esJ/MIgfYOQZmdlM7XwBOQULZqZeNCWnF\n", + "Mjh0Yw3uq2y04NdoNC2AjFyKnGH5V7DjEav9FdfpLcGm3OPxifDemARE7s/ATmEWfxZm4SBN8jzK\n", + "gOsB3I1a9Xf1g/APIHDoGdhlVOi1qZW7BOh4IgDXwWfh8d/hyFT4q73KEOcAp8q9L1BlI7G231b1\n", + "vspGC36NRtMCMAR3kRNIi1gru06vJcFaqaRsMjYSNs+D0GgIWweh0RTuCJcfZt+DShIXAuwQZjGq\n", + "61J22eXTwTmTRd7H6ey9i5mWaN4ntkHnzJJrWQy2hsfRs3GhtMs4wcVCO+iaBn8fB3MgoWw1j9V9\n", + "laLy+sOVod05NRpNi6A8N03rNkFCmEbCM0vAzbKvIh/6y30rPf6dopCFPfdhN6kAr+ie4JcGWQlc\n", + "aLOBkz/bGHahtIum0ce6NhspzOnP+JCFZCb645FcxOJjJ+UjtudW9b60H79Go9GUQ5AQoQGw4ntw\n", + "O9papVywpEUuy4e+LL/+ie5xT/WayKTvekO6C9gXwz17IDaSHb3B25KxE9RK3rZWrl+Q+NPYU7y+\n", + "8QHsYz5WqZnvaEX+7nxmHciR39XkvrQfv0aj0ZSDH4QPMVb6o+ZA3DvQIUsds/WhL8+vPysrKee9\n", + "n9K4bzfcPRNyHWBtdxgAWZvBFApPeoBreRHAQXEELwP7uYchsifM2wpfpOM0tp14V4iQRyqLQagr\n", + "tODXaDRXBZ4lyTdpmwMXXUsE/5U+9IZff6sk5UZ5YCawOPAgsemwhTFJsP4j6P2EytDZ2YPC2Ax5\n", + "RWBYWWMAeHSHmjQsOLnQiS6mTiRZEnGWBI/V/s6vRBt3NRrNVUEG5E4Bngfa5ECKscaf5orMcaXX\n", + "bdb+9775bZlxPzw60Mp/HjLo5HI/4gyAbwbMilP59DffSWpVxwAw9AyMTSzZn3VpEMy4T6VvBurC\n", + "V78itODXaDRXBYmw4BM4EgxcyIa33WAy5LbNJ3NtDj2Ww/hnuhGcci8ruHPDYC72ggVH4Jd/Xu6j\n", + "mCCn7wg6FQrRYbDu0G/EICDXh0nCLLpUZQxzVbbNy9yBa0581t8hcSx02WJ1pHa++hWhVT0ajeaq\n", + "IFbKyCAhOAVPZkmG7GrLeX8o+F8RQxNaw+23QrozmDfhNn+FU9b+nMN2kjZWi+O/AlNJ42BWpNx7\n", + "2RAszCIFlcL5ReChqowhFJ6kNb1TXXHdfzrwVCbThvF9KHXpq18RtV7xCyGmCiHihRCHhRDPltNm\n", + "gXF8jxBiSG2vqdFoNDUhVsrISClDTvfh84NTWOoNGQA+GfDCejjwX5i7E7q0znJ3Cf7Rju5jwXEO\n", + "MAu4CPwMnHW36XY3qj7ATGEWvao6hqh5BG1+iKK0cWc/U7761kK/9r76FVGrFb8Qwh54G7gBFXm2\n", + "XQjxg5TygFWbUCBQStlTCDEKeJd6KCWm0WgajiAhQv0g3BNcMiA3ERZU5AffBEkB2lh07q6FcPPB\n", + "koMBKbBu6EXEgN+RSRdg7VdwbqBx9AFfIYJCrQyv8aiyi/nAS8DtVRmAkV30Ra5Pns2GTfOQoRXG\n", + "INQltV3xjwSOSCmPSykLgC+B6TZtbgaWAkgptwLeQoiOtbyuRqNpJIKECB0D86MgeDml89I09tiq\n", + "wUWgbVk69+eAvWPgh2Uw8K1BcPxRuGcKdF1ntFjS2cbwegKIAwaikrFVR6uxFGiNab9DOTV364Xa\n", + "Cn5flG7LQpKxr7I2lRpBNBpN08QPwt+HwLMecKCd2meTl6Y5kAK0iZUycjPMsxhrQ+BCCLB+LUw+\n", + "Ct6FbrDlT7DgMJy81ur0UobX40Br4FtgF6pAe6UIERRKxNSVfDWqmFSXz4Vz3xsrP6tuqK1xt6ph\n", + "v7ZRZWWeJ4SIsPoaI6WMqcGYNBoNZUeeVnUlaaQX6AB0s9q6A93c/sg4N3fwzIfxx2HFCnVOuYVE\n", + "miYXgbagdO4Y/vdBQoR+AvPHGRG4zhiO/vmeNqeXMryeQOXlvx3YRr4oEn2GbuVgYE55z71UgFis\n", + "hGGTYEjOh0IEza7sNxJCTAAm1Oy2FbUV/KdQ5cUs+KFW9BW16UI5meiklBG1HI9Go6HyilKGYG9P\n", + "acHeDUO4owRZFmo1a9n2Aj8MXIH7L+e51r2g9DXLKiTShEkB2tjutPa68QDXMxx2F9zvK/m4c0mr\n", + "KwyvJ4Bu0iSPipva7OJcn9FcI0ZycBlqzVtWMJYRIOZ+XqWCXv0a3HFzB/b0/yOVBIEZC+IYy3ch\n", + "hKm6N19bwb8D6CmE6IYqejwLuMOmzQ+oIsVfCiFGA6lSynO1vK5Go6kQQ7C0Pgqdfwfv4+DtFEin\n", + "Ux8Ls0hGCfccSgv2/Sihcww4YeSRv4KgCMEfYb5tXpryM0w2PFUwPl+kDMEPpd8AwDKJVmh4PQd4\n", + "CrNw4+cbnCmI9mD4YOi10sihvzhQnW8t0I08+7Nmwq8vqzTQxyfAhB096+gRVEitBL+UslAI8QSq\n", + "uLA98KGU8oAQ4mHj+CIpZaQQIlQIcQS1gphd61FrNJpKMARLtxjouRJSu8GFPpDU6xz+2+5ECfb0\n", + "mvRsuyouLy9NY2ExPltPTHMhIEgIrMaYgqHqqYyyavSWOm6SxcIsEoGu5LcuBnv48X3Isy6qaxuM\n", + "lZELEtrHQXJ/tWvNK/BoT19hFh2Nko31Rq0DuKSUUUCUzb5FNt+fqO11NBpNdTAKeOx6QG2XiUqS\n", + "e+S+2vZuuypuSvhB+GIIvOAGbbOVsmUxBIYq47Mas7nfdfztgJtwnLmOwpycOkiKdhzo6sAFz0KA\n", + "pDE2h22DsRIX0OrOXhQ7dCerg9qV+koCKY576VxkAh6rxVgqRads0GhaJPVTwKM5YEmENvgROO5d\n", + "st9ifBYiKBQ5dj45HQQu/x1X0wLmQgSFChESLURYDAc69G3zo9Nj49nRKYBZpdtx3xnb5y5lbCRj\n", + "Vn9Aet6ly4Vf2BJO59y5wG3CLHrX7O6rhk7ZoNG0QKSMjRQiiEp00y2SDMi96AoZTtDNKnVaifHZ\n", + "sH9k9wfXFMjsTNl6+PK5wnh+5u8EHHu14y9kOM7rEcmvySNom+GOC1nsJykzkcHhQoQ9Y/HyAaBN\n", + "v3v43dXi+XP5txFm8TqpjkuECMmorzTNWvBrNC2UynTTLZVEWHCXL0EDzuNr8SMvbXw27B/HJ9ic\n", + "WZ2kaMbkYZ8HfpsgtRtudu6OkI1Lj0zu8tnB/22ElXhwGzd1gc+tjLYzB4C3IGWJxVPIp5Tnz5u9\n", + "DjEnaSR+f3Mg8RqjSd2madaqHo1G06KIlTJy4xhWJqRzMgzWhUJ06UpYhv0j8r8lhlWgeknRjMnD\n", + "6yTcche030eWcz4A2Y7gZri6LqAPOXzuiv9GcMowzu3nA0s6478RHI04ARYHOtDhJQDSezzCmncd\n", + "mPI0JSFPdZumWQt+jUbT4sgKwOlsEK8sl3JCpJQhpT2O6sL+YUweKT3h4xgY+BnxY/K5E+dsa8G/\n", + "y86jCICJL4DfZuNcB/A4C7fPAM/Tl3tsA/1U2gtPF/beBdltoZV1WFTdpWnWqh6NRtMSGQS8V9aB\n", + "iuwfVU8+l7gA5gbA4kAu9oIlG8n8Y3eizjv87tCKwF32pH4DJ1Lsiv0pph+nRqqCLglTgEKY9Ffl\n", + "bZVSogEaQoarHTwZR0Yu0h6++NHmmnWXplkLfo1G06IQZuEA9AFiy2tTlv2jIv9/UG6ilgmhPyyI\n", + "g3mXJ4+0zBwKxbDU6wtbA7kXAnlebpPfChEUisddyzg104PBH6tOfTfkEbjNmbdLXPUDCONJ4lkK\n", + "rpD42uVJ5TJ165GlBb9Go2lp9AaSpElmVdrSQIig0NF4LZ3vmNbu4/6wpjv871vl/z8FXuoKXrYT\n", + "AsTNi5Wx1gVZ1gJvAkvtMzEFO4hHbgPn/bmJJw/kxfYs9ou3Q9ycx9QLbu5x3siOk/DMdGdwShZP\n", + "Es80Mvkv5DSER5YW/BqNpqUxCNhTVbWNEEGhdOr5buKQlHZ+A9IYnQQP/w5SgJDgCT0WCVq/MAEe\n", + "3KVcRK0DwizXmdyevvkF/GP3ODIcOtLLcRaDli4H18J07ji/N3eZsHOUo/LccDxHVlsPXG7bydEF\n", + "xbgZ47D2PKpvjywt+DUaTUtjUNuN5FSWtkGYhQtwK494LKTVGe/iQ2nsXARd02A9qo6iA5ADHr8C\n", + "dhKGPQR37oO/rQePLFxLqYeSAeh4RwzFEx2wWzcB5oXA+z/CF5m4RF2QpI3fDp+thJCbKYwMY3zB\n", + "JbzYmuZE6uaGTHuhBb9Go2lpDBywlY6LIfC0J6ztBnftK1mlC7NIAB4G7gF2cr51Nh553hkb/skz\n", + "ae/xOAmsAl4p6c/xeQnBMfD4dvjHddDvcXDfT5e+kTy1uJjANd1V+ca+F+CLdOz+5AiffAupLlaj\n", + "srOHQidIGg1tCnE5eY54/kwmdpuljAyhAdHunBqNpqUxqHUOeQDP3gBxHSDPHr4Mgi1zGQ2sA/KA\n", + "UcAWup1vzUcbyLz4FyKZj5m2vILyoN/uozp8BVgNdMiCt6Jh0mJOnOvG0QJfxgFs8oP/jiwZgHOx\n", + "ekNoY/jhJLSGjHZSpWD2PAPFDgzLKmYI9xfakx0oRFiMSv9QvbQRNUULfo1G02IQZtEecM0pJG2T\n", + "H6zuAdkO4P8nWDwUOu/mOOCP0uS8AITyTec5XHz9CEAm0ygiiD0dYcL98MiNkGvoRfZDiiUgbP8l\n", + "HstbKKfYn2crwN17YVl/yLdXbfdJu1LFpsZNccd5yzXYeR9iQIepeCQXcZaj7ON6hyJiAmH5+Jrm\n", + "DKoJWtWj0WhaEoOAfZv/wM7xfZjsJrFzLIYNH8FrF0k4B88zDWfgK6AAmCCPHcsSIigVQp/Ew97z\n", + "wMRNw6b0xuWltTBnJ9gbIjwHtkVKWUolcyaPV+/EecXnqXlufS5AdCB8eg62ZTwjRvNOmiey+GQP\n", + "vM52zLP7w9eJxPYvYmr3fRxKhh0EkMoycD8PSMjqSHVzBtUULfg1Gk2LQJhFN+BZYFjaIDqKPM6M\n", + "/DdxJwpw/qNRMyAugl0oVc8O4DFpkoUARMT9DHHdgIi0c6y+9R36P5xND0vf5RWaiZUy0luMShhB\n", + "6wFpe49y/+gjFORLMr+cwgXOO2H3nishAwnYfJSvCo9x7ynY0gXc4iAQd075bIewW2GdySp9dt1F\n", + "6JaHFvwajabZYgRr3Ygy1o4AzgP/AeZIZ6atzpe/W7XtC2wGPgBekSYpjf0TgAXABWBS7jtyX9C7\n", + "IrSqhWbSaHN6B1EDiLsE09pDsR3INcCHrgxfAC6p+B71Bs4TEQN33AI9kuE0mTDpeYh+C+L/YNVj\n", + "3UXolocW/BqNptkhzMIPmAM8CJwgrtVmvgvqQKfiQQw89zSu2el81a4jpsvtrwW+Bp6VJvmxsc8f\n", + "eB0YDfwZ+NoyGVSv0IyRviF3cSAZncA9GTiSi9sFF8a/BBf7kH3RBVhD90twqC2MTYbbOEjCJyEc\n", + "pUToO3Nndl4D1EzQgl+j0TQ5lIHTL9w6Hz0RcauAqcAjwFjgcyCEiP5+0Gsx9PEh5x7oN86ed+La\n", + "wf99IETQHCLi3IB3gLulSf4szMIVeBoIB94GZkuTzK7pWEtF2l7KHYFnfhtI2c/EF4YSeydELSCe\n", + "lcziOP/xTMChGP6QBZ+QyQKiWMgIcnHnIDnZeSS+litP17svv5BSVt6qARBCSCmlqLylRqNpyVxR\n", + "5MTzNIwMTWH03kIc5XFgEbDMkpJBiJBoGBYML8PdU+FICGz5o+qszfgDhK9vhVIH7QH+APwbpeP/\n", + "izTJE2VNMjVNjyDMwgSY2NY6gqBsEwtP25Gjarp7OF+X1zVgE+dGFTsM/4hLJ2FVV2hb27rFNZGd\n", + "esWv0WiaGH7h8H4gAatg+CJVMD4urA2fOv8mj2+99sr2ni7gAA65Kr/+tsdLDrk6dAX6AR4oV/xO\n", + "wIPSJH8Fq0lGvBeItENV6K1F0ZNDHu0JyIS+Oc+x3aeI4mnHwC8JkZ6f+YfdY+P6FP8D8I2S8vFK\n", + "+6pHtB+/RqNpYni6gID+K+DIVPjPCfjpPTjRtbDs9hm5UAiFrrDqTSh2tDpUtB14ClgLfAcMtgh9\n", + "hVFJa+KLMPYNY1/Nip4IERTK/iG3gL3AtdiFmEOO5AVJ2P8aplXv0SdzC9AN2F/dvusaveLXaDRN\n", + "DKPIyQ8f2Owvz9slcQG4DoDnfS4nWhBFMPyaNIK3DQTigX7SJC9cea6nC20PqTeLd/da7a+JS6Vf\n", + "OLlzOmG3AdI7ge8OSLL45celoGIH7kHZJhoVveLXaDRNjOpVyFIqmUNzsVu3D+fgIrpfm89jXtlM\n", + "2JGEg5wkTfKRsoU+QHouIU/Chucgw8dqf01cKot86GeCLDf4vQcM/JfaLdzdgVDgW5TaKa76fdct\n", + "esWv0WiaFDXKRx8RdxpoB+z+//bOO76KKnvg35OQXoCEAKFJCTVROtIksVGiguISK6uyYN1F3XWx\n", + "rb489+euuq6urqIu4ip27KgBRZei0pEOgSR0CC1AKun398fMy3sJL8l7aS/lfj+f+bzJzJ2ZM5P3\n", + "ztx7zrnnAB2AOcBHtvDMSpmydgNtSy9l7Te+9o3uFT0x/ARhT9G6QzR9V8P+S2Hrv2FWNHz3IwRm\n", + "BIVu4fCg5Xy0+k6CLn+Wd2MSpZLKXg2DVvwajabR4U4+erHKVcDHQCmwBHhGWVSOC8cFMZjp/Bz+\n", + "JKVT4mpS9MQegdQhiitTYd+lkB8GZ3vAqWHQ+9GC1v47ZPJiOkzvRMzTx2ExTKiYIrqh0Ypfo9E0\n", + "Cc4Lu5SDL2PZeSVGQZTVwO3KotLcOOXjwC9q6alngWdrJpUZgTRwHHQ9APN/Bq9SY9eW6TD0LwV9\n", + "VuXFLMjH56UIiD5h7HIs5FKz69YOrfg1Gk2j57zY/nbJcPWll1EgXvipu5RFzXflPLZqWcUdadvq\n", + "drX5yCcAACAASURBVAZ3+oQZttm9NSPEHymFUcmw9N+Q1c2+a2cnmJARGvRpaAlk0eMs9M2w7w6G\n", + "es/JUxnauavRaJoAZtilXxaMfwjuuASS5/jwwuU/uaP0R8FLSTDB6wpGPLsCn/FpWGJEapEGOTuf\n", + "IfOBIDj4jcP2lZD/RSmp15Hj18UbYPJumOjgss6Bes/JUxla8Ws0miZAiFHLKuF68D8Dc7fDmgeh\n", + "oK3LM1a7wux5EPVxNOxvA39Ya5hcuhkml5rRYc98LptdQkAxBAzHSPF/Yz7ydD686cXW6SSPUNxA\n", + "r3KHVZbts6HQph6NRlOvuFr0vKpjwxh50WmADxcZE7XKcD3sMgT8c31g1mQYfQh8TFN8rUwu9+wd\n", + "TZ53Cmfzwjn+y07TObwG1edxAFInkjPobZJkOsPVGwSzoTiAjB8asr6uM7Ti12g09UaMSPwIePMt\n", + "iLRtmwEXxYjMrE7xORYy/0/wdu7zvoHizI8dWrgXdpkN+Tf8BkTBJ5/Yt9fU5GKmeZ5OYAlccGas\n", + "UguTbb6IYLJ8+jGBoJICcj/2IxlfNrAEfCfCY989HZ1I6CSRJTV5GdYFWvFrNE2Mukwq5tL1rCKA\n", + "HxBayRJS2b6gexhZ7E1gJz/wL4a9L8FbEDkenqKaiBabaSY9GCx35XD3F0mkZA5nFW1OZ+Ozzp2w\n", + "S4A1U9hwtg8Tlr0NoQXGtpqaXMxn8i+M9AtblEUlm1LPDubaqHju5COOGm2BG0gjKfAf5ISdPiGF\n", + "fHr6NkLeXkrgMKMJDR3eqRW/RtOEOC+6BagsqZhYxQsjOVllCrtKpV2hTSmQBWSbn86WbOC447Zh\n", + "X/PZ6/kQUmBXthgn7FHdvYaAP0DHHPhhAUSfzAE2kADbFlYogVgdYpVwBvNHnwx+fO4ARXNrmRET\n", + "I9tnFMbzmeogtX9vvxcYd9FRYobD3G8h9gB8TBojSk4Wrb89O7DzanLj1hP4WAiEtYV7zzR8eKdW\n", + "/BpNk8KMbhn5IrTZD35Z4JcVRevDC8QqaZRX2IFALpUradv6CSC1kn1ZQLayKAe17TpXJ0pJPyfb\n", + "j3ckWKzyV4we805gj7KociaXbMgHo8ccfdK+3V3TjFjFG/gRyC0KZ1KSUkVu3cT55/PDqPJ1AnjN\n", + "lg5CrHIh0zr03NYzgxV74dUkGHfAflzHgtzkrp+qfxaM5q1jnWDBFxCZY0wmgIYN79SKX6NpUpjR\n", + "LUVBcKYXFIRAQSjI0SMkrJlNeYWdqyyq1IPCkgV7H4ehTztse8gLzgZwGCgGrsXQfb3EKoexvwh2\n", + "th9D0m3riXqn0B4SU0PTzN+BfkC8stRO6Zs8gKH0OwKvi1VuAu4FehCStSxmbtvrF2afPE+JF1Ny\n", + "JDqZm77eg9fTl8C4O2DHXHi6xIgFasjwTl2IRaNpQhhFRxZPOH9P/BKlktwyf9QHTiJ4VveBO6Oh\n", + "kzdQAmyH9BQo59wV3/7X4NVlDj7+bfHL9GP0tsMMPduWUvq13Qb91+AVkk/JuRKO7+3KS4enMV9Z\n", + "VFZ18siUtk8Rk/Uoh9qd4d0hv9bWHyJWiTRugQxgGzAGI+naXGCRsqiiThJmiSNvzgcUBNqOmwlp\n", + "a2D2AJizEGIBMgIg3FT1N0L+dri+oQqxaMWv0TQhnNv4Z6bBmtn16eB1BccoHNu2WZC6Gt7rBiMr\n", + "qzRVid8iFVbf3997h9dIxStvlXKBbc9NoRR8cxWlOX3JwBgd7MJhpKAs6jSADOk8i/EnX0MCvXll\n", + "F+RElp3X3WcVIxLfRZi9fgYjclsTVBCEN968CryuLGqXs/bdnBRrnySyZDGc9+IeDxu/V2qYOzLZ\n", + "0Ipfo2kBGIqym+uZKxsIm1J7/0IILILrzDiXeFiSVIUztmwUM+Y5GD4XigKhMAi89pxuU5xVekUW\n", + "7YKKoOcZeHKFeS34bkkid2OkOa645AG7KfAaRWGED7uuhxUWyG1vXtG90VGvzpLQthevHh9Gu2PB\n", + "8M/vYP02jmw6x53u9tCdvRxto4GaRvTo0osaTQvAncyVDYktCuecDyyJsiv+6p2Wpt9i/T2wYxr4\n", + "5IFvLgQ/eKiP3yrvaSW0y/UxXiaO11IWtR/Yj8OzMMMsOwPvc86vGL9CHzpugrsGw4sHQXnjapEV\n", + "scow4F7v25g+OplWpbnw1DK4YzMAnWsShbNdqaQYEeKdjAbcOU9t0Ypfo9HUCbYonLEH4elL7Nur\n", + "d1qaFbcKQ4yljNbpYSAJEFPxiMrOqSxKiVVuAELwKfbioy/hwLiKR1cqj1glAEjAcNZ2AF6/8hX2\n", + "vJvNgMOh0Cnb3ramUTimkvfoi1vn6tFoNHXCIXh5FqT2PQU5vnA4tCwKZ80kkSUJIssniSw5Pyla\n", + "5RW3bOcst6eKyB6xyqXAn4E1FLCKA+86PW+MSPwkkSWTpdXWUdLmZEjERclybZd9FMsx4Abgr0Cv\n", + "6ES2+mbTHaBLFng5WMY9mWSttmgbv0ajqTNsTs0NtzEsYhdHZB1fjIJbnTh87z/fwevcb1GZo7Ti\n", + "tcUqXYF1GOGhzwEXkhg9uOJ5o9kxfATMmScEJvWGucNhWScvSjdfS9GvXgfI2HWv7dqTRJY8ChO+\n", + "EXjOQVXeAXnrYZon8+3Y0M5djUbTKBCr/AnoMTGRqMUw4VQgvDYMnlhp7K/O4VuD6/kBKzHq2l4O\n", + "fKss6l8V28WIxHcJ4pPYwQS+Pgw65MLv18G0HXBtcVtOM5wU0jecVVuHAySILF8IsSuBxQJ+yghJ\n", + "XQvbvlfqorqSvzZo565GoylHQ+f1ceBnYHoInAVYcQGs7WLfWRezVMvd27QOPel8+hBtitKAm4FX\n", + "yrU1nL6j2t3Cm2ldCOy8Cwanw4Q0+O0Wo83FnOEpvudmAqJjROK3K5Vk81uMA8Y59JHj4Uht5fck\n", + "2sav0TRT7PHxiyfAwljjc9RLxvZ651egV5YXJQDLekDcfvvOPLjQub3fNcrd26BJsXRo05W3pkZS\n", + "JHOB3yuLKgYQqwSLVe4ENgHvRBwl796XYP4iuGIfbIq0n3NVZ1DAB5wLsOXod9fH0FTQPX6Nptni\n", + "ULWq9QFAQD0Yhc+OR8y8PqUYus7xs662FQPrtw5mxayNdFvdnai3vzSkegyYA2HjalV03Ly34HS4\n", + "8mF445/Q6usevHFFIae8H5OvOvdjytEY4BYME9CfgR8vWEbSFOj1OBCfDu8MNM52ezDcc9rICwT2\n", + "EUljCb+sa7Ti12iaLWZ8fMfNEH8fSKmRjN7nwDBgEcaI3wtD3zl+1sU2AUjvGxw3/3QvVOh2rjwz\n", + "iIgOuzk9Loe2R2DcqtpkpTTvLScS/v0GFK4C3oe+i3yJnzuBDqev4HDAJ3Q5N0hZ1CHbUTGJ8vK7\n", + "0OtWiHo1D37tALe2hZlnIM7h7I4RO40h/LKuqbHiF5Ew4GPgAoxJFAlKqbNO2u3HSBhVAhQppUbU\n", + "9JoajcYdzPj4A+PgtW0O2+NX1HdeH7GKsKjT46TEPqa6Tg3g4NucPfcNYedu4PXPk5hMTlnbmtn7\n", + "zXsDyN8A/AOmJUDQcVh/LyQv9qbk2jZKJR0Cew6hAeC/rxV5N8aSmdcXr1Z5+GX7kRkHEbbTVTTl\n", + "eNBPUn8opWq0YIRLzTHXHwaeqaTdPiDMhfOpmsqiF73o5fwFouNhZgooZV9+lwrR8Q1yfa8JP4BS\n", + "xN+nGPV8mQwTGOYokJoEi2t1b4H3GKfyyVXl73XacqUU0RB/Bxx13HmrL9n9fLiGRD4Kncbzk2Dx\n", + "NFg+CRZHQ7zT65QtM1Ma6hm69ixQ7h5TG1PPZMwsc8A7wHLgkUra6jBNjaaBUWp7kkgMEO+ZvD6l\n", + "oYZ+SZ0AJweUbc4nqGy9po7Ssnvzv/IBIrIu5wBeFAVWaJV9TqzSaVBvXhwZSuSfwuG+9UbOn3cL\n", + "Cb4UrxeSV3UrzQpUYxbTfwcceu78Z2P6ErovB+8CSJuAkUwuvsGKptQHtVH8HZRSx8314xjTm52h\n", + "gB9EpAR4Qyk1rxbX1Gg0buDZvD6mOWbPNeW2bqbgVALsqMxR6qppRantSWKVWDa28eXIjF4Uv2UP\n", + "GA29qYCrfo4FNh0cR/jak9AnA/yK7ceH4N2TtDe8uORvwOIuziuZhfjTZbVhRvrEsd6va/l+GitV\n", + "Kn4RWYpRbKAijzv+oZRSIlLZTLAxSql0EYkAlopIslLqp0qul+jw53Kl1PKq5NNoNI2ZQy/je/tA\n", + "Ct920CEz0zLJnr2wkqiYSktLhvT14aE9qUBfoI+5DAQGM/RsHr6fpbMqOZ2C1oWUnMuk897/0jfn\n", + "Y+DRYe9x33wn9cMKCPYifTB02IrRP3XSk+++35dpU+CLBbD/UoejK8/3U9+ISBzlfdHun8O0EdXk\n", + "4slAnFLqmIhEAsuUUs6qrDkeYwFylFL/dLJPKT1zV6NpVkhk1K0EhL3FvgtWQW61pqayFM1+mXDZ\n", + "XyB8j7GEHijFW+0BHJe7gS+B/1OW8opMrDIceBfYONZK9IV+DJxrdwfzGLCEwWziV/DJNSqaAZCw\n", + "QqmFceY5YiiWlXwZl8/2/zlE/DeO+gc2Gnrm7iLgNuBZ8/NLJwIFAt5KqWwRCQLGA9ZaXFOj0TQh\n", + "VHrqe2KVRFh/n7KoHdUfYYZpFgcYpSVT4iGjD2Q+/LMq+dTmU0SskgD4AH93VPpiFR8Mi8Q9wB+U\n", + "RS2M+Enm7GxNTOBXeAeXGOGFW2iVn8Jf7WUsTVpzKDpBZPnhSLxkBgOUj7qX7SeyPOYnqSdqo/if\n", + "ARaKyO8wwzkBRKQTME8pdRWGmehzEbFd632l1Pe1klij0TQtTvnu44ce30ri1aHgB2Tvg6NPOFee\n", + "pl+gxBfWPOCwPS/PtiZWCQH+Cdxsm6Frbu8HLMAoizhYWdRRsUpHLuH+sDVYdpYw1jYJazMha3L4\n", + "8la4qsykFMyNRe+zvd2ANsTG3gijvudE5nqytjfS+ge1QSdp02g09YZITDy9A97n6MA25L5pTCJT\n", + "XsCMdFg3s6Lyr6q0ZDQ76Aqzd1/DgJwQvNt/wKztSiWJVbyA+4AngSew9j+IumA2XkEBzFwaQ0nR\n", + "EvVm3i1OZTMzd7bmUPT7bG83MiCH4XfCQ6vg3vV1n0yuPtBJ2jQaTSOj62z29WtD8Qtw4Qcw+h/w\n", + "5looeSuy8pDI3Zlw9WnwE8jeC0efjGYHo+ClByOIGtcfts+FJ+ClXp2lHXcyHQgBRpMY3bvsxRH3\n", + "OJzLhPe6jZD5MfEVXzKOEU8JIsuvglh1Dt5cBJftM9rURTK5xohO0qbRaOqREH8CFdx8DYx9Br7+\n", + "j2HGASqGRNp7+yuHwjdh8FlbuKA1QFeY/R+I+sMko+5uxxwj3UO4H/Mw5hCNVRaVUhZ33zsJBi6A\n", + "z98HNT/K6NlXji0Lp2BX+tC0i61Uhe7xa5okzXIafTNDrOLFuKgILv4W1j4CH3/uoPTh/JBIU2m3\n", + "2W9E8qSNxxZiGcIO/yJvuHKvYYKx0eko25RFPW3fYjqHAzLgsw8dCqxXHXdvZuHsVbEIelPPwlkZ\n", + "WvFrmhyVxnqfN/lG4ynEKn2ANxm5z4t3Yk9wPL89OCr9O9LhYHmlGkZrRt8NAz6Bnx4zFT9AcEA2\n", + "5PuWwCM/l79OYQEny28xncNbp1eQqOq4++aahbMytOLXNEHMnmHntRB8DI4Nhsz/RMFV1U6j1yMF\n", + "93HnmYlVWgF/wkiD/BSBJa9y/PgE+MkKV/d0iOp50nYOsUqk33HekFneF6uND8EruyGvncNZc87t\n", + "C2LerTDqvVxCbVud98gPvQyzep3vHD5Ybc+9OWbhrAyt+DVNEHM4H3oEhrwJHTeBdyGcZqRY5TmM\n", + "ohubgBRlUSW2o/RIwX3ceWZilUHAfIxwyuHKogxruQWnClWs0h54hBJm9TxI8ePL/cSSu480HJX+\n", + "zDSity3dPY1nj29g/cQkVGgpPpX1yO35icY/BSE9oUBB1nlZg1s6OpxT0+Qom93pSHA69Jy4kalb\n", + "vwAGm0t7YCu2F8F/R8zg8E+j8T8D/pnGxCAA4pfUd5ripkrZsw5LgbwIyG9j7rE/M7GKP/AEMAuY\n", + "A7xTcSZtuXNapR3wkNn+/XEvceGKM8SVCrzcJpikM/0oJIhNFBZmjU1bTedzF5E09ADZEZmujNIq\n", + "eVmlwur7m+MLXodzaloITobzOU+ksbXkSbXF3gMUq7QBBmG8BOKYsmMQIW0gOxJCjsCOG2HjLDjh\n", + "G9zw99BUMEdXlz8OUYsJTvam31ohpCDvsnHhkrw1ll8YSBywGbhIWdSximew5cL3CSJ4cxwdGUJ7\n", + "vPkAGKQs6lBCoiwHyAiA+TfmkBa2gegTEHS2lW9Wq9DRrIjNIvfzQcZEXah+lGaaAgF8c6AwmOaQ\n", + "UbMu0T1+TZPEcfKNq9PoRSYtodXnE+iwDfp+BSNegRI/8MsooVVpKnYT0SZgk7KoUw1xL40Zx9FV\n", + "MN8QL7/nY3WAbF949AqYPwDFWTLzu+CPUXsjGdhtLsk936DbmDP8Pepier58MUxJhuyf2b/zNPfZ\n", + "zDSTRJYshrIRXK4PbO4IN/XowKHwCOhUYpSOnLfeIb1z5aM08b9uJX1+cwkD34V2u+ClvaC8cczD\n", + "05yoie7Uil/TYjjPBOCbDdddmEOPgxn4q9lAG+xmosFAJvYXwa/m5+GKZgxbjzYE/LMh/xC83Fyi\n", + "QRyf2TAmsJ7vWd4dbrsWrtgLz38Pt+SzZHEiU4HeGNkz+5mf/aWEQXjh1S4XnlsKt28xzus4IzZG\n", + "JH4UvOQYSpkgF7BYvUoO64FE439VHAClNiNFeSVuzt6NA6ZT4H0rB8e3YstvYfdk7Hn6m6dJT5t6\n", + "NJoqOK8wSWHOORYG/RuL6ozhlPyTsqgHoUyR9MD+ErjH/GwlVrG9BDZ1+oqQScKcN5VdadW8gHjj\n", + "w/GZtWbdKKC1XzHMX2QofjBmtyqLOofhT9kqVgkE7gWubL+XUwt/pn2JGAVQbDjOiLWFUo6i9Tt+\n", + "DGqXiz/J6g/kcBWw2mhUGFJBMiM8U6zSH5gO3IrhVF7AR11uZ1/nRLjR7cieloLu8Ws0gFjlImAh\n", + "hqb5vbKo3EraRQJDMF8IftlM8vUl4KLjMPKw0QOGppHjxV0qmmQAVgJ/h1MhsCNLKNwYy95TcUwG\n", + "VgGJExN5vuIx4Pz5OHfKXpcObYG37GmR5Xf7if16CXEnhwGdgfeAd5VFbSt/LvdMgU0VberRaGqB\n", + "WCUYmAsMBRJcSSOcILL8DX9iN3eEQ63ht6YpIwFWLFQqrj7lbWgqmmRWAu9C0Ty715Vbgsn9qQuP\n", + "HNylXnF2DBjx92vg3a4wqqJ5zJnCBkC63E+QTxdaZ7Tjkm1B9Mv5wrg8PzqG7LZEtOLXaOoAscrt\n", + "wD+Ah4H/VhWa6KwXDM2zxw/QO1ymhoXwx+II2maG0H1kWwL3hMMZf0gxDSkV7z1GJL5b+Rmxa0bB\n", + "rY4vgxmQngpHO0KO7UWwI5HFwGjgt8BvMMxr7wKfK4vKbsj7bsxoxa/R1BFilQHAJxjK5m5lUTnO\n", + "2lXRo53dVG38ZjGT7thLHDqWOwwDUoGCbpsZ9NQ+WvXJMOrZhptJEaoa7YhVZOwrLJvdnth1nWFC\n", + "mt1X8ATwVyCtLUwdyultIyhUvpzByLH/vrKoQ/V2000Yrfg1mjrEdFL+GxgLTFMWtdVZOyc92kaf\n", + "40WsIhiFkpwp9+7AUewlDnebn6nAGIy89+mXPUfAj3kMr3huxx6/WKUtMBwYYVt88wibeBCfEUdg\n", + "6i7obwbN3hUEO26APeFw0zZYs5tV625jbFUjLo1W/JpGTFMOeRSr3Aq8iFHSb15TUkRmtSpnyr0P\n", + "Ririisp9D5CmLCrf4RxewPVAIkaI6xPA/6ITmVRxtHN7Kw4njeXbk3EEYyj6jsBGYJ1tmZDIvCVO\n", + "zGM3tYVbImBCKviUNk8/SX2gFb+mUWIzh/wHomz/4FmQuhrub0LKvx9G1M8O4C5lUVkeFqkM0zTT\n", + "E+cKvjWQwvnKfY+yqDOO56n4cj4ovLzTgi9GnexCDIX/nbIoZb4M+rX/gZm9U7jez5uwbH8Cdw9h\n", + "X1YMPwBrMRR9ckXnqzPz2GPARGCcQ7vm6iepa7Ti1zRKbA7QO6bA6q4w4KSxfJ7Lll2TuAPYrSwq\n", + "r9oTeRixSgBGz/9yICE6kciGGsWYpplOOFfu3YDDOO+9H1EWVVrd+R2VsQKSesP0KyjIDOVIaQAP\n", + "YExgG+GwDANO4tCTx5jt7FLhEkfz2FkIDobIz437A5q+n6Qh0Yq/EaHT/9pJEFm+EGILvCElHHZG\n", + "GMvrXTh5PIrjGD2/o8AuYKfDktyYetY2xCo3SjFvDP8fBWtWEVHdKMbNtMatKW+OcVTwOThX7nuV\n", + "RRXU5p5sL+fNHeHuq420Cdbl8I9MTqy5k2KMZPq2Xvw6YL2yqIzaXNORpugnaSxoxd9IaGnZAauj\n", + "upBHM4d7L6A/MMBc+mNM/T+N8RJwfCnsqkulUxPGRMrKc1O4pNdpo0Zra1PtVjRPOP0ueM9IZeCS\n", + "55mcfozzlXswDuYY7Ao+RVlUnacXFqv4AhfFv8gH32bSOzUMNnSChB3gpeCaYHZ+8xBXA/ubkm+j\n", + "JaFTNjQazOyAU2+BnI6QPgTS/xjF6QdbZHbA6sraKYsqxp7Y60tbG9OOfAH2F8JI4A5ggFglH4cX\n", + "gcP68YZQUJ2PUbpgPjwVC4Xe9u3nF+c2vwv9voCh84ySgqGHo8iVF4BlGEp9PfC+uX60vuQ3n2cU\n", + "5U02FwKpZ/0JIBOiThuLjZIcDpbl1dc0G3SPvx4QSVgOC2Pp9T1E/mpfQvaX4FOyFsNe+mu3Dwjs\n", + "v4fJoeDX1CJd3KUuh/IO9m7byMD2GQ14UWF0YH4eqkyh1sQs5+rErbLvQsfNEHrIqAFwtgeU3Frv\n", + "mSLFKh0pr+SHY0Tl2Mw1a4FflUXlNsf5CC0F3eNvNJh1P9PGO9QNBQIvX8ac/z0NDGmzkemjjzHm\n", + "Q4dCpLf5MaRbtPztUAKvO4bTQdMOh4S6LWtnKvAj5rLUcZ9YJYLyL4SrzPVQscouKr4Unu7fD8a8\n", + "6G5VLteLc5vfhWODjKWMqmvAuouZbmIo5RV9CHYl/zKGXf64s+NbWs3Zlo7u8dcDzm38M9NgzWyb\n", + "MrH1GL/rBaEFMPwotCqFkd3IXjsDH2APG9qe4JcLO3udC/KNKMiInK92Bl6FMYG0qYVDehqzKEt/\n", + "KvoRir26cepCL072h+VWt6pyuTKKceW7UIN78QFiKK/ke2Jkx3R0wKZpu3zzR/f4Gwnnpf91kh0w\n", + "BPzBiG55ZxDsbwPjDkB2OseBBBZ2iSXtsscoeCeiFDgOXBd6A7Mikng1LYd5EBUPzc5nUF8jG9Mx\n", + "upqyPL8G4n/dSsL+cgkRuyC/tcOe4Aq2+vNxZRTjynehKkyzVg/sCv5iYCBwALuCnwtsUxZV6Mo5\n", + "NRqt+OsJ84dd6Y8725g1yYNrjOVEECzrDvfH4A98ztXHI0kt8WPv25B2JWR3pijrY7acGw5sAJw5\n", + "Eps2zuzM9Z7bviA/j/ShkD60wo66M8VU911wxDRVlUtxAJzDruT/AmxsjGGumqaDVvweoqKNuH0u\n", + "LN1BWrsdzD6mVJK0n7CGrrEXE7UYAk/BqocAaFUUVHaOHEMhNBu6wux5EJXlZyTqGnyMBhjZOKnf\n", + "20BFO8xcQEMor+TDMaJ81gH/AWYqizpa37JoWhZa8XuIap1pJ73OcnIW/Dqr3HH+GPVBnDsSmzY2\n", + "89emjjAtARZ9aBQ3qc+RTW1NMa4iVvHG8Cs4mmz6ANsxlHwSRi6cPa7MtNVoaoN27jZSnDkF/bg5\n", + "byBJaeFkHvFExEV9z0YeL7Lxe6MHzLe94Y5rDeX/5GE2fq/UsLq6Tn1j2uW7Ub4nPwRjdrJjKOWW\n", + "2s641Wi0c7cZ4awnWsDBf69VZz3izK1kNnK1YY/ukA/qMeBvwFUp8PaXcPlN0OtTAqs71pOIVcI4\n", + "3y6vsEfY/B+woWJSNI3GU+gev8YlRCYtgcUTCN8N4/9shD1m9IG819dxw6apuDDj1DR3tAe6OFsC\n", + "shjhfwT/futg3EHwKYGQ3vCXqRQVBTBOWdSa+r3H6kc0YhV/YBDllXwkRuphx1DKwzqUUtMQ6Fw9\n", + "mnqjbAaq/1novsxIPRCeApGfZRJ5Nh8jx8wB4BhwFrCZMAKwK/tIjNw7h50to1/jqR8yuCSguPy1\n", + "B17Exq1T6QZMri/l73REIzNTGZL0PNekF2BX8gOAZMpnpdzV0uu+ajyHNvVonFJb27xYxZeIsULA\n", + "TxB62FhCjoL/GWhVBFCCMQO5nfnZESN1QhBGlEoJkAb8hKE0bfnhUxxLGsYkyjOzIbLibNiSrTzJ\n", + "VBSwSKwyRVlUuVj8usHMqRO+Bwb9F7qshciNURQWvAB8haHg3wM2N0QKaZ3dVVOfaMXfzKnONm/m\n", + "mO9MJeYXcwnjzl/OcGJqPmcu8yeri5Fv5uiWYxwLfI7Lcj8BjpnJ1spf33B0tsOefbI3MM1cjxKr\n", + "nMWWiTKRlIwkPrxyC3GtC1F5ijxHJ7ZY5TbgK4lr/wwrho6vW6UY4g9Aq3NQ7A+//BmODoe8e9cr\n", + "tfDm2p3bPcr9z6QElDd17U/RtGy0qaeZU2ab7/M1dNxi77GHL8smPK8Qw0RzhErML+ZyQllUiaGQ\n", + "utVZ2KOZLbIz9heCYx76btjrvtpGCHvY1HoCffNn88Eybw6PMs9U+5TXZc/pPKpP3VDXiExcQo85\n", + "Exj9PJzqB9+94DFZNI0fberROMHsyYanGL3ZYwNhz1WQn7uHGcsnAadcdUK6MwPVpfMZ8eqHzOVH\n", + "x31mPpru2F8K/YEpbOk7hh1Wb26aAh9+haH850URdLlFrLIZSK+ZU9VzE7lsmPc8jd+HjEHdZ0za\n", + "23aLQ4vq00hoNK6gFX+zx8wOufqPFba/dlJZ1MmGl8c1lEUVYfT0Uxy3S2LCcpgYyxcLIPiYfUeo\n", + "9AU2AYFiFdtxtmImKRgTo07jhBiR+Ikw24fkcyf55NQu+qZnEn6kPiZyOcMsiD4TeADYx8rujsie\n", + "8wAABthJREFUe9i2eQjKq0LLus3oqWm5aMXf7PF8T7ZuMV9kqRPLb073Xa0sapJZutDRbDQRmA30\n", + "EavYXiZlFa46LKHDRF8eeLuQXoYPOpNZrDu7ug4nyFWWeE6s0tmUbSZGeunfKItaL4kx8XCXk4ye\n", + "TfV/pmlsaBt/C6CubfOepKZpjk0ncwTl/Qi9A04znhCCw87BA2vgoVVG+4oFVWqKs8Rz13bi4OLr\n", + "SSkMZwiwAHipYpWr5vQ/09QvOo5f0yKoS6WYILL8IyH2cKjxd7dMczusWKhUXG1ltdVdUMCPPeH5\n", + "0bC1A/htY8/+0YzUs3k1tUU7dzUtgrp0MmdDvpeyK3wbdZX51JZ4LrkdPDAR/rQKvvoQppeQvu87\n", + "rfQ1nkErfk2LxvUSijXDVneh/ynYNhds3bLmllJb07TQil/ToqnvWrOOLxab0m+OKbU1TQtt49do\n", + "6hlXavNqNDVFO3c1Go2mhVET3Vlxhog7F5smIjtEpEREhlTRbqKIJItIiog8XNPraTQajaZuqLHi\n", + "B7YB1wErK2sgIt7AKxiTaAYAN4lI/1pcs9EiInGelqGmNGXZQcvvabT8TY8aK36lVLJSak81zUYA\n", + "qUqp/UqpIuAjYEpNr9nIifO0ALUgztMC1JI4TwtQS+I8LUAtifO0ALUkztMCNDS16fG7QmeMBFw2\n", + "DpvbNBqNRuMhqgznFJGlGEU1KvKYUuprF87fODzHGo1Goymj1lE9IrIM+JNS6lcn+0YCiUqpiebf\n", + "jwKlSqlnnbTVLwmNRqOpAZ5K2VDZRTcAvUWkO0ZRjRuAm5w11KGcGo1G0zDUJpzzOhE5BIwEvhWR\n", + "xeb2TiLyLYBSqhj4PfAdsBP4WCm1q/ZiazQajaamNJoJXBqNRqNpGOo7qscpIhImIktFZI+IfC8i\n", + "bapo6y0im0TEFWdyg+CK/CLSVUSWmZPctovIbE/IWkGmaifTicjL5v4tIjK4oWWsiurkF5FbTLm3\n", + "isgvInKRJ+SsDFcnM4rIcBEpFpGpDSlfVbj43Ykzf6vbRWR5A4tYJS58d9qJyBIR2WzKf7sHxHSK\n", + "iLwlIsdFZFsVbdz73SqlGnwBngPmmOsPA89U0faPwPvAIk/IWlP5MaKhBpnrwcBuoL8HZfYGUjHq\n", + "2PoAmyvKA8QDSeb6xcAaTz9rN+UfBbQ21yc2Nfkd2v0P+Aa43tNyu/Hs2wA7gC7m3+08Lbeb8icC\n", + "f7fJDmQArTwtuynPJcBgYFsl+93+3Xqkxw9MBt4x198BrnXWSES6YNzUm1TuQPYE1cqvlDqmlNps\n", + "rucAu4BODSbh+bgyma7svpRSa4E2ItKhYcWslGrlV0qtVkrZMuuvBbo0sIxV4epkxj8AnwKNqR6y\n", + "K7LfDHymlDoMoJQ61cAyVoUr8qcDZjkeQoEMZfgoPY5S6iegqtoNbv9uPaX4Oyiljpvrx4HKhHwR\n", + "+DNQ2iBSuY6r8gNgRjUNxlBGnsKVyXTO2jQW5enuZMDfUUfFWuqIauUXkc4YCuk1c1NjccC58ux7\n", + "A2GmeXODiExvMOmqxxX55wHRInIU2ALc30Cy1QVu/27rLR9/FZO/Hnf8QymlnMXwi8jVwAml1CZP\n", + "5NKorfwO5wnG6MHdb/b8PYWrSqTiyKqxKB+X5RCRS4EZwJj6E8dtXJH/X8Aj5ndKaDyjXFdk9wGG\n", + "AJcDgcBqEVmjlEqpV8lcwxX5HwM2K6XiRKQXsFREBiqlsutZtrrCrd9tvSl+pdSVle0zHRUdlVLH\n", + "RCQSOOGk2WhgsojEY5SvCxWRBUqp39aTyOWoA/kRER/gM+A9pdSX9SSqqxwBujr83RWjZ1BVmy7m\n", + "tsaAK/JjOnTnAROValSlDV2RfyjwkaHzaQdMEpEipdSihhGxUlyR/RBwSil1DjgnIiuBgUBjUPyu\n", + "yD8aeBpAKZUmIvuAvhhzkRo77v9uPeSseA542Fx/hCqcu2abWOBrTztZ3JEf4w28AHjR0/Ka8rQC\n", + "0jAcXL5U79wdSeNyjroifzcMJ95IT8tbE/krtP8vMNXTcrvx7PsBP2A4UgMxsvcO8LTsbsj/AmAx\n", + "1ztgvBjCPC27g3zdcc2569Lv1lM3EWZ+SfYA3wNtzO2dgG+dtI+lcUX1VCs/MBbDN7EZ2GQuEz0s\n", + "9ySM6KJU4FFz213AXQ5tXjH3bwGGePpZuyM/RhBAhsPzXudpmd19/g5tG43id+O78xBGZM82YLan\n", + "ZXbzu9MO+Nr83m8Dbva0zA6yf4iR+aAQY2Q1o7a/Wz2BS6PRaFoYnorq0Wg0Go2H0Ipfo9FoWhha\n", + "8Ws0Gk0LQyt+jUajaWFoxa/RaDQtDK34NRqNpoWhFb9Go9G0MLTi12g0mhbG/wNCBunWNpTTeQAA\n", + "AABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "modelNN = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelNN)\n", + "fwd_NN = generateFwdTest(environment, modelNN)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Weighted Nearest Neighbor forward model\n", + "\n", + "To perform a forward prediction of $m$, the Weighted Nearest Neighbor model looks for the $k$ (parameter) nearest neighbors of $m$ in the dataset, and returns the average of the $k$ corresponding $s$. This average is weighted by the distance to $m$ with a gaussian of standard deviation $\\sigma$ (parameter). It finds the $k$ nearest neighbors (with the same algorithm than for NN model :[scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html), with k = n the number of interesting neigbhors ) before weights them. It returns the n-dimensional weighted neighbor $s_p$. " + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEZCAYAAACAZ8KHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xm8HFWd9/HPLyGQhB2iCCGAQkBAYRDZRDQID4SMghv6\n", + "sArIgAskPPKouAxExIVxVBZHNmURlLihwgwGfdSLDAQlyqaAkwCRkAQkJAqaBAL8nj/O6Xvr9q3q\n", + "ru7b1Uv19/165ZXb3dVVp6u769fn/M5i7o6IiEheYzpdABER6S0KHCIi0hAFDhERaYgCh4iINESB\n", + "Q0REGqLAISIiDen5wGFmL5nZqzpdjrIws2PM7JY2H3ORmR3UzmP2IjPbwsx+bWbPmNmXCjzO/ma2\n", + "wMyeNbPDizyumf3BzN7Uyn22mpkNmNn7O3Ts2WZ2bfx7m/ieWBuOW/M72dbAEQuzKr74Z+MH8RUF\n", + "Hm/AzFab2daJ+w42s0eryvSkmU1M3Heymf1qlMc+2szmx9e51MxuNrP9R7PPdnD3b7v7oe0+bPzX\n", + "sPj+vaXF5elWpwB/cfeN3P2jBR7nXOAid9/Q3W9s1XHN7Goz+2zyPnd/jbv/epTlLVrTn88WHTv8\n", + "4f5YfE9qlsXMppnZ4hYcN/M47a5xOPDW+OI3jB/EJwo+5j+Af62zzRhgVqsOaGYfAb4KnAe8HJgC\n", + "/AdweKuOUQQzG9vpMjTBgcJ/gXWJbYEH23CcbYAHOnDcUjOzdTpdhpZx97b9Ax4F3pJy/zXAR+Lf\n", + "k4GXgA/F29sDTye2/SiwFHgcOClu+6qM4/0KOBt4prINcDDwaFWZPg48DWwc7zsZ+FWTr3Fj4Fng\n", + "XTW2WQ+4AFgS/30VWDc+Ni2+to8Cf4mv9e3ADOB/YjnPSuxrNvADYE58nb8Ddks8fhawMD72R+Dt\n", + "icdOAG4HvgIsBz4b77stPm6xbE8CfwPuA3ZNvM5vxTIuAj4FWGK//w18CVgBPAJMr/O5OCuWbwVw\n", + "JbBe4vG3AvcAK2N5XxvvvxZ4EVgVz/lHgasb+Cyl7jc+thXww/j6HgFOrzrn3yN8bp8B/gDsmfHa\n", + "3gA8BWwdb+8eX+OONba/C/gr8Ftgv3j/1cDzwHPxtaZ9j2bEc/gM4TN0Zo1zfhIhOKwA5gLbxPsf\n", + "rjqn36k+bvxcVD5Xy4HvApsm9v1G4I54Xh8D3gf8S9V+fhK3XRT3uVU8ZnI/e8RzN7ZWmTNe3/eB\n", + "ZfE83grsknjsasIPuf+M5+pOEtcQ4H8BD8XnXgwMAO/POM5san//FgEfI3x3VhN+pO6bOD/3AG9O\n", + "bP/KWN5ngJ/F418bH9uO8HkeE29vBlxFuIasAG4AJsbjvBjP8zPAK3K8Z8cBf46PfZKMa/Xg9s1c\n", + "HJv9FwtzUMr9JwI3xr+Pji9uTuLD8qP493TgCWCXeIK+Q/3A8X7gy4mTnxY4DiJcJD4b7xtN4JgO\n", + "rK28uRnbnBs/OJPiv9uBc+Nj0+LzPw2MjWVZDnwbWD++9lXAtokP7vPAO+P2ZxIudJUv27uBV8S/\n", + "3wP8Hdgi3j4hHuvD8QM9nuGB41BgPrBRvL1TYl/fAn4Uy7Qt8CfgpMR+n4/n3oAPAEtqnI9FhC/W\n", + "ZGBTQtCpvBd7EALXXnFfx8f3bFzi/XtLYl95P0uZ+43n4nfxPViH8GV+GDgkcc5Xx/fagM8D82q8\n", + "vvOAXwATgPuJgSxlu80IF5NjYhn+N+GCsGl8/Cri5yTj+cuA/ePfGwN7ZGx3BLAgvp9jCEH/9qrv\n", + "RPKcDjsuoXZ+B+FiPw64FPhOfGxbwsXqvYTP42bA7lnlTx4rnqOTE499Cfh6njKnvMYTCJ/NcYQf\n", + "P3cnHrua8J16fSzjdcD18bFJsfyV79MZhO/ISRnHmU3t798i4PeEz/Z68f/lxB9ShOvRcmDzeHse\n", + "8O+x3AfEsnwrPrYdwwPHfwHXx/d6HeCAeP+bgcVV5az1nu1CCDJvBNYlXC/X0kWBY1Es4Mr474Z4\n", + "//aEL4gBlxDaVBfHx64Bzoh/Xwl8PrG/qdQPHCfFD8Nf4wlKCxxvAXaN20xidIHjGGBZnW0WkvgF\n", + "DhxSKRMhcKxi6Nf7hvE17pXYfj5weOKDe0fiMSPUUt6Ycey7E889AfhzyheuEjjeQggI+5AIhIQv\n", + "yHPAqxP3nVI5Z3EfCxKPTYyv4eUZZXoUOCVx+zBgYfz7EkZebB5i6EtSfZHL+1nK2u+b4uutPi+f\n", + "AK5MnPOfJR7bBVhV4/1eJ75n9wM319juOODOqvvuAN4X/76KGFAznv/n+Ho3qvP5+ymJCyHhQvwP\n", + "YErGOR12XMKv/uTjWxIunmPjefphxnFHlJ/hgeP9wC8Sn+PHKp/jemWu83o3iZ+/DRPluLzq8/Zg\n", + "/Pt4Et+neN9iageOtO/f/onXd0Li8Y8TA0HivrnxuNsQLtgTEo99m5QaRzznLxJbSar2N42RgaPW\n", + "e3Y2MYgkvq/PUSNwdCLHcYS7bxr/vRPA3R8mfAj+iRBl/xNYamY7Er7It8bnb0l4Eysey3VQ9+XA\n", + "1wi/9D1jmz/G456VtQ2AmV2aSO6flbLJ08AkM6t1brcifMkrHov3De7D4ztI+GUL4dcxifs2SNx+\n", + "PPE6PN7eMpb3eDO728xWmtlK4DXA5onnZibR3P2XhPP2H8CTZnaZmW1ICK7jUl7D5MTtJxL7WRX/\n", + "TJa5WvX7Wjkf2wJnVsofX8PWDD9fyTLn/Sxl7XfL+NhWVY99gpCvqki+H6uA8Vnvubu/QAhauxJ+\n", + "zWXZipGf6T9nvdYU7yI0Vy2KHUP2zdhuW+DCxGt7Ot4/OWP7atsBP0o8/wHgBWALwjl8JOd+qt0A\n", + "7Bc7zLwJeMnd/7vRMpvZGDP7opktNLO/ES7eED63FVnfp61IfJ+ieonmtO9f8j1LPn9b4Miqz9b+\n", + "hOakrYCV7r46sX3yO5Y0BVjh7n+rU7aK7ch+z7aseg2rGDq/qbqpO+6twJGEJoil8fYJhKaLe+I2\n", + "ywhRuSL5dz1fAg4E9qyxzTmEttjML5C7f8CHkvtfTNlkHiFav6PGcZYS3siKbeJ9zZpS+SNevLYm\n", + "XCy3BS4nNEVt5u6bEtrjk8nkzCAJ4O4Xu/vrCb+qdyTkEZ4i/DKqfg3VX7hGVL+vS+LfjwGfS/zY\n", + "2NTdN3D379Yof57PUq39PkaoASYf28jd31rjmJnMbDLhV92VwFfMbN2MTZcQLixJ2zJ0Lmpy9/nu\n", + "/nbgZcCPCXmYNI8RanjJ17e+u9+Z5zjx+dOrnj8xnuvFhFpfahHrlH8loV3/vYRmxuubLPMxhI4o\n", + "B7n7xoSmRsjXiWIpw79PlrydIfX7l3xpVa/j2qrXsaG7/xvh+rZpsocn4f1PO2+Lgc3MbOOUx9K2\n", + "r/WeLat6DRMZ/uNyhG4LHKcBla55A/H2bYlf398DTjCzneOLOyfHfg0gRuYvE6qKqeKv1e8yih5W\n", + "8ThnA/9hZkeY2UQzG2dmh5nZ+XGz64FPm9kkM5sUt7+22WMCe5rZO2KvjTOANYSE3/qED9FyYIyZ\n", + "nUioceRiZq83s33MbBzhV/Ua4EV3f4nwXnzOzDaIAer/ENqKm2HAh81sspltRmi/rgSGK4APmNne\n", + "FqxvZv9sZpVfiE8y8kKV57NUa7+/BZ41s4+Z2QQzG2tmrzGz1yfKm++FhQvP1cA33P1kwpf0sxmb\n", + "3wzsaGZHmdk6ZvZe4NWEWlPN48bP2DFmtrG7VxKjL2ZsfinwSTPbJT53YzM7stbLSHn+581sm/j8\n", + "l5lZpcfgt4GDzezI+Bo2N7Pd42NPAvXGXH2HkEx/V/y7mTJvQPjxtsLM1ifkoGq9nqSbgV0T36eZ\n", + "hNpALVnfvzTXAW8zs0Pi52p87D472d3/TGjS/Ex8P99I6MAxgrsvIzTffd3MNonbV8bDPAlsbmYb\n", + "JZ5S6z37AfBWC+N31iW0zNSMDd0UOH5NeMMrX/bbCcnEwT7e7j6X0Bvpl4QeRr+g/q+/5OMXEqpn\n", + "tZ5zLqGNr6FflcMO6P4V4COE5OpfCNH+Q4RkMoRk6XxCQvi++Pd5GWVOu1392E8Iv9JWEH5tvdPd\n", + "X3T3BwjBch6h6eg1hMRz8rlpx6rctxGhxrKCkJ9aTqi5AZxOaBJ6BLiNcMG4qs5+a72GbxN+bT5M\n", + "SIKeB+DuvyPUAr8Wy7GA0B5c8QVCEF5poRs05PssZe43Bsa3Epq7HiHUsC6P56PR1zeT0ERS6RJ+\n", + "InCipYzpcfcV8bhnEs71/yV0X19R47hJxwKPxuaZUwifhRHc/cfA+cCcuO39hI4QWaqPeyFwI/Az\n", + "M3uG8PnaO+57MaG57ExCc8fdwG7xed8Edonv1Q0Zx7oR2IGQJ7y/yTJ/i9DEs4RQw55XVf7M9y82\n", + "ax8JfJHwHuzA8O9MtczvX+rG7o8TEv2fZOjacCZD1+KjCTm2FYQflNeklTM6jlDzf4gQLGbGYzxE\n", + "+HH6iJmtiE1/td6zBwitEt8h1JRWUKd5zoZ+gLWemV0J/DNh8NBrM7a5iJCcWkVIIt1dWIFKyMzO\n", + "AXZw9+M6XRaRftOv37+iaxxXEbospjKzGYSTPpXwC+mSgstTRv0y+E2kG/Xl96/QwOHutxG63WY5\n", + "nFgVc/ffAJuY2RZFlqmE6jVfiEhx+vL71+kh8JMZ3pb2OKFHwpPpm0s1d/9Mp8sg0q/69fvXDcnx\n", + "6qpe30VvEZFe0ukaxxKG95HempQ+62amYCIi0gR3b3keptOB40ZC//o5Fka5/tXdU5upinjxvcjM\n", + "Zrv77E6XoxvoXAzRuRjSl+fCbCphgOkb4z3XAbOszgjwZhUaOMzsesKEW5MszA9/DmGqCtz9Mne/\n", + "2cxmmNlCwpiAE4ssj4hIqYSR6jMJgxwnEMZrnUpYRwUKWvOp0MDh7kfl2Oa0IssgIlJKGbUMhgaM\n", + "FqYbkuPSmIFOF6CLDHS6AF1koNMF6CIDnS5APbGlZa6FySjnxjFteZ88BrMzgHsJQeMJ4Ajcj2tH\n", + "0ICCR463ipm5chwiUgYxSFxImM6kYiEwy91vrvPkhmoZRV07VeMQEWmvmQwPGsTbp2c+owtqGUkK\n", + "HCLS90bVdNS48Rn3T0i9N9QybiWsZDiBUMvYdTAB3gGd7o4rItJRGU1H25sZdZuOmrMm4/7Vw27V\n", + "6zHVQapxiEi/a7zpaHQuIuQ0kh4GLh681YW1jCTVOESk3+VqOoo1k5lx+zXARc3USOL4NQiBaQKh\n", + "pnGxu9/czbWMJAUOEel3G2bcX1llsuXNWfE5w5/XwXEZjVLgEJF+lzUmIXl/VnPWj83sfsL0SfvR\n", + "TG2kR2oZSQocItLv/p5x//ZmNkAIBFtlbDMOeB2wOzC26rn1ayM9VMtIUuAQkX6X1ctpU8JcexCW\n", + "tq5lbNXtSnI9PXD0YC0jSb2qRKRvxdzFy6juCjvSROoHj2o9My6jUQocItKXEgnv1zF0kV8NPJvx\n", + "lIeB5Q0cYuS4jC4a/T0aChwi0q/SEt4TgOcytl8CvA9YmmPfPTUuo1EKHCLSr7LGb4xnZHBYBdwZ\n", + "k93/Avwt47krgLnAzMFxGSWpZSQpOS4i/SorKb4B8Dyh5rFevG8icKyZ3RUH8N3DUOI86X53Pwzo\n", + "2R5TeajGISL9Km3qj4rNGAoaFclpSLLnmyppLSNJNQ4R6UuJqT+uJQSKPCpJ9IuA7RmeI3n4ePgh\n", + "IZdRulpGkgKHiJRSnrmlYvC4Czg0525XJ54Hcb6pMbD6p/DYISGg9Ny4jEYpcIhI6TQ4t9Q84ABC\n", + "HqNiWfx/y8R9w3pKDc43NZTLOCU+VMpaRpJyHCJSRrmmSo8B5hSGB401wGXAycB8YCWht9TwnlR9\n", + "kMvIohqHiJRRVlfbyWY2l6Hmq+0ZOQ/VeOCtwF3AJoSpRyDkQS40MxwWUNIeU3mYe9bEkN2jqAXX\n", + "RaRcEnmNvRm64Cclu9jWsoIQOIblPgz4LDz4KdiOHshlFHXtVI1DREohI69RLU/QqBhWa9mBUMU4\n", + "AHaOd/VVLSNJOQ4RKYu0vEazHiUu5GTALEIi4wDgKVhLn+QysihwiEhZZOU1GuWEALTVDoRBGRcQ\n", + "sufXAq+BP3Zr01S7KHCISFlkjeZulBlsfAa8olLLWAYcDhwP/CV7nqq+ocAhImUxj5FrZqxtdCeV\n", + "WsZXwSq1jF2Bm4Y2qbd2R+kpOS4iPS8mxo9l+HiMVcCPgM0JPaBeS42pRYyhJfkmEmoZH4CXbhz+\n", + "A3v4dOl9SoFDRMogLTE+Edi8MlttHL+ROrVIoscUEGoZs4CVYVGneYTAsxq4uO464n1AgUNEyiAr\n", + "MZ5cvnXExIRptYxTGWyWWgt81d0/0/LS9jgFDhHpGTUmLsye5jyqnpjwn8Cug513DWuOJ2sZLxFq\n", + "GgoaGRQ4RKQn1Jq4kIxpzqnKR7j7zeuZ2dnw72fCjuNhzLPw95nwP1eHYKHmqBw05YiIFCrP9OY5\n", + "95OVo3ieoZrFU4S1wVMDwPvMTv4wXLx3bNq6FvgIPLIcTi9jsNCUIyLScxqc3ryerDzGuvEfhFTF\n", + "dSOamMzGADMvgy+PhzFVuYxXEZqvShc4iqJxHCJSpFzTm+eUZ4DfOOC0YfeE9TJuBb46HsakjMuA\n", + "4Ul0qaPQwGFm083sITNbYGYfT3l8kpnNNbN7zOwPZnZCkeURkbbLqiXsF7/7M9IeNLMZ8fGBxHa1\n", + "1ghPGhd3Mmy9jDWw8h3w3PGEBTaq9P2gvkYUluMws7HAn4CDCW2OdwFHufuDiW1mA+u5+yfMbFLc\n", + "fgt3f6FqX8pxiPSgWmMnooXArGSzVUbz1kJCpyeIvaKA/Rhqokpa7vAGqtbL2BK2egLekrL9KuBI\n", + "5TjyK7LGsTew0N0XuftaYA5wRNU2y4CN4t8bAU9XBw0R6Wn1agnDmq1i0LiGjOYtd7/Z3Q9z92mE\n", + "4RfDphQZA2uvCKv2jViV7wkYm1GGh8sYNIpUZHJ8MrA4cftxYJ+qba4AfmlmS4ENgfcUWB4RabOq\n", + "sRP7ARunbDYBhtU0JmXsbrKZ/Q54JaE56iVCq9MmwItTYZ1rwkGmA/wXLJ0N/+euoZlss3IkSxp9\n", + "Xf2uyMCRpw3sk8A97j7NzLYHfm5mu7v7s9UbxmatigF3H2hNMUWkSPHX/M01mq0q+YV662nsyMiF\n", + "mDYy4Ax48TwYWzX6eyvgc2b291iGXGM9epmZTQOmFX2cIgPHEmBK4vYUQq0j6Q3A5wDc/WEzexTY\n", + "iVDVHMbdZxdTTBFphRzjNepduGutp7GK4RMYAsPmmBoLw0Z/Jzc5Hbi5euQ4JRzsF39QD1Rum9k5\n", + "RRynyMAxH5hqZtsBS4H3AkdVbfMQIXl+u5ltQQgajxRYJhEpQJ7xGjku3FlNScsJFYnXDh6PmnNM\n", + "VRvsalup/TT04mSEwgKHu79gZqcBtxB+DXzT3R80s1Pj45cR3verzOxeQqL+Y96nSzGK9Lha4zUG\n", + "L9R1LtxZNZI4wHtopxkz2WZRV9sWK3TkuLv/FPhp1X2XJf5eDrytyDKISFvkmZ22powayZ2EdTY2\n", + "arCWUVGqHEa30JQjItIKdWenbYAl/n8bsEMDtYx/xGMuI+RZS5XD6BYKHCLSCqPusZSWJxkDq0+n\n", + "oVrGbZWFmxrVqskY+4ECh4iMWot6LA3Lk8RaxoQGchlNN0u1eDLG0tO06iLSFcxsAHhzA7mMBYRg\n", + "MSJQNVp7qDHGZG6zNZhuoGnVRaTs1qTlMs6AZ1eEmSWqLU27qDdZexh1cr+faFp1Eek8szG3wJ/v\n", + "Az+AUMs4HDgeHl4B/5PxrKzEezNTubcyuV96qnGISFtkNh+F9TKuPCTOZHszLD0JHn0yLOV6MbAX\n", + "sDPDR47Xymc0U3so/XQkraTAISKFy+gxtf3PzI44BI4jXNSfAE6d4X7jE8OfdyzDg8Yq4NoazU4N\n", + "1x76YTqSVlJyXEQKUVXD2JXErLfVuQzgOmAWVTNHNJO0zshxPAzM7LdAoOS4iPSMjIv3iDmmlsPz\n", + "k+BIhqY+r5bV7LSPmc1ICwSqPRRPgUNEijAiQZ3WY+pjcNuy7KAB2c1OmwIXZvWU0mSGxVKvKhHJ\n", + "JWMd8CyDNQUjDNy7lxA0kj2mnoCv1DlsrRUE6/WUkoKoxiEidWU0Pe0WV+/8OyMH2a2BmjPZ1ktw\n", + "A8Oana4FNkvZROMsOkCBQ0TySBsbsWX8VzE4yG5duPhM2PPTMClj9PdEYN88B47B4y5qrx4obaTA\n", + "IVJCBUzYV2t1vorQdGS24Dk4i9iL6npY+2EYlzLHVN3aQuJ1bMXIVQA1zqJDFDhESmY0E/bVCDhZ\n", + "Seqh5wKzYSohnTE4LuNo+BBN1BYyXscqQsDQlOkdpMAhUj65VuOrVivgkD6yetjOYy5j+3jX0LgM\n", + "sxdSnpuntpD2OiYCS3p54sEyUOAQKZ9mJ+zLDDjuflgMIOcCu1T2VT0uYw2sHA8nJMdlVI2rmEzI\n", + "i6wCZmriwd6kwCFSPs1O2FfzQh0DwMzK7eoeUwvgl1PDYL4V1TtIBI8LCbmPScBrqd2EpokHu5TG\n", + "cYiUT9rYhzxNQ3ku1OPTxmW8D/4w1f2gtKCR0Oistc2+DimYahwiJTOKKTfS8hjLgJfHRZbWvAY2\n", + "/zqp4zIev6Z+0XI3PSWS9KuB5WgN8a6iwCFSQs1MuZEScNYn5CReV8llfAF8AiPGZeStBeRqespI\n", + "0v8VBY2uodlxRSRVZWba6lzGj2HFB+HuJ8IPz9wTCOadtbasy7h2gmbHFSm5AgbtjcoYGH86qWt/\n", + "3+/uBze6vwaa0NSbqsspcIh0gdEM2quxv+aDkNnU38Nuu8ebiVwGjKJXU84mNPWm6nIKHCLdoalB\n", + "e2lGFYTMxsSyfH53mPAXePFkGJuYY6odvZq0jGuXU+AQ6Q6tbJ5pLgjFtb+Ja38D1/0z3DQfTqSN\n", + "CyJpIabup8Ah0h1a2TyTKwhVmrPGwPhzYYuz4JVjYT3iHFO433hX2PR7aTsrMiejhZi6mwKHSHdo\n", + "ZfNM3SBUac7aAXbIO/o7qdU5GektGjku0gXixXYWMBe4Nf4/s8mLcN0R12Ng5izYoXpVvh3h+XpB\n", + "I2p0FLiUiGocIl2iVc0zdXMEZlPnw757xO2rekzlzamoy2wfU+AQKaHUIJToMbUHTEhZlQ/y51TU\n", + "ZbaPKXCI9IOqHlML4JdvgO2Ww6sSWzWSU1GX2T6mKUdEyixRyyCxKh/uN8YEd9NdXkf7fCleUddO\n", + "BQ6RskoZl0FlVb62HL67plDpRz05V5WZTQcuAMYC33D381O2mQZ8FRgHLHf3aUWWSaT0atQy2lcE\n", + "ddcts8JqHGY2FvgTcDBhHv27gKPc/cHENpsAtwOHuvvjZjbJ3Zen7Es1DpE8OlDLSKtZxNua4bbD\n", + "OlrjMLOJwBR3/1MD+94bWOjui+I+5gBHAA8mtjka+KG7Pw6QFjREJIcO1TKyahZk965Sd90SqDsA\n", + "0MwOB+4Gbom39zCzPB/GycDixO3H431JU4HNzOxXZjbfzI7LV2wRGRRqGbcSmnwnEGoZu7apaSpr\n", + "IOCWGduru24J5Bk5PhvYhzg+yN3vZngXvix52sDGAa8DZhCqtf9q4UsgIvWYjcHsDMLy328k1DKO\n", + "wP24PE1TZjbDzOaa2UD8f0YTpcgaCLgMrRdeWnmaqta6+1/jSNSKl3I8bwkwJXF7CqHWkbSYkBBf\n", + "Daw2s18DuwMLqndmZrMTNwfcfSBHGUTKqYlcRlUuYkPgFcBWiU2aSV5nDQRcQggS6q7bRrGz0bTC\n", + "D+TuNf8RPpzHAPcTmpYuBi7N8bx1CL8wtgPWBe4Bdq7a5tXA/yP0upoYj7FLyr683vH0T/965R+h\n", + "hj0XGIj/z8j9fBjjcIbDKgd3WOZweM5jLiC0BNT699MmXkv1fhc29Jr0r8jPmhex3zw1jtOBTwHP\n", + "AdcTch2fzRGQXjCz0+L2Y4FvuvuDZnZqfPwyd38ori98H6EWc4W7P5CjTCKFK2IcwigXWRpNj6m0\n", + "XESahpLXrrUz+lLd7rhm9jp3/32bypNVBnd1x5U2yrjALwRmjeaiGH8oNdZNtQU9psxsAHhzjk1X\n", + "ELrOa7BeCRR17cyTHP+KmT1kZp81s9e0ugAiXaqoacMbm1W2dT2msnIR1TYjBLYLm0yWSx+oGzg8\n", + "jOQ+EFgOXGZm95vZvxZdMJEOK2ra8Hyzyo6yx1SKtDU6lgHzGZxRfRitrSGZci3k5O7L3P1C4AOE\n", + "D/LZhZZKpPOKmja87iJLRYzL8PSFok52970IOcY0Gqwnqeomx81sF+A9wLuBp4HvAh8puFwinVbI\n", + "tOE1k8kFj/727IWitLaGNCRPcvxOYA7wfXdf0pZSjSyDkuPSdm2dNryDM9lmdAR4mOaXrpUuoWnV\n", + "FTikjLpgJttQDK2tUUZtDxxm9n13P9LM7k952N19t1YXJosCh5RSh9fLkPLrRODYyt2Xmtm2QPWB\n", + "3d3/3OrCZFHgkFLpklqGlF/bx3G4+9L454fcfVHyH/ChVhdEpC90diZbkZbI0x33kJT7NDBIpBGt\n", + "H5ch0jGZ3XHN7IOEmsX2VXmODQmr9olIHsplSMnUynFsDGwKfBH4OEN5jmfd/en2FG+wLMpxSO9R\n", + "LkM6rGPdcc1sP+CP7v5MvL0RYXr037S6MDXKoMAhvaWLahlFzPIrvaGTa45fQlilr+IfwKXAHq0u\n", + "jEjP67JaxqimcRfJkHeuqpcSf79IWF9DRJK6s8dUUbP8Sh/LEzgeNbOZZjbOzNY1s1nAI0UXTKRn\n", + "dHePqaJm+ZU+lidwfADYn7CG8OPAvsApRRZKpGd0Zy0jSRMYSsvVzXG4+5PAe9tQFpHe0eZcxigS\n", + "3IXM8iv9Lc+06jsBXwde4e67mtluwOHufl7hpRPpRm3uMTWaBLfWBJci5OmO+2vgo8Cl7r6HhU/h\n", + "H9x913YUMJZB3XGl8zrUY6qpdcpF6Gx33Inu/pv4qwV3dzNb2+qCiHS1zo7LUIJbukqe5PhTZjZY\n", + "RTazdxPWKhYpv+7oMaUEt3SVPDWO04DLgZ3MbCnwKHBMoaUS6QbdM/q7qQS3RoxLUWpNcjjL3S8E\n", + "tnT3g8xsA2BMZeoRkdJqMJcxmgt0nuc2k+DWiHEpUq1JDu91993N7G537+j0IkqOS9s0WMvIuEAv\n", + "BGbVu0APMdv7AAAP6ElEQVSP5rn1KKEu0IGFnIAHzGwBoYnq/qp/97W6ICLtYmYzzGyumQ3E/2eM\n", + "Ipcxmik9ipwORAl1KUxmU5W7H2VmrwBuAQ5n5PKxIj0n7Vf+LvDqv8DfXw6VLuaN5DJGc4Eu8uKu\n", + "hLoUplaO4xcxt3FLO9cXFynY4K98YzCRse3E8Fgz4zJGc4Gu+dxRJrc1YlwKU6tX1ZZmtj9wuJnN\n", + "IXzPBhMi7v77ogsnUoDxEK6mVwIHxDtvgiffFuaYarTHVNoFeg3wcjObUedCn3lxH21yWyPGpUi1\n", + "kuNHAu8nTHA4v/pxdz+w2KINK4uS49ISY83mng6Hfh6YSBiQdCpw0yiSxvEi/xlCU1eymaluojs+\n", + "d8TFXcltaYVOrgB4truf2+oDN0KBQ1rCbOpf4EeVXMa1wCxgZfiVP3M0v8ZbfaE3swHgzSkP3eru\n", + "0xrdn/SnTk45cp6ZHQe80t3PNbNtCBMe/rbVhREpRGJcxsthwhpY+UF49Gp4ltY14bQ60a3ktnSt\n", + "PFOOfB3YDzg63v57vE+k+6WslzEedrjKfU93n+buh7Wo3b/VF/qLCE1dSUpuS1fIU+PYJ86KezeA\n", + "u68ws3EFl0tkdNo/k21LezEpuS3dLE/geN7MBtcYN7OXAS/V2F6kszowx1QRF/r4XAUK6Tp5kuPH\n", + "Au8B9gSuAd4NfNrdv1d88QbLoOS41Neh9TJEulXHelXFg+8MHBRv/sLdH8y1c7PpwAXAWOAb7n5+\n", + "xnZ7AfOA97j7DSmPK3BIbd0zk61I1+ho4Ghqx6F560/AwcAS4C7gqOqgE7f7ObAKuMrdf5iyLwUO\n", + "SadahkimTkxyOFp7AwvdfZG7rwXmAEekbHc68APgqQLLImWU0mOKMPpbQUOkQEUGjsnA4sTtx+N9\n", + "g8xsMiGYXBLvKqb6I+XSHavyifStuoHDzHZJuW9ajn3nCQIXAGd5aC8zNAOv1KNahkjH5emO+z0z\n", + "uxb4N8IX9XxgL2DfOs9bAkxJ3J5CqHUk7QnMid0YJwGHmdlaT7kImNnsxM0Bdx/IUXYpC+UyROqK\n", + "P+qnFX6cHN1x1ycEi9cDGwDfAb7o7jXHcpjZOoTk+EHAUuC3pCTHE9tfBdykXlUygnpMiTSlk3NV\n", + "vUAYzDSBMB/PI/WCBoC7v2BmpxEWghoLfNPdHzSzU+PjlzVfbOkLqmWIdKU8NY57gRuBcwnNSZcB\n", + "z7n7kcUXb7AMqnH0G9UyREatk9Oq7+Xud1Xdd7y7f6vVhalRBgWOLjfK1eqSO1ItQ6RFem4AYCsp\n", + "cHS3jNXq6i5ilLIj1TJEWqgXBwBK/xhcxzthB8Lgzvo0LkOkp+RJjovU0/wiRqpliPQc1TikFRpf\n", + "xEi1DJGepcAhrdDYanUlHP1tZjPMbK6ZDcT/Z3S6TCJFUVOVjFruRYxK2mMqo3PA9mZGUz3LRLqc\n", + "elVJe5Q4l2Fmc4FDUx6a6+6Htbs8IhXqVSW9qT9yGc13DhDpQWqqkuKUuJZRpfHOASI9TDUOab3+\n", + "qGUkNdY5QKTHqcYhrdU/tYxBuTsHiJSEkuPSGiXtMSXSy5Qcl+7VJeMyNJZCpD3UVCXNa3EtYzQz\n", + "7GoshUj7KHBIc1qcy2jBhb/WRIsKHCItpKYqaUxxPaZGN8OuxlKItI1qHJJfsT2mRnvh11gKkTZR\n", + "jUPqa8+4jNFe+DWWQqRNVOOQ2to3LuMiYHuGN1flvvBrLIVI+2gch6TrwLiMmCDXhV+kRbTmuAJH\n", + "+/Th6G+RMtIAQCle/80xJSJNUI5DAtUyRCQn1Tj6XYG1DE0BIlJOqnH0swJrGZoCRKS8VOPoR+3J\n", + "ZYx2JLiIdCnVOPpN+3IZmgJEpKRU4+gX7e8xpSlAREpKgaMfdGa9jK6bAkTJepHWUFNVmXVwVb5u\n", + "mwJEyXqR1tHI8bLSuIxhzGwucGjKQ3Pd/bB2l0ekHTRyXPLR6O8sStaLtIiaqspEtYxalKwXaRHV\n", + "OMqgR2sZbU5Wd12yXqRXqcbR63q0ltHuZHW3JetFelnhyXEzmw5cAIwFvuHu51c9fgzwMcCAZ4EP\n", + "uvt9VdsoOV6tgz2mWkHJapHiFXXtLLTGYWZjga8BBwNLgLvM7EZ3fzCx2SPAm9z9bzHIXA7sW2S5\n", + "el6P1jKqKFkt0qOKznHsDSx090XuvhaYAxyR3MDd57n73+LN3wBbF1ym3tWjuYwMSlaL9KiiA8dk\n", + "YHHi9uPxvizvB9TmnKYzo7+LpGS1SI8qOjmeO4FiZgcCJwH7Zzw+O3FzwN0HRlWyXtHjuYwsVcnq\n", + "ycCWwCpgpkZzizTHzKYB04o+TtGBYwkwJXF7CqHWMYyZ7QZcAUx395VpO3L32UUUsKuVI5eRKRE8\n", + "LgQmxX+vRVOBiDQl/qAeqNw2s3OKOE7RTVXzgalmtp2ZrQu8Fxj2S9nMtgFuAI519+qmi/5UrlxG\n", + "PVq3Q6THFFrjcPcXzOw04BZCd9xvuvuDZnZqfPwy4GxgU+CS+OtzrbvvXWS5ulrJaxkp1LtKpMdo\n", + "ksNuUdJcRj0azyFSHE1yWGbl6zHVCPWuEukxmnKkk/q0lpGkqUBEeo+aqjql/3IZItJmaqoqi/7q\n", + "MdVyWv5VpPPUVNVOqmWMipZ/FekOqnG0g2oZraIxHyJdQDWOoqmW0Uoa8yHSBVTjKIpqGUXQjLoi\n", + "XUCBowj9PS6jSBrzIdIF1FTVShqXUSiN+RDpDhrH0SrKZYhIl9E4jm6lXIaI9Bk1VY2Gahki0odU\n", + "42iGahki0sdU42iUahki0udU48hLtQwREUA1jnxUyxARGaQaRy2qZYiIjKAaRxbVMkREUqnGUU21\n", + "jExaC0NEQDWO4VTLyKS1MESkQjUOUC0jH62FISKAahyqZeSntTBEBOjnGodqGY3SWhgiAvRr4NB6\n", + "Gc3QWhgiAvRbU5XWy2ia1sIQkYr+WY9DuQwR6TNaj6NZymWIiLRUuZuqVMsQEWm5ctY4VMsQESlM\n", + "+WocqmWIiBSqPDUO1TJERNqiHDUO1TJERNqmt2scqmWIiLRd79Y4VMsQEemIQmscZjbdzB4yswVm\n", + "9vGMbS6Kj99rZnvk2KlqGSIiHVRY4DCzscDXgOnALsBRZrZz1TYzgB3cfSpwCnBJnZ32/RxTZjat\n", + "02XoFjoXQ3QuhuhcFK/IGsfewEJ3X+Tua4E5wBFV2xwOXAPg7r8BNjGzLVL31qO1jAJWzZvWinKV\n", + "xLROF6CLTOt0AbrItE4XoOyKzHFMBhYnbj8O7JNjm62BJ1P299X4f8/kMjqxal485kzC+hlrgIs0\n", + "EaGItFKRgSPv7InVE3BlPa8XZ7KttWpeyy/mWt5VRNqhsNlxzWxfYLa7T4+3PwG85O7nJ7a5FBhw\n", + "9znx9kPAm939yap9df8UviIiXaiI2XGLrHHMB6aa2XbAUuC9wFFV29wInAbMiYHmr9VBA4p54SIi\n", + "0pzCAoe7v2BmpwG3AGOBb7r7g2Z2anz8srg40AwzWwj8AzixqPKIiEhr9MRCTiIi0j26asqRQgYM\n", + "9qh658LMjonn4D4zu93MdutEOdshz+cibreXmb1gZu9sZ/naJef3Y5qZ3W1mfzCzgTYXsW1yfD8m\n", + "xe7v98RzcUIHitkWZnalmT1pZvfX2Ka1101374p/hOashcB2wDjgHmDnqm1mADfHv/cB7ux0uTt4\n", + "LvYDNo5/T+/nc5HY7pfAfwLv6nS5O/SZ2AT4I7B1vD2p0+Xu4LmYDXyhch6Ap4F1Ol32gs7HAcAe\n", + "wP0Zj7f8utlNNY7WDhjsbXXPhbvPc/e/xZu/IYx/KaM8nwsIXZx/ADzVzsK1UZ7zcDTwQ3d/HMDd\n", + "l7e5jO2S51wsAzaKf28EPO3uL7SxjG3j7rcBK2ts0vLrZjcFjrTBgJNzbFPGC2aec5H0fgoYF9Il\n", + "6p4LM5tMuHBUpqwpY+Iuz2diKrCZmf3KzOab2XFtK1175TkXVwC7mtlSwowTs9pUtm7U8utmN82O\n", + "2+oBg70s92syswOBk4D9iytOR+U5FxcAZ7m7m5kx8jNSBnnOwzjgdcBBwERgnpnd6e4LCi1Z++U5\n", + "F58E7nH3aWa2PfBzM9vd3Z8tuGzdqqXXzW4KHEuAKYnbUwiRsdY2W8f7yibPuSAmxK8Aprt7rapq\n", + "L8tzLvYkjAWC0J59mJmt9d6aZaCePOdhMbDc3VcDq83s18DuQNkCR55z8QbgcwDu/rCZPQrsRBhf\n", + "1m9aft3spqaqwQGDZrYuYcBg9Rf/RuB4GByZnjpgsATqngsz2wa4ATjW3Rd2oIztUvdcuPur3P2V\n", + "7v5KQp7jgyULGpDv+/ET4I1mNtbMJhISoQ+0uZztkOdcPAQcDBDb83cCHmlrKbtHy6+bXVPjcA0Y\n", + "HJTnXABnA5sCl8Rf2mvdfe9OlbkoOc9F6eX8fjxkZnOB+4CXgCvcvXSBI+dn4vPAVWZ2L+EH8se8\n", + "ByZGbYaZXQ+8GZhkZouBcwjNloVdNzUAUEREGtJNTVUiItIDFDhERKQhChwiItIQBQ4REWmIAoeI\n", + "iDREgUNERBqiwCHSAnE685vi32+rM/37xmb2wSaOMdvMzhxNOUVaQYFDpAYza/g74u43ufv5NTbZ\n", + "FPhQE8XRoCvpCgocUjpxQad7zWw9M1s/LuSzS9U228WFgK4zswfM7PtmNiE+tsjMvmhmvwOONLND\n", + "zOwOM/udmX3PzNaP2003swfjdu9I7PsEM7s4/r2Fmf0oLih0j5ntB3wR2D4uuHR+3O6jZvbbWO7Z\n", + "iX19ysz+ZGa3EabNEOm4rplyRKRV3P0uM7sROA+YAFybMfXGjsCJ7j7PzL5JqAV8mfDLfrm772lm\n", + "k4AfAge5++rYBPURM/sScDlwYJxE77uk1wguAn7l7u+ItZcNgI8Du7r7HgBmdgiwg7vvHbf5iZkd\n", + "AKwizMO0O2EKid/Tn5P0SZdR4JCyOpdwkV1NWOQpzWJ3nxf/vg6YSQgcAN+N/+8L7ALcEecEWxe4\n", + "g/Dr/1F3fzjx/FNSjnEgcCyAu78EPGNmm1VtcwhwiJndHW+vT1hbY0PgBndfA6yJwbCMU8ZLj1Hg\n", + "kLKaRLgAjyXUOlalbJOsIVjV7X8k/v65ux+dfKKZ7V61r1oX9DwX+y+4++VVx5hV9VwFDekKynFI\n", + "WV0GfBr4DpCVqN4mTjMNYdnV21K2+Q2wf1wMiJgzmUqYtns7M3tV3O6ojGP8AvhgfO5YM9sIeJZQ\n", + "m6i4BTgpkTuZbGYvA34NvN3MxpvZhsBbUYJcuoACh5SOmR0PPOfucwiJ6L3MbFrKpn8CPmxmDwAb\n", + "k7L0rLs/BZwAXB+n6L4D2MndnyM0Tf1XTI4/mXieJ/6eBRxoZvcRms52dvengdvN7H4zO9/df04I\n", + "cPPidt8DNnD3uwlNZvcSlgb+7ShPjUhLaFp16Utmth1wk7u/tsNFEek5qnFIP9OvJpEmqMYhIiIN\n", + "UY1DREQaosAhIiINUeAQEZGGKHCIiEhDFDhERKQhChwiItKQ/w9+ko845ptIQQAAAABJRU5ErkJg\n", + "gg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd8VUX2wL8nvUICBAgdEhAhFAUFVIqoQGJFBMGGDXVd\n", + "xV3d1Z+r7suzbnNXsYsidsFeKCIK2AAJAtKCEDoJIRAgvc/vj7kv7+XxXnjpAeb7+dxP8ubOnZnb\n", + "zsw9c+YcUUphMBgMhlMHv6ZugMFgMBgaFyP4DQaD4RTDCH6DwWA4xTCC32AwGE4xjOA3GAyGUwwj\n", + "+A0Gg+EUwwj+OiAiFSLSowHLHy4iqQ1VfkMjIjtF5IKmbkdTICKhIvKliBwRkTlW2uMikiUi6fVc\n", + "14MiMrM+y6xvRORGEfmhieruZr2rftbv+SJyfSPUmywibzd0PbXhlBH8lhAqEJFca8sRkfZN2J5k\n", + "ESm12pEjIltE5DnXNimlflBK9faxrOb4gClrqzHW/Rpdz+1pTK4C2gKtlFJXi0gX4F6gt1KqQ20L\n", + "FZFRIrLHNU0p9ZRSalrdmnvqoJRKUkod932ph2ew2S6SOmUEP/omXKKUirS2Fkqp/U3cnveVUi2A\n", + "aGA80B5Y3ZQdUjNCAdLUjagDXYHflVIV1u8uwCGl1KEmbNNJgYj4N1JVJ/oz6JVTSfB7RETeFJF7\n", + "rf87Wp+Ed1q/40TkkEvev4pIuojsFZGb61q1taGUKldKbQKuBrKA+6z6qozuROQBq+4cEUkVkdEi\n", + "Mg54ELja+pJZY+W9SUQ2WXnTROQ2l3JGWeXcKyKZ1jnd6LI/VESetkY8R0TkBxEJsfYNFZGfReSw\n", + "iKwVkZHHOc+zRWSjiGSLyCwRCXap5xKrjMMi8pOI9LPS30YLyi+tc/qriMyuwX3yWK61r4OIfCwi\n", + "B0Rku4jc7bIvWUTmWs9EjohsEJFBXm+gSG8R+UZEDln3Y6KVbgcecbkntwGLgA7W71nHu5Yi0kpE\n", + "3hCRfda1+0REwoAFLuXkiEis6xefiCwQkT+6tXOdiFxRXZu9nF9dnqHWIvKFiBwVkZVAXDX1OFQx\n", + "06zzTReR+9zuy0ci8raIHAWmikhLEXldnO/jY+JU5fiJyH9Eq9XSgIvd6lsqIre4/J7mcp4bReQM\n", + "D8/gX3y4Z91FZJlVziKgjbdzbnKUUqfEBuwALvCQfhPwhfX/NcA24APr983Ap9b/44D9QB8gDHgP\n", + "qAB61LI9ycDbHtLtwArr/1HAHuv/04DdQHvrdxdH3YANeMutnCSgu/X/CCAfOMOl3FKrDf5AorW/\n", + "pbX/BeA7IBY9OBgKBAEdgYPAOCvfhdbvNl7OcSfwm3VcNPAj8Ji17wwgEzgL3QHeYN2jQJf7NboW\n", + "98lruda5rAYeBgKA7kAaMMblnhRa91qAJ4HlXs4tHNgDTLXKHYjutE/3dE+AkY57af32di1bW7/n\n", + "Ae8DLa22DvdUjntdwPXAjy77+gCHrfOvts0ezrEuz9AH1hYK9AX2At97qacb+l1618qfABzAel+t\n", + "OkqAy6zfIcCnwEtW/hhgJXCbtf8OYDPO524JUA74WfuXADdb/0+02jbI+h0HdPHyDB7vni0H/mNd\n", + "6+FADm7vZXPZmrwBjXaiWgjlWi/BYeATlxudjX7RXwJuwyls3wT+ZP0/C3jSpbyeNIzgvwOtInC8\n", + "XI62xKMF2gVYwvF4Zbnl+RSY7lJugeNFsNIygbPRAqEA6OehjAfcH2RgIXCDlzp3OF5G63cisM36\n", + "/yXgUbf8qTgFnPtL5+t98lbuCGAIsMtt34PALJfruMhlXx+gwMu5XY2bIANeAf7u6Z643svjXUt0\n", + "h1uOJUTd8lQpx70uIBLIAzpbv58AXvOlzT48s74+Q/5oQd3LZd8TwA9eyu2Gfpdc8//Tpd3JwFKX\n", + "fe2AIiDEJW0K8J31/3duz91FVvmeBP/XwN3VPL+uz2B196wLuiMMddn3Lsd5L5tqO5VUPQq4XCkV\n", + "bW1XAiil0tAjlYHoXvorIF1EeqGFxTLr+Fj0aMnBbm8VibbGcUwir69hOzsCx+iBlVLbgD+hX4JM\n", + "EXlfRGKraUOiiKywPukPo0dvrV2yHFJO/TPolzgC/Xkagh4Ju9MVmGh95h62yj0XPTfhDfdr5pjY\n", + "7Arc51ZWJ5f9VajBffJWbqy1r4PbvgfRk7AOMt2uSYhDheDhWgxxK+satFDyhequZWcgWyl11Mey\n", + "KlFK5aK/FqZYSZPRAqjGba7DMxSD/krx6X1xwduzAnpU7qArelSd4XIeL1v1Qg3eVfSz4elZ90R1\n", + "96wDcFgpVeiSf5eP5TY6AU3dgGbCMvQnX6BSKl1ElgE3oj8T11p5MtC9uoMueEEp9QN65FUdyj3B\n", + "EjCXovXBnsp9H3hfRCLRI7V/okcbVcoSrUf/GLgO+FwpVS4in+LbRNVB9GgqHq2mcWU3egRz2zFH\n", + "ecf9mu1zKesJpdSTXo475vrg233yWq6IDAV2KKV61aBOb+wGlimlxtSyLK/X0urQW4lISw/C31O5\n", + "7mnvAzbR5pMhSqklPrbZtQ11eYaygDL0/d5ipXl9X1xwz7/PZZ/rOe4BitEqFteOx4HP76pVVryX\n", + "fe7Xtbp71hWIFpEwpVSBldwV/eXW7DiVRvzVsQy4C/je+r3U+v2Dsr7ZgLnAjSJyuuhJNlsd66x8\n", + "gUQkQEROR7+wbYH/HpNZpJfoydxg9ENfhPOh2g90ExFHmUHWdhCoEJFE4LgvO4D1Is0C/it64tBf\n", + "RIaJSBDwDnCpiIyx0kOsSb6O1ZzjH0VPxrYCHgLmWPtmAneIyNmiCReRi0UkwtqfybETgr7cp+rK\n", + "/QXIFZH7RU9g+4tIgogMdmmvr3wF9BKR60Qk0NrOEhGH+e3xyvJ6LZVSGehJ3BdFJMoqe4TLdWkt\n", + "Ii1cynKvaz5a6NjRenZf2+xKXZ6hcuATINm6zn3Q8wrH6wwftvL3RXfoczxlsq7PIvQzGil6MjfO\n", + "5RrNBaZbz1008H/V1Pka8BcROdN6XuJFm97Csc9gdfdsF5AC2K3reh5wyXHOt8kwgl/zPfoT1SFQ\n", + "fkJPGjl+o5RaCDyD1h/+DnxL3ex0FZbVB3AE+Bw9UhqkqpqZOuoIBp6y8mSgVTIPWvs+tP4eEpEU\n", + "63N/OvoFyEZ/9n/uoX5v/AVYD6xCq52eQutH9wKXA39DT77tRlsgeXuOFFrNsAj9Ob0VeBxAKbUa\n", + "mAY8b7VxK/rrxcFTaEFwWCxrHny7T17LtTq1S9Dqou3oa/kq4BCiysN18XidlFJ5aEE4GT0yzbDa\n", + "HORLWT5cy+vROuNUtACabh2Xih4gbBdt7RPrXpdSqgQteC9AGyH42mbX86vrM3QX+l7tRw8kZlWT\n", + "18Ey9KT9YuDfSqnFLvW413WD1e5NVvs+xKlynInW3a9DC+OPvbVVKfURev7hPfRk7CfoL0hwewZ9\n", + "uGfXoOeRsoG/o+eemiXiHCjVsgBtmnYxcEAp1c9Lnhnoib0C4Eal1Jo6VWowGE4aRKQbuiMO8KK6\n", + "MdQz9THifwNt/uYREUkC4pVSPdGWGC/VQ50Gg8FgqCV1FvzWRObharJchvXJo5RaCUSJiK+WDwaD\n", + "4dSgbqoHQ41oDB1/R6qaVu1Fm1AZDAYDSqmdSil/o+ZpPBprctfd6sD07gaDwdBENIYd/z70ghQH\n", + "nahqnwuAiJjOwGAwGGqBUqpGzuQaQ/B/gTbt+sBaQHNEKZXpKWNNG38iISLJSqnkpm5HQ3AynxuY\n", + "8zvROQXOr8aD5joLfhF5H+04qo1oT5I29HJqlFKvKKXmi0iSiGxDL7m/qa51GgwGg6H21FnwK6Wm\n", + "+JDnrrrWYzAYDIb6wazcbTyWNnUDGpClTd2ABmZpUzeggVna1A1oYJY2dQOaG3VeuVtfiIg6mXX8\n", + "BoPB0BDURnaaEb/BYDCcYhi3zIZ6RSQhCTpPh8gQyC2CPTOU2jC/qdtlMBicGMFvqDe00B/2LMx0\n", + "8W8+LU4kASP8DYbmg1H1GOqRztNhZjzhmeBXZqXNjIcud1d7mMFgaFTMiL+BODVVHpEhACTdBT3n\n", + "Q1Yf2D8QcnbHi13OA35TNpXTtG00GAxG8DcAp67KI7cIgA8/hKBcaLce2q+F7l8GA08DCWKXTHSY\n", + "xHUuf3cpW+Oal52aHbPBoDHmnA2ASOJCWDCWqJ0QchgK2kBBDJRduVCp+YlN3b6GwnOHd2sarJiu\n", + "1Ib5Yhd/dHzTgcAAl7/h6A7AtTPYqGyqqPHaOW0bLL/HCH/DiUZtZKcR/A2AyKSlMHckg1+GwS9D\n", + "2EEIywJVXkFg+W50yL+D1l9v/x8EjjT2SLiuaKHa5W6ICIW8Qtj93PGEqdglBt0BuHYGPdHhGl07\n", + "g7XKpg64H58gktQZpkdCSC4U7YEZG5TyWKfYRXjuvCW0vn8k7X6DlD9AYStrb9JJ3TEbTk6M4G8m\n", + "VI74q6Ag9KJveODbO4AYa2vj4X/XtFB0zFtfOoks4KCyqdIGPr1GQewSDPTB2RHoTqFMFBktyzkQ\n", + "XUhmyOG2u/d8f9n+vHEz9ZcEANNg23K4Z2MyS4G+1rH9K//mB4WRPjqIzP6w/F7Id8QFmrRMqbmj\n", + "GvE0DYY6YwR/M+F4Kg+fy7FLEJ47BG9prdGO8HzpJBz/550oXxXi1zeJqIQXaHttN9qtg/ZrGbzi\n", + "M7Vqd4VkhsOqjrCuHfzWDr7oREFRFAJsAX7DUiV1m0XM4d1DnzvK8jbH1mBG/IYTDyP4mxG1UXnU\n", + "uU67+AFR+NZJOP73x/dOIgvIVjZV7kt7aqKC8en8HF9S3ZZA2w3w662MLEtkKct4dgjM7wkDMmHA\n", + "fnjGj4qU8ezERVXUeQ7RYzbz0Hgi4u8hiTTmuJRe847ZYGgOGMFvqDFilzCO7Ry8dRJt0B3LEY7T\n", + "SbRbRK9Rm7j3jTy6hVom/Q4VTG2Ff+XcSdv1cP7fofNyBr/WglVHth6TNxG+XpjMn3CZNwgsYHS4\n", + "ENw/Ey5cGMFP+3tTRDhrKT54lNyp9S30jeWQoTEwgt/Q4IhdAoBWHKeTCDvEkOhAIrPCoGc2bHhR\n", + "H58EC+crVSt1yjFzJzEbiYi7i6TUpcw54sx3K6StgOnuHcwkkaUvhDFyXXvofhjiDlvpsGyuUqNq\n", + "0ybvbTWWQ4bGoTay09jxG2qEsqky4IC1eWWSyNK5MFIBhYHO9Ag9YV1L9syAaXGVwjSrL3lZcWlL\n", + "Y1Z/eW673AlBQcSWFrM3I4BH0/Yd+1WRC0UxBXDh9qrpeVBY+zZ5w1rF3CYVDvUC5Ydud9LdgBH8\n", + "hibFCH5Dg5ALRQAChLnYGdVFyCq1Yb5IAlp4OudOMg/kzAf+LHbpANwHPCN2GQ78U9nUNsfxe2DG\n", + "NIhztQC6FdJ2w3O1bZN3IkOIyICbhsPrP0N2Tys9og4dn8FQPxhVzylMfU++upc9DJ51F7KeVDD1\n", + "jdilNTAduBP4BnhK2dR6R7u6wN0REJoHhbvhufpsj+Oa/sLQs7Mndo7mUE/47gmXHMZyyFC/GB2/\n", + "wWc8Cea6Tr56qqMhhezxELu0AO4A/gysAp5UNrWioepzvabJPUN4clwApS8dgDLHIN9YDhnqHyP4\n", + "DR6xJmTbArGOrctK7k/yIz4jEqauhfGpOm9dJl+bK2KXUOAm4H70auAnge/6JpNYn188iSILF8DY\n", + "vCBIuBOmfRHCD9sT+Jmo7FwCf2kMk17DqYeZ3D3FsFa3tsdFoHvYOqAXdmUDGY4twI+ghANw0XYY\n", + "lOEss26Tr80TZVOFwItil5nANcAL/gXQri8t5m0i1s8a+0yDuAQRaiv8IyEEYE8LuGY9PLS9CEhh\n", + "Eqyfe5J1poYTGyP4myFil3A8C3D3tEggExeBbm2/uP0+4O7KIVFk4R+hi3vdDWPh0jywrsGbYpd3\n", + "en9LyuHzOG3ACLAvhSs3w0yIT4JaW904JrRPPwhPfutMz4NCY9NvaE4YwV9LfHmRq+bJKSJ26yxu\n", + "376B6kfosUAgxwrzDCDV7fdBZVMVtWl/41q4NC+UTZVPSpajc1bDojjY18K5ry5fPN6u6QpiV5ya\n", + "broNzRUj+GtBlcU5UqG9b7a87XRJav0aQ7L3ArFkBg/lmrbnE5ITQWQqROyHirKLKPbLILhiG07h\n", + "nQ6spqpAP9rQ/nM2KDU/QYSkJpx8bUpyoUiAsWlV0+vyxePtmh5mgLbpD8yH8mCoCKAxbfrN14bB\n", + "HSP4a4W1OGfE4zDyUShuAbmxXSgtvweYB2SwpWNPMp+KoDgCItN1NKojPfwouHG9Kl/YLPS9lpA/\n", + "JQVAQ33xeLqmIpPuB+CMWXDhg5DZH9IHweH0bmKXBCDVWhhX71RdQazQKyvM18apjrHqqQWVPmOC\n", + "8qA8UI/iAFe3vpV5Wm+BxOl6xB+ZAaEHFX7KVS+/n6qjfcfv/dakpKGBaCxz0yquJoJzoP0a6JAC\n", + "cf/IIP5gHnr+Zh36yy/F+pvqqzM8n+ru/BNc9AC8tRjKQjDrCU4ejFVPo2GFGCyJcEvPKzwmz6HT\n", + "4J2vncn+4xbxyNe3UFWn3x5IAC7CaaXTXuxSyPE7iAzqGLClIRdyNWca74vHxdVEcQvYNRJ2vZ3G\n", + "8nbTlcqaL3ZpCZwJDAKSgEfQ938dzo5gNbCl5p1BRAjn/AfO+Td8PssS+uBYQVxVDbQ/AkIEonJr\n", + "qxIyaqUTAzPirwW++Nuvq09+sYsA0VTtHNw7C8f/wbh8KeC9gzjgrlJojIVcpwrVCb2auukWu0Th\n", + "7AwGW3/boV1MOzqDFOB3bxP8YpdW7IpOxe+0GD6aA0ddjbiSFsLu55zP6PfA1+Bv01+xWiVUI6dy\n", + "xjFd02AWcDUivrzIjeWT33Kt7NoRePvf1Z5/P5DRaTUj7s+kR/s8vYgrwBIhJ+NCroakMYSe2CUa\n", + "3Rk4OoJBaG+oa3B+FaQAW608c8gIWcNrU/pRPuuYAYjupBaMJTgHiv8FPA7n/gu6fwtfvA45naiJ\n", + "SqhSrdRzPpQFw44LrD1GrdSQGFVPI2K9zNW+0L7kqZe22FQBsN3avGKt4I3BpVMILWFUahtY1g0m\n", + "bHbmPRkXcjUs1oR/yBEoDYPyIOrbckfZ1GHgW2sDrFG9szO4Angc3dn7AwuILfqQfl8vYF3ilajI\n", + "KgOQyknnKZfCZ110lIXlfwb/Yrj9TPj6v/BbeA2eg0itRyqJgEkT4MMPYecojGO65ocR/KcQlprH\n", + "ofYBIFFk4gvQzT3vybyQq2GwhN6At2BUMvx+CWyaANtDwhuyVmVT2cBiYLE1V/AaOlD9/9CTxhO4\n", + "In0wV6RHA78CG4EWYpeeMK4YgDmfQNR1WvBXBML3j8DWi2H8DQT0SR/WvatM3rFLfXD81ljzWrtG\n", + "aKE/cSLM/Rh25ZlnqZlhVD2nOE3pRfNkoorlTuQ+OP1TOP1j6PhDGUHlnwAfA/OVTeXVV52uk/K7\n", + "uhKYci3dKoL4HLhX2VRRlfbZpQ1O9ZBWFaVGtGbepX7kvhcKSyFkLhS9WHlMD/8JnHH+l8w7o7Q8\n", + "ZAtPHv5c/b36a+Cm7ur+LUy8uJxVLR5Q3x14ur7O21AVo+M31Iqm9qJ5MuB1Mr/Ltw9z884IYAJw\n", + "DrAE3Ql8ZaluaoWjw34V4l87E/52AfT5hv2H1nKLr/dO7BLDl7F3sCv+evyDo6nIbkFgQBABoUSV\n", + "5ZNckMo9R/L4qTNcMJGC4hZ8DExXNnXEa5nu81rjVv7I0Ox7gMuVTS2v/jhjDVQbjOA3GJqQ403m\n", + "W5Y6l6I7gdHAz+hO4DNlU1k1qcvhCfTT3mA7Hz6cC6cdqvuk/CUt5acpXTnn4dHQNh++eg9iCuCK\n", + "YH78/EF+s9p/i7Kpb3wtU+wyDngLuFTZ1Mpj9htroDphBL/BcIIgdolA2+xPAMaiLXM+Bj5VNrUP\n", + "ql9f4QhtWSFQ7A+OgPZ1jR/s6FDK/ODh0fBeP/jgI3h8j+5QxC5j0PMIXwF/VTaV7+P5XgzMAi5W\n", + "NpVSZV+lmkzBWS/B6ml6rsFYA/lEbWSnX0M1xmAweEfZVJ6yqbnKpq5GW1j9DzgL+E3s8nPEVJnZ\n", + "pxUvLICxc2HkAhg7DJ5NEEkCpydQP+UU+lD3SXnLlcW2gAr4x2J4cR6Mnkz599ezR+wiyqYWAf2B\n", + "cGCd2OVcH893HjANmCd2ObPqXmtivN16vdCswmFzYqyBGgoz4jcYmhFilyDg/HabeK2iK506H4Uf\n", + "3nDGLXaochpyUt59zmd9X+buncidwG7gZmVTR622XgG8BLwN/N19QtnL+Y23jhmnbGotuIz4Rzyu\n", + "HR4ufMbKbUb8vmBUPQbDScIkkaXvCyNXd4Cz97mku6hyGnNS3gr681+0Wuoqh9Du3lUm55zPM8Ut\n", + "iezzBesKdvL48dogdpkAvACMUTb1W6WOf9raeBb/E3aMxoSp9B0j+BsRY4VgaEgcunb39KZeUS12\n", + "mYz2YPpgHzvp5yiefVmI/yAB/jwOYn8lu+QnbtxcqL485ljXd6ZFVhSJqztzeu5IZVMbpFfX67lq\n", + "3+v86/LllBcWmDCVvmMEfyPR3K0QTlWnaycTzXl9hdilN/BRzBaid3xEh/NvhB1R0KYAssLgiD+l\n", + "5SG8CWzAsWDwk469SL3wQUpmx1UWFDQ1k/GfBnJ67nBgBDBc2dS1TXFOJzJG8DcSlTrJM2aB8tMe\n", + "D8uCISh5NVf+9gBQ7LIVuf0uBorrw+WuJ4zTtZOH2qhyGqvTF7uEx24hLfBoRLtO3/RGlYdDQD5j\n", + "WqXy6qi8zIzeRKJXCmcCseQGn0GIhFIRAE+nQ0mkLqjlqN/487I2wDbgBWVTc+u7rSc7RvA3EpW+\n", + "9pP+CEF5EFAEAcUQ9mM2XQ6tQ3vLdGwhbr8dWwXVdAy13Xfa19yVnEu/kDLofVBv0PQqAkPD09id\n", + "fj+JSskMGjsoq2ROZVocVxPG1ynrk49OBmajn/ObSJ44C+aMJOQoFLVEe/+ElgxZnxDzi9+KafQ9\n", + "73l+PpjDE2aAUjOMk7ZGw/JJMv8Ft/SkX3yxQrBcLgfgvVM4Xqfhui8caOVIz+lG20/KtG33+FSn\n", + "4DdO105+OsP0mRBvGwVvDoTAcgisIH6nPx+IXbYCpUCZ9bfUw+/q9h2T1++8Hm0rCi6Eitk6Ct3m\n", + "K0ljDgGMFmX7Lk3sMgr4E7CS4Wsz+eF7KPoG/eiXEUEkSayLm9CGsFd3w9c5nHOzHy8miNxphH/D\n", + "YgR/rXAJrFHJrWnav/nxsYKmOF6g3PpsWaLIwrkeJgWN07WTn0g9GOBPK+DGtVDqD2V+cFcIW5bc\n", + "wh+AQPQ7H+jhf1/2BQMRjt8V7Uv9KVkJfmV6FL/5SgDKAqJKQQe1B54Wuyxk8I5v6Hqd4vMVQm5H\n", + "AHrTUb1HcdgNveGyLfocZlXQdUwQD3CKhgRtLIzgrwXapW0C2uVuw/rarykNFUvW0PxxLOqKLtKb\n", + "gxA4qGwqxYsl2me1rU8ksRe81uGYHZ33nil2udhatIWyqY0SMHY9w4fFcscZkHI7LHmUcHqKIp1l\n", + "XeGJb52Hl7VliHTpcSN7TptsrOYaBiP4a0lj+dqvKRuUmp8gQpJxunbKUV2n78USrY5B1718+UZk\n", + "vAy8JHZ5B72wq4zylsEsTYYDfWHCNRD/NUfeDeeHArjmGXgdrUcaA/x+oN1RyvvOgkHiTH3bBIiv\n", + "R8zkrsFwEuHNEqjSEi0oD/q9p/3hINR1daw3x3RilxjgXSAImELyuDcq3Va3Wws3j8CvrITzvyhW\n", + "i7dQ+d6PJaJsERMUzA501vIQWnv5DytcpFk/40qTWPWIyDjgGXTEn9eUUv902z8K+BxndKiPlVKP\n", + "eyjHCH6DoYGotEQLy4Lrx8Luc2Hhs6AmL1Nq7qgGqdMu/sDDwG382HpG5OKB00/Dv0M4xeT7V5Df\n", + "5wdVfD4yYhc8Px/CS2Esg1nEKggohOgdkNXHKu0RYON6aB3aXNfPNBWNbtUjIv7A88CFwD5glYh8\n", + "oZTa7JZ1mVLqsrrUZTAY6oJliVYQA7OXwDWXwBVT4Yuc4/rXqS3W5K5d7PKzDD00p0fptwErv9eO\n", + "5SiHq9dT9voWAmcMgSBrVUsxVsCyjqvgqsnw2gorSLw/UBgLM9sQUAgt9kF2PJ7CW5pV9cenrt45\n", + "zwa2KaV2KqVKgQ+Ayz3kMyN5g6FJ2TNDj46B4pbwztcQ+W0B07+NErs0qKmvsqlvznuRdeFxRF46\n", + "BbKt2npCYEQJ/O0HCKzQacFYXp53jYCf74PJl0NgPvivVoQW6pgFcd/osI44tBVOL57OuYwFY2Hu\n", + "SP132LM63eCgroK/I7DH5fdeK80VBZwjIutEZL6I9MFgMDQqesS7/B5IWgiTllF61UI+bDGFlmU7\n", + "gAVilxYNWX/7bGTpbBiUAQWW9n4McIubmXEpWzKEG3VM6OX3QuYAGN+nnF5rlnD7yi5h4e8weMsL\n", + "jPxiK4PDziSCeei5BQdW0PuWuyEy3UqbGa/nIQwO6mrV48sEwa9AZ6VUgYgkAp8BvTxlFJFkl59L\n", + "lVJL69g+g8Fg4ckSTewyD62u/Vbskqhs6mBD1J0LRYEV8OgSZ9oI4GHYmAQHwyEsPZb4DcNyD6vv\n", + "frYTffbb7O24jnn5R/jzvi70KV8asjHQL2Dq1JHzZ1dITAbAWqZwdekyglY4S7V8+w9/Ao50hx//\n", + "z0o/eXz7W/Omo+pURl0md0VkKJCslBpn/X4QqHCf4HU7ZgcwSCmV7ZZuJncNhibAWkn+BDAeuEjZ\n", + "1N76rsMXp3NiFz90QJpxQICyqTgrPRb4pe8XZF0RxRlfnAbfvamdwgFcAtnlsGoPzNjIuOkEfDqW\n", + "ezvCy2shp7NV28nr27/RrXpEJADYAlwApAO/AFNcJ3dFpB1wQCmlRORsYK5Sqlt9NN5gMNQfYpe/\n", + "Anei/eRvre/yfXE6Z3VCi4EzgTOUTe200gcHFvLzqtkE/tAVpqyH1paCxwacTQS30qcgk/ADqo+K\n", + "5SwJ5s3vrFJPbt/+TWXOmYjTnPN1pdRTInI7gFLqFRH5I/AH9EqMAuBepdQKD+UYwW8wNDFil1sB\n", + "O5CkbGpdfZfvi/dQsctKYCX6C2ScsqmNAH2GyLrCYfT/ZaYOAO9gXFAE20qSSMNyFjd5OGzJK2FN\n", + "9y1QtK+FtpftAAAgAElEQVS5rKpvKIx3ToPBUGfELhPRev8rlU39VF/lHs97aIJIUpuW/OWnOxkx\n", + "6j8sWTeMLVmjuRp4ANjXch2jQlswPTSKsKs2Qm4wfBsGe8JaUBR4OgQfhTeWwfRe8L/dUDz5GPWO\n", + "09SzvAP4x0JoBhSmezL5PFHMQo3gNxgM9YLYZSzwTquVzDh7AefWh39/R1Sx5Z3gq15wJAQOh8KC\n", + "KLIqjnAw6RvixvYg6Kte8NFcmBxF+fyxHMk9nZbAOmB7YBaRfsGMCM0ieOjn+Lctg91lIRyt6EwL\n", + "WpIflkdqQlvyfl4GTKqyOM1p6nl9PHyNntZwUHUhWHMPtuRKrWSnUqpZbLopTd8Os5nNbHqLGcV9\n", + "wfdTNqcvSqG3W2FrX0iqTXkTYakC9WNn1OPDUc+fhXqnH+rsfvw2OpQVCtSESag3BjrrS4QFJDOc\n", + "ZA6QzFVKKeJimNDiLkpfHOzM9zdQy6z/JwW0VxF8pSBxgWv9MG4hoQcVra90HKaQcuf/Lvlh3EJQ\n", + "ip7zFIH5HvM0l602stM4aTMYDB4ZtJSL/rEZ/6Rr4WgwTPsVZkJ8ElRZKesrDu+h5+7Rm4N3YZ8j\n", + "XsTtKXBmhnNfBIQqm/pB7DIGmC92iR6XxYSv3yXgnFt0vInzd+qx+2Vt4bmRUBSwH7/AK8tpW95J\n", + "7LICR/yK/wuIJ6gtFAeCfwT4F0NBG3jaUaGryWdkCCGH9erhp9NxadFJYRZqBL/BYPBIJIQMyISl\n", + "s+GT053ptQ3qU5330LYEPAZlXLS96jGOOBLKptaKXUYCiySKirjD8N7H8LcL4OfXtWuADnkwehOE\n", + "lEFWeUmZvz/lReWQeg4pBT0YQ3ZoDl9/3oqsL6DsUSgPhvJA19pcFoLlFtFrHuw4H0oivOQ5cTGC\n", + "32AweMQxQu+ZDQ+4TPHWNqiPN5fhG+nLbtq3v5qdzCGtMv9UJGM3qjKOhLKprWKX8w61YBtH4IId\n", + "MOINpz+YmAKYtFH//x9aBOcHnjFge0w+6mDqma0y8+zZX3dZA+9ZOv5/UFXH7x5Iac8MEv52Hpse\n", + "Dfee58TFTO4aDAaP+LLoqj5wuIyOGJxI7607CT/alnxC2Up6yhH121nu+YeFyNqeQQx4yyV23d/Q\n", + "q75GANcSzhd+b5FXoSOCxXE1wXyzdRNDtjuteUrzIDBCW/Uca/IpdgmlnIP87/zl5LUJaE7Bltwx\n", + "MXcNBkO90XhBfbSbhby0F0i55nLY1xPmvQDl1+d7yt25mCPXlMG4DhC1H1pXQDF61ddTtOBH/9fJ\n", + "m2aHrzrA3qGkMYdozo2DBT2dpUw7AsunViPIx+DPSpX73YX1e67NAyP4DQaDVywh38CjXMtl9OEe\n", + "8PpyGH8DTB0NnwSWe8wNRePKYXQmLK+ARTiVNiMZSN7ln2nnbnuHVB5TSjs/znsKjnaF9dfgyZ2z\n", + "G+OBT+vrDJsbdfXOaTAYGgiRhCSRxIUik5bqvyera2Gny+iIkmUMnpPPqI/Xlp3Vctl5XfrIPcfk\n", + "1pPE24LKYSQ6NtcVUHAlrP9lyK4i2q6Hr17G1Rt8ATGwbwiMStbB4QFvFjpilwDgErRDyZMSM+I3\n", + "GJohDRMjt3mi1Ib5Igm0pL89iW1936MwlKMEcBQmR/F0+3Ol4/6f1P2O/O4qqP0QHgJ+RT2Q0lG7\n", + "A/xeu/RIRWlYlM79PfB0RQXd/djxLWxqDf3ehXVTqcZCZwSwQ9nUHi/7T3jM5K7B0AypjJF7/RhQ\n", + "fpA+WG8H/reE6d9foGzN5MWtRxwre98aAAfDIKxUb49GU5I2ii+BF4E8tM+vAqAg7gXOHXmIfzwV\n", + "Svzg2+CFefDs75HpyxicUUZAEHSKg1lhlZUE3AuJX8G889Ko+MWj4zaxy3NAhrKpJxvp1OuEcdlg\n", + "MJwkVMbIjUyHDil6i10Nnb8pJbQ0G0hx2VYrm8qotsATgEkiS+fCyJcGw9bWOmBLQSB8HcGhA3GA\n", + "1t3sRC/ICgPC/EpoQwD+SnT4xlaFurNIh9zCsogK8s9qSWkYZMfpGMMAHc8p5dwNz6s5Ofe6t8Hy\n", + "Drob7aHUPYRss8RY9RgMJw3WhGduB9hymd4ASPyW5IW3AYOt7W5gsNiliKqdQYqyqazGb3ftcawb\n", + "+ENK1fQkWLUgmUuBp9FWm5crm0oF3VnMgZEL4mHIXr0otyAQbgtjy5KgM/xRD59BYEHVhVrZMRvp\n", + "k3uF2OUBZVOlbs0YDOSfKEK/thjBbzA0S/bMgGlxVXX8t6bBnucs3fMeLKsTa5TaDWdn8BdgkNjl\n", + "KMd+GVQJgNScqG5lr7KpMuAescvNwPdil5uUTc3LhSIBkrZZB1ih40OyOQjhAqOPraiwdD9wEJgK\n", + "vOa296S25nFgVD0GQzNFT/B2uVtbn9RsAZEVzaoHzs5gMDq4SRZVO4NflU0d9VSGL77z6xsfg7UM\n", + "Az4CnutjJzhecf8ZEFaGjuP7lrXIbCN9OXaCXAdlIXnjESnh0wv/xdqoMoId57cxmaeBqcqmfmnI\n", + "86xPjI7fYDB4xeoMelG1MxiIjp7n2hms6ZvM8Op85zd+66sidunkX8h3nXYSu+kTIsIshc3NUPAL\n", + "/GuDUnbw3nkmiCQdupEPk9cTdvtqfeyNfhR9cQX+Z3/Kd3tVw3dy9YUR/AaDoUZYNuu9qdoZ9As5\n", + "gpq4i/DB6XD1BmhnraFNgoXzlWoWsWsvCpZF7S/moo1t4bMPoIv13eJLGxNFFto6MXbSRNg6A4Kt\n", + "pWIT2sDHB5tXJ3c8zOSuwWCoEZbufIO1zQYQuwQO+5ifR7ZhcEoHHenKIfhr65mzIYguIeitT+G/\n", + "w2BOX/jrzzrdlzZGQsjQvTBuG6S1gj7WNHgny/9PXdxPnwgYwW8wGKqgbKo0MVkO3bIHbllTdV9t\n", + "PXM2BI6J3fuWV033pY0OC6JXv6yaHlHs8n8z6uTqG+OywWAwHIPDLYJrmsPCpqna5E5d2ujp2L+h\n", + "3T84aE6dXH1jdPwGg8EjvljYNDXubVxL9IoMhgzzJUC649gQ6FgBcfdC2AhrX0O4n24ozOSuwWBo\n", + "UJrCxNNX6hIg/UTo5LxhBL/BYGgwPAVmqa31ixbSnaf7MjL3vUzLv1FAIZzxBqy609qTtFCp+c3C\n", + "EqkhMFY9BoOhwegM02dCfO+7YNWrEFnim/WL+1fCSmKXw8XXwatWByLUj+dRHdCF8iC46K+w7gYr\n", + "Xm7NA6Q3TMdU/2XWFiP4DQaDT0RCyDwi2NqygCR1DmEUMZ1UIsjzKlhdvxIUkNoGhvQIOp+uR4Po\n", + "1g7e/A4OJOBDYBQfsPwbKX842BtiNsG+s6lpgPSGcInd3NxsG6seg8HgE6m0jLiHJCokgB8rFrOI\n", + "VdxDEqm0DPd2jOMrYdqlEPsXSLoWwmKLgvj9Eng1xRL6Dmo+Mq+KM6ALBxKg7QZqFyC983SYGU9A\n", + "kUvazHi9Ari2WGVGZFjtqo8ya48Z8RsMBp/YzJlSxhzw89ejaiCNOQQw2qt+ORJCACZugod+gG5H\n", + "YCydWcQNHnLXbGTujiOgCyTdTe6OXnRb7MeaaI8+96vHUhlNmAK/XQ+br7TSa9cxiV2iOadfd+Iv\n", + "gNhf4ccHXTq8unZ2tcMIfoPB4BNltNHrWh8tc0/P83aMY6HUmDRn2nRSWcY1BcW85wyQUquR+bFY\n", + "Qn6+2CUR+LP6ZF8t1Ci5RaCgy09OH/5ATTomsUs4cBkwBRhJ/L5CVtlgaxKUucr6unV2tcUIfoPB\n", + "4COWDh33Ab534eXJ1fKn5KWFsfTtYpKG1sbzqI9sABKOm8sje2YQM7E3ZcFdOdrFStMdU3XmrGKX\n", + "IHS8gClAIrAceB+4jrdiz9O9yAQ3T6F17+xqgxH8BoPBR7zFCPAuvNzj4zps5LNVekNPaO4FwsUu\n", + "rZVNHarJgX3ZSHb3NHVoX1hJMBflF1K+vYwDf+/LRtzNWW8R4tqMkf6HziUe7ct/I1rYT68SCMeG\n", + "Uw3VcJ2dzxjBbzAYfKKKDr0GwssaETeqgOubTOKuP1Ax4FsWJyZLpq8LzRxWSNKuqFu/nUXczeKg\n", + "adByOc6JagX80hHe7wcL+hJfVMyDwGPAwOMHaHfY2zftmiUj+A0Gg884dOhN3Y7qcAjvc/cQNaAl\n", + "A+8EpkFcggjHE/4O4d63M9xuhYB0rFWIsCaq84LgjkvgilRYOhsePsSauUr9p7pyjTmnwWAwNCAO\n", + "4Z1wADa01WkzIb6LXmhWLZEQUi7QNwsGZDrTIyDUMVEdWQJrXgHbMuh1yFdnbpY5Z+ghGPEYSAVN\n", + "ac5pBL/BYDipcJiQ3rgW/r3Ime6Lm+VcKPJXMPdDCKhwpudBYd08lkaG0G0p3DEQQo6ClDtaZcw5\n", + "DQaDoa64jsxd8WVkXl3Ad28T1cdTH4ldArmkc2dO+xE+ewPSqjh/bhJzTuOkzWAwnFS4uon4HlgE\n", + "bIOibNiUDo8cT1DXp6dOsUs34D1yAoKYObEVue91d+7Vgd/r7gPIeOc0GAwGEkSSWoG9J/R93UXF\n", + "05ixdMUuk4EZwD+AZ0juO85T4Pc612MEv8FgONmorVfLESIpw2HQ5rbQMwsuVjCChg8YL3aJQAv8\n", + "84ApyqZWN1RdYNwyGwyGk4zamkEmiCQNgT5PABzQaQ9Z+1wneesjsIxrGTu7EeQ3hS4VwXwDnKls\n", + "yqs7i6bECH6DwdCMscwgT/8EygPh90vxxYVzZ5j+OoTmBMPEidpJ3F83wdNFzkleL4FlqrX3d//6\n", + "iGbd8glw3StC/DNDYcl5cO5CMrPX8OEG1TyFPhjBbzAYmjWWp8ycTjD5cvjucVhzC8czg3SYdIaU\n", + "wR0p8G5/uG8MRO6gIr+IX8UuIeMse//3EyC8VDuSm1nmPbCMp6+PAq4ZfgVfhj0+Io/5PWHla9Dj\n", + "MO2OF5ymqTGC32AwNGMsx3D7zobZy+C6cRCZAd/nVmsG6TDpDCqH8al6OxICQwayZ984hgH71k+i\n", + "ZMkvUCbw32Ew9QpI2gpZ2+ksdglVNlVZhzXSfxM6tiFoOgSMgIKrKOa9sOc4iw9WpvDgDxBo2f77\n", + "smagKTELuAwGQzPGJbjKoV7w+s+Q8HQJdy4pF7v4ez0KZlwfymHXtL8UkRa4gjuVTY0GBgRlc/Te\n", + "sfDgRXD2PvhoLpy7G34/m1ggQ+zyvthlgkT1Gq9H+gvaQDKUzIDSH4DvASginKgip9AHX1fzNh3G\n", + "qsdgMDRr9GjbxQwy5vfX+GPancAR4FplU0Wejms5UXYOnkdG60KKPdnjO3T8f4oh/t3+8F4/OFxG\n", + "SVke7xd0YwZwFnAVJf6jWHZRAGs7Qn4soIAxwDfAY7RnSEEGv1TGFrgV0lbA9MYwGQVjzmkwGE4R\n", + "xC7BwGygI3C5sqnDbvtPA5YAnZRNVY7F3SdnY1m5fCCHh0ZAaK5QmDKKbw+OJA6YCGwC3uXZYX8m\n", + "/8zTKHnepYaHgINAeVo0898eSsbQ+ljwVRuM4DcYDKcMYhc/4GngQiBR2dTeSsF+0Y5etDzqz0et\n", + "/+Aw+3ROzr4a7wwmM20bLL/H3TTUJajKtRT7T2THxcL6a2HLZVAWYuVKLIE945vKp76D2shOo+M3\n", + "GAwnJNZI/l7gLeAnGdzhdksXP5ZuLbqz+p0uMOxZLfABOk8n6qF4bhoB4ZZxv5uHzASRpESRhROT\n", + "WTQumTv7JvMm/xu3ic1XwpmvQWi2SwtCtzS10K8tdbbqEZFxwDOAP/CaUuqfHvLMQIciKwBuVEqt\n", + "qWu9BoPBoGxKAf8Wu+znwqzXOHBjEDm7IXo77BoBXOC0+e9eEMOV58CP/wf5bV1K0aah3uz6txQV\n", + "5JStmwrrprrVXrSvwU+wgajTiF9E/IHn0Z9EfYApInK6W54kIF4p1RO4DXipLnUaDAaDO8qm3uar\n", + "walMHg9dbTBrOFQ8ATwMlHUUu0zg6p/78eUrsHK629HaQ6bDj/97/WBxD71nJsSfzq8V2qGaK00X\n", + "L7c+qOuI/2xgm1JqJ4CIfABcDmx2yXMZ8CaAUmqliESJSDulVKZ7YQaDwVBrNkZlkPFkf8q/g6Of\n", + "OtPlxt5sinyZvWH38fsX0+FSjzGDHYu+MiJgeSe4cLs22OzC0bjcHnNz9xT9Vkp6+9RyyvbB7uf6\n", + "spFEkYV1cffQVNRV8HcEXGNM7gWG+JCnE2AEv8FgqEf2zPDP/mhUOQuD6fMhtEmF7x8BNTuQT9M3\n", + "qJJFz4kkpHmLGexY9DV0L3yQoIX+18BXED3unNzoJ9atYkk6ocutwCs1dffQnKir4PfVJMh9xtnj\n", + "cSKS7PJzqVJqaS3aZDAYTiEcljz+9OjgB0HlfmUw+mGY7zS/bFFaPniSyNJxULSHjR5H5o4gLDMy\n", + "iN8UAwuAp4BDoZDSAT6ZA9dY8XcVyEyIPxAObfP18Y7YvDSwqwYRGQWMqksZdRX8+4DOLr87o0f0\n", + "1eXpZKUdg1IquY7tMRgMpxCu/nPKgfLAP0HCm5DbAbZfWJnvbHIi5sJI8D4yd0TYmlDG3QFHOHdj\n", + "MFBMZOtCSHsWwkp1Poc7hhJ/OOcWuHslTF+pR7eN4arBGhAvdfwWEVtNy6ir4E8BeopINyAduBqY\n", + "4pbnC+Au4AMRGQocMfp9g8FQP2jvnRFd76N32evklyo2jyqDDxfjUDREhE9i37BUsn+CVoXVj8yt\n", + "zmC+JLX+PLO87ALIAaBlsTNPHhQqkKByWPwWXHIN/N4anl0IeRXeXTX46gK6tvEHakKdBL9SqkxE\n", + "7kKrwvyB15VSm0Xkdmv/K0qp+SKSJCLbgHzgpjq32mAwGACIDIlgHkmZs5lTdJRnh8B7+/3Zu/dP\n", + "xBBKHvn8Lz+VpX55PD0MnvhOHxUCHb1NzIokJBF0yZAdZd3Db+BfvOUiy12Dq0+DuJlHiP/pdbh6\n", + "InS+noLwBbzuqZUOU9EriIifQW+KCecQhcNbSYd/Zat0uyNfbeMP1BSzctdgMJywiCQuHEzF2FUs\n", + "Ii8I4qfDorehfyY8AvwOzLHylgv4W+LuCij4DCr967iGZBRJXBjBXWOTuJs/soNv0KPaX5Hy7ajH\n", + "Nihlh6qxeXP8KFp6O6XF7egOXKJs2tLRQaLIwruIGHtLYBKZpXOcO/ymKvotTmF8+hYggr0th1PR\n", + "tzVBefD+l3C0i5UxaaFS8z1GDTMRuAwGwynGnhmRZI0AQgsCwbZUC32ATVC2F3bcDBGzINYh9G+C\n", + "gnsh7OXB8O9zoE8W9Mkivjyfp8QuB5AJYb0DnuSG0izuDR1MVlA4rUrzubci1f/FIv+7omTIhNPZ\n", + "EtsD/4xSytM3wb82lKv5YhdhW/hLdChJle6D97IzpiWEZBBxJKt3l/AuD7ZoS2Z0f4i+BZYmQ05n\n", + "qHhT+O2yAeQE7OFgj26UtQhBdYKQwZDXzuU8q48/UFOM4DcYDCcsSm2YP1oCNwNnts2HP6Q49xXC\n", + "4pVKJSaIJI2BRyOhRzGofAgCuPVXGL0DNsbAphg40p32wGsM+a1f4dYD3HMoibTCOVAIu4GpUVcT\n", + "NuDrNhdv2NhmTn4+QBug3y1CXJc+0pZOrduT03M8xcHBXPdjHLldIDS7DSi2HA6siMzOhcM5sG8I\n", + "lIa5nESPIHa0GQeznIlFDwEr0VGCwbHIrL4wqh6DwdBsqE0MXE+uFlxdIzv2vyLE+1ni7iFgLE6x\n", + "CpAoLFxoYzW5QX9t8d+zgnLUjyAV0Psz2DweEKL9ziK7IoWUDvDI+ZDWCna3hIpiKkpzI4s4mBhG\n", + "7gbIvw6GPgOrp8GSx9ATzeOAhceeQOhl0P9CaLMZUsdD2hhrxyPAY+hFZiume9PxG1WPwWA4YalN\n", + "DFxwmmEmWfp2d9fIDlcMt1wKP3SFQekwKANezYD+GRBVBNeHsGPxnbQChjPzopQ81fYc/Ivhihuh\n", + "xT7YmghloVRUtAGgQy78cRX0OAzdD8OECHYuuKhFe+K+gVeS4MiD2rdPj8UgClruhNAAyL4Rimc7\n", + "Gx81BQZthJBOkNUHDnd3ObPUo5C03HWRWX1hBL/BYGgWdIbpr0L8j13gvN06zddFUQ4zTE/7HK4Y\n", + "XvkKUtvA6lj4NRYW9EbFtEP8i6goDqcjAWQAT1BecH9FcCuYnAiF0fD2okpXzA79SIdcvTk4GE1n\n", + "StRe3vuyO7H/g35PQMwmiNkMF/8BCltBbiGkt4SNwyBzEJSEw5E/wLeFBfBiGMeQv9zbhG5dMYLf\n", + "YDA0D1rT8tKxsCMKfn7daTtf10VRDlcMARWQcEBvU9dBPoiEwY5W+JUW47ejFZ075vKVdFoSuPqi\n", + "ZZTsioevvgHliPB4c3kJF/hfze/MYXtl+VdH+KnUgRVH6Jfeie7jSsnsH0jWPki7A1beAwd7g7LB\n", + "NYshqgtk3A0lz2dD2Hr4RyHsXgHTrqtqwtmwTuCMjt9gOAmojW68uWDFzr0roIh/234m8P6fdJB0\n", + "B0mwcL5S1Y58q1v05EmFdDMQLvCcJf6+B/4HtAuAjR1gQAT8tj1c/RSWUFEREi6E5AhnpZbSMz8g\n", + "Ypvy673cj/CCKPLLo0mNHE9e6dbd5G2+h5zAEu3fv6wj+MdCcAjh3SO4dgHsPw++ehkqAnA3zzwm\n", + "vGQN1DtGx28wnILUVjfeHBC7DABmAoVtv+aPu9Zwf5DbJK1jwZTXMo6z6Ml9DqAA+nWBVs8p+MZP\n", + "uw6OrIBPAcqA3XBtS9h4Wb6Et1qpctszB8gChgF980rbl6aMOj2K2F8h7Uz48N8AXSDpdkuYV15z\n", + "GdjpVs5f/CJr/xLIUht6kvfY0bwl5BsvXKMZ8RsMJy5il+gBH7JoUisGp3SA//sRzrY8YfkyUm4q\n", + "xC6hgA09+P4bMEvZVIXroihf49eKJC6EBWNpuwFQcKCftcfzoqf+EpWST89BbfwL6BG6mbg8xeP6\n", + "SLJDobVlOPkwkAqFHyfzGTq847PA8yRP/BzmjkQqIPgoFEVbJU9aptTcUS7nOAT4jNTIuXxwXq/a\n", + "jOZ9wYz4DYaTGLFLOHAmcJa1DQba7zqX8kM7YdJGiHOJDNgYDsNqg9jlQuBltK+v/sqm9jv2VTdJ\n", + "651IPfPa+1PwL3ER/McuehJJSBKu6KBCnqFV6268v09xRziQD991hz+Pg9WvQGCFFo5HQggN20lR\n", + "QTfilE3lAkhyYhEAys9F6IOrrb3Y5VJgFnCjej9nHu/X7IwaGiP4DYZmiNglGBiAFu4OQd8d2ACs\n", + "QvvHehxIHfoq857WZulVyMO7w7DG4Bi9e+cts7llxzjgfOBOZVPz6qemXC2Iy4Mh2MXUxuOip87T\n", + "FW/EMmUk4Z9FAEcJtrxujt4BnXLgX+fCQz/AOuDiYgiaTex8pVwK3jMDpsV5m4wVu9wOJANJyqZW\n", + "1c851i9G8BsMjUB1k49ilwB06FLHKP4s6/dWtJBfgQ5xul7ZVIl72QnJMmMaxLkvYDqebrwuHG8y\n", + "uareXUH/d2HstAvZH/wl7Yv7KpvKq6+2RLNueSlTRueVDQ0kQPcBEUwuDWTtimNzR4aAwGdvkH/4\n", + "TmAfE0r0gq4ngJe+gv63w7Ob+yIH21Cg8jnC1o6uJSi1Yb5IAu4BXUjeuEDs8hgwGRiubGpbfZ1j\n", + "fWMEv8HQwFQRglIBrbZB11sGyh9CVtC+uA0wEB3HIgUt6N8G1iqbKvCl/OMtYKpvfJtM1u6SCTkM\n", + "V02BiAx493t/0m0hSs2vN6EPMISMYXfxVeD95T9z2L+U/iznblIDXyBv6LG5ra+Dw3GkMp2rSWMO\n", + "OpzuI8BPRyMoWdqTnEsjYPZ3LFJ+hDC5zxCJ+q0VR9MdHZz7ZKzYJRCt2ukDnKNsKqs+z7G+MYLf\n", + "YGhwLCF44QMw+BUoioJ9Z7UjrUNv2u+4E1itbOpoXWqonW68dnSG6X+OIf6eQRB3WAchOXahlaV3\n", + "L24BGyfBuuuhIpD6djYGeoHWxeSRU5THijJ4lgwA3vQ4x+FU0+RxMfOBodxaMZgDfuu6VpB6pDdF\n", + "q1ZAv/Ng0KuQcgdFfOAfzVn9FpDSz5O1lNglAvgIbRM0WtlUfn2fY31jBL/B0OBYQnDNLbD8Pshv\n", + "a6VP2q8Wbf+u6dpVM8QuIcCEqNsZemEE3LwGLk917q86mWyNrJU/rLnZpZT6dTYGzgVaUzborbIm\n", + "D3Mc7mqaPPIKCyiMeZ6KQUf3w8DgcA4qf/h8FoQerjwuR8JBHdvBiV3aA/OA1eh5i7L6Pr+GwAh+\n", + "g6HBsYTgoV5u6fUvBBsCsctpwG3ADcCajinsWLOGgYEVVfNVFbTVT4DWFk9zC1ixcj3NcVQztzLf\n", + "tcxp8OzMYuJ7FeezE+Dg6VXq3RmTDwf0/44OzrouC4A3gMeVrZnYxvuAEfwGQ4PTMEKwIRG7BAHj\n", + "gduBvmjhNlTZVFpCsiTd6cEbputksrcJ0LrYr3ubW1gO9yyHe9znODbSF1+iWbnOkRxha8dgrokr\n", + "5r1K3zkBLSeRNSqVR/fDI99DAfQb3FNWyGR6qQD+omxqVm3PqakwC7gMhkagLkvyGxOxSxwwDR0i\n", + "dSPwCvCZsqli13y1WWhVVxJFFi6AsfN6wme9te+dgAr4JISd6QMqdezO7eduN5B7Vy+UP+wdqjeg\n", + "umhW4LxX/gR0jCGz5ytsCll+QR5PnwPRB2DMBlh4Dgz8kvSMVKY19epos4DLYGimNPaS/JpgWaRc\n", + "CtwBnAG8BYxQNrXF2zGNOZnswOFls2OuXp1c5qe31gG0D/6JSzM7sqKgG2louRZGsIRCOviVwaGe\n", + "leVEUTIsUWShN39GrvcqQSTpqY7MbvUL4adFElbYBuaM1vb+NwTR4V1/ptNM72t1GMFvMJyiiF26\n", + "okf3NwPb0KP7y5RNFTVpw7zgmMQduF9vDg5AyGNw2jTwXw5znUHTEwfB053dyxnC0ZYLYKyvvv7F\n", + "LknB+fyU9jL0+SO8+xFEF8MTw2HFhYwUu9wBzG6u180TRtVjMJykeJrYJHnjIiAJrbsfCrwDvKps\n", + "amOTNtYHPOn47wiBHq3hfg/+iTw5b2sVMokLei3gyb15xGf77s+o1c1y4NGNxLQpgMdGwJpXtAfR\n", + "wTQrhocAACAASURBVD1ZsfpastFrMZ4GXmlsc06j6jEYDIAHoddiL5x98VmUSgWBahvaV85EXxeJ\n", + "NQdcJ2HDYVhvaOnXA7I6Apbg///2zjw8yupc4L83CVnISlgTSAgS1kQEBBdEQVwgUdRahWqpS4HW\n", + "2oq211uXXh3G3l61Vq+Vam2xequ1CnWpIhDBKqAWlFVkCYQthJCwhKxkT87943yTDMMkTJJJZpKc\n", + "3/OcJzPfnO/MezIz73e+97yLs0up8wZzDNWXXkxx9MyQTPbFlTFpOow8CcWZDBG7RDgiiZuKSO6x\n", + "l//+5eU8W/B7gt48H56aDIfXsr8yi18rm1ohdhmLTjb3sNhlEbBI2VRRcxHbvsSs+A2GLkhDxsrE\n", + "L2DSMzD4c/j2Ntix+UuVvWGyr+VrK46N3oxkeGYS/Ot1fbypFbyjv+N5dSAsHwZzL+V44WCCgX8O\n", + "fI/daduZ73xHcTMcLYP8GCjNiWNsQS+Kk/M5uvpHXNh3Nfcd3aT+5Pw+YpeRwMPATHJDP+GtmydS\n", + "9qZTPcX5+2D9/b7OzhngrTc3GAz+hBU01vMk7J0J/3sYVrwIhxM7RYDRucjRvvv7CvJ6si4ukClc\n", + "QRwXlW8gzk1+nsb+jufBdbA8k/3xr3E3MArYObCIxxZD8p7esG2ALs4yCuJXwfilMGV9HtHjjzLw\n", + "YDlP14byQN5M7hS7nKFDlU1lKpu6C7iQwphL+OnKIaQtgEjrloTFydq7y7cYxW8wdEmsoLHMm2DL\n", + "PKiOsI53jqCxc7FDqRXvEve3uadvLK+tjmNdr1fJ56uehVw3R5tXzu5v+fpnzIK16ZCxARbsUGqF\n", + "sql8ZVO/SzzM5m/6w5V3wY5+sAqduK0kBG76nh7n7SICo0JC3+DXo7KBeuBed/IpmzrEO5cf5MWd\n", + "ul5v1BGnV72ftqKlGMVvMHRJcl7QZgVn/DtorKUUcsGlVfy9J3kXQtwW62jTK+odSq1YoVTaUqWm\n", + "rlAqzdWb5+BQQq79Afx+JczZfuYG6KdOxpqwiLoIAi76PR/Evw4sFLskupewtJKyOFj9W8i92Om4\n", + "7y++ZnPXYOiCtEfkrP9hmbM++qNLQZSWr6jFLtPkNkZNeo2Cb3LpvRPYbb3Wo07vCTg4XRcO448O\n", + "5atLnqT/5gJG574jdrn47JQN/huxbRS/wdBF8eegMe9gmbPK4lyOt2xFLXa5DngtbhlPDs/l/v+2\n", + "jq8D5kPdy3UE1li2kVkMILMyFSbvgM37Y1kdGEtyv2q28xTwkPO4/nzxNYrfYDC0K+cq2tJ6cl6I\n", + "5OrzRxAYH04VpwlhD7V5pRzzeEUtdpmNTvQ2c8w32F+FuOXDoC4AelXA5GICx5VE19ZLcVCE3ESF\n", + "qqW+6D8h9zk4/y2defT9VcHMmfyA2OUZZVMnncdv6uLrazdPo/gNBoPHtFRheVa0pXWksJMJ7JL/\n", + "o9HCchfCJjxzURe7zAV+DVyjbGr7rIUSCrAmCTL7QFEo5ByLIPvL6UHUfcDpwLf0Ri2/gnfnQ63l\n", + "NZp7EewbUMX5OavELq8ARUCh9dfRCh2Rve4Cy9wlj2tPjB+/wWDwiCYUVrN+6WkiGR8J04tDdV6d\n", + "flZMq6cRsw7c3TUkwIKVMP1IFLw2VmfO9HRsscsDwM/RSn+vNf5fL4Y+tcC1wBXAdCawio3wSCQ8\n", + "exSqI60RHkNfMywGTNrLPev7A18ApUAvIMap9QIUUERRaASlY8OpjIHPnoCjE61Bmk8e1+RcTOSu\n", + "wWBoP6xKYv2/gd5ZEFoEoSOSif34BbFLGmcquhggOvBR4oODIKoKrsuCv72nR4pwWx3LPU3dNWRb\n", + "+f9LQuCt8xsVf3Nji10E+C/gB+i6uIedxu/j6Pcr6+9WoiqBUMr7QGCN00hOu73M209+yc+BWqrl\n", + "DZ6btp3K2B5QWgQ5Tyi1Y4X1vqFADEsv+4DAJyYSWgQlzqmEOs7N0yh+g8HgIZYXzdDVMGi9LiFZ\n", + "FQ21oYHowvDOpo1ioGjK8/xldQVXBbgYFtxVx2qKBFiwGJK/6Q9LU+DRz2FxDclpcBIgrAYqnDRZ\n", + "U2Nbyve3wAx09tF85/Ez+8CLEyH1OKSdANsJCgorVDYwnt8fdBntq2q4tQLKaiDnDWsjN51by8OY\n", + "mno1Gc9b/RwmHLUCLVeFLEw7BZPcSNhxbp5G8RsMBg+xvGj+/aDL8cxMtXLvC85HLNPJ03XQbx6U\n", + "vwoNhU1ci7Y49Xe7AexIx9y3HA72glE/g2dWQehO8uZD0RO1JFcGNT02gBVh+xIwHpiibOqU4zXH\n", + "+JFVMKQIvh4Ir46Dzf2Jqdu3CVbcXk5pY2EWmFsDjwTDFcH6+fw5IqkbIWEBH/0tkntTdY3hvAvR\n", + "ZrF0p1rE4A9unkbxGwwGD/FMYbmaZtYBN0F5AOyvhFxH0RbHRnEgPeL7ctHQp9nV8zrKgDM3gB3p\n", + "mONL4e/vwrrBcF8aHLqMgT238V8HdnDzyWCuTIfV7grCiF2CgP8DBgFXKZsqdX7dMf7AUvjF+sbj\n", + "acLqDFvpT9i/5k4OXnEbgWExBBf35tJ9PRj4L/jLl1A6kEblHhFKRW94/ROXMptnmnD8ws1TKeUX\n", + "TYviezlMM820phukpEPaSrh1jf6bku7aZwZkKFD7eqHqQSmrpcHKM8eZl+X0shocdb2yDQs9q38K\n", + "pM+DLOXU+e4A9kV8n5dYyHEW8gcWUulW3oWEsJD3WcgKFtLTXR9348+FfSlw1tzg1jVIrSI2SyG1\n", + "TqfcugZmZDjPp7GlrWzJ/7jlnwmqpeeYFb/BYPAYT4LCIiG0XuCWWXrj9Xs74LYdEHHcedPV2igO\n", + "OwXjF8Oo98iO3cerOyNZmKUtSo5NWud0zA2lHutZVPo3tULs8jgngl+nT3WITB6Tyb/jD6GOrIeE\n", + "S5HwnsRfMpoLM3czvugqZVPV7uR1O36TpSRLK1GBcCrZ5XhZBeQs8rUJx1OMO6fBYPAqjhTICp3l\n", + "8q3z4e1UOFkVWFdxYNABcmuf4ttJd8DSKfQ8AVfaYPfNcGgKU+qvYQ1rAQ/dMh0upr96PZn8cRBQ\n", + "DCuG15L7QVAEyxnJC0SxrVJxatdxah9ra+yAe5fWefthw4KGDd4Orq3cGt1pFL/BYPAq7twvb5Xz\n", + "WJ7wYypSD0PqK3X8fWwNRzaEup47nYlksIl5sN+RPdN5XNcN4J3MWAArp/NQL3ghC4b/EK7eRMTn\n", + "KaRv3McSdahh7Pmwbz3c7x3l37HKvXl5WqE7fW0zbIudyjTTTPPPlgLpabDyaiJPTWC6ioh8SRGZ\n", + "q23eATWKuLFlhM89wxYewp1qDP1K0mClq33dnR1+HmQFMnM7KMW4VxQ9TiuwKUKK1YTeg5UC9c8R\n", + "qDWDG/canPcZukprje40Nn6DweB1rFX1CpFZa2DpFG6cDtsjYPsPoD4I8pJr4Q7gUQiqgdpQqvgh\n", + "2ynf8o1aepZ5x+FrP/sWeGk59K6AxZD8D06cLAbYOtfqWQtVUYRXJQHZVAbBj2ZCdBX855fQM5Oe\n", + "rmN3R0w+foPB0C6kiqRHk5NC7z0wYBvsutXp1bIanRThf6D2GXT6gytoKojJ4WtfGQQZTtb1EezO\n", + "O7PuwLXA/JrThAAweyfsflEHfT1/CXz0cyaKXX4mdgn36mQ7GUbxGwwGr+Ow87/Jjj7RE2fqKmC1\n", + "DpP+vP2Q84eWFIpx+NpflwXLnVzke1Ocy8iPf8+Qi6qIvD4TnsqA9b/JIm/T7YRVAAQouCkTRr3K\n", + "/qjNPAZMAw6KXZ4Qu/Tz+uQ7AWZz12AweB2HZ09ZMMQ/AONeHoOU9GIbVSeLKb2zpR4wjguJLYrk\n", + "C+6BY7+De+rZ/+FU/nhiKr8E7lU29a7rOYlNuGiKXYYDvwBmA0uBZ5VN7fV1uuTWYLx6DAaDXzBL\n", + "ZM1SmFIVCF8kwlVWqptZsHapUlNbM2aqSHoA0fadg4aNCz0RXV6ZdCy//tad/QlSs5RNfdyaMa0V\n", + "/8+AeyjqsY9/XpPAoeWDGns0n33UH2iN7jSmHoOhC5Mqkp4mkjFLZE2aSEaqyFmFyNsDh2kmpK5R\n", + "6UPLkrO5spMUvuXWmPojGwPLk+6LrL/h2DD+Pr2EhSmB5z7bPcqmjiubehwYwtbBMdyQOYi5k6DX\n", + "fqtH0zV8OzW+dkVqi0uSaaaZ1nRrygXSXSqCjnjvptIgeNoaUiL036Z4sL8ifqM19DWbvCFzQzqG\n", + "0f9Q9Cg7Ix2Drz/L5uVGtfScVrtzikgssAQYDBwCZimlitz0OwSUAHVAjVLqota+p8Fg8Jy4YB74\n", + "UR+SX+0Pd28FQbtApoNLtkjv07I0CJ5ipYU+Ngb+tAVK463jsaNFUtPbbo6x0jHsusXleMelS+4o\n", + "2uLH/zCwWin1WxF5yHr+sJt+CpiqVGMaVIPB4F3ELrHAOGCs42/ALxk1/ySMzdf5cnpadURaUgSl\n", + "LTh8+b03opUWGnFS+gDDwqDECxcz36dL7ijaovhvAKZYj/8KrMG94ge92DAYDG3EKiaSiIuSR5f2\n", + "+wbYCnwKPHvVUzy1qpZrXcdoi53dt+S8AHOvgL84XbgeRddV2dPmi5lfpEvuIFrt1SMihUqpXtZj\n", + "AU45nrv0O4CuxlMH/EkptbiJ8ZQyXj0GQwNWHvmRnK3kK4FtaCXv+HtA2VS98/nucua4y4HTmRC5\n", + "YhNMuVCXPqwDrkEHfrWuXm1XwOs1d0VkNTDAzUu/cn6ilFIi0tQV5DKlVJ6I9AVWi0imUurzJt5v\n", + "odPTNUqpNc3JZzB0FaxI0jFo5e5Q8KOBIzQq+KeBbcqmjnkyZvvY2X3Nqcch3012TM/NMZ3RV98Z\n", + "EZkKTG3TGG1Y8Weibff5IhIHfKaUGnmOc2xAmVLqWTevmRW/odPjiVKxfMcdK3iHkk8EdnHmKn67\n", + "sqmyjp2B/9OW7Jju0yr7v69+c3RoAJeI/BYoUEo9LSIPAzFKqYdd+vQEApVSpSISDqwC7EqpVd4Q\n", + "3mDwJ85SKlIPsbOzuXz1m4wtVjQq+Z6cqeC3AZnKpmp8JLpPaa7ebmsRuwQC0UCM1fTjVcOfoP6e\n", + "VEKLYP1/QFWUdUbnNRV53dRzDp4ClorIXCx3TkuIeGCxUuo6tJnoPb0FQBDwpjulbzB0DayqUiM+\n", + "gEnPQv9voDJmMMUB84A/AovRiv6wsrVyxdXFcLcPMR+GjgqRgMxHWc+ZyrslLRztRl50Rkss60tR\n", + "NlTG6AtzAxEd4unkL5iUDQaDl2hIQdx3F0TkQf5YqOgNzFqr1NKpPhbPL3Hk9DkWDlffAUWhupX1\n", + "QBHgorTdt+Imjpe6bnYDiKRlwMrpZ0tiVvwGg6FVWH7mJ0br1kDXCwDyFo50y7EV8Pd3IaZS586f\n", + "W826f9S3LqdP83QfX/3m6HKKv7Pv2Bs6M0aptBRHTp8e9XD+8cbjp9sp1qA7+eo3R5dS/E3s2A8V\n", + "SaW7fbCGjscolZaTAy/Mh6GusQaHod0ultbn0a0/ky5l42+w3wVV6o2bGkeVtc5rvzMYujrN5c03\n", + "nBtj43ckcUr8AmZ/B7KvgL0z4YCK8bFgBoNP8dRlsj1cK8+F93P6GM5FF1P81ubagavhf3MgOQOG\n", + "L4NrVl8odtkKfAQsAza52/E3GPwBbypfkdT0aAKeSCds9N+paHBZnA9DU0VwHrcp10rXfobOTxcz\n", + "9biz8c/bT/CXD/BoZglwPTATndBqOfoi8ImJjjT4C00o333r4f6WKl/H72ECh5NXh67ik/MgLQvC\n", + "rTCxdMhYoVSDCTRNJOMRmP7PIDgSA3El8N1qeMqlX3OyN3fBMo4X7UO3N/U0ublWtdvx5VoH/FLs\n", + "koy+CPwMeEPs8gX6buAjZVPZvpHeYIAEWLAYkvMiILMPXHmodTn0xS6BnDfhMZL6Je8d8haJ/WDy\n", + "YZiYC+HFuo9reuY6iP8YeK4WOKmP3R0BBT0Zdq73O9fdgnG88C+61Iq/Ve9rl2hgOvpCkA4cRd8J\n", + "LAM2Kpuq62iZDF2L5la6TmmWxwPj+2Rzb1AssdWBMPEorHgTAlTztWqt9ARJwCXo7/FEYDD1Ekh9\n", + "kAxbHcT2zRWE1p55npsV/4mV0GdjvA6iUqKLaSzoT/3ea9kJ/AOdXkLQZVsb/o7+iF89XsHYsmB4\n", + "OxXu2qbP/0042zOn8xyrhj9IxUOpoOBEChy5xCGFcbxoI91+xd8alE0VA0uBpdYP6BK0OegVoK/Y\n", + "ZQX6bmCVsqlSX2x+GTovZ6x0pR5i9xEZ+Z2Jk/oG1IT3UMETQ4nIvIjS0lGsB7YM2Eb2RweITSw+\n", + "s4hFGVRYi5QR6FTNI4BR6Pw/g9A6WtDpUzYA/8UfJv+YU2un5rGCO7mfJexvGM+dy2QY5AF9Xr8A\n", + "dvcFUfqiUxBEOVAP/BKdCzkLOEpRj74URp6HCgo8MfRU9Lv1tdQDnw2BvuX63OIQ+gPTSCzrS8Xn\n", + "oAKgJtxJ8XevVAn+Qrdf8TeH2OU84Dr0heDSoFKyxm1g0NKd9E2yiky21v5q6B40uBiHH4MFw4jY\n", + "EUr6p+UsOX26oY/zd2h0sFyfEsWiH/YiKbMP7OkD7/en8kQcFSqIYCAbKAeigARgH5aZEvha2VRt\n", + "43s3XnQiWM5IFhHFlkpF4c7j1D7u+p11pE9wnYPjzkDsEoD+LTxKVUAcqy8JZsua/tT3YALT2cgq\n", + "FBDyGBQ/CWG1Tud2wVQJ/oJZ8XsZZVMH0KuiRWKXyBFrWJcyiL4XzYcrD8KSdzquhqmhs2K5GJ/u\n", + "B88fYmTFbSxhFad7wK6+WrGXEJG859io92TQVbUkTAzbPT6zdHVMaUH0KSoDiyktVWxUQdQDl6Md\n", + "E74GMtCOCQVNvbPznlcZEWGbCKiAfouUOu72u3quYCplU/WpIjUJUFgTGjKquFdmZOb1Ayn79zoy\n", + "Ty5gNvtZwn5iK6AwDO4rdb6rMFHN/kS3U/yt9SxQNlU6a6EUv7YZ6gSORTS+1lE1TA2dEac6sRWx\n", + "hFMFwIph8D+XQ9S3EXy7JZ3ayiUhQAgoqLqpuPiaTz4tHlOeBExA7ztlAM8B37Yks2dLolTPVbjl\n", + "jA3cygrIq2D28kGsqNtDGTeyAriUO0+V1hSEfjeaLaWlPOk410Q1+xlKKb9oWpT2fo+UdJiXBUo1\n", + "tnlZkJLuyfkzIEOdebJSoNJgpa//f6b5Z3P9zk3gWuX83bmWCfphwheKm+5QPNhfcV+y4rtxh1jI\n", + "9SwkwtdzcLQZkFERhHr6MlRpcOMcJjDdaUppK1nIlyzkcl/L211aa3RnN1vxW/nSpQ7uGQel8VCc\n", + "kExt2fNWVaQcR1M2dVaSKF/kFTF0blxXulnkhd+FDPw/VBxAFeG6Y1AV5F4Max+HwqHArEPqnaUf\n", + "+U7ysykZwYALroGUE3D3Voio1sfDsW5qtOlmA9m9fsqW5JdkYVqu8dX3T7qZ4rfsrQi8+yZE50D0\n", + "Yej/aQgwDb1ZlgAMEruU4XQhAA6zkJyi9/jztbu5LroGOQ3lJq+I4Vy4mltSRdId5pRtVKUAfTg4\n", + "DQ5OczrLf1I5i116A88Ez2TE0mVw454zX69ixylI/xoOb4BL51BU1ReZ1hfuSjW++v5Jt/Lq8dSz\n", + "wPKt7ou+CCTSeEFwbgPQYS6NF4YzLxQ5QL5JDdG18LY7b5PR5mxY4Gtlaf0O5gDPAEuSF7FuagFP\n", + "ud7xboAFOkjL+n3NeACKE2H9L6xexnOnPTFePefEM88Ca/PsuNU2uxtJ7BKEVv7OF4YktOeF43kv\n", + "sUseTV8YcoACU4avc3Cu6NTWXBT8ddPTim7/I9AHmKlsaiM2SBWpaGrzt+GOeuNPoC7YaTTjq+9v\n", + "dKsVv36f1HRI7JAfmdglBB1c4+6OwdFCgSM0fWHIUTZV0h7yGZrGnRIfBAue68v0NUk69cHEo7pv\n", + "OmQchkXeyrHjS8QuwcCDwC+AJ4HfO8cGNHuu8dX3Ca3Rnd1O8fsbYpcImr8wJKCjJZu7azjibjPa\n", + "FRN17BmOlf2fIXlXX1iTBE8nU5afQFhCJYFTsuEnGxsV/yxYWwqVy4XpW+KgRx1ccEy/5poWwZ8R\n", + "u0wC/owOEvupsqlDLTrfj81WXRmj+Lsglp01hqb3GhKAgUApzVwcRj7FmMmVPNfZV6TthfV/7gVc\n", + "1W83zw3oxaC9vSG4Dm7ZBVMPwSuHObW2iFjXc6dFsDkrjfj6BOIiquGxdTBnu36tuRw7/oLYJQa9\n", + "ur8ReAD4R2vNjx15R23QGMXfTbFC6fvRzF2D1DEw7jSSWAzpWVo5QedakbYFS7HHAoMHrOTmYVnc\n", + "EhZARF4cYXsvg6oBRAGBQE1IKWrKMUIuPqJX9TP36jGuhW8HQ5jzxXN2DPUZV7Krdyk9MrYyYrhL\n", + "HK2//X/PDGAsqeQ7G7ZyQfEd6KSEDyubKvK1jIaWYTZ3uymW51C+1Ta663NLoKx9LpIrcqIgyMnP\n", + "qKtEHVuKvXfCEr4/NJe7wwKIKAmmx45J5BePpSd64702fD9lcaH0630NwZ8PhtgKGHSE0ycKeKkk\n", + "hd8qm8p1zVmjgG/7w95xhH4VTt03W6iNOU1hdRV5uQH8T/F7akmqSPozLjb+tsR4tIdZ7gxTTHQ2\n", + "XHcv9FZXsrbvo+rT48+2ZWxD58Io/m7C6XoqEoshsfjM42XgN/7izSF2kaRXmd0niAWqF9GHqyOj\n", + "TuanhqiA8EBCSoK5LCIwsr6s7rJcerxVQojjvDs+JuKjGr4unEgRMKY6jr7RAQRHF8F7b8MVhwEI\n", + "T4fhK5aqXNCBencHkXzbYIYuGw4fjoACoba2gt1VA3hh4/l8rmyq2lm+c6U7aAntVwnLCmActhy+\n", + "cyes/zkseT+YupuuBozi70YYxd9N8EbUcXtWUHKKnUgChgDDgWHW80HUMyhnDkH15YjsjaDk8zRU\n", + "6ZLGAQpvrxgVsiTgrZL6EAVsjYPxefB6BbEX7ebqjRM5AuyIOcaIhBJCIqsh0kl1R0CY2KUPkM5C\n", + "Zu6sY8A7JymK30dh/DvkRuTy5M765pWut2rHJsCCFwNJXjoSxubD8AJvJQO03C3zLoRX1sMpR30V\n", + "427Z3TCKv5vQ1hWppxWULBfWaKtFuTx2uLbGA/3RNvcYIBzt1qqsFgjUAKeBEqAwKo+SGYX0jqyG\n", + "1V+NpKp0CUgdDNgGSWshqSws9Mt6lqbo5GeiYP1fILQWkg7w5dc2vcGaJpLxumXGUcDuPrBsBGSc\n", + "zxhgP/AvYBmB/LT0JXW8Nf/rtiB2SRx6HaMGj4RRJ+GZVY2vtd0sZyWMKxuADkFx4D9RwoaOwSj+\n", + "bkRzK9Jzr+YtM0HPk3Dtf0BoMYSUJBN56C2xywkalXwA2nxUgy7eEQAEo5VWNVCEjnjOB3aiXQf3\n", + "A3utY9Xoi4EjajoRSAyEwZvj4UgUJP3Lym9z0R/gwj9D9uVQEs9XNwXU15yuD/jvT+G6vY2FTJzN\n", + "WYdCeXHGIFJHD2XgsuFQGQRhByjpcZj/ZQDPKJtyJJ7pMKzN+WuBnwCTy0Mo/fSvWvE703aznEmN\n", + "bNAYxW/wcDUfoc0ENWFw6EqoioLKaIh8BG7eGABEopX6IatlOz12PC9Hex8lOrXBwM1Oz6NodEt1\n", + "tC8SvyR16TEmJBTDTbWn2QOwZa4WbdLv4MRoAlcmZI3Oyg683sWctS+GV8UutwEzeZgZeyso2L2d\n", + "rPM+oCT0MCdyYFGBD1xaLdPS3cCP0Xc2LwG3x77HlOe8uFHswF+jhA0dj3HnNDRGXPY8Cb33QMwh\n", + "3eIXHWHUsUwgidcnnMeBjQFnnRwxbTMPfvYDtGKvp3GlPpgzFbwjDqGMRoWezZkK/jBw3F1+I+cN\n", + "zyWh4dw7cQinLj4OhyfDF4/A0Zf3w4YFKewkEe4L6UGvgkiit0+huvgChgBr0S6LHymbOurN/19L\n", + "sPYyLkGv7mcCH6BTI3zt7DufKpKe6IWNYkPXx7hzGlqJtek37lUY+T4UJemW27ecUcd+B2STXzoK\n", + "mfcs6pUhDaf1nFPEtK2VwOtoxR5NY/oJR/s38DZayecomypvjYQ7lFoxZIjEJIzh1/mjTyf2PJhZ\n", + "HPjm2Py6vMCT8HgFgYde5LHdxTvhhp36ohOLVvTL0JWqWvW+3sKK0L4duBe9p/Ey8POmKmh5a6PY\n", + "YHCHWfEbms6xMuCyI9zz70wcq/XdkTWsHw1VUTVQXkbKntVccXIVjUr+WHtkIxW7DEbnj/k+8Bbw\n", + "jLKpQ2KXSLRt/AYgHV2p6kO0st/kD5lRxS4p6NX97ei7jpeAf/mDbIaugVnxdyNa4lrpCG7Cvfll\n", + "MLMjk1k1W1G4pPHLEzankOFZ7wPLsRS7ervk9FmDtyNil5HAQ2jF/gowGr1RPFPscgNwKbAerewf\n", + "VzaV3ZHyNYWV6OxmtMIfBiwGxiibOuJTwQwGC7Pi74SctRkbWAUxc7IZ/9nLXFaQh3sbewVn29Mb\n", + "bey/HjWeuqSfdvSmn7sLGAt35gOPAFPQG5r/BqaiLwDxaBPIMmCVP2Uute5MfgTMBXahV/cfKJuq\n", + "8alghi6NydXTTWgwzSR9Bt+9HcJO6TKSlQWFxJUu5+xN0xxlU6U+FdoNZ13ABq+Dqd8rZ1B+BT3U\n", + "++g70hlAIY32+vXKpup8JrQLlivmdPTq/jLgDeBlZVOZPhXM0G0wpp5ug7UZe3Qi/HmTDshRgcCs\n", + "7Uot/YFvZXOP25W9Izag9x64cS5E5MMXT/Tky5eDmbN5KFrR/0bZ1D5fy++K5Yr5Q7QrZhF6dX+b\n", + "sqkONYcZDK3BKP5OiRWBWR2hWwP+GYHZRJ72oQQf1+Fa5X3h65/CrluhPggCVn6lbJumNTmgj7D2\n", + "Si5Fr+6vB/4J3AZsNFXUDJ0Jo/g7JZ0tAtNa2QdVQtIaGPEhDF+VzLtxdRwGKmJhx22N3esr/Mos\n", + "ZXkPfR+t8MPQrpj3K5s65VPBDIZWYhR/J6TzRWBapqm7puharHtnwhsfw8n7d8H8MH+9gIldUtHK\n", + "/jZgDdql1LhiGjo9RvF3Uiwl76eK3hXLNPXa5y5FuINyYf0if7qAWUnmHK6YyRhXTEMXxHj1K6O9\n", + "3wAABvFJREFUGNqdzlCLVeySRKMr5g70Zu2HxhXT4O8Yd06D3+KPtVjFLoE0umJOQqeeeFnZ1B5f\n", + "ymUwtASj+A0GJ5qKbha79EW7Yt4DFKBX92/7Op+PwdAajB+/wWBxtnlJwZDrU+T+4H3EMg54D5il\n", + "bMptjWKDoStjFL+hi2K5kAaXwZg3YOIfIahyEDsTyrj8wHnGFdPQnTGK39BFsVxIw4/DeZ/Ax8/B\n", + "wWmgvndMfbLfKH1Dt8YofkMXxXIhLTwPlr7rdNw/o5sNho7k7IpKHiIit4rIThGpE5HxzfSbISKZ\n", + "IpIlIg+19v0MhpaR8wLMd8nx4z/BYQaDL2m1V4+IjESX2vsT8B9KqS1u+gQCe4CrgVxgI3CbUmq3\n", + "m75d2qtHRKYqpdb4Wo72wF/n5i0XUn+dn7cw8+vcdKhXj1I67axIs+93EbBPKXXI6vs2cCNwluLv\n", + "BkxFh/13Rabih3PzYnTzVPxwfl5kKmZ+3YpWm3o8ZCCQ4/T8iHXMYDAYDD6i2RW/iKwGBrh56VGl\n", + "1DIPxveP6DCDwWAwNNDmyF0R+YymbfyXAAuVUjOs548A9Uqpp930NRcJg8FgaAW+itxt6k03AcNE\n", + "JAk4CsxGp7g9i668sWswGAz+RFvcOb8jIjnAJcByEVlpHY8XkeUASqla4GfAx+ji00vcefQYDAaD\n", + "oePwmyRtBoPBYOgY2turp0lEJFZEVovIXhFZJSIxbvokiMhnVqDYDhFZ4AtZPcWTYDURecF6/RsR\n", + "GdfRMraFc81PRL5vzWu7iHwpImN8IWdr8TTYUEQmikitiNzckfK1FQ+/n1NFZKv1e1vTwSK2Gg++\n", + "m31EJENEtllzu8sHYrYKEXlVRI6JyLfN9GmZXlFK+aQBvwV+aT1+CHjKTZ8BwFjrcQQ6GGyUr2Q+\n", + "x3wCgX1AEtAD2OYqK5AOrLAeXwxs8LXcXp7fpUC09XhGV5ufU79PgY+A7/pabi9/fjHATmCQ9byP\n", + "r+X24twWAk865oVOxx3ka9k9nN/lwDjg2yZeb7Fe8dmKH7gB+Kv1+K/ATa4dlFL5Sqlt1uMydOBX\n", + "fIdJ2DIagtWUUjWAI1jNmYY5K6W+AmJEpH/Hitlqzjk/pdR6pVSx9fQrYFAHy9gWPPn8AO4D3gFO\n", + "dKRwXsCT+d0OvKuULjOplDrZwTK2Fk/mlgdEWY+jgAKl9yD9HqXU50BhM11arFd8qfj7K6WOWY+P\n", + "Ac0KankGjUMrFH/Ek2A1d306i3JsaTDeXDpNTWDAg/mJyEC0QvmjdagzbZB58vkNA2It8+omEflB\n", + "h0nXNjyZ22IgRUSOAt8A93eQbB1Bi/VKu2bnbCYA7FfOT5RSqjk/fhGJQK+y7rdW/v6Ip0rA1W21\n", + "sygPj+UUkSvRFa4uaz9xvI4n83seeNj6vgpNuzH7I57MrwcwHrgK6AmsF5ENSqmsdpWs7Xgyt0eB\n", + "bUqpqSIyFFgtIhcopUrbWbaOokV6pV0Vv1LqmqZeszYrBiil8kUkDjjeRL8ewLvA35RS/2wnUb1B\n", + "LpDg9DwBfeVtrs8g61hnwJP5YW3oLgZmKKWauz31NzyZ34XA21Z+qj5AmojUKKU+7BgR24Qn88sB\n", + "TiqlKoAKEVkHXAD4u+L3ZG6TgN8AKKX2i8hBYAQ61qiz02K94ktTz4fAndbjO4GzlLq1qvoLsEsp\n", + "9XwHytYaGoLVRCQYHazmqhA+BO6AhqjmIidzl79zzvmJSCK6pOEcpdQ+N2P4M+ecn1LqPKXUEKXU\n", + "EPQd6E86idIHz76fHwCTRSRQRHqiNwp3dbCcrcGTuWWiswRj2b9HAAc6VMr2o+V6xYc71bHAJ8Be\n", + "YBUQYx2PB5ZbjyejUz9vA7ZabYavd9mbmVMa2vNoH/CIdezHwI+d+vzBev0bYLyvZfbm/IBX0N4S\n", + "js/qa1/L7O3Pz6nva8DNvpbZ2/MDHkR79nwLLPC1zN6aG/oObZn1u/sWuN3XMrdgbm+hMx9Uo+/K\n", + "fthWvWICuAwGg6Gb4UtTj8FgMBh8gFH8BoPB0M0wit9gMBi6GUbxGwwGQzfDKH6DwWDoZhjFbzAY\n", + "DN0Mo/gNBoOhm2EUv8FgMHQzjOI3GNwgInYRud/p+W/8vRCQweApJnLXYHCDiAwG3lNKXSgiAejU\n", + "IhNV50o8ZzC4pV2zcxoMnRWlVLaIFIjIWHRq8S1G6Ru6CkbxGwxN8wpwN7pI0Ks+lsVg8BrG1GMw\n", + "NIFVC2IHuqbrMGV+LIYuglnxGwxNoJSqEZFPgUKj9A1dCaP4DYYmsDZ1LwFu8bUsBoM3Me6cBoMb\n", + "RGQ0uuTgJ0qp/b6Wx2DwJsbGbzAYDN0Ms+I3GAyGboZR/AaDwdDNMIrfYDAYuhlG8RsMBkM3wyh+\n", + "g8Fg6GYYxW8wGAzdjP8HuK8w17ibVlIAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['WNN']\n", + "modelWNN = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelWNN)\n", + "fwd_WNN = generateFwdTest(environment, modelWNN)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "####Locally Weighted Linear Regression forward model\n", + "\n", + "The LWLR computes a linear regression of the $k$ nearest neighbors of $m$ which is weighted by the distances from $m$ to his neighbors. It finds the requested $s_p$ given $m$. As before, it is possible to change the number $k$ of nearest neighbors. " + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEZCAYAAACAZ8KHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXm8HVWV77/rhkASJoEIQpiEBJUINAIBhWgQHoZIgxP4\n", + "ABmliSgkNDwVh4YIaIO0CgEbAWUKoyK2pMWgDwjSDEKYFfAlIWHKABlkMAMB1vtj75PUPbfq3Dr3\n", + "njrj7/v53M89VbWrap06VXvV2mvY5u4IIYQQeelqtABCCCFaCykOIYQQVSHFIYQQoiqkOIQQQlSF\n", + "FIcQQoiqkOIQQghRFS2vOMzsXTPbrtFytAtmdqSZ3VHnc841s/3qec5WxMw2M7M/mdnrZnZBgefZ\n", + "28xmmtkbZnZwkec1s7+Y2cdrecxaY2bTzezLDTr3JDObEj9vHX8Tq8N5Kz6TdVUcUZhl8cu/EW/E\n", + "9xV4vulmttzMtkys29/M5pTJtNDMhiTWnWBmd/fz3EeY2Yz4PeeZ2e1mtnd/jlkP3P16d/9UvU8b\n", + "/6om/n6frLE8zcqJwCvuvoG7f73A85wNTHb39d39tlqd18yuNrNzkuvc/cPu/qd+yls0fb4/a3Tu\n", + "8MH9hfibVJTFzMaY2Ys1OG/meeptcThwUPzy68cbcUHB5/wH8G+9tOkCJtbqhGZ2GvAT4FxgU2Ar\n", + "4KfAwbU6RxGY2YBGy9AHHCj8DaxJ2AZ4pg7n2Rp4ugHnbWvMbK1Gy1Az3L1uf8Ac4JMp668BTouf\n", + "hwHvAl+Ny9sDixNtvw7MA14Cjo9tt8s4393AmcDrpTbA/sCcMpm+CSwGNozrTgDu7uN33BB4A/h8\n", + "hTbrABcCL8e/nwBrx21j4nf7OvBK/K6fAcYB/y/KeUbiWJOAW4Cb4vd8BNg5sf0MYFbc9lfgM4lt\n", + "xwL3AT8GFgHnxHX3xu0WZVsIvAY8CYxMfM9ro4xzge8Aljju/wAXAEuA54CxvdwXZ0T5lgBXAusk\n", + "th8EPA4sjfLuFNdPAd4BlsVr/nXg6irupdTjxm1bAL+O3+854JSya/5Lwn37OvAXYLeM7/Yx4FVg\n", + "y7i8S/yOO1Ro/zDwd+Ah4KNx/dXAW8DK+F3TnqNx8Rq+TriHTq9wzY8nKIclwDRg67h+dtk1vaH8\n", + "vPG+KN1Xi4CbgY0Sx94HuD9e1xeAY4B/KTvOb2PbufGYW8RzJo+za7x2AyrJnPH9fgXMj9fxHmDH\n", + "xLarCS9y/x2v1YMk+hDgfwHPxn0vBqYDX844zyQqP39zgW8Qnp3lhJfUvRLX53HgE4n274/yvg78\n", + "IZ5/Sty2LeF+7orLGwNXEfqQJcCtwJB4nnfidX4deF+O3+wo4Pm47dtk9NWr2/elc+zrXxRmv5T1\n", + "xwG3xc9HxC93U+Jm+U38PBZYAOwYL9AN9K44vgz8KHHx0xTHfoRO4py4rj+KYyywqvTjZrQ5O944\n", + "Q+PffcDZcduYuP93gQFRlkXA9cC68bsvA7ZJ3LhvAZ+L7U8ndHSlh+0LwPvi58OAN4HN4vKx8Vxf\n", + "izf0ILorjk8BM4AN4vIHEse6FvhNlGkb4G/A8YnjvhWvvQFfAV6ucD3mEh6sYcBGBKVT+i12JSiu\n", + "PeKxjo6/2cDE7/fJxLHy3kuZx43X4pH4G6xFeJhnAwckrvny+Fsb8APggQrf71zgTmAw8BRRkaW0\n", + "25jQmRwZZfjfhA5ho7j9KuJ9krH/fGDv+HlDYNeMdocAM+Pv2UVQ+veVPRPJa9rtvATr/H5CZz8Q\n", + "+BlwQ9y2DaGz+iLhftwY2CVL/uS54jU6IbHtAuA/88ic8h2PJdybAwkvP48ltl1NeKZ2jzJeB9wY\n", + "tw2N8peep1MJz8jxGeeZROXnby7wKOHeXif+X0R8kSL0R4uATeLyA8B/RLlHR1mujdu2pbvi+B1w\n", + "Y/yt1wJGx/WfAF4sk7PSb7YjQcnsA6xN6C9X0USKY24UcGn8uzWu357wgBhwKWFM9cW47Rrg1Pj5\n", + "SuAHieONoHfFcXy8Gf4eL1Ca4vgkMDK2GUr/FMeRwPxe2swi8QYOHFCSiaA4lrHm7X39+B33SLSf\n", + "ARycuHHvT2wzgpWyT8a5H0vseyzwfMoDV1IcnyQohD1JKELCA7IS+GBi3YmlaxaPMTOxbUj8Dptm\n", + "yDQHODGxfCAwK36+lJ6dzbOseUjKO7m891LWcT8ev2/5dfkWcGXimv8hsW1HYFmF33ut+Js9Bdxe\n", + "od1RwINl6+4HjomfryIq1Iz9n4/fd4Ne7r/fk+gICR3xP4CtMq5pt/MS3vqT2zcndJ4D4nX6dcZ5\n", + "e8hPd8XxZeDOxH38Quk+7k3mXr7ve+L9t35CjsvL7rdn4uejSTxPcd2LVFYcac/f3onvd2xi+zeJ\n", + "iiCxblo879aEDntwYtv1pFgc8Zq/QxwlKTveGHoqjkq/2ZlEJZJ4XldSQXE0wsdxiLtvFP8+B+Du\n", + "swk3wT8RtOx/A/PMbAfCg3xP3H9zwo9Y4oVcJ3VfBFxCeNP3jDZ/jec9I6sNgJn9LOHcPyOlyWJg\n", + "qJlVurZbEB7yEi/EdauP4fEXJLzZQng7JrFuvcTyS4nv4XF58yjv0Wb2mJktNbOlwIeBTRL7ZjrR\n", + "3P0uwnX7KbDQzC4zs/UJynVgyncYllhekDjOsvgxKXM55b9r6XpsA5xekj9+hy3pfr2SMue9l7KO\n", + "u3nctkXZtm8R/FUlkr/HMmBQ1m/u7m8TlNZIwttcFlvQ855+Puu7pvB5wnDV3BgYsldGu22AixLf\n", + "bXFcPyyjfTnbAr9J7P808DawGeEaPpfzOOXcCnw0Bsx8HHjX3f+nWpnNrMvMzjOzWWb2GqHzhnDf\n", + "lsh6nrYg8TxFenM0pz1/yd8suf82wKFl99behOGkLYCl7r480T75jCXZClji7q/1IluJbcn+zTYv\n", + "+w7LWHN9U2mmcNx7gEMJQxDz4vKxhKGLx2Ob+QStXCL5uTcuAPYFdqvQ5izCWGzmA+TuX/E1zv3z\n", + "Upo8QNDWn61wnnmEH7LE1nFdX9mq9CF2XlsSOsttgMsJQ1Ebu/tGhPH4pDM5U0kCuPvF7r474a16\n", + "B4If4VXCm1H5dyh/4Kqh/Hd9OX5+Afh+4mVjI3dfz91vriB/nnup0nFfIFiAyW0buPtBFc6ZiZkN\n", + "I7zVXQn82MzWzmj6MqFjSbINa65FRdx9hrt/Bngv8F8EP0waLxAsvOT3W9fdH8xznrj/2LL9h8Rr\n", + "/SLB6ksVsRf5lxLG9b9IGGa8sY8yH0kIRNnP3TckDDVCviCKeXR/niy5nEHq85f8amXfY0rZ91jf\n", + "3X9I6N82SkZ4En7/tOv2IrCxmW2Ysi2tfaXfbH7ZdxhC95fLHjSb4jgZKIXmTY/L9ybevn8JHGtm\n", + "H4pf7qwcxzWAqJl/RDAVU4lvqzfTjwireJ4zgZ+a2SFmNsTMBprZgWZ2fmx2I/BdMxtqZkNj+yl9\n", + "PSewm5l9NkZtnAqsIDj81iXcRIuALjM7jmBx5MLMdjezPc1sIOGtegXwjru/S/gtvm9m60UF9a+E\n", + "seK+YMDXzGyYmW1MGL8uKYYrgK+Y2SgLrGtmnzaz0hviQnp2VHnupUrHfQh4w8y+YWaDzWyAmX3Y\n", + "zHZPyJvvi4WO52rg5+5+AuEhPSej+e3ADmZ2uJmtZWZfBD5IsJoqnjfeY0ea2YbuXnKMvpPR/GfA\n", + "t81sx7jvhmZ2aKWvkbL/D8xs67j/e82sFDF4PbC/mR0av8MmZrZL3LYQ6C3n6gaCM/3z8XNfZF6P\n", + "8PK2xMzWJfigKn2fJLcDIxPP0wSCNVCJrOcvjeuAfzazA+J9NSiGzw5z9+cJQ5rfi7/nPoQAjh64\n", + "+3zC8N1/mtl7YvtSPsxCYBMz2yCxS6Xf7BbgIAv5O2sTRmYq6oZmUhx/IvzgpYf9PoIzcXWMt7tP\n", + "I0Qj3UWIMLqT3t/+ktsvIphnlfY5mzDGV9VbZbcTuv8YOI3gXH2FoO2/SnAmQ3CWziA4hJ+Mn8/N\n", + "kDltuXzbbwlvaUsIb1ufc/d33P1pgrJ8gDB09GGC4zm5b9q5Sus2IFgsSwj+qUUEyw3gFMKQ0HPA\n", + "vYQO46pejlvpO1xPeNucTXCCngvg7o8QrMBLohwzCePBJf6doISXWgiDhnz3UuZxo2I8iDDc9RzB\n", + "wro8Xo9qv98EwhBJKST8OOA4S8npcfcl8bynE671/yGEry+pcN4kXwLmxOGZEwn3Qg/c/b+A84Gb\n", + "YtunCIEQWZSf9yLgNuAPZvY64f4aFY/9ImG47HTCcMdjwM5xv18AO8bf6taMc90GDCf4CZ/qo8zX\n", + "EoZ4XiZY2A+UyZ/5+8Vh7UOB8wi/wXC6PzPlZD5/qY3dXyI4+r/Nmr7hdNb0xUcQfGxLCC+U16TJ\n", + "GTmKYPk/S1AWE+I5niW8nD5nZkvi0F+l3+xpwqjEDQRLaQm9DM/Zmhew2mNmVwKfJiQP7ZTRZjLB\n", + "ObWM4ER6rDCB2hAzOwsY7u5HNVoWITqNTn3+irY4riKELKZiZuMIF30E4Q3p0oLlaUc6JflNiGak\n", + "I5+/QhWHu99LCLvN4mCiKebufwbeY2abFSlTG9Lb8IUQojg68vlrdAr8MLqPpb1EiEhYmN5clOPu\n", + "32u0DEJ0Kp36/DWDc7zc1Os47S2EEK1Eoy2Ol+keI70lKTHrZiZlIoQQfcDda+6HabTiuI0QX3+T\n", + "hSzXv7t76jBVEV++FTGzSe4+qdFyNAO6FmvQtVhDR14LsxGEBNN94prrgInWSwZ4XylUcZjZjYSC\n", + "W0Mt1Ic/i1CqAne/zN1vN7NxZjaLkBNwXJHyCCFELYgRoRMIhUFXEOYvub0BgnRFOX5AyFVaAIwn\n", + "zKMCBc35VKjicPfDc7Q5uUgZhBCilkSlcREhObDE9mZGXZVHhpXBmoTRwmgG57iojumNFqCJmN5o\n", + "AZqI6Y0WoImYXvDxJ9BdaRCXp5jZtKhYisOsC7NTgScISmMBcAjuR9VDaUDBmeO1wsxcPg4hRDNg\n", + "ZtMJQ/BZzAImFmJ9VGllFNV3yuIQQojqWNHL9uGEWm61owmsjCRSHEIIUR2TCVZFJQbX7GzByriH\n", + "MJPhYIKVMXK1A7wBNDocVwghGkpahFTclBo1FaNBIVgVexLmeSlnecq6agWrHDHVQKQ4hBAdS0aE\n", + "1O6EsvzrJNZ1i5qK/2/P2H82cHHKefKH7zYwYioPUhxCiE4mLUIqbfa7kt/i9hQlcB2wF8EqWA5c\n", + "nFQKVYXvNrGVkUSKQwjRyQyqou3gLCVA5SiqrPDdUwgzDgaa3MpIIue4EKKT6S1CKslyKiuBLLKU\n", + "U3CgN1nEVB6kOIQQnUyeCCkIM5ReTG9KIJ0s5bS8GSOm8qChKiFEx1IWITUYWJcwT9DmiWbLgB/G\n", + "thMyDlUpimoyYThrtaXSBbN/H+Ybf4Im9mVkocxxIYRIEP0YJUXSzdldIYpqQqUoqeQx/wnsDthk\n", + "UxgZNxfmyyiq75TiEEK0PbWsZhuPdTawHWHiuTnAmb0eryxiagUsPQnmXA1v9FemCrIW0ndqqEoI\n", + "0XJUowiqrWab89gbsibxb2PgoorVccsipmbCXR+DbRfBR/LI1GxIcQghWoo+lDXPFw6b/9i5j5eV\n", + "l7EDfJVgsfR+jCZEUVVCiFaj2pDYaiKh8hw73/EqR0z1JTqraZDFIYRoNartdLPCYUfGEunJ+lSj\n", + "MtoOM7Np8dwjM9qEyKp82d/ZIbotgBSHEKLVqLbT7REOC6wChrJmXo2dACO9YCFx/53K9h+YWA71\n", + "qfJnf6fJ1KPGVbMixSGEaDWq6nRTcjVGEpRGki0qnO9dYEjZuoHAIuCvwPK14ZKVsANwCznyMlJk\n", + "6lHjqpmR4hBCtBT96HRLYakDqjxlli/4r+4+pq81pkoVdquUpSlQHocQojBqmT/RTxnKI6X6TRdM\n", + "ewfuoIkr2SqPQwjRUvQhbLYo0iKlypkf/29esVXkQ/DCdNiKEDEFTVzJtggUjiuEKIq+VJItgt5K\n", + "py8CToh/0wghtIvSGnbBknPhmadgs1gypOkr2RaBLA4hRFE0S65Cb6XTBxFKiLwZ2/4wru9mLUUr\n", + "44161JhqdqQ4hBBFUZNchUp+kpw+lLQorCTrAbsllnciWBLLgUVdMP9sWOsM2G4AbE0T+jLqjRSH\n", + "EKIo+p2rkOEnGW1mswm5FO+jeyhtDx9KIgrrewRroTeLZ4vSMYcD18N6o9ZYTx1rZSRRVJUQojAq\n", + "lSjPuf804FNVnnaaux9YQZ4phMKE2edlTer3EGAxrNwEDms1K0NRVUKIlqMGuQrVzAleItOiiNbH\n", + "w1RQRsMJSRmj4/IU4OswY0GLKY0iUVSVEKKZqWZO8BLr9rI9dbpYAyYSpuQbTYjPPRg4GlgY5swQ\n", + "ESkOIUQzk3dO8CTD4pBUDxLO9OWEkNungEc+DE89Aq9dSBiamkJwhkwNu9WshpSZjTOzaWY2Pf5P\n", + "lbPZ0VCVEKJpKSsvMozgbC+vG1XO5uSca6ML/v57eOAAOIqY/X05XD4+VMmtaQ2pJkqI7Ddyjgsh\n", + "WoaEs/2jhFn4sriHkI+RDNUdSiLsttyXQcERUxUc/ZnO/BqcU85xIURnU3K254i2Wpeeb/fLoWfE\n", + "1CJ4aygcWoeIqWZJiOw38nEIIVqRB4BlGdtmE/q28oS/wcMJpkjSl7ET3FunMNuWnrwpiRSHEKJP\n", + "1MLR25djxDZforuv4x1gLqHW1ATKoqAqREzNXgA/rlbuPpLm6G+ZyZuSaKhKCFE1tXD09uMYacUT\n", + "BwDPlnwFZjahtKHcl3E7zDse5sQQ27pNntTqkzclKdQ5bmZjCVbhAODn7n5+2fahBIfU+whK7D/c\n", + "/eqU48g5LkQTUQtHbzXHKKtJtTPpU7ze4+5jSu274KJTYHjJl/EKvPNf8P0T3c/KI1870HLOcTMb\n", + "AFwC7A+8DDxsZre5+zOJZicDj7n7t6IS+ZuZXefubxcllxCiJtTC0Zs1XWu3Y1QxEdNqX8HRsMXX\n", + "YMtRcflGWPUd+PFzHaQ0iqRIH8coYJa7z3X3VcBNwCFlbeYDG8TPGwCLpTSEaAn65eiNymD7jM0f\n", + "M7MZCX9HnomYgq/ArOsPZpf9DC4fBYNKvowjYOAcOKpVE+6ajSIVxzDgxcTyS3FdkiuAkWY2j+C3\n", + "mligPEKI2tFfR+8EshP5BhLyLa6IHX2lelXLgUeACQ4zgXsOgBMHg5Vlf0OwcOo9iVRbUqRzPI/z\n", + "5NvA4+4+xsy2B/5oZru4e4+6MGY2KbE43d2n10ZMIUS11MDRm6d4Yamjr1SvanAXvPoO7ADcAgxe\n", + "BG8dD2tPzWifU76WxMzGAGOKPk+RiuNlwpy8JbYiWB1JPgZ8H8DdZ5vZHOADwIzyg7n7pGLEFEL0\n", + "hX5Wvs1bvHAwIQM8dSKm4cAvQxb52Ljqup1giwXwyYzjtVzORDXEF+rppWUzK8SnU+RQ1QxghJlt\n", + "a2ZrA18EypNsniU4zzGzzQhK47kCZRJCNAd5ixcujwpqIol5wJN5GbuG0iOr5/5eAD8i+E/LmU8L\n", + "5kw0I4UpjujkPhm4A3gauNndnzGz8WY2Pjb7AbC7mT0B/F/gG97hM2sJ0Q70ltiXUAbTCBVqV6Yc\n", + "ZnVHH9sfA8wqz/6eCXcBI0vZ37HtCQTfx5L4NwM4oRVzJpoRFTkUQvSZtDm/46by8NlZwMSsjjse\n", + "52zg/XHVc8BZ3dqbdf0BLv04nDAIuhbDyl/D+Z2Ul1EtRfWdUhxCiD6RkV+xjFD+Y/2UXfpeBdZs\n", + "BCEBfJ+4RnN/56DlEgCFEO1JwsoYRc8M7kpzZVQf0WTWxZpitoMJvozxrTb3d7shxSGEyE0VWdxp\n", + "VBfRJCujaVF1XCFENeTJ4k4jf3KgWRdmpxKCpvYhETElpdEcyOIQQlRDnsS9JEuAh8ibHNgPKyPN\n", + "Ua8oqmKQ4hBCVENW4t4bhCrYSR/HbGBCToXRL19GO83n3QooqkoIkZuMDno2odOHvpQgqWBl5LUi\n", + "GjGfdyugqCohRENI6byvA/YiXUHkf7vvxcqo0opom/m8WwEpDiFEJlmdNxWS+XIeOI8vI80RP5xg\n", + "1ZSfu23m824FFFUlhKhEpc67eqqLmKrGimib+bxbAVkcQohK1G4IqPqIqdxWRDvN590KSHEIISqR\n", + "1Xmvm/sIfY+YmkzPcuqZVkQ/y7yLKpDiEKJNqVFew2RgJ3rODz7MzMb1erx+5GXIimheFI4rRBuS\n", + "4dSuWKG2wrEeAT6Ssik71LXGNaaU3Nc3FI4rhKiGaiKSeqPHVM6RdD9HjWtMKbmv+ZDiEKI9qWVe\n", + "Q6afIybeDQJWrA0Xr4QR1L6SbS2VoKgBUhxCtCe1zGtIc1LPB4YBuxM3XA+fYI3CqmUlWyX3NRlS\n", + "HEK0J7kikvL4DjKc1JsCHzHWODKGwKDFsHITOKzG82Uoua/JkOIQog3JE5FUyXcQKVcoByb2nT6c\n", + "4MgYHddNAb4OMxbUfpKlqsJyRfFIcQjRpuTIa8jyHXwPeA9ZzmizrnNhs38llMKdD4wHpoZ2WY70\n", + "PqOw3OZD4bhCdChmNp3glyhnKT2nhAWY5kHZrI6YmgJMjDtQTRl1URcUjiuEqDVZvoMeb5MGTAoR\n", + "U08QI6Yuh8vHh3nHZQV0GLI4hGgy6pXsVmFujddIJPyV+zLQ3N8tgywOITqAeia7ZfkO4uaLDIYn\n", + "IqZYAUsHwbE1jpgSLYgsDiGaiGaZye4YsxNOgx/uEn0dM+GuEXBob1aGSoM0F7I4hOgMGpvsFmtM\n", + "XVOW/T0ih5Wh0iCdgyZyEqK56Feym5mNM7NpZjY9/h+X+8yhxtQ9wE8ISuM6YGQVQ1O1nfRJNC2y\n", + "OIRoLvqc7NbnN/7aVbJVaZAOQYpDiCain8lu1RcDrG0lW5UG6RCkOIRoMvLMZJfmhKaaN/4az5cR\n", + "UWmQDkGKQ4gmoJpopIwhqdHAuxmH7/7GX+P5MkqoNEjnIMUhRIPpg28ibUhqSMbh17zx57Ay+htO\n", + "q3m/OwMpDiEKoopOuFrfRNaQVJIlwEOU3vhzWBkKpxV5keIQogCq7ISrjUbKckInecrdD8SsC7NT\n", + "yefL0Ex7IhfK4xCiGKrJaag2GmkyMKuX8y/vQ16GwmlFLgpVHGY21syeNbOZZvbNjDZjzOwxM/tL\n", + "LPMsRDtQTSecpggyo5GixTIRmAbMpayabResuiJ8fIIwNLUAOAT3o3pxgCucVuSisKEqMxsAXALs\n", + "D7wMPGxmt7n7M4k27wF+CnzK3V8ys6FFySNEncndCfclGqnkhI61rbYtrY+VbAeOhrFxVTURUwqn\n", + "FbnIpTjMbAiwlbv/rYpjjwJmufvceIybgEOAZxJtjgB+7e4vAbj7oiqOL0QzU1UnnBWNlMPBPgjC\n", + "fBnJSraL4K2hoShh7rwMhdOKvPSqOMzsYOACYB1gWzPbFfieux/cy67DgBcTyy8Be5a1GQEMNLO7\n", + "gfWBi9x9Sl7hhWhWatEJ53Swr0ib+/sbcO/8PiTzKZxW5CGPxTGJ0OHfDeDuj5nZdjn2y1OvfSBh\n", + "wpj9CC9KD5jZg+4+M8e+QjQ1NeiEK0c5mXXdAc+PBh8Mlpj7ezbw436cV4iK5FEcq9z97/HtqURW\n", + "hmqSl4GtEstbEayOJC8Ci9x9ObDczP4E7AL0UBxmNimxON3dp+eQQYhWJtvBHvMyDoh5GbfDvONh\n", + "zkJ4Aw0vdSxmNgYYU/h5epvIycyuBO4EzgA+R3gLGujuX+llv7WAvxGsiXmEZKTDy5zjHyQ40D9F\n", + "GAr7M/BFd3+67FiayEl0DAm/xijiREqrtwHnwDPfCQ7xWtWYEm1KIydyOgX4DrASuBG4Azint53c\n", + "/W0zOzm2HwD8wt2fMbPxcftl7v5sjAp5kmDFXFGuNIToJDL8GhBXXAcr9oQPxVWa+1s0hDwWx0fc\n", + "/dE6yZMlgywO0RGkTR1rwOmw7BwYNCjkXsnKELkoqu/MkwD445jEd46ZfbjWAgghutHNrzGckPp9\n", + "AQyJSqPaWfmEqDm9Kg53HwPsCywCLjOzp8zs34oWTIgOZQUEK2MiIfV7NLA4DBXnyf4WonBylRxx\n", + "9/nufhHwFcK9fGahUgnRuUzeEZ6/B7iQEKN+C7wxFo6WlSGahTwJgDsChwFfABYDNwOnFSyXEJ2H\n", + "WZfDDu/A+wYQsr+/Dn+5Gv5N4bWimcjjHH8QuAn4lbu/XBepesog57hobwqalU90NkX1nb0qjmZA\n", + "ikO0Mom8jC2AzYH5hNymyR4q3NZ67m8hgAYoDjP7lbsfamZPpWx2d9+51sJkIcUhWpVKeRk7wvN3\n", + "w5ubwsi4SlaGqCmNUBxbuPs8M9uGEOSRxN39+VoLk4UUh2hVsvIykpVskZUhCqLueRzuPi9+/Kq7\n", + "z03+AV+ttSBCtCmpeRmliKmpsBDlZYgWI0847gEp68bVWhAhWhkzG2dm08xsevxfekZS8zLmAweH\n", + "v8c0NCVajcxwXDM7iWBZbF/m51gfuK9owYRoFTL8GDub2Txg7R1g+c9hcHK+jInAUs2uJ1qUSj6O\n", + "DQmVOc8DvskaP8cb7r64PuKtlkU+DtG0pPkxoKcv4xV45yT4x63wPGHaAZU/F4VS9+q47v4a8JqZ\n", + "XQQsdffXoyAbmNme7v7nWgsjRIvSY96MjFn5ps9337+egglRBHl8HJcCbyaW/wH8rBhxhGhJVpQ+\n", + "ZPkyjgYW5JvGQIimJ2+tqncTn98hzK8hhAhMBmaVR0xNISRoTF3TbnkDZBOi5uRRHHPMbIKZDTSz\n", + "tc1sIvBc0YIJUSQVoqCq3sdh2h1w11Pw7mjgVVj1BVhyNLB0ze5yhIu2IU+tqs0Ib1T7xlV3AhPd\n", + "/ZWCZUvKIOe4qBkZUVCzCPd1qrM6a5+j4fxr4BjKakwZ7EWYPXMwwdKQI1zUHdWqkuIQNSIrCgqY\n", + "5u4H5tmnFDF1HryrWflEs9KwGQDN7ANmdqeZ/TUu72xm3621IELUkR5RUJHBefZJ+jI0K5/oRPL4\n", + "OK4Avg28FZefAg4vTCIhimdFxvpKzusVaRFTx8GjmpVPdBp5FMeQZM6Gh7GtVcWJJEThTCb4NJJU\n", + "dF4fDbc8CCuSEVM7w5yrQdMoi44jT1z5q2a22iFoZl8gvGwJ0ZK4++1mBnmc12ZdwIRrQgL4oFdh\n", + "1XhY+ZuNm78iAAATpElEQVRggcvKEB1Jnqiq7YHLgY8CfwfmAEfGKrl1Qc5x0RDKZuWbCXd9DLZd\n", + "BNslWlWMxhKikdTdOR7zNQA2d/f9gE2BD7r73vVUGkLUHbMuzE4luDP2IURMHbIDrCpTGhB85afU\n", + "W0QhGkklH8fx8f/FAO7+ZqlelRBti9mIV+BJ4CfA4N/BvD3CrHy30bdoLCHajko+jqfNbCYwLGX6\n", + "2LpOHStE4URfxjtw3qawznxgPDA1zBP+fTN7k75FYwnRdlSqjnu4mb0PuINQp00+BlEoMTt7AuHN\n", + "fgUwuS6+g4QvYwDd5ssoURqOmgxsT/fscZUSER1HpYmc7nT3/czsjnrOLy46k4ySHtubGYUpj2hl\n", + "ECKmBgMLjoFF18KHU1oPqyoaS4g2ptJETk8D/wL8AjiCYHGsbuzuj9ZDwCiLoqranN7KgJRZI+sR\n", + "7sc36KtlUhYxxZoaUzdkyLEMOFRKQrQSdZ/ICTiLkNw0DPhRyvZ9U9YJ0VcyHc8Z1kiS/JZJipVB\n", + "ssaU2WRCYviQsj2HECwNKQ7R8eTJ4zjT3c+ukzxZMsjiaHMqWRwE6yJtW7d2WQUKEydJtTLKy4WY\n", + "2ZPATilHuMfdx/QihxBNQ8OKHALnmtlRZnZmFGRrMxtVa0FEx1OpDEiWNZIkOyQ2Iy+jQo2peRlH\n", + "UvSUEORTHP9JyBo/Ii6/GdcJUTPiMNNEgoVxT/w/Ia7PCoNNkt6pByvjHmJeBvkq2VZdy0qITiJP\n", + "rao93X1XM3sMwN2XmNnAguUSHUhUEmk+hLQw2CQ9O/XefBm9yKHoKSGyyaM43jKz1XOMm9l7gXcr\n", + "tBeipqR05OsS/B5vktap5/Rl9HZO5AgXIpU8zvEvAYcBuwHXAF8AvuvuvyxevNUyyDkueqcfVoYQ\n", + "7UhDp441sw8B+8XFO939mVwHNxtLmChtAPBzdz8/o90ewAPAYe5+a8p2KQ5RmRpYGUK0Gy0353gc\n", + "3vobsD/wMvAwcHi50ont/khIsLrK3X+dciwpDpGOrAwhMmlkOG5fGQXMcve57r4KuAk4JKXdKcAt\n", + "wKsFyiLakb5FTAkh+kmRimMY8GJi+aW4bjVmNoygTC6Nq4oxf0RLYmbjzGyamU2P/8fFDdXmZQgh\n", + "akivUVVmtqO7P122boy7T+9l1zxK4ELgDHd3C2EzGo4SQHbRw2PMtrgGjkG+DCEaRp5w3F+a2RTg\n", + "h4ThgPOBPYC9etnvZWCrxPJWBKsjyW7ATTHUcihwoJmt8pShBjOblFicnkNxidZmAgmlYWHF8PPg\n", + "MoKlLF+GEGWY2RhgTOHnyRGOuy5BWexOqEp6A3Ceu1fM5TCztQjO8f0IJRweIsU5nmh/FTBVUVUC\n", + "wMymA5+AoD2uJFQejMjKECIHjXSOv01IshpMqBn0XG9KA8Dd3wZOJkwE9TRws7s/Y2bjzWx8P2QW\n", + "ncEKI9QgeYKgNOYDx8Gj8mUI0VjyWBxPALcBZxOGky4DVrr7ocWLt1oGWRwdxjFmJ3wNLh4VCxxO\n", + "AU6DOYvgZJX+ECIfDcvjMLM93P3hsnVHu/u1tRamggxSHJ1CWV7GYlh5Gsy8NvjHVC9KiCpouQTA\n", + "WiLF0SEo+1uImtKIGQCF6Bdl072unuK1fP3acPFKGIGyv4VoCaQ4RCFk5WHEumRfKq0fDlwfoqdK\n", + "kzXJyhCiydFQlSiEClPBLgKGxrwMfkCYzHsxrNwEDpOVIUTtaMVaVaKzyZrudeBwQoGpCwlKYwow\n", + "EmZIaQjRGkhxiKLoMd2rAf8H1krmZRwMHA0shDfqK54Qoq9IcYii6DZv93DgAVhxAaybsDKYGjZr\n", + "Pm8hWgg5x0UhlKZ77YJTzoIR34D3DwrDVwsuh8vHh7L7ms9biBZEznHRg6ww2j4cSHkZQjQQ5XGI\n", + "ulAhjJbcykOz8gnR1sjiEN2oEEa7hDD9b2XrQ1aGEE2DLA5RL7LCaDcmKJR060NWhhAdg6KqRDk9\n", + "wmjLGE6YJ34NmvtbiI5CikOU0y2MNoPBAOuYffr7Zs+sgGeBfVbAUjT3txBtjxSH6EYcgpoITAPe\n", + "zGi2/BizE+6FW74DHxwEXVOArWCphYm/hBBtjHwcogelHAxgF8J0wavpgvm/hxc+DpcNgq75wHhW\n", + "J/JtRxjGUk6GEG2MLA6RxdnA5skVw4GHYP0D4MSSlZHI/i4xuF4CCiEagxSH6EHM5dhx9TJr5v7e\n", + "LVggC46DR48mODXKWF4fKYUQjUKKQ6QxgWg5lFeyvR3mASOvhn+jpxNdNaeE6ADk4xBpDCqfL2M+\n", + "cBK89Vv4F3df4lDyg5yCak4J0VEoc1z0YFezP02G0aPj8hTCUNVSeMTdd2+gaEKIKlDmuKgZmUUM\n", + "Y/b3DBg1gGBlJCKmZgNnNkRgIURTIcXRYWQVMTzGbItr4BhgnwHATLjr4+ALwj2iYSghxGo0VNVh\n", + "lBcxLPkyzoN3B4VgCdWYEqJN0FCVqBWrixgOJ5Sxjb6MLlTJVgiRA4Xjdh4rknkZpbm/j4NHVWNK\n", + "CJEHKY4O42i45UFYUcrLmALsDHOuDnkZQgjRK/JxdApl82UshpWnwcxr4SXk+BaiLSmq75Ti6AQ0\n", + "K58QHUlRfaeGqtoZsy7MTiW4M/YhRExpvgwhRL9QVFW7IitDCFEQsjjaDVkZQoiCkcXRTsjKEELU\n", + "AVkc7UBOK8PMxpnZNDObHv+Pa5TIQojWRRZHq5PTysiqUWVmKBRXCFENhVscZjbWzJ41s5lm9s2U\n", + "7Uea2RNm9qSZ3WdmOxctU1tQvS9jAt2VBnH5lGIFFUK0G4VaHGY2ALgE2B94GXjYzG5z92cSzZ4D\n", + "Pu7ur5nZWOByYK8i5Wp5+ubLGJSxXnOECyGqomiLYxQwy93nuvsq4CbgkGQDd3/A3V+Li38GtixY\n", + "ptalfxFTKzLWa45wIURVFK04hgEvJpZfiuuy+DKg8fY0gpVxD/ATgpVwHTCyivLnk9Ec4UKIGlC0\n", + "czx3PRMz2xc4Htg7Y/ukxOJ0d5/eL8lahbIaU/Rxvgx31xzhQrQ5ZjYGGFP4eYqsVWVmewGT3H1s\n", + "XP4W8K67n1/WbmfgVmCsu5e/FXdurSrlZQgh+kGr1qqaAYwws23NbG3gi0C3N2Uz25qgNL6UpjQ6\n", + "EmV/CyGamEKHqtz9bTM7GbgDGAD8wt2fMbPxcftlwJnARsClcShllbuPKlKupkZWhhCiyVFZ9Wah\n", + "j76MmNg3gRBuuwKYLL+FEAI053h700crQ9ngQohGoFpVjaT/vgxlgwsh6o4sjkZRG1+GssGFEHVH\n", + "Fke9qW3ElLLBhRB1R4qjnpRlf0+FhZvD0wZv9/GIygYXQtQdDVX1gaojmcoipl6Bd06AAVNhM8Lf\n", + "1n1xaCsbXAjRCBSOWyUZkUyzgImpHXaZL+N3MO8o2GJpz0NPc/cDCxBZCNGhtGrmeDuSL5Ipw5dx\n", + "EMxMURrQT4e2ZvcTQtQLDVVVT++RTJUipsy+mrF/nx3ayucQQtQTWRwZVHiDz4pkGrmO2adzREwV\n", + "4dBWPocQom7I4kih0hs8oePfvmwbw2Ho9XALayyS1LyMghzayucQQtQNKY50Mt/g3f3A2PFfAww1\n", + "1oRLDYFBi2HlJnBYpRpTUUnUcghJ+RxCiLqhoap0Kr7Bx47/r8MJSRkXAkOAKcBImFHtJEs1QPkc\n", + "Qoi6IYsjncpv8GZd58Jm/0pQGPOB8cDU0OaN4sXrjvI5hBD1RHkc6edL83HMBiY4zCQRMTUFmAgs\n", + "TbZRhy2EaAJUVr2OpL3Brw2XrIQdCA7wwcCCy+Hy8TAKveULIToIWRz5BNCsfEKIlkOZ441Ac38L\n", + "IUQPNFSVhawMIYRIpaMtjtTscFkZQghRkY61ONIip3aED74Cb24KI+MqWRlCCFFGxzrHzWwa8CmA\n", + "suxvCFbG+AYk8gkhRM1QOG7tGQTB3LgSGB1XToWF/wwjZWUIIUQ6Hevj6IIVEwmOjNGE7O+Dw99j\n", + "UhpCCJFNZ1ocZiPmw5abxsVE9rfqOwkhRC90lo+jbO7vFbD0JJhzdagvpcxvIURbUZSPo3MUh/Iy\n", + "hBAdhjLH+4ryMoQQoqa0t+IIVsY9wE+AwVNh4ebwtMHbDZZMCCFalvZ0jpf5Ml6Bd06AAVNhM8Lf\n", + "1maG/BlCCFE97WdxlFkZv4N5HwxKI8lwQsl0IYQQVdI+iiPDl3EQzFyavsfg+gknhBDtQ3sojjIr\n", + "gxAxNTKWDKk8DawQQoiqaG3FkS9iajIwq2xPJfoJIUQfaV3neM68jLRpYFGinxBC9JlCEwDNbCxw\n", + "ITAA+Lm7n5/SZjJwILAMONbdH0tpsyaJpSxiihpWso2l1icQCiCuACZLwQghWpWWSwA0swHAJcBY\n", + "YEfgcDP7UFmbccBwdx8BnAhc2stBK/ky+itvaX6OTwGfiP8viuubBjMb02gZmgVdizXoWqxB16J4\n", + "ivRxjAJmuftcd18F3AQcUtbmYOAaAHf/M/AeM9ss9WjFZ39PIDGpU6QZw3bHNFqAJmJMowVoIsY0\n", + "WoAmYkyjBWh3ilQcw4AXE8svxXW9tdky43g1tzLKGJSxXmG7QgiRoEjneF7nSfn4W9Z+Rc/Kp7Bd\n", + "IYTIQWHOcTPbC5jk7mPj8reAd5MOcjP7GTDd3W+Ky88Cn3D3hWXHav4SvkII0YS02tSxM4ARZrYt\n", + "MA/4InB4WZvbgJOBm6Ki+Xu50oBivrgQQoi+UZjicPe3zexk4A5COO4v3P0ZMxsft18WcyzGmdks\n", + "4B/AcUXJI4QQoja0xEROQgghmoemKjliZmPN7Fkzm2lm38xoMzluf8LMdq23jPWit2thZkfGa/Ck\n", + "md1nZjs3Qs56kOe+iO32MLO3zexz9ZSvXuR8PsaY2WNm9hczm15nEetGjudjqJlNM7PH47U4tgFi\n", + "1gUzu9LMFprZUxXa1LbfdPem+CMMZ80CtgUGAo8DHyprMw64PX7eE3iw0XI38Fp8FNgwfh7bydci\n", + "0e4u4L+Bzzda7gbdE+8B/gpsGZeHNlruBl6LScC/l64DsBhYq9GyF3Q9RgO7Ak9lbK95v9lMFkdt\n", + "EwZbm16vhbs/4O6vxcU/k53/0urkuS8gJGreArxaT+HqSJ7rcATwa3d/CcDdF9VZxnqR51rMBzaI\n", + "nzcAFrt7W8786e73AhmzRwAF9JvNpDhqnTDYyuS5Fkm+DLRrTa1er4WZDSN0HKWSNe3ouMtzT4wA\n", + "Njazu81shpkdVTfp6kuea3EFMNLM5hEqTkysk2zNSM37zWaqjlvrhMFWJvd3MrN9geOBvYsTp6Hk\n", + "uRYXAme4u1sohdyO4dt5rsNA4CPAfsAQ4AEze9DdZxYqWf3Jcy2+DTzu7mPMbHvgj2a2i7u/UbBs\n", + "zUpN+81mUhwvA1sllrciaMZKbbaM69qNPNeC6BC/Ahjr7pVM1VYmz7XYjZALBGE8+0AzW+XFVRlo\n", + "BHmuw4vAIndfDiw3sz8BuwDtpjjyXIuPAd8HcPfZZjYH+AAhv6zTqHm/2UxDVasTBs1sbULCYPmD\n", + "fxtwNKzOTE9NGGwDer0WZrY1cCvwJXcvn6iqnej1Wrj7du7+fnd/P8HPcVKbKQ3I93z8FtjHzAaY\n", + "2RCCI/TpOstZD/Jci2eB/QHieP4HgOfqKmXzUPN+s2ksDlfC4GryXAvgTGAj4NL4pr3K3Uc1Suai\n", + "yHkt2p6cz8ezZjYNeBJ4F7jC3dtOceS8J34AXGVmTxBekL/htauk3VSY2Y2EqSCGmtmLwFmEYcvC\n", + "+k0lAAohhKiKZhqqEkII0QJIcQghhKgKKQ4hhBBVIcUhhBCiKqQ4hBBCVIUUhxBCiKqQ4hCiBsRy\n", + "5lPj53/upfz7hmZ2Uh/OMcnMTu+PnELUAikOISpgZlU/I+4+1d3Pr9BkI+CrfRBHSVeiKZDiEG1H\n", + "nNDpCTNbx8zWjRP57FjWZts4EdB1Zva0mf3KzAbHbXPN7DwzewQ41MwOMLP7zewRM/ulma0b2401\n", + "s2diu88mjn2smV0cP29mZr+JEwo9bmYfBc4Dto8TLp0f233dzB6Kck9KHOs7ZvY3M7uXUDZDiIbT\n", + "NCVHhKgV7v6wmd0GnAsMBqZklN7YATjO3R8ws18QrIAfEd7sF7n7bmY2FPg1sJ+7L49DUKeZ2QXA\n", + "5cC+sYjezaRbBJOBu939s9F6WQ/4JjDS3XcFMLMDgOHuPiq2+a2ZjQaWEeow7UIoIfEonVmkTzQZ\n", + "UhyiXTmb0MkuJ0zylMaL7v5A/HwdMIGgOABujv/3AnYE7o81wdYG7ie8/c9x99mJ/U9MOce+wJcA\n", + "3P1d4HUz27iszQHAAWb2WFxelzC3xvrAre6+AlgRlWE7lowXLYYUh2hXhhI64AEEq2NZSpukhWBl\n", + "y/9IfP6jux+R3NHMdik7VqUOPU9n/+/ufnnZOSaW7SulIZoC+ThEu3IZ8F3gBiDLUb11LDMNYdrV\n", + "e1Pa/BnYO04GRPSZjCCU7d7WzLaL7Q7POMedwElx3wFmtgHwBsGaKHEHcHzCdzLMzN4L/An4jJkN\n", + "MrP1gYOQg1w0AVIcou0ws6OBle5+E8ERvYeZjUlp+jfga2b2NLAhKVPPuvurwLHAjbFE9/3AB9x9\n", + "JWFo6nfROb4wsZ8nPk8E9jWzJwlDZx9y98XAfWb2lJmd7+5/JCi4B2K7XwLruftjhCGzJwhTAz/U\n", + "z0sjRE1QWXXRkZjZtsBUd9+pwaII0XLI4hCdjN6ahOgDsjiEEEJUhSwOIYQQVSHFIYQQoiqkOIQQ\n", + "QlSFFIcQQoiqkOIQQghRFVIcQgghquL/A4lyzbhX2qMhAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd8VUX6/99PeiUktNBLQk1QqYIFsAG5ILYFrKso6K4l\n", + "+ltXd60hrru6+90m6lpQXHUt4FrWEiKiBCx0BemE0AIJNSGFFFLm98ecm5xcbtpNhcz79Tqv5M6Z\n", + "OzOn3M+Z88wzz4hSCoPBYDC0HbxaugEGg8FgaF6M8BsMBkMbwwi/wWAwtDGM8BsMBkMbwwi/wWAw\n", + "tDGM8BsMBkMbwwh/AxCRchHp14TlXywi25uq/KZGRPaKyGUt3Y6WQEQCReQzETkhIguttKdF5KiI\n", + "ZDRyXY+IyPzGLLOxEZHbROTbFqq7j/Vb9bI+J4nILc1Q71wRebup6/GENiP8lggViEieteWKSGQL\n", + "tmeuiJRY7cgVkR0i8ry9TUqpb5VSg+pYVmu8wZS11Rvrel3ayO1pTn4BdAYilFIzRaQX8BtgkFKq\n", + "m6eFisgEEUm3pymlnlFKzWlYc9sOSimHUqrW30sj3IOtdpJUmxF+9EWYqpQKtbZ2SqlDLdye95RS\n", + "7YBw4BogEljfkg+kVoQCpKUb0QB6AzuVUuXW517AcaXU8RZs01mBiHg3U1Vn+j1YLW1J+N0iIm+K\n", + "yG+s/7tbr4R3W5+jROS4Le9DIpIhIgdE5PaGVm1tKKXKlFJbgZnAUeBBq74qvTsR+Z1Vd66IbBeR\n", + "S0VkMvAIMNN6k/nJyjtLRLZaedNE5E5bOROscn4jIoetY7rNtj9QRP5m9XhOiMi3IhJg7RsjIj+I\n", + "SLaIbBCR8bUc52gR2SIiWSKyQET8bfVMtcrIFpHvRWSolf42Wig/s47pIRH5dz2uk9tyrX3dRORD\n", + "ETkiIrtF5D7bvrkissi6J3JFZLOIjKj2AooMEpGvROS4dT2mW+mJwBO2a3InsAToZn1eUNu5FJEI\n", + "EXlDRA5a5+4jEQkCFtvKyRWRrvY3PhFZLCL3uLRzo4hcXVObqzm+htxDHUTkUxHJEZHVQFQN9ThN\n", + "MXOs480QkQddrst/ReRtEckBbhWRMBF5XSp/j3+QSlOOl4j8VbRZLQ2Y4lJfiojcYfs8x3acW0Rk\n", + "mJt78Ld1uGZ9RWS5Vc4SoGN1x9ziKKXaxAbsAS5zkz4L+NT6/0ZgF/C+9fl24GPr/8nAIWAIEAS8\n", + "C5QD/Txsz1zgbTfpicAq6/8JQLr1/0BgPxBpfe7lrBtIAN5yKccB9LX+HwecBIbZyi2x2uANxFn7\n", + "w6z9LwLfAF3RnYMxgB/QHTgGTLbyXW597ljNMe4Ffra+Fw58B/zB2jcMOAyMQj8Af2ldI1/b9brU\n", + "g+tUbbnWsawHHgd8gL5AGjDRdk0KrWstwJ+AldUcWzCQDtxqlXse+qE92N01AcY7r6X1ubpz2cH6\n", + "/AXwHhBmtfVid+W41gXcAnxn2zcEyLaOv8Y2uznGhtxD71tbIBADHABWVFNPH/Rv6R0rfyxwBOv3\n", + "atVxCphmfQ4APgZesvJ3AlYDd1r7fwVso/K+WwaUAV7W/mXA7db/0622jbA+RwG9qrkHa7tmK4G/\n", + "Wuf6YiAXl99la9lavAHNdqBahPKsH0E28JHtQmehf+gvAXdSKbZvAg9Y/y8A/mQrrz9NI/y/QpsI\n", + "nD8uZ1ui0YJ2GZY41laWS56PgXhbuQXOH4KVdhgYjRaEAmComzJ+53ojA8nAL6upc4/zx2h9jgN2\n", + "Wf+/BDzlkn87lQLn+qOr63WqrtxxwPnAPpd9jwALbOdxiW3fEKCgmmObiYuQAa8AT7q7JvZrWdu5\n", + "RD9wy7BE1CVPlXJc6wJCgXygp/X5j8BrdWlzHe7Zut5D3mihHmDb90fg22rK7YP+Ldnz/9nW7rlA\n", + "im1fF6AICLCl3QB8Y/3/jct9d4VVvjvh/xK4r4b7134P1nTNeqEfhIG2fe9Qy++ypba2ZOpRwFVK\n", + "qXBruxZAKZWG7qmch35Kfw5kiMgAtFgst77fFd1bcrK/uopEe+M4B5E31bOd3YHT7MBKqV3AA+gf\n", + "wWEReU9EutbQhjgRWWW90meje28dbFmOq0r7M+gfcQj69TQA3RN2pTcw3XrNzbbKvRA9NlEdrufM\n", + "ObDZG3jQpawetv1VqMd1qq7crta+bi77HkEPwjo57HJOApwmBDfn4nyXsm5Ei1JdqOlc9gSylFI5\n", + "dSyrAqVUHvpt4QYr6Xq0ANW7zQ24hzqh31Lq9HuxUd29ArpX7qQ3uledaTuOl616oR6/VfS94e5e\n", + "d0dN16wbkK2UKrTl31fHcpsdn5ZuQCthOfqVz1cplSEiy4Hb0K+JG6w8meinupNeVINS6lt0z6sm\n", + "lGuCJTBXou3B7sp9D3hPRELRPbU/o3sbVcoSbUf/ELgZ+J9SqkxEPqZuA1XH0L2paLSZxs5+dA/m\n", + "ztO+VT2u5+ygraw/KqX+VM33Tjs/1O06VVuuiIwB9iilBtSjzurYDyxXSk30sKxqz6X1QI8QkTA3\n", + "4u+uXNe094AE0e6TAUqpZXVss70NDbmHjgKl6Ou9w0qr9vdiwzX/Qds++zGmA8VoE4v9weOkzr9V\n", + "q6zoava5ntearllvIFxEgpRSBVZyb/SbW6ujLfX4a2I5cC+wwvqcYn3+VlnvbMAi4DYRGSx6kC2h\n", + "gXVW/IBExEdEBqN/sJ2Bv5+WWWSA6MFcf/RNX0TlTXUI6CMizjL9rO0YUC4icUCtP3YA64e0APi7\n", + "6IFDbxEZKyJ+wH+AK0VkopUeYA3yda/hGO8RPRgbATwGLLT2zQd+JSKjRRMsIlNEJMTaf5jTBwTr\n", + "cp1qKncNkCciD4sewPYWkVgRGWlrb135HBggIjeLiK+1jRIRp/ttbWVVey6VUpnoQdx/iUh7q+xx\n", + "tvPSQUTa2cpyrSsJLTqJaDt7XdtspyH3UBnwETDXOs9D0OMKtT0MH7fyx6Af6AvdZbLOzxL0PRoq\n", + "ejA3ynaOFgHx1n0XDvy+hjpfA34rIsOt+yVatOstnH4P1nTN9gHrgETrvF4ETK3leFsMI/yaFehX\n", + "VKegfI8eNHJ+RimVDPwTbT/cCXxNw/x0FZbXB3AC+B+6pzRCVXUzddbhDzxj5clEm2QesfZ9YP09\n", + "LiLrrNf9ePQPIAv92v8/N/VXx2+BTcBatNnpGbR99ABwFfAoevBtP9oDqbr7SKHNDEvQr9OpwNMA\n", + "Sqn1wBzgBauNqei3FyfPoIUgWyxvHup2naot13qoTUWbi3ajz+WrgFNElZvz4vY8KaXy0UJ4Pbpn\n", + "mmm12a8uZdXhXN6CthlvRwtQvPW97egOwm7R3j5dXetSSp1CC+9laCeEurbZfnwNvYfuRV+rQ+iO\n", + "xIIa8jpZjh60Xwr8n1Jqqa0e17p+abV7q9W+D6g0Oc5H2+43osX4w+raqpT6L3r84V30YOxH6DdI\n", + "cLkH63DNbkSPI2UBT6LHnlolUtlR8rAA7Zo2BTiilBpaTZ556IG9AuA2pdRPDarUYDCcNYhIH/SD\n", + "2Kca042hkWmMHv8baPc3t4iIA4hWSvVHe2K81Ah1GgwGg8FDGiz81kBmdg1ZpmG98iilVgPtRaSu\n", + "ng8Gg6Ft0DDTg6FeNIeNvztVXasOoF2oDAaDAaXUXqWUtzHzNB/NNbjr6nVgnu4Gg8HQQjSHH/9B\n", + "9IQUJz2o6p8LgIiYh4HBYDB4gFKqXsHkmkP4P0W7dr1vTaA5oZQ67C5jfRvfEojIXKXU3JZuR02c\n", + "CW0E087GxrSzcTmD2lnvTnODhV9E3kMHjuooOpJkAno6NUqpV5RSSSLiEJFd6Cn3sxpap8FgMBg8\n", + "p8HCr5S6oQ557m1oPQaDwWBoHMzM3fqT0tINqAMpLd2AOpLS0g2oIykt3YA6ktLSDagjKS3dgDqS\n", + "0tINaCoaPHO3sRARdSbY+A0Gg6E14Yl2mh6/wWAwtDGM8BsMBkMbwwi/wWAwtDHMQiytHJFYB/SM\n", + "h9AAyCuC9HlKbU5q6XYZDIYzFyP8rYyqQn8oBEZ3gwW2JRbnRInE0lDxjxVx9IT4UAjIg6J0mLdZ\n", + "KfNAMRjaAEb4WxFa9Mc+B/OtpeAeB56GsP0Qdx8s/BjU/Ghw3IdeZckjYkUcY+G5+RBd4gW+5TAH\n", + "omJFMOJvMJz9GBt/q6JnPMyPJuQQeBdT8VzO6QmhGTDkv1a+kMAG1QLx8yH640Fw/hwoE5gP0b3g\n", + "Pte8IrEOkbhkkYk/i8QdFbn2Z/051tGQNhgMhpbD9PhbFaEBAEy+H/ZcCutLrXSBr5+BKXfDtmug\n", + "PL+wQbVAwD/HwP9dAJ+9B97WVI4QvYwhoN8KvAh7KhDHkEK5IxD1DchToLw7AkMby+RkMBiaH9Pj\n", + "b0X4cCyUgBMQnQxbp6OXR31M79x9OeT0wmf4BadG80P3OJHkWL26Wb2QRPH+7lr6zB8OP7wOwzMr\n", + "9+VDIVSagrrSf0Rh1G2B9EwE+QM83An88q3c86Oh12lvCAaDofVjhL+VECviGM+6yE5DrtAiXxgB\n", + "jAM2ZcHE9d5M2xTxdWZR2Lj1fik+OUMXw6Sx8Fx9xF8SJQj44Eg/coa/we7eOZX7ZkPafngeKk1B\n", + "m648CFPvgiPngvKCE32g0xZbiQ0zORkMhpbBCH8roSfELyWvW+dzf+S8nzcynglMYhRDWbFbqSUj\n", + "r+CzjOMHtwaMP6B4YbT+TnV2eXdIonQCvgEKykIY/VMh9zkgeQYsd0DyKoh3DuyGQgBA95/bwb+2\n", + "QFGYLuTwUOiyyVZqw0xOBoOhZTA2/lZArIijD4xOAIZ/WM6teWlcRhoAM3Qo6wox/vNSyPGv/K7d\n", + "Lm+nilto5AEvbpdo/NQC4AmVoBQJJFGNZ1AeFAHM3XeQ+5lFGvcAj8GRodBZC78/NxYEsWFVo5wA\n", + "g8HQrBjhb2FsrpXhAORqq74v2tDjtLs7xTg6q+r3nfvtVHEL7fk9zLwOlo45wprcH5TaXGtUvnSY\n", + "Nwei5pMfDUk8z27WUlSiDp/yVv2PeJ3PD9zH9qC3KX8yTM65OZfy+80gr8Fw5mBMPS2M054OlT35\n", + "PwJfUdXubonxLvt37ftdStVuoYM+huuvgY/fhDU/dK7PYOw+yL0Osl4iP7uAdetGsHnT5iM7vXw6\n", + "n2Ax65hCPu9T4DWAbtEw+jXj3mkwnDmYHn8L4zTh7G0PF94Oe/+pJ1RthawdNrv7ZqWSYkVwwH0h\n", + "EJgPhfvhefcTriy30PxIeHsJHDrPSq99MNY+ucuZNgfa74PCrnlw7mE46Qchp/S+YArRM4sbNqms\n", + "KTDhLgwG9xjhb2GcJpw+J6BfNnw+AK7ZDoWwxlXUrc91EK68IgAOjHVJr30w1vkGUuQDfmXgpfQg\n", + "8mTIFWDpW1Xzn9TPLVqbh8/ps6DBmnswCnqONQ8DQ1vGmHpaGLsJ58718OqImkw4dS51HszZVTVt\n", + "dhrsr7VM5xvIRbfDeluEINoRMrMdVcYHZhDFduKtT63Nw8cyd/kshk5XA3MBFQ2jHoHFk2DReP13\n", + "7HPGTGVoa5gefwtjN+EEbCN4qYMxkUN4On2L5zFzlNqcJBKLNr+EBGpR3v98XXq2zjeQy3bDZwNh\n", + "VIZOD/PBa0W0V/aow7QPzugsJ0vOZTv3kc8UYFZmXR4qzUtoAKyA8q/h6CdW2uPA0/502QiDP4KU\n", + "RPQbQeszUxkMTYkR/laA3YQjifLcgRlENbRMS+TrLWbpMO8OGDdrJ4H3OuCpZfCADxw4D0r6lLPu\n", + "QL/rKen+EPj0gwXAc3sg48nWZi7x4VhoKUug/K9wxUOw5zLYZd3u57wDZb623K3LTGUwNDVG+Fsf\n", + "rwJLJFESVYIqrTV3I7NZqaTzRQ78Pj24/6bQYsLDRlDoV8a0Y9sJTclfnVyWtghY1Nztqi+D+VGl\n", + "0oGioe/C4I/h28eA7wAFMQvh3c9tuVubmcpgaFqM8LcyVILaIomyB5gC/K+5648VcXQmtMN+FUd5\n", + "agAnBoyGtffw+dHrywJY0eAJW03taeNcZ2AgRB/pvI2iySnw1lIoag9MhB63QUkwHIm1vlG3sQ+D\n", + "4WzCCH/r5FXgTlpA+HtCfBkDI9JYCDv/C8Nfg7X3UMj73oU4xnhabpVon76vBVISZO1pvCifdlfU\n", + "HH8YMnMrQUtGUXD4XCvHOGToL8tUKodhZmp9xj4MhrMJ49XTOvkAGCOJ0qu5Kw6FgGKC9YddkyDw\n", + "OEiZtdczW7hTkCOJHlF47uRA7hsAAdnW3saL8ul0RVXArKvhqt2KRRu30o9RjGcCXWR0gTpvfwEX\n", + "7LtUqUUTlEqKM6JvaIsY4W+FqARVCLwDzG7uuvOgKECHB4JToTB/LShva69ntvCeEP+SF9EbfrEf\n", + "LvwLvPMFFIXbcjTO4KrTFXV/mF5c5h/JMIV8hrMuJ4jlyaWXrX0Kf5WmEtSOxqjPYDhTMcLfBMSK\n", + "OOJEkmeIpHgaNx9t7rlDEqVZzXHpMK+MHRlRzKySLtzqsctmKAT4lEPk9lB4dR1UmF6cNM7gqtMV\n", + "tXcO/O998LdeVE7CyiSl4o5fRB9gYWPUZTCcyRjhbyScSxT6yLSfjzP6g3sJmbQIxnsSNx9AJajN\n", + "wF6gWScXbVYq6RB5c4L4cl0HxmaFckWWD5euV6yf7alZxCnIz2w+QlTprS57G29wtYZ4RqsmecuX\n", + "voXcceGLxHn4IDYYzhrM4G4jYA8PUAYcAuK9f8EpSeaa0pPMh2iHjptfP+Hc0m4VoV6viczY2pzh\n", + "BeoeGqJunB7tcxQ/0q4oG7WllCONNgdgCzHsoHPuQryzfMmX7mxLKyfn87Fw8/S+RJ84Dt8dZdwc\n", + "6ObJwvIm9o/hrEEp1So23ZSWb4dnbZ+cDEoR+67iyjmKu4YpHgtUw6P7KwVKgZoOKfUrM8aB7627\n", + "eDhCEbbPKmZ2KsQ4Wvp4PdliwBEHi6dDShwsjoFGPQ6IcejzU3HKFcxOvQSf9QrUrKtQfx9TuTMO\n", + "FntcvpS2qusRA47JkDwdUiZDcmOfW7O17s0T7WzxRjek8a1lg+kpoBRj/qEY9YKix0qFT4Eaz3jl\n", + "udBYD5O4exUTEmxiFlevctrKBpOTkVLF8FdtwqzU5YQeV6DmXIlKb1dxEj14EE9Kps8yxXXXK24b\n", + "32quRww4ZkOqrUFqNqQa8W87myfaaWz8jYIVDXPVA7D2HjgwBkoDcXrHeBZ0zQqtvP5O8C62pZvw\n", + "Am7xDgrk2ltg6HvgU3m+8vEVgFc/gx652NJPX8DGHf07yvXjOsj2Cd2WXDGybCohm9rBwo9sOVr2\n", + "ejhdWNd1g3eG6rT6LMlpaJsY4W8UTo+G6c+NBdmkbnJdz7buWA+TI0Ph62ds6Sa8gCuSKP7csmwQ\n", + "/jnaVbRichhso3ta3RewqShPJFHGh0+TZSPKeOfhrOCBfhkjvILTRxK8cxsBhQtsuVv2eoRCQK4/\n", + "XP8LHUbbSXVLchoMYAZ3GwV30TCL2f/8anWiAQN/6fNgTlTVePImvIArkihBwIe0z0/l+S65lAVW\n", + "OV85lCeshDotYCOJ0hH4JXrWdPnQ75FbToR43XBlJ/LSfgdbfwGAP7OAFcBbLX49cqHo11Pg0j0w\n", + "fWtlel3faAxtEyP8jYSn0TBrKs/T0MptBUmUUOAzIJ32JVdStmZiDefL7XmTRBHgYuAudHykT9ET\n", + "576PzGLZPAYNyls7H26eBEVhsPsKinkDiDsG6fGeXo/G8hD6YQZbpQuXZL6MnzOt4es5GM52xBoc\n", + "aHFERCmlpKXbYTgzkERpDywGNgG/Ugmq3F0+Z9C2UAjIg6J0mLdZqSRJlA5U9u4V8ArwtkpQFcvZ\n", + "x4kkFzJ+0nJSoNd3cPnv4I1vQXkBM5YrtWiCR213vzrYLlhZr0XrJVEGAt91/YInz1vLtNqX5DSc\n", + "jXiinUb4DWcckiidgCXAcuD/qQT3N7Hr+sEKmNKPA0unkloSwXD028IrwPfuyogVcRxn9AeHWK0H\n", + "DaTcEn0AR7JSSXEetV/ikiFpEu336TKz+9W7TEmUAGAl8IpKUC970g7D2YEn2mlMPYYzCkmUrsBS\n", + "4BPg8epEHyo9XrIC4a1z9bKWCnr03Eze7nH0s/fu3bFZqaQI6fYXf258uJh3gypFv35jLZY5qTcw\n", + "AhjBHRGj6dAJyvzgu9/DaufylfXyEPoLkIZ+cBkM9cIIv6FVYzfVZHYAr7voX+7HiypB/am274ZC\n", + "gAKuuAWGHIVXPoOL9sNMOJL2dc2i7yRLZSSKxK51jh34cCxkMD8yiJyH40TinaYjZ35L5HsBI3EK\n", + "vd5OAeuBdazrvoe0L8PJ7+pSW908hCRRpgHTgGE1PfgMhuowwm9otdhNNbsi4PJbYPgKjhV+xwYS\n", + "av9+HhQJsPo18LGNALjzeKluLAAqB+7dmY6uD2dg+NXyzolheFEp8iXAOrTQvwCsVwkqw1mXzI1d\n", + "C08+54nHliRKD2A+cI1KUNm15TcY3GFs/IZWS5xI8mKYtLUTTLwFnlwOd64HByQnKVWrLdxVqAFu\n", + "RTL/R2xGDoPynd40MWzBNd8c2PUhXf+TzbljnZ43Q1nZ8WdyRvx9LCyJgnXdwLcMirI5eqIX/0IL\n", + "fRWRrw49wNurXh5bkijewDfAEpWg/lhbHYa2gbHxG84qnPH1/3QxPLsUbv5Zp9d1ctJmpZJiRSp8\n", + "+I/hE7KO8V3zWDqiMtecqM7syJ1PaXRGKOT5QVQ2XF0eEv02Ex6Gdytmg+3ixsIv+IzI/HzuWQMj\n", + "MqFbHsyArYuUmuvMVxdXTQ/dfx8HyoBn6/k9g6EKpsdvaLU4e/wKsN8Yde3xu6K9aRZPImYhFHSC\n", + "PZcCcDntsr4iL2JhDDx6GWSGgvfxQPKPXg1HYnQYjqL2AExiFMmsq1LuWMKOraLHrdbcCzeumtdm\n", + "QP4haJ/nqc++JMo49FoCI+ryRmFoO5gev+GsojKcc6UJpmGTk6z4R+c/Dyser0h1xvOZuUVvBb5w\n", + "ccfB/Nh5MnTaAuXeFXl/IrQQ2xvHDKLYzHMd4ZPnRGIhvMNDRI2IZtBk2DkF1pwLDO6G72PdPF1n\n", + "2Jpz8B/gDiP6hsag1Qp/TYNthraBq6mm4ZOT8ooIOgqdN8GeSypSdTyfrPbOB0xQCWRk+hSQ+csg\n", + "1xKyYOtYwnr7c27Hkx3S2Z4/l/zQKBgUFc05779L2I5gdvSEH2frNYv5M3glwu2j4It/wYGx6LcB\n", + "R43rM1Sai0ICuC18MP6F36uXC839b2gUWqXwuxuUmwNRniyeYTizadxFYdLnMeSa89h9eRfK/K00\n", + "9/F8iklfBXNudvW8KeXIk6u8L/sdN+aOI0JB+VPgWwDbr4ZlQ/eRGnKI0v9MrPyOD4x+Hgo66qit\n", + "FYQEVjcWUMVcNOpF8NsNr59zjrwS6zAhOwyNQasUfufEm3w/OBQC0Vl4voqVwYDuTEyG+JUDfQJP\n", + "beuVd4ppe8soPVhTPB+7/z6SV8zwjd9zZebVlG69iPIgWHMPbJ0OGSPQoxCODO2SOadfxQOjXRaM\n", + "ewFe/4GqIxUnQtyEbYjS8Zl6xsP8aLpshAlz9XdL+0fV9pZgMNSVBgu/iEwG/gl4A68ppf7ssn8C\n", + "8D9gt5X0oVLq6ZrKdHpzrO0GT42HZW/qdBNq1uAJzjfIF7yJ7tyzlH0f7+ZRdgeutMYK4kSS3ZoU\n", + "5275Aba0B64CJgFBQBDFXtv55y/8KflzVGUt2g9fqc1J3SRiVG8+uDcY8V0dVxBSsKa/lB8f4FU1\n", + "bxHIK9F03gjtDkKqg0oTUIgei+i3FL78B2T1t75n1mIwNA4NEn4R8UZPULkcOAisFZFPlVLbXLIu\n", + "V0pNq2u5zsW5T/pBcEllugk1a/AE5xvkl30g9gh0KtBvkOMgcSC0t5sUrw9jQOhNsjh/AP2BMeh4\n", + "QJ8ADwB/BToTXDaNknWXuIsEGivimAI3z4eOX/SHBzrDOR/u5QCjCCCYLf6FRbnnpe4qGeQzksiO\n", + "cLITbL/GEn7Q5VlrMax80OVIzFoMhsahoT3+0cAupdReABF5H907chX+erkaOb05LvclOsgSfhNq\n", + "1uApzjdI33KIX12Z3k57DIUfaKdj+XwyCHZF0DcwnavzIR64ViWofGvi1JtAF2CaSlCFJOB27MH5\n", + "kCnwhXsdeuWvK0pP4ohcxw+3QfdcAnyPMvjQ1sEH+PDrDu7DNqQ/b9ZiMDQlDRX+7kC67fMB4HyX\n", + "PAq4QEQ2ot8KfquU2koNOL05vg3j2TwvOjlggwk1a/AU5xvkpXuqpvvre5PMEL09sxTG7YObykld\n", + "pNSHUDFb9t9AV+BKlaAKaqrL+ZBJ6g9jDsAVloGzbw68OU+/bcyAPR/g9ZfqwjaYtRgMTU1Dhb8u\n", + "s79+BHoqpQpEJA792jzAXUYRmWv7mMJEXgUGH1Tqnga209CGqW4+QB7kABGjMmCUzTveaVK0RP8N\n", + "oBt1EH2ofMj8Yitcvb0yPaIQOtnKr03c3c3src3F2bhAtw2scdMJDSmjocJ/EOhp+9wT3euvQCmV\n", + "Z/t/sYj8S0QilDo9OqKyTXsHkEQZDdaK5QaDh1Q3HwBgjovbsNOkaIn+AqAHMLUuog9VHzLOwHCP\n", + "ApNdyof6hW2wuzg7ZzLbXZzt+8sEvJVxgT5bUUqlACnOzyJSh5CFVWmo8K8D+otIHyADmAncYM8g\n", + "Il2AI0opJSKj0WEi6hQSFwgG6vSDMxhqorr5AO4eCFvm8iXwOjq8cp1F31mPvcwTEFIEahecfLYB\n", + "E9C6e3H/tf2IvvFcKBNY+N+qLs7OsYW13eA3k+DbN4wLtKF6GiT8SqlSEbkX+BLtzvm6UmqbiNxl\n", + "7X8F+AXwaxEpRYv49fWoIhg43JA2Ggw14fpAsHr6r6EXTpmqElS93zgba9KZFdt/GHCL32+5JCcL\n", + "btkIM7ZU5nG6ODvHFh6/FG7adPp+g8FOg/34lVKL0Wuf2tNesf3/IvCih8UHYUw9hmZCEsULHeu+\n", + "LzDFE9FvpHb0BG4CbkEL939GvMWqHw5xsWvefCgUiXWEMSbmvD6F7IzYzq9/8sH5szEu0AZ3eNWe\n", + "pWUQiXWwo9NVJJ8bLxKXrKexGwxNgyX6rwFRNLHoi8Q69D09I8V5b0uitJNEuV0SZRmwAf3wuQuI\n", + "UgnqydygnbkiAAAgAElEQVRDPDsHdtnLmQ1pGwhfBWOfy+GHjhsvC6Iw5TV+WzaFLwgxLtCGammV\n", + "IRsqYpWUZXcjdyYwfWB9IxoaDDVh94DJFYr87kFOdSSAZhD9ilANXiUQtQRG3H0hZQjefIUW6i9U\n", + "giq2f6+6AepMztfhHQZ8Dn55sOkG0riZmxh7rAer4s3ArsEtSqlWsemmOP+fnAxKcVOcov/nCpS1\n", + "xS1u6Xaa7czfYsAxG1IVqDJB3TEN1Wk2hdERXNvUdVfc22H7FL/trLhjrGLkvxQhlyz1rLzpKaAU\n", + "3dYoei+3/Vamp7T0eTZb82x27azr1ip7/BVx00sCoTjMlm5ilRgajtMDplzgrqmwswPsfouAGaeY\n", + "A3zUtLVb93ZOT3h9JWT3s9KXefhbtMI7ZIwCIIQvGMQ82rNyaJxIsvHlN7ijldr4rZt50Yew/yJb\n", + "uolVYmg4Tg+YrZ1gX3tIegdCTjWXB4x1byM20QfP7+30eTBnF2jRd3Ana1jCV+RFLIZJI5HXYkXM\n", + "+JihCq1U+Ctv5kpMrBJD4+CcXRt7BL58W4s+NJcHTOPe23rMa+X94EiO4ea8hWRwzfXwXS+9/9+o\n", + "rp3xeaqhrTacXbRKU4+JVWJoSuyza53RA5vLA6Yp7m3nDOArvEKzUHDbBvjlNbDxJQg9Bd4E9m28\n", + "IzCcDZjF1g1tklgRR69GW9KxZbBcUIeh1wqYNPJNLl67R0fCvWMaHFA+8Nl5/EB4aT7eX3uyyLuh\n", + "9eOJdhrhNxjOICRRugAT0WI/EchCz5xPDvvDkKcnlRUPX0gaH/gFc+OvoTT5XdjhXApjzi5Yeb8R\n", + "/7MLI/wGw1mGJIofcAE6ztsk9MSub4Bk4EuVoPZV5JVYRyiR8wfi0y2NcrJ7PQnTp8PLG+FkZyuX\n", + "I1mppLjmPg5D02GE32A4C5BEiaJS6McDO9C9+i+B1SpBlVT7XYl1QK/7IHgsfBDG2L/Dnkvh0HlW\n", + "juuyYcfNptd/9mCE32BoxVQXL18SJRS4BMtWjw5O6BT6r1SCOlbfukTikmHxpNP3PAEcqrPJRz9I\n", + "esZDaEAY20OGs006Uppn4v23HjzRzlbp1WMwnGnYBVL76lcdSLXHyy8X2NgF7hjESJ+H5CAh9APW\n", + "oIX+OuBnldDQHln6vNOWb/R5ANrFArdGc+qu30iifKkSVFnNx6TDS4TwBZO4n4WUVuw38f7PXEyP\n", + "32BoIFXi71RQdSA1TiR5MUy6ewp8NBjaFcOkXbDiIOt/vpbxTREfSLerz9swMoLAIzBmE/QvhIBs\n", + "CN5fin+pAPnoAeJsa6v8//s+13D80QEUhTOg6A+8X/Az4UXQPVevXwzggOQkpcyYQQtievwGQ4vQ\n", + "UwdK67QVjg5Gr481P1r76uu4/M7ZwlN3wkPfQ98T+pszIH/jxqYJCqfnDMSthbmTKASWWRsAjqX4\n", + "7n0Rv8gHCPYN8Q44GtY9aEdox5CCrjl+XiEHAjt4F/v4dGTQJ9D1R47kHWaWF2QHwCfvw7BDuhQT\n", + "7//MxAi/wdBgQgIY80+46Fl4dR3k9nCmV4iic7awI7XqNxtjtnDNZiY3Jh89U3gVJRf+g5L50ZyE\n", + "MlZwlP+jHQX0Ixef3ofYMekE+O2ClESi13/AWpaeVreJ939mYoTfYPAQkVgH0uMBOpaP5cCn8K/n\n", + "oaCHLUdl/J3qFnxv6GzhasxMFSHMnTOFfbj0qUC8+/mRr7qx7cRWGTatbMDUaC68EN7/f1DwE4Xe\n", + "H7K5zJfNCAFZMwn/ci3Z+68DdSfb6c5M9rCQtIpaTLz/Mxdj4zcYPEAk1oHX+S9S/nqfytTH0E45\n", + "49C96lXxrgO8jT1buMJ7J/Z9yBgJWU79r/TXtw8sl3rBohj4dU9/NeBnP/EpjmRDDz+KBgyAvl9r\n", + "n/8T+pCCuYyTJABfAdtzwtiRann15J+ps53rSnUeWC3dLncYG7/B0ES4CoFX4MV9yote7UP3NXBw\n", + "tJXrj8DULHh2Dex/PoYtxIkkO78DzGv8gVArzHPXHyHyJ1j6Z51KyfkzRFJOQGhHiHpZCHttGDxz\n", + "EfinQ6+8U1I2pZi09nmEpnWiaNvv4POXbRO9oIBO1n9/ABwrT6if28Qgrv1B6Uw72zyYjPAbDG6w\n", + "C/0JCB0AkR9Bt0IfeOgKKG+fCj26Qm53+PdyKG5nfTNok1KL4jwRj9pcQt1jhXn+aRbceil880co\n", + "9+ECToQv0pO/mBUIc6Nh4QVwPAj8I+H2XMXeY9A1FzYu7w1HbzmtZEV/dG//rTYVGbdTCA/OCif6\n", + "jQ4QVAIzt8B8iHZAxWD9mY4RfoPBBVfRzgqE2/rDxYNgzQDwKYe+y3zZs3hlhVmkEm3Xdy728skg\n", + "+McYGHgcBh8jes1JnpJE2QnsVQmqwim+Nlt99a21Bm+PzY/mRB+ITiZ851uEsp27h8DGMbCpC3Td\n", + "Aw+u1IPLr+fCXPR6BLsiYEm77bySdxOlRe/Yyn0UPXn4uayuLHv7XLLjZ4g83NrNHnVFEsUfvb7y\n", + "QJdtgHc87R84CgOPwaV7Kr9zNnkwGeE3GFxwivZ/h8BLI2FdNy0AJekwwQ8++AC+Lc5mOo8WFvKu\n", + "TQwq4+o73TfH74XQYtjREXZ0gIOD6QcsBbpIouwBtgM7uGDgVPbfHs3xLCiMsMqr6hLqjiqDtxuz\n", + "hgaed4vfgp2lTCGfu/bA9Cz4+hjcWapXbgcqpmANOaq3aeTzA9v4iScAb6AMLfrj8GHunilk33wm\n", + "mj0kUQToyuniPhDoDuwDdqJDYvwAvAHsuPxPvJmsB2uqcDZ5MBnhNxhccIp2QCnEr4YrdutX/ieA\n", + "xJXgpWAK+USTtGUTjmPu4uo73TfDi+CyPXoDSIXVSUrFSaIEAv1xClHv3E7ExEPHHfDOF7D/Yqs1\n", + "tS83qtTmpDiR+Pc34df7chgdBBTAK4XwRKE+mFCokPXvIOd2KFigRRGAcHZlCuko/t21suTZaYP5\n", + "kfkQfSgE7nXA376E+Tmty+whiRKC/Vzaeu9AAVrYnQK/zPq7u7qYR7FzpUk8sFoTRvgNBhecoj11\n", + "5+n7vCwnuNmQVk5OglJJbsWvNvdNlaAKgZ+tDZG4i3RsHQVi97Sr25KMoRAQVgz/SIZT3pXp3mij\n", + "zUwsXyNIOwbxxwCHzcPoMHnPK9bhukDMIHIeBuhYACMzYOSd8OelEPxT85o9JFG8gd5oMXcV+Ahg\n", + "F5UCnww8B+xUCSq7vnVtViopVqTK+TnbPJiMO6fB4IK7gdlZkJkGByPhZF2FoD7um+5t/Ke7hFaH\n", + "MySEa/pkyCmA1Pq0u6ZyN3XWq3vtLeHoieW9fkPakJvrNxhdM5IoEVT21u3iHgUcRYu7vQe/A9iv\n", + "ElR5Q+o9kzHROQ2GRqIlVuiqDKlc/yUZ3T2sZkPaKohvSLvdPgS9SXvn2oADJX3VRSS94c3m69Fh\n", + "Kuq20Iu1xoBzYNVV4P2pFHS7wKc2RTyjswEj/AZDG6apHlau5a6i66pszr0X3yEdiVwPHXvBT29Z\n", + "ufXEMWtgNZKq9nbn/z2BdNz33g81PDJp28IIv8FgqBXP5gvYv2szSfkWQMdfQ0Rf6OgF3V8+woDM\n", + "/WihP4X73nuaSlCnmuTg2iBm5q7BYKgRz+cLOLEikV57E/T+FoKOQnYUHFsDx6+BPe0OMyAzHtih\n", + "ElRWkx2IoUEY4TcY2hSWcPvnQEQaZA6nLvMFKrFCRKyOh2V/gBO9QXmjp4QdSAOf36sf1Mqma7+h\n", + "MTDCbzA0Aw0xrzQE1xhDYYzultMuHW5ywM4rLeGHmuYLuLQ9BlbAwXEuuVYfg/Q6eSAZWh4j/AZD\n", + "E1NhXvF6KZpy50+uPuYVz3B65LwK0U4D8I3eG4o+u2QY+RsehZX/z5bb/XyBakxDJYCvnhkA2u3U\n", + "iP6ZhBncNRiaEEkU4Z3hKxlw/vkM+QBeWw3Z/ay9laGTmwKnD/6DE/WkridWQOeTMDq4ffHak9n+\n", + "lTmrny9QEfbZLx9KAi2zDkDcMQjdUl+3U0PjYwZ3DYYWwF3s9i1z2QvcBNyIY3tnfrwW5q+BE31t\n", + "3zzdvNKYJiFn6InffwdPj4PB98D9q6HDqtxdMK4Q2kWBv4K8nBpK0Tb9CXMhJBM+eRP91hK6RalF\n", + "Ezxpl6Hl8WrpBhgMZzJOc8pimPSPUMZfPpZJGb/mIylhBXoy0rU8d/G3fPuYi+iDq3ml0qyyeBIs\n", + "Gq//jn1Op9cfZ+iJTgXwXDKsna8Dxa2cUj5wVLsN54wnN3wk+REh3D+8+nqssM/f/AECs+AX14P3\n", + "KTqQPjROJDlWxKO2GVoYpVSr2HRTWr4dZjNbfbbJkKxApfRGhf8Odfs01Nd9UZO8WOzMAzEOmJ0K\n", + "SlVud+yCGIe9LJicDEoRkqFw3K0IyLbyxi2urR26jsnJMD1F/41xDPJj2k3B5NoqVVdDxvXevsX2\n", + "tBlEqRA+d1tPlbZ7Fymun6aCbuiqPvIJVgrUbEiNAUdDzqHZGrZ5op3G1GMwNACnOeWCdMj4m47o\n", + "CfCyLXa7M3SyawC00004llnlVCghR/YyqHMkwUcGUFx08PxYEUe94vzI7P7bpxzIyyzP2TL5U/La\n", + "KfzyobAUOn9cVtL1WBAUe0O3PFhIGqN4nnW0O830ZG97aFnJ+WMWZYUXXneU12eUcvW7Z98CJW0F\n", + "I/wGQwNwmlN8y/XmxDV2uyXydVpNK+TUchzrdrCQYmATQPjt8Po4kYORkH/6YiiWb75vAYx+HlY+\n", + "COWv9eOH7ftyfv39iORPVJmzhhkiKQBfRsFvJ0KuP/TPgoPH10NRYA9JlFuBVPQs2+MqQSln22eI\n", + "pCwqZ3zph7Cmu47O8wUhrCb2fJEZKc3ppmpoGEb4DYYGUFv45epwNyAMMfNgTtQg9kcvJA0FfDII\n", + "xu+DBYVE3hNA5Iva4u6yGEpoAN7FMPNayI8EZQ3dHe66VyVUij5UPqhu2qS3XH9IjYAZHUuKj406\n", + "uRK4ArgbHXJBSaKkctwvn12RvaLOCe7649GT9D+u33C+IIT7cZDFwnCsZR7h9nNEYmcb8W/dGHdO\n", + "g6GB1Dc4WjXr8e5aCfdvIYbL2f/2V+RF5PvBjddBSh849xAcOgwX+sGCT7RXhgOSFxPzPPR4i46h\n", + "HfAugMO/BS6xSj3dXdRd3TfiX5BC0F8yVFaiM80KstaBlE63kt//IdpN6OLdYTkhHdZSEnGKdsVQ\n", + "fDyE7KyZcHwAbL8Kjg+0vj1xvVJLRjb8zBrqggnSZjC0IHVxxZREiThvEck3tWfUT5Hw9DfQ94Te\n", + "54DkJKXiXGPgF/lo8X9sAOyP0auBTUmFJXsC96alziij5N9RlTU8BkzCn5cLziUpLYKcDNc1cuu3\n", + "ToDlxy9l4FVGSNlXDJR5BIZ+f2Jdh4EhRRF3+tBhJ2y7DtIvsL51XZZSH3ZopNNqqAUj/AZDC3H6\n", + "AKuC9jfs5aIlbzIyuxwYZm0R7TMpv2U/YcMy4aodEGGNBsyA5YuUmuCuV+5c+vxiYFsn+KI/PDIo\n", + "tKSsC77suxh2ToV1vwIEPy4v+4jV3lPIB2CWD2kp3Xli7yzWAmHW1s72f/WfT/pH4+Pnh+9JWPG4\n", + "3rqvgY63H2Frr04UXyh6Fd+JVM7knZql1OdG+JsJM4HLYGgxrAHW8N0w9VcQ+RMgfcguvwd4HXgP\n", + "eBhIG/MKSfNqWMzbdem/ExASAl3/BN1WAEuOwq6jFHlvHelVVvQRRC2BLhvRw60wllLviB75dLke\n", + "cgKgXIhSJbyJjoGfY9tybf8fRS9fWDV9wcgX8J03np4rIeoreLgTbOgNy0eFU/wfm9g8Zv1NBnJ3\n", + "N+KJNTQBpsdvMHjA6WadwG7w0VD88qDPcsgcBnndgJnLXWe4erJaVqyIIxj+OQSi3gCvv4+FJw6M\n", + "pCB97Wl5JzGKT3zWkeMP7Yq1i+lM622iTseWKOHApcBETslVnAroSOpMb3ZfAbsvh5N3FhDw7yBi\n", + "FkJROGyZYX3zeqA4E1LN4G4zYnr8BkMzUGHWkZejK2PXXFUAwKlQbXap4PTgZ54u5h0J3d8Ar9eG\n", + "w7zz4YUN2/kjM0ljYUUef24ovo/t/gGllXMKAA5BcJxIst2LyFmfJIovMAbt0TMRGAJ8ByzBT83j\n", + "mb69UYfvQz4KJOYvwQw93J/evSFtIqy5z9bCkiwj+mcGRvgNhnrTMx6/v0dzw+WwPAH2TgAeDILb\n", + "C2BBUGW+2Wmw361bpyW6dRbInhA/DIJKveB/A2HJ2zCgMJ/OJHE/o+hBMAGcZC87939CvkyxvU1c\n", + "A5nR0H0BjARQwPRODAq9WZLy+9MdmIA283yFHk74XiWoYuf3BSmFrRuAW4BMlkVn8MnmMApdzfiF\n", + "a4zonxkYU4/BUE8k6KpvueHYRRwdAp+/Uuk3z8RN4HPQk8XSa2OGSMoAGP+0m31j+kHp5RBzBFbn\n", + "szv3BG/FbuSSsBI4ac3WXQLDF0fDx4NhSRSUekHxHr/iYwejdnTZdjB5WF7uuS5B5n4AZgC3AX2B\n", + "/wBvqgS12X2o5uojfBqalhbx6hGRycA/AW/gNaXUn93kmQfEAQXAbUqpn9zkMcJvaPVIorTnSMhe\n", + "9t0SRtILNtGHpgyzHCeS/AhM+hL4oy39LuBqHwiPhM2dIaE3ezPOJRWICdlBeMx3nOqWSeCQUvwK\n", + "BkKvcJiYBoOPwiWMZz0PMZXrS94j37dM4Ot+cOdI8vYNwAtvFrM2fDOLR11AeZi/3UVVi3+vWkJQ\n", + "GJoDj7SzgcGBvNGviH0AX2ADMNgljwNIsv4/H1jVWIGGzGa25tyYSwRzWcev/D+BO2oNutaYWww4\n", + "ZkPqclCPg0oAdRWUv2hrxB2wyxkwLQYcdwhp9mBsj4Jabvs8MjRGjWSiUqDWdkN1/w1qxJ2o50ej\n", + "RgSFHoMrfoZZJ6se5+zUpjxOs3lwX7ZAkLbRwC6l1F7ryfM+cBWwzZZnGvCm1brVItJeRLoopQ43\n", + "sG6DoclxhlbwCSE0aBZDy4tZUtSteDqsiqs96Frj4RwQPlh1QHjVKRiT4maAuCfEv6bolxoBPXIh\n", + "sFS/KTyB9raf4d2N7T5zGMHHAAw8Bov/A0OP6Pr+y/AOMLoDAQ/CBZb/fmkA9Vuf19Baaajwd0f7\n", + "Bjs5gO7V15anB2CE39Cqcbpd/jGY6MtugQe2wOFvOHcVxG2uU9C1xqU+A8LOqKHPjYH/nAOTd8H0\n", + "LbBhl5SOKpnos73sPvKzp3DSKi70VKXoA5z0L4bBG+DywbDtWvAqwSqSmtbnNZwZNFT46zpA4Gp/\n", + "cvs9EZlr+5iilErxoE0GQ6PQE+Jf8CZ6+K0wfSskpICcIWGIncHYXkjS7f54MLw8EpZdraRs77Z8\n", + "NhaEkHqS7SXx3MD3JTcjvvMYRDHBbKeUnNGbYIg/vPsFZIxyKd39+ryG5kFEJqA9sTymocJ/EOhp\n", + "+9wT3aOvKU8PK+00lFJzG9geg6HRCIUA/zJ462MYkVmZHmKLtd/UeLoUoz1qaKcCuHM9rFlPWq+e\n", + "PL7nwuyxXDDnRq7OD88/EHbs41Sf1I/WXzH81KkPKl1Rf7wdvh0GfALYhb/SRbUxl4k01B2rQ5zi\n", + "/CwiCfUto6HCvw7oLyJ9gAxgJnCDS55PgXuB90VkDHDC2PcNZwLOXrNd9OH0WPtNhXu3yTlRIrHU\n", + "JrDVTRLbvV8lAe8D90uidKBf1tXFvmHPMn5JELuv02vqngqBkwvQIwKTgKsLwCsNig46xzIa0jZD\n", + "y9MY7pxxVLpzvq6UekZE7gJQSr1i5XkBHWPqJDBLKfWjm3KUMu6chlaEJ6EVGpOKyJgAnbbC0SHW\n", + "Hs/dRmNFHN3gD6HQtxg4EsrBtUGX9SZ3UShRS2DzTCots9Nz4ORK+8C1JEoI0JdPYv+N/5zhtN8D\n", + "B8bawjaMWwfBx81bQPPRIiEblFKLgcUuaa+4fL63ofUYDM2Np6EVGo/QAEIzYPIDELkBXt4AJUF4\n", + "OrgaK+IYDa8tgK7OtBu8Cd+Wn6PyCyNg8/VV8of5pHt7X7Y6P2sst0mizEVP5AoG9jLsUBcO79AL\n", + "yGf3s76xAugfA6/b2mfeAlojZuauwdAKkUTxJiVqE6NyBrP+LljxGJQ69dSzHr8zzn9WIGzsAnvC\n", + "YU97eLsohP1bHKjcypg/UczgORbzfmD+8a+G8frhiXwM7AUOqwSlKt5GfAoh5DCEHIKQv0HIZfr/\n", + "HVdC5ogGtddQN0yQNoPhLEASZRjwCqP2lvHWtP0cfrpX5d7q4//UhtPF8/ue8H8XQt9svQjMeQX5\n", + "RIYkcSh3FH0Ixp+T3BS4na7t87kxmA5rIe4wnAAigUhJlEge8YoCv3K8vbzIj9RLPuanl5PfwYv8\n", + "LlDmZ6vZuH+2NozwGwytBEmUUOAp4EbgkcF/KzscWf7ZU960C8nHV7bRPS2H8gSlNie5W7O3NhOU\n", + "c7D6yp16c/IEMJR8vFlHAhD2CGwsgch8veWV0hm9OMseYCVwCP/yQ7zUZyiHB9wOodYktnad4eXh\n", + "p9ds3D9bG0b4DYZWgCTK1cA84BsgNmYuo/TAcmk05AEwh6z2K6l2zV7b4uvuSYd5t8M5dhv/o8Ah\n", + "dCS2Jehh3exnwdtmAXbATweV+v1pBSawHfig4hgk1gFz3ARv8+wNxdB0GBu/wdCCSKL0Ap4HBgK/\n", + "Ugl60qLTHn+gHfiXQicd7R8HJCuQxTBpfxh4KR2SwbkvSakabemWV89TITCwBIK6gNcv0WEcroHM\n", + "cMD+YKivF5MJ3tb8GBu/wXCGIIniA9wPPAI8B8ywx8B32uOTo+HJS+DVz2DqzqqTx5ZEwSOXQfsi\n", + "mLAXMg/TWxKlu0pQbidIQtWwD7EijjK47wUIfNbyWAIa5MWkWiCUhaH+mB6/wdAM2G3ye6Lw//EX\n", + "dC4PZDdwt0pQqa75nT1+gBW94dardTjl3Uv5yqeIcue+coEtnSClD8wdzOGsvvgAWeiZncuA5SpB\n", + "ZTTbgRqanRaJx99YGOE3nK04bfJ/9Sf60cvgo8HQ/xsOH9/A7VvKq19j127Hz/WHYVPJ2zOQ/O6f\n", + "8rfJm/mVu4llW+aSDMQCl6DjuYxHL6S+DP0wWK4SVKZrfYYzFyP8BkMrJE4k+Qth0rC7YOwBeGYp\n", + "hBfVbpOPFXH0cjG7bJmLP/BSxA+kjF5CuC/eXY8S0nUbAzNziMhwnSkrieIFnIN+CExAm/MPox8C\n", + "KegHwaEmO3hDk2OE32BohcwQSVkE47MDtOBXpMPyRUpNqG95kiiRwGsUeg3k31f5cfgjm5//nF2w\n", + "8v7qBlQlUbypfBBcAlwMZPofYXfUGnr03cnJslzy0mHeFmIwQdhaP0b4DYZWiN1eb6cuXjjVIYki\n", + "fN1/E2OzYlj+JKy517YMZN1nykqieHdZwt09fHiya3c6ftsbuufCiXTfkxl7x5wi7cNwCjpZuWt+\n", + "qBhaBk+006v2LAaDoSFYIZJ32dNmQ5rTi8YTVIJSfHveMV5bBbHvwZD/2vbWfaasSlBlw35gyroV\n", + "dBxzAK7aBuP2QXlel2CGtgsnPhruGg5ShvbP73Wfp202tB6MO6fB0MQ0VbA3H46FlmZFwxvfuiz6\n", + "7n6mbHWzfZ2uo5N3QZeusCsCSjdHQcrn4FUKHXaC8taFRKghkih3AGnoh1mGSlDlrnWZWP2tGyP8\n", + "BkMzUJ9lE+tCrIhjPKGRe5lJWnllcDXh1kzlZqZsTbN9e9rWHXCuPfATJ1kCUO5jCwcNeJ0sRg8Q\n", + "zwKigPaSKHvQDwK9rYloT6dL7iDr3d6VMXtMlM7WhLHxGwxnIM5xg08J4V8MoohgAjhJBqnrflYn\n", + "XNdK5FLxXf8NpcPLBQ6GQk/bbN/98LzrQ+EyQjOXcS2Kf3etLGV2GqyKd/EaCgH6oR8CejsQNp2g\n", + "Dh1odwBW/T9Y+qyV20TpbArMzF2DoY3gNM8k3pnPnvB1dM3TAdWOltJLEuWv6BA8mcAhPusafYm0\n", + "H4I6xpZOcMlt8MAqeOh7CCkj0J0p6jB5zyvWAY4awy+oBJUP/GxtAIjMGAyLxuNVAr4FttwmSmdr\n", + "wQi/wXAG4oy0uXY+ZAXCoRDIDIH4zhw6NIAjQDdgBBDJxdmj8o6XBLAXhh6B9a/AA5Nh6N0Q/A1B\n", + "UKMpygPTTJ52Wi33heIwW7qJ0tlaMKYeg+EMw7l8YgQMjobAiWije3UB1URmpIRw63gH8Sxkd0X6\n", + "xQP8y7+fWlaqymQ14SU31BTjpz64X4/3dDORoXEwfvwGw1mOu+UTZ8GpNPg5CxLceQo5V8sK4Qti\n", + "+A2d2McpgjhKH3b6PsbJS+ZmMXqLDz4qEXieuTFXNNQjx0TpbD6M8BsMZzkTRdYvgeGHg2F/GBT6\n", + "QpEPPBhE2ubreBwdvdO+BZAZMIRDPS8NOdQrzLF5BQtPllSUN5MokniO/K5/WsFdP5yiyCuahZN8\n", + "2JPUo7JWM3GrNWOE32A4y7lOJOtDCJ8/HF4ZCQGlEFgCG0q91THvjscoKy8hPHcDnYt3oMcBCoFC\n", + "UkP6nf9p2c2r8gpD94XB1/3g9p90maOYxDraLWfuB5fw+ZCfGJdzLmlXwFd/oXLWrvHIaa0Yrx6D\n", + "4SzHGbB/zo96czKKy+UYyZZKzymAlS+69tBniAwBxgeWQvxEeHv7eajCMNIoBw4FqwSlZO6ME/z8\n", + "OkyYC1N/DYucM4KNR87ZhAnZYDCcQeTC7sdc0maEebPdsR1CnNGW3YdWqPAEOhmC1/Y+pIycznJS\n", + "yGYJEN1d2+XzijgVCkv+Bh8stH3beOScTRjhNxjOILLgyW2Q8QQwF5hEOItzPiZ/07twsost5+k9\n", + "dGfMoHkMIm/V/2DUi+B9ytq7oKt+WKTP0zZ9KsM0mHVzzzqMqcdgOIOwJlvNKbImW61mYEw+V3Yk\n", + "3TXn6T1050St/bR/m8PnRPD1MzoWT0VYhZBApTYnicRS28Qtw5mNGdw1GM5gPPGZd7p3nr7HDOCe\n", + "iZjBXYOhjeFZDz19HsyJOv1hYcw5bQXT4zcY2iBmgtXZg/HjNxgMFVQXf7+l22VoXIypx2AwADXH\n", + "35H//1wAAB1KSURBVDfibzDunAbDWUhPiJ8P0ct7w4reOm0+RPcCs3SiwQi/wXA24ozX/1NXWBRT\n", + "mR6i4/cY2jhG+A2GsxDnLN2Bx2BHh8r0fB27x9DGMcJvMJyFOGfpDjwOOzrqtNmQth+My6bBDO4a\n", + "DC1FU3rdOGfp3p3DfQeDmXiFP19nFvNPM7BrAOPOaTC0CNV43exaCffXR5zr8vCQxP/f3pnHV1Vd\n", + "e/y7khBCSBhCFIiACEGGBJBRcIAgUJKgFaqAvraOYH1thbY+B9SaXH1aa/taUfuq8tQ69Ck4WwlB\n", + "aQ1aBWtEAXkgEASBIPMUSCAJ6/1xziWXmOFmuvcmd30/n/25556zzzm/M62zz95rry1rWNL5SZYP\n", + "ubQhg6sYoYm5czYA83k2mhrfe6w7pMyHxPd6wVPDYOZKeGIzyZcpt6SK4M+96I/LpkhqJj/q1I2i\n", + "c/4LhkWDd6DGWb1FUjHjH56Y4cd8no2mp/I9lu3OH7kDChLg7vEw6/vQei1Dh37KnxYcoKd33eru\n", + "Ra/L5qrOTj1+SRQMjyL5/fb8XjwyiI86DSQ2I4PCHh1IiAayIOI2OAlOuIbMW6jXYOpGc8cad6l4\n", + "gDZ0gg97OPPM59loTLz32M44x0CXufPbH4eb8yH/KXj7JTgeTbu/z6Ln2OvgxYFwPLL6e9HrsvlJ\n", + "N3hlACztBZ8lQWl72gEd+bz/+Rx7oSP7+kLiV85KJ38HvOduwQZXCVfM8FPxABXGwxUznE9vMJ9n\n", + "o/Hw3mNPD4WkW2HdSPhVpe/tx7+loN87bNz2B4g7AddNhXZz4ZJrYH8KSeBU3Yhk5IpMz3uXUSmL\n", + "iOOmz+CVV+D5N+Cpv0H7N9rvJDt9MHu7OP48e/tBzAGfPXnj7NvgKuGKNe4CGSK5i2ESwIZO8P2r\n", + "YfxmKFjCktwyTQ+GJqNl4XuPbW8HL6XCcx2g7VpOdjzECY5y/Fgpm2JA3oWhAAdi4IVBzstidWeg\n", + "JOIEHw4vI39pLCfiAYjj6tJb+Xur5ZzNcdqyihPHD3LGUXgrAe4B/rMKNb8GdtYYutloPliQtnpS\n", + "uf71UGvoP4Nju8+koDyO8Zqle4Khy2g5VNWOdAOcWNsZ7TWI1h8MhC5FoB9waNBX6F+UDt5818PO\n", + "j9vwkw39U35Lnz796ZkH/70WjiQBIJGZquU5Fc9Oq9kwZDu02wFLxwMP+ii5oRg2rYX9WWb0WwZm\n", + "+BtAqkhmD3dUoyIo3tKKP627mwuBq4ApmqWrgqXNaBmkimQmwX0JMKAPtJmI418zF0iNhzPOgD8O\n", + "ghVRMOoj6HkIOhyDr6BwBR2f2smY/4A344jdC8cSKzbcbSJc9i0s+SNsnuDMa38NtJoLe3cDS4H1\n", + "h+Docgu/3PIww98EiEeuBh4FbtYsfS3YeozmjbfKZ975sLkjdD8M3Q/Bg7GweTyMfh7e2APPDHGq\n", + "eDZ3hMu+grxViScKC8ZFw8IqtnoPnHWZ8wVwuLs7L5sK3yGw0bVaLvWxnda4WwuapS8B6cAfxSP3\n", + "iUfsnBn1xtvIO3gXnH3IcSh4dQDsGwxxpVAaBW1L4aJv4Nx9cNZhJ8haYfqxaKb8C9r85LTtteHH\n", + "wPdgx/k+Rh+g3Gf6+p02upbhi5X4/UQ80hl4DdgDXKNZeiTIkoxmiG8jry+/Bu4HLodjb0Gs77Ky\n", + "CGjfejzH2j4GSb+n3ertDOE4MRxlFFt5kXEUsMBnjdnAMaAbzgtgWb7qByOa8LCMIGIl/iZEs3QX\n", + "MB7YCywXj/QOsiSjGeINnuY773o49gmsyYTcAni48vJrTrY+VlLcG/b2h9VPc5LZdGY7ueSTzR7m\n", + "kUPnqBFEtJuoJE2CqW/BWTfhVPXcD3Q5GrgjNJoD9S7xi0gCsAA4G9gCTFfVg1Xk2wIcxil6lKrq\n", + "yGq2F9Ilfi/iEQF+CtwL/Jtm6d+DLMloZlR2JPgGHvPtlVt5+Rd0XLGTtJugfxI8AEAci+jPzONd\n", + "2LOhjPIdX8fw5HoZfwfFS0d9Z4ddLyzkJx//HvgM+EKz9LDvYmf83e6zLY5P8ySgjbsi8jCwV1Uf\n", + "FpE7gI6qemcV+b4Ghqnq/lq21ywMvxfxyDjgJRxfucc0K0TqzIwWiWOcEzzQrhe0Bo58DYX3+hpo\n", + "J8/oeU44BpfI67cxOuc1JuxuBQwDBgE7gJXASj7uFMk/02dy7MVeFXubtQmWzzHj3zwItOFfD4xV\n", + "1V0i0gXIU9V+VeT7Ghiuqvtq2V6zMvwA4pFzgLeAT4GfapYeD7IkI8xxjH+PW5xwDEXFld03xSNR\n", + "QF+cTmJD2Rl/LQl05FgnWD/FcQkFzAuo+RBow39AVTu60wLs9/6vlG8zcAinqudJVZ1fzfaaneEH\n", + "EI/EAc8BXYEfkJ0y1D6bw5fmFuVVZHoe8vJYEjZB7F7YdoG7ZPoy1YVpwdRm+Eejh2UWkfeALlUs\n", + "utv3j6qqiFT3BrlQVXeKyBnAeyKyXlU/rGZ/2T5/81Q1ryZ9oYBmaZF4ZBpwD6Wymu69Stj2to9f\n", + "nYW/DRe8vXOfgmQViNDmEOX1SAkaAfvOddIpLI5PqCIiaUBagzaiqvVKwHqgizvdFVjvxzpZwK3V\n", + "LNP6agmVxNCUldyWqAx8UUF9UsbiYGuz1PQpHXL3xKKXX4U+PaTiBsiAkL3+kJIJMzeefr/euAlS\n", + "MoOtzZK/1xCt6zoNicf/NnAt8Fv3983KGUQkFohU1SMi0hZnFAhPA/YZ2qwccJjtL8EVP4Svx0OR\n", + "92PJwt+GA4f60+W8DLh6DfxwdcX8UI7yqvpljkgqTmz+qtsFjJZHQwz/Q8BCEbkR150TQESSgPmq\n", + "Ohmnmuh1pwmAKOCvqvpugxSHNEdK2D0QnvgC1LeLhH02t2TEI9HAf7a6lH6LXoOJm09fXgQhff1d\n", + "I2+GPoyot+FXxz1zQhXzC4HJ7vRm4Lx6q2t2bHsUZvVGfdzpmFlg3eVbFqf5vXfZHsG1EV1pc3Ld\n", + "WQu4buE33D/RJwLnTCj4Buz6GyGFhWxoZGpzpzOaNxW+8k8lM+QZmHAn/LP3HlYcuU5Prs2prXOW\n", + "YTQ2Fp3TMJoYkYxcWDyJibdDci68+hLsScH83o1g0ejunIYRigTXVz4+BoBP/x3evw/KYtz51oBv\n", + "NB/M8BvNCq+v/BNCcoSCEGhf+SMlABw8p9J8a8A3mg8WndNoFngHGf+GCS9+w/Dkmf3iyBrnLJsP\n", + "yT3glsAo2faoE8vGF2vAN5oXVuI3Qh7f4GNHgHeBNhtmMHFDDh9QxBgC5yvfUL93i4RphAJm+I1m\n", + "QPfZMD+ZxHWgkbCvD8XlCzjOCJaQDwTWV76+fu9VRs+0kB5GEDDDbzQZjdcI6zao9vgI0rKcBtWN\n", + "kynOjeUBhYlQInDmdJG8UA6MFsWZ95cxP5n+r8M3F8LRzjgvgcxbsA5URgAJG8Pf3KImNne8jbDz\n", + "IbkkCmLKGtII6zaorpwJK2+EzmsgKZ82upwPgO4Q8YwTZhgIzcBoqSKZCYzrv7v9VrhsFjyxymep\n", + "eQQZgSUsGne9RmgxTFoIYxfDpNEwL1UkM9jaWirdYfZ8SN7QCQb8DFZ1dhphk+C+DJHc6SJ5GSK5\n", + "/l0D3wZVgV2D6P15LrewnneBZyB6V1vw9kgJbGOvf3SH2edxpA0X/wY+mQOHu/ksNY8gI7CEheH3\n", + "GqH5Q+HTJGdeKBqHlkQ8xACcuw9+sxQmXANv9oMEGJBTxxewU/+9fE5kwqhDZ8glpZMYwTwWM5ki\n", + "NkHJSYGLboD8pIp1Qi0wWjzEzGY95yzZAx/ddmp+G64uNo8gI9CERVVPPMT87VzIToOPn66YH2rG\n", + "oSVxBEq80zPWQq8DMPUq6JNIm7HJ4MmDcVucF3Cm8wKuuVome+3xctjb6UF+FXGCf38O2vwJisvg\n", + "zHfOZWjHEhheWJE91AKjHYGSyRRB6bs8xhhKaEsMRylk49rVejBkqqSM8CAsSvxbehJ94+XwxgI4\n", + "+1DF/FAzDi2JbfDoLDjl7z6iEC6cT0nhAGhdDtOmQa7r21LTC1gkNVMi0nPZE/8m7wwoWn8ipSxH\n", + "NWOhalqOakYh/HrWRRT/crnTmQtCMzCa93xMpohc8sljGd3ILzjJoaxgazPCjxZd4k8VyUxI4LZV\n", + "1zP8gkUcH7mD1t5loWgcWhJfquakipDpE7Cs6AhnfP4sw66bAl2Owo+mwtNvQ9FXVb+AT7k/plyS\n", + "zIn9kP/JYLhpnq/749psdkopR59bxwdvQExDAqM1pY99VefDArgZQSPYo8c0ZBSZmlIKZF7Tmk2D\n", + "b0YfvgBdBno5HJ0KqzNgcQrYCEMBTimQORM2vi/oxWlou1+gqedx8qyBLKz6nkjPRcqU2b2Vnu9X\n", + "OaIZ2TxPNrc3VFvVI1HN3GgjUVkK9VQf29niSvzeUltcxCUjd13xWcfuB44yaVMZKQJjlNhM2JGj\n", + "muGbN5x7UQbSzdUt9Y4oV25flkfsi/vhV5OQvv/gii4Xy399+6Heevoa8TFoJLywBA709pnvuD+K\n", + "R5KAy4A5DVfndhKTcog6DqWxmI+90VJpUYbfN1Z6UfotFEVGcvzt9mSMzeXIoCKGFcLW/aSIR6by\n", + "Qo+28L2scO5F6etr753X1D7w3WH0MxD793PAkwae9+HBsUS02shs8chGzdInKnK7/vunGX3wcX/8\n", + "GfCiZumBhitzO4ldcg+0Pgw5f3Lnm4+90fJoYY27bqnt/EehZx4sfIUjRa8wcFE/tjwCd/4Tysso\n", + "AWYxrfAZfpmbzPQrYeTj7vrzk51BVMKD7jD78UiSb5sIRdHOvLq4uaaKZNbVJ9/r5jn+a3gkFx66\n", + "GC7eCgd7cgL4nXjkPypyVxsQbYW0nvguxa1u488XDHZe+PXDewwJbBtEygJIfRnyfIeFNh97o+XR\n", + "okr8p0pt+/vA/74Dx9sDUEJbEorhlQIK4gv4heZojsi0PBJ+M5azPoG2u322ET4lvHiIiS6HfbEw\n", + "cWok8QvP44TGsYbj54ukZtb05VPfrwVfN89LN8CYrXDnBChpQySwDrhfPJKgWXpXNQHRVsDoHzFo\n", + "WDJb28KuNy+GWV3r86XmewyPdlnFLzOv5eQLK+BYopvDom4aLZRgN0w0pIHiu9tIzz29cc5JnRi1\n", + "r3KDbnV5fRsOGzulQGY65E6DvHTIbeoG5tr2lw65CvpGZFuNuT5RGT/X74ZN77oKWhhXcQIzoMbz\n", + "523g9T3pN8KmxEu4jWy+IpsNZFPK5A6fQvoeuPKg85uSdeq6Sbny83OVs/MadN28x7CrLXr2L9A7\n", + "B8ToJIZrPBP2QcZia9i11BxSfWxn0EU3RPx3t1GVZ8aNm6p6gOuStzFSVQZvJmxsKuPvz/68eb7H\n", + "cCV2tzLnHOWcpX4Z02mQp6Db49FOt6PHopyVpkGeP9oyYPE0yPN9IZNNDNk8wD2UcFeU0u91hWUK\n", + "dytcdRLGb4SJq5Fypc8ihZM+WqfVut/qjuHV/ui9aRXnyZ9jsGQpVFLYG35nOymZTmltWl5tpba6\n", + "5G1oGkfUZwr6bi/0kfNRf0vI1etOz3V0p+dWpdtbmi0T9Nu21e8vBTKdEq4q8TsUKffLmPqW+DN+\n", + "iP5lcP2P5zvH13X0fn7WV5kbrVw0ppKBv/6o8zLQSsm5frWdl+qOwTc1xjFYshSoZIY/RBOkZI7q\n", + "mFA8ZQbaazb69rlofUuXNfmbk42QTTLZXN3zcrZdfD0aNxedMqPm/dWn2sv3i+KtvuioG50qm8b4\n", + "goErDxJRqiRNUW4aqkz9sRJV7KPr8qNVfKllwcyNRB3zu7qqumon6+NhqTml+tjOFta4G3qIR9py\n", + "affH8gccibnvY3jpNSdEsZe6h41wPZdQaL8Nkj6FpMRkem1/HogEDgP5lFB87zIYVggdSyrWrnp/\n", + "2x6FWb1Pd22tuWHTtydq7EZiV36fkVvO5w87VzSGG2hRKSejoHAwPPtXmHItDHkGPv2puzyiADJ3\n", + "QFyb9qxvO5R1EasYPmd/15s7MqMfPPshHOpBbX741pvWCFfM8DcR4hEBZgC/o11pdPQT8/mi/OfE\n", + "lBWdynM1bYq/obiOXiOu59J5f4EJc2HHCCgcDsv7FXLlJxM1S3eB47GyAOZN8PG6qS5MRX2HE3QN\n", + "ZI57vNnfZpBSt2Opjm2Pw6y7oXMrSmPh1QWVlpfsUM3J8PXKGZhcxP6pGfC3J12j76VmLy3fYzCM\n", + "cEHcT4WgIyKqqlJ7ztBHPHIe8CgQB8yOyh43ryxq0dC4KYn0e30kbU8qR4lhI4X5B3X1iDptWzJy\n", + "YfEkpBw0gorQZJm5qjkZvnlTRTJ7BKg0Kx7pBqwGumuWHm3w9iQ1CxJ/Cb3j4Wmf/iYzC2DFbNUv\n", + "czJEchfDpDf7wYxLozjx8gewfXSlLX33vBhGS6I+ttNK/I2IeCQRuB/4AfBr4OmUbCZ1Ib/Ll+eO\n", + "Z1fsaPJPLnXycu1OZXtW3ffiVsto7dUygSzNapZuF498CFwFPF1b/lq3p196AI/TOavqLxFvZ7AL\n", + "tsFjz0bz8L5HKMDX8JsfvmFUhZX4GwHxSBRwM3Av8DKQ5Q0j4C2VXjg9kkMbu5H4eU9vHPb81Xqw\n", + "TqX9U/uT1Eynh7H/1TKBQDySCXg0S+t1XHXFe269/xcRx2P042M67D9Cq3+FynkxjKbESvxNTFVB\n", + "3cheW4xTrbMHGK9ZusZ3nXiIKY2AHUnlfP72VjqyFYDpUO/qENeYhaJBWwL8t3hkqGbpyqbemRvj\n", + "vre39/BkiniD/IIeMNsaaA2jeqzE7ycVAeDcKpb2WyFzTBHnbDtGtP4UeF2zvnsyvaXScoFIn6UZ\n", + "sDce1ra0gd/lhrbPcTT+EhaOKQhExNNAtmMYRihSL9sZbB/UhviiBlaf6+seVayM9Si3Jyhjs5Xo\n", + "iUtqWq8aX/ETywLUgzew5yglk3ZXbeaOjkr0Yb986S1ZstSwVB/b2cKiczYlrhslOEHdnlwJy7Lg\n", + "RIfWNazEl6o5y2FOJuROh2UZsPcaaBXRA97u6+RpOQO/d5/N4ZfO4etxMOiv7rz5yZB0X1BlGYZx\n", + "GlbH7zdubPiyGMh53Gd+7WF7fb1rpovkjYGxn5bBrMtg5A7oUnT6uLPNdYCYSFollQO8fx9opM+S\n", + "hIG1Rfs0DCNwWInfb6qNDV8nd0FvWOIRhTBrJdx0GSgVPWor2hIWT4KFY53f0fMaEnM+UMSxpysA\n", + "e1Jgbz+fJX2iw2mcA8MIdczw+4lTWl0+BzJzYfoy59fpSFSX7bieKJsA7l0GW9vDRcPZXdGj1g3J\n", + "EH3EaUCWkzSXAWL6sm5nDNdWmnsXMJFwGufAMEIdq+qpA43hRnlafJhy2rTJIWr5NaTqpbhuoG5b\n", + "QtfP4cqrnGEA9/aDI4VDxCNzcQYr+T9gs2ZpWXX78SVQ4+omcKiwP2sGfs6vccIGlQPpwBjgIRvJ\n", + "yjBCBHPnDAHEI/cAFwPpZKcvdqp3XGIOQuJ6OPu6NUz8agnQHxgAdAUKcF4C63x+N2iWngrLVs1I\n", + "WZuWw5zGNv6pIpldiJ+/hYykAiri6zi9lD+baXX8htH41Md2muEPAdyev8uB/yE7Zdtp/QUA3/g0\n", + "PuvEAufivAT6U/FC6AVsw30Z9F1C5vPfMLD/Hog/UbHFTMjNUW30GDapIpkRtPcU0r/XCeIopvzr\n", + "Mnbfa0bfMJoGM/zNGPHIAMpkOU9e8AV7YjtCZFdosxNKdtQl9IB4pBXQG/eF0HUDs7vEc+ZXnWDl\n", + "k9B3n5NvOixbqJrWVMdjGEZgsJANzZnslJ6MaX2CyVFjeC7Xjbw56yAsr1O8Gc3SUmC9m8gQuXgx\n", + "TDpZ6bao+zgAhmG0FMyrJ2ToPpsP/5VIRBmM9PYTaLg3j9eLKEIhwv24qy4uv2EY4YGV+EOG+Bg0\n", + "Et58FkbN85nfMDdIG2XKMIzKmOEPGdyewfv71LlncG3YKFOGYfhiVT0hQ+P0DDYMw6gN8+oJIUJ1\n", + "gBXDMEIXc+c0DMMIM+pjO+td1SMi00RkrYiUi8jQGvKli8h6EdkoInfUd3+GYRhG49CQOv41wFTg\n", + "g+oyiEgk8DhOwJYBwNUi0r8B+ww6IpIWbA210Rw0gulsbExn49JcdNaHeht+VV2vqhtqyTYS2KSq\n", + "W1S1FGcg8svru88QIS3YAvwgLdgC/CQt2AL8JC3YAvwkLdgC/CQt2AL8JC3YApqKpvbqOQsnboyX\n", + "7e48wzAMI0jU6McvIu8BXapYdJeq/s2P7YdGy7FhGIZxigZ79YjI+8CtqrqyimWjgGxVTXf/zwVO\n", + "qupvq8hrLwnDMIx6EKwgbdXtNB/oIyI9gUJgBnB1VRnNldMwDCMwNMSdc6qIbANGAYtEZLE7P0lE\n", + "FgGoahnwc2AJzkAhC1R1XcNlG4ZhGPUlZDpwGYZhGIEhaLF6RCRBRN4TkQ0i8q6IdKgiT3cRed/t\n", + "KPaliMwOkLZaO52JyKPu8lUiMiQQuqrQUKNOEfmhq2+1iHwkIoNCUadPvhEiUiYiPwikPp/9+3Pd\n", + "00Tkc/d+zAuwRK+G2q57oojkisgXrs7rgqDxGRHZJSJrasgTCs9QjTpD4Rny51y6+fx/flQ1KAl4\n", + "GLjdnb4DeKiKPF2A89zpOOAroH8T64oENgE9gVbAF5X3CWQCOe70+cCKIJw/f3SOBtq70+mhqtMn\n", + "3z+Ad4ArQlEn0AFYC3Rz/yeGqM5s4DdejcA+ICrAOi8GhgBrqlke9GfIT52h8AzVqNHnvvD7+Qlm\n", + "dM7vA8+5088BUypnUNVvVfULd7oIZxzZpCbW5U+ns1PaVfUToIOIdG5iXZWpVaeqLlfVQ+7fT4Bu\n", + "AdYI/nfiuwV4FdgTSHE++KPz34DXVHU7gKruDbBG8E/nTqCdO90O2KdOe1vAUNUPgQM1ZAmFZ6hW\n", + "naHwDPlxLqGOz08wDX9nVd3lTu8CarzormfQEJyT35T40+msqjyBviHq2jnuRoITk79WnSJyFo7x\n", + "+rM7KxgNT/6czz5Aglv9mC8iPw6Yugr80TkfSBGRQmAVMCdA2upCKDxDdSVYz1CN1Of5adKBWGro\n", + "AHa37x9V1Zr8+EUkDudtNsct+Tcl/hqdyu6ngTZWfu9PRMYBNwAXNp2cavFH5yPAne59IFTvHtyU\n", + "+KOzFTAUGA/EAstFZIWqbmxSZafjj867gC9UNU1EegPvichgVT3SxNrqSrCfIb8J8jNUG3V+fprU\n", + "8KvqxOqWuY0VXVT1WxHpCuyuJl8r4DXgRVV9s4mk+rID6O7zvztOaaSmPN3ceYHEH524jVHzgXRV\n", + "re1zsSnwR+cw4GXnniURyBCRUlV9OzASAf90bgP2qmoxUCwiHwCDgUAafn90XgA8AKCqBSLyNdAX\n", + "p19NqBAKz5BfhMAzVBt1f36C0aDiNkY8DNzhTt9J1Y27AjwP/DGAuqKAApzGs2hqb9wdRXAafPzR\n", + "2QOnIXBUEK9zrTor5X8W+EEo6gT6AUtxGtJicSLUDghBnX8AstzpzjgvhoQgnNOe+Ne4G5RnyE+d\n", + "QX+GatNYKZ9fz08wx9x9CFgoIjcCW4Dp4HQAA+ar6mScz6ofAatF5HN3vbmqmttUolS1TES8nc4i\n", + "gadVdZ2I/MRd/qSq5ohIpohsAo4C1zeVnoboBO4FOgJ/dksDpao6MgR1Bh0/r/t6EckFVgMnce7T\n", + "/ws1ncCDwLMisgqnHe92Vd0fSJ0i8hIwFkh0O3pm4VSVhcwz5I9OQuAZ8kNj3bfpviUMwzCMMMEG\n", + "WzcMwwgzzPAbhmGEGWb4DcMwwgwz/IZhGGGGGX7DMIwwwwy/YRhGmGGG3zAMI8www28YhhFmmOE3\n", + "jCoQEY+IzPH5/0CgBgIyjKbGeu4aRhWIyNnA66o6TEQigA3ACA3NIF2GUSeCGavHMEIWVd0qIvtE\n", + "5Dyc0OIrzegbLQUz/IZRPf+DEzysM/BMkLUYRqNhVT2GUQ3uWBBf4kTB7KP2sBgtBCvxG0Y1qGqp\n", + "iPwDOGBG32hJmOE3jGpwG3VHAVcGW4thNCbmzmkYVSAiA3CGVFyqqgXB1mMYjYnV8RuGYYQZVuI3\n", + "DMMIM8zwG4ZhhBlm+A3DMMIMM/yGYRhhhhl+wzCMMMMMv2EYRpjx/5WxPOsrMTqmAAAAAElFTkSu\n", + "QmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['LWLR-BFGS']\n", + "modelLWLR = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelLWLR)\n", + "fwd_LWLR = generateFwdTest(environment, modelLWLR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Forward models comparisons" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'max time': 0.011260986328125, 'mean time': 0.00037045001983642577, 'mean distance': 0.16072982253082238, 'max distance': 0.43973074597217354, 'std time': 0.0010947639700226491, 'std distance': 0.10037534368797667} \n", + "{'max time': 0.011703968048095703, 'mean time': 0.00073633909225463863, 'mean distance': 0.093771696344595853, 'max distance': 0.30806254447231185, 'std time': 0.0011039698586537453, 'std distance': 0.058426547119284841} \n", + "{'max time': 0.012078046798706055, 'mean time': 0.00098849296569824218, 'mean distance': 0.085331665126708686, 'max distance': 0.5727275322273625, 'std time': 0.0011153885287879712, 'std distance': 0.086142758938267172} \n", + "\n" + ] + } + ], + "source": [ + "print fwd_NN, '\\n', fwd_WNN, '\\n', fwd_LWLR, '\\n'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Distance between $s_p$ and $s$ comparison\n", + "\n", + "If we look at comparisons values with a 1000 training $(m,s)$, we can easily notice that LWLR is closer to the goal on average than NN or WNN model. NN is really further than the two others which are not so different and the 3 standard deviation is equivalent. And the maximum distance can be sometimes very far away between the prediction and the goal for NN models. With a bigger dataset (10000), NN gets better results and is closest to the two other models even if they are still better. LWLR has still the best average but WNN has a significant better standard deviation and a smallest maximum distance. To conclude, LWLR looks better in average but seems to be less good sometimes than the WNN model for an equal number k of neighbors. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Time processing comparison\n", + "\n", + "NN model is far away faster than WNN and LWLR in speed processing in any case : around 4 times faster than LWLR model and twice faster than WNN with an equal standard deviation for $n$ = 100. These results were forseeable knowing that LWLR also computes WNN to make its model and WNN uses NN search. These models work sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. In that case, it would be faster to use an approximate nearest neighbor search. The processing time can be accelerated for WNN and LWLR by reducing the number of $k$ neighbors observed but it would also alterate the distance results." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Getting started with inverse models\n", + "\n", + "The predicted motor command $m_p$ to reach a goal $s_g$ can be obtained this way :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "m_pred = model.inverse_prediction(s_g)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to test foward models, we are going to generate randomly n $s_g$ and use one of these models to find out $m$. The distance between $s_g$ and the effective $s$ and the time processing are weighted and saved in $comparison$ dictionary." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "####Nearest Neighbor inverse model\n", + "\n", + "\n", + "To perform the inverse inference, the Nearest Neighbor inverse model looks in the dataset of tuples $(m, s)$, the nearest neighbor of the given $s$ motor command, and return its corresponding $m$. " + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEZCAYAAACTsIJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXm8XFWV77/rBoSEGRmEyCAkiqIgIoMieBWfhthAt93I\n", + "QwUcnkT7QVBbG7UVIqI03T4FtJvJAQmNERDbYGNwwBtpGRpaQBRoQxgzgCYERJnJen/sXbnn1q1T\n", + "darqnKpzqn7fz+d+bp2h9lln1zl77bXXWnubuyOEEELUGOm3AEIIIcqFFIMQQogJSDEIIYSYgBSD\n", + "EEKICUgxCCGEmIAUgxBCiAlIMQwwZva4me3cw+vNM7P5vbpelTGz08zsD2a2osBrTDWzK83sUTP7\n", + "bpHXNbNPmdkFeZaZN2b2XjO7tk/X3tnM1prZSNy+ysyO7sF1O3onK6EYzOw+Mzu4T9d+qZldFl+m\n", + "R83sNjP7aO0HLjPuvom739fLS3b6xWFSKma2I/AxYDd3377AS/0NsA2wpbsfmdd1zWzUzB5M7nP3\n", + "0939g92JOzy4+2x3b/m8x7bvzd1cqpMvlb5xizhdNDqdYma7AjcC9wOvdPfNgSOAvYFNei1PVsxs\n", + "vX5duk/XrRo7AqvdfXXB19kJ+J27r+3xdQceM5vSo0s5/Xiv3L30f8C9wJvj5/cC/wn8M/AIcA8w\n", + "Kx47Erip7rsfBX7Q4XUvBq5scc5hwG+BNcDPCb2x2rH7gI8DvwYeB74BbAv8CHgM+AmweTx3Z2At\n", + "8EFgObAC+LtEWfsC18frrAC+CqyfOL4W+FtgCbA0sW+X+Hl2lPOPwLK6sj8Yv7ca+AGwXV25c4Df\n", + "xWt/rUldnAJcBiyI1/lvYI/E8e2B7wG/j7/bCXH/LOBp4JlYT7cAo8Dtie/+BPivxPa1wGHNyo3H\n", + "DPgkcDewCvgusEVdnR9DUP5/AD6dcm8viHIdH7enAL8EPpNy/mbARVGm+4B/iLK8BXgCeD7e6zcb\n", + "fHcr4IexvlcDvwAs5Tq7xbpZDdwFHBH3f66uTo9rdF1gf+C6eK1bgTcmyt4S+BbheXwEuAKYBjyZ\n", + "KOePwHbAPGB+/N6PgP9bJ+dtwF82kznl/t4H3BGvsxQ4LnFslPAsfwx4mPBevDdx/IXAQsK7diPw\n", + "eeDalOvUnoW0928ecDkwP5b3/vgbfyOeuyyWPxLPHwG+FJ+ppcD/jeXXjo8BH6h7B2v3+Vtgr3it\n", + "5+Pv9jjw8Qy/2UuAxbGcHxPaifltt32dNJi9/mOyYngG+ADhRfsQsDwemxYrZEbiuzcB7+zwuiuB\n", + "Y5scfynwJ+BgQkPxCUIDu15C7uuArQmN18PAr4A9gQ2AnwEn1z2Y/wZMBV5JaFQOjsdfQ1AOI4Se\n", + "4B3AiQlZ1gJXA5sDGyT27ZK4lwN8vNHaK35+c3x4X01o/M4GFteVuxDYFNghyvS2lPqYF3+bd8T6\n", + "+DtCQz0lyv3fwGeA9eIDvBR4a/zuKcBFibKmEhqgLYH1Y909CGwUjz0BbJGh3BPjb7B9LOdc4JK6\n", + "Oj8v/h57AE+RUO5197c7oYHcjdDQX0d6g30R8P0o707A/wDvj8feCDzY5Lk6HTgn1tuU2u/W4LyN\n", + "Yp0cG+vh1fG3fHlKnU64LjCdoCxrHau3xO0Xxu3/AL4Tn5f1gAPT5E9eCzga+M/EsVcQGrH1W8nc\n", + "4B5nAy+Jnw8C/sz4szsKPEt47qYAh8Tjm8XjC+Lf1PjbLQN+kXKd2rOQ9v7NIzzbtc7IhvH3PSee\n", + "vzVB+RwXj38IuDPW8RaETuPzjCuGnyeehyOibHvH7V2BHevbvoy/2fUEhbQ+cCChPbyo0T03bfs6\n", + "aTB7/cdkxbAkcWxa/EG3idvzgc/GzzNjxWzY4XWfITYwKcc/CyxIbFv8gQ9KyH1U4vjlwL8kto8H\n", + "vl/3YL40cfwM4Osp1/4IcEViey0wWndOUjHcT+g1blp3zjeAf0xsbxTve8dEGa9PHP8ucFKKTPOA\n", + "6+rqYwXwBmA/4P668z/FeM91HnU9G0JP+a8IPaSrCS/524A3AbfFc1qVe2fdi7VdvL+RRJ1vnzh+\n", + "I3Bkk9/8Y4RGfjWwa8o5Uwi99aT1eBzw8/h5lOaK4XPAv6eVnzjvSOoaOoKSq3U2JtRp/XWBk6hr\n", + "NIBFBAtqO0JDtlmD606Sn4kWwyaEDtMOcfsLxOe4lcwZ3snvA3MTcjxBbGzjvocJHagp8XdOvk9f\n", + "oLXF0PD9i/c3lji2LaETsWFi31HANfHzNUy0bv4XEy2GpGK4moSVWydXvWJo9pvtSFCUUxPH/o0O\n", + "LIaq+Bjqeaj2wd2fiB83jv8vIfxAAO8iNLxP1RdgZgfGqJ3Hzez2lOusJvQ009gOeCAhixN6Q9MT\n", + "5zyc+Pxk3fZTCblrJJ16D9SuH53gPzSzlWb2GOEhf2GT79bz14Te131mNmZm+yfu4f7EPfyZcN/J\n", + "e3go8fmJBjInWZYoy+P29oSHdnszW1P7IzTg2zQpazHh5T8wfl5M6K0eRDDFIfTGm5W7E/D9xLE7\n", + "gOcIL3ba/W3URKaL4r1c5e5LU87ZitBjuz+x7wEm1mkz/pkw9PVjM1tqZielnLcTsF/dvb+LiffW\n", + "jJ2AI+q+fwDwIoJ1+Ii7P5axrHW4++MEa6P2Hv5vQgPVtsxmdoiZ3WBmq+O5s5n43K/2cR8KjD+f\n", + "WxOsnPr3qRUN37/IssTnnQi/8crEfZwbrwvhvcp67RcTrNwsNPvNtgfWuPuTifPvb1RIK/rlpCyS\n", + "nwJbm9mehAfyI41Ocvdrae1A/imhQb0w5fgK4FW1DTMzwgu1vEmZrRxJOxJ6pLXPtbLOIQyZHOnu\n", + "fzazj0TZknhaoe5+M/CX0Wl2AnBpLH8FobdUu4eNCC9es3toxg6JskYID/1yQu/zXnd/acr31jbY\n", + "txj4MuHhPh14FPg6QaF+LZ7zYItyHwDe5+7X1x/oMJT3Xwnj/7PM7AB3/2WDc1YRem47EywWCHW9\n", + "rMG5k3D3PxF8Ux83s92Ba8zsJne/pu7UBwjDfm9NK6rFpR4g9CaPqz9gZtsBW5rZZg2UQ6Ny6/d9\n", + "Bzglhodu6O4/zyhzUoYNCL6j9xD8hM+b2ffJ5oz9A6EDUP8+tSLt/YOJ9/ggwSp8YZ1iqrGy7nrN\n", + "rv0gMCPlWH29NvvNdgK2MLNpiQ7zToR3ry2qajGk4u7PEhygXyKM7f2ki+JOAV5vZv9kZtsCmNkM\n", + "M5tvZpsSGte3m9mbzWx9wpj6U4Sx5075TIw/350wbPbduH9jggPqCTPbDfhw1gLNbH0ze3d8yWtO\n", + "w9rD8h3gfWa2Z3wRvwjc4O5pPZxWL+XeZvZXMTLqI4T6uIHg63nczP4+3t8UM3ulmb02fu9hYOeo\n", + "XGtcB7wM2IfgeL6D2OMkDDNBGPppVu65wBdjqCZmtrWZHdbiHhreY4w734swPj4X+HZUpBOIdXwp\n", + "8AUz2zi+sB8lBDO0xMzeHp8zIwyFPk/jl/uHwEvN7D3xN17fzPaJz0fqfSS4GDjUzN4a623DGIo6\n", + "3d1XEpzI/2pmm8eyD4rfexh4YXwH1oldV/ZVhN/qc4QhwKwyJ3lB/FsFrDWzQ4CWCgXW/QZXAPPi\n", + "c/EKwu/WSlmmvX/15a8kOHe/bGabmNmIme2aqKNLgblmNt3MtiAEQKTxdUIn4DUWmFF7Xgl1vWvi\n", + "3Ga/2f3AzcDnYr2+AfiLFvfbkCoqBmfyj1u/fQnBIXxZijbPdiH3e4DXEXp+vzWzRwl+gpuAP7n7\n", + "7wi9ma8SeihvBw519+dayJ/8XC/7YsIwwk+Bf3b3n8b9HyeY3H8Ezie8bPVlNbvWe4B7LQxDHQe8\n", + "O97jzwi+ku8RrIeXECyttHIbyZw89u+EceRH4jXe4e7Pxxf1LwjOxnsI9XU+wakNQZkDrDazm6Ns\n", + "TxCspN8m6vQ64D53XxXPWdui3LMIzvMfm9kfCc65fZvcX8N98UX9CnCMuz/h7t8hvIRfTqmLEwiO\n", + "0HsIEVT/RojwaXbdGjMJHZrH4/3+i7svniRksCzeSvi9lhN6qacTGtPaNVLfFXdfBhwOfJrgaH2A\n", + "0LmptQtHEyyfuwgN1Nz4vbsIHYp7zOyRaF14XdnPEBrmgwnvY1aZk/f3eLzmpYTn6ShC1FzD+2nA\n", + "8YQO1UPAN+NfK9Lev0Z1eUyU+44o32WEIR2ACwi+g9sIz8n30mR198sJQ8OXEN7vKwidWgh185k4\n", + "bPSxDL/Zuwgdp0eAk4FvZ7jnSVh0UBSCmX2T0Fj+3t1flXLO2YRogicIoWa3FCZQiYnDGvcQIpo6\n", + "VmZCiPbR+zeRoi2GbxFi1BtiZrMJoaUzCb3YcwqWRwghRAsKVQzRwbumySmHEU0dd78R2Lw2lj+k\n", + "FGe+CSFaofcv0m8fw3QmhnQtI0SxDB3ufp+7T5EZK0Tv0fs3kX4rBpgczSCtLYQQfaTfeQzLScS9\n", + "Mx7zPgEzk7IQQogOcPe2J+Hrt2JYSAgpW2AhE/dRd3+40Ymd3NwgYmbz3H1ev+UoA6qLcVQX4wxl\n", + "XZjNJITjviHuuRg40cIsBm1TqGIws+8QpjDYysL87acQ0shx9/Pc/Sozm21mdxNivt9XpDxCCDFQ\n", + "hNkF5hISU6cScjbm4L4wHu+o2EIVg7sfleGc44uUQQghBpIUKwH3R7otugzOZ9EeY/0WoESM9VuA\n", + "EjHWbwFKxFi/BSgUsxHCXGm3EZTCQ8DhuB+dh1KAgjOf88LMXD4GIcTQ06aV0GnbKYtBCCHKTp2V\n", + "sBqePhZ+Y7C1hfVKcqXfUUlCCCGaUWclXA6PHwebrAmrzL0S2NXMcPer8rqkLAYhhCgjDXwJ74Nf\n", + "HRGUQpIZhNl8c0OKQQghykawEhYTpnqfSvAl7H5hmIq9EVPzvLwUgxBClIXWEUeTlimOPJmyvyOk\n", + "GIQQok1iYu4iC+unL4pLCHRbaEMrYV2yWuBswkJCSZYSFgvLDTmfhRCiDaISOIuJ6zR37gBulb2c\n", + "IM4WAcGnMJVgKXw1T8czKI9BCCHawswWAW9rcGiRux/SZmGFZS+H4pXHIIQQvWDDlP3ZHcA9yF7u\n", + "BikGIUTlKWTMP53uHMDZfAl9RT4GIUSlyX3MvzVnA7vWXa+1A7gNX0K/kY9BCFFpch3zz37N2bTj\n", + "AC7Yl9BEzo7aTlkMQoiq0/2Yf5tEJdDaGqmQlZBEikEIUXV6kvTVNn2yEvJAzmchRNf02PlbT0+S\n", + "vjLTZsRRn+uuIbIYhBBd0Qfn7wR6lfSVifbXS+hr3aUh57MQoiv64fwtHR36EoquOzmfhRD9oufO\n", + "31LRnS+hlHUnH4MQolvK6fwtGrORH5ud9xTcRVxV7Xw4tc3s5VLWnRSDEKJbyuX87QVmM38Pv34r\n", + "HLchjMwHZsIGc+BdbTqPS1l38jEIIbqm7YSvqlLnS1gJzAGunHhWW/6BIuuu07ZTikEIIbJQ50u4\n", + "Eh4+FrZdM/nMxe4+2lPZUtDsqkKI0lDG2PyOSclLOAxubaAUYAB8K4pKEkLkSllj8zuiWcSR2XN0\n", + "MpleBdBQkhAiV9qJzY9KZC4hbPMp4Oyk8mh1vDAy5iWU3beiPAYhRFnIFJvfyrLom+XRRl5C5sn0\n", + "KoZ8DEKIvMkamz+XiY0+cfuEjMfzpeSrqvUSKQYhRN5kjc1vZVn0Liu4Aquq9RINJQkhcqWNSe02\n", + "SSmiZlkUnxWcw3oJffODFIgUgxAid1qNvcfG9EUNDq1k3LK4HngzsH7i+LPADbkI2YYvIa3xH6gI\n", + "rARSDEKIfjAX2L7B/uWJBvV1TFQKxO39u7pym1ZCs8af5n4QKQYhhGiDNP/BnzOc07mPobOZUJs1\n", + "/qWcHbVb5HwWQvSDLP6D/HwM3UUcNWv8M8lYtUxwWQxCiH5wNq2zhrOc05ru115u1vh/tZWMVfRD\n", + "FKoYzGwWcCYwBfi6u59Rd3wrwo/0oijLl9z9wiJlEkI0pxdRNlkil1qd01LOHCKOIqkKKmMEVvX8\n", + "EO5eyB9BGdwN7ExwGN0KvLzunHnA6fHzVsBqYL0GZXlRcupPf/ob/wNmA0sAT/wtAWb3W7a25ISZ\n", + "Dtc6ePyb77Bll9f7ETAW/2euj/gdb/A31oN68k6+V6TFsC9wt7vfB2BmC4DDgTsT56wE9oifNwVW\n", + "u/tzBcokhGhOVXq3DeUcgRMweyndWwkT8O6mvijlKm3NKNL5PB14MLG9LO5LcgGwu5mtIDiFTixQ\n", + "HiFEa6oSZTNJzhnAzSHEtePs5YKcxKVcpa0ZRVoMWaZt/TRwq7uPmtmuwE/MbE93f7z+RDObl9gc\n", + "c/exfMQUQiSoSu92nZzGuCNhGmxGh1ZCUU5iz54J3jVmNgqMdl1QgWNb+xOm2a1tfwo4qe6cq4AD\n", + "Ets/A16b1ziZ/vQ3DH+E8e9FhLHsRXThD6Dx2P3d7ZaZp0zN5JwB/otxP4L/Dn7WqS8hytnIF/Cj\n", + "fv/GXdSTd/K9Ii2Gm4GZZrYzsAI4Ejiq7py7gLcAvzSzbYGXAfcUKJMQA0XevVzPoXfbi/BMh0U/\n", + "hmsOgl02hJHV8PT34Izj3E/potiqDKMVTqEL9ZjZIYyHq37D3U83szkA7n5eDFf9FrAjwd9xurtf\n", + "0qAcdy3UI8Qk2lkUp1cULpPZzN/D97eB3QH+A1bMg4/e5H5pd8WWry67pZQL9bj7jwihXcl95yU+\n", + "rwIOLVIGIQacvvRyW+QQFCNTzEt4Hv5xG9hgJTAHuDLMufQFM/tTlxZJPgl1A4Ayn4WoNj13FmcY\n", + "KspfpkT28hRgPiGEcc34GV2H1OYxjDYoSDEIUW360cttleuQn0wNspePhVUXwSsbnN21leQDulRn\n", + "u0gxCFF9/gg8QojcXAqcUnAvt+lQUW4975Q5ji6CS2isGMoWUltZpBiEqCgpQzqb9+DSLYeKuup5\n", + "t5rjyEy+gIKRYhCiuvRr+oriGuYMM6HKFzCRIiY9lGIQorr0JSIprWGGdSGf7TdQbc6EKl9AoKic\n", + "ESkGIapL36avqG+Yu2qgul8vYZgpxGrUCm5CVJdGk7OtBLbuw0phzRqoxnS3qpoIFGI1ymIQoqI0\n", + "GNLZGNgO2DtxWq9WCmuvgZKVkBeFWI2yGISoMO5+lbsf4u6jwCpCFnCS5r32/MjWQMlKyJtCpvSW\n", + "xSDE4NDxsEIOkS2tI5VkJeROURFaUgxCDA4dDSvkEdnStIHKb+1l0YAiIrQKnV01LzS7qhCtSWng\n", + "lwJzmzXwhc4qWmIroYj4/7JRytlVhRC9o4thhfwjW0puJfRizYgqI8UgxADR4bBCvpEtJbYSEvQr\n", + "a7wSKCpJCJFPZEu1Io7qo7dqDN1qbY2QxSDEkJNLZEs1rARg3TDSrimHNUMrcj4LIbqh5L6ERjRx\n", + "tj8BHDFIPoZO204NJQkhOiNYCYuBrxCUwsXA7mVWCpE0Z/vSsisFM5sdpzopdMoTDSUJIdqjglZC\n", + "HWnO9uU9laJNehlJJYtBiAbk3TPrVU+vcKprJSQpZBqJHtD+RIUdIotBiDry7pkNRMx89a2EdVR4\n", + "oZ+erb8hxSDEZPKOca92zHyFIo6yUtGFfnq2/oaGkoSYTN49s76stNY11cpLGAZ6NgQmi0GIyeTd\n", + "M+vbSmsdM4BWQpVIm8epV0NgUgxCTCbvxe5zK6/wid8K8CUMw2R1eZLBJ1V43UkxCFFH3j2zvMor\n", + "3IldgJUwEI733tN3n5Qyn4WoCIVNj11gxFGhU3oPKGY2BryxwaHFcaW+dspS5rMQA04R02Nnykvo\n", + "Ig+jmo73/tJ3n5SGkoSoDvk1GG1YCV0OB/W9kasgefu42kaKQYjqkE+D0b4voZsx7743clWjDAl4\n", + "UgxCVISuG4zOfQkdDweVoZGrIv1OwJPzeYhQ2OAQ00XEkRzI1UVrPoumKGxwSGnTSmjUeUDDQUOH\n", + "LIYhQb2+IaRNKyGl83A3cGL8rOGgilFKi8HMZgFnAlOAr7v7GQ3OGSWEyq0PrGo3TldkRmGDXdCr\n", + "YbhcrtO5LyHVyRw7D1IEQ0JhisHMpgBfA95CWADjJjNb6O53Js7ZHPgX4G3uvszMtipKniqSc2M0\n", + "VGGDedZdr4bhcrlOd9nL6jwIIKNiMLNpwA7u/j9tlL0vcLe73xfLWAAcDtyZOOddwPfcfRmAu69q\n", + "o/yBpoDGaGjGiQuou15NUdD5dfLJXh6qzoNIp2Xms5kdBtwCXB239zKzLA/bdODBxPayuC/JTGBL\n", + "M/u5md1sZkdnE3soyHW1ptggnggsImS6LgLmDug4cWrddZjB26uedGfXyW9VtaqubCZyJovFMA/Y\n", + "D/g5gLvfYma7ZPheFq/2+sBrgIOBacD1ZnaDuy/J8N1BJ/fGqN+x0T0kre6m05kl0auedHvXyXmO\n", + "I+UciBpZFMOz7v5ofGBqrM3wveXADontHQhWQ5IHCQ7nJ4EnzewXwJ7AJMVgZvMSm2PuPpZBhioj\n", + "s75z0upuO6Dej5VlqKZXw3DZr1PQeglD1HkYSGIwz2i35WRRDL81s3cD61l4GOcC12X43s3ATDPb\n", + "GVgBHAkcVXfOD4CvRUf1BgTL5MuNCnP3eRmuOUgMjU+gANLq7gkmKwZoYYUletKfi+U68Fgukk6+\n", + "zj7A8QRr+llg/oQe+wCtvSzyJ3aYx2rbZnZKJ+VkUQwnAP8APA18h+Br+HwGAZ8zs+Pj+VOAb7j7\n", + "nWY2Jx4/z93vivH1vyZYIRe4+x2d3MigIbO+c9LqjtCgvqrBV7JaYZsDW8TPWwJn1Q9DdRINlfjO\n", + "9gTFMy1x+D1mdpO7X6VV1USvaJngZmavcfdf9UieNBmU4Ca6JiVaaSkZnPBZEgSbJYillZ/ynQmM\n", + "wKLnQwdLVoJoiyIT3L5sZi8CLgO+6+6/aVs6IUpAl1ZYlmCATsJNG31nwpcvhdcBs+KuyloJmqur\n", + "OrRUDO4+ambbAe8EzjOzTYFL3b3lcJIQZaML52qaQ3vjxOdOIskafscYdyRMg82ouJWgubqqRaYV\n", + "3Nx9pbufBXwIuA04uVCphCgfZwMrG+zfLpEL0Ukk2aTvzCAkJZxJcDYsgWvoLC+hTOSalyOKJUuC\n", + "2yvMbJ6Z/YYwxcV1TE5UE2Kgib3aFQ0Obc9449ZJgti67xghA/E24EBgNTx9Ppw60/3gKg4d1aHp\n", + "NipEFh/DN4EFhPmMlhcsjxBl5k8p+6dCZz6M2ndeDSd9E/bcKwwbAVz8QjjxuOorhBrKy6kQWXwM\n", + "+/dCECEqQMvGrW0fhtmIw0uBfRjsiCPl5VSIVMVgZpe5+xFmdnuDw+7uexQolxC5k0NUTL6NW4ny\n", + "EoqOGFJeTrVoZjHUFuf4C8LwZ5Lyr+4jRII8omKyNm4tG9mSZS/3KmJI021UhywJbme4+0mt9hWJ\n", + "EtxEt/RqBbuWSW4lshJqaHW/waXTtjNLuOpbG+zLMlWxEGWiV1ExDcMyR+AEzD5CCDp6A8FKOBz3\n", + "o9tVCh1OHd4MRQyJCTTzMXwY+FuCSZn0M2wC/LJowYTImV5FxWxfv2MGcAkcRA7ZywUN+yhiSEyg\n", + "mcVwCXAosJDgZzg0/u3t7u/ugWxC5EmvFqHZrvYhmZewT8hV69hKSFBEolhlF+gpwHoSNLEY3P0x\n", + "4DEzOwtY4+5/BDCzTc1sP3e/sVdCCtEtPYyKWQlsNYPgSDgw7rwCHn1HyF7u1pdQyAJOVYwY0jQb\n", + "xZHF+Xwr8Bp3Xxu3pwA3u/tePZCvJoOcz2ISZZyUbYrZohPgbXGOI1YCc4Arc3LkylE8juqiNUXO\n", + "rkpNKcTPz0flIERutNvIl7K3aDZzJbx4m7g5nzCUtCbfYRklio0jp3lBZFEM95rZXOAcwrDph4F7\n", + "CpVKDBUdNvKdTHFdDIm8hG1g6lOw5sNw74XwODkPy1R12Kcg5DQviCxDSdsSeilvirt+RojJ/n3B\n", + "siVl0FDSANPJkICZjQFvbHBosbuP5iddC0qYlzAsdLPw0rBQ2FCSuz9MWK9ZiKLoZEigv73FkmUv\n", + "DyOynoqjpWIws5cB/wq8yN13N7M9gMPc/bTCpRPDQieNfP/G2mUllAZNs1EMWTKfLwA+DTwTt28H\n", + "jipMIjGMtB1HHxuEE4FFhHVtFlH0EILZSF7Zy0KUmSzO52nufmM02XB3N7NnixVLDBOdDgn0tLco\n", + "K0EMEVkUwx/MbJ25bmZ/Q+MlDoXomNIOCciXIIaQLFFJuwLnA68DHgXuBd7t7vcVLt24DIpKEoXS\n", + "MI8CliArQVSY3KOSzOxEdz8L2M7dDzazjYGR2tQYQgwK9WGPBnwS9n4eNpkCGyArQQwZqRaDmd3m\n", + "7nua2S29nP4iRRZZDKIwknkU9XMcIStBVJgi8hjuMLMlwPQGy3tqaU8xSGxojDsSanMcfRJ+8233\n", + "o/sqmRB9oNnsqkeZ2YuAq4HDmLy8pxB9Ie/J814NI2czbiUk5jha9u1uhRWigjTzMfws+haudvf7\n", + "eymUEGnkOnlejDi6GfadwoSZUGF4J6YToulQ0nZmdgBwmJktIFgM6xwS7v6rooUTogH5TJ6XyEuY\n", + "AiyBaw4Cfyi8E5paQQw1zRTDKcBngenA/2tw/E0N9glRNN1NtZySlzDTfaGSc4QINPMxXAZcZmYn\n", + "u/upPZRJiGZ0PnmespeFyESWuZJOM7OjzexkADPb0cz2LVguIdJof31izXEkRFtkyXw+F1gLvNnd\n", + "dzOzLYEfu/treyFglEF5DGId0QGdbV4lWQliiOm07cyiGG5x972SiW615LcOZW0bKQbRNprjSIiO\n", + "284sQ0nPJNd4NrOtCRaEEOUkWAmLga8QlMLFwO5lUwpmNtvMFpnZWPw/u98yCQHZZlf9KvB9YBsz\n", + "+yLwN8BnCpVKiE6okJWQaz6GEDnTcigJwMxeDhwcN3/m7ndmKtxsFnAmMAX4urufkXLePsD1wDvd\n", + "/YoGxzWUJJpTMV9CJ+tcC9Euha35DBAVQSZlkBBoCvA14C3AcuAmM1tYr1TieWcQVuBS4y/ao0JW\n", + "Qh3d5WMIUSBZfAydsi9wt7vf5+7PAguAwxucdwJwOfCHAmURPaYn4+c5+RL6NNbfeT6GEAWTyWLo\n", + "kOnAg4ntZcB+yRPMbDpBWbwZ2IfElBuiuhQ+fp6jldDHsf6zgV3rrqv5mUQpaGkxmNkrGuwbzVB2\n", + "lkb+TOByLGg6AAARIUlEQVSTHhwdhoaSBoVm8xl1R/4RR8XJ2oSodE4kDKEujv/nyvEsykAWi+FS\n", + "M5sP/BPhRTyD0Lvfv8X3lgM7JLZ3IFgNSfYGFsSF4LcCDjGzZ73BS25m8xKbY+4+lkF20R/yHz8v\n", + "zpfQt7H+0q5zLSpL7LSPdltOFsWwH0EZXA9sDFwCvD7D924GZprZzsAK4EjgqOQJ7r5L7bOZfQu4\n", + "spFSiOfOy3BNUQ7yHT8vNuJIY/1iYIgd5rHatpmd0kk5WZzPzxFekqmE3tU97t4ywc3dnwOOJyz0\n", + "cwfwXXe/08zmmNmcToTtFUo86pr25zNqRG/mOMpHViEGiCxTYtwGLAROJQz3nAc87e5HFC/eOhl6\n", + "lseQ4oy8GzhR47/ZaWs+o8YF9CwvoWtZS0weq93lvWKe6B0dt53u3vQP2KfBvmNafS/PvyBmz661\n", + "iOA4r//7US/vuUx/wOxYL2Px/+zCrgcjDh9xeMLBHVY6HNbvOihN/bQv15K653hJO/LlUYb++voM\n", + "eCffa+ljcPebGuy7KKviqSBKPEqQNZwzl15l9bKXZxMs6Vcw8fkoy9QWeax2l8+KeaJSFJnHUFXk\n", + "jJxIy4ah61yAFhFHeQ5l5FVWyj3XKEvDmUcnRx2lIUSKYTJKPJpIloah815lCyshzwS0nJPZGt1z\n", + "kjI0nHl0ctRRGkKKnBKjkniXiUcDGNGUpWFov1eZPeIozwS0PMtKu+caZWg484i4UtTWECKLoQHe\n", + "YeJRVaZSbnM4JYsF1V6vsj1fQp5DGXmWlXbPUJKG092vismjHUdc5VGGqB5SDPlSekddu8orY8PQ\n", + "SHk8CWxtZrPXndtZ9nKeQxl5ltXonp8CfgucXJaGs9NOTt5liGohxZAvVXDUta28WjUMCeWRjNCZ\n", + "Spjy5Cwzw0OIYycRR3n6fHIpK2FxPQmsAlYSpoBRT1oMBFIM+VIFR10hyisqh7n15RjM+Dx8CdiZ\n", + "DuY4ynMoI4+yUiyuRzuVSYgyIsWQL1WIaCpSeU1QOjMIJsKB8PK4q6O8hDyHMnIoq/TDhUJ0ixRD\n", + "jlTEUVek8noKwtzpNUfCNGA1PP1CeGdWK6HkVGG4UIiukGLImbI76gpWXme/AnY7F3Y6MO64HB4/\n", + "A/7PTYOhFKAaw4VCdIUUwxCSp/KqOWJHYMPTYNtPwPYvAFbBM5+A31wIny2ZxdQtVRguFKIrWs6u\n", + "WgZ6ObvqsJDjrJtnzYAZ0ZcAwBK4ZiYcUdY5jrplkGdjFYNFp22nLIYhJK9EvBGYewLMqPkSVgJz\n", + "gCvhGR9QpQDlHy4Uols0JUYBVGBajO6nhjCbeTPsfyZBKcwHdgeuDEfliBWiwshiyJmKTIvReWRN\n", + "Int5L5iasBKSyBErRIWRxZA/eU7UVhSdRdaEOY4WA18Bpi6Ba/aAe+qUQmGO2ApYYkIMBLIY8qcK\n", + "ce7tRdakzHE0033hqh45YitiiQkxEEgx5E/p49zbymVoMRNqDx2xyjgWokdIMeRPJeLcWzbonc2E\n", + "WiRVsMSEGAikGHKmItNiNKecay+X3hITYlBQgpsYp3xWwjpSfAxLaWN1PSGGDSW4ie4op5WwjoGw\n", + "xISoCLIYSkwe01ZkuEhprQQhRHfIYhgwmoVnRhoqjLaUScmtBCFEf5BiKC9p4ZmnApuRrjBax/rL\n", + "ShBCNEGKobykhWfuAmxRt68Wz2+0ivWXlSCEaIGmxCgvaeGZaU6hqTSL9TcbwewjwG0EpfAQcDju\n", + "R0spCCGSyGIoL2mJco8CWzY4/0mCxTCJV4f9i5GVIITIgBRDSUkLz4yHG8Xz146tUyYGfBJWfR72\n", + "AzZAvgQhRAakGEpM2rQVzeL5a8f2gC0vgpl7wlbxa7IShBCZUB7DoKGIIyFERHkMQhFHQohcUFTS\n", + "IKCIIyFEjshiqDqyEoQQOVO4xWBms8zsLjNbYmYnNTj+bjO7zcx+bWa/NLM9ipaprLS1dKWsBCFE\n", + "QRRqMZjZFOBrwFuA5cBNZrbQ3e9MnHYPcJC7P2Zms4Dzgf2LlKuMtLV0pawEIUSBFG0x7Avc7e73\n", + "ufuzwALg8OQJ7n69uz8WN28EXlywTGWl2dKVAVkJQogeULRimA48mNheFvel8QGGd/3e5ktXBith\n", + "MfCVuO9iYHeFoQoh8qZo53PmJAkzexPwfuCAlOPzEptj7j7WlWTlo+HcSCPwZLQSlJcgRMnoyZop\n", + "7ckzCox2W07RimE5sENieweC1TCB6HC+AJjl7msaFeTu84oQsERMmhvp5fDAWKizr8Rd8iUIURLa\n", + "8gv2iNhhHqttm9kpnZRTaOazma0H/A9wMLAC+C/gqKTz2cx2BK4B3uPuN6SUMxSZz/FBO2EEpp4K\n", + "23wSdpmiOY6EKCVmtgh4W4NDi9z9kF7L04hSZj67+3NmdjxwNTAF+Ia732lmc+Lx84CTCesLnBPn\n", + "+XnW3fctUq6y4u5XYbaEEHH08rhbVoIQ5aS5X7DCaK6ksqA5joSoFINsMWhKjDKgiCMhqsjZwN11\n", + "+5JT4FcWTYnRT2QlCFFZ0tZM6WdUUl5oKKlfKHtZCFEwGkqqCspeFkKUHCmGnMg0AZ58CbnR1oSD\n", + "Qoi2kI+hBVkyG1smusiXkCtlTCwSYpCQYmhCGw1Q+gR443kJ8iXkR7MJB6UYhOiSoRpK6mD4ofWM\n", + "p4FJiS4GfA5mIl9CEQxsYpEQZWBoLIYOhx+yNkATJsCbQTARDgxzH4GshLxpOOEgIVxQCNElw2Qx\n", + "ZO39J0ltgJLWB7A1sMKAEwkmwoHhy2uQlVAEA5tYJEQZGBqLgc6GHybNeEpogG6gzvrYDX5/Mfxp\n", + "b9gYYAlcMxOOkELIn0FOLBKiDAyTYmh7+CGtASJhfRjrwo22mRa+9hAwZ2YJI47KNnd8N0S5Kym7\n", + "EGVnmBRDWu+/6fBDowbIzP4eJvgSALgSHj405CWUzkpQiKcQIitDoxjyHH4YgadOICQlTANWAnOA\n", + "K+EWL6FSiCjEUwiRiaFRDJDT8IPZzJXw4m3i5nyCw3lNwvoo6ZCNQjyFEJkYKsXQFYns5W1g6lOw\n", + "5sNw74XwOAnro8RDNgrxFEJkYpjCVTvHbObv4dfEOY7+A1YcCB/6lvve7j7q7ockGv1OwmJ7gUI8\n", + "hRCZkMXQjGglPA//uA1skPAlbA98wcz+1MAKKOWQjUI8hRBZkWJII7FewhQm+BJqpDluSztkoxBP\n", + "IUQWhm4oqeV8SQ3WSzgWfnMME5RCjUZWQF+GbDQNtRAiL4bKYsgwPXbDVdUugkuAVzYocpIV0I8h\n", + "mxI7vIUQFWSolvY0s0XA2+r3j8Ci5+FqUtZLSGl4lwJzy9Dwpt0XsMjdD+m1PEKIctBp2zlUFgMN\n", + "HMMzgEvhdcCsuGvSTKgVcNyW0uEthKgmQ6MYYq9/93XbjC+pNg02o8WqaiV33JbW4S2EqB5D4XxO\n", + "DAVtBcFKWAycSZjSYglcQ7XXXlaOghAiN4bFYpgLzKizEngI1i6E045zPyXtiyWd3mICFRjqEkJU\n", + "iGFRDBvWz4Q6H/gEXP9Qa6VQiWifkg91CSEqxOAPJZmNnAbb1lZVWwkcBhwDPBzmOWpGWae3EEKI\n", + "whhsxRDyEhb/A+w2jWAl7A5cGY5mGYNXtI8QYugYzKGkxEyoxLyE8+H8ObAv7Y3BK9qnTargkxFC\n", + "NGfwFENK9vJx7o8c135pHa36NqxUyScjhEhncDKfG1gJNMlLaOPas1G0TyaUgS1EuRjuzOcUKyGP\n", + "tZcV7dMW8skIMQBU2/ncYCZU4HDcj85DKYi2kU9GiAGguoohRhwRV1UjWAlVzl4eBJSBLcQAUKhi\n", + "MLNZZnaXmS0xs5NSzjk7Hr/NzPbKUGhLK0FrE/SHOOx2IrCIoLQXUZIZaIUQ2SnMx2BmU4CvAW8B\n", + "lgM3mdlCd78zcc5sYIa7zzSz/YBzgP2bFNrSlzDokTFmNuruY/2WI41e+mTKXhe9RHUxjuqie4q0\n", + "GPYF7nb3+9z9WWABcHjdOYcB3wZw9xuBzc1s24alZfclDHq28mi/BSgRo/0WoESM9luAEjHabwGq\n", + "TpGKYTrwYGJ7WdzX6pwXp5SX1ZegyBghhOiCIsNVsyZI1MfYpn0va16CImOEEKILCktwM7P9gXnu\n", + "PitufwpY6+5nJM45Fxhz9wVx+y7gje7+cF1Z5c/CE0KIElK2BLebgZlmtjOwAjgSOKrunIXA8cCC\n", + "qEgerVcK0NmNCSGE6IzCFIO7P2dmxwNXA1OAb7j7nWY2Jx4/Ly4wM9vM7gb+DLyvKHmEEEJkoxJz\n", + "JQkhhOgdpcp8LiQhrqK0qgsze3esg1+b2S/NbI9+yNkLsjwX8bx9zOw5M3tHL+XrFRnfj1Ezu8XM\n", + "fmNmYz0WsWdkeD+2ismtt8a6eG8fxOwJZvZNM3vYzG5vck577aa7l+KPMNx0N7AzsD5wK/DyunNm\n", + "A1fFz/sBN/Rb7j7WxeuAzeLnWcNcF4nzrgF+CPx1v+Xu0zOxOfBb4MVxe6t+y93HupgHnF6rB2A1\n", + "sF6/ZS+oPg4E9gJuTznedrtZJosh34S4atOyLtz9end/LG7eSHr+R9XJ8lxASGC8HPhDL4XrIVnq\n", + "4V3A99x9GYC7r+qxjL0iS12sBDaNnzcFVrv7cz2UsWe4+7XAmiantN1ulkkx5J0QV2Wy1EWSDzC4\n", + "U4O3rAszm05oGM6JuwbRcZblmZgJbGlmPzezm83s6J5J11uy1MUFwO5mtoIwY8KJPZKtjLTdbpZp\n", + "PYa8E+KqTOZ7MrM3Ae8HDihOnL6SpS7OBD7p7m5mxuRnZBDIUg/rA68BDgamAdeb2Q3uvqRQyXpP\n", + "lrr4NHCru4+a2a7AT8xsT3d/vGDZykpb7WaZFMNyYIfE9g4EzdbsnBfHfYNGlrogOpwvAGa5ezNT\n", + "sspkqYu9CbkwEMaTDzGzZ32wpmDPUg8PAqvc/UngSTP7BbAnMGiKIUtdvB74AoC7LzWze4GXEfKr\n", + "ho22280yDSWtS4gzsxcQEuLqX+yFwDGwLrO6YULcANCyLsxsR+AK4D3uXr8GwiDRsi7cfRd3f4m7\n", + "v4TgZ/jwgCkFyPZ+/AB4g5lNMbNpBEfjHT2WsxdkqYu7CDM7E8fTXwbc01Mpy0Pb7WZpLAZXQtw6\n", + "stQFcDKwBXBO7Ck/6+779kvmoshYFwNPxvfjLgvrbv8aWAtc4O4DpxgyPhNfBL5lZrcROsB/7wO6\n", + "qqOZfQd4I7CVmT0InEIYVuy43VSCmxBCiAmUaShJCCFECZBiEEIIMQEpBiGEEBOQYhBCCDEBKQYh\n", + "hBATkGIQQggxASkGIfqAmc0zs7/rtxxCNEKKQYj+oAQiUVqkGIRg3SI/t5nZBma2UVzc5RUNzvts\n", + "XCDmWjO7pNbrN7NXm9kNsYwrzGzzuP+DZvZfccGYy81saq/vTYh2kWIQAnD3mwhzypwGnAHMr59O\n", + "wsz2Ad4B7AEcAryW8Z7/RcAn3H1P4HbCtAQQ1kfY191fDdxJmCJdiFJTmrmShCgBpxImaHuSsPBP\n", + "PQcA/+7uzwDPmNmVAGa2KWE1vWvjed8GLoufX2VmpwGbARsDiwqUX4hckGIQYpytgI0IE7NNBZ6o\n", + "O+5MnNc+bd2H5P4LgcPc/XYzOxYYzUVSIQpEQ0lCjHMe8BngEsJwUj2/BA6NfoiNgbcDuPsfgTVm\n", + "9oZ43tHAWPy8MfCQma0PvIfxoadBXExIDAiyGIQAzOwY4Gl3X2BmI8B1Zjbq7mO1c9z9ZjNbSJjW\n", + "+mGCL6G27vaxwLlxHYSljE9t/FnCmtx/iP83rhWHIpNESdG020K0gZlt5O5/jgpgMfBBd7+133IJ\n", + "kSeyGIRoj/NjGOuGwIVSCmIQkcUghBBiAnI+CyGEmIAUgxBCiAlIMQghhJiAFIMQQogJSDEIIYSY\n", + "gBSDEEKICfx/BE/79jHEbCsAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4VVXWxn8rBVLpHemhJqA0JQKCWICggg3LWBgEy6jY\n", + "21hOjvNh1xmxMA6IBZViQSyA2GgKSFd6L9I7CaGG/f2x9iU3IeXm3hTU8z7PeZJ7yj77tLXXXuVd\n", + "YozBgwcPHjz8dRBW2h3w4MGDBw8lC0/we/DgwcNfDJ7g9+DBg4e/GDzB78GDBw9/MXiC34MHDx7+\n", + "YvAEvwcPHjz8xeAJ/hAgIidEpGExtt9ZRJYXV/vFDRFZLyIXlHY/SgMiEi0iX4rIPhEZY9f9n4js\n", + "FJEtRXyux0RkWFG2WdQQkX4iMr2Uzl3ffqth9vcEEbmxBM6bKiIji/s8weAvI/itEMoQkTS7HBCR\n", + "GqXYn1QROWb7cUBEVojIa/59MsZMN8Y0C7Ct0/EFM3YpNOzz6lbE/SlJXAVUAyoZY64RkbrA/UAz\n", + "Y0ytYBsVka4issl/nTHmWWPMwNC6+9eBMSbFGFPg91IE7+BpmyT1lxH86EO4xBgTb5dyxphtpdyf\n", + "UcaYckBF4HKgBjCvNAek0wgGkNLuRAioB6w0xpywv+sCu40xu0uxT38KiEh4CZ3qj/4O5om/kuDP\n", + "FSLynojcb/+vbaeE/7C/G4nIbr99HxKRLSLyu4j0D/XUdsEYk2mMWQpcA+wEHrDny6bdicgj9twH\n", + "RGS5iHQTkR7AY8A1diazwO77dxFZavddIyK3+rXT1bZzv4hst9fUz297tIi8bDWefSIyXUSi7LYO\n", + "IvKziOwVkYUi0qWA6zxbRJaIyB4RGSEiZf3Oc4ltY6+I/CQiLe36kaig/NJe00Mi8m4hnlOu7dpt\n", + "tUTkUxHZISJrReRuv22pIjLWvhMHRGSxiLTN8wGKNBORb0Vkt30eV9v1LvCk3zO5FZgM1LK/RxR0\n", + "L0Wkkoi8IyKb7b37TERigIl+7RwQkZr+Mz4RmSgid+bo5yIR6ZNfn/O4vlDeocoi8oWI7BeR2UCj\n", + "fM7jM8UMtNe7RUQeyPFcPhGRkSKyH7hZRMqLyNuS9T3+S7JMOWEi8pKoWW0N0CvH+aaIyC1+vwf6\n", + "XecSEWmdyzv4YADPrIGITLXtTAaq5HXNpQ5jzF9iAdYBF+Sy/u/AF/b/64HVwGj7uz8wzv7fA9gG\n", + "tABigI+AE0DDIPuTCozMZb0LzLL/dwU22f+bAhuBGvZ3Xd+5AQd4P0c7KUAD+/95wEGgtV+7x2wf\n", + "woGednt5u/0N4AegJqocdADKALWBXUAPu9+F9neVPK5xPfCrPa4iMAP4l93WGtgOtEcHwJvsM4r0\n", + "e17dgnhOebZrr2Ue8AQQATQA1gAX+z2TQ/ZZC/AMMDOPa4sFNgE323bPQgft5rk9E6CL71na33nd\n", + "y8r299fAKKC87Wvn3NrJeS7gRmCG37YWwF57/fn2OZdrDOUdGm2XaCAR+B2Ylsd56qPf0od2/yRg\n", + "B/Z7tec4Clxmf0cB44Chdv+qwGzgVrv9dmAZWe/dj0AmEGa3/wj0t/9fbfvW1v5uBNTN4x0s6JnN\n", + "BF6y97ozcIAc3+XpspR6B0rsQlUIpdmPYC/wmd+D3oN+6EOBW8kStu8B99r/RwDP+LXXmOIR/Lej\n", + "JgLfx+XrSwIq0C7ACseC2sqxzzhgkF+7Gb4Pwa7bDpyNCoQMoGUubTyS80UGJgE35XHOdb6P0f7u\n", + "Cay2/w8Fns6x/3KyBFzOjy7Q55RXu+cB5wAbcmx7DBjhdx8n+21rAWTkcW3XkEOQAW8BT+X2TPyf\n", + "ZUH3Eh1wM7FCNMc+2drJeS4gHkgH6tjfg4HhgfQ5gHc20HcoHBXUTfy2DQam59FuffRb8t//eb9+\n", + "pwJT/LZVBw4DUX7rrgN+sP//kOO9u8i2n5vg/wa4O5/31/8dzO+Z1UUHwmi/bR9SwHdZWstfydRj\n", + "gN7GmIp2uQLAGLMG1VTOQkfpr4AtItIEFRZT7fE1UW3Jh415nUg0GsfnRP6tkP2sDZxiBzbGrAbu\n", + "RT+C7SIySkRq5tOHniIyy07p96LaW2W/XXabLPsz6Ecch05Po1BNOCfqAVfbae5e225H1DeRF3Le\n", + "M59jsx7wQI62zvDbng2FeE55tVvTbquVY9tjqBPWh+057kmUz4SQy704J0db16NCKRDkdy/rAHuM\n", + "MfsDbOskjDFp6GzhOrvqWlQAFbrPIbxDVdFZSkDfix/yeldAtXIf6qFa9Va/6/ivPS8U4ltF343c\n", + "3vXckN8zqwXsNcYc8tt/Q4DtljgiSrsDpwmmolO+SGPMFhGZCvRDp4kL7T5b0VHdh7rkAWPMdFTz\n", + "yg8m5worYC5F7cG5tTsKGCUi8aim9jyqbWRrS9SO/ilwAzDeGJMpIuMIzFG1C9WmElAzjT82ohrM\n", + "racclTdy3rPNfm0NNsY8k8dxp9wfAntOebYrIh2AdcaYJoU4Z17YCEw1xlwcZFt53ks7oFcSkfK5\n", + "CP/c2s25bhTgiIZPRhljfgywz/59COUd2gkcR5/3Crsuz+/FDzn33+y3zf8aNwFHUBOL/8DjQ8Df\n", + "qm0rIY9tOe9rfs+sHlBRRGKMMRl2dT105nba4a+k8eeHqcBdwDT7e4r9Pd3YORswFugnIs1FnWxO\n", + "iOc8+QGJSISINEc/2GrAK6fsLNJE1JlbFn3pD5P1Um0D6ouIr80ydtkFnBCRnkCBHzuA/ZBGAK+I\n", + "Og7DRSRZRMoAHwCXisjFdn2UdfLVzuca7xR1xlYCHgfG2G3DgNtF5GxRxIpILxGJs9u3c6pDMJDn\n", + "lF+7vwBpIvKwqAM7XESSRKSdX38DxVdAExG5QUQi7dJeRHzhtwW1lee9NMZsRZ24b4pIBdv2eX73\n", + "pbKIlPNrK+e5JqBCx0Xt7IH22R+hvEOZwGdAqr3PLVC/QkGD4RN2/0R0QB+T2072/kxG39F4UWdu\n", + "I797NBYYZN+7isCj+ZxzOPCgiLSx70uCaOgtnPoO5vfMNgBzAdfe107AJQVcb6nBE/yKaegU1SdQ\n", + "fkKdRr7fGGMmAf9B7Ycrge8JLU7XYKM+gH3AeFRTamuyh5n6zlEWeNbusxU1yTxmt31s/+4Wkbl2\n", + "uj8I/QD2oNP+8bmcPy88CPwGzEHNTs+i9tHfgd7AP1Hn20Y0Aimv98igZobJ6HR6FfB/AMaYecBA\n", + "4HXbx1Xo7MWHZ1FBsFdsNA+BPac827WD2iWouWgtei//B/iEqMnlvuR6n4wx6aggvBbVTLfaPpcJ\n", + "pK0A7uWNqM14OSqABtnjlqMKwlrRaJ+aOc9ljDmKCt4L0CCEQPvsf32hvkN3oc9qG6pIjMhnXx+m\n", + "ok7774AXjTHf+Z0n57lusv1eavv3MVkmx2Go7X4RKow/zauvxphPUP/DR6gz9jN0Bgk53sEAntn1\n", + "qB9pD/AU6ns6LSFZilIQB2tYWi9ghzGmZR77DEGdehlAP2PMgqBP6MGDhz8dRKQ+OhBH5GG68VDE\n", + "CFXjfwcNfcsVIpICJBhjGqNRGENDPJ8HDx48eAgRIQl+68Tcm88ul2GnO8aY2UAFEQk06sGDBw9/\n", + "HYRiNvVQSBS3jb822cOqfkfDpzx48OABAGPMemNMuGfmKTmUhHM3Z8SBN7J78ODBQymiuOP4N6PJ\n", + "KD6cQfbYXABExBsMPHjw4CEIGGMKTyQXauovmm79Wx7bUoAJ9v8OWA6aXPYzpZ3CHOI9SC3tPnj9\n", + "L/1+lHb/r4YpBkxGBKbqQ5hVlTAGzNV+dAd5LT1g0rEwzCMXYtZU1OMMmF6wuwdMSoSUP+P9/6P0\n", + "PRFSBsAqA+aEfTYDNFTZBNNeSKYeERkF/Aw0FZFNItJfRG4TkdusNJ+AxhuvRjNN/xHK+Tx48JA3\n", + "0jSpj+jj0H8BvNFe16cr8Vy+iIwlruffYFF1qJyRtb4dVJoI3ZPh1SSN0vNQCqgDg4ZBwtut4UGb\n", + "Rjcs74zjAhGSqccYc10A+9wVyjk8ePAQGDbBkIHQaBgk/GMOtL4Ndk9h7cYjvJbfceJK06hbaX37\n", + "UnjxW4jwc7HujwSOqZBJgbvRrOA/LJJEUurAoHiISoPD0bnwYp2OiIeo7xrCPy+A6e+E3p7H1VM0\n", + "mFLaHQgRU0q7AyFiSml3IERMKYpGFhszIUmEFLg7bj/RbKPZuKv4Ju0Dk6ewFlcuAj6M3Mrw9G9I\n", + "ifDTIgdFwtJkTuZFx2mWdLH1v7iRJJKSDK/6a8o9YHOSSMpik/c9Oh2w6Qwirr8SPhkLTYpgqAop\n", + "c7eoICLGBOOg8HBaI6d2tQmGnO4f2J8J4sp5qIk10TjZQyXFFQHuRGsTXGMcMzVJJKUu3B0N57SA\n", + "irWrwLt9YNZwPSYFJk0wpmcJX0aRoafIpInQ/YTAviioZA1gp/t1iSs15CiLOk7CTJ+fxaQ6ANa8\n", + "DY2CkZ2exu+hWJCbdjUQGiWJ4An/EsN0lNDvQvwYX8WVSGAISmd9rnHMWsD3XCYkiaRUglf7ZZLw\n", + "fKweMwDWbCR/k9Hpjphwot9Pgmc7wSUr1awF+c5kSh3iSgzwhSnDm3vnMycF7o6D6HQ4ZJ/H18G0\n", + "6wl+D8UCnzNqZwxUydBkjj+LnfiPAuMYI64MQcnWJgOIK5VRQrNDQLJxzIGcx/lMRrcf4t6N8VzQ\n", + "EyZvgtf+qAO2uBIF9CtzL+337ILXJsIFa7O2B+L8Lg2IK2EoI+gK4OnFap7J9gyyCHkLB4+d00Ox\n", + "IF6LufDIRXDmHfBhSzgednprV382JImkXPgM10Ye4uKONWVarbZyGzALmA9clpvQ92GxMRO+PWQu\n", + "PhHB4Ump9P0jCn1xJVZcuR9lhr20/DyeTHiP1ReuzcoqPc1nMs+jhW8GGKdobfKexu+hWOALLXx7\n", + "PHyTAM91gie6QcQiqoor0cYxpaJliSSlQJ1BEB8FaYdh0xBjFhco1P5o/oqTprajJDw2F5Z1ofO8\n", + "epwbv5QhB8aYBwvR1Ha0Qlear93T/T6IKxXQmeXdKNXzJcYxC3AgSWRZTnNJUfa/qO6PuHI7ynWW\n", + "bBxzpKj654Mn+D0UC/xDC3ushh6roVc9Nk++ggPAOmuCeNM4Zl+wwriw0PMkvwrD/OKfBzYSSSK/\n", + "8/0R/RU+U9vhcDgUAV80g0kjCf/PWprnXt4kT/gE/+rT/T6IK9WA+1Am4C+B84xjlvvv4/NjFMf5\n", + "i+r+iCs90EJPnYxj9hRHXz3B76FYkC200KddbeC1Y6+YCeJKC7Rw9Rq5LfpHyvVpw4FRDbKOLlgY\n", + "B4c6g2BYApVWQUZVOFwBHQRS8vU7+ITo4mpwTzNInga1IaEOvJckcnNpCj1xpax2kfr+S/nbSa4V\n", + "A9vjoGwm9FgFK6tA3NpCm9p8gv/kfTBAehmIP3p6+G3ElTOAh9DiNaOBtsYx6+02QQu2RPkt0Tl+\n", + "B7KtwGPK3k/D/YaYqhGw9tXg7o+4ciYwEuhjHBNoLeBCwxP8HooNeWlXxjFLgZvFlXrsqjiVO76p\n", + "x9Jb4aeHYU8CgQjj4BAfhZyAK6+HWffBb9fb9XH5CkOfv+LrMlB3vi0hpqgyUDNai03jFVfKoIK9\n", + "ATmEu12qovxX6/2WyXVm0jyuHW3abYEPP4OFNWDgZdBgTqEdmScFv+8+vNUOZteGd2w9roL8NuJK\n", + "OFpBrqiFbiWgCVqudA9aJrIH0Mc6dKPteY+hpsfclkMBrN8TyDGdP2LYiAzOjjoOsceyrj9Qv5a4\n", + "UgudqdxtHPNTIMcEC0/weyg1GMdsEOm7npg363H2a1BzvhX8UJAwDg5ph2n5IZgwWHyt3/r0fIVh\n", + "Ghz+mjgmph1jSvoRNsdDrbT8I5UCNV/5Cfb6eSzVgC2oQF9n/04mS8hvMY45nqPNxCW9qNViPnuf\n", + "/YaKzxsI3wiVPufEb81JE1fqErhwTQCaiiv1OlajPjvg0hWaQXrkK51NbKpDS3Fldj7tRRC80PX9\n", + "3uv3fxW08t+ZaDnIUWgpxNzaO2IcUyIFz3umyt46uawPJGpIXIlDayL/1zhmdEH7hwpP8HsoZaQd\n", + "JqMKTHFzrM9dGIskpZQn7OnmbG4YxzEyObRuB8efDEjjrrjmLS667QLGfheB8QW0DVgDG/ON6phN\n", + "zZkz6NKtbdi0SNjC9VfCDb/CwPm6PadGl82XEHYMym+Cyv9IkuviP6dZ+iGgAb+Vb8m8JvUwXcsg\n", + "B4/SbsVmkg6sRSkE9qL1hCejwsvfVFEVHSgu9q2z2q3/9tqmDAd2pFF2RDi8fxxOCLi/E3ZNRa6a\n", + "uJSuaS3YR2BCNxOtSbx/RSLf3Lyfy99Lo2qr7TApAcatZevGSryKZu/m1d6xoohKEVfao/Vuk9H6\n", + "15fkF5lU0vD3a/nWBRI1ZGdEHwEL0Tq/xQ5P8HsoZWwaAgMbZXe45i6MRZJS4qkxrDvra43hpM+r\n", + "Yj9keJLIgAKF/z2rWrM3cjZb3CNExMYQlnaU+ivHcP3GneJKZ/LSWCt3vp7doyIPlq0GwJtfQ9d+\n", + "cME6aLgXNtUmUVz58eQx9c5OYMOwWPp1gTNmQXpN2Fe/Npll/wHpR1gel8n3PaLYNzrc9qwsu6+v\n", + "yfEJuzlrfxpQHjVR5BSgB8hfWF8J/A0tpj6r9Szeez6abvd2gt+qwffvw5i9yEWfs+zbMaZLIE9H\n", + "XLkKuN445lmAJJHxKXD37jU0uuVs4mqsYMDmhcXn47A2+vOAx4FmwIvA34xjMvI9sBSQq18rsKih\n", + "l4FY4KqiDtvMC57g91CqMGbxBJEk1KYfF62a/sbXcnfs1hnUlBO1xrCGxdVgciO4egm8e8DUTD6D\n", + "98WVZeRvIw6n4rEMnpzsr9X+g/zNDochJhpgebWuXLNjNmN2buSxGXBzH6j/Ids21GAomiWr+2+t\n", + "9RbQno/HwqFKcCLS9r/vNGPGdhXpOQlGd6fKcqi+CDZ2hrSPovk8ZbcZN+GKwt5D6+AdCrQB2hnH\n", + "bBRXai+/jKaJTeDmhfDBZ1n7h5ejUSGaP2njhyy/jbhSBVizO5Wphe1vILACvwcq8KsDzwEjjWOO\n", + "Fsf5igqFjRoSV+5GZ2/nluS1eYLfQ6nDCvkAPpb4qFh2ABB+ApZUhcG3Q7NdsHcDR4B/o+U9cxPi\n", + "bwIbjWMeL2z/JLVnY6BO+q9jmcDXtOc1YmYdYlHzn47Nvy5zwsF3zdM59tfpyMGc5aV95qv4KACi\n", + "9kLSaOh1p0YYbT90lrjyd5QWbW0g2p+4UhX4DNgJdALKiyuvAX87DvuXvgE10rMfsyeeauJKvHFM\n", + "WgCXn03w+2Acs0tc+RmNNR8VQDsBwWarXo6adMoAzwAf5/Rj/BkgrlwCPAZ0NI7ZV5Ln9jJ3PYSE\n", + "JJGUniKT+opM6SkyqXg529MOH6QsAM13wdtfwNaX4YlpsLcaBhiOTpu7AgeNYzYZx+wEmgMXoFpj\n", + "ENg0BAauBkinF3OZxDTTeE3arJq3ZjTgMnGlZV77Z8HffJV2GIDfk2HMOHhxB4waD9tidwMXoYL/\n", + "d3FltLjyD3ElyQpEIOueX1BH5pRJY0P07/wO3Itmev6G8vM0rziOO59MJ1s/BsCaVS2ZBdwc4MXn\n", + "KvgtRqFmpZAhrkSKKzcCi9FQ36eBM41jRv1JhX4b4B3gcuOYdSV+fo+d00OwyCNhZfVMuCfQ8MbC\n", + "ZDr6bPw9WV9rDFkhzjcjW+dhBixJ5XuUkKwvqon+CowFbgLeMo4ZEey1qsO27inmKHGlP8qFc7b/\n", + "VD2v/bO25UwkG7AGZg2ybQoavnke0Nn+rQTMiF3LjvN/pPstsdS59VJ4ciq8VpP9q1oRTjj/BV4y\n", + "jtnuf3/r5rA5L0klDR0km+dk7TzlurUvh4DKxjEHc2wrB2xq+BYDm2ylfzDZqj4eHVTYbwAGA9+V\n", + "lK27NCCu1AFmAvcYx3waUltByk5P8HsIGj1FJo0Pp/tzneDMbdB7ha4PlOY2mIHDRvW4zdnSMI6j\n", + "vqiep3z7+waSWCF6Tyzx8y6mzIFWNENt8GOBz/wFY6iwgnE88FthzEj5DQx5nKcW0Ln6b7wg9am7\n", + "PQ6a74St8TBgPsyZzQ8/7jcXFKLP84HHjGMmBbD/BuB8H4unP8rcJzPa/UTjn+dQzbcukMFfXIkF\n", + "bgMeABYBg4s7dv10gLgSD8wAPjCOeTHk9oKUnZ6N30PQONiIaq27Q8Ie+PuCrPWBJqz4MkHXV4Bv\n", + "GsFt8wrOdMzPH5BtIDFAOlz7Pcenryd1y2X8hs4EnhVX5pE1COws1EXn7I8yYA4EFokrXxnHzAzo\n", + "uID9GifPs0Vc+dzE8FpmGMQfhvM2wNM/QtUM6AvhBbeSrc8+1s4CBT9Z5p5TBH/jGcTGNqfawYVw\n", + "+bXw5UcwLDPvZ2h5dO6y587i0fkLQFyJAMagRHkvlWZfPBu/h0JDXCknrrwx60pauFPg89FQxy+a\n", + "OlCa2zLRxD52AbS9VakFfHPPYBk868CgRyqR8EQ3OGcAZAqM3k/EmfPpaBwz3jjmb0BN4HXUD7BK\n", + "XPlWXBloo1SCgp1B3AG8bzXZIoe40g7YsKM+VW5aCGteg6Ffq9CHoKiFRwHtxJUmAey7jTzs/E1+\n", + "JW1ObaVwCD8BH7bS9afkNrhSTVx5BmXKbAx0MY65+o8i9EP1ZdlZ1hB0gL6rtE1ZnsbvoVAQV/qg\n", + "CSkT64zkpm+2Mviq4BJWbom8m/YVV8KvQ6G2X3zJJiq31JDHwMjabNbj1RVuo0PHePjbbzD8Cwi3\n", + "n5a/ELKsoOOAcbbIRU90JvCSuDILnQl8bhxTqAJ3xjHj7L15EQ0RLRKIKw1Q7bAP8FP9d7n3wCb+\n", + "VaWQ9zyX/h4WV4aRpX3nhzwdvIePknHJSvg4ER78Ge5OgX4LId3oQJSDR2cMGm5a4s7MUFBE5Gv3\n", + "olFXnYxjjhW0c3HDE/weAoK1Mb8GJAE3GMdMtTS36fklrJxCXdD9l+kkcw2wt9JPPBz5E3fX9vug\n", + "+tKIxbxaCXp1z4+szWpQnYC/o+F/08/4hbXzfqV1mRwJ+nlpwzYJ6FPgU6up90IHgVdsqKJvENgb\n", + "4G26BzX5dDeO+SbAY3KFuNIQDWnsi2qJtxrHvG3v+YEiohYeCvwqrjxRQAZsnoJ/Eww5toyWo5Op\n", + "NX0ElD0OFzdj6/IIPrYDy5Vo9EqSccyWIPpY6vCZJDeWhxuugGnvFI58zSoED6Cx+qdFprEn+D3k\n", + "CxtGOBDlJvsvmjV52Lc9v4SVbNErVZbBxQ9CtaPdmF/hedrse2rbDGOSRFanwN3HiD9nHx0qLk9Z\n", + "SfruNTD3CGSeStZmNcib0EiQ46hQ+adxzLakVEm5M4dmFqg2bCNWxgJj7QziElToviqu+BzD4/OL\n", + "tzaO2Seu9OeYjJH4botIrxJeWJppcaURmrTUG3V6pgG9jWPm+vYpKmph45jfxZXv0NDO/O7RdjRr\n", + "9hQsNmZCsxi5Y01vPkmpzLx9a6m48EqqE8ELaO5EE+OYXaH2tTThI6ebUwvKH85aH4hJ0tJMDAN6\n", + "GMdsLK4+Fhae4PeQJ8SVZuhLG4FGdSwuXAuWBrnbE9D2LZjxGIz5LJLMy9uZ8RMM+GWCSt8pMLYL\n", + "c3+DCx+FDv+BH/4PFsdG28zU3qh2fw5aOvBG4Bd/W+liYya0CBOSazOyUhq7zX4V+oXVho1j0lF6\n", + "39E2CuNSdBB4TVyZig4CXxjH7D/l4NTEslx6PJzuNbrx6Ud25S3niZy3FPY8ldcAIA0a3MLhWi6R\n", + "Xatz7MhG+s5dSqVjcUD7YtaUhwAjxJU38gnt3A7kSfGwPMN8Ia58NelumgAVUP66K4xjphV9d0se\n", + "vqJCc2tBO78nUZBfRVypB3yOVtCaV5x9LCw8we/hFFjGyEfRqawLDA2O4dBmqK47H2bdCxk+/2lu\n", + "zJs2qWlHS/joa6g/BXreBb1WJKPMi3OBEcCVial0rQNuPET1TJVscePLHMoAW4GziiLxx2a3fgR8\n", + "ZOPWL0MHgTcsP89Y4MusKXydQUz6tAK3tYHEMbDkGuDtaHiyLWx7NafpSlxpzNyKb7Lv4m7sGx1G\n", + "3Fa4tk9DtteqxrtlbzT7VxS3eeQnIB3oDkzMY588TT3iio9HpzWaONYQdXTfgSai/eHhI19bX4uE\n", + "e2fpuoJmkuJKebQQ+ovGMeNLpqeBwxP8HrJBXOkI/A+NvmhjHLMp2LbKszyuMd2JXXeEg5RlOYNI\n", + "pxe5M29asraYZxNo+SG0fgei1x3nkMwmijOAE8DyxFS65uVoW5LKd6hz9c7iyPa0wv0D4AMblngZ\n", + "cB0wVFz5HhhL2JWxHIuBz0ZC+6FW8ANyAkyW6cpG0zwB9GRW0j72jQ4jeg8MPAfmDYRpT8RBr9tQ\n", + "jbHYkCO0MyDB78ej8080Suo5dEa2DmUOHQb8U1yp7yuI8kfGYmMmJIYJK85gfNnt/PIGHMhvJimu\n", + "RKKz0inAqyXZ10DhJXB5AE5qKM+iH/A9wKehhJwliaS0Q4a/i6npW3cNjZhIva1pbB+QQ+uNALqz\n", + "L/IxYk6cw7pqu1lYYwMrDz9tji/92n5I/QEn+S34eSs159SCyBPQajuEGegJuzZ0Y//W+pSrPYJ+\n", + "JVkVS1ypiN63vrzX/iLW/XKqQhV1EXTbChV276DJthVAIkotPITUq8fDWDWlVP8VttuYSPpONWZs\n", + "12Lvf3TzPtSIH8Pm2gs5dnhvTp+Evb71QEWyeHTKojw6Y32DrLjyKrDHOMYVV14AIo1j7ivu/pcE\n", + "xJUE4AfjmLoF7Ceo4lQL9c0UK92El8DlIWj4h2ii0ReBRrHkiTow6JVoU3NQV3h8GlQ/CGNYQzc2\n", + "bPnBHJtgz9sUtdvfCGyiwrERQC/z0ZZstnMb/vaWuPJBhcP8BjCvFrycDGll4aI1ELmGKtvbUuXn\n", + "d+CVYq6KlRP2fr0LvCtDGl9D2ZuHcOS9k5msRA6CqOsh+gWot6MKyrkv9rrrUX5HJXxXfFLoQ0EF\n", + "YooC6oDv9CIb/lsGE362rj0lmioNiAGW2P+fRs1bOX0Co1F/wdOo7+BXceXponifTgO0Q82NBeEh\n", + "u2/n05ljyBP8f2HYEM3XUe1TQzSLpl056xzqJXaCq5ZClN/rXyns+CFxZQAq8Bui9UUvsuUY84Vx\n", + "zMGeqbI+Zv9lAAAgAElEQVQSaHD7XLh9LqytqPTMg1tBeln425XQfTUJZTbjiCvflTSNr9m9aoxI\n", + "Uhr0GIW0LUf5DXD+NGj1OuxIgm+bbOCS5W1Re3gi0IUui5ow7dpMP35+COu/EbO+ULH5wcE64K/p\n", + "DdvPhGlPnIymsuarfiiPTiYa2fVRPjPBWWikSyvjmEXiyldo4fPni6q3heF2KmIUKPht7YK7gQ42\n", + "QOC0RciCX0R6oFPWcGC4Meb5HNuroHbRGvZ8Lxlj3g31vB4Kh2zx9HLgMNf+tIqmXIuGaF7vH6IZ\n", + "0nk0EmjoyvbUmjIK2udwTW6sRweUQvg5YFJhk1lyVjlquBemroLr9sPDn8KyqvBNAqy+gObATnFl\n", + "GvCNXVYbx5hAyyIGC60x0HcBZnAXjm2Hne/Aq9dAo2+h9WMVUefzBNQxPNyM3/u6hLVIoexFj1K2\n", + "THVi98XR+bdoWqS9bfs/DaU3WFoQqVrhYR3wXw+FS26DgWfDuPfgCI1RP8+v6MzkVWBVfuY/6y8Y\n", + "jfo9FqFMqRPElX8XxQBcRIlUwaI92cotZ4e40gENX73YOGZzMfclZIRk4xeRcGAFyoi4GZgDXGeM\n", + "Wea3TypQ1hjzmB0EVgDVjcmaBnk2/uLFKfH0l94KkcsOs6DM/eaXLUOL5Bzlm/ah86GXaLmtHrPr\n", + "rqoxdffYFPbd/PYJ6vv2uTGKXTPjuWf1DvNRPk0VCH/GyTRI7FuBKmMugTUVYfAPWpylF0yamMqN\n", + "6LvZ3S6H2VF2GdPObc2qz2typJxtceBqmHlPUQp/zTye2P3ULSmTSJ14M3AFGh3UGo3+GAtM9g3A\n", + "1lZcD2Xm7EIWQ+d0dBCYBiwMtZ5s9n4aOPN9uPghWFEmnTabLzCO+cX252u0HuyX+bbniq8ObgM7\n", + "EEwGPjSOeS+UfoKSAk6A7i92hNijcOccXR8oKWCwsJnm+4B6xjF7ctneEI2OGmAc83Vx9SPXvpUG\n", + "O6eIJAOOMaaH/f0ogDHmOb99bgNaGWPuFJGGwCRjTJMc7XiCvxhx8uOusE41uqkOzLkDzKWTjJlQ\n", + "6A8m53R76jnldhxKzryWzSmRfPcM1J4D7e7PiMvYxplT2VVlH7uOHGHHpuAzTPPti08L/L4BPHIR\n", + "rAvjiKwhdddkv/dQBWkSMxp8TM2EppwxU/nwR36DmttTgroXeaEg6mW/ftUgaxA4E/gSHQS+NY45\n", + "kq1NNc2dR9ZgUBv4GR0EpgFzC6tZiySlIB1exwxvcHJllSt3c9MX6yh3PAy42ThmsbgyAvjZOGZ4\n", + "vu3pfV4K9DeOmSmuXIxq/q1C5ae5vKxMi76Uzisrwzg/fqi+MHWsMV1DaTs/iCvNga+MY06pXGYd\n", + "3z8DrxvHvFFcfcizb6Xk3K0N+If7/Y4m2PhjGPCDiGwB4tEX3EOJwk7n9zWA11doOUAg93j6vCGS\n", + "lBJBtX9V4vzmtUmLviR+KRO6Z3C09mHDV58L8Vs0HHFLO5j775j0FSMmzzg6ORett+iQrc7pOqKr\n", + "DuPQ6j4s3N+RAeJKF+BR45hFVuj8JtJ3G4xtSmQGVFuMCn0o7L0oCIGWlDSO2YaaCN4UV2qiFAcP\n", + "o4RvX6CDwHfGMUdtItdou/iqb3VCB4HXgcbiyi9kmYZmW24iIBf6jCZLPyR1Y1uWbazKlOWb2FNt\n", + "C7F7Yui08Cjljp+N+mF+FFf+jeZS5FWQxf96jLjiK9AyE/gW5d+7GDW3BQVxpW7MrZx5+RaYPgKi\n", + "/fxGQRDUFRa52vdtvsunqMmyxIV+KAhV8Acygv8TWGiM6SoijYBvReRMYwIq++ahSJCWZb8/KfSh\n", + "MFEjPg32OMMSdkgmk9sP5bsuD3LVvEiSx58tM471hMor4a0FsN8X8fbpOZHSbV5z5ptm7E8vLmdc\n", + "bhQG4oqDUk1MsrQET2pMub0Xx2Jg89l+RxR9BE0Q1MtbUQH+urhSGx0E/gmMFFfGo4PA9z6/iKWU\n", + "HmcXH+VxR3RG8CzQUlxZCEzli1qHoOffYXhDKq6BTs9D4g8XsTVqPM3TmprRM7bYNqLQgihNjWNG\n", + "2Hs3HKVsCDQhazQwVVy53zgmU1x5CY12CUrwiyudgTFygI+jPqNLdIgEdUGgPWrG9u+TAG8BB4AH\n", + "i/n8RY5QaZk3owkbPtRBtX5/nIsmM2CMWYMmeTTN2ZCIpPotXUPsl4dsKKgUYCCw0R/Re2BAB2jx\n", + "MSfenc/+H84k5pgdV3Y38RP6AM3KH+eHNhl0b3szcV0mQvdkDbUsxvKMCqshvwE0QZ2U88SVf5eL\n", + "X7CoLNdnZN+7sPei+GEcs9k4ZohxTCfUBPQr8BSwVVwZLq5cbPMb/I/ZZxzztXHMI8YxyaiGngpk\n", + "sqPu/TC8IbV/0VlZenUYsjmMt86P9qeEsD4GH2snll+mOyq0rxJXHrY27/z6vhLYQhbNw2igmbjS\n", + "urD3QVy5DdWq+6e/ZwbMgntSYFJfmJoCk2bBoBJw7Oam8f8TaIlyV4XkZykMRKSrv6wMup0QbfwR\n", + "qLP2AvRB/8Kpzt1XgP3GGFdEqgPzUJv/Hr99PBt/MaOwFZ9OPd5y6WCg8URY1RMQutCVh5jHlVya\n", + "cYSPYk4eEHEfJC+BBiegTBpnT97P7I1aoqu4nXG59t+V6mW3M9yUI+WaL+PCti5txjFiWcGhjCNs\n", + "emGP2eKWZH+ChbhSF7gKNZk2QrX9scCU/OLGTz4/yYQy6XCkvG6ofcFBBv7wDmoamm4cs93ONn5D\n", + "HbT77Xm7oQlbGWjIZj/jmBX59PMhlKBtoN/vM41jbgjwOsugkURd0USolYEcV9SwyYX7gZo+Wg5x\n", + "5To0Kq2DnaWVGkrFxm+MOS4id6HaQDjwtjFmmXXoYox5C31Z3hGRRegM42F/oe+hZFBYs8Op8JmL\n", + "BFZlKexRHGQc6WtimDLyCCkdIDYZmpWnTDLs6gRb4uFIOSJ3PojqCMEXWgkFxjHbe4pEDqlE2H3d\n", + "01nScy6pU6D/AmIuO0GHku5PsLAa+CsodXR9dBB4BqgvrnyGct5PO1ULtc/PhGcJfYA98iuwEWXo\n", + "HCaubEcHgRUoh7xvQNwOlEdn8LcDM8SVZ4FX89B4xwALxJU7rcP5f8BacaVOQTQg4ko14BNU4J5T\n", + "ylTGLYCNfkK/EzogXVDaQj8UeJQNHgJCblEqYbHXZCYe/GbBCfY7vul2XmGM3WnPJDtbLkmN35ol\n", + "WgGdqq/mybDqVAV4cTKMaA2by0H8TyyZ25uWoUadlCZsSKFvJnAGah4ZC8wwjskMJMrI3quWqImm\n", + "D+or2IDa9uejGbsVrQO3IUqJHQ783ThmVS59mgE8Zxzzlf39MmCMY/K0iVtz0OdoYt9TRZ+3UDiI\n", + "K7cAXY1jbhRXGqPhtDebEOstFBW8Yuseih3ZzEVxu2K4aH6k+Wxf61P3yS5gGtGXV5lIL9IZAGuK\n", + "0y4rrkSjkWWd7JKM+qJmNP2GDhOX0bL+Po3lMWjW7xUppGVUZinw8J+BSthy+l+NDgI1Ue15LP9q\n", + "Xo7M+ncFYu6zzss5qGMXdBC4DjXp+qKGpqNm3qeAfwGvGcec8IX7bjqPhtvrEFf9QwYsNmaCNVMt\n", + "ABrmRmktrlyLOmr/YRzzcZHdkBAgrgwFlqNJqDOBl4xj/le6vcqCJ/g9lCisZvaOccxZp2zzGyAi\n", + "2BVno3oOhlgtKq9+VEYjWTqjgr4Vap+eDswAfvIVAskt83MArPk5nHuWPUkFNDNzMfBYYWsPFHc2\n", + "cLCwWqpvEKiKbxCAmQVp0+LKTajzsrv9vcW21QToEr+U7s1+oVJkWQ7+2o2oQ3Fsrj6Z51MW8cgw\n", + "SNgeC03vhj4vs2buMR3sxZUPgQXGMS/5nSccvffXAn2MYxYV/Z0IDuLKHDQi6WlglnHMw6XcpWzw\n", + "BL+HEoW4UgcVHmeU4DkFqE+WNt8ZzSWZRZag/8VoScVc4Z/1m3MgEi34cjsasTEBcEwAVZNyN6MU\n", + "fTZwqLCkeL5BoBIabTcWjfc/ZRCw92MjaupYJq4swBYV8Q2i/4MEQQvbtzufzEXnEt5iN9zwK9y8\n", + "CG6+HAbOg3eWqnlPXGmDZvY2Mo45allhP0JJ4PraENXTAvb696L9jUT7V6qmp5zwBL+HEoVoofI9\n", + "QHRx2catJphEljbfCbUp+4T8dOC3omZBtMLoIbSYyAjg2dxS9U/u7/NrtH1Ls4FPMmwWbTZwUcJm\n", + "o14NXIMmVvoGgV+MY4zPXLMqhWYHY5DKn3DHklQGAUOMYyb46BMuv1bJ8nrYYOHzqrN/29WUPxQJ\n", + "738G6yrBV00gYoxm14okpXDrppEsbLiDTdE76Te7AWVPfA7cX1jepuKGuNIOpdNYh1agK3a21MIi\n", + "WNkZahy/h78orFadCcQWRXsiSSkS1uNbiem9QKqct1IurzAHpS8eg8axT0SdjrWMY/raGPcFxUF9\n", + "axyz3zjmCXTQiQdWiCuPWP9BLp2Pi+KihyD533Ak3m9D0WYDFyWMY5YZxzxtHJMI9ESrcL0LrIu+\n", + "TT5pUIf/ToDuU6dT70gj6raJ4rUyu4nAZu/GQ5QAD/0E/frAsDbabtXtnFj2BgyaDX37wv6y8F0D\n", + "2BPDsZMzox9GV6LD/mbcsKoz359ThtTEiaeb0Le4E41A6306Cv1Q4NEyewgFu4AqqNAoNMSVSkBH\n", + "Zla6iXLdLyHtgygOhWkC/tf9tjHjpzvMzlWjirLDhYEN17vdUhYMBlbajOD3TVbxkShuqNyUiObw\n", + "9k9wqLJfC8XPp++PYCmLjWOWAI64kgokVd3MuJW9qVMzCi5cA+1/h9Zn0fCHjcjmyir4fXVoO25S\n", + "CoWeN8D6CnDgB9bebig/7GcSeq3SQeHoCTJnXck6RtokwOrPQflNMPlF+OXear6qZMV5bwoLcaUr\n", + "6nN4wThmeyl3p8jhCX4PocAn+NcXtKO1z9clu9mmLjCLeYkNOPBRFNf2hnm3wqpecOzdGuxKuQko\n", + "NcHvg01UuspS7z4PPCCuPIaam8ZT6cAq3kg4yPHKfiReJZsNXBSUxT4+o74iv4+BRi+eCy+dC2Uy\n", + "4YeGELeNCkCSuCKJfvTYjffAzOHQ/Ho5caBhWJlNozIfSDnIHXE7ia70NodP3EX0wUb049wta2N/\n", + "fo7ms4YQO7MyByP+j+UcIf00mxlZavExaATTV6XcnWKBZ+P3EBREklIY8Pv7zGy2hSUVt+RSri8M\n", + "NZX4nLCdUAeZzzY/A1hkHHP8ZFbpHa1g3PuwzRcoVDKlBwsDO4CloIyTddHM2RtJTewRSmZ0qOgp\n", + "MmkidD8UAZ+0gL/9piUpg8mZ8LVlgB43QLe18P5ZsEHYd7AqEcA2YGzVYbEVGmyO7xdN05iDRLEs\n", + "4lYO9r03nVpb1hGX2cXYylviSiywLWxHmTLV9p8oM+fL45xhU7KuoTyTqLFqv1neJK/+lCQs8d0s\n", + "tHbzK2jewpH8jyo9eKUXPZQYTtpq92RUJrxnZbihJQxIkDPPSOSKzRGokD8XZXScAUwGngTW5O4I\n", + "TjsMBiqsh331/daXrKkkENjkpR1AOTQ0sivwGalLHjPO4lJz5MZDFMCuGBjaHl4/G96YAHFbCp8l\n", + "7V/s5o0J0GEARPwYn3EwMSKeT9oYIg5W4bzFXXZee7TNziPlolnSGeYPVJ6mUX3i6F0nnrO2/Cyu\n", + "pBjHrDOOOSiufN1mWFTvy5IP0OY2+OhTuHAtjGE/HZBqBfeq+GEJ6saj3EKLgGWns9APBZ7g9xAE\n", + "rK024x6I2WXXDW/Evg6Pw+YRwNsoH3uAttFNQ4i5sTEmrCGHK9h1px9xGoC4chl6fbcYx3xhhcWd\n", + "KBvleCDVlEIFJp/Nvc4BmDECRraCS68Ds4mG4koVXy5DIMhGdb2H6CNjqyXu/r1nZbpMEk4Mgc0t\n", + "KjBq4NmwfTO1nqxP4liI2amC34TB5x03cNbHnwI/iSuXGcfMBUbFIVc9OQ0uWwFV/QJuo6ulx4or\n", + "g1Ee/yXAclNEFeEChZ2hvouGrz6JPtM5+R3zR4Zn6vEQEGzWpdrmh3W7ic3fx1J+A2SWhfQadq/g\n", + "TTPSscbdtE0bzGu95peGqSQQiCv/QIVCb+OrTOVL3IopE8eF82px5uYqhPMG8LxxzL6S6ltuNv4b\n", + "oln3yc38eqQGyYADDAuGSVKkxy6YVJnzn9KB/us37ZaeR2FimVOP0DBWcaU3mvnbH5jc7rlyh+Yc\n", + "PnDKd352+eijc+47NBitQZyIks9tImsg8C0rimtAsANPV5SD57C48j7KeZRv4ZnShmfq8VBksNpP\n", + "C7I7YqPx2eaV2CuZ/fVyHKmmmaCiSy7evhn4wZixfYr4ckKGvR/PAb2BjsYxayFH4lYG8AUw7dr1\n", + "/G1ca6oeXSmuPA+8URLaazYt3ZecdojXDg81E8SVVijP/0BLmjarcK3Hq5yYPQjK+vOlmWMwcOOp\n", + "/D86UzOOGS+ubEW5dwavTDix5prFcY3GkH5SUF1L7PFlSZnHgf/4EaFFAo3RdzAR5Q16HGgormwi\n", + "+2CwlBAHBHGlP5rPkOzXTjvUxv+nhKfxe/BlKLYjyxF7LhpD73PCzsCv0HZ+hF+JLCGX6JLVM+Ge\n", + "/IS/uHI/UNc45t6iv8LgYU0576LEZ72NY3af3OZL3IrMgPOfhG9fUPZLrav7AMqa2RqdJXxYkrzt\n", + "OWGd0tcDL6Bsuo8ax+wI6FjpuRMmVjl1S89dsOnmgpza4kpDjoRNZX3tCnHLI+KaLRBiyeQgGZnr\n", + "CBu9O3V7BJo9/O8CrqEM+l4l5lgaoCYa/8HAN0PI10YvrlwIfAic56OZFlfiUQd2hdM0v+AkvMxd\n", + "DwHDVmo6lyxtvg1KROWLuPnJaEnAvNvIg9/fFxGyOxoqHIZw+3oVFF0irgwB1hrH/KdILrIIYPMM\n", + "xgNbgZtyapUno5E6vgC15sDHPl6xLJOXpfF9Hk0EexSYWJosoOJKOZRU7SaUf+a/BSXBiSQ5kPw4\n", + "DPMr/DLgGMwabMzigOoYSHy377n6WDdqz4H/zoNdiXZLyiRSJz6JsokmBCNo7YDQmOyDQQt0QNjA\n", + "qSajlcYxR8SVROBH4GrjmKl+7XVBWUWTC9uXkoZn6vGQJ8SVM8geVtkQLZozA2VVnGWcwpXCzIvf\n", + "3xddMvg8GJ0EVy+BaxdD7O8FRpfUB34oTB+KE+JKAzRb+Evgkdw5WtIOE7UXzn0RRszwW58VjWQc\n", + "M8MK/8uAl4CHxZVHjGNmB9qXYBOzcoM1pzwoWjz9NbLMPzPyPMYsdrV+cM+7CIuJJfJABEe2DDZm\n", + "SeDFa9KrhDPyfbj9TLj2chjxM2RUAeKijWPmiivrUAqJj4K4pqNkCfWTsANCE7IGgqtQX0cDazKq\n", + "hUac1RBXktAB4Sh51Nj9M8HT+P9ksPbo5mQX9LFkj59fUFxTWJ/GD7CiMoxJ0gFgTTSHj8bxOhoq\n", + "Nz+n1iuu/Ipq1QuLo1+FgXSqPoiOe19gdpNNTK2zJi+mTZGkFLrzAWWSK/LlMLs2O8d9tv21mtPN\n", + "aHGTmcDjiakk5CfU80jMKtB0FtB1qvnnajQnYQpKS51vcRHLnzQbpWB+L+Bz+cxikgndnoAWn8KH\n", + "E2DPIJ8j+BJ0BtK2uGdEdsY7DViJzgZ8s4T6KC9PLFp/4CO73TcgnHbwTD1/UVitpi1ZQr4jyijo\n", + "s81PR1/cEnnQuQmqW2DNhLN5eVsKtdE0eNDMyNEoDTLAPqC+L+mntCCXVkqlRcYTfDEqnJWXwokI\n", + "cjJt+jTwsAqUm3Q7Z8tbHZZk7q2zN9BoJEtwN0iO81jCYszU7yhf05Je5BTqvoH0+wYQfRySN2kt\n", + "gaIsZiOuxKHO0wGoX+L1/BQDS172FdAiP/K6bMfk9Au1fQu63ZvJL/EPmyk7XrEKy2LgLuOYYpv5\n", + "2fN8jJaQvMn/u7C+rqaoD+RzlJcoEU3UW0d2/8ES1O8V0oAQ6mzOE/x/EVjmyGSyBH1btEyeT9D/\n", + "ZPyKZ5cGCqA+FtSncI1dDqIf2d1AuVK2f99BRuS/+XB6WWosgiZfwiej4VgsvhBF/4HtH70g5hjs\n", + "nxycBn5+vHzf9ly6vXMWzH8L6tnSJBfDvHDYFQ9RmdDqU6g4Kgme7AYVD8E9s2HcEqZ9etx0yf8M\n", + "hb7+psAQlOr6LuOYKfns+wYQYRxzW8Dt5/QLpcyaydl77wJuN475zFa7utI4JqWgtoKFuPICWqjn\n", + "4twcv+JKRdRRXMHnjPcbEHL6EOoCaznVh7AqkBl1UczmPMH/J4Vo4Wt//vkENLHEp83PMqVbkzRo\n", + "WO3rHFToX41+NKOBMcYx60q4H88CfXjz4r3s+OYcwo7BZQOhyjIY9SUcvGuqMWO7+jTw1ZU0o3XF\n", + "a1D5UHAaeF+RKWOhy/ZYqH4wa/21cGi0rUv8BFqhBJTzfkJjeLUDTKvBkWMxPIs6Z4uMRMwOzH2A\n", + "f6PmqAdzS0iz5pKlwBWFDw/N1k4bNBD2ZWAoqllfVNhCOAGe6zbgfjRsM9eZio3yeco45rwA2osi\n", + "+4DgCz+tgw4IOcNOsw0Ivnfpg1bQezksOKoOh2WwJwPmBKL9e87dPwHsR9eM7PHz5cjS5j9A7fOn\n", + "pb2xsLAO05niSg3UrvoKagqaLa6sRweBscYxvxdXH/zCNesA57Ij7EMATkTC5+/A+U9B/44wtrpA\n", + "lvN6QmO4b6YKfQiugLwv29Zf6AM0huilVWFQT0iYB/evgFeOa4TUpSth/ErWLG3Py1t70RpYLq58\n", + "gRY9nx/UTfCDnXGNE1e+AR4DFlkt+T/+751xzD5x5UHgv+JKu2DpsY1j5osr56KBAg2AN1Dh3D/U\n", + "a/GHuNID9a10KsA8FbBj10Z5LbKL/7miyRoQWgA32P/PEFfWYAeCtm2os2gzDLwUqi3RWpaDtYlK\n", + "QPfCkuwVBp7GX4qw9vk2ZGnzHYEDZI+fX16a5o+SgLhyH2rfv8f+jgDOx5biQ7WlMcAnBYWZFgR/\n", + "m+quODKn3UG1zFiWo/beQ7nmKHTosJMLfgkn0vTokcq/fM5rg9rbITiNP7epfn841A+i20bClPow\n", + "rR78ICBroNwhDhw5zq41dXl366W8ahxzQLT05ACUYmAD8CrweVHVKRBXEoD/oNm0dxvHfOe3TYBv\n", + "ga9CDcO1M4jPUFLuZCCxIEdzIdpuBXyPlnX8qYB9P0XfsyJnhbUDQjPszKDiem6JrUi1zeWgyg44\n", + "fyck7oR2WyDFlq4vMAzaM/Wc/rAx1MlkafPtgNVkj58vcZ6X0oa48iqwPrcEHjs4Xoz6Ay5Boy3G\n", + "AJ/6J1MFAn9Bu66CcsiHrWUf33DD0uPm65PnzCVHgdQlEcDbNb/i9V5zuSFn3d5gC8jn9IekQ9Vp\n", + "6rfJhovK8u13j/E8WvT8PKA9mnsxzS4z7fp70NnLG8DwQJ2vBUFcuRQdVOaj1bI22vVNOS6/8Gan\n", + "+eypIaHUG7bPejj6vEcXRTKfuFILvTePBiLMxZUNwIXGMatCPXdBSBJJievAO41rUC1mFnSuBkuq\n", + "qjLxzPe6T1+0clme/fUE/+kHcaUm2cMqm6DTSJ82P9M4Zn/p9fD0gCU3e9c4ZlwB+0Wj1aKuAXoA\n", + "P6PmoM8DuY8+m+qKynB+P3hsOtz9S+DauuXjH1fte8a2nU6T3JzXoSKvgvCzYGQdSPZFf6wvy9Dl\n", + "Tc5ozJYGtxJZtjLR+8vRdsVmkg5MQHlu2gAXouUUh9hiKyHB3v+HgEGoWe5lUhMfpWLVxwmvEsmu\n", + "pqjMHhl0vWE7i3gVncG0M45ZEEJ/Y9FB8TPjmMEB7F8NDfGslHveRtGj7F0yqe4S6jSdQs2voGLO\n", + "7Z7Gf5rDvrBNye6IrQD8RJbpZv6fleY1FIgri4B+hfnIbQjiJag56Hw0Dn008KVxTK4VwXzO1MMR\n", + "8HMd6GbdxwVpVTnO2xiYBIwE3OIww+USFTUrGW74nx0MBLiQ+C0/cIUY3q158sDw/ps478tJdNlV\n", + "FX3/0tAw2YbAbyjf0IRQhZpNbnuFo2Fn83G3yqz6tmzW1sdRS9hzIdUbFlfmoN9TL+OY6YU9vkUZ\n", + "uWTb33g7+hAnWo5h0e+BOEpd6Qk8YBxzYZDdLjREC9jfnphK5TwG/Hxnkp7gL2KcZF0kPiq36asl\n", + "kmpNdkdsOtnj55eXlObwR4UdMEOK4bchrr3RQaAjGoc9BhVyJ7No/ZPL/FFY+7y4Uh0twr0QuKO4\n", + "kuHsvWnS+Hs+bVeNxCn14dv31Q7cnXZMZg40/QIiD8Li6+xRJ5kxfYl856GskxejDvTDaEbyS8Bc\n", + "4xhT0LueZ/9anTmXrofasrMFTPo37GtgtzwJrAipiI64cg4a5hsODDKOGR3osUkiKZmX8GGtSlSY\n", + "+KFWEAuQL+opIMY45tFg+10Y2MCCPUBl45hD+YVB59mGF9VTdMjVwVf25gTpUbk1yXvKoMK+PRqy\n", + "NR0VMncXZ/TJnxg+Av6gKYytmed94H3r7LwCuAN4W1z5Cn0+kxNhZn/oPAJifMcOgDUblbqgMOfb\n", + "LlqTdSwwXlzpm9csozDwi+rqihaW7wIcPVibshcth8HfQ317l474atyfMQuO+te71zKGVuHwhRIO\n", + "tW03RKNlrkerTB2Ra8stI6pPXQ6/70fCNrCRSBIFCv/fmqazdCQkvwKdnyErezmcUIvoGMfMFldW\n", + "o6GeL4gr9dD6t7lqqv6DV1SHem2r1tsY9/57hpGtoP8CGAYJKRo2nN81tUPfo6BRyISsViiR3CHA\n", + "F71TIlTknuDPFbbQSLXF0GY41J0OVVY0Yk/YA2is8Yuofb7E+Nb/xKiPOnaLZOppHb7DgGFWM78K\n", + "eIhMPjx0JSZxITGPr4PIE7AQMlbDyGDs88Yx6eJKb+ZW/JpFTX6Xf125hMyMtMI4Nq0wboEK+K72\n", + "bwZqtpqEOiTX9xSZ9PccM5Wy2BjQmJ0BVS2z93cNaot5XFypAzxKg0O3cfnecGZ/B2svQA1JwxKI\n", + "ueApceX7/E2TaYfJLAszHsuxfmFGERXReREllEtGZ1gNxJW7ckYsZVPUmnzF4Y4zkLd7MixjGlN3\n", + "pfLHvAcAACAASURBVDMzHmqkwXFNTMsP7VD/RVAIou5xO2BesOcLBZ7gzxXxUQCEH4G0mjDxNdjS\n", + "FjJv/NWYsY+XcudOCxQhcVh9AijWHgysZv4uMLXJ93zUog4tX+wDB6LgpkVw72JinttIh6BPkJp4\n", + "ESQ3gGHlUbZTrLbcHuok5zSdSFadg652OQ81D05BKRAeMo7ZkPM0/qUQfeuOs2Kr0A8Tu7cmB32V\n", + "CwOvWmYcswm4U8pe3pKklM70uBfm3g6/3KU7VCAR2G1t7b7IoVnGMX5ZB5uGQP9WMCLLz0C/I7D6\n", + "hSIqovMVKvwT0Hvlm2Fdk32GZRW1Ggug999h1Jds3NeBkbRnzaaskPz+KoRTcntPbfRPJBoSGxTq\n", + "wKBhkHDuLTDpAyh3pMCZRjuULLHE4Qn+XJGm9Ltb2+pyEqdfDdjSQBCaTa4QSUrhgobPUC4zXkm8\n", + "Ch8GaGP+z0CTfxr6/fX9Xw5Yv6cp1Wpvh4d/hkoZsD0O7usOS8vRzVJCj0YFWyF8MlbgNPwWNnSB\n", + "zDKoebDPw/B5DHICqi2GhAFt5L4yK6lAM9SkNRWlez4ZFpkfciuysp201wxzodKGDzm2dx38b3tQ\n", + "VcuOHs5g/kCYPwDC/VwVW8rOQH0m56JC92ngLEumpwNB9YYxbN9n1KYfDmQCB3ZTRCULjWNOiCsv\n", + "o9nDl9qQ0jeBaeLKJVnUJFZRa/UBfD0UftexvA6x7IiFqgd1HjMCYvIRwu2xPo9g+xsPUZkCs2tD\n", + "rF+KZT7JfW3t9ZQ4Qhb8ItIDTfAIB4YbY57PZZ+uaAp4JLDLBBhBUXrYNAQGNsqrstBfHT7N5qq+\n", + "EHcUaqZBUjoJP59gsLiSjhax2Aak+T6kXByIMyH5BiJjEthaH7ivdm62ZWsOqcypgt339wy0qPta\n", + "NN1/Leq89P3eZhxzoqfIpNdzmEse+Qk61mTWz7exEzUPxYsrY1CfwLyChUB8FBGHoNNz0KcfzL0D\n", + "5t0KB8+Kodk4uGwALK0MsxOrsrBaDEePzuXYlqC04bzsv+LKHm6c3tc4ZnVh21T4veuZviqK+q5b\n", + "38lEu/jI5c5BB4L7GbC+C7vKhbOhjg4cO1oC1IKUgmzphZkxjgT+Ja40N45ZJq7cCvwTzfhO0TBV\n", + "q6hNfjnbgVEc5OY+WtT9gZl2XcRJn1JOhEzFnAaH90dB/NGsOhQA6ZqUlg32XjZGo61KHCEJfhEJ\n", + "R0u6XQhsBuaIyBfGmGV++1RAk0m6G2N+F5FcKvmcXjBm8QTlH0/Jt7LQXxU+2oL+C2BbnC7/z955\n", + "h0dVrH/886aQBBISivQqQZCE3lEBFQXitSLBXsEu2Ov1nj22q15/Kui1oSBWmgWVgIg0pTeRKhCk\n", + "hYDUEEpIQub3x8xJNsmm7W6K1/0+zz6Qc+bMnLPlnZm3fL9ba8PBujRGV503NC/Elr0cDz7FdY2a\n", + "cqRVJMcaaI3eY2P7k35XGHWfgh3nmZ7HxlKr36uGL8XdwOegDbljzFejqzy3ATtKkyLryV0yHJLT\n", + "UnlZWSoJbVzi0avcLwBxmwTWep4E0jPIjoCPf4J6a6HnGLivDWxqBmv6wptj4eRK85ZQA+gHIxqX\n", + "KnBaetRDT3xeoSzfdWWpE2jhkrkAEjJkPg0f6UvzBRDqbtsii6WvcHaMbwcRG5KjV+NF7RiVpU4a\n", + "QriHgBHmc3jBUHrMFVuugbhCC7UwrjtxP5uqt/8eeg6HTnvhwj8gpRFxYktND/xW3dDxO6+xC8bc\n", + "WZ22tU+Sq0laTPJAR2BDZaV3+5TOKSK9AUspNcj8/QSAUuoltzb3AA2UUv8qpp8ql84ZQNEobVqk\n", + "ybVvyOddPiXkiR7U2qYD5TVT4NReCGugXSE/PwXzjKZH3YF7uG/WG+St3v/wF1VzadPlzC6jM3oS\n", + "cBhEJ6HJ4zbltvOU/RVx7Qm6RFenRxJMagt7ZkHbb+CMDbDuGjh8Jk7Kpa/PY1aNh4CIyqD1yOXY\n", + "L4Tin8/5/rzWG2a1gnHToFE6dCB6xVp6H/QQG6kLbAHOdqfsMJlVk4BHcMUddK+2rsWvS4aQesNY\n", + "iJ3bAq4bAueNY8fs3qw73INQ4B9OGq75vPcDHXxltq1/now63olnE95idQnfsfuB+LKwm3pCZaVz\n", + "NkZXCTrYjd4KuqM1ECoic9Hyc6OVUp/4OG4AlYiiVs8FVzYmALdFXIknYShE79SGfm8XWLEL0sfB\n", + "EzGwxK0y/0Dwb8pS/ymP+y5tupwxoquAVWLL4+jv9DXAT2LLfpxJQKnCq+WTO5ewsPcNLN4WS9go\n", + "3eGRFtBqFgzvBYdbQnJ6a7GlkR/os88A9lcel1NBl+gC4LUTEN64uJiNs2O8fymkhUHnO+G2SZFs\n", + "3ZUQB5+77RYc159Kqn2JLIxbxsJEl+xyXENKqSSx5XxgOq7142B9gvt7ES+yPAHuj9xORPVfqf/l\n", + "HYTkRHANOkj8X7HlTtO+OZDpDzrzPwewCVg6WamLS2jaDV3vUynw1fCX5gsXii4fvxCdP71YRJYo\n", + "lZ8LQ0Rcbn/OU6poLvAAKheego3FF5sYH2xaM/jamfMXQPgNJ4DqZDhu16oXRzGGYQmwRGx5GF2o\n", + "NwztY96Bi0mw/g6TJQOASPxyci67n5PSE6jF3k4w/W2YMRpazoEeN0YB603V5hdoSoEy8w51b8k/\n", + "NyUQM1hkpi9yjN4iv5souzE0aQXfVAfa65fnegCHlTQ0B+x5MHgrXCBtOcnnEXR/G36/DI42QU8o\n", + "CffHi3BFEPHjcmiOdv/luoaM8e+NzgBqaYx5FuSf6M2q/nO023kY2ug+gs4a8qfUYm30LqwkdEXH\n", + "RssEEy/tX9brCsJXw5+CJoRy0BS96nfHLnRA9yRwUkQWoP1b+Qy/Usrl470EUIEoW7FJ4WB5FHZq\n", + "yzoLspPTcsLaU/foRhonp5FjVeU4ihHmmA/MF1tGoqkihgG/ii0b0ZlBU5V5b7QraMQYGNsK0FTP\n", + "ez49RE5GCLrqdym6ovZVseVn9CQwraRiMMdHfmUIsW8egRnlTOFbHBztZZHBMwl6vz1hhyD0RD7D\n", + "TYHvScEdY6/dUIOojJMQTrVjemf0xTSTURcZ0RRGfphD8xfPgxt+g2Zp+dMklaX2GrfPF6SHLJXq\n", + "Fx7kZJ1Qd3eRspQSW4aj+Z1uBi5BT+Z/oA2/XzKRKIXhNy7QlhTQCC4NzIJ4Xm5fIlZZ+wDfDf8K\n", + "oLWItAD2oH8E1xZoMw14ywSCw9Db5td8HDeAvxAKBhCj2VTjCtY1vjxKNf3oMEzjUK0RHIpZXNk3\n", + "WgaYIqIfgR/FlnuAi9DuoOfMSn4iLr7CxUjoaxNSI47g0DCyTqTydeOnOHtTDTSTZj00h85BdEXt\n", + "22LLTPQkMsNwvueDk1X1UQ2oZ7LqS1mZ6hFmNRwBRKPTX6NL8/+aa2nadjlNayhCu7Wk2qae1TjW\n", + "PFrHMd536pIKB3o97RiP6PehCwsfg0Ot4IZBuhJ407GTURCRI5AVpN1CjyyChxZD5Om8NEllqWMS\n", + "dvZ7DD79Kbfs78xnE8zkk7frUJY6LrZciWbrXANchqb32I4uFPMHaqOlT4tDJ2B9Zepq+GT4lVLZ\n", + "InIf+s0LBj5USm0UkTvN+feUUptEZCbwGzo7Y6xSaoOvNx7AXwvOyhB0cO8j6PZ6TB4FgS+Gq7Jh\n", + "fsDTgemGwXIQehL4Dw/9voUFPZqw7osI49KKI+TW/9ZypX3Qk9QjJ84kdENv7j9wJlEE8zHwHHpH\n", + "PBJNOTENvROY41SsOj7yw+F5hh+gWhh1xZbzKGysSzLmNYEstBZEmnl5+n8KWhshrdG3tLn4N+4c\n", + "n00uX8SwP84kidEc4xK3d8dz7UvBHaPZHelA+cYh2i14bT/oLcePjkeCFVjz4cbf4IFB0L4zVJ9L\n", + "jXydZra4j2lJ0fR5VU8c76wBlX/XoSy1TWy5GT2x9kBTWExDB3f9gVro96k4+NO15BUCJG0BVDgc\n", + "lsyXz4HoU3CX+QmUhSXTG/ix2rhUEFsimX72L5zZpiMt58DY5XDwLABiqvc4lZK1POxomA5w3luP\n", + "PT8PYFNmHbqgDcdCdFVvV3S1b0102mZ693E0X7ZTG70cgSDzE+7VjPSlt7GGkg24+/+PAkfLuvp0\n", + "MnOOhsGa+nCeKUPrzkBWMNO0Gp4MS0aWmsIinw5C+kkSlqbS4/BNoQfZfMN/CR2Xk5dMcGE7Uude\n", + "gahqLAIeVJbaKZI4DyZrHeLqB+CEkzmeWIgwTmx5Cr3ivw3t798L9PGVhsWpFFeWGl9Mm0/RE/k4\n", + "X8aCAElbAH8hOMG9xwtoIXkqdPEX/FVtDCC2BFP8ajrv2I4mDVj+NYSlwamauX0cOaN6WMxNUPsk\n", + "RGdAzVM0Cs8gLFP7b+uglcdC0Kkyz6LT3bsAfVfcyKl2q8n+bBXRnUxy43BIPraTkaYmodzh7DqS\n", + "a0HiUHhsITywBGJYdAgS13pT++K+K3QgtozOqsO8jx8meNv7/HJGGqd3tqB7Sgivq2q8BTwGrBZb\n", + "/g8ZmJmbbnLCvVzI467j3+hJdQwwBz3Zfim2DPbRBVOa4G5X4BUfxvAZgRV/ABWOYsRGvFKxKg2c\n", + "FWpGCBwJ16vso2FwRy2W/zqUlymDbxtt9NIpegWdd+z1fneQNq99wfs5J6Q73LSC7z6HWsaL777j\n", + "MX73PmiXz0XoCtY3laW2ii3tw1P4p6rJpcGnoe5mUrJTeSVllRpbcJzygnstx45ouPIaaLcf/vye\n", + "WbNOKQ+5/d7DKHPNR9MqPIDmhhioLHWFOX8m8AYborrw9ZAgssa7cQcVvesQW6LQ/v15QCLwNdrl\n", + "M9zbFFmx5RfgyaI0BIwK3x4gxh/ymAE+/gD+UvCGe9wXOO6lBwbBxHhNoBWdAdsURw41YS4lGfD8\n", + "/z9WWsPgqcgrjOtOfMl31RM4hvuXvihdAMOkeTdaW3cZWqHK0b51agyGAanoeMCk0nAA+YKCk/eJ\n", + "UIi7kmM7W7IvJ4ILPZHN+QrRou8PoVfondHC6b+7nb+EDVFj+SU+iD8b/EF2xpGSdh2GhC4WHZdZ\n", + "j95hTVGW+reX97gBGFqU4pnY0g94SVmqtzf9F+ovYPgDqEx4K+ZRUfCXCIs3KKjh615V6rQpldqS\n", + "Dhxfh84GCkEXzH1sslWC0bTO16L1CDaiJ4EpylJeUzoUh4KT9w7hzQ0WbdDul+uUpeb6e0yx5XL0\n", + "cylgtrLU5QXOh5vxR6GzB18tihbBvGdHgDvQrpdu6CSVxcBjylKTvLi/vUBnVYRQvKkFaaEsdX9Z\n", + "+/bYX8DwB1BZ8EhdwAivdVfLA5XhXirpfrzd8Rg3UD+0cTsP+Ah4S1lquzlfDT3JXYPOV1+KNpZf\n", + "V4TGs9hyIfAZ2o8+xt+VxWJLPNksJJiarG2Swrdnryd7z+gC5H4t0QVS7dAiSTMLLU66rfmGf6Q+\n", + "rCzVWmyx0XUZF6KVy2YDVyhLLSrDfQlwCqjpKQ3XtPkCmKksNcHrN8C9v4DhD6CykMvZcn0CzHoV\n", + "9rczZ/zDSeMvVLR7qSJgDNw9wK1oNbjRwPw4F4ObwsjwMKpvjAtqsjUuotbpphlR7Kl5kLSccXRM\n", + "e86QrpXXfbVA+8x/A+5yl8As1fXF7CBF4hOI6vAWd81qSXCmpsT4ptVO9m65u+BCQ2y5BBjDkdB9\n", + "fHxFQw5NbpF7stu5++izbJMandnfaCV8CyQrS40SWwYB49HupORSPnMNNIVG9WLabAauLMoVVFYE\n", + "DH8AlYbcNLqRsfDpDDjU2pwpnEYXQPnAGJ0bgZFBGUT0nEP1n1ZRL8KED4fRiunhL3C87Qno9NQJ\n", + "mu5VBPMNeifwY3kUExkSuQ+As4CrSht3KGkHmbvQqLcGbj8HjjeAsMOwKmYT522LK6ipILaEs7TZ\n", + "Wtofi2XJg7DwMa2dMPh+yErapH5MPtu0i0FX8D6rLPWJ2HI3elfVR1mqRBoGE4tZrCzVpIjzMWgm\n", + "gxhTBe4zvLWdQf4YPIC/OwwXT7V0yIxyOx4QrqkoKEsdV5Z6F4hr/x0H6rSiXvMHtSgIwCSSOTvz\n", + "Pfj1VvgotTpj+i9FcxA9BewRW94XW843fm9AG2CRwTNFEufpf+MTynhPJ4Dr0ZPLUhPYLAWajkTe\n", + "i+W8F6CaZq+I5IrYXuyekCgyrxfLekQyHf7sCK/u1aynWTXg7D+bALPElnyGV1kqgxk9U3h/hZaq\n", + "dOxkoxWws2GGW7sjwJXAa2JLF2Wpd9AcQF8Z91lJKCmVswuwxl9G3xcE8vgD8AMMF0+1Y7Gccgx/\n", + "1SNc+ztAWUoluuT45PVaI6Fhet65GjW35knap50RrCz1FvCWETIfhg6G1hdbJvFTvR1w6b3wgfuq\n", + "u3Qi7AXuB/g/o9w1SWx5AR2PKMbVEBWOCoI6m2HA40QmJZDAKCaSVlegHxxiGKNIAo5lXQJznoeD\n", + "rWHQ8GrATjSr6khlqYl5faZncKQlzByt/wzKgvq/wc7e+Sp2laXWiS33kClJUvP89aRfHUyjlLbE\n", + "/b5UZNA+qFlc8kJJhr/SK3YdBFb8AfgMpdYlEbrwQUJOQNYt8yFhZlkqNgPwL5wCudhDUMNNTfH4\n", + "kXZurfJ2Y8pSO5SlXlGW6gxcAByl29EXGDk3lose0yIzgHa9NPMqG0VZ6kd0XcJwYLzJvimEeJGE\n", + "XsyK60d/uk3bTWToJNqGW0wimeuGwNwWut0kkmnrzgK+5udkVsQ8AyQA7wMuseUz417BLE7yVMrq\n", + "rYf0kCwy9hZmyHTFHWf12dW4MvgCgr7ox55F9VkysCNxLQbqyuAZA6H3aA87oJIMf1eqiOEP+PgD\n", + "8AvElmhgl7JUzRIbB1BuEFvq1FnEmAHLGDbxCLlum0RaMSOXR6dkKgWRofNo+GQ/brwIIg7D6VBI\n", + "bwhHjx2k+cFP0UVIqW6vPcCRkjJ4TCziQzS98lXKUrlsvp4yr4aFNORAzf38dCibn1rCDVfBsrHQ\n", + "9ChcRNSh2QzKVyUstrRG8yYloSnh/wHcoiw1Ny+tNrsx3VJacuaRLCZ3WFZw9a6ZRr8byPWDYW9n\n", + "+NEU2TY/D6Lu1a4loGDygtgyAuipLDW8iGdPBi5xF/PxFQHKhgAqG1HoatYAKgFiS2PgYeCWg334\n", + "culm7ko4wpBIiDhASOQqqqtjTDgO/y0llcKxDFK7wCsHNN3EWdOh3RRo9V002g+ejHYcxQCN0FKb\n", + "1Uweu6dJwf3v69Bc+MvElmFOlavDOrqyITQ5CvWPw6TsVAakkwMEXfiHpoW4ohdcPAtqks4gpmTs\n", + "csvOUpbaIrb0QktzHkFXPn8qtnyBi6dxAfQeTYOWkWyPB+4fWNiFFRVOTghMnQhdPkCXDAik9IKo\n", + "7m7vUSHm0VoUseIXW2qjhXM2F/++VwwChj8AfyGSgOGvcIgtscDjwBB0Pn8HZandaJb2D7zv2U1D\n", + "4VQMrL0e1s5NptpZD/DUpix0odjlaP3j/0Mb2gygAXkTQUPz/7YF/q4B7ENXQf8otiwFZrfvQ8uk\n", + "/fBFvDa1E77RouWSxcZromkzMY2QXgvh9xq6QADtWimkRaAsdUhsuRh4D7DQNQ02sJywBkc5NTaW\n", + "Rl3h11vMs46NDeGCZ8nlCTLJCifrwMLH896S7HA43MrtPSqUvFAcJXNXYHXBjKPKQsDwB1AkyliN\n", + "+z+14q/qlchiS0fgCWAA8DZwlrLUAX/1X6QI+6mNznvwg/HTJ6AngVfRdQSOmIxHrhpz7+HoCaIh\n", + "mnrhaSB6b3Mix5wJu2vChrowKV7TTqdl0vRUNbbW20vrmnvJejSN8G+PaUrvDvs8U3orS2WKLbeh\n", + "J8UZaCbOjtQ7/T67gK8/hkN5ceva0C5eJEFPHoWFg2B4FtwU6va3p+SF2mitaE+oMoFdCBj+AIpA\n", + "EbnUxWV1/M8Yfi+evcIgtpwDPIlODXwNuENZqlzed09smfnO6+rUr9DpjlHoHUCJYjLm7+3mtVhs\n", + "+RgYf6gp4THv8cfMNFq+1QO+bgN1vmPH/Pa8cfxC/thfkwdrpNNtRQ1IjYI6J/SuACASCgm+mHjD\n", + "S2LLVmAWcDt7QxYDfdkfl69tE05EbKXXFyKJq6FpBiz+FBJ6uU16S2BPL3grohjm0eKCu12BL4t6\n", + "LysaAcMfQBFoOhLGxhKWBn2fh+P14VjfWHKWu8SW3eit+gG3nOQoNH/8/wDMs4NbbYJnGcGKgKEC\n", + "GIjOuW8CvAxcXRQtQGXATD6fov3pddGupyLFZApce0xsSTxdnccn38cjWyezpPlKMhf1oWtEH8Yd\n", + "mq7eABBbfqr3G/vGeqB/K47SW1lqqtiyE/iG89ZMD59zXfcMN1H3BlzDHmpzlKSaaCoM9Iq/zJQj\n", + "xRn+bugJu0ogkNXzN0FZXRe51bjhR6DrexC5D2rsg9ozj9DkUApQHx3YO4SeBATt5//K/O289pp/\n", + "9/uDhrYikPvsrafDRY/BO7+BCqaiK5FNMdVVaIMRinZtT/6rvI+QG3RORLuDmgNT0ZPAImWpnILi\n", + "OGu6sij1Uu5F++Z3oV1IHRwB9SYd5dFzd/Jv94yla6M4ueYkwzZkqe9KuJfmwHfRP0Q16Lm4zRkZ\n", + "1GB58+M0STnNluxV0HAlHGiri8GAslKOiC2/ArcqS60ucPwMtMZ4bX/7+ANZPQEUCe9cFybAlRGT\n", + "P8BFwhLnxyC2hKAzFeqjlYzi0Ya+PtDe/NvA/FtbbDlC/knB02sv8KfzQ68cpGdQfw1ccQt88a0x\n", + "+lBelcgFjd8fEbz9++PURfunDwMu4PuqEhgsC5SlUoDXgddNIHoY8C5QM+JOWXZxY3p8k0JTx3KN\n", + "WEmr2Qd5avstPIhmyUxBs2f+F2D3GvWfOoOld5819GqSyuZ0yFg8gPppHTkHKNbwK0vtEFvOPd47\n", + "/ac1rVfV2TQ5J+ijhvDC8X5wAOj0EcRNgYWPwoq7IauwXnAJKCqrpyuwqip9foEV/98AudwmMX9A\n", + "m+9g6UhzpugVjefJolhRi0eBespSj3rsT69e66IngeJeDUy7o5Q8SewD9hVFu+stJLb5DVx+YDw/\n", + "jA9hfaI5WjYZwdLCPXf9RCh80AWePIfsTGFtdhQPA/P8zW5ZFSC2tG+ykm9Cz+TMaqfh5l/hyV/0\n", + "uQSYOcNFIjpLKRadCdTakUU09NS/Ak8bN84ZaI6dh5SlvirF2CGhq2NSgptk1Yub0paV1YNg+zJ9\n", + "st5a6G9D04Xwa/VNnLetS2kJ5sSWdKBRwZiL2PJPNGPnY6Xpxx0lyYUGVvwBFIMoXSV5KhrOeRn2\n", + "doIdffGQh5yLIrM6is/qKdLHb2IBjrEuFoYpsQ6eJ4bWBf6uJ7Ycp/STRLE/YrGlBjfyIDuqf8b6\n", + "j+rD1ELP7k/t3qYw8j0h9oVzYUxPOHcnzJ9IyL/2sC9J+Z/P3h2VmbmkLLU2UWTXJDhzWWNYWz/v\n", + "XCREKEuliy1Xo+MaT6JX/Neba08awfRvxJYFylJ/mrZJYsuG4gqk4kUSBsHIUNL3relZPWbVjduq\n", + "sboH7LsTTr4Hf7aHyVOh0eW7SJxxCEgWW14G3i/uu2O4fMLx/BvoinZvlQn+lAstiIDh/1vAyUuu\n", + "DdPfhstuh3fXQFbxrouSsjoKIArtk/UZZku837zWFdfWTBK18DxJ9Cp4TGzJoOiJYT9a2m8bzU/c\n", + "q1TS8YLj+fvHGAXhQQpCcmDeR3C2Scj0lKXiT+Tu6ILfiuV0NXSIpmIzl9IhQ4CeKfrlwAnUmp3O\n", + "C2LLduATY9RfMOeWGGHzd8SWq5WlVogtTwBfiy09PGU65f/sTsPSdPodDjn185WzQ1TLajBu22+o\n", + "Wkfh2En27HxTvZ6ZJLZ0RrvaHhNbXgLGFhFUrwUcLmJ31g1dXFcmOAVt+6vr1Nb7lnlOXfUGAcP/\n", + "t4BbXvLvl0PcZLi46xGmB/uTRK1S0jnNJHHQvDYU19Zkx8TgeZLohuapqYv2qx8QW7IpMDk0S+Ci\n", + "Ln/S6qvjmgunqDzy0qIyhOc1TObSOc9ByClNdFbBmUu7YMwIaFVQHGcn5PteKkt9JrZ0BR431Mcj\n", + "DY20C1iJDhx/riw1TmzpCXxkJoN8RrgpjHwzhNiLroXXfoD2f8L8zdlhvb5g4dLbTnbGmr0HuNT9\n", + "OhOovdyM7zL38CLwYQEXo8eMHrGlAbpgraj8/iLhCNrviIGPOmnDD/5ZFAQM/98Ahdw2sw5kM+r3\n", + "znT3qxpTla/cNT/ow+aVzx0gttwDnIuWxTtsJomaFJggQmHwrw1gXyS0OaANP3j/Yyyt8fM/osIJ\n", + "yoZu78Fn092Olzmg6TXWKZUUL0JC6cRxngaGotWx5hrDniq23IR28cw1cocj0bq5j6HTXnMRBeHh\n", + "2XDLr3DBzXD3tHCWbo7n953R8bxz8nduWXIxETkfiy3DC8aNlKVWApeKLd3RE8ATZgIYZyaholI5\n", + "uwIrvYnTOIuCI+EQ47bH8MeiIGD4/yYo6LYRW64CxoktncqqjlQE/rIFXGLLYOAZ4BxlqcOQO0k4\n", + "Auu5/CqDRS59T6cl5oO3P8YyGj8/Ij2Ds77T6lX7Orodr1gNBfOcJT6r8es/gRZG+R7N8zPUuHze\n", + "A94XWy5Tljpl/P3LxJYVylI/OX04hvT6tbD3cASPD1OcXpwIix6JZp90ZuzQU9z8TReis2eLLVd6\n", + "qoRWlloOXGJ2Fi7gSUM1/SeeDb/XFbvOomBgOLGO4ffXoiBAy/w3hcl+WA0866cu/5IFXGJLB2AC\n", + "MERZaltJ7c2Pcav7MV9/jOuUSkpSavBkpfonKTW4YuQgd42h990nWX6P27Eqr6HgiKwnA3cD34ot\n", + "w4HngabAzQDKUrvQFcSfmdx9IP9nN2t3HKc/+B06fAaX3wZyGg5NCWNK1/po6oklYkvbom5EWWqp\n", + "stRgtK7xEGAsOmU5tEBTr6mY1ymVtBhGPV2bdUtgbwLM9JdGdCCd828Mkwb3G1oDdImPfa0GbleW\n", + "WuWXm6sAiC0N0SpUj+cX7Sge/wvavWJLG7JlCS9dtJTs6PBSZG1VCRjKii/QxG9NgW+AuWiqOXZx\n", + "MwAAIABJREFU5xlAF4fqWWx5BG2Yz3UCss5nt5gLex9hdjTVjkHcJFh9ux6g6QWZ3D63J5pD6CXg\n", + "OvddQzH3NRq4AjiNnog+UZbKElv2AL2VpTzUG5f6mR8BGihLPVLoXEB6MYCyQllqPzAy6BSTL6om\n", + "sxJF5g0WmRkvUiaJPYNKcfV4Kw9oeOG/Q2dplNroQ2Wt0P2OuwhR76qsHwYpNbm/UkmDq7rRB1CW\n", + "WoierB9Slvod6Ak0Bt4AxqEpIhxD+H/ANuAt53rnsztCqF7oZEbmGX2AE9nbgVHKUuPRxWafm11F\n", + "SUgz49+MTjvdKLaMAhxVMF8QQ552ml8QMPx/c8S5ON54B7W69eWiydBvBgzsDaO9MP4VHtzNKzKb\n", + "UZIyUv7rdDHZp+hU0Rcq5GY9IF4kYbDITB8n3DKPOSBcfgzJ4L5z/0ufihizHPAE8KDY0lBZ6iha\n", + "H2A22r3TFBgBuXGa24DeRiTFDQUUuQDt6kr9F3CF2NJAWWoecB46k+cVkzpcFGoDh5SlflaWupCv\n", + "G7/P7LOeZ3etWrzeb42EtrvUh8+76hl+ERkkIptEZIuIPF5Mu+4iki0iV/k6ZgD+Q1MYuXwakeM7\n", + "w4Yz9LGxENtMpycCpTZQleDjNymJtbdAr9fNsVLJA76Mzru+o7KqYp2c8hkw0McJt8xjXtuOAYN2\n", + "EPLzfvqW95jlAROL+RB4zvydoyxlA/ehs69eFVtamHPH0HxHL4gtPXL7UOuSYPEoLROamCcXemDL\n", + "JGASOoaAstRmdD1IT2Cq2Sl6Qm5Wj0h8AmsGjyDkmki23RNE2rz21Ojw1ekzoz79Xrz6vKuW4ReR\n", + "YPQ2ahDQDrhWRM4uot3LwEx0pUgAVQRREF7/OCz6EM52k5120hNLY6DMCjocKFTwVM53ryuSW87R\n", + "wtm5KDolUWy5E7gULfuXWb73VzSc4pyXz4HljfSxghNueY35Tne4Z3nFjFmOeBG4tGFvuddZlAxy\n", + "cU+jaTyJzt75xVTTYlxCI9CGu57TgVLrkrSLq5CrazRwl9ENQFnqIHAxmkZkvtjSyMP9uKVzmgVJ\n", + "oxWwp5s+lDYxZO+pNrXi74FNdfWhMrz30WhXkt/g64q/B7BVKbVdKZWF5t++3EO7+9GsfPs9nAug\n", + "EuGkuJ15OP+M7KQnNoWR7wQR+2FnmGCy/jx8YSOB4xW/ejYVyU2WwO5ebsc9pySKLY4S0yXKUsWJ\n", + "Ypc7nOKciGx46dy84+VZseuM+dmXMDC5YsYsLyhLHYnczFTVjv8kuS1KElbzaMv3uQ+oDmwQW+qb\n", + "9tOAT4BJhlywuL43AqvQriPn2CngVjT77BKxpZNzTiQ+gT9r9OLjvs9rXqzTemJIvjjf97JDSg3e\n", + "nAHN3dbupXzvq9aKHx1UcS/T322O5UJEGqMng3fMocpPIwogF8WlJ4otcqAzTdrfDZ90zKMTgEJf\n", + "2DIFdr0NyHq4e+2nzWf4Packii3x6B/+1cpSWwuer2g4E+7tq+Dn5vB7HX28PCt2nTHbHIQgt19h\n", + "+VcJlw/6TCS2dgQRn3aAtWYdPxZi2+7hVqAPmtxttSm6AvgXkEmucmOxeB14wC1QjLKUUpZ6Ea0X\n", + "/KPYcmke9UXDaI580EXHmZq0ggWwdBQca5DbYQTHGbBNT/YOSvne+93w+1rAVRoj/gbwhFJKiYhQ\n", + "hKtHRFxuf85TSs3z8d4CKAXWKZXUSGp3703OfTWQ0OOorB0EfZLqOnwSWLLhXJp9OQMGbvW8IzAo\n", + "VWA3XiQhiOhnI0hod9JNCMNbjhil1iVJo1aRxGz/nP3PLYQTJzylJJqy+e+BB5WlfinLGOWF3Ird\n", + "LGLvWQ6v9gH1XflW7FZelXD5IDqHsFGz4K5/wKlg6LcDrHkQuZ8IZalNYstTaErn6ZIY/QlTBsUR\n", + "GVKDO2fdK1fGZKmvjzxVTPc/AsFoGo986ZzKUpPFlh3A19Suk8ahsbFE1NFcWACMqw5XnIC+1Z1r\n", + "hJtTs/ldoScjoEzvfa7hF5H+QP9SXFMsfDX8KegouoOm6FW/O7oCE7XNpy4wWESylFLfujdSSrl8\n", + "vJcAvIBesQy5IZWx2vPYYDUMvOQxMuUuqqmHmr/N0S9P88ag4o1FiYFdJ1awk9axa/kczlivhauz\n", + "w/GJI+bObWnAz+r01PM9Pp8t1YFvgfHKUp+Vuf9ygnvFbvAKas64n+6NN+DasbX8UkMrr0q4fJAO\n", + "GYO36NjUxclwOkhTMeTs5SxTfDUGuJI10etpdvp+Bp0VyqxX4fO1cGOfx6R7o51q+Z53PfWtLKXE\n", + "ljeABylg+M35pWJLHyJC1gMwZqvWrshFUDIkpDjMtoqdb+4l3dv3PtfwmwXxPOeEiFilerMKPYBS\n", + "Xr/QE0cy0AKdr/orcHYx7ccDV3k4rny5j8DLl89w0ExQitpbFEOuUTzcUNH9v4qQi2c6beIgYTDM\n", + "GArzBsOMOEjI14eLC3Axt7hxBsFMBaof/RTtP1U8WlfRZLECZV5D53l1/y4sXPy7iHNBuJiKi09w\n", + "6WLFqvrCxWhcvFLU+ThIGAQzh8K8QTCz4Gfwd3zFQcJw2PJbPVS9R1CHwlE3hpFc/RY+wsWfuPgU\n", + "FxfQsnsm4YcV1yUoEu7R37eOHykeDD+Gi+hiPpMI00+bItsEXTw77zvs/ho8w0/fixBcZBf1/fXW\n", + "dvq04ldKZYvIfcAP6G3Rh0qpjSJypzn/ni/9B1ARiApHTkPi1bB+KHz7gZGemxfutCgFn0qJPn4n\n", + "sJh1xgEtdPHxT7Cvg1sLrzlieqEVnTzh30A94CJvA8/+5qwvhsv/NWCV2PKiIzjifk158bL/leHs\n", + "YFL+5P5qO+gYP4hTtb7h/uPjVZLYUhNN2DaJUzUzyIgJ5YtvIeKwvnjNzRD7TBrtd00QW67ypI5l\n", + "+IHeN/3c6/EmclJegxEtYGyrvIN+pb6IBtL8nTjhM0mbUmoGulTa/ZhHg6+UutXX8QLwN9IzUMHw\n", + "3ipQ7rH+MhniEn38TmDxqf07GPn2QLaddjf63v1QTEFNT+AWD+dGoPO3e3mr0OWdZGXRKM6AK6WS\n", + "xJbp6PzxfMFHJw1zRzQ0S9OxFn/xsheFyhRpKQucRYnJ3lm/p5Mm1DOFXc+LLW+SeWolEIUKhhN1\n", + "8y6edvZa2u+qjy4Ie7GIIf6Lzg56xlMmWD7m22hiqX2gKdVT31brdvnrvfJ7YBcClbsBOJkx+Yx+\n", + "mQ1xiT5+J3voEo4x5vQPDKQ7Z3BhRggXrPRB0vAs4IiyVD5VL7FlAJov5RKTg+0lTD52tXS44J8Q\n", + "nEkpC8Q892YMOMA+UwZUIDX2FWCkkz/uwNktXXO1FuRwUF5pmN5WRFcmzHfg/yhAxawslcaBwyMJ\n", + "vi2/SFDQbTvIThkDXA3cJ7ZcXES/qWhqjxGezoNbPcCRpNbcvHwIQ3c/IbYM8/GRHAQMfwD+R5EV\n", + "jGUzxCW6ehymwQSYOYFj84NYMbMec4ZkqTndfFhJ9kLztuRCbGkHfA4MNVWXPiAqnLA0uHEgVD8A\n", + "Oc4G2TvOeseAv3AeDBmWlxLnGHBlqXVoYZGb3a9zdkuv/AiPXQQnDP9j+aVhmgmvVjJE7jXHvJ/w\n", + "KhBvAN3Elr7uB5Val8TpZXcR038djS88zhnnbWPo1Nq41l+GdlFfi1b4alFMv/d5YN4sBGWp6cBF\n", + "wCtiyz/d00G9RMDwB1A+KKaCsbQoVR5/OZCb5TP8Zrs/HXhEWWqBj31D9QPZ3HgxpHaG799xc4V5\n", + "F49Ih4yXztU1EVMm56XHFjDgLwGPmmpoIG+3dN5OOGcnvHxOOadhNs6sw1XXw4ie0NCdbLXiRFq8\n", + "gdGVeAJ4rSCvjlLrknhgfgdGzFnAvb9M4Oz0M9EGdTWQCLwNfGWE3Av2uwpN9jaklPexBv3dvByY\n", + "ILaE+fBYAcMfQJVFZYmw5Bp+84OdhqbD/djXjsWW2tw/vzn70o6Q9BZ5Ztr7wN2Cm0l5oStZcyZA\n", + "Q+MYK2jATZ3BPtyMjPtu6chclrzYi6xZZ/O8vwO7YksPseUbbljQgX0dYPQ22OLu3alYkRYvMRHI\n", + "xgizu8MESEegOX2aKks9gaZ3Po4WeKmBlm2UgkWGrIqZjyaGK9UK3riI+pk+fxRb6pZwSVEIGP4A\n", + "qiwqnpnTlkigNfCrWd1NQK/KvMtrzt93HWA2ETnf8X3w9XCJL24wp88HT7Skb+0kbh+ezsxEmF+M\n", + "sMbLaEbIXCPj7JZmHFS9s8N5ftcw/OJvF1tEbLlAbJkNTAFm886Zw1i4dSunarq1rHiRFm/YLI1x\n", + "fxB40dRwFDyfgq68nSC2hClL7VeWegwt6TgTGMKx4NVEdXgrX4zju6uuJVOaAb1Le//KUifQcpGL\n", + "0DQPbUp7rRvKxfAHpBcD8AcqQ32rG7BGWSrTaJ82Agb4mvZmVmazgVnA4ypnvcLHzBnDy34f0H/H\n", + "ZrULTR1RHL5HZ/YMQFeQFsSr6EyT/oY62Jt7EuAfwFNogrF/owXLM7FAJD4zV6O5EkRafElhVZZa\n", + "LLYsBB7GMHgWwCfoHdUzwD/NNfuAUWLLJMJzfua+74NY+TAsfAyO1wf1YSxL5m+kb/IDaENeKpg0\n", + "0SfEls3AArHlGmWpuaW9nsCKP4AqjMpw9fRGr6JuRftor3RUlryFYW6cgzb0j/sjd1psuQ/tRjjf\n", + "SAKWCGMsXgE80pybleSjwOiSCMc83E+w2HItsKbmOt7o/xoRV7tIHeTimjgXA3LH8D3u4xOcDKhf\n", + "msHUdrA3ssxMok+gDXkhJk3zud4JjHDj8XHOLeLb7hvIjITww9BoZd7JRfEHgQvd5RxLC2WpcWg1\n", + "sIliy21luDRg+AOosqgMw9/LjPkS8A+jJuY1TGB4LlrK72lfCr5yfcP9Wq8nU54BLlCWKqsK0xfA\n", + "WWJL1yLOTwUOA4XUoTy5SMSWMKMktQm4t+F3TE2cSs7co3ScUkF6AGWBkwF1OFyzwra7F1rfD2uG\n", + "0UlsuV1saVOcv11ZajvwAQeqjfdECKgstRc9IU8omD7Lb7VTWDUcaidD8kV5xzMyjwEf4SWNtVnp\n", + "9wWeElteKkHYxUHA8AdQZVGhht/84M8B7gGuUZba5GN/DdH8J5OVpf7lW5WvyX/vOqAfXTLb8d6Q\n", + "E7ji2pW1L6MV8DpFr/oV2nDZYkst53hB/YSpoQyMOJcJksVudM767cB5HVfSZyzEftsGklrra6sS\n", + "N7+TwnrpZvjuCzjwCnw9CWqkchA4H+2K2ye2fCW2PCS2dC+Ubvl2qxVEBF1IgxeLqkeYBKwHns0/\n", + "+q4xzEvZSlYNuMh5+3NjHG8Ct4otUd48l9EG6IVmD53iKQ5RAAHDH0CVRSQV6+Pvgv5BPFpGfymQ\n", + "f0Xct47MDTrFcuAzo+LkA0z+e+Ol0Pd5mDAHDk5p4UP++1jgfLGltaeTJm3wK8CVewfGRXIkXNcL\n", + "nDkKmjWibrfP2awsNUhZaoGylHJW1PWOw+2XwftmX1EZ3PyedigF6cKDFLzxJ8nVFvCYstQNylLN\n", + "0XGeKeg4wIfAIbHlJ7HFJbYM4GiLO5n7ejADHyavaiKvHsFMnvcAN4otfZyxlFqXhFo6immnfiLu\n", + "3Qx6tFvjBPXNTmIuHqrFSwtlqQPoXP/jaGGXhsU0j8HPIiwQCO4G4B9U2IrfbMs/B7YqS31U1uvd\n", + "g4a7a8L510PHxRzMnMcq3/OBjCJYSg94byWcMFqWXua/K0sdE1veQWeh3FlEs2fQgd73laXWOwb9\n", + "0YvgVAjMnQDt9kMiZLlf5Kyoe+2Gn8dDwvWwPQbS55QfN78nniIA5/NQ6KTZEdBqMYwyKaxFslka\n", + "99lOtFsMs/PpA5wLWDw8rw9/HoGoPdDtHdg4RAdq3T4PZan9Yss96DTOTiZ+4lByJIktHUnYOJuE\n", + "fLojr6NdRG8rS5325r1QljolttwMPI2OVV1mJvKCiKYcVvyVzrDnC8Nc4FU1Xrg4jovIChgnCBdf\n", + "4OJ3XDzmTR8OS+iOaFSrkaj/9EEpUIPBZzbFXKbTQi/vmRpxcQYuDuGiYTFtRuLiR1yI83w5BW6i\n", + "4PM5zJbO+f3VUXXu4GToSObiIszfn13B8RSo4bDlPFihQG2ujeo5PO++/fJ5hA6YRbOfFee+qJk5\n", + "H49R3N9acU293bi4DRetHdZLXHyGizeKeH9vwMUWXMSYvwUXy3FxmZ++18MMC+glHs7txEWzor9z\n", + "KG/GDLh6AvAJFay3a6MpwNOAxd504KyIT4TCI4v0C/zl4jC8R/ngW/67CVp/hvbnF4V30Omslzku\n", + "Eveop6cqX/eisESYf9MJZtaZyLVZtTkI/OAeN/AHHBfUaYFk0/NYiK0JLQHGddZVyc59++XzyEp9\n", + "g50TtvLLk/D5dHjlIExtt4ugE9PQqbJzgL1iy5fABuBaseWCgt0oS32KzvH/RGwJMi6i19H1Aj5D\n", + "WWoSusp3rNgyskDQOpDHH0CVRIXo7Zpt8fXoashNaE6bMsNxcbQ9oF8O/MF7k4+p0b/57/8HrBRb\n", + "/q0sVcjfqyyVJbY8ALy73kUcruJdJA480W2LLd+i6wQWii2DlaV2+HjvQN6Eu60W9LsVdr+m/fZh\n", + "INlBMKETzHarty6Xz0MdO0nqzjfVZ+m5z2xSM881rwxgttgyHx3s/wVYqix1DF0TMAftmnkOHVt4\n", + "xbiHfvX5XnXtwTnoGo42pvYDtHaw3+Nnosr391q6mxBRSilfyYwCqASILY2B5cpShfKl/ThGf2Ay\n", + "2ujXAsYoS3Xzpi9PhUHDIbmICtoqA7HlM3TB2ivFtPkGbahKoylb0nijgMeASw1XjU8YLDJzBgwE\n", + "6HgX/DcJzt0JF8PK03E0OtmLhos+1G0r8/Mw73MMsBY4D+iEzvz5BVgHvMCy2m+T1OMcaslZhKVV\n", + "Y2/aHXGspwidhbKOH43+ruc0+5hJ9RXvt/iDRUX16a3tDLh6AvAV5RrYNWXuk4BrlaU24oGRsyxY\n", + "Txwfcf7Rmgw4VIdehzsQvaKqG32DV9Di3+HFtHkYeNhT0VJZoSw1Gl1tPFNs33P73bN0rt4AU9pp\n", + "A78H/rXgYnYc2sTaEmgsKgr3AO2B2cpS56DlYh8GDgBXk0MM3Q4/y9DIgTRPbEnmhMbQZVwDosY6\n", + "KbT3ETnwID2mhMhlv7nXDpQGZkd3Sdif5KQl8P6UQ4ROLoc6i4CrJwBfUW6G39AnTAeeUpZydE97\n", + "oTV0y96fybPPZmysc8OHGBHjZbigQqEstUYeDk1hWcsV4ko84EkcRVkqWWwZiy5qu8kPY34ttqSS\n", + "LUnS96w9/NzJ47ilgbveb+YW6iy4gQ6xPzJq4zP8CrT9/SKabvpFVTTtRyEoS6WJLcMli88urCFr\n", + "h54gxG21/aIED5zJ+Z0H0vFTfcEF/4Sg7PrrdoZwewZk7o5g4a+D2JszpTp6AmlfVvEeZansQSLB\n", + "g3oR2ns4fD0Reqb4WXzH39F7r6Lagayev+yrNHq7XvYbhoufcfGSUnmas2GPkNGnPgu80ZzNzboJ\n", + "P6zoZ/tdH7Vc32fiEmg1aDf3t1ZItrnv4VsgrqD+cRQuUnDRy2/j1h2ynftjFRc8qSDH47hefL7r\n", + "cdEbF0/iYmxlv7/urzhIiL2StNsuy/2CqAuJSgnh/JVw9RHIUVxyl6LxEv1+xPyh2nZoqwZfjwoe\n", + "Ga54Mkpx40WKbm97/R0bCvMUqG/PQj15Yd59DIV5+T8flDfPGHD1BOAr/F68ZbIaxgF7gaccv/wH\n", + "UQyMDCLsl32c59221+TZdxkLddw1Wqo2z7xG05EkJzXmZG1o+405VlgcRVkqHXgSGFNKSoCSxz0w\n", + "tTnzXNDlQ7jqBgh+yx+iLFPJqyT+wOfb9COawshV06k5p6Wuap5OJNsZ3CibOV2gTTQITH8HUnoC\n", + "Akda0Py3SJI+g3PH9IQ3/oBl98HJ2nmdRoQ2KMvn4V65/OJPecf9Jb4TMPwB+IrycPVY6ODrTcpS\n", + "OU4q4NImuuDI0ZwtO71AegZB2dDzTVjsnon3V+CZjwoHgQVPQ50tbsc9TlqfAjn4wd0DUeHU3gqD\n", + "HoQpkyD0JNwwCGqEeEVZ4IYp6CytDGCZ7/fpP0RBeFQmjJsGm+rCGNqSzCRo/xk0C0Mn9uQhJiSR\n", + "UxGaNSSM43CyDvx+Gax3U1+stzcW+MNw9HTwxPnvHgvYBWNuDuNP93H8Kb4TMPwB+Aq/Gn6x5Qa0\n", + "9OBlRlEpNxVwY11t+B2UPdd71xjaX7iXIy0g1eE+q3ieee+QrplHN18KvzzhdrzwpGXYPUeiOelr\n", + "FjxfJlQ7nMmwq2CeC3b0h8lTYG8nGD67ozcslW5Yj/78fijvVOCywlltn78dHloMJ0LC4dI7oN+z\n", + "cOpydHLSM9TkCoLO7M640zPYf/4x7o6Ao/yeHsZ1J/L3ODyZHceHoWmwFfAdGUF/cH7ox8S87ZFH\n", + "aJ1SSTPO4dtz67G9PILegeBuAL7CJ8PvXsaffBYRkkgbFcI57gLqzg/x6Z8hxy1xrazbXqXWJcnj\n", + "IUeY3TYVEo9WBs+899g1Bka00u4dB0VPWspSy8SWWejlqUeit5Igtgh3Vgtmb+N0lt+tV/gqGH5I\n", + "T6Ze0E/UYqGhGvAm3TMaCANK1LGtaJgMpFZjIXZzHVgzdCXsbwLvr4BMZ6PTl5DwnhmdB6wIv/J9\n", + "OLgX/jWUE7U/Tr/mFL9RTC3Hk2LL03zVaRGte/ZkRA9Yfq+eWBkbq6/Twdv9fUnd35fxylLPFr5L\n", + "3xAw/AH4Cq8Nv3tO/ZbacN5lMGAyKXs20xyL9U479x9ikFkberPtFVt6UZ0wLlsfr1au84pjpbLg\n", + "ZXHYk8BaseUDZaktxbTLhftE3Ko/9f7olRmeMyvkZrjkjnzjfnwsSWy5Cp3uebOy1IwyPtJ1wHzg\n", + "ErFlVFVa9TsZSHHdeWHLBcTV+UXtSV9YrRpEuZGpDU8+1n7Lpt1H6JAI246s49TeBHqmutimrHWb\n", + "KCbzRlkqR1yJGWx+G2aMhnD3mrx8rrsY3Ijq/ImA4Q/AV0QCKd5c6PjuD0bAJdfDs3Phjs00Lpiy\n", + "5p4KWFI1agl4EF389Zcy+g4c4rBSt7dUqtjyCrry97KS2rtPxIuawhXd4aqx7NiYtuXUOrV5sIf+\n", + "vxJbUtEi5f9SlhpbhscZjt6JvIMuklpdhmvLFWJLOC7+wYao+ozusWJvRu1MSI2CvinQ4Lgz+WVe\n", + "cnjYPnhustLPLbY8h3ax3VPyKMZ1lxMKJ9zlePO57sqFrgECPv4AfIfXK37Hdz8pHi7fBHcYEgZP\n", + "vntHc3ayUv2TlBpcVqMvtjRD87OM8+Ze/8IYDZwttgwsqaEzEe+NhMShOrg55SDNiwuiK0stRouL\n", + "PC62vFCcOIoDsaULWu7xJ3R2z9BSP005Q2xpBSxiVUx7piSeJGN2b+2Dn9UF2sTAhlfcFMm6Aivc\n", + "Ln8bzfdT22Pn+VAqXqeA4Q+gysJrw+/47u9ZDq+4Kcv6K2WtAO4DJihLHS2HvqsslKVOAQ8BbxQS\n", + "KikAZyI+HgpPL4B/mIzXkoLoxo3UG7gATWRWrYTbuh0YZ4LQU4GhpZkwyhtiy9Xoar5xfNvrOOqD\n", + "M6mxz61FXvqs2BKJJpjLdUkqS6WiiwvvKGksPXEsHgUJMyFxvv5Xc/67NQsY/gCqLLw2/O5l/M6v\n", + "3p8paw7Mj/Q2/NzvXwjfo3nr7y2ukTMRtzoMd7utY0szERsW0QvRpGIzxZYYT+3Elgi09uxH5tBK\n", + "tMu5fUljlBeMLOWbwMtAgrLUWxAVTnAm3N4H2kxza53rg+8ErDdKae54A7ivpEkWSqVrXC4iLBAw\n", + "/AH4jii8LOAqSA1cjjwttwDzlaX+8HO/fwmYwOkDwNNiyxlFtSuoegVlm4iNiMlQNMHZQuNeK4gh\n", + "wDJHg9jcm1PMVeEQW1qiCdgaA12VpcyUl57B6WowdSJcNhwaOolLuT74buR38wCgLLUa/R7643nK\n", + "R4QFPxh+ERkkIptEZIuIFEobE5HrRWSNiPwmIgtFpIOvYwZQpRCJD+mcvvrui4Ij5zc0SOaFHeXl\n", + "uvMrnpDHk6RgZY1hCO4+BZ4vqi9/TMTKUqeVpUahZSMXiS2dCzS5HS2T6I5KMfxiy5XAUvT7MkRZ\n", + "ys3IGh/8nu7w/btwzeUQfc12Nx98Qf++O14HHvSD+6rcXD0+ZfWISDDwFjpolgIsF5FvlVIb3Zpt\n", + "A/oqpdJEZBDwPppoK4D/DVSo0Hpp4J6d8l1r2J4OHedyZ7zIhopiffRE/zwCWsWL4M/JrYxj2MAm\n", + "seVdszItBE8c/d5AWeoNsWUXMEtsuUlZaobYEgvEUZhkbxkQKba0U5ba4OvYJcHEIF4GrgD+oSxV\n", + "qHI4X/rsxsgImoY05K4pwUTkLDBNugH/KWKI74HX0HGPRV7eYzBQg3L6bfm64u8BbFVKbVdKZQET\n", + "0UoyuVBKLVYqVzxiKdDExzEDqFqocobfyU4BeL03PLgEPvCK4sG3e3gfYu++BFaa7G/vaCaKH8PR\n", + "qn21D6w/o/gx4lz0af0TB2JSmTuonHYg7lCW+hJtD8aLLSPQcZaPC/rFjbvnSypg1W+qjRcArdCu\n", + "nSLpItx98PTZ3tYY/c9M/KIpWrWr8HU6XXg0vil01QTSTQDc7/DV8DeGfCLEu82xonA7/qAUDaAq\n", + "ocoZfvfslKhTmv8d/CWvWPp7EGDANhh0g5YW9Pc9OM95KgRSI/U48ffA1oG0FVtau7d1dgcbfyGu\n", + "BUTfGudffveioCy1CC1o8jh6Qiro5nFQ7u4eseVS9O5iCnC5stSh0l5rJqe70Ab5XWCtslR2MZeM\n", + "By4QW1p4ebvl5uYB3wu4Sl1tJyLno2f8c4o473L7c55Sap5PdxZAucNsRyOAEyW1rUg42Sk1smDa\n", + "xLzj5ZQmWuw9DNkI7fbDldfAssaQNlMf9+cY4dnwf7PgPz/CoqaQ2B0BFpjiqonA5EFmd/B6T7hm\n", + "HTx6MWzaTOzVWX7idy8GylJbxBYXuljrKbHldg/ZMIuBumJLG2Wp3/05vsmweRFIBK4uRf/8AAAd\n", + "7klEQVQwtQdlhrJUptgyBPgdHcAurm262PIROo34ES+G82j4RaQ/0N+L/vLB1xV/CnrL46ApetWf\n", + "DyagOxa4TCl12FNHSimX22uej/cVQMWgBlpvt1y2o97C1+wUf9/D2Qdg2ViYHs3xnx6ihdjiF3dn\n", + "wecMUvDRTpJrf8k9aJfqw2iXxvJFd9Pn9V4Qe1C7hc46AK+cU/67IIeBkj/OeIM5sTs4EtoKD+me\n", + "5jvkd3eP2NIUrZ/bDujirdF3YHYJS4AuYsuAEpq/CdwqtnjDZOrR8Cul5rnbSi/6BXw3/CuA1iLS\n", + "QkSqAcMoELgRkWbAV8ANSqly4Z0IoNJQ5dw8UKFpoqW+h2tOMbPm5ySers54YJnREfbrGO7PabJr\n", + "5ipL3Qk0avEzv6+tDzdfBfWPweIm8Hov2Fu39Lv2ssJRPCNy3EAaZNVhyeo4Rt94BvvC0oFfPKR7\n", + "+tXdYyQjl6Nt0qXKUgf91HUbYBTwudhydlGNlKW2owXab/VijHJ19fgsti4ig9FFC8HAh0qpf4vI\n", + "nQBKqfdE5APgSnQBCUCWUqpHgT6UCoit/+UgtrQFpilLtanse/krwawUP0Xr6L5eEQRljo//rWBi\n", + "Z7WCf58Li5sCpzlKCI8AX/nRMAIgMngmzBjIuS9BrWT4zqHyGTwT18xZ6B3JpbjiGkLTkRAZTosd\n", + "vWH/PeqPP4qKBZQ8ri0hwHPADWit5l98f5rcvmPQXo1o0/+/gF6mgM1T+3OACUCbsnBEiS23An2V\n", + "pYqdNLy1nT6TtCmlZgAzChx7z+3/w9GETAH878Hr4q2/M5SlZostPdGujR5iy3Blla/erEN0d+Vp\n", + "7o/cTETMZk6G38qBjOZcixZseVVsWYgWtv/GiH77CKN4tukKOO1eyBoVoSz1utiyi2yZR9uGx9g0\n", + "QwvEbwfCb3pZJD61tHTZ7oyie2ujgm+n7ukapKBdOx4Nsg/oAvxqjPgEseUs4GuxZYCylKf4zSLg\n", + "EJqLf5qH80WhXFf8gcrdAHxBlXT1/BWgLLUDOBcdGF9SMAunPFCwWC6jOTehF22dgbOATzC7c7Hl\n", + "G7HlWkN34SUMA+WBtnC4ldtxXf2qLDWVSZ038o+1jejipr6Y8XGd0ko7OjuZGTDw9lb023Ir/duv\n", + "pOHZz/FmORh9KFy49QyQCnzoqWDL7OZep+ypnQHDH0DVQ7xIQvw3/KfuduLLqyq1KsMfVblmhXg7\n", + "Ogi4UGwpkTrZnzBG6XLgODALmKIsdQXQDPgauBFIEVumiC1DDM9OGVAKBsotrTIYvwB6vAWRqXnN\n", + "QsNrlWYEp17imfPh9sth4lRYPYc6LU5zX9nutdTIR9VggtI3oetG/lXENVOBWA9VzMWhSqdzBvA3\n", + "hLPK6n+a2Onp8DkM9HdValWGP6tyjfF9T2xZA0wRW7oDrorSDFCWyhFbLgEWAuOMqEoa2i89QWyp\n", + "g94F3I1e1U5Hu4N+MMyfRfddKvGY9AwOngXvrQLltg6NOhBdmvt36iUapcPK96D+cX28HLOVuqE1\n", + "oXOhLHVSbLkcWBJ9tVTv8yUdoyA8HTJ2wRilVJLcWuNHTtX4XiRxi94J7RpTgisrYPgDqFpwKkbf\n", + "DdMFUqArRgsKqPyvwnn+hU3h2X7QezcM2U3stlQexMvnV5ZaIrZ0QxvV78WW68tSYOQLlKVWiC2f\n", + "oP3QzwH/dDt3EPgA+EBsqY8mWXsY+EhsmYauE5ijLJXlse8SxWOMpKRyk5QMvWUP568p1b07tQx3\n", + "F2DNKY+aDcOzfwawueA5Zam9DXvKy4f78+YzTQnuY8paR0CrRlK7O9Wv7Mv90xsROboRxxoCI1qJ\n", + "xFOM8Q+4egKoWnAqRrunwFC3ovWKrIytTDjPH/8n3LscMoN1Tvz8BzhfbNkktowXW+4UWzqaIrdC\n", + "cPLbRRLn6X/jE4zO8AA0FcAKsaVTBT7Wk+iF4A1ii0f/urLUPmWpt5Wl+qFplNcALmCP2PKe2HJB\n", + "Uc9bFDzz0i+9i/ZHzzA5+MWigms2ugKri6pb6bSMy7/+iuAhibDdVCmMhdjm5NzHiU/PZN210P1t\n", + "0zqP278IBFb8AVQtOKusrqn5j1dkZWxlwnn+6FNw2e/6BTAoiNk//IvH0SSEvdEBvUZiywp00c9i\n", + "YCmuuG7Qe3R+4XRnBaiSgIfFlmXAj2LLQ8pSn5T3MylL7TfSgUPQalr7lKUmF9M+BZ3G/YahJUhE\n", + "k5Y1Elumoncui0pT3OdpVyC2fGvu5Y3irvWjLGdpUBwjJ1EQPngrfPAtnHE873gNDDf/klHQxT1L\n", + "NdLjQkkkPoGR1Tvzdc9XxTX4YCncQmWGz3n8frmJQB7/XwqefNzDIbmii6QqC2V5fuMe6IGeCHoB\n", + "PTkaVo3tQyLY3Ru2XQgHnBqghJlKJQ12uzYeXfz4A/CwB5oDv8JQG/yK5qJ5Bp0D/1MZ+2iNLuQc\n", + "hl61TkZPAsvLUq9giq+eUpY6tyzjFwf3tE/H/16W76uZ0L5UlvrC0/nBIjNnQCGJy95EH1jCkbqF\n", + "r8j/eYNb0dsDs2IZvwDSmqMD5ItHeTL+3trOgOEPwCvEiyQ0q5hVVpWEt88vtgTx/oVLqH9dd5os\n", + "gT/jYOkoczZxvlKT+xdoHw18DNQFhipL7fH7w+Qf7yI0p85dwOfAIGWpVcVfVWRfceRNAqHoSWAi\n", + "sKakScBQJ+8F2pvdhU8oIiC/dTGMKu33VmzZDlysLFXIx1/UGMMhOYlan6Qy5Ib8O7zhyR6kFvOK\n", + "3p6IgTe2Q4bDbFF4ktDtA4Y/gAD+Esj9cRdCET9uW4KAp9CZNdcoS/1crveng7aL0UHMt4DzlKWS\n", + "S7xO4hN0BW5UuHvmislv74iWXBwGZKJ3AROVpTYUc90E9E7hLV+fyVmNHw6HmIw8qc8EmJmkVKH3\n", + "vNCz2VIXSAZqFee+KmpBoJ+xWTHZTWYcSZwHk/sRPxHWJ7plOhVeFOj2lVS5G0AAAZQVJpOl0Apw\n", + "p8eApDE0z5tYwVSx5XngrXKkengYHZPoADxLpvwsMf03kVYvqKhUxFwXRdFxi1+BX8WWJ4Hu6Alg\n", + "ljwZnM0F7SP5dUyd/2/vzOOkqK49/j2sg7IoIqAOgs6QKAOKgmxBGYmGYTTGuIWoMYKgL4kZl2jU\n", + "mKSnP4nPZ+KLxpi4oPjcEjWSF0XJPBGdxLCJC4QhGBbFgAoqLoCCbOf9caudnmF6urqru6t7+nw/\n", + "n/pM9+3bVb/u6Tp1696z8MHAJu+jlsc9LYENf2xBftxkuPcJOM67b0rBIWEY8HKyNYtEhWySezfF\n", + "8ILeGiY1a9+a0fUz8+oxjBzTsifL3rf9e70vonW4tYIpwIMSlX2yoi+iq3EunDdSW/FvXhzSmUmb\n", + "T6TzPePcncroXztDH0+/GphezqA/QsfYyubenisaUdWIvqgR/QFwKH8auoHOxx/AlONh5G3N3zcH\n", + "ONpzIw3EFtj+TldY3x2O2dDYnoJDQos1djOPj6C3DGCG3zBCIL66k/vrz2tDI/o6rqbFHmCBRKUs\n", + "yVvS5QbgJMq6/IRnl/TkrRFwzpm4EhwtuSJ2K0H2wMDZMG0EHBjz823ZcwW8O5mVZdv5y2/gv9+C\n", + "V6fEvdq1ixfZPBsXQBaIdXDb2V9k44lvQAdvzJ6i22dODH+6g4JUMcNvGAWGRvRT4Nu4+tXzPQ+Y\n", + "TB9jC3AdE1ZWIApP/xZeuJ7G2fHmBn3LdrQdPHEfzL8aLhwHRz9A8ikKb2pD28OO+LRAn7/vceDs\n", + "oJ+nQXX24jEsX7aB5Wmm6h4OvBxUhx/SHRSkghl+wyhAvCmT3wJnAHdLVCLeInAmeQh27+GoB51h\n", + "XlsZ91Jzgx43RbHkQrj/eTjh0p1cOrd961NSSac26oDhEpUDg3wQiYrsOIBBq8ZzWixJXQrePH2A\n", + "rsDrQTTkE2b4DaOA0YjOwy2WngQ80byyVcB976Fh3ygnf2c3neKTsO4957zXFMW7P6zj4T6T6LVj\n", + "I67wTIsFS5JNbWhEt+GM/+kBP85gXLW4dIz3MOClXNRNyBXmzmkYbQAv+OpmoBo4QyPaak3YlPZd\n", + "0/lZ3ux9GE+OXteaK2ICXYKrQHUTkFYUskTlLGCaRrQFF1jf+/gBUK4R/U4a7/0p0EUjel26x88W\n", + "5sdvGCGSyBc95zqich4uzUFNogjTNPZ5EK64+CjP4yedfQwB/gjMG3gLT5V9zCV+I2glKvsCbwOH\n", + "p1ol7PP/y5TFI1jSdy2v8ONUC7zs6sPwXdtY/95mfpRvQYpp205VDX1zMsLXYZtt6WxQUQ1TV4Fq\n", + "4zZ1FVRUh6KnlqOpZQ213ELJEV+Fqjo4u979TU8TtVxDLU8E1NW1Yw3P9biUz1b0avyypsKqCmhV\n", + "F7U8Ti2T0/q/dNimXNdVKfnQ9/+lAqqnwqo9oNvb+9eZ+98ems77bI7fMILS6aDL6X9+OWNvhCNn\n", + "eo1Jsy9mDY3oUmA4mzt8ifM3PUrX+ybAY6344PviVqBCovKVALq2jr+NHTfPp9Pxk2HRIa59OpQf\n", + "6lJ6t0Yahdi92IJ+8+DdIV76A3//l977cuWQkZQP+S7cPCYlnQWBRe4aRgp4c9b9gDHeNpqr2x3L\n", + "xi2wbgy8eUJc78Q+7NlGI/qhtKv6gHGjujDtOHj0T/D2cTjDV51y3QSN6GcSlStx2TiPTpR/Pxnd\n", + "oWTqKzBmHZTFVRvwEUH7NK5gzX4aUZ/pir2avweshFXx17oEWTHd/3YscHGHGir7roTbZ8O4tSnp\n", + "LAjM8BtGK3jJwo7BRczGjH1HXBHt+cCj/HJ8hB1zTt773ZkNs08Z7V5CfS28PRw+6x73QtoXpFnA\n", + "94DvAr9OZwexlNaDmlXDTRZBqxHdIlF5HjgNl7TOz9FcjMBLzddzm/5fvDw8FwDTvKbpY2/n4N9v\n", + "YXzzPbaV1ONm+A0jDolKb5oa+WNwybnm4wzfdcDr8a59Ujv4Vph2mN/cO7nDM3wrT23Wnt4FSSOq\n", + "EpUr2CULpMeJp7H5wPapLmR7hVPKmmew9BVB29B9Fd3a3yxyzhR/x02cE8kb3VfijH018CRwMfB3\n", + "jagOrpXXpsGhaeksAMyrxyhavGpRFcRP27jSegtpHNG/qBHdnHRfPrMv5pKWE6e1nA44pX2euuth\n", + "qNyPp+70WhPni2+JdFJaiwyupuTY33DFnw/nV+u9O5jkx93r/9J/xQNMXluKM/g7cNHPD7VU5nJQ\n", + "O6nuOoD/LV3HK9t38VE+ph43d07DSIKX234kjYZ+JC7ne8zILwD+6adqVKGQ6QuSyMQ6Sn4/gUuP\n", + "gIf+DzbEqkO2nFI6U3yeyvrcU2HZuW7zeVwvonk8bkR/MvBnnMFf2FpQlkSlFJemoW++Bm9ZWmbD\n", + "iMO7lS+n0ciPAQ7Dncjzcbfs52lE30u4kzaA/3TAfulWwvb94ek7oN2uuPZsL2R7C7VLvwXd4mt+\n", + "Jj6uRKUvLnhsKrAVuAu42P/isEvMlq9GPwhm+I02gZcPZjiNUzZjcAtxsdH8dFzlp7S8UYwY3rrB\n", + "ijOatWdnITsWRHUS3Y76iAm8tryGrVye8Lje6P5k3Oh+PM4N9JukWPrRI2eJ2XKNGX6jIPFuw+NH\n", + "8xVAA2665mHgUo3ouvAUtlVSKyIThKalDLcAz/AN1jAb2MopTY4rUTmExtH9+7gL/WQ/6zOtMBz4\n", + "XbBPkZ/YHL8RKn4KYHt5aIbS1NCX0Dian4+7JW8Trnb5Tq4WsmPlEt/bBw78tLF9BL12LubIpXR8\n", + "P8r1KxQ3uj8eV9N3ukY00Cjdfb7SGq55bjx3j57Hh5t+GfZCfSJCm+MXkSpcVF974B5VvamFPrcB\n", + "E4FPgQtV9dWgxzUKnwQFsMsOP1S6v3ERn9Bo5IfhUuLOxwXyXA+sydbcq5+LUTGT+XWDlomVSzzr\n", + "HJjUAN/xyqDs066sI+M/PpyRr80A3sAt1J6nEd0a9Jife0L1+HE5u0bDh3+thGmlroRkfhr/dAhk\n", + "+EWkPa4e5knAW8BiEXlSVVfE9akGylV1oIiMBO4ARgU5rtE26Ac1d0N5Q2+Y3+/zrfzf3XgQeB5n\n", + "6G8AFmlEP86FpviLkeLKjkyDssEitAXjX0gXtViw14wnYMxFcOT7ULkWPun/MnS6pCcPdpmnby4c\n", + "m9mjemkeDp7pAt+AdKOd85qACYJGA3Vxz68Frm3W507gG3HPXwP6ZCLRkG2FvZ0N9bsFPfZi9ILT\n", + "0TuHof/ojZ4p1IelqQrqFHT5geiE89FdgiroRPhL2N9X0C0+8VgqCdKa76MK6s6G+iqoy2bSsphe\n", + "BX32MLTPVWj1gT21a/vHPflnZ/x34pLZqSK7lC6b4pLuZf5YmdGLpvO+oFM9hwDxC2jrcb7RyfqU\n", + "AhsDHtsocLbA9nYKL9/dtP3TEMPiY9MLR7wP2zrAb0bC5QvbRo6W2B3W8IvhiUegdLNLPFbtEo8l\n", + "Hc3G3w3tEWin2b0balCdPViE0fS4v/MbQ3t1emEjdWdtZ8+9E2A3ZMeTKK4U5Laece0hp9/IMEGz\n", + "c/qdY22++BD+irIROl74fpP87mGHxcemF9opTJ8FPz8BXt+/beRo6QYlAgzdAI9VNLb7vaj1g5or\n", + "e1E+7asw4XzXlu2MlQ2qsxdS+u2/MnD1ukX/ZM9b4+HrF4BclKWUGElLQbYJgo7438JlKozRDzei\n", + "b61PqdfWBBGpjXtar6r1AbUZeU5sRFedYvh+NonPJfOFTfDDeTDm62w74L7Cz9ESu6hNaoAffRmu\n", + "XODak13UvGC4E3pdyPDKXvC9xXDj3MbXs303pNowW2QwcMr3mV2yD9PmHMWU3Yv0nk8z/jtpPFZ1\n", + "XqXfiCEilbgcQ8H2480TpSuiA/Av4Mu4CjkvAt/UvRd3L1XVahEZBdyqqqOa7UfV3DmNPCE+l8zm\n", + "dmyfczVle7pwk0b0nrC1BSE2VXNHO8oPuRL+PgNu+oA1C6GmpYutRKUDrpj7VUCPgXPZuXQBFV12\n", + "Ne1XDXWzVbOWrqEFXX2AxcAVGtGZyfq3ZULL1SMiE2l057xXVW8UkUsAVPUur8/tQBXwCTBZVV/J\n", + "hHjDyAUSlaOAucBQjehed6uFROyitvj0jsdt+ah3l131x67Zzc634zNdSlS6AlOAK3B38DcDsypq\n", + "qWrufjuVxBeObCJRGYYrwn6SV3imKLEkbYaRRSQqUVyK5q8Veu4WkcHVHNb/LiauLeV3DXhOq6vp\n", + "+3yU/1gzCBcQVQ/crBFdGP/edDJrZguJyjeB/wRGtPWcS4mwJG2GkV1uAF4BJgEZKWIeHgf/jLWz\n", + "Sul0GBywCjZ9AZheTpcR98Gau4CRGtE1Lb3TM/J5Md+tEf2DRGUIW9vPlQ4T3mF3j85hFrovJGzE\n", + "bxg+kaiMwBXsGFKoI0wXmTr4cXikC503N63M1e7Mebp7ZoYDorKLdBh0Cud+/CgffG1fno6l1Umt\n", + "PkAhk67ttGLrhuETjeiLwEOkWXYwP+hXA+XOC6dJOUZgz7YtIQgKxu7+3+exFfsyoB7KnvEawyt0\n", + "XyiY4TeM1PgpMEKi8tWwhaRHtxL4Cq6CZDxTthWmr3q3Ej7rDjNegDXxZY/DK3RfCNgcv2GkgEb0\n", + "U4nKVOAhicoLKRT1yBO2bIcTvMc/wTnj7QZWLy/MqREv0nbbAc3a21akbaaxEb9hpIhGtB54Cvhl\n", + "yFLSIBaZegLwM6AWeGcNfBAJV1e6FEekbaaxxV3DSAOJSndc4ZfJGtG5yfrnE/lYGD4Ibe3zpIL5\n", + "8RtGjpGoVOPSkg/RiH4Sth6j+DCvHsPIMRrR2cA84OdhazGMVDDDbxjBuByYJFEZHbYQw/CLGX7D\n", + "CIBGdBNQA9wrUekcth7D8IMZfsMIzuO4LLU/CVuIYfjBFncNIwNIVA4ClgJf0YguCVuPURzY4q5h\n", + "hIhG9B3gGmCGl8feMPIWM/yGkTn+B3gPV7jEMPIWm+oxjAwiURmAqw41ViP6r3DVGG0dm+oxjDxA\n", + "I7oWiOK8fOz8MvIS+2EaRub5HZ+035/6sgaRc+pFJta5tAKGkR/YIpRhZJraiip6f3FfLvxrf5b8\n", + "4kg+GgBMKxMZTLHkkDHyGxvxG0bG6VfDuzP7M/8qqLrMa7PiIEb+YCN+w8g43UoAmH8VdF8f127F\n", + "QYz8wEb8hpFxvOIgezrgpnliWHEQIz8ww28YGceKgxj5jfnxG0YWKObiIEbusEIshmEYRYYFcBmG\n", + "YRi+MMNvGIZRZJjhNwzDKDLSNvwi0lNE5ojIShF5RkT2a6FPPxF5XkSWi0iDiNQEk2sYhmEEJciI\n", + "/1pgjqp+AZjrPW/OTuAKVa0ARgHfE5EjAxwzLxGRyrA1BMH0h4vpD49C1h6EIIb/NOB+7/H9wOnN\n", + "O6jqBlVXjUhVtwIrgIMDHDNfqQxbQEAqwxYQkMqwBQSkMmwBAakMW0AAKsMWEAZBDH8fVd3oPd4I\n", + "9Gmts4gMAI4BFgU4pmEYhhGQVnP1iMgcoG8LL10f/0RVVUQSBgSISFdcQerLvJG/YRiGERJpB3CJ\n", + "yGtApapuEJGDgOdV9YgW+nUEngL+oqq3JthX+FFkhmEYBUg6AVxBsnM+CXwbuMn7++fmHUREgHuB\n", + "fyYy+pCecMMwDCM9goz4ewKPAYcCa4FzVPUjETkYmK6qp4jIWOBvwD+A2IGuU9W6wMoNwzCMtMiL\n", + "XD2GYRhG7gglctdP8Fdc3/Yi8qqIzMqlxtYo1OA1EakSkddEZJWIXJOgz23e60tF5Jhca2yNZPpF\n", + "5DxP9z9EZJ6IHBWGzpbw8917/Y4TkV0ickYu9SXD52+n0jtXG0SkPscSW8XHb6eXiNSJyBJP/4Uh\n", + "yGwREZkhIhtFZFkrfVI7b1U15xvwC+CH3uNrgP9qpe+VwMPAk2FoTVc/zhtqqPe4K/Av4MgQNbcH\n", + "VgMDgI7AkuZ6gGpgtvd4JLAw7O86Rf2jgR7e46p80e9He1y/53DOEGeGrTvF734/YDlQ6j3vFbbu\n", + "FPXXAjfGtAObgA5ha/f0HI9zhV+W4PWUz9uwcvUkDf4CEJFS3Ie6B8inBeBCDF4bAaxW1bWquhN4\n", + "BPhasz6ffy5VXQTsJyKtxmfkkKT6VXWBqn7sPV0ElOZYYyL8fPcA38e5Pb+XS3E+8KP/XGCmqq4H\n", + "UNX3c6yxNfzofwfo7j3uDmxS1V051JgQVX0B+LCVLimft2EZfr/BX7cAVwN7cqLKP4UYvHYIsC7u\n", + "+XqvLVmffDGefvTHcxGQL4VPkmoXkUNwxugOrymfFt/8fPcDgZ7e9OZLIvKtnKlLjh/904EKEXkb\n", + "WApcliNtmSDl8zZrxdaDBn+JyKnAu6r6ahj5NNpg8JpfQ9L8zipfDJBvHSJyIjAF+FL25KSEH+23\n", + "Atd6vychv+5w/ejvCBwLfBnYB1ggIgtVdVVWlfnDj/4fAUtUtVJEyoA5InK0qm7JsrZMkdJ5mzXD\n", + "r6onJ3rNW6joq43BX++20G0McJqIVAMlQHcReUBVL8iS5CZkQH8seG0m8JCq7hXnkGPeAvrFPe+H\n", + "Gxm01qfUa8sH/OjHW9CdDlSpamu3x7nEj/ZhwCPO5tMLmCgiO1X1ydxIbBU/+tcB76vqNmCbiPwN\n", + "OBrIB8PvR/8Y4AYAVV0jIm8AXwReyonCYKR+3oa0WPEL4Brv8bW0srjr9RkHzAp7kSUV/bgr8APA\n", + "LWHr9fR0ANbgFrg6kXxxdxR5sjiagv5DcYt4o8LWm6r2Zv3vA84IW3eK3/0RwLO4hdR9gGXAoLC1\n", + "p6D/V0DEe9wHd2HoGbb2OH0D8Le46+u8DetD9PR+JCuBZ4D9vPaDgadb6D+O/PLqSaofGItbm1gC\n", + "vOptVSHrnojzLlqNC6QDuAS4JK7P7d7rS4Fjw/6uU9GPcwLYFPd9vxi25lS++7i+eWX4U/jtXIXz\n", + "7FkG1IStOcXfTi9glve7XwacG7bmOO1/AN4GduDurKYEPW8tgMswDKPIsNKLhmEYRYYZfsMwjCLD\n", + "DL9hGEaRYYbfMAyjyDDDbxiGUWSY4TcMwygyzPAbhmEUGWb4DcMwigwz/IbRAiISFZHL4p7fkA/F\n", + "dAwjE1jkrmG0gIj0B/6kqsNEpB0uPcdxmj+J3wwjbbKWndMwChlVfVNENonIUFx67lfM6BttBTP8\n", + "hpGYe4DJuGyNM0LWYhgZw6Z6DCMBXj2FBlyq4YFqJ4vRRrARv2EkQFV3ishzwIdm9I22hBl+w0iA\n", + "t6g7CjgrbC2GkUnMndMwWkBEBuHKBj6rqmvC1mMYmcTm+A3DMIoMG/EbhmEUGWb4DcMwigwz/IZh\n", + "GEWGGX7DMIwiwwy/YRhGkWGG3zAMo8j4f5zK8+dXcH02AAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "modelNN = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelNN)\n", + "inv_NN = generateInvTest(environment, modelNN)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### WNN Inverse Model\n", + "\n", + "Typical robotic forward models are very redundant: e.g. a robotic arm can put its hand to position $s$ with an infinity of possible $m$ motor positions.\n", + "Thus, trying to infer a motor command $m$ to reach a given goal $s$ doing an average of the nearest neighbors of $s$ in the dataset would make no sense as those nearest neighbors might have very different corresponding motor commands.\n", + "But to perform the inverse inference of a given $s$, the Weighted Nearest Neighbor model looks at the nearest neighbor of $s$ in the dataset and gets its corresponding $m$. It finds now the $k$ nearest neighbors of $m$ in the dataset, and returns their average weighted by the distance of their sensory part to $s$, with a gaussian of standard deviation $\\sigma$ (parameter)." + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEZCAYAAACTsIJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXncZEV1979nhkE22WQRkE1EEQIIyGJAfRRfGcYEEhPl\n", + "RVlEI2TBGTVG4oIMvKKSRYOSACIuQAAFIQGDg+uMhE1GAUcWwwzrwEhgAEEHZJnz/lHVM/fpp2/3\n", + "7e57+y79+34+/Xme2/d2Vd26devUqXNOlbk7QgghRItpZRdACCFEtZBgEEIIMQkJBiGEEJOQYBBC\n", + "CDEJCQYhhBCTkGAQQggxCQmGBmNmT5nZdiPMb66ZnT+q/OqMmX3azB4xs4cKzGNtM7vSzJ4ws28W\n", + "ma+ZfczMzskzzbwxs/eY2TUl5b2dma00s2nx+CozO3IE+Q70TtZCMJjZvWZ2YEl5v9LMLokv0xNm\n", + "dquZfaj1gKuMu7/Y3e8dZZaD/nCchIqZbQN8GNjJ3bcsMKs/BzYDNnb3w/LK18wmzOyB5Hfu/ll3\n", + "f/9wxR0f3H2Wu/ds77Hve/MwWQ3yo8p3bhFniE5nUMxsB+BG4D7gD9x9Q+AdwF7Ai0ddnqyY2Rpl\n", + "ZV1SvnVjG2C5uy8vOJ9tgf9x95UjzrfxmNn0EWXllPFeuXvlP8A9wJvj/+8B/hv4R+Ax4G5gZjx3\n", + "GHBT228/BPzngPleAFzZ45pDgNuAx4EfE0ZjrXP3Ah8BfgE8BZwLbA58F/gN8H1gw3jtdsBK4P3A\n", + "g8BDwN8m0toHuD7m8xDwJWBG4vxK4K+Bu4Alie9eHv+fFcv5JLC0Le33x98tB/4T2KIt3eOA/4l5\n", + "n9GlLk4CLgEujvn8DNgtcX5L4NvA/8bn9oH4/Uzg98CzsZ5uBiaARYnffh/4aeL4GuCQbunGcwb8\n", + "PbAYeBT4JrBRW50fRRD+jwAfT7m3NWO5jo/H04FrgU+mXL8BcF4s073AJ2JZ3gKsAF6I9/rVDr/d\n", + "BPhOrO/lwE8AS8lnp1g3y4E7gXfE709uq9NjO+UL7AdcF/O6BXhjIu2Nga8R2uNjwGXAOsDTiXSe\n", + "BLYA5gLnx999F/ibtnLeCvxJtzKn3N8xwO0xnyXAsYlzE4S2/GHgYcJ78Z7E+ZcAVxDetRuB/wdc\n", + "k5JPqy2kvX9zgUuB82N6743P+Nx47dKY/rR4/TTgn2KbWgL8TUy/dX4+8L62d7B1n7cBe8S8XojP\n", + "7SngIxme2fbAgpjO9wj9xPl9932DdJij/jBVMDwLvI/wov0l8GA8t06skFckfnsT8M4B810GHN3l\n", + "/CuB3wIHEjqKvyN0sGskyn0dsCmh83oY+DmwO/Ai4IfAp9oa5r8DawN/QOhUDozn9yQIh2mEkeDt\n", + "wJxEWVYCVwMbAi9KfPfyxL3s76s7rT3i/2+Ojfc1hM7vi8CCtnSvANYHto5lOiilPubGZ/P2WB9/\n", + "S+iop8dy/wz4JLBGbMBLgLfG354EnJdIa21CB7QxMCPW3QPAuvHcCmCjDOnOic9gy5jOWcCFbXV+\n", + "dnweuwHPkBDubfe3C6GD3InQ0V9Heod9HnB5LO+2wK+A98ZzbwQe6NKuPgucGetteuu5dbhu3Vgn\n", + "R8d6eE18lq9OqdNJ+QJbEYRla2D1lnj8knj8X8BFsb2sAbw+rfzJvIAjgf9OnNuZ0InN6FXmDvc4\n", + "C9g+/v8G4HesbrsTwHOEdjcdODie3yCevzh+1o7Pbinwk5R8Wm0h7f2bS2jbrcHIWvH5nhmv35Qg\n", + "fI6N5/8SuCPW8UaEQeMLrBYMP060h3fEsu0Vj3cAtmnv+zI+s+sJAmkG8HpCf3hep3vu2vcN0mGO\n", + "+sNUwXBX4tw68YFuFo/PB06M/+8YK2atAfN9ltjBpJw/Ebg4cWzxAb8hUe7DE+cvBf41cXw8cHlb\n", + "w3xl4vxpwFdS8v4gcFnieCUw0XZNUjDcRxg1rt92zbnA5xLH68b73iaRxh8mzn8TOCGlTHOB69rq\n", + "4yHgAGBf4L626z/G6pHrXNpGNoSR8p8SRkhXE17yg4A3AbfGa3qle0fbi7VFvL9piTrfMnH+RuCw\n", + "Ls/8w4ROfjmwQ8o10wmj9aT2eCzw4/j/BN0Fw8nAf6Sln7juMNo6OoKQaw02JtVpe77ACbR1GsA8\n", + "gga1BaEj26BDvlPKz2SN4cWEAdPW8fhUYjvuVeYM7+TlwOxEOVYQO9v43cOEAdT0+JyT79Op9NYY\n", + "Or5/8f7mJ85tThhErJX47nDgR/H/HzFZu/k/TNYYkoLhahJablu52gVDt2e2DUFQrp049+8MoDHU\n", + "xcbQzq9b/7j7ivjvevHvhYQHBPAuQsf7THsCZvb66LXzlJktSslnOWGkmcYWwP2JsjhhNLRV4pqH\n", + "E/8/3Xb8TKLcLZJGvftb+Ucj+HfMbJmZ/YbQyF/S5bft/Blh9HWvmc03s/0S93Bf4h5+R7jv5D38\n", + "OvH/ig5lTrI0kZbH4y0JjXZLM3u89SF04Jt1SWsB4eV/ffx/AWG0+gaCKg5hNN4t3W2ByxPnbgee\n", + "J7zYafe3bpcynRfv5Sp3X5JyzSaEEdt9ie/uZ3KdduMfCVNf3zOzJWZ2Qsp12wL7tt37u5h8b93Y\n", + "FnhH2+/3B15K0A4fc/ffZExrFe7+FEHbaL2H/5fQQfVdZjM72MxuMLPl8dpZTG73y321DQVWt89N\n", + "CVpO+/vUi47vX2Rp4v9tCc94WeI+zor5Qnivsub9MoKWm4Vuz2xL4HF3fzpx/X2dEulFWUbKIvkB\n", + "sKmZ7U5okB/sdJG7X0NvA/IPCB3q11POPwTs2jowMyO8UA92SbOXIWkbwoi09X8rrTMJUyaHufvv\n", + "zOyDsWxJPC1Rd18I/Ek0mn0A+FZM/yHCaKl1D+sSXrxu99CNrRNpTSM0+gcJo8973P2VKb9b2eG7\n", + "BcDnCY37s8ATwFcIAvWMeM0DPdK9HzjG3a9vPzGgK++/Eeb/Z5rZ/u5+bYdrHiWM3LYjaCwQ6npp\n", + "h2un4O6/JdimPmJmuwA/MrOb3P1HbZfeT5j2e2taUj2yup8wmjy2/YSZbQFsbGYbdBAOndJt/+4i\n", + "4KToHrqWu/84Y5mTZXgRwXZ0BMFO+IKZXU42Y+wjhAFA+/vUi7T3Dybf4wMErfAlbYKpxbK2/Lrl\n", + "/QDwipRz7fXa7ZltC2xkZuskBszbEt69vqirxpCKuz9HMID+E2Fu7/tDJHcS8Idm9g9mtjmAmb3C\n", + "zM43s/UJnevbzOzNZjaDMKf+DGHueVA+Gf3PdyFMm30zfr8ewQC1wsx2Av4qa4JmNsPM3h1f8pbR\n", + "sNVYLgKOMbPd44v4GeAGd08b4fR6Kfcysz+NnlEfJNTHDQRbz1Nm9tF4f9PN7A/M7LXxdw8D20Xh\n", + "2uI64FXA3gTD8+3EESdhmgnC1E+3dM8CPhNdNTGzTc3skB730PEeo9/5HoT58dnAN6IgnUSs428B\n", + "p5rZevGF/RDBmaEnZva22M6MMBX6Ap1f7u8ArzSzI+IznmFme8f2kXofCS4A/tjM3hrrba3oirqV\n", + "uy8jGJH/zcw2jGm/If7uYeAl8R1YVey2tK8iPKuTCVOAWcucZM34eRRYaWYHAz0FCqx6BpcBc2O7\n", + "2Jnw3HoJy7T3rz39ZQTj7ufN7MVmNs3MdkjU0beA2Wa2lZltRHCASOMrhEHAnhZ4Rau9Eup6h8S1\n", + "3Z7ZfcBC4ORYrwcAf9TjfjtSR8HgTH247ccXEgzCl6RI82wZud8NvI4w8rvNzJ4g2AluAn7r7v9D\n", + "GM18iTBCeRvwx+7+fI/yJ/9vL/sCwjTCD4B/dPcfxO8/QlC5nwS+THjZ2tPqltcRwD0WpqGOBd4d\n", + "7/GHBFvJtwnaw/YETSst3U5lTp77D8I88mMxj7e7+wvxRf0jgrHxbkJ9fZlg1IYgzAGWm9nCWLYV\n", + "BC3ptkSdXgfc6+6PxmtW9kj3dILx/Htm9iTBOLdPl/vr+F18Ub8AHOXuK9z9IsJL+PmUuvgAwRB6\n", + "N8GD6t8JHj7d8m2xI2FA81S833919wVTChk0i7cSnteDhFHqZwmdaSuP1HfF3ZcChwIfJxha7ycM\n", + "blr9wpEEzedOQgc1O/7uTsKA4m4zeyxqF96W9rOEjvlAwvuYtczJ+3sq5vktQns6nOA11/F+OnA8\n", + "YUD1a+Cr8dOLtPevU10eFct9eyzfJYQpHYBzCLaDWwnt5NtpZXX3SwlTwxcS3u/LCINaCHXzyTht\n", + "9OEMz+xdhIHTY8CngG9kuOcpWDRQFIKZfZXQWf6vu++acs0XCd4EKwiuZjcXVqAKE6c17iZ4NA0s\n", + "zIQQ/aP3bzJFawxfI/iod8TMZhFcS3ckjGLPLLg8QgghelCoYIgG3se7XHIIUdVx9xuBDVtz+WNK\n", + "ceqbEKIXev8iZdsYtmKyS9dSghfL2OHu97r7dKmxQowevX+TKVswwFRvBkltIYQokbLjGB4k4ffO\n", + "ap/3SZiZhIUQQgyAu/e9CF/ZguEKgkvZxRYicZ9w94c7XTjIzTURM5vr7nPLLkcVUF2sRnWxmrGs\n", + "C7MdCe64B8RvLgDmWFjFoG8KFQxmdhFhCYNNLKzffhIhjBx3P9vdrzKzWWa2mODzfUyR5RFCiEYR\n", + "VheYTQhMXZsQs3Ec7lfE8wMlW6hgcPfDM1xzfJFlEEKIRpKiJeD+2LBJV8H4LPpjftkFqBDzyy5A\n", + "hZhfdgEqxPyyC1AoZtMIa6XdShAKvwYOxf3IPIQCFBz5nBdm5rIxCCHqTAzonU3Yy+EZ4IvuflWf\n", + "ifSlJQzad5ZtfBZCiMYThcLpTF5FdQczI5Nw6GVLyBlNJQkhRPHMZurS2q8gLLbYnaAlLCAs4rg2\n", + "QUvYpSihABIMQggxCtZK+X7t1F+MwJaQhqaShBCieKbsIhl5uuO3BXocZUEagxBCFM8XCfs8JFlC\n", + "2MtlNSVqCUmkMQghRMHEYF4INoW1CZrClyYZnkvWEpLIXVUIIQYgF/fTkFBhHkdyVxVCiBExtPvp\n", + "6oQqoyUkkY1BCCH6IAqFbzCo+2lIpBK2hDSkMQghREYSmsImKZeku5+uTqSSWkISaQxCCJGdToFq\n", + "STq7n0LltYQk0hiEECI7aYFq0Mn9tEUNtIQk0hiEECI7aYFqjwKzpxiea6QlJJFgEEKI7KQFqh3d\n", + "QSiMfI2jvNBUkhBCZCRjoNpIV0ItAgW4CSFEXlTMljBo36mpJCGEGBazad8zO/sZuBM4YDn8/stw\n", + "StVtCWlIYxBCiGEw2/F/4fLNYBeA84E5wOPBFjFnoGUyMmXbe0kOLYkhhBCjJGFL2AzWXgYcB1y5\n", + "+opWJHTugiG3JTnS0pfGIIQQfdJmS7gSHj4aNn986pWPA79gmEX2OmZv84CDOpya5+4HJ66TjUEI\n", + "IQolJS7hELilg1AA2Ah4I6ETPz2O9POg/x3h+kCCQQjROMxslpnNM7P58e/wHXL3uIRO8Q3tZF9k\n", + "rzf97QjXJ7IxCCEaRe7z7xniEjrEN+wKbNwhtVxG9ARBtAOT7zF9SY4+kY1BCNEoss6/Z0xsoLiE\n", + "XMuQnscsugXaIa8kIYRoMfz8+/DRy4WO6IGW9lOIK6wEgxCiaQw3/55D9HKmpTMKoENsw2DpaCpJ\n", + "CNEkUmwMS+i0+unkH9Z6jaOU+0ZTSUKIsWeg0XrF1jgakF6bCGVGGoMQYnypuZaQxMzmE2ImJiGN\n", + "QQghstIMLSHJwDaFdhTgJkSFKSRQq2TKvCczmzXdbN4pZotbK6FSk13VMpAlyC4T0hiEqChFL5RW\n", + "BmXek5nN2hn+7SzY9vXxu0vhqdNgzk01nDpqJ8W2MnOQtGRjEKKiDBsklWVZ5lEzisCvlIynnQq3\n", + "fQh2WgdoWwm12LxLRAFuQjSPgQO1KqxtFLr4W0eiLeETsBNM2i+h+LxrSqE2BjObaWZ3mtldZnZC\n", + "h/ObxDnGW8zsl2b2niLLI0TNGCZQq5PrYp6LuA1KoYu/TaJtJdTl8PtDgKOYJBSKybvmFCYYzGw6\n", + "cAZhjmtn4HAze3XbZccDN7v7a4AJ4J/NTFqMEIFOxsSsyyqMfmSejWHuKTsdVkKdCUddOYq8G0CR\n", + "nfA+wGJ3vxfAzC4GDgXuSFyzDNgt/r8+sNzdny+wTLlRxflb0SyGXFZhdCPzPih8qYgucQk3AWb2\n", + "28LybhBFCoatgAcSx0uBfduuOQf4kZk9BLwYeGeB5cmNCs/fioYxxEJphS/iNiiFLf6WIS4hS95m\n", + "dhJhNmMG8Bxwhruf3HZNoweGRQqGLO5OHwducfcJM9sB+L6Z7e7uT7VfaGZzE4fz3X1+PsUciG7z\n", + "t41pHKK+lLWIWynkGL0chcInCEKhxSfioO/keE1lB4ZmNkGYlh8unaLcVc1sP2Cuu8+Mxx8DVrr7\n", + "aYlrrgJOdfdr4/EPgRPcfWFbWpVyV00LPQcWuPvEaEsjxBiTc/SymT0CbNLh1KPuvmm8phyX2wGo\n", + "4p7PC4EdzWw7M1sTOAxol+B3Am8BMLPNgVcBdxdYpryo5PytEC2aGDE9iZS9l3OIXp6R4fuqGvZz\n", + "o7CpJHd/3syOB64GpgPnuvsdZnZcPH82QfX7mpndShBSH/V6hKRXdv5WiCpPdeRCsWscPZfh+8YP\n", + "DBX5PCBZttUTogyqOtUxtMF2BCuhptgYniNMeXezMfTe76EEFPk8YorcVk+IIancVMfQWkz+toSO\n", + "QsrdT45G+1SvpHEw7EtjEKJhVFFjGLhMBWgJKUJqMTAn2bk3wSVVGoMQokUVbWD9azHF2RJ6ups3\n", + "3k7TAwkGIRpGRac6shtsi7clZBFSYx2rJMEgRAOpoA0smxYzml3VsgipytlpRokEgxCicHpqMaPd\n", + "ezmLkGq8S2o3ZHwWYsTU2ahZSNlL2Hu5l7v5IC6pVXyuMj4LUQPqbNTMveyj1RIm0WuqrV87TZ2f\n", + "ayekMQgxQqroSpqVXMtegpZQJFV9rlVcK0kIMZU6GzWHL3txaxyVTZ2f6xQ0lSTEaKmzUXO4sjdM\n", + "S2ijzs91CtIYhBgto9nashgGK3tztYQkdX6uU5DGIMQIqWjwWSYGKnuztYRV1Pm5dkLGZyFE/uTk\n", + "cVRFF9A6IXdVIUQ1yElLaJoLaJ2QjUEIkQ/52xK6rVck2shz1z5pDEKI4emgJewNVy6Ev8bswww2\n", + "DdQoF9AiSdOuBk1PgkGIMaGg5Sw62hIMnmf4aaDauoCWYBtJ064GQoJBiDGgkPn6braEEAk87LLV\n", + "VdxXoicl2UbStKuBkGAQYjzIb3+BbB5HQ08DlekCOuSIv4y9HNK0q4GQYBCixvTRgeUzX5/d4yiX\n", + "aaAy9pXIYcRfhm0kTbsayM4gwSBETemzAxt2OYt+4xJqOQ0UGXbEP3LbSJp2BfzXIOlJMAhRX/rp\n", + "wAbvqAeIS6h5JPCwI/5ShGIn7So+g76RYBC1Q9Gwq+jagXWopwuA/ci+nMVQ0csV3F40K0ON+AcR\n", + "ilVr0xIMolYoGnYSqR1YF7/2OZnqaUzWOEph6BF/P0Kxim1aayWJWlHVDVHKoNv2k/HTfz2VuKta\n", + "lei19WfbdUON9Its01orSYwLioadzJPAY4ARhMJJcSrjoynXp9fTeGsJk8gy4s9xpJ9rm24TVgOh\n", + "tZJE3ahtNGyeJDqlPYGNgY2ADROXZK6nF5m97VSzO56BO4EDnoHHad5+CUWQ11pOubXpRLs4CHhj\n", + "v79vIcEg6kajNkQZgl6dUqZ6OtrsL66BSz8BO60F084HtobH45IWojt5jfTzbNOd2kXfaCpJ1Iqa\n", + "u0HmSddOqWc9RVvC2fDPa8G0ZcBxwJUhjZdTbJRuU8gtiC/HNp3L0hgSDKJ21NgNMk96dkqp9ZSw\n", + "JawFnA/MIcwfJSjMZlM118whyC1eIcc2ncvSGBIMonI0qOMokv47pQ4eR8fAQ18Pdop2CrHZ5Oma\n", + "WXY7qaj22qld9I+7V/4Till+OfQZybOeBdwFeOJzFzCr7LJV7RPr6rvA/Pg3vY5gR4drHDx+zvdg\n", + "tO5U34uLqm9gXlterc931U4KaRc+SBqKYxCVQnEKOZMhLiGrz34+xbH5dPaWWeDuE32ko3aSAcUx\n", + "iKagOIW8yBiX4KO12eTlmql2UiCFuqua2Uwzu9PM7jKzE1KumTCzm83sl3E0IcYbxSkMS/57L+dJ\n", + "J9fMZ4DN+tyjWO2kSAqc55pOaADbATOAW4BXt12zIXAb8LJ4vElKWgPNk+lTvw8jnvNO5DmPMCc7\n", + "b5i88kxroE+KLaHs59qhjm4CVjCgjWDYdlL6cxpdXfsgv8s0lWRm6wBbu/uvslwf2QdY7O73xjQu\n", + "Bg4F7khc8y7g2+6+NN7Bo32kLxqIr/b0OIXgT+/AE0XlV4CXTDmLodVojaP4jGczddon854HPoRH\n", + "UBUXrasaPaeSzOwQ4Gbg6ni8h5llaWxbAQ8kjpfG75LsCGxsZj82s4VmdmS2YosxYAPCMg8bA3sB\n", + "p/c51ZCVvJY1yDut7ARbwgLgC4RO8gJglyoKhQS5bP3p7ge7+0T8m8fWm4JsNoa5wL7E+Bd3v5kw\n", + "kutFFnenGQQf6lkED4MTLTRyMd6M8sXN04i5ZY5p9abatoRelGkjkOG6B1mmkp5z9yfadgJameF3\n", + "DwJbJ463JmgNSR4AHnX3pwlryP8E2J0wdzgJM5ubOJzv7vMzlEHUk54vbo7BTbl0ULE8afvr5t/Z\n", + "1X8l1DK3/mys4drMJoCJoRPKYLz4KvBuYBFh6udLwFkZfrcG4UFvB6xJZ+PzTsAPCIbqdWIeO+dl\n", + "QNGnnh96BEGRY3BTSlp9G7u7lPl3g5Qr9QPTHD7osCIal5c5HFL2MxvwOWcP0Ms/35E6OJRYxz7Q\n", + "7zIkvC7BoLUwfk4F1spYqIOBX8VK/1j87jjguMQ1HyF4Ji0CZud5c/rU89Prxe0lOAbMb6gOKv62\n", + "U5l+kchjOC+YGngc1eVTllAq4T59kN/1jHw2sz3d/eddLyoYRT6PH92icfOKns2TbpG4BC273Qtm\n", + "Mdm32ayNx5GoFkVGPn/ezF4KXAJ8091/2XfphOgT7x6NW8U54m5z5t2M6d0FQ/1tCaKG9PRKiiOw\n", + "NwGPAmeb2SIzO7HoggnRhcpt1hMF2RyChrAg/p0dv+/fC6beHkei5vS1iJ6Z7QqcABzm7jMKK9XU\n", + "fDWVVEHKXPZ4lAu/DUvfC75JS+hJ2Utu14XCppLMbGfgncCfA8uBbwIf7ruEolGUHT3aY6qpamRz\n", + "zZQtIRNlt71xIIvx+QbgYuASd39wJKWaWgZpDBVDyx73R08NR1pCZtT2slOYxuDu+w1WJNFwFD3a\n", + "B6kajrSEQVDbK5hUwWBml7j7O8xsUYfT7u67FVguUX2q6BlUL6QlDIraXqQoW0s3jWFO/PtHQLsq\n", + "Uv1t30TRlLmkQb2RljAsansUa2vJYmM4zd1P6PVdkcjGUE3q5BlUGaQl5ILaXjZby6B9ZxbBcLO7\n", + "79H23SJ337XfzAZFgkHUHmkJImeyrACQu/HZzP4K+GuCapK0M7wYuLbfjIQYW6QliGIozNbSzcZw\n", + "IWFxqc8RgtpaUucpd18+bMZCNB5pCaJYCrO1ZJlKeh1wm7s/GY/XJyyffeOwmWdFU0midkhLECOg\n", + "l62lSBvDLcCe7r4yHk8HFrbbHYpEgqFZ5OliV7mlEXLSEip3X6KWFLm6Ki2hEP9/IQoHUTOq0Nnk\n", + "6WJXuaURctISKndfYuzIsufzPWY228xmmNmaZjYHuLvogol8SXQ2BxE8GQ4CTo/fj5I893Ouxqbu\n", + "+a+EWo37EmNLFsHwl8D+hD2clwL7AccWWShRCFXpbPJczqD8pRGClrAA+ELM9wJglyENzOXflxhr\n", + "sqyV9DBw2AjKIoqlKp1Nni525S2NUKzHkZZ8EKXSU2Mws1eZ2Q/N7LZ4vJuZfbL4oomcqUpnk+cm\n", + "O+Vs2FOMlpCkchsRifEii/H5HODvgLPi8SLgIuDTRRVKFEIl1pdx96vMDHJYziDPtDJRgJaQ5hAw\n", + "0vsSoo0s7qoL3f21yaUxzOwWd3/NSEqI3FXzQuvLDEEBcQkp3keLgTl6LiIPinRXfcTMVjVcM/tz\n", + "YFm/GYnyqdmuZ31RmCtusbaEbg4BjXxOoh5kEQzHA18GXmVmDwH3AO8utFRC9EFhfv/FRy/35RBQ\n", + "hTiUOqB6Gp5ui+jNcffTgS3c/UAzWw+Y1loaQ4gKke/Ie3RrHGV2CFDQWzZUT/nQzSvpvfHvlwDc\n", + "/bcSCqKi5OeKW7zHUZJ+vI+qEodSdVRPOdBtKul2M7sL2KrD9p6V2dpTaqMgD1fcElZCzeJ9lGjf\n", + "aXuvK+htMlWJ16k1qYLB3Q83s5cCVwOHMHV7z9KR2igiw7nilrgSajeHgJT23Y6C3iZTlXidWtPN\n", + "xvDDaFu42t3vG2Wh+kBeHQ1iUO1vYL//6u+X0Kl9J1HQ21QqEa9Td7pNJW1hZvsDh5jZxQSNYVXQ\n", + "g7v/vOjCZUBqY0MYVvvr2xW3HvslpLXv3wDXoziUKSg4MB+6CYaTgBOBrYB/7nD+TYWUqD+kNjaH\n", + "0Wh/1dcSkqS17+tbm72LqTQ5XmdUdLMxXAJcYmafcvdTRlimfqi82ijjeGaK1/7qoSUkqXz77oXa\n", + "fz3JEuD2aTM7Etje3U8xs22Al7r7TwsuW0+qrjbKON4XxWl/9dISVlH19t0Ltf/6kmWtpLOAlcCb\n", + "3X0nM9sY+J67v3YUBYxlqOVaSWY2j7AhTjvzNBUwmZROZAkwu+LRywPT9NG02n/5FLlW0r7uvoeZ\n", + "3Qzg7o+Z2Yy+SzieNMI4PooOLPfRccW1hDEZTTei/Y8jWQTDs8k9ns1sU4IGIXpTe+P4KDuw3IyG\n", + "FdYSEoyDq3Xt2/+4kmVrzy8BlwObmdlngGuBzxZaqubQhA1X6rPEQP57LxfJOIymm9D+x5IsW3te\n", + "YGY/Aw6MXx3q7ndkSdzMZgL/AkwHvuLup6VctzfBL/ud7n5ZppLXgLobDyP16MDqoSUkafxouiHt\n", + "fyzJMpVEFASZhEGLOP10BvAW4EHgJjO7ol2oxOtOA+ZRwWU3hqUMn+qcbQLV7sAqbkvoQu1dUbOg\n", + "mIJ6kkkwDMg+wGJ3vxcgRk8fylQB8wHgUmDvAssyNhRgE6huBzYCLaEow7tG06LKFCkYtgIeSBwv\n", + "BfZNXmDUoGAaAAAO9UlEQVRmWxGExZsJgqG776zIQq5GzUp2YCPSEoo2vGs0LapKT8FgZju7++1t\n", + "3024+/weP83Syf8L8Pfu7hZ6n8ZNJZVA7jaBSnVgo7UljIPnkBBTyKIxfMvMzgf+gdC5nEYY3aet\n", + "D9/iQWDrxPHWBK0hyV7AxXFEuglwsJk95x1GfmY2N3E4P4NgGleqbRMYlHJsCfUwvAsRMbMJYGLo\n", + "dDJEPq9LEAavBdYDLgQ+5+5dYxnMbA3gVwRvpoeAnwKHp3k0mdnXgCs7eSXVNfK5DAqLIC6TEWoJ\n", + "bTaFXQgDlnYUuStqQZGRz88TRptrE16Wu3sJBQB3f97Mjids9DMdONfd7zCz4+L5s/strOhNJW0C\n", + "gzJiLSFFqD4HJCP9q2F4F6JAsmgMtwJXAKcQRk9nA79393cUX7xVZZDGMG6UEJfQZW2fR4HbqLOQ\n", + "FWNJkRrDX7j7TfH/ZYSNe47qNyMhMlFuXEKaTeE2d58YQf5CVIIskc83dfjuvGKKI8aa8qOXm2m4\n", + "F6JPsqyVJESxVGeNI63tIwTFBrgJ0ZvytYRVNMpwL8QQ9DQ+VwEZnxtIfdc4EjWm6ZsjtVOk8VmI\n", + "fKmQliDGhzHZHCkXZGMQo6M6tgQxntRnb5GSkcYgRoO0BFE+WuIkI9IYRLFISxDVQe7IGZFgEMUR\n", + "tIQFwBcIo7ILgF1kYBYlIXfkjGgqSeSPPI5EBZE7cnbkrloBGuVCJ1uCEJVB7qo1pTEudNIShGgM\n", + "sjGUT/1d6GRLEKJRSDCUT31d6ORxJEQjkWAon3q60ElLKAUzm2Vm88xsfvw7q+wyieYhG0P5fBHY\n", + "galbca5yoauUcVq2hNJojD1KVJ5GeCVVquMcgFj+ji508dw5wJaJnzwEvH/k9yiPo1Ixs58Be3Y4\n", + "pT2oRUcG9UqqvWBIGUUtBuakdZx1EiRmthDYq8Ophe6+94gKIS2hZGKbvZTOtqcF2mFOdGKc3VW7\n", + "efVM6exrqI6/POv3hQg8aQlVYTbpDgnVtkeJ2tEEwdCvV09fgqQu5C7wpCVUjbR2/jRa0kHkTBO8\n", + "kvr16qmbe+g9Gb/PLx5CHkdVJK2d31ZRTVfUmCYIhn4Xxqqbe+iJwLK275YBn2r7bniBp7iEKpPW\n", + "zk8qoSyi4dR+KmmAhbF6uodWiXh/f0Hv+xtO4MmWUGm0AJwYJbX3ShowvVT30LqSYmNYAszuem85\n", + "2xLq5PElRNMZW3dVsZq+BV7OWsIgrsNCiOKQYBDZKcjjyMzmAQd1OKUALCFKYJzjGEQ/FGtLqJvH\n", + "lxCiA03wShJZGI3HUd08voQQHZBgGAdGF5egPXWFaACaSmoyI45elkulEM1AxuemMsZxCXKZFSIg\n", + "47MIjPkaRzVcJFGIyiGNoUl00BL2hisXwnsZk9GzXGaFWI00hnEmRUsweJ6po+fXm9kSwmY/TRQS\n", + "cpkVYkgkGOpON1tCGD23r7i6DrBr/DRxikUus0IMSeHuqmY208zuNLO7zOyEDuffbWa3mtkvzOxa\n", + "M9stp3ybvWl6triEtNFzi8GW5a42cpkVYkgK1RjMbDpwBvAW4EHgJjO7wt3vSFx2N/AGd/+Nmc0E\n", + "vgzsN2S+nQyQbzCz24FP1X6EnN3jKG30nKRRUyxymRVieIqeStoHWOzu9wKY2cXAocAqweDu1yeu\n", + "vxF4WQ75dtq0Zm3C3smn13b6pH+Po05LjLfTuCmW+Gzr93yFqAhFTyVtBTyQOF4av0vjfeTzQneb\n", + "Qqnn9MkA0cuxg5wDzAMWASvaLtEUixBiCkVrDJl9Yc3sTQS3yv1Tzs9NHM539/ldkus1hVKf6ZMh\n", + "4xKSo+cm7kMhhFiNmU0AE8OmU7RgeBDYOnG8NUFrmEQ0OJ8DzHT3xzsl5O5z+8i31xRKPaZPco5e\n", + "1hSLEM0mDpjnt47NbKCtX4ueSloI7Ghm25nZmsBhwKSRrpltA1wGHOHu7d4kA5GYQvkZU4VA9adP\n", + "ClwJtfHeWkKIoSlUY3D3583seOBqYDpwrrvfYWbHxfNnEza13wg4M3qTPOfu++SQ91XAVbWbPilw\n", + "jSMtFyGEyIKWxKgKI1jjSMtFCDFeaEmMOjO6lVC1XIQQoifaqKdMRrOrWhItFyGE6IkEQ1mMble1\n", + "JFouQgjRk0ZOJVV6o5YS90vQchFCiCw0zvic4nmzGJhTegc4xruqCSFGz6DG5yZOJXVaJ6ncZTBG\n", + "b0sQQoiBaaJgqJbnTTm2hIFRAJwQook2hmp43tRw72UFwAkhoJkaQ/meNzXTEhJUbxpOCDFyGqcx\n", + "lOp5U0MtoY0tU75XAJwQY0TjBAOUtIpojTyOOrnzxlM7pPxEAXBCjBGNFAwjpWZaQpodAXgSWKfD\n", + "T1agADghxorGxTGMlBppCS26LKT3GLBxh+8XuftuxZZKCFEEimMYJfWOS0hz501rPA+uukCurEKM\n", + "BZpK6pcaagltpLnzLgE2ZPIU0ypvLrmyCjE+aCopeyFqZUtII6WDX0K4N0jx5tJeDkLUD+3HUCT1\n", + "1xJWkcGdN230X62IciFEYUgwdKMhWkI7A7rzViOiXAhRODI+p1Hf6OWi6BRRvgK4oYSyCCEKRIKh\n", + "nXp7HBVG1DIuIAiDFusAR8g7SYhmIcGQRFpCL17H1CA4raUkRMOQYABpCdmRAVqIMUDG5wZ5HI0A\n", + "GaCFGAPGV2OQljAI5S9pLoQonPHUGKQlDESpS5oLIUbGeEU+NzQuQQghOqHI515ISxBCiEw038YQ\n", + "bQkvwCLggEfh2WPg5wYXSSgIIcRUmj2V1KYlnA/MAR4PZxcDczQ/LoRoKtqPIUmbx9Fy+P0hwFGs\n", + "EgqgwCwhhOhI82wMHWwJu8D2D8P+Ha4uJTCr057L0lyEEFWhOYKhi8fRw2EvgU6MPDBLG94IIapO\n", + "M6aSeq9xVKXArNlMFgqgaS0hRIWot8aQMS6hYoFZWm9ICFFp6isY+oxLGHBzmqHoZEtA6w0JISpO\n", + "oVNJZjbTzO40s7vM7ISUa74Yz99qZntkSLQWaxwlbAkHAW+Mf08Hrqc601pCCDGFwgSDmU0HzgBm\n", + "AjsDh5vZq9uumQW8wt13BI4FzuyRaOn7JZjZLDObZ2bz49+0TWrSbAn7EcIp5hHuZR4wO8u0Vsz7\n", + "pxnyHgvMbKLsMlQF1cVqVBfDU+RU0j7AYne/F8DMLgYOBe5IXHMI8A0Ad7/RzDY0s83d/eEpqQUt\n", + "odQ1jvr0KEq1JQwyrSVvpo5MAPNLLkNVmEB10WIC1cVQFDmVtBXwQOJ4afyu1zUvS0mvCruq9eNR\n", + "lLctQd5MQoiRUKRgyLrWRnu4dtrvqmBL6MejKG8XWXkzCSFGQmFrJZnZfsBcd58Zjz8GrHT30xLX\n", + "nAXMd/eL4/GdwBvbp5LMrPoLOgkhRAWp2rLbC4EdzWw74CHgMODwtmuuAI4HLo6C5IlO9oVc9mIQ\n", + "QgiRicIEg7s/b2bHA1cD04Fz3f0OMzsunj87Bp7NMrPFwO+AY4oqjxBCiGzUYtltIYQQo6NSayUV\n", + "EhBXU3rVhZm9O9bBL8zsWjPbrYxyjoIs7SJet7eZPW9mbx9l+UZFxvdjwsxuNrNfmtn8ERdxZGR4\n", + "PzaJsT63xLp4TwnFHAlm9lUze9jMFnW5pr9+090r8SFMNy0GtgNmALcAr267ZhZwVfx/X+CGsstd\n", + "Yl28Dtgg/j9znOsicd2PgO8Af1Z2uUtqExsCtwEvi8eblF3uEutiLvDZVj0Ay4E1yi57QfXxemAP\n", + "YFHK+b77zSppDKsC4tz9OaAVEJdkUkAcsKGZbT7aYo6EnnXh7te7+2/i4Y2kx3/UnSztAkI8x6XA\n", + "I6Ms3AjJUg/vAr7t7ksB3P3REZdxVGSpi2XA+vH/9YHl7v78CMs4Mtz9GibtQTaFvvvNKgmGvAPi\n", + "6kyWukjyPka8QOAI6VkXZrYVoWNoLanSRMNZljaxI7Cxmf3YzBaa2ZEjK91oyVIX5wC7mNlDhHXV\n", + "5oyobFWk736zSqur5h0QV2cy35OZvQl4L513qGsCWeriX4C/d3e3sL56E92bs9TDDGBP4EBgHeB6\n", + "M7vB3e8qtGSjJ0tdfBy4xd0nzGwH4Ptmtru7P1Vw2apKX/1mlQTDg8DWieOtCZKt2zUvi981jSx1\n", + "QTQ4nwPMdPduqmSdyVIXexFiYSDMJx9sZs95OcumFEWWengAeNTdnwaeNrOfALsDTRMMWeriD4FT\n", + "Adx9iZndA7yKEF81bvTdb1ZpKmlVQJyZrUkIiGt/sa8AjoJVkdUdA+IaQM+6MLNtgMuAI9y9femN\n", + "JtGzLtz95e6+vbtvT7Az/FXDhAJkez/+EzjAzKab2ToEQ+PtIy7nKMhSF3cCbwGI8+mvAu4eaSmr\n", + "Q9/9ZmU0BldA3Cqy1AXwKWAj4Mw4Un7O3fcpq8xFkbEuGk/G9+NOC/ub/wJYCZzj7o0TDBnbxGeA\n", + "r5nZrYQB8Ee9Qvu15ImZXUTY82UTM3sAOIkwrThwv6kANyGEEJOo0lSSEEKICiDBIIQQYhISDEII\n", + "ISYhwSCEEGISEgxCCCEmIcEghBBiEhIMQpSAmc01s78tuxxCdEKCQYhyUACRqCwSDEKwapOfW83s\n", + "RWa2btzcZecO150YN4i5xswubI36zew1ZnZDTOMyM9swfv9+M/tp3DDmUjNbe9T3JkS/SDAIAbj7\n", + "TYQ1ZT4NnAac376chJntDbwd2A04GHgtq0f+5wF/5+67A4sIyxJA2B9hH3d/DXAHYYl0ISpNZdZK\n", + "EqICnEJYoO1pwsY/7ewP/Ie7Pws8a2ZXApjZ+oTd9K6J130DuCT+v6uZfRrYAFgPmFdg+YXIBQkG\n", + "IVazCbAuYWG2tYEVbeedyevap+37kPz+68Ah7r7IzI4GJnIpqRAFoqkkIVZzNvBJ4ELCdFI71wJ/\n", + "HO0Q6wFvA3D3J4HHzeyAeN2RwPz4/3rAr81sBnAEq6eemriZkGgI0hiEAMzsKOD37n6xmU0DrjOz\n", + "CXef37rG3Rea2RWEZa0fJtgSWvtuHw2cFfdBWMLqpY1PJOzJ/Uj8u14rOeSZJCqKlt0Wog/MbF13\n", + "/10UAAuA97v7LWWXS4g8kcYgRH98ObqxrgV8XUJBNBFpDEIIISYh47MQQohJSDAIIYSYhASDEEKI\n", + "SUgwCCGEmIQEgxBCiElIMAghhJjE/wdZK7t2b8ZM0wAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4lFX2xz8nBVIIIfReQw8KAgKKVGnBsjZU1rqKuvbu\n", + "urs6GXv/2RvYFbuuinQpolQRRaoQQHoJLaQQUu7vj3MnM5nMJJNkUpT5Ps/7zLzt3vu2c+8953vO\n", + "EWMMIYQQQgghHD8Iq+4GhBBCCCGEULUICf4QQgghhOMMIcEfQgghhHCcIST4QwghhBCOM4QEfwgh\n", + "hBDCcYaQ4A8hhBBCOM4QEvwVgIgUiEj7Siz/NBFZV1nlVzZEZIuIDK/udlQHRCRaRL4RkUMi8rHd\n", + "9pCI7BORnUGu614RmRjMMoMNEblCRBZUU91t7bcaZtenisilVVBvioi8V9n1lAfHjeC3QihLRI7Y\n", + "JV1EmlZje1JEJNe2I11E1ovIC55tMsYsMMZ0CbCsmviCGbuUGfZ5DQtye6oS5wONgfrGmAtFpDVw\n", + "O9DFGNO8vIWKyBAR2ea5zRjzqDFmQsWae/zAGJNsjCn1ewnCO1hjnaSOG8GPPoQzjDFxdqlrjNld\n", + "ze350BhTF0gAzgGaAsurs0OqQTCAVHcjKoA2wO/GmAK73hrYb4zZX41t+ktARMKrqKo/+zvoF8eT\n", + "4PcJEXlHRG63/1vYKeH1dr2DiOz3OPYuEdkpIttF5B8VrdouGGPyjTFrgAuBfcAdtr4iozsRucfW\n", + "nS4i60RkmIiMBu4FLrQzmRX22CtFZI09NlVErvEoZ4gt53YR2WOv6QqP/dEi8rQd8RwSkQUiEmX3\n", + "9ReRhSJyUER+EZHBpVznySKyWkQOiMibIlLbo54zbBkHReRHEelht7+HCspv7DXdJSJvl+E5+SzX\n", + "7msuIp+LyF4R2SQiN3nsSxGRT+w7kS4iq0Skt98HKNJFRGaJyH77PC6w253AfR7P5BpgJtDcrr9Z\n", + "2r0Ukfoi8paI7LD37gsRiQGmeZSTLiLNPGd8IjJNRG7wauevIvK3ktrs5/oq8g41EJGvReSwiCwB\n", + "OpRQj0sVM8Fe704RucPruXwmIu+JyGHgchGJF5E3xP09PihuVU6YiDwlqlZLBcZ61TdPRK7yWJ/g\n", + "cZ2rRaSXj3fwzgCeWTsRmW/LmQk09HfN1Q5jzHGxAJuB4T62Xwl8bf+PBzYCH9n1fwBf2v+jgd1A\n", + "NyAGmAwUAO3L2Z4U4D0f253AYvt/CLDN/u8MbAWa2vXWrroBB/CuVznJQDv7fxCQCfTyKDfXtiEc\n", + "GGP3x9v9LwFzgGbo4KA/UAtoAaQBo+1xp9v1hn6ucQuw0p6XAPwAPGj39QL2AH3RDvAy+4wiPZ7X\n", + "sHI8J7/l2mtZDvwXiADaAanASI9nkm2ftQCPAIv8XFsssA243JbbE+20u/p6JsBg17O06/7uZQO7\n", + "/i3wIRBv23qar3K86wIuBX7w2NcNOGivv8Q2+7jGirxDH9klGugObAe+91NPW/Rb+sAenwTsxX6v\n", + "to5jwFl2PQr4EnjFHt8IWAJcY/dfB6zF/d7NBfKBMLt/LvAP+/8C27bedr0D0NrPO1jaM1sEPGXv\n", + "9WlAOl7fZU1Zqr0BVXahKoSO2I/gIPCFx4M+gH7orwDX4Ba27wC32v9vAo94lNeRyhH816EqAtfH\n", + "5WpLIirQhmOFY2lleR3zJXCzR7lZrg/BbtsDnIwKhCygh48y7vF+kYHpwGV+6tzs+hjt+hhgo/3/\n", + "CvCA1/HrcAs4748u0Ofkr9xBQD/gD6999wJvetzHmR77ugFZfq7tQrwEGfAacL+vZ+L5LEu7l2iH\n", + "m48Vol7HFCnHuy4gDsgAWtn1h4FJgbQ5gHc20HcoHBXUnTz2PQws8FNuW/Rb8jz+cY92pwDzPPY1\n", + "AY4CUR7bLgbm2P9zvN67EbZ8X4J/BnBTCe+v5ztY0jNrjXaE0R77PqCU77K6luNJ1WOAs40xCXY5\n", + "F8AYk4qOVHqivfQUYKeIdEKFxXx7fjN0tOTCVn8VibJxXEbk38rYzhZAMT2wMWYjcCv6EewRkQ9F\n", + "pFkJbRgjIovtlP4gOnpr4HHIfuPWP4N+xHXQ6WkUOhL2RhvgAjvNPWjLPRW1TfiD9z1zGTbbAHd4\n", + "ldXSY38RlOE5+Su3md3X3GvfvagR1oU9XvckyqVC8HEv+nmVNR4VSoGgpHvZCjhgjDkcYFmFMMYc\n", + "QWcLF9tNF6ECqMxtrsA71AidpQT0vXjA37sCOip3oQ06qt7lcR2v2nqhDN8q+m74etd9oaRn1hw4\n", + "aIzJ9jj+jwDLrXJEVHcDagjmo1O+SGPMThGZD1yBThN/scfsQnt1F1rjB8aYBejIqyQY7w1WwJyJ\n", + "6oN9lfsh8KGIxKEjtcfR0UaRskT16J8DlwBfGWPyReRLAjNUpaGjqURUTeOJregI5ppiZ/mH9z3b\n", + "4VHWw8aYR/ycV+z+ENhz8luuiPQHNhtjOpWhTn/YCsw3xowsZ1l+76Xt0OuLSLwP4e+rXO9tHwIO\n", + "UfpklDFmboBt9mxDRd6hfUAe+rzX221+vxcPeB+/w2Of5zVuA3JQFYtnx+NCwN+qLSvRzz7v+1rS\n", + "M2sDJIhIjDEmy25ug87cahyOpxF/SZgP3Ah8b9fn2fUFxs7ZgE+AK0Skq6iRzVHBOgs/IBGJEJGu\n", + "6AfbGHim2MEinUSNubXRl/4o7pdqN9BWRFxl1rJLGlAgImOAUj92APshvQk8I2o4DBeRASJSC3gf\n", + "OFNERtrtUdbI16KEa7xB1BhbH/gP8LHdNxG4TkROFkWsiIwVkTp2/x6KGwQDeU4llbsUOCIid4sa\n", + "sMNFJElE+ni0N1BMATqJyCUiEmmXviLiot+WVpbfe2mM2YUacV8WkXq27EEe96WBiNT1KMu7rqmo\n", + "0HGievZA2+yJirxD+cAXQIq9z91Qu0JpneF/7fHd0Q79Y18H2fszE31H40SNuR087tEnwM32vUsA\n", + "/lVCnZOAO0XkJPu+JIpSb6H4O1jSM/sD+Alw2vs6EDijlOutNoQEv+J7dIrqEig/okYj1zrGmOnA\n", + "s6j+8HfgOyrG0zVY1gdwCPgKHSn1NkVppq46agOP2mN2oSqZe+2+T+3vfhH5yU73b0Y/gAPotP8r\n", + "H/X7w53Ab8AyVO30KKof3Q6cDfwbNb5tRRlI/t4jg6oZZqLT6Q3AQwDGmOXABOBF28YN6OzFhUdR\n", + "QXBQLJuHwJ6T33Jtp3YGqi7ahN7L1wGXEDU+7ovP+2SMyUAF4UXoyHSXbXOtQMoK4F5eiuqM16EC\n", + "6GZ73jp0gLBJlO3TzLsuY8wxVPAOR0kIgbbZ8/oq+g7diD6r3ehA4s0SjnVhPmq0nw08aYyZ7VGP\n", + "d12X2Xavse37FLfKcSKqu/8VFcaf+2urMeYz1P4wGTXGfoHOIMHrHQzgmY1H7UgHgPtR21ONhLgH\n", + "SuUsQKlpY4G9xpgefo55HjXsZQFXGGNWVKjSEEII4S8DEWmLdsQRflQ3IQQZwRjxv4XS33xCRJKB\n", + "RGNMR5SJ8UoQ6gwhhBBCCKGcqLDgt4bMgyUcchZ2ymOMWQLUE5FAmQ8hhBDC8YGKqR5CKBOqQsff\n", + "gqLUqu0ohSqEEEIIAWPMFmNMeEjNU3WoKuOuN+sg1LuHEEIIIVQTqoLHvwN1SHGhJUX5uQCISKgz\n", + "CCGEEEIoB4wxZQsmFwz3X9Tl+jc/+5KBqfZ/f2wcGh/Hmep2Y67MBUip7jZUx7V1h+SrYUMBGGOX\n", + "q2FDd0iu7naXtIyG6QbM150wvTphdtbRto+BaVXVhgtgngHzzomYvhMw+aJtuMAjfEFlP7+/wnIc\n", + "XJ8p6zkVVvWIyIfAQqCziGwTkX+IyLUicq1t0VSUc7wR9Ta9vqJ1hvDnQSu4+YUIEntfC++cCAUC\n", + "EyGxNdxU+tnVhzgNW8FpWyE6D5Kuh4cGQe1axFZVG46okx6XrITIfHijl27P0EByIYRQbgSD1XOx\n", + "Maa5MaaWMaaVMeZNY8xrxpjXPI650RiTaIw50Rjzc0XrDKFmIEkkeYzI9ES4YozI9CSl7hZBHERF\n", + "5cErU+DVPnDyBPihNdRRx6saC5fQrXcURmyCZRNhZROYejN9xSmXiNNn/J6gYhs8PwE2hhl4aSr8\n", + "dxj8PYbNW+GFyq47hL82Qp67VYd51d2AYCJJJHkAPDcNRk2ENtNg1AB4zlv4uwRovx2w8A24YyGM\n", + "Pw/mXEZncUq76ml96XAJXdAwlO0PQt1PSY1fzn9Rj9Yl4pTTKrMNq4yZughuSYbpj+xmfvgWtn5+\n", + "BWtW6Sw6mJgX5PJqGuZVdwO84Ro0jROZ52/QVJmosOdusCAixpTVQBFCtWGMyPRpMGp+G0itD2M2\n", + "QLMMSIbpU40Z4zrO1UFM9AiEdXkkmz67hB+z2jAWDZnwqHGY9Oq4jpKQJJLcGm6qA9EZkL0VXlhl\n", + "zFQ72r8IdelfBtxjHCbQCI/lhjglAY0zn2wcoZnznxW+vokJsHER3FKeTr08sjMk+EMoF8aJzPsE\n", + "Bs9vAy/3hVkdoO0hOLydrZv6Mh5YYhwmD0oUoC3QOCkj0YxVbxuHqZHRDH1BnBIN3Ibm0n0beNg4\n", + "TEnOjMGo8yrgauBU4wjx3v+McA2ajtSC9NrQ4ohu9x40BYqQ4A+hyuB6eV3reWGwuCVcfCKbtvcm\n", + "HY0OORONMjndOMwef2WJU/oA/4cG9brNOMy8ym19cCFOaQo8APwNeBB41ThMbiXVFYZmenrFOMzb\n", + "lVFHCJWLcSLzxndh8E1j4I5FcOtiux3mf2LMkLKWFxL8IVQZfE1Xr4bUxXCzHc03R2M4JaNRIlPR\n", + "cMHTgKXeI3txigDnA08AK4C7qkJ9EkyIU3oAT6Px3+8EvjWO4H9gtqP8BuhqHOZQsMuvaiSJJLeC\n", + "m+Mg6ggc3QbPV4Ido0ZAnNIyYQvLG9eh8WvfwGCPVC2hEX8Ifwr4U+F4HydOiQROQSO0JqPZimai\n", + "HcEM4zD7PI6NQtUnd6ABAB8yjrJnoqou2A5sNNoB7ALuMA7zS8lnlaue14Ac4zA3B7vsqkSw9d01\n", + "FeKUcOAG4L7orcy48F36v5XnjvXvOWgqc9khwR/CnwHilFa4ZwPD0Jjz09CO4CfjMAVWffIQa+PO\n", + "ZWavXRxsnAYZ2bBtEbQaAHFRcOQobHvemFU1TkCIUyLQvAAONBXif43D7Api+Q3QWPQjjMN4Z0rz\n", + "i+oeXdv70hboDHRusobbusTQ8vcGsP4FiDumx5V39FsTIU7piZIYsoDrjMOsC3TQFFD5IcEfwp8N\n", + "4pRawEDcs4HGaALraUxsl8/uIU+S/6ZHyI8JuXBppKbZBZiwERbdUhOFP4A4JR5N3HE1msjnaeMo\n", + "TM1X0bKvRVMjDgpEpVSVo2vbMXX2sbRDE8usB9Z3n8PoZ7fTsXMatEx3B/Uqr767JkGcEovmyL4M\n", + "zQL2dkVVf7467tXwbUjwh/CnhjilDdoJjOFY2Fj2nBzOhmRY9zfYa/P8RF0P7YaD2MRMsSm/MHbN\n", + "Y6jcqKlLAjACjVs1B1gVhDLD0BzEK9FMYyUe32g9I8dk09wIOOdCO2sdKLduWTvtDvgW8JFY4e61\n", + "bDAOd0Jyb5KAC5U94q/smY84JRl4CViAqvv2lXJKqfDXcU/SfCdlkp2hZOsh1CgYh/kDeBV4VSLP\n", + "nU/r6wfRcSokTvcQ/EfghA/AWJlWe38L4DzcKfpq4nIETQHYEhV0J6PqrS0VLPdddDYxFQ3l4PfY\n", + "ZlsYMDRb+8u6Oe57XpIXtbVZNMW3cG+Jhlx3CfXFaO6N9cCeQEa31lGugzdJoDK9k/0I0A5JIlRU\n", + "+ItTmgHPAScBE4yjMH1khdEKbp4IiTnh+upH5Wn4k0nlKCsk+EOoucjLzmbT6bDp9KLbD7WFjx/0\n", + "2DDmZ2OmjfNXjEhSMrS6uabYBSwl80LgMTQn7D3GYTZWoLwEoIVxmDtKOm5Mioy7QgV2EWRAtjgl\n", + "BuhIceHeCThG0VH7fPu7yTjMsfK2G9Q7OUmEZN9+Hq5ZTSQqqyI8/vva5u9/kW2dB3BP/6MkvhoO\n", + "HffD8M0qQJM1flT59Oz6TK9B6byvA5d7zmyCgTiI+r4NXHsG3PMjXFEBykBI1RNCtaE0gaz7BzwH\n", + "ExPdZ12dC5e5dfxxF2czaupektKvMw4z3Xcd3mXUDLuAdQC7FWUwvYMymEp1ALNCxlO4NUUTz4/D\n", + "5q7Fh9Br/j9OG7Cd266tS5P1DWF9A/i0Kcf2NueoiSQaTT6/x/6mAfvRxOF53mX5+V9uYVzC/gJb\n", + "f6799fc/4P3N1zFsdBZNIgrglG1w+a96X8vNo3dKEhqAEuAa4zCry1pGAHUkNFnDyoiWtHxhKpyz\n", + "zmMfZQ/LHBL8xwGqm8nhC4EKZD2u9U1QJ1pZPVsXQ+v+heuy5QUcayOAp9DYOncYh1nrPn/MdJg2\n", + "iugDELMPwvIgPBeir1nI5cvuoOyCKJhCzfU/ClWbxKOCNrOU88MoLtQigdoohTQfCMc9Wq5l64iS\n", + "PArq7MPEHaIgIp3ctMZszWrHZuCQLaeiArZcwtjf/8rwTg6WXcF23Pehqrb7gInBbq+d9VwAPFt7\n", + "D8vHvUW3d4/S3rX/akh9AzqEdPwhFEFl6jMrhlY3w8REaqfDdT3hSHM40jyRvIMviVNeRpP17CSF\n", + "jbD6fOMwmSWV1rW20KgOj4fH8uvAl2XXnnzu3pBmPtbZBND9Y+j/LBRE6BK++QSUZVNRoZWL0vSC\n", + "ISDboY5fzVEa6DQ/5xSggr0tbpVMF2A8UBftAH5H1TGu3/XA7wUP1ryYSFWNQO0KJQ2YxCkjgFdQ\n", + "Vd0JxmF2B7udlujwEvqczzv6slmU9Ioke6vFULpw2coOjfj/2nCNbrbVLUqXq26etMi4efDJYCQf\n", + "EjZD3E6I2wGNH0hl0Lqv0FzNzT1+jwE7cXUI7t+djebQeuhv3Pz+YdpG2vHWRfXI/64nk9IWjGxH\n", + "/oyRxVuQPN2YqTWOJ+7hAPYUqnZxosK+RFqkXSKBu4HOxmGOVHnj/0QojUfvOWAy6HczATbObsP9\n", + "W65kLHAqcL1xmGnBbpt19roJ+C8ayuTJkmwp5ZGdoRH/XxxxEJUbBoOv1Hg6I1NhRCqE/0Hd6m3Z\n", + "kaMAmHA4kKgLAO9tMN+tLWKktMKwHu5OwNUhdAGGZ/VgyI99iI+NhZN2weJJ8NEhwgds4Ly0u2cf\n", + "5avhO1kzu7m727s6FbbWmJj2fmiRh1Dmz1xU1z4f+AWYjA9apEdZJ6EC454qaXwNQllUmna73xlv\n", + "K7j56dokXjcCWh+GexdA/14kvj2St1HWTlJps9DyQJzSC5gIpAOnGIf5Pdh1QGjE/5eHa8RvgPUN\n", + "YVZ7mNkBprUjL78WvwKz7PKjcZickksLHvwYblNh8c1lNbq6IoXmCxyKggZWHF4A8z9L4Qlywl5l\n", + "X1wM03pvZkftNNj6QrAMu4EyhrxokZ0oKuRbUZQW6blkA/eiXsDPoQ5gmf7qtR7Pq4CBxmHWcZwg\n", + "2M5pA5Lk150jOGHEJrjmJ7hrJGRHQp0ZLJ/zh+kT3NYXOns5gMvRTvudQJ29QiP+EIrBU5/ZJQ26\n", + "pMGvS0lNjOb29fdwEA2J/AjQTZzyI9oJzARWV0aAMReMWTVVJAlI9jTclksgu5K9hBu30AfIhGzj\n", + "MFPFKR1oefg6Jsy5D9XJLgvGNfjsvCKvSJQBzdoxevc+SqdFfk9gtMh/2dg8jwLrZFz8x8gFZ2Mm\n", + "eRrGO4gkYZQG+TDwgjhlZGU+w5oEF8c9NwyyIiE+p3wUTXFKPeDphE50OXcSbOwDQ/8OE+bD08vg\n", + "TEOFHbF81DkKtRcsBHoYh9kb7DqK1Rka8f/1EUhcEMsFH4Z6l45AnXpmY2cElWG8ChZKixTq2iZO\n", + "qY+OqsajHPoXKsJDL2QMtZ8Npz4BDdZD7F7IkAwSsmfhPXpP6d6/ov4E4pQB7K0zjbxO8fxwDyCw\n", + "ZShkNcRlt7BB8VYADuMwn5f3+v4sEKc06DmVBV1a0XVGIvz3e7h9ke4rC0VTnDIWeDVhGSv7rqX/\n", + "lmTqd98Hz0+DV9JhDezaAFcHixQhTmmM6vAHAP80DjOjXOWEYvX89VFV1ExxSgfcncAwVBXhmg0s\n", + "CFa8mWChLEGvxCldUONpZ+Au4KvyjIwLDdT1N0KD3yGtszqXmYvnG/PJkKLH2tlB5HOJ5EZjzYXl\n", + "8icQuWAeSecNZtTtQAHUyoCDibDr8HZ6bbkWnUn0Rr16u1WGLro6YdVmXYEz7HJiwhaOPrGSxskb\n", + "oLmHWTsQEoMdEDyLxoy6vfE6XqzdjBaPz4KLVrktQyNh+UxTcTWPbf8V6ODjHcBZkWcUEvx/cVRX\n", + "CFsbUbEP7o6gF7AU7QRmAb9UVjaoyvS6FaeMBJ4B9qIJYH4tW9vsiL8YijOGCo8dczPU2QXfvA5H\n", + "E3weG3C9EdnQ/zk45Sn1bs75MZXe27ejz+oX1C/gF+DqqrTfVAbEKbWBwbiFfTiak2AKMK97CsMC\n", + "mfX5KPdvwMtoOI1fgYfa/ELeb1Np8Y+z4ez1cImNfRqMwHHilE5oSJK6aEiHFRUpD0KC/y+PEbVk\n", + "5pMNGLGmEfxtHcTYHE9VTc0Up8ShOchHoDaCBsB32I7AOMy2oNRTBV63HuGTU4Cv0fDJfrOFld4+\n", + "3wbqwtlBxFE4/V/Q5Uv48j3448Vis4My1xu7F0YMTCdpoyHCONA0kCcDZwPXAjmoZ+93aIC4FX+G\n", + "FJfWUJ2MCvrhqNF6Cirwi9mgyjjra4hy4Pug6r9/APWBa0an8NBHtRnV+jbY8iwkKP+sQt+ZZW7d\n", + "heaaeAh40ZWatKIICf6/CGwyki5AN6C7XbqF5dGh6wHCuu+F56ZD0ww9vrpD2IpTWgOno53AcJR+\n", + "6JoNzCsvp7xwZFt3O7SfBdsHqDqFsUHn4Fuj3n0oq+JJ4DlSug8rbbbhw7PYp4G62Oyg41Q46ypY\n", + "H5lKn21dy5qq0Ve9pKzeiqqw2qNC5mvUIczlbDQMfT5NgXloR/AdsL4mGIGtCqRngx+4LXE9Z0VD\n", + "bE4eaant+WDvCB4zDpMWpHrOR4X+xyht9kaU4PC8cZi8JJHk+D682bgDTb78WM+pUKIUpwxAKZpb\n", + "gBtsIMKgoVoEv4iMRvVj4cAkY8zjXvsbAu+jL1sE8JQxxXOFHo+C35+AR+l9qcBqNNnGamD1yAd5\n", + "dkY+xZyRqtsZyxM2jkxPtBMYgY48V+Cmjf4U6EincJTcaA0MeghaLYRaR2Bf2AHapD2DsiCWGYfJ\n", + "CGL7OwJPckz6MWUQrJzb1K3lLf9sw+fsIO7iLUz4bD9183KBvxuH2RSka3A5gO1DHbreBf5lHOYr\n", + "u7857k5gOPrtzsF2BMGasQXY1hjbhjOAM+JWU3D2t9R5L4t6rmOCpc60xtSXgB6oUfUm/AjjyDvl\n", + "587zkW4/cbi8iVJsLoZHgHPQmEyfVkoqzqoW/CISjjIWTkc9KZcBFxvjGStFUoDaxph7bSewHmhi\n", + "TNGP/68s+AMQ8IXC3S4bfY0AA2Wv1CTYD3sQbvtAS9QpaRYwsyRh51OHHrcTOo1cwZmr56DpHE9E\n", + "36lFaEewCNhc0Q9MuvdayuD8vhytB9P/D3b1tnvK7/HrZ5Q+HbgZTdZyq3GYyRVpd2FdqsK6CvX8\n", + "/QV93zp7O33ZUXYH3J3AUHQU7JoNzA3WSNujztbAWFTYn4ZSbL8Bvh2dwvMuT/PmR5SiCxVWswhw\n", + "ETpA/RCog+Z8uAX43PtdsaGV1wDNyxthU5xyDjqrmIpGXy01+F55UR2CfwDgMMaMtuv/AjDGPOZx\n", + "zLXACcaYG0SkPTDdGNMpGI2vabACvjNFhXt3fAv4Naj3ZZmm+MFM2VYdsB/V6bg7gizcs4E5nh+I\n", + "a5Rch78lduF5Yskhm/VZ28h5Yqc54LTl1UZjn5+C0uJOQYOTuTqBhcBy4zBHy9ROGTcP+XAwJ70B\n", + "Pd+GNxeolzHjyqyTD6g+9dicjA6ebjSO4MTUEafURR3AbkfvxRklMUjsjK0H7o5gIBrx0zUj+L6s\n", + "MywbgqAvcCYq7JujcYimoJ1/YcJ4lzPesMvhqp/h77/Z7eWPnNkMVXN1BD5A1Tr/A+71l8tZnHIL\n", + "0Ms4zBXlqK8lKvC7oJE6F5S1jDLXWQ2C/3xglDFmgl2/BOhnjLnJ45gw9KXpBMQB44wpHt/izyT4\n", + "SxHwmygq3FdTDgF/PMCOxJJwdwID0fvloo0ubpaS8O8hZN09mZwY13klTf1tma0p2hF0BX7DY1Zg\n", + "HGZ7iW0rMttwRWuByozxY703n0E7xvHGYZYEsexT0JnWATQN4HuBMLGsT0Bf3B2BizHkmhEs8cUY\n", + "sh3OSFTQJwO7UUE/xZ7j07js8jSf0w6uOwPWvAQRBeWKnCnApajK62NU8LdAhfGiUs5dihr5Z5ah\n", + "vnDgOpQk8CLwWFUxqapD8J8HjC5F8P8XaGiMuVVEOqAf9YnGFDX4iYhBp6UuzDPGzCt344KAkICv\n", + "Wtj7fQrujqDjgInkLNxBIwO8cRJ0ToOuaXBZVuCCwArUPrg7glPQmYarI1iIUlILn10wQ0qUFeKU\n", + "c9FR6nPA48Fi4IhT/o2qOCLQUM13GEfZvjGruhuI20bQBb1/36Eqt/aoGudk4AdU0H8bqEHTpc58\n", + "HRKHXgFXroAFv5ZNnSlOaYEmQ3GpFS9BO4CnS/s+rY1nAdAyYFuUU3qgxttctGNZW8opFYKIDEFZ\n", + "dS44qlrw9wdSPFQ99wIFngZeEZkKPGyM+dGufwfcY4z5yausahvxByjgPdU0GyuaeSiE0iFOaXjG\n", + "U8z/JoNu2RFwYzKsbQRrG0Im5OVGswhY67VsK02/b0eDiXjOCtbXSWRB0lGy4zM4lpNG1Lan2Bd1\n", + "KBDGTmXAqgzeQ6calwbD4GrVYr+hlMI6wOOo4f1uUrp3LKu/hJ0NjELj0Q+2ZebbMj9B1TllZgy5\n", + "1JnpnWj60xl0bvcyF67NNt8EcH2C0jIfA74E+qP5Cf4ZqOFcnHI/0MA4zC0BHOsZj/8/wBuV5c9S\n", + "YjuqYcQfgfbyw9EQuUspbtx9BjhsjHGKSBNgOarzP1DRxhc9v3RHHy8B72lobY1/I2tIwFcjfCXN\n", + "MECvbuSdOwm8AAAgAElEQVT9Oo7NwGY0kFk8+mzj0HdyLfo8XR1Cqr8RnEhSMtL/BczE9oUqnXoX\n", + "FTBy6h66HfkO96xgVVXy36364G6UEfJP4zBfBKHM0agqIsluuoW1cf/mm7MLyHqvnvtI3wwmcUoD\n", + "NGz0GehzScWtwlmBsveCxhgSp8wGPjQO80Ypx7VGR91N0Oc9BM1s9mHAwc6041gHXFaamk2cMhx1\n", + "xPoZNcrvCqSOykB10TnH4KZzvmGMedQadDHGvGaZPG+hwjUMeNSY4syFigj+YtPyiKPQ+KKtDJj7\n", + "ET3ScylZwLuMrCEBXwPhj8n0YyS3rftPYZC5Eagg+xGdpm9BVRld7dINNShuovgMYT0po7+AaaM4\n", + "4zpo8iv8MRi2DIZ9jy/itvlv4VYRNUcHNy4V0eLKZGu4IE7phxom56AexhUKwSBO+RI1eD8EIBGj\n", + "5pA/YygtlqgBe6crKkHydFKmJaP3z+Uxe4JtxxRgakkCzw9j6CBuR7JSGUPilFPRa+/k6xu1dVwD\n", + "PAzMQBlk01EmzQHv40upqzfWHuCvs7COX0/Za7nBOMyUstRRGThuHbgKDXFtvoezrob4rXCwPRzZ\n", + "u5v2+1+jqA4+JOD/ZAgwyFw9igaZi8UjyBxKUeyEuzNwLYlMGgrb50QRmQUtlkDb+dBmPrRcUEBk\n", + "/s9o7Jv5wCqmNLuULR0uI7J2faIOx9F7/Q6SjszGPStYXxnTfWssfQHoB1xcEVd/cUpbdOZ9knGY\n", + "P0TOXQlf9KDTFDj7Spj1JPxyBTQctYMbZ+ai0yDXqH5eWRlSHvX6Ywy5DMULfDGGxCnTgS+Nw7zm\n", + "tb0dMAn1HD8ANAOuNQ7zfTnb9wyQYRzmfh/7BPg7KvQ/BO4Lpv9IRXAcC37r6BN1UHneBzpCfi0q\n", + "i3oXQs2HOKU9RYPM7cDdCXzvGjWLUyJ45PQ5HJt1WrFCOvQ5xqXLV6PhlOMpoB0H6wobL6vFliHw\n", + "xyDIuWcbA6d8w9B98eisoB6wGPesYGkws2GJU8ajRt9HgWfL28lYXfaJpHR/Azp8Cl8pa6rRGrjw\n", + "HEgdCesWZ3P5T5cDn1WK45HaCE7GrRryyRiyM55P0ZF4ju1ArkcZNAvR+/4c8ER5mTRWrbYNGOad\n", + "x8C+S68CjdH4OkEJ6x0sHMeCP/BgWSEcf7AftWeQuZNQvrzSRh/o2pSCU58txuBpPvcBrtm0C5e6\n", + "aFedcdSLSCAiG47V0aTt6S1h34GtdN99DzorMKhqyKUe6gVsoKiDWWpFBKkd6U5GszRdXp6Q2dbe\n", + "tYH1DcM40Ko5SzvCQRufoPZhOC8pnxa79hCbH4Eaaf9jHGZHedscYJtcjKHhaGfgyRg6E1XDTAfe\n", + "QDvYcDTA3nUVzVQlThmGpjjs7bEtEjWE340awp+tiay941jwVx/1LoQ/H2yQucG4O4LG/FxvNd+f\n", + "WJ+M+hnkHT3ki8FTOLOM3g/x22BvktoEul6ayqC1q1Ev1DS0A3Cph3ajwv+Uej9zTseV9K2TT/jR\n", + "fA5u6MrUtNN4Ew1jUSYPUeuZez8aYO5q4zDflkZwsLRWV3iEsYAhJ6IJH38TQdYaCJsBInCkCWRu\n", + "X819cz615c9GBe8LwJOkdB9cWRFTva4xATXSDrftbYNSJv9AA6rdSRkyVZVS1xvAGuMwT9v1vqix\n", + "eA9lYAVVB45bwa/nBxYsK4TjB4HmLrDUyREeywGKBplLh9JnllYFkYR2KoNRQ2MmMD9uDQdGfce5\n", + "n+ynjeslvySGw1PGsOdwD1qiNijPWUGptFTb9kHAe+yp/QsTL+5O3lsd3HsnbKTLjIe4aFssKuwH\n", + "ojMdF7f+d7kqYS/rL2zEjw2BCKi9D/qvhX4/5BCT+29U/fESqtvuSa6MZMaAPJYvaIIJc9cTxIip\n", + "Pq6xM0oQ6YGO8ncCUajtwWUoLneMITv72WnLTwceBC5EO5bJNSGAXUk4rgX/nxVVlVilqlCZ8fPL\n", + "gvLmLrDC+0TcIaf7oXrnWXzWMpNVo/8JEz2Eq/+ZpUfCkEENNnJ/rSY0CzMw/y3oYLlAyTB9Wgrn\n", + "UtTBbAA6svV0MFvhj5ggTklgU/21xLZowufvQ61M6DRFl3prconK+xB3eIQiYQqkTbtnuWjXLby6\n", + "UdVWeqdyaTl7EldvaYiOuCejFM75TO51IqdF9SM6DXLqwtrzYU19OPBlGsStDuYzt7Oa21FP4y1A\n", + "Q9Ro3wql8PpjDH2HdtgBxRiycXVuQgO3vYh2JHcah9lf0WuoCoQEf5BR2UKsuhKrVBZ8qdxqMT6r\n", + "R8S3m+vWTt+9uRFvbrmCBUAkSrd0LRVdL7Yt4Q9OOzmXRsfCof92eOQ7bU85XP9demelja6La8/3\n", + "SZlkJqSTfWwXuTseNwVrSn1W40TmfQyDN9aHtocg0ppkfcWgsR1Ge4qGneiI8uQXNZ3G0R7LGVgv\n", + "D3ENFlZz/t30GjOYEXdBXhT8ehn8fiZsf2a+KfisSPlF6pIx0xnaZxQNfofPPvbYUziL6YIK3jOB\n", + "feyp25z318TRfhaMuAeO1IJpJ8HWr9ynhv9jG2bxP03+mm9Luy9+2+WU7ugoPx4V+C+jlM330ZAb\n", + "T3sdH4ZSTV2G4tNQ6naJjCF77hTU/yAeZQXNKW+7qwMhwR9EVEUSEJdzUr7AqsbQaT9E5/kXTtZI\n", + "6SngyiwQK3X97b6N2bK0FgOegQMdYP3ZAIS170vdC34i25B/LJJDJpJ0lCmTa389F912MLI+afGJ\n", + "5NUSTH4eDQ6toEnOBh/n+Fzv+yWOBzJJisyHJpmQZNNXVzR3gU0O4hlk7ihFg8z55I77ckSDwDsi\n", + "a5c4ucEPXD5yCedNPkJh7KLLa7Pvf3Ht09IPrO9KQiqcN15H71+/AVmXTYetL/gbwIiMm0fk24O5\n", + "uh+8Px2OtLClFmXEWQro3fzc4hoSTTiffax8/35j4dRfYeXfYf79kN1AT2h3ci6XL5uCjp7nAGsD\n", + "VF1FosbUO9ER/E40DMIauz8JtTkklkSn9GAMuQzF3oyhxUAe7pH+MyhFs1zROKsTIcEfRBTqc+P/\n", + "gHpblMERfgzq3PMzZ696nCCMUhN20K97HvUyIzUUQU6EBqTKNxQURJCNOzpYuD1HKEXgBXG97Oc8\n", + "eO7H5H8+gN6vQZvv4YsPAGgfN4S7O80nNhcej2DFqrP4FxorJ9N7MQ6TG4xOt6KCNhDYkXk33E5k\n", + "A1GnMFdHsMilnglWSG3Xdc1uD5vraRa22Fy4pz7Hfh8aHsneXsKunlB3OzSfm8+UhpNZN3oATCqs\n", + "N5rx2YlMXVPA4ftXM/pmmDYKybfRR13wzYiTZomX0KjVK4xaU4f5Dli2B2JvgCEpsO5vSgMFiDh3\n", + "Ef/98iVU6A4FYtC4OXPRjqAYs6lZf7n+cF8eNbWolVuL8JgtvHKkC7d5U1bFKR+hqq8iuT9Kghdj\n", + "aDiqgjuGhpjYBAyoSq/sYCIk+IOIQgZHn1ehx2T1C8ivBRE/7afdvrkEQcj2/ATn8xn0jSyAWvkQ\n", + "VgB76sBNzVm1YTjfoNP9jnbJorjX6VpgZ00xPhV2lnE74Poe8OQeKIikTYO+jDzlJzIjYVYcafva\n", + "sQLV1fpaDMfC4WiTCHJjYekNsMQVNiVwem515C6wsXA8g8x1Qj2JZwEzm6XUG9cGc2MsEpmJyf2D\n", + "sBdd4aUDhSts8Tsnwg+tISsSMmvBwlrkZUeTkxUVGVEQbcKJzA8jzIRRIMrUyY2BuQ/A4tsAGEVf\n", + "WvHTxs9p9v5Bxl5SFkacSFIyzer+hwtW9mV73Ui+3qTqpSIo+qwsBXWoXYYBBVjvXWBB9FaceY25\n", + "OD6fsNM3wf/NgPsyfKs9xSldUcZUYlnDV1tD7r3ADWie3TFoRIFoNCuZK7xEjchKFghCgj+IqArf\n", + "gECFkx1ZtsDtbdrF4380Gl9krcfvWmBToNEFg4UiI/Vr+sDMp+iw5WWeYxpj0Vl5SSNue52RPHnm\n", + "HMJfPpXITMiJh4ym9oiyOeRVd+4CG9dmODCCXDmLo1H12XhhBKkjNTl61j1ZsD0VwncGaj/yN5O5\n", + "D6WieNqIxCnhPH7WcnI+P5HILCiI0A4AaM0Q3mM+j8H0aXR/oTyMOHFKLAcjZ5ITdzKTf4kgvZXd\n", + "U0rHoc+5I9oBnAMMo4Dw2Dxk7O9w50Lou1OPLUHt+T6qPnq4tHZ6nDMIjdq5BlXxFNj/zVF66FCK\n", + "xhhyqYXmVGVWsrIiJPiDiKryDaiocBKn1KdoR+BamqHGLc/ZwTp0JJMVrPYXa4+l1cqI9b2iwzIb\n", + "fDIjM8Il9AMdcf8VHfJERk+nwfOjOPEdaPortP4BDraD1GjY9ABs/SCVvGWlvlu+BguXxkFOZxif\n", + "AcM2w0U5bmHp716Ooi+9+Yll8NtMY04o93U5RdgcM4kmuZcwvec+0qUBPdevoefh20oKnWBnR/eh\n", + "2cdovobM27bR9LU+sC0e2h+EoZthyS5WLz+bId4MHXFKJzQ2U6K/hCoexyYAT6DMpJuNw3xpt98K\n", + "9PROuOIRvdVlHxiGUnw9s5LVGMZPSPAHGX9m3wAbMrYzxTuFRNSpqJjaqKxBrUqp/6SwY3wz8hFW\n", + "xpWxU/srOuQVqg5H3wonvA8//wO2nQKd7oT2eRCzH/aFp9Hy8OOoamilP1WDa7AQCwM6Q3yneNjX\n", + "DaYnwuKWEHGAw4ea8QQww5dXcp2YcXyYNY0zyGAMpE0zplGFr88pp6OMmydQLvy/0JDIDwMzPK/F\n", + "OkdNBhJQZ6wrR6fwhCvl4onXwZcfwbKW8HAX9h1qTW00CqvLPvC9cZjD4pS30TSbPtVlVoCPQ423\n", + "XwD/9lQN2YQr/zEOM6uUa3MxhjxjDAXEGKoKhAR/CKXCcqPbUXyG0AVlqHiqi1zL9rLqO+1Htw04\n", + "3Tv2SUDn/4k7XV8oMvJOSIV+z8OJ70FqY6jdBlouhT0R+2mbNh31HaiL20g8yzjMTu8yfal9siJh\n", + "QBd+WnkeC9F99Vleb1X9bzsN6FEQHRVJJsMarePefSqnzoXfvqjAiL/INSrz50vUGe2fKAX03+h7\n", + "9Qga+uFBNFNVAaprf9U4TL7nTObi81TVs2aRzhBXpzAL6I3bUNwffS9XoLl0u3mHkxCntEEpoK3x\n", + "kXWrPAlXPM71ZAwNt20rwhiqymCQIcEfQrlhBXUzincIXdEEG94dwjqUmeE3dok45RXU1vBk5ba+\n", + "5sPnLCbqdjgpG/pNUfpl7u+7aX8gAlVhfIQKf1eQuV24O4L5xmEyA7ERWWE8asDrOBfupIl3u8rL\n", + "cvLn42LZM6+THTaAN0/Zzr6mhri0upyztCHts5qiLJrvUL58EWHtmslktqPx4vPo2v55xq3NKR72\n", + "2KqJ+tn7ci0anXMpOiOYh8ZiugelaD7lJ5yzA6gfSMKVUu+FhsI4FXdH0Al1unMZin+pTMZQSPCH\n", + "UCmwIY+9ZwddUYPzZnzEuDcOkylj699P67xbeXX0yur04q0pcM9iolpAQQe4PQYGQVgunDB8D6MW\n", + "phOdL2hYhd4ok+tZNJtVEm7aaG/gJ2BW41lk9FrEmLoFJavTkkSS+8Pzk9TbFYAL61EwYzBLD/fi\n", + "XVQdE1iWqlLothLWPZlTY96h/7aGfDUJOk6FXq8ZpCCbCDah1M7H0Tg7PqNpilN+AJ4zDvNpiW1x\n", + "h5iegMbzuRAN57AM+BbtDJZ5Cn+PhCuXGodZGsg1lwXW7jYYd0fQGO2QXOElgsoYCgn+EKoUlhrX\n", + "iRlNxrOh4/mERdclKj2KU1fXJl8OM3NMLNdNj+G5TerYI1dvxiy+8XgW/i74UmWRsnoaOnK8HY3z\n", + "8x2aUaozmoP3VeMwe8UpdSgaZK4JKlBmomohn/ltvYkEGxry7sYbEdToORLVzc+wy1x/CV8K1Vax\n", + "eyGrgQf/33r7uvaf/ByMvh1MGPx8FXyXOstkzxopThmIpirsgcYAmuhdl2je4TuNw5xS6r10yiRb\n", + "Vlt0pP8F6rnroo4m4h6Bz0X9YSZTQsKVYEI0B7DLSDwcpY96ZiXbXqHyQ4I/hLKiorGC/I7+wtfm\n", + "kP9Ddyb0gVUXw6I7dFe7k49x+bIlFFUZuXLlFostX1Ni/1Q1xCkdUMbLpajq5xgqOL5AR8IrPY5t\n", + "SVFv4kO4Qk6rAC+V6+4Ro2iUXfqg6pPpaEfwm0tIug3Vt0Dnr+Gnf6pgz/7nfGM+GSIybh4NHhrM\n", + "RWdBpA1hvTcJvjm2wBz9cpBHnb1RG8BANJ7+Sy6GjvVS3wCMNw6zuIR2j0Ypmk1Qhk6xROceI3DP\n", + "juAPtDOda68tKMlzSvuevBhDrhhD+3F3BD4ZQyWVGxL8IZQJwYgVVDi6azdHE5MURNg9ZxyAKfU5\n", + "5zLo+hm8vhzSukL4eYu474v/Ulx1FI87V64uXzdrxC+j76TgzUoLm1HTYdVsE9BOYCvqZTocvUf/\n", + "h6Y/LHAJhjpC1NbWRK4awrqsdrRGDaErcUcbXRqIMdOGiBiKzgZGof4iOht4cOQE8mcMA6D5Mmj9\n", + "MOzeA0fqHuPYsZ/pv6E1vY425/v/wNKbICwPxl4PbT46Qv3sXsZhUr3q6oYaesegCU+eNQ6TJk65\n", + "BTjFOMyFPtrXxF5/f9RYfBaQbRzmrlKuKxxNyvM4+t4NRdlF83CzhvyqYkoSwOX5nvwwhjbi7ggW\n", + "dE9hUEnlhgR/CAHBMns6d5nO5OS6nLCiGVz+C1z+q+4vi8FPIs+dz+mtBtH5a3h7HhxuY/ecdxA+\n", + "TyB2D9zSHnLi4INpsPs/vkMBOCUeb+ppeu3hxBDDobbKV/zkU6tW+PPy+csLyyQ5H1UD1UNnAScC\n", + "sXU2MPvcTxn5zjG3/t4lGFanMBfPIHOqDpmL21C8McAYOom4OoF1dYYx9Yww0j+M0rQDM4CHofUC\n", + "OPNaSD9s+KVROmuWxJNf25ZwVSrjP5lBp4zz0eQx033U0R5V1VwAvI2OyBdjU0TaYwS4EngMDeLm\n", + "NA6TZdUpv6EMH7+JaUSTpD/hlXClJe7ZwDA0PIpLLTQHpYya7mGS3DeC5x+OosOBaDgQDSlx7Fre\n", + "nY+PdGVHy+X884wC2h+Ihu774P75Wn6Zvien1AL64sEYitvNsdvWkTB8swYcrJVftNyQ4K+hqE51\n", + "hdXD90CTgfRCGQ9JwI4mG6l36xYa9dql9Ln6NjxVoIHMxCnt2Be7gv2nx/O/t+BogsfekcuhTTxM\n", + "TOSqAbBxJJz8eD7L6t5j5u592m+hnuXLuHlEvDuY+hsgYVNh0LfjOaWmFXyedoBp8VsZFd6QRv9Y\n", + "AbcsgZZWseNL4NiRsqdaKBf3bOC7QHw5xCm1+V/z29nZfgKHY1qTMyOcwQ9A79dh2nOw9lxocUo6\n", + "l/wUxerWu1ncYhNpB560rJ+BaCatl4BHfXU6VojfCVyOznKWGoe5xjptvYayzCYYh/nF67xnAWMc\n", + "5rYS2v4G6q37Juqt61oSPP63Q+0qbVDDrAB5FBBVqwBpkK202RP26DezCHbs7cLHnRZyzq0HaFc/\n", + "W8Nu97EE3IoEBhSnxPb/lIWDmnHCd+3hmuW6eJYbEvw1EG4d+OuJ+v5AZakrrFqgJ24h3wtlcfyO\n", + "cp5dy6/GYdIrEshMnPI34HVSY//HexcN9QwC5nK20v+tb2JkamfijoSRlTOJfgduRvW2s0u9nr+g\n", + "B28w4bIDRORw/dhNRMTmwpW/wOmWm1OawPHIF+CaDZyG2lxcs4GFpfHRC/X9jdZAegsNsQHQYPR2\n", + "Tl/4GXmx59IxrTm74w6wK+w5Bux/FA2R8BkaefMKfzmJxSmN0CxjN6Cj+dZont0XjcPk20GNt8B+\n", + "mR8bfMWKrv0hNorIdKHfml30PJyP0j7boT4ER1Bv3IP294CPddf/eKB7403ckd+UhgnZsKUevDoF\n", + "zvgdbsrU+1xZgQFLKzck+GsgCoXX2VfC1oGw4iq7p/zCy4Nz38traYTqcz2F/Gp/lLnyBDKzU9HH\n", + "gHOBi4zDLC7N2cqG0p2CfnQD0eBYVxuH+brE6/wLevBWBobFyuwxPRn+Qj8NdXD7IhVIZ5gy5x6o\n", + "hcb/144gnyR21Mtgc7N0fo/fxc70R03Baq90lH465wYDd3Lu+vo0PBrF9s5wNBOabjeE5eewP/xt\n", + "EjPuQ716T0MN2AcoPvKuD3RHVT8FKBsmC8gB4tB4OkWF9aq6JzAzuSnpH9YubEvklbvoOPsJxm0/\n", + "hjp8DS0Pr36MyPRvhVGrGsPov0PHA7CyCeQcJSM7gbfrreDw2Flc/H4W7V3nBCMwYGnfaUjwFyuz\n", + "+hkhhSOi+hvg0pGw7HpYeBeBqius8ac9RVU1vdCPYIXXstH1Qgd67WWJFWS9IT9GE1xfEWiIB9tR\n", + "bQLOMg7zmzilD9oR3GYc5kO/50lSMjR/EOLaQo5AeioccISEflG4BMPLYSR+3g2eHgDrYsgljUkZ\n", + "HbnLHy2zJIgkJRPT8wXant2eDrOgw0yI2JtPTv5cGhx7C5htHGav/87590PwfW/i34e270HrNpA4\n", + "DcJzIC/LUDcTwjiGhisX9J3aiXu0nYkaPRPR+Punorr9IcBl6AzgAeMwPxRpd8SoORRMG8qAZ2D5\n", + "NZolDIDk6aRMywSmGYd5o6z3A4oK4PPGwbjVMGMNqd+ewvN7RxAFDCWfwTGHyGu8lcN1N7MncxeP\n", + "btxrPi9Pfd51+/tOq0Xwi8ho1MkkHJhkTPEY2SIyBLXARwJpxsf0M9iCvyoSqQTWDo8RUd3tKvzX\n", + "nQ3frUiD7Zd7jYwj0fjunqP4E1F6nreQ9xtGoTKuXZxyJjAJeBJ4uhwhHJ4HdhuHecSuJ6FUwRTj\n", + "MJPKew01oXOvCfAUDEcg+6ehfJc2mAGoHWASqh7ZUUoxhSh8bzt/Bfs7wf6OkLAZeiSvYejG31Fj\n", + "6BZgJl83P8yKEwZj4moV+iTQ7W74ZDBhd0HBkxCZqY5qcbsgcQaceP8hmh2JtdXtQ0NyPw+kMK3p\n", + "A+xpdQcZCQc5yFrydzxNyur7gCeNw3xhPXcvR+MBbUNnDrOMw5hCu9CYm7Wz+t/bsGUIhJ33A/d/\n", + "cQLQxjjMoYre53Vn0t0cIzt2Brd50TUjUeOsK7xEP2AVbkPxj8EOkljlgl9EwlEK3ukoRWoZcLEx\n", + "bi6tiLgYCKOMMdtFpKExxXNhBl/wewjciGzIi7Z7qlY/XEyAxaTB30+A3T1hFds5ZcE3dMyohQr5\n", + "rujH5CngfylrJMDCa+/3vIbh3d4f9nUFc2aZr92+yI+gHpEXGYdZWJbzPcoZgY7QBri2tWsnVzWG\n", + "FxocYqc5xMai3OQx05FvRxGZCZFZkOmKNuB+fjWlc6/J8PIHmAo8Yxzm51LPk3HzkI8Gc+7focVS\n", + "iN2r7+zBbTvo+ce9aGyaeJR5MhIdnS/GZSh2jnoMM32UquRT4PR/aSKjGc/YGsbNJ+XTMahwvB4V\n", + "lNHkk8/CHoYlMyLIaGaPnbCR/t98yug9p5HS/VGPjj6HU1asZOSesUAG8DApo6+HaZoNpuNUOHMC\n", + "rB5H3YXT/ugetz6q5U7WBSO3tThlApq85R+lHBeFqs9crKGewM+4O4LF/lSxAbelGgT/AMBhjBlt\n", + "1/8FYIx5zOOY64Gmxpj7SykryILfqljCc+Bf9SA3Fg63hqPb99Nu32SULeC57A6WE0fxtiQlQ6t3\n", + "oF9D4rbC4B/gpFQ4Gg9/RG6j695HUSH/W/cUBvviCZfF0arw2k98F9rPhpaLIXYPpEUcouWBl9AP\n", + "dIlxmH0lttsprVDVzkHgstI6IKuWikVZF3FeSzzqaPM4IPUXc8KYBQx/PxPXXJyL65Lz7Sj2HelO\n", + "OLnhjYkoCCc3GrIawbNb7FFuFZk0GTif1pcMosNMTfu3u6c9JmT89YY4pR6bY56mUd540mNzWNZi\n", + "E6vy7zfH1hSLhQM+dPdRB6HZz5A4YT2nbv4VVTk2RW1Ky1GmTCQ6eDmdPGnE723C+T0pjtRX1Xv3\n", + "+iR45Tc40pwiHbhy668HHiQrIpbovIiYTWF0+y6e2J09yCSKDexafnjcllZ8cf4x8t5s6W7phI2E\n", + "/Xgr96+tDfyHVXXr8/Xfojn2jo4UovdTp3eX7ORVaVEfHUIK6RUVzG0tThmKUkkHlXpw0fPqoGor\n", + "V0fQFViCuyP4qaT4V1Dcl2C6DqqrVPCfj1Y6wa5fAvQzxtzkcYxLxdMdFQDPGWPe81FW5Y34MRC7\n", + "D+K3QtMrVnDW6ndRhoDnkoDOWrw7hMKlIqFX3br+jTqCPdAOzr0MYhZkMLnnYnLqR8azrs7fWNX8\n", + "bYxrqON6Qd8fAJcE6hji0+AWkwaJw5dz7sqp6AjkZHSKvQzVl65FdazR6HMaiDrGLEA/bJcw9yXU\n", + "XdtigWyUMeFaMjz+n4x6Yy45+Q3G31GXDvPbqCFyzEZt5ojaLJh9Lxfz+LC3OTrz9KLpAIG4oSu4\n", + "Y95iYCRZtVrx+0W1SB0JG8bC0Xr2oOOX7ukPhbOjsJcT6fY5DHgaYtblksYkOmYUswMEYli3LLJe\n", + "aOwg19Ic7Qx+Jy2yOVlR/WiYU5eMRM3SdaQ5fJ6wiWM/32TpnScAE1GD7TWkXPBq7d4NBjP8NSZ/\n", + "YzjX6g7GE5U9Jbbt/iOZa1tSbzMk3wg7+sH2frD7idkm47sR1pY0ipV1n+LnLu0oiKnNnoiFg3Pn\n", + "xc8ryDvhjpFKW75olZZZEbaNHRQtMQ7TvDzne5QTj6rjXB1Be+AH3H4ERQK8uewMl0LiTCACcAJV\n", + "LfjPA0aXIvhfREcHw9HgTIuAscaYDV5lGXsNLswzxswrf9vKxgixU7KWFO8QPJejlNAxALv8sQV8\n", + "CuOwPDirfR4NWkYweQp9si9mGTPZGwuNPT7DMZA2DRoWCGRGwpHakFELLq3LwqWX8x+8BfCPDU7i\n", + "xzHJZL1Xr7CQuIuzGTl1Bz3SDUUFdS4aMTEcfY8yUAZFDJrebhXFBbiv9SNozlzf1++UZsB/gWTg\n", + "aEQOiaO3EDH4DzhnrfKeAUY1ZNfMG2lJSvfRMOB5mFjolETChYbBM1bQ8/BkYCYpo56E6ZWeJa0i\n", + "IXx3gxoAACAASURBVC2qC3b2FW2XGF4f8AEFLw0kMks9qLMToPWPMPTsPbQ7EIHbDlAYN6Y8obHF\n", + "KXXx7gwKaMvB6AKORUbSJD2CAjHkhK0hNn8/6mNyD/CGcZgCkTHT+1Aw6pXmMzlvnDpBXbVCyz65\n", + "YdTRZQW/RZHRxM5kl0CLJdBiQT618jehI2fXEofOMJuOeIXsmXto+EtTGHEpzH8buu2rML8+DDVA\n", + "NyyP8byEchtSNLxEU9RLbg4wd5STJ8cYRn2C8m+hegR/fyDFQ9VzL1DgaeAVkXuAaGNMil2fBEw3\n", + "xnzmVVYlsXqCE9PdjiYaUHLH0BAdNRfvFL5t1obfTr+To++2d5d6ZRZyeQw3ToA6u+n/XgyLtu9l\n", + "yBUQnQuPz1YnkQvg8KcQP/48+KozxB2DuBzYY8g40pCf8SWEv2/YkhXd+pMXJ5CVTfv1n3LOzu8o\n", + "QVCLU7oAn0Jh4ouT0M5uscfys3GY7ADuV0v0BR6MMjEaop3+MGDoyAdImVFQnJvcvxWHllzFemAH\n", + "a+NGsqibIbPeYXKO7SZ/58Mma93/CuuoZLpnMEJaeMN6TcfgEsjF/5d13d++2ujsKwvI5lBMQ7I7\n", + "R5MbAzOe1tEyYHXtV1HUDvB/xmGWl+f6fF5zw47nEd/xWRqPbMlJkyB+C9TKBMMxwshCNQKLgC/4\n", + "pGX20DXHXp7D3uh9MZAfBk3tPHtYQuTRuVfHR7Gzr+Zi3jhaPbnDRk/n/hl3o4bUfujMMhHNC3BC\n", + "n3eJWLaJcIC3esITp8LSiTA2jvULbqJ7eUMmi1NWAxd7xk0KNuyAaQj63YwKy6VFg22EPbBGM5R1\n", + "2q/0vqoW/BGocXc4KvCWUty42wV4EXVAqI32xhcaY9Z4lfWn5/FbtkEL/HUMBbQnLzycI9E5ZERm\n", + "cTAqjH23NCA/AjrMplbj2fz2Th5tD8NrveGhQaoC2fgDeT+kEWFwu4ABjIEZ02ynG4S2j0bd5J8H\n", + "HjMOU2A7u/ZoPBTX0g3V5y4GFrd9k9pdtjIuOoL4A7HErhzIroN96YCGFZjvsfxmy/weeKx7CngL\n", + "1YviyZ06mswjXclC48+fbxxmS4ntrsSELS7HmbUNYVVjyI5Uj80n41m36TQ+oHzCOxwVxp5LdiWs\n", + "Hy2S9SoAZziPuEA3oR3/M8CUisaSL6w7Jg3G3ADdP4NvX4Ajby5h/PIPUbXiAHR0a/q8jSzbQrh3\n", + "OcOIWD639vhGdB3ampNfhOgDsCJhPxsPXW92pH5SpE7VpfcGHqyznlPGToOPDmmZE86EmbHkHMwl\n", + "Nas9Bf3f4UDzvZiyzujEKV+hoaW/qMj9KaH8SHTgdDYaiyi38RpqnbiJVs1awpx2cMMyuPeHKhb8\n", + "ACIyBjed8w1jzKMici2AMeY1e8ydKAe3AJhojHneRzl/esFfGqwgTUBdwVszr8OjRJ7Tlfitan9o\n", + "9BvUzqRZBnQ4AM0yYG49ctKaEt4ylbyPFhCVtBfic+DCePKnJpOf0ZlNKEc+1et3cyC0MTsCdaL0\n", + "uL8bh5lfyvHR6AeVXPc3zh89h8SPD7r7o0tiODy/LSnbx/G8z2ibTrkbHZGtqPsrF3X6la71sjmS\n", + "c4w9Wxry4raLeRlVOU1Gp+vnBJv+FijGicz7BAZ/0AO+7AoxubpMj2D7Hz15l/IJ5tyqCAXsjbLM\n", + "jqzAOQ+4A+3AnwXeLq9Ko9C+dfILSgnNj9RUk1+nF7HF2IQmPRss4pYRizjrw3QKnbAurkvOzFOY\n", + "cmBHi4Xsb303mfWO0HDfPpJXZtPg2EnAF01m8kuvhYz1VMutTmEgcGub97it01Yuioyhxb76NF1+\n", + "IXEFtSmodRQjkYSfsxZuWwSv7mHj0nz3jK7EqJhOeRr+n73zDo+iWv/456SRSugt9EQEg4CCVCki\n", + "ShJ7gStWFLAL3nu99p+zY9frtXdEQUSliKKUiCgISAelhA4CofeQQAgp5/fHO5Nskk2ym91NIub7\n", + "PPNkszNzzpnZmfe85y3flwPa0K+W5764vFdi809AhH0CknX/PTANWB/vIDEWJk+DcA1kB0KN3EoQ\n", + "/L7C30HwF4Wrl7HGBW2P5Vy+KartIv7MzSZzVzv+ONWCAJVNgg6krtKgcskljz15oWwE0hDHmEK0\n", + "yjqIg60lkghTdGKwPx9Asn+/ss6/VRv6oKsHPcXBLIT6wTbdXAqENVtK0OXBRG2sB312wos/yzVc\n", + "1JrcFbcXrAoQCtxWiFnycsTH8A4S+jfflWC3JqRPrH6v1GUU1PYH/JWCX1nwdHXkxAv0T+R3L+YH\n", + "cK9fFxFCI8+BcW3n6/0L+7o6x46XDwsg6nAt6qzuS2ZaR1oiExGIEvkd4gDdHraLW1QtbuqYRlDP\n", + "OZGs3tmW1URlHmqeoYjfOoduxzK0oYc4XVtPlcOCsFwCzjsE2+pCTgBkKwg6TlpGA8bVXMvpy+fx\n", + "j0lHaOEqGkiZ6n6ECvpuT+5HsfsjjuKrEWHfHQmomAb8oA29z8W9MbrCo5/KChJFteD/y6GEghwa\n", + "GIcI49n5x5oqHqFL6IAwF64HmlHcrNQQEez7kYnhDPJ8hCMrjiaIYzcIoYD9EdhWexm1L1nBXV8c\n", + "pcXkcJgZCEdqkHc8DL2xOzkZ53LKOu8osLbFas57LJWYdoeh/UGoZ4nvGwL4beozTAauRfwEkYgD\n", + "eTPCATMIqX40t9R7Iw60t5GXYaCn+QzeojyUFmcrXOQDuO0HcLnaGNDxKO02/q7fzhrg4TgaAAnk\n", + "8h55AZKck6vyVFBuUNsjqOCNkWxYmUT2iYlOZw3fzj8m1aFdem9t6HX2t906qrW7B9D+xvXwcyu4\n", + "biN82AWi17EjLYu5bdZzS2QgIRnBcGUOPGFNd/kcOaa6HHhcG7q/h9egkHf4GmtrgdzTaUgltDKj\n", + "B50T9iZD32rBf5ZAmaoXUnTjwaLl55Sp+gGvIua1/2hD/1JkfzAi3GUi2BF+GSej+hOZG0HUyRCi\n", + "M0MJJBCxox+y2olWZ2iiAgkM3QmJM2CKk5i9I4QDc+N4OXUwY2xSrZI0Ykvjn49o9LORZJ+6iOOt\n", + "OyI8GiKO78UUrAzWFuWKt16SF5HC3Ze50oD8CU8oLc4GuFFIpBYwHJkE3PYDFFNwGmwew/3bPgAu\n", + "1obe5MkYlWqfRKe6Y+hEI6Z/CLGzqX3Oo3lnmp8JyD0azukto2DbZZDak3xa6Ia9Urlv0VJt6EF2\n", + "O4lKJXfuz8DFTSH5CwjOg+VNoM8gTjc4QM6qaUTWtcIYHkfC0frgxIopNNJztaFbFB1jsTHLO9mH\n", + "Ant9LiLopyHZvB4VfC98P6q5es4qKFN1RDQBhzb06CL7FKI5v4Q42B/Thl5brA3VPgm6v0Xkc3HU\n", + "3wD1NkDMmzm02b6L8Lz6yCpAAblBWaj6ZwhKz4OsSKh/Ekb/AElW4G0iHE6FO6xlbtMGc/j3gD8Y\n", + "PiGDSLu/O4LZt7QGD21ML5mfRJmqLyIwhlLYcdwCyRnIjyKyBb0y1RNR63mw+7dsrZXtuSPOV/ir\n", + "hne6A0+imJz8AP9CVpEe+wGUqZ5C+PNv8WScSiUmE/D9QEbFwtffwb4L6cJAfgucTdemHVkdeyW0\n", + "/kmYQsdbC+aYS08x4pcQhHLkZW3oE+2VSuqmeGvnbcR12w0v/CIruu3BnOjUnwsmxhd+/v8PeI5C\n", + "Gn8QEtIZrQ192sX11aTAXp+IrK5tYZ/iK19PteA/C2EVwJgNfKQNFzxIwqh4L1LDdBZih62NXdnq\n", + "YOR11AyshQ6AzDqgciH8EORmZRGe8511zjxt6J22Bu8Ang6AfZFQM0ucyQAPhcKcARzf3J4TeaFE\n", + "AnMa/My+jkvoVCsb3NWIrRfmANDBmT/G0iYvovBkkAEsidhGWq/F3DhtB7VDLd3I29BKT+GbimWl\n", + "cwtVJveQ/fv/2gJWNYZb1ko+SWk+DUsB6YlMAB75AZSpolQOu7qNJaXZbnLcnUgLOYuzI+D3u4hk\n", + "BlcxKHMjHcJ+x6rUGJDjVBHu8pU4floCXIf4wr4C3ot30LJ+Tf69+G56tZnDurw/eOY8eHQS9J3X\n", + "EjbXLeC/dwC7i5j6lKk2A9fYJR+tMOarEGHfE0nGsu31e8u6J+VBteA/S2EVppiNMFo+DkiR84Ky\n", + "he2QzOhzkbDeHQgB2mom9LqPPd91In4iNFoNO/rCzr5wYuRayNzrLGDiSaEHvNUQ4p53MY7Lm0Df\n", + "WJi2h8XLb6e3N2F+IaPU3Ja/U7/TAg6X9MKrgvqk3Rut4/kmdWi+sZ6wIn42TY6pSEerLRj3RcLp\n", + "oIIon0E5JCfnlj2GsriFKpt7yI5iWt0QXu8B09pCvx2wZyMpK67lgrKoBIr4AWYhvEAl+gHaK5VU\n", + "oy+fxzag7iTLmOnORFpSaGo0HVacIeScTAZGC2+bjSeBhStwLOiDBDYMQ8JHRyAZ6+8i7KDfAD0S\n", + "HLzvyoTpvOJ1uuaZ1rXWQoR9Kwrb613WGvAlqgV/FUV5tThlqgLNXbIhb0Xs8cFIdI5dqNzeNiHa\n", + "vglcCbzD6O7/ZM/iOsVbv/YUAZPDyQu2/hcBE08KdcA8B+LHiGYEuLZxlutmIC983U6MiTqPRtO/\n", + "tHov44W3hdKpYFmJ2Jm+3o7FkzG3hC+6QO2UOrDqYkg/V+L6Twqx8BnKis/fVL8XJ25sQnY4bLpa\n", + "ahQDdiy9qnHZbFrffxntpkpx8t8eK7Tf39dY1GeTHgKT4+HhbhxLb0Q2EmI7Vht6dWntuOsHSFQq\n", + "eUowA2NHwezxkqwIZU/mpYWmCivoA31p+izs7Wpp/JcB70oheFM9BFyuDX2VtVq+ASn00gJYDTRv\n", + "8zrP9DnBf0vkv5cVa29E0N8J5ACfI2GXC8uaIH2N8sjOoLIPqYY3KEGLi1WqPRZXiUKSvpy1d3uL\n", + "oLBwvw95mfYiMfeuWP1OAsOUqe4EPqB3SjZT7ziQT1oFwJ2n4F/hXHkv1DgBv7wAR0bHQdJD6/S6\n", + "RGBme6WSEmFcN6iXS4HQBzHpeHNPmsHIrzbSqHmiCM2IbBgNcUmSOORS8KdLBjHh2QVCH+BIRMHk\n", + "5C84mXiktuRReOp7kZB9gERITnbkmxDCS9x2NO5ATnvhasopqBNCVEALZaopPBLYn915sOEG2Hit\n", + "0wgi/X6NAKnw9giItQVe1BlY9Dvbmv/OyBQHm5Fcjx+UqQ4jyX5faqM4065Fe/yaMtVbiGB9yun/\n", + "sXbUShSERmTD0/NhWUyB4I+k9N/UWh0BScVCU5VKHAl9YfccCqc7vmw/s6OBR5WpumpDL0NMPl8p\n", + "U3UCHkAzcPPwGhP2f9Fq37qD+w7XJ2NfDrl7tkXxyeZ/E65MNR55HbYjWv37QM3Syj1WRVRr/H5G\n", + "/rI0IAdqb4N6G6H+Bmj++h7aHNqLCPtTFNfeNwB7ijqArOxgO7np+qKhX1YI5JOIFnMHkM3amh+x\n", + "vF0DDjXcQWb2PsiJgdnnE3wKur0FPf8H62+EhamL9bEZPe22/BXOaGvvr/eAW9ZAQ8sdWJr27mos\n", + "Q4PYM/UGItPbcbM2/GfndzbxRGfJ5APi7Nvnwf0oMXs2pschRix5jP/1u5X0uS5CAyuObbSsKCaL\n", + "SfMSRNO9AvgZKXqeXFJkSkl+gAQHn/g6T8JNcrn7OBE0jNcHHHZehQMQ3f5dRsxrBXlCBX44I51m\n", + "qVuomXsOsAgR9t/bvillqiRglDa0i6zoikG1qacKIt8RFTcLrnhAePEPt4OMnzZx+Zq7gI3uVrLK\n", + "b1OWmh8iRdOT7POtGOcvEB/AEKeHMwAYjIRFbuCTbtHsXtIrv8GwI9D7Jej8ZjY1cv8LvGonTPkj\n", + "nLG8iVGuxpLi4AiyxC4W9uor2BPVYwPgnW7Q6hh03ge/7+fU/jAch/vwQVmx18pUMcyr/xQrBwwl\n", + "/UsnjXbYn7D0wZJt/FW31KSVZfoPJDqrNfLsfaYNnVLKOfl+gOCjrE6YSuz3u2lm7/eFYlFmKdDI\n", + "tldzT+o3TP4piFRbzxmxFTalwfzOnPstDB4MOcGQVRvC9ucSnPce8JY29PYi19MGqeoVSyWhWvBX\n", + "QfirYLilRb2CLDsvRzThLxFb4zOutC9rtXAfOcrBhtaKn+bV5IRNbT58G21nP8dNqf0QTe5l4H07\n", + "TM2X0SberCRKyCzejTizn9SGHlueMbmCfc3dWdZ1MUdrA5wJhJT6sLIJ/F8su/bHsx+ZgHchBTZW\n", + "Wn9/R4jprre2c4HpzGy0g+WdujtXqyoe1eMf7iF/QpnqXGQCuB2hNx8LfF2SUmP7AVQ2j0YeJqjt\n", + "EvbUWcvu3Xn+z5NQKjGZC68fSPwkGP+T054rj8L0OoQdhe6vw/lfwccrIOqmpTwwewGyylmKOIN/\n", + "jHeQ0BQePt2CAaE7mbMb3qyM0N5qwV8F4W8tTpnqCeARJIX9dm3oWW6cU4s9oR9RL/s61rbYxy+t\n", + "NnNq/0Jo1gOiQqlxLIjE5UF0SmsMPMML7Y6Q3esNX0ablGclUVo4ZYqDbUjk03+1od8tz5ic4fy7\n", + "RTKDJEYxkW35+4s4++wCJBcinsTeiN9GIxFWc4EpwDJt6GNF+/IWVSm3wDIFXYZMAglIVvhYYLar\n", + "KDDr3l2P8ALVBgr5AfwyRjV4HgET+nL3RfDldAqUnxuOwTe18w9MGCXcQl9nJ+u8WYnKVOFIsfYH\n", + "1RkaXbiQ4NnLqVfH8h5UdHhxwfVUC/4qCX9pcareOTcRWu8d2h6LpPP2AH6t+0+9ZN/7bp8vHCEm\n", + "Oeo65nbJZsnC+uSGWHtHbKXDrI+5fs+1HA3rwKzJkaAlE3K7zQTu2arFMlGFWlsNp8+h7nzfbBnD\n", + "hpwh9nQQDFkH3Yun0LdECnOP0YZ+yd1xuRyrvVLr/zQcjSVybSRtc8dQi0VHg0lfZk9U1sqrMyK8\n", + "bkAck1MRHpkjSKk9m5u+E5IpvZKClcHKolQUnqyu/EEd7StYUWk3IZNAU2A8ItQ3uji23PkAHo/L\n", + "/m1VnlQGy8flK6FFdL6CE3gGhjU5zeGchUztkZv/e6idb3eO3fBM2w50m3GOcFTdt0JaqAwep2rB\n", + "/zeC6tDsEVJ7vcTxryUyK34iXHFHLstqPqbnHvxfsePFzu9KqNZgVttxnF+zA9G7YPXtsP8CCMyC\n", + "6BdS6L9lNBsbP07TnEYoi2xz/WAIOg1h049TIzeLQBVMUDZEnzxARG5msfYLPiskOqfoluXO93FL\n", + "uGl4Oi1r5MLArdDOiidxdgpb/OU/AT8gpp9yPeD5vpk2P8AFn0LLebD5KtiwbTU3LeqCxIHbZpws\n", + "JAZ8KlI6z2WfljZ8DrIysCeDC4Dj2JPBsjoBzE+4k4wJrQrOLHl1laBU8ouNGfhdW6GOnmpR1FQ1\n", + "IjmLZ2ooEpK8gwJTUDHyPYsKYSRiNiozH8DjsZQaDgqFlLTGm9Zz695RTJkeyJ+XWseO2NqVyZlL\n", + "STv/QIQURaro8OLC11Mt+M96WAL8EcZe9Bw7loVw7jTo+q4I4ogDUGeLJoC9iOnHWQAHUViQFnw+\n", + "ULM1mRdEEXxKBP7htlImL/iXfcTvnsyqmKvIGNqKeinQdhoci4UV/eDkpiyyR9Ugp4ZVzP713TRZ\n", + "+V8uO/AzLoS5N3wk4L5T2KpilIzwAI0qTy3lYr6Z8ENw/pfQ9cls6p4KRDT3rxHNtNzp99bvGYs9\n", + "GeypeRd1AuuSHQ4pg+DHN+yrdObNt+PIr62RwT3Nsqhx3Ua4diP0SJXZtTIEkDuwxj4QsZcPQMJ3\n", + "PwN+KWoKcpEP8AaSAetVfQBwfxWuVGIyrR4ZyPW3ir0/PQaAaHocPs6SekWPr9b4PYS3gr8yU90r\n", + "CspUdRHWzjo8f50iZ2p3au2AOlvEBJMTCjF3byRpdX3gmdj3OB57hLuiNMEnNZkl2X7LckAX0pC6\n", + "vw4XfAazwmHHUtGG62yFn18sdI4/rt8Tp7AVcTId4UcZUdqk49JhTDzQ/W34pCBao+aQ03SZ8yV9\n", + "Dn+LVES6BWEcHQtM1oY+4e01ykpjYl8iJkH2QjhTF8kPWpqCY87/IYynVyCC8Lvuo0lYtIeLi744\n", + "VU3jdwXreb4ZWQnURwITxmmjSFnWwn6AOhTwAvnND5Dft73y6/E6HOgA24VMNJCr197JD2FVgbm1\n", + "XLJTa10lNhlKec+NT4LhW0Drgm34FohPquzr8tn9cdADBztx8BoOgiEhufD12lviLBx0UE9xuFt3\n", + "DjjvHA5b4qHYPXF9/4Ztdb5/ckziLGpcO5/Hg85Q48otxCzR/Ke+pt4Gp/MGzfPnfYiHpESYNQjm\n", + "JcIsV9fjdM8icPAjDibjIKSk9obDFuf7dEcI+2pdzXxuisygafcjRCduIfiyuUWfJxwE4+BqHEzF\n", + "wXEcfIGDATgILP+znJAMv2p4UhOUWTCsoNs010WvwsEDOGhW2viHwdbS7ktV3HDQAQev4+AADhbg\n", + "YBgOahY5RuGgFw6+wcFhHLyCg6Z+HVcp75n9LF4bwrKuLciorHteHtlZ6T+4N4Mv9uNcd5vmmjs1\n", + "7aZoaqRpSJxV2dfl9X2Rh/3f1gtxdcE1ly6sezbk19Yj0S9ejM5zOigRXN6TfMHOoHnyt+RJEwcv\n", + "0LpLKv9sqjl3WuEXQiXMrux7VmSsNSzBPBMHYUX3J0CyBj23Jdrsi/65FfpkMLpvLdbioL4H/dTD\n", + "wUM4WImDVBy8gIM2Ho+3Wcs7UVdlgdZcca88z8En84WNq3M8mQy9vp/EJ8n7Nmie/PWtcoWDYLo2\n", + "epYmPQ7QvF8OjXruoVOTJ3AQUOS41jh4EwdHcTABB138d71lKEUOwnBw2psJ37sxoj0956ww9eQv\n", + "x2pvh3NmQJvp0GwRHAo5TtOjzyI8IVvKaqcqwNnscDiS3AUjiMiJRgH/KFp/tjQ75WCl5r0ZRd+E\n", + "W+HTadDF4gX0he1Xmao5pwK283t8Oj+tqZW/I/LmkyRNP8V56Y8Dn3tr0/cVLLvyWCSy5Cpt6HTL\n", + "CXzdgI944ad91FrTECacDwtawOqGEHSM9BMN+QhhV1zoSREYZarzkazpWxFSsHHARGdHpv07R0Lo\n", + "ruYEr72MHZnNiAea8PrAIE4k1yYkA664Dxr9AZMnw+FnCpUqrGhUBImcyz5qDjlDwozjnJf+IWIK\n", + "yk+i8qcfoPCYSvcHKFOlAr3LqhHtD/xtbfwubdQhGRDfYxXXrFuF2EQzEJvvDGCBNvQZb8fsazjb\n", + "sJfGwD8GQdgWjutfuGPjKf29J23ZjtAzgRDi9Ar4wvarTPUBkMTCOvOY061BkephR5HEsvrAE0h6\n", + "e6U/ZJYTdTxS2Hs/wm46o9//iJ+bTifnY08Fw8WxLPv9Jn5AnKjdgd3IJLAAeX52utFnMOLIHEqB\n", + "I3Ncm/9So3Uj3m8bR8x3bcUZG7qV44cyefFwH17HkTCj4HnWcOEYuPQJmF9/tV6yvlMJ3fkd+e/Z\n", + "xS+JrXvvRdYe3/l18vtotgjiJ0Hym7IjdMAiHv95JTAESEEcwt9oQ2co1T6JwJhRXHC4KRdtbklo\n", + "diCr4lJZ2mgHp/e/EU8K/s5zUKaaC7ygDT3Hl+261fffV/CXniRlxQhfgEwAVyJZlHOQSWCmNvQB\n", + "ry/AB7CF9biO8J/L4eMfJFKjPMLaXzw7ylTDESfbUOBboFVRsjjrfici2b/pSHm6BeXt0xsoU7VD\n", + "4uuvRzT+/UgpyL7a0Knu3CdrxdABmQTsLQuniQBY7xw9VCzYoPHmCdyzvRdwA5p6DU/CoBQYsQrO\n", + "PyDCPz8fwdXz3PiaVIZOD6BG3kwkUskrorzyIH9lfd3t8Gd/+GOotWewz1Yi+X2EpMOIbrD4n7Bq\n", + "RH4fVvb5lcjzdzGHQ5Yzs387ts9sKndRQ7M7oMcuaLmO4DXhGVcvTj05JY18kkJ/5DkoU32ChPJ+\n", + "6Ks23e7778rOWRpbH4Clca6ytueUqRoigukK4A2rmIK9Gvi9POF/vkCUhF3SaT8sHQ2tjsv3ZbEV\n", + "usI6rWe2V4okH/LsKFN1R/h+emtDb1KmWoNEZXzmfJx1v2cqU/1o7R+vTLUWeMK55qk/4DTJ2wlV\n", + "UUh8/b8QQZ2L8KvNUaYaoN24T5bJyn5+3nKqE9AbWUH8C6irTPUbsIBvYnIh4b5CEUGZN13G6iPr\n", + "6Jj2XPfJ3NU7ho4TzofHF5LPIWn/zi6f53273qFG3gLgY2CJMtUgbejN/rqPrpEuVabSG0OkcwXM\n", + "DB9OQlYfZ6Lg62/hrovhQEfYI31YSsY3wDfKVI3YGDOPhF1NCYqDlXcLlXXq53BwJER8RO2ul0f+\n", + "ci+Rt2yBN36UwjJlMcGWE1txUh6qOs4KwQ/ysuDmD2lp+GOBsRYn98XIJPAlEGUVV5gBzKmIQgo2\n", + "bOrhjkXWH+WlQbaEl29sr2ITnwIMc6qR+hrwpjLVWFfmHMvOOl6ZahJCKf2zMtUshEtoly/GZY0t\n", + "gMIJVbmIcBgKLHcxkT+rTJUOzFemukx7eJ+sa92iVPtzoFkTiNpD0PHddFm7hoT9bUmPGQKfhBJ+\n", + "GBJHQlozONErgB0pOXRMW1RjD9e+vAFengMBTnfN+Xcu6XlWproZuAf4TZnqQW3oiUWPKQrfUTqk\n", + "vg0jYsmIj6O2bWYfvg12veN5W2X0weg4jpwLP3wM/7gkhykNxhU9Uht6v1KD9zNn4rk0WQGNVxXs\n", + "rLMd7uhKuzFBTJsLYztJNTkb2UR1k9WFz0K/tyI1pf8SOCtMPT4dh5Q6tE1C3ZEkoOnADG3obaWd\n", + "6y38ZZ7xFtbyei5Cvfus0/cKKaT+mDZ0shvtRCO8Qvcjq4SXPHGaFmkrGEntvx4pp3cY0ey/QYq2\n", + "l/lgK1ONAAwgwdOVSIE55uM4GqyDtt9B/BtZ1D2exUcDMjk0uyEh6fJ9zd0QnQoNJ+XS/MhRlUOE\n", + "gvAW6dD0BDRLgz8yOb6rDl9lnMNsxJ+QChwqafWpTHUBMBnhJ/qXq5qv4HtKB6XaJ3GRfoG2R2IY\n", + "f+FKf5DIFXOmjph7gpjT9YCBRQMGSs5B+T8IH0kXNYDlJ9cU23tRYB9W5P5q/ee9g9ri8x+vS6gY\n", + "6AAAIABJREFUDX1+edsod9+VYeNXSiUgCRWBwCdaF68Lax13ESJEB2utp7rYXyUEvzOUqaIQwqkr\n", + "rO04BSYhv1TaaaLqGC3IezACFXwSnb2TgHf36qOmr/vxBMpUHwENgBuKCiJlqtuAO7ShB3jQXmPE\n", + "3DIYqc70ljtFupWpQpHf43qkrul2RNhPLa/ZQ5lqCBIJcqU29Aq3z7MLft/XQQqrbLxOiqfsevlH\n", + "8hQuhVH4pUt49JfvgIsjN9Kv9XoCg4LITI/g1O42LM9sxn6gGeKLaArURJgu7Ymg6N804CUk83eQ\n", + "K8Wkj1Ir+kDnA5GwJxLOtIGIJrAgjIPHWtjFafNRmjBw3lcXKfU5v7Rza62iYbsVxEbkEngykNwN\n", + "Xdh6/EJc+dPKEkIaqXlzDFhbaM+qWo34JakTGRMiC758EuGH60NkaJ/Mq1jIl6d1vrl0cHQgsxIU\n", + "GTENYNM1sP1SSH3/Z53+s9vPcFFYsuIAEFnRpuIKF/xKqUCk3N8A5AFdDgzRWgoPFznuJ6TgyGda\n", + "629ctFXlBL8zLHPChRSsBuKQa5qO8HEf8rqPSq656nJMprobeBjo5srsZZnKtiOC8w8P2z4HeB4x\n", + "tZnAp8U0OlNFItTT1yNv82pE2H/rK3ORMtXVCPXCDe46ofOdkHW2wtFYCiz1g3+F9a+6UQwkABGe\n", + "F1PgMA6msMN4E9CYgsnA1d8oxIFeE1iCKFepwO6GP9H8kj94ecIpwmyT0qhgiGkAU+qxbvl1PO18\n", + "SaVdbpH/hbVVzHcuz200iwsHrmLY2Gwa2d8NDWH/jxfw6f5EnGwypfbrvD8KCRb4HKFGLtif3PAC\n", + "1rdLIC8yhNyMUPRpCKp3moCMbOI3JDfkAO1SSIjMI/gQkc1T6twfmRHVSWhG6myD1nOgxU+5hOT+\n", + "gQR9zAF+89SBrky1H+hs18GoKFSG4O8BGFrrBOv/xwG01i8XOe5h4AxwETD9ryj4i0KZqhEikK4A\n", + "LkUqaNmrgT+KmhrcsbPmL1uTHhRH1YEO1h7fhMt5SmuhTNUTYZm8uDSNWpnqMSBeG/p2d8fifD92\n", + "tCJk1Q2E50YSBjwZ+zaBTXN5OjiUJmnhRG/uyOq0TnwMTPNXBJYy1QDEx3OrNvTsMo93i+bCfUZW\n", + "y2zWnIJJ4GJEuC+hYCJYVlQYKVOFWcf1B55DbM1rgJjwI/QNCyMqPUTYI9+0jHH/B6z0psqVTMYH\n", + "gYiSTGp2hFq/oTDhG4ixVAavqmuZqgtC2tbbFcOnW22U9LsFDfyRp2e/iLzLA5AormVIhbE5CItq\n", + "LpT8LitTLQSe0ob+tVj7fkRlRPXEINqFjd0UcXAopWKQosT9EcFfNZwKXkIbej/wKfCpZQPvjUwC\n", + "k4Awy0E8Hfg53kFfF3bW2PZKUVj4R4UCkFlHOHDsGGYf1Fwtq/ZvseNN1QSxId/phhnlI2C7MlVT\n", + "HPEdyppcitmd/4QhH/Hnt7ewJrsW448NJuyTZOi3wxrln0Qv/o7d67T/wm61oecoU10LfKtMda82\n", + "9Leln+HkhMxHgaPTk2ADq38N7LS2LwCbbK4XMgm8ApyvTLUamQQWIlrpUWALsEWZaiLyTHYGBg98\n", + "h2lT4fzMIMgMLuhrC5zeBeV2yGpDZyhT5SKrjGLsmlAQodY4HWaeI2GrUL4INad+VyhTPY78Rl3L\n", + "F3hRwu+Ws+dtbej5iPnKUKaqiZiXLgXGADHKVL9GbmHf5Q1ImnKQFraktd9lHPmRPRUq+MsDbwW/\n", + "O0L8TeBxrbVWSilKWdoppRxO/87TWs/zbngVAyvEzF4i/tMqx3YlMAr4Ys8wsjqupd6fmwtCNF2H\n", + "lFmhbH8MheHd4KdXhHzNJ+FyzUbC6DhazoOsKNjXGXn4k4qFtVkT2TfAB9rQM8pqWRv6uDLV5yyu\n", + "8wb06FTW5NIMRo6GuNSa8M158E07WNuQVlG7CY3/is33NKPjsKvh9R/hmk2u75U/io9oQy9SpkoE\n", + "ZihTRWhDf1HisWWEEPsCWgqZT7M2lKkiEMXqYiRTdYIy1U4Km4duAEaqHH4/GUEoJyEsRzYbRyHF\n", + "B8EC+xCTj0vBb0eoXbEFppxXIPjLG6FmQxt6jBVW/JkV0uqRIunu72YR7k23NnuF3z88l1eX30JM\n", + "MwXXbIT3ZhY8nynwGxUQ0qmU6gf086YNbwX/Hiiol2l93l3kmM7A1yLzqQckKqWytS6eiaq1dng5\n", + "nioBS0N+HXhdmSo69ncWrWxGvdd6woZ3C17C4tqPpY0cGx3HwfZw7g+wPtlH4XLWaqJGGtz4D/jq\n", + "B9jTlaKrCcvk8C6wF4nZdxdvsTl2E4wOpn4K1NoJW5JwNbnY2uCkeEhpILHsl/4Jt+ewGWBIGtyw\n", + "AZTTK+18r+wVwwcBxAVoCYl0vYLyHNrQq5SpLgV+VKaKLC0hx1Ot3ltYDvBfrM1OLOuErDZvRJSs\n", + "TGDB+d9ydGt/Wt0zBz5yErV3wqm9Yp/3Frbgd2lySYW3R0DsS1uJu/8KOB0ED+awzZuVhhMeQia5\n", + "R4D/enpyeX43a4X/5WCl7p4IMaMjI/kwry39iKAGJznOlhhI24pMvD5FUSUnXpQch71fKWV43KiX\n", + "5EBBCBdJSyAECe1rV8rxnwHX+4po6K+y2URgzmRpJRGm5ZOldeu0gbtqHfQVCVYhlsE2PwirZtNF\n", + "xYi/cHAvDlJwEOVxHw0uOwha03yB5oF2GvJcMnba96PolgizSttX9Pzv26BbjUK/2hN9KLxkArpy\n", + "3S8hAduOg/9U9vPjwZgVDs7FwfDL6rP/SBg6qSf6X0FoA/TToC+DtT7q62sc3FzaMTZ5XPS9pHVs\n", + "z3JfksfhoDkO9uOgf0Xe4wRInk6kjmVwoUe0BkNOcl6zh3Hwuy/7c8W+OrwIy255ZKdXGr/WOkcp\n", + "9SBSVzMQGKO13qCUusfa/5E37Z8tsLWfovH5rrQfWxux6nvuxnF8tY9GUWDb3HwlfDsObr4kl+VR\n", + "P9tHKFP1Ap4FepXLfpqetw2oz65eEJANMcutVUVhU1VZ96Ose2WvGK7cLJmY718EcSMhYgcXKFN1\n", + "Q5ygXvmStKG3K1P1RjJ8owCjKnAOlQZrfJuATYkOdWMdGDhjUeFjLmpNO2WqXygwDy12xWvvRiCA\n", + "rfGXCDuBUJnqidU30kSv9V0uijb0LmWqWxBzV1dt6NQyT/IBUuHt4ZzXez8Twwk6DUGZEJBDVuBr\n", + "4RwefAOknqOk8HwQEqVV2t8yj2mRwLCY08Q9HQDDVomp2BeZx9UJXBWE8hQXt+Lnd3hbPza/vaKR\n", + "JglLF9L96MPI8nQbEsUwXLtRsL3E9qM6fEP6l6H0fkESl2ZkuywsX9r9KOteuarEdTgcuvZi05+9\n", + "qIHUun0fKe13qjzXkn9NpmqAKDbzkESpqvHClIGSkgHn1+KJLQ+TQUH00IXABgp8BAtxxHcpK6xY\n", + "mepRoIE29CNljUWZqgMSHRbr6/tnRZRdD/QpyhnlDsrjKwpSV6/J5fvzSRwJHT+H3GDICwJ1LIvI\n", + "rGCktORppIJOdgl/S9uX/7f1cm669STNg/Pg9tXQ3PKoFCo3+nclaTtbYWmvXwBt/CVwLHv210gp\n", + "wfHeTjKqW+Nn2d9iJBm1NnDPnM68FztYp236zutxOmmgQRyO6suKRnNIb2LvtzOcUxz8iEwKDyCO\n", + "0HHAh97QclvUvzMRVsh7fUn560+4o2xYSXFdKAgh7UlaaAjbbgln18Wwszcca41FI+dc/vE2JOP5\n", + "lrLGYfmNdlrHr/flNVptT0GynO/15NzyZjWXFsqLY1Yd4J/a0IuK7/cc7pQbrRb8ZxmUqVTAaXZ0\n", + "msr+2M1k+oNS1npxpiOxy1d4SytrJSZtBIYBTyMl8r7yqk0XoaiKofva892etqSdLEWotUZ4be5C\n", + "CNbeR2ozeCy4rdj1aUj8+u3+yNquClCmCmTMJUtodEMXWiyA+uvhwz9AB+DMwmnlPTypDd3fzXY/\n", + "ALZrQ3vsjHWj7ZpIUter2tCflXW8DVuoZgXC/khoYWnTZeUalFqs3ZFyS4Of2Hfhb7T3RcSZW+yx\n", + "1YL/7EJ7pZJC+zDu/NrU+2yafOdrSlllqvuRDMx/I6uL27Shf/SyzfuQLNuvgaHa0C60Iw/as+kR\n", + "Oo2DQ+dBak9rj3uJbZZWOwhZBTRG8g7GeJoMZrUzCaDNa4xpncF9/uR4ryw4a7SRzKAtbxNBFln8\n", + "cTidtDvWaT2zyUXq3mMX89pVb7LCnetXproCeFQbuq9fxiz02/ORVcVKd84ZrNS8SdB3Xkt44lJY\n", + "PMb6voRiRYX9HvsjxdVUK8M5JLTeQDUhcQGJ4zOpbZ/n7Ttb1sqtWvCfZUhUKnlsBAPbPgi73oAo\n", + "q3SMrwppW87LKUBPbehtTpm6Q7XhFX1zOGLnvBSxjXcqr/NNmSqYHzuspWv6uRyNhZ/+C/vtWiSe\n", + "88ArU3VGJrobEfPN+0gilFsvgjJVcPAx5tQ5wUVbJxAWaf0m/uB4ryzYGm0k18YlMYqv2UZOAATn\n", + "5V/nF53CuX36SFoft3L0y7p+65nYD7TQhj7ml3GbahDwKtDFHfI/W+N/6WI4FCF5I+D6/Sqm5Qdm\n", + "Qc3bd9B+3ltcenA70Aho2HA9o3pB3f2RUgBp7riS2/QVyiM7A/wxkGr4BlEQ2vAk9N0Jv7Qq+N6b\n", + "7EcbylRNgYkIwdo2kAQmhPxsrDLVVeVt23KofoiwcE4C3KZycBpfkDLVUGAj5++oz7efw/ifnIQ+\n", + "lCexTRt6pTb0cKAV4sz+FPhDmeoey5xT1vnZl7xD5pVHCLv8Njgu2RGMhrjmEmnxl4c4cBePas8t\n", + "hyeyjU8uhOFXy77RENcMHhx/itangyAzqOD70q7feibmA5f7bdyGnowoMl8pUwWWdbwVXbZ1SVPo\n", + "YaklJUXb5SdAXvwSPFYHnoyCoYta0uGkA7gb6ArUqH2IzCHr4JU58IlTppIv3llfolrwV2HY2Y8T\n", + "J0sGqw1vsx8tk8VUhBWzEJ2yNvRShHriE2Wq67zo5j3gJqwVhOVLcGdsQcpUtyORJkOBu/i42W3s\n", + "Gre18JHe8cBrQx/Thn4TaIskAiUAu5Sp3rHMBiUiOo/Q0d9D1z3wYZeC76vay11etFcqKYGUkU1J\n", + "Cwa4eS0saQpfWoTDkRCsgOs2QEZIwXluXP8MJKPdn3gCCYd8tqwD12k9c5Fi1MwWnPl0P0uSILlk\n", + "CnQrAXLl3fD2Fnj+NLyRCu8l/aENfaU29HBt6Kebz2fLjevh4l0Q67Su8fad9TXOmkIsZyPy491z\n", + "y47/dxeWAP4AKUz9qqtjtKGXW9QFM5WpArWhp3jajzb0AWWqKUhkTTYSMVIi86Wlod2EZJUeAO7W\n", + "hp4LgAH+okewKHR/An5SpmqGOIPnKlOtR8xA04o6ctPhtALeSAbnBXZVe7nLA2dnok3dGZENX30D\n", + "A2+F7rsh4xjZIN85w43rn4EUwQn0V2SUNnSOMtVNwAplqmXa0NNKO369wUbg0KwjukfpLVt0Kpl1\n", + "i3xfJEclj9duqkXfr48XKNXevrP+QLWNv4qjPPH/pUGZ6kFkadqjLA58q7hEMlLjtcxKTy7Ob4cU\n", + "cHkLiNOGHubimECEl/8ZJP7eAH6pzHh5i2r6esRUFYuUOxytDb0XKq5gjj/4iMqCbfdOqQ9TwuHo\n", + "XnjLmvZe7wEvns+Z6Km81+MU14zJonVIrgR6unv9Ssp13uurcMdS+ukG/IATs6yrpDQcKbWB67Sh\n", + "byy1vTLqejsfGz1Ibb1oBgfrZHLGF+9sWah27lajVChT9UVs7j20obeXdbx1zvlIlad/a0N/WY4+\n", + "pyMO3qeApvZkY4V9DkIEfZr196eqliBlXf/9yGpkDrIKmBfvINGXE3JR+LpylruwI11mxcHnHeHQ\n", + "IQjaAjma3PQQTq38ByG5EZwhF6UgQitUQC65WnFCB3EcOInU3ThVwufuCEX7t6UcU+i7ojUa3IUy\n", + "1T2I36E7jvg+LpPS7hu/gYZZv2pD/6/M9tyk2lZSavS78rwv5UG14K9GiVCmao7EOt/hDt98kXPj\n", + "EeH/hDb05x6eewkiLLchNM/jkUxhA3nBDeDHqibwi8KKFb8NCQkFuabx2tAu2Sm9ha15r68PDTOg\n", + "rmVQ8Gd0iHO/Rb+3+1Wmaohwcg3Rhp6npARmGBAORFh/S/vcFgkgmOTm8RFAHiVPEmV9HgIEMLV9\n", + "KCfe6cyZCDjRFDIstokHI09Q72SSNvRvPrmBgDLVi0CmNvRzvmqz1P4qgY+/Gn8BWMU6pgKveyr0\n", + "AbShU6wM3znKVEHa0J96cPo8xPa7FvgPki+QBTyKVC6r0gLfhkXT+54y1ftIrd/7gecsDvz3taGL\n", + "F3b1AjYf0Xdt4dVekLQFRqyEiB3+dSCXxaNk+W7uAsYrU3W06gFkAyfcad8y7R0AXnEnxNfySQXj\n", + "/sRif25kfd4FXMEl20NIc0iZzNW3wbKH5HN0ZiQUqgjmC2xFnpEqi2qN/yyH9eKMRdhTb/ZG0Fp1\n", + "Bn4GntOG/tiD/l9D/AqhSAz9mL+KwC8NSorVjECubTuyCvhGG/qMt207a95Hw2B8BxjdGbaGciqr\n", + "Js8iGdF+KUzjJtXDG0ALpFylR7+lMtUXSM3qEimvfQllqpZkBm3i6zkh7HSSx80XwFWJafrdjFo+\n", + "7q8P8JI2dC9ftltif9Vx/NVwgYcQzvbhPmCs3AxcAjxlZeeWCGUqpaSW7Uqk+tppJMa62dkg9AG0\n", + "ofdqQ5sILfmbwHAkJPQFy7RWbiyl8eLGdD3Vj74MyexC3NJIur3Ptpor+T/gXGCTMtUUZaqBlr/E\n", + "Z1in9cyZWidO0rrfTK0TS/ApPI7kQtxdji6mIyHDFQJt6B2srvksgxJyiXIqh9vq4SPk5vijWpZd\n", + "iavKolrjP4uhTNUPoU3ooQ39pw/bbY0UA/mfNvQ7RfYp5KV2IEt0B8Jx8y8kk7cd0NoKozzrYEUy\n", + "3QfciiQsvQ/M8eR6XUWQ1ODmU+HMe/Wo3mta/UQj9usRQF2kPOBn2tBFCyH5DcpUbRF65z6ekK8p\n", + "U9VGSNsaag8LmnsDdVfEOEIDrubjy9eQm3mKh+fUpFb2u95ySRXrR96BDKCxZSL0K6qdu9XIhzJV\n", + "C6RQ923eEq+V0H5LdYbFrZZyvPPPHDgBp5cn8dvRrlyFOPtMYKot8CxBtT3gNCc7fM/+c9ZzqiI5\n", + "bio6NNJyBt+J5AWEI1Es85Hoxyhrq+n0ueC7gxFdUM2jCUmHn1+CNbdarbrmJlKmuhCZAP6BlP8b\n", + "DcwsbzSMJ1CmGgE8CHTThj7twXm/Inb+CqO4sFZG3yJ1wh9Cqsz10Ibe4Ye+1gB3xDto7O/nrtq5\n", + "Ww2gkDP3NX8IfYB4B+fF1+b0yttoWzOctrsaQk4Yl0Sv5vW0jjxVVMPVhk6rm6h+bZlJQru2NPvC\n", + "0g99VTKxNJQQGlmsXyW1hksSyq6FdMn/hyJaXzri/LwNEZB7EEf3TmtfuvVdev6WfOErpH94AVlR\n", + "cKqe05VEunTsakOvAu5TpnoEyYl4HPhAmeozxJ9SbLVX2kTo0SRpnreH2/Y3JD1qq1KJ61wUbCkJ\n", + "dhZvRZauzLOywpcj9bBtumh/YGvDZAb1gEFlPXeVgWrBf5bBWmZ+jFAjv+6vfprByInHaPl4iiT2\n", + "XL8BfhtDyFWaTjOnujZrdP6ZuhOCCYsbCWk1IDrLN9WE3BnraIg7Ggb3XgnpIXCiBnHbI/lameoI\n", + "BUIbJDol3Wlz9f9BJDy1tGNOFfVlWEVdhgH3AvURM9CkopqyciT+G85zcSWlcxNZORKfIYXI2yOr\n", + "gOXKVCuRVcD32tBnmqg6Rj9qPPolWeH2ubZAAnBnkgTbJNXzLSa92pB7O8E5D8aw5btYpdrjhvCf\n", + "DsxSplIV6fPRhk5TproeWASs8GPfW9ts4cbRELczGp7rC6O/r5jn3R1UC/6zD6OA9kj5RL+9UHa4\n", + "4VML4IFlcNkd8GJviJxfcrhhrWx0/WxY+gnUdKqV5G+OG3us4dlw43qIyhKm02c0m+YOYzCWwC5P\n", + "BSdPoA19EHhJmepVxA9yP/A/SzP/sCCpzqlMZj484ybShl4HjFJSoeoGZLXxnronbMFFwZFJX2Zn\n", + "hR0NgycvhQ+mFwgkDWo0xL3TFaacB0F5EJRH3J4QxipTLaKgelQON9Xvx0liyHsS9naBa4bBh7/H\n", + "kTHMHcG2AYnPb4+sgCoM2tDrlKkWAt2UqepYIam+xrawAKIAYtJhcVOY0UbKhVYFTqdqwX8WQZmq\n", + "P7LM7669LDlYFmwCuagzss0bC/3vgJNRxJSkxdnntD1c+Ht/c9zY/YbmwOCUgu9D4bAvnd7uwuKp\n", + "+R74XpkqDlkBLFOmWgq8j4NkHIzyBTeRtZqYgNSmbcOBusnhDQ+EsRtqZ8KPsfBHI7hgf2GBdMUW\n", + "6HAAcgIgOxCMcA4sa85YnGvF7mzchayuEJADAblwKB6uuwO+iC5TsGlDayur+woqWPBbqIOEJn+h\n", + "THWlH4INtp6oQQ2QyfOVOfDYAEjYChl5VYDTyZcV4b3ZKEel+OrN6f45aImD/Ti4tCL6i4ek4bBF\n", + "g7a3IZH8GfA4O3DwPA4JHCjrnGGwNR6SKnqsFdGvh79fGA7uxMEKHGzHwaM4qOfzfhg0rwsD8u/D\n", + "05eg/zlQPifCrARIdr5P9pYIs4q3lZBc6LCAbM1dPTUDWm1085oTcLCwEu51KA5O4iAaB7/iwPRD\n", + "Hy2iBnPIfu7yQPcdiu7elYO+fu7KIzuro3rOAlhFLn4DPteGfqOi+nWV6JPiYDnCaTMLoXjQRc9p\n", + "EMWzKopzQ/ayMNXPBFaljbWyHWwlQZnqIoQa4lpkZfA+sNQXpjulEpMjeXBgEqOYyDY21YV+Q6Hv\n", + "GyGn1uWdGQTFbfwlEbC5JC6rM2gn939TiyB9aVmVsCx68ANIeG+ZhVN8BWWqHsC72tCdlakaASsQ\n", + "4rjpPuwjEDh57qsMaX2KuyMhbEdrQlYMoY0OpkVZBIke9VUdzvn3g+XM/QLQSOhmpf+gylR1Earj\n", + "ucAjLpycAcB64L586uVqFIN1H+9E8gLSkBoHX3ljxnOurtWWd4jgNCtG/JYXuCZ4QtqSU7eDZ5Ok\n", + "K+IyHCk1ET78C7WhM8q4xmmIg3tCea/JUyhT/QuI1YZ+wPq/JxLm2dMuSuSjfjYAgyx/i/3d18A6\n", + "bejnfdZPteD/+8F6iG9F6Gf9atf3BFaSzmwkeuLhosK/5hD1VmA4Qy77lPVnW81aX8OaKAcizuCe\n", + "wOfABzbdsMftFRXWt87fSdzJCG3o23w45s8ArQ19VxnHjQAu0Ya+2Vd9lwWLPfN7begvnL57gAK6\n", + "cp+8R8pUPyDhtN85fReLkCWeZzn7ve+nMgS/UioBSVcPBD7RWr9SZP8tCCGXQqIn7tO6OKFVteD3\n", + "HMpUAxC2y+7a0P6KRy43lKlqAT8iS+mHbAdae6WSLgri7VkPEzt3LLQ7fHbVrPUnlKlaIklhwxCW\n", + "zPeB6drQOa745t1xCFthppsR2uxSNXQPxinkZ6ujv+HbHheUNCZlqhhgDZLF6/eEM6vPVOCSeAdt\n", + "7HyFE3B67kMEn6nLPny0crb4jPZoQ79W5Ps3gSBt6Ae97QPKKTu9dCoEIrwULZH0/D+AdkWO6QFE\n", + "W58TgCW+clD8nTcctLKcuf0qeyxljDMaB4tw8CEOArTW2A5ER1/0vVegS3MgVm8l3tdQHNxq3dtd\n", + "3Bk+jqgh2wv7ZIdvgXi3HIk4mIGDW306xl4NR/JojRxq/VnqmHCwCge9K+i+NcXBofNUcYf/HcFs\n", + "DXiMbTh4yK22iE8SB/egefK32HU9gIMPXYyhHg4O46CNT66pHLLTW3KnrsBWrfUOrXU2wgtzTZGJ\n", + "ZbHW+ZzlS4GmXvb5t4flzP0WYQCcV8nDKRUWX/1AIB74WJkqwI6rf3gJvPhzwbFVIb75rwJt6NPa\n", + "0F9oQ/cEruFkVH/un9WKG4YI6yQacbo2d7cA/HjEZOg7/HZBEgufD+SGmyXkE0oa0wwqjrStO7Ck\n", + "uZakvmUxcFyq6TI2m9geY0kF/k+Z6uLSGilwbM8aCJP6yt8eb8n3+XBJ1qYNfRhhrH3JVxflKbwV\n", + "/DEI74WN3dZ3JWEYlZyx9leH5cwdA6wG3q7k4bgFbeh0IBE4BxiTFiBx9dFZUNspZ/VsqFlbGdCG\n", + "/p1Jfbbx1p+wuzt0f9Npr2uaBxf4HkloauS7kUWFsvhfQjvRZEVpY5qO/4uw2+gOLLaVj+FXww4n\n", + "UuYmQnQ9FJioTNW45GaajYTRcTT6A26x6ZOKTWqlsXS+BXS1HMsVDm8Fv9t2MKXUJcBdwGOlHONw\n", + "2vp5ObazFf9GBOi9VSGCx11YtuMkoPm8BwgeFsBW5/1VsSD1XwvppzldC5aOgknfIC41KIvmwYbl\n", + "0JyGMH76bkw6AL6aJhNSPoqNaTnQwPJf+Bs9gCXpcFoD22tDq2NOI5PKWTMR2pOJVoUxF4iSdUJm\n", + "HWjonH9WaFLbBTS2OKAKwWIl/T/gv5Yy5zaUUv2cZaUn59rwVvDvAZo5/d8M0foLQSnVAeEKuVpr\n", + "fazofhtaa4fTNs/LsZ11UKa6DBH811ckna2vYMUuX3WmLrnjH2RPQgA/DoZfkyDZ14XK/35IfRtG\n", + "bC38nWc0D/jc3GOPyVmuFR+T5fSfhZ/NPcpUIUhtiuWp8PatkfwZkisrTyimfDyHcC7913Vr6bJW\n", + "TW8MEQedTFkFk5o2dDZiEWlVwpDGIzxR13pyHVrrec6y0pNzbXgr+FcA5yilWiqlQhBa2O+dD1BK\n", + "NUeYIm/VWm910UY13IDFgf8FcJM29K7KHk95YWmW12TXIfPHZzgx2cFlpRT7qIabkEiZxaMgKRkG\n", + "/yp/l4z0kOZhHtBImcoVQ5y/x1QRxVk6AVu1odPXaT1zzoW8c+YkJ1wpH9ZkdBtwpTKVi1WQNanl\n", + "BYspK3I/JUy0W4FYV4OxqDseBV4ueWXhH3jF1aO1zlFKPYiE7AUCY7TWG5RS91j7PwJrzSLTAAAg\n", + "AElEQVSeAWoDHyhZ0WRrrbt6N+y/F5SpIoDvgOe1of1RMahCoQ2dqUx1HVKRa6Iy1U2+KFfoKSqa\n", + "o9/fsARqucevDZ2rTPUlovU/WcFjmg18qkwV4cus1iLoDiy2/znYn33A7ElaD3J1sDb0MYvJ82dl\n", + "qnXa0Pk2Ha3XzVSqPZD0EJkne9HguhROZD7nYlIrqxrXj8iqYDjwQfkuy3NUJ3BVcVj2v68Rx+ed\n", + "fyW7flmwbJ+TrH8H+5sd0xklcPT/7XMJlKk6AD8ArXDEJ5QnL8CLvn8B3tCG/sFP7X8F/KgNPVap\n", + "9kkMPPkmISqUH85dX9q1KVPdglSSu0gb+riL/d8AX2tDT3ax72EkS7jE6CplqguQybGNFQjh2XVV\n", + "19w9O9BeqaREpZIHKzWv5SI2Bp6iE38xZ647sAT9ICAX+MbibqkQ2Bz973SFb9vKd6Mhrrlwpf9t\n", + "oQ29BkhjQb1HCsIVJ5YUruhr2MVZ/IXuwOL8UMyQAeew79FmZV2bRScxCxhfQn3j3ZQcpl5m/V1t\n", + "6N8RfqtH3L4SL1Et+KsYbE10FgwcFkvfrPNpc+PHhMQ76F/ZY/MHLBPPP4BTwLdW9TC/ww7nO+8Q\n", + "PHI5ZAXK99W5BACMp17AQzA6jtrb4O4u0HANHuYFlAil2icplZis1OB58jdf4E4HrvA0ysWtPiVM\n", + "NRrYkh+KWftPOGb7Xcu8tkcQKmdXJjCvBL+Fp4EHSw8h9R2qBX8Vg62JnqgBQ6+FiZPh6+O0PJs1\n", + "USv64WbgODCtTS11nb3iSVQqub1SPtcybY7+S/+E+EPwTjf5vjqXAICvaH20EUGn4VhrWDoSbr8U\n", + "erwOKsKribFQ4pP6uuhKYjPyu3T0yVUURndgiThtrVDM3GA45ux3LTnnwVJQBiElLhOK7C5N8P8J\n", + "NC/LeWtRrnyKmJT8jmrBX8Vga6I1s2D5aOhtxe+c7ZqoxdNyW8gRAk/cwIQpwQycBH1nwcAe8Jav\n", + "hX8qvD1CtDH+Oxte6QU3R/JndS4BaEPv5kj4Cc6ZAShYfQd8shTOmwLDf2pv8euUE5a23Xwh3D4A\n", + "apzA1rYtU6a/ont6AEvkoxWKOWEWHHVWxsssbbkXuAkYp0zlHKJZouC3zJn7gOZujPFF4HplqnZu\n", + "HOsVqgV/FYOtiQI0PVHw/d9BE9WGzun3HtkJRwm74hbICJHv/WF7X6f1zMUwKgmS/+8IvwZvY+fU\n", + "20j5Ozt2C+G4HkfnUQXRNcdaw2dtt5F7ZhawSpnqhvI1bGnbqT3gcFu44xKJgy/Qtv1l53eK6Cl/\n", + "zoM29AJEQE91MkuWpvGDm+YebehjwMukBX1aginMZ6gW/FUMzpqoDX9mtTo7kv1lVvEE0XmEfjoN\n", + "uu2GgxEF3/tjxbNO65kztU6cpHW/fR3onNWQbr6KYf/L47x0B632KCL7/5wfg5+3bKQec+o2hI/r\n", + "FWWqT5Wpojxr2NK2dSDMeA+2JMGdvaHefjtwYT5wnjJVfV9dimVm6QwsA5/kPLyN1JP4wPJH7EUy\n", + "dANLOH4b7tn54bU2W1EhXWjxRGkcQN6jIhjx/MUwd7Zu8ZCUCLMGwbxEmOWvEoGuShIOhy2VWZLQ\n", + "k9J/vt5w8E8czKjs37+iNjfYJb/GwX0l3KtIHHyCg2046OFZn8O3FPp5L+58iKfUQRy0tdqeioPb\n", + "ffi7XoiDdT5+ViJwsMa+Pzg4gIMmLq/3slYbubZFqqt7XPz4hGTO/0IzvKuGPKdXILHE5788srNa\n", + "46+CcNZE/ZnVajuSN9SDfw2ENQ0rP6Sxolc8RfAe0EaZ6vIK6KtS4Sa7ZIkUDtrQGdrQw4H/AN8p\n", + "UzmUqcpMCHWpbS88fQfB+j/AXGWqLvjezu9k3/cNrCSz6wHTKuWYShFzT/49Tv3fuYR1aOqe9h4V\n", + "yrohcLoW1N7u9L3bZHtuoVrw/41hO5JrnYbwbLjiZuh8N+zqS5wyVZ3KGJOz7b2ieXysyI3/AP9z\n", + "R4j9tWE5WQNyINg25RcLaZwNxFl0IS6hDT0VuACpDLZAtWw1rCz7tNbrZmo9M1HrSf3k77qZ2tDj\n", + "kAIzM5Horst9SGNQKGPXV9CG3oowDk8CDlHMzm/d46NxUMfWZcoKG7WI7b74sUjEkXtke+7iLH+4\n", + "q1EabEdy4wx4/hcw58IvreDmnkQA25WpZgNjgdkVVR0JRPhTefTd04CHESbZjytpDD6DNYE1QYol\n", + "FWwjancjvDVE7YEFT8Gvz1hnFGiW2tDZylQTEa3/2ZL60Ibeq0yVwK/1PiCt20fwtZOte0SsUu1x\n", + "x36uDf29MtVgRJAeBnoh/EHeogfwsg/aKQZt6B+UqbqqbO5rtZiWg5UaadN/wCBxZB+LhSPnOJ1V\n", + "mvae+jaMiC1UwN5zsr0yUU3Z8DeGK9qC4bBtCYxMcbAICV27E9FkxgOfaUNvqqThVhiUqS5EokvO\n", + "1YY+UdbxlYkSBXvBFgMcBHYU2iZ1uod9Uy7iRDPIDXFqMSlZ65k2wTzKVF0RcsBzy8ocVyoxGWYN\n", + "JOwo5IRCdrjLNt24ps6IwF+oDe32eSW0VR/YAtSxS3/6CjbXU46iydIHiT/3NAHLR8u+EbB1Muen\n", + "pbGmc/EzS78frgrYlzZxVhdbr4bHaK9UUnN4KBLCMiBzF7xT1KxiRboMRdgK/wQ+AyZZ1bXOSihT\n", + "jQX2akP7hKzMi3GUT7AXbKmuCPAKbPxFNcvC0S1W1Mom4FZt6GUljLEx0Ic1zV+nYXQTau2Ar76H\n", + "Hf2sIwb/qvWkfq7OLfG6r631PB3TnmRhu+380mJreXmClKmuQuo9+9Rv46w0PQ007QyPDIRPp8Hg\n", + "FDmmP0Er5zI0uqx77C3KIzurTT1/c7hjVtGGXg88qkz1JFI3+U6kgMR0ZBKY62ttqgrgKWCNMtXH\n", + "2tA7/NVJOQX7b8AEShHsZaEQu2QpmqU2tFamGo9M+susiaAl0Mdpqwss4ERgOks/gX0XQJ6Teb7B\n", + "3hbKVKHa0KdxA0q1T0Ld+A/O+V7RPisWOsfyS4zbJqMi8It93w6M2FYbgo5B2yPQ5jC0cKJwq0dO\n", + "Bix+pqx7XBmoFvzVcBuWnX86MF2Zqh5Cs/AaUFuZahwwTht6e2lt/FWgDb1HmeptpC5quatSuSnY\n", + "D1FYsC8CvqRAsPuFtTSeFJqRoqKAdFCpLo6xBP1SYIr1m/dGKNh/BRYAbwIp2tB5sooYXXgVoYb9\n", + "SfeUvcikcbM29LqyR9ZsJPqTODYPE/t4u6kQdlEcs5o+hOe+nx6UWEyl/IiC0DOBcPltcOknsPcE\n", + "bA+DWXuE2vRyrGpeXlJl+wvVgr8a5YJVMPpt4G1lqk7IKmCpMlUKsgqY4kdedZ/DFTc/Dl4DNilT\n", + "9dCGdqk1linY82gWnElueDpZwemcPBnGr5lN+ZkKEOyloQRa6th2NVTAxifZh2jyva0tHckcPwD0\n", + "A7a5sve7XEXoXe9w4fFZyPMxV5nqeeCd0leIVnbv4n+DDoBlD8JN18CQDZ2VqULcXeFYCVVdkInL\n", + "p0iH0yG5MGEqDOkAuSsgMwqeURCgYQRk7/JxCKkvUW3jr4bPYJW2uxJ5yS9GKq99BvxWlSmlS+Pm\n", + "T3HQAMlr+Cfua+w7gB0xU2lx2Xqe+CynoAJTVeH8T1QqeRYMzAqE5TGwoDnMbwE/tSAnN4TNSAbt\n", + "fGCBNvRuZap7gX7a0DeVt09lqjjEUZwGDNWG3ufyONtJ7Iyg03Bbk4O0OLYKuNEdpUKZqiMwURu6\n", + "bXnHXBKcn5lbomFCGtT/D6x7HxpaI0uC5JnaO+e0O6i28VejUmFpYlMRHpPGSBjgx0Cw5Sz9XBva\n", + "lUWhUmHba6e2g3UNYEct2FGLuK31mIKYNRRyHSvwwBST6FDJn0Hst23hre7QJB1iThCXmctrVlW1\n", + "vUjd6r0VXYHMzuG46UZIjYY+O+GelRA0jWU/pOteLk6ZjJQIrFneSCdt6K3KVL0RCuLflanu1Yb+\n", + "//buPMyK6szj+PcnokhE0YggCi7gijEuUXGl4xJw301EAWPGMeNETSaJMcPjU1RmsjHJRMk2LlER\n", + "jIrGGBcgooJGH3ELIAioSBQ3XACNuKK888c5DZe2+/btvkvd7no/z9MPd6mu+xbd/Z6qU+e85/bP\n", + "btnMkMZPvvU8N/T+Nv+54lTgngF9dflOr3FOK6unHUAV+vch3BvbXeJouOBz73AAsOnX5sFHBRm1\n", + "ngsreuJ3VRHP5v5HqX4B7Eu4CpitVE8QrgJuL/VmX7U1JsG5W8KqLnDgSzB8Loxdydxp53Mo4Qbh\n", + "eODctixy37jfQ5aESXKvbAKv9IBPt2QTwhoEW8evPkr1NmsbgsKvwteWVerKqXEOx58mha6JRleG\n", + "BcY/wxJbplTTCbNVr2vv58YS3IlSTQUmKtUxwHcssZVrtmnpxvNHCyYr1eRur3HrspOZcM14Ntgq\n", + "fte5MGB3iSbJvyo3dhs1Dow4SpoKDP31lHXfr+fCit7V42omVjM8kdAI7EOYqHMt8HiWXUGN3R5N\n", + "Xy+8VFeq24DHLLGSJwKVst+47/WAXqxtCBq/+jZ53p1Q4relhqHx6qHVhNNc99ZwNnx/Bt3HvmrL\n", + "0+a+J1bkPN8SO7yU429NLPA2jtAteGZLw0WbGiZNPeQQhl6zF0ybADusCK838//6DHBaXFWsaorN\n", + "h6lFl56P43cdhlL1A0YS5gd8TGgAJlpiS2sdSyl/uLF/eiYwyBJ7vVL7bQul6g5sRfHGoS/wHkUa\n", + "hvjvG1uN2ezSfmx48Ubs3P09urGQC1jJ7YvgkYuaG3IYl8Z8BfiiJfZyW+MvclynEuok/Qb46aAx\n", + "fKXpjfbC/6/TpRmTYMhVe4ers0FvxtfhgUlmDXGfnyfMOdnMEvu0UrG2pHE+DD3ZeUUPer69lFEL\n", + "Pq7O2sFNeeJ3HU4cLngw4SrgJOAhQiNwVy37vUucyPZLYGNL7LxK7reS4v/n52n96mFTVm7wKW/v\n", + "1Y1/bg1/nlDSTFuluhJYZImNrXDc2wDXdXmPrU7+A90nLWe7xvea3hAv8QrtaOC7lbo6KVW8ersb\n", + "mGOJXVKTz/TE7zoypdoYOIXQCOxGuIF6rSU2J9PAIqXajDCL9XBLbG7W8ZRDqTbkN0MfYKNL92eT\n", + "V+Dp0wj3sKHYTFsd0etiBr13KeOOfTLU1m/fjNoWYlpv+4eY/+5e7PzLe2DEnLURFSb1Eq/QfgR0\n", + "scRGVyK2Nh5HL2AW4Z7QlNa2L/vzPPF3LM2NHc96mF+9UKoBwKj4tZxwFfDHOH8gy7guAI4Dhtbz\n", + "ENVSNDtsEmjpjD/MqB18ORdNG8iNd8LrexBWsmq+a6g9TpdmjO7NkOGnwJV3wkFxDFhhNw60fiWl\n", + "VNOAyy2xuyoRV1sp1aGEe1j7WGKvVPWzskj8koYRZu91Aa42s583s8044CjgfeBsM5vVzDa5SvzF\n", + "xo578l8rXjp/mXAVcCxwL6ER+GstK4YWxNMVmAv8hyUd++dUar2etdvHhuKw0dDlY5jWOCG2bUXY\n", + "imnsxlm1HnQtmOLVljHxceLWcmCgJfZmJeJqD6UaTeiSOqyav6vtyZ1l1eOX1IVwQ2YY4dL8DGnd\n", + "hYIVlvIbaGY7Av8K/L6cz+wsGseOP7Y1TBkIn6yX/SIo9cgSW22J3WeJnQVsS6gRPxpYolRja7Ew\n", + "dZN4VgHfI9Tsr1S9+Ey0fQnCOKP2qbNgh/sKXq/cIiGNC/EUJv12LMSzK/BGlkk/+ilh2OyYjOP4\n", + "jHLH8e8HLDILRawk3URYj3NBwTbHE8ZAY2aPSuopqbdZaSMjOqvGMd7LN4K0Ac45Ac6cCx/NZ4uM\n", + "Q6tbsRrolcCVSrULYUTQfUq1hHAVcLMl9naRXVTK3YSa/ecCv6vB51VN22rJxPVy39oVrny84PXK\n", + "LRJSODGqjBvig6mDcgmW2GqlGkFYnP4BS2xa1jE1KncFrq0JS441ejm+1to2xVakz4XGCTTDFsHM\n", + "q2H6eNjgU3joDHZXqllK9W2l2jLrOOuVJbYwjproT1gk5HDgBaX6o1IdWWTh60p8tgHfJUxE6lmt\n", + "z6k/L40LffqExdKBaiwSUoGlR6s2Y7et4tDfs4DxcTZ7XSj3jL/UGwRN+5+a/T5JYwqezjCzGe2I\n", + "qUOIl7QDGvv4d3kL3riP5wc8yLcXjOYDwk3NMUr1IOGK6a4sinnVu9h3OhmYHMdun0FYbalXQcXQ\n", + "RcX20c7PnaNUdxC6nb5f6f3Xo1JLOdeBwYR5AXXBEpuuVFewsstUdRn6Gqs37VbOiChJDYRiee1W\n", + "1s1dSYOBMWY2LD7/IbC68AavpP8jJPGb4vOFwJCmXT15u7kLJY1M6EEY3jgS2IMwSmA8YQZphx5R\n", + "Um1KtQehK+hMwhDMa4FbCksDVOAz+gDzgP0tsecrtV/XfvEK7GWgZxY3/1uiDXY7lhHLJ7H4mxsx\n", + "Y0x8tTIjomo+qkfS+sRxzYQZgY8BZ5jZgoJtjga+ZWZHx4biMjMbXIng80SptiUshjESWA1cD0yo\n", + "x6Jn9SRWDD2aMCroUOB2Qq2ZByvReMaRG3taYqeVuy9XPqX6CjDaEhuSdSyFpKOmsvG1Qzlvb7ht\n", + "IvzjsPhO+SOiaj6qx8w+Ab4F/BWYD9xsZgsknSfpvLjNZGCxpEXAFcD55XxmXlliL1pi/w3sTEhi\n", + "/QlFz+5VqpGx2qNrwhL72BK73RI7AdiFcIb+W2CRUl2qVP3L/Ij/BfZTqoPLjdVVRN3076+rRzdW\n", + "9glJX4VLEVRuRFRb+ASuDizWTjmOcD/gIOAvhK6gBzrhUogVE8sa7ENoQL9KmGV5HXBbW6pvFuxv\n", + "OKFe//7+/54tpZoCXNF8uefstHWyXNv27TN3cyv2Nw8nNAI9gQmE+vfPZhpYnYuN5wmERmA/Qt35\n", + "a4FHS+0KipPMHiGsLDWxWrG64uLPYRmwaxbF/opp62S5tu3bE79jzcpDowgNwWLC/YCbLbEVmQZW\n", + "52KhsBGERuBTwlXABEvs1RK+9yDgJmBnS+z9asbpmhfndkyxxLbPOpbmhOTfv+Ijojzxu3XEmaVf\n", + "ITQCQwn3Yq4nlDtYlWVs9Sx2BR1IaABOIay4dS1wZ7EhtUo1CZhrif1XTQJ161CqrwNHWmLDs46l\n", + "ljzxuxbFypKnExqBHQiVL8fXS+XLehVvmp9MaAS+ANxIuBKYZYlZOIvrdyH06EbXFeKkmV9i2t6P\n", + "saK3Kl290hWnVFcA8yyxik4oq3ee+F1JlGonwrDQEcAKwlXADaUuMJJXSrU9oeE8G3iH5z83kz+f\n", + "cCQrb1jbtbDRiNV84b31eOy2+EJlq1e6linVU8A3LLHHW924E/HE79ok3gwbQkhmJwAPExqBO+pl\n", + "Pdx6tOb/7dleE+n/cV/+cRg8fj4sPiJssN1B8OFvYeme8TsqV73SNS9OdnwN2LzWC9dnrT250xdb\n", + "z7E49HA6MD0ugnISsYKqUt1CGBo602cJr6vx/006/Tk2vLovu90Cmy1eu8Fr+8L6hWVZshmrnTP7\n", + "AbPzlvTbyxO/AyCWMpgATIiTms4i9GVLqRpnCb+YYYh16N0P+WgTmPWNdV/+qAd81LvghcpVr3Qt\n", + "GkxdTtyqT+VW53SdkCW2xBL7CWGm6wjCeq1PKtV0pTo7Xh24wmqVa/zLKjiy8HnFq1e6Zh1AHZRi\n", + "7ii8j9+VRKk2JKyANYpQ8+YOQlfQDEvs0yxjy1IzY7NnQv/BdV69slOJw2/fBPYoZc5FZ+M3d11N\n", + "xHUCziA0Ar0IXUTjLbFnMg3M5ZJS7QjcZ4mVW3epQ/LE72pOqb5AaADOBJYQrgJussSWZxqYy424\n", + "ytWxlthXs44lC574XWaUan1C5/YowhrM9xKGhk7xWcKumpTqd8Bzltivso4lC574XV2Ii2GcRmgE\n", + "diTMdh1PGG5XH79wrtNQqr8D51tiuby564nf1R2lGkiYJTwSeJfQANxgib2WaWCuU4glNd4gTNzK\n", + "5dKknvhd3YqzXQ8hXAWcRBhzfT3wl/bUwHcOQKmGAD+zxA7IOpaseOJ3HUI8SzuR0Ah8CbiV0Ag8\n", + "7F1Bri2U6hKgtyX2naxjyYonftfhxBr4ZxIagQ0IDcD1ltgLWcblOgaluh34oyU2KetYsuKJ33VY\n", + "cRLOlwj3Ar4GPE1oBG61xP6ZZWyuPsXfmaXAvpbYkqzjyYonftcpKNUGwDGEq4AG4C5CI3BfnmcJ\n", + "u3XFMtkPAdvkuYvQE7/rdJSqF+EKYBTQB5hI6Aqan2lgLnNxkftTLLFTso4lS574XaemVIMIXUFn\n", + "Aa8ShobeaIktyzQwlwmlGgcsscR+kXUsWfLE73JBqboARxCuAo4B7ic0ApO9Hnvnt2a5y39/+ECm\n", + "7TifZz/6UZ4L4dU88UvaHLgZ2BZ4ATjdzN5usk0/Qv/sloABV5rZuGb25YnftZlSbcLaWcK7ADcR\n", + "ft+ezHO/b2cVkv4Bl7P+uIFcvAWMfQs+uTDXy1tmkfjHAm+Z2VhJPwA2M7NLmmzTB+hjZrMlbQw8\n", + "CZxoZgvKDd65Qkq1A2H9gJHAh4SrgIl5LNXbWUlHTYUpQ+n/EAz9DlzVuLxufpe3bE/uLHchluMJ\n", + "f1zEf09suoGZLTWz2fHxSmABYWEP5yrKEltsiaXAQOCbwE7A00r1V6UarlTds43Qla9HNwDe6Qf3\n", + "/7jgdV/esi3KPeNfYWabxccCljc+b2H77YAHgEGxESh8z8/4XcXFZH8CoStof+A2wknK37wrqONZ\n", + "c8b/GX7G35bvaXXNXUnTCMPomhpd+MTMTFKLf0ixm+dW4KKmSb9gmzEFT2eY2YzW4nOuGEvsfUJ1\n", + "0BuVqi9hlvDvgO5xLeHrLbHFxfbh6slL4+DcAXDVwLWv5Wt5S0kNhPkt7d9HmWf8C4EGM1sqaStg\n", + "upnt0sx2XQmTcKaY2WUt7MvP+F1NxBmfexOuAr4GPEO4CrjFEnsny9hc65pZ7jLXy1tmdXN3mZn9\n", + "XNIlQM9mbu6K8Ee1zKzlQkqe+F0W4izhowiNwOHAZMLv6zSfJew6gqyGc04C+lMwnFNSX+AqMztG\n", + "0sHAg8BThOGcAD80s6nlBu9cJSnV51k7S3gb1s4SnpdpYM4V4RO4nKsQpdqVMCx0BPA6a2cJv5lp\n", + "YM414YnfuQqLs4QPIzQCxxFGpY0H7s7rik+uvnjid66KlKoHcCqhK2gQYdb69cDjPjTUZcUTv3M1\n", + "EksCn0VoBFaxdpbwy1BQT4Ye3eDdD+GlcXkeeeKqxxO/czUWh4YeSOgKOg14knmbzOaOk07i4+sG\n", + "rN3y3FzXk3HV44nfuQwp1UbA8Szp+Wt60YuFJ8KcUfDioWDrkefZpa56sqjV45yLLLEPLLGbuebI\n", + "+fx2AbyxOwz5EahxOoDXk3H1wRO/cxX37oes7AOPfBfG3w+ru8bXV36QaVjORZ74nau4l8aFPv1C\n", + "+aon4+qb9/E7VwVeT8bVit/cdc65nPGbu84551rlid8553LGE79zzuWMJ37nnMsZT/zOOZcznvid\n", + "cy5nPPE751zOeOJ3zrmc8cTvnHM544nfOedyxhO/c87ljCd+55zLmXYnfkmbS5om6VlJ90jqWWTb\n", + "LpJmSbqzvZ/nnHOuMso5478EmGZmOwH3xectuQiYD9RHKdAMSGrIOoZq6czHBn58HV1nP772KCfx\n", + "Hw+Mj4/HAyc2t5GkbYCjgauBPJddbsg6gCpqyDqAKmvIOoAqa8g6gCpryDqAelNO4u9tZq/Hx68D\n", + "vVvY7lfA94HVZXyWc865Clm/2JuSpgF9mnlrdOETMzNJn+nGkXQs8IaZzfLLLeecqw/tXoFL0kKg\n", + "wcyWStoKmG5muzTZ5ifACOAToBuwCfAnMxvZzP5y2//vnHPlqNnSi5LGAsvM7OeSLgF6mlmLN3gl\n", + "DQG+Z2bHtesDnXPOVUQ5ffw/A46U9CxwWHyOpL6S7m7he/ys3jnnMlY3i60755yrjcxm7pYyAUxS\n", + "P0nTJT0taZ6kC7OItVSShklaKOk5ST9oYZtx8f05kvaqdYzlaO34JJ0Zj+spSQ9L2iOLONurlJ9f\n", + "3G5fSZ9IOrmW8ZWrxN/PhjjZcp6kGTUOsSwl/H5uIWmqpNnx+M7OIMx2kXSNpNclzS2yTem5xcwy\n", + "+QLGAhfHxz8AftbMNn2APePjjYFngF2zirmV4+kCLAK2A7oCs5vGSpjPMDk+3h+YmXXcFT6+A4BN\n", + "4+Nhne34Cra7H7gLOCXruCv88+sJPA1sE59vkXXcFT6+McBPG48NWAasn3XsJR7fIcBewNwW3m9T\n", + "bsmyVk+rE8DMbKmZzY6PVwILgL41i7Bt9gMWmdkLZrYKuAk4ock2a47ZzB4Fekpqaf5DvWn1+Mzs\n", + "ETN7Jz59FNimxjGWo5SfH8AFwK3Am7UMrgJKOb7hhFF3LwOY2Vs1jrEcpRzfa4SRhcR/l5nZJzWM\n", + "sd3M7G/AiiKbtCm3ZJn4S50ABoCk7Qgt3qPVDavdtgZeKnj+cnyttW06SnIs5fgKfQOYXNWIKqvV\n", + "45O0NSGZ/D6+1JFukJXy89sR2Dx2rz4haUTNoitfKcd3FTBI0qvAHEIpmc6iTbml6ASucpU7Aaxg\n", + "PxsTzrIuimf+9ajUJNB0vG1HSR4lxynpy8A5wEHVC6fiSjm+y4BL4u+r6FglSEo5vq7A3sDhQHfg\n", + "EUkzzey5qkZWGaUc338Cs82sQdIAYJqkL5rZu1WOrVZKzi1VTfxmdmRL78UbFX1s7QSwN1rYrivw\n", + "J2Cimd1epVAr4RWgX8HzfoRWt9g228TXOoJSjo94Q/cqYJiZFbs0rTelHN8+wE0h57MFcJSkVWZ2\n", + "R21CLEspx/cS8JaZfQB8IOlB4ItAR0j8pRzfgcCPAczseUn/AHYGnqhJhNXVptySZVfPHcCo+HgU\n", + "8JmkHs+q/gDMN7PLahhbezwB7ChpO0kbAF8lHGOhO4CRAJIGA28XdHfVu1aPT1J/4DbgLDNblEGM\n", + "5Wj1+MxsBzPb3sy2J1yB/lsHSfpQ2u/nX4CDYxn17oSbhPNrHGd7lXJ8C4EjAEBzXtwAAAGTSURB\n", + "VGL/987A4ppGWT1tyy0Z3qXeHLgXeBa4hzDzF8LN27vj44MJxd1mA7Pi17Cs77AXOaajCCOPFgE/\n", + "jK+dB5xXsM1v4vtzgL2zjrmSx0eowLqs4Gf1WNYxV/rnV7DttcDJWcdc6eMDvkcY2TMXuDDrmCt5\n", + "fISrtDvj395cYHjWMbfh2G4EXgU+JlyZnVNObvEJXM45lzO+9KJzzuWMJ37nnMsZT/zOOZcznvid\n", + "cy5nPPE751zOeOJ3zrmc8cTvnHM544nfOedyxhO/cy2QlEq6qOD5j+t9MSDnSuEzd51rgaRtgdvM\n", + "bB9J6xHKi+xrHav4nHOfUdXqnM51ZGb2oqRlkvYklBf/uyd91xl44neuuKuBrxMWCrom41icqwjv\n", + "6nGuiLgexDzCmq47mv/BuE7Az/idK8LMVkm6H1jhSd91Fp74nSsi3tQdDJyadSzOVYoP53SuBZJ2\n", + "Iyw7eK+ZPZ91PM5VivfxO+dczvgZv3PO5YwnfuecyxlP/M45lzOe+J1zLmc88TvnXM544nfOuZz5\n", + "f95IrH54gZWFAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['WNN']\n", + "modelWNN = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelWNN)\n", + "inv_WNN = generateInvTest(environment, modelWNN)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "####Optimization Inverse Model (BFGS and CMAES)\n", + "Another possibility to perform inverse inference is to use an optimization algorithm to minimize the error $e(m) = ||f(m) - s_g||^2$ where $s_g$ is the goal, $f$ is the forward model, and $m$ is the motor command to be infered.\n", + "\n", + "This is how our [scipy.optimize based](https://github.com/flowersteam/explauto/blob/master/explauto/sensorimotor_model/inverse/sciopt.py#L8) inverse models do. They take a 'maxfun' ([BFGS](https://en.wikipedia.org/wiki/Broyden%E2%80%93Fletcher%E2%80%93Goldfarb%E2%80%93Shanno_algorithm)) or 'maxiter' ([COBYLA](https://en.wikipedia.org/wiki/COBYLA)) parameter that limits the number of error function (and so forward model) evaluation. These two algorithms are efficient to find local minima bacause they work with second order derivates.\n", + "\n", + "The Covariance Matrix Adaptation -Evolutuionary Strategy (**CMAES**) optimizes that error function by making fewer assumptions on the regularity of the forward model to perform the search. It is based on a random exploration (with a computed covariance) around a current point of interest, and adapts this point and recompute the covariance matrix at each iteration, with memory of the taken path.\n", + "The initial point is set as the motor part $m$ of the nearest neighbor $s$ of the goal $s_g$, and the initial covariance matrix is identity times an exploration $\\sigma$ (parameter). This inverse model also takes a 'maxfevals' parameter that limits the number of forward model evaluations.\n", + "\n", + "The method should be applied, if BFGS fails due to a rugged search landscape (e.g. discontinuities, sharp bends or ridges, noise, local optima, outliers). If second order derivative based methods are successful, they are usually faster than the CMA-ES: on purely convex-quadratic functions, BFGS is typically faster by a factor of about ten (in terms of number of objective function evaluations needed to reach a target function value, assuming that gradients are not available). \n", + "\n", + "See [Hansen's website](https://www.lri.fr/~hansen/cmaesintro.html) and this [tutorial](https://www.lri.fr/~hansen/cmatutorial.pdf) on CMA-ES." + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEZCAYAAACTsIJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXm4HFWZ/z9vrmxhx6hAZJMEgcgmA6KAXoUfhqgw4wzD\n", + "AIKKQtSBhHEBdFTiLuqjEhnZBJQwgIA4ggPBBW5kZBEciKxjErZsoAmgQXby/v44p5O6na7u6qW6\n", + "qru/n+e5z+1auupUddV5z7sec3eEEEKICmOKboAQQohyIcEghBBiFBIMQgghRiHBIIQQYhQSDEII\n", + "IUYhwSCEEGIUEgx9jJmtMLNtu3i+GWY2q1vn62XM7Mtm9mczW5LjOdYzs2vM7Ckz+3Ge5zWzT5vZ\n", + "eZ08Zqcxsw+Y2U0FnXtbM1tpZmPi8rVmdnQXztvSO9kTgsHMHjazAwo69w5mdkV8mZ4ys7lm9m+V\n", + "H7jMuPuG7v5wN0/Z6hcHSaiY2dbAx4Ed3X3LHE/1T8Crgc3c/fBOndfMhs1sYXKdu3/N3Y9rr7mD\n", + "g7tPcfeGz3vs+97Rzqla+VLpO7eI00an0ypmtj1wG/AI8AZ33wQ4DNgT2LDb7cmKmb2iqFMXdN5e\n", + "Y2tgubsvz/k82wB/dPeVXT5v32NmQ106lVPEe+Xupf8DHgLeET9/APgf4JvAE8CDwOS47XDg9qrv\n", + "/hvwsxbPezFwTYN9DgHuBZ4EbiSMxirbHgY+CfwBWAGcD7wGuA74C/BLYJO477bASuA4YDGwBPhE\n", + "4lh7A7fE8ywBvgesldi+EvgYMA9YkFj3uvh5SmznX4FFVcc+Ln5vOfAzYIuq404F/hjPfWade3Ea\n", + "cAVwWTzP74FdE9u3BH4C/Cn+bifG9ZOB54EX4n26ExgG7k5895fA7xLLNwGH1Dtu3GbAqcB8YBnw\n", + "Y2DTqnt+DEH4/xn4TMq1rR3bdUJcHgJ+C3w2Zf+NgYtimx4G/j225UDgGeDleK0X1PjuOODn8X4v\n", + "B34DWMp5doz3ZjnwAHBYXP+Fqnt6fK3zAvsAN8dz3QW8LXHszYALCc/jE8BVwFjg2cRx/gpsAcwA\n", + "ZsXvXQf8a1U75wJ/X6/NKdf3QeC+eJ4FwPGJbcOEZ/njwOOE9+IDie2vBK4mvGu3AV8Cbko5T+VZ\n", + "SHv/ZgBXArPi8Y6Nv/H5cd9F8fhj4v5jgG/FZ2oB8K/x+JXtI8CHqt7BynXeC+wRz/Vy/N1WAJ/M\n", + "8JttB8yJx/kFoZ+Y1XTf10qH2e0/1hQMLwAfIrxoHwEWx21j4w2ZkPju7cA/t3jepcD762zfAXga\n", + "OIDQUXyK0MG+ItHum4FXETqvx4H/BXYD1gF+DXy+6sH8T2A94A2ETuWAuP2NBOEwhjASvA+YnmjL\n", + "SuB6YBNgncS61yWuZV9f3WntET+/Iz68uxM6v5nAnKrjXg1sBGwV2/TOlPsxI/4274334xOEjnoo\n", + "tvv3wGeBV8QHeAFwUPzuacBFiWOtR+iANgPWivduIbB+3PYMsGmG406Pv8GW8ThnA5dU3fNz4u+x\n", + "K/AcCeFedX2TCB3kjoSO/mbSO+yLgJ/G9m4D/B9wbNz2NmBhnefqa8BZ8b4NVX63GvutH+/J++N9\n", + "2D3+ljul3NNR5wXGE4RlZWB1YFx+ZVz+b+DS+Ly8Atg/rf3JcwFHA/+T2LYzoRNbq1Gba1zjFGC7\n", + "+PmtwN9Y/ewOAy8Snrsh4OC4feO4/bL4t1787RYBv0k5T+VZSHv/ZhCe7cpgZN34+54V938VQfgc\n", + "H7d/BLg/3uNNCYPGl1ktGG5MPA+HxbbtGZe3B7au7vsy/ma3EATSWsD+hP7wolrXXLfva6XD7PYf\n", + "awqGeYltY+MP+uq4PAv4XPw8Md6YdVs87wvEDiZl++eAyxLLFn/gtybafURi+5XAfySWTwB+WvVg\n", + "7pDYfjrwg5RznwRclVheCQxX7ZMUDI8QRo0bVe1zPvD1xPL68bq3ThzjLYntPwZOSWnTDODmqvux\n", + "BNgPeBPwSNX+n2b1yHUGVSMbwkj5HwgjpOsJL/k7gbcDc+M+jY57f9WLtUW8vjGJe75lYvttwOF1\n", + "fvOPEzr55cD2KfsMEUbrSe3xeODG+HmY+oLhC8B/pR0/sd/hVHV0BCFXGWyMuqfV5wVOoarTAGYT\n", + "NKgtCB3ZxjXOu0b7Ga0xbEgYMG0Vl79CfI4btTnDO/lTYFqiHc8QO9u47nHCAGoo/s7J9+krNNYY\n", + "ar5/8fpGEtteQxhErJtYdwRwQ/x8A6O1m//HaI0hKRiuJ6HlVrWrWjDU+822JgjK9RLb/pMWNIZe\n", + "8TFU81jlg7s/Ez9uEP9fQviBAI4kdLzPVR/AzPaPUTsrzOzulPMsJ4w009gCeDTRFieMhsYn9nk8\n", + "8fnZquXnEu2ukHTqPVo5f3SC/9zMlprZXwgP+SvrfLeafySMvh42sxEz2ydxDY8kruFvhOtOXsNj\n", + "ic/P1GhzkkWJY3lc3pLw0G5pZk9W/ggd+KvrHGsO4eXfP36eQxitvpWgikMYjdc77jbATxPb7gNe\n", + "IrzYade3fp02XRSv5Vp3X5CyzzjCiO2RxLpHGX1P6/FNgunrF2a2wMxOSdlvG+BNVdd+JKOvrR7b\n", + "AIdVfX9fYHOCdviEu/8l47FW4e4rCNpG5T38F0IH1XSbzexgM7vVzJbHfacw+rlf7qt9KLD6+XwV\n", + "Qcupfp8aUfP9iyxKfN6G8BsvTVzH2fG8EN6rrOd+LUHLzUK932xL4El3fzax/yO1DtKIopyUefIr\n", + "4FVmthvhgTyp1k7ufhONHci/InSoP0zZvgTYpbJgZkZ4oRbXOWYjR9LWhBFp5XPlWGcRTCaHu/vf\n", + "zOyk2LYknnZQd78D+PvoNDsRuDwefwlhtFS5hvUJL169a6jHVoljjSE89IsJo8+H3H2HlO+trLFu\n", + "DvBtwsP9NeAp4AcEgXpm3Gdhg+M+CnzQ3W+p3tBiKO/3Cfb/yWa2r7v/tsY+ywgjt20JGguEe72o\n", + "xr5r4O5PE3xTnzSzScANZna7u99QteujBLPfQWmHanCqRwmjyeOrN5jZFsBmZrZxDeFQ67jV6y4F\n", + "Tovhoeu6+40Z25xswzoE39H7CH7Cl83sp2Rzxv6ZMACofp8akfb+wehrXEjQCl9ZJZgqLK06X71z\n", + "LwQmpGyrvq/1frNtgE3NbGxiwLwN4d1ril7VGFJx9xcJDtBvEWx7v2zjcKcBbzGzb5jZawDMbIKZ\n", + "zTKzjQid67vM7B1mthbBpv4cwfbcKp+N8eeTCGazH8f1GxAcUM+Y2Y7AR7Me0MzWMrOj4ktecRpW\n", + "HpZLgQ+a2W7xRfwqcKu7p41wGr2Ue5rZP8TIqJMI9+NWgq9nhZmdHK9vyMzeYGZ/F7/3OLBtFK4V\n", + "bgZeD+xFcDzfRxxxEsxMEEw/9Y57NvDVGKqJmb3KzA5pcA01rzHGne9BsI9PA34UBeko4j2+HPiK\n", + "mW0QX9h/IwQzNMTM3hWfMyOYQl+m9sv9c2AHM3tf/I3XMrO94vOReh0JLgbeY2YHxfu2bgxFHe/u\n", + "SwlO5O+b2Sbx2G+N33sceGV8B1Y1u+rY1xJ+qy8QTIBZ25xk7fi3DFhpZgcDDQUKrPoNrgJmxOdi\n", + "Z8Lv1khYpr1/1cdfSnDuftvMNjSzMWa2feIeXQ5MM7PxZrYpIQAijR8QBgFvtMCEyvNKuNfbJ/at\n", + "95s9AtwBfCHe1/2Adze43pr0omBw1vxxq5cvITiEr0iR5tlO5P4g8GbCyO9eM3uK4Ce4HXja3f9I\n", + "GM18jzBCeRfwHnd/qUH7k5+r2z6HYEb4FfBNd/9VXP9Jgsr9V+BcwstWfax653of8JAFM9TxwFHx\n", + "Gn9N8JX8hKA9bEfQtNKOW6vNyW3/RbAjPxHP8V53fzm+qO8mOBsfJNyvcwlObQjCHGC5md0R2/YM\n", + "QUu6N3FPbwYedvdlcZ+VDY57BsF5/gsz+yvBObd3neuruS6+qN8BjnH3Z9z9UsJL+O2Ue3EiwRH6\n", + "ICGC6j8JET71zlthImFAsyJe73+4+5w1Ghk0i4MIv9diwij1a4TOtHKO1HfF3RcBhwKfIThaHyUM\n", + "bir9wtEEzecBQgc1LX7vAcKA4kEzeyJqF1517BcIHfMBhPcxa5uT17cinvNywvN0BCFqrub11OAE\n", + "woDqMeCC+NeItPev1r08Jrb7vti+KwgmHYDzCL6DuYTn5CdpbXX3Kwmm4UsI7/dVhEEthHvz2Wg2\n", + "+niG3+xIwsDpCeDzwI8yXPMaWHRQ5IKZXUDoLP/k7ruk7DOTEE3wDCHU7M7cGlRiolnjQUJEU8vC\n", + "TAjRPHr/RpO3xnAhIUa9JmY2hRBaOpEwij0r5/YIIYRoQK6CITp4n6yzyyFEVcfdbwM2qdjyB5T8\n", + "1DchRCP0/kWK9jGMZ3RI1yJCFMvA4e4Pu/uQ1Fghuo/ev9EULRhgzWgGSW0hhCiQovMYFpOIe2d1\n", + "zPsozEzCQgghWsDdmy7CV7RguJoQUnaZhUzcp9z98Vo7tnJx/YiZzXD3GUW3owzoXqxG92I1/XAv\n", + "YmDOGYxOfJtPqI92rZmNEKoAQNzpAkKJAIB5cMNEOMxCFYOmydWUZGaXEpOUzGyhmR1rZlPNbCqA\n", + "u19LiIWeT6iX8rE82yOEED3CNNbMhp5AyI+BkDiKEapEziUIhaWEiJ4dYGsLNcZaIleNwd2PyLDP\n", + "CXm2QQghepB1U9avF//P3Bl2PBu2qWgJswhCIoaBJoVI0xRtShLNM1J0A0rESNENKBEjRTegRIwU\n", + "3YAOsEbhz8izmI1x2OFl2HwIeAz8eLBr1tx3vTVXZUOCocdw95Gi21AWdC9Wo3uxmj65FzMJNZKS\n", + "5qQFx4TSGnOA/eIUchfvAVs+FuZVqebZGusyIcEghBA5E53J0wgmog0I7oEVBM1gZvS3riI6mCGY\n", + "g9YbA89eB48eFATGeoT6T1Nxv/qxcOytqRIihBpuqZUn6rY3z1pJncLMXFFJQoheJCXCKMmqaKOU\n", + "A0wkBB3tF9dcDEzH/Ymqc5zI6pkPvxeFS0t9pwSDEELkiJnNJsw8WI/Z7n5w1RfHELSMr1KlJTRx\n", + "7pb6zjJkPgshRD+TFmGUZD0II38zm72b2W1zwzwU34nbLgYmNSMU2kGCQQgh8iUtwijJs2Y2ZQyc\n", + "MR3eeQvsvRts+id4+Vz4Iu5HJ01HeSPBIIQQ+TKT4EdIYwHwvd3h1BGY8F1gLCEvYUcYmjp6Yqmu\n", + "oKgkIYTIkeoII2B9QlTS08Cza8OZz8MOz8G+6xKyl6cCibyElvMRWkXOZyGEiFSFldYMJe3wCUdF\n", + "HFVlL1dY0zGd+fCt9Z3SGIQQgtSw0u3NjI4LhxoRR+fCuVPDnM218hG6ijQGIYSgblhpyyP2lBOl\n", + "5iWk5SO0fippDEII0Q6NCte1R4a8hCgE8jNdZUSCQQghAumF69olQ/ZymVC4qhBCBGqFlbZn4zcb\n", + "g9lJhCkT9iNoCYd2Oy+hWaQxCCEENcNK27Px95iWkETOZyGE6CQdqHHUuabI+SyEEMXSw1pCEvkY\n", + "hBCiXXrUl5CGBIMQoiaVSp9mNhL/Tym6TaUkaAlzKKgSah7IlCREj9GNsg1dzQLuVUrkS+g0EgxC\n", + "9BBd7LCnseaMYxMIETsSDH3iS0hDpiQheot6HXYnyTcLuFfpki+haDOeNAYheotuddj5ZQH3Kl3S\n", + "ErJqhXmaFCUYhOgtutVhzwS2pwSVPgun+76Ehma8vE2KEgxC9BZd6bA7ngXcqxTjS8iiFebqA5Jg\n", + "EKKH6GaHXZZKn4WQoiUYvARcglmeE/lk0QpzNSlKMAjRYwx0h92AjtjdU7QEg31Y03yzq5ktIUzT\n", + "2SlBkUUrzNWkKMEghGiZrk+F2bgtrdvdG/kSzGqZb7aIf82fL4WMWmGuJkUV0RNCtERKRzwfmF6E\n", + "cGhrBrYMvgQzGwHelqEpnZ3xLYUss72piJ4QotuULQmuebt7cxFHaeab7OfrIHmaFJXgJoRolbIl\n", + "wTVnd2++xlGtiXyyn2+N05e3FpU0BiFEq5QtCS6b3b3FvIQatv8NCP6FLeuerwZlr0UlH4MQoiVS\n", + "OrcFwLSCHdDpdvcO5yVksfOnfK91f0hz7Wup75RgEKKPyTtqqNWOseuUrBJqHUf2HHcf7uB55HwW\n", + "QqymG+aKnsipKGcl1LKZ4UaRq/PZzCab2QNmNs/MTqmxfVx0utxlZveY2QfybI8QA0a3KrGWk3LP\n", + "qlbLkV2aWlS5aQxmNgScCRwILAZuN7Or3f3+xG4nAHe6+6fNbBzwf2Z2sbu/lFe7hBggcosaKlNi\n", + "W03KqSWsouy1qPI0Je0NzHf3hwHM7DLgUCApGJYCu8bPGwHLJRSE6Bi5mCtKHVFTMl9CPcpshsvT\n", + "lDQeWJhYXhTXJTkPmBRrjcwFpufYHiEGjbzMFW2bqFqN4a/7vT6ce7ko8tQYsoQ7fQa4y92HzWx7\n", + "4Jdmtpu7r6je0cxmJBZH3H2kM80UIj+KNLnkaK5oy0TVqsaR9r11zOx5mEgPaAl5Y2bDwHC7x8lT\n", + "MCwGtkosb0XQGpK8BfgKgLsvMLOHgNcDd1QfzN1n5NNMIfKhDCaXnMwV7ZqoWi2lscb3JsCEK2EW\n", + "sGlcVSpfQreJA+aRyrKZndbKcfI0Jd0BTDSzbc1sbeBwoFqCP0BwTmNmryEIhQdzbJMQ3aRfo4La\n", + "NVG1qnGs+p4R7M5zgd2CUChTxFHPk5vG4O4vmdkJwPXAEHC+u99vZlPj9nMIqt+FZjaXIKROdv2o\n", + "on8oWy2hjtABE1WrGsdzECTrBcD+ceW1sGQK7JJFIJQ+mqok5Jrg5u7XAddVrTsn8XkZ8J482yBE\n", + "gZQ6iakd2jRRtTSXwNrwvU/Anp+FcWMJIY0nwdLL4bgsA8oymPZ6BWU+C5EfXZmfuddoSeMwm/g8\n", + "nAqMA7gGHj8e7nkMvt1Ep162MuGlRYJBiJzodhJTL5lJMmscKXkJ73G/emnzp+1L014eSDAIkSPd\n", + "SmLqSzNJ57OX+9a012k0UY8Q/UH/REDlV+Oo1PWJyoQ0BiH6g/4wk+RY46js9YnKhASDEP1Bb5tJ\n", + "ulTjqMz1icqETElC9Ae9ayZRjaOm6MZc0dIYhOgDetJM0kOVUPOglSiybgUZaGpPIfqMnghbbeBL\n", + "6IlraIOUDn4+ML1BIcGm5orW1J5CiPKHrWbQEkp/DZ2h1WS7rgQZyMcgRH9R2rDV95t9eC4sI/oS\n", + "5sEN1PYldPUaumGzr0GrHXxXggykMQjRX5QvbNVszC/grLPhuPXAlgJTgWtga2AfX3OE3LVrKFA7\n", + "abWD70qZFQkGIfqLcoWtRl/CQdGXMItQLvvJsDXNdNLNayiqflJLHXy3ggwkGIToL8pRuK/Kl7AM\n", + "XjgW1r5mzT3HR4fqKicz3b2GQjSsdjr4buRiKCpJiD4jmkeKC1utEXG0BWz5GLyjxt7PAGMTy/NZ\n", + "Pfd77tfQbJRPr9Fq3ynBIIToDHUijlJs+dVCoULXOuWUdi0ApvVDBJTCVYUQxdEgLyHFdDIe2KXG\n", + "0brmKO/JxMAuII1BCNE6bWQvd9KM0+8Jca0ijUEI0V3ar4TaESfzgCTEdRVpDEKI5uhgjaNOOMr7\n", + "3YHcDtIYhBD50+H5EjoUelm+pL4eRyUxhBCNyW9WtU5QrqS+PkCCQQhRn/LPl9C7c1GUFJmShBhg\n", + "6kbz9Mh8CQo57TxyPotCUZhhcdSdEwDmkdPcy6J7yPkseg6FGRbOGgXkDCZ8Cb4FbEuJtQSRL/Ix\n", + "iCIp7dwBA8KoaJ4JBEfCv8NOlNOXILqEBIMoEoUZFstzAEaoWjcX2B9YDs9TnogjUQASDKJIFGZY\n", + "LDN3hkfmAN8lVLO7ElZMhmOkJQw28jGIIinH3AGDiNkYhx1ehs2HgGXwwqfgnh/C5+TfEYpKEoVS\n", + "+NwBg0iHs5dFedF8DEKI+nQ4L0GhxuVH4apCiHQ6rCXkHWosoVMsEgxioEnrgPqmY8ove7leqHFb\n", + "90n5LcUjwSAGljod0F7A+2qs762OKV9fQp6hxrkJHZGNXMNVzWyymT1gZvPM7JSUfYbN7E4zu8fM\n", + "RvJsjxBVpHVAJ6SsL03inZlNMbPZZjYS/09JbOxGJdQ8Q42V31IwuWkMZjYEnAkcCCwGbjezq939\n", + "/sQ+mwD/AbzT3ReZ2bi82iNEDdI6oLVS1jfVMeVljqpraulejaM8Q42V31IwmQSDmY0FtnL3/2vi\n", + "2HsD89394XiMy4BDgfsT+xwJ/MTdFwG4+7Imji9Eu6R1QC+mrM/cMeVsJy+8xlHOFU2V31IwDU1J\n", + "ZnYIcCdwfVzew8yyPGzjgYWJ5UVxXZKJwGZmdqOZ3WFmR2drthAdIa2O/5kp65vpmNqqA1XXVFSS\n", + "Gkfufq27H+zuw/F/R+z/8TjTgdmES5sNTOsp/06Pk0VjmAG8CbgRwN3vNLPXZfhelgSJtYA3AgcQ\n", + "MvJvMbNb3X1ehu8K0Rb1Rr1mdnut9U0cvmU7eQZtY1WNo0q40VhCjaNXwj/3QzmLDk35KVoki2B4\n", + "0d2fii9QhZUZvrcY2CqxvBVBa0iyEFjm7s8Cz5rZb4DdCHbSUZjZjMTiiLuPZGiDEHVJ64A60DG1\n", + "YydvFJUzc2fY8WzYZv+48UpYcTp8+PY+EAqidcxsGBhu9zhZBMO9ZnYU8AoL4W/TgJszfO8OYKKZ\n", + "bQssAQ4Hjqja52fAmdFRvQ5BM/l2rYO5+4wM5xSiLLRjJ0/XNlTjSNQhDphHKstmdlorx8kiGE4E\n", + "/p1QivdSgq/hSxka+JKZnRD3HwLOd/f7zWxq3H6Ouz9gZrOBPxC0kPPc/b5WLqRZ+iaBSZSSNp2z\n", + "NbWN3YP1aA6w31BYdfE4mH6h+xMXdqLRQkQa1koysze6+/92qT1pbehoraS6UxpKOIiCqX4+DTgV\n", + "ln0JNhwKmrVmVROZyK2IXkw62xy4Avixu9/TUgvbIAfBMBt4Z41Ns9394E6dR4hWqVSd3RU2uwgm\n", + "7gabxk2qhCoy02rf2TBc1d2HgbcDy4BzzOxuM/tc800sFcqsFKXGYbbD9XNhlygU8sheFqImmUpi\n", + "uPtSdz8D+Aghzf7zubYqf5RZKcpLCPKYA3wHzb0sCiBLgtvOZjbDzO4hJP7czJqJar1GWmKTMitF\n", + "cXSnxlHP0CDJT+RIlqikC4DLCPWMFufcnq6Qczq/EM2jWdVGodLbxaIZ3ERX6ccw4bauKb/5Enoa\n", + "BYh0ho7P4GZmV7j7YWZ2d43N7u67Nnsy0RsUUhW0R4VDW9ckLaEeChApkHqmpOnx/7sJodRJyq9m\n", + "iJbodlVQen8CluavSVpCFhQgUiCpzmd3XxI/fszdH07+AR/rSutEEbRVFbQB/TgKbO6aFHGUFQWI\n", + "FEiWcNWDaqxTdED/kmfnncsosODolWzXpIijplDp7WKp52P4KEEz2L7Kz7Ah8Nu8GyYKI08VvuMT\n", + "sJTAb9H4muRLaAmV3i6O1KgkM9uYkHH5deAUVvsZVrj78u40b1VbFJXUJVI62gV0aLRWKfVAh8KE\n", + "yxC9knpN8iWIgsmzVtKbgXvd/a9xeSNgJ3e/raWWtoAEQ3fpdOedJ7GW19tqbJoTy7kUwwBrCf0Y\n", + "ktyrdDxcNcFZhFnWKvwNOBvYo9mTid6gx1T4ckWvDLiW0AnTngRL8WQRDLj7ysTnl+PEOkKUgfJM\n", + "HD/AWkKCtkKSS+AzEmQTDA+Z2TSC5mDAR4EHc22VEFWkjSJLUd5kwLWEKtqNauvHXJeeI4tg+Ahh\n", + "VPbZuPxr4PjcWiREFY1GkYWavqQlVNOuaa8fc116joaCwd0fJ8zXLAaEEtp4yzeKlJaQRrumvXL5\n", + "jAaUhoLBzF4PfB/Y3N0nmdmuwCHu/uXcWye6TkltvOUaRUpLSKUDpr3y+IwGmCzhqr8BPgWc7e57\n", + "WPjV73H3Sd1oYGyDwlW7RBnyAqopTZukJXSFXgqXLjt5hquOdffb4igAd3cze7HZE4meoVyj80Dx\n", + "o8gCtIQSmvS6Qo+FS/clWQTDn81s1QtpZv8ELM2vSaJgSmfjLTTyqCAtoaQmPTEgZDElbQ+cC7wZ\n", + "eAp4CDgqVlntCjIl5UvVyHQDYEtgi8QuHSuJ0VMU6EsojflM9DR5TNQz3d3PALZw9wPMbANgTKU0\n", + "hugPUkamS4DfA08ziDbecvgSymjSEwNCvbLbx8b/3wNw96clFPqSWqGgWwLbxM+DpamVZ76E0pn0\n", + "xOBQz8dwn5nNA8bXmN5TU3v2D2kj03GsLk7X/7btcmgJSYp3uIuBJVUwuPsRZrY5cD1wCIM2chwc\n", + "0kamSfq7JEEJ8xJKUepDDCz1fAy/jr6F6939kW42SnSVWiPTWvSfbbt8WsIoFLYpiqKeKWkLM9sX\n", + "OMTMLiNoDKtCmNz9f/NunMifGiPTSQQzUjX9ZdsuoZYgRFmoN4PbYcCHgH2BO6q3u/vb823aqLYo\n", + "XLVL5D2DW55kSggruZYgRCfJcwa3z7v7F1tuWQeQYOguvViSIEWgzQemr2q7tAQxYOQpGMYARwHb\n", + "ufsXzWxrQkG937XW1OaRYBCNqJsQBu9CWoIYQFrtO+vlMVT4PiHr+ci4/HRcJ0SZqBl2uytsRjny\n", + "EkqBmU0xs9lmNhL/Tym6TaJ8ZKmV9KZYVfVOAHd/wszWyrldQjTLqLBbI6gIX4e/IwyABl5LUP0l\n", + "kZUsGsMLyTmezexVwMo6+wtRBDMJPgUmEFSE7wLrhmd8oLWEBPUmPBJiFVkEw/eAnwKvNrOvAr8F\n", + "vpZrq4RoEne/dm046ctw/92wcn/gOXgSOBT3o+VgBlR/SWQky9SeF5vZ74ED4qpD3f3+LAc3s8mE\n", + "gdsQ8AN3Pz1lv72AW4B/dverMrVciCRmE5+HU4Gd4pqL180YcTRA8x6o/pLIRBYfA1EQZBIGFaL5\n", + "6UzgQGAxcLuZXV0tVOJ+pwOzUdmNviTXjrfNvIQBs7ur/pLIRCbB0CJ7A/Mr8zbE7OlDWVPAnAhc\n", + "CeyVY1tEQeTa8XYmL6Ge3b2vBIPqL4ms5CkYxgMLE8uLgDcldzCz8QRh8Q6CYKifVCGAnjN9dL7j\n", + "7Wz2clfs7mX5zVR/SWShoWAws53d/b6qdcPuPtLgq1k6+e8Cp8Z5pA2ZkhrSaARelg4oQWc73s5n\n", + "L+dudx8l4dGEAAAQs0lEQVQwc5XoA7JoDJeb2SzgG4SX+XTC6H6fBt9bDGyVWN6KoDUk2RO4LKq3\n", + "44CDzexFrzHyM7MZicWRDIKpX0kdgcf7WLYOqDMdb341jrphdx8Yc5UoFjMbBobbPpC71/0D1ic4\n", + "kW8F7gE+Q5jis9H3XkF4wbYF1gbuAnaqs/+FwHtTtnmj8w3KHzBC0Maq/0YIDvxa264rsL1TgHlV\n", + "7ZkPTMl8HJjocJODx79ZDpt1uI3XxXt4XVNta/M3K/p50l9//7Xad2bRGF4ijO7WI5gFHnT3hglu\n", + "7v6SmZ1AmOhnCDjf3e83s6lx+zkZzi3WpN4IPM08U1icurfj8OxSJVTP3+6uMFHRU2QpojcXuBr4\n", + "IsHccw7wvLsfln/zVrXBvY+L6DXjF6hXFjv+1S4k535wRxudN31UCbWXS5mL3qbVvjOLxvBhd789\n", + "fl5KmLjnmGZPJGrTrGOy3gg8ru/tOPU+nC+hLa1JiAJoqDGUgX7WGOqWi25hlN+Lcymsoo+0BCHK\n", + "QJ4ag8iXjoZzdsFe3nn6UEsQopfJUkRP5EuqY3IgaucHLaHhfAkDcS+EKAnSGIonLY7+VgrMScg9\n", + "Ua4JLUEJYkJ0FwmGgklzTJJjUlSjTj/3jrh5X4ISxIToIhIMJaCWX8DMTk7Zva2chIydfj4dceu+\n", + "BM0jIEQXkY+hvOSVFJVlFq+0jvjNLdv3M/oSUlCCmBBdRIKhvKyaqjJBJ3ISsoy+0zrijQmhtWdk\n", + "Fg5mYzA7CZhLMB09RvOzquV1L4QQNZApqaTkmBSVZfRdyyGeJJtZqUN5CUoQE6K7KMFtwMhaniGR\n", + "KPdmgqZQzRx3H045ifIShCgBSnATmcg6+q44xOtkZte27yt7WYieRxqDqEvmAnDSEoQoHdIYRC5k\n", + "0jCkJQjRV0hjEK0jLUGIUiONQXQXaQlC9C3KYxDN0Zm8BCFEiZHGILIjLUGIgUAagwAalLWWliDE\n", + "QCGNQdQvrAfzkJYgxEAhwSCgRmE9gwlfgm8B26KIo6bJfT4LIXJEgkFAVWG9CQQVYX/YKa6SltAE\n", + "mlhI9DryMQiIhfUMmE5wJOwPLIfnkS+hFbKUNheitEgwCICZO8Mjc4DvAmOBK2HFZDhGpqOW0MRC\n", + "oqeRKWnQMRvjsMPLsPkQsAxe+BTc80P4nMweLaOJhURPI41hkEnMqjYE6wAXj4MtLnTfU0KhLTSx\n", + "kOhppDEMIqpxlCuaWEj0OiqiN2goe1mIgaHVvlOmpEFB2ctCiIwMrGCoWwKi30j4EgimjYuBSTId\n", + "CSFqMZA+hoFJQJIvQQjRAgMpGKiTgBSdhr1fykC+BDEgqPxI5xlUwZCWgDSeXtckpCWIAWJgtP8u\n", + "M6g+hrQEpC3o5VIG8iWIwUPlR3JgUAVDWgLS0pT92y5l0Clnd83jKOJIDC4qP5IDA2lKSktAIow+\n", + "dqnxlaZLGVTZPTcENge2TOzStLpbS23eGXb8Ezz9apgUV8mXIAYJlR/JgdwFg5lNJtRmGwJ+4O6n\n", + "V20/CjiZUNxzBfBRd/9Dju2pdlR9o9I5R2GxPaNV06ZLGaTYPaupqLsNBUOizXsDm0K4WdGRsM3Y\n", + "sJt8CWIQmUkH3lkxmlwFg5kNAWcCBwKLgdvN7Gp3vz+x24PAW939L1GInAvsk1N76jqqqjSJ8QSf\n", + "wzPAtCZH97XsnrVoqO7WanNivgQAroHH3xN8CdISxECh8iP5kLfGsDcw390fBjCzy4BDgVWCwd1v\n", + "Sex/G/DaHNtTz1F1bWxP5UE7AxgX/3ahOdNPmt2zmizq7qo2J7QExhIcIlOBa+BOl1AQA0p8JyUI\n", + "OkjezufxwMLE8qK4Lo0Pke8PnNVR1W6kQ5rdM0lWdXfdysmT8yXMIjgVrpHaLIToMHlrDJkr9JnZ\n", + "24FjgX1Tts9ILI64+0gL7cnqqGo30qGW3XMpwZz2N5pQd8fAcydSU0t4Avhd1uMIIfofMxsGhts9\n", + "Tt6CYTGwVWJ5K4LWMAoz2xU4D5js7k/WOpC7z+hAe7I6qtqKdOiY3dNs4h9hp+3j4izC1JtPhjZP\n", + "k0AQQiSJA+aRyrKZndbKcfIWDHcAE81sW2AJcDhwRHIHM9sauAp4n7tX5xZ0lCY67LYjHdqye8bs\n", + "5Zfh69vDOgktAYIzfNagCAWVOxCi++QqGNz9JTM7AbieEK56vrvfb2ZT4/ZzgM8TQjDPip32i+6+\n", + "d45tathhFxrpkKhxNMQoLaHCWHKK2iobKncgRDFoop6yUKPG0fth2UXwhhp7z3H34W42rwjMbDbw\n", + "zhqbZrv7wd1ujxC9hibq6WXMJv4J/kCscfTfsGQvmH5R8NHUYlCyOlXuQIgCkGAokljj6GW4+9Uw\n", + "aSlwCPBu2PIO+ApwC4M9qbzKHQhRAANZK6kUNPYlTCD4EqYzuFmdKncgRAHIx9Bt5EtoiuiAHlTB\n", + "KERbtNp3SjB0k5RZ1QwuQU5WIUSHkfO5zDSeL2Ema84FsRSZTIQQBSAfQ95kn3u5WnUrvyonhOhL\n", + "pDHkRXOzqk1j9CQ+xGVNTyiE6DrSGPIgu5ZQQfH6QojSII2hk7Q+97Li9YUQpUGCoVMELWEOMXuZ\n", + "oCVMyjjV5kwGO5FNCFEiZEpqlxp5CTQ597KmJxRClAnlMbRD874EIYToGspjyIiZTTGz2WY2Ev9P\n", + "aeEgrfoS8mmPEEJ0kIEyJXWkvn8TWkKjSWY034AQoowMlCmprfr+TfoSUjr9+cD0Sqev+QaEEHki\n", + "U1I2WssXaC3iaBqjhQJxOZm0pvwFIUTpGDTB0Fy+QHu+hCydvvIXhBClY9AEQ/Z8gfbyEiBbp6/8\n", + "BSFE6Rgo53OmfIEO5CVEGk4yo/wFIUQZGSjnc4YTdTQvQZPMCCGKRBP1tHbcKcC0MbDuF+E1p8J2\n", + "Q7AOrWsJQghRGlrtOwfKlJSkEk46ASZcAOwf18+DGybCYcpezodGuR1CiOLpS8GQpfMZA9NOhAlf\n", + "BcYSpkubClwDL7iEQi4ooU+I3qDvBEOdzmcv4M3AurvDmFthz73ixlnAdODJsKgcgvyol9shwSBE\n", + "Seg7wUB653OywdhKuFGVlpBEOQT5oYQ+IXqAfsxjqNn5TICxc4DvEoTCLOAN8EyVUFAOQQbaKPyn\n", + "hD4heoB+1BhGdT7G6qSEGlrCAmAxCifNTJt+goa5HUKI4ulHwbCq85lASEqoRBxV+RIAFqtYXdO0\n", + "7CdQQp8QvUFPCoZ6UUfufu06ZvZ5+OYn4PXrwpgV8PSHYcXlsEXiMH0/Us0pNLQtP0E8vwSBECWm\n", + "5wSDmZ0GnEywDFVYbcowm/g8nArsFLddvCFMvxz2YYBGqjmGhspPIESf01OZz7Gzu4LRQgGAMTD7\n", + "Zbie9msc9QV5zfWQInAWANP6WdAK0YsMSubzNGoIhQnA5SFHYXJc1XKNoz7KzM0lNFR+AiH6n14T\n", + "DKM6u6qIo41pU0vos8zc3Ew+8hMI0d/0Wh7Dqs5uAmGyhEpewjy4gebmS6hFllnXegXN9SCEaIlc\n", + "BYOZTTazB8xsnpmdkrLPzLh9rpnt0eCQM8fA/OmEKdX2Bx4DPxUuneh+QAcK3/VNZm4c1U8HZhNk\n", + "6GzkBxBCZCA3wWBmQ8CZBLv/zsARZrZT1T5TgAnuPhE4Hjir3jEd5i2F5ytawrWw5D3wL193P7JD\n", + "zU4zv0xqIcs3F8xsOOu+7n6tux/s7sPxf18JhWbuRb+je7Ea3Yv2yVNj2BuY7+4Pu/uLwGXAoVX7\n", + "HAL8CMDdbwM2MbPX1DxanHv51TCJOPfyFPfxt7tf3sE21zK/vAiMA95GiPI5o2DhMJy2oY1SFb3K\n", + "cNENKBHDRTegRAwX3YBeJ0/n83hgYWJ5EfCmDPu8Fni8xvG+E/+3NataPWpE3EwiCIUkpawG2meO\n", + "cyFEgeSpMWRNkKiOsU373mPAobgfneckOknzC3Bvym5l9Dn0k+NcCFEguSW4mdk+wAx3nxyXPw2s\n", + "dPfTE/ucDYy4+2Vx+QHgbe7+eNWxyp+FJ4QQJaRsCW53ABPNbFtgCXA4cETVPlcDJwCXRUHyVLVQ\n", + "gNYuTAghRGvkJhjc/SUzO4FQpmIION/d7zezqXH7OdGmP8XM5gN/Az6YV3uEEEJkoydqJQkhhOge\n", + "pcp8ziEhrmdpdC/M7Kh4D/5gZr81s12LaGc3yPJcxP32MrOXzOy93Wxft8j4fgyb2Z1mdo+ZjXS5\n", + "iV0jw/sxLoZs3xXvxQcKaGZXMLMLzOxxM7u7zj7N9ZvuXoo/grlpPrAtsBZwF7BT1T5TgGvj5zcB\n", + "txbd7gLvxZuBjePnyYN8LxL73QD8HPjHottd0DOxCSGS7rVxeVzR7S7wXswAvla5D8By4BVFtz2n\n", + "+7E/sAdwd8r2pvvNMmkMnU2I620a3gt3v8Xd/xIXbyPkf/QjWZ4LCGG5VwJ/7mbjukiW+3Ak8BN3\n", + "XwTg7su63MZukeVeLAU2ip83Apa7+0tdbGPXcPebGDUx5Ro03W+WSTDUSnYbn2GffuwQs9yLJB+i\n", + "ZAl3HaThvTCz8YSOoVJSpR8dZ1meiYnAZmZ2o5ndYWZHd6113SXLvTiPUMpmCaG02vQuta2MNN1v\n", + "lqnsdqcT4nqZzNdkZm8HjgX2za85hZLlXnwXONU9zObEms9IP5DlPqwFvBE4gFBO7BYzu9Xd5+Xa\n", + "su6T5V58BrjL3YfNbHvgl2a2m7uvyLltZaWpfrNMgmExsFVieSuCZKu3z2vjun4jy70gOpzPAya7\n", + "ez1VspfJci/2JOTCQLAnH2xmL3p/zd6X5T4sBJa5+7PAs2b2G2A3oN8EQ5Z78RbgKwDuvsDMHgJe\n", + "T8ivGjSa7jfLZEpalRBnZmsTEuKqX+yrgWNgVWZ1zYS4PqDhvTCzrYGrgPe5e3Xhv36i4b1w99e5\n", + "+3buvh3Bz/DRPhMKkO39+Bmwn5kNmdlYgqPxvi63sxtkuRcPAAcCRHv664EHu9rK8tB0v1kajcGV\n", + "ELeKLPcC+DywKXBWHCm/6O57F9XmvMh4L/qejO/HAxbm+v4DsBI4z937TjBkfCa+ClxoZnMJA+CT\n", + "Pccaa0ViZpcSqj+PM7OFwGkEs2LL/aYS3IQQQoyiTKYkIYQQJUCCQQghxCgkGIQQQoxCgkEIIcQo\n", + "JBiEEEKMQoJBCCHEKCQYhCgAM5thZp8ouh1C1EKCQYhiUAKRKC0SDEKwapKfuWa2jpmtHyd32bnG\n", + "fp+LE8TcZGaXVEb9Zra7md0aj3GVmW0S1x9nZr+LE8ZcaWbrdfvahGgWCQYhAHe/nVBT5svA6cCs\n", + "6nISZrYX8F5gV+Bg4O9YPfK/CPiUu+8G3E0oSwBhfoS93X134H5CiXQhSk1paiUJUQK+SCjQ9ixh\n", + "4p9q9gX+y91fAF4ws2sAzGwjwmx6N8X9fgRcET/vYmZfBjYGNgBm59h+ITqCBIMQqxkHrE8ozLYe\n", + "8EzVdmd0Xfu0eR+S638IHOLud5vZ+4HhjrRUiByRKUmI1ZwDfBa4hGBOqua3wHuiH2ID4F0A7v5X\n", + "4Ekz2y/udzQwEj9vADxmZmsB72O16akfJxMSfYI0BiEAMzsGeN7dLzOzMcDNZjbs7iOVfdz9DjO7\n", + "mlDW+nGCL6Ey7/b7gbPjPAgLWF3a+HOEObn/HP9vUDkcikwSJUVlt4VoAjNb393/FgXAHOA4d7+r\n", + "6HYJ0UmkMQjRHOfGMNZ1gR9KKIh+RBqDEEKIUcj5LIQQYhQSDEIIIUYhwSCEEGIUEgxCCCFGIcEg\n", + "hBBiFBIMQgghRvH/AW6zmhuZz7RGAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4FNX6xz8vCSSBhN47JiAloIggYAGkJvZ7FXsXu1h+\n", + "9nuvu2PvBbtYrtfeOyAoBhRBioh06b0XKaFzfn+8Z9nNZjdtN9lNmO/zzJPszJkzZ2bOvO973irG\n", + "GFy4cOHCxeGDSrEegAsXLly4KFu4hN+FCxcuDjO4hN+FCxcuDjO4hN+FCxcuDjO4hN+FCxcuDjO4\n", + "hN+FCxcuDjO4hD8CiMhBETmiFPs/UUTmlVb/pQ0RWSoifWM9jlhARFJE5BsR2SoiH9l9D4rIBhFZ\n", + "HeVr3SMiw6PZZ7QhIpeJyM8xunZL+61Wsr9HiMjFZXBdr4i8U9rXKQkOG8JviVCuiGy32zYRaRjD\n", + "8XhFZJ8dxzYRmS8izweOyRjzszGmbRH7iscJZuxWbNj3dXKUx1OWOBuoD9Q2xpwrIs2B24C2xpjG\n", + "Je1URHqLyIrAfcaYR4wxQyIb7uEDY0y2MabQ7yUKczBug6QOG8KPvoRTjTFpdqtujFkb4/F8YIyp\n", + "DtQCzgIaAtNiyZDiCAaQWA8iArQA/jLGHLS/mwObjDGbYjimCgERSSijS5X3ORgWhxPhDwkReVtE\n", + "brP/N7FLwuvt73QR2RTQ9g4RWS0iK0XkikgvbTeMMQeMMXOAc4ENwP/Z6+WR7kTkLnvtbSIyT0RO\n", + "FpFBwD3AuXYlM922vVxE5ti2i0Tk6oB+ett+bhORdfaeLgs4niIiT1mJZ6uI/CwiyfZYdxH5VUS2\n", + "iMgfItKrkPvsJiKzRWSziLwpIkkB1znV9rFFRCaISEe7/x2UUH5j7+kOEflvMd5TyH7tscYi8pmI\n", + "rBeRxSJyU8Axr4h8bOfENhGZJSJdwr5AkbYiMkZENtn3cY7d7wD/CXgnVwOjgcb295uFPUsRqS0i\n", + "b4nIKvvsPheRqsDIgH62iUijwBWfiIwUkRuCxjlDRM4saMxh7i+SOVRHRL4Wkb9F5DcgvYDr+FQx\n", + "Q+z9rhaR/wt6L5+KyDsi8jdwqYjUEJE3xP89PiB+VU4lEXlSVK22CDgl6Ho5InJlwO8hAfc5W0Q6\n", + "h5iDtxfhnbUSkXG2n9FA3XD3HHMYYw6LDVgC9A2x/3Lga/v/BcBC4EP7+wrgC/v/IGAt0B6oCrwP\n", + "HASOKOF4vMA7IfY7wCT7f29ghf3/SGA50ND+bu67NuAB/hfUTzbQyv5/ErAT6BzQ7z47hgQgyx6v\n", + "YY+/CIwFGqHCQXegCtAE2AgMsu362d91w9zjUuBPe14t4BfgAXusM7AO6IoywEvsO6oc8L5OLsF7\n", + "CtuvvZdpwL+BRKAVsAgYEPBOdtl3LcDDwMQw91YNWAFcavs9GmXa7UK9E6CX713a3+GeZR37+zvg\n", + "A6CGHeuJofoJvhZwMfBLwLH2wBZ7/wWOOcQ9RjKHPrRbCtABWAmMD3Odlui39J5tnwmsx36v9hp7\n", + "gdPt72TgC+Bl274e8BtwtT1+LTAX/7z7CTgAVLLHfwKusP+fY8fWxf5OB5qHmYOFvbOJwJP2WZ8I\n", + "bCPou4yXLeYDKLMbVSK03X4EW4DPA170ZvRDfxm4Gj+xfRu4xf7/JvBwQH+tKR3Cfy2qIvB9XL6x\n", + "ZKAErS+WOBbWV1CbL4ChAf3m+j4Eu28d0A0lCLlAxxB93BU8kYFRwCVhrrnE9zHa31nAQvv/y8D9\n", + "Qe3n4SdwwR9dUd9TuH5PAo4DlgUduwd4M+A5jg441h7IDXNv5xJEyIBXgftCvZPAd1nYs0QZ7gEs\n", + "EQ1qk6ef4GsBacAOoJn9/RDwelHGXIQ5W9Q5lIAS6jYBxx4Cfg7Tb0v0Wwps/1jAuL1ATsCxBsBu\n", + "IDlg3/nAWPv/2KB519/2H4rwfw/cVMD8DZyDBb2z5igjTAk49h6FfJex2g4nVY8BzjDG1LLbPwCM\n", + "MYtQSeVolEt/C6wWkTYosRhnz2+ESks+LA93IVFvHJ8ReWYxx9kEyKcHNsYsBG5BP4J1IvKBiDQq\n", + "YAxZIjLJLum3oNJbnYAmm4xf/wz6Eaeiy9NkVBIORgvgHLvM3WL7PR61TYRD8DPzGTZbAP8X1FfT\n", + "gON5UIz3FK7fRvZY46Bj96BGWB/WBT2TZJ8KIcSzOC6orwtQolQUFPQsmwGbjTF/F7GvQzDGbEdX\n", + "C+fbXeehBKjYY45gDtVDVylF+l4CEG6ugErlPrRApeo1Affxir0uFONbRedGqLkeCgW9s8bAFmPM\n", + "roD2y4rYb5kjMdYDiBOMQ5d8lY0xq0VkHHAZukz8w7ZZg3J1H5oTBsaYn1HJqyCY4B2WwJyG6oND\n", + "9fsB8IGIpKGS2mOotJGnL1E9+mfARcBXxpgDIvIFRTNUbUSlqQxUTROI5agEc3W+s8Ij+JmtCujr\n", + "IWPMw2HOy/d8KNp7CtuviHQHlhhj2hTjmuGwHBhnjBlQwr7CPkvL0GuLSI0QxD9Uv8H7PgA8ou6T\n", + "ycaYn4o45sAxRDKHNgD70fc93+4L+70EILj9qoBjgfe4AtiDqlgCGY8PRf5WbV8ZYY4FP9eC3lkL\n", + "oJaIVDXG5NrdLdCVW9zhcJL4C8I44EZgvP2dY3//bOyaDfgYuExE2oka2TwRXvPQByQiiSLSDv1g\n", + "6wNP52ss0kbUmJuETvrd+CfVWqCliPj6rGK3jcBBEckCCv3YAeyH9CbwtKjhMEFEeohIFeBd4DQR\n", + "GWD3J1sjX5MC7vEGUWNsbeBfwEf22HDgWhHpJopqInKKiKTa4+vIbxAsynsqqN/JwHYRuVPUgJ0g\n", + "IpkicmzAeIuKb4E2InKRiFS2W1cR8bnfFtZX2GdpjFmDGnFfEpGatu+TAp5LHRGpHtBX8LVGoETH\n", + "QfXsRR1zICKZQweAzwGvfc7tUbtCYczw37Z9B5ShfxSqkX0+o9E5miZqzE0PeEYfA0PtvKsF3F3A\n", + "NV8HbheRY+x8yRB1vYX8c7Cgd7YMmAo49rmeAJxayP3GDC7hV4xHl6g+gjIBNRr5fmOMGQU8i+oP\n", + "/wJ+JDI/XYP1+gC2Al+hklIXk9fN1HeNJOAR22YNqpK5xx77xP7dJCJT7XJ/KPoBbEaX/V+FuH44\n", + "3A7MBKagaqdHUP3oSuAM4F7U+LYc9UAKN48MqmYYjS6nFwAPAhhjpgFDgBfsGBegqxcfHkEJwRax\n", + "3jwU7T2F7dcytVNRddFi9Fm+BviIqAnxXEI+J2PMDpQQnodKpmvsmKsUpa8iPMuLUZ3xPJQADbXn\n", + "zUMFhMWi3j6Ngq9ljNmLEt6+qBNCUccceH+RzqEb0Xe1FhUk3iygrQ/jUKP9D8ATxpgfAq4TfK1L\n", + "7Ljn2PF9gl/lOBzV3c9AifFn4cZqjPkUtT+8jxpjP0dXkBA0B4vwzi5A7UibgftQ21NcQvyCUglO\n", + "Vre0U4D1xpiOYdoMQ416ucBlxpjpJb6gCxcuKhxEpCXKiBPDqG5cRBmRSvxvoa5vISEi2UCGMaY1\n", + "6oXxcoTXc+HChQsXESIiwm+NmFsKaHI6drljjPkNqCkiRfV6cOHCxeGDSNSmLoqJ0tbxNyGvW9VK\n", + "1H3KhQsXLgAwxiw1xiS4ap6yQ1kYd4M9DlzO7sKFCxcxRGn78a9Cg1F8aEpe31wARMRlBi5cuHBR\n", + "Ahhjip1IrrQJ/9eoW9eHNnhmqzFmXaiGJRl8eYGIeI0x3liPo7Tg3l/5RkW+v4p8b1ByoTkiwi8i\n", + "H6BJo+qKZpH0oKHUGGNeNcaMEJFsEVmIhttfHsn1XJRPZIpkN4OhaZC8HXavgGGzjBkR63G5cHG4\n", + "IiLCb4w5vwhtbozkGi7KNzJFsnvAc8MDwuKHQHqmCC7xd+EiNnAjd8sGObEeQCkjJ9yBZjD0wWpk\n", + "fNEWNlbVfcMhozncFO6cOEROrAdQysiJ9QBKETmxHkA8wk3SVgYwxuTEegylicD7E0cqofnXewLH\n", + "p9xGr7aVocdKaLsR6tr0VamaaqFc4HB6f6WBWKr6Kvq7Kylcwu8iIogjqWh+kp5oitruaB6TCcDP\n", + "R33MERNWcXylIBPUDi144qKCw1X1xSciytUTtUGImIrs1VNRII4ImuLWR+R7Am2A6cCvvs14zAbf\n", + "OaE+/Ktg0SQY6n74FR9ZIqNGwsAFteHmLPjuPQ3syYZRI4zJivX4yjtKSjtdid9FWIgjldFMloGE\n", + "PhGV5n9F09RONx6zJ1wfs4wZkSlCNtyUCik7YNdyeN4l+ocH0rSoD+lbYGlN+PEI6Le4fKn6KiJc\n", + "wu/iEMSR2kAP/ES+C5o18VfgGzSv+RLjKd4y0RJ5l9AfhtiudSOoZOCen+HhE5Xwu6q+2MJV9Rym\n", + "sGqbNviJfE80svo3lNBPAH4znuKX/3PhwodAVd++StB6KHT4glXLlnG1u+qLHCWlnS7hP0wgjqQA\n", + "x5KX0G/HT+R/BWYZj9kfs0G6qJDIFMlublV903tRb+kxbN/3tOke63FVBLiE30UeiCON8BP544FM\n", + "YBYBhN54zOrYjdDF4QgrgCwGBhiPmRnr8ZR3uIT/MIY4koAS9kBCX5280vwU4zHlQq8qkpkNzYZC\n", + "WjJs3w0rhhkzy1ULVBCII3cCRxmPuTDWYynvcAl/OUC0AlnEkeqov7yPyHcDVuMn8r8C84trhI0H\n", + "KNHv8RwMz/DvHbIQJt7sEv+KATt/FwHdjccsinb/h1NuKNedM85R0kAWa4RtRV6XynRgGkronwMm\n", + "Go/ZVKo3UGZoNhSGZ1B5J+yrinp9D8+A7JtwPYMqBIzHbBNHXgHuBK6JZt+B39lBUW8iN2AsP1yJ\n", + "v4zgC2T5oyEcvda/PziQRRxJAjqTl9AfJK80/4fxmL1lOPwSoSSSl8jgHPi4F4Nugc5vwvpM3bZN\n", + "WEifOUNQA/TGsrkDF6UFcaQu8BeQGU1bk+87W5sKAy6GKa9B0oGKGzDmSvxxjh2tadC3ByyppZOx\n", + "jtW2pyRQXRw5HT+R7wwsQAn9Z8BtwPLyprbJFMk+Fnn9v5hGvn2XIZ0yRa4qmPhv3w3AqGdh3H1Q\n", + "fxbUnwktv0kCHgQyxZFdwEzUWD3TbnOMx+SW3h25iCaMx2wUR95G5/ft0erXFzDm6Q39FynRBzdg\n", + "LBiuxF/KEEd6AE6V7Zzw0lhSLpkBlQMqi3Zrxf4pl/IjfkPsZOMx22Mz2ujhZKk8bSz7j9mT4P/4\n", + "AE4mcdpYs+/YcOeF1vFftQgmDTVm1gir+mqGGrM72i0TOBKt6RzMEBa6LqrxCXGkKfAn0Dpaqsos\n", + "kVFP1mNgn8tg/vNQS8UIV+IPPs8l/KUDcaQbKqF2AiZWn0HTrJ845sOt/lTYlyew4je4fs5+823M\n", + "BloKEEdathmZNLt1+p6q41vAX89Dwx167OTalff8NHTfM2jk5i40snNXnu2Lxp34q90ZHEytjNmZ\n", + "S73FbzJk8Xe+9sZjDoS4ZmWgNfkZQmNgPvkZwqrytoqqiBBHXgdWGk90qmRlimRvvoRP7vyLqrdM\n", + "0n0VOTeUS/jjAFaCuQg1WDVBC8v/jkryE9JfpmqbdVxU0XLWWKJ7PHAKkA3Uq/NnlRovzt9bZcAi\n", + "v9QFcFzNqrmTb8l9CF16+7bkoN8FHUsG9hPMLMIxEdgHVAVqALWAekADIAFYASxBPUzmA3PRzKL5\n", + "+jIeE7BOcxEtiCOt0dXuEdFY6Yoj/WUvb/d/nD9r7Ce5In1noeAS/iihqD7k4kgiKs37dPO9gdqo\n", + "IXYU6m0zyXjM7uBzKwLEkYZAFkrs+6F2ie9Qz5upNbwdJw8kt8tH+L31BpPOaKpO3Wr+7BrBdQVI\n", + "IjyzKCoTqYUygHr2/xpANfT97bV/Qe1gSSgDCcdcCmI8JdnvW9kcFsxGHPkQmGo85skI+0lABa37\n", + "jcd8FpXBxTlcwh+VcYT3Icc7+1c0gZnP26YrsAyYh7pbNgUeAl6riMTeflRdUYk+G3UpHYMS+1HG\n", + "Y9blaS+Z2Wk0HH4kiY2rsZudJDOffWu2s+6qePXHt0VkWuBXE/lURunAcnRFsACNPF0KbEKZQlEY\n", + "T0n27yVKTKSI+2PCbMSRo1CBIT2Sb0ccuRy4sr3Dw82N68df4Hku4Q8cR9YoGDkQDNReCM1+1S39\n", + "nR3U2gUwBb9b5d+oR8LxwOPAK+UlMraosNk6B6BS/SBgLfqBfofGDuwr8HzJzIbmN0FqCuzYBcuf\n", + "j1eiXxDEkSqo8TiYIdRDmUGw/WBtpPaDgJVNNJhIUc9JQplNma1qsMxGHPkW+MZ4zKslfF7VgPn1\n", + "x/LU6eO5PiheZuFEuLkiEn+X8EdlHNaHPGUTXNsZVvSE5cfDus+mcfm47sZj9osj7QEP0At4EnjZ\n", + "eMzOmA48SrDEphMq0Z9i/89Bif0I4zHLYze6+IONQO1AfoYAfkZw6K/xmG2xGGdRYVc8PmYTKRMp\n", + "6n4fs9mL2mKWUTLm0g+on/kVKU9uo3PKfuiw3u827Xr1BJ3nEv7Acfgk/vHAaFS9ux8YPxXvzxcD\n", + "9wF9gaeBF43H7IjdaKMDcSQNvSefCmc3fl39uIqotipNWObZgLyeRR2B9sBG/KsCH0OYV1gwXkVO\n", + "QRDEbL4DPkFViMVhInWAc4Ex9ZbQ4+iD1NmVCA/8BL2X6nUGw7iPjeldZjdWRnAJf1TGkZkNbYZD\n", + "u8aqrgdqL4CTB+yi7bJ9JJrHgOfLs5+9JUyt8XvgdAcm4Sf2C+LBzbGiETtrI2mFnyH4mEJL1GYQ\n", + "zBCWGo85GCbVR4VUXYgjA4GngE7FsTVYl9DNxmPu9EXuBrdxJf6g81zCnxciA6bB6GOotQh6PQCt\n", + "v4PfboYpOWNM7g8DYj2+kkAcSUZVUz5in4xfVz823hjZYUbskoF25I8/qAXMrj+XxvcupWnmeui0\n", + "DurZ2OSKSMisUDIVcIzHfF3EczqhK4QjjcdsPdxqPLspG6KGmtuRgzD4bJh3Jjy/AHbXBP6sEuuR\n", + "FQfiSHP8uvpewAyU2P8DmBkPUn04NIOhwyFjRxVI3g+JB2E4ZGRDhUvUZlVp0+12COJILSCz/mre\n", + "mF8XPm0Pzf+G9z7X4xUxBYHxGCOOPAz8Sxz5pohz9AngQeMxW8Gt8VxUuIQ/H7bvxlSC16aBqRSw\n", + "f0dce+zYIKqe+HX1DYGRwHvApcZjNsdweMWCL9/KUz20RmvTbXDEFpi3i6NsLvdFqHpkcUUtDWk8\n", + "Zgvwc5ZXFr+kqrk8qMA1a79A9ax9gLEFNbSqoVbAK4H73RrPhcMl/PmwYhgMSccE54pZ/nzsxhQa\n", + "4kgD1M3yFKA/ShBHAFehATH5UhuUB/gKdHvGwd2/wLKasLgW3NSULajhtCdwBHCEOLIbZQKHmEHA\n", + "/6vK6zPwYQUMGwLpwaqL5RB38zEasK6djwL3UgDhtzaTJ4E7C3MrdpEfro4/BOLV/9x6QByLX4WT\n", + "AfyAEvuRxmPWFnB6uUFR9bRWJ1wfywTQQKvAv3VQ98BQTGFxeXHDDaxZezioLuzqdSFwjvGYyWHa\n", + "XAVcDPSOZ7VlaSNmxl0RGQQ8i+Y+ed0Y81jQ8brAu6jqIRF40hjz36A2cUX4Y4VQniyzvUxEg6iy\n", + "Uel+A9avHphQUaWdaBA7W9+1FXmZge//VmgQXiAzCGQQaw5nghJriCM3An2Nx5wV4lgqmsv/dOMx\n", + "U8t8cHGEmBB+EUlAk1v1A1ahka3nG2PmBrTxAknGmHssE5gPNDDGnyrXJfx+Kfc1yJhVH75rA0+3\n", + "ZfeGRhgSGIt64Iw0HrM0xkOtELCrp4bkXyX4/k/Dn8Btcb0ckjOn0rXGXg7s2sfWlYZnCy8q49YO\n", + "LinEkaooA+5rPGZ20LH70aRuF8VkcHGEWHn1dAMWGqPESEQ+BM5Aw9h9WINGgIIWAN8USPRdqAST\n", + "eTQPJDQlo8mRsDsRLvwT/pdD8tPLGT16jzk11mOsaLB+4qvt9nPwcStVtgLS643nlAGTOefdXGr4\n", + "jp9Xkz41/inzt3ViCvlXCxvwdsgKkfcpXSQTl/gXDuMxueLIc8DdqEoHAHGkCXADWrDIRQkRKeFv\n", + "gqa29WElcFxQm+HAWBFZjUpRgyO8ZrlBQRKfOJKB36++x+pjOdBmNnz+IfS/BJ4aDVUOwJsa1eii\n", + "jGGjsmcCM7NErn0XaqxOgz8aQvYC+HAriX2/Z+fYTvyCrhJOx79iSGLoEsO6NmlsuR02tYZp1+DW\n", + "Di42XgIWiSOtjMcssfseRBMhuulDIkCkhL8oeqJ7gT+MMb1FJB0YIyJHGRNfQUPRRr5Mnwl7IP20\n", + "TLkueSoN97RHUwCPQF3Rzun2Oh/fZiMO226ESU3hpGUV2m2v3MDnXro2FW4ZBC91hWdGQZ3N7DIe\n", + "80Zwe3GkJl92+4HUC7pQazHUWhJwNLXC+d+XFozH/C2OvArcAVwvjhyNpgJvE9uRlX9ESvhXoWXw\n", + "fGiGSv2B6InNf2CMWSQiS9BMh3mMMtYW4EOOMSYnwrHFGM2GwvAMkrbBWZdAy59gfWYTljTaScOl\n", + "g4EZgcbDTK8cctvrtxh+OAL+t6ziuu2VJ/jcS49ZA7NegueOgx5XQco8mokjacGRz8Zjtoo3ayOc\n", + "HaK3+I4HiUM8B8wTRx5A3TedeE92V5oQkd5o7Y/I+onQuJuIGmv7orrSyeQ37j4N/G2McUSkATAN\n", + "6GSMP6CoIhp3D2X6xED7z2BJH9hVBxg8zpiPe4c6x+fJsrUdjWb2pkWLl7mwIrvtlReEci89rzpL\n", + "v7iUhXvr0B7VQ78XmF+msNrBZTn+8g5xZBhaQrMD0NGtoexHLN05s/C7c75hjHlERK4BMMa8aj15\n", + "3gKaA5WAR4wx70dj8PEMf6bPYGSPMmZEgTlWbP6WDUCTw1m6iadEbeHcS8WR7uiqbB8wNNC9MF7j\n", + "QcobxJFWqF//hcZjPoz1eMoKRZn/bpK2OEOkEp848gPwnPGYb0pxmHGL8pSozbqGXgo8jLrd3ms8\n", + "Zn1sR1VxII5cg9bAeMV4zP2xHk9ZoKjz3yX8cYiSSHyHPIH6L2lD2rZKfF77+sNRSvSl153aGJps\n", + "gwY7oZIpflbKsvSlF0dqoDUbLkGZwAsVNcCurGCL3cwHrgNeQ/33y30djMLgm/+TmkJOS01dAvnn\n", + "v5udMw5hCUyRiUyeVcLsqXDmpUCP5w5H3+80SDbAzYNgYW3YlqTZKTflcpw48gpa83aJ/bsUWB8c\n", + "aRumhnLEvvThmIlNGPd/4shwVP05RBy5xXjM6Ghdo6RjLse4CxhtPOZLceSCaot4OkukeTyo/0oL\n", + "4kiVo7vR/LhOsKEaDP1N3SeF6GVldQl/HMD/kbfsBsNrUXce9Pk31FoM3a/IYOMf/xFHJlTUTJSh\n", + "sB12CzDhTf29s7Imazu/EYs3NWcmWsCkCxpk1RKoKo4sJZAZdGl/AWuuyWDrRsitg346kfnSF4WZ\n", + "GI+ZJ45kAacCL4sjM4HbjMcsjtY1DgeII82Aa4GjABp8z/htPXnmywQSk2zqvSGQnilCRSD+Nuni\n", + "NcC1i4+iyjvj4ZS/ICFAnImWe7dL+GOMvB+5V3dubwxTboTqq6Ddl1B1fgdglTiyFZhjt9m+/20K\n", + "3wqF4KyU1fbB0xtYdGAD95kZ+T9yW0KyZcDWig4bm3Ls1VBzCfx0P0y+ybaOxJfeuunWmQ9nXgY/\n", + "PgxL8zMTu/r4RhwZA9wKTLYrlUcKTw5nr5E1FOafBov7c5gGfz0EvGQ8ZiVA54mcao4g8dUucO5s\n", + "Vf9VhDoN4kgXYCgaBPgxMKDZcJp/A8+dXkpZWV0df4xxyPvnpAdg5izY8pH/4LEvQ9PfYOyy6dyW\n", + "8x808rkRGi/RAo0SzQB2oGkyZhHAFIzHbCrbuwmPknjoRJqoLY9nlRwMqK9QuGdV+D6tm64chPaf\n", + "QN9/aWTu+D1TzfKxXcOe50hT4DHgJOBO4MNwSeBE/vEnfN6RNt9A1lBY3RW+fxq2DZ1pzOedQp8T\n", + "n6ohm0E1GZ27hW3VA/5vimYBmIMGO6Yl7KP+gUQqCdBxHcywWfjLYz1dm4H0LJTgNwdeAN4I/GaL\n", + "Mv9d4245xSFC0u0F2DkbFhvYZWd07QVw+VGGhVUm0fnvv9EPyFdsOjlgq2r/JgI+X/JK9v89wE6U\n", + "OWwFNgHb0KCk3ejScXcBv4vSZhewJxwhi5WHTmn40udz003YC11egz637SVl38fAfwpKpCeOnAAM\n", + "Q9/JUOMx0/O1kawNMLIuAJVz4YRHoetLMLH2TvouqB1cnD2MamghTLy5JPcpjiRSNEIdimCH2g4A\n", + "2+22LeD/gra7gNHAh759Jz/Gf8fspl+vy+CGKXDeLB1veSpDKY7UBYYA16NqyeeAr0oam+AS/nKK\n", + "/P7+49ESonM2Q+5k/vX9MVQ2vYzHzCu0L3UrTMLPGJqjQS9t0SpO6agaxJegbB0aL7AJTVG8n7wM\n", + "JZjBFPQ7CWUy+RhD6npadt1JzeT90H8R3DpJx1sWH2y0fenDMpM64+7ipoUdUbXD/4CHjMdsDNmH\n", + "FhG5AngA+BL4d2BbkQF/QteONuBd0fxMGDh2F022LwVuMB7zk388zd6G4+oiu6DaUZB2JCRth5pD\n", + "p3HmzKcpPtGuggoKgYS4qAQ73xbMqAp9xo6cBjwKHBVIEH0CxFmtybi7H8x4GYaUk3q6tjbwUOCf\n", + "6DsfForpF7tfl/CXTxQmlYojbwC/G495MSrX06V3A6A9yhTaB/xfiSD7gd1WF5abPoDpJAdtKSe+\n", + "w+veg3TenQgNdkCXNXpOeVyiZ4pkV6LG/atp12ovqbKLA4v3s/6+gOR7DYD/AOcBzwDPhtPp27q6\n", + "XuB8lAm8bDxmvwoD9wxUASAB2A/Nk2Hw/btI3fcHytDH807zESwa4Mkzd2pcBD1mQqMawNzNtNg4\n", + "huIT7dxY1SKwKpCZwK3GY0YGH7cqw5t+uYkTW41n3sEZ3BevRN8y+NOAm9H8Qi+jCeaiFuPhEv5y\n", + "jIKkUnHkfGBwqIIUUR+HI/XxM4JAxpBECKMysLIoBMLnkxy8vzwt0SGvysrnXhdOZWWzrz4InAjc\n", + "D7wZzqdfHOmALvkbADfj7ZAcUhio/vPt3PZXJmosnseehG7MPzeRnfVg7TEw4xLb9j8oHym5LSNW\n", + "EEduQFPRoyUcAAAgAElEQVS7Dyxobokjg4FbgOM7eMmKlwhvO7ZawJVo+ui16Lv9vLgrnyJdyyX8\n", + "FRNWgpwH1ItVjhKrl2xPfqZQjbwrAx9jWBGYt6aopRTjHT4GNuw42JoM943T/QUxMHHkWNSo2xTN\n", + "VPt5KIJmV2JnAU8B03ij1besaHsupKaQtGUv3WeMos+GXWge+m5AB7YnJSA19bsZ+yD8fpXtzQus\n", + "LHd5gWwA3HyU6M8opG0CMLfuz7x+5o8MiYcIb3GkHarOOQ+N4B4WrnRk1K7pEv6KC3HkT2CI8Zjf\n", + "Yj2WQIgjtYF25Fcb1US9jA6tEJp+Sv3M2ZyTZuK/bmw4D5nBIjkfQ681qdDlGnj7C+i/uHCVlSXq\n", + "/VEGsBctED4uTNtmqLh+DlrUpQrqxTUHmA78Yf/+yWMnj2HXD91p/ykMvA2W9oYxT8COyzfCikvL\n", + "E9EHsEXW6xmPubKI7a+osZLHt75OnQv/AS99BzX26LHiriZLmhfKqjizUHVOJ+BVNLXEmqJeOxK4\n", + "kbsVGWuSF7KswTsig1fHk6ue8ZjNwAS7HYI4UhM/Q2gPnLzybNqvPJs66OplBXCU1efOBpYYjzlQ\n", + "poMPg4KCpwbZ9MyNdsB7n8EF/4Spr8GO7QUH1VgJf7TNv3Qe8JY4Mhd14asKHI1K8p3t7z+A94GO\n", + "aMH4K4CPtKpXs6GQdo6dB6Pg6rrMGZ7Bwiw46QG4vuVBVid+RsbOYkcLxxLiSAvU26VjMU57d3dN\n", + "XpraGKY3ghU1oIbVnhcnwjWM11mBgWE2lcRlqDF/G6rO+ch4zJ5ijD9mcCX+OIdIZjbtGg6n28HG\n", + "vD3W7i25q14sYT+WtuQ3KtdHi2cH2xAWBau3Sjtj5yEvq/qzYGc92NnAHske1YGRzwcSiIdPhGfa\n", + "srvuOwyeuyt8Mj3L4NqjhP1o4BjgWNR2shr4HMhBJfllgaogcaQXMIwdCfDeaTVZ80Vzf89DFsLE\n", + "d6F5d6RqNequa8Sg3xuRnrsBNdJeZzwmD1OOV4gj7wELjMd4i3Neel+Ze3Rd2m5PgtsmwqCFur84\n", + "En+WyKiPqzDw3U4wpx48PzJ8H+JIa+BGtBzkGJTgT4yZMdyV+Csqmg1l0SeNObOR+nTvq0p5jeK0\n", + "KaYn2+0QbH3btvgZwRX2/8biyAIsI6g5naQ+Dbjwow20qGwtCNEP2U9LBuCIH6DX/fDnhfDr7fB3\n", + "asosY0ZkipBtg2q2/8KurV2ps/FuegHf2HtJQ1MMBErxbdE0Ej5Vzbf2717gdtQIuB8YH0xAjMeM\n", + "E0e6MLnVDC6a0JzZN6o+f3dN7DzoHmjAFUeao66QA9DI4a+Au+I5W6g40hUtLnJNcc9NmM693w3h\n", + "k+ylJKysrvuKE+EqjrRv/g86tmgNJy+BGwJmpm/VEKCqG4raV15HXU1XhOiyXMCV+OMchwK8Lu4P\n", + "Yx+CVd3skfAFXSoKxJGq+BlC+1pLubJOGvVX1IBrp8Kzo7RdNL2D8sRVpK6F7s/AMa/DisRVHLm+\n", + "r/GY+QHjawicxH7eYFPqfpIPJFF1TxX2yUKqHsjBr4+faTwmt4D7bIS64gxGjbvPBbcXGZxDysu9\n", + "OPFhGP9v2F3LHgk9D8SRnijxa4QSsH8Br8aLSs0HS1THAW+HKmNZFFS7Qt42qZzVZCGbW49kbmH2\n", + "I7sCOwNluEc2m0zur7+Q3jSo8kX/ZMb8cDdfoOqcfWjg3fvGY+Kmippr3K2g8BMinwOhD+XPVS9S\n", + "+IyruxJhexLUt97x0YwHCKnjT7loCRd+/idNd/VBVTObUHVPZbYnLmdF03SO2JTGJx/Dkn5w8LoS\n", + "qeLEkTZo1FZP1DXnLZ+qqySFfazh8WLgcbtrHXC18ZhJxRlXaUIcORN1d+1cUqZkbUorgW+Nx5xX\n", + "QLtGwNV2W4gWc/+ig5d+gSq8JTXhlJ5snXcMlUwiP6IEf1ys1DkFwSX8FRRKiNoMh/aNVTO3H5i9\n", + "BhZcVd50/JGipPEAxbELiCNJfNjsatYecTWJSbVI2VaV42cl0XbHBuBPoDK63P8DuA/voP/AyIF0\n", + "ewFa5sDHn/pGVfJ8QI4ch3oANQDuAb5Sw27J0k9YVdo9qKrCAJ+inkUhI4vLCuJIFTS/1I0lSV0d\n", + "1NcnQDfjMS2C9guaH+kGoB+aAuJl4zEzA9t1qCTZSW3xrOzGEVsaUSNxM1/vbsztBaXfiAe4hL+C\n", + "Qgl/t9fhzUb+vVesgcmHHeEvSTxAQXmCZnuZgOriA/XxrYFF5HWd/CMwA6o4koR6dNzF6pq1+fGj\n", + "GizqB1VyYW+qbRWZKs4SrEEoA9gB3IW3Q1ok6SdsCcNngJPRtB13oonBYqL+EUeGAlnGE7maThzp\n", + "gxpbmxiPWWdtLRejOXEqodL9/4JLmYojKcCFKFNMRKX7dwrPoBofcAl/BcWhJX7KJujwCWxoDxva\n", + "Qe6lh52qB4qfsdO3SliTCtMawx8NYXpD+K4pu/ZU5wCaHiCQyM8yHrO7KGMRRxIZ2XYaXSp1Yn8K\n", + "/HwvzDvTZgGNjirOBipdgPr2/4mWdZwVYZ+9UH/zRqhr7eXGY6ZEOtZijqEmGqzVN9L7sf3VAVYB\n", + "76BG8/OBscCLQE6+Ij0aL3E9cBUwCSX4P8SjOqcguIS/guKQcbf6CujtQL05UHcuyM79JO+biD9Q\n", + "yvd3VXmbvKUJn13gpiz4qw50XgtHr4U3NjL5h2vpGam0K5KZjXR/jiNPzeDEh6DKTphUez2zN11l\n", + "ds3N5+IZQaBQMlp+8B7UK8gTiVdJQKK4J9AgsU/Q/DibS9pnMa//BFDDeMzVUeirMnAmqsYR1Kbx\n", + "vPGYVUHtBLWf3Iyqff6HlsdcGOkYYgWX8FdQhDbqGajZ5yduGfcg/kAp39+qaJBUIDOYSxwFSZUl\n", + "yiJPkD/XUrUUOiysStbMJFIPpKEE6L++FUQ00lPbtAZ3opWp3gAejYRY2/7uB66W/ZjWOSzpNIEN\n", + "O0zp5byxKqcpQKbxmLUR9NMYDfryGWvbYN2Fjcc8FNAuCTgXJfjVUen+7WC1T3mES/grKIqbU94m\n", + "iApmBu3QIKkF5F8hLCiN5FHxgljlCbLulPeiwVpPA68M8vLpSBi4LQmqHIBkG5pWEiZkiZ4Xze/z\n", + "BCrhltjNsFUrufLIBJ7f2ocUMfDiCHh5TenkvBFHPgRmG495oATnhjXWiiM5wNtoHMMRKJG/DmUM\n", + "M9Bgq1GBeaTKEqURfOgS/gqMaOSUF0eqoT7xgcygHZqffxn5VwjzyouBqzBEWskrEogjRwN3A30z\n", + "JrHjt3G0/LgD3DoQWm6Fjuvhj20sXdCDW1Ed/tLiECZxpC3wMNAV8KAGzGIn8/OtjHJawMz68GAv\n", + "OGcOzB3HDz/uMP2L218B4+2OehW1KSi2IcR5hRprxZF30eItl6FEPx34AGWKc6N1DyVBaRUjcgm/\n", + "ixLBLoMzyL9CaA2sJ/8KYW5FrPFb2hBH2tSfx9j9zWly5XSNEN2WBDMbwF2tWLzyGOaheWpqoWkr\n", + "ZqKMYCYaAFZgGU1xpAfqAVQHtQN8Uxxbj88WcmM2fJAJF/2pGUg/bMPBvVW5Ga19G5GkbKX1X4Dh\n", + "xmP+W8RzOqDEvjBjrc9O0RktYlANaG08ZkMkY44WfIx1RGv4+kh45VvdH6nK0SX8LqIKa/xrRf4V\n", + "Qjsgl/wrhDnAOtewHB6ZItkdavFig+60fLeTlg7cMJFlczdzvU/qs6q6TJQJBG47CWAEdpsb6IFk\n", + "CespwCNoRbW7ipqrJ9AWsqQmPNUT3usIso6dW1qSDCwHzjYe83tJ718cORuNID7WZ28KlQmVygcS\n", + "SGn4ANUSWpC0LYU2iz+j56Y7g421ts/6qCrnOtTtdRFa/GQEmjTtzZKON5o4RyTnhOPo9dgJ8NlH\n", + "0GOl7o80+NAl/C7KBJa4NCEvM/AlXEsgxAoBWB4rvWq8wad2qlSd6jN60XDl0dQjgS9QI21IdYR9\n", + "5s1RBtAJPzNIR+u25lkdoC6aF6FG299RF9A5hY0rWBVxQSpLvzyPSbuaMgj1lklDPYouMR7zd3Hu\n", + "20rkc9HI4R8hhP0qbTW0GridZR2q8fcHlfyR6vmTEoojnVFj7Rmo6miYfR5XGI85XRzpDbwGtIu1\n", + "U4M4UrnBbBbVq0uzb9+HFgFPzpX4XcJf7iGO1CMvM/D99flsBzOFfNk3DzdYf/Yb0ACiX4CHjcdM\n", + "K+K5SajdJnBl0AnVb89Cn3EdoA+aRO4e4zErw/WXKZJdn8T7E0g5YgdVzFwaL/mbg/fhnf0zKlXf\n", + "a/s2aG6hxwstyemT6Pssy6DVmuq82eSyQ9XlfB5rTSdBj6c0Md4bfWDTp3BTa1jbGRYN0G3r1dPw\n", + "jumOum3ejNqmXkTVRpvs8zgWLW14jGWWE9DSlx8X5XmWBuwK7pPEbaRd8CJ13t5Duu9YNJwMXMLv\n", + "otgo7RTHPgSkYw62IzRBl+ZzycsU5hc1iKqiwBrfr0Kzdc5Gi7X/XMK+auNXF3XCH51cGV0hfIu6\n", + "U85Ejfh7IJwHmV/atozmUtRrphawGTjDeMwvIcfh6y/lsQxubAtvjYONT/v788WodHoHkv/W0pF7\n", + "nga8Kv0f8QMcMQbSR8O+nVBj5y4qsQS1ZbwfLDTYXDwzjMfUt79PRQPfjomFCtKmcP4WrcZ1Rwcv\n", + "A6PtZOASfhdAaJ1pKA+g0vIyKNZYNVy+DflXCEegUZjBK4R5FcH3uiBY4nox6gm0BvXYGRUp4bIS\n", + "8HGo+qcn6tqbhNpxFgEzmdiiC0ueb826TvB3c/yqlrxRyNb+czGqXklD30/v4NTPhyT6fndB0jb4\n", + "7uU8/YWOUfk3Wqo4sKOD0PZkaPfXUjqtWQh0RyOtx6BePFONx+y349oFpBmP2WPv+Q/g7lCF20sT\n", + "VtX0IXCf8ZjXSu06sSL8IjIIeBbV775ujHksRJveaI6QysBGE2TMqMiEv6iEOHrXCiGx1Rh3J7cu\n", + "+B2o59ta/cK95xqO3FANkvar3zbERwF0G4l5BPlXCEcCW8i/QphTUMKxslrZRBPiSCJafvFeNCXw\n", + "w2gmyYGR3os40t721xmViH8HOjCt1UPUaNOM+jNh3H0wzZceP2zqZ0FVVI+hTORH4EzjMTsgIOq8\n", + "2no4mAC76uTpL/R8PWsN1KoDb1bxX+hOMKcCL+h5KjCciNYcGIDWMx6LMoL/ACcaj1lix3gecIPx\n", + "mBOL84wigThyJfp8L/DZM0rtWrEg/CKSgOpu+6ES2hTgfGP8RioRqYnq2gYaY1aKSF1j8n6kFZXw\n", + "F7Z0jv71rATV/Rno9B5U3QhVN0DCroMkmNXABt/W4g96D9lEk3q50HQbZC/QPqKZ4jjasGmGmxM6\n", + "QG0/IQzL7R069TSxXdlEAnvPpwD/qrSHxj3GUOWn32kQUIimxPcijhyPRhdXB+7GO/AmGKUSuBy0\n", + "OYegsLxDlgE8i1amEtR3/ma8g94tLJV0qBgVqH0/9OqisuQBtAbKSWHHYVU8/VAmcC6afvprlBGM\n", + "R6N5Ly+p6qyosCuOR1E7xKmBtRtK7ZoxIvw9AI8xZpD9fTeAMebRgDbXAw2NMfcV0E8FJfwBS9mM\n", + "kbDieNhTndLKpX9Iwqo7T5fWO+tBbl3Ye8U4Yz7pHdi2LFIZlBUs4WlAfmbQLmEvdbusJ7HdRui3\n", + "WP3TofzdpzgiR3/Eb7W70nVRbXhyNJxt/XQiuRf77E4DHmVHwgE+GVSTZd829bcoWupn21cK8BVK\n", + "qQ8wrcYYvvtnWw6+0bI4/RU3Wj1oDB+hK5gDKCPoAaxFDdKXYNVChd1LcWFTX7+Pqr7OLizuImrX\n", + "jVHpxSao65gPK1E9YiBaA5VF5Cf0oTxnjHknwuuWGSJT1dgyfpVzofuzcM5gWN0VVq5pYwNT5hRH\n", + "d1v4WLarQXRj26Azd+YL5V8Bw4ZAenAqg6KWrIsn2Ge41m5jA4+dniq/3F2b4+fUg4QAh9LiFOOO\n", + "BxiPMYO9kvvxXJjUFPZV8h+L5F7ss/taHBlB6oFLuWjEY6yss47vj1nG2sqbixMlblNGDLBz+2u6\n", + "/D2QRu/t45u5q9nUYBV792wqSn9q+M1Ey4sWO1p9JXDQeMyTwJOWGZ2M6tvfBuqLI2NR28Bon0oo\n", + "Ethyl1+jGo+zy0MKlEgJf1GIVmU0X0lfNIHYRBGZZIxZENhIRLwBP3OMMTkRji1ihFHVpItkUrRJ\n", + "aAnxvqrw7vdQeSe0+gmOGpKIWvpFHBkBjATG+nSjodBYanu6kXRnCnWr7uQg8xjKDr4MGsuKYTAk\n", + "Pb+ktDwfMQ+uH1vWqQzKCvt2sqPnTugZlMdyhxoByxW2w26A7kEOmdG4FysFvyGOfECrzTdx7Q93\n", + "oIbRP4prIzEeMxtIF0cup/GeF7hmYl00knYcaqMpfDw6p0syF1cBh4qxWGb0nThyHyr9+zJz9gcc\n", + "cWQHlgkAP5UgPuE44HO0ZOYzpe09ZO2lvSPuJ0JVT3fAG6DquQc4GGjgFZG7gBRjjNf+fh0YZYz5\n", + "NKBNXKp6Dqlq6s2G/SmwtQWYBIqqqiloyYp39kjUxTHbbt2AiehkHwn85ZtEmSLZnUj65B3ZU9UI\n", + "JB6Ec0lnBM+xgxfzelxEIa9PRUKskrSVBsryXqxL6D0c4NrMyez7JYdaNfboseLYFayh/lXUDXQj\n", + "sC9hB1s6fM+eNjPZsSPKxnZxZDAw2HjM2UH7U4HFqOF3vt0nqMurz0jcAw2E8zGCKQWphcSRc9EV\n", + "8pXGY/Kl4C4LxErHn4gtpoDWIp1MfuNuW+AFVJ+cBPwGnGuMP5Iwfgm/1ZkPvA3afwrV1sPWlrBj\n", + "0yZabvwf6hLn21aEik4tKiG2vu59gSyUEexBmcCIfg9z6x3N6H/7APjXeDh3tp7TlYFMpXqFL7oe\n", + "KWKZpC3aKOt7ObGu5GScQK/v2sBjY+DyP3R/ce0KNhXz5xiOqrmOPY0qkVzlINz1C/wwh4VfHGz0\n", + "7haO6hGp95vNivq08ZjuIY7dB7Q0HnNFmHNTgBPwM4LmwE/41UKLbTsB7kPrGZxuPGZGcccZLcTS\n", + "nTMLvzvnG8aYR0TkGgBjzKu2ze3A5Wi5t+HGmGHRGHxpI5+fceIuqL0Imp4/ndNnfYjaL3xbbVSi\n", + "WBBiW13MjIs+SSQbOJuDdKm6H86fCff8Aul2sdybXoyj6mFZictF2cCXvG1mfViTBgMW2f0l9P7q\n", + "cKz8vrofnXMrw7kzYWlt+Ku6sOnXY/bun/5zFfb7zBUl836z+vZfjcc0DXGsNpq3/2jjMcuL0FdD\n", + "/N5CA9BcQGPRlXpV1HOnxPUEogE3gKsUUBzvAht5mUFeZuDb0tAgmVBMYW0ovaA40qjWFN7KmE2f\n", + "GjvYn1qfqrtbw/TWUGO3ul+OWFhr919r659rdsz7Gsqnv7qLskdx5km0vb8Gi+S8m0CvO/rD8C5w\n", + "+wQYsbQ103q0hSaTYcIdMPH/fFcptlBjVUs7gaqh1DTiyONAkvGYm4vZrwC9UANxFSAVv1poDFr8\n", + "pczTj7iEv5QQpVz41QnPFJJRKcTHCJYB3ar9xblnfsn+d3Op6evnX0B/geoN4dI2CfvmHm3WHqh1\n", + "sAaQkzqf5dmjOPWjLbT0tS9P/uouCka0mHpxI7ajbVcIZCQrq8P/DYCvmySze+QnqkZtMhmm+zQx\n", + "JStYL46sAbqGyktkff5nA22DI40L6bMT6rnzFhr9nIyqhfqjq4EW+NVCY4zHLCruuEsCl/CXU9gk\n", + "Xa3R1AXnoJMoN2EPNVINiRmb4fZfNYUvwCmwc2NLUmosZXYCrJ7fhLeWDKFS3b94kiY0brATPv8I\n", + "2lgv4vLmr+4iP3zE92LIGI264k2H3EXw+CxjnOL05SO8exNgcwo0tH5kWbAxDWaHYirRtCuEYiS1\n", + "09vs3pJFMpuOhJHPwdZW9kjJ4l3EkSnATcZjJoU5/jKw2XjMv4rY36nAm8BQ4zEfhmnTgLxqoVzy\n", + "egttheivymPlx+8iQhiP2Wp1j3ehOdT7GI/5bbBIzssp9FpQB+oF1MFKFRImnEelrY9qNsYhq0if\n", + "6OXm9rDgA6HxtMbQLMAhrTT91csyHcXhjGYw9GLI+KwyPLfv0O6qV8CdmSJTikM40lRS5Z1O8G0b\n", + "+OIj3X8c1PWqKoMhkJ4pgq9f+zcq7zWUGzGLtk/ilYEX071NOld3hd+GwoTFi9mf3w25iFiJxhiF\n", + "wxPAZHHk8YLcN61651Y0cd7p4RgJgPGYdcB7wHv2vEyUAVwD/E8cmZmygiV9WnLSV8tpmuiPvM7z\n", + "rMsKLuGPIcSRjugkTEcLaH/p0/dvh911dkGdoMVquiF5V8BbGw4Z2XDTdtidYKBbUKmK0vJXjzzG\n", + "ITYoj3aQNEgejRJ9b2+omwvXT4E3DVVPqsMz4sha4I+iOBD4YgHOnQ139odlNTQ//M4EOP9MeP1r\n", + "GL5P5xRRIvbBCMVIRDKn8Mu6m5jbtSanPteK47ekUKX46giRzGz+2egYNtXKFG/WkFDCiPGYxeLI\n", + "SLR4y6Mh+9H6AS+ibtbdi2IMDujf4K+N8JQ4kgycUHsjr60eSNNG1WHl05B0wP/9UkrPOhxcwh8D\n", + "WD3jA8DpaCrCV4Kj/UJF1l4Buy6FlNf3wEGBSvazSIWUOfB42UbiNhsKwzPo+QSsPRoW90eZQHaZ\n", + "T+KiwqdmeEXI8MVDxEriKg62w27fh3reLLjiDPi4A7zxFVQVqqGpAmqLI2OA71Ed85pQfR2aV3vJ\n", + "uGQGvHIsyI9wygH47wE4/Xz45gNI3Ve2kc3BAVviSBYwTByZBdxiPGZZYX0cEkbWZjSn6kbgiYwC\n", + "hJFHgR/FkWHBtX/tCvxT1Eh8gvGY7RHdm6YY/2GwyPKPodWWZCX6PsQiirxS4U1cRAviSDVxxIMW\n", + "ydiMFpweFirEe5YxIybCzdkwajCMy4ZRC2FOL2D9E36iDyrVh2pfukFKaclkfgDdXoD1mQH7U+M2\n", + "FUIzGDocMkanQ5ub4IVu8GxlMpqrxBW3WAHDpqvOmLYb4ec34R9zocdVsOBotgMd0GLrOagwMUcc\n", + "mSGOPCGO9LMSJ5B3Xs2ezuSnjsH0SdRQ0De+gkY74MzzYGsV9pT9nfph0yh3BKYB08SRe9umyulZ\n", + "IqMGi+RkiYzKFMnOe5YVRrY1heq+pfLwDHXOyNf/bGAS6ot/COJIG7v/dzTTaEREPxC+1VatoEoT\n", + "MYkiN8bEfNNhxH4cpXZ/XhLwciVeVuHlfby0LEk/HSD7KlhgwPi2K2FhB8gu83tqc8xv3FHPUP/P\n", + "wOEYyBoZ6+cdbjsHcnwD/bUp5qxzMfXuwKRnsxQv9WM9vkLevedy2Bn4sP9Zh6UJtzMDL5Pw0j5g\n", + "viXipQdevHj5FS/b8TISL7fgpT1edeowxlDp+sS/qndutacXvcwAjjVfkWpanMv2xNuYipfkWN+3\n", + "vZ9WibcyMW0oe79P99//VbAgcO7DOTlgDLX/MmR+EPCozskJ0+9xeFmGlyr298l4WYeXq0rpHUb9\n", + "+y0p7XS9ekoZ4shAVI+/FbjdeMzkSPqLhyhUcaQN+2USn/TbxfzRjf1Hip7JMRYI5ZP+Vx046WRW\n", + "rOtAGvAR8JTx5M0jFS8I9e5nexmFlkV8AK158YTxmH2B59nyf31RY+NAdKX/PTNqbGBxp8s4bmdD\n", + "XpsKCElckJtSKefxrfet6YAGKf3TV6ErlsgSGXVDGwYOzYKhv8Et1swa6LUWurALFOQdJI78ALyL\n", + "+uY/AJxnPOan0rmL6H+/rjtnnCHAcHsEarj9Khbl36INcaQumlPocbwdVpWnvEAF+aTP9jIVzSd/\n", + "LVr79gnjMRNjNdbiQhxpgRYXr4fmng+ZRsB6nLQBBrK85r9psL8eCftgxDD4/WrbKnsU3pGnoxkt\n", + "KxMHGSd9EcS7EiG3MtSxypHACOJiBVz6PNLabW3ImVPaw8H1JJk+8cr0w8El/HECcaQxGuBxGipB\n", + "vBosgZVXWF3xj8DPxmPujvV4SoLCJC4bgX05cBuaf+oJ4JvipNyIFSxRvwytiPUyWrc3LMEWGZxD\n", + "wju9GHQLVFsHH39ujwz2VbqqAnyMZuEdHMt5XNQI4qIEXB5iEFWezuDs86D5LzCm4zqmbb0ingWX\n", + "UHAJf4xhs//djhoKXwce8QVtRIp4cEG0laDeBwQ4vzwQwkhgSx/+A7gDTbnxFPBOeSgCL440AV4B\n", + "WgJXGI+Z4jsWOJdG073D30ysS/IWuLk5vHAl7KwJ/LYRVlxqC6xXAT5DkwaeHyviH80I4kMqoQuz\n", + "4e9msHAAnPQwvFZ/lDEjy1Wwo0v4YwRbbu0yVMrPAf5lPGZptPqPh6LoAOLIQ0AfoK/NcX5YICBH\n", + "y51ojdoXgJeNx2yO6cAKgR33+aje/y3A28HLyYFz6TtSOY9T9+3gusqcejNs+weM/4/twZ8kzRaA\n", + "/xzYDlxU2jlpwgk60dKP+2sBr4Od9UEMXJcBY+puT1jQcGkqGxodydw1tfl7dbzHeZSYdsbaYh+J\n", + "ZTrWG14G4mUmXsbjpWtpXGMQjDJgJjXBPHii3xsgC8rMewYvV+BlIV7qxfqZx/h9Z+Llv3jZjJfn\n", + "SuqdVcZjboCXT/Ayr0trJhkwW5Ix+yrpPPqWVJNA3z00mGG4rbGh0t6QHlp4ScbL93h5Dy8JpTXe\n", + "UJ4vwd47ET8TBo3K64k2ztDxdMNlJx3al85g8y2pUb921N9vCWmn68dfAogjncSR79HgqP8AvQKX\n", + "09GEL8S+1VZ4vyPc30v3l1XQhzjSD3gEOMV4zIayuGa8wnjMLOMxl6H+5XtQ//L3xZHOsR1ZeBiP\n", + "WWc85hzg3zPPovMtg+DJHtDpOviiLWSzgzTYxbpO8OvtUCUgP0hATIZVcZ0J1AfesivdqMMXa2GA\n", + "eXV133CiHWuxYpiuaHwYDbM/gxoroNkEABbxEc/RthSuHR9wCX8xII40FkfeQNOwfgN0MB7zZWl6\n", + "6/iCPurvhLFvwweZ8NCJZRP0IY5konr9c3xViw4HZIpkFxQoZDxmlfGYO1GPrd+Bb8SRH8SRgVbF\n", + "Eh/MHh4AACAASURBVHcwHvNpz5f4ZWNV+KAjXPIHOL2h+1WwL8Vmapt0K+yuGXDWjl1BfewCzgCa\n", + "Aq9bu09U4RN01qZCzythiw09i6agowbciTdD9igYPA7mbuZgIvxylxZcslidUi3q144XuCkbioAg\n", + "w+1wNOK2WLU5S4rA1A0NLPE/8gr2HUgnZEh+tGDTSnwL3Go8ZnzYdhUsUVsYm0rItA52DjwpjgwD\n", + "zgOeBA6KI08CHxqP2RcPhnkfNuzgqYzPaf5sGzKuOxVO/Qv+XMv6ndlzEhl9QS7b36/qbx26VrPx\n", + "mFxx5DQ0vcJr4sjV0TT0+wSdRjvgtPnw6rFw9y/RF3QCU0SosZeB/H4VGD8v25y2E3aVz/rMhcE1\n", + "7hYAu5y9HDXc/gTcW5ScIdFGsFFrdmveX34h96E5fp6K9vWsS+M4NPbggbDt8vhNG9Thp2SVk+IF\n", + "PrfBS86CNalw4nI4aRk8vJrRo/eYEMFBflhpfyDqCdSm7nhGnTGWk1/XlQEQ+xoJvrlUuSppk06j\n", + "xYYMqpjKXM7Y+lmsaDGE3Jrb2WrmsmfNowW9QysMjQTmANdFi/gHMt4ZDSD7QhjwHIumHCi99COh\n", + "/P9byGA2/HMk53y5Y9HU/fFbn9n16ol4DEGSa9bkCRy3eTCaU+f20tLhlxTiSFOUOD9vPObZKPab\n", + "gHpwbEZdAcNOkMpy8rT9jD2GerMh62b43xiU+GdthLTZkawAYiUp+wKFNqfAhGbwcwsY3wKmNODg\n", + "wcpMBH4GxqPl/QpK6dulx6t88+saGr3WBfovUjsNxFeNBHFkABr49SPwb+BilHF9DTgFZaUUR9LQ\n", + "pHDTgRujpfIMFHS+H0ImW/jv35+Y26PRdzj4/P8TSGzi8+qZc93fzSov45nN35n743Vl6xL+iK4f\n", + "wPEb/An974DaE/exJOFRumz1xDLitqAJZ+uLjkPTDLwQles58ixqvMwqKPgnUyR7A30+XZ8wMoUh\n", + "3TSH+vQr7VGv3aAkK4BYubBaZvP2SKgbfKx/EmN+uIfHgJPs1hWYj58R/Bxs/D5HJCejL70+bwff\n", + "vwstLeEvab3a0oIl4I+i+vvr0Hu6A41ifhuNSQlp2LfV5UYDk4Gbo/2t2CydjwCdy/o7FEduBTri\n", + "7fBpiBTkcbGydQl/RNe3AR0Np8NFg2DcfTDtajh4RkwLmYfJeZ9nwokjLdH4gceMx7wc0fUcuQn9\n", + "8HsWFnyWJTLqIMcOHN2/N9ReCB99jkr7QOqVkPsqHPSZkIpXScmnbtleBdICWE9pSso+ZnOhrXL1\n", + "cMCxUIFC1re9C35GcDywCj8jmFB/Hr+0TKXJd+/Db7mpDKMte6jG9Cq5e7e1W3UfZ61+PJ7SeIgj\n", + "vdHgw9+Am1Eb4L9R+8XzwNOhslXaKnJj0FQXt0Xznqz6bBZa/erHaPVbxGs3B6bzwICpHPh+AHX+\n", + "gj1psKORbVGyCmFRHWMJaafr1QOoNI3mlR+2EKbcAAcrE/sUwzbN7NVd0PziEJxm1gaLnQzcI45c\n", + "HaqXosAa7O5B3TYLjThOg+SbmEsN+Rq+GY6P6CdXOh+O/x2StgW0Lt5z9Hl2XHkGtL0R7u4HvzWB\n", + "ahJ97wpxpKY4MnB7NsOWX0TGWXfBUdXUR9eLliQMFR1qPGaP8Zhfjcc8ajwmG6gNXIjqvM8B5m9q\n", + "Sr2Wn7L9t9xUbiab0UxhHDls2zu5CktPeoCZ1eeLI4NtlHDMYTwmBzgKWIcWETnBeMyNaDGSDGCB\n", + "OHJLYJpne95WNAHcScDj0fRsskzkaeD/CmsbbVg110KO3NYQgKPfgr6B1RpjTR9KDlfip2RZ/coC\n", + "hyIM76wLL8yF3Hr2SP4i1OJIBmqA9uDtsLY4+khx/p+98w6votra+G8lARJIaNI7GJEmqEhTkapA\n", + "sCvYsCHYy7VfvX7OmWvvBTteOxZEsQHBCihVEMFQFJDeOwkQIGF9f6w5yUk4SU5JgXvzPs95IHNm\n", + "Zu+ZM7P23mu9613SEUgFzlRHZ4bSN/+sfByJjKAVmVQhnt0sq76OpXv+hP2JAXtHNuNXYHYD+KIV\n", + "jG0NS6uw70Bl3gLGApPDFQ7z6IetgW7epyvQBJjTYjbNn1tCky5roG4AlT1ct4y4chRG9V0KPFn7\n", + "R67dN6PTtbsOTqlEs0mwq1Fu/YKqveZyx6S9QH3gGZ48dh17ml93OPiRxZVuWJ3ZBcBN6uhGT3jw\n", + "EWxw8GESFllgK6aGsdyZVY/O+/ezeesWbl54sHjcct5AswLorY4uLI5zhtH23SyseyujNzSi0k64\n", + "pSW89z1sOo6ytg9QPuOPEvkTOqAgOlvpIt3ThfEzZvzIOIRepo4uBfpwQJ7kxAqjoGM/aNPD/m05\n", + "0txGh8Jbzn4FXBeq0YccmunSgWSQymwmMZmalWfv2bjj2HV5jX7499F/bgE6rYNHfoSTX2ZZ7e+4\n", + "BViJid9tEFc+EFcu8FhIwa6thrjSX1xxvYS7bcCXmATDHCyQWUMd7dnyGxad/Wdeow/hUfnElcaY\n", + "q+cXTMZj1+beLNx16fIM7q4D3R+BpHW5B1TjOGA7MIGlVa4j/rhPbQIyuof92+2Fgn63koanTHoC\n", + "sASYL64MAdLU0bMxKYirvO3nt4kxN9nEbHr/sJbEnzfTvGM8H7SJyV8oJeK+ZAKvYPVvSxuf0XJT\n", + "EjHXLGVfNfj5fjj9Hg4P+xA5ymf8OX0oWtWvbPrU7QXu/SyZF5fA3qMoSvNe6p+YxmVL2vLdqzB/\n", + "iLf1X8DPs1WndMqzryvVMCP1TiS00HYiKfUrcX92bU7K2suKLdu4Y5G2pTjuYwgqmg2wYOR52Mx9\n", + "EhZg3I0Fp7sCjYHZmIz0DGCGOrqpoPaiEQETV9pi9MYvvT4MBOoBqYxv3Z4/fmnP3pp5D4rr9xMP\n", + "fPsKcBpbK19FYkwSazvDp6O93xoOi1mlKydhs/+VwPXq6NoA6upjXf5D8xmrqbYuCca0Mb18gO61\n", + "WPrzZj2mmPpQG/gLaOUVNi81iCtzmHrUp3zXuQexCZW5bdxJLEh8RFO3PFr00SXct/Lg7pGLQpk7\n", + "0i6F+xZ/yYspM9mdlV6UIRU5cxu1n6zBFX1h4jOQdon3zZnbVL85Kmc/VyoA4zCXxE2RBOTElT7A\n", + "Rxib46Nwj48GXnGRrpjL5lSgC3AQqIS5Bb7A8hz+DvWckYiAeQbpFkzELQszTuOxeztLHc0ORSde\n", + "ZPAk4t/oQeNpsLR/biJR3TO2cMN3Z6mjM0K9jpKAp9J5P3Aj8E/gbXVUxZWYgU+T9k0GrbclwClD\n", + "rRD8LbOgT0P2/Dicx9TRh4upD68BG9VRpzjOF0a79wGN1NGbvL8HYfeiY1mr1JYb/iMUITJ3dgJN\n", + "Qwm6ilywDT6rQZ00aPcx/Oi9cxXP2aX7vqzmnU8w7nYD4JxI1BbFlSswrfrB6ujkcI8Ps61YoA25\n", + "fvlumGzAr+SdzW8WVxKAvthK4CxgFTYIjAUWRMs48eIEx2Mz+oHY6iIOc0U8pY6uC3pcESvKAuNM\n", + "NXss4tYpCcAa7H5/U5bGRlzpgM3+twLD1dGVgVr5K6qb8X9xAry+hJ++e4AG2Iry8WJo+1jMlda0\n", + "NBVivTq8kzHjn+29P9OBl9XR90urH0H7Vm74j0zkvPBNJ8PuurCllfdN7hJfXNkFNA5FJkLkjDnw\n", + "7YmHfNG8cxZX/vpvjK99B0bROy3cYtLeQ/8AVqQ6RR1dFM7xIbZRk1wD3xVjlWwk18hPx/zNhQ5Y\n", + "HlvmFGwQOA84gA0AY7GBIiQD6nHV+2KGPgXYhc3oD2JMnrOjTfArbFWAb8G3wAUYt74KVhvgg7Kq\n", + "DeDd17sxps2DrR9i5SnZPO93k82tB92ugLg1zNrdkpswvaeR6uhTxdD219jg93q05wqz3XlYktrP\n", + "3t+nYtd1bFnKlJcb/iMUOcydIf3h1xvgz3O8b3KZO+JKOtBQHd1V0Hlyz9cuBTq/CW/Vz9169Xoa\n", + "TrmP4X9fDByLiU6dpI6uDauv5h56FQv6DVRHNxR1TFEZuN5svi15mTYNsNm838jPUEe3BDl9OH0X\n", + "bKbuHwRqYUHtscCPgQwhb99jMSM/EBt4pmHGfjywDFvqDwP6qaN/RdO3nHaLWhVYv3piRvcEjFv/\n", + "qjq6vTjaD7u/rrTGZv/7Gn7O++3nc6HfTTZjILO3d+J2zP31KVbzd4Q6+lyUbfbEisy0Kc2Vj7jy\n", + "f0AtdfS2gG1jgenq6JOl1Y9D+lVWhl9E+gPPA7HAm6r6RAH7dcJe4sGq+nm+7/6HDf9ps6F7RxrP\n", + "gLUnwsGzMDp0nhl/BlA/1Nl5QQZEXDkZo21mYb/ZY6FWVPJmvaOBbOAidTSjqGOCBUyHVObv8b14\n", + "b3snKmBGvhOwgVwj75/NZ4fSr0jh0V/PxQaBNlj26VKMj38GFivwG/of/NfrDVTPYz9Sf3W0RMXy\n", + "CoKnnHoXcDbwHvBcWehIeffjNmwgfAR40f/biStXYgys77BqZgo8qo4+HUV7ggXsHXX0myi7H067\n", + "rbHraOIfcDzX01Rs1r+1tPqSp19lYfhFJBZLW++LZS3+Clyimnf57+33HbAHeFtVP8v3/f+k4Q8+\n", + "O/8XsHA9LBkW4OPfDdRRR3cHP1MIbblyNMbgGYol57yB8cevVkd/L+LYBpgBnIEtd0OKCbST6rOr\n", + "Vjym45/VqhATu5uKHReT3j4D2cLWXQ15jdzZfNm8NEa/TMGM0mkYdbMyxg56D/hKHd2UE3yPS0jg\n", + "kiktqbtjM4nZ3UtLobUweJpNt2G/60QszjC3DPpxDJb1WwHTeFrsbf8XcCFGnXUxJtZY4PJIXVXi\n", + "yqVYfKFXcfQ9jHYXAMM8qqt/2yvAPnW0LKimZWb4uwGOqvb3/v4ngGreQI6I/APYj83uvik3/IYc\n", + "/361lRC7H7b5mW9nzFH99qSc/VzZCxylju6JqB1LKpoGPO+XdfBmTldiAcOXsZnYfutXAMuo0vY4\n", + "Os5vx5/HbmRr3fWQUWBikbhSC5vFd2VetTP5qV8HdnyS831ilYt4c/94PjuQUSZaNZ5vuhu5LpwG\n", + "2ApoHPCtOrrVW9mkYCuBfsyvuobx59RFX6rFRedBZg34PGkZWb8WSKktC3jU3GuxQWAx9rt+G2kw\n", + "OxKRPC/wfQNm4J/2PtmYe7A5cCbQh4N8yf5YYXLbv5lZbyUH174Qzr30XI5/Y8SE3yK5vkggrrhA\n", + "ojp6Z8C2uli2dmd1dFlp9SWn/TIy/BcC/VR1uPf3EKCLqt4SsE9D4ANMVuAt4OtyV48hx7/f/RGo\n", + "mAE/POZ9kzczV1zJxBKNwg4ieZoy32HUwkMUDsUKc78BNASuwte2waFSy8Oy4YpYmxQDDF9KxV9u\n", + "5/7Fa8gNwnbDeOuzgOk83SuFjB9PpPZCUIEtrQGo1LQTybVmz11wFh1LQ6fGo1v2x4z5GRjLZxwB\n", + "dMtCjo3n6V5TyfjxRM69Cg4kwPiXQGOBAYdlYW6PdnkJ5gY6iA0An4Tq0oPoRfI8/aiRQA1M1nwR\n", + "pvi6HbfNJ9Rs8wpXT2lKZjW7l1PqrSdt0zA9uCAc4383cLw6elmox0QLL3P5G6BZ4LPr+f/bqaMX\n", + "lVZfctqO0HZGqxESyov7PPBPVVURESBoJ0XEF/DnJFWdFGXfjgB4mblV18DmtgHbD8nMFUK713kP\n", + "sln9W8BmjGd+CLxknDOrLuDpPS2YGVezcnbmtpEJnPKkNTn1XuDNWGLuheSd0GgGNF6WTMO/vsCy\n", + "Omdgfs6ngYU5/l3f4O7E7YVBg62kn2f4EzYk7V90qQVWxZWbi9sv7V3zCeQycNoAP2KG/q5wAtrq\n", + "aKb4BltcZfwIT4bCe3wb7esprjyLuS2mlXRMIlR4q7Z3xZX3sAHvbuBRMdXVkaHEifzlD52eUD0T\n", + "bpgNI7NITrF8hSKNszq6QkzueSh2718CrgAmMjB9BN982pR5d0KXl2H+JXDyvPqctvJDceWCMITY\n", + "RgJ/iyuN1dHVIR4TLdKwQjEnYW5tP54F/hJXuoST/R4JRKQnFuCPCtEa/rVYdqQfjTG+cSA6Ah+b\n", + "zacWMEBEDqjqV4E7qaovyr4cgVj9IjHXtKLq5qYs81O4g6aCCzZ7CxcuNmvrVRgDoq2PAd3gbF8S\n", + "FdvHV7YSSMt7wYWXwLS7LZmo+iro8iKs6QZT74b1iTM046tTC246PZPT7zFdmt+vzNmasY8/Dlbi\n", + "ZMwgzRFXHgNeiCSXwA8xWeHTMWM/AMjADP3/YXLJ+yI9d87gvD8p7+YtMXOAnRizpoG44mcI/VBW\n", + "NMtAeDPSCcAEL/P2LuB+ceVNLAAbNN8AckXyLlwID/SG57uCOwkqzwtdJM9r/z+eVMbrGA/+Do7Z\n", + "8jUdX4cfHjchxFOehCUD4e+D6xkw71VxZRVwX1H0WHV0h7jyLrnJcyUOL2FtDBaz+DVg+25x5UHg\n", + "KXGlR0muZL0J8ST/3yISUTJbtK6eOCy42wdYhy3zDwnuBuz/NuWuHiDAj14psw1Xz27E+BOWsSpx\n", + "abDMXHElC0gIZ7kurlwFPAh0KyrF3Z+AcyAGmh91Ems3/wooXH+CZf8u74PZ0MBiXIdKCeSJDSRu\n", + "akSftGZMXBqbW8c1X7aqMWtewQp4h6wV5M3qW5KbRNUZCxSPA8aro0tCOU9IbYWSdetKc3IZQu0x\n", + "htBYry9lHgD2w+vn7cAQLKnt6WCiZ4EJWQDTGptC6uyqZOytweVYZbaQDYf3e10GPMOCupk0kSZ8\n", + "8zr8eTY0nQxDBkD2/gPEZw8BqmPP7UzggcLyRDyX0hzM9RJWPkqkEFdOAMYAyfncPbHAPOBf6uiX\n", + "pdEXKFs65wBy6Zz/UdXHROQ6ANW8SRblht9wiDG5uw683mc5u/64uYCgaTZQKdRZsbjSG5NS6BlK\n", + "gpW/6tSnbeDJ2oksnZzCDj6BTq9A08nEjalCFlfh9/En0Wf9SUxZX4usdH/gb4FR8fMayLgrt5C1\n", + "fAXU212Qbo9nFC5OWsRL7SeRUXczq/YcZHcQvn88Jq7md+HEkyuNkEO3LAmEo+MkrtTBMobPw27Y\n", + "NGwQ+KqsqJ/54QX7bwBuxqiRTwFT/IYsmI//Glg2NoX3tnfmAoz99E91wnPHiiv12FFhDFKxCxXj\n", + "4hiVCmu6Qr3zVjP8i+rEsgOLB9wF9Jcs/lV7KRknfsdqtrIzWIBZXBmNudqKrQpdEdcgGO33wvzs\n", + "KXElBXP7tItmBRtWf8oTuI4c5LB5jhkHK3rCP2vAw3tBzwoqyCWuHAQqFORHDmRgrG5I7MyrOU7j\n", + "OE8d/SmU/gTKIB8UuFwT2UYr0itVYuY/ZnD7iOr8sac5M6m2U9m05FzSGr6D5lBQh8PSTzlu507m\n", + "d6TOH6ZAmeO6KlpkrJ1ISldhxJuatzbtxGN5aPUlJGDGvidGQ/UHZueXRnA4GnguqP7YIDAAM2pj\n", + "gbFqaqplCk/e4nIsA3cnNgB8ro5mF6Rb5DF3LsaWf0uwOtQhM2vEFeH3ao/QOuMuYjSG9zpNZ3XG\n", + "Y/gWrMFWSqnAmfFr+eHcT+h09Ek0f/UkuGIebJrK8nkZ3JxvQtAF+ASbgZeOsXXlCSBLHf1Xvu0C\n", + "fA98qo6+Vip9KTf8Rw5EBk8i9oMeXDoQ4rdD0gZ4dg3BdPYBxBUFYoIZusDZ2cYq0HUYNJzKxh2z\n", + "GRpqmcL8M7wHAL+q1tXnQNvNcNc0q4ClIBOgX0ZFSE02PzBAN47aNoMtNen+iBVh+d6fxxf8mgLh\n", + "H3iyYmBGIxh3DIxrCYuqkZUVz2jM0E8sK75/ccBj2/TCBoFzMK0bv3zE3LIcxDxjfjYWd6mHzVrf\n", + "Low+7F3PMOxxmQL8XzguNo9t9Q0WiB+kjn4prhyPGf77ay3h4YQ61H8uFU5eDY92hw+Pg8Q0lq7q\n", + "TMfALHZx5RcsTvRp2BcfAcSVTsAoLHFL833X0buulm19dC/putHlevxHFNIzya4IH0yEdZ2gykZo\n", + "8ynBdPa9WQQFGQY/A2NPBTjrUpsZ/TKbuk0s6BUS0lTHT4fbUiB1MEyeArOHwnqATnPgsY5wEWRm\n", + "QZ0E474ztTGM6Jx7jkT228NXdz5sbB9w9kOvKT/8wcR7TodbBkCMwmvfwCkfAvA7NoM6Yo0+GNtG\n", + "HZ2ojl6PUWeHY9nBnwArxJUXxJWeUgbVuNTRg+roF+roKRj75nSvT65noIMds18dfQU4BpgPTBdX\n", + "XvOS/UJpc7M62gWjeX4qpry5DHPjPdY8ja3vfw5OL0irAyMmwOw34EA1krBKYLdLbiWwZ4A7/e9K\n", + "KWA29tu1y/+FOjoH+CFhNa91gxcmQL/R0GMC9OsGL7ST4qlREC3KDX+ZwCv8ojGwsod9zhh6gJt+\n", + "EDm0qEihD7PfaG5LgNOXgW+SbU8kvDKFaarjx6sOGK3ac4pqp1kw7DSYPXsNe+tnww3NiP8WTsyG\n", + "owGmNIXTAoiYWbJ3BdUu2Z/X8IdWrCLdKHI89S3Mfd0rvLIaKm5gGkYcmCNWEeq/Ap6hna6O3oMF\n", + "qVMwyu3TwHpx5W1x5WzPFVPafZuqjp4LdMcyu/8SV171AvHB9t+tjj6KaRvtAv4QVx4Xk80OBZdg\n", + "UiADMVfeUcDAuf1pmVER5r4GfT1h7eY74PiPmIs9Ez28vg3FVoS1gJMju+qCIdIuRWRAqsjgSfZv\n", + "uxRvEuZn9wTDv/bXYZCbRLICv1vhRkZCcjgTspJEueEvA1hgcPptNO62nfrOOtIXreD9epdQe/8m\n", + "YLa35PWjUA6/32g22mUG0z9KhFM5KhjSVMdXga1vQcK1c+CNjrb9Tqg8FPZMbpZr+IfBsnkpWRvo\n", + "OWEaNf48yFbfFEhJLaxgTCD8FbdiA65yGCxbt58nMN/4o8Bn4sorYoW9/2ugjqo6ukAdfVgdPQmj\n", + "P8/F2DcbxJXPxJUhwQxpMKNUjP36Ux29FmiFuaWme33pGqx9fP1H4Ws7CSvLWBMzyveKK5WLun4s\n", + "ySsNi4G8CVxXbS6+C84j+4cWuc/0MFi2yoTe0rzB6SJshTIPKztarHV5c0kYE/pR4e38VdEKNPzq\n", + "6MrGC9jg6wl7K8AZl8OfXiWMcCdkJYVyH38ZwZvNbQHeBparVwFLXLkMY0k9DLyIsaUy1dGgLoBo\n", + "K0cVBj/bZ1sCdLwWFr8ElbKhTwXSJt1L67OfYtq+feye24XZGwZwKfYCj1BHO4TbVggVt6oDj2H+\n", + "8duB0Yd7cDdaeBIYZ2JxgV4YxXEs8CW+th2KquNQzH1JxBKy7gBWM6fGj3xz/qXom0HbFxMwewiT\n", + "xX4I+E9hdGTv/JMxH/9RwMDKf5O6vz5XnPQ1i2ssZF2wwjiee+cM4AlM5fUadfQ9//eRSE/knNtP\n", + "wqixDK7qBR99BRuOB1JS8U0YiGWBnxGMEts7Ub5Pu5E+P71jVclWV4M3v7I42XjVYsv4Lg/uHmEQ\n", + "V7pjvsmVwBh19JOA747GtL63YPorK9TRCgWdK5LKUaEgkM+dLeCfkZ/YillzL0bV0a5iImFzsOBg\n", + "G6wg9uXRtl0QxBRGX8cSBW9UR5eXVFuHEzwXYD9sEBjIpioxzH+gGovPDajhACVdqtGLQVzIlsqv\n", + "o02qMv1OK/GZ5Xe3523fSx57FNPqeQCL1wRNJhRX6mH014ew9+JNrKJZR+DiwrJ6vQD1GGyA/A24\n", + "r62PWlFJT/glVcBicANvgjEfwfLXJ6uO7imuvABsUUcfyn9sO5GU+O68W68xtd4dC8fcCme8xoq0\n", + "ndxUnAHe8uDuEYJ2IikDRFJbTuXdBvOoHbuHduTLdvbEnk7FgmazijpnoH9+vOqA4nqw/C4YyDX6\n", + "w2DZ4pNZAkz2klbewzJBZ2LJS/OLo+2CoI5OA07Eshd/FVf+6Yl2/VfD86V/7g2qdfmp/UqqroYr\n", + "+kDzHwP2TCxRV4I6mqWOfsxLKXMZ/zK0/gwuDJSoydu+OjpbHT0DuB5zxcwWV/oFC8Sq1XcYgK3s\n", + "KmLVzf7EvD2fi2nxF9Svg1heAlidhc/XX8lbt9QheUybXF9peH729NwM7IWDYPSncMGl0CXN724s\n", + "0N2Tpjo+4zeu+b4+e89uwryEJaz88iLmFDerJ1KUG/5ShN8tMwH6Jdem+YjFNKuURXKj0RxSkFod\n", + "PaCO3gdcA8SJK096FLpSQ362TwqkzoBb9zahPkbhuxtzRfnVWEvc8EPOvXkCU3vtAfzmrQT+J6CO\n", + "HmBRtfWMfxmeWw0regR8WzSLqniQkcny3jBqAoz5uMj2vdl6F8yF+QLwY2C8IGC/PzGZ7Pewwuq3\n", + "YVnRO4FUOauGr6C4hidD8RUmrX1MnTXs7nslDDsL3jwht43Q/eweCcOPlT3gg26r6bu4gScSNw2o\n", + "I1aa8RAsztCv9iUxdNolZK1rT4/MBvSKJEblnywOFpk0QCS1OJhBpU4dO9JQWCH0cOGnXh4US4Mf\n", + "+RUcqEJcm7+4GHingMMmA/uwINtUceXS4pQkKAreDCXQ114RoyDuwfy9HTW3DmkHSsHw+6GOLvey\n", + "JQdhlMCvMZ2XMqlIVbpY/SIMPxrNLyVRNIuqWNtnZDJZfjt6aPuBPvb+/ixvH+0wSfBPxZXZmDTD\n", + "Av8x6ug0ceU6TMjvVHX0F3HlWLZXSKXjDof0LjDZwRYCw48WaUfAO/ksB+RHnujbc22W1uj04w6y\n", + "uy7m+rMymFcPHpwCGbtDIz6opo0XaQek5GZtb1g1ggr6B6aD1BCjo16ArVKCYTT2npyMsY9uKGTf\n", + "Q1CAUurR7USIavWgqmX+sW6UfT8O7VfbFBi2BFRzP8OWQNuUSM43CCYp6F810VY3oWuT0Lp3oYNM\n", + "jTR4H3xUxscefAg+bsbHZnxcgc/iM6V+P47pOIObEzNo2nk3Xes9EtDP+l7fSr1fXvvV8fEyPtbh\n", + "45Ky6kep/x4MmACDJtm/kT2XJdV+W0gZBksU9KD3Ag2DJW0hxfvNEvBxJz424eNtfDTN95vehI8/\n", + "8VHL2uufSucXlQdjlSt7KklrvXdywIQ8fbq67h46vJPzzh7NYD2hR6J2G4pWvJfshGsYhY+qormD\n", + "KQAAIABJREFUxfC8TcbHT/j4rYh9e+BjOT5OwMd6fCSE2k5/S5rULsPQbfHeBYEOgAl2vWgk/S93\n", + "9RSKxrfCyGTqzgfxqyWMTDbdlvDhp14esw3mvwprk6DhriKplzGAerS/lzAO8z+BD8SVqiWxDAyG\n", + "HGpb3Qu7sPSaKqycWZkZZw4OWGp3oAxlFNTRHeroTZib4J9Aqhck/6+Fatp41fEDVEf3tH9LtzBM\n", + "Ue37V7jft4CLPU94oI9dHd3rsdmOweJcv4krz/mTxtTRl/F0jowWmhTPrFvgnR9NJfb64+H4d4Aq\n", + "Aa6bxrfy8zsJnPwMfs/+Mj5h+dS2O36tw4Fq07lrb2OysCSwOwKSwMK7dkd3YMH2rUA7caVAJps6\n", + "OhnLUeiNESGuLGjf/PDn6WRUNGaQH9HSQssNf6FIsoei979gwK3khogiC6AFBksrHIQ1VWHjHnav\n", + "MmnfgpCHx6+Ozsf0wNNlP382a8prkWYHhscD9wbBppMDfMp5BsFS8e8XBXV0BnBSrSms6fQui1Jq\n", + "yt/9Rb49XDIm/5fgN1onr4ZJzWChlwOc32ipozvV0f/DWGFxwGJxxfG0ju7Hqm2NImanBVtXnQY/\n", + "PArvfwtdXoBh37UVV5rY8xvbmaXT4au6UGV0Ths7sprMy4rnmc29OUEdvRKbQJ2G5RtcE0nGtJr8\n", + "9kVYADrVY7gVhHuxCcnLwF0eMaJI+CeLjXfCqgDDH22eTrnhLxReVP/zD6Dpz9gsAiINoOUPlt5d\n", + "n0VbkvipCF/dIQlc6ugedfT6Nqls+HUQjR871eiWEDprIU9yinyUPzklCLxBcHlvWNU9Z2sscQ0H\n", + "iKTW/4s7j/2WvsVlYKNZybT1cfq5P3LarOVUGL+d5qlweqc43ig3/qULv9GqfABumwmPe9UbCjJa\n", + "6uhGdfQWLGifjInA3YIxgqpy3eQDMCw32LrheBh5/DKyD4wnS/6ga+LbyFc1wIW138Hu+RgHAbx3\n", + "9lGgj7jSNSAJbDAmU50mrlwYruyDJ5x4B3AAmCautC1gP38Vsj7ARiwukIOCnnf/ZLHxLlhd1fb1\n", + "J7KF089DO3RY+Coj81OVfL8CfPxVVyu3N1I6nLahuHyp+HgcH/cXsU81fOwM9t0gmLSqKtrjKnRK\n", + "k1z/X2Exg9xr658KqlRbqVzfQam8+RB/ab79J+aNddinHp13K+hxN6Bz6uf14Ub6CfQN+z/hnNfv\n", + "F/2pGdppOHr+YPS2/miTAezAx9X46IaPxviIC+0Z6J9qfuz+qaXtRy+rT3Fcd+DvuD0erXkPemFN\n", + "VoT6O+KjPT6+xscKfFyPj3lcVfmtYHEFGnX9hWGdlSt7KTWWBTw6DyhcszRnPx+X42MWPmIC2hF8\n", + "nIGPOfj4FR99w7pXPirgYws+bsPHRnx0L2C/evjYio9hXlsSyvPeFlKaDuCvFmeycgBMCLx/kdrO\n", + "clZPIcgT1d+VmMBnDeO44ud2nFdsRR8aYVK0hSGGAiQb0iGz8S746Z28gj6hLQO9GfzOJrC0P1x8\n", + "Lrz3PWQV4Mbq++smZl66l/QPc76vxKV73mRh5f2xsKQmtNlsK45QS/QVBL9v+KILYW59SNoHVfeR\n", + "vC6Gt8WV7+3S2eX9G/jZBaT3asRRyzOg2Q54eiJsSLLZkjYgDiv8shaj/NUSVzYCq73PmoD/r+a9\n", + "pscgfX35slPzs0j+6xC8+Ez4152mOr6dCClwS2ImCZUX0fjri1mU+XJobBTPrXmWuHIqRhmuRLM9\n", + "Z+KbcLs6OirPzmsaZ/HWh9D1ebjkLHhtHhyMAxZugz8DpUNGATdhctTveu0o8K33bF0AvCyurMEY\n", + "YkXm0aijB8SVL7F3dQgmL3KDOvpZvv02iCsvYklm8djs/3v/8/7YqdB5LfRZnvc98uSw61TcyuUt\n", + "QdrAPQNEbl1tmf0RodzwFwHvgQmkM54OjBErsbY4ytM34tBSlTloJ5LSK5E7f76FKgNEUvOnm3vL\n", + "wKPzyzWEtgwMSE754VG48GI4Zyh8nh5MIfRkTuV0Fsy8jvSUS/3Utg5MaziQjOO2VILrZ0O8p4Ye\n", + "beDJ7xseMcHE59IrQnol+GdVNv3alAlAVduNJEycKylw24zzadUrBnZVsmNjFJL2Q3o2MZhRb4C5\n", + "IX7A+OGCvQutsOSwRKA6F61uSuy7FdgzwZRUtzeHA28kw8CoBrZAFCdduPjgxXMq7bI6wxqDDQIp\n", + "h1x3Uf0PpAN7RWoWiyv1NYyiNB6dszsmZvcs8La4UlvzFF9Jz+RgnNV3nnmLZ/QB9s4K7I86elBc\n", + "uRX4Qlz5XAMqd3lJYJ+KK2OBqzAD/itGNz1EliEfxnj7PSeu9AO+8a7zpXz7PYNlI7+B+f2/9z/v\n", + "mXHwU3Mz/JD3PTpqGvVjG9NtQsC24XD0AiJDueEPE+rod+LKvcB4caXIsoZFoCE2+zwEfv7u49kk\n", + "H3MQJkC//PzdPDOqsOUaAnjYGgNj34WhjTO5Zs+OwL3ElWrYLOk6XbfsS+B9/3e9pcIcgFp74LmJ\n", + "ucdsIS4x3BsRCL9vuM5u+/hRC9bo7/pBUccHcp8V2BcHQ+NZPqU5D6+9gN+w8n6XYYG5H7Fi8ZXJ\n", + "HUxsENlatTbSrBoJ2y1DtlI6xO6DLDldXFlNASuOQv7Ou+2R1qfCKc9FO7MufnirwR4udHzDfOnr\n", + "T4Tt65qJK+2AxepoVrgrA3V0k7jyAaa1FFadXG9WPk5cSQV8wDPiygXALero73me5+xK3lHB8xrU\n", + "0VniyreYhMS9Qb7PAt4UV0YBNwKTxJVxgA9f27YFDHQ/AKPElYbq6FxvlZIqrjTEitWod+4MccUH\n", + "XAocLa507O89753XwgsBKW2BK/eW8xmwsRUJf9cw6fJxH9qq4M1wbmIAyrV6IoS44mACWj3V0d1F\n", + "7R/keMGSoGprkLKBfp2cLZWh1c2w5UnbXpwiT4eUFGyy6F2GrngEeFgdfdvr5yhglzp6Q/7jq0v7\n", + "2f3Y0/ETluVsG8zRfEvl2Tt0fqe87YQ+qy0O4blQ9IvElabAS5jU9HXq6M95748n0hWImCyI7/c9\n", + "9/w4lLwrj7yDRijbDlKVrMpWyH3Kv2CWPyZfsno7RSHPdcdvh/pzof5v0OKJ9SRvScdWqn/w6ikN\n", + "2PhLY+qkQZ00SLv4kP7nF0lb0IqPVl/Ms8Ax6ui2iPvoyiWY224/ZnQfxNe2ZRglMutjFMtuRSVE\n", + "epOfO8nmH8w9NpufplRndx3v2zzCdO8Cs9XREd5xtYCvsSD1MHV0v7c9DmPA/QJUb+vjnW7wwiNV\n", + "SD72Ztj6JFyreZ/38yrJlAn30P2X/8Cwc+B3r76XAJHYzvIZf+T4N9AU+FhcOU/DL/tWE1PdDFor\n", + "1r/8izsIp6zK3V6csq753VgA4srvmA7PKkyP/QSMPnoIdtIqY3zchXSqdRNV9AC7N3ZhMbeSwbs5\n", + "A2Ek/uLoVjK558h/bfmhjq4UV87GhM8+EldSGdn8O9Yee7UNUrsTYeh6eCunzCQHr1/Gno3PqaOr\n", + "Q+1LQRAZNIkK7/SgUnqAyBmUtN5O0QiYPWfWMCbX8g+XMa3uraqbx4srVYEOZFZ9C4AO70F2gJpI\n", + "NTlaXOnS8lnqnwZP5ck6XczR721h9v5a3AK4kfZQHf3IE3W7FqN7zsC3YDQsGBqKG0kdXS+uPIW5\n", + "Xs4uYt+dwINSveepdOvQi5taw6ybLXtY87jAxmD1gkd4x20RV/oAHwNfiysXqqPp6miW5zV4Eqi1\n", + "wMf9+Ljtqt3ckplFz+71mLVzPU8EPu+Z+9mTuB/WJUGV/ZHcsbwop3NGCG/pdh1WiefFcGlgFOLm\n", + "gVx3R/VM+DJACiVa/m5R8OIWg7FU8xeBS7SgEnz118RkXP8gsxv1YfLGG5lNNzKYDmwIKCbj+YtR\n", + "qL7C21Z0ElxJCc/lh5cY9znQho2VanPp+lG0v7QffNIDpnSEHQpnzIHBk8OpMRAaMjI5UAUy6kFm\n", + "oIRLaentBEdOvQhSUoNdtzq6Sx39mZ26DNSE2hYGaJUl7EgAXl16K5/NuIHkK8+FD7zaPCMh+aTP\n", + "iAdu9nj6kffT0ecwGefuWALhHoyW+WiImjjPA208n3zR2FknhtQX4I05sLemF/uAgIH6O6CDNyD5\n", + "+7gHSypcibmM/N99g9E6ZwB3+Z/3zCS+mnYdI/M/76vhxewM9q2sBlU8cethBCy1w0S54Y8Cnr74\n", + "hZjm+N1hHl5oYDcw2cuPYuHvhoZpwHaMTbQh2A7iykCumdGeiUk7mH00RpH2YRpcyQ1z8gGqVEik\n", + "8wi4/gS4LMVcJUDZz2rzQh3dxau9KjFqSizdnoPTHva++bwBxG0umezYfCJgQOnq7RSM0LKCV79I\n", + "w3Nt5bPBn7g6bBkbdl6njp54zuP88s4XcOoqC1z60XA9isVWri2Grt6JGdBnsbjB8UAdLDP3Himk\n", + "EIw6ug/j4D8XmsKrR4jY0Qxm3haw3QZqL6FrHLaCDGwnC5skfoHpbbX0Jo53Y6vpwQEDwiygM/mQ\n", + "pjo+oxJzn6jP37/HsMUvmFh0n4Oj3NUTJdTRXZ5Q2HRxZZU6+nGRBxkaUojhLw53RxR4EPNLzgK+\n", + "blldHjt6J9f5/bSz+7KBUzmdOB3AkhovwSMnAlAx3fzVvFWfKr194soQbovtwp9VYOIzsKJXwCyp\n", + "bGe1wZEUz7pOMHIWVAgM25TMIBVUBKwQv/ThBtW08TK88lRW1OwCF63K3/+9WeztuB465nO8eKvW\n", + "xzCCxMv42vaOlNnksXSuACYCT6ujdwDDxJWnsVnIX+LKv4G38bU9PX87+Pgao3fehK0ACkGACywH\n", + "hwzUYzB56Ffz9VOBh8SVdZgr9Vx1dKa4MgloAdwG3Ie9c4OCtZ5VjTlrT6QaIONVhwBIhGWGy4O7\n", + "xQRx5TgsyHShOjolhP1dAHXUKem+hQNxpQfmkzwe2FRxK9/X2UaXlR9SJcZ7VC6pSuasKly7bJ2+\n", + "LzJ4EpVf6UHvB6DRDHhtLiDQsM9uhv94H2+02Mi63o8c+rIUp8ukeBA0mAuUdbD1cIXn3lwEXBGM\n", + "715UkF5cGcePdf5mytn9o60kJlaa8hfgTc8F5N/eGXiMfTHHMv7UWOb/VC938mHt4FuwAlPBbaOO\n", + "bi60nfyEiHwDtVhlvQ1AckHnElcGYmq8VwMLsMIxB7FiNdnAJqCGPxgccNy9GPd/uTp6nfWnvBBL\n", + "mUId/QMrHP2puNI6hEMKdfWUBbyX532sfN1GdVR7vEpWiwpUuef03P0+2kX8seu5VFyJo8dvdbmp\n", + "DWRVgnd+IieVbG3Fn9XREbp22ejC/MWHFw5f18thijYYDfbXYF8WVM8hYNX6KKuaXQNvJJvYWk65\n", + "lLCFED0p7gHAHeLK4IDts9TRPnx53Hq67K7H8E6Q4CcTWTseR38UtkIovJ0iXGDq6F4s7nBuIX0d\n", + "hzECRwJ94tfzU53FxA94nrn9fXxWNY2NmPZVfqwGamOxjKhQ7uopRqijP3gFGvwc/6D+cQ+FunpK\n", + "G97s7Q1grDq57qTqWVR67RMYfpYpBCZ6c5CYJJoB6+iyogafnp7J8hcCaCnDlsHqHGMZjD10OOJI\n", + "d72UAS4APitMkbUwdpU6OlVe77sfJIGBN8CCwXDA75IP372mjq4SV84EvhNXNnqqmIaFLXez8BNo\n", + "8QPsDaxbn9OOS5b8Lc26tGNl0wNRJtONwQoojSykrzPFlR6yn8ktVlJp43FUfjaOFq2gxcWfx2dP\n", + "GN98jPja3Ziv/dVYPeKw6eP5UT7jL2aoFXp+C8vcKyyRqRGFsHrKAFcDxxKQ0CKuyIaa1K25Fz4b\n", + "nWv0ATbW4VhgKpWz27B89QVHxoy+aJS11PERhguBz4rcqzCkH7QVVmZ1iJuI5VT5gPS2havFBoc6\n", + "Og9LjhqdVzAtPRME/u5LPoETizX52nbj+8776V3pZGN0FSVaWCgmAN3ElZpF9PWv015mUXwTaiRv\n", + "h3v62vaPD2bGttzTpGmQ9lcD1Sg3/IctHgZ+j9vFD/1iZWIBCpOHjatHrHTcExh1M9PblgC8O683\n", + "Fa+qkJfZc2kiGbs2MUgdPU8dXVJuLP934FeRPL2+zKywh5atH6Ja0UcVgt0bHqTqJftYVB32TcNe\n", + "HR8woVakhlcd/R5j+4z3Mmcp2o3X+FZmPFaH7+Kg4sVYUneVZGj8brh98HJzvqeI/ACAOjuJmfQO\n", + "VN0Hf9SFHV7ScRUyCeLyWovJiZS7eg5HqKPaOkG+3HkRl7QYQOVXxnlF4jzJhQU+pmDFpMu8RKBY\n", + "KcUPAUe98nfiSmOsdim72rH/81iqLZzFgWp7SZdtpK3L4Ik/D5Oi0eUoPQQGax9LhpZpsD+b59uJ\n", + "aKRsMz24cLx0rf8085vez8GnhOQJsKYrZNagIH2gkM7r6AeePv54ceU0VS3CjZfdAL6HNT6MIPSI\n", + "/1S1YPgLEchojMFkQd4pbKd0yEzaD+NGwbCzof/l8M2HsHuP33Oa6/LyxOD2ASFQTwtH1DN+Eekv\n", + "IotFZImIHKJ7ISKXicg8EZkvIlNFJFjQ4r8OzTK56c+PqDyjETx5im0L0MpvCKwtzDdaingIWAe8\n", + "Kq7Eiit3YiJSrYDlwM701mz+9UrO/G69HvXtPu1RSpTSchxm8KtIAnzWBi5cGHr9h0IxYMODxCTY\n", + "u9DiB7ixHbQa630ZFZX2CYzp85m4UrHwlWlsfXgEYr4GHoGmk6HuPO+7iKrujQO6e3IPBcKfr1Ph\n", + "ILzzBfReDs2HVmBhdT+j8xDa816KIXs/KsMvIrGY1kl/LMJ/icghjJa/gdNUtT1mZN6Ips0jBUkQ\n", + "n7TfxJS2JwTU7rIf7bBw83jp5EOw1Pl/A5sx+dt3sd/pNCyDt4M6WpR8dDn+y+GXEdlTAWrshe6e\n", + "lEi0MiLq6EF0r6lkfvs0jPkYTr8XBg2Gapuzizi8sPMqluSUDrwlrhRi7xIs26DmSvuz+U/QdnTA\n", + "9+ENQOroLmAScFZh+/mZT72Jm9OHOnu/+6Ef+2cNZc/QB6FZyo4gjLL9mLsnKkQ74+8MLFXVFap6\n", + "AON/nxO4g6pOV9Wd3p8zMaP3Xw+/5EKDdHj8+9xwkpe8UuaMHs/3ORrjDE/E6GfbsSSSszBhsXbq\n", + "6LP5+cSl1sewSkOWo6QRWFHru/dNRwqKSUak/V9TqX6xnXFVd3h1HmQs2MEtk08UVy6PQBIFyKmQ\n", + "dSmWJPVowXvuXQfAFq9M8/oTTZwuBxElHI7BAuCFIk11/I964KSfqH3hbGJS98/aNpmpVVcwJDWx\n", + "Zr8FJwRW5qqwlTjs3YwK0fr4G2KRZj/WAF0K2f8ajgBaX3GgEK38GU2n80BMReKDaeyXNMSV47Hf\n", + "4dqkhew44VsqVEigwsY6NFjUjy3ZlRkMnK+OziytPgXtZzEVAylH8SG6+g9FoNP2eVRIPYpfT27O\n", + "2kaLyMrYywQZQRfdBPwHuERcua6tj+MC1T5DeX/U0b2eGN9UcWW1WhH3/FfnZeVengz3w/obof4c\n", + "bK0+PNJcjq+Bl8SVpEDd/wL7GUB7FleaJ6xk7u4OuJetJ3aIV836hDSyFrWmTQR9yYNoDX/IPmoR\n", + "6QUMxXRtgn3vC/hzkqpOiqpnZYwCJBdmdIMhFeJIbrMRbobG+TX2SwKeYNUlwDAsAWR+1TTWn/8F\n", + "sU9WpO2/usOCltD5J7J2/MYdC7PK1ugbPHG3ng5sPRb+uJRogn3liB4lLCOyneN3Tuf46U2BW73q\n", + "WwCIK52AeySLtMSu7Bs3k9r+LPJQ3x9PKXMA8Iu4sk4dHZvn+5wcjrW3QFZDdg2rT+z2mrQ54QC6\n", + "bYQuXBVJgHmHuPILMBDzhoSDFe1+IuGd3cQOuMxUOe+eCuf8TdziLXTKZy/DR3R1OekKpAb8fR9w\n", + "b5D92mOCY8kFnCeiupFH2sdfC/bsi9GxrXLraw6AoHVuo/ptrI5oT3y8j48d+BiNj374aIePzd2P\n", + "4s/MWLTZbeg/+llN1JLqS2TP1qBJtPxKub2xUmVjQDnSQZPKum/lnxL4vX0Mx8eb+LgHHx8G26dr\n", + "Q37uMsxqTC+pmfNAhPXM4qMjPjbj4+QQ9p2Ij4e9/c+K8LquxseYSI7tW4+tCromCR16NrovFp3e\n", + "CE26kYyc80doO6P18c8GjhGRZiJSESO/fhW4g4g0warLD1HVpUHO8T8Df3Bs0EI4IUC4qjg19sWV\n", + "BuLKfZjI2kuYDsgx6uhgTI/kA+D3uAQaV8qGua9b9azqmcXfl6hQd20M51wDn44mt+gFHJ7ibuUo\n", + "BuzAKqO9BpwhriTn36HxWrKn/gfOXQxvnpi7PZxnVh2dA1wBfC6uHFvE7r8B+7AZ++viyk2hthOA\n", + "L4HTxZUqRe6ZD5lZbANomA7/+QoqZkPjnZCZWMZ0TlXNwpToJgILgU9UdZGIXCci13m7PQjUAF4V\n", + "kbkiUmTx4v9W+INjQ+ZD052526MNjokrFcSVc8WVrzHRp+YYh/g4dfS5ALGo57B6s9kV1jMdcg1+\n", + "cfUlGviTg86rJFMqDppxElOa7WRNQC26ct2csOC/nwUkEB5u2AFU99gwrxCkNGM6ZMYq/GOGESb8\n", + "CPeZVUcnYN6JCYHa+UHwG3CiJ0B3KnCLuPJM4eygQ9rahmnuhy3yt6wp712alPfa/lEBPRBPjJd/\n", + "EzGiTuBS1QlYinLgttcD/j8M8y3/zyOa4Fj+Enar4cUFPpZhcZMrMVfaf7Ds20OqeokrNwDDgZeB\n", + "O9Zm0284NCmRQF0E8CcHvQHJl58JF685yJqZi7ZPoffSLGplRKubUxZFzYP9ZqUVyA+8n5A3gfAw\n", + "zcPwz/jBCgD9Ja646miOrElxBpfV0be9RMVx4krPAoKvc4Gnvf3/FldOBsZichCXe4JsocDP7hkT\n", + "Th/Xn8UrXy/m3gEfM9H/DP3SnzOIYR1GrFkezvnyoKx9e9H4qY7ET1tIGQATBsGkATChLaSEcsww\n", + "WKKgGRXQt49Haw9jrzzAdnw8iY9Whd5fH8PwkY2Pf0fbl5L6+OMfL3VCO1yP7q6AFlfMAdqmwLAl\n", + "uXECVfu7bYldb+Bv5v8MgyWldY/997PNjejf1XP7cLjEcA75jXwk42NpwN/P4OPZYPe1uJ5ZLw42\n", + "Eh+p+KgQ5PsYfOzEx1EB2yrhYxQ+pjVrwsX9IXUQTOoPqQX1hSbNLub+2ANUOG8K9E8N57nDx1J8\n", + "tPb+XwUfe/HxCz5Os2cbjejay/oHj6bz/ysf/0s8syFa/V504KXo563QfrG5gfUCHppYfDyCjz34\n", + "eLOsr6OwzyCYpKDz6qJLa6B+QzXIGF5RndteNlVi9ivx2wNs8YASM4L+32xHJXRXxdzrKS3D67+f\n", + "va9Av21RvPezJD74qIWPLQF/N8THNnzUKuF24/AxDh9v47P6JPm+n4SPvvm2xSQM4+PE29j/V0CQ\n", + "OdjAnjPpuKK30mps2JMOfHyIjyu9/9fGxxZ8fISPy+z8aCTXXS7SdgTAHxRuvxHSXjEtj/MWQ9Vs\n", + "4gs6xksV/xKrn7sIuKF0ehsZ/PGP9hvh6AAFo+KJOSTZfaqTBrc3gSH94KTXoHrh6fRRtej9ZiM7\n", + "Qv8hkO55ZEsreO6/n0dvh6UBGpFlGcMpAjuB6v5ELc/F8ylWmarE4JVFvAhoh6nD5cdc4MR8xxzs\n", + "8SbVn/2ZCt2HwtTGtj24fIVHS154IbTxe3rCkoAILMVYBVPmXA00DvH4oCg3/EcA/C9xfJZF+P0o\n", + "6CUWV1phD8wuzG96kVcf+LBFydYY9mqlbjgBnlkHvw2HJr/ADRNPEleme7VZW0LxBUT9v9kd0+G4\n", + "TbnGv7QMr/9+Jm+DZZ7hL8sYTlHwns9M8soRPAncIK5EnalaRNsZGHPnMnFleL6vfyOf4Qcb2If/\n", + "Bu+OhdkNcrcfOrB7k47F51mt3tw9Q50A5DX8aUkw6egz+aPxLVYxLjKUG/4jAOEYRa8QxRSs+HQH\n", + "4E51Dn8abQjVmqJAgCTv/kRYeCF8Hr+M55MvBByMBTUp9j5ZKWfwwUMN6PcJ9JgA/brBC5EYf/9v\n", + "FqPwyjgz/i2uJHPJUbwZ/fUUDf/9fG8vc9+rz9ZQ72cZy2QEBnhRR5dhjMESX62qo5sw5s2/vdKI\n", + "fgQ1/P6Bvd8yuC0g3fHQgd2bdGTUgx8DC3yFTEueC7QRV+IZ3eh0vh1Ylw1Pt6bi8Q2ClwkNDeU1\n", + "d48QtBNJaVJIxqS3RP4XcD3GIBiCVeu59DBRAS1ThFArNabj+0zt25yuY1vBSetg1Of2XQqkjlcN\n", + "m44X+JulC3t/ugHdV4dqQP9QUviLA+JKB2CUOtquyH2Dy2SEXf82Uogrf2DP6x8B244DvgOah8Gi\n", + "iaYPXYBvgBR19FdxJQ4bkBp4VFOg6HrCOecLek/DqzktrvwG3MBTvUaw+8dO1J8DZw+D162+dSS2\n", + "s9zw/xfAq/T1DkbxugDoiFHiTlBHd5Rh144oDBaZNBp6KFZmMsmTphsMk0er9oz2/B7/+xXgOIrJ\n", + "+BdFU/WejU1Aojp6sPBzecXmK+yBg7GQ7VUFKaVi8+LKz8D96ujP+bZ/CXwbXGOnRPpxNvA60F0d\n", + "XSquzADuzt+voiZjOecrYtIRQn9eAxbw1FnXsvurdlTaBS2/8WRMIjP85YVYjnCIKy2AL7CC15cB\n", + "NbFanxeUG/3w4F++C7lGH4rPL6+OHhRXbsSMf6q4MiBwFhkuQhGyU0czxJWdQH2KLPXp+aOTJ8BZ\n", + "18Ki82H+EFhVpbSyufO4egLwGPCJuPJGacSq1NGvxJUGWILXyeS6e/IY/sLqCec5X/Q1p2cBvYjd\n", + "ZRLV+6p6Rj9ylPv4j2CIK32B6djsZBhwANPSf00dnVqWfTsSUbIBZoM3674RmI8ZligClx5jpMFs\n", + "iPWPVEEZI8sIcEkUDM8fvegCeG0ebG0JA26FO7/qIq48Lq4U6S6KEjuwLP88UEdnYL9LdNYuAEUF\n", + "8dXR1zDZ8m+ANIL4+YurrRBgAd72i36iypBicRGWz/iPQHj+/NuBu4HB6uhkb/sdGOUOw640AAAe\n", + "LUlEQVTr4UIOL0cBKGH1yRx4M/+bsCzqCZHP/JPiSVwPlw2At34xFVMgCGNkKXA0ptVUCPzSxCOT\n", + "2dUIpt0N0/5cRudNz5CyoanX163AKOAjdbS4a0oUNOMHq4X4irjygaexHzGC+ecLyGp+AKsfchFB\n", + "BqRibqswLALq03fTOqqOn8L4lNhctxH9I+lXuY//CEBg6v/2iuyfch2x+4+iRuNPeLHtIi5OgvgV\n", + "zag4ewhtNI7j1dEVZd3nchQNz+f/MqZeG7bxFxmQyvlH9WNnY/jhsYBv8vrkxZUHgMrq6P1Fn7Ng\n", + "f7TX39Mwl+IFGONkFPCZOrqz4LOGeD2u/BvIUkf/HeQ7wVa3T6mjn0XTzgCR1AnQb28crKgOrbfY\n", + "9mBBfE8TZxzQE6gaboDZ39bfNeDxU61cZa/lcM7B8AgD4sokTHhxuzqao2MUqe0sN/yHOQJnDKur\n", + "wnkXw5adpMd/xYvd93LRSEjeXQFOvA7qTmXDtrlcc5hqsZQjCKIx/tK39j102PMIIzbFccAv/ngo\n", + "Y0RcuQQ4z1NoLa5+x+Nx34E+GO1yFDAhkopt7URS9vbh2exEqrT+kgXBdI28oKsP6BgNU22wyKRP\n", + "oMdlF0DCAVO+hIKD+J47bgPwrjoaFrXUTxjYUhne7QCftrWEuvgVbFjbhqHAD/77VVCgXqRdCufs\n", + "eIk6e2qwJmkLE5JyWFaR2s5yH/9hDn+B61+aQJfhcFEaLP+EpOZ7uc6/fLy9P3RdA1PmUi/qwtfl\n", + "KFV4Pv+bCNPnL65UoPuWK1hW8QkODEqFwZMhJbUAmqDf1VOc/c5URz9TR8/H8iC+B+4A1okrr4or\n", + "p4aqYumf3PxrG8f2hkaF5E98A1QAIuavgwXxHz4NltWAlwLuVEFBfG8w/hIYJK5cGW5bALX2wJ3T\n", + "Ycab8NvrUGkL2zFX0gZx5V05s6aPuE4vGjd/dA/7t9sLIu0c6PYCS55vTkKN6uy8OdnbHlV+Rbnh\n", + "P8zhT/3PjIO3v4C7pxnrJNFeANLqwKRmuQ/wYaOnX46QEWD852Fsn1CM/63AGk7Y8X+q4weoju5p\n", + "/walCS4FkiOtW1sU1NFt6ugb6mgPjEq8CiMcLBNXHhZXWhd2vH9yUz0TdngiJMHkD7z79BhQpMuq\n", + "MEw/j7mPn0TWFx9DQpZtCyGIPxX4AXhSXDkj1LaCEQb+vZNlCT9ylzp6CkbtnU2jrFu584ujOX8I\n", + "VNnk7TkyGRrfDCOTWdsZktbDgcqEKfkQFOXB3cMc/hlD37/zbs8wBg/tNsHc16DKgZzth6sWSzkK\n", + "gRfwvRkrnpMqrvQvyO0jrjTE9OS7heLyUEe3iyvZQC1gc1H7RwN1dCXwmLjyOJY5PgT4XlzZgBUB\n", + "+lgdXR94jH9y03YTnPlX7vYCJjGjgYfEle75efWhQFzpRAeG1U3l9msyGBhGEP83TP78ArJknDTv\n", + "vIAVzfYXJfFdFGHA0yQaITL4AhJf6EGrLyAzML6daEVXdjaGZWfAfr9LL2TJh6AoN/yHOQrSIF8N\n", + "7w+HISMh2W/0S0OLpSw15v/bEYbxfxqj7C4J4/R+d0+JGn4/vAHpd+B3ceVeLDg6BHhQXPkVGwTG\n", + "qqPp/snNsVvt40ewSYw6miWuPIENfGEZfnGlEaanP2zDdP0Su8+hYh7Qlsdb1eCYers5/69uvDXa\n", + "09/JmzuRH6Hx/dMzyagPs/OHEDK8t1ssqe6AX8ooukp05a6ewxyFaNi4JadtExx+X+wE6Dc6Si2b\n", + "cgSH5864GTOah7h9xJU+WK3rR8M89VJC4vIXP9TRbHX0B3X0aqwC3JuYrMhqceWjmQOZMTQmrPyJ\n", + "d4EO4soJofbBK334FfCiOvplBNewG1hB7Wr38sdP9Zl6L1x0PshBisP1kkdPKgfDlsHql3K2V9zt\n", + "zfijr0RXzuopR8jwU9O2JsCSo8zNlLg/ci2bchQMLzD6EnA8Ju+wy6MWzgP+Ga7xElceArLVUV+x\n", + "dzZCiCu1gEHAEMmibb3F7Eyey9Yqy9i4ugjXi5ez0jUUppJ3L8dgarVXR8oIEldGkdqhIzN+t4SJ\n", + "6isCFDcHT1Yd3TOS8+acvwAqbc7266Z3Y1KLxfy579/RsnrKDX85QoafmjazIdw0EBbWhgbpkL6D\n", + "LZta8DLGTJkP/F2ULkw5ikZ+448J8PUAzgzXeHlslL7q6OXF3tFigCc9cinmDorDqKGj1NG/Ctg/\n", + "Efgb09P5s4hzP4rVzD1dHd0XRR/v5I/6t/LZuiaHflvyekaeWNtwr2C8bYvQdpb7+MsRMvy+2C5r\n", + "YfYbkBVjnOQLmrNmUwvigKswPnotcSWN3IFgPvCHOrq9oHOX41Dky/D9CWgGdI5wxroUGzgOS6ij\n", + "fwMPiyuPYMygy4Ap4soqLB7wiTq60R9jGgTx649i54JujAAKZNmIK1dgmbddojH6Hn6jxaYMc73k\n", + "V9uMzvUSIqoAe4rjROUz/nKEjJClaF2pjlU0ah/wOQ7YTt7BYD7wl1cFqRwFwKNhLgEqAW0jkXcQ\n", + "V+phg2/t4u5fScGTRO6DDQJnx+1iaddJNEr9g7p+QsPF1Tn4ayLXLFut7wQ5/lTgc6CnOrqwGPpT\n", + "HVjNQ60vJrvZzZGqbUbR/hrgZHV0Vc62cldPOUoDoUrR5ofntmhGwGAQs4+uxFK/yg72xG9l154K\n", + "jN/dgtHAfHV0Y2Cb/8tMIo83/iqWJNUe6Be2vIMNHulAw+KQVyhtiCtVWk9gWvOjaT+1CXz3HnRa\n", + "Z9+dWpeVv2zQZvn2bw5Mw3z6EVeqCkQ7kZSldzKm+yj+iNvA9tJ+DsWVbcAx6mgO96nc8JfjiIJ/\n", + "9fB8BZL/qANpdeHphuxceiyrshNphOUpzI9fT3rHOZw8Yg11W2+x8pPDYel0uO1/wfiLK5WwldEd\n", + "GCXwZeAEIjP+vwND1dHfir2jpQB/jGlTFaiWCZU8qbZejcmadA2N/JMFjwk1DXhDHX2xONr2P6/b\n", + "B5N8wUK4JC2657CoOgpBj3FlH1BNHc3MPU+5ZEM5yhDhSs/6szVTk2FEF7jmN1j8NdXOeJq1WOWw\n", + "jsCz9ZbTtmkT6va5EqreB21ugowLSN7dj+fElYHiSuOSykg9THAnsFgdHef59m/CxNEmRiDpHKI8\n", + "8+EJf4ypzu5cow9wYD/rgH8AiCuxwMcYx7/Y/O7+5/XE9fBbfdsWvLh60citozChH7Ef9IAJ/RJo\n", + "P6a9VJ9d0Hvjub3igGjjFEB5cLccxYBIpGf92ZopS8DtCSM7wrVzLFvTM3BrgDWDRe4dBS0X1IY7\n", + "z4AFdUz3hEokYLIF7YF4cSV/7GCBV0QbiGyGVVbwu7b0KKrFXkvH+l9xHY59p45qQMB3opfkFarr\n", + "psy4/MWBgpIZ11XkYeAZL7HLASoCtxZnyVH/83rFPJNP8SMyiRSvjsLRE6HXg/DRV+zd/WFCAzp1\n", + "bMzsFwp4b6oAu4vrmsoNfzkKRSj+df9saEMi1N4NsWqzoRSbDQU1rv7ZW0IWjP4Uul8NXdZAxsa8\n", + "2Zr+/dpuhtRR8H0LuOsM2CIkAT51dLq4UgcLHrcHTsbYK63FlbXAfFYl7KVdl96sG1Gf7S1AYygq\n", + "27KsEDiInt8XnKn8f3vnHh1ldS3w3yZBIo+AgIKSKEIUIeSqVR4qVR6KJLrUakFRS8FHbVcF69Ki\n", + "0ktnxtZl9d5eRfF6W9/F+ojV6xMQUFHrRRQVBRQkqSiCgqAgSAivff8438CQzCSTzOPLzOzfWt/K\n", + "N9+czLfPPPY5Z5/94ItlTOkvsi4izD+s/CMjfONR/tXAoFTKn0qipT9YzEFvf7V60EXcs3snZdUr\n", + "GLRqJ232lCW7Ulf4e1hUx7jWvBQpXqWz6pFQvACuGAwPv872ze0a+t20A35o+r1ioKq+H04M/+Ww\n", + "Y/+jFCqugJUKGj6ugJWlUBHZbjTMV9BTx6Ntp6AnXolOOBftO4wqgpxOkG6NvfajZWiHSewo6cIF\n", + "jckwQagqHM2fCbKaIJUE6V3vOxUknyB9CXIhZxdVM/Zs5TeHK7/qH/FS5bP8fo/rHqNgtoLOLEFL\n", + "JqI1+U7YcqgnK0GEIPcQZAFBOjb22gQZTpDX/e5jsg4orYArVoIqR76iXH+I0vX8L6C0Itn3ivY9\n", + "vByq6v4W4pN71OyIl1FKZiqtduiZnKgKOhrmR/nsjiJIdf3XQpvTH5vxGzEphkn3tqLkvDFQvhJG\n", + "fwz31dSfkYRnQ68/DN+3cRlDlxwCs4+kNTAVKJOQ7AKW7D2CLNkxjckV3/GL9nDg1iXU1J6KVE3k\n", + "AgnJM+ElbdQkV8rdmyt1poRkKq4S2UIJyd+APxIsHeyW0qP3mnSg32qo7AVAfuQELbFEV6kgbFJ4\n", + "7hi4e5bbzIboJgVv5l83t09DM/+MNvXUxzOZdPkULhgL/3gCNgwrhoqYK83mktzqbBGVzgCqyunN\n", + "GCayHKi/ihDpX8ERA3/HOcu6iZTPToaZMmHFLyKjgDuBPOB+Vb0tSpu7gHJc8MF4Vf0g0fsaqSes\n", + "hC77AP5eBpPPgNM+h3UrOUJC0lYDug32t70W1sLJq+HB1VR3fo9Ja5/Smd7m62E4c0wZLvr06pXX\n", + "0GclrGXfgLACZ6P9BS6tLxA7yZV3/1skJPcDAXbJZ5xasIO3nu3K7jZeqyt7w+f7Fui7IvVnYomu\n", + "UkF4EL33RZd+O0wDueJjKv+6Zrq+eUz/ZCpdIj+7zMYzmYy4CV77A6wa5l1v1zYVd4u3uHpjeGkY\n", + "yGf4zZ2h3/FsOXAiyzmLrfVyFO3dCN4zoYRt1+Hy9CdupkzInVNE8nA/1tOBNcC7wFhV/SSiTQVw\n", + "tapWiMggYJqqDq7zOqrmztkgfviyh3PzhB9vOQCePQYmDmTD5iJaAy/gQuvnlQYZ2VT/fs9T4Sj2\n", + "DQhluKLWxbg6o+8SuUqArxra3JIeJ73JaQcP4ZClMO9WWDYGpz5PXQR9OtWPtoxatMRX4g2Sq4s3\n", + "uE7HvX+jSoOcEmXDverJ0bTZUkqFBnRpSjuSBtzsd9aZ5NWyb6AHOg1dqt/NL/NPsvhpLC5mbx97\n", + "zYUht8Hf5nnPuBQRfqVsGAhUqboaryLyBHAu7kcb5hxcNj1UdaGIdBKRbqr7AnSMhklSweYmU9eL\n", + "osMOeP0jqos+YtLmIO/hEmwFgEeWBXlqGdwMvB2v54EXsfuJd1SGr0tILseZiN4BjgYqcINCKwlJ\n", + "5ECwBFiqAd0CwNri3TxeCT1fg7LHPcUP0P0HWBBwJoD0Rls2leaaFCJm/ncDL3dry9b7tlFSmwcv\n", + "HQ3nf+I23Jf9H98sKKUEyHjFv9dksjtiQM8fv4aR73eWkOQlWpQ9HTS+ivBWNevLYH4w4rq/+fh7\n", + "AKsjHn9Jfa+BaG2KAFP8cRL2mgHYLfF5zSSDOJTQdGB6RIKtB4E2EpLHcQm2mhUmrwF9QEJyEs5D\n", + "51JPqQnQjX0rg5NwJqG+EpL1wBLOLipm1ROwrgxeuod9xpKtNZ6Sb3GKPhrNNSl479NE4O5F4xl3\n", + "x/vwXyfBcV+7PZoDd0FhLTtIchlGvwibTPYb0Hevupt+W6bg0j4/6bOISWCLC9ba2t0de0nMTJmo\n", + "4o/XTlR3KeJ/uHAGEba17xE4YCq0Uvcj3r6HERKSz3H23+3e3+SeB1mwDF4FamPN5Osk2DoWl1tl\n", + "joRkA/AY8LgGdHW0/22AScBC4HLgfu/eX3vH3HAjL2CnN1BGt43nUzi5G10K2lG4GjYeDd9+v5W2\n", + "67+SkFTgVghfNrYiySSf/yjkA4u3HsQvQ6fBM0/C8FX7nqzZzfdk0QZvtAFdQgKuClhlMn35/aHO\n", + "RjCQjKRwiSr+NTh7bJhi3Iy+oTZF3rX9EJFgxMP5qjo/QdmyhvCGXyuFXTfDzjyoyYfzCnhz/rVc\n", + "jvP4KPD+NnbeEejehPbh89ZeyHg8g8Z2XGHsLsBYICgh+QpnulkAbIzjNWpwq4hXJSTvaEA/ivbe\n", + "eMv5T73j6b25yw8obUePNXkM2LiQntvAef+U4VYkS6lvLtoEkVGVkT+0lunzH4m3X3Ip8HuguvNb\n", + "3NC5kKlTTqfjyzOgY63bK1jZi8eBU/2VNuXMwhWqOQv3PcxY6q9qqg6E5VVQM1BEBjb3dRPd3M3H\n", + "be6OwHlnvEPDm7uDgTttc7dpNHfDL5l4SdbCA0Hdv42dtwf64jJ2HgGsxw3+m3AZJ2P9b9iOKcC3\n", + "OK+wRFcxB+AGviJPll64FcMmYBnv9ziKz27ryfoyWN/fC/aCdORbbw7eimcsbq9lDfB7DegbAKWt\n", + "pGLjufJwzcHS+egZHb9fub3oX5t7bvkfxq+aogHt5afcqUZCMgY32J+c+bP+2PiWpE1EytnnzvmA\n", + "qt4qIlcBqOpfvDbTcYUkfgAmqO6fJMoUf+M0NytmS8PLL3MebjY/COcZ9BgwL1p6ZglJa+AB3CBw\n", + "PU0bcJpy3g5ox/s929JmgNBlBfz1PdjjLYp7jNjGla8up/GVTiImtp3xKilP4Y8GgsAGYKoG9LX9\n", + "2kj/Chg8jYqCEg5bBDNehtrrqhn75OH02dpeA7ojnntlIhKSPGpbfc7/HruW5SXbMtBkFxeWndPI\n", + "OCQk3YAxuEGgF86z5zHqeAZJSNriVpN3aEAfSKlMYfe5urQ545/cNO9aUjfwFOCSJsYzUHTFrZ5q\n", + "ccnIVkRt/1z/yXz/n8ezqwBO+At0roYZc+DQkdsY/87xsapbZQMi/SsYUPgQx7Q/hBlzvKtXVsGC\n", + "a7JJ+ZviNzIaCUlvnMniEpz55zHgsbBnkISkL/AGMFwDuiRlckS18afH59+z0zc0OAwDxgG7cYXD\n", + "qxts/9nBI9hzXBfya2BzMdR0gR7vwJwDN3HZ6xdrQGelsj9+IlI+m7znzmRSCTz5NKwd4D3TMk12\n", + "zcUUv5EVeG6bx+FWAWNxZoy/41LtDgOmACdGZt5Mugwxil6n6n4NyuLej7OBEG6v4/fAi/GYhOqv\n", + "XhTKJ0Gvh3Zw8A//rgH9jxSJ7TsiY+ZD5WmUPQbburqEaEAyiqK3JEzxG1mHZ8f+MW4QuADngdMa\n", + "5zl2UVZv2jmFPwoXFNcGt3n7bFP6HH31cnk1Vz+6na47ugJ9MrEaVzzENNnZjN/9nyl+IxPwKlGN\n", + "An4G/ASXc/9PwAvZkXfG4Sn803EKvxC3efu0BnRPs14vyuqF4LLWOIeM9cDIbFT+fprs0okpfiNn\n", + "kJAMwAWVfQiU0ohnUKYgIRmGU/gH40w7lalIOyAhKQWexgXCDcSVcdyU7Pv4TUsy2aUKU/xGTiEh\n", + "GQfchMvjczZuU/hIYngGtSTqRQYPX/QKp26owMUWhHCRzinLMyMhORD4DufCegfOrTYrlX+2Y4rf\n", + "yDkkJA/ibP7jvDw1DXoGtQT2M0EULXCl97ou2MWaVnfTb8vkdK1YJCRfAqcAXwDTMOWfkVixdSMX\n", + "mYhLQzwBQANarQH9I9APtxlcAMyVkHwgIfmthKQo/I8i/StEymeLjJnv/vZvsDh88vCKh4y8Hn56\n", + "kcsgOu27fCqH9E2zmaoKKPFWRdfg8iK9LN17j/bnfTHSic34jYxGQtIP598/LJp/f4Rn0CXA+cAS\n", + "VnT4iOfOOYttj0akLUhPcM9eN8NOq2DLoRF55NPrZugVr3lXA150fUiEdW2eZU+7M3mkug3bO3kt\n", + "sy/oKZuwGb+Rk3hmnOuASglJ+yjP79aAzteAXomrAnYH+QeMZtILvbjoXCh9Elrtwnl/HD4x9RJ7\n", + "aXY39dy/eEj6q4FVE5GeWQOq3Du0DV9c0oZLz4SCsMUnXe+LkU5M8RsZjwb0EeBt4L89d8hY7Wo1\n", + "oM8xY/gK7lgNn1wAfZ6PSMSWjhq8q+9ys+hIEk+z22QWd+zAZ53H7W/SKSxg1jRY/hPI3x7RuOXV\n", + "JjYSw4qtG9nC1bh8PuOBhxpuumU7tYXw4Th37CX1s+6oxUPS7GYo0r+CHqddyjmfdYPKbu5quDax\n", + "wD9vrPMfLa82sZEYNuM3sgIN6A+4bJW3S0j6N9za31m36tKZqjPLVSuHur/ptp8XT2LDjGIOqmZf\n", + "TaT7SmD7nhaxGjFSjs34jaxBA/qxhOS3wFMSkgGx8vm0hFm3v3QooLYQFlwH+bWwq8C7njm1iY3E\n", + "MK8eI+uQkDyMW83+vKUGcflJruSxyQWaqzttxm9kI78G3uXjDn8WKe+XobVzU0hq6rgamYPN+I2s\n", + "RAYc9kuGfzudh97L45tS76r5pIfJhTw2uYClbDCMCETKZ3PchWdyyu3w13dhZzvvGTNnGNmDmXoM\n", + "Yz86FLB4vAtEyq+NUPzmk24YpviNLMWLkH37N3Wum0+6YZgfv5GltJAIWcNogZiN38habAPTyHZs\n", + "c9cwDCPHsOychmEYRlyY4jcMw8gxTPEbhmHkGKb4DcMwcgxT/IZhGDlGsxW/iHQWkbki8qmIzBGR\n", + "TlHaFIvIayKyTESWisikxMQ1DMMwEiWRGf+NwFxVPRp4xXtcl53AtapaCgwGfi0ifRO4Z0YiIkP9\n", + "liGVWP8ym2zuXzb3LRESUfznAI94548A59VtoKpfq+pi73wr8Amu4HWuMdRvAVLMUL8FSDFD/RYg\n", + "xQz1W4AUMtRvAVoiiSj+bqq6zjtfB3RrqLGI9ASOBxYmcE/DMAwjQRpM0iYic4HuUZ76XeQDVVUR\n", + "iRkCLCLtgX8A13gzf8MwDMMnmp2yQUSWA0NV9WsRORR4TVWPidKuNfAiMEtV74zxWv7njTAMw8hA\n", + "0p2P/3ng58Bt3t9n6zYQEQEeAD6OpfSheYIbhmEYzSORGX9noBI4HFgFjFHVTSJyGHCfqp4lIkOA\n", + "N4CPgPCNblLV2QlLbhiGYTSLFpGd0zAMw0gfvkTuZmvwl4iMEpHlIrJSRG6I0eYu7/kPReT4dMuY\n", + "CI31T0Qu8fr1kYi8JSL/5oeczSGez85rN0BEdonI+emUL1Hi/G4OFZEPvN/b/DSLmBBxfDe7ishs\n", + "EVns9W+8D2I2CxF5UETWiciSBto0Ta+oatoP4HZgsnd+A/CnKG26A8d55+2BFUBfP+SNs095QBXQ\n", + "E2gNLK4rL1ABzPTOBwFv+y13kvt3EtDROx+VKf2Lp28R7V7FOStc4LfcSf7sOgHLgCLvcVe/5U5y\n", + "/4LAreG+ARuBfL9lj7N/P8a5wi+J8XyT9YpfuXqyMfhrIFClqqtUdSfwBHBunTZ7+62qC4FOItJg\n", + "/EMLotH+qeoCVd3sPVwIFKVZxuYSz2cHMBHnlvxNOoVLAvH072LgaVX9EkBVN6RZxkSIp39fAYXe\n", + "eSGwUVV3pVHGZqOqbwLfNdCkyXrFL8WfjcFfPYDVEY+/9K411iZTlGM8/YvkciBTyhw22jcR6YFT\n", + "Jvd6lzJpcyyez+4ooLNnXl0kIj9Lm3SJE0//7gNKRWQt8CFwTZpkSwdN1iuJuHM2SA4Gf8WrCOq6\n", + "rmaKAolbThEZBlwGnJI6cZJKPH27E7jR+74K9T/Hlkw8/WsN/AgYAbQFFojI26q6MqWSJYd4+jcF\n", + "WKyqQ0WkNzBXRI5V1S0pli1dNEmvpEzxq+oZsZ7zNiq6677gr/Ux2rUGngYeVdV6cQItjDVAccTj\n", + "YtzI21CbIu9aJhBP//A2dO8DRqlqQ8vTlkQ8fTsBeMLpfLoC5SKyU1WfT4+ICRFP/1YDG1S1BqgR\n", + "kTeAY4FMUPzx9O9k4BYAVa0Wkc+APsCitEiYWpqsV/wy9YSDvyDB4K8WxCLgKBHpKSIHABfi+hnJ\n", + "88A4ABEZDGyKMHm1dBrtn4gcDjwDXKqqVT7I2Fwa7Zuq9lLVI1X1SNwK9FcZovQhvu/mc8AQEckT\n", + "kba4TcKP0yxnc4mnf8uB0wE8+3cf4F9plTJ1NF2v+LRL3RmYB3wKzAE6edcPA17yzocAe3A79B94\n", + "xyi/d9gb6Vc5zvuoCheoBnAVcFVEm+ne8x8CP/Jb5mT2D7gf5y0R/rze8VvmZH52EW0fAs73W+Zk\n", + "9w+4HufZswSY5LfMyewfbpX2gve7WwJc7LfMTejb48BaYAduZXZZonrFArgMwzByDCu9aBiGkWOY\n", + "4jcMw8gxTPEbhmHkGKb4DcMwcgxT/IZhGDmGKX7DMIwcwxS/YRhGjmGK3zAMI8cwxW8YURCRkIhc\n", + "E/H4lkwoBmQY8WCRu4YRBRE5AnhGVU8QkVa49CIDNHMSzxlGTFKWndMwMhlV/VxENorIcbj04u+b\n", + "0jeyBVP8hhGb+4EJuEJBD/osi2EkDTP1GEYMvHoQS3E1XY9S+7EYWYLN+A0jBqq6U0ReBb4zpW9k\n", + "E6b4DSMG3qbuYOCnfstiGMnE3DkNIwoi0g9XdnCeqlb7LY9hJBOz8RuGYeQYNuM3DMPIMUzxG4Zh\n", + "5Bim+A3DMHIMU/yGYRg5hil+wzCMHMMUv2EYRo7x/+aA4Lwnek4NAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['LWLR-BFGS']\n", + "modelBFGS = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelBFGS)\n", + "inv_BFGS = generateInvTest(environment, modelBFGS)" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(, {'default': {'fwd': 'LWLR', 'k': 10, 'inv': 'L-BFGS-B', 'maxfun': 50}})\n", + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEZCAYAAACTsIJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXncHFWZ779PIkLYwYBCZFESdGAENxYFNCNeCdGBGUfk\n", + "ooKiV1AvJLiMqFclOi7jzHxckBlA3GEQATdwIIwKb2QEkYyKyOIkYcsmQlgMOyHP/eOczlvd6equ\n", + "Xqpr6d/38+nP+1ZX9alTp6rOc57zLMfcHSGEEKLBlKIrIIQQolxIMAghhGhCgkEIIUQTEgxCCCGa\n", + "kGAQQgjRhASDEEKIJiQYaoyZrTWz3Ud4vgVmdu6ozldlzOxTZnaPma3K8RzTzOxSM3vAzL6b53nN\n", + "7MNmds4wyxw2ZvY2M7u6oHPvbmbrzWxK3L7MzI4dwXn7eicrIRjM7A4zO7Sgc+9pZhfFl+kBM7vB\n", + "zN7buMFlxt23cvc7RnnKfn84TkLFzHYF3gc83913zvFUbwB2BLZ396OHdV4zm21my5Pfuftn3f2d\n", + "g1V3fHD3ue7e9XmPfd+rBjlVPz8qfecWcQbodPrFzPYArgPuBP7S3bcFjgJeAmw16vpkxcyeVtSp\n", + "Czpv1dgVWOPua3I+z27A/7j7+hGft/aY2dQRncop4r1y99J/gNuBV8X/3wb8F/DPwH3AbcCcuO9o\n", + "4PqW374X+FGf5z0PuLTLMUcANwH3A1cRRmONfXcAHwB+B6wFvgY8E7gceBD4CbBtPHZ3YD3wTmAl\n", + "sAp4f6Ks/YFr43lWAV8GNknsXw+8B1gCLEt899z4/9xYzz8DK1rKfmf83RrgR8BOLeWeCPxPPPcZ\n", + "HdriNOAi4IJ4nv8G9kns3xn4HvCneN9Ojt/PAR4Hnojt9BtgNnBj4rc/AX6V2L4aOKJTuXGfAR8C\n", + "lgL3At8Ftmtp8+MIwv8e4CMp1/b0WK+T4vZU4BfAR1OO3wb4dqzTHcD/i3V5NfAI8FS81q+3+e10\n", + "4MexvdcAPwcs5TzPj22zBrgVOCp+/4mWNj2h3XmBA4Fr4rl+C7wyUfb2wDcIz+N9wPeBzYFHE+X8\n", + "GdgJWACcG393OfB/W+p5A/A3neqccn3HAzfH8ywDTkjsm014lt8H3E14L96W2P8M4BLCu3Yd8A/A\n", + "1SnnaTwLae/fAuBi4NxY3tvjPf5aPHZFLH9KPH4K8C/xmVoG/N9YfmP/BPCOlnewcZ03AS+K53oq\n", + "3re1wAcy3LPnAItiOf9J6CfO7bnv66fDHPWHjQXDE8A7CC/au4CVcd/msUFmJn57PfDGPs+7Gnhr\n", + "h/17Ag8BhxI6ir8ndLBPS9T7GmAHQud1N/BrYF9gU+BnwMdbHsx/B6YBf0noVA6N+19MEA5TCCPB\n", + "m4H5ibqsB64AtgU2TXz33MS1HOSTndaL4v+vig/vCwmd3+nAopZyLwG2BnaJdTospT0WxHvz+tge\n", + "7yd01FNjvf8b+CjwtPgALwNeE397GvDtRFnTCB3Q9sAmse2WA1vEfY8A22Uod368BzvHcs4Czm9p\n", + "87Pj/dgHeIyEcG+5vr0JHeTzCR39NaR32N8GfhDruxvwB+Dtcd8rgeUdnqvPAmfGdpvauG9tjtsi\n", + "tslbYzu8MN7Lv0hp06bzAjMIwrIxsHp13H5G3P4P4DvxeXkacEha/ZPnAo4F/iuxby9CJ7ZJtzq3\n", + "uca5wHPi/68AHmby2Z0NPEl47qYCh8f928T9F8TPtHjvVgA/TzlP41lIe/8WEJ7txmBks3h/z4zH\n", + "70AQPifE/e8CboltvB1h0PgUk4LhqsTzcFSs20vi9h7Arq19X8Z7di1BIG0CHELoD7/d7po79n39\n", + "dJij/rCxYFiS2Ld5vKE7xu1zgY/F/2fFhtmsz/M+QexgUvZ/DLggsW3xBr8iUe9jEvsvBv41sX0S\n", + "8IOWB3PPxP7PAV9NOfcpwPcT2+uB2S3HJAXDnYRR49Ytx3wN+MfE9hbxundNlPHyxP7vAqem1GkB\n", + "cE1Le6wCDgYOAO5sOf7DTI5cF9AysiGMlP+WMEK6gvCSHwb8FXBDPKZbube0vFg7xeubkmjznRP7\n", + "rwOO7nDP30fo5NcAe6QcM5UwWk9qjycAV8X/Z9NZMHwC+GFa+YnjjqaloyMIucZgo6lNW88LnEpL\n", + "pwEsJGhQOxE6sm3anHej+tOsMWxFGDDtErc/TXyOu9U5wzv5A2Beoh6PEDvb+N3dhAHU1Hifk+/T\n", + "p+muMbR9/+L1TST2PZMwiNgs8d0xwJXx/ytp1m7+F80aQ1IwXEFCy22pV6tg6HTPdiUIymmJff9O\n", + "HxpDVWwMrfyx8Y+7PxL/3TL+PZ9wgwDeROh4H2stwMwOiV47a83sxpTzrCGMNNPYCbgrURcnjIZm\n", + "JI65O/H/oy3bjyXq3SBp1Lurcf5oBP+xma02swcJD/kzOvy2lb8jjL7uMLMJMzswcQ13Jq7hYcJ1\n", + "J6/hj4n/H2lT5yQrEmV53N6Z8NDubGb3Nz6EDnzHDmUtIrz8h8T/FxFGq68gqOIQRuOdyt0N+EFi\n", + "383AOsKLnXZ9W3So07fjtVzm7stSjplOGLHdmfjuLprbtBP/TJj6+k8zW2Zmp6YctxtwQMu1v4nm\n", + "a+vEbsBRLb8/CHgWQTu8z90fzFjWBtx9LUHbaLyH/5vQQfVcZzM73Mx+aWZr4rFzaX7u1/ikDQUm\n", + "n88dCFpO6/vUjbbvX2RF4v/dCPd4deI6zornhfBeZT33swlabhY63bOdgfvd/dHE8Xe2K6QbRRkp\n", + "8+SnwA5mti/hgTyl3UHufjXdDcg/JXSo30zZvwp4QWPDzIzwQq3sUGY3Q9KuhBFp4/9GWWcSpkyO\n", + "dveHzeyUWLcknlaouy8G/iYazU4GLozlryKMlhrXsAXhxet0DZ3YJVHWFMJDv5Iw+rzd3fdM+d36\n", + "Nt8tAj5PeLg/CzwAfJUgUM+IxyzvUu5dwPHufm3rjj5def+NMP8/x8wOcvdftDnmXsLIbXeCxgKh\n", + "rVe0OXYj3P0hgm3qA2a2N3ClmV3v7le2HHoXYdrvNWlFdTnVXYTR5AmtO8xsJ2B7M9umjXBoV27r\n", + "d98BTovuoZu5+1UZ65ysw6YE29FbCHbCp8zsB2Qzxt5DGAC0vk/dSHv/oPkalxO0wme0CKYGq1vO\n", + "1+ncy4GZKfta27XTPdsN2M7MNk8MmHcjvHs9UVWNIRV3f5JgAP0XwtzeTwYo7jTg5Wb2T2b2TAAz\n", + "m2lm55rZ1oTO9bVm9ioz24Qwp/4YYe65Xz4a/c/3JkybfTd+vyXBAPWImT0feHfWAs1sEzN7c3zJ\n", + "G0bDxsPyHeB4M9s3voifAX7p7mkjnG4v5UvM7G+jZ9QphPb4JcHWs9bMPhivb6qZ/aWZvTT+7m5g\n", + "9yhcG1wDPA/Yj2B4vpk44iRMM0GY+ulU7lnAZ6KrJma2g5kd0eUa2l5j9Dt/EWF+fB7wrShIm4ht\n", + "fCHwaTPbMr6w7yU4M3TFzF4bnzMjTIU+RfuX+8fAnmb2lniPNzGz/eLzkXodCc4D/trMXhPbbbPo\n", + "ijrD3VcTjMj/ZmbbxrJfEX93N/CM+A5sqHZL2ZcR7tUnCFOAWeuc5Onxcy+w3swOB7oKFNhwD74P\n", + "LIjPxV6E+9ZNWKa9f63lryYYdz9vZluZ2RQz2yPRRhcC88xshpltR3CASOOrhEHAiy0ws/G8Etp6\n", + "j8Sxne7ZncBi4BOxXQ8GXtflettSRcHgbHxzW7fPJxiEL0qR5tlO5H4b8DLCyO8mM3uAYCe4HnjI\n", + "3f+HMJr5MmGE8lrgr919XZf6J/9vrfsiwjTCT4F/dvefxu8/QFC5/wx8hfCytZbV6VxvAW63MA11\n", + "AvDmeI0/I9hKvkfQHp5D0LTSym1X5+S+HxLmke+L53i9uz8VX9TXEYyNtxHa6ysEozYEYQ6wxswW\n", + "x7o9QtCSbkq06TXAHe5+bzxmfZdyv0Qwnv+nmf2ZYJzbv8P1tf0uvqhfAI5z90fc/TuEl/DzKW1x\n", + "MsEQehvBg+rfCR4+nc7bYBZhQLM2Xu+/uvuijSoZNIvXEO7XSsIo9bOEzrRxjtR3xd1XAEcCHyEY\n", + "Wu8iDG4a/cKxBM3nVkIHNS/+7lbCgOI2M7svahfeUvYThI75UML7mLXOyetbG895IeF5OobgNdf2\n", + "etpwEmFA9Ufg6/HTjbT3r11bHhfrfXOs30WEKR2Acwi2gxsIz8n30urq7hcTpobPJ7zf3ycMaiG0\n", + "zUfjtNH7MtyzNxEGTvcBHwe+leGaN8KigSIXzOzrhM7yT+7+gpRjTid4EzxCcDX7TW4VKjFxWuM2\n", + "gkdT38JMCNE7ev+ayVtj+AbBR70tZjaX4Fo6izCKPTPn+gghhOhCroIhGnjv73DIEURVx92vA7Zt\n", + "zOWPKfmpb0KIbuj9ixRtY5hBs0vXCoIXy9jh7ne4+1SpsUKMHr1/zRQtGGBjbwZJbSGEKJCi4xhW\n", + "kvB7Z9LnvQkzk7AQQog+cPeek/AVLRguIbiUXWAhEvcBd7+73YH9XFwdMbMF7r6g6HqUAbXFJGqL\n", + "ScayLcxmEdxxD47fnAfMt5DFoGdyFQxm9h1CCoPpFvK3n0YII8fdz3b3y8xsrpktJfh8H59nfYQQ\n", + "olaE7ALzCIGp0wgxGyfifknc31exuQoGdz8mwzEn5VkHIYSoJSlaAu73DVp0GYzPojcmiq5AiZgo\n", + "ugIlYqLoCpSIiaIrkCtmUwi50m4gCIU/AkfifuwwhALkHPk8LMzMZWMQQow9PWoJ/fad0hiEEKLs\n", + "jEBLSFK0V5IQQohO5GhLSEMagxBClJERawlJpDEIIUTZKEBLSCKNQQghykKBWkISaQxCCFEGCtYS\n", + "kkhjEEKIIimJltBUJcUxCCFEQbTREvaDSxfD24HNCGumn+7ul/VXfH99p6aShBBi1KTkODJYR1in\n", + "fGbi6D3MjH6FQz9oKkkIIUZJ0BIWAV8gCIXzgL1j4rt5NAsF4vbJo6yiBIMQojLEbMwLzWwi/p1b\n", + "dJ0yk82WsFnKr6eNoooNNJUkhKgEUQgUPs3SF9k9jh5LKeHRvKrWDmkMQoiqUIpplp7o3ePodGBp\n", + "y3fLgC/nW9FmpDEIIapCKaZZMtNHXEJcvAyCsJtG0BS+PGqNSIJBCFEVSjHN0pVuq6p1IQqBQqfG\n", + "NJUkhKgKpZhm6Uhnj6PKII1BCFEJyjLN0pYBtYSyochnIYQYhJyjlwermiKfhRBidJQ8enkQZGMQ\n", + "QoheqUD08iBIMAghRFYqFL08CJpKEkKILGSPS9gypYQt8qrasJHGIIQYa7rmX+o9ejnN2FsZBxpp\n", + "DEKIsaVr/qUeopdjWfOAPVJO99Dwap4vEgxCiHGmraF4CpyM2Z5kjEtIETCtlCtCuwMSDEKIcWYj\n", + "Q/FM4EJ4GTAnfpVl7eV2AiZJuSK0uyAbgxBinNmQf8mA+QRDwotgG3pbeznNE+lBYCEwryoxDCCN\n", + "QQgx3pwO7DETZn4dOCR+uQSunAVHZRAIDdIS/F3r7ocPXMsRI41BiJpQ6dXNCsJh4RVw5Y2w/hBg\n", + "DTz+FfjkLPdDexAKUIUEfz2gXElC1IAU4+dSYH6VpjDSSHj8DC/3UB/rJWSoY6kS/PXbd0owCFED\n", + "zGwhcFibXQurOJXRIgi2BHYGdkoc0r/Qq1km1E4oiZ4Q403l0zA0yOj62cg91JtgGLKWUFdkYxCi\n", + "HlRjdbNsdHP9bJBd6PUevTzWSDAIUQ/qZPxM035aySb0arKq2ijJVTCY2Rwzu9XMlpjZqW32T4/e\n", + "E781s9+b2dvyrI8QdSXOtc8n+MwvooK+8wnStJ8k3YWetIS+yc34bGZTgT8ArwZWAtcDx7j7LYlj\n", + "FgCbuvuHzWx6PP6Z7r6upSwZn4WoIe28jeKuVhvDamAVId9Qd48f2RKAchqf9weWuvsdAGZ2AXAk\n", + "cEvimNXAPvH/rYE1rUJBCFFP0hLYETSf+fTj+jlGHkd5kqdgmAEsT2yvAA5oOeYc4EozWwVsBbwx\n", + "x/oIIcpF6kpn0cVWHkc90kYD64s8BUOWOaqPAL9199lmtgfwEzPb193Xth4Yp50aTLj7xHCqKYQo\n", + "iOG42EpLADYIha8QBuUDkadgWAnsktjehaA1JHk58GkAd19mZrcDzwMWtxbm7gvyqaYQg5FLVO54\n", + "MLiLrbSEJPMYglCAfAXDYmCWme1OMBodDRzTcsytBOP0L8zsmQShcFuOdRJiqHRd6EUAqUbm0wk2\n", + "hWTbZXOxLZmWUJLBQVY3367kJhjcfZ2ZnQRcAUwFvubut5jZiXH/2YSb+g0zu4HgOvtBH09JL6pL\n", + "6jw5vc6R15ShG5lLpiWUaHDQt02hFeVKEmIAzGwCeGWbXYvcffZoa1NOOuRxuhe4iawj7JJpCZPV\n", + "KkeeqrRUImVzVxViHKhTKoq8SJvimM6kUO08wi6ZltBCKfJUuftlZgbNGticjj9KQYJBiMHof558\n", + "fMgyxdF++q2kWkILpRkcRMG6oQ3NrK8pIQkGIQYgZZRWeB7+ktFOeLajeYRdbi0hSe0GBxIMQgxI\n", + "6yhNNNNGeO5NmEZqJYywq6ElbKCOgwMZn4UQuZDmwpliJF0GzHNYQjW0hEpQxlxJQogxpZsLZ+sI\n", + "++lwxuOwJ3AxMO0xuP/dcPs3Q2Ds+ZgpaHCESGMQQvRNB60guwtniy1hCVz5ctj9Xnhu4qjarF89\n", + "SqQxCCF6YtBo3U5aAVlcOFNsCXvCe2gWCqCgwZEiwSDEGDKkaN1OUd+dXTg7eRyZvS/lt9NKknqi\n", + "9mhpT1FrzGxuXCVwIv6dW3SdSkKnTj0rnbSCtkuNPh3OwOyUp+BG4OB74Ynj4dcG30kYmNOEyhYE\n", + "YXYYITDuMOBLuqfDRxqDqC0lymFTRoYRrZuqFbQzMB8H3/sWfAg4eCpwLjAfnn4/vJjQwTfuS1pc\n", + "wBTGNC/VqDUlCQZRZ5TgLp1hROt2DOzaEN8xaUs4HZi2Bh4/Hja9tLmsDfclLS4A+GBKPUaaemLU\n", + "FDHAkWAQdaYUOWxKysDRupkCu9rYEvaG59wNB7UpcsN9aRc0aGbzUqpS97xUIx/gSDCIOlOaHDZl\n", + "Y1jRuqlR3x2il+8Orqzt6HZfTiesEb9T4rvVVDj1REZGPsCRYBB1pjY5bPKYY84tlUf3HEeD3JfW\n", + "wKvyB2INzsgHOBIMorbUJYdNZYzoGXMcDXBf5gE7t3y3M/W3GY18gKPIZyFKTlkWgunICDKhjvOi\n", + "SHFw0PMAR5HPQtSX8hrRR5sJdWxtRqPO4KsANyHKTzk7xKAlLAK+QBAK5wF755geu23QHBW0GZUd\n", + "aQxClJ9yGdELWi+hLjajKiAbgxAVoN855hwqUpVV1UrLKKOY++07JRiEEN2p2KpqZSXFwyy3lOL9\n", + "9p2yMQghOjMkW4ISGgLDSV6YO7IxCCHaM0QtoTKxGPlTXg+zBNIYhBAbM3yPo0qMlEdAOT3MWpBg\n", + "EKIASjutYjYFs1OAGwgG5j8CR+J+7IAG5kqMlEdAJVxuNZUkxIgp7bRKvh5HlRgp501VXG7llSTE\n", + "iCldios+bQm9uF2mCMNlwLyydIp1XDZUKTGEqA7lmVbpU0voVesp+0i5tFpcQUgwCBFJjBh3JuT8\n", + "Xw2sYvgjx+KnVQb3OOp58ZhR5/vpEa32l0CCQQhSR4zTgRcw/JHjUFJc9D31MRxbQnm0nuFQt+sZ\n", + "CAkGIQLtRowNhjpyHMa0Sl9TH8ONXi5e6xkudbuegZBgECKQNmJsMNSR4xCmVXqb+hi+x1G5EvsN\n", + "Tt2uZyAkGIQIpI0YG5Rt5Jht6iOnHEdlNyb3St2uZ1AkGIQItBsxNijjyLH71EfOmVCzaj1VcQMt\n", + "uXF8pOQqGMxsDvBFYCrwVXf/XJtjZhPC7jcB7q37En2inLSMGGcw6ZW0knKOHK8FDgE2T3z3CDBj\n", + "qtnCy+HO18CxFJwJVW6g1SS3ADczmwr8AXg14eW6HjjG3W9JHLMt8AvgMHdfYWbT3f3eNmUpwE2I\n", + "SEpn64DNJKgIh0x+X+h6CaUL5hszck27bWabm9nzeix7f2Cpu9/h7k8CFwBHthzzJuB77r4CoJ1Q\n", + "EEJsxEaGZwObT0hwdAhB1Tkefj2EHEeD0tUWUtq8UWNMV8FgZkcAvwGuiNsvMrMsKukMYHlie0X8\n", + "LsksYHszu8rMFpvZsdmqLcRY09TZziSkQf0iYV7pXGBv4JuwduQ125iOtpCE9nMY8Mr490sSDsWS\n", + "RWNYABwA3A/g7r8Bnpvhd1nmqDYBXgzMJTwQH7NgMBNCpPMYgAGtWsIRwHHEl7UcnlTdsokqHXcJ\n", + "yWJ8ftLdH4iGuQbrM/xuJbBLYnsXgtaQZDnB4Pwo8KiZ/RzYF1jSWpiZLUhsTrj7RIY6CFFHTt8L\n", + "nn8W7NawJZwH6+fBlPsnjxnYk2oY3kQZ3EAVcTxEojPP7EHLySIYbjKzNwNPi6P5ecA1GX63GJhl\n", + "ZrsT8s0cDRzTcsyPgDOioXpTgmby+XaFufuCDOcUot6YTXHY8yl41lTgXnji7+H334RLgAMZkg/+\n", + "ML2JuriBKuJ4iMQB80Rj28xO67egjh9gC0JwzOL4+TSwWbffxd8eTvBMWgp8OH53InBi4pgPADcB\n", + "NxJS8LYrx7OcT5/yfAjTgwvjQ7oQmFt0nar8Aea+EH7+a3jAwePnXIftczrfQsJ0cOvn8hyekyUt\n", + "51iq52Vo7ev9/K6ru6qZvdjdf92X1BkScletFimjzaXAfJfves9savba98M3PwrTNyfYEk6B1RfC\n", + "/8mrPc1sgmAMbmWRDznWKD4vijjOgX77ziyCYQJ4FnAR8F13/31fNRwACYZqUQff9dJE65rNugGu\n", + "2xe2g+BxNJ8NxuXc2rMO91DkuFCPu882s52ANwJnm9nWwIXu/g991FOMB5U2KJYiWjeR42hfmLaa\n", + "MAd7afNRebanksqNMZkC3Nx9tbt/CXgXwTvu47nWSlSdqhsUi3WhDE4eiwipYqb9B6zam42EAuTY\n", + "nlEAzifYGhbFv6VZhlPkS1eNwcz2ImgLbwDWAN8F3pdzvUS1qfposxiNJyUT6utgHe3XS861PV1J\n", + "5caWLO6qXyekszjM3VfmXB9RA7z6KYxHr/F0yITqQMXbsxBKYycaAqO+ltyS6A0TGZ/FKEmxMSwj\n", + "j6mUnNZLGHfq5Bk3yLUM3SvJzC5y96PM7MY2u93d9+n1ZP0iwSBGzUhcKHNeL2GcqZNX1SDXkodX\n", + "0vz493WEtCxJyq9mCDEAuc6vS0sYBZX2jGth5NeS6pXk7qviv+/xkDp7wwd4T14VGleUenhMaPE4\n", + "ImgJe0soDJ2qe8YlGfm1ZHFXfU2b79RpDRGlHh4DzKZgdgrB3ftggpZwJMWvl1BXumV1rRIjv5bU\n", + "qSQzezdBM9ijxc6wFWHVNTE8OvnNV8pQJtogW8LIqYFn3AaKuJZOxudtCGH4/wicyqSdYa27r8mr\n", + "Qil1qbXxeZR5acQIkS1BFMzQjc/u/iDwoJl9Cbjf3f8cT7S1mR3g7tf1X13RQp3mQwVISxCVJouN\n", + "4UzgocT2w8BZ+VRnbKnTfOh4I1uCqAFZIp9x9/WJ/5+KC+uIIVGn+dCxJgctoU7Ru6I6ZBEMt5vZ\n", + "PILmYMC7gdtyrdUYorw0FSYnW0IpsryKsSTLVNK7gIMIazivICwfeEKelRKiMuQbl1BsllcxtmRZ\n", + "j+FuwnrNQogGo/E4qlP0rqgQXTUGM3uemf3MzG6K2/uY2Ufzr5oQJWV00csDeaspml70S5appHOA\n", + "jwBPxO0bgWNyq5EQZaWDx5HBgTl0wn17qymaXgxCFuPz5u5+XfSawd3dzJ7Mt1pClIwOHkd5GYmz\n", + "equ181xC0fRiALIIhnvMbMMDZmZvAFbnVyUhSkQ2W0JunXA3b7U0oUT6dJPsE6IrWQTDScBXgOeZ\n", + "2SrgduDNudZKiDKQPS6hSCNxmlC6N+V4RdOLrqTaGMyssR7DTu5+KLAj8Hx3Pyim3hainvQevVxk\n", + "SpM0obQaRdOLPulkfH57/PtlAHd/qJEvSYja0p/H0enAqpbvVjOaTjhNKK0kLLa1kHA9C8ljaVJR\n", + "SzpNJd1sZkuAGW2W9xzp0p5C5M7gcQlFZf89nWBTaF2f+suKphf9kpp2G8DMngVcARxBy4M/yumk\n", + "vhe0Vp6ZsSfTMzBgjqOi1xceyfrUopIMPe22mf3M3Q81syvc/c7Bqjd6lGemHBQpnOO5zwF2Tnz9\n", + "AjN7p7tfNsTo5UKMz23a9p9G3Lap91WDsmrTaSppJzM7CDjCzC4gaAwb1At3/3XelRuQ2vtxl/3l\n", + "K4Fw/iTNQoG4/QnCNOmwMqGO3PhcZNt2O3cJ7rsYFHdv+wGOIhis1gJXtX7SfpfHJ1Sz599MEARZ\n", + "62dilHXPsU3mAktarm0JMLfouiXquDDlHlw+ovPf13puA/8APOzwiIM7rHY4Iod7sbTbvYi/Wxif\n", + "1YW93Lsi27bbuYu+7/o03Svv53edVnC7CLjIzD7u7p9MO67E1H1VtCpoRKVKAjeToCIcApvHrzJr\n", + "CZ20M+9jPY0hjKqLbNtu5y7VfRe9kyXA7VNmdizwHHf/pJntCjzL3X+Vc90GJdVbo5jqDJ0qvHwD\n", + "C+cBp8tuB7YzJg0JmwP3wJM7wBvIaEtI6cRfYWY3Ax9398u8dw+gQQV7kQOfbueu+6Cs/mRQRc4C\n", + "/g24NW5vDyyugjpEUNUvJ6jql1OiaZYhtEnp1XX6nGLp8vum6TI6TMcAc58Pd/88TBm5g18Aj7wU\n", + "3jiktu5r+i7WeaNpLnqY6hykbTu12TDOPeh912d4n777zgwF/yb5N/5/QxUurs6fqrx8gwjnbsKv\n", + "o+CAKQ6nrIPHHPweePxt8N/9tA/p9qqehXFKnQcpq6e27dRmvQiMbuce5L7rM7xPnoLhOmBqQkDs\n", + "kBQSZb64un/K/PL10sl0KCOtQ56I+9sKjhfCIoerG1qCw7kO2w9wLZ00hsyj/Axl5S7YO5x/cZrA\n", + "KPpZ0meg++39/C6LjeHLwA+AHc3sM8AbAC3UUwK8pJGtQ3RX7DZX3WRnadgS/jG4oE5heKuqtbNX\n", + "tatPFtJsQ/cxmpQVaed/LrBdy3dlc2YQI6LrQj3ufh5wKvBZQj6YI939wiyFm9kcM7vVzJaY2akd\n", + "jtvPzNYw4jb1AAAPsElEQVSZ2euzVlyUmmGtVdxtoZoNgmMmISHQF4HNwnM9tFXVYmc9nzAV1SoE\n", + "enVoSBN2vxqBUOh0fk/5vkzODGJEZNEYcPdbgFt6KdjMpgJnAK8mJPS63swuiWW1Hvc5gopbVL4Z\n", + "MVyG4jHl3d1AT58Ce5wMMxseR3+Cp34Inz7B/bQ+655aF6ARvDVI+omiveXSzv8AwbGkFXkSjSGZ\n", + "BEOf7A8s9ZhTKUZPH8nGAuZk4GJgvxzrIkbL0NwVO02XOSz5Ezy+Y9y+DFadBu9dDA+dGPIXDT0i\n", + "fNDpuwzCLlfSzh93t07/1cm9W/RAnoJhBrA8sb0COCB5gJnNIAiLVxEEQ5o6K6pFvqPiRI6jHRM5\n", + "jua6X/LaCqRjKNo21Hr+RKzIo4QFflYTtPzSJeMrexqYutBVMJjZXu5+c8t3s919ostPs3TyXwQ+\n", + "5O5uYRijqaQakOuouHsm1CpEhJeGFEeBByivUCi10K8LWTSGC83sXOCfCC/55wij+wO7/G4lsEti\n", + "exeC1pDkJcAFsROZDhxuZk96G4OhmS1IbE5kEEyiQIY+Ks6eCbUKEeFlokqCtEp1LQQzmw3MHrSc\n", + "LILhAIIwuBbYEjgfeHmG3y0GZpnZ7gRvpqOBY5IHuPtzG/+b2TeAS9sJhXjsggznFHWkt/USlI6h\n", + "N6okSKtU10KIA+aJxraZ9eWE0dVdFVhHeKmmEW7Mbe6+PkMF1wEnERb6uRn4rrvfYmYnmtmJ/VRW\n", + "jBm9r70M3V1cRTNVEqRVqmul6biCG4CZ3QBcQshtPx04G3jc3Y/Kv3ob6uDexypEIn9yMwYOsKqa\n", + "VjTLTsq8/TJKuD50lepaFvpe/TKDYNjP3a9v+e44d/92ryfrFwmGcpLyoi4F5vf9og5vVTWRkSoJ\n", + "0irVtQzkJhjKgARDORn6WscDrr0shGim374zi41BiDSGYwzsz5ZQGGY218wWmtlE/Du36DoJMUzy\n", + "DHAT9WdwY2DFtAT50otxQBqDGIT+PYAqpiUkGFaCQCFKizSGHlA4fjN9RzhXTEtoQb70ovZIMCTo\n", + "1PFrCqE9PUU418PjSL70ovZIMEQydPwKxx+EamsJSYpOmy1E7kgwTNKt49cUQj/UQ0vYQNFps4UY\n", + "BRIMk3Tr+DWF0Cv10RKaKDptthB5I6+kSbp1/JXLwVOYv311PY6EEEhjSNJx7jiPKYQ8vZwKM5bX\n", + "VEsQYpxQSozm84wsD0sueYaayx9uuoruJ6yVLUGIOtBv3ymNIcGI547z9nIanbG8pFqC4k6E6A8J\n", + "huLIu+POxVie7GynwGOXw52vgWMpmZaguBMh+keCoTjy9nIaur99srOdSVARDpncXQotIYHiToTo\n", + "EwmG4sg1UConf/t5BjMbhoTNgdXAR+DX33A/dtA6D5mBNDJNQ4lxRoKhIEYRKDVsm8k+sN0ZTGoJ\n", + "5wLzgfth7TeGdZLh0bdGpmkoMe5IMBRIZQKlosfRdfDSzQhawonApZNHlDHIbxCNTNNQYqyRYBCd\n", + "SXgcbQZcDGtPgK3unzyilEF+A2pkSn8ixhoJhgKoxPx1SlzCUbCOiuQJGkAjU/oTMdZIMIyYSsxf\n", + "d4hLiOGQ5ahnfiiDqhhrFPk8YkYekdwLil7ewCij4IXIC0U+V4dyzl+XNHq5KCrjGCBEDii76ugp\n", + "1/y1MqEKIVqQYBg95UnfHbSERcAXCBrLecDeo5o6KiwtuBCiI5pKGjGlWAGsBLaEShjhhRhTZHwe\n", + "N0piSyi1Eb5gKuHOLCqBjM+iMyXQEloopxG+YKRJiTIgG8M4ULAtIYVyGeHLQ6d0HEKMhMoIBhkq\n", + "+6DcHkflMcKXC2lSonCqNJUk9boXSmJLSKMURvhyIk1KFE5ljM8pu8beULkR5bMliB5IsTEsA+ZJ\n", + "aIpeGVfjs9TrJCXXEkR3pEmJMlB1wSD1GqQl1Ayl4xBFUxnjMzJUtqecHkdCiAqTu2AwszlmdquZ\n", + "LTGzU9vsf7OZ3WBmvzOzX5jZPilFzQcWEjrBhYz7nGu5PY6EEBUmV+OzmU0F/gC8GlgJXA8c4+63\n", + "JI55GXCzuz9oZnOABe5+YEs5inxOMqAtQZG1QowHZTU+7w8sdfc7AMzsAuBIYINgcPdrE8dfBzw7\n", + "5zpVlyHYEhRZK4ToRt5TSTOA5YntFfG7NN6BjG7tGZ4tQZG1QoiO5K0xZJ6nMrO/At4OHJSyf0Fi\n", + "c8LdJwaqWVUYvsdRaSNrNcUlxGCY2Wxg9qDl5C0YVgK7JLZ3IWgNTUSD8znAHHe/v11B7r4gjwqW\n", + "mnziEkoZWaspLiEGJw6YJxrbZnZaP+XkPZW0GJhlZrub2dOBo4Gmka6Z7Qp8H3iLu7e6pI4n+Xoc\n", + "lTVHkaa4hCgJuWoM7r7OzE4CrgCmAl9z91vM7MS4/2zg48B2wJkx4vNJd98/z3oNSq5THjlHL5c4\n", + "sra0U1xCjBuVyZVUFnfVlCmPpcD8gTrXMY9e1sI9QgyffvvOKkU+l4XhT3koehnKO8UlxNhR9VxJ\n", + "RTC8KY8SaQlFewSVeIpLiLFDgqF3huPVU6JMqGXxCFLyOCHKgaaSemewKY9y5jiSR5AQYgPSGHpk\n", + "oCmPEmkJLcgjSAixgVoLhrzmzXue8iiRLSGFUga9CSGKobaCoSzz5iXWEpKcDuzBxstJyiNIiDGk\n", + "tnEMhfvFl19LaCIKUnkECVEjypp2O3c6TBcVN29eDS2hCXkECSEaVFowdJouooh584ppCUII0Y6q\n", + "u6t2crMcbSStopeFEDWh0hoDHaaLRhZJKy1BCFEzqi4YOk4X5T5vXkFbghBCdKPqU0ntposeAWaY\n", + "2cJogxg+5YxeFkKIoVBpjaFlumgGwRd/c+AF8TP8uAVpCUKImlObOIbc4xZkSxBCVIyxjWNIkF/c\n", + "grQEIcQYUTkbg5nNjfaDiRY7wvDjFmRLEEKMIZXSGLoEtA0334+0BCHEmFIpwUCHgDZ3P3wocQuy\n", + "JQghxpyqCYaOdoSB4xakJQghROVsDPnkP5ItQQghNlA1wTD8/EfKcSSEEE1UaippqPmPZEuoDXmt\n", + "1CfEuFKbALceC6ycLUGdX3tSPNWWAvPVPmLcUYBbFiqqJQy6TGnNhUqn1Ot1uUYhRsr4CIYKagkJ\n", + "+u78SrP2dX4Ut1KfEDWlasbn3qmHx9EgnV8noVIHRr9SnxA1p96CoT4eR4N0fnUfUY92pT4hxoB6\n", + "TiVV1JbQgUHSfdR6RD2ylfqEGCPq55VUbVtCKtFW0HPnl2JjWAbMU+cpRL3p1yupPoKhflrC0OhX\n", + "qAghqs14C4aaaglCCDEI/QqGahuf6+FxJIQQpaK6xmdpCUIIkQu5agxmNsfMbjWzJWZ2asoxp8f9\n", + "N5jZizIU2pOW0GHFNyGEEG3ITTCY2VTgDGAOsBdwjJn9Rcsxc4GZ7j4LOAE4s0uhPcUlJDxyDgNe\n", + "Gf9+qcrCwcxmF12HsqC2mERtMYnaYnDy1Bj2B5a6+x3u/iRwAXBkyzFHAN8CcPfrgG3N7JltS+vP\n", + "llDHqN/ZRVegRMwuugIlYnbRFSgRs4uuQNXJUzDMAJYntlfE77od8+yU8vqJXq571K8QQgydPI3P\n", + "Wf1gW12p0n7XT1xCraN+hRAiD3KLYzCzA4EF7j4nbn8YWO/un0sccxYw4e4XxO1bgVe6+90tZZU/\n", + "2EIIIUpI2dZjWAzMMrPdgVXA0cAxLcdcApwEXBAFyQOtQgH6uzAhhBD9kZtgcPd1ZnYScAUwFfia\n", + "u99iZifG/WfHBGhzzWwp8DBwfF71EUIIkY1KpMQQQggxOkqVEiOXgLiK0q0tzOzNsQ1+Z2a/MLN9\n", + "iqjnKMjyXMTj9jOzdWb2+lHWb1RkfD9mm9lvzOz3ZjYx4iqOjAzvx/QY0Prb2BZvK6CaI8HMvm5m\n", + "d5vZjR2O6a3fdPdSfAjTTUuB3YFNgN8Cf9FyzFzgsvj/AcAvi653gW3xMmCb+P+ccW6LxHFXAj8G\n", + "/q7oehf0TGwL3AQ8O25PL7reBbbFAuCzjXYA1gBPK7ruObXHIcCLgBtT9vfcb5ZJYxhuQFy16doW\n", + "7n6tuz8YN68jPf6j6mR5LiAELV4M3DPKyo2QLO3wJuB77r4CwN3vHXEdR0WWtlgNbB3/3xpY4+7r\n", + "RljHkeHuVwP3dzik536zTIJh2AFxVSZLWyR5B1DX9RW6toWZzSB0DI2UKnU0nGV5JmYB25vZVWa2\n", + "2MyOHVntRkuWtjgH2NvMVhEyJswfUd3KSM/9Zpmyqw47IK7KZL4mM/sr4O3AQflVp1CytMUXgQ+5\n", + "u1tY57OO7s1Z2mET4MXAocDmwLVm9kt3X5JrzUZPlrb4CPBbd59tZnsAPzGzfd19bc51Kys99Ztl\n", + "EgwrgV0S27sQJFunY54dv6sbWdqCaHA+B5jj7p1UySqTpS1eQoiFgTCffLiZPen1Wr0vSzssB+51\n", + "90eBR83s58C+QN0EQ5a2eDnwaQB3X2ZmtwPPI8RXjRs995tlmkraEBBnZk8nBMS1vtiXAMfBhsjq\n", + "tgFxNaBrW5jZrsD3gbe4+9IC6jgquraFuz/X3Z/j7s8h2BneXTOhANnejx8BB5vZVDPbnGBovHnE\n", + "9RwFWdriVuDVAHE+/XnAbSOtZXnoud8sjcbgCojbQJa2AD4ObAecGUfKT7r7/kXVOS8ytkXtyfh+\n", + "3GpmC4HfAeuBc9y9doIh4zPxGeAbZnYDYQD8Qa/pIl5m9h3CsgLTzWw5cBphWrHvflMBbkIIIZoo\n", + "01SSEEKIEiDBIIQQogkJBiGEEE1IMAghhGhCgkEIIUQTEgxCCCGakGAQogDMbIGZvb/oegjRDgkG\n", + "IYpBAUSitEgwCMGGRX5uMLNNzWyLuLjLXm2O+1hcIOZqMzu/Meo3sxea2S9jGd83s23j9+80s1/F\n", + "BWMuNrNpo742IXpFgkEIwN2vJ+SU+RTwOeDc1nQSZrYf8HpgH+Bw4KVMjvy/Dfy9u+8L3EhISwBh\n", + "fYT93f2FwC2EFOlClJrS5EoSogR8kpCg7VHCwj+tHAT80N2fAJ4ws0sBzGxrwmp6V8fjvgVcFP9/\n", + "gZl9CtgG2BJYmGP9hRgKEgxCTDId2IKQmG0a8EjLfqc5r33aug/J778JHOHuN5rZW4HZQ6mpEDmi\n", + "qSQhJjkb+ChwPmE6qZVfAH8d7RBbAq8FcPc/A/eb2cHxuGOBifj/lsAfzWwT4C1MTj3VcTEhUROk\n", + "MQgBmNlxwOPufoGZTQGuMbPZ7j7ROMbdF5vZJYS01ncTbAmNdbffCpwV10FYxmRq448R1uS+J/7d\n", + "slEc8kwSJUVpt4XoATPbwt0fjgJgEfBOd/9t0fUSYphIYxCiN74S3Vg3A74poSDqiDQGIYQQTcj4\n", + "LIQQogkJBiGEEE1IMAghhGhCgkEIIUQTEgxCCCGakGAQQgjRxP8H5NM2ovskyZwAAAAASUVORK5C\n", + "YII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4lFX2xz8nCaSQAKGHXkIPKIqABVBEEOwFUVdd+66r\n", + "4trbrpNXf+oW196xrm0FxQ4IqIAgRVCR3msIoQRIQkJIub8/zp3MZDKTTJIJCTDf53mfmbfde992\n", + "zrmnijGGMMIII4wwjh1E1PYAwggjjDDCOLwIE/4wwggjjGMMYcIfRhhhhHGMIUz4wwgjjDCOMYQJ\n", + "fxhhhBHGMYYw4Q8jjDDCOMYQJvzVgIgUi0jnGmx/sIisqqn2axoisklEzqztcdQGRCRWRL4SkX0i\n", + "8rHd9n8isktEtoe4rwdFZHwo2ww1RORaEfmxlvruaL/VCLs+WUSuPgz9porIezXdT1VwzBB+S4Ry\n", + "RSTbLlki0qoWx5MqIgV2HFkislpEXvAekzHmR2NMjyDbqosvmLFLpWGf17AQj+dw4lKgBdDEGDNW\n", + "RNoDdwE9jDGtq9qoiJwuIlu9txljnjTG3FS94R47MMaMNsZU+L2E4B2ss0FSxwzhRx/CucaYBLs0\n", + "NMbsqOXxfGSMaQgkAhcBrYDFtcmQ6hAMILU9iGqgA7DGGFNs19sDe4wxe2pxTEcFRCTyMHV1pL+D\n", + "AXEsEX6/EJF3ReQu+7+NnRL+xa53EZE9XsfeKyLbRWSbiFxf3a7tgjGmyBizAhgL7ALutv2Vku5E\n", + "5H7bd5aIrBKRYSJyNvAgMNbOZH61x14nIivssetF5Gavdk637dwlIhn2mq712h8rIv+xEs8+EflR\n", + "RGLsvkEi8pOI7BWR30RkaAXXOUBElotIpoi8JSLRXv2ca9vYKyJzRaSP3f4eSii/std0r4i8U4nn\n", + "5Lddu6+1iHwqIjtFZIOI3O61L1VEJth3IktElonIiQEfoEgPEZkuInvs8xhjtzvA372eyc3ANKC1\n", + "XX+ronspIk1E5G0RSbP3bpKIxAFTvNrJEpEk7xmfiEwRkVt9xrlERC4sb8wBrq8671BTEflSRPaL\n", + "yAKgSzn9uFUxN9nr3S4id/s8l09E5D0R2Q/8UUQaicib4vkeHxOPKidCRJ4SVautB87x6W+miNzg\n", + "tX6T13UuF5F+ft7Be4J4Zp1EZJZtZxrQLNA11zqMMcfEAmwEzvSz/TrgS/v/SmAd8D+7fj3wmf1/\n", + "NrAD6AXEAR8CxUDnKo4nFXjPz3YHmG//nw5stf+7A1uAVna9vbtvwAX816ed0UAn+38IcADo59Vu\n", + "gR1DJDDK7m9k978EfA8kocLBIKA+0AbYDZxtjxtu15sFuMZNwO/2vERgDvCY3dcPyABOQhngNfYZ\n", + "1fN6XsOq8JwCtmuvZTHwNyAK6ASsB0Z4PZM8+6wFeAKYF+DaGgBbgT/ado9HmXZPf88EGOp+lnY9\n", + "0L1sate/AT4CGtmxDvbXjm9fwNXAHK99vYC99vrLHbOfa6zOO/Q/u8QCvYFtwOwA/XREv6UP7PEp\n", + "wE7s92r7OAScb9djgM+AV+zxzYEFwM12/5+BlXjeux+AIiDC7v8BuN7+H2PHdqJd7wK0D/AOVvTM\n", + "5gFP2Xs9GMjC57usK0utD+CwXagSoWz7EewFJnk96Ez0Q38FuBkPsX0X+Kv9/xbwhFd7XakZwv9n\n", + "VEXg/rjcY0lGCdqZWOJYUVs+x3wGjPNqN9f9IdhtGcAAlCDkAn38tHG/74sMTAWuCdDnRvfHaNdH\n", + "Aevs/1eAR32OX4WHwPl+dME+p0DtDgEGApt99j0IvOV1H6d57esF5Aa4trH4EDLgNeARf8/E+1lW\n", + "dC9RhluEJaI+x5Rqx7cvIAHIAdrZ9ceBN4IZcxDvbLDvUCRKqLt57Xsc+DFAux3Rb8n7+H96jTsV\n", + "mOm1ryVwEIjx2nYF8L39/73Pe3eWbd8f4f8WuL2c99f7HSzvmbVHGWGs174PqOC7rK3lWFL1GOAC\n", + "Y0yiXS4GMMasRyWV41Eu/TWwXUS6ocRilj0/CZWW3NgSqCNRbxy3EXlpJcfZBiijBzbGrAP+in4E\n", + "GSLykYgklTOGUSIy307p96LSW1OvQ/YYj/4Z9COOR6enMagk7IsOwBg7zd1r2z0VtU0Egu89cxs2\n", + "OwB3+7TV1mt/KVTiOQVqN8nua+2z70HUCOtGhs89iXGrEPzci4E+bV2JEqVgUN69bAdkGmP2B9lW\n", + "CYwx2ehs4Qq76XKUAFV6zNV4h5qjs5SgvhcvBHpXQKVyNzqgUnW613W8avuFSnyr6Lvh7133h/Ke\n", + "WWtgrzEmz+v4zUG2e9gRVdsDqCOYhU756hljtovILOBadJr4mz0mHeXqbrQnAIwxP6KSV3kwvhss\n", + "gTkP1Qf7a/cj4CMRSUAltX+i0kaptkT16J8CVwFfGGOKROQzgjNU7UalqWRUTeONLagEc3OZswLD\n", + "956lebX1uDHmiQDnlbk/BPecArYrIoOAjcaYbpXoMxC2ALOMMSOq2FbAe2kZehMRaeSH+Ptr13fb\n", + "R4BL1H0yxhjzQ5Bj9h5Ddd6hXUAh+rxX220Bvxcv+B6f5rXP+xq3AvmoisWb8bgR9Ldq20oOsM/3\n", + "vpb3zDoAiSISZ4zJtZs7oDO3OodjSeIvD7OA24DZdn2mXf/R2DkbMAG4VkR6ihrZXNXss+QDEpEo\n", + "EemJfrAtgKfLHCzSTdSYG42+9AfxvFQ7gI4i4m6zvl12A8UiMgqo8GMHsB/SW8DToobDSBE5WUTq\n", + "A+8D54nICLs9xhr52pRzjbeKGmObAA8DH9t944E/i8gAUTQQkXNEJN7uz6CsQTCY51ReuwuBbBG5\n", + "T9SAHSkiKSLS32u8weJroJuIXCUi9exykoi43W8raivgvTTGpKNG3JdFpLFte4jXfWkqIg292vLt\n", + "azJKdBxUzx7smL1RnXeoCJgEpNr73Au1K1TEDP9mj++NMvSP/R1k78809B1NEDXmdvG6RxOAcfa9\n", + "SwQeKKfPN4B7ROQE+74ki7reQtl3sLxnthlYBDj2vp4GnFvB9dYawoRfMRudoroJylzUaORexxgz\n", + "FXgW1R+uAb6jen66Buv1AewDvkAlpRNNaTdTdx/RwJP2mHRUJfOg3TfR/u4RkUV2uj8O/QAy0Wn/\n", + "F376D4R7gKXAz6ja6UlUP7oNuAB4CDW+bUE9kAK9RwZVM0xDp9Nrgf8DMMYsBm4CXrRjXIvOXtx4\n", + "EiUEe8V68xDccwrYrmVq56Lqog3ovXwdcBNR4+e++L1PxpgclBBejkqm6XbM9YNpK4h7eTWqM16F\n", + "EqBx9rxVqICwQdTbJ8m3L2PMIZTwnok6IQQ7Zu/rq+47dBv6rHaggsRb5RzrxizUaD8D+LcxZoZX\n", + "P759XWPHvcKObyIeleN4VHe/BCXGnwYaqzHmE9T+8CFqjJ2EziDB5x0M4pldidqRMoFHUNtTnYR4\n", + "BKUqnKxuaecAO40xfQIc8zxq1MsFrjXG/FrlDsMII4yjDiLSEWXEUQFUN2GEGNWV+N9GXd/8QkRG\n", + "A8nGmK6oF8Yr1ewvjDDCCCOMaqJahN8aMfeWc8j52OmOMWYB0FhEgvV6CCOMMI4dVEdtGkYlUdM6\n", + "/jaUdqvahrpPhRFGGGEAYIzZZIyJDKt5Dh8Oh3HX1+MgzNnDCCOMMGoRNe3Hn4YGo7jRltK+uQCI\n", + "SJgZhBFGGGFUAcaYyieSq27oLxpuvTTAvtHAZPt/EDYHjZ/jTG2HMNfkAqTW9hjC1xe+vupcX28Y\n", + "fSOsNWDcy42wtjeMDnTO8PpM+6Qn5opLMLM6eM4bBVNqor9j9NmZqpxXLYlfRD5Ck0Y1E80i6UJD\n", + "qTHGvGaMmSwio0VkHRpuf111+gsjjOoiRWR0OxiXADHZcHArPL/MmMm1Pa66jnYwbjwkvzgADkXC\n", + "XfNgPCSPhtvRgDEAxJEE1MX70sh7GGa2wSUroNcuT1vxGntRYX+vQ/JlY+C9SRBd5L+/MKqGahF+\n", + "Y8wVQRxzW3X6OFoRJkCHHykio0+G516HZPfc+CbokiJC+N6XjwTN38SJ2+HaC+HOeWq8i4dYcSQR\n", + "TTVyCXAGmoX108EvkDgjmzKFTHI0A2qF/Qmworku/WxIYzBMI4yKEc7Vc3gw03vFTYDGe+UIOcIJ\n", + "0MzaHkBFEEfiU/rxf7QluVMX+P0VaJgftBQ58zANs7Yws6IDsjVFCIO2QVQxfN0VMhJgej96o8nI\n", + "fgA+Af5oXGYfQEqqpN8E7b3f8xth/RZ4Idj+jtsBS1p5CH8wTKOy13YsIkz4DwOMMTO9193T5r0x\n", + "cOllMHEijM87cqexvtdXVyCOdELVDucCp24/kcJey+Den5Tou1GRFFlXry9UCOb6tsLzVybQbXB3\n", + "Oh2KhEsuh1brOGAyeYN2PGFcJtv3nGXGTE4RYTTcHg+xOZC3BV4IRrjZCs/fBF2OyyB5iY38CZZp\n", + "VPbajkWECX8twD1tTjyoksyYMTD1fYgvPrqnsSIpo6HdOEiIgeyDsPV5Y5aFjNGJI1HAKXiIfTOU\n", + "kb4BjB3wBh/fCSN9z6uCFAkcG+o6caQdcDGpXLK8iBbTN5De+mf2F51Bcv3vuHZfhvmkvPPt/aj0\n", + "PXEzjZ+zcLb0Ink1zA+WaYRRMaqVqydkgxAxpiouSUcoRolMnWIJUJHA+VdA+/2w6RumTjFmVG2P\n", + "ryagRP/k52C8Vwrcm9bBvDuqQ/zFkaZo2pBz0Hu6Gc1C+TWwyLg8QUG+KrbZwNOQGwHr82B7ZQh3\n", + "AHXdunlwx5FOnOxM6RK0YHxX4CtUjTPDuMxBe8xEu/5aDY8lCU0Y2Ny46gCxqmOoKu0MS/y1APc0\n", + "djwkRxr46FNodzOHiv/AxtoeW82h3TgYn0zjTdDrE8hqA9lXJ5O36j5x5Hs3QakI4oigpfzORYl9\n", + "X1SP+zVwr3GZMnEibnirHgqhTVvo8rmW0ewD9AnGzmL7TxzQgYfPjSH5+cZwoB48OOfI9joRR7qh\n", + "hP4SNPbmc9RL7wfjMof8nPIm8BhaF6ImsQOtntUaPzFAcGzMvEKNMOGvBZTRfeaT1/AHJm67lCfE\n", + "kc+My0yv7TGGHgkxAEQUQMJ2aP0zNEyDxMUDgf3iSDb6YftbdgGd0Upb56DR31+j6XRnBss0QO+9\n", + "ODLllFeZdWZz4sa1hVt+hp67lXCPgnHiyHK0eEeHAL+FK84n6o3d0GE/JGd62j9SvE68GKhbsm+K\n", + "piS+B/jRuExhBU1MB14XR44zLrOkpsZpXMaII0uA4/BD+I9CR4nDgrCqpw5BHBmK5hUfbFxmdUXH\n", + "H0kQGTUVppTRr8O5mUjhz7Rb/Q7Xb1qN5ndqA/RAC6Z3Q4mSW2WzgwOR+0lv3ISshCIOROTQcM/n\n", + "HLf/a5QwbPeVUK06aACaK/0UYEB0DnHnbabewDS4Yim0sabJMzpgZl7HdlRltMXP7xbjMvu91XXe\n", + "GA1TJ9dRdZ0l9v1QYn8JOtv5FFXjzPNWiwXZngMkGpcZF+JxRqMV7NzLg6gdZorP9oRWy7hieBHt\n", + "sqPhtoUwfIO2UZefQyhRVdoZJvx1DOLIjcB9wCDjMpkVHX+kwL+O/yFUPT8E5MZ1DP7qZYbtbIKq\n", + "cdqjhay/Br41LpMpjsQxqc0VHOjjEHd1GxLSoOE2aPJZDm23byOuqAFajCMPLf0XhRrSo9CiJu53\n", + "bNug8TSal1aqfiwAo+DbKcYETDXuhj9J80ZYPx/G1SVJ0xL7AXjUOAYl9J8CP1dHby6OdEQLnbRH\n", + "AzcTfJaGfrYFswiQ7bVEo0VdfvLZnt37B66/dx/JCYfgpDRol6VjuwxmTTDm9Kpe25GCMOE/iiCO\n", + "PIPqnUcZlymozbGEUn+qxL/97RA7EHolEnUKdDsA3b6GrpPhUE4OiXkvocR+vj91Q8nMocVStRW0\n", + "WAbNVkHjVYXUL45EiUYeWgVpJ6omykKJRwJa2rJN/Gpizp1MxEf7NdIc4JoYdk8/ntd3nI179pBe\n", + "3v1PERndvgquijUNcSQSndm4JfscPMTerZaJo2pE2XdphiZ7zMGHKFdjyfdmSOLIccBHxmV6+V7r\n", + "kTjzCiXChP8ognVL/ArYYFzm1sPZtzeh3wHxydD6LUhy76+s54o/F07odR9MGMrA5yF5Kqw5B9ae\n", + "A/vum2XMhNMDtuVIMz4Z+D3NRvahyzRotQQKYmFnb9i9bQv9N96AqiwOVDguR+I7/Jcru2RwY2wE\n", + "CVn1iVg+gNWZAykkN7IXJqIjMYX1ORRZAMVbiC1eQWAbRFZNe5z4UX/4Lo1QYeF4oDtalzkDLesZ\n", + "6XNsPHAID6HNoupE+izgGuMyw2vw2usD+4EmxmVKud4eKTOvmkKY8B9lEEcaAfOAF43LvHw4+vT9\n", + "iP6GFsg9UA8eGA5nbYDTN8Hl+cFJU4FdOFfvh9knlj1j9FRjJo+CEkLXD49ufiDQnLSGBWy4tSnb\n", + "BhKXlk2vnPdoQD75/LY7m/1/rO7HXmrMUgTxGdD4T1vpN+cdTtiXgdof2uKxRbRBZxm+zGA7OuvY\n", + "hxLIQ6iUHSr1RzYqZceis5h2tq8lwAK0lGFAgh2E8Ta4+6XPaRswwLhMjXmliSO/A9cZl1nsu6+u\n", + "zrwOB8KE/yiEONIFLSj+B+My39V0f+5p80/t4OPeUDwTXjgI+6Phtf4wvTPMbwtRmezfl8TTaBH1\n", + "RYGIiKplJo+kyXqVzLPb2D0jFkOHRh6GYKD5pVsYOmMCKVkxKJHvDawGFqKEbAGwitTeZ8PJz8Vz\n", + "YfJo7uBj1pf0Fwo/+hJVUqPN0HgTRGdD/WxIdC3nzLVv458oNwaaoEQ9HiXwUUCRXhyCSt0FaO3p\n", + "bFSCzQR2oy6L29GiRbsoR/0hjsSgUvalqC1kNarGmWRcZlOw1xlSFZ4jz6LM5O9VOT/IPt5DXUuD\n", + "Kdp+zCDsx38UwrjMenHkcuBjceQ04zJra7I/d0RxmyxIyoEfmgDboVE+3DdXl9x6cEp31uy7lIbA\n", + "60A7ceR7lAlMR4nUScBArm96Es2aQUEcTP8XLLM5/eKj8xny6XvItKtpeaApLffFE1EcQz3TASXw\n", + "HwO/GJfJLTNIF5NFUkhh4rsfs7/ZtobQMgfqFXv86FNEqDpRs26nvT6FHp9BfkM4lACS2wSV7rOB\n", + "dGAN5atAcr29ZMSRekCr5t9zaYsDXGMSiN/fkHY7O1JU0IQmKDFvgzKLNFSK9nZnbSWO9EPTm/+K\n", + "6usf8he3UBFR957ZFQtEmGq7QL4JTBZHUo3LFFXh/GDgdukMIwQIS/xHAMSRm4G7UE+ffTXVj6+h\n", + "bDbqP/ek1zFjG1M8bQjz9p3Ae/aQZGAscCqqbhCUMM5nSo+urP6mL/E7oc0CaLtAf+M3F1K/aBYe\n", + "SX6hcZkdlRnrZSIzJ8DQv54Nn/eAe36C63+FqwpY2hRifYha0DMBkRGLYdoJZfeMWGzMtP6+Wysj\n", + "OQfIDloyNuuB0whlAF1Rl6fB6D3OQo3WsfaYDMqql7Y1nUPb05dwy3/30SGuoHQfy1OZAnTuNo3P\n", + "T25ByqwO8MAc+JNVnlTHICqOLABSjctMqcr5QbQ/AmV0p9dE+0cqwqqeoxClDKMXz+lIp117SCgc\n", + "GCr9rC/8GcougvQDsL0R5OyLJnJe+8SsA7ndBxER05D6OVEMWHWI7jlr0eyM7wEtgSuAUzG0xRDB\n", + "gVawbRCsORe2f72F3av/YgpXfFOdsXozqQVt4J+nwdx2kLCY3IXzidsRD1ddDJ9MgM57gydqIkMW\n", + "weATNTbMjYeAOYuMmX1SRferPCYzSmTqp/UYOeQ6zTHfc7dud4/NK73xpWidizmoZP+FcZk9JWNU\n", + "Y2cSpe0MbYA2Cemc3SKaxLQE6LpHEwDO6ggP9yB9d1eKgYhWa4l8ZDUt4tfAqiz1wywEFsLSacb0\n", + "rege+b1vKpyMNC5zSVXOD6L9lsBKoGk4dYMHYcJ/lKGMYTSiEK5un0tc5gzz8sELaqpft6GMxjTa\n", + "2onodf1Zd7ANzYD+rEg4wOTzEsj5IB6AuN3Qcewuhs7dRsv8dqhr3yFgHcoIvmBh4slExV1L+/3N\n", + "aZgXQ54solHh+6hqaF1VP2J/RPfilmz5aTAJh7qQeO2vmgTvxQHw/iQYvyE4v26Ry2bCbUNJfBVi\n", + "90JMJhyfBq2ys2mR9S0ayLUJ2HzmkzwwI59Tfm8JjQ9qviUIzGTcs5T3+sKDw+GHd3SMw45nzdIR\n", + "bEBnTd+hxP7rys7uxJGIYeNZcHFr+s/qCLM6aAGToZtgSQZrlo7gXGDd2alMeRBGfktp9nY95C6E\n", + "MVVR94gjDdEAt27GZXZW9vwg+9gBnGRcZmtNtF8XUFnbS1jHf9TB5rbpPQGyk2DrKfDxijj+nHSm\n", + "OPKnUCbHEkfigf7AAFIZuBxSUAPlQlTKWggsZMKp78MHI+n3Fgx+HOL2QNpJzdnWIouWW29A9bBd\n", + "UH31COBqBuydDXufRQl9JvUZbvc/BBSII9Psvu8rE7DmN+VvBi/0+4Rx4xsy8plB8MzJcPJWuPIS\n", + "SPiVVuKIVMxosg/CENg7BPYCUgw7M6DV+cu4atEnaKnRXsAo04zjSYMP+6hK6Qm3+b0xXcWRi1Em\n", + "sRnYY1zGuHPMn7UBvt0Iff4C9YugfhoNgbeBMcZlcoK9B9Zfvy86OxgKDJ47lrgO6+GcNfCv6dDR\n", + "so7RsGHpCDYBLZacyGcP7mbovbHEvBmrKarHrIC3IK6quYaMy2SJI58B1wBPVfb8IOHW8x+VhP9w\n", + "pp8IS/x1FCp5Wl/3fm9BfDqsvgB2z1/NyKWJwOXGZX6odLsaI9Ab9Zxxu0p2Bn7H6tvt7wZfIlky\n", + "pibrNOfOnu5gIoDL/PrfiyPNgDPxMAJBDcDTgRlAc7v9LFSXvdLum4YGcPlLDlYuvD+ezFh46ST4\n", + "v5MpPlSfPCKZA1zs12hcco3+XFBvXA/zx/lmEXWrm35J0tTazz0fzwv0YF5UQn52i4P7OWV5DilZ\n", + "TVBtSlrEQWLqF9KmuD6RceuaELk+iczM+qZBVtqz2bsz7qro2uyzOwEl8megM4RMYAXqvpkRu4Ue\n", + "7Xdx7on1aLQnDvbEwsp4Cg/Ec4hIolF2tqdROu0GZxHXNA/6pcMdC7SP6kS8iiOnAeOBXjWhjhFH\n", + "/g3sMy7zeIUH11GIIxFoCpIkNMo8yb00Xc9lvaJolR6vwsHLVhlanpoyLPEfdcjWxGMLxumSuB56\n", + "fgbHf9QSfW6TxZF7gHcCBSxZY2F7ShP5fqjE5CbyrwK/B0dk7Zgyk3225/jNZ29cZjfqofOxHUs3\n", + "lMhfDryCEqvpwDOoXeAE0mJuoX7k7TQ62ECub5JJwaFJJB94FlgdDDEpNRPIIzZnNnkdlvL62jvo\n", + "BDwKZIgjtwAfkNp7lL/6ACIpwOjbIT5Wr23LC/5SR7uzrL6eTnLuxnhuiRzNtqKPoZBottOCH8bk\n", + "0mDyJDrl9gW6Fsfwc8FvcRlmxuh++3Im6rcXUSA5SZfeKdc0uJouuZvw+P3no66gzdHMlEmoUbcY\n", + "jZQtQF1B96FRyS2AyLz2bNxWwMeylkGNchDyyGncgDcPXMwkYL/b02iUyNSvQlyb4GwYd6gNHchk\n", + "XkqqPFoDvvRLUBtInYO1u7TEQ8hLEXWvbS3xeIbtsL/pwKb2q9j76C5aJWVDa6+yNjWR+C8s8ddR\n", + "lCd5krr8N3Q6fT5KCL5HMyvOQomrm9APsCeWeM+g+Vn2h3pMlc2pb90bB6KM4CygD9lRa/i5b3tW\n", + "v9WM7NbQ6Qfo/lAWPTfkU8/kozOBacB3lqlUbvza51vA5eRF7OTb0yJY8n0rTKQ9ouL6AL6RyEks\n", + "mHc8ewf90GTA6QczF8RQ7wAMek7TSSSkwRbZSq+MG9AsogUlcQInvg5n3Qv1D8DBxlCQY2iUvw71\n", + "92+AxgfEos9XUK+eTaj9ZA2wHo8qaatxmfyyow2MUEa8VuStVJm2yoM40geYaFymR6jaDKLPBMoS\n", + "cX9EvRGwMyKP3Ia7aNQgm8KIXHL3NmJqTjdm4CHyOwI9q6qknwgbd49CeHLblJU8rYTxHqrz3G1/\n", + "41EJ8GdgAkokt4Zy2l3emKrVriON+bL39yQN6Ufn6VAYA68stXtHTSV16l/xqIWGAmvxqIV+qgzh\n", + "E0eG813yFLq2jCJ+B3w5HjadYfd6oofLnFdOMRmikx3yP+9PRAEMfwDWnAebB4O5opQarERdVj8b\n", + "IguU6JsIaDssnxt/qAf8hhp4ZwNzjMvss8+6HZoWugNqZ/D+3xp9B0oMz77//am3QhXxOkpk6pcR\n", + "jLz2Qrj6dzh7nb2TIc6XYxl3FurZE1BdF0Q7AdUtftYj8EjlvlK697bdvVMZWZ3iPFVhxmHCfxTD\n", + "qkmS8ahrBqB5WdahL/BK4G70Qz8LuAjNW78SnQl8ZlxmfZmG6xhKiCJA7B7IcyfPLG1DsIRwIB5G\n", + "0At1fXQzghUVMTupf/F8CiYNpP0cyGnlpb7yb6/Q8VlpvV4uNF8OGX2JL5pBCn/YvYaekZnMSyx7\n", + "lsf/XxxpyFNnfE/O92XTVcQPW8Q9P8xCbSJnVsbQbY28rSnLENz/26PqhTIMwf2/MrNAX8+TevVo\n", + "UzyGFDEwYSLEWmfjmsiQKY78BtxsXGahn33e6pZAqpYkPOoWXyLuj6hnBys4uSX2t/pBl0wYulm3\n", + "V4YBVpYZh3X8RxHEkea4VTVZUecQHdmXgqhidjbYB/lf0/nAfWhka471/Z4PDDQu8zvqCvip/QiG\n", + "oUzgJ3EkHfgMZQTL6qYvdLanoEoJ0QdfG4K1R/xol7/bezAMZQTjgPriSIkR2bhMRpmuCvLU32XL\n", + "aT47/NsrFDaqt+FWOP9G4jNXMXoKfJx9qNk3LGNszFgOHPzY6/j7oe2BTvLn2EkkHWwH9OSsXzYw\n", + "9epM8t5r4jnuxvXk7HSh8XJPAd+KI8ODJcY2WnarXX703W8l3BaUZgg90ACxDkAHcaSIALMF+3+P\n", + "cRnjK5Vm14dOV1I8Ihve/UwjqN2oqr3Az/jj8RDv/cCd4shmyhL1xmhGVl8i/hua4ruEwFdWNRYM\n", + "3JHvX3SHP3qVpqmMjr6qNYori7DEfxgQyDc3RWR0W+HO6Gia7o0jdulp7Nx3Au3QvC8/sy12D/NO\n", + "HsLm95Mgd4crAAAgAElEQVTIcSfILKuHtmXzfgTGGpeZ6du/V5rei4CLUcOgmwksrGwBjppCKGwI\n", + "dnbUBc9s4AyUcLntA3OMyxz021fUtWkULro5UF+eYjKzgWnEs5xT2MZVMav413U5ZEzqza6YRMhq\n", + "r15YA5dB7HGwY+12Tt18OXqv8ytQ4QnwPHAiGhCV7W8soYTtswmBVUkdUAPy5sZbaX75Dpp12A+X\n", + "LIc/XApJ6ZD4DbnvGOLcbY5tROH8FozbvMa8EqDPCNtnIKk8kLolHrV5fExZSX13DaaMqBBuib/v\n", + "LcoE+9lY9JpMER1W9dRR+OZFWdUMburIzjUJbB6+iL4fZRHtPvaP9cmY1ZZHNl/DG8ZlikslDCuK\n", + "hpyW6DtfVg8tjgwH3gdOLU+t41WFyc0EGqP1VScBs2s7/3+obQjWBXIAHkbQFy3oMZ0P2+eyptd5\n", + "kBBL/O4GnLMomZ7ZfwNe9jcj0rF1Gw89W2veUgChC2O5uflknio+gV2X74I1o2HlpbD9RCiuB5Fj\n", + "4IJpy+mbNQMtXLIIWBOI4Vqi+CqaXnlUdfTZoYIN0OowYBIfXhNNyrLmMLMTnL8a/jEDRsLSKEiL\n", + "jSRuV2OKfz2Tgpxe5KHSqz+i3hLNLhqM/rwk7bU4cibgMi4z5HBefzBIERk9CJ6b8CDJW57RoL6a\n", + "ThEdJvx1FG4pYFccJI+DFgdgQBqkfUfOd1nEf9kdLlxFSWkob+mgROc9+HE45T9QHAk7UyBrQxrH\n", + "bXGAZajaJhtAHLkVuBU4OVg1gTjSA2UCF6H+/F+jTGC6b+7zowE23fUZeBhBAp7YgjWoH/pC4FZ/\n", + "tXxLcvl0/wK6fwVfvgHASE7CANOGngsx++DbZ7zO+js0+Gkh937/CZrArj8a5fwLHkawCFjvReAi\n", + "0KCu1sB5lakrXBNwq1v6fcT71zdkQOrp0HuXBoilJ8CcRLLzmpCPR92SiXqYvY/mESqjT6+KusWq\n", + "QdeiJR9rn3j5oHNbGbvlj7x/8RPMPRwposOEv47CHaZvgMxYaGpJ6ahEsnMuJCHCwDcfQrz1ovc2\n", + "iJWuU2sgIV0rTnW6ZRWnbViARtj2RLM3LrXLSaiu8azKEgtxpB1wIToTOAFVjUwCvjEuk1X1u1B3\n", + "IY50whNgNgwlSlGoG+W5vrOnEmZ83WBYeBssHwvAUE7nXhZzXvMzjbl6kfDMFhvc5i4v+aKvgbop\n", + "X7a+hc1driEqOpHYrHgGrSykR/Z8PIzgF+AJ1FXwokCE0l+xm2BmSXb25/ZuCaRqca9HAukReRii\n", + "6HxaGjJyPSRlwwcHSV/WmCcyzmYiXuoWceQ74DXjMhMqGktlII5sR4WbzaFsNxQQR/oD443L9Dss\n", + "/YWNu3UT7jB9QYm+Ad48Ab4bTvyTP8Kd8zXc343SBrGtz8NNXVQPLZDdGrIfWc/62LvNdOPWCUei\n", + "Ou0U1NMnC9XnZ4sjq/EwhGX2d3MgFYPNgfIC8IKVrM4H/gC8Jo7MQZnAl+5cLKHM6V5bsMVDXgde\n", + "t/eyP8oErgfWiiOL0Xz304AlcPZB2iyARlthpScf2TLyM18iZ6HZldaXvJzWtD0XtiagnqdDgH+U\n", + "nj2l9h4IJ/8RXk8ume9tvmEjJ06Zw7npBvgj8CKevP5LxJGH0HiM7SUzA3+2iojru0j3Dk25cssq\n", + "yifqvuoWt1S+xfbjvS0LOKE4lq8bLuPpBp/Q+zeInQN5O+CFHf6f+5vADahrcSjhTt1Q5wg/ahPZ\n", + "VMtjqBDVlvhF5GzgWVQieMMY80+f/c3Q6V4r9CV+yhjzjs8xR63E763j3xEPN50HcxI51HA6b4xY\n", + "y4iKfHarovMWR5qgH+6HaKBPHzyMoRGwnNLMYKlxmV3ltNcQGI2qg0YCvzVYx6pzvmHkx3vp6D6u\n", + "JoJ2ahPiyCUo8foFVbk0IbPeCg4lDGTluBhmueyRNrAOgAFvMKRzEg12wpTngYeBFemw9sZSBnn3\n", + "bO6qkRqzsOZcXXJuKGW/EUdaAyejkn9D9BsqxD0reOqM88n5/gROegn6v6ZG5Zh9kC/5xBUsp3z9\n", + "eUaws0JxZDDqMfYn4zKfBXlOLOppdGIopXNx5B/AAeMyj4WqzVBBHLkXSDIuU2EKjpD0VxuqHhGJ\n", + "RCsADUf1eD8DVxhjVnodkwpEG2MetExgNdDSGE9q4aOZ8IMSf07g/9YOJ6XlSrbEzeCuVbnmy5os\n", + "GWd197OBS43LzPba3gTN1ePNDPqgKQJ8ZwfLfdNBuCtAtVjFK0XtadNxH9zwC9yySPcfbUWuxZGu\n", + "wBfovfw3cCnFPEZBJORGF7C18S7y897mpL3/IfXsT2DKSJqugWtPh6e3WXVP2Vz+JSqj2EytO9zt\n", + "K0j+FrKK8tjUOI0VnfezOXo3bNM0Elri8AtgD1oV8wSgP68N/xPp0xNJXK/VwrKTILcZyGVzTdGn\n", + "vr6qVb0HZwP/Ba40LjOjkue+gLqCpoZiLLbNK9GcS5eGqs1QQRx5CVhlXOaFw9JfLRH+kwGXMeZs\n", + "u/4AgDHmH17H/Anoa4y5VUQ6A1ONMd1CMfgjAdaY+AKqfrnGuMxPh7HvEcC7wCnl1UO1ut42eJiA\n", + "myF0RyVDX4awdkwq0z+MYOjsDrA7Di5brm3VRNBObcPOeN5FfeFXolGyD6PeUW4jcX9eO7OQ9Eca\n", + "wzSNyi2qZ3e/WCYorLT9xiKiADqcfpBuA2Kk60Si6u+m2VopTNx4aHPB1uJ7197JVNT4vgW4oZTn\n", + "ly86Dyjkmp+3Utp4vLiy6TrEkTGoyulC4zLzKnOuPf94lGF1DpWrpTjSGw1K7FbhwYcZ4shk4BXj\n", + "Ml8dlv5qScffhtIpUrehEZXeGA98LyLbUQ+Ky6rZ5xEDcWQY6pnxDXB8ZVLuhgLGZaaJI08AX4kj\n", + "p/gaaN06+jGldfT/8hp/FKqKcjODsagfY9tvxlFw7TZI2Ql9MmBLI2i3P3RBO3UJvVM5ra0Qu+Yc\n", + "2m48kVMSF+NkfmWK8BDUJ8SReDJzf4VvG8PjqpUH4GGI2N6kbKve9huL4ptz2fhkXHyDVxk9L4PH\n", + "6hXydTeivjqRLnPO45OoLBYVNuR94CrgZU0217tsO9y4nk05d6Bqvv52eRQ4XhxJozQz+DXQeymO\n", + "XI8+7xHGZZb4O6YiGJf5TRzZhWoFvq1KG36wGmgrjjQIlKCwFtEJqLGi86FCdSX+S4CzjTE32fWr\n", + "gIHGmNu9jvkb0MwY81cR6YK6zR1njCcw5WiT+K1u80m0ktKNxmWm1uJYBM2E2Ra4wC11VbZ6lE+b\n", + "cS2mc2PyIR4elEiLpS1haQvYU5/i4kJWFzVgNqXtB0GnH6hr8L5PT56mBed/akVR/c28kPU/c6f3\n", + "sSWunkmLIfIQbDtZd7Q4uZC/zN+Apy7xTOMyWWXtN4VtYFqffvXO5M6e3/NBX/jfJ+oPvjcGBvUn\n", + "bc1wfkXTMUej9/d2Hu3ZguKOt1VkB7KMvAceZtAfZeqbKM0MlgA3A3ei3mFrqnMPbTbUM4zLhEzo\n", + "s0b3W43LzA9Vm9WF/dYOAC0Ol5BXW6qeQUCql6rnQaDY28ArIpOBx40xc+36d8D9xphF3oMHHK+m\n", + "ZxpTNgL1SIA4ciKaPG0p8Bfvknm1BZvc6lt0qn8veOILDFAY4Qm1r05ekVXteHfjDeygtO0gBfUc\n", + "KWVMBlbWhcCkiuC+T/mR0Omv8O17eq/6Xc2Bg414B7jTHfRWordPngLn3ayEf8Y/YO/9s0j95E48\n", + "bqMD0YLp7txCi4BiPjxhHj36DYzq+S4jtxZy7W8aIFXfzh5GNid92q0Uocbd5SgDKEarnn0DfIWm\n", + "qAhaCrbvRm9KM4O+qAPaZ2jG10Vo6u4Sd9LKeHSJI41R5pJclayqAdp8G63ZELKCRNWFONIKFXSa\n", + "11gfIqcDp3ttctUG4Y9Cp11nAtvRwBdf4+7TwH5jjCMiLYHFqM4/0+uYI17it9LUQ8BtwB3GZT46\n", + "DH3GoJ4eDVFvnfL+N+OQnMeCToWs6ohEZcU26L8q4mCvHMYu1/KEEHodvVdNAG/bQQoa3LOVsgxh\n", + "vamhmsJVgTsOIy0BXu0Pj9nSNxfEMufL+9mPqi/HGJfZWUrfXi8XTn4aBj0La2I2cnzaCe5SiuJI\n", + "HFp4ZgTqLdUBKKJQCljUy/Sd06zJkpxZZcYyGqZOSWU0mpTubDQ3/WD02/sVtUG4E9Z9BXzdO5U+\n", + "lSDQAjyNfs/3ogF9bmbQFS34sihhFfln/MiFn6TT3i0wVDRbFEf+i6qVnvG3v7IQR/4KdDUuc2so\n", + "2gsFxJFBwPPGZQZ4b69Jt+da0fEbYwpF5DZUmowE3jTGrLQGXYwxr6FuaG+LyBI058Z93kT/aIA4\n", + "0h31etgH9DMuk1bB8fWomFAH+u+9DTRpVZZd/P3fC2xiWstObBqUxR9+as5aB7P5NJptHsszkyZz\n", + "odesNNQ6eutv7k729bXPPeiGhxlcbf8niSOrKM0QlgFptRGp6Y7DaJPtIfoABXnkoHEODrBIHLm4\n", + "lL69IA5m/w1+WZrHiNmNyIvKkKsT3iI5ZxwqTTchO+p06psubGyxh/1ROXTdsYX+K/ot7RmVn7w2\n", + "MvLf64qihm2ERvluV9+k+aQeN8UrUOtfpC6/FpXKW9glBw3gG0sR/0z7C9EXraT+uWvgpO3wJ+O/\n", + "lJ+NYXgdZRxDjcvs9dkfh/rO948RHlh3Aa0bN4aBafDduzAekiso2/gm8JI48myInuMSVJVal9AJ\n", + "Hx9+b1WhQSM2aqqcYmVwVEXuVjWCMej2VapPoDQRvhINcvoazQJYHqF2/6+HhzD7I9YVEfMstJpS\n", + "8Dno3dJo8lQ45xZ4cRUURTOSk5iKat1qOq+IL/xJQstTmY2qHnzVRfWwKSrw8jIylSxIXpUxVpQj\n", + "XYk+rwF3k9p7t+rtY9pAcRe4Kw6GQIvf4aJhB2mxp4hIismOXMt3p7Zm2dRWFLqTN960DvnpDlwr\n", + "tjXYwO1R9bkwpyWJsZlk5++O+a1g0bBkNn/RluIoz/HMu4PU5b+gxP8N1IPmbGCUFHBWSiaRjfMg\n", + "rSHk1Idz1sLPW/l12fkMceuhbSbX99GkaRdWpJ92z4Ky68O6Jp5kZOXNFu1sYg1wdSj08uJIU9SI\n", + "2rjOJBnUALtGxmXud287q75Mu70zZ03sBZsaw49v6/ZQuT0f8ykbyi2Skbp8KkqwKytR+/6PQfN4\n", + "7wdy0aA0AeaiHk3lEWvvbXmHW3otles+bhfkqhoygbMyz2bG0sORVwQ8xL4IWreFLm/hyehYnrpA\n", + "HGlBWWbQG51l+aqLVoUyt00w8RbWxfBzdkQvZ/zQWIriT4KeiUQOgUG/wfHvQEQh7N63je67DpCe\n", + "0IKvpyfSdgEsuB082Zp8A7higNP4tc3rtGreicSN8NM9OpvwOl4caYPGGjxnXOZ5gIvry+w/tWfw\n", + "lK6aHPDlb+DrbuD0YW9mW+qh7+1U4AJ7H6/oncqwitQSVakUZa/lAaCLcakzSHUhjmwDhhiX2RCK\n", + "9qoLceR1VOX2NqrGGxOVz+WnpBN12XK4eCUkWZYaKpVqOGUD7cbB+GRO+wd0/wJi9kN0VjIx6V+i\n", + "X9UBKpamN1ew3200uwKNVn4aeLIu6aQDwyvXfa7H9pRNvYUTqiF5BDvLEkek49tc3qct/7w+nnav\n", + "NIRmjeDKhp487uWpC2yaiO/t4m4zAtWPu5nBaOB+oIs4somy6qINVfElDyZHunGZ5dK6y8OMyHub\n", + "qwrimPiaBlIVPQR5m7XK19ZTgLHrSZ04nOUdl3P5hYnUy4W9nbRiF6CeOaXaPQjMELlsC0zoRIMM\n", + "jcwtgR5vXCbNug/PEkfyjcu8lldA7sj1MNIr29C4BTB1AQumpDIWzcv0L1SoWRuTxrsdOnLKl5tp\n", + "G2nFEn9qCXetYd9Z0BaNVykP7wIrxJE7Q+T1sgQ1RNc64bcBdgPQ9ClPAL8DE055hbaz9pUyxgK1\n", + "7/Z8FBF+WyRj9XmweQgcbAT5DaHgtnnc/+XQUEwH7fTyZZTIjDIus7i6bR4++PEb58b1sKXKEYae\n", + "WdbrycTs1wIlTe/sI1cmTKJ7zn7UqNvOLm22Xklk7H7q/fsg5O6EJvvguB1Q7CWvVKZohX2mG+3y\n", + "Zcm4VHXRHQ9DuN7+NhdHVuCjLkIzRZY7AwvKQJfe7Xr++3Ucw/4Gl10K78wEnoBf/o464ADk5BmX\n", + "KZTUURtZOLcbfxgNYy6DeXfDnPvhUKBCMJZxH2ipSwk8xxuX2WzTFs+UsQ27N6JPsytZl/chebEA\n", + "3xDPjfTK3UXLNvwn+zP+Mrs9scWfAncAA5rt4L0to2ibFA+XL4Pnp/hnxqUK2lci6ty4TLo4MhuN\n", + "5XmrvGODhDtnz+chaKvSsMR+BHo956Iutk8BVxmXSQdISZWNN0HbKjDJGsVRRPjth7Grt8/2gpwQ\n", + "Ef1RaDDaRODaIy1lsTHLJoukAKNDWC/XzrLuagvRWbC/HWS1a01h3GWQMwc15uejka5RxVG0z47W\n", + "ZHUnzIQH/Mh8oZCEjMscEklpB+2u8ZqJ/IXU5XMona7iPPsfccRXXbTcHfDmT89/JdGDG8vA9ftp\n", + "st0zy0mIwUTCd0/q/SiBu5i7N6Pd+jyH7urC168mc/VZ0GgLjGtRRFq9teJIVNlZZHCM27jMejmh\n", + "zaOcufeV/X3uj/xqaWNO4gXyWZ6/hsHk82EcCWl9uOYs+K3XXqYVf2OKlxcCP10msnUCdN7UGFY2\n", + "87TpjxlXo1LUm+isLFSEf2wI2gkaXsR+DPr+/I7ShAfQgLknvNWMVWWSNY2jiPCHXqIF3HnI/42q\n", + "Ea42LvNDBadUGzXl/mWJfHWKmkSiWR07Ap1IPLs7e1FD8aF4z4FJw2Po8V0e6uHgXjYOf5KXpxUy\n", + "AlQZ/TDwuFf7oZKEAth7upCKu3JZSeoBa3RsiWd2MAi4CehlI06XtT2PnmdsovPvO6HHbvWr/5D8\n", + "uJNI7LOIKX3gpi7KVNt51Gn5DT1dsygTRi/0ZrQljHhX2u0UZQ1h6crf2dnoI87KuBj4VRy5x7hM\n", + "SaRrpRj3r30vYdtTkVwznJyi51m0Yirwt2j4P0hcD9ecBYv+DHPvS9T29J1wezB13KeLGyFWS0xG\n", + "s732NC6P23cV8TulX6EagQ+xPxcVECYADxiX2W6PaQdk+rMtHa5yipXBUUP4a0KiFUdOQd005wJ9\n", + "K5vnpCoIEFF7WNy/rM7cTdi9l072tx2aJGwTsImoHJ1JeRN9gPT6PxmXucq3/ZRUee4m6Dwekt3l\n", + "ky6E3AhYfxDSQicJtRtH9H+SaT4fEjfA0itRJjDiUZFRPvYIMxnNXLkDDahy34tIe919Yg/x9Oc9\n", + "4LEhcPXv8JCtatsgbjPkFYEZn6zv3ZYAwscmv6Uj3YxYHHFx1aLGxmWet0nNzkdTY28A7jEus8z7\n", + "+IqvPyGGXb3h/alw4nhYMYaST73dTzD3PiX8gLdNoRq6+6BhXKZQHHkHTdd8TzWbW4u6/yaYEJeo\n", + "DEDsJ+JF7H3QkSMgHbMbRw3hh+pLtG5YHXEqqhv+i3GZSdVtM1i0g3HjIfnfp8DSltAyB3rkkDy3\n", + "mCfEkXwgAyVSmZVVYVnC3hI3Qd8cN5IDCWeSUNCAhrnRJFCPCDJRnfkmPKH8n9htW7wlGklNGQ03\n", + "+amR63+WVRPTXpseoyceL58U7ok+nfpJsKsX7OwDyy63WTKb9IL/eaktVFL3S5TVCLwOWDdK5E8T\n", + "8KSfduNAYjpc2xdmpsLKBrGmuMrCxwRgujhyt32mX4gjU4A/A9+LI58DjxiX2RHcXbFqz4zjYPKL\n", + "dpvVHP1+tc+xHhvBYVRLvAXMEUceMi5zqKqNWCayAp2pVTv5oSX2Z+HR2VdE7L1xROToceOoIvyh\n", + "gDiSgvo0b0ETqwX5sYUGCeoySr1V8fzyew9yIxpQVO8AWb1Wd4Dsh1EX0lZAvDiyEw8jcC/uNAj1\n", + "0MLUTdBkeh1RY2sWsIm99fLZ0TGFXbcnsq8j7OtIzP5H8roWTNtWzP7HgvnYqzLLquq01zLjriiB\n", + "dy+90VnIWjw+/q/x3onx7PxxiBJ7b3SNJX4HHGhhGYFbUi9/PP4k4cvowqq0Z2FaFJzxCAxfdoI4\n", + "cjGpfG5clZtlGpdZKY5konn359pth4DnxZH3UK3YMnHkWeDpilNd+FN7Lk9XOeatJM+2skz6cKgl\n", + "jMusFUdWojryT6vZnNvAWyXC70Xs3Tr7yhB7b3QkTPiPPNip/Z2o4el+4O3aihT9hnhezBzNej4u\n", + "2R7945X1mbPkKVwrFqEvWTKe1Acd0fzsTdG8kHn2NxL1kxc85Rm3AztYmzScXbclcrARHGoAhdEc\n", + "5J3Y1gw9sR2LngtWtRSqWZYb9jl0xhPE5V66oO62y9GP80P7u874FIiX1JRC+FPr0oTv+jy4NpYz\n", + "H4LYTJj0vlVRxVfoReQtCUcR2SaD5l1W8FxcDufYOcHE9Zyz7n2a5D0M/F0cSUUrlVXm/ZmAGirn\n", + "em+0EbT3iCMvA/8AVosjDwPvB6ykFoAh695QGveDgz+bFakl1bmqS/h/R106g4YfYr8cvf8PVpLY\n", + "e6MTPs+uLuOoCeCqVv9ad/UdlED+sbzc9TWNFJHRexgwcQcL4qh3AM66DxpvgsSNkLi6iKjiffgY\n", + "Tb3+b/bnHy2ONEBVPO7ZQicWdr6LiOGt6TwDog5CcT2I30FkUSGdc4rYUcDe7FZ8R+nZhPfsYmd1\n", + "punWqNqO0tJ7Cpo9ciceCd5N6CsVlFU282VOc5h9IpGHNHK59WL46EvY/+dSAVNVa1sJqL0mdxqH\n", + "QsAFTA6GAYgj3YCZQLvyYg3EkVOB/6AzuruNq24nMwyUBfbHOO5bfR9vAscZLflZJYgjQ9FYmlMq\n", + "OK4+HjWOm9hPBD6tKMVKkOOYCTxmXOa76rZVqX6P9cjdKvWrH+p1wD/t8kyoikVUB1Fy/u9FfNkH\n", + "KYKTXsatiiHr73NM3ueD/Z1j00m0pPyC2e7/ebw1IIqcDxpw40B4aYX1DTcMizmBlxv8xg1N+W3u\n", + "lfzDHu/NNNz/W6BqI39MwXc9Eo8e3r30QvPKuAm7e1lREyltS3v6GDj5GTj14SJ+TrjPzNz5dEj7\n", + "UlvKhSgDyEUZwLcVMQBx5Fc0wd/sCo4TdHbwJLCEz1t/w299L6mpVCXVwSiRqZ9HMvK/x8E1SyDa\n", + "fl024dxGIN1Uo4SiOJKIqmUb+c6AaprY+/S1CTjTuMz6io4Nab/hyN3KQRxpiSal6gAMMy6ztJaH\n", + "VIIiCrYDfTCRsPB2z46G++PFkXH4J+xNUH953/qqy4AZXus7jMvkSWrKaK4c9jHz7op3BwR1YSx3\n", + "HVxH94PQcA87jMt4dE0+sMStKb4zCTgeVcsk2TG5VU0FaPTzTlRl8w46S/FlFDVSWKOM+mNeTh5N\n", + "Yhdwxq4HxZEM4zIfhKwvJUCTrFH2UjTCe5844kLTJgdiABNQIlUu4bfn/08c+ZyNcS8xcverJHWN\n", + "YNYjGi1cjtH6cEIciep7Mh27D9SCPeevhpb26drYgDeBT8SRx6saa2NcZq+1j3QG1nkR+zHo7MtN\n", + "7B8KNbF3wyYcTEIZ0BGBY1LiF0cuRIuTvA04lUl2FqL+BSWK/iTyJJY06sX3o3qw/6N6JSc1vOIg\n", + "p09dzAn7fqNs4ewdwK7KpI4QR06lQD6L/Pdp25oeiurRj+zY21nFOeRUmKzNxjb0oqyhNYGyEvxy\n", + "1AW0OYFnD97rcSgT8J4xBJpN5FTXDiOO9EGjfj9APWdCnvDL2i0uQyX/XbafMvEg4kgymlK5TbAz\n", + "T5FRU4l7dySXXwTNVsOcBzT3T9FFlVZhhQpWKLgYeCwhnZZTJpN4qo8yxyvF9K+oy2qlavn69OdO\n", + "kNgWJfYrUCYacsk+QP+d0OI6HWq6rzJ9h1U9QfSj9W+fA05DdfmljDHVze5pOb+bmAVStSTZY3Ip\n", + "K517CPl7HbqyqccYihKi4EBIDXGW8cwDXjIu816gJGQ2QVgPSuvgU+z4V1JaB78M2BoCQhyD5x76\n", + "Ywze61CxmikDyCgv0tomgJtkj72mMoVMKgPLAK5AGcA2wOWr1hGtLHVPsIGCIpfNJPK9oYy8C3pN\n", + "hP0dIG4PzElcwXm/pITSQaGi78O+VyPQXDUAD/VyiDzFBM5uKo7cBpxqXOaKSo1FJfvhKEMdizLU\n", + "/6DEflv1rrRysDmSXMZlhh7OfiFM+Cvuw5HTUfXCVPTDKqVHriC75yzKJ+Tu9UQ86hZvadx3fUdt\n", + "pnwQRy5HC22cZFym2DIst5eQtwTfAQ1D95Xgq5TsLNSwM4/yZg/e//Mon0nsAe5G78P51SEeQRDI\n", + "KLRu7iNogjGXWwgRR+4HOhqXuSW4vryKv7SfA+ffCAeaQ8PFOSTmLUUNwJUuku7/mvx/H9awfSpK\n", + "8FsAf0cJsIHys5taHf1GNGtnudXqvIj9GDSj6ApUjXMQzZ11YXWvsyoQrU08xLjMtYe97zDhD9C2\n", + "SpBPoFLBTcYVQH3h/oCaroYzXBCfDgnp0HB9EfWKCyifkLv/7zpcBLEqaR3sFLw76j3yJdAAJfJd\n", + "0WpYvmqatdXx3KkrsJJoY8qfPXgbrcGT/K08ldOeMgbFCgikz7jqAdeghHI1OhPIABYArYNR3ZXp\n", + "L+ogDDtpLwOWRRDFJFQCn4v6pVfZW02/jwdHkvgy5LaE/ARtusN9c7luwT40iCoVeK+y2WrFkQ+A\n", + "Be500j77fIn9SjxqnG32mG6o8bxTVa+vOhBHHgOKjMukHva+w8bdshBHTkDr365A3cbKqfdps3se\n", + "TITV50N2EuQkQe7987nvy8G14dMfCBWldbCErg1lJfieqJE1H8gEfkSzCa6qOCjoyIV9dnvtUm5+\n", + "GKuOuQp4BvgYJchub6l+lGYSjWw+Hw9jOK/tEHamdCbnY03DnNWOQIFiNv7gTRukdR1K0JaiBvDT\n", + "UaN8+dfma7QuzMljmnmBU9iGFmZZhwoli8SRN9EkYlUoXlPUGr6Fvf/T1aZr4IzzodOGgcBdwCXV\n", + "sAFtBL0AACAASURBVJW9CTwrjrxgXMb4EPvzgVXovfl7gJnYejTzaqPDkVbFDzrhle7jSMBRSfjt\n", + "VPoBYBwalPVhxYTbnfa2hc3t4kZBdl0i+uBJ6wCwswEsbw59W5D8VUdeFUe2okQ+D48EPwd4FSVO\n", + "i9DSeqv9tV3TVczqOuyM7V1x5Dd0VuR2ACjzDlgC1QLv2UN+3FCarIf2cyGvqSX8UF6gmJ1VveaV\n", + "w+YJ4A1x5CLjMr9WOOYAQXTiyMloyuWH0HTirdEAsMeA13wD38pHZBI8rrWEz74Den4G8+6CeV8V\n", + "ctP8L6rpIDETjTK/XRzph4fYTyQwsS+BcZkicWQ5OuuYU41xVBUdOYKiduEoJPziSFc0sdoB4MTg\n", + "g0NqJrtnTcCd1mFZCxhynbrKpeyEZjs4mNGLh9CUwmVmNzYB2EflE/2yWS3rgmvg4YZxmSXiyEDg\n", + "M6CnOHKd76zIEuxtdgFAZNQYeN6PyiFQnv1S7eUDL4sjM4BfgG/EkflAqnGZ36twDUXA0+LI542W\n", + "8EmPRXSpH8W2388kNbs594sjtwJfBSfYxKYDzSiI1fxHM/4JeU0gcVYWmk30TTSQam8FDZXAMs4z\n", + "Ucm+Fcqg/oF6PVU2qMuduqE2CH+ZWrt1HUeNjt+qN24BHkUDZ16qdBKzABGZ1RlXTcBd+s795EqK\n", + "9pVT+k60IPxcoEcglVcpQ2HHmZDRR6VWn3KAxxKsjegN1DZyQUUh/f6Z543rYb7fDJ3l9DsPTTnc\n", + "FU0h8iM681hW2WvwVQ0a4KwepP9wEYXF0axDDcDlzixKvRulMHoqqVNuQPX77opeLwaKsvYh9heg\n", + "qrQJKMGehkYuB+VV5W3n+nUoLbaksDn/xerXsa0MbPqHLCAuVPa9ytjvjmnjrmi90TdR3/hrjMus\n", + "Ctng6iCCKQDuC3HkC2CucZl/BWq3pC5vZD5cPRKSftGAoD25u0jOeApYDCyumo74yIUVKh5Cs2Ve\n", + "aCqovBYKASL+Gnm9QQGjh/6PdZnRFMy7nC25nTgX+AFlAEHnsncLCjsbwO446LQXYgvhjAQWzryb\n", + "t1GiPRV4OJDfezAMTRzpya+N3mJJ9+PZ03wT2UVbYOtzpC6fQVliPxH4xFuyF0e+ASYYl3m3omvy\n", + "/QZ+bA8XjeJgq9e45HAWObGG5SnGZbqEor1AKS4C1qI+Vo271jXxOeAl1HBVpfq3R5Juu7Lpc60r\n", + "a18qrFZk7RxF0Vo2UIqhyVpIvmg7yRlJKIE4Xhxx2woWoczgF2OrVR2NsKqQx8WRVcBUceQW4zKf\n", + "BDy+monrUkRGn9uYs6bfTJv3I2lTPx9uepd1M5twy7pxdEPr6k4DHjUus6ai9tyqwQVt4N4RsKkx\n", + "NMmDA7mchLogf4DOLFZYlY3L+OS3DyoTa2rvTnByMxgfQ0RBD5K/68Fxtw6miEIiS7JeuspR47yB\n", + "2uQqJPxuO9fcdvDO8fDUNDjYlJi2Ef5rNtcgQpqOuVU0d17aluQHO8KjP1Rci7qqOGIJvzjSBCX2\n", + "xwPnGJdZVOW2vGvHlihODp9uuyqumcGmz7UunP9BMw9WkOTMx85hImDPv9ezJ+IhM7/E7zoSVXv0\n", + "t8slwHHWqLzIa/mtJnLu1CaMy3wqjmwEPhdHegCP14Thvx2M+98+Op66G77rBKPW2Y8/k5vWuswo\n", + "m6nzdmCuODIZTQ62LlB77spa563RpVhgewKc35rFv15ODlpxbDGwBlWX/lUcyUDtDBtKllQ2wPIx\n", + "gZ+rLcU56nbo8yHs6Q7Lb/t/9s47PKpqa+O/FTok9CZNkCAtgDQBUapSglgBu3IVxIq9ez2cz94V\n", + "O+gVsSEq9gCCUkRAAZEOUqSGIoSSAIGU9f2x9ySTkDItDed9nnkgZ07ZZ+bM2muv8r4VWPXhfi5f\n", + "enteKyWRmFhK9buJu2d1k1rnJLC31nY4Gp+bA+aZzM7YBT+cDrcsglqHIa021X35jEOIxnjF9/39\n", + "LduS3jMxK6K+pe6le8oO6Ps3JJeGMraY2h8tal9QIgz/Cd74wN/n0YWbMAIhHYJvhrIP7BUXQONZ\n", + "RjbvWOVo2PaJuLIIE8Pz6+VrxYT30k4x006IFbeuwpRw5sq744EvXp2NY662r4mQUUXVCuiImQyu\n", + "ANpYI+k9GSzLq2y0oCQnQwl19A+b9P0Gk/QdEepmPI9Ru2oFrKptDD9k/vjt6upJceV14E5gobjy\n", + "LfCEOrop+/my6wlEKIw5xMbjh3DU0TgxDJfjMbQH52Oovl/GfKdbMMatD4YPp4m4koj3hOB5lb64\n", + "CqnAxn5G5ctT0VR55j+w9DtxZQ7/azyDrS2Gea+szU7dXiXtmmj+PERk/TrVWuxNrFaJY22Osu+c\n", + "elL9uXhNcL3vyTOZVUqBR+bCo32g7W7Y2ICywX7+fiLD4/f8lsdBdIb7mO23bB2xNlhDj2ER2Aj8\n", + "BDzV6wXunXmMc7NfJMTyl8U/xp8ltuihKW4xIZWVFR7T6XufDs31bWxb0qHMYSOUXe4QVL7pD66d\n", + "+yBQOYBXKj5MENGzuOax/bT8qQmUT4WRf0DlY3BjGj/PvovzgeRAvUpxpSKmLO6K7PQU3igIg2uT\n", + "eK3JnAw6YQzJBrJOBsvV0WR/Y5tFDTHKX+9jjOJFGkLBHk9MPvv23JL3tvv1LuBWDL/9k+roFu99\n", + "8uqe9bqfxzDlpPdjwi0XY1hrN2C63VfZfEddzCSQ9TWhc2c2/17uhBuq3Hspd8++ld+qjWZBv2Ec\n", + "mOSlkDNyA6w7CHM6UuFmIkufQWzErXx2MLMu40rKHVnOsaHe4/V+Xo6Xgua3gWwncVc1fjgy3j/6\n", + "h2AgrkzCaC984vneXu4K+yrCEz+bRPo5dZjz6818gjH0vYEDGEP/EzDLu2PZ3/zdSZvczdJRe+Vg\n", + "2N4Vpo6F5CtDVmmSV8VCINewP47y+DBBNFzBtT3TqbczEuY0hub74Fgp2FKRlJQKpGFWZX6vOOzr\n", + "CswDdAVwOKcqp8I0uLYCog1mEvBMCM2BdbXXUPP/NtCgU7wpTfWm782tUqmoYb/nxzDSVheqo3+G\n", + "4ryBJO/teGpgmqluwlTKPOVvWaSto38X0+A3ClOqegsmuT0FE6PfneOxEhMLXcfCu5mJzopXH6Df\n", + "92s542AkKREtSalWiv2nwYznYHMvu9P5CfBdderF0ik+nUX8iALbqkAj246V03PgPZkt70b1v3pR\n", + "RcuxTB29wJ97Dgbiym/AXero/GEisydDz5GD4WgZKJcKP50GO8tw/HglJmONfX7fSX6TdJbrn7yG\n", + "33rj5Q6ZMMy6C+07w+aoTu4VmuuHpgQvEHh7d690ha9awKwP4Hw1D7r1nKPIewKpksO2GpiE7l4M\n", + "NUMFDP99lsmh+ibaXXSAOpWPQex6OM8GCgrL4FpPs23rn/nwzGo0W1wP7lgIN9jiwmEwZ7Jqr4Ie\n", + "RzAQV4Zh8k0j1dGvQ3FOf378OYynFkbIfCQmcft0fmWo2Y4vjZlA7sc0k72KecYexVBMvITRrjgh\n", + "/JBXRZPI0NlUeqMn1TbB/iZ46MCJHHSEI99UpMrV9Ny/i9nMYWsV6DAK4l+Esmn5Pwc297QWqKyO\n", + "1vH1XoOFuLKn8QQebrKXW8qWpdWxSpRbehacHgXXLoe+m+DuvUybWkC/pZPY8IfWG899DEVTw+/t\n", + "3aUJnHM9pK3mn8MLGB6kCPnbwBF19G77dylymEA6fMeLNyutDpWDTvHQwwYICtvg+hveKGqckHc6\n", + "+4+pnLvnPuA14Lni0O1tWUfvx6xIJgLP+BOSsjTR4zGOwwh1dLnd9gwmIfkwpivep36ZXH/LDbom\n", + "cvGackwbWbbTpo9ZlGaG2OM/cM98uHCdb8+BuDIEk8uq6U8jGfhZO296O7oBAyLXce+gacik/RlV\n", + "IVwbBT3KwIgE31ZqweAkNvxF540XFry9u01VqRlRleYNtrP4aCoHA4m3iyutMfXeLdTRhLz2LS4G\n", + "N9DwRlEgVyK2Zj/+H1dtvRNDk3FjkDQGIYO4cgqmCexaTF7iWXV0j4/HCpk0Eu9g8gfJ4srZmGqx\n", + "CEwDWJ7iMZDHb1nmjyZ2V2eik++NXELFQb8qkzQ5YlxHmHEaVPnct+fAjjURM8E94cv9QdZnL11M\n", + "8ts73Gmdpg5kJmS7YhKy206bS/9RxygTHwV3L/AKTZViP2n85s9KLRAUmeEXkQHAKxh5vXdV9dkc\n", + "9umFqRIoA+zVbJ5kfoMvKR21wSJU8XZb4vejOvpKINcsKoMbTHijMJHhuXZ+w4ifzB5j6AtMF+sQ\n", + "TGL0FOBiXw1sYcA2Oj6IqfQaDzyfN3FhlmPrAa9jiP5GqqPzbIWKRwJyKXC/Oro+z/PkFQoyBvbL\n", + "yHX0azOHQ1UPs/3HW2l36ntcuXGXfp73Oe3qq/62Vpy9qjQtE2v52knrcX5e6QLL65gCi9/rw+PN\n", + "2bXvNBIx9OQpwHFsxRWwAzhaeyPNr91F2XqJcOWKTIWxoTDn80JYMReJ4ReRUpguvHMxH8Qi4ArV\n", + "zK5CEamKoQror6rbRaSmataHrajF1osLPA9gUll4ozPc/6sp7/TH+xZXzsOoi7XylVK5pBjc4oKM\n", + "vFPFvdD7MWj1Bcx5DBbPnqtpX/S0BtEFrgEGazGS9QQQVxpiwjTDMF78i/lx4XsdeykwFvga0xty\n", + "yOZp7sDkFT7GNJb5dL4czt8KQ93wOnAPq6NSmHnGIRLq7spR2yCnVUTVy9OImf2q/rLrHntOAWpi\n", + "SOrqZ/83ai89y1UgMqGC+b1FKJROAznMkSPV+B5jv9ZgbFw8cNCyiN7W/S3un7ebhmRDoeXIisjw\n", + "dwMcVR1g/34QQFWf8drnFqCuqj6Wx3nChh/wVAU81Be2V4YPv7LbfYy3W49pKaal/8sCHey/GCfE\n", + "qmuvgAF3QbX5SVQ7OkQdnQ4grlyJWQ1fr45+X0TDzRXiyqnAI5gmvDeBl3yJjdvy0Rcw2rY3q6M/\n", + "2O21Md3dQzGrgDcCCXeJKyuAm3gtugHHznyPpI8rZb6bVdsg47uoswxqr4TKOyAqHupOTKPx/t8x\n", + "xv0UTGFDPJnGex8mz9WwbBK9IyMo33qPYbv9/lNomgCD8jHe4sqLNedS7aKfOcd7xXxFFEdWJDK0\n", + "MJynQG1nRP675In6GAEPD7bbbd5oBlQXkVkislhErgnymictEiF5fXUY3xGe82L39qN54zqMoPmU\n", + "AhheGBnYNtYYIIs9bWDiqRvZVP4l4HVx5Xtxpbk6+gkwGEO5fK/1PIsN1NEt6uiNmLLaesB6ccUR\n", + "I1Ga13H71dEbMBoCY8WVT8SVWuroHnX0FqAHpuFrtbgyJID7NqLz+6L/Q9LHlYjaYfj/AePZNxyd\n", + "uavV0YieDqd/D5V2w8FGsLHeUWChHUdVoBFmRbIcw+I5CmgI/FRtHvdd/DwbXpsKZdMhOgFGwsat\n", + "JlGfFxrv7cG0BXBHLEwbBnN6VWXV9B7MK+4r5mA7d31ZLpQhMzFSEVggIgtVs8YCRWSM15+zVXV2\n", + "kGMrcdgGY3udzzkPzKPiKbYp/vIqHF/akj/yO1aMDOHjmLhy0WfsT2Lk2uH8bUKcuPIUmXQKEzFs\n", + "sd0w3P6txJWbfA3BFRbUKHPdIK48jVED2yiuvAKMzYuDSR39SYxYvQusFFfuBT6yBHLniyt9MQng\n", + "O8WVe9TR33wZT71v2PXPeTxSiZTkAwD97oV9p8Ns27zb4FgPcWUo8AUMMDQkv96f9SSVv9tAX67B\n", + "0LP3wPSN/IGppb8D+D3je3AgRmTThmPcuy6Ks2PhJx/DnU2Av1eqLsLSp1itg4D4wnyBzZf2Cvo8\n", + "QYZ6ugJjvEI9DwHp3gleEXkAqKBqZMlE5F1gmmomyVU41GMgrgyKOMbb5z7PqiqplE+CoytimLl9\n", + "CPcCMXnFTcWVMcDp6uiVue0TRuHBhj0ex7BRjgE+xSR9qwOX+JpUzQ+h6Lo+oTT1tDVTuHZLD4xs\n", + "48vRY1kXncCNeV1DXOmEYciNB27ydA7b8ON1mM9iLiYvsDmv++kGry66ieiyEzqxqPbLcOkV8Ppa\n", + "SLERn8g+i7h3VmngOFPqT2H5wJFZYvxVLksjNi6V5klHMTz9zwC/5Ef3bHlzjgDlfClRFVcSML+5\n", + "vV7bJgI/q6MT8js+FCiqGH9pTHK3L+YL/50Tk7stMIma/kA5jJ7oZaq6OtjBn0ywXa0rgds8MWKv\n", + "917G1CbnGCazFRcrMMIzmwt6rGH4DnGlHSbOXxNDq9AXk1QdrE7mbyAQhKIKLC+NYMas+rtMAm9F\n", + "lOfsx+dR6pZFhhsnt2tYw3kfpvnr/zAx/jT7XiQm1HI78G7TN1nUbA8jsk8mngKHp86BeUcr8VOH\n", + "shxf8LqXKp4p5WbMqmkYz/0R1kTB7y0qkxKZSsqxvXRZvZkOB5ZgEtdzgWbqoySjuLKXPDQrvPar\n", + "gskXRHmvsMWV2Zjk9s++XC8QeE/2n0PPQo/xq2oqcBswHUPa9ZmqrhGRUSIyyu6zFsP1vRxj9Md7\n", + "G/0wMnA3Rjlreg7vPQqcJa7E5nLsE8C7YaNf/KCOLsPEmR1gHKYc8k1gtrgSVNWHh5r4hbPgm+Zm\n", + "23iIbmSMq69nMQSFnd6CeovstvHR0Oh2dXRN37EkL55Aqd/rQ7ubITUi92uooynq6FNAd2AIMM/2\n", + "lKCOJqkRI29bdi/ttw9n0vmd6f9xBD2nQv9u8GqMSKyHoG7kEuhd9jBNUw/Sb8VLlKva5xh1um/j\n", + "rO+nMGbVpRhiuPuBH2mZOIPrFh1ixKxPuXn+WXQ48DLG2K8Fvgfu8eNj3YOR08wPTYC/cwirNgK2\n", + "+nE9v+CZ7KdC/8nQM9DzBJvcRVWnqmpzVY1W1afttndU9R2vfV5Q1daq2kZVxwZ7zZMN4koDzMN5\n", + "d07v2yXqSOBtcaVytmPbAYMwDTZhFEOoo6qOTsGQ1C0AHsKIc78vrtwZaNLXYyTb74S7BhgaX/CX\n", + "wtcmR5vOgCre9spoBEdB+Zg98PnnsOBdKJ2e/zXUSHv2woS2ZtuEcVn73o4+r5O+cCKlvmoJnW/M\n", + "nEwiqTppOt269aInl6e155luwgfT0pnOEk5vNCuVm+c3oN/u5hgW0Vignjp6pTrq4aTagwnt9MPQ\n", + "tYPJP9xqQ2++YA9GQzk/NCab3KINa2UveAkpGsLod4To9dVhfRAE1CWCljk7SpJoio94HngrJ0pd\n", + "D9TRn8WVaRhpu5sgoz75BczS0qelbBhFB6uH8Ky48gFGVjECuLfsPwzoV0akairl/InTe6iJ+/5t\n", + "eOlf7AaP/OIvha8V34lIhfQyXtuNRrDnGgC1vAi187uGjZG/La58j1nh/GEprBdGQfkzdsGMibCu\n", + "ZuZkUp6oqEPMZw7AOQ8QtWE/e+L3ck35pH37U3kCuBJ4M6dVsRpVuIfElTcwxr6euPII5vfxMaZx\n", + "LUfHKhv88vizbasLJISyY9uGgGMwE1n7KjfRrWo1qHYU7lmAiaEEgBJn+E82QXDLhX4Wpi0+P9yH\n", + "qZ7orY7OAgZiStLGFeAQwwgxLF/ODeJKx6iVfBhZkfNSriLirclQ46jvegzePPsvTjfe8/IVbN56\n", + "IN8yRO+zGPGdiJRo0j3mYMRG2Ppa9mt4jhjhW6mj5163iysXYvIaX4krk/tFkEK6aZZq4RVJP0wr\n", + "E25Krgod3iPxzRVcxSV7GyQvvG7bKo0TV9LL7uP+gSJ35ZZoVke3Yz7bDpiV8AiMY/W4uPKyD2yl\n", + "vhr+xpxo+IMK89j+iHZAe6yhx5TDb8D05/zZZA7rftpM5+p22r0jwGuVOMOfEZOsvA0q7Ic9rUHH\n", + "R5vSukKVXAsalgVxLIbrPFeBEg/U0YPiys3Au5Y+9wVMm7xPoi9hFC+oo0sGimz9Xmj54Llw4RXw\n", + "y/98l9rLIsF5gAoVV9Pgq2vZdvxV36t6MkpTK26fSJkDO+D1eG8aBX9lPnO5TwU+E1dmAi8tGELb\n", + "4V8RPyGFep59hlGVtdwM598E5Q/A/Hsg6RQO0nDVAV0QB9D4ff7ZcSW9Pi9LRKQtiM1jklyAKTz5\n", + "E7NKTgHexkwGecEfj392tm2nYoRr8oRdqTck07ifYV81MbnQpcAvmMl1pXop58WMkbUPZEvoB4IS\n", + "aPhtTPKUP4woS+Qu2NEF9v7d0tIV/JZX7XExwyhMB2Gu+q3ZoY5+L0ZneAqwG/iugMYWRiEgCsqX\n", + "Unh+hhFC9wT7K0YQ6cvx3hKc4kolYI240j0v4Z3sUF0ZJ66sYNjC/7MryVyvEQxsOfJ14kq/KTBx\n", + "/S/EV9gdWfFgeveqa6lCEhfCHIWhl0Ot1Tb8lJQRUmqxhetabSHisV7QOR6uWJnnJLkM6KKOviqu\n", + "dMUQ1L0nrswDbldHl+YyzD0YY5wfcgr1nODxW+euOVm9+DMwE9FSzMT0KYZEb0N+ZaTZJ2ICTPCW\n", + "QMNvY5LrLjSviv9Ag4XQ4pY0TPNJB3FlIzDfvn4l5+x7kUJcqYmp9OgdwNgexbADXl/c7isM/+Ad\n", + "Q6/ptebbeiqdxZX/AB/4Snusjh4WVx7AdNOe6StJmUUZCrDxyBvq6I/iSvT8VjxO6uHr+OHILpY+\n", + "VJeIh6Dvd/D1+3DGBLiiyWG+rvSW57goKH/JcnjtTPiwHXTdDk0O5JpoXgbcaK+nwAfiSiPgAmCq\n", + "uDID+G8OlXD5evzWY29MtuQu0BRIElduIdOLb40p+/QY+ecxetQBK7ZlmexFAvr9B13VU/jI1i5/\n", + "pBb89c1Gvq1yuzraA9MgMxKzzBuMWTLtFFem2Lb5s2zCpKjxJIbLfFUAx47E3NcDxeRewggQNoae\n", + "RSh9BGzcWYEHMd/zInHlHD9OOQnThHS9n0MpjfFCCwW2vPMuSutA+v96jP9c/A89Ju3maHwKKyev\n", + "YBLTqbX7T+5bd5tdyZAIyResg9W14OZFcO3FkCa5JppXYjSRvZ3blzEhlosxjtMSceVFMcplHvgS\n", + "6qkBpAFdxJUHxJVJ4spaTJ7uQoxXvwzTt1FXHT1dHb1MHX1aHZ0WjNEPFYo9H3/O+/tO0+wVT+uO\n", + "SaKeBbTAzL6eVcF8zUVOriAgrnQEfsA0ihzw89iGmLGfgckPrFJHHw39KMMoLOTGjmqf3csxurcL\n", + "MPkcX2LI7YGp+PF8iStLgFHq6OIgbiUg2FJPFxPueAp4TB1Nt0Z7PCZUEtt6DGd1g1dTLiK67W74\n", + "7nQ4sIV9KbO5Nkc9WlfWYyQxV3ttuwPoq45eIK7UxUhnDsN44mNP/YCr66TzyqlbWJQIyVsieG3N\n", + "Y6wjayz+TKAapjnsTzK9+Y+A4XmEkUKOk1aIpUCuZ7oIO2Mmge4YLpUETFjIMxms8nOpnPc1M0pQ\n", + "I8vTcFs7Gv/9gc7dfWcAY/8Q2KKOPipGYGMZ0E9DpPcaRvGDuFIRU9E1GlMa+aw6mpTPMeMwOst3\n", + "+XiNZcC1tuGs0ODpQl19MTHHSlPqaDr7D7VhH9/U+5ClbS9BIstz8a+NabY7jQrpZ7UeQ8cyrRiz\n", + "sQ8tz5jE4nk30UFL0ysnYyuufAF8qY5+6rWtPPAXcJk6usBuaw48JSn06DKDUvMWUa2UNYuXVyM9\n", + "7jz2JbZiPplGvh5wnjp6SbbrHQBO03zEj0KJsOEP5vqGP70FmSuCszBUrr+RmScIOGmcV1u8PyWo\n", + "lg/lOww/SKLdNhxjELqEq3tObtjV3tOY5qiHWz7OvlPTuD2n0kYxururgR6WNC2/c68GhgYYegwI\n", + "ni7Uu2oR3XM4rHkDHjrChi87l123vw8Dmf9YBL/eD+ml4dwzEui88ijl0s/iyZZtuXPDF3xyznKS\n", + "0spx3tIqxBxqqY4ezdLjM/C3+jTYs1THHR2W7V5vAIZjcoIZCdeWU4mp0YqIA+Xh2ZlGgxpO5NYX\n", + "V+7DhHDu8dqWI4VDQSNQ21kCk7uhh02erbavdyEj+doNMwk8CnQMPGlsS1BbfQ5HasLm3phJwPcS\n", + "VK9mLcdj9C0+wIQD7sUYhTBOUtga9KvFla6ljjBh9wgav/cD5bptN+97lzaqo/+IK08Ar4grA3x4\n", + "Tgs1xg+mC3UcRA/oD4/ONcnt8RC9clGFqgv/Wh7BRddBuw9hyocwc1l10puuoeY/i0nrepQ/zy9H\n", + "i9Kd+ekpmHZVEoenfSoSMy6Lg7XpG6h1cz1p0eharti2n6yVNadiOMTmYEsnW//OS5N/45zvmsOv\n", + "DTMNfw7J4yYYYZZst8PWklJsETb8ucCSNH1nX544ZDtMaGgwhvGvlLiSkScAluTUtVeFhHrN6E+l\n", + "TTs5XHs9a7t0J2n5Z3A00o/Wei7A1Pn+L9s4VVwZBSwWV76y/CRhnMRQRxcOiJDNV7Wh+dBh0G8j\n", + "vPdNjqWNb2IqWwZjaKHzQmkKqarHgygon1zaNHHdsihzeyWkDAcbwYYBcOpcuHIwLL8K5rTdS4X9\n", + "aaT/L4bly+GKwfDzE5D0cSRruvSn1bH6rB4fTZ1l0PYjKDUL6uytyOHuExhffx8x62fRbd8kTBdv\n", + "B46Ucnnu3KZQuTUkDtnHzEpCKhesgwvWZY4nh+RxE0502Hyq4S8uKIFVPUUDdfS4OrpIHX1FHR0G\n", + "NMAkeSZj6nfHAvvElV/FlefFlYvFlToxIrGxLGu6iB+ZnbyCRVuTiV2+mMgBTaHrimq+8LRY1sPn\n", + "gPvU0RN+nDbhNwb4n+ULCeMkR2Wl/DXLYd1rcMWKzPp/b+/Uhv7uBF6yse28UGjlnB4kQnKFVHh1\n", + "GpTxKlg9jA1ZJp1itIzfXAGRu+HWqZ04XtnsubstfP82GZIge+r8RezaNlRIgNLJsOMozOwOpSpC\n", + "wufCjgU1mX5xe8a0TlJH/+LxlokkRTWm+c39YXJPmNp/MT3rDkd2eo8xly7lxoS4a7ewETb8AcIS\n", + "b21VRyepo6PV0U4Yro5HgQOYVvE1G+7mi1IXH6v4dif4yxaNfXb0IK3iSifT869IYLq40jSfy92E\n", + "8Sam5bHPW5gf7m3B3VkYJQGe+v9KKXCeF8NTdu9UHZ2BKW3ML8lb6KGe3EpZtxDxOozcQFJdzy/g\n", + "jgAAIABJREFUiNppSranlN/I2orPUHv36Rk7bxgIav2cI6nxbKq+i0G3wI4zYXVVSH3VTBB1PPlq\n", + "wzoKQNqptzPjo7L0eRTE1HAkMrPe18Ts6H4K8edHsTYWpi2E0d4VQ141/Nm9+xLl8YdDPSGErbSY\n", + "ZV+IKxFnf8rCXnXp/GsjSCwL9803+9Y5dmA9FdI7YDyy38SVFzCi11l+fOJKVcxkcl5e8UNb/jYC\n", + "mC+ufJcX4VsYJR9+cujcg3nGJqqjO3I5ZaF7/LnRQcRrQpxIzCJSVjxM1ZXtIXYubH1Nf0iIk8rN\n", + "V1Hx6vc48lGGPGTpMpentEuZd3aDKYnsaPi5rj21oSRtsaItG/tBWW/9FU94Nao862OhzadQZRsc\n", + "aAzAQVocnj9qxafAbnX0+RyGXQdIzKGqqhEliDImbPgLEOpo+gBXDt6wE27IVmyWStoOG7Z5QVz5\n", + "EhOPvVJcuVEdXegpc+tfg1aJpTl+cDcNcFiez/X+EleeJbH0lyIDdkPlk4W9NIxs8IdDRx3daMs7\n", + "nwFy07wudI8fcqeDsDQSi4A1qnEZFTV6aN2XIjFHqdj3v1TT9mWPJZaRc9aWue3vpDLD/wS2pXNZ\n", + "1ReIi2h/OCl9TCXmZm9x8VBAJCaDwJSPcno/ryauJpzYsQvhUE8Y3ljcl11XRZLFO8jumanRPI3F\n", + "NK9MKX+LfNuhPK9Nhf7T9tHw19008AhV5HvBp1qs4XDllnQYkhG7hG6vmjK3ME4mrFSNi1MdOFm1\n", + "V5zqwHyI054Ceosr3bw3xojEDhSZFpFC5c5PVV5fVbosFxk4rZg8L/uAKh4ufw9UV8bp4Z+6nbd7\n", + "1pyL0xZHLJubhNMLFjQw7392AFpXW56epcMf8GYdPYEBIOv7+Rn+7PF9KGGhnrDhL0CIK6fuO5uB\n", + "C6pyeyxMGwZzcoobQkbOYBIQU/Ufus26mdO+bpH5vs/KSscb38aU2eXo+xBEeVb1XrHNMEIKj+Ec\n", + "JjJ7oMg0nybnIoANTTyI4fGJgKxqTqUF+SXtUM3+7GsTyW3FwlmwZda5CqNUTaVci/3QfB/88Y7h\n", + "7vEgsmxaOn2+ng2x02DYHPPvwtGela/5d8Edubyfl+FvTDbDb4sv6mDkZ0sEwqGegsULwNhN23QC\n", + "MMGXA1qPoWsMVLrlVLhxMJRKh8F/mfd8U1aKKs+eNrDwLmg0D1ZdZrf7VToahg/IRfPWJy79IsLH\n", + "wC2Y5qX/eaQbwahglU6Hz9hIZ15lMT8WF6rznZiiiRN49BMh2ZOUqJGt4FL2sYweey+ix9Q+6uiK\n", + "nE5sjXxO95efx78k27Z6mJxAiWmgDHv8BQRxpS/QEcMB4jMawuhoqNBjCyx7K7OJBHxVVrLspb88\n", + "7GX0ITO2GUao4DGcz58FD/eFP06BcX5r3hYebHHA7cCT4koVj3SjYpyLCFs6UKnO71DuIMXEWdiF\n", + "6aI/Adtg7GqIfyTb9ssrk/r7BdQH3gA+DoDIcDd+ePyUsDAPhA1/gcAu/cYCd6ujfhncKCjfD7hP\n", + "oFwaeDhDrrfJu/zPkGfsMowQwmM4z9sE6QJDh0LTO2DtYFqLK2f60qNR2FBHl2AIAh/zlIQK8PWk\n", + "zF6Aw2mV4T89oNoen+igCxi7MB7/CVipGvcXjPwFFp8PCZdCQt+yrI4byOFDMXwC3AyUA57xMyT3\n", + "D1A7l+8vp+RuiUrsQjjUE1Jk8IT0bhlN0/iqvFf/OI5/50iE5B4AaohESmH4XzfAKl/CBxmKSsT6\n", + "xF4aRuDwGM4zdpnX0zNhWV24oBPHgQ+B8rZi60tgga+8+oWAh4FVa07jkZGbspaEDqMpa/e+Auv+\n", + "m8DNc1uJKy2KuBvcE+rJETlVBYkrgzFqW/0AR44zut7pXD31L2p69skrJKeOJosryUAVTE+O57yl\n", + "MNQM2b37Emf4wx5/iJBBxFZpQn86/dOUrxfWQM/yO0HmaWrpATyOacfdCRsT8H0KUV0Zpxo3UHVy\n", + "L/Nv2OgXBLI3IAnw+i42Vv6e0RjSv0HAIYwR2iauvCau9Czq7mp1dA/w9JZrufhX4Y5+sGQwEUnd\n", + "qZwyh0pJyby0hFkp11BWHwRmiytnFeFwc/X4c4M6+h1mdfwucFXLGfy9ZhA1bxwMB2z/sg/FEjnF\n", + "+esBe72lEC1KXKgn7PGHDJaI7dzrYdl1sLcF/hKxQWg0TsMoHPjwXa20rzHiSgvgUuAV4BRx5SuM\n", + "5OacnGg4ChIxIrHnlab/r7dxTunWNItcSYUppEeaOWp5mZFQZQGw0tEJ4spu4Btx5QZ1ND++n4LA\n", + "LuDcAI57FmgDvNdqEdvfXU7TB8+F3+pD/41mh3yKJTyG/y+vbXnV8BfFZxMwwoY/ZLBawMuvhvhO\n", + "Xtv9T5CFSuM0WGShuA03guUIX78rdXRtjMjShnBOWm2Orz+DPtva0zetAtXElW8wk8DP6ujxghxv\n", + "RiVSKtFTv4fRA2nabA1MiIQ2FaHjzqxkb+roVHElFvhWXKmrjo4ryPHlAL89fsggLxwBzN1dg8pV\n", + "9sFbP2TdJ59iiZw8/sacBDX8EA71hBC2mubvPnCsstf2kllNk6khMDXcCBYCeAzuN6Xo/+Mezvz7\n", + "R07/z7NIg8nch6EDfwwjETpBXDm/oCQ1PZVIuyvBEz2gWQLU6ArzU2DwlSZBva7GCWRvi4BzgPvF\n", + "FbeQk9Z5xvjzgi2suOjPvlQfXgZfyNe8kZPhP8Hjt59FOMb/78XJVk1jQ1elk6HdRLst3AiWE0Ri\n", + "Yk2367DZuXW9egxu7FXwQTuzbTxEt1nNZeroS+roWRja7z+A+4Fd4srHluU1ZGWVnkqkOoeNUHmt\n", + "JHiuO0RFwPqxxuM/+3qYcxlNrfALAOroBgwl+SBgXDYt24LEbkxoLKDJRh3dkdiK86dcQsXzyjFv\n", + "YDU2d63PoS+IObCKoffn0aWcm+HP7vFXA1IDFWkqqgbAsOEPEfLpBARKTpenQVR5yu+Hq/vD6d9D\n", + "hCcMXSxqu4sNfF0ZeQzu63HwSF8Y38Fsz+ZZb1dHx6qjPYCWwDwM2+ouceUzcWWoR3g8UHgqkQDG\n", + "ToWZTaHfBphxrmH6fHAe9H+dvw9VZj6wzIqR17Tj241R/2oIfGUlIQsU6uhh4DimwibQc/yW2JLR\n", + "Mx/ilGllT3v4t0E1yh7sMrJjPivZDMPvmdiJr3YRn50xKtu+AYd5vDunJ0PPqdDfZ2qWIBE2/CFE\n", + "XtU0RfklB4Qau+D6s2FnB/hikpG/A0pq6KrgYFdGFRLI4IbPYWXkMbgt9sKsCSbM8kbn3OPM6ugu\n", + "dfQtdbQvptxyJobqO15c+VJcuVJcqZzTsXnBuxKp+lF4+3uY0pD0lU3LaFSDjklV6bo37ugpHxwd\n", + "p5cBrTET1jpxxRFXoiz1w2CMRvVPnkmhgBFwuMcDdXQi8BWla7/OFwvL0+NxiNxl381xJbsHqJ1l\n", + "Yq8YVYVdX3bONlEEHObxrAL3VYAOo+xICqkBMGjDLyIDRGStiKwXkQfy2K+ziKSKyCW57XMyw7s9\n", + "3o+SsiKBuNKWm+a1ZkWFvUx/GdTzmJTk0FVBwSb1L70C2nuLo2VdGXkb3GYJMHsCPHA2qXOvZTv5\n", + "QB39Rx0dr472x4QbvgOuBLaLK9+KK9eKK9V8Ge1K1bgFcIeHO+qRv6osPra98THd00OSBkZEHpRf\n", + "a+5n0NUiMbHq6E519FaM4FAzYL24ciemvWQ4hn78V3GliS/XDgK5du/6iQdJi4SEaHj7T0jynktO\n", + "WMlaj99O7BEpZqI42JBsE0XAht+zCtwVCUe9Ame+UbMEh6AMv4iUwuhWDgBaAVeISMtc9nsWIyRS\n", + "7LoZCwOeL3lxPTjjJthiF66F8SX7A3GlNzCTMno7vyRfl1foKgzISOr/+AKc+yBU3Wy3Z10ZZTe4\n", + "tx5gWvWpjDh8Gr3ElYd8vZo6mqCOTlBHz8cYncnAJcAWcSVOXLkhPy/cm9VzBd328cMfFai1Bsom\n", + "2XxOVg9YHd2ojl6NaYjqC6wD/oNJSL8GzBNX2vt6DwEgoMqe7FBH09gTYQjSE+tne/eElaw1/HZi\n", + "L3XcyDyml7FvZ0wUAYd6PKvA3ZEm55IxEp+oWYJDsAmaM4ENqroZQEQmARdyohDx7Zhytc5BXq/E\n", + "wvMld4qHuxZA3+tg7vuQlFjwX7KvEFcux1BNXKaOzrItYyXK0Ht0DKKgfCIkb4OxBdsDsW0sjGzK\n", + "nvHRzL8XLrweJjbZiJ64Msqly3QG8LOlHv4/f8S61dEDwEfAR+JKFIbaewhGavF3zG/uaxubzwVR\n", + "5UmuZnjpq/4NfR+GNZfAsRNzOerocmCwuNIdeBq4DyMSdAdGSe5KdXSmr+P3A0GHejKQvuMlIm5o\n", + "Rvp7jTI35riStYY/0XjzKZVg/n1eb2dMFI2AxYEMxSOm0zuS6LqWuN2HaqOQIFjDX5+srHnbgS7e\n", + "O4hIfcxk0Adj+EuECn2o4a2YdMdvcLQMtBhOSo1vmZj/0QULWzFxN0YNrG9ubIbFHZ48yttCdISa\n", + "pWVBs2VmociYX7EC7Ra146pFM/TDRJ+up47Giys9gZ+AsuLKo63HMNDfyUsdTQQ+Az6zCeABmEng\n", + "WXFlKWYS+EodzUYdbFcsm3sDveHUX6DHEzAj91yOOvqrHfMADM9/KmYi+FhcuUsd/cSXe/cDIfH4\n", + "IeP7upnIPi7VaMuu0gtIiX8uh5VsAlCF0lveIHVkU7MK8iDLRNGIAD1+TwPgz7V5MS2NqFhYUVjN\n", + "mqK+OxgnHixyKTBAVUfav68Guqjq7V77fA68oKq/icgE4DtV/TLbeRRwvTbNVtXZAQ+smCJGJLaR\n", + "V5fn7BtIONqQGKC3OppQFGOy3OwvYbojB6qjJ9DflhQMFJk2Ffp/0Qoe6QM3LoHhf8I1R5kWpzow\n", + "/zMED3HldGA+0E0dXZ/f/l7H1QJmVF/Ixkum0fZtIdpD0DcSNiyAOwIxCFZkvR9mEhgMrMJMAl+q\n", + "o9syk5fWsEXuglsap/NjjZt06Y7xPpw/AhiKYRhJwDQ5Pa+OvujvWPO4xnCgjzp6bajOac97JyZk\n", + "1T0HKUVs13I7xrTuYEJfJ3JfiSs7gU55SFr6Mo5ngEPq6FP57ivSC1NZ5YGjqn6Hz4M1/F2BMao6\n", + "wP79EJCuqs967bOJzLh+TeAIMFI1s/1bRDSQwZd0WE/7OcwXea46erCQr18emIgRkbhIHd1fmNcP\n", + "NYaJzJ4MPRVY0BDe7gTfNoeKW9mz83SGAPP8CaUECnFlNHA5cI46mubHcdW7vMffC7dR+UFLUvD0\n", + "TPPjiSX4ycs2hfXFTAIXAuuBL/i8wT5WtRmWYdiunbuD0w6foo4O8uPcZTBG1AUqAl8B14eCmE5c\n", + "GYBhuu0X7LmynVeA9zClokOzj1VcWQFcZUNcOR1fDsNzUdGf7zmH80wA5qqj/8tv3xOODdB2BlvV\n", + "sxhoJiKNRaQscBnZOCtU9TRVbaKqTTCexs3eRv/fDGuE7gcWAnHiSmRhXdtWgUy3f/Yv6UYfMvMo\n", + "Apy1DSZ+BZtehQq72AeMB1aKK6N9rYAJAq8DxzAi5z5DHU1osIMVAPfOh5+awK2DDOVzKIoA1NFj\n", + "6micOno9JnTyX6AZQ7c/y5iptRnz+XTGTB3NaYdvAaItVYOv506xdA6nAS9iqo422hVQsAhdjN8L\n", + "9vd3M6Zi6LEcdslLkAVMP8OOYIy+RR1Mo1qhISjDr6qpmAaT6Zi2889UdY2IjBKRUaEY4MkO+/Dd\n", + "gUmIfxvKLs3cYDsy52G6RC/PgW2wRCI7WybA/UfZWOFn7sU0RN0CdAM2iSvviytdC4J+wHqO/wHu\n", + "E1di/Dn2cLrRZ655BH6aCKtqwbUXw6FShPQ7soZ6hjo6CsM6eS/QAJgLLAJ+A97Irnfrw3mPqqP/\n", + "Z891FFglrrwlruRlQPNDqMo5T4A6egxTFfUfcWVItrfzM/yhomoodMMfVKgnZIP4l4Z6vGGpeicC\n", + "1TFhl2MFdJ22GCGOl9XRlwriGkWJ7HmUnJJlNp4+HLgROAy8A3wcaNt9bhBXRgI3AV19leXLLud4\n", + "tDQ0vZIj/9RgeWoVehf0JG2fw26YcNAoTCjjHcxqfYU/oTJ7rnHABZja/9eBF/0NadrzJGNCKgUi\n", + "byiudMA4sOepo3/aba8Cf6ujr+RyzHBCkHsQV+KBM9XRfHs6Tjg2QNsZNvzFCJb/ZBKm2mposA95\n", + "9tLGRecxe1937gZGW2H3fzVsYrIPxsCdC3wOvGNVqkJxfsGUby5UR9389vfAM3lVFCrtqEfLNZ1Y\n", + "e7A9O8l0Ck5IRBYExJXmGM//E0yp6HHMBPAFsNSXScB+Bg8Ct2JWEt0xea03/FGns8axczBJVB+u\n", + "McyO7Ux1dI+48ghQSR19+IR9JSaWgYmvImXKENdsbaDMtfYZPGav4zcza9jwnySwS+spQBImsRRQ\n", + "/DC75zgpBobHkha5lEf3/qjPhHDIJwXElbrA9cBIYB/Gy/00WCMrrtQHlgID1NE/Aji+PMbQpmCq\n", + "ZloCgworJyOuPA/UAG7AaEhfiqniicAoi30B/J7fJCCuXIdp4rwHs5rojEkEv++LHoG48gdwozoa\n", + "UM28rxBXHscUW/QFrsWs1kZk2cdTCXVBejTbu8IfIzEEjQvu8Nf422a7v9TR6gGNt4iSu2GEGHbW\n", + "H4L5sb1nPQK/4aGIUODFbnDfebBoAqXOnEHPUI73ZIHlxnkKM1E+imGh3CquvCmutAvivDuAu4CJ\n", + "gVAt29DOJZj+l7rA78AscaVOoGPyE49j6vU7q6OL1dGHMPQNF2PCLxMwXcMviyvdc3te1dEPMOG1\n", + "l4H3MRPIFcBqcWWYD895yGr584GDmfjfwMT4c/icLY1Dla1w0NMHFjBzbV3MvRUqwoa/GML+2C/C\n", + "VEi8EUgC0kMRsaAhvN8e5r8HbfYUP4qI4gZ1NE0dnaaOXgS0xSTdvhdXFogrwwNkpPwEo+Tkc7gn\n", + "25iOYyrmkjDUKN8Bc8WVRnkeGALYvMfDwFiPcVZHVR1dpo7+Vx1tiZkY9gNvYfiDXhdXekk2iUl1\n", + "dBomZPQ2hoK6LyYEdD+wWFwZkMezXiCVPdlhE/PXAF2BnuSY3LU0DlE74eCpXtsDYq4t9MQuhA1/\n", + "sYWlox0EtMe04Ptl/D2ljWdtg8XjoKFNWxYGD8jJAkuT7GKI0Z7ChDi2iiuviiut/DiPYpK8wyVA\n", + "/Vqb77kKYyTOxtSfzw1RuWR+mIipkr06l7GtVkf/Tx1tC/QG4jFNgfHiytviyrk2f4UN1fTAGPsx\n", + "GNbRzsCTGFnK3DR+C8vj93RBX4AJ9eQwudpu57eWw97mXtsDYq4NG/4wssI+gAMxMccn/DnWu7Sx\n", + "vI2gFhYPyMkGdTRVHf3ONjR1xFS6zBRX5oorV9k4fH7n2IMpJ50Q4KoBGwsfjhEDGYxJRM62lVoF\n", + "BusFjwaetpxAee27Th19Sh3tgKkO2ogx6jvFlXfFlYGYEsizMN7/eKCUOvolEAN8AEwSwzraxuvU\n", + "BVbSmct9/I0x/HXFleis71rRJY0gszc1YObaIgn1hJO7JQA2ATQbmKSO+jwB+FLaGEZgsJ2qgzEV\n", + "Qe0xXvE4dfSvfI77GNirjt4RxLUjMDHo9pjwynPAherowkDP6eN1PwB2qqMPBnDsqZhcxRDSaMuG\n", + "WodY1fgAB6R2RMzafS1+lCO7Uls2TiGSI6RuTuu9chE9914EzMA0V3XE9JxcGtKbynvMgqm42Qh0\n", + "8S73NQnenGkc/LzGs8ABdfTpgMYYruo5uWGrTuZiyg1DxoMSRvAQV5piqoH+A6zEVAR9nVN5nrhS\n", + "HVgOXKOOzgrimoIJjXTHVMu8AVyhjv4U6Dl9uOYpwApMpcuG/PbP8RwSE0uVmNdp3r0Jrb6EOstg\n", + "Y0Ut9ddpkrZmOqSYxZAwfKdWXjCau/9qjVltzAEaqKNnhup+fBqvK5uBXzASixeGoEs3+/knECBd\n", + "A4Srek56qKO7sMkwceWWoh5PGJlQw1f/IKaFfxwmnr9VXHlaXDkt274JmMax9yUABS2v8yiGTfVn\n", + "TBXSDcCn4soFgZ7Th2vuBJ7HxO8DRMPRHJzUhL8Gw4TZ8MYa2NxW0s4oB/ecAtFTzbWYcAqHmt5g\n", + "cywtgANAR3HlKXGlatA34wNEYmL5p1JVPjq7FfGVu7Gj/KcFcJlwVU8YeUMNc2Zf4EFx5fqiHs/J\n", + "DF8E1LNDHT2ujn6mjvbBVISUBX4TV6aLK5fY8BDqaBwmhBHUys0a/wcw/FjPYKpR3hFXrgzmvPng\n", + "FY5HdJS27Rb789lkIqo8km5kPWutNipYi7vAxJkwdiNs887rmioZdfQfjNd/HFNls15ceTDQXIkv\n", + "yKjV39+rChH3d+CjjdWJLHWxDKnyXIgvFU7uhpE/bNLpXODxAv6B/2vhq4B6XrBJznswq4CJmFr+\n", + "zeLK47YM8x45zgXt2sriYSKzB4pMC0R/2ZZW/hfT8f0qpjb+OXHlJn/P5RPGtO7L172g57GOlPoo\n", + "gM8mMRmNgOVXwxkT7DZbfXCkJhzz1lTPrJKxjXSpGN2IczAx//Xiys2eCTW0sLX6h2tDpT1mbB8v\n", + "KE2zI3eKK6EUlAob/jB8g00g9gdekouqPeGvZxpGfrA/+qbToYEnXxpYg446mqyOfqyOnoPhxa8C\n", + "LC19iBltF1Bq73l0fLsCPadC/27waiDG317ncUxj1LsYSuj7xc1dAztwNBzN6pn12N8EznzdbvPn\n", + "s7EVMX8Oh7YfQkQq5fkjtS5XZNlLuG5nDlUyu4BT1NG16uhQTMnlRcBaMeLzIbRntlb/cG2oYJuk\n", + "97SBaWf8BXwlrtQL9gp2vLUwjWKFirDhL6FQR1cyvc4TND/6IM1uD9gzDSMTMSKxA0WmVSWlKwAR\n", + "qXDZJV46ugE16GRAHV2ljo4GGjZdSMUKp1HjUDkYdCXsiILxEN3IyJQGen5PkvdDDC3ydTYmHsLC\n", + "iajyIDD9ZUjzdrR9+2xM5cuCO9h79zSOHD1ETMclFfjziVpMXVyDbglRnJdQmj5LlCUjcqiSyVLL\n", + "r44uUSNAPwITCloqrpwfmvu1tfozn4b592Zu/rPWNkwD2le+lPHmgxoYARa/OXqCRdjwl2QsaH8+\n", + "H88pxUXDobZHLTHg1vF/NTzcRlOh/5kcNPGG9YNg3oNw5flQ7iABNuicAHX0SNv57FvwHsyYCK33\n", + "QJtb4OLLIKE19YPxXNXRlzEJ2MmYmv9+wGuh84atQdzbAn73fsx8/2xUV8apxg2kzsH7uWT5pgSN\n", + "d5frgc57dUGNQzqjRor+3CmX0sgcu3dtdVQ3DN3Cs8Av4so5/tzVibArE7znkIxa/ScxvRTjgpxk\n", + "iiTMA2HDX8IRVZ4dXeB/v8A/rb22B+eZ/hvh4TaKj4JbWEtTLjNv/HY7bO4FV7Q4Stm/3/A+JpAE\n", + "sAeezuquO+Dd72DryxC7Hlb25lSMgMlDgfLxqKNvAv+HIfu7GUM9McHTPRscPAbRGwE3L30G9LMl\n", + "rr4g1yYum+v4GnOv4zDcSHHiyhkBjCtzZULsNBg2x/y7cLTqyjibVL8e03B2bz6nygtFUtEDwYut\n", + "h1GksN7XvubZtofGM/03wcNtNPAqWFMriagVcVRZ1JnDx6NSUpckb+fqf0rz8K5bxZUdwFbcVl3g\n", + "rFezinCPbCoSgy+NPLazuqmHPTXyOPz2Bxsb/8HoVWPYg2kMWyuuzMD0BcxSP2QM1dF3xZXjwDeY\n", + "WPjjwOfiyuUahNZDFnH5IJuX1NED4kocJiH9Rn774wNtg62znyiufIYpm50qrswG/utv74G9pxzv\n", + "Sx09Iq5ciKnaWmUrtfxFkXn84QauEowThLIB430Zz6ToRlby4BFqB0iNgJ2RsLUKjDyFZWti+RRo\n", + "ikmaJgIVSYmI4sDppTjYCPY3hR/etGeKnaYa55M2bn6d1eJKFQw/zyiMju07wAR1dK+v9yWuXI5h\n", + "xByM4cepClxsuaCKHOJKP+BJdTTfShlbwtxDHR3ux/kjMQp3d2EopB8PJae/5RX6Guipjq7x89i7\n", + "gUbq6J0BXz/cufvvRKhax//tyK5fAIbbaCGM9hhjSzuwABjFMxfeT9RTZ1NlK1Tca8oTARg2R3Vy\n", + "r1COzcaRu2Aawy4EpmISjL/kx4Nvj78UeJNMiokWGE7/A6EcZyCwDJ6bgYHq6Mp89h0I3KGODgjg\n", + "OjUwPQ83YAjunlFHE8zvp+Fok7ROTA5EUMVOSA9hBFx81kkQV54DEtQJXB8jbPjDCCNI+Cjb2EVS\n", + "+bH1/yql14jvVPUw5VjLaJIYZPfw3eMPBGKE4q/BTAJg49m2Iziv4wZjDN5FwDBMg1l/Sx5XpBBX\n", + "ngTKqaN5xsvFlfaYFU/A+ghihHH+CwxhS8Uf+HhId45/0DRzj4AFVV4GWgOx6oOwjD3mA2C2Ovq+\n", + "P9fKco6w4Q8jjIJHjEhszXa8t7EPdRe+C/UT4TKaEserJPFVoYXZ7CrgbIwHPwjTvfsOsCC3VYC4\n", + "MgDTTDYE0wF+GUZjdltBjzcvWGrpuUBDzUNu1HIF/amOBi1CI640Y0ONOdQpcwq/PAxLboQ0j06O\n", + "/5O3TZz/AKxWR+/y8ZhpwNgA8wPmHGGunjDCyIpgqm5yQ0MYPXsZdW9ZBHdY0/AZG4nhqr2FmVux\n", + "VSy/qKNXYxSxlmPUsJaJK7fa/ECWz4AxA+7km3ovYyQT52JWC7+IK80KY8y5wTYkbsTmWPLAHqB6\n", + "KKqT1NH1fNTnLz6Og2ZToYt3UZL/VXGtx9Cv9/OUqnCQUc3PlhU+NuKFq3rCKPnILu6+DcYWFQ10\n", + "zolv36tucoOn+ufBeZDoJaTYkIOrFuiBIrlXm+x9UVx5CSOEMgp4Qm4r9xsN+7Vi27cNM+rRl45s\n", + "SvrU57l4x6eYkNETGE7/AeroilwuURh4H8Nu+n1uO6ijaeLKPgxfT3zwl0xMZld7+DgOxLtgyr+q\n", + "OE9+6M2jRG/8EHr8h5iGOyp8UEb6bE2lZmIeuYNwHX8YJRveDVCTCZ6CIHg0GE3VR6LxdIvdAAAg\n", + "AElEQVRp9UXQtAve8NTfC1DZqyiyOCib2VXAz+roZUAL1tdrwiWrGjKqI5yyxO41PpplbXtjYv0f\n", + "YjzOuzHCMl2KaOgAnwN9rfZEXgihEpdXT4J6TKH/PQkNYfQ4iG54N1Q7Crd+VZ5ll2rN1CoTOuTW\n", + "UW+T2jUpAroGCHv8YYQIngaoD9rBn3WhxlHocITo+cKT4soxIAEjYr0POOJLNYo/sNwpnYFOQCce\n", + "KNOHlO4Q3xn+GOG1Z3DNbdnr76F4Kpupo7tFhu1kxqTTOW0mJHpTy0RWUEfniyuDMB72TZiGpO/E\n", + "lcuC0QkIYrwHxZXvMTX9eX2WIdPeDVVPQhSU31oFRKH2YZi/IYa0BZfB5RfC/+ZBSiWM0xF7O5l9\n", + "ATWAg3nlNAoSYcMfRkjgCYGcehD+qQQJFWBbXdhbjQYYvvgaQHX7r9gl+z6yTgh5bvNUS4grtfAY\n", + "ePPqDJQBFgGLgbcY1608++f0OnGkwTW3rVSNixEhtkQom1kmzI39sm03n4E6usgmfOMw3P5DMU1e\n", + "N6ij3xXyYMHkKJ4jb8MfUgnGvJq0fEUiJC+uB53izUrwGJVg/j1QZQvUXAc7O9g9szgdRRbmgbDh\n", + "DyNE8IRAem02Lw+2weI41SwVEpZHvQZZJwPPqx6mFd7zdy1MTDdS3IxArGCEOXYDWzCt/5vwnjii\n", + "tn7IgRGN0He9hFACphbIAmvki6Ghz45tY2Fk0xMb/DI/A3V0qW2imo6pcx+E8fzvUkcLQngkL/wM\n", + "1BBX2qmjy3LZp9BE133FNhjrNOLMofFUAyjHYUBgavZHLYvTUYciSuxC2PCHESL4EwJRR48AR8xh\n", + "mRBXKgEdyPTkm2N+5EsxnvwajIE/jJkwvCeNFnhPJNdvrsG6z2rz+zLleGQqEUeO0XFtMm0PjRJX\n", + "hpDPCiMQWoNQNAOFEr6GMtTRFeLKucCPGH3bc4Fp4kqUOjqu0MbraLq4MhG4DpN3yAm78HrGigNW\n", + "qsaVuVc2T5nBplWQtJP1lYTh9ZUJXiuTE5yOuoQ9/jBKOvwNgVhK23ZkDdc0wWi6LsYoVD0FrA1G\n", + "51RcKYfRS62R7eWZNKJz2FZDXEnhxHBT7qGp8U3aI72fQN8LaRVRsPA1lKGOrhZX+gAzMZ97T2CG\n", + "uFJFHX2+gIfpjQ+AX8WVB3KJf+/E9C8UG4grQhSNl19Cq2XLdBd4nIA8J9wiDfUE3cAlIgMwos+l\n", + "gHdV9dls71+F4QgRDM/Jzaq6PNs+4QaukxhWISmGTAPfCeOhr8UY+cWY+PyqouAmzw7bHBVJzqGo\n", + "nLcdK9WIMpQhuQq8uslLSapgO3lDDasR/BOG32cKq6LmM6tdCnvrboOkQlnFiCtzgRfV0W9yeK8H\n", + "8JQ6WmyMv/3M5qqjDfw45jnMyvLZfHfO6zwB2s6gPH4RKQW8jlka7gAWici3qlnIijYBPVT1oJ0k\n", + "xgFdg7luGMUXtkytBVmNfBsMH4sn+foesFwdLfISyJxgK44S7WuzL8eIDJuNfNqTCvvhmLeGesmi\n", + "yFZHN4krvYCfmFuzHbMuTLV5EpsrKYRVzMzaS9jUdJyMGXZXDiGzYhfjxzzji/08pi6wugDG4hOC\n", + "DfWcCWxQ1c0AIjIJQyKVYfhVdYHX/r8BPs+KYRRvWHGPpmQ18u0xy3GPJ/8ZsNRqpp7ESExGSxlt\n", + "1iwoeRTZ6ugWcaUnG09bh75biah4OFwL0suQQ1liSGFCJIMvgHdrY5L6ZJtsQlbOGUIEYvhLdFVP\n", + "fbIm6LZjWARzww2UiGqIMLLDhj8akdXIdwQOkenJu8Af/jAUnjzIv4KmJEEd3SGPX7QVaMlFw2HJ\n", + "SFg91L5brgCdt4aj4d3TkHToMtYI4WiWySYJUw4cpY4mFtw4/EJHjOqZPyjRVT0+JwhEpDemSaR7\n", + "Lu+P8fpztqrODmpkYQQFS4jlbeQ7AWlkGvkXgSXFgd2xOCCUAiXFBmnHahEVD/UWwade4fZ6u08X\n", + "VyoVDKe/FTlv+Cuc8T4s9FDVm5CZOqriiifcU+SG3656OwJL8ts3GwKq6hGRXkAvf4/LjmAN/w6g\n", + "odffDTFefxaISFtgPDBANWdvUFXHBDmWMAKEbZPvSKaR74xpyPIY+XeAkUB8qDtuTyaEohmoeCFt\n", + "JzHX1mTtxZDqSVU8BE3iDwPTxZXzQ8/pb1XlWk/2WmFAtpCZJ9yzPrTXDghNMR24//h6gM2D1QB8\n", + "PsYD6xDPzjiXiOPvOSB4w78YaCYijTGkSZdhWq4zICKNMNqfV6v6J30WRmDIiyzNsjZ2JGsZZXWM\n", + "x7IY+BijVrS5OBn54lYj/+9AqXjabm7Dj3WBMZgF30CY/+dvnLdlPfCzuNLfH6OXP7aNRUY0pVVc\n", + "NBM8zBEnhMxC2r0bJAKJ79cADhQVXQMEafhVNVVEbsN0/ZUC3lPVNSIyyr7/DqYhpBrwlhhB+hRV\n", + "PTO4YYeRG7yVpA6XgaWnwF2N6Fj2DlmRUp36mLzMn5iH9RuMKMV6f/RcCxsFxbQZRj7otOxrIg/0\n", + "ZfOa0ubnDTBiI7rtNYwK2P8Bc8WV89TRE1b6gUB1ZZz0rdWalMP/5dBDq2myvT07Eu/WY2viwDzf\n", + "dS+lc/V9tBs4Rq4vSgZYi0AreoossQshaOBS1amYh8B72zte/x8BjMh+XBgFAw9Z2sIG0Oc6iNkD\n", + "neOpmbiYmuv6MQRY46tCUPFBw9EwPpozX4fSyabC5MhF0aQte1RcWYtZMicVpxXKSYHzdzYivvw3\n", + "6OBKueQt/iuuHMRw+p/nr5h5ruixtyHwvB6f8rgVSi8FmU7Nqf/Q6EgZeAqiR0LTGBGK0Ph3BJ70\n", + "85gireiBcOfuSQcPWVrHeNj/DJSzPa/DIGHtr0XKtx4ETMIvMmE1Lfb/QCWSOVw2jbXtD5+RZPhd\n", + "agGlxZW9mEkgp3+zb9tXlEvt4g6btLyKesmDVeOW57afOvqCuHKITE7/PHVzfbzuEKCP3TQBGA58\n", + "5XFq3kuEXxuZN8dDdCwUWHmpD2PtgP+J3SKt6IGw4T/p4CFLK5MtcFMc+OIDR2JyJD8Qu+FHPmNr\n", + "xtYrd5bT5XHcslI1zov4rRaG59z737Y5bKsuriTh+0SxFzjkvaoIJO9QnMRq8sHZmKRlrkbfA3V0\n", + "nLiSiOH0v0Ad/T2I63YH9qqja+3fXwAviyt1hlqnptFBWOC1touEomqSOx34Jz+94xxQ8kM9YRQv\n", + "lBS+eP+wbWwrRpzzGbsqpgvsioR6ifAJxyp6vL3ciN9yg/XWqmEmguyTQl0MxUT2SaScXVXsZVmV\n", + "dCIHNSXp48iMk5Yd3k461B/LhfE/YCcPbwoK7/yLZ1sxCFXkhquBj3zdWR391Br/78WVYeoEXI49\n", + "FCPK4jlvkrjyNXCVx6k5b5N5eVCETk0n/Pf2IRzqCSPUKFl88b5BdWXcBVJ6I9Dm3WoVueO6VLq8\n", + "3I1yHOYA6+sHdE6TzPaQrK3z5RhLLGcmih87jOfwx5FU/RuqbYK/+8LxCXX5p9u9EH+V3a+GuHIE\n", + "u2qoej2npe6j1n1HYNgq6BxftKGK3GDv81LgDH+OU0e/F1cuAyaLK9ero7nKKOZy3Qh73b7Z3poA\n", + "vL5VeGCkFiunJpDELhjDH1RILFiEDf9JiJLDF+87UkiL/4HINs8mDCS51BzmVPkADp5KOa5sKhIT\n", + "WxjVPepoMqZPZbuMGWaalyrtgSFXwLjFcLARbG+4Qp0FvSDDkFXBrhqaLeGdsyOotbdihgIuUKSh\n", + "itwQCyxTR31aPXlDHZ0lrgwGvhVXRqujn/lx+FkYwZ212bb/AlRa7bBbxnBHMXJqOmGqFv1FONQT\n", + "Rhi+YBuMHUGrc3YxuSJbh0CjebDiVI7xScWC5I7JHbbRaEcXWHA3XHI1fPAzpP9/e2ceJkV1LfDf\n", + "kVX2MQQEHBAZBAEVULaIMkZ0GFCTaMTgbgyaqIC+mAX1WVMhRoOJ4hI3NERiovKCOzCCIhqVRSKy\n", + "qwwIsmhQUVBBRDjvj1sNTdM93dP7zJzf98033VW3qs7tnjl166z7Eo2Cp4rPgp9VpWWy8TJnQtqP\n", + "PPS/VMnME4l6Oj+o718uvjRTTycmeOh+Zp6w8+0RX/4GXLJMNS+ejoIkrGOBt5I4POemHmu2blQL\n", + "lqlO/5jWqwFYVQoNt4btzUUFzLBG3a//GnbXg+8ft6Wy2jyB/2W/kMd0mCp6iAwtFSkfLjKnVKQ8\n", + "lQb34sshOFPL1FRkUk+X4mr6Xy++/DKB64aieQ5Q/AGTgRFBf4V8oCvwYZKZyxbVYxiJsptdm4Cj\n", + "WXRZxJ7sV8DcrzaPNjmY53bv4aqlPRmo22Idkwn/S8hhfN9BFO0RqL87ZYfxj4EX1NOtcUfGQT2t\n", + "COrnzwoyxr1Kci1CZp6V0Xaqp2vFlyXA6aR4U0oTSTl2UynXkE5sxW9UI8JW2XvJXQVM1WXTVaeX\n", + "qk4p1i1zvk9dvRh4VHwpiHXMMtXp01VLp6gWT1ctTdU+fZgw+pQeFHW7Cp7q6rZNhKL2zmGcDCmZ\n", + "eSIJ/AQnAWcAE4KVfTSimnkimARcmi7ZUiRZx25LXLmGnCZRmuI3qg3OgTt3DAwth+GvuN/zRudL\n", + "2Qb19DngOeDBoIx1xhBfRHwZ9vrVDLx9ANw7zUUKhUjGYSy+HA50A8rTJSdAUMH1ZJyyfFh82c/S\n", + "UJmZJ9yMdcotXMRuBgWVY3NNKhE9OTXzgJl6jGpGZRUw8yQ56lfAAlzviYcycYFQ+0GgoMPrvDf/\n", + "LXpF3mUiHcYJfjbnA1My0f5SPf1cfDkNeAp4XHw5P6yh/QDgs0gzT8iM9Zc6FNXfDeyEohVs+6gx\n", + "48hhGZjgxnUMsCiJw3Me0QO24jdikE6HYTYIKYkZUDIFBs2AkgFwZ7blDkI+fwLcIr4clc5ziy+9\n", + "xZcZuIbkDwLH8BY3Xh7HYZzIZxM8oaTVzBNJUL//DJzeeSbItgZn5pkSOb4QRj8gFA07D6Z1dtsm\n", + "vUmzPQWcm+knqjh0Az5QL7Y/pxJyHtEDpviNKOSLEq0KoTouX9WD4y+HCf3hTw1SsnUnjXq6ArgR\n", + "eCxIhkoJ8aWr+DIFeB5nSuqink5WT3cvU50+F8YMhfLh8MpQKJ8Ho8NX86HPZns92BOoyyh+gN5A\n", + "AyC8VWraCVb5w4HNuJr+LYhh328KDf88AHbUgxIXz8XAD4A61MWZWnJFsmYeMFOPka+EFMWd/eCF\n", + "IiipgOsqKLrm0/zKMA0nVJyu0S64ezrc1Q9+NwiaruIY8aVrlKSgTPMgcBpwK3BNnLFREV/aAx5w\n", + "JvAn4NJoXa/iJeyFPpuyYijYAWNfc9sj/AAXAI9Gi7pJdy8E9fRb8eUS4C5gHq4G0gHRPGs7Un/O\n", + "CfDmg1A3qD0lQKsVrF/Xn0twjYJyQbKlGsBMPUa+ElIUFy+Gy96CZa1g8EUw55cUiy/3iy8/FF+a\n", + "5VrOcEJ1XAQYsAEemwrL7gXdyQ5c5cgXxJdhlUSVpJVAgY4EzhJfhlXlWPGllfgyAWdD/hDorJ7+\n", + "MdlWh6HPZkE7OO7DfdtDfoDAZj0C14Rnf1n29kKYUQJTBrnfA+5025MnSG4bhevZ/B3xZb/SG+JL\n", + "0/+MoMNRM/moQ1hg6c9g9Z613Aycm46nqSRJdcVvit/IP0KKosXXcPZKmPgcfHAH9HqcN4H3gCuB\n", + "jeLLK+LLWPGlV7YUaiyiJUfd9AWrm01jNNABp9R84D3x5ZogrjyjBFUbL8BFssSNRBFfWogv44CV\n", + "uHtYN/X0xlTbG66Huy4TKt5qA8dvctsi/ACn4GzWe2sWBVFDLTni4BvpfmoRJ4yHji8FeycWQft0\n", + "mNAEaItLzvq3+HJE2L6799Sn/NPFXBZpxvpgpT6CuymemQYZqiawL/Vx2ddvJ3kKM/UY+Um0Cp8j\n", + "YfW2jdyqnk4Hbg8cc4OAIcBjQAvxZSYuFHBWetvxxSeB5KjJ4svfgf7AaOAm8eUx4O5MmoHU01fF\n", + "lweC65dE63QWfJajgOtwNvze6um6dMmwnO68c2jDb/Z8tWJP5x3Hbm3HytV72OotL+N18aUnMBbY\n", + "IL7cBRwOdAx+72Lou/XY/AR83hH21As7a1qypfvjSj9fJ75U4Lp5leAiZgYAvZepfkV0M9bfcHX6\n", + "D3AKZ5juwBr19Mskj88LU48pfuMAEskwDcog7+2+Jr50BEpwjrt7xZdVuJtAOTA/Gwkr8Wzdgfll\n", + "LjBXfGkL/BxnBlqMW/1Oz1ALynG4BtnXAeNDG4PV42U4R/AbwEmxMleTQXxpzKMdLqRe8U27Wxe3\n", + "YeNMtvDPgi3NRhxN6bQn4AsB1uHqyv8NeB/X2GYt8L56ulWktBymlhx49rRkS++N5lFP7w81dMF1\n", + "3Bocx7T1FHC3+NJWPd2UBlkSJRUzD+SJqUc0D7rViYiqai7Ds4w0Eii0AbingRLcCvIl3E3ghWSq\n", + "PmaKoPbLcGAM0AK4B5iUjpIFEdfpgHNGDsMV9hqBMz2tAm5QT5NJ/28AtGffCr1jxOvmTOr7Levm\n", + "N2bYlfDpkTAv8DPXKZnN/84cDJwHnK+eRrXZR+93/LPVqSbOBabBD4DTgiiokK9hKXAYcLp6+kqc\n", + "c0wEKtTTPyYrR1UJnt6WqadVyhYX6TGUg9qN5sZZp/H7U2exZ+Od6Ug8TFZ3muI3Mo74ciguwqUk\n", + "+L2Z4CYAvBrEvueUIC68P87kEjJfpcUMFEqeqtOEwnd702nN99i8pyHrgesrU26BImzHgQo99LoV\n", + "sBG3Ul8b/A5//RFl58yGKYMouRaWngeb+gDQnH5LB7Bg05s/pU+r5Ww4aD5jYyW7OeXfflSMvrtJ\n", + "Ib58D5ionnYP2zYO6Avchvv8Lw5Mi5Wd42GcLyQrikx8+Q9wtXqacNjr3ptnk3FF/OIYuG0zrvTI\n", + "3DEpf46m+I3qQFCkqjfuJjAEZ899jX03gvdy3TQ9zAx0ObDXDERZ9yHJtFocAHeO6EjR9afAjrpQ\n", + "8AY7Pl7Kj1d4lONsvrFW7O1wN8m1HKjU3wc2xjOhOVPNjP1MNU2Yxhmcvf2OxjsbdRkFG/8M1+yi\n", + "Yi6MyVams/hyB86+Xxa8HwQ8DvRSTz8SX/oDzwCj1NOodvzgZv0ucKF6Oj8LMjfAldhuGZg6Ezsu\n", + "9B20XuzKd98Xan09tFx1emlKMpniN/KZWCUDggSeU3A3gSHAt+y7CcxOMjsyLexnBvpG2vLqcfV4\n", + "88WW7AwFBMVftfXpJHObD6T/+y2g3wZothPWFsAr32Xn181RXDhjNKW+FhdpszPWuROaQxRTTV/a\n", + "bJ/PR43u7Af/aQuTn3Lbh0L5dNWUFFFCMjkzzzpgiHq6PCgF/TZwhXo6I2zcMTgf0k3q6cMxznU9\n", + "0F49/XkW5D4eeFg9PbZKx8nwOTBlEM3WQ8fZsPjiYM/wV1SnFKckU5K605y7RsaprNesuhXmVGBq\n", + "sILrhnsauBL4u/jyFvucxIsjna/pTi4KJ1C6fxdfHmVK77kc27kf13R0JpMZd4JOLAo1gTlAjj6L\n", + "n2HYh6c1OIted8+Gs1fAH06Cjp/BGe/BloYc9ObZ9FJPl8eTI6U5hJePDkw1rfm4HXD0d3bAz8Pc\n", + "lFnsBNYPl7S1PPjOJwJTw5U+gHq6RHwpxpV1bqae3hHlXJOBxeLLtepppstzJ+nYDZr2bCsMU/qQ\n", + "i3LiIUzxGxknlAn8TBeXgTlsVfRes4GJZ3nwExky+jjQPDxklLLufQ50PI7sJNKDdFbsVE9VyoZ/\n", + "TcU/oekm6DQTtE6wt8nB+62qC9ZAcRl03jKYNY0nnfj4V6+O/IZTAf40c985xx9CBfBX8WWgeror\n", + "XbJGlT+isF2pSDlw9AVL9h+XxU5gw9lXomEk0AnnZD4A9XRVRE1/P9wUqJ5uqHedrO38KnOHl8nn\n", + "GS7Ol6TiX38XjOx0oIM8N+XEwRK4jCwQygRu+g1cOwTOHAFrCuKvMNXT7erpDPV0jHraBRcp9AZO\n", + "caziqrWPcfKhRRS+DgeFTN1pSy6KIFi1fdEW3r4kbPuXO9xK/8EiSkfByL6wpRPcubkOk0867MNv\n", + "mBCt69bHn3Edrgn779Iva+VkqhNYIoSXYA6K2N0MjKjMpKWefoCr6f9D3IJgr2mjh8jQAbNp274L\n", + "x2ahrlRSpRrysZy4rfiNjBPKBP7++7D0Xrh9APQdCY2X0U58OTjRR3T19H3gfuB+8aU+s3rOp/Db\n", + "ngwdBVsL4fFngpGZaMVY2aqt269BYMMAeMWD7S33yhErJ2LFHp0uviwEFrUskW19ZjIoW+WkM9EJ\n", + "rAr0A74AVuPq9FyfSO6Cevpf8eVkYBrwkPhyuXq6uxBGP7mUQ9sPhk8aQcvt0Z8mU0V8ORiX77Ak\n", + "3tio8ldSTjwXmHPXyDjRbPzDC1j39EWs31VAO1wRs+eqGs2zX8RKnW9gd/1gT+rREtGvFz2sMVrk\n", + "TKJyfKdUbtjRnbJ191H3u0GcyEiyG2GTTcSX23GKvzkuXv8c9VR7iAxtC+OaQsedwDZYswVuivwM\n", + "xJcmwNPAFuCCc8qYOQUGbWvgHOchhsMrU1SL0yh3f+Be9bR3us6ZDpLVnWbqMTJOtNLBKz7jym8m\n", + "6Im4kMnxwPPiS1GcU0UQ1opxr9LPnO10v1aLOr1036N68i0h+5Zz4tVLqHvpDyF010uxdWLeEmbm\n", + "+RA4C7g8pPT7wkMzofdUKHgeCk6E446EiZEmm6BUwulAfeDpbcIu2F/pQ0b8FceRWsZuXpGy4heR\n", + "ISLyjoisEpHfxBhzV7B/sYj0SvWaRvUjVq9Z9fRFXCz/HGCe+DIurEFHpeSL7TQVOZpCw9/Phu31\n", + "4N2W+7ZnMcImm/TFKWQPuCAoYkchjP4rtJnUE/7d3g28GegObaPdAIOEv3OAT+f+iDY/gzXh+zPk\n", + "r0i1VENekZKNX0Tq4FLcB+MyCN8UkWdV99nsxN2xi1S1s4j0A+7DZUgaBgBBq7/bxJd/4urOrxBf\n", + "rgWejmf+yRfbabJyfAFf198NLz3iSlWGyGKETcYJ5XB0+AHdd8F3du7g6U9e0FdD+0PO/wa74aIf\n", + "QectMG421NkY+waonu4SXy7edgz3/J8wePXTdRbX3d2o/ZfU15W0/XwraS+5dDxO19UIUl3x9wUq\n", + "VHWtqu7Chdz9IGLMmbhWcajqfKCFiLRO8bpGDUQ93aiejgAuBX4PlIsvR+ZYrIwSirAJV/rZirDJ\n", + "BiH/zjShZM8RHPbCXA7+0Uz6hptwQs7/85bCu/e4nIdzhsM/zoN1h1Mv1rmDnI6rth3ScNGcKxsf\n", + "9WLTdwrm8ckhW1lyXDp6BoQQXxrjQk6XpeN8+UCqir8dEF5wa0OwLd6Yw1K8rlGDUU9fBnrisnff\n", + "EF9uCf75ahyJtE6szoRyOBa0g8bfQPfNMBE6hZtw1sNdF9Xnc4D6u+GK/8BP7oYG77PtzfPpKr48\n", + "Kb4cHe386qkysbg5i8bW59IToenGYE9aw3p7AstTzaLOJ1IN50w0CiPS65z7UCIjrwmSmm4Paubf\n", + "BqwUX34J/CvXtXzSTbxy0tWZkBmn3Tb4y/R9iiDchLO8jFc+WMG333+Odwp20GonsO1b1jAXT0uY\n", + "A/wCl8A1Byg7sHBe04a89lvY3AO2fzdse9rCemuUYxdSV/wbgcKw94W4FX1lYw4Ltu2HiJSFvZ2j\n", + "qnNSlM2oAainHwIXBEW87gEuF19Gp7NuvZE5Qmacwm3uJ0SED+PXX3Rj5uwn9PwYp/lzUA75alyz\n", + "lnLgd+ppRVAqw1X4fO/0iMPSVhLheKDSEtHZQkSKgeJUz5OqqWch0FlEDheR+sC5wLMRY54FLgIQ\n", + "kf7A56p6QCMCVS0L+5mTolxGDSMoX9wbeB73zz9efGmaY7GMOCzqz6IRzdmvJEW4DyNoKH818NvK\n", + "zqOefqme3orLBakA5snVDcop6P4XGNsSbog4Iq1hvXkT0aOqc8J1ZbLnSTmBS0RKgQm4rjkPq+ot\n", + "InJFIOQDwZh7cPVWvgIuVdW3Is5hCVxGwgT1/f+Iq+p5HX63bWj7jBRqM5JHfDkcWFD4BDf3WMmQ\n", + "aFnC4ss/cM1UvCqeu4CFhQvp9tURLD8XZg+GHYtwamj+J7D+4rQ0OnGLi4+AFpmuqZQMVpbZqHWI\n", + "LwPZcdAjfNyyDc/NPpiPQz090tPkwkieoInMHOAZ9fS2GGP6A/8CusRpsxj9GjJ8Do3uHcQJ46HN\n", + "WzD5xWBP6uWOw2Q8CRivnuZlCLqVZTZqHerpa1KnpILjzziCS4phyYXw0h/g233lknMtYy3mRmA7\n", + "8OdoO4NCaxOAsckofccXX7O9JcwaDxIet5/Wcsd5Y+ZJJ1aywaje7GnegAVXw73LYcchYaUbMlGo\n", + "zUgE8eVE4Apc68RYmVQjcHaZfyR/pbBSGRpSZWkv2VHjInrAVvxGtScol/xVK3j1xrDtuWtyUZsR\n", + "XwqAR4GRQURWtDGNgFtx5ZiTTrGN1mQmHf2AIazBzzWNTuJfR3eQsh6ba5Lp0BS/Uc3JvyYXtZXA\n", + "fPMgzq7/fCVDrwPeUE9fT/WamSjZsbexToM/FdGoHWx67QT4xZ3pbvCTS0zxG9WaTK76jCrzU6AL\n", + "cGGsAeJLO2A0zoSSpxSOholFtHkZPjoW9tTFLSxqjt/IFL9R7cmXQm21GfGlK858MyionhmLPwAP\n", + "qKfrsiNZMjRtCECzjfDBiWHba47fyBS/YRgpIb40AB4D/lc9XVHJuD7Aqbingjwm8BstuSBie83x\n", + "G1lUj2EYqXILsBZ4INaAsPDNG9TTL7IkV5Ik31inumArfsMwkkZ8GYJritIzTvG84bjCbI9kRbAU\n", + "qA1+I8vcNQwjKcSX1sAi4PyglHascQcDK4GL1NvXgMVIHeu5axhG1gj65/4NmFSZ0g+4FlhoSj9/\n", + "MFOPYRjJMAYoAMoqGyS+tAH+B9etz8gTTPEbhlElxJdewPVAvwQqVt4MPKSerokzzsgipvgNw0iY\n", + "oAXmY8A18ZS5+HIcUEreh2/WPszGbxhGVZgALFBPKy2uFoRv3oGL7d9W2Vgj+9exdvgAAAenSURB\n", + "VNiK3zCMhBBffgycDPRKYPhZQDNgUkaFMpLCwjkNw4hL0CJxIXC6erogztiGwArgsgQifowUsHBO\n", + "wzAygvhSB1dq+fZ4Sj9gDLDYlH7+YqYewzDicQOwCxgfb2DQD/lXQF62KjQcpvgNw4iJ+HICcCXQ\n", + "O8GmKeNwSV0VcUcaOcMUv2EYURFfWuBaI16unm5KYHxP4AwsfDPvMRu/YRgHEIRj3g9MU0+frXSs\n", + "9BgqMqScjQUvM7voU8q6n5AdKY1ksRW/YRjRuAToTpxSC3vbFHYdVkTdjfDaohY1rU1hTcRW/IZh\n", + "7If4ciTOkTtCPY3TfKRwNDxYxIl/gBduD2tT2H5UFkQ1ksRW/IZh7EV8qY8ryeCpp8viH9G0IQhM\n", + "fhF2NgvbXnPaFNZEbMVvGEY4NwMbgPsSGx60KdxP6UNNalNYEzHFbxgGAOLLacAIXMZtgin9Nb9N\n", + "YU3ESjYYhoH40grXTetC9XR2lY6VHkOdTb9mtinMZ5LVnUkrfhE5BHgC6IBrtDxcVT+PGFMITAZa\n", + "AQo8qKp3RTmXKX7DyBFB6ObzwBL1dGyu5TESJxe1en4LzFLVI4GXgveR7AKuVdXuuBTuq0TkqBSu\n", + "WS0RkeJcy5BJbH7VExd/X1rOk+3X83HjE7i16xu5lind1NTvLlVSUfxnAo8Erx8Bfhg5QFU/UtW3\n", + "g9df4hout03hmtWV4lwLkGGKcy1AhinOtQDpZm/8fetbS2jycTv+ubg5Xw+83W2vURTnWoB8JBXF\n", + "31pV/xu8/i/QurLBInI4ro73/BSuaRhGWigcDROLGHINVJTAZ52w+PvaQ6Vx/CIyCzg0yq4bwt+o\n", + "qopITGeBiDQB/gWMCVb+hmHklKYNAXjiKfj6jrDtFn9fG0jFufsOUKyqH4lIG+BlVe0aZVw9nONo\n", + "hqpOiHGu3IcWGYZhVEOSce6mkrn7LHAx8Mfg99ORA0REgIeBFbGUPiQnuGEYhpEcqYZzTgHaExbO\n", + "KSJtgYmqOkxEBgKvAktw4ZwAY1W1PGXJDcMwjKTIiwQuwzAMI3vkpGSDiBwiIrNE5D0RmSkiLaKM\n", + "KRSRl0VkuYgsE5HRuZC1KojIEBF5R0RWichvYoy5K9i/WER6ZVvGVIg3PxE5P5jXEhF5XUSOyYWc\n", + "yZDIdxeM6yMi34rIWdmUL1US/NssFpFFwf/bnCyLmBIJ/G22FJFyEXk7mN8lORAzKUTkryLyXxFZ\n", + "WsmYqukVVc36D67k66+D178Bbo0y5lCgZ/C6CfAucFQu5E1wTnWACuBwoB7wdqS8wFBgevC6HzAv\n", + "13KneX4DgObB6yHVZX6JzC1s3GxcsMLZuZY7zd9dC2A5cFjwvmWu5U7z/MqAW0JzAz4F6uZa9gTn\n", + "dyIuFH5pjP1V1iu5KtJWE5O/+gIVqrpWVXcBjwM/iBizd96qOh9oISKV5j/kEXHnp6pzVXVr8HY+\n", + "cFiWZUyWRL47gFG4sOSPsylcGkhkfucBU1V1A4CqfpJlGVMhkfl9CIRKiDYDPlXVb7MoY9Ko6r+B\n", + "zyoZUmW9kivFXxOTv9oB68Pebwi2xRtTXZRjIvML5zKguhTqijs3EWmHUyahcsXVyTmWyHfXGTgk\n", + "MK8uFJELsyZd6iQyv4lAdxHZBCwGxmRJtmxQZb2SsUYstTD5K1FFEBm6Wl0USMJyisjJwE+B6tJ7\n", + "NZG5TQB+G/y9Cgd+j/lMIvOrB/QGTgEaAXNFZJ6qrsqoZOkhkfldD7ytqsUi0gmYJSLHquoXGZYt\n", + "W1RJr2RM8avqqbH2BY6KQ3Vf8tfmGOPqAVOBR1X1gDyBPGMjUBj2vhB3561szGHBtupAIvMjcOhO\n", + "BIaoamWPp/lEInM7Dnjc6XxaAqUisku18kbkeUIi81sPfKKqO4AdIvIqcCxQHRR/IvP7Hq7JDKq6\n", + "WkTeB7oAC7MiYWapsl7JlaknlPwFKSZ/5RELgc4icriI1AfOxc0znGeBiwBEpD/weZjJK9+JOz8R\n", + "aQ88CVygqhVRzpGvxJ2bqh6hqh1VtSPuCfQX1UTpQ2J/m88AA0Wkjog0wjkJV2RZzmRJZH7vAIMB\n", + "Avt3F2BNVqXMHFXXKznyUh8CvAi8B8wEWgTb2wLTgtcDgT04D/2i4GdIrj3sceZVios+qsAlqgFc\n", + "AVwRNuaeYP9ioHeuZU7n/ICHcNESoe9rQa5lTud3FzZ2EnBWrmVO9/yA63CRPUuB0bmWOZ3zwz2l\n", + "PRf83y0Fzsu1zFWY22PAJuAb3JPZT1PVK5bAZRiGUcuwnruGYRi1DFP8hmEYtQxT/IZhGLUMU/yG\n", + "YRi1DFP8hmEYtQxT/IZhGLUMU/yGYRi1DFP8hmEYtQxT/IYRBRHxRWRM2Pubq0MzIMNIBMvcNYwo\n", + "iEgH4ElVPU5EDsKVF+mj1afwnGHEJGPVOQ2jOqOq60TkUxHpiSsv/pYpfaOmYIrfMGLzEHAprlHQ\n", + "X3Msi2GkDTP1GEYMgn4Qy3A9XTur/bMYNQRb8RtGDFR1l4jMBj4zpW/UJEzxG0YMAqduf+DHuZbF\n", + "MNKJhXMaRhREpBuu7eCLqro61/IYRjoxG79hGEYtw1b8hmEYtQxT/IZhGLUMU/yGYRi1DFP8hmEY\n", + "tQxT/IZhGLUMU/yGYRi1jP8H3BY7kBSPDXsAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "print sensorimotor_models['LWLR-BFGS']\n", + "sm_cls, sm_configs = sensorimotor_models['LWLR-COBYLA']\n", + "modelCOBYLA = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelCOBYLA)\n", + "inv_COBYLA = generateInvTest(environment, modelCOBYLA)" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEZCAYAAACTsIJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXu8HFWV778rIUDCG2MQwlMSFVACOgZGQKJ4JUSFGRW5\n", + "qODrCqMDCTqOoBcl+Bx0rgzoDAKCSBAiKM6AYhgVEhkFhBmICGEmCc88iBACggEhsO4fe3dSp9LV\n", + "Xd2n69F9ft/P53xOV9euqlW7q/baa6+19zJ3RwghhGgwqmoBhBBC1AspBiGEEEOQYhBCCDEEKQYh\n", + "hBBDkGIQQggxBCkGIYQQQ5BiGGDM7Ckz273E6802szllXa+fMbMvmdmjZraiwGuMNbNrzewJM/tB\n", + "kdc1s8+Y2YW9PGevMbMPmtlNFV17dzN70cxGxe3rzOy4Eq7b1TvZF4rBzB4ws8MquvYrzOyq+DI9\n", + "YWYLzewTjR+4zrj7Vu7+QJmX7PbAkaRUzGxX4JPAq9x9pwIv9W5gArC9ux/Tq+ua2TQzezj5nbt/\n", + "1d0/OjxxRw7uPsPd2z7vse1783Au1c1BtW/cIs4wGp1uMbM9gVuBB4FXu/u2wNHA64CtypYnL2a2\n", + "SVWXrui6/cauwGp3X13wdXYD/sfdXyz5ugOPmY0u6VJOFe+Vu9f+D7gfeHP8/EHgP4CvA48D9wHT\n", + "475jgNtSx34C+Lcur3sZcG2bMkcCdwNrgBsJvbHGvgeATwG/A54CLgJ2AH4GPAn8HNg2lt0deBH4\n", + "KLAcWAH8XeJcU4Gb43VWAN8ExiT2vwh8HFgMLE189/L4eUaU84/AstS5PxqPWw38G7Bj6rwnAv8T\n", + "r/2tFnVxBnAVMDde5z+BfRP7dwJ+BPwh/m4nx++nA38Gnov1dAcwDbgrcezPgd8mtm8Cjmx13rjP\n", + "gNOAJcBjwA+A7VJ1fjxB+T8KfDbj3jaNcp0Ut0cDvwZOzyi/DXBplOkB4P9GWd4CrAVeiPd6cZNj\n", + "xwM/ifW9GvgVYBnXeVWsm9XAvcDR8fszU3V6QrPrAgcCv4nXuhM4NHHu7YHvEp7Hx4GrgXHAM4nz\n", + "/BHYEZgNzInH/Qz425ScC4G/aiVzxv19CLgnXmcpcEJi3zTCs/xJYBXhvfhgYv9LgGsI79qtwBeB\n", + "mzKu03gWst6/2cAPgTnxfB+Ov/FFseyyeP5Rsfwo4B/jM7UU+Nt4/sb++cBHUu9g4z7vBvaP13oh\n", + "/m5PAZ/K8ZvtASyI5/l3Qjsxp+O2r5sGs+w/NlYMzwEfIbxofwMsj/vGxQqZlDj2NuA9XV53JfCB\n", + "FvtfATwNHEZoKP6e0MBukpD7N8BLCY3XKuC/gCnAZsAvgc+nHszvA2OBVxMalcPi/tcSlMMoQk/w\n", + "HmBWQpYXgeuBbYHNEt+9PHEvB/mGRmv/+PnN8eHdj9D4nQssSJ33GmBrYJco0+EZ9TE7/jbvjPXx\n", + "d4SGenSU+z+B04FN4gO8FHhrPPYM4NLEucYSGqDtgTGx7h4Gtoj71gLb5TjvrPgb7BTP823g8lSd\n", + "nx9/j32BZ0ko99T97UNoIF9FaOh/Q3aDfSnw4yjvbsB/Ax+O+w4FHm7xXH0VOC/W2+jG79ak3Bax\n", + "Tj4Q62G/+FvulVGnQ64LTCQoy0bH6i1x+yVx+6fAFfF52QQ4JEv+5LWA44D/SOzbm9CIjWknc5N7\n", + "nAHsET+/EfgTG57dacDzhOduNHBE3L9N3D83/o2Nv90y4FcZ12k8C1nv32zCs93ojGwef9/zYvmX\n", + "EpTPCXH/3wCLYh1vR+g0vsAGxXBj4nk4Osr2uri9J7Bruu3L+ZvdTFBIY4BDCO3hpc3uuWXb102D\n", + "WfYfGyuGxYl94+IPOiFuzwE+Fz9PjhWzeZfXfY7YwGTs/xwwN7Ft8Qd+Y0LuYxP7fwj8c2L7JODH\n", + "qQfzFYn9ZwHfybj2KcDVie0XgWmpMknF8CCh17h1qsxFwD8ktreI971r4hxvSOz/AXBqhkyzgd+k\n", + "6mMFcDBwAPBgqvxn2NBznU2qZ0PoKf81oYd0PeElPxx4E7Awlml33kWpF2vHeH+jEnW+U2L/rcAx\n", + "LX7zTxIa+dXAnhllRhN660nr8QTgxvh5Gq0Vw5nAv2adP1HuGFINHUHJNTobQ+o0fV3gVFKNBjCP\n", + "YEHtSGjItmly3Y3kZ6jFsBWhw7RL3P4y8TluJ3OOd/LHwMyEHGuJjW38bhWhAzU6/s7J9+nLtLcY\n", + "mr5/8f7mJ/btQOhEbJ747ljghvj5BoZaN/+LoRZDUjFcT8LKTcmVVgytfrNdCYpybGLf9+nCYugX\n", + "H0OaRxof3H1t/Lhl/H854QcCeC+h4X02fQIzOyRG7TxlZndlXGc1oaeZxY7AQwlZnNAbmpgosyrx\n", + "+ZnU9rMJuRsknXoPNa4fneA/MbOVZvYk4SF/SYtj07yL0Pt6wMzmm9mBiXt4MHEPfyLcd/IeHkl8\n", + "XttE5iTLEufyuL0T4aHdyczWNP4IDfiEFudaQHj5D4mfFxB6q28kmOIQeuOtzrsb8OPEvnuAdYQX\n", + "O+v+tmgh06XxXq5z96UZZcYTemwPJr57iKF12oqvE4a+/t3MlprZqRnldgMOSN37exl6b63YDTg6\n", + "dfxBwMsI1uHj7v5kznOtx92fIlgbjffwfxMaqI5lNrMjzOwWM1sdy85g6HO/2jf4UGDD8/lSgpWT\n", + "fp/a0fT9iyxLfN6N8BuvTNzHt+N1IbxXea+9M8HKzUOr32wnYI27P5Mo/2Czk7SjKidlkfwCeKmZ\n", + "TSE8kKc0K+TuN9HegfwLQoN6Scb+FcBrGhtmZoQXanmLc7ZzJO1K6JE2PjfOdR5hyOQYd/+TmZ0S\n", + "ZUviWSd199uBv4pOs5OBK+P5VxB6S4172ILw4rW6h1bskjjXKMJDv5zQ+7zf3V+RcdyLTb5bAHyD\n", + "8HB/FXgC+A5BoX4rlnm4zXkfAj7k7jend3QZyvsvhPH/6WZ2kLv/ukmZxwg9t90JFguEul7WpOxG\n", + "uPvTBN/Up8xsH+AGM7vN3W9IFX2IMOz31qxTtbnUQ4Te5AnpHWa2I7C9mW3TRDk0O2/6uyuAM2J4\n", + "6ObufmNOmZMybEbwHb2f4Cd8wcx+TD5n7KOEDkD6fWpH1vsHQ+/xYYJV+JKUYmqwMnW9Vtd+GJiU\n", + "sS9dr61+s92A7cxsXKLDvBvh3euIfrUYMnH35wkO0H8kjO39fBinOwN4g5l9zcx2ADCzSWY2x8y2\n", + "JjSubzOzN5vZGMKY+rOEseduOT3Gn+9DGDb7Qfx+S4IDaq2ZvQr4WN4TmtkYM3tffMkbTsPGw3IF\n", + "8CEzmxJfxK8At7h7Vg+n3Uv5OjP76xgZdQqhPm4h+HqeMrNPx/sbbWavNrO/iMetAnaPyrXBb4BX\n", + "Aq8nOJ7vIfY4CcNMEIZ+Wp3328BXYqgmZvZSMzuyzT00vccYd74/YXx8JvC9qEiHEOv4SuDLZrZl\n", + "fGE/QQhmaIuZvS0+Z0YYCn2B5i/3T4BXmNn74288xsxeH5+PzPtIcBnwDjN7a6y3zWMo6kR3X0lw\n", + "Iv+LmW0bz/3GeNwq4CXxHVgvdurc1xF+qzMJQ4B5ZU6yafx7DHjRzI4A2ioUWP8bXA3Mjs/F3oTf\n", + "rZ2yzHr/0udfSXDufsPMtjKzUWa2Z6KOrgRmmtlEM9uOEACRxXcInYDXWmBS43kl1PWeibKtfrMH\n", + "gduBM2O9Hgy8vc39NqUfFYOz8Y+b3r6c4BC+KkOb57uQ+33AXxJ6fneb2RMEP8FtwNPu/j+E3sw3\n", + "CT2UtwHvcPd1beRPfk7LvoAwjPAL4Ovu/ov4/acIJvcfgQsIL1v6XK2u9X7gfgvDUCcA74v3+EuC\n", + "r+RHBOthD4KllXXeZjIn9/0rYRz58XiNd7r7C/FFfTvB2Xgfob4uIDi1IShzgNVmdnuUbS3BSro7\n", + "Uae/AR5w98dimRfbnPccgvP8383sjwTn3NQW99f0u/iing0c7+5r3f0Kwkv4jYy6OJngCL2PEEH1\n", + "fUKET6vrNphM6NA8Fe/3n919wUZCBsvirYTfazmhl/pVQmPauEbmu+Luy4CjgM8SHK0PETo3jXbh\n", + "OILlcy+hgZoZj7uX0KG4z8wej9aFp879HKFhPozwPuaVOXl/T8VrXkl4no4lRM01vZ8mnEToUD0C\n", + "XBz/2pH1/jWry+Oj3PdE+a4iDOkAXEjwHSwkPCc/ypLV3X9IGBq+nPB+X03o1EKom9PjsNEnc/xm\n", + "7yV0nB4HPg98L8c9b4RFB0UhmNnFhMbyD+7+mowy5xKiCdYSQs3uKEygGhOHNe4jRDR1rcyEEJ2j\n", + "928oRVsM3yXEqDfFzGYQQksnE3qx5xUsjxBCiDYUqhiig3dNiyJHEk0dd78V2LYxlj9CKc58E0K0\n", + "Q+9fpGofw0SGhnQtI0SxjDjc/QF3Hy0zVojy0fs3lKoVA2wczSCtLYQQFVL1PIblJOLe2RDzPgQz\n", + "k7IQQogucPeOF+GrWjFcQwgpm2thJu4T7r6qWcFubm4QMbPZ7j67ajnqgOpiA6qLDYzIujCbTAjH\n", + "PTh+cxkwy8IqBh1TqGIwsysISxiMt7B++xmEaeS4+/nufp2ZzTCzJYSY7w8VKY8QQgwUYXWBmYSJ\n", + "qWMJczZOxP2auL+r0xaqGNz92BxlTipSBiGEGEgyrATcHx/uqevgfBadMb9qAWrE/KoFqBHzqxag\n", + "RsyvWoBCMRtFWCttIUEpPAIchftxvVAKUPDM515hZi4fgxBixNOhldBt2ymLQQgh6k4JVkISKQYh\n", + "hCiIGFwzz0IOlHlxGaCOjt/f7Fd3hEXxziY4mC8D9lnvYC6AqsNVhRBiIIlK4ByG5lrY08xw9+va\n", + "Hb+Z2ds+A5ecDuPHEZahPQVWXglXeAFWQhL5GIQQogDMbB4hFW2aee5+RJuDJy+EW6fE5bfnEJKX\n", + "r8l7/AYZ5GMQQogasXnG92Mzj0j4EqbAdisJK40ez5DVSLOP7xFSDEKIEc9wfQEZbJRrPvJM029D\n", + "xNECoi/hp7BiH+DavMf3EPkYhBAjmuH6AlpwLiEtZ/K8SwkZHxvXnTkKNv8C7HAa7DEaNiPOXn57\n", + "yFmdlmv98UUixSCEGBgajS1hGOdZ4NwcjftMhja+xO2TCbmruyIu+UM8z1hCT/+bjaWAgHMmwaSL\n", + "gUPiMYvhhslwNO6Pe7ifpsd3K1NepBiEEAPBMHr+nfsCchKvu9G1R8HMk2HSV4BGxNGJwLXwXDLi\n", + "KOv4opGPQQgxKLTq+beiM1/AcDGbfDsc+E8EpTAHSPgSCncs50GKQQgxhIIcsWXQbc//XGBJ6rve\n", + "j+UnIo72h20yIo4KdyznQUNJQoj1FOiILYOuev6tfAE9kyy1xtFiuOENsPtj8PJEqVIcy3nQBDch\n", + "xHqGNSmrYjKU2lJgZmVKrUW+hChvoY7lbttOWQxCiCSFOWKLppSefye0WQm1KsdyHqQYhBBJynXE\n", + "9phaNLbtsqr1AXI+CyGSlOOIHVRSs5cpYSXUIpDFIIRYT+2GY3LS5cS2XgpQCyuhST10dx45n4UQ\n", + "/UyG03kJMKsU5VBg7uXOxGhaD2h1VSHESKTbiW3Do+SsajloVg9doaEkIUS/U34kVU2shBRZ9dAx\n", + "shiEEP1OeZFU9bMSknTtU0gjxSCE6HfKWtKi7hFHzeqhKzSUJIToawqPpKpJxFE7MuphejfnUlSS\n", + "EEJkUU9fQm6U81kIIXpFvX0JhSPFIIQQSQr0JfTLkubyMQghCqXyWcl5KdiX0E9LmksxCCEKo28a\n", + "w3J8CYXkli4CDSUJIYqkmlnJeenAl9CDYaC+WdJcFoMQfUwfDNPUtzHswErokeXTN0uaSzEI0af0\n", + "yTBN/RrD7nwJvRgGOhfYk40zzNVuSXMpBiH6l34Ys65XY9i9L2HYlk+vJ+IVaS1KMQjRv9R3mCZS\n", + "m/wOw4846onl06sMc0Vbi1IMQvQv9RumaULl6TZ7E3FUL8unYGux0KgkM5tuZvea2WIzO7XJ/vHR\n", + "u3+nmf3ezD5YpDxCDBhKw9mKHs5ejsptFjCPMPltHjCzQl9OodZiYWslmdlo4L+BtwDLgduAY919\n", + "UaLMbGAzd/+MmY2P5Xdw93Wpc2mtJCGaEIcU+ioNZyn0+RpH7TCzecDhTXbNc/cjEuW6ajuLHEqa\n", + "Cixx9wcAzGwucBSwKFFmJbBv/Lw1sDqtFIQQ2VQ+TFM3+mQl1B5Q6NBWkYphIvBwYnsZcECqzIXA\n", + "DWa2AtgKeE+B8gghBpkBtxKSFO3UL1Ix5Bmj+ixwp7tPM7M9gZ+b2RR3fypdMA47NZjv7vN7I6YQ\n", + "oq8ZOVbCEJpZi2Y2DZg23HMXqRiWA7sktnchWA1J3gB8GcDdl5rZ/cArgdvTJ3P32cWIKYToW0aQ\n", + "lZCH2GGe39g2szO6OU+RUUm3A5PNbHcz2xQ4Bkhr8HsJzmnMbAeCUrivQJmEEIPACM+XUDSFWQzu\n", + "vs7MTgKuB0YDF7n7IjM7Me4/n2D6fdfMFhKU1KddP6oQohWyEgpHqT2FEP1Byb6EPligsC11DFcV\n", + "QvQ5tWkcS7YS+mSBwsKQYhBCNKUWjWN1EUf9sEBhU1LKvCukGIQQWVTbOFbrS6j9AoXNyFDmHaMM\n", + "bkKILKppHOsRcdQXCxQ2oZky7xgpBiFEFuU3jsFKWACcTVBAlwH7VDBZrV8XKOx6+CiJhpKEEENI\n", + "jFHvBKwFxiV2524cO3JcF+RL6NZ5Xps8Ep2Tpcw7QopBCLGejDHqtQSFsJycjWNHjuuCfAnDdZ73\n", + "6QKFzRbX6xjNYxBCrCfvcs6J8k175LnOU3DEUaf3MiiklmI/VPMYhBDDJbfDuVWPvO15zCb/AX48\n", + "AfYB+CmsmA2fuK23voRKnOdVz/1IWjpm1lXPX4pBCJGkE4dzq3DWpucZBc9gdsoL8A8TYLOVwInA\n", + "tcGf8WUze7qHjWjpzvNazP3oAYpKEkIk6SQap1WPfKPz7AUPrQyrLJ89GjabQzAXrt1QpKFUekUV\n", + "kUWtlGXXmNmMmAZ5fvw/Yzjna4csBiHEejqMxsnskSfPMwrGfgEmnAYvHw27Ao98AB67FF7d5Nie\n", + "DfNUFFnU8+GrKqwQKQYhxBA6iMZpmV7S3a/DbDEh4mivuP8yYNalcDnNFUNPh3kqiCwqYviq9Bno\n", + "GkoSQnRFbHRnAfMIk9LmATOjQmg3e7nnwzxlD7dk0Oy+1gIThyFT6U50WQxCiEzaRdg07ZHnmJfQ\n", + "62Geujh9U/c1kWBRjQNeE/+6kal8J7rmMQghmpHR2C4BZjVt2CrMvVzHOQu9kinjd1hKwzprfazy\n", + "MQghekr+se3qs6rtlPH9xJKu34yeDAFV4USXYhBCZNG+YavQSkixY4ffA4VPRuvZEFDZTnQpBiEG\n", + "hAIaudYNW/VWQpKVwPiM75tSgl+iZdRWnZFiEGIAKKiRO5fgME0O06zcFL4VI46qthKSrCDImmZ5\n", + "i2MKDQPt4xVapRiEGBCKauSGOC5fBaMXwFnENY6o1kpI0k3vvPAw0D5doVWKQYgBoYhGbiZxjN5Y\n", + "70iYMA4mUA8rYT1d9s77NUtb4UgxCDEYFNHIbQ6hC34xcEj88lpY9Y6QVa1qK2EIXfTO+9YHUDRS\n", + "DEIMBj1v5EbBsycTHAnjCF7cuBLqHV4zpdAN/ewDKBopBiEGgJ43cmaTV8LOE+LmHMLaF2sGrEfd\n", + "rz6AotHMZyHEBlLzEp6FNR+D+y+Bp1CPuu/otu2UYhBCBEqal9BsvkXcVVnWs0FFS2IIIbqjxNnL\n", + "GfMt9gWcofMl+i7r2SAhi0FUQtV5cUWk5NnLLRaWa0ZlC+ANCrIYRN9QlyWSRzTVrXGUNd+iGYXl\n", + "GxCtUaIeUQWF5MUVrWkksplidutCeAw4m9D4XkaYl1DGZLWs+RbNGPETzapCikFUQekZqUY6ZjZj\n", + "FJwzCw6/GaZOge3+AC9cAF9IZFUrg2YZzlYS1jpKMlBhsf2GhpJGOBWN9WspgpLZD047FyY1Zi/H\n", + "eQmj18DUE0qUI2u+RdytiWY1QYphBFPhWP+IW4qgMmd79CXcDAdtzpDZyw1Kt9JaTCqTIqgJUgwj\n", + "m0KXHc5ipC1FUJkCTkQcbc6Q2ctJZKWJjSjUx2Bm083sXjNbbGanZpSZZmZ3mNnvzWx+kfKIjahs\n", + "rN/dr3P3I9x9Wvw/kEohUoqzveFcHm02/8tmi16AuwhhqI9cAF84HpaklMJAW2miewqzGMxsNPAt\n", + "4C2EZBm3mdk17r4oUWZb4J+Bw919mZk1y8AkikNj/eVQuAJuWCWTYFJyJdTFcMNkOPoE98dPNLuV\n", + "EWKlieGRSzGY2ThgF3f/7w7OPRVY4u4PxHPMBY4CFiXKvBf4kbsvA3D3xzo4vxg+Az/WX5OJdIUr\n", + "4FEw82SY1GQl1OcaK6FqwTiRl7aKwcyOBL4ObAbsbmb7A2e6+5FtDp0IPJzYXgYckCozGRhjZjcC\n", + "WwHnuPucvMKL4THoY/01mkhXrAI2m3w7HLh/3Ez5EhQCLDomj8Uwm9Cg3wjg7neY2ctzHJdnrY0x\n", + "wGuBwwgdnZvN7BZ3X5zjWNEDBrwXWYlzPU0TBbwFwb/3aTObSbdWTGL28v4wtknEEWhYUHRBHsXw\n", + "vLs/ER/sBi/mOG45sEtiexeC1ZDkYeAxd38GeMbMfgVMATZSDGY2O7E5393n55BBjGxqM5GuoYB7\n", + "ZsWk1jhaDDe8AXZ/DJKdto2skpoMrYmCMLNpwLRhn8jdW/4RHr73ESIcJhMetG/nOG4TwoO5O7Ap\n", + "cCewV6rMq4BfAKMJFsNdwN5NzuXtrqc//aX/gHkEyzX997O+lQlGOZzisNbBHVY6HBnPPQP4GTA/\n", + "/p+RuvYMQqcred3F6XL6G1Jf82J9zuvHeuq27cxjMZwM/F/gz8AVwPXAF9sd5O7rzOykWH40cJG7\n", + "LzKzE+P+89393rja4u8IVsiF7n5PDpmEyEMdnevdWzEpK+GnsOIjcP8q+Dhm67z9sGAthtb6gRr5\n", + "pyqh7bLbZvZad/+vkuTJksFdy24LOh8KieVr41xvsex09hLTTbKqfQCevRJ2TJRaAsxqUxfzgUOb\n", + "7Frg7tPy3cHIoKvfqYYUuez2N8zsZcBVwA/c/fcdSydED+imF5ejF102nVkxTfIl7AE7PQJvTpXM\n", + "0/PXvJX81MY/VQVtZz7HnsSbCMv0nm9md5nZ54oWTIgm9P1y3VFRzSKMWS+I/2dupNjMRmF2CrCQ\n", + "OHsZOAr34x4JQ7PNaNdoNVvZtOqhtdrQmDkeLat9MoqNCCWaa4Kbu68EzjGzG4BTgc+Tw88gRI8Z\n", + "iF5cWyumfVa1rnr+PuDzVoZDhjX6PCGkvsGIUaJ5JrjtDbwHeDewGvgB8MmC5RKiGZUOhRQe6pk/\n", + "q1rXTvUaDq3VhWbW6BjCSMndjDAlmsdiuBiYS1jPaHnB8gjRisqijAqPUukg97J6/oWQZY3ePRId\n", + "820Vg7sfWIYgQrSj4gaxmFDPLnMvq+ffc+SYT5CpGMzsKnc/2szuarLb3X3fAuUSoikVNoi99290\n", + "YCWIwqnjnJfKaGUxzIr/3w6k42DzrIMkxCDRux5ll1aCKI5+Gp4rY1mTPBPcznL3U9t9VySa4Caq\n", + "JsPHsJTwgkLeF1VWghgGGc9h5uTGbtvOPIrhDnffP/XdXe7+mk4v1i1SDKIONJtFHXe1f1FlJYge\n", + "0OmM7J7PfDazjwEfJ0ReJP0MWwG/7vRCQvQ7zfwb8UVt7ZSWlSB6RylzeVr5GC4nrND4D4RJbQ2t\n", + "85S7r+6lEEL0MdkvqqwE0XtKiZ7KVAzu/iTwpJmdA6xx9z8CmNnWZnaAu9/aS0GE6FOavqj7hY7U\n", + "AmQliN5SSvRUHh/DncBr3f3FuD0auD3tdygS+RhEmXQS9ZF2BhpwGjz2RdhqdEiHKytB9JROVgwu\n", + "cnVVGkohfn4hKgchBo5OZzgnwxz3he0vhclTYHzcLStB9Jwy5vK0XV0VuN/MZprZGDPb1MxmAfcV\n", + "KZQQFdLxCq4O8xyuXwivmQLbkVgJVUpB9CN5FMPfAAcRcjgvAw4ETihSKCEqpLOojxBxtAA4O5a5\n", + "DNinX4aOkktNx/8zBuFaYnjkWStpFXBMCbIIUQfyRX2UEHFU9AzXMtNXjvRUmf1GW4vBzF5pZr80\n", + "s7vj9r5mdnrxoglRCe2T2ZRgJSQa0sMJ6TgPJ+RE6WUvu8zER32fZGkkkWco6ULgs8Bzcfsu4NjC\n", + "JBKiQlpmWGuRVa0AX0IZDWmZiY8GIsnSSCFPVNI4d781Rl7g7m5mzxcrlhD56fWQS9Ooj/JnL5fR\n", + "kJa51LSWte4j8iiGR81sfc/FzN4NrCxOJCHyU0ICnapmL5fRkJa51LSWte4j8iiGk4ALgFea2Qrg\n", + "fuB9hUolRH6KSaADVa9xVHhDWuZS0/20rLVoMfPZzGa5+zlmdrC7/4eZbQmMaiyNUSaa+SyyMLP5\n", + "BOdsmgVdp2QswEroZrirkxmuQjSjiJnPHyaY6N8E9nf3p7sVTogC6e2QSwFWQqvhrkhThaH0naIq\n", + "WimGe8xsMTCxSXpPpfYUdaE3Qy7F+hKyhrvOBLZFsf2iZrRcRM/MXgZcDxxJKr2nuz9QqGRD5dBQ\n", + "kshk2EMuBfsSWgx3rSEsoZGmadIVITqliEQ9v3T3w8zsend/cHjiCVEcXQ+5lBdxlDXcldUrU2y/\n", + "qJRWQ0k7mtlBwJFmNpdgMax/kN39v4oWTojCaGIlvB6uvR0+jtkn6e0SFFnDXU8C2zcpr9h+USmt\n", + "FMMZwOeAicD/a7L/TYVIJESRZFgJBusoaD5EVqhm3J2+pmL7ReXkSdTzeXf/QknyZMkgH4MYPi18\n", + "CZ0mWe+dSApJFcXRbduZRzGMIkxo28Pdv2BmuwIvc/ffdidq50gxiGGRw5dQyHwIISqm27YzzyJ6\n", + "/wL8JfDeuP10/E6I+pN/JVSt5SNEJI9iOMDdP058QTyE8I0pVCohhkvnK6G2X25biBFCnrWSnkvm\n", + "eDazlwIvtihfCHEMuKeJSsSA0sW8BK3lI8QG8vgY3g+8B3gd8D3g3cDp7n5l8eKtl6Eh5BJgll7W\n", + "aig6o9iwZYm5Eyh/JVQhaklhzud48r2Aw+LmL919UU6hpgP/BIwGvuPuZ2WUez1wM/Aed7+6yf6k\n", + "kJoV2mMK3cjHAAARqklEQVTyNPgZ6/1UoqibybI3PHgjPD0B9olf9WqNo1ooQiG6oYhF9NYTFUEu\n", + "ZZAQaDTwLeAtwHLgNjO7Jq1UYrmzCL29PDegWaE9pIN8BsUtb90562Ux1psIu40L+3piJShHsRjJ\n", + "5HE+d8tUYIm7P+DuzwNzgaOalDsZ+CHwaM7zKkqkt+RNIVmn1IybQxByAcEkHQdcDU/Qu9zLylEs\n", + "RixFKoaJwMOJ7WXxu/WY2USCsjgvftVuXEtRIr0nb4Nfm3DOUfDsLEK40SGEdIJHAu+CTQ0O7NFl\n", + "6qQIhSiVtorBzPZu8t20HOdu77wInb3TPDg6jNZDSRuSsote0rbBj8Mq49lYCZSvqM0mr4SdG1bC\n", + "HIJT4dqwdxy969FXogjNbIaZzTOz+fH/jCKvV3dUH9WQx8dwpZnNAb5G6C2dBbye9j2z5cAuie1d\n", + "CFZDktcBc2OY4HjgCDN73psPBdwKTDWzqcB8d5+fQ/aBowCHaMt8Bhlj7c8A9wCfL01RJ2YvT4Cx\n", + "j8K6j8Am125cslc9+tJzFMuvMRTVR+fETvu0YZ/I3Vv+AVsQnMi3AL8HPktI8dnuuE0IL9LuwKbA\n", + "ncBeLcp/F3hnxj5vd72R8AfMABYTrLHG32JgRg/O+zNgfvw/I7FvXup6jb+flXbvMNnhJgePf3Ne\n", + "Br8sWq5W9VLQ71t9XdfoT/XRkzr0bo7LYzGsI/QQxxJ6qfe5e9sJbu6+zsxOIiT6GQ1c5O6LzOzE\n", + "uP/8HNcWQykkMshb5zOobqy9xRpHj4Te5K4U2KNvUy9FIL/GUFQfFZFHMfwWuAb4C8Jwz/lm9i53\n", + "P7rdge7+M0JPK/ldU4Xg7h/KIctIp4oXpfSxdjObsR+cdjHsuz9sE78eMi/BB3Omcm0c/DVB9VER\n", + "eRTD/3H32+LnlYTEPccXKJPIpooXpdSx9s3M3vYZuOR0GD+O8MCdAiuvhCs8NVmtgh59T2jhJyrd\n", + "r1FzVB8V0VYxJJRC8rtLixFHtKH0F6XUnrnZ5N/CnCkxD/IcYBawBnakmol0PaedQ3UAraCuUX1U\n", + "R64lMapG+Rg2MJCJXVK+hJXAiawPQW0wEHkRqkoIJEYmhS6JIepDXYZPehY2m1oJ9aew4jjYac3G\n", + "JQdlXFkOVVF7pBhEx/Qkvjwj4ujtzXMvD9K4shyqovZIMYhuGF7YbIt8CQ4M+LiyHKqi9kgxiG7o\n", + "bjgkR+5lqM9wWRHIoSr6ASkG0Q2dD4d0kVVtUClb8SmvhOgUKQbRDfmHQ3JaCaK3JJTBToTfalxi\n", + "t9YbEi1RuKroilxhs7ISKiEjOCCNwmNHAIWm9qwaKYY+Q1ZCpbSYK5FkIOaFiNZoHoOoB7IS6kBW\n", + "cEAShceKTIrM4CZGEmajMDuFkFjtYIKVcBTux0kplE5WcEADhceKlshiEMNHVkLdaBYcsJagEJaj\n", + "8FjRBikGkYumIY8x3SryJdQKzZUQw0XOZ9GWZlEue8ODN8LTE0LKZZCVIETtUFSSKIxklIuxwUSI\n", + "gfGyEoSoKYpKEkWyOQRz4WLgkPjltbDqHbCPrAQhBgtFJYm2jIJnZxHCjQ4hpvELf3dIKQgxeMhi\n", + "6FNKW//GbPJK2HlC3ExkVVPIoxADihRDH9KTfAjtL7J+9vIEGPssrPkY3H8JPIWiXIQYaOR87kMK\n", + "Tw+peQlCDATdtp3yMfQnxaSH1OxlIQRSDP1K79NDBithAXA2QcFcRog46nkYqpnNMLN5ZjY//p/R\n", + "62sIIbpHPob+pHfpIUteCdXMzgA+jfIDCFFb5GPoU3LlQ2h/klJ9CVHmqxiqFBooP4AQPUYT3EYY\n", + "w0oPWV2+hJk0VwowXP+IEKJnyMcw0ijRl9CEVnkClB9A9AUjwUcmi2GkUI+sallO87VospzoA0qZ\n", + "Q1QDZDGMBKq1EpKcCyxJfbcW+NogvVRioJnJxrm0JxH8fQODLIZBpoWVYGYzMCt+SY0EyhMgBoBi\n", + "5hDVDCmGQaVFxFGGOXyImX3N3c8sUqxhOc2FqJ7ezyGqIRpKqhE9cWrlm73czBweB3wuzjMoR1Yh\n", + "+o9mw6EDt6CkLIaa0BOnVv55CVnm8Gjg02Z2W6trjhQHnBBpRspwqCa41YRhLYzXYcRRi2vlumbh\n", + "i/gJIXqCFtGrEV0Os3Tn1Oou4uhcQjRQFu0caSPCASfESKVwxWBm083sXjNbbGanNtn/PjNbaGa/\n", + "M7Nfm9m+RctUJIlhlsOBQ+P/c3Ioh86cWsNYCTWavV8DXujomt3KKoToKwpVDGY2GvgWMB3YGzjW\n", + "zPZKFbsPeKO77wt8EbigSJlKoNs45/xOrR7MS4jRR19kY8shjyNtRDjghBipFO18ngoscfcHAMxs\n", + "LnAUsKhRwN1vTpS/Fdi5YJmKpqthllxOrR7PXnb3M83stpbX7FZWIUTfUrRimAg8nNheBhzQovxH\n", + "6P8Y96xhln3MbEarxrNljH9BK6F2O69A8xGEGFyKVgy5Q57M7E3Ah4GDMvY/AKwjWBUXuvv8HshX\n", + "BM1yJQCMJ/gaOgvprMcaR0KIPsDMpgHThnueohXDcmCXxPYuBKthCNHhfCEw3d3XZJxrt/jfge/3\n", + "Ushekhhm+R5BGSRp+Bp6PS9BCCGIHeb5je28E1bTFB2VdDsw2cx2N7NNgWOAIT1dM9sVuBp4v7un\n", + "HZrNqP2CVdEiuDtjd/uQTuVeFkJUSKEWg7uvM7OTgOsJs2ovcvdFZnZi3H8+8HlgO+C82NN+3t2n\n", + "tjl1P8TLdxfSKStBCFExfTPzOfVV7WfYZiwbsRSY2dTHIF+CEKLHjKTUnn0RL99RSKesBCFEjegn\n", + "i2EBgxYvLytBCFEg3VoMfaMYBm4RPVkJQoiC0SJ6/YIijoQQNacffQz9i6wEIUQfIIuhDGQlCCH6\n", + "CFkMRSMrQQjRZ8hiKApZCUKIPkUWQxHIShBC9DEDaTF0mVqzFxeWlSCE6HsGzmLIWIpiz46Xu+78\n", + "wrIShBADwSBaDN2m1uwOWQlCiAFjEBVDV6k1obMhKDObsb/Zr+6AxxlG7mUhhKgbAzeURJfLXXcy\n", + "BLWZ2ds+A5ecDuPHASuBU2DllXCFy0oQQvQ5g2gxnAukE/7kWZE13xCU2eTfwpyvRKUwB9gHuBJ2\n", + "3KisEEL0IQOnGGLvfhYhe9wawlDPkzkObT0ElfAlTIHtVgJHAsfHiwwp2wWVRVKJgUXPlOiWQRxK\n", + "arAtITMcwPbAOW0ik7KHoFIRRz+FFcfBTk2SU7fOzpZBZZFUYmDRMyWGw8BZDJFuIpM2GoIaBUuv\n", + "h4dIRRy9HT66prvhql7KK0Qr9EyJrhlUi6HjyKR0xrX9wK6Hl0yAE2KR9fMSHMidnW148k40s3lx\n", + "/7PAuertiZx0HZ0nxKAqhtyRSdHknklsfDeFb/4ZJtMmq1psoHvVSGfJuyfwmuS2hgJETrqKzhMC\n", + "BlcxnEtoVJOm9EZDPelx2EnA9+FQNvS2ypq93EzetcC4VLnGUIAUg2hHrndAiGYMpGJIDwuRPdQz\n", + "E5hkbEi8PA42Xw1/fgm8p6yJahnyTmSotdBAQwGiLR28A0JsxIjO+Wxm8yfBoRcDh8Tv5gB/D79+\n", + "xP3gFocWTvQtHN5k1zx3P6JseYQQ/YdyPneK2agvwQ4LCUohOS9hFTxVqWyBbifqCSHEsBiZFkNq\n", + "XsIcwoy4OC9hKTAzr8mddl7Tw8iheG4NBQghuqLbtnNkKQazUWxwJ4wFHrkALjgRptJF45sxiWgJ\n", + "MEsNuBCiaqQY2p+k5/kS5AcQQtQZ+RiyKDZfgiYRCSEGjoEMV11P8VnVNIlICDFwDKbFUF5WtZaR\n", + "Q1rdUgjRjwyexVBi7uVWk4i0uqUQol8ZHOdzk4gjmqxxVBZyTAshqmZkO5+DlbCAEnMv5xgmkmNa\n", + "CNGX9PdQUkVWQs5hopaO6SInxgkhxHDoX8VQoi+hCa2SoDQa98zVLeV/EELUmUKHksxsupnda2aL\n", + "zezUjDLnxv0LzWz/HCctK+KoFW2HiRK5p+cRhrnmsWGpDWXXEkLUlsIUg5mNBr4FTAf2Bo41s71S\n", + "ZWYAk9x9MiFT2nltTlq6LyGDXPMX3P06dz/C3afF/w1roGv/g5lNyy/mYKO62IDqYgOqi+FTpMUw\n", + "FVji7g+4+/PAXOCoVJkjge8BuPutwLZmtkPTs1VvJSQZ7sqnw5kYNy3nNUYC06oWoEZMq1qAGjGt\n", + "agH6nSJ9DBOBhxPby4ADcpTZGVjV5Hxnx/9l+hKa0oMkKMquJYSoLUUqhrwTJNIxtlnHVTovIc1w\n", + "cj4ru5YQos4UNsHNzA4EZrv79Lj9GeBFdz8rUebbwHx3nxu37wUOdfdVqXPVfxaeEELUkG4muBVp\n", + "MdwOTDaz3YEVwDHAsaky1wAnAXOjInkirRSguxsTQgjRHYUpBndfZ2YnAdcDo4GL3H2RmZ0Y95/f\n", + "WFPIzJYAfwI+VJQ8Qggh8tEXayUJIYQoj1qtlVTIhLg+pV1dmNn7Yh38zsx+bWb7ViFnGeR5LmK5\n", + "15vZOjN7Z5nylUXO92Oamd1hZr83s/kli1gaOd6P8XENsztjXXywAjFLwcwuNrNVZnZXizKdtZvu\n", + "Xos/wnDTEmB3YAxwJ7BXqswM4Lr4+QDglqrlrrAu/hLYJn6ePpLrIlHuBuAnwLuqlruiZ2Jb4G5g\n", + "57g9vmq5K6yL2cBXG/UArAY2qVr2gurjEGB/4K6M/R23m3WyGHo7Ia6/aVsX7n6zuz8ZN28lzP8Y\n", + "RPI8FxBCf38IPFqmcCWSpx7eC/zI3ZcBuPtjJctYFnnqYiWwdfy8NbDa3deVKGNpuPtNwJoWRTpu\n", + "N+ukGJpNdpuYo8wgNoh56iLJR+hyTkUf0LYuzGwioWFoLKkyiI6zPM/EZGB7M7vRzG43s+NKk65c\n", + "8tTFhcA+ZraCsGLCrJJkqyMdt5t1Wl211xPi+pnc92RmbwI+DBxUnDiVkqcu/gk4zd3dwszBQQxv\n", + "zlMPY4DXAocB44CbzewWd19cqGTlk6cuPgvc6e7TzGxP4OdmNsXdnypYtrrSUbtZJ8WwHNglsb0L\n", + "QbO1KrNz/G7QyFMXRIfzhcB0d29lSvYzeeridYS5MBDGk48ws+e9JrPke0SeengYeMzdnwGeMbNf\n", + "AVOAQVMMeeriDcCXAdx9qZndD7ySML9qpNFxu1mnoaT1E+LMbFPChLj0i30NcDysn1nddELcANC2\n", + "LsxsV+Bq4P3unl7Qb5BoWxfu/nJ338Pd9yD4GT42YEoB8r0f/wYcbGajzWwcwdF4T8lylkGeurgX\n", + "eAtAHE9/JXBfqVLWh47bzdpYDK4JcevJUxfA54HtgPNiT/l5d59alcxFkbMuBp6c78e9FnKN/w54\n", + "EbjQ3QdOMeR8Jr4CfNfMFhI6wJ/2ChfeLBIzuwI4FBhvZg8DZxCGFbtuNzXBTQghxBDqNJQkhBCi\n", + "BkgxCCGEGIIUgxBCiCFIMQghhBiCFIMQQoghSDEIIYQYghSDEBVgZrPN7O+qlkOIZkgxCFENmkAk\n", + "aosUgxCsT/Kz0Mw2M7MtYnKXvZuU+1xMEHOTmV3e6PWb2X5mdks8x9Vmtm38/qNm9tuYMOaHZja2\n", + "7HsTolOkGIQA3P02wpoyXwLOAuakl5Mws9cD7wT2BY4A/oINPf9Lgb939ynAXYRlCSDkR5jq7vsB\n", + "iwhLpAtRa2qzVpIQNeALhAXaniEk/klzEPCv7v4c8JyZXQtgZlsTsundFMt9D7gqfn6NmX0J2AbY\n", + "EphXoPxC9AQpBiE2MB7YgrAw21hgbWq/M3Rd+6y8D8nvLwGOdPe7zOwDwLSeSCpEgWgoSYgNnA+c\n", + "DlxOGE5K82vgHdEPsSXwNgB3/yOwxswOjuWOA+bHz1sCj5jZGOD9bBh6GsRkQmJAkMUgBGBmxwN/\n", + "dve5ZjYK+I2ZTXP3+Y0y7n67mV1DWNZ6FcGX0Mi7/QHg2zEPwlI2LG38OUJO7kfj/y0bp0ORSaKm\n", + "aNltITrAzLZw9z9FBbAA+Ki731m1XEL0ElkMQnTGBTGMdXPgEikFMYjIYhBCCDEEOZ+FEEIMQYpB\n", + "CCHEEKQYhBBCDEGKQQghxBCkGIQQQgxBikEIIcQQ/j+O30HURJnrpwAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4VNXWxn8rPZDQkRpaAggExYYCUkSlBLALNryKon4W\n", + "vNar3quTY73Wa1fEjqigWFABUQFFBESUKi2hhQ4hQAgJELK/P9aeZDLMJJMeYN7nOc/MnHNmn33a\n", + "2muv8i4xxhBEEEEEEcTxg5Cq7kAQQQQRRBCVi6DgDyKIIII4zhAU/EEEEUQQxxmCgj+IIIII4jhD\n", + "UPAHEUQQQRxnCAr+IIIIIojjDEHBXwaISJ6ItKnA9nuKyIqKar+iISLrROTcqu5HVUBEokXkGxHZ\n", + "LSLj7brHRWSHiGwu52M9KCJjyrPN8oaIXCcis6ro2K3suxpif08WkeGVcNxkERlb0ccpDY4bwW+F\n", + "0H4RybTLXhFpXIX9SRaRQ7Yfe0VkpYi84tknY8wsY8yJAbZVHR8wY5cSw96vvuXcn8rEZcAJQD1j\n", + "zDARaQHcDZxojGla2kZFpI+IpHmuM8Y8ZYwZWbbuHj8wxiQZY4p9X8rhGay2SVLHjeBHb8JgY0ys\n", + "XWoZY7ZWcX8+McbUAuoCFwONgQVVOSBVIxhAqroTZUBLYJUxJs/+bgGkG2PSq7BPxwREJLSSDnW0\n", + "P4N+cTwJfp8QkQ9E5G77vZmdEt5qf8eLSLrHvveJyGYR2SgiI8p6aLtgjDlsjPkbGAbsAO6xxyuk\n", + "3YnIv+yx94rIChHpKyIDgAeBYXYm85fd93oR+dvumyoiN3m008e2c7eIbLPndJ3H9mgRed5qPLtF\n", + "ZJaIRNltZ4nIbyKSISILRaR3MefZVUSWicguEXlXRCI9jjPYtpEhIrNFpLNdPxYVlN/Yc7pPRN4v\n", + "wX3y2a7d1lREJorIdhFZIyJ3eGxLFpEJ9pnYKyJLReQ0vzdQ5EQR+UFE0u39uNyud4CHPe7JTcA0\n", + "oKn9/W5x11JE6onIeyKyyV67L0SkBjDFo529ItLEc8YnIlNE5Davfi4SkYuK6rOf8yvLM1RfRCaJ\n", + "yB4RmQfEF3EctylmpD3fzSJyj9d9+VxExorIHuAfIlJbRN6RgvfxMSkw5YSIyHOiZrVUYJDX8WaK\n", + "yA0ev0d6nOcyETnFxzN4bwD3rLWI/GzbmQY08HfOVQ5jzHGxAGuBc32svx6YZL9fBaQAn9rfI4Av\n", + "7fcBwFagI1AD+BjIA9qUsj/JwFgf6x1grv3eB0iz39sDG4DG9ncL97EBF/ChVztJQGv7vReQBZzi\n", + "0e4h24dQYKDdXttufw2YDjRBlYOzgAigGbATGGD3O8/+buDnHNcBi+3/6gK/Ao/ZbacA24Az0AHw\n", + "WnuPwj3uV99S3Ce/7dpzWQD8BwgDWgOpQD+Pe5Jt77UATwJz/JxbTSAN+Idttws6aHfwdU+A3u57\n", + "aX/7u5b17e/vgE+A2ravPX21430sYDjwq8e2jkCGPf8i++zjHMvyDH1ql2igE7AR+MXPcVqh79I4\n", + "u38isB37vtpjHAQusL+jgC+BN+z+DYF5wE12+y3AcgqeuxnAYSDEbp8BjLDfL7d9O83+jgda+HkG\n", + "i7tnc4Dn7LXuCezF672sLkuVd6DSTlSFUKZ9CTKALzxu9C70RX8DuIkCYfsB8E/7/V3gSY/22lIx\n", + "gv8W1ETgfrncfUlABdq5WOFYXFte+3wJjPJod7/7RbDrtgFdUYGwH+jso41/eT/IwFTgWj/HXOt+\n", + "Ge3vgUCK/f4G8KjX/isoEHDeL12g98lfu72AM4H1XtseBN71uI7TPLZ1BPb7ObdheAkyYDTwiK97\n", + "4nkvi7uW6IB7GCtEvfYp1I73sYBYYB8QZ38/AbwdSJ8DeGYDfYZCUUHdzmPbE8AsP+22Qt8lz/2f\n", + "9uh3MjDTY1sjIAeI8lh3JTDdfp/u9dydb9v3Jfi/B+4o4vn1fAaLumct0IEw2mPbOIp5L6tqOZ5M\n", + "PQa40BhT1y6XABhjUlFNpQs6Sn8LbBaRdqiw+Nn+vwmqLbmxwd+BRKNx3E7kJSXsZzPgCDuwMSYF\n", + "+Cf6EmwTkU9EpEkRfRgoInPtlD4D1d7qe+ySbgrsz6AvcQw6PY1CNWFvtAQut9PcDNtuD9Q34Q/e\n", + "18zt2GwJ3OPVVnOP7YVQgvvkr90mdltTr20Pok5YN7Z5XZMotwnBx7U406utq1ChFAiKupZxwC5j\n", + "zJ4A28qHMSYTnS1caVddgQqgEve5DM9QQ3SWEtD74gF/zwqoVu5GS1Sr3uJxHm/a40IJ3lX02fD1\n", + "rPtCUfesKZBhjMn22H99gO1WOsKqugPVBD+jU75wY8xmEfkZuA6dJi60+2xBR3U3WuAHxphZqOZV\n", + "FIz3CitghqD2YF/tfgJ8IiKxqKb2NKptFGpL1I4+EbgG+NoYc1hEviQwR9VOVJtKQM00ntiAajA3\n", + "HfEv//C+Zps82nrCGPOkn/8dcX0I7D75bVdEzgLWGmPaleCY/rAB+NkY06+Ubfm9lnZArycitX0I\n", + "f1/teq/7BHCJhk9GGWNmBNhnzz6U5RnaAeSi93ulXef3ffGA9/6bPLZ5nmMacAA1sXgOPG4E/K7a\n", + "thL8bPO+rkXds5ZAXRGpYYzZb1e3RGdu1Q7Hk8ZfFH4Gbgd+sb9n2t+zjJ2zAROA60Skg6iTzVXG\n", + "Y+a/QCISJiId0Bf2BOCFI3YWaSfqzI1EH/ocCh6qrUArEXG3GWGXnUCeiAwEin3ZAeyL9C7wgqjj\n", + "MFREuolIBPARMERE+tn1UdbJ16yIc7xN1BlbD/g3MN5uGwPcIiJdRVFTRAaJSIzdvo0jHYKB3Kei\n", + "2v0dyBSR+0Ud2KEikigip3v0N1B8C7QTkWtEJNwuZ4iIO/y2uLb8XktjzBbUifu6iNSxbffyuC71\n", + "RaSWR1vex5qMCh0HtbMH2mdPlOUZOgx8ASTb69wR9SsUNxj+x+7fCR3Qx/vayV6faegzGivqzI33\n", + "uEYTgFH2uasLPFDEMd8G7hWRU+3zkiAaegtHPoNF3bP1wB+AY6/r2cDgYs63yhAU/Ipf0CmqW6DM\n", + "Rp1G7t8YY6YCL6L2w1XAT5QtTtdgoz6A3cDXqKZ0mikcZuo+RiTwlN1nC2qSedBu+8x+povIH3a6\n", + "Pwp9AXah0/6vfRzfH+4FlgDzUbPTU6h9dCNwIfAQ6nzbgEYg+XuODGpmmIZOp1cDjwMYYxYAI4FX\n", + "bR9Xo7MXN55CBUGG2GgeArtPftu1g9pg1Fy0Br2WbwFuIWp8XBef18kYsw8VhFegmukW2+eIQNoK\n", + "4FoOR23GK1ABNMr+bwWqIKwRjfZp4n0sY8xBVPCeiwYhBNpnz/Mr6zN0O3qvtqKKxLtF7OvGz6jT\n", + "/kfgWWPMjx7H8T7Wtbbff9v+fUaByXEMartfhArjif76aoz5HPU/fIw6Y79AZ5Dg9QwGcM+uQv1I\n", + "u4BHUN9TtYQUKEql+LOGpQ0CthtjOvvZ52XUqbcfuM4Y81epDxhEEEEccxCRVuhAHObHdBNEOaOs\n", + "Gv97aOibT4hIEpBgjGmLRmG8UcbjBRFEEEEEUUaUSfBbJ2ZGEbtcgJ3uGGPmAXVEJNCohyCCCOL4\n", + "QVnMpkGUEBVt429G4bCqjWj4VBBBBBEEAMaYdcaY0KCZp/JQGc5d74iD4MgeRBBBBFGFqOg4/k1o\n", + "MoobzSkcmwuAiAQHgyCCCCKIUsAYU2IiuYoW/JPQsK5PbfLMbmPMNl87lqbzRwtEJNkYk1zV/ago\n", + "HOvn11IkZT3EZ0ZA51thzCQ4fw0kwdTJxgys6v55QhypCbRBk5Li7af7e1PU9JqKhk2mAKm8TH9G\n", + "ca9xmeyBIlOnQH/vdqvjuQaCY/3ZLK3SXCbBLyKfoKRRDURZJF1oKjXGmNHGmMkikiQiKWi6/fVl\n", + "OV4QQVQFdsC8kWDGHCRh9Ddw0xDo+QZrNhzklarojzhSh8IC3fOzLhoa6RbuS1COnRRgg3GZQ0e0\n", + "lyynGpdSDaTByyMhfoxHNuuNkLqBqjnXICoGZRL8xpgrA9jn9rIcI4ggqhrZsHoOjEuCO2JSic7a\n", + "TsKEG1ia87qZXBHHE0cEzeD2JdgTUOXKU2ufjUbPpQKbjKv0TtKlxkxOFCEJ7oiB6H2QvQFeWWoq\n", + "5lyDqBqUKYGr3DohYo5xU08fY8zMqu5HReF4Oz9xpB6qSQ81LjO7VG06EoL6vLzNMe7PA3iaYwp/\n", + "7jCu8ntxj+X7V97nliiSFAejYiEqE3LS4OWqHBRLKzuDgj+IIEoBceQSlK+/i3GZHD/7hKOUw760\n", + "9lZoar8vwZ5qXGZ3xZ5BECVFokhSN3jJ0ww2ElLmwJ1VJfyDgj+IICoZ4shnaJ2H9/HtTHVHsRV2\n", + "purnGuPKZ3EMoppDHJFeLzE9uTZ9VtWHbTHwiCUCr0rHd2llZ5CWOYggioE4UpsjtfZ4oB1aVP0y\n", + "YBkq0JcD36ACfp1xmYNV0ecgSgfrOG/na5lzExGPbId26XDizoKCvDFKFHhUISj4gzjuYZ2pDfCt\n", + "tSegL7anOWYeyjqaika13Q1c7CtiJojqB3EkEr2vvgR8TZR917186/5+7tN86ivUdZ+W66w0ePoZ\n", + "SttG0NQTxHEB60xtiv9ImVwKm2I8v2/z50y1g8Z3wG/GZR6v4NMIIkDY+x2H1qr2Fu5N0epYq7yW\n", + "lcAWf/fal43/RkidC6Mqy8bv3QehdDlQQcEfxDEDcSQMLUDiS7C3Bvbg35m6y1ebgURxiCNxwJ9A\n", + "b+Myf1fM2QXhDTvo1se3cE9Aa0n4Eu7rSjs7SxRJalGFoa7uBLu3T4Vz10Cb3UHBf1xDJDEJ4kZB\n", + "bBRk5kDay8YsPeZir8WRKFSI+wqBbIEWF/EW7G5n6r6SHKskURziyC1o1agexmWqZbm90qKqQxht\n", + "NnJbfJtmQlBh7i3cU0p6v48GDBWZ+YnQu9F98Neb0GJv9aRsCKISoEK/20swxqN26Mh4kUSORuEv\n", + "jsTiW2uPRxObNlAg0FejZQpTgbXGZQ6UVz/iYNQYSMgOg/Qa0HwvjIGEJLgDLW/oibfQylajgP+V\n", + "Vx+qGn4Gv/hEEcpT+NvZWit8a+8N0PvrFuwz0ZrTq4Cd5ZnTUN2RCTm/N4NmeyFub+nbCQr+YwJx\n", + "o2BMAs3nQMeJMP0xyB2TAEm+BFSVw07R6+GfdiCWwlr7ArT+aiqQZlwmtzL66XaefZ8Ao0+DKeN0\n", + "va8oDuMyeeLIjcBccWSScZnUyuhjRcM9+L3QDVrsgcv+LnLwKxL2vjfGt3Bvhc7W3ML9b+ArVHtP\n", + "O9ZmUaVFGrx8U0e6Dl6dXx6yVAgK/mMCserd39UWam2EW06Br96DjTFVFmZmX/Im+HemQmFzzAy0\n", + "8HUKRTjYyq1/AZjGMrWgPWduhBsuKAjf8xfFYVwmRRx5Chgjjpx7LGiisRC1owY82RPmjSlYX1QI\n", + "ow1/9RkSiV47T7PMb6hwT/WXCBdEAZYaMzn0AcmI/JJVqfp89i5NO0HBf0wgU1+Y/Q3g80+h4+cw\n", + "7BJICW0hjkS7CbjKG3Z6HofvEMg2wD4K29m/8fi+q6IEY3FCPVDTWD5h2T4Sah6ClHrw9K5iCcte\n", + "BIaiBd/fKv+zq1xkQs5jveHqxRDvUWtvTxg54khHfAv3WAoL98mo+Wu1cZmiKvYFUQzEkWZEU2fB\n", + "VbT/w2VyS8vOGXTuHgPwKchirlrLDZ9vpO6hhsD1xmXmlqptjXlujW+tvQWwHf/O1DJYIUsHP0I9\n", + "Bebc6RbqIgOnwuT+DLkZtneCTV1h6ymQe8lUYyYXysB0R3H8OZzT6q1ic8g8HirOti2OdELt0KcY\n", + "l9lY7idZSRBHQurP4t49XXnqsV8I2RILq+rDrIbkZtXCEMI6jnSqrgI2HwuzneoIa07sa1zmKghS\n", + "NlRLVGY0hAq8po9CbBs4YGDPLpA9nLY/mvMWJZARNommOcN9Tadt1IQ/srAmKIe7rxj3tRU1mygt\n", + "VKhP6U+bH2FrF50FAZCUL9RFhs4k5OPenPQRNJsHzedB/ZWwJzSThplj0QSteaiGmgcgjtzHtsiz\n", + "eeOcyEAip8SRR4CuwJDqLgTFkaJCIpGD7DkhhUP1dnIwLJ3d6cLozRfxfjBhrfIhjnwJTDQu8xEE\n", + "KRuqHSorGqIwWtaGMW6nTz34NyzoDytOhItPHcjBzevEkVftdk8BXwflcHcL9EXAFxTB4V59ERuF\n", + "HIZuL0DcbMhsBut7wvYtLcWRFsZlNkBmDnlhsPA6XQDC90O9Hps4FHsuYVGXU2NPDGctPyyOzAHm\n", + "8dMJZ3LiwXPhzBDN9eoHjC0qcuq/wB/AVWiWb5VCHKmB3mtfAj6MAm19JfCZ/V4HGGsiaLd1fJBX\n", + "qKphZ999UTNi2doKavwVA3eixe4oeOhcdQwaga9qkLatI1NRP6GvhSK2+d/3rW5ns/m3RjT8G5rO\n", + "h3opujT+DurlAHlg8g4TZgTYi5KH7UedbQfLpQ/lt2/p28wOq0te3QgwIAZCciHkEIRlG0Lss27I\n", + "43BICHlRYnMfISXM8MMAyBhf8BzWHQYDJh9GCOGHfsLIqfD0LjgcCfwb6A/y1A8mb0q/I58AEEdO\n", + "R7N6OxuX2e5rn/KERwKbL+HeEB3cvc0yq/BB82yd8zOBD43LvFPRfQ+ieIgj5wGPGpfpnr8uqPFX\n", + "L7hDAcMPQ6J95cXA7GhytnVkAXYsYEVsImlN+pIXFY7kHKL5lh/omLk4f3vxC4Bhb/0OQCNazYC4\n", + "ObArAVYnwboVcOhOyKkPUY8v55Lf/wv8H+qUfQsVAP7bLUkfym+/0u87oVlfdnZ/jLwXW2Pc48Gd\n", + "a6kz9wFuWvMDkIDQjb2hlxB+qCthJoztsRn82OkQGeObEZ6l/zlUAzLGwycDf9KmJ/ZjVxdovEh9\n", + "AjwBPAxxOeeKI39SYB76HVhhXCbPuMwf4sj7qDN4mO8npWSwArkRvoV7a2ArBQJ9OfC1/b6hhCGR\n", + "g9Cs2A/Ko99BlAsGUU7h2UHBX0FwhwLWPAS3zi9Y/w2kLvnFjIZ8R+T9Xo7IKJjzY0kTryR54A1A\n", + "R+bfBvNvK9jQ+g3YOgSy6wNvbDSLzDhx5GNUEL0EvAM4JUl8qtZZwi7GiSRmwHV3QEw07MuGDa+Y\n", + "rFR3/+bb5WUAcaQ5LTN6ElLjOQDip8GFI2DFxbDoWthQI5q8UK1ota431FlnBT9AKKRF/oiWHD0T\n", + "tf/8B2ggjvyBDgJ/AJeKIxcZl/kq0NMQR2rhPyTyAIU19w/s99Ty8LnYmcPTwL8qK2ciiIAwiPJS\n", + "IIKmnopBIIRO+Y7I0AOaa7XxLEjrDjvvmmrMlBLxe/uOZnkIBk+EOZMg/dlUmDuqUFijI43Cd/NF\n", + "mOGkrl+zKnodO4pzQAcSNVN432o6QHgh/14AxGyBzp/AyR9CzHJIbZDDL9OjSG/v9a+L9kPK5Uec\n", + "tyMNUMduV3RA6I6yPn4L/IoOCAuAQ7jpndfWuICcmH7UPhhLnawoog5BCCs40iyz2h+vUHnBRo5c\n", + "A5xT3R3TxwvEkbbAz0Azz3sSjOqphiiO0Elk6EyY0JvwLOjyPsT9pkv0xlyicqeiyS2/AfMDKdqh\n", + "graF1XR3x0CO4f8Wt+PHhL9ZnfOYt4BKFEk6C17q25mEu/rDjX/C5l9InZ/rMTg5EoMKp7ZAAitO\n", + "uJ2oE5tRdy28lAp54ba1pEKhkCUZIKoDfPf3xlR6fPMaJ+25mBg5m4yThUXDYekVcODuXOJ+/pLr\n", + "199pXGaL33aVJbIZ8C5qf89CTTK17C6ZZIbtYmVCfbbeGUt6O0hvB5nJKZi5R1yrio4UsxFeK4FL\n", + "jMv8Xl7tBlE2iCN3or6iGwutDwr+ow+FtExP1O0zgzt/fg3VFLsDJ6Ep7O6B4DfjMmkBHcORb4Ax\n", + "xmUmeW9zO6D3RcDcZvDQebChNhzcybaMVqyicMTPaiCFHztfwKYX25HeFvY2p8C/OvRnYyb0OeLc\n", + "+rhg8TWaVQx4DxDVCYUHTmsicsf+R3YYTPtIF523taDVjvrkyEZq5W6ngAVyHrAWdZx7FvNIQFlB\n", + "U4EuwMeo5r8WFf6nMbr7A2yZ3ZTQA9BgJWw7STsU3m+mOTjtHHf/fM0iR8D+jZAaCptLOgj4GkSW\n", + "JXMKcJJxmRKbFKqazO1YhjgyDXjDuMyXhdYHnbtHI9JehpHxR2iZGTufMy4zGZgIuBkpT0MHgSuA\n", + "l8WRg3gMBMBCP2GXO1GSqyPgdkB3u0EjjhLSoWEWfN+KBsAPKNvkOncsO4AkD+wMfdsd2do+L9uy\n", + "pZGI3AsnfQQzHbu+6mgkioMV8j4FlTmw/Ftx5CdU6HYhgouAHmiWag3UWZ6FXtPDwFKUPO5rYJ7l\n", + "8unHQRnLC33bkFMv3G3+gmargaY0/BuuGQCLh8MMBxof6iGObERNQ/POqcml/80jYU592BcB56+B\n", + "d6HGw9D5MehcknBhn6ZIod2G5dTP7MCpJb12VRO+fHzAzrrPAi4trzaDgr8KYczSySKJqIH/SC0z\n", + "fz9NupptF3dkRxsKZgQjgHhxZAEFA8Ec4zI7KULwux3Qi98o0NsB+tThl5//SW2UJOu6RJHGbk3u\n", + "HMJi/+C8zZn82LTgHzemwgYvGgNLI7HkarhsGMxMRo/iPUBUL4gjofgPiWyEzn7cNvfJqIZ/KvpS\n", + "GuBD1BYbD/QE3mdFbFNp3i2bjF659NtUn3M6nMcU9+UaGQ8r9wCaPfz6UhgwCu5oC6tD0tB8iq7A\n", + "nbPuoHEboH069F6ngh+UlxhKRp7mJl/bWEtZRwHeNrReMZP1v35acoI5d3ufJELjfXDOutKTuQVx\n", + "BM5FlYfM8mowKPirGEVpmX7/4zJGJLE9xF1tHadbqLXmMe5etQcdCG4HPhJHtgKZwA5x5Dtguaf2\n", + "ngZzRkDPd1VjBdQBvXM3z6Ha6jWSy/SQ8zn89XTqRRwGyOU6pm/5ipP+2MOJWf4Gq/zZzOa3EsgL\n", + "h+ZzYeM7PgaIyocdOE/At3BvA2yjcELTN/b7eu+QSGveOCUGNq+LJ3JJP8460Ii7gCXAh7wWP4Wd\n", + "fZ7DvN0K/gNT74FbE2HZMNhwNjAmgXo9N9Gz3R5qt6hN/VVQYwfsD8nllP1N0UiOt4A/erzOozP2\n", + "co73vH59LXT4IfD6r7EQtT8ceozQouE3/KXrG+1kUwkuZaH2AP5oCk2s4C9Jf4IoEuUWxulGUPAf\n", + "hfDpiNw7Mp7k8DuNWeqA1Vw/bnEze5v/m7DIjoRm/U635XniyK/Ab/V/I3dQJMOvO0CNh4FQYCHs\n", + "T4GxHlPzsb3ryYhaA+jTdSR887FygL+PaZLEkkWTzWK/tvqC2cygO1iddyJnXRLC5/VHVaZj1/L6\n", + "t8W3gD9E4WiZsfYzJdCQSLd548VwEmocAkmFkW+QMqsmI1beRyhwLSPXDWbl/jA2/Q9WroWMujD5\n", + "Vegw0Qp+IDasKZ1SdrAxfRvzm+5hcZs09u58geRlM4GHgYeA/2zfx/M3QZynOeUh4HoPRqRA679m\n", + "Qk6NQ/Djh3D+tbA7Cu6ZA9mHKRW/knv2GHMQssIL1ld2PdpjDVZJSQKeK9d2g87dow/5jtMWs9QR\n", + "eKC23eLJR+NjcJAb13LGdx+RtDUydisj8+pRt206dE+Dl6dAqIEkmDrZmHyBPlRk5njo/UUHGLIK\n", + "Iqy+OxR+nmBMn4D660gb1PnZtLzpH8SRCDRKxpdwr406pb3L7602LpNe1mO7neMjh6jgfP07aLi/\n", + "8DWU2CGz6TCgO11fhRrrYNFtmh+wrTP5BjYZMA3X90+gpqGeQDc0s/oXYBZKhPcokNvyI8Z1TOHC\n", + "KGiWB/F3Q41etj8lqf/qaZNPq6XCP3wVGXk/cM2yvJLb5N3tte1Bwo4a8OwPlV+P9liEOHIy8Llx\n", + "mbY+twedu8cTrON0yM0w4TPY4Rb8no5TW5zlxK8gtZ9mopq3W/N70hlm3uSBQ0XO/CiU3n81hiWN\n", + "VOjDkVPzTMgR4NLlhXtQEk3OuMwacWQl3zV5SJIHditpXL9HoXRfwj0O2EiB9v4XWrRlFbDJ07RV\n", + "3nCbN16ZAg+fAyf/nwr/mBUe13BfbmZ+Ul2DsXDSm3DVBMiupwPA0vnryNz4knGZX1BB706gOgno\n", + "BVyCDgbZwNb11/Dsep2dXNwpmb7/hTteLUX916XGTE4UYSDccagm3ep+yebfryEirzsDxZGpJb1u\n", + "7vZmhvHsgdrUWQaLK7se7TGKcjfzQFDwH6WwjtOo3R7aPhRynEZH1GTgNdBkgc4KMtrYDTo4ZEJO\n", + "xGE4c5Mu+S14CfR8TnqvRLRiOOmPxPSGC1l+zr0wLqZgZWEOfHGkLirMvQV8W9SK7WmamWE/1xiX\n", + "OViivpQT3OaNqFzVcC9aAdddBHtOpa04Ule55z0it3YOh+ktYcbz+4nfsZXTn47kvO0NCOV2W7zk\n", + "a+My+2227J92edFO99uhA0E/4B/ATcuSmbNMnb+z0KiuXAg8cW6pMZPtoNoCOJmCJLP3xZERJc3a\n", + "te01AM7f8JkZXqqLGoQ3BgFOsXuVEGUW/CIyAC0+EQq8bYx52mt7A+AjtORaGPCcMeb9sh73+IYV\n", + "JpF7EsipY9cVRNaII724LeJ0/r4R3lqg2n4+dHAIVKC7NbmkIhLRAsLsUzpweFwMoQeg/mqlQa7f\n", + "JoG4SW+JI+tRwRZJYeH+JQWmmUrn9i8O3tewRxp0H82a8TewDFgsjow0xhwZuWU2vGJW5w92NYCL\n", + "UGH+ujjyBRoZNMutddtMzZV2GWP/dz3wLHAzcBPQTByZy6/1txI2pC+57zUr6Knv+ss+qBn2iCP9\n", + "0TDiz8SRK0tRFWsfOoBUOY72vAJLl52IRomVb9tlsfGLSCj6MJ6H2iTnA1caY5Z77JMMRBpjHrSD\n", + "wEqgkTEF2kTQxl9ySHSHIdy/4msevewXyMqGDa+QvOxHIBm4jvl1R/PdpdcckSPgQdtQXGZxufbX\n", + "naXc5kcYOIr8DNWsqavot2QkKuC3HW0UAf6uoTjSF83W/QG4J5CBSxxpitI4/wPNDxgLjDUus8rP\n", + "/rHAY2huRzKwmdfPfonts1oRlg2hBwtmhKEDfjK5U8/z+v8NwLVAn0I0AOo3+QglabvQuMy+QK+H\n", + "HTjuMS793yN2AAAgAElEQVTjk7G0suD2OYwWEtykrCMhZQ7cebQIf3HkKmCYcZkL/e5TRTb+rkCK\n", + "MWad7cSnwIUoK6AbW1B7JWimYrqn0A+idGjdcEXNDYfIvYTPyQRZfArNN2v8/hagi/l213aRxPmQ\n", + "dAdx2eexOeIXDm963lPrsy9AJb0E1jy15jx47W+P9UvXmNmLf6mcPpQ//F1D4zLTxZGTgOeBRdZ0\n", + "MqOotozLbAaeE0eeR00v1wK/iCNr0VnAeE+eHhvX/U9xZBwa8rmDjAbbgFa0+w763Qtfvwtr+0Kz\n", + "A33EkYWoWWgWSh7noNQMxqsfB8WRK4HRwI/iSFIJ+IH2ATHF7lXBiINRr4eQ0PM6eHsSdNh5VOYV\n", + "DEJpvcsdIcXvUiSaodWZ3Nho13liDNBJRDajBT7uLOMxj3skiiSdtp//tthP+HjofeHp9E8/n9dj\n", + "VjIHuMDN/W7M0snGTB7IDTPX8vC026qWIyftZZ1xeMJX4texA+Mye43LjARuBcaKIy9b005x/zPG\n", + "ZRYal7kbaI5q9b2BNeLIRHHkQquVu/efD5wBTKP5Js26/fsy+PZNuOgfOsPaGjYDuAXYgBKwLUWj\n", + "nm4RR64XR+KtLwGATsn0759M81Z/0ix6F+tbtZGrAzztamHqiYWoZ3pArQNw4s6C9UdLXoFNJOxP\n", + "BQ1SZdX4A5mWPwQsNMb0EZF44AcROdmY8stCO94QB6MeiKDliANwwZWwJRYWvUPoXekkTPZtu/Ob\n", + "vVsR8OdcFEmExj1Gk1P7ILtZ5Tvx69iDcZkpVvt/GVgojlxnXOa3AP+bi778k60D+DLgbuBtcWQ8\n", + "OhOYb/d7Tt5ps5PYq14j8+MapAyANxbDBafu454NHWx7z9oaAcvRGUUr1GH8OCDiyKyY1aSf25RB\n", + "X2yhhUyCJ3vCfy/kvbhOEp62rFj/XLXQ+NOaETq9G/w5unBW+lGUV3AmGpVWITWbyyr4N6HhdG64\n", + "Q+s80R2tWoExJlVE1qJRG3947mR9AW7MNMbMLGPfjlnEQtSeKKiXDReuhGsXaXx9EdrMTtReW+Eo\n", + "yB8YngDT0EcsoqdI4jPGLHXEkWuB/xmXqZZEbRUFayq5Rhy5GJgojowFHimJ89S4zB60fsI74khr\n", + "VHMfBxwWRz4EPjIbzPsS0nE7tc55ktrSgYMHt/J9xL3clZcHfCWOvItq+h9bPihQp7Kg+RA9a+Ty\n", + "+PJLaF6/pmbgThwPtQ8Qfs8g3hBH5hmXWX5E5wqQRRULfnEkNPRqGp42ix0t9tDQvb5U0WhVB59m\n", + "HhHpEw0jG8KZEWWQ32UV/H8AbUWkFbAZLRJwpdc+K1Dn72wRcVcOWuPdkDEmuYx9OebgT3POhJzd\n", + "UVD7gFIpu1GENlOJGn/cKBieQOhXcPgF98oaMOJ+kcT5JDMVqC+OJBqXWVo5fao+MC7zpc2efgNY\n", + "II5ca1xmQSnaWQs8Jo48jhJ4XQv8JY4swsWHsLwn+n4/DfyPKY0/YMFJy2mz7xYu+b0OPzV4EFeh\n", + "9gz6Xq4ZKnL9BGi+NQaWNVSN+fbf4W1h3aKBTBdHBhfR5+qg8Y86XINtmb9zTxLcXhnBCxWAQcBt\n", + "3is7QY1u0HWMckFR2oiYMmfuishACsI53zHGPCUiNwMYY0bbSJ730FjhEOApY8zHXm0Eo3q8kK85\n", + "h72cwOFIMCG4+ew7sYzaZ/BeQjNO+MDWdPKXJZkokrT7Ql6LySKv9Y+sruiQNo3eadcbHoczXoeD\n", + "MZqoBLgzi8WRp4E84zIPVlQ/qjushn0F+u68CTxR1nwEW4x7MDoI9EZj8j/kq6ZdWNPrMfZ+EsFl\n", + "wzSvY8mSw5z+00ecvfNG73h9d0ayd/tJMHVKMqNRR/JlNunMuw8hKB1GeEUmz/mDOBKPZol3My6z\n", + "urKPXx4QR5oBi4ETvLmhPO9NZgTUOgilkZ1lde5ijJlijGlvjEkwxjxl1402RssLGmN2GmOGGGNO\n", + "NsZ09hb6QfiDzbzt/hxcnaTEXYxJgBZ3LDVm8qIT+eqHENYPhZ+TYKo/od8NXrpjJ62GCG2mQP9u\n", + "8FKiSFLF9TszJ38iufYcOP9+SJhqt+VnFn8EXG2FxHEJ68D9BDgFpdyeJ450LmObB4zLTLThf22B\n", + "ucDj9NvxKGfGRZD4MbSYDXPvgt2fhrIiYTDwqzhSqLSYzU9I8VznNpPY8pFXAp+Lc+RzZIV9Nh7E\n", + "f5UFO5iOAf57tAp9iyTge181kmMhantNuGUwdLvRxz8DxHH74lV/WFqGXx+ELafAzadCi19xC8+s\n", + "eLZsOYkPJxjTZ7IxA31p8W6q3Ab7Id2+hmMgoYWGtFUQ0l6Gv7Ra2M4OMP4LuHg4NJ2PO3nMuMwS\n", + "IAOlIjiuYUM4h6CO3+niyIM2saqs7e4wLvOqcZmujO21mLww6H8vHIqG00ZDzW2wo9E61Dn8qzgy\n", + "yj0QLzVm8hy4Mwmm+lIsjMv8BFwAvCeOXOHj8FVl5x9pj/tiFRy7POHbvu9I5B/n0bjjbRB9CGa9\n", + "W/oDBAV/tYWNe88Lg5+egm9Hw9DLoN/8xvYFrQ3sLqoFN5dM0mq41yOGpCJD2jRKJ/UZGKHCP607\n", + "THoHru4FF832dGR+hDonj3tY7f89VPPvC8wWR04stwNsCd/FT0/CCxv1OWq8CO5oD8NnngIMQDXM\n", + "YWjMfktQ4T/ZmIH+FAvjMnNR393z4shNXkes9JBOcSQODSIpMdVEdYI1150DTPVYJ+LIRcCytM7s\n", + "6f0+6//3PdQtaU61B4KCv9oi7WW16VusToK3e6+nS1oeyg/fCC3p5xduLpkm+6DjjoL1FR3SptTQ\n", + "v18OSVNh6M+sfHMqm8LeocveQeLkR299Alxqq4sFARiX2YCGVr6PauF3+TKHiSQmiQycKjJ0pn4m\n", + "FmO6s8+SCdFkrq/ehxcuXMPevDeB01GTUCaaVf+HODLCM6a/iP4uQX0JD4oj93tsqlQHr+3rm6gp\n", + "6mgPGOgFLHOzx1p2zp/QcNtbD71gzly5nVvds7HSHiRIy1yN4asGLMnLfkA1m9uBx43LPOnv/z7L\n", + "61UhVa448hxqZnrQuMwLtpTh68ZlJlZ2X6o7rJPyPfvzeuPSqlilLWJfZD1hNde8hgZo7EeDRf4G\n", + "rimqkLxHX5uj1BRfAv8GfgXuNy4zu8QnXgqII9cA9wOnVxVhX3lBHHkR2AG8jSbuXYjScYzxNZMJ\n", + "Fls/ziCOLEIjpR4HXvDHcVOZfDzFwWpmY9EkpDuAXDTT+OKq6E91h83evBN4EHgEeJPkAVNgSn/C\n", + "cqDOWmVdPRxJWYvY24zih1HSt7/QBKII4AOUxK1IygZxpCFqnpiHKhrPG5f5vrT9CRTiSCM0AmaQ\n", + "cZk/itvfF6oTmZs4koJGY12DzvweNy7j16QbFPzHGUTr6yYD/0FLBV5XAj6VKoMVZlPRQuWjUC6b\n", + "1kdD36sK1t7/AbCXVwbEkD7lLOqvgqsGQ+0NsK8x7MvMoPmu8WjhmRT7ubak7Jo2sugttGD8LDSW\n", + "PAq9Z28DU/1p1TazeBKaCHaPcZnPSnXCJevvZyg1979K838/ReIrnczNKkW3oY7pb4H7AolMCgr+\n", + "4wxWMxgIrAf+ixbsGGZcZl6VdiwAiCPRqDmgPcrf9KFxafjv8YhA+PNtpM/95IQlM/WtcBZeBwiE\n", + "5ELt9dDs0j+4bNEHqABraz9bokqB52Dg/lzjb1Cwg/PNKInbGKAe6vzdhNYq/hSNBlrgPdO093Y1\n", + "WjWseylonQOGOHIJ8BTQJdBymd4YKDL1kyj6f9EB9kbCP+fqeu9KdBUJceQUVOC3Bf4yLjMo4P8G\n", + "Bf/xBXFkJ9DRTchmvf5vAU8CL1UlvXGAgqwuSuPdDEg1LpNYJZ2tYpTUZi9nNbmV03JeIOPsSL55\n", + "C/Y1wZtuO39fHSxaUDAQeH66BwXvASEFHRSybSLRyygn/Buo2el3IBUdCA6gA8A44zJpHsd1O433\n", + "orTO5c7LJY7UQ4nmhhqX+bUU/48Ckk5Yw+icpjTou1YLzg+2BNglKS1aWogjjVF/3SDUlHc58JrN\n", + "lQisjaDgP35gp4UHgRjjMgc81rcGJqCMqSOKsg1WWN9KIMisU/CPyC2ccNanLDlhDxlVbWOtbOTX\n", + "Tz75A2g2H1IGaOLbocv92uylxokX0Hf/CyRubcGMhL+ZLw+ZvGUlul52UIjD96DQCtXY3YNBBJoR\n", + "PAcV5j2A69EM3eGowPoLHQS+AFyogzIeTVAbWB41jr36/z6QaVwm4JwUO5PpBVyNzpAXtfuRhnP/\n", + "oJN3aGRFavx20LkLuAet2fAEkIfS3jQpUf2DoOA/fmAdcenGZY6Ix7dxwM+iL+rQ0jq8PFES55fI\n", + "wKmETOpP/dVaV3ZfY7vFt/Ox6ely866+vDnpC+hnSZtHwJbf4cbjQfjnF6iptxo6fKlZzk3nw46I\n", + "3TTf9QRqW1/mawYnjpyOCttlwK3GZXZ471OqPqmAbEHhAeFElBOoLhr6GYEOCh+jM4BmaFx/D9T8\n", + "uBi4Dp2BDgL62WS18ujfADR8M7E4IWmVpC6osL8C5a0aB3xqXCatMiPfbF8uA55BB8r7jcuk2G0X\n", + "AbcZlzm/RG0GBf/xgUSRpPp1uW/uSHr0fYbp/oSwOHIZ8DrwaEeHNS1M6aIWinJ+LVPCtZZAZ9Qc\n", + "kEh6zQuodbgme1rAtOdg1RD7r6E/GzOhj3f7/UQWuOI49eIrYPI4ON2Khn6wYJoxp5fs6hx9yNf4\n", + "PRGRCR17/MlFS+ahfpxwdACYCvzoOZOz2uOjqOZ9q3GZL488RmA1eAPqryNnomGmB9A8oDjU5NIA\n", + "depm2P7WRGcE09FZQk/gPOMyRxA0lvD4tYAlwEjjMtOK2K81Ws3sajRh8WOUkXSZ976VEfkmjpyG\n", + "2vFjgbu8i/KII2PQAb5EWcdBwX8cIFHEFQ/3twujxvwm8GgajC0iAkEciQ/J5vvmG2i0+Atialuj\n", + "UEmiFtykUAdC4ZeWsPQEXcbHsSerIaHoi740f3n/jFvY+HM3cr0nI741/ktFdk2Eul+3h+/awVvf\n", + "2PWwa6IxlUIlXZXwbRorsNlbLbEtmmE7ADgb1abdA8GfxmXyxJEeaPjfXGCUcZkM/+0XH/dfZJ/V\n", + "TPRP4IHwXSwx0XRvuYQtbaaxKqUxH6+9kS7AqSjbZ3d0QAhF63csAhZQ2KeQalwmK8Bjvw5EGpe5\n", + "wce2hsBQVNi3BT5DtfvfqsrnJVpO80mUWO1h4D1vDh57jzc2+xJX50VcVhIFLSj4j3EkiiR1hc/e\n", + "9SC/+jf6NP23CHvk+REyrW0/zp8WDxM+g1NtOk5RNkxP085hOGki1N0bqUVfOm+DxO0wbjd/zRrO\n", + "OZYjPh/FCTLvYw0W2fWtmg8wkE8zO0jY812eqeO9/7GIopKrjthXo2Z6UjAQNEALH0xFI6XuQYu3\n", + "j+yUTMhGzvpgD3Ma0GkCtJoBm8+ATV1h571TzeGpZbJhx3WS6w6fzmu1Y6lRPxuywqHVJDZM78GE\n", + "vYk0MS5zje1zKEpF8QTq9E1FC8EI0MYuu/DtaE5xDwriSG9UkCe6Zz3iSE00yelq1Mw02e4zzbjM\n", + "obKcX1lg79M9qC3/LeAp46fusjjSJeQg3414kv0lDSsNCv5jBHb0j0aFYf7SfhpP3JxHYkY03DEP\n", + "GioTDg8DK4uIQBgqMnMC9B7fCWa1hFftIzQUfv4bnvG23QN4mnb+g2aIeaOogaMkgqyXyB894bQn\n", + "PNY9BEw9gYN/3Upn46fQeBAKcaRlw+nck5DC0MgwGmQbslZ2YcGB+nS56HNCN+/rXetnZkL9leo/\n", + "aPa7OpFrrTlM+OHZaGTVfDRaZ11JNOOBIlMnQ//He8HTPeDMTbCoMchGNu9sx3zjMhf56O9QNER0\n", + "NToT+BzlbVrPkU7mBNRBnIEOFicBX6HCvQHqqO2POp3HAV+VxDFaEbDv7zC0DsLvaPJbkeYtceTf\n", + "TRYzcvMXtEyPhuxwaG6HiOKczFVVbP2oRXnaPX22r7bXul5LvQDW1UOV3wyPZdfeljRcl6HETJ63\n", + "OZSiuXfcfD3Dlunixm6I8WG7j18Vw/5zWpNwbQLcNxv6bdeZhadgLq6Skb2OAV3LXfDIchjzMDQN\n", + "RbOGlsOWTe34FCUN61NWu/CxjE7JdOoGA8codxNAreE76TL1HCKn3EaNiPezNGgzvb0ubtQ8dwb3\n", + "TX8GrdV7JfACECmOuAeB+WhJx23+jh0LUQLc8TuMORVC8yA8FzIaUw/oI4609U5CMi4zQRzZAYxH\n", + "NeJGaFH3SNKi5/LtKc3Z1szYd/J+kpdNRR3Hz6FV5DqjTtrDqPzKQP0JfYE4m9+yGjUfVWp5V3Gk\n", + "K/A/VHEb7qtegR8MarlCebe+6ADzmmuBeKg4QsXjUvD7sXvGiyTiKfxFC1qXRnjXpeCh3EVhIe5e\n", + "1gJ/eq3bBWT4SkYZKDL1JR/FMRbC/qKEsOVWj/eOWshBKZoPhsDYk2FdHViYQMLCBpi6a2FAipK7\n", + "uQniB8OuGrCkvJ1fS42ZnCgyMsfLubZtlpksjqwGfhJHennGiQdRADf1dmYEbI6F9ukwNpu6gyez\n", + "6+1fqPFMgxWMixjG9oPjPf51YypZ2/5nXOYHlGMHwF0A5Ay73AmcLo7spWBGMB9N2toLBUpFnRz4\n", + "dCJcPAze+BauGIRBHbxzxREXyseUX5TFuMwMcWQwmuV7N9CJHxrdQb06DteurkO6aPGev2e1ZdKu\n", + "Z7hgS1fgUvSd+QS43LhMqiWwa0bhGcJV9jNeHNmDf/NRuQ0K9ro9hUY1/RtNSDyCS9/PfxsAnWJX\n", + "MRc46UAYRHkw8lQUoeJxaerJj6SI3QzdnofoDIjeBbWnZ9AkcyMFwjsS30LbnzD3XL+/PB1KvqJr\n", + "rof98+GZpcY4xf3XM2phZVM+qdmKh2q3p/2cOH3Qbv0dklLgmTQyJh9Wm7snKjOT0RPiyF3ArUCv\n", + "QAjDjhdYgXF2y794peEJNF/eEK5YWqApXgoZE63v5DtieIUTyaEmC0Nydu/J23d1ILNbK1jjga4U\n", + "DAhdULPM/JjVZPWZxeDPNxEXeRge6wWvtiXbrOSBHefxb1T470HNNCMs+6hn+4mob+IJkgdcCFP6\n", + "0+156POIWv/Ds8EYQwjZKIncv4zLmEDCi23fm+LbfJSARhr5GxR82uJ9XJ8awL3oIPkmWgCmRAOK\n", + "OHI1cHmnZN7qBi+1707Clhh4flpgYaVBG3+Jjmdjp2vsgC4fQHZdjTk3zy3iyt/+QYHw3leVGbDe\n", + "KG3YmTU7nU2BQ7B5WDbR9XOJeGI6jPirwKnaC/5oD3WqC6MngDjyEOq861NesepHGyzffE/Urt0T\n", + "aA7MaTmHNmOX0/aMzYU1xX6woCXU9ryP/whn65eXEJHZgXeAR0ju1Lek5k5xJBzohB0MQrLpSzit\n", + "amaQVWM7GdsTCDGR/IByyg9AHZttUHPM3cAHnu+UZSH9gXkJIWx9sCWdx0GTPyGtG+yOgw4f5BB7\n", + "IAwNHc2tkcrmi76g/rgsYt1tlJRbxw4KTfCdvBaP0kr7orlIMS6z1/7/SpQq5Td0QFoXyLF99OVj\n", + "YIZxmTGJIkn7BvBiaCiR7b/j70De76DgL9HxfMROA2VlOKwusA6mBPTF64/l+EZD/ToCnWNWMvHy\n", + "8Qx4N+9IAQ9QXRg93RBHHkMrVfU91gnd7P1rR2FBH4OSpv1iPxcZl8ktKgEJjryPy5KZD7xBTsgZ\n", + "jBskpE2KKzhy6cI8reZ7CjoY9EaTB0NRvvj5aCTaVWhc/+/ADcZltrlpE4AbMCSR3g5+egJWD4bc\n", + "KGi0GK4/7RBRua1RW/fIyEzujM8m8tpFcPWSAifoWS3YO28E36B00u5lTUmLsthr754p+JotHEBn\n", + "MgfQLOXpFAwKRdbH8HGsMNQDc5JxmU123WPAIeMyjwbURlDwl+R4JQs5PBogjsRQoGUNQF+U/Fhv\n", + "lL9/OPASSuO8rzpRNhcH+0I+iwrC80v6klUVAuQtCkUjVjwF/QFUyLsF/Yryot4WR4TJHRbSK/0k\n", + "FtwMv/wHDkfYrWVXfsSRYcAnzK/7BIdrDaPR/no02h1LRK4QZgSlJ/gbpYZYCIzj82Z5nJ39Ohsv\n", + "j+S710AM3HTCAXbnjjaf7L3T3fblIjPvbEHvD0+G3+Jg8RsQYuCiKP78+gFeQRUb99IEFcrugWC5\n", + "/VxdUt5+O+P6L+pEfhf1N8RT2Hy0H//moyPoU2zuxWvGZbp4rHsG2Glc5pmA+hUU/CU9ZuAhh9UR\n", + "VhB2pkCr74pqU9+jwn4JKvz/iU6xPwUeKypKo7rDnvMrQJeEl3khYRc3lReHekVEeflNnqo56x7u\n", + "W5lOgaDvDmzBQ6M3LrO+LMcuvm9DZxLzUm/6OPD983DIXSnRd4Z1idp2RFgVc5hJF2Sxb1wMGGj8\n", + "F5w1bA+JKeGE4a66loee91xgPr/XjSIu959k1swlPWo3iRv3E5t7queA504ohMJ5H758UHYm0p7C\n", + "g0FHNNt8LYVnB38DK73ZRG2ewP2o4vQ68LSvkFH7bDbGt/koAXXSeg8K/VDqlXs92nkZjUh6KSBf\n", + "RlDwH/uwjITnUSDsDwBTUEE/w/1A2inkdShf/2/AvwPh9j4aII6EROxgcp1seq37kOhoO5EvC4d6\n", + "RWS3arvWpBiWAy1+hZa/6NJs1mHC8xZRIOh/dbOsVhYq0twpkphE6+hvWTtfqLURhveDsGxYchWs\n", + "nDGLkXMGoJTPt6Hmn7dQ7p+u6MzHoErL4yg3/WI3GWF5cOtYPqt2QAcKDwjxwEYKZgZ1gItRk9W9\n", + "3s5pb/gT1B6Dgrf5aAg6+GVTMCB0ABae8CNL+i1g1Nhs2rjb9/WMBwX/MQT3AxQDUbuiiVx0Nqnp\n", + "PYhHnWq/oIL+e3QKacBDY60Z1oz6O1px2oq1nLznRuMyv1fhqVQI+ofK1AYX0X9XNHz1KUTawLnS\n", + "Rh7lC8Fo6zrIrme3lLGqlTuIoPYGuORq2NAT1veCTW/8avZ/3bO07ZYHKsrcmd9u8/UJbJwGkgfN\n", + "5sHGs1D9vGBGIY6chM5E2wBfJ7zChNZ7uOm3W+h+MJKw3CiyTTib0USvZdiQ0iaTiDr5Ly6KNeVr\n", + "orSO63hU2LsL0OxCHenbKTw7WA4sd5twSlrQxTLTLkTzGBpSMCDcBeTU2En7kFhqRRyGnhv0OYcj\n", + "n/FgAtdRguJMCglN5JoekTz3wQGbkJMNw2dz4vSdPLv5Qs7xVdhCJDGJsDNGk/tuc7IEsoANI6P5\n", + "ck4DXJV3bqVFSUvf1c4j6oOv4NWuBVN9KFmyi7WrdwK6cUXTLjRoD7Fb4JvRsPRKd4tlTJ7J1Hu1\n", + "pwW8N8tj/ctVml0KmmQnkggklbO5M24UjElAetsDhcDGbh7b9+XHpRuXWWwrfv2TPJ5aP5LL+i8m\n", + "JGs//PwadLyQA6nticyLpgPKFtoVGLDlAs7YcgENUd/VYqCGONIS2FDGKLym6Cy5B/AASuqWZ5+V\n", + "VhTMDHoD/wecaPMc/m5yCW1PX0/LWTug4w6on615MklaYtTXNU0Cvrfx/lvt8qtlHv1y0KvcMh56\n", + "b68J22sW/Km8ErqCgr8S4VPLCh0RL+c36MzZ6XWBAWdE0+mDrYTlhMGSE+CMzTB2P3WS/qLnpj+P\n", + "LKwujrSjabd32fxeI3o9DrmR8Nt96DGS/D101QZ+NKX4RBH8Cf9MyAnLK6iW5EZRyS7iSH2UVvgs\n", + "oBsak74VmMOmmjuZ8VkjtncCE+rZYhmTZ9JehpHxR2rVG/wm3FUmvDOsE0WSBopMLZvfJFbt97tu\n", + "RUsFP+Wx7chzt4Lv+V71ZfC+S+nz2hkwYDUcCoWVX1G7xRDSN57GVNShn19wxd7P09H7eC3wKiA+\n", + "Mo93FtdjGxjxACrMX0GjjvJJ42wfU+3yjcf/QtDZQMc6u3l1fjP4oAs02gdf2ny5IgT1IDR72RuR\n", + "wIFMyBGgUZYubpRXQldQ8FcqrDZUZ53ypiRMhVYzEsg8/CD6wN3Wci1PGuh1wwX6j3Ff6Kf3A2Sr\n", + "97iAy9lfZy9xs6HrqzB6gcdeZdVYKx7uzNOFjTVdPW4PXLqXhKU5PCiOzPYVveMvG9mdwVxImy9Y\n", + "mqACYS6aVj/XXRxEkhOT4BUfZo+yCeiK06rLH6UZgH3DznKyhqGX/GEgFKJ+zaPj8vfNgk0+22q0\n", + "C4nMgcuXwpZacNrN8OGX0O0b0j47jSnALHHkfOMyqQD23n1vF7dztTkFiWb3opnH6RTOPP7TwxcW\n", + "gg4aTwAz0BKOAWeI22zkDcCGgSIpb6uZqBB8CWrrY+gDjPDRbBR20C3qGS8rgoK/UmG1oa6vQs3t\n", + "sOxy+OYtyLp9oTETHgYYmCzZyX0gtR7MeL/gn+4HSByJRR/q21Ea3vYcyhnPpVe3ZtIYyGzmcbyy\n", + "aqwVj1h90InM1bC8uc3hs9qwuB6nApvEkTy0oljBkkzaljm8v2wJ/Rulw55wDi7szayMM+gujtyD\n", + "vvhbUPKuOSgPzTJ/afQVKaBLwltUWlihF4nGy9f0+KwZ6Lq619F3bR4ndA+HwwLz3i7WVOEHnrOc\n", + "XuhyYyodlr/DBZtvF0fe8uXIXtyD+jHRMGUchOXB+E4w6CqIWk4z9P7tBn4WRwYYl1nq/X9r4nE/\n", + "I1/Y6xKCOnHdg8HlQGdxZA0qsBPRDN5hvso3lsQEWUJB3RtY6qcqWSRwYKkx0xNFSKqgcOug4K9U\n", + "WG1o2nNe6wsE9G+Xs3RWc85NfYswd8TKjZC6NpzXxZFbURXqJ+A04zLrxBFh5K9RpLbZzaohHjTG\n", + "1cekUBTcfC8ddkLyzIL1SfDLlGSSgNposQ/30gK4eFc32s3pRhO0sIUAZ3JQ9rK1Vjhb6+9iV8QB\n", + "YnesoEf6T8DG4rhTKlJAW8EcRSmFcoDrctE48iyPz6wi1mWiyUNZQFb8Qjr/ay8n1DgENT3IjEtq\n", + "U/Y7iP65abItovKeODLYK3u3qZxD3AXvsiEsjxaghIJfprFu4o1kAPNQzfw+lLvpAuMy84rti2rk\n", + "K7z5dksAACAASURBVOwy1h6rHWoW6obWBmgAfC+OLMGDqbTDY8T3gBcDnQFZzqlABfUg4Ds/3Y7C\n", + "vhP2vxXyTAYFf6WiaJuvONKbTlzb5Btuvz6Li2IgOhOyF57Fn1sH8Dwae5xkXOYvj0ZHUudQDDPM\n", + "dZB0S3U3KXijKE3JuIyRgjKAbpONtzY/B9jK942GsrfTQ9S4pCG106BpGtT7wcVBuZMIU88SdqV5\n", + "LRs9PnfxakISe1rfgtSMJjTzMO2Wf8XFm5dQdqFcA62RHKhQzkI5bjYHsN9+lBeqTNzzA5Pl2vPV\n", + "PFYIpbEpFzGIPoLWDBiFJhIiIZ2S+Efd98z2eru/29wi/ST+3H4ie7L2QfaGvbySW4spwA2oKeYZ\n", + "4EbgG3HkCuMy0wPtk50pPwjcjFbCusi4zH67LYaCzOMkwLXqX7RospGwBzbDNYu1BsUYSBgMYweK\n", + "zPel/QciqK0SMAglnfOFSDRMu0JR5nBOERmAXshQ4G1jzNM+9umD2lXDgZ3Gizv+eArn9Jc4Jo60\n", + "R0M1rzYu8yOAONILfdgjUD6QHwq15UgnYCbQ07jMiso9k/KDO/O0hhC9MY6wZT34a197Yilsm3cL\n", + "+Xm+psj5IZmtZkCrmRC+HyKyoPbnm2i3Yw4FxHu10FlCNPqShQMhrIqBKUmQ4eFvq33FIc6fkkbi\n", + "3vVoWN9OlMelJJp1FiqYA2JrrCpUVu1Zy80zF+hHcqcmdKn/Dt13Nuad3+BAbfzlT4gjrVDTZhia\n", + "SPUiWn7x62KOF4rmtDyGMpE+5KZHKApDYmX2bY3p/nszrQV91kZdn2yX0uaN2BnHdCDOTx3lv1H2\n", + "0SNKRPpsryrCOUUkFJ02nQdsAuaLyCRjzHKPfeqgzHr9jTEbRaRBWY55tMOXNmSZFr9DH8ofLWvh\n", + "U6gN8j/AJ560tvY/0ShF7b+OVqGfH2mTTLdlOridimq5sQRgmy8M6z8JPQQI7G8Iu1tB+m/7aLfj\n", + "M4rRmPn47Ckwvh/hWXD6aJg3CvZ8Gs5v3WuSOKcmWmy8ARoJ5D1z2O2xfrv3vToaUEJTRalh6ZT/\n", + "CXxC7QZbOW9FY6Y9C7d1hBmPwsI3EzBDjvArWLNmX9Tn8BLwNjBaHIk1LvORr2OJVux6Eb3HFxqX\n", + "mR9oP3P3kTkgRenJPfHXCcD2ov0fxfgGBgGTiwg7rRSNv6ymnq5AijHKTCcin6Jl0JZ77HMVMNEY\n", + "sxHAmOLDq44nWKKqr9D6oN+LI++gGX1PAZe5MxZ94Dk0keS9SumoHwTqALOaVyKFI20aU6DNP48f\n", + "bT4wWP9Jaj9d8vHdWjNn4YTi/i3JQyMBCMvRaKv2k2Dix7C5+Qrj0hmqrc/QlMI+h3bAuWhESRxQ\n", + "SxzZjG+TkntJr06sr25UpE3ZE8Zlxokj/Rmy/DIWXwOLh0N6O+h3L5z1Isyq2UwcEe9rZAfUl8SR\n", + "74EP0PDKZ8T5f/bOOzyq6nnjn0mBBAi9SAk1FA1FURREigJCgti+Aip2wW6sP7veXHtHQEXAXhCx\n", + "KwYU6QooXXrvSAk1lACB8/tjziabze5mUyjBvM+zD+TuLWfv3p0zZ+add6Scccw7nv3ElfqortM5\n", + "qNzCyLzeb38hyDuioFQsWsqF//xHCOyo7gRn5mTG+I8lCmr4a6IPsgcbgPN89mkIRIrIBNSTG2CM\n", + "+ayA1z0lYON9HwAeqeF5aPl6I3+iTl7HXQ4kAGedSAMS7CFfmMzf/FL9blY3uIHIkhWJalWGc5Zs\n", + "Jj7td+BP1NCH6M2HgoJy5u3EcaASfD4a2r0It50DY6pl9ji2wl5r7Msv7ETumQQ8r2bo9+X5O0pc\n", + "8Z0MfP/efTJODoWIX6i6+zq+ek7/2ngefDQZmvwICdfUB8aKK//nk88CwDhmiRU4exStdH1GXCmH\n", + "Rh+eRPMAbwLX+WtqFAq8V0DRcN7pUGFsF/h6ZtY+/vIfHnqyAXZHaZMaz+pAXJmC2sccLSm9UCQ8\n", + "/lAezEh0Cd8JTXJNE5HpxmTXjhGRZK8/JxpjJhZwbEUBz6FVgtFoDLmFccyGYAdYlcAh6NL1hCpU\n", + "eh7yIwILqsK0WDhUi7iV9fiaJWUMSzqGkTY8yyta3S+dr6d9fSySzgWnZHpNHCYcJj8Nm/7YRO+x\n", + "9cWVZwE3lEnKVlavsC+/sMlE38mhFSoV4PlbxJVgE8N6f2JhRQHiSnngDVZGv0vpW+5g1whbNSew\n", + "ZNRK1tR9gMeWxAKjxZXfgKd8dXKs3PIL4sovaMjzadTojwSaGcdsgrxXhXvDswJqKpK4L46hZWpS\n", + "8yxbvhWIqumhJ28uAy3uhK2v6Xa7OugMTMvlewvq8dt8acdQxh8MBTX8G9GH1INY9AH1xno0oXsA\n", + "OCAik4EWqChRJowxyQUcS5GB5Re/g3om44EHQ0nm2HDJF8BbxjHTc9v/WMPzkG8rDb17Qpv10HY9\n", + "bJjJovEbLtgBwzXmUnkJpDbhWFcTF4SS6XfiWLFxEJFmNnrPx4or1xrHbC7wOPWH76EZ+oX1YGN9\n", + "Xhd4/y2uHCTIxIDSWPPk8R6rXtTZztu7agMq7Z5nfth5j3SqUorlbS5nfa35sG8/rBtkDixOsffg\n", + "czRUM0dcGQa8RHJ822zj61JpIm23H0Ydp6poFGILFF5R2gJjUkomydJaC9nTG7YGy3946Mmn7YV9\n", + "kZBWAmIOZa4OgtE4PQjq8VuHeKLnbxHJlyhLQQ3/TKChiNRFk3K90c403vgReNsmgkuiS503C3jd\n", + "IgtxpQtq9Ouh7ejyEvZ6ElUzDEmr+1jD+yFf8nbW9h8gFWLU0y+RBjd1hBE/WKGuk7eaONDEIa5c\n", + "jHqUs8SV6/NCI8z3WHQ1txvIUaxkxyRor2ffyaGz1/9riitpBJ4Y1gMbPdr0ofaiziuynbf+71Bj\n", + "OgzudUjebZpIcmpf2qfGAn8aJ7vzZ1sgPiWuvAc8S4asoW2pw0z/sQrl1kGX/4Ma6Z2YW+5Vztz9\n", + "FBpV+AlYKa606gZJb4cTd0cCDEqByKP5K0oTV8pSibNXtafhynHBO8B55wbq7YJVFWDQFlauEQah\n", + "CekcrEev64Sj7MgCUXNDQYEMvzEmQ0TuQcumw4EPjDGLReR2+/4QY8wSERmDiikdBYYZYxYVdOBF\n", + "DeLKWeiX3hClFSZ4aJshHt8O7T3b8mShBgavVkxLAuBQDKQMgstvgvfmQMbJX03sC3u/k8WVP4DP\n", + "rSF64UR+Dzb+v92+5vrbx64sq5B9YqiFrrg9f1e3sgbrubFibbaUqsae12F3LCzsReGs0qxUSYm9\n", + "0KOfCuGlJ9SHxHuNsyBFXLkBmC2ujDOOmeJ7tA1/3iK1WzeiQ/m2XHAahB2GKU/At19GkHFlS/N9\n", + "igF+t6qXM4B125uzvOQ/sKgKfH869LJr6nwInfUCxpsQ2n565wa27qNVn5qsYwtPLXb4F23lGkwe\n", + "vSRw8HjkdgpcwGWMGY1qwntvG+Lz9+soC+U/B8s/fh71Rt5EJWgfyqPRrwh8jopHbToGw8wXglEA\n", + "NWxiY+aLesIZ38DFZ+8iJeykryYOBEu1PQcYDrQTV/ocbx39vMCyYLbY10x/+1gv8zQglgX1PiCy\n", + "bjXKrYeq82Fhb7tXQVdplmpbfRasSNAXANHniTRNNKpZ3w+dVM80jtnp9zTra2fw+Ujo9Bg0HgWN\n", + "f4a1HWB91viMY3aIK02AlJmXcdGtdeG2mTDgvCzDH6goLUg+4Ga0+1ZI8OQGxJX+2+qx0cwyKeLK\n", + "U+Qe5jkujB4ortw9ZrAc9SeBG9Ek0P1Y2qZxzAd5OI+gS8TvjWNye3COOwJRAHPEzH/blkHSkpac\n", + "G5itVBRgHLNJXOmM1vHMtsZ/0gkeVr5hVy0bgY2SnLAeHjgj514FXaVZxtTaDvrKxBkVoOIADSWZ\n", + "UTYMOkxc6enf67XnGfcyjH8Bmn8OV/WGHfubiCsNPd60ccxhcaVr5A5++fx0Lh5fj7D9ETCzBry3\n", + "yX9SNlA+oG4DqcUN1MfHuQ0Rq9DGKqDx/Wdy2f+4MHpAO9cXoxAhrkSLK4+hibsotAzeRYtONqGT\n", + "QV5wO5oPeLQwx3k8YMyCFGNSEowZ2dHsntCZCNMP+Fi0JV6RhXFMhnHMU6iUwAhx5UkbViniWD9Q\n", + "K2e9URiaT/7O+yjQBQ0l1b7Xa2McSnoIfh4TDvNuhEEXHmBDqQwyZKa4MkhcqQK62jlUhcTw7Yzc\n", + "WIL01JIcad+TvVPK8JC/pKyHobY/EtaX1W3DIC42jUeBz00em7ZbrAQa2ALNM9DK/GA4bh7/KfCw\n", + "nhwQV8LFlVuAZWjhSFvjmLvik2l5wdss7zSUHl1dKsQn0y0P52yKUj6vDlLIVWRgHPMtGnJ4/kSP\n", + "pTBgHPMr+l13RZf2VU7wkAoETeBOuw8Sx0CvSfpvwTpyZT/vJTt0ofQ4XP4VdPkZSu7GE0qyVNhr\n", + "gJfEldMDn+fiWXD1AXgaMm6NZtz6mrx1zXa2lKwDLBZXHhdXoo1jzP5h5prDpXn6aAn+PVCBksse\n", + "5hVxpaXvuT0MtZ8aw13ds7ZHRlELlYrID1ahod1uaI4gt99wscdfVCCuiLhyCVp8dROqs3GVccyy\n", + "piKJZ5fgwympNPh9EzFjDJ3bwICmIomBzudphnFFSZkcvZNpMYv4zDhm6fH6PMcB9wJX22R1kYfV\n", + "fbkImIOGfi44wUMqELKt0kxKQmHVXOh5jsxQw/8S/D4NSm2He5pAu3mVbK4B45jFwBPoSirK/3nC\n", + "U2FENJWvhZuegaidsPeLegy+KBJtXH8OsFRcuVFcCTeOeR14FhXKW4/WBzwj2moRyGKodV0Bk+rC\n", + "fvvOfuFAqLo5frAGFRi8hNzj+1Ds8Z98EGmaKJIwRqTXRP23aaK4ch7KqX0FVf7rAPwtrtQRVy7e\n", + "34nBpbtQrdMNcNnVep5hEFdbjV8OeOKMo6HraV1od/kGyvQaSY9gE0VRg5VkuBP4UFwpndv+RQE2\n", + "9ONRfvxGXHn01Aj9FDa8QjV7q8OPH8JX52yg9UoBZlptHYBhaAFcAOqjTRanNoFN58CNF0GpbUCZ\n", + "aOOYZcYx/0NXDrejFNwuxjHD0Bj7Rejz1waYKq6cAZkMtRUV0qHlvzChLlxbhr2r6vFFfj+tXcFs\n", + "RVeEoeQISnKcDH9xs/UQkIPfXHE5dLtwL/U3ZhDBV+iX2xAV8mqEinatq7GYcx9dQ1iTVDh9G8Tu\n", + "0fP1gkkjfRRKARJExoyGrt+dDv/XBWYPgXIH899E/GSGuPIZsMM45r4TPZbChK2s/grYCdyQf+2h\n", + "oodQqmT9qdOSvHA02iTlVWAWqru/C11F3eVLashUYgXAwEVPQ5PvYXiV8WbnxE6Z+ykx4n8oI2cF\n", + "Wgz2EfpbvRINw7xg338rPpmuteHe1RfRcGdlovaFUX5vE2IDsoxCgLgyByhjHNMwhH07AM8Zx7QP\n", + "+fz5tJ3FXkkQ2DBODU6PTKbVWXH06AcP1NblaYMtZUiLjkAVG8PQpVw/VEa4BVAl7lcWJf2lsq4e\n", + "ow+B6WQxEHVU4OULYPi3avSh8Bosn2S4D7jKy8s7JWC0dV8HYCEa+jn/BA/puMB7tToSOoyGrv7C\n", + "mv5CScYxxjhmJMqAmYPy8P8P/T19IK5Uz34172SxwPjnYUnkDu6c0tjy+PVaet5v0MRqCirLvB3V\n", + "xhrO7PKxvNhlMUM6Pc37rbctrF33tHUwqMJiNu2qQ7Wmk9gTn0wbCoYwINRQ7XHz+E9ZOmdeSs9F\n", + "e2A2BBqjXrvn1Rg4QPs1Jdk0WwWk1rWFKd/Cvy3BXDPLmJFX+ZwrCn3Ivtm+i8n9/GicB+qbmQbp\n", + "YQamfqDt5zworAbLJxMs3/oOOcSIztGyoGI6kflv8H1ywTZFecSKcn0vrrwKvHkqi67FQtJQiNtS\n", + "Oqs5eF6rZK28xPPiykfAi2hS9S/gU3Glq0fu2q+8xviMQbQ/2gSYLK5cZBxVDLbnPQQMFFc+QUOy\n", + "ndgeOZPGBx5nbZ9w5t2oO5a/etihhtv3/LE8rXzjdBhsqP6OTl557DucDdXQ/F8oiOI4JXdPScPv\n", + "v/S8bwOpW68cN6/ZQHbD3gStZlxDln7KeLTZw1LjmB26tHy/K2MGwmFvJmJ2frOX2ua/wBMLjDma\n", + "F43zzErYo8emwfLJhvhkjuy/itJNLqLz2/aO5K/B98kJ45ifxZVz0dBPB3HlJuOYHSd6XN4oLG2e\n", + "GIgyAnFJsOHNgq1WbcL8Rnvv3kLVTd9GK9d1H//yGiniSjram7ezb5WslcF4TFzZx86yT1Bdwul2\n", + "v+YKNp4Hu0aEbSnTqnzidTPpsgp+bgTDNuen77DChv1KEfo9KPb4CwZbIl5rGpw9TEXCKi+JI2zP\n", + "JyidcAm6/Jps/7/KBG1dZ5UbD+cq+ZsMNAAu9HgnedE4P17NME4WxELSl6OIaXYnXDsfzl+f3wbf\n", + "Jy+MY9aKdlJ7GQ399DYh9Is9HihMbR7PavWMbbCwqn6XULDVqnHM31Z++V6gv7jSEOhrHLM2yDHv\n", + "WuM/QVy52Dh+5WHeYlKzZzj8JnR7AK64AX5/BZZcRosNpbl8CdTfAU9fBE9PLlCoNRGVIK8X4v7F\n", + "Hn/BYLP+h0vB+jYw52bY3hj23T3VmK875vVsoUj+Wr2RG4DW+dUAh+PXDONkQAxElU+HcZ9CPa/0\n", + "2amW07ChhgfFlclov9gXgQEnPvRjHaTwQ3DNpfD5GPKrzeNZrTbdStwCa/gLY7Vq79FAcWUHMBCd\n", + "PN8FXjaO2RfgmA+tcuk4cSXBOGauz/tp8u4FG9l6Vh0+nqCNd7o8Am3e5NBv27hjJhwKh2WVYEtp\n", + "2Lsv35NXd+B7ggiz+eC4efynaHLXlnZvaQGz+8G6drCvKrAv/95HEH6zTVC+DnQ3jtlS0NH/V+Dh\n", + "TjfarsqJHpyKOQ0A45gfUHXaPsC3Vpf+BMI6SEciof5YEM+XkHdtngXGpEyD+ybuY8kLddiYCGMK\n", + "s1+v0faK36Fh2PooT//6QLRZ45gvgHvQrnatcuwQtfFZyl99BES1g96bC/MP7Z5z9dKjva+CDWWV\n", + "lHHFGWzNz+Rlc30dgW+AcHGlQgiHHTeP/xQ1/Meq9DwnRJukjwSuDbCsLEYAeLjT3ttO5ZwGgHHM\n", + "alRXfwPqvZ5z4kZjHSQEMqK1QT2QX22eBcakrGpH0rrmLE8xJuEYhCjvQ+P9KSj9815gmrjS2t/O\n", + "tlK8L/CLDRllvbd29Yd0GDODCh0WQq9JmB5jmLn32qjVZua0A2xpcjsZv5Zj24x2rMnn5+gA/GNz\n", + "OivREHBuKI7xFwQF78YUGsSnSXphnvu/gP9aTsMDW7qfZEM/KeLKc8Dbxz/049V17HApNfyH7i+o\n", + "g7QAaCZ+euYWFMYx+8SVa4Df0JVTa+A6dPU0EXjUt4OdTbBfh7KrehvHTMh886zdT3LW5EFoTs6I\n", + "K9X2QKM9KlddencsLwE3iSuPA/1tQVao8G664pFu8KuQ6oVij7+gOFal5x5IVpP0b/KitlmM7Fhg\n", + "TEqKMQkjjel4jLzEkxaWY94GlfoYKdp16/hd31ub52haOqX+N6kQtHk2A4J2w/ILf1XwIY9Ze/C+\n", + "gLZbDDeO+RRl560G5okrjq8IoHHMb+gK4StxxVsrawLaI6Sz/fs64AfjmL3GMVuMY25B6wp6AEvE\n", + "lT6hVGRbdl93svIkJ53Hf8oa/mMJX9rmCR5OMYowjGNWon2Xt6LyAjkExI7p9a2DREz6Ku7+454C\n", + "C7Kpl78AaOrv/Swm0eiuMLKD/ttmQF6MP6p0ux1VvcUa6qfQ3t5noEb6Gvs79YxrEtrk/FNx5TKv\n", + "sQ4A7rP73oxW9nrja7Sa+AYgCZghrlyYy/gaASXQ5lOQ5fHnhmKP/yRHMjqD3+ChbRZleITheolM\n", + "TBAZcyppAxUFGMekG8fcjUp2jxFX7vQ2WoWJIN72PpRzXhiYTwDDn8kkqrLQK6eQTZo5V1iDfRMa\n", + "hrnIa/ta45jeQJ+wAzxbZgs7OtaXWZ5n2jhmKkqxHCKu9LSHfQGciza6jwJ8O4CNQj3+KWho6VW0\n", + "mniUR+fHD7oDKV6hrlANf7HHfyIQyhLU0javBy4rCG3zZEGopfbFOPYwjvkK9f5vB74UV8oW5vlz\n", + "8bb3A4UlmhfQ489kEp3/Olz8sNf2vDGJbOezm1APvrL3e/HJxNz0KgyYTvllV9Ky6uV0bVaWt63x\n", + "nwlcDAwQ7Z98AG10lAx87CcvsRAwQLyVgPgKlZYYB0wUV4bmlJTIFuaB0EM9xTz+441Qilm8aJsd\n", + "TybapvUOw9C+x2FB/p9j2/nVeOzhDOIWC9TfCSWPnHpFVEUJxjHLxZU2aMXqTNFuVKGW/OcCD2//\n", + "IETvUIXMTN7+wsL0+Begnef8wDKJfu0Pd5wJjUbBskvID5PIOOY3ceVLVOn1Mo/RjoWkIULcpF2w\n", + "dBC82A6G3UG9Mv/wlrgywTjmH3GlEzDW5uo+AB4DrvZzDSOujEKllRfYbQfRgrKP0VDvAnFlEGob\n", + "wtAVxDiv06xDexuXsDUdgVDM6jn+sD+KhHsh/DDIEZCjcZTeNlRcGQ+UR1sG/QW4Vj88T0b2GL4v\n", + "aJLK8zri82+g/x+Z04fqPQ5D+FH4Zbgafzj1iqiKEqwXeru4ci3aQPxJYFjBWTLW2277GlRZBN8O\n", + "t9vLRKM5hsLy+BcC8eJKWM5QqGUSpQ+L47vPoGcvGNpxDWn5ZhI9CUxF5RzeASsfAdxwBYz5HF4a\n", + "B/1mQ5seVAAWiSuPoPz6jqiBboP2Jb4Y8EfJ/hlw8Om7a1U7/09ceQdNOC8DfgSmGcfs9drvsLiy\n", + "EagDBGu2XuzxH3/YH8W2eP3ThMHOtbAtvjzjm7emz5Q6bA8fT739n5AHw3qc3jf5NQoeKWjf7adq\n", + "EVVRgnHMcHFlFppg7CCu3O5tUPKOtHQqroDWb8GQWV7b9x6gEEM9xjE7xZU9aBOSNdne86ZarysT\n", + "zbLIWvT7ZgdlM/LT0xbjmEOW4jlVXJliHPNPGqRHHoW+s+G9c+CdFHVozv6UmaOTeRXoD9zLr9VG\n", + "MrP5Gm6ceSPLKu3gtC2PiCuDjPYh9sYkoKm4Utk4JtXPGNYAfWxNxk9AmGhzpl/8xPmDGf5ij//4\n", + "wy5BZ95h/54MrIWIlNL07NyQf+6H37fHwbQ9hU0NPZHIFIYLUUG0GMcXxjFLbYHSQLJCP/PzdTJZ\n", + "N5Ae7dvxx6Ol2F3HbswsbOxO4YV6ICvOv8b3DW+BNdEuWNk89rzChsceRvMireLtM+3MJq75nfDK\n", + "73D/IX2mjWMmiCtnszSmPxfsfouaFcOpaGDqP5Upc3MGqyc/g4Pjc/6D4so4IAH4LMhQZqGr76fR\n", + "JPBD4srDxjGzCC3OX8zqOf7wrfb9DXgeLr0V0qrDuBfJK/vgZEKgxLWn1D4RxvSCSYVdan+qoCDc\n", + "84LCOGa/cUxfNJwwXly5JV+sH2dRaapv2cZf437101O3MJO7EDTBmwUrjtgHSA7CkgkFn6Lyx294\n", + "nunb9jAmYjOpLVuz0PuZNo45wpdtGzFwczgxGyEyHc4bCGmfRLCt1v8FuLc/o+yeYDgL2GO7fTVH\n", + "aw1+Fle+QBvz5MbsKfb4jzdyVvseaUbEwYrsrg2TntHQD5AfHZMTjdwS1/8lYbj8oDBVLAsC45jP\n", + "fEI/dwUSKvOFZQj1J+ro1SZjzB9+dinM5C6o4e+c616AccwyceUJ4AtxpbXJvSm5v3MYceVOYI64\n", + "coUx5nu0KrrLtnq8xkW+rQ9jojhYDsa/ABH7odVgOHsozImOQplCN/iET1OAN3NJ0GZW6xrHZABD\n", + "xZXhwMPAQ8C/4soLJnBHL78efyidzfKKYo/fC97VvrB/BhlRMO4l1THJRP50TE4sYpMo0T+OZl+g\n", + "zDQoaquXE1VrIK6UpGzlh6n4SBw1ZkKE5+s/MffP6kGdi36RM8SV+BAPfQ4YYxzjz+hD4Xv8Qbj8\n", + "fvE+sBZ4Pr8XtHr71wLvWS180ORtaZSD7wUb2l3bHlZ2gxE/wqj3oOWqw0Bv4KszIqS755nrlswn\n", + "4fvZguosBYIvjdNTXJaMtoCshIrLPSDa/MkXOTx+D906Bbp+ElF4dOtijz8gvHRMMnFshN6OJcSV\n", + "ZvwvthlxtWFtO1ieCOkeocCisXrxPPzeeYhQGraIKxFAWaAcysoq5/UqH+D/vn9HcNdU2N8N0svD\n", + "yG9gl0de/cTcP+vl3ySu3IRyyR82jvkk0P62GvhqtKo1EPYBdQtxmIuBRuJKhPV+g8J67H1R2YXR\n", + "xjHj83NR45jp4spA4DNxpZNxzBFx5T20wfq0rD39/L5XfbWSkaclc/vqoRiu3HA3l43/gBKn2TXV\n", + "mTPZvqQR96IKodkgrlRB+f2TAwztb7SatzUq03yv1QAa6bWyyOHx14KkqxoQd+5FcMUSeGJK4dCt\n", + "iw1/ABwvobdjAXElGrgKuAOoywE5wOB5sCfWZ8+isXqJhaRhELe1NIytD7ujoH5J4kZX5G1x5TcC\n", + "G/BSwB5gt33t8vq/5+8tKA0v0PsHeLnT6Kzm3t44sffPOOZjcWUm8LWtMbnHOGa/9z6Wdvwe8JgJ\n", + "3vi9UEM9xjH7LYUxDlgSSrjCOCZVXLkF+FhcOdPkv1vZy2iY6XF0BfExsNKblRPw971pVYq40umc\n", + "j2m/5Urq130Anh0P9/8FHy+iUuszuTiAAF03YFygMJBxzC5x5RCwzTjmEiv78Drap+Fh45gp+Hj8\n", + "4kr78rfT+r5IeHYCXOVFNC0o3brY8AdBgPZuJy1EJaJvR3VFZgKvAaNIibkYnvVtRVlkVi8x6gmR\n", + "Wgp+aQTl0qF8OpRRszuPwIZ9b2FIakhy05N29Wccs0BUb34w8Je40jM+mfoeI9u+AlXmXojZ05yA\n", + "KwKLwg71gE3wNhWpH+qKzTjmV3HlO1RWoVd+aMrWy78Olb0eZxwzTVz5EdXieS1zv8C/7wExR7lm\n", + "8iDo1gdGNIX3z4bXfwUTRjgqCrfE55gcYR4/8FA6t1p2USvgGnR1MhcoAxys1k7uO9iEp6PKV7bN\n", + "dQAAIABJREFUUbrmDA7PnZu9BzcUnG4tpoA1ISLSDa0yDAfeN8b47TYjIq3QpVYvY8x3Pu8ZY8wx\n", + "0SY5GVFYfU4BxJUSqM7I7UA88CFa7LMq5zVrF7nVCwSuNUiEMSnGJByPMZzs988yUW6VDN5om8KB\n", + "KbOp5nnvlnDW/X2EOwOFxZqKJIY157lN51C31YfMKKyG96Jy00e7JXPeaOi6IxqiD0O0DfwE+v5s\n", + "Ne0M4A3jmI8LcP3LUNt0Ftpb+3OgUSjOQJtY2TFtAxUywtTojomDB7rCylKkHy7N28Yx/+d1nQi0\n", + "AK6pccymIOMZAfxsm8R4b49CQzevyCFSSx6m4psTCL91Dkw/Ap/B4WEQ6dm/L6z0sJTyazsL5PGL\n", + "SDjaBLkzsBGYISI/GWMW+9nvFWAMynP9z6KwGCLiSj3gNtSLWYQu538IuNQsYqsXbxzLWoNQGRMn\n", + "+/2znvH7rWvLTVsvo+1tNVWAKToDPjxC7UAxYU/+5No9xLlHYTR0LcSG9wuAXp4V213doe06uPdv\n", + "fTNQuMI4Jl1c6YO2TpxiFUzzDOOYH8WVruhv4xogDa2+/zW3Y9fU5N1r9/DQ8D069m4r4KtVrFx1\n", + "B8sozX02nOrY8FkbYE0wo28RSKwtFp2cKLOdiMhyhG8vBRlh0F5LySITIDUGFhZWz4qChnrOBVYY\n", + "Y9YAiMgI4DI0seONe9ES6Zwt0P5zsNIQJdK01d3BcoTa59R6Fpeg3n0rlLvc0TjGd9l5SuFYNWzJ\n", + "b9L4ZEbt9WSMHQpJCbCqAsRv0+2BjKwnf/L3YdhnfcpC1GpaADybplr5PDgNevaEO2Zqq81g4Qqr\n", + "p/MCGgZpH0qCOAAeQlcPN6HhsDsJwfBvTsAZVYd+nX9mTsUDHNoLB9YdZdChqkxAvfsSwGI7xpqE\n", + "dq9WoSJ8AIgrdYBnUJvZH8joOoT5r1Sg/ROd4K+acOEaaA+8DQtHGtMx9I8dHAU1/DWB9V5/b0A7\n", + "42RCRGqiH+wi1Fid4AbTJxpWGuKip+FwtNJFASgTHcj7FFdqoS3k+qKUt/eAK08FddBQcSxqDTxG\n", + "73AYbCwLdXcVfYG6NEiPOQQf/Zh9eyAj6/HGa+6BnoWYPLRYDtReVZZH++2hwbCNxMXtgOHNYMq8\n", + "kFZsA1EZ5Sex2vt5hXHMAXHlarTpShfgZXEl1jhmfS7HHRFXXht3Bi2MY673fk9cmWDPNwB4E22z\n", + "+HgIw1kJ3GDVPJ9AqaeDgYYoCeG5vXCg/k4Y8U32AwtbQqWgPP5QjPhbwGNGkwlCgFCPiCR7vToW\n", + "cFwnMSx/eNoDcM4QKKXSHxGklvGWRx4ldK3ehGGRD8o0tKFDZSDBOKatccxn/yWjf6zgMXqrK0AX\n", + "r592URaoWw8Dr48mGxsmWFjM0/C+Zho88mfW9sIwNDbsuGLZg6z1VIcfmMG8Oy5k39Rw7sttVWVj\n", + "8TcBd1rF0vyOYwEqsvYhWk3bL8RDPwC6+5FdHgVcYhyz0J7roB1jirjSJEjNyQ40pLMQOAycbhzz\n", + "lC3oKgkczK0PtYh09LaVebwVmSiox78RjU95EIt6/d44GxghWgVdGUgQkcPGmJ+8dzLGJBdwLEUE\n", + "lj+8e1gcC3tCmzdh3NaVpzObYRC3pTR8eBYMPRsq76dG/RnsWNaZ2v7EuQozSXyqw99qKtYave3R\n", + "UMnLzBVlgbqFySxbt5iIi79jUvnD+lmChcWOg1bTfKDpAmM+QytpBfhr8dP4K2DKAeOYTbYi93NL\n", + "8UzL5zgGo+qbpYErxJXnrFxEsGvvtAnZOyCbfs8vwEs29JqIyjncAtwjGfyV0YOjX/xO+Yr2Keor\n", + "NKx8sfShLd1Qp+Is45hsxh1r+HMLaxpjJgITPQeJiEN+YIzJ9wudOFaihR8lgLnA6UH2/wi40s92\n", + "U5BxFLUXxCdCwmgqd53O4+GHqFmvd0+YaMC0vwnTtwdmRg2MAdMTJgY+R9/l6G721Xc5xCee6M93\n", + "7O9dtzHQc6L+m/vnjYfEvrDc60aZvrA8Hpy+sPznRpjEa3X7rbAiHorcPdT70nUMt1bcQed6S/Ly\n", + "HMRDYgKM7gkTE2B0YX5+knmCZF7x2XYFycwgWVmF8ZDYDcb0hIndYIzn+tm+62rnr+eSCmMLOJZK\n", + "JLOeZP4hmatCPKYJyWwmmZLZtj8atpzGZ/3FTZVTOff0eZ773bEs4+7ojqn6MObdc7Ket/Ors5Fk\n", + "6pPMMpJz2kiSqU4ym/P+vWPydS8K/sCRACxFlyeP2223A7f72bfY8Of8woeRzPPdYIwBczS7JTcJ\n", + "MNr/fe82BowhfoShwgqvQxL87n8qvPI72V0cxpjlFTHfN8GkRme/t/GQ2Ph8/ql+DZsL2+gd9/sS\n", + "P8JwZzND2KGTxgkgmUtJ5hefbWEks4hkOgealCtQ3cnxXZe7+hCtq71YwPFcSDI7SGZKHo4ZQzI3\n", + "ZrvfXZpt5+IHDI/HGKK3Z95vjwM3rxrm9TZZg/c4cCQzmmQu8XONuiSzNu/fPSY/96HABVzGmNGQ\n", + "XQDJGDMkwL43F/R6pyBeBGYuq8Gd/TblZcltk8TRO+GWC+DLn2BTK4qKDEP+YBlRp82F3bXhQEW8\n", + "GVE2jFAT1YjJfIU9zlld9kLTrdAkNSusUwaibfL8dKDmJmMePDGfq6CITaLk63H0qAO/vg5HIwmV\n", + "KXYcsABo5r3BOOaouPIy8EQsHBoGcTujtChP0AT719S5B4ZVJmonlNirVee7v4xky7kPiSvvGsf4\n", + "hpRDgi2cGoJWzDYJkRE3AHhBXPlUabOxSSx8riK9r4TNLbKew/BuSVtjFlZmFzTfoi8PvMKHgSid\n", + "URwnZU4oFmk74TCOWQ18v+o2muVNHtmrf8CoIdAnUdvYFREZBm+ELnlsJ7uuD8Jpc7I2Vz7SQlz5\n", + "A5W+nYFS+GqiDbLvvvANxq8eAD9/qYbfA68fYyUgm5xB0WpAHxNF97sgPF0FxzJxUjgBa4CK4ko5\n", + "n+1fAvVLRFEFoFdP+NJrehBKK7k0bgzc3AHKr9E3dlXaBHwirhTEdj0DpAJ+HVQ/+BXNDViBtpgo\n", + "/m0J4YdUuVeOQLPhkDS5/dwLybg5Inue08eBC6TLX5LjpMUPxZINJwteBGYsTKb/AidU/riXyNTS\n", + "S2H4KLi24xE2RPgmjU5q5FbQJq7EoBXJTanati5bgfCDkBGVtfuR9F3AU8BC45htvtdomiz9+0Hd\n", + "IKupSmhfVN2/iPD7PQnrVjVLnTUn7gAlv7uFfXtqee1x4p0A690vQr/DqV7bD4srr2+ryNNsslo0\n", + "veCSZVD2IBj2aeJ1wTXaH/imjvDJONjJUtQIP4hq3eRnTIfFld7AZHHlfOOYqbnsf9QKv90HTIG0\n", + "dEwYLOsOTUdAtwfgYAyMaTJ/16LZ5zUVSQxSc7IKuNDPZY6rx19s+E8CGMessloi96PeSO7H+IpM\n", + "bdx7gF8rfcOVGx8TV54Hni54j9bjARu+iUiHykug6gKoWimO2hs/Flf2A1XQgsAFNF36O1NuTiQi\n", + "vTpHPKSQvivZuf1h45iJga4QQgFYZdQD1BFZfv+MGvBQV2icCo22Ezf9AM+JK6uAVbk0zT7m8ExO\n", + "7wlxrRP38/6vkLJ4Iin8wl66c7JoCVl4mrL4GtgPF7Tj2Vu+Yd2HG6h98Up4rj3sHMvKMNZ+Bv2u\n", + "g2FxzLgbTDjc3DyDcRW+AX4H/hZXfjeOmZufARnH/GH1cb4VVxqG0NLyE7TXdh3kjIE07tKMOqtr\n", + "UGYLfDMCln+3Ev5yIdeak0ChnmKP/z+KF1CRrf5BGjVkgz8ZAXHlJ5RnHCuu9DvRBip3HKkBT0HM\n", + "aojcCDGl4VAbmB23ldozLwdWe/dAFWmaSPSqr5BHl0DJ1FA1c3L5MWYL9Xj4/U1SwZ0ASyvDskqw\n", + "uTF1UeperLiyASU1LAOW8kONCiyM78rhcsDeY06t9UxOX50BpQ7DDfPgRlbShht3TOfcv0+EllAQ\n", + "+Qu/3bisgudr3yfSZfPPLAqbQNnP76JVlR28tmPmpiEiTWdkOjYz9x4gLnwZV2x00BDeg8BwceUc\n", + "X0XSPOBp1KAPAG4NtqNxzF5x5RPgJZxFsRxccoQJjf6h0/54NvQfD5vfCvF+rwLqSc5G9MUe/38R\n", + "xjErxZWf0eVkcgHOs81Kvo4AfhFX/mccs6eQhlmo0DDPuQ2QZ2FnmEbo1z+JFqlPXW/m5OA6e8I/\n", + "W+g3/lrjmGCNq/OCbIbfU9QUc0hL5i9co9uXwN8pxiRYYbz6QCOgETMqXM7KDu05PDwrpl6mT1vp\n", + "Wvlnzt+egk4Oy4xjdhXSeDMnp56LoPOqrKrIWLbPn2ZSggrXHYuOTp4VyOAw4jxKkp7wGMnMR6VG\n", + "chxzUSk6TU6i3Z7pTN21jRcyooj7twe9xJWhxs9kLa7MQfXwu6DKrK8C9+Rz2GNQOeou4kpv45iv\n", + "Au1olTRboZILt1Py6Edm2uIj4spoHh33oQkxRGsnkDTgNMBb2+e4evzFyd2TCy8A94gr5QtyEusB\n", + "XYmWzE8RV2oWxuAKH7FJ8GEpzn0b+rWCNm9A2TuBN/fnEqYobO8om+HPrXrSOOaQccwS45ifjGNe\n", + "55fzIG14NDGb4MrrNNm394syzDm9FSrX+x6wQVzZIq5MEVfeF1ceEVcuF1dOD9CNKSg8k1OYyVvx\n", + "mcdAeyrEC6ujk2cF8kgXuPoq2FBW2Tm1Vf4ih8fvGce4/XR6eAYRLVrRvg0MaPIiq9Dw3lX+rmPV\n", + "Oh9Fwz0DgR7i5m/sdiU5GJgDDBJX6vruI640E1d+AL4HvkBXfBFeq9Cf8TOp5QJ/Cd5iVs9/Fbaa\n", + "bxTq9Rf0XBnA3Sh7YqqE3qIvX8hfM3LL0plxlzazr7oQ7mwOfScbkhfWFlcqBziw0JpSWwpoZbwM\n", + "f94b0NvPsfc0KLsezn1HN2+rvtE45hrjmJZADFqu/wzKPKqGai/9COwWV1bakv+3xJW7xJVO4kqs\n", + "L3vFc5+nhp1Tp3dEyWw5nFAqbj0G+oV2sNI2YvMy0PmGZwXy/HhouB3OvANebQvR4ZQCNgPh4kpV\n", + "33EY4O6/Vb/nuTLE1TvE3agH/4a4UsbftYxjPkeZW9+hGj7ve587j/gQXWIOQkNHEQDiSiNx5Utg\n", + "LDAJaGgcMwSVoEmSrIbsvwCJog1vQoW/OH9xjP8/jheAaeLKW7aHaL5hk7sv23j0eLucnVgYg/RG\n", + "JjNHhsRlNaUPRWraUlKPRsCqLvoaNRian7OUWjs7Aq+IK3+ik9cPXuX6fptS5xNlgEPGMdkmkryJ\n", + "wtnPYcKUWnvLBbDkctidxaqx38Um+5rgfbQNHdVDQ0eNgTOBXvb/ZcWV5cAyNkQf4eyWF7I5udqe\n", + "7Y1ISZ/KefTdX41tKzM4stFXmsGfpEdPa6AHngc3zst2EwpE/fSsQEodhucm6Lnv6wbjW3E20Iks\n", + "Pv84yJoo7k2E07dBn/nwVmso8zvRxjGTxZXJqDibX/Ez45gvxZUM1GCnAB+KKz3ySmgwjtkqrozW\n", + "j0AaWRPOpahiZj+fxO8kVGenC/CbccxaceVfVJwyKDvICyfc4y82/CcZjGOWiyspQBLaILswzvm5\n", + "uLIJGCmuJBnHjCiM82YhNonwt+O4oQOkvANbmhNaAZGfvqdH7l7JHPO0mW1SvH6A10Bmm8UvKdwf\n", + "SQ4OP+RVB8nrc6Q2gen3waVt9vN5+ZBYNTYBv9S+fs42DlfK4sklbKryLHVjq9HqNqiwir0Z0fy9\n", + "vVEp9h+tSJOtXwAlxZUzgJUkx3fyR5NNZemezWUyyAhTRU4PCqpP5Kv5E7cDThvOyugefJF+NkOB\n", + "oygPfhxkTRT1dmri/OGpcPZtcOZUPPo5jwD/iCsfGccsC3DfvhZXPOGaHaimzuB8DH8w6vlPRlc+\n", + "n6Eefo6cjHGM8aJ2/mY3e8I9oRr+VejE4Y1ij78YPA/8Ka4MLKjX74FxzHhxpROa8K2FdjfKk3cU\n", + "2BjGRNHlUdhfGbZ4F2kGLyDKra+x9bSGo0vwisD/0DBABDDMLsXH5Sa2lQtyGP68NsvJ8Tmm7k7n\n", + "/M1NcDb5DVXkBTYxPxOYKdLrNviyAVf1hun3w8quUGkZ1EraR5OtVVHD2giow0MrjrI5Nprt92mR\n", + "X+rpwLC42fw184aa8zc130INT6wir6Js/p8D/5TZHT+ZFFul+zXwuGjf2Tfj7URx6XbixtVXSeyy\n", + "q0mb3tsmPJPjz6RixVRKlJwuyQl/B5p4jWO+s8b/A+BFcWWicbI3ggo2bpIX/gX0QFdcc1Cp5FcJ\n", + "HgYfjoq0NbKT0ii0GOyJEG+hv1BPscf/X4dxzDJxZQzqfTxfiOedL66cj0ps1BZXHvCmSgZDljEc\n", + "GkfYEQ3PWGPIWVKWxjNgyGyyq27nXkAUamcro423h4krX6CGejbKfvpUXPkGXQn8mY8eu9k4/Apb\n", + "W1BuLcROhQU1gWpx0PgzkYQZ/oyQ7+ewMsLfiitjQ6Xn5o60dOQo1BsPY1+DtBr6WlNrlZnyz0Ne\n", + "147ki3Z/UPbuc6m0VDnwFrtpsu/P1vPHlE+jUy9Yk9emNtmeg8zv2jMp+g+PWU38V4AaaLeq+QuT\n", + "SSKZ+xbu5bG5VTknESYdXM2P+7vJSxLRdhacdzo7PvA4Dl2DTrzaaSsDGxIUV5r50phzTOYld0P7\n", + "dq3IkAgizBdo7uVM45gR4sp5aN7gf/6cI/t5hqG/z3uBv4HTxJU6xjFrQ7iN/kI9xayeYgBq8O+z\n", + "S/1Cg9U4uQBlWXwt2kIud5Sofj9nnh/Hba3gvAF247A4Ims8QveF9fghfj3pFbwOyH8BUS6J4pJA\n", + "unHMAOOY1kBrVAr8XWCNuPKauNLSK/mWm/yCn1CPTdbG/As13kAr9p8Hvq0Io7tCmwG5Ja+NY6ah\n", + "ycfXgu2XJ5w3dyYNEjNIL69aRYC/+2wcc5jNETtZdglMewi2N/J6d++B/fUouak57khjOqYYk5A3\n", + "KmdsEgyN48ZOUGWh3TYsTvsRB8VCNAx0GfAA8PbCZPpNu41bD5QjbHQyl/47M34dq2tGUrp+S/gg\n", + "Wov6PM578GsYx/yC5kXqomEbP+MeFkfkPmj7CiQ1hNItKzKk7RzjmLvQFrJdRLX3H0NXALcF+Tzv\n", + "An3ElXLWeUohdHbPZiDGJ3ldzOopBhjHLEUtToHYFgHOvRvoBuxH+5oGYs8grsSJK6/zwKSOnPEt\n", + "THgWpj+QtUOVIy2JMM+xds0dkDgGek3Sf6cn5aeAKMszG90VRnbwY2izJXaNY1YZx7xoHNMM1UY/\n", + "hIYVlogrbs2Wclsu9EU/ht8ma/dXhiWlgBeg7kQ49237fkiGDnTp31XcgjcWElcqkrD5FtpPHs3m\n", + "tPW53+f1A6GfTx1E5iTRAuXA5wMxUSAw/xq44kYI80TZcgnr6YotDahtjXRTYBYwDX0OG0FsEhO/\n", + "LU3MVqg+C247G1q963WWXK8xBugDXCOu+DDj7GReZjNUnwMfTYIfPoZt1T3H7mFbyWn8VXsyyT1/\n", + "ZWibvWTIq4HYcMYxG9Hf5y120yhCNPx2Vbqa7OGeYo+/GJnweP0xhX1iuxS+AWUpTBVXMh9CcSVc\n", + "XOlh2Q7TgKN8dO40ho+C5YlkMXcAOXAA6G/MghRjUhKMGdlR/81v1aj1zOQo1J2ANnnLZmgDekbG\n", + "MQuMY55EPcvrgbLbujBw5u3EvdoWNtq76ENf9GP4rdHcXwlMCd20OxY6uBoiAEIRQLPx+XuAoSGv\n", + "rALjTeBbah8IJ37Lg7ndZ90+7T7fyZjkhePQ+7PI33G5w06Ks/vC/kpwwSt2e0i6QPOxfH7jmHTj\n", + "mOeBc1CWzFia7ajBv2fBWSvhugSY8iSMHph1dIldfrv3ecM45hvgCQz9m7aUWZ5VXgSp+u3vbKAS\n", + "C6mnZxu3SNNEfugaT5OjcYQN78CmqRfwW+t00sNGiStRAS43ALjXUjl/A9oGoqD6gW+cv9jjL4bC\n", + "Ssb+Tv4rE3M7/1HjmMdRbvIf4koXceVRtHjpKbT6t7ZxzCNs3fVKDg+yXO8MDmxLKlxNIOuZtfgE\n", + "Onsz+TINba4cfuMYYxzzt3HMA5e+xvQ3f4UVFeFvrzI2L/pijhh/ptE8eO0YIq2h39kAViR4ef2h\n", + "CaAZx/wYuYuttWayIL9Kn+JKN6AjGoduhw8dNOC1/U/GZwArfemrocOzkhD46X04byDUuGx9iGG9\n", + "HIVcxjFr0BXaj1w8N45HqkDF0vDe1TD/WjLzCFHXbyfx70AGOBvik5lfazn7VnSn5a0NdJXXgZmn\n", + "CTf9m31P7zBZbBIbf6zNnlho8ZFu+vvPqmyqEEWAcJ1xzHRgG9qGcQ/wF9A5lDGSM85faLUpoaDY\n", + "8J/8eA544Fh4/ZBZwDQbWIIuXTsBPY1jzjOO+cTY3r7ZPMiIK6dT79xD1P7zMbN9ecAy9/whLZ2S\n", + "e6CTx9vzOHmZhjZPHP59hvQL18DQn+EKL+X1YJLMYI3m0dEJtFq6C+m7BoApT0DrAVDihlWh5i+a\n", + "iiT+70NqpJ9O/aeq5b1S1n7vQ9B4czywwjgmx3jzgAKEeXyegz0PTeLPivO5ftRhkhf+HsLhObT5\n", + "LVYAzYk+fJh1MXs5bQPUOYhGyq5Oh4tncXTmLZy5u7y4kms4JRaSlo2kTPU06NkLRsfB76TVaMoP\n", + "GwOHI63DsbQHXHI3dH5M+wB803YlWh3cI8DlBpBVcBlyuAcvj1+kaSJLq/Tg1+b3h178WDAUG/6T\n", + "HJaaNg6twi00iCulxJVbUargF2hyqiv6w2zpdyxmQQrJoy/lqe/hxhlPmX82vFGYY1KsH0in1rtY\n", + "0RU2nmu3ZUtg5mlJPI8K066hTDa659WUOTyXCtPtn34NfyZOT9tE3NhXIXEMqc9MYvPRzVzz7cRQ\n", + "Q1mxkPTlHuq9MB6cjrotj5WyL6OU1d/QSXlciMcFQgvgn4KcwHslwcVLWxB9dDGhURlzePziSkN0\n", + "UmtChGnB8HK9+TB+Imf9uI2H3jxAj99eJXlsK3Nw8U/oPRsQJPQCaHFYdAb8MEIlnm+8AkY1gibs\n", + "3hc4HGlDWNMfgINloeIyuLcxnLm0LHAdyiir4edy3wCNxZXmqOHv7lttHQCrgPqZOa1DnWqQ9ljj\n", + "UMkDBUWx4S8a8Hj9BeaFiysNxZU3Uf35y9GQTkPjmNeNY8aioYT/E1ee82bGeOEFtFjmGBh9IHnh\n", + "ClouCWPS6vEBEpgly86jVKhNUv7l3DajIt+PbFXifDpGnEMruvILIyL/pXVru0s2uQY/SKXPusWZ\n", + "hq7B9ouptz8x1Ji9p0K172z45Ies7aFUyoor7dHvyEPVLCzDn2+P3xc2zHcbcJe44tdh8MJi1EhG\n", + "iCth4so9aNHT18Ae45g1xixIMdsmX2g+3VyVmIOXcfbO3mjtSZyd/OYB/xfsIp7isBZbYNkgGDUc\n", + "br0U5jWnZuDnxoawMqJgzs2wMw6+brmBC1ZEoqHQUcBnvtIMNlc2GEgyjlmJSg2eHcKts6EeL1ny\n", + "TKnxkMkD+UYxj78IwDhmkbgyAbgLLS7JE+zD2h1dNZyF0t1aGe3+5XutFZbrPwrl+mdKO4sr3YGr\n", + "gZb54MuHiv5EmOfNzol+46o1fqJdh+XUH249x8Nh0Kc8jat0lsGp7dgE1M72eiK8yV7zJzN314aF\n", + "vbVjEgCfeAxvJXLw+LMh1e4DZNZCTAf6oSJhQeEtplbWK0DlWymbo7io7Kr3eJBXgbuNY3aKK6XR\n", + "ldiU3K4ZCHYib04hGn4A45hN4sqDwMfiSivjGL+hOOOYfeLKRlQb50mgFKp2uQp4VFwp6X2sccxY\n", + "60nfD0wXV94DHmdxzAwpcXFnDpc3/qqqvauISx2GczdCky9J/eta6r94mLj/WYaod3OdbEV48zIq\n", + "cvOEM5lW/x5KHfkJLep6GY3DP09OGYkhwDJx5TH0d9MD1WMKhjVAbaT0Jgzwa3844E2HPrbd04o9\n", + "/qKD54CH8uL1iytVxZXH0R/WE8DnaLL2MX9G3wOjXawuBCoAo8SVsuJKLFodea1xTDBDmW+Iqiw2\n", + "ROOmftFoOVcOT6PUo52h1oNQ+kmYfiN1DzbiMZTOWRYNZbwLXMtb7Sfy0h54d6GX0QfYVUYkYQyH\n", + "w2vxcqdhQZbWqeiqwBvPA49ICKqauSl9grfW0S9dkS+Vwto24kN2Rm42jvGsE9oBs4xj9uV2zSCo\n", + "gUonbC7AOQLhC/Q5ezrQDnbi2YMqXf4GXGAcs8wKCq7DT4MSq4T6KqpfFMchmcyyM4XDv7YPQPf1\n", + "K7JXciPrpn9G2N3d4cfGup9vyC0zhLXlt/OIzpjIw8tiLFHgC6AJWrH7qLgyTFwp5TXGbfYz9SNE\n", + "tU6bO0ulkm3Mu6suHPTuTnlsu6cVe/xFBMYxC8WVScCdBCkKsj+u1qh33x0tIrrSOGZWHq+3X1y5\n", + "EvVqJ6P8+AHGMX/k8yMEhRUq6w884Ft16Y0yhpIAt8+Cu2dAjTSIOAq94J+Rxlyb47zJTd+E2+pk\n", + "l1+4+V8oU52I4WcTVhbSx3aG2+oGqAzdjo/hN46ZJa78A9yMSi4HRAjdv8hc7rf4GM74Bv58GOJT\n", + "KzCs7WHeytypM4UU5ilcFpbCatjcAcwTV340jsnm8drCqGFAdeAL45hXfE6xHJ30/cot2MLDq+WM\n", + "s/7mwu2tiO8GowfZ4rSculC+Inu9RCaeuRnGfgrlvNYjQUJug9GQ0uf2+vuA+8WVxWiYs5u48ggw\n", + "wt7PAai33x+oI67UtFz/YFjFWYvHMLZfzezP57Hvnlbs8RctPIt6/aV93xBXSosrfVGGzmf23wbG\n", + "Mbfm1eh7YLKknXeiSd+fgx9RICShNMNfgu2UFs4RgPo7ofZuNfoQWGTMP5995Sb4rgbRO5SLjhAk\n", + "rurP4wddgT0mrkTm9sEWGJOSYkxC4EpZyyj5pw/sqg3Xd4WpD8HuKt7x5JMuvu8L45jNKMPlY08C\n", + "VlwRceVqYC4wi/llP2VVxSv9VGV7DH/wSuvFDffz3lzVKWrd3+vqwUMjnpBbs6363HjZDThyAAAg\n", + "AElEQVQQRJzOE+ps7vMZh6Ce/yJ0Ypgi2gVsHhq3vwxt8BIKu2clbben+qu3ONbd04o9/iIE45gF\n", + "4soU1Ot/HVQ33P59A/AnWm4+thBj8F3Rgp8H0SrfXvHJlC7MDk7iyml23G1z23dRCyZeN4s6n+8j\n", + "U8oiN5GxHDo60msioDo3b3lLq/g1HqloXiT7OR0zTVxZgTI+Pspt3MHhkaeOhH2nQWpjaPsa7K9e\n", + "BsBWVtdHNWEKghaofnxA5E2V1C++QpuouOLKa2jIrSnQneT4qpzWcDBXLa4GI6vp7lbvKZnlQLPc\n", + "G92npXM0EqY96HPZ4KERX/VQCP7cGMdkWD2eO+3LGw+gbLiXgEjgZ1vs+Ak68Q1EK4iHBBsTltlj\n", + "zIL3CVkCvHBQbPiLHp4Fxoora9GY4plo7P1sWwxTaBDt3PUR0NuoRvpSyeCHSmeSPnoup3n2y/7D\n", + "zBdeBD62MhVBse0ilqeUZnLiaCICh05ywrvdYDlax2c6fUdKeO1l4/7Z1BsDevygXv/74spndnWU\n", + "T1hZ56r3xXHuIBW7q3DHBq4bXVdceQpt3TilgCqkoIb/pUBv5lWV1B9syOcutC7kFuBj4AbjmHRJ\n", + "ThjDtq9qU64cRKRDRhRZYZqF/YErYyFpcBhxf9aE89fbtRjEJWosPsWvlHfYLWs5Gjw0ElrILQfe\n", + "BxaKK48ar/alNkl9NVpc2Qbtm/AUGoINQ1fIHcSVUiZ4P2DPCuG4o9jwFyGIK9VQxkBZ9CF7Crg0\n", + "/1WYQa8VgS5p3zGOmQwq7dy6tixcfRVt34iGB6f5+2Hm+TqtgAQ0eRYKonaex9KUFPNwqNfw9SJ/\n", + "YQFXc83hvXzpFaaxcX++86Li9WvAuG3v0GlrJd9zWkxGE6W90eRmntFUJLEbJIXL4gMTL/8o48gf\n", + "Nbak77l9PnvWDSLSzAW+RQ1obt5jUFj6aV0CxNAVXqqk5dfA2g6E0lfBe1JNLUVGiVvhUCUOolIM\n", + "z2Q9nzFRHCkBc2+CqJ2wt7o9Q5lodGV15pw+HKlaS2Wax3wOVW0q2xOLzyGBXeXfmrRZsMn8uDPX\n", + "Zy9vzXUy2Uq/o6u6d33emyeuPIf+Ri4wjnnErhC+R7n9a4CL0JBRIPiTZz4uKI7xn+SwMdK2onLE\n", + "S9AH5WaUWvbdsTD6FslohWw2D7H2ejKmfgCftoCZXuUs+engZAtdBgJPmtD7DuS5tN3T5m9PSR1z\n", + "u5J7GcGoyHK0Sc0W96/0cg0S74ErbrBHDotjaaPLCeDx26Tec8CTIRbtZIN3/9sLWx9t1urgkYg+\n", + "09cfiGf0IGMWpBjHbEKlGioBfcUVXynfvCAebfgeMHEOMVFEpEOvq6Cmd1QpcPzc+zP0bUCHFbfT\n", + "qe5azmk4gLvQ0KOXrLgNaf0y2MvoA7HrWqAyFOXLrmXbgndh9pAsow/ZY/HZCsju/qMFLXfVFu01\n", + "cSwwGLgzQE3LIGArugrHOGY5qnxr0Naa74krzYLkLIoNfzGywyZrb0ObQ3yMxhTrG8f0NY75ChVP\n", + "u/0YXbsLOrlcb3z0+tMgvdYemDkUWm3K2p7PDk590FXnx3k4Js9tFz1FVKvLQ78eUP0h6PvQXuS2\n", + "6ZEkf72c5NHruHlRI265ANLLw+8vZx2cVjGcwKEe0J6saWhz+zzBMyGtqAgvtYP3f4L3TY6q3tPQ\n", + "z/sWKqbn27kpVISQ2E1LJyEJdteBqd4LqsDx81hIGgpx9ybovf3wR1j6E+XidnIbqjF1jbhyAQAx\n", + "q4YReVN2Kmmp63ZRef1rQFVg6cGtvOOkBae/esOGUh5Am6WX8LdPATEBjePnyD/Zif9m4HpxpbPd\n", + "tgslV3wDlCaDKYcuY/hnpfyqw24DSogr5Y/BuIOi2PCfZBBXGosrb6G85u5oC7rGxjH9TfaGHs+i\n", + "FbaFWuhhaXefANcZx2zxfd/DS4/0Sh3ntYOTvU4MWhSTlMdEdJ49fu9KzjlDYO+LMPkjKLWVHSj3\n", + "/3+sj4H+a2H885r09SBqZ0UgWlxp4M+r9/L6nwrgFQaEZ0L6uRE8ORka2G/XZ/XUCZVseAfVm/9U\n", + "XHkor9ciFMPf+88l1PvqMD98RJZGUnBqYQxECdBhLfwzGDqvyvoMVlPoOeB7cWU8Dy37mEt+2ETF\n", + "DouJvOJvSBzD/rl9zOyNL9rCreXrrmVz3hrdA9qwfh3HRsLcoJRd3wSv5/1twI3AJ+JKFbt5IOoI\n", + "pJ75DUu7HqLc6XfDl1aswlM/YM99Qrz+Asf4RaQb6o2EA+8bk52fKyJ9UOMlqGd0pzGmQFohpxps\n", + "PL0HWpnbHE3WtjRBuvkYx8wVV/5Cy+UDFjzlcRzhaMxyiHGMXwXIfCbJ/OEJ1KBNy+Nxefb4vRkd\n", + "m2Jg8Dnw2jkcOXKEbWgF6Th+L50ASdkTm1HXp3L+grVobuBPtHnGCjTZugztkbsMlR0w6Hf4U6jj\n", + "8kxID0zXgz3wWT1l0jiNYyaJdof6ATjLVlWHutJqEWxs4srZnE4ffqp+L4d6X+6vFSbkZP1cSEQM\n", + "ZHCVj8jzpqrUFW0SXwrYBewDqpvvdu0lMJYDDReoDclLLN6IK0noiuhLGyIrTHwCOOJKFWvofa//\n", + "u7jyOfCRaMP3peLKHED21aHxoNFwx0yYdkSTchFAGJzXVCSR5EyVztmFPOagKJDhF5FwtHNNZ2Aj\n", + "MENEfjImW8/LVUB7Y8xuO0kMRQuM/vOwydp+aMhmPfAO8E2gknc/eBbVMRmaBwMQDM+glZ1B2z3m\n", + "NUnmC3ElDv3czXPb1w/yrFu+wJiU0y6QuKp1eHRnHapWXs6mSr/z/MbZZljmTg45+/+mrxtkRu1I\n", + "EVfmo2Gp1SjXvJF9XYx6mY1Qx+YLceVbsk8KKwJ9N94Tkr/+t9arvwi1FwAYx6yzoZNhqJT2FcYx\n", + "6wJ9djXUtZJ4POJ83rngcUluWsKXoSOuVEJDE3eZWZu+JkAi2R/rZyadN90o47d8Ykw1z7ZrypK+\n", + "pDmT0GKmeWgF+D+ohs2kQGNFDX+rIO8HhNF2pUNRSZPr8nOOIOfeKa58jybZfQvPPHgadQ7uQb+/\n", + "AcCgTQ2oALB9mz48L2TtX6EfDPh3Ov/saF30PP5zgRXGKI1QREag9KRMw29MNo/uL6BWAa9ZpODN\n", + "eEiD9HXCwEUOe9DCqARUoOpS45g5eT23ccwccWUGIerGBINNjvVDVxoh9eEtAN4AXs+nZxZyqMeu\n", + "pC4D7qcLddCV6fv/fu2/B26Q/r+pQGXjmH9Qzyybd2YNdDXU898JlEMbwTQC6osrW8i5SlhGMr+S\n", + "zH1BVk9nAAd85TVsVfV1aG3FX+JKbw/zKtu4PIa63FNxHGoNeyZcBP1qe9Mz7SrvC9Th+DroDc1s\n", + "knMEav0FDVNIa7i9xnf/396Zh0lRXvv/c1iHVUCjbKOgLLIIiqCSoIIahTE/NWpcYy4oxng1qLle\n", + "tyxNeeN6jRHUKCIYE5e4xDUCkahIZDEBRUFRBpQru6Cg7DDD+f3xvs30NLN0d1V3z3I+z1PPdFVX\n", + "V71vdc+pt857zvd8RcnSWaxpu4VNu7exZtW3/G7D9HJPgF/7rN7HJJB+GtPKRv3FOF2cTLkNWCyB\n", + "nFDR9QjJQ8AzEsj/VuSa1JjukkAuBOZIIDNxkhSlWw+gyUWt+PzQzXS9DZh+KCxvA5e/51w+S95l\n", + "18zjqhQJzAphDX8n3Eg1zkrg2Cr2v4wcJyrkk8Qwwi1N4Mkj4KbjGNZgJ+v3NOUe4Eo/GRSGAJdA\n", + "8kimET4+gepPuMncbOi4JJ7rVFyEyXkZHqJaV4+fLLsMNxpfhTP4L4aItS8n1JaM99WulUB+iRvx\n", + "DYnLIvibz8GUPSX0wLmEegAHfTSWzz5yN4IPcX83+yfBL6kiW9cf/3f+aeQ5CSQAHiovx+ANdftX\n", + "YF1/v22f8MwY7maaLDxWAT7DuP0HcPqVrhrb1PvZsvK+2bNKnz+xqk9qTP8mgZyDG5H/ZyW7FeOu\n", + "S0b4+Pr/Ah6QQAaEy63Y59j/lkC+xiU0Tq1kn6XixOr+gnu6GU8Dbv5bES9//xl+ArT75ABYkvBL\n", + "2m8nJdRCH3/Kmh8iMgz3qFRhdqaIjE1YnaGqM0K1rAYQj9p4pSeMPAtOXA7PTqXJvZ+zcOoeva/a\n", + "A6SAxvQ9CWQ+brSe8gRr/EmkhVDQejR9d+/h9W2PalhJgCrx8gb3Ab9Iw52VTKWuHnHa7mNwbpmp\n", + "wHka07DZrlC5bEMyz+JuxEPxVbK88fnML9OS2tsMN38QvyEcj7th9cBFkuwBFkkgv6HsiaFYY7o5\n", + "fgyN6evi1FRfxvn9ry67tt5Q778E1sYNP8TDM8UVNRkFDEzNSPpwzDUD4OHEeeLbq0pSSuQ64EMJ\n", + "5AWNaUWFW1YB+0kgrRL7mCbP41yn/0nIp+AKeAg3yVuh4QfQmP5ZAjmN9U2fZ9KQxvxiRofNrVpe\n", + "spGty6Gk3c5G0DTheXp7CZtIw/CLyFDc7ysUYQ3/KqAwYb0QN+ovh4j0w/kkh6tW9pitY0O2pcYR\n", + "j9o4diUseLhMI2RiBjHv1RAAL0sgE1MZ9Sc+idx6Any1Cw79E4P6TpKiMNILKXAV7gkxjOZPOVeP\n", + "d7MMw0n3Dsb9zvp5Ua+o2EeorSI0pqUSyO04f2+15RG973+hX/bSV6TogNZc/87VnNBlNu1Wd6PX\n", + "9s4cgbshdJdANpHsNnKSHb8C3pJAztGYrtlrqGdfn1AUHWDLdj/PMhk4s6LorYqpIGs2DUExjekm\n", + "CeRyXLZzv8RsWP/+Hj953g0Xxpw2fqL358BMCeSZ1PuWEk8Dd0kgB1c1r8KDh73IxWufpuuVjVnQ\n", + "AwZM2n9egyG7Ru55e033htqhqb/FjoZlK53b8zkJpHEqmdl+QDwjvi4isUw6Ejaccx7QXUS6iEgT\n", + "XAZjucgBETkYpxD5Y1VdWsEx6izxqI2DtqYsDJURXoTtfdxosVriTyIzurgIlydfgEn7xo9Hig91\n", + "+yVwbbrqkIkJMK3WMGj/dzhSAimQQC7FTR4+gMuQPERjekvERh9SH/GD85d3kUCq1R2qiPhN+c7W\n", + "DOvzNQ2XzqD3xY8ysM9YHtOY9gda4typ/4MTPivEjUKfxYWm9gA+k0Ce4oT5S2k8ys2j7IknKY9e\n", + "RvPPHsFlBAfpRFVVVsA9HS0fjenfcf7veyrZZa9YW6aoq1r3RyqfiM30uNtwap0/rXLH9d0v57k3\n", + "GvODK2HhxSB72Nz92g4v0XfVhNYse64Jy+Nhqot36ivAGpw7MGeEGvGraomIXI2r1doQmKSqi0Xk\n", + "Cv/+BFykSFvgIXGhx7tV9ZjKjlmXSFcYKiQB8JIE8mh1bpT4k8if+7mqUB39Q3Um2bdpcBvwhP+n\n", + "TJlkuYWjFTa15pavS7hJGzEHuB4nShe51HACG0gx2kRjulsCuRM36h+e7oniN+XbusLJfko3URLD\n", + "Tyyu8Es515xPYDoU5+q6jpPWz2f/F75mwUf7U9qiMWzfypGfrmLApgCniz9PAmmblB9SIWVhnL29\n", + "jtHHd4dQkLwe5/I5zd8IEglt+D234iZ6v6sxnR3B8eI8DMyQQG6tPAu6VQGrjnVCcj1fcdLRg3/P\n", + "N58evvWbQQvfBL5eMrVc2Hs8pHNZhO2sktBx/Ko6lSSflzf48dejgdFhz1MbiTDmvVo0pvMkkA9w\n", + "o/4/VLVv/Enk0VfK0nQg+ieROOJK8p1B6no8e4kbwvc6wLhjYUF7OHsjrQ+azD9nr9KsF6X2pDPi\n", + "Bxf3/Wtx1aiqq8RUjvhNeY/A6UvKtqdyU/aG6BN/7qeAl+j/7d/p/+8BuM93x7nbinCRdw8CPSSQ\n", + "nZR3G8WXpRrTHVGItyW181txEuKTvcsnMcChGDfXEQqN6WZxevkP+O8hkkg1jeknEsjHwA9xSqQV\n", + "4F1ss25wq+t7wRmXg5y8HeeqTB6Y5TyJyzJ3s0z1WuyREuA04qusDBXPvk00+tl6EvE++PHArzOJ\n", + "YGoFBSUN4Ooi6L3e6fDf+hZ0Xk22Sj9WRJVRPcn4J667SYi/T5X4TfnXM8tG/JD+Tdk/WR2LG0m+\n", + "jjM4TXE68UM0pudrTAfiQk+PwCXUzcH18z9wYcabJJDPGb3yT4wocMqhzeKRh+HqwvrJ3b8B9ya9\n", + "FdWIH5xPfjPRS5vEJ3krwdfv1QagDeCDnwB74IJZxbjvIPlJIT7izxmmzlmH0Jj+SwJZRDWVoXL5\n", + "JIKr0dscN5GYNpthR6M9MHuSW394IBSUZO/ppBLSHfGDk/S9WQLpr65IR0pE6R70k6ln4Nwe83BG\n", + "5zKNlc21xUNR/VIu9t2Hoh7C3MNfpOVh+/OdxdAocbAaui7sDTiXz+laVoAnMsPvJ3qvxtWReK6i\n", + "rNsMeQkYJ4H01ph+nPzmPgqibNnOxkY9aF9yKYs7bmZlyyEytu/yhKelz8gwcS1TbMRf9wiAW6ob\n", + "9efiSURcpbC7cXo8GT1qJ9es3dEIbt7D8izNk1RGSlE9ifiInd+R5qi/onqxKWjVVNWOUlys/hag\n", + "FW5yONXPlmhMl7Go7WrmXguv/aG8jlHIurA+ketSYIIEEq80vhanjRSJcJnGdCFOhuT2KI7nj7kb\n", + "J6vys0r3SVQQ5Yv7eWNIAS1LW9BgQHs2/7pvUp1gc/UY4dCYvgt8BIzMc1PAVdX6p4ao05tsCNc3\n", + "oeTfLbkxyy6zZLYAjTMQxHsYOEEC6Z3Oh7JwU74DNxk8BLhNArnLZ+ymiHddlCOaurAa0xm4qL/x\n", + "fl2J1t0D7sb3AwkkyqCSRyhlpBScMr2CMpJJFI5hyZSOaAM4cBGUNCXJVbYMOCwD4b2MMcNfN4mP\n", + "+rMhU5sSEkhXXBLNDWGPlWgIS5uy+7OfVlncInK8MUrLz+8/txWXsHZLNtqVChLIubhSiBd7WZBB\n", + "wECcxlPbKj/siSKMsxpuBo6TQM7y65EafnW1Hm7CTfRGY/PG9jmCzzs1oM8Fp8CzJ8LU05JG8Qm0\n", + "KqC0KSw7BUqaQWn8Ydy5ynxUVSlp/r7CYIa/DqIxnYuL7hiZx2bcA/w+yph6PyJKW50zIjLx84OL\n", + "nDnNZxXnFAmkF24i8lx1Esn4v6fhonr+JYH0SeVYia4L9ze6YuD+BjkK+IO4+sJRj/jBaeTvJsVc\n", + "l+opHMPcR1sw8CHKBAwqm/D2UT5zj4Id66HkWZwHcG2LhJ1yOsFrhr/ukvNRfzzR6nu9ZEGTzYzo\n", + "cS+LIj5FI6A0ByJy5egrUtR6NZ0HP8PjSRWUqsVnpz5ISlo40SGu3sELwI0+wS+xTSUa0+twSWBv\n", + "JYy084Z3Bz6Nm7uJ3PD7/IergN9KIO3CH7FVActOhd0toGVicnBFE94rxsPZq1m+C0p7Q+lonABu\n", + "t0758vOb4a+j+KSVeCp/1oknWr3agNO+HUb/p6fQ7IRv+d90jGQKpC3JHJZ4v4Z/TbtrGtAvqYJS\n", + "qowDzpRAumSnleXxT0aP4eZXKo2m0pj+CRfTP14CGRuZGyRzfgUchRN/jPwJSWO6AKflU6XseGps\n", + "3oE2gMdmwpb2Cdv3nfB2T0db1qJ3uaiokrirZ3IHOPjnIn2LmN/5aOZ0v73quYLoyPcXbWSXQHbx\n", + "29Mayd8rqPcZKfFEq4cHulqpP1xcVmkowtPk3M0T79cB22BDc7ct3X55H+4E4MbstHIf/gs4BCdY\n", + "VyUa03k4v/8pwAsSSOsst62qtmzHuSevIYRKZzX8CjjbJxWGIN0J7zYuP/7pV5zI3V4KOsHgcaz6\n", + "zaEUDOlS9VxBdJjhr8P0Gct+B66h9Xn9OLWCep+R0goKFHjqCBg3rSwjOGIZiLTLLoYlnkl793T4\n", + "aYLDJIN+/R44XwLpFF3r9kUCGYaTRDg3VZluL2R2Ei6Ucm4+5iMS2jIXp7PTwheIifr4G3GaUaEm\n", + "etOf8PZ+/q0HJkzuAmzvABO7sfEwaBtXbAiXHJcKZvjrMIUw5rk3aHbbCbDbf9NZGIUDLtFKgHcm\n", + "Q98vy7ZHnGiV8xF/PJO2xW5IrDOcQSbtepz7JXSUU2VIIJ1xMeuXaBVlOytCY7pLY/oznFvqHQkk\n", + "bZ2hCInholyqyI4NxWM4bbFQbtD0JrwrekIYtQ02u6I0a48sk3gAIkiOqxIz/HWYVlBw/BdO5uDt\n", + "LmXbsyHGFk+0apAglZYFGYic+/iTE8ggVL/uAS7xhW8ixU/iPwfcrzGdnulxNKYTcIXCJ0kgN+Yy\n", + "tjyhDTtw0sP/nY1r5Sd6rwbuiCpRrNpzuieEJ+CsbbS7CNr8GBjVHHocCDNhezsoPj3hE+GS46rD\n", + "DH8dJj5afe1JOOWzsu3ZkDuIOuO0EnLu6omyX04jnydxPviouRdXtevOsAfSmM7C6fycAzztM7Bz\n", + "zbu4qmQPZ+Pm48XzXsVFv+WIwsHwUnP2vxjOWgGcAExuDvcmFbKJJjmuKkyrpw6zV/elNCey0KGL\n", + "sKdAXmL4I+7X3ZTy8bDWMuA7m2m4GXasgPFhbpASyCW4wu+DtIJ6sJmgMV0pgZyAm5SeJYGcpTFX\n", + "WztHFONqDh+Ok5l+IgvnuAX4WAKZpK6ecpbxFdE+PwlaJ6a3NFgGRav26vrwxf1R5klUhBn+OkyO\n", + "xdhyQc5H/FHTZyxH7Pwhe743iJN++6bbdjkc1leETL4XCaQ/brR/ks9QjQyN6Q4JZCQuOmiuBHKh\n", + "xrTaymIRUYxLaBopJbx5Yju57KCNSBQ3yjga0w2+rOUDEsiJWa7pwN4J3pJmMD9RMHTHKtUpI7J7\n", + "7vKY4a/j5GAUnhP6ihQd0Y9bVw+k6wiRaVH98+eaQhjz4AxaD7ocrp8NbXaUL7RS3efjtZJbQcGG\n", + "FpTINfTWJozxYmSR443hOK/6+nTLS+SlIU/QpTUURGmEK6AY6N47oH2jkyltNYKhzzzlosXC3Cgr\n", + "YKI7JBfh3HBZJFzpykhR1bwvrhn5b4ctNXPpA0WjofivvdCzzkcVdDQU94GifLct3eVHMENB//v7\n", + "6OzOri8K+iOYkep1UNBSQX9wIdrz/7ExV9ehcx9GtbmKnSPPRLc3yv73wFg2nLgfb+5siB55Bfpm\n", + "l7LrNQKmRniewYxlFWNpne1rCH2KYMRU+NEM97dPqGuXqe20yV2jxhNPotrZ0GnxQ/bCUrNNfML9\n", + "7ukwOMHNm8qEe/w6ANx2PGxsBh9OoU2urkPfjzh/5SM02dYYRp/htmX5eyguPZC2TUrh7T/CsOVl\n", + "b0QZmaYxncOGJh+xoOMH1StthjxXFjWP0sFcPUaNJ55ENXgldEmo4ZXlGsFZIUyhlfh1WN0KJh8F\n", + "syZDk9LcXYdWUNBiN/zl+bIsZsjq+Zd8eSADKIbWSVP6UUamifQtouW53bjy9S58Z2wX1vcmTGnJ\n", + "2oAZfqPGEx8ld9lU3vDnuApXJISZcI9fh46bYfGDZU8/uboO8fML8J2EAMQsnr/4i94UXD6Lgigq\n", + "klVO4Ri2PNmVt++HE34Lf30K54cvSmnepTZiht+o8URZjrAmkOmEe+J1iBv9XF6HPHwPxTs6caTP\n", + "o8hiZJoPs5x3JSwYlbA9u9mz+cQMv1HjqYNhqRmR7+uQh/MXA92zH5nmwyz3NIJdiZUps5s9m0/E\n", + "zwzntxEiqqo5Tw03jJqKm1wsHONGo5t3wIrxddXfXBm+psBaoGU2Y+zdtR48bt8wy0irjGWFTG2n\n", + "GX7DqGFUbIguXwpzrsm1IUrMG8hy3P4+iPQt4sZPX+SR789no36bzZufu+YH/zyX2bNRkKntNFeP\n", + "YdQ4CsfAxG60WQ6buvhtuZ9sjBehSfTpR5w8VSl7b35ftm3CfjcMZuNQshlp449Z4w19VFgcv2HU\n", + "NA7ZcQAXnAmjjocmmxPeyO1kYwP2u/ULBnY7vtEQhjXvz2u0zGH+hL/5fd0d9l/it2Vfp76+YCN+\n", + "w6gh+KpQMc5v3JcZv4Pnn4GSgoQ9cjfZKNK3qBlFvRfyFAy8DzrPZcXzPYEptGRLDm5APtJm7rWw\n", + "K1EctO5G2uQSM/yGkWf2GnwYCNzJH7pOZsuH90BBHjVdCsds56lmNN4G37sLnpzKMo7kfgbRgHk5\n", + "uAH5SJt1/ZK2191Im1wS2vCLyHDgPlxFm0dV9a4K9hkPjAC2ASNV9f2w5zXqHvmcSMwFyf17/7u8\n", + "tu5UTiFu8OF8jekOYiDSd7fz6edrstGPuNsthcXnuApRwHu03nFgDvIGOvDunEI6HN+Mns230pRP\n", + "GMMWXsyPoFldJKRAUENcdaIuQGNgAdAraZ8iYIp/fSwwNyqhIVvqzpIoQBZfaqsQW3X9m98BPeMC\n", + "tNn1lLT8MQ8xloJ8t204TPsRzBgO0/pAEQyflvBV7F0aMWxePn4LF9J0awfaxvL9Pda0JVPbGfak\n", + "g4FpCes3ATcl7fMwcH7C+ifAQVE03pa6swyHaQr69iHoO4XoknboN03R4RGqMNaE/l13GtrxF+j4\n", + "Y5zCZZQqk5ksld1wO9A2BqOLyxv+y5aGVZNM51oVt0PPvKCsAfm+VjVxydR2hnX1dAJWJKyv9KP6\n", + "6vbpDKwLeW6jDhEXIHuuN8zvCOtawJctYFtDTpVA/g9XVnBdNX83aExL89ODqon372fz4PY3ynR2\n", + "8i00F1f8/LoZXHAu3PM6TFxHtyI2HreGOdfkw90Uv1b/7giNEuqJ5fta1SXCGv5Us7+SEwzynzVm\n", + "1CjiAmD3Ty2//dQm/GP6LVwBHAQcmPC3C3BM0vY2EshGqr9BrAO+1JimNFEYRRZtvH89viq/Pd9C\n", + "c3Ej23Y7XLgQTv4JXDsXms+iuZbmJ7Y9fq3md4SBq8u25/ta1SXCGv5VQGHCeiFuRF/VPp39tnKI\n", + "yNiE1RmqOiNk24xaRGUCYKt3Mc7Xel1e3TEkkEbAAZS/QcT/9kjeLoHsorqbxMsde9J82I1s+/Oh\n", + "ZeOX9BOJaqrQXKLi5qgFcPLnTmt/dj/6SyC9NKaLc92m+LUq7ki3X85022rCtaoJiMhQYGjo43g/\n", + "UaaNaAR8CpwMrAb+BVyoWvZjEZEi4GpVLRKR44D7VPW4pOOommRDvaevSNHBOdFVUYcAAAkCSURB\n", + "VBIAk0AEaE3ZjaCim8VBfFMwgKZNm9N4G7w6IUG9sWhaunVSc9m/dNqUnJ17GSx79kKmbunJBcDd\n", + "wL25dqH1biSnf3ojL58+jrklW9lcE65VTSRvWj0iMoKycM5JqnqHiFwBoKoT/D4PAMOBrcAoVX0v\n", + "isYbRrYROW8GPHsiDXeCaEJC1Xlvqz47NI9Ni4zKbkgSSFdgMq7I/UiN6ZJqDhUZEsjhwGsa08Ny\n", + "dc7aSN60elR1KjA1aduEpPWrw57HMPKDTyQqbZq0ve4kElUme6wx/VwCORm4CpgtgfwPcL/GdE/y\n", + "vlngaGB+Ds5TLzGtHsOokhXjnTJmIrnOos0fGtM9GtP7caHb5wFvSSCH5uDUA4F5OThPvcRkmQ2j\n", + "GmqrZG/USCANgWtx+Tq/ASZka/QvgfwTiGlM38zG8esKpsdvGEZOkEB6AY8D3wKXaky/iPj4DYFN\n", + "QKHGdFN1+9dnMrWd5uoxDCMtfIjnd4E3gPkSyGU+SioqegJrzehnDzP8hmGkjca0RGN6B3ASbvL3\n", + "NQmkU0SHN/9+ljHDbxhGxmhMF+JkWt4F3pdALolg9G+GP8uYHr9hGKHQmO4GAgnkVZzv/xw5tMtz\n", + "fN7rkgxlLgYCL2StwYZN7hqGER0SSFNWNnucdnvOZcofG7LofJwgRGrF4r3sxiago8b021y0uTZj\n", + "k7uGYeQdjelOHj2xDU/ObMiJAQz7jX8n5Xq5vYCVZvSzixl+wzAiplUBq46BCe/D/J8mbK+6Xq5I\n", + "3yJe7/EUS9q3FRkxzeVPGNnAfPyGYUSMl7koKYBvE4V5K5e5cEZ+8DjaNOnGZ92A607LRAXVSA0b\n", + "8RuGETGZyFwUjoGJ3eg4H1YP9NtSdg8ZaWIjfsMwIkV10RSRvqRXvcsXd597LawZkLC9aveQkRlm\n", + "+A3DiBxv5NNw0Xj30KILkrbXHRXUmoS5egzDqAHUbxXUXGNx/IZh1AhMBTV9TJ3TMAyjnmEJXIZh\n", + "GEZKmOE3DMOoZ5jhNwzDqGeY4TcMw6hnmOE3DMOoZ5jhNwzDqGeY4TcMw6hnmOE3DMOoZ5jhNwzD\n", + "qGeY4TcMw6hnmOE3DMOoZ2Rs+EWknYhMF5ElIvK6iLSpYJ9CEXlLRD4SkUUiMiZccw3DMIywhBnx\n", + "3wRMV9UewBt+PZndwHWq2gc4DrhKRHqFOGetRESG5rsN2cT6V7upy/2ry30LQxjDfwbwuH/9OHBW\n", + "8g6qulZVF/jXW4DFQMcQ56ytDM13A7LM0Hw3IMsMzXcDsszQfDcgiwzNdwNqImEM/0Gqus6/Xgcc\n", + "VNXOItIFOAp4N8Q5DcMwjJBUWXpRRKYD7St465eJK6qqIlKpsL+ItASeB67xI3/DMAwjT2RciEVE\n", + "PgGGqupaEekAvKWqh1ewX2Pgb8BUVb2vkmPlvxqMYRhGLSSTQixhiq2/AvwHcJf/+1LyDiIiwCTg\n", + "48qMPmTWcMMwDCMzwoz42wHPAgcDy4HzVHWTiHQEJqrq6SIyBJgJfAjET3Szqk4L3XLDMAwjI2pE\n", + "zV3DMAwjd+Qlc7euJn+JyHAR+UREikXkxkr2Ge/f/0BEjsp1G8NQXf9E5GLfrw9FZJaI9MtHOzMh\n", + "le/O7zdIREpE5Oxcti8sKf42h4rI+/7/bUaOmxiKFH6bB4jINBFZ4Ps3Mg/NzAgRmSwi60RkYRX7\n", + "pGdXVDXnC3A3cIN/fSNwZwX7tAeO9K9bAp8CvfLR3hT71BBYCnQBGgMLktsLFAFT/Otjgbn5bnfE\n", + "/RsM7OdfD68t/Uulbwn7vYkLVjgn3+2O+LtrA3wEdPbrB+S73RH3byxwR7xvwFdAo3y3PcX+HY8L\n", + "hV9Yyftp25V8afXUxeSvY4ClqrpcVXcDfwHOTNpnb79V9V2gjYhUmf9Qg6i2f6o6R1W/8avvAp1z\n", + "3MZMSeW7A/g5Lix5fS4bFwGp9O8i4K+quhJAVTfkuI1hSKV/a4DW/nVr4CtVLclhGzNGVf8JbKxi\n", + "l7TtSr4Mf11M/uoErEhYX+m3VbdPbTGOqfQvkcuAKVltUXRU2zcR6YQzJg/5TbVpciyV76470M67\n", + "V+eJyCU5a114UunfRKCPiKwGPgCuyVHbckHadiVMOGeV1MPkr1QNQXLoam0xICm3U0SGAZcC38te\n", + "cyIllb7dB9zkf6/Cvt9jTSaV/jUGBgAnA82BOSIyV1WLs9qyaEilf7cAC1R1qIgcBkwXkf6qujnL\n", + "bcsVadmVrBl+Vf1+Ze/5iYr2Wpb89WUl+zUG/go8oar75AnUMFYBhQnrhbg7b1X7dPbbagOp9A8/\n", + "oTsRGK6qVT2e1iRS6dvRwF+czecAYISI7FbVV3LTxFCk0r8VwAZV3Q5sF5GZQH+gNhj+VPr3XeA2\n", + "AFVdJiKfAz2BeTlpYXZJ267ky9UTT/6CkMlfNYh5QHcR6SIiTYDzcf1M5BXgJwAichywKcHlVdOp\n", + "tn8icjDwAvBjVV2ahzZmSrV9U9VDVbWrqnbFPYFeWUuMPqT223wZGCIiDUWkOW6S8OMctzNTUunf\n", + "J8ApAN7/3RP4LKetzB7p25U8zVK3A/4BLAFeB9r47R2B1/zrIcAe3Az9+34Znu8Z9mr6NQIXfbQU\n", + "l6gGcAVwRcI+D/j3PwAG5LvNUfYPeBQXLRH/vv6V7zZH+d0l7PsYcHa+2xx1/4DrcZE9C4Ex+W5z\n", + "lP3DPaW96v/vFgIX5bvNafTtaWA1sAv3ZHZpWLtiCVyGYRj1DCu9aBiGUc8ww28YhlHPMMNvGIZR\n", + "zzDDbxiGUc8ww28YhlHPMMNvGIZRzzDDbxiGUc8ww28YhlHPMMNvGBUgIoGIXJOwflttKAZkGKlg\n", + "mbuGUQEicgjwgqoeLSINcPIig7T2CM8ZRqVkTZ3TMGozqvp/IvKViByJkxd/z4y+UVcww28YlfMo\n", + "MApXKGhynttiGJFhrh7DqARfD2IRrqZrd7V/FqOOYCN+w6gEVd0tIm8CG83oG3UJM/yGUQl+Uvc4\n", + "4Nx8t8UwosTCOQ2jAkSkN67s4D9UdVm+22MYUWI+fsMwjHqGjfgNwzDqGWb4DcMw6hlm+A3DMOoZ\n", + "ZvgNwzDqGWb4DcMw6hlm+A3DMOoZ/x+00DEWA9mFZwAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['LWLR-CMAES']\n", + "modelCMA = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelCMA)\n", + "inv_CMA = generateInvTest(environment, modelCMA)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inverse models comparisons" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'max time': 0.010724067687988281, 'mean time': 0.00041047811508178713, 'mean distance': 0.20168292159661327, 'max distance': 0.59686369464621802, 'std time': 0.0010366151892852594, 'std distance': 0.13705465684012169} \n", + "{'max time': 0.033882856369018555, 'mean time': 0.012726972103118897, 'mean distance': 0.23639504162074204, 'max distance': 0.76669268165169346, 'std time': 0.0022641205855169206, 'std distance': 0.14802255009520515} \n", + "{'max time': 0.06476306915283203, 'mean time': 0.037118465900421144, 'mean distance': 0.18990682784894602, 'max distance': 0.67562787551620396, 'std time': 0.010865131486743193, 'std distance': 0.12664684144794416} \n", + "{'max time': 0.07274603843688965, 'mean time': 0.022376320362091064, 'mean distance': 0.2002982591788359, 'max distance': 0.60823034408229959, 'std time': 0.0094409313074482956, 'std distance': 0.12922653395158204} \n", + "{'max time': 0.2664639949798584, 'mean time': 0.14175652027130126, 'mean distance': 0.19038157825142649, 'max distance': 0.62944030876841794, 'std time': 0.018157911349176364, 'std distance': 0.13479678396048539}\n" + ] + } + ], + "source": [ + "print inv_NN, '\\n', inv_WNN, '\\n', inv_BFGS, '\\n', inv_COBYLA, '\\n', inv_CMA" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Distance between $s_p$ and $s$ comparison\n", + "The mean distance is almost the same for each method knowing that the training set has 10000 $m,s$ pairs and that we test 100 points. With others parameters, CMAES could have better results.\n", + "\n", + "#### Time processing comparison\n", + "NN is the fastest inverse method and is used to find the first point in BFGS, COBYLA, CMAES and GMR look up. CMAES is almost 4 times slower than Cobyla and BFGS and 10 times slower than WNN to compute the distance (for $n$ = 100 observations). " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}