diff --git a/README.md b/README.md index 9bf292f2..7aa4f8bd 100644 --- a/README.md +++ b/README.md @@ -22,22 +22,23 @@ # Basics -`lagom` balances between the flexibility and the userability when developing reinforcement learning (RL) algorithms. The library is built on top of [PyTorch](https://pytorch.org/) and provides modular tools to quickly prototype RL algorithms. However, we do not go overboard, because going too low level is rather time consuming and prone to potential bugs, while going too high level degrades the flexibility which makes it difficult to try out some crazy ideas. +`lagom` balances between the flexibility and the usability when developing reinforcement learning (RL) algorithms. The library is built on top of [PyTorch](https://pytorch.org/) and provides modular tools to quickly prototype RL algorithms. However, it does not go overboard, because too low level is often time consuming and prone to potential bugs, while too high level degrades the flexibility which makes it difficult to try out some crazy ideas fast. -We are continuously making `lagom` more 'self-contained' to run experiments quickly. Now, it internally supports base classes for multiprocessing ([master-worker framework](https://en.wikipedia.org/wiki/Master/slave_(technology))) to parallelize (e.g. experiments and evolution strategies). It also supports hyperparameter search by defining configurations either as grid search or random search. +We are continuously making `lagom` more 'self-contained' to set up and run experiments quickly. It internally supports base classes for multiprocessing ([master-worker framework](https://en.wikipedia.org/wiki/Master/slave_(technology))) for parallelization (e.g. experiments and evolution strategies). It also supports hyperparameter search by defining configurations either as grid search or random search. -One of the main pipelines to use `lagom` can be done as following: -1. Define environment and RL agent -2. User runner to collect data for agent -3. Define algorithm to train agent -4. Define experiment and configurations. +A common pipeline to use `lagom` can be done as following: +1. Define [environment](lagom/envs) and [agent](lagom/agents) (mainly for RL) +2. Use [runner](lagom/runner) to collect data (trajectories or segments) for agent +3. Define [engine](lagom/engine) for training and evaluating the agent +4. Define [algorithm](lagom/base_algo.py) +5. Define [experiment](lagom/experiment) and [configurations](lagom/experiment/configurator.py) A graphical illustration is coming soon. # Installation ## Install dependencies -Run the following command to install [all the dependencies](./requirements.txt): +Run the following command to install [all required dependencies](./requirements.txt): ```bash pip install -r requirements.txt @@ -53,7 +54,7 @@ We also provide some bash scripts in [scripts/](scripts/) directory to automatic ## Install lagom -Run the following command to install from source: +Run the following commands to install lagom from source: ```bash git clone https://github.com/zuoxingdong/lagom.git @@ -73,7 +74,7 @@ The documentation hosted by ReadTheDocs is available online at [http://lagom.rea # Examples -We shall continuously provide [examples/](examples/) to use lagom. +We are continuously providing [examples/](examples/) to use lagom. # Test @@ -86,7 +87,6 @@ pytest test -v # Roadmap ## Core - - Readthedocs Documentation - Tutorials ## More standard RL baselines - TRPO/PPO @@ -99,7 +99,6 @@ pytest test -v ## More standard networks - Monte Carlo Dropout/Concrete Dropout ## Misc - - VecEnv: similar to that of OpenAI baseline - Support pip install - Technical report diff --git a/examples/es/rl/README.md b/examples/es/rl/README.md index 00583572..7621c412 100644 --- a/examples/es/rl/README.md +++ b/examples/es/rl/README.md @@ -14,4 +14,4 @@ One could modify [experiment.py](./experiment.py) to quickly set up different co # Results - + diff --git a/examples/policy_gradient/README.md b/examples/policy_gradient/README.md index 01367380..0e5455e3 100644 --- a/examples/policy_gradient/README.md +++ b/examples/policy_gradient/README.md @@ -1,5 +1,5 @@ -We benchmark three baselines for policy gradient method in several different perspectives -1. REINFORCE -2. Actor-Critic/Vanilla Policy Gradient -3. Advantage Actor-Critic (A2C) +This example includes the implementations of the following policy gradient algorithms: +- [REINFORCE](reinforce) +- [Vanilla Policy Gradient (VPG)](vpg) +- [Advantage Actor-Critic (A2C)](a2c) diff --git a/examples/policy_gradient/a2c/README.md b/examples/policy_gradient/a2c/README.md new file mode 100644 index 00000000..1a2742ff --- /dev/null +++ b/examples/policy_gradient/a2c/README.md @@ -0,0 +1,17 @@ +# Advantage Actor Critic (A2C) + +This is an implementation of [A2C](https://blog.openai.com/baselines-acktr-a2c/) algorithm. + +# Usage + +Run the following command to start parallelized training: + +```bash +python main.py +``` + +One could modify [experiment.py](./experiment.py) to quickly set up different configurations. + +# Results + + diff --git a/examples/policy_gradient/a2c/experiment.py b/examples/policy_gradient/a2c/experiment.py index b508ee3e..cff242e0 100644 --- a/examples/policy_gradient/a2c/experiment.py +++ b/examples/policy_gradient/a2c/experiment.py @@ -28,6 +28,7 @@ def make_configs(self): configurator.fixed('algo.gamma', 0.99) configurator.fixed('agent.standardize_Q', False) # whether to standardize discounted returns + configurator.fixed('agent.standardize_adv', True) # whether to standardize advantage estimates configurator.fixed('agent.max_grad_norm', 0.5) # grad clipping, set None to turn off configurator.fixed('agent.entropy_coef', 0.01) configurator.fixed('agent.value_coef', 0.5) diff --git a/examples/policy_gradient/a2c/main.ipynb b/examples/policy_gradient/a2c/main.ipynb new file mode 100644 index 00000000..fc472a7d --- /dev/null +++ b/examples/policy_gradient/a2c/main.ipynb @@ -0,0 +1,232 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/zuo/Code/lagom/lagom/core/plotter/__init__.py:9: UserWarning: ImageViewer failed to import due to pyglet. \n", + " warnings.warn('ImageViewer failed to import due to pyglet. ')\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "from lagom.experiment import Configurator\n", + "\n", + "from lagom import pickle_load\n", + "\n", + "from lagom.core.plotter import CurvePlot" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IDcudaenv.idenv.standardizenetwork.hidden_sizesalgo.lralgo.use_lr_scheduleralgo.gammaagent.standardize_Qagent.standardize_adv...agent.constant_stdagent.std_state_dependentagent.init_stdtrain.timesteptrain.Ntrain.Teval.Nlog.record_intervallog.print_intervallog.dir
00TrueHalfCheetah-v2True[64, 64]0.001True0.99FalseTrue...NoneFalse0.51000000.0165101001000logs
\n", + "

1 rows × 25 columns

\n", + "
" + ], + "text/plain": [ + " ID cuda env.id env.standardize network.hidden_sizes algo.lr \\\n", + "0 0 True HalfCheetah-v2 True [64, 64] 0.001 \n", + "\n", + " algo.use_lr_scheduler algo.gamma agent.standardize_Q \\\n", + "0 True 0.99 False \n", + "\n", + " agent.standardize_adv ... agent.constant_std \\\n", + "0 True ... None \n", + "\n", + " agent.std_state_dependent agent.init_std train.timestep train.N train.T \\\n", + "0 False 0.5 1000000.0 16 5 \n", + "\n", + " eval.N log.record_interval log.print_interval log.dir \n", + "0 10 100 1000 logs \n", + "\n", + "[1 rows x 25 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "log_folder = Path('logs')\n", + "\n", + "list_config = pickle_load(log_folder/'configs.pkl')\n", + "configs = Configurator.to_dataframe(list_config)\n", + "configs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def load_results(log_folder, ID, f):\n", + " p = Path(log_folder)/str(ID)\n", + " \n", + " list_result = []\n", + " for sub in p.iterdir():\n", + " if sub.is_dir() and (sub/f).exists():\n", + " list_result.append(pickle_load(sub/f))\n", + " \n", + " return list_result\n", + "\n", + "\n", + "def get_returns(list_result):\n", + " returns = []\n", + " for result in list_result:\n", + " #x_values = [i['evaluation_iteration'][0] for i in result]\n", + " x_values = [i['accumulated_trained_timesteps'][0] for i in result]\n", + " y_values = [i['average_return'][0] for i in result]\n", + " returns.append([x_values, y_values])\n", + " \n", + " return returns\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "ID = 0\n", + "env_id = configs.loc[configs['ID'] == ID]['env.id'].values[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "list_result = load_results('logs', ID, 'eval_logs.pkl')\n", + "returns = get_returns(list_result)\n", + "x_values, y_values = zip(*returns)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot = CurvePlot()\n", + "plot.add('A2C', y_values, xvalues=x_values)\n", + "ax = plot(title=f'A2C on {env_id}', \n", + " xlabel='Iteration', \n", + " ylabel='Mean Episode Reward', \n", + " num_tick=6, \n", + " xscale_magnitude=None)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ax.figure.savefig('data/result.png')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/policy_gradient/reinforce/README.md b/examples/policy_gradient/reinforce/README.md new file mode 100644 index 00000000..c4b3b215 --- /dev/null +++ b/examples/policy_gradient/reinforce/README.md @@ -0,0 +1,17 @@ +# REINFORCE + +This is an implementation of [REINFORCE](https://link.springer.com/article/10.1007/BF00992696) algorithm. + +# Usage + +Run the following command to start parallelized training: + +```bash +python main.py +``` + +One could modify [experiment.py](./experiment.py) to quickly set up different configurations. + +# Results + + diff --git a/examples/policy_gradient/reinforce/experiment.py b/examples/policy_gradient/reinforce/experiment.py index 7052fcf3..a2035059 100644 --- a/examples/policy_gradient/reinforce/experiment.py +++ b/examples/policy_gradient/reinforce/experiment.py @@ -18,7 +18,7 @@ def make_configs(self): configurator.fixed('cuda', True) # whether to use GPU - configurator.fixed('env.id', 'Reacher-v2') + configurator.fixed('env.id', 'HalfCheetah-v2') configurator.fixed('env.standardize', True) # whether to use VecStandardize configurator.fixed('network.hidden_sizes', [64, 64]) diff --git a/examples/policy_gradient/reinforce/main.ipynb b/examples/policy_gradient/reinforce/main.ipynb index 30d01b74..2a46a7af 100644 --- a/examples/policy_gradient/reinforce/main.ipynb +++ b/examples/policy_gradient/reinforce/main.ipynb @@ -77,18 +77,18 @@ " 0\n", " 0\n", " True\n", - " Reacher-v2\n", + " HalfCheetah-v2\n", " True\n", - " [64]\n", + " [64, 64]\n", " 0.001\n", - " False\n", + " True\n", " 0.99\n", " True\n", " 0.5\n", " ...\n", " None\n", " False\n", - " 0.5\n", + " 1.0\n", " 1000000.0\n", " 1\n", " 200\n", @@ -103,17 +103,17 @@ "" ], "text/plain": [ - " ID cuda env.id env.standardize network.hidden_sizes algo.lr \\\n", - "0 0 True Reacher-v2 True [64] 0.001 \n", + " ID cuda env.id env.standardize network.hidden_sizes algo.lr \\\n", + "0 0 True HalfCheetah-v2 True [64, 64] 0.001 \n", "\n", " algo.use_lr_scheduler algo.gamma agent.standardize_Q \\\n", - "0 False 0.99 True \n", + "0 True 0.99 True \n", "\n", " agent.max_grad_norm ... agent.constant_std \\\n", "0 0.5 ... None \n", "\n", " agent.std_state_dependent agent.init_std train.timestep train.N train.T \\\n", - "0 False 0.5 1000000.0 1 200 \n", + "0 False 1.0 1000000.0 1 200 \n", "\n", " eval.N log.record_interval log.print_interval log.dir \n", "0 10 100 1000 logs \n", @@ -136,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -164,23 +164,33 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ - "list_result = load_results('logs', 0, 'eval_logs.pkl')\n", + "ID = 0\n", + "env_id = configs.loc[configs['ID'] == ID]['env.id'].values[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "list_result = load_results('logs', ID, 'eval_logs.pkl')\n", "returns = get_returns(list_result)\n", "x_values, y_values = zip(*returns)" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -192,12 +202,21 @@ "source": [ "plot = CurvePlot()\n", "plot.add('REINFORCE', y_values, xvalues=x_values)\n", - "ax = plot(title='REINFORCE', \n", + "ax = plot(title=f'REINFORCE on {env_id}', \n", " xlabel='Iteration', \n", " ylabel='Mean Episode Reward', \n", " num_tick=6, \n", " xscale_magnitude=None)" ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "ax.figure.savefig('data/result.png')" + ] } ], "metadata": { diff --git a/examples/policy_gradient/vpg/README.md b/examples/policy_gradient/vpg/README.md new file mode 100644 index 00000000..76d38e2c --- /dev/null +++ b/examples/policy_gradient/vpg/README.md @@ -0,0 +1,17 @@ +# Vanilla Policy Gradient (VPG) + +This is an implementation of [VPG](http://rll.berkeley.edu/deeprlcoursesp17/docs/lec2.pdf) algorithm. + +# Usage + +Run the following command to start parallelized training: + +```bash +python main.py +``` + +One could modify [experiment.py](./experiment.py) to quickly set up different configurations. + +# Results + + diff --git a/examples/policy_gradient/vpg/experiment.py b/examples/policy_gradient/vpg/experiment.py index d2077b75..6a237289 100644 --- a/examples/policy_gradient/vpg/experiment.py +++ b/examples/policy_gradient/vpg/experiment.py @@ -28,6 +28,7 @@ def make_configs(self): configurator.fixed('algo.gamma', 0.99) configurator.fixed('agent.standardize_Q', True) # whether to standardize discounted returns + configurator.fixed('agent.standardize_adv', False) # whether to standardize advantage estimates configurator.fixed('agent.max_grad_norm', 0.5) # grad clipping, set None to turn off configurator.fixed('agent.entropy_coef', 0.01) configurator.fixed('agent.value_coef', 0.5) diff --git a/examples/policy_gradient/vpg/main.ipynb b/examples/policy_gradient/vpg/main.ipynb new file mode 100644 index 00000000..01c3cabd --- /dev/null +++ b/examples/policy_gradient/vpg/main.ipynb @@ -0,0 +1,234 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "from lagom.experiment import Configurator\n", + "\n", + "from lagom import pickle_load\n", + "\n", + "from lagom.core.plotter import CurvePlot" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IDcudaenv.idenv.standardizenetwork.hidden_sizesalgo.lralgo.use_lr_scheduleralgo.gammaagent.standardize_Qagent.max_grad_norm...agent.constant_stdagent.std_state_dependentagent.init_stdtrain.timesteptrain.Ntrain.Teval.Nlog.record_intervallog.print_intervallog.dir
00TrueHalfCheetah-v2True[64, 64]0.001True0.99True0.5...NoneFalse0.51000000.01200101001000logs
\n", + "

1 rows × 24 columns

\n", + "
" + ], + "text/plain": [ + " ID cuda env.id env.standardize network.hidden_sizes algo.lr \\\n", + "0 0 True HalfCheetah-v2 True [64, 64] 0.001 \n", + "\n", + " algo.use_lr_scheduler algo.gamma agent.standardize_Q \\\n", + "0 True 0.99 True \n", + "\n", + " agent.max_grad_norm ... agent.constant_std \\\n", + "0 0.5 ... None \n", + "\n", + " agent.std_state_dependent agent.init_std train.timestep train.N train.T \\\n", + "0 False 0.5 1000000.0 1 200 \n", + "\n", + " eval.N log.record_interval log.print_interval log.dir \n", + "0 10 100 1000 logs \n", + "\n", + "[1 rows x 24 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "log_folder = Path('logs')\n", + "\n", + "list_config = pickle_load(log_folder/'configs.pkl')\n", + "configs = Configurator.to_dataframe(list_config)\n", + "configs" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def load_results(log_folder, ID, f):\n", + " p = Path(log_folder)/str(ID)\n", + " \n", + " list_result = []\n", + " for sub in p.iterdir():\n", + " if sub.is_dir() and (sub/f).exists():\n", + " list_result.append(pickle_load(sub/f))\n", + " \n", + " return list_result\n", + "\n", + "\n", + "def get_returns(list_result):\n", + " returns = []\n", + " for result in list_result:\n", + " #x_values = [i['evaluation_iteration'][0] for i in result]\n", + " x_values = [i['accumulated_trained_timesteps'][0] for i in result]\n", + " y_values = [i['average_return'][0] for i in result]\n", + " returns.append([x_values, y_values])\n", + " \n", + " return returns\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "ID = 0\n", + "env_id = configs.loc[configs['ID'] == ID]['env.id'].values[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "list_result = load_results('logs', ID, 'eval_logs.pkl')\n", + "returns = get_returns(list_result)\n", + "x_values, y_values = zip(*returns)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAEcCAYAAAARLRmYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsvXecXHW9+P0+Z9rO9p4t6QkpEIJJNkREEgwlYghgQ0SUcvHxxZVyEVRQDBcIeEH9oShevBbQB36CPgoYbkIQAhiRFkhIQkjbzfY6vc+ZU54/Zneym52ZnS2zJfm+X6+8YE+Z8zlndr+f8+mSYRgGAoFAIBBkEXmiBRAIBALBiY9QNgKBQCDIOkLZCAQCgSDrCGUjEAgEgqwjlI1AIBAIso5QNgKBQCDIOkLZCAQTTGtrKwsXLkRVVQAcDgdf+cpXWLZsGf/1X/817PMnkp///OfcfvvtEy2GYBIilI1gwvm3f/s3fvaznw3a/vLLL3P22Wejqip33HEHS5YsYdmyZZx55plce+211NfXJ45tbGzk1ltv5eMf/zjLly/nwgsv5L777qOzszPr8t9xxx08/PDDA7aNRgE888wzlJSU8P7773PHHXcAcPToUW6++WZWrVrFihUr2LBhA48//jiapo3JPaTiq1/9Kn/+85+zeo1UvPbaa3z5y1+mrq6Os88+m7vuuotAIDAhsghGj1A2ggnns5/9LM8//zzH1xf/7W9/Y8OGDZjNZiCulHbt2sXrr79OaWkpd955JwBNTU1cfvnlVFZW8txzz/H+++/zxz/+kRkzZvDee++N+/2Mlvb2dubNm4ckSQA0Nzdz+eWXU11dzebNm3nvvff42c9+xr59+wgGgxMsbfbw+/3ccMMN7Nixgy1bttDZ2clDDz000WIJRohQNoIJ5/zzz8fr9bJz587ENq/Xy6uvvspll1026Hi73c6GDRs4fPgwEHfdLF++nDvvvJOqqioAysrKuOaaa1i/fn3Sa+q6zi9/+Us+9alPcdZZZ/Gd73wHv98PHLNKnn32Wc4991xWrVrFf//3f4/qHl977TUuu+wyli9fzpo1a/j5z3+e9Lg77riD5557jt/+9rcsW7aMf/3rXzzyyCMsW7aMO++8k8rKSgDmzp3LT37yEwoLCxPnbt68Oam8uq7zP//zP5x//vmsWrWKW265BY/Hk9i/e/durrjiCurq6rjkkkt4++23AXj44YfZuXMn9957L8uWLePee+8FYNOmTaxZs4bly5fzuc99bsD3BhCLxfjOd77DsmXLWL9+PXv37k16r11dXSxdunSALPv372fVqlXEYjE2bNjA6tWrsdvtFBUVcfnll7Nr167hPHbBJEIoG8GEk5OTw0UXXcRzzz2X2LZ161bmzp3LokWLBh0fDAbZvHkzixcvBuDNN9/kwgsvHNY1//rXv/Lss8/yhz/8gZdffplQKJRYTPt47733ePHFF/n973/Po48+OsBtN1zsdjsPPvggO3fu5Fe/+hV//OMfefnllwcd91//9V9s2LAhYcV94hOf4M0332TdunVDXiOVvH33+OSTT7Jjxw6KiooS99rV1cU3vvENbrjhBt555x2++93vcvPNN+Nyubj11lupq6tj48aN7Nq1i40bNwJw+umn89xzz/HOO+9w8cUXc8sttxCNRhNybN++nfXr17Nz507Wrl3Lfffdl1TeadOm8bGPfYyXXnopsW3z5s2sW7cOi8Uy6Ph3332X+fPnD/kcBJMToWwEk4LLLruMF198kUgkAsBzzz3HZz/72QHH/O53v6Ouro4LL7yQYDCYCJ673W7Ky8sTxz355JPU1dWxbNky7rrrrqTX27x5M9dccw0zZswgLy+Pb33rW2zZsmVAjOXGG28kJyeHRYsWsWjRIg4cOJBS/j7Z+v5dcsklA/avWrWKhQsXIssyixYtYv369bzzzjsZPRuPx0NFRcWQx6WS95lnnuHWW2+lqqoKq9XKjTfeyLZt21BVleeff57Vq1ezZs0aZFnm7LPPZsmSJbz++uspr3PppZdSUlKC2WzmuuuuQ1EUjh49mti/YsUK1qxZg8lk4tJLL0373DZs2MALL7wAgGEYbNmyhQ0bNgw67o033uC5557j5ptvHvI5CCYn5okWQCAAqKuro7S0lFdeeYWlS5eyb98+fvGLXww45rrrruPWW28ddG5xcTE9PT2Jn6+66iquuuoqHn74Ybq6upJer7u7m9ra2sTPtbW1qKqK0+lMbOuvwOx2O6FQKKX8x8vW2trKeeedl/j5gw8+4Mc//jGHDx8mFouhKAqf/vSnU35euvtLRSp529vb+eY3v4ksH3u3lGUZp9NJe3s7L774Iq+++mpin6qqrFq1KuV1fve73/HnP/+Z7u5uJEkiEAjgdruTypGTk0M0GkVVVbZs2cLdd98NxBXSb37zG9atW8d9991HV1cXTU1NSJJEXV3dgOvt3r2b2267jUceeYQ5c+YM+RwEkxOhbASThksvvZTnnnuOo0ePcvbZZw9YtNJx1lln8fe//53Pf/7zGV+rsrKStra2xM/t7e2YzWbKysqyksF22223cdVVV/Gb3/wGm83G/fffP2CBTsdZZ53FSy+9NKz7609VVRUPPPAAK1asGLSvurqaSy+9lE2bNmX0WTt37uTXv/41TzzxBKeccgqyLLNy5cpByR3JuOSSSwZZfIWFhZx99tls3bqVhoYG1q9fn0iMgHgM54YbbuCBBx7grLPOykhGweREuNEEk4bLLruMN998kz/96U9JEwNSceONN7Jz505++MMfJiwZl8tFQ0NDynMuvvhifv/739PS0kIwGOThhx/moosuSmS+jTXBYJCioiJsNht79uxJuI4y4eabb2bXrl08+OCDCQunqamJ22+/HZ/PN+T5X/7yl/npT3+aUK4ulysRL7rkkkt49dVX2bFjB5qmEY1GefvttxMKt7y8nJaWlgH3YTKZKC0tRVVVfvGLX4w6HXnDhg08//zzbNu2bYAL7dChQ1x//fX84Ac/YO3ataO6hmDiEcpGMGmYPn06y5YtIxwOD3BBDcWcOXN45pln6Ozs5JJLLmHZsmV8+ctfprKykltuuSXpOZ///Oe55JJLuOqqqzjvvPOwWq384Ac/GKtbGcTdd9+dyCp79NFHueiiizI+d+bMmTz99NO0tbVx8cUXs2LFCm666SaWLFlCXl7ekOd/7WtfY+3atVx33XUsW7aMyy+/nD179gBxy+aXv/wlv/rVrzjrrLNYs2YNv/3tb9F1PXHutm3bWLlyJZs2beKTn/wkq1evZt26daxduxabzUZ1dfXIHkova9eupbGxkfLy8gEJIY8//jgul4vvf//7LFu2LJHdJpiaSGJ4mkAgEAiyjbBsBAKBQJB1hLIRCAQCQdYRykYgEAgEWUcoG4FAIBBkHaFsBAKBQJB1hLIRCAQCQdYRHQQAtzuIrg8/A7ysLB+n8+SaryHu+eTgZLvnk+1+YXT3LMsSJSVD13j1RygbQNeNESmbvnNPNsQ9nxycbPd8st0vjO89CzeaQCAQCLKOUDYCgUAgyDrCjSYQCAQZYBgGbncPihIBpr7LrbtbTvTAS46E1ZpDSUnFgE7cI0UoG4FAIMiAQMCLJElMmzYdSZr6TiGzWUZVUysbw9DxeBwEAl4KCopHfb2p/8QEAoFgHAiHAxQUFJ8QiiYTJEmmoKCEcHhssvROjqcmEAgEo0TXNUymk8sZZDKZ0XVtTD5LKBuBQCDIkLGIXUwlxvJ+Ty41LRAIBCcA3/rWTaxefS6XXXZsVLhhGFx++aV85jMbeOaZp6iqqiEWizFr1mzuuOMuCguLMAyDv/zlGZ5//q/ouo7VaqWkpIxrr72e008/I6syC8tGIBCMOybTyWUhjDXr11/Cli2bB2zbtes9TCYTlZXTWL7iTB597Pf84rE/oOkGT/z+twD8+tf/zfbtL/N//s8veOaZv/L44/+XK6/8KvX1R7Ius1A2AoFgXJFlCW9IRTUMZFkonZGwevW5tLW1cPRoQ2Lb//7v37jgwvVEFA1V1VFiOiCz9IwVNDc1EQqFePrpJ7njjruoqKhMnFdXd+YACylbCDeaQCAYV2RZornTR48nzGlzyygvzIEpNp3+jb0d/HNPR1Y++5NLqzn79Oq0x1gsFi644NNs3bqZf//3WwiFguzY8Tq//NVT7Nr1TuK4mKLw9lv/ZNGixTQ2NmC1Wpk5c3ZW5B4KYdkIBIJxRTcMPIEobl+Ef33QzvuHewgpGiaTWI6Gw/r1l7Jt2xZUVeWVV/7OkiVLKSuvAOCD3Tu5+ZtXc9utX6equpYvXP5Vjm+D5vf7ueaaK/nKV77A97737azLKywbgUAwrigxnXBUBeKKp7nDR5czyIKZJcypLpwSb8Bnnz609ZFtTjllAWVl5bz99pts2fI3Lv3slxL7zvhYHXfedf+A42fOnI2iKLS0NDNjxkwKCgp44on/yxtv7OCPf/x/sy7vVPheBQLBCURMN4j0Kps+oorG3iMOHL7oSZdePBrWr7+E3/3uf2hubmblqk+mPdZksfGlL32FBx/chMPRk9geiYSzLSYgLBuBQDCOSFJcscRStEnpdASoLrGjaZnFcEwmGU1L19/rxOaCCy7i0Ucf4ZJLP4vJZE4b+lI1neu/fgN/+f+e5j/+45sYhk5hYREFBQVcd93/k3VZx13ZPPjgg2zbto22tjY2b97MggULAFi7di1WqxWbzQbA7bffzjnnnAPA7t272bhxI9FolNraWn70ox9RVlY25D6BQDC5kCQJbyCacr/LFyGq6pgzNG7CMQ27xXTSKpzCwkK2b38DVdPxh2IAnH/Bes6/YP2gY3UdNN3g8suv5PLLrxyyN9pYM+5utPPOO4+nnnqK2traQfseeeQRnn/+eZ5//vmEojEMg29/+9ts3LiRbdu2UVdXx49//OMh9wkEgsmHLEu4/ZGU+/1BBSWWWXsUk0mm0xkicJxL7mREy3AImhLTJ6xf9bgrm7q6OqqrMw+s7d27F5vNRl1dHQBXXHEFL7744pD7BALB2CJJ0qjrYmKaQaD3DTwZmm7g8kUyuo6m6zR3+jja7kU+yYtE1QwtO1XTJ2wi6aRKELj99tvZsGED//mf/4nP5wOgo6ODmpqaxDGlpaXouo7H40m7TyAQjC2yCULK6JoyxtRjmWip6HAGIQPdEVZ0vIEoTR0+ApGT17oxyHy8s2GQMl6WbSZNgsBTTz1FdXU1iqJw//33c++9946bS6ysLH/E51ZUFIyhJFMDcc8nB8ffcyCs0O7yUTOnDNMILZwuVwjZZCIvL/V7rqIZmKxmyvJz0n7WwSYXVpsFgHZnmDNPnTaqWp2hvuPubhmTSZp02XJ9Vk2m34mq60hyfOk3m9M/L8MwkGV5TH7/J42y6XOtWa1WrrzySm644YbE9vb29sRxLpcLSZIoLi5Ou284OJ2BEZmWFRUF9PT4h33eVEbc8+RFNslIGBlncsWPJ2lwPdk9R1WdjxocFOZasA+xSCVDkiRcvgj+QOqYDUAoGMXpDhMLp3a3ySaZ+hY3wWA82eBQo5Oa0lxyrSOTS5dlTIaRdnKlLJvxej3k5RVOKoWj6QZqht85xK2gWEzDZDMPMTzNIBj0IcvmQb8LsiwN+yV9UiibUCiEpmkUFBRgGAZbtmxh8eLFACxZsoRIJMLOnTupq6vj6aef5qKLLhpyn0BwshGKauTnmMh0ZLGi6pjkjDxWQDze4vXH3VanzS4ddgaYLEt4/Kkz0fowgB53iJLpxSmvEVY03L5jSkuJadS3eThjfhn6MBZeAEXXOdjo5pTpRdjSxH5KSipwu3sIBCaXm17VjIyTKvrweWRybOYhxkKD2WylpKRiNOId+6wx+ZRhsGnTJl566SUcDgfXXnstxcXFPPbYY9x0001omoau68ybN4+7774bAFmWeeihh7j77rsHpDcPtU8gOJmQZYlAWCHPZsr4HE3T0XSwZeB6kmWJQEjBAJo6fMyuLiRnBNZNuky0/nS5wsyrLUq6T5IgGI4ROi5O09zpY25tEXnWzJ8BssT+I066PRGqy3LJKbCmrFUxmcyUl8c9MLJJRhlGina2MJtldh7oprHDN6zzcnNMfOaTc1Gjqa3HsUYyjCnWAS8LCDda5oh7npyYzTJH2n3MmpaPlOGvcjimYxgGuUkW5+Pv2WSS+bDRxYFGFwCnzi1j8cySYVk3mgH//KANdwbWTY7VxKfqZia1NEwmmd31DupbBlsYc2qLWDa/Ysg3dogr0IZOPx8c7CY3z0ZVqZ2PzSvP6J6imk5zZ4AFM4owJii7C0AH/rmnHZc3MyXen7UrZ1Gcax7R2jcSN9qkykYTCAQjIxrTcfsiw/Lda7qBPxTLKP5gAN6Akvj5aLuX4DDrW1Rt6Ey0PiKKRiAcI5loUVXD4U7eYqW1y48vrCQ9rz+yLNHji/JhvSPhdHS4w0QzyNSSZQlvQOGjo07aHKEJnc2jqPogCy9Thvv9jRahbASCE4CYpuPxRzIu7pMkiXBUxR3IrKYlvqgdc7mEIyqt3YFhLbQxTScyjNTpTkcwaXZZRNHwBZNbRzFV53CLh3TaRpIgGNV4/0DXgDRgf1DJTD4JWrr96IbB3iM9eDNU2NkgpumD+sxNVoSyEQjGiWyuR9GYhj8Uy3gsjCRBKBLD449mlE6gJlnUGto8hJTM3GiyLCXaqWSK0xtGOc7SMJlkulyhtPfZ1h3AG1IwmWRMJnmQMlV12H24m+Bx2W66YdDtDg2ZPh1WdJyeuGUVjqrsPuRAnQBXWtzCGtolOVkQykYgGAckCRQNpCxMpjSZ4inFum5kXLAnSRLBiEooHMsokymm6kSPOy4UUWnt9mdk3cTb1AxvYfQFFaKxgfej6gYdjmDa81RN5519nbz5YSf7jrpo7gngCcUIxXQU3eBAs5suZyjpuZ3OYFrrUJIkfEFlgOvK4QlxsNmdle82HbIsjShWM1FMitRngeBER5ZlWjt9+IJRFs4sIc9mHsPmkRJOT3zRCUdjFOVaGCrvpy+jKxxViekG5jQLZdwqUZLua2jzMqOyAOsQCkc3wJthJlofqqbjCUTJK8tNBLGjMS2jt/lAOEbgOMvFJEtYrSYiaWIcHn+USExLmWknydDSNThZ5Eirh9LCHGr6yZptYpqBL5j8e5mMCMtGIBgHJAncvghH27z8c3cbbc4gjNGbsKLqBMLxRScUUZEz+KtWdYNoTI1bLIqW1sUnyxKeQPJFLRiO0dozdOxGUbWMkwP60+EIJuIhsizh8kVH3G5F0w3CETWt21CJaXgCSso4VkTRcXgGW0W6bvDB4R78EXXc4jeKqg2Io012hLIRCMYBVTMSC0MgHOPtfR3sOtRDRNVHPQ45pumJ+EMww8VO1QxivS4qTyD9wDJdB18aa6KhzUMkll4BxDRjRMrG448Q6XPfSRJt45CC3t4TSPo8krnQ+hOOquw+2EMgqqIRT0fPpt4Z6TOdKISyEQjGAUXTiSjHFgbDiBdH7tjdRoc7NOJuypIEoaiaeNsPRWIZBfw1XUdR44u4e4guy3GrJPUbdCAUo9OVPgVYiaUemJYOf0hJxIoix3UNyBYuX/iYguuHLMez0NLR4wmx/d1m/vlBO3uPuvCEYsR0A5NpbBWPLEv4g0rGCSGTAaFsBIJxQNMMItHBC1gwHGPn/i66vZER1WvIsozbd8zqiMY0VHXoFUjXSSQG+EMKsTTxI1Uf+g26oc2LkuK6o8maMgxweCOYzTKBJF0DskEwFCMUHexaDCs6Ds/QI5Q13cDti3Cw0cVrO1v4x6423jvUTXSYbXTSIcsSzimUHABC2QgE44Ki6ilnjigxjXf3d9LjjQ7bwjEwcHqPLYCxmIaWQfW8ph9r2BmOqoNSjPsTU3WUIdxkbl8Elz+5/CPJROtPlzOIbJJpHyILbawwgA5nYIB7U5IkfCFlULp0Jp/lDyk0tvto7swscy8TVN3AO0RD08mGUDYCAWMzGCwV8Wyu9IttVIkrHFdAGdaCpMR0Av0yxRRVH7KwU5IYYKlEomrKzgOyLOFNUUB5PEdaPOhJ/DqqZuAfRdaUNxDF7Y/S406erpwNul2hAQpYluPdCUbD0XYv4WEUtaZ1bcZG3jlgohDKRnDSI0nxWfbBqJaVTCJZlvClyObqTziq8u7+TtzBWMaKL6YbAxadWExjKG+NJEmE+sVgDCP+9p3KKvH4M1MUPZ4QnuDgFjPKMNrUJCMUUWlo845KYQ0XX0AZkPQQVjR6MnChpSOeuRfMrC7JJOEOKilrd1RdJyyUjUAwdYgXWxq891E37x/oQhmz2pdj6Ab4UtSpHE8wHOOdDzvwhYdWOPFaGXWAey7uHkt/D5IkEQoPXKg8/uQZaZpupGwNczy6blDfNrhVzHB6oqWivjW51ZQtVE3H6Q0jy/Fhaf6QOmwXWjIa2jyEh3BJShIEwipv7+vgSJtv0POMyxMb1+cxFghlIzipUXXYdbCbHk+IHk+YPfUOMlU3mVpBMVUbVv+qQCjGOx92Ehyy/kXG5Rv8th2Opk9/7mtV059UbWuUDMY496fTERwwojl+LXXC5t6Pho6e+HhqWZZo6R5eC/9UBEIxOlL0fOvDQGJ/o4tQRGVffQ8fNbsx+n2fJpM0Lll5Y41QNoKTFh3YU+8YEHhu6fRzsNmTtuDSZJKJqjqxDALxEK+HGE4DSoi3ajnY6ErbAsUwwJVk0QlF1LRKStMNwspABRKKxAa1o4F4IHo4ijKm6jS2+xKLqSzLeKZQ/67+uP0RwopGJJa6y/RIqG/1JE2thrgi6XKHaOtNsTYMONjoYm+9M/ESpBtG0u99siOUjeCkxJDib49NSYZOHWp20dTpR07mW5ck2pxB/vlB+6C+XanQdYOoMnw3Umt3oLejcPL9UVUjmKS5ZTCS3gUXU48VdPYRjqpJEwtGUh/T0u0/1r5eAo9vaiqbcFQlEFLxhwa3vhkNvqDSW5c0ePkNKzr76p2D6mca2jzsOtSDahgoqjHl4jUglI3gZESWONTi4UiS4VsQf5vce8RBhyucWLRNJpmIqrPrcA9v7+vAH1LwBoZOVe5reDkS97qq6XEZU2ib/l0J+hMKpy/s1IxjBZ19xFSd8HFuO1mWRtR7KxJVaesJYDbHp1kGp1BLleNpc/iHLOQcCUdaPESP+w5kWeJwqydlH7qWLj/vftSFJxCdUm1q+kjZiLOlpSWjD5gxY8awLvjggw+ybds22tra2Lx5MwsWLMDtdvOd73yH5uZmrFYrs2bN4t5776W0tBSAhQsXsmDBAuTepk8PPfQQCxcuBGD79u089NBDaJrGaaedxg9/+EPsdvuwZBKcPMiyRH2HjwONzrTHqZrOrgNd5CytIa9ApaUnwIcNzgFBYocnwszK/LTxiL5K75HS1h1g/vRiCu3mAQpLkiT84VhSayQa0xI1NMnQdQZZNhBPMS4vsCbOHU19TGO7j5nTCuIuuynUUuV4jrZ5s/K53kCULneYmRV5aJoR7/sWUIa8XpczhMMdznhu0WQipbK54IILkCQJwzAGBBuP//mjjz4a1gXPO+88vva1r/GVr3wlsU2SJK6//npWrVoFxBXSj3/8Yx544IHEMU8//TR5eXkDPisYDPKDH/yAp556itmzZ/P973+f3/72t9x4443Dkklw8hBSNA40ujKyNCK9tS/NXQEaWt2DzvEEIsQ0nXS2jSRJo4pZqJrOkVYPyxdU0F+AeHv55HEEJaahanrKTs6abiQtMHV5I8yvKYReu0jTR14f4w8pdLvDFOfbiE5hZZPNhK8jLR6qSnIxSfG43r56R8rC3/5MRUUDadxoBw4c4KOPPuLAgQNs2rSJz3zmM2zdupU9e/awdetWLr74Yu6///5hX7Curo7q6uoB24qLixOKBuBjH/sY7e3tQ37WP/7xD5YsWcLs2bMBuOKKK9i6deuwZRKcHJhMMu09AaLDCNb39f1KtujEZ8GkXxxUTR+1y6OtO4DvuNhNuiBxTNVRU6ySksSAHm39CYSVAYWMUXV0UyCPtHro9oQy6tV2MuL2RejxhrFYTTR3+TNqhTOVyWiezc9+9jNeeuklcnJyAJg9ezb33nsv69at43Of+9yYCqTrOn/84x9Zu3btgO1f/epX0TSN1atXc9NNN2G1Wuno6KCmpiZxTE1NDR0dHWMqj+DEIapqNHWOnf89omhEVR1bitknMLgB50hQtfio4xULj1k3iqoTShG0VmIahg6YBu+TJCl11+KISkwzsPUmRmij7Crs9kXwjqJNzcnAoWY3OVYzB5pcEy1K1slI2ei6TltbG/PmzUtsa29vR88w9XM43HfffeTm5nLVVVcltr322mtUV1cTCAT49re/zaOPPsqtt946ZtcsK8sf8bkVFQVjJsdUYare89E2L6oBeXm2YZ+b6pywojFvRknK83rcIUxmE3l5o8vF8QQVFB1qep99lzOIZJJTymW2mKioSP573dAVSHqeJPWeV9brrjZJ2HIsDP9pTU1G8nsxWqKqwZ56J2aLGbNl/GdZjmbtGy4Z3d0111zD1Vdfzec+9zmqqqro7Ozkr3/9K1dfffWYCvPggw/S1NTEY489lkgGABJut/z8fL74xS/y+OOPJ7a//fbbiePa29sHuegywekMjKjorKKigJ5xmK8xmZiy9yxJfFjfQzDDavj+5OXZUp7X2umjptSOliI92BtW8Y5RTcSew91YZZCI9+7yp4kFeXxhrBKDJnZaLCac7lDK++lxBrFgUFaWT7cjOKLnNRVJ9x1nm/FpL5qcka59siwNW1Fl9Lp1/fXX88ADD+BwONi+fTs9PT088MADfP3rXx+2kKl4+OGH2bdvH48++ihWqzWx3ev1EonE/1hVVWXbtm0sXrwYgHPOOYe9e/fS2NgIxJMILrroojGTSXDiEIio9IxhYV4f/pCSMm4jy9KAJpmjpb0nXndjMslDtpdPVdipqundeu5+nZunajGmYHIypGWjaRrf+973uO+++1i9evWoL7hp0yZeeuklHA4H1157LcXFxfz0pz/lscceY/bs2VxxxRUATJ8+nUcffZSGhgY2btyIJEmznB+PAAAgAElEQVSoqsqyZcu45ZZbgLilc++99/KNb3wDXddZvHgx3//+90cto2DyYTJJadN5058r09TpzijTZ7gEwzEUTceeJG4T75g8dspG0wwONbs589RpePzplU0woiLL0qC3VlU30iY1ePwRdAOiijqujS8FJz5DKhuTycQbb7wxZt1w77rrLu66665B2w8ePJj0+GXLlrF58+aUn3f++edz/vnnj4lsgsmJLEu4gzHy7WbkEeibsKIm2n+MNTE13n03t8A6KGNNN8i4iWWmdPQEaOvJH7IpZDCcXFGouk5MTZ2NF4qqKDGNcHR4/dwEgqHIyI129dVX8/Of/5xYbOpVrQqmPhFV572PuuL9oYb50hPvNRXO6uwPhzc8IMbYx3AbcGaCphvs3N855P1EFS3pjBrdIK1lE46oxHSjdxS0UDaCsSOjBIEnn3wSh8PB448/Tmlp6QAr57XXXsuWbAIBkixxuMmNNxBNtIdZMqcMKcNqu5hmcLQ9O1Xgfbh8kaR1OOoIGnBmQiZFfTFVQ9UNzMfpZk1LXtDZh6rFa2sMpClbPCiYnGSkbH70ox9lWw6BYBCyLNHtjdDQeqyHWX2LB1mSOG126ZDl3ZIE3kAs6+3Yg6EYUVXDclzFvjbCBpxjgRLT0TQds7n/aOPUBZ398QSi5KhC0QjGloyUzZlnnpltOQSCQURiOnuP9Ax6wz7c7EaWJBbNKklr4UiyREO7J6stRyDeZTmm6lisx6ooR9OAcyxQVI3jDZN0BZ39cfmi5GbY0VogyJSMq4g++ugjdu7cidvtHpC735cZJhCMJZIscajRhTfFOOVDTS5kCRbOLEHCSLqoByMaXc7sVzHouoE/pJCfk5vI/pJlUnbvHQ80zRikpOPKZui4a1u3f0IKHAUnNhklCDzzzDN8+ctf5q233uLXv/41hw4d4vHHH6e5uTnb8glOQmRZoscTSdsB1wAONLr4sNGFM6AQimlENR3NAJNZxmIx0dLtH7J32Vjh8EYGjBuQJBnvBNepxCd2HvtZlqWMRhvrujElJ2sKJjcZWTa/+c1v+M1vfkNdXR0rV67k0Ucf5fXXX2fLli3Zlk9wEhJRdfYkcZ8dj0HcpdbnVrNZTeRYTeTYLOTbLbSNY6cDty8yIPtL1fQxmVk/GkLRGJKUk/BEqJqelYQFgSATMrJsnE4ndXV18RNkGV3XWbNmDa+++mpWhROcfEiyxMEm97CHdulGvGmk2x+lwxHgcIs7q+nOxxOMxAYMw4qNQQPO0RIKqwMyR1VNR0kxjlggyDYZWTZVVVW0trYyffp0Zs+ezSuvvEJJSQkWiyXb8glOMgIRlcYspypng0hERVF1bL2jflXdIBKd2IU9FBk4lkDVjbQFnQJBNslI2Vx//fXU19czffp0/v3f/51bbrmFWCwmWsMIxpS+McRTsb7DALz+KEV2C3pvS5hstMcZDmFFHfAshyroFAiySUbKpv/MmjVr1vDOO+8Qi8UGTc4UCEaDLEtTeoCUwxNmdlV8BMBYNuAcKbGYjqoZ9I6nGbKgUyDIJhnFbP7whz9w4MCBxM9Wq1UoGsGYE9N0PFN42JY3qBBV9TFvwDlSFFVD7Z05lWlBp0CQLTKybPbu3cvjjz9OMBhkxYoVnHnmmaxcuZJTTz01aU8ogaAPk0lGy/BtWlF1gqMcoTyRBMO9xZ0mecwbcI6EWExH753YKUmS6HUmmFCG1a6mtbWVd999l3feeYdHH30UgJ07d2ZPOsGURpYlhhOOjsZGN/N+olFiGmFFw2YxTYr7UDU9EbORpMxqbASCbJFxB4GGhoaEonn//feZPXs2K1euzKZsgimOLEs4vBEqCnOGtG5kWcp6D7PxwO2NUJhrmTT1LBFFpSDHlGifIxBMFBkpm0984hPk5eWxbt06Lr30Uu655x7y88dvdrVgaqLqBi5vhLKCoVufSLKEwzt1kwP6cHjDTCvLnbAGnMcTiqhIRTlo+tS2GgVTn4wCLp/61KcwmUy8/PLLvPzyy7z66qt0dnZmWzbBFEeJ6XS6gkQySLdVYvoJMRkyEFJwepOPHJgI4rU2EqqWfmiaQJBtMrJs7r//fgAcDgfvvvsu7777Lvfccw8lJSX8/e9/z6qAgqlLTNNxeSJEFJWcXEvaBViZBO1dxgJfUOGjRudEi5EgGI4rG01HdA8QTCgZp5Lt37+fF154gb/97W+88MIL2O12li5dOqyLPfjgg6xdu5aFCxdy6NChxPajR4/ypS99iXXr1vGlL32JxsbGUe8TTCx9BZq6YdDlCqXNWpSk3gmR6olRAxKeRLGRiKKh6TqaYZwwz1cwNclI2axcuZIbb7yR/fv3s3btWv785z+zY8cOfvKTnwzrYueddx5PPfUUtbW1A7bffffdXHnllWzbto0rr7ySjRs3jnqfYGKRZQlXb8C/xx1CS2PWyLJ8QsRrJiMxNT4eWteEshFMLBkpm2effZbt27fz0EMP8cUvfpFZs2aN6GJ1dXVUV1cP2OZ0Otm/fz8XX3wxABdffDH79+/H5XKNeJ9g4lF1A48/rmz8QYVomuwsAxKKSTC2KDENQxR0CiYBGcVspk+fTn19PS+++CJOp5ONGzdSX19PLBZj0aJFoxKgo6ODadOmYTLFpxyaTCYqKyvp6OjAMIwR7SstLR2WDGVlI8+sq6goGPG5U5VM7tntj2BIcmIIl4aU8jxvIIqONKkHdk1m2dJhNklYrWZ0SRn2PUzVex4pJ9v9wujWvuGSkbLZunUr99xzDxdeeCEvvPACGzduJBQK8ZOf/IQnnngiyyJmH6czMKJhURUVBfSM48yUyUCm9xxUNJzuYCIpoLnDS2GOCTWJKycU03C4gpN2YFdeno3gJOgIMFL8gSguT2hY9zDV73m4nGz328dI1z5ZloatqDJSNo888giPP/44ixcvZuvWrQAsWrRoQL+0kVJdXU1XVxeapmEymdA0je7ubqqrqzEMY0T7BBNLX3JA/zCNwxMmphlIKY6drIrmRCAcVQmEhRtNMLFkFLNxuVwJd1nfMCZJkgYMZhopZWVlLF68mBdeeAGAF154gcWLF1NaWjrifYKJRZYlnN6BMRh/UCGaJPU23ulZxGuySSAUIyoKOgUTTEbK5rTTTuP5558fsO1///d/h536vGnTJlavXk1nZyfXXnst69evB+A///M/efLJJ1m3bh1PPvkk99xzT+Kcke4TTByqbuAJDFQg0ZhGIKxy/PuJqh1LJBBkh253aEo3OBUMTd+U2smMZBhD1zrX19fzb//2b0yfPp3du3ezatUqjh49yu9+9ztmz549DmJmFxGzyZxM7lnRDF7f1TqoSPOUmSWcMa9sQNwmqhm89l7LpO5IfDL680+2e57q9/v2/i663GHm1hRy6qwSZHlor9OqpbXUluRMrpjNvHnz2Lp1K6+++irnnnsu1dXVnHvuuWKmjSApMU0nlORN2ukNo6j6AHNaiWmTWtEIBJMdwzBw+iLkWE00tPtw+yKsWFhJbk7GfZbHhYylsdvtfOYznxmw7bXXXuPcc88da5kEU5hkyQF9+HuHi9nNcuLYqTwsTSCYDPhCMVTN4PS5JZhkid1HHLz+QTvL5pdTVZY70eIlGDJm09jYyLZt2wZknr3yyit87nOf484778yqcIKpR7LkgD5iqo4/FEsklsiyRM8UHgMtEEwG+gqiSwtt1JTnsfqMGnJtZt450M2+o65Jk+mZ1rL561//yg9+8AOKiorweDzccccdvPXWWxw8eJDrrruOz3/+8+Mlp2CKoGqDkwP60+UMUlNqR1UNoqqOfwr7yacyEUXlUIuXU2eXYDaJabtTGZcvSo7VRK4tvpzn2y18cmk1+xtdNLT78AUVzjpt2phkD4+GtMrm17/+Nb/85S9Zs2YNr7zyCjfffDNf/epX+dnPfobFYhkvGQVTiKiqEUrTvdnliyTiNrFJNAZa1fSTatHtcIZo7PRTXpxDTZmIvU5V+uI1pYW2AcrEJEucPreMvBwL+4666PGEqSyZWJda2r+u7u5u1qxZA8DatWuRZZnbbrtNKBpBSlTNSBvw74vbSBKEoxpKBrNuso3LF2Hr2810uUITLcq44eudHdQjapymNOGoRkTRKCvMSbp/dlUBOVYTR9p84yzZYNIqm/5Z0ZIkYbfbhaIRpCRdckAfqqbjDSiYzaZJ03zzUIsXw4CDLR4yqAQ4IfCF4haliJlNbZyJeE1yZSPLEnOqC3B4I3gneDhhWjdaOBwekG3m9/sHZZ+99tprWRBLMBVJlxzQn05nkFnTCnBOgoXOE4jS7QlTlGfFE1Do8USoLLFPtFhZxTAMfEEFs0kiFFEJRmLk5YiXyKmIyxfBbJIozE39/c2qKuBQi5f6Ni/LF1SMo3QDSatsfv/734+XHIITgEy7AXj8EXwhBX944sdAH271YjZJfPy0aby+u53DrZ4TXtmEIiqabjC3ppCGdh8OT4S8qolVNn0K0GY1kWMd3/oQhyfM9l1tfOLUaeTYJldtylC4fFFKC3PSBv+tZhMzp+XT2Oln8awS7BN0j2mveuaZZ46XHIITgKiqJS3mPB5/UMHhDadNJBgP/CGFDmeIBdOLsFlMzK8tYt9RF05vhLKi5G4JiC+Mzd0BKovtE/aHOxp8obiSry3Po90RpMcTZlbV+I/K0DSdHm+ELleILneYiKJRlGdl9RnV45o5dajVSyAUo6krwMKZxeN23dGixDT84Ri1FUMneMytKeRoh5+jHT5OnT0x/SNPnvQbQdaJDZEc0IemG+w60I02wfn/h1u9mGSJOTWFAMyclo/VInOo1ZP2vIYOHx8ccXKkzTseYo45vmBcyRfkWqgozqHHG8koVqUkaaQ6Eno8Yd7e38WL77TwzkfdtDmClBTYmF1VgDeo0O0eP/eqL6jg8EaQJYnmLn9GzyESVXljbwfd7olNKHH54mUDqZID+pOXY6G6LJemzgCqNjFJOULZCMYEWZbwB6JpkwP6M1G/8H0EIzHaeoLMqirAZokP4DObZObVFNLjiaRsaujyR9jf6AambiaXL6SQl2PGbJKpKLITU/Uhg8feoMK2d1s41JJeEQ+FYRi8e6AbT0Bh5rR8Pn7qNNadOZOViypZMqcUu83EoVbvuCVqHO3wIcsSKxZXEla0jBTdkXYfTl+Udw/0JAL0E4HTH0GWoLjAmtHx82oLiWk6zV2BLEuWHKFsBBljMskoMW1Q52boTQ7wTZ0Czfo2H5IE83qtmj5mVxViMckcbh1stSgxjfcO9GC3mlkwo4hAOEZokvR1UzWdQCgzt6QvqFCYF1+gyovjb8VDZaU1dvgSGXujaTHU11rl1NklnD63jMoSOyb5WEeJ+bVFuP3RxFt7OpSYRmAUrlglptHSE2R6RR5za4qwWWSauoZoMqtqNHX6mVZiJ8dq4p393RlleQ1HeRqGwb/2dfLBEUfa41y+KMX5NkxyZst4aUEOJQU2Gtp9E5J1OSxlo+s63d3d2ZJFMImRZIl2Z5B/7W3HH1GRTQM1zlQaFRBRVJq7/MyozB8Uc7GYZebUFNDpCiVqUSC+ALx/2EE0plG3sILa8rifvGccXT7pONjs4bUP2pNOQu2PqukEIyoFvdlLOVYzBbmWtFaaquq09gSpKs3FZjHx/uGeEVumfRZjSUHyEcwzKzNzZWq6wRv7Onl9d3vSOUmZ0NTlR9cN5lYXIssSM6cV0OkKp3UFN3b40XSDRbNKOOu0Kkwmibc+7BzU4bwPwzA42uFj2zstHEnyApOMTlcYhzdCU1cg5QuEqul4AlFKC4c3ynpebSGhqEqHc/xdgBkpG5/Px2233cbSpUu58MILgXh/tIcffjirwgkmHlmWiOkGexucvP1hJ+09QV5/v5X9R90omoGpt+o+0+SAyUB9mw/dgPm1RUn3z60uxCRLA6ybI21eut1hTptTSnGBjXy7hRyraVLUqRiGQZsjPlbbNYTV0bd49Vk2ABXFdly+CFoKBdLmCKLpBvNrC1l2SjmBsJpwJQ4Xtz+C1SyTl6IjsckkM6+miB5PJK0FdaDZjT8UQ9ONjBfx/ui6wdEOP+VFOYlnMXNavGV+KjeTpuk0dPioLLZTlGclN8fMWadNwzDgzQ+7iBynpDyBKDv2dLC3wYVuGBxs8RBR0lvChmFwsNlNrs2MSZZSKl1Pr8s6k3hNf6pLc8nNMVPfPv5Fnhkpm7vvvpv8/Hy2b9+eKOpctmxZYkS04MRENkm4Agpv7GnnSIsn0dAvpuocaHLxj92tNHcH0Mk8OWCiUWIajZ1+aivyyLMnT/e1WkzMri6gzREkEI7R7QrxUZOHmvJcZvdmbUmSREWxPePgejZxB6JElPjb/VAxhL5MtMLcY8qmsjgH3SClG7Sx009BroWSAhsVxXbm1hTS2OkfUYDc5YtSUmBLm202u6oAs0nicIoEDKc3Qn2bj1nT8plekcfRTv+ghX4oOlwhIorG3OpjbtS8nHjCRKpEgZbuAEpMZ/70Y+cU5FpZdeo0ojGNN/d3ocQ0YqrG3gYn//igg3BUZfmCctacUYNuGBxoSm+xdThD+EIxFs0sZlZVAW09waRWU5+bsWSYlo0kScyrKcTtj9LUOb4KJyNl8+abb3LXXXdRWVmZ+CUpLS3F6XRmVTjBxKEDh1t9vPFBW8o3zEAoxrv7O3lrXycNrd6MkwMmkoYOH5pucMr05FZNH/Nq4q6V/Y1u/rW3nbwcMx+bVz5gkawsjgfXPYGJrRdqd4SQJSiwW3AMUVTrC8YwydIAy6K0MAdZSh638QSieIMKs6sKEve+eFYxBbkWdh12DsuFpcQ0ghF1SNePxSwzt7qQDmcIf2jgs42pOu8f7iE3x8xpc0pZOLMYwzA4NEzrpqHdR26OmWmlA2uqZk0rSJooYBgGR9p9FOdbB1kTJQU2zlxcSTAc418fdrL9/TaOdviZU13A2uW1TK/IJ89uYU51Ic3dgZQxnrhV4yHfbqG2Io/5tYVIEknjh05fhIJcC1azaVj3DTCjMh+LWeaN3e3DPnc0ZKRsCgoKcLsHms3t7e1UVIxdNWprayuXXnpp4t/atWsTdT5r167l05/+dGLfjh07Euft3r2bSy65hHXr1nHdddcJBTgGmM0yB5rd7D3SQ2yIGADExw43tI0uS2k8iCoaRzv8VJXmDnizT0aO1cysafl0ukIoMZ26RZWYzQP/XPqC690T6EozDIMOZ5CKYjvTSu14AtG08RRfSKEg1zJAaZpNMiUF8RTo42nq9GOSJab3q+UwyTLLF1SgqBp76p0ZW3ZDxWv6M6dmsCsTYN9RF+GoxvJTyjGbZPJyLMyszKepy5+xG9fjj+L2R5lTXTDIworHpWQaOwcmCrQ7Q4QiKvOnFyW1yiqK7axYWIE/GMNuM7P6jGpOn1uGpZ8yWDC9CItZZn+jK6lcbY4g/nCMhTOLkSQp/jtYVUBLT2DAvemGgcsXHbYLrQ+zKa7MGyejZfPFL36Rm2++mbfeegtd19m1axff/e53ueKKK8ZMkOnTp/P8888n/p133nlcfPHFif2PPPJIYt8555wDxP/Qvv3tb7Nx40a2bdtGXV0dP/7xj8dMppMVVTNwZdB2ZqoQUTQ+bHTx8nutqJrOghnprZo+5tcWkZdjZuWp0yjKG6ycbBYTxfnWCU0S8AQUwlGN6vI8ygpzMAxSpm33VeknU7QVxTn4ggpR5Zil0pcYUFOeN2DRBCjKs7JoZgkdzhAtPcGMZHX5o0hAcf7QysZmMSXcSH0LbYczREt3gFOmFw3oBbZgRjEScLAlM+umocOHSZaYWTm4kLUvUaDLfSxRwDDicaG8HDPVpak7J1eX5XHByhmcs7Q66T1aLSYWTI/Ho463nPReq6Yw10JNv4Fn82uLkBho3fiCCppuDDs5oD8LZhTxH1csG/H5IyEjZfP1r3+dT3/609x7772oqsr3vvc9zjvvPK6++uqsCKUoCps3bx5yXs7evXux2WzU1dUBcMUVV/Diiy9mRaaTCUXVp0T8ZSgiUZV9DS5eea+V+jYfVaW5nPuxmowWOwC7zcza5bXMqUmtnCqK7bj90YwswGzQ7gwiSVBVak8swKniNtGYhqLqA5ID+qgojruTerzHFsHW3sSAWVXJZ83Pry2krNDGvgZnRlaF2x+lMM+a8SiHeTWFIMGRNh8RReODegdFeVYWzhhY5W+3mZldXUhLd2CQ2+14IopKmyPIzGlxV1Iyjk8U6GtiOb82uVXTnxyrKX08qrqQ3BwzHza6BliErd0BghE1YdX0v7eZ0wpo7g4k/iaHU8yZCkmSyB3nfngZ9dqQJIlrrrmGa665JsvixNm+fTvTpk3jtNNOS2y7/fbbMQyDFStW8K1vfYvCwkI6OjqoqalJHFNaWoqu63g8HoqLp07bicmGqk9tZRONaRxs9vQGemF6ZR6nTC8mP0VCQDqGWlwqi+0cbvXi8IapHue5MIZh0OEIUVFsT/jui/KsKZuh9nUOSNa0sTjfisUs4/BEmF4RX2ybOv0U5looSaGcJUli2SnlbH+/jYZ2P0vmpm6DYhgGbn+UGZXJFVcy7DYzMyvzae7yEwjHUFWd5UvKkeXB38kptUU0dfo52OKhbmFlys9s7Iz/TsypLkx5TF+iQFOXnwUzijjS5sVmMTG9cvTfr0mWOHVWCTsP9tDcFWBWVQG6bnCoxUtRnpWqJJbT/OlFNHX5OdzqZem8Mpy+CHabacq1Skop7ZtvvpnRB5x11lljJkwff/nLXwZYNU899RTV1dUoisL999/PvffeO6busrKyzP8AjqeiYvx7SmWbhjYvdnvqmEZe3sjN92zT5Qrx5t72eKZRTRGnziklf4j4TCakuuccuxXzR124AwrzZw6/59ShZjftjiCapqNqBqqmo2kGqq5TXZbHx5dUpVR4Ll+EUFTl9PnlCfmqyvM43OIhJ8eSSEvvI9Lr7qqqyMeWpNllVWkuDl+E3Ny4wvIGFeoWVZKfn/oNOi/PRnV5Hp2uEGemkdXtj6DpBtUV+cP6/Tn9lAqauwI4vBGWLaygKsXfW14eLJpVwodHXSinGJQUDJZZ03WaugLUlOcxrXzw33x/uRbOKuWfH7TT2BWgxxPhjFPKKSwYmwat83OtNHbFFeMps0pp6vQRiqqsObU26bPOy7Mxt6aIox0+zlhQidsfZVpZ7pj8HY5m7RsuKZXN97///QE/9xVzFhcX4/HEg8HTpk3jlVdeGVOBurq6ePfdd3nooYcS26qrqwGwWq1ceeWV3HDDDYnt7e3HMipcLheSJA3bqnE6AyOa011RUUBPT/qK46mGySTT6fATTDGuOS/PlnLfRNLn8z7c6iXfbmb10mqK8m1gGKOWd6h7LivMod0RHPZ1Gjv97Kl3km83Y7OYMJtkbJZ4fYWq6TR2+CjNtzI9hTVQ3+JGkqAkz5K4dqHdgq4btHX5BzUTdbhD2Cwm1JiGmiSLrKTARkt3gG5HkKbuACZZoqIoZ8j7qiy209YTpLXTl3KuSntvZX6uVR7Wc5KJFyKGoxrTy3LTnjuzMo9DzR52Hehm1anTEtsNw6DbE6axw09U0ZhZmT/oc47/jotzLdgsJvbWOzGbJGpK0197uCyaWcw/93Sy+2AXbT3x3nCFdnPKa8yuyqehzctbvS9SRXbLmMgz0rVPlqVhK6qUymb79u2J/3/sscfweDzccsst2O12wuEwjzzySFZcVc8++yxr1qyhpKQEgFAohKZpFBQUYBgGW7ZsYfHixQAsWbKESCTCzp07qaur4+mnn+aiiy4ac5lOKiQD9xRqOwPxlvnvHerB7Y8yszKfJXNLx3XEc2WJnS53mGA4lrJ253i63SH21jupLLZz5qmVyMdZBIZhsGNPBx82uplWmjsovmAYBu3OEOVFOVgtx4L3Zb1BY4dvcOdqfyhGYV5q+Sp6s+s6XEGaOn3UlueljGv0p6o0F1mKZ2ylUjYufxSrRSZ3BK6fTLsUW8wm5tUWcqDZg8sfwWoy0dztp7UnSETRsJplTplelLjPdMQTBfI53OpldlVBRs9hOJQW5FBTlpuYoPmxU8rTumzzcixMr8ynpTseRypN05V8spLRN//EE0+wY8eOREGn3W7nW9/6Fueccw7f+MY3xlSgZ599doBV5XQ6uemmm9A0DV3XmTdvHnfffTcAsizz0EMPcffddxONRqmtreVHP/rRmMpzsqHEjEnXCcDhDdPaHSTHaiLHZsZujfurc2wmHN4IHxx2YmCwfEF5It4wnvQF17s9YeZkoGy8QYV3D/RQkGehbmHFIEUD8XjI0rll/GNPBweb3SyZWzZgvy+oEIqonHJcFwSrxURhriUet5lxbLtuGPhDSqLDdTLycizk2swcavH2JgZk5iK2mGUqiu10OIKcNrsk6aLp9kcpHaKYcyyYW1NIQ4ePtz7sQtUMJOIvA0vm5lNVkps03pOKOdUFhKIq89IkiIyGxbNL6HSFKCmwUZ6B8jhlehEt3QEsZpmCEcQfJ5qMlE1ubi579uxhxYoViW179+7Fbh/7IVPbtm0b8POMGTN47rnnUh6/fPlyNm/ePOZynKzENJ1wZPIkBygxjfcO9qBqRsqRBMX5VlYsqMjYqhhr8nLM5NrM9HjCaQPPAOGoytv7u7CYZVYtnjaodqc/xb1t9xs6/MyYVjAg/brdGUICqsoGB5TLinJo7oq7R/oW12A4hm4wZH1RPDAeoLjARnF+5rGumvI8utzhuFI5zrqJ9hZzzpyW/fim2SRz2uxSjnb4qCnPY3pF3oiHseVYzazI4mTLvBwL5yytxm4zZ6SE8+2WRDHyeM77GSsy+hZuvvlmrr/+etauXUtVVRWdnZ28+uqrbNy4MdvyCcaZmKqPuLFhNviw0Y0S01l9RjUFeVaiikY4qhLp/a8sS8yaVjCsN9axJt66JifRnyyVLDFV55n6wmAAACAASURBVO39XaiaztmnV2eUTbRoZjHtjiB7652cfXo8AG8YBu2OIGVFOYnxCP0pK8zhaIe/t1FjfOFPZKIlSXvuT0WxnaauQMrixVSkc6X11f2UZlDMORbMqMwfVtbbRFKUYRp+H4tnlWRJkuyTkSPysssu489//jNz584lEAgwZ84c/vSnP3HZZZdlWz7BOCLLEt7A5InXdLvDtHTHF76ifBuyJGG3mSktzKGmPI95tUXM6e3YO9FUlNhRNSNlQaWuG+w82I0/FKNuYWXSItFkWC0mTp1dgssfTfjrfaEYwYhKTXnyVNy+WE3/ehtfSEGCIdO/q8py+dj8MubWDi8e29+VdnxHAbc/iiQxLEtJcOKRsX05f/585s6di8PhoLy8HDnDGQqCqYMsS0N2DR4vVE1PZGplWvE/kVQU5SAR7y92fGA+GtPY1+CKp9DOi89wGQ4zKvNp6gqwv8lNVVkuHY54CnOqanabxZTok3bK9Pg2X1AhP9eSmB2TClmKV9APdVwyEq60QJTSfqnHLl+UojzroFRswclFRt9+IBDgO9/5DkuXLmXNmjUsXbqU7373u/j9J1ba78mOqhv4Jkla84EmN6GoyhnzyzMeDjWRWMwmigtsA/qkqZrOoRYPr7zXSpsjmOjkO1ziyQKlKDGdA00e2p1ByotysFlTN2EsK8rB5Yui91oZvlDyNjVjSVWpHUmKNwbtQzcMPIFoRv3QBCc2Gf0Vb9q0iXA4zObNm/nggw/YvHkz4XCYTZs2ZVs+wTiiqJMjOcDli9DQ2zV3NC05xpvKYjueQLy/WFOXn+3vt3Gg2UN5UQ6fWlbDghkjLxUoyrcxp7qAxk4/gbBKdZLEgP6UFeag6QbegEJM1QlHtbRpz2OBxWyisthOh/OYK83f28dLKBtBRm60HTt28PLLLyeyz+bMmcMPf/hDLrjggqwKJxhfVE0f9lyQsUbTDXYfcWK3mVg8c2oFQyuKczjYAq/uakNRdUoKbKxYWDFmCrMvWSAa04dWNkXxxd3piySsm2xbNgDV5Xl0HQ7jCSiUFNgSbtnxSg4QTF4yUjY2mw2Xy0VtbW1im9vtxmoVAb8TBUmKF0emSi8eLw63eAiEY3z81MEt/Sc7xQU27FYTsiyxdF4Z1WW5Y5qiajGbWL6gAl9IGTKdN8dqJi/HjNMbScRfCjJMShgN1aV2PpCg3RGvinf7o9gsU6+Pl2Dsyeg34Atf+ALXXXcd11xzDTU1NbS3t/PEE09w+eWXZ1s+wTghy3LaMbzjgTeocLjNy/SKPCpL0r+5T0ZkSeJTy2sxyVLW6iAqiu2JItKhKCuKt9HJsZowmyTsaWI8Y4XFbKKi2E67M5jIohtqMqfg5CAjZXPDDTdQWVnJCy+8QHd3N5WVlVx//fV84QtfyLZ8gnHE7R/bGTZ9fvtMFhrDMNhzxIHFLLNkzvAbWk4WxrNNzlCUFcaLOzucIQrzrOO24NeU5bLbHabbHSYUUROjtAUnNxmPGPjCF74glMsJjKJqSWedj4Z/7evCapGpW1gx5ELX3B3AHVBYdkr5gF5fgpHT1wJFUfVxidf0UVWWi1TvZH9jfLqvSA4QQIbZaC+88AL19fUAHD16lKuuuoqvfe1riW2CqU9MM8Z0ho0S03D6IonpikMd+1Gjm9JC24Dxw4LRYbeZE40vh+ocMJZYe11p/nBMFHMKEmSkbH76059SVBQvrHvwwQc5/fTTWblyJffcc09WhROMHzFVHzASeLQ4egd42W0m9h11EUqTUn2g2YOi6pw+t0z49seYvgLTZAPTsknfaOOiPOuUqJMSZJ+MfgtcLhfl5eVEo1Hee+89br31Vr75zW9y4MCBbMsnGAdkWcIXTD9Od7g4erOgzjqtCsOA3Uccg9qYAHgCURo74zU1mbZwEWRObXkeBXbLuFo2EHelydLoRhcLTiwyitmUlpbS1NTEoUOHOP3007FarYTD4aSLh2DqIcsS7hRz60eK0xuhtNBGvt3CkjmlfFDv7FUqx7oiG/9/e3ce3VZ5Jn78e+/Vvi+WLHlPnNhx9pAAKQVKAmUZQgIpLUwOaWmbKadMN6ZQlpRkSKbQMD0DwxRmOudAaQsDP7pBS2hLgdAFBoaUQEkJCYRsxPu+yrZ0398fipU4tmTZlmzZfj/n5JxIV8v7Wlf30bs9rxC8c7AJk1FlXoncxjsbgl4rQW/hyA/MMJNB4/wlBXLKs5SQ1plw4403sn79ejRN47777gPi20bPmzcvq4WTJkZMF7RlME1NpC9KR09/YofJknwHNU3dvHu4hYDHmkgGeeyUSQFGg5wUMN1MdGtKym1pBZv169cndsAcyCKwZMkS/u3f/i17JZMmTG9/ZtPUNJ0YrxmYDaUoCkvm+Hl5TzV73m/k3EUh+qM67x5uweeUkwIkaSZIGmyEEInBWl3XMZvNif8DiW2bpakvpmd2JlpjWwSDpuA+ZRaS1Wxg4Wwfe95v5GB1O92RaHxSQLmcFCBJM0HSYLN8+XLefPNNAObPnz/kgjAQjPbt25exwqxevRqTyZQIbDfffDPnnXceb731Flu2bBm09bPfH98mN9UxaWSKAl0ZTlPT2BbB77IM2e64KGCnpqmb9460oAvkpABJmkGSBpudO3cm/v/iiy9OSGEAHnjgASoqKhK3hRDccsst3HPPPaxYsYKHHnqI733ve9xzzz0pj0npUVWV1s7MTQ7o6Y3SlWTVuKIoLCn3s2tPBBTkpABJmkGSTn0Oh8OJ/xcWFlJYWEhBQQFWq5WCgoLEfdn2zjvvYDabWbFiBQDXXnstv/3tb0c8JqVJIaMz0RpPG685ndmkce7iMOcuCstJAZI0g6Q1QaC9vZ3t27fzm9/8hmg0itFo5NJLL2Xz5s14PJn9dXrzzTcjhGD58uX80z/9EzU1NRQUFCSO+3w+dF2ntbU15bFMl2u66o/qdGcwTU1jWwSjQU05E2mkrYklSZp+0go2t99+O5qm8cwzzySyPj/wwAPccccdPPTQQxkrzOOPP044HKavr4/vfOc7bNu2bUL2zPH7HWN+biAwtZMMNrX1oGgadnv6+auSPVYIQVN7hHyfDYdjei3mG83fZ7qYaXWeafWF8V37RiutYPP666/z5z//GYslfgEpLy/nu9/9Luedd15GCzPQdWcymdiwYQNf/vKX+exnP0t1dXXiMc3NzSiKgsfjIRwOJz02Gk1NnehjGCAPBJw0NEztrbE7IlGaW7tHfuAJdruZriRrcroi/XRHopQXmJI+ZipKVefpaqbVeabVd8BYr32qqow6UKWVrmbWrFkcP3580H3V1dXMmjVrVG+WSnd3Nx0d8Qu3EILnnnuOqqoqFi5cSCQSYffu3QA8+eSTiTU/qY5JI1NVhY4MpqkZabxGkqSZK62Wzcc+9jG+8IUvsG7dOkKhELW1tfzqV79i3bp1/OxnP0s8bjxbEDQ1NfHVr36VWCyGruuUl5ezdetWVFXl3nvvZevWrYOmNwMpj0kjUxQlsW3vSISI72dvNicfb2lsi2A2qnJMRpKkIRSRRoKzjRs3jvxCisKPf/zjjBRqos3UbrR+XfDHPcfp6E7dumluj7DvSAtN7b2E/DbOHGZ/GiEEz7/xEXluC8srA9ks9oSbiV0sM63OM62+AGcvLqTQa5mwbrS0WjY/+clPRl0YKbepqkJDc3fKQNPe3cd7R1qobe7BZFQpCtj5qKGL9z9qo6J48LhYV0+U3v5YIqW9JEnSqVKO2bz99tuDbkcig9dj/P73v898iaQJEdUFH3zUOuyx7kiUPe838PKeahrbIswr8XDR8iKWzc2jJOTkvaOtifGZAY1tPcDUHa9RVQVNk2lzJClbUgabz3/+84Nun3/++YNu33rrrZkvkZR1iqLQ2tk37GLO3v4YL791nOMNXZQXuLhoeREVxR4MmoqiKJw1P4TdYuAv+xuInLLZWmNbBItJw26Zminly8Iu5hbLfH+SlC0pg83pwzkj3ZamCAUOftTKcB9fXXM30ZjgnEUhFszyYTIOXuVvNKismBekP6bz5oEGhBAIIWhsj5DntkzZpJpFQSeFQceQfG6SJGVGymBz+oVjpNvS1NDRE6Wuefi1NbXN3VjNGl5H8gVubruJRbN8NLZFOHCsjY7ufvr69SnbhWa3GnHYjNhMhkGZqiVJypyp2echjZmqKRyqaSMa04cci8Z0GlojlOQ7RvwhUZLvoKk9wv5jrbSfmGSQ57ZmpczZFvBYsRo1FAVCeQ5a0pwOLklS+lIGm56eHi644ILE7Y6OjsRtIcSQCQPS5NKJtzaVFN2b3b0xjtd3DnussS1CTBfk+2wjvpeiKCwu99Pa2UdNUzc2swHbFB2vKQo60fV4d2BBwM7+w83osotYkjIq5dXhRz/60USVQxonRVFo7eilpqmL+WVelGGulZqmUl3TTiTJRmm1zd0YNIU8V3rdYQZNZcW8AH96u4aAZ2p2odksBlx2U2L80WYy4Haa08qEralKRvcBkqTpLGWwOeussyaqHNJ4KfBhdRsf1XWgAPPLfJw+AyASjXG4pn3YpwshqGvuJui1oqrpj8W5bCYuWFaAeYpuF+D3WLGYVPRY/G9lNqqE/fYRg03Ib6cw6OAv++omopiSNOWllRtNyn1dkRh1TV0AHDjawr4jLYhTxl1UVaGpNUJ7klxoLZ299PbrhNLoQjud3WLEYJiap1Jx0AmnxORoVKcgYE8ZcFVFoaLUS8hnwy5T80hSWqbmFUIaRNMUjtV30B89Oei//0gz7x1tgRMXzagu+OB4W9LXqGvuQVEg6J2ag/xjYTUbcNtNQ9J1WM0G3Clm4wX9NnwOExajRjhv4lK0S9JUJoPNNBDp1/mobmiOtgOHm9l/pAVFVWjr7qcpxVYCtU3d+F0WTFO0O2wsfG4LVtPQnmSTplKQJIioqkJlqQ8FhVhMpzTkHFW3oyTNVDLYTHGqqtDUFhk2x5kA3jvczL4jLbx/tGXYRZwAnT39dPT0j6kLLVctKPdTEEjd6igKOhnUh3ZCLKYTzhu+Ky3fb8N7yoQCh9WIN80JFZI0k6U1V7W1tZVHHnmEffv20d09+Nfx448/npWCSemJCcGH1cm7xwYCTioDCzzzfdOjC83vtjI77KYvqNPW2UvXMNtem00aXqc5acZbm1nD4zDTfMpEAVVVqCzxoXAyRBnUeKqbptaeLNQku4JeG5G+aNJxPEnKpLSCzTe/+U36+vq47LLLsFqnxwVpOlAUaO+J0jjOC11tczdOmxG7ZeoPdmuawsJyP0ZNwWQwsHhugNf31gwJKj6XBatJQyQJNkZNJZznGBRsQn47nlNaNQCxmCDgsWIxG5JOKc9FqqKwoNxPpC/K//61ZrKLI2WAqipj2i5goqQVbPbs2cNrr72GySRTeeQSVVU4XN02rhOsrz9Gc3svc4rcGSzZ5CkrcONLtFgEIa+V8iIP7x9tGfS4wqBzUAvldANdafsONwHxNTUVJV4UxJDn2Mwa+T4bR5JMK89FAa8Vl82E02rE77FOyZbZdJfq/BzyWAXOnB/i3UNNGd19N5PSGrOprKyktrY222WRRqmrN0Z1Y9e4XqOupQcB02K8xmE1UlHsHdRaEbqgosSD75RxFZNRxe8eedOoga40OLVVM/RxQheUFbiZSqkC5xR70RQwqAqVJV6mUNFnBIvZwPL5obTPKafNRMhno7I0dzOXp9WyWblyJZs2bWL9+vXk5eUNOjaeraClsdM0ldq6znF33dQ2d2M2animeAJKBZg/24/NpBE7Le+bWVNZUhHglbeP09ev43VZsZo0GCHYGDWVgoCDI/WdVJQO36qB+NpZl9WIx2GeEnnVvC7LKa2/+B5Efo+NxhSzFaWJVRh0UBSw8/5RM22dI59Tfo8Vg6YQ9tnxuixpZcCYaGkFm927d5Ofn88rr7wy6H5FUTIWbFpaWvjWt77F0aNHMZlMlJaWsm3bNnw+H5WVlVRUVKCq8YbYvffeS2VlJQAvvfQS9957L7FYjAULFnDPPffMiHGlvqjOkZrkEwPSEdMF9S09FAXsUz6DdzhgJ+y3Dwk0ALou8DpMzJ+Vx1sH6ikM2NEUiA3zOqca6Err0/V4qyZFcDIZVIpDLlo6GsZZk+wrL/JgMijETmRNMKgKlaVemlq70+62kbJH0xRmhVwYVIWg15ZWsCnMc6DHBEZNoarMx/++U5109ulkyZltoRVFYdOmTZx99tkA7Nixg+9973vcfffdADz55JPY7fZBz+nq6uLOO+/k8ccfp6ysjM2bN/Pwww/zla98JevlnUzxzc96aR3nr+imE4k3p3oXmtmoMX+WHzVJywNAjwlKQ05aOnoJeGyJC+1IrCaNuUXeIal/TheL6YT9dt473ERf/9CAlyucNhP5Xuug+uu6wO82k+e10dAiWzeTLei14bAaicV0CoMOPjjWkvJHgNVswGk3nthbKp7FPOi1U9c8vi72TBv1OhshBLquJ/5lisfjSQQagKVLl1JdXZ3yOX/84x9ZuHAhZWVlAFx77bX85je/yViZcpYCHx5vHfev0NrmbjRVIW+KJtEcMLfEi9s2/HjKqVQEVWVeLKb0F64aVIWgz5bWr0S7RSPgze3AXRp2YTEO/doblHjrZoo3cHOWosSDwoiPI97yVJX47xu7xYDDlrqL2+uMz6wcoALzZvnQcmyxcVotm7q6OrZt28bu3btpbx8842bfvn0ZL5Su6zzxxBOsXr06cd/GjRuJxWKcf/75fPWrX8VkMlFTU0NBQUHiMQUFBdTUjH4ap98/9pQjgYBzzM8dq+MNnXREotjtyVOqjEQIQV1LD+E8Oy7n6Lodx/O+meZ2mFgwJ4DLnt0xp3Q/56rZMVq7hq7ryQVmk8bcUh8+z/Cft9Vu4Wh9F01t8ZlpufQ5T4Rs1rck5KQ05OK1vTWD0kqdzm03URRy4TwRYHRdUBR2cbR2aIaQAbOLPfh9g69hTnd88tBIE4jGc+0brbSCzdatW7FYLDz66KNcd911PP744/zHf/wHn/jEJ7JSqO3bt2Oz2bjuuusAePnllwmHw3R2dnLLLbfw4IMPctNNN2Xs/ZqaOsc0fTgQcNLQkPwkyApV4e399bSPYwAwGtN593ALPb1RAm4LXV3pd8fZ7eZRPT6b/G4rC8p89Ef6aOjOXplG8zmbNQUNkZMLJQt8XlRdT1oXVVUozXdwrKYVmy13PueJkM3z2mE1Uhp0YDcpFAccvPNB8nG9imI3/ZF+Gk6URVEU8pwW9h1sHPbxBk3FZjYM+UwVBUqCDg4fb00Z3MZ67VNVZdSBKq1utD179nD33XdTVVWFoijMmzeP73znOzzyyCOjLuRIduzYwZEjR7j//vsTEwLC4TAADoeDT3/607z55puJ+0/taquurk48djpSFIXmjl5qGoff/CwdbZ29/PHtGg7XdjC7wEVhwD7yk3JQadjFyoUhHGZDTi1ksxhVCoMT39odidGgUlbgGnYCxQBdF/icZoLeqXlOjEdR0EEwC2OXigIL5+RhNxuIRQVlYSd5SVqWNouBkG/wJBchBE6bMenGhG6HeVAX2snngdtmoiTkykxFMiCtYKOqKgZDvLIul4vm5mZsNht1dZndy+O+++5j7969PPjgg4kFpG1tbYkdQaPRKL/73e+oqqoC4LzzzuOdd97h8OHDQHwSwWWXXZbRMuUSHRHfRXKYi6sQgo7uvqQXXiHiWZ//+Nd4M37lgnwWzvKhTrFOek1TWDQnwLK5AYyqMmg1fy7QdZGVi9Z4hfMcOK0jd2SoQGWplxzr7s+60pCLRXPyMBkzm4i2JOQi5LMlAohBUVg0Jw/jMFtyFAad2IYJHBaTij9JgAr57RiSfFi6rlNe5MY8ijHKbEqrG23JkiX84Q9/4JOf/CTnnnsu3/jGN7BYLCxcuDBjBXn//ff5r//6L8rKyrj22msBKCoqYtOmTWzZsgVFUYhGoyxbtoyvf/3rQLyls23bNm644QZ0XaeqqorNmzdnrEy5RFUValt6qG8efrbQ/mOtHDjWhqoqeBwmfE4zPqcFryu+nmLP+400tkUI+WwsnePP+JdqIljNBpZWBgl7bRmdnJJJQoDFpGE0qCm7LyaSqirMKXKnnLo9QAiBz2kinOegI40pt9PBwG6tejRKRYmXvUm6rE41q9CN12nmnQ8ak37OdquRqjLfoPVcQsSn4c8t9vLuoabE/QZNpSyUpOUp4vsuHasd2lUW8ttStladFiOzCz3sO+W9Jktawebee+9NfLnvuOMOHnnkEbq6uvjc5z6XsYLMnTuX/fv3D3vs17/+ddLnXXTRRVx00UUZK0eu6o8J3jvcPOwMtOb2CAeOtZHvtWK3Gmlpj3Cwup0PRHwyh6rEu+CWlPspyXdMyTU1XpeFM+YFcVuNORtoBhhVBavZQH80N8Ztgl4bLpsp/VaggOXzgsSiMQ5+1JrdwuUAn8uC026ipbmfsrCL4/UdKRfn+t1WFszyYTKo2K0m3nyvbkiyV0WBBbP98e6z04KBHhPMLnRT09SVWHyZ77PhsBqG/UGg6wK3w4zFpBHpO7k6zGkzjTizMhbTKQu7OFrbPmxC2omUVrBxuU72+1ksFm688casFUgaStNUPqrvHJQUckB/VOfNA43YzAbOqAgkmuexmE5rVx/N7b309EaZXeDCMUV3lTSbNFZU5eO05Nb4TDImo4bNasyJSQI+t5UlcwOjyrMF4LCZWDQ73gJ+73BTzi0QzKSCgBODFv/emDSFhXMCvPr2cWLDnGtWs4FllQGManwr8aDbzMcXF7Bnfz0Np+SXKwo6KUiyyHjgfRbPyeOVt6uJxXTKizwpPyCrScXntlLdcHK8Nr6luUZshBa0zaQxr8w36VuYpzVm09fXx3333ceFF17I8uXLAfjzn//MY489ltXCSXGR/hgHjgy/TcDeQ01090ZZVjG4H1jTVPwuC3OL3Cwu9+dUoLFZ4tmYTcOs9xhOZakPl9U4JQINxNdKeJ2TP2044LVx9oIQNpM2trEtIags8bB4TiDn1mxkitGg4nWd/Kx0XZDnMlMaHjqwrqkKSyuCuKzGxN8zFhPYzQbOWhii7MRzrGYDVWU+lBTRQ9cFfqeF2UVuvC4LHscILU8Bhaftz1QYiGcNGEksplOQZ0867jNR0vq233333Rw4cIDvfe97iS6YuXPn8sQTT2S1cFJ8QPyjhq5hfyVXN3ZxrL6LiiI3/imygZfdauTshWEqit3Mn503YgJIv8dKab4zZb90rtF1gcc5uZ9HyG/nrPn5WAzjnEShC8oLXZwxL3/YQe2pzu0wYzlt/DKevNWL/bQfaJVlPsJ+65AfPUIIjIrC0rkBFs3JY/5sP06rYcTWoK7rzC3yUFHqxail/ibousDntiR+oFnNBpw2Y9qfrVFV4lk2JvFHQ1rdaC+88ALPP/88NpstMR05Pz8/47PRpKG6+3Q+ONYy5P6e3ihvH2zC4zBRUeyZhJKNntNm4qwFIdw2I9F+ndJ8J81tPUkXrMX3psnDqOX2Ph2nE0LgtBpRlBGz3GRFYdAZb+mqSkbeX48JioN2jMYQf9lXR2/fSFnlpo5w3vCzuexmA/Nn+dn9bi2C+N90TqE7dUtCCOYWutEFaadDMhtUwv700idZjRoep5X65i68rviW5nqaP8LiLSkzhUHHkIkGEyWtnypGo5FYbPAJ1tzcjMczNS5yU5WmqRyuGTqwJ0R8dpmuC86oCEzqr5V0uR1mPrYojNt2sjtMEYIFs/NwJln9P7vAg99hmlKBZoCmKWmlJ0nF57aMOn1MadjFGRUBDEpmAs0APSYIe62cs7gg6eeVCae3JrJJUSDoG342V7zryRbPsGE3sajczwiNDyB+UR/NH17XBSLNwKSpJNbFFQQco/4loyCYV+qbtJmoaQWbSy+9lFtvvZVjx44BUF9fz7Zt27j88suzWriZrrM3yqHjQ2cDHaxup7EtwsJZvpwai0nG57KwcmEYxzAD/FajytKKYGKAdoDTZmJOsWdKBhoAk0HDNo6dT0vCLj6+uGDYsYNkZhe6WTwnL62L4ljEYgKv3cTHFxeQ78/8WqKCPDufWFbEOYsLyPPasp6nzWUffkHkAJX4thVnzMs/Me6V3fKMJBYTBLzxXWH9rpH3YzqdEOC0GuKTESZBWsHmpptuorCwkLVr19Le3s4ll1xCMBjkH//xH7NdvhlL1VSO1nYMmuoI0NbVx3tHWgj5bJTkT1xeo7EKeKycdWKQergvh64LAm4zVbN8ifsUBRaU+7GZpu4YgVFTxtwCyPfbWFyeh0GBBbP8eNKYbBDOs7Nglp9s/2bVdYHVqHJWVYjZhZ6MbbrmdphZUhHEbFAIea2csyjEuUsKCfntWVt4nOexYjYk/4sNXJx9OdS6tpoMlIRcWMb43dBjglnhk7nXJlJa7XyTycTmzZvZvHkzzc3NeL3eKblWYyqJ9EU5Wjs46Wl8cWYDRoPKkjn+nP8MzCaNZfOCWI1qyoHMgS9AU2sP1Y1dFASdhLzpbwOQi+KpXywcYnR7DnmcZs6ozMeoxi92ZoPKssogr7xdTV//8GMlboeZJXMDGNSJGSMSAjQFFs/x47AZ+duHjeP6rKxmAyuq8rEa1Xi3khCoQMBtwefKp7Wrnw+OtlDb3JXRc6Ig4BhxzZbQSbFxxcQzqAoFeXYMqjrmSTPWE1OhJ/rqkTLYJEvxf2pm5VOzLkuZoWkq1fWdQ8Zq3v+ojfaufs6cF8Q8BTIA5HmsOCzGtAYxNQUWzQnQ268z/8S00dz5io+ergvco5z+bLcaOXN+KHHRHXgdr93Mojl5vPle3ZBgYjUbWF6Vn7TlmFW6oLzAhd1iZM/+uiGt8HQYNJVl84KDxvISL68LFMBnN3Hm/Hw6u/v5sLqN4w2d456kYLMYcFiNk941NlqxmE6e20I0yQ+PfaFoJgAAGidJREFUdF8j7LfREZnYiR4pg83q1asTv56H+2WqKEpWthiY6SLR2JCxmrauPg581Ephnp1wFvrLs6E05Er7p7YQ4LDEL5wOi5bW+oFcZzKomIxa0hbJqSwmjTPnh4ZduKrrOsUBB83tEQ4dP9lSMmgqZ8wL4hnmQj1RhC4o8NuIzPKzZ3/9qJ47kKQy5LWm/LyFEHDi/Fg6N4+5JV6O1XVwZJjJM+nyuCxYjVrOZ6MYzngCzQBNUfC5zIjoxAWclMGmsrKS3t5errrqKtauXUswGJyocs1YqqrQ0NhNW+fJdTW6Lnjr/UaMBpWFs30pnp07bBYDbod5VBfBWEzHYZ4egQbAqKnYLIYRg43RoHLGvHz8TlPybiIhqCrz0doeoaWjF0WBRXPzyB/hQj0RYjGdPI8VVVHQR9FUmFPspSzfOary6zGB1aBSVeKhLOyipqmLv77fMOrutcI8B6PLqTC9CCHwuiw0NY09g/xopRxleuaZZ3jggQdobW1lw4YNfOlLX2Lnzp309/ejaRqalvtdOVNNVBd8cFo+qg+Ot9HW1cficv+kdp+ZTVra03kDXtuYBvhzZSA2E0xGBXsaM9IWzw0QOm2r5uFYDCpLK+NdqHNLfJSO8kKdTWaDisOW/uy7gjw780pH3m47mVhMYFIVZuU7KRrllg5Gg4pvDLO5phslw9PjRzLi1aCiooJbb72VF198keuvv56XX36Zc889l7/97W8TUb4ZRVXj+9W0tJ3Mgdbe1cf+Y60U5Nko8E/8PiNGg0q+386K+SFWLS9m+bxgWut6SkIupmAPRWYJBc8ImR2cNhMhny2tC198/MbE8vn5VJZ4BmUTnmxmo5Z21gSzSWPhnPhsu/ESQjC32DOq7AYuh3nMs7mksUt71dnhw4d54403eOutt6iqqhqUnFPKDF0IPjjWmmjc60Lw1gfx7rNFs/0TVg5FiSdwLA46yPfZsZo1VOIXO6fLStBnozbFdrNOmwnXKFJpTFe6ro+YIy3os6WVTPHkawrC3tRp5SeDEIJQnn3IDMrh+FwW7ObhMxyP/n3BZTNSEnZx8Fh6Garje8CMfTaXNDYpg01rays7d+7kl7/8JV1dXaxbt47HHntMzkDLAkWBlq5+6ltO7ldz8HgbrZ19rKgMjKv7TDmR8jedr7ZyYlbY7LALTVXiX0hdMPC1tJgNVJR4qWvqStoEz/fbsRi1Gf9lFgLsFmP875jkwlqU70w75ciAXPy76rrA4zBj0FSiI5QvnOcYdRbqlO8dE5QXuvmormPEWWrp7AEjZUfKYHPeeedRVFTEunXrWLJkCQBHjhzhyJEjicd87GMfy24JZwpF4YOPWhPdKR3dfew/2krYb6Mgb+zdZwGvjfmzfHRHorz9fj19/cm/ZIoCC8sDlBe4ELpIOobgdZgJem3UDbORm6JAcf7I6xdmCu3E3jadw8yactpNOCwjJ2ycKsxGFafNmHIvGIOmkucZmsxyvBwWA7PCbt5Lkh19gNNmwjoFlg1MRymDTSAQoLe3l6eeeoqnnnpqyHFFUXjxxRezVrjpRtPiixuH+6J19EQTXVNdPf289rc6DJrK4jF2n7nsJuaV+eJdBgrkuSxYzIZhN3qCgc2e8igvdI3YvaEpMLfES31L95ALpctuxj6NLqDjZTaqWC3GYYNNvm96tQBNWnzPlVTBJp5lOfPjJXpMUFbg4khdOz2RaNLH5fvsmEfRbSllTspg89JLL01UOcbl0KFD3HbbbbS2tuLxeNixYwdlZWWTXawEVVXojekcrmnHbNRw2U0YDSoWo5ZYxfvh8WaiMZ3Onn5e3VuLrgs+tiB/1PuHW0wac4q9lIaciQtZPHbEN3o6Z3EBf3mvnua2kxs9KQpUzfIzp8id1qBzfHW8Gb/HRmPL4NZNOC9+AY3KLzMQb9m4HWYaTvs7KUBRcHq1AHVdEPLbU+7uGfLbMWrZGS+xmTXKCz1Jt3WeVehmXqlXBppJMr60tDli69atbNiwgXXr1vHMM8+wZcsWfvzjH092seIp5lGobe3hbwebaDuxp7uqKNisBhxWEz63BYfVxPH6jsGBZmEI9yhya1nMBoqCTsoL3Tgs8a1oT/9Cx2ICh9nAxxaGePuDRj6q60AB5pX5qSga3ewmg6pQUewZFGxUVaEo6JCB5hQDgfl0Trtp2rUAhRA4bUZMRnXY7tpsj5foMUFJvpPD1W2DWpKKEt+Ar7LEizKd/uBTzJQPNk1NTbz77rv88Ic/BGDNmjVs376d5uZmfL7JWwCpaSrtPf28d7iZj+o7Bl1UdCHo7O6ns7uf2qZ411lHdx+v7q1DIDhnYQhXmoHGZTdRFnZREHBgO7EgMtWXWQiBUVU4oyKA3WJEVRjTNFpdF+S5LfhclsR21R6nGds40+pPN7oucDqGfpbTrQttgNmo4rSbaTpli+QBLrspZZblTLCaVOaUeHnrRDYDTVVYUJ7H7AJXTk0Vn4mm/JWhpqaG/Pz8xAJTTdMIBoPU1NRMWrCJAfuPNPPWgQaa2yN09vTT2RNFUeKD6x6nGZfNmEgFFA808U2azlkYwjVCRlZFgTyPjfIiN363BYvhRHfZKBb4qUBVqTc+I2iMX0KDqjC3xMvre+O58goDjqx1kUxlJk3FYtISucMUBYqm6SQKo6YS8FiHDTZ5HhvmLAfYWExQlGfn0HET3ZEoSyuCFAftObP4dSab8sEmE/z+safqDwQGr17+fy/s57lXDtPSHhk0tdNyIlHi0bp4egiDpuB1WfC7LByqaUdRFC5cUYzbkXpdhqYqLJkboCTkHNd+KeNxap1NFhNH6zvpivQzq9CDzzfxC08nwumf82h0R/rxee2JblSnzUjQb8dlH12izok21jqXRGIcaxi6Dmt2sXfCzo/FFVGMRpWykAtNS29Cwng+46lqIus85YNNOBymrq6OWCyGpmnEYjHq6+sJh8Npv0ZTU+eYpmIGAk4aGk5usarrgp+9+D52q5G5xW4cFiMOqxG71YjREJ+J1hWJ0trRS0tnLy0dvRw42oLJqHHOghAGBbq6ks/kGVgDE3Ca6OqI0NURSfrYbDm9zpqmUHhiMZ8ixKBj08XpdR4tzaCiIRKfbaHfRrS3n4buvhGeOXnGU2dNEcSiMSK9J2eF2SwGDAoTdn7kOU2oCjQ3J198fKrxfsZT0XjqrKrKqH+kT/lg4/f7qaqq4tlnn2XdunU8++yzVFVVTUoX2tH6+GZn5y4Ox1PrnzYYqSgKDms8ABUF4x9UTBcoCmltEDW32MvssCuncjrFYoJ8nw2jpmJQITZ9tqfPnBNJD4/VdcS70ILOnPoMM81i1HDZzYOCjc9lwWrSRr2AdayELpCnYm6Z8sEG4J//+Z+57bbbeOihh3C5XOzYsWNSyrH/aHzK5wVnFOGym6lv6aa6sZO2jl76k8zQ0tLIMwZQnO8cV+LCbLIYVPJ9IyeSnKl0XSR223TZzdgsk7/FcDapikK+z0r9Ka2KwqAzJ89daeJMi2BTXl7OT3/608kuBgeOtZLnthD221AEuAvdzA676OmP0dLRS3V9B+1dfXRF+kd1YQ54bCyek5feHt6TQE4ISE2I+CZnBk0lNAPWIcViOgHvyT2XTEYVj3N0201I08+0CDa5QBeCA8daqSrzYdRUotGT61ysBhW730ZxwEZvv05fVNDV009TWw9NbRG6I/10R/qH/eHnsps4Y14Qkzax6cClzDKoCnarkaLAzFiHZDFq2K1Gunr68TjjG5XJE3hmk8EmQ443dNEViVJR4hm21aLrAnQwKAoGo4LdZCHssxLTBb39Ov0nsge0dsQ3x+ruiQefFfND2M2TsOWvlFFmY7xVk+5+QFOdxajhtpvp6uknnGc/kdRVnsMz2cw48yfA/qMtACyY5U8rtb4Qgmg0/jiTpmDSNBxmAwU+GwLo648REwzaj16aulRFIei1YTGqM6JloyiCfL+NuuYugjm4JYI08WSwyZADH7XhdZoJ+Wxj7i4Q4mSmZYOqYGB67Vw5kw1kXJgJgQbisxT9bisepwWLzLIskcZOndLIxInxmrKwC6OWge0HpWlH18WMy8tlNqqUhl2Ys5DlWZp65FmQATVN3bR39TG3ePjxGkmCmddKtRg1/G6L7EKTABlsMmL/ie1oF8zyzfitkCVpgBACt90oJ6FJgByzyYj3j7Xispso8NtGfrAkzRC6PvxGgdLMJFs24ySE4L2j8fEak0EOhEqSJA1HBptxqm/tobWzl7lFHtmFJkmSlIQMNuN04EQ+tPmzfbLLQJIkKQkZbMbpwEet8SzOedNzHxdJkqRMkMFmnPYfbaU07MSS5e1uJUmSpjIZbMahvrmbxrZIfLxGdqFJkiQlJYPNOOz9sAmAqjI5XiNJkpSKDDbjsPdgI1azgdLQ6LZHlSRJmmlksBmHvR82URZ2YjXKtbGSJEmp5MRV8q677uJ///d/MZlM2Gw2Nm/ezKJFiwDYuHEj1dXVOBzx1sNnP/tZPvWpTwFw6NAhbrvtNlpbW/F4POzYsYOysrIJKXNLRy81jV0srwzI9TWSJEkjyIlgc/7553PHHXdgNBrZtWsXN910Ey+88ELi+Le//W1WrVo15Hlbt25lw4YNrFu3jmeeeYYtW7bw4x//eELKfOBEPrT5crxGkiRpRDnRjbZq1SqMRiMAS5cupba2Fl1PnSm2qamJd999lzVr1gCwZs0a3n33XZqbm7NeXogn37SYNMrCzgl5P0mSpKksJ4LNqR5//HEuuOACVPVk0e69916uuOIKbr75Zurq6gCoqakhPz8fTYuvb9E0jWAwSE1NzYSUs7api4oSL3ZLTjQOJUmSctqEXCmvuuoqqqurhz326quvJgLGzp07+fWvf83jjz+eOH7vvfcSDoeJxWL84Ac/4Bvf+AZPPPFERsvn949+NtnNG88k0hvF5515M9ECgZnXmpN1nv5mWn1hYuusiBwZ3f7973/Pjh07ePTRRykqKhr2MZ2dnZx11lns3buXlpYWLrnkEl5//XU0TSMWi3H22Wfz/PPP4/P5RvXeTU2dYxp38XhttLZ0j/p5U1kg4KShoWOyizGhZJ2nv5lWXxhfnVVVGfWP9JzoRtu1axf33HMPDz/88KBAE41GaWxsTNzeuXMnFRUVqKqK3++nqqqKZ599FoBnn32WqqqqUQea8TDKLQUkSZLSkhMtm5UrV2I0GgcFikcffRSz2cx1111Hf38/AMFgkM2bNzN79mwADh48yG233UZ7ezsul4sdO3Ykjo3GWFs28tfQzCDrPP3NtPrCxLdsciLYTDYZbNIn6zwzzLQ6z7T6wgztRpMkSZKmNxlsJEmSpKyTwUaSJEnKOhlsJEmSpKyTwUaSJEnKOplrhfjMisl47lQl6zwzzLQ6z7T6wtjrPJbnyanPkiRJUtbJbjRJkiQp62SwkSRJkrJOBhtJkiQp62SwkSRJkrJOBhtJkiQp62SwkSRJkrJOBhtJkiQp62SwkSRJkrJOBhtJkiQp62SwGYNDhw5xzTXXcMkll3DNNddw+PDhyS7SqLW0tPAP//APXHLJJVxxxRV85Stfobm5GYC33nqLtWvXcskll/CFL3yBpqamxPNSHausrKSrqwuA5uZmrrrqKu67776JrViavv/971NZWcmBAweA6V3n3t5etm7dysUXX8wVV1zBnXfeCaQ+j1MdW716deLv1tPTwxe/+EVuv/12YrHYRFYrpV27dnHllVeybt06rrjiCp5//nlgetd5ODt27GD16tWDznWI1+fcc88dVP6f//znVFZW8thjj2WnMEIatY0bN4qnn35aCCHE008/LTZu3DjJJRq9lpYW8dprryVuf/e73xW333670HVdXHTRReKNN94QQgjx4IMPittuu00IIVIeE0KIiooK0dnZKWpqasSll14qHn744QmsUfr27t0rvvjFL4oLLrhA7N+/f9rXefv27eI73/mO0HVdCCFEQ0ODECL1eZzq2KpVq8T+/ftFe3u7uPbaa8X27dsTr50LdF0XK1asEPv37xdCCLFv3z6xdOlSEYvFpm2dk3njjTdEdXV1ovwDVq1aJa688krx8ssvJ+677rrrxFVXXSV+8pOfZKUsMtiMUmNjo1i+fLmIRqNCCCGi0ahYvny5aGpqmuSSjc9vf/tb8bnPfU68/fbb4vLLL0/c39TUJJYuXSqEECmPCRG/8L777rviwgsvFE899dTEFX4Uent7xWc+8xlx9OjRxBdwOte5s7NTLF++XHR2dg66P9V5PNI5vmrVKvHqq6+KdevWifvvv39iK5QGXdfFWWedJXbv3i2EEOL//u//xMUXXzyt6zyS4YLNj370I/G1r31NCCHE0aNHxac+9Slx6623Zi3YyKzPo1RTU0N+fj6apgGgaRrBYJCamhp8Pt8kl25sdF3niSeeYPXq1dTU1FBQUJA45vP50HWd1tbWlMc8Hg8A119/PbfccgtXX331hNcjHf/+7//O2rVrKS4uTtw3net87NgxPB4P3//+93n99dex2+18/etfx2KxJD2PhRAjnuPf+MY32LBhA1//+tcnrW7JKIrC/fffz4033ojNZqOrq4sf/OAHKb+7U73OY3H22WfzP//zP7S1tfHLX/6SK6+8kr1792bt/eSYjcT27dux2Wxcd911436tCy64gJ/97Gd0dnZmoGSZtWfPHt555x02bNiQ0dfN5TpHo1GOHTvG/Pnz+cUvfsHNN9/MV7/6Vbq7u8f1up/4xCd47rnnqK+vz1BJMycajfKDH/yAhx56iF27dvGf//mf3HTTTdO6zmOhKAqXXXYZO3fu5LnnnuPyyy/P6vvJYDNK4XCYurq6xMBaLBajvr6ecDg8ySUbmx07dnDkyBHuv/9+VFUlHA5TXV2dON7c3IyiKHg8npTHBtx5551UVFSwadOmnLv4vvHGG3z44YdceOGFrF69mtraWr74xS9y5MiRaVvngoICDAYDa9asAWDJkiV4vV4sFkvS8zidc3zTpk2sX7+ejRs35tzFd9++fdTX17N8+XIAli9fjtVqxWw2T9s6j9X69et54IEHqKiowOv1ZvW9ZLAZJb/fT1VVFc8++ywAzz77LFVVVVOyC+2+++5j7969PPjgg5hMJgAWLlxIJBJh9+7dADz55JNcdtllIx4boCgKd911V05efL/0pS/x5z//mZdeeomXXnqJUCjEww8/zKZNm6ZtnX0+H2effTavvPIKEJ9x1dTURFlZWdLzON1z/IYbbuCqq67KuYtvKBSitraWDz/8EICDBw/S2NhIaWnptK3zWBUXF3PTTTdx4403Zv/NsjISNM198MEH4uqrrxYXX3yxuPrqq8XBgwcnu0ijduDAAVFRUSEuvvhisXbtWrF27Vpx4403CiGE+Mtf/iLWrFkjPvnJT4rrr78+MXtppGMDM7OEiA/Sfvvb3xbXXHON6OjomNjKpenUQdPpXOejR4+K6667TqxZs2bQDKRU53GqY6cPNj/00EPi4osvFrW1tRNXqRE888wzYs2aNeKKK64QV1xxhfj9738vhJjedR7O9u3bxXnnnSeqqqrEOeecI/7u7/5OCDG0PgOyOUFA7tQpSZIkZZ3sRpMkSZKyTgYbSZIkKetksJEkSZKyTgYbSZIkKetksJEkSZKyTgYbSZqili1bxrFjxya7GJKUFhlsJGmMVq9ezauvvsovfvEL/v7v/z6r77Vx40Z++tOfDrpvz549g3K8SVIuk8FGkiZZNBqd7CJIUtbJYCNJ43Dw4EG2bt3KW2+9xbJly1ixYgUAfX197NixgwsuuIBzzjmHLVu2EIlEAHj99dc5//zz+e///m8+/vGPc/vtt9PW1sYNN9zAypUrOfPMM7nhhhuora0F4mmFdu/ezbZt21i2bBnbtm0D4hu3HTlyBICOjg6+9a1vsXLlSlatWsVDDz2ErusAiZbXjh07OPPMM1m9ejV/+MMfJvpPJc1wMthI0jiUl5dz1113sXTpUvbs2ZPIofav//qvHDp0iKeffprnn3+e+vp6HnzwwcTzGhsbaWtrY9euXWzfvh1d11m/fj27du1i165dmM3mRFC56aabWLFiBVu2bGHPnj1s2bJlSDm2b99OR0cHL7zwAj/5yU945pln+PnPf544/te//pVZs2bx2muvsWnTJjZv3oxMHiJNJBlsJCnDhBD89Kc/5Y477sDj8eBwOLjhhhvYuXNn4jGqqvK1r30Nk8mExWLB6/VyySWXYLVacTgcfPnLX+aNN95I6/1isRjPPfcc3/zmN3E4HBQVFfH5z3+eX/3qV4nHFBQU8JnPfAZN07jqqqtoaGigsbEx43WXpGTk5mmSlGHNzc309PSwfv36xH1CiES3FoDX68VsNidu9/T0cM899/CnP/2JtrY2ALq6uojFYokNvZJpaWmhv79/0CZvBQUF1NXVJW7n5eUl/m+1WgHGvb+LJI2GDDaSNE6Kogy6PbBfzM6dO8nPz0/rOY888giHDh3iqaeeIhAIsG/fPq688sq0urq8Xi9Go5Hq6mrmzJkDnNxRVpJyhexGk6Rx8vv91NXV0dfXB8S7yD796U9z991309TUBEBdXR1/+tOfkr5GV1cXZrMZl8tFa2sr3//+9wcdz8vLS7qmRtM0Lr30Uu677z46Ozs5fvw4P/zhD1m7dm2GaihJ4yeDjSSN08qVK5kzZw7nnnsuZ599NgC33HILpaWlfOYzn+GMM87g+uuv59ChQ0lf43Of+xy9vb2sXLmSa665hvPOO2/Q8c9+9rP87ne/48wzz+Rf/uVfhjz/zjvvxGq1ctFFF7FhwwbWrFnDpz71qcxWVJLGQe5nI0mSJGWdbNlIkiRJWSeDjSRJkpR1MthIkiRJWSeDjSRJkpR1MthIkiRJWSeDjSRJkpR1MthIkiRJWSeDjSRJkpR1MthIkiRJWff/ASP41/oZzSPtAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot = CurvePlot()\n", + "plot.add('VPG', y_values, xvalues=x_values)\n", + "ax = plot(title=f'VPG on {env_id}', \n", + " xlabel='Iteration', \n", + " ylabel='Mean Episode Reward', \n", + " num_tick=6, \n", + " xscale_magnitude=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "ax.figure.savefig('data/result.png')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/lagom/agents/a2c_agent.py b/lagom/agents/a2c_agent.py index db7985bf..9d878bc3 100644 --- a/lagom/agents/a2c_agent.py +++ b/lagom/agents/a2c_agent.py @@ -57,7 +57,6 @@ def learn(self, D): for segment in D: # iterate over segments # Get all boostrapped discounted returns as estimate of Q Qs = segment.all_bootstrapped_discounted_returns - # Standardize: encourage/discourage half of performed actions if self.config['agent.standardize_Q']: Qs = Standardize()(Qs).tolist() @@ -69,6 +68,9 @@ def learn(self, D): # Advantage estimates As = [Q - V.item() for Q, V in zip(Qs, Vs)] + # Standardize advantage: encourage/discourage half of performed actions + if self.config['agent.standardize_adv']: + As = Standardize()(As).tolist() # Get all log-probabilities and entropies logprobs = segment.all_info('action_logprob') diff --git a/lagom/agents/vpg_agent.py b/lagom/agents/vpg_agent.py index 7c6cf848..b2bbb41d 100644 --- a/lagom/agents/vpg_agent.py +++ b/lagom/agents/vpg_agent.py @@ -41,7 +41,6 @@ def learn(self, D): for trajectory in D: # iterate over trajectories # Get all discounted returns as estimate of Q Qs = trajectory.all_discounted_returns - # Standardize: encourage/discourage half of performed actions if self.config['agent.standardize_Q']: Qs = Standardize()(Qs).tolist() @@ -53,6 +52,9 @@ def learn(self, D): # Advantage estimates As = [Q - V.item() for Q, V in zip(Qs, Vs)] + # Standardize advantage: encourage/discourage half of performed actions + if self.config['agent.standardize_adv']: + As = Standardize()(As).tolist() # Get all log-probabilities and entropies logprobs = trajectory.all_info('action_logprob')