diff --git a/conf/velmass_ini.ini b/conf/velmass_ini.ini index f47d13f..0478140 100644 --- a/conf/velmass_ini.ini +++ b/conf/velmass_ini.ini @@ -20,16 +20,16 @@ bias_sampler_blocked= true nmean_sampler_blocked= true sigma8_sampler_blocked = true omega_m_sampler_blocked = true -muA_sampler_blocked = true -alpha_sampler_blocked = true -lam_sampler_blocked = true -sig_v_sampler_blocked = true -bulk_flow_sampler_blocked = true +muA_sampler_blocked = false +alpha_sampler_blocked = false +lam_sampler_blocked = false +sig_v_sampler_blocked = false +bulk_flow_sampler_blocked = false ares_heat = 1.0 [mcmc] number_to_generate = 15000 -warmup_model = 0 +warmup_model = 500 warmup_cosmo = 0 random_ic = false init_random_scaling = 0.1 diff --git a/figs/field_slice_velmass_delta.png b/figs/field_slice_velmass_delta.png new file mode 100644 index 0000000..ca31a4c Binary files /dev/null and b/figs/field_slice_velmass_delta.png differ diff --git a/figs/field_slice_velmass_delta_cropped.png b/figs/field_slice_velmass_delta_cropped.png new file mode 100644 index 0000000..627d07a Binary files /dev/null and b/figs/field_slice_velmass_delta_cropped.png differ diff --git a/figs/pk_velmass_delta_cropped.png b/figs/pk_velmass_delta_cropped.png new file mode 100644 index 0000000..32ca8e9 Binary files /dev/null and b/figs/pk_velmass_delta_cropped.png differ diff --git a/notebooks/Analyse_chain.ipynb b/notebooks/Analyse_chain.ipynb index 66e0ac0..b0ff22b 100644 --- a/notebooks/Analyse_chain.ipynb +++ b/notebooks/Analyse_chain.ipynb @@ -30,7 +30,13 @@ " try:\n", " yield\n", " finally:\n", - " sys.stdout = old_stdout" + " sys.stdout = old_stdout\n", + " \n", + "from analysis import (\n", + " get_mcmc_steps, load_param_samples, get_truths,\n", + " crop_field, compute_ensemble_mean_field, \n", + " get_mock_field, get_spectra, get_both_fields,\n", + " get_likelihood_values)" ] }, { @@ -41,290 +47,7 @@ "tags": [] }, "outputs": [], - "source": [ - "def get_mcmc_steps(dirname, nframe, iter_max, iter_min=0):\n", - " \"\"\"\n", - " Obtain evenly-spaced sample of MCMC steps to make movie from\n", - " \"\"\"\n", - " all_mcmc = glob.glob(dirname + '/mcmc_*.h5')\n", - " x = [m[len(dirname + '/mcmc_'):-3] for m in all_mcmc]\n", - " all_mcmc = np.sort([int(m[len(dirname + '/mcmc_'):-3]) for m in all_mcmc])\n", - " if iter_max >= 0:\n", - " all_mcmc = all_mcmc[all_mcmc <= iter_max]\n", - " all_mcmc = all_mcmc[all_mcmc >= iter_min]\n", - " if nframe > 0:\n", - " max_out = max(all_mcmc)\n", - " min_out = min(all_mcmc)\n", - " step = max(int((max_out - min_out+1) / nframe), 1)\n", - " all_mcmc = all_mcmc[::step]\n", - " if max_out not in all_mcmc:\n", - " all_mcmc = np.concatenate([all_mcmc, [max_out]])\n", - " return all_mcmc\n", - "\n", - "def load_param_samples(ini_name, dirname, nframe, iter_max, iter_min):\n", - " \n", - " config = configparser.ConfigParser()\n", - " config.read(ini_name)\n", - " to_sample = []\n", - " for k,v in config['block_loop'].items():\n", - " if v.strip() == 'false':\n", - " i = k.index('_sampler')\n", - " if k[:i] not in ['hades', 'bias', 'nmean']:\n", - " to_sample.append(k[:i])\n", - " \n", - " print(\"TO SAMPLE\", to_sample)\n", - " nsamp = int(config['run']['nsamp'])\n", - " new_to_sample = []\n", - " for s in to_sample:\n", - " if s in ['omega_m', 'sigma8', 'sig_v']:\n", - " new_to_sample.append(s)\n", - " elif s == 'bulk_flow':\n", - " for d in ['_x', '_y', '_z']:\n", - " new_to_sample.append(f'{s}{d}')\n", - " else:\n", - " for i in range(nsamp):\n", - " new_to_sample.append(f'{s}{i}')\n", - " \n", - " # This is desired list to sample\n", - " to_sample = new_to_sample\n", - " \n", - " # Which steps to use\n", - " all_mcmc = get_mcmc_steps(dirname, nframe, iter_max, iter_min=iter_min)\n", - " \n", - " sampler = config['sampling']['algorithm'].lower()\n", - " samples = np.empty((len(to_sample),len(all_mcmc)))\n", - " \n", - " print('MY SAMPLER IS', sampler)\n", - " \n", - " if sampler == 'slice': \n", - "\n", - " for i in tqdm(range(len(all_mcmc))):\n", - " with h5.File(f'{dirname}/mcmc_{all_mcmc[i]}.h5', 'r') as f:\n", - " for j, s in enumerate(to_sample):\n", - " if 'model_params_' + s in f['scalars'].keys():\n", - " samples[j,i] = f['scalars/model_params_' + s][:][0]\n", - " elif 'model_params_cosmology.' + s in f['scalars'].keys():\n", - " samples[j,i] = f['scalars/model_params_cosmology.' + s][:][0]\n", - " elif s == 'sig_v':\n", - " samples[j,i] = float(config['model'][s])\n", - " elif s.startswith('bulk_flow'):\n", - " if s[-1] == 'x':\n", - " samples[j,i] = np.array(ast.literal_eval(config['model']['bulk_flow']))[0]\n", - " elif s[-1] == 'y':\n", - " samples[j,i] = np.array(ast.literal_eval(config['model']['bulk_flow']))[1]\n", - " elif s[-1] == 'z':\n", - " samples[j,i] = np.array(ast.literal_eval(config['model']['bulk_flow']))[2]\n", - " else:\n", - " raise NotImplementedError\n", - " else:\n", - " if s in config[f'cosmology'].keys():\n", - " samples[j,i] = float(config['cosmology'][s])\n", - " else:\n", - " print(\"NOT THERE\")\n", - " samples[j,i] = float(config[f'sample_{s[-1]}'][s[:-1]]) \n", - " \n", - " elif sampler in ['hmc', 'mvslice', 'transformedblackjax', 'blackjax']:\n", - " \n", - " if sampler in ['hmc', 'transformedblackjax']:\n", - " key_name = 'attributes'\n", - " key_name = 'model_params'\n", - " elif sampler in ['mvslice', 'blackjax']:\n", - " key_name = 'model_paramsattributes'\n", - " \n", - " # Get order in which model parameters are stored\n", - " if os.path.isfile(f'{dirname}/model_params.txt'):\n", - " with open(f'{dirname}/model_params.txt', 'r') as file:\n", - " model_params = [line.strip() for line in file]\n", - " else:\n", - " model_params = []\n", - " \n", - " print(model_params)\n", - " \n", - " for i in tqdm(range(len(all_mcmc))):\n", - " with h5.File(f'{dirname}/mcmc_{all_mcmc[i]}.h5', 'r') as f:\n", - " if key_name in f['scalars'].keys():\n", - " data = f[f'scalars/{key_name}'][:]\n", - " else:\n", - " data = None\n", - " for j, s in enumerate(to_sample):\n", - " if s in model_params:\n", - " samples[j,i] = data[model_params.index(s)]\n", - " elif 'model_params_cosmology.' + s in f['scalars'].keys():\n", - " samples[j,i] = f['scalars/model_params_cosmology.' + s][:][0]\n", - " elif s == 'sig_v':\n", - " samples[j,i] = float(config['model'][s])\n", - " elif s in config[f'cosmology'].keys():\n", - " samples[j,i] = float(config['cosmology'][s])\n", - " elif s.startswith('bulk_flow'):\n", - " idx = {'x':0, 'y':1, 'z':2}\n", - " idx = idx[s[-1]]\n", - " samples[j,i] = np.array(ast.literal_eval(config['model']['bulk_flow']))[idx]\n", - " else:\n", - " samples[j,i] = float(config[f'sample_{s[-1]}'][s[:-1]]) \n", - " else:\n", - " raise NotImplementedError\n", - "\n", - " return to_sample, all_mcmc, samples\n", - "\n", - "\n", - "def get_truths(ini_name, to_sample):\n", - " \n", - " config = configparser.ConfigParser()\n", - " config.read(ini_name)\n", - " \n", - " truths = [None] * len(to_sample)\n", - " \n", - " for i, s in enumerate(to_sample):\n", - " if s in config[f'cosmology'].keys():\n", - " truths[i] = float(config['cosmology'][s])\n", - " elif s == 'sig_v':\n", - " truths[i] = float(config['model'][s])\n", - " elif s.startswith('bulk_flow'):\n", - " idx = {'x':0, 'y':1, 'z':2}\n", - " idx = idx[s[-1]]\n", - " truths[i] = np.array(ast.literal_eval(config['model']['bulk_flow']))[idx]\n", - " else:\n", - " truths[i] = float(config[f'sample_{s[-1]}'][s[:-1]]) \n", - " \n", - " return truths\n", - "\n", - "\n", - "def crop_field(ini_name, field):\n", - " \n", - " config = configparser.ConfigParser()\n", - " config.read(ini_name)\n", - " Rmax = float(config['mock']['R_max'])\n", - " xmin = float(config['system']['corner0'])\n", - " L = float(config['system']['L0'])\n", - " N = int(config['system']['N0'])\n", - " x = np.linspace(xmin, xmin+L, N)\n", - " m = np.abs(x) < Rmax\n", - " L = x[m].max() - x[m].min()\n", - " \n", - " return field[m][:, m][:, :, m], L\n", - "\n", - "\n", - "def compute_ensemble_mean_field(ini_name, dirname, nframe, iter_max, iter_min, cut_field=True):\n", - " \"\"\"\n", - " Compute the mean and std deviation of the inferred density field\n", - " \"\"\"\n", - "\n", - " print('Computing ensemble mean field')\n", - " \n", - " # Which steps to use\n", - " all_mcmc = get_mcmc_steps(dirname, nframe, iter_max, iter_min=iter_min)\n", - "\n", - " #COMPUTE THE MEAN-DENSITY FIELD\n", - " for i in tqdm(range(len(all_mcmc))):\n", - " idx = all_mcmc[i]\n", - " with h5.File(dirname + \"/mcmc_%d.h5\" % idx,'r') as mcmc_file:\n", - " temp_field = np.array(mcmc_file['scalars/BORG_final_density'][...],dtype=np.float64)\n", - " if i == 0:\n", - " mean_field = np.array(np.full(temp_field.shape,0),dtype=np.float64)\n", - " std_field = np.array(np.full(temp_field.shape,0),dtype=np.float64)\n", - " mean_field += temp_field\n", - " std_field += temp_field*temp_field\n", - " mean_field = mean_field/np.float64(len(all_mcmc))\n", - " std_field = std_field/np.float64(len(all_mcmc)) # < delta^2 >\n", - " std_field = np.sqrt(std_field - mean_field **2) # < delta^2 > - < delta >^2\n", - " \n", - " # Cut the density field if needed\n", - " if cut_field:\n", - " mean_field, _ = crop_field(ini_name, mean_field)\n", - " std_field, _ = crop_field(ini_name, std_field)\n", - " \n", - " return mean_field, std_field\n", - "\n", - "\n", - "def get_mock_field(ini_name, dirname, which_field='delta', cut_field=True):\n", - " with h5.File(f'{dirname}/mock_data.h5', 'r') as f:\n", - " if which_field == 'delta':\n", - " dens = f['scalars/BORG_final_density'][:]\n", - " elif which_field == 'ics':\n", - " dens = f['scalars/s_field'][:]\n", - " if cut_field:\n", - " dens, L = crop_field(ini_name, dens)\n", - " else:\n", - " config = configparser.ConfigParser()\n", - " config.read(ini_name)\n", - " L = float(config['system']['L0'])\n", - " return dens, L\n", - "\n", - "\n", - "def get_spectra(ini_file, dirname, nframe, iter_max, iter_min, which_field='delta', cut_field=True):\n", - " \n", - " # Which steps to use\n", - " all_mcmc = get_mcmc_steps(dirname, nframe, iter_max, iter_min=iter_min)\n", - " \n", - " if which_field == 'delta':\n", - " MAS = \"CIC\"\n", - " elif which_field == 'ics':\n", - " MAS = None\n", - " else:\n", - " raise NotImplementedError\n", - " \n", - " # Compute original power spectrum\n", - " delta1, boxsize = get_mock_field(ini_name, dirname, which_field=which_field, cut_field=cut_field)\n", - " print(\"BOXSIZE\", boxsize)\n", - " Pk = PKL.Pk(delta1.astype(np.float32), boxsize, axis=0, MAS=MAS, threads=1, verbose=True)\n", - " k = Pk.k3D\n", - " Pk_true = Pk.Pk[:,0]\n", - " \n", - " # Get other spectra\n", - " all_pk = np.zeros((len(all_mcmc), len(k)))\n", - " all_r = np.zeros((len(all_mcmc), len(k)))\n", - " for i in tqdm(range(len(all_mcmc))):\n", - " idx = all_mcmc[i]\n", - " with h5.File(dirname + \"/mcmc_%d.h5\" % idx,'r') as mcmc_file:\n", - " if which_field == 'delta':\n", - " delta2= np.array(mcmc_file['scalars/BORG_final_density'][...],dtype=np.float64)\n", - " elif which_field == 'ics':\n", - " delta2 = np.array(mcmc_file['scalars/s_field'][...],dtype=np.float64)\n", - " else:\n", - " raise NotImplementedError\n", - " if cut_field:\n", - " delta2, _ = crop_field(ini_name, delta2)\n", - " with suppress_stdout():\n", - " Pk = PKL.XPk([delta1.astype(np.float32),delta2.astype(np.float32)], boxsize, axis=0, MAS=[MAS, MAS], threads=1)\n", - " all_pk[i,:] = Pk.Pk[:,0,1] #monopole of field 2\n", - " all_r[i,:] = Pk.XPk[:,0,0] / np.sqrt(Pk.Pk[:,0,1] * Pk.Pk[:,0,0])\n", - " \n", - " return k, Pk_true, all_pk, all_r\n", - "\n", - "\n", - "def get_both_fields(ini_file, dirname, step, which_field='delta', cut_field=True):\n", - " \n", - " # Mock\n", - " delta1, boxsize = get_mock_field(ini_name, dirname, which_field=which_field, cut_field=cut_field)\n", - " \n", - " # Step\n", - " with h5.File(dirname + \"/mcmc_%d.h5\" % step,'r') as mcmc_file:\n", - " if which_field == 'delta':\n", - " delta2= np.array(mcmc_file['scalars/BORG_final_density'][...],dtype=np.float64)\n", - " elif which_field == 'ics':\n", - " delta2 = np.array(mcmc_file['scalars/s_field'][...],dtype=np.float64)\n", - " else:\n", - " raise NotImplementedError\n", - " if cut_field:\n", - " delta2, _ = crop_field(ini_name, delta2)\n", - " \n", - " return delta1, delta2\n", - "\n", - "\n", - "def get_likelihood_values(dirname, nframe, iter_max, iter_min):\n", - " \n", - " all_mcmc = get_mcmc_steps(dirname, nframe, iter_max, iter_min=iter_min)\n", - " \n", - " all_logL = np.zeros(len(all_mcmc))\n", - " all_logprior = np.zeros(len(all_mcmc))\n", - " for i in tqdm(range(len(all_mcmc))):\n", - " with h5.File(f'{dirname}/mcmc_{all_mcmc[i]}.h5', 'r') as f:\n", - " s_hat = f['scalars/s_hat_field'][:]\n", - " all_logL[i] = f['scalars/hmc_Elh'][:]\n", - " all_logprior[i] = f['scalars/hmc_Eprior'][:]\n", - " \n", - " return all_logL, all_logprior" - ] + "source": [] }, { "cell_type": "markdown", diff --git a/notebooks/Velmass_analysis.ipynb b/notebooks/Velmass_analysis.ipynb new file mode 100644 index 0000000..e176bf5 --- /dev/null +++ b/notebooks/Velmass_analysis.ipynb @@ -0,0 +1,259 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 65, + "id": "bbe11a9c-4251-4685-b339-666197ee2aa6", + "metadata": {}, + "outputs": [], + "source": [ + "import analysis\n", + "import importlib\n", + "importlib.reload(analysis)\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "05a5d6ae-3eeb-46b9-994d-ef32117e74a1", + "metadata": {}, + "source": [ + "# Density Field Slice" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "f4137a68-a2a5-4ee1-ad4a-aa01eec8a59d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing ensemble mean field\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 111/111 [00:01<00:00, 76.44it/s]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvAAAAKyCAYAAACzNuodAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9d5wlV3UtvKrq5r637+0cpnvyjNKMcgYhCQkJTLCNDbb1jA3GNjbg9/gE5lnmMxZ+BmxsA37gxGcewsYEEx7BBiyBQEI5x8mxe6ZzuN19++Zb9f1xzqm9rrqlGYEm9lm/3/y6pm6FU1Xn7Dq199prO0EQBLCwsLCwsLCwsLCwOCXgnugGWFhYWFhYWFhYWFgcPewE3sLCwsLCwsLCwuIUgp3AW1hYWFhYWFhYWJxCsBN4CwsLCwsLCwsLi1MIdgJvYWFhYWFhYWFhcQrBTuAtLCwsLCwsLCwsTiHYCbyFhYWFhYWFhYXFKQQ7gbewsLCwsLCwsLA4hWAn8BYWFhYWFhYWFhanEOwE3sLCwmIFwHGco/r34x//+Gc6z7Zt23DrrbfiwIEDS3675pprsGXLlp/p+BYWFhYWQOREN8DCwsLC4tjj/vvvb/r///pf/ws/+tGPcOeddzatP/vss3+m82zbtg0f+tCHcM0112Dt2rU/07EsLCwsLJaHncBbWFhYrABcfvnlTf/v6uqC67pL1j8XxWIRqVTqWDbNwsLCwuJFwlJoLCwsLCwACMXl7rvvxpVXXolUKoXf+q3fAqAoOLfeeuuSfdauXYu3vvWtAIDbbrsNb3rTmwAA1157bUjLue2225r2efjhh3HVVVchlUph/fr1+Iu/+Av4vn8sL83CwsLitIKdwFtYWFhYhBgdHcWv//qv46abbsJ3v/tdvPOd7zzqfV/72tfiIx/5CADg7/7u73D//ffj/vvvx2tf+9pwm7GxMfy3//bf8Ou//uv49re/jde85jW45ZZb8IUvfOElvxYLCwuL0xWWQmNhYWFhEWJmZgZf/epX8cpXvvJF79vV1YVNmzYBUFz65eg509PT+O53v4tLL70UAHD99dfjxz/+Mb74xS/iN37jN362xltYWFisEFgPvIWFhYVFiLa2tp9q8n606O3tDSfvBueeey4OHjx4zM5pYWFhcbrBTuAtLCwsLEL09fUd0+N3dHQsWRePx1EqlY7peS0sLCxOJ9gJvIWFhYVFCMdxll0fj8dRqVSWrJ+enj7WTbKwsLCweA7sBN7CwsLC4ohYu3YtnnrqqaZ1d955JwqFQtO6eDwOANajbmFhYXEMYZNYLSwsLCyOiLe85S34kz/5E3zwgx/E1VdfjW3btuHTn/40stls03am0upnPvMZZDIZJBIJrFu3blnqjIWFhYXFTwfrgbewsLCwOCL+8A//EH/4h3+I2267Da9//evx9a9/Hf/+7/+OXC7XtN26devwyU9+Ek8++SSuueYaXHLJJfjOd75zYhptYWFhcZrCCYIgONGNsLCwsLCwsLCwsLA4OlgPvIWFhYWFhYWFhcUpBDuBt7CwsLCwsLCwsDiFYCfwFhYWFhYWFhYWFqcQ7ATewsLCwsLCwsLC4hSCncBbWFhYWFhYWFhYnEKwE3gLCwsLCwsLCwuLUwgropCT7/sYGRlBJpN53jLhFhYnEkEQYGFhAf39/XBd+119LGDtgMXJDmsHji2sDbA4FXC0dmBFTOBHRkYwODh4opthYXFEDA8PY2Bg4EQ347SEtQMWpwqsHTg2sDbA4lTCkezAipjAZzIZAMA1vW+Dl22XH/SHjTNXCFf53W3h8txmtR+o1lVyqh4uRwo1dZh6I1xXbUuEy6XOKAAgMSP78LESo+q8TqkivzfkWOEuyWS47JRKaiEaC9dNvqw7XI7N+wCA7FMT4bp6V2u4PHtGCgDgVaUdbU/OyPGr+vyBv6QdgHgsgrh0nUaral9kZFo2jcjv9W5Vat0t1+RIZbkn1Z602qVQDde5JVl2Jmd1Q6VkexBX99aPeeG6co/cp1pKPdzoolxHyy5q3/zCkmM2WuXZOQ19f8hJ447Nyvn1c3C6pDx8vS0l19Qqzyc8fkK1KaAP6vRB1QfqjQrufuaTYV+1eOlh7u1FN34AyZrqP7Ob5Dl1P7IQLntTerkqfZbHZmNajRkvK/0HHblwMYioh2zGBgA4DemL3kReLdTkmEGHOla9NS771GSfyJzqc42M/O4tiO0w/deldUGCTLz2ODoHRsJVpcs2hsuxWbVf5LCMk2Be7klgrp9smNuu7KXfzmNTxmQ9pe6z48s+9RZpU2rbqNqnUJRm0phETd9/uk/8HPz+TtWOw5NYgta0LDs06PTY9adlPDtJGvv6moKotNOpUT8wRoFtJPWT+iplE7y5suwxk5dtzf0jG1lb36P2rVdw70Mfs3bgGMHc1yte/keIROLhOzq7LR9uY+YD1bVd4bpIkd5dekz6NLY8eveZOYQ7XwrXNejdMLNFtSE5Jf3YrVJfclX/iuXlHTh5gdq/Lt0UCXlto/Mx1X6fxh6PuVJvaul5KALhR9Ryav+c/D4yJpu2tKjtemR+5C7I9aGi2upPUaN0P28aWym5D8VzVwEACv1yH7seojGp5ws+vZcbySiei+iYtDlIiD33E2rbRovsU9O2h6/TKYrtCbTNGLlWrrP1oDynUoe6v4U1cv7Ox+X31se1bW0sf5/DMU9j//Cr1fytZUz2adTKePzbf35EO7AiJvAmVBZxY/A8efmFE3hXBqdPv0eiuuPQCysSoQl8RD1MN6AXSkQ6WyQaXbJP07G8mj4/NTZYZgJPbXJc/ZA96ahejM+pfo+4dJ3UJrOtB24HHd/T5/eXmcBTRww8ernp4zed06WupX93PblQxxNDY+5ZhH53PTmX4+prpXYGnp7AUzvC5wUgiLp6HU2Amp59ZckxHbpPDvR+dM2uK/c8cBr6Opa/z3506QTeiS6dwJs+EG5jw7rHDKEdiCYQCVT/8eLynCIReRaeq1+eLj0PGpuOo/enPtHcP9VDbupTDk3gzVhx67SPXsf7BNx//SXHpGEUrndpHY/TcALv0DXTmIlEjJ2k63DoY8Ax108TeL0t280gwmN/6QQeNDE25wroPjhNdkQPFpdtKNlbfV4em7LvMscBAG1DfboPfE/MmG6ycQ3a34xRtpF8fP0cPE+u2eH2mXcA2ciAnqk6hbUDxwKhDYjEEYkk5B3d9I7VE0d+l3s8MW7o32Vi6FFfC/ukJ/3DWeYdHInSBD5YOoGPRKRPeXG1T0BdmqYAYfv9CPdZesfrce76zzOBj+pzemX6ncaE7r88zl13aZt5TEG/Q51ljsNt8mJkD5rmIq4+J9nDyNIJfMSVNgd0U3y9zPuYj3K+TsclJ4o+v7nfqp3yu6cdhi4NV/49tJ3B80zgzZgn22LOxXMV2fWF7cCKmMAb1NZ0wS3JoKh2qa/BCHnJqlnpANUWdfOCiNzEBDlx3ZL2wFfkxZ8oSMeILKiv1npaOlBhQJYXBpWnpi4fpei7cwoA4OQlKuBUmyd5ADC/tVOOs07WTw+qbb2qeA/qKbnm9m2L6nfyDiycIV+b6f3a48YdR79w5s8QT35+A7/Q1J+2nRLqyT4uEQBvVn3hOhSpmLlMogbJCd1m9qI1vRB1N12UNtd6VVuGr5eRFN+al+v4kvo9OSpf135WbnTQob60A/poiByUNiOhBmJ1UO4NWnrDxdiBpR4/fs4La9Ryx1OLcvz9armRlf7WaFH9rVFfLuJhcSzgRx2U06pPZQ5Jnxy/TLwduX3qGaW2U58okdGP60leRSa4Dv2OeTV+vUPyEi1ce6YsX6T6X8+D8+E6d0x5r6IUfap3SZtKa3IAgPgUeb7INngHtFepVfapZcULXepUfS27KLaj1C4TE6+sX270UeOkW2TZ2IRlxiZ7+stdMiZTB9X1OdPi8SpdKe6r/BXKZiSmZYIeXZDrX1irxmz2WfHM1TqpTXrcNLFEzccCe83jcTwXAUc7yQuHcbU+2LQ6XDVziUTafH3LOh+SlwE/+8jwlF5Y+vEEAP6CjrzGaLIR05MVy3s/Log9shsRJ4a48Q6Tlxi6/8d2HApX+avkfXrg59U7oX2H2Ox0Q/qHN6Kef3VTn6xblL6YmlT9a7Fbxl6xT5YH71DvCY4udz6hxvzUufLuKMswRqAdXhyFjuXlnEHo1Rd75U2I7alsUAcLyMPtUF8Miur87gJNlpNkJ7TH2aWItJk3LF4g8wKHvuNNJKPn9sOyyxRFMmrKJjgJGbtRskfFrcqD79H8bexlOTm+fjx9X90VritdrSKO7NV3yHZVutXxoxJ4RHKsTMvqb8+PZX7WxJowdoDHPkUCA3NPo/Jsc/vU/l6JPhTq5LB4AVhrYWFhYWFhYWFhYXEKwU7gLSwsLCwsLCwsLE4hrCgKTXRsDm5CwhmJ3eNqgagd9bP7w+X8NSpslLtbQjTJ/RLKxZwKQQUc7qgRRz6vkzuJdxYfp/D1gAp1F7spmalLtc+hpBe3StxbzWubWychmBg1KTVi+JuyDydyRiZ1bIja1PqYJKsgTJJdyjXLEFcNASWj9KjvwFoL0W7mJDwXJrFQYkfrHglZ1wxtidoUMF1Bh+X8jIS9orOqnZkDsm7ey4XL/Tvyat99w3KcDCW1mbAc0x5aiMuk+0TsUF7WEd0GKfVsAwqF5TdISLGoo6fxOek7WU1b8oaFfmP2dnyhDVgcWwSucD65zy6ukm06ntHjZ5ESnMoSfnaziqLFFJqA+o+j6V78e3qfjIn4rOoX7jTFaquqDwQ56afVNulT0TndR5huRRQaE+ZurJPQvR+VPhtb0NzdtIyZcodcf267Pj6N09rGPtpWtSV1SO5JI6UpNDQ2ovOU8LeoxxdRSLKPjIbL+cvV8f045b+MyphMD2kaI3GQq62UBKuTwPn4M6/ZpP6eJevSYgbQc58ymG5B6G38bA1FiOkCbU9K7L/andLXJvv4eaEIuYbCFDDvX+ypaxL5WsQ2RDUtymlQOyyOGZyebpXrYJK0+T1g6HEdQp8srBf6aEpPG8o56bPJlPRJt11tW2mXZ17vJ7qJ7hbpMZkrLKyj/XXyZlMyuabC9f1I+izD5J207JB9KgO5cDkxrq6PE9yNvQGA6Izpf5S3wXQYYweLQt+rrBNBELei+rR5LwPA7Lnq/hW7ZRz2302UQU01arJhREdxNF+9aWzSHCG1V1EOi5uJvkSbpnSScH2DGPZoQa1ziySSQQnyye3KNiXuzcvvOUmqD5N4aZ4X0Nh39LygulnsZnRKnpmhEjaIkjW31tNtExvXqB4dpdZ64C0sLCwsLCwsLCxOIdgJvIWFhYWFhYWFhcUphBVFoQliMdRzEuaO6LBZQGHy0StInvGA+psZkhDP4pkSrolPq1Apq6s4FN525vRxSUvZmcqHy6kJFQIi4oZQO2IsxySoa/UUzubuflTCfybb3U94WA5GvSU6NCUrlzlXjTRwZ85SLYwtykkzByRUVupUv3c8TBI9WQk5hmEvVpcbEnWP6rk6S53UL1ij2dOhvPlNpBLyoAp1df+XhORSF0qobGGTOn82n5OTsuaeCduRpN3imUJvMlKP6V3SDj8l7SusU21JTErMbnYrZZEX1QFYrSdw1XXknpRm4JCKxwaBpdAcL7TuLSCWV33VaHYDQIVsQ7FPPev4MxTKpPBudbOi2rFCVWyM6DBdKrzMtgGLMk5jRd1vWP3EhF97pZ/PnCH9MzOspSm7SZWhV1QZonOq/y4OEOVvQvpnNK/Ov7hWjt97n7S5rqlsUxfIOKrJ4dH9uNrfm6IweFK1xalI//XbhAJU68+pc4/TvSFaUWa/un6X1Lv8Frm+mq6n4DJFoUZh/qoOZbNajqYBRBfk2cTn5DmWBrUOdyBhbneeqAnaTvikbuEOCc0wMaXaFBAFxyV969CO8bNnVa+csk1+mo6v7YBrqXTHB66j/pkaK9QnDT1i/nx5Bxa7xY5n96l3R3SBtP9Ja7x0lqJZzK+RfTqflm3jY6rfuLMyjjY+RRLNc2qsBETBMopFVaLFNGJy/Pi4Gkd+SsZOvUXed8ZORQ7Re5/rORg6C9NIWYVGz5WcmFxnYte4/G4opaRik5xU19x+r1BGG4ekBgU0RSnoFRvsLpJiy7y6Py6pagXtMq8wrS/0iW2IFWica8123yMa6xN63kG0nEYvUYHGVFsDourwNbuGNhcntR6iWhllnqmtQlPsfphkJjU9yqXaP/136jkbHbPeIErXC8B64C0sLCwsLCwsLCxOIawoDzxcSpgEsDigPE2RCiVPcpVMLQPLXrZqWjYotesk1Yp8yZbbWHNdfQ3H9tDXPXtijEePNUPNVzElmNT75AuxuEqdk3VKXarW6GktaY+SyvycfMFOXZIDALRBvM1eSRIyXFPoYlY8g4m8+posdlEhpkHSep7QBRsWORFMrrPRrs7vVuU8DnmvEuNqefR1orvc9QSJ3I7l1XZU0bbeq66DK8/V0rI8eaFZJxq0UYogZJ/QX9rTUjmukqOqrm2q/elnqc0luaaUTrSb2yhf9z33SZPTh9S9WKTkpfDZc1EQnVjr+BWAiuBZHDu4YzMI9JiPUDJSav3acLnYpZ5V4+c2hevan5AHZCJdDntqFsibrhPhKlRHoEGJmnFd9dRjrXKdPGoqPANAbo/0lemzlZ0orhGPTvd9lNCpbYdJVgWA2B5KUNfnIqc6nFFKqNZetFi3eODTVB0w1MUmb3foAuIE32FK2tLeqUa77FNpE3tmxj5HLusZstG9OjlvlHS0d4kX0dR2qHXJ8bM7lOeu7UFKQG5pLpQEiIgAALh1ihpoO0J1t5AeIRutr9XJUpVEqp7lZ1Vb2MMatFKEQEdf3IJEMYM+rcPdqABUzNLiGKFYAlwfgX5WDnk/oasCZ+85EK5q5XoPnNyp4daoxoijxn7vA+JFjQ5LdLq6Rj3r2BxFhDkSZ87D3nBtZ2KH55asY3A/56qrlZzqv1HyNjtP7ZRlba9Y+70pqmXaQlHygJbDopglGafJZ1RHDsrLe5NN0r1TonuXkfcpdHSvQhFJh6IG+Q3qWll8oP8eOf/o5bqWS0auqXW7ug9cWbncSxFLXx2sqbIzeeANg4PtFbvB82cqO1J6hejEH+wR29K+TSf7Frj4py6CFZX5Rb3mAY/hiLAeeAsLCwsLCwsLC4tTCHYCb2FhYWFhYWFhYXEK4ZhSaD760Y/iG9/4Bnbs2IFkMokrr7wSf/mXf4kzzjgj3CYIAnzoQx/CZz7zGczOzuKyyy7D3/3d3+Gcc84Jt6lUKnjf+96HL33pSyiVSrjuuuvw93//9xgYGFjutM8Lp1BEhEoaG8rE2KVyG+pp0vstqpDG+MXye4RynVoPqjBK7jEJt3ASSZhgtUyoCwBgdMkjFEqbml2yWWRYwi2tUyps1EoUmdJaCdNHtLZwQCHBsatzS45ZIApM2+OUfKr12x3Sgs7mVTgoy9dBNBC/Q+mk+u0SKnKnKNSnyzyb0DGAJl1kU744oN642E+a71mVTBSbFVqR0cf2KExYzVAikKueY6Qsz7P1GYlNBwl1fg6HthyW46fG9LEoyZXpEq4ud58eXj5ZGHr37DYJo+e3qPtUayP9Zx0SDBoxQCpKnzY42WwAAJXArLlywYKEOnPbhZcWnK3CtnMbpU+VunLhsqOH5KrbKSmMxoyhZsUpgb16lrS1nlL9z6My4fBVX3DnJeRc3CpjqusJZbtmSzJ2GhTFTh7Mq/P0UaIXJX35CT1mJsjGcAl5TeVre0iS08rrZHwE7TkAgDNHSfn6+nyixDlECXR0MroX5MJ1tdUSMq+ltWY2aWovrJEmte5X9yS5j3glpEXt6pB/jDTbjb3lEH+tXc4ZO6TalBwW28D1HMIaF8R2NAnGAABT94PoV3DJNmjqTKOb6FOUhBs+vUNynzHYq8/JJz19cNLZgUgEcCNC+yQ7b7S+uQ4A237TV1jU4OBrZJzmdus+e0hsP9sGo5Ve3ihJsoltZPypf4cw1BbWq+fEW2078pf1hquSE5Q4O6v6aqWH6CJxmqu0qXfTclQvAPA7c6oZtM4h/fZQqKOF6HWG7kLX7jItR88hgpm8rCNaUdCtbE98L40TSpbvXOgGAHQ8KWOGE+zXjCvbxhQco5fP4zl1gOYqRgefqUQNpvep0ZvYR3Mmog8mu9Rx/e/KdbYOkdDFJnXPa0npb+kRdR/LtC7wj84OHFMP/F133YV3vetdeOCBB3DHHXegXq/jhhtuwOKiGPuPfexj+PjHP45Pf/rTePjhh9Hb24tXvepVWFiQl8R73vMe/N//+3/x5S9/Gffccw8KhQJe97rXoUGqEBYWFicfrA2wsLCwdsDC4qXHMfXAf//732/6/+c+9zl0d3fj0UcfxSte8QoEQYBPfvKT+MAHPoA3vvGNAIDPf/7z6OnpwRe/+EW84x3vwNzcHD772c/iX//1X3H99dcDAL7whS9gcHAQP/jBD3DjjTcey0uwsLD4GWBtgIWFhbUDFhYvPY6rCs3cnApVtLerTOj9+/djbGwMN9xwQ7hNPB7H1Vdfjfvuuw/veMc78Oijj6JWqzVt09/fjy1btuC+++5bdtBWKhVUKLw0r/VED//8IAYeJDWDMRWOqWaIrkHJ4LknVXi8TgoKM2dL6KUR09nDrBc8QiF1E6LibHLSBq6sVffBlDEGAEdrovpJCW95c9Qore7CWsmsR2vC5wGFYn2KDrftUaE0n5R1mkoZ6+WAVHBczjY3II+HCRnXB0Q5xqFQXElneafnKDRIWeCBbkrbTlkXlo0H4Okwp0MqNqGeLYXruyfkObSM6vvgyXU6C8R/0tcUUIZ5fAeFMfX9CyicySWVnZg6bzUn5/eqEpJPjGp1jb1D4br22Zw+EdEmdJjRaawM/efjZQOA57cDQeBjueAjj93oGtV/c7tlO4/UpiJlFVYtbBKaRGY7UcxKqt8E1M9ju0bDZb9Pj3MKw1c7dL2FSRnv7dtkObJH9c/U9qWKKqoxatso0UH4+GGZdC5NzvrlhhpC9Lh6Sq4/ltAKDvNEVeMwullHtiGkKBHtJjsrIevGmh71NyEUBKchx3fN4alWR0A0gsZatX9kkuhPZkzT2GfNa0OXcGZpH00RYCSGKbTOIXVDOyIaINMegjYVsg8idO+2Dy85flAnhatxFZJ3VogO/ImeCxTO6UYkmgjfg63PCiXCqahOV1ovii3RBVIc0n2J6y04FAAwtE0nX1iyDwAEui/NnC1js7vYI/sf1u8UotfV27RaTkA0VaqdYGpH1OnVMreejn/f9JJ2OB1yfUbVzSMluSZFm0lNu6OaMQHNUcwcwolK/w3MfSd74DAVTb9jmSyibLPG6IReR23OCSXQKapzuVNEjWXbpi857ohMTXGt2r9Bii+t24ieZ2wLUX2CmNjD0CYQ9bJyjqjnza9Wzy63W+5D7NG94XLPpKo9Udgg15HQdQEMnRAAAqp18UI4bkmsQRDg5ptvxstf/nJs2bIFADA2piTOenp6mrbt6ekJfxsbG0MsFkNbW9vzbvNcfPSjH0U2mw3/DQ4OvtSXY2Fh8SJxPG0AYO2AhcXJCDsXsLB4aXDcPPDvfve78dRTT+Gee+5Z8pvznMSdIAiWrHsuXmibW265BTfffHP4//n5eQwODqL7sRKKg/KVU0+q75fue0jzk5NE9JdfdEK+0LqfIo/TGlWN0VT2A4BUnr4wNUz1UwAo9slXbSOu2p8kT43xRpe65NEkJ8njpn+PFOWrlvWll9Mwdsk7MH2W/kLcQyvJExSehrxLRseVk9OaqrdqDWST2AkAC2eIkZ0fVO1LTMpXrUfXvLBanav7AUmuc+aXRh3qPeIBL56jPJipEXlekVF5TslxXcGxSB4t9sLppBujww4AaKXlRe1R43tDUQmnpK65nli+RkDqcdUWnxPd5vVX+6Ccp6GjP/V6GdiH0xrH0wYAz28HUKuFHlWHkzjJ6xJ6nqnLtO4Uj+zc2Trpi528MUre1NGaYJKSnTrE293QSayROem/B96g9u95QPp5alT6XIT7qgHbKwNKjnS0jQIAx3jC+JqpT4fjnDxzM2dRhKmi7k9yniJp2tvsko0MKNHMRPIc8iZyVMKbUuMwnRJ7k3tWrskkuM9es1b2pxoThVVquWObHD8+o85ZS0vbE6PLeEPT8jyqXbScVfvFJ+h5cgK+tnelDZLgW+qiCpW6XkV8kp4N3XNT/detkmfykK4QeZomsTJOhrlAbK6GSMSDb7yrXE1dJ1VGs9InRl4uy6426d2PyfNdJYXFBZygTuOspO1/6wF5NxR7Zdvy2eojoyzDEB3bdJ+aosRSisJPnquXyV4tbOJ6EfrnBEXkqA6B0VevZ8nrXqbK4mbM0NibuVj6f/vjej0nuRpxDur7i5soqjGvK9o+cyBc1+RBN9FpmncE5MEPdHSxaV4SyDMxkUB3Kh+ui3QqexKn2jdNyeg6+ljcIO1sJOW9bqpARxZlTje/Tu6pqYkTp6rcDjMY8mp9ZhtV8dXRlfR+YQicVJVY/+AP/gDf/va38aMf/agpW7y3V2VMP/freWJiIvwS7+3tRbVaxezs7PNu81zE43G0trY2/bOwsDhxON42ALB2wMLiZIOdC1hYvHQ4phP4IAjw7ne/G9/4xjdw5513Yt26dU2/r1u3Dr29vbjjjjvCddVqFXfddReuvPJKAMBFF12EaDTatM3o6CieeeaZcBsLC4uTE9YGWFhYWDtgYfHS45hSaN71rnfhi1/8Ir71rW8hk8mEX9fZbBbJZBKO4+A973kPPvKRj2DTpk3YtGkTPvKRjyCVSuGmm24Kt33729+O9773vejo6EB7ezve9773YevWrWEm+tHCLdex2CMJCZ1P6JBFgegaHPbSNAtO1OLwr6GMRCiJtCmhVSefhsljADL7KJSr4RDNw9HJWikOCxGNI9A0DId0a+sbJUlj4kIVrmnbLRya9u1y/PnVWguakySoDHhTkomBocuQtryfpjC8LitcJYrA4VfS8RPq/kTK8nu0KOdZWKv+toyLdyS9jcLwOszpx6WdJmHU6LICgLcgxzQ62/Ex8dYEc6IR62TVuUobJfHWq5BebVWFtSIU/quszoXLvqYAte5bWgJbnUCFFF0uu62PNbtV6EWlTrVdo+ICDy5/qFMZJ5sNAIBg02o482pMBXmhxfgUMl8YUM+l0i79uJ6Q55Y+rPp0sZdoFpQUaTSaHU76onoPjYRarrQR/W7Y0HakH5Z6pH8XBpSXkilxbT8+IMfX+3GyNdPGql0qdO/3yzkTh2lMLKq21nooYY9Qa1HtS1KYu7YqBwCI0bVzDYmwBDvbVab9FEwCV3e4amG1tN8IBSzcKHazPixUp+5H1PVNE9WnoZNtY/Q44n3y7OpJnTxH9zEzLDY8fUCdq5GmNlMysK+fXZGezWIfJd421O9lqouRbqFy7Jra4xFFIX5AL/unpxziyWYHIoUqIp4j+v9ci0WPH7csfWLgv/Lh8uSlOQBANSvPNL1DqHJVPX6KZ9C7hSivpU51rtwuobBwXZbVv7kHADDxCfnIieX1XGNKOnWDxDU6nlW/lztkHFQ6SFNdX2dxFb2DW6V/x6bVeyxwqHZCTn53q2r8OGOS6J+ckWsydRaq62XsthxYaDo30EwBCq/FET+ykySKjLFnRB3kxPBQ1IITzHneZLT7KSnf09SZSF7e240OOb6nhTb4PjJNtvORvDrltLw3OqdIZ15fq7NA84JgmYTUCtEIjbgHXZvbWEprXg7HdAL/D//wDwCAa665pmn95z73Obz1rW8FALz//e9HqVTCO9/5zrB4w+23345MRm7KJz7xCUQiEbz5zW8Oizfcdttt8OjBWFhYnHywNsDCwsLaAQuLlx7HdAIfLPfl8Rw4joNbb70Vt9566/Nuk0gk8KlPfQqf+tSnXsLWWVhYHGtYG2BhYWHtgIXFS4/jqgN/ouFW6kiPUra5DrGUzhGlhvgUlenWesWsiW5KFgMItX+rbRIqK3dKCKr1KRUqjgyTNjyHj7WmacA6pv4yYSPSKHbM+ek4kRnJXs7tUSGozG7SWm6RNuV2N5qPA6CyQdofG1fhYxNuB4DIorp+75Bch0th9OpaVRK6lhEvSHqfLC+ep8JFbl1CjoY6AgCtWn0lOUbqFk2V9dSxopMSRo+NqfZzSI218/O6ZHHXjHhvXMo2N+Wyx66Qe9PxtJwzWlDHrbYLBaaSlWuKlNRzSj42IsckrWpf0whcXX4eAGYuVTQBn+SjO55V97Fep+x7i2OKYl8Kju6rbjvRRSgS275T9YW5dfLMpy+U/pGmkgEG9UEZR5EhrWzlyUEXN+XCZaMp7xKVrf9e1X88VnmhiY+hrc2vlzB4aYvQ55I7tfoM2Ss/KSHtw9eoMZEgYZwItbmqGWzcP/vvFttiKAWVzX1y/m618eIq0ULO7hBajlvQ/ZrtHtVeCFLqpDy2yu1iGyqa+bLqn2ScJg6K5IcZUx6Jg/Xfo9rM96naSvZmSNmBYpecc/jVFGbXChPpQ9TkeXkObU8qe92xWxIu29tJn1pTK4O4vF5rHUJ3iE9ptZ8aURDOUsoj9XoZuB8WxxqOAzgOFgdUH0kkSG2prPqHU6G5AtUg6X5APf9FoouAaGPz69Q4LQxIn+t4lmgY9yvbwKpVXlXeXfu/vBEA0EJSchFNcTG0XgDwiPYT05saTXHV6Fy4WO5X7/P8Rjnn4oDsv/4bZl4gu0eKVKdA68D7q7rCdbN0rJYxrepFr22zDysEuUzR1XMI1n5nRRkno8aUnyZaMlFX/O6cbpO8o73hpfQ9rk8TmVX3p5GRY1bbhL6U1HOp9h+Idntjba+cv6xtq0/nYeUd/TegNjts+/QcJCgRlVrX1XCIbuscJYXmuOnAW1hYWFhYWFhYWFj87FhRHnin1kAsL66a/Jnqq5S/GpN76AtWJx069IUYNH1N6epjlKQ6v15uaWaX8jQ5XEWQtcSNzilVFws1U5fRoweAhYuV9JbROgaAmXMoeVMvZp+RLzhmB47cqFxa7bvkovPrZYuWMdXmaka+7boe1h5B0nfmxJH5dcp70DIi97aTvNmlvrg+puyemJZrSk3pr3/yctRWSdKZub9+VM4ZnVVtYt1arrqanFbPrJ6T32Nl0vnOqDatu40qJFJUoXT+GnVM+sRtu1uqqtZXa09EkwYtVYwzScaUAG28rg6Jhzf0NTXst/RxQ3KshOiC7p8cXSNPUUInTntl8RZf+Oad4fJdzln6YPJ8J14uXuLV31bj1KXqvOxlzu1Sdsalyocm8cnPUdSIvDvepPJsZ+tkjygCZZLBuHqwt0dCBWu/qaT2Dr0qF66bO1+uv+1h1f7ZM2Qc7u0RL3bLsLo/mUOU7K0jCCXyZk9fIJ7JakbtE1uQ+zB7tjQ5t1393vWwJJun28WeFQbUOI1Tsi0LBSTy6jlGSvLsFtaq37lyLieZRguqre1Pizez2EVVEPXQ7b4vH65zuJqkeSYkaAB+JjPa80gJeR4l/ZvaFA7VzahoHfp6nSOPFscKTqkGx3PDmgI+VduM5tW79/D18g5q3yljIvWECs1EO+V9Mn2FyFjWWnRtgmflWXJF47mtyiNsxgYALKyR5VV3qf7lUp9ytHgF11jwW6VPjV+qbQbJ4bN4hXmHJqfIaz9Hka52NfZ5fhQ7nJdr2qC80N6iHLPvHhmTBV25uthNCavnKBuYOECVTgnGMx6ZJm80a7Lr97FLVU/5fevmlQ3lirGsOV8dVFrus5tlnYmE+DF5Hsm9EpL0dV0Wl8ZhpU2iI5GkTpCnd0UwQQwLDactJ/+h+iLhO4YrvJscD9bA948uIm9nDRYWFhYWFhYWFhanEOwE3sLCwsLCwsLCwuIUwoqi0CAIEClQWMlXoZFYgcKfCUqw0qHaWk6SGKJU+hxa571lh4RQPKp/7JuyxatF49ijcJEJBXMYPAyvUiiJk52ii2q5sFrCQvPriLrha93kM6UdrPmeHlHLLXskZJ0aIs1THZZrLUkobXaLConXtf4t0Jx8l5pQbWokSXeWQnlt29Tf2ILc5+SEPIdaRp3fHZc2uXOkwazpOjOXU5jyTNXOBm2W3Sf3LKJ1d8sd8jxjVOQvNqzDehTKCuieh2E1ShpiakJEJ7E0KKnHYz1aE15PCQVhsc/VbaPNVqn2Nao2dH684PgBYGoC8DNrkWcV0eOc6XGPfm1LuJzVZsCrkrY79cVFnefpE38tUpJjFft0svkOSljVmvF+Svqsu0j2RteDYHvQSFIinE5qa9KB57oVh1XyXPfjcp0TENpPi07w73haxubw9bJtakq1P7NfbFi5V/3OVDO+zsIqZQiqOTEI9VYZZ/kzVJvThyVpPjEuNMZEi7q+WjdpNZNtqqbVidke5TerdWv/Xexy9gmqpZHU1zwsBmHAFyGD8JkPjcq6rNCaDMXJpfocDiW1QVf79Dtkn/wZEkYvad3p1KS0uXWf6gdOnWg5FscMzkIBjltDYlY9o6ktMnhTXbrPSZdDbJboTjqJe34t1XhwiVKhx3zmMcp0p+TN4rocAGBhQMb5um9QdVk9vktrZBxHcqox069aQ+eUXaKLS1V+4mP07tI1XDIHpJ+OX8pUNHWwSodcUzUn7zZDT03nxV5V+shehvRQOb+nk4CDlNxbZ1zoKhFDLSY6StOyoZSk5Tw+iw745tpo3tEi55o5S80RKsKECmmubNcZ7qRKkjUJsgAwvUWeU9tudZ9iozTnIqqcQZ0oefV0dMnv8Wl63oauQ/YEfhVHA+uBt7CwsLCwsLCwsDiFYCfwFhYWFhYWFhYWFqcQVhSFppFNwiWlkIaOFnGYm2FC1dWc3KYgQmEnTaHxRyQUmyDdZ1Mud+4S0U12BigkfViFo1wKiYfKBFz4gpZN+e3kJGnMPiPty2/Wp85KO+LzEjYzygwlKlfOGL9EhXsiRaHoZPepc7IKTHJK2pw6oMJODpWe9ikzvKJD+umDEhrnrH+jeJNiLeVRCX/7JXWfMgfkd6M0MbdR2h6bl2O2HtD66knSiady6O60oiYErDfPmttZ/Zzo2bLWr2NCovS4i+cPhMuRRRUOc0lLuPNJdR2xA5PhutKZip5Vrx9dyMziZ0dhTRrZuHp+TEfxiT7n1PymvwAw+DUKiWtlqkZXLlxV6hfbMHaZGpMePdaWwzJmQxWpAvGpNCIsasB2wNX9m6gd0VaK85tdiArklJZqyieeEYHzgQmh2jUyanwEZMNcYnS0P6B05oMovzbUuVITcp9i8xIKzuxXB/AWpB3DrxVd5rpmlgRRpiDIOHar6rjeIqk5zQg1IDemQtG11XLMzqdUGN2ZIwpBWahIjTOUZn2E1CGcibxs26bC9A4pWvBzcrVCWGWraN83EtLm1LPqPrlTolmNQEL/OW1PDc0PoFoeDVsP4nggKJURuD7iQ3m1YovQM+tJ1RfXfCsfriv3SV/xtE3ofERoEKwoFCJOnLoFqqdQV+/DxCzRMOZIaUX3tRTtg7gam6ysxGPT0NrcMVJ8IYWtynlr9f7S53oeIiUUfVijYQ8As2fImGzfrjZg7XueD0TK6p7MXEBqPeOqzTSKEF0kRRZD7+PaOkxFM7Q1ojk6ZTl+Wc9hai3ye3qvjPneH6l6ETWqaeNqqqpDtTbq3TKv8HTdCodVpZgGacZsXhR4mHoZaGpMZC/1h41Sq8Mxcwied2jaUEAqNEFgKTQWFhYWFhYWFhYWpx1WlAd+8oI0uvZSVTD9MbcwSDroQ/LV7Gmd0cy9++QgUUpIMFVTY+LZ5Qpfjk6oSI3Jl5XRWwWAQH/B0jcnoCt4uZxcNyuenKhOeIjS74mH5au7/ktKn7pllDxWVTmD0VX2auRNHxXvUs/Duu2U5JHcpSvHzctXJ1dMC7Vp6UvUpS/p1Jj66p7f0ELrpH0mQlDPyb2LTpIXTh/XmWfvlE4Ajko7258WL4ajox9+RDxfE5fnwuXOx3WkYb986QaghL9p9SXvn7luyTEBSVB2ySPASUWL/doLSN6F3H3a80lf2slH9wMA6keZtGLxs6N1+wx2/0H/kvWdj4ptyAyp5xEpkpuLPc+VpZ7Swir5ve0CNWbmHqZEMMrPMnUM+DgmiZo1x4MO8Xg5Be1F5mSnRfKwa49VU0IlJ1iZehaUrF2nKoSxUTW+A7It7TvEXhmta6O9DgCFPnXNXQ/mw3VcLdFUXT1wk9zv0kYSEphT+/O9cakehFvVtTQ4EuEtDZnWMmKXPe0N9HslulDuFttUb1H7ZwpiG/ia3bx48cLfWQdeJyyW2+icZGNDO0kRu47/2iMHM9WZG02W//nXWbz06O0EvDiQV++MVf8hUS0jZMFR6miBEpa1d5Yjzly3xVR2j49T1IbGXGKXitBE53LhuqbaDwk9B+GxrW0PVzluSsTU4yPIibfZmZV+7OsIl0/vbdamjxZU/84ckOvwKjIXis+q9nN11pFXyJhKTKljDXyfxoluXoXGSSMh1UZj07qSfQe992ep7oVmOLC32iEd/Pik+j25Z2kUE0AoUBGl93bo9afk/ghFT4ymfBAVGzNwe15+17aHBS3AdX7Mc6Zk3LAqNyA69VR11VRtdSgR2vErAJnR54P1wFtYWFhYWFhYWFicQrATeAsLCwsLCwsLC4tTCCuKQlPNNFMaIkW17L5JklEqeyShITWis8k4mcnhJFUV7vE3DoarFldLWCl9QIXnai1ym0sdlPhRVOGYWEHCRo1WFbaqUTnxGCfXmTLeM3lZRyHljmcU7cckeQJAdpuE3dqH1bX6OaGzuHMSAqquU+sjZQrPGX3phNwHDiE5OsEGCUraIZpIaq+i+DjrRJA1ssA68MklbU5k14bLiz3q/PWEhJjSWrO67RkKp1OYnek48rssmlLKQZe0yamwDqtJNqGdRiUU5lR1CI7ufWpI2teik1wbA5JcF4bVqJ2BTjQ62qQVi58djUwcsVn1/BMU3UwflmewsEb16WpG+nTPg6wdrMY508ISM0J/KH5XUWe6Dkn4N70nHy6H4fcWSqTUyaOsm1zul9B6fErZAZfCv6xXbGpIgMqAI07h65xqc4N0k8culTHdf89S+gZTQ1KjmlZEIeHEqKKp1DrJXnHIe17Zo+5HpM2NZ+X8Xkkn5Q9LvDiILX0tmbLpABDM5uWHflVjIzEh9sjVCWqmzgYARMrSpoVBrYlNVCMWEjBJhAHrvMfoPq5RogQsFNB6kLbVtR9MMiwAgOgM5voc0vivrFb3sV4vA3thcYzhTOXhuDFAU0oabUI98XVtBSNEAKBZSGJBPTefxqlL9Ac/rvuFR+vaidqiKTgNqvcAWo4N6f43R3QZPddwia7brBuujhl0Cm2M5y2GQjO/RsYWi3e079b66CUZB5m9MuY8PReavHGttJMoHp2Pqf7tDY/L8XWNFKavFXvkOg1dptYiDUkMyThutGnqLL2D3Vmhybom8fx55h2BvmcOJauH94wpeUSBcUytDaYvZeTZ1QbUfMHrl6TnJiGCgrpn/maZEzqUOOxO6TbH5TkubFRzzsxumhc0lmrHLwfrgbewsLCwsLCwsLA4hWAn8BYWFhYWFhYWFhanEFYUhSa7zw8VCgAg+7QKUeXv7Q7XeRyC0aoOfquEorxJ0v/UqHTJ75ESqRFEl6olsH56mHFNkevoQRWeZl3jwgbJhm/Zr0JVboTKB1PIOb/Z6DJTSJfDRTqbfXFQwkrJuOzfulsdn3Vvy+tUWC5hNHPRnA1uQs0cZq7158JlT9NlYjNyb2ttEvaKzan9WT+adVgjWR0Kp+sodqnr96qyrtJFShNa/z05JmHqLIkJuVrLt9InYW4O5aUOqbBY070jJQFf9xOXdLibSthrag2Hz8w6VrQwy0FA21kcU1TaEuh8Sj1/o74AAIndEv6tZpV272KvhMFrrdJnjZKJw4IvE6SspEuTN+Kkb072wJQ252MajebIhNgYlygsZtvqoIRnuf0xraTiFEnlhbSkZ65UIe34vPTprielzXt+RSswJOScZ/wT6Vdr6gCrQniTeXWeBim6kD1yNJ0nMS7H4XEan1KhamdMSqyz/nrUqDzNL9DvQo0J9Ph0SdfZT6v7xBSF2HbRvu8ZVrZt9rLecF3bPcN0zGWUYEh9rK718n2KcsdH5ZkFGXX84lqhY7pEhTK1PJysXOfiKnXMRtWq0BwXRCKAGwk1xme2ih03Y7b3G7tle6bRatvvkHKR3y3UFaMVzv08eUBoukZdJlYgmsYyykpN0FS7oEXshZMXOkmgqRsgGzNx5dJ6C7E5oqMQA6emFWli01QzhugqhjLbtkPoIlzLxdiBpuvQ1BeHXqGmlgSAcExn5mSc8DveKLw5pEqFBdLLN/rpBbEtDimFOa3quI120vCf08+MKE9NdTOMvjvNr1gpLLpPtd/vIxUZUh50q2oOUOyXY7YMSZtr6xX1ppoV41HJ6bkK0X7rdZLlegFYD7yFhYWFhYWFhYXFKYQV5YH3agHK3fIlnVpUX1YDP5IvJG9aliuDKmEhOiNfykFeMjdM8mjygKzz+Qu5ZrxPpBVOX6jmd3dSvs5NxUCnLl944I8xkxhD3uBGm3xhxha0pjpVIGXPn6kYF1uQ/QuDck9yj6ov0CR5wGtt+sswvzT6oNqsv1DJ8+bTOaNGV5m14+nrffKClG6zHLPrSfEitupkGpc8i4evVx6PcrvcnNYD4hlc1PrU8bycJzYn+5tEvuicfF0nnhAt4DBxhbW/yQvjmcQZuiauGNfQlVyDCOlLT6nzO5QUY5ZdvwIMweI4IPXkECKefn6UTMRofVT1hZZDElWpZWTb2JzyXCfHKGpEniLjhR6+Xp51hyde2EhRja/kHiq7qj1JQY+M/fwmStDSXb3zUfFGe0NSKTjQidUORYXqg+KFM573zG6yYWNy/vUlVUl49gwZiOUeqhw9o2xjk8crrEi8fGVnhL/LOCh3yJhpJFVbUxBvuLtIGvvG3nFdDIqSOqaaJeu468Rw9sovtz9HV+JbRac+OaTsXCgYAKmwCADxvcoL1ztCSf1cLVLbZp+SGB1XPIumFkfbk1K/I5nUifp10qy2OHYIAvVPR42z+0h/3ER9uOZLbWnCKCg5srSak1T1s+acd9b310noTUmqWfJCt2hdcFMvAECjU/2+QEnz8VnZx+izz22UsZuiaH/6h8pONKjqaCMh49BcszdGcxGqZGzGeTUnNjC1W6Jm4Zike1bVEQiu8dCUYG9EHWhOFZCefijwQO9Yl++TeR9PUjuWqdXB9mT+bDVvMPZXLcuzjY5rBsRWqf8SG5ZxGuhzMQPCp2rcvrb76d0UcSFN+Ki2obVWSYINIyEc7eflF4D1wFtYWFhYWFhYWFicQrATeAsLCwsLCwsLC4tTCCuKQpN+dBi18zeE/y+vUuGYxBAJmpI2cJio1pAwdlRyncKwrEOa6B4tm/LI7iSFiNolBOToJJaAEjNMAldkRMJCmWEKv5mQP+0TIVpOxpRbpxCMn5T2BzphNTZCYfiShMnnLlAJvdmHDofroprq4/dKON4tk275sL5munfxIQk7UUPlnBTerqXV+T2JniGxT66/0anuY52SvrqeUGGxUs/yeqmB/jStZaSLs/Z8oBPcvCkqNz1PGrNabzdISsiQqS+1PkUZMEktAIBZec4mGbq6QUJl5tnzdRjU62VLoTle8DwEOgnboQSmpgQsHTLn/uGUiVoyoPrCwmoZWzPnyO7tz6i/CRoGHiW4z69R/S9wZUyltmstZwq5dj0ifarUr8LnHmuis1b5MolwblEoGS2HtE3YJ0bMpzEb2zcBAOjZQWObdaeN7eHkPWOHgq5w3dQFRDtKqz7fepB12GX/5KRqU4rtKlH1nMRSqlNQoUQ2nQjXlECuQ+5Me3GyQl8qb1Jjkil3jMX16lgte2h/oiVV9P4+0eOS+yjMrut2tAzLc2J7vNin7snUJZL4WFitnnmj7AM/XLZZFi8lGg0gaGD+AkXdCsiVmdm7lA4S0DvU0e8JrtcwdY68Z9p2qX7VSFD/oPcIJnUSLOuX8/s6rd4PLtWsMfrqGVfeJyz0YOh7nfdT4uk40fM0VaiRkD4Xm6BxNKn7b4vYOKdXxrShgh5+hdyTjQeIEqvtANug+GFlrxY3S62VoTetCpdXf0W98JiSx5RUV9vmgIVFuP6MWXi+BGC9f71NbLzRw69lZB+XdObNO76a5akx3TMj1EHPa2G92Ib51eo+9TxKtXvoOUUn1H1OPSYv+/oVawAAkTmaADWIRvgCOKYe+Lvvvhuvf/3r0d/fD8dx8M1vfrPp9yAIcOutt6K/vx/JZBLXXHMNnn322aZtKpUK/uAP/gCdnZ1oaWnBG97wBhw6dAgWFhanBqwdsLCwsHbAwuKlxTH1wC8uLuK8887D2972NvzSL/3Skt8/9rGP4eMf/zhuu+02bN68GX/+53+OV73qVdi5cycyGeUxec973oPvfOc7+PKXv4yOjg68973vxete9zo8+uij8I4kvfQc1Fd3Ncm6+RG17HWRzFBRvorj0/oriPIJmrxc5iusqaoXVQTUX/Bckc+pUJKSTrion79RVu0dW3IcRqCrhjnskaKE0DAqQFX+nAR5kUl6KtwlKV+LLcbxXpV2mgiD0yrXwZXrvFWqMmGDEni9BZGbCtI6KYc9BiXx8hkvHCcSsRfO01/oHnlEGv3qqzizh7yF9DmaPmwSjCkphzxmQZv2gnNCXlPFXdU3nKp46fw0VXacV201ScdqF2qA7hP1NEUA5tXvHnlFTWKuc5Rf3KciTjY7EFQq8DeuX/oDJR0GWmbMLdOzOjQRLqf0OI4sypgodVCCvJaUTDxG0TfyLnkV1ZfKHSRP2JcDABTWSD9LD0n/So6ovlrvomRYSoQzYz/IiMdp8tJcuJzbo/pYlCul8r0zSWPs1afkuyCnvVMXi72KH9LXR1GBrvvkngUpZXumLpDIY3GVHDM9osfZPon4NaVvmUgJy8NRm42MJLylY48rVQZUuTpxQNvl9eJZc2ty1pSJHnLiq0tJ+VrUYGEDRVPXiJfRIFKQ+8DPtJ7U18wFc/UpT2MzcFLZgfKWQUQiCcTz6hnFJqT/GtnmNL+v5ui9aaqeUv+IUjHO5KTqs3MbxB7kt+TC5bZxHV0mD7zfIX2p3K36SmqUkjNJOtWAzz95pUp873iaZF8PLP2wiR2g0tPLRdfI69+UmK2rlHc+Lb83svQ+HFRJ4MEYVSvX84bJ8yXKWMuQFPQ5at6Q2in7BC2UGK7vM88VOEnVTy2NCLJ8Y1V72cs5seuxgjp/qZMSSxdkubJRMRCGXyXHTFGyevqQembRRekbo1dJ8wJXDerBb+XDdSxjWbpgLQAguV0EM1yd9Dx9kdiQRrUMNH+7LotjOoF/zWteg9e85jXL/hYEAT75yU/iAx/4AN74xjcCAD7/+c+jp6cHX/ziF/GOd7wDc3Nz+OxnP4t//dd/xfXXXw8A+MIXvoDBwUH84Ac/wI033ngsm29hYfESwNoBCwsLawcsLF5anLAk1v3792NsbAw33HBDuC4ej+Pqq6/GfffdBwB49NFHUavVmrbp7+/Hli1bwm0sji/OLh3CK+efxWBJvpqjfh0byuOI+PUX2NPCYimsHTg1cfX4U7hx5FHEffEyd9bn0VvLH7UEmoWFgbUDpx7aqwu4dvJJXD6zo2n9msYM0v5pHEo6iXDCkljHxhRVpKenp2l9T08PDh48GG4Ti8XQ1ta2ZBuz/3KoVCqoUPWs+XkVZl5Ym0LhbLnk7sfUhLPSIaGkBIWQTIIiJ05wFc0wdNMh7WMahqFsFNdIeKzlQSkHajRPPaKeBJ05dZxpCr1zkoepPkaV3zh5NNR8T0ho3h2WREtzLU5czmmS49QP6k/Ps9P4xfIzSAVV/G36FWrlxBR+vng/XlE/gE+nX4ehrEoAaulz8emf3IbyoSh+4ao/QdWLwksmkK0XsejFUdehSA65uQvyfLp+oqkJVG0xoOfnJHWCGiXYhFXaxinMSLq8SaPnTxVjHU6QMeFR0pXlpKRGi+oTkUlpk0vPJAzZ0zk5JGloDolDEnqta9pOdIqep9Ha9SlMuIJwIuyAv64fs+er59P1AFUArdAHqKZccD8EUcgMxYwTo7sfl5/NeoeqLRraFwDE96sEs9g0VQGcUufMzUifauTk95ruP4eupoqwmU3h8hn/qD+qKaScmBXb0Ejp2gdnCX3ImaPKiq1qfLkFueZzC/tx7cJ27Ir34ntFdf35DR34ox99FfFGHb92xfsxn8wi9uQ+vKz0NH6v+ADujwziQ8nr1LGyrWhrLKKa2yh6yAHp6evqyw7ZUJC9Ncl3KBSXrgPgmMR4trvaBvIxWSjA2MvoPNEE+aNDt3P8WumTSapQGZ9R+3HovOdBaVN8TldXrhBlj1xlRhMhRuynsmYZnM4UmhfCsbIDz2cDIoUaIhEP3pwWkiAaqYEzT32OEyn1u9chilbnk6Rfrrt5dq+saySE3jN3tRLSCIjxkz4ofT5S0qIRPTSv0O8rfm9y1VVT/2V6q9iOttjZsr+e1yz2i+1ID0v7/FgOQLPoA1et/+UHv4fzKofw2e7XY39GUV/Wlcbxx3u+hr2pHtx7+XtUkxIx/N6eH+KChQP4m+5fwPd7LkYsD0TrdaRqFTiP0TvWJPku0n3mOjsd2l5SUj/PIUq9anniImlz+zZpc3anerfmqD5HYaOaS8xtkHs3djlVkM9qO5ChOjQHxV7VUqotcapoO0BJ5y37dPvJ3ngkbhHdpGptMM3Rj6r7wDVtGpVTpBKr4zQ3NAiCJeueiyNt89GPfhTZbDb8N0ilxy2WR3cpj+5SPvy/A+CXyk/jVZVdiAYyAPZ67XjU68dUrLVp/4VIAuOJHKqeDIbfH7sdX935CdyQf/JYN9/iFIe1AycBggBnLB5qmsyuqU7h1QtP4/LinqZNH1y1GfcOnokGfSxUnAiqcDFMRZ3cwMf/Gfs8vnTPX2J1YQIWFi+El9oOWBvw4hFt1LE538yfv6K8Dy8v78WW2YPhutloCx7Prsf2TPM9XfTUx/RwUlRsLjq8Fz/5pz/Bx+/7DJzAh8VLgxM2ge/tVd7b5345T0xMhF/hvb29qFarmJ2dfd5tlsMtt9yCubm58N/w8PDzbmsB/Oreu/CVH3wUb9ktn5KTbgu+ljgXf9tyVVMn+Ur8PHyg5Ubc2yFf96OpDrz+lX+K/3HhO5qO21+bRSKo4VBMKksmGlVEKexusbJh7cBJgiDAX+7+V/zvnf8HFy9KlPDJ5Gp8KXc5vpW9sGnz97zmt/EHP/e7mIrLZP17ibPwxva34suxc8N13Y0FeIGPmF/HSEoiEK3lRUu1sQhxrOyAtQEvDv2L0/jaHR/GJ+/7DBJ18fbfnjob/9z6MjzZLhVK97X04f3nvA1/u+Hnm47xv9a9GW/c8n7sSA+E69bkVcRxMplFQGIPmWoRFj89ThiFZt26dejt7cUdd9yBCy64AABQrVZx11134S//8i8BABdddBGi0SjuuOMOvPnNbwYAjI6O4plnnsHHPvax5z12PB5HnCgiBonpGrI/kv8bHdTCGfJiqWXEgxwxdJMUZYBniDJhlGJIP5y1Yyur1RfoYo/c5pYW2d+EtbCXvnYHlCGauWZNuCq3g2gcOjO9nuEy3rK70RJ1GktDwgAQ1OpwA1/RPfT6Xal+eAjQWZxHNF9V6/0A/5y4RO0ejSlmDd3Talauc/pstTxOWrmt+zvx6xe+D+dMD2Gf3wc4DqKFOl4/9gjedPgn+GbuYnyl80oAQK1Hhea9tOzvlmiSH9JMKENeK4awMk6TEoXRtXXJM0PLRknC6OIDQK1TnnNVhxKrG2Rd27MS8y4OqOeYmBAjFxmWvACvoMJurD4QK+gwaFmeXcTo9q9Qp8SJsAMjr8ggrruSM0paydQ/fENboz7VZAe0+otLpb/rF64Ol6utuqT2tIxdlleZfoVSbaiTKlb3g/o8pFQV0PkXe1WfSpKQxEIr6RGfpT6UW4bEHrVuF33y4vqcavoZerz5DbTsl+PvqazCWcVD6Kvlw3UHM/34fEa11dHKUD130iRLl4U396sGoJFtDTWaR/q78cbe/4nVIwcQ2TmBCIDE/jj++tAXkfIr+Mya1+Cx7IbmEuisza/D636J9J+rEt6uXH4GAKDUJfYo96SmRdWfR21H2xOPlLwcUt0yFJ4klaKvZuQ+1bWmd9sGubepb4oqV1gDoybHjLf0hcsTl6m/hQ65Du+Qsgn+ixNUOm1wrOzA89kAr1iF5zlhtKmWlr6QOqQnlUVSUuP+od+bhU1CcTHKQgCQe1ZRJvyY9Omxy8R2+PpUuV1i9FntqtSr+sLeXybN9S9rBakhslf0Xm97TO3PlLtGghRbYqr/VlpJXUWr8LlBI7z+yUIrFr0E4k4NuY457OhSk/B/PV8lCHNdi+578+FyRNvBxXNVPy8hHar8pSYDfKf/Stz/i+eg4+FRtDytKL3ZdIB/eeZv8VjLenyq79WYjmbgLBC91ChHdcn8zJsXe5ueVc8n/STRT2tEgzQ2haityXF1H9NDcp+S06Q0p9uc2SfncacpcmiUBYmi3EjL+7zcp+xAskZUa6L/RcbyeC5an1HPtPVxaXvdr2D7ki2X4phO4AuFAvbskdDr/v378cQTT6C9vR2rV6/Ge97zHnzkIx/Bpk2bsGnTJnzkIx9BKpXCTTfdBADIZrN4+9vfjve+973o6OhAe3s73ve+92Hr1q1hFrrFi8NqP4/31u7H9yvn4L8SZwEAnmxbj9942Xsx3NIFt7J8cZOfCo6DZzvXIDkpxumy2Z3I1YvIR1peYEeL0wnWDpx8uO7gE3j3E/+J/7nxNzCmi7t8afXV+MKaa1GZfGkjZFU3in0xCae31QvYUFEvxZHEUvlFi9MT1g6cXIj6Nbxt/w9x9vwQ/uAVvw/fcRE4Lv7ovLdhLJHDdFfqyAd5EZhKZdGIygT9wvl9iAUNtDaKmLXzgZ8Kx3QC/8gjj+Daa68N/3/zzTcDAH7zN38Tt912G97//vejVCrhne98J2ZnZ3HZZZfh9ttvDzVfAeATn/gEIpEI3vzmN6NUKuG6667Dbbfd9qK1nwEguWMMkQhpfWuN4/T9eVnXnpNl/QUXUHKlw0msJoGREiXZYxebUF9enRMUJiLvkdGBdUCJHdqLPXsmeYuL0rlNpdVqq3wBpnbIF2Iwq6+FEr0C+iq9OBjFmcE02ouP4Yfxzag7HubXxPEsVIW0lPY6xUij1lRC42qGyWHxRrem1UuYtZQz9+8Pl/1+laHlVOv4o8FfxbmLB/FEel3oQeiIFbAQSyIYo0pkzGnUz5qropb71ZeuWxEjkxjOS5vNfWbPHiWOmARjh9oczYs33VRZLPRLP5s+T3j/nQ8pL59DevdIy/FLA+pe1VLSH+J5dW9N4pS6JnWfg5fwu+lkw8lmB9IjAdzEUv3wgLzprDsuG5ALXVfsCyjpqtglbTFenUYn5YqQhz82r2xPZbXskz9H608fWtoPAYngtD9EXjhOYNdJ2FzvwFmUY6X2q7Ymox7evOse9C3O4pdn7sffbFWa3N6zmppA94GXw6vnBPMu5fV3+4jCQMnivvZUOeRBny5XcFPylzDgz2Gi3gK3XsHodV3YPHUYuzv60PkYVbaeaaZLAM0VLBf71PGji1RNcZlaF01RyKpu/4gk9/trpUKk36WeWYQq50YqpH+tqzm6X6AkQ8o+DaZmlpwzlhe7nxpW9rzj+/LsU08pe1n3qxDLeXrhZLID85uyiERlLuDQ0G59RI8vOqbTSTVQdMLr7Cb5vUKaEk6gxnFAr7A6Be9M8mr2MYpkkVBFSp+3/UmqH6O1wuv9Qkf1CjI2a52qT5mESACILMp7P6Irr/cclt+9sz289oGHkK5VsAV78JO1Z6PvrnlMIYFIsYz2Z+UC8pvVBXj0vmTPs6dtY2KUEtB1lJwrS3NU6kf1fuzq/DXUEy0IyjU4AJxUAmsrE9if6JG5EkXS2PPt6GrwwRzNzyh6F+iIaXFDTk7foq6/8wmZv7gUJW10a3vNtp7toVlPkftKl9ijQp9a79bE7sfJm49F9ZybxFD6lHPDKVH04CgV/Y7pBP6aa66RQhvLwHEc3Hrrrbj11lufd5tEIoFPfepT+NSnPnUMWrhCEAThy+SbkTPRFpTx7cwFqDvHP17rO27T5N0LGvizR/4VbZUCPtz1BuxK9B3hCBanGqwdOAkQBGIHHAcfX/sGXDf9JD5/zg1H3vcYYNGJYafXFebXrJmdwL989W/xVO9afLj/V1BkR4vFaQFrB04C0FxgoqUNf3H5L6MUieEn684+wo7HBocjbUBUvm5el38M7xj/Ab7ccSW+EDn3Bfa0AE4CFRqLY4sbSjvw4cL3Q66f77j4bOxCTHsnR8iqs7aAlnoZiUYVk5HMkXewsLB4UYgEDbxv8nv4pakHw3Vj8Tb8W/81qLsnLA2qCRunRxE4Dmqeh6K3lLNsYWHxs6G7NodP7/8c1pYlYn/7ugvxk8EtJ7BVzVhdmYKHAHORl5a+c7ri5LDexwlBawswuUx4lUsap4Sm4ZbUl2GTDjvrimsKDf/uUJjcCZQXqakUMIdOTGiok0ropvQjIUdFy5Ac/+AvqVK/lXbZYBNRgAITonIcdPoFvGvhJ4ihgSvcUdyf3ACHErcMOCwWn9FtpTA4GjqRjMo9588W9YnEjAr3pLZTsgeF9t0J1T5Til39R51zPJrF75/1e1hbmsD0/gUAKpzldkhMstFL8UmN+dWqfb3fJVUB0ur1z1qr/saoBPpIPlx25tQ9rWzqlf3pc9Yrq2fTd6fsM3kllYTuUtcSm5Lf66skvBmfVGGzxAQl3+mQX/4C2S7ct1YGdi5ZbXEMUEs5cFr0OM1In6yfIaoJ0WFNg6BENtQ5QUqFcutnS7I56/imD6n+P3uOHN+loZ/drfqfVxNP88FfUvu0tIm9WPVRKtc+Q+HpcKWM03pO2asa0+tKNbwy/ySuW9yOK0p78b3ei1Ei/fMkaSQb2+ZTUn5Ql21dTWVwEuQd1wm3xbNkHDFdxFtQ46CxWRJ8IweFulLVCezf/M3NePzGP0AlGkHs22KjIin1IndIHAA5sUPtj2oqG43DkPLHNqwpmV3T5yjcXm0XL6DRy4/NiD1xq/Lwdv8/qi1tP5Z9eLoRJjtT8uT8Btmi6yl1f+IP7ZY2m/oewcqsB3G8UWl3UY+5iJTUeyhzUJ51oycHAPBm5L3L1A0jsLD6q4fDdX4HOZ+0ZnuZ6qu0HuB5gTnR8rxJbzIPAIgvyP7eghr7PglFBJQkW9a1bFi8Ijor11TvSON3d3wLGyrjeEvxXvzPc38LbU+R5rqJjNTlve1RPlxdd99YgahqnKip7YBLbfLj+p5FmQ7LL1nV5pD2C+DvElfgrvY1eBZ9CLQ9cmguwfMzX9u7KI9tSjZu6N9jc7Ku0K9pNatkPKbnxa6Wu/XYpUPGibrr6W25HTOb5ZoTs+r+lHq4rkC3HGtUUXeKlADtaapesErsWr1eBo5CMGlFTeBXGqbcNP6i5Vqc4czi/sT6I+9wglDxYtiZHoADleC00Z/GL08/hE+0X4+aY7uohcXPgtuz52JdeQIPdZ6JxUgSLk5O6baDverD1kz1f+ngPfAWFvDtzPknrE0WFqcLPr7hF1Ad+U/87ZY3nOimvCCeifWHy5GggfeO/ye+kbsIe+K9L7DXyoSdHZ2G8AI/VCW8L7YW96fOOqHteTGIBA38SeUu9AaLmPTS+Fzu5Se6SRYWpxw8v4GG0Vt2HPxT76vgt5w61JQz54bx7p3/AQDYG+vCs273EfawsLB4Ljy/gYarIkrz0RZ88JK3nOAWvTj8WvkJXFvZjq2lYbx99duxTAxyRWNFTeCDRLSp5LYJYQXtErrwKbsYORUWa0oUqC2THcwhHNKKdooqhBVMTj93D/W7Dt8X10k4JT6lQs7dj5OGMYW5u7Teq8Oa6Bsk9P+6vXfhVYvb8cGOX8SCpylA1KbFTTm1P1F0Jq8nVYnb1f1pH6Zsb7M/hecS05ThrukmHEZ060vvE5eqb7QTB1+Hj51IBA1E8Enn5fgVdye+suaVCLwESjrslRyT4du+TWd2c5g8kGzvSoe6jrBcM4DIPD2bMRUejc5TaWpKsHLzOnxKlKnMsNCGRi9Xx++D3Huj/Q0ALQcUFai4mpQEGur82e0SujRhxnqdMtUtjikyw1XE9RcuKxtFD5LAulao4roOPPYNnWz8UgnFOqTl78c1TYPGmU9d1ZtS/cPJyvnjQ2q5MsmlvSX8G5vRdJQ2KsNN9sqUSQ/iPv7yzi/gUGsnPtdxvSSML2jVBtqHw+Dlrcr3ndgl6hhN9EF9/UGRaGGasmfKv6s2CW0tou1EpEZ0hA6q1KrD9J3/SXSW1gBPZdbiC7PXwCv6eHL1efDyck4TGgeAyJB6ZgErgRnViwgl6RNNsnSRKkYze4bc586nSK3nmVHdULKxpGCV2KaePSuLVNuI9qMpfxWS4eN+kBjWOuGsbW+0qoOjU5+w+NnQ8eQCIpEa6i3qvntUd8Sb0Aol/HyK1JdqS2VW/b5cuFxco2uETFMdgHl5D4XKZqQPHrCyk7Y9rdtFKcXXii9eXvYxNE4AiM+oc8X3Cj2tu1HAh8e+js90XIN7zrlUtWlKxolLCmqlTUoJJblDxr5ndNgB9E/qvsxqP2wb9Pveofe+Z6gvTPMjFZ3IpLo+prKBKjujUsXXkufiHG8GX+m4EtV4sqk+jGsUtpiKRPO7iNaJR1muOb5KiWQsDJLdpCJgvjYJXY/LtR26TuYq6UNq0LeMynV2P0ZUO01BqiflPsWmKeKp6YmJcWlntU0tVzOyT712dFPzFTWBP93RVivg7XP3IhXUcO3iDny79YIT3aSfCk9E+vHE2kuapSQtLCyOCtcdeBJXDz+LshfBD88/D0OpU9B77Tj4h62vRWqscuRtLSwsluBtsz/BQH0Wvzl7D+4LLobvnHqaJSUnhlsGf83OBZ4HK2sCHwB+DxUO0V+IM+eJRyi3Q76W3GnlKQmyS73FAODMq68053k0aOtaOzZCOvLBMp7pWpr2117z5CjpL5Ouc/KgapOzKO1s9Kprmom04t09N+HK0l58u10mwE5JXoLmC7zYJ1+A77n4h+HyZ55+LQAgS/rVpnKoMy/nTOw+IG0+U3m0fE70IU10oxfrUoXJqfPEM230rdsOUSLQuEQtLs/vw1wkhX2r1so+Y+rr3W8VN1jhPJmomITBJGnLOwUKwGm9/8Ia+ro+QAnO5quekm4iC9L+9EhUr1s+6Wxhk+pTXkXcsqmnR1SbSds6YrwPvk1eO17wKj4c7S4PojL2gnHRV3dNjQeup9AltsP09YFvjoTr5i4UjubCgDKtUUr6an+cNM21HUg+I4lw63eotpTOEinVgKJ7rtZ9rgyIvZpbu5QW82BwNj5wjgqVH3ba4Wl94ZpO1FxYLd7ijsfz4bKJRs1fLJro+Q1yf/rvVePf46SvPh2lrEo/j42TrrKOtHEU0R2Tco6e9ri1kQe8Th72yfPV+EjMxfFz+x7B99ddCKcibUpXlbfbj0qhqHpaPZsiJZIVu6lS5t56018AiI1RxVwDSkJlIYK+e3QVZ9Lcjk2SN1Xb3Titc2tyTXVdLTPSJUnx5l3k+FVgGZ0Fi5cW3sgMPDcGT0c+Qv1vWvaGpU+Wz5ExEZ1XfYG9wVWKpC32qf6Z2ZUP19WTcvzWA9r2UE0Y1gUPtOffnRR7YVgCXGm1TPrj0YLenyLS73nn2/GbD92Fb2+5CPNV1f8yQyTCQdr2yd06kpUXrz8LUThtyub4SYrMsxa6tgMxqnnj7B1SC2uE084JqaEoAFVK5boa4TuYqrNmslFcUDiAu3Nnhwm7zDAIqH3utL4WErdo3anWRVeRuADZrmpWXZO3KPcplpc5QjWto5ntYoOyO2mca8GOKEX8OGJjopfeeD5clyjrmiKkwufUjq40+8qawK8AjEZz+Hr0otPmi/WG0nb8P+M/xq5EH97d//vwT4B2vYXFqYYHO84EAHjFl7aq6onCX9z1eVwz/Az6CjO4bfONJ7o5FhYnPWpeBP98xXUAgMTyLN5TCtlGEX+/+yvI1osYj2WxK2Zrxpx6MRWLJTizcAirSlNH3vAUxCOx1VhwE9iT6EHUP43LlVpY/Iy49sBTSNROT8rJ7esuwGIkjvGWtiNvbGGxQhH163h5YWdzJdHTBHNeCk+k1+FQvEMS9Fc4VpQH3l2swKUStX5OhUZSkzIxjFCSSDgImDZDiZhBVoU+HEqcYG3W/Bkq3NWxSLrfTSEktczJLpMXqNBLmkoeZw5QcqXWVTYa8km/ig/s/ApyjSL+tOcX8aSvz8XlfzVdBAAi4ypEFU1LOz/x0PXhspHHXiRqSWpEtSVCJcpd0s+u6USgpuS1KdKTNRq2pILR8bSExYxutd8p7XRHVUhvxmvB72z4XcxFWlCNUKhN32dnn1AQMjWhMPgJnZw0QbQFCqU1Vqttfdao5aiFSdSjkGQQkd+X05/2zxWt60bcbEuGxjwTNq7m+P7RhcwsfnYUBuJAWoVdO5+Q8exQslUQaEoDUd6caQnvRg4vnShn75UxV36Dkm2tZJdS7gCIXnGWaGO6JHhsWo5z4Ofl99RGRRHLHpA2zW1Ufy/evw8f+8HnMdLSjv+RexOKrh5r1H/jc8q2OQ2h4HD/dfqU7UiNyPmji6R3fJayZy5lbyanlR2qtcjY96Ny/Nkz1P6F1VS34p+I/pdW7fR2HAzXualBOr56DneuOhePv2E9ZhMZuBRUmNtMtSU0yu16zNEwq9FmpQ7V1s6HyC1Jw9TY9Xqr2CuPqHKuLmtv+gjQXC6+1qn1p4mW49CYH79M2dauBNWo0IluQaMCSB6hxbFCva4SJnXyc0BJqI2EplEQhWqxV6gZkZz6PfvwaLgulpZtaym17fhV8t5Pjcscw9RdcajWCaaFVmbW+0TdNRQ0TmJNEr3T0XUKbqo8il8d/wm+13Uh/nzPTeHvrc9oB1+D+iwl8PujKvnVYdpYm4xjo3sezj+AJvGOhk7ar1E9hXhefWybdzEAeLPSfiMEMLNV6EVtOyjBXVMGQXOuv6tdhlrMRW0hAn+Vus/zm2X/2Jzc56Sm7HINCZO0nxqSseknlpkG03htHZLzT16g68/cT3OhGeK8mWRkokexEIJJ2J27VChZlVZ17yo52aVRiQD/tbRZz8WKmsCfjogHdRyOtCEAsDPeC5ROj5A5Yy5yclSNtbA4WeEEASZSWTzetR7FxqkjF3nUcBzMJmylZguLF8JcNIWq4+GB9jNOdFOOCYru0kKUKxl2An+KI++l8IHeX0JHo4CyGwNw+k3gDfpKM3j9yEN4uH0TnkH/kXewsFgheHj9Brzl+vcCACKPn550OgBAEOCCib143YGH8VcXvhHF6Gn4sWJh8VPia/0vx487tmIqnj3yxqcwYkEdV00/gVXlGfzvzb9woptzwrCiJvB+Oo7ZsyTzPzmpQiOpx6lmLdModOiDaTP1TonFmkxhj7SUKz3iLZ4+X/1NH5Z9YrMUgjLKDBS+TUyr0E01Iyunzpf90yNaD7YsobDofBUTyAEAAkf99eZINzkrYa2azpaf2iJhna4fSbjIlExu0pnXKjj11aL04JIqg1HKaFJyYG1WrdfqLkqbmMHmb1A6rIevz4XrBr5PVCetYvP6iXvwK4d+goHaFB648rcAAJkJCT2GpZv5BESbYf3qRotWkSlTaejiMkowpELCZaoDTU2Y+PmN4TrWhW5oR0G9RfpTZFHRKpLDQsWoZ9RO9XrZhs6PE6YvCND/qKbIkDIS6xH7Ro2Bnj+X6Xbi+gGTggJIeSm7V/Ulr0yUuzmiVGjlKu6zrqbiuXvEHm34vITZ61odI/BImYb0gp1xrW5BdS0W15LShK6jYCggaqXQ/9wh1QEd0ruPdMr5K22KwlPsltHb0EoUrIHPtiO3W92HxCwpwpwhdiR5WIWfOczNNIHcY4p2ZErZO0GAW/Z8FQOlaWyPDuDr518FACh1Ep1At6UqtwEuiX9FS6p9TOkzeuAAENEKFDVSFmHVrvwGTSkkU54al2O1jOoS8GSboqRv7dbUsWKHSXFjTmtiWzWq44NMC+DGQwpNZDQf/uRoBbYgIwa97VlRZ2mYvkLa7UwN6dihfp8+k8amL3Qpr6L6X2SdzEXinN+lqTFBfKlggzMmH+cOvddDhbdFH7OIwSuX0DpN1A7dv4IeofVUemRekRjT85ZWsRe1PvkI8JZRW+PxU+hX19q2Q2xkvV9Tgeg6oqxGNaX6f26n3Kdaq4y5yqCyp0nWrteDur84gfc9/m004OC7j5yHqehS25g/T10r19+ILSjjkN6dD9dVc1QjokvZmdictINrOLQcUn9HrhbjEp+Ve9bxmLomd47okkR1Mqp5Rs0GAKYv1s/elRP5paOrB7GiJvCnE1y/gevHnsDd3VuxUlI7v7XmcqxdGMd3Vl92optiYXFSYP3kOHrm53D/+k0nuinHBYHj4GurXoYNhVE807rmRDfHwuKkwEULezEaa8OIlzvRTTkuGEp1446u83Ew1YWyGz3yDqcpVtQEvpGMonWvfBl5I8pDEizIl6pDmqKh97aFKv9RBa7agErS8OgLkZO5Oh9Tf+fXUhJHn3S26KKuuPaIJGLGt6njN1aJl6qwVrz60Xn1+9bkXtzyzFfx37I/wi+/4Y+WyEa2jFLSzSLRanRyxsAdktzJX/XmC72wQb6+h16lrn/wB+LBjpAWdPEM9TVaOVPuU+cT4m30plXbqqty4bpKh9yTzDaVTDbwXXkO/HXvas/4tov78I5zfg8A0PFG5aUcXSUecPay1bQztJeqMUZm6KtY34fIonz+TF0u3on0iLr+2c1yHxfWkWdx+1KZzux+8rbqqAR7BEzF2jpV0ozMKTde0LCet+OF2JSL1u2q/zuktVzfILSsyB7tpSXbwAi99RxpmpZjJWZ1tc1e8bI5lEweVoHmBKqyXuZaEVTvIXJAjbnaBknWfte378TrDzyML2+8Cp/tvkEdmhLqEhNUJVDnxyxsFnuSpFBYVEcdmupakIZxZr9qi1uVce5V1X1KDlNSV5ESfHUyV/JZuk+kkRzoCIdP9q7SKcdPDOs2LYi9+f58D4Ae4GAJrTPKdrZS1KC0RSWILQyS3a3K2M1vVBc9eg15MDNkIyeUZ7LtGRm7FRK/qV+krrV8WMZx55NsY9Wf6lmSjMuVWvNbdOXqqFSAXPV17c6n6IXFMUQQqH86AlXtl/ddsU89K66EWstKBMYIHwSbxV5EJ6T/tzx0AACQ2pcL11X6yGN7WPfpOlUv7pJtTaIlR4WiFS0EQfbEXVDjzAsaeO/Qt9HeWMTNF/42nmjfoPaZkTHjd+q20jyB303mvd+guioRiipgSCXsBhRJcpJy/ekRNf5iIxJVKm5Ux+Q6N1GuSqoTaiOz8l6OTMg4jusopzMlkSyuzfA3va/V10EVTHPynErt6vo4CbWp5o5G8mA+XE6MKXu0uE6eF9fCSMyo8Rmbl3sXWyDPudahdysUmaX3gqtZAB1PyX2sp9S5Fl8h98GPHZ2amNXiOUXhBj6GWjvwgw3nnjaa7xYWFi8O87EUFiNx/Gjg3BPdFAsLixOA1kYJu+O9mPLSeCZno1IrCSvKA3864c4N5+JH67cgXq8D5SNvfzohUavg5/7zaUx2ZfB9DB55BwuL0xR/v/V1+NxZr0LJiyE1dnpqwD8fuhoF/Nzsk/hW6wWYg1WnsFiZmI2kcWv/G5Hwq6i7K2xKFwQ4e3EY5y3sx5d6X3GiW3PcsaKednRsDi7RKEz5Yi5pzPqfYZicEqx8CjEZz7ffRhSXgoTFGgn1e2qckt8oQurrEFZAyXOODre4lFyX2S2hPLM+3Wba5CFCCQ/JPYoOU6fS0C5VY0wU1EueS5uzTrxJWE2Oy1dBfFaXQ6fwbnVQYsomJJ05KL+Xu6m8ca9O3GiVUFSD3rcxHb706DpKvRIKMwm7uT3qOn5jz534rT0/wPc2n48fvPzl4XacSDdzpXqmjaTc2/isLFdv0Ak0X5AEFJPcBgCT56n7W9gk9y51QPpBy7hOgGbqwIzQhoJWdc+Mfi4AeFqDn/Vzjfa3TV47flj97Wk4zlLe5NxG0jfPrlV/f7JdNuBIl7YTPuk3g4qLuFrfvdxH9RQWKHysk18D7gs6pOx0CpXL75D+OXW+GtMdz0ifS0zXEMBFAnUsrlLtzz4i+tRMx2n0qqQytlGF1XLNrTVFPXEoKZ81jr1hVZuhdZpsoKEBUEKf3yftd6o6ybVAXgZKLHf0NfsZCY3HpyT0b2gGxXOEbpJ6QLXpTwp3YHN9Cgdzq3Bn7/nh77G8On4n6em7ebH7bl0dq7xZ7s0la4fC5fFuRaEZmxWt5sHbZf/DMfV7/6NiG6LzlCyv7bpTF4PENMb1X1XX2khQCfeNqk31ehkQRqXFMYKfTsH34nDLyu66VLp+bp0ax9lnZBwUSQe+dbfqC94cjWeu42HELxalT8SIzuKYZHiio/C8w9QU4NoBJqG1kSK7RXMJr1TDIoD51ZQEeq6Mqb771JjxRqX2QeU8ocAU16l3cGJieW9gE7VYwycKTsszSkee7U3irmfU37PWh+umL5J5Q+agso0u2ZummjtaNCIykw/XcYL+3FlZdJbm8IlvfQ4A8KWLX4mgKPv3/VDNhfxWoj9FtGgE01hpTmjoh4aqrC80XOy8d0LtT2ImTDWqdS2tS1HfIHbE1Blyx+S90fWoOr5blXdFo3p0FedX1AT+dEGqUcZCEKxY6sxTbevwWP867OrsP/LGFhanI4IAqUYFC1j6wlgpeDi6GrOpNix4SycXFhYrAfFGFXXn6CZ7pyOmklk80rURM/EMkvUqalhZCa12An8K4hMH/gUtByv4n1f8Fna0rTwKyRMdG3Dny84EAMTmbdKXxcpDf2UGtz3xt9jb0ovfvfgPVuTH/BdaLoE/0HPkDS0sTlO8fuQhvH3f7fhm72X459U3nOjmnBC85+XvCJdj1aOTXzxdsLIm8J4Hp0vCu0bhIeAyxpTlDF1KOIjJbap2SuglsVeFaPKXiCpEU2a3Xkxuk5B2UJRwS6gFPdAt59TZ4EF0+a/q+Uuz6NuZR9RvYKwlh8AFps+Sr85kj2pLZojUJ4hCAxPWpZLK1YGcbKuVUjis1H+n2r/eJqGoRoyy0fWYiRXkmJWctH/2THUjeh6WUFnLHsnMrnVoig6FnDPPijLOwjkq896ryO9dj6uQZHRa2skhy/RhpWoRzVPJ5KQ8x90XqufYPScDPkpat63btRrQ/dIfZs4kzW5dDttP0Bd/J5WB1io9HhuUkg6jcrjV6HD7K28CdqLglCuorVF0kvlLRf2k2E3KAvO69sEFIs/YID3jSEGNiQjR30CqEo0e3ReYdUNqBKEKTa+EhEOt8xpRcSbz4XJyWo2TWiaGgZKyWbU6EBtSy4v9feo4SSqHXpM2u7ov+jFpVO5JCamH44frKRC90NcUnKbS4caecbiflSrMhwVThUgv33x4ePMUup+X4xuFsCSPsy7RpjcUpcQk1ZjQyk71dglJu1EZ+9ld6ph+VOhJDzmS/OdG1Phc/wOx1UFUrqnrcfXsE4dEcYNrRGBSq5sRncAhPf24oRORDS6v05rZjtWVOB5opKNwIjG4WoWKJ0J992oKC1He0sMS5anr+gDe4UnZiSgmQUb1u8oA0ViJohPVNNiAxplPc4zIpKbMkqKKUWLz9stcorGuD+vmRxEL6liMJhFEPKQmxQbF52TMeeZ9TnUf4pOkY6/7JFPdmBpsaLYOK6oUKOfG2IEIad/rZWciH67L7iU1pk2qLYkZopoVyYYm9fyod124rtYi46NlTN3H6CzNdbiuh9b4d8rSJlMDY/RKUtspyXLvPWpMOzQ202PynEIbTb+D6stEt+m5JGm/u6ll8nOIlp0/U9nDMk1NG0eZzrSyJvCnASqRKK55y5/jzKFRW1o8CJBoVFH2bAKbxcrCvd3n4Beu/n/Rs+fQiW7KCUfEryPq11FbaQl8Fisen1j3Bny5/yqUYpZGlmhUUF1hwoqnjMX7+7//e/zVX/0VRkdHcc455+CTn/wkrrrqqhd1jEZrApEZShY0lQ8zMhEOKBnL0ckTTpY0XMfpgKaKG1XzLOfkqzelNU2DwlL9cQDwdWVSl9/BphIaVYAMkqTpXgrQQBSHZ7LIzKgv9XoyJ03K6qqo2+mg5BELulQSST0nAz52KC/bmgQzOr+rPWLRQBJQIhSyr+svzGKnePuy++U+G2+mH1laJQ0Qz2c8L/cmfUi8iKkR9XXvUWW5a4o78c6x2/Fw12b8+dZfAwBMnyMauZ1PKU8Cf5F7pCWde1pFPebk4x5dj1HSm66i6C6Kt7CNnIilbtW+5DB5Dg+OyHJGcZNr6yXEHzVa1Zy8ZL7UGyvL8Py0eCnsgN+WRr1FVw58SryobVzh1HijC6TD3iERFuMxq1Ayt09RqUrb0ghaYqPQ3Zy9anxGd0nGYtCtvbTkyefqrZmn2PgAFQBDbjZMHEtNqL7O+tKsI+9oT1Gkg5LmZyRBPqw0u0gdnTxq7rj2vjlLf6+vpigiB5N0rYsgKR/ZhU1yz9J78gCAWid5+3rEHscO6gjBuEQK+Pzvz9+BV409jo8Pvh4/btsKQCpPc3VNjkq4s8qOZA5Km/wfkb3RXky3LHa7sFZyDeop9ZxrLeJVb90p50Kgk5Ep2ls8Q2xT6pED6pzz8mwT+pnV/ZWlJPTT4me1A04jgOMEgK4TwmIDRmii3ifPlwUWHFPJOC19dvyVYucjWgyh44cHlz2336P6f/5smVe07qWEWF17oSm6XNZjkxgCRgd+DGkE0RjcSh1R0idPLlBf0nMZFuyILFKp4tLS5FW3JO/LcN6SSi3ZTh1saQ0LIxLiUK2Mpij7sI5kUWXyYEyiGuVLVY2XRqvYoNb95O2eVOM4Pj+Hv5v4Inrr8/jl896PoqfvkdGRH5aoRXpC/ZY6JGOThQZMRJ3r1LTupjpB07rSamdOrp3vnZk3UcTP5QrvOoJRPn9tuMpUZW09KPemThGbF8IpMWv4yle+gve85z34wAc+gMcffxxXXXUVXvOa12BoaOjIO1uclpj3ksj4ZWxYGD3yxhanBawdsHguam4EsaCB9aXxI29scVrA2gELRsWNIho04CHA2hVmB06JCfzHP/5xvP3tb8dv//Zv46yzzsInP/lJDA4O4h/+4R9OdNOOO35u38P43Se/j43FlT1xfTq1Gm/b8Hu4+aLfOdFNsThOsHZA8Nbpu/HfZu5FYoXLj9627nr82hXvx5d7Xn7kjS1OC1g7oDBYmcJbx3+MV88+caKbcsLxvq434S29b8Pu1MpSpjvpKTTVahWPPvoo/uiP/qhp/Q033ID77rvvRR3LaQRokD66N6ZDwlmi0IxR2EiHnAMqp85lxgMdNkrvlCTYNFFkKgMq5F7fsjZcFyG9YLekXr5BTI5pEsmcCUoua5PQ/WsO3IdLasOYHXg99iR18iyFrDuf1u3n5Douja4TKDm8zIlqYXJdm9wTR4eDyn0SRi53SNfpeFYds9Qp34Os+d76pNJOLW2QsFVsXsJq2WdV+NAnjVuHQkje0JhqU1XoMLVkAmOIwC9GES3qBJyGhBdj+1UortGTk+OQ3mxJ5y7GKa9wYZ1cX6sJe41OyDFJv9qt6ZA469ZSiXhzH6MjeVlntmWKg+kvPq2zWIKX0g4AQHxGU6xmiUJCdBF/TD13h+lnM5TApcdUjJO2eiUhNnlAPVdjAwCgQUnUkdUq4RQlGnv+0gRzh45vqFfuzCx+Jf8QAOCbfVci0NrGi7oEvFsVGxc9TP3KtHmSklA5ad/0Twp5BxQqNrUjSmuFAmPsACdxsh1oGVU0RWMDgOZEtUpvRrdJKARsBxqd6lq8IUoorcg9q+zLo4Jm7fmJS9Qx+/4jL8cknXlPj7nh6ymhj+yAofw5JarFcefOcNnR1In6oNBiGOE7gt4bqe0UEtf7u0niLRsqnU1ifUG8VHYgki8h4vnhmGehCrei+nmlY2ktErWB+nPoOqHN+JSGte7rebWO7AXDX63sBMmLo9xFdRA8LdpQ5IRM1SZTLwAABkaewq9O34dnMqvxn9ErVNPqMg6NpjkAuJra4cSpobxs3kNMj2M7YGjAPVSjgpJw5y9RFLrss0KHqfSoxHCvKvcuNkw2tKz7P+u8E4XZ1MhoxKVNkbzMz4rrlR2KzaUxCnV+p0o1LIxzg8eUnkM4+4S6mDok11G4XHFqS0QHbnmcnqOeC7HISJPwiblnVDOH6cLpYTX2y+0kjKJfEX0/knlk/SizWE/6CfzU1BQajQZ6eprlwnp6ejA2NrbsPpVKBRXqCPPz88tudyri/thajHqtOJhY/uVhYXE6wtoBgYsA30hsRQwNVNyVpXtssbLxYu3A6WoDAGA00Y5v9F2B8XjuRDfF4gThpJ/AGzjP0TkOgmDJOoOPfvSj+NCHPrTMQQDQhzQniIWbkLfaMZJLnKSwXKVWSnQL5sRAxPV+PskLVrpJ2qyqjh87KJKJ4fH565hkir7Xco5q0oa1chz66o5O6Guie9MgOTVvTh+LE1Q4qVJ7hUxFVgCodSgvWHSeElOpyqHxSKQPyj4eSToa6aXkE5TUQzJKQU55vjnBOJiUCETQWJrQkSrN4zWVHSjORfHdxNkAgG66Dj+nvHBN8nRlOf66/6s8BVzZzqH7WF6tK9MNS2IqJyMHEfXF32iRr2//7NWyf4c6bmZXXo5vEgYp0SdMCvKPLmllpeOlsAPu3CK84pw5oByrlcZmn5ogBLN5WRdZRumBo1vcT3VfiXOC+jLtrPaT9KiOOkXmqJ/1dizZp55qwf+XeqU6ZYu0qe1J5SnisVsdEG+5kUI0EpgA4JVlGW586TXxebWs3OS59NGgT5XbTVEDug2VrN4gIseMk7e9rqskukWKbpH0a6Mrt0xDZPxsnN6Lrf4EDhZ68FhMJQnnOnW1xVVy76qtlJSfVdfZtkPGe9vT+XDZT+gE5VUSyYhk5T57O5QdiwxTmyj6FibvxciGc/RwrfLAcgVHp2AkZleWjvVPi6O1A89nA4KIi8BzUdqg7PjE+TIVSuhXT8ez8o70aUx5RfWMIiWK+NK3g6OFE5xWiWL7qyQ6Z8ZnxyPyjqtRZU/jeS73UOXwTRn9m5xnNwawu31AnV+LVgQ16WfBmj7aXy1H8/I+dBbp3ajHVMBVkjvEdlTPVtVEFwYp8ZuS/svan9iIiT2bukCNr54HKUpdl989Lds886qN4broItkRkyt8mLzR9IwXBtWY7pws45rpp9FWK+DhuQxGPH0OM4diQRAdFQvofesQW8EIbSSnyYgxQ0HPz1wWr1hunFOl15YRaX8to9rSICnfmJ4WlNbmwnX1WhmgIuDPh5M+XtfZ2QnP85Z8XU9MTCz5Cje45ZZbMDc3F/4bHh5edjuLUxdtQQm/XXwIbys+cqKbYnEcYO2AxXI4zx/H79YexTWVPSe6KRbHAS/WDlgbsDLwhomH8PvD38e6xsyRNz6NcNJP4GOxGC666CLccccdTevvuOMOXHnllcvuE4/H0dra2vTvtEIQwA1Wtse2jAjuiG/CT2LrjryxxSkPaweWwg38pojgSsSQ04ofeOuwPWorsq4EvFg7cLrbAAQBXJs/hUdbN+DO9q0Yd1dWbZxTgkJz88034y1veQsuvvhiXHHFFfjMZz6DoaEh/N7v/d6LOk49FUW0QHquOsTCyZFNFQVNqJbX1SjEqakfXLGtqfqeDkex9mn8sFBsnLxe5vObUDMnOlJVr3cv3I3XlrbhH/M34B8ufzUAIDVBk3lzTGqzx5QNqsQWgs5vktY4Kc1UoIyNSts56WfyUqWX6zRNJkg/fbu6P+7+5YvOuLpyHVdgZCqTodv4lBQ2lUjjb9LXAH0SmsyfLWHI3E5NQ6Bnw6F3Q51ZXCX3o3WPHN/o/lauODNcF1mU/as5tf/0mXIfonSqljH1TEyVWQCIzWpqAN0nU7GzUS8Dy8sGW2i8VHYgmJ1DAB1W5VDqDPU5PU6aKjcvELWlrBOnuc9TMlY4ZqkOARapHoQOBUeIguWaKoiUuBpElpro+rpufPmBv0BndQHvGHg3drWqMHpiXJ2fqwTGZulYGUUDceYoiZVpB/qaF0mnnSsfjqk8OcSJ8ZcZVtdfT8p2HU+TPTTUAxrbbkNsQ7SsxxRporPt87Rt4mrV7pwc/+H5BB7GmU3JuLG8srsL62Tsccg6OaXOmTkoFAmHaDuevufehNi7sLIuKFl5fvn76HQrPgFXgo1MUkVokwBH+/jtauLhN2KAVUN8QbwUdqCRScCJJBDR84HcXum/qVFFmainZOxwImVUV/rtu0eeaalP+vTky1T/6HyI6LhkB6JTir4XcMXhbpl4lrpjuh1CvTDji+lpZ0/sxyef/Wfko2n8esdb1O9ETfUp0bLYp8ZHpE3oHumdNC8wY47ru3RTAr6m3+V2ythziX43c152SfsG7lS2Ib1DDEa9Q97RxnYurKHaOWPyHLJ71fXH9lC0hextzw/1/anX8eXY+UCsmRZtkt2D9aukzcauU30MPmZ8Vt2TwgDdJ6bHaZolV9Gtt9ByxlTTpsq783KfFvtUn2o9IM82Pq9pNVGiPWN5WuhzcUpM4H/lV34F09PT+LM/+zOMjo5iy5Yt+O53v4s1a9YceefTDEMRNVkenJs6wpYWFqcXrB0QHEx1o71awMDiVDiBt7BYCbB2QOFgsgsOgHS9hLRfRsFdxjlncVrjlJjAA8A73/lOvPOd7zzRzTjhuDO5GfckNuCZG8870U05ocj6Jcw51mCtNFg7oPDxzb+I+UgKhfTzVEZcAXADH2m/hHnXlpFfabB2ACh7cfzOue/CSLwdGF65Dr2UX0EdHqruKTOdfcmwoq549qwkEo9QFrbOHm6ia3ApYK0iw+WHWfOzoUPSAWUcRymE1ehUYbEwNA6gQds2+nXYlLK5TeZ1fISoNkRnKehwT7Qg61yKhJks9KZrYhUdE17ncu1c6lirQcyfJyHr9AEV6vP3S2yX70O31ocunCl0g1IHlZXvUNu25CQkZygIgGiq8jGDnHAVHU1bcihD/lNzX0EyqOJ/xt+E/TEVsozNS+g/pC1RSM1fLTxZEx7NPUGGjygSvs66L/TL88ztlFCY0bLuv5dKU88QRUIfyyjsABD6UkomHIXVqj/Uay5g83GPC5xoFE5c0xtItYHVBPysei5Mf8Pk0nEUkN4v2wlX9/XqGqp9MC7HD/t8lQavCbO7Yg9YkSXQ/abckcFB6L5MkdbaBaqIScuQhOZrbfKR61Z0bYJxUb/AcgpPB8T2zJwvYyo+o07W94BcZ+IpbRNYyaFN+nxVn7++lkrNj4tWtGPGSReN3XkaR/qai4NyzKRWm1pTHMU/7v089kY78e51b5dLSqoxm5iWe7tI47jSpsZ+nJ8nacsbyl6Qz4erPKI/BZ0qCgrWyJ+nkLym+DikXFPrIUWSmKZDEL3P6P27/tHpP1v8bKinIkAkAlfrhrfuXEoPdUlTPE6a7IFWKaq1yniOzdG7YVE/3wqNbabeajikjmIomwAQeOq4XkXOn9mtxoxDdSMWtnRhJ1TUIZFQ+0QPiWa5Q/vH5gxFRs7faCWd+zndlpLsE5mQcRoZUv0yYKob0W06R9R7dO4V6+Wcs7qt9N4uUO0Er6re94Pfy4frqp1iR4waj89KYFQ7IehQNvYXpu/FTbP346u5S/G59TdK8/YML2lncbOeK+TlPrJiXr1F2eXUhDwPv43yJky5BqJEuVTHp5rRz74h858I3dP2J9U9deeFvhedVPe+tJrmR7Wjy3FcURN4i9MDLX4FOb+ECBoYj5xmSUkWFhZHhcGS+hBZsJE4C4sVi/5aHh4CzHkrLxq5oibwsfkAUxfnwv93ao+nWyBNdPrCdAaUdqpDHmzWdJ+4RHnxuh6nKoI5SVyq5tQXZoI88JGxvCzrBK1Gb3u4rtKpXkYLZ4hHKlqQL7jkvhlsLQ7hyh//GDvaBvGddZc1XaOpEtikb52hr1rtmXfz8oXY5K3XnqjUqLTZPaSrKHZIO5uwqO5fYlK+ZBOT8nOgIwxDbxHFmAg52ZIzyouZOUDeQvI0OCV93H7lxVsE8Ib2D2JVaRojm0R7PZ5fpsJpl7SZK8eFmvScxEcJjZ5OrsvtIs/KwXFZNhXZ+N5ydTadjOzkKdHNeOCpsEj2UZWgU7eet+OG2sY+FLTmbkDe7jRp+0amdAclna5gHSVDmerAHL0iD/785apflrqkT/SMk23RCWCmRoI6qG4L12Vg6ITQ2ILqm68/9CDOn9qLL6y+BgdbesLKjbUsVRg9KB65YFwPygxFhRyKxKW1d4vGRMe9o+Fyckp5rxyKOoQJt1QjwSVvdmJUbWu8Zc89vqlcWBqUD/HUdvKM60S/9JNyzHq/so0/7jsPD/WcgdZaET6W0mhYM7tOSYipBa3T3iROQJGYaX3P+iQK2ZSgrKszOxRRXC5y61Gk4dBN0nei2iQkRuRdUc9p7fp6Gdi35FIsXmLUky4QdTF1mRqzyQnpPyUdLEqKuUfP90RhoHieepaVVulgTdVCy6pfeRWqiLxfKhGb90DpzN5wVWJEbENyQtkE9vA3unTNGPIcB56DTLWIX911FwZnp/Dhrb/a9G5xR2RM1jYprXWvJn2+1krViXUErSl1kiP3ppJry/NMkiNLKzIbe1Zd27XcHkiNqHkDe6ODLjl+vVVHyrLkpGPRAR29/OvsdbgtfRmqTgSF9bJta0ndX4eO7+qIYFgPB0CQ5MRf1eaWnRKlLK3juVhdX5rYi0ZCptHFLtUnuMpu606O3Gp7y0IWOtrLFWuD+tF54E96GUmLpVhXncQv7HsArxp67EQ35YSh7kZwsMVKx1msXFw18QyunXoaF+X3nuimnDAsRhIYTT6PY8HC4jRH3fXwlh134rrxJ9FfnD7yDqcjHAdTkQzmvZWXC7OiPPCnCx5s2YDVqTl8Y8Py+tenM5wgwMpWvrawULi970I8k16Nuzq3nOimHHc4gY/Asf4ni5WNUiSOf990FQ5EezAZb4WL8pF3Oo2w0ucDK24CH9AV+1oL3KlzwoKUHzbxifJGKkdOCacRHYXJb5Ivv4W18nulQ4VLBn4o+2fupoqBWl/UYeqGTl5IbcvLdqw3HPEwjhQ+Hb0WGAJah8ZRWSseqOo6FfblBBwu2d3I6KSynIS1YhTaN6HwyAGJHxqdfCdNJYMJQVHrvBPtpU5hfBNWW1wrbXLL8vKN6csr9VBIr0R0l5qEnV4+tx2/Nnkf/n3+Cvw4ew7SFLKbPkfCbxlHLRdWSZg7OUNJQUO6I1DonLWmfaN9P073nqFpBH6arrNGdIQOFcpzpySMbhKHjZYsI7C1OI4bCoNJTOtv376fUL2EAtGYNB0qYK3uuBgPtz2nFqgegjMjiXDldrU/a6JjkqoEmrE/J/uE1BKm0HAZcH2u+G41Nn+CfgSLWWDvLCKYDalwXoJkJSNE6+pRY75B+uSe1o7n9vvUJqdTbItJSit3yziNG737MoV8E9R+PU64bHuQkv2nX67C3ExBSHEJcUNLIhsdOTyNmyf/C2m/jM9c8gbszfbDych9qulENKYedj5OycA66axO9izWTjZ+TFNkJsijGSfbZ6hORFcIiEK0ZDsA1az0s8SkWp/fKueMaVpPvWYNwfFAy8EFRLwqkuNL32mVNtU/ma7C1I3UdtU/qpcIBcaPEGXVJDpyIiLXX/GWfnhycmrigLITQZRqOOixP3pNLlxXe4Uap3920yuR/rZKku7cRfaqX95n9ZRa75D4RWKfCDgY6q/L9WdKRC0Od5Kx25QAr/t6Zjsl0eqaNH6/JK5mn5Vx4pi6KGRja2mxV2auVV8jkXaTAA4A0aCB/+/hv8XDmY34/MArUfQSiCxK+8uD6t2feFLoT4nd9ExNO4jyl9J2vzKQk3PG5Zw1RyfIEy2H624kNB04OSnzCn4vGHsesD3RNpJrBHmNo6PUWheGxSmFV88+ifXlCQxUVmi40MJihSPlV3D14k5cUdoHb4VXpLawWKm4Ymo7BkrTePnsdpTd6JF3OA2x4jzwpxPa6gW8ev4p7Euuwd09W090c44LPjr4C7h+9mnckznzyBtbWKwAbKxP4vXlbfiX9GWY8ZZGd043FN043tX/67istA+7craIlYWF5zfwiqFncWX+CfxT7hUnujnHBT/pOgfvP/dtyCwuwne8I+9wGmJFTeDL7Q44YLa4SlFfIp0SFppfLbekbacKrbiUuZ04IJSIWF69LCMFCsFMCo2j1Kk1RYeJhsEKEDpEVe0QCk6xW31Jxg+QbiyF1OcuVS+sStbFjU/did84cC92BAfw/S0XAI4TZsCnDpOqQpFCYVqHvpaR64zk5evVNSo2dM6G1nD2Se+Uyxub8s2c7R2WSIeULT7zf8u9MeE1QDTfq72ilTy3QZ5JtKCfU76EQiSFb3ZdBqdUhVOtwV2Ue9++g+hNutx1LS0UmvQuCe8tp8nOmtyGpsAl2nnb/CXqngSUtt/2IJV8NveP9gnpV5SBXtUltOv1FTUUTyjafrwfnTsVVa6J6rXvcLhsNN1dUl5yfOmfRqGh0SHh4QiFwTueWhoerp8xKNsaNSpWQmlTx3dYFYuUbQydp9Er1Atvbwm/t/gAttTHMJFoxxfTlzeVOGfKX/5C1WeTE/K7N0sWUYfPQxsAhJrogKi2pLdJ6D0w6hW15TWvg3Y1tp05Cp2TLnSxW+nkdz9O6hqk++yYkD2H7ktlHEIKh2JbkDysa1SQwlRqj1pX75Ln5Q2TpEirWn/wTRKad2pCh+h7QNkMj7S/6xm5T7W0GqvTZ8mYXXWXUHS8CWXb5i+QYzYSVMtjtXomiSl5Npn96p54datGdTzg1Bpw/Ab2/Irq6z0PyvPJPqUoLIUzqQZCXKi10Vk1Ppn2lR6ld8e4+t0bovcBj/M+RWULldAA+IPSF0t9akylhki1SlN4WFmpNC+2a3VtER+++wuI+g1874yXY0+mH5UO6bOLvaqtsQV5h0fOEoqNUdRpu1vekfX1cs1GecqbpPd2ahnlJ1JkcfQ71p2V+U/+UhkTrTu1It6kzKlY/a7arsZ8sV+us2VIKIne1DyeRjuQ6IWnlf5SB0U1K1TIYvqSsae15edXNT3OjR480Dx/M3VBmC5b7BPbVOzWY5tU/owNBKReBCvfGPgpqkPSODpmv501nML4zuZL8fLh7fjO2svgIEDQLAJ1WiFZr6AWBM0SdBYWFvhWcgsmqmk8klx7optyzJHyKygeeTMLixWF6VQrvn7mFagXIpiJpY+8w6mMIEDKr8B+6q6wCXzf1/ciks6F//c7dKXUafnSrbT2h8u1jPagj5BHjL6kY7tG1AJ9wSXI45U8rD1a9IXpkx7yoTcpPdlSL3n4tVcmPidJptEFrtKm/tZbgKmWNN7+5nc1aY723q88XW6RkjXI4xXRJZcjs6TnWqZttSertFa8D4u9OnluXvimMfaI1XUD+Eu2m7Wm1TJXm3NHxCPm6El5nCIFqYx8/VfaoviL+25DUAnwyYHXYjraiuqqHAAgiMo5myra1tTXbPaBYWkHaz0b7XvS8Q4y4k2FTjSdulQ8sNm9ch8nz1PnjVDSf2pMqm5Ws/qezZKOvI7UhLr6AOLaa+tZHfjjhqBSgXNYPYNokbS8WeNYJ5oZrzgANNLS5yM6WrNI3qEUeceie8n7plE9Q2xLvTe35HdzrOSE9AWvSJEs7fVxqM+isw334GLcg4vht+jEWNIQ9pPU5pJaH83L8at94h1yq2qcFtaKZy13v0QlvDHtnaOkLTPiONEsMixFIEzynUOJe5zw2b5LXUtkkZK+WH/dYHIGHY1F/F3+a/jPzLn4YuulaDheWHuhnhaPVrVNjdnEOE31ufJ0UletvFySiiuPyjg3UYsgQm0mx8Gh67XWc6vYzaGU9JOajrKmh2SfwR/Icyz0q/27HsqH6/zEyuTwnigEUQ+B56H3PvXuzT5OERodXcs8TjaZEpaRVc+6mpbn2zJCQhR51b99qgLucmXxSTWOAnrfcYJ8oU8tx/Iydmumf5NjtuvH0mfqKQd/ec0bsSgmBr0PSp8b+KHynLM3nN998a6cOjzVwfEWyTYaj/MiVQ9mO2Si8FTNPKxCTt7kGNVqMeIWQZ4qvlLit5fX0T2ukuwHuLqwA7878yN8qvUaPJBc35RsG5B2vWMiBA7NVYztoaTk0FMPIFJQdogrN6d30LPXnnuuNp0ekvPH88q21FrEdhRXi21o0ZFZd07uY9Cp56FUEda1SawrD/Ha0gzr0wEb5sewdeYAthYOIuYvLUltYWEhiPm1I290CuKayh5kgzIuLB88raONFhY/M4IAscZpaAeCAK+dfwLtjSLW16eOvP1pjhXlgT+dcdW+bfjTO/4d/3vwDXio7YwT3ZyXFHuzfXj7Nf8DZ+3Zj9G4LdpiYbEcvKCBXx39CV4z9Tjetfl3MB85vUqLfz11Hsa9DIZaeuBbDXgLi2XRtTCPP/vWVxHNA//vxb9xetFOHQcf6P1lvHbhSXwnftaJbs0Jx4qawAfVKrAgISTXaAsTLabcRjruWRWebcTkRchh0UhF78867tNy/IYJs1CIxs1LiCq3VycwkvZp+3YdJq9zyWPZP6v14XMPS6iovKET1+zcgZ7Febxx+n78eMv5yFD53oBCUGHrSxQe5kRLnUgRodB9571KsjGYoSTQhFAHiueqxFrWS3Wp/YlD6p64pAXNusqBDstxmeaWfUQ7aoljAlkcvPAK+X2PasvotUJ7SU7Lc4iPL8OU5bBZsDRJZHGNhLoMjaHrh4fCdcWzJAGn8yl1rLZ75XdO+PM3qnaxHr8pGc3Pw9CbguD0jJ6cjAhW9wPTKpRq6BQAANJddjTdqqmX0Isw0FSzxT6icMVkHMVyqwEAqXt2ybrt0lcaOmltYaMkjLraYVZrlX4UmSO6S7caH1FaV+mSc2a3j+EV08+iqzaP6w7ch28mz4VH4ywZ1dQUmvsurJVx3HG/ohXlRoVa4k+SXKumzjhMnzNJqjy2aLnRos7vFmUfh8Lc6Z3qXI2sXAcnc4W0IU1buAfngWHC8Cb0DQCB1uR2SuSBpDYX9TiPfV3sbnZa7F09odZPnif3Jrtffl/7LXXc6Jxcx8IGsvHa9jUlzY8Kraglp6kJ3N807SloWDtwPNBIx+FEEsg+pMakPy7eXFf3Na6hENC8wbynuh5fRvsfQLVfPd/YrLzDAlM3AgA0Rcuh924jKefK7dPvBKKdTW1VNqE4SO+4x8UelfRrMHCBtmIBr9i1HQgcbD44hKFUN9zJvNqAqWRl6b+eGZM8tlm/3LSFRDgCov0YSqpDNFVHz48Cuo+pPWRPzDE5yZToedOXKUpq5/0ydlCuoOa4+GbrBQjSyabzACKo0XR8alNI3+OxR3OBRotaX+qkj54mu69sk0O0Y5cEKJK6fk5wnggWeFQPoL5KXRMLgkQnTCEcmh8dJaV2RU3gT2d8duONmI+24N+2XnOim/KS4aq57diV7MNoS8+RN7awWOGouRF8vOc16M+P4K7YhhPdnJcEXtDAq2eewA9im1FdoVrPFhYvBjv7+vEnv/hmzOxqx1BqmXySUxDd1TzOKI/iJ9F1p1dE4WeEjUOeJqh6Ufzb+mtR9U6Pl9zl8ztxy9A38I+7P4O1xfEj72BhYYHdiT7cFd942rzk3nX4+/iDw9/Dxw9/Ca4t2mRhcVT4+kWX4kDq9HB8JRsVfHT4y/jjkW/hN/L3nejmnFRYUR54pyUFEB0GmkdZXdtB62TRaKq7lDcZmaGwmQl5cGlkossU1qrweLSLlCr2SVi11YTvYhRuqaiXVDUnIZbkuISAjN5xtU9CWaVu0mrW77jXTTyMXH0R/9Z1VZMWeRiuohBSaX0uXK5m1LXE5iTU5mXUPg5VgmcKSnJEhYCcIoV9FjnLWh+fQmkcqnOW0Wt9OrcRO6cHsDO9Cnvb+wHHaaLV1HU5+ESe9Ht3Uta/0Z12lw+FQYc0jYoFACSmJSwW0aEw3mdhUO5z9oDa1p+Sm+JmRWkg/pNn1TqiBQXVWvP1AqidragW9XoZsLbpuMDNzwO+1lTPSJ+rp+S5xIeVwpQzQc83Jt4soyxgakUAQHKPhOGNyozTIWpOPObciuoLrbslNF9vUf1rYY20KbJI9Dbdl/fcJLQbpy79c7Muo2407KNBAzdX7sZ3s+fjmeQgyl1qzLkkHtHxIIWnTXi5TmpRSaK2mN9ZuUkrtVTbpM3JQ9Km6JgOw3MtCg6Z6/XePKljkPb9HamzccXcTtzW/0o00noskcqOUYxxqYZDI6rD3EyTI9tjVD68KqljzJE2vtZ/T2dknyY1qSf2qOOTXn5rhWy0Vv7huhaRnfvDZUMhcug+BINKdSsIrE/teCCy+zAibgxo03QmfodrGgerJTVBUzK8grzvuA5BSdeXiY2IiovD/dvQPOic3qL038hB9e6Zv3ItHV/97XpYxlaCFF2iRXUso+cOAO6Cal9fdQbvmPkh/mbw9ViISp90iCJjqHJuF82F+J5UDb+P6CpUNM5cf9BBajt6TAQJosRNErXVzEuo1orfJffM6OwvZrP4bvfF+LmpR/Gd3ssQRNV+k1co3pBPPstOojVFRjRdh2iEhv7nz9G1ny85g9Nnqd9TE6Tb7y2dQ9Q6ifpYIWWdLmXvIyVZVxiQ6zP1bTJDcvycpti4pA3vNyoACeg9H1bUBH6l4IyZQ3j3+O0AgGdSg3gSnUfY4+TDQiSF95/1VlTdyGnjTbSwOJ54c/UpXFvZjvOLB/G2tb+LwpF3OemwI7kKb1v7uyi3nOba1hYWxwJBgFsOfROby2N458h/4S/XvPFEt+inwlf7Xo5vd18afkdYKKy8CTx7f0xv8OVrKDUh3p3UqP7C5gkkVxlcXJoo6eTkC7Lcrr5gOaGTkzSMtz4+I8dMHsyrv6xBzB7bdvX1ObtZvipze8g7VG7gELrw6XNei47KAu49+wI04uxlVtvGJuV1ntojXkZzXlMhFCAt5wFJ4qxRBcvQy8YVFi9cLW3S3gVO4uOET+PRuLG0HUU3hp+0bMb8hhYAzWXhW0tLJSRz2+RL2h1ehmpD3jxwIpF5jhPiNY1OUQKP8TLSPm27JMkkdlB/3XeSKk58mUS9pgQddcyAqAANnTDXqFN0wuKYwp+aATpVX45Q0rnToErBJnJCSV/1tPSlYrd6Xl0/kaSseg953EzyMo33ylrxThlvemRBxm40r6sHn03VgWn/5L48AGDDv5Nnd1KiTmH/2qTG3r/7fdiwt4jvtF+EcqoFSV3PwlsgbzjpNoeed7I37I03HjlONjfVl+NkI/0+8eI5ph4FJcw5ERnXpqqs0UCO+A38zuSd+HrPFRiPt8GdmkMFQKOFqmVvkPOndFXZxLaRcF31LCWGXdlMlTRnJFLS+Zi6Zw3SjueIovEcZh+Xeg3swffXq4hpLSttcilRLXJY9QknyMkxmyJxqi0B2UsTkXFPR+m/kxCB30AQNFBZq+x3rIXs9CH9HmFvM1fkLuj3Pie2rlslPw+ocZLZJ+PYJY9vOKboHehSBCfQXlyuP5M+oMZ2Ya18yEYK5PnVc4xij8wbTATqr/tfj3eO345/6ntVkzeZazO4PdqbzR50rqZu7BAnq1PSpat/r/XK/p62CS5VaG+a/5j5V0zug5lr9JZn8e4v/wf+qec6lHQ0s44oqm1ig1MTqn31JEUyCiTekVX3ipPiwzZxhWy6D+071NiMUaSAa2kgjPjJdXDla1+3PzJPc4WCXF98VtmRztsPyDG13W5QLY2jlcldeRP4FYKvbLy66f/pagnZ6iKmkX2ePU4stlRH8J78D1CDi+FoO2YxeOSdLCwsnhdVN4o/W/OmpnWrSxOY8hOonKQJoW+d+DF+fuphnL+wH7939u+f6OZYWJzyGI534o82vKVp3abFEewN0idldNsJfPz5jn/F6vIUKm4E/9D78ye6SSctLOFuheB/PPkt/Ovtf4Prxh4/0U1ZFs9E+/BQci2+mr0EB6IdR97BwsLiRSHZqODDu76Av9//WQxUpo+8wwnANzouw+F4O/5x8NVW693C4hhgy8JBfHrnP+ODE9+GFzSOvMNxRuC4+PzgddiV6MX/bbvkRDfnpMbK8sBHowDpd5oQWIyoMPWWNeHy1LkqBFbNyS5rv0ChVpOURjSNBoXR27ep40b3UyjWX6qkkNw2Kv8xCU6sk04haZOwmjksAy/1lFBTTMJotVXC7JnpEvrmZhFr1DF1qIzY+L4m2hBrXTtazzXGX+auepHOnSXXlh4mzVJTfrlNfq9RWCuio/QcMk6uasUvjj2AL/W/AphSG/zpwK+HL22Hyi+37lbHdyhRzTO0I06Oo2sKqS/L6L0DQKBDpg5yspLpAoF6tpyIVsvIcIktU0OAk/scTa3xKTTr6pBsQGW14+Pq2r2jLJ1s8bPDzWTkWVFymUf9s3SeoqFEieIyu5mepe6ffpoSsEjb19FUtKBfaBx+ZOmEtNRHyZ9j6m96VPpR7HCeGq7296N0HKbxaSqa63Lymdi7VZiD6/vwfWBypoLAmWzywIW61KSbzL+HSdqcFK/7v0MUgFo70UVy6v7ES5Tw1yYUmv5EHufMHsR/rroUADCCVvx24p3KDpANiEwJVSiZpaQ0PeaDNhmnieE8novFzUJ1Sx1QdAZT8h4AGh2kb200rak2QyMtz6narq7JK1OiPyU0VtepZOeZs2WfXNsmad8+RdsLWGPfULUaJ9+E6nSE09UBx4sjuqDFCCiB0NV0KScr793qoPSf2Lh+H9G7p0FiCL33a1EHSrZm/fQwmZ3fwTF5t5Q7Vb9JPUuU0IrqX9FOGXv5zWJ78meqY3lkDpqSqPV1uvMlrJkbQw0u8i05VLvVNZo6DqbuAgA4ZFsaver6vVnKpGFRCt1/WQhg8gJlB/q/L/cpyNF9cEy9hiquXdiG0WgbnsgoKs+dmQtw58bz4TsuGlRfZuZMOefAneo5sF6+zwmz2jY1ktIms3fxknVyGYtMFdLCJbNCeQpyRCfWFJrSoFyHE1CtDV3zxtgQAPAooTU5pe0p14LR7ffGROAksDrwFgY1N4I/vPC3cPbcMHbvl850Qe0w9nodmHcTL7D3Sw8nCPDX2z+HDcVx+I6Lr0QvAADrcbOwOIbYH+/G7615OzonDqLsqAmLG/i4rDaEh6KrcbxFGleVp/FPj/8jHATYnerHrqwuCGftgIXFMcP3cudje3IVRtuFc91bmUVrvYjdsd4X2PPY4A1zj+H3J3+I4Wg7fnvzGaEUtrUDR8YxvUMf/vCHceWVVyKVSiGXyy27zdDQEF7/+tejpaUFnZ2d+O///b+jSl4jAHj66adx9dVXI5lMYtWqVfizP/szBM/jWbVYHoHj4tmcRBcSQQ3/b+EH+MLcl7CmMfMCe7406CvNhDrOgePgq30vx+F4O55sXXvMz21x4mBtwMmFohfHQU+8iRfVD+NPF3+Av5//xvNGq14yBAH6auJlOpzowN19W3B/91mYSpycuTkWLw2sHTi5cCDehWJEHHdvHrsXn9rxz3jb6J3H/Nwxv4aOmkTU7sycg7FIFne2no2GnbS/KBxTD3y1WsWb3vQmXHHFFfjsZz+75PdGo4HXvva16Orqwj333IPp6Wn85m/+JoIgwKc+9SkAwPz8PF71qlfh2muvxcMPP4xdu3bhrW99K1paWvDe9773RbVnYWsP2raLlnioEMKa5gfk92hBhXr3vUN2mbhOss27f6SVDyhkzYovsd2KGhNQqI21g5HRy0zrMRnZpFrgU3guuqgmwclRipWRproJBc6vkUfb92MJBxmKTGfCxUixDUm/huHOdXB0OGv1/AgmvTRKlM1tNK1ZD7+JrmK0ouk6/ZiE3t+/56t41fATuDX9KjwUVdSEu2oDuK/nJtQWI4Aufe5OSzuz27gcuw5ZV5eq0CynBKSuU1MYiALQyEn40TOZ8c9DF/A71YSi2EP0KLqmFh1y5NB9kfT0vZL6PTpPoTATMiR1g7puU6N+vP2fxwcnmw0AoMp+mxAnax1T2NOESpmuYrT/ASA6u1ShKiyJ/TyITMszNsoIUdKPNjSRFKkaBKTQ4GfUOJhfK+O985nmCQ6A5j5NoVqja+2QvWgpVDHjJPFIbFDofR1t2Fgaxb5ED3wKqYf0DjqmP6Mm5A6HjFskPD12gerf7Wek8dkv/yN6FvL4jeg7UHLV9X+yeAFq8OAcLCMJbXMoNG9Uaji8PH223JP0iGpzfL+MsyBPNl4j3k7KN5r25BKliel57qJqB997b4YoPHPa5nDpc+pH8xepNrM+dXycdcC1bV4r75KatgP1ehnYt6T5pzxOOjtQrwO+B0+PuVp/Lvxp6jWqivH8OhnbnU/J2K0n1baOLx+dsRnpfyF1g9RPItS/glFFqeV6IG6cKDQbVV+tXtYXrss+pZxs8Qmhfc3+nFAx33W9ko3+9APXyTGJ4uXq97lPdS9YhSnwfVQdD4+6/XDmVF9tCWpoayziULQ97P9NtC+aNwXadiTJNjiBrm1A4/lS/yDet+sbeDq7Fn986VvVdvsb+N31v4OaG0F0aA6mVUFCLTVa5b1dulbaX+pTc6SW/UR3obmSoQOZug4A0OhU7+upc+R+D/xA7qk7o8cpX8ek2B6jJhWbp1ody7zjjaoWACRpLuXHlW2obhVnalRTiDE8JtcRLGPXl8ExncB/6EMfAgDcdttty/5+++23Y9u2bRgeHkZ/v5L++pu/+Ru89a1vxYc//GG0trbi3/7t31Aul3HbbbchHo9jy5Yt2LVrFz7+8Y/j5ptvDieeFi8Oh2Pt+O/9v45WvyST3CDAB2a/h4H6LN7b92vYkVDPJFUvw3ccFJF8gSMC0aCO6wrbsa42hb/wfx2+/rCZSWTgIsAZ9clwAg/HQc0yuE57WBtwcuPH8Y24J7YOMUpmW1WZxqcO3IYZrwX/bc3vhS+lbKOIBTdxRKpNT3kWV808i7oTwT/iegDAVDoDN/DhBgE2VMbxTFJLMTrWBqwEWDtwcuPT/a/Bv3RfjYWiTMpvKDyD3525C9/LbMX/7r4xXN/uFzHjvPBcAADOndmHi6d342m/H0/p3MJDqU601ktYuziOWKMW0mVqrrUDPw1O6F27//77sWXLlnDAAsCNN96ISqWCRx99FNdeey3uv/9+XH311YiTDuuNN96IW265BQcOHMC6deuWHLdSqaBSkS+g+Xn1hTZ5kYe2h+VrK9BfWU6WqpNRslV0Vx4A0PvN9eG6RkI6eGWdSgCpJ+Wrr0IVVNt3aF1mCgM6ZbrlOlG10S1f0ubLzaEvONY2jWoPfyNFSTdjcnzvkEqQip0pHqfiGjl+Qnv8jJcgj9awAmRHZR7uUAAXwFAlDtTU1+hrJ+7Dby/ej3+ZvA7/sk69kK+Y3Y5fPfQTPNO6Gp9Lv1y1KebhHcN3IxHU8LWR63Ewozh2X1t1Ff6j9zLM7F4UdVP2XlEFU7lRlFynvdNNiT79+pmtkyTBYq/ck4VBtf+ab4nHIDIlXrBgTHlBfK4Mwd7YdnV8rmxXycnPyXMVXzd1IB+uS+0Xz1+1SyW5lLvF0MVi6n5E5uTavQXt7VuhSazHygYAz28HVCKVGnu1LklGmj5HnlV6RHnMWN/boaCTo73RNYrqgGojxCa0x4qSqqo5ab/5aI7NUBK2TgRz50iDOCfjePwy1Sc7nyat415SbNIfzFxd1qNjhTaFPGJOxEMDQAlAvU0nnS3uQCGSwFCmO0z2BoA/Pvhv2FyfwC2pG7HdU4mav1N7DFvqY/hS8gI8qD/OB4f24ndnbsdhL4t/cJS9WFwFvOt33oLh9na03yXjNGWqxyblPpl2AJL4W9ss3NzcXvFmhvru7DHTns2AxnZkz2G6ZypRbupisR3pw7Jt3F0axnfypONtPPPUtwKKqnU8llc/d1PF3GmKCugE+MYG6fMm+a9eX5kTmeM9F0C1BrguAh0Fr7RTpFVXAPXpURT6qU9omkf6kHz0xsfJ253X0Zp2mVeUB8VbHx9T1Y8DapeTl3dT+rBq02I/1RXR/c8hEYzuh+SYX3r61QCAgSlpR6NFLiCincj1Vjnm6OUyttt2RbGANpS6xDZ0ffdB1Gdd7Fu1Giio8dWSTeCLw5/DuJfBb7b+irrewMfHit9DLKjjlvIvoKija9ftfAhvWHgCX2+7BE/H1ftydDGF9655C3Yk++GNV5BEpSnxdPLSXLjc+aS6j+OXUt0HKiUzpvLesTpPevtcFVVHUT3SZDeiBQM/JB33g+L5Dm0j1f9omiXreVPsUF5Wpeg5meqzNFeZ3yzXVMnqvtUrv7frxNnFLWeF6+q1MvA1HBEn1FqMjY2hp6enaV1bWxtisRjGxsbCbdauXdu0jdlnbGxs2UH70Y9+NPzitzh6TMdb8Tt9v4lso4hiVQxWX2MOLoB4Q15SrbUizi4MYy6aAvQcyHdcfD93HmqOh7Ing3I6oSboSTxPaWqLFYtjZQMAawd+WtzduxU/6TkHmVoJmNIvuiBAnz+PBJpVUvr9eZzpT6Hdlw+F3bFu3JNYj13RHvXC0x8r21epyVn7c45hYWHnAicfPrnlF/D3Z70WXuDD2aYcgwO1WdThIhFQ8SI4OLsxruYIQR1F7Rx5NLkG8aAWRtsMtqUGjts1nO540RkDt956KxzHecF/jzzyyFEfb7mwVxAETeufu41JWnm+kNktt9yCubm58N/w8PBRt8cCmPNSTf//+/RV+LX2t+BbA5eH6x7PbsAHz7wJXxi8tmnbf+q5Hv+n+1qMp9pgcXriVLABgLUDPwsCx8V8jPJ1HAe/kfs1vD33JhxwZWz/e2wr/jR5HR6Jyku54Cbw4fafw1czF52UhWIsXhqcCnbA2oCfDVUvilJEPMy74r144+p34o96flk2chz8r+Qr8SfJ67HoiuPuodR6fLLzBjyQ3gSLY4MX7YF/97vfjV/91V99wW2e+5X8fOjt7cWDDz7YtG52dha1Wi38su7t7Q2/wA0mJhT94blf7AbxeLwpzGbQui9o0mwPk0ho2+oqCUuZ5IfMPklgckk72ISX61QifX6NGJLk+Yr3lXhoj+zDWuM69NJUkjuh20ShfU6kMyH9hTWkMbwoL1SThNF5n2jPm2QQgMoKV8ULFlmgUHBWvbTZHAbFImadBErtEq4fCzowpnVyY7v18yHt+sQhCQmakKJPpaddStINqSuLlOxLz6m0VoUiWQ82opNE49OULEJlostt6pqrPXIf43tIj99oPUdJ17+7M1xu6N87npbnvbCeQnm7VBgUFKZ3KHkwrhMRg7Wi+DF+ido/WpDjtExo/dxaGdiGUwKngg0Ant8OlFe1opwxz0LGQfdDQnMwoVC/RfaPjJBak+4f8QUJz1ZX5cLlwmY1JicuJLoKOZ7771UhaS6N7mptYS7TXeiXsTt3pjpAz0NkQ7iy+Wo1TordFJ59hjSOJ3T7OVl7UO5fqUfZlJaDYu84QR+JBEaQgJ+fA7QXfUdSedWdSERsBtm47ifU/Rn4ttw7v02uuTqgk7qy0uZSh9yztu3Ksx+ZJbvLiWqzmqo0L212tDhBWKcDaNKuN3SW5DRRF2tiB0r9qm80YnLtGdK5D+kO1Lcc0vlu6PB5fJRoN2z3dTl5pvVE9Luo7h9d8trJgFPBDjyfDQiyaQReHE5J3e/0o8LNSOtn0dUhFJiJS6SvVPUUwQhKAADo3RNkNX2yh2isPVRDZIP62HWnxN4EaaJaDiu+S2RW1pn6Ls4CUe4IXkX13ypRPotdct0x/W5zqMkRYpZMb9XvQ7JRnY/TBgaOg5oTxYF4FxxHxsT97gb98zJTSq59w7SheXUyTqqPFeQ+1zTdp7BaxmbqsNznlC6fUxiQ/ZOTJACgn0mMqLGBnlcxjRUtRIM04hxMoeGaPJo+xxQZcDL8jKY61cRuH3q1HKv9MbW+bRfdB00Rnt5CYijlo/Otv+gJfGdnJzo7O4+84VHgiiuuwIc//GGMjo6ir09lLN9+++2Ix+O46KKLwm3++I//GNVqFTE9qbv99tvR399/1MbBwsLipYO1ARYWFtYOWFicWBxTDvzQ0BBmZmYwNDSERqOBJ554AgCwceNGpNNp3HDDDTj77LPxlre8BX/1V3+FmZkZvO9978Pv/M7voLVVfYnddNNN+NCHPoS3vvWt+OM//mPs3r0bH/nIR/DBD37wRWedV1odlM4Waab4lP6apeMUe+Vryyurr6X0bpERakq+1F9mc+soufJM+f2Qrt6X3nh2uC6Rl6/J/CZ13iQ5hk2iJH8J81dzRTvbG2vlS7ySlahBy5jyGiSmSfJuimSSTEIsyb5xYsvMJaoBPbfTF2JOHT82K8eMTIrHK+hQvzdJsY1OSqP1F3aT152rOZaXJnD6Wdk2uqCT+8hLltqub1pJ7oPbLy+TXER9ac9StbrIgIT5Ox+g9plzUrVFI0EVUPQjNUqVGbtU/+QqcBGdQAwgrIDJSZBRTRPmZMhqWiceVl80m+2UwMlmAwBg5owo0Kr6/+r/yIfrmxINtfe2uaopJTzrMROQ92X8Yuk/5llXV0mfyTwttiU6p/p8nPpUac1SLfTCalmOTWsvGUmOVvvFS1hPqd+9qnQw9hz2GulUrhhMnuXkmLIN7gj1Y6robLzIborGsfFesceKxraJJhj5NgDwKJIR3aU8VpFNcqEVqlRcXKWOxaQ+Tuo33j324oXiBJ0S/QJ746vKdiUmKLlxo5whOamvs8pGmPpZWm3LybZuRWxfQ4sCcMKhkfAEJLmWpTddI6Tgn575ASebHXBKFTju8pKjRurZncyH67oek+OXenX/JhnFekb639R5yg4kp+T32AJJyOqKzS49f+O5BUR22klK4natU7UpSn2qZYTex7rS6tRFVDmcGHCdT2mDRNWN0wfFdu19s+rLa79DghjjeTmAeUdTtXWWr3ZKenxRMncwpyvWkj0ISDDEELg5ypmYoerGOiG150EZu5VWeQ6FV6lI2Ny4jMOBO6k6rHGmt4g3vNKmjpWg6FqM7GFJJxtHqHpqpECyuVrus6kaNvWDaLvqqz556N2StCmpc4piYxTl1P0gNUpSt0cZiDumE/gPfvCD+PznPx/+/4ILVMXNH/3oR7jmmmvgeR7+8z//E+985zvxspe9DMlkEjfddBP++q//Otwnm83ijjvuwLve9S5cfPHFaGtrw80334ybb775WDbdwsLiJYC1ARYWFtYOWFi89DimE/jbbrvteXVfDVavXo3/+I//eMFttm7dirvvvvslbJmFhcXxgLUBFhYW1g5YWLz0WFGis4l8gEZCQh/lbhV6CSIUfiN6g9EYDqhaYmONJMuUu1Xop+txoXH0f4my3HUyVfkMCYWNvIz0ZnXEPT4nJ/V0pMqPSpvqxDYxv6/6F3l0HtFIjJ4tV4SNUPsNTKIWANRSck9KXepvQGEtP6mWJy6WfXrvoaQuo9NOiTxNyZ0mVJiT8Nvky7vD5eS0CldxIhHr3Ffa1XJqRK4zmFZheE52dSclHBprUetzJUoIHKBkXn19LiUh8jnzm9TDCVy5pq57hVpQ61LhrhhV3wxal+o+x/aOh+tSbQP6mOEq1DSFJqDIn8WxRbUVaPTpPktjw2ksQ5mg0Pz466QehHle7dukTw5+c1S2vU5R9TrvkeN33k/UlOhSOoxXVOefXyd9uusJCinrvuweEs5dfFHGVODo8G+Bxt5aMR4H36RsV+fTEuZOjEr7Q2oKUVg4vO3q+8Oa7Y2MOr5L9LnJS6RNyUm1z8Jq6eCrvkbJwObYwzROOomCo0P+PtkzxyeaY12H5KkKNPqUEcufLe1IHySqnU7kZ7vfIBNpbG/LHqFOcuJstVedsykMzkjr4xP9yqNaF4GhYVJ/M+uOtgKjxc+GelcrEEnA10nUTYndmh7B46jWKh0kPqvWM8Wq3C30ucyQWh+hdw/TLLy87otc+ZkoVuadRlMRxExCNFHVYkSNNQnqPbPyPpq+UuYdlXY1jpOH5fdGTMZ2Zp+z5Jgs+AFoCs4sJd52i6hFo18tR0ZlbDtmDkDXzsm+hs7DNnDsMqpMvajr0+wQ2xKbl+ufmVR2Ij4j4yy/QQ5f2Kppivup8rTOG8/sEXtQ65QEdE9TXpuEPWgcm77xfFW3Q3tJ17n587JtcUDNEQqbqAbFXnVP04fl2uq1o6PSnZ7EWwsLCwsLCwsLC4vTFHYCb2FhYWFhYWFhYXEKYUVRaNqfnEN0kUoNd5uMYQllRRcoO/mgCnkHlEU9c4GEZWs6ett7H4VvWbVBlz9O7BbFk46sqODkN6lzOb6EmJyGCr1wUn2EolptO1VYKvn4gXCdKQ0OAIevVW2tEy2m/VlpU2GVOvDAHRL+jSWlG0xeoPYfuV6O2TpkVGCkHUw3KWkqUWpE6CgeUU9CHVjSgM0My8GqraZ8sYTKWKc1rfX4q+0SpnQ3qupuzkRezsPZ4KMqLOWS5nT7rBzTHZ1Wu1DoMkJ6+dm9qv0LayT8Vh6UMHhy/6y50HCdQ0oUgaYhNHLSdwwli5+3KRPtl23Bm+OFdV8cgdOraBYN6vtOt6iWGBWiRkrCyBWJeiKhug9iB0jNiJ5r/iy1nNtGz5XCqkZ/OoiI7Ylr/eeWFNUjiMk+XkWPo4i0OTgktJ2ECW+TJnmGVCt8rcwUMGOQNYyLenyyQhWpa8SKus1U+jykoZTk2jOHKOSt6zTU0kK/YyWwSElR6bxFoY4kxogaYJSBokRj7JZx2MhqCg/d28IG9Xuhn2z5HCkAFXQYfFjC/e1leS9MXqwpMnmhxEXpOUeNcZ7Jh+tYnaMwqOxUnML98YhQLw0diMPwvr7Pfr0MPAqLY4y5jSl4sUSo2MTqJ02UD43ogryvIrs01ZPGbiQl1Uaj+t3F9Mxar/TZ2QsV3SQxLeMkxWo4Larf1Tqk/xk1s2pWxgG3KTqvxynVWuFiLoYW5idlf7ckY67vR4oiE9aKAJonIUl594Y/L0r15aBDje/quq5wXUS/b90y0cLo3jpm/FTk97VfJR13reTiNKnEyH3M7lD338xPACB1SGxHaad+t0ZozhdX1+QWZC4SJfqfM6f2D+ZEFWjh1eeEy3Nrle3ov4dUamZogqZNTrlL7hfTloyS3+yZMi9oGVLXYag0AFBvLFXmWw7WA29hYWFhYWFhYWFxCmFFeeABAJS05o0pj5fLCSRpEk919Rc2eXdMwiUARCrq+2fkKvFwD34tL/u35wAAflq8WNlnpuVcvvL4jV8qX/JZXbS160H6EiYvmjOp2hxQ0pZzWJLaYnnlJmQN2MyQfM25NZPAJd9uJvEVAOIzZjvZPzFZ0cf2lt3HVE5sOUTt7JIEl9oy1c84ASg1pr+AKXpRXE2RDH37C73SXTu1jrY/m5fNyEsHXZnRo6/7wkWiA1/eor1spM87+jK5J70PKE9BsVuefYs4O0NPQoO04xfXyE2vJ9R+GUqei06rflZam5PreEodp14LsB8WxwULi/B8rZlOVfiMNxcQ2xCh6sA9D0v/q6eXZh2bKsYAkNuhnn92P3mfDkjlTV/rJbtkb0xSWIQ8a8hQUpeORDUGxEPvkWfMJJfW2uQ6OBmr7VEddSIvHOvAB5Pqd04Mb6piqBM53XlKJveUl8s9JEmoSfZoaTvVMSwebFM3ApBIBEfnghyN/Yy6PwF5A2tUtyKx31yTtHn6HNXO3gfIq7+HIiXGc0qVk126D7GCGpNzG+U+ZqKSEBhGHajSptH1B6RCZ8tTZDAcuo+t6p45pJntzemk6qP0vFn8bOj4ySFE3HjY10ZfIeE1IyrRNi3vK65xYqqpOzGKCqVI019X4eT6KlyLpaEFEhb7xZ40kpJ9Wc6pvpLdK+cvd6r+HZundtA7vHiW6p+xOenzkxeLt7vjCdW+GtkbrmsSP6jGEVdmZtsQVjzWFWGfe37zPq8l5JrKA+q9n9olcx5Oig+yqoqzt+OgnIfnNRV9TymJNPWEiIT4UVU7gtkGLiXxtsypCEFljTzbaF7PG1pJGYSjArp+S0Be/8we8cYnZtR+YRQGQFAl7fySsm0Jzl8mTfjYuLqPnRWqxaGjvVxl1/GtB97CwsLCwsLCwsLitIOdwFtYWFhYWFhYWFicQlhRFBpnfBqBT0lbOhks1OUFmvXLO1TopdIrIV2TiAhIIlvgSBh7/qJ+2XZOhbviQ3k5PoWIWh9V5219gsLxJoGMNak5MUUnyjmangMAQYskiNV1hCxSpIQ5Kp+c2a/O71Mp4Zkz5PyevryObaSPrhP9qhnSQs7I/pGyOv7igLQjTSGi/GYVdkrMkB7rQUmidcrqPnGiz/gl0jVrrer4vfeSZvYhnWBM4X6HyjQ3enLqd6IApHdIKK+xVdEQYguUaDYr15ffoO5fg3J3Ji4g2tDPqVBjZj9RbEakfSaBrZ4i2kWLCq8lhyQkl5pTz7Z+lCEzi5cAiZiMr7w8iyZSjLYNjXbpU7FJGoeuCg+XzhRqBdeYyO6tLlkX+BxX1cuU7O1UzD4yDnicLWrKRtfdQldpCv/OqzB9rEh0lJYE/a7a32iTGgwu2QZHH4vDx84C0Qs15SQgG+maxG+iEzA1RKgjZM/2SRg80PfZ2FoATZTBuS2KVpScIIrKvCwXN6txzKXPM0P6Otg9RWFuJHSSLyegl+WasrvVNc+cI3SD2TPEdnU/pJLNGi2kRz8l9ixpKDqk2R0skma8ptDw76GN960O/HFBpQa4DnxN+cgeJAGFghZtKMg7sKlehBYo8DtknDJNxIzp8mAuXDV6rVBKDSW09YCck+cV0+eo/lEhSl9qSvVpTtLkJNnCpWpMH3ij2JONX6Axo+mbs+dLOyYukj7d9/+z9+VhelRl9qeWb+uv9yXd6eyEsAZBQFYRkFUFxQ2V0QFXENHB6LiOiswIyLjNDwcHBMFxQ0dx3wAXEBEMe1jDlrWTdHrfvq2q7u+PurfuqVQ1CZKk0933PE+e/lLrrap737r1vuc9r6R+cFK/cPT589JO1Jq1PclsJdsg6TQWjQlPJoxWuzVlTlFIAGB873DM5/ZZGC1zeymZ10mhKdJcTd0zt0TTWFov5JjKNOl5CaTmvMW05H59TmXb7HYtaCDIRioKTu0A3ebMZv0OgUzsdTYSZS9D91TWinEo8bWysDlc16XFBzyvDGhm0aQwHngDAwMDAwMDAwODaQQzgTcwMDAwMDAwMDCYRphVFBq4LtCuFRwgw6YW6Y/HShqXZbiEqCOFTTrU6oyH6+t6iSZR0N9EGamD6lMIx2ogLXOZJc1h/CisW0dhH8rChgxViSYdbinNozC/jAaVtBwrBvclNYX1qgy0DiE1rtO/S63h8bOrKH6TD0NtGVK/qKPQ/6gs1z4+V9+nckuzbpNUZajV6+sod+nwdKUlvH9MZ+l4QP9WNIKARGb8BeEFsjqAxyFtqSut1ESA+LNteCbc1t6i1y/apEOivceGocbyaTq8VntMhwLb7w//tt7fFy2zBvRz9BaHFJtNx+jrdCV7qtWjZVIRxPfKgGYWGOxClPafi4ZnZSh3QmsZ8zgcf9liAHH6Wd19m6PfOVX+m+giXofuP0rVpPeoZr3/Eq2CBKXaQjUmAmkncn2aZudUdZjbkaXdlVpMuBOFgrvCMDqHrDMDdH1Si73nOG1bFv6cNIwVLY81n0mFh5WvonNK2g4atT0a3V+H6be+NLQJe31T2xNB98xSYXK699aIti0NUsGBFS+cHq3QVRgNx1KVaI52LanjzWXh1bEsnyhNdG22pMCMd+tranlCb2vL2hM2qdgw3KckHYZoQVaOytLLkH1tL634MdEVPmevVgZ+mnpYg52JXAaws3AGw/GRzel3uCPVngKqd8BzBPU+5HcP2wGlbuRUdJ8UxAZpXxXOG3LP6HcHU+kW/SJcP3BIc7SsKBVjek7QY7thPfV5T1Jrc/q9WWvUL8xye9gXmx/T77OWB6nNahxSO2L65lLLPUu1C5hujAlJO6K6J+p9nt2g37Eoa1pP8cHw3gekShWj/I3L+VO7vk6rPqns45CqFohGq66ErYGQNRjsXro2UrhSNNyAqJOx9dKu1zr0ddb2JrqNE9q+4gNapSZGleuRioFUy8PPhvuX2mkZqfQ9H4wH3sDAwMDAwMDAwGAaYZZ54O1IyxigyoMMTpyQuuLZIUpwoWSl8uLwy6lAlVZj3nJVqYy8bJxkEYG9M+pLn3SRY8lQFfnVujA9Ea3tkfD4a99PevVPaY9bYY38Gh7Tnjm/TnsGB/a3E21SVckc+noOyHPZVNkLAJBv19dZbqOuJZtXaSI9fbplTiXcIEMat9nntLa9+moP5umwQlVWfhtdoL3Zbfdr74K9KTyBIB141vhXOYSxJEDqD4FsfvCg9g4s/SG1ST4T0Ud6/XTP+l8SnoujBrnN4bl6X6q9CF13h8cJ7GTCjsGuwdi8LOxi6P2sW0OeX0pkHJc1Bzr+Sl4y1lxXXhlK3mQt8cqc8PkXN5NHrEN7dKFqI1BCplWSEcFhqpI8QrZDedvzpKXMXnGZfMoJ6tU5us/37x/uVztce9G2DOkx1XH3UHgdw9o7xRUJrZRqjFGSKtkoTsirXx+23+/SXqpYT1fXRFUtS/vrSq1K41mQZ9DfW99HtxTuX/+Mbmdugzw/VbcM5pO97JHPtED3lhJalVZ1y5MUpXyUxrn0sFb303aT61q4a6WdoEqtbIfUNZfbdfXO0QXh+f2K8antFngBYPtATXpxJ8ijKvXbOVna6uUoedhXLaohIageSCDFCgTVj5n7p6Hot9JHV/UAgFBgI4KsaTDRofdvfizsP61PEhtgvbYTyt6Iqu4/owv0O7hxXfhurbbrc+bXkGe8GtoRj+yF26/fjUFLuJwrM8eSWEvhvcqs0/Yyo2wCJ5CzDZUsgkqnbhPPZdwxWbOGxiYoaIZyeP7Rg3TEr+mOZ+lc4fOptuhzVprDe1KX1fdRVW0HACHrysRGIc8J5ZyuQHUvLEpSVXZm62mLomUdf+G5jJz/0byj7vFw/eBZ86JlfmXHKrMba2FgYGBgYGBgYGAwjWAm8AYGBgYGBgYGBgbTCLOLQpPJxJIWFV3FolCqRcmjnkzaHJ+nqRF2TSeqOVK/nDXbA0pY7Ts+1IjuuEeHxyxKpFRhVS7JrHROBSXN2G06/Kz03/2cDutkB5Ka7a2/0e1oWKfXq/BwZVGzPj4ltCrt5NEjtM5pw8owu1KMU0Icwd4UXl9ln8W6nZQ5YsnDtzypQ2lrXqu7XtuDYbio4SmiAxBdRyX01lr1c4pC1haVs6bS1dZaSUcgWkswp1nvL+kKsaRlSgi0JRuCy7Ez7UjRoiyiR4lm3Tca1oUH6LibkmVkSDU7pikAdlkm//g7lrRi8OLh54CRhWH/y4zQeKdy6APHh2Om7yhNodrnOup/svy1vXUoWmaVqE7C0rAvbD1U+0jyB+iQt/u7ZgBA+8O6z7l9MpRLFJlY+FnRMIgKZlGfg9R5zz9L4XiipnRUwn739P6UOMtvANk/Y6F9Wh21hekgqvQ41arI9GsbO+fZsK21JZrCsvFtOrzcviocJ4UNlABOpdEn5oTtz4xrg9LyoKazWKPhmBQNus0TMqms7jHdTnuAdNhV/Y8C2YsRSs5zwgS24gYqbV4ie9RQL9up7y3fxvFDQ2pM8QlKcGeqk6RZ5rcSZc8Jw/xejTkCBrsKQWcLAicHeyi0z14Dv+Pl2N5MtCl6HweSVsbvckbPuw8I15NJn/9LPSYK62XC6TD1uUZKeJX9s32V7r/lrnDM1q0doe30OMltCpcv/JVOnPbyyfd6Zpj6MdmWoFmenwc8jYmJfcP5gF3V4zDL4huSUihaksmf1qAee163prs4o+GYKDyn780z5+rE7ooc+3t/X997x+O5Vmhb6jbTNVFyaG1+eC/WnKmX5QbCG9G4mmpl0PyrcthSAED+8U10HVTLQ85LLDoP181Q2vy2p98bMTp0GuRzaFyjj+PVTBKrgYGBgYGBgYGBwYyDmcAbGBgYGBgYGBgYTCPMKgpNrbMRIqPDx5nVG8MflBnNGsqKItP0BIdXSRNUakELolGMLtUhbbcchpuqpD6RI6UTS6rccMhcHd0i3eKgQ7fJXhdmP2eZzlLU4WPhyDLMjbqdXoEUHmRbLIrUcshaqcNMdNI+py8GAHSs1KEujrQJmVGdG+AS6noL4Ya/c6S9uvcP6PokHYi14UG/HUnxUbr6AGDJEFP7vaTqQ5ndmB+G4rgMsj1BoX8Z/lOUJAAI2vV9bnou3Db/iNZz5TLOqqy8UioCgPVnap18pT6zeDWFzmXItUjhMSF1ri1uu8EuRftD48hNyDG9USsEZEltYO/BUGHkudfrsTmyVJvL5sdl+Jh10oUeVE33hn/dig4Jj71EP/fj33cPAGDlpYdHyxq2ynMxnYrGUdS/SX9c1On2KWWqibnaHlWa9Nj2CuGx2hZrasdYn+6zQlI77O2EfEUlGYbnMLKVUgJ93Sm6TQUW9vnrE4ljNoxpFZqJ00JlBp/UnKxN+gDqvBZpUuckTXDoKK3q0Pwg7ZMLDza8vx7vuUFtt/Obwr7BqkQxKpP8WdhAtBxPP3vLD20w0ykD0rJW6D+I1DfkMf2q8antDpTm1sHN5OHtFT4XP0+KL49KKhvbZLLztqRQxdbTHEK9W5ufpfchY11IzwioT9lM482FY5KpJULq1HvNKTRSaEpo/cp10bKRozQNNgK99/3OZv1baqkPLdXv5fZRbbuKz8n3JWnf8/tQ2SyLKHt+V0hhCZo1fa7Sqo9f3xNS/fi92/4g0X6c5FjgWi9Cqtq547pNE4doZahANqVzHz32N/fKc9E7uNah5xo9x4bHX1DWbVZ1AQDAllRBpjjHbLSk+NSv18/Wo/o5rppOBLrvKNpRcZ2eZ3r+dmg3qj07tJWBgYGBgYGBgYGBwR6BWeWBz2wZBbq0x6q6f/i1xl9YLiV5qOprVkV/bQ0dpr/MtpwZbpt/VHtv5p6sy2lu/UWYzJQf0l+lte5mfXw/6XVVDyTgimRc8U1+6YtWSl4jT4D6Euekr8KjPdHvvKx6VqIqg8X12jNevz78Eu87iLx4Uir6iQu1Fym3RXedJT8JPQXZIUrKosp2493hPS9QO1WlVADwZFLe1pfqr+vMy3UCUednpWdwI4nHq2PRl2xMy3lu2GivVT/v7CZKupHJrUGbvo+s25vbIu8JV5vjr+5sMnrS9hh5AjrCZx40ksdEJfpQ8tHIMpkQV3OBB2Cwm2BJ7xV7wXg0Oo+vAQB0de2n96ENVP+2OyjBfCvXBAj7R3G1Xjb6K207HntL6G0ptWvb0DCW0ucowSoCVzLlRLhC6PFS2ugAUOjVY3K8O7QdvQ9rj1CGc2Tbw/V1Q5RoP0I68NIL6b9k72iZuy4ck1ZafQsgihbUb9SLOm/V9ihQNjaXnrjb9lDYloCS9vmeWIWkZ9vZEnpQg2Xasza2r35OqlJrzynaC9fUoa953gdCzzon5gqKelgyUuFRJVX2wqkKltZW7UGNvLYAMBIev6Wgk3lHFof2yApMJG53YGyeCyfrwpPdzqXuO7xf+E5oGSMvKL1bJpY0h4tI/GF4se6/HQ9X5Dn0+8zdSydv5uW7K5YESxH3KOmTxoHqXQPH7BMtq+8hO9Amx+5Tuk8X1+kofaUjH/sLIFZ1dVxG3At9+pociljXZN0Vl6LgNte3kWOCk8nV/Kbcru/N2DzSse8J7dXEfL1Pjmru5NcPhW1bRjbW0+NjdEFoB+r69DFzA+Qtr8haLdfoe98lo5CijuYaVK163u1ybBNrYXShvmet0jZanMDLogOyeu9El7ZRpQ69vrmlGwCQHaB5phzzTr+2N/ZUe+DXrFmDd7/73ViyZAkKhQKWLl2Kz33uc6hyKBLAunXrcOaZZ6JYLKK9vR0f+tCHEtusWrUKxx9/PAqFAubNm4dLL700om0YGBjsmTA2wMDAwNgBA4Ndg13mgX/iiScQBAGuueYa7L333njkkUfw3ve+F+Pj4/jSl74EAPB9H695zWvQ0dGBO++8E/39/Tj33HMhhMBVV10FABgZGcEpp5yCE088EStXrsTq1atx3nnnoVgs4iMf+ciuar6BgcGLhLEBBgYGxg4YGOwa7LIJ/Omnn47TTz89+v9ee+2FJ598Et/4xjeiQXvLLbfgsccew/r169HdHYYWvvzlL+O8887DF77wBTQ2NuJ73/seyuUybrzxRuRyOSxfvhyrV6/GV77yFaxYsQKWZaWePw1BYwHZrTrxaOjwMKRd10Ple4nWEsiwblmGzACgWk+aoAPh+lIXldzO6tDHWF8KzSMWapUhEwrHKG14Gzps5Lfp8KtoCMNWtcaU0DoAX4Z+HIrCi0a9/8i+TdvuAqeWSyxj1G0O/1badFjJJsdIaUEYxh5cprtT/QYO44eN2fJyfU3ZEX1PanXhPalRDmvlUb1t4/wwrFYcTIb2OZHGJi1dSybVZAYpiZS1mGXo3h4gCsI4hTSLsjH1FBIkTfmITkNh0OLjenW+N7znNUo6ykl6k71BJ07mZWlrz5sk4WkaY0+0AQDg9o0iaGwGANhNRKFKoUyMd+k+P0hJqO0rw+fWuEb3ebeeE9lk/6e2tTylbcOaO0L6RI6YFZX9wqTL3JOaYhKjbaUlzxGcwTAUnGMbRiXDm+4Nk+ea7tbHLO+nE0ajJHNKRLOY+uGH1+SM0DiS1IJgvqaT2JSorzSQG9dQ4m090cpU3Q06pyjrMe0Mh+dyqUZDLGlM/maqWiDpS+6E3iczrp9dbkNIsWm5X1OahpbrfjCvKGtIMG2GdZ+lV1jVcAAAv45epfK0AdeYIFqUqvuRW68pNu5cef/Ibs8U7Il2oH6DBzfjYWC/8LnVb9LPsn5VKBQhhoajZfz8c3KciwzNBWxKJpdUzFIrUVTm6nfH/IFwTNlMleOETVlvhJPiVWJ407P04qXLdUdlXROirirteAAYXhwuD2jaMOc+PY6zUsiCxwnT86wmot4o2NRmZQeotsL4wnBsjy7QY7uul65Jjun6Z/R9Bo1zRTUd79LXVNyibVfDenn/OIeUqC9je4dtZoGI3FB4/P6X0FyBTIstL7/Upg+aH9D7Dx8ajtPGJ2jORP3OqtTkPqRXnyFBkZxMvCW77IyH+8RsmL9j5JjdmsQ6PDyM1lY9Mfvb3/6G5cuXRwMWAE477TRUKhXcd9990TbHH388csSRPO2009DT04M1a9bstrYbGBi8eBgbYGBgYOyAgcGLx26bwD/zzDO46qqrcMEFF0TLNm/ejM7Ozth2LS0tyGaz2Lx586TbqP+rbbZFpVLByMhI7J+BgcHUYnfaAMDYAQODPRFmLmBgsHPwgik0l1xyCT7/+c8/7zYrV67E4YdrfeOenh6cfvrpePOb34z3vOc9sW3Twl5CiNjybbdRSSuThcwuv/zy1DYGGQd+qw5TNP/xGXWCaJm/uCv6veUIqZlOssyCxBCcCZmx3KzDOuu/tTT63f6QVKDo0ZQJzNMGKNIA5/BwCliFxpGZ8cLVIaCJLh3ecqTCQutKrdgSUGg/MxpeTG5Qh7mdAaKmyNBOI5UJzw6FIZ6Ou3W2drVTh9YdqcM6Z4TUfAb1tluOC7PAJ07S9KWJR3X7O1eG+2eoFH1xI5WRbpMatUfpcH/TI+E12QNkkFmLWoXxWR2DqETlBc1h2yt6n8zTVF5ZGnqrTXuJQGWcFZ2AKTYgCoYj+9TQfvqcmYHwOjicnl83JA+9Y1nnewKmgw0AJrcDE8vaUd8fPr9grlYosLn/SFWI/JAem3XrdP8c2i88PysMWD4rEsmwKIVP81v1M97rf0JZlvKBWrd4bL4Ks2sv5NDe+phqbNdRGLmwhsL8w+H4Yq+MTYo1kaoF1Y2o1dM4l2XGhaPj7IJsx/iikFZW/5wex0KWYLfHiFZDIeuxQ7oT5ymsSeGJTEILsgaGkgtJk9tvUXUtSD1DlmjPjujtcs/16/3lfZr7f/rYbmlZ9Htir1AdI79F33t7MykMSVqQs1Xv7xDFYvyAUAHLXqBpOVbK5dmkYqLqdvjVF0YHm0pMBzswmQ2o+9tTcK0sik+0qQNzQ8I/VM9AEP3SHpfv4Kx+5u0Pk+0fCt9985/Vz3frcfq9r5TH6oq6f2bX6f6lqDOxd4+8Th5HA/vr33PuD9tcIXvUt1y3Ly+l0HMjTBHW+1caw7FfO0+PE/E/+n1b9/RQ2KYRrolDqm/SDowt1jxYRcfpXKntnruW5kJlubxZj5OYaltveM45f9H30W/WtsvpG03s49fTmPXD62+7T1PV/IbQngVZbdfGuvV1ZORUqO0xUicjtZ6MpCpZ43peIQpErZUUGpvqQjgVfc/zfeFxB/fXbW55Qm5XJo19a8d86y94An/RRRfhrW996/Nus3jx4uh3T08PTjzxRBx99NG49tprY9t1dXXhnnvuiS0bHBxErVaLvqy7uroSX9e9vWEn2PZrXOGTn/wkVqxYEf1/ZGQECxYseP4LMzAw2CFMBxsAGDtgYLArMR3sgLEBBjMZL3gC397ejvb29u1vCGDjxo048cQTcdhhh+GGG26Abce/Ko4++mh84QtfwKZNmzB3bvi1d8sttyCXy+Gwww6LtvnUpz6FarWKrPSK3XLLLeju7o4ZB0Yul4vx5BQGDyiiRt7qrnvCL+CAklHG5+qv4pp0ns69S39tVVpJg9iXiSV/Js31jVStdFR6ofOUADJC3m6poxqrYtgZ3luvVX/J2hPJZBeuUlbs0e1zn5EJcOTREk36ay+/NfQkKC9CeKH05Se/UO2K/oKc6AzvZZG+KrmiW5AN2zKyRF+nn6fkTenFbP8Kaasu0geoycRgj6rh+Tn6Kpa61rmtVPVSej9Yi5k1YlViiz2hv9irc/RvPx8eP/8slYUkL54ltelHDtJ93SYHvNJ5b39ARwDsLXRTZAIcR29G9g89DU3rN0XL1HP2vGT1yj0V08EGAJPbAafkQ8ikSaV9DgDl/bW+ufKYDhyg+2Tb4Vui36qiX/ufKLGbkkcn5oR2Yqxb7z93kMaxvA9cnTgzFPZpTohUXncAKPSFnSm/We8TNNKYk1GxTB8lT3LV1AZpU6h6rE1jpvfI8Jo40c2lgs+ji+W1UWXolifD42e5eiw9Y5VIyjUWQF48VdHQamrRbeY+oiq9UtSAI1jOcNjAoD75nGsNpA9NFWtVfQ9USG/+fh3JEPnw/lfbyG7262diqbawl4zsrdL+r1EFbrtG9rQ7PG5xnbbbjWvDtnq16ZPFOh3swGQ2AEEAWAHEgHxf8ztQ9mXW7ueK3SITPit7lAcHHbpZ2vR6qmq6kjzs0rPvN+j1/hzthXbUO548u9bm8D3V8KgeR73n6DmCtTLctviw/sDJ9evoonpHj80jTfZuPdDrtobXP3BHh76QNhL3mAg97BZF3lkTviaZDdUGStiUdqzuMd0mQRXklSiEiI1NSmItleQyYiAMUsKrBPcljpQV68IPNY8ScGsN4TVnh7W9aiDTpRgKGWIoVNv0/tFcke3dBv1eEAvDvisootOwRl+zmrd1rCR7I9vPybaW//ysDIVdxoHv6enBCSecgAULFuBLX/oStm7dis2bN8e+oE899VQccMABeMc73oEHHngAf/jDH/DRj34U733ve9HYGHboc845B7lcDueddx4eeeQR/PSnP8Vll132D6lPGBgY7D4YG2BgYGDsgIHBrsEuk5G85ZZb8PTTT+Ppp5/G/PnzY+sUb81xHPz617/GhRdeiGOPPRaFQgHnnHNOJC0FAE1NTbj11lvxgQ98AIcffjhaWlqwYsWKWFjMwMBgz4OxAQYGBsYOGBjsGlhiFpQxGxkZQVNTE06eez7cOiq9LfXZvbnN0aKhfSjBqxh+1Tc9SxrGlJQ2sE/4/dN9J5XAfXKdPr4Ms1gFotCwp0DSNMBhU5kMJUhzvDZHh62y62WIKEO6xC4FUjbJ0uYFHf71FuiwmC0TYm3WciYoHdlauz7n0DJZprlXh7JsCu17MuG10qSvLTes1zc8JUubU9LP4HJ9/HFJM1jwOx1WGl+k19ekRm1xsw55u6NKi1m3acuxOgw/eES4vvMPRIkq6PY1rg3XF1ZTsm+TDklOyPNXG3UYPt+vz+XKxN3sJkqi5aqBMrw+vpz0seU9KzyjE4WCYnhvPb+CP676IoaHhyOPk8HORWQHln0Yrhve99Ki5mi9n6P+K+ku1WbdfzYdRdQWGT1ue1SHUgu9Ouw6tE84/mwa2m2/fzr6HcwNxySH0TOrw8RWrm1gkU49lE3gEuxU+0DRvbyCtgetf9dJY7XOcFum3/W+VNumtsfDxhYe1Tr0QZumy1Q7QtuY7dchYWVHRJE08IeYTyDibQeAEVqvbCMliAs6p18Mw+teg34O+af0mI20uudpTfdNJ4X3ge9915/0PpBheME673M0FcSXlMOhfbQ9aFivn212jRy/eX1NHDK3+kNahujQ9shvoOS8mnwvcKn6DkWlK+OOv/67sQO7CJENaH8XXDsLSCqOoDEV6fzXkUABUWgUXUps1XbcymsaSG2fsJ6DRbQpVc8AAIKGcFuLKHf2EJ1fUmd8Ss6MzkPjpNyp1xd6JhLHYVqX3x6O/UqrHqcxIYs1MhpCydj+PE3BieotkH65XWJqi5wDMfVD1Xbg9yLR1lTyanWu7udM/9vy8vD8HQ9QgvCzVCNDPhNFaQIAa0zbzqA1fIcPHaCP3/RUeHy/oK+z7yX6ntRJGmzj0/qcG0+gGhG3DQEAbEpi9Yj+1H9Q2GcaNpDQwDo9R+g5KUxM7rxHX6erRESIxuUFFdz23FXbtQO7VQfewMDAwMDAwMDAwODFwUzgDQwMDAwMDAwMDKYRdhkHfo+EEFp7FIjCOS6FUouN8/TmMio6skSHbz1KaPcky4PDMTarvygKDYeV2nVYtdoVhkYG9tchnOKWcJ+6jTpMnekj7VUZymLajNeiQ30uJF2GwnNuP+2vVCn4PlDYzLLCY7FqglsOj1X/sM625qx5uxbelIYndKjIGqQwuby/9lxN5XFLpI3aH15Tea4OWdc/NaSPtSnMwA8WEh1F6uFz2Kn5ab1/11vCUNtjJ+jnuf+XKYO9R15LljSlF2jd3dxA2DfqH9QqNX6XfnaOVPvhcukgvVhrcZgB73IJ92clnYEoVVbURyir3WDXYnAYyIZ9MtenB/TAck1HyY6E/cod089l0e+0nehfHoavSx2kb76VFGseDMeCIIUEplQERRm6Z/qbDOdz7QIO7as6A9YkdJRGWadh5OhFej2Nj8yGkNrBVLGWp6lEfJ+kwzRr+hpIPcadCI8lSB87ohNQGFt0NEe/7Q29se2AbShCStOdlCaCHMngyDHFtJmgV/9W1AWLdOjrN4TPjClRrNmt9hHdmjZTayD9aKnPPj5X799/kF6/7AZ5TlatStGrZxUah+gGiobgjun9lWKHV5tdr+SpgrdkLuDm4UjKRexZNkmqWROp0GzW74Go//I4oHeo6usOKb1ZRB3peU3Y77rv0GO3vETTVTIj4X5jC0ghqzW0E+0P0bxgRPcpvy4cM7VG/Q4bWqb77Jy7w7Fft/JZpEFE449pNdreKcpfpo/e60yHUe/RGF1Gjnka2xGlDoDXFt5fL0+0nAZ9zaNLwm0zE9peNWZ0DkWlTdLriBoriKGcHwjtQOu9pDQn6XNct6HYsRDbYmyRPqfPDGjZT1ghyCE6cuetQ2Gb5mgaYFAg+l+/7BtjPA+V95nvXUC/nwfGA29gYGBgYGBgYGAwjTCrPvcHj1uIXKC/SvMDUqubtEdL7fqWKA3oBspLdejDaHRR+J/eQ/Qn2vznqKqY9NiuP44SMimHtijzMTrv1Mkwo/uG+wwcqPfp+Bt55PLya46SpjKbKZFSLSfPnOAvZfU1TJ5nluBSiTkuecka7PDr2+tq1vuQRy2/St4gWsaeaVsm61qbtOesuV97w0ePkIU1KGpgVeirXSarxKqs9civavJwWvR1/1xf6NHIbWJvnv4ZaTmTd4C/3rPrpT4wHZO17yE1gm1KXuIv6Fp7eM1rztRf6su+IxOJ5uiv+/w6eR/o2g12MerygKU016nqKDnUJjrD59b8EFXwpDHRtVFuzB5yhuyz1S494J31OoLllsK+Mn6ATr4cfE3oOe/8rTY4QZ/WNY4S5SiiF4tKSQ3kWKXUAmksS/10m8ZeHVV5Vm3NUrI4e9Ydqq4cQdkRsqFekz5nVo4z0a/rY8Q8l8r2UJJgpUPb03yPvL8l0q4nfW6oe0Ka7I2PhfdhYilFPMgDX9snvGeqFgQABK4e/MW1YaTDpSLOXrOOxNSkFnZ2M3kjOcIg73N2ta73wPClqEBQ1PcpNxCezPHKqfsY7FxUm7MIMlmgORznuTptpzcdE46D7j8NRctYv1y9M1goQrTocW7JocAV1Pl93fx02JcqpC9e2KD7klUO+09zjx77gay9wImvbp9un7cwtCOCvdkkNKHaoqq8AvFKs5EmO1cup3fblpc3AwCanqVKq6PaQ6+ST1l8w5K2S1AU0CLxDXddOB/w9tMVX51Rff6lN0khgXbNMFBJogAw5+/hvMce1s9mYm8dyVARRVV5OQZ6VzesplouUtt/9GBtVztXJu1hTASEjhXI6CNXuXWH9H3Kjsoqu1RBPtK7Z7sW7FhE3njgDQwMDAwMDAwMDKYRzATewMDAwMDAwMDAYBphVlFoCv0ecp4OZY0sDkNYlRa9rPVxHQ6p3xiGO7wChZGrOgQ1dET4d583PRUtu2/ZXvqE9cnEEIzokH2xJ/x+Ks3XtJu6jWE4JTOmQ1EBhfdUyJ8TZ/PP6jC/Sq4o7bNYH/MJ0kBWIbIsJcJRWMtS4SBKclXJb6KRyplT0pii6LDevUXHV2E5QWXd7Wad5FFcE4a47AEK/dfp8GRpcbgta7I3DYXJOrFkXnpOXdeG4b8sHbO0QJ8zK3WZ3Q06wSW7Tocso4RUTvCtUVhLhiLFJBSKsfky0a1LhwQHDg7Pr5JrAGBkeXgdXq0MPJl6KIOdjKCpAZ7UT+eQNNPjBt4cPtfMhKZhFO/foDeQNBZFlwDitDFH9v+x+TpRsmVrs95fhtRVsnTs9ziFZ7lMhzxXsFQnXXF4OadC9pNUpQyaZIL6AHHBiCKTGZKhXKK7OAN0LKVBTaF1pdlukz1w8lSjQobULRrPnMSdRkGyqHmKjpMdp/ByWt0M1qGXSWF9B+p27P1xrYf/5Orw/rXdo9eP7E33+Uh5TcSAyG2m0L/UvGZ6Edp18mCU+MuJ/ETVGzggpCFUmvW9VZr1fjUD3AeDXYzcQBmuC/S/JLQDWw/R7+XcUPi31q77bHY99XkpwGDN1fS3aqseh6rOQtCl3+s+UVucStjBa/WUAM9jVo15GmeKJiLqaRzxmJLvq1pRH7PYq98zVVlLJsuCGkSXUfUe7F56BxLm3DuWWObzOJcUtVqzHod2c9g+1o7PbhzSBxgOaSQqaRcAyvP0PctvDNfnn9Hv6PbxZn38PkkFJIpO3cNko9PsYEt4nf0v03a5Ya2+D1lJ861/WtMM+b0v5NhWthQAvAZqk5wfZnr1/RJ0n+o2STtJdt3KyefMidCGQmNgYGBgYGBgYGAw8zCrPPD5NQNwHf2FWJ8Nv1/qevV3zPhc/SVeag2/tlxyoDc+p70/+WfCbR9ZuyxaRimNcNeFX54O7S/ok8mR8oxuib7wMuEG5Vb+YtdHzWwNv+ycElVqnas9y678mnUm9DHH99fyjYVN4Zc8fxVz4gg2yUQ7riyopNpKKbJRoMQU8ggoKS4AkbfSGqZkW0rY8BrDZ5KlxBBrSG+bG5DVSilpqDyXPHLbXBtAX+djelmhrL+6x/cK71k9fbBjnLyBUt6utFzLUGZG9LO3t8qkIPYGkpet5f7Qa+BUdFKNJb32earYOb4gWW3PYNfCnqigKiVDOaozukD3+Vfv9RgA4PcHHRktK66myowj0sOyoCta5JCnRkm7+hToGttHe/Prekry/Hoc1T0eVkMU1I+4GqToCvtSQIm3+Sc363N2h+trTfqkOVJQU148v117uTgZXXmXogrRQCRdCegKlejW9kRVP1YJZQDgkGytkLZBNFNyPyVvOio5sKxtC0suKim9lgE9ji2W2ZQ2hxPk0Ra2qdCnr+2xO5dGv7sfCsdhwxrdzpYnKRLRL6s1ciVMctDbqtIsRRl98sjZ8lo4sZGlN7Nj4cFUpW8AGFsULgvKJpl9d8DyAljCR+uj4bOemEueYzmM/SxFdw/Q0qyqfwY0dgb3o6qofeEBVAVyABg6UkdoPNlVun+xMVpWXaTfE153+G6ru3+NbrD0zlosycgeeNmWug16nHB0utIhpVOd5mhZjqqIRzKaOZrB0PuwPEeyFchessxqZjxcP+fuoWhZJPVM8sqq0jugkzZtktv055K9k3KynPDpPqftnYrsW536vY5ReoerSEh7c7RIRVV6T6QE3F9T0v2TSZluTtBXif4ByevmN+tzRm2lvuG16UiNMy5twwRFWWUV6cGX6j7gV8tAuuJnDMYDb2BgYGBgYGBgYDCNMCs88EJ+DXlBBYD+cvKkZFdA3zF+Vd8SvxJua7EKI3lc/Ur4pS3oo5hhqQ/LSTzwflW2y6OCD1K20CMJKM/TDbD8cFtBXDbfo8foV+U+5D2o6a9mz5fX7FHhFZ8bqM5FHvhAro9JHdKFqKIDAR2HCxOptnJxAtpWPQeb96dtfbneq1GbvCRHzPG1Zy46Fh2Hr9OryWNOck4lH+mRrJvl1RLbBoL2EbpNtjyXOg8AWFFdC71MXZMvtxPCeOB2FdgORM+fxoZfIY/VWE0uo2flJ/sK9ykuxqXGn1/lcUhSi1GfpnEu+6KgPsUFZtS5fMrjSRtHHnmMYmNC7e+TfBx74KWOqphkTETtomv2q/KcKecBAGEnx2lAdkREtoPuE40Pac5i996i9glfeul47KrrrBLHt0x2Xz6H2HlYUi/tPvOwTLGHvq/bb/tkJ6LdyQbLvsd9Q3neg7KxA7sSkQ2QzziQ7xE27arLcjFDtv3Cly98ekTc1zwZifNSxgkAqOHnpYzdcH9Hruf3kXqH8gSCx0z4m4tGCrDtUS8fPR6d2DgNz2lNMvZ1n2V7STkcKeM0sgOkzyxI7tWKbCjZwBrbWzUv4Hcs2yuZe5dil8Pf0gPP7305poMS2wM9f1L3PIjZdT3B87zQ3gR0Tam2iT3w9GyFtA2WeH57taPzAUvMAkuxYcMGLFiwYKqbYWCwXaxfvx7z58/f/oYGLxjGDhhMFxg7sGtgbIDBdML27MCsmMAHQYCenh40NDTEiha9UIyMjGDBggVYv349Ghsbt7/DDIa5FyF21n0QQmB0dBTd3d2wbcNs2xUwdmDnwtwHDWMHpgeMDdj5MPdCY3fbgVlBobFte6d6MxobG2d9R1Uw9yLEzrgPTU1N29/I4B+GsQO7BuY+aBg7sGfD2IBdB3MvNHaXHTCf+AYGBgYGBgYGBgbTCGYCb2BgYGBgYGBgYDCNYCbwLwC5XA6f+9znkGOt1FkKcy9CmPsw+2CeeQhzHzTMvZhdMM9bw9wLjd19L2ZFEquBgYGBgYGBgYHBTIHxwBsYGBgYGBgYGBhMI5gJvIGBgYGBgYGBgcE0gpnAGxgYGBgYGBgYGEwjmAn8NlizZg3e/e53Y8mSJSgUCli6dCk+97nPoVqtxrZbt24dzjzzTBSLRbS3t+NDH/pQYptVq1bh+OOPR6FQwLx583DppZfOiBLZV199NZYsWYJ8Po/DDjsMf/nLX6a6STsVl19+OV72spehoaEBc+bMwVlnnYUnn3wyto0QApdccgm6u7tRKBRwwgkn4NFHH41tU6lU8MEPfhDt7e0oFot47Wtfiw0bNuzOSzH4B2HswPZh7ICxAzMdxg48P4wNmGIbIAxi+O1vfyvOO+888fvf/14888wz4uc//7mYM2eO+MhHPhJt43meWL58uTjxxBPF/fffL2699VbR3d0tLrroomib4eFh0dnZKd761reKVatWiZ/85CeioaFBfOlLX5qKy9ppuOmmm0QmkxHf/OY3xWOPPSb+5V/+RRSLRbF27dqpbtpOw2mnnSZuuOEG8cgjj4gHH3xQvOY1rxELFy4UY2Nj0TZXXHGFaGhoED/5yU/EqlWrxFve8hYxd+5cMTIyEm1zwQUXiHnz5olbb71V3H///eLEE08UBx98sPA8byouy+AFwNiB54exAyGMHZjZMHZgchgbEGIqbYCZwO8ArrzySrFkyZLo/7/5zW+Ebdti48aN0bIf/OAHIpfLieHhYSGEEFdffbVoamoS5XI52ubyyy8X3d3dIgiC3df4nYwjjjhCXHDBBbFl++23n/jEJz4xRS3a9ejt7RUAxO233y6EECIIAtHV1SWuuOKKaJtyuSyamprE//zP/wghhBgaGhKZTEbcdNNN0TYbN24Utm2L3/3ud7v3Agx2Cowd0DB2wNiB2QpjB0IYGzD1NsBQaHYAw8PDaG1tjf7/t7/9DcuXL0d3d3e07LTTTkOlUsF9990XbXP88cfH9EBPO+009PT0YM2aNbut7TsT1WoV9913H0499dTY8lNPPRV33XXXFLVq12N4eBgAoj7w3HPPYfPmzbH7kMvlcPzxx0f34b777kOtVott093djeXLl8/oezWTYexACGMHjB2YzTB2wNiAPcUGmAn8dvDMM8/gqquuwgUXXBAt27x5Mzo7O2PbtbS0IJvNYvPmzZNuo/6vtplu6Ovrg+/7qdc1Xa9pexBCYMWKFXj5y1+O5cuXA9DP7/nuw+bNm5HNZtHS0jLpNgbTB8YOaBg7YOzAbIWxAyGMDdgzbMCsmcBfcsklsCzref/de++9sX16enpw+umn481vfjPe8573xNZZlpU4hxAitnzbbYRMWEnbdzoh7bqm+zVNhosuuggPP/wwfvCDHyTW/SP3YSbfq+kAYwd2HowdCGHswPSDsQM7B8YGhJgqG+C+qL2nES666CK89a1vfd5tFi9eHP3u6enBiSeeiKOPPhrXXnttbLuuri7cc889sWWDg4Oo1WrRl1hXV1fi66q3txdA8mttuqC9vR2O46Re13S9pufDBz/4QfziF7/AHXfcgfnz50fLu7q6AIRf1nPnzo2W833o6upCtVrF4OBg7Mu7t7cXxxxzzG66AoNtYezAi4exAyGMHZi+MHbgxcHYgBBTbgNeFIN+hmLDhg1i2bJl4q1vfWtqlrBKWunp6YmW3XTTTYmklebmZlGpVKJtrrjiimmdtCJEmLjy/ve/P7Zs//33n1GJK0EQiA984AOiu7tbrF69OnV9V1eX+OIXvxgtq1QqqYkrP/zhD6Ntenp6TPLaNIKxA5PD2AFjB2YLjB1Ih7EBU28DzAR+G2zcuFHsvffe4pWvfKXYsGGD2LRpU/RPQclGnXTSSeL+++8Xt912m5g/f35MNmpoaEh0dnaKt73tbWLVqlXi5ptvFo2NjdNaNkoILR11/fXXi8cee0xcfPHFolgsijVr1kx103Ya3v/+94umpibx5z//Ofb8JyYmom2uuOIK0dTUJG6++WaxatUq8ba3vS1VOmr+/PnitttuE/fff7945StfaeTjpgmMHXh+GDsQwtiBmQ1jByaHsQEhptIGmAn8NrjhhhsEgNR/jLVr14rXvOY1olAoiNbWVnHRRRfFJKKEEOLhhx8Wxx13nMjlcqKrq0tccskl0/Zrm/Hf//3fYtGiRSKbzYpDDz00klSaKZjs+d9www3RNkEQiM997nOiq6tL5HI58YpXvEKsWrUqdpxSqSQuuugi0draKgqFgjjjjDPEunXrdvPVGPwjMHZg+zB2wNiBmQ5jB54fxgZMrQ2wZCMNDAwMDAwMDAwMDKYBZo0KjYGBgYGBgYGBgcFMgJnAGxgYGBgYGBgYGEwjmAm8gYGBgYGBgYGBwTSCmcAbGBgYGBgYGBgYTCOYCbyBgYGBgYGBgYHBNIKZwBsYGBgYGBgYGBhMI5gJvIGBgYGBgYGBgcE0gpnAGxgYGBgYGBgYGEwjmAm8gYGBgYGBgYGBwTSCmcAbGBgYGBgYGBgYTCOYCbyBgYGBgYGBgYHBNIKZwBsYGBgYGBgYGBhMI5gJvIGBgYGBgYGBgcE0gpnAGxgYGBgYGBgYGEwjmAm8gYGBgYGBgYGBwTSCmcAbGBgYGBgYGBgYTCOYCbyBgYGBgYGBgYHBNIKZwBsYGBj8A7jxxhthWdak//785z9PdRNfFP785z/Dsiz8+Mc/3u62l1xyCSzL2unntiwLN954Y+o2r3zlK2FZFhYvXrzTzmtgYGAwXeBOdQMMDAwMpjNuuOEG7LfffonlBxxwwBS0ZmahoaEB119/Pc4777zY8ueeew5//vOf0djYODUNMzAwMJhimAm8gYGBwYvA8uXLcfjhh091M2Yk3vKWt+C6667DU089hWXLlkXLv/Wtb2HevHk46KCD8Nhjj01hCw0MDAymBoZCY2BgYLCLYVkWLrroInznO9/B/vvvj7q6Ohx88MH41a9+Fdtu69ateN/73ocFCxYgl8uho6MDxx57LG677bbYdrfddhtOOukkNDY2oq6uDsceeyz+8Ic/xLZRtJaHH34Yb37zm9HU1ITW1lasWLECnufhySefxOmnn46GhgYsXrwYV155ZWrby+UyVqxYga6uLhQKBRx//PF44IEHdui6f/jDH+Loo49GsVhEfX09TjvttB3eFwBOOeUULFiwAN/61reiZUEQ4Nvf/jbOPfdc2HbyFSaEwNVXX41DDjkEhUIBLS0teNOb3oRnn302tt2tt96K173udZg/fz7y+Tz23ntvnH/++ejr64ttp+7jo48+ire97W1oampCZ2cn3vWud2F4eHiHr8XAwMBgZ8JM4A0MDAxeBHzfh+d5sX++7ye2+/Wvf42vf/3ruPTSS/GTn/wEra2teP3rXx+bWL7jHe/Az372M3z2s5/FLbfcguuuuw4nn3wy+vv7o22++93v4tRTT0VjYyO+/e1v40c/+hFaW1tx2mmnJSbxAHD22Wfj4IMPxk9+8hO8973vxVe/+lV8+MMfxllnnYXXvOY1+OlPf4pXvvKV+PjHP46bb745sf+nPvUpPPvss7juuutw3XXXoaenByeccEJiQrwtLrvsMrztbW/DAQccgB/96Ef4zne+g9HRURx33HE77DW3bRvnnXce/vd//ze6p7fccgs2bNiAd77znan7nH/++bj44otx8skn42c/+xmuvvpqPProozjmmGOwZcuWaLtnnnkGRx99NL7xjW/glltuwWc/+1ncc889ePnLX45arZY47hvf+Ebss88++MlPfoJPfOIT+P73v48Pf/jDO3QdBgYGBjsdwsDAwMDgBeOGG24QAFL/OY4T2xaA6OzsFCMjI9GyzZs3C9u2xeWXXx4tq6+vFxdffPGk5xwfHxetra3izDPPjC33fV8cfPDB4ogjjoiWfe5znxMAxJe//OXYtocccogAIG6++eZoWa1WEx0dHeINb3hDtOxPf/qTACAOPfRQEQRBtHzNmjUik8mI97znPYlzKaxbt064ris++MEPxs49Ojoqurq6xNlnnz3pNfK5/+///k88++yzwrIs8atf/UoIIcSb3/xmccIJJwghhHjNa14jFi1aFO33t7/9LfWa169fLwqFgvjYxz6Wer4gCEStVhNr164VAMTPf/7zxLVdeeWVsX0uvPBCkc/nY/fGwMDAYHfBeOANDAwMXgT+93//FytXroz9u+eeexLbnXjiiWhoaIj+39nZiTlz5mDt2rXRsiOOOAI33ngj/uM//gN33313whN81113YWBgAOeee27M4x8EAU4//XSsXLkS4+PjsX3OOOOM2P/3339/WJaFV73qVdEy13Wx9957x9qicM4558QUZhYtWoRjjjkGf/rTnya9J7///e/heR7++Z//OdbOfD6P448//gUp9CxZsgQnnHACvvWtb6G/vx8///nP8a53vSt121/96lewLAtvf/vbY+ft6urCwQcfHDtvb28vLrjgAixYsACu6yKTyWDRokUAgMcffzxx7Ne+9rWx/7/kJS9BuVxGb2/vDl+LgYGBwc6CSWI1MDAweBHYf//9dyiJta2tLbEsl8uhVCpF///hD3+I//iP/8B1112Hz3zmM6ivr8frX/96XHnllejq6oooIG9605smPc/AwACKxWL0/9bW1tj6bDaLuro65PP5xPKRkZHE8bq6ulKXPfTQQ5O2QbXzZS97Wer6NO768+Hd73433vnOd+IrX/kKCoXCpNe/ZcsWCCHQ2dmZun6vvfYCEPLoTz31VPT09OAzn/kMDjroIBSLRQRBgKOOOir2TBS2fX65XA4AUrc1MDAw2NUwE3gDAwODPQTt7e342te+hq997WtYt24dfvGLX+ATn/gEent78bvf/Q7t7e0AgKuuugpHHXVU6jEmm7z+o9i8eXPqsrQPEgXVzh//+MeRV/vF4A1veAM+8IEP4IorrsB73/teFAqFSc9rWRb+8pe/RBNshlr2yCOP4KGHHsKNN96Ic889N1r/9NNPv+i2GhgYGOwOmAm8gYGBwR6IhQsX4qKLLsIf/vAH/PWvfwUAHHvssWhubsZjjz2Giy66aLe04wc/+AFWrFgR0WjWrl2Lu+66C//8z/886T6nnXYaXNfFM888gze+8Y0vug2FQgGf/exncccdd+D973//pNudccYZuOKKK7Bx40acffbZk26nrmXbSf4111zzottqYGBgsDtgJvAGBgYGLwKPPPIIPM9LLF+6dCk6Ojp2+DjDw8M48cQTcc4552C//fZDQ0MDVq5cid/97nd4wxveAACor6/HVVddhXPPPRcDAwN405vehDlz5mDr1q146KGHsHXrVnzjG9/YadcGhFzx17/+9Xjve9+L4eFhfO5zn0M+n8cnP/nJSfdZvHgxLr30Unz605/Gs88+i9NPPx0tLS3YsmUL/v73v6NYLOLzn//8C2rHihUrsGLFiufd5thjj8X73vc+vPOd78S9996LV7ziFSgWi9i0aRPuvPNOHHTQQXj/+9+P/fbbD0uXLsUnPvEJCCHQ2tqKX/7yl7j11ltfUJsMDAwMpgpmAm9gYGDwIjCZnOE3v/lNvOc979nh4+TzeRx55JH4zne+gzVr1qBWq2HhwoX4+Mc/jo997GPRdm9/+9uxcOFCXHnllTj//PMxOjqKOXPm4JBDDklULN0ZuOyyy7By5Uq8853vxMjICI444gjcdNNNWLp06fPu98lPfhIHHHAA/uu//gs/+MEPUKlU0NXVhZe97GW44IILdno7Fa655hocddRRuOaaa3D11VcjCAJ0d3fj2GOPxRFHHAEAyGQy+OUvf4l/+Zd/wfnnnw/XdXHyySfjtttuw8KFC3dZ2wwMDAx2FiwhhJjqRhgYGBgYGBgYGBgY7BiMjKSBgYGBgYGBgYHBNIKZwBsYGBgYGBgYGBhMI5gJvIGBgYGBgYGBgcE0gpnAGxgYGBgYGBgYGEwjmAm8gYGBgYGBgYGBwTSCmcAbGBgYGBgYGBgYTCOYCbyBgYGBgYGBgYHBNMKsKOQUBAF6enrQ0NAQldA2MNiTIITA6Ogouru7Ydvmu3pXwNgBgz0dxg7sWhgbYDAdsKN2YFZM4Ht6erBgwYKpboaBwXaxfv16zJ8/f6qbMSNh7IDBdIGxA7sGxgYYTCdszw7Migl8Q0MDAOCIEz+JnMhGy51xDwBge360zM/rW1KrzwAA3DKtz+qvoSAT/s6O1KJldtmLfouMk2iLM1bR//GCxPqgPmxftTmnj0OegsxEeHynpM9pVXX7rLJeHu1f0Ndc6agLj9+orzPI6G1zQ+Gx3HF9HGGH5/cKeh/h6jZZvizma+tlTkW3KXDD+2QFuuivXdPXXmkKG2BRTeDcAN0ndU5H33t1LIvuoXD0+dWzq7ToNkftBGDXwt9OTS8L6JoCeazsqH6emVF9T4KsI/9Smzx9LEf2A7tGfaeQSe4j74PnVXDXPVdGfdVg50Pd28NP/TREczgOMmP6+WSH9fPNDJYAAFZFP39w0Wo3fP5+vR6nQS453m0aBxb1eSG3rbTQOHeTHkG2N5nx8FgO2SPL18fkc+mF+pjl9nx4HnLo2NT/o/FDzeDzq/HjVPQ5g4y0DXXUzjG9PqNsLLWZ75OyLU6J7rPN4zgcv9UGslc5vd6uJtuk7EhA9oBtg7qOzAQ9+4GyPuZENdwny/aO7b4jl23Hg0t2W9A1qfFfIRtsS9vh1cq47/dfMHZgF0Hd11cc9GG4Tg6QfSGo0y9Brxg+l+wg9YnhicSxRIHGPs0bbPVuJnvh1+f1frLf8PuC+1LU18jcqGN5dTRl4/Vy99ygfm+qfgwAlnwPBWSvuE+qvurTO96jcWrJ89eKtIymL+p9rMZj2NbwOtwJvaFTpXEqbRfPC7yifg7uBNkE1WYax8o28bxB8CUFyX3U2PcKejzzOx7qOujZ2FW9PpB232vQ7eR74pbCk3Lf4XlLTe7H9kzZ9eyQfl6eX8Gd939pu3ZgVkzgVajMdfNweQLvypeLoBeiS0Y7IyfwHq9PTuBdVz9A26EJvJsygedFImUC7+Zif4H4QHNlmx06kEXntJxkuEU4+pp9Ny/bnj6Bd105gXeTL1lkJpnA2ykTeH87E3i6dj+TnMC7KS/H1Ak80ifw6tl52eRLEgBsaf0cPP8EXt3v8LdD2zqxawvbQhN41bcC7juZ5D7b9AET1t11iOxAJo8gm5e/9fPh5+s68uXCA5Yn8HK55egXc5Ay3tk5YFFfENLO+Jnnn8BbGd1X1Nh0XDomvUX5XLqdZDsyKRN4PP8Ens+vxrkTJCfw4HZm9Ho1fmyX7UHKBN5Nn8Cr+8T2ys+SnRHJNm13Ai+vw6U2uQ7ZBrmtcMjeke0JZJv+4Qm8HP8+XZPNxg/GDuwqRDbAyYUTeNn/A1e/IyGfLw9n206OLeHQBN7VL1Fb9RWyF5abMoHHC5/A8zs4bQLP702b+7y0PQHZKx4Tqq/y/AcZnqyHJxOZ7Uzg2Uaq+RHZg9g4tZITeNB95HdvWpvVXOwFTeDVxjG7mjKBp5tr+8kJPLeT74krnTR8G9l2CDUHoOeo3kGum5y7bc8OzIoJPIONupWXXjT66mTvqHqGYpIXgZrwVZu40+n9Pfll5pb04LfLya9aQZOEWmNoFGr1ellmnF7SylMV8OjhwS/3o8vw67RxUm3yCukdQ3n32COmIgA8AeZrrjY6cj0dh7xb6pj8EuOogvKC8wSan4na3x3RX7UR7KRnjJEfoI8b8sB7dXICRrcx16+/gH3ZN/je1uirG2kDi0eTXK889QAiI+wOV7EthJ80Vga7BlYgor6svB9AvH+LnPyopAgKLOprckxZ9KHqjiSfIXvm/EZ64Us7E/OAp3i4+YWsPPgORfm4f9Vk1I6jW1E/puOyB58nGcq7xzYw9kJUbRpPTrb9LNmYPHnjR+W5h0u6HWxDi2GbLfJyxaNqhXAZmzueGKlrJdui9ud9+DrVBIk/pGtNemLjyI9+i2ysTx5aFRVgDyp7z5zR8Fr9hkK0zGtMehYLFDFRHj1Ri0/kDXYNrJofTmrlM7bL9KGrnEPkwRZZmrCpMW3zxIycO/lwLAiaJKZF5wR/INCYdQdk9G9Ce9NFPjy/7ek+FYOaeKZ43QFtz2JOiIDGYUG+D2ns5bfqY6l5SX4gGeGPgQ6v7Gk88p38EOJr5yi3PR6en22DKOjnELSF94K96Tw/y4z6sh36+J68TjVnAbQjFgDycg7gkVfdJhscRdarbFySHzpsl/nZKxuc79fX6U6Ev21iVQh/O/dZtW2HtjIwMDAwMDAwMDAw2CMwqzzwft6GQ98stq941OleD6HCw/Qx5JJnWXnWPfJyeeQ5V54o/iq0K/oL0lFfpuQJsiWf3a0kuaeA9grxV2mszdJ7xJy+aiuH+mQIsUR0D/qajLx7sVCX5LnmtJeNQ365wXAfDmWxB98ZDz0JzBf26skjlcKTZShvvMv3QV5/jKdKXnv1bJgXHPNWyudUbtHL6sjzqT2j+py1Br2t4t+5tE/MXSmkl455kGofpgJJHmDgJT00BrsGwraiyIyT4k0GgCAn+1Kg+3zMEyS9bwGNfbefeLJyzEfHwTahXOl1sil8rCJUsUgABwAUT7qo2xRRWABMdCqKVvxaFYpbwvazB90ukedYerw4JBzLxZGeKm6fuidFsiGVVqIjyNP7LXX6nJWk7fIatQecQ+rKI+hy/gB7xEqTh9nZA8nPLpDcZaYYxKDeCzR2nQnyjqnoG7m/2FuvbBLvb5PtUiF1m3OX5PVZKXlRBrsAlhX+k9HvGDVEPgP29jI8macW424TN92pyudL7zNnjHLWosg7U6w46pVCWZXt47HDfdqXkSy+jtg4bpWee+ry7PlWvH93zKNl+vp9OZfhPCHOv1Fjxqf7EPHNyZudGaWxrfYXKcsQHz/RMo4qKNs2Cc1EzXWYGRDZS56r8PxHPic3SB+Hyp77OaLgMMdfPnOeU7pViuTYivZDtkHl3KT1ge3AeOANDAwMDAwMDAwMphHMBN7AwMDAwMDAwMBgGmFWUWiyox7y5WRYJpZomIJ4wiWFcJRSCYXKai7TOILYdgBQbdbh5YwMpXJSWhSeZroIh19lWCxGoWGhf/WTQzAU6lOyeaxE4ZRT1HDylFVfTVJbMpSwpyT3mHbDiblRohAdxyklw+BWmUJNOZL1kglelc5itEyFqGKhLJbXk2FQTjzlUFluODxntYEkNpv1s8vKBJg06UlAq8fwfYgl6UZhfKLlRImtnCgtFSm8WTUUpxRewUItRQaUx4lanhkhisx4SvIxJ6236/6pks19SmBiWTRLKsbEaB6yzwaUdO5zGF+yWViCjGlr+UFfnlO3qdJIjd2eaEpEn9PL+P6okDTTBTJKCo7GNo+TiF5YpH1G2B5KtShKfC30Eq1HHtePSdgSBU2Gn60ay/fKbTmpnVW7ZOKxRZJ3ccm/8Eb79F5gukG0y2She2k72fbE6FOOSnRjebmwzV7N2IGphqLFBRmiz7Fcay35XufE82iccfdgupaiz42SPUmjvgTUzxVlNE80VqKP+nJ88fzCp+ROpdxk0aucJXQVlTTHUwm6poyk1sQoLjwXUvOSIPmOdCr62lUSKQDYnpz/ED3NqqTIYLMQANFw1bs5v1Un+1qsxCWbyjRHRQXy9WHgZ1LGsUjOuQBW6uJkWWq/PH9ceYZsj7RnAdkzvxDSC5lmJXawiJvxwBsYGBgYGBgYGBhMI5gJvIGBgYGBgYGBgcE0wqyK1zEdIracNVgpzB3IbHL+zCm36xBVrRiuyPfrfXL9OpyjqrqyMk2syqGMVznjFHaScZ8sa4WzzrsKzdCyIJt8jM6o1kzPU+i/1h5mo3OFRZdDWDKMzkElFcKKqTKMp4S9OCs9l6QACaLYsHqEPVZO7K/0oQGt3e9TmF3RfmIFMOieqGx4rjiraDOAVqfJDadnm0ft4/tMoTRFnYkVpyIagS7GkexzSoMe0PfGr5lv6d2F3JAPJy/veza9/6hQqcMUmwlSk1LUDVINYS1xIRUcmHrBlAlHUU+IPoeogFC6AlXUZ70k1QcgKhrtk+9L2h6utyAoJG0rO0L75waoNoLSimZFGEUbI/oYj9NKU/g7Ns5YdUJeC9NuYuNIFZjh3bnwixqTtSQ9KVYHh8Lw0TOLFVpK1v+I6eFzdVipRhXT8OcwuQrjp/QngKh8dE1qmUih6hjsfAjHgnCsSHvbpnoOlhoHXGWZi+wofXPuk8wYTSnExNQTRcNl5SLQvEM0ScWm2DgJtj1krDaB6p8x2kzOSqzn99XoAqKpylM6ZaKyxRRnkvrmlp2knoiUZQy2DVDU3ZTrBDSV0CO76hEVz1XUFX4Hc4V6WZWelf8UFS8zzkUhdZNULQ2e68SqzybF6eKUwhFFvU2v06NoRw4dvyLnZHxMP60oXwrMrMHAwMDAwMDAwMBgGmGXeuAvv/xy3HzzzXjiiSdQKBRwzDHH4Itf/CL23XffaBshBD7/+c/j2muvxeDgII488kj893//Nw488MBom0qlgo9+9KP4wQ9+gFKphJNOOglXX3015s+f/4LbxEllKmE0pktMSRS2THyamK81jJVHKXZM9gxXklW5YskgnPCgyhPTV636mnPHkxXJAMBrCb9G/Tk6YY49h+rL0R3V7bPZy6ecT5wYS/vb0isQ01eX62PJJpywmkvRy2XPcyVsvz3KSS/U9fykR4y/xFVUxKXEV3csJaGQPfBSZz5T0sepko67JaMirOHq1ZH3Qn6pZ4eoGh55F9IqufI9DVQ2EHtQVfVPSnxVUZjJahFMd+yJNiC3ZQJ2o0pU08+82kR9XuWSkxeLvU+2knyfpMpgFK1hxy5HcxpD75KTSfcERcfkxGylH039kKuqRvvzeK4k9+caDAFXMFX65+yN5MRzdR0plak5OsVJ8cqJ7VA1apFyTkastHoUlWAbp1er6KNDVSuj6rCkPc8JpRkZ3WQbFmuH8lbymIxpvod/uSaIXabkO3msDEVRuW9EUQValhkJT+D5KdWmZwD2NDtQbS0gcPPI9Y4DAKxxfd+jdx+9w7JU40ElNcaqspMXNlpOXSItCdpv0lVVY+9oVUmYq5bKCBMneVpcYyLysOtdcoMkriHfd6V2rjmjr69hvUw45cRusiOVVlmZmlazZrzyOHP0UIGj4OUWivyXpFDAGNeNoHesrP7KNjrtPenR2OaomTsq3610H1UFVVW7Jmwzv9ftxDl9al5UPyemp59iQ2PPLsWbTgnKyk5wArJX27G6MLvUA3/77bfjAx/4AO6++27ceuut8DwPp556KsbHx6NtrrzySnzlK1/B17/+daxcuRJdXV045ZRTMDqqZ6AXX3wxfvrTn+Kmm27CnXfeibGxMZxxxhnw/R0LMxgYGEwNjA0wMDAwdsDAYOdjl3rgf/e738X+f8MNN2DOnDm477778IpXvAJCCHzta1/Dpz/9abzhDW8AAHz7299GZ2cnvv/97+P888/H8PAwrr/+enznO9/BySefDAD47ne/iwULFuC2227DaaedtisvwcDA4EXA2AADAwNjBwwMdj52axLr8PAwAKC1tRUA8Nxzz2Hz5s049dRTo21yuRyOP/543HXXXTj//PNx3333oVarxbbp7u7G8uXLcdddd72gQevlHNgWU2iSZbhj2zeFIQ2VrAqk6y7HQqms+y2pL1nWNvWSNJKAyog7FZXgQnSMOtZkD4/PiROclJYZl/tX0j0SKtFNOBR2YlpRJZl8aadoszJYJ1UhphGrlzgIBQABAABJREFUNOVjJZM5FifpDETFYQpNZqic3F+GzEUdCbqyPrQf3h+btN9BiWzVotLFpcRcCv0LVXGZQoI2tUnUlCY2aTnXc0hTtn2cKDySjsHLopBnsGOlk6c7ptoGAECtLY+MesB0212iW5VbJTWDmBlM/QhSyqzHqSEypEzJkTxOFTXEpuRlK0puZA1i0pmXesaxegN0TJVslRvU49Ud0tQAS9o7m6hAsT4btSlJuwF0Ejonz1VbVFl5fWkBmQOlNe2Oa1tbbSR7JkPisbFH1xfRG+k+sL0SlhznZXoeqt4Ch95TqDqx0uV0H9VzCkgfmhNWs0OSEsjJtjafK1weS6jjd42yc1wfRFIjt/NKmjGYajtg+QKWJRDId4It9HtEUWi4z3DdlYgCJei9S5rukRAE00y5r8n3ZYw2E3s3yn5VriTXW3naLikKYfk0tokyqqiATkWfp36j7p+Kildt4sTWZAI8U+G4zcoOME1V0VRYI7/Qn6yrEqPFpCS0BkVOQKf3tZzj8JzLp3e8mk/YZJvSqEwxYRFpvJSGvdxLnzNFPCPWZtlPrBJRfKkfBA118ppIz18e3uV7u4NJrLttAi+EwIoVK/Dyl78cy5cvBwBs3rwZANDZ2RnbtrOzE2vXro22yWazaGlpSWyj9t8WlUoFlYru/CMjIzvtOgwMDP4x7E4bABg7YGCwJ8LMBQwMdg52mwrNRRddhIcffhg/+MEPEuusbSraCSESy7bF821z+eWXo6mpKfq3YMGCf7zhBgYGOwW70wYAxg4YGOyJMHMBA4Odg93igf/gBz+IX/ziF7jjjjti2eJdXV0Awi/ruXPnRst7e3ujL/Guri5Uq1UMDg7Gvrx7e3txzDHHpJ7vk5/8JFasWBH9f2RkBAsWLICFbcItMhTLoW2HqCcqhMSZ2Vx+WIWFHS6RHlNnkcentllMN0nRCHck7YbLhdcadXhPqdhkB3VoPKBsdBV+Z1oLh/9UeNyeLMtZhvpSSxqzMg3TVVTWfGkSlRoVPqR9uER8TA9XLSPlnSikGVN6CJLLiBrgjCsODKlPMINBavyzHj6HxFU4i0sz25VkqE/YSSUAAKg2hMe1KeSn1sf6WzlJm5iJ2N02AJjcDviuDdtNhslZ0SU3JOlOpCTijLMikVQNaaLQO1E2XBlS922iixD/Tg19Li2elRQaZ0yP7Vq7VptS/SYzls6ziFhBk/Qlda3uoFbUsGo6JB+pr/jpYXI1fmP0PaWXz9RBiklHNpTqPsRCxarNREeIaSirZTSOLIqJK4qb0owOr8lPtJ3pMNE5fX4XJJUsOPTPtkHp4MdpglwaPewTMUpVkLQDsfOrEu8zvB7EnjIXcEoeHNfT76aUd3FMbSnlAyGmNJIyTpiFwZRQS84b+N0i+B2uzsU0ikI4Tpm6F9Ncl/swbUa9gwDAlsOv0EeqUuVk+2PjjC4p21+NbQfEVbmUHWBlm8ie0KK69dr22CVpT7kGA90npQLo5KjNRMWL5h08f2ARHbU8Nu9IzntitKDoOEnaDKDnfPwOZ216X9avcSZRuFJ1eLiugFLZi9GvvRSqTwp2qbUQQuCiiy7CzTffjD/+8Y9YsmRJbP2SJUvQ1dWFW2+9NVpWrVZx++23RwPysMMOQyaTiW2zadMmPPLII5MO2lwuh8bGxtg/AwOD3Y+psgGAsQMGBnsKzFzAwGDnY5d64D/wgQ/g+9//Pn7+85+joaEh4qk1NTWhUCjAsixcfPHFuOyyy7Bs2TIsW7YMl112Gerq6nDOOedE27773e/GRz7yEbS1taG1tRUf/ehHcdBBB0WZ6DsK4Viw6AtReb/Yq85QyakOJbe5Y+RlVl+t7Ikhz7dK9rKpSl+saphKeOCvLaUjSp+t/DUW6ZxSpphNCROqLRZp23OVQCG/4FkvNZYwq9rPFdekp4g9/dxmZ7gU/hgv6evIa89k5GkijxbrNotC6D3z6ylBh7z56qs/oIRVS0iPGyfcVZJf5yJWPVUfU3lL2ZtYo4q5KkmFk1XSvtTZS8e/hfS8elQjQFX95MRISz6HwJqZnrc9zQYAYZVjqyGbWM59Or9pLFzGyWtc8dhJVjZkTXjlnYqN7RSvS60xmRCap6gSJ2J6ssoiJ6rF2q+COXQeh72ImWSyOFdQVU4nv1HrU7OXUF1LzHMnPX+Cuy8njMqmxqrLpkQIHLKrnDQftZV1l7kSbVTYgmtAhHaCx3a1iexlTdaIGNEDkb3hdi25LK2aIru/VGVeALBkNUu2PR73N1VMm25jZlS9C2ZmFuueZgeCrI3AtaO+JJwUIQZOrqRxFP2exEnqpVRhdsYqie34fRarF6GSXO0mam/Ylzkaz2NCBbACamekWQ7NImBvMkf/VCVgO1Yfho6fUiWabRMLAGyLWE2bMo8TuZznJ2S7+He0fzX5jo+tJ9vhy0RRrqWhIqOxWhk0dtEQzkFYu54jCLaM3MeeLSfgy3viNxRoJ7JN6p5xf1L1Ocheed6OTc136QT+G9/4BgDghBNOiC2/4YYbcN555wEAPvaxj6FUKuHCCy+MijfccsstaGhoiLb/6le/Ctd1cfbZZ0fFG2688UY4KYPOwMBgz4GxAQYGBsYOGBjsfOzSCbxI4ZVtC8uycMkll+CSSy6ZdJt8Po+rrroKV1111U5snYGBwa6GsQEGBgbGDhgY7HzsVh34qYaXtyOdT0DTI0qdmrrBoZHMqNQwLqeHd6OwW1p4DaQXG0uAoripDBFZHMJROTWUHJnhhFWV0MmJGxzpTSnbKzjxRYbAODzGoTDHTrZZXZNP+ssZ1kBWbapwMm16+DlCSnjaZ71XoZ9JlEDEJeRHy3I7ejFU6T5mZBiTEgL5mhRtp1as103ikskTabrRtH44PG4s5EdeoKwKpRGFRpVcjpVuzks9eSflHhnsElhBENEn/AL1WX7kMpGTkyMDTuJWY4b6nzNBtC/ZvdPCwAybaFee1HH36vU5/RxRsGRf4nA116DwpKY7j22nrNtsq8Tr7GSUvvC4lU4d/uVkrVx/eM9iIXFPJb8laTUAUJW1NBzWvGaqUT5pQ1UiGECa71yXosaUwmS9h6icOYe+6dFE1EdqRyyxV9HveGznk5SrWP0LuuYoMZKuia9f2VtOjFXPPpaYaLDLYAUi/Jeit23LZHW25/xbUUlFXbL2QHgAKVbA46ye6J9qzLHOfMp72yO6jOqLnIztUJ9Xv5nexvUSlB0RKdQNQPf5zATT15KUWWHx+4yTvCXNluYSqi+zXYxdZ0qyeto4YypTWs2Z2HXQ8dM03yMKUNp4BSJ7aPPj8NlGptFo6Zxyrlhr0vMXtuGB/F1p5PdCNnGeQOyYHZiZxFsDAwMDAwMDAwODGQozgTcwMDAwMDAwMDCYRphVFJrMuI/MGGtthpfvUdiGQ8aVlnB9XQ9lPrPCgi3VUSjUxGEzFa5iXWfWk/WLYVldi0K1XH5b78TqFioURhQbj44faa7r3Tkkr9rHpcHVdQD6+m3B1JCkfnmsZLEMm7kpIbnYZWQ4DMlKGOEfVnnxKDypQt6xMLlSsWEKjZ3U2Gdlmti2Sq2HKQS0qbrPXCKe26fus08lkWNa11JVw/a47LsKrZLGf1Fltc9sHfg9CV4xC8sK+5c7RqoIXMegFj7LmPIM0RtUKJVDxqlhcFIfYbpXTdJdxubpfu6Ww/V+VofOa0U6p+xerKMeo5OosctqSCkUL5sogTxO0+g+qn8CgDuRUmJeUhDs8aTKBgBkIpUa1nnX+ysKU7lDjxN3Io0Ow8ozGspM8XUomiNT3pha4I6E9tIe1XYTNbK7ii7hUjif75OyfWxPyK4H8pr4mlnNSi1nRY9I5WMHQ+cGOwfRM2A2jJdUBApSaF1cQ4TpLIqKx8+8WtB9SSlQuaPpY8aSlAyX7JFSVgLRTFlFRqmZsSIKUzdU/7LHyXZ4yXHG8w+e14gU1S1nvJZY7zWRPUvTV2cFKnV/qVaGINpPrUnRXPV15Pv17o6ffGemUWxilEHVDHo2oLlGNJehWhtMf1M2vtpKKjMEV1FwWDkwk6QtMUUnqt+ResTnh/HAGxgYGBgYGBgYGEwjzCoPvO0FgM+Cq+GfDCWFZQf0V3G1OfwC5GQQK0hWTPPq9Rcca4kr/fiYNjx9yVfl12qs0pfSPGcddq6OFiivf7IKG0Cew0LS6w4AvtKS9tI9vpb6kqYvfeVd8Or0vWNdZZVUx541eyKpl+9TIo/yQAJae5Yr2trkzeQEMwWRzcSOHR6fdORlEqLFyXMpCTyse8tJjCrXmb/dWRdaVcRjL5vS/wW0dyUWfZHe3LjWrfySNx743QZLiKh/c6KjE4vmyG25irGVHHNONT06p/ZzyYNfbSYvnvSY+STrnJHdnJNUOcEqitJw3jbpyEeVVtlDz7URUpRAfErSjRJzY9VpuS3KVZTURI8lvXPCaVYmdTVTYmxjMgLFXqrsEHkzIw87JZyS59JRifMpY5sjYrEKj2OyXsUE1a3gpPtC2FaOvnDE0GvIJNrE7Vf30eKq35TMnhlPeiaVVxYzVAd+T0O1KYsgk43Gf24r9QXVvyeJsKRWZWVvtkrsLnMJUqrIXE2+L0HVj9XyWJRaCWJQn6q0JbXKXYoKqLojgLYdaUnxgE6Gt3LplV6VRjlHijN949HvqEIs21M1B+DoGSfzKg//JAmlaq7DUXA7RVyD733gpCSWp9TesXneQFF0dZ1ZqsDNUQlPJqdWm+jec1RCRk/4OWU42dcP9+PojbLXfL/tHazMbjzwBgYGBgYGBgYGBtMIZgJvYGBgYGBgYGBgMI0wqyg07mgVQV0x+r+iRGRGSNeYQjTueBhuiSWm2jrcEtE8ONLGpYhlokR5rtYajyVTyeNzkoSQZYWZjsFQIRpOwuAkVUcljVFyHV+T0iFV5w6vg0JQki7EFBcV2smOUpJpgb795DkV5QgArEai8MjwcoyuUE6GkVmjNhYqi66J9atV2/QiThiMknY4fMW/ZSIfJ8baKbSizEg1sQyIJ6KmHn9EhmRZ61bRp4S+t7kt4XaOTwl1BrsUzngNyITPpUYUlColYGXGVKKZfv6sGR8lfVHCJSNK+qKx7ZSIXlcJ1+fqOYwt7dEo2QOqB6HGPCfH+YU0ig1ReSrJcebTOIklo0vb4FFonRmD1UaZBMtjRjEPWL+cb4mq8VCnr501kJVNyI6SpjVRXxRdRWSTtAUGPxtVGt0eHKPGU5KqSliN1dIQifXxpHv9W11/TGeaEugr9fLZ03uDbQtTBfUxZTKwbyg0uxOKKukRjcJNqeGg+iGgKROcuMp9gWl30foMvy/lufP8jqV3uOy/sf6X8r7JjTB1RB1bj5PMGIkupCShMtVO0V04cbXWmLQ9EPqctQ6a14yFtLZU6gm1qdZMNFcRPzewbTJ62L5MbH5FdTOkHbPJxgV0z5TttkuULCx395s0pa9GFGhFy2FxgoDarEVA+NnTnE9eqsOCBkyvkjYnz6ZDbhvrQ176vGNbGA+8gYGBgYGBgYGBwTSCmcAbGBgYGBgYGBgYTCPMKgqNM1qBlUnqd/qsPUpKERFNYxJqh8o2zw5q+kN2kI4rM89rxfSMZVvSSDhUF2k5U3iOQ+aKrhPTWOXVUYl3WuYkM9OzHNId1+Earz6kGLGqgjsu1S2ITuCO63s23h2GmAKHM6uTWfkO6VPHSkLL5bGSyXSsWqvUy2eGS6QNT8+D7q0K/3FWem44JTxNdANWh1AUIaZPxcJmsq0cauN7HtF+CqQ8Iik0sTChDO/Z/o6FzAxePOyKp6kt9PgqrCyQD5+7U+Iy2CkULrIN3H+V2kFMkYWpaioUS/tUmsJzZcaStBqANM851Mrlt+WY4nB/Gm0sRvOj9tcUHYfsiVNN0spKc5I1GjIpdR/CtsowOIXWLY+VLsK/SgUjbDP/Du8TK3/EakwEkubI9DmpZGH56co4yGSSy5hOI9cz/chJUSGJjWPqR6r2A6tnME1T0Q1iCJQySUodEIOdjuxIDa7rRJQHHjNBJrTT/I6NqbapZ81DIzam1PNPp4WpeUFMHY7UYRStj993al7A1FfBqm+yT8a03WPUDbUTvfdHSHlHdWBWvyNqSCBpdX4zUcVa9O/iJqnKRXQYpeLE9TFi8x/17uYaC4Wk8o4dG+/U5Epy/sRQ9Rhi509R4mJ7V1NKez6p8NWSNph13LPDRMGWql9sV0WObVP4NzOs54xeQ9jffKIh+qym8zwwHngDAwMDAwMDAwODaYRZ5YEPChmAkp3U12JmsBTfRqLWGH4ZBZRA5ZTJE6S8JvyFx7rQ5dDrZPl10TJ7POlpDfJcvVVVAKUveqrOp77UOYEm5kWTyaNOZZKvTvnT5ypuflKjNjtCnmn5tWhVyDukJWBRlG1lL4Y7mtSBZ53TIKu/SmsN4TNxuKoleRc8pa3PThDZTsdhDzgl76kKjlwhke6TL70cLmvPs8dNtpWr3WV89maG2/p0zR4l/qqkI/aAqnoBfG+iZBdhvqV3F0TGifoFe9Zyg0nNdPb8cvKh8p5x0lR2ZILWK535ZA2H8D9yH6oMrfpaPPpFSbDy/OxZ5khVtVlqDNP+pU5OGgt/c1djL7FQBUgpesbJ8qpdrC8djd2JpB49QDrxdB6XKzjKccbRjUobJ43JqMQo21WyLeqYE+TlUsmBGfLmkb2JamSIZDsBSvhLSUYE2NtPCcSUlJ/vDT3sqd4+IOZx3LbNgqMGBrsOQgBCRDaZ+7nty36eS4++CqgoOfUZfnepcc4Vh+tS9NU573sS/XYFR+m40/yl2kC2Z1TVPUmvrOzJa+H3nWDNd7ktX1Nh42j0Oy899FwptTyHEkGlHeB3qNeg7BHVQBhLSViN1UUhe6vsBHuzuWq9fCYe19mhZHlfVnHheYeqIcHREU7AjzzszFBgtoO8focrePvJe25NUh8kep/E6s+I2PWE50+PaG4LM2swMDAwMDAwMDAwmEYwE3gDAwMDAwMDAwODaYRZRaERGQcuJVnYKpGNwhXOiE4uUMlQXp1ORKw267BTTpX65XCHnwx/xbTKSVNUhas4jO/4ySQIy06G1GPhOy4jrnRO67iEu26zn5fhwRqF37bq0L8K/cQSYAZlKI1Dwi5pWqvr42ZQqE2FFLmdGabYyGsRlEDDOvTZoWTynScTgzmJlEPWUWIsPY84bUiVq6Zl9BxU+zg8xmF2RZHgZ8vUBVteC1OZVGKsS/LUqo8JQ6HZrVAhay5pHdPzVX01pm9O6xX1g555nMIlnzsnP3Jitgwvc59TNJMKJYo5ZQ71yuOA9cX1+vzWZHJkjJoik3T9XLqmupdXoX1ORicagDSDmYkkJS+NNgNoLesaJ9ayvZXhab/AZduTVLp4CXUaKzVZS4MSQ31Zrj2iygCxJFU1djk0H9ORV/Q8OmaMCiWfmU/iBC4l6UY63vTsmSYQnZftqUoiFOnPxmDnwitmADeDmqRnsma6el9xn1bUCwAI8pJ2k0m32ar/eK2aYlLq4BoT4fqYEAVB2RYnRV88NjY4yTWT7Dfc/vGusK9mSHyi4dmkZjvT01Ch/h9tSKIQlLldaQ/HXHkOzW/kO7hGVB+bE28lZYTtItNdonOzpnosW1z+IXsS1NiOSApNI4/tlMRXalN2WNltvbrayEn74V9OSnaG9PxJ6curBF5gm7mUfC8ERKlSdEymYfnejk3NzazBwMDAwMDAwMDAYBphdnngbSuq0seIJRt5/CWuvpSTkogASSZxQgLL/8j9WVqp1qK/UH1ZZTEzRHJOajv6eo99lVpJ741Nxw/qQq9TvHosfZVKL5tbSk8MiU4zQd48VZmwRl7znI5KWNKjbOc5MTVZ1TLW5goliKmEwYCSXbg6biklmUUenz0S7EFV3g32knjk5cuOSg88S4SyR0N6Zh169sLmc4XHzw7q/hSv1pj0rmRkopFNXg6VFCQ88y29u2DVfPiyz3tF/czYg63GRKwfc/KxjN4JlzwpdeTxlX2apQhjUbVI1k3vklWVFVnGsZKSsEomhr1sKkHepmRzv56SWKXt8ijRi5PnMuPSXlXIxnHFZFlBmKMW0fljifLJpC1nkvugzs8BKCWnCehxGksALlHVYllh1fK0PXGrySgm22U7JTm10kLywVJUwKIoYGTDuK0cHOGkNfWbrzOjjy/ITkb7V1TEzySx7g4EGSsuZVxOJg1yn41H16RnmZKt0yRDg5jErF6v3lM8l3BJwpjllvXx5T6cTBuL6IV9ttxO72WelkiTwNXUY55h9U6arP8pWWSyJyJFdCItqiBKbPeSid3OqB7PdjY5JY29d2mcqeheLEmVk3Rl+zioxfMihQxLc6rIKkdmORIjk3A5CZbnT+qZ8DLLSb7bmWGg7q3Fkr07lsNqPPAGBgYGBgYGBgYG0wlmAm9gYGBgYGBgYGAwjTCrKDRB1oHgJNMUnd5Y0qJKoKqlxzPSdIIFaZJaUaiMEyH1b1VxzSnpMLwzFoaTWHOaw/iWovhwBUYK3XtSozjWZou0zMeVJrteXW3TdB2VnGGPJ0NNMVDIWv22ynScqm6TorFwtbl48l7YVg5bcfJfpLdPIU2VKGRRQh7r51pK1JqOEyWoQD9bDgNyd7AqSR1wUUjSkhSVImwT0QRkCI17GG+rt5NhQGznfhvsPFhWRFPhhM5YnQJFoannZ64PEYXcuc/UUsLPTNGixKdMiu1xy5LWE6sLwUldaQnyRANIqf6apk/NtBvWOFY0EU7e5LoYakS7pIGsdPADTtrKpPRlZtiw7rKVvKbYbiqvlsdOjX6rkL/vJNc7nChGrzqVL+qkh8lVW2O1NLxkEq0TJMe7PLDcie0R0zRl8l7afTLYLcgOVeG6NjKyL8ZqwUh9dKaiIaXCaXYonYqm6KE5orbm+uh9rQQQWHueTmXJ6stM/1T0zDgVjUUd5HuEuxTRVbIj4X5MMUEtnSIUgeZCqs+zdjzPaxSVlO9DuUNWtGV6ENmbalNoUTJcgTRPdiSqtk5JqjTMglwa3YZti9yO7rOqtcE677EK2Yp2k3IcgChAXD+DbZ+8Z16RK/vSHGQovE/ZAaJrZpK1f+DtWEXmXeqBv+OOO3DmmWeiu7sblmXhZz/7WWy9EAKXXHIJuru7USgUcMIJJ+DRRx+NbVOpVPDBD34Q7e3tKBaLeO1rX4sNGzbsymYbGBjsRBg7YGBgYOyAgcHOxS6dwI+Pj+Pggw/G17/+9dT1V155Jb7yla/g61//OlauXImuri6ccsopGB3VFcAuvvhi/PSnP8VNN92EO++8E2NjYzjjjDPgm2QfA4NpAWMHDAwMjB0wMNi52KUUmle96lV41atelbpOCIGvfe1r+PSnP403vOENAIBvf/vb6OzsxPe//32cf/75GB4exvXXX4/vfOc7OPnkkwEA3/3ud7FgwQLcdtttOO20015Qe/ycjWqBMsdV5vQEq0uQ0opUrHEojO0ViRoiw0mTZSSrEE9aljKgs81j4TeplsDhFM5KV8dMy2wGdCljzorPjuiwmVKQiIfvSJdZ3QsOGefDUJjlJjOnw4NKbVUuzcwl6GVIkSkkcVqRH/sLaK1dgDTbSTtVUX1ETMuZ42vhPrkBep5c2lrRYeicfM9dqQwUe56g65MhTY/aZLP+tWoW3Qc7pW6Aar+YwfrPe5odCLJOpMRiU+a/n0JdiY09GqfVJqUfna5SpPpNQMeM9fkgecwI1KdrrDWuwt9WMiQMAFZbnWyHXl9p1fYqUqVgRQ2O2gpVDp3GKfVpO8XmRNQQPiZTT0SSijYxl9okN83TOM0NJ2mMXMI96GrVbRqXoWjW6FehdbZRbCfksfh5s71UVDhnhHSwycb7xdAeBjm+H2QH1DWT8k2sBLzsB3aZFNG2QyWaCdiT7IAzUYPj2Ol1TyS1KUaJmyClODmHYDpsZlw/S0tSb/h9yOp36jdTX2tNpJ/uWYnjQ4rLxGg1TNdVdF+mexBNRNE42B6wOh6qksbBOvA83utCemxM3Y77tBwzHtF9lepbhXTYJ7qIbqJEt0gjn9/BShXLndD3wa7R/EnOJyKVOgA+zc8UzTFgGqSc9/g0/2GdevUaZnvkkh3w5fs+ICUv1oSP2sna9PScFLUmM5Ks2RFTM0xR60nDlCWxPvfcc9i8eTNOPfXUaFkul8Pxxx+Pu+66CwBw3333oVarxbbp7u7G8uXLo20MdjOEQEZ4cITxeBi8eBg7MD1hiQA5vwpL7KDemYHB88DYgekJW/jI+jvG1zbY+ZiyJNbNmzcDADo7O2PLOzs7sXbt2mibbDaLlpaWxDZq/zRUKhVUqIrYyMgIgFDTOFPlrylZzZO+Kq1GnYgZeZViCZWUOCITRifzZttSQ3ky56qqqhr3HiW1TWNJaXK5zV9otL4q9eNd0i12R6lKoPQSsuePvXDKE5ERHvaq9KLVG8ff8kvClXUFfLrnp3j52GpcNf/V+FXb4QCA1kIZX3rwOjxuL8B/HPFWVJ0MMpS44sovaf5S5sqI6pyxJA6uuKb09Mc5gUfq2YN2qSWTwqzYlzBrwqv7rLflSEX0zKkdfM/4metltF7p5sb6hrz35JmZ7ZgKO1BtyUXjJzuu+4fS+AUQ5YtyUrtPCZ22rJTHXrKgkJJUxUmo3NmspGc6SoDKp9cusD2VyJas3goA5YKsQJpSzRDQHjnWvOb26YRd7Q1s6x3APuM9GHPyeNLvBgD4DVn89s7PISN8vPXIj6Ev2wS76uPVW+7Fa3pX4s6G/fDDOceG55QePR6Z+T59H8vtUluexmaun+yViihy8h4luqnKh+wt5Uib3ik9aS11mXwmXIsjpgkuwcnGoN856Y3k/sAJzEhJcI8Sa60p86lNKXaVHZjMBlheAEsE8SrqElF1bB6bFH0WaVrl5GVN0yePeatVVVc6vk8eXV9mamaHtT3K9o4n9inPrY9+Kw872wP+raqAR9WWATjl5FyH6684w7pNHbkS9hnbiPsz+2AoG573yM2P44pV38ZT9XPx/kMvCtvhAJes/C6aqxP47rITcO+cfWJRTpfqSig2AEeyeK6k7NRkQhF2ORmF50GlasSMd1HV+TEZmR+i47CghhQeYa+6RcnM6kiinp4dRUlVciuzOmKJ+inDO3rH8LrpogNvbRM6FEIklm2L7W1z+eWXo6mpKfq3YMGCndLWmQ72ps2vDuBrG76HFb2/jSkoVC1ZfCrQHTwb1DCvNICXbn0WVVt35nOfuhX/9uAPsN/o+t3QeoPpDGMH9gxs61E/s3clLnvqu3hd7z2x5WqcZ8kOFP0ylo1vQmd1KLbtpRt+hPf23IqW2tiuabTBjMHOtgPGBvxj2NYO/NvqH+EzT/0Ihww8Gy1LswEA0FYZxWF9T8eWLx3pwVf+fi3esP6vJmq3EzFlE/iuri4ASHw59/b2Rl/hXV1dqFarGBwcnHSbNHzyk5/E8PBw9G/9ejOBfD4cPvAUvvbgtXjThr9Gy9Zl27DFbcTj+W7UBdqD8d9zTsUbl16Mn3ccES3bkm/Bxw5+J7760tfFPATH9D6BU3oexPxy/+65EINpB2MH9hAIgX968k/40e+vwILx3mjx6mI3NuRa0Z9piG3+jpd9BGcc8xlsymtv6K3th+Dfl70Fv289JFrW4o3hZRPP4bV9f9/ll2AwfbGr7ICxAS8MzdUxfPiZn+Hrq66JRa0ebViIJ4rz4FOE6NHGhTjrmE/jgkM/EDvGl1/yenzxkDfikdZF0bIDhtbhsP5n8Iqtj8zaKNOuwJRRaJYsWYKuri7ceuuteOlLXwoAqFaruP322/HFL34RAHDYYYchk8ng1ltvxdlnnw0A2LRpEx555BFceeWVkx47l8shl8sllrtjVdg+Jy1KPV43vUOpsCwnIzGU9irrj2d1wrymrnBiCemwRvrnpGeaVoo3BpUgxfrP4xRq6w8n25xQGSV6gUN9+v60V4awfGQtGmvj+EnbUYBlwcvlce4+YVjMqqqkHBfjsstU5ujwXaXFxZ2dByKg3uRUA1y79HQc1fck7mg+AJYvIDIOjhp6EscMPYFfthyGp+vmyhshDUUtXXfXl1QlTrpRYU7W6mWKjteiaQAKrF+tQuasO8tUpiCfMjRYr1aG/GPhN45UNEtqAIUs68eTyS6OTH4Ss5RHOBV2wM87yI6F4yMzXKYVXC5dUjcoqcvO6D7hlMP+5dVz4rY+lKKDcfiUbY8jbYNNoXdfJjgxbaZWpDLhMo8uN6iPk+sj/WpJBVT6yuG1ajuS7w2v1aZr8hr1ODmobw3mTgzi1evvxbV7h8mGd88/EHfPPxAAkOkLw/ju4AQmwqPDqhew4CPI2BjINOL24kExOkppIovL574W7d4ohoIcrEoN+TUDeGff7ShbGdx82IkYyDfE9PZzA/RMVKIb61RTSF2Pc/0c3EF5neNUop2FBhQFQhDFheyIorh51Cam96nrY3ocaz1PLAiTidk25JjWowQC6L2i6JieN/OTWdOwq+zAZDYAQsSpqbGETJnYSn0maKjT26oxy4+KHq9KkmbBCu4rlnqfcQ2GYf1u8iS1V/0FAGckSed1YnVRknVJWIs8oplQmwOat6hE0VIhjxP6V6HOr2J/awsebQgn4V9b+vrwODQtccdsjCMP+IAt+3Tdxhp60Yg/ugcBmwLUYQz2RAWrap34RsdJ2Oi2ILs+/ABzMjY+s/4n+HPnS3BH23LUbBeVVv2slFa6XaL5C+vQyzE76YixknMAZaP5OnKDlLCqxCuYwsu/5f13xyehyMj7zHUrnBQqVUzMZESeM5cU7tgedukEfmxsDE8//XT0/+eeew4PPvggWltbsXDhQlx88cW47LLLsGzZMixbtgyXXXYZ6urqcM455wAAmpqa8O53vxsf+chH0NbWhtbWVnz0ox/FQQcdFGWhG7ww2CLAm7b+DX+fsx+eKYac1j91vASt1TH8ruswINh5L5AHW5fiwdalyAzpAXhW7z146ehzQCDw1bozd9q5DPZcGDuw56GpNo63brkT1+77atRkwaPv730ibp97EO5oOnCnnadsZ3FHw/6xj98Gv4Szhu5FVvh4Ymgp7uzaeecz2HNh7MCehwMG1uIlA2vw4+6XAwBKbg5f3/tM9BRa8Vh23k47T2+mCb9oOTyW+3bsyBM4cuxp7FfuwX1Ne0fceoMdxy6dwN9777048cQTo/+vWLECAHDuuefixhtvxMc+9jGUSiVceOGFGBwcxJFHHolbbrkFDQ06XPvVr34Vruvi7LPPRqlUwkknnYQbb7wRziRecYPnxz9v/jPeuvUuHD/yGD5w0Pvh2w4qThbfX3gCAJ14u6vwv90noKe/Fdd36n5hCbHdiowG0xfGDuxhEAJffOo7WFLuRSWXw3VLTwcAPNqyCI+2LIIzsWttQNnK4KtzXoX5tYHY5N0SgQmvz2AYO7BnYf7YVvz3nVfDAvBE3Xw80rwYAPD7uYcBAJzSro0KP1RchBs7jsealu7Y5N3YgR2HJURaDd2ZhZGRETQ1NeGkfT+CjE9hrYIMNXOIJKXkddCgwzq1Jvpdn8w2z4xRWGyEdH4lWGNZhWNieq7y/KyYEtNzlZnb7ihpFJeTtBwOCTINoDHr4ctPfxs/6H4Fbms7GLCs2PnttHLs0jjyMWsUpldhKYdC56zoobR2mYrEIeuLNvwGGeHj2rknY9wJw15BUd9npbXuktauosvwtQlSE/KbZBib7rc9PBH9DuT6WmNKeJUQoyJRBny1WSp+0HNiCo7uG3p13RZZV4CoQCpU5vll/PGBKzA8PIzGxsbnbZPBPwZlB15+4iUojCmt5fTJaqQPXdP9R1BtAr8h7KesgMD9Q1E/Kh2s70ylzfvCvsiKRIqOw6W/08LcPLZi5d7lOatzdLifbUduw1D4w7Fx1OhqvGPrX3DlAW/C0/VhJK7aLEubj1L4N6V2A19zRDMkZY6YeoeiwvE+dMzSwvDFHTT5uP7XV+Fn+xyFP3oHRS9wZc/4ObEdKncVw8NTuXVX0hGcUdLuJkRh7Ly2YewZVM8kpuFPIe2oRDtp01ea9PVXG8MNCn26zXUbxun4bmJ/pWjj1cq467bPGTuwi6BswCsP/jhcJ6frDDBlVS6zJqHYBKqvT6IUx89VgW2+Uk+JzTVYkUZqmbM6nnrfs2pOrYVUZNRhWDWLaKARrS2mEx/gI6tvhisCXDP3VIy6hbhqG6lujS4ObYpb0uvzW/UcRNHy7FGivymaCNsophUpe0rzr2VBLz7yzE/xlaVnYbUT5kVYJf3e53d8ZI/cJMUFAHypKDgxV9tgRfN1y/reFzbpeYEzHNqMgGxDap2fNBtH6wOyh7H1qv307BWNlpd5fgV/ePQ/t2sHzGfODMfcygBePfxg9P9ht4j37XsBbms/ZI8oHjK3MoBXDTyA0wYfwtLSlqlujoHBjMSxWx/FgSVdcv7uhn3wwSXvjCbvU42zVt+DfQd6cN7Df0AhSDo+DAwMXhxsEeCcNX9CwdMT768uex2+uO+bMOomPwamAu9cfxsWl7bitZtN0vuOYMqSWKcCfmMeLn0gRl4jK/1LWsgvUP4StsnTY3vh90+l0U4sAwCnLCu60VexV0+ea/k1yl4ulQzDHh/+gouObrOHnjx/yitg22ivjuDLz30HTd4Eni3OxROFeYAQCGDFPE42VZtUXnLWME7TyuUkjuj+sdbyiL7RUVSBbYQ85ianGR9feA6WT6zHQ61LqR36+lQycJpHhJfxPXOkJ2BSzXWVDMx67iytrz60yYVukTZsfrP0qHH1WEoIFG742yU6QlQXgK7NkxqynjfjA2F7DJyyB7ucrJbJ7oxIa5yrMDdTB5Z9nvW9OdlKjc/sINdb4CRpaVvIW6e6WmZsktC1ithxRdjmot5f9WXq0tmhGl6xdRX+7fEfYnOmGe9f+m5UMuG5fThx3WjZPE6Kd4bIc1yU/ZvumfKmxzzUKd5K5d0P1+txUpNazT845OXwXQtrm+dgUDRH63MykU1FRIB4lWY1ZtkuR1HISSpDR88hSNo1YJt6FRI+20O5PyfrcuTVkfUeuK4EJ8WpZ8468qrir0ixtQY7H8KxIRwn0iBPi7bEKpXyu01VWiUvK/cPFaHKDFISNQlJoCx/53X0V9UzCA8Q/mHRBRUViGueJz34MXGLWPRM4KNP34zTtj6Azokh/Nfer4MlI4Y20qOQMQ++PFRugGo0DCUjXCKTMqWkaHpaQqg1oe/N5Z2vxdvtv+B7LS/Xy6tU5TagMZ1Nebdzkq+cA+QpSj7RFdqh2PyKazzIuRpHNvmei6yMjjBDgm2ol7yXsfeCvGXMMFARF47gCj8peJEG44GfwejLNODvDcuwJjcHfW7D9neYIjxatwA/bD8m+n/er+KY/semsEUGBjMHDzXthfWFdtxfvxi+tWdyhYVl44cHHYe7F+wbLdt7pAeLJ0xUzsBgZ+DWjkMw5uTxQPNeU92USTHmFPA/Xadi1NU0wKMnnkYumJ0qbdvDrPLAzzpYFv7f/FejUCljwnl+rveeAjfw8dlnfojDRp/Fl/Z+PX7fedhUN8nAYFpjOFvEh156PiqD/h5Bm9sRzBvvw5f+fh2sQOAjB74bG2H44AYGLwYPNe2Ftx/+EYzvIXSZHcErRx7Fv279NR7MzcdnO89CDaaKOWNWTeBFxkZAlUKV9m7AIV/S81W/VfJY+JsSvGRCR5Z1PjmnUYZZLDt5TIY7ngybxkI8nEQBVX6Ywlt0/IVeH44afRo3dR0HWBZ82BhtatLHUklnrD9dR4l0BUe2iagBKjmTw4hUHlntb00W/S1JXWamwHB4W940YduoWRaeq+vEfuMbsMlqhF2qRm1WiYMAINxM7HrCDej4qhw20Z+CRm24VBjeoxLWXGI+M1pLXLM1QaE8ldxI2vUOJTy6MiGRkwjtajIspsLp1szPJd9jYHlaA9ryiOZA5dIVdUbEEryphoSXTK5kBHUyLErruSS3ouMw9UOVFp8sJOtLSp9PpcdrDbp9tbqwzdkxgTOeuwc9xTasKiwGAAyjHtkUbrmf4/4vQ+qTJJ3ZKqQ9Rg1UdIAcUWRatKKEI8dMnmgpgs5ptYVjutSmzzOwbwZeuQkbn2hFphygt7sV/pB+Nkw7Yn12fVGSsscUB9LrV8nmrKPNNEFLjmlnmGz9BCWcNskEZqYqjXBierJvcFvU+fO9OnlOUSuZbmmw6yAcG8K1Nb2TBRqaw2edJaqaSzrtenwQRYUFFOR+bDtiSd6KPhFLfKX+oeidVBPAb84n9onRRdT4iiVxunjPU7/HjxYfh9454RygNq7HaWaYjqVyXOkdlenVlZMzfWp9Cl0XAMZkX87QOFM1bYqkx87vU3UudiqMasoeqlX01LKYsDJYa7fAK3tAht7x0sbyOItR7eQcg2myKnk1prPOtCRXPjOyu5afTNoHPe9qi75mpeDlcs0aevaBEk5JoQNXSbff2zEGzeyawM90NHvjuGzNTWjzxlB2c/hZx5FT3aQXDsvCtQtOwy/aD8eWXMv2tzcwMIjh2J5H8fH7foya7eB9R38Qa+snr1a7p2IkX4cLXv8+1K8XGM8UkEd5+zsZGBhE+JfHf47Xrr8HL+tbjXeecjGCaSjN+ESmExe2nY0tdsO0iR7uTpgJ/AzCsFOHH3UcjROHHsUfWl4y1c35x2FZscl73q9CWMAEkpXVDAwM4ni4fQl+v+hQlJ0s1hbnTHVz/mEMF4qwMtoT1lwbw1DGFHsxMNgR/GLBUdh3eANu3PvkaTl5V9jixOlzTd44ht3iJFvPLsyqCbxd8aJsagCwZRgkoBAKh5SVbvNkoVYVQeKbWGkhPWCpDeyQyguHzCPtYoqaptEsYlrTMoTD2u2Q1A0B4BfFQ/CLuoMhkInoAUGRSqvLUHKtQbdzaC/9u36jpAUNkvaqCqNTuNryOTwcrvcpkz9Pmu1WNTw+02YqnXoAltrD9fkBfczC2iEAwAETG/DRnl/i3vq98P+aXq/bJG9+aYEe3BHtBTrMzvebw5SqTHW5mVSDqhRqk0ocvD9DyGPFfAIu9R3ZZ2La4EpJgPuYoi2kZK8b7BrYNR9BMUVDuZJ8Bn69zh1JU2NirxCrr6j+GaPgME1D/uQ6BY6k3JXbSZ881u6w/1SaKXxLClhK43h8qIDLXvpWQIhQt1kOW6UqwRQcti2KQlZr0wlkXNhN6apbFQo/F+RHtZUSZqbj24MUGqfQe1balvygvqZyi25fqTX8/cY19+KCVb/Bp47+Z9zdsX+0PlJ/YTqCtHdMZ4zZbakeYxMljp9TpI7B9Cpar3SbmXpojyfpSbFxTnbdGQ/bzOobGVUW3ifFCoNdBndoAq7jR/QGmxRXLBE+N5+URnyq5xApS02iA5/rk1IjNCaqc/T7TtFULWawUPdTSi9M/1T7ZIfSqDz6XD696x/rWoB3zrsYsCxkJA04t5lUpaj/KnqezfVlxjXFK3r3E1UuqNc21FbUr2qKBCzTRZhKpu6PzzTDFE13+bcuqOCi3ttx8MRaXLD43RiQ7Re2bhMrQ6nxz/O7qIZDlm01/VbnpLkC69Arm8H7ZGOKgXJs0zJFuQOASrOsaVNKzgljyn7ejiXtTt/PMoMIdX4FtmDi7MwJNWWEh7m1IRwx9gzqPBNGNzCYDA3lifiCGWQHusYHkPdrOGn9Q1PdFAODPRr1NZJ3nEE2oGY52KuyBU3+BA6ZWDPVzdkjMKs88MKx4dWRGovs3Oy5jVXWlF9RSocciOsJ+w0yqSzPHi29u/KIcVlgm5JYlZeOvbxCedjp67hKVU9t2SZVyRFC4GObf4n6oIIvt5yMnrYF4WJKyGMvn18Ir7/URlXeaF6stItZCznyPk2iQevIhNfJvNWR9it9aTvs2auEx6+0UMJpNqTQ3IUWXNoC/K1jP4w0kWdQRkcy40mddSCuYRuBvaVKc3uck4VTqumxAeRvJJlYHBR0f2Lt/LR9PJmIpLwpgI7O+N6sGopTCyG0B4UTzLNJLyvrKnP1YTXm2ZPCXhdVLZXtSbVB9191XNZUcGXthEprA+2j9y/0h/3bIQ+4J51grROj+Mn3/hO/3/cQ3DD3Vag6SdukfnvkgY95ATNJLWlY1MK5SQqbLyvF1q/XRsQZ01680vyQ8pIr6HvnULVGS3rMClspaZ7GgrKn/3PIq/Bk23z8bvGhcQ99m3oOeh9HJtjX9WoblumjSU2K24o9apYKj7BOPNkusLde7c/L5KFUtWYAyFCSqyM9p+zBjIQKhPGp7Rb4AYAg8q66o8nE6FojRYwp0uXVhc+Na3yoegUARaD4HUlJ0GoOwfbCjkXZVcVjmjcobfoxGjvkGa7OD9+Xh3mr8W/3/hBfPfQs/NbVCm75TaHn3R4c0cespKjRcBIpCTSgLrRdAdWdGFlGdDYRRsLz/TSOZfQ5M6AdC7GqqarKckDv5Uaixkh7qa6zBuA/C2fCEQFWF7oj28Hv3UpbMnopUkREMiRMwpEMrrwdgce+kJF3Tsblau9K75/WuxyBUM+eI4buPz7mzaxhmmNudRAHVTYiI3xkxMykYfyh+5CpboKBwR6NE555FG2lMRy24Rlc3z1zvG4KFTeL3y0xkrIGBs+HM55bicZaCXsNb5rqpuwSPJPvmuom7FEwE/hpjk25Vrx/zjnYt7oF6zJtU92cXY79BtdjMFePrdnmqW6KgcEeg5sPOgo9jS0YKNTDG57ZZt31fRyz/gncseiAGUURMDB4sfjUsf+M1z5zD36918umuim7HA21CSyZ2IIHCsumuilThplt6bfFNsY+SjRjDVeiuLi1ZCiVNZrdktJUTw+BqPA0UzM4FJdTi1mP1VU677pNTC1RSWHC0uH43lI3etENAKh1yBAUa8RScoRKzOFIbd0W7bnPjMlwEEe6ZIiq2qRDivleHZJ2e4flPkQlYl1bFSqj0tCZUR1Wy2wOQ80T++gPEL5Pbim8Px9Y9Sucs/p2/HDZcfivl75OHocS5igU5RektmqTbgeHPKNy2UT7YTqEogV5pB/NSbrROZlVRGFQ1Td80natygQWr0BJfKMy+ai2Z1bInJGwrIiyIGLqDFZsGwDIDOp+btc0JWJCUvGYNhZPUpV9nuolcChXaRNz0jwQhn+5HkGe6ghkZZg+6CAaIJmOOw4Kq5i2Pk6J22TPVO0G7vNMQVOl32M1Iig8XW2UCX811l6X46xFh67zHFKW5+TS4w7TEOX4YqGAQi+NQ0XlUzrVIsC1j1+NReNbcfHR78O9c8OXd9o45NB0dQ7R72pJql+MzqBC6m76mLTKknbBmtMFqmsh94uJF3CYXt0ftpeyrWIaq4VMJ4i6HISTi9Mj1Do5TpnmWUfvDjut9gPrikc1Jvh9wjVEpG0QyX1i7SAKjVOSQhUkBOFTXZNKq0zoDCz8fMkxgACKmyj5cuPW5HmyRDdRy1mAvE6PmZqk6HhFJv1pKNoaizYom8BJ+Tx/KmyRdKBCetK+OyDpPPyM5JjZq7IFX33yuyjbWbyt4V8jyqBT5roe4bZMhVJ2wqaxGaPKqXvOVBoWmPBSRET4tTGhEuDTtekzQ+H7pNZK9DlVi4Br1tg7Nh8w1mIao742sf2NZhBWdi5D1XbgBDOTKmRg8EJRqFXg+jtY9WMGQFg27u/YG/25ejRXxra/g4HBLEBDdSL1I2CmYk22A4OZemzJNqGjOrL9HWYoZpcHfgZhyehmXPO3q/DHuQfjvxpPnRWh5L937oOzzvgMhnJGC9rAAAD+6YG/4J8evANXHfNq3HTsUVPdnN2Cb+57Gq468Ex4tnl9GRgAwJf+ej3cwMflh5+Np1rmTXVzdjkCy8YH93svht26qKr6bMSssoBenQuXFByUljnTVZhmEYVAWX2Es49lKMyhffIUmlE0Dg6dO5TYrWgsTP1Qe3NIt36DznCvtIbhpsMnViMrfGQdD7U5WrVChWE4JO2RekYgVSMULQWIUz+i7ShUp0JgHKZmTXXRGZZptql8sD2eIvnoUFgoQ+WF8+HxXVIDyg4mtVVhWfBgox4TKHWGihix5yE4DK4y3JPNCNsf3nO7+vxeC1bxYDqCU1JhUNqYI6Lyg4rLOKvnbZkAwpTCqnpALrk8ptmvwuCs3z2iO5MKLjM1hMeRJ/WYOdzukLKT0hD3WY/YkQoHsXC8/qnOxX36Fc89iraJMVRjevN6p8IWbTuUTag1kj3gsS/Pa1dI6aJKFLRROWb6R/U+FXn8OlK0oLFdGCH1l+iayPZIzXm/jmpIbBjW5x8MzyVayMZtspGFhyy0Tr9fp8+p7ilTmvg61X0MeGzS+ojikGOdd1IZqUiFIlI084lCoyiT7pC+jzF7KCk2bPfVM489e4NdhiDnIHBd2PI9aNHYtKVWuVWmd0s5GeXi+ipBnlVslPxcupa3otyyw9yZ4Lopki5D/UOp0PBOvlQz6ygPYe/hHthCYMSri5TkYu91qUonSno8WkQdCVqkUyxNGQna5igqDwA08TgdkF5w2sdeMhcAMNGt1au4boVTDu8fa9s7w2QvJuRvnyku+j6PIA/LC2DRepueUyCV6GqkFKcog0olDIhr01u+XE42DFn6QJDUmpgGPytYqbkK3zuuiyHttKLohvtLyh+9C7CD/thZNYGfSfjOgSdhZdc+qDouMLr97WcamitjyPo1DKFh+xsbGMxQnPfWi3DCM4/gjr0OmOqmTAn2Gt+EtYU58M2rzGCWYmu+GW965aewfHAtBnOz731oCx+LJ3rxbHHuVDdlt2NWWT2n4sMlPeAoeZX0xTnxSVXTnCzZRH2hsrfbLnM1UJn82cpfgOShzyQT2bIjyUp8/CXsyPXVOXVYiy4gACqd5H3Ky685R3815oYpaU1WLsz36vPEEmalh1/pOwM6gpAbpgQR+rofmx9+tQcZfR/zg5rmYqmkN/qq5EQ6FXaIeSsHid+/je7yq/rvx4V3/xa/azkEV3edpttE27kZVR2WPP3kQa80hdtyJILbZKuKcPwlTN0gI7+gxSRfysrLUm1MekYzJQ7pqMYZz9vuQlDIRMk/7HXnJCLlCY0lJ3I/lHYgppkeq/wZruf+V2sgj25NVXlOhohiVQLZqy+9zBZ52AO4+OPSgwEAucFwmUuJqUytU22p1fN1UPNlYlVsHHLynfI6UdE4IT3wFkfXOPlzjHSlFYraTqiqsAFr03PFWzslTUvaw8+s+zGOHVmNT+39T7jX30e3WUUqyDPHnm2VmBtQgnpMfj1F3CBwtBfR8kIbyf2FE9yzMhnYpkR9VCn60tUa/uXzy+fseSYtbXdA2DaEbcNvCJ8r1y5IrbjMWt1qfWwukIxksWeXaR7V5rD/RIIRiEf6Utur9MNpGSfQV6ou7sssRWZYX0e5U3vTs21hlNzaSPMLGlsqIpjZSnklpAnvyirMQZv+QGD988gO5PRcx90aeuULFKWsNOtxVGuQ1WW1Ix9+s26zI+0tVywWlPBanVNEa2UE/73yKjTWJnDGSZ9HrVGfXyW08rylVpRVdotcJyfpja+16HZw5erscGgP2asee3bKduRYaCClEi0n3asyOWT3/TS7lwJjLQymHcbtHDII0Fkb3v7GBgYGMxIVK4MAQHdlYKqbYmBgMAUYzNaj6JVhC4Gu0uBUN2e3Y1Z54GcKPrT+16j0Z/HjRS/HprqZr/2+LVY27o1zln0QA5mGeHTEwGCWoLE6jn976CY8MLAIVx99+qxIYt8W13W9Ev9vyZkoOSkJDQYGswDH9D2GE7auwl+b98Nf2pZPdXN2O4Rl473H/At6883wbWfW5ZDMqgm8M16NhUVVQoRFYXQ3hSLDYWzBCQ0q8Yg1Pzn8LH9bFDrnZCulYc4JFX5DGCLijmixbnEOOGnwYeT7a/i//Y9DtdHF0DIu8xz+bXqa9KMphJTtG0+0U8Re/iH1pbJAvxSjyuIU4uEEsOxYuAGHgEpt+j6X2sNtC326TQ1rdWhewaEk2FiCjaWS+8I2l6wMykEQJpOxlnIx2ea00DgA5AdlQl+d3oB/2xXZN1jz2knSiljj36aQYiBLLrsTnAiUpE0ompbtJe+Hwa6BX5eBJRVMXKqRwEljQiUycoISUeWQTyYpZ0b0M4xqTPD6sWQdApESA7U8qifA4d0o+dLGvsMbcWTfanTVBnHtIa8CAGTH5DFT+imgE9By5LDm9qmkT6bo2BMp/ZK0yq2MtG31mhYTSwpTtoVoNVwjwpVa2x63mZM7neQNUsfvz7bAqnqwvJpO8gMQSDsQT0wluyz/xuhNRCtSSa4xTWlqR7VZJs7m6N4xa0mdi8PgRR2St0uSbkA2zldJz2n0DYOdDpGxIVwbthwTfp2mZqgx4YwSfSyFRssJ7Jw4rigVAb2PuJ6IejcxVSeWcGor8Quuq6IooUzrsnDImmfxyq0PYwB1+GvdvrFrdJiqqdrfoKmtta5Gva2i7pYneQ9VJXWE19OY1nagqE8p1/NcxqVcbi3qkN7nlVa6QzTGIKXmTp/fCHs8gI0Azigl4JdkvQZKSLXnhNfPcxmVCA8ArqTu8tgPMrpv1OT8LENUZ7YtgepHzJJNqTUQo/bKtrAN8mo7NjWfVRP4mQBbCHxl2VlYLHqxvqF9qptjYGAwBVhbPwdfPeAsTLQZE25gMFtxy7xD0Z9vxBN+11Q3xWAKYKz/NINnu/jjnIMjGcXZin3Lm3Dq6CpsyrTgx61HTnVzDAx2K7bmm/HzhUdjZNHs1UAGgFMGH8ZhY8/g182H4pG6hVPdHAOD3YrHmxfi8eaFKPTM3qJmWb+Gf9rwZ+w1vhn/Pv8N8K3ZU9V82kzgr776avznf/4nNm3ahAMPPBBf+9rXcNxxx72gY9ilGkSDnvh69UqrmeMdrA0sQ9ZEu/GIAqNCYaxkwWEvFXZzJ3Q4pjSHstEbwmMxpcIdT4awKh26zWXpcZvoYHUJvW12KPxb6KcS6ZOEe7ZtJwA4klKQ70vRlaYon0e6zZ6iE1B0KztKYXjJAsgNc0lkOr9S/KDQO5emjjSUq/redHrDePXIw3gy1xVN4C3WZpUZ7Fz23ae5jqIAZUeI1kB0GEU9cKmcNmu+q8x0QSE9l+Q8HfnMcyna4tyfbKk/bM+iapovBjvFDlQDiGL43CptevDwOFRhT1YYYGqICokzRSUtLMp9yqFxqKhySpECADKjUmOYQuscZvcVhYYUojLjTPmTv6lNmWEKKcvx4UwmO+sk9cn5d4QsaUVLG+k3kQ482xOpD8+a6TzOIyWNPFFgSLfZkbQ0pjmy+sWhI8/ihNHHsTbTjkcKC8KF8p4FXKI9RY2n0qLbwTTDtHHK9D7HVfQ5ojPENJylPcynKxhZKSom6vjCT9cON4jjxdqBwLURuDY8qRDH77NIK5zGa5BPTpWYZhF7rzqqf9B7nWiyqn/EKJfU5yOab4oyGaueKUUUAIA8v6B2Zvu1CpIl36GikahurLinlF5IYQpOsk/z2ItBUmcCml9FfZ6uo24T0ZIkdYZrLMSUcSR1hulHSkWG25QZAl636W4U/QoWZtdiTbZDNkDV8iAVmZ7wPvktpDxIlL5aa7ic54SsMhjdf54n0tgWmeTHgxCkViUV/1jZRs2r+F1h7aAq3bRQofnhD3+Iiy++GJ/+9KfxwAMP4LjjjsOrXvUqrFu3bqqbttsxf6QPew/2oKGcUiBlFuHR/Dx8q/U4/KbpkKluisFugrEDGvsMbcDikc1wgtldFey3TQfjuvYT8Ghh/lQ3xWA3wdiBEEWvhKVjPegqzz71FYawbFyz4DRcs+A0jNuzK6HdEmLPl/E48sgjceihh+Ib3/hGtGz//ffHWWedhcsvv3y7+4+MjKCpqQmvPPjjsBq1jqnSPGfvizuW9ICztih70JV3lysjKh328LjhyzVDFUZrVBW13Bx+jRX69PnVtqwnX56jvxa/8NCNeHnP4/j3o8/GL5eFnueAPMvNq8OJPUcF2DOYGQzXW1wZkJNlpNcooKQe9YXK0Qf2EqpIAuuscwVIdU85OuE1JJOGuFpibkC3zxmQerRl+lJX3gGXPCOUVOO1yWQV8pCzl2W8K9yvfiN51qrJpKKY54SiAhwViU7PVXzHk540FelQmruA9sJ4Xhl/uu9yDA8Po7GxMbGvwa6xA8oGAP+YHeAIT5odyFLUKc0OKBsAaDvA26XZgVqjhbt++DEAwKlnfx5DedXXw+2UDQDS7YCyAUC6HWDP8Y7aAWUDwnYk7QDfzzQ7wMm0aXYgsgHADtsBZQPCNiXtgLIBQLod4MTCNDuQZgMAbQfSbABg7MCLxYuxA5ENOOjjcJ0cyt2h53iCaqmo6HFxve5zaeomLP5gpVTe5H4erychKwVTVVMWSKhK28B2QEWD+B124qP34pK1/4fH6+bhw3u/M3EerkoKGVGsdegx4VKSrr11KPxRSp8XqORX9rBztXalq16rT0bX3FIyeR/QfT6mu5+ipqXqNgCAV6RkYHms7FYdabD7SVpaVYlm2yBFSARVjmZvvKo67xX0tddtpkqx8p5y5DVWb0JFYthDz1EF2f5aIzE5vKT4gFcr42+/++x27cAe74GvVqu47777cOqpp8aWn3rqqbjrrrtS96lUKhgZGYn9mykYyxQwkKvHRGZ2c+ANZheMHdDIBD62FJowmCuGlZgNDGYJXqgdmKk2AAACy0af24Aht7j9jQ1mJPZ469/X1wff99HZ2Rlb3tnZic2bN6fuc/nll+Pzn//87mjebsfnjz4HQLxS6myEI3y0eWOoIm8M2CyAsQMaVSeDs173GQC6mvNsRdEvo05UMW4VMWH04Gc8XqgdmKk2AAD+3rgMbz/gX6a6GXsEWmujsITAmPBQs/b4ae1Ow7S5Umub0IoQIrFM4ZOf/CRWrFgR/X9kZAQLFiyAX5eBQ6EPV+qkehT2iSUWyeSFWCiVtFXtqgyFUriFS5M75aSucm6rDl9nRsLzxsqxy+QFr4ETufQ5C33h75FFOrRd7CEKznO9sqGUKNmoJ7hKGxUVoghQsoolE0XtlGReh0J+XMa5MC5DYRRGtEe5NLW8j5wURgk0UcIfh7mLTLEJ93NG9L3r7N+A63u+jXE7izftFRox1t0VUSJROsVBrZ/o1CG57CiFwlTeLmvYUlJTdjgMb3JonhNTrCB8trEEZ5mtEtP1D6KVBjuAnWEHhGtHfV6NUQBwhyjh05P60E2U7JThkLk8P9kG1iLPyNoITKtiKlul0U7sk6YNX2vSkbZSR7g/f7xz/86OhL8zm3QYWRT1/iopDJOxJlXSPtFm4nrGItYOABjvlAl5Hm9Hv4NwTObYxlCbVTl1HptsLxVtx6LQPYeNT+t/EO8duB1/qD8AX+p8dbjQV3bXT93Hqcq6FJToz8noNTmOuR2gRDpFp2Hd5gzVe1D23OYE6JSkN7YtiiIR2LNHQePFYEftwGQ2wKp6sBwH+V75TrH1OHfKSQqMParfPUIlVxKljhNakVW2n56/y5QKmeTMmuZW0rZwEnVNUtS8vN7HmaPf66qeCPcpbl+lLfydGaF3+BbNnRcTE7IZ1KYUfgYnho/spWkoyg5UqK6kXQvb3/qYvo5iD80LZJt9ame5jZL6ZTJxZpjouNSWiI7s2vjk0zfjJWNr8YWO1+DO4j7yAHLMcr9QtmGCaITbqR/D2vuOEp2g+Q9DCR0ocQoAsCgxXfcJfe8ULYrfRWIH60Hs8RP49vZ2OI6T+Lru7e1NfIUr5HI55HLGGzOT4YoAZctFxZrdMnqzBcYOGKTBEgJVy0F1FnndZjNeqB0wNmB2QFgWPMuedXZgj7/abDaLww47DLfeeite//rXR8tvvfVWvO51r3tBxxK2FftyUp5lm9xM/NWrE0dIKpA8LUEu+YkaS2qTni6bJabYw1+TX5YpH1uxSqQkc/Sq/ntxWP/T+EXmUPxh74Nlm+jrX+3HX4AZmuTW5HKSZASvV/J55HGwZLKKTQ4pmyQbU6s1sqSjquJWpcQNks2Kqk2Sx6PWrNcr6SXRrL9a1zhL8LrOT4WeUvmFzfdJeTliFdWa6DrltUxGRXJk4g17zgKWhVMefkpgsX3a1rVjfwGd8BfzyksvjLBS3B0GEXaqHXDsaGw6JBPKHidPJjZxBc7skPYEqagYe2e4Mme0jNZXWsiTU5EJWKOU+Cz7KkuYsdSbU9Vyrp+660dorEzgK0e+DlvqW8L10vYIlk8k26MSSS1KjMUYJYdmZRXoPCWuUqJlRXrHYt5ydXi69NwwRa1kBMInzyEnteUGqslrZslHmRxXna+T7zKj2hv/o7aT8SOcHErRqf2kDWRvJIsLKCk6jnxW6pPjL99HVXBpWyVrF7P11H4l3xeTIOWEP5UEHEuEU892dlOitoedZgdkFE71NWciOQ4ZLM+oxiR71WMedPkOZblUTr5UUoTOJInb6ljlRpacDs/plnWfWzDai3Of+wPGMgX8v6WvDXflKDi9ZwJJL8sMkXodVwhVUTGm5DkUDZLHtUv6Xe9OkOfaV7LNehflxS636rGVG6I5QCQfzevZWx2e0xkhQQt9+Oj6rKqHjy95e/Q7ehZZeS9q9DxlZJWvzadnoyIcDk1pWLpTRTFjEqJp3nKa57EELhwpLU4MBbsimRgUkREUPXw+7PETeABYsWIF3vGOd+Dwww/H0UcfjWuvvRbr1q3DBRdcMNVN2+1oqY7ihM2rMPpsLprAz2qYF96sgbEDGvsObMT+/Rtwy14vjSbwsxrGDswaGDsQYsLN45W9D8OHhWsXn46yk93+TjMds8wOTIsJ/Fve8hb09/fj0ksvxaZNm7B8+XL85je/waJFi6a6absdd805AONuHn99ybKpboqBwW6FsQMa3z3wBGT9Gh6es3iqm2JgsFth7ECI/lwjrt/rVKwtzoE/yyauBiGmxQQeAC688EJceOGFL+oYtifiFUBVmGOSfAGlaRpwAoqjQyNKw5nDWvm+pGYoWCOWwrpR1S4u8SlSQqkUjnmqZT6eapmPiToH2bGUZDSpc4oSh234ouVXOodoPAr1So3lWHXW0Uy8vdgmDK90mTkZl8JWQuqxWhZVayTYA7I0JIW1HKIy+SlV8D6+7qco2xl8f8EJ2JIPPZBBjkN+UqOfKASZEd3mvKQ/eRRa5yQSRa3gKmxplTaZgmGnbMthTKX7G6vaJ7fb0cprsx07ww4A+n6X23UYuNpMFCs5/rKDFEtlO6EoOPTMnRKN7ZTEb8tPahhzleQoTD1GVB0aU9nN4W+vtYi/Yz8AwJiTj+yPHekJ0zjlCr8y1CsyHMami5Lj1GZteK7EqkwT9VVFG1PJ9QDQ+CxVgFSa2EwFGqYw/pjclmh8QROpSsnr9zm8LOkGHeUhfPzJ/8NjzYtww+JT9C4qCZH2UfrOYZvlpZEgQa3IFbSR2F+Q3Xbk9Sv6z7bwZRKwoOS8WgPRIRpl0lpVHzM7FD6nYM9Xdt4j8GLtgNeUB9x8RM+MVStXlXyZAkOiEuo9U23g5EaqISH7N/f5gKh0qv8ybYb13dX6Wh3RcmRX4boSTtnDTV1h9VlnqAQX1RgNlTXhoykGa7uzHUCKLDWtV5WUY7aFKbWyWU1Pk2DHSHgfyy36nBNz9DEb5DjNEDXRHiPbo6i1o2O6HTRXcYbD+cSJ/nN4+dhq/Llhf9w+76W6ffI5Mq0IeUmNpGcbq5YtaXHuuL7P2QGiE1eStR0EUQ4tpRNPzz7t04rnAK6kIHutJDaSUncgDcZaGEw7ZP0ajh94FK/uux++4Y4bGMxK7DeyAYcOPosj+56Y6qYYGBhMEV46sRbHjD+FRdW+qW7Kbse08cAbaNTXSjiwpwej2QKeaF8w1c3Z7RAW8IWlb8aiUi/6sqZaocHsREdlCIet34qHOpZE1VhnEx5vXIArD3gjarZ5jRnMTtjCx+KJXswf3oy/Nu031c2ZEvyy+aV4LteBVYXZNxeaXZZPiBjNwivI3xStCEiVRNErmEJTbqFscun8zQ2n0yiiEA5lKbO2rArHMDUlKk9MoXNWaMhtLeEtG/6Ef974Z9wy/xD8+2HnxMv2yhLBTIEJKMQj5PU7TKsZGEICVpIOEwsflSgMrq6JE6cpw91SpYxzFGpiGonSZOXQfLMOJ1UkzSEzLMu221n8Zc5y/AXxMssxVQB5qFqLDg06pNaTGZWKH1667rLKgGc9V1aiUBQan/oTqwGp36pcdLiTojBQuFRpAtuGw7i7EGRs+M1hX6yR+ki+n+kuSZUZK2YnlOpCehlwpfZgU+0CRUUDdLiUFVcUhYzrJVjjRLERUpVhNFx/yVPfwz6lTbj0JW/Dn7p0QjuHzh0ah/awVJwhBSohqP2qCvg4lSanehKZkfC4PsnyZSSNr+kJXeGS9aW5HoU+T5BYH7TqDxCfakA4E+H4y29NKoMMI48/OslJS7UlK9tJFBi2p5Je6I7rsV0kG62eOSvL2LES8FL9gnTiY0oU8rQeKW0p5RtAv09idSnkMpEacDfY2fAKDuA68OUcwKno94hSh2P1OFZKUe8WpkDF7ICib1aYVqOpIap/C3p3MX1Tg94tShN9nGux+GitjuCah6+GDwtvzn4IJYsSWameQzSH4RoQTNtUdoLnElQ/ptIZjs+YPjqpbik7UOjT7cv1h9dsV/Q7eGwe0wjlNU82P1K2g+cNIMj36VPFuXgqP1c2isbkhLSddM3q3RuwqhCbYGkbsoNUE4TnAIoay8p71E8UdSamQEX2PC3JNqLz8LOZrFbHNphdE/gZgocal2C49+9YX+yY6qYYGBhMER4uLkLGDjDupPBXDQwMZjwGso1Yl2/HJqcJ9X4FJdco0cwmzKoJvF3xYLuUnCC/mtmLGvPoyo9Bpdm8LdQXeK6fks7IY6a+Jn2qIsjefKUF6tcnC004saQa8gxWfTwmOvDWI/4VNTuD3EA1nhhblxzAFuu9+rJNjeyZJj1X9YO+erW+corePKA98FX6UiXPnlUnE0fqdRIrt0mo/fjr305y24Osg6WjPTh66+P49bwjMJhriHkEYl6ylEppMS1eVS3RS3+2UZLqOFfKpGuS+/EybovyHHKkQV2TFZBXVH6pCz+ZHGOwa1BpyaLaHY7z/AB5XmMeW7mM9Msz4xxtCZ9hFMVDPHrnjsn9JlGHiKJzHCmTnhpRowQrT+u0i5aG8JyyHsL1jafjmyUBWBayA+Wor1WoQqNHyZO5TfKYW/QxLSfFO+QkE+oA7WXMDpNncVyOo1FKPiN7FdWd4PHsko1tkBUw6T5kekf1tuOqUibdx0IeJw89DN+ycWfj/qjZLjL9Omrgd4f3iSMmLnk4VRIpXxvbcJVUF9Ojr0u+KtlDG4soqmRk8vLlhmh1RtWooKR5lQTpGTuwO+BUAzhBEL0zuC/U5PhyJ0iTnN4Trkryjml9p2jHUxJorIaI7MsuedO5yrjyyFba9ftS1Z2IVfGW5//A/u+Dp4Q0qE21Bkrclu3n6qyZEiVNTsjxmaekfrIjquaNTzrxNkUgikNh/88N0lxI6rcX2IOd0ZTXQFUkpoghm4moqqkzSZ6b5+G8sbvxd2tfPJbrBiwLdr+uQh3ZnnpKipf3hyNmbCciUQqe31BCqifnTTbVdeCKu76sm2FzEiufSwkJxCKv8jcv20FVIZMBOB1hWajZs7MC6RvW3YV3P3Mr3r/611PdFAODKUXNzsw63WMAcISP8/ruwMc2/QpHjT011c0xMJhSVGfpXGC/2ha8ZfwBXLb5x6gPKtvfYQbCTOCnORZO9GJ+aetUN2O3YWXbPnikaSF+seCoqW6KgcEeAUsEOHz4KWSCpBdwJsIVPn7V/FKsznfhbw37THVzDAz2CBT8Cg4ZXzPVzdhtGLHz+F1hf9xSfyDGZimNcFZRaCwvgE365SpBkcMhQaYu+p2hSK4Ch9R9GTJnagaHwlQ8yKcwOyc+KV1pDrGoJFtBtJ608JwzWsUbev+G83tuxe1NB+DyxW8M2yJDZC4lWVgjFDKXHjums4CS0liPWUFIbXkO96NAA8aWbY0lrlLibLNMgOFw/IDWdo1C6h2t0aJqK4X6RsLr9/MO/jTvYPxp3sGRnmx2lBJ8B5MJpwFpOVebKGmoougAtA87M6PkUr0/J7S68j5WmyhMSaXV3RpRCrYB62xHYVamORnsUjg1oelOnPdM7gxFcxCTuDgURcsiaoeT4gQSBUrAojLkyk6whrCi0MS02WmceU152Saimrk2vvjYjThkZA2u7DoDf2o8EPnndP8qLW2Lfo/uG9ZLaKD2Way7LNviN2nbwKFeFb7PEl1F6UIrnWgAsCbIBqowNtFmUKePH0jKXywprE8nwSrdZ4v2r3hZ3JQ7BDflDgE8AcCL2Sal68zUQv6tqI8u1cpwRlPG6yRa0SpRje+NIBpArVFeEwkasNa10pd3SO8/ouD4s9OTuLshHAvCsaKkRU7o9IuytD1RN3hMqsR0Tk4Mirr/O2qOweVX6PiKOsu0K054VWOK3yfRmKexz/OGtmAU1zx9LTLCx9uXX4zhTDHW5zJDsp1EEfZb9FwHcsxzsm61kbaVCasWTUWyI/o/2QFVQyLZf9nu5Tfx/EhdL82piikUYB7bJX3Pe9CG/8qdHNJiZA0LpvFGCfT0Dlf3lu+d26fnR76kTwVMkbGZBis1+um9nyHWjpVGyWWaZCElWiLXx6jcTG18HhgP/DTGgw1L4MOCDRGfXBsYGMwaPNi4F8acPIqzNIxsYDDb0ZdpxIZcG7ZkmzGnOrz9HQxmBGaVB36m4dlCF/7pwA9jyC1uf+Npjreuux0DdQ347bzDZyXv18BgMvx07tG4ee4xqA3P7ARIR/j48Njt+Kl1KJ7Jzpnq5hgY7FH43KI3Y7DQNOPfj/NrA3jz8L24ruEYjDrp1d1nC2bVBF5knVhoJAJ1+CyFnYJceHsCyijOjFHYSIZla0UKNTWQ0orMZHYoVMuUjkCGi1iZRoVlY3qorGMahYXCP4O5+m1CRMmgihghuooMAVlEleHwt9JJTc2SFhQm95MhZaumtZxrTTr0X20O709uQE8wshQyVxSbWlsy6x0AloxsxrueuxWOCLC+pR0Pti+NqA1McaiQRr9SF+BMeQ75qVCYFVOu0c9JqU4EdUSPGqKSyrUk5YXDpKqfxVRG1L0lHXi1XvhJ1RyDXQN3wkNxi9QCnyAVIX7vqd8U2MqO6P6rQuo8nrmcejSO61gJgs4lKSEBh+HlsVyihYkcKVnIEKs7rMeOXa5CaqZo6kpZ27B8jz5/TVJoxpY16/V9NA5TahE4RBuzy+G2FtEQle3kdsbpdapYhm6H36RD974MKdujFD1gG+bL44sAZ5UexkmVp3Bo/0acN+9dqNquDpPT2MtIJQwnn64uhpKkP7EN4/eCtNsBUWhiNSDU+6CeNa2TFB5+r/i8rVKiYMkNSccUhkq3WyBsC8K2NHWKI9i2fIezPadxbsu+Lqh/lDv1e7+gFKYmUSmK3rFEk7D5/PJ96xAFS9FPa/XpUza/4KAXDciQfrnTp2szRDUkskRtJdsTUfnIBGRGmToSnlepbwFArk+/DyMVqhpxbNTYpHHgDGv6nT443eci2w61kN6N+Rwu7v0jDixtgGsD/zn3zFhdi9jHi7RDsboacnzF3t/07lXURqZE+TQHiN7nMW156htqDsHlQcopCkXUd1SbY/Ts2o6RYwyFZoag3ivhQ2t/iTnlwe1vPM2wrjgH39z7NPxm4WF4sH3pVDfHwGCPxZLqVnxg7C8zklJ3a24f3J7dC99seUU4eTcwMEhCCJzU/xDOGHlgqluy82FZuHbOK/FYYR5uaD9+qlsz5ZhVVtCry8ApJC+ZkxMtQV+d0jvEyZecpKA8dqw/7pGnJar0R1/yVoqnlXVI1dcgVxXlxIco+YK+NKsteXzwoZ/ghK2r0CFG8K8vew8cTqphXWfl4ZnkBa88VYKiDrbURmX/HOtLT3QlIwmM7EjSq1Ra3KKvT3qfLErayZC33B0q46fFlwH1AsW1YWZxTuqxstc9FsmQz0xVgwO2qYrqpTwH1tuX9ycgzyIn96kkFtb+dlh73pm8siJrSqtn73vG87a7IBwr0uD2ChQRI41jV3ppOeJmj1NiuPLSNlPEjZLNVbI4e3F92laNX7YHKjmUE6wqXTrlVPXvLJ+HvOF5UcMX+25GQ1DB2kwbflU8KLa+bqP0LnH14AFKcK+kqNiwd0smq4t68pIpXWVKVOPqq6KOU2YlyJ6qqqcZWoZYApesp2DZGHGKuKLxFKCpQds/9dfn56SSBLlKs37ONWmj2cbGKqlGUVDOcCZ7qU5J9zEzqu+zqvjM7w2+58IKf/sdOhKhIome5wCPwGAXw64FsEWgnzX1jzSt8EioAeSdFRy9pTlAgxSSGCN7kVIPpNas39EunV/VkuF5hYoEC4e8/h3kJZbvIWfCw2FDT+Nja36GKhw8kFuAjZkW3X5OzKUxaw2FUXqbEswtX/dPVQOCo9RcmT3ycnPVUVX3hCN2FYq0RZVYaexS+5SXmvcX+QyezCzAioZzUesII/dcA4KvSXnzueZMlLTPdq0uzS6nV0V15Ti3OXpB4zyqL8PCI05yDhCLAMjj27Wkbv/2MKsm8DMZ1+19GuaV+nDj3idPdVN2GloqoxjKEr9/hnP7DAxeDMp2Fjc2HYNDJ9bgzvzMiVS1BhMYdOhDwNgBA4NJcV/TUtzZuj+eDlqwyW2a6ubsFDjCR71fwRDk9RgbAMBM4GcMNhbb8b4jPxTj6k1nzC3142sPXIv1dR34Uvdr0Zdt3P5OBgazHL8pHoTfZPebMS+4E6rP4KPjf8bPCgfhhrojEVgzw74ZGOwyWBY+v+/b4PYMTHVLdgosIfDhLb/F4ePP4f/NfzX+2rTfVDdpj8HsmsBv81JTYQ6VnAXEk1BVqJTDRk5KQgJTYFhHNaJKUCQuM0CJH1IPnBPA1Pk56cpv16EslSjnxMo8Uzn4urDRc+0hNHolPNq0CHaX1oJW4Sil7Q7Ekyqj8sZE+1EhPQ5lcQipDvWJNvlE+1Ghap+Syph6osKPfM45Y0Oo8ypoqo6jOlyCbYuYVnqm3Cj3ocRXvvfyt0XPjpNh0rT1QfdBJa5wm7l9leakVi8owSjSCafz24H8bSUTE4WYGROuaYEAqDaF993Ls447Ud3kT05g55Lavhw/TLPwibZmpVC07DSKCkOF84l2w7SeiA6WEn4FAKgxXa/txdEjT2JVYQHGnAIcGT62KBldkL56FDYuTVLDQCZ6xuyFXOZYk9BRVPs4YZTC5FHpcrbNTdrbPm+iDBcCuayDoKUZsCz4rcmonMNazDKRTuTpPnJpc9k8HrscMlf33Ktje6X3d8fDNttEmWMqlLo+7hvumLaNyslSowRnRbMUgbEDuwN2NYAdBPBVHQJ6H9jyPWbR+6JGtEe/PtyHKZOccFprkNvSo3SHaUzJrhRLfE7RCuckZ5Xs7o7rdpbI3ijKBQstKPEKRwQ4wV+DP+aXAUGSLgJA01goCVUQFc4dKsfaDmxTwyKaN/CYkO91ptB4KbbLTv8oV+/orF/BnNoIikEF1VwOgTyvoq7ENNv5/EHSBqtk3hjNL59S+4bujaIPAYAtbaho1jaWhQhUIqrD9iblXcDiCFE9ItrOTtsnBbNrAj9LsGh0C/7r/mvhBh4+8tL3Yi2mn/d6VeNi/OuB78LWbCPGeo2+tYHBC8WpQw/hw5t/i9W5LnxswdtQnobm/vvNR+GpbCfubVw2Y6IKBga7DULgU+N/wLG1tVjsD+BbdSdMdYteMCp2Fp+Z+0bsX+7Bfc37TnVz9iiYeOQMxOZCC9YU56Cnrg09dW3b32EPwfzxregs6bDf6vp5GMymJMEZGBhsF08WujHsFPBIYT4qVop87h6Kl4yvhUNiAivrlsRlbQ0MDHYMloX7MvNRhYMHM/OmujU7DFsEeMn42uj/FTuDB+sWTWGL9kxMP5fMi4BXdJEdI0qDpIbEFApadFhKhU3tCoc2KPNchsSdEe0htim8HOmjUyjHHiUdVBmqtgKt6hCFoi29TKSEf1kdhWk5EAUEsLHi+Pei4FUxnCsiZ9cAIWBBwFU6sfxCpPYpig63WVED7Em06dUx7UGtO2t1NEe/K+2F2LEBwKXbYFd97DW+CZc//r+YcHP48IHvwbDPerBK9kEvUu2z6ZjOOF2HCotxBrhIyXCfpMyxevYcRmeWi1uWIcsya3vrDTwZcs1waF1l5Qc7lmFusItgIyoJrp4jgFiZcF/SKBxaz7S2SqsMozPthp6r0gaOhcmprygFh5gecLSSwrdkb5RyQSw0zBQaGQYPpM76c3XzcGHhfPRlQtUWu1yFLYKYxrHXoseZXQ2vye2lgZZSV4KvyUkpnc7XZEmaYExrmcYk20sAOKPvXlzY8zv8qXk5vrTgdfDmhQ4IVnzh+6zojTEVEXlMDq0zxcGXykM8XmukqqVsrDVJFFvVqGAKDbev2iKpBfRscgNcI0LSDSg0H9ExjBrVboFwLAjHilguAdEo1Hs9YPU2GgfVRqmJXmHbTrY/ouUxPY0UYyQtM0a/8/W51Lsj1s8V3YtpWTwvkb+tcf1iVXv/Jrc//p5diD6nPqKX2SJAUKdpICiE72hR4FovrMKj/tI443nDeAo9UK2vTBJBzyRtn7BtWELgMxtuxhFjT+OLi9+AOwra687KPWrs2yV9fKariDT3tKIM0rm5BoQl6dQ22bUYpTGfHNt8n3xJn/LqmCaY7Cf8bDNyWaxG0A7m+hgP/AxF1clgOKe5omds+ju+8uB1mFvZMxNbNudaULMdlOys8bYZGOwk9GUb9QeBEPjshp/ggjW/Qc6vPv+OU4R1+XbYACac3Ha3NTAw2DH0ObrIYrM/gWt6v4cTRx+bVE56KiEsCxuybfAsx9R72A5m1d1xSj4cTiZRX0H0oclJIlUn/DJjffFqk/5ay8rEKadCFTop0TJK9uKv1rRKe6xTKnVMbcdJbgeq3kqJE46WcoYtPU0+VVzL+DW8Y80f0V4dxZG5J/Hz1pfFEmQ4whAld9IkemJJKN2UHeJ9yPPdLyu9sreZdW2llzwzSAk2to1FpV6sLYQl0Utw8el934HNuWZUnCysgO6TuhauIqeiG2yAUrRb+T5ZnGgn9w9oWcAJq/JY1XqucqsPnxtKPkeHqtT50ktXac8n1vPXt6qs59Vm1VCcUtgVP6rKW22ixGOuyuspLWjyqseqcUq9X87Jou9O5Z0Vk9RGSG+Y7NNUpdjNJhNGubJf7OiyX7HGcK1Ve9leUtqAI8efQXViDX7d+TKsq5uTmmAVNOQTywDAlu1i3WPIpEt7gipYc2Xn+tCzx1GDmO1xgLmVQWwqhdutcrrxL93/hNXZTmCsDEtFC0iHm+2VM67aRINTto9tA9t9NbY5MRUp0ZNYcU7qB0oLmm0ke2hV+7iadCxxV+rEu7XkvRd+LbHMYOejVnQhMi6ywzIS5iQj0kGBkjSpr0R9YZL+kR0J93dL6cnmQSTqQP2DJqqq2imLZ0SRJq5JQ++McnvY1ly7lo20cykfwY6NN/Tei/n+MN44eh/+PO+l8C0nshmx6rClZF8MJqvXILuyoEiUnSL4EfO6q4rNQqDFG4NnORiWUfBvLzoJv116JNbUd8XGJnu287LOTmqSKPT453vmt4QfMlydlecykegEz9MoSug1ynvKc4lYNXdZ8bas9+fon0KtQfctryjvCX9L7eB3lZk1zALUbBcfeun5OGvj3fhF8fBoeTaooWrvfm6sJQQuXvcLnD7wID6x9O14oGEvAMDaujm7vS0GBrMFjzUsxKeX/RM6/FGso7GW9WuRs2J3oqM6jM+t/hFaamN4/4J3YswJX+irc127vS0GBrMF3+54BSbsLO5u2w++LCqWCTx4lrOj88adipeNPY1/7fkV7isuweWNZwMAqnYmnLwbPC92KYXmC1/4Ao455hjU1dWhubk5dZt169bhzDPPRLFYRHt7Oz70oQ+hWo2Hd1etWoXjjz8ehUIB8+bNw6WXXgqxB4Z+9mRsybfgmqWv0vQUIXDVs9/Cpet+iDnVod3aFmFZqNoZBACWTfTs1nMb7F4YG7Bn4d6mZfh158ui/y+c6MX/3XMFPvDMr3Z7OH3YrUM+qCIrPCys9u3WcxvsXhg7sOfAtxzc1H4snq3TE+TX9a/E9auvxokDq3Z7ewbdetQFFcyrDqDgG8W5F4Jd6oGvVqt485vfjKOPPhrXX399Yr3v+3jNa16Djo4O3Hnnnejv78e5554LIQSuuuoqAMDIyAhOOeUUnHjiiVi5ciVWr16N8847D8ViER/5yEdeUHucih8L+wgVxaAIDCcjqVAsh0MyQ5TcoHRIKSmMExGikDuFWzJlKlVclrc/RQeVqTi8Pgq/UXgWLaTtKpEdSU+GUgkbSyubsajajw5vFEOtrfAl59Sq+Sl6+TI0z6EiDq9J6oxo1jw7ngyc/vTdeO3AvfjSgtdhfb4dAPCt9uPxp/r98XjdfFgy+S5W8pi1Y5WuMtFy1HUwXSBKmCN4zZoOwJflZ5MUJebeq/BbcbN+gVSIbqF05n2Scs6M6d9K5561ptNqCLglec4Zmry2p9kAIHwOVia835FmM+JJiyrxiOlOrCXuqNLpNCY8SoRUNoMpOPHEcbmIw7+B7B9cmttN2hOHEz89tlcq/Js+oSnNDek0mVHdD49fvwpFv4LO0lCUVCkcJxy/lhVri2LB2BNcrjy0G0E9JZeNEZ1G0nFyBeCNG/+Kg4efw78e+C4Iy0YZWVy671sxnClitK8G1OSYJ216X2q5xxJn6fiK8ue3UEKeyverpY8pZzhM9GPt+rTkPE5e8xqo7P2oPD89urRkeH4XxErQq2tJCf3HEgdnEPY0O+AVbCBjw6sL+2d2mHTgKzLJlBO4mY4lbYPDSchEl7ElrUu914B4XxIpieHs+naULnhKgnhMK3xcH0fZnvIcPQ7ynECvEtxprqJqnQDAKx5/HN3VIWTdIKqfYG+VohSWBQyFv53WZn3ONv2+VxS5WD0FdZyibtMirx9v2noX+jKN+Fb36QCAx9v3xsca3olHGhchEExFC+9pfBwlE9gZQT2Jf1gqYZQFOeQ10/O0x3kCKI8ZS2DmmjXKrut92DaobVk7PkafGw3nKFmaCwTyOTDdd4/Qgf/85z8PALjxxhtT199yyy147LHHsH79enR3dwMAvvzlL+O8887DF77wBTQ2NuJ73/seyuUybrzxRuRyOSxfvhyrV6/GV77yFaxYsSLGazbYcTxdNxfvPOAiLCltQYkSxv7t2f9DNvDwzfmnYH2h4wUft94vYUm5Fw8V94mWHTPyJPYtbcIZ/ffhG/NOAxCWfX+8bv6LvxCDPRrGBuzZ+N68E/BIwyKMu/rFV+eX8d+PXoNH6xfiS3u//oXrrwuBOd4I6v0ynm4Ipd98y8IbN96F4v9n7zvD5Ciutd+eHHY2a3e1q5wlBBJIBCFAEklggsFkbJINBoOwseAzYF+DjDFwsX3BF9v42thEk4xFMjkLkAChnHNYbdDmnd3ZiT39/aiqPqeZEchGaaV6n2ee7a3urq6urjpdfcJ7zCTGd27EouJhAIDNYaEF9GDfDK7X2DXQcmDfxk3DL8eU9hV4v+xgu+yo2Hpc2vYRXikaj1cw9N+u0501MTDejO60Gy1ekYumMtWBk9qXocsdwONDTkBauvAuKRZutMYOlA8a+bFXWWjmzZuHsWPH2hMWAKZPn45kMokFCxbYx0yZMgV+FpAxffp01NfXY/PmzXu6yfsV6gOl+LhktP1/WSqKyR2rcGR0HZLMN35K41LcveBhHN260i4bFG/C2c2fYlLnGrvMn03jmVX349eb/o7SVJddPrv8SPy1chqerDxmN9+RRm+DlgF7GYaBJUVDsD5M/T+1dTlqkm0Y2tPgWLxfs+0N3LxlNvqm2u2yozrW4NzGuRgYb7LLjuleg0c3/Qk/3P6GXZZw+/G3QSfhl6MuwLLCQbv3njR6HbQc2LtIurx4s2w8km4yKZ8SXYrBqRaUZoglw22Z+HXt33F109t2mcvK4ptNn+K8xo/hzZLlfOamF/Gn5Q/ipI6ldtnnkaGYXX4Efjb4IqQNHYL5dbFXe7CxsRGVlZWOspKSEvh8PjQ2NtrHDBo0yHGMOqexsRGDBw/OqTeZTCLJuEejUWH+cSXSMENk9rFNrI70v8xElZImGG4G58dK2olUGbmwcMYaxUDhjZK5JMNMvYpBgbNK2BzGnB+aW3d9yrzHOYzpWBVVz7lH04XenG2+X1FZNKIPrjr2Bozp2IK6ikr75X3oyg2Y1Lwate4yzIsITtZRPdtwdcNbmFc4AnMOHQ8ASLpdqN3SBz4zjbJkF9o8IgnT8rKhWF421E63DACuJE102x2HmRx5P6tUx5li6mebU567Gjkiw3Mj+R382inFI89cdbjFVPY/N395GBNBRnFJc2YSPzf/ifp90dxIfs7/rFyyjAPU9293yQBgx3IgE/LCI+cPdycxg4zxxaueK2N7YmwCSjbw589ZiJTrDTelGmzMGynJfsE+lG2zLB+nLM+B4kDmssHF3c5kEKgygQPEOQ5w9gvmdpMn3fubZePQ5C2ExzId5uvJ0dWoSHXilcLxqHcJfvZvbP8cR3avR3fWi1qUAAA2uEqRgQsmZOpxw4DlceHlcul7nwEMODntFVsNAKTLSUZnJEuTfztj+oqTC4+l8mFw7atin/DkusUAzAzPZYeVK+O5e57DbUldixVZjLfZ7jMujzg/taqLuydJuW7upOl8f8MeXwtkLLgMC1395fuWuW0p9wX+zIxsLhsZZ2QxONuUdIlwpegcnkNC5RZxMNtwJjiV74Gxo9jMUEb+MevJw8PO37HKzTVbQoPWZNd3S5nB5/tvq07DYT2bscVXDkh6+QGddRgb34aBiWb8qUtY0w3LwrW1rwMA3nYNRadbrHE2ohQxlw9emPZYz4T9+NOw0wEA6SIhzzhfu7+V3GBttipXfsuK7cIcYGxBjjw80p2FedYquczdIbm8RFLKY7YOtJn5wFh6uLzg7jjSZTZTQHKds5O5pV7T4SINub5h759MOj8L4Rfxb2vgZ82aBcMwvvT3+eef73R9+cxelmU5Kf++cIwKWtmRyezuu+9GUVGR/evfv/9Ot+dAx/qiarw0cJLj5fOv6iPwv8POwJLIILuszl+Gd4sPwtKwMzva1RNn4DtH/wTrmEZPY/9Cb5ABgJYD/ylMw40FRcPwKU9bblm4f/AZeKTf8Wj2ElXdktBAvF00Fo3eYruswVOEbw24Djf2vfDfd7/R6DXoDXJAy4D/HF3uID6IjMZmP7nSNnsiuKf0FMyOHGaXWYaBdwsPwltFB8NkS8pXig7FeUN+hMeqpu7JZh9Q+Lc18DNmzMCFF174pcd88St5R6iqqsKnn37qKGtvb0c6nba/rKuqquwvcIWmJmGu/eIXu8Ktt96KmTNn2v9Ho1H0798frp4U3CbjIvfnUqdxjZna5oFsJgvWUto3npHPwwIilMbLEbTCM2zZmhyuiRGPxAx5co8D8aAqDTAAeHtYQIX8ikuWMC0c0w74uuTXPc8kxrmu88jBLf4KbKl0Ujx+NmosPsNYAEA6LK7pSWaRsdVS9FWsgje55pkHwtkBnDw7moc9G1euRsvmgefBJgHab0qNBQ8MUdo8APBKzbjBNLA8kM0My34Osy9p1o+euLgXbzfTkDJLhxoz3KJjjwOuuelWGvjew//cG2QA8CVyIGPBJfMM8MDlNIvBdskpwbXu7h5mNbL5gtk8YnNKaYc457mDq9ynMgWz8avq4XUyTY09j/h1mAyz5HkWt3Qx2eRT3PZ5Mpny6/Jxzvd/XjICn5eMcNzzbPdR4txEmuaxy420kgN5cm04cmVIeRevoaRzXB752oWccHczNVoe7ZeLaeXVPHYEADuC0lTQPJ3iyDhr5D47DjsLNlfa+3K1rVyzyC016r3C5bKylJiZ3uNW0BvkwI5kgOUyYLkMeHrkQ2TvPZXrxROjAZLNk8+By37kmfsO7nc2J9MFYptzx7uTuRYas5jmhCk1ulwGcTmhtOm8TQ5ue0kX6WH5ECw3eQOo96TDUsSy0xol4qO92zDwQUGJbDTd070DzxLHsXwQaSnj+Nzj9SvZlClgVkKe90J5I3jpPgLNzBKnuOtZ3zrzwsjrJEg2uKQ2PVnJ+pZp4I20L6edljePNpzLM0fGXEWIn5+8wrbqcU8PrwxaZlp7105ma/+3pUV5eTnKy8v/3dPyYtKkSfjVr36FhoYG9O3bF4AIZvH7/ZgwYYJ9zE9/+lOkUin4ZCKfN998E9XV1TsUDn6/3+Enp6GhsevQG2QAoOWAhsbuRG+QA1oGaOzP2K1BrFu3bsXixYuxdetWmKaJxYsXY/HixejuFnx7J598MsaMGYNLLrkEixYtwjvvvIObbroJV111FQoLRdTyxRdfDL/fj8svvxzLly/H888/j7vuuktHnWto9AJoGaChoaHlgIbGrsdutdfddtttePTRR+3/Dz30UADAe++9h6lTp8LtduOVV17Btddei8mTJyMYDOLiiy/Gb37zG/ucoqIivPXWW7juuuswceJElJSUYObMmQ6z2E7DzOb3yeRmbmZ2VWYUbmZ3mKUU3zAzs3MTjkumGbeYN0i8D7mWeMJ5ArTslMY81S43K0nXDu4uwsxOwRYZpMHMTh7mYqNcP1yOgDxmS87KYBZWp+LG5+4gHhaw528WZrksC45z8VTC7ZIg3eEiw/pZ1cu50Fmgngpa8zIzuQrqcXC3m3nMmBzc5KiC+0rJlLYj86R9T4yD1tupuH6ZKYzdv+IB5+2zU907uL+/8Hc/wz4nAyDNqAEVEMpc0bq5u4oMgo7nD6x28TTpEnzMWdJ8zM2zZpiNaTm+3Lx+S3Ke89wGbKy4u+SY4wHeTHbZsodzprMgbdUWPrf5nDZDQuaki5j7G2ufMvlbvty55dAEGSyoTLr4cJdAF+OuT5aJY5OFVFa0jhIq2K52XDZwM7m6fzZ/LG9ugLFDNkjZ4piH3NVNushYLDjOyhNIZ3nz67/MgEveE3s2Wbp/v8zRwQMXPXI8WftpPoh9TQ5YbgOW20Co2bT/V1DPhbtAcRcb5abC92fCfKzIMjbmeYB8qkBUFujgLjT8HSz/BHOXZ473Ehu/3i7pEsrzCDjymshylivFKArkHOtwqXO4kcg5wfns87iWWIyHXZ3v4GFn96RIRHiwL2+zR76P04Us2QqHXS9bd8Q5UYCUXWkmYz3SfYn1N3dxVusSzu2ez/WWDw3eZ64uEe1rBdmijz8z1RYut1XQMnObMXaXC82/g0ceeWSHvK8KAwYMwL/+9a8vPebggw/GnDlzdmHLNDQ09gS0DNDQ0NByQENj16P3RMzsAmQjASBEX4gqoIF/yTq0aC4Z+NHNgiDiucGGWZbRjNMTqYAGk5WZfhY0JwMlfa2cTkp+4TEtnDfKvrTVl3KaHl1Pn1yKKk+cZYhkAa9KG5/lARNmbsAr1+B7ZTAPp8lzBGUlc/vElcqltUKKfR3zADGldbLoPo1upklQ53ENqNTCZcNMi8CenU3Ryb5+va2MWrNUBPCogCUA8LDn5O0QVhF3noytAGkX+H16YrmaTQcFldRYZAqYhlNRYWV27otb4+vDSGYAOWz43PB18QAwqYlh2mgeXOmOyTHJVTFsyNpaGaZRSpYy65vUuPJsi0q7lQ2y8SGzhgJMCcg1xzx4UmoBHdobM1erwwP1HQHyio6WWxHZPatAUZNpG1VmQ66NdlgdpDwymdaeZydWwXdcm5kspTnt9angOy6XeUZmOadYm5QlwpE5lwWSubtyn03eINY8GRgBsmBw2jdHPyrrKKve5G7Y8vZ9LKu3GjsuM4/c1NjlcKeycFtZIjNwaD/F3zTLrMwzn3u7VOBrLrkEQO9QntmZk0MYynK/A5mv5hK3DirZw7OnuqM0flR24oxDq84GnamCvZmGmwe0KtnDteo8w7wKcuWyhckJU2mcWZmvQ2qjeTA5e/f5moSlzdPB+o5TQgbUPGP9UMwzIst+5hmX+XY8kdMm9cy4xYM/O1vuhxj5RYA9e5mclq95OK2tXU+I3QcjwoDqC953UnYlSum4zA6ySH8RezWRk4aGhoaGhoaGhobGvwe9gNfQ0NDQ0NDQ0NDoRTigXGiS5UF4WeZD5ZriSpM5hJtNHSZStZ9zJCdzzRxOTnVprmGBYOE6FtAhTUQ8+NPyCBNYmru4ZLipypXTTh/jnlcuOv5OaluamYPsbKHcrMSTkaprubjJWmynivIHkyjzMudbdZinVfBqF6VkzpvJjLnIgGXGU4En8PtyyowdZFM08nBm2yY1AG5pquOmfwdfq9z2uFjWR9bnKiiPX99gZnZLmRzBYPNLs3qk6dHcT4PX9km4XLYrnDfGuI55sJHc5IFo6RA3o4vn6+vk/OPsdJUjgmVT9Ley8ZmHL1i5W1nMTO7IVaHc5xIU9A6Hm4dogIu53fDgT7esK8vNu5zrWWWbdGSCpftTpmrlngaQW5gjMJaZ2SlDJHPzYyZpdWy4kbm4JHLnAs+/4YDyZuCmfdn8VBFd08NcAm3XBh5Iz13dpIuOsYOsqMpFiMsOnuPCJ2WvyUz/jmyMMkiSu0PY5ATalW6PwJ3Iwp3J2q4UDlc2OU88fG5lWBZu5TaWhxseIBcx/r7g4zPYIp6/v5Wu6WIECiozqIOgQQ50vibJeih7sUKSuWFw2eLvFOPbx+7TYO9D26fQz967/H1syPw0gfwupe58rsV+5V7Hgkz5+JayyZErJUIuQCo3gmtHr0bVP3ytwVXSXtkX/D6kiwyf7948pAF+1iYl6wG2lttBJlbL5r7n7lVMDuUhssjmcSO0dlK1rjXwGhoaGhoaGhoaGr0IegGvoaGhoaGhoaGh0YtwQLnQwDAcPg12ZHUeVxgASEUU5zrjeOXZ0LvFP36W3tfysOhlaTrxdpHJmTPaALJe5lKhOJi5yRV5UyZTmwMtZA5S/OacRYa32ZTl3lh+87BiqCDTN91HlkXiB5rJ/ObqYK4x6po+ZspT3Kec6SGdh1+bu83wY21zFjNzB3LNc0Yil8HByRPPOLU7cyPkebp2Q7kecIYddi13VtXJuef5hRVntienzMPGg82PbWnT+Z6CkcrAlRKmZG/nDphEpAsbZ09xzCPpHpFinOd8zthMEtzljrlZuOLSlO3mlUqTMjMzc8YiZX52OdKFMxccxZme4m49rP48blqOfA++XH0Od7Hx9OTmPrDknHNxpi3GXqHcDLg84zks/NKN0RtlbWb3pNwLlTkdoBTsAJAJK1c2Ng/lNR2p6tk5ipM7w3j5Hbk88rH1cDO5NI87njdnL1OMMkxGcyYN5fbjOMdw/tXYvXAnTbhNk41/Nmblu4czDzkYW+R7IM0YUUxfLpObN57NKQNofnP3Ou4Kl46IOc/ZUbwxmTeCjWM+D1Ml4pzuvnSOP8rcdpqkbGFMcFzeOd5TajdzLXGbQl652DuQyw5Xl5JnPE+OdBfhPPBMTmSLQjnX5AxW6j3p6WRVMrc1e/3G1k9u7pqiXH65C02eZQ93p8nrlsO2FY+9we7dzRn1siqHAHOf4wRXsk84e52RETLW38H6eyddarUGXkNDQ0NDQ0NDQ6MX4YDSwJt+F9wGDyySwSLsC45zBxu2poTq8DF+cjvYin2hZfkXovzqNrn2iF9LfsU5vtCk1sedJxMoAHglV7WHZYJUHLAA4OkQ5yeqI3RN9oHpi2ZkPfm/xFX7eUAmpKaKB585sospzXaWabH4V6mdITI//zRlU+RfyjxLoqzXywLuEqL9FtPaO7Kf2YGx7JK+3P2OzG0JFkiUJ/Mch51dlmsxGBe1CnTiQbRK88KtMIobPJPObxHR2A2wLCAhNGpuHlBcTBohJQe8XTSmvV1URUpmDk2zLMk8qM0ttW/uHXCum0r7xILblAVoRxk+XSp41BEgzq8v526SB6LlBltxzZqniwXSJVWm1vzBmba1y8jVsvF5wrXltjzh+RhiXIbmCeZ1ZJoV9SZLGPlANw86k/OYad4MWaenm2dW5hlnpfWOZ33k/SAtDVmHJYFzQUvO7Qjjnjdz2881/BwemUOABy4qzaXSdGrsXph+NwyP29Zye2PMEtsj3pGOfAbB3DmVzZftG4CvKzezZpZZ5lWm3kwhjS+eBVyB88greeRic4NfXVluvD10zVBjbhZmd3EY+ZCSuRe4JcrsU0DtS+YGnPJ5rvKZOLKzKis1azOXLfmCgD2sH+x3M5cHLGeNzV3PtOG8TxURiIcFxXvahYzlWncH+YR8TslyFkzL2ulrF7LB5TiH7iklM7vz976vjctYmV22lN41aZl/w80yM+9sJlatgdfQ0NDQ0NDQ0NDoRdALeA0NDQ0NDQ0NDY1ehAPKhcbfnoKPmYRVmvREOeNFZkFrnrh0eehhJhhulpV1cf5zbppxx6SLDA/cYCakdIFKFUzXDDZLLmjOw84tTdLsy7lFuflWBcbwIFYvc/tRqaO56wj/jHMlVDQVC6STAVjJYjowxEyKbsXzzvjuHYF0ys2FmRE5J7vDtcZuSB7zZIbVL083WJCdGSReXDuQjZnPrBDjkpb96OCJ5+1TJkHmCuTgnJdtyZaSqxI3KSoXCzdLG6/cKjJhzr1tOf5q7AEYBo1JFkytXCcAwJtvfLB55pEm91QpSzfOTcJqGu3AzK7GCpcnCtwlLlPITLmhXLcs8DwEyp2F5UswYpwTXp7H5gGXV54u6cLD5oHF3AjsNOd51D6JSpp7JpM9isPZG6Xr+Dqon5WLjeOabM6pQFJ/e/5cHTYvcx554crjlgAA6kpuB989O1bKI4OXBXP5+B3ueTyINk9bbFch1q5MMT1bxaNtIf940di1sFzi506qgFKeT0T84ZznPAjZDiZnst2xLd258gVGi7pkvdzFhvGve6QLjyvF1gBynnBXMe7io8akm712+ThUOU74dVJFNKaTxaJNgVbkRVa6n/KcNtwFTeWW4IQgpnRn4e3guRmUe6IrnT9gM10m3Ex4P/I5rWSXwQgvEn2Y25u8rIu7+0rZYSR24LLqzX02YJu23O7K7+qmiD7UOku0n7btHBz8VSHbx9eGWWPndOtaA6+hoaGhoaGhoaHRi6AX8BoaGhoaGhoaGhq9CAeUC407noaLWU5cScUCw1waMny/NIVx/mbOziLNWZzVAcz8mw3k+T7ivOTSNOPryq3fYmYhbk3JKguPn7viMDO3ZDVJFrEI8STZgNKF0gxfwFgdoiy9srwXHk0eaBb7uRnYwU4h3VgM7jbDed7VDfAbycd7zl1YHG4C6lq5vMzGDth6VAS6m0fK+7iZXpZxtx9HSuTcdOn8c9cqEhH6yT4UTW6y5227znBLXJ7hoFwD3Jn85n6NXY9syAcrm8u/z91JXGoec/c3by67ipVnbgJAJiT/Yc+fu74ojmMHp/qXsLwAzAzP5Q1rnzo/y9KR83QK+eaKkcwz/nka8AjjupYuBQarRnGyK3YsAPCxe3LlYVfi+Rrc0gVIpa8HnP3saZf5GnibShhbkDQ7u5mZ3WYC4/fOc0SoPmOsWdkgZ7iSZnbGxczZLwxJ9O7toPwfjtTo0kzuYPPh3P5Fsk/5Y5ayzwIbRBq7DZbLgOU2bPdY/l5Xrik834Cfu4bI58qZ4PLOrXyuoQB8sl5+zXQhc3uTY4WPeZV3wsfa4WZj2j62ID/Li2LRybAxx99XNjMUkz18TqnxzZlx+DveVPOHzSNTrlH4OzQd5u5xyhWJuy8xtyJ13g68S5WrIXc59LL3veoT7nak8lpwNz0OJaP5s81mOHOh+MvlIpeHHsnux9kMewYW5hzr6Waui3IMOtymNQ+8hoaGhoaGhoaGxv6HA0oDnwn74GExXeoL2Bfl2mL2FSS/YDm3Ow/cUJysDg7kPMFODp53ng1UarR5kKrNacozF4aYNrxJRm92M40UC2hVmSN54AbnTVacoyZ98DuC7ywZgOZh56gvcc5n6rA6KJ7WAAsS5Rp4FXzqUAeyG1T9x/leecY4HryqIPcbTGvvCrGbkhky4+XM0tDDsrYq6npHhkc6Vlk1uNWBa+vTMgBtR0GK6rwdcQUr6AyMex6ZiA8uUzxrHlDM56nSDnFeYh4oSdkaOdcz259HNeJmmTvdUcX5TuNPBW3x4DI+/tQ1OXd9hlnS1PV5kKgj82Aeq5eVJ3A7XU5c0UpeOE+iTaVh5zzWXButAoMdGZG5dknek5FhQWFsHmf9yrrHNFZM852skkHkrE9cefJz8BwRKrutHUwIp7z0b4s62ibqzLUuGvlyWYAy5Xp5f7PnYPPHa/XZXod6tybKmOZYaqZ90R1oQZUWlhW58gQx88BVbrFWmnNntk4eECrKHVmg1X6uIY/mBlIGeCA9a5Piu3czecVzXGTCKoM7q4wJMbc6jambuYVC9UmqkGU3ltfi1qdAK5OByhLBiCa4lVIFr3IrnpXH4sjv053M1eY7ONvVmozVw4NMbUuDyd4L/jyEIlze8HeEbCrP0uvIwiubymWPGieaB15DQ0NDQ0NDQ0NjP4dewGtoaGhoaGhoaGj0IhxQLjSWx3C6uEjwYA5lagLIBORj1lMe4KXMMJY7f/ClSn3u4FJm7jgq8MVl5ZqlHFzHCW66zzWl5UtTbnTlCX4DkJImcxePmWRWN2Wy98QYt70yie8g3bltPmZBYfByjtp8/gRfEaxl8gAyuc3NSvL6DnM8Ny+q4Lqe/Hz6iVLFwc94aWMsyDCuTGnsni3GCywD+hwuNmyc2Cne2S3lM4OqQLfsV/WHxi5D1utCWnKqO1y5GBTnfzrCgsscPPDyYcfoHHeczXO/Cvjk/ibsWsoFjLmKucLC7GoU7EAsy8HE+Z+TxeyactOdYgGXaRZspeYRD+Bi7UuXCLcwh2tJkpv+c11TlDzjnOoO/nTlbsID+rgrnewT7oboyJshXRy4SduVYPXbLmi5zzHrqJO7HYlybtp3cHarPuFt5s9O5bDg/RghtyPrK+ayCtpzEBUo7vkdBD5q7Fq401m4rawtk7kLi5rnPDgxw9YI6j3iZY8qTXHjdl2BVvYO5cHcctPFXEO9Xbnjl68B8rWTv1yUCxt3CU0W8cBrucGDbVlVdjAvbyf34lDzzJXbJoCCNrlLoVfmuHDw0ecJjOVB645L2nz8zC2Hue4qFxqDRdY6cnG4VJs4H79cX32F7prLQMeaMJ0bYJxl5Bg2T3wPI0RgfcrXfwo9VUK2qRxAAGBmdm49oDXwGhoaGhoaGhoaGr0IegGvoaGhoaGhoaGh0Yuw2xbwmzdvxve+9z0MHjwYwWAQQ4cOxe23344U5woHsHXrVpxxxhkIh8MoLy/HD3/4w5xjli1bhilTpiAYDKKmpgZ33HEHrHw84l8BVyqLniq//WsdG0Lr2BASpW77505a9s8XNeGLmnAn6Gf63fbPcoufK5Wxf0Yma//gNsTPtOyfK2HaP8O0YJgWUhGP/UuWeJEs8Qp3EflzpbL2LxP2IhP2wjJg/7ydCfsXaOhGoKEbnu60/TO9LvtnZAUDS7AlZf88sYz9s6/VlbR/RiojWCAMw/5ZXrf9M8N+mGE/spGA/YPPRz+vJ/fn99PP5XKao3cAw+uxf65gEK5gEAgG6JfN2j93LAN3LANvlH6ulGX/MgFD/EKwf0bWsn+BtjQCbWm4U1n753gmpviZAZf9swzD/hlmVpjDDdg/T08anp403DH68ee0v2FflAGAcJdQ88CdNOkXz9g/NQ/MoMv+JUu99s8MeIRpNwv7x+ep+vG5bQbd9s8K+cXP77N/rrQJV9qEO5G1f1mfYf9ShR6kCj3oqfLaP3UfRhYItJkItJmC41r+kn0C9i8b9CEb9DnmCZ/TClmPYf94/e5EBu5EBq6Uaf/U2DUSGftnyz23ASscgBUOAAEf/dR8d7mQDfnEL+i1f1yGpgu84hehHz+fZFfK/tnyl8EMeuxf1i04+/l858iG/ciG/bB8bvvnAO8zJQ8dc9+EYZpwJTL2z7As+km5z/txf8a+KAeMdBZGOkvvUTf9lLxORVz2z35fBAx6J7B1gacna//caQvutOV4R/P3gOVxOdzEAMAVT9k/I2WKn2yjkc4KVzfLQtbrsn/8HazGvBlwsx97N0l54I1l6BdN5fzcPWn750pn6Zc0c3955IAnYdo/JTcyEa/9c9xzZ4/4sfUTXIb9U31n+l32L+t12z9bTqRN+8flOSwAlnBxsX9+D7J+Dyyvy/4puZgN+pApDiJTHHTMbVfGol9a/LJuw/5xGan6xn6GKdOWm+5EhvqpJ2P/gk1pBJvSOe+OncFu84FfvXo1stks/u///g/Dhg3D8uXLcdVVVyEWi+E3v/kNAMA0TZx22mno06cPPvroI7S2tuKyyy6DZVl44IEHAADRaBQnnXQSpk2bhvnz52Pt2rW4/PLLEQ6HceONN+6u5mtoaHxNaBmgoaGh5YCGxu6BYf2naqz/AL/+9a/x4IMPYuPGjQCA1157Daeffjpqa2tRXV0NAHj66adx+eWXo6mpCYWFhXjwwQdx6623Yvv27fD7RUDWPffcgwceeADbtm1zcvHuANFoFEVFRZh22K0wq0vscpWtlGcqVcEcAOCV2bJcSZ7xjHGjdslgJs4BywIuKLiT8Xtmcr+sMsVB2pbBE272BZaPa5wHXTl4VGWgGg+4S5WxzIWS593LMoE5OKtlf/J7zvo9OXUaXGuk+KNZwB/XKLtjgq+Wax0cdXVLXuduigi0OPe7CvDiPPPFIrtZNsC433lsngxgSzE+Vh7IFpdBrKlCKvP0ML7adnFNXycPRqF7ThXnZrz1MV5ddR7XrtnjhfNTy0CcjJnEu4vvQWdnJwoLKXPb/oa9JQMAkgNHfeMOWCUi6JA/M577QGVKNcO5mQUBwCsz7vHgtFRpbna+dNidUwbQ/OPzQGldeAZPkwWlpQpzs7sW1FJiCxVMxeUF52VWsV6BJuJR5zzwdnAoa1O6lGST4q82Q7l6H39dlOrkAV4qMNchO3iOCBlUxgP9WVZWpbXbEae2KnfUnyf7q4OXWT5HN5ObPNBOPWdvlGSYtyNB9fdI/u0E4+H2MznkyQ1A45lmzQLRFh5wp55dJpPAR+/N0nIAu3ctcNyxt8HjCdj5Puy5BdiB3Z4ET6NNm4q4gHO/8/FpZyxmQdKOPB9yWwVEAl8Yv3k4wJVMcASEsrwk6pxEOY1zRcQAAKbkMuc5b3juBrueNF9LsBwXivyDB8Gy963KbeAIspWHJsppbvvb6PqBhm5RJcsczbPKJ0vkuoPHv7Og+mBjPLedvjzyjEEFmDsC5Xngb6m4T6/jXZBbD5fRPCOuHaCc4mvGPAHKPHeQkts8908mgTkf//Ir5cAe9YHv7OxEaWmp/f+8efMwduxYe8ICwPTp05FMJrFgwQL7mClTptgTVh1TX1+PzZs377G2a2hofH1oGaChoaHlgIbG18ceW8Bv2LABDzzwAK655hq7rLGxEZWVlY7jSkpK4PP50NjYuMNj1P/qmC8imUwiGo06fhoaGnsXe1IGAFoOaGjsi9BrAQ2NXYN/2wd+1qxZ+MUvfvGlx8yfPx8TJ060/6+vr8cpp5yC8847D1deeaXj2HxmL8uyHOVfPEZ5/ezIZHb33XfnbaMrmYFnO5mPPTFhLuFmau5mocw5HmYC8bSTKVW5yBhJxvfaw1xflNn0K1xoeGpwV1Kcw9Msu7vpmsrlgqdgzwaY+c+Qj9TKb+qyuVXZPaeZmd3XKflkObepNBcptwJRDzMPyk0Xu7d0IQtYUamlOccxO9YqEi4+LnbPRg/1iepni3MtS5N7NsBSHjOzWDos9ifK8g9xlVI62MrNmLQ/HZbprFn9/jaeDl6cF+hgLjI9uSZ57m7gjsn2cT59O3Vz7+F/7g0yANixHLDcBkzp8aCeMwC4uck5nOu64c1jSk2XMBetPLzNPE+A5c3Docxpl+X5WR7gxsaKSu3OA5xcjHNd1cn5zz1MHin3uVRJgJ1Dlwq2kzuOgmNcWqqMpWiX84zfu8FM127lQubgj2YXVVzOTB64sowbX8oeHgCXYfzWHuX+yNrk6xByyt3F5Cqbh4qX2R2j65gFVL9ye+LukrxPXflyUHjzuAC589+zOi9TQu5Jyp0mk+49+SB6gxzY4VoglYUrm4W/TYyVTJDmhHI9UeMIADLMlU5xmXM3VoeLjeIAZ23KsPGneMWzTB5w1xa7XjZn1JjlLibxSj/bL3PWdDFu+TYa/+o96Xyv0zZ3x6F7yuNdzd3jGKe57TbE3dfkoekQnZNkbraWOyLr4f3E5pxHyVBqB3d3NpVbD3v0fF2jnpijTbL9PI+N5WL5Imz3JiaPmDuMq0eOiUz+wHNLrRfYfM8GeS4RUW8mlJuPyMNcmqwd1J9zzk4dxTBjxgxceOGFX3rMoEGD7O36+npMmzYNkyZNwp///GfHcVVVVfj0008dZe3t7Uin0/aXdVVVVc7XdVNTEwDkfI0r3HrrrZg5c6b9fzQaRf/+/b/8xjQ0NHYKvUEGAFoOaGjsTvQGOaBlgMb+jH97AV9eXo7y8vKdOraurg7Tpk3DhAkT8PDDDzs0rAAwadIk/OpXv0JDQwP69u0LAHjzzTfh9/sxYcIE+5if/vSnSKVS8Pl89jHV1dUO4cDh9/sdfnIaGhq7Dr1BBgBaDmho7E70BjmgZYDG/ozdRiNZX1+PqVOnYsCAAfjNb36D5uZme19VVRUA4OSTT8aYMWNwySWX4Ne//jXa2tpw00034aqrrrIjby+++GL84he/wOWXX46f/vSnWLduHe666y7cdtttO80+oZANeh1048pUzd1mHJHjspwzObgSLKW3NK0Y3NQaYmwEdkW56X1F/So3OmOiUCYah8k1D3NNEZn8uMldubGYfmayC3LXEun2w61jzFTmkW4eXh7hrlJLm3lMaqzNdtsBGIxZJyXdaXydtN8RpS3bb5aSi4yLmZ2USZq7K9jXYS4O/DklikWd6TBzf2JeOcE22U8+tp+5OxhZ2SZ//jHmjYn280h+zq6hovYzzGSonpmDRUOlkzbzmDB7OfZFGQAAwe0JWCnxfDirAWcTsGS9FjcTMzO4MhlzFxQuOzxyfDhyg7Pxp+DgAJfHWiyNd5Yx36g05dxVzWaHAM2jLDNzc7Yp23UjTGPSwWQh5QB3z/N0EtOKGt9ZH81TJbuyBSSPXG53zjncvc1i+81CMadd+Uz4cLoe5IMSrR72HNV9ZIOceYaZ1qNObnHgC25LyruJMU0gD5MEGLOMg2lCuUIxtxvHO0Y2lcsBd0aOtzyyvrdjX5QDWa8LWY/LnvPhOuYam8d1hM85NWccbEp5rm8w9zZ3F40lvzzWMXfZGkKxnTnqVy4fFnO7YrJBuep52DuWu+cpRhYuwzIFjDVOufFyRj3ePunOw+cxd1dBnrWBR7oSheupb7r7UZ09FaItXsb+lmHv22Cb6Acvcy/iTGDKhYe78/Jnp/Y7GK6ku46D5Y/NTeWm6HAp4u7Cap4bTC5xd2bVZ+wc7vakXJ14m5XLlOVwM9y58bzbFvBvvvkm1q9fj/Xr16Nfv36Ofcpvze1245VXXsG1116LyZMnIxgM4uKLL7a5YQGgqKgIb731Fq677jpMnDgRJSUlmDlzpsMspqGhse9BywANDQ0tBzQ0dg/2KA/83oLNAz/hVrhCpD1S2h0H7zLTyLqkcizLPjQ5t6qt3WJdyINdlHaYf805uFfll7iDezUp9zPNssW06Yr3nAddcQ290u6kI/zrmS6ZKlKaQ7rPUAN9tau28sBYpXl3aMlYnXYgHQsMyTBteqpIcqsyXmVPF9Psyft3BOYyDbw6P1HKOK1l96QijL+ZGT+83eIAfydrEwuQsdvOuHg576/qM84H6+XaSNUnUcapza0G6qufB2Cp55xHW5MxE3h30f7PA783oeTA8eNvgREpAPAFHvYk11ZLfnI2Jnnwp9Lk8PHDA5+UZs+hRWMwpRbclYez3Axy6xnjNVYafh6fzoM/pVYpxQPImWbY18p4y+128AAumSMiSsfxIFkl53jeClvrz3mVmUbL3yI0m64EyRjOgay0gA6edx4kW6CC+vNrpJR10RvjfP65gfhcy6a0lCpnxheRKhdB9WaA7snXTu33RHP7kWvbbfBYZB7UJt83/NnbwW2ZBN5bcLeWA7sJSgYcc/wseDwBCmjmAYRuZZnPn7fEFZMWZz6mHRYcFQnJrU5sXdEtxw97X5olBfZ2Vs5/Nx9nbkWKQHM7y2QTrTXoPhwBq4r8gs0DHgzviYp5yuVdupAsWCpwl6+VuKVPabR5YK+yMHFtc7wv5aTJyPnlYpZLl0Mey2fDrGs8cDYfHBZNKTO4BtwOeGUy1N/K3+sqQJ0H47Ig23Bu8Cn3ZrC9OhzBvswiqvKH5PNmYEWZTALvz//VvsUDr6GhoaGhoaGhoaHx9aAX8BoaGhoaGhoaGhq9CLvNB35fhOVxO8xO+VwZuMuE7eLCTCDxPjyQTabkZm41PLBEmZzTYWaKSrPAEWlO8cRYA+xglfyeTcrs623JDcQCiHvezU1NPIZWmvwzLMW7J8aCS5XpP8vuUwZmJMvJhcBxfkKZIRkPep6gL4dJ253Ld5wppPrjFYw7VXZJsJnMgyrNsiNIldFY+6PiPr0x9myYe5Qy/3G3GRcz1SnObm5mdLjDJHLNoI6gNXeeb2PFec1cprLSPSqb6T38z70dZsgLQ5qp+fPlY9Ydy51fKigLIFOyyUzKDpcINY/4PGYuG24VyOjgI5Z1BXJlDAC4VTAXT6fAXGz80g3A00P3kSpm/OnSHYW3M83mseJYtjw8iJaupcYtdyExC8QB3IXGYVKW/Ww55j4L1lLuCmz4u8D6KSG3dyAPzYBf/mXuCi6Z1p25C3DZpPrcYEHLPO+EXxEBFPjZOcy9TskBfh/8/u3cDoyzmrVPjTlHLg3VD5bWqe0JZL0u8fO57P8V7PmxA+firHRjcZAWFPDcCrl5T7hLhs0Vzl1fuRtuULm5Up2qLkduArYuUUHaGeYukmbkFWZAHBtm7rKebibj1FqHjVkvz/uiAmvTLK9JHrc2Pk/sgFn+3uR8+Ur2sv08YNV2Q+TvS5aXRfUJdznkpAPqXhy5OFQqFtb2eCXrZ9l+f3uu6yBvP3e35G6GinAjVcrWfHwNoY7Lk2eHu1pbyO3bfNDSQkNDQ0NDQ0NDQ6MXQS/gNTQ0NDQ0NDQ0NHoRDigXmqzHgJ+ZhdydwueCm4w5Q4IylXFGF4COzQSUmYOZbXjmcWVKc6RZZqwmzcJ3xiyhyGzFi8zTIDvM8HZkO3NX4dHoksXGyyPkAyx9sWKN8DOTH79/t2SEYaa6ZKnsB5Z2nnnYICMZawKcPSIf4wunqGVmL2U/NxnzDXdl8sQlN6uDKUD0bSFjAXHyqCKnzdydRnF2c/MaN3kqhiLeJm5mtdM0e5j5jpnFFEeug2dbcb47XG0kv661cyYzja+PRKkPHvmsXBnGNNLBOP1tFpr8z0W5UXCXOTPN5qFyieIMU5z0xDbl5pp8OZNDOuRn22IeB9ry8yL31Ag54olxdxG6ZKpQztM2KuQp3NU9JcpJXvg6mUk77jwOoDnhYNNJcdcRd849ObjlJRsPl7EOPn7pBsP54DnzD7FvMDYexX7B5rPNcw32bLmbn8GeQ5c41pNg8sbBaCPdr7qIO9zF5KWSx/xdks9dk8uTVLHoh0x6B34bGrsF6j3hGL9yTHHXDKcLlXi+/Pnx96U61sNY1/g7WnGmc9dcB6OMvBR3j1N5Sfg7zmQuMnY55xdn7+Os+YXj4HTjsNlV2DDlrGuqXjfL9WKGeK4WWRfrE+XOw73CXEw2uFSXs/38nlVbjB30Mzy5LDPcJdKU7oGcOVDJQxd/14dz3fuSJSzfD2eqk/k9HMx/PYy1S5Y7sgHx3EOqzx1uzf957getgdfQ0NDQ0NDQ0NDoRTiwNPA+N8Bj00yV8YwFa7CorUyR2OaaGl8XC1qU5VyLxTW2njzZOl1Mu5Qvu5/6erf8XNPPrAKy3NvO+FxjTKMlsy2Cf6myr2Y7QI4HWPHMjz6hmXdkJpTwdzLNXoZr2cSxngTt59yuyoLAtXA86MstgwN9qdwAYoA0fvyrV2nOuYaRa9tVBlUX02w7uF2VdSSbG6ACAG75VWzyoBj2uFLFftkOrhnkfLWqfsbjLbWxPOhFPWdXhqtnNXYn+Hzm44cHJtnHOjIis/Fta9BzrSlAfp5fHuimtHt8nvnaFRdzfkuXGtOWmwo9cZ7HQGqWmZbNEYSN3IA9xZnOy71ddIZDG56HHzsTkuObXVMF5wOU9ZQH/BkZVqcrlwc+w3JcKAsDz8/BsyOrPg8m82jgdzCnsuFcue7msiEuNesme54x1n6P3OaWS84VLTMum4H8skHdH9egJoqlFTKlg9n3BLzRFDwel/0e41Zu9dwcRlE2vpVVdUcaejvPgMP6xuSBKuev2DyGPh6ErQzuvIzP83RIZhjlaWaYOFPWZ8c8C+fmiuGyJ1FB+R5si/UOtMV2ML+DE11y1zNLQ4CthdxyTrlYP6VKSUaqzOoOTnWH1czZdoAs4wDlhuBEA+q9zLXy3Mro4JHPA2+HlA08AN3HAmvT8p5SuVp9gPHps2zYtnWDEyeY+UlKvgitgdfQ0NDQ0NDQ0NDoRdALeA0NDQ0NDQ0NDY1ehAPKhcaVzsLyscCLIhH0Zac2hjPYRLnDOExZDO60CqBivMVx7maiuFOZWYabXhRnO7u+S5pilfsOAGRYgJfNIczNczzIVW2nmf0szPjbJdc6DzK10rn3xznRHdz4Er4mIl1XbiA8zTM3a9kBnY4AGlfOfm8n46NPsoBCVSfjjicXFbp3Xxe1MyldGzj3e4aTTct+Mn25qZEB5qLDTZ98U5nv2NgwXbnmb4fbkApY9TKTm3peeYLcNHYPPIksIOPGmYeTzckPkJuTwbjbDe4ilpCuHQEeqMguop4rTyPAA5/kuEqyvBKK95m7cjnMwzHpisbc07xszCvzNjcze5g8SntVmzknee6c4MGfjkC9PG51ah5yM7WvLff8bAEzxzMzvHLL4S556Qi1KVkk+a0DbB5TzD9cUky4Mjxvhcy3wGSDK8kI7SW83UxGsmOh5jGfkxaTgbL9VpCRA+QJWHXkBeB9KtuXKtD6s70FV9KEK2Pa8jdTQM9SuW1xl1Ce+0C9e91JtpZgAaG27EjyYGw2z9T8ZO8WPlZt1xMfn8fStXYHwY/utMtxHAAEmlmbFWe6n7cjN3eDyV6HiRKWI0IGn1rsHcdzqCh5luVrJTkPPNy9LcnXR3mCydk0VLLNkTeCTZl0RMw57gbplJ1Gzn77ONbf3g7qJ0eeILtOzm0vnjlfv1h5XBIdvP8Ol0PpPhdi/ajc8yw2BjP5XZW+iANiAW+pSZpJwmWxwWSm5V+2gGcv7ExGdHaW+cFmuU91Vh3HorUZ7AW8mV+QW2Ymt0wt4NkLLcMW6yrKmbdZ3QcAliyGfSgwX85Mxsip08rDfOByJJnI2e3sM8nkYTKfU5P3mdy2WJ1ZzvqgovIzbAFv5vFHZgajjO27mNs2AMjIhBNZ7kvP79P68vOtdK7PIBcEahzwe+KLtaztt88+RLLKR5kLTjk2ZX9aO0hYo/H1QXIgASOd+wHozvB5JJ+HY5zyD3GXrCuXNQFg84N/ALKxqOYKZx1xZVTyJ9YM7pMpp0eW1cn9R9VY5DIKbE6qOc9fgtwfPV+yJAf7Rh6DrZpnpsHnJrGzKHalLPv4drzc8iQuyjA2H+UTbnL2Df7NkVHn8GAYK6ftrjwvRMe9M3mGrCxn92SXMVgm+/hi8ko9W+6j7GC4Sqtnz/xks3LRlpZxEFoO7BZYX5C3tvxl48N0576vuE+ykgNZ/j7jyhtVN3svK+YaWYM8ji3a2fBSMiHDP5jVx/kOEvxk0op2ja0bMnkW8GweOuae3DTzzD2A3p2O6crZoNQC3spdwFtsbroc73gpm3hiukxunZyhjV8/k86zfHVcKzcmSMkRHh9jsLmfNb58AW+zj7F3OH9HIKMUP0zGOdYt0i+f9TOkHOJxcDu7HjCsA0BSbNu2Df3799/bzdDQ+ErU1taiX79+e7sZ+yW0HNDoLdByYPdAywCN3oSvkgMHxAI+m82ivr4ekUgExtdwVYhGo+jfvz9qa2tRWFi4C1vY+6D7QmBX9YNlWejq6kJ1dTVcLm1a3x3QcmDXQvcDQcuB3gEtA3Y9dF8Q9rQcOCBcaFwu1y7VZhQWFh7wA1VB94XAruiHoqKiXdQajXzQcmD3QPcDQcuBfRtaBuw+6L4g7Ck5oD/xNTQ0NDQ0NDQ0NHoR9AJeQ0NDQ0NDQ0NDoxdBL+D/Dfj9ftx+++3w+3MpyQ406L4Q0P1w4EE/cwHdDwTdFwcW9PMm6L4g7Om+OCCCWDU0NDQ0NDQ0NDT2F2gNvIaGhoaGhoaGhkYvgl7Aa2hoaGhoaGhoaPQi6AW8hoaGhoaGhoaGRi+CXsBraGhoaGhoaGho9CLoBfwXsHnzZnzve9/D4MGDEQwGMXToUNx+++1IpVKO47Zu3YozzjgD4XAY5eXl+OEPf5hzzLJlyzBlyhQEg0HU1NTgjjvuwP4QM/zHP/4RgwcPRiAQwIQJE/Dhhx/u7SbtUtx99904/PDDEYlEUFFRgbPOOgtr1qxxHGNZFmbNmoXq6moEg0FMnToVK1ascByTTCZx/fXXo7y8HOFwGGeeeSa2bdu2J29F4z+ElgNfDS0HtBzY36HlwJdDy4C9LAMsDQdee+016/LLL7feeOMNa8OGDdaLL75oVVRUWDfeeKN9TCaTscaOHWtNmzbNWrhwofXWW29Z1dXV1owZM+xjOjs7rcrKSuvCCy+0li1bZv3zn/+0IpGI9Zvf/GZv3NYuw9NPP215vV7rL3/5i7Vy5UrrRz/6kRUOh60tW7bs7abtMkyfPt16+OGHreXLl1uLFy+2TjvtNGvAgAFWd3e3fcw999xjRSIR65///Ke1bNky64ILLrD69u1rRaNR+5hrrrnGqqmpsd566y1r4cKF1rRp06xx48ZZmUxmb9yWxr8BLQe+HFoOCGg5sH9Dy4EdQ8sAgb0pA/QCfidw7733WoMHD7b/f/XVVy2Xy2XV1dXZZU899ZTl9/utzs5Oy7Is649//KNVVFRkJRIJ+5i7777bqq6utrLZ7J5r/C7GEUccYV1zzTWOslGjRlm33HLLXmrR7kdTU5MFwPrggw8sy7KsbDZrVVVVWffcc499TCKRsIqKiqw//elPlmVZVkdHh+X1eq2nn37aPqaurs5yuVzW66+/vmdvQGOXQMsBgpYDWg4cqNByQEDLgL0vA7QLzU6gs7MTpaWl9v/z5s3D2LFjUV1dbZdNnz4dyWQSCxYssI+ZMmWKg9B/+vTpqK+vx+bNm/dY23clUqkUFixYgJNPPtlRfvLJJ2Pu3Ll7qVW7H52dnQBgj4FNmzahsbHR0Q9+vx9Tpkyx+2HBggVIp9OOY6qrqzF27Nj9uq/2Z2g5IKDlgJYDBzK0HNAyYF+RAXoB/xXYsGEDHnjgAVxzzTV2WWNjIyorKx3HlZSUwOfzobGxcYfHqP/VMb0NLS0tME0z73311nv6KliWhZkzZ+KYY47B2LFjAdDz+7J+aGxshM/nQ0lJyQ6P0eg90HKAoOWAlgMHKrQcENAyYN+QAQfMAn7WrFkwDONLf59//rnjnPr6epxyyik477zzcOWVVzr2GYaRcw3LshzlXzzGkgEr+c7tTch3X739nnaEGTNmYOnSpXjqqady9v0n/bA/91VvgJYDuw5aDghoOdD7oOXAroGWAQJ7SwZ4vtbZvQgzZszAhRde+KXHDBo0yN6ur6/HtGnTMGnSJPz5z392HFdVVYVPP/3UUdbe3o50Om1/iVVVVeV8XTU1NQHI/VrrLSgvL4fb7c57X731nr4M119/PV566SXMmTMH/fr1s8urqqoAiC/rvn372uW8H6qqqpBKpdDe3u748m5qasLRRx+9h+5A44vQcuDrQ8sBAS0Hei+0HPh60DJAYK/LgK/lQb+fYtu2bdbw4cOtCy+8MG+UsApaqa+vt8uefvrpnKCV4uJiK5lM2sfcc889vTpoxbJE4MoPfvADR9no0aP3q8CVbDZrXXfddVZ1dbW1du3avPurqqqs//7v/7bLkslk3sCVZ555xj6mvr5eB6/1Img5sGNoOaDlwIECLQfyQ8uAvS8D9AL+C6irq7OGDRtmHX/88da2bdushoYG+6egaKNOOOEEa+HChdbbb79t9evXz0Eb1dHRYVVWVloXXXSRtWzZMmv27NlWYWFhr6aNsiyijvrrX/9qrVy50rrhhhuscDhsbd68eW83bZfhBz/4gVVUVGS9//77juff09NjH3PPPfdYRUVF1uzZs61ly5ZZF110UV7qqH79+llvv/22tXDhQuv444/X9HG9BFoOfDm0HBDQcmD/hpYDO4aWAQJ7UwboBfwX8PDDD1sA8v44tmzZYp122mlWMBi0SktLrRkzZjgooizLspYuXWode+yxlt/vt6qqqqxZs2b12q9tjj/84Q/WwIEDLZ/PZx122GE2pdL+gh09/4cfftg+JpvNWrfffrtVVVVl+f1+67jjjrOWLVvmqCcej1szZsywSktLrWAwaJ1++unW1q1b9/DdaPwn0HLgq6HlgJYD+zu0HPhyaBmwd2WAIRupoaGhoaGhoaGhodELcMCw0GhoaGhoaGhoaGjsD9ALeA0NDQ0NDQ0NDY1eBL2A19DQ0NDQ0NDQ0OhF0At4DQ0NDQ0NDQ0NjV4EvYDX0NDQ0NDQ0NDQ6EXQC3gNDQ0NDQ0NDQ2NXgS9gNfQ0NDQ0NDQ0NDoRdALeA0NDQ0NDQ0NDY1eBL2A19DQ0NDQ0NDQ0OhF0At4DQ0NDQ0NDQ0NjV4EvYDX0NDQ0NDQ0NDQ6EXQC3gNDQ0NDQ0NDQ2NXgS9gNfQ0NDQ0NDQ0NDoRdALeA0NDQ0NDQ0NDY1eBL2A19DQ0NDQ0NDQ0OhF0At4DQ0NDQ0NDQ0NjV4EvYDX0NDQ0NDQ0NDQ6EXQC3gNDQ2N3YRHHnkEhmHs8Pf+++/v7SZ+Lbz//vswDAPPPffcVx47a9YsGIaxS6+/atUqXHLJJRgyZAgCgQDKy8tx2GGHYcaMGYhGo/ZxTz75JO6///6drnfz5s0wDAOPPPLILm2vhoaGxq6CZ283QENDQ2N/x8MPP4xRo0bllI8ZM2YvtGb/wKJFizB58mSMHj0at912GwYNGoSWlhYsWbIETz/9NG666SYUFhYCEAv45cuX44Ybbti7jdbQ0NDYRdALeA0NDY3djLFjx2LixIl7uxn7Fe6//364XC68//77iEQidvm5556LX/7yl7Asay+2TkNDQ2P3QrvQaGhoaOwDMAwDM2bMwOOPP47Ro0cjFAph3Lhx+Ne//uU4rrm5Gd///vfRv39/+P1+9OnTB5MnT8bbb7/tOO7tt9/GCSecgMLCQoRCIUyePBnvvPOO4xjl1rJ06VKcd955KCoqQmlpKWbOnIlMJoM1a9bglFNOQSQSwaBBg3DvvffmbXsikcDMmTNRVVWFYDCIKVOmYNGiRTt138888wwmTZqEcDiMgoICTJ8+fafObW1tRWFhIQoKCvLuV+46U6dOxSuvvIItW7Y43JcU6uvrcf755yMSiaCoqAgXXHABGhsbd6rtGhoaGnsLegGvoaGhsZthmiYymYzjZ5pmznGvvPIKfv/73+OOO+7AP//5T5SWluLss8/Gxo0b7WMuueQSvPDCC7jtttvw5ptv4qGHHsKJJ56I1tZW+5gnnngCJ598MgoLC/Hoo4/i2WefRWlpKaZPn56ziAeA888/H+PGjcM///lPXHXVVbjvvvvw4x//GGeddRZOO+00PP/88zj++ONx8803Y/bs2Tnn//SnP8XGjRvx0EMP4aGHHkJ9fT2mTp3qaHc+3HXXXbjoooswZswYPPvss3j88cfR1dWFY489FitXrvzScydNmoSGhgZ8+9vfxgcffIB4PJ73uD/+8Y+YPHkyqqqqMG/ePPsHAPF4HCeeeCLefPNN3H333fjHP/6BqqoqXHDBBV96bQ0NDY29DktDQ0NDY7fg4YcftgDk/bndbsexAKzKykorGo3aZY2NjZbL5bLuvvtuu6ygoMC64YYbdnjNWCxmlZaWWmeccYaj3DRNa9y4cdYRRxxhl91+++0WAOu3v/2t49jx48dbAKzZs2fbZel02urTp4/1rW99yy577733LADWYYcdZmWzWbt88+bNltfrta688sqcayls3brV8ng81vXXX++4dldXl1VVVWWdf/75O7xHy7KsRCJhnXXWWY7+PPTQQ62f/exnVlNTk+PY0047zRo4cGBOHQ8++KAFwHrxxRcd5VdddZUFwHr44Ye/tA0aGhoaewtaA6+hoaGxm/HYY49h/vz5jt+nn36ac9y0adMc/tyVlZWoqKjAli1b7LIjjjgCjzzyCO6880588sknSKfTjjrmzp2LtrY2XHbZZQ6NfzabxSmnnIL58+cjFos5zjn99NMd/48ePRqGYeDUU0+1yzweD4YNG+Zoi8LFF1/scEsZOHAgjj76aLz33ns77JM33ngDmUwGl156qaOdgUAAU6ZM+UqGHr/fj+effx4rV67EfffdhwsvvBDNzc341a9+hdGjR2PNmjVfej4AvPfee4hEIjjzzDNz7kdDQ0NjX4YOYtXQ0NDYzRg9evROBbGWlZXllPn9fod7yDPPPIM777wTDz30EH7+85+joKAAZ599Nu69915UVVVh+/btAEQw547Q1taGcDhs/19aWurY7/P5EAqFEAgEcso5PaNCVVVV3rIlS5bssA2qnYcffnje/S7XzumXRo8ejdGjRwMALMvC/fffj5kzZ+LnP/85nn322S89t7W1FZWVlXnbrqGhobEvQy/gNTQ0NHoRysvLcf/99+P+++/H1q1b8dJLL+GWW25BU1MTXn/9dZSXlwMAHnjgARx11FF568i3aP06yBf02djYmPeDREG187nnnsPAgQN3STsMw8CPf/xj3HHHHVi+fPlXHl9WVobPPvssp1wHsWpoaOzr0At4DQ0NjV6KAQMGYMaMGXjnnXfw8ccfAwAmT56M4uJirFy5EjNmzNgj7Xjqqacwc+ZM241my5YtmDt3Li699NIdnjN9+nR4PB5s2LAB55xzzr99zYaGBvTt2zenvL6+HtFoFBMmTLDLvmjFUJg2bRqeffZZvPTSSw43mieffPLfbo+GhobGnoRewGtoaGjsZixfvhyZTCanfOjQoejTp89O19PZ2Ylp06bh4osvxqhRoxCJRDB//ny8/vrr+Na3vgUAKCgowAMPPIDLLrsMbW1tOPfcc1FRUYHm5mYsWbIEzc3NePDBB3fZvQFAU1MTzj77bFx11VXo7OzE7bffjkAggFtvvXWH5wwaNAh33HEHfvazn2Hjxo045ZRTUFJSgu3bt+Ozzz5DOBzGL37xix2e//3vfx8dHR0455xzMHbsWLjdbqxevRr33XcfXC4Xbr75ZvvYgw8+GLNnz8aDDz6ICRMmwOVyYeLEibj00ktx33334dJLL8WvfvUrDB8+HK+++ireeOONXdo/GhoaGrsaegGvoaGhsZtxxRVX5C3/y1/+giuvvHKn6wkEAjjyyCPx+OOPY/PmzUin0xgwYABuvvlm/OQnP7GP+853voMBAwbg3nvvxdVXX42uri5UVFRg/PjxuPzyy7/u7eTgrrvuwvz583HFFVcgGo3iiCOOwNNPP42hQ4d+6Xm33norxowZg9/97nd46qmnkEwmUVVVhcMPPxzXXHPNl557/fXX45lnnsFf/vIX1NXVIRaLoU+fPpg0aRIee+wxh/vQj370I6xYsQI//elP0dnZCcuyYFkWQqEQ3n33XfzoRz/CLbfcAsMwcPLJJ+Ppp5/G0UcfvUv6RkNDQ2N3wLAsna5OQ0NDQ0NDQ0NDo7dA00hqaGhoaGhoaGho9CLoBbyGhoaGhoaGhoZGL4JewGtoaGhoaGhoaGj0IugFvIaGhoaGhoaGhkYvgl7Aa2hoaGhoaGhoaPQi6AW8hoaGhoaGhoaGRi/CAcEDn81mUV9fj0gkYmcK1NDYl2BZFrq6ulBdXQ2XS39X7w5oOaCxr0PLgd0LLQM0egN2Vg4cEAv4+vp69O/ff283Q0PjK1FbW4t+/frt7Wbsl9ByQKO3QMuB3QMtAzR6E75KDhwQC/hIJAIAmPDk1QhH3HZ57aIaAIC7h77Ek4OS9vaxI9YBAObOO8guM32U96pwQCcAIL6yxC5z0elI9EsDAArWeO2ycBPLmyU3s7Qb6ZBoS/cAOi5TQinYPR2enDb7Oun8ok3iWFeKzu8aSBfoPiYGAJg0cJNd9od+n9jbhz39PQBAoInq7x4u6vQU0s2VROL2djTuBwB8dyTV83LDWHs76BH9sHZjX7sstJnaNPmMxeI+LXo2n71wsL2dOFhcy+017TKzLizauZ3a6aUmoWuIuP9Jh6+yyx7sP9fevrN5DABgftsAu+z86gX29pZkOQDg2RWH0X0sC9rbqWLxN11GzwYZptGRH82eKN1Ttlo0MJti086TFWXxJOpuuMceqxq7HqpvRz38Q8yb/K+c/ePe/w4duyAg/m6jMefK0JxyJ0W56SHtSO0Z9Pw9neK5+1vYPO2ia7UfKebSE8c8ZJd9f+klAICe7WG7rHpws71dHuwBACxdNpDaVJSyt4s/EuMzE6DrBDqozcFv1wMAmrtpjE2o2mpvL2+tFsd5qc6hhS32dn1PEQCgpaeA6pdz27LoPidXbrS3n196qDiuMGGXjehDdS7fKmQCn1uZELU/M0Lc8+jq7XbZuKJt9vZnbaIvatuL7bJUQsiWwwbScU091KfbmoS89myiaxZtypXL0YF0T0FqMlKF4m+atZM7o2YHiXlubacHEdlEdXVOEP37X0e8bJf9betkAECmJ4kFF/+flgO7Capfh/zoNrj9AbjE8EWikp6/0UeMVauJnl+fz9k8ahYndQ302WXRAfR8izeIY7NMzEcH0/5UpTjfSLNBw9NpusQ/7hi9O3xt4vx4P5JHQ4fX29sXVH8OAPjdI2fbZf4OqjLUJN5T2ydSoyK1tL+nQvxNlmftsppRNOeycn7fPex5u+z7i0heFofFmN/eWEyVxkX7zzlqvl30xtbR9nZqWRG+iGHHbra31342CABgeahzzDDdv7dEPKdgIG2X3TLidXv7NxtOFveWoLVGdoWYvP5xHXZZ99ZCqrNDPBNPD7XJoEsiNkD2TwF77zN468WYiJBYRbwPbRce3QQAOKV6pV02xCdk/B2vnkvtTCSw9c5ffqUcOCAW8MpU5gn54QnTpHAFxAR1Z2lyuYLshVvgcxwHAJafvcRDiZz9br6GC4pruf00gNy+3BeFwRbwWZ8h66TjXEEaLK6EJ6fNbno3wuOVC3iWYNftowu4Qqbj3gCgMJKnT/y8T2SdIXbNME10tyHOCRTQcPKE/bQtFzmuIOsn1id2P7MFvNtPx7pCUqCxBbyVp51uNtFU/+3oPv1xcX1PktoZZO33e73y2rzNrE1ykz+bfAt4V4quCXkfcOcu4BW0WXf3QfWtO+R3jAWFfM/aw8acy2BzyhTlhpdewlx2uJJq7rPxyT7u1bEFETrfHfLLfdQOPo+8ah4G+dxg5/tEuUVD3iFvVF3uLNXJ54dbfoh7fLkyEAA8hjwfbG7L++cLeH8BkzeyrW622PWGqU7V53xuWewDJBvK5pzD61fz151kfeLy5pyj2u64JpfbeeSy49nxPpVVZVk7HdFkcp5bjvq5PBUHB3cgLwEtB3YXbBngD4gFvJLT7H1ryLHKn5/Hy+aRR85tH5s7AT5WxLEGE/N8v1oXGJ4vX8C7TP4+lOuCIMkjPmbUWOLziI9ZtS5wBzx596sx7QrS+4jXrxbwTnnF5VRWns8nhVRisPmqZJxoCz9WwCEb5H6+gLfY/SuZ4g5Qm0JMrqtruV1Up6HWDawdjnVJQtTF1xJ8AW/3TzD/At4dENfK17cA9WmA9UnIL9rsytMfXyUHDMuyrC89Yj9ANBpFUVERxjz9E8QbK+3yrBoYhfQFN24waW0Cbql5dtETvLTiY3v799tOAADUddGXZFttsb39zSOERveNl46wy/hg8EXFXzfTHLePFQOkZGi7Xda5qtTeDtWJB+rvzP/Y/FFRbrIBFB1MA3zc6UIj/fdB7+c9f9hT1wAAIlto4MSk4jzQSsd1D6IbOeXIJQCA+U2kzW7dTl+1SIgB6uliE62B6o8eIjRShw6nz9alnwy1t00pXN0JNpjlZpDV42Jzqu9ZWwAAa5aTudRVQiuo4TXiS3jNZrIKeLYz4TGkGwCQ3UDaRosJcV+HuG6yNP9zyMoPJTfTkFaVigfe/l4VXUcOPTOZwOoHforOzk4UFrK+09hlUHJg5JO34MnJfwcAXPDkj+39kc10rK9LzEN/lF5oriRtm3IRlmYL6KyHadkiUmNG4gbxfiRnvBExLrIZOr+4WKh92jeQRa9qJGngY0kxPuMraL81JGZv33DIuwCA/3nzNLusZHibvd3eLrTQ4YWkeU5SVSg6TFyrNETqpxRbRBT7haZg0dLBdlmoVuwfedp6u6wyELW3Cz3inFeePNouC2+nORMdJPrJ203t4AqJmDCSOuZ2eigJTEspMjpo7nqjok+5tdQXpWejLJ4+ErFIM0WXkstcg2pr3gAcMVFYZj/bSJaQsvfoLR2uF42NDqaXdIJEONKFuRra5865HwDQ3ZXFlLF1Wg7sJigZMOS2u+AKBBBqFOV8fKWkyA8xa3nrobla4MIV9HyZ7ske3901NOZMtohT1+LvDr4uiGwW5wXaaMx1DMv1g3aROEGiQtRVNZfOMZhuqKdSNpC9rrgFyXuieLm3baO1THgDDdDYUNHo0BYq49dXY5n3Y09fcTFPjPoh3ED7LXlL7NsfXcOo0YEmcUC4PvfjGgDaR4sT+02oo/qZ9XDFKrEecSXZ3C8UDfzb1L/ZZc0Zmme3vHYhAKBgIMmw5NJie9tUH+eszSWjaGHUsbIMABBkngGJcjrWrBbCrbyMzLGta8QBAWatNZMJrP3NV68HdJSMhoaGhoaGhoaGRi+CXsBraGhoaGhoaGho9CIcED7wCr8e8xxu8l9i/28uFeaiJHNWW7qYzMOWdK0Z2r/JLrt6zmX2thEV53n7ksn57CM/t7cH+IX52jiEzDFYSOYQZYJKU3wVQvXim6rvODqnrYK5cTQKW1yomWxuzDUXHUNFm7r7U6F/KEW5Kj/eoxZTwERRgEzSgWZhxolspfoDbaJNytwNAFaATF2vfzoOAFA6qMMuc7eQebF4rTiPmxHjFbRdsFKYv9etHEZtZnEBV31HBKY8+M9Tab+8FDdlmcyFrOUJYd4uYC4CySi5DvQfISp4bfqrdtmIOZfa26l26dfP3JvSA8m2f8HJnwIA5reRGT2VJTtq/WvCfJcspbFV3V+4ZwVOIttjy4vSxYeZIzV2L+46aDauWiHkQLqIxnnbwcyPNS62Q430/Aq30JhPFIs50U1eY6hYSHVllW+4i+oMbWG+291iO07eVOgJCPOut5P0Ki0LyQdHudqlBtJgOaQvBZpdWyzG17Xn/59dFrfIbew7G08HAKzYSPPMw8Z36nURbbVmAp0zcmCjvb144RAAQNE6ap83JuRJ7cPk8rbocOqnYIVw8Sk+gdrZ8RHdU0gWRwdRO3jQfmS16P+ug9kEiVE/RlaJ/QkmT1JF2Zx2BtpIHrYcItvO3Gq8LMDYK72S3Ek6p2Qd3dPC7pEAAB9rUtIRjyfalCFxg3g185GQfryeJnL7uX3LNwEA6VgKwJ+hsXthZIS7h3IzUa5aABCWXrQmi4EIDKD38Y9GvwcAuDt9BjuJxmxqq3jR+ZmLFnc/DbSLi7aPpPHZM4DOT5SJ8ZMspv2lx4l52PYhCYxILXPvk654mSCd0zmUkXMME++ubJK5xFXSoC+RAfJtaXphxsaSHJgyUriNLVhP5BQ8pifQKuZKF1sjmEXink6ZstQue2PtGNov22J0kYxVrqcA4F0v7sXbzWKPUswvyBDnb91O/mnhAtYoeWh4M/VJ+eliLZdmPk8/X3KmvR3ZJN3vthXTNZk7cqpMVsr88ts7aAEXqVUugWz91cEIQWSsjvkxLVYqO0SdbWNY3+2kY7vWwGtoaGhoaGhoaGj0IhxQGvgPYyNhMuoi9YVssK+xxEAKgoApvm82rKqmc1rp2KQMSkvFSSO0vos4g178QASvZotJVWNU0hek/6gOAEBXPQtSkF9efUP0xb8iToGYdrALj+dM536umSyavKeTVEGNRSJaq7WTvho751Obg/KyPRV0n0pjkB1PkWZGF6nTS5aLY7OryuyyAtY+T0K0L96HBfmVMBabuGRlYFRtPAj3d5+cKK5ZxIIIhwuNwnfHzrPLHn3hBHvbJR8jDz6z/LS9qYtFlUmsPe4xe/vUNd8AAKwJkMajtJAsLaMDgsLriXlT7bLQGFK5xGSQb+E66sf5S6WWkrWj+CRppelJAn/KaZLGbsDxwQzqB4txc82hFDg9jwVP/mbbKQCAFfOG2GWKoQCgYK1UMT3LuuNof5+Fufu5Zl1JjBAL6vKuF3MzRnHVSLIxn64RcuSYERvsMh+LGvtd+yAAwOdRsgo9PvADe7vAI7RTGRYE6p9PsqFsudifKKO5fe0x71NjpBi68TmyQhatF3M6xURY0Qoa851ZIWfeO5OsApf5z7e37xvyDwDAKC/Jo4P+8AN72yun3MghRJkXz5C8NV4Qsiu7kWSLrVWtpP5Oh2l/gaTPK6hn2jzG5dAwWTJR9KP57l1E7XNL2ZKoJG1huIHuWV2r6yCS+y4/PSdDNuvcU4gQ4a4KoaWMdplgRkON3QRfpwiWNuVQ4gHF7eOl5ngCaY5HhsiC9M0CSS99GFEUz32HNNPq3cytwykWJO1Kix1lK5i2uZsa0Dki993h/r0IdAzSUgSpQqbBrxbjd9A3iR56lJ/G79FFIsh8duOhdtm2jmJ7+63Rglb36f40+v5ef6S9/fH74v6KmFXB30nzR1kLguSsALekb3w1Od4umzZxhb19VtkiAMCPPrrILqt4j5ne5WIoVcgCQkuonzIymDi0kmSYq5u2S+Q87WHytLZF3N9JY2g+zhpHlMIPPnEeAMBgKvDuGn5N8UzSNaTp97Prq/VbGxsOnKSkUDLs8qDnlnFS68+YkLLenVPBaw28hoaGhoaGhoaGRi+CXsBraGhoaGhoaGho9CIcUC40f190JApZsJLiQLZYL7jaWdIByTvO+U77HUvpy5TZacgb37PL6v5OJvfsOGHi6VNBQaTpcrKd9MSFn0h4PTUgWS5MJ588O84uY7mngKkdos2byCbXPoIlZ5CWncEvkHmuczD5o3RViuCJ/uVkC4u+R4SwKgtiqInMY00TxXfeGUMoe9jr/yTzmuKej5eTqYsHcHnrRF3heuZC0E3bwRaxP1FCZd3HEb+11S3a72M88imZHeH6EjJzvnDYIfZ2S6vonzEDyEdh+VpyRdqwRQbSUWI4LEiR+9TWt6UbQg3142njyfz3089FxrtsDfldmB+R+bFAZdllY8vyifssKCXTZkerCFDOxg+oqbhXcdLyM5H2iX7/sHQElZfR821PBnPOCzUzty/JCW+52Nxlvg8qKNPXnt9tzCvHcsk6lpglLvanWZKPLEsU5W4SY35uxyi7rGhIh739wUcie3HZMmrHyBEUNKbMshbjR8+wAPqO4aL+ZAW16UevU7bFW08QmUMzBbQ/JROncBeaRA0JzGsmvQ8AeCJKmZXXbCG3tHcrRUBocWS1XcZ5n5WHUMML5BbkYa5OEUtcyxfNTaxS2kJm7pbxzAUmqdrOgsv6cfcocf1hlcTBvyFE59vPMUTXNH0kpFX23s4J7D620XhSPPOvfTLZLvv0THF/mVgSwB9y7kVj1yJVCLgDQPlS8awC7UyXKYMjm8fSO/bHFe/Y2/WmmPP/Vf2aXfbIafQ+/fvHIueBp5tlUmXrDuXilWGJ33jQo1dmcS7ewNyu5JhMM7GUZF6g3i5RVyPLsnxR38/s7QsLRPsSFsmW7wynOQeEHMcBwCt+8v1QOTK4vLB9wUAuQpxIQsHTRf0wIkyuSLetFEHAlW+zpEaNJDti1aK8jUQYjH60LvCvEY1JHETt9H7KsitvFO/zAube1nqw6NMVaXoHL47RWqv2VMld30Fy/dQTiZgkKV/ocZPaPCdF7xCrVpQ7kk8xIoNgqxhv3TUsQ/tg2RaWnBM9TMh9CbQGXkNDQ0NDQ0NDQ6MXYbcu4O+++24cfvjhiEQiqKiowFlnnYU1a9Y4jrEsC7NmzUJ1dTWCwSCmTp2KFStWOI5JJpO4/vrrUV5ejnA4jDPPPBPbtm2DhobGvg0tAzQ0NLQc0NDY9TAsy9q5cNf/AKeccgouvPBCHH744chkMvjZz36GZcuWYeXKlQiHhfnjv//7v/GrX/0KjzzyCEaMGIE777wTc+bMwZo1axCJCLvMD37wA7z88st45JFHUFZWhhtvvBFtbW1YsGAB3G73lzUBAKVPHvyLuxCMk41HMZUUNDCmEmbuUCbWjuPIRLN+2iM59XP+8EwL1d93mKBV+fiQ2XbZkNnft7fDW0TbudnJHCtMROlmKgw00z3+8jtPAAAKXdSmaz8lM7c/IG4qXkumtMhG5ppyhDivuIhMSLEFxB5TtF4Mh55KZl6WfLCuDmbqqqU6TWm1ivcjk58rQqawmmfEedwdwJNgnNol4v4yjHeX82vb51CT7XTrPFV9uppM5oGNwh0gMZjcYrwhatP5IwVNyOpuMucH3LR/QZ1wtzHXUD8OmkSMJR6XaH9LjGyKzVvJpjlomODt3bKSQuCNjLg/N0vtbAwTzD5mTwIbL7trv0uhvq/IAIDkwMRz7kSqWpiMs4z0YMn/e9DevqNF+Fa9UnuQXdYzh9ialJuHcrcAgOhgGt/xKuliE6E54WkkV7asZIni80iZ1rk8CG2n+hWLk3UkueSpXBYAUKzmLmN74unUlXtcTzXjj04znvp6OT6Z9dbF6MvbjxLzKxCmOeWfI55P10D2GqmkCoLy2J5uYrbx1NINqnTqrqHEcBX8kPJeqDnfOZzqT5dSn/obxQPs/zZd0/KI+2gdQ9eMHkH7Sz4U1/d1MaauCiYj5b0YfRlbzzJyMzQPE/4QxjKSDX0WU0d1DBbjsWs0tbPyQxqj3TWifQXb6J6SxTJXRiqB5X/+6hTqvQ37ihxQMmDAn2+DKxSAf70YC/3eoZdLT19RFh1AY4LLiZ6RYkzfehTlELmqiFw172wRLm7/eGSaXebvYAwjbvGsY/2oTs5UohhKypfR+PF2ifHVNprGdOdRNKbdDaLcGkAVGZtpzK69jGSbAncjebbjcADA2w0j7bL2ufRyVW1K9KU2FTDXX+XW1nUkXd+UbqH+Inovr578eE47Rv2NWKc4i016qpBzNcUk7zY2kgw20+L5TGasXB8tI3eW4DZx/YJa6vvDfrAEANAvQK5CD78/xd6+cprg+PcaNJ9DLmr/c3WHAQCOr1xrl81vJ/e+ZSvFthFm65/ZNHgC0q0vOphcfRJlYjx0jqVzsvEEts24/SvlwG51vH399dcd/z/88MOoqKjAggULcNxxx8GyLNx///342c9+hm9961sAgEcffRSVlZV48skncfXVV6OzsxN//etf8fjjj+PEEwWd4BNPPIH+/fvj7bffxvTp03fnLWhoaHwNaBmgoaGh5YCGxq7HHo2c6+wUX1KlpUJTuWnTJjQ2NuLkk0+2j/H7/ZgyZQrmzp2Lq6++GgsWLEA6nXYcU11djbFjx2Lu3Ln/1qStGNcIBOirtPMjkb4vzYJJFOc5ALQcLD4782ndAWDIC0Kb7mcacitIX3s9r4gv2Akv0hfmkLX0NZcJiWPrj6bHoDKlooC+dK0q+lL+2eKzAAAjK+hT9bih6+ztD98TgZx9VrCgmB6mhoP48otOorJMP/ryM7eKr0UedBNaLb7uecZXFYgFAEmpqAhvZF/kPSy7mldci2e28zEO2UCLzOI2gL5UCzfSxZSmLOtlwSBNos3JUjons4I0nB3D5QaLCzln5GJ7+5cVywEAo9ePt8s4n/8xw8RX/fylpIFdv5xUJkWDOwAAR1SSVv5Phz6HL+LozDn29txx/wQAPN1N0Y5dUt0a787gxzln73/Y2zIAAJqPACIylipVTOVHL6Fn9a3+iwEAJ9SQpuWZarJUJaSWm2vmLC8LSC0VKqmBfdqozaNo0nw0X2j4eVBYJizGvI9l7uNzJtZPzpkosyIynvlrfy7G16xPKUNkcBUdG2qUGnrGJV02kpIvdCSEdqtoHZvobP6EVwg5EGMZA73Hd4i/GZKBN499097+5Rsi2Jtz4F/xrbfs7YdfOAkA4HFT31nMsbNbTrlDJ5OM6xci7dnaqJDhTRsG2WXKAqFyMQCAq5Vkg8oxkShlQXgsk2pW5mn45ojldtmLSQp0c28UFoLiOjpHad0Bkp2BekYuwCyOsUFiO8muX32Y4LnPxJIHRCLWvS0HrKgXVtoLn1TudvenedIlNe9MCYvyFfQ+7oyJAfS7tWfZZXcNpXeov0EIhaJWmkcqFwoApGSSlNJVLMcDW4Moa4yvkwVJB8T44oQagTXUZmWpilu0vrnhmy/b27dsF+P3vfrhdllTQ7G9baiXOMuw7iphVoMSceHAZppHwWZmQfqm6Mjnxj9sl537/A1iHxMnZ6w9xd6OpUVdTMHtuL+eBjHPfsg8GH60lHJQhOtEmxcvpyjXid8kObG8VFjX2wvIovfWvEPkNVnWbRY8+vArIpfMwMOJrITDkIug9kwo7/6CDeI5hRsY+UCCnmPjUeI8niMgKV8rvu2MvCDBBt+XYI8t4C3LwsyZM3HMMcdg7FjBct/YKNwMKisrHcdWVlZiy5Yt9jE+nw8lJSU5x6jzv4hkMolkkkZFNBrNe5yGhsaew56UAYCWAxoa+yL0WkBDY9dgj7HQzJgxA0uXLsVTTz2Vs88wDMf/lmXllH0RX3bM3XffjaKiIvvXv3//vMdpaGjsOexJGQBoOaChsS9CrwU0NHYN9ogG/vrrr8dLL72EOXPmoF8/ckOoqhImjsbGRvTtS8F+TU1N9pd4VVUVUqkU2tvbHV/eTU1NOProo/Ne79Zbb8XMmTPt/6PRKPr374+BkXYs76I6vDJuKuujyR9nPO3jjiVzTD4o15kgUZs63DzoOmRDilWRCcrXLcxVLBs6vPOFucesoHOmHUSR+G+/K1Ihb/mY+ObrTmy1t1VgbvfZpGkofZxMSOHt4pqBQnLL2R6lwBhlMg81kQmnoE60JROk771OFrCngu4CZI23rwMA7pTizKZz2kZRPyge+WQxnV+8PjewONhC9jVPTN4o+wT1MSHukly93Z10nadSxF3/jwIRjPKTQ9+wyx7bepS9vXh7jaiHmfRKl9LFErXC9PvGSApk+2acgk2urPkQANC8goJuvlcqeJ//2p9SqCtEXeZ+7UKzp2UAsGM54KmOoWRCBwBga125vb9xAwvmHiTmxx8/pUC0vnOp7liVGGvGCeTO0dlC88y/QPjGHHvJfLvskbnHUAUyJ8DAaWSqbZwtAqBK1tKg2zaN+ei4pExgOQPMMM3Tu5YJ87RvIwuAJw8eW85UfEbzJNpC4zNTJl07imicB1jwnXKb85ZRwGlZSATdb6glzelrLcT5PnGCSOG+9hkKLnt64wRq1AhRV/+SDrtocwn5s6jgvgVbaOH1uUkR7u56ca/FLmpnYa24D2+MZHl0GHMHkCKBz20vdwmUQWVvvHQEXSdM54caxH7uFtF6GMmrwSNEQGOpi8q2eKjN/YaK/dvWUJ/VtRSLtu0k/3Nvxb6yFghvdcPtdyNWLZ5hoJW5sJTK912IjaktPE+A+BtuYGOikblLpSRnewHV6Wcuo4Vt4t3lSjG3qhp6B1vSBcuVpv0Nk8Q47xlA871wDY1vFUSaZMHg1xYTO8/kpWIsT6ggefN6LfWh4mrPMP5yb5S1X7rOcJfD6BDa3z8iGn3Oh+QurPYWVVCbmh4ZRPXLdVGY1cnzSSg+/OtfI7eZgjxB/16qHqtfJBeh8g2irzgpQPu3hLxKNpDvYnA7WzdIY82GdTQGuStcslxcdLNFfojc5a9YyiuV00Ncnw4oPlnM/c4eCmJVW8nlxVTRTlLL7FYNvGVZmDFjBmbPno13330XgwcPduwfPHgwqqqq8NZb5BOZSqXwwQcf2BNywoQJ8Hq9jmMaGhqwfPnyHU5av9+PwsJCx09DQ2PPY2/JAEDLAQ2NfQV6LaChseuxWzXw1113HZ588km8+OKLiEQitp9aUVERgsEgDMPADTfcgLvuugvDhw/H8OHDcddddyEUCuHiiy+2j/3e976HG2+8EWVlZSgtLcVNN92Egw8+2I5E19DQ2DehZYCGhoaWAxoaux67dQH/4IOCe3Tq1KmO8ocffhiXX345AOAnP/kJ4vE4rr32WrS3t+PII4/Em2++afO+AsB9990Hj8eD888/H/F4HCeccAIeeeSRneZ/Vril75s47/Ob7f+zA4SdomQlmVA4q8TK14U55iCLzDJZ8shAQHqu+DvJ3pEopboS0jqfDuevPxMS7XcTrTJCTTKVL4uSfu/Vw+xtS5pys+zWjRfI9F/aI/mpGUexm5nqWsaKE8sY64PBuKCV6aZ5PGNVkF4CGfIQgIeZrfosEbZoT4ylQe5HdiuVbp27EpUvI1Nxdz9pPmTN6OpP1w+0ifPaKsjMGGgXHcl5rv3tjHNbMu9w81XpQp72Xmz/1kOC/5fjX7K3I9J2f338IrvMXMu4oAPyObF06t+v+cDePi0k7u/zkz60y8q9wsz486axdM0KYrrYH7GvyQAA8CyIoHaomMieHhofIRYH99dPvwkAKGPudTFKGQCZURvxNWSGjtRxM7z4+8g8cpux3DT+FVPF1j50vik9KkJNdE+uITTRfjxWjK9uZhN+dtOh9nZiobgolyf+DsZ0IeVQTwW1M8NSs1vSrSdeydhZShhPvKS6Tn5C+Q5qg2J7+NHExrS4rsbePmKACEDkLC/J9XTP7hrhqrThE+JSLtlE/aQ407Mp5i7A+PSDoztE/Y3Fdlm8XLLQDKW5eduUF+3tOz4RLD3lc0gYc7kdbBT3z03vVjXJK7NNdFrHcDqndDG1r75ZuIYEDiX/pSvPJmaePy8XrnTclam7RsgWM7nHwtL2KPY1OeA5ph3ukB/GypKcfWE5j1OFjG2pm95tGckY44vS3OJuZ2r8cRYbM8AZ2MT4ThUx9rk0y/cg52dtDb1vRp4gWNGaeugl3BBkbU+I+3/jCOJ7f7xrkL3d9qkQLu9nWZBwFTVQvpow8ihysVmRZa5qSVF/qpDayd+9tfOEi1uQ5WpRTCvJTmpnkOXN8HeI+emNsxwMbEnaNVYIMqObygqY25JaA3FXtlALbddNk3kz/MwdeJ4YS2G2fuHPMdZXtoWzxAxjOSZMsT+wiWSQJ0bHqvVd1wAaj9w1eJhP1HVaNb33/zRvqrhkNQnubJwJ8S/Bbl3A70yOKMMwMGvWLMyaNWuHxwQCATzwwAN44IEHdmHrNDQ0dje0DNDQ0NByQENj12OP8sDvbQz2hHHyiQvs/z/cNhQA4B5NX9epFGll4rXCX67PglwNNQDEpHao42DS9BQvpfPVlxkPUlUBoQAQqzZyylT21zTTdhczXma3JFVNsf0c3m7xtRloIuqs+uMoYKNwUjMAoG4DBa8ZhXT/8Qrx5WgxhYYlR4l5CH22uj+lBkQlf3vJGrrRQCttK0sDh+nnWVnFPcX6M254xq1va0LYYyhfKr5kM2HqbzfjTs2Exfm8b8P1dJ9paRVoLKT7+GgIBdr9a5XUkrez7JnMehLZJDWD20iFeePGK+zt+ycJTUaxn77eF24SgUQW0yb+8tT9WwO/L8ITBwrni+fXTXF0MNg8DbSLsRSrJBHJ8yB0D5HzbDs9S57R2S8DwMwGOj8zvcPe7ukQKul0HY0/q7+Ys20mWZqGVlBk+NSQSD0/q/ZMuyy2grThLnmpnsE0990Jqktp261DKcmDtZmu3+cTcS9t00mNdtUhc+zt338orFUli9k9yTpbniVtXYBp9VeEhNmCa6kMk03kJiGbHBljOSd2mez0FMkLThpw2qkiwP+1zGS7zC8DyWJ+qvSzLvK59oVkdtgKmttcToSaxEBoH8lkeTfdlErYnJlA8tB/JN1g2xZhEc0up2fz10XEXW4y7n67TFbPu0Zj96GzPgJXMIBQu9SWsw+MyFYxt7kVuOUQGguKKKJ1LI1JfxuzvFeKurydzPLuYVrmvow0QoKPfxVEe9nJ79tlbzaK7K6dPWQWcrdQm5RF+OQ3iArBxTTbGCLeQ74gvQONOloXqIDutXNZbALTCKsFQZhZGXlmdCUHOD26yofAMzsHWkjIZuUaoLsvs4wzS51LWtn5e7+7L/2j1iichKSQWe+8Mp9GqozKevrJ9VOMzolspn5SlghFMgAAVozJgQ5xUW6d4zlx1DuE59rIhBm3vnyJ3Fy63i7LHiWu/4/NZE01e5LIz0TvxP5pr9PQ0NDQ0NDQ0NDYT6EX8BoaGhoaGhoaGhq9CAeUC80pK09Hx6JB9v+Dj98MAJhUuskue7GWOIwLB4j0wOnVFITh62LuLNJU62Z8w5xbOCnNNTXvk9nI8pDppvVgcV6CYlDhlZbYQDOV8bS73TXim6trMJllgtvpO8zXLbYzERagxTjlT67aCABYHyYz+ooFZDbrqRHmQxczWacj4vwfjCEi7P/LHGtvx+uEPSmyjYaTJ0b37JY87okyFqBSw/pMer5ENtJ9dg1nEUDyVn3tdE7W75bXYe5PJWQSV0FBkS3kTpAJskC4mOSIZQHGn7cQ13RlubCLNXbTw+HP1hOXbj8nk/0s+D7Z/+rmiLrW1zC3olIxYFLMFWP03O+IdvQkANwNjd2PZAlg9hHP3U807ihbHre3FQdzx1Aas5wDuUhyMHceSmbmRBMbf/Kxn3vtO3bZnz89jiooFgdsOu0hu+iElSK48qzDl9hl1xdTcOg/uoU7ytJPh9plXmoyfniRCMK+953TqM2MNc/fIf76XiG3Ge4WpFzZMt0kO3qYO49Kt87llUdeP7KNxnmilOZZ5wLhRsK8WRyuaMol8bZLnraLbl90BrV5qTDz+4fTPOtuI9eUuc1CdnE3xXCjdH9iad/f3k7m6cINhjyOTvJFmWlfujsU1FGje/qQPMxI83nhq+SC0F1EfRqQfZ5h3PGBsTTQPKYcOx0kL9JF4lpZf657jcZuQCALBLLoGSHmrydOYyWdh1wi1o+5ZgwT787+hfQO3by1wt42uiWnOnNztcaQi1XRK2LcmMz1w2RuZ8WrRfkLaykHhZpzMy+bbZf90TfF3j6xRrjXvbDuELsslSR/lo0nPAwAuGQLnTMvQe991xbRgOK1dJ/mIXR/MeUWxlaMgVY6NhMSbY73o/e2b4XohySLtQ038mBxITyybrr5rgF0gcqDmgAAVw36yC674/1v0vWle6KbycDmU8lfZ3iNOH9qn7V22UOvCjdAzt3O3XaSsp+9DTQeeI6Iwq2S+OT7W+yyVRvJX8bdJoRbgHHLWwZdbOVnos9fqcklIvB7qO9MF1v/fAm0Bl5DQ0NDQ0NDQ0OjF0Ev4DU0NDQ0NDQ0NDR6EQ4oF5ro21VgwcPY0iZsO88Me94ue+bvZLZSEdU+ZvKNM77g2EBh7jQqyWxz7gnz7O3H18hU3O/RVduZSd4sFzY6b5h8M6xVwrzWcTjZ7wLMFKzMt9z0zd0Ags3ivFQhY8/oR+HiRdLmPaMfmfZvaLnA3k7GJaNMCZn8gl7Rvu8XE2PKTVM32NtjpBtI20ji6y1iqadNv+Sf7kN91zWETMVGRpR7u2n/oGFEyt3xvOCV9vZwfmjRJ+EG6rv6Y5iLTY14JmVvUd9zs5kyuXur6D5HFJPfUsIU/dAYIvtaQS1LzT5YtLXQT88pehyZHJMtwixYuJKeQ6KP6J+CVmpH93jZ3vjOmcw0vj6S5SbSpWLcGOsY6xTLM6DcPHxRGnNB9tw6ZRrx0JpctxkAiGwV4+LR1UfaZU+d8Cd7+7sLLs9p13k1CwEAv1l4EhUe+q69+UL9OACAh82TxEAa/9cU1QEA7q8km3JoOdnxufuffT6TZ22SeMlgfPVPrZtgb1sRcYNJk/rMkkwbPC18gMmjjExDzvnmOdKjRVu9jAIo3U7PwS2nT0cTyZZCxtff9oYwXxuM/aKnj+SsLqE2ebpp8kdqRZ+FNnXQfRjUD6lqca3oADqHu88d+x3BZPbq/PHUzi46VnHGD6gkHvgrBpD74V3LTgEAZELUzwWSCWN/5YHf1/DfRz2HUMSNj7tEjpe35lMmV1NOaQ9jTzGD9Kz6Fwmfigll2+yyTZvJhaagVjxDzmrVU0PPNSplB2dnKVtJ8l+5d7aNZu996a316+UkG84ettTeXtIh3pEBPw3UEyctsreV60xNoMMuO3YYvcM/6BoNAEgxVq30GnJVsySLzRXjaH3z6t3kjpOW7HmRvvQO9M8T706vg62GsfEMEDfFOfR5Lo7GtYIp7/DRm+2y8EZ6n6alSAjTNEMsQ3Vd2/99AMD/W3QOnS9ZdALtjA2wiuZ++GBRWcc2eu/7OqlPGk8U/RvJMha9EPW5R/LD83vmrliKYWtRzyC7LL5Y9HN6bKddZia/mnYV0Bp4DQ0NDQ0NDQ0NjV6FA0oDnywBPPSBiFirUNucveZcu8xNMY/wyQ8irj3iwZWeqPgyc7lJ0+Nl6dfi7UL72zIul0MWADzbxddaqI6+tBOSnv3yCaSxSRxK5z+9QGj1xw2n4LaVMQpqcyeF9opnCcw0536nff8d4iznQbim1LINKOywy5Z9NAwAcHj71XZZNkv1G9IccNJ3PrfL2tKkEmuKCy1gexuLZmEctJZHfm2yaN3NdeX2dkR2T6qYcdBKxbnpY1qKPtS5fUoER3PFFfRJ35kibXzjIhEQmGmlhztqTIO9HZIPatGWkVQ/z1opu7R5M2kpQnXUj0PnCo2Fp4s+xaPDRT/0lNPzKFgk2mSycaexe+FvcSM0UgiCzjRFeSYqWGB1Sow1zjnOszAr65ybTS0eFKlQ+BqN80s3XG9vF6jpS4o/vNMqtGDFc2ig/SlAweKjKkRQVgspapBgPPYnrTodAM1HwBl05usSsqljGNNi8XwTo4WJ4Rv9Vtplz6yhLNCTRgmN3fwPRttlyvqXKCcZFWwmjZTSZhonkJpsdAlthzxint295lS7zNNB7cuOFfO4b4QRyb9FOSxcMiI8yjIfumXZ4BeYZqyH8V8n5HNKsTK+LaMPEySCHBrYV5eIQEE/y5ibGU5Wj/VTH8EX8UKMxkF6i6g/xALdStaJNmXSuWNIY9ejMxtEyvTgnkoRMP7ciEn2vqI1MpMv4/J29SF1eYFXjNlNMYrmVpmVAdK8p1lwZCBA4yshx0oyQeOHz5+yZUKo8LVIpiArr03jY/ZLlPsg1U+0ycWyjr4+h+bu5EliTr9RO8ou62IZkavmi/EdZwHqmRF0z+P6C+veB83D7LLOc1kehA+EHM3MLbbLitaKOdt4FI395knUfkO+98s/pHtnBgLE20U/nPMZrTsMqgrHnyIslq+voMzm4SJq84/e+TYAoGQRyROfzAavLKgAyRgAsFuSof3uo5lJsUMI/nUrKdu0p5yumRgqnoM7SS+LslV0z91Voi0vbGXBxurZLaIBk00y88yXQGvgNTQ0NDQ0NDQ0NHoR9AJeQ0NDQ0NDQ0NDoxfhgHKhKV9iIkqWC1S9L26/pZLsMkPPoRS3yz8U5iLu9uJrJbOXV1pe/G+RHXr2CxRkUiwDxDpHkotNZAPjEy4RppUei6Uml6ayl7YSH/1NI96yt9+sFCawJRuIs9yIUP3tY2QK93KyvwUjtH1b+SoAwGM9xEldsJnMRRdcKVKnnxyhgNVzy68VbZ9P/RTrT9fccN7/4Yu4Zfs4e3veRsnVXEuuAVXjyTehfqu027UzPvttFMjWdbAwP3qaWPCcPJRzc7t8ZD58dOyjAICBHurb7SY9yPPS3xX1MLedR1YfZW9fPuoTAE63iXglu0FpUQ/Wu5EPhikO6BpCY6P1INFoXwcdV7pWm873NMqXmYhmheuTuw+5Rlw8/UN7+6lVMnizkcZ85nDyv3PJcWOt5s+XxlqwWXKqB2l88WBznmpb4R9D3gYADJ44yC7zZWh8rW8VPh3ctaO4gtq0rb0YAPDExL/RPa39EV1fuvyFttM9N5MlGFcPmg8AeLaWTO/JTpqH8zcI15kJx62xyz5bIIIA/R0ssLaU+qFosxjXrR+Rq9mKiTSppg9ZDQBoa6V+ZNT36IgImdHQzGSHi66l+NtNluMhKzfdCZpT7k5yccmGxT1lSxgffg/JBsMUsi1CVM/IeplLYlDIIe6eBB8zk2dzzd8/WXCpvV2+WF7HYoFqWcv5V2O34lcfnw5XMIDbfeJZ9x3dZO9rKBKuJT7m2mo10Phb5xUuXMke5jZTSO9DlynkPM934J5H7hGRY4ULWU01+cIdVlJrb788QriEdK0hF5dsRLzbkoupjLt1KdcZ31pqJw+8/uzNg8R9sJwyFauozeEGMf4TpYz0YTttZ/uJExuj5HI4qIxc4VYPE3OpaDXLH1Mk+i/YRu1Ml9Dc8H0oolBDzTR3OBGFIhrwbCIZHGIy9L0tw2XjqCy1ivq5YrwgpUguI5e7VIEkH2DBstEw1e8dK+VEiNYSndspgL64SgQwx0M0NrLrSY64/OJeuWtixxCWS0Q2L/IcyUPfUJknZzDJoGycLTq/BFoDr6GhoaGhoaGhodGLoBfwGhoaGhoaGhoaGr0IB5QLTdZnoPhYct2IxYRPROkfyESy4hgybQyaLGy5G5aQuwonYDckF2iokcr8nWR6CTXIlN41ZIaObGPcxAnR/dEhdL5VIE3ODWSqeqWM/H5UyuTZ3eSiUllNpqxCvzBRrW0gXtr4djIRDXnpKgCAO8V4j1m0/N9eP178rSF6jMIVkht+PZm6Kj+n7VGdPwAA9J9MZsC696nPCiV/tsW8TRoKyQ/gzCMEX+3yIVV2WW0LmQpPHrIOAPDZ9gF2WWypeE5BlqIcaRrON2/+FgDgxeFv2GUbGDNOd1w8kxQzg1pxOv/pjcKFIjiqg6pn7gyJZlHXpHGUprkmSCbRfwwR54c2MS7p0cLdwT2Hxps7LsaDldEp1PcUWsa6obKYZ6vIvezlrcRmkG0Upmie4jyzkeyiZrm0T/cnU2fxuzSWVM4DzgccaKFtxWxwYyO5q/y2SrAqHDKC5lHCpDG5dr3wu6lg6c67UiSvrr/gZQDAR7ERdtmgo8gfZZMh5o8ZorEWqqPx+bv5JwAAghEyc19x5Mf4Iv5f2WJ7+/S4kC21PUSH428n2eKV/OjWUYw6h82jlxeMBwAYCWoHdzmcMG4jAGDhAmLaCm1n5mV1KHMN6Bok/gk3kdxNFZHJO10gru9JsDnHiOSNtOjfYCvtj1VR+7i8tMsYm9XR9/9Y1MO84gJ52IC6q6kfWsaJA7IJD0Aekxq7Cb7tXrgDXgw+RvhJtfQwehP5qD0H0ZgdXU6T996BswEA01+ZaZdZPuYmUiC2vV0sZ8woNmZbhBzp3FhsFzUNI9lydN9NAIBMJc3ddzaIOX3UdHJfu7aSckRcv+oiAEC8k8Zh12gagH0Hipdw63zyA+2ppDGdLBbuMpxprZRo5rG2dWjO/rqxND8GjakHADRvITlQd5yQh+ky5sq2ie6zYoMoj1UyF2ImjwsXi/nrJZIYh0tr4APxHk0eRPVHDqFkHU+PfRgA8G3XZXZZz6vi/sMN1PY4y+HQulqsS8KMIYqzASXqpbxl89k1ghr483GvAQBuf5O45ws3MTdKOaS83cxVTvo1BTfSzZnJnVsPaA28hoaGhoaGhoaGRi/CAaWB335sFpH36As0JLNxpQpJE1KxgDToZ5+7GADw3xv72mWGi2ng28UXU7ycqX/AgqlkAGWWfZ03H8YCNTvEX56B1PKIr9ZAC5UtXjfG3t5QKwOsiqme+lHsq3ujDKBhmU77DKOv0tmHiK/SXzWeaJfNe5S0gMFmcd14lAWNfSL4XN0x+hTtHkpqKENeatMyioizhvNALvF1nyqmfihbSP00Z9VEAEB0GLX5sAmUJe6tNSJwN7iS5dGVSmweYGKY1GcrEuKZDdt2uV2WTdI1p4wRmvNtMbqPpi6qq2uDDGRi2kT+9W8MFPd3d7+X7bIBHjr/OVPcEw8kSqTF9f3s47plrKjUTGaB96CxB5CsNJGVQcYWy6jHg8YMmU0zlaB5ENlCY6HTL+b2xAkU9L7l3eH2tgpO5gFMMRYwWiBzRzw/b6Jd9tuzhQb+pv5kNfr+wu/QOetFXe400/aNpODM3751GgDAE6N7KhxHmsPBRwqNXn0njfnCkTRPZ49+TLTdTff5cvdge/tbBUJbedT879plPslLzfnyucYsKRVWy4960i7jnOi/+J0I7uxic/+np7xgbx/sF9kur/rHD+0yM0Dz2BMT1w81UJ+oLMmZANNPsYDR6CBpOW2i+2yeSPu9nWJ/ASlAHdbDTFgcmy2hyV20gISDynibKOHvBUK8XFRmkoEAVl/xHKyeneN/1vh6SJeZMIMmLqsRmUUf2EgZ2P0F4j0Xa6FxWvsGzZnpBwvNu7uM3ocms976ZD6QASdSFPRrI1+1t//eJSbF7a+cb5c11Rfb29kKYYErZua7C0eL7L9HFGy0y55sI9KF5vWCCCLMVnRFy+mfZ78hSB0ucl1il7W/Resala+heAPNw+B2Got+FczOMhY3DKT3sdcj1k2pI9nkXye07YNZVvW6uaShj0lO9I7jSYaVFVG+h64ycU1flKrk3PwyqTy8bXSfHRGypA2S7+OPD5ltlw3eKjwQ0gUs1wQLNs4Gxf13j6B+KKuiBkRbRJ2eRprvFc/SNe8whQz292X3MZBlkd4sZEPLeJJNgYOFNTbaTvVk4zuXGEZr4DU0NDQ0NDQ0NDR6EfQCXkNDQ0NDQ0NDQ6MX4YByoSmt6YTBeJsDHcJM4usgU2jWR9809875BgDAW0TmjEyCuqygVppSPcwFhn0SKdNMuJb2dw/OsmPFwUXr6Bx3XBzL+c09LBBOBVNxntHqObTdLU1M3mo6aUBRh71d4xbmnIFBcqv5jMXXKLNuxSIKDPG0S3NQjExdwSYyn/WdK/qk6TAyK3mH0PW9ktO9g7XZneTBwLLOBuq8JR+RO0LFcmWSpvN7RopGTx9Dad83dFEe6I3Lhb/C0UeststOKV1mb29LCzNmd4bs2M3drIEVwnzo2s54dVk/9XlB3OtUk3i2rRQz7XeJbcUHDgDG59JExizrycnC5Gj2JIA/QmMPoHCNG1mZo6FkHAWAdy6nIOqEjNbKVNBDT3YzXugCYTJu6CHzqHLdAADTK+ZEoJ2ev+ckulZrvTDJc3eXP3WKMft8w3i7zL2A6s9Ii36sinGSd7MU7CuUawi5AdaWF9M1TTGB+g0lzus+QTL1Nppi/D/WTsG8T35A6doflK54T4wnnvk7tp0BAFheTEHphVvo+v6oaOvwJ66xy444huakdZIwH7tWUzu/W0j+OMtSQg5xM7evnZ6Ju0vM00Lm9uONs4MllNsKABRuloHjzC3mzMmf29uro8LNkrsaJVZQ+7Kl4vqGm54tD3QLbRdt9sboAtuPYjz50uUyvI3OCS+UQdPJ/G43GrsWJf064Q4l0Mct3CMattC7A14xPgpX0bveG2NBh5JoYt2UR+2iY5edbW831ws5UuzL7w7183lnAQACnfSs4zTN8eZakW8BjIfdJUknnupHLndooXeXVSza9PPvP2eXPdFALjbPRUVemW0biRM9wtw7w03i/jwxmruWm7l5tImDm8ZTm/pVEoGEkiOLVw6zywrkNN72KbnNMA9ke60U+ZhFxiZpOyDlXYI9Gp6bQZ2fLGZlLNfMqWvE+m0Ukyf+JvFMPST2HO5/Scn9UVJJ+TU6VxFRQMlG8Rxifdk5RWzRVyeun6okgWAU0U0nisX5s85/2i4bL90ET//njVRPQgexamhoaGhoaGhoaOx3OKA08NGVpSimD0wkC8X3iytD3eBO0AEF60R5NymDYTGtiy8qNcOlTMPej7bDDXKDKVXccfpmuu4MQTn0+KYj7LLA8+JzMzaAvsDS7AuuZIXQ6qTZF3t3NdU55iKRaXX5c6PtssSZuY85xNTJxjcp0K1rtbh+QR1rtMoOmKZPdk9jB22bos+KiyhKr7GqmK4l+8cM0D1lQtRm9YWdoRgOR+Bvx3Bxfp/F9Gw6DhFlHheVHV5GUWcbS4Wm4UxGebcqQREwjywQNJmTR1EQogrEAQDvevklz7ohUU5t2i6/uv1bSAviY4yWSrvHA9UMWb3JgmEzW4WaIZvIn9FVY9fDH7XQOkForO4bRkHI//XUlfZ2z3ihPbvriBftsvfHjrK331giMhvWbSezUNlWFlwakZY0ljXUeo9USWr6miwu+965p4rjmJbKywK/rf4y0HEDaZl4AFegLVdr42th+6XivbWCgvO21VGbrn5T0MGyxNDwMGV2xxIxpy74lOjzlPXMTwor9FTSWA42SytnlPph/gckm9KSjjPMgsUv2TLF3m5JiLaWrWJUdF1MsymD6rwtZB30dgjtV8coEpK+LuqbngoxdztGU9lbW0ZSm/2iTV2t1E+uELOkdYpOYYzCcJnsOcmsrQbLqhrexsgLornZVr0qc29a08nuCURXl8AVCODqThHUWfYZDXr1LL3d9Cx44HjxZ0KoH97nPLvs6MrN9vbL8t2z8H0aU8f9hjTTkUFifiSZZrlwJU00X1Rsdw2i/eYwYdEOLqaXJH9fZirF/Lh7zSlUj5veZw93CG18oI5li2YZUl0pOf7Ye9nD1kIuuc2tVo2f0vu0WU5Js4rOqTpbaJbXrCANvMUYHJIDZT/X0wvRGEZBsP65wiLoYnSs3HLfLrk9CsbQi7dviFTrp1QI6/wnHUOozrEdAIDuDWRdszxsPsrMvJzQwAxSm73SYhpoYxShnJxAZrXvqqI6Dzpsk729oVm05b/+dYFdlpV9wi0yZmLnLHFaA6+hoaGhoaGhoaHRi7BbF/Bz5szBGWecgerqahiGgRdeeMGx37IszJo1C9XV1QgGg5g6dSpWrFjhOCaZTOL6669HeXk5wuEwzjzzTGzbtg0aGhq9A1oOaGhoaDmgobFrsVtdaGKxGMaNG4crrrgC55xzTs7+e++9F//zP/+DRx55BCNGjMCdd96Jk046CWvWrEEkIsyfN9xwA15++WU8/fTTKCsrw4033ojTTz8dCxYsgNv977kduGMG4pSgFIbMgNXdj7qh5j0KPgg2C9NOJkj7U6PIVKu4RHkQRaIf2XsS0lTLvDxQMpwC2UYGRPaymghlfNtYLuxq/jaWJa2MKojLWLFUCcv+2kHmlk/mC7NdYDJxl679mLicR3wizOQ8G6O/hfFGS28abzddMzZStCnQSDY7y0PnKH545ZIEAC7qJjv7mH8p7efBvj65X3GkAkD7CLqnog2ivH0YM81vFduvpsdTO4rJLej00csBAI/VT7LLNr9K/RCW1X8MMm26W8mMWbpRXNP0cx542lbuMDy4jpvUgzIoKDqIzlGc8KHtdGAP47XdX7GvyYFEiYFvThSc6/9oJfe1WDU9qxNHiIyHq+L0gOp6yOz6r5P/FwBw29Zv2mVbXTSWlJtETwUbM8w7Ii5NrKWjyX3NXCRM7+kIHegaTCbhVItwnXGx2+XBk6lCyX8eZJNrKJ2fHC5N1iySbEA/uv62ThF85+mm83mgZY8M3PIydxllxvd3UJ2BdpIdpl8G1jbQORWXbLa31zWKe/Z30kRa3Eg26VvGvA4AuHscmZyTU8m8XfmZuG6okTqiY7jwS+J9Y7K5260SOjPTef+SDnt7zSZxo8ULqU0Gd72ULoHxSnpO0SFsnstMs1n2duXPPiXdqwq3Mhkr3Y7M1P5rFN+X5ECw0YDbbyC4TIyVYAu5h0YHiueu+PwBIFRLrh1GVrhWdbxJgdsfpmm7plE81wTFPiK4nQZjoFn87elL/nMNx9Cx6n3so2UBehrE3Le4S2dfWmsY7cKtJ1BM7WyopQaMHyWiP5eNpGvGY+SK55deKJFtVKevkSZ64zQxT7nLn5fxs6v3YGF/Krx38D9Fm4bQOG/NUgW/rRPuPs015KpWFiDyi0WjBgEAXD30XF0Z5qJcJ/6619F9bhhXbG//sUWUf/eguXbZymYRoJ4to+d94phV9vbCJuHuYzAXmM7l5OvUIdclXEYXbKY56+0R5xmNdJ91xfTeOE7m+njr/UPtstEHCd7/2o2D7DJj52jgd+8C/tRTT8Wpp56ad59lWbj//vvxs5/9DN/6lkh7/+ijj6KyshJPPvkkrr76anR2duKvf/0rHn/8cZx4okg89MQTT6B///54++23MX369N3ZfA0NjV0ALQc0NDS0HNDQ2LXYa5/7mzZtQmNjI04++WS7zO/3Y8qUKZg7V3wxLViwAOl02nFMdXU1xo4dax+TD8lkEtFo1PHT+M8QzDg/Bc9t+Bi/WPckjmhfY5dFMj24ouFdHL9pCTxm5otVaGjsEFoO7PswrCwCaacc+PW/HsMfnv8LintIwz+hYT0uXfYuxrZt3sMt1Ojt2F1yQMuAXQevmbEJKwBg1PZt+N3sv+HWt2c7jrvg1c9x7usL4K3Va4Hdjb3GQtPYKNLrVlZWOsorKyuxZcsW+xifz4eSkpKcY9T5+XD33XfjF7/4RU65GQJK1zPTCONttsuGk5uIGZBMEqWMy9lHA7jlePFSM5qJauTgUcSEsmquiDjODiB/kr8c9Li9PXOdSKVcN59MxmFptfJ3UJsKN9F3VttY0RYV7QwAGWbWGjhG2Ko315FJr7iO9isTD6dXidOhKN4gTEvDmutw14rHkIWBS8f/GADQMaYAA5ubMKljDT4aMxqth0gGleIYLrhnLs786DMc8+xPYLpdyLSGcdyytfCnM1jkOxhpjwfFG9iEZqwNiq2Bu6B0DKPIdGWKLl/OzJyDhM3OzbnXV5JJ8JWmwwAAfUcT5zXnzi84THBaXzn4M7vswRXHUl3zxThIFVE/pYbTcywvFabK7gS1sztO2509kge8hBgzEltFA1LFVKdvoHjg5gGaQn1vyIGeiT14fZNgQvHMJ6aSMHNtemOx4EIvXE0ismsozf1zmq4GAKS2k7wIMHcob0w842QZ1ZkpovN9ZeJ5XzFknl32u8/PBACsPPf3dtlrPcX29s0LhdtBvxHEulDfQebZtmGirdk2kkcVETJJd0iTubmYzolOpDa5+4rxnYzSOL70/U/xwzmv4uWDJuL3XWcBAJomGjhu80qEUikE3AlkwmGkIgaGr6vD9QtewXt9D8aKwwcBEK4D32iYj2XDB2BF+QBHKnYA8PmETEiTFR2Bf1H7frlcus4wxg1PD3OHqZEMV34SgooH351kjBfF9BxLpMU8EyLZUb92oL3t6i+eWeW5RDq9sYmEpGuVaOz4wyit/YWVJEd+99MLAQCtY0luly2ntnT3c8k2M9YJ2XzzAKWB311yYEcywHKLX7BZjD9fJ7lfpsaKd4uHMYFkfTR+TJkrhruzKPcyAEgXiHHF3UQ3nk3vpqpPVP4Y2u9i/P+Ro4SPTeZl4myvmC/OSRXQcUd/i+IDSr3iQ/qFl4+2y4KM573vocIf50dHv2WXXbeKcjN0jRP3H1tHsqM6SS/MX7/5MKZsXInrzr4S8wYJN90CqwcnrluONRVVdo6KyX234tzPFmLkwu34ceY8PD/5MCBroE9nF05auBKfRMaisVA8P3XOoceTMnDZdsrFYSQl40sz65ta7p4nyqMDmQtLF22XDBWy7+ZSYpq7+QixPepvP7DL3o5T3gvLI+ZpaAu5z5XUctYosd05jK7TNYzalKwQMjT0MfVdyaEkg5e1iZdEwRa6p1WFwm3H1Z9kRLa38MAbXxDolmXllH0RX3XMrbfeis7OTvtXW1u7S9q6vyKSiOM7C+bgqM1r7bJmfxEqkp2oSHYikqEB+NLwI/GrSefh034j7LJoMIinjzoKbxx7EEyW/OHK1z7EX373OC5f+N6euRGNXgstB/Y+Btc345bHXkOkhz5Uo/4gCpMJjGiudxx7x1ln4ebzz0dHiFbWKyr74Y1h4zC/gmRDwEzhhrUv4pFX/hfD2xugofFl2NVyQMuAfw+GlcXRG9bgmg/fcpRnXG54syaGt9Ac3lheidtPPxf/e/wpjmM/P2Eglh9VjSVD+ttlR6zZhLseex6PP/F7GJamSt1V2Gsa+Koq8aXV2NiIvn3p87Wpqcn+Cq+qqkIqlUJ7e7vjq7upqQlHH300dgS/3w+/359TXrzWQqiZPkuVljfZh76gCrewgM5N8qu0mmVgZB9jlX2EOc7HgklWNZAGQQVReVfR1/c5LZS509spvzAP6aD6G4rFBg+aYhrbkAwq6x5IDeFfc7WL5RdeI5UVryftQqJMPHIe1HXVnHfx3SXv4NPq4Zh5tNAsdngK8YPJ12FzQSVMGaAWaDexLDgUy4JDUXeEG+prNFMcwM1Xno1QaRxQl4p7sLK6BkMaWjH70MORCYog1wHRJlR3t2FB8XBYhvP7MbidtNDF6+kLuH2kaKs7RcNVJspEyVr2Rc7uqeSbQtB4GRduiGVc6/lMBKb86XPyyTQZ13NPH6lBZcqe40fQB046K7QsiqcaAJavI77bD6bfBwD4ME6avd++K7SJnL/Xs1VogM1UbvbIAwF7Qw58b+xcPCOjxryMu98Tp+evNO99FpHrSPF60ti2j5DWlLG0P+Gj/ZkOGZQYZFzLLDOnb704/7ebzrDLjjpZ8Bb7DRoLHSaNr8oSIW9qW6gPit+kwdQ1UAZYDaMFeGWYAtG6PxIaPYNp5qKdciJZFp6+9yGMqm/E1qIyPHqSyMD64fk1OPv4q7Ghfx9EnpF1fmphDkTwbzrmgj8mNJAf9h2GDycOQ+lKuueazd2YWzIKhVYCjT3liPSkkLqtEhPb1qHJX4TWXwqBEWXJGAvq6AUfkfK4awDtL9zEgt1HyXsO09wvlbk2eFZJHmDvSUiLH5OxxRvpH0PO7dcufNUuu7ucPkr+EhdjZ0yEFjPnFVDEYesv/wUA+MNq4rPvZpYSv8zO21VDbcpMYpa4AzAj8+6SAzuSAcFWC26fhXREPGuXScqlXREAAKtNSURBVHOusFaMPz4+OkZy/nUx1hKkIEeQDL2IHiot8yxnTHVFB21PEvN4/griJw9voHfbWQOWAgD+fBiNn35v5Opa311HY9KzSUwgRfgAAG2kWMYJxUK2vNc1xi7LsnwkwbWijyrLa/HXO/8PWcPAO+cdhrpC8Z6875BTce83TsemCUHAEO/p7NIiPDdG9LtfJnaf/8Q4zMc44EigcF4G/QH4ohlEWn1YVjQQ80uGo+oTMefThR6csvVzvL7xEHQFRP8WfZNe0l7J1R5opXtqHkcytGStKI9sZZY2lhW1z9EU0PtFZAaTjAwvIeFTuFVa9Lx0TfJaAJrHSdnCSDrCy6hNHWPEfQSZs0H9e/QhkxwtTgwyi2PhSvHsY0dSpUbPzkWx7jUN/ODBg1FVVYW33qIvvVQqhQ8++MCejBMmTIDX63Uc09DQgOXLl3/pi1vjyzGosxHhFA2W50cehTWl1Xh30CGOL5SVJQPR4w3kq2KncM85p+PYO2/B9sJiu+ziVR/g/vcfwh2fPfEf16ux/0DLgb0Ey8K4us30v2Hg8eOOxlsHj8HKAeQL1BkJYs3gKmQ8/1misTZfBHcOvQAzJ1CSLJdl4qY1s/Hw57/DaW8t/U/vQGM/gpYDewf+dAqjG4hqamtVGV45aiwen34k0ozVZ0tZH9QXl+a4wO0s5peNwA2HXY0nB061y0a11+Kni5/F64/dgcqu9h2frLFD7FYNfHd3N9avJ/+jTZs2YfHixSgtLcWAAQNwww034K677sLw4cMxfPhw3HXXXQiFQrj44osBAEVFRfje976HG2+8EWVlZSgtLcVNN92Egw8+2I5C1/j3cMaGT/H/5s/Ga0Mn4M7JQiPcECnFt8++EQDg78zNEvh1YLmc34gdgQK0+cN4dOQJu/Q6GvsutBzYx2BZ+PXLj+Mbqxfj+xXfxtsThVbu78dOwt+PnQSEza+o4D+4JLO2FabjWBupQVciiLemjPmSszT2J2g5sG+hpr0NDz3+ZxT3xHDG1T9BW1hYg394g4jhKH479GWn/0fgciBgprC+sC8+HTQM2yMlX3KWxo6wWxfwn3/+OaZNm2b/P3OmSMF92WWX4ZFHHsFPfvITxONxXHvttWhvb8eRRx6JN9980+Z8BYD77rsPHo8H559/PuLxOE444QQ88sgj/zb3MwAEW0z4msg0UbFQDKboQOqGHmYW83fIYCNmasp0kTlu6oglAIAPGon/eXBFq729UUa5RD6kieCLMrOpVG53bym0y0qkC0qGmZRD28lE1NVfnN9nAb8vsokrF6BUhK7Dg0NXD6uE59Msis1uZIpNZNweB4ez0sCnWUrljqPE8+C8ynzbkPzpxiYyQxYxrmgeePLQiFPw8LCT4G3LINAiKjkyvQZxjx9zB1Gqeo5kuTg/s5WeeUjyrHN+ZW4mD7nEjvXLya1l0BpyJdo+UTzUeDXj3GaBRB2HCBuYu5uu+e7Hh9jbxZLP/xIWBNuTofv/Y6sws48PU1Bzj4zP8VBIAUw5nHb9kmnfwb4mBx5eOQlWuzDPRph1nQedla6Rzz9OttB0IckJFcAWWksVmKwuZX4//NjVdllbkuRA7VvCtSpbRROpsUfc75B/Xm2XBavJDOx7T8gJP3uv8tTi5UvERevKSGAtS1OA/OD5YvwnSj1oMUqQMVwY1NYKj1+cVzNKuIQ0v0ZzBgbVlQko2UDzpKBezB9/J+s8HtzXT9iKUwW0P91VglsqroA7a6JepquPTGzFlc9+jFenjkXbRsrX4I2J/eXLqE7uLmNInvxkPXVKdIC4VkmS8UfnCZrnPN9ZT26+hqH/oOdgFTKbuOSlfvpNIu/2n0L7/6tcPPOph/3FLjtv7k10eqW4VmwME6KtQuBn4/tvFOu+JAfaxwCuAOCSvPvhbcxNVlblZrwCyu0KoOBTvp+/h6y0qLOolLmvvULBmesyYrtvK53kjdH4efIJodwyRjPX1xJx0YIGOq5nLS0SCraqwFgWGM0+xH/yybkAAFcDCamI20TK5YFpuDBqeQtWloXhW0z9kA5S+1qOEnX5GImHi02JcKOUAx2039slJpKnkzoqG6R35JKyIfje5B/B8AIF9eI84x8FuHjJh/jbxOPhTeXKG28er5jOoSxvRT09p/pnhBz5zXVD7bIuGS3ODQkWGzpKbsdZTpA0C5pXuWosVoErw/IF1Im2pGnIIthM232mCEtDs5eenZI3BXOpzEztnBzYrQv4qVOnwrJ2rNE1DAOzZs3CrFmzdnhMIBDAAw88gAceeGA3tHD/hztron+sGbVh8WWysN8QXHTpj7CyvP9/bA77ujBdbnghZn9ZMopbFv0DkXQCM6d8F3NrtEZuf4OWA3sfZdFuFKUMdPqE7/1fx56MNwceis/OKN5rbTJdbgDixX/yR6tw/RPv49IXPsHZ3/gvxHzBLz9Zo9dBy4G9j2HbG7G+ohIwDKTdHvz4rMvQGQjBatpL880wYDIr/c0fPo/T1izEiNZ6/GTaFXunTb0Ie52FRmP3wZ9J49fvPYz75/8fClPE17y8by6d295CtyeAVwcejhWlA/Bp35F7uzkaGvsdhtY34eXbf4+ZK5+3LWwptxcbivedNMCrhlZhwUH98eQZh+vFu4bGbsBZHy3CK//zW3xrwed22daSPujkEZV7GW8MPxSNBcX46wTtYrsz2GssNHsDjRM9KGmgwapMQNzFo6eS7Clto0X3+Fjuh2AzmYDmDxLUCB8fQokMvlc72d5elxCmMu4O030QmcX8tcJcFapn5mV5rJdFOfu6yJTlTioXGcZMsz1Xq2G5AH82iX5dLQiZCdS4m7G9vEgRxyDBuN+LNjEXnRqZBpy5DUklGbLMdM9TrCuzEzczhprIvqZcE+J9aLgFWiXLi8ePv5acCE9RBqkA7Q+5ehANiGcVWSfaxHncs15xvo+56gTb6D7anxaR38ZoalOqkJ6t4l0uHdpml7U0EFNEoFia/erJFlbA7tn7mfDZe8pLFFpFlxNF2SWlgt/7z83EJKBYblI1LF11oTCjmz0J4A/Q2AOwtoRRXCfGD3cv4yxG6aDkeu5DJuf6Y2meZr1irBWup7LSlSRH1JhfkhlNdbLxm+4nTcYdNNE2tQl3l3Adc7NrJfc65ZrSU8Ps9ZOYmb5VTNARQ4gdpfaDAei3MYHyzm5k/E0IpxNIpWmeeT+jRjVBbJetofEZaCRBlCwXk8YTZ36srcL+mwnS3FIuKgCQKBfysnMo9W2CMWi5ZPElx3+G9VMrUJbtwXbp6hNMpuDbEEDK43WYoaPkYYPCsJinUcYGFWgT9Zt+aqfpZc9WuuBwF4gUM3nb91FGLi79KynIruNf4sMnw9Y9bzaS+98NpYsBANetu5Duk/nI9fSV7BnF1LfZucWinckD6pW815DtkwRCBtybxZjuGMNyNLSLsVyxMD/DWeEWUd6doWeVpFcHjIwYd+6XS6mMTdnyRYKxyAzRWiJZRnJGvc8N5rur5EmauaL5iPjIzlfiIT0dKubRse2jAhi5qhWebBaHr9mMV4YdgSwjPksWi2Ndac7wxNxwTXED7uU06MuX01rGlRL7LYcrmijLFNMCKF5B96nmYUEt1bOweBQuPPFmZEwPAu3i/KoNzejyyBwWrM8yIdH/baNYLpYaun7feaLeRx+nxF+J8cJ/NdNDz66AueV4u8Sz5bF73LUyExT1c7cbvhaLSM54Lu8CzFUq9TexJswyXaVyqU3ScIG5cyQ0B9YC/kBDZ6AAM6ZfjZr2diypGPzVJ+xFZFw0FC9a8QEuXf4erjrrWmwuqfySszQ0NL4Knw4ZjqsvvgrtW8sR8+7D2m2XYb8sfekM/u93T8ATM/CDC74H4MCkWdXQ2FX47cmnYW1pP7wx+pCvPngvgq8F+nU3448r/oB/Vh6N56o009AXcUAt4C0fYLnoy6hTxp4my+iYSL8Oe/sHIz4EAPz+aeJqDlCMKoYXCrXQaWuJS/zgIpbwRGrLuw+mzykrQ59zyQHiC7HgYx4o5vwLALFKekzqq5lncTOYX6FVaGJAZzM2ZIWWqClYgg2j6NNOBYEUr2Vf2sOZZlp+IIdZzhX1UvXGWFbJINOoyf4LraEvTZWNDgBCdULTxLUQ2yewAJwG+aUeMuAxMzh10wKUx7tw4qpleGxsBQz5pd42ib7UlTbS/QG92MNNTIsi79PIsHaWUJvSxeKa0W5qR2QV1WW5xTbX8AfaGKd8fULWTze19QMiq36+XGSCfWfrcDq/SbZlO10ndpA4Pxvfn8NY9y0EtwOhFtHf6TDNR659ykqNW3cZsxqxPAJK08SDlbqr2fiSiirOD126ip5x2yhxbGwwabt/M+1pAMCv7vsOXZOxq7VPFfOIy5BlRz5pb69IC1XOVSsvwYDaVnQUh5AeJcrmjOpnB9NbTHYk+jCrWYMcn8y7Lhukgz1yjHq7KWhezWk307ylC+gcFYDmZ/fRZzEd2zpGzL+3hh9kl2086W/AiiSMTbVIZtw4ZuAivFVwhL2/YCxZzaZUC1aTf8VIYGa2is53M777ONMDKMUm1+q7mWhRmj/Pu1Sn1VJhb3eeISoObqV53NhGlpKDX58BAAhtpv0sFhhmRPSj+UmxXZaWm9kDMyHzHodvYwBuf4DebX2o4y+b8gkA4FGL3DgixEVgW38NFsSZKqF5dPjBGwAAqxlPO+cy7xwphIY/Su8OJQ8Apxbd3n+YuFhoS24uFACIyKTBJls3pM5sx9g1dVg+ohp/POifAIDvFyo61yyCDSRHVDZ2d4LKitdT+wo3i/Z5elhuhSJqS1i+D7OMZUa9G7uGk9be00N1GjLtcIplSQ600ET0tPdgassilGZiOKl1MV6qOBwxlnE5XiHmVwlby7iZF0DXALHfewzJi+4GMU8rakggJVYQc4knIe6vcj7dJycvUJa81oPoeXkndNjbzZWifhfToHMNffNkOWiyjLtexjf7y8kit7OZ2Q+oBfz+DlfWxD3v/h0TGjbg/027AvP7jvjqk/YxZNweXHvG1Zi+YimeHzFpbzdHQ6PXoW9jB/5w81PoLAzi27d8Fy3FefxD9nUc5If1aDVuqZ+MtaOqgI/3doM0NHoXTv5wJe65dzZmTz8U+L1F/mq9CC+UH4GU14c5JWOQcmkr3BehF/D7ESKZOMKpJFxWFmlX7320HcECvXjX0PgPUdksgnYMy0L6P0zAtE9gcggrVu87gbYaGr0J1ds7YLpcyBqGw6rW2/BKn4l7uwn7LHrvKu8/gBnIwsN4k213mhCZS8rCZL96aIMISOWc5zxYZXWHsMvWt1PhxX0/tbdDR8sgiveOs8vcjGvcjCjuVGaq6hAmlgzjYVfBtAAQbsjlPzdksEjUCGHmxO9jQHcz1pZX24FTqSK653iVDDbxUwW/mfqMvX3T+yK5U0EdXVMFqaYLOB8r1elvE+UNk6nN5YupfcrdgAeDpFk/Hn+5UK/9/UMKAB72jDAhBcwULmt5B8vLBuLxKWRmz0qO50nXESH+y5+Pt7crBghfJ9ciMo/FGL31wLHC1emSfvS8/lx4rL3dtFqc52J8rPyZdA0R7gi+Lho7PLD3kbenirKtLMBlm+jznkoWiLRN+CyZzPSnsXth+ilPAucYDjXRnMjIMdsxiplnGUe3T1pgeSBjN2XMRlZyKLtTzEWHub4oVzWVRhsAslPF/oMvWWGXrWgl/ujs5mIAQJ/BZBLmOMgrxmTtEWWY8dhF8CUz6IEfXplloFt6eJkhuk9/Nck7q0lo6psOpTb522m7dJWQZ54kjfnuQcKO72LuKip4DQAS0nuv6jMyCXMOZXdC1D/3+XFUwfVz7c0JpSIw/ORDVuKMe5fg+f86DCsZe86Lcw4HAHgZD71ykYlVMFnLOPq90i2ucCvdBzeJdw0UdfWdRz4SvE/6zBNjouVQus/S92ggBJtFvUkmdznnvFsGqpYvI3eBpOT5zqSz2AiN3Y2KRRl4vBm0jBX9njBp/HzeIXI0pMrZOB9DyTus1WKeZAro+WcZZ/qa53It322ncPcI6Z5ZSAuLK0bPs7cfXiWUV54FFGBeMUAInMQqep+VrmbuLDIHSobNrYNuq8f8iweiZHAM73cLeuai1XSfKRYfn6gU7a9YzLjpO2l8qrUSD1DvGEE+PJZHuLaE65i7sFucEx1EbQpup3kWqRfziwcIJ0uY25kpZUuc2nF4bDVOql2MWUdcjK4BucHoRpbqUrk6yoP07FzVov3vj/+7XTZu2Q32dtcA+T5mQe/F6+kCqnXBFkZ20kxzv0ASEIQamYsyY8Y+b4JYr3y8nWISm5YJ97zAcrKUmqmdszZoGsn9DJbhwpbI/hP4eUrjApy39mPMXPACCnbSL0xD40BHdySAtvKCrz6wl+CsXy3CqI+244x7l+ztpmho9BrEhvkBdy9WvzMUpWOY9dmTOHHbEpy6ZcFXn3AAQC/g9wOcV/sRzq39CC4r+9UH9zK8VH0E3u83Fj+f/B10hwJffYKGxoEI04JxbSMwt+erj+2FePGnh2LllL54+SfjvvpgDY0DFDWdrfj1a4+iortjbzdll6PTG8bvDz4dj4+chrf7j9/bzdkncEC50LgTLjQdTqaNqUeJ/NzvrSQO39qWEnvb7BS22OoNLGK4iL55WmPCdNK/jCKal/QMtLe3J4RJxNuXXqrFBWRK64oLc03nELJlFW2UJr0Suk5PNV0/NkRsV78t9td0t+B7m96E1zKxLdwHbw0WLzjOqFG0jvFKS77mQy9aZZc9vf1Ie7v8E2G64SmRlfnMZTKTIWOdSBVKFxk2mhypp/3imgZLZ84j7Z9ZLRhb4KP6111KtA3X9TkHAPDQuEftsve6hF3qo+YhdlnJYmpAR5kwv3k5iwxjwoinRf2vtRxsl3X2MNYJt2hr10h2z34ymxVuEeWdA+maXUPo/oKS0UOx4QBAxwjJLc4+m1N9he9BNs58EDR2K0w/EJPp7PmYiA6k5xuUrBEGeyzmQJq71ihh1k3FyDfD6iKzZ9lCUVeUhiemXEJao3drBTtRZgH5kv3PLy4CAGw/lubeuDFb7O3uNkH31N5NZnQcKv8+3gnj+S7gnRj6P9+OeIEY38U11OalHuF60tVOCR2yFs3j+GHy2Do+D2h/3VRRZ7KKcT37RT8Uz6VzijZS+zPyUh3DaD9nc4rUiXkUL6dJceqab9jbDVEhG78xaCUe+19BI/dQn3dpf80rAIC/tFHMzOftwldo4zySxQWUosF2p+EMRKlDSCC51kkWmzjN/fJl1OamQ8Wz7TOkxS5Lr6Zn0lMh9rePo3MKV9PYUq6NnYNJxilGEkur1PYI3EkTbtNE+XLxf5OH3EGWNA4FABx+xDq77Jkh79DJks3wm+um20Wr5tJEDzYL2eFljCvJMjbnCiXrWoDGxMMrafx6PxeWs2ALc1dZIMZXSSt/h9L4ajlY1PWb2c9iyvp1MCIpbEwRc9JzLwr30Op15I6SCdJgcy8UbQpuZeTyCTo2WybWMp0jyKrXcixjo/LIvBifUj+qvBcVn9Nx0UHMNUSuBzjneorx3LeNFn1WtoLmyevRiUAR4Gq3UCTXZW2jGbNfBWNzc4n6f9KfIuB/u/YkAMBxi4npqw9zG/LExTlcNhhs3dMlXQajg+k59BtA1IQ9C4TLY2QbZ8yj9i85XMjg+m3EDBjqVOsrOsXaSVI6LS56OerCZfjfEWfi7crx+KTsAMhkmrVgpLS/uIaGA+dEYH2nENZt5fbifb9GYv+zNmpofF388uLTMHf0EPzy4tP2dlP2CHzmga34OqA08OnSNEJtpAla1Sa+liyTNErDqogceE2yLwCgu4ZlCGWBbun3iwEAm4+kF+a3az6zt2t84gvyOxMoKOukIAVGHbnoXABAlAXCZWRQXayGyjxVpEUbVSXIqJe6KWLupfgkvATxBd8m4zw5nyvPKLf9cPGl/sEqFmiTYJplGUfhZdkWlbaSc8zyII3Kj4Uas3gd3Uh0IPWJ4sD1pKjv+ixmmoC1QiVWezI9B08p7e/ZKhr1zpxRuObJOXjim0fiw/OElmTzegryK2Xr+khI+MvfcxXxZP9tOwWprmgW5xX5WDbE5WQJqVop2to+gvqGc2bHRovnaDGe+crqDnu7ySe+sJNldP7U44X/7hkyUyMAzG6ZAABIdafwNDT2BILNgFsOT86lzLPrJUrFcy1bTs98eynJgTMPWggAeOURCrzmnqYqsycP7lzSTsGX8Y2SL5i5qXcMl4FiYZIRy7fROaUbRVvaxua5qYgb1q9F7MsHL5FFccr41fb2IZUicHtejAKojBXUgNLNov4s07qnWLB5bIKYK/6NrNMMoVHrGkT9FGhneSWCojxRRnUWbCM50DxenO9hmacbXiDNucp3MbtI9LORzWLsvFqcOWcpzvr1DxA+WHTw8sWD7HN8NVKbPpS06tmxFFwXWyOsrPE+LOBtK2lI/VKh5sivwSj4VI6M9Kukdef9pKw27i6SoV5miQu2yiy8ebIAG/q7ZI+gdbQfbr/ffm7pQhZwPEA8rIFhChb/9uap9rZ6d3RtoYceZvlhgi1i/rpZsHf1R/Rgt00VY77oXZpH3GKt8i10DGNc43L8JItoHPb0oXdsydFiXbC+ri8u/n9XAwDue/Ise//gF8U7mlvUrAp6X/s65PxgY75nFGnw20aJNqdZ4OuJB5EVf86bwvLP54Eiz9j8LWaxC1IcW6pQLCj4uoIL0eqPRJs8XbQWSFSIPusba8UPP3gRfeJRXFhyIyCDdz1x6rNksfh722ffpHuWRAKBzdR3oR6St4owJNhE/eBtpsmbHiPkRHgkmW55DgiVAoNnpuYB7FvnCOvgsGPJJFhb39/RXmDnM7FqDbxGr0FBTwr9GzvwjQ9WfPXBGhoa+x0slwsDGttQ2JPAN+Yu29vN0dDQ2Avo8gYxoWkDRnTUY1hbw1efsJ/igNLA708o7o7hf/76LJ4+9gistQ6yv0D3Z/zr+IOR9Lnx+nEHIQCduVRDA692w3g3Buu7xcAY/1cevj/gf8+fhr+eORnzDh6CkWj+6hM0NPZzXPfQe+gqCODP46eiPRL+6hN6Obp9Idx55AVYU1KDDWX7D+vev4sDagHv8psOk3bjBhEUZjDT+camcjq+Q3RPoJ3xqJex4FLpveH2kHnsjg/IXHP4QYLRdy6G2mVzCigfu8ctg1mCLM3yUGkKYiZX3/s0IRtPF7b5Cz6bjxOWrkZVZyeuPOpgewFv9RcmqtCHZJ7rGEI3qIImRw+ut8u6UvTi71oh3IZ8UVogN06W6dCbqZ6evvTBsOUMYZKu+YCCdcuWkQ0oWSZsZJ4YmaoU7zEAuJOiH0qXUv2Wi9rvlj7vycVV+BeqgFeBzVOFWS28mbWJzeNkq3ANuG7hxXZZRRFFtE6pEemuVTAhAKSL6DmqYJpEBZWNPpjyaXckRPsaGijomWP0WGEiu6bfB3ZZIivMkGeEqJ9+tEZcPxvXFJl7CuGGDFLSRS1dwMvZPC8X49vbTc+/cg6N2eeaZY6IYjo/E2IuF9XieXo20zjums2SEg0Tx2YqmStZTIxlK8kEUg9td/eTwU79yTXE+J8OGJ/EgUoPLLWAD1CbP1g02t4uWSLqMieSECw7nBbA1lYh+zjvsckC7VzS36hsBc1tb7s4NhMhGRIdRNvVH0l3kQznQaf2+aLqRuiWizZS+/ytov61P6A6N88RLkKF24A6n5CHYfYcuz0yR0Mr43aPsCDCsMy/MZSEbE+UnlO2RZjXOwfTNQu2UZsKN4l7ahtDAXk9I+g5+mrF+RULuVsE3bN6h6jgf4DcDM1emC2zN6JrqAlX0ETFZ+JZ8HleFxBj5YX1R9llRRTPiqJm8R7rmczcUZgvQ7JYjDt7bAPI+ljAqBwq3HWEu7aEmsT48sZo/KrgSu72FThOBFGXdMRwwf9+Dm8mizd/MAGxmmIAQEEdjT8jJdpsdJHs8PlInmXCYszG+tNaw2ShNCpvS0Et1bnmTsrLMnibCH51dVD9DacKedfRh/r2mGEb7O25DYKIouoT2h9ooXnkbZZ1eVjfJWhOvtdXuO1kWVysh5Fwqftvy1JHp2uE7ArSMgxtI1neiw7xNxOkfm4/jNaE4UbRj21zGdlJf1or+Ttz4/M4d74i+qidSy7QoUbxV+XpAIDsTi4HDqgF/P6E1488CKVdMaweUAW0HKBC38qdLBoaBxKsn5QBj3bA+nbhVx+8P8KyDgjro4bGjhAL+XHPj0/BuOXbsKKm/1efsD/iAJUD2ge+l6KuTwl+fdF0vDz5wONFHt+4EY/d+zdc+/L7e7spGhp7F5OCsP7UF6jeucx9+xPOXfUx/vnMf2N4a/1XH6yhsZ8i5fPg9ZPG4r9/fMrebsoeRyTVg5s+fAFPP/M/B6RC74DSwJfO8aOknsy/baOFOSZJlJyIM3NLqElGLLeT64fppS5TzAnpzWR2qmBxVQujwj1iwKF1dtn8DUfY24OqhQnMM4RMuZ7PhEk4TVl14eHmlH8Ic072UBqsTWfRAeGQuL9J31tJ19xOtpkBYXGtbbOJiYKb//qeI3inOT/02cUiSORfrxFffJjFjRSeK+5v01gyK3lX0g0os1b3QcyMHqDnUDBPmq/ZB3TxWsYdO1gsToLNwtQ2srEBxy1fh0CTgdeizAUhRCbHZkM8x/RIorcYHCFWgd9VzwcANFW+Z5edX/Bte7ulSZj/OFNEe5zM8B2fyAj9SsYPvYkG0uXHi9TY3F3miq2CBefmt8mtwR0TnW9oWrw9hp4qDyzpchFibAOJEhqA6rl3DqYxlWFuGmp/kj1/hEhOICrsz5NOXG4XFbKJ/NIi8eHNdUbeTnGttJcxYlSTSTpeIOSVwV1s8qBwEdm+U8VUrlKnuxkTVvw9xqQiRUK8nGRgyVq6v4JtYtvNWBtcPWL+uZmZO8TSpQeaxfzL+hgzTYBkaEJap7np28HEorazuc/muK0rMbijCYev34ANhX3t/ZZ0q+Mc//4O6tOWcdKVqILaXNOXZENDu/DFS0cY40cVfSAlSySrFstlwQVF2XLR6MgGOsBi97/9O7lzPdooZEs2bkHTUe1+RPp1wR1KISEV1plX6d1VulT8TbB1AWeFC0v3i1LGpeBwNwmLcdM0kcZ5sJHGUvAwMdbMd+kCkW0sd4LkZ+euIaEtpqyb6mzdTG32dInxFaRhjOhgds1Wca2CBTTRsl7GuS7d70pX03vZV08up5FN4h29/Sha6wRbGbuMlANmKb33K/5/e98dZldVrv+efs6c6b0mk94bCSVASAISelMRRBEQ8dLlh3iver2KKMUrol4Uu+BFBbxUqSah15CeSZ20mUzvc86c3vbvj2/t/X3DBBKFlJlZ7/PkyZp1dllr7bW+vfZX3m8VnW/YuC5nFsvAnGm0QDtTPA7pLHaRKdpAcsgd5PWS9nKbA+NtiCQ9uOT5t+DKZJBd1IfmCqbBMXYol0Sxv7lm/lsAgD81n2bVFWwTrkaq2HUut/PmY16wyj/+M+WkkWu/dJV0j6IL9MwQzIUdfH2Pej4p3kpYbjch+TKwHdzHyKjawI8ULGmsw74cHzaOGYO4e/Rp3t4vm4yfzboAWwrHHvhgDY0RCHcyhQve2QBUxoFp7lFpPv7btJPwctUcrCuZeKSboqFxRDCxrQMT2juxuaQWHXn5R7o5hx0xlxt3XnA+WgsK0J+VdeATRhhG1QbeHcwM0v6YwSTZzUIzLHhETc7Tvgki2+Y8/kL1Kf5y+XUtg5UKtlJ9dCZ/ni+bxtypy9cToXP2Tr6+aQ0wgy0AIFHEv2fvseM/HnsCxa8M4NG/Hou2ufn4WkHDh3UZAHB5kgO0dv6KtL/5nSKaVwTQNL5Cm+I5Z+6w6tpjNBA2oWzsm8797G0hLZ6jmz8mknk8phNOo/bt7uZgEGMLf5Wb2gufyDKXzBY8qkGVHS2b2tmQXYLmfLqWp5e1gf1CWwp1KfcW7vt7eznoZnwxJb367HFrrLpTy+qt8p/KygddBwASaXF91X2X4Lwu3MoH/7eTskl2L3zTqnunkVSc9gSPdzqXBjXj0qw6hwuBSQa8SsHiFRqrKNMeW8HuUhssA5/iSvnlmMwareReVtGnS0m47ArwnO99k3MWeJSiKVHC8zdLWbWiGV7vyQhf08ihY+3dHkzb14H//v2TSD5px3tragGbDT9sPBcAMDCBG51bLzIKqurUTl4T0TKZsdnkUhac7t0sh6yMzBGWHYYKhIuX8DUTOXxPr7JwhMbw724RMGhqGT1LOatpXGQptKm0qZUvCU7sARqH9a7JsOcZQALI2y3kpeKXToiwAJnVstDM8ZARZs4TWKWWPb4fABDZxhrOZC63uXJqJ10/JSx+e2Wb6f9UDst9Q2Su9r5N9TGeGvCoc9Ix7dV6OBCry4fD67Xmn1Os/fxdKqtog7C8e2UgJf0eqt7/9qn8XVr7A2NZm5xcyNrsgQ6ad958Pifl5fmRzKJ7pYVuLqgyfseKuM5dEsVFL6/GDU+8jmcmHYcfnnwJhOEc7iD/4QqpvmTzJrf9eC4Xbaff3Z3SrMRwDJAlzRlhDbzMSu9XciA8ln/PaqVzclr43XZjCVu8X3yH0khXrOe1Fajla3YdT+d5hEVP5lNwKOP64xNPoUIPULaF17k9qSxhzXzOIz2keU/WiOyqY/meuXup3ilk5L3eT1llk9Qib7u0OLI8HKihte0QPO7yHWJmgY5OZM+BaJmaRy4hF90Htx/Q0mKYwZNKYmPlWAQqveiaknPgEzQ0NEYcHJkM3p04Af0n+Eal9l1DQwPozfVja205Npdoa/RohN7ADzPEXW587aIv448rFw3K9jXa4E9EcWx7PWb37jnSTdHQOOxYX1uLL9xwPbb/svzAB49glEb7cUpHHcqifQc+WENjhOHhs0/AhT++Hk9POeHAB49Q2DMZTOlowfmbV4+6QNZh40LzwAMP4Mc//jHa2towY8YM/OxnP8OiRYv+qWvYUwYSubzp7Z9KDzuvXgRjiDi0eAmZMWIVPCkKCtnEFFDn+7Zx0FfGJblhqRxayfa5e//fX6xydjUFOs54l4Mnc14iu29YcLMXHN9plZPKxHQgt5nTtp5nlTtWVlvlLAe1OZE/lGMWoDTzAPD+HpHOPErTxOkVwR7FwrTep0zFlYI/uo/Nxzvaqf/pDjZL2f3iWipALZ4SgWrC7JS3i2xltjRXntm/DrdufxprcifgPydTwGlWF9scQ+o5yOeZEYFGWSX0HB/fOI8rB/j8Ly8l/vY/vH+yVVeT22+Vt3rJlmmfwqbRbg+7O2TtpTF7pGmpVWdm5g4Jpq/CjdTOdMIBTq6s8WH4JORAOjuFWBmZPWNCceXq4OefvVfNzw9RbqeVydvjErkN3GIdZdP6aO3Mt+oqtwmu6U+pQMh8XkdJlYfbIYLWEwV8jl1xwmey2LzalWYrXK6LruXpYr2Mr4fP9/TTeTkt/HtG6ADMNSfjpwwHHxsvoPGJlgl+9EZaR6EKfpW4B0Q+hUJa86FK4VbTx4Oav5NuFpzG1wzM49/HPUPj6wryOEk3yFvqn8LCzh24b9aFeKr8xEF9inF8LrI6+P7BWrp+8QntVl3nGv4QSo9V8sbOA5HdwOe3guSZu5/r3NPZtp9QiXRSPiFwxDwy3RzSHhHcZgYEHmQK9dGOjysHnHHAASChHpF0GV21g1wdx/6NH1rPTJ5zZlCknb0gBgVKppT7Z+k6Xqehdl6nbvUa9PaK/C/j5Tqjej9zXyChYjPTImeMe5143yg3DplfxdPHrh22NJ3XdSL7bYUmcvuqXlHzV1rzXCLwXPHEe/t4bbsG+PyMWpPC+w/RMq+q42ue/fLNVjlvJ/VZ5sFxMucE7FFFIiLdHMWaXng6EQSsfWEKHv3pT+HKZHDpCTXoUr5JJv96Io/lenGdcsvp4zrpyta+mPrn7hYycj0HxprU+ZJkpHM+r/PUMTSOmTT3Ob6D3Yps5utiQAS5VtEeItzLLk2G8+A+RIaFBv6xxx7DLbfcgv/8z//E+vXrsWjRIpx11lnYt2/fgU/WGJHYnleD+pwqRByjI/ukhpYDGkOxpnQStubXwGFoFqfRAi0HNCQSLhdemzIdG6rHID+5fx/+kQqbYRz9Nofjjz8exxxzDH71q19ZddOmTcOFF16Iu++++4DnB4NB5OXlYfp1dyFRw9ry6uMpuqH9NdZQ5zaIQEpFB9V3EqvEzprO3FEm1WJblL/Q/jT+Gas879XrAQDuPXzPihP5s/rm2pcBAN/eeBE3to4+7fLrRWCH+Dq/c83/4pjN+9D+zVy0npkPALjQz5N21s+vAwAU7OCv41iBCLjopvqsRtYcZ2RGtjz6muydyhtjM3AmUShekpmhqsniqRyI1tnAQV3Fa+j+/jbWVrYt5C/gtNLse0VCqtx9fK/sBvosdwT48zzjp/YZgr4uXsJtDpcqq0GMn2fXfG7rny/6BQDglm2X7rfNUFpORye309vF7fMvJVNFjofnxr5VrFo3gyA9wrLvVnRRkt7Lryis04kY6v7wbQQCAeTmjtKkPAfAoZADpgwA9i8HTBkA7F8OSLrV/ckBUwYA+5cDpgwAhByoY/XO/uRA1sIuPP2VXyPptGPrkxVIKK2bKQdMGQDsXw6YMgDYvxwwZQDwyckBUwYA+5cDaWHd258cMGUAcPBywJQBwP7lgCkDgA+RA8LSsT85YMoAYP9yQGb91nLgk8PHkQOmDJh19V1wuL0wziH17m9m/nnIsV9+gLXFUuNqZs6UlqqkIEAxA0IhMnD2TxDW4bFU7xJBpmYGUAAIn0Tr2LmFNbemZjo8m+fZ2f/biP947wlsK6rG94/9IgAgMIHXgbymp5/WUcfxfM+iTfx77l4y/bjbRfrYpKCbnUSq74Fq7keCxR3C1aqvZdw+o5vWYcFWbpMMws1Sma/dIR6ntJvbZ2ZDlVr9MItoy4KVt0v0aSPvhZydlB02VZ7P/SilNnn6eXHuuYjlnb2U2r9z8Z+sukmvXWmVfWvJfCIJPaRl31znMoBeZtw1g1cNoaG3qcD10vFsakiH41j32fsOKAeOeg18IpHA2rVrsWzZskH1y5YtwzvvvHOEWnXkUNEZQG1zLxxRrXHSGD3QcoDhSqVR09aH8U09g8zTGhojHVoOMHLjUYwZ6EZJNHjggzVGJI56H/ju7m6k02mUlZUNqi8rK0N7e/t+z4nH44jH2ZkwGBw5E/zer56OgkAEF528/kg3RUPjsEHLAUbabscV910BTyKFM7M2H/gEDY0Rgn9WDoxUGQAAa8on4itn3oiYY/TlgtEgHPUbeBO2D1ClGYYxpM7E3Xffje9///tD6qMVBjwiSKJhKwU/olQEiiUl36v6v4VtIJvKK62y30XmkDn57BazMSECNZ10XUMEigX/xindbpt+Of0ugqWMSjJbFSxl037HRs6kui4xGfABi4t2WlzkEx+93Pp90sqhAspwiBSS6lbJQt+QOgDwNJINyD5BcFYrs5AzMpRTGgDcZKmCb3m+VVclXA/sSbI3pT1ibEWwlr+NjpVmqX5hCuydRqbEkvX8HMY0tON79Y8g4MvGvy+4mo6bzNPZpei5w/mSc53NZjNV8OF7cx/nm87l4n19FMj0+79xempPgH/v20AmxbjISGsXwTDWOX08uKa2VI6dyfuf1sFrB4VPQg4kcoG0nx7C3maOiipt5GflCtPvwbG8eDMJLmerCfyZfM4j8GgfZyo+fSOtSd9WnrPx2cwZ//BUCma/ueHTVl20T2UeFCbZLhHQmTONTKyr5j8BLKC6qW/z2v+hj9pUtIVN384oL6qkCkRLi0D7RBHb/jNuu+ozbwiyOniyugdUhslxfP1rFlCeg28VcQ6FDPicyTvIhShSvv+spokxKhIwxGMbL+CyfZdyN5nI7czfxn06tWcTLuhYhVWFk/GXmqWqn9QPGVgos1qa8m7lwEyravnsh63yCZFrAAAzynlDuPDY3Vb5F6+dDgBYN4dTpk577Ea+VwX1aRzzFSBWLHJ9mPzZYtoOqGDqjMy6rfGhOFg58GEyIJkFZDyA/WUSwD/MPdf6rW4rPYwc4QJVtHUoV3m0UgR0ioDmeJ7KqJzF7RkYJ1zEVMCyt4evnxahXFnv0vtOuo6ExtOcXzZ1u1X3smsy9oDe0761dP+keNWLZYie+fSHr4kvmruXJ5u7QbmDSY9qH8suMyDUEG1yncoduHrsBgCD5cDaBK2Dy3u/xvcR71CHGl85Tl0LRF4KRS7ibxPjHBYuNopIIKsrjW+sfxzjg+14OH8RNmXXAgAyOSQzbCmWF/69A6o/fE1/E/dzwjx6of9fiP2D0jGRk0Z5HGYLN8DuWTwovQupz+UruE4SaeTtofruuWJfUklyeyDKkyAtXP4+Cke9C01xcTEcDseQr+vOzs4hX+EmvvWtbyEQCFj/mpo0v8dIgz8dx5RwKyYHWg58sMawh5YDGvtDabwf08LNKIv3H+mmaBwG/LNyQMuA0YEJgTbM6m1E1ijThB31Gni324358+djxYoVuOgiDvZcsWIFLrjggv2e4/F44PF49vvbcMfMfc0Y292N3IlRBCf6DnzCCEWXOxffmfIFpPzafDgaoOXAB7A8BEQM+LPjCPtGaB8PAm8UzkCDrxRdWflHuikahwH/rBwYyTKgIBjGsdsbkHA6sQrzDnzCCMYvZ52L/HgYjcH8I92Uw4qjfgMPALfeeisuv/xyLFiwAAsXLsRvf/tb7Nu3D9dee+0/dR1X0AafDLLOJgOE5B5N72etG7Vs+m7bwK4lOdPIt+TWiW9bdaXCXcXtVumJpbJA2DyyG5QpTfCcEjstsC3FjCbuAT7pM2+vw5XvvoFtmTKs+U4ttWOP4J5XZkRHL7NLOEWac2eMzEnuNh6IVJGwuyXJrpXVyWanvsnUpv25zQBATjOdY08Izuk+wROvuKTjRewb4ObmIauD7hWsZVNVtFzyzdL5rUu4n+HtxWhEMVwRkTpZuOAkVJdiJYLDv4xv2pamZzPpQ2xQJU46NpG3/wj5ZBX1L5riCSOZJkwEJvE5TjWNJDuAOffSglNYY//4pOSAzYDFnuLo4jkZF+5W3fPV77z0kb2DPxafbifO8ScnzrHqvjqT5UC2h+ZH6Rl7rbpnJ79klS9vJJP9hr1Mq5C3ma6f1SWYsIR5+avnvcF9+G43bI1JnPrf27FuPpn897aQO5BPuKrJNRlWbiyF9YJ3OcwTzxakelsN9zMo0oyHZtCxM8ax1etkP5nML9rFQYWbm9nN0NdK94yVCk71Ru5T3joaf8lH7xBrIZFL9+86gRd3sJZZGbq6crEJtYPklUkM5IzzPTtO5t/XnP0zAMA5m66w6r5TzK4JW08kRpJpv2M2nzUV46yyXbniTX+E3WYcCe5TzePUZtcAuyhIF5r+RbToK0pYiHatpveKcXAZ1Ec1Pgk54IoCjjS7Lm3eWGv9llev9gXCnUmQTVmunu4+wawkDMH2JM07+b5YdBKz161qppsGdzG1jeT9TueofA1lnFvgzfm/BQD8umehVVe4O4Vf3fcIwm43ll42Gxm7HY64eEeJ17pN5VgpEKxWjrDwETIZZ+z2oXUAnGEqO2IsG2x2vpYpByTmK1/A2z7/pFV31wv80WVTTCyS211y65s8+f5WfhABobQ0WYD8ewewB8UAipEuFv6H+4HZZMPB6zFcw/24rZpk9H0tZ1h1VVW8QesYR+vUE+RxKtjB58fzaXz6pgomrT0y5w39n9UmXGh6yIVH5tfIxA5OMTksNvCXXHIJenp6cMcdd6CtrQ0zZ87ECy+8gLFjR1/64PU1tZjdvA/pMUc9+6eGxicKLQcElmTBaEoiKZKtaGiMBmg5QNhTWoqtlZXYVV6GrGQcIc/otciPVgyLDTwAXH/99bj++usPfOBHIOMYrGE3v4aS2SIjXq/4MjqWtLCTizlYY3uSNfDr5j8GAHg2wplWv/FX1uqYGmGp4XcOCk4wv0BFYIaK1fLv4xezDPic9P0mvINxuD6/GfNBX4Z3CT5Ww63OExy0gwLZcsysqvyl6mzv5wtEqLHZe1hD71AkuFKj4IwIDXkgIbtD5zQxR7IZGJNxVlhV4SruX+FWal/pOqERAAeWmF/l4Rq+wVm71qLXl40N5bWIueihxvP57GQ+ta9kNZ8Ta2Ke9yuc9Jx+MPlpq+7mDcwFHemhB1G4U/CAH8fqgS/MeR8A8Fg7Z2p1RfhYU6vgEhYfl1KoeAIisNX80E7oD7KDwSchB9IeIJ1Nc27lmT+16nuFcHg9PBUA8MDrp1l1vg4R0KrWtE1k2XuwjrXQMRUY72tnTc2svsuscriDzitexdf09ptZAnkdhKq5TQ/ecT4A4P4qO1AKoBSIpgxgnTp/wAwG5/UeKWNNTm4jtSmRLfJC7BKWMpVNUQZo2dLcvpDKBLuzi1VmiybT/98IsVZcBn2Fx1FbfC1ive/gdeTdSzIsMpEJovsniiDXHOqTq0cEhakm++MxLOtdg7ox1dg6ppZ/V8MXL+NxOOeYjVb5seAUAIPzPjw/meXN/+yjZ56cwILb1s/y0ltE7fdv5WcTHG8V0T+e2mpMYhVoYAY/072nPgQAeCnK17x5PQXiG8PmjXxk8XHlwMBYA3avAaOKtLt5b/PmN6uL1kk8l9dJuILLUZWZ3T+eLShhI98qu0NqHQqRbhfm61nlFCi5Q2Rxrsnrt8pPTnoOALA9yXOmykHv4IgkHa+O4fyfkpWo+O8+OOODrU42kaMhoazYkq9e5k4wCpQ1QKZ4yOH5bfKnyz719PP8XqSWz+WNi626t+snUDMrWIPtHsNWBWMf3dMlci+Vv89r1tdG5k/7PnZhKGrmdZqqJtaIialOVMW6sTVnDBpKeI8RqiSZk7+LxzFVTP1Ie3hsHFEeh4hB47t+E1vc/A0suyrqVftEsG8il38vX6WC7scM5bMHYHkMyMBcM8g1No8tDbbIwUWzH/VBrBoaH4Qtk8G3X3scv/77b1AT6DnwCRoaGiMOM9qb8MO/PYlf/vHhAx+soaExInFa90Z8e9fj+Gzb2wc+eIRBf+8PVxgGEDMA3+j7BvMnEnirdhom9rRjT+H+GUg0NEYDnOk0DABpx+hzpUk5HHh92hS05ecf6aZoaBxReFJJxJ2jk9Ch3VOArdnV2Jpdc+CDRxhG1QY+p8nAwCz++8YLnwcAPNHCEdwXVbKpdU2QfOrm5DAn+/OTXxxy3X/fwFzOZkpsCXdY8syL+hDVhyr45WumJ5YcsX1z2dT2k5Xn4AtvvoPAC+/h74vm4IdXnYNscWyknExE2TE2bxl24UZSqO5l49/9azn60kgPNRG5e8hmbYisj67Wfj7Hp8x6MgBGllUQqwyoK10jeHG3KzJ1L5vssqp4Y94/me7rUSnWk/Dh9uOI/zolUy9nCfueMh/GCvh3d5B/D75Obk//KJ9t1dmEfTBvCy0N94C4ZpSf0yObiYg7I+4pXaHMAKKCbeL3Yvo9kSfSKKshSYvgI41DC08fcMaFtM4nOHkdNCT5+d5WSLzfnztvg1V32t++YZXt6nl5RAB6eAzP78I6mvMF2zkKdqCJ3UzKryKZsjfKQayuoOKPFqb7ytf5mt5uWodJP9nBf7TyT1jUtAXXfOkreHfiZMTKae0GBKd63l42SWe1KpN0lIWQrYfXvk0FnXkFn3akWKTxVpF86UZ2G7pjyjSqe5LdaqasY9eCvpl0fk4jm4RdPcJmrhAr2v+rKLeRZF/+Hq4LldOxW7PG49sziLM9VcPXXzKFAuquLGGNXNhg14Ovb7iY2rSTx+mW8JVWOe1TYy6XpBBn8QYy/TvFOs4S+SBMV75oNY+93cPlr7UeCwD4eeVqq84YQ+46xkGazjU+HtLFSRg+B5CiB5sQbqiOONUFJnJdZgy7Uxnd9J6yiyBOmXPA20Nz1ieC0dc8yu+ZSKUKci3idbg1wC48szqvAgCU5LG7SX+EfjdWc0PzOoHicAC/ef4BlISCuOCU7yLp43WU8nI5WaSCUBPCFS3Jc9I2oOSUSELReSwnNglOpDZ7O3jOHzOGKTnv6CY58N6b06y6EhW327yE3eMKS5hIIqJES47Iv2FLiwD+fBpnV4pdlO0xdr+zR6n82IzFeAzkuiPdfAu3k7x0hHn/ZNiofykfr/0sQTJyy4ZLAABl7/IDzWnkZx+YQC48MtA+It/7uVTO38n9cAi3JtMlULYzZXoFNYsYhtjB7QdGn/p2BCDo86EgFMXE5s4j3RQNDY0jhJTdDk8qhUmd+89Eq6GhMbLR68tBcSQIp5FGdaT7SDdH4zBjVGngRwpWzpqOr3zzcrw5d+KBDx5hyIuGURgJoRulBz5YQ2ME449zP4Wfn3s6dpWVH/jgEYZxfe3ozspFUgS7a2iMNmTsdnzj9KvQNlCMoMt/4BNGGKaEm7E5MxFp++hzIQRG2QZeRlADwP1/PwcAYNj5h78m2I+s2E+m3l9uXmrVPVk91yqXZJGJy76B+VwlL7mvi0w3oSq+ZqyA75+/m0xYEQ6ctiBdNypX2EV9GoAT70+bB88qqPbzeSbzjYwwT/lFKuAgmf2aPsW/T+jnDYCrpU+dIzhJVYp1wyVu5OKpY0uZdD6SwFmUc8hNIe3nc9xBQXgcVWbjODNiJP3cpnihYgUYm8QVz76Jf398Of50wiLcdfZFSE9hc7zRziYoM7W1Ida16YoDAO5++n9NN/vNxeP8nFyqS66QTJfNF0sr8192A49JWuwlzOtLbnHTTCv59PN2K3OqZqE5bDjt0tX4eeXmofU+npN39xC9ymQv+0Z4xjOlkOllUpHH7iJnlG21yvdnEZNJzj6ZUpufcXeYXrYyh0NgPs3/abV8z9Cr7GLTM5NcZ8w5XV9RAW9XBkWKNWNgDP3wqctXWec8u/x4q1z1Ok1Q3z7BPFPEAslMOW4I9zfJapG3Y+iaemgt8eFP2MmuH/bOfqtcuIHalvHx2soIBqx0EY2Dv53lRe4eNnk7FE99xi1cAzxZuP3VRzEx0IZvnvYlvDlmBiqf4Wuuu4LGbEk+uwB4beyu8LcFvwMAfMH5ZavO2JXPfQ5TP72dwvXwWJYzudnU10g/uwa4heuk5Sbp5fmUiXH7n98xAwDwjz1TrTpPHcku7Up3eOBqccPhdSNRqOa8mNPdC+kB+vfwnI23sHDPZNGcdjzPLEYlXcJdSr0P027xDhbsLyZXu62Lr1/9Ms/PgTH0vmybySfl7FYsMrzVANTSfL9yMgrqo7CnMkiLzYDpsgkAtoRyFcrluv5pfLFcD81P0wUXAKJL2d3FtYWOTR3Dbj2xNM9pUw7kixwP2a20dl3P83Edx/OYmVsUOfYZMWbxfPohW7je2oRrb2F8AD/d8SB6GnJxzXE3Y8CVhawIPwdXN7U1PCHfqkvkDN3ox7hJ8LxJL3anuE4ij5+T6S5TsEuw5fQItqL5JBu6fbwX8TfzmHj7qf3Stdd8jjKXwMHKAe1CM9xhGHClUwc+boSgojeAtM2GLZXVBz5YQ2OUwJVODYpbGcnwJ6PwphJwZDLYUjzmSDdHQ+OowWjaC4yJdWHA4UO7twADrqwDnzACMao08M5wBiXr+WvO1AIHxwgN+WQu71hHQaxOoTHtL+Avq5PLKbKq7Hz+Uq37OQerpL30fRQ+k3/P8rKmKRokDY4MhAvMpC/xYJLbUbpGLEr1ks5uzuDEtq24tu5FvFsyDb+feia1b5z5SHlCZ0TwafYu0iJObBcaMQ9/lUYmUzCaI86dNjX4MsAkUc7BbfYEjaOzjwP2EtOEZruQ7uUOcj88XSLFpY+0G6H5vCmPsfIMhZtoHAdqPbjjU5fg9/NPx6vXP4J7vGvww27WYv2peQm3eTIFnoyv7LDqbq1ZbpWvf+yrAIDWVVVWnVMYBbx91FdnlMfBGeZxcm6neRAaL04SGtzit6jPMlglrQJey9/lcbQUJsnRsfk62vBshNfJf+/m7HutHfkffaLiBd/ZykGweztZI2tmVe3j6QlfF8+lzKtK7SMksHcvab+2pXlOFpWIjIGqWsqLgRo7rn/rJXx+3du4benV2FwyFqvuPtb6PXk6rzn712ktRH/K1i1niH83tV/hcpYN0rpnWgWD43lOF7xP45DM4eu4fayttKlAs3Qhy81ErgykUxYokT02Z5eI7VFWAXsuj7Ntp4GbKq9EVaIXRrMTBYhawWUAcP5Ysq6s7J2O/eGHHWdTm9fnW3XlW/jZhKqpLbmNvJ6bprGGf9nUDQCA5147yaozM3oCwJIz6ffXX5xr1cl8EGYuDpmB2xxnm8j5oXHoYMuofykzUzA//9wtNP/NYFMAyGngOZ/TZGZa5XNiBfxuMC2s0WKh7RUK1azWoZUyV4u5JpwiA7uZLyTDSxNZXbzm/K4Yvrb1GUwdaMKnP/MtpO0O5O3h9vm67arNfL4s904jORgSRC6/OuYvVvkmx+cBAD+b/ZhVd81KtmAVbKA5nbeHLQmBWrpBvsg1UfE2r33DoSwRImeNzDw9UENt9vTLbSqv8/W+yfhC0W0o7uyAp0kF49uGaq5lEGla7SuSfj6u/H0eR/OZRUr52bnCfL6Z1yIyi/vp2y6sM30qwFm4eySzRZ8WkobeSIt2qneJt1NY8w+SUEhr4IcxXOk0Jgba8KmW9bAZmQOfMELQWlAIePXU1dAAgKpAHwqjYZy5Z+2Rbsrhg82GFk/RgY/T0BgFCLm8mNuzB5WhPsxv23Wkm3PYkLQ70enKO/CBIxSjSgM/0vBW5XT8+JhP47WSOTBsI3tDO7ujAbsL8tGel3+km6KhcVThj8ctxcrJs7DWP/XABw9znDBQj3VZ45C061eXhoaJlN2JH8/6DBqri7GzsPJIN+eQwptOYHZgL9Zkjz4Sjw9iVEnBeIED7kHkvso1RHgvJNfm8x8F9INpZgOARCObcp/fcAIA4IbLnrXqVpXM4fNtdH1jCweLhKZxEIhNrTNDNMnhI3NOdILgRl0tgqkUX7IzasCAHc+MXYjgWBmkSueFy7mu7OWhNHOxau5HIoc3/74u5cIzju1rGRfdX5qi5NQx0xJndbApqe1EvqY5vqkcPqfsHXbB8ZWQ+S5WMNRkCACu3Ah+9MhDyFoRx9X/9SVsmlyNoMplP9HLLjKOsRxolopT/3e0MJ/8NTvY5Gf3Kl7bLjG2xSLI8By6vmcTu1gUbmMzp8mnH5/GLlEO4WvVP0W5DXGMo9W+QLvg4G+ne2b2Y/rTODR4rn4GtifJ56EnwswNgSA/a5sKbM9Zxa4fvm5+vvE85dY1TgRVvcfnh5WXSukZnEOi+wV2EXOomE/JPz12SSMAoGk5+2P4O9i8m8xWuQlEPoN4gQ17C8qxt6AcpWuiAJJwt/KkcySYnz12Hc3J4Exeh75OlhMO0yospmKsUKYBp/9LNvA6cEZoTFJZIvisOt8qe5r76Xcv36dvMt/fDOSXqc2NXH4mtqBa03ZgXmgvbm96HDvzKvDVpTch4XBZLm5mcD4APPmXU1TbuB+hk/gPTx09p4Rwm5BmbqeifU5kc588bdz+3gS1TwYUSl7olW/TO8AuXBRSFcJtTt3KGRHp3MX5GoceiTFx2H02VD9DczFaKNcBPat4kcyfwufm7qP/DbF7Sl/I/lCRv9PBgwLARR6DTkohApvwjM1rFC6t5vtWpASQ+WNM9E8QRBJL+vA8xsD7eD5sann6W/kCngAdm8zmfsqg+pSyaCeCPOevfvarfLMCmqDf3M45bwrX8P1z91EDPd3Mme5T95KBqe6AcOlTPPSScCNTzIvGdAGKCjfCRJ4D16x9EZfUv4VHJp6CX846Dz6R58bZxe7KCSWHZOCqod6zUjZId+G83dSPthNY7kfKxfUDdC1nKV8g5eV9j0lqIfeU0lUpE1B/CIcJf5Pq/4kst43IwfnSjWy17SjD8fvq4RyBQSzZ8Rjac/PRnZ+NHWN15lUNjQ+DI5PG3EjDkW7GIYHLSKPfkYWNxeORcIzOrJMaGgeDokgQE0JtBz5wuMEwEHO6kbLZsbp08pFuzRHHqNLAj2R8/Y2/44p1r+H3cz6FX88/60g35xNFa34hvnDlTSge04a4R7+4NTT2B286jp9t+B3Gh9pxW/UXsN03skzp7+dMxL9NugY9U0oOfLCGxijFrM69+Okrf0DI7sW/zb0JMYf7wCcNF9hs+PWcs/HMhOPR6Sw88PEjHKNqA9+7MI6yMWxiaW2kCZC7g4+RaXWTyrydcQl7SDmbpWKKE/SnL5xr1TkFz7szNPh/AIgIPmD7ZDLDSP5yW7syx2SzmbpvEp+T3Ua2l6SfjSdnX/U2HNVRZNYDydI0uo8x4BMpjw3J2R4nU5iZjhwAXFHuX3AMLXbJX+7rpt9DVcKkWMLnVM+isPpkmk1VX6neZJV/X0dsDb4t7GLQyxmX4a6kTXm0nK/pFUQUjjgAONC1txqOvVQ3t+0WAMAL599nHbewpsEq5zrpOb35xwVWnTRl+TtoHCXLRhZ74yC1m9oaFzKiax73b8Iiutexfjadbu9n60DLbjKzp5lWF5NKugAA2Rcx4euqDeTHl4lmAA7w1ziE8HhTWFKyEwDwWtckq/62ySus8gMNlJq7J5fXpiPGk8XM9+Cf1mfV+d5gtzBHko7tCbM7SPJElj3hfeRG5W/iNdW0glxnchvYvto1l9dpXLn0lYpYVVeLYMJwebHXX46yaD9ybHEYLidcgmUm+ALNTy97miGniW3zzhCVZb6H/B0shwwH1ceEmdt0B/H08XWiJfz7wBhKuOaMibXdw+XAOFpTbsHSYrgEo0eMTMnmKAVhRyLjhkPlTXDEqP92weKUo8Y05eWx9a9i2WMs6QcAnFPNwX7L+1lOsHlduA/xo8PyOuJxRzmPrcnCAQCOKJ0XmixYQkp50Av8dIPmLJGMTrlOZqKahuZwwN7nhj3qhqePxjtaxHMuox6lT+4FhLtUUrmLxXOFa4iD10noLOUK8T77x2V18vz09NL8qP1Ug1W3r7vWKpetpTY5Y7yOQpV0jpkTBRjs9pXup/lty7Nhm68SYbcHoYwPeZEBxD35SKk1GxHMOKbbCwDk7iU55hpgGZbdKtzGptG+JNjM7iJlgvvelAOJQv7d5FI3XYIAIOPma2btokVl5p8AgEQe08+FKujY4k3srjIwlq7fmlOEs7/1OgDgpR8stn53FfIL19zjyHe85erTzusxXsayoWM+yXu5vznj1HVWee3PjgEARNt5QkjGvNAs2l+VrWBFoyfA/UsqFxvpLpxUt4+Ehdty5OBISUbVBn4kY/Pp1bjv6Tz8omnZkW7KJwJnOo0fPfsXrK6ZgMdnLBzxQboaGp8EfjnpXPwxbxH6ndkHPngYoDwVwC3BV/FQ4SJs944si4KGxqFA2O3FNRddh9Q2FzK2kZGhdHFXHU7p2Yx7Sj+LXl/OgU8YJRhdG/iwEyeU7bT+fLGOTLHZrVLjJbIQhunLUQZUZkRGNmeMfrcLt3OZZdPMzJnMFdqhtXy+GZiS4I9eRKroAr4S/uoMncgNSKqMfQVCM/bks8xHbB+ngi8bXPCkkgh5fMiIrKqJGrqZzGgWFkEa3l5jUNsAIG8ntSVHZB2NVPA196mMh4Xv8hfkH2tP52sqhUR0Dge4FOTzF3DvblJzm5orADh70wactW0DluzcgubmUjT6SgdxvA6Mow3K+aHbrLpUqWi0g8axcD/BPwAHjdkyQqMhMtaaQSim1pOO5fPvqH0GALA6Os6qOy5nr1X+QTtl+fXU8/NufoKOHaiV1gtS86TCcTTtv6kanzAiHX7M9lEk2uQa9hM9P4u16Q+7SQvWPIYXd1a7yCh4CtU7Q6yhzwhLmVtpbL2P51t1LhGoiYrBxwFAWs3JhNDsyQyOuSpra8YptNkDUiPnRB9y0FnDmr/iniACbj9gs6F4E1mlZGbBpAjwSvsU73KPiKgUuR+ias2HK8Q6UWIop0UGgXKbosU0JnLthMbI7MR0/dy3+IBINVstrmjYiDmJVtww8Dqum3w9MjYHgmMlj7wK6hcafjMDdlJkwI4KZfeYHBr0v6+ba9VlCTlhtjXEdPyY/6ltVvnd7RMAAH4RyBYrEtHIZmbF3UIrv5V/b6smGZw1gc0OiQQdm8mMvBimoxG5u2xwuG3om0zy2R0SXOFq2uQ18rPomcrPsneayoqax+c4BnihXjR5IwDgb62cBTm7VQRqqku1BHhOuIRVrGsWrbOU+AaPVtJCy60XQainsfU3WE+mf18PTd5uFKGgrx3m0VVdHQg4suDr4M1G2sd9SqqMyIk8vn6wRuRmaKS++rp53xEuE9tH9aEgiS7MrPC+Tl5crgEu28Jq/XwIgUNuAx3rS8Vw455nkZ+KYEt/OX6ykPI4PLRiCQCgUOznTSshwDz5MojVFSTZZni57cFa3rf4lHVwYB7LwIEkv8MdSs6kfNzmZK4Igi0kd4vABDbd+7qEHFDjI/eUpqEv0y808FGtgR+18MUS+MUT/wt/PI5rP3fNkW7Ov4Tnpx6DqmAvtpZWo7Gp9MAnaGhoDMK4QDv+5/Xf4KWaBfitSvQ23HDfxAsRt7vw+wnLRow2UUPjcOL0YB2u7X4FPyi/EGsx60g3559G1OHBN2dciTM71uK+M4anHDtU0H4JIxAVvQHMatuHKV2tGNPXfaSbc9BwptNwpNVnu82G3x5/Ot4aN+2jT9LQ0NgvZnY3ojg+gOM6d8CT/hBT1FEIt2hr1OHBvZM+jV5P7kecoaGhsV8YBhaGdyHLSGJ+ZO+Bjz+KIOXAbn8Ffjn+XBh2vWWVGFUa+HGT2/Dc28dYf5fWKb5XYbIecwI7MrT2k4kr2cg2mvxtwnSiLL1OwdcqgxYdKh4pm2MW4W8V5qQwmXhiRWw6sWVIy5TsE8Ekcg+uLCuti7kdpavZbNXj9KEBY/D5b12DvHAEq6eXocjN189tSAxpc0qWlWlIBn60nUQdzeoQvLEi5bG9j+xBRXVsB3TG2aTYeaLalAsTUV87m6UKttuQHY/izlf+jIDHj+8vugRZ7WxCsiWUKTMtzXPKpNfF7XQKLl2TX1sGH0m3oHie6R4l+KvlHsE0axXwSWNq+EHc10qxBjJlckzkP/b5VSDSAPfTdzZF5maJcwZiNGHSOnbtsGHRnG04J4sm/VebWR481MIT4PLK9wAA39nwOasuKshPzplLQdotkXyrbtfGCVY5oszfMoeET6zjindpHUbKec64B2heRMpESu2x7Hbm2kFzSab2lq4p7j66Zric1t4TcxYi4nfh3Zop6PNloWAH9bl/vNBkS75itWQr3hJmbge/IsxgtBRPafg7zFwZwp0gxY0qWU3tT+Xx2jdT0QPMbW/mVZjU24qfrPwDfj31bLxaOQfdc5VpX7gTSNeCxDjqU+HrIp254p2W7kdeIScau8i87W2V/NKCp92tZMtY9m+q7+OHv2gauWG+uZ4TZ/nEOKZmkxycWs5R8Tu7+HzziU8p4Uat30zudRl+3BqHEKGxBuxeA+5+mtNptwi0VA+oZx6vQ5FuBJOXEqn7lvW1Vp3Lxe42LbF8AEBWM6+zJHuFwb+gBwBwXFmjVfeP49kVz+6i9ZNJ8f0dDppgiTw+Lh3hzYZJWpG3Q0SDJ2gd3114JpZ5tuIF/yw42tlNMD2O52Qqi9oaKRV95kPh7VNtEu9L6Qbi7af2uYPsYpP20LHugMiVIu5v+NUCdYhgXJcNMAyc2/A+rtq2EteedR06CtgdJVXCsqnkDWpA7l5+eSbyJZ++cgkMyCBZkkPhSl77cq9jkhMUv87yat3WGXyA8piNVPM1fe38nMtnk8z4yuUvWHX/8f5n+F7d9MzcfSLAXuwP/1noz5kRiq1jK/HudM5UNrW7GZdufgM24+B8qw43KkK9WNi8A5/auxHj+zsOfIKGhsYB8cLkBegTQV/ntL6PeS17PuKMI4uFLdtQHuvHF3e/CkcmfeATNDQ0PhJJmxPPZ8+2khjZjQyu7HsLhfHgAc48MrDBwNkNa1AR7sOF9e8d6eYc1RhVGvjRCmc6he+/9ldM7GtH8fgQ/nfCp450kwiGYQWw7Cyqwo8XXoTthVXYXVABf5sO5tLQ+CQxLtSOm3Y+C0d9Bp+/7BZsLa850k0iiID6v8xYgoL+CB4bfwrSdu3zrqHxSeOi4DpcEliNU9btwhXH33p0rDMhAwybHXct+BxO6arDn2YvtTwZNIZiVG3gG+uqULaVTRfuAVPDwxO48X1+qZnm6UyVmEEXMKm78VoRACCnmTebhjAHDVTTdWMFXJfbyBpwR4TMQV4xectUqt7O+WweS7HVzHIDyanltLvBTiaf9yn+9PPPWmXVPbP5ZPx1wcm46v1X8UzNCXRvES2e0ywiyytoSviFC0vhdWTqa/sLM67E87lNlYpBwtkvWBkK2WbobaNrVr3Gvjpzk7txQ91z+H+LvormSmr/n09mNh1HQkRuJ8lmnhEpl80U7hnHUEYMAPCoAP39sQLR9en/aBHXhWv5Av4Guu6mZb+06rLtfIErGilde1BEqNetHs8XU488PZ3nhlPx5BdlsavR+DwypybDCWyBxuHA2mdnYnwTBXM9ueQBq/7LdVdY5W8vvxgA4G+TacD5Glv7ygEA8TTP03ANz5/8bfSsw4L5MKdZvKSUnDBduQAgqDxwql7n60TKBQ99giazTbiS2ZLC1UzxKUtO9GgxX3/n9DI8H1yAvGQYO/Kr4YgPzo0QK6bzAhMF64IQfa5wRv3PdQk/Xd/fwm2WPPFp5c5imtMBwBWiYx2ZND7f8gpmdTbiexO+aH3MP1R2GhAG3OEEnIrpIlQjXBcr2SSftZ3aKtPa29U4ZYlcGILSHak6kk35i9jSF3mOczhEFOd2UTZ3tOs1fpDvu4l1y5bPY5+Ywb4vpofcwxOeturOjX/eKrdso3vV7WILaR6l0kA6fhRspkYBLj39TXizXXj4uaUABvP85+2l+Rmu5jlrumQCwLRcYg7bM5ZfHuIVjtVNYwAAbqGDkq61wYZ8AMBpU1606q475TWrfME/bgYAeNpE/hfl2ZvbyHO/v5PfsX2zqc2dxwnu+S5Jz0IN9ARSeCd0DBZt2YPH5p6Ensl+Va/Y70SOBiln4nlqHQtXIzkm9qQpz4ZuKbOEDE1VsDtMxkNzPdsbxW0bnsDakkn4QzVxum9DGdacQeQVnh7hrhtgFxmTecrVx2vPcMr9F8khn5BhvdPo/JhwhyyqE7k0FD97wQ7huihclfo+SzLha9Pesup+vuZUq7y7g2TDD4LnWHW+jSzDfV3U5t7T+PozziCL6NvvTOdGJQ7OOeaQutDceeedOPHEE5GVlYX8/Pz9HrNv3z6cd9558Pv9KC4uxs0334xEIjHomLq6OixevBg+nw9VVVW44447YMgVo/HRsNnwt7kn4ryrv4mAmx1Ib9j4LM5ueH9QsMhhaY6RwZe3Lsf4YAeu2rbiwCdoDFtoGXD0IOT24QenXIJvnHGFtVnOjkdxz4t/xoKmXYN3IYcBpbF+XLXxZZzcvA3H9dYf1ntrHF5oOXD0oCG7HDccex2emcI0lye0bcP1G59D5UDPYW/PSe3bsKh9K67evhxZidiBT9CwcEg18IlEAhdffDEWLlyIP/zhD0N+T6fTOOecc1BSUoK33noLPT09uOKKK2AYBu6//34AQDAYxOmnn46lS5di9erVqK+vx5VXXgm/34+vf/3r/1R7XEGbxcEKAPF8+gKUmtt0NU8gI0hfaw43f6GlVvJXd0YpqgZq+KKBiUKY2FW5lK8Z7GXtVn6cbiwDwGwqWMXkYweAjPiqjKuv3rAIuEON+NRXWWMf2cKZBR1KQR+HA55y+mariPbg0p1vwA4D714xAd359Enq66K+hir4225WFqket08WloJVXPbvIfVFpDYf+8PUV3pxVuta/PXEkxHy0Nfoj/A5nNP0Pv4w5Qy4B8xsitzPvF2s/QpXqS9YwRcbz6Wyp5/vU7idv2oD42mcY0V8jtQmBsdSvdQmSpja+GPf+4pV99tj/myVv1T6NgBgqY8/fpbEPm2Vm1tonnhaRIDyKqprLuc51KCUKJnYyBRcR5sMAICcfRkYBRRANVsEeH9dZGK9561LAAzWzMmgyJb3iSRcyo6smayit9fSmrRtEPJCyJ5oCf3h6ed1VKSSF5uWOwBIVvKk7UuSJqhwq4xjEbzQSeqLIZS4SSEmbIv66fc3862689eswTnb12FyVyvem/oNwGYbFJw2iNNdZavMERkcQ9VKoyW07t4ubvNALa3DlM+GCb1tWNC6C3+dtwgA0IsK/MhzIWJON1ZHJ8GWUYF6BXytYC2tUznOpa9wA719NM69U3hwQ4r/3QxIA4BEDssBM9t2d4CVGbkieLRsNd0sWl9h1dlZQY+C+qFZnGOFrGXrn0q/z3viFj5fyDaf0ih6mcYbLsVDnk6MzM3o0SYH/r2oHrk5Dnznyu0AgPFPfdX6LTiZno+vmn3EI608V3aGSDMci/I8de3g5+9Sc8nUtgKD51/OblpHt28+z6o7przZKudvorlscrpLxPN5njvF/LYl6Pp9x/MHT2ojt88TpGP7J7I2OTyWF9Ulz76B49t3IlTmwH3Hkfa45mVex+49ZNqPTS7ne0rzneqeOyD67B9KFJHx2XBc1w4YsGHlbLKCPuxbiCq048mZJ6BzihsmU0dWy1D9sswVY1raUrlCQz6Jy8Hx1JacRh6zlHrf5u4WTRdLLruFZJvMlREpEdzyy8mq8ce3zrLqnEI2OKN0f+dx/D4Pz2PPhLLf0rP3PsFj9+YFlA38X9GmH9IN/Pe//30AwEMPPbTf35cvX46tW7eiqakJlZVkovzJT36CK6+8EnfeeSdyc3Pxl7/8BbFYDA899BA8Hg9mzpyJ+vp63Hfffbj11lth+5AkABofjaDbh1/OPxs1A91oymd70gW73kPK7sA/cmci4PN/xBU+Ah/QiNyz4UFMDbZgoMSDR2aS60ljThkemH7e/s7WGEHQMuDoxntjJuGx2Sdic1mN9YFsMzK44f0XsLl0LN4pnP6hiVYOCCEHSkL9eOxv98IOA2+Mn4ZmlTL9yZkL6fcNmn5lJEPLgaMbf5u6CGm7A48du9CqGxvuwKKuLVhVNAWNcH3E2QeAiHU7p+l93Lb5KezJLsfKY2ZSvc2Ge5aayq+jk2TjaMURZaF59913MXPmTGvBAsAZZ5yBeDyOtWvXWscsXrwYHo9n0DGtra1oaGg43E0eMRjwZOF/Z5+KO09imjxfMo4b1z+H/3rvMZQP9Fv1VTv7sPC53ajqZZWRO51ESaQfBTFWUXrSCdz7/u/x1Cs/hC/JX+8vVS7AzpxKtPvzD2mfNIYftAw4sthTVI4fnvZZPD1TmNOb6/Hl9a/gG28/NWjzvrRhE5Y01MGX4rWdE4+gPNSHrCRrnGb1N+CX6x7AHVvYYtWVnY+3xk7DyvGz4UwLdbqGBrQcONJ4q3oG/t+p16BFUDZe0PIertq7Eme2reUDDQMX7Xsbc3r3DKorigRRGewZxHL3pY2v4KnH7sZ5rRyP92rFHHR68/B+ySS405qo4uPiiAaxtre3o6ysbFBdQUEB3G432tvbrWNqa2sHHWOe097ejnHjxuGDiMfjiMf5JRMMkikst8FAUgR1mbzLMpAMfWzaMHz0ojE6RUCpCIQs2EmTte1kwSFbwCYs0x3G3sIndS/m3+0qOjV3L2ufEioIJJErgtumioluuvNE2U6+cPZOq7z6TeImdgX5i9l1HHOvFp5EZv4da8fyNZUNyRZJ4eFzj8O8+iZsWFqIlJPaWvKbGK56/W045zhx30kXAADObFmDb656Aq+OmYUbL7sKAAXqjH2nA4WJEGbuacGmUno2v79gEX5rOwWR8WkA1JeQCNDJ30n3zxJpmqX2zkwt77iEeZP76shqkM2WR4v/GQDsasikmVtyXpu/Z4S7QfaeoQGxvlVsOr3ZfYlVLs2mYOZ3i9kWd3IpC7VHlQtNooj7lHM8zenI65yj3aWstKOVB/5QyQDgw+VAzyy7pU+a/MqXrd+9Wbw2Tfe4eCFPGsndmxpDG1ZDBlWt5qiusDpf6gSdURHEqublwBieoEVbaFI6EjwPs+qFyXscmXfjLSLfgFgz6ayhLoHxsdynmya/CQC4t4kDrOwFPD4Fr5E8Gkhm4+/jjkPY5UVgArfvmn/8A1N62vDVs6/H2koKwPzl3/+IEzp34O7ZF+OlanLb66vyY+rGFvR7suCIZwCbDYYd+MaSq5Cx25Fx2OBUIi+7nfocruJ+trMSEFljSF75nmVfIDPgDgACtSRH7EJEmkH/klDA0y/IA5SbivEKWxhN0zkAxIrpmvJ5hSbwoDri9LtN3DPMSxq2YhrTTEi4+gjO+dAEOjHjFBz7VYqPPDY6tciHey/wpYalcPnd+L/xKwEAr533E+uY0x77BhXW8Hp2z2Pyis2t5FqV6eY5m/SLHCVz6B69u3jOpv08f5xFJDtSAd4X/PLY5Vb5FBDvuOlaCgB9k4Zu1Tx9fE9PN63TTID3L1nd4vd+un+omq+Ts5PlTEy52UrSh3WVE5GfCWN11SSgi46t2dWImxueRcTuxpmVPwRAwejLn78dAPCZBd/EgJN8DQt6ohgb6ML40jYEx9FY7ZvkxaLF/4WM3Y6sNrpPlL1yUPkGlyMqAXtIkGV5hIv+QA21KVrEvo1x5vNAxqOCXPnRIVJG6yvG3ylIZbGMy25UeSuypYzlQTFzdGSE95BX5PcIz6Fn68nwOq4oYtfKZK4KzO1leWPvobEpnc77m1Q4Ds4S8OH4pzXwt99+O2w220f+W7NmzUFfb39mL8MwBtV/8BgzaOXDTGZ333038vLyrH81NUcJXdpRjmBWFn76+dPxpe99GSknL+6W/AKsHjsefT7ezMYdTiTtDnzQY/M/z78En73m/2FrEY95xm7/183wGkcdhoMMALQc+FexK78S9xz7Odw/93yuNAzUlY3FjqIKhN28cUnYXYjbnbALzdvu/Ar856Iv4uozvzbouhmdRXFEYTjIAS0D/nW8XD0X/3nCFXi9arZV5zZSeNs/CftcHNuTtjuQsDsQdbjgErkbVlTOw23Hfhn/s+DcQdfVcuCTwz+tgb/xxhtx6aWXfuQxH/xK/jCUl5dj1apVg+r6+vqQTCatL+vy8nLrC9xEZycFVHzwi93Et771Ldx6663W38FgUC/cj4HH55+Ax+efYAV/AcDzE47F8xOPG3Lsm5OmAQByGkdmMJbG8JABgJYDnyhsNvxwKbnbyWDw7yy4HLDZBlHOJR1OrKydBwCwp7QcGKkYDnJAy4BPFi3uQvyw8qIh9Z86+y7AZoO3i13pmrJL0JRdgoh3VLGVH1b80yNbXFyM4uLiT+TmCxcuxJ133om2tjZUVJBZavny5fB4PJg/f751zLe//W0kEgm4FWPE8uXLUVlZ+aHCwePxDPKTM5GzLwZDmDVTXvoSHMQf3s1fh7Y0lSXHcHQGT9BYGd0jZ4/gRhUR0R7luSKDtYMFfP3+ySYTCp/jVPzsSZEuHB7Wbp00dRcA4OGxr1t141+6ms8fSxHPTyz8lVU31cWm4ov3UBKnTBZf01si+NuDqi1hYWprUNyls7hJRjGb5vMK6PxwL98n5eM+5e6l/91BvmZWJ9/fGaNyUpiy4hN5AMw0zi1bOdg2k0sPLZHL1xyoGcpe4W/jNuddzP42e3fQfCvcJFk8hvJnB8aLZ6v4ewEg4CbzaMffx1h11/7b363yA6c8DAC44bmruH0JGhM5H4q3q0j65PAJ3hkOMgD4cDmQcRtQlPxwe9kPojCb10HPbMVytIrN4HbBaJe7iszfJrsDMHizGqo0GRj4nES2yGOgOIzlNV0haoszKlJ/Z8t8EHQxaVqPlvD8NV1LUj6es0Vv8mT71VYKGs/jbiKZI3jmlexJe4Q2UzI0tFG7JCuWYeZmEKfIdWReK5klWGDE2o8pJrD4pezmV2zn/vfsoHmWL9gtHGJ8vH10/5RXtEkNiUxf7wqJ+3fQoDsE40tG8NR7u+k5xAt4bP17Wc5ElWnfyxZvpErZJP6FGaR13hdlO/263ZyO3ZlD948XC01kIdVlIsOHjWo4yIEPkwGtA7lwZrg+RyQzOvfU1QCAlfumWHUX1nKWjiyVROTPe5dYdZkadoMdV0ixYo2d7IKTv6zTKl9aTfPj5Z5pVt3sZ262yuYrreUUblOqhO7p7OT17BOuG27lihkTeU3iuXId07UKdvDaCwumOZMXPeXjNRERssUxgz6QXEGe55IT3p5W8s4t2uyj69sFS7VkfRuYqHK5+LhNktHvnpuIregHO1mDH32WP9TMfZuUsen5HJNni5s5bcReZh/dq+NYYUUUTF19U5U7jhi6aAn/YfL5m+MNADG5BJQLdqqO3aPEkMHvpft70iLPzmb6vy2P/X8y0YOTA4fUlrFv3z5s2LAB+/btQzqdxoYNG7BhwwaEQuSUtGzZMkyfPh2XX3451q9fj5dffhm33XYbrrnmGuTm0qhedtll8Hg8uPLKK7F582Y89dRTuOuuu3TUuYbGMICWARoaGloOaGh88jikto3vfve7+NOf/mT9PW8emVVfffVVLFmyBA6HA88//zyuv/56nHTSSfD5fLjssstw7733Wufk5eVhxYoVuOGGG7BgwQIUFBTg1ltvHWQWO1gMjPHCkxacpOoLMiK+sGRwQqKYNDH+3TxMbsH7nUrR55hHaIcyrv1n/zPxX4uetcq/33syACDWWGrVmcFtrmNZI3XDJM76dX0+aZE3iIQHPzjpKav851bKtCq17mftONsq79hWDQDwtvGXcvZq1nbbzSCPYu5TYJLSRgreYkeryNbYR+UC8SUsrRoFO6mtMpNquIIPTuQqbtQ+oZUX/NO+NlIZTniCn0PnfPpSlkErMlAtUUhtdsT4ntP8/Nmcnkz1XeXcd/dr/CluXvepyzi46aZ6NhcHnqCoNTlf7t+6hO+/m/hi8xpEZrgB+lSXVoGw4uVPH2TmteGGo00GAEB2ow2m8ihYy+PevIO1Ozk1NFfsQhEiNbpupVCTmt+k4ImPH0uqpnSSrx8Zy3PelqU0//08gRwJWkcyeFIGqRoq67AMzjSkkk2V5ZwclONCKdtlBsUcESllWp3GXLDXqvMkWVO1r5LGJ2cX98mnAuWMD5m+Zr07xH2SgbuJE0lj9s68B626xT9lTu9sNUzOmAgiFeW0az/0dvvx2nFFWDb0q0yzMhhWyhszm6N8Dg45D1SCy0ileE57uB1PF5LP8BWT2CXkT7dwdN72JM2Ni1b/m1Vn20QXHanB7EebHAhEvHDAiylvfgkAkAjwPLcpbbKcR/NnNFjlu7afCQBI5fI8nFTB5pjeGAmCWZ/eZtXdWc3v/VonPetf7TjFqit5n9eEmXE5djKbym6b8SoA4CcrOADdzI4KsFXIDNwEgGS24J5vUZrfXjb5BcYJ7nrr1SjiDUT/Tatb2iM07MJibsoeaXk3ZY+0OEeqhDxTOWuyirifiVx+B1+/QmXG9vLazBLJZYu2qXwNhWJPt4MPKN1sZq5mK6s9RXXhGr6mp1eMo5KB6eNZk1+cy1GwHavJOiTdCKUVtXgdnR+q5roskQ/A02cG7fP+ybTGOgK8v7HFDm5rfkg38A899NCH8r6aGDNmDJ577rmPPGbWrFl44403PvIYDQ2Now9aBmhoaGg5oKHxyWNkqv00NDQ0NDQ0NDQ0RihGVXhw50kpOITZqeRVsu24Rbr0SJWwGynOdRHrAv8KNtHYVRBU7zTpgsPn59dT/cBJHODy5dwOq3z57McAANO33GjV5alzMm+yb8iDTiZGfruATHVrmzmS/s55T1vlG2teAQAEM3zPvV0c2ZK7QwWNCdeT6H5ciGwVbDP2rSJTmww+65/I45i3R5myigWPuojJNE3+njZ2YUnkFoiyCha2czu8nWxWsyXp+s4Qt6mgnkzW3bPYdB0YJ/izVbyq5Ifee99Uq9yqrJc/P+thq+5rbV+0ymXvUZsueOt6q861k02Opmk/t4lv0Gdn859J1y/dq9LK3SIqgl5MU1yam65xiJHyAQ5lyXW52KTr2yOCuoL5AIDkDH6+rny2mxp15E8jucBz9wnZsYp+D1dz3RdOZVe4zUFKWNPz01q+Z74KIhVuOa6QcB3JV/kQYiKFuggOHaim32OlwmTbw7/Hi2hSuvqFKxvnzYH3GPKR27Kb7b/uNl5f1WupLWkRVB8ca1ft5OtEBK9zajzJoUyK77l4CuetKPOQTCiws/9R1bns17O7gxZLXgObnFNZ/NqKFSk3yLks7zIqeM2bx/KiK5fldkE9jY+vU+TkEEHkkXIS+MExvCilW5JTiaboBHanzJnBXM/vzX0cAHBFI7tIoJDzRZixgfYN3KaM6pJ0idI4dMgYNtgMGzL7aN5ldw8NVLzvij9YdVNdTEAe3JsPYLCH7LnldVY530ET5A/7TrLq/mPfhVb5sfEvAwCSKZ5foWqxTkvU/HTy2n+k6Vh88KbSdaP6Nfqj8RxeG+FaMafV9Qs38jvM37afd1MZ18UK+GaxQmqrp4/bnBTuLBxIyueUrFeB2cLN7Xdn8pje+PBXAQCOen5v5jSLjUM9yYz2hTLYVrjiDVBbJE97dhPf39el8mrEWEhnlAtQ3g7hxidcCs3mnzGO3Z+qPP1W+Y8J5UIjZHDZWn5OSRW46+vidphkJQDQfQw9H3efIOwop/YtnrOd2xRKHBoeeA0NDQ0NDQ0NDQ2NI4dRpYHPLQnDm8tatKSftDu+Hv6Cswk6qDmVxDm7LYeD2xaN32qVX2+lbITupNDUbODPucAE+kpLRXiYJ7zMtIIuRWFnlLOmqNdLqp78sazR6engL9SqSqKR3Ccoh17un26VH6iiwKlFdZdZdaeOq7fKLwaJC3L2pCarrm6LyMpqIi60A+NofELH8tjZnSJLnIru87cLDaQoDlRTnwr7RGbCHtZe+Zup7OjoH9oOAOmyfABAopyjCGNFNKYF9fx13T+ex3l/QXVSm+ntorZ87Y3PW3VZzdxnd5Cu69m6f42FmdHNcPA9Pf38e7jCNuQcR1wFyIhsvqb1Jy20KRqHFvm70ghQDB1OquGAzRXTeR3ZVPDptClMPfrNMS9a5ccmUA6EF1bNteo8AZ4/5jO2J4RmzeD5v2PFBABAVS+vfVeI7hkYx+reSBmfExxH16p4m+e8DDQzLVl5OwWN5CbmbetcQOsnLqjm7CIYK1RPMuXsJeusunfXzOc+qchfSWOZ1aGsjDX7D973bqb1ExnLbV6Uz/JokpsskuOf4IBO2amKicSV1zuV174hKP9cpvW0gxeVZyyZA7ae+Ger7uoa1oZubKUgU1u5DCDme5rBeb4ekQ06R1g6FpGGddkE7seaTraIjnvhKwCAsWM5sPGSPadZ5dX1tdROEX8bL1TWXhFMq3Ho4HWn4HAnESyhd49vGz8MUxv+7a3Mdx6N8+9zj6GM2/luthKHhFB/pZssvemM0PKKlN/m/MjfxNf0twrrtiLa8EzkNTPwIpm13MJyHpjC87P3JCpfNHs11yV4zYzLonX05O4lVl3RVkHIobI4h6oEdWoHX9+UPb7TmId/YA2b2sxs6pJ2ueM4Wl+JXL7O/zR/yirn7Vb7I2FxlAGpEVJ2Y/xM3qvsbhaEHw1kKpG0thKRchpfHzN4Wp4BDhl4WsfjbFJfvvYnznETZfZqePvVvQWRQFoQlzjjdANDJKvK1PKe0tamiAoEnWYyTGP+dsM4Pucg6WS1Bl5DQ0NDQ0NDQ0NjGEFv4DU0NDQ0NDQ0NDSGEUaVC00s4UR4D2fHw0yVWXC74Dbt54jVNsVJWpnP7iw/rVhrlS8IkQtO8yPjrTppbrGNIRObs4kDtBwxNpvlzycTqzuPTTjPLPkrAGBdnCNEfrCHM5FdUkAuMiuaJlt1L70/h296Ef1e7GMbzXiRsu3aE14DAPxm9WKrLreKg0ujW8hGl7OBx2TgNLqWwyG4U1/n9uU1qGCRqAxuY/N07j6yV6VyeGwdUTbfOQLKxOTgexo+Pt9M026X6dpVtsmUV5jT2VKFmLK0RQRXb9FmPr94E9W35fLzKN7Cz8HMECnNb9LUZwbtSFcdmU/A5MCNCZOgyYebEasufCqZ+9ORGPB7aBwGJHLt1vN7o2GCVe9t5bmw6KyNAIDLit+16lZH2cS5rotcJvZc9FurbnLRl6xydVE/AKAnzGbsZ0U2zpwWmouJPJ4MZj6E3nk8Z21JwfluH+peYcvwnC7aolzREoLT3MXzL383/d6dxf2UQWG2apJXXyx6x6rb9hl2H0z/XJnx+4T9WQ1krJCvGRcBn2Zw66xp+6y6M/y7rPLFm68EAGS1yPwcfH5XMeVpSNWKYGPh6jZwAi16o4dlS4Gf6u7r4+e1sauKz1HyLFQviP2FFd5cn6lS7qdNuAxeNYNk7B9WncwnyehT5QLU2MAvg+Ywuxu4lauU6TYDAMfOozFJhhNghwGNQ4WBvizYY16MqyEB3zyRA7fNzKGp13mvkNPL62S3CogOThXum4InvsRLk37jVnZNbQvzOnJW0vyUmckD4wQpxBJyKzu/epNV97sx5HriDMmJysUXlt4PYHD+F4mZ/3MdAKBiPb8kk3m8ZgeqaU0lSsQ6e5dvYGaBbtnFc9ousrZmddBYuAd4bZqZYAu38XH1Ud4reZW3scx0H5zA98zZTWPS9C67p3kEaYAZfBot4zEpe58PCJfThZPCJdEVVnkrBGlEtEgE5vrVvkIQlzBHPmddlTkgXGHx3s9QWZJnyBwvTuVSWVzH+58eJUNDXnbDEhwkHwmtgdfQ0NDQ0NDQ0NAYRtAbeA0NDQ0NDQ0NDY1hhFHlQrP2hEeRmzOUcPv/TmPmmKe751nlTR1Eknx6JfNzznj3C1bZUGbT+IkcMfyHkx+yyj/eRymXGzbXWnWSN9rvJgqIL9e8bdX9sJPMsu92sPm3cwcTh1+y5SYAgD3K316CWh4nbfo0AGBBMRtiH9/HferqJvOfu4nNSqmdojyV+pISrA7pVnIBOvsUjnD/x0aO0k5kU1tyetjk7OvlcTZTnzv7OGofwh0mncdMLyZkFLdjgOxJzhDXuSJkdkr5BFetYNdIZZMprnR8r1UXKedxNJk0CphUaJBrgF1xSUsWkKhgojBdcNwBYUadxHY305VKtilaRvfMEXzjG04iHvrgQBqCYEDjUMIG1KykORXbwHMvUMuHvLaHGKZefX22VeeI8vM/9Sxiavl1gF0zvjePs0j+19vEYJG3ntdWUpiH+xThTWYHi+CcJuUCI1zqHJKn/g1yJ7EZfJ2BGl5n4UoqV73J58vcCqYrmluYhL2CJ97YSeb3LzXcZNWlK1m2ZU+gtuYLK76VTl2Y81PZgktamZQ37WQz+CvlLNtiKdV/oUoStMuI9ZIc2nMhuypNf4fzNbg3kjyTrBL9PeQ/98c3zrTqktn8e7JIjU8Bj23BFh5HXxd1puPT/Ht+HrskPvLYUgCAfz67Voa72XWhYL1yKxokj3hMspU3kclKBQDbGsklMh0/OPYJjY8HhycFuzdlvXt/Ej3d+i2ykVxnQtPYzSEcku8zVRBuU0Uenh8rNtHitol8CbY8nqBGms7rOo5/d0TEuy1J82dTkN16vLW0aOU8c/Wy7PhByzkAgL/UvmbVSca7gpOJx749zZNSkGIhMlm1T6zjfWfx9bOJeAf+Rh6HyEyeq4k8knPxHO6H5aYi5JWXvXmtNZsUu9DS1ZJRhtZMtmByG6gZ6mqX8gs2nql8sdBken72CLe5ZA1dX+7DpPucT7lKLfl3diMsEz40P3ub5om3TTDeiS1l+8nUV7tgtcpdz/sCbx/VdywQboxVio3QwecYqYNjo9IaeA0NDQ0NDQ0NDY1hhFGlgZ/z2hfh7sm3/l6whLJt/WLMC1Zdupi/aXb3k8Z2RStn8HS+xZzsZgCjv5/vcd2ea61yrJq+AF05/GXljPDn3q21KwAA52Txl+wDe5cAANqaWR/ryAzlWK5c0GpVNbVzsI3xDwqWqTubPzGrclhTFH+RVMOS41gGbBg20nilOO4W+ZNIiy0DeCflHmuVoyU0ELm7WWPlEdr4ZDZNs1hRvlWXvaOP+9euyiJjGwxBcG2jTjvEV2mBCsbpOY616l5OlseaQYHABB5Hj7IQFNSzlsVw8jnJbPrdzl2yMvQBgL+JNC5dx/B8kFkt/QuoMRmhpQm3k7YwIbIBPx+h8Y5ExI00Dim8vWk4FM9/VoLHPZHN2q30BlUW00gGM73x1DEAgFfmcjB5SZ5MR0rzJzhRaFJk/Fk23TdWwiLYFaVy1SN84L6zRTC3muqdfl4nOc1Cs6uyGJp87QDgbWfZYqh1FDmJr+nmZYjCHbQWvMJ61jOLLXFm4JY9LdocUnWnsqXLnRBWq34635bmNv3g6c9a5VQejUO24KNPiAyPthSdN/kNDhBOxfj+bnWr2DiWNw6vIifo5gXraxXBvDupf5FSblNWh1h/apwKVoqgMhdbatzqsgMRMY5dIiBxCj0Ht8h4mxYBf2Z25razWPZkbVec1loMHBaUFgzA6U/gb+30HuvvFBnWTY2uXQR4i/lrNwPLxbN6t6WW/1CnefcIy7ZfzBUlJmKlIthcyJnQVnr3r4vxez01mazXMqg9VcGLxvQWgGiGTcz/3jDNT594hyXyRP9UgLwh11YlWxXyplKjm+sFD7s41iSVyG7jfUfbQvo9OF4EcY7ntPe2/VjPkiKztMkDX/6+2FeIDKbmHiUlzvnqlc9b5TXKpOpz8DpbvW0uACB/J9804+FrhlTg60tN06y6cfks2xx+upa/RcpA8RyV1cXdLrLCdwkLwXRqayJPBLDPJPOGU2w2kuEEOAPJh0Nr4DU0NDQ0NDQ0NDSGEfQGXkNDQ0NDQ0NDQ2MYYVS50DjdaRTVseli9zZyjWn9IbvQrOjjdOoB5d6QSfN3To6Iw3QPkGnE28NmI3uKh9SmgjxSPSKCahabkCIZsmeNf+IKq65kLZlYikR63t65wlZnWvdgDKkDAP8y4rX9+rjlVt2nfHzPSy+mYJeGfnbRcT/JZTPVcGQSm5j8j5Mpb9br11l12YKn1NuvGmDjNrtb+vmAGrq+ma55CJw0ZoaXTe+2kLhBQpnA0jwOmSpyBZLuAhGm2kW8lJ5Jh3BFcgsPncQiGpNIgJ/NIA7bPLpu72wxuGKgu+eR60z4DB7buRXs1tQZJReMYi9PmEwBudVsCEy06m56kZ59JhoD8B1oHHrECh1wgdZeyi9MnR1sah1QeQwyYs6AvaUQqaK5mOfldXJGxTarHCols+gT2ziAfMFY5kLf/PcpAAC7MB+biOdym9wiyNQMACuuY7eYnhns5hEroPMC8/mi1U+LoLcQtVnmNjCDqgDAnhyab0EGaFXMpTTq9nn8e+s6snM71rO5XwaqZSkrf5hjfZHTyOd7e6l/AaaHHjTmReuVab6FK3umszvC3Eu2AAC649zPidnUgH/sWmDVFW5n2WEG/jqFLA+Xc0e9fSQEc/fyOAbGS2Jo9d8u4VbDXoqIqtTuC5ZxhPy7uzlwt+N8dc5ePj9eRGOSiUl5o3Go8I8ZzyI3x4H/6pwJAKizc8CoyeOfv4bnmVwH8Xz639cm8sf0MBGGVz3C7BZ+lub7RF7L5DkHAGNpv1UeaCHXkpRwccnykGyKpni9uxp5ToarZfAnIePivY67iGRGFHz+2Qs2WuWdQXqf7mwSfPXvs1tRf4bKPj4dDvGK7p9KbbWJgTL3ElmTeXFsPO4Rq3x1zUkAgDf28PswVc++u4kCusBANe+p+qdxn8oV94c7yH3/6WscuO5VbizRakEKMFG1M8XP1iQPAACHCj7taWFhv66Dx8EWVbk6ZrM8Cfdwn/27qWwTWzb3VW1WuSRDz7xlD/Pp7+wj38ia3H6rLpkc+jz3B62B19DQ0NDQ0NDQ0BhG0Bt4DQ0NDQ0NDQ0NjWGEUeVC89bCP+Gi5bdYfzuVufK857jOUcBm06mVZDLeXM8cxhkxYmYac8PJ5o6+qSJKvIdMpH5hBrd1sTnmm1HibHfE+PdgLZUl44lM1z7xMWK56XuWbdI+wRjjPY3cNCSzzX19zJTx1ER2rTExvvmrVrlqQhcVXuXU3z1zlElRcKbnNAuzU4zMWimRot3uZ1ubTbHHuAbYlGUTLDPpEjJX2WLi95Skf1FlcY69sx8A4O3l8QxMEHZOZQYtKGcXlwnTmabmJ2OeAgDcVMKMGH1xNml3txBfrr1P9Im7jO7j6Y8zxuzm+yfF+SFyzekIcvscitXALvif0z5lErRr0/nhQmCiDa7dJjMSP4uB43nOnTNlDQBg5VPshiHXvq+cGBoCwj2ueBLPtXlZDQCAvw1wvoSNy6dY5dKtNNejhTxno6otZ1/FeSF2hpj1Ye3uMQCAVBavrWMu3GKVq3z9AIAnnz3JqrMZgtlA5cCQbjuS/SJaSnO961yWHRMr2N/G66A27+jkNrkDavwE2Y50gfG30w8+wRDljEh3FjrY35YRvwtO7CitC0eCfy/cyXJigp/k1ZpWltE71lIKe7fgeu6fKMa5jK7pn9xv1YXq861ylupyuIrN7LmNYtDMLu/mueMM881CNfR83nUzk4WvTbwXjqN5Ei/mc/x7aHKl4wdnOtf4ePhp33h4ky7cUPQeAOAHZ2wecszkh5lRzjGBGaaSKkfISeP3WHXr2tkFJ9xH74GsDp4/8t0RV68EuQ7jEX7hf/e0pwEAT3Ww+10kReuksZ5ddXIa+Xzv8cSU0pdhv7C8Mey6cnpNPQDg8W5mj3th9Vyr/NczHwAArCpjd5b0Ap6Lv3jvNACAo4eFYEEL3z/jUfuWz/JCdyaGbi/NPDUA0NZCbndlrwruduFql1RdjXOXgRJm3onn0jh7+1k2ZO+WrnC0zj39fP20kk1h4TE1yO3ZvJSXr7nuU/db5WUbyeW1P8Aue3EnC7yK10h29U5jGXZqWb1V/tsu9UyzeO3fOOk1AMADuxZzOyOClusjoDXwGhoaGhoaGhoaGsMIo0oDf9Jj18E3RmTyUh9O3jLWnF04cZNVXppDKufr2zj7arRUfs3RtZKTBDdpHmuXsnc6B90HGJwF0UjReeki/jx399NXezKXNbKXN/KXmam9lZzjMoCqWfHcH7+eNcuFWfxVfmvBXgBAT4Y5Xh0iw2n7RgpiyRP80KaFISgCzXJahRZZ8ai6QtyPeCl/oSZUUJ7tQ5TMpoY+Vs3aTF9KaON71aCJIFYkSH2Ru5U5WoO1HBhiqMDYfvH5vkloOcaMJzXIM5P+sd82nZj+DACgY4B55lPyOebS/V/exVrVdIK//u29dLDMrlY2mYLrwoIT2szAZ4vpb+nDie459L9cjzIY/IVX5gMA0tVizgmtiXeTshpNZG31vS+eZ5ULppAmytXN8sLBh8Ldr7KuRlnTEymltf/oRtb6u328plzNNH9FagE0hjhI+09j3wAAPDZ2vlXX3yO4zNX0l/LIENZBk788E+U272wVvM+KV9rXLvjN1eWlhjFnt9CmK+uct4Mj3mKlbKnyBBX/tMgYG2HjHwbG0r2yyrkfhVtZdfmnV0+h80XWS3eYruVisQ670MY7xpLsC7axdcwlgsbClYoHfofIESGWp7eJJk2yRMi4fB5Ubz/NmZzdPI4yn0SkRZ0nMu461dywHZziTeNj4o+rToHd58VvUqcCAP7v7F9Yv93XugzA4HVS4BNWqUqS450xfl/NLG23yp+eQflSfrDlMqsuIbTI5vu6dB0/7MZCnt9376V3j01YtZxq+bBOn61TABB6lhbNie993ao75nQOqn9yKwk8Zz+/owwnn//ltVcCAOItPKeNbJ60dqXFlgGj5jwHgIFaFUAfZHcA70Za56FK0ZFGXkjFSkMeKeZrxkU6cjPbfHicaIfIEG/mi0iI7K8Z4bkwMEYFwAtCdZcK0JdZkGU2d1eEfp8ylgNPb2kSgbFOWrMuYd5zdLE8i6gtiF/c80+vnWKVjRw6b95EJjT4cm4HAKCugq358VASvBP9cOhdg4aGhoaGhoaGhsYwgt7Aa2hoaGhoaGhoaAwjjCoXGnefDVM/u9P6+//GrwQAfKFhiVX36FsncNlBZU+H4AcvYXNOyk/fPzJAKXsPH5tR9i4ZkOoJikBMF11r16kPDWnrorqLrPL2XjZjjz22CQDQ0pfPbdrDpjzvOjKBRRayiedPM/8krky/f3HnxdzmJmFOUhaqnGZh3lVp4SXnes9Unjqm+TftYZtj3h4ep2iJSl0uTOOJHHZNydtJLj7OATZZ2wQXNVzqXpLIXRHSJkuE241IWYwMtTVawd+oWWMO3j7d0aV4YMUlvT18LVs7jaP7eHbhSSR5THzv0MPvnc3mw87tZF9zCTOkOUdwkLyvGh8ftiSQUm5MmSiPu2Mfm0KzlEXcOI19bDYc+6hV/lorBYM9WzfbqiufzgGf7Z1kM7/wrFVW3VPrj7HKvf10L5tw7XApTzcZOJ1dxMFzy84h3ua7Stm4+sPuqVZ5wv/9G7U5V7ifLWVfuNjOfABAzp79z7WMh8akvJLPaW8osspZpuuMWBPmOBZyPB8yIodFSumIQmPYNC955nunKjdCwS9duJV/71pA5Xg+r714gZA9yv3P1cG/e1TzpatRelm/VU70kpn/xkUrrbpfvH66VTY6HUP64RSuToZb5a1wCP2XyIFhugTmtIgA4iw+1qfa6trtFueo/4Wrjcahg7vDCYfXCft08rP6XSe7qeY46T3xnbOftOp+tZvdIN7ZQoGejiDPQ+mOEppDzzU8RswZ4Y4CG61vM9cEAGQ38/xJKi+UNIsjy/1OuuLI+Z3VTfeKLmZ32V+M4fw2BbV00Xl3cy4XW0aQZzjpPZrVznXRcjGnTW77Ju5nyivdUKheupFGS6nu3JPWWXUvRtg9sOx98gvqn8QdHZjIY2ZL0/UnTeFoWclTn/u2a0g7guNEm6bQWAw42K0np5F+j7NYQ7RG7DuUy6tfBLa+t6/WKht7SI6Vz2cXm5BwxXOH1DhI2SFclH1qze+o52DhC86k33d2sQtwOiL8LT8Ch0wD39DQgKuvvhrjxo2Dz+fDhAkT8L3vfQ+JxODMJfv27cN5550Hv9+P4uJi3HzzzUOOqaurw+LFi+Hz+VBVVYU77rgDhmAk0dDQOPqgZYCGhoaWAxoahwaHTAO/fft2ZDIZ/OY3v8HEiROxefNmXHPNNQiHw7j33nsBAOl0Gueccw5KSkrw1ltvoaenB1dccQUMw8D99xN1TzAYxOmnn46lS5di9erVqK+vx5VXXgm/34+vf/3rH9UEDQ2NIwgtAzQ0NLQc0NA4NDhkG/gzzzwTZ57J0bvjx4/Hjh078Ktf/cpatMuXL8fWrVvR1NSEykqiVfnJT36CK6+8EnfeeSdyc3Pxl7/8BbFYDA899BA8Hg9mzpyJ+vp63Hfffbj11lthsx2864FhA7Z3sTvKj/LJjLE3IOwpwtTlaSRzh0y5LVPc5u6iclYnn9MvuMgtFgQRhG2mMweAwpfJbjzBuMqq+5+FlGq4pUG4mFSwGX/3dhonW46gfShn15BwCRlV8lewre3cxlutcv5Esi/bBCWMjHY3zfiBWp4aKWXhckaHHgcACeXFMvPCHVbdxpeYnSV/l2KZKWKDT6hSRLP3KnaLJnYXMKRJ2kO/pwtkmmUau4RMOz/AHUl5qb76eCbLjSbZNeE1xb2/xLt/7c3sWjLb7dkwwarLCJr50CSyea86ht2TbmpmM/y7YyhFt1e4X/kUxb40kwdVamfJVjNScDTKAABIVCdw7vHEn/7ClplWvaOLTdqJHMVrvIlpEcb3Xm2Vs3bQsXk8ZfH2t9nkPv7ZawAA2Q5em4+d+iurfH05MVT0C9YG13Yqe7p4nfQVsuvJXccM5SV4+LmlVjlTophthAvOybPYt2VHNsm+3t3MmS45lovfp/s6VrLsyfoCU7kk++jgZD5P4DGTiEHB9jrL1Ugxz/lwuXIXEYwwzjjP9cq3SMMaquY2R0qEbOhUZbE8+qby+JjsN7ZjmYor8wq1U7obZLtYXgaVaf7F9hlW3ZyZDVb5xjNeBgBc8xI/78rXuH0m+5ivVcgrJz8nMz+Ia4AbLd0dEoqPPzKZ54Y59zIxLQcOhxzIeA3Aa2BhNb0fKr391m/LcuoAAHfvO8eqC0ZFXpMEPX/pNuMR7pW7u2n9LDmBueW39bL/aLsjHwDQncfv2Jlz9lrlrS0VAIB0D/vexhUb1uUL3rXqHl6z0Co7FdvV1dP49/t7mY3qu8XESBPlZQqXkF2GykOSyuIxLFvF/Ws/h9ZpN3uwIO9dHpOqea3U5gyPQ4tBPO93lr9p1b03e6xVDm+gfVc8Tzw3Maa7P035b65oZPelnQY3IFag5FVCuCULg03Js8pNMcP7gv6JdM6kU1kuOu38+69qKT/MCX/nPVPeDpZnJvNNe2+uVecVeXjMJBFusfaz93H/DHUpuaes20pjYs/hxmdiB7c1P6xBrIFAAIWFhdbf7777LmbOnGktWAA444wzEI/HsXbtWuuYxYsXw+PxDDqmtbUVDQ0N+71PPB5HMBgc9E9DQ+PI43DJAEDLAQ2NoxV6L6Ch8fFx2IJYd+/ejfvvvx8/+clPrLr29naUlZUNOq6goAButxvt7e3WMbW1tYOOMc9pb2/HuHHjhtzr7rvvxve///0h9Z4gEKnnL6enPHMBAKdXbrfqno5xUNolF1FGxM/mrbXqLr3vNqucNOMnu0QQa5vQupifR0IzYE/y72YGsYpnWPN32x6lja8W3PBPshYwq8Kmrs1fhbb5rH1aMmYXAOClXg6Yy4iv2qIs4kC+d/zjVt2nAxzYkvU+fbVmBOFsvIjOz2qV/cAQ7OpnS8a40xqsclOkFgDgEBp8yYscGE/TMOnnZ5Nbz4LWUCkww9VCW6ksGYFxIrjtGOa2N4f84mIOWs4Sn+c5dtJ+9WS4Iy+EWTsQStIAfPe6P1t13910vlXOc9L9r2k826qre56tDqbCL1LNX/e+bmqrHNu8nUrTmxj5QayHUwYAHy4HXFlJXFRAa3pNyRirvrubNc/2BbSm0ltYjesTQYem9iq2hFXLx6y9hG+iltxfXj3Zqvr+5zhr6g0TXgcA3Lv1U1ZdpJjmyudOfs+qe3oXy6OL99Cx1T4OMs3bxWs7EiQtsbleAWDlHp6THsVdPDCLF9/S+dymzQ/MAgDYU3x+rIHXpE3JEZuwQp5YQprDVwsquE17OADL10NtsotMqrEifu0ExtGYukNinYisrX1T6F6LTmXrw6oWXqde1acFpU1W3Zt5cwEM1vp3tuZbZU8btal9J1siwtNYNryWqzKoCvWWsR9VVzKfNZChStbQJ5RGMcrTCYkqIc9bSXa/durPrbob9hCpQDKcQMPQW40oHA17AV+bDQ6PDRv+Sha4B7/J1rE3lfaz/jVOfCLJK7zt9PyKN3NdrECsmTCpad8Ua9cYyyrXhZOJ77vKx+/tJ1893iqblv2B8SJbOeie2wdYk7/nrN8P6de8NSyD4mv4A2n1qbRmZC6K8HRhAXJTXxIQPOvZgl89rrI4u7nPpvUYAM5UcuDx7XOtOjMYP9vO11w1j/cd49u/ohoq9ic1/Xz9DG0YflD1vFW3ZB27SkXUdEkI7nijXGwyDNrLOAVRgZlN29R6A0BWGZsiiieoPYbIxOqI8V6roJXqHXX8Eenp43v2T6K+GsJaL8cpZy+1JcFiFX5FfOKMcTDvwWZk/qc18LfffjtsNttH/luzZs2gc1pbW3HmmWfi4osvxle+8pVBv+3P7GUYxqD6Dx5jBq18mMnsW9/6FgKBgPWvqalpv8dpaGj88xgOMgDQckBD41BiOMgBLQM0RjL+aQ38jTfeiEsvvfQjj5Ffya2trVi6dCkWLlyI3/72t4OOKy8vx6pVqwbV9fX1IZlMWl/W5eXl1he4ic5Oomv74Be7CY/HM8jMpqGh8clhOMgAQMsBDY1DieEgB7QM0BjJ+Kc38MXFxSguLj7wgQBaWlqwdOlSzJ8/Hw8++CDs9sEK/4ULF+LOO+9EW1sbKirIBLt8+XJ4PB7Mnz/fOubb3/42EokE3G63dUxlZeUQc9qBMDDWgE24L3xz0osAgK5U7n6P/06x6VrDAUquZd1WObCJxqFwO5tbemYILnAVtJgW9OXREsFhrFIhS/Ns4Ta6VrxFBk3x775O8zpcd/pYDh59dhuZwa85gzmO/6Nw15C+AWyuOWPyVqv8QoLOL3iPB8rTr1KTh9kUZJq2AaC4TrX5KZ4XzblcDs0g83HuJu6IiO1DUg1v66cEx76PXRfMNOj9k0TK5bHqWBG46nVy+cljfwMAmOriZ3d3z2Sr/OUNVwAAfjPnYavuV3uYC3hsLrkpfMbPdvjyeXzs8gEap789xQE2hSKFvImoCNYNjlNpnIW7jGnmTw+jFOrDWQYAgG2HH9fY6Pk73PzMXAOCu1cFQoan85yUfMT5brJF7xZuY/0BkUa8hdZ5bDy7ZsxaxanV43H63bmN56dptV3by64dzx/Ppv32FF3/3+s/a9WlPSJASokWu3Bxca8SeRI6af4lJvLvG3/PZv6cblpotiSPSelqGYBF5d5p/Az/tplc9XJFIJqrWPCbK873aCmv/ZRoc99MupdP8LhLV7tULo3/K3XTrLpbFrJs+9nbFDj+8lZ2F0CuklMicrRmLMvtZhc9M9dW8TIQnNj/t3MetV2s047jBHnBHupLQT3LQykbVRybFQgNAEZa8HyPpbmz5JVbrLpx1STYU6mhMuRoxXCWA6lswPAAiXx6bku2XGD91thAL9dB/Abi+bmVd6fMVZLMFu8mNRUr3+J8DMn17EZSn01z+d2TWTbYhQHBdC/N3S1cc1VOgfWRSVZdX+2zVnn+M7cAAIrX8ri6ROR309PkXuQ5jfOWbJn/mFU+8bZrAQDOCM+/Pn5dIn8DzflwlVjHhdw/Uw5k4ry/yVHBm5Neu9Kqe23R/Vb5zNkULLy6k90Yn5/9oFW+ai/lwtm2nDnT7UXCFa+Myhkfy+irZ7P74R/76d0s+e5RoMZcPM/IAD+biU/TOGTvFuQTPXxPZ5julfbyOPfM4L1UTL0OZJCqjMAPVZsdEa7UPYqbXrgCHex+4JAFsba2tmLJkiWoqanBvffei66uLrS3tw/6gl62bBmmT5+Oyy+/HOvXr8fLL7+M2267Dddccw1yc2lTfdlll8Hj8eDKK6/E5s2b8dRTT+Guu+76l9gnNDQ0Dh+0DNDQ0NByQEPj0OCQBbEuX74cu3btwq5du1BdXT3oN9NvzeFw4Pnnn8f111+Pk046CT6fD5dddplFLQUAeXl5WLFiBW644QYsWLAABQUFuPXWW3HrrbdCQ0Pj6IWWARoaGloOaGgcGtiMUZDGLBgMIi8vD+O/exeMfPaHGzObuEvPqGAXkikeTpFb6yI6hLluNrGcuPEzVjn+DJGqZoSLS+RkZkJJ9il+82b+TjI50QHArvhLJSOL6U7jGuBKyXUeqqZycIJIOZxi7YO/SUWwT+TzbcJc9MtzyUR1po/Nd6dsvtAqt69TbBKCJ96oIZNv/ivCVCTMPXl7qS2SvULy4cePozFJRnigcjew+do0N8Xz+Zrh8dx+Z4CuVTm/1aqbV9gMAPhpBTMEPTzA5tykCgO/a81ZVt3nZ64Z8vv6Pn6hLClhxpqYeqhvdTETQfMqPjZZQO2rfZrb2TdZ9ElF+w/ipvfRcwgLt5q4Yi/IxGJo+M5/IhAIWBonjU8WphyYf8md6DuW1nTJzC7r984eTomdo9iYYsIzo/CEDqs8q5DkxD82MZe4q4fXucnYFKrlNeEXfMDm+pQcwyaii5gV4dOTNlrlc3I3AACeDcyz6v72DrNX2OOKn3wcMzjlZ7E/StcqYrDws4hD/zThQtRP55eu4zntiA116Whaxv3MFCruecFOMbOa12n9PyiPQnYLj0PXAnFN5ebiDrAxWOZJmH4quf8l0jxOe3rYbSk6QDLW0c1rL+Ma+kormMDMPbF36HzTHRFg7nYA6FbtcxUxZYdrI7s65TbQsWGRaj5Swefnb1frvIqvH6tkd4OT5tQDANa+ON2qy2k0U9HHsP6vWg4cKpgyYMK37oLD60WiQD3roEh3P4fcTGLrefFni9hXby9NUE8fP9OBsTz/Ul56/p6gcJ0QMj+3ge7p7WNmouYlvC9JFNL1CzbznDcZVzz93A6Z58CcX7lbeW3GeJnAN5f69J1pL1h1d2w51yr7/0YXk7lOes7i+Z+1huRhkj3yEBsrqOhUHpOcjcJ9Ti3zNG+fEJ3N8siXRXuQMQW8NmfksVXmiTeOAwBkN/KzGZjCY+5pp76azxAA7MXse5LpojGVOVYchXTP785/zqq765GLrbLp0irdmt2CLz+lHtPAJBZSpePYLSmaoH1DsJvlhTOL22y00WC4+3k+mO7EktkvHY9h2y+/fUA5cFh54DU0NDQ0NDQ0NDQ0Ph4OGw/80QBbajAn+lfHUoawS7P5C/AvA/zV/ZXNXwIALK7kINB35jxhlS/Pp6DHTR2cfGJuMat1dmaRRnjCTCY2vqHyZat8dwNxiHc8w0Ec5leYK1doBHpEdtg+an/FW9wvd4A/3Xqm0xdwbg1r4cI78q3yLY9QdsHlX/pvq67zfeZw9islo6lFAIBwGbWl/IucLe67YzmA5qr1FBCYSvHne56fv7SL3fTV22pjlUHaKzQWKvbPdhzz4q49ljlu/9BPAaMPvMqc2fap6jkKDXylk5/jTes/DwDIhFnrnxTkrFsC1OfWALfpHTtr23894f8AAH95ZZFV55CxMHV0rXiB4JgVlpikWln9k8WXtsr+amrwAJH57iB5XzU+PkKVNhiVpF3yudgSZRPqDFMTJbW0Pe8z08U/ykm95YhIzTE/Q183PWPJQTwoB8RqlaE0LCxpqhgY4LXxpQLOrHjFZlpn+T5eWyvOu88qn/O/3wAAhFtYTbbiAmb7WLyGfu87lvt87OQGq7yuiSxM3UkRjNvDa8ZcPtmc3BjxILVVasE2pVj1nKVEU89coRX3CxV7hC6a8omslr08Zut3kmy0ufj6nnpW6dkLVQbJfNZymTFj/iKOJOvt5jHJUdWefr5mdhMfGyugYzNNgrxAauHU7cNVwkop3isZN7VfZrg2tYUAsL6RNO+JEsHhr9b/wfI/a3w8ZHyUiXXybFKtX1b5vvXbQ02U4bQzwnuBwCSZb4HmbMlGrgtMGPoecDC3hCUPALZUp3y8trwi94ExmWRTYDKvQ1NjmxE7tlgpr6NZU/cBAOrAe4kfn/qoVS530Lv1ir9zzhd7VPC8q7h5yRPv2sEWdysbuwjOzNvALzxT258UyuKoymVjS4nAWkE0keujmx2Tz+aNv75xklXO2UPnyXVki/O1sqnLGHCIXDBZPEAuUzaLJVU4nhbyT+tPs+p+cTnLyNNUQOyEx/+N2zmZrbSBCC1+3zreNwS6mFHElJHFx3DQfFLsi4JuUuFL7nrPWFL7pzbz4KXFc/goaA28hoaGhoaGhoaGxjCC3sBraGhoaGhoaGhoDCOMKhcaby/g7uFvll++8TkAwHc+zYEPOTlsng7tIDvHvnwRySbw3UpK8Xtz7HNWXWuYzSBXTSDz93v97Jrxo0YOqoz8gkzNQcF//t1Tn6a2/ZiDZWUQayJXcbJHROpmkZrc30H2pvBrwkZTyce6lZfJl3Z80apL+YUpWPmJGGJm/GbR/wIATvexmXq14Cl957g/AAAu3MZpnF+Z8Xer/OsA9fPejtP5nmV8T1+7Cvpq5iDCU8BZ+q6YRAk+SsaznXFyHpm1JMfsuVPqrHJVQT8AoM3O9reX9jGXtF3xsEb38vPaGuJAojv95K5TOpXNZ6eUsyvV08+dCABwhdg+l9XFfeqdTvWSk9uMC5ZuNX4V7zeceOCHO+aftxm1RbTONwXY3cOziU3G+btprkeLee05Y8IW20ELRAZcDoI61BMUKblFyvBQBV036Rf86YpLPGsnu9BULmN5ZaYh78uwHfu5cK1Vvvhccgl8ei9zu9/exmsOEymYXHh64f3tnH4+W7mc1F3H3POzfsYmd6cSjTGRgyKZQ/0zzd0AkBZB/1EV3Olr5d8LX+Ux7ZqrXNEmss3Y3s7ne5rUWMzgfAzRsXz+6bOJgODl92bx9TfRvaLFbOYu4mUMl+K6NmUpAMQLee0XbRfuOArJLLso03k1K/i4tE+4CQyQi1IoIl0MhJxQfPwZJ9f9+KskQyMDaVz80yG31/iEkfJnYPdl0NhD7/YHUydavzWvJZmQnsFz0ukROUrU/41jRYIoEYHo7CPZ4O3jtZ/08/xwD9AVIiI3wsA46VpCL4NQWrjQHEMv7mA/100ZwwGfLQNqrnu5nT/Ztcwq//vElwBwoDowWHaFVV6VwjH9Vl1sA0fB+pUrob+dTxqoEvsS5ULn7uPrnz+PAvDLPewau6J9qlU23+Ezsji/Ru10DoBvTNJz8HUKuSs88QKKEn/eyfVW3doGzqFRfwW54Y5f8WWrrj9MMj4h3BTva+Jx+ocKojVyeW3/1yQOeL3+jcsBAB4hRMvf42c/MIZ+CGWYUMPDnr3AZBq/jCAJibaRq55rKhOgGJGD86HRGngNDQ0NDQ0NDQ2NYYRRpYEPTsigmJkC4YzQ11DFk/wlnfSz9ieklDrr1k6w6n6Y22yVzUyt23eyFs8mNK4PvHcOXTObv7YKt/D97SquylvKEVKPtS0AMFgD3nUMl9NFpN1xvM1fkFld/FVsBt9JbbBd0ky2D6WFc/fx72l12WgFH/dEz7EAgF9EWVvdFMy3yufUUKcCT/A4zHidNXexErpWVjN/L6Y4PszKbJcUVHLpbtae/eVl+kLO6uY2vTlBZcvjeDxMmccaCZNeUtJ+9qwvtcrf+jQFI//OdbJVF4zys39xPWkxp05i7cDLrZyabv5p2wAA73tZo5DTIMZxLKkrjR6eW2b//axksAIbTUpRjUOPPFcMrXGaX2U+1uxuK+BnYGYkNOy8ELObhwatOWazdinSzxr8TANpYtJunhNtiySdGWm7j6lhebLrLzS/ouU8zwcM1gSZq6/Azlq4u+rO5HvuIAuW1Ky9vGuOVU7n0A85OwQNpKA/jPpo8U97h61zmXy+lqml8+8TXHNTqB/BHCGPhAUhr15Z9ISqKJEtgudmkuwzwnxOVLSpaAoFg51QxpGzWwMcTPy1MsrKujKP16E9RddyCIuJMyaySE+l+7v7uU02ER2Yt1tpvwTDsjMkMsXm07NN5PM4SAq49hPo/pJyzyOCFOOXkEquwMUnmbS+wdSHmXQ0Pkl4uhxweB3wbKc10ziRX0gm6+DkGqaNvaP2Gav8uZX0bvv0AiZQaI/xu3HDC2TplVp3iXAFzQ+Z9TRnD8+lgJeu5ahib4AiP2ln55Xx+6jay6rdU8bQXuR/OzkItNTDsm2RisaP17KpN3cDv5vcKjC318Hv3UWn8WZldQsFx4bq2Uru4svDVamsgiKw++eVq/FBvNDKtLsrd04BALxVN9eq+86XOfD2rXxSsffEeSHtEpmvLxm7DgBwW+Fuqy46jvv3PbVxqq3kgNJgnN7xgSSPt1vweD++UW22YvzsblnLngV565RsEfuOWCHLDm+v2ut08DjE8/laResUDTgbPpFSVkzvKp6D6fhQeuH9QWvgNTQ0NDQ0NDQ0NIYR9AZeQ0NDQ0NDQ0NDYxhhVLnQuPvsyP0cm6AadpMptmo5mztksNLcheRvs2Yr2ztebOXseaYLjd3LZm57gM1SZvBCVrvgAheuEokcqs9+gU1EPaByXASKycyCOQVkqooVsMnZJbiofZ1klvUEuE2BCdymvPPJzeSpaY9YdRcYl3GbUjQlKr1svjNNXYbguc5/h91NniokrvTUaewKlGxlM//Jx5G7ybtltVZdqo/PT0ygNuesEfzOIo7MDO6zibq08laIjGMz9I/e4gDh7uOJKP930x+26m5wft4qv9hN/lGGwX1aXMNBqi+0zwUARFMcrZJK8zhv7aa5ky5lW1p/Ni8neyf1pXiD6IcymfZPFLy1yiKYOUjeV42Pj+fWzsWzFxH37yw3u71ccQo/v+1baZ2HOCYKWW08V0o2kNm1P8gm52WXbLDK76+ZC2Cwa4Wvlc2iaeVW9th4zgsx9VTKJ2FvZFNqQ5LL1+4md5mU8EeJt/M6sysu9UwWm4SzGrlP4Xz6XWYz9Jdx4FREBXEnm1geZfL5Wu5ikgmRFN/zhum0zm4t4BwRk7qvtcquMI1ZYJLgce8VAaFRap8h3PxcY1iOmIG7g1Ap/6C2vHPq/1g1v5xzAgDgbZFFuS3ALg5uJ/UpvimfL2Pj+yf9NCdyG3mc3P28zj29Kkh1Js+dhOC/jpUOdVPM3szXNxx0/7dnP2nVrVDjEBZ5AzQOHWxpep+Ybk62Ina9cChXuPpmdtX64js3W2WVBBxP2dm3tbyS3VmcavrK7L6GXTx/c/qLOZfiqYScMrrA5ROZm/6BNUsAAHNn8/5FBuCfkkN7kfVtwp13Fcump8bPBwDYs1kgSafN8FjlyhlmGXV+8XqrfHzeHgDAtSfus+q+0znXKhcrf5rGKAdvTnqd8lY8ufDXVl3HBh7T/F3Uf+lq9u23Py0apfj2RabTqYWcmEO6zpjw2XivszlIgqI/xoO7oIw451c2zrTqdm1gF+ki5eo2IFxc4k6+ZmqcGjUxeBkfr/eCTdRmGewbz+fnHJxLsmOCcM9qfoteMjEeuoPeD4yKDbyhfBkz8RhSYZFqN0qjlBJ+6+kET+BkODHoOACDzg8OpIf8DuFraSXlEP5SabGBTyfM34f6P8uEHpkoT5B0JG71xWqTSBCTSqnkCcJ/My3aZLZ/YCAzpA4A0soHMyVoUTIqItrIyHGSbTXbxm3KiCQRCXMcB/3O59vULkcysRjCFdT0D7clZZ/s6jpihySGMRai+pB9//1MZhJD6hI+vpY1N+TYxIa+XDNR4asWFctJJZyQ42S2Py2SUWTUs8nE1BgbQ+eCxicDSw7EYgip+R9080Qz5ylAKe2Bwc9cPstUks6TvoqJ0NDzjUHpsUVZrQVThsi6TIyvGRbr1JRHaUPKBiF7kmpNCCf4dFz4u6u1IhNOmfIEADKK2com5EUmI2WPap9Y27EQbXKDThGHE+M2mXJskAwT/qVm+zNC7qbdfL4cn4/CQJqvH1drf9DaFbInrZLJpAe1U1xMPcZUUihmUnIhq6RLCTGO4nzZV+t3cayh2iX7Zm7cIyGq03Lg0MAc17R6f5pJguS7yVzzg95XYpmZckC+ewbNtbi5r5AZiOQHnKqS7zPxToBak+baonvRNc25DbA8AICwmktyPdvi8n2rriU0CoP2GLGh8y0i5mc0pda5Y+g6A4CYi35PiDExxy8kZNgg2ZAwk5fxPTNRsc7Uu1X2Kenh3w8kGyx5Kc43ZbSUm1KGm89WJlKSz9kWU/JUbuAhZJuSY+b74YPXN/s3eF+h3hWiO+b+7kBywGaMAknR3NyMmpqaAx+ooXGE0dTUhOrq6iPdjBEJLQc0hgu0HDg00DJAYzjhQHJgVGzgM5kMWltbkZOTA5vtXzdRBoNB1NTUoKmpCbm5uQc+YQRDjwXhkxoHwzAwMDCAyspK2O06NOVQQMuBTxZ6HBhaDgwPaBnwyUOPBeNwy4FR4UJjt9s/UW1Gbm7uqJ+oJvRYED6JccjLyzvwQRr/MrQcODTQ48DQcuDohpYBhw56LBiHSw7oT3wNDQ0NDQ0NDQ2NYQS9gdfQ0NDQ0NDQ0NAYRtAb+H8CHo8H3/ve9+DxeA588AiHHguCHofRB/3MCXocGHosRhf082bosWAc7rEYFUGsGhoaGhoaGhoaGiMFWgOvoaGhoaGhoaGhMYygN/AaGhoaGhoaGhoawwh6A6+hoaGhoaGhoaExjKA38BoaGhoaGhoaGhrDCHoD/wE0NDTg6quvxrhx4+Dz+TBhwgR873vfQyKRGHTcvn37cN5558Hv96O4uBg333zzkGPq6uqwePFi+Hw+VFVV4Y477sBIiBl+4IEHMG7cOHi9XsyfPx9vvvnmkW7SJ4q7774bxx57LHJyclBaWooLL7wQO3bsGHSMYRi4/fbbUVlZCZ/PhyVLlmDLli2DjonH47jppptQXFwMv9+P888/H83NzYezKxr/IrQcODC0HNByYKRDy4GPhpYBR1gGGBqD8OKLLxpXXnml8Y9//MPYvXu38cwzzxilpaXG17/+deuYVCplzJw501i6dKmxbt06Y8WKFUZlZaVx4403WscEAgGjrKzMuPTSS426ujrjiSeeMHJycox77733SHTrE8Ojjz5quFwu43e/+52xdetW42tf+5rh9/uNxsbGI920TwxnnHGG8eCDDxqbN282NmzYYJxzzjnGmDFjjFAoZB1zzz33GDk5OcYTTzxh1NXVGZdccolRUVFhBINB65hrr73WqKqqMlasWGGsW7fOWLp0qTFnzhwjlUodiW5p/BPQcuCjoeUAQcuBkQ0tBz4cWgYQjqQM0Bv4g8B///d/G+PGjbP+fuGFFwy73W60tLRYdY888ojh8XiMQCBgGIZhPPDAA0ZeXp4Ri8WsY+6++26jsrLSyGQyh6/xnzCOO+4449prrx1UN3XqVOOb3/zmEWrRoUdnZ6cBwHj99dcNwzCMTCZjlJeXG/fcc491TCwWM/Ly8oxf//rXhmEYRn9/v+FyuYxHH33UOqalpcWw2+3GSy+9dHg7oPGJQMsBhpYDWg6MVmg5QNAy4MjLAO1CcxAIBAIoLCy0/n733Xcxc+ZMVFZWWnVnnHEG4vE41q5dax2zePHiQYT+Z5xxBlpbW9HQ0HDY2v5JIpFIYO3atVi2bNmg+mXLluGdd945Qq069AgEAgBgzYG9e/eivb190Dh4PB4sXrzYGoe1a9cimUwOOqayshIzZ84c0WM1kqHlAEHLAS0HRjO0HNAy4GiRAXoDfwDs3r0b999/P6699lqrrr29HWVlZYOOKygogNvtRnt7+4ceY/5tHjPc0N3djXQ6vd9+Ddc+HQiGYeDWW2/FySefjJkzZwLg5/dR49De3g63242CgoIPPUZj+EDLAYaWA1oOjFZoOUDQMuDokAGjZgN/++23w2azfeS/NWvWDDqntbUVZ555Ji6++GJ85StfGfSbzWYbcg/DMAbVf/AYQwWs7O/c4YT99Wu49+nDcOONN2LTpk145JFHhvz2r4zDSB6r4QAtBz45aDlA0HJg+EHLgU8GWgYQjpQMcH6ss4cRbrzxRlx66aUfeUxtba1Vbm1txdKlS7Fw4UL89re/HXRceXk5Vq1aNaiur68PyWTS+hIrLy8f8nXV2dkJYOjX2nBBcXExHA7Hfvs1XPv0Ubjpppvw97//HW+88Qaqq6ut+vLycgD0ZV1RUWHVy3EoLy9HIpFAX1/foC/vzs5OnHjiiYepBxofhJYDHx9aDhC0HBi+0HLg40HLAMIRlwEfy4N+hKK5udmYNGmScemll+43StgMWmltbbXqHn300SFBK/n5+UY8HreOueeee4Z10IphUODKddddN6hu2rRpIypwJZPJGDfccINRWVlp1NfX7/f38vJy40c/+pFVF4/H9xu48thjj1nHtLa26uC1YQQtBz4cWg5oOTBaoOXA/qFlwJGXAXoD/wG0tLQYEydONE499VSjubnZaGtrs/6ZMGmjTjvtNGPdunXGypUrjerq6kG0Uf39/UZZWZnx+c9/3qirqzOefPJJIzc3d1jTRhkGU0f94Q9/MLZu3Wrccsstht/vNxoaGo500z4xXHfddUZeXp7x2muvDXr+kUjEOuaee+4x8vLyjCeffNKoq6szPv/5z++XOqq6utpYuXKlsW7dOuPUU0/V9HHDBFoOfDS0HCBoOTCyoeXAh0PLAMKRlAF6A/8BPPjggwaA/f6TaGxsNM455xzD5/MZhYWFxo033jiIIsowDGPTpk3GokWLDI/HY5SXlxu33377sP3alvjlL39pjB071nC73cYxxxxjUSqNFHzY83/wwQetYzKZjPG9733PKC8vNzwej3HKKacYdXV1g64TjUaNG2+80SgsLDR8Pp9x7rnnGvv27TvMvdH4V6DlwIGh5YCWAyMdWg58NLQMOLIywKYaqaGhoaGhoaGhoaExDDBqWGg0NDQ0NDQ0NDQ0RgL0Bl5DQ0NDQ0NDQ0NjGEFv4DU0NDQ0NDQ0NDSGEfQGXkNDQ0NDQ0NDQ2MYQW/gNTQ0NDQ0NDQ0NIYR9AZeQ0NDQ0NDQ0NDYxhBb+A1NDQ0NDQ0NDQ0hhH0Bl5DQ0NDQ0NDQ0NjGEFv4DU0NDQ0NDQ0NDSGEfQGXkNDQ0NDQ0NDQ2MYQW/gNTQ0NDQ0NDQ0NIYR9AZeQ0NDQ0NDQ0NDYxjh/wMBAepRh1w53QAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "borg_dirname = '/data101/bartlett/fsigma8/borg_velocity/velmass_ics'\n", + "ini_name = borg_dirname + '/ini_file.ini'\n", + "field_type = 'delta'\n", + "nframe = 100\n", + "iter_min = 1000\n", + "iter_max = 1767\n", + "cut_field = False\n", + "\n", + "true_delta = analysis.crop_velmass_to_borg(ini_name, field_type)\n", + "if cut_field:\n", + " true_delta, _ = analysis.crop_field(ini_name, true_delta)\n", + "borg_mean, borg_std = analysis.compute_ensemble_mean_field(ini_name, borg_dirname, nframe, iter_max, iter_min, cut_field=cut_field)\n", + "\n", + "fig, axs = plt.subplots(3, 3, figsize=(8,7))\n", + "\n", + "# Parameter for uncut box\n", + "Rmax = analysis.get_borg_Rmax(ini_name)\n", + "L0 = analysis.get_borg_Lbox(ini_name)\n", + "N0 = analysis.get_borg_N(ini_name)\n", + "corner0 = analysis.get_borg_corner(ini_name)\n", + "\n", + "x = np.linspace(corner0, corner0+L0, N0)\n", + "if cut_field:\n", + " m = np.abs(x) < Rmax\n", + " x = x[m]\n", + "\n", + "for i, field in enumerate([np.log10(2+true_delta), np.log10(2+borg_mean), borg_std]):\n", + " if i == 0:\n", + " vmin = field.min()\n", + " vmax = field.max()\n", + " N = field.shape[0]\n", + " j = N//2\n", + " axs[i,0].pcolor(x, x, field[j], vmin=vmin, vmax=vmax)\n", + " axs[i,1].pcolor(x, x, field[:,j,:], vmin=vmin, vmax=vmax)\n", + " axs[i,2].pcolor(x, x, field[:,:,j], vmin=vmin, vmax=vmax)\n", + " for ax in axs[i,:]:\n", + " circle = plt.Circle((0, 0), Rmax, color='red', fill=False, linestyle='dotted', lw=1.5)\n", + " xlim = ax.get_xlim()\n", + " ylim = ax.get_ylim()\n", + " ax.add_patch(circle)\n", + " ax.set_xlim(xlim)\n", + " ax.set_ylim(ylim)\n", + "\n", + " for ax in axs[i,:]:\n", + " ax.set_aspect('equal')\n", + "\n", + "axs[0,1].set_title('Truth')\n", + "axs[1,1].set_title('Ensemble Mean')\n", + "axs[2,1].set_title('Ensemble Std')\n", + "\n", + "fig.tight_layout()\n", + "\n", + "savename = f'../figs/field_slice_velmass_{field_type}'\n", + "if cut_field:\n", + " savename += '_cropped'\n", + "fig.savefig(f'{savename}.png', bbox_inches='tight', facecolor='white')" + ] + }, + { + "cell_type": "markdown", + "id": "1f5f59bf-24f1-4b31-a0e7-cdb5a12cdb02", + "metadata": {}, + "source": [ + "# Power and Cross Spectra" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "ac6a9840-dcfc-4d16-98e4-39740656810b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BOXSIZE 198.41269841269843\n", + "\n", + "Computing power spectrum of the field...\n", + "Time to complete loop = 0.00\n", + "Time taken = 0.00 seconds\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 101/101 [00:09<00:00, 11.03it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "borg_dirname = '/data101/bartlett/fsigma8/borg_velocity/velmass_ics'\n", + "ini_name = borg_dirname + '/ini_file.ini'\n", + "field_type = 'delta'\n", + "# field_type = 'ics'\n", + "nframe = 100\n", + "iter_min = 0\n", + "iter_max = 500 #1767\n", + "cut_field = True\n", + "\n", + "k, Pk_true, all_pk, all_r = analysis.get_spectra(ini_name, borg_dirname, nframe, iter_max, iter_min, which_field=field_type, cut_field=cut_field, mock_type='velmass')\n", + "all_mcmc = analysis.get_mcmc_steps(borg_dirname, nframe, iter_max, iter_min=iter_min)\n", + "\n", + "# Get axis range\n", + "if field_type == 'delta':\n", + " ymin = 1e1\n", + " ymax = None\n", + "else:\n", + " ymin = None\n", + " ymax = None\n", + "\n", + "# Normalize the index for coloring\n", + "norm = plt.Normalize(all_mcmc[0], all_mcmc[-1])\n", + "cmap = plt.cm.spring # Choose a colormap\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(15,4))\n", + "\n", + "# Plot Pk and r\n", + "for i in range(all_pk.shape[0]):\n", + " axs[0].loglog(k, all_pk[i, :], color=cmap(norm(all_mcmc[i])))\n", + " axs[1].semilogx(k, all_r[i, :], color=cmap(norm(all_mcmc[i])))\n", + "axs[0].loglog(k, Pk_true, color='k')\n", + "for i in [-1, 0, 1]:\n", + " axs[1].axhline(i, color='k')\n", + "\n", + "sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)\n", + "sm.set_array([])\n", + "for ax in axs:\n", + " cbar = plt.colorbar(sm, ax=ax)\n", + " cbar.set_label('Step')\n", + " ax.set_title(field_type)\n", + " ax.set_xlabel(r'$k$')\n", + "axs[0].set_ylim(ymin, ymax)\n", + "axs[0].set_ylabel(r'$P(k)$')\n", + "axs[1].set_ylabel(r'$r(k)$')\n", + "fig.tight_layout()\n", + "savename = f'../figs/pk_velmass_{field_type}'\n", + "if cut_field:\n", + " savename += '_cropped'\n", + "# fig.savefig(f'{savename}.png', bbox_inches='tight', facecolor='white')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "617d573a-03d2-4bea-839c-2b283ea39ac8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "179592db-996d-4292-9350-3a0711048cb0", + "metadata": {}, + "source": [ + "# TO DO\n", + "\n", + "* Looks like VELMASS ICs are after P(k) applied - extract white noise field" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c0c7b33-89a1-4926-8354-1e8f475d756d", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "borg_new", + "language": "python", + "name": "borg_new" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/analysis.py b/notebooks/analysis.py new file mode 100644 index 0000000..8a2529c --- /dev/null +++ b/notebooks/analysis.py @@ -0,0 +1,420 @@ +import numpy as np +import glob +import configparser +import h5py as h5 +import ast +import Pk_library as PKL +import os +from tqdm import tqdm +import sys +from contextlib import contextmanager + +@contextmanager +def suppress_stdout(): + with open(os.devnull, 'w') as devnull: + old_stdout = sys.stdout + sys.stdout = devnull + try: + yield + finally: + sys.stdout = old_stdout + +def get_mcmc_steps(dirname, nframe, iter_max, iter_min=0): + """ + Obtain evenly-spaced sample of MCMC steps to make movie from + """ + all_mcmc = glob.glob(dirname + '/mcmc_*.h5') + x = [m[len(dirname + '/mcmc_'):-3] for m in all_mcmc] + all_mcmc = np.sort([int(m[len(dirname + '/mcmc_'):-3]) for m in all_mcmc]) + if iter_max >= 0: + all_mcmc = all_mcmc[all_mcmc <= iter_max] + all_mcmc = all_mcmc[all_mcmc >= iter_min] + if nframe > 0: + max_out = max(all_mcmc) + min_out = min(all_mcmc) + step = max(int((max_out - min_out+1) / nframe), 1) + all_mcmc = all_mcmc[::step] + if max_out not in all_mcmc: + all_mcmc = np.concatenate([all_mcmc, [max_out]]) + return all_mcmc + +def load_param_samples(ini_name, dirname, nframe, iter_max, iter_min): + + config = configparser.ConfigParser() + config.read(ini_name) + to_sample = [] + for k,v in config['block_loop'].items(): + if v.strip() == 'false': + i = k.index('_sampler') + if k[:i] not in ['hades', 'bias', 'nmean']: + to_sample.append(k[:i]) + + print("TO SAMPLE", to_sample) + nsamp = int(config['run']['nsamp']) + new_to_sample = [] + for s in to_sample: + if s in ['omega_m', 'sigma8', 'sig_v']: + new_to_sample.append(s) + elif s == 'bulk_flow': + for d in ['_x', '_y', '_z']: + new_to_sample.append(f'{s}{d}') + else: + for i in range(nsamp): + new_to_sample.append(f'{s}{i}') + + # This is desired list to sample + to_sample = new_to_sample + + # Which steps to use + all_mcmc = get_mcmc_steps(dirname, nframe, iter_max, iter_min=iter_min) + + sampler = config['sampling']['algorithm'].lower() + samples = np.empty((len(to_sample),len(all_mcmc))) + + print('MY SAMPLER IS', sampler) + + if sampler == 'slice': + + for i in tqdm(range(len(all_mcmc))): + with h5.File(f'{dirname}/mcmc_{all_mcmc[i]}.h5', 'r') as f: + for j, s in enumerate(to_sample): + if 'model_params_' + s in f['scalars'].keys(): + samples[j,i] = f['scalars/model_params_' + s][:][0] + elif 'model_params_cosmology.' + s in f['scalars'].keys(): + samples[j,i] = f['scalars/model_params_cosmology.' + s][:][0] + elif s == 'sig_v': + samples[j,i] = float(config['model'][s]) + elif s.startswith('bulk_flow'): + if s[-1] == 'x': + samples[j,i] = np.array(ast.literal_eval(config['model']['bulk_flow']))[0] + elif s[-1] == 'y': + samples[j,i] = np.array(ast.literal_eval(config['model']['bulk_flow']))[1] + elif s[-1] == 'z': + samples[j,i] = np.array(ast.literal_eval(config['model']['bulk_flow']))[2] + else: + raise NotImplementedError + else: + if s in config[f'cosmology'].keys(): + samples[j,i] = float(config['cosmology'][s]) + else: + print("NOT THERE") + samples[j,i] = float(config[f'sample_{s[-1]}'][s[:-1]]) + + elif sampler in ['hmc', 'mvslice', 'transformedblackjax', 'blackjax']: + + if sampler in ['hmc', 'transformedblackjax']: + key_name = 'attributes' + key_name = 'model_params' + elif sampler in ['mvslice', 'blackjax']: + key_name = 'model_paramsattributes' + + # Get order in which model parameters are stored + if os.path.isfile(f'{dirname}/model_params.txt'): + with open(f'{dirname}/model_params.txt', 'r') as file: + model_params = [line.strip() for line in file] + else: + model_params = [] + + print(model_params) + + for i in tqdm(range(len(all_mcmc))): + with h5.File(f'{dirname}/mcmc_{all_mcmc[i]}.h5', 'r') as f: + if key_name in f['scalars'].keys(): + data = f[f'scalars/{key_name}'][:] + else: + data = None + for j, s in enumerate(to_sample): + if s in model_params: + samples[j,i] = data[model_params.index(s)] + elif 'model_params_cosmology.' + s in f['scalars'].keys(): + samples[j,i] = f['scalars/model_params_cosmology.' + s][:][0] + elif s == 'sig_v': + samples[j,i] = float(config['model'][s]) + elif s in config[f'cosmology'].keys(): + samples[j,i] = float(config['cosmology'][s]) + elif s.startswith('bulk_flow'): + idx = {'x':0, 'y':1, 'z':2} + idx = idx[s[-1]] + samples[j,i] = np.array(ast.literal_eval(config['model']['bulk_flow']))[idx] + else: + samples[j,i] = float(config[f'sample_{s[-1]}'][s[:-1]]) + else: + raise NotImplementedError + + return to_sample, all_mcmc, samples + + +def get_truths(ini_name, to_sample): + + config = configparser.ConfigParser() + config.read(ini_name) + + truths = [None] * len(to_sample) + + for i, s in enumerate(to_sample): + if s in config[f'cosmology'].keys(): + truths[i] = float(config['cosmology'][s]) + elif s == 'sig_v': + truths[i] = float(config['model'][s]) + elif s.startswith('bulk_flow'): + idx = {'x':0, 'y':1, 'z':2} + idx = idx[s[-1]] + truths[i] = np.array(ast.literal_eval(config['model']['bulk_flow']))[idx] + else: + truths[i] = float(config[f'sample_{s[-1]}'][s[:-1]]) + + return truths + + +def crop_field(ini_name, field): + + config = configparser.ConfigParser() + config.read(ini_name) + Rmax = float(config['mock']['R_max']) + xmin = float(config['system']['corner0']) + L = float(config['system']['L0']) + N = int(config['system']['N0']) + x = np.linspace(xmin, xmin+L, N) + m = np.abs(x) < Rmax + L = x[m].max() - x[m].min() + + return field[m][:, m][:, :, m], L + + +def compute_ensemble_mean_field(ini_name, dirname, nframe, iter_max, iter_min, cut_field=True): + """ + Compute the mean and std deviation of the inferred density field + """ + + print('Computing ensemble mean field') + + # Which steps to use + all_mcmc = get_mcmc_steps(dirname, nframe, iter_max, iter_min=iter_min) + + #COMPUTE THE MEAN-DENSITY FIELD + for i in tqdm(range(len(all_mcmc))): + idx = all_mcmc[i] + with h5.File(dirname + "/mcmc_%d.h5" % idx,'r') as mcmc_file: + temp_field = np.array(mcmc_file['scalars/BORG_final_density'][...],dtype=np.float64) + if i == 0: + mean_field = np.array(np.full(temp_field.shape,0),dtype=np.float64) + std_field = np.array(np.full(temp_field.shape,0),dtype=np.float64) + mean_field += temp_field + std_field += temp_field*temp_field + mean_field = mean_field/np.float64(len(all_mcmc)) + std_field = std_field/np.float64(len(all_mcmc)) # < delta^2 > + std_field = np.sqrt(std_field - mean_field **2) # < delta^2 > - < delta >^2 + + # Cut the density field if needed + if cut_field: + mean_field, _ = crop_field(ini_name, mean_field) + std_field, _ = crop_field(ini_name, std_field) + + return mean_field, std_field + + +def get_mock_field(ini_name, dirname, which_field='delta', cut_field=True): + with h5.File(f'{dirname}/mock_data.h5', 'r') as f: + if which_field == 'delta': + dens = f['scalars/BORG_final_density'][:] + elif which_field == 'ics': + dens = f['scalars/s_field'][:] + if cut_field: + dens, L = crop_field(ini_name, dens) + else: + config = configparser.ConfigParser() + config.read(ini_name) + L = float(config['system']['L0']) + return dens, L + + +def get_velmass_field(ini_file, field_type): + """ + Load the true field from the Velmass directory. + Uses the ini file given in dirname + field_type can be one of 'delta', 'vx', 'vy', 'vz', 'ics' + """ + config = configparser.ConfigParser() + config.read(ini_file) + dirname = config['mock']['velmass_dirname'] + if field_type == 'ics': + f = np.load('/data101/bartlett/fsigma8/VELMASS/velmass_density.npy') + else: + if field_type == 'delta': + key = 'd' + else: + key = field_type + f = np.load(dirname + '/../density.npz')[key] + if field_type == 'delta': + f = f / np.mean(f) - 1 + return f + + +def get_velmass_Lbox(ini_file): + """ + Load the true box length from the Velmass directory. + Uses the ini file given in dirname + """ + config = configparser.ConfigParser() + config.read(ini_file) + velmass_dirname = config['mock']['velmass_dirname'] + # Get box size + with open(velmass_dirname + '/auto-rockstar.cfg') as f: + data = [r for r in f] + Lbox = [r for r in data if r.startswith('BOX_SIZE')][0].strip() + Lbox = float(Lbox.split('=')[1]) + return Lbox + + +def get_borg_Lbox(ini_file): + """ + Load the box length used by BORG + Uses the ini file given in dirname + """ + config = configparser.ConfigParser() + config.read(ini_file) + Lbox = float(config['system']['L0']) + return Lbox + + +def get_borg_N(ini_file): + """ + Load the box length used by BORG + Uses the ini file given in dirname + """ + config = configparser.ConfigParser() + config.read(ini_file) + N = int(config['system']['N0']) + return N + + +def get_borg_Rmax(ini_file): + """ + Load the Rmax used by BORG + Uses the ini file given in dirname + """ + config = configparser.ConfigParser() + config.read(ini_file) + R_max = float(config['mock']['R_max']) + return R_max + + +def get_borg_corner(ini_file): + """ + Load the corner used by BORG + Uses the ini file given in dirname + """ + config = configparser.ConfigParser() + config.read(ini_file) + corn = float(config['system']['corner0']) + return corn + + +def crop_velmass_to_borg(ini_file, field_type): + """ + Load the true field from the Velmass directory. + Then crop the field to only contain the region used by BORG + Uses the ini file given in dirname + field_type can be one of 'delta', 'vx', 'vy', 'vz', or 'ics' + """ + true_field = get_velmass_field(ini_file, field_type) + Lbox_true = get_velmass_Lbox(ini_file) + Lbox_borg = get_borg_Lbox(ini_file) + N = true_field.shape[0] + imin = int((1 - Lbox_borg / Lbox_true) * N / 2) + imax = int((1 + Lbox_borg / Lbox_true) * N / 2) + true_field = true_field[imin:imax,imin:imax,imin:imax] + return true_field + + +def get_spectra(ini_name, dirname, nframe, iter_max, iter_min, which_field='delta', cut_field=True, mock_type='borg'): + + # Which steps to use + all_mcmc = get_mcmc_steps(dirname, nframe, iter_max, iter_min=iter_min) + + if which_field == 'delta': + MAS = "CIC" + elif which_field == 'ics': + MAS = None + else: + raise NotImplementedError + + # Compute original power spectrum + if mock_type == 'borg': + delta1, boxsize = get_mock_field(ini_name, dirname, which_field=which_field, cut_field=cut_field) + elif mock_type == 'velmass': + delta1 = crop_velmass_to_borg(ini_name, which_field) + if cut_field: + delta1, boxsize = crop_field(ini_name, delta1) + else: + boxsize = get_borg_Lbox(ini_name) + else: + raise NotImplementedError + print("BOXSIZE", boxsize) + Pk = PKL.Pk(delta1.astype(np.float32), boxsize, axis=0, MAS=MAS, threads=1, verbose=True) + k = Pk.k3D + Pk_true = Pk.Pk[:,0] + + # Get other spectra + all_pk = np.zeros((len(all_mcmc), len(k))) + all_r = np.zeros((len(all_mcmc), len(k))) + for i in tqdm(range(len(all_mcmc))): + idx = all_mcmc[i] + with h5.File(dirname + "/mcmc_%d.h5" % idx,'r') as mcmc_file: + if which_field == 'delta': + delta2= np.array(mcmc_file['scalars/BORG_final_density'][...],dtype=np.float64) + elif which_field == 'ics': + delta2 = np.array(mcmc_file['scalars/s_field'][...],dtype=np.float64) + else: + raise NotImplementedError + if cut_field: + delta2, _ = crop_field(ini_name, delta2) + with suppress_stdout(): + Pk = PKL.XPk([delta1.astype(np.float32),delta2.astype(np.float32)], boxsize, axis=0, MAS=[MAS, MAS], threads=1) + all_pk[i,:] = Pk.Pk[:,0,1] #monopole of field 2 + all_r[i,:] = Pk.XPk[:,0,0] / np.sqrt(Pk.Pk[:,0,1] * Pk.Pk[:,0,0]) + + return k, Pk_true, all_pk, all_r + + +def get_both_fields(ini_name, dirname, step, which_field='delta', cut_field=True, mock_type='borg'): + + # Mock + if mock_type == 'borg': + delta1, boxsize = get_mock_field(ini_name, dirname, which_field=which_field, cut_field=cut_field) + elif mock_type == 'velmass': + delta1 = crop_velmass_to_borg(ini_name, which_field) + if cut_field: + delta1, boxsize = crop_field(ini_name, delta1) + else: + boxsize = get_borg_Lbox(ini_name) + else: + raise NotImplementedError + + # Step + with h5.File(dirname + "/mcmc_%d.h5" % step,'r') as mcmc_file: + if which_field == 'delta': + delta2= np.array(mcmc_file['scalars/BORG_final_density'][...],dtype=np.float64) + elif which_field == 'ics': + delta2 = np.array(mcmc_file['scalars/s_field'][...],dtype=np.float64) + else: + raise NotImplementedError + if cut_field: + delta2, _ = crop_field(ini_name, delta2) + + return delta1, delta2 + + +def get_likelihood_values(dirname, nframe, iter_max, iter_min): + + all_mcmc = get_mcmc_steps(dirname, nframe, iter_max, iter_min=iter_min) + + all_logL = np.zeros(len(all_mcmc)) + all_logprior = np.zeros(len(all_mcmc)) + for i in tqdm(range(len(all_mcmc))): + with h5.File(f'{dirname}/mcmc_{all_mcmc[i]}.h5', 'r') as f: + s_hat = f['scalars/s_hat_field'][:] + all_logL[i] = f['scalars/hmc_Elh'][:] + all_logprior[i] = f['scalars/hmc_Eprior'][:] + + return all_logL, all_logprior \ No newline at end of file diff --git a/scripts/submit_borg.sh b/scripts/submit_borg.sh index 662f34b..e6e9571 100755 --- a/scripts/submit_borg.sh +++ b/scripts/submit_borg.sh @@ -1,5 +1,5 @@ #!/bin/bash -#SBATCH --job-name=velmass_ics +#SBATCH --job-name=velmass_ics_model #SBATCH --nodes=1 #SBATCH --exclusive #SBATCH --ntasks=40 @@ -28,7 +28,7 @@ set -e # Path variables BORG=/data101/bartlett/build_borg/tools/hades_python/hades_python -RUN_DIR=/data101/bartlett/fsigma8/borg_velocity/velmass_ics +RUN_DIR=/data101/bartlett/fsigma8/borg_velocity/velmass_ics_model mkdir -p $RUN_DIR cd $RUN_DIR