diff --git a/.gitignore b/.gitignore index 76454ef..b77605b 100644 --- a/.gitignore +++ b/.gitignore @@ -6,7 +6,12 @@ gen .gitignore # Jupyter Notebook -/fast_rl/notebooks/.ipynb_checkpoints/ +*/.ipynb_checkpoints/* # Data Files -/docs_src/data/* \ No newline at end of file +#/docs_src/data/* + +# Build Files / Directories +build/* +dist/* +fast_rl.egg-info/* \ No newline at end of file diff --git a/README.md b/README.md index 4752e34..59d4d0c 100644 --- a/README.md +++ b/README.md @@ -20,9 +20,6 @@ However there are also frameworks in PyTorch most notably Facebook's Horizon: - [Horizon](https://github.com/facebookresearch/Horizon) - [DeepRL](https://github.com/ShangtongZhang/DeepRL) -Our motivation is that existing frameworks commonly use tensorflow, which nothing against tensorflow, but we have -accomplished more in shorter periods of time using PyTorch. - Fastai for computer vision and tabular learning has been amazing. One would wish that this would be the same for RL. The purpose of this repo is to have a framework that is as easy as possible to start, but also designed for testing new agents. @@ -72,141 +69,28 @@ working at their best. Post 1.0.0 will be more formal feature development with C **Critical** Testable code: ```python -from fast_rl.agents.DQN import DQN -from fast_rl.core.basic_train import AgentLearner -from fast_rl.core.MarkovDecisionProcess import MDPDataBunch - -data = MDPDataBunch.from_env('maze-random-5x5-v0', render='human') -model = DQN(data) -learn = AgentLearner(data, model) -learn.fit(450) -``` -Result: - -| ![](res/pre_interpretation_maze_dqn.gif) | -|:---:| -| *Fig 1: We are now able to train an agent using some Fastai API* | - - -We believe that the agent explodes after the first episode. Not to worry! We will make a RL interpreter to see whats -going on! - -- [X] 0.2.0 AgentInterpretation: First method will be heatmapping the image / state space of the -environment with the expected rewards for super important debugging. In the code above, we are testing with a maze for a -good reason. Heatmapping rewards over a maze is pretty easy as opposed to other environments. - -Usage example: -```python -from fast_rl.agents.DQN import DQN -from fast_rl.core.Interpreter import AgentInterpretationAlpha -from fast_rl.core.basic_train import AgentLearner -from fast_rl.core.MarkovDecisionProcess import MDPDataBunch - -data = MDPDataBunch.from_env('maze-random-5x5-v0', render='human') -model = DQN(data) -learn = AgentLearner(data, model) -learn.fit(10) - -# Note that the Interpretation is broken, will be fixed with documentation in 0.9 -interp = AgentInterpretationAlpha(learn) -interp.plot_heatmapped_episode(5) -``` - -| ![](res/heat_map_1.png) | -|:---:| -| *Fig 2: Cumulative rewards calculated over states during episode 0* | -| ![](res/heat_map_2.png) | -| *Fig 3: Episode 7* | -| ![](res/heat_map_3.png) | -| *Fig 4: Unimportant parts are excluded via reward penalization* | -| ![](res/heat_map_4.png) | -| *Fig 5: Finally, state space is fully explored, and the highest rewards are near the goal state* | - -If we change: -```python -interp = AgentInterpretationAlpha(learn) -interp.plot_heatmapped_episode(epoch) -``` -to: -```python -interp = AgentInterpretationAlpha(learn) -interp.plot_episode(epoch) -``` -We can get the following plots for specific episodes: - -| ![](res/reward_plot_1.png) | -|:----:| -| *Fig 6: Rewards estimated by the agent during episode 0* | - -As determined by our AgentInterpretation object, we need to either debug or improve our agent. -We will do this in parallel with creating our Learner fit function. - -- [X] 0.3.0 Add DQNs: DQN, Dueling DQN, Double DQN, Fixed Target DQN, DDDQN. -- [X] 0.4.0 Learner Basic: We need to convert this into a suitable object. Will be similar to the basic fasai learner -hopefully. Possibly as add prioritize replay? - - Added PER. -- [X] 0.5.0 DDPG Agent: We need to have at least one agent able to perform continuous environment execution. As a note, we -could give discrete agents the ability to operate in a continuous domain via binning. - - [X] 0.5.0 DDPG added. let us move - - [X] 0.5.0 The DDPG paper contains a visualization for Q learning might prove useful. Add to interpreter. - -| ![](res/ddpg_balancing.gif) | -|:----:| -| *Fig 7: DDPG trains stably now..* | - - -Added q value interpretation per explanation by Lillicrap et al., 2016. Currently both models (DQN and DDPG) have -unstable q value approximations. Below is an example from DQN. -```python -interp = AgentInterpretationAlpha(learn, ds_type=DatasetType.Train) -interp.plot_q_density(epoch) -``` -Can be referenced in `fast_rl/tests/test_interpretation` for usage. A good agent will have mostly a diagonal line, -a failing one will look globular or horizontal. - -| ![](res/dqn_q_estimate_1.jpg) | -|:----:| -| *Fig 8: Initial Q Value Estimate. Seems globular which is expected for an initial model.* | - -| ![](res/dqn_q_estimate_2.jpg) | -|:----:| -| *Fig 9: Seems like the DQN is not learning...* | - -| ![](res/dqn_q_estimate_3.jpg) | -|:----:| -| *Fig 10: Alarming later epoch results. It seems that the DQN converges to predicting a single Q value.* | - -- [X] 0.6.0 Single Global fit function like Fastai's. Think about the missing batch step. Noted some of the changes to -the existing the Fastai - -| ![](res/fit_func_out.jpg) | -|:----:| -| *Fig 11: Resulting output of a typical fit function using ref code below.* | - -```python -from fast_rl.agents.DQN import DuelingDQN -from fast_rl.core.Learner import AgentLearner -from fast_rl.core.MarkovDecisionProcess import MDPDataBunch - - -data = MDPDataBunch.from_env('maze-random-5x5-v0', render='human', max_steps=1000) -model = DuelingDQN(data) -# model = DQN(data) -learn = AgentLearner(data, model) - -learn.fit(5) +from fast_rl.agents.dqn import * +from fast_rl.agents.dqn_models import * +from fast_rl.core.agent_core import ExperienceReplay, GreedyEpsilon +from fast_rl.core.data_block import MDPDataBunch +from fast_rl.core.metrics import * + +data = MDPDataBunch.from_env('CartPole-v1', render='rgb_array', bs=32, add_valid=False) +model = create_dqn_model(data, FixedTargetDQNModule, opt=torch.optim.RMSprop, lr=0.00025) +memory = ExperienceReplay(memory_size=1000, reduce_ram=True) +exploration_method = GreedyEpsilon(epsilon_start=1, epsilon_end=0.1, decay=0.001) +learner = dqn_learner(data=data, model=model, memory=memory, exploration_method=exploration_method) +learner.fit(10) ``` -reset commit - - [X] 0.7.0 Full test suite using multi-processing. Connect to CI. - [X] 0.8.0 Comprehensive model eval **debug/verify**. Each model should succeed at at least a few known environments. Also, massive refactoring will be needed. -- [ ] **Working on** 0.9.0 Notebook demonstrations of basic model usage. -- [ ] **1.0.0** Base version is completed with working model visualizations proving performance / expected failure. At +- [X] 0.9.0 Notebook demonstrations of basic model usage. +- [ ] **Working on** **1.0.0** Base version is completed with working model visualizations proving performance / expected failure. At this point, all models should have guaranteed environments they should succeed in. -- [ ] 1.2.0 Add PyBullet Fetch Environments - - [ ] 1.2.0 Not part of this repo, however the envs need to subclass the OpenAI `gym.GoalEnv` - - [ ] 1.2.0 Add HER +- [ ] 1.8.0 Add PyBullet Fetch Environments + - [ ] 1.8.0 Not part of this repo, however the envs need to subclass the OpenAI `gym.GoalEnv` + - [ ] 1.8.0 Add HER ## Code diff --git a/azure-pipelines.yml b/azure-pipelines.yml index c6d4f90..d28958f 100644 --- a/azure-pipelines.yml +++ b/azure-pipelines.yml @@ -3,43 +3,42 @@ # Add steps that build, run tests, deploy, and more: # https://aka.ms/yaml +# - bash: "sudo apt-get install -y xvfb freeglut3-dev python-opengl --fix-missing" +# displayName: 'Install ffmpeg, freeglut3-dev, and xvfb' + trigger: - master -pool: - vmImage: 'ubuntu-18.04' - -steps: - -#- bash: "sudo apt-get install -y ffmpeg xvfb freeglut3-dev python-opengl" -# displayName: 'Install ffmpeg, freeglut3-dev, and xvfb' - -- task: UsePythonVersion@0 - inputs: - versionSpec: '3.7' - -# - script: sh ./build/azure_pipeline_helper.sh -# displayName: 'Complex Installs' - -- script: | - # pip install Bottleneck - # python setup.py install - pip install pytest - pip install pytest-cov - displayName: 'Install Python Packages' - -- script: | - xvfb-run -s "-screen 0 1400x900x24" pytest tests --doctest-modules --junitxml=junit/test-results.xml --cov=./ --cov-report=xml --cov-report=html - displayName: 'Test with pytest' - -- task: PublishTestResults@2 - condition: succeededOrFailed() - inputs: - testResultsFiles: '**/test-*.xml' - testRunTitle: 'Publish test results for Python $(python.version)' - -- task: PublishCodeCoverageResults@1 - inputs: - codeCoverageTool: Cobertura - summaryFileLocation: '$(System.DefaultWorkingDirectory)/**/coverage.xml' - reportDirectory: '$(System.DefaultWorkingDirectory)/**/htmlcov' \ No newline at end of file +jobs: +- job: 'Test' + pool: + vmImage: 'ubuntu-16.04' # other options: 'macOS-10.13', 'vs2017-win2016' + strategy: + matrix: + Python36: + python.version: '3.6' + steps: + - task: UsePythonVersion@0 + inputs: + versionSpec: '$(python.version)' + + - bash: "sudo apt-get install -y freeglut3-dev python-opengl" + displayName: 'Install freeglut3-dev' + + - script: | + python -m pip install --upgrade pip setuptools wheel pytest pytest-cov -e . + python setup.py install + displayName: 'Install dependencies' + + - script: sh ./build/azure_pipeline_helper.sh + displayName: 'Complex Installs' + + - script: | + xvfb-run -s "-screen 0 1400x900x24" py.test tests --cov fast_rl --cov-report html --doctest-modules --junitxml=junit/test-results.xml --cov=./ --cov-report=xml --cov-report=html + displayName: 'Test with pytest' + + - task: PublishTestResults@2 + condition: succeededOrFailed() + inputs: + testResultsFiles: '**/test-*.xml' + testRunTitle: 'Publish test results for Python $(python.version)' \ No newline at end of file diff --git a/build/azure_pipeline_helper.sh b/build/azure_pipeline_helper.sh index 2eaecba..8701eef 100755 --- a/build/azure_pipeline_helper.sh +++ b/build/azure_pipeline_helper.sh @@ -1,14 +1,14 @@ #!/usr/bin/env bash -# Install pybullet -git clone https://github.com/benelot/pybullet-gym.git -cd pybullet-gym -pip install -e . -cd ../ +## Install pybullet +#git clone https://github.com/benelot/pybullet-gym.git +#cd pybullet-gym +#pip install -e . +#cd ../ -# Install gym_maze -git clone https://github.com/MattChanTK/gym-maze.git -cd gym-maze -python setup.py install -cd ../ +## Install gym_maze +#git clone https://github.com/MattChanTK/gym-maze.git +#cd gym-maze +#python setup.py install +#cd ../ diff --git a/docs_src/data/cartpole_dddqn/dddqn_er_rms.pickle b/docs_src/data/cartpole_dddqn/dddqn_er_rms.pickle new file mode 100644 index 0000000..2e5f837 Binary files /dev/null and b/docs_src/data/cartpole_dddqn/dddqn_er_rms.pickle differ diff --git a/docs_src/data/cartpole_dddqn/dddqn_per_rms.pickle b/docs_src/data/cartpole_dddqn/dddqn_per_rms.pickle new file mode 100644 index 0000000..d2f1946 Binary files /dev/null and b/docs_src/data/cartpole_dddqn/dddqn_per_rms.pickle differ diff --git a/docs_src/data/cartpole_ddqn/ddqn_er_rms.pickle b/docs_src/data/cartpole_ddqn/ddqn_er_rms.pickle new file mode 100644 index 0000000..569eff2 Binary files /dev/null and b/docs_src/data/cartpole_ddqn/ddqn_er_rms.pickle differ diff --git a/docs_src/data/cartpole_ddqn/ddqn_per_rms.pickle b/docs_src/data/cartpole_ddqn/ddqn_per_rms.pickle new file mode 100644 index 0000000..f225cac Binary files /dev/null and b/docs_src/data/cartpole_ddqn/ddqn_per_rms.pickle differ diff --git a/docs_src/data/cartpole_dqn fixed targeting/dqn fixed targeting_er_rms.pickle b/docs_src/data/cartpole_dqn fixed targeting/dqn fixed targeting_er_rms.pickle new file mode 100644 index 0000000..d20df17 Binary files /dev/null and b/docs_src/data/cartpole_dqn fixed targeting/dqn fixed targeting_er_rms.pickle differ diff --git a/docs_src/data/cartpole_dqn fixed targeting/dqn fixed targeting_per_rms.pickle b/docs_src/data/cartpole_dqn fixed targeting/dqn fixed targeting_per_rms.pickle new file mode 100644 index 0000000..0bbd417 Binary files /dev/null and b/docs_src/data/cartpole_dqn fixed targeting/dqn fixed targeting_per_rms.pickle differ diff --git a/docs_src/data/cartpole_dqn/dqn_ExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/cartpole_dqn/dqn_ExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..5e5ba90 Binary files /dev/null and b/docs_src/data/cartpole_dqn/dqn_ExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/cartpole_dqn/dqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/cartpole_dqn/dqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..df00ea9 Binary files /dev/null and b/docs_src/data/cartpole_dqn/dqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/cartpole_dueling dqn/dueling dqn_er_rms.pickle b/docs_src/data/cartpole_dueling dqn/dueling dqn_er_rms.pickle new file mode 100644 index 0000000..86ba9b0 Binary files /dev/null and b/docs_src/data/cartpole_dueling dqn/dueling dqn_er_rms.pickle differ diff --git a/docs_src/data/cartpole_dueling dqn/dueling dqn_per_rms.pickle b/docs_src/data/cartpole_dueling dqn/dueling dqn_per_rms.pickle new file mode 100644 index 0000000..efbdb0e Binary files /dev/null and b/docs_src/data/cartpole_dueling dqn/dueling dqn_per_rms.pickle differ diff --git a/docs_src/data/halfcheetah_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/halfcheetah_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..efd2720 Binary files /dev/null and b/docs_src/data/halfcheetah_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/halfcheetah_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/halfcheetah_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..637927c Binary files /dev/null and b/docs_src/data/halfcheetah_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/lunarlander_dddqn/dddqn_ExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/lunarlander_dddqn/dddqn_ExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..f6b33ad Binary files /dev/null and b/docs_src/data/lunarlander_dddqn/dddqn_ExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/lunarlander_dddqn/dddqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/lunarlander_dddqn/dddqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..c48cfb5 Binary files /dev/null and b/docs_src/data/lunarlander_dddqn/dddqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/lunarlander_ddqn/ddqn_ExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/lunarlander_ddqn/ddqn_ExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..e262a94 Binary files /dev/null and b/docs_src/data/lunarlander_ddqn/ddqn_ExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/lunarlander_ddqn/ddqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/lunarlander_ddqn/ddqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..b644864 Binary files /dev/null and b/docs_src/data/lunarlander_ddqn/ddqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/lunarlander_dqn fixed targeting/dqn fixed targeting_ExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/lunarlander_dqn fixed targeting/dqn fixed targeting_ExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..a5fdff4 Binary files /dev/null and b/docs_src/data/lunarlander_dqn fixed targeting/dqn fixed targeting_ExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/lunarlander_dqn fixed targeting/dqn fixed targeting_PriorityExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/lunarlander_dqn fixed targeting/dqn fixed targeting_PriorityExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..bc9d798 Binary files /dev/null and b/docs_src/data/lunarlander_dqn fixed targeting/dqn fixed targeting_PriorityExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/lunarlander_dqn/dqn_ExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/lunarlander_dqn/dqn_ExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..37aaaa3 Binary files /dev/null and b/docs_src/data/lunarlander_dqn/dqn_ExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/lunarlander_dqn/dqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/lunarlander_dqn/dqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..0eead33 Binary files /dev/null and b/docs_src/data/lunarlander_dqn/dqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/lunarlander_dueling dqn/dueling dqn_ExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/lunarlander_dueling dqn/dueling dqn_ExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..ee01b79 Binary files /dev/null and b/docs_src/data/lunarlander_dueling dqn/dueling dqn_ExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/lunarlander_dueling dqn/dueling dqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/lunarlander_dueling dqn/dueling dqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..1cc9ddc Binary files /dev/null and b/docs_src/data/lunarlander_dueling dqn/dueling dqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/mountaincarcontinuous_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/mountaincarcontinuous_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..03fdb63 Binary files /dev/null and b/docs_src/data/mountaincarcontinuous_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/mountaincarcontinuous_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/mountaincarcontinuous_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..9814ca0 Binary files /dev/null and b/docs_src/data/mountaincarcontinuous_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/mujocoreach_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/mujocoreach_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..d90f0c3 Binary files /dev/null and b/docs_src/data/mujocoreach_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/mujocoreach_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/mujocoreach_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..72b1ee4 Binary files /dev/null and b/docs_src/data/mujocoreach_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/pendulum_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/pendulum_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..3117850 Binary files /dev/null and b/docs_src/data/pendulum_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/pendulum_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/pendulum_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..434bef7 Binary files /dev/null and b/docs_src/data/pendulum_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/walker2d_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/walker2d_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..60cb6ad Binary files /dev/null and b/docs_src/data/walker2d_ddpg/ddpg_ExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/data/walker2d_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle b/docs_src/data/walker2d_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..3b2244c Binary files /dev/null and b/docs_src/data/walker2d_ddpg/ddpg_PriorityExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/docs_src/rl.agents.dddqn.ipynb b/docs_src/rl.agents.dddqn.ipynb new file mode 100644 index 0000000..de2e0ec --- /dev/null +++ b/docs_src/rl.agents.dddqn.ipynb @@ -0,0 +1,636 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "from fast_rl.core.basic_train import AgentLearner\n", + "from fast_rl.agents.dqn import *\n", + "from fast_rl.agents.dqn_models import *\n", + "from fast_rl.core.train import AgentInterpretation, GroupAgentInterpretation\n", + "from fast_rl.core.data_block import MDPDataBunch\n", + "from fast_rl.core.agent_core import ExperienceReplay, GreedyEpsilon\n", + "from fastai.basic_data import DatasetType\n", + "from fast_rl.core.metrics import *\n", + "from fastai.gen_doc.nbdoc import *" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "

__init__[test]

\n", + "\n", + "> __init__(**\\*\\*`kwargs`**)\n", + "\n", + "
×

No tests found for __init__. To contribute a test please refer to this guide and this discussion.

\n", + "\n", + "Basic DQN Module. Args:\n", + " ni: Number of inputs. Expecting a flat state `[1 x ni]`\n", + " ao: Number of actions to output.\n", + " layers: Number of layers where is determined per element.\n", + " n_conv_blocks: If `n_conv_blocks` is not 0, then convolutional blocks will be added\n", + " to the head on top of existing linear layers.\n", + " nc: Number of channels that will be expected by the convolutional blocks. " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_doc(DoubleDuelingModule.__init__)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "model_dirs = ['data/cartpole_ddqn', 'data/cartpole_dddqn']\n", + "group_interp = GroupAgentInterpretation()\n", + "for model_dir in model_dirs:\n", + " for file in os.listdir(model_dir):\n", + " file = file.replace('.pickle', '')\n", + " group_interp.add_interpretation(GroupAgentInterpretation.from_pickle(model_dir, file))\n", + "group_interp.plot_reward_bounds(per_episode=True, smooth_groups=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model_dirs = ['data/cartpole_dueling dqn', 'data/cartpole_dddqn']\n", + "group_interp_2 = GroupAgentInterpretation()\n", + "for model_dir in model_dirs:\n", + " for file in os.listdir(model_dir):\n", + " file = file.replace('.pickle', '')\n", + " group_interp_2.add_interpretation(GroupAgentInterpretation.from_pickle(model_dir, file))\n", + "group_interp_2.plot_reward_bounds(per_episode=True, smooth_groups=10)\n", + "group_interp.add_interpretation(group_interp_2)" + ] + }, + { + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nameaveragemaxmintype
0(DDQN, ExperienceReplay_FEED_TYPE_STATE, reward)188.234590499.09.1reward
1(DDQN, ExperienceReplay_FEED_TYPE_STATE, reward)220.743902499.012.4reward
2(DDQN, ExperienceReplay_FEED_TYPE_STATE, reward)186.998891499.09.5reward
3(DDQN, ExperienceReplay_FEED_TYPE_STATE, reward)152.903104499.07.1reward
4(DDQN, ExperienceReplay_FEED_TYPE_STATE, reward)147.719512499.09.2reward
5(DDQN, PriorityExperienceReplay_FEED_TYPE_STAT...57.051663202.310.5reward
6(DDQN, PriorityExperienceReplay_FEED_TYPE_STAT...75.768736198.010.3reward
7(DDQN, PriorityExperienceReplay_FEED_TYPE_STAT...56.496674166.49.1reward
8(DDQN, PriorityExperienceReplay_FEED_TYPE_STAT...11.07405826.85.8reward
9(DDQN, PriorityExperienceReplay_FEED_TYPE_STAT...36.042572275.09.5reward
10(DDDQN, PriorityExperienceReplay_FEED_TYPE_STA...55.912860397.69.3reward
11(DDDQN, PriorityExperienceReplay_FEED_TYPE_STA...41.026608164.89.6reward
12(DDDQN, PriorityExperienceReplay_FEED_TYPE_STA...39.898004154.59.9reward
13(DDDQN, PriorityExperienceReplay_FEED_TYPE_STA...34.858980179.07.6reward
14(DDDQN, PriorityExperienceReplay_FEED_TYPE_STA...37.738359155.59.1reward
15(DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew...213.458093499.011.6reward
16(DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew...205.934368499.015.8reward
17(DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew...196.119734499.010.1reward
18(DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew...223.166962499.010.8reward
19(DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew...162.472949316.910.9reward
20(Dueling DQN, PriorityExperienceReplay_FEED_TY...37.997111137.111.7reward
21(Dueling DQN, PriorityExperienceReplay_FEED_TY...32.31197382.89.1reward
22(Dueling DQN, PriorityExperienceReplay_FEED_TY...27.884035131.65.9reward
23(Dueling DQN, PriorityExperienceReplay_FEED_TY...48.784701254.59.5reward
24(Dueling DQN, PriorityExperienceReplay_FEED_TY...55.326164243.49.7reward
25(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...258.565333499.013.9reward
26(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...269.299778499.016.0reward
27(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...154.370067499.010.5reward
28(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...141.921508252.610.2reward
29(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...168.225721499.012.8reward
30(DDDQN, PriorityExperienceReplay_FEED_TYPE_STA...55.912860397.69.3reward
31(DDDQN, PriorityExperienceReplay_FEED_TYPE_STA...41.026608164.89.6reward
32(DDDQN, PriorityExperienceReplay_FEED_TYPE_STA...39.898004154.59.9reward
33(DDDQN, PriorityExperienceReplay_FEED_TYPE_STA...34.858980179.07.6reward
34(DDDQN, PriorityExperienceReplay_FEED_TYPE_STA...37.738359155.59.1reward
35(DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew...213.458093499.011.6reward
36(DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew...205.934368499.015.8reward
37(DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew...196.119734499.010.1reward
38(DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew...223.166962499.010.8reward
39(DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew...162.472949316.910.9reward
\n", + "
" + ], + "text/plain": [ + " name average max \\\n", + "0 (DDQN, ExperienceReplay_FEED_TYPE_STATE, reward) 188.234590 499.0 \n", + "1 (DDQN, ExperienceReplay_FEED_TYPE_STATE, reward) 220.743902 499.0 \n", + "2 (DDQN, ExperienceReplay_FEED_TYPE_STATE, reward) 186.998891 499.0 \n", + "3 (DDQN, ExperienceReplay_FEED_TYPE_STATE, reward) 152.903104 499.0 \n", + "4 (DDQN, ExperienceReplay_FEED_TYPE_STATE, reward) 147.719512 499.0 \n", + "5 (DDQN, PriorityExperienceReplay_FEED_TYPE_STAT... 57.051663 202.3 \n", + "6 (DDQN, PriorityExperienceReplay_FEED_TYPE_STAT... 75.768736 198.0 \n", + "7 (DDQN, PriorityExperienceReplay_FEED_TYPE_STAT... 56.496674 166.4 \n", + "8 (DDQN, PriorityExperienceReplay_FEED_TYPE_STAT... 11.074058 26.8 \n", + "9 (DDQN, PriorityExperienceReplay_FEED_TYPE_STAT... 36.042572 275.0 \n", + "10 (DDDQN, PriorityExperienceReplay_FEED_TYPE_STA... 55.912860 397.6 \n", + "11 (DDDQN, PriorityExperienceReplay_FEED_TYPE_STA... 41.026608 164.8 \n", + "12 (DDDQN, PriorityExperienceReplay_FEED_TYPE_STA... 39.898004 154.5 \n", + "13 (DDDQN, PriorityExperienceReplay_FEED_TYPE_STA... 34.858980 179.0 \n", + "14 (DDDQN, PriorityExperienceReplay_FEED_TYPE_STA... 37.738359 155.5 \n", + "15 (DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew... 213.458093 499.0 \n", + "16 (DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew... 205.934368 499.0 \n", + "17 (DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew... 196.119734 499.0 \n", + "18 (DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew... 223.166962 499.0 \n", + "19 (DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew... 162.472949 316.9 \n", + "20 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 37.997111 137.1 \n", + "21 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 32.311973 82.8 \n", + "22 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 27.884035 131.6 \n", + "23 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 48.784701 254.5 \n", + "24 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 55.326164 243.4 \n", + "25 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 258.565333 499.0 \n", + "26 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 269.299778 499.0 \n", + "27 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 154.370067 499.0 \n", + "28 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 141.921508 252.6 \n", + "29 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 168.225721 499.0 \n", + "30 (DDDQN, PriorityExperienceReplay_FEED_TYPE_STA... 55.912860 397.6 \n", + "31 (DDDQN, PriorityExperienceReplay_FEED_TYPE_STA... 41.026608 164.8 \n", + "32 (DDDQN, PriorityExperienceReplay_FEED_TYPE_STA... 39.898004 154.5 \n", + "33 (DDDQN, PriorityExperienceReplay_FEED_TYPE_STA... 34.858980 179.0 \n", + "34 (DDDQN, PriorityExperienceReplay_FEED_TYPE_STA... 37.738359 155.5 \n", + "35 (DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew... 213.458093 499.0 \n", + "36 (DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew... 205.934368 499.0 \n", + "37 (DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew... 196.119734 499.0 \n", + "38 (DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew... 223.166962 499.0 \n", + "39 (DDDQN, ExperienceReplay_FEED_TYPE_STATE , rew... 162.472949 316.9 \n", + "\n", + " min type \n", + "0 9.1 reward \n", + "1 12.4 reward \n", + "2 9.5 reward \n", + "3 7.1 reward \n", + "4 9.2 reward \n", + "5 10.5 reward \n", + "6 10.3 reward \n", + "7 9.1 reward \n", + "8 5.8 reward \n", + "9 9.5 reward \n", + "10 9.3 reward \n", + "11 9.6 reward \n", + "12 9.9 reward \n", + "13 7.6 reward \n", + "14 9.1 reward \n", + "15 11.6 reward \n", + "16 15.8 reward \n", + "17 10.1 reward \n", + "18 10.8 reward \n", + "19 10.9 reward \n", + "20 11.7 reward \n", + "21 9.1 reward \n", + "22 5.9 reward \n", + "23 9.5 reward \n", + "24 9.7 reward \n", + "25 13.9 reward \n", + "26 16.0 reward \n", + "27 10.5 reward \n", + "28 10.2 reward \n", + "29 12.8 reward \n", + "30 9.3 reward \n", + "31 9.6 reward \n", + "32 9.9 reward \n", + "33 7.6 reward \n", + "34 9.1 reward \n", + "35 11.6 reward \n", + "36 15.8 reward \n", + "37 10.1 reward \n", + "38 10.8 reward \n", + "39 10.9 reward " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "group_interp.analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model_dirs = ['data/lunarlander_dueling dqn','data/lunarlander_ddqn', 'data/lunarlander_dddqn']\n", + "group_interp_2 = GroupAgentInterpretation()\n", + "for model_dir in model_dirs:\n", + " for file in os.listdir(model_dir):\n", + " file = file.replace('.pickle', '')\n", + " group_interp_2.add_interpretation(GroupAgentInterpretation.from_pickle(model_dir, file))\n", + "group_interp_2.plot_reward_bounds(per_episode=True, smooth_groups=20)\n", + "group_interp.add_interpretation(group_interp_2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.5" + }, + "pycharm": { + "stem_cell": { + "cell_type": "raw", + "metadata": { + "collapsed": false + }, + "source": [] + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/docs_src/rl.agents.ddpg.ipynb b/docs_src/rl.agents.ddpg.ipynb new file mode 100644 index 0000000..003bbc6 --- /dev/null +++ b/docs_src/rl.agents.ddpg.ipynb @@ -0,0 +1,254 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Can't import one of these: No module named 'pybulletgym.envs.mujoco.envs'\n", + "pygame 1.9.6\n", + "Hello from the pygame community. https://www.pygame.org/contribute.html\n" + ] + } + ], + "source": [ + "from fast_rl.core.basic_train import AgentLearner\n", + "from fast_rl.agents.ddpg import *\n", + "from fast_rl.core.train import AgentInterpretation, GroupAgentInterpretation\n", + "from fast_rl.core.data_block import MDPDataBunch\n", + "from fast_rl.core.agent_core import *\n", + "from fast_rl.core.data_block import *\n", + "from fastai.basic_data import DatasetType\n", + "from fast_rl.core.metrics import *\n", + "from fastai.gen_doc.nbdoc import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [ + { + "data": { + "text/markdown": [ + "

__init__[test]

\n", + "\n", + "> __init__(**`ni`**:`int`, **`ao`**:`int`, **`layers`**:`Collection`\\[`int`\\], **`discount`**:`float`=***`0.99`***, **`n_conv_blocks`**:`Collection`\\[`int`\\]=***`0`***, **`nc`**=***`3`***, **`opt`**=***`None`***, **`emb_szs`**:`ListSizes`=***`None`***, **`loss_func`**=***`None`***, **`w`**=***`-1`***, **`h`**=***`-1`***, **`ks`**=***`None`***, **`stride`**=***`None`***, **`grad_clip`**=***`5`***, **`tau`**=***`0.001`***, **`lr`**=***`0.001`***, **`actor_lr`**=***`0.0001`***, **\\*\\*`kwargs`**)\n", + "\n", + "
×

No tests found for __init__. To contribute a test please refer to this guide and this discussion.

\n", + "\n", + "Implementation of a discrete control algorithm using an actor/critic architecture. Notes:\n", + " Uses 4 networks, 2 actors, 2 critics.\n", + " All models use batch norm for feature invariance.\n", + " NNCritic simply predicts Q while the Actor proposes the actions to take given a s s.\n", + "\n", + "References:\n", + " [1] Lillicrap, Timothy P., et al. \"Continuous control with deep reinforcement learning.\"\n", + " arXiv preprint arXiv:1509.02971 (2015).\n", + "\n", + "Args:\n", + " data: Primary data object to use.\n", + " memory: How big the tree buffer will be for offline training.\n", + " tau: Defines how \"soft/hard\" we will copy the target networks over to the primary networks.\n", + " discount: Determines the amount of discounting the existing Q reward.\n", + " lr: Rate that the opt will learn parameter gradients. " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_doc(DDPGModule.__init__)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data = MDPDataBunch.from_env('Pendulum-v0', render='human', bs=64)\n", + "exploration_method = OrnsteinUhlenbeck(size=data.action.taken_action.shape, epsilon_start=1, \n", + " epsilon_end=0.1, decay=0.001)\n", + "memory = ExperienceReplay(memory_size=1000000, reduce_ram=True)\n", + "model = create_ddpg_model(data=data, base_arch=DDPGModule)\n", + "learner = ddpg_learner(data=data, model=model, memory=memory, exploration_method=exploration_method)\n", + "learner.fit(450)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "import os\n", + "def show_config_group(model_dirs):\n", + " group_interp = GroupAgentInterpretation()\n", + " for model_dir in model_dirs:\n", + " for file in os.listdir(model_dir):\n", + " file = file.replace('.pickle', '')\n", + " group_interp.add_interpretation(GroupAgentInterpretation.from_pickle(model_dir, file))\n", + " group_interp.plot_reward_bounds(per_episode=True, smooth_groups=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnAAAAFNCAYAAACAH1JNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOydd5gkV3mv36+qunvi5lUOKySEECIJEWyDZZMN2BgwYJtoXxOcSDYYYS7GJBuTwwUMiIyEEBkEEhIgIYFyzqvdlVabw+SZDpXO/eOcqjrV0xM2DLPTe97n2We6e6qrT1X3bP369yVRSuFwOBwOh8PhWDp4i70Ah8PhcDgcDse+4QScw+FwOBwOxxLDCTiHw+FwOByOJYYTcA6Hw+FwOBxLDCfgHA6Hw+FwOJYYTsA5HA6Hw+FwLDGcgHMsCiLyMhH5+UHe5zoRUSISHMz9HkqIyB+JyNbFXofD4XA4Fhcn4LocEXlARBoiMikiu0TkKyIycJD2/W4Ricy+s3+j83muUuqbSqlnHox1HAzajmVURH4rIr+32OtyOBwOh6MTTsAdHvypUmoAOBM4C3jnvu5gFlfrAqXUgPVvxYEsdJG5wJynNcCvgAsXczHd7CQ6HA6H48BwAu4wQim1DfgZcAaAiCwXkXNFZIeIbBOR94mIb373ahH5jYh8TESGgHfv6+uZcOYbRGSTiOwVkQ+JiGft/ypzW8zr7BaRcRG5XUTsNX5NRPaIyGYReae1D19EPmz2vQl4btvrz3h8c5ynGPgmcKyIrLX29zwRucVy6B5lHv8bEfmxtd19InKhdX+LiDzG3P6EuT8uIjeKyFOs7d4tIt8RkW+IyDjwahHpNa7piIjcBTy+7Rj/zRzbhIjcKyJPm+fb43A4HI4ljPuGfxghIscDzwG+Zx76CrAbOAXoB34CbAH+1/z+icC3gCOByn6+7AvQrt8AcBlwL/DFtm2eCfwhcCowBpwGZKHYTwHLgYcAq4GfAzuAc4HXAM8DHgtMAd9t2+9cx9cREakCrwSGgBHz2GOBLwF/CtwAvBz4kYg8DLgC+JgRlkcBVeD3zPMeYo79NrP764H3mON8I3ChiKxTSjXN758PvNi8fg34D+Bk868fLcCzdT4M+Cfg8Uqp7SKyDphToDocDodj6eMcuMODH5jctKvQYuMDInIkWsy9SSk1pZTaDXwM+EvreduVUp9SSsVKqcYM+36JcaSyf79q+/0HlVLDSqkHgY8Df9VhHxEwiBZuopS6Wym1w7hlfwmco5SaUEo9AHwEeEX22sDHlVJblFLDwH9lO5zn8XU8FqCBFod/Ydw4gNcC/6uUulYplSilvgq0gCcppTYBE8Bj0EL0EmC7iJwGnA1cqZRKAZRS31BKDZlz+hG0SHuYtYarlVI/UEql5py/BHi/OYdbgE9a2ybm+aeLSEUp9YBSauMsx+dwOByOLsE5cIcHf66Uusx+QEQeiXbVdohI9rCHdqgy7Nsz8W2l1Mtn+b29j83AMe0bKKV+KSKfBv4fcKKIfA/4V6DXrHFz2z6ONbeP6bD/jBOZ+/g6HouIrEG7eY8DLrf29yoR+Wdr+6p1PFcAf4R2+65AO4hno524K7IniMi/Av/HPE8By9A5dxnt65vxGJVSG0TkTejw9iNE5BLgLUqp7bMco8PhcDi6AOfAHb5sQTtIa5RSK8y/ZUqpR1jbqIPwOsdbt08AOooLpdQnlVKPA05Hh1LfCuxFu3Mntu1jm7m9o8P+M+ZzfB1RSu1FO27vFpGjrf2939rXCqVUn1LqfPP7TMA9xdy+Ai3gzja3Mflub0O7aitNwccYkCtMpp/z2Y4RpdR5Sqkno8+RAj441/E5HA6HY+njBNxhilJqBzqf7CMiskxEPBE5WUTOPsgv9VYRWWny794IXNC+gYg8XkSeKCIVdC5bE0iVUgnwbeD9IjIoIicCbwG+YZ76beANInKciKwE3n6wjk8pdS86FPo289AXgNebdYqI9IvIc0Vk0Pz+CuCPgV6l1FbgSuDZ6Ly9m802g0AM7AECEXkX2oGbjW8D55hzeByQO4Ai8jAReaqI1Mw5awDpfI7P4XA4HEsbJ+AOb16JDgPehU7W/w5w9KzPmM5LpdwHblJEjrB+/0PgRuAW4CJ08UE7y9ACaQQdIhwCPmR+989oUbcJncN3HrqYAPOcS4BbgZsoijMO1vF9CHitiByhlLoBnRf3abOvDcCrsw2VUuuBSbRwQyk1btb8GyNEMWu9GFhvjrPJ3GHq/zTb3o8WpF+3flcD/hvtVO4EjgDO2YfjczgcDscSRZQ6GFEyh2M6IqKAhyqlNiz2WhwOh8Ph6CacA+dwOBwOh8OxxHACzuFwOBwOh2OJsagCTkSebbrHbxCRt8/9DMdSQiklLnzqcDgcDsfBZ9Fy4EyT1vXAM4Ct6A71f6WUumtRFuRwOBwOh8OxRFhMB+4JwAal1CalVIge2fT8RVyPw+FwOBwOx5JgMScxHEu5hcJW9OzNGVmzZo1at27dQq7J4XAchtx44417lVJrF3sdDofDMV8O+VFaIvJadFd8TjjhBG644YZFXpHD4eg2RGTz3Fs5HA7HocNihlC3UR4RdBzFiKQcpdTnlVJnKaXOWrvWfUF2OBwOh8PhWEwBdz3wUBE5SUSqwF8CP1rE9TgcDofD4XAsCRYthKqUikXkn9DjhXzgS0qpOxdrPQ6Hw+FwOBxLhUXNgVNK/RT46WKuweFwOBwOh2Op4SYxOBwOh8PhcCwxnIBzOBwOh8PhWGI4AedwOBwOh8OxxHACzuFwOBwOh2OJ4QScw+FwOBwOxxKjewVcawJu+DLsvW+xV+JwOBwOh8NxUOleAdcYgZ+8Ce51XUocDofD4XB0F90r4LyK/jniRhw6HA6Hw+HoLrpXwPlGwKXx4q7D4XA4HA6H4yDTvQLOM0Mm0mRx1+FwOBwOh8NxkOleAeccOIfD4XA4HF1K9wo458A5HA6Hw+HoUrpYwDkHzuFwOBwOR3fSxQLOA/FAOQfO4XA4HA5Hd9G9Ag50GNU5cA6Hw+FwOLoMJ+AcDofD4XA4lhiHgYBzIVSHw+FwOBzdRZcLOP+QE3DNKOGzl28kStLFXorD4XA4HI4lSpcLuADUoRVC/cKvN/HBi+/hU7+4b7GX4nA4HA6HY4nS/QLuEHPgpkK9nq2jjUVeicPhcDgcjqWKE3C/Y3xzxpNELe5CHA6Hw+FwLFkOAwF3aIVQPREAUuUEnMPhcDgcjv2j+wXcIdbINxNwiRNwDkeZyT2QRIu9CofD4VgSdLeA8wNI973a879+ejc3PTiyAAsC3zMOXOoEnMORoxR8+BS44BWLvRKHw+FYEnS3gPMq+1yFWg9j/vfXm3jhZ367MEvS+s05cA6HTTilf67/2eKuw+FwOJYIXS7g9r2IYWgyXKDFaCTLgXNt4ByOgnCyuJ0cWnmrDofDcSjS3QLO33cBNzxVCLjJ5sG/kISxVm7JAoZQoyTlnp3jC7Z/h+Og07IE3PjWxVuHw+FwLBEWRcCJyItF5E4RSUXkrAV7Ia+iixj2we6yBdz2BejVFpoJDAs5ieHt372dZ3/8ygVZv8OxILSsLxyNscVbh8PhcCwRFsuBuwN4IfDrBX2VfJTW/N2uIUvANeODX8GaOXDhAgq4H96yDYANuyfn2NIxH4YmW7zqS9dx+b27F3sp3YsdQo1bi7cOh8PhWCIsioBTSt2tlLp3wV8oayOi9sWBKy4erfjgi6xcwC3AvjNiE56tBd0dIf9dcfODo1yxfg+v/vL1RHHK7vHmYi+p+7BDqLE7vw6HwzEX3X2Fz4oY9qHi03bgFkJkZfuMfgeTGLys5NVxQGRhdd8T3vfTu3jCB37BngnnEh1U5unAffHKTdy2dfR3sCCHw+E4tAkWascichlwVIdf/btS6of7sJ/XAq8FOOGEE/ZtEV7FCLj5C7HNe+v57Va0ACHUJAuhLkyD4clWUXgRu15zB4VM1NcCjwtv0An263dPsHawtpjL6i5aE8XtZGYH7n0X3Q3AA//93IVekcPhcBzSLJgDp5R6ulLqjA7/5i3ezH4+r5Q6Syl11tq1a/dtEfkkhvkLmXt3TRAY52oh8tSKEOrCiKu7dxTJ4PEC5tkdTmRhdU+gHmrh3d3W9SKwjzlw53zvNiaabmqDw+E4fOnu65Dn6wrUeYZQm1HC5qEpjlnRAyxMDly2z0aYLEgrkTu2FRV88e8gTNvtNKOEi+/cCYCth7ORaI6DhJ0Dl3Tuxaisv+Pzr9vCZy7fsNCrcjgcjkOWxWoj8gIR2Qr8HnCRiFyyIC+0j0UMW0capAqOWLZwAi5z9YbrIZMH00FIE7jp62wbLkJRTsAdOF+7+gG2DOt2LLbgPuy9zSSCey8+OPtKE7jnouJ+1DmE2p4SMDrlHDiHw3H4slhVqN9XSh2nlKoppY5USj1rQV7I37cQ6mhdf/Nf1qNTAxckBy5O8El4q3ce92++f+4nzLcA47ovwI/+iUdtuyB/KHbjHg4Yu9jEPp/RAlYRLwkufjuc/1LYePmB72t0M+y+E448Q9+fScC1fSGZWIBG2w6Hw7FU6O4QaqUP4nDGkEw7I3X9jX5ZTwXQ4bODTRinPCW4h9cHP2bNZW+cfeM0gf9cAT9/19w7HjFisFFU6EWuiOGgcfzKXuzTedjnF979Y/1zbMuB7ysyDaeXH6d/zlDE0P6FZKdr5+JwOA5julvArXyIduD23DevzUeMA7eiTwu4hSg0aMUpy3p8ANLGHOOuhkyOzw3nzr3jps59m5CB/KHkcBcZB4F6GCMCjzpueenxw77Cd3KX/ulXDnxfmeNW6dM/ZyhiaM8Z3TvpWrk4HI7Dl+4WcKtP1j933T6vzUdzAVcFoLVAkxgGKmag/VxDu7ffrH8OdurGYhGHsPGXANRVtXh4X0TGPhR7LBmiJtxy/gEdVz1M6Ak8Kn75T2UhR6EtKfZx1nBHItO6J9C5pzM18m3vnVgPE/c+OByOw5buFnCrHqJ/7rpjXpuP1CN8EZZnOXALcHGYasWsDPQFSs118dt1p/7Zu2r27a7+dO6IpPuTp5Um8J6V8PN3zm/7pcLlH4AfvB5uPX+/d9EIE6qB30HAdZnY3V+igzBvNxNs1fk5cA9Z089ZJ64kjNMFqeR2OByOpUB3C7hqP1QHYfiBeW0+Wg/pq/lUAx3iXIhJDCP1iJV+JuDm2P+kmb2ZzuHUNa3O9Gmc97GL5+s8ZXlMV396ftsvFab26p+77tr/XYQJFV+o+OW2Ic75MURNuOnr8NGH77/TmYnALISadBZw2Tl/zPErGKgFhEnKlfftcaFUh8NxWNLdAg6gbxVMbJvXpqP1iL6qT09lYQRcI0xoRAnLPSPg1CwO3ORu2HaDvp3M0S6hv2hwLElE1cxAnbcDt9fKEeymMKpvwskHMBy9EcZUA49qmwN32BcxZCQN+PEbYXx7kbO5r2QCrtqvf87hwPmeUAs8WlHKa752Iy/+3NX5Ntu3PsAdt1xPErsKVYfD0d10v4DrX6OdmLlEENCIEiq+RzUwkxgOsoDLiiSWib5gnZxuZuMXXqHzz9r51OOKC+Ku22H7LTPv2Gq7oNIoFxvJfMWYLeAORkjsUCEwo64OYDh6PUyoeNNz4MKFDqHe9UMtig514lYhvCZ27ec+2h24zlXjWRWqCFQDL/98PzhcjL974NLPccYPnk6rOdlxHw6Hw9EtdL+A61utW2s0hufcNE4UnghVT5+Wgz1KKxuKPkhxwTl524/Ycf+d0zdutVWofv7smXccFfuTNM4duHk38h3b2vn2UierkJwhJDcfploxlcCjErTnwC3MLFtA5yR++5Xw+T9auNc4EOwvBlEDKr36dmus8/ZzkX0BCWq6+XY8k4AzDpwINZPmkN3PqDX3Mqb62LPjILQ3cTgcjkOY7hdwK08CFNx24ZybRkmKJ+B5gu/Jgjlw/VIvPT46PtFp8+nM5CLGTfCMWLEE3LzztGzHY2rP/J6zFMhDqPPrA9iJephQ9b08rzBjQfv4Zo7h5H46Wp1ojsPkQXpv7eKbuFU4Z8052uLMhF2F6vkzO3DmC4nnQa1S/Ndlm6O9rb3sYQXiHYT2Jg6Hw3EI0/0Cbs3DoG8N3PmDOTeNkhTfE0SEwJODnqieNQruV3W2eMfytug1AEy15ukQDc8wucFyQSSN8xDqvNuI2EUS22+Cyz9Yagi8ZBHj0hyAA1cPE6od2ojk4n58O9z8zf3ef0cOIGdvRj7ze/DhUw5OjqP9ebFDqM39dOAywerX9BeRGUOoRsCJR81yRMVy4PrCvQyzHKnU9m8tDofDsUTofgEnAitOgOENMDV7GDVKFL5xWhZCwI03tICrqZDVPfCHR+kLYateduRKTtvAkcXt3TNUU0YN7TaJj6f2I4SaWq/383fq9hu3fmt+zz2UyYTAAeT1NSLtwPntDlz22Tj3WfDDf4Cx+RXKzIsDyNmbkXETGm8eBGFuf16SVhFC3d99Rw0d7vZ8CCdh4y9gfMe0zbJz7nmUQ6jWezMQDTHMcjzPn/Z8h8Ph6Ca6X8ABDB4JjRH4xCNn3SxOUjzzbT7wvQObxHDn9+GD66A+kj+UV9GRgPgs79Vhnkar7YJdH9I/z/iLYryQ/fi0hZsLoB/gqSh3J+Y9C7VTQ+H63DmDhzyZgNt6PbTmGaZuo2HaiATtbUQyd3PsQf1zYuf+rnI6toCbR/HNPjF6EHLD2h24PIR6AA6cXwWx/ju6bfoXCDsH7lEjP+ei6jmcLg/kf7MoxWA8zIgsx2sT3A6Hw9FtHB4CLrvAhJOdKz4NoQmhAlR8ObAihjt/oEXjpf+RP5Q5er5KUOLh+6ZhcLNNwGXPqfaX841mElVRQ4eevABfJYUDN+8QalTk0GXMc37socLfffUGzrt2c/nBTAiFk3DuM/drv1GSEvhCxevQRmS+AnlfsUOoB+N9sMOme9cf+P5swZ+ERQj17h/vX4g2qhcC7vmfBQS23ThtszwHToTHb/saj/A282hvY5ED1xihppqMyvJC1DkcDkeX0rUCLoxTbt1eZ7glcMTpxS9m6b0Wp0UItep7BzZKK3POthcXosyBE5WACEFgBJztwCUx3HaB2cfxZbdjpkraqAF+gJKAQMWFAzfvIoYIagNtj4Wc9b5L+ffvz28M2aLx6w+jPvtkbr37Ht7x/TvKx2wXL4w8AGF92tNnI02V/kyITA+hpkqHmvMHivfw/Ose5O4d+5nQD2UBF07t/34ybPdxaOOB76/kwIU69Am6IfTue/Z9f5EpwhGBvpWw5pSO+8kcZZ2nqj/jfTQLsWZGz22W4/C69n82h8Ph0HTtf3O7J5o8/6vrefrPVxOtfjgc81jd8HYWhyCyQqi1ik8rOgCHJcu7mtyVOzV5CEhFKPEtAWddsLffBCh47Mu18LQduJmq/OImeAHKC6gQ5y0v5m0gpknhUmYkIXsnQ7557YPz3MkicdNXkV2380xfC+VL7tzJXdvNecqKF1afom+n+xaOjMz7FvjTixjiJG3rn6fFoVKKc753O8/5xJVz7v/VX76OV33puum/sAVcNg+3E0rNL7/PrmbNplMcCO05cLYjNzk9d21Oshy4LITav1Z/WWkLH9sOXFa4MGAEnFIKtt1IinC/HF9qLeJwOBzdSNcKuFX9VZ572nKGQ5/rd8VQHdBCRc2sauwihlpwgA5c5sjUh/P+WPkFiASFV4Q6Q8uBy0TBinU6W1u1VYh2ylcL6+BXtICTmJq/jzlwaVS4KBlLJYRqxE4FfV7e/9O7efMFt+gLetyCwaPh6Mfo9761b81ds0pTXzqN0lJlZ8sIqcmWXsd8AomX37uHK9bvmT7P086Bu/N7M+/g2s/B+4+au4DCzp0M9y8XsIQtrJKwLOj2J6zcGtc94DIB17NCn9u2atzsC1DgCVX0a/ZJE6WMuz20gT2ymsTv2fc1OBwOxxKjawVcXzXg75+0BoDfbE/1N/w5BFxs5cDVAl3EsN/DsrPeViqBoU16/2mKCHhpAuIRmEazUWSJpezinVX22Q7c7rvg1x/qsHBdhZqKceCySQzzXXsSlRPIoSTg1KE8Xsu0O8ku6DvHmozUQy2wklA3hs2GpH/sdNiHBrzZwHrfk1xsZ8SJ0kn72Xkz79uoaRWzLwbQ9rE2F80WLiMPzPzE27+jf278xewvcLBDsvZnMommCzrg5gdHeNWXrptfJXdzrOgBB1rAJaHOIbWwR2n5iT7f/TSJ0pRUAY0Rxhig4gpQHQ7HYUDXCjiAtQMVfBS7p5S+kKfxHAJO5aGXWuATJekBCDjLRTG5a1k+lagYJR6YIoYk6pC07le4cZfivnB1eb87b+vwWrqIQXkBVZJcwO1THzjx4E8+BE97NyAoS8DNez+/a5IoD5NW0KIiVdCKzfsWt3QvuMAKD49smvfu86ITX6aHUNNUC4/aoNlYC/ZMwNWC+f9p3bqlrf3GfKtQs1Fh0RxtR2yHbB/zAOfcXxKWc+LM5+bNF9zCFev3cM3GGSqnbZqjWsBl9K7QP8fKFbN2DpyfaNF7Su8kSapIlYLGKOOqj4qLnjocjsOArhZwAJ4o3TXfC3Q4ctYQauHAVQOP8EAEXGy5KuEUXPE/nDR0JZ8MPoGftlDioUyj2dS+SGduiV/lp5sVL9r7WhpnvKz4fV+boIM8hyhz4HxP8GRfHTgfVhwPR5wGno+KizUd7H54Bw1rakRVChHRjBI9JzNuaVcnq5KEstiYgyyEGpjGzjZxahy42jL9gBFw2bSNqj//P60Nu9tCu9lnwAvmJ+DCOULDdtg9OhgCrk2wpTEgxX20kAbdR29OmuPlHMweI+DaesHFliPqmb+vXppESWoE3Aijqp+Kd4h+4XA4HI6DSLDYC1hofFEkivk5cKnKWxLoEGo6/4Hw7URN7WqpFHbcCld9lJcAeKDqHmM9a1CePv1RaIVQcweuSpjAOP1sO+YZnLL1NzD6APmFMqMxoh2M3hWo8b1UiPFE8ET2oZFvXM6B84KSqGzFKX3VfT0BvwOs5PwshApaeMVxqoWQb4VQ95GsjYznS6nbPxgx0RqDgVNgjNzZygXcPBy4NQNV9k6GpWHseufZbNCe2QWnbwTcXFMzbMfsYAg4WxCGU1og+2aCgvncpKooOJgVpXQOXJYyANCzXP9s662XO3BCHkLtU03iRGnB2BxlRB1H1TtEv3A4HA7HQeQwcODM3MosBy7t7AgopVtG5FWogUeUGCEwT172xWv4x2+atiFxwxoxVK4eFVKUeKRiBFzU5sCZ8GpoljrWUvDM95qFtq3/t5/WPwePIZWAqkT5PNdHTf56XjNgSdty4LyAJC4u0mP1kOGpkJsfHOnw5BnYeoO+OF/y77Dxl/N/3jwYngr5zYa9pdmeWRED6AKCyVasw6teUBYHswj4dmwHrh1Jm/q9ykKocZM0VbzxW7cA8xNwmbzePtqeA2flQc4m4DIHbq4JCJkYD2plZ3h/ydaUFRskoTV3VruH2fceNVc5Rzip3xP7PTK5oUTlfL0slF9VEWL220OTOFUkSQLNMYbTfqriBJzD4eh+ul7A+Zhv58btmqm60k5YB30BThU090HA/WbDEBfdvpPNQ1NmPqlxflod2n+IlztwYRzz+V9vLIsOPLIuJqOhmMeknJDeGIErP6xvLz8uD6F6ovAF/mHXu+F7fzd3ZWB7EYMXlHLgdo+HnPneS3nBZ35LOFNl7r0XF0Lhgavgi0+Dy/8Lrv40fP0Fs7/+fDGd/l/+xWt52RevpT5cVF/aAg5gvBmZEGpQDs/tw5xROweunUpkwpZWCHXvZLHv+YRQM4d097h+XjNK+OzlG4uq5NkcuHsuKo5lrgkI2T4qfdoZPtCilMzR61mmBVg8XcBlDlw612tlaw96GWoqPeEic4Mtpy9JFe/9iR4lV5PiPNeUOXeNSUhCRtUAgXPgHA7HYUDXCzhPlBZCmYCb4QJuJ0hDMWsxawuxL7z1O7exd3SscOA6jsAqBFwcx3zgp/fwpas2FaJDPFpGK4230GWNfmW6gMMcm3HgasT4tIWu5nKdEt1G5JqdinVfTonwSyHULSNF2G2k3iEna9PlcP5L4eJzzPGahsM3fW32190Xbjkf/vsE2H4r63fpVhjjQ9sBCL1eqm0CbqJpiWHfiv/uj4DrMJapFrcLuAYtS+ynSs1ZvZvtf7QRESUpn7l8Ix+8+B6u36CPK3fg2gX48P3wrb+G9T/T9zt9QbDJ3stKH41WyPBEQ3/J2F9yB265/mzV9xbnONXCP8u/nOm7Q5SkDE+FuYBL/B4ed77irb9OdT4mlL5s3bl9jKb5RlNLbQGnxW40qf8WxuinKi4HzuFwdD9dL+B8ociBA534bl1Vrrt/mP/44R1EcTFnEYoqwqn9EHDX3T+MihokWfVjBwGXiocyIdTMPWqEqSXghDBz4LLrldcm4LI+ZI99BfQMEgX9rJBJfC8ti465BFwag/j8aJM+B1NJgLLcD1vEdkxKz44vq5DNQnqTu2d/3fmy9z74wev17c1X5XMuvcndUOml5feVihjACLi4pc9Z3ypYc6r+xT70t7vqPn1c7QUMgSd4mYjIQn9xizBJWck4T5S7SVI1p9GVOXBhnBInim0jOrwZtRqA6JBnmjCtq1x7YcNcc16NY6Yq/eydijnzA7/i7A9dzg0P7Oe828QKoYL+IhG0O3Dmrl1Ic99l8NU/g8Yo//cHd3Dmey+lNaHXMJTqv5Wfb6H4W7Vy97YMF6HfKlq0xX4vVaXfz9DsZ1z10eMcOIfDcRhwGAg4U8SQ5dWc+3S46mP579/0rZv56tWbuWGzvgDYfeAApsL5Cbhv31C0PKgSsVbGUZmAa3TIHbOqUGtGfFQDMflEWsBlWmks0xx+pZguAEVunWnB0OhZy5GMUEvq5WHecwo47cBlz0gkQFkiYcIWcJ0EbRZ+zV4n6/bvH6QamZ++tbgd9OAJHMUQR9z9FQh6SKQyLYT6LxfeWnT4BzjtefpnPD8B99sNe/nYZXpuaNA2l6nie0hebFIDBKImYZzy49o7uaD2XiRuzVkAkzlwrTghTlPGGnqffV6s1+3N0LswabiiDosAACAASURBVHMR53IVzXsZBX30SdFyZL/HfdkOXIZx4IYm9f5VpxDqN18E918B913CpXfpApQ7NutK012RFsIDQWqFUIvP4H27C5GaOXBJZYCqCaFGTe2ITtLjihgcDsdhQdcLOA9FoqT4Vg+w4bL85slH6Bmgv7xbu0WZ8KmZbqATzbkFXDNKeNt3iv5sn658EgBVnVnAKfFBhFR8ju0xjkLeu0znwGUO3Fh2fc4q/TKy0Jl5nUZtLZ4oVofby6OEZpn/CmhHxcqBS8QvO3CN4kLaMScwe25WIJI5cgcrkrX82OK2SvFFeKF/lb7fGGE8Nu1TrGMea0SoqFGE9nJRML8Q6ndu2prfbg+hVnzBy0SM5+vXiJtErSbHiRava9Nds+Z/JalO7xd0/mUYp3l4ui+ZMI1tA/3etQu49vFZc7mKZq0N6aOfQsBVgzk63t76LbjyIx32Zz4Pdksbc54/9FsdEp01B+7Gr3HiSl2AsWWP3v6cW1YBMFCxcuAsB+6BvUXIt5Kav5egD5+EKhFRS/++Sc05cA6H47Cg6wWcn/VDswVc0JMncp+4WoufW7eOmu31xXpFn3ZudrZ3yc+oF7Ma90yURUE2l1MmdurX7ZCjpIzoUV7AE1br54dxahw4Pdg77OjAWRfrzIGrahE6VTsCgNXh1n3LgUujIu8ISAhKyfPjzeJC2jGE2u7AZQLOXusM1b/zYvnxpbV6nuChX2vqxKczGleoElMJimMOiJE04ic7BnnjFemcRSzt7J0stmtv4lsL/GI/XmByE5ukVsj4yHTPrCHUzH3rrRa5lqOmBcmayXv1CDC/2rn1TXsrkLl625nPaZ0aAcX7EM1VoPP918Ev3jM9ZJvdHziCvK2NEXBVIsYb0fQcOPtkbL6K56Bnxe4Z1Z/hEP331uen5gsMJbe0HhbrroRmNF1FVwD30SRuagFXVzWq3gF81hwOh2OJsCgCTkQ+JCL3iMhtIvJ9EVmxUK+lQ6htDtymX8IFujludqHZOa6/1Wduy6q+Ks/yrmNgw0+m77QxCv9zUh7aG5oqi4I9SoeWWr1rygn0JYyAk4DAOA1R5sB5fmcB51XKIcDcgdPFEvWqHh22srWNWjCzgPvxrdu55E6rx1ZbH7hEygJuslVcEJvhbALOXKTznD/ror0PDXSnYQuIsIEnwmoZJ/Z72XvqXxERcGLPFFXf45jlPRw5WKMHM9JprJ8fbsIqYpmfgBu13tP2HLhqIEUI1fNzYZ02CqF+RLpnVgcuE3B9RsDdv2eKjXumqBKxeuo+7ToG1c4h1PZpCkk0e2Wp+XztjnoIJCV7X+bdoLn9vcvEeNCjB89DngP3nspXue/an+bLyXPg2sK8nvmMxC39dxealpTb6z7Pv0imva7t/C4fvxeA+sCJgB6nlbb0OWlQo0ecgHM4HN3PYjlwlwJnKKUeBawHzlmoF5qWA5dxz0UAhKZ4IXNcshDqQE/A3wYXc+aWr0y/ON76Lf1z068AGLLaRyzrCUgRfpk8hqFTXzqjgFNeIeB8k4gdxakO8YkPUoRQJ3IHrto5hFrTDlzd1xWRg9EwA4F1EbMEwGg95J/Pv5nXff1GGll+X5uAiyVAWY7ZZGsOBy4TWLkD1yE5/kAEnN2INm7ge1rAhcEAIT4Ruvr24/IRXqV+yBNOWkWvEXBNdKguZf4h1E17JrltW9Gao32QfcX3ijV5Qd4kOrWc1qPZw2yDMLIChl4Tqv/hrbry9HjZja9iGDha7zeqw4V/A0Mbiyd3cuBmc1lNOPxXu3SemW/cy3C/BZw5dvFh2dH6tld8zpff+fVcvCaZBZet+chHAlBJtGMm5v0IVYWV1YTh0OfW4SwkbzWTjhLWre7jU3/5WI6YWk+rtoawR4dw+6VJakKoDar0+C6E6nA4up9FEXBKqZ8rpbKrwjXAcQv1WtOqUNtodyGya7UnwoAXkyTpdAE3rvOjVM9Kfnr7jlII9bjlVdYwxh1qHY1gedFstQ1lTn3qV6mkLZ3Hk6SlNiKZ2TURZWGqSlnMNMf1Y74uYgilRlNV6E3GWRnY8yqtgoRmB2etLQcuVAGSX7QVU9ZzmkbAbdg9wY+N6Cj233axtjkgB84eBdXAE1jFOC2/n5YKCFVAlZCnqmt5XfhVKr5Hj+kV1lBaWKSZQJ2HA/fUj1xRut9exBB4HpIdsx8UI6+shs39amrWNiLtIdStI3X+j/9TXu6b/MzagBbVaQz3XQJfenbpHJSYS8CZz0zLnIssjNqab4/D9vC3nf83cCRAXpAD4IcTuXjNx7nd+X3988jTIajRFxuBbL6QhFRYXcvWIyT4pfe9FadUfI/eisfy4Vtp9R6Zh1AHaDAwqnvENZTLgXM4HIcHh8Iorb8FLlionfuiSOw+cG1ME3DWxbrXi/RzVUpJ6xoRsGOsyT988ybWrS5mbT7zqAn8McUetYJmzMwhVCOYEr9Gb2Mn63texWXb/wpqrdwNyxy4yUhQSiF+VbeMOPdZcMrTtAMX9ObbxwpGGaA3GWdZxR6fVCSuNy0HLUrMbZMDl8mNiCAvfLih9vc0di/jKfwPYFqdAE//6K8BeNrDj6AvcwUzwdJJwM1RKamU4obNI5x14sppY6v0+kTvP2ogJoTa9JbRUj4hASvjIv8s8CV34BrGgVN5XtUcDtzWGziaIXZQJOhnuXX/9MencPm9u0mVwsvyAqWSO3DKaudRIZ61f3JkhE2fceC2jTa4sPKNYoNKb/kzO7Vbf+6CaiHgnvp/Yf0lMLxRi6x2lzkjiVDiExkXMiChBcTzdeDaz1liuY+9K/UmSUL26n48mVfgJqnSEzMuekvxnNoyBqbG8EjzUHSLCmt7UjaYU5hKgG99WWlGCYEv9E0+QE9jJyNrHkdqvrj8R+VrnLZ5E2BCqE7AORyOw4AFc+BE5DIRuaPDv+db2/w7EAPfnGU/rxWRG0Tkhj179sy02Yx4YiYxSIdDTVOiJGWgVlwobbOlz4tIVUozak/iNhc0I1QesJqi/vm2jwKwRa2lGavSiKAL4z/Mb2dFDKnfS62pKxefPny+7myfTWgw+moyFp1LlBUxbLkGfvV+7fgEPXkBQpLCiBqgN5lk0LOcJsuxsZPBo0TpLHOVgnhkRluo/NyBWyPjHJ9qx/H1/o/41S9+UrgqoKcPZOcjc4EswZjTnL1lxc/u2MmLP3c15151f/GgUnDN5+Den2mhChA38UVYLRM0/AHCRAvOrB8YwKs3v4M3BN8DdEgNyJsmzxlC/eLTuLrnn0sPZXLyMcev4E1PP5XeSoCXiQs/E3BR3o8tRagQF+HDDmQFBL1Vk/s12nbOaoPTv3Rs/o15shHIfWt1/qPtwKWJnoRhk8YoCUjMn3vmwIX2rFyl4JbzOjuUVhW1Uoo0c8bEz1uJJC2rSjQu3McoSWHv+mJffhVqy3kWv2VTz8vxzPuRiM+KarGeRKY7cIHnsXzoZgCmBk/KBdyjvU3FUqk6AedwOA4LFkzAKaWerpQ6o8O/HwKIyKuB5wEvU7PEmpRSn1dKnaWUOmvt2rX7vA4f9OWqQ/XhN6+5nzBRrOyv8IR12kmoW33OegnxVZI3WM0xDkQcTq9Q9VVEwxvgivTRepKCmZV5afI4/jN+ZbFh7sD14ClLIA5tKAScEUpTsadFk18pNwVuTegQrVGdcQqjapCjJ+/k98PfFNvFhTgoC7jUyuXyaZpftVSAdGg98vbKtzg3fgeX3V0MkdcTD7IcuCxhvUPl7hzNZu/bpft4leatDm2Ei/8NxrYYJ1OPEvMEBqnTlD7CtKhgzDh94iqe518LWDlwHbr7zxevTfwHvhQCzvNNCDVGQtOLTAaoEs0aoswmf2Qh1GnUlk0XcCbnMhfkQdWIekvA/faT8JXn5jmeACQRqeebGR2FgMsdWNDb/+Dv4eK36/v2n+RnnpiXk77u6zfy/h+bljl+JRdwKrQEXNIkUBFCqr8k7Lmn2JdfRfUsy++emmhxVws8+vziNVN8UOXQfcUXfPPZiqvLSfzp6Qm+CPMYQ+twOBxLnsWqQn028Dbgz5RSHeJtB4+sClV1cOD+/Uf3EMYJvggvf9KJPP3hR/CoY4uC2CoRPgl3bm+bNWlCSoNMX3pFRQz3HIfCoxEDVS3gRlV/SWjkDpxpwltetN4ui3aGqVCPVNFWIqM5Zhw4I+AUrBAtlF44+hVrvZ1DqHGiaLaMIyW+Xi+6IlBmaftx/57J/PbwVFiIokxExE1dMWsTd3DlLJpmxmpgt+yw26+Ip/PN4hbHsIdeCWlJLXfgZiLLgVMzCbhbL4AHfkM7gSes6s/C3+XvFxXfw89Et18lloA4ibnqDl1oUPf6qRLPKuCy4pmsiMFGIVDt556xtuOaNA50VNefBS8wzX7jIk9tj67QLLleqQ6hZgIuK2KIbAfOiE923akd1PbzNKEb7v78rl1FKxLxSc0osUy8AohKuLv6St4fnKud46ENxX78Kkm1EHBnp9cB0B9Ar3W42oGzihjilMD3ECOcUy8g7SDgen1Fh8lnDofD0XUs1nfVTwODwKUicouIfG6hXigLoaq1jyB9zCva3BpFM9Jjp/qqAX/5+BM4ekUR8qykLSqScO5vt7Du7RcRZYPczcVtGVO0X9wD1crzrYaacNukrhAdoz/PQdKvbMKefgcBlztw5BV1I60UKv3l7ZqjUCmen6TwcG8L05jBgQuTlJd+Tvfjag+heqpcdCAUYmRkonDTRqbCIkdKpdqpiVul0LFe3OzOV8OsqzQE3nJ1tNOlHcjvtF6nn4MWcKGauSFtHX1+kkzk2etQCn72Vrj0XdOe96zT1/Ku553Oa5/yEFb2l/MYKyUHLuC3uwJuHfIYoMGk6iGRKlUiwnhmERynKf8T/C+vHPpYueky0PD6wK+ycaLtuPLQvWlQnInapAUfPAFu/iZ5wNcW4ElESiHgsqkVpfzPLH9uyzXw/iOnN58e357f7JcGSvSor9feoJss71zz+8WujLj96+BXugioMVrsJ6hRDwoBl9EXpPQGVggVv3QMzSih4hXnXUklD6HaLKuk03MoHQ6HowtZrCrUU5RSxyulHmP+vX6hXktXoQpKYOrk55Ty0GpE7BxrdhxWjlL4aQuflFu3acFyxzbtCCkjWHxRpc72AIGKUKao4H03Bvx8uxYyIZW88hTIw56dLkL4FZRSRKnQby5qjQg45anW84OiiMEQpfCm8B+m789KQrfbgMRpypY9+piizDHE5MCR4ltNXyvWbTX8YH57aDIstxHJxGKl7bjmqP5sGbFTDWYQcIgWLVNFsUJDemgl00OoNlkOXEt1EHATO7SL2TRixcpZ6w1goBbwhJNW6ca9FtqByyoxK0QEBCQM0mCSXlIJqBLlw9c7ESWKlwRX8MThH00buVWX/iI0m+H5xTmMGkXo3C6SueHLutgDypW7aUwqPrERur7odcW2A9eer/fgNeX7E4WAG6ShP3d+wGU7eljXPI9NxzyvOD+q+LxFqSrlHf75FUdy3v2D085Hv5/S1+7AWW5zaBy4QsD5pN70AqFHr2hO69vncDgc3UjXZ4t4GAcOaCXwrvjVfDx+IaAvRDvHywJu3V2f5Q9+8kdIGiEoAmvG5m7TLkRZIqA9jOqnEWIuvPVYSI0j4rU5dZmY6+jABb1k1/4sL6gRA8uOhWf9Fzzkj3RiemOUi3at4Lfb9caJgh+kT+aeY19S3p/lwDWs2a5RovJwWD3xaeQ5cD6ikpI4tTv41+tWCLVuhVDTuGgyG7Q7cLMXD2Rip+RGWWE5MDmAU0UOYIMaYTp7CLWpdJitkZqPui0kd91lNhrXItSqeuydJRG+HELVAu4IGeVZ/vWsT49D/ICqxOwY7zzFoxUnpdFQp67pLYnluvRNF3B+rVw8Y1rNlCeMmDxBKAvVJCIVX7tazODAlc41MHRf+f5E0fh5UBooq3gGYCIpblfS4r3Ox8MZdoY93NOwZqga+oOygIspBFycpMSpIvAkD6EqT88L3vjw8heWpxzRwBlwDofjcKDrBZyfhVCVrupM8Lk/PQqAQdFiwxZwp9zxMXrr26m0tFAIrNDhqBk2riwR0CP69vLeCiet6aOiolJT3NScYjsECXYVagcBV+nNW4j0ZQ6cyZlSK9eRrDhJ7zNusqExwM82aqGQib5Wb1uxR9zSJ6AxUi5iiNP8Yr43DHIHrpn4xImizxJw9rD4RqMQrXYO3K56CpERJu0OXCYoxnfA9V+cdshZbl7JjbLbkSiTA9gsQnsNpUOok6pNLFpMkQm4Djlwu42Aa03oxy2hsVxmTs2s+EJATKqES7YGxPgcLcOskCm+kDyXINAO3H07OxduvPP7d/AvF96a33/bWR7/+OSiFWJd+kCC/IsAYKZwtIpj8PS83FLrkKBWlMza5y7VIdSoPQfO7jRccjspcukyrBDqAEbAWSXbu6yXq4qdZ5mWv0BQY5gODlyg6LFCqLaAy3IJq4HOgUslyPM+VVse3GmrDoXOSA6Hw7HwHAYCTodQQTtwACPmArKaMbPN9K/sgREitvM0YsYrKatNxllH6lN48tp+3vEnD9fVd5aA26B0jtB9qq1XscziwFX68hYifSYHLhNXH79F8eZrily4cdVLM9brzwyVsGdNeX9xE+78HnxwHQN7b8sfbkYpvabh7e6wipmlzkhcISDmjFXFBbVqCbhmszj+EUvATbUSrrzbhFfbizOycNj5L4WL/gV23lH6dRbaLY2fKomKtnm2wJTqIUxgiOk5VSNqgM3LHkfD5MA1M4fIboScCbi4CdtvLiXNr8LK22qj4ntUiYkI+Nq9ko+BAtilVlIJ9GSIDbs7C7gr1pfb4Txi07k8N740v68dOE8LlfxYrTm4mYATKReLBD3kCi60XjuJScTL24hk4fDSLNR2Abe3zYGbLCqPB6hr4WSt7wM3ds5DbHfgGtQYVp0FXK9VhRqrIgcuE3C+yYFT4ueh4tQ6/n+u/ifiz5wP6XA4HN1E1ws4z3LgMgG3W+mWIWvFCLgOOTPZwGxbwGUzT1USkhpRuKaqHws8QUTw0hZihZYuSx/HN44+h+8kRe4d2JMYOkxqqBQh1Cyxu2kcuE/cAtenD8s3naAvb/8RG/ET11aW9xc1YYd2fI7f/tP84Y9dtj4Pk+6NepiKTO8ufAJSXv7IwtkqDUE37VNWMs5Dd1+SC4s+aXHNvdsAuHm87SKdXcTHdTUjU2UR0zIHnJRcISusp9S0StYparTSYvaszeNbn+Hy4/4+v99MRYf84g4OHOjWG1aYd1AVguYhd3yCYzecl9+v+B4VYkICfA8iVQiZEaX7t/VJyIPD2pYangpL4coVfZWSo3n0gz/iYbd8IL8/SR8A9bTY7/ZmjTRbe9zSXwBEpjtwWeK/LcjSiMQqYlhVS/FFijmlUD7Xfg3GijxHoPR+DUqDxKuVHDiAJzY/zXeTp5Qe0wKuCasfyhvWfJGQChPm+Gz6KopeS3tFFPN4M3c2sAScMkJVWaJ+uHrMtP06HA5Ht9L1Ai4QRWxy4LKwZHbBXyvaZWkflQRQaelQnS1cRjOLKm4xgRY3KwN9kUkBlMJLI/wg4MxVIacO6gvuO+9/JEVsS1OEUOcQcHkOXPH8HaxmYvBkQOd4Zb+LUy1Ypb0jf9yElTrsuqJRVKneuX2cPuPATaQ1Golx8pSPJ4plVn5fRQrBEYf6uD5a+wJvHv8g7LwdgKNkhD/d8UkArh9rE1XhFFx8TlGE0NZnLmsjkuucPffCL99nbaHgSX9fes4kfbQSxd4OAi4mYCotzkMzVkXDXdCCcM+95SIAq69fjULoPeSu/8fDb3p3fj/wdaPeCB8fStXFIwygvICaxIw19Hi0M997Kf9qhUyX91bop3N+XHZcAJuChwBwd3oCIQG370m48IYt2in0fEBKAgZFEcK2BVxSFnD/8sQBeqt+eRJDtv3Kk/QYr7oJVf/eP8LAUaX+gwM0OjrHu1jFHrWi9FgeQvWrxIE+rs3qKG4/5sV89dh3F/tsC6FG+PlnJHPgKqaNiDLHDmUHrubNMnzW4XA4uoyuF3CeYNwylTtwwwwSK48jjIDr7MDp31UkIWsVkuXAkUS5i7DMTDxoRUmeYC2ez7vObPLBx0+/SBd9yYyA61BJR7WfuF3AJeWL082n/St7j30av04fWThwqZnlKnDZw97NS1v/F4DtIxN5yHZVuL20nyzPbSjpM6+XEpuPRTUpj4bK0OJGcbJn3LRtN+a/Oy28E4CJ9ry0LdfCNZ8p7ltNZBthwvqdE5wiWzlh8hb94PqLy89XKaw9DV5SjJsaSvqYDGFUyiHUyaoOIdfj4pw1YrRbFVuFAHETTjpb3+9ZUXLgskrNTmQOXERAPZG8iGJM9fGU1ZMor0KViKmwKFb44S3FeW/FKQOiz3si00N+U+aztZM1/EHzE7wm+hdaVBhrJnzv5m0mhKrDiBsnbLGeFkUk9rzUNCbG7gMX43sdHLi+NfDUd0J1gLw9zuCx0Le61ApkmdRzAVdp+x/EFrNgHNWoCX5Q+gqz96izecSJRxXnVMoh1EiZHDil8gpl7cDFpRCqcgLO4XAcpnS9gPOZHkJVeOxlOWspQqhPuPQFnHH1m/LnBdG4tQ99Md811oKhjVTG7mdC6Yts5mA1oxQv1WIu6/ovHYThvSYXLuuzlnaalVobzAVcTybgIpWHUQEu3dXP91f9HaMM0sqdMy3gBIj6j2azOgKAT1w9TGLCb5W0HIY8fY1e6+5YC65VtbToFxYVYTW7jcgxMsQDPS/jBFUWgzbTwmSTu8v3LQfuivW7mQoTLqu9jTc++AbdAmPZsW3bm2P3C8fp4j2r+dJdMGYJuF3HPosbTnyNfsmoOP+tROkQYzYlIhMkvStg3R9qQWCJHluwtq/BF6EqCREB45Gf58ANq0Fef1oDTBVqPUy41ypkyAaODE+FPGqtPsdpMD2cOC4mhBrDNtZyzMp+WqpKTSJdRZwXMcB4XJwPlSZF8YJdxJA5cKaNyLGbLuQZcu10By6oaUeyavUbrPRC73LdssbkCA7QIPZqTISqNLDhHWcM56+RoR241rTGzjWf0sSER6xM2kKovhnzpvIK5cDXVah2CNV24GYaauFwOBzdSPcLOFEkSifHWwWY7FHLixCqLywbuZOjthT5YVkOHBRh1G2jDfjUmQCMG4GS5cCt6q/imVwwJZ0r4QaClHjwBL3PUAtE24EbwoQCa8umhVCbSSFAAb6+PuD91+vftUoOnH6s5kPT9EDrpcVEXYsTj3Lo8vRUTw/YHeuL9spqmrebCCwB12OFFE+UXcxF0v7RGnmgfN8qJrju/pFyA9+4wfReEIVSuJYzAJgyBQotT/8cW3kGO056Aa1l6wDyogyAqUi0GMkcqqYRcJVe7cylccmBq3YQcNl4scGeQOfAqYCxyMsduBEGES9ASYWKiqiHKfftLs7hlBnTNlIPWWs+N0kHAZd9OWjEcMpgxItPTmhRoUZEvZWYHDjj+vWdyJWJPh8qTYpQqCVG945PsqNZyV3fVXuu5cPph6c7cH5V5wlWrDVVe7U72ZqAuEVATK+ExH4vj/ymTk84ri/iS38wzBOOCjo4cKk+r16A/XJe25ebowYr2B+BZhpoka9SWlkOnOkDV3bgir+1qnPgHA7HYUTXCzgdQtW3bQFUp4d+aepxWR2qUDsJuOGpQsRkIcKjqy3+5Rmn8qIzj8sdOLuNyDOPKUTBq06epPKoF7Lr2GcysvYJQFnAvUHOIX3EC6G2rHDgAlOFGpGHSttpptrdiXMHTqh6ioZpodFLSL2hnTdRaR4yfpZ3PX8y+V0Adkb6or2ymhQzM+MijyqrVgVYLsXjrwjfnt/+/eYn+fPWe7g5PYU70pPKixzfWr5vddm/6cERjltphVyVmt7417J63qLezLNb/50LzSj1uP7xH2fzqX+j123ezrqlwW7Yja7SHNqgKywzB67SV8wTtaolA3s+bb4G/V6cdtQgjzqqD/F8LeBMEcOIGgQJUF5AQEycqryQAWDneJMwTplqJfz15FeAzgJuk3divv6Kp1hVU7mAa0Sx7kNoPmPjwWpeEb2DETWASqKiGMEci1KK3SMTjCXV0ucSdB+4B4fqfP5X9+o8xt5VWhhlAs6vauesZ7l2/RojrETvP/SK9+uhgzGrzByslT3lv6XcgfMrpffDM39zD578cnYc95xp52A8qZjKZEUzy4HzPCQNzVg048CJ5cB1/f9mDofDUdD1/+X5okiQvJFvRktVeKJ3D+t7XtUxB+74jUXVYUCCzqIryIakS9Lg4UcvMw6cvmjaF5WXn1IIkaqnUH6VHSe9kLDvSL2tFQJ6kKNQZ/wFVHpyB67HXHObCfmoq3ZaiZAqRWLlwFU9aJkJBT0S0mjqtXkqpSfwGKTOeytfzvexM+4zr6dy98y3HDi7J1zWfgXgN+kZ/G/8XD4WvYjtrOEWdQovCN/DKAOdF5thTQq4f+8UawetYo40LlpmPPLF5sHi7E+qHu5RJ+T3m4lAUCU1o8ayvKysuENQXLnD073Lwkn49FmWA9dXzBO1qlwrqpMDp98UEWGgkpKKz1RcOHAT9CKekHoBPilCyu7xYp+tOCX9wT9yV+1veFhTt3NpF3Cv5x3sCo4x69d5XYMV/V5WiWiECVONBtcPG/cxGz+LmR2aOYxpAkoLyEHqTNBXngQCqCThr75wDb+59Lu6SOHIM7SAq1oCTrxiLFp9mFWineNWpagyzlxfgD85vvwtI0lNEYNXzNoF8nmlw0c/mV3r/mzauY7xdfGC5cBVPJN6IJ4e5UXZgas4B87hcBxGdL+AMzlwmEa+GXbvrt6kc7+ujICEY1eWk/I9kxcXWGG3zIFTltNRtRKzO4V4lJUDFyvJ3cKsZqHmpYgpwJjJgWslQpLqRr6eyYGrePpnQ1XpoUXD9G4TeoBkzAAAIABJREFUUnoC4Y3Bd/MiDoDhUK+jzy8mGwRx4R6dvqJ48dXmIn7R2teQ4vFf8cv4RPKi0ppmm46gD9DqDRYm1EojtBqFgOs3TYktBy5K4WlHNXjzw/X7NhikpQ9yYM5z5vg8YkXErqaf94TTL2qOvTpgQqiRTrbP9pFV3aoiTywLoUoa0z++Ic91zMKGk6oXT4oQepWYPZMtqkScLNtoxQk9d5yX500CNPrKuX6JVPK+hfUIar6i4ulxYTWJaEQpjUaD9ZO9TLSS/DMdEqCSGJXlvpnw4x3bxlkmU4yp/lJ/QoAgnuS08at4d/AVwtpqOObR+heVNgGXiaS4yUcrnwVgVBUC/Yh0qMhpbHuNJEnyHDg7pD3TsISvPmWcTzx+1LQRSUwRQ8pnKx/jLdc9Oc+By/cgxTtvC0mHw+HodrpewHmmkW9qFTFUPZW7UwDHxB0GwFsEJBy1rNw2IUvq9zoIuLTkChTP6RTisUOoO5oVPm26TWQOnI9Q9eZw4FJBoUwRgwIxkTBPzwLtIaRuBFxATG/FmzY/NDKi4YlrQh61Sr+Qbwm4551SrHO1aOEU9azqvCAgVHMIOBPiS1JFmKT02KOrWuOFgMsaAlsCLk61M3X2sYpvnD3Oex87XsqpykKoV+/Wazh1mVYOQ5FVMJINa68tK3qpWb3QAvNeenbjX+MCrtx9NX2TD3Jb8EigKHiYoA+kcIVqRAxPhZwTnMcvam9F2vIA9xx9NlG13AIlkSAPn0/FUDPt3lpKh1CbcZL3oLt7KMk/J7Hy+fEDkLRMeFtp8VNvhQzSYJw+Uil/AI9IdnBu9SOc5O1iW//pbDITSoocOAXic+eIfl7rgWt5hLcZgG2JXvcqxvnA+L9x3Ibz9TOsqtpUiXkflRZwtgM3w7zS5TU4btAjNuPcUCnNKOFP/OvxVUwQTZhcvunPz4Svw+FwHA50vYDLvpUnaSHgBitpScA8ofZgp6fmBCTlIetAFX1h95LCtfHyMU22K1A8p1ObA9XWRuITt8JoI84v4r6nqPqzO3BhIiSpytuIZK9eM3lwvYS0WnqdVRXRE0jH3mkAAxXFk482rx1bgiYukuLzCRZBuYed7YCM0U87u7AEX5xV7+qDsvPqCCcsAZc5n8W+E1WE4AYqsG65h1h5jBVPF4xknNSvlcNoaL0ZjRFAoNZfVEi2Cic26CDQxTSWrTZ1T7Rba2cBurEt6LxITyQX8MukTj1MeJS3Sa9r67Wl85FKUGqDkT2Wua9jLUW/OY4sBy5JyVuY3L6nKMyJCOglLHL3Ui1+JJzEE8W46pv2WVsbF5XB3991JE/9vrmThVCTEMTjRw/o5923t/isv+ee4wFYIfozsmxUt49pfw0/ex/9IBdwzz16ovR+teN7EEsFX8U6hGpNjOgfv79UxGBTGsPmcDgcXU7XCzjPiIpYqTxfaDBQhKq4cJ7k7e701JxAEgJfeOdzTssf65MmsQR46ewOnE2tU5sD60L0qpO0gBhvqVzABSafrRnLzCHUVDuMWSPfjKoPTVWlV1rEkb6w1ySi19dOXCd6/OIiHFitKPykEHCZUPNrZQHXZ4WLW1R5V/Qqfp08Mn9sj2fNaDX5ZtkIreVYkwBa40URQ5Z/ZS7OSikSJSVh3I4I/Mdji7UHWU83a1QW9SHdLsOvFA5cq2gd4xkhlBemUIj1imkxE/ta6AyYpryJV0VESAIdXnx7cB71MMmb2/r18vQJ5VXKjXiBptdLooRmrAhTod80t81y4Hpp0i8tQgLuGSkLuGVYIlilgMJrabE9Tv+0htX9aXHOR0zOYpoq3W8PdEWr5+WhYtWcmLa9l8/4NTlp0wSc+dx4FSYjxTOObvB3p8/cYy8j8apUVJg7cKHKCmsmp71GRs2FUB0Ox2FE109+zi70sTK9wNAuU6tVCDhfFRfpZs+R9DTLbTICEgJPWLdmgClVo19a7FErSKVSOAxYbs1MF5g5kqwHa3qxk6HKQ2OBKGq+opkWIVQdMC0UTKyEKEmJ0rLjV/EUzaRKD1GpbcfySpyHgH9wzFu4ecgnq1GoeCpvN+EnloCLy8PdEyX0VsruUV+QMhEXIuFrybP4WvIs7vNeQUUShvwjIDVD0s15axgFMmiLj2y4vHi6NxlAPoDdrGeOc/nQ5SlfP3uc7270OX2l0qIztUTr5G4dPvVsAVcIlKxPn1jvbyZGsvYqsXEHB83g+5cdu5thYHTNmTQ3LmNlorfbq3Sfukp9R2mNSoLSvNPND301k1tWEKeKcfOyfZaA65GIu3v+Vp8HFXD/uHDUsmL8WcnFNA5cYKqpx1U/vRWg+L5B0hwnM6KznLYUhbfsGF3Q0LPCPGYaAFtFLTEB6/ojeuom7zMfbVV89j1RVFN9zmIvYDISBoJ0VvctX5tXpaZCGjdfwBWXJzxDreZE2W3OW/nv667T38yvd1b5w2OcgHM4HIcPXe/A+Sb0FifQMm0Znntcs1TEYIfJkvYh7GgBt2ZAP75NdJ7Q26PXkHoVxHZoMgeufZSVoVaZ/cKVOXT1hCKEKtqFqcdFCNXuWJ8xFWvXLhBKF8gGNXpolQTcMr9FVSJSJTR6j+L+3jPy31X8YkqEHxWCIBMvWQf+pvTQE5QvpH0d1gXkbUnGZJCPRH9hHiyHUGvWqC5aU0Wz2uxcGgfuvdeZ9zOdWwQMVuDVpyUs7w2oeSoPgQIwtUs7cF6lCKFaOXC+OV++5bBmIjYIx0m8Kr5pKvy1+JkohHDVqXpD8RjvO4E/8O/kvcGX8n51W3fuLa0vtRy4Zs8RjBz5JHzPI1HCWEsfZ18WQlXlhs8RAVunJE8L0A6cEdlekOfA+Wao/Th9pUa5AMvFduB0VWmamWNPfSc88XVAkdMn5vPw3ujlAJw8mNCb9wfMHLjyfykVE4ZvGMe7P5ifyMqKe3ov+Ve+nvwbNSk+v6qtUCJc9TCedPpJLOvt+u+jDofDkdP1Aq7H11eknXVFmOr8qDNXxzz3hCIe6Vv5Xcqr0qqtKe3jr0+v8ZRT9GNVSbgoeQLj9JNIpRRik7wKtbOA65nDNcpahkyG2jEE7TT1BYqpSPJJDJ0EXD3MqlBVHpVNlNBUFXolRKy2HYNeSNXkUfUGXu4MeigCkSKEarluxzygE6TqA+v0eQh8etpa39dmEHBZjeiUqnFe8jSzOC2MshBqzbPiw5M7LQFXFi7fuCfb6Qzx5Bmo+dCyDefJPXrmp+cVIrFZhFDzilPbgTOiM4jGSf1eApOId5M6lSvP/DiTK0/Pt0187c69IriMmglXnzR1S2lNygumhVABNk5UuNTU1WSiuE45XB0SsLvpMxFmDlxQOHCV3tyB803D6Dq9/P7aVmkfxwSWgDMOnLKb5Zjzkk8WMQ7cL9LHArC2Jy0qaqVzCDVzK6cS/T7uq4DLOEpGit/N4HA7HA7H4UTXC7jHLZ/AF8UX7tBFDBVR2qEKiguEXYigxGfTI/6xtI/HHFmh14iVqiTERggkfg/V1oi1n2yUVmcB1z43sp1MwG2bUrzxCn2hCwT6A2gkkieB93a4CNZj6IvHuCx6Fau3X66PRWUOXFgKHw56UV7J2F9VufDys+I+c4FsD5sCTKzQ+VGVeBKvLadqpj5cWUuOSdVTFI8YMZSFUKtiCbJfvlfnwNkO3IB2Po8bgGN7Y150UodGu7NQ8xXn1l5ZPJCFUKGjgMuqT22BnoWUg2iSxK9RseLV1SAotbSwR2Qd6+mihxPbci2VVKZN7ThxQJ+H/zHjZbMQaoOyoKn4Qoqw3nz8IuWzzIRyE98IOFQuoN79iN08+siyCPzjIwoBl4VQhxqKa3eW38dMMHnGgWsaN7Dqo91dihBqe/pAxZyzc25dDUB/ME/h3WnEXIZ0/X9bjv/P3peHV1Ge7d/vLGfNvpEEQgIEsrCDYkVQ0Fq1CmoRd0HrUrRUrda69VOr1k+ttJX6tWqxtli3Wr6C+tO6fFJL1SqgArIE2deEJCQ5J2edmff9/TH7nDnJCQQXPPd1cZFMZnlnOee9536e536yyCKLXnHUfxMWiApmVCXwxh4Bn7Yywx/NOnHylhAqI3yKgmYNvXk5s1doa8EYBMPbEOz8HIC1iMGdwKWzTtDh04b01EZzEuQ5NYQakwniGmdxJXASQ7Gi5u6VtvwbAHBOdRJ+kUeQJGx2GN8NvYhqcgBJCMgTTXsTkTDt2qgLCKgtRwsAuorG4GDpsegomZASyhLTJJHrFZ0R6jFD11pBga7AeZzN4xNdJoE7+WfA8ddBpgz7Igzji5LI72O4zMsBB1gBMOYCdYEcA7yaGa1+v7b/E12cmvel58DZCJweQpVCoLwPouX0nWld1BKKbyQ70M5y4QTl+JSCl1k19g4UOdq9jjM7+SoQ1evVpNnZWX331kdyDR84PdeQ8B5bH1n1PCwETitKuOr/CC54nSFqMU3UFTg9pK63aBM5WEKoKpzqmEdRt9Fte4IZ3janAgeYJNH6wpVFFllk8U3FUU/gAOCEAepkvL1LNXklFq8uAOAdCpzVmw1wEjgFklYR11GgGp8WtbwHwFTg0oVQuTT2peuOewSbxv3MIHB7ui2eZjxDUGSIKhyiWmKcW65ZRDbz5nScNTiJhhIBfpI0CAkATOj+J07lV0OCAI7jDGVQb8Nl8/Li7cSBciJ21V2JnXVXpaotaRQ4PQ+xm/lMoqFdKyMHTvOBe1cZo/493qWZwnLAgFHYxg/BcS+qFailvr6FTwFVgUsosCs7hmGtdr+ojI+8kwFYFDirz5/2nAjJECjvsfVvTUnMF03j54GkDV0siM9ojW0VxgkpCpwzDO3XUgCcClypqI6lW1KPK1t6kHbQIBhV8P62DiMETHjRJbypkqs5yVsRgTreDR3q/g6ETWKmk3hBU9P0Fm0nVyQxOlcv/HAPoXq0bXRfwNwMQ6jgUglcOG84AMAf2ZvZPrLIIossjmJ8IwhcgVcLQynEUJmsyocthMpxKQSOs/TF9EA2JkspoNpiBEO6Aqe10kpD4NIV3yliDuI5g+DTJu+kJUFfJCphS1KCsETUyj6XuxaV1FZagL3llyIEkI+ww5BWhcQE8BxvdItggGpEa5mEI3nDsLXxOstJaH/TVLoXpnXhilp1knbLTBocNIljiHlBwamtupQkQBWMXX4FvsVtgFcLoW5jmgldXFPgtEuxpg1o125Tntj3akMvr7XcshaY6BWulmW7+UEAAE7LgbPbiKg/i1IYCu+zEVbnvXXe6iREXJy8A8/KpxjLKOdNyYGz3tuqgISygLqnmCMHLo+LocRrEllrUU4IATBKcfHi9WBaqJryYkroMdi9XT1nVgYnrG3n9OfBI9vVNJ8AnF4Zs52wk8D5aFTbRuv0IfRuIQIATEglcBEt/zIWqMxoH1lkkUUWRzO+GQTOY060IqerJeYUyzlCqM4qUmLxDyNMNlUkwYukpwCB7h3afnQFzj1/pzf3BJ+LssYTMw+qNaqSNz1PyopuiRmFD9ZzS/pK4UcSJbQtZZskBHA8Z8vNI8ReSUg5L8JFYyxb2cfoEwgCWnWt29ScIzC0azYaMUW9bjIEQJHw2eYtqGj/AI+Kjxkh1BjRQo+6AqeNpcuSfy9ymZEA2zh51QfQRs51Nc5CuFtICWRwFgUutUjFCKFarpvzg8TDfo8k8AghB/fLlxjLKO+xEB6tkMTyjJw5MAa/R71mUUcI1c8SGBRUr0OOQG0h1BALgiMM48gWJDUDZ8YJaR/AOEt9XhOWlwg9hCrSGOJMhP58cTDVZ5X505QqVD9TCV4CIhry4ij0ZtYtgbiEUBXBh8+OfRC7h89x2SKLLLLI4puFo5bAdSdk/L/PDmBf3GNz5heMKk2TiFjNeNU+VHYVgVgUOI7KmFwSxbTSbhBCkPAPgC/aDDCW1sj36alh/HJCB/jecuBcJCyeMAQ1frE/SuDnGc6rTmB6uT0PKCoRM9RrOUzCr6org+lu7GTltm0kCCCEGD1aKdMeCMsknPSqOWH7qs9RJ3KXBHL9tPQrOr7QrOoNCgy/Yhep+6CFxnGhJLFk1Q5jPb0KlfI6gevU7oO685Al1cpNgewNXl5VNm3qqE7U/QXGogOkFAp4owrVXsSQABiDkNQVOMsBnLdWI0thpoYm9TCytR9rOqVWhzXHLu5ofeYjJoEr9SqQmSWEquWzLfXeBX+32vrKGaq1whmeBewKXELbt1eJ2pTA/I518OvedpptiTMv0krg5jfEEPRllgRHXBQ4xnkgewt6bOGWRRZZZPFNwVFL4CL7NuG0Dy6B0q6GiXQVTs2Bs8+2NgXOZV/W8COhMoq9DDeOpfCJPGRPHgQ5AkIlcDSp5gs5SE6hl2F4Ed+rgalAUhtyq1Wo6rL1B4EynwKRB44ttatQMZm5hkl1AudDEu3Ic5wYBwbOIET6ka1hsKRHJV0Hqk7HuuN/A8lTACf0s6UMWHJyF24bbV7PHJFiiTIV0dN/g0/oUAAagaMSurq6zPPUFCtJs99APARKePxuHUF7nCGUtHSY6MWOxQ1ejiGpEHtyvP6zz2wr1k4KIYM3QqhiotP4G6ESOCUBjslQBJ9tHJzj3rZWTMcLysn4H/ls7fxSO19YlVq3J8Nq/JxwhFAjYgmqNAIncmYrsuXKWHQxs43Z8dHlkBkHohG4Dcfch9byqbZ9xV0InDWMryunPha1rWstguCoDAKaEkLN0dqMJZmA/D6Evt0UuB4rU7PIIossvmE4agkc8irRyvJxVuh5EDlmEDg9b8nKk3iadNuDAYPgMQaOybZJSuH94OQ4CJPBKVKPoareQEhqGFXggAKPZuaqEJT5FPA8B0drVkRlgDeUQksI1Vto/sx43J93t/F7hZ8CFgWOMTW8bD0/ybI940TXc9MXMaZWzXotElmOwCBRgqSvRG1uDjWcyOQkwmHVtiPIU6MwQ9YJnBxHc8KDhz8GFq6W0GVT4FLHICY6MGDXa7am91boCpytwMRq2jz1J0DV8UhCAAUPohV9lOxfbqzCUQmC1kaLcj6D+HJIfSmggh//je+rla8wCaptHU5A0qvaa7QPmJJ6TpaH1EqcHhKugTB0CgZqBE7gGJqY2pv0Efl8W0GDD0lIEMA0y5ekrxR7a80wLmDmtFmRtLwfRBUthApFC6Fq40uaFjqEySCMwklF9TZjgiDYbFd6Aye6hFAzIHAyVf+xbF/ULLLI4ijHUUvgeG8Q/y1dAh+Lo7jlfQRE01dNhSUBXXEncHrXAb1aTw+rweJ/JgsB8EocnCKBowkwIoAdxmV1Gp1yhKDUZy4boFVg6kRU0Cb5qAxbpakBwiOqVRhKjEe7d5Chqgm8GqIUDQWOpOTA6QpeT9ArJz0uuWk+XjUU3njQXBaDD0yKIRrtNrbXfeCMECqA1qQ6YXfGJIQsUW43w+AhG3+Pil0vIxja4jpGj1YIYquqFSw/DzoGmHIDZMZBthC4wtaVCOfXAVDz4QwCJ/gg6C8DaXiJwMHowiBaCNwaonrpMW0/n57wO7QOPCVle+t5xi0K3Nn1uQgEc40QKkcYBow7HWPjT2I9G2LLhwO0UHmaCmh1HKnPa8zyKEWpSQj1cXBg8MbNvEpRCiOnY4O92wWA7/CqoV2ZjxnGx5lAEFJDrZTzuqxpx993enDJJw2QaZbAZZFFFkc3jloCJ3AEH7E6SESEP7LX6F4guITfOJsCp04ya4/7FZrG3qpuo7UD0icnalXghAAIKGrXLQCnJNX8t0NU4ACX/C4C5FuKMAYGVCKgE9EynwIChpgM1xAqAESJapchg4fImblXjHCqAmepQnUqcLKYl7I/JyaVypg1OIoLa2Ipf9P3fdGb5omFEYCSiNiMgnXCRAXTfiNK1Ul82W4/1rVb95k6BlEzVOZkd48wn0bgJN4ML9oInAaJAgp4cFQBJ0fBK3FDhSQ0aYQNFYsCl+5u84QhqhE4wWJUfK94A7Y2XAfJV6rtgHPtyOC1PguWnDDZr26XLzLkCBQ8GEYUALlB9drJjnpgVYHr2zMZNytiEFOsBE4dx7SyCMTEQUSDVWgfcAIAYND2l4wCoISmLOoYGKTg+T583QgBPC6fhauV241FTksbN0ha6Ffsy7GyyCKLLL6G+FK+5Qgh9xFC1hJCPiWEvEkI6XdfAIFX87tiJAiOJo0CAT0sFckdYqyr5zsB5mRMxQCS/gHqvrRJmxgKl3nZFI1wDNr2Ajg5ohoBH8ZldYZGCeyVibW56hiisrqw0KPAx6uKieCmwAGIcippkSHAwzEjjKgTNdGRA2fN4WNp+rpawRPgshEyBhemhrjcCg5CCEJOxGwmsDo5JhZS1U3N/e2z9Gn3uhV76GQwDXkO6G3KiNkhAS59b2UKKEQtYtC7bEiiasLLUQmi1pqK8l4zHO96RBURphE4Sw5ckvgQLh7jalZrhbWo5ecTLb5s2jNHCPC96gTGF6jEWRedUggcSa/ANQ863fh5UrFJfmOWd4GIVYFjHpxeHsIPGmT1hYX3YrtmM5P0FiERqMSOuquwd8hs23FGFvTNfNcnAA/KF2OFNMJYZlVn0yFJAZHQXguGssgiiyy+7viyXlN/yRgbwxgbB+BVAHf19wH0cE2cC4BTEkZumR5yjOXWYO1xC4zwmA6bPkc4KJwXvOZ/pStczKHA6eCV+GHlwAEqGbINwTHx6r5ggzUrkSnFEXh5hrgtB86OKFEJnAQeHo4ZVbK66mMUMWgnbzPyTdMWLFN4HYrn4ICEEAsAcsxow0SYWYAheMxJul0JwA3OfQJWEs4Qd/H51btXdFDLPsXU/esKHKEyxIQa99VVSI6ZOXCyGDBz4NJ0oABgKHDWEGpP61vhtYhyg3LMbazVq98bIuGcWvV+yZr6JDE7gVNbv9mfI1lQn4mWwWfigpoY5tZ04Lgyc4xxaw6chcDF4EFE5uEVORAtH7Sz9FgcLJ1kWK50lh6DeND+TnZcad9Cmjp5TVry85QMFDiZqukFvRUMZZFFFll83dG3fkT9BMZYyPJrEO7Fn4cF/Q08ygXhVxLwabzASpCoGHSxcnAko/MmgdNVImuOmJXACVK4HxQ481LkoxuB6C7I+TV49FvdaAkl4RHUma0iwLDk5E6AcVi6jyGqEIgulY4A0AVdgeMhuipwFiNfx/mBc5G7MsCZVQl81k5s4c4ppXEEPASh1iB4OWY2QgcDoRIYCHweU5XqYEHU5UloCtnvUU89ZVuTAi5cnod5dVGcXmVeDz23MKxYHnkXdVHWCZxFgZM1BY4oEoSk2nlA4QPGONJRBQIgouWMuRUx9AZnQUs0pxoxf3naXqB6BbPskgPnfKnYcOwDEJJdYJyIi2olADzWWPIU45J57IjCG696cXiM8yVUMV4CJG8xguFtqp0I4VNCwrzQtyug5/9Ry2cpkxw4iapm3VkBLosssjja8aUQOAAghPwCwBwAXQCm9/f+eW3CipEgeOWgMRk60+ydtgdwqCMK7wMvx7Q/ySnbWKsaxWSX+rfDePu3Tjx/9dyLunV7sOb4hajO8aA6xzEpasUUXh6ISIAX7gpcO1V9wSSNwFEHgdOVJOqiwB0qrq5LQFEoVrabhCwgMIgcQRcLgFdiCMDSpoomwQiPoMc8xzALYHJpHN0yh71Rc0zWnrJESaLh43uM3w/G1b/9317eRuB0BS6UsNxfFyIkaSHUQPcuVG5foi7z5mtjlIxQrSIGDbKdI6YxFiZAlLkocBm+rzhDxZvH3Z5SJGDFneNiWLoNkFtTFTinwS7lvUg6ClRyRWvem7k8qvDQhbCBAQXn18QAeECYYuSDvrlDwrliTCV1PJ/iO9fXlxq3QpXMcuCyClwWWWTxzcARC6ESQt4mhHzm8u9sAGCM3ckYqwLwLID5PeznGkLIKkLIqtbW1oyPz3EEHAFiXAAcTRru/YpjrnUajzrnVsr7wCsqgXMLoUqWJH+DwPWYFdUzrAphHbdH3W+8Pc3aKnw8Q0Qm8BCdwDGbnUaSqCRKZgJ4mAqcTmDMIgatn6WmnnTnDj3k8wAAnudsE7GfZxA5oJMFwTMZ+cT0ESNUDcflec31QwgYzdytsF5db7wVnoQpHek6j8Ls9yCg8YmQrV4l9fGXqar6iFIXBux5HQAgiflg4NQQqqbGKrwXAQH4fm0UtzR0pewHAFpivFGFqufATSqOY1ZVt+v6TrjlcbkVO+gYFKSYP5pCciliyITQVPjND0dc44kKZWB6+zMAg3OBQQXq80SYYhC1g8hFgEaNgqCUz1UfCVVQAAK848OagRosUQKB0LR9h7PIIossjhYcMQLHGPs2Y2yUy79ljlWfBTCrh/08yRg7hjF2TGlpaZ/GwHMEUaLmwAlaqybFwQd6cqgH1CIFXqtsNDsdWDoV+Muwt/ocANBCUoenwH27MlVF422dIlLh5YEtYREejSSoflzmiY4sV8O879Bx4EDNHDhHEYMOxonYNO5O7BxxxaGehgFrEUNAoBCJGhoFgHJ0GOPVFbg8kRk5XCEWQK6owOkIYScj9mutUJXAyU4CpxFJqyGwk8DJlCEkMVuVMQOBLOaAcTxyujZDkLpVBVN7bmbWyKgrcc8THOCnRtXmn5XTAAB3jE9i1ICelaRRhbLLmWUO6rwm6N1EGgD8AvC36SoZTWjcSaLmPgC74kyYYhC1gywPHGEQtCKPFAUuTdg3HTgC3DXeXtWcyT4kqhYqZQW4LLLI4mjHlxJCJYQMZ4x9rv16NoBNR+I4AsepBI4mIGiExqnMOCeaUNEo2++U90FMdgJUcQ2hAkA8RzVR5WmyV0LYG6ZVSJhcmsD5/zQ7HvBSpIctzFwpjxZCJVTWXHnVv0cHn4yb2sbhjfgIDFU6wLTCBLOIIVXl0s/pcGFV4Hw8Q5wxtYgBQDk5qI1XUhU4jkOeqDZuFxFFGAH4eVMZ1GGdnInDhFnWGLqUosCpy7sSAHLKgO4DKWN9fz/hTYugAAAgAElEQVQQkQjEgAg94kk5D8Dx4KiEnNAW5IS2QBaCGZGJh46NoDMq45Ochbj3n8W9rq/jrnFRdMYVeJwlyRlCdGSbyXBvgeYGgSfgwJDQ3lV0AkcJDzDJ1iZOLWIQQBkzW4ZpIWZ6mCFUAAg6Ojdksg89hOrsjJFFFllkcbThy8qBe5AQUgc1JW0ngHlH4iCCpsDxctwIYaUocJawzIaJ9yHps0+0Cu8DpyRAmALOpYgBcObmHP7E4RE4/HlKB7BKOw+555CbnitlKnCK2tZIV014D0rKq4AuoNBDwUfUSTbpUXO7eioKOFzYFTgGRYHRnWAop/bR5JisVvASHj5BrXTMQxQhFkBAQIoCZx0ul4bA7Y8J2NXNYXAONY4NAL9Z58El5z2MUhJO8YFbdYCBgMHv80JPz6O8x7iOOijnyYgQFXgYCjw8AB6XDYtDVGLI5CPn4YGy4KHnIfKOTE8fEkj0gdB4eBiVvLK2K51EU2v7L0rBOAEKZUbhhJtKzUAOSZV2mlpncs2T2SKGLLLI4huCL6sKNW3ItD/BcwQRohrt5isHARSmDaFSwquebi7kjKNJtVWQbpTrXMdSHScmes5XyxQlxMyrshreusHrVOCYguL9/0IiUIFwYSMA4IxBEsYXJlHq5yG2qP09JVFr86RNduP66NWVCazqnp9nKAko+AcrBwAMIqaTvy+6X21eT7RKVAmIwI+AmErgrByZU5wEziQv93/ix5NTVfXSWhCwvh2YVpMajt8fUUkXEa1+YySVsHNin0OCs4ZI+KI+bjc0dANbtc4aYMhlEfQchLfDwzGjmb2uwHEaKbQqzHoOnEIZktq5Gd1ALIRt44S7M1YArXASuEyuuUzVSu6sApdFFlkc7Tiq7cp5nmCDOBIAcFLnUgBAoWgPL+kKHOV9Rmg0JgPrDurLPeCoBMKoQeCoYyKx+lO1VZzUP2OXTNKmV8GmhTbPeYg6eXJUwqDtL2HY+oXGKoQAFTkEAs8ZSf+Sr8j426ITQrhpVM9E8VBgtREJCAzjixXccSyHGLOb2Poie9QQGSHoDlYDAKLwIsizlJpN6+TsVOAUahK4AwkeksbYrYpMMk3R6P4IUOSlYLzf/gcncSDksKxijjQCvPocRHi1wCYHPYfgnfBwQFxRL5iuwPGaz54zB45yIhTKjMKJjw+mmhMnfX3LXbWOw47eSZlEAQ+htkrlLLLIIoujEV/dWagfIHAEm8RGtJdNRqWyFz+uD+PioXYtwlDgeDMs9uh6P/7r4yAORBgopxE4RTJbVTnye6iNwPWPI4pe7QjAqIJNB73rka7AWbd1Q6hQzfNLaAQOAEr8QJ6v/xUiqwKXr+U01eQT7GRqlwtJM5T1xQ8YDdebhlyGy5O3YBcbAA9PMLZIJSR3jg7hntEHbQn5OoHbSNWcPb0H5hDN6DiUMNnaT0ap16Xb3W0F+yMqwaeODg1O5YdQ+ZAUpS8KoaIxiAUqsarwTABAHvpGzEWOIZlGgaPOIgbCQ6bM6L/6/E6X1muHqIbpm92B+dhfdWZG+0lSckRTArLIIossvio4qr/qeI5AoQyR/OHwJNoxrTyG4hx7xaAsqh5pYMyYqLd3q2pCWGJGzg8vxwyyQB1WDjaD0UM0vk0Zu43A9Rza1Ps/+mBXoyQtx82J3cMvxcbxP0Mi0O8dzFJgDV3mWsSZ/Uwljwmf6UXGoJogezwe/JOOB6DO2dc2xPHIxE5MKKEYN8B+7fUQ6n3yZQBU2wsvx3BhndaVwKK2Dda6GWzuJNh40BGeYwz7IwxFXmrrx6oOwv4x4ah0WJXGRxqKEEDT+P/CgZJvAci884MOL2+qlPr1kxyFL2AURLOkUSwEzllAAeCwyO4fJodw8vh6tFTPyGh9vYghiyyyyOJoR0bfrISQYYQQr/bzNELI9YSQgt62+7IhcBwoY4jkDgVHJfhi9spDxoB3O9WiBU5JplSXMmaqa7wcsXhc2Ukg1Xpahgoa+m3stkbvtGcPe32S9TsIXNLjfosYJyIRHKTmnB1hCBaeY/V0CxOVOCtiALLezYJwALH3AOWIqqjUFnKuzdD1e9KtVUFSSuHV/OYAU50ETDPfxzeIOGMZA7Uk18UVtb9svkjt99eFqJE0PWe/UiAEokd9dpOsb8qqmgNnD6FGePVlQLdYIVpIlWpFDLr1i0j699qUBoCSYObjlyiBh0sTI88iiyyyOIqQ6TfjEgDHEEJqATwJYBmA5wB890gNrD8gcASUMcSDAwEAnkQbYrmDjb/vjXJY2lyGi70ARxMuvmBm1Z2gRA21J6X9FuGw7rhf2sxzD3vsmgJHiYDiA+8jHqxE68Bvu66rK3B+kkA3yUUOU9s9EUY1O5EvTy2yHtpqTDup0gs0A4zzQOH9EOSopoASWN0zektl0glcGCoJpIzCyzGIGtmz2sb4He7+EqXwaoppRAur+ngGZhm008JEPebXgMBBbQj/g+SP8TkbiF/1YTsPB0gyBXa+DzlwHACCiFCAIvmAQdz0lwpGnAqcDMbUTggMBLHgoH4+q56h+sD1z75Wr15dJgjCIgCjcJRHK7LIIouvHCiAz2RZvmrixImpvlfInMBRxphMCDkXwG8ZY78lhHzSb8M8QhB4AkoBWVTzrJzVnDIDmqGG8sxm6CaSiqmucVLUKGJw83pTtH6Z/QVejoISHrKYA0+yEwO3/w1t5SdCkCOQvIW2dU+uTOLTgwIGeqJQ/OVAWCdwCtQKh69GuM+aWM486j1hhDdUTp3A2bbphXwSJQkFZlGErsB5OLuCBAB+h+CoWBS4qMbJ1IreXo5J0yTRfcXgF4A36LHab6Ee17XCwzPUJLcA7y+Eb+T1AL6FCK+quWLS+mwBlE8lcPojt2bK78H1VoDTz5AoMTqLHC4EQVhUXl7eUFpa2sFx2bhsFllk8cWBUkpaW1sbm5ubFwGY6bZOpm+VEiHkIgBzAbyqLXO3n/8KgdcUOEVLlOcURwEDMz3J3CAxU4HjlWjaHLgjAV6KgPJ+MIvvVv3HP8fIlbcDjpDqieUy/ja9EwV8EswTxAenLkNHyTHqJNuPquDhwqqmKVqeGWEKFL3qk3ApaiHpRYLjaBJJeAwfMkqZGkLVyJpi8Y3hOcBrmYcTlsuoK3BehwLnBv15+qrDqThmCg8H+KjWPq5rNwDgg+JzEc4fga6iMQBMAqcWMVDDRkSEAmqpG07JJzzCkJj9Hh8mRpWWloay5C2LLLL4osFxHCstLe2CGgFwXyfDfV0B4HgAv2CMbSeEDAHwTD+M8YhCz4GTdQLnUE4kCsThhQKCnQXfwt4IZ6tQTFJiKHCCbIZQnTlwR2TschSK4LeRRa/mMeeNNaeuz3PgaBKU8yJS2ICEvwyEqoa+PaElRrCj+/CjQ2EJ2B/tmfjwnMXclZjGr3rVpzMHscLXu9LFUQlJ4jFsLChV4OWYYUHhbKll5WZdCRcFjmOQvEVIh91DL8Cu2ot7HddXAak2HJnByzOITH3WdQUtLuRj6+ibEM0fBsDMA6Scx12B+xLAmKrA9WMRA5clb1lkkcWXBe37J+03eUZSEmNsA4DrLb9vB/DQYY/uCEPgCKKUQRHdFTg9UXs6/yfsahYBjRcN0Jp6S9RahWpV4I4cgQuEtqKm6SlIYh4o53VV+wKRPUhoeX1WcDQJhfdpY/Sok2wvCtwP3lNDv38/pavHfpndEtAS4zAsz50Q3r4yiD1RHn8/uStFNbt5VATxWBxW0ZZZkuEVjcDpYweAF6eHIEkKgJ4LLTgliQQ8arsoAGAUPp5B5AkAZguhAvaq1M64hcBZcuBChaOxt2YWBu5YknK8jgHHg/K+lOVfRei3MxMibIXIASJLAMRMOxAdt8FQ4DgBMmWQLUUMXxbjMex0stlqWWSRxTcAPRI4Qsg69PA+zRgb0+8j6keoIVRAFtSKR6fpa1JL/nd+3zON9HRJPCJUq0KVIiBMy4E7ggSucsff4UkchCdxEN25Q1NUKQDwRlMVuKKW98ErcVCtPRTlPVpLrVQjXDdQysDz6Qnc/Z8GsKlLwEvTOiG69OjcE1XH2R5XUBKwP1ZTyxU4I+56yzLJk28wDcVioOvlAS9vnrs/vAOymGeYD+vgaBISRIPAMUrh4+FahQoApT6K5pi6rt7Yfn+E4bI3mXZcBhAObRUnoXLH39FarhozN429HTldm44Ief+0nceKZhE/Gtn/nTB+f3wIPJXRly4QHg7waAqcoKjFNM5Hwyhi0BQ4awj1y4ra62S9H0OoWWSRRRZfWfT2rnoWgBkA/qH9u0T79zqA147s0A4fIq+GUBnvASWCiwKn/p9OeHpqSy5+vFotGBCUyBeSA2dNkKe8z5UsurXWGvz5YgAmCWKcR51k+2k23RJSSU9zt3bRGMO4f8/DgJ2vqGMiOhnKrGCiu6Ae2xquxf7qmUY4VekhX6puzYMYueqOlOWEKZDA2wicX4BRyepsnfbgsVFMKFKfgy6Nz39sqe8J6EIe78GaEx5D26BTEZOBR/bUYWf5aUfEeuWeT4L4v/0edMf7v7q1IgiU5fbRRoRn8DD1GomS2odXcBI4p42ItQr1MMd8qNBfyPqriOGrAJ7nJ9bX1zcOHz585BlnnDE0HA67fmefdNJJtW1tbX16OPVt2tra+AcffLDXdhmvvvpqbm5u7rj6+vpG/d/SpUv7t3rLgRtvvLHySB9Dx6xZs2oGDhw4ur6+vrGurq5x2bJlh3zchQsXFs+ZM2dw72tmhptuuqmyrKxsjH7dr7vuuoEAMGnSpLqamppR+vLTTz99qNv69fX1jW1tbbx+DxsaGhprampGHXPMMXXPP/+8u2EogFtvvbVc315/Fuvr6xvvu+++snHjxtVTrfONLMtoaGhofOutt4LWYw8fPnzks88+m9/TmNyOGw6HuZkzZw4ZMWJE4/Dhw0dOnDixbvPmzR59u5KSkrHWfcXjcQIAzzzzTAEhZOInn3ziA4CPPvrIr6+Tn58/Tr+/kydPHtHU1OTx+XwTrON57LHHip1j0a/xiBEjGocMGTJyzpw5g63j1q9LbW3tyLq6usa77757gKKo34/Wz8zQoUNH3nzzzRX6dsuXLw9MmjSprrq6elRjY2PDtGnTaj/66KM+JQ33+M3OGNsJAISQUxlj4y1/upUQ8jGA2/pysC8aAk/AGAPTChmcClxC+8IngKZUkRTFKsZURYuTYwDh1UrJI+ifZs3TUwQ/OCU1/NWTD5le0WmEUDOcTntbKygwdEkEYUm7Zto4y3e/hpbqGSjxMbTECFpiHEZndEQgVDxW25eWT+VsYZXRwClk8FCMdxEKv8AMAufMgSvwMFw2XMLHH3oR0kKo1jCrrRkF4cAIh9d3efDWXg9EJuGaxp49+Q4HYYkh5ysQnfVygEfzFBTlNAqcQeBEWyeGLzMHTg+Pe44iBc7r9dJNmzZtAICZM2cOWbBgQek999zTov+dUgrGGN59990tme7TuU1TU5PnqaeeKrvttttae9v2mGOO6V6+fHnGxzocyLKM3/zmN/u+iGPpuP/++/dcccUVHa+88kru/Pnzq88+++zPvsjj94R58+a13HvvvS3O5YsXL9524oknprzVp1vfeg/ff/99/+zZs2sDgcCOs88+O+xc96GHHmp+6KGHmgEgEAiM159FAPjwww9zfvOb35TcdNNNbQ888EDZ2LFjI6eeemrk9ddfz9eP/fHHH/tOOeWUugsvvHBNT2Ny4oEHHigrKyuTXn755e0AsGbNGm9VVZWkH/+mm26qzMnJUZz7euGFF4omTJjQvXjx4qLx48fvmzRpUkzfZtasWTVnnXVW1xVXXNEBqM99VVVVwnpO6aBf43g8Tn70ox8NPOOMM2pXrlzZBNg/o3v37hVmz549NBQK8b/+9a/3Wa93KBTiRo8e3Xjuued2VVdXJy+99NJhf/rTn7adeuqpEQB44403cpqamryTJk3KuHQ/01dzQgg5gTH2nvbLZHwNfJH0ECoDIIuBFAUuaVHg/DwQVeydAwAgBpUQFbatRkH7J+YGvYFRcFSytdnKBDYCx/tTCi8AgHcQUSv0nD21h6vcaxGDMdxe5ryAwNAlAQfiHBphtvfSQ7zFXoqWGIe2BA84jinG2zFs/UJsHXlDSggUMEPbbuHi3kCYoqlvBEnGgzCKgGCGUBWX08/RWnq1aRHLVsvHxa1yU0/pi0pHlhgcAQHukCByDH6onxWvHDKWWWFWodptRDyQbVWoXyR0Auf8DPcHbvnbmqrNzeFAf+5zRHlu9Jfnjd2d6fpTpkzpXrt2rb+pqclz2mmnjRg/fnz3unXrgq+99trn06dPr1u1atXGiooK+Z577hnw7LPPlgDAZZdd1nrXXXcd6Gmbm2++edDu3bu99fX1jSeddFLowIEDwve+973Oyy67rBNQieP555/fUVBQ4Pr28u677wauvvrqmk8//XSjLMtkwoQJDc8///zWlpYW8Z577qnMyclRduzY4Zs8eXLomWee2cXzPP73f/837957761MJpOkuro68cILL+zIz8+nAwcOHD1z5syD7777bt6NN97Y/MYbb+Trk+6KFSsCN910U1U0GuUKCwvlZ599dkd1dbU0adKkuokTJ3b/+9//zguHw/zjjz++4/TTT++WZRnXXXfdoOXLl+cTQtjcuXPb7rzzzgPp9mM9p1NOOaX7wIEDRvijp2OPHDky+sEHH+QqikKefPLJ7dOnT7eRqeeeey7/wQcfrJAkiSssLJRffPHFbZWVlfLQoUNHffDBB5sqKytlRVEwZMiQUf/5z382VVZWfmHfBJMnT47dcsst+x577LEyNwLXE/7nf/5n95QpU+pOPPHE7kWLFpWtXLlyo3OdCRMmxHmeR3Nzc5/CAPv37xerq6uNiW7s2LGJntYHgK6uLm7lypU5b7/9dtPMmTOH6wSqP+Hz+djvf//7PdXV1aM/+OAD//HHH28jWwMHDpQXLVq0Y/LkyY0LFiywHT8vL4+OHj06umnTJu9LL71UcP7557fr5A0ATjvttO6+jidTEvZ9AL8jhOwghOwA8Dtt2VcaupEvY6r1g15FqsOqwOlzc1K3TtMQQgCdLGiSNyCjRuYDt72IMR/cAPTR9JVYyJkiBuAmZ/TkQ6aPjXIelbz10sXB3K5n6Gltv2kqQHuMme29CEFR83vwa+73cZpKbkuaV8AXa8GA3e5Rd9NfL/W6Dtj1Kkb95ybLQO2MjDDF6AKggIcAxRZC7ZIIDiYI5rybg/eadbLJEOApNnYAv/qE4ndrzbP3u3zN6IqOxDILD/cVghZ+1hvIf1FIR9o9PBDQCJxH7gYBNUOojGLkhz9F1eY/AwAU3mtrZi9AAT0C/E2hwOObfNgTSf/Z0w2tjwSB+7IhSRLeeOONvNGjR8cAYNeuXd758+e3btmyZf2IESOML40VK1YEnnvuueLVq1dvXLVq1cbFixeXvvfee/6etlmwYMEeXYl44okn9lx11VVtf/7zn4sBoL29nV+9enXOBRdc0AkAq1atyrGGnNavX+896aSToqeffnrnjTfeOPCHP/zhoNmzZ7cfe+yxcQBYt25d8He/+92uLVu2fLZjxw7v4sWLC/fv3y888MADFf/61782b9iwYeOECROi99133wB9PMXFxfKGDRs2XnPNNR36skQiQa6//vrBy5Yt27p+/fqNc+fObfvJT35iVHLJskzWrVu38aGHHtp97733VmrnVbpr1y7Phg0b1m/evHnDVVdd1d7bfnQsWbIk/9vf/nZnJseOxWLcpk2bNixcuHDnNddcM8S5r1NPPbX7008/3bRx48YN55133sF77723nOd5nHfeee2LFi0qAoBly5blNTQ0xHoib48//vgA/bovWbLEaDo8Z86cofryH/zgB4Pc1j/uuONGpNvvpEmTolu3bu2z9l9dXS3NmzfvwLRp0xp+8pOf7B8wYEDKZPPOO+8EOY5jFRUVcl/GdM0117T99re/LR83blz99ddfX7lu3bpelZDnnnuuYNq0aV1jxoxJFBYWyitWrOj1hUt/cdH//eMf/8jpbRtBENDQ0BD97LPPXK9ZY2NjUlEU7N271zabNDc385988klw3LhxsY0bN/onTpzYtybVbmPpbQVCCAegljE2lhCSDwCMsa7DPfAXAZ5TjXwZGGQhB4JkNzM1cuCghtEIGCiII+xGsIYOw0n8Wtuy3lDSvAIA4IvuRzynKuXvy/eL+Owgn5K4zltIpiK4P0tuqpy5vbo/XYnL2HQ2AwVOx+4uBYOCcWMsg7c8gyHeIViNemMSte1aU9a4ND1duwvqUXBwDRK+1DScil2v2n5XG6hzlt8pJK1AQtIIXFA03fj/sCUPf9ACPn/drGBKmQyOEzA8T8H6gxz+scd+PN5FXU1nSdJf4NSC2S+UwIWSBHP+lYsbGyOYVmn/3vVyDH6i2YiAogDd0LuYcUoCohSCqH2WmJYDx8BBZhxEIkM+AgxubQePf+zxYE+Y4v5j3RVo6QgWMfRFKetPJBIJrr6+vhEAjjvuuPANN9zQtnPnTrGioiJ5yimnRJzr//Of/8z57ne/25mXp5aLn3nmmR3Lly/PnT17dme6bZw488wzu2+44Ybqffv2CX/5y18KzzzzzA5RVD9j6UKoDz/88P6xY8c2eL1e+vTTT+/Sl48ePTrS2NiYBIDzzz//4IoVK3J8Ph/dunWrb9KkSfUAIEkSmThxoqE+zJkzp8O5/7Vr13o///xz/8knnzwCUMPApaWlxpfb7NmzOwBg8uTJkVtuucUDAO+8807evHnzWvWxDxgwQFm5cqWvp/387Gc/G/Tzn/98YEtLi/jOO+9syuTYF1988UEAOOOMM7q7u7s5Z17X9u3bPeecc86g1tZWMZlMclVVVQkAuPbaa9tmzpxZe9dddx344x//WHL55Ze39XRf+iuE6gQ7jDzp22677cD9998/8Prrr2+3Ln/88ccH/PWvfy0OBoPK4sWLt3GahVSmY5o8eXJs+/bt65YuXZr31ltv5U2ePLnh3Xff3TRhwoS0lV5//etfi66//voDADBr1qyDzzzzTNHUqVN7JEmZhlCd6Ms1W7VqVU5DQ0Mjx3HshhtuaD7mmGNSzmHMmDH13d3d/EknnRR6+umnM/6u6ZXAMcYoIeSnAP76dSFuOnQfODBAEXPgTbTZWkvpSc8KU1sm5QgM3bLZyFvHGjYUJ8FC4HoJoYqJDrWNFYBgeBsIo4jlVtvWeXS9mu919YgIfLpHA6M2kiO5EDhGOBBnXpxFZdNDm0YHiR7Crbb99sLgrAROBjGOo8Mjq9+/kkvI0iRc7tetrWIaQgUNkHwp+aNq8Ykl549QxVbYQagMWQtzyxqBCwj2dlw63uXmoWvjKGwfOR/D8ig+2+VJWYe6fDBFXs+V67+sgU2dPEp8FFXSDvhIPfxIfKEErj2hHut/NgYwrdIeOfHygB/mc1hCQhA41YrHGZJnvAeylkQoQYAIGa1xDvviPOoLFCNNwXOIqtiCdX5MKJYQktRrXyCmTwnQXx58R95n+wuDNb/GikAg0OeGr33Z5oILLmj/wx/+ULRkyZKip59+ekdv67e0tAjRaJSTZZlEo1FOJ5BOayJC1LzkKVOmhF555ZXtbvvKzc1NGSdjjNTW1sY+/fTTTW7b+Hw+BqjqiKKk/yD1th89B+4Xv/hF2VVXXVWzfv36jb1t43aOVsyfP3/wDTfc0HzJJZd0vfrqq7m6QlhbWyuVlJTIL7/8cu6nn34aXLp06bZ04z6SWLlyZaC2tvaQSuB5nne1n8qUqPWE/Px8Onfu3M65c+d2zpkzB8uWLctPR+BaWlr4//znP7lNTU3++fPnQ1EUQghhlNI9HNe/2V6yLKOpqSkwZswY1xDthg0bPDzPY+DAgfKaNWtcX3oaGhpiq1evDlx66aWdALB27dpNTz/9dOGrr76atqDEDZme2duEkJ8QQqoIIUX6v74c6MuA3omBAVAEn5Ysb3436ApcTPu8B0X3UFY7s19Tt/6YVjSuNKslq7Y+j7o1/51+ZQtf4JQEiGWBLAZT4lyykJNCyqy/Hxj4HQCmApdp387e3iesYakk48wQqgZBI1lJVwVOfczS5uMRgmSg3LXiVvLaO2UQRxhcVeDUGVuGAAEyckSkELh8qAQzv0PNSS7wMFuf1BNKYlgwsQN+p+EZYFwcpyXJ4eC2VUEsfn8b6tb8N9aKc7HGdw0SzpLZIwj9sZIYQbsjZTbfQ40QKgCUkC7jehLn88SY0ZJMggAPZNyyKh+3rQpCUSiuWJGLi/5pFvNxSgJVm/8MXuo93YMyYEWLiEc3BIzQab6nJwKn/v9NthGZPn1692uvvVYQDoe5UCjEvfbaa4XTp0/vMbcpPz9fiUTssel58+a1PfHEEwMAYOLEib1O7ldccUX1nXfeue+8885rnz9/vhHGW7duXXDTpk0eRVHwt7/9rWjq1KnhadOmRVatWpXz2WefeQEgFApxa9eu7TFENmbMmPjBgweFt99+OwioYc1Vq1b1GPY75ZRTQk888USJJKkvvC0tLXym+7n99tsPUErJkiVL8nrb5vnnny8E1CT03Nxcpbi42CZph8NhfvDgwRIA/OlPf7K9pX7/+99vveqqq4bMmDHjoCB88W8eH374of+Xv/xl5Q9/+EPXXptfFt58881ga2srDwDxeJxs3rzZV1NTk1aNeOaZZwrPPffcg/v27Vu3d+/edc3NzWsHDRqUfOONN3oNifYFiUSCzJ8/f1BFRUXyuOOOSyk22Ldvn3D11VdXX3HFFQd6Io4333zzgRdffLH4rbfeMtr6OD+DmSDTJ+YC7f8fWpYxAEP7esAvEgKvFTEwtSCAUAmEUSOkl9SIWkxWr1uuyNASszdAv7oujrbPHaH03vpzutEhprhXr1qbvTv6RlLen0IVZTFHDaFalBDn/kcAACAASURBVESdwO0cPhetg05FXFKgEFH7W+8h1BqyH4VtGxCrODbtOtaoWEIBONn+nc5B/c5yI3DQFbhDmFclMQ/euBlZEOQIFK+R/mHkwAU8PGRwEEAhimYRg47BxP795CQCJ5dHMKwwVZEDzNBpf+fADSCOSFEiDCB9a7f+hPVc/rGbxyUjzDmnwKOGUNtYHkpICCXogkDU6nfiyKkUpLBB4JIQ1Bw46J8riois/swoA+EIiptXoPjAByBMxq66K3sco17xDMDYDwUHZ5GMcU5HsIjh64IpU6ZEL7744vYJEyY0AGoRwwknnBBrampyf7gBlJeXKxMnTuwePnz4yJNPPrnriSee2FNVVSUPGzYsPmPGjE7runoOnP77rbfeuj8SiXCiKLJ58+YdlGUZEyZMqH/55ZdzOY7DqFGjIvPmzRusFzFcdtllnTzP44knnthx4YUXDk0mkwQA7r777r1jxoxJm6ju8/nYCy+8sPX6668fHA6HeUVRyLXXXtviFo7S8eMf/7h18+bN3vr6+pGCILC5c+e23nHHHa2Z7IfjONx66637HnnkkfJZs2aFetrG5/OxhoaGRlmWyZNPPpmiKt555537LrroomH5+fnylClTwrt27TLI6kUXXdQ1f/58/pprrml3bpcp5syZM9Tn81EAKCoqkt9///3NgBnG1NdbtmzZFsAM6cViMa64uFj65S9/uauvBQyHCrcx1dXVpRCzzZs3++bPn18NqD1Bv/3tb3fNnTs3JbSu46WXXiq65ZZbbAapZ599dsdf/vKXojPOOCPt26KeA6f/fumll7b97Gc/SyGzc+bMGerxeGgymeSmTp0aev311w1FTU9zkGWZ8DzPLrjggva77767R/Vx8ODB8jPPPLPttttuG3TllVeKxcXFcmFhoXzPPff0qfAi004MKYmZXwcIHAGlDAwMlPeZxEdDQvvCj2pELsfFozXHQ7CT2O0tMilicIKTE6CiSgStlZHU8rMelmwvOx7FBz5A0mNvWg+oxRhqLh+F3qVAJ2kK7wcFwfznP8ZPyrswCi6KiQve9PwUnq0K1gwYl9akWGGq15vCCOIKB55z5O5BPU5POXCHwuD0akcdgtyNhOPvEniMqyqA0OyBQBUoYCkKXDVRP0+UEwHGkOcxx3JNbQjjy9Ib9Ork1e3cDgU60Ygy+4u/nGHByeHgT597cWyJ/ZnollOtVvxIYA8rVQkc6TKKGJwWNglfKWStJZkMXrUR0cHsPxKY3VBIBjkkBxPmuHT109lZw4qjMYQajUY/cS6rq6tLfv755+uty/bu3btO//mee+5psVqNZLKNM5wZDoe5HTt2eK+88sqD+rKzzjorHA6HP3Ub5/z589sBNYS5du3aTYDhgaW45czNnDkzPHPmzJSqReuYAGDJkiU79J8nT54cW7VqVZNzm48++shYVlFRIev7EEURixYt2gPAlumabj/WYwHA5Zdf3nn55Zd39rSNtl77H//4R1vekpYT1g4Al156aaceKnPiww8/9NfV1UXHjx/fo8r5q1/9ynVit567c323berq6pLp7mFvcHsW3ZanG2u6Mblh/vz57fozlW5f1t8//PDDzc51nETMeX/r6uqS8Xj8497Gku4a61AUZXW6v5111lnhs846y5Ucn3LKKRHdiuRQkTETIYSMIoScTwiZo/87nAN/EeCtOXC8GkK1hvH0UKmuGun2ElbkiECU9E2Bc0Nbh5k+2JG0TkyWZuuaAneg6nS8O+M9tNTMhJP06AocsVRj6tW1ihBAWPOi2NiqTpTrOznXvDQrPEQlDpycvlJboUBAywVLKKkFCT2FUM3K0b4TOKf1izP3TlfgRJ5DSUEuxuZ2Y1qVkELgqohqcaXwPoBR5FsIXK7IwHHp76lsIXAtMYJnt3oPyx9ZD90LsJOhF3YVoTvRP+G/st2vY8j6x2zLGAOW7vTiztVB2zPhTBnIExkCSGA/K4LMOHsI1ULg9lWfg/bKafh4l/piLDEBHmL+3RoR1pN+OaPIpveOFu0J9aA8MVui9aSCZkOo/YOlS5fm1tXVjbz66qsPOMOBWfQf7rjjjvILL7xw2AMPPLD3yx5LFl9PZPSuSgi5G8A0AI1QOzCcAeDfABYfsZH1AwSLDxwVfGqokTHc9GEQJ5QlEXMoD7muChwQhdNgtgcCx9zZ0r93RjGzDFjfwaPTQuAky9cjr6gFM5KnAJLf3RhdFnPUylILg9CtRxQhiI6opkZr/nNPbS3A4JiIqxt6D6V6Em0o37IYO0dcAeroiqAwtZAhLANl8W2o3LfU9neTwKXuVy9CyER1ccLpeZeag6UgyQR4eAKuoArDpM1AUES7g4vmk4g2BgWEKcgXzUdfLdBIf08VjZTuiIi44T8C4grBxMIY6ovc33+W7xPx6AY//jglhCKXLB095zJA7IP0kQTWtnswufLwlb7KncsAqKFuqvWatebwWStqYw4Cx3OAnyQQZT60Iw/FCIEzwvXm9ZeFALolgq2t6rVNakUMOtzIPK8R8kz6yXZoCpyPZ5C1fck9qKC6ApfthXp4OOecc8LnnHPOut7X7Bk9qQ9HC3pTZ3rCAw880PzAAw/Ywn633npr+bJly2z55WefffZB3Uz3SOLLOPaSJUvy7rzzzkHWZVVVVYm33npr65E65tGETIMN5wEYC+ATxtgVhJABAP5y5IbVP+A5olocaDlwHJNBFRnbwjy2hf2oy7eTgVwXBc7DATHOVOAkMadHBU6Q3L+vfFQNw/9uo89ms2CdSHUFLilaiiacRQxirqHA6X/Rc+BkIYCOiEZ4BC9AAS+S2Bc1Z7SkAly+IhdXD49i+kD7y3X5rv+H/I51KNm3HAcGf9f2N4URBAQ1bHti9+up5w1TgWOM2SqTTNLV58K5FAUOjhAeYRQJxqv9WQtrgZ3vA3ISArGn/OhVlbwcA0eTyPOYf88ReiaWVuKjq1XhBEU6AfvNfeqbwPo2BVMHpSZkxbUXhwDsKqYfSTTH/DjUVgYtMYJCD3NUfFpSBiy3O6GdFAfmWv3qRwJR5sVBFKCEdEHRnkNrSJtxHiQsMU1Jy4EzfqfAePK51l5LzaEz29GlTckyoL/oeLkMFTjtVH0un+Mssvg6wNr54Jtw7FmzZoVmzZrVZxuPLFRk+q4aY4xRADIhJA/AAQCp5mZfMeT7RcQlBUlFMXqEdsRMAhB1KnCWOeXuSeqMkStQxDijUARN437W4zGFNNV1+sQXShKEJfOyW839dQInWyovnQURspgDTknaJlIjB04IoCOqmeKK6vnqfl46uiSCqEzw6MYgnNDDW27VogpT+2H6eQYvjSGSU4PWiunmeTP1uBIlKfxD96ILhrdl7ktnjMlZcWsnnYQpUMDDI/BA0VBAjgOxtpQihqCmdhEwcHIUIgeMKVTHUujtecJ3Kw5NugSWdkc4rDvIG22n0vmhxbRtA3AocEiiOZ7ZO5UvshfF+981fk8owA/ey8VjG5zFfOYzblXEOrXLWuB1958r4OI4vkxCUVklxvoOwKfFUK0KqMJ7IFkSOhMQjQ4OgJpb93fv3fir9z4wLdkzhZD3AMmw+SGm0XYP7wD6PfH2EA7PIosssjhakKkCt4oQUgDgDwBWA+gG8MERG1U/obo4AAagJRTHSC2k2BFVJyA/TxGTCcYUJrG2Q2VuAS1TO0eguLyRx7erKMoCfsQ/Mmdr2dtzlWA6gkKoAsbUajrrtC4pVgVODUXF+Vy8snYf8n0ijnPsRxZyQEAhJtqhiCoJ00kOFfzojJo/I6GSAmt/+aTleE4zQj285VakoRcxBETAS2NQ+FxbGExkZhEDZQy8hTjoYTdR6kb5zlewf8j3XK9RChgFx+zX01kFSahaxODhCFA8XF3Y9jmE6krbelZfMzEZhuQvw88nxNAZ70aet+f3GLfEeTcl6G/bPdjQwaEioF5XJY1a5AyhxpgXfpLAiGAEW+O9v1MVtnyA6s/VTggdpceBCj7s1irQN3U6FT93BU4PTxZ4gZjC2VVTRsEzCTmBACjvQWHXBvBEV+BMAsc4r42kdjM/gsS8zmFLqgCf7ALEYguB610l03PaEpSYClwPIVRdzc7mwGWRRRbfBGSkwDHGrmOMdTLGHgdwKoC5jLErjuzQDh/VxWros7krAUXL6eqMq7NYvkgRU4DKgPllX53LEBAY5jdEQQhBVR4Pr8CB5zP3JeDSNJonTEZMASiIzUfOOgEGQ1uR8BZjc9iDZZ/uw+L/7EyZ5g4OmAwAKNv7lrEsKek5cD5ENBkiylRS6kfSto+YZRI/ELXvnaPa5OrS0kolcGpLLR+LQxH8oLyZNChCV+Dcz12HJ5G2EjwFTvXNuS8AAKNQoIVQh0wFAsXAjvdSFDir2qXnGhICFPp5FLd/jKKW99OOw42IualWCYUgrhDj7qZrSGANoXYjgO/TOwEAZZ4EwnLvH0mdvAEAp5H+nd3qMzrAr9jzIy1336rARSWTwO2MCHhxmyk/m4quHwlfKQQpbFaPWhQ4ynttClw3/MiFWWRitQHJDatFjum6cbjBIHCK+bNB4JiCQVuehcdiMWM0s3fpZ5tFFllkcbQhIwJHCHmGEHI1IaSeMbaDMba2962+fAwuUhWq9kjSUIsimgyRI6q5P9YOAwU+4LNLOFw53u79x3PA/xNOxb7qc3o9plMh0sExGd1S6qSvkwNCZeR0bUa4oAHdzAyDOVWyUNEYRHKHQJDNDiF/3qTeRlnIQVyriogoKrnyOkKoVuKxaLO9UMFtkgYAXoqgWGkDT4AckcDHYlCEgC2PyQP1OElKUoiL1YtO8uQhUxiE0gKqpIZQJahEG4IXqDkR6G4GYRQcMQdiLRhw+u3VNC3C4M8Xpy1A0dVHK/bFBDRH7fdTZirB0I9L0xRGaO8QyOMSiMGLKFXvVRGfQETioNDMcwUF7Vx0Ba7Qo9hJEnNX4HTrHP35f2G7+SzoRTGU9yMeqATHFIhJlXhzltC9M4TaDR9yLASu2xLv9CYOaOPVn9veSZZesMBAjHSHqEyw7iAHf/celDSvwND1vzXWT1ICApYtYsgiiyy+Ecj0q+6PACoA/JYQso0QsoQQcsMRHFe/oCTHA4EjCMclQ4HjNVIgUZU85Yim/5tAVDsJkbdfFoEAf/JejANVp/d4PKIkUWpRxqzgmIJul+iqPsdxShwck9HsqcbCd0zbJOaczAmBLARtuUR6Mrwi5iChyRDdGinwI2GjEVYCt7Ldni+lK17OTg8Nq/4Lz8k3gScMC6W7kYdICoETmbWIwTFkq2pDMjfpclPguiX7zgkoZPDw6D4XueWqIa4i2c47gDhatY4a6VUgd1Khq49WEvfy3hzMez/XRrAlSpCgxMiBc7VUgRlCzedVAtetqaVFQhxhmaAP/M1QE/WXA8oIBNmSh8nU0P2qNgEJy73XCVFX0j5GMdFh5mIKAcSCas9ub0wlYLZ7yXkhK84QqkngWMJsuykmwxDj7fDF1BxpkoYsW2FVc7s1ZXJ3VMB/fZyDbd3q8y0kQ7b1BQ49WsJ83cDz/ERrs+077rij/Ege79lnn80/0sfQsXDhwuLCwsKx9fX1jUOGDBn585//vOxQ99XU1OQZPnz4yP4am+ZhN06/7pMnTx4BADfddFNlWVnZGOs9aWtr453r19fXNy5dujQXMO9hbW3tyLq6usa77757gKK4v+gvWbIkT98+EAiMr6mpGVVfX9940kkn1Q4cOHD0rl27jC/Qyy67bPDtt99ebj320KFDR958880VbudgHZMbbr311vLa2tqRI0aMaKyvr2985513gqeeeuqw+vr6xsGDB4+y7kvvILB//35BEIQJDz/8sGGbMGbMmPr6+vrGioqK0fr9ra+vb2xqavIMHDhwtL7/+vr6xssvvzwll956jaurq0d95zvfGbZ69WojX2fSpEl1NTU1o0aMGNE4ZMiQkXPmzBls7T+rX+/hw4ePPOOMM4aGw2EOAHbv3i3MmDFjyKBBg0aPHDmyYdy4cfWLFy/+YpzTjxAyNfJdTgj5F4BjAUwHMA/ASACPHs7BCSE3A3gEQCljrMdGvoe4fwS9ApIKBdVy4IyuBRF1AsgRCfI8QLcE8GkmcJFzT2R3YuD2vxmtmpzgmYSQiwKn5/boRQkrDtir85xqFgMHRcyBaJm4ghqBk4UgYpLquxkxCJw9hKqrP1c2KHhqoz00rCtexEHgBI0kiETBcPlzAIDEB8GsBE4LoSYVGBWLOgiTkfQUwpPsSN9OywVuCe9dCQajJpgxcEyBDB5eQTuXnDK1kCEZAoPZtSaXxNHCClFKuoxcPyc2dPAYnAuEJA7XvZ+D+8eHMapYrYDkCQNPiC0EDTBUbF+CzgHfQjw4CDJV1SL9WUlH4HQSnUfiiDEvIlS9jvl8AhGZQ0JhEDPkuZ54OyL5MMiZzAh4ySROhMn4V4uAX38WwIQi877qClyHxmVzBApejmDkytvRnTcMgBpCjWsEzhNvN/anwxpCvW7aMMTfD2gKnGbLkjSJZEXLclS0LDePLzN8eEDAcWXpjaateYbOa7mzS33eBIsvoEwBkTDX3oxfV6TrhXokIEkSLrnkki4AX1jP6xkzZnQsXrx4V3NzM9/Q0DDqkksu6aitre1bpdMRglsPSyB9n89061vv4d69e4XZs2cPDYVC/K9//esUU1trVeakSZPqHnnkkd16o/qHH3649Ec/+lHVsmXLtv/73/8OfPjhhzmLFi3a+NZbb+Xoxw6FQtzo0aMbzz333K6exuTE22+/HXzjjTcK1q1bt8Hv97P9+/cLiUSC6HYer776au6CBQsGOPe1ePHiwrFjx0Zeeumlop/+9KetAAwj54ULFxavWrUquHjx4l3Wbd59993NFRUVPTrMW6/xH/7wh8LTTjutbu3atesrKytl7bjbTjzxxGg8Hic/+tGPBp5xxhm1uimu9XrPnDlzyIIFC0rvuuuulhkzZtRefPHF7bpp9ebNmz0vvfTS15rAZRpC/T8A70FtqdUE4FjGWP3hHJgQUgXgOwB29bbu4SDg4ZGUqVGF6vQV8wnM8H+Lp2l2yXPpE9Jt+4qmN5kWmOQaQtUPqRM46uDUt8TmIMpbwo6EQBGCmqcdVf3ZSBxR5gXjRCOE2q2FUH1whFA15cXNn0wPj/GK+/cnbxm+xAdsOXAejcBREEgO1slRySDQ6ULMbnALodrvkUoeZMbDq7cKyNXEg2iHTQkMkgQOMPWzmq4S8o6P8/CLT/z4tF0lg7/eEEBUVu89T1IbsuchgvJ9b2P42gUATMVID/2lM1DWQ5lBkkAEPsShEThOHVcobcc/pNjKVH/+Z4jxNmOfMoWtTy1HZRzUCiN2R8wT0FXAH45R91fooeAklQzlhFQLJkUIIh5Qi0HEpGokb71/lPdB0tjqMdVFuHz6aHiIAq/2LLBk+n6n77QE8d9rA0j0UFaa7vpN4z5BaczSOEBT85KUYCjXDOHgFsBFvT0sLP1hFZ6cXtev/5b+8JAq+dvb2/mamppRa9as8QLAjBkzhixYsKAEAAKBwPgrr7yyqra2duTxxx8/Yt++fQIArF+/3jt16tThI0eObJg4cWLdJ5984gOAWbNm1Vx88cWDx4wZU3/ttdcOWrhwYfGcOXMGA2pfx9NOO23YqFGjGkaNGtXw5ptvBgFVIZk9e3bNpEmT6gYNGjT6/vvvN5Szxx57rHjEiBGNdXV1jeecc86QnvZjRXl5uTJ48ODE7t27xd6Ofc455wwZN25cfXV19Sj9vK1oamryTJw4sa6xsbGhsbGxQVeLzj333JpnnnnGmLBnzpw55C9/+csXOoEPHDhQXrRo0Y6nn366jPZFagdw8803t+7cudP7yiuv5M6fP3/wo48+usvrtZfQ5+Xl0dGjR0c3bdrUY29ZJ/bu3SsWFRXJfr+fAWpHi5qaml6J9EsvvVT0yCOP7G5paRG3bt3auzv3IeDqq6/umDp1atdTTz2V0n/d5/Ox3//+93v27dvn+eCDD5yGrZgyZUr3li1bvK+88kquKIpMJ5kAMGLEiOSdd975leoB21dkGkJdCyCJ/8/el8fdVZVXr733Ge78TpnnkJAJEqYIiKCAFgREBkvRFqSMoqKAWkVtHfpV/SigrVUUsAJSS22LaFGRT7FCFJEpQEIIBJIAmd/kne90hr2/P/be5+xz7pA3GESSu36//HKHM+wzvHevs57nWQ9wMIBlAA4mhDScrD3E1wB8Eq/W9GqcyDkM9YBLB34ALFUlOlQHrllO4FCBWcXmJG08CtwLIxRjoyMtv7dEkKjK0/CjHDhF4GiSJdxfPgBHl28wPlEhVC6tREIuFbgKXAhqRQSuHgI+cRpsRLQC19vmz5uI5pMfM7tYCJbKgfOjfKpKiqgSHoBTGwIEBHtA4BTRevqgv8HX/PcAQKLhuw7DhWBwbUOBA4DKrkSxSA41DBD5W92743dACyL5wpgV3ZC76gw3PJ1BoEKo6cKICEITySRx83jzFbhaLos6yiKDKuTFKFIP88hmDNVbPyw0C/9myltR44YCZ+T4ERFGtoV1Q8WqBgSMCJw+B/gzRSNEKqwZWjmEdgGc2hEpTCtwgZqEXIvCyckQtVaEdXHNqEi1oiM0svwY9doocC3mt9uc6/Ce8n9E73WofVuV4s/ZCtiPfrvl9X2jQfdZ1P9uueWWnr6+vvBrX/vayxdccMHcm2++uWdoaMj6+Mc/vhMAqtUqXb58efmFF1545i1vecvoNddcMw0ALrnkktk33njjy88888yz11133aYPfvCDs/Q+tm7d6jzxxBNrVdupCB/4wAdmfuxjH9u+evXqZ+++++4XL7/88jn6uxdeeCHzwAMPPP/oo48+e/3110/TDd6vv/76qQ888MDzzz333Jqbbrrp5d1tR2PdunVOvV6nukF4u3WeffbZ7G9+85vnHn744bXXXXfdtI0bNyaIw7Rp04IVK1Y8v2bNmmd/8IMfrL/66qtnqXOw8/bbb+8DJAl+/PHHC+eee27TFldA3Pd10aJFSz71qU9FYeVvf/vbk/XnRx111IJmyy9atGjJM8880/RXdsmSJV4Yhti8efMeNX1jjOHGG2986bzzzps3b968WrMen9u2bWMrV67MH3roodU9GdOZZ545smXLFmfOnDkHn3feebN++tOf7rYJ/AsvvGD39/fbJ5xwQuXd73734Pe+970GgtUMb3vb2xbo8Yw3bH7YYYdV1q5d29T927IsLF68uLJ69erE977v47777istXbq0umrVquyyZcsqzdZ/I2O8IdSrAYAQUgTw1wBuBTAFwB6xfA1CyBkANgshnnqtwx15x0I1CMGZJBs0RSDOnidw8BSCNecTUDR3h7do0q+tGX691cZpfKipoX9VOLAQJFpoachG4CRW4EjjQ8yo0QlCEILQyoFwD0RwBEIm6FeEC0EoqorA+SGHb7vIoJ6gyDp810yB06AtrFDMQoB6vQ670BeN2YGPki1QCUhDb00iAghqQVB7jxQ4rZYOZ2fj1nABrrbvgmcocHpbfiKEqn5na8MgEBGJc+FhhEol063vwuRNP8f2Wac1KFpCAMJQWzdXKLpcDkY4/or8ArfjWAxBppGwVDg4Jm4k8X8auigigxrGxETUIa/57KGHcb/7Y/x04DJgwuFN17WCcpPPRiMFLhQk2W6MB9FTmpkDVw0JLCIrcfO2JHckpVoFlvwNF8SKyDJN5MA5kQKXcSiIK89LgVQxIErw/ABgwCYxAYtJ3CoypG5k/NzWFqTJd31NontEBKiHwLNDDEfkNwDuZCC7l4WVM7/5yu4X2vtoFUI966yzRv7zP/+z55Of/OTsxx9/POpxSinFJZdcMgAAF1100a6zzz57/vDwMF25cmXhnHPOmaeX003kAeDss88etKzGqeC3v/1tad26ddGPz9jYGBseHqYAcNJJJw1ls1mRzWaD3t5ef9OmTdZ9991XOv300wd1eGzy5Mnh7rZzzz339CxYsKCwYcOGzFe+8pWXczlpC9BunVNOOWWoUCiIQqEQvPnNbx5ZsWJF/sgjj4wmZ8/zyMUXXzx7zZo1WUopXnrpJRcATjvttLErr7xy9pYtW6x/+7d/6znttNMGbbu1aLS3Qqh7E8ccc0z1wAMPrF5xxRUJ5Ug3qKeUiiuvvHLb8uXLaz/5yU/s8Y6pq6uLr169es3Pf/7z4v3331+84IIL5n3uc5/bpHq6NsX3vve93ne/+92DAHD++ecPXHzxxXO++MUvtm3iDowvhJpGupiv3ff6oQcAjjrqqNErr7xy5/XXX59obXT++efPeuSRRwq2bYvVq1c39OR9o2C8rbSuAHAcgCMAbIQsalixm3V+CUny0vgsgM9Ahk/Hs+/LAFwGALNmzdrN0o3IuxaGaz6EIkYmgXjn9BoOniLVfIu2FiMtMh4FjiXULk6syFJkBDlk4KG/1qwKVRmkagJHGy9J0peNIrDzMo9LcAScIAcZihPEQk0l1QVcwKNuYwg1JKAQ6HLbqTzNFbgexArjLpSQUwqc53bDDXx0ORzbqjRRrGHXB1EYeRHl4gHg1G5oTt8OWoGrknx0FGZ4Vqt5AVhkNIvCZHWgI3AZQS0EbASwEMIjmYjMavuJtC0JF0nlh6prv5Ssx9XiDiy21+Jy/2qcOqOORzc1J3BlRWC9FmH3QMjtuqKOUZ4FQOBTF9ma/O3Lj20A0JzAsWYEzh+LiLnPAWoocJO2/hrElfN2WoGzqAAhQM5W5C4VOtc+g5xa0XVrlQOXsRmgCJy2EiFcErjNYgIWI+Y/gsYdG7w2f1c+B/IWR9mwVllMGzMuCPexpSZ7/s7nG0C6FwPObgWENzTCMMTzzz+fyWQyfNeuXda8efOaPnURQhCGIYrFYtAql65QKDTVOoUQeOKJJ57VpMqEGbpjjCEIgpY/KO22o3PgcyzsKAAAIABJREFUHnzwwdzpp5++4C/+4i+GZs2aFbRbJ/3Qn37/pS99afKkSZP8u+66awPnHNls9gj93bnnnrvrlltu6b3rrrt6b7311o2txvxaYs2aNQ5jDNOnT98jEqNBaaO11d4gj5ZlRe3Pli1bVr3jjjv62hG4u+66q7e/v9/+4Q9/2AsAO3bssFetWuUuXbp0/G7d48STTz6ZO+KII5oqaEEQ4LnnnsstW7ZsC9D8oWfp0qXVH//4xz36/R133PHy1q1breXLly/e22P9Y2K8IdQMgK8CWCSEeIcQ4otCiF+1W0Etd3D6H4D1AOYCeIoQshHADABPEEKaVj4JIW4WQiwXQiyfOLF5f9B2yLsqB04RIzOElx2nX5TNpLLR6ilACGD9aPIP6rET4k5jNeHAJT76a41+cnEOnPxbFrur0lQKHOU+CA+kAocaKsiACwIv4NJSA0AdLrKksYjBZQJZ48Eznd+XrkLV6BaSwN0VHoff9Z2D0Z7FqORnoZKbjgKpoku1MCobv+XdO5+Q+x3ZiRAMa4ZtPD88Pl+9mMBl4KtnDS9sVOACMLg6vpnrAwgDvFFk1Kk8vCTHXaeNUf90PhwHwe0vxPIkJTIsqTs59JBRzCv4OGeRm2gbBcSKkT5+v4lXHAAcXH0ME8gwXFFHRYnYAY33qYsamoEFjSFUFlQiBc5PhVD7tv+2qWpX4xSMyMkvZ2kFLskBAkuWi0gFLkBxYHWqE0NchZqxaEzgSAX3Op/C+9j9AICdoiuxXUFt2NBKcesHCZ8n25xZROBAsqlhORZUIfwq7nE+i2w4Ckw7rG27u30Bf//3fz95wYIFtdtuu239RRddNKdel3F3zjluvfXWHgC47bbb+o488sjR3t5ePmPGDO+73/1uj16mWb5QGscee+zIV77ylSjE9dBDD7Vd5+STTx655557erZt28YAYPv27Wy823nrW99aOfvss3dde+21k3e3zr333ttdqVTItm3b2MMPP1w89thjEzf48PAwmzp1qq9Cjn1mxefll1++86abbpoMAEccccT4TQn3ErZs2WJdeumlsy+88MIdtI1o8MfGU0895a5atSqKqK1cuTI7Y8aMlomkTz/9tFsul9mOHTue3rx586rNmzevuuKKK7bdfvvt4wqj7gluu+227hUrVnRddNFFA+nv6vU6ueKKK2ZMnTrV0+H3Zjj99NNH6/U6ufbaayMSMTY29qdzAV4lxmvkez0AG8D5AEAImUgImftqdiiEWCWEmCSEmCOEmANgE4DDhRCvSQ+2nGPBDzlCIUkDMRJHM+P052WkkeRc/XAeP1UV3R5vDJeFVpynW4ODw8m6yETYRFSFGpGR9gROgETbZkFFqhSkJnOptD2FYmd1ONJGxBhaLSRwmYi6Tswi2xs8zlopcL0qfLUiXIoKzWFw8jH43Tt/hnJ+FnrJKLoceTAVs9uD+v/j/gdQ5QyvlBk+9agkBlzI/p2tDG81kayxHEJQcEEgOI+ItFaFElWolAL5CUBtFBkmye3N+AcAwBCLf1uY8iPbXWunTRULD++w4JKYuFhUhqAZ0ddTjkeT8XYKHAsquGTkm7iZXQ9H1KL8t8DoasHamN026/TB/HJchcpJg88d0u8VbCJAlTlzPQSQIu76PhPUQs/OxzFvzTfQu+Ph6HtBHWzcJedO12aSPAOYTzZjMX0Fh9L1AICdiAlcPTMJnFhRCLVZl4to2JygaMcLlByBGaSxWJ2GdWRq/VhKN2JHYRHw1r9pvdE3GNI5cB/60IemP/XUU+4dd9wx4cYbb3zlne9859jRRx89es0110wFgGw2yx955JH8gQceeNCDDz5Y/MpXvrIVAO688871t95664SFCxcuOfDAAw+66667dhtjvvnmm1954okn8gsWLFgyb968g77xjW+0fYJevnx57eMf//jW4447btHChQuXfOhDH5q5J9v5/Oc/v+0HP/jBhMHBQdpuncWLF1eOOeaYhUcdddTiT3ziE1vTyfZXXXXVjjvvvLNv4cKFS9auXZvJZrPRTTRz5sxg3rx5tfPOO6+lsrQ7mDlw2h4DaMw300RaX8P58+cfdMIJJyx4+9vfPnL99de3rnjbi2g1pjRGRkbY+9///rnz5s07aMGCBUvWrl2bvfbaa1uO8fbbb+899dRTE67s733vewe1GtcOZg7cWWedNafZMvocz549++Dvf//7fffdd99zugIVAN7//vcfoIplDiqXy/Tee+9tqz5SSnHPPfe8uGLFiuL06dOXLl26dPF555035wtf+ELjE+EbCOMNoX4ewHIACyHz32zIZvZvee2GtnegFbhAh1CNEF4vGQHGynHiewvYVJINIeIH+w1jDLc8n8Nps0YSuUUaJoGbRnahSKq4MPgvfJmclyCDMvFdROOq8PaXJBAyuRyQCe0BJcihhp3oivLfJhZd7BitowIHGXiJNK8xnyDHBLKqpPRB9+rkuKkD2x+WSeCpgooupcCVkYGlQmeCOajZPZiOUXTb6hgCeUxA3JniYb4EAbHgkDDKS/veCy5+9JKLC+dXcMacxmiCGUIFylKFE2HkUhEVD4DBMb37ilOA+jAyDDiErkKXJ58NhqyJ+IT9ZVxX/tuoZ20rS5HEOREEJVIFhCTQjAgs7CGRiqShQ6j6+JrdF1DXeR7ZDAshykISN12lC0CqSC2g8xOffMu3MP/p61EYfRFWWIlCqIEASIoA8rA5S2IUICDIWrJfQxikcuBsRbRpLNe6taiIC+sGQ/x+g3wozlgUsOXf0eF0XWI7u4TMPawJG0+89V9x2G8+AIvowo+WhwpPABOceIEuW2A6b07ghHqA2jD3fZhU2HOl/k8VYRg+3uzz9evXR3lv6eID9T7x2aJFi7wVK1YkLwyAu+66a6P5XoXMdgGyEvGnP/3p+vQ6X/3qVxMT+7p166KxfOQjH9n1kY98JEGOWm3H3BcAzJkzx9+5c+dT6i1vtg4gw2F33313YtwLFy709DiWLl1af/7556MQ2re+9a3N+vXo6CjduHGje/HFFzeoOSZ0KDH9+Ve/+tUt6ePX+x8dHX2y2bZaXcPd4ZFHHnluPJ+3Guu73vWu0VZjSuO4446rrFy5cm2r79P7uOGGG7amlznqqKOq5n2Zvr4AsHnz5lW7G0urc6zR6rxoVCqVlc0+nz17tv+Tn/yk6T31RsV4JcSzALwbQBkAhBBbALQ0BNwTKCVur3vAaeQcS4ZQiSQjB4YvoACpvly95W+Aez7a0oFfw1JVqEKRknQktc4bG8CHxoRcVOamF1v34gQnmYYSRiFUObFXeXNZ8KPeFbjGvwQCFIEt83vyoxsQCFn1V0YGIzU5uc/skdGGiuqxaRLGXXWCHoej0CJKN9pzMGxvGJbfWFFrEjg/5Fi/cwz/dP/zqNjdyJE6JljyOKsGcdGKkQcbPuxIeQFk3iAAPLmLgQvgF5ttDNVjI2DKPXBioS4kqfVVMj1PK3DCMPIFIjNflwG7RHybjtoTsZIehP7pb5fHJ3hTq5JmKMlbH1wQ2ATIWATvnd88hBq9V+d95S6GCx4ooOKLqAgg6oOqFDhtcwMART7SMlyvVcnQyuLhU+5FuXgAWFCNDKEDnipiABAaeZ8ZxqP2WtIzTRYxAEDgp/IBtQLXJKzPiYUBHj+kWIwCuT6EguBwEvMEDxZGhFxuG/pQ6V6oQqjjKWIAckaag1Tg+huWY9yLDK+Z3aY6p4P9Gj/60Y+KCxcuPOjSSy/d0dfXt2+UKXewX2O8ZcyeEEIQImNthJAGH58/VeSVjUigigWOCh/HjfY/4/3+NTGZCOqA3Tq9IwqhqrkkXdDghQQOUgpSk2IEAPgO+RLm4N+j9yFPKnDVsPl6/8NlD9S3gmJg8lvAqY3e/t8jKJwoq1C5i+GKHMO8iQUA2zHMs5iKwYSx7q46xcHdIbJ2rJKZGO1ZjO5dTyBb3oJRN6m2d3EZQq2IDLyA4+4nNuPZbaNYY9k4BMBEOgyCXoz4FD7nsKmsWgzAwEHhCRZN3ACwpSKvyfoxG/dvDvHNtfIavGd2Fecf6IOGNXBqR+HpEDKZnguAAXhmgGAJdA6cQXwLk4H675CxRMKcueL0IawI+E4XWFgH4UHTEGqfy7Grnny20QROgEBzRZemCFzqdGpF7ocbXQz7FA9tA06dkLxPdA6csOL7bxr6sZkHYKyxQk4T4oDF6pjgPCLpaRsRAAgNBc4mgGAyZMqoVJSz6pYLjfAsJxaEuodF6l4OWA6/fdevQHcx6AdsQghAGQZQwhwaF6J5sDGmqrt11S4nVpwD1+bZyeck4b13gNWPhaSxGJSGNSCU53F/J3Ct1Id9Be2Umd3hzDPPHD3zzDMTCtBdd91V+uxnPzvD/GzmzJl1bWD7WuL12Pe2bdvY8ccfvzD9+a9//evnpkyZ0iG1bzCMl8D9JyHkJgDdhJBLAVwE4Duv3bD2HnKu9PWqhPGEfCh9AdNMZXc31hZpH7j0RF0PpU2FCdGkIXwzBFzAqfZHOXAVTjGjJ4tvn3cE3vUvv2lYXggB3+3B4ITlyJY3SZUCsiXTcFWOYf4kqdD18wIOIqNYM+xizK8jawFDdYKJmbhfZCAoLMKxi/SiF0MY7DsCM1/4PpzqdshmGzFKKQVuVm8Oz24bxfNjcvIshSMo2sDPNufwcD/Hd986BsL9qAChLiw4auKuhcBAnSLDBIZ9iv5qrMT8couD8+d7yJY3Q1AnUmk4tUDCMFLgtoyp3DMwZEyTtvxEwCvDdTgsI3eN2S5C7sG3S2BhFUSEiYKNjZm/xP/xz8PZbz8RX16ZwW+NIEFRqbYWCWFRuV+HaPYhwEVjnmQlkFWw80ohVg1aeHGEgfYmc9h0CFVYMfGYgl3orw0gzE9GGjqEytXygloQQbzNtJEvAHDj/raoAAVBPVQKHEjUSi70DQJH7Uh5S1dGc+aCUxehUZGqu1cV+6YCA7HVR0hsjCkbHAapngpqwVb5gz/bkkOVhHjblMYQus+T3nsnhw/AJiEe5QvwJvq8cU48CHWMzGldAPIqwDnnhFL6mnpVdvD6wex8sD/se8qUKeEfq7NHB384OOcEaN2+aE+KGP4bwF2QeXCfE0J8fa+M8DVGXj3CV4zKSAqBWdSw0Qna+/tZOgdOL26czsEa8LFHCpH7vIYAxbqlH8NV7LNNt6kLB46q/C+WPP53yI/IsFOFM0wuZXDw9K6m6+mEf0FtEMHhhxwuPNTgYFiFUDWB2xnm0Y1RAAL/sDKLYY+Ag2ByLi69XyNmoyZsXJT7On519tMY7V0qx9ckWb7EJYHzqFTgMurcbq5LNajAR6Jw3IBHUfO5bKOlfM5qPFbgdlTlrXdASZ5Ms76jHFDkR9ahMPICbH84KgbgxAYTIXxtRuxLpSfQzew1cn2ACNFLxuI8tUP/Cq7jIOQCvl0C5T5oWG/wpfuM8wMc2JfBHSeTRJWyJnAFVGGpa+eSeN1myfgbyzbe+78lZNR2BmoUU17+SWIZHUKFJf/f4MoGJ7nRDWiGKISqFThiReFDlwr4nICGXiKEb/bTtQjgKlUra8kihhnKcaNimOoKakcPIYImlcDAzoMzB4FRfULV/ZTpSpLOkNgYE5rAhYrAxaH0JwddfG11Ds3gcwKHxiSuRGoYEVms4gekzokPqND0XlbgVvf393epH9EOOuiggz8aOOekv7+/C0Dz/pwYvwIHIcQvAPwCAAghlBDyV0KI7//hw3xtkXPkIdaMGZaBoxuGiXW9DDQLCu9cBxACix6gbETkx4GhtLxSVkaxJEl4vvGbzfjgiZfj4edW4dLiv+KWoYuj7x52P4zzws/jhWASFtdkzm62LHOOK6GFQkvLfyMPT3mqcR6CEYGacDBcDZC1GaZ2y0lsQBThkBAFVPHiWBaDyuF/Sj4ev4MAD4pDsKWeRUhthFoJEo2KyJRwM0AoRu0+WdmrJvAhdfJyooKcHW97zRDFgdyPjGprRghVE+opOYE1g8m8uUAQWH6ck6vDbJzasEmAB7Y7OG12iPOHvimXRyoHLie760ygw9imCdyiU+E8zqQ/niOT6i1/rMGXjoKDqW39xykUZ/xEHmNRhVCLqEQEztEETrQ3eq6rU3lI+DS6dz2R+E6HUHWo95XsIsytr0WuvAnNShl0CFUXsghqgasczqIjMOwRUF5DyHJRgYYwSCojAjranGWSyB/QJfddNQicVODkgjyVAxdaeQhiRV0Ylk7viggcjroc8Cu48aVp+BD7MThNKnBC6BBq8v4SXICkmtAHXFr4OEx5wlF5L+kHgsQ5UQTOtl+Vt3hTBEFwybZt276zbdu2gzH+fOEOOuigg70BDmB1EASXtFqgLYEjhJQAfBjAdAD/A0ngPgzgEwCeAvAnT+DySm7QLaYAqcD1EGN6rDfp2Ti6FfjF3wF2Dtb07yBoocBprpVW4B7fNIbhioeqzzGSnQ4YDVumkEEsJK9gKDMRbqhyq5TaUQkpJtit/U2CQACOqgwUPAqf1WBjpOqj4FrIOzbyDsNgIBP4e8gotolsRJp6XJPA+WDMwmjNhx9wOMrOIurGYBR4OMID8hPheK7MK1Rx5S1lAC4wyakjb9xRO6tyctUTri8s2CqkWVXzd5/ii/VUFJuo41pz+BfillRMJr/fsi6Pd86IT6iNABnLOGd5aWdxbPcAfrRDbZjasBmVCpylOikEjQTOzAs8ZCLBhUsEbl0DTINUbIukGoVONYETaN41QCMqVOGNpLiiQqhUbbPsTMArYiIKVRW/FRyTX7kX/dNOBLeysq8sYUZ+mh0pbH0usLOmFDinBHiDahNJCxStkmaVx1reJpiS46j7JoFzIgLXqMAVpR+hOrBrTlmErE5WW3QqsOhUrPriPwLixxDUisLEFBycawUumXsYcAFbEbgxXxaL+ILApsCsAvDsIJAl8l6qp362TAJnuXtPgTviiCN2QBZvddBBBx38yWF3T5V3QIZMVwG4BMD/AjgHwJlCiDNe47HtFUQKnJEtzUiIzyw1CJzXROsYfEn+71dgQYUutQJnEDjNbzJoDDm+NFBB1QtRcBt5cjcpY24JyHO5b6pMVMsBk672Bn7/mRPxNyfLvFNfTdZCu+OrkFodDipegKzDYDOCUtbGgCoU7sWozANU83PRJHAkAKVSmQqFAKdSwdCN7RtIR24Csq4FL+RRcURdyAl+ZtaPyAEg/eAoD6LvfVhRsYcOmU5Q820tZbnxXyqNd6R3WeT2D+ZEOXQhBzw4GBQF/IofBps1KnAn9+3EF9/kx+syKhU4WylwQbmBwJFURXLWAiwEmM1l8nweVVg0SeAIdp+MDySV2+gcKQWOqjQHYeewms9BtrIVEBxdu57C1Jfvwcx130M1AF4ZDiSh0uFNYkU5gdMzVRxG1oHxOkKjKMJU4Cwi0OXIceSM23JmgSAMzBAqMwhcSoFTJF93xUiErxWo6ojBqY2KKmLYil6ZikBZgwXLmNGS4YMPFfD+B+W961CBJX1qv4GHurBRyiflchZ6UR6r5ew9Ba6DDjro4E8ZuyNwBwgh/loIcROA9wFYAuBkIcS4vGX+FBApcEE8YRCIKCQGAPCa5MBpx3vKUBJDOA4ro/ClORFX1cSdLmIAgE2DFXghRyHTSOBKpIK5JYIuIQlcEGi7DYacUjM+e+pi9OUdZB0ryuWrK/bIVQ4cAk3gbJS9EFmbwmIUU7uyGBIyuamHjIILoKy4TMEgWQ4CdGcthFwg5CLqGQulwNF0KLU0TZojByJSYOqQ62RoCPNQKwEF4UEUQvURh860AqcJXD2lYHmetsvIR0ofsZwod2rlTgIHHm4LTkYAKw7hAZGhLPHLmJxVxIDZcCypwGkCx/xq5MvWCtvKwIFkM2wE2O7MhENCOEKeG01CpALXehua3NVFo7KaDqEKK4ctYgKsoKwMleXKtj+K29ZlsG6Qoy7M/DQWPUX8VXA37nY/D8a9qI8pAMDIgbMp0KU4jmnRkbUBS8QPISyoRj6APKXAUVUkoUPobpOQ/2fPPV5+57gYQR4f8a7AhfVPIuQcnNqJ4hIA6K/H12/Uj7fnMuCcA+V3BephdongjMOTLfUI96NOJq6zf1ehdtBBB/sPdkfgol90IUQIYJMQ4o/efuQPgVbgvEQOnAA2G9X2TdoTIepGQPG+bdfh29YNsOtDKAcyTKUxqhZL58ABwNZhGSYqNlHgSqSK2SWpgAHAZqOiUhO4S996AB769IkoZezIJkOrUbK9UVxFWRMOql6IvNrX3Al5jEDmSZVQBQfBgJokC0qBefA9QJ/tgVq2NHLlAiAUnNqRX1mDAleYjJzD4IVhrMApgsYQwKRhtZCAch91YaPgWvAQ58DpnLe+LFHLxuu9b36AnAqxBXY+oTpqBe/bz8j1hiCJSqLoNy8VOHhjUWgNzIFjUQScw7cUgVOVqO1wQBdBH5HFG7xHJs9rAmPT9kUMGnZYkQn8TVpOVIzwolw4C0/ZpRBw2RYMAIRALQQyxEMdyfw0oQhcyY63H9ixSsWNa8iIiGxDTLLtMsA2VGTLKOzRoXdtxVPNSHVN34suaySm06bNAAgFUcUZ9/BjsAM9qHghBLEa2pAN1qS/4ljqzyhvExw9hWDle4FpeQHGLBQLsbefAAEVQXSf2u5uO0R10EEHHewT2B2BO4QQMqL+jQJYpl8TQhqdXv8EkUspVxFGtwAZVelZb3IogcrRIUCPqnZ0azvwgd8U8YWV8eQ4otSCZgrczjG5ja5so59XFymjNyNzfYC4yjGAhawdz6y6RZQOU3kJBS6MGpDX4KBihGtn9+Ui+45lJak2blOVnyU1nFklCiYCCNWUXisqnDqRopFu9o7CZDgWxYadFazdpnqM6qTyMEi07SoHBEQEqMFGb95BYChwOmQ6SSlkZteCbhfIkjoCYkkbkZCDEoCVpmAq2RWdPwAYViaxCQXOygBQzdl1+JAqAhcKVLKTwamNTGVLQxVqGpcvBb5whLy2UyfJTgMfmC9tMhyDhPgpcqYrWCk4vjXyYfwf61awtFcgGkOolm3DgwUmAoDzqKsDwJFlQAaezCmMFDgrUtgy2fi+DJTKCCR94CwqfQ0BIGf0Gc0wwBZ+tD/TDHhE3doP8EPwnvrnsWrxx+R21THbVpP8P8qAbC8KWRdnHDoNHz1xPgBgzdYRaSOSInB1Dtz0XAbnPVBKfF5UgnBPloLxAGA2mGOEh6kFCB4ROMvpELgOOuhg/0BbAieEYEKIkvpXFEJYxutSu3X/VNBMgYu/nAj0zJHVpibqY8CGB6O3Qp+mwMNYkJysdN/LdBEDAPQrAldsQuCOLg2g2wF8SIJWIpLAebCQcxsVDZ0X52kFjjoqBy4mcFU/RFHJKjmHIVSKyVsmyRl4e5WCQCDvGMfAQ4DJdbQtRMgyURFDgwJXnIKzDpPek9tHdCI6kWHUVDP0SkhAQg9V4aAv78gQqsobi0KoWoHjJoEjyKEOn7gQhMEPBSxGkZ1xCObS7ciihm4VAtcVsIkCRkIAOyPDy1phsxy4OgeOZjE48UgUhp9vWlhgwqIE87vUvZOVxsaLupTaY/jApfPbejPyXPap/rGnst9HqqaJmgo/U6VmMsbgq84TEKFBpAWylpAEjjhxCJVYIOBwKEfRMhRBOw6hmj5wDHHhjW3Ym7kMsIWHIWtCwxgDdY9W4eJxsRA7iFxG3y/pnM0Ix14FNu94/PN7D8NH3n4gcg7Duh1j4LRRgfMFxc83NXq4JTqGhB5ALVCDpHGlREfnqZMD10EHHewn2OdL43UOnNesHySzgXnvAAZeTJKPh78JDCvH9zCIJsswaHTt14UBmsCtyh+DbwWnAwCGKvKznlwjgTsgX0d3hiBUk2OswDEUmhA4U4HjQiCkTIVQFYETcqYrZeS+zn3TTJx++GwAQMFS3ms1BpcJWJrtCA6IMFLg9ITMmRspUw0KXHEy/vyIGVg2I+lT5xM7IpMaBw6sgF0fggcbk0sZeIJFIdByQOBQgaIik5UgvhW7bI6JZAg+cSAoQxByWJSATz4IBAKLyCuRAqfbNBGkVCArI8ejyYvKgQOAIOQY7jsUTn2gbeP4CPreUAQOvlSnzLZgfqo9R68r308mshJ0lyjBEkmVlhMrejgI5p4gd5WdCE8pp9KrThFpwZFlAhn4KgdOFxgwEB4ibwlkWXyPB0YvXoYwagoviOzAAADcOGc6hPqyV8Q3gjPw5LwPxttSuXu6mnS4qrpBqL+pRB9aE8d8BDhR+iDajGJyKYOyFyCwu9CLEZgVv2M+AUOISUj0x0bRVPdCX/7NspjVaTsdygP4goHQxr+1DjrooIN9Efs8gctYDAQtFDjGZL5U6EWTMgCgYvbfFZG6U/aahMAU8dA5cL+Z/SFcG7wvsUxXtok7fFBHlxu3F9LNvUPQKI/NhA6leiHHZXc8jt+/NAbCDQKnlJySIovFjI1rTj0YAFBgksTsqMnOB5QSaZPywD+q8yDXXbtV5XpRB0QltDeoRnkZRkwTOA9OnG8GYDr68ff2rXCCEdRhoztnJ4oY7t2cAUFsaVE2lM1Dhu/HKexROLwGaAWOEqBnLgBgKtmFHuWSNow8FkwqJEK38oRmVAg1zoHTlap+KOA73SAQTXu+NjS7jQhcr/xf3SuRAidkVayJkrrkmsANoJgoEkjDO+5vgA8+BD79TVHomwofNFpHwGEytFwjDkAohBB4eciHzwXyjCNr5OTVRExkHAQRoRRCmvkCyc4RGQtwhI8aHFwfnIvH5lwafadV4qOmyvOnDaMDLsAoAaNNQqhNUMpaqHohRnoOQhcpYxaJzbQHPYpPW/+ORzIfVubTwDF0NbqZUWDEPXmvWoZJMdUKXIgADJTu8z9pHXTQQQcA9gMCRylB1mHNCRyx5RM9kDSutZJhGKa+G6w1SUJXc+aVB8lJvVgoNCwzpdSkMi7z3YjHAAAgAElEQVSoo8sWYEYoSapxBHmnCYFTcS9f9fHaOhqAgEe9PDWB684YCoQKjeapHL8AgUsBRgiwbTWwVRYTE0uuc+ejr2DbUBWcuaBagUt3ZFAkppRJKh0+SYZQVdtcANJmJGNT+EiGzlxehmsRuEwkyMTUYWl2mxFVCELhhxwWo6CuMgwmdSyiL6MuLBx18ALc89FjG8N4djapwNFYgRus+vBVn1fbGweB0+dAVbfq/MiEApdapahOz2Qi/eoGRAl2isCZFb6UMmDyQXAzbuSbR3gAooppiJAeanPJVmzDRADAYy8N4sVdNVgIkbOSBO6hbfH5cOBHfnsCBAt75LmenI3/JlwGOPCifMbQyOnThDKTkRsZq8lxB6EkcKSBPTdHd9ZBzecYVt0+DiVxy8chj+IEKu/HPjKCAir4d+fLOHTN9fEGwqCBwHFqo2fn4zip9nN4sOV57KCDDjrYD7DPEzhA5oM1FDEAAKUxgQsNAseShMsOpQowUG0kcFWlHGVVNembD5CT/BmHTsO7lk3Ff1x2NBZPKzash6CKLiuMlDcA4Cos1lyBU6E2lbAeqTQqBFhTE++ULmPsyr/LMfaxvcZAKeIiDSARkhqq+QhZJlLgdIjx2tzHgHf+X6Bb5r+lCZNPHID7UYL82bPi0KQHC45FIx+4a5ZVsIRsxNOZy8DW/xoft/4Lb6NPRcsTHaqEzPEKlAJHHEngsqhjGVmPZ8UsFIrdkTqZgJWVhFLnwDEnChj+y6/WwXe65cfNCFy69ZwmpjmlwCnSbBvnNUjVQhQiAicVuEFRaFqprKFFLNdiRgg1iHMRRYiCP4AuUsE6KpXIe1dvQwALDCEKlkiMZ0M4AUfX/kWOEwH6VE6eAPCXC4Hb3hHifYvje8VlBC481FUo3gwJ+yqXUhcI6IehgHMwQjBOAQ5dWRv1IMRoXob2p5Od0XeDHoty7SyEkVKbrxjN60OlwM04ElsxAQ9byxMmwwFYQzeHDjrooIN9FeNupfVGRs6xmufAUQvQE4CZA2c1T4ReM9L4eSWUk5st5KQ+b9pErP37gwDSJrkbAPwa8jSZE6UnsFwTAqe35UcEjqlhy21kXRcXHj4HJx00xTg+PbmFOHmWwH0vE1AIUNCIhAAAMYxaw1DIHDhPKkcskMriFmsGcHTcDiybJnDUAcIAXzyawCUBLljgAbJ4F3U4cC2GP1s6E/azAc6f7+HFZzbKIW76HS4jq3GZA8yp/bvcp+nlRYhU4CgBVQQuhzoW0ldwX7gcXcVmPdAgixjqykaEUIDSSCmq+Ry+Kwkc9Zt04WgVQtUK3FN3ArtegFVYoldAkFqloCw9ulTLNgJZQZrGvIl5vNhfjnL4XItGRQyE+4mOGKeM3AkAeJYcgAMhfQYDJk1xC5bMZxxCAV8tfgq/x8HYqUKRDgJMyMaHRgjB8TOTCmqGyTzOqlJyw7BRgdPVn/ohIuQCFiPJCuA20CHUOlxUhZPohjLo0Sgf1EIY5Uomiky4LwlcpoSz3ZsxrcjwvfpV8ThJR4HroIMO9h/sFwQu7zBUvSZ2EdQaVwhVo4BGw1+twNnck9YJlhs1eW8LvwrCkxN6mdvReNOYWJBj+sGjsmeqnlS5L5Wu/7nsUDhTlsj8Ng19bJzjprczPDvAMVT2QWkG8GOFjLD4Nnhl0AihCg6q7CTqNBkazqTMW33iAtzH1DzBv5xoA/0xAXiaz8UCi2H+lF7gWYG8TfCX8wPgpSR51LAUubzPOQkMkrRajEbVhzlSQxfKGECpabgZgAyhVgdlCJUwgBCc+6aZ+Pz/PIN5E/PwFRm0g2YELkX2eSoHDgA2PQpr8cL4+FXI8W+PCPDE9hCuCkvr4haLBHCb5MD97KPHon/Ui1pRmQrcrHW3w6kPAAAytR1Yih14lC/AY+ECnBJwcCFJP0MoPeAEhw8bT9rLMFaWOWFcEDjEx8SMvC9atWx1mfSYq3EncTwA4KsiBjsjfQV1GN8PBRghjfmHLdCVtVH1Q3ghxwCKUR4jAAzWKXxFvhbTl7FLFbkTc8ShDzD5d+AwqeiafVoDMLAOgeuggw72E+wfIVTXwvaRJtWGJoELDYLHmley5UnjNirKv4xyD6BOylHWwNs/l3wf1JJhTMSkLN+kCrUn7zRdVitpmVwpSd6AeCwqD2xxL8WbZ2YS6wEAMcb8309swmCdyupTISIFzrOSYeC0uhhQV6pdmvwo1eoX4eH4MX8LMo4ZrvZxWF/YsG8NFtawAdNxc/HDctsqhEopQ8gy6MMILMIxKnINSmAEHULlgSTWhCJjMxw5t1d2Y3BUDhxvrCxuVODUNpx84vrq/EWC2Mj3qMkCN/5ZNgp5OyTu2tBMgXNtCzN6c8Z7Gl1bt74rSWAAfNz/IAY9hqpqexWAwUKIksMBHoCDwg8Fyl4IgKiwdYgenQPXgsG5ymNO51KGTQicpQncq1XgMja4AEZrAYZEIaHAjQY0UqCvt2/Crc51yZWFkNdTNau3GEHIBYQR/vdhgXSKGDrooIP9BPvFr13BtTBSixW2p8gi+cIMoZrJ+i3MXYuoNnxWCQgsImQxAXOi9kMNOO7jwEefNj4QQD3Zg3VAFJFzaGtVyYAOoWq1SprXpkCIOr4m4WOj+4Qrksc14EkCR8DBwhq4IAisXGKZNIELiZMkcOp8fiM4EwCReWpmm642/mskqKJKMqipJvZeyGEzAkoJuJXDJFUYMIYsFkxuLBoBIEOoPFAhVFkcAgA2I+BCILDykRVHI9IKnKfuFQYYHQ6shJGv3L6jkgDPX5z0B3RIgAzxMGZ142j+3ZbHnrFYTM6b4GUxGVU/xIgy0uNEhlCzFgDOwVXVbrkuv6/DggM/yskTabuVaL+yn68uYgiMlANPEzi3CIuSqAODz7kqYmg53AS0ofVwxceAKGJxZhB3nhTAZXEXkpYQIQARKXA2o+BcJK4hAwfpKHAddNDBfoL9gsClFa2KUCFSanhKJXJt1OtM0iojg0a1xg85PmN9H7S8XSpMLUkBgGzK+1gRuI1ctibaSSfg/131VvTmm4dw77z06Hi/Kk8qR2py4ms1cVHWnJAaBM4OkwQuoK7MPVIK3BiyoKl2SWnlK2CuVKpSCpzuk5q1DQVOEysgJQmpnqdBFVVkI186P+SRBQi3YwJ3zkElLJ3R3fy4LVWFGvqyWEUpZxalsqE6aSSl8TDSRQyBvFcITYTXdXUyF8BzI0o1U6dlYpbgv04lcFUul4sQLnx4JINhofbLGu1levJ23NkihdD4c+0flfeiIBYoEbI9nAjACUXF59G5q8JFDrWofVaDALfhQeDO9yKLOlxDgQs4x/aRGjbuKsPXpM8pIGOzKIQaqhDqeBU4TeB2jNUxiCLyKOPNU2l0znirnyPOgS2q/bIlx2czGrVy08ij2loB76CDDjrYx7Bf/NrlUoqWZasJkrLIaqOBwBWnAqfekFjPJY2q0VH0WVzEfga2c62cXJrkdMU7TqlkNenSv1bI5twb6CzM6M239NV687y+qOJPqxV51GQeUKuJi9pSvfArwLP3xOTEDN/aSSLDqSMtLAQHC6sYRRZWqtKzQYGjKQVO2V9oMpKxWylw8SSs+58Sv4I6NQmciAicsHOYpCo77VxX9HkDbO0DF8prokiGRaUCJwQQtiJwYeo6h77aBoUpN1mh9oML8b/bZX6emb7o0LjFGlUhVB8WQgH849QbgL+4o2HXBddqMKP1bfkgscJ9W/RZRODU/Xb+juukAgeWUJtHRQ5FUkEuUuBSWPNjAMDEwSfBiIgMoUMu8MOVm3HLivXwuDwo6uZkiJfrKlQBtkdFDHIQ20dqGBQF5HgZ4AEcHelv9fAjAuCRW9TJUH1oVQjVJNvr6ewOgeuggw72G+wXv3bpooCFU5QSxmwjhGpM2nrCXvQuYNph0ccufDg0OQVaZriNtgmhAlH4J4JS4PonHIkPeFfh391zd3ssupJSJ7rnSF1OfC0JHJMKxqP/Cjz5feDlh+XnQR3onQec/nUMLbsksUpIXeVRJkDDGsZEFlZagXNowzrgfqyoaQKnDGVdi8YELgwMkhSfz17VXpcEVdRpJsrDCkIO29L9n/KYBKnAkWxSIU3AykqCPLJJFTEoBY4RcA4ICIRWiwrWIJWrxk0CFx+3te7e6LU2ZDZvNZfFBs8MIVziwyMOOBfYmD8MWPjOhl0TQpDNJYllYOfx23feh9t7r4w+02a6E0ryGGZ6LwLchyAMY/VYcR1FDiVU4Cjm35ADp6xRjlj3TwBiO5pQyDBsuR6irmxEqJNH1mZ/kI0IAOwYrWMEean88sBQ4Fr87XAOdE2Trw87D4BS4LiIcgS/Q96DLxf/DuOO53bQQQcdvMGxXxC4tC1HKac8FRJFDCm7AmrJcNlZN0cfu/CRYfEMyIiImpDLD+z2CkA6wdqTFZAHTc7hPn4khN1CETKgp6fIciRS4FpMXEwpcEPKT8srqw3U5PEdcQHsrsmJVXzqgHBfKnBBFaPIwUoR07T3Wshc5bumCZwOoSoCZ7NEEUNEmHl8/rpUf1P4NdRpDiEX4ELADwVcrbQ5+cg7j+VbhE+BKNSGwY3qPCsFjlFwIQCB1iHUesobThN62poou/BBIGAbbCYQiOwwqOCqEb2DUMjk/1Yo5pPjEsRCtTgbdRr3AK358hwcMNkgsYIncsIsSjAiciiRKmYX5XU5eUaKnGb7koceFTEAVU9WjOocODh5ZCwWKaNBKI9jvEa+2vy5f7SOQDBJvngY5Q2GrRQ47knlbeJi4ACpQtrRdZTnYQd6AbcFIe+ggw462AexfxA4Fe67t/jn0stLTzitbETCQE3YFHDiydRJEbisBRTMwgbL3TMFoC4JHFOWE+NpSaQ3rxPdc6jLSbulAmdJklQdUBtQk2RQj0K66TCkBwdUhIAIwYIKhkW+IYSaddIhVE3g0jlwZghVn2vDYDeMCUWJKJuWsA5OXVllKKQCp7soUKNq1M61UeAGNsSvg5qRA0cQCgEBRAqc2XZKnoAUgeO+DLWnFDgTvWQUjCARTpxdNG1EZA5cHQ6EaH+t0wSOM1ndzA35rOrL80ctI49Oe94pdGVtqcCRMvrcEC9eAFy5PEVaM6m8TIWQC2n5EXA8JJbhl9bbgL75yDosKmIIuQDbg5ClVuD6R+sItf0HD+MQaisFzq/LFAAnJmgyhIrogaEi7AR57qCDDjrY17FfEDid7Hz3xA8CV6+Jw5zMNPJtosABQG5C9LFL/CgZHJAhsiIxCVyTStB2UBYdoRqDNS4CJ5fxjRCqoO1y4CxJljztd6ZIQFCTXmlAgxrkEUkKaOjB8kcxIIoNJC+dA8epo0KoipilerR2Za1UCFVV/RoErhtj+NLyKojgENRGwAWEEPC5iAics+XRaPm2BC5tBRPlwMnqxee2jWJTWW6zjNR1S1UHR4SeUKBFFWcvRmBTkeDvRYdgcZc8zvm5aqJIwGpjd1HMJ5UkTmXonXNJXACgpgicZRnHyZMKXClrY0RkUYQ8p4zS6DxGSMVUJ6oCkVCIiCSu8afixt5PARPmy5ZoyuQ35GJc92x0XBlLWa6I6KHFDKHSVi51oddA4HKOBT/kIEoBrwm7dT5kBx100ME+iP3iF0+Hm1yLyuR2PWklFDgjFBr68ed2BvjcIFa5h8sQqpED5zKgpMN+wJ4TONUUPVAVpe3Cahp6Ce3NlUdt9wqceWy6IjWoReN10gockcdOuQfLL8tG7KmxpatQQ5aR+9Gh0dCDAIlCvZOLWeNch3ERheFHN88dwl8tkQRHMAshFwi4QMhF5KuGP48tOOx2IbNTbwBO+cf4vTo/0kYE+Kf712HDqDymnSJFBOvl5HttI9JWgRtRClzyc23W3OtyZIiPitAErvW1zmazifehyp0MDSIbETi7tQJXylgYQR4FVEDR3BonItwKr4hJ0b70Psr1INpvVhEnIUTUzH68oJTEbeL0QxQPo7xBm7QYI/fl34oTexGWlCmw/luucgtWh8B10EEH+xH2i188PRE1tLZiRjN702qD+0kFh1L41JUhVMswOOVAkRjdGew9JXByXV+pJuNREBpDqLW2uVlgdurYpD0IAi+qPk2TM1+rRP4YqPAxIEoNJC/diUGTjKgAICLBctt516hCffJO4KXfqOVjArc4O5RoPh9wgW0jkuRO61ak5uD3YMMFK/Ef0z6NXN/U5scMAPk+4KgPGB/IcTBKouKIspDXS7v+xycg1XEj9JWNCEmGyPMTgIt+AQDow6hS4FKEJoztUjLwUNUELq2EGbCc5H3ENYETIso9jBU4QxIWYSLPsitrY1TkkCE+iN/EsBhI3BtP8Pn47/CtAGS/U620CcT3ZsaiCEIBLuR42DgeOkzoMCrXCrcIkVEvLbTwBhzZKu9bI9yr23Lph5OqsOFYnRBqBx10sP9gvyBwh82Sye4HatPXKAfOqEI1lYgwkBWlBgJiw4WPnJEDd/IskjT3HY8Cd+r1wDu+KJdVlgjTuiWRWjq9TUhQQffM1MnmFuHtCZwOoWqEniJxYRSSSofzdJjPVv1QpQKXInDpIgZ9vsKYwBFqgVGCdyyeJNfXBK68I17RIHBv6xuNFTxmI+QCmwblOTrEODdz5x6A9152DUqluOl9W1huRGxM/zAdOm3wXWtG4DShN89ztheYuABAawUuChXzEBnio6w8CNspcLaTvPe4ocBpJbLqSeJim6RHtw1T6M45GIUkvsRPqYoaxr2xhs+GJroVL0mmNIHXOXBcCJUD9+oInNA5cKEf5cDZrVTCh/5Z/u8aBC6jQuyqCKbKbdidLgwddNDBfoTXpRcqIeQLAC4F0K8++owQ4mev1f7OOHQ6Fk8pxi2LdAh1vAocAJ84cOAjayhwXzyaoL9cBnaqD9xku6mmOPJS+f9DX49y4OZOKOB3nz4xqtJrBz1fDgsjfGh0GmgAtRo97jRpUgUaaXVNW3/YnvRb2yVKmJBSWigl+NGHjsE3//dF/OLZ7QiYIq9621yqVi98/jhUiVLPmrUo8+JepAXqRWMl1ELAObYMVUEJcNCM3ZPbprjmFaCyK3prUQKuFLiKInChmTxvZRoJnFHwofMGAcj8yEwXAmKjj4zCIiIi2BGMZvQuPJTF7nPgnBYKHFchS4uSKD/NNdtziTDRzH1i0cWgkOOlQWMfX7nR+L73DCJbrifJlA6hZqwkgRtP2N+ENtWOcvUEjxQ4m4Stm7UCCYse7SknDAVuUhtVs4MOOuhgX8Pr+Yv3NSHEoerfa0beNBZMKTUY+iY6MaQVuCYEziU+skqBc6icTKc4Rn/UOW8d/4DsXEwUmIWpXdk4P6gN9HQ5jJjAEWY1WpRoNCVwasxagUtNwlqRihQ4UWqaX3TorB5MKklyIbQCp3K+EHgAs0AIi897uvOAaXps52WekyZwloMgFBirB8g5VqTc7DEyJaB3bvSWMYK68jHTaliix61bkkUMz9wdKaRmwQfO/bd42cIkgBBUrRK6MQor6fMb9+8EgNADA8eYahbfjvjYbjIHjqtzGwp5z7kWjUKojjBCozxMkJzJJTdSamnYIoQqTAIXX49ySoHT6QcZm6rikphQ7gn0doQZQlVDtlopcBpGu7soFKsexjxYDQ8iHXTQQQf7MvbTXzytwLkxiWhQ4JKmuzqEahI4AHESfs9cYO4eEDgnHxUxtO3ekILOsarAjQoZ2vZ/ZHZMIgAZ4owUOBlSNnPvcg6LbDUsT1ZjDiPfcnLUgkmoKiWxY63cx9BL0iTWPLY0gTPPeXGytDrRBI7JEJkXcFiM7DFRaAUzzPa8mAkAGIKhnFoZYPPjwNM/AJ75IbDpMekLp/Mb++YBV60CJiwADvlLeewsiyzxQCFSBE717wSicx4RuDaHk3VsXOR9Aut7jgUQdygIuQAl0lNPe7GlCRxNELhMRMZJq96zhg+fSeAqKQVO28a4NlM5cAKhEHscttQh4DiEOo4cOECGq98SGxmX9Epq/HV0qlA76KCD/Quv5y/eFYSQpwkh3yWEjDOZaS+DsmRlpAZvrsA5CJBhqqJVz5OBJyfzDz8CdM8Y/76dQlwdSsevLhHj1ZBS4Wg7AkithFVHUoHTBC7eqsNo5MbPVKuomnASy5jQ0WiuQ6ir/xv47deB4VeAqYfFhrpAkxCqES9beCowuAFY/2s5bEX2an4Im9Jxt2vaHUzl69f8UHyq63pcJ843FjBJpgBWXC9fmibL3bOAD/0eWHASAEngcqhDBlCNcZrWNOqcawJnW61Jd8am+BU/HMOu7D4gaKw2aQVOg5lVqCIEMTpm9OWdmJSZJN6E4X+o++sCjQqc7mbiWrKVFlfVwXtKrHURRvTQIYLImifR1SSNA44HuuK/Lx1C9UP5dxuANVqkdNBBBx3sw3jNfvEIIb8khKxu8u8MAN8CMA/AoQC2ArihzXYuI4Q8Rgh5rL+/v9Virw6mD5xpQCt4MtcJQAAbLjwQxVgiQ9+wLid9K6Uu7Q6KPMlx7EF40JgvR1QeHGFtCByzkwQuNAicquojhOCkJZNx5dvnw7FoVCnJ1HI12G0mR3keuKmubX5M/r/4XamxGMuc+a349VuuBo77hMwpW/MjOSZ1Pqt+uFcVuHTxwDNsEfrZJFQu+50sLjGJmknA0l0yaBwv5XYWGdQRilQRAze7HujK192HUKMwo1LNdL5YEApQQhLV1N6bPhivWNkFxyBwvXknzmsLUx0YojGaClx8H45U0wRO3mOuRWURM391OXCRAsdi5VuHUFm7EKpbSLzVIdS6IpocSWLbQQcddLCv4zX7xRNCvEMIcXCTfz8WQmwXQoRCZiDfAuDINtu5WQixXAixfOLEiXt5lNQoYlATlm41lUm2afKpA0YEDih4OGtuiL89TIU/Qw9ge2gfAiQnpHRosQ3M6XIIchvUakMAqZXs7cn9OIRqVPXd/P7luOodCySB43JyZaEmcE6jBUsKPN3ntXu2VE1MmMd56F/Gr4uTgVwPsOg0Y9jymKqeJHB7T4FL3vJ+KPt5YsIC4NirksS9NhS/tlt7znk0ixypo9fhSRsRrXoZ26yNwwcuJnCS0JgKnGUocIwS2JkCcOLfxesaXL4378LTqlqrEKqhPAckXtkLk2qYzs/UCtpA2UPARdtijGZwtf2MUf2dVfHkRAg1rUo7yQKhuX15TCll4KsCFIEmJsUddNBBB/swXpdfPEKIaeB1FoDVf9QB6LgfoY1VqJrAZZNRXe2Nlqcevna8jVMWKPITeNKmYk9huMrvSQiVqok/Y9GoEpW0DaGmFDjux3l7TpKUEEJkCFWkQqhwMKXUnKTqUxnQ1Pe984BMqnK0ldKoyZFRxctMBY7ScTdM3x3SxMkLZRgwIoimFYxRvZo+VyaKxS6UaA1XLU0VCqhWaeZ5iApE2uRraZPkGlFVspYkgCEXoJRE32dsKu8H4/pnEY+hlLFii5SWOXAxgQtJ6/uooJihJmBfvnctgPGZT5uIQqhagQuDiHQyM43h2KuAS+6P36fuJUoJvnTWwbjE/wS+FZyOTWJCp4ihgw462K/wev3i/SMhZBUh5GkAJwC4+nUZBWUxedKhJG1rkUs2+fZVdwJbpHKJwr1A4PYg/Kqny6zDIgUObUOoVmRXAkCqQrq6sontiW1RVBWBo0EVARgEKCa1IHDnLJd5SUtmTkp+0T2rceFWRFX3mzXOCbXlOa35HPYeNEzfHRoIXMDBKImLD0wCV94Zv06HUA2UiiXMz9dw4pxk2B0VtX5XfC50VWi7vp1agbtv4oV46cD3Y8vc9wBQVahGCDVrM1lEYBBjK4ztQhgjmDFRPYjwFuHJBIFLXh9zhEU3DqGa2NP+o3r96KFD8OYh1KCefIhq0rN1Zm8O68U0XBu8DwDpKHAddNDBfoXXxQdOCDNr/HVGupm9VuAKyXBtoKwcLJFSMkJvz1toASkFbs+rUDM2w4BXVJ+1CW/6teT70FDgmhA4l1FUQ1WFGlZRJVlQIj3FmuGI2b1Y96VTQIZfSX7RM7tx4VahYn3+jLxAFhG4cK8qK81CqJSYCpxxnNWB+HW7LhtODiT0QEjKxKyscjZLseAcKXBtyIZW2MrIYt1hfxt9rnuPahUsazOpgJnE2IsJHCUEN/31m4GvI2HBkYChevHUfehaFDVluZJzdRFD8l7b0/ZVEYFjZghVvmQIgUlL5N/U/Hck7xe30QdweneSMLcqtOmggw462Bexfz+yEpWIbvYLbRFCDZQ6YZm2DULIySZV8DAuOK8uB+5Nc+S4Cq6FXaqHJxFtqvfSxGrb08D2Z+Rru9CwuGPRqFISAKgIkXdYZCPRDDajsBxDoTr1OuCwJhyd2UDXTODIy1M7VesaeYG62bnZxmlvID3J+6FS4PQHrci41eYa23l5H6SvQ7lfteCKz10RkmC1K8rQbcqCMEkIOZfr6S4YGZtJRdG0kfFjtZUREtvhjEOB4ykFzlS0dA5cWuXa0xCqk7YRMZrZMxECpWnAFY9JSx6TTGcbCVzaN3Fv5Ul20EEHHbwR8LoocH9yoFZccahbDqVCqB6Rk8mEygZgSx2YeggwplpC/aEK3B6EYP/p3MPw2MYB3PjrF7Fzl87Dq7ZeYfClxs82PSrH7DSGBV2boiosbJ9+MiZvvg8WAhRctnsVTCsqxSnAkZc1X4YQ6aGWzseydAjVVOBiErk3Q2OMphU4AUaNyb9VOLudAmdnZS5kA4HbBWS7gUqs5D3Ml8hV2pzPjCLL6UIC3Xu0Jy/Pdc5hUpE1cwv9ClZ88gRs3FmW+XH63hpHEQNNkUrXZkBNrlfYSyFUfdw8shHhsMwQqu45CyQfbFJFRc3QrolDBx100MG+ho4CB8iJQqSKGHK9iUV9ReDetOUO4IFrgVX/BfzkKvnlq1HgzJwqp1EJa4Wsw3DcgonI2hQDQoVQ/TYEziR3J30J6DEALzAAAB8vSURBVD1Avl5+cYPKCAA5x0IQCmydKStCGTgK7jhc7rPd0obj1JaOMBJpwgHE5Mg4D7lMfE73JoFL041IgSOtllBoRYAASYRF2GjVEaoWXCoX7v5lX8MIdP/ZNgqcYjR+msBxAUYoZqqWcJGKZ4Y+i1MwszeH4xaoFABNgsZRxKB1PD02c4x6TH9oCFWfZ673xjkywYjaf5jM5zQfbLqaeyyahHK01uYaddBBBx3sY9g/CZxOsNdhGcuNc4S8sgw7pVS1OkmpZM/cHb9uk+DeEq/WB07BtVlchdpOgTvmI/HrrunA2d8Bjv80cMKnmxY/5B0GL+Dw7Dg/rpS1G9SZpjj2qkbvt/FAhyeNEGopHxO4venvFfKkTqNtRKIiCdFCx8n2Nv8ciKtovdR1CANJrk7/F2D6cniTlsartCE+OswbGmMRQqDmh8g5DLMUgav5TYygz/hmcmP6Ph4HgdOXuJhpvC8cFdaNbEAU9tSfTwero3y7Hc/g+Ec+gGPpqliBizZu/M216DNshlFLTcbdQQcddLCvYv8kcO/4AvCuf5KJ0oAkcDqEGnoyjJZK6C7k26hkryoHzgihvgoC51gUw7oKtZ0Cd9I/GPtxgBlHAMdf03JCzLkWvICjzuLvu3N7aFK8p4gUuPicdOVfGwUuHZbkIhVWTYdBS9OAyx4EFpzceqM6FB2kCkZ4IPPTph8GXPJLZCbEhR3tFDhCZMN6bpDNshci4AITCg4mFCSx0Q3tIyJemAzMTFkqpn0O0zBCqJrDzp9UQF/ewckHTcHbF8nqYh1iTpPpdsfR/NjUcLQCt3MdAGAZeRE2wuTfnXldWqQZ3HDOIZjencXX33sozlk+c4/G0kEHHXTwRsb++chqucDyC+P3zI2ViMCTKkCqv+iFJywB1rfY3qtS4F5dFWq0OqNYL6bil+w4vOOY03a/AjCuYom8w1APODw7zjmaUHgVOX57Aj0uw6y1mFDg2psI7wnSChyQSsRPEzjmAlMObrgfEtDXP62EcqXAKdZiFoLsLvlfErj4/UhVKsSTShkcNK2EjE3/f3v3Hi1XWd5x/PvsPTPnnOQkITdCgASSUkAEjBgRFKhitAi2WOsqqFR6sbS22qqtFaptsa6u1braaq29UYvaShXrvXa1ywtU67KCqIABpNJKFUUiLQlySc5c3v6x3z2zZ2bPde/JPjPn91lr1lyz3/3OnJx5zvO+7/Ny0WlHRU/GPz+WEuiaRe9vfXAGLp5FdtJRa7ju5WcRWBTgfmf/42z1ZWQ6P4uRM3Dx7hXNRQwdq2N7lcTpMc/0WScfyWdf90w/DK5FDCKycqzMAK5Tab71RVJfirIWHaU5Fhb6ZeB6F3ntKTmEOkIh3+Y/LwXUCXnL4uvYc/aPDPeP+tWL81ZVSizVGzwWtPp05NoJZ+DiwCORFQzK88yXAw5WG7kOocbzyjYvzvH9R6IVxW1BSFcAV+kfvEErO9S532ij2pY5WignA7j+fSqFQdsQ6gEfwG1dN8+a+TJ3vumC1vPxz09aAAf+D5TBGbjv1qIpBesW2rdO27Gp9bPQnYEbcQ6cv27E/798YPnENY/CQXr/MdPnMxh1Hp6IyCzQbz6IhkwbiSHUlAxc32HSueEXITS1ZeBG/xjiTMhINdL6VNqPxasNH6XV3y09ivjmJs6cLCaKAYdzzf0358t5BnBR0LN2ofVetA8DdmTohlkh3GuhQJyB89oycAMyV2HHEOrDiQAOohWjzXl0YZ8MHERB2r2f664JCFEGbvvZcMl1fLYarZDdtLp3nzPPgfMvr8cBnP/D6aKtfvFQ0PHHwtN/Fc593UhtiIisBArgoD1DUV+KvhA7vww7A7jk1j5rjx69zT5bMw31z30mZKgaafGX5RBDtXHB1kdrrS/mLWvHmOM3jO1Pj67j9zoZNJfmWrXHcsywnHRUFGz/0OZW0N32HqZl4AbpNc+sXmub35jMwA363EqhtWfgDsYBXMpn0W8IFaDqi/ve8eHu51w96uMTnt8s2rt5Te8+d61CHTGAi+fSuTj53/medWaJn/tmePYbERGRdgrgIJpEX6+1CvMOk4FLBkMbTxi9zRFKh6T+8ziAG2Z4MQ5CBg0FQjPrdbDa4Csbns+rll7Zlq3K1eUfh9fc1VVzD4Ag5MLToh0MVs3l1/75J2/hE686h5efu6P5WFuA2Nwn179Xw2Tggh4BXEcGbj45hDog61oKjOR0vceXoqHO9atShtsHDaHG0lbYNhpdPxcb+mXgOn7eRp12tueULZRDY8+p/o+eOGCOjzNCUWsRkZVMARxEGTjnA7jaUvqXSNck6sQ3V48VnX3FGbiUWmzDmGtm4Ib4Bo0DzEFf8ETFYSFa4fiR7VfxT42nt2WOchWWYd3R7VHADj+fr3aI119wEh/4xbO57KyUfVUzOPWYdaxdaAVCbUHwtqdF18fujq6HWWDSdwg1kYGrJDNwgxYxBG0LLpbqDUqBpc/3it+/QQF62s+1q3X1ceNi7yBqvuNnIWVNSF/HHLHA3W9+Hued3JG1diklUUREpCctYgA/B64ONHwZkZSaX52phuT9cYZDy/NRiY9NJ47+b2lljYaa4P/TH4avvrdVxLePeA7cwWq9OeG/80t7ol7yAfjfe2BxC2bGmTv61F/LIDn0V0kGU0/7Rdh+Fnzri/Dtm7pLg6TpF8D1GEIduAo1NBqJjFm15iiHQXo9vmYWa0Awn/Z0o9E1N3LtfO8gqnPOW9qq3kGiHSI6fvXE790QC21EREQBXKQ0H32BxEOo4ZBbW132Edj/raGGJlMli+yOKJ5MPtT8sMUj4dzXDnXceLjyUC0ZwB3GRG15PirbMWHJ2m9tGTgzOHpXa5u0gw8PcbB4Y/aO+XMdAVwYGJUw8Nm0IYZQE8FRtd6gFFr6fp9xKRDr8XP46r3wtlPTS4m4elfQNNSwvFcbI4ADujNt8QreYf/viYiscArgIPrSePT7cOfHWoV8BzI44fyJn1ovceBWybFGGrSGUJdqjeZm6vM5t7EcJDNwc2lB8BpfY63fFlqx5iKGjg3jOwI4iILhpXqDcmlQBq69jEg8hBqmBXBuQAC3uMWfT7X7uUareO4nXnUOn7rzgWYWtpdzTtjE5++JtgcbJwMHdA9Nx++zhlBFRIaiOXDQmqi+94M+gBuibEbBNUPjRQyVAYHAyMf1wUyt4ZrbTA210nXKJIcwUzNOW06Fp/wsnPvrgw+WNoTqnA+O2v8YiOfBDVq92VnIt1pv+CHUlBfHL+yV1YvrGnbWqXMNwDWDqVOPWcdrnnPiwCHza172FF7xzGg4/vRj1/V9bU+dAVy8j2xJAZyIyDCUgYP2lYb16nABXMERXDOAyzm4io9bbziqdRcN241YKmIaJOdypc4jDAL4sbcNebCUDFwcHHVl4KLgqDxgCLUcBizVWgFhte7nwKVl4HacByc/H574wvSDmUWrqOMgKVYfL+u1qlLi9Rc8gdc+56T08xlGEESLauJh5+YQqlahiogMY/ZSK2NJVuKv9y4dseul6f+mAHE9rrwXGMQBXJyBKwXGDMZvbXPQMu+1GgcdiV0NWpPy24OjVZWQwBgYFIdBex24eA5c6hBqqQKXXgen/WTvA6YFcPHWX+MUoiYKMkct5NsmmYVTACciMhIFcADVR9vv98rAveAv4MXXR7cL3ncxDjry3GYqedx6HMBl/ZJeptozcBmD4CAlA9cM4DqGUMulaN/OAX8AlMP2RQxLNR9Mj/tZlBe6h1CrcQA3RhmcPCSD2zi4DDWEKiIyDAVwAEsdAdxQ22YVHMDFZUTyzsCFHUOoQY+Vj1Nu4CKGUTRXoQ4RwFX8MOiAt7QUBDQcOJ+FW6pn3BM2NQPnS6TMrR3/uFns+b1WQev43IapuyciIgrggO4ArtQngIu/kJdJBi7vEh/NRQz1BtVGNGw3g/Fb2yKGzEFw2iKG+HYpPQPn0nZF6Di/hnPNnVnjRQxjK83D926Hxx9qPRZn4BbGXIiQ1Zkvh6vug9WblYETERmRAjiApUfa769O2dop1syoFBvVbN+wiiPXzLFjU7Y9VTsFgVEKLDEHLkifdzXlknPg5soZ+5e2iKFZFqN7FWoUwA06Px/A+ddVay7bXL37b4uuv/Bn8O2b/UHjIdSCAjiI/hAKK9EOKKA5cCIiQ1IAB/CkF7ffP2Jb79fGX9YFxzSb18zxhSvP5/yTt+R+7Eop2sapFq9CncEALjmVLHOduyCMVlSmBXAdC2I2LVZYXQnbdllIUwoCGg2Ic3DREGoOw+X77oTP/wkc+G5iCLWgOXCxsAINDaGKiIxCvy0Bdr0EHrgD/uMd0f11/fbetI7r4qTui5mDShhQa7jsE+eXMUsEpbms5A3L7QFcPT2Ae/WeE7nwtKM4YlX/TFMYRqtQmxm4rHPg5tbBoQOt+/v/p5WBmy8wAwc+gKu3bouIyEDKwMWaWQiDtUf3eaH/Rh1iY/hpVSkFzSHUzCU2pkAufQwq0cbwsR6LGNYtlHnq8RsHruwtBx17oWb9LF75pfb7B/e3MnCFB3Dl9NsiItKTMnCxuHRIeaH/KtR4r8ZVk9lkfTkoh0G0iCHrxPkpkcvQZGcGrscQ6tCHCwIajSgDV284Gi5jpnBNx1D74/tbe6AWtQo1lgzatJWWiMhQFMDF4qCtvKr/TgybToAf/QPYdubhOa8CxHPgqnWX+04Py9Ggba2GknMAVw6tWUak6vekzbXm38EDUFkdZQiH2vt3gpJZSg2hiogMRQFcLA7aKouDv3TPfsXkz6dArQBu8Kbr02ztfImHD9byKZMSltvrwMVFc/uVpOl3uMCoN6IlDLVJBXBhKQqYil440BbAKQMnIjKMwtIrZvYqM/u6md1hZm8p6jya4gBubnXhNd6KNucXMdQas52B27V9PUDbpvFjS07EB2j4AK48zL663cph0JwDV/MnWM41gNsfZQmDUrSKtkhtc+CUgRMRGUYhf3qb2bOAi4EnOecOmdmRRZxHm7iQaKXg+UDLQKUU8INDNWoNN9Nz4N7xkifzoS/fx+nbcpjEH1baC/nGdc36Dcf3O5zPwDWco+631Mrts1i1McrA1Ws+eCv4DxYNoYqIjKyob+dXAH/gnDsE4JzbV9B5tMQV6ucVwM2VA+qNBvUZD+DWzpf52WfsGFjSYyjVx6KdDuKi0I1sQ6jxTgwANR/AzeeVgTviOB/AHQQLi19RnVxEoSFUEZGhFPWb+0TgXDO7ycw+a2ZPLeg8Wo7dHV1ve1qx57EMxHXgZj2Ay9X+b0XX934huo4zumMOoZaaGbhWAJfbEOr646L5eo891CpCXKTFRAJeq1BFRIYysSFUM/s0cFTKU2/w7W4AzgKeCnzAzHa6lA0izewK4AqA7dv7FdjN6Linw29+s38JkRWiUgpYqkXzrirhyp4POLTzfxtueDPc9XE4+kmtRQzlVWMdrrmZfcNRjxcx5BVMrz8+un70+1ENuKIDuNWbW7cD/cEgIjKMif22dM7tcc6dmnL5GHAf8GEXuRloAJt6HOca59xu59zuzZs3p70kP6s2KIADKqWwGcBNareHmXPKC6Lrxx6Ez/5hIoAbcwjVlzapO9dcxJBbUeUNO6PrQw8vvwzcCl9AJCIyrKJ+c38UeBaAmZ0IVIAHCzoX6VAJAw76AC7X0hWzLDl3q17LYQ5c9L7X/WpgyPGzWL+zddvC4oOm1ckATj9vIiLDKKoA1LXAtWa2F1gCLk8bPpViVErWzMDlWrpiliVrB5pFc+CC8thDgnEGrtporULNLQN3xPaofEijFtWCKzqAi3c1CUpjB7wiIitNIQGcc24JuKyItmWwUiLomOU6cLlqK39h0RBqhhprc+Xofa/Woi3NIBrazkV5VTRs+fB3iy/iC7DpRNh0EjzxJ4rfFUJEZEosg9/estyUEgsXVsJm9rlIBnBGFMCFpbGHBON9T6v1RisDlzWY/oUb4fbrobIAa4/xAdwyWPU5twi//EVweVRUFhFZGRTASZfk3qAK4IaUmoErZw7gDlbrzTlwmT+LY86ILgCr/JqhondhiAUBBW4MIyIydfQbU7okV55qEcOQkosYLPBz4ErRIoExLPgAbqmWWMRQzvGzqPjyJsthCFVEREamb2fpkszA5VZ7bNa1LQSwaBVqOH4GLg7gDtXqzTpwuc5HLCuAExGZZvrtLV3aFjEoAzc6o5WBG3OIcqESve9LiTlwuWZDK6ujawVwIiJTSb+9pUtyEcNcXisfV5TEKtQxM3Dx+16tu+aeqLmWdFEGTkRkqum3t3RpG0JVBm50cR24sDJ2jbWFSmsVaizfDNx4W3yJiMjyoG9n6RK2rUJVBm4s9WrHytTRxHPgavVGYieGHD+Lsh9CVekOEZGppAycdCknJsuXS9qbcnQW7XKQYXiyuQq17ggsXsSQ42cR7xzh6vkdU0REDhsFcNKlLQOnVahjMHDZArj5RAYuCIzQjGDMbblSxWVPlIETEZlKCuCkSznUHLhMDGjUMwVw8ftebTQICQgDI8gzGRrvwNBQBk5EZBopgJMuYVsZEc2BG5lzPoAb/70LAmO+FFCtO3DOB3A5RnChAjgRkWmmAE66tGfgNAduZK6eeQ4cRMOoS7UGViL/AC4+Nw2hiohMJQVw0kWrUDNq1KMgLsy2Ufx8JQrgwsAIAxu3Ikk6zYETEZlqmuAkXZI7Mcznuf/mStGoQ6Mx9j6osa1r59n/eJV6w1HKO4Db9rTo+qSLcjyoiIgcLsrASZdkId9SnisfVwqXTwZux+bVfOaufaxfVc5/CHX1Jvidh1RGRERkSunbWbokt9IKcl36OOMu/KPoulHPvAoVYOem1Rx4vMqjh2r5B3AAQZA5yBQRkWIogJMuyaxbqABueGf+Auz+OWhUAZc5ODpuY7RbwvcePhTNgcvhFEVEZDYogJMubRk4RQ2jCeegthTdtmwZuDXz0b9vZuD0YYiIiKcATrok58DlPmw368Kyz8ABYfYyIgC1hlMmVERE2iiAky6lUEOoYyvNt27nUAcuVtbnICIiCQrgpIsycBksHtm6HVYyHSq5jVlJe9KKiEiCvhWkSxhoDtzY1hzVup1jBq6kD0JERBIUwEmX5FZapgzcaNYc3bqddSeGsjJwIiKSTt8K0iVU8d7xrd3aup15CFVz4EREJJ2+qaWLhusyWJ2YA5d5CDWZgdNnIiIiLQrgpEscLChkGEOydEieGTgNoYqISEIhe6Ga2fXASf7uEcB+59yuIs5FusU7MahwbEYZA7gwMEqBUWs4zYETEZE2hQRwzrlL4ttm9sfAgSLOQ9LFQ6iK3zLKYZ/R+XLII4dqbQtLRERECgngYhYtcfwp4Pwiz0PaxZk3FfHNKIcAruIDNw2hiohIUtHfCucCDzjnvlHweUhCXED27J0bCz6TKRUvXsg4hAqtYLqiDJyIiCRMLANnZp8Gjkp56g3OuY/52y8G3jfgOFcAVwBs374913OUdPPlkK+8cQ9axjCm0jwsPQJBOPi1A8RZ0HKY/VgiIjI7JhbAOef29HvezErAC4GnDDjONcA1ALt373a5naD0tWFxruhTmF7NzFv2ADi0OIBTMC0iIi1FDqHuAb7unLuvwHMQyV+8oX0OGbjmEGqp6NkOIiKynBT5rXApA4ZPRaZSyWfgctiGbPVclCTXIgYREUkqbBWqc+5nimpbZKLiDJxrZD7UKVvXcvf3fsCjh2qZjyUiIrNDf9aL5K3k5w/WDmY+1O7j1wPw0GNLmY8lIiKzo9A6cCIz6ZQXwP23wfyGzIe6ZPc27t9/kOeecuTgF4uIyIphzk3Pws7du3e7W265pejTEOnPOXjoXlh7dCsbJ8uamX3ZObe76PMQERmWMnAieTODDTuKPgsREZlhmgMnIiIiMmUUwImIiIhMGQVwIiIiIlNGAZyIiIjIlFEAJyIiIjJlFMCJiIiITBkFcCIiIiJTRgGciIiIyJRRACciIiIyZRTAiYiIiEyZqdoL1cy+D/zPiP9sE/DgBE5H7c1um2pv+tsctb3jnHObJ3UyIiJ5m6oAbhxmdsvh3KRa7U1/m2pv+tssoo8iIoeThlBFREREpowCOBEREZEpsxICuGvU3lS3V0Sbam/62yyijyIih83Mz4ETERERmTUrIQMnIiIiMlNmNoAzswvM7G4zu8fMrpxQG/ea2dfM7FYzu8U/tsHMPmVm3/DX6zO2ca2Z7TOzvYnHUtuwyNt9n283szNyau9qM/uO7+etZnZh4rmrfHt3m9mPjtHeNjO70czuNLM7zOzXJtnHPu1NpI9mNm9mN5vZbb69N/nHd5jZTf6415tZxT8+5+/f458/fpT2BrT5bjP7ZqKPu/zjmX9u/HFCM/uqmX1i0n3s0d5E+ycisqw452buAoTAfwE7gQpwG3DKBNq5F9jU8dhbgCv97SuBP8zYxnnAGcDeQW0AFwL/AhhwFnBTTu1dDfxGymtP8e/tHLDDv+fhiO1tBc7wt9cA/+mPO5E+9mlvIn3057nob5eBm/x5fwC41D/+V8Ar/O1fBv7K374UuH6Mz7BXm+8GXpTy+sw/N/44rwX+AfiEvz+xPvZob6L900UXXXRZTpdZzcCdCdzjnPtv59wS8H7g4sPU9sXAe/zt9wAvyHIw59zngP8bso2Lgb9zkS8CR5jZ1hza6+Vi4P3OuUPOuW8C9xC996O0d79z7iv+9g+Au4BjmFAf+7TXS6Y++vN8xN8t+4sDzgc+6B/v7F/c7w8CzzYzG7a9AW32kvnnxsyOBS4C3unvGxPsY2d7A2Tun4jIcjOrAdwxwLcT9++j/5f0uBzwSTP7spld4R/b4py739/+HrBlAu32amOS/X6lH3661lrDwrm254fSnkyUMZp4Hzvagwn10Q/13QrsAz5FlMXb75yrpRyz2Z5//gCwcZT20tp0zsV9/H3fx7ea2VxnmynnM6y3Ab8JNPz9jUy2j53txSbVPxGRZWVWA7jD5Rzn3BnA84BfMbPzkk865xz9Mx+ZHY42gL8EfgjYBdwP/HHeDZjZIvAh4NXOuYeTz02ijyntTayPzrm6c24XcCxR9u7kvI49bJtmdipwlW/7qcAG4PV5tGVmzwf2Oee+nMfxMrQ3kf6JiCxHsxrAfQfYlrh/rH8sV8657/jrfcBHiL6cH4iHZ/z1vrzb7dPGRPrtnHvABwQN4G9oDSHm0p6ZlYmCqeuccx/2D0+sj2ntTbqPvo39wI3A2UTDeKWUYzbb88+vA/53nPY62rzADx8759wh4F3k18dnAD9uZvcSTVc4H/hTJtfHrvbM7L0T7J+IyLIzqwHcl4Af9qvgKkQTpT+eZwNmttrM1sS3gecCe307l/uXXQ58LM92vV5tfBx4mV91dxZwIDEMObaO+UI/QdTPuL1L/arCHcAPAzePeGwD/ha4yzn3J4mnJtLHXu1Nqo9mttnMjvC3F4DnEM27uxF4UY/+xf1+EXCDz0AOrUebX08ExEY0Hy3Zx7HfU+fcVc65Y51zxxP9X7vBOffSSfWxR3uXTap/IiLLUp4rIpbThWjl2X8SzTd6wwSOv5NodeJtwB1xG0RzeT4DfAP4NLAhYzvvIxrSqxLN3fn5Xm0QrbL7c9/nrwG7c2rv7/3xbif6MtyaeP0bfHt3A88bo71ziIZHbwdu9ZcLJ9XHPu1NpI/A6cBX/XH3Ar+T+Pm5mWhRxD8Cc/7xeX//Hv/8zjHe015t3uD7uBd4L62Vqpl/bhJtP5PWqtCJ9bFHexPvny666KLLcrloJwYRERGRKTOrQ6giIiIiM0sBnIiIiMiUUQAnIiIiMmUUwImIiIhMGQVwIiIiIlNGAZwUzszqZnZr4nLlgNf/kpm9LId27zWzTVmPIyIicripjIgUzswecc4tFtDuvUQ1wR483G2LiIhkoQycLFs+Q/YWM/uamd1sZif4x682s9/wt3/VzO70G5i/3z+2wcw+6h/7opmd7h/faGafNLM7zOydRAVe47Yu823camZ/7TeDD83s3Wa215/Dawp4G0RERLoogJPlYKFjCPWSxHMHnHOnAe8A3pbyb68EnuycOx34Jf/Ym4Cv+sd+C/g7//jvAp93zj2RaO/a7QBm9gTgEuAZLtoAvg68lGhj+2Occ6f6c3hXjn0WEREZW2nwS0Qm7nEfOKV5X+L6rSnP3w5cZ2YfBT7qHzsH+EkA59wNPvO2FjgPeKF//J/N7CH/+mcDTwG+FG2jyQKwD/gnYKeZ/Rnwz8Anx++iiIhIfpSBk+XO9bgdu4hon8sziAKwcf4oMeA9zrld/nKSc+5q59xDwJOAfyPK7r1zjGOLiIjkTgGcLHeXJK7/I/mEmQXANufcjcDrgXXAIvDvREOgmNkzgQedcw8DnwNe4h9/HrDeH+ozwIvM7Ej/3AYzO86vUA2ccx8C3kgUJIqIiBROQ6iyHCyY2a2J+//qnItLiaw3s9uBQ8CLO/5dCLzXzNYRZdHe7pzbb2ZXA9f6f/cYcLl//ZuA95nZHcAXgG8BOOfuNLM3Ap/0QWEV+BXgceBd/jGAq/LrsoiIyPhURkSWLZX5EBERSachVBEREZEpowyciIiIyJRRBk5ERERkyiiAExEREZkyCuBEREREpowCOBEREZEpowBOREREZMoogBMRERGZMv8PcOKIRfErQ4MAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model_dirs = ['data/pendulum_ddpg']\n", + "show_config_group(model_dirs)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model_dirs = ['data/mujocoreach_ddpg']\n", + "show_config_group(model_dirs)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model_dirs = ['data/mountaincarcontinuous_ddpg']\n", + "show_config_group(model_dirs)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model_dirs = ['data/walker2d_ddpg']\n", + "show_config_group(model_dirs)" + ] + } + ], + "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.7.5" + }, + "pycharm": { + "stem_cell": { + "cell_type": "raw", + "metadata": { + "collapsed": false + }, + "source": [] + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/docs_src/rl.agents.doubledqn.ipynb b/docs_src/rl.agents.doubledqn.ipynb new file mode 100644 index 0000000..8a8a16f --- /dev/null +++ b/docs_src/rl.agents.doubledqn.ipynb @@ -0,0 +1,399 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "from fast_rl.core.basic_train import AgentLearner\n", + "from fast_rl.agents.dqn import FixedTargetDQNTrainer\n", + "from fast_rl.core.train import AgentInterpretation, GroupAgentInterpretation\n", + "from fast_rl.core.data_block import MDPDataBunch\n", + "from fast_rl.core.agent_core import ExperienceReplay, GreedyEpsilon\n", + "from fastai.basic_data import DatasetType\n", + "from fast_rl.agents.dqn_models import *\n", + "from fast_rl.core.metrics import *\n", + "from fastai.gen_doc.nbdoc import *" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "

__init__[test]

\n", + "\n", + "> __init__(**`ni`**:`int`, **`ao`**:`int`, **`layers`**:`Collection`\\[`int`\\], **\\*\\*`kwargs`**)\n", + "\n", + "
×

No tests found for __init__. To contribute a test please refer to this guide and this discussion.

\n", + "\n", + "Basic DQN Module. Args:\n", + " ni: Number of inputs. Expecting a flat state `[1 x ni]`\n", + " ao: Number of actions to output.\n", + " layers: Number of layers where is determined per element.\n", + " n_conv_blocks: If `n_conv_blocks` is not 0, then convolutional blocks will be added\n", + " to the head on top of existing linear layers.\n", + " nc: Number of channels that will be expected by the convolutional blocks. " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_doc(DoubleDQNModule.__init__)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "model_dirs = ['data/cartpole_ddqn', 'data/cartpole_dqn fixed targeting']\n", + "group_interp = GroupAgentInterpretation()\n", + "for model_dir in model_dirs:\n", + " for file in os.listdir(model_dir):\n", + " file = file.replace('.pickle', '')\n", + " group_interp.add_interpretation(GroupAgentInterpretation.from_pickle(model_dir, file))\n", + "group_interp.plot_reward_bounds(per_episode=True, smooth_groups=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nameaveragemaxmintype
0(DDQN, ExperienceReplay_FEED_TYPE_STATE, reward)188.234590499.09.1reward
1(DDQN, ExperienceReplay_FEED_TYPE_STATE, reward)220.743902499.012.4reward
2(DDQN, ExperienceReplay_FEED_TYPE_STATE, reward)186.998891499.09.5reward
3(DDQN, ExperienceReplay_FEED_TYPE_STATE, reward)152.903104499.07.1reward
4(DDQN, ExperienceReplay_FEED_TYPE_STATE, reward)147.719512499.09.2reward
5(DDQN, PriorityExperienceReplay_FEED_TYPE_STAT...57.051663202.310.5reward
6(DDQN, PriorityExperienceReplay_FEED_TYPE_STAT...75.768736198.010.3reward
7(DDQN, PriorityExperienceReplay_FEED_TYPE_STAT...56.496674166.49.1reward
8(DDQN, PriorityExperienceReplay_FEED_TYPE_STAT...11.07405826.85.8reward
9(DDQN, PriorityExperienceReplay_FEED_TYPE_STAT...36.042572275.09.5reward
10(DQN Fixed Targeting, ExperienceReplay_FEED_TY...148.154989499.010.6reward
11(DQN Fixed Targeting, ExperienceReplay_FEED_TY...141.317738285.814.1reward
12(DQN Fixed Targeting, ExperienceReplay_FEED_TY...229.873836496.09.8reward
13(DQN Fixed Targeting, ExperienceReplay_FEED_TY...149.444346483.913.5reward
14(DQN Fixed Targeting, ExperienceReplay_FEED_TY...137.559645499.010.4reward
15(DQN Fixed Targeting, PriorityExperienceReplay...29.12533381.67.2reward
16(DQN Fixed Targeting, PriorityExperienceReplay...52.764745166.89.6reward
17(DQN Fixed Targeting, PriorityExperienceReplay...16.28691847.85.9reward
18(DQN Fixed Targeting, PriorityExperienceReplay...16.516186119.88.3reward
19(DQN Fixed Targeting, PriorityExperienceReplay...16.339468218.58.4reward
\n", + "
" + ], + "text/plain": [ + " name average max \\\n", + "0 (DDQN, ExperienceReplay_FEED_TYPE_STATE, reward) 188.234590 499.0 \n", + "1 (DDQN, ExperienceReplay_FEED_TYPE_STATE, reward) 220.743902 499.0 \n", + "2 (DDQN, ExperienceReplay_FEED_TYPE_STATE, reward) 186.998891 499.0 \n", + "3 (DDQN, ExperienceReplay_FEED_TYPE_STATE, reward) 152.903104 499.0 \n", + "4 (DDQN, ExperienceReplay_FEED_TYPE_STATE, reward) 147.719512 499.0 \n", + "5 (DDQN, PriorityExperienceReplay_FEED_TYPE_STAT... 57.051663 202.3 \n", + "6 (DDQN, PriorityExperienceReplay_FEED_TYPE_STAT... 75.768736 198.0 \n", + "7 (DDQN, PriorityExperienceReplay_FEED_TYPE_STAT... 56.496674 166.4 \n", + "8 (DDQN, PriorityExperienceReplay_FEED_TYPE_STAT... 11.074058 26.8 \n", + "9 (DDQN, PriorityExperienceReplay_FEED_TYPE_STAT... 36.042572 275.0 \n", + "10 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 148.154989 499.0 \n", + "11 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 141.317738 285.8 \n", + "12 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 229.873836 496.0 \n", + "13 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 149.444346 483.9 \n", + "14 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 137.559645 499.0 \n", + "15 (DQN Fixed Targeting, PriorityExperienceReplay... 29.125333 81.6 \n", + "16 (DQN Fixed Targeting, PriorityExperienceReplay... 52.764745 166.8 \n", + "17 (DQN Fixed Targeting, PriorityExperienceReplay... 16.286918 47.8 \n", + "18 (DQN Fixed Targeting, PriorityExperienceReplay... 16.516186 119.8 \n", + "19 (DQN Fixed Targeting, PriorityExperienceReplay... 16.339468 218.5 \n", + "\n", + " min type \n", + "0 9.1 reward \n", + "1 12.4 reward \n", + "2 9.5 reward \n", + "3 7.1 reward \n", + "4 9.2 reward \n", + "5 10.5 reward \n", + "6 10.3 reward \n", + "7 9.1 reward \n", + "8 5.8 reward \n", + "9 9.5 reward \n", + "10 10.6 reward \n", + "11 14.1 reward \n", + "12 9.8 reward \n", + "13 13.5 reward \n", + "14 10.4 reward \n", + "15 7.2 reward \n", + "16 9.6 reward \n", + "17 5.9 reward \n", + "18 8.3 reward \n", + "19 8.4 reward " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "group_interp.analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model_dirs = ['data/lunarlander_ddqn', 'data/lunarlander_dqn fixed targeting']\n", + "group_interp = GroupAgentInterpretation()\n", + "for model_dir in model_dirs:\n", + " for file in os.listdir(model_dir):\n", + " file = file.replace('.pickle', '')\n", + " group_interp.add_interpretation(GroupAgentInterpretation.from_pickle(model_dir, file))\n", + "group_interp.plot_reward_bounds(per_episode=True, smooth_groups=10)" + ] + } + ], + "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.7.5" + }, + "pycharm": { + "stem_cell": { + "cell_type": "raw", + "metadata": { + "collapsed": false + }, + "source": [] + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/docs_src/rl.agents.dqn.ipynb b/docs_src/rl.agents.dqn.ipynb new file mode 100644 index 0000000..daa6871 --- /dev/null +++ b/docs_src/rl.agents.dqn.ipynb @@ -0,0 +1,343 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [ + { + "name": "stdout", + "text": [ + "Can't import one of these: No module named 'pybulletgym.envs.mujoco.envs'\n", + "pygame 1.9.6\n", + "Hello from the pygame community. https://www.pygame.org/contribute.html\n" + ], + "output_type": "stream" + }, + { + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mImportError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mfast_rl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbasic_train\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mAgentLearner\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mfast_rl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0magents\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdqn\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mDQN\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mBaseDQNCallback\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mfast_rl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mAgentInterpretation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGroupAgentInterpretation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mfast_rl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata_block\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mMDPDataBunch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mfast_rl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0magent_core\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mExperienceReplay\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGreedyEpsilon\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPriorityExperienceReplay\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mImportError\u001b[0m: cannot import name 'DQN' from 'fast_rl.agents.dqn' (/Users/jlaivins/PycharmProjects/fast-reinforcement-learning/fast_rl/agents/dqn.py)" + ], + "ename": "ImportError", + "evalue": "cannot import name 'DQN' from 'fast_rl.agents.dqn' (/Users/jlaivins/PycharmProjects/fast-reinforcement-learning/fast_rl/agents/dqn.py)", + "output_type": "error" + } + ], + "source": [ + "from fast_rl.core.basic_train import AgentLearner\n", + "from fast_rl.agents.dqn import DQN, BaseDQNCallback\n", + "from fast_rl.core.train import AgentInterpretation, GroupAgentInterpretation\n", + "from fast_rl.core.data_block import MDPDataBunch\n", + "from fast_rl.core.agent_core import ExperienceReplay, GreedyEpsilon, PriorityExperienceReplay\n", + "import torch\n", + "from fastai.gen_doc.nbdoc import *\n", + "from fastai.basic_data import DatasetType" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Databunch for Training / Validation\n", + "For reinforcement learning, training might take a long time.\n", + "\n", + "Note that if you want to avoid validation running, just turn it off and reflect the change in \n", + "the interpretation objects. The agent will train much faster, and then you could validate later.\n", + "```python\n", + "data = MDPDataBunch.from_env('CartPole-v1', render='rgb_array', add_valid=False, bs=128)\n", + "AgentInterpretation(learn=learn, ds_type=DatasetType.Train)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "data = MDPDataBunch.from_env('CartPole-v1', render='rgb_array', bs=32)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "show_doc(DQN.__init__)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "show_doc(BaseDQNCallback.__init__)\n", + "show_doc(BaseDQNCallback.on_loss_begin)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The batch size will be defined in the data class because `DataBunches` already require a \n", + "batch size input. This batch size will be used by the model during optimization." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Experience Replay" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "model = DQN(data, memory=ExperienceReplay(memory_size=100000, reduce_ram=True),\n", + " lr=0.00025, optimizer=torch.optim.RMSprop)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "learn = AgentLearner(data, model)\n", + "learn.fit(450)\n", + "data.close()\n", + "learn.recorder.plot_losses()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "interp = AgentInterpretation(learn)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "interp.plot_rewards(cumulative=True, per_episode=True, group_name='er_rms')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also pipe-line this to truly see how our model actually performs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "group_interp = GroupAgentInterpretation()\n", + "group_interp.add_interpretation(interp)\n", + "for i in range(5):\n", + " data = MDPDataBunch.from_env('CartPole-v1', render='rgb_array', bs=32, add_valid=False)\n", + " model = DQN(data, memory=ExperienceReplay(memory_size=1000000, reduce_ram=True),\n", + " lr=0.001, optimizer=torch.optim.RMSprop)\n", + " learn = AgentLearner(data, model)\n", + " learn.fit(450)\n", + " interp = AgentInterpretation(learn, ds_type=DatasetType.Train)\n", + " interp.plot_rewards(cumulative=True, per_episode=True, group_name='er_rms', no_show=True)\n", + " group_interp.add_interpretation(interp)\n", + " group_interp.to_pickle('data/dqn', 'dqn_er_rms')\n", + " data.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "group_interp = GroupAgentInterpretation.from_pickle('data/cartpole_dqn', 'dqn_ExperienceReplay_FEED_TYPE_STATE')\n", + "group_interp.plot_reward_bounds(per_episode=True, smooth_groups=10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "[g.analysis for g in group_interp.groups]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Priority Experience Replay" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "per_group_interp = GroupAgentInterpretation()\n", + "per_group_interp.add_interpretation(interp)\n", + "for i in range(4):\n", + " data = MDPDataBunch.from_env('CartPole-v1', render='rgb_array', bs=32)\n", + " model = DQN(data, memory=PriorityExperienceReplay(memory_size=100000, reduce_ram=True))\n", + " learn = AgentLearner(data, model)\n", + " learn.fit(450)\n", + " interp = AgentInterpretation(learn, ds_type=DatasetType.Train)\n", + " interp.plot_rewards(cumulative=True, per_episode=True, group_name='per_rms', no_show=True)\n", + " per_group_interp.add_interpretation(interp)\n", + " group_interp.to_pickle('data/dqn', 'dqn_per')\n", + " data.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "per_group_interp = GroupAgentInterpretation.from_pickle('data/cartpole_dqn', 'dqn_PriorityExperienceReplay_FEED_TYPE_STATE')\n", + "per_group_interp.add_interpretation(group_interp)\n", + "per_group_interp.plot_reward_bounds(per_episode=True, smooth_groups=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "CartPole envs might be too simple for PER to be effective. We also tested with lunar lander to see if PER improves performance, and noticed that it actually performs worse than ER. There is a possibility that you could increase the random sampling for PER to see if there is an improvement." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "per_group_interp = GroupAgentInterpretation.from_pickle('data/lunarlander_dqn', 'dqn_ExperienceReplay_FEED_TYPE_STATE')\n", + "per_group_interp.add_interpretation(\n", + " GroupAgentInterpretation.from_pickle('data/lunarlander_dqn', 'dqn_PriorityExperienceReplay_FEED_TYPE_STATE')\n", + ")\n", + "per_group_interp.plot_reward_bounds(per_episode=True, smooth_groups=10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "per_group_interp.analysis" + ] + } + ], + "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.7.5" + }, + "pycharm": { + "stem_cell": { + "cell_type": "raw", + "source": [], + "metadata": { + "collapsed": false + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} \ No newline at end of file diff --git a/docs_src/rl.agents.dqnfixedtarget.ipynb b/docs_src/rl.agents.dqnfixedtarget.ipynb index e3b1a7f..44fd18a 100644 --- a/docs_src/rl.agents.dqnfixedtarget.ipynb +++ b/docs_src/rl.agents.dqnfixedtarget.ipynb @@ -5,23 +5,30 @@ "execution_count": 1, "metadata": { "pycharm": { - "is_executing": true + "is_executing": false } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "text": [ + "Can't import one of these: No module named 'pybulletgym.envs.mujoco.envs'\n", + "pygame 1.9.6\n", + "Hello from the pygame community. https://www.pygame.org/contribute.html\n" + ], + "output_type": "stream" + } + ], "source": [ - "import fast_rl.core.Interpreter\n", - "import fast_rl.core.Learner \n", - "import fast_rl.agents.DQN \n", - "from fast_rl.agents.DQN import DQN, FixedTargetDQN, DoubleDQN, DuelingDQN, DoubleDuelingDQN\n", - "from fast_rl.core.Interpreter import AgentInterpretationAlpha\n", - "from fast_rl.core.Learner import AgentLearnerAlpha\n", - "from fast_rl.core.MarkovDecisionProcess import MDPDataBunchAlpha\n", - "from fast_rl.core.agent_core import PriorityExperienceReplay, ExperienceReplay\n", - "from fast_rl.core.MarkovDecisionProcess import MDPDataBunchAlpha, FEED_TYPE_IMAGE, FEED_TYPE_STATE\n", + "from fast_rl.core.basic_train import AgentLearner\n", + "from fast_rl.agents.dqn import *\n", + "from fast_rl.core.train import AgentInterpretation, GroupAgentInterpretation\n", + "from fast_rl.core.data_block import MDPDataBunch\n", "from fast_rl.core.agent_core import ExperienceReplay, GreedyEpsilon\n", - "import sys\n", - "import importlib" + "from fastai.basic_data import DatasetType\n", + "from fast_rl.agents.dqn_models import *\n", + "from fast_rl.core.metrics import *\n", + "from fastai.gen_doc.nbdoc import *" ] }, { @@ -29,429 +36,43 @@ "execution_count": 2, "metadata": { "pycharm": { - "is_executing": true + "is_executing": false } }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "pygame 2.0.0.dev3 (SDL 2.0.9, python 3.6.9)\n", - "Hello from the pygame community. https://www.pygame.org/contribute.html\n" - ] - }, { "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
epochtrain_lossvalid_lossepsilontime
00.0000430.0000420.80092100:24
10.0000140.0000140.75353400:07
20.0000100.0000100.72228300:12
30.0000140.0000140.70691900:12
40.0000040.0000040.59146700:24
50.0000000.0000000.39838800:53
60.0000000.0000000.28116300:50
70.0000010.0000010.27198300:27
80.0000010.26874600:01
90.0000030.0000020.24038600:12
100.0000020.0000010.23774400:01
110.0000010.0000010.23515100:02
120.0000010.0000000.23168300:02
130.0000000.0000000.23063300:01
140.0000010.0000000.22946300:00
150.0000000.0000000.22753600:02
160.0000010.0000010.22601400:02
170.0000010.0000010.22488500:02
180.0000010.0000010.22351900:01
190.0000010.0000010.22229000:02
200.0000010.0000010.22095200:01
210.0000010.0000010.21109600:08
220.0000010.0000010.21010100:01
230.0000010.0000010.20846100:01
240.0000010.0000000.20759700:00
250.0000010.0000000.20473100:04
260.0000010.0000010.20389600:01
270.0000010.0000010.20265700:01
280.0000010.0000010.20194100:01
290.0000010.0000010.20102800:01
300.0000010.0000000.19912600:01
310.0000010.0000000.19833600:01
320.0000010.0000000.19687200:01
330.0000000.0000010.19600400:01
340.0000010.0000010.19514400:01
350.0000010.0000010.19429200:01
360.0000010.0000010.19298100:01
370.0000010.0000000.19233200:01
380.0000010.0000010.18960400:02
390.0000000.0000010.18880100:01
400.0000010.0000010.18747900:02
410.0000010.0000010.18678200:01
420.0000010.0000010.18540400:01
430.0000010.0000010.18455400:01
440.0000010.0000010.18371300:01
450.0000000.0000000.18296300:01
460.0000010.0000010.18222000:10
470.0000010.0000010.18123900:01
480.0000010.0000000.18027000:01
490.0000010.0000000.17963000:01
" - ], - "text/plain": [ - "" - ] + "text/plain": "", + "text/markdown": "

__init__[test]

\n\n> __init__(**`ni`**:`int`, **`ao`**:`int`, **`layers`**:`Collection`\\[`int`\\], **`tau`**=***`1`***, **\\*\\*`kwargs`**)\n\n
×

No tests found for __init__. To contribute a test please refer to this guide and this discussion.

\n\nBasic DQN Module. Args:\n ni: Number of inputs. Expecting a flat state `[1 x ni]`\n ao: Number of actions to output.\n layers: Number of layers where is determined per element.\n n_conv_blocks: If `n_conv_blocks` is not 0, then convolutional blocks will be added\n to the head on top of existing linear layers.\n nc: Number of channels that will be expected by the convolutional blocks. " }, "metadata": {}, "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "unsupported format string passed to list.__format__\n" - ] } ], "source": [ - "data = MDPDataBunchAlpha.from_env('maze-random-5x5-v0', render='human', max_steps=1000)\n", - "model = FixedTargetDQN(data, batch_size=128, max_episodes=50, lr=0.001, copy_over_frequency=3,\n", - " memory=ExperienceReplay(10000), discount=0.99, \n", - " exploration_strategy=GreedyEpsilon(epsilon_start=1, epsilon_end=0.1,\n", - " decay=0.001, do_exploration=True))\n", - "learn = AgentLearnerAlpha(data, model)\n", - "\n", - "learn.fit(50)" + "show_doc(FixedTargetDQNModule.__init__)" ] }, { "cell_type": "code", "execution_count": 3, - "metadata": {}, + "metadata": { + "pycharm": { + "is_executing": false + } + }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABZgAAAIyCAYAAABGja/CAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzde3wU9b3/8deSqBxEIXITSDByUimg1UIiYpWi3CkGEQtBuRU01YMUhR7Bn1VEPYgVLbZYT6m2qBWw0CpFkRZv4OXIxWq1amu0IEm8wUEUaxVI5vfHnhmJhNuy7Mrm9Xw8eOxmdmb2O9ks2XzmM+9vLAgCJEmSJEmSJEnaX/XSPQBJkiRJkiRJ0qHJArMkSZIkSZIkKSEWmCVJkiRJkiRJCbHALEmSJEmSJElKiAVmSZIkSZIkSVJCLDBLkiRJkiRJkhKSvT8rN23aNMjPzz9IQ5EkSZIkSZIkfRW98MILm4IgaPbl5ftVYM7Pz2ft2rXJG5UkSZIkSZIk6SsvFou9XdtyIzIkSZIkSZIkSQmxwCxJkiRJkiRJSogFZkmSJEmSJElSQiwwS5IkSZIkSZISYoFZkiRJkiRJkpQQC8ySJEmSJEmSpIRYYJYkSZIkSZIkJcQCsyRJkiRJkiQpIdnpHoAkSZJ0oPr160dJSQkAo0aNSvnzX3fddbz55psA/OY3v0n580uSJEnpYoFZkiRJKZGfnw/A+++/T1ZW1i6Pjx49mtmzZye070cfffRAhnZIKCsrA+Ckk07i/PPPB2oWs4MgYPr06QD84he/YMuWLQD079+fOXPmAHD00UencsiSJEmqA4zIkCRJkiRJkiQlxA5mSZIkpdSSJUvo2bNnuodxyBk3bhwARUVFtT5+7733ct999wHw7LPPkpOTA8CFF17I+PHjAbjnnntSMFJJkiTVJRaYJUmS9JUzd+5cfvnLXwLQqVMn7r33XgBatmzJHXfcAUCPHj2i9bt3787w4cMBuOiii6I85LFjx/LSSy8BcNhhh0XbPPDAA9G2zz33HBMmTADgjTfe4IQTTgDg9ttv5/TTT4/WW7duHRCP8gD485//zGmnnQZAu3btaj2O559/nokTJwLw2muvcdxxx0X77t69+z5/PxYsWEDjxo0BOP3006Pj29mSJUsYO3YsAHl5edHyyZMnc/bZZwNw55130qBBg31+XkmSJGlvjMiQJEmSJEmSJCXEDmZJkiR9Ja1atQqA888/n02bNgHw+9//nvPOOw+IdxQfc8wxtW57zTXXANC7d2+efPJJALZt28batWujdTZv3gzAd77zHX76058CMGzYMBYuXBgtDzuFmzRpwgUXXABA165dAfjTn/4UjfE73/kOAwcOjPZdWVkZLQ9jK/r27cvjjz8OwODBg/nb3/4GQLNmzXb7Pfj4448BuPbaa6Nt77777lrXDYKAIAhqXf75558D8YkCTz755N0+nyRJkrS/LDBLkiQppc4991yys3f9GHrLLbdw8cUXR183b94cgMsvv5xYLAbA0KFDufXWWwF45JFHGDFiRK3PcdhhhwHw9ttv88477wCQm5vLGWecEa3zyCOPAPC1r32txn6GDRsGwE9/+lOWLFkCwNlnn82aNWsAeOyxxwA44ogj6NatGwDnnHNOjef/zW9+A0D//v3p379/tLxXr14AFBYWsnTpUgBGjRpV6zHAF4XysWPH1oi9qE2/fv348Y9/DMCQIUOiDOabb745WufTTz/d4z4kSZKk/WVEhiRJkiRJkiQpIXYwS5IkKaUeeughevbsudf1WrduDRB1L4fCifLCzuTahJ2811xzDaeeeioAOTk5TJo0CYAxY8ZE24f7+7Ljjjsuirp45513oo7gI488stZ1y8vLo6/ffvttABYuXBh1Qe9s+/btnHXWWbsdP8BLL70UdUu/+OKLe1wX4scUjqF79+7s2LEDgEmTJkVjyM3N3et+JEmSpP1hgVmSJElfSWFxNwiCGkXmDRs2AFBcXLzbbY899lgAfvnLX0bLnnnmmaiw3a1bN1q1agV8UQz+sg0bNtC3b18AWrZsyYcffgjAP//5T6BmoXnDhg01xhjGWYwYMaLGGPbHU089xfr16wFo06ZNtPyTTz6hqqoKgNdee40///nPANSrV49p06YBRLcQz4oOi/XhrSRJkpQsRmRIkiRJkiRJkhJiB7MkSZK+kj744AMgPtnef/zHfwDxeI3XX38doMbkeV+2cOFCALp27RrFQuTk5ERdxllZWdH248ePZ968eUB8crzf/e53QLw7eMCAAQA0bdqUwsJCAKZOnQrA9OnTWb16NQBLliyp0VE9fPhwAIqKivjjH/8IQM+ePdm+fTsAzz//PAUFBcDuYytKS0spKSnZZfnMmTOjzuY777wzWr558+aoy7pt27bR92nixIlce+21QLzLWZIkSUomC8ySJElKqXPOOYesrKxdlvfq1YsHH3ww+rpLly4AlJWV0bRpUwBatGjBokWLAGjSpMlun2PNmjUAXH755Xz00UfRtrfffjsAxx9/fLTuww8/zIQJEwC49NJLo8Lvww8/HD0vEBWhR40aBcAxxxxD165dARg5ciRbtmyJ1g0jMhYvXsyVV14JwLBhw6LjPvXUU2sUh2vToEEDGjRosMvyhg0bUr9+fQCaNWsWLd+0aRPnnHMOAOXl5dFjEyZMoLS0dI/PJUmSJCXKFgZJkiRJkiRJUkJiQRDs88qFhYXB2rVrD+JwJEmSJJg7dy533XUXEJ+cT5IkSVJ6xWKxF4IgKPzycjuYJUmSJEmSJEkJscAsSZIkSZIkSUqIBWZJkiRJkiRJUkLMYJYkSZIkSZIk7ZEZzJIkSZIkSZKkpLLALEmSJEmSJElKiAVmSZIkSZIkSVJCLDBLkiRJkiRJkhJigVmSJEmSJEmSlBALzJIkSZIkSZKkhFhgliRJkiRJkiQlxAKzJEmSJEmSJCkhFpglSZIkSZIkSQmxwCxJkiRJkiRJSkh2ugcgSXXdhg0bAOjQoQMfffQRAFlZWQf1OUePHk1ubi4AN95440F9LqVHLBajrKwMgIKCgjSPRpIkSZKUqSwwS9JBlJ+fD8D7779fa9H4jTfeoE2bNgB88sknqRzaPtm2bRsAV111FQ888AAAW7ZsAaBZs2ace+65APzkJz+JtsnPz+euu+4CoGfPngk/98EugldUVDBhwgQAVqxYwfbt2wFo06YNkyZNisagL6xfvx6A448/Pvp+ZWf7UUKSJEmS6jIjMiRJkiRJkiRJCbHtSJJSYMmSJQfUzZsuN910EwBr165l9erVALRs2RKAt99+m5UrV6ZtbAdqxIgRnHzyyUD8WI444ggAXnnlFd577710Dk2SJEmSpEOGBWZJSrPdxQ50794dgDPPPJMnnngCgJdffpmuXbsCMG/ePJo2bRrt57vf/S4ATz/9NP/6178AOPnkk7nzzjsB6Nix436Pbc2aNQAMGjSIVq1a1XgsPz8/igCBeMEW4pnS55xzDhDPkr722msBuPLKK/dpjHPmzAHg/vvvJxaLATBr1izOOussIF6sf+eddwAYP358VORu2LAhV1xxBQA/+MEP9unYwmiPI488Mlr+zW9+s8Z6O78+c+fOBeCaa64B4NNPP42e8+qrr462Wb16dRS/8frrr/Nv//ZvAAwePJjbbrsNgMMPPzxaPxaLcfvtt0fH+vHHHwPwve99j5tvvhmAevXq8eabbwIwduxYXnrpJQAOO+wwevToARDFmIQee+wxAPr168emTZsAuOCCC5g9e3b0vNXV1QBMnz6dX/7ylwD861//om/fvgD87Gc/o1GjRgB069Yt2nfjxo2j+8uXLweIfjYlSZIkSXWHERmSJEmSJEmSpITYwSxJX3Hz5s3j0UcfBSAvL49+/foBMHPmTGbMmBGtFy7/1a9+FXXHTp48mQsvvBAg6njdH6eddhoAt912W7TPM888E4ATTzwx6jAGuO+++4B4d/LuJvnblzGWlpYC8Nxzz9U6yV91dXXUIT1w4EDmz58PxCftC5+vXbt29OnTZ6/HNm7cOCDeCX366acDRJMu1uaZZ54B4O9//zsQn6Tx1FNPBeC8886jffv2QLxzO+yOLiwspKKiIjr+n//85wBcfvnlNfb94IMPAvE4knDCx549e9KuXTsALrrooqhzunfv3jz55JNAfCLGtWvX1jrehx9+GIh3a4dd0Z07d46+f3379o26sufOnRvts3nz5owcORKAyy67LHptw27x448/Pprs0Un+JEmSJKlu869CSUqBc889t0YhLoy/eOihh/a67fe+9z1OOOGE6OshQ4YA8Ic//KHGemPGjNll2+uuu46cnBwAPvrooyjqYF9dddVVAOTk5HD//fcDRJEQTZo0iTKaR40atU/7S8YY16xZw8aNGwGi+A2Atm3bcvHFFwOwYMGCvRaYFy5cGMVP3HDDDfztb38D4KSTToqiIoqKimpsM3XqVIAo8uLkk0+Ocpz/8pe/RAXmzp0719gujBL5/ve/z4oVK4BdC8yTJ08G4JhjjuGYY46J1gkL6BdddBGHHXYYEM+MDmNCcnNzOeOMM2o9xilTpgDxOIsw0uKss86KTjb07ds3el0nTpxI27Zto23D1/bEE0/k17/+da37lyR99TzzzDNceeWVALz66qtkZWUB0L59e2bNmgXEf7+FJxjvuuuu6ARqotavX8/xxx8PwPbt2w/Kyce7774bgFtuuYXKykoAGjRoQGFhIRD/3X/UUUcl/XnTqXv37gwfPhyIfw7Y2VNPPQXA8OHDoxPZB1t+fv5umwgkSXWbERmSJEmSJEmSpITYwSxJKfDQQw8l3Olx7LHH1vi6QYMGAFGMAkBVVVU0ydzChQujDt969b44j7hp06b97mAOu57GjRsXxUmEk/P96le/ijqSTz311Kh7d3eSNcadu3d3nmgufA74IsZjT3JycqKIkRkzZkST4P3whz/k3HPPBdilI+jLrwXU/nq88cYbTJw4EYhHXnz66acA7NixY5fu5lBeXt4uy4477rjoWAF+/OMfA/FJBsNojpycHCZNmgTs2iG+u/HuPNZw/8cdd9wuzx2O+f333691zJKkr44wCmnAgAHR5LlDhgxh27ZtQDzC6ogjjkjb+A7EihUr+H//7/8BsGzZsmhC3s2bN7NkyZJ0Dk2SJGGBWZIywrx581i8eDEAjz32WBTJ8NFHH0XxE0EQJOW5wniIcePGRZERr732WlRg3jmX+UDGuLv95OXlRZfhlpWVHeDRfKFp06ZAvMB8zz33APE/XBNx6aWXRn/8zp8/P7pkd9asWSxatKjWbcrLywHo2LFjtGzDhg20atUq+josGIcRHhC/FDo8edGtWzcKCgr2a6zh/t9+++0ayzds2ADEM5ZbtGgBEF2SLEn66nnjjTei+8OGDYvuh7+3e/fuHS17/fXXueSSS4B4pEXDhg2B+P/5Ycb+I488wo9+9CMA3nrrregE8NixY4F4xFWoW7du0f2dT/4uX76crl27AvET07fccgsA7733XnSidM6cObuc5PyyNWvWRPsJf79CPFaqtpiu0aNHU79+/Wjszz//PACdOnXi3nvvBWqeWJ0wYQK///3vgfjnkq997WtA/Pf2zietwxPZYcTW3XffzQcffADACSecEEWf5eXlRdFb48eP54UXXgCgWbNm3HDDDcAXkWfJ9tFHHwHx6KulS5cC8ZP53/ve9wCYNm1a1EDw1ltvRfFif/nLX6LPXn369OGOO+4A4q/niBEjgPhng3Aeh3Af1157bXQsxx9/PL/61a+i5eEJ7Ztuuik6wT527NjoM8bw4cOZPXt2NPa33noLgIsvvpi//OUvQPzzYBh7dscdd9T4+do5giycL+Ldd9+NGgXuvPPO6OdAknRwGZEhSZIkSZIkSUqIHcySlAG2bt0aXfbapEmTKJIhvJw0UeFkQKeccgpdunQBiCaau//++9m6dStQs5uoRYsW/OMf/zjgMe5uP6eeeipHH300EO8g+sEPfgDA4Ycfzuuvvw7EYzy+PEHfl02ePDnqyPn6178eRX/ceeedURdwkyZNomPcH1u3bo3G2LBhw6iL6c4776RZs2a1bhN2dXXp0iXq+Ln99tujqA2IR4sAdO3aldzcXCAekRF2HIXdRPsj7HK7+eab6devHxDvsApfl6FDh0aTNYVjr1evXvTa7DwBpSQpfcL/j7OysqKu3pKSEk477TSA6GohiE/499///d/A7if5O/LII6Nu344dO/LXv/4VgF69egHxzwZhp+jKlSujq4u2bNlSY5K/sKt3+vTpUZzF1772tSimatiwYTz33HN7PLYuXbpwzTXXAPEJd8Nu7MLCwt3GfoST2D7yyCPRZ5grr7ySCy+8EKDGMRcVFUUTBzdq1Ijbb78dgO9+97usX78egPr163PbbbcBRBPwLl26NPq+v/zyy1Fs1j//+c/o+3T99dfz6KOPRuuEY+/YsWONq5aSJXztW7RowZtvvhmNZ8CAAUC8u/r73/8+EL9yLJzQuVu3blHMyuDBg6MO9VmzZkXdwU8//XStk/yF3yOAVatWAfGrzFauXAlAcXExffv2BeJXsW3fvh2If3787ne/C8C3v/3t6Eq2q666KuqK//jjjxk8eDAQ75oPP5vu7P777+ePf/wjEP+5Dbusb7zxRm688cZ9/+ZJkhJmgVmSMsDIkSOjD9atW7fmmGOOAeCGG26IchgTEV5WO2nSpOiPlLCYecIJJ/C73/0OgLZt20bbXHXVVYwfPx6I/yEXXl57ySWX7NcYx44dG/3R0bhxY7p37w7E/1AN/0CdNGlS9Aft559/Trt27QD26Y+JTz/9lEGDBgHxyynDY+3SpQt/+MMf9rr9nsycOZPS0lIgnpscFuCHDh3KE088Ues2AwcOBKBz587R5a2jR4+OLkWG+CXCAJdffnm0TosWLaI/hMPvxf4Ic5vfeeed6I+5zz77LLoc9Wc/+1m0bviH89VXX823vvUtIH5p9bJlywCiIoYkKfXCE5vPPPNMFOFw8cUX89577wHQv3//KGIpjD7ak/D3bugb3/gG8MWJyRUrVkQF5j35xS9+AcQ/H+w8X0N4InP69OlRTNPuojLOPPPMKMLi5z//efR7b8eOHdHv21tuuaXGidbvfOc7QM34jv/6r/+Koj7Ky8uj+Q+GDx9e4/nCuQ1uvPFG/v73vwNw8sknR8XVcE6E8HNH+HjogQceiOIbwmgKiEd0hMXSRYsW7VOBOTyR/sMf/rDG8h07dgA1I0nef//9qJi9ZcuW6LPNkUceyRVXXAHEI0nCAnNBQUGNaK3wRPLEiROZNm3aXsdWm/BEQP369aNi+pFHHhn93DRv3jxa98wzz+TFF18E4gXmcCxfHlN4sn13Y7rssstqzGURzvkxfvx4C8ySlCJGZEiSJEmSJEmSEhLbn0mfCgsLg7Vr1x7E4UiSVPfEYrFowsL9naRPkqQ9CWOahg8fHk1eN3/+fObOnQvsPiJj1apVTJkyBYC//vWvbNu2DYhfMQTx+IgwOmH9+vXRVTTbt2+vEZHRoUMHID5B3M7LQ59//jmPP/44AKeffvo+HVN1dTUATz75ZHS100033RR15o4ePTrqxg0jqELh8ocffjiKzrj11luj7uR33nknulrr448/Zvny5QD06NEjupJn9erVAJx44om1ju/HP/5xdAVXuE0o7DweMWLEXq8y6969e9RdfdFFF9V47KmnngLir2tFRUU0rvBqorCjPRR+z/Ly8nj11VcB+OCDD6IO6aeffjqKBauuro4iVcJJiCE+qd6eIjKOP/74KP5i59c6NzeX3/zmN9ExhYYPH87Xv/51AH70ox9FEyb+4Ac/4OmnnwbisWPh2HNycnYZD8Qn/ws71oHo+AoLC6MINElScsRisReCICj88nI7mCVJkiRJkiRJCTGDWZIkSZIyVNghOnr06CgPGb6YU2F3LrjgAi677DIAHn30UerXrw/E5wEA2LRp0z7tK8zGvfrqq6MJ9g5UvXrxPqkePXpw9tlnA0STEIZ27nQNffLJJ2zevBmAVq1aRV2yN998c9RF3bFjx2j/OTk57HzFb3gsb731FrD7Dua8vDy+/e1vA0Qd0KmQl5cXTXq4adOmWjvGd3bVVVdFr93LL79MkyZNgPh8F+Frv7O9/cwcqHDCwVgsxssvvwzEJ1wOJ4qsbUyw62u9YcMGIP4aS5JSwwKzdBAsW7aMCRMmAFBVVRVd0hZeZihJkiQlUxiF8cgjjzB06FAgHk0QFt/mz59fYzLWcKK/ioqKKP7i8MMPjx7funVrNCFv/fr1o1iIefPmAUQTuEE8diIsyv7jH//ghBNOiB675JJLgPjkb6eccgoQL+KGk9X+6U9/imIudmfx4sVR1EGfPn2iie3WrFnDihUrAJg1a1aNbZYuXQrEJz089dRTozGEsRh5eXm88sorQDzOIYzO2LFjBzNmzADiERk7Cz/ThxPZdejQIYq2euWVV2jdujUAAwYMiD7333fffZSUlET7eOmllwBo2LBhjUkPk6Fly5bR6zJp0iRuuOGG6LnWrVsHxF/vsPi9devWaNLDxo0bU1lZCewaKxJq0aIF//jHP5I65p2FER2NGjWKXuPKysrdjid0xx13MGDAACAeSTJ9+nSA6H0gSTr4jMiQJEmSJEmSJCXEDmYpiaqqqgAYN25cdDlcbm4uRUVFABQXF0cTnUhSaH8m3JUkqTZHHXUUEJ+c77bbbgNgy5YtUSfogAEDanSChtESHTt25NhjjwXi0RNh9MXPf/5zJk2aBMSjCcKu1yFDhkT7DjVo0ICrr74agG9961vRRG/Lli1j0KBBQDyeIuzkffvtt6PO2V69eu21gzknJ4ef/vSn0VjCiQZbtmzJf/7nfwLsEr9xwQUXADBt2jT+53/+B4BOnTpx//33R+v06dMHgH79+kVd10ceeSRXXHEF8EUkRmjixInAFxMd9u7dO/p+ff3rX+fBBx8E4rEOf/rTn6Jtwu2qq6s5+eSTAaLXKNnuvfdeIH7lZPh3x9atW2nbti0AkydPjtadOnUqI0eOBOJdw2E39ogRI/jJT36yy76vuuoqxo8fD8CVV14JxCfnO//885My9qlTpwIwcuTI6OejoKCAESNGANQ6Joi/1mHn9jvvvMPAgQOjsUmSUiO2P3/UFhYWBmvXrj2Iw5EObeGH1+uuu44//vGP0fKbbropuh9mi0mSJElKvtGjR5ObmwvAjTfemObR6GDJz88H4K677qJnz57pHYwk1RGxWOyFIAgKv7zciAxJkiRJkiRJUkKMyJCSKJwY48uX04UdFKtWrUr5mCRJkiRJkqSDxQKzlER7i5yJxWK7fWzOnDk1bgFeeOGvZGUdm5zB1VGnnNI03UPICFVVkJWV7lFIX/BnMnnWr18fZYhKkiQd6vqcdST/u7kqqfts2rI7y5YtS+o+pUxiRIYkSZIkSZIkKSF2MEtJFEZhlJeX11heUVEBQKtWrXa7bWlpaY1bgOzsfBo3vibZw6xT1q4dm+4hZIQtW6pp3Nhzkvrq8GcyeQoLd5mjQ5IOaXPnzk33EJQC69evT/cQ9BX1v5urWP3HNknd56kDvNpL2hMLzFISFRUVAVBWVsa6desAaN26NQsWLABg3rx5aRubJEmSJEmZLgCqqU73MKQ6xdYfSZIkSZIkSVJC7GCWkig7O/6Wmj17Nn369AGgqqqKMWPGANCxY8e0jU2SJEmSpMwXUBWkt4M5nBBwwoQJVFXFJxy86KKLmDJlSq3rr1y5EoDLL7+cl19+GYAFCxZw/vnn77LulVdeySOPPAJAdXU1vXr1AuD2228nFosl90CkfWSBWToI+vfvT//+/dM9DEmSpIPq8Fh9/q1ew3QP45AVVHsJ94GIHeafs4kI/L4dsO1HZ6V7CIek7R9tBmDHp/88qM8Tj8gIDupz7ElVVRXjxo0DYPny5dFcTUVFRRQXFwPQoUOHGtu0aRPPjJ47dy4zZ86sdb/PPfccAM8++2xUhAY444wzAFixYgXdu3dP3oFI+8GIDEmSJEmSJElSQjx1KUmSJCkh/1avIac1LE73MA5Z1Vu3pnsIh7Tspi3SPYRDUlXrpukewiGvskejdA/hkPSPe25L2XOlc5K/1atXU1BQAEDbtm2j5SUlJSxevBjYtYM5Pz8/ul+vXu29oGH8xWeffca2bdsACIKA7du3A9Cihf8nKn0sMEuSJEmSJCkjBARUBemLyKisrCQvL2+X5bm5uaxatSrh/Xbt2hWAs846i5YtWwLxAvNll10GQPv27RPet3SgjMiQJEmSJEmSJCXEDmZJkiRJkiRljGRP8rdx40YKCwt3WV5aWlrjFuJdxbsTxlwk4s033wTg9ddfp6KiIlreq1cvAFauXEm3bt0S3r90ICwwS5IkSZIkKSMEQFWSC8zNmjVj7dq1+7Rubm4u5eXluyyvqKigVatWCY/hwQcfBOC0006jYcOG0fJ+/foB8Pzzz1tgVtoYkSFJkiRJkiRJSogFZkmSJEmSJGWMaoKk/tsfRUVFlJWVUVZWxrp169i2bRvbtm1jwYIFFBcXU1xcnNAxtWnThjZt2rBixQp27NjBjh072L59OytWrGDFihVO8qe0MiJDkiRJkiRJGSEAqvaQg3ywZWdnM3v2bAD69OlDVVUVAGPGjKFjx44AXHvttVGmc3FxMWvWrAFg0KBBfPjhhwAsWbKEqVOnAvDqq69y/vnnA/DEE09w0kknAfFM5759+wJwzjnnpOLwpFrZwSxJkiRJkiRJSogdzJIkSZIkScoY1Wl+/v79+9e4/bLrr7++xtdFRUVAfCLA3cnKygLgF7/4RTKGKCWVBWZJkiRJkiRlhICAqv3MTZZ0YIzIkCRJkiRJkiQlxA5mSZIkSZIkZYYAqmxgllLKDmZJkiRJkiRJUkIsMEuSJEmSJEmSEmJEhiRJkiRJkjJCAFSnexBSHWOBWZIkSZIkSRkiRhWxdA9CqlOMyJAkSZIkSZIkJcQOZkmSJEmSJGWEAKgO0j0KqW6xwCxJkiRJkqSMYUSGlFpGZEiSJEmSJEmSEmIHsyRJkiRJkp51fdwAACAASURBVDJCgB3MUqpZYJYkSZIkSVLGqA4sMEupZESGJEmSJEmSJCkhdjBLkiRJkiQpIxiRIaWeBWZJkiRJkiRlhIAYVV6wL6WU7zhJkiRJkiRJUkLsYJYkSZIkSVLGcJI/KbUsMEuSJEmSJCkjmMEspZ4RGZIkSZIkSZKkhNjBLEmSJEmSpAwRoyqwn1JKJQvMkiRJkiRJyggBUO0F+1JK+Y6TJEmSJEmSJCXEArMkSZJUhyxbtoxly5bRrl07CgoKKCgoYMaMGekeliRJSVNFLKn/JO2ZERmSJElSHVFVVcW4ceMAWL58Obm5uQAUFRVRXFwMQIcOHdI2PkmSDlQQmMEspZrvOEmSJEmSJElSQuxgliRJkuqI1atXU1BQAEDbtm2j5SUlJSxevBiwg1mSdOirNtZCSik7mCVJkiRJkiRJCbGDWZIkSaojKisrycvL22V5bm4uq1atSsOIJElKrgCosp9SSikLzJIkSVIdEQTBbh+LxfZ8OfGcOXNq3AJsCz5LzsAkSUoaJ/mTUs13nCRJkiRJkiQpIXYwS5IkSXVEbm4u5eXluyyvqKigVatWe9y2tLS0xi1Ao6ymyR2gJEmSDjkWmCVJkqQ6oqioiLKyMgDWrVtH69atAViwYAHz5s1L59AkSUqKAKj2gn0ppXzHSZIkSZIkSZISYgezJEmSVEdkZ2cze/ZsAPr06UNVVRUAY8aMoWPHjukcmiRJSVMV7HniWknJZYFZkiRJqkP69+9f41aSpEwSEKPKC/allPIdJ0mSJEmSJElKiB3MkiRJkiRJyhjVQbL7KYMk70/KLBaYJUmSJEmSlBECOAgRGVVJ3p+UWYzIkCRJkiRJkiQlxA5mSZIkSZIkZYSAGFVBLN3DkOoUC8wSMGbMGB5++GEAmjdvzl//+tfosc2bNwMwdOhQANavX09+fj4Av/3tb8nJyQEgCAImTJgAwNKlS2nQoAEAc+fOpVOnTik5DkmSJEmS6rpqL9iXUsp3nCRJkiRJkiQpIXYwS8Do0aO57LLLABg5cmSNx2bMmAFAjx49AJgyZUq0bMaMGdx8880APProo5SVlQFQVlbGqlWrALj00kuj+5IkSZIk6eAJAqgK7KeUUskCswR069aN9evX1/rY4sWLAXjqqaeiZaNGjQKge/fuUYF58eLFUXE6Fotx2mmnAbBlyxbeffddAFq2bHkwhi9JkiRJkgCIUY0ZzFIqeUpHkiRJkiRJkpQQO5ilvXj//feBmt3H4f0PPvggWlZZWUleXt4u2+fm5lJZWbnLPiRJkiRJUnIFGJEhpZoFZilJgiDY7WOx2N4vz5kzZ06N2/g+tx74wCRJkiRJqkOqvGBfSinfcZIkSZIkSZKkhNjBLO1FixYtAGpM1Bfeb968ebRebm4u5eXlu2xfUVFBq1at9vo8paWlNW4BsrPzEx63JEmSJEl1TUCM6sBJ/qRUssAs7UVxcTEA99xzDwBTpkyJ7g8cOLDGerNnzwagpKSEVatWAdCoUSOzlyVJkiRJShEjMqTU8h0nSZIkSZIkSUqIHcwSMGzYMJ566ikANm3aRG5uLgDTpk1jypQpAAwZMgSAu+++mzZt2gCwcOHCaB/9+/dn6dKlABQUFNCgQQMAfv3rX6fkGCRJkiRJqusCoDqwn1JKJQvMEjB//vy9rvP444/v8fFYLMYdd9yRrCFJkiRJkqT9FqMKM5ilVPKUjiRJkiRJkiQpIXYwS5IkSZIkKSMYkSGlnu84SZIkSZIkSVJCLDBLkiRJkiRJkhJiRIYkSZIkSZIyhpP8SallgVmSJEmSJEkZIQhiZjBLKeY7TpIkSZIkSZKUEAvMkiRJkiRJyhhVQb2k/ttfy5YtY9myZbRr146CggIKCgqYMWPGbtdfuXIlK1eupFOnTmRnZ5Odnc2iRYtqrPPkk0/y5JNPcsopp9T4V79+ferXr89DDz203+OUksWIDEmSJEmSJGWEAKhOYwZzVVUV48aNA2D58uXk5uYCUFRURHFxMQAdOnSosU2bNm0AmDt3LjNnzqx1v2eddRYAL730UrRs8+bNFBQUANC7d+8kHoW0f+xgliRJkiRJkiQlxA5m6SvslFOasnbt2HQPQ5IkSZKkQ0QsoViLZFm9enXUVdy2bdtoeUlJCYsXLwZ27WDOz8+P7tert+9jX7RoEf369QOgQYMGiQ5ZOmAWmCVJkiRJkpQRAqA6SF9ERmVlJXl5ebssz83NZdWqVUl9rgULFjBx4sSk7lNKhBEZkiRJkiRJkqSE2MEsSZIkSZKkjFGV5H7KjRs3UlhYuMvy0tLSGrcAQRDsdj+xWHI6q999910AXnnlFfr06ZOUfUoHwgKzJEmSpMQclk3s2GbpHsUh65+9O+x9Je1W1rbdF3G0e1mfV6d7CIe8T47fke4hHJKqD0/NezYglvSIjGbNmrF27dp9Wjc3N5fy8vJdlldUVNCqVaukjOe3v/0tAIMGDeKwww5Lyj6lA2FEhiRJkiRJkiQpIXYwS5IkSZIkKWNUp7GfsqioiLKyMgDWrVtH69atgfiEfPPmzUvKc8yfPx+Am266KSn7kw6UBWZJkiRJkiRlhCCAqiRHZOyP7OxsZs+eDUCfPn2oqqoCYMyYMXTs2BGAa6+9Nsp0Li4uZs2aNUA88uLDDz8EYMmSJUydOhWAV199Ndr/+vXrowiOb3/72yk4ImnvjMiQJEmSJEmSJCXEDmZJkiRJkiRljGRP8re/+vfvX+P2y66//voaXxcVFQHxiQD3Jj8/n8rKygMcoZRcFpglSZIkSZKUEQJiVAdesC+lku84SZIkSZIkSVJC7GCWJEmSJElSxqgivREZUl1jgVmSJEmSJEkZISD9GcxSXWNEhiRJkiRJkiQpIXYwS5IkSZIkKUM4yZ+UahaYJUmSJEmSlDGqzWCWUspTOpIkSZIkSZKkhFhgliRJkiRJkiQlxAKzJEmSJEmSJCkhZjBLkiRJkiQpIwQBVAVmMEupZIFZkiRJkiRJGaM68IJ9KZV8x0mSJEmSJEmSEmIHsyRJkiRJkjJCQIxqIzKklLLALEmSJEmSpIxRjQVmKZWMyJAkSZIkSZIkJcQOZkmSJEmSJGWEAIzIkFLMArMkSZIkSZIyRnXgBftSKvmOkyRJkiRJkiQlxA5mSZIkSZIkZYYgZkSGlGIWmCVJkiRJkpQRAqAaC8xSKhmRIUmSJEmSJElKiB3MkiRJkiRJyhhGZEipZYFZkiRJkiRJGSHAArOUakZkSJIkSZIkSZISYgezJEmSJEmSMoYdzFJqWWCWJEmSJElSRgiIWWCWUsyIDEmSJEmSJElSQiwwS5IkSXXEmDFjaN68Oc2bN+fEE09M93AkSTooqokl9Z+kPbPALEmSJNURo0ePZtmyZSxbtizdQ5Ek6eAI4hnMyfwnac8sMEuSJEmSJEmSEuIkfxJQXl7OyJEjAXjvvfeoVy9+7qW0tJQJEyYAsHnzZgCGDh3K+vXrAcjPz+e3v/0tADk5OQRBAMCECRNYunQpAA0aNGDu3LkAdOrUKSXHI0mSVJtu3bpFn2MkScpEAdh1LKWYBWYJyM7O5tZbbwXiReCtW7cC0LlzZ3r16gUQFYl79OjBlClTAJgxYwYzZswA4Oabb+bRRx8FoKysjLKyMgBWrVrFpZdeGt2XJEmSJEkHjwVmKbWMyJAkSZIkSZIkJcQOZglo2bIlLVu2jL4+6qijAGjfvj2VlZUALF68GICnnnoqWm/UqFF0794diHcwh+uMHDmSWCx+xvS0005jy5YtALz77rs1nkeSJOlQMWfOnBq3ANuq/pWu4UiSJOkrwgKzVIswm/DFF1+kS5cuALz//vsANQrELVu25IMPPoi+DovReXl5NfaXm5sbPW6BWZIkHYpKS0tr3AI0qn9suoYjSVKtAmJGZEgpZkSGJEmSJEmSJCkhdjBLX/LJJ58wePBgAGbNmsXRRx+9z9sGQbDHx8PYjNrUdtnpxo0b9/m5JUmSJEkSBHYwSyllgVn6P9u3bwdg8ODBXHjhhQCcd9550eMtWrQAauYov/vuuzRv3jxaJ4zCKC8vr7HviooKAFq1arXb56/tstPCwsLEDkaSJKkWw4YNi+aT2LRpU/TZZdq0aYwdOzaNI5MkKXmqscAspZIRGZIkSZIkSZKkhNjBLBGPtgi7dtq3b8/EiRN3Wae4uBiAe+65hylTpkT3Bw4cuMs6s2fPpqSkBIBVq1bRqFEjACf4kyRJaTV//vx0D0GSpIMqCHCSPynFLDBLwLPPPst9990HwEknncQpp5wSPTZ9+nSAqKg8ZMgQ7r77bgDatGnDwoULo3X79+8PwNKlSykoKACgQYMG/PrXvz74ByFJkiRJksxgllLMiAxJkiRJkiRJUkLsYJaAM844gyAI9mndxx9/fLePxWLxs6R33HFHUsYlSZIkSZL2R8yIDCnFLDBLkiRJkiQpYxiRIaWWERmSJEmSJEmSpITYwSxJkiRJkqSMEIARGVKKWWCWJEmSJElSZghgH6dYkpQkRmRIkiRJkiRJkhJiB7MkSZIkSZIyRjXJjcgwcEPaMwvMkiRJkiRJyggBECQ5g9kCs7RnRmRIkiRJkiRJkhJiB7MkSZIkSZIyRIzqJHcw250p7ZkFZkmSJEmSJGWMIEj3CKS6xZMwkiRJkiRJkqSE2MEsSZIkSZKkjJHsSf4k7ZkFZkmSJEmSJGWEILDALKWaERmSJEmSJEmSpITYwSxJkiRJkqSMUW0Hs5RSdjBLkiRJkiQpY8RjMpL3b38tW7aMZcuW0a5dOwoKCigoKGDGjBm7XX/lypWsXLmSTp06kZ2dTXZ2NosWLap13Q0bNtC7d2969+5N+/bt6dChAx06dGD9+vX7P1ApSSwwS5IkSZIkSZISYkSGJEmSJEmSlARVVVWMGzcOgOXLl5ObmwtAUVERxcXFAHTo0KHGNm3atAFg7ty5zJw5c4/7HzlyJFdffTUAvXr14pNPPgGgXj17SJU+/vRJkiRJkiRJkhJiB7MkSZIkSZIyRpDGSf5Wr15NQUEBAG3bto2Wl5SUsHjxYmDXDub8/Pzo/u46kV977TUAduzYQa9evaLlDRs2TMq4pQNhgVmSJEmSJEkZISCW1gJzZWUleXl5uyzPzc1l1apVCe/3jTfeAKBx48acd955AKxbt46ePXsCMGPGDLKyshLev3QgjMiQJEmSJEmSJCXEDmZJkiRJkiRljCDJ+9u4cSOFhYW7LC8tLa1xCxAEu3/2WCzxzuodO3YA8PTTT/Piiy8C8ckBhw4dCsQnCBw7dmzC+5cOhAVmSZIkSZIkZYYg+RnMzZo1Y+3atfu0bm5uLuXl5bssr6iooFWrVgmPITc3F4BvfvObNbKdzz33XACef/55C8xKGyMyJEmSJEmSJEkJsYNZkiRJkiRJmSPZGRn7oaioiLKyMiA+CV/r1q0BWLBgAfPmzTug/QJ8+OGHbNy4EYh3Vj/xxBMAtUZ4SKligVmSJEmSJEkZI9kRGfsjOzub2bNnA9CnTx+qqqoAGDNmDB07dgTg2muvjQrCxcXFrFmzBoBBgwbx4YcfArBkyRKmTp0KwKuvvkpWVhYAM2fOpEePHkA877lz584AXHzxxak4PKlWRmRIkiRJkiRJkhJiB7P0FVZVBVu2VKd7GBI5OVl8+GFVuochRXJystI9hIwRdr1IkiRliiCNERkA/fv3r3H7Zddff32Nr8P4i4qKir3uu1evXrz88ssHOEIpuSwwS19hWVnQuLEXGuirwZ9FfdUE6f7LIUOY16cDUX14Np/n5aR7GIesz3L83XogPv73dI/g0BRr+1m6h3DIG3KCxb1E3Nfw05Q8T0B6IzKkushPNJIkSZIkSZKkhNjBLEmSJEmSpMwQAHYwSyllgVmSJEmSJEkZwyQ1KbWMyJAkSZIkSZIkJcQOZkmSJEmSJGUOO5illLLALEmSJEmSpAwRIzCDWUopIzIkSZIkSZIkSQmxg1mSJEmSJEmZw4gMKaUsMEuSJEmSJCkzBBiRIaWYERmSJEmSJEmSpITYwSxJkiRJkqTMYUSGlFIWmCVJkiRJkpRBjMiQUsmIDEmSJEmSJElSQiwwS5IkSZIkSZISYkSGJEmSJEmSMocZzFJK2cEsSZIkSZIkSUqIHcySJEmSJEnKHHYwSyllgVmSJEmSJEmZIQCCWLpHIdUpRmRIkiRJkiRJkhJiB7MkSZIkSZIyRmBEhpRSFpglSZIkSZKUOSwwSyllRIYkSZIkSZIkKSF2MEvAZ599Rrdu3QD4/PPP2bFjBwDnn38+06ZNA2DdunUAlJSUsHnzZgA6derEfffdB8Dhhx/O559/DsDIkSN54YUXAGjSpAkPPPAAAPn5+ak5IEmSJEmS6ion+ZNSygKzBBxxxBE88cQTADRs2JDt27cDcMYZZ9CvXz8AbrvtNgCuuOIKSkpKALjkkku4++67Abj00kuj+zk5Obz55psALFiwgMmTJwNEhWZJkiRJknRwxIzIkFLKiAxJkiRJkiRJUkLsYJaAWCxGw4YNo6/DDubt27cTi8UvrQk7nOfNmxetN2rUKK677jog3sG8ePFigGgZxGM2LrvsMgCCIIj2J0mSJEmSkizASf6kFLPALP2fqqoqADp37hzFW4wbN45///d/B6Bx48YAZGd/8bbJzc2lsrIy+jq8n5eXFy3Lzs6mUaNGAPzv//4vTZs2PYhHIUmSJElSXRYzg1lKMSMyJEmSJEmSJEkJsYNZ+j9ZWVkAvPTSS2zZsgWAQYMG8frrr+9xu50jL4Jgz9fh7CkeY86cOTVuATZu3LjnQUuSJEmSpJqMyJBSygKzVIswDqN79+48//zzAFHReceOHVFMRkVFBa1atYq2y83NBaC8vDy6v2PHDj766CMAjjnmmN0+Z2lpaY1bgMLCwqQcjyRJkiRJdYYFZimljMiQJEmSJEmSJCXEDmaJeBTFYYcdBsS7l//1r38B8NhjjzF58mQAzjrrLAAWLVpESUkJAPfccw8DBw6M9lNcXBwt79q1a7T+2WefDew5IkOSJEmSJCWBHcxSSllgloB3332XUaNGAVBVVUV1dTUAQ4YMYcCAAQB06NABgJKSEn70ox8B8M1vfpOxY8dG+wnvjxgxgoKCAiAei7FgwYLUHIgkSZIkSXVZAAQ2d0mpZESGJEmSJEmSJCkhdjBLwDe+8Q1efPHFPa7Ttm1bAFavXr3bderXrw/AwoULkzc4SZKkJCkvL2fkyJEAvPfee9SrF+83KS0tZcKECekcmiRJSRMzIkNKKQvMkiRJUh2RnZ3NrbfeCkCnTp3YunUrAJ07d6ZXr17AF7FgkiQdsiwwSyllRIYkSZIkSZIkKSF2MEuSJEl1RMuWLWnZsmX09VFHHQVA+/btqaysBOxgliRJ0v6xwCxJkiTVUevXrwfgxRdfpEuXLukdjCRJkg5JRmRIkiRJkiRJkhJiB7MkSZJUB33yyScMHjwYgFmzZnH00Ufvcf05c+bUuAXYvv2fB2+AkiQlKOYkf1JKWWCWJEmS6pDt27cDMHjwYC688EIAzjvvvL1uV1paWuMW4Kijcw/CCCVJOkBBLN0jkOoUIzIkSZIkSZIkSQmxg1mSJEmqI4IgYOzYsQC0b9+eiRMnpnlEkiQlWfB//ySljB3MkiRJkiRJkqSE2MEsSZIk1RHPPvss9913HwAnnXQSp5xySvTY9OnTAejfv39axiZJUtLYwSyllAVmSZIkqY4444wzCAL/6pYkZbaYv+qklDIiQ5IkSZIkSZKUEDuYJUn6/+3df4yV9Zk//PeRqWx5tIooCgw8hE4WxdpVmHnUjeuymqqlzShbqtNfaq1BjSTadrOycWtrv0nFLmtqSncbs1aMPxaVJ1kqRbaW1tBluyBW29W4BgO2wFIcRUq1ojJzvn+Mc9fhV+FmOGfmzOuVTM597rnPfa7Ph3PODNdc9/UBAAAahwpmqCkJZgAAAAAahwQz1JQWGQAAAAAAlKKCGQAAAICGUKla5A9qTYIZAAAAgMZRrdQ7AhhStMgAAAAAAKAUFcwAAAAANA4tMqCmJJgBAAAAaBh6MENtaZEBAAAAAEApKpgBAAAAaBwqmKGmJJgBAAAAaAxVLTKg1rTIAAAAAACgFAlmAAAAABpHtZ+/DtLy5cuzfPnyTJ48OS0tLWlpacm8efP2efzKlSuzcuXKTJ06NU1NTWlqasrixYv3euywYcNy+umnF1/t7e1pb28/+CChH2mRAQAAAEDjqGOLjK6urlx//fVJkscffzzNzc1Jkra2tiIRPGXKlD6PmTBhQpJk4cKFmT9//n7P//73vz/PPPNMf4cNh0QFMwAAAAAApahgBgAAAKBh1HORvzVr1qSlpSVJMmnSpGJ/R0dHlixZkmTPCuaJEycW20ccoRaUwUeCGQAAAAD6webNmzN+/Pg99jc3N2f16tWHfP6dO3emtbU1SdLU1JS5c+cmSS655JJDPjeU5c8iAAAAAACUooIZAAAAAPahs7OzqBp+r9mzZ/e5TZJqdd/9OSqVyiHH8utf/zpjx45Nkqxfvz7nnXdekuS0007LBz/4wUM+P5QhwQwAAABA4+jnHswnnHBC1q5de0DHNjc3Z+PGjXvs37RpU5EYPhTvPcekSZMyffr0JMnTTz8twUzdaJEBAAAAAEApKpgBAAAAaAzVpNLPFcwHo62tLevWrUuSbNiwIePGjUuSLFq0KA8++GDp87722mtJkhEjRmT48OFJkldeeSWrVq1Kkvzt3/7toYQNh0SCGQAAAIDGUccEc1NTUxYsWJAkufDCC9PV1ZUkueqqq3LqqacmSW655Zaip3N7e3uefPLJJMnMmTOLRPKjjz6ar371q0mS5557Ls8//3yS5JprrskRR/Q0JOju7s7cuXOTJFOmTKnF8GCvtMgAAAAAAKAUFcwAAAAANI46VjAnyYwZM/rc7u7rX/96n/ttbW1JehYC3Jc///M/T5L893//d3+ECP1KghkAAACAhlBJfXsww1CkRQYAAAAAAKWoYAYAAACgcahghpqSYAYAAACgMVS1yIBa0yIDAAAAAIBSVDADAAAA0DhUMENNSTADAAClVN9XyZuj31fvMAatbX/xVr1DGNT+dPzWeocwKF0w+vl6hzDofem49fUOYVD6SdPva/dkEsxQU1pkAAAAAABQigpmAGDQee21rnqHAADAAGWRP6gtCWYAAAAAGocEM9SUFhkAAAAAAJSighkAAACAxlCNCmaoMQlm2E1XV1daW1uTJOPGjcvSpUuTJBs2bEiSdHR0ZNu2bUmSqVOn5r777kuSHHnkkXnrrZ6VwC+//PI89dRTSZJRo0bloYceSpJMnDixZuMAAACAoUgPZqgtLTIAAAAAAChFBTPs5s4778wpp5ySJNmxY0ex/6abbkqSfPGLX0xHR0eS5Nprr83dd9+dJLnuuuuK7ZEjR+bFF19MkixatKh4bG8lMwAAAHCYqGCGmpJghndt2rQpSfKDH/wgN998c5LkjjvuSLXa85Ppxz/+cZLkwQcfLB5zxRVX5Gtf+1qSngTzkiVLkqTYlySzZs3KnDlzkiTVajWVSuWwjgMAAACGMi0yoLa0yAAAAAAAoBQVzPCuG2+8MUnyzW9+M7/73e+K/a+++mqS5Nhjj02SNDX94W3T3NyczZs3F/d7t8ePH1/sa2pqyjHHHFOc6/jjjz9MIwAAAACA2pJghiRLly7N6NGjkyTTpk3LE088UXyvt0XGvry35cXBHLu7u+66q89tknR2du73fAAAAMButMiAmtIiAwAAAACAUlQwQ5JVq1bl+9//fpJk2bJl2blzZ5Jkx44dReuM7du3J0l27dpVtMnYtGlTxo4dW5ynubk5SbJx48Zie9euXfntb3+bJDnuuOP2GcPs2bP73CZJa2vroQ8OAAAAhopqVDBDjUkwQ5Lbbrstt912W3G/t0XG/Pnz88ADDyRJPvnJTyZJFi9enI6OjiTJvffem4svvrh4XHt7e7H/7LPPLo4/77zzkuy/RQYAAABwaCrvfgG1o0UGAAAAAAClqGCGA3T77bcnSTo6OvL3f//3SZIzzjgjX/jCF4pjerc/97nPpaWlJUlPW4xFixbVOFoAAAAYorTIgJpSwQwAAAAAQCkqmGEvpk+f3uc2SSZNmpQkWbNmzT4f9yd/8idJkkceeeSwxQYAAADsW0UFM9SUBDMAAAAAjUOCGWpKiwwAAAAAAEpRwQwAAABA41DBDDUlwQwAAABAY6jqwQy1pkUGAAAAAAClqGAGAAAAoHGoYIaakmAGAAAAoGFokQG1pUUGAAAAAAClqGAGAAAAoHGoYIaakmAGAAAAoGFokQG1pUUGAAAAAAClqGAGAAAAoDFUo0UG1JgEMwAAAACNQ4IZakqLDAAAAAAASlHBDAAAAEBDqMQif1BrEswAADBE7Ny5M+eee26S5K233squXbuSJLNmzcqtt95az9AAoP9IMENNaZEBAAAAAEApKpgBAGCIGD58eH784x8nSY466qi88847SZJzzjknH/3oR5MkZ511Vt3iA4D+UKkqYYZakmAGAIAholKp5Kijjiru9yaY33nnnVQqlXqFBQDAIKZFBgAAAAAApahgBgCAIaSrqytJMm3atLz44otJkuuvvz5nnnlmPcMCgP5RjUX+oMYkmAEAYAgZNmxYkuSZZ57J9u3bkyQzZ87Ms88+myT50Ic+tNfH3XXXXX1uk+SdnW8czlABoJRKPyeY5ath/7TIAAAAAACgFBXMAAAwRB177LFJkunTp2f58uVJ9l3BPHv27D63SXLUqPGHOUIAKEHJMdSUCmYAABgiOjs7s3379qI1xptvvpk333wzP/rRj3LyySfn5JNPrnOEAHDoKtX+/QL2T4IZAAAAAIBStMgAAIAhYsuWLbniiiuSJF1dXenu7k6SXHrppfn4xz9e/9M5wQAAHoxJREFUz9AAoP+oOoaakmAGAIAh4sMf/nCefvrpeocBAIePthZQc1pkAAAAAABQigpmAAAAABqHCmaoKQlmAAAAABpCJVpkQK1pkQEAAAAAQCkqmAEAAABoHFUlzFBLKpgBAAAAaBiVav9+Hazly5dn+fLlmTx5clpaWtLS0pJ58+bt8/iVK1dm5cqVmTp1apqamtLU1JTFixfv8/gdO3Zkx44dGTduXObMmZM5c+YcfJDQjySYAQAAAAAoRYsMAAAAABpD9d2vOunq6sr111+fJHn88cfT3NycJGlra0t7e3uSZMqUKX0eM2HChCTJwoULM3/+/D/6HF/5yleSJH/5l3/Zb3HDoZBgBgAAAKBhVLrr99xr1qxJS0tLkmTSpEnF/o6OjixZsiTJngnmiRMnFttHHLH/ZgNPPfVUtm7dmiS56KKLsnbt2v4IGw6JFhkAAAAAAJSighkAAACAxlHHFhmbN2/O+PHj99jf3Nyc1atXlz5vd3dPWfaXv/zl3HfffUmSFStWlD4f9CcJZgAAAAAaRqWfE8ydnZ1pbW3dY//s2bP73CZJtbrvJ69UKqVj+Kd/+qckyYwZM/aawIZ60iIDAAAAAIBSVDADAAAA0BiqSfZTRVzGCSeccMCL6TU3N2fjxo177N+0aVPGjh1bOoaf/exnSZKf/vSnRTXz66+/nrfffjtJctRRR2XevHmlzw+HQoIZAAAAgIbR3y0yDkZbW1vWrVuXJNmwYUPGjRuXJFm0aFEefPDB0ud94IEH9ti3cOHCIvEtuUw9aZEBAAAAAEApKpgBAAAAoB80NTVlwYIFSZILL7wwXV1dSZKrrroqp556apLklltuKRYNbG9vz5NPPpkkmTlzZl577bUkyaOPPpqvfvWrSZLnnnuupmOAgyXBDAAAAEDjqGOLjCSZMWNGn9vdff3rX+9zv62tLUlPn+aDceWVV+bKK688+AChn2mRAQAAAABAKSqYAQAAAGgIldR3kT8YiiSYAQAAAGgM1WrPF1AzWmQAAAAAAFCKCmYAAAAAGoYWGVBbEszwrokTJyZJjj766AwbNixJ0tTUlLVr1yZJtm3bliS57LLL8tJLLxWPefjhh5MkI0eOTPXdy3BuuOGGLFu2LEkyYsSILFy4MEkyderUWgwFAAAAhi4JZqgpLTIAAAAAAChFBTPs5ic/+UmOP/74PfbPmzcvSXL++edn7ty5xb7e/bfffnsee+yxJMm6deuybt26JMnq1atz3XXXFdsAAADA4aNFBtSWCmYAAAAAAEpRwQwHaMmSJUmSJ554oth3xRVXZPr06Ul6Kph7j7n88stTqVSSJGeddVa2b9+eJNmyZUvGjBlTu6ABAABgKKkm6VbCDLUkwQzv6k0IX3DBBcX2Nddck9mzZydJtm7dmiR9EsRjxozJyy+/XNzfvHlzkmT8+PF9zt3c3Fx8X4IZAAAADiP5ZagpLTIAAAAAAChFBTO8a9WqVUmSsWPHFlXJH/nIR3LyyScf8Dmq1f3/mbS3Mnpv7rrrrj63SdLZ2XnAzw0AAABY5A9qTYIZ3jV27Nhie/To0UmSmTNnZs2aNUmSE088MUnfPspbtmwpjk3+0Apj48aNfc69adOmPZ5jd72tOHpvk6S1tbXcYAAAAGCo+iPFX0D/0iIDAAAAAIBSVDBDkjfeeCPd3d1JkqOPPjpvvPFGkuSHP/xhbrnlliRJe3t7kuTee+/N3Llzi+2LL764OE/vMQsWLEhHR0eSZPXq1TnmmGOSxAJ/AEBD6WpK3jhJzUpZw7YMr3cIg9q5Z7xY7xAGpY8e9Wy9Qxj0Vrx5dL1DGJR2dNfuubTIgNqSYIYkW7duzcyZM4v7u3btSpJ8+tOfzkUXXZQkaWtrS5Jceumlufvuu5MkEyZMyCOPPFI8bsaMGUmSZcuWpaWlJUkyYsSI3HPPPYd/EAAAADDUVd/9AmpGuQEAAAAAAKWoYIYkkyZNyi9+8Yv9HjNq1KgkyYoVK/Z5TKVSSZJ85zvf6Ze4nnrqqeKcUG/bt9fwmrYGNnLksHqH0DBee62r3iEAADDAVJJULPIHNSXBDAPYtGnTsnbt2nqHAdm+vTvHHuuil/5Q9ctuv9i+vTv/f8voeofRGCZOrHcEAAD9S20M1JRsAQAAAAAApahgBgAAAKBhaJEBtSXBDAAAAEBjqL77BdSMFhkAAAAAAJQiwQwAAAAAQClaZAAAAADQIKqJHsxQUyqYAQAAAAAoRQUzAAAAAA2jooAZakqCGQAAAIDGoUUG1JQWGQAAAAAAlKKCGQAAAIDGUE0q3fUOAoYWCWYAAAAAGocWGVBTWmQAAAAAAFCKCmYAAAAAGocCZqgpCWYAAAAAGkZFiwyoKS0yAAAAAAAoRQUzAAAAAI1DBTPUlAQzAAAAAI2hmqS73kHA0KJFBgAAAAAApahgBgAAAKAhVFK1yB/UmAQzAAAAAI1DghlqSosMAAAAAABKUcEMANCPrn71/+yx719GfaUOkQAADFH9XcFc6d/TQaORYAYAOAR7Syj/sWMknAEADpNqku5+Puewfj4fNBgtMgAAAAAAKEUFMwDAQTqQquUDfbxqZgCA/lWxyB/UlAQzAMABOtTE8v7OKdEMANBPJJihprTIAAAAAACgFBXMAAB/xOGoXN7bc6hiBgA4VFUVzFBjEswAAPtRi+Ty7s8l0UwtdHV1pbW1NUkybty4LF26tM4RAQAwGGmRAQAAAABAKSqYAQBgCLrzzjtzyimnJEl27NhR52gAoJ9Uo0UG1JgEMwDAXtSyNcbenlubDA6XTZs2JUl+8IMf5Oabb06S3HHHHfUMCQD6V3e9A4ChRYsMAAAAAABKUcEMAABDyI033pgk+eY3v5nf/e53dY4GAPpfRYsMqCkJZgAAGCKWLl2a0aNHJ0mmTZuWJ5544oAfe9ddd/W5TZKuN9/o1/gAoF9IMENNaZEBAAAAAEApKpgBAHZTzwX+4HBatWpVvv/97ydJli1blp07dyZJduzYkc9+9rNJkvvvv3+vj509e3af2yR5/4njD2e4AHDwqkm6VTBDLUkwAwDAEHHbbbfltttuK+73tsiYP3/+PhPLADC4VLXIgBrTIgMAAAAAgFIkmAEAAABoHNVq/34dpOXLl2f58uWZPHlyWlpa0tLSknnz5u3z+JUrV2blypWZOnVqmpqa0tTUlMWLF/c55le/+lV+9atfZdq0aTn99NNz+umn59RTT813v/vdfPe73z3oGKE/STADAAAAAFCKHswAALv5l1FfsdAfQ8L06dP73AJAQ6hjD+aurq5cf/31SZLHH388zc3NSZK2tra0t7cnSaZMmdLnMRMmTEiSLFy4MPPnz9/receMGZMk+c///M8MHz48SfL666/nQx/6UJKkvb09Y8eO7efRwIGRYAYAAACgMVSTdNcvwbxmzZq0tLQkSSZNmlTs7+joyJIlS5LsmWCeOHFisX3EEXtvNnDkkUfuse+tt95Kd3f3oYYMh0yLDAAAAAAASlHBDAAAAECDqCbV+lX1bt68OePHj99jf3Nzc1avXn3I59+4cWM+9rGPJUlefPHF/MM//EOSaI9BXUkwAwDsxb+M+kqS1KUXc+9zAwBQQj/3YO7s7Exra+se+2fPnt3ntuep9/3clUrlkGMZP358fvnLXyZJ/vd//zeXXHJJkmTWrFk58cQTD/n8UIYWGQAAAAAAlKKCGQBggFC5DABwiA7DIn8njD4ha9euPaBjm5ubs3Hjxj32b9q0qd/bWIwdOzannnpqkuSnP/1pZs2a1a/nhwMlwQzv2r59e5Lk6quvzrPPPpuk5/KV733ve0mSyZMnJ0kuu+yyvPTSS0l6Vnp9+OGHkyQjR44sLoW54YYbsmzZsiTJiBEjsnDhwiTJ1KlTazIWAPrPv4z6Sl3aZAAAUFI/t8g4GG1tbVm3bl2SZMOGDRk3blySZNGiRXnwwQdLn3fTpk1JklGjRuX9739/kuS1117LqlWrkiRf+tKXDiVsOCRaZAAAAAAAUIoKZnjXDTfckCS56KKLsnjx4iTJ22+/nd///vdJkm984xtJkvPPPz9z585NksybNy/z5s1Lktx+++157LHHkiTr1q0r/mK5evXqXHfddcU2AINPLRb80x4DAKCf1LGCuampKQsWLEiSXHjhhenq6kqSXHXVVUU7i1tuuaVYNLC9vT1PPvlkkmTmzJl57bXXkiSPPvpovvrVryZJnnvuuTz//PNJki9/+cvFYoHVajV/8zd/kyQ57bTTajE82CsJZkiyY8eOrFy5MkmKdhZJcuSRR+bII49MkixZsiRJ8sQTTxTfv+KKKzJ9+vQkPQnm3mMuv/zy4gP/rLPOKtpvbNmyJWPGjDmcQwHgMOrvRLOkMgBAf6vWNcGcJDNmzOhzu7uvf/3rfe63tbUl+UMbjL35yEc+kiT55S9/2R8hQr/SIgMAAAAAgFJUMEOS9evX54QTTkiSfP7zn88vfvGLJMm0adNy5513Jkm2bt2aJH0qkMeMGZOXX365uL958+Ykyfjx4/ucv7m5ufi+CmaAwe+9lcdlqplVLgMAHCbVJN3d9Y4ChhQJZkiya9eu/PznP0+SfPvb386ZZ56ZpKcvc2+P5QNR/SOX4fS2zdibu+66q89tknR2dh7wcwNQH5LFAADAUKZFBgAAAAAApahghvS0sOhtY9FbvZwks2bNKiqYTzzxxCR9F+rbsmVLRo8e3ec8SbJx48Y+5+9t1D927Nh9xjB79uw+t0mKVWUBAACAA1TnRf5gqJFghiQnnXRS0Tf5hRdeyOTJk5MkK1asyJQpU5KkuL333nszd+7cYvviiy8uztPe3p4kWbBgQTo6OpIkq1evzjHHHJMk+i8DAADA4SbBDDWlRQYAAAAAAKWoYIZ3ffvb306SfOYzn8nbb7+dJJk0aVLuueeeJEn3u6vQXnrppbn77ruTJBMmTMgjjzxSnGPGjBlJkmXLlqWlpSVJMmLEiOIcAAAAwOFUTbpVMEMtSTDDu04//fQkydq1a/d73IoVK/b5vUqlkiT5zne+03+BAQAAAAemmlSr3fWOAoYULTIAAAAAAChFBTMAAAAAjUOLDKgpCWYAAAAAGkdVghlqSYsMAAAAAABKUcEMAAAAQGOoVpNui/xBLUkwAwAAANA4tMiAmtIiAwAAAACAUlQwAwAAANAwqlpkQE1JMAMAAADQIKpaZECNaZEBAAAAAEApKpgBAAAAaAzVJN0qmKGWJJgBAAAAaBxVPZihlrTIAAAAAACgFBXMAABAKf9P15sZvvKBeoexV52dnTnhhBPqHcZ+Da93APsxGObv3x6udwT71tnZmSQDcg7/LWPqHcJ+DYbX3kA2kOdv25ajavI81SRVLTKgpiSYAQCAUl555ZV6h7BPra2tWbt2bb3DGLTM36FpbW1NEnNYgtfeoTF/SapVLTKgxrTIAAAAAACgFBXMAAAAADQMLTKgtiSYAQAAAGgcWmRATWmRAQAAAABAKSqYYQD7n//5n2KBkKFqIK+CfLgN5NXHa2Woz8FQfv332u8cTJxY01hqrVav/5deeumwnh/qZfbs2fUOYVAzf4fG/JVn7g6N+Uv+/ML/L6+8sqFfz3n88cf36/mg0VSq1QPvS9Pa2lod8quRQg1ZAXhoz4HVx83BUH799xrKczDUX/8AAMDAUqlUnqpWq3tUQmqRAQAAAABAKRLMAAAAAACUogczAADQMJYvX54kueGGG9LV1ZUkufrqqzN37tx6hjUoXHXVVVm6dGmSZPTo0Xn22WfrHNHgsXHjxlx++eVJkt/85jc54oieWq7Zs2fnhhtuqGdog8LOnTtz7rnnJkneeuut7Nq1K0kya9as3HrrrfUMbdDo/bxrbW3NuHHjkqR4PwMcbiqYAQAAAAAoRQUzDGBWAB7aczCUx95rqM/BUB9/MrTnYCiPHcrq6urK9ddfnyR5/PHH09zcnCRpa2tLe3t7kmTKlCl1i2+gu/LKKzNnzpwkKapxOTBNTU35x3/8xyTJ1KlT87vf/S5JMm3atHzkIx9J4rW3P8OHD8+Pf/zjJMlRRx2Vd955J0lyzjnn5KMf/WiS5KyzzqpbfIPBnXfemSQ55ZRTsmPHjjpHAww1EswwgEkuDO05GMpj7zXU52Cojz8Z2nMwlMcOZa1ZsyYtLS1JkkmTJhX7Ozo6smTJkiSSfPtz7rnn5qWXXqp3GIPSmDFjMmbMmOL+0UcfnaQn2bd58+YkXnv7U6lUctRRRxX3exPM77zzTiqVSr3CGjQ2bdqUH/zgB0mSm2++OXfccUedIwKGGi0yAAAAAAAoRQUzAADQEDZv3pzx48fvsb+5uTmrV6+uQ0QMVb2V4E8//XTOPPPM+gYzSPQuUjdt2rS8+OKLSZLrr7/e/B2AG2+8Md/85jeTpGjPAlBLEswwADXi6udXXXVVkp6VjEePHp0kfVYm37ZtWy677LIkPb+QT5w4MUny8MMPZ+TIkUmSarVarMK9bNmyjBgxIkmycOHCTJ06tSbjKOtAVhZv9Dk4kNXBN2zYkI6OjiQ989E7pvvuuy9HHnlk8djeuXzqqacyatSoJMlDDz1UzNlAtq8Vvjds2JCk5zLubdu2Jenp4XjfffclSY488si89dZbSXr6Yj711FNJklGjRuWhhx5KkkEx/okTJxaXDQ8bNixNTT2/iqxdu7YY92WXXVb8x3zixIl5+OGHkyQjR45MtVpN0vP5uGzZsiTJiBEjsnDhwiQZ0O+D7du3J+n5PO/9/KtUKvne976XJJk8eXJDfwZALfR+RuyNy+yplddffz2f+MQnkiTf+ta38oEPfKDOEQ0Ow4YNS5I888wzxc/MmTNnFj8zP/ShD9UttoFq6dKlSZLRo0dn2rRpSZInnniijhEBQ5UWGQAAAAAAlKKCGQaYRl39/Morr0ySzJkzZ6+rks+bNy/nn39+kmTu3LmZN29esf/2229Pkjz22GNZt25dkmTdunXFpa7XXXfdgL/s9UBWFl+4cGFDz8GBrA5+xx135Itf/GKSnkrea6+9Nkly991357rrriu2e6s5X3zxxSxatChJctNNNxWVvAPZvlb4vummm5IkX/ziF4sq7muvvTZ33313kp5/497tkSNHFpeOLlq0qHjsYBh/kvzkJz9Jkhx//PF99ve+5s8///ziio158+YV+2+//fY89thjSXpe/73vhdWrVxevj4H8PuitPL7ooouyePHiJMnbb7+d3//+90mSb3zjGw39GQC10NzcnI0bN+6xf9OmTRk7dmwdImIo6f3d5hOf+EQ+85nPJEn++q//up4hDVrHHntskmT69OnF1Z0qmPe0atWqJMn3v//94squnTt3Fr9jfvazn839999ft/iAoaOyv8vIdtfa2lpdu3btYQwH+NnPfpavfe1rSZJ///d/L/bfdtttxfbf/d3f1TqsfvPSSy/l4x//eJK+LTImT55cXM41ZsyYbNmyJUnPL5UvvPBCkuSaa67J9OnTkySf+tSn9vnYweTiiy/OnDlzkvQk34fSHPQm1c4555z88z//c5LkYx/7WH7zm98k6UnK/+xnP0uSfO1rXyveDxdeeGHxHjn77LOLVhsnnXRSOjs7kwzcy6A3bdqUK664IknfFb4fffTRnHDCCUl6Wqj0to3Y/fPgwgsvTNIzH2effXaSZNeuXTnppJOSJJ2dnQN27L0mTpyY3t8ldk8wT548OUnPpZ29r+MtW7YUr/kXXngh11xzTZKe98Xu74HdHzuQ7NixI3/2Z3+WJFm/fv1e/52G6ucg9Kddu3blT//0T5MkK1asKFoRtbW15cEHH0ySnHrqqXWLbzDobVH08Y9/vM/vauxftVotfsYfd9xx+da3vlXniAaXzs7OvO9970vSk1x+8803kyQXXHBB8Yf03v9DsH9PPPFE5s+fn+QPLTQA+kulUnmqWq227r5fiwwAAAAAAErRIgMGmKG6+vnWrVv7VN31br/88svFvv3NzebNm/s8bqDb28riQ2EO9rU6+Ac/+MEkPRUrvdW7SYoWMb1j691+7xz0Hn/MMcfk1VdfTbJnZexAsa8Vvl999dXiUtDdx7/72JPsMf5jjjmmOM9AHXuvSqWSCy64oNjurUiePXt2tm7dmiR7vA92fw8k2eN98N7XykB8D6xfv76oUv/85z+fX/ziF0l63gu9bVOGwmcAHG5NTU1ZsGBBkp4rXnp/7lx11VUqlw/Apz71qeJqiFdeeaX4bL311lvzhS98oY6RDXyrVq0qFuY97bTTcvrppxff+8Y3vpEkmTFjRl1iGwy2bNlSVIB3dXWlu7s7SXLppZeqXAYYBFQwAwAAAABQigpmGGD21xd9oPdWPdwaZW5ef/31fOITn0iSfOtb38oHPvCBA37sYJ+DYcOGJUmeeeaZbN++PUkyc+bMPP/88/t93HvHNhjnoLf/3ejRozNt2rQkKSrEkgMf0x9bN2Ggjv+9Vq1aVSy09fLLLxeLXJ588skH9PjBOge7du3Kz3/+8yTJt7/97eLKhRtuuKFYzO9ADMbXP9Rab5WoatGD96//+q/1DmHQOuecc/7ozyj27cMf/nCefvrpeofREKZPn16s1wBQKxLMMMAM1dXPTzzxxGJBq/cubjV69OjimME+N39sZfGhMAfv9d7Vwf/rv/4rSbJ9+/Zi0b6mpqZs2rQpSfqM7b1z0NzcXBz/29/+Nscdd1zN4j8Yf2yF7xtvvLFIuO/atatok7H7v2vvpcobN24stnft2pXf/va3STJgx/9e7x3P6NGjM3PmzCTJmjVrcuKJJybpuUz2vYv87f4eSLLH+2Bvr5WBpLm5uYi9N7mcJLNmzSoSzEPtMwAAAGgMWmQAAAAAAFCKCmYYYNra2rJu3bokyYYNGzJu3LgkyaJFi/Lggw/WM7TDqr29Pffee2+SZO7cucX2xRdf3OeY3oV7Ojo6ikUPjznmmAG/qFW1Wi0WxznllFPypS99aY9jGn0OOjs78773vS9JT/Xym2++mST50Y9+lJtuuilJ8ld/9VdZvHhxkp7x7WsOevefffbZxfHnnXfegG0RcNttt/W5TXpaZMyfPz9J8sADD+STn/xkkmTx4sXp6OhIktx77717jL13/9lnn10cf9555yUZ2C0S3njjjSRJd3d3jj766GLfD3/4wyTJLbfc0md8c+fOLbb3NgcLFiwo5mn16tXFQocD9X1w0kknFYvzvfDCC5k8eXKSZMWKFZkyZUqSZMqUKQ39GQAAADSmysH0iWptba2uXbv2MIYDJCkuob/xxhv7rH5+88031zOsQ/KpT30qSU9S7ZVXXknSczn4rbfemiS55JJLcumllyZJfv3rX2fChAlJkkceeaS47L9arWbOnDlJkuXLl2fEiBFJknvuuSetra21G0wJ//Ef/5G/+Iu/SNKzsvgRR/zhApLelcXPPPPMhp6DX/7yl/tcHfyWW25Jkqxfv75IGm7bti1nnHFGkuT+++/P8OHDk/S0lvjc5z6XJHn66aeLuVm0aFEmTZpUuwEdovcmmJcuXZr169cn6Ukabtu2LUlyxhln5P7770+SDB8+PDt37kySfO5znyv6FB533HFZtGhRkgzo8feOr7clRtLT3uPTn/50kuTmm2/Oq6++mqTnNfHrX/86STJhwoQ88sgjSXrG2vt7y5w5c7J8+fIkyYgRI3LPPfckyYB+HzzzzDNJkquvvjpvv/12kp5/s97Yu7u7G/ozAAAAGNwqlcpT1Wp1j/94aJEBAAAAAEApKpgBAAAAANgvFcwAAAAAAPQrCWYAAAAAAEqRYAYAAAAAoBQJZgAAAAAASpFgBgAAAACgFAlmAAAAAABKkWAGAAAAAKAUCWYAAAAAAEqRYAYAAAAAoBQJZgAAAAAASpFgBgAAAACgFAlmAAAAAABKkWAGAAAAAKAUCWYAAAAAAEqRYAYAAAAAoBQJZgAAAAAASpFgBgAAAACgFAlmAAAAAABKkWAGAAAAAKAUCWYAAAAAAEqRYAYAAAAAoBQJZgAAAAAASpFgBgAAAACgFAlmAAAAAABKkWAGAAAAAKAUCWYAAAAAAEqRYAYAAAAAoBQJZgAAAAAASpFgBgAAAACgFAlmAAAAAABKkWAGAAAAAKAUCWYAAAAAAEqRYAYAAAAAoBQJZgAAAAAASpFgBgAAAACgFAlmAAAAAABKkWAGAAAAAKAUCWYAAAAAAEqRYAYAAAAAoBQJZgAAAAAASpFgBgAAAACgFAlmAAAAAABKkWAGAAAAAKAUCWYAAAAAAEqpVKvVAz+4UulM8qvDFw4AAAAAAAPQ/1utVk/YfedBJZgBAAAAAKCXFhkAAAAAAJQiwQwAAAAAQCkSzAAAAAAAlCLBDAAAAABAKRLMAAAAAACUIsEMAAAAAEApEswAAAAAAJQiwQwAAAAAQCkSzAAAAAAAlPJ/AXnqd0HjM7xaAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] + "text/plain": "", + "text/markdown": "

target_copy_over[test]

\n\n> target_copy_over()\n\n
×

No tests found for target_copy_over. To contribute a test please refer to this guide and this discussion.

\n\nUpdates the target network from calls in the FixedTargetDQNTrainer callback. " }, "metadata": {}, "output_type": "display_data" } ], "source": [ - "interp = AgentInterpretationAlpha(learn, base_chart_size=(20, 10))\n", - "interp.plot_heatmapped_episode(-1, return_heat_maps=False)" + "show_doc(FixedTargetDQNModule.target_copy_over)" ] }, { @@ -459,74 +80,91 @@ "execution_count": 4, "metadata": { "pycharm": { - "is_executing": true + "is_executing": false } }, "outputs": [ { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "", + "text/markdown": "

__init__[test]

\n\n> __init__(**`learn`**, **`copy_over_frequency`**=***`3`***)\n\n
×

No tests found for __init__. To contribute a test please refer to this guide and this discussion.

\n\nHandles updating the target model in a fixed target DQN. Args:\n learn: Basic Learner.\n copy_over_frequency: For every N iterations we want to update the target model. " }, "metadata": {}, "output_type": "display_data" - }, + } + ], + "source": [ + "show_doc(FixedTargetDQNTrainer.__init__)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [ { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "", + "text/html": "\n
\n \n \n \n
\n \n" }, "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABZgAAAIyCAYAAABGja/CAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzde7xVdZ038M8BvISkoKKBB0KGNCFHQ/A2RnhBlAyvKaYiiVI+aJjMo/iYmuWjWOZog/kMZaEm0uhMMXihzPLSRQRHs8wZqUQuXklR7KJwzn7+2LOXHLkom8M+ss/7/Xrx2vusvdbav3X2OZy9v+u7Pr+GUqkUAAAAAABYXx3aegAAAAAAAGyaFJgBAAAAAKiKAjMAAAAAAFVRYAYAAAAAoCoKzAAAAAAAVEWBGQAAAACAqnRan5W33377Up8+fTbSUAAAAAAAeC965JFHlpZKpe5vX75eBeY+ffpk3rx5rTcqAAAAAADe8xoaGp5Z03IRGQAAAAAAVEWBGQAAAACAqigwAwAAAABQFQVmAAAAAACqosAMAAAAAEBVFJgBAAAAAKiKAjMAAAAAAFVRYAYAAAAAoCqd2noAAACwoQ4//PCMGjUqSXLqqafW/Pm/9KUv5fe//32S5Hvf+17Nnx8AANqKAjMAADXRp0+fJMkLL7yQjh07rvb4mDFjMmXKlKr2fffdd2/I0DYJ8+fPT5LsvvvuOe6445K0LGaXSqVcfvnlSZJ/+Zd/ybJly5IkI0aMyNSpU5MkW2+9dS2HDABAOyAiAwAAAACAquhgBgCgpmbNmpVDDjmkrYexyRk/fnySZPDgwWt8/KabbsrNN9+cJPnFL36Rbt26JUlOOumknH322UmSG2+8sQYjBQCgPVFgBgDgPWfatGn51re+lSQZOHBgbrrppiRJjx49ct111yVJDj744GL9oUOH5uSTT06SnH766UUe8tixY/PYY48lSTbbbLNim+9///vFtr/85S8zYcKEJMlTTz2VXXbZJUly7bXXZv/99y/We/rpp5OUozyS5D//8z+z7777Jkl23XXXNR7HQw89lHPPPTdJ8rvf/S4f/OAHi30PHTr0XX8/ZsyYka5duyZJ9t9//+L4VjVr1qyMHTs2SdKrV69i+fnnn5+DDjooSXL99denc+fO7/p5AQDgnYjIAAAAAACgKjqYAQB4T5ozZ06S5LjjjsvSpUuTJP/+7/+eY445Jkm5o3jbbbdd47YXXXRRkuTQQw/Nz372syTJm2++mXnz5hXrvPzyy0mST3ziE/nGN76RJDnxxBNz2223FcsrncLbbbddPv3pTydJ9ttvvyTJj3/842KMn/jEJ3LkkUcW+16yZEmxvBJbcdhhh+Xee+9Nkhx77LH5r//6ryRJ9+7d1/o9eO2115IkF198cbHtDTfcsMZ1S6VSSqXSGpe/8cYbScoTBe6xxx5rfT4AAFhfCswAANTUUUcdlU6dVn8b+rWvfS1nnHFG8fUOO+yQJDnnnHPS0NCQJDnhhBPy9a9/PUly55135pRTTlnjc2y22WZJkmeeeSbPPvtskqSxsTEHHHBAsc6dd96ZJPnQhz7UYj8nnnhikuQb3/hGZs2alSQ56KCDMnfu3CTJT37ykyTJFltskSFDhiRJPvnJT7Z4/u9973tJkhEjRmTEiBHF8mHDhiVJBg0alLvuuitJcuqpp67xGJK3CuVjx45tEXuxJocffni++tWvJkmOP/74IoP5yiuvLNb5y1/+ss59AADA+hKRAQAAAABAVXQwAwBQUz/84Q9zyCGHvON6O+20U5IU3csVlYnyKp3Ja1Lp5L3ooouy9957J0m6deuWiRMnJklOO+20YvvK/t7ugx/8YBF18eyzzxYdwVtttdUa1120aFHx9TPPPJMkue2224ou6FWtWLEiBx544FrHnySPPfZY0S396KOPrnPdpHxMlTEMHTo0K1euTJJMnDixGENjY+M77gcAANaHAjMAAO9JleJuqVRqUWReuHBhkmTkyJFr3fYDH/hAkuRb3/pWseznP/95UdgeMmRIevbsmeStYvDbLVy4MIcddliSpEePHnnllVeSJH/+85+TtCw0L1y4sMUYK3EWp5xySosxrI/77rsvCxYsSJL07t27WP7666+nqakpSfK73/0u//mf/5kk6dChQy699NIkKW6TclZ0pVhfuQUAgNYiIgMAAAAAgKroYAYA4D3pxRdfTFKebO9//a//laQcr/Hkk08mSYvJ897utttuS5Lst99+RSxEt27dii7jjh07FtufffbZmT59epLy5Hj/9m//lqTcHXzEEUckSbbffvsMGjQoSXLJJZckSS6//PI8/PDDSZJZs2a16Kg++eSTkySDBw/Oj370oyTJIYcckhUrViRJHnroofTr1y/J2mMrxo0bl1GjRq22/Kqrrio6m6+//vpi+csvv1x0Wfft27f4Pp177rm5+OKLk5S7nAEAoDUpMAMAUFOf/OQn07Fjx9WWDxs2LD/4wQ+Kr/fZZ58kyfz587P99tsnSXbcccfcfvvtSZLtttturc8xd+7cJMk555yTV199tdj22muvTZLsvPPOxbp33HFHJkyYkCQ588wzi8LvHXfcUTxvkqIIfeqppyZJtt122+y3335JktGjR2fZsmXFupWIjJkzZ+a8885Lkpx44onFce+9994tisNr0rlz53Tu3Hm15V26dMmWW26ZJOnevXuxfOnSpfnkJz+ZJFm0aFHx2IQJEzJu3Lh1PhcAAFRLCwMAAAAAAFVpKJVK73rlQYMGlebNm7cRhwMAAMm0adPy7W9/O0l5cj4AAKBtNTQ0PFIqlQa9fbkOZgAAAAAAqqLADAAAAABAVRSYAQAAAACoigxmAAAAAADWSQYzAAAAAACtSoEZAAAAAICqKDADAAAAAFAVBWYAAAAAAKqiwAwAAAAAQFUUmAEAAAAAqIoCMwAAAAAAVVFgBgAAAACgKgrMAAAAAABURYEZAAAAAICqdGrrAQC0dwsXLkyS9O/fP6+++mqSpGPHjhv1OceMGZPGxsYkyWWXXbZRn4u20dDQkPnz5ydJ+vXr18ajAQAAoF4pMANsRH369EmSvPDCC2ssGj/11FPp3bt3kuT111+v5dDelTfffDNJcsEFF+T73/9+kmTZsmVJku7du+eoo45KkvzTP/1TsU2fPn3y7W9/O0lyyCGHVP3cG7sIvnjx4kyYMCFJcv/992fFihVJkt69e2fixInFGHjLggULkiQ777xz8f3q1MlbCQAAgPZMRAYAAAAAAFXRdgRQA7Nmzdqgbt62csUVVyRJ5s2bl4cffjhJ0qNHjyTJM888kwceeKDNxrahTjnllOyxxx5JyseyxRZbJEl+85vf5Pnnn2/LoQEAAMAmQ4EZoI2tLXZg6NChSZKPfexj+elPf5okefzxx7PffvslSaZPn57tt9++2M+nPvWpJMmDDz6Yv/71r0mSPfbYI9dff32SZMCAAes9trlz5yZJjj766PTs2bPFY3369CkiQJJywTYpZ0p/8pOfTFLOkr744ouTJOedd967GuPUqVOTJLfccksaGhqSJNdcc00OPPDAJOVi/bPPPpskOfvss4sid5cuXfKFL3whSfL5z3/+XR1bJdpjq622KpZ/9KMfbbHeqq/PtGnTkiQXXXRRkuQvf/lL8ZwXXnhhsc3DDz9cxG88+eSTed/73pckOfbYY3P11VcnSTbffPNi/YaGhlx77bXFsb722mtJks985jO58sorkyQdOnTI73//+yTJ2LFj89hjjyVJNttssxx88MFJUsSYVPzkJz9Jkhx++OFZunRpkuTTn/50pkyZUjxvc3NzkuTyyy/Pt771rSTJX//61xx22GFJkn/+53/ONttskyQZMmRIse+uXbsW9++5554kKX42AQAAaD9EZAAAAAAAUBUdzADvcdOnT8/dd9+dJOnVq1cOP/zwJMlVV12VyZMnF+tVln/nO98pumPPP//8nHTSSUlSdLyuj3333TdJcvXVVxf7/NjHPpYk+chHPlJ0GCfJzTffnKTcnby2Sf7ezRjHjRuXJPnlL3+5xkn+mpubiw7pI488MrfeemuS8qR9lefbddddM3z48Hc8tvHjxycpd0Lvv//+SVJMurgmP//5z5Mk//3f/52kPEnj3nvvnSQ55phjsttuuyUpd25XuqMHDRqUxYsXF8f/zW9+M0lyzjnntNj3D37wgyTlOJLKhI+HHHJIdt111yTJ6aefXnROH3roofnZz36WpDwR47x589Y43jvuuCNJuVu70hW91157Fd+/ww47rOjKnjZtWrHPHXbYIaNHj06SnHXWWcVrW+kW33nnnYvJHk3yBwAA0L75VAhQA0cddVSLQlwl/uKHP/zhO277mc98Jrvsskvx9fHHH58k+Y//+I8W65122mmrbfulL30p3bp1S5K8+uqrRdTBu3XBBRckSbp165ZbbrklSYpIiO22267IaD711FPf1f5aY4xz587NSy+9lCRF/EaS9O3bN2eccUaSZMaMGe9YYL7tttuK+ImvfOUr+a//+q8kye67715ERQwePLjFNpdcckmSFJEXe+yxR5Hj/Otf/7ooMO+1114ttqtEiXz2s5/N/fffn2T1AvP555+fJNl2222z7bbbFutUCuinn356NttssyTlzOhKTEhjY2MOOOCANR7jpEmTkpTjLCqRFgceeGBxsuGwww4rXtdzzz03ffv2LbatvLYf+chH8t3vfneN+wfgvefnP/95zjvvvCTJE088kY4dOyZJdtttt1xzzTVJyn/fKicYv/3tbxcnUKu1YMGC7LzzzkmSFStWbJSTjzfccEOS5Gtf+1qWLFmSJOncuXMGDRqUpPy3//3vf3+rP29bGjp0aE4++eQk5fcBq7rvvvuSJCeffHJxIntj69Onz1qbCABo30RkAAAAAABQFR3MADXwwx/+sOpOjw984AMtvu7cuXOSFDEKSdLU1FRMMnfbbbcVHb4dOrx1HnHp0qXr3cFc6XoaP358ESdRmZzvO9/5TtGRvPfeexfdu2vTWmNctXt31YnmKs+RvBXjsS7dunUrIkYmT55cTIL3j//4jznqqKOSZLWOoLe/FsmaX4+nnnoq5557bpJy5MVf/vKXJMnKlStX626u6NWr12rLPvjBDxbHmiRf/epXk5QnGaxEc3Tr1i0TJ05MsnqH+NrGu+pYK/v/4Ac/uNpzV8b8wgsvrHHMALx3VKKQjjjiiGLy3OOPPz5vvvlmknKE1RZbbNFm49sQ999/f/7P//k/SZLZs2cXE/K+/PLLmTVrVlsODQCIAjNAXZg+fXpmzpyZJPnJT35SRDK8+uqrRfxEqVRqleeqxEOMHz++iIz43e9+VxSYV81l3pAxrm0/vXr1Ki7DnT9//gYezVu23377JOUC84033pik/MG1GmeeeWbx4ffWW28tLtm95pprcvvtt69xm0WLFiVJBgwYUCxbuHBhevbsWXxdKRhXIjyS8qXQlZMXQ4YMSb9+/dZrrJX9P/PMMy2WL1y4MEk5Y3nHHXdMkuKSZADee5566qni/oknnljcr/zdPvTQQ4tlTz75ZD73uc8lKUdadOnSJUn5//xKxv6dd96ZL37xi0mSP/zhD8UJ4LFjxyYpR1xVDBkypLi/6snfe+65J/vtt1+S8onpr33ta0mS559/vjhROnXq1NVOcr7d3Llzi/1U/r4m5VipNcV0jRkzJltuuWUx9oceeihJMnDgwNx0001JWp5YnTBhQv793/89Sfl9yYc+9KEk5b/bq560rpzIrkRs3XDDDXnxxReTJLvssksRfdarV68ieuvss8/OI488kiTp3r17vvKVryR5K/Kstb366qtJytFXd911V5LyyfzPfOYzSZJLL720aCD4wx/+UMSL/frXvy7eew0fPjzXXXddkvLrecoppyQpvzeozONQ2cfFF19cHMvOO++c73znO8XyygntK664ojjBPnbs2OI9xsknn5wpU6YUY//DH/6QJDnjjDPy61//Okn5/WAl9uy6665r8fO1agRZZb6I5557rmgUuP7664ufAwA2LhEZAAAAAABURQczQB1Yvnx5cdnrdtttV0QyVC4nrVZlMqA999wz++yzT5IUE83dcsstWb58eZKW3UQ77rhj/vjHP27wGNe2n7333jtbb711knIH0ec///kkyeabb54nn3wySTnG4+0T9L3d+eefX3TkfPjDHy6iP66//vqiC3i77bYrjnF9LF++vBhjly5dii6m66+/Pt27d1/jNpWurn322afo+Ln22muLqI2kHC2SJPvtt18aGxuTlCMyKh1HlW6i9VHpcrvyyitz+OGHJyl3WFVelxNOOKGYrKky9g4dOhSvzaoTUALQdir/H3fs2LHo6h01alT23XffJCmuFkrKE/79v//3/5KsfZK/rbbaquj2HTBgQH77298mSYYNG5ak/N6g0in6wAMPFFcXLVu2rMUkf5Wu3ssvv7yIs/jQhz5UxFSdeOKJ+eUvf7nOY9tnn31y0UUXJSlPuFvpxh40aNBaYz8qk9jeeeedxXuY8847LyeddFKStDjmwYMHFxMHb7PNNrn22muTJJ/61KeyYMGCJMmWW26Zq6++OkmKCXjvuuuu4vv++OOPF7FZf/7zn4vv05e//OXcfffdxTqVsQ8YMKDFVUutpfLa77jjjvn9739fjOeII45IUu6u/uxnP5ukfOVYZULnIUOGFDErxx57bNGhfs011xTdwQ8++OAaJ/mrfI+SZM6cOUnKV5k98MADSZKRI0fmsMMOS1K+im3FihVJyu8fP/WpTyVJPv7xjxdXsl1wwQVFV/xrr72WY489Nkm5a77y3nRVt9xyS370ox8lKf/cVrqsL7vsslx22WXv/psHQNUUmAHqwOjRo4s31jvttFO23XbbJMlXvvKVIoexGpXLaidOnFh8SKkUM3fZZZf827/9W5Kkb9++xTYXXHBBzj777CTlD3KVy2s/97nPrdcYx44dW3zo6Nq1a4YOHZqk/EG18gF14sSJxQfaN954I7vuumuSvKsPE3/5y19y9NFHJylfTlk51n322Sf/8R//8Y7br8tVV12VcePGJSnnJlcK8CeccEJ++tOfrnGbI488Mkmy1157FZe3jhkzprgUOSlfIpwk55xzTrHOjjvuWHwQrnwv1kclt/nZZ58tPsz97W9/Ky5H/ed//udi3coH5wsvvDD/8A//kKR8afXs2bOTpChiAFB7lRObP//5z4sIhzPOOCPPP/98kmTEiBFFxFIl+mhdKn93K/7+7/8+yVsnJu+///6iwLwu//Iv/5Kk/P5g1fkaKicyL7/88iKmaW1RGR/72MeKCItvfvObxd+9lStXFn9vv/a1r7U40fqJT3wiScv4jv/7f/9vEfWxaNGiYv6Dk08+ucXzVeY2uOyyy/Lf//3fSZI99tijKK5W5kSovO+oPF7x/e9/v4hvqERTJOWIjkqx9Pbbb39XBebKifR//Md/bLF85cqVSVpGkrzwwgtFMXvZsmXFe5utttoqX/jCF5KUI0kqBeZ+/fq1iNaqnEg+99xzc+mll77j2NakciJgyy23LIrpW221VfFzs8MOOxTrfuxjH8ujjz6apFxgrozl7WOqnGxf25jOOuusFnNZVOb8OPvssxWYAWpERAYAAAAAAFVpWJ9JnwYNGlSaN2/eRhwOALQ/DQ0NxYSF6ztJHwCsSyWm6eSTTy4mr7v11lszbdq0JGuPyJgzZ04mTZqUJPntb3+bN998M0n5iqGkHB9RiU5YsGBBcRXNihUrWkRk9O/fP0l5grhVl1e88cYbuffee5Mk+++//7s6pubm5iTJz372s+JqpyuuuKLozB0zZkzRjVuJoKqoLL/jjjuK6Iyvf/3rRXfys88+W1yt9dprr+Wee+5Jkhx88MHFlTwPP/xwkuQjH/nIGsf31a9+tbiCq7JNRaXz+JRTTnnHq8yGDh1adFeffvrpLR677777kpRf18WLFxfjqlxNVOlor6h8z3r16pUnnngiSfLiiy8WHdIPPvhgEQvW3NxcRKpUJiFOypPqrSsiY+eddy7iL1Z9rRsbG/O9732vOKaKk08+OR/+8IeTJF/84heLCRM///nP58EHH0xSjh2rjL1bt26rjScpT/5X6VhPUhzfoEGDigg0AFpHQ0PDI6VSadDbl+tgBgAAAACgKjKYAQAA6lSlQ3TMmDFFHnLy1pwKa/PpT386Z511VpLk7rvvzpZbbpmkPA9AkixduvRd7auSjXvhhRcWE+xtqA4dyn1SBx98cA466KAkKSYhrFi107Xi9ddfz8svv5wk6dmzZ9Ele+WVVxZd1AMGDCj2361bt6x6xW/lWP7whz8kWXsHc69evfLxj388SYoO6Fro1atXMenh0qVL19gxvqoLLrigeO0ef/zxbLfddknK811UXvtVvdPPzIaqTDjY0NCQxx9/PEl5wuXKRJFrGlOy+mu9cOHCJOXXGIDaUGCGjWD27NmZMGFCkqSpqam4pK1ymSEAALSmShTGnXfemRNOOCFJOZqgUny79dZbW0zGWpnob/HixUX8xeabb148vnz58mJC3i233LKIhZg+fXqSFBO4JeXYiUpR9o9//GN22WWX4rHPfe5zScqTv+25555JykXcymS1P/7xj4uYi7WZOXNmEXUwfPjwYmK7uXPn5v7770+SXHPNNS22ueuuu5KUJz3ce++9izFUYjF69eqV3/zmN0nKcQ6V6IyVK1dm8uTJScoRGauqvKevTGTXv3//ItrqN7/5TXbaaackyRFHHFG877/55pszatSoYh+PPfZYkqRLly4tJj1sDT169Chel4kTJ+YrX/lK8VxPP/10kvLrXSl+L1++vJj0sGvXrlmyZEmS1WNFKnbcccf88Y9/bNUxr6oS0bHNNtsUr/GSJUvWOp6K6667LkcccUSSciTJ5ZdfniTF7wEAG5+IDAAAAAAAqqKDGVpRU1NTkmT8+PHF5XCNjY0ZPHhwkmTkyJHFRCcAFesz4S4ArMn73//+JOXJ+a6++uokybJly4pO0COOOKJFJ2glWmLAgAH5wAc+kKQcPVGJvvjmN7+ZiRMnJilHE1S6Xo8//vhi3xWdO3fOhRdemCT5h3/4h2Kit9mzZ+foo49OUo6nqHTyPvPMM0Xn7LBhw96xg7lbt275xje+UYylMtFgjx498r//9/9OktXiNz796U8nSS699NL86le/SpIMHDgwt9xyS7HO8OHDkySHH3540XW91VZb5Qtf+EKStyIxKs4999wkb010eOihhxbfrw9/+MP5wQ9+kKQc6/DjH/+42KayXXNzc/bYY48kKV6j1nbTTTclKV85WfncsXz58vTt2zdJcv755xfrXnLJJRk9enSSctdwpRv7lFNOyT/90z+ttu8LLrggZ599dpLkvPPOS1KenO+4445rlbFfcsklSZLRo0cXPx/9+vXLKaeckiRrHFNSfq0rndvPPvtsjjzyyGJsANRGw/p8qB00aFBp3rx5G3E4sGmrvHn90pe+lB/96EfF8iuuuKK4X8kWAwAAWt+YMWPS2NiYJLnsssvaeDRsLH369EmSfPvb384hhxzStoMBaCcaGhoeKZVKg96+XEQGAAAAAABVEZEBragyMcbbL6erdFDMmTOn5mMCAAAAgI1FgRla0TtFzjQ0NKz1salTp7a4TZJHHvltOnb8QOsMrp3ac8/t23oIdaGpKenYsa1HAW/xM9l6FixYUGSIAgBs6oYfuFX+9HJTq+5z+x5DM3v27FbdJ9QTERkAAAAAAFRFBzO0okoUxqJFi1osX7x4cZKkZ8+ea9123LhxLW6TpFOnPuna9aLWHma7Mm/e2LYeQl1Ytqw5Xbs6J8l7h5/J1jNo0GpzdABs0qZNm9bWQ6AGFixY0NZD4D3qTy835eEf9W7Vfe59hKu9YF0UmKEVDR48OEkyf/78PP3000mSnXbaKTNmzEiSTJ8+vc3GBgAAAPWulKQ5zW09DGhXtP4AAAAAAFAVHczQijp1Kv9KTZkyJcOHD0+SNDU15bTTTkuSDBgwoM3GBgAAAPWvlKaSDmaoJQVm2AhGjBiRESNGtPUwAAA2qk7v2yqbb71tWw9j06X+sWFcj1uVku/bBtvs+T+39RA2SX9L+fv2ZumNjfo85YiM0kZ9DqAlf1oAAAAAAKiKDmYAAKAqm2+9bfqdeG5bD2OT1enPOuw2xMrODW09hE3Sii5tPYJNX+MVv2zrIWyS5pTurdlzmeQPakuBGQAAAIC6UEopTSUn8KCWRGQAAAAAAFAVHcwAAAAA1A2T/EFtKTADAAAAUBdKSZoUmKGmRGQAAAAAAFAVHcwAAAAA1A0RGVBbCswAAAAA1IVSkqaSAjPUkogMAAAAAACqooMZAAAAgLrR3NYDgHZGgRkAAACAulBKKU0ymKGmRGQAAAAAAFAVHcwAAAAA1IdS0qSBGWpKBzMAAAAAAFVRYAYAAAAAoCoiMgAAAACoC6UkzW09CGhnFJgBAAAAqBMNaUpDWw8C2hURGQAAAAAAVEUHMwAAAAB1oZSkudTWo4D2RYEZAAAAgLohIgNqS0QGAAAAAABV0cEMAAAAQF0oRQcz1JoCMwAAAAB1o7mkwAy1JCIDAAAAAICq6GAGAAAAoC6IyIDaU2AGAAAAoC6U0pAmF+xDTfmNAwAAAACgKgrMAAAAANSN5lJDq/5bX7Nnz87s2bOz6667pl+/funXr18mT5681vUfeOCBPPDAAxk4cGA6deqUTp065fbbb1/jugsXLsyhhx6aQw89NLvttlv69++f/v37Z8GCBes9TmgtIjIAAAAAqAttncHc1NSU8ePHJ0nuueeeNDY2JkkGDx6ckSNHJkn69+/fYpvevXsnSaZNm5arrrpqnfsfPXp0LrzwwiTJsGHD8vrrrydJOnTQQ0rb8dMHAAAAAEBVdDADAAAAUCca0lRqu37Khx9+OP369UuS9O3bt1g+atSozJw5M8nqHcx9+vQp7q+tE/l3v/tdkmTlypUZNmxYsbxLly6tMm7YEArMAAAAANSFUpLmNrxgf8mSJenVq9dqyxsbGzNnzpyq9/vUU08lSbp27ZpjjjkmSdk0PTgAACAASURBVPL000/nkEMOSZJMnjw5HTt2rHr/sCFEZAAAAAAAUBUdzAAA0I7Mnj07STJhwoQ0NTUlSU4//fRMmjSpLYcFAK2mtSf5e+mllzJo0KDVlo8bN67FbZKUSqW17qehofpxrVy5Mkny4IMP5tFHH01SnhzwhBNOSFKeIHDs2LFV7x82hAIzAAC0E9XMbA8Am5JSqfUzmLt375558+a9q3UbGxuzaNGi1ZYvXrw4PXv2rHoMlb/ZH/3oR1tkOx911FFJkoceekiBmTYjIgMAAAAAgKroYAYAgHaimpntAWBT09zKERnrY/DgwZk/f36S8iR8O+20U5JkxowZmT59+gbtN0leeeWVvPTSS0nKndU//elPk2SNER5QKzqYAQAAAACoig5mAABoJ5YsWZJevXqttryxsTFz5sxpgxEBQOsqJWlqw37KTp06ZcqUKUmS4cOHFxPqnnbaaRkwYECS5OKLLy46jkeOHJm5c+cmSY4++ui88sorSZJZs2blkksuSZI88cQT6dixY5LkqquuysEHH5ykPKHgXnvtlSQ544wzanF4sEYKzAAA0E5syMz2U6dObXGbJCv/+ufWGRgAtJrWn+RvfY0YMaLF7dt9+ctfbvF1Jf5i8eLF77jvYcOG5fHHH9/AEULrEpEBAAAAAEBVdDADAEA70djYmEWLFq22fPHixenZs+c6tx03blyL2yTpvOPqcRsAALQvCswAANBObKyZ7QHgvaKUpNkF+1BTfuMAAAAAAKiKDmYAAGgn3s3M9gCwqWsqrXviWqB1KTADAEA78k4z2wPApqyUhjS5YB9qym8cAAAAAABV0cEMAAAAQN1oLrV2P2WplfcH9UWBGQAAAIC6UEo2QkRGUyvvD+qLiAwAAAAAAKqigxkAAACAulBKQ5pKDW09DGhXFJghyWmnnZY77rgjSbLDDjvkt7/9bfHYyy+/nCQ54YQTkiQLFixInz59kiT/+q//mm7duiVJSqVSJkyYkCS566670rlz5yTJtGnTMnDgwJocBwAAALR3zS7Yh5ryGwcAAAAAQFV0MEOSMWPG5KyzzkqSjB49usVjkydPTpIcfPDBSZJJkyYVyyZPnpwrr7wySXL33Xdn/vz5SZL58+dnzpw5SZIzzzyzuA8AAABsPKVS0lTSTwm1pMAMSYYMGZIFCxas8bGZM2cmSe67775i2amnnpokGTp0aFFgnjlzZlGcbmhoyL777pskWbZsWZ577rkkSY8ePTbG8AEAAIAkSUOaI4MZaskpHQAAAAAAqqKDGd7BCy+8kKRl93Hl/osvvlgsW7JkSXr16rXa9o2NjVmyZMlq+wAAAABaVykiMqDWFJihlZRKpbU+1tDwzpfnTJ06tcVteZ/LN3xgAAAA0I40uWAfaspvHAAAAAAAVdHBDO9gxx13TJIWE/VV7u+www7Feo2NjVm0aNFq2y9evDg9e/Z8x+cZN25ci9sk6dSpT9XjBgAAgPamlIY0l0zyB7WkwAzvYOTIkUmSG2+8MUkyadKk4v6RRx7ZYr0pU6YkSUaNGpU5c+YkSbbZZhvZywAAAFAjIjKgtvzGAQAAAABQFR3MkOTEE0/MfffdlyRZunRpGhsbkySXXnppJk2alCQ5/vjjkyQ33HBDevfunSS57bbbin2MGDEid911V5KkX79+6dy5c5Lku9/9bk2OAQAAANq7UpLmkn5KqCUFZkhy6623vuM699577zofb2hoyHXXXddaQwIAAADWW0OaIoMZaskpHQAAAAAAqqKDGQAAAIC6ICIDas9vHAAAAAAAVVFgBgAAAACgKiIyAAAAAKgbJvmD2lJgBgAAAKAulEoNMpihxvzGAQAAAABQFR3MAAAAANSNJh3MUFMKzAAAAADUhVKSZhnMUFNO6QAAAAAAUBUdzPAetuee22fevLFtPQwAAADYRDSIyIAaU2AGAAAAoC6UkjSXRGRALTmlAwAAAABAVXQwAwAAAFA3mvRTQk0pMAMAANUpJR3eLLX1KDZZf9p/RVsPYdP2pgJSNTovVAbYUPNvGtjWQ9gkvXHxr2ryPKU0iMiAGvMXGQAAAACAqjh1CQAAAEDdaNZPCTWlwAwAAABAXSiVkiYRGVBTTukAAAAAAFAVHcwAAAAA1A2T/EFtKTADAAAAUBdKaUhzyQX7UEt+4wAAAAAAqIoOZgAAAADqRlNEZEAtKTADAAAAUBdKkcEMtSYiAwAAAACAquhgBgAAAKBOmOQPak2BGQAAAIC60SyDGWrKKR0AAAAAAKqiwAwAAAAArWT27NmZPXt2dt111/Tr1y/9+vXL5MmT17r+Aw88kAceeCADBw5Mp06d0qlTp9x+++1rXLdjx47Zc889i38jR47MyJEjN9ahwLuiwAwAAAAAQFVkMAMAAABQF0qlpKnUdhnMTU1NGT9+fJLknnvuSWNjY5Jk8ODBRadx//79W2zTu3fvJMm0adNy1VVXrXP/73vf+/LYY4+19rBhgygwAwAAAFA3mkttd8H+ww8/nH79+iVJ+vbtWywfNWpUZs6cmWT1AnOfPn2K+x06CBtg0+OnFgAAAACAquhgBgAAAKAulNKQ5jaMyFiyZEl69eq12vLGxsbMmTNng/f/t7/9LYMGDUqSdOrUKZMmTUqSHHXUURu8b6iWAjMAAAAAdaM5rVtgfumll4qi7qrGjRvX4jZJSqXSWvfT0LDh41q4cGF69uyZJPnjH/+Ygw46KEmy++675+/+7u82eP9QDREZAAAAAABURQczAAAAAHWhlLR6REb37t0zb968d7VuY2NjFi1atNryxYsXF53HG2LVffTt2zdDhw5Nkjz66KM6mGkzCswAAAAA1I3mUttdsD948ODMnz8/SfL0009np512SpLMmDEj06dPr3q/r7zySpKkc+fO2WKLLZIkS5cuzS9+8YskyXnnnbchw4YNIiIDAAAAAICq6GAGAAAAoD6UGlo9ImN9dOrUKVOmTEmSDB8+PE1NTUmS0047LQMGDEiSXHzxxcWkgSNHjszcuXOTJEcffXTRqTxr1qxccsklSZInnngiTz75ZJLks5/9bDp0KPeLNjc3Z9KkSUmS/v371+LwYI0UmAEAAACoC6UkzWm7AnOSjBgxosXt2335y19u8fXgwYOTlHOa12b//fdPkvzmN79pjSFCqxKRAQAAAABAVXQwAwAAAFA32jIiA9ojBWYAAAAA6kIpCsxQayIyAAAAAACoig5mAAAAAOqGDmaoLQVmAAAAAOpCKQ0KzFBjIjIAAAAAAKiKAjMAALQTp512WnbYYYfssMMO+chHPtLWwwGAjaI5Da36D1g3BWYAAGgnxowZk9mzZ2f27NltPRQA2DhK5Qzm1vwHrJsCMwAAAAAAVTHJHyRZtGhRRo8enSR5/vnn06FD+dzLuHHjMmHChCTJyy+/nCQ54YQTsmDBgiRJnz598q//+q9Jkm7duqVUKiVJJkyYkLvuuitJ0rlz50ybNi1JMnDgwJocDwDAmgwZMqR4HwMA9aiU6DqGGlNghiSdOnXK17/+9STlIvDy5cuTJHvttVeGDRuWJEWR+OCDD86kSZOSJJMnT87kyZOTJFdeeWXuvvvuJMn8+fMzf/78JMmcOXNy5plnFvcBAACAjUeBGWpLRAYAAAAAAFXRwQxJevTokR49ehRfv//970+S7LbbblmyZEmSZObMmUmS++67r1jv1FNPzdChQ5OUO5gr64wePToNDeUzpvvuu2+WLVuWJHnuuedaPA8AwKZi6tSpLW6TZOVf/9xWwwEA4D1CgRnWoJJN+Oijj2afffZJkrzwwgtJ0qJA3KNHj7z44ovF15VidK9evVrsr7GxsXhcgRkA2BSNGzeuxW2SdN6h19pWB4A2UUqDiAyoMREZAAAAAABURQczvM3rr7+eY489NklyzTXXZOutt37X25ZKpXU+XonNWJM1XXb60ksvvevnBgAAAJKSDmaoKQVm+B8rVqxIkhx77LE56aSTkiTHHHNM8fiOO+6YpGWO8nPPPZcddtihWKcShbFo0aIW+168eHGSpGfPnmt9/jVddjpo0KDqDgYAYA1OPPHEYj6JpUuXFu9dLr300owdO7YNRwYArac5CsxQSyIyAAAAAACoig5mSDnaotK1s9tuu+Xcc89dbZ2RI0cmSW688cZMmjSpuH/kkUeuts6UKVMyatSoJMmcOXOyzTbbJIkJ/gCANnXrrbe29RAAYKMqlWKSP6gxBWZI8otf/CI333xzkmT33XfPnnvuWTx2+eWXJ0lRVD7++ONzww03JEl69+6d2267rVh3xIgRSZK77ror/fr1S5J07tw53/3udzf+QQAAAAAymKHGRGQAAAAAAFAVHcyQ5IADDkipVHpX6957771rfayhoXyW9LrrrmuVcQEAAADro0FEBtSYAjMAAAAAdUNEBtSWiAwAAAAAAKqigxkAAACAulBKRGRAjSkwAwAAAFAfSsm7nGIJaCUiMgAAAAAAqIoOZgAAAADqRnNaNyJD4AasmwIzAAAAAHWhlKTUyhnMCsywbiIyAAAAAACoig5mAAAAAOpEQ5pbuYNZdyasmwIzAAAAAHWjVGrrEUD74iQMAAAAAABV0cEMAAAAQN1o7Un+gHVTYAYAAACgLpRKCsxQayIyAAAAAACoig5mAAAAAOpGsw5mqCkFZgAAAADqRqnU1iOA9kVEBgAAAAAAVVFgBgAAAACgKgrMAAAAAABURQYzAAAAAHWjZJI/qCkFZgAAAADqQikNCsxQYyIyAAAAAACoig5mAAAAAOpGqa0HAO2MAjMAAAAA9aEkgxlqTUQGAAAAAABV0cEMAAAAQP2QkQE1pcAMAAAAQN0QkQG1JSIDAAAAAICq6GCG97CmpmTZsua2HgakW7eOeeWVprYeBhS6devY1kOoG3vttVdbDwEAoFWV2jgiY/bs2UmSCRMmpKmp/Dnq9NNPz6RJk9a4/gMPPJAkOeecc/L4448nSWbMmJHjjjtujeu/9tprSZLddtstRx99dJJkypQprXcAsJ4UmOE9rGPHpGtXFxrw3uBnkfeaUlt/cqgTgwYNaushsAkrdUhWdHEZMm2ja8/X2noIm6Td93y2rYewyVv0ere2HsIm6U+brazJ85TSthEZTU1NGT9+fJLknnvuSWNjY5Jk8ODBGTlyZJKkf//+Lbbp3bt3kmTatGm56qqr3vE5LrrooiTJxz/+8VYbN2wI1QIAAAAAAKqigxkAAACA+lBK0oYdzA8//HD69euXJOnbt2+xfNSoUZk5c2aS1TuY+/TpU9zv0GHdvaCPPPJIXnjhhSTJYYcdlnnz5rXGsGGDKDADAAAAUDfaMkltyZIl6dWr12rLGxsbM2fOnKr329xcnp9p4sSJufnmm5Mk9957b9X7g9YkIgMAAAAAgKroYAYAAACgfrRyB/NLL720xomRx40b1+I2WfdE1A0N1Ud3fPOb30ySjBgxYo0d0tCWFJgBAAAAqBMNKbVyBnP37t3fddZxY2NjFi1atNryxYsXp2fPnlWP4Ve/+lWS5MEHHyyKza+//nrefPPNJEmXLl0yefLkqvcPG0JEBgAAAAAAVdHBDAAAAED9aMNJ/gYPHpz58+cnSZ5++unstNNOSZIZM2Zk+vTpVe/3lltuWW3ZtGnTis5q3cu0JQVmAAAAAOpDKa0ekbE+OnXqlClTpiRJhg8fnqampiTJaaedlgEDBiRJLr744iLTeeTIkZk7d26S5Oijj84rr7ySJJk1a1YuueSSJMkTTzxR02OA9SUiAwAAAACAquhgBgAAAKB+tGFERpKMGDGixe3bffnLX27x9eDBg5OUJwJcH2PGjMmYMWPWf4DQyhSYAQAAAKgjbReRAe2RiAwAAAAAAKqiwAwAAAAAQFVEZAAAAABQP9o4gxnaGx3MAAAAAABURQczAAAAAPVDBzPUlAIzAAAAAPWhlKTU0NajgHZFRAYAAAAAAFXRwQwAAABA3SiJyICaUmAGAAAAoH4oMENNicgAAAAAAKAqOpghyd/+9rcMGTIkSfLGG29k5cqVSZLjjjsul156aZLk6aefTpKMGjUqL7/8cpJk4MCBufnmm5Mkm2++ed54440kyejRo/PII48kSbbbbrt8//vfT5L06dOnNgcEAAAA7ZVJ/qCmFJghyRZbbJGf/vSnSZIuXbpkxYoVSZIDDjgghx9+eJLk6quvTpJ84QtfyKhRo5Ikn/vc53LDDTckSc4888zifrdu3fL73/8+STJjxoycf/75SVIUmgEAAICNo0FEBtSUiAwAAAAAAKqigxmSNDQ0pEuXLsXXlQ7mFStWpKGhfGlNpcN5+vTpxXqnnnpqvvSlLyUpdzDPnDkzSYplSTlm46yzzkqSlEqlYn8AAABAKyvFJH9QYwrM8D+ampqSJHvttVcRbzF+/Pj83d/9XZKka9euSZJOnd76tWlsbMySJUuKryv3e/XqVSzr1KlTttlmmyTJn/70p2y//fYb8SgAAACgPWuQwQw1JiIDAAAAAICq6GCG/9GxY8ckyWOPPZZly5YlSY4++ug8+eST69xu1ciLUmnd1+GsKx5j6tSpLW6T5KWXXlr3oAEAAICWRGRATSkwwxpU4jCGDh2ahx56KEmKovPKlSuLmIzFixenZ8+exXaNjY1JkkWLFhX3V65cmVdffTVJsu222671OceNG9fiNkkGDRrUKscDAAAA7YYCM9SUiAwAAAAAAKqigxlSjqLYbLPNkpS7l//6178mSX7yk5/k/PPPT5IceOCBSZLbb789o0aNSpLceOONOfLII4v9jBw5sli+3377FesfdNBBSdYdkQEAAAC0Ah3MUFMKzJDkueeey6mnnpokaWpqSnNzc5Lk+OOPzxFHHJEk6d+/f5Jk1KhR+eIXv5gk+ehHP5qxY8cW+6ncP+WUU9KvX78k5ViMGTNm1OZAAAAAoD0rJSlp7oJaEpEBAAAAAEBVdDBDkr//+7/Po48+us51+vbtmyR5+OGH17rOlltumSS57bbbWm9wAACtZNGiRRk9enSS5Pnnn0+HDuV+k3HjxmXChAltOTQAaDUNIjKgphSYAQCgnejUqVO+/vWvJ0kGDhyY5cuXJ0n22muvDBs2LMlbsWAAsMlSYIaaEpEBAAAAAEBVdDADAEA70aNHj/To0aP4+v3vf3+SZLfddsuSJUuS6GAGAGD9KDADAEA7tWDBgiTJo48+mn322adtBwMAwCZJRAYAAAAAAFXRwQwAAO3Q66+/nmOPPTZJcs0112Trrbde5/pTp05tcZskTX/988YbIABUqcEkf1BTCswAANCOrFixIkly7LHH5qSTTkqSHHPMMe+43bhx41rcJsn7PtBrI4wQADZQqaGtRwDtiogMAAAAAACqooMZAADaiVKplLFjxyZJdtttt5x77rltPCIAaGWl//kH1IwOZgAAAAAAqqKDGQAA2olf/OIXufnmm5Mku+++e/bcc8/iscsvvzxJMmLEiDYZGwC0Gh3MUFMKzAAA0E4ccMABKZV86gagvjX4Uwc1JSIDAAAAAICq6GAGAAAAoH7oYIaaUmAGAAAAoH4oMENNicgAAAAAAKAqOpgBAAAAqAsNJZP8Qa0pMAMAAABQP0oNbT0CaFdEZAAAAAAAUBUdzAAAAADUDxEZUFMKzAAAAADUDRnMUFsiMgAAAAAAqIoOZgAAAADqhw5mqCkFZgDg/7d390FS1Xf+6N8tBLNcDSKCAgM/irBB0WRVZq56y1islmLUwrCijokPibFQS6rA7G7Jlrv4cLcEs6ylJanNWmuE1bD4cP9AEdkYDWWWTUCMD6WVWFhiwhCio4j4hMpM3z/G6Tg8BQ9D90zP61U11afPnD79+X7p7pn58DmfLwAA1IeyFhlQbVpkAAAAAABQiApmAAAAAOqHCmaoKhXMAAAAANSPcjd/fU4rVqzIihUrMn78+IwbNy7jxo3LvHnzdnv8U089laeeeirHH398+vfvn/79++ehhx7qcszvfve7/O53v8vEiRNz7LHH5thjj83RRx+dH/3oR/nRj370+YOEbiTBDAAAAABAIVpkAAAAAFA3arnIX1tbW6655pokyeOPP56GhoYkSVNTU6ZMmZIkmTBhQpfHjB49OkmycOHCzJ8/f5fnHT58eJLkf//3f3PggQcmSd57770cc8wxSZIpU6ZkxIgR3Twa2DsSzAAAAADQDdasWZNx48YlScaOHVvZ39zcnKVLlybZOcE8ZsyYyvYBB+y62cCAAQN22vfRRx+lvb19X0OGfaZFBgAAAAAAhahgBgAAAIBusHHjxowaNWqn/Q0NDVm9evU+n3/Dhg05++yzkySvvPJK/uVf/iVJtMegpiSYAQAAAKgf3dyDubW1NY2NjTvtnz59epfbJCmXd//kpVJpn2MZNWpUXnjhhSTJH/7wh3zzm99MkkybNi2HH374Pp8fitAiAwAAAACAQlQwAwAAAFAfykmpmyuYhw4dmrVr1+7VsQ0NDdmwYcNO+1taWrq9jcWIESNy9NFHJ0l+8YtfZNq0ad16fthbEswAAAAA1I9uTjB/Hk1NTVm3bl2SZP369Rk5cmSSZMmSJVm8eHHh87a0tCRJhgwZkr/4i79Ikrz99ttZtWpVkuT73//+voQN+0SLDAAAAAAAClHBDAAAAED9qGEFc//+/bNgwYIkyeTJk9PW1pYkufzyyyvtLObMmVNZNHDKlCl5+umnkyRTp07N22+/nSR55JFHcsMNNyRJXnrppfzmN79Jkvzt3/5tZbHAcrmcv/u7v0uSfPWrX63G8GCXJJgBAAAAqAuldH8P5s/rrLPO6nK7o5tvvrnL/aampiR/aoOxK6effnqS5IUXXuiOEKFbaZEBAAAAAEAhKpgBAAAAqB81rmCGvkaCGQAAAID6UK59iwzoa7TIAAAAAACgEBXMAAAAANQPFcxQVRLMAABAIeV+yceH+Cu+qDO++lKtQ+jV/nrQb2sdQq90zv+1qdYh9HpPfnhorUPolf5uwNbqPZkfTVBVWmQAAAAAAFCICmYAoNd5++22WocAAEAPZZE/qC4JZgAAAADqhwQzVJUWGQAAAAAAFKKCGQAAAID6UI4KZqgyCWbYQVtbWxobG5MkI0eOzLJly5Ik69evT5I0Nzdn8+bNSZLjjz8+9957b5JkwIAB+eijj5Ikl156aZ555pkkyZAhQ3L//fcnScaMGVO1cQAAAEBfpAczVJcWGQAAAAAAFKKCGXZwxx135KijjkqSbN26tbL/uuuuS5Jce+21aW5uTpJcddVVufvuu5MkV199dWV78ODBeeWVV5IkS5YsqTy2s5IZAAAA2E9UMENVSTDDp1paWpIkjz76aK6//vokyW233ZZyueMn05NPPpkkWbx4ceUxl112WW688cYkHQnmpUuXJkllX5JMmzYtM2bMSJKUy+WUSqX9Og4AAADoy7TIgOrSIgMAAAAAgEJUMMOnZs2alST5wQ9+kHfffbey/6233kqSHHLIIUmS/v3/9LZpaGjIxo0bK/c7t0eNGlXZ179//wwaNKhyrsMOO2w/jQAAAAAAqkuCGZIsW7Ysw4YNS5JMnDgxK1eurHyvs0XG7ny25cXnOXZHd911V5fbJGltbd3j+QAAAIAdaJEBVaVFBgAAAAAAhahghiSrVq3Kww8/nCRZvnx5tm3bliTZunVrpXXGli1bkiTbt2+vtMloaWnJiBEjKudpaGhIkmzYsKGyvX379rzzzjtJkkMPPXS3MUyfPr3LbZI0Njbu++AAAACgryhHBTNUmQQzJJk7d27mzp1bud/ZImP+/Pn5yU9+kiQ5//zzkyQPPfRQmpubkySLFi3KueeeW3nclClTKvtPOumkyvGnnnpqkj23yAAAAAD2TenTL6B6tMgAAAAAAKAQFcywl2699dYkSXNzc/7xH/8xSXLcccfle9/7XuWYzu1LLrkk48aNS9LRFmPJkiVVjhYAAAD6KC0yoKpUMAMAAAAAUIgKZtiFSZMmdblNkrFjxyZJ1qxZs9vHffGLX0ySPPjgg/stNgAAAGD3SiqYoaokmAEAAACoHxLMUFVaZAAAAAAAUIgKZgAAAADqhwpmqCoJZgAAAADqQ1kPZqg2LTIAAAAAAChEBTMAAAAA9UMFM1SVBDMAAAAAdUOLDKguLTIAAAAAAChEBTMAAAAA9UMFM1SVBDMAAAAAdUOLDKguLTIAAAAAAChEBTMAAAAA9aEcLTKgyiSYAQAAAKgfEsxQVVpkAAAAAABQiApmAAAAAOpCKRb5g2qTYAYAgD5i27ZtOeWUU5IkH330UbZv354kmTZtWm666aZahgYA3UeCGapKiwwAAAAAAApRwQwAAH3EgQcemCeffDJJctBBB+WTTz5Jkpx88sn5xje+kSQ58cQTaxYfAHSHUlkJM1STBDMAAPQRpVIpBx10UOV+Z4L5k08+SalUqlVYAAD0YlpkAAAAAABQiApmAADoQ9ra2pIkEydOzCuvvJIkueaaa3LCCSfUMiwA6B7lWOQPqkyCGQAA+pB+/folSZ577rls2bIlSTJ16tS8+OKLSZJjjjlml4+76667utwmSdv77+/PUAGgkFI3J5jlq2HPtMgAAAAAAKAQFcwAANBHHXLIIUmSSZMmZcWKFUl2X8E8ffr0LrdJ8sWRo/ZzhABQgJJjqCoVzAAA0Ee0trZmy5YtldYYH374YT788MP87Gc/y5FHHpkjjzyyxhECwL4rlbv3C9gzCWYAAAAAAArRIgMAAPqITZs25bLLLkuStLW1pb29PUlywQUX5JxzzqllaADQfVQdQ1VJMAMAQB/xta99Lc8++2ytwwCA/acHtLXoXNdg5syZaWtrS5JcccUVmT179i6Pf+qpp5Iks2bNygsvvJAkWbJkSaZNm1Y55rnnnkuSXH311dm6dWuSpF+/frn++uuTJBdeeOF+GAnsHS0yAAAAtHkdlAAAHbhJREFUAAAoRAUzAAAAAPWjhhXMbW1tueaaa5Ikjz/+eBoaGpIkTU1NmTJlSpJkwoQJXR4zevToJMnChQszf/78XZ534MCBSZL//M//zF/+5V8mSf7whz9k4sSJSZLJkyfnkEMO6ebRwN6RYAYAAACgLpRS2xYZa9asybhx45IkY8eOrexvbm7O0qVLk+ycYB4zZkxl+4ADdt1s4Ctf+cpO+0aMGJFhw4YlSVpbWyWYqRktMgAAAAAAKEQFMwAAAAD1o1y7EuaNGzdm1KhRO+1vaGjI6tWru/W51qxZk48//jhJ8uUvf7lbzw2fhwQzAAAAAHWju1tktLa2prGxcaf906dP73KbJOU9JLdLpVK3xLNp06YkySWXXJJFixYl2X1rDagGrz4AAAAAAApRwQwAAABAfSh/+tWNhg4dmrVr1+7VsQ0NDdmwYcNO+1taWjJixIh9jmXr1q05++yzkyT//M//nBNPPHGfzwn7SoIZAAAAgLpRaq/dczc1NWXdunVJkvXr12fkyJFJkiVLlmTx4sWFz9vZa3nq1Km59NJLkyTnn3/+PkYL3UOLDAAAAAAAClHBDAAAAED96OYWGZ9H//79s2DBgiTJ5MmT09bWliS5/PLLc/TRRydJ5syZU1k0cMqUKXn66aeTdFQnv/3220mSRx55JDfccEOS5KWXXsoDDzyQJHnqqafy1ltvJUkWLlxYed6FCxfm2GOP3c+jg12TYAYAAACgbpRqmGBOkrPOOqvL7Y5uvvnmLvebmpqSdPRp3p2LL764yy30JFpkAAAAAABQiApmAAAAAOpDOUm5xiXM0MdIMAMAAABQN2rdIgP6Gi0yAAAAAAAoRIIZAAAAAIBCtMgAAAAAoH5okQFVpYIZAAAAAIBCVDADAAAAUBdKscgfVJsEMwAAAAD1oVzu+AKqRosMAAAAAAAKUcEMAAAAQN3QIgOqS4IZPjVmzJgkycEHH5x+/folSfr375+1a9cmSTZv3pwkufDCC/Paa69VHvPAAw8kSQYPHpzyp5fhzJw5M8uXL0+SDBw4MAsXLkySHH/88dUYCgAAAPRdEsxQVVpkAAAAAABQiApm2MHPf/7zHHbYYTvtnzdvXpLktNNOy+zZsyv7Ovffeuuteeyxx5Ik69aty7p165Ikq1evztVXX13ZBgAAAPYfLTKgulQwAwAAAABQiApm2EtLly5NkqxcubKy77LLLsukSZOSdFQwdx5z6aWXplQqJUlOPPHEbNmyJUmyadOmDB8+vHpBAwAAQF9STtKuhBmqSYIZPtWZED7jjDMq21deeWWmT5+eJHn99deTpEuCePjw4XnjjTcq9zdu3JgkGTVqVJdzNzQ0VL4vwQwAAAD7kfwyVJUWGQAAAAAAFKKCGT61atWqJMmIESMqVcmnn356jjzyyL0+R7m85/8m7ayM3pW77rqry22StLa27vVzAwAAABb5g2qTYIZPjRgxorI9bNiwJMnUqVOzZs2aJMnhhx+epGsf5U2bNlWOTf7UCmPDhg1dzt3S0rLTc+yosxVH522SNDY2FhsMAAAA9FV/pvgL6F5aZAAAAAAAUIgKZkjy/vvvp729PUly8MEH5/3330+S/PSnP82cOXOSJFOmTEmSLFq0KLNnz65sn3vuuZXzdB6zYMGCNDc3J0lWr16dQYMGJYkF/gCAulLuX87Hh7XVOoxe68ADttc6hF5twoGbah1Cr3TQAV+sdQi93ssf+buuiG3l16r2XFpkQHVJMEOS119/PVOnTq3c376945f9b33rWznzzDOTJE1NTUmSCy64IHfffXeSZPTo0XnwwQcrjzvrrLOSJMuXL8+4ceOSJAMHDsw999yz/wcBAAAAfV350y+garTIAAAAAACgEBXMkGTs2LF5/vnn93jMkCFDkiRPPPHEbo8plUpJkh/+8IfdEtczzzxTOSfU2pYt7bUOoS4MHtyv1iHUjbffdlk+AABdlZKULPIHVSXBDD3YxIkTs3bt2lqHAdmypT2HHOKil+5Q9stut9iypT3/37hhtQ6jPowZU+sIAAC6l9oYqCrZAgAAAAAAClHBDAAAAEDd0CIDqkuCGQAAAID6UP70C6gaLTIAAAAAAChEghkAAAAAgEK0yAAAAACgTpQTPZihqlQwAwAAAABQiApmAAAAAOpGSQEzVJUEMwAAAAD1Q4sMqCotMgAAAAAAKEQFMwAAAAD1oZyU2msdBPQtEswAAAAA1A8tMqCqtMgAAAAAAKAQFcwAAAAA1A8FzFBVEswAAAAA1I2SFhlQVVpkAAAAAABQiApmAAAAAOqHCmaoKglmAAAAAOpDOUl7rYOAvkWLDAAAAAAAClHBDAAAAEBdKKVskT+oMglmAAAAAOqHBDNUlRYZAAAAAAAUooIZAKAbXfHW/7vTvv8Y8k81iAQAoI/q7grmUveeDuqNBDMAwD7YVUL5zx0j4QwAsJ+Uk7R38zn7dfP5oM5okQEAAAAAQCEqmAEAPqe9qVre28erZgYA6F6lGi/yt2LFiiTJzJkz09bWliS54oorMnv27F0e/9RTTyVJZs2alRdeeCFJsmTJkkybNm2nY88888z86le/SpKcfPLJWbZsWbfHD5+XBDMAwF7a18Tyns4p0QwA0E1qmGBua2vLNddckyR5/PHH09DQkCRpamrKlClTkiQTJkzo8pjRo0cnSRYuXJj58+fv8fx///d/nw8++CBJ8u///u/dGjsUpUUGAAAAAACFqGAGAPgz9kfl8q6eQxUzAMC+Kte0gnnNmjUZN25ckmTs2LGV/c3NzVm6dGmSnSuYx4wZU9k+4IA914KedtppWblyZfcEC91EghkAYA+qkVze8bkkmqmGtra2NDY2JklGjhyphyMAdIONGzdm1KhRO+1vaGjI6tWraxAR7H9aZAAAAAAAUIgKZgAA6IPuuOOOHHXUUUmSrVu31jgaAOgm5XR7i4zW1tbKVT+fNX369C63SVLew3OXSqVujQt6CglmAIBdqGZrjF09tzYZ7C8tLS1JkkcffTTXX399kuS2226rZUgA0L3au/d0Q4cOzdq1a/fq2IaGhmzYsGGn/S0tLRkxYkT3BgY9hBYZAAAAAAAUooIZAAD6kFmzZiVJfvCDH+Tdd9+tcTQA0P1K3dwi4/NoamrKunXrkiTr16/PyJEjkyRLlizJ4sWLaxYX7E8SzAAA0EcsW7Ysw4YNS5JMnDgxK1eu3OvH3nXXXV1uk6Ttvfe7NT4A6BY1TDD3798/CxYsSJJMnjw5bW1tSZLLL788Rx99dJJkzpw5lZ7OU6ZMydNPP50kmTp1at5+++0kySOPPJIbbrghSfLSSy9Vzv/1r389v/3tb5Mk7733XhoaGpIkd999dyZPnry/hwe7pEUGAAAAAACFqGAGANhBLRf4g/1p1apVefjhh5Mky5cvz7Zt25IkW7duzcUXX5wkue+++3b52OnTp3e5TZID/0/D/gwXAD6/cpL22lUwJ8lZZ53V5XZHN998c5f7TU1NSf60EO+e/OIXv9jH6KD7STADAEAfMXfu3MydO7dyv7NFxvz583ebWAaA3qVc0xYZ0BdpkQEAAAAAQCEqmAEAAACoHyqYoapUMAMAAAAAUIgKZgCAHfzHkH+y0B99wqRJk7rcAkBdUMEMVSXBDAAAAEB9KCdpl2CGatIiAwAAAACAQlQwAwAAAFAnykm5vdZBQJ8iwQwAsAv/MeSfkqQmvZg7nxsAgAL0YIaq0iIDAAAAAIBCVDADAPQQKpcBAPaRRf6g6iSY4VNbtmxJklxxxRV58cUXkySlUik//vGPkyTjx49Pklx44YV57bXXkiRjxozJAw88kCQZPHhwyp9ehjNz5swsX748STJw4MAsXLgwSXL88cdXZSwAdJ//GPJPNWmTAQBAQVpkQFVpkQEAAAAAQCEqmOFTM2fOTJKceeaZeeihh5IkH3/8cT744IMkyS233JIkOe200zJ79uwkybx58zJv3rwkya233prHHnssSbJu3bqsW7cuSbJ69epcffXVlW0Aep9qLPinPQYAQDdRwQxVJcEMSbZu3ZqnnnoqSSrtLJJkwIABGTBgQJJk6dKlSZKVK1dWvn/ZZZdl0qRJSToSzJ3HXHrppSmVSkmSE088sdJ+Y9OmTRk+fPj+HAoA+1F3J5ollQEAultZghmqTIsMAAAAAAAKUcEMSV599dUMHTo0SfLd7343zz//fJJk4sSJueOOO5Ikr7/+epJ0qUAePnx43njjjcr9jRs3JklGjRrV5fwNDQ2V76tgBuj9Plt5XKSaWeUyAMB+Uk7S3l7rKKBPkWCGJNu3b8+vf/3rJMmdd96ZE044IUlHX+bOHst7o/xnLsPpbJuxK3fddVeX2yRpbW3d6+cGoDYkiwEAgL5MiwwAAAAAAApRwQzpaGHR2cais3o5SaZNm1apYD788MOTdF2ob9OmTRk2bFiX8yTJhg0bupy/paUlSTJixIjdxjB9+vQut0nS2NhYbEAAAADQV1nkD6pKghmSHHHEEZW+yS+//HLGjx+fJHniiScyYcKEJKncLlq0KLNnz65sn3vuuZXzTJkyJUmyYMGCNDc3J0lWr16dQYMGJYn+ywAAALC/STBDVWmRAQAAAABAISqY4VN33nlnkuTb3/52Pv744yTJ2LFjc8899yRJ2j9dhfaCCy7I3XffnSQZPXp0Hnzwwco5zjrrrCTJ8uXLM27cuCTJwIEDK+cAAAAA9qdy0q6CGapJghk+deyxxyZJ1q5du8fjnnjiid1+r1QqJUl++MMfdl9gAAAAwN4pJ+Vye62jgD5FiwwAAAAAAApRwQwAAABA/dAiA6pKghkAAACA+lGWYIZq0iIDAAAAAIBCVDADAAAAUB/K5aTdIn9QTRLMAAAAANQPLTKgqrTIAAAAAACgEBXMAAAAANSNshYZUFUSzAAAAADUibIWGVBlWmQAAAAAAFCICmYAAAAA6kM5SbsKZqgmCWYAAAAA6kdZD2aoJi0yAAAAAAAoRAUzAABQyMHvb8vQu+6vdRi71NramqFDh9Y6jD361V21jmD3esX85fBah7Bbra2tSdLj57An6g2vveTNWgewWz15/rb98QtVeZ5ykrIWGVBVEswAAEAhb77Zc5MsjY2NWbt2ba3D6LXM375pbGxMEnNYgNfevjF/ScplLTKgyrTIAAAAAACgEBXMAAAAANQNLTKguiSYAQAAAKgfWmRAVWmRAQAAAABAISqYoQf77W9/W1kgpK/qyasg729WHzcHffn132mPczBmTFVjqbZqvf5fe+21/Xp+qJXp06fXOoRezfztG/NXnLnbN+Yv+X8m/99588313XrOww47rFvPB/WmVC7vfV+axsbGcp9fjRSqyArAfXsOrD5uDvry679TX56Dvv76BwAAepZSqfRMuVzeqRJSiwwAAAAAAAqRYAYAAAAAoBA9mAEAgLqxYsWKJMnMmTPT1taWJLniiisye/bsWobVK1x++eVZtmxZkmTYsGF58cUXaxxR77Fhw4ZceumlSZI//vGPOeCAjlqu6dOnZ+bMmbUMrVfYtm1bTjnllCTJRx99lO3btydJpk2blptuuqmWofUanZ93jY2NGTlyZJJU3s8A+5sKZgAAAAAAClHBDD2YFYD79hz05bF36utz0NfHn/TtOejLY4ei2tracs011yRJHn/88TQ0NCRJmpqaMmXKlCTJhAkTahZfT/ed73wnM2bMSJJKNS57p3///vnXf/3XJMnxxx+fd999N0kyceLEnH766Um89vbkwAMPzJNPPpkkOeigg/LJJ58kSU4++eR84xvfSJKceOKJNYuvN7jjjjuSJEcddVS2bt1a42iAvkaCGXowyYW+PQd9eeyd+voc9PXxJ317Dvry2KGoNWvWZNy4cUmSsWPHVvY3Nzdn6dKlSST59uSUU07Ja6+9VusweqXhw4dn+PDhlfsHH3xwko5k38aNG5N47e1JqVTKQQcdVLnfmWD+5JNPUiqVahVWr9HS0pJHH300SXL99dfntttuq3FEQF+jRQYAAAAAAIWoYAYAAOrCxo0bM2rUqJ32NzQ0ZPXq1TWIiL6qsxL82WefzQknnFDbYHqJzkXqJk6cmFdeeSVJcs0115i/vTBr1qz84Ac/SJJKexaAapJghh6oHlc/v/zyy5N0rGQ8bNiwJOmyMvnmzZtz4YUXJun4hXzMmDFJkgceeCCDBw9OkpTL5coq3MuXL8/AgQOTJAsXLszxxx9flXEUtTcri9f7HOzN6uDr169Pc3Nzko756BzTvffemwEDBlQe2zmXzzzzTIYMGZIkuf/++ytz1pPtboXv9evXJ+m4jHvz5s1JOno43nvvvUmSAQMG5KOPPkrS0RfzmWeeSZIMGTIk999/f5L0ivGPGTOmctlwv3790r9/x68ia9eurYz7wgsvrPxhPmbMmDzwwANJksGDB6dcLifp+Hxcvnx5kmTgwIFZuHBhkvTo98GWLVuSdHyed37+lUql/PjHP06SjB8/vq4/A6AaOj8jdsVl9lTLe++9l/POOy9Jcvvtt+dLX/pSjSPqHfr165ckee655yo/M6dOnVr5mXnMMcfULLaeatmyZUmSYcOGZeLEiUmSlStX1jAioK/SIgMAAAAAgEJUMEMPU6+rn3/nO99JksyYMWOXq5LPmzcvp512WpJk9uzZmTdvXmX/rbfemiR57LHHsm7duiTJunXrKpe6Xn311T3+ste9WVl84cKFdT0He7M6+G233ZZrr702SUcl71VXXZUkufvuu3P11VdXtjurOV955ZUsWbIkSXLddddVKnl7st2t8H3dddclSa699tpKFfdVV12Vu+++O0nHv3Hn9uDBgyuXji5ZsqTy2N4w/iT5+c9/niQ57LDDuuzvfM2fdtpplSs25s2bV9l/66235rHHHkvS8frvfC+sXr268vroye+DzsrjM888Mw899FCS5OOPP84HH3yQJLnlllvq+jMAqqGhoSEbNmzYaX9LS0tGjBhRg4joSzp/tznvvPPy7W9/O0nyN3/zN7UMqdc65JBDkiSTJk2qXN2pgnlnq1atSpI8/PDDlSu7tm3bVvkd8+KLL859991Xs/iAvqO0p8vIdtTY2Fheu3btfgwH+OUvf5kbb7wxSfLf//3flf1z586tbP/DP/xDtcPqNq+99lrOOeecJF1bZIwfP75yOdfw4cOzadOmJB2/VL788stJkiuvvDKTJk1Kklx00UW7fWxvcu6552bGjBlJOpLvfWkOOpNqJ598cv7t3/4tSXL22Wfnj3/8Y5KOpPwvf/nLJMmNN95YeT9Mnjy58h456aSTKq02jjjiiLS2tibpuZdBt7S05LLLLkvSdYXvRx55JEOHDk3S0UKls23Ejp8HkydPTtIxHyeddFKSZPv27TniiCOSJK2trT127J3GjBmTzt8ldkwwjx8/PknHpZ2dr+NNmzZVXvMvv/xyrrzyyiQd74sd3wM7PrYn2bp1a/7qr/4qSfLqq6/u8t+pr34OQnfavn17vvKVryRJnnjiiUoroqampixevDhJcvTRR9csvt6gs0XROeec0+V3NfasXC5XfsYfeuihuf3222scUe/S2tqaL3zhC0k6kssffvhhkuSMM86o/Ed6598Q7NnKlSszf/78JH9qoQHQXUql0jPlcrlxx/1aZAAAAAAAUIgWGdDD9NXVz19//fUuVXed22+88UZl357mZuPGjV0e19PtamXxvjAHu1sd/Mtf/nKSjoqVzurdJJUWMZ1j69z+7Bx0Hj9o0KC89dZbSXaujO0pdrfC91tvvVW5FHTH8e849iQ7jX/QoEGV8/TUsXcqlUo544wzKtudFcnTp0/P66+/niQ7vQ92fA8k2el98NnXSk98D7z66quVKvXvfve7ef7555N0vBc626b0hc8A2N/69++fBQsWJOm44qXz587ll1+ucnkvXHTRRZWrId58883KZ+tNN92U733vezWMrOdbtWpVZWHer371qzn22GMr37vllluSJGeddVZNYusNNm3aVKkAb2trS3t7e5LkggsuULkM0AuoYAYAAAAAoBAVzNDD7Kkvek/vrbq/1cvcvPfeeznvvPOSJLfffnu+9KUv7fVje/sc9OvXL0ny3HPPZcuWLUmSqVOn5je/+c0eH/fZsfXGOejsfzds2LBMnDgxSSoVYsnej+nPrZvQU8f/WatWraostPXGG29UFrk88sgj9+rxvXUOtm/fnl//+tdJkjvvvLNy5cLMmTMri/ntjd74+odq66wSVS36+f3Xf/1XrUPotU4++eQ/+zOK3fva176WZ599ttZh1IVJkyZV1msAqBYJZuhh+urq54cffnhlQavPLm41bNiwyjG9fW7+3MrifWEOPuuzq4P/6le/SpJs2bKlsmhf//7909LSkiRdxvbZOWhoaKgc/8477+TQQw+tWvyfx59b4XvWrFmVhPv27dsrbTJ2/HftvFR5w4YNle3t27fnnXfeSZIeO/7P+ux4hg0blqlTpyZJ1qxZk8MPPzxJx2Wyn13kb8f3QJKd3ge7eq30JA0NDZXYO5PLSTJt2rRKgrmvfQYAAAD1QYsMAAAAAAAKUcEMPUxTU1PWrVuXJFm/fn1GjhyZJFmyZEkWL15cy9D2qylTpmTRokVJktmzZ1e2zz333C7HdC7c09zcXFn0cNCgQT1+UatyuVxZHOeoo47K97///Z2Oqfc5aG1tzRe+8IUkHdXLH374YZLkZz/7Wa677rokyV//9V/noYceStIxvt3NQef+k046qXL8qaee2mNbBMydO7fLbdLRImP+/PlJkp/85Cc5//zzkyQPPfRQmpubkySLFi3aaeyd+0866aTK8aeeemqSnt0i4f3330+StLe35+CDD67s++lPf5okmTNnTpfxzZ49u7K9qzlYsGBBZZ5Wr15dWeiwp74PjjjiiMrifC+//HLGjx+fJHniiScyYcKEJMmECRPq+jMAAACoT6XP0yeqsbGxvHbt2v0YDpCkcgn9rFmzuqx+fv3119cyrH1y0UUXJelIqr355ptJOi4Hv+mmm5Ik3/zmN3PBBRckSX7/+99n9OjRSZIHH3ywctl/uVzOjBkzkiQrVqzIwIEDkyT33HNPGhsbqzeYAv7nf/4nX//615N0rCx+wAF/uoCkc2XxE044oa7n4IUXXtjt6uBz5sxJkrz66quVpOHmzZtz3HHHJUnuu+++HHjggUk6WktccsklSZJnn322MjdLlizJ2LFjqzegffTZBPOyZcvy6quvJulIGm7evDlJctxxx+W+++5Lkhx44IHZtm1bkuSSSy6p9Ck89NBDs2TJkiTp0ePvHF9nS4yko73Ht771rSTJ9ddfn7feeitJx2vi97//fZJk9OjRefDBB5N0jLXz95YZM2ZkxYoVSZKBAwfmnnvuSZIe/T547rnnkiRXXHFFPv744yQd/2adsbe3t9f1ZwAAANC7lUqlZ8rl8k5/eGiRAQAAAABAISqYAQAAAADYIxXMAAAAAAB0KwlmAAAAAAAKkWAGAAAAAKAQCWYAAAAAAAqRYAYAAAAAoBAJZgAAAAAACpFgBgAAAACgEAlmAAAAAAAKkWAGAAAAAKAQCWYAAAAAAAqRYAYAAAAAoBAJZgAAAAAACpFgBgAAAACgEAlmAAAAAAAKkWAGAAAAAKAQCWYAAAAAAAqRYAYAAAAAoBAJZgAAAAAACpFgBgAAAACgEAlmAAAAAAAKkWAGAAAAAKAQCWYAAAAAAAqRYAYAAAAAoBAJZgAAAAAACpFgBgAAAACgEAlmAAAAAAAKkWAGAAAAAKAQCWYAAAAAAAqRYAYAAAAAoBAJZgAAAAAACpFgBgAAAACgEAlmAAAAAAAKkWAGAAAAAKAQCWYAAAAAAAqRYAYAAAAAoBAJZgAAAAAACpFgBgAAAACgEAlmAAAAAAAKkWAGAAAAAKAQCWYAAAAAAAqRYAYAAAAAoBAJZgAAAAAACpFgBgAAAACgEAlmAAAAAAAKKZXL5b0/uFRqTfK7/RcOAAAAAAA90P8pl8tDd9z5uRLMAAAAAADQSYsMAAAAAAAKkWAGAAAAAKAQCWYAAAAAAAqRYAYAAAAAoBAJZgAAAAAACpFgBgAAAACgEAlmAAAAAAAKkWAGAAAAAKAQCWYAAAAAAAr5/wFbZLeDuuMAdQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], "source": [ - "for i in range(4):\n", - " interp.plot_heatmapped_episode(-1, action_index=i, return_heat_maps=False)" + "data = MDPDataBunch.from_env('CartPole-v1', render='rgb_array', bs=32, add_valid=False)\n", + "model = create_dqn_model(data, FixedTargetDQNModule, opt=torch.optim.RMSprop, lr=0.00025)\n", + "memory = ExperienceReplay(memory_size=1000, reduce_ram=True)\n", + "exploration_method = GreedyEpsilon(epsilon_start=1, epsilon_end=0.1, decay=0.001)\n", + "learner = dqn_learner(data=data, model=model, memory=memory, exploration_method=exploration_method)\n", + "learner.fit(10)\n", + "\n", + "data.close()\n", + "learner.recorder.plot_losses()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "is_executing": true + } + }, + "source": [ + "## Rational\n", + "Fixed Target DQNs seem to be able to solve environments even if the loss becomes massive. You can reduce this by making the `copy_over_frequency` larger.\n", + "\n", + "Results of the fixed target over 5 runs are auto-generated from the `tests/test_dqn.py` directory. You can run them via:\n", + "`py.test tests/test_dqn.py -k 'test_dqn_models_cartpole' -s --include_performance_tests'`. Once finished, it will generate a `.pickle` understandable by the GroupInterpretation object below." ] }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "execution_count": 6, + "metadata": { + "pycharm": { + "is_executing": false + } + }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-1.279396092362345 -0.07939609236234499 4.109805011749268 5.309805011749267\n" - ] - }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsMAAAFNCAYAAADl3mJ3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdeXxU5dUH8N+5985MJitJ2EIgBBJCEjaRFCpaUfuCRQUFRFxQFFDRWmiBCrZWqm99FUFRpFYRK+BWFxQEFypiEevKIpCFfc/CEkL22Z/3j3vvZDKZLZBJAjnfzycfZu7c5ZkJyZycOc95SAgBxhhjjDHG2iKppQfAGGOMMcZYS+FgmDHGGGOMtVkcDDPGGGOMsTaLg2HGGGOMMdZmcTDMGGOMMcbaLA6GGWOMMcZYm8XBMGsViOgOIvp3E58zlYgEESlNed7WhIiuIqLjLT0Oxhhj7ELFwXAbQ0SHiaiWiKqI6AQRLSei6CY691+JyK6dW/86G8qxQoi3hBAjmmIcTcHruZwlom+J6LKWHhdjjDHGmhYHw23TKCFENIBLAeQAeLSxJwiQbX1XCBHt8dXufAbawt7VXqf2AL4C8H5LDuZiznAzxhhjLYWD4TZMCFEI4DMAfQGAiOKI6DUiKiaiQiL6GxHJ2mN3E9F/iWgREZUC+Gtjr6eVLEwnooNEdJqIFhCR5HH+b7TbpF3nJBFVENEuIvIc40oiOkVER4joUY9zyES0UDv3QQDXe13f7/ML8jo5ALwFIJmIOnic7wYi+tkjc9xf234PEa312G8fEb3vcf8YEV2i3X5Bu19BRFuJ6Fce+/2ViD4gojeJqALA3URk1rL5ZUSUD+AXXs9xjvbcKoloDxH9OsRvD2OMMdYmcaapDSOibgCuA/Chtmk5gJMA0gFEAVgH4BiAV7THhwD4F4BOAAzneNkxULPR0QA2ANgDYJnXPiMAXAkgA0A5gEwAernFiwDiAPQEkAjg3wCKAbwG4F4ANwAYCKAawCqv8wZ7fj4RkRHAXQBKAZRp2wYC+CeAUQC2AJgI4GMi6g1gE4BFWpDeGYARwGXacT21575TO/1PAJ7QnucMAO8TUaoQwqI9fiOA8dr1TQDmAUjTvqKg/jGjj7M3gIcA/EIIUUREqQCCBvuMMcZYW8aZ4bZptVbL+w3UwO3/iKgT1MD490KIaiHESQCLANzqcVyREOJFIYRDCFHr59y3aJlS/esrr8fnCyHOCCGOAngewG0+zmEHEAM1CCYhRIEQoljL4t4K4BEhRKUQ4jCAZwHcqV8bwPNCiGNCiDMAntJPGOLz8/lcANRCDbRv1rLEAHAfgFeEED8IIZxCiBUArAB+KYQ4CKASwCVQg/r1AIqIKBPAMACbhRAuABBCvCmEKNVe02ehBry9PcbwnRBitRDCpb3mtwB4UnsNjwFY7LGvUzs+m4gMQojDQogDAZ4fY4wx1uZxZrhtukkIscFzAxH1g5rtLSYifbMENXOq87ztz3tCiIkBHvc8xxEAXbx3EEJsJKIlAP4OoDsRfQhgNgCzNsYjXudI1m538XF+XXcEf34+nwsRtYeaZR4E4D8e55tERL/z2N/o8Xw2AbgKahZ6E9TM9jCoGeJN+gFENBvAFO04ASAWao2yznt8fp+jEGI/Ef0eaglLHyJaD2CmEKIowHNkjDHG2jTODDPdMaiZzfZCiHbaV6wQoo/HPqIJrtPN43YKAJ+BmhBisRBiEIBsqOUSfwRwGmrWuLvXOQq128U+zq8L5fn5JIQ4DTUT/FciSvI435Me52onhIgUQryjPa4Hw7/Sbm+CGgwP025Dqw9+GGq2N16bbFgOwB2to+FrHug5QgjxthDiCqivkQAwP9jzY4wxxtoyDoYZAEAIUQy1/vZZIoolIomI0ohoWBNf6o9EFK/VK88A8K73DkT0CyIaQkQGqLW/FgAuIYQTwHsAniSiGCLqDmAmgDe1Q98DMJ2IuhJRPIC5TfX8hBB7oJY7PKxtehXANG2cRERRRHQ9EcVoj28CcDUAsxDiOIDNAH4Dtc55u7ZPDAAHgFMAFCJ6DGpmOJD3ADyivYZdAbgz00TUm4iuISKT9prVAnCF8vwYY4yxtoqDYebpLqgf9edDnSj2AYCkgEc0NIHq9xmuIqKOHo+vAbAVwM8APoE68c1bLNRgswxqGUApgAXaY7+DGiAfhFrz/DbUiWzQjlkPYAeAbaibGNhUz28BgPuIqKMQYgvUOuIl2rn2A7hb31EIsRdAFdQgGEKICm3M/9WCemhj/RzAXu15WhC8FOVxbd9DUIP7NzweMwF4GmoGvQRARwCPNOL5McYYY20OCdEUn3wzFhwRCQC9hBD7W3osjDHGGGMAZ4YZY4wxxlgbxsEwY4wxxhhrs7hMgjHGGGOMtVmcGWaMMcYYY20WB8OMMcYYY6zNuqBXoGvfvr1ITU1t6WEwxi4yW7duPS2E6NDS42CMMRZ+F3QwnJqaii1btrT0MBhjFxkiOhJ8L8YYYxcDLpNgjDHGGGNtFgfDjDHGGGOszeJgmDHGGGOMtVkcDDPGGGOMsTaLg2HGGGOMMdZmcTDMGGOMMcbarLAGw0R0mIh2EdHPRLRF25ZARF8Q0T7t33htOxHRYiLaT0Q7iejScI6NMcYYY4yx5sgMXy2EuEQIkaPdnwvgSyFELwBfavcBYCSAXtrXfQD+0QxjY4wxxhhjbVhLlEncCGCFdnsFgJs8tq8Uqu8BtCOipBYYH2OMMcYYayPCvQKdAPBvIhIAXhFCLAXQSQhRrD1eAqCTdjsZwDGPY49r24rBGLugCCHwWW4Jymvt530ugyzh+n5JMBvlJhgZY4wxVl+4g+ErhBCFRNQRwBdEtNvzQSGE0ALlkBHRfVDLKJCSktJ0I2WMNZkDp6rw4Fvbmux8hWU1mPE/GU12PsYYY0wX1mBYCFGo/XuSiD4CMBjACSJKEkIUa2UQJ7XdCwF08zi8q7bN+5xLASwFgJycnEYF0oyx5lFldQIAru/fGQO7xZ/XuV75+iDW7SoOGgx/f7AUs9/fAbvTBQD4Zc9EvHDrwPO6NmOMsYtf2IJhIooCIAkhKrXbIwA8AeBjAJMAPK39u0Y75GMADxHRvwAMAVDuUU7BGLuAWO1qMNwxxoTUxKjzOle/LrH4Zn8pLHYnIgz+SyW2HS3D8bJaDOgWh6IyCzbuPhn0GMYYYyycE+g6AfiGiHYA+BHAJ0KIz6EGwcOJaB+A/9HuA8CnAA4C2A/gVQAPhnFsjLEwsmnZWVk6/18x8VFG2JwunKmyBdyv2uqARMCkX3ZHv+Q4OF0CThd/eMQYYyywsGWGhRAHAQzwsb0UwK99bBcAfhuu8TDGmo/VrgbDBonO+1yxEQYAQEmFBV3izX73q7aqWWBFliBLBKdLwCU4GGaMMRYYr0DHGGtyembYKJ9/iUKsuS4YDqTS4oBJkSAReQTD5315xhhjF7lwd5NgjF2gPt5RhL0llYgyKZhyRQ8YldD/drY61JphRW6KzLD6a+pEeeBguNrqgEmRIUsERdaCYZfrvK/PGGPs4sbBMGPMp4c/2AGLVu6Q1iEKI/p0DvlYm0Mrk2iCYDhOywz/98Bp3HNFD7/7VdscMGqZYUUiCAAOTg0zxhgLgsskGGMNCCFgsbuQ1kHtBHG6ytqo4/VguDHZZH+itczwhoKTOFPtfxyVFgeMCkEiQNZqla0OzgwzxhgLjINhxlgDehAZZVID0Wqr45yON8jn/ytGkSSM6q+uzH68rNbvflVamQQRQdG6WNgdnBlmjDEWGJdJMMYa0LtBmLUevTVa3+CQj2/CYBgAkuLULhKVlvpBucXuxEv/OYAaqwP7T1ZhYEo7AICiZYZtjsaNmzHGWNvDwTBjrAF9ApzZqAXDtnMNhs+/ZhgAIgxqUO0dDG87WobFX+6D3sGtVlv5zl0m4eQyCcYYY4FxmQRjrAF3mYQWDNc2Mhi2OVxQJGqSRTcAuFeRq7DY623Xx3XTJckAACfUsghZC8LtHAwzxhgLgoNhxi4wu0sqMOK5TSgLMJnsfFm0sgg9CD2nYFgmNMGaG/XGUVFbfxU6vdtFt4RIPHhVGm4e2BVAXZkET6BjjDEWDAfDjF1gnvl8D/aerML7W4+H7Rp6EBlhkEAE1Da6ZtgJRZJAaJpoWK9drqxtWDMMACaZcGlKPNI6RgOAewKdjYNhxhhjQXAwzNgFpqzGFnyn81S3aIYEoyy5g85QNX1mWP1VVe49gU4bp0Gpv9KdXjNsd3I3CcYYY4FxMMzYBeZsjVo3a2lk6UJj6OUHCqnBsN5dIlRWrWaYqKkm0KnBrneLN32cJqX+dRR3MMzdJBhjjAXGwTBjF5gz1WpmuLqR2drGsLozrgSjIrkzsKFSJ9CpJRZNQZ2MR6hqEAyr4zL6yQzbuM8wY4yxIDgYZuwCU2NTA8KKWnuQPc+dngk2yhKMitToiWg2pwuyRE0WDBMRTIrUIDNstTtBAIyy78ywjbtJMMYYC4KDYcYuIDaHy10HW2Vp3KpwjaEHvyblXMsknJAlgtREE+gAdRKd9+IfFocLBlmC5NXCTW+tZmvkuBljjLU9vOgGYxcQz8lzlY1cIrkx9PIDg5YZttidqNR6/BoVCSavsgRvVrteM9x0Y4owSA1avFnsThh8TNRzd5PgmmHGGGNBcDDM2AXkdFVdb+HqZsgMGxUJZqOMfSer0O+v/wagZos3zhqG5PhIv8dbHGqQ2lQT6AB1Ep13Vws1GJYgkZ8yCW6txhhjLAgOhhm7gJRW1WWGq2zhDIb1iWkSxg3siuQ4M0DAqUorthwpQ25hReBg2O6CSWnaKiyzQcbZWjucLuGeIGexqy3cvGNuXo6ZMcZYqDgYZqyF3bdyC87W2vHe/ZcF3ffgqSoAQLRJcbcVCweLxwS6jjFGjBukruxWUFyBLUfKgi7CYbU73Us5N5UIgwxrhRUOlwuyJGvjDJwZdnBmmDHGWBAcDDPWwv6dfwIA6mU8fXG6BP66Nh8AkBBlhN3pghCiSUsRdFaHExLV1d7qDLJ6vzZIVtricEGRmzYzHGGQYXU44fKIby1aP2PvYLguM8yt1RhjjAXG3SQYayUcrsBZTL2VWu/OMYgzG+BwCjhd4Qn2rHa9S0P97UY9GA6WGXY4G7Q7O18RBrXFm+frZLE7fZZJ6EG8ncskGGOMBcGZYcZaCYdTwBTgJ7JcC4b7dYnF4dIaOFwuhCkWhlVvWeYVZRq0ld5qbIGDTLWbRNNnhm0OFxxOFz7Yehwl5bU4dqYG0SalYZmEzBPoGGOMhYaDYcZaiWBZTD0YjjDIMMgSHE4BlwhPNOzOuHptr8sM+y+TEEKoyzE3cWbYbJAhABw4VY3Z7+9wb7+sZ0KDfWVedIMxxliIOBhmrJWotjnRzn+DBncwbDbKMMgEhyt8wbBVr8X1qmHWa4YDTd7T27IZwlAzDAC7CssBALf9ohsGdY+H0UfXCj0YdnAwzBhjLAiuGWasBXl+jF9eawuwZ10wHGnUM8Ou8NUMO9QuDQ0yw4oeDPuvGdaDYSXAZMBzEaFdO1cLhrsnRqFdpBGRxoZ/00ukLsRh5wl0jDHGguBgmLEWVO2xilxFbeAODXowHG1U1GDYJcJWM2yxu9TllL1rhuUQgmHtsabuJpHaPgoEYO2OYhgVteVbILJEPIGOMcZYUBwMM9aCqjyC4Uot2PVHD4ZjzAZ3mYQzTMGe1eGE7GM5ZTVAVlua+T82PJnhTrERGHdpMjrEGJHTPR5mHxlhT4pEnBlmjDEWFNcMM9aCPIPh8iDLK1fU2mGQCRGKXJehdQRucXau1G4QvpdTNshSwMyw/lhT1wwDwG/6JmFEn84A0CBr7U2WpKDt6hhjjDEOhhlrQacqre7b5UEyw6cqrYgxGSBL5O7UEKzf77myaDXDvhhkKWDLMndmuIm7SeiCBcE6RSI4ODPMGGMsCC6TYKwFPfzBTvftorKagPseL6tFXKQBBoXqMsNB+v2eK4vdf2s0g0ywBshIW9w1w+EJhkPFNcOMMcZCwcEwYy3IJQTizAaYDTL2n6oOuO+xshrEmQ1QJCmkiWznw+pw+l00w6iEmBlu4kU3GkuROTPMGGMsOA6GGWtBVocLmZ1jkNzOjKNn/GeGbQ4XTlRYEB9pAKBmZ/XjwzUug5/MrjFImURdzXALZ4ZJnWTIGGOMBcLBMGMtyGJ3wqhI6NIuAiXlFtj9lB8cL6uBSwDxkWo7sVAWvzgfVrsLBj+ZXYMiwebwH2S2qswwT6BjjDEWBAfDjLUQl0toGVgJXdqZUWt34lhZrc99tx09CwDoGm8GUBcM14arm4TD6bfm1yhLsLtcEH5Wv9Mzw8aWzgxLEpdJMMYYC4qDYcZaSK1H0NglTg1yc4sqfO675fAZRBpldEtQ12vWSxAstsDt2M6FyyVgd4oAE+gk2J0uvwt+6JlhoyI3+dgaQ5G4TIIxxlhwHAwz1kJqPfrxdmkXAQAoKCr3uW9RuQWJUUZEmxT3Meo5mr4MwKZ1YPBXJmGU1Yyrq5VnhhWZ4OQyCcYYY0FwMMxYC6m11QXDMRHqxLhTVTaf+1rt6opw+qpueqAajm4SwVqjGRS1ZZnTT9a19WSGJThdaqabMcYY84eDYcZaiOdKbRIBBPjti2t1uKDIkntFOD1QDUcwHGwCnFGWYA8lM6y0cGZYIjhd/sfJGGOMARwMM9Ziaj1akBGRukiEn5ZlVrvTnRVWjwlfNwmrdk5/rdEMsgRHkJphWSLILdxNQpYITiHAoTBjjLFAOBhmrIW4yyS0DKosEex+alwtjvorwtX1GQ5DmYR2TjnAcsx2l/BfJmF3wahlu1uSzJlhxhhjIeBgmLEWUtdNQq2tVZcP9leHW39FOHdmOAyLbuiZYcVPNGtUJDhdAg4/JR0WrS2bRK2jTIJjYcYYY4GEPRgmIpmIthPROu1+DyL6gYj2E9G7RGTUtpu0+/u1x1PDPTbGWlJdba36Y6hIFKRmuGGZhO0ca4bf++kYnvwkHzuOnfVxrSAT6LTttX6ubbW7tDrolu4mIXFmmDHGWFDNkRmeAaDA4/58AIuEEOkAygBM0bZPAVCmbV+k7cfYRatGK5MwacGwLJHfRSJsjvorwrkn0J1DZlgIgUc+2oVXNx/C/M93N3hcn0AXqLUaUFfm4c3icMIgEVo4FnaXSXAszBhjLJCwBsNE1BXA9QCWafcJwDUAPtB2WQHgJu32jdp9aI//mqil304ZCx89s2rSWpApkuR3kQirvX5mWNIm3NnOIRi22OvaopXVNGzlFqwbRF2PY/+ZYaU1ZIa5ZpgxxlgIwp0Zfh7AwwD0d+xEAGeFEPqyWccBJGu3kwEcAwDt8XJtf8YuSnoga1Lq2qX5qsMVQsDmdDUoWzDI5M7iNka1x6p1vjLRdZlh332CDUrgHsdqfTO1jgl0QvjtesEYY4wBYQyGiegGACeFEFub+Lz3EdEWItpy6tSppjw1Y81KD4YVua5mOHBwWv/H1SBJIWeGhRAorbICAGqsdUGsrxplvWbYX2ZYL5Oo8VMmYbW7IGvt4lqSOzPMq9AxxhgLIJyZ4csBjCaiwwD+BbU84gUA7YhI0fbpCqBQu10IoBsAaI/HASj1PqkQYqkQIkcIkdOhQ4cwDp+x8NIDUb1rg7/WanWLYNQPLhXZ/4Q7b3NX7cKgv23A8bIaVFk9MsMu0WCFNou7z7C/1mpavXKAmuHWkhkGAJufOmzGGGMMCGMwLIR4RAjRVQiRCuBWABuFEHcA+ArAzdpukwCs0W5/rN2H9vhGIbjYj1289CBND3IV2XfNsNXd99e7TCL0zPC7W44BAHYdL0eNViZhlCU4fKwkZ7XXn9jnTe9+4a9m2KItENLymWF1nP4WMmGMMcaAlukzPAfATCLaD7Um+DVt+2sAErXtMwHMbYGxMdZsbA6XmkGV6sokfC1k4V4RzrtMQpZCzgzrKix2VGsZ3UijDIer4Upy7rIMP8FwXY9jf8Gwy29WuTkp7oVJOBhmjDHmnxJ8l/MnhPgPgP9otw8CGOxjHwuA8c0xHsZaA7s2KU4vJ6ircRWQPGoM9GCuYWaYYAshGPb8gOVMtQ2xEQYAQJRJRpXV2TAzrF3P6CegrWut5q8nshOyZAw6rnBzl0mEYZU+xhhjF4+WT98w1kbZHC7IEoGglUlIvheJ0MskvDPDRlnyu2KdJ8/Si7M1dnfNcJRR0TLD3jXDTshE7ol93gzuMgmHz8dbTWaYa4YZY4yFoOXfsRhro+xOFxRJci9O4V4kwms/9wQ6HzXDDqcLwUrrPeuKz9bY3F0goiIUOJyiQWmGvtqdvwlwBu0Bz64U3tcz+Fm9rjnVTaDjMgnGGGP+cTDMWAtxZ4a9guGGE9r0mmEfwbCrYTDrzbNmtrzW4e4zHG1S1G4SDWqGnQGXU9Yn0PmqGRZCqBPoWkVmWJtAx8EwY4yxAFr+HYuxNsrm1CbQUd2iG76WD67rJlH/x1VdpCP4ohKemeEKix01VieIgEiDDKdLwOnVzk0tc/C/nLJ7Ap29YZBpd6qZbe82cC1BzwxbfYyTMcYY0zXLBDrGWEN2p14zrFLcK6b5ntDmKzNs91Hz680zGP72QCkSoowwylJdizSbE4iqfz3PIN2bMcByzHq2uFXUDGulGpwZZowxFkjLv2Mx1kbZHC414PSuGfbT6sy7u4PiZ39vemY5wqAev+VwGQyy5D6fd4bXandCliW/mWFJIsgS+VyOWc/CtobMsHsCHbdWY4wxFgAHw4y1ELtT1C+T8NdNwq4vj9ywTMLX/t70YPqynokAgCqrHYpM7q4Q3rW/7sww/Ae0Bpl8Bpl6gNwaaoZ5Ah1jjLFQtPw7FmNtlM3hgiS5E8MeE+jq7+cuk2iQGfYdPHvTjzcbZQBAtVVdIa4uM1w/GK5bQc7/OQ2y5LMWt26sLZ8Z1oNhXoGOMcZYIBwMM9ZCbO7WavUn0Lm8JrTpGVijUj/AlCXy2Q2iwXW04yO0TLA6wU1yB6wNyiS01mqBllM2ypLPld3cmWGp5X+16GOwcmaYMcZYAC3/jsVYG6W3VtMpEkEAsPvo+wsARkWut91f8NzgOlowGGGomy8rSx5lEj4yw94LfHhTZPIZZPrridwS6mqGeQU6xhhj/nEwzFgzOlJajaKztQDUINUzGPbXCsy9Ap1XgBnqCmt6zbHZUPfjrkiECEUvm6i/kpzFEbxPsFGWfAaZ7vrmVhAM1y3HzCvQMcYY84+DYcaa0bAF/8HQpzcCUGtZPYNhg5+WZfqENpka1gyrjwfOfOqZYbOxfmY4Uqshrqi119/f7graDcKoSD5rcfXMsNwayiS0gDzY68MYY6xta/l3LMbaICGEe9ENnT6hzTt4s2qLYHjHl3XBXuAyCT3TXC8zLBOiTGpwfKamfjCs1wwHYpQln10aLH46X7QE/Y+FYJlzxhhjbVvLv2Mx1gY5XaJBmYQ7M2zzzgyrZQsE32USwbol6EGrQa6bNKdIkjszXF5r87qeK+iiGQZFgt0p4PJX39yKWqs5eAIdY4yxAFr+HYuxNsjhErB7ZYbrujv46fvrlaytK5MIEgzr7c4UyX2MIhPMBj0Y9qoZ1lqrBWKUJTicAs4Gq+W1wpphDoYZY4wFwMEwYy3A4RJaN4m6H8G67g6+Wp1JDVqdyaGWSbgDVAkGRc8MExRtFbpKS12ZhNMl4HCJoBPoIgwyamwOOL0yw/rYjQbZ12HNqi5zzmUSjDHG/ONgmLEWYLE7YPOqzdXbmTXIDPtZBMMQ4nLDNo+FMPRr6BniCIOEKovD576BdI03o9rmxJHS6vpj9Qi8W5o7GObMMGOMsQBa/h2LsTbCM4t6otwKlwBMHkFj8DKJhotuAKEHw4pE7lpgPQiPNCqo8mitFuqiGd0TIgEA246crT9We+urGQ72+jDGGGvbWv4di7E2wrNLRHG5BUD9rgt1rdUa9hmWfWSG9VIGmzNw6zB1QhxBkjwn0OnBsIwajwl7oS6akRxvBgDkF1fU225zukCEoDXHzYGIIEsEe5BFSRhjjLVtHAwz1kw8F9MoKlcX3jApvmqGG7ZWU2SpQWZYCXFRCTWzLEGiugDaOxgW2kQ49wIfQYJZs0GGREBZjY9OFBJBagXBMKAtWc2t1RhjjAXAwTBjzaS0ui5wPFGhZ4brJprpWdsaP2US3vRtoSy6ocgE8mjOpgfFkUYFFrsTDpceDLvqPe4PESHSqKDca8EOq93pM3BvKTIR1wwzxhgLiINhxprJ/zy3yX37dKUaGPsqk7A1CIad9foR6/RuEqHUDOsT8PQYVfbIDNfanXA4BXaXVGDK8p8AhFbmEGWSG65epwferSMWhiIR7JwZZowxFgAHw4y1gNPVVgBeZRKy79ZqdqfwGZwaQlyOua41W10QrGduI40yLHYnbE4nfjpchmNltRjYLQ5pHaODPodoU/3Jd4BW0iG1osywTHBwzTBjjLEAOBhmrAWUaSUTZkPDMgmLV3Br91qpTqdvs9oDZz5tDqe7G8Wo/l0woGscsrvEqNc3ynAJoMrixMkKC4iA2wZ3R7f4yKDPIcqkoMbmrNclw+qRhW4NFK4ZZowxFoTS0gNgrC3wXhK4rEYtL4gwBM8Mey/brFPcZRJBaoYd6vEEICspFllJse7HIo2KNh4rTlRYEBthqDemQKJNCo6U1mjBuhrUWz0C79ZAkTgzzBhjLDDODDPWDLyXBNa7MEQa6zLDktYKzLvswXvZZp17OeYgmU+bU8/WNjyHnpkuq7HjZKUVMRGKOygPJsqooNburPfcrHrg3TpiYciSxJlhxhhjAXEwzFgzsHple/WJZxGG+h/OGGRqMCHO7hC+M8NSaJlhq90FyU+AqgfjWw6X4dCpakSblJB7BEeZZNgcLtR41A3rwXBryQzLErk7ZTDGGGO+cDDMWDOwegW4LqEGs94rtRkkqcG+/mqGzVogW2lxNHjMky1AgKoHwy98uQ9HztQgPtLgM4PsS5RWYnHGo2Wc1e4MObPcHBSZa4YZY4wF1nretRi7iOmlD0lxEe7ShGiT0iDINShSvcywEAIOl4DsI0A1yBJiIxQUna0NfG0/ZRZAXUANAINT43AcFT8AACAASURBVHHTJcmhPSGoE+iA+v2T/fVEbilcM8wYYywYDoYZawZ6gHtlRgf3BLVIk9xg2WODXH+RCL1Hrq/MMAC0jzbhRKU16LX1+mJvnpnpznFmJEabgjyTOlEmrd7YKxiWgyzl3JwUSYJTCLi4VIIxxpgfHAwz1gzcK7tJdQttmA1yw8ywXL9MQg+MAwXDpVXWBt0q6l3b7vSbrfVcac7QyCBWzwyXVdctvGF1ON39j1sDRSI4XQIcCjPGGPOn9bxrMXYR08skFFlyL7QRaVQa1PE2zAyrtyU/wWxitBHltXbU2PzXDduc/rO1nplhf9ljf/SaYX0BEUBbdKMVZYZlWQ2GXYLDYcYYY75xMMxYM9C7SRgkCUZFLS/wbKumM8gS7I66wM0WJDNsUiS4BFBr958ZtgWo4/XMBisNhxNQtJ4Zrqkrk1DbuLWeXyt6ZpiDYcYYY/60nnctxi5iVqdeJkEwSHVLIXszyhLsroY1w4qfDg9654ZASzLbnC6/pQueQXZjg9gIgwSJgPKaujKJQIF3S5D1MgmOhRljjPnBwTBjzcCdGVbqWpz5zQw7Xe4JX3ZH4Mywe0lmh+/MsBACVrvv1mwA6rVRa2x5AxHBbJBRobV2E0Ko3SRaUZmEPoGOg2HGGGP+8HLMjDUDPXNrlGWMGZiM9jEmXNotvsF+BlldMc0lBCTUtQWT/WRt9cyw90IdOoc2eSyUAPVcJr4ZFQkWu/rc3FnsVpgZ5jIJxhhj/nAwzFgz0DO3BpmQ2j4Kqe2jfO5nkNUV05xCQAFgcwRurebODNt9l0nYHHXlGcEYlMYHsREG2R0M6wG/v8C9JTRlzfDWrVs7KoqyDEBf8KdqjDF2oXAByHU4HFMHDRp00tcOHAwz1gxs7mA4cAyll0nosVuw1mp6/bHVzyprdcFw8NjNKDdyBh3UCXwWrQTE3T6uVZVJNF1rNUVRlnXu3DmrQ4cOZZIkcaqZMcYuAC6Xi06dOpVdUlKyDMBoX/twdoOxMFv85T48ujoXABosv+zNoEhweGQy64Jh3/vrfYL9ZYb1ADWUhTAa22cYAEyKDItDzwyHnoVuLnprNdE0i9D17dChQwUHwowxduGQJEl06NChHOqner73acbxMNYmPffFXvdtgxIsM0xwOF1wahPobM7AmV09Y+yvZrgxZRLGIGPzJcKgLh/tdIm6awUJ+JuTTASXQFMtySxxIMwYYxce7Xe33zen1vOuxVgbYAySfTXIat9gPQgOthyzns31103C5tQW+wihTCJYCYcvJkV2B8PuhUVaUWZYCTLBkDHGGAtbMExEEUT0IxHtIKI8Inpc296DiH4gov1E9C4RGbXtJu3+fu3x1HCNjbGWYjIErsvVyygsNq1DQ8it1QKXSYSUGT6nYFiCTctk6+3jWlvNMIB6vZsvZLIsD8rMzMzWv/70pz91Duf13nrrrbhwX0O3ePHixPj4+AGZmZnZPXr06PP44493PNdz7dmzx9irV68+TTW2devWxcTExFyiv+5Dhw7NAICZM2d26dixY3/P78np06dl7/0zMzOzV69eHQPUfQ/T09P79O7dO3vevHmdnE7fP7+rVq2K1Y+PjIwcmJqa2jczMzN72LBh6cnJyf2OHj3qnvdz5513pjzyyCOdPa/ds2fPPrNmzUry9Rw8x+TLnDlzOqenp/fJyMjIzszMzN64cWPU8OHD0zIzM7NTUlL6ep7riy++iAKA4uJiRVGUS5955pkO+nn69++fmZmZmZ2UlNRP//5mZmZm79mzx5icnNxPP39mZmb23Xff3S3Q90H/P5KVlZXdvXv3vldccUUv/doA4HK58PDDDyd17969b2pqat9f/OIXvX/44Qez/nhycnK/a6+9Nk2///rrr8ePGzcuNdTv9zPPPNNhyZIliYHGGApf/z9//PFHs369uLi4S5KTk/t5XjtcPv7445gvv/zS/Ro+9dRTHf7xj38khPOarVE4J9BZAVwjhKgiIgOAb4joMwAzASwSQvyLiF4GMAXAP7R/y4QQ6UR0K4D5ACaEcXyMNStFouA1w9rjte52ZXUr1wXa3+ZnBTpbuGuG9TIJIYKWdLSEYH2YLzQmk8m1e/fu/Oa4lt1uxx133FEOoLw5rgcAo0aNKlu5cuXRkpISOSsrq+8dd9xRlp6ebg9+ZPjl5ORUffXVV/u9t0+bNu3EE088cSLU/T2/h4WFhcr48eN7VlRUyIsWLSry3nfcuHEV48aNyweAwYMH9164cOGxK6+8sgZQA7Pf/e533dasWXPom2++ifzhhx+ily1bVvDFF19E69euqKiQ+vXrlz1mzJjyQGPytmHDhqj169e327VrV77ZbBbFxcWK1WqlL7744gCgBovPPvtsJ+9zrVy5Mn7AgAHV77//fsLDDz98CgB27ty5G1AD2S1btkStXLnyqOcxmzZt2puUlOR/PXkv+v8RAFi7dm3Mbbfdlv7vf/97z6WXXmp5+umnO/zwww9Rubm5+TExMa4PP/wwduzYsekFBQV5sbGxLgDIzc2N3Lp1a8SgQYMsga7j67XSn1M4DB48uFb/fzFu3LjUG264ofyee+4pC/V4l8sFIQTkRk6E3rBhQ0z79u0dv/71r6sB4JFHHgnbc2zNwhYMCyEEgCrtrkH7EgCuAXC7tn0FgL9CDYZv1G4DwAcAlhARaedh7IKkL54BAB1jTPUWufBFz6rqHRrcAaafQFXPfFqCZIb9ZZY9SecQxOplEg6Hy2PJ6VaYGW7iYPiPH+zotrekMrIpz5nROaZmwc0DjjX2uNLSUnnQoEFZa9as2TdgwADrqFGjelx11VWVs2bNOh0ZGTnwtttuO71p06bYDh062FetWnWwS5cujry8PNO0adNSzpw5o0RERLiWLVt2ZODAgZZx48almkwmV25ubuTgwYOr+vfvX6sHMEVFRco999zTvbCw0AgAzz333NERI0ZUz5w5s8uxY8eMR44cMRUVFRmnTZt24tFHHz0JAEuWLElcvHhxJyJCVlZW7erVqw/5O4/nc+rcubMzJSXFeuzYMUN6ero90LUPHjxoOnz4sKmsrEyZPn16yaxZs057nmvPnj3G22+/vUdtba0EAC+88MLR4cOHV48ZMyZ17NixZ++8886zADB69Oget9xyS9nEiRPPnsv371wkJyc7li1bdnjo0KHZzz77bFFjfgZnzZp16u23305cu3ZtzF/+8pfkF1544ajJZKr3fhkbG+vq169fze7du02dO3cOOeAsLCw0JCQkOMxmswCAUIPV999/P2HhwoXHJk2a1PPAgQOGtLS0sP4hM2rUqMqJEyee+vvf/97htddeO7Z48eKkjRs37o6JiXEBwNixYytWrlxZtXTp0oTZs2efBoAHH3zwxOOPP5708ccfH2rs9WbOnNklOjra+Ze//OXEwIEDs55++unjN9xwQ+Vvf/vbZEmS8OKLLxZu3rw5cubMmd1qamqk+Ph4x1tvvXW4e/fu9s2bN0dOnTo1FQCuuuqqisZc98yZM9J1112XXlFRITscDnr88ccLb7vttvLc3FzTjTfemN6nT5+avLy8yA0bNuz94IMP4v7+9793jo2NdWRlZdVGRUW5/vnPfx47duyYMmXKlO5FRUVGIsLzzz9/tHPnzo633367gyRJ4u23327/4osvHlm7dm1c+/btHY899tjJQYMG9R4yZEjV5s2bYysrK+VXX3310PDhw6srKiqk8ePH99i/f39Er169ao8fP25aunTp4aFDh9Y29jVtLcKawiEimYh+BnASwBcADgA4K4TQf7COA0jWbicDOAYA2uPlAM774wjGWlKltjpbUlwEbh+SEnT/hpnhwAtZ6FlYvR+xN3dLt1CC4XOIYU2KBAGgxu50l2oEmyTYnPTX52LJDFutVsnzY+5XX301PjEx0blo0aKjkyZN6rF06dL4s2fPKnpAWFtbK+Xk5FTv378/7/LLL6+cO3duFwCYOnVq95deeuloXl5ewYIFC44/8MAD7v+cxcXFxm3btu1etmzZcc9r33///d1mzpx5Ijc3t+Cjjz46MG3atFT9sf3790ds2rRp708//VSwcOHCLlarlbZs2RKxcOHCpE2bNu3ds2dP/iuvvHI02Hl0+/btM1qtVmnIkCG1wY4pKCgwf/PNN3u+//773QsWLOhy+PBhg+e5unTp4ti8efPe/Pz8gnfffffgH/7whxTtNTi9YsWKRED9g2Lr1q3REyZM8BsIb9myJVp/3efMmeMuHXn55Zc76duHDBmS4Wv/zMzM7Ly8PJOv82ZnZ9ucTicKCwsblZySZRkvvfTSkYkTJ6alpaVZRo4cWeW9T0lJibx9+/aoSy65pLYxY7rpppsqioqKjKmpqX0nTpyY8sknn0QHG8/+/fsNp06dMlx99dU1o0ePLlu5cmVIH7UPGzYsQx/PuZTGDBo0qGbfvn0RZ86ckWpra6Xs7Gyb1+PV+fn57lKJu+6660xubm5kbm6uz+eu8/f9BgCDwYDly5cfmj59esrq1atjNm7cGLdgwYIiq9VK06dPT1mzZs2BvLy8gkmTJp2ePXt2MgBMmTIl9fnnnz+6Z8+eRn+yExUVJT799NP9+fn5BV999dXeuXPnustJDh06FDF79uwTBw4cyHM6nXj++eeTfvrpp4Iff/xxz969e93Pe9q0aSlz5swpyc3NLfjggw8OTJs2LbVPnz7W22+//dRDDz1Usnv37vzhw4dXe19bCIFdu3YVPPnkk8eeeOKJLgDw9NNPd+zYsaP9wIEDefPmzSsuKCho0sRASwhrn2EhhBPAJUTUDsBHADLP95xEdB+A+wAgJSV4cMFYSzpTo/5evjwtEZmdY4Pu764Z9iqT8JfZVeTANcN1ZRL+A9T+XeOw83i5e5noxjBpgW+lxe4OOM+l9jhc9NdNfx2byrlkcJuCvzKJMWPGVLz33nvxDz/8cPetW7fm6dslScLUqVPPAMDkyZNLx44dm15eXi5t3749evz48e7aSZvN5v7mjx07tkxRGr41/Pe//43dt2+f+821qqpKLi8vlwBgxIgRZ81mszCbzY6EhAT78ePHlfXr18eOGjWqTM8qdurUyRnsPGvXro3PyMiIPnToUMRTTz11NDIyUgQ7ZuTIkWejo6NFdHS047LLLqvYvHlz1ODBg2s8n9uUKVO65+fnmyVJwpEjR0wAcP3111fNmDGje1FRkfLmm2/GX3/99WUGQ704up6mKpNoSkOHDq3t1atX7UMPPVRvIYEtW7ZEZ2VlZUuSJGbMmFGSk5NjWbdunSHUMcXFxblyc3PzP//885gvv/wyZtKkSWmPPfbY8enTp5f6O2blypUJo0ePLgOAO++888yUKVNSH3/88Qavi7fGlkl4a+yHx4qiYPr06SVPPPFE55EjR/rN0AZ7rXJyciy33HJL6YQJE3pt3LixICIiQvz0008R+/btM19zzTUZgFq60KFDB/vp06flyspKWf+DZfLkyaUbN26MC3XMQghMnz69648//hgtSRJKSkqMxcXFCgB069bNqpfObN68Ofryyy+v6NChgxMAbrzxxrKjR48aAfVn6MCBAxH6OcvLy+Wqqqqgv/THjx9/FgCGDh1a8+ijjxoB4LvvvoueM2dOCQBcdtlltWlpaRdsRljXLItuCCHOEtFXAC4D0I6IFC372xVAobZbIYBuAI4TkQIgDkCDHzwhxFIASwEgJyeHSyhYq1Zeq35KaDaGVsdlcJdJaL17tX/9tT2rK5Pw100ieGb4oavTUW11uAPbxojQJgRWWZwhLyzSnDI6ReO2wd3QLtLY0kMJK6fTib1790ZERES4SktLFX8fTxMRnE4nYmJiHP5qj6Ojo33+ZxJCYNu2bQV6gOrJ8+N5WZbhcDj8/ocLdB69HvTrr7+OHDVqVMYtt9xyNiUlxRHoGO/SI+/7Tz75ZKeOHTvaV61adcjlcsFsNg/SH5swYULpq6++mrBq1aqE119//bC/MYdTfn6+UZZlJCcnn1NAKElSgzrRpgjEFUXBDTfcUHnDDTdU9u/fv/aNN95IDBQMr1q1KuHUqVOGDz/8MAEATp48adi1a5epX79+1vMZRzDbtm2LzMjIqE1ISHCZzWZXfn6+0TM7vG3btsjhw4fXC3ofeOCBM4sWLUrq06fPeQVxeXl55piYGGdJSYkBQK0QgtLT02t//vnn3Z77nT59uvErGnl46aWXEisqKuS8vLx8g8GATp069a+pqSEAMJvNIf2lL4TAzz//XBAREdGouCkiIsIFALIsC6fT2Xpq4JpYOLtJdNAywiAiM4DhAAoAfAXgZm23SQDWaLc/1u5De3wj1wuzC12VViYRaqBpcGeG1d9vepDrNxgO0jrMXboQIECViBATYQhaz+xLpBbkl9XYPMokWs/vy8RoE/p0iUOU6eJebPOJJ57olJGRYVm+fPnByZMnp1qtVgLUzNTrr78eDwDLly9PHDx4cGVCQoKra9eutn/+85/x+j7fffedOdD5AeCKK66oeOqpp9wfY3/77bcBj7n22msr1q5dG19SUiIDwIkTJ+RQz3PllVfWjB07tnT+/Pmdgh3z2WeftaupqaGSkhL5+++/j7niiivqfdRbXl4uJyUl2bWygkTPzg3Tpk07/corr3QCgGATqsKhqKhIuffee7vfc889J8+lZj9cduzYYdq1a5e7jGD79u3mrl272vztv3PnTlN1dbV88uTJnYWFhbsKCwt3PfTQQyUrVqwIa1eCTz75JPrNN9/s8OCDD54GgIceeqjkt7/9bYqe8Vy9enXM3r17zXfffXe9iWgmk0k88MADJ15++eVO53rtFStWtCsrK1M2bty4e9asWSmnT5+W+/fvbzlz5oyyYcOGKADQy4Xat2/vjImJca5fvz4aAJYvX96o16W8vFzu0KGDw2Aw4KOPPoo9efKkz48wrrjiiupvv/029vTp07LVaqW1a9e20x+7/PLLK+bPn+/u8qH/DMXExLgqKysbFaz/8pe/rHrnnXfiAbULxsGDB4P+/mjtwvkOkQRgBRHJUIPu94QQ64goH8C/iOhvALYDeE3b/zUAbxDRfgBnANwaxrEx1iwqLXpmOLQfNYNXmYQ+Kc3kJ5hVgiy6UaO1aAvW3/hc6UHm2VpbqyyTuNjoNcP6/Wuuuab8/vvvP/3GG2+037p1a0F8fLzrgw8+qJw7d27SokWLisxms+vHH3+MWrBgQZfExET7hx9+eBAA3nnnnYP33ntv9/nz5yc5HA4aM2bMmcsuuyxglmzp0qXHpk6dmpKRkZHtdDppyJAhlUOHDj3qb/+cnBzLrFmzin/1q19lSpIk+vbtW7Nq1arDoZ5n3rx5JTk5Odl/+9vfigMdk5WVVTN06NDeZWVlyuzZs4tTU1Pte/bscX8U8Pvf//7kuHHj0v71r38lXnPNNeWembRu3bo50tLSLKNGjTrnSXMvv/xyp/fee889v2XNmjX7gbqaU337nDlziu+5554y/XvocDhIlmUxYcKE0nnz5gUtJ2gK/sbkvV9FRYU8ffr0lIqKClmWZZGammpdsWLFEX/nXbFiRcJ1111X7zy33npr2W233dZz4cKFxYHGNGzYsAz9D4GsrKyajz766HCg/deuXRufmZkZbbFYpK5du1rffvvt/ZdeeqkFAP70pz+dPHv2rNynT58+DoeD7HY77dq1K8/XJwozZsw4/dxzzyUFupY/xcXFyrx587pu2LBhT3p6un3q1Kkn77vvvm4ffvjh4X/9618Hpk+fnlJZWSk7nU564IEHTuTk5Fhee+21w1OnTk0lokZPoLvvvvtKR44cmZ6RkZF9ySWXVHfv3t1ntr1Xr1623/3udyWDBg3KiouLc6SlpVni4uKcALBs2bKjkydPTsnIyGjvdDpp6NChlUOHDj168803n50wYULPdevWxS9evNjv99jT3LlzT44fP75HWlpan169etX27NmzNiEhwXet3gWCLuTka05OjtiyZUtLD4Mxv9776RgeXrUTc67tjV6d/Lb0dDtSWo3//aQA/3tjH9x5WSrmf74bS78+iGdvHoDoiIYBtdXuxG/f2Y4JOd0w/+b+9R7bf7IS//Pc1wCAx67PRkpi089xKCyrxby1efjTdZmQiPC3Twrwfzf1RcfYiOAHN5OSCguuzuyI5HahJy+IaKsQIsdz244dOw4PGDDgtL9jWqPIyMiBNTU121t6HOGiz+73VbMbisrKSik7Ozv7559/LkhMTLyg38xZfeXl5dLIkSPTLr300polS5YUBj/i4lBeXi7FxcW5rFYrjRgxIu3+++8/dfvttzdpe0S73Q673U6RkZFi165dpt/85jcZhw8f3hWo5r412LFjR/sBAwak+nospHQVEaUBOC6EsBLRVQD6A1gphGi2FjSMXYgqrWqZRKQp1Jrh+mUSVrsLBpng7xNUd5mEjwliPxw6U3feMJUu6M/rTLUNMRHqL8Jz6VfMWHNbvXp1zIMPPpg6bdq0ExwIX3zi4uJc33777b6WHkdzmzlzZvK3334bY7Va6eqrr6649dZbm7xPeHl5uTxs2LAMh8NBQgi8+OKLR1p7IBxMqGUSqwDkEFE61MlrawC8DeC6cA2MsYuBXiYRaWhcmUSNXQ2iLQ4nDLIEgu8AUyKA4LuPbrW1bj5OuCa1RWnlH2dr7O7yCIXLJFqNizkrDADPPfdcg4UqQnXTTTdV3nTTTbs8t61atSr2z3/+c1fPbd26dbPqi02EU0tcu6SkRL7qqqt6e2//z3/+s6dz5878B8IF6LXXXgt7p5v27ds78/LyCsJ9neYUajDsEkI4iGgMgBeFEC8S0UX9S5axplBlUbs0hNp7191NwlZXM6xI5LcHMBFBkclnZvhERV1ZWbhqho2KBINMKK+1I85sgEGmkBb4YKw18lzxrS1cu3Pnzs7mWtGQsdYs1BSOnYhug9rtYZ227cLOiTPWDCotDkQYZMghdmpo2E1CywwHOF6RJJ99dI+ecbdahUThy9aaDTIqtD7DiiydU79ixhhjrKWE+g55D9QewU8KIQ4RUQ8Ab4RvWIxdHKq0/r2hZkv1Fmqe3SQCZYYBdWEJfaU6T3qPYwAIZ3waZVJQaXGowbDkr6CDMcYYa51CKpMQQuQDmO5x/xCA+eEaFGMXiwqLHSZF8jsBzlvdIhpaMOxwQpEpcGZYJp+ZYc864nAGwxEGCRZtOWZFCjxWxhhjrLUJGAwT0S4AfnuvCSH6+3uMMaZmeBVZCrlMgoigSOTuL2y1uyAHyQwrku9g2LOO2NW0qxHXY5RlWB3qCnSKLIU18GaMMcaaWrB81Q0ARgH4XPu6Q/v6DMCn4R0aYxc+i9YarTHZUoNM7gUsLA4nFCl4zbDD1fBvVpvDhfSOUfjL9Vkht3Y7FyZFgs3p8ijp4Gg4XGRZHpSZmZmtf/3pT3/qHM7rvfXWW3HhvoZu8eLFifHx8QMyMzOze/To0efxxx/vGPwo3/bs2WPs1atXn6Ya27p162JiYmIu0V/3oUOHZgBqn+OOHTv29/yenD59WvbePzMzM3v16tUxQN33MD09vU/v3r2z582b18lzVTxPq1atitWPj4yMHJiamto3MzMze9iwYenJycn9jh496k5o3XnnnSmPPPJIZ89r9+zZs8+sWbOSfD0HzzH5MmfOnM7p6el9MjIysjMzM7M3btwYNXz48LTMzMzslJSUvp7n+uKLL6IAdTEKRVEufeaZZ9wrnfXv3z8zMzMzOykpqZ/+/c3MzMzes2ePMTk5uZ9+/szMzOy77767m/c4PF/j7t279x0xYkTa1q1b3Y3MLRYLTZ48uVtKSkrflJSUvldffXX6vn373IuuENGge++9192l47HHHus0c+bMLiF941mbETAzLIQ4AgBENFwIMdDjoTlEtA3A3HAOjrELnVULZhvDIEvuFeUsdmfQtmgGmeDwVSbhdCEmwoDuiVGNun5jGRUJdqeAxeGELBFnhsPIZDK5mmv2v91uxx133FEOoMn7lPozatSospUrVx4tKSmRs7Ky+t5xxx1l6enp9uBHhl9OTk7VV199td97+7Rp0074WvTD3/6e38PCwkJl/PjxPSsqKuRFixY1aBPn2WFi8ODBvRcuXHjsyiuvrAGAZ555psPvfve7bmvWrDn0zTffRP7www/Ry5YtK/jiiy+i9WtXVFRI/fr1yx4zZkx5oDF527BhQ9T69evb7dq1K99sNovi4mLFarWS3uZt3bp1Mc8++2wn73OtXLkyfsCAAdXvv/9+wsMPP3wKAHbu3LkbUP/Y2bJlS9TKlSvrrTa4adOmvUlJSQ4E4Pkav/rqq/HXXntt7507d+Z16dLFMX369OSqqirp4MGDuYqi4IUXXkgcPXp0em5ubr4syzAajeLTTz+NLy4uLgl2HdZ2hdpajYjociHEf7U7QxH65DvG2iyrw4UIc+OysgZZcmeGQzne3wQ6m9PlrkEOJ6Miwe5wwWp3tp3M8OrfdsPJ/KZd0q9jdg1u+nuje4SWlpbKgwYNylqzZs2+AQMGWEeNGtXjqquuqpw1a9bpyMjIgbfddtvpTZs2xXbo0MG+atWqg126dHHk5eWZpk2blnLmzBklIiLCtWzZsiMDBw60jBs3LtVkMrlyc3MjBw8eXNW/f/9aPYApKipS7rnnnu6FhYVGAHjuueeOjhgxonrmzJldjh07Zjxy5IipqKjIOG3atBOPPvroSQBYsmRJ4uLFizsREbKysmpXr159yN95PJ9T586dnSkpKdZjx44Z0tPT7YGuffDgQdPhw4dNZWVlyvTp00tmzZpVb5XAPXv2GG+//fYetbW1EgC88MILR4cPH149ZsyY1LFjx5698847zwLA6NGje9xyyy1lEydObLbFpJKTkx3Lli07PHTo0Oxnn322SGrEH86zZs069fbbbyeuXbs25i9/+UvyCZfUewAAIABJREFUCy+8cNRkMtX7RRAbG+vq169fze7du02dO3cOORAsLCw0JCQkOMxmswCAUIPI999/P2HhwoXHJk2a1PPAgQOGtLS0Jv9D5t577y379NNP41577bWE3//+96ffe++99gcPHtypKGo4M2PGjNKVK1e2X7NmTezYsWMrZFkWd91116n/+7//6/Tiiy+2mZXoWOOE+pM3GcBLRHSYiA4DeEnbxhgLQC8daAzPvsEWLcAMxCD7L5Nojp6/Rllt7aa2VmsDgXALslqtkufH3K+++mp8YmKic9GiRUcnTZrUY+nSpfFnz55V9ICwtrZWysnJqd6/f3/e5ZdfXjl37twuADB16tTuL7300tG8vLyCBQsWHH/ggQdS9GsUFxcbt23btnvZsmXHPa99//33d5s5c+aJ3Nzcgo8++ujAtGnTUvXH9u/fH7Fp06a9P/30U8HChQu7WK1W2rJlS8TChQuTNm3atHfPnj35r7zyytFg59Ht27fPaLVapSFDhtQGO6agoMD8zTff7Pn+++93L1iwoMvhw4frtf3s0qWLY/PmzXvz8/ML3n333YN/+MMfUrTX4PSKFSsSAfUPiq1bt0ZPmDDBbyC8ZcuWaP11nzNnjrt05OWXX+6kbx8yZEiGr/0zMzOz8/LyTL7Om52dbXM6nSgsLAw1OQUAkGUZL7300pGJEyempaWlWUaOHFnlvU9JSYm8ffv2qEsuuaS2MWO66aabKoqKioypqal9J06cmPLJJ59EBxvP/v37DadOnTJcffXVNaNHjy5buXJlQijPY9iwYRn6eEItjRk4cGDN7t27I/Lz801JSUm2hISEeh+NXXLJJTW5ubnuUoo//vGPJz/88MOE0tLS8NWLsQta0B8+IpIApAshBhBRHAAIIZrtYzPGWoPcwnJEGGQ8/MEO/O+NfdEnOS6k49RuEI37EMUoS7C5u0m4gpZJKJJaY+xyCUgewa/dKZonGHaXSbgaXRJywTqHDG5T8FcmMWbMmIr33nsv/uGHH+6+devWPH27JEmYOnXqGQCYPHly6dixY9PLy8ul7du3R48fPz5N389ms7n/o4wdO7ZMz7J5+u9//xu7b98+s36/qqpKLi8vlwBgxIgRZ81mszCbzY6EhAT78ePHlfXr18eOGjWqTM8qdurUyRnsPGvXro3PyMiIPnToUMRTTz11NDIyUgQ7ZuTIkWejo6NFdHS047LLLqvYvHlz1ODBg91Ntm02G02ZMqV7fn6+WZIkHDlyxAQA119/fdWMGTO6FxUVKW+++Wb89ddfXxZoSdmmKpNoSkOHDq3t1atX7UMPPXTSc/uWLVuis7KysiVJEjNmzCjJycmxrFu3zhDqmOLi4ly5ubn5n3/+ecyXX34ZM2nSpLTHHnvs+PTp00v9HbNy5cqE0aNHlwHAnXfeeWbKlCmpjz/+eIPXxVsoZRLehPA7r9+nhIQE1/jx40uffvrpjmazOYzTidmFKmgwLIRwEdHDAN7jIJi1RV/vPYW7/vkjCGprldkf7MBnM64M6VirwwVDIwNSkyKj1t1Nwulelc4fRZbgcNnhEgISPIPhZiyTcKplEtGmRiW3WBNxOp3Yu3dvREREhKu0tFTx9/E0EcHpdCImJsbhr/Y4OjraZ7AghMC2bdsK9ADVk+fH87Isw+Fw+P2PF+g8es3w119/HTlq1KiMW2655WxKSooj0DHek0u97z/55JOdOnbsaF+1atUhl8sFs9k8SH9swoQJpa+++mrCqlWrEl5//fXD/sYcTvn5+UZZlpGcnHxO9aySJEGW6yc8myIQVxQFN9xwQ+UNN9xQ2b9//9o33ngjMVAwvGrVqoRTp04ZPvzwwwQAOHnypGHXrl2mfv36Wf0dc65+/vnnyEGDBtVkZWVZi4uLjWVlZVJ8fLz7/+2OHTsib7nlljLPYx555JETl156afatt956uuEZWVsXahpnAxHNJqJuRJSgf4V1ZIy1Eh9sVT8t1t+FbY7QEwu2cygdSIw24myNDbU2B2rtLpgMgT/ZU2SC0yXgXSlhdzZfmYSAusAIl0m0jCeeeKJTRkaGZfny5QcnT56carVaCQBcLhdef/31eABYvnx54uDBgysTEhJcXbt2tf3zn/+M1/f57rvvzIHODwBXXHFFxVNPPeX+GPvbb78NeMy1115bsXbt2viSkhIZAE6cOCGHep4rr7yyZuzYsaXz58/vFOyYzz77rF1NTQ2VlJTI33//fcwVV1xRr/64vLxcTkpKsmtlBYmenRumTZt2+pVXXukEAIMGDbIEew2aWlFRkXLvvfd2v+eee042pl443Hbs2GHatWuXu4Ri+/bt5q5du9r87b9z505TdXW1fPLkyZ2FhYW7CgsLdz300EMlK1asaPI4Yfny5e02b94cN3ny5DOxsbGum2+++fQDDzzQzeFQ/5ZYsmRJoslkcg0fPrxe2UinTp2co0aNKnv77bfbN/WY2IUv1J++CQB+C+BrAFu1ry3hGhRjrcXG3Sfw7/ySett8TVbzxeF0weESjS4dSIw2orzWjpIK9b05QgkSDEt6MFw3LiFEs5ZJAEBFraPtlEm0EO+a4QcffDB5x44dpjfeeKP9Sy+9dOw3v/lN1S9/+cvKuXPnJgGA2Wx2/fjjj1G9evXq8/XXX8c89dRTxQDwzjvvHHz99dfb9+7dO7tXr159Vq1a1S7YtZcuXXps27ZtURkZGdlpaWl9lixZ0iHQ/jk5OZZZs2YV/+pXv8rs3bt39oMPPtitMeeZN29eybvvvtu+rKxMCnRMVlZWzdChQ3sPGTIka/bs2cWpqan1suK///3vT77zzjuJvXv3zt69e3eE58fk3bp1c6SlpVkmTpzoN+MZjGfNsN4yDGhYn6v/UaJ/D9PT0/tcffXVGb/+9a8rFi5c2KCTRDj4G5O3iooK+a677uqRlpbWJyMjI3v37t3m+fPn+x3jihUrEq677rp6mdhbb721TM8SB+JZMzxmzJhUX/vor3H37t37vvXWW4nr16/f06VLFwcAvPjii4URERGunj179u3YsWP/JUuWdFq/fv1+X39c/PnPfy45e/Ysf3zFGqDG1t60Jjk5OWLLlrYbk287Woa8ogrc+cvuLT2Ui1KFxY5B//sFIo0yeneOxY+HzgAAurSLwLdzfx30+BqbA9mPrcdv+nTCzYMatM/06+u9p7Dy+yP4xx2X4oG3tuHmS5Pxm75Jfvd/7ZtDKCipwHdzfw2zUQ2cbQ4XMh79DP+T1RG3/iLF77FN4et9p7DyuyMAgF/2SMDUX/UM6/Uaq6TCgqszOyK5XdDkpxsRbRVC5Hhu27Fjx+EBAwZcUB+xRkZGDqypqdne0uMIl5kzZ3aJjo52+qrZDUVlZaWUnZ2d/fPPPxckJib6bvbLLhhHjx5Vrr322owpU6acnD179gX1s8rCb8eOHe0HDBiQ6uuxkP9CIqK+ALIBuGdoCiFWnvfo2jibw4Vl3xzEPUN7uAOZUI196VsAwI0DkhBrNgbZmzVWpcUBu1PgqoyOiI8yuoNhR4iZYX0VuXPJDANAXlEFAAQvk9Ayw8JjsUh9RbrmyAybPCb4NXayIGMtZfXq1TEPPvhg6rRp005wIHxxSElJcRQUFDRLH252cQkpGCaieQCughoMfwpgJIBvAHAwfJ7W/FyIZz7fg+P/z96ZxzdR5n/8MzO5mja97xvapm3a0tKWypab6v5AWQ4LiriCKIsFWVDUBcV1XQXWC0VXXVkPXEB0VZDLA1EQWFFogUKBHrRQWuh9JmmaYzLz+yOZNG2TNiltKTLv14sX6WSeeZ4kk8xnvs/n+X6bNVg/y/Hq1pVNlsXSKK1XIzWct3D3NzqD6fooEhDwknasMqcdrG3M5QqmnPTReriY+rrcYLK8uQh7ySZBEaCNnT3DnBgeDNsCZ5PgxsIzdPgtR4UB4PXXX++zvWDmzJmqmTNnFlhv27Fjh/uaNWtCrbeFhYXpuGITA8mN6LumpoaaOHFibNftP/30U3FgYCB/g8Bzy+BoZHg2gGQAp1mWXUgQRACAbQM3rFsHtc5k+i+46lyijot1qo7HtbwYHgg4MSugSLhLrMSwkQVtZHqNgurM6dGczSYhFZm+ltWtJs+wi7Dnr6mAImFkO3uGuUV+g+kZBjAo2St4eAYK64pvt0LfgYGBxsGqaMjDM5RxNGzUzrIsA4AmCMIdQB0Ax02QPHa51twOACi4psS3BdUOtyur61gwXVyj6mFPnr5iEcMkCZmkQ5DSDGuzyIXd9k5aB1zNdpkasxh2FTtgkzCyYK0C1vpBtEmIrG0S/AI6Hh4eHp6bDEevXHkEQXgCeB+mTBKnAPwyYKO6haiwsjscLql3uN2lBjXcxAK4iQW4UK0ciKHd8nA2CSEFuHURw5wNoef2nJh2TpCKBCQokkCdypSes7fcvQKSgJFlYbSyb3AZLwYrz7BlLLxNgoeHh4fnJsMhmwTLskvND98jCOI7AO4sy54duGHdOpTUqqAIkqGsvg1NbXbTOHajsFoFf5kY7hIBimtU3aqP8Vw/HZFhqlPEkzYy3XL62m5vEtPORoYJgoBUSEGlo0EQ6HVhJXd8HW0thm+MTWIw+uPh4eHh4elPHLpKEwSxlSCIPxEEEceybDkvhJ3j+/M1aNd3X4tQq9SivFGDcG9XyCQCNDsohnW0EeerWhHsKUGUvxuaNQZUtbT397BveTpsDp0FHsOiUxS21/Z9cA5IzdYIb6nIoXLMAKC1EsMdnmHn+3YWa5uEkLdJ8PDw8PDcZDh65foIQBCAfxIEcYkgiB0EQawYwHH9Zjh3rRWLt57EE1/kd3sur9yUo3yYrxQyiRCt7TYrqHbj10tNMBhZhHpJLQu7uCl1nv6Di+yKbChKWzc39tr3JmZtwS2i83ET9Vp0gzu+ge4YU4dneHCzSYh7yXzBc31QFJUWFxeniImJSZg6depwlUpl8w2fMGFCdENDg1O5Grk2DQ0N1EsvvdRjQQ0A2Ldvn0wmk6VYF3HYtWuXzJk+neWxxx4LHug+OLKzsyNDQkKS4uLiFLGxsYrdu3f3ud+33nrLZ/78+f2W8HvlypXB/v7+I6yLrwBARkZGbGRkZCK3fcqUKcNt7R8XF6doaGiguM8wPj5eERkZmZienh776aefetjrd9WqVYFce+5cjIuLU7z44ov+KSkpcYw5SEDTNOLj4xUHDhxwte47JiYm4ZNPPvHoaUy2+lWpVOT06dOHyeVyRUxMTEJaWlpsSUmJiGvn6+ubbH0srVZLAMDWrVs9CYJIO336tAQATpw44cLt4+HhkcJ9vpmZmfLi4mKRRCJJtR7P22+/7dPT58CdI7GxsYrIyMjEWbNmRZaVlVlWWzc2NlKzZs2KDA8PTwwLC0ucPn36sPr6egoAiouLRQRBpK1bt85SWXH+/Pnhb731Vrc+7X3e9957b8TJkyclXfd3Flvn55tvvunD9ScUClPlcnmnvgeKjRs3+lRUVFhcC7Nnz448c+aMuKc2/YGjNolDBEEcATAKwCQAOQASALw5gGP7TcAJ3NI6dbfnLtapQAAI85bCXSLAmautuFSvxnA/N5vHYlkW894/jl8uNcJfJoYiSIZapUkEO2Ox4HEMzvPLib05aaHYlX8NBiMLrcFxz3BfxDC3iM7HVdSr/YWyERk2DGZk2EoMiwS8TWIgEYvFDLf6f/r06cM2bNjg9/zzz1sKTjAMA5Zlcfjw4VJHj9m1TXFxsejDDz/0X716da+LGNLT09WHDh1yuK/rgaZpbNy4cVAqtXGsXbv26sKFC5v37t0rW7ZsWcSMGTPODWb/PZGTk1Nrq9jIli1bLo0fP17j6P7Wn+GxY8dc5syZEy2VSstnzJjRbWX2yy+/XPPyyy/XAKaCLtaZKI4fP+62ceNG35UrVzasX7/ePzk5ue2OO+5o+/bbbz24vk+dOiXJysqKnTt37pmextSV9evX+/v7+xv27NlzGTCViw4LCzNw/dsrvvLZZ595p6amqrds2eI9cuTIqoyMjHauTXZ2duS0adNaFy5c2AyYzvuwsDCds9k1uHOEYRi8+OKL/llZWbFFRUXnJRIJe//990coFArtV199dQ4AHn/88eC5c+dG/vjjj2UA4O3tTW/atMn/iSeeqJdIJD2a72y9V//973+vODNWZ1ixYkXjihUrGgEgJCQk6fDhwyVBQUG0o+0NBgOEQmHvO3Zh69atvhkZGZrw8HAaAL788stypw/SBxy1SfwI4GeYyjIXAxjFsmzcQA7st0JPC60uN7TB21UEN7EADWqTmH3yizN2969u1eKXS6aqoemR3gjycIGreXFVSzsvhvsbzubAidn/SwjEHHMlOR3tSGS4s5h2Bh83041woHvvVdM4G0dnz7Dpd3UwIsPWYr+3KHZX9DSDZk33c7fgWiuWfHISGr3Dv72Dyl9//mvYffvui+3Pf3/9+a9OZegZO3asurS0VFxcXCziolJyuTyhrKxMFBISklRdXS0AgOeffz4gJiYmISYmJuGFF17wB0wXfnttnnjiidDKykpxXFyc4pFHHgmdNWtW5NatWy3lmqdPnz5s27Ztdss3Hz58WCqXyxUajYZQKpVkdHR0Qm5urmTfvn2y9PT02IkTJ0ZHRkYmzps3L9xoNH2Pdu7c6Z6SkhKnUCjip06dOry1tZUETBfhJUuWhCgUiviPPvrIKzs7O5IrIXz06FHpqFGjYhMSEuLHjh0bc+XKFSFgio4uWbIkJCkpKT4yMjLxu+++cwNMYnrx4sWhMTExCXK5XMFF5Owdx5qsrCx1XV2dZXtPfS9cuDCMi4IeOnRI2vVY27dv9xgxYkRcfHy8IjMzU15ZWSkwGo2IiIhIrKqqEgCA0WhEeHi45e/BIjMzs/2pp56qevvtt/1737sz77zzTuUbb7wRmJeXJ/nggw/833zzzatd90lNTdVSFIWamhqnXld1dbUwJCTEMnWanJysc3Fx6VE8tra2krm5uW6bN28u/+qrrwY89yhJkvjb3/5W5+vra/jyyy89zp07Jy4oKHB95ZVXLDdwr776alVRUZGUi3R6e3vTY8eOVb3zzjs9RqDtkZGREXvkyBFpSUmJKCIiIrG6ulpgNBqRlpYWu3PnTncAePfdd72TkpLi4+LiFPPmzYugadNv6ptvvukTGRmZmJSUFH/s2DHbETg7/Pjjj64pKSlx8fHxitTU1LiCggIxALz++uu+t99+e9Rtt90mHz9+vJymacybNy982LBhCWPGjIkZN25cDPdbcvjwYct3aPz48TGVlZWC999/36uwsFA6b968KC7Cn5aWFnvs2DEXg8EAmUyWsnTp0pDY2FhFSkpK3LVr1wQAUFBQIB4xYkScXC5X/PnPfw6RyWQpzr6Xjl4pzwLQA0gEMAJAIkEQjtc2vYVp05l+7G3Fyy7Xm8SwWEAhK97022OvOjZtZHDySkfpd7m/GwiCgKt5Or2Bt0n0Ox02iY5PjxO2WoMTNok+LCqblxGOZ6bGYWKsb6/7cp5h6xsvvVlkDEY2CZLo6MMZMcwwLP786Wms2nG2U45kAJYIvK0ZFR5T1GX//v3uSUlJ7QBQUVEhXrZsWX1pael5uVxuubs4evSodPv27T4nT54szMvLK9yyZYvfzz//7NJTmw0bNlzlImSbNm26umjRoob//Oc/PoBp2vfkyZNu9957bwsA5OXluVlPK58/f148YcIEzZQpU1oee+yxkEcffTR0zpw5jaNGjdICQEFBgeu7775bUVpaeq68vFy8ZcsWr+rqasH69euDjhw5UnLhwoXC1NRUzYsvvhjAjcfHx4e+cOFC4eLFiy0/gDqdjli+fHn47t27y86fP1+4YMGChieffNIyfUvTNFFQUFD48ssvV77wwgvB5tflV1FRIbpw4cL5kpKSC4sWLWrs7TgcO3bs8Lj99ttbHOm7vb2dLCoquvDWW29dWbx48bCux7rjjjvU+fn5RYWFhRdmz57d9MILLwRSFIXZs2c3fvDBB94AsHv3bvf4+Pj24OBgu3eD7733XgD3vu/YscOd2z5//vzh3PZHHnkk1Nb+t912m9zecTMyMjRlZWVOT71HREQYcnJy6iZOnBj/5JNPVgcEBHT7kTx48KArSZIsF2F0dEyLFy9u+Oc//xmYkpISt3z58mBOfPXE9u3bPSdOnNg6YsQInZeXF3306NFuNyZd4W4CuX/cjZQzjBgxQlNYWCg5c+aMRKFQaASCDt0vEAigUCg0Z8+eteinZ599tvqf//xnICdS7WHv8wYAuVyuX7FiRc1DDz0U/vzzzwfExsZq7777buWpU6ckX375pXdeXl5RUVHRBZIk2ffee8/nypUrwpdeein42LFjRbm5uUUlJSVO6bmUlBRtbm5uUWFh4YVnnnmmavXq1Zbz/8KFC9J9+/aV/fLLLyUfffSRV01Njai0tPT8J598Up6fn+8KAO3t7cRjjz0WvmfPnrLz588X3nfffY1/+ctfQv70pz81x8fHa7Zv315WVFR0oWu0XK1WUxMnTlQVFxdfSE9PV7/zzju+ALB06dLwxx57rLakpORCUFBQnyKDjtokHgcAgiBkAB4EsBlAIIAB93Hc7Ci1pptZmmFx4nITMoZ13KBeadIgLlAGiiQwPsYPBy7UwmhHDc/74LilHPDCMZGQB5jsa1wO2hYH/cY8jmOJDFtFdoVUd0tCb+1FvZRTtgVFEnbtMl3hMl3oDN0X0A12EQyJE57hGqXWcr7rDEynrBnc14C1d3d4g3lxzIuVN6JfnU5HxsXFKQDgtttuU61YsaLhypUrwqCgIH1WVlZb1/1/+ukntzvvvLPF3d2dAYC77rqr+dChQ7I5c+a02GvTlbvuuku9YsWKiKqqKsG2bdu87rrrrmZu+tOeTeKVV16pTk5OjheLxczmzZsruO1JSUltCoVCDwD33HNP09GjR90kEglTVlYmycjIiAMAg8FApKWlWe6C5s+f39z1+GfPnhVfvHjRZfLkyXLAZPXw8/Oz/AjOmTOnGQAyMzPbnnrqKREAHDx40D0nJ6eeG3tAQIAxNzdX0tNxnn322dC///3vIbW1tcKDBw8WOdL3vHnzmgBg6tSparVaTXb1wV6+fFk0c+bM0Pr6eqFeryfDwsJ0ALBkyZKG6dOnRz/33HN1H330ke+DDz7Y0NPn0l82ia5cz3du9erVdWvXrg1Zvnx5o/X29957L+Dzzz/3cXV1NW7ZsuUSaf7NcnRMmZmZ7ZcvXy7YtWuX+4EDB9wzMzPjDx8+XJSamqq11+bzzz/3Xr58eR0AZGdnN23dutV73Lhx3d4Xa/pik+iKs++fQqHQjxw5Ur1p06Yeo9e9vVcrV65s2Llzp9fHH3/sd/bs2QsA8N1338nOnTsnTU5OjgcArVZL+vv700eOHHEdPXq0irvZuvvuu5tKSkocvgFqbGyk7rnnnsiKiopubcaPH6/08/MzAsD//vc/WXZ2dhNFUYiMjDSMGjVKDQCnT5+WlJaWSiZNmmT5DgUGBvYqYiQSCXPPPfcoASAtLU1z9OhRNwA4c+aM64IFCy4CwMMPP9z0j3/8w2lfs6PlmJcBGAcgDUA5TAvqjjrb2a0I5xkuq2/D3H//gv+tmoRgTyn0NIPWdkOn/LVSEYU2ne27Q04Ie7oIMTLM0xKh5BZa2Zpq5rk+LJ5hG0UldM54hgdYkFI2IsOcEBc7aVu4Xrjz0RHaraLrLGxfQIxDUwvfMKw9w9ZIpVLHaoT3sc29997b+P7773vv2LHDe/PmzeW97V9bWyvQaDQkTdOERqMhOTFOEJ2/CwRBgGVZjB07Vrl3797Lto4lk8m6jZNlWSI6Oro9Pz+/yFYbLqIkEAhgNBrtfgF7Ow7nB123bp3/okWLIs+fP1/YWxtbr9GaZcuWha9YsaLm/vvvb923b5+Mi1xHR0cbfH196T179sjy8/Ndd+3adcneuAeS3NxcaXR0tF2R2RMURXV7vYDjorcnPDw8mAULFrQsWLCgZf78+di9e7eHPTFcW1tL/frrr7Li4mKXZcuWwWg0EgRBsAzDXCUH2DpWUFAgvf3222uSk5O1Fy5ckBqNRlCU6XfYaDSisLBQOnr06ErGKiPRc889V3PPPfdEjR49us8VtFQqFVlTUyMCAKVSSXl5eTEsyxJz5sxpfOedd65Z72tte+oLTz31VMgdd9yhXL16ddm5c+fEd955Zwz3nCO/KyzLQi6Xt588ebLYmX4FAoHlikBRFNvTd9tZHD0rJABeBxDHsuztLMv+nWXZg/01iN8ySquILcMCZypNZZc58epqJR5cxQJo9EYwPSSxFQnITuJMJCAhpAgo24emt/JmRm80giKITjmGuciwzgmbhGiABSk3Jr1VtLpj8d5gR4Ydf63WVhOatn3OO1LchMc+kyZNUn/zzTeeKpWKVCqV5DfffOM1adKkHi+4Hh4exra2tk7XhpycnIZNmzYFAEBaWlqvQmnhwoURa9asqZo9e3bjsmXLLFP1BQUFrkVFRSKj0Ygvv/zSe9y4caqJEye25eXluZ07d04MAEqlkjx79myPs44jRozQNjU1CX744QdXwGRdyMvL6zGylZWVpdy0aZOvwWD6Ta6traUcPc7TTz9dxzAMsWPHDvfe2nz66adeALB//343mUxm9PHx6fRjoVKpqPDwcAMAfPzxx528og899FD9okWLhv3hD39osp5eHyyOHz/u8uqrrwY/+uijdYPeeQ98//33rlwWBq1WS5SUlEgiIyPtRoC2bt3qNWvWrKaqqqqCa9euFdTU1JwNDQ3V79+/32nbg6MwDIO1a9f619fXC7Ozs5WJiYm6hIQEzapVq4K4fVatWhU0duxYZUxMTKexjxw5UhsTE9P+ww8/2M3k0RvLli0LmT17duMzzzxT9eCDD0YAwJQpU5T79u3z4ry1tbW1VElJiWj8+PGQkmW7AAAgAElEQVRtx48fl9XU1FA6nY746quvvJzpS6VSUaGhoQYA+Pe//23X7zxmzBj1zp07vRiGwZUrV4S5ublugMk7XltbK+I89Vqt1vIdcnV1ZZRKpVMXzREjRrRxAn/z5s198oc7JIZZln0NgBDAAwBAEIQfQRDdvFA83emaLu3klWZoDUY0qLtXF5OKKGgNRhi65LC1FgQsuhdxkIoEaOEjw/2OzsBAQBGwDnRwi8XaHbRJEETf8gw7AxcZ1neKDJuuv4MdGXYmc4Z1Rg490/nmgptqNNgRyTyOMXbsWM28efMaU1NT49PS0uIfeOCB+jFjxvSYlDwwMNCYlpamjomJSeA8p2FhYXRUVJT2j3/8Y6fp766e4c2bN3u9/fbbPkKhkM3JyWlat25dTX5+vnTPnj0yAEhMTGzLyckJj4qKSgwPD9c98MADLcHBwfSmTZvK586dO1wulyvS09PjCgoKehS2EomE/eyzz8pWr14dGhsbq0hISFAcPny4R6Hz+OOP14eGhurj4uISYmNjFR9++KG3o8chSRKrVq2qeu211wJ7ayORSNj4+HjFsmXLIjZt2lTe9Vhr1qypuu+++6ISEhLifXx8OkUx7rvvvlaNRkMtXry4sWs7R7H2DGdmZlp8uNae07i4OEVxcbEIMH2GXGq1pUuXhr/66qsVtjJJDAT2xtSVkpISyZgxY2LlcrkiMTFRkZKSolmwYEE3+wzHF1984X333Xd3en7GjBnN27Zt61EodfUMr127tteFhM8++2xobGysYtiwYYl5eXmuBw8eLOZmJrZv315eWloqCQsLS/Ty8krOzc113bZtm80MEH/961+ra2trbb7+3vj666/d8vPzXdeuXVuzZMmSJqFQyL755ps+aWlp2mefffZaVlaWXC6XKyZPniyvrKwURkREGFatWlU1evTo+PT09Di5XO7UTMCqVatqnn322VCFQhHPsqzdiMvDDz/c5OfnR0dFRSXcf//9kQqFQuPp6Wl0cXFhP/vss7Inn3wyjPtM//e//7kCwPz58xtycnIirVPk9cY777xTsWHDhiC5XK64fPmyWCaT9R6t6gLhiL+FIIi/AUgHEMuyrJwgiGAAX7AsO8bZDvuT9PR0Ni8v70YOoVf+/Olp7D3TORtQRqQ3Hp0cjQUfncDiccOQMcx0Y7X9RAUOFtXhv4+Mxm3DOm62rjZrMPblQwAAP5kY/5iV1Ol4L39XBIORwU9PTRrgV3Nr8ddd5/DV6Wv4x6wki5/1Yp0KL39XjJezk3DvKPtpQ1vbDZj17s+42tyOV7JH9FpS+XoorVPjpe+K8I9ZibjvtggAwAdHL2Ht14VYOyMBgR4Dv9Z10RbT9/CtuSkOWyV+LmvA5p/LAQAvTE9AsGfHOP++9zwqm9tx/21hmBQbYOcIjlGj1GJSnD9CPB1/HwiCOMmybLr1tjNnzpQnJyf36OP8raJSqUiFQqHIz88v7BrpdJR9+/bJNmzYEDBYqdhuBBkZGbGvvfZapS3PriMcOXJE+vjjj4c5O33MM/Q5c+aM+A9/+EPMq6++Wnnvvfe23ujxDBatra2kh4cHU1VVJcjIyIg/ceJEYU8LQ/uCUqkk3dzcGJIk8e6773rv3r3ba//+/WVd9ztz5oxvcnJypK1jOHqFngVgJIBTAMCybJV5MR1PL9gqpHGpQY16c/YHmaQjiw/nLX344zwcemICfNzEOHKxHvvP11j2ifDuviA2xNMFv15uxBd5lSirb8PqqXzWu/5ARxvtR4b1PUeGV/43H5fqTWuTBnoNG7dIzjq1GmdB6Etat+uBsuEXtIe177pOpUVjmx6Jwe4mH6l5O+1I3WueAWXXrl2ypUuXRubk5NT2VQjz9M4zzzwT+PHHH/tt3rzZpnea5+YmOTlZV1FRMWTyVA8WkydPjlGr1RRN08TTTz99rb+FMAAcOXLE9cknnwxjGAYeHh7G//znP05/hxwVw3qWZVmCIFgAIAjC1dmOblVabeT/pRkW9SrTrISHtEMMq82L59Q6Gk9+eQbnrinRaC6mkRTigaw4fwR5dJ89DPZ0gdbA4KkvTVWyUyM88XtFYL+/llsNrYGBgCQ6pQ7jxLDW0PP3ubK5IzBEOiEQ+wKXZ1jfZQEdgcHPJtFbgRBrrD3Dbx8y3cT/X0KAJZcz0JEvmefGMXPmTNXMmTMLrvc406ZNU02bNm1Qpt9vFCdOnOhzRHf9+vU169evr7HetmrVqsDdu3d3mtqfMWNGE1f4YiC5EX3v2LHDfc2aNaHW28LCwnQHDhzoFuXjuTkYjFkO82/LdWUBcVQMf04QxCYAngRB/AnAQwA+uJ6Of6us/6YQB4vq8MPKCQCAVo0BLkIKcUEyXKhSQkcz0NMMrrW0QyIg4WaVTmp6cjAEFAG1lsaRkgZLdCzKzxV3JgUixt92MD68S7T4P8fKeTHcD6h1NMQCslNkV2Cj2pstrCOyA6yFOzJc0J3FsFBAYqBXTnNsmJOMWqXWKfGt7VK4JCHYHfvP10IR5G5JrUbzYpjnFsa64tut0Hd2drYyOzv7ukQND09fcGYB3ZcAdgCIBfAcy7JvDeTAblb+feQSSuvUqGwyTZErtTQSQ9zx6MRovH3fSNwe7w+twYjyBg183MQQW62+93ET44HRkUgN97II4YVjIrB6SpxdIQwAkT4dYjg13BN55c0OZTuwZm/ZXlQqb0jq1CGLSmuASEB1inZykWFdL2LYeuHaQEeGLQvoOmWTMEJIEgNu0eDwcBFCHiCzmVbJHl1LWn8w32TRfeOHixZ7EZ9NgoeHh4dnoHE4bMSy7AGWZZ9iWfZJAD8SBHH/AI7rpifvSjNYloWy3WBZfEUQBNwlQjCsaSGWp1TYKU0aR0xAh/D1kop6FRgCisSoSC8ogmSQB8igoxmU1jteueu74vN45n/P4PGfHne4za1Aa7sBEgHZxSZhjgz3crNh/bkOeGTYjk1CQJEDLsSvh643bO4uQkyM9QPQYRmieTHMw8PDwzPA9CiGCYJwJwjiaYIg3iYI4veEiWUALgG4Z3CGePOgs5r2/euu87hYpwbNsHCxiv5yj2uVOvi42ha63q4i+LiaMqz4uTlW5O+R8VFYNikGge4mT/Hl+l4LS1n4+4+fAgDUOl54WKPS0t3y5nKRYX1vkWGrSmykzWLc/YelHHMXm4SAJAZciF8PXa0mFElg470pnaLZ/AI6Hh4eHp6BprfI8FaYbBEFABYBOARgDoCZLMvOGOCx3XRUNpkWTVEkAbWOxsr/5gPoXIjAuuSsbw9CNzHEAx4uQqeKGIgEpOWY5Y2Oi2E3V9O4m1o7xnOkpB4r/5vfYwGQ3zq2xLBgKEaGye4CncuEMVQjw9ea23Gtub2Tx1hIkfCUijA5riO1J2+T6AxFUWlxcXGKmJiYhKlTpw5XqVQ2f8MnTJgQ3bUMcG9wbRoaGqiXXnrJr7f99+3bJ5PJZCnWeVl37do1oFmGHnvsseCB7oMjOzs7MiQkJCkuLk4RGxur2L17d5/7feutt3zmz59vPxejk6xcuTLY399/BPe+L126NAQwpXaLjIxM5LZPmTJluK394+LiFA0NDRT3GXJ5htPT02M//fRTu4UfVq1aFci1587FuLg4xYsvvuifkpISx1VVo2ka8fHxigMHDrha9x0TE5PwySefePQ0Jlv9qlQqcvr06cPkcrkiJiYmIS0tLbakpETEtfP19U22PhaXn3br1q2eBEGknT59WgIAJ06ccOH28fDwSOE+38zMTHlxcbFIIpGkWo/n7bff7lZQgnuP5XK5YtiwYQnz588Ptx53WVmZMCsrKyoiIiIxNDQ0af78+eHt7e0EYPrOEASRtn37dst7PGnSpOh9+/bx2bluML0toBvOsmwSABAE8QGAagDhLMv2qVTjb51z15QAgEVjh+HzvEqcqzL9bS2orB8HuNvPKz8nLRTjY3zh6mR+Wh83U0T5cqPjaS4JwgiwgEpnwLVmDQiCwPyPTgAA/jw5GsP8Bqxoz3XDsiy+v1CLrDj/bsVIrgcjw0KtoyERdj4mRZiirb15hjsvoBucbBI6o3VqNQYCkhyykeG/7T0PABjm64rLDaYbN877nBDsgR8KTQWw+GwSnbEuxzx9+vRhGzZs8Hv++ectZW4ZhgHLsjh8+LDDuXy7tikuLhZ9+OGH/qtXr67vrW16erp6sPIG0zSNjRs3VvW+Z//BlWPeu3evbNmyZREzZswYMqmx7JU43rJlyyVbeY7t7W/9GR47dsxlzpw50VKptNxW4Q3rRXVSqXSkdWnw48ePu23cuNF35cqVDevXr/dPTk5uu+OOO9q+/fZbD67vU6dOSbKysmLnzp17pqcxdWX9+vX+/v7+hj179lwGTDl7w8LCDFz/K1euDHZzczN2PdZnn33mnZqaqt6yZYv3yJEjqzIyMtq5NtnZ2ZHTpk1rXbhwYTNgOu/DwsJ0tsqdd4V7j7VaLfHnP/85ZOrUqdG5ubnFDMNg5syZ0YsWLapbsWJFGU3TmDdvXsTSpUtDN2/eXAkAAQEBhpdffjlo3rx5t0yu4ZuB3tSDJUkuy7JGAFd5IWyf0xXNEAtIRPm5ISuuo1CAtU1CahUZ7qkIgERIIcLH1enInpAiEewpQV55k8Nt9EZzmjBSh6JaFf595JLluXr10K5sd/ZqKx7ZehI7T13rfWcn4DyrXSPDBEFAQBKdLAm2MA5iRJ3L7WvoGhkmh25kmCPKr3uWxhkpwZbHvGfYPmPHjlWXlpaKi4uLRZGRkYmzZs2KlMvlCWVlZaKQkJCk6upqAQA8//zzATExMQkxMTEJL7zwgj9guvDba/PEE0+EcpW4HnnkkdBZs2ZFcqVOAZMI37Ztm6e9cR0+fFgql8sVGo2GUCqVZHR0dEJubq5k3759svT09NiJEydGR0ZGJs6bNy/caDTNsOzcudM9JSUlTqFQxE+dOnV4a2srCQAhISFJS5YsCVEoFPEfffSRV3Z2duTmzZu9AODo0aPSUaNGxSYkJMSPHTs25sqVK0LAFLlbsmRJSFJSUnxkZGTid9995waYxPTixYtDY2JiEuRyuWLdunX+PR3HmqysLHVdXZ1le099L1y4MIyLgnLlZq3Zvn27x4gRI+Li4+MVmZmZ8srKSoHRaERERERiVVWVAACMRiPCw8Mtfw8WmZmZ7U899VTV22+/3Wvlta688847lW+88UZgXl6e5IMPPvB/8803r3bdJzU1VUtRFGpqapx6XdXV1cKQkBCLHklOTta5uLj0+CPb2tpK5ubmum3evLn8q6++6lOJ3t6QSCTsv/71r6tVVVWiX375xWXv3r0ysVjMrFixohEABAIB3nvvvcodO3b4cOd0fHy8RiaTGb/66iv3gRgTT9/o7YRMJghCaX5MAHAx/00AYFmW5T9MK85XKRHs6QKZRAA/WYflwFoAc5XIxAIS7i4D8zs3PtoPn+VV4tFPTmHj3JReS+TqjXqABAhSi4omNa42d1RrbWrTDcgY+4srZmtKwbUW3DMqrJe9Heea+T0Q2yhaIaTITlFYW/QWOe5PSHPWCIOVANcZGFBD2CbBMTUxED8U1nWKYA/3c8PamYl4dte5Tq9pKFH1zJow3cWL3SvgXAfimBhN8Pp1DqV0MRgM2L9/v/vvf/97JQBUVFSIP/zww8tZWVnl1vsdPXpUun37dp+TJ08WsiyLtLS0+KysLJWvr6/RXpsNGzZcnTZtmgsXIfv666/d3njjjYAHHnigpbGxkTp58qTbjh07Lu/fv1/GlWPm2u7YsaNswoQJmilTprQ89thjIe3t7eScOXMaR40apd23b5+woKDA9fTp0+fkcrl+/PjxMVu2bPGaMmWKav369UFHjhwpcXd3Z9asWRP44osvBrz22mvVAODj40NfuHChEAD279/vAQA6nY5Yvnx5+Ndff10aHBxMv//++15PPvlkyBdffFEOADRNEwUFBYX//e9/PV544YXgKVOmlGzYsMGvoqJCdOHChfNCoRC1tbVUb8exel0et99+e4sjfbe3t5NFRUUXvv32W7fFixcPu3jx4nnrY91xxx3quXPnFpEkiddff933hRdeCHz//fevzp49u/GDDz7wfu655+p2797tHh8f395TgYL33nsv4PPPP/cBgHXr1l3Nzs5WAqZyzBKJhAGACRMmKDdt2nS16/4eHh708ePHS2wdNyMjQ/PWW285nZszIiLCkJOTUzdx4sT49evXVwQEBHTzkh08eNCVJEk2KCiIdmZMixcvbpg2bZp89+7dXuPHj1f+6U9/akxKSurx4rR9+3bPiRMnto4YMULn5eVFHz16VDpu3Lgep0y5m0Du740bN1ZMmTKlx9XoAoEA8fHxmnPnzklqa2uFycnJnfrw9vZmQkJC9OfPn7eIgjVr1lQ/99xzIbNmzVJ2PyLPjaBHNcayrFOeM2sIgggDsAVAAAAWwL9Zln2TIAhvAP8FEAmgHMA9LMs2E6a55DcB3AlAA+BBlmVP9bX/G0GNUgsfVxGEFAmZpOOtdbd6HOzpgiUThsPfXexw2VpnmRTnj1qVFl8XVGO83LfHssEAYGBMN9wEqcO1Jg3qVFpIhCS0Bgb/PnIJRTUq5EyIcsq/PFhUtZhEKxfJ7Q9UWgPufOsoAHSzSQBwKDLM+XfnpIX2uF9/ISBJ0NYV6GijpaLhUEQiJPG74T7IijfNoAi75EP+4+gIbD9e0alKHQ+g0+lI7mJ92223qVasWNFw5coVYVBQkD4rK6vbQoGffvrJ7c4772xxd3dnAOCuu+5qPnTokGzOnDkt9tp05a677lKvWLEioqqqSrBt2zavu+66q1koNAVJ7dkkXnnllerk5OR4sVjMbN68uYLbnpSU1KZQKPQAcM899zQdPXrUTSKRMGVlZZKMjIw4ADAYDERaWppFgMyfP7+56/HPnj0rvnjxosvkyZPlgMnq4efnZ4kczpkzpxkAMjMz25566ikRABw8eNA9Jyennht7QECAMTc3V9LTcZ599tnQv//97yG1tbXCgwcPFjnS97x585oAYOrUqWq1Wk129cFevnxZNHPmzND6+nqhXq8nw8LCdACwZMmShunTp0c/99xzdR999JHvgw8+2GPp7/6ySXSFZft+A7p69eq6tWvXhixfvrzRejsnel1dXY1btmy5xOU/d3RMmZmZ7ZcvXy7YtWuX+4EDB9wzMzPjDx8+XJSammp3pvrzzz/3Xr58eR0AZGdnN23dutW7NzHsqE2iK86+Z1OnTlU/99xz2L9//9D1IN5iDOQUDA3gCZZlT5lLN58kCOIAgAcB/Miy7EsEQawGsBrAKgBTAcSY/90G4F/m/28KWJZFrVKLYb6mYJGb2FoMd551S4sYkBkbCxRJ4J70MBwpacDPpQ29imGaMQlJgtKiqrUd9Sod/GUSVDRpcKqiBacqWlDRpMHr96QM6Lj7AhfBbdf3T5XY3fnXsOIz08JHiiQQ5Nnd1y2kSEsaM5XWgDvfPAqCIPDeH1OhCDati9DRRgzzdcXvFQHd2g8EFElAz1jnGWYGvRSzM9BGFiIBCZlEiCAPCaYlBXXbx1Mq7DRLMZRwNILb31h7hq2RSqVO3zU40+bee+9tfP/997137NjhvXnz5vLe9q+trRVoNBqSpmlCo9GQnBjv6p8nCAIsy2Ls2LHKvXv32iyhKpPJuo2TZVkiOjq6PT8/v8hWG4lEwgKmqJ3RaLR7V9jbcTjP8Lp16/wXLVoUef78+cLe2th6jdYsW7YsfMWKFTX3339/6759+2QvvPBCMABER0cbfH196T179sjy8/Ndd+3adQk3gNzcXGl0dHSf7JAURdlcI+Go6O0JDw8PZsGCBS0LFixomT9/Pnbv3u1hTwzX1tZSv/76q6y4uNhl2bJlMBqNBEEQLMMwV/u7EBFN0yguLpaOGDGiqrq6mt61a5eX9fNNTU1kQ0ODYMSIEdqffvrJIn6ffvrp6rVr1wYJBIKhOf11izFgV0uWZau5yC7LsioAhQBCAMwA8B/zbv8BMNP8eAaALayJX2Gqdtf9CjlEadEYYDCykIlNwtc6MjxQEeCeEFIkQr1ccOZq7x59mjUHNUidlRjusHkkBLnju3M1vaYTuxFwkeH+EsOcEAaAl+5OgiKw+8JqIUVAb17Y9fXZalQ2t6OiSYO/7Dhr2acjtdngRGcFJAGaNo3JYGTQ1KYf9FLMjsKyLGiGhUhAgSIJHFs9GX+ZGtdtPy+pCO0G46D6r39rTJo0Sf3NN994qlQqUqlUkt98843XpEmTeiyJ7OHhYWxra+t0bcjJyWnYtGlTAACkpaX1KpQWLlwYsWbNmqrZs2c3Llu2zDI9UlBQ4FpUVCQyGo348ssvvceNG6eaOHFiW15entu5c+fEAKBUKsmzZ8/2mFNyxIgR2qamJsEPP/zgCpisC3l5efZXJAPIyspSbtq0yddgMP3e1dbWUo4e5+mnn65jGIbYsWOHe29tPv30Uy8A2L9/v5tMJjP6+Ph0+nFSqVRUeHi4AQA+/vjjTtkKHnroofpFixYN+8Mf/tAkEAz+deP48eMur776avCjjz5aN+id98D333/vWl9fTwGAVqslSkpKJJGRkXYXtGzdutVr1qxZTVVVVQXXrl0rqKmpORsaGqrv70isTqcjli1bFhoUFKS/7bbb2qdPn67SarUkl4WCpmksXbo07KGHHqpzc3Pr9EN29913K1tbW6mioiL7i4d4Bo1BCR0RBBEJYCSA4wACWJatNj9VA5ONAjAJZetoy1Xztq7HWkwQRB5BEHn19b0udh406lQm+5K7i0kMWwtgbrX/YDN6uA+uNGrw/Tn7FTVZloWRNUeGCQb5lU2gGbaTGI4NlEGjN+Jqs+MZKgaLq2YxrHGy4p4tuqZLcxMLbIpZAUXCYM4p/XNZI7ylQkxJCMS5a0pLSju9WQwPFhRFWNKQ7TtbhcY2PRKCh6alnxO3YvP3giAIm752D6kQ7XpeDF8PY8eO1cybN68xNTU1Pi0tLf6BBx6oHzNmTI/h9sDAQGNaWpo6JiYm4ZFHHgkFgLCwMDoqKkr7xz/+sdP0N+cZ5v5t3rzZ6+233/YRCoVsTk5O07p162ry8/Ole/bskQFAYmJiW05OTnhUVFRieHi47oEHHmgJDg6mN23aVD537tzhcrlckZ6eHldQUNCjsJVIJOxnn31Wtnr16tDY2FhFQkKC4vDhwz0Knccff7w+NDRUHxcXlxAbG6v48MMPvR09DkmSWLVqVdVrr70W2FsbiUTCxsfHK5YtWxaxadOm8q7HWrNmTdV9990XlZCQEO/j49PJ33Xfffe1ajQaavHixY1d2znK/Pnzh3OfR2Zmppzb/t577wVYf1bFxcUiwPQZcqnVli5dGv7qq69W2MokMRDYG1NXSkpKJGPGjImVy+WKxMRERUpKimbBggXd7DMcX3zxhffdd9/d6fkZM2Y0b9u2rcdpWc4zzP1bu3atzYWE8+fPHy6XyxWxsbEJbW1t5LffflsKmM6TXbt2le7cudMrIiIi0cvLK4UkSdgra71q1arqmpoam6+ZZ3Ahrscf5FAHBOEG4DCAdSzL7iQIooVlWU+r55tZlvUiCGIfgJdYlv2fefuPAFaxLJtn79jp6elsXp7dpweVIyX1mP/RCSwaF4nRw3wBAIu2mMb2r/tTe13ENhDoaQaPbj+F2WmheHVOcrfnV315FsW1KhQTr0DgapqRU198BiztjgdGh2Prryar358nR+OfB0vx7v0jcWdScLfj3EiSnt8PlZZGfJA7vl0xrk/H2HX6GsK8XXCwqA7vHCoDAIwI9cDyyTE291/3TSEEJIEDKyfg3k2/oE6lxe3xAXj/6GVseSgD4+V+mPTaT3ATC7Aiy/Yx+pvVO88iwscVO5Zk4s0fLuKNH0rw8t1J8HGwaMtg0q434s+fnca8jHCsvzvJ7n6vfFeE9w6XYeM9KZA6mWLQmhqlFpPi/HvM3tIVgiBOsiybbr3tzJkz5cnJyT36OH+rqFQqUqFQKPLz8wu7RjodZd++fbINGzYEDFYqthtBRkZG7GuvvVZpy7PrCEeOHJE+/vjjYSdPnizu77HxDD4HDhxwXbBgwfDPP/+8bOzYsUMvmnSLcebMGd/k5ORIW88N6DwMQRBCADsAfMKy7E7z5lqCIIJYlq022yC46ZhrAKzTAYSat90UNGtMMzacTcIa6gZNV5uKcIhslmZWag3YceqqqUJeRIf9YfZtIii8FPCTiSEkSRgYBkEepiBNUbUKd9rXLoOOUmuASmsKrLT1YQHdwaJabDxwEWevdbaSPDpxOGID7EdVhRRhsYzUq3RwFQks6fM05nHoaCM8XLqfCwOFgCQtacha2vVwEVIQD8EFjwBAm73NvXmaPaWm0uUaPX1dYpjn+ti1a5ds6dKlkTk5ObV9FcI8vfPMM88Efvzxx36bN2+26Z3mufm444472qqqqgpu9Dh4emfArjDm7BAfAihkWfZ1q6f2AFgA4CXz/7utti8jCOIzmBbOtVrZKYY8XDYDVyt7xOJxw6DW0Tc0vVWwpwuuNbeDZdlOU/4/X2wAzbCYlxGGAy2ADhRYGOHtoUWYt2kRYGa0KcLNsCwkAhLnq4ZWFhhu8RxFEGg3GLu9xt745NeKbkIYAEK8pD2KLyFJQsOY+qtX65AQ7G7JtKG2iGFmUO0xYgGJdrPNo0VjgFREDVnPMFdIQ2wjU4c1ni6m2UOVjoYvX5/phjFz5kzVzJkzr/uCPm3aNNW0adMGZfr9RnHixIk+R3TXr19fs379+k7T6atWrQrcvXt3p6n9GTNmNNmbdu9PbkTfO3bscF+zZk2nFDxhYWG6AwcOlA1Unzw8wMBGhscAeABAAUEQ3KqkZ2ASwZ8TBPEwgCsA7jE/9w1MadVKYUqttnAAx9bvqM0RSqm4IxqXMaxbJcdBJ8TLBR0tkE0AACAASURBVAXXWqFsp+Eh7YhUnrzSDCFFICnUAydpCq0GN7TRrVAbuhfrIAkC4T5SFNcOresYJ4b9ZCKodUbQDAuhgwLUyLDILW9CeoQX/jg6AnvPXENjmwGt7fpONzS2EFIkaCMLjd4IlZaGTCKw5CPmxLCBZgY1tZm/uxildWoYGRYtGj1chrAY5iLDkl6sQ9z5yn23bMGyLJo1Bni78rY7nt8e1hXfboW+s7OzldnZ2U6nNuPhuV4GTAybvb/2rsZZNvZnATw6UOMZaNQ6GgQBSIZYOqtgDxcwLHChWonfRXWI8/zKFoR4usBDIoKRNUBCuaKNboWKtr0mYZiPK34orINaa4CbZHCm/1mWxc+ljZAHusFf1n09zaUGk/0jzEuK05UtMBgZm95slmXxTUENPjh6CQ+PHYbJ8f6Y++9fodTSiPJ3hZtYgPsyIgDA7jGsEVAEaIZBTatpUb2bWGixJHC2DVNkePDOhUB3CXLLmzHr3Z9x9morov3dbpg9pzdoS2S4ZxsHZzNR6+2L4T1nqrD3bDWWTBg+4CkLATAMwxAkSfIr+nh4eHhuIhiGIQDYTYk1tJTbTYxKS0MioAZVADlCsHnR0IWqVpy43IQTl5vQoNbhzNUWhHlJIRKQMLI0XChTWVy1wXYqNk+pCEaWtWTNGAyOlTXijx8ex6RXf0K7DUFUWqeGTCKAv7sENMPaLbxxvkqJR7efwunKFqz84gy2/XoFZ6+2wlVMIb2LgHJkoSMXGa40Z9fwcBFaboLa9DRYloWeZgZVjAa4m24WzppT6Q1mWjdn4bJeuPQihj3NkWF7fnCV1oCvC0xOqoNFg5IJ6lx9fb2H+UeVh4eHh+cmgGEYor6+3gPAOXv78KtS+gm1joZESA65aFyQhwQkARwtbcCLXxcCAJ6bFg+DkUVKuCmpB80aQBECCEkxNLRtXzBXRa9WpcVwv8EpmvNjoUngtOmNePenMjzx+9hOz5fWqeEvE1vG1tymtxlBLqw2vaZ5GeH44mQl1n9TBALA8skx8JI6P70upAjQDIviGpNtJNhDArHAJOzadEboaAYsAPEg3hjFB7kj2t8NEd5S/FhUh/pBvGlxFppxzjPcbqcKXW55MxgWCPGUoKXdACPDDuj3j6bpRTU1NR/U1NQkgg8k8PDw8NwsMADO0TS9yN4OvBjuJ9p0NEQCEtQQi8YJKRJjo33xU3FHTuZDxfXwcxMjyixqjQwNEhQkpBRttG1fsMxsjahXOi6yGIbFe0fKkBnli5Qwz94bWKE1GLHvbBXiAk0rpzYduYQlE6Ms+ZsPl9TjdGULxkX7WsbW1GaweaySWhWEFIGR4Z745VIjLje0wd9djGCPvuU6F1AkaIZBUY0K7hIB/GUSi2e4TUdbIpmDWQHOw0WIVf8XCx3N4MeiOksGkKEIFxnurbw3FxnW2CmocqFKCW9XEZJCPJF3pQkMy4Ky68y6ftLS0uoATB+wDnh4eHh4bgi8GO4n1DoaYsHQiwwDwO+G++DIxY70qEcvNkAR5A6pyCRGjCwNkiQhFcjQRtu2SchczJFhB8Twwx/nolmjx5hoX/zzYCmAYvy8ahJCvKQOj/nTExWoU+lwV1IQSJJAUY0KZytbMDrKFz8V1+HRT04hxNMFWfH+aDaL4BaN7YJERTUqBLhLIBVRCHSX4HJDGwLcJb1GJu0hJAnQRhZl9Wr4ycSQiEiQJAEhRUCjpy3iTTTIlhmCICARUlg7MwGCfi452p9YPMO93CxIhJQpS4YNMUwzDIpqlUgK8YBURMHIsBjglOk8PDw8PL9Rhu4V8yZDqTVAJLBdl/1GE+nr2m1bTICbJeWbkTVFhl0FHtAYVTCy3cWHuzn6WqfquRJraZ0KPxbV4VRFC/55sBQ+riKQBPDqfucyDm3+uRxRfm5ICfNEqNn3XGBOg/buoTIIKBL3jgpDsIeLRdQ32xDDRobFqYpmBHu6QESRlqhkoLukzynvhBQJI8OiqqUdHi5Ci/AUCyhoDEa0mf3Nwhu0mDLQ3QW+Q7DYBofFJiHoPQ+yh4vQkjLOmvIGDbQGBmnhXhALOTHMq2EeHh4eHufhxXA/odbSvUa6bhRCisSskSEYEeIBAIj0kWJqQqDleSNLgyRIuAo90E6roTd2F7xuYgEIoFcv6mv7SyzFPgBgRkowQr1cUGROy8YwLFo1tu0MHFqDERVNGkT6SuEqFiDQ7HvOv9qK178vxonyJqSGeyI+0B0EQVisE81tncUww7A4XFKHNp0R4d4uIAgCWXH+EAtIxAf1PXGtgCLAAmhQ6zsV1hALSGj1RrTpzJHhIXo+3Gi4GxJHIvMeLkKbkeEL1UoQAH6fEAARRZjEcH8PlIeHh4fnloC3SfQTap0RnoNYccxZ7koKQotGj1U7CzAq0tuS9YJlWbMYFsBV4AEGRigNDXARdI4mUyQBDxchqlvtR4bL6tX47nwNJsf54c6kIDSq9IjwkeLklWbUKnVgGBbv/lSK174vwWtzRmB2WpjN41w1Z2nwNntGhRSJ+EB3fH3WlDkgwluKTKs0cVxkuKmLyF6zqwCfnqgEYEoNBwAxATK8eW/KdRVCsc5DbP2ZS4QkNHqjRbwN1ZujG42jNgkA8JKKbM5GXKhSIthTgugAmSm7B2+T4OHh4eHpI/zVup9o09FDtvwth6dUhH/NS0VWvL9lGwMGLFiQIOEqMEVLG3W286wHe7qgvLENnxy/YilHDACXG9oQufprPPH5GZAEkDHMG54uIkT5u0FAkfBwEUKlM6DdYMSWX64AMFV/s0dFk1kMu3ZM9adGeFkeTxsRiGG+HRkt3CQCCCkCVeYiHACw90yVRQgD6LRYTkCZPL59ZfTwDiHubiWGPVxEaGk3oE1nEuWD7Rm+WTAwji2gAwBfmQhqHQ2G6VC6OoMRlxrUiA1yh0wsgFBAmiPDvBrm4eHh4XEe/mrdDzAMaxLDN0EkkCSJTourjIxJuJEECTFpWuBmbxFdiKcLapU6rPnqHF77vsiyPbfcVLUuv7IFoV5ShHp2XijnKRWhTWfEmastljzFNUqtXY9nRaNJDPtb+V659GlAR2YLy2siCPjLxKgwR5QBYHf+NfiZ2/u4ieDaQ3llZ3ERUVgyYThcRRT8ZB1j9HEVoUVjQKu58IaLaGjfHN0ouMiwIzaSMG8pmjUGaK18w9da2sGwQFq4JwiCgMgcGTYyvBjm4eHh4XEe3ibRD2gMRlNeWQcWBA01jKxJuJEECSFpEnbtdJvNfUO9O6Kr352rxTN3KgAAtVbWiTAvl24RP85X+3muKVIbGyDD5cY2tOuNkNoQqVeaNBALSHi5doheazHrZqNNgLsEFU0aGBkWJGHKQRvl54rHb4+B3shcVyTYFmkR3kgO8wRplcrL280UxWwwC/7eikrcqnDlmB15fyK8XWFkWNSqdBhm/tyvtphmAJLDTLMFnKimjXaLC/Hw8PDw8Nhl6IcybwK4vLJ9TdV1I+HEMAEKIk4MG23nGh5plSv4arMGjWqT6CurV1u2p4Z3zyccaK6Otiu/Ct5SEeKDZNDTDBR/248/bcnttn9lkwberqJOthNrMSy1EXEN8nBBU5se9Sot3vzxIlrbDRju5wZ/dwlCnUjp5gwCsrPdwtvVtGjwFXPmDMkNOh+O1e3DRWX+DenbEQxGx7NJRPiYPrtaZccNV2WTBiKKRIy/ySojpEyfAc1Hhnl4eHh4+sDNp96GICrztPjNYJPoCs1yNgmqIzJstB0ZlooEWDphOMZG+4BhgZ9LTbmLC661IsbfDa9kJyEptLsYjg2UYdX/xWJSrB/uHx2O0cN9MCLUlNniwIU6XLOyNwAmm4SnVNipNLKrlQC2VfI6IdgdDAt8d64GP5c2IMBdjN8N9+6230DCiX4ORzyx/U2DtgpfXNmId4ufhFLfOOj9czRr9Nh5+iryK1u6PcdFcMWC3qP1MQFuoAjCUmZaraPxy6VGxAS4WWYcuPOEF8M8PDw8PH3h5lNvQxA1Fxm+CW0SXBo1gbkcMwBo7YhhAEiN8Ma96eEQC0j8+8glLN6Sh7L6NkT5ucHbVWw3S0NMgAz33xaB5FBP+LqJsXxyDFZNMZVX/vpsx4I9HW1ERbMG3lJRp2NZR4ZtVfmL9nODu0SAnaevobpVi0B3CTxcnC+1fD0M93XF9ORgy98UMfhfr/zmw5bHV9qKethz4GBZFu8cKsU3BTX4+Fi5xRbBYTCayiZTDiww9JdJcHdaCE5WNEOlNeBMZQu0BgbzfxdhudngxLCB5m0SPDw8PDzOw3uG+wG19ua1SegZkximSCEoQgASJHTG9h7buIgoTBsRhB2nruFclRKAKYLnLFG+bgj2kOCV/UU4UFiDh8cOw4nLzdAaGET7dz6edZSYorqLYZIkMF7uh33m9GvDbRQaGWgIgsD05GCkR3ghr7wJQgcin/1JG63E/mtbIaVk0BhVqGu/Cnj13q6/udzYhvJGDVxFFDR6GlqDEW7ijs+PZhgISMLhwsmzU0PxRd5V5JY3o7hWBZlEgEmxHRlRLJ5hPjLMw8PDw9MHeDHcD6jNqbSkN+GCKU4MCyAAQRAQkGLomJ7FMABMTQxCeoQX6lU6eEqF8JNJem3TFZIksCIrBnvOVKG4VoWcbacAAKMivTAq0r7FwVZkGADiA90tYtj9BuZ8DvZ0wfSUkEHpS2dsR7O+DoEuEajXXgXN6pHmlYXjDd+iTms/fd1AwpXsvj0+ALvPVEHVTsNN3PF5GIwsBCThcOny9EhvSIQkSutVOF/ViqQQD4s/G+hIYcd5kXl4eHh4eJzh5gtlDkHU5opjN2P2AOvIMACISHGvkWEOP5kEimAPBHtKO0VuncHHTYyFY4ZhzZ3xlm2/G+5j028b4C5GbIDMbsnrII8OQe4uGboFUPqT7ZdfxsvnHkaboRXN+joAgEzoDVeBO2pvkBjmFpQO9zNF51vbOxdDoY0MKIpwuPAJRRKI8nOzzBqMi/Ht5Bvv8AzzNgkeHh4eHufhI8P9gFprutjfjHllOc+w0CyGhaTYIpAHE5lEiGAPCVrbDd0sEhzrZiZBR3cvzdtxjI7TOdjT+Uj1zUip8gwAoKDlF0sWEHeBF8Jd41DcehIqfRNkosFdSNimo0EAiDRbVZRmGxEHzbCdcl07ApczOszLBXenhnZ6jssmwUeGeXh4eHj6Ai+G+wEt7XhFraGGnjFNaQvMi+dEN0gMA8Cau+KhbqchFdk/LXtapHigsBbpEV4QUSSi/Jz3MN9sGIwMdHopQKmw7+q/0UYrISCEkAjcECVLRmHrCZxu+gnjA+8e1HGpdTQkQgoBZuuMStc1MuycTQIAov3d8FNJPXImDO+WKq/DM8xHhnl4eHh4nIe3SfQD3Cp2YT8XdhgMOOErJEweTBEpgd6oBcMOvrAQCyj4WFV0cwaV1oDP865CpaXx4JhIu7YNjZ7Gt+eq8XNpw4BWLGtQ61DeYD8rR09UtpWgSnOp1/2uNrfDYPZ3t9GmhYxuAk8ISCH8JKEQkRKcbz3epzFcD206I6QiCv7uYsvf1hjMC+gctUkAwBO/j8W2hzOQnRbW7TnOM0zzkWEeHh4enj7AR4b7AYORAQGAcnLqdyhgWUBHmYSLhHJFg64KDEuDJAY3Ndn1UFxjsghcaWqD0ciCtJHJoVapxdcF1ThWZsq/6yKikBre/+kW9DSDZ74qAMMCj98eg4RgD4fbsiyL1y8sBQC8MeqHHvctb2oBKVSCMnrDSDVhhNdYBLkMh4AQgiAIhLnKcUlVgKttpQh0iYCAHBwfdZuOhouIQpCHBH5uYpy43IQ/jAiyeL0NZs+wM7eOLiIKY2P8bD4n5LNJ8PDw8PBcBzefehuC6M15U526ug8ROiLDJqEkoaTQM1pLMY6hDMOyKKxWol6lQ6FZDGsNDErru1fQ09FGrNl1DsfKGiE3p4GrUw2MHeRSgxqcLvvnwVJc7VJUpCeq2y9bHmuNPbcrbi4EAIg1k/DH4c8gzed2hLrGWERntGwkaFaPDRdycLh2h5Ovou+odTSkIgoSIYUlE6NQo9TianPHokzOJtFfJbK5WQAjb5Pg4eHh4ekDvBjuBwxGBgKKwE3okoDeqAUJyhI1FFNSGFkaGoO6l5Y3npNXmrHhQAme+aoAh0vqLdkkCqu7i2G11SKudTMTAQDt+oERT8U1KhAA3po7EkaGxQ9FdQ63vag8bXl8te1ij/te1RaAZQkQ2iiIKReQRGc/dYg0CuP8ZwEAylRnHX8B10lruwEyiSk6nRhiiopfaewQ9gYj4/QCup4QWcRwvx2Sh4eHh+cWghfD/YDByIAiCTg38Ts00DNaCEghCPOpIKHMGQDophs5LIfgSvRyk+PjY/wQ5uWC8qbuEVWNweRb/cv/xSI1whsEgDY93W2/60FnMGLf2SqcvNKMUC8XTI73x23DvXG5Xg2WdWwK37pq3KmmQ3b3Y1gWKhSC0QbDaJDZ3IcgCMg9UuEp9IPK0GzZ3qSrxbnmYw6+KudQaQ1oaTdgmI9pkRsXha9q7fhMaIbtcyo+W4jMlhg+MszDw8PD0xd4MdwPmCJdBJxYDzRk0DM6k8fULOQllEnEKPWNN3JYDlFYrURCsDsevz0G/7g7EX+ZEotwHylU7YZu4rNdbxLDnlIhKJKAu4vQsq0/YFgWbx8qxa78KlS1apEa7gk3sQCRPq5QttMO+VlZlkW5+jxCpNEIlcbgdNMh0Ixtu0qNUglCcgVGTRQMNAWmh+O7CT3RRrda3pNPLr2ED0ufQ6W6pG8vtge4CHByuCcAwFMqQoy/G/6fvfcOk6wu0/4/J1Wu6qrOeXpyjgxhYECSkkTEdVcUwVVY0de0676umFbXXX+6rq6s4V3FjJgARSUoMOQwwOQce2a6p3N3dVdOJ/3+OFXV3dO5p4ce5Hyuy8uuU6dOfU8o5j7Pub/P/cLRMNF0DrD6DCujpAhOl8E+w7Zn2MbGxsZm6thieAbIaWa+Mvz6I2dkkEQFQRheGY6rkdkc1oREUjkiaZUVtSV84spFvPu8OZT5nFT6XSSy2ohOEam88C0kl4U8SnHZTPDKsf6ibxlgTX5iXk2Jm3hWIz2JKnRL8gADuR5q3E3M868koyfHtDccjR5CEHUcWiM5TcAYp/LslUtIafGiDzypWRX1P7X9gO8f+jSx3Mw9BWjuTSAA6+cMTky866Y1pHI6mw50A1Y/4JmsDA96hm0xbGNjY2MzdWwxPAOouoEkiGMmo53N5IwMsiAPqQznxfBZbpNozVsh1uYrkAXKfQ4SWQ31FANpKi9GQ568GPY6istmguOntFFbkO9zXPAx9yZyE27jQPRVBAQavYupdc8D4HBs+6jr9mROAuBXKsjkQB1nvqNXKSFrpElrlg88oVk3OkfjuzgU28aj7T+dcGyTZV9HjPqQm8ZSb3HZ8toSVtaVsKfdav+mGQbKKN0+Jotpmnx7+7dpibUAg32GbTFsY2NjYzMdbDE8AxQ9w68/LWxVhgUZsVgZtmwSibO8MnysL4kArJszvDVahd+JqpskssOFbqEKXOKxJgqWehykcvq4FdWp0BZJ0VjqLr4upK/V5JPwwpMQw13pFlxCiIFIGW7ZEtMxdeRNyUC2h67sYUxDZlVdCYYpsLV57IvPLVnbiqphEmqkGM5R4JW+PxPJ9U04vt5MG4933DtmD2pNNzgeTrKkJoDXObxr48aF5XRGM8TTqlUZPo0JdOFMmB/u+SE3PXwTYFeGbWxsbGxOD1sMzwCWGOb1KYZ1SwwXKsMO0YmAUHyUfrZyqCtObdBNXdA9bHlFPrRjIDW8VFoQwwG3JdJqg24GUrliYMrpYJombQNpGkoHk9ECbktsFsbXl8hOuJ3udAuxWDV/esVDJCmgCE62hp/gxZ6HiutohsqXd7+H5syTGLky1s11sHauyLZmhZ7I6GLQXZgUmQvTlbaqqUtKzh22zsu9j044vh8d+Vf+3P4zDka3jPp+JK1imhQnzw1l/ZwQumFyuCeBZpjFau50SGtWm7aEmmBTy6bBbhIzdGNjY2NjY/PGwhbDM4Cqm4iCgPg6dA1bleFBz7AgiDglD0ltZHuys4Xm3gTNvQkW1/hHVCDLfZYYjowQwxpOWcQtW+vPq/CSUQ3CyYlF6kRE0iqpnM7CSj/fetdq3nNeIx6H1eassdSDQxLpiWfpT+bIqKP7lLeFn6Q704qRrQSgP24iidZYX+j+Y3G9P7T+v+LfRqYWv0vm/Ze5kEWBbcdGv/6GdgjpzlhieI5vGXO8S1kUWAdAONMx7j5m9TQ9mVYAXu17fNR1BpJW9bsuOFIMF24UOqNpVM3A65h+dHlBDAPcvfvu4mQ8uzJsY2NjYzMd7AS6GUDVDStA4PWnhckZGbxSYNgyl+ghrZ9dfYabexP88pVWKv1OtrYM4HVI3HbR3BHrFTzBydzIyrBbkZDzwmle3tPbFslQO4p4mwrt+UCJlbUBblxbz41r64vvyZLI3Aov3bEM//I7azJcmdfBJ65YSG2+atybaefeY18FQI2eA0BWA8O0hHNP5iQpLYEoiLzYO1glNjL1eJ0yAbfAwhqRnpgIpj7iEUXBJjGQ7WZH/9MoopOAXMaVte9BNzVak4cmbKV3NL4LAAGBE4l9mKY5wiNfqMbPGaUyXDgvBzrjmMDqhukn/2W0wbCUeC6OLImIgh3HbGNjY2MzPezK8AyQ0w0kQUB8HfokcrrVTWIoLtlL5iwTwy8fC9Pan2JrywBrG4P88vbz2TCvbMR6AZe1L2l1uP0hndNxKVIx7GF+hVUtbQkPn/g2HU7mE+ZW1I8eu7yiNsCRnsHjGU7m2HFy0JNdsKQ0KVdi5qzIYVUD3bR8zwY6h2PbiOZ9vUtLzsOpzYPkKqS8uK8rFYklRdRRBKFLtvb1YHQLfdkOSh1VOPLx25Ig45VL6M92jekFBiu0QxJklpVcQFTtoz/bOWKdgZRVGa4vdY94L5j3ah/qjiMKcMmi0aOVJ0OhMlzqKmUgO0BOz6FIom2TsLGxsbGZFrYYngFUzZpA93qkMIFuKC7JS1ZPo5sz13rsdCncaJwzJ8gX37qMNY2hUeN8C57gzClt05I5DZciFivD9SEPaxqCbDkxMOlAjLFoj6QJuGWqS0aKQIBPXbVkxLKh48voliDv7GoqLstpwrDjfzC6lahqieEKZz3lqdtwiF7k/DGoCYmoukA0NVLQKoIDSZA5mbL6Cq8ru6KYOAigmyp92Q6e7Ro7sjmuDuCSvNR6rC4XB6JbCJ8iiMPJHE5ZpMzrHDkGSSTgss5NiVuhKjBynclSEMOVnkqSapJwOmyJYdsmYWNjY2MzDWwxPAPk9NenGDZNMx+64Ri23CV6yBkZ9DECH2aDaFql3Ofgng+cX+zhOxr+fGU4o+nDRG7RJjHkPF2/upb+ZI6uaGbEdqZC20Ca6oALn3N011F1iWuEdSCWHTy2Gd2qLPdHfcVlRztlCtl6bslHS/JgsTLsUQLkNAFFNos3CY3l1k95y9HhYzjcIfD8fokF/jXFZUFleFV2gX81ALsGnhtzH7N6CkVwEHRYnubftX6H/9h9C1l90L/bE8tQ5nXgUkb3A4fyPZ4DbmXMdSZDQQzPK7GE+U/3/hRFEmwxbGNjY2MzLWwxPAOouvm6FMO6qWJiIJ9SGZZFBc1UMTh7KsORlIrfpUzYhUASBXxOmacO9vIPv9hWFMSpnI7HKQ/zuS6tsWKMj/VN3yqhGQad0QyNpZ5xr4H779jA565dwo4vvJnGUg/xtGWB0A2TtGZ9v6m7WL9AQwB6IhJqfBkAVa5GBrJdDGR7APDJQTIqOGSQ8vuzoFpkXpVAZ//wNLqDbSLbmyXmSFcWlynS8Juf1aVvIuSoRDXGnkyY0VPIogOvXDLs5mnLkMl0XbEMFX4nLmX0c1SWF8NBt3JaoRsFMbw4tJhaby3be7bjkEU7gc7GxsbGZlrYYngGUF+nleGsYVVET/UMy6ID3dTQjJkJpehKt/ClnTexueeRaW8jks4RcMmTElF+16C4j6atCmw6p+M/pXK7pNqaONg2kGa6JDJW2l1j6fiT8CoDLv7hkvmEvA7KfQ52t0cJJ7J84Y97efqw1aXBNJysm6vgymvNTPu7ua7mQ1S555A10hxL7MEpunFJbiJJgRKvWbSKCIJAXUhCN4an0cWsojMH263xWWJ2+PkG8CulJLTomL7htJ5AFhQkUcIj+4vLW5OHAOs3EE7mqAu5xwyfKc3bJ8p807dIwKAYdspOXLJr0DNsi2EbGxsbm2lgi+EZ4PXqGc7plhgeURnOi6WccXr2gQInk4eJqn38vvV70/LnmqZJNK0Wo5QnotDjF6zKq2GaZFR9mEgGK5p5eW2Aba0D6Pr0+g0nT4l5ngzr8jaPHzx3jJ54lrZYfjKd4aTcL+IqDN9U8EnVlLlqATgU20aZswZVc5DKClSVDL/mnApoGgw9xLGUtc6xTpmbmz7LdXUfKLbRG4pPCZLSYqj66NXhjJ5CEa19vKD8WhyiFSYSVwcA6E/mME1oLPOO+nmAy5ZY9gz5NH8rBTHsEl0oooJqqLYYtrGxsbGZNrYYngFyunHa/8DPBoXH4pIwsjIMkDWmXzEdSqFbgmHqaObUfchpVUfVzWKgxkQEh4hhVTdJ53RMhovkAh+7fAH9yRx3/HL7pIIxTiWVT7ordEuYDJ9/6zJW1pUU7RmynMU0HIBIqU9gqC5P5kxKHVXF1xWuBjrD1nfVlw3/+boUAVWHY90CyQxkVGsiXqnPJJ0TicQd+B2lo47JL5eimSr9ue5R38/oyaIYbvAt4j1zP01QqSie23jGOg4140yMe/e5jXzhrcv4yGULxjk6Y5PVs2zv3k5aSyMg4JAcKKKCZmi2Z9jGxsbGZtrYYngGUHWz6N18PVGwScji8IqpkhfH2fzErtMlqcUAq0XYIUPzqAAAIABJREFU0AlXk6UQoFEVcE1q/aFV2qyms6vNqryWuEdOcHvLsmoW5HsO37f15JTHVqgMl0/x0f/1q2sQBLjp3HquXRXC1K3Pux1ScTIcQDoLTmmwS0WlsoCndku4HQZLaofvj0MBwxT48zYH9zwtc7TDuiZXNFrvd44TKljqtAT3nsgLfHnXzbQkDpIzsty1/2M80vYTqzIsDO6jJMp4ZD8p3QpnKcRfV/rHPkeiKHDbxrmsbghOdHhG5aNPfpT3/eV9PHvyWRySA0mUUCSrMmx5hk8/TdDGxsbG5o2HLYZngNetZzgvdsesDE9DuI7G0GjnQnuwqVDw/dYGJyeGF1cPelozqsGmA9bEs0LQxlBEUeDxf7qEK5ZW0hJODZt8NhlSuXxl2D15mwTABy+Zz44vvJkvvW0FSFnKfS4+dp2OSxH5x+tcvGW19dNMW617meNdhlcuobevgXRO4O8uhIbS4QLcpQxeg1lVYNMumYoSnbeuV5BECMfG/rmXOasB+HP7zxjIdfPHk99nS9/jtCQP8FTnb9DMXPG6KOCWfWS0JLqhEc9Y52iqNwVTYXevFVpyaOAQDtGBIAjIooxu6nZl2MbGxsZm2thieAZ4vYrhVL5i65SGT/4qdAuYOTEcK/5d6IgwFSJ5MVw/yaS4ueWDvtWsptOfzHFeU4jrV9eOur4oCiys9BNJq2PGJY9FKl8ZDk3BM1wg6LHakEWyEdyKgzWNXiTR6oV88RJLVGZV67q6svbdvCn4MWJJBUUyOWeuc0SfZecpTo31C1X++XonlX4ntSGB/vjYP3en5KHMWVN8fTyxlwda/gcAUbDaoCnicKHrlvxkjBQ5I8veduscn07/4KngVtyIgohDdKAZGrJoi2EbGxsbm+lhxzGfJqZpvm5bqyXyFdtCXG+BQiDDTHqGJUFGNzUiuamL4WiqUBkePdTiVDbMH0ymi2VUElmN+pAHpzx2b9uGUje6YdKTyNI0Rr/g0UhOwzM8FM3Q2Nu3l8WhxYhDJrb587u6v1VhYY3B9mMi245a5ynoNXA6Ru7L0MrwjRcYXLc2UEzca6qU2HLUQNNyyGO0p7uu/nZOJPaTVCNs639ycIx5n7dySmXYKbnQTY3d7WG2tVoT6fyu6R2HiTBNk+yQyX2lrlIUUUEWZWsCnWyJ4dFiom1sbGxsbMbjjFWGBUH4iSAIPYIg7B2yrFQQhCcEQTiS//9QfrkgCMK3BUE4KgjCbkEQ1p2pcc00Wc3yKZ5O39TZomBfcMvDOwAUxfAMVIajuT5iaj+h/CSw7kzr1LeRUVEkYdLV10q/i99+8AIAfvZSC8CI0ItTqQ9Z7/fEpjaJLpXTcckirnGE9njs7NlJUk0yJzBnmIgLekWuP0eiJyrxw8cVth0d3L7PZaCII6+3oZXhgEssCmGAOeUiGVUgMkpCXQFFdLAwsIZVpRezKHAOFc56ql1NxfdL81aKAoUnCAPpwT7NygR9oKeLZmjopk69rx6AWl8toiAOn0BnmtiJzDY2NjY2U+VMKrifAVefsuxO4EnTNBcCT+ZfA1wDLMz/74PA/57Bcc0ovXFLPHmnUE08W0hoURTBOeLxd9EmYUx/Al1fpoMTif18addN9GbaqHDW4ZK8dKenLoYTGQ2vQ54wcGMop56PodaJ0VhU5UMUYPOxvim1f4tnNDwOqRjzPFX+d9f/EnAEWBxaPOK9v7nAxbsukllSr3P7FQZleSt0wMOoUdTOIZVhr2v4++UB63UkMfE4RUHi4qq387bGO1gRuhAASZApd9UNW69w0xTNWNfJuU0hHGfopjCTbwO4tGwpt624jcsbLgdAERV0U0cWTauNHrYatrGxsbGZGmdMwZmm+ZwgCE2nLL4BuDT/98+BZ4BP55ffY1oq5GVBEIKCINSYptl5psY3U/Tm23F5R3lsfbaT1GI4JXfRE1pAmYEJdN/a/5FipwGAuf6VRNRewtmpn9J4RsXrlKYktDxDzsdd71rDFUurxlkbakrcfPyKhdy16Qgf/80O3rW+kY0Lyyf8np54hpDXgXMaFVHDNNjdu5tVFauo8dWMus41a5xcs8a6Wfn1C1YFtjI4uqAd6lDwOIaPJ+i1PpPMTW2M9Z6FrCm9lEpnA05xuE2l0I86mkmhSB6+++61U7phmQoZzRLDiqiwpnIwWlqRrDGIopa3SZyRr7exsbGx+SvmtX62XzVE4HYBBYVSBwzta9WWX3bWU6gMj9bD9mwnqUZwSm4khovhgsjJnkboxlAhfEPDh6lyN1LiKCehRciNE/s7GrGMhtcpo0yh+uoeIoavWFo5qcr9xy9fyI1r60irBs8cntjbbJom3bEs1SUu5EkKddVQ+ebWb3L37rvpSfWQ0TOUucqG+YXHYuMSax/etHT0fRlaGfY4hx+roMd6nc5OrYItiTLnlF1Bg2/RCC9uobtELJfC71LwnSG/MAwXw0MpvBYlWwzb2NjY2EyPWXu2b5qmKQjClP/pEgThg1hWChobG2d8XFOlENQQfB2K4YQWRRGdI4RY4fF3bpqVYc1QERDxKyHOK7+KUmcVoiDilrzkjAyqnsEhTr7rQDyjUun3TWlilEcZvLTdyuSq9qIo8K13raEvkaW5JzHhZKx4RiOt6swpHd+CAdAaa+WljpcQBZGf7fsZAM+cfAaAUvfoQRin8q4LHVy9Vhy1XzJAiXuoGB7+XsAtIAiQyk3PzmGa8MCLEg7ZxOUUqA6alFZY10kim8HvmpqNZaqk89fiWGJYklR0k2klHNrY2NjYvLF5rcVwd8H+IAhCDVAov7UDDUPWq88vG4FpmncDdwOsX79+1v/lK1SGQ56pt9aaKY70xPnm44c5f24p779o7qQ/l9SiBJSyEfG8pxvH3J/rxsRgkX8dc3xLi8tdkiUaY+oAXqVkUtsyTZNEVptyt4ahleHJVm0L1Ic8bG8dIKcb43agKNwIzS0ff3LeydhJrnvwOgCc0qBK3dO3B4AyV9monzsVURQIecc+DkN9wm5luOgVRQG/a+qV4QKJDLT3W8dRlkwOnBS5cI01lr5kipWlzjM6ibRQGT41IKb4WtTQdcl2DNvY2NjYTJnX2ibxJ+B9+b/fB/xxyPJb810lLgCirwe/MFiCyOuUcE2y+ngmeO5wH5ph8mJzmO88dYREPhp3IhJaFIc4MshCEEQkQZ6ynaFAe/IIAAFleMVzUAyHJ72trGag6uaUbzYUSWBlXQkfuKhpSp8DqA+5SWb1CY9jIQykPjR2y7eMluHaB68tvs7qWc6tPrf4+rKGy2gMzNwTjiW11k96tIp2wCOQnmZlOJqyPnfzJQb/dYt1zUQSlhjWjBzXrhzd8zxTFNqqnSqGHZJ1XThlLR/bbafQ2djY2NhMjTNWGRYE4ddYk+XKBUFoA74IfA24TxCE24AW4O/yqz8KXAscBVLA+8/UuGaa3ngWv1OZdjeB02VXW4TNx8JDXkd5eE8HN507vsDK6RlUIzss6ncosqCgTlMMH4nvxCG6qHA3DFs+tDI8WQqCs8I/tTAHQRB46GMb0aYhjgpJdz3xDGXjJKrF8mK5umRsMfylzV8asezC2gvZ0rUFRVS4Zu41w6rFp8s/v81FOKbiG8Uj7XEIRNMCTKN+Gst3T6sLyYS8Mn53lnTGAQq4XSrXrqwefwPTYKhNJa1ZNomC+C1QEMflATBM6Iymz1ivYxsbGxubv07OWGXYNM13m6ZZY5qmYppmvWmaPzZNM2ya5hWmaS40TfNK0zT78+uapml+xDTN+aZprjRNc+uZGtdM0xvPWq21Zil0Y3vLAE5Z5GOXLyguawlP3BKtkAp3aoeAArLoQDWm2Hogz4nEfsqcNXjk4WEeBTEcV/snva2CGK4umVwU86lM1SIBUJdPugtP0HqhMLbRUtcO9R8ipabY1r2NBcEFfGjVhwCo99XTFGjiysYr+cCKD+CWJxckMlkUSaA65Bi19ZpLEdD06flqrcqwSWWJdTyrgyInuqzjNKdCo8I3vfMzHpfedykf3vRhYNAmceqNQ8EzXOKzzkV7ZPqTPm1sbGxs3pi8/pIizjJ641l8LnnWUq+O9SVpKvNyZb51mEsWaRtIkcqO/4i/ELjhOAOV4f5sNx7JP6Jlm7tQGc5N3iZREJy10xTD06FQGY7kk+/GIppW8TgkvI7hlchwOsw7H3on73/s/XQlu6jz1bG8fDlfuegr3L7qdmRR5oYFN7CifMUZ24fRcCqgGcK0xHAsJeB1mUUv9vwqCdOwqrRr54qjiu/TQTVU+jP9vND+AqZpklSt0rTjlBS8Wm8tTsnJ/ce/i6D0TTk0xcbGxsbGxhbDp4FpmvQlcvhnKXBD0w06oxnmV3hZ3RDk5c9czg9uOYe0avDnfV3jfrYQxTyaZxisjhKaOfXKcEZPkjVSeOTAiPdckhdFcNKbbZv09k63MjwdqgMuRGFiMRzLqPhdMk5l+M/oiZYnANgf3g8MTpALOAOTnix3JnAqApouYExjllk0BT6XWeyn/HcXKnzhHdbNjShNzqM+FVqiLcW/U1qKf33pX4GRNomAM8DtK26nPxumrGYrR3ri2NjY2NjYTAVbDJ8GyZxOWtXxuWZHDKdyOjDop60ucfOmxZVU+J30xMevkBUqwwXrwqkowvRsEgO5XoARFgmwfLylzmq6M62Trk5GUiqSIEzZM3w6yJJIpd9VFOKjoekGJ/qSBN2OEWEg+8L7kASJCncFAsKYgRqvNU6FvE0CUlnY1zr5am40KRDwmEXbiSgIzKt0IyCQ0qafVDjsO7LWNdkWb+PbO75dXL6rd1fx71PFMMCSsiXML5mP7DvEiXCKLScmb8OxsbGxsbGxxfBp0DfLUcwp1RLDJae0HQu6FdJ5oTwWGd0SMON5hnVTxTCnNgEtkrW65bmkkWIYoMxVQyTXS0ZPTmp70bSKzyXjkl/bY9xY5im2ThuNvR0xBlIq162qGWER6E52U+Ot4c7z7uRLF36J+SXzz/RwJ4VTEVA1MEyTB16SeWKnTG904vOr6ZDMCpSdckoFQcAhOUioidMe2/2H72fjbzZyqP8QH970YZ4++XTxvTueuAOA86vPH7OyvqxsGUmzE58nxfNH+k57PDY2NjY2bxxsMXwa9KesyqnPOTtt1QqCN+geXi0LeRykcuM/ui6KYWksm4QDzdAwpyiGB3KWGPYpwVHfL3PWoJsa7aljk9peNK2e8UCH0VhZV0JnLDPmTUVP3Jqo9eZlI2Oeu5Jd+BQfDslBqau0GBk827gUMEyBVw/L9MctAd8Xn/j8xvLZK+WBkeeg3lfPscjkzuV43L37bgC+t+N7nIidsMYruVhRNuir3li3ccxjuaR0iTXGyuOk1fFvBG1sbGxsbIZii+HTYCDfbcDjmC2bhCV4Q6dWhj0KGdXAGMccmtVTCAjIwuj2A1lQ0E0VnakJi75sB6Ig4ZdDo75f5rQsA63Jg5PaXjRtebKdr7EYXlVfgqabHO8bverZn8zhkEWqTrFvmKZJV6qLgHOkZ3q2KcQ1b2uWkUTr2khmJj6usXyP4eqSkesuCi2iM9lJd7J7WmPqSnaxr28f4bQ1qfLpNqsivKx0Gbcsu4U7Vt9RnDQXco5+TQHU++sRETGVDtI5HcNOorOxsbGxmSSzFsf810B/XgwHZqmvaaFqeapNosStkFF1dNNEZHRfaEZPoYhOJHH0qrYsOtBMdcqV4XC2A58cxDFG79yQoxIRibbUkUltL5JWaSz1zHi3golYUm2J2fZImmW1I9PywskcQbeC+5QboUg2QlpLU+KcXMLea8lQN8+/vF3kq783aQtLqJrA2nkGj+2QKA8YXLR0uJCM5y3BVcGR18qckjmYmOzs3clV3qsmPZaeVA/3HbqPn+79Kbm8N/2i2otwyS40Q+O6edcV2859/oLPc7j/MF7H2LHXoiAiSzKSqZJWdXTDRJyl3t82NjY2Nq8vbDF8GgykCmJ4dj3DwVPS2YIehVTOEgRjBeNljRSy4EAURq8MKoKCbmoY5hQrw5kOvLK/GOl8KqIg4VOC9GfH73YB1iS1ZFanfJzgizNFsb3aKJPoXj4W5mh3guqga0TF+kd7foSAQIO/YcTnZhtXvjJcW6qzuCaAz5XkRLfMiW4w0TneLXK8W2RJfZYy/+B+xdICgmBS4R95rdR6awE4GD7IVU2TF8MffOKDNEeaWV62nH3hfQA0+hu5sO7CEeuGXCHOrz1/wm0qooIoqaRyGpo+9rVvY2NjY2MzFNsmcRr0J1UkUcDjmG3P8Kk2CQc53Rh3El1WT6OIDoQxLgFrAp2GZk6+bZZuaPRm2/HKQYQxRDaAXwkRm0TwRqGbQ+UooRZnGr9Lwe+SR7RXS2Q1fvTCceJZjQqfc1jFemfPTn598NesqVzDsrJlr/WQJ6TgmnHnD+f7L3Vw6Qodp2JyrGvwGu45ZVJdLCXgdZq4R/HGB51BXJKLZ9uepSs58Q0OWD2Ej0ePM79kPrcsvaW4POQa2wYxGWRBRpRUVN2ccAKpjY2NjY1NAVsMnwYDyRw+p4xDnh0xnMrpCIysTJfkxXFinOCNjJ5EEpQxK8OSYG1T1Sef6NWSPIBqZKlw1o27nk8OktJiaBO0bivGHQdeux7DQ6kLujnYFUczBsVhd2zweBR6H5umyc2P3Mwtf74FRVTYWLdxRiOWZ4p0zlLDhQcJ58xX+Ps3Bagvk+iLDV7Dp/qI4ynwukwUceS1IggCy8qWcSRyhNsfv31SLfPa4+0YpsHy8uV4HV6uaboG4LStJYqkIIrWNRPLTC890cbGxsbmjYcthk+D/lQOj0NCmqUo5lROw6VIKKeI8UJP3oFx4oSzehpZVMasDBfEcG6SwRsHoq/ywyOfQ0Cgyj1n3HV9SpCskSapjR+QUJggOBs2CYBSr4NoWuWezYMBEF3RQTFcH7Q8rc2RZnb37QbgkvpLWBhc+NoOdJJcuFhm1Rx4y+rh57yhdPjrVHb49RxLC5R4zDF927cuu5V5JfNoibXQGm+dcByFdQoT4q6Zew1f2/g1qr3Vk96X0ZBFGQSrkh/PzHwQiI2NjY3NXye2GD4NBpI53MrsieFYRsPrlFBOmShUlxdpfeOI4bSetMTwGDHSBTE8UfUWrPjluw9/loyewisHCTjGT1nzyVbbtb5s+7jrZVSrIlvinp0Jip+9dikOWeTlY+FivHXnEDHcWOoB4KFjDxWXLQwunLVo7olwOwQ++VYvKxuGNwwuD1jjVSQTt2OwewSAbkAiAyHf2PskiRI3LLgBgJc7XgYgpY4dxLGzZycCAtUeS/wKgoDX4R3zKcVkUUQFBOt6jWbGTw+0sbGxsbEpYIvh06A/aVWGxVkSP7G0atk0TklAK4jhaHqcyrCRQhFGpnkVkASr2jyZSOaH234IWNHOS0rWo4hjbxcGexD3ZTrGXa/g+wzMkhheUVfCf7x9BYYJnVGr2W7bwKDIayj10JXs4id7f8LK8pV85rzPMD94dgRsTIWh/YNFAY52KrSFLbtDIg0gUDaOGAZr8pssymzp2sJfjv+F8391Prt7d49YT9VVfn/k9ywOLabCUzGTu2GJ4bxNwq4M29jY2NhMFlsMnwb9qRyeWUqfA0sM+11KMSK3QNCj4FLEEZO/hpLWEiji2PYDcQqV4eOJ/TR6FnPzvDtZGdo44fqFynA4O4EYznfLmK3WdQD1IevGojeRwzRNWsIpaktcvGVZFfMrfWzu2AzAhpoN1Ppqx2xVdzZT7s8LXQHefp51rNvCJl0DAj990npdFRz/PxWyKDPHP4e94b3ctf0uAG5+9GZean+puE5KTbHu3nWEM2FWV67GKc+s/UURFUxsm4SNjY2NzdSwxfA00Q2TaErFO0udJMCySZwauAHWY+faoLvYB/lUMnqKrJHGPUZkMgxWhlVj/MfNOT1DJNeDTwkhCtKkHnV7ZD8CIuEJ2qulx4ibfi1pCFlWiMM9caJplXhW47Illdx963q8LoN79t9D0BlkTmB8n/TZTFleDDskuHyFgihAKiPQ0mstb6rUWN048TlYVraM9kQ77Yn24nVwx6Y7+N3h3wGwo2cHAG7ZPSxZbqZQRAXD1PA4pHEnj9rY2NjY2AzFFsPTJJpWMZm99DlVN0irOqXe0S0JaxuCtPSnyGkjW0zFclbal1saL8SgIIaz446jN+/79SuTb4slCiJeOVCMbh6LtKrjkMTXPH1uKDX5jhHPHe7jYJc14W9RlXUTsallE0cjR7my8Up8jrFvLM52gh6BK1ZKvPdNApIoEPRCIiMSTwm4HAb//FYPwTGus6Fc2nBpcVLcrUtv5SsXfQWX5OJLm7/Ev774r3xo04cA+MS6TxB0jR7XfTrIooxmapT7HHToz3Bv81dn/DtsbGxsbP76sMXwNClUXWerMlx4DFzuH/1R88ULK0jldA51j4wTjqp9ALjGEcPFCXTm+JXhIzGr2hdQSice9BACShnHE3v5S/s9pLQ4kVzviHXSOR2nIs7aBEUAWRJ5z/mNAOw8GQGgqcw6bn858RdCzhBrK9ee9uSv2UQQBG65xMWGhdZ+lflFjnXJ9ETB5zJxTfIad0gObl12KwuDC2kqaSLgDHBJ/SUAPHj0QQCaAk2Uu8rPyH4oooJmaJT7HcTFXWzrf3LCpw82NjY2NjZ2At00KaTPjRZE8FpQaDtWOoaF4NLFFSiSwJbj/aysG96/NZqvDHvkwJjbL4hhfZzQjZbEAR5t+ynVriYqXY1TGn+5q5aOdDOPddzDYx33ICLxT8u+R713QXGdjKrjkiUUaXaF5scuX8CvXmnlSI91Y1ETdHAgfICXOl5ifdV6/A7/rI5vpmkoEznSadATFZlbpU3p+C8ILeDjoY8XX18992qWli7lZOIkhmGwoXbDjHuFC8iijGZoVHolmrNWqEtLYj+1yshUOxsbGxsbmwKv33LWLHM0L4xKPRM/Pj4TFNqO+Zyji+Ggx8ElCyvY1xlFN4YnikVVSwx7lbFDDoo2CX1sm8S28FPopsY5ZVfgkj1TGn9hEp0iOqn3WO3IfnL0X0lq0eI6aXX2K8MA+wZewumKEE2reBwCn33lg/zdw3+HZmgsL1t+VrRS8/7iYcpu+zdcj71k9UM7DW65ZPCaDp2m+0MRFRaEFnBZw2VcMecKPMrUrpOp4JAcaIbGv/TciVeyJmcej+87Y99nY2NjY/PXgS2Gp8mukxG8DqkYvPBak9UKbcfGLu6/eVkV0bRGc29y2PKEGkEWFFzS2MKkmEA3Tmu1ttRhypzVlLvGT5wbjXn+lTR4FnFF9U1cVXcrF1e+nYFcD892/b64Tiqn45RF5FkUw8+1Pcc/PfuPOJvuIiT0Eaj9GYcGDgBQ76tnUWjRrI2tgLLnCL57HkFu7aLkG7/A/cCm09qeIAgUclyuEHdRefQZmESy3GwS6D6IgohuaARTu4nnx9+aOjS7A7OxsbGxOeuxxfA02d0WpS7oxjtLrdUKleHx2o5dvMjq47qvMzZseVKL4pQ8xervaBT7DI/RWk01crSljlLiqEAWp97twSm5eUvdLdTlbRHzA6sJOirYPfBCcZ1YWqXEPXYwyKTRVXjsc3DPDVP62M/3/ZyPPPkRAEwhg7n4v0i6LSH8sTUf4/aVt5/RSudkUfYdAyB1xfkAOLfsHblSTkXZf2zSolbWsywTTvCRk99k2bPfon7X/YTats/YmGeSQPdB1j38acq6D6CaGm+aUw+AbAr0ZE6iG3ZnCRsbGxubsbHF8DQwTZMT4SRlPueIHr+vFZl82zGva2wxXhd0U+F3crJ/eBpYUoviEF1IjC2GxQkqwzv7n0U1stS450516GNS655PX7adtJ7CNE1iGZXQ6dpQWl+Bfy+Hzd+FY89AYuREvbG4/9D9ALxj4TsoF13ogsDb4gn+pWQt84LzKHOPn7T3WiF1hTE8LnLnLkNd0IB8sgeGWGOklk7KPvQVSj/xX7j/9OyktvlD5b951PnZ4usF237J6sf+jcXPfOusqBIL0QTKTqvqW3X0aQAC0cG+1R8YiHN9ykdGT3Ig/vysjNHGxsbG5vWBLYanwUBKJZXTCXlnr/9tVstXhp0yxLvHFChrG4K0DaRpCSeLk/6SWgxFdI7bAWGiyvC28CYCSin1noVTG7hpgGly5b4fs/HQb4a9VeGqQzc1WhMHSas6qm5S5jvNyVbNTw5/3XNg5DrHn4OufDXVMCDVT1bP0p5s5/Lgct7X08GvTjRzT0cX/9Y3wCWJCLJ49sw9lbr6MAJeTEUmt6QJqT9K+S1fQEhb0dG+ex9FPtkNgOcPeeHYc4i1D91J9eGRlgolHeFiaQ8AfSX1HFzyFrrL55P0hKhpfgZn/4kzuj/uaAdVR58Z833H9gNUvvNTlH7qLkq++L9UHnkOgJK05TevN11c3e/jxkgWvxzicPylMbdlY2NjY2Nz9vyL/jqiUGk97arlNBHiMa744Zeo0dxUHWmBpz8DC6+Cd/4YnMM7G6yqL+Hx/d38+yOWCPzhLeeQ1KK4JT/CuGJ47NZqaS3BkdhOFgbW4JYnP8NK0dJ85KkPsbP+Cla0WwJmZ8OVJDxWq61KVwMAzfGdlLDMWjZG67hJ07MfXCWw+t3wyvfh8c+BrxIWXwNrb4FDj8L9f28t+8ir8Nw3YPN32fm+36EZGtcdepZ5Ket8V+sGSV8Zvkjb6Y1pLHQDz++fRF00B3X1IhzJMHO33Yu/r5ldV38Z1TO8N68z2YeSiSG39aD7PSBL5M5djtQ7gOuVvXh/8Qjpay/G8coetGX1OKUk5qF+6nY8QN3RJ/HEOnDEOlAyMXrnXoTy400YJX4cV1oe8J0rbyBSuQQUJ11NF1DSf4K1r95DWcsrdJQ2wSn2FbErjFFVOmL5REg9feihElAUME3Oe+D/IGAyULGIXEnt8JVVjcA3flF86XppN7o/x6GLrqE/3cTDAAAgAElEQVQpF+PyXDc1Fcvp3HOced0dXLPhI+Q015TGY2NjY2PzxsIWw9Pg5IAljmalk4RpEvjVj/Ad308tUPKXh8EJHHkMvlpvieKb7yuuvrjaap/2T/L9HDYa2Nu+kIQWpUbwcM3u/8fjy29Hl0buh1isDI8Uwx3pYxjoVDjrpuTnrR+wHmuvaRus1s7p3cq+OVcD4FdK8clBDkS3MF/+WwCqA9MUMql+OPRnOP48lM6DhvPYv/te7tHbubjzKNce3YSw/R7o3GWtn+iB/2ziVZeTX1aWE9nydUImXJxOs2X13xBM9ZMWRapi3QTDx0HXQJqZn48QSxL6v/+NmMogdVstweQvXor3548SWpLAFdSY/+J3OXjFZyAf9+xIhtnwm9uInnDT0R0iN78eRU+gSj7S127EceA43vs34b3fqvzWVR7CiKt054LMefZXDDR7SZaHqKgfYP6Wn1P3+C85/lglAE29vVAG2pYk/sgWMhvmoy6uIe2xbCGLdvwaCTi57qbiPohdYSpu+TwA0X+8mcx1Y8dyO5JhKo+/SNvy63GfOELgg9/CWWnQ+48fwluRRcB6ynHOw3fy8k0/xpQGn8A4dh9B6h2gfmM//dXLST3QSS4uM1DahOmr4EYA3aB801bSWZmKeUdpXzfzaXc2NjY2Nn89vDFtEloOtv0com3T8j/ubY8hiQLVJa99xcn9/JP4HvsTuscSYolOFzRdDKvywuTIY5CJgZqBY8+wpMpHBRE+IT/I9xzfpmHPf5PRk1zcuZXFXa/QdOxlNnzx2yz55Z+Gfc94leHcid8i6SZX795D7YHdkxr3m/f+iBt2fKv4envVORgIlMdbi8sEQaDeu5DO9An6k1YHjJpg/hgfeBh+8x5r3ybDpi/CH/+PZctYcCWm7ObuxRt4xOflzspyLmuoo6V3SNutKkswfTcU5Cmvh+3pTm4diNDWtIFk1WLa519M/9yLiIYacOaSuMaxCrhiXQhjTNpS0hEEQ0fQB4+rcrgF5XgH4kCc7PL5APh//TDREx5attcQ81VS3bqF8x74MGXHXwZgxZNfAyB20gUBhYaFxzn38NdZc/QuyqO70eqqBo+rbFJSESVdbgWjND9SRf9BH30vuDmxqYyu7YGiEAY48UQFiQ4n3j/sx/PMQfy/sr4z5xx8CtCw9w8I2mDbPcfuw8W/S+76JZ57Hh794JgmKzb9fyx45cf4OvdS8Yt7Acj2iAQ+ezfeL/+cgWQlne2VODNRSlpfHX789jdjCuCpytKANaGvd18AXR4MkFGae5Cylqe+7smzc9KfjY2Njc3ZwxuzMrz5O/Dkl62/r/5PuOBDEG6Gzd+DsgVw/odAHPs+YcuJfupDboLu19gzbJrUPvINMg6J+dd1cfRPlXTurCQS1/Cu9VE+73I49hT0HYE/fwrat1F3w/9yuWSlxCU6nVzY9ge4uIJAfoJV3WNbcZ/sJXCyk7aLzyXRWINgGmw49hCtuwwWO3dAk1l89O2JNZNrfYKvPuyhqfsIcATljhSt56zHlGUc0Tiq140pD15akp5jaeeLADzbcBmdgTmkHSXMjzRTmhyeEFbmrOWguYW2ZCsgWjcc2Tj89mae9riJPnIHCy/9PMvLlo99nAzdqgpXr4b17+c5tZ/Pbfs3IlqKc/3z8MtunhrYxy6XkzlyHXjLYe2tHBBU9u77Hg5D56pEkjfj5fi8i2CIPzhSak0YXPri9zh2/m1Ea4ZXHd3Rds773UeJVCzi0KoP4vrNM1Qv6kStrSVWuZjlT30dgGRJHVtu/DZib5TgZ78LQOhGP70Ni2BfMwOHLeGZw8PODe/lkie+SurlJPKPf8bqK39IoLSPDrWJRHsO53yd8uwhUqIfU9dY1PEAzfPOJXcA/GsEyqt7MCSJtjnr8FftQ+hOI8xzoUYl0n2Q7htpRTn5nFUF1qoCSN0x0AwQBQ60rMZZkqQ03EHZ939E+Na/x/R7cL6yF8PlJHXNhfgefBr/Lx7B99xmPGs99L77ZpKlTcx/+Uc07HsI04TW50qpfuGbxNuGtybMnISuk9bxDl0t43/ueaJlq5GPteP/4YOIfQNIIQVJGbyJzUVl3M81k37LSgDkFith0VeXprG9nR3x4a0FbWxsbGxshvLGFMMHHhr8e/vPYeU74afXQiIvzNL9cPnnR/1oNK2yuy3CBfPKcCqjd2NwHdqB/4FfoMtecrfciOSAaPm6SQ+vUFU0T5mk5Yk1o55MEqjJ4pZy7K+dz6rjR0jtayG1rwXv596Gm6fgR5cXPyPu+DnvrwuhHpc4+awlcO57QeOFN8+nrbkV94leEjUV+Dp7qd6yi6ONNaw//ggrnnyc0ldCQBt+x20cfNdPCIR3Uvfi9wj9zGon5lqtkzsgsOQHf6Sh8gUOfPKdrL/zB2RK/HRsPAfN7SK4LM2FR3+HaBo8XXMF3vt6qAumab9iOf3ucsqT3Vx64B5ayldxonwVpQ6rotmVOYYk11LmVTAeu5OHfF4+X1EGib3w8E1sW/VpHA0XQPlgYt3jJx5nXsk8Fux5EDPRS8a9ETEq8tCz91FZDevrV7DOP5dqZ5Cn+/exx+kgV9bAH50C2eO/5lCqE7/k5jNiiOv6NrNv0eWgDBdrKW8ZbfXnUNW1l6aXf8SuG++y3jBNnMk+yk5uQzANSnoPM+frXyZy2MPAJqg5fy8Nc/9Y3I432k7ZzscQvv48Qv7pRDV7qWnbS0tlGakeS6DKPXH8P3ienvlzSHUmwRBIHdIInCMQecxAEEyqGnoQMDnqOYecq5x1fb9jvn8LqXcF8AgxBuQq9nnOQXeVEHnHBTj3d6A2lGKU+RCjKfx7jiDu64WMSf3FYU4OzEXvBa02iOF24HnpKK7nDqK09sPmXrJAJ0Ek9lL58KcwvB7EWJLcugVU1bbjPzdC15YgQks/6ZZ+1js+QbjpfMpbXyHe5qJ7TxA1OvJms+76OP273KRbrev++F8qgRZqn/wcWdOH1GVZSOreFCYqV5IV3bDRCy9E8P92C7mVDeg1QZQTYUyPQvmyXhLtbiof2QqXv3fSvz8bGxsbmzcWgnkWtEmaLuvXrze3bt069Q9+fR6UL+SYVsG8jocwvJWIyR648BPQ/BT0N8Mn94M7NOxjh7vjfOuJw+x/aQefSezAc9315JavHlZFDra/SOhz/4KWkdBVidIFcarPidFT92b2nfs19FGie7WeVn6x+056qjxcUHENVx38FXW7ovSblzHwic8iGCo1LX+k9PBjDNx9lKp1UXYsWMZ3su/h+66dyIpC772P4jt3EdXVz6N4dczQfDJxHy51F4IA4ZZaejaDWa4i9FkVbVMCV53Gzg1vY85TL6Ok0jj+vpSFvVs5/EgtHU6T2n5wrEqw4wN3cuOrX+L4ISfqNj+bz/URWryK1fEtBE6E6d0VoGJljN49wyOe517dw0B1JR1iDd39Fcz9w6CtIvmuOtYLW4qvT5Qu4/51/8i9zV/FIP+YWw5Aup92xRJIXsMgKYq8PxLjjmgG4YLvgL+a3Yee4Rvt93GoXmDJgMaXvz/8GA9Uusj9583FCvcXjt5HRB9sOfem3QbnHTZJXbKYpeetp3LPK3SvXDdiQmJxv/Y/QejFHXTH55EMNRG62sOcXQ+QDiskzCDHLrmKkq88hZl3EgiSSemiBNlQCbENS1nWvonmtqWoL0QAkBwGi95h3YzlNAfb5DcjRzV8f94z4rsNr4Jx/Rzk3xyl8vI0ZZUD9DgaOeq/CGQHvmwXjlyEhamtSOicdC7mZPCCUfejgJDIENh7CHGxk4HAAssPbZpIXVEC920Zsb5jgUzdgg76D/lIyFWIVR6a6vYiCyq6Dt1bgiR7HGgpGW9DFtE0kOY7iTxr/Vb0piCipFHlb6dzwRKSQh1mhRdTzeJ+qRUxnkFu7Ud0mJg5AVExMFQRR0Cl9Ho45L8YI39uHPva8W7aT3rDfGJ3XEbp53+HgMmyjYfY/XQDhE3KfvMAjSsmH5AiCMI20zTXT/oDNjY2NjavW954leFcElJhTMd5/N/jV3GncJjzkocwq1ci1K61ugo8/jl47ptw1X9Yn8nGie3fxO1/cvDe5+/lA31H8GWS8OpTGGWlSJKGEcthhEpQ+jrJqTINl/ST6HQycMRLSVOaSp7AEBSSwUV4o4fIuSop73ial9/yRyq+9gk+f2KA51YpNHV+B2ccMhnw8ATOpT7m6Q/hSbQS6/IyQAltnvP4h9xt/I2nE++8Rgo3NIkthznua6DhkzfQ8dNnyZ3sof6qKhQhTPKEiuQPEHlrmF2vlrNxv8kjGy/kUzUP4Jce4ZXzL2P+w89Qu3MPzV21kDT53ZUyb3vZIN3v49+6v8+rqTLev80Sk9qiJlBkjgZXcMmSxwnvN4i2WFXU8lUxXCUqbc+XcfwvlRiSgEfvpMHVRybooW9dE3XPHEDZ1I9xeXFOGE39+1nWtZVLKt/O8R2v8olHWjhZMcDPr5BAgStDK/hIf5hPa538NBhg1WMu6n71RQBKgH8H7r1FZcULDshPwupaV01zupuLDmQIH+5CW1wDQEjxEtFTrPU18YFXnFQ9kvcPHzlIZnsKdrQyf9lBfMtNjm+4hliw0Yo5lkUQBAaO+Ei9WApEcLITpSVFi6OG1BHAFPA/8wwGIunrFpGrKsX/h52EDwiAgbn/GOFLqzG29eMM6TReFqaPGgbkKkJaN3F3OWaoFLVKJFoVwL35GOg6jqM9qPUhlLYBhN82YyoSgXIrFrxLmQuyA0VPszz6JBnRx97Sq1k6sIl+adAPPBamz0X0gtXDFwoCek2Q6Hs34H7hMHI4gbcuR/qgSaq0gp3zL2BJ+TPUatbEyKhSyXHXKlLOKiqvPIIRScED/SRP5m0Y+SYcmbVzSF+8EASBiGGAABQ6mygOUlcuB9NEjKQQkhkCv9uOaQhUr48QaEzzSugmGDLpM7e8Dsfhbpy72xCiKeSOCNnldZz0rWb5ubt4cvdqtK5+Gu15dDY2NjY2o/DGqwz3HET/nwvY8fgCMqrEF668nb91PYcx91I+clENgiCgPfg5Uh0Z/P+9G0GWSd59LfLBlzn2qPUIXyurJHPuBqRkBPcLzyA7DTzVOTJxN05/hmTNMhbNeRFDhaOP1iCJGq6QSklTGn99ZthwUr5Gmn+RQ86KmIKJXm6QCWn0RJ3M64ZAY5rqcyMcP7ic3IEIgmHwm+tv4+fSUr5RfpirqqwKanLPEZLbDpJr7wFA9LoxUumCJgTAtaiRfW+fx3/knqdq1420B5dzl/wdNkp7MXQ4/GA1pjZY5f7kR71cvC3FjZtNHtkA1222lh+rk0hdcT5yvpuCYmao//MenN1pAE5etYRcpQdv1wDB7d3IiRxy1rJ+DCyqpvvChfha+qh/+gDpN5WSPLcMVXaxpmsL3u4Y8S437a2lOMLWJDNdgtj1a8ie04RQX0ZOV/nVlj/x6R9YVdVkhc6rdRKX7Rzc153zBA6+YxGmIrEpdYgffVsns2EBsQ9eCsCW/gO8Gmvm6vL1XPhRa7JXbm4FjuPDQzkUr0bdW+I0b25A6kqQW1hFbkU9vge3YYoCpZdoxF4S0HMjH/sHVmmc3Hg5huIE08Tz+D7k9gGk+OA1ULokQd+FK4n65iFiUJpsJi6FyLpHEbA5HUwD30O7UNoHUBtKcV4Voj65g10lV+GQBZYNPIFHt/rtHvWcQ8ZZTkwuH+Z7noiSbAc+LUy3exE+tQ9NdOJVw8yLvoypC0SOe8gsLKej4lycehxXboBgroMW9ypybiv1sDp1gJJcNz2/0kA1KV8TJ6JWEalrQmsox5xE/2jB1JEMFfFQGMMrU1baS9p0EAuMrPDKrWF8f9iO6VIQ0yrJSxeTW9XAsr4/cUIrh7f/mjXr7MqwjY2Njc1I3niV4d4DRE+48caTeIH/2foLNlctY++RY/w6keVvzw1x7LcqRtpEXL+W4PVvJvnEYbIRSwgLC8pRr76BuuwLBLKHcVd0kRNLcMsRYIA+aSX93vUc1uYg6CrqpSbGn19ETcrE29zUvNdDpqwJT18zPrMNd7QVMVfDQxvgU3M66aKKHrGW/6mN8oEns6ze4SbW6gb6Mb0ejtTN549SPevEk1zqOQFYvXm9KxfiWbGA2HPbybX34Fu/lOSOw2SOnsS7tglHTQVKQwNJOUxSEjheUce5SphPJT/Is9InESWTugsHCPeWoCpO3MEcH482EgtqwBGu2wyO2gzxNRnqlRBR+gljCTZVcNG3tIm67gNoTplMoARddpKqU4jW1YFusvDXmxE1g3hDGQgCiTnlpEu9ODZHObTuPExRZndXlrrnDqClJJxSluC6NLm0i3i7m9AfdsIfdpJZ00j0o1fy/n0lZOUIH/6IRNItYQoC83AwZ3eKzMY4PzgvSFhpBsDllsk1BHBuPYF77j4cBzp4R+txbnJmiShWqIhe6iX1psWI0RTiXA/LF+7i4L5lqHsidD/vQR6IY9Z7cBzpxnGkG8PvInnVCqK1AaTGCMRNxFgW3+4jOPQU2X6F6gW9VA48SKtvHd2eRaSuWmF5dB/YCi4JZYFIpKGCqLsRBBEDkT7f4rGvXYcESCSvWYlr6wlyS2pIeAOE3Y349AgNsR049SSHAxdRlz7EgtQ2SMEJz2pSjnI0wUnCUYFoqjj0NBk5gFcNA5BU8ml6psmC2Is4jRSNie0Ma5wngiCaSCtKqM21UNvXAsChwMUc+f/bu/M4ycry0OO/52y1V3dXb7PvM8zADAzLMAiKgILghhivippoJEFzzVXvjYlLvAlmuR+jSVBzzXYVg0bleoMoggphcUAEHGSGYZiFWXuW3rfqqq7tLO/9o6p7emCGdRoG+vl+PvXpqreqznOe09Wffuo973nf3BuO7GY4zqLCI1hEpC91KPbEyK0Yp10KbM3OZyzx3OaOXj3yczL+IIXOHAfTZzHgnUIkx75oNVjQSumSVSQ37CTMpZDZcRxTpeLmODU8iLTrXMNKKaWObcb1DBf/+TIOf7uLoaiNzNxW7J37IAwnL2ICCBwHiUXY40eWtB1NZVm6eoS2xfUr1a3GmNagarHXfRtJ+nB272O040x8uwUZGiVas6I+nnhwGGv7Xuxte4jOXIHs6YbxEvZ7zifXdR+DD1jc9gbDJxL9dGWXsDV2Nj/ObqFbxvjXu2OURtKMZFv5/RW/w8edm/moc+QCwFp2HUFyMcZtwaoNYOwUD8WExbWA1qAJ+h4jy6+oeivJV9bzkyVFviIbuW7sHB4trea7Iyv5i9StZB2fC2obaDf1/EIsqsT4tXc+5+z/JeIY/PYEMatGwtR7gG+NX0UoRwobZ6yMhBFNmQJLwt3MjQ5RJsFeZxldo/NxC2WKi9rrx8QYzh76FeWf+0T+kV5VP+0RrYiRWzTEDnsx6Tn1xTdkeJz4loPEHzuIsS0kjOhaHtJ3cYmvtzRRtiwe3XcAO4Syk2FL0xv5q+xODthFOqIEf9F9Ki3f24iEEcazcAiO6s0tvHkNnXMGiAdjNNe6saMam913kvrOLwHInhbQsWqInY+fShjaVNfMI1hw9HLMucoBVubvJQqE3eZMMrmI5vHdJKIifbEl7M+uJ7Q87LDC2UM/pGw38WTT66jaGZyDw0hnHNeqUrXThNaUuZ+NobO8i1QwRFOth/74UgYTS1mevw+DRclpZna5PlShK3k6hxf+FvP67mb+0H34RZvqmINlG7xMSCneTJI80bihFkuRiY0RIWxteROBlWDe+BY6KnvoiS/HlQgJyrT69WWOt+beTJDqRCyXNV3fwAChFceJyuzNrKc/WS/kF489RGf5SQ5lzyFZ6eVQ7rVkaz0sGf4FB+KnUvFaKXgdVO1jL9jSUd7FkrGHsIgo2s2kw/oZgO74KezPrp98XfrHm7AHixjbImxNkTujQr59AZ2VXbT7XfgS43BiBYtKj+O/6zbc1a87Zrxj0Z5hpZSaOWZWMRxUqf3POey+pYP/XJfj4dc241HjfYPL6e/pYke1yuKBbjasaOE++1P8t5Fb+d2xO7hn3jqSzkoWthqWFv8fXjRCWLLImwX03147qpCeymlzsLMu6RURlcQcxm/Zd8zXFRLgmYhYxWLZlb10p+ZzdzrP9a1Z7u06REtkERrwpD7UoEQWu3k1TvUgUfkgN2UznFKrcW6lyp3JBH/U2U5nEHBTdy+tQYQJhb5NWUb3pNh54Wz+Y1Yfn9ngsX/JMvpGoSNTxV2V5fLqTxiQNnZ6axmPt3Np/iasxjiL7fYqNrW8GUtg5fAvWRs+zEGZxyPx+uIKtvGJmSq5aIiz/YfwcRiVFpJUyJgxNtrrOOQtbbw2YF3tV8yOusl3Jeh9opnxeIb2s4pIs0WGMZqozye8O72e4cQiTh++HSsKGN9tMXI4S5BKsXBZF1azRY/bwe70Yi4ceQinMS/yocSpfCVb5o5kyJIgwx/XzsY7OEzqsT0sXnsAjCEMHaI+n/E+j+yagJipENaEni05yvk4USoNYYRUa1Q+cAlnjN1I3mlnZ+5SMBGxqERrZT+t1QPYURXbBAQ4bFl4DSbeBGJDFHLa/htoqhzgYHwVB5vOpWX8AKuK91LsjlEe8hjelyEqQaK9ypxzRym1tLEt96bJi/06Sk+yrPDgs368B9157JnzDsJYG9l//gH20CiN72xHEwOmvm0rA/PWDzG6L0lQsJj3+iEGzDwO2q/DX7USRGgp7MApHGZg1oWTY3W96jD440TxHKfu/xYxf5gtubcyq7yLOaUn6PMWs3fxb4NlI4USJuZy7r4v40T1ISIRwsH0meS9WRTd+tAKwgjnwBArogewRqpEoXBo6BTsrkHazi7h+BUG9rRQjWWwlyeR+3sJ5jRDEOH0jyF2hJsKya0Yxz+1ndbaIYpWlnKYovXtf4t79hXPegwnD5EWw0opNWPMqGI4PLyJwueuoOfhFn52lnDbeotkFf745pCOPPz9OyweWlXvLZQwRurwe+koe3zE6WJe3MU7uIdc9hAc6mLoN02T27XXNdE7EuAbaPGh1SkRT5co7HEJKjYmrBceqVkVSgMxFlw8SGXMZWBnG0EhwDrSAY13msXSNYfYGI/x4dmdfGxsDZcPPkrZuCyzDnA4NoevLDqDzlqKq382zsNN+9joFbnjbOHPw5X8oPoE25M2yZrh/fcZzt9hkSoeqyI6mrsoImmV2RMsIWpq4tDF53FW4S5WlR8hT5bbW6/B2DEyB7pZ9qO7YJZHW8sQ3YVOqqkUTQcGaF1SIDOvTCGZ5f72q0juGSF7oIdTznySVmsIH4duez7z/C4sidhnLyayY8yt7WU381gje/GNjS0Rn/Z/n2tjd7E82osvMVxTxRcP19SO/D6xeWTRfyVMtIMIElaxghJndH2DeDDGd7Npvtia47xKig+HZ2MQ1g38ADER23OX0jw+hH3/DvL7kpPF4YQok8Qq1GebMEBt9TJa1hsWjt9Pyc6SDMcoD7mUBjxsLyL0LcqDHoV8hvyH3kXUdmQmEiuqceau6wmN8ETtQtI3b8KOhYSVxmpyWZ+gbBMFgljQsTZPkRyFrhgdp42SSeQpJzJsX3kN4nq0jG0jW9jNUHwxuaCXWmjobb8QE2/G6eoh/Z3bEb/+xSnMZal94CIS3/oZFHxqKxdhEh7GcYmakiTvOnqmCPusDNXDLk7fMJV1p1F+24VP/7BUauA6YNf/VrLj+1jddUPjWAkjYRu729+G5AV3x368x3djLIvU+WnY1ku5tz7UIT2nQttpBfpG5lDbVkOsiKB49HSFxrKQKOJYLDci+eFOotYMpqdMbMNuxvtj+EWH4rsvJNeZZ+nAz9gVnMKiD/wT7sqzn/FvYCothpVSauaYUcXw4E++QPeXvkOp6NJUPtIeUV+Kb2RWgs6La3w5WaMn9Ohvgnmhx+dujIgX6nNkVWKGiiM0j0MtCeO5iJuv8rkzfWQFrJYwxDXCXza9G2OvpelLX8QeqZ/qtZpspOITVi3cVMDhhRGPxmN0dq5mybZh3PESMsfBHw35/BVFDsUXkN13Ptf95kc8utZw0YYCueLTc7tzncO+togP3xkxPD9LtizE+/I8usLmyVmGmgvvmz3Ktl0JDtou7+zIEmyssaF9JedvewzbN0ddbDe8YhGHX382C2pPkLezDMWXM+ehzTQ/vpuYX8VPxHDL9WMilsFER4pJI8LwKYtp3bG38Ri85pCWhUViTQHdDzcTVmxKLRl2Zeewbs12lqZ72RQt47drn+GDLdv4+sg5fKrzMT7U+4+UuoTBkVlU5i/DX7WIVK5EZ9999CVXMNZx3pHpKADJF0mU+lg2dAsxK8+DiTgraz65qF64Wb7Pk8V1FL1lJDb8BimWEE+gHIINhFBZv5r8dR/F6hvC27qH+N0P423aCZaQXOMRbx6nvN1Q6T/2+NXy686kcml9KjP7YB/x+35DrKebjqWDjOxJEtUsvFmGvL2Q0tsuILY8ybwnb2Ff+4Uk/mUjzsHeY243aG+het4awlmtuDv2E3a2EiyeiwQBUXMGqj7Nf/MtJIwI5rQx8jefgNAQzW2Hag2p+ZhkYrKIBUj/w02kbt1AaiWEfTUqI0cvzR02pwk72yi9/ULcnV3EfrMdu3uAKJui+prTkfEyJpOiZf9GYsURCmNZotFgcqzxRDFrPBepPWU1w8bxnmAlIdYa4jQZDr/mLVijEZU3nkvUlCFxx69AhMyKGq07f4G7tYdkW41YU4BBJpdwfmjp/6Dpr28CIEolmP/GIWrxGE1Xf1+LYaWUUsc0c4rhQh99157L8KYkhQTEA0M5Bg+cYnHreourHvO57AGL1KIS44cT4AuBY3CC+r/1H54vlD3h/b+o91J9/a02GyamahIhk1/CZX4nvald9IvPrnj9iv4lzjtorr6V4WKN1+/YwIWbfs7hVocDy5OcNvcwt2UMD8RjrNJyu18AABX1SURBVEt/igvuuJez7ttw1G4/vlBwQsOqQ0faDNDbbnPjxcLp3hKu+O6TyJRfoxHBJGJU168m/4mrORgO8uVHvkxHvJX+yhArm5fxkdM/gmPHuP1Rn1s3VojbAVeavfy6L8n7hh9k3db6cQ0smx2LVrKyawdOWK9c/vLcD3Jw1XI+5/+Qy4PbQKDX72B79XRGU4uY9ehWWnYfIPRc9rzl9TTt7yZ9qJfUwPBRuY3FUmSr4/R0zmbWlW08ai3j870XYBPh+TW+eugHzH+sPi/x1GIq6Mjhr15K5bVngjFIuUL8/k3YQ3nc3Qcntx9lk1jiw9IcSXeUtsRhhnelKB5ONJ5PMf7OSyj9l0uxD/QQdeag6oPrYJqOnl/Y+9VjNP+vbyLV+j5E6QTVc1dTuvIi4g9sJpjXiX/qYnIf/zJRU5qwsxW7ZxCnb4go7mHSCezB+mcifnmGg9d8kqh5ztM+plbvEJmv30SLv4f0giLd2+djIhuTTODu6MKqVJ/2HgDjOogfYIDy5edTfuvrCE5ZdMzXPk3NxzFVMvseprw/huRLVC4+h/T3fkb8no1Y5SrGc5BagHFsgnkdOIcHJnufAYxtI+GRytbEXKLmDKN/di1hWzNSqZH9yveorF9NOH8WeA7h3A7S3/wRya6djP7+5VROfQ24LkTVpy128vSEDVIbx6qVsMIaq+7/GsPZWRy64GNYvaMkf/wLkrduILFY6FiXx3vPLbir1j2344EWw0opNZPMmGK4OJJnx0UX0t9UY3E/fPm3LLYvNVyTrxJ3knwpY/iD2yMuetxQiAs/XSfMGjFEFmxZLpQXudht59G+X1jSa9i8+nU8kR/iYE8n7bN2YFWW0zs0ZehEahfJBd/ERC7BwFuJNW8mlAK4Q4gYjLEQqRfWQXEF5YMfZm6hn2/c/SX2NM3h+nVX8/H9tzH/wE4MUJ3fjpXJEq1cTOFdl+AEhrGU4Fkew3u2w6at1Ab76X7NMqxcC2c0rSTV3F6fGs4fZ8PBDdx14C78yOeqZVdxyYIjq9QFYUTFDxkqWPzlzWWCAC7q38LSwYO8a9cvANjUvpxblr6OTR0rENfGbwz9uNjaRJfpJLOwg4vXhPX5YqOI2Q9tJnQc+s9ZXb9gLoqYe98jJIZGOfyatWwbSvDjfTmuLTzAVXffgrGEYFYbjyXm8qTTxqrhLs4c2EVt5SLG330p/ukrkMI4uT/5KvbAyOS+G4DGBXVRNgUGwvZmnAO9BHM7ED/A6T4yXZoRCBbOpnz5BVQuWYdpSj/j0ttHCSO8hx/He3QHpasuIprVflQvK0D2i98icfev60Xj3A6CpfMYf98VRLkmcp/4EsH8WeT/9BrwnsNS3kENnCk9tUFA6ns/x9l7GH/5AqRURqo1xA9J3P0wUvWpnLeG/J/+HsS942/3+QgCErfdT/rG2zCOzciXP0k4uw1n72FiDz2OVGuELU1ULlsPGCQyWD2DBMvm14vzTOpZQxBFz/138EzMkWXDAbJ/+20Sdz3IgksG8a69GXfNMYZ8HIcWw0opNXPMmGL4QP9B/vm6d3LOziKzRmHjX72ND63/KEk3iZtq5+4D9/LL7ge5f/NPGY3XOKPtMrqGArrzZUhux471H7U9EzmYMElK5nFKZxPLcnPZNXSYaugjEmETpxaN8+TYYwAIQsbLQpjGpQm7uoR8tYCV2okrSSJrnIw1l45yiR7TRzkJri3k3CYybgbLsmlPd1INqxgM7Yl2dgzvYG9+L+P++DFzdsRhdno2feN91KIjY21bYi2cP+d8dgzv4JIFlzA/M5+usS6KfpFqTegpDhBKgf5yH3Kon3ndFZ44pYWqaYWgjbeftpK+Qp6hAkjUzO7eiMG8xzvPbkFMBj+AIKwXqlUfCmXBcyDmGsJISHiG2x9xSMUiPv5mizU9XcTu2Ujs0R1Yw3kkqn8mh89dQ/CnH8Yk4xhjKPpFUlXB7R/F3bmfxM8eIMqmkHKN0jtej3/OaRjPBceGIIAggpiLvb8bCSOcPQcJW5vxVy87ccXiU0i5QvL7d1A7ZSH+uavrY2snRBHUgumJHUVYvUOYpjQmVe9VrYU1XMtFRJ7lzc9BECKVan3bz7C9yERYjQU0/NDHsZznFN8YQyWsUA7q45fSbho/8ukZ72H3yG5c2yWIAuak57Aou4iUm5qMM/F+gzmqzRocpf33/ox08xizvvDXuK99/3NOV4thpZSaOWZMMVwLAj7/ydfzu3cN03sWnH/Dr4nFn77Urh/6jFRHyMVzOJZDxQ/4zoNdfHPjfZTs7bTFZtPeUiawuxF3hK7iLiph/R+4a7n4kU/Gy+CHPn7kE7Nj2JZNsVbEYIjZMYIoIDRHTiknnATtiXaGKkN4lkdboo2MlyEyEb3jvYxUR3Atl6JfxLVcIhMRmpCMm2FR0yLWz17PmR1nsrx5OUW/yPah7WwZ3EJXvoveUi9tiTbmpOdwz4F7mJOew66RXRie+feecBL4oU97sp0VLSsYrgwzXBmmd7z3qH2fykQ2UXUWxrgQuRjjgHEg8jCNUaRChHjDWM4oTYkYp7TNJzIRjuVQC2sUyqMsfXiAAx0Z7OU5QiuiFtYYKA1Q8AtYWHi2RyWsYIvNvPQ8PNtjqDJEa7wVz/awxcYSi7gTx7EcgiggiAIqQYVxf5zhyjC2ZeNZHqEJsS2buB0n7sSxxCLlpCbbK0EFSywEIWbH6u1iT/5+km4S13KxxaboFynUCjiWg2u5xOwYzbFm7MaY5kKtQCWskK/mqYU1xmpjDJWHMBjidhwRIe2mKQdlkm6ShJOgWCvi2i6e5WFb9bwm8pu4uZZLyS/hRz6FWoFCrcBYbYyiX8QWm7SbJuNlyHgZgiigHJQni2THckg6SYp+kZJfIu7EOa31NDzbY7gyTH+pH9dySXtpKkGFSlAhG8tii01oQmphjSAKSLkpBsoD7B7ZzfzsfPLVPPlqHtuyaY41s6RpCWk3zWB5cHJbpaBEyS9RDsoU/eJkIfxcOJaDIw5xJ04trFEJK0QmojnWjDGGjJdhdno2f/DjMdL3bWPJDdcTO/dNz3n7WgwrpdTMMWOK4d1PPMz4ez5Ez1zDuZ/5JLmLP/q8441XA5KefVRPVy2ska/mGSgNMDs1G6Txj9pyqASVyWK4GlTxI5+Um2LcH2fr4FYGygPMTc9lVW4VKS9FGIXUohoJO4Fr10+jRyaiUCvgWi7loIxjOYRRSM94D+2JdtqSbUf1hj2VMWZyf/3Ix8IiX8uzb3Qfnu2xuX8zA+UBZqVmcXr76UQmIuNl6l8GxCEwAU2xpslt9Y73sm14G2knTcpLcaBwgFpQ41d7Rtg6vJExsw9bhJoZJzQBrjiE4oOpn8VGIC7NxKWFZKJCb6kbz/YIoxDHcki5KVJuirHaGH7k44qLYzk0x5pZkVvBuD/OaHWUJq8JP/LZObITYwxZL0u+mic0IRERkYmoBPUCybZsHHHwbI+Ek5jMpxbWJo9nOSxTC2uEJqTsl7EtmzAK6/tmQiyx8EMfSyyCKGA8GJ+8P1XKSRGYgDAKCczRz01IOkk82yPlpmiJtdQ/H2GVyESMVcdIuSnKQZlSUCLtpieLzshEGAyRiY66BVFAzInhWi5xO042liXtppmTnkMtrDFSGWGsNkahVsASi4STIDABxpjJLwmO5dAcb6Z3vJfRav1iT0cccokcQRhQCSt4todnexRqBQBssXEaK9v5kU/cjpOL59iX38fs9GxW5lZiMPQUe9g1uotaWCMXz03+XSScBAk3QdpNY4vNguwCmrwmbLEZqY7g2R5NsSYuW3AZMSeGYzk82P0gT448yWB5kEpYmSzgm7wmLLE4VDyEIw5DlSH2j+3nDQey/N7NRRb+7d+TeeMbjvn7OBYthpVSauY4qYphEbkc+Cr168y/YYz54jO9/vkUw6ZW4v6/u5KWRStY856vHTUDgTpxIhM1ru03lIMynu3hhz6mcc3/RM/mRLFfDauEUb2nWURwrXrxO1HkARgMnuUd83S7MYbABLiWO3mqfGrPdS2sIUi9F1ScybhPFUQBtbBG3IkTRMFk0TnxRcPCIuLIFF/VsIogFP1iPT9jQCAXz0328o7VxujKd00WxRNnABJuAs/ysKTeyz1VGIWTMSfeZ2HVC18ijKnvl4hMHueJMwVeY6GOuHP81daCKJg8vhNxJgr3mB0jjEK6x7sp+SVy8RwpN0XMjk0Oz0k4icne5am/Sz/06z3klo0f+ZO9xRP80CdfzZN0k4jIZI828Ixf5l6Mew7cw5/c+0ecmjuVG9/yHeR5jEvWYlgppWaOk6YYFhEbeBK4FDgEbASuNsZsO957XsgKdEqpmePxwcdp9pqZn53/vN6nxbBSSs0czrO/5CVzLrDbGLMXQERuAq4EjlsMK6XUM1nTtubl3gWllFInuek5P/nCzAUOTnl8qNGmlFJKKaXUtDiZiuHnRESuFZFHROSRgYGBZ3+DUkoppZRSx3EyFcOHgakD++Y12o5ijPlXY8w5xphz2tvbX7KdU0oppZRSrz4nUzG8EVguIotFxAPeC9z6Mu+TUkoppZR6FTtpLqAzxgQi8ofAHdSnVrvBGPPEy7xbSimllFLqVeykKYYBjDE/BX76cu+HUkoppZSaGU6mYRJKKaWUUkq9pLQYVkoppZRSM5YWw0oppZRSasbSYlgppZRSSs1YYox5uffhBRORAaDreb6tDRicht3ReK/OeC9HTI338sdbaIzRicyVUmoGeEUXwy+EiDxijDlH42m8kzWmxntlx1NKKfXKosMklFJKKaXUjKXFsFJKKaWUmrFmYjH8rxpP453kMTXeKzueUkqpV5AZN2ZYKaWUUkqpCTOxZ1gppZRSSilgBhXDInK5iOwUkd0i8plpirFfRB4Xkc0i8kijLSci/ykiuxo/W15kjBtEpF9Etk5pO2YMqftaI+ctInLWCYp3nYgcbuS5WUTePOW5zzbi7RSRN72AePNF5F4R2SYiT4jIJ6Yzx2eINy05ikhcRH4tIo814n2h0b5YRB5ubPf/iojXaI81Hu9uPL/oBMX7NxHZNyW/tY32F/2ZaWzHFpFNInLbdOb3DPGmNT+llFKvHjOiGBYRG/g6cAVwKnC1iJw6TeEuNsasnTKV02eAu40xy4G7G49fjH8DLn9K2/FiXAEsb9yuBf7pBMUDuL6R51pjzE8BGsf0vcBpjff8Y+PYPx8B8EfGmFOB84CPNbY7XTkeL9505VgFLjHGnAGsBS4XkfOAv2nEWwaMANc0Xn8NMNJov77xuufjePEA/nhKfpsbbSfiMwPwCWD7lMfTld/x4sH05qeUUupVYkYUw8C5wG5jzF5jTA24CbjyJYp9JXBj4/6NwDtezMaMMfcBw88xxpXAt03dQ0CziMw+AfGO50rgJmNM1RizD9hN/dg/n3g9xphHG/cL1AucuUxTjs8Q73heVI6N/Sw2HrqNmwEuAf6j0f7U/Cby/g/gDSIiJyDe8bzoz4yIzAPeAnyj8ViYpvyOFe9ZvOj8lFJKvbrMlGJ4LnBwyuNDPHPB80IZ4E4R+Y2IXNto6zTG9DTu9wKd0xD3eDGmM+8/bJxmvkGODP04ofEap8zPBB7mJcjxKfFgmnJsnNLfDPQD/wnsAUaNMcExtjkZr/F8Hmh9MfGMMRP5/XUjv+tFJHai8gO+AvwJEDUetzKN+R0j3oTpyk8ppdSryEwphl8qrzXGnEX9VOzHROTCqU+a+tQd0zp9x0sRg/qp5aXUT7v3AH93ogOISBq4GfikMWZs6nPTkeMx4k1bjsaY0BizFphHvVd55Yna9nOJJyKrgc824q4DcsCnT0QsEXkr0G+M+c2J2N6LiDct+SmllHr1mSnF8GFg/pTH8xptJ5Qx5nDjZz9wC/VCp2/iNGzjZ/+JjvsMMaYlb2NMX6PAioD/w5FhAicknoi41AvT7xpjfthonrYcjxVvunNsxBgF7gVeQ/10vXOMbU7GazzfBAy9yHiXN4aHGGNMFfgWJy6/C4C3i8h+6sORLgG+yvTl97R4IvLv05ifUkqpV5mZUgxvBJY3rmj3qF8AdeuJDCAiKRHJTNwHLgO2NuJ8sPGyDwI/PpFxG44X41bgdxpX0J8H5KcMNXjBnjLG8irqeU7Ee29jhoDF1C9S+vXz3LYA3wS2G2P+fspT05Lj8eJNV44i0i4izY37CeBS6uOU7wXedZz8JvJ+F3CPeR6Tgx8n3o4pXyyE+vjdqfm94ONpjPmsMWaeMWYR9b+ze4wx75+u/I4T7wPTlZ9SSqlXH+fZX/LKZ4wJROQPgTsAG7jBGPPECQ7TCdzSuPbHAb5njPm5iGwEfiAi1wBdwLtfTBAR+T5wEdAmIoeAPwe+eJwYPwXeTP0irxLwuyco3kVSn6rKAPuBjwAYY54QkR8A26jP0vAxY0z4PENeAPw28HhjnCvA56Yxx+PFu3qacpwN3NiYgcICfmCMuU1EtgE3ichfAZuoF+g0fn5HRHZTv5Dxvc8zv+PFu0dE2gEBNgMfbbz+RX9mjuPTTE9+x/Pdlzg/pZRSr1C6Ap1SSimllJqxZsowCaWUUkoppZ5Gi2GllFJKKTVjaTGslFJKKaVmLC2GlVJKKaXUjKXFsFJKKaWUmrG0GFYnHREJRWTzlNtnnuX1HxWR3zkBcfeLSNuL3Y5SSimlXjl0ajV10hGRojEm/TLE3Q+cY4wZfKljK6WUUurloT3D6hWj0XP7JRF5XER+LSLLGu3XicinGvc/LiLbRGSLiNzUaMuJyI8abQ+JyOmN9lYRuVNEnhCRb1BfoGEi1gcaMTaLyL+IiN24/ZuIbG3sw39/GQ6DUkoppU4gLYbVySjxlGES75nyXN4Yswb438BXjvHezwBnGmNO58iqY18ANjXaPgd8u9H+58AvjTGnAbcACwBEZBXwHuACY8xaIATeD6wF5hpjVjf24VsnMGellFJKvQxmxHLM6hWn3ChCj+X7U35ef4znt1BfivdHwI8aba8FfgvAGHNPo0c4C1wIvLPRfruIjDRe/wbgbGBjY3ntBNAP/ARYIiL/ANwO3PnCU1RKKaXUyUB7htUrjTnO/QlvAb4OnEW9mH0hX/gEuNEYs7ZxO8UYc50xZgQ4A/gF9V7nb7yAbSullFLqJKLFsHqlec+Unw9OfUJELGC+MeZe4NNAE5AG7qc+zAERuQgYNMaMAfcB72u0XwG0NDZ1N/AuEeloPJcTkYWNmSYsY8zNwOepF9xKKaWUegXTYRLqZJQQkc1THv/cGDMxvVqLiGwBqsDVT3mfDfy7iDRR7939mjFmVESuA25ovK8EfLDx+i8A3xeRJ4BfAQcAjDHbROTzwJ2NAtsHPgaUgW812gA+e+JSVkoppdTLQadWU68YOvWZUkoppU40HSahlFJKKaVmLO0ZVkoppZRSM5b2DCullFJKqRlLi2GllFJKKTVjaTGslFJKKaVmLC2GlVJKKaXUjKXFsFJKKaWUmrG0GFZKKaWUUjPW/wfPnOup2j26vAAAAABJRU5ErkJggg==\n" }, "metadata": { "needs_background": "light" @@ -535,15 +173,57 @@ } ], "source": [ - "interp.plot_q_density()" + "import os\n", + "model_dirs = ['data/cartpole_dqn', 'data/cartpole_dqn fixed targeting']\n", + "group_interp = GroupAgentInterpretation()\n", + "for model_dir in model_dirs:\n", + " for file in os.listdir(model_dir):\n", + " file = file.replace('.pickle', '')\n", + " group_interp.add_interpretation(GroupAgentInterpretation.from_pickle(model_dir, file))\n", + "group_interp.plot_reward_bounds(per_episode=True, smooth_groups=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [ + { + "data": { + "text/plain": " name average max \\\n0 (DQN, ExperienceReplay_FEED_TYPE_STATE, reward) 27.895787 48.7 \n1 (DQN, ExperienceReplay_FEED_TYPE_STATE, reward) 27.521729 46.8 \n2 (DQN, ExperienceReplay_FEED_TYPE_STATE, reward) 29.128825 44.0 \n3 (DQN, ExperienceReplay_FEED_TYPE_STATE, reward) 26.520843 52.3 \n4 (DQN, ExperienceReplay_FEED_TYPE_STATE, reward) 27.778936 49.2 \n5 (DQN, PriorityExperienceReplay_FEED_TYPE_STATE... 25.197561 36.8 \n6 (DQN, PriorityExperienceReplay_FEED_TYPE_STATE... 22.827716 38.0 \n7 (DQN, PriorityExperienceReplay_FEED_TYPE_STATE... 24.578271 51.9 \n8 (DQN, PriorityExperienceReplay_FEED_TYPE_STATE... 22.751663 36.8 \n9 (DQN, PriorityExperienceReplay_FEED_TYPE_STATE... 26.039690 46.8 \n10 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 148.154989 499.0 \n11 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 141.317738 285.8 \n12 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 229.873836 496.0 \n13 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 149.444346 483.9 \n14 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 137.559645 499.0 \n15 (DQN Fixed Targeting, PriorityExperienceReplay... 29.125333 81.6 \n16 (DQN Fixed Targeting, PriorityExperienceReplay... 52.764745 166.8 \n17 (DQN Fixed Targeting, PriorityExperienceReplay... 16.286918 47.8 \n18 (DQN Fixed Targeting, PriorityExperienceReplay... 16.516186 119.8 \n19 (DQN Fixed Targeting, PriorityExperienceReplay... 16.339468 218.5 \n\n min type \n0 8.0 reward \n1 10.9 reward \n2 16.9 reward \n3 10.7 reward \n4 13.2 reward \n5 12.0 reward \n6 9.1 reward \n7 13.7 reward \n8 8.8 reward \n9 9.3 reward \n10 10.6 reward \n11 14.1 reward \n12 9.8 reward \n13 13.5 reward \n14 10.4 reward \n15 7.2 reward \n16 9.6 reward \n17 5.9 reward \n18 8.3 reward \n19 8.4 reward ", + "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 \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
nameaveragemaxmintype
0(DQN, ExperienceReplay_FEED_TYPE_STATE, reward)27.89578748.78.0reward
1(DQN, ExperienceReplay_FEED_TYPE_STATE, reward)27.52172946.810.9reward
2(DQN, ExperienceReplay_FEED_TYPE_STATE, reward)29.12882544.016.9reward
3(DQN, ExperienceReplay_FEED_TYPE_STATE, reward)26.52084352.310.7reward
4(DQN, ExperienceReplay_FEED_TYPE_STATE, reward)27.77893649.213.2reward
5(DQN, PriorityExperienceReplay_FEED_TYPE_STATE...25.19756136.812.0reward
6(DQN, PriorityExperienceReplay_FEED_TYPE_STATE...22.82771638.09.1reward
7(DQN, PriorityExperienceReplay_FEED_TYPE_STATE...24.57827151.913.7reward
8(DQN, PriorityExperienceReplay_FEED_TYPE_STATE...22.75166336.88.8reward
9(DQN, PriorityExperienceReplay_FEED_TYPE_STATE...26.03969046.89.3reward
10(DQN Fixed Targeting, ExperienceReplay_FEED_TY...148.154989499.010.6reward
11(DQN Fixed Targeting, ExperienceReplay_FEED_TY...141.317738285.814.1reward
12(DQN Fixed Targeting, ExperienceReplay_FEED_TY...229.873836496.09.8reward
13(DQN Fixed Targeting, ExperienceReplay_FEED_TY...149.444346483.913.5reward
14(DQN Fixed Targeting, ExperienceReplay_FEED_TY...137.559645499.010.4reward
15(DQN Fixed Targeting, PriorityExperienceReplay...29.12533381.67.2reward
16(DQN Fixed Targeting, PriorityExperienceReplay...52.764745166.89.6reward
17(DQN Fixed Targeting, PriorityExperienceReplay...16.28691847.85.9reward
18(DQN Fixed Targeting, PriorityExperienceReplay...16.516186119.88.3reward
19(DQN Fixed Targeting, PriorityExperienceReplay...16.339468218.58.4reward
\n
" + }, + "metadata": {}, + "output_type": "execute_result", + "execution_count": 7 + } + ], + "source": [ + "group_interp.analysis" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "pycharm": { + "is_executing": true + } + }, "outputs": [], - "source": [] + "source": [ + "model_dirs = ['data/lunarlander_dqn', 'data/lunarlander_dqn fixed targeting']\n", + "group_interp = GroupAgentInterpretation()\n", + "for model_dir in model_dirs:\n", + " for file in os.listdir(model_dir):\n", + " file = file.replace('.pickle', '')\n", + " group_interp.add_interpretation(GroupAgentInterpretation.from_pickle(model_dir, file))\n", + "group_interp.plot_reward_bounds(per_episode=True, smooth_groups=10)" + ] } ], "metadata": { @@ -562,9 +242,18 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.9" + "version": "3.7.5" + }, + "pycharm": { + "stem_cell": { + "cell_type": "raw", + "metadata": { + "collapsed": false + }, + "source": [] + } } }, "nbformat": 4, "nbformat_minor": 1 -} +} \ No newline at end of file diff --git a/docs_src/rl.agents.duelingdqn.ipynb b/docs_src/rl.agents.duelingdqn.ipynb new file mode 100644 index 0000000..52d442e --- /dev/null +++ b/docs_src/rl.agents.duelingdqn.ipynb @@ -0,0 +1,571 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "is_executing": true + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Can't import one of these: No module named 'pybulletgym.envs.mujoco.envs'\n", + "pygame 1.9.6\n", + "Hello from the pygame community. https://www.pygame.org/contribute.html\n" + ] + } + ], + "source": [ + "from fast_rl.core.basic_train import AgentLearner\n", + "from fast_rl.agents.dqn import *\n", + "from fast_rl.agents.dqn_models import *\n", + "from fast_rl.core.train import AgentInterpretation, GroupAgentInterpretation\n", + "from fast_rl.core.data_block import MDPDataBunch\n", + "from fast_rl.core.agent_core import ExperienceReplay, GreedyEpsilon\n", + "from fastai.basic_data import DatasetType\n", + "from fast_rl.core.metrics import *\n", + "from fastai.gen_doc.nbdoc import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "

__init__[test]

\n", + "\n", + "> __init__(**\\*\\*`kwargs`**)\n", + "\n", + "
×

No tests found for __init__. To contribute a test please refer to this guide and this discussion.

\n", + "\n", + "Basic DQN Module. Args:\n", + " ni: Number of inputs. Expecting a flat state `[1 x ni]`\n", + " ao: Number of actions to output.\n", + " layers: Number of layers where is determined per element.\n", + " n_conv_blocks: If `n_conv_blocks` is not 0, then convolutional blocks will be added\n", + " to the head on top of existing linear layers.\n", + " nc: Number of channels that will be expected by the convolutional blocks. " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_doc(DuelingDQNModule.__init__)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "

forward[test]

\n", + "\n", + "> forward(**`xi`**)\n", + "\n", + "
×

No tests found for forward. To contribute a test please refer to this guide and this discussion.

\n", + "\n", + "Splits the base neural net output into 2 streams to evaluate the advantage and v of the s space and corresponding actions.\n", + "\n", + ".. math::\n", + " Q(s,a;\\; \\Theta, \\\\alpha, \\\\beta) = V(s;\\; \\Theta, \\\\beta) + A(s, a;\\; \\Theta, \\\\alpha) - \\\\frac{1}{|A|}\n", + " \\\\Big\\\\sum_{a'} A(s, a';\\; \\Theta, \\\\alpha) " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_doc(DuelingBlock.forward)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "model_dirs = ['data/cartpole_dqn fixed targeting', 'data/cartpole_dueling dqn']\n", + "group_interp = GroupAgentInterpretation()\n", + "for model_dir in model_dirs:\n", + " for file in os.listdir(model_dir):\n", + " file = file.replace('.pickle', '')\n", + " group_interp.add_interpretation(GroupAgentInterpretation.from_pickle(model_dir, file))\n", + "group_interp.plot_reward_bounds(per_episode=True, smooth_groups=10, show_average=True, hide_edges=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model_dirs = ['data/cartpole_dueling dqn', 'data/cartpole_ddqn']\n", + "group_interp_2 = GroupAgentInterpretation()\n", + "for model_dir in model_dirs:\n", + " for file in os.listdir(model_dir):\n", + " file = file.replace('.pickle', '')\n", + " group_interp_2.add_interpretation(GroupAgentInterpretation.from_pickle(model_dir, file))\n", + "group_interp_2.plot_reward_bounds(per_episode=True, smooth_groups=10, show_average=True, hide_edges=True)\n", + "group_interp.add_interpretation(group_interp_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nameaveragemaxmintype
0(Dueling DQN, PriorityExperienceReplay_FEED_TY...37.997111137.111.7reward
1(Dueling DQN, PriorityExperienceReplay_FEED_TY...32.31197382.89.1reward
2(Dueling DQN, PriorityExperienceReplay_FEED_TY...27.884035131.65.9reward
3(Dueling DQN, PriorityExperienceReplay_FEED_TY...48.784701254.59.5reward
4(Dueling DQN, PriorityExperienceReplay_FEED_TY...55.326164243.49.7reward
5(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...258.565333499.013.9reward
6(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...269.299778499.016.0reward
7(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...154.370067499.010.5reward
8(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...141.921508252.610.2reward
9(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...168.225721499.012.8reward
10(DQN Fixed Targeting, ExperienceReplay_FEED_TY...148.154989499.010.6reward
11(DQN Fixed Targeting, ExperienceReplay_FEED_TY...141.317738285.814.1reward
12(DQN Fixed Targeting, ExperienceReplay_FEED_TY...229.873836496.09.8reward
13(DQN Fixed Targeting, ExperienceReplay_FEED_TY...149.444346483.913.5reward
14(DQN Fixed Targeting, ExperienceReplay_FEED_TY...137.559645499.010.4reward
15(DQN Fixed Targeting, PriorityExperienceReplay...29.12533381.67.2reward
16(DQN Fixed Targeting, PriorityExperienceReplay...52.764745166.89.6reward
17(DQN Fixed Targeting, PriorityExperienceReplay...16.28691847.85.9reward
18(DQN Fixed Targeting, PriorityExperienceReplay...16.516186119.88.3reward
19(DQN Fixed Targeting, PriorityExperienceReplay...16.339468218.58.4reward
20(Dueling DQN, PriorityExperienceReplay_FEED_TY...37.997111137.111.7reward
21(Dueling DQN, PriorityExperienceReplay_FEED_TY...32.31197382.89.1reward
22(Dueling DQN, PriorityExperienceReplay_FEED_TY...27.884035131.65.9reward
23(Dueling DQN, PriorityExperienceReplay_FEED_TY...48.784701254.59.5reward
24(Dueling DQN, PriorityExperienceReplay_FEED_TY...55.326164243.49.7reward
25(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...258.565333499.013.9reward
26(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...269.299778499.016.0reward
27(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...154.370067499.010.5reward
28(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...141.921508252.610.2reward
29(Dueling DQN, ExperienceReplay_FEED_TYPE_STATE...168.225721499.012.8reward
\n", + "
" + ], + "text/plain": [ + " name average max \\\n", + "0 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 37.997111 137.1 \n", + "1 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 32.311973 82.8 \n", + "2 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 27.884035 131.6 \n", + "3 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 48.784701 254.5 \n", + "4 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 55.326164 243.4 \n", + "5 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 258.565333 499.0 \n", + "6 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 269.299778 499.0 \n", + "7 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 154.370067 499.0 \n", + "8 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 141.921508 252.6 \n", + "9 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 168.225721 499.0 \n", + "10 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 148.154989 499.0 \n", + "11 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 141.317738 285.8 \n", + "12 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 229.873836 496.0 \n", + "13 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 149.444346 483.9 \n", + "14 (DQN Fixed Targeting, ExperienceReplay_FEED_TY... 137.559645 499.0 \n", + "15 (DQN Fixed Targeting, PriorityExperienceReplay... 29.125333 81.6 \n", + "16 (DQN Fixed Targeting, PriorityExperienceReplay... 52.764745 166.8 \n", + "17 (DQN Fixed Targeting, PriorityExperienceReplay... 16.286918 47.8 \n", + "18 (DQN Fixed Targeting, PriorityExperienceReplay... 16.516186 119.8 \n", + "19 (DQN Fixed Targeting, PriorityExperienceReplay... 16.339468 218.5 \n", + "20 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 37.997111 137.1 \n", + "21 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 32.311973 82.8 \n", + "22 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 27.884035 131.6 \n", + "23 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 48.784701 254.5 \n", + "24 (Dueling DQN, PriorityExperienceReplay_FEED_TY... 55.326164 243.4 \n", + "25 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 258.565333 499.0 \n", + "26 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 269.299778 499.0 \n", + "27 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 154.370067 499.0 \n", + "28 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 141.921508 252.6 \n", + "29 (Dueling DQN, ExperienceReplay_FEED_TYPE_STATE... 168.225721 499.0 \n", + "\n", + " min type \n", + "0 11.7 reward \n", + "1 9.1 reward \n", + "2 5.9 reward \n", + "3 9.5 reward \n", + "4 9.7 reward \n", + "5 13.9 reward \n", + "6 16.0 reward \n", + "7 10.5 reward \n", + "8 10.2 reward \n", + "9 12.8 reward \n", + "10 10.6 reward \n", + "11 14.1 reward \n", + "12 9.8 reward \n", + "13 13.5 reward \n", + "14 10.4 reward \n", + "15 7.2 reward \n", + "16 9.6 reward \n", + "17 5.9 reward \n", + "18 8.3 reward \n", + "19 8.4 reward \n", + "20 11.7 reward \n", + "21 9.1 reward \n", + "22 5.9 reward \n", + "23 9.5 reward \n", + "24 9.7 reward \n", + "25 13.9 reward \n", + "26 16.0 reward \n", + "27 10.5 reward \n", + "28 10.2 reward \n", + "29 12.8 reward " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "group_interp.analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model_dirs = ['data/lunarlander_dueling dqn', 'data/lunarlander_ddqn']\n", + "group_interp_2 = GroupAgentInterpretation()\n", + "for model_dir in model_dirs:\n", + " for file in os.listdir(model_dir):\n", + " file = file.replace('.pickle', '')\n", + " group_interp_2.add_interpretation(GroupAgentInterpretation.from_pickle(model_dir, file))\n", + "group_interp_2.plot_reward_bounds(per_episode=True, smooth_groups=20)\n", + "group_interp.add_interpretation(group_interp_2)" + ] + } + ], + "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.7.5" + }, + "pycharm": { + "stem_cell": { + "cell_type": "raw", + "metadata": { + "collapsed": false + }, + "source": [] + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/docs_src/rl.core.mdp_interpreter.ipynb b/docs_src/rl.core.mdp_interpreter.ipynb deleted file mode 100644 index 315ead8..0000000 --- a/docs_src/rl.core.mdp_interpreter.ipynb +++ /dev/null @@ -1,360 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Interpreter Demo" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "pygame 2.0.0.dev3 (SDL 2.0.9, python 3.6.9)\n", - "Hello from the pygame community. https://www.pygame.org/contribute.html\n" - ] - }, - { - "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", - "
epochtrain_lossvalid_losstime
00.5364730.53881300:41
10.5369590.53758900:00
20.5363760.53536900:00
30.5357730.53441000:00
40.5367610.53985200:00
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import gym\n", - "import numpy as np\n", - "\n", - "from fast_rl.agents.DQN import DQN\n", - "from fast_rl.core.Learner import AgentLearnerAlpha\n", - "from fast_rl.core.MarkovDecisionProcess import MDPDataBunchAlpha, MDPDatasetAlpha\n", - "from fast_rl.core.Interpreter import AgentInterpretationAlpha\n", - "%matplotlib inline\n", - " \n", - "data = MDPDataBunchAlpha.from_env('CartPole-v1', render='human', bs=64)\n", - "model = DQN(data)\n", - "learn = AgentLearnerAlpha(data, model)\n", - "\n", - "learn.fit(5)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "data.to_pickle()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "data = MDPDataBunchAlpha.from_pickle('CartPole-v1', render='human', bs=64)\n", - "model = DQN(data)\n", - "learn = AgentLearnerAlpha(data, model)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.1222222222222222 1.3222222222222224 -1.4745813310146332 -0.2745814025402069\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "interp = AgentInterpretationAlpha(learn)\n", - "interp.plot_q_density()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "interp.plot_episode(1)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "interp.plot_rewards_over_iterations(1)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "interp.plot_rewards_over_iterations(cumulative=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "interp.plot_rewards_over_episodes(cumulative=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe4AAAIZCAYAAABgaNxqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzddXgc573F8fOTDDLKzMwUOyZJgYbTJg2zLTtmyW3DbUOFUHPTNrmhpmkTy8x2qKE2aZhFZmZmZln03j92c+s6hrWt3dnZ/X6ex492Z2d3jta2jt6Zd2fMOScAAOAPCV4HAAAAoaO4AQDwEYobAAAfobgBAPARihsAAB+huAEA8BGKGwAAH6G4AR+ygDFmtsvMcr3OE25m1sLMnJmV8zoL4DWKGzhNZrbazA6Z2T4z221m35rZz8ws4aj1zjWzT4Pr7TGzd8yswxGPXxQspZePet7XZjboOJs/X9Llkpo451LK6PupYGaPmdkyMzsQ/P5Gm1mL03y9i8xs/VHLHjOzIjPbf8R7dk5Z5AfiBcUNnJlrnHPVJDWX9CdJD0oa9f2DwVL6t6S3JTWS1FLSXEnfHFWIByQNOIWSbC5ptXPuwKkGPsGo9XVJ10pKl5QsqZukGZIuLcNtSNI051xVSXUlfS3pTTOzU90GEK8obqAMOOf2OOfekXSbpIFm1iX40NOSxjvnXnTO7XPO7XTO/U5SrqRHj3iJ3ZLGHrXsmMxsqKSRks4JjlwfDy7PMLPlZrYzOKpvdMRznJndYWbLJC07xmtepsAI/jrnXJ5zrjj4Pb3snBsVXGewmS0K7jlYaWbDj3j+RWa23sweNLPNkqZI+pekRsGM+4/ME3zPiiSNk9RAUm0zSzCz35nZGjPbambjzSz5OO9BspmNMrNNZrbBzJ40s8STvXdALKC4gTLknMuVtF7Sj8yssqRzJb12jFWnS/rxUcv+R9JNZtb+JNsYJelnkr5zzlV1zj1qZpdI+qOkWyU1lLRG0tSjnnq9pFRJnY7xspdJynXOrTvBprdKulpSdUmDJT1vZj2OeLyBpFoK7A0YIOlKSRuDGas65zYe+WJmVlHSIEnrnXPbg7cHSbpYUitJVSX99ThZxkkqltRGUncF3sthJ8gOxAyKGyh7GxUosFoK/B/bdIx1Nimwq/j/Oec2S3pF0hOnsc1+kkY752Y65w5LeliBEXmLI9b5Y3DEf+gYz699nJxH5nvfObfCBXyhwCGAHx2xSqmkR51zh4+zje/dama7Ja2T1FOBXyi+/x6ec86tdM7tD34PfY7e7W5m9RX4peBe59wB59xWSc9L6nOi/ECsYIYmUPYaS9opaZcCZdZQ0uKj1mkoadsxnvtnSSvMrNspbrORpJnf33HO7TezHcEsq4OLTzSa3iGp3Yk2YGZXKrArv50Cv5BUljTviFW2OecKQsg63TnX/xjLGymwp+B7axT4GVX/qPWaSyovadMRh8YTdOLvD4gZjLiBMmRmvRUoy6+DE8e+k3TLMVa9VdIXRy90zu2Q9IKkP5zipjcqUGjf56iiwCh6w5Evf4LnfywpxcyaHOvB4G7tNyT9r6T6zrkakv4p6chJZUe//qleM/i/vgdJzRTYHb7lqPXWSTosqY5zrkbwT3XnXOdT3B7gSxQ3UAbMrLqZXa3AceWJzrnvR6IPKTBZ7W4zq2ZmNc3sSUkXKHBM+lieU+DYeMdTiDBZ0mAzOztYsk9JynHOrQ7lyc65jyV9JOktM+tpZuWCeX9mZkMkVZBUUYG9BMXB0ffRx+iPtkWBSWfHnGB2DFMk3WdmLc2savB7mOacKz4q6yYFdtM/G3zfE8ystZldGOJ2AF+juIEz866Z7VNgFPhbBUp38PcPOue+lvQTSTcqcAx5p6SBki45otz/i3NurwKz0WuFGsI594mk3yswKt4kqbVO/ZjvzQqMoqdJ2iNpvqRekj52zu2TdLcCk+p2KfCRsXdOkmmxAmW8MviZ7UYnWl/SaEkTJH0paZWkAkl3HWfdAQr8MrEwmOd1BQ4/ADHPnDvVvVkATlfw2PWnktKdcx96nQeA/zDiBiLIOTdHgVnUZ3H6TgCngxE3AAA+wogbAAAfobgBAPARihsAAB+huAEA8BGKGwAAH6G4AQDwEYobAAAfobgBAPARihsAAB+huAEA8BGKGwAAH6G4AQDwEYobAAAfobgBAPARihsAAB+huAEA8BGKGwAAH6G4AQDwEYobAAAfobgBAPARihsAAB+huAEA8BGKGwAAH6G4AQDwEYobAAAfobgBAPARihsAAB+huAEA8BGKGwAAH6G4AQDwEYobAAAfobgBAPARihsAAB+huAEA8BGKGwAAH6G4AQDwEYobAAAfobgBAPARihsAAB+huAEA8BGKGwAAH6G4AQDwEYobAAAfKed1gFDUqVPHtWjRwusYAABExIwZM7Y75+oe6zFfFHeLFi2Un5/vdQwAACLCzNYc7zF2lQMA4CMUNwAAPkJxAwDgIxQ3AAA+QnEDAOAjFDcAAD5CcQMA4CMUNwAAPkJxAwDgIxQ3AAA+QnEDAOAjFDcAAD5CcQMA4CMUNwAAPkJxAwDgIxQ3AAA+QnEDAHAGtu4r0P7DxRHbHsUNAMBp2rynQH1ezdadk2dGbJsUNwAAp2H9roO69dXvtHXfYd15cZuIbbdcxLYEAECMWLvjoPpmZWtvQZEmDE1R92Y1I7ZtihsAgFOwctt+pWflqKC4RFMy0tSlcXJEt09xAwAQouVb96lvVo5KS52mZKSpY8PqEc9AcQMAEILFm/eqX1aOzExTM9PUtn41T3IwOQ0AgJOYv2GP+o7IVrlE07Th3pW2RHEDAHBCs9ftVnpWtipXKKfpw89R67pVPc3DrnIAAI5jxpqdGjg6TzWrlNeUjDQ1qVnZ60gUNwAAx5K9coeGjM1T/epJmpyRqobJlbyOJIld5QAA/MA3y7dr0JhcNUxO0rTMtKgpbYkRNwAA/+XzJVs1fMIMtahdRROHpaputYpeR/ovFDcAAEEfL9yiX0yaqTb1qmrisFTVqlLB60g/wK5yAAAkfTB/k342cYY6NqymKRlpUVnaEsUNAIDembNRd0yepa5NkjVhWKqSK5f3OtJxsascABDX3py5Xr9+bY56tail0YN6q2rF6K7G6E4HAEAYTc9bpwffnKtzWtXWyIG9VLlC9Ndi9CcEACAMJmav0e/+MV8XtKurEbf3VFL5RK8jhYRj3ACAuDPmm1X63T/m69IO9XxV2hIjbgBAnHn1ixX6478W64rODfSXvt1VoZy/xrAUNwAgbrz0yTI9+9FSXdOtkZ67tZvKJ/qrtCWKGwAQB5xzev6jpfrLp8t1Y/fGevrmrirnw9KWKG4AQIxzzulPHyzWq1+s1K29muiPN3ZVYoJ5Heu0UdwAgJjlnNMf3luk0d+sUv+0Znri2i5K8HFpSxQ3ACBGlZY6PfrOAk3IXqPB57XQI1d3kpm/S1uiuAEAMai01Ok3b83T1Lx1Gn5hKz10RYeYKG2J4gYAxJiSUqf7X5+jN2du0N2XtNF9l7eLmdKWKG4AQAwpKinVL6fP0btzNuqXl7fT3Ze29TpSmaO4AQAxobC4VPdMnaV/zd+sh67soJ9d2NrrSGFBcQMAfO9wcYnumDRTHy/aqt9f3UlDz2/pdaSwobgBAL5WUFSi4RNm6Iul2/SH67vo9rTmXkcKK4obAOBbhwpLNGx8nr5dsUN/vuks3da7mdeRwo7iBgD40oHDxRoyNk95q3fq2Vu66cYeTbyOFBEUNwDAd/YWFGnwmDzNXrdbL/Tprmu7NfI6UsRQ3AAAX9lzsEgDRudowca9+mvf7rryrIZeR4ooihsA4Bu7DhSq/6gcLduyX6/076nLOtX3OlLEUdwAAF/Yvv+w+o/M0artBzRiQE9d1L6e15E8QXEDAKLe1r0FSh+Zo/W7Dmr0oN46r00dryN5huIGAES1TXsOKT0rR1v2Fmjs4BSltartdSRPUdwAgKi1ftdBpWflaNeBQk0YmqKezWt5HclzFDcAICqt3XFQfbOyta+gSBOHpapb0xpeR4oKFDcAIOqs3LZf6Vk5Kigu0eSMNHVpnOx1pKhBcQMAosqyLfuUPjJHpaVOUzPT1KFBda8jRZUErwMAAPC9RZv2qs+IbEmitI+D4gYARIX5G/aob1a2yicmaFpmmtrWr+Z1pKhEcQMAPDd73W6lZ2WrSoVymjY8Ta3qVvU6UtTiGDcAwFP5q3dq0Jg81apSQZMzUtWkZmWvI0U1RtwAAM9kr9yhAaNzVa9aRU0bnkZph4ARNwDAE18v265h4/PUtGZlTRqWqnrVk7yO5AsUNwAg4j5bslXDJ8xQqzpVNHFYqupUreh1JN8I+65yM0s0s1lm9l7wfkszyzGzZWY2zcwqhDsDACB6fLRwi4aPn6G29apqSkYapX2KInGM+x5Ji464/2dJzzvn2kraJWloBDIAAKLAP+dt0s8nzlDHRtU1eViaalZh7HaqwlrcZtZE0lWSRgbvm6RLJL0eXGWcpOvDmQEAEB3enr1Bd02ZpW5Na2ji0BQlVy7vdSRfCveI+wVJD0gqDd6vLWm3c644eH+9pMbHeqKZZZpZvpnlb9u2LcwxAQDh9PqM9bpv2mz1al5T44ekqFoSpX26wlbcZna1pK3OuRlHLj7Gqu5Yz3fOjXDO9XLO9apbt25YMgIAwm9q7lrd//ocndu6jsYOTlGVisyLPhPhfPfOk3Stmf1UUpKk6gqMwGuYWbngqLuJpI1hzAAA8ND471brkbcX6KL2dfVK/55KKp/odSTfC9uI2zn3sHOuiXOuhaQ+kj51zvWT9Jmkm4OrDZT0drgyAAC8M/KrlXrk7QW6rGN9vXo7pV1WvDhz2oOSfmlmyxU45j3KgwwAgDD6++cr9OT7i3Rllwb6W78eqliO0i4rETnQ4Jz7XNLnwdsrJaVEYrsAgMj7yyfL9NxHS3Vtt0Z67tZuKpfI2bXLEjMEAABlwjmn5z5aqpc+Xa4bezTWMzd3U2LCseYk40xQ3ACAM+ac05/+tVivfrlSfXo31VM3nKUESjssKG4AwBlxzumJ9xZqzDerdXtacz1+bWdKO4wobgDAaSstdfr92/M1KWethpzXUr+/uqMCJ8lEuFDcAIDTUlLq9PCbczU9f71+dmFrPXhFe0o7AihuAMApKy4p1f2vz9Vbszbo7kvb6r7L2lLaEUJxAwBOSVFJqe6bNlvvzd2kX/+4ne68pK3XkeIKxQ0ACFlhcanumjJTHy7Yot/8tIMyL2jtdaS4Q3EDAEJSUFSiOybN1CeLt+rRazpp8HktvY4UlyhuAMBJFRSVKGN8vr5atl1PXt9F/dOaex0pblHcAIATOlhYrKFj85W9aoeevqmrbu3d1OtIcY3iBgAc1/7DxRoyJk/5a3bquVu76YbuTbyOFPcobgDAMe0tKNKg0bmas36PXuzTXdd0a+R1JIjiBgAcw+6DhRowOleLNu3Vy+k9dEWXBl5HQhDFDQD4LzsPFKr/yBwt37pfr/TvqUs71vc6Eo5AcQMA/t+2fYfVb2S21uw4qKyBvXRhu7peR8JRKG4AgCRpy94CpWdla+PuAo0Z1FvntqnjdSQcA8UNANDG3YeUnpWtbfsOa9yQFKW0rOV1JBwHxQ0AcW7dzoNKH5mt3QeKNH5oqno2r+l1JJwAxQ0AcWz19gNKz8rWgcISTcpIVdcmNbyOhJOguAEgTq3Ytl/pWdkqLC7V5IxUdW6U7HUkhIDiBoA4tHTLPqVn5Uhympp5jto3qOZ1JISI4gaAOLNw4171H5WjcgmmyRnnqE29ql5HwilI8DoAACBy5q3fo75Z2apYLkHThlPafsSIGwDixMy1uzRwdK6qJ5XX1Mw0Na1V2etIOA0UNwDEgbzVOzV4TJ5qV62gyRlpalyjkteRcJoobgCIcd+t2KGh4/LUIDlJk4elqUFykteRcAY4xg0AMeyrZds0eGyuGteopKmZlHYsYMQNADHqs8VbNXziDLWqU0WThqWqdtWKXkdCGaC4ASAG/XvBZt0xeabaN6imCUNSVbNKBa8joYxQ3AAQY96fu0n3TJ2lLo2TNW5IipIrlfc6EsoQx7gBIIa8PXuD7poyU92b1dCEoZR2LGLEDQAx4rX8dXrgjblKbVlLowb2VpWK/IiPRfytAkAMmJyzVr95a55+1LaORtzeS5UqJHodCWFCcQOAz437drUefWeBLm5fV3/v31NJ5SntWEZxA4CPjfxqpZ58f5Eu71Rff03vrorlKO1YR3EDgE+9/NlyPfPhEl11VkO90OdslU9kvnE8oLgBwGecc3rxk2V64eNluv7sRvrfW7qpHKUdNyhuAPAR55ye+XCJ/vb5Ct3cs4n+fFNXJSaY17EQQRQ3APiEc07/8/4ijfx6lfqmNNP/XN9FCZR23KG4AcAHnHN67J0FGvfdGg08p7keu7azzCjteERxA0CUKy11+u0/5mtK7lpl/KilfvPTjpR2HKO4ASCKlZQ6PfjGXL0+Y73uuLi1fv3j9pR2nKO4ASBKFZeU6levzdHbszfqvsva6e5L21DaoLgBIBoVlZTq3qmz9f68Tbr/J+11x8VtvI6EKEFxA0CUOVxcojsnz9JHC7fod1d11LAftfI6EqIIxQ0AUaSgqEQ/nzhDny3Zpsev7ayB57bwOhKiDMUNAFHiUGGJMifk66tl2/XUDWcpPbWZ15EQhShuAIgCBw4Xa+i4POWs2qlnbu6qW3o19ToSohTFDQAe21dQpMFj8jRz7S69cNvZuu7sxl5HQhSjuAHAQ3sOFWng6FzN37BHL/Xtoau6NvQ6EqIcxQ0AHtl9sFC3j8rV4s179bd+PfTjzg28jgQfoLgBwAM79h9Wv5E5Wrn9gEbc3ksXd6jndST4BMUNABG2dV+B+mXlaO3Ogxo5oJcuaFfX60jwEYobACJo854CpY/M1qbdBRozuLfObV3H60jwGYobACJkw+5DSs/K1o79hRo/NEW9W9TyOhJ8iOIGgAhYt/Og+mZla8+hIo0fmqIezWp6HQk+RXEDQJit2n5A6VnZOlhYosnD0nRWk2SvI8HHKG4ACKPlW/crPStbxaVOUzLS1KlRda8jwecobgAIkyWb96nfyGxJpqmZaWpXv5rXkRADErwOAACxaMHGPeoz4jslGKWNssWIGwDK2Nz1u3X7qFxVqZCoyRlpalGniteREEMobgAoQzPW7NKg0blKrlxeUzLS1LRWZa8jIcZQ3ABQRnJW7tCQsXmqU62ipmSkqVGNSl5HQgyiuAGgDHy7fLuGjstXwxpJmpKRpvrVk7yOhBjF5DQAOENfLN2mwWPz1LRWJU3NpLQRXoy4AeAMfLJoi34+caZa16uqiUNTVLtqRa8jIcZR3ABwmj6Yv1l3TZmpDg2qa8LQFNWoXMHrSIgD7CoHgNPw3tyNumPyTHVpnKyJw1IpbUQMI24AOEVvzVqvX02fo57Na2rM4BRVrciPUkQO/9oA4BRMz1unB9+cq7SWtTVqUC9VrsCPUUQWu8oBIESTctbogTfm6vw2dTR6UG9KG57gXx0AhGDsN6v02LsLdUmHevpbvx5KKp/odSTEKYobAE5ixJcr9NQ/F+snnevrpb49VKEcOyvhHYobAE7g5c+W65kPl+iqrg31wm1nq3wipQ1vUdwAcAzOOb3w8TK9+Mky3dC9sZ65uavKUdqIAhQ3ABzFOaenP1yiv3++Qrf0bKI/3dRViQnmdSxAEsUNAP/FOacn31+kUV+vUnpqMz15XRclUNqIIhQ3AASVljo99u4Cjf9ujQad20KPXtNJZpQ2okvYDtiYWZKZ5ZrZHDNbYGaPB5e3NLMcM1tmZtPMjPMEAvBcaanTb/8xT+O/W6PMC1pR2oha4ZxpcVjSJc65bpLOlnSFmaVJ+rOk551zbSXtkjQ0jBkA4KRKSp3uf32upuSu0x0Xt9bDV3agtBG1wlbcLmB/8G754B8n6RJJrweXj5N0fbgyAMDJFJeU6pfTZ+uNmet132Xt9Osft6e0EdXC+tkGM0s0s9mStkr6SNIKSbudc8XBVdZLanyc52aaWb6Z5W/bti2cMQHEqaKSUt0zdbbenr1R9/+kve65rC2ljagX1uJ2zpU4586W1ERSiqSOx1rtOM8d4Zzr5ZzrVbdu3XDGBBCHDheX6BeTZur9eZv0u6s66o6L23gdCQhJRGaVO+d2m9nnktIk1TCzcsFRdxNJGyORAQC+V1BUop9PnKHPlmzTE9d11oBzWngdCQhZOGeV1zWzGsHblSRdJmmRpM8k3RxcbaCkt8OVAQCOdqiwRMPG5evzpdv0xxvPorThO+EccTeUNM7MEhX4BWG6c+49M1soaaqZPSlplqRRYcwAAP/vwOFiDR2Xp5xVO/X0TV11S6+mXkcCTlnYits5N1dS92MsX6nA8W4AiJh9BUUaPCZPs9bt1gu3na3rzj7mvFgg6nHmNAAxb8+hIg0cnav5G/bopb7d9dOzGnodCThtFDeAmLbrQKFuH52jJZv36W/9eujHnRt4HQk4IyednGZm55lZleDt/mb2nJk1D380ADgzO/YfVt+sbC3dsl8jBvSitBETQplV/ndJB82sm6QHJK2RND6sqQDgDG3dW6A+I7K1escBjRrYSxe3r+d1JKBMhFLcxc45J+k6SS86516UVC28sQDg9G3eEyjtDbsPacygFP2oLSdxQuwI5Rj3PjN7WFJ/SRcEP95VPryxAOD0rN91UOlZOdp5oFDjh6SoV4taXkcCylQoI+7bFLjS11Dn3GYFzi3+TFhTAcBpWLvjoG57NVu7DhZqwlBKG7HppCPuYFk/d8T9teIYN4Aos2r7AaVnZetQUYmmZKSpS+NkryMBYXHc4jazfTrOBUAkyTlXPSyJAOAULd+6T32zclRa6jQlI00dG/LjCbHruMXtnKsmSWb2hKTNkiZIMkn9xOQ0AFFi8ea96peVIzPT1Mw0ta3PjyfEtlCOcf/EOfc359w+59xe59zfJd0U7mAAcDLzN+xR3xHZKpdomjac0kZ8CKW4S8ysn5klmlmCmfWTVBLuYABwInPW7VZ6VrYqVyin6cPPUeu6Vb2OBEREKMWdLulWSVuCf24JLgMAT8xYs1P9R+YouXJ5Tc1MU/PaVbyOBETMCWeVBz+zfYNz7roI5QGAE8pZuUODx+apfvUkTc5IVcPkSl5HAiLqhCNu51yJAmdMAwDPfbN8uwaOyVXD5CRNy0yjtBGXQjlz2jdm9ldJ0yQd+H6hc25m2FIBwFG+WLpNmePz1aJ2FU0clqq61Sp6HQnwRCjFfW7w6xNHLHOSLin7OADwQx8v3KJfTJqpNvWqauKwVNWqUsHrSIBnQjlz2sWRCAIAx/LB/E26c/IsdW5UXeOHpCq5MpdKQHwLZcQtM7tKUmdJSd8vc849cfxnAMCZe3fORt07bba6NUnW2CEpqp5EaQMnLW4ze0VSZUkXSxop6WZJuWHOBSDOvTlzvX792hz1alFLowf1VtWKIY0zgJgXyue4z3XODZC0yzn3uKRzJDUNbywA8Wx63jr96rU5SmtVW2MHU9rAkUIp7kPBrwfNrJGkIkktwxcJQDybkL1GD7wxVz9qW1ejB/VW5QqUNnCkUP5HvGdmNRS4BvdMBWaUZ4U1FYC4NPrrVXrivYW6tEM9vdyvh5LKJ3odCYg6ocwq/0Pw5htm9p6kJOfcnvDGAhBvXv1ihf74r8W6onMD/aVvd1UoF8oOQSD+hDI57StJX0r6StI3lDaAsvbSJ8v07EdLdU23Rnru1m4qn0hpA8cTyv+OgZKWKHApz2/NLN/Mng9vLADxwDmn5/69RM9+tFQ3dm+sF247m9IGTiKUXeUrzeyQpMLgn4sldQx3MACxzTmnP32wWK9+sVK39Wqqp248S4kJ5nUsIOqFsqt8haTtkiZLGiXpLudcabiDAYhdzjk98d5CjflmtfqnNdMT13ZRAqUNhCSUWeV/kXS+pL6Sukv6wsy+dM6tCGsyADGptNTp0XcWaEL2Gg0+r4UeubqTzChtIFSh7Cp/UdKLZlZV0mBJj0lqIonPaQA4JaWlTr95a56m5q3T8Ata6aErO1DawCkKZVf5swqMuKtK+k7SIwrMMAeAkJWUOt3/+hy9OXOD7r6kje67vB2lDZyGUHaVZ0t62jm3JdxhAMSmopJS/XL6HL07Z6N+dXk73XVpW68jAb4Vyucu3pB0uZn9XpLMrJmZpYQ3FoBYUVhcqrsmz9K7czbqoSs7UNrAGQqluF9W4MIi6cH7+4LLAOCEDheX6BeTZuiDBZv1+6s76WcXtvY6EuB7oewqT3XO9TCzWZLknNtlZhXCnAuAzxUUlWj4hBn6Yuk2/eH6Lro9rbnXkYCYEEpxF5lZogIXF5GZ1ZXE57gBHNfBwmJljM/Xtyt26M83naXbejfzOhIQM0LZVf4XSW9Jqmdm/yPpa0lPhTUVAN/af7hYg8bk6bsVO/TsLd0obaCMhfI57klmNkPSpZJM0vXOuUVhTwbAd/YWFGnwmDzNXrdbL/bprmu6NfI6EhBzQrpCvXNusaTFkmRmNczst865/wlrMgC+sudgkQaMztGCjXv1cnp3XdGlodeRgJh03F3lZtbUzEaY2XtmNszMKgdPxrJUUr3IRQQQ7XYeKFTfrGwt2rRPr/TvSWkDYXSiEfd4SV8o8DnuKxQ4EcsCSV2dc5sjkA2AD2zff1j9R+Zo1fYDGjGgpy5qz+/1QDidqLhrOeceC97+0My2SOrtnDsc/lgA/GDr3gKlj8zR+l0HNXpQb53Xpo7XkYCYd8Jj3GZWU4EJaZK0WVJlM6siSc65nWHOBiCKbdpzSOlZOdqyt0DjBqcotVVtryMBceFExZ0saYb+U9ySNDP41UlqFa5QAKLb+l0HlZ6Vo10HCjVhaIp6Nq/ldSQgbhy3uJ1zLSKYA4BPrNlxQOlZOdpXUKSJw1LVrWkNryMBcSWkj4MBgCSt2LZf/bJyVFBcoskZaerSONnrSEDcobgBhGTZln1KH5mj0lKnqZlp6tCguteRgLgUyilPAcS5RZv2qs+IbEmitAGPhVTcZna+mQ0O3q5rZi3DG4ICZwIAAB+7SURBVAtAtJi/YY/6ZmWrfGKCpmWmqW39al5HAuLaSYvbzB6V9KCkh4OLykuaGM5QAKLD7HW7lZ6VrSoVymn68HPUqm5VryMBcS+UEfcNkq6VdECSnHMbJfErNxDj8lfvVP+ROapRuYKmDU9Ts9qVvY4EQKEVd6Fzzuk/1+OuEt5IALz23YodGjA6V/WqVdS04WlqUpPSBqJFKMU93cxelVTDzDIkfSwpK7yxAHjl62XbNXhsrhrXqKSpmWlqmFzJ60gAjhDK9bj/18wul7RXUntJjzjnPgp7MgAR99mSrRo+YYZa1amiicNSVadqRa8jATjKSYvbzO6T9BplDcS2jxZu0R2TZqpdg6qaMCRVNatU8DoSgGMIZVd5dQWuDvaVmd1hZvXDHQpAZP1r3ib9fOIMdWxUXZOGpVHaQBQ7aXE75x53znWWdIekRpK+MLOPw54MQES8PXuD7pwyS92a1tDEoSlKrlTe60gATuBUzpy2VYFLe+6QVC88cQBE0usz1uveabPVq3lNjR+SompJlDYQ7UI5AcvPzexzSZ9IqiMpwznXNdzBAITXlNy1uv/1OTqvdR2NHZyiKhW5dAHgB6H8T20u6V7n3OxwhwEQGeO/W61H3l6gi9rX1Sv9eyqpfKLXkQCE6LjFbWbVnXN7JT0dvF/ryMedczvDnA1AGIz8aqWefH+RLutYXy/3666K5ShtwE9ONOKeLOlqSTMUOGuaHfGYk9QqjLkAhMHfPl+upz9Yoiu7NNCLfbqrQjkuEAj4zXGL2zl3dfArVwIDfM45p798slzPf7xU13ZrpOdu7aZyiZQ24EehTE77JJRlAKKTc07P/nupnv94qW7s0VjP33Y2pQ342ImOcSdJqiypjpnV1H92lVdX4PPcAKKcc05//Ndijfhypfr0bqqnbjhLCQl28icCiFonOsY9XNK9CpT0DP2nuPdKejnMuQCcIeecHn93ocZ+u1q3pzXX49d2prSBGHCiY9wvSnrRzO5yzr0UwUwAzlBpqdMj78zXxOy1Gnp+S/3uqo4yo7SBWBDK1cFeMrMukjpJSjpi+fhwBgNwekpKnR5+c66m56/Xzy5srQevaE9pAzEklKuDPSrpIgWK+5+SrpT0tSSKG4gyxSWluv/1uXpr1gbdfWlb3XdZW0obiDGhTC29WdKlkjY75wZL6iaJi/QCUaaopFT3Tputt2Zt0K9/3E6/vLwdpQ3EoFBOeXrIOVdqZsVmVl2Bi41w8hUgihQWl+quKTP14YIt+s1POyjzgtZeRwIQJqEUd76Z1ZCUpcDs8v2ScsOaCkDICopKdMekmfpk8VY9ek0nDT6PcyYBsSyUyWm/CN58xcw+kFTdOTc3vLEAhKKgqEQZ4/P11bLtevL6Luqf1tzrSADC7EQnYOlxosecczPDEwlAKA4WFmvo2Hxlr9qhp2/qqlt7N/U6EoAIONGI+9kTPOYkXVLGWQCEaP/hYg0Zk6f8NTv17C3ddGOPJl5HAhAhJzoBy8WRDAIgNHsLijRwdK7mrt+jF/t01zXdOAMxEE9C+Rz3gGMt5wQsQOTtPlioAaNztWjTXr2c3l1XdGnodSQAERbKrPLeR9xOUuAz3TPFCViAiNp5oFD9R+Zo+db9eqV/T13asb7XkQB4IJRZ5Xcded/MkiVNCFsiAD+wbd9h9RuZrTU7DiprYC9d2K6u15EAeOR0Lsp7UFLbk61kZk3N7DMzW2RmC8zsnuDyWmb2kZktC36teRoZgLixZW+B+oz4Tut2HtLoQb0pbSDOhXKM+10FZpFLgaLvJGl6CK9dLOlXzrmZZlZN0gwz+0jSIEmfOOf+ZGYPSXpI0oOnEx6IdRt3H1J6Vra27TuscUNSlNKylteRAHgslGPc/3vE7WJJa5xz60/2JOfcJkmbgrf3mdkiSY0lXafARUskaZykz0VxAz+wbudB9c3K1p6DRRo/NFU9m7NzCkBox7i/kKTgecrLBW/Xcs7tDHUjZtZCUndJOZLqB0tdzrlNZlbvOM/JlJQpSc2aNQt1U0BMWL39gNKzsnWgsESTMlLVtUkNryMBiBInPcZtZplmtkXSXEn5CpyvPD/UDZhZVUlvSLrXObc31Oc550Y453o553rVrcsxPcSP5Vv367YR36mguFSTKW0ARwllV/n9kjo757af6oubWXkFSnuSc+7N4OItZtYwONpuqMDVxgBIWrJ5n/qNzJHkNCUjTe0bVPM6EoAoE8qs8hUKzCQ/JRa4EPAoSYucc88d8dA7kgYGbw+U9PapvjYQixZu3Ku+WdlKMGlq5jmUNoBjCmXE/bCkb80sR9Lh7xc65+4+yfPOk3S7pHlmNju47DeS/iRpupkNlbRW0i2nnBqIMXPX79bto3JVuUKiJmekqWWdKl5HAhClQinuVyV9KmmepNJQX9g597UkO87Dl4b6OkCsm7l2lwaOylX1SuU1NTNNTWtV9joSgCgWSnEXO+d+GfYkQBzKW71Tg0bnqk61ipqckabGNSp5HQlAlAvlGPdnwZnlDYNnPatlZpwFAjhD367YrgGjclU/OUnTMs+htAGEJJQRd3rw68NHLHOSWpV9HCA+fLl0mzLG56tZrcqalJGqetWSvI4EwCdCOQFLy0gEAeLFp4u36GcTZqpV3SqaNCxVtatW9DoSAB/hetxABH24YLPunDxT7RtU04QhqapZpYLXkQD4DNfjBiLk/bmbdM/UWerSOFnjhqQouVJ5ryMB8CGuxw1EwD9mbdAvp89Wj2Y1NWZwb1VLorQBnJ5QRtxHC+l63AACXstfpwfemKvUlrU0amBvVal4Ov/tACAgnNfjBuLe5Jy1+s1b8/SjtnU04vZeqlQh0etIAHwubNfjBuLd+O9W65G3F+ji9nX19/49lVSe0gZw5o5b3GbWRoFrZ39x1PIfmVlF59yKsKcDfGrkVyv15PuLdHmn+vprendVLEdpAygbJzpz2guS9h1j+aHgYwCO4e+fr9CT7y/ST89qoL/160FpAyhTJ9pV3sI5N/fohc65fDNrEbZEgE855/SXT5br+Y+X6tpujfTcrd1ULjGUswoDQOhOVNwnOgcjJ1UGjuCc0//+e4le/myFbu7ZRH++qasSE453cTwAOH0nGg7kmVnG0QuD19GeEb5IgL845/TUPxfp5c9WqG9KUz1NaQMIoxONuO+V9JaZ9dN/irqXpAqSbgh3MMAPnHN6/N2FGvvtag04p7keu6azEihtAGF03OJ2zm2RdK6ZXSypS3Dx+865TyOSDIhypaVOv3t7vibnrNWw81vqt1d1lBmlDSC8Qjnl6WeSPotAFsA3SkqdHnpjrl6bsV6/uKi17v9Je0obQERw7kXgFBWXlOrXr83RP2Zv1L2XtdU9l7altAFEDMUNnIKiklLdO3W23p+3Sff/pL3uuLiN15EAxBmKGwjR4eIS3TV5lv69cIt++9OOyrigldeRAMQhihsIQUFRiX4xaaY+XbxVj13TSYPOa+l1JABxiuIGTuJQYYkyJ+Trq2Xb9dQNZyk9tZnXkQDEMYobOIGDhcUaOjZf2at26Ombu+rWXk29jgQgzlHcwHHsKyjSkLF5mrFml56/9Wxd372x15EAgOIGjmXPoSINGpOreev36KW+PXRV14ZeRwIASRQ38AO7Dxbq9lG5Wrx5r17u10M/6dzA60gA8P8obuAIO/YfVv9RuVqxbb9evb2nLulQ3+tIAPBfKG4gaNu+w+o3MltrdhzUyAG9dEG7ul5HAoAfoLgBSVv2Fig9K1sbdxdozODeOrd1Ha8jAcAxUdyIext3H1J6Vra27y/U+KEp6t2ilteRAOC4KG7EtXU7D6pvVrb2HCrS+KEp6tGspteRAOCEKG7ErdXbDyg9K1sHCks0eViazmqS7HUkADgpihtxafnW/UrPylZxqdOUjDR1alTd60gAEBKKG3FnyeZ96jcyW5Jpamaa2tWv5nUkAAhZgtcBgEhauHGv+mZlK8EobQD+RHEjbsxdv1t9s7KVVC5B04efozb1qnodCQBOGbvKERdmrt2lgaNylVy5vKZkpKlprcpeRwKA00JxI+blrtqpwWNyVadaRU3JSFOjGpW8jgQAp43iRkz7dvl2DR2Xr4Y1kjQlI031qyd5HQkAzgjHuBGzvly6TYPH5qlprUqalnkOpQ0gJjDiRkz6dPEW/WzCTLWuV1UTh6aodtWKXkcCgDJBcSPmfDB/s+6aMlMdG1bX+CEpqlG5gteRAKDMUNyIKe/N3ah7ps5W1ybJGjckRdWTynsdCQDKFMe4ETPemrVed0+ZpR7NamjC0FRKG0BMYsSNmDA9b50efHOu0lrW1qhBvVS5Av+0AcQmRtzwvUk5a/TAG3N1fps6Gj2oN6UNIKbxEw6+NvabVXrs3YW6pEM9/a1fDyWVT/Q6EgCEFcUN3xrx5Qo99c/F+knn+nqpbw9VKMcOJACxj+KGL7382XI98+ESXdW1oV647WyVT6S0AcQHihu+4pzTCx8v04ufLNMN3RvrmZu7qhylDSCOUNzwDeecnv5wif7++Qrd0rOJ/nRTVyUmmNexACCiKG74gnNOT76/SKO+XqX01GZ68rouSqC0AcQhihtRr7TU6bF3F2j8d2s06NwWevSaTjKjtAHEJ4obUa201Om3/5inKbnrlHlBKz18ZQdKG0Bco7gRtUpKnR58Y65en7Fed17cRr/6cTtKG0Dco7gRlYpLSvWr1+bo7dkbde9lbXXPpW0pbQAQxY0oVFRSqnumztI/523WA1e01y8uauN1JACIGhQ3osrh4hLdOXmWPlq4Rb+7qqOG/aiV15EAIKpQ3IgaBUUl+vnEGfpsyTY9cV1nDTinhdeRACDqUNyICocKS5QxPl/frNiuP954lvqmNPM6EgBEJYobnjtwuFhDx+UpZ9VOPXNzN93cs4nXkQAgalHc8NS+giINHpOnWet264XbztZ1Zzf2OhIARDWKG57Zc6hIA0bnasGGPXqpb3f99KyGXkcCgKhHccMTuw4U6vbROVqyeZ/+1q+Hfty5gdeRAMAXKG5E3Pb9h9V/ZI5Wbj+gEQN66eL29byOBAC+QXEjorbuK1C/rByt23VQowf21vlt63gdCQB8heJGxGzeU6D0rGxt3lugsYNTlNaqtteRAMB3KG5ExPpdB5WelaOdBwo1fkiKerWo5XUkAPAlihtht3bHQfXNytbegiJNGJqi7s1qeh0JAHyL4kZYrdp+QOlZ2TpUVKIpGWnq0jjZ60gA4GsUN8Jm+dZ96puVo9JSpykZaerYsLrXkQDA9yhuhMXizXvVLytHCQmmqZlpalu/mteRACAmUNwoc/M37NHto3JUoVyCpmSkqVXdql5HAoCYkeB1AMSWOet2Kz0rW5UrlNP04edQ2gBQxhhxo8zMWLNTg0bnqUaV8pqSkaYmNSt7HQkAYg7FjTKRs3KHBo/NU/3qSZqckaqGyZW8jgQAMYld5Thj3yzfroFjctUwOUnTMtMobQAII4obZ+SLpds0ZGyemteqoqmZ56he9SSvIwFATAtbcZvZaDPbambzj1hWy8w+MrNlwa+cQsvHPl64RRnj8tW6blVNyUxT3WoVvY4EADEvnCPusZKuOGrZQ5I+cc61lfRJ8D586IP5m/SziTPUoWE1Tc5IVa0qFbyOBABxIWzF7Zz7UtLOoxZfJ2lc8PY4SdeHa/sIn3fnbNQdk2epa5NkTRyWqhqVKW0AiJRIH+Ou75zbJEnBr/WOt6KZZZpZvpnlb9u2LWIBcWJvzlyve6bOUs9mNTV+aKqqJ5X3OhIAxJWonZzmnBvhnOvlnOtVt25dr+NA0vS8dfrVa3OU1qq2xg7praoV+TQhAERapIt7i5k1lKTg160R3j5O04TsNXrgjbm6oG1djR7UW5UrUNoA4IVIF/c7kgYGbw+U9HaEt4/TMPrrVfr9P+brso71NGJATyWVT/Q6EgDErXB+HGyKpO8ktTez9WY2VNKfJF1uZsskXR68jyj2yhcr9MR7C3VF5wb6W7+eqliO0gYAL4Vtf6dzru9xHro0XNtE2Xrpk2V69qOluqZbIz13azeVT4zaKREAEDc4UIkfcM7p+Y+W6i+fLteN3RvrmVu6KTHBvI4FABDFjaM45/SnDxbr1S9W6rZeTfXUjWdR2gAQRShu/D/nnP7w3iKN/maV+qc10xPXdlECpQ0AUYXihiSptNTpkXfma2L2Wg0+r4UeubqTzChtAIg2FDdUUur0mzfnaVr+Og2/sJUeuqIDpQ0AUYrijnMlpU73vzZHb87aoLsvaaP7Lm9HaQNAFKO441hRSal+OX2O3p2zUb+6vJ3uurSt15EAACdBccepwuJS3T1llj5YsFkPX9lBwy9s7XUkAEAIKO44dLi4RHdMmqmPF23VI1d30pDzW3odCQAQIoo7zhQUlShzwgx9uXSb/nB9F92e1tzrSACAU0Bxx5GDhcUaNi5f363coT/fdJZu693M60gAgFNEcceJ/YeLNWRMnvLX7NSzt3TTjT2aeB0JAHAaKO44sLegSING52rO+j16oU93XdutkdeRAACnieKOcXsOFmnA6Bwt2LhXL6d31xVdGnodCQBwBijuGLbzQKH6j8zR8q379Ur/nrqsU32vIwEAzhDFHaO27z+s/iNztGr7AY0Y0FMXta/ndSQAQBmguGPQ1r0FSh+Zo/W7Dmr0oN46r00dryMBAMoIxR1jNu05pPSsHG3ZW6Bxg1OU2qq215EAAGWI4o4h63YeVPrIbO0+UKQJQ1PUs3ktryMBAMoYxR0j1uw4oPSsHO0rKNLEYanq1rSG15EAAGFAcceAFdv2q19WjgqKSzQ5I01dGid7HQkAECYUt88t27JPfbNy5JzT1Mw0dWhQ3etIAIAworh9bNGmveo/MkcJCaYpGWlqW7+a15EAAGGW4HUAnJ75G/aob1a2yicmaFompQ0A8YIRtw/NXrdbA0blqFpSeU3JSFOz2pW9jgQAiBCK22fyV+/UoDF5qlWlgiZnpKpJTUobAOIJxe0j363YoaHj8lS/epKmZKSpQXKS15EAABHGMW6f+HrZdg0em6vGNSppWialDQDxihG3D3y2ZKuGT5ihVnWqaOKwVNWpWtHrSAAAj1DcUe6jhVt0x6SZategqiYMSVXNKhW8jgQA8BDFHcX+NW+T7poyS50bJ2v8kBQlVyrvdSQAgMc4xh2l3p69QXdOmaVuTWto4lBKGwAQQHFHoddnrNd902arV/OaGj8kRdWSKG0AQAC7yqPM1Ny1eviteTqvdR1lDeilShUSvY4EAIgijLijyPjvVuuhN+fpwnZ1NXIgpQ0A+CFG3FFi5Fcr9eT7i3RZx/p6uV93VSxHaQMAfojijgJ//3yF/vzBYl3ZpYFe7NNdFcqxIwQAcGwUt8f+8skyPffRUl3brZGeu7WbyiVS2gCA46O4PeKc07P/Xqq/frZcN/ZorGdu7qbEBPM6FgAgylHcHnDO6Y//WqwRX65Un95N9dQNZymB0gYAhIDijjDnnB5/d6HGfrtat6c11+PXdqa0AQAho7gjqLTU6fdvz9eknLUaen5L/e6qjjKjtAEAoaO4I6Sk1OnhN+dqev56/fyi1nrgJ+0pbQDAKaO4I6C4pFT3vz5Xb83aoHsubat7L2tLaQMATgvFHWZFJaW6d9psvT93k37943a685K2XkcCAPgYxR1GhcWlumvKTH24YIt+89MOyrygtdeRAAA+R3GHSUFRiX4xaaY+XbxVj17TSYPPa+l1JABADKC4w6CgqESZE2boy6Xb9D83dFG/1OZeRwIAxAiKu4wdLCzW0LH5yl61Q0/f1FW39m7qdSQAQAyhuMvQ/sPFGjImT/lrduq5W7vphu5NvI4EAIgxFHcZ2VtQpIGjczV3/R692Ke7runWyOtIAIAYRHGXgd0HCzVgdK4Wbdqrl9N76IouDbyOBACIURT3Gdp5oFD9R+Zo+db9eqV/T13asb7XkQAAMYziPgPb9h1W/5E5Wr3jgLIG9tKF7ep6HQkAEOMo7tO0ZW+B0rOytXF3gcYM6q1z29TxOhIAIA5Q3Kdh4+5DSs/K1rZ9hzVuSIpSWtbyOhIAIE5Q3Kdo3c6DSh+Zrd0HijR+aKp6Nq/pdSQAQByhuE/B6u0HlJ6Vrf2HizVxWKq6Na3hdSQAQJyhuEO0Ytt+pWdlq7C4VFMy09S5UbLXkQAAcYjiDsHSLfuUnpUjyWlq5jlq36Ca15EAAHGK4j6JhRv3qv+oHJVLME3OOEdt6lX1OhIAII4leB0gms1bv0d9s7JVsVyCpg2ntAEA3mPEfRyz1u7SgNG5qp5UXlMz09S0VmWvIwEAQHEfS97qnRo8Jk+1q1bQ5Iw0Na5RyetIAABIYlf5D3y3YocGjs5VvWoVNS3zHEobABBVKO4jfLVsmwaPzVXjGpU0dXiaGiQneR0JAID/wq7yoM8Wb9XwiTPUqk4VTRqWqtpVK3odCQCAH6C4Jf17wWbdMXmm2jeopglDUlWzSgWvIwEAcExxX9zvz92ke6bOUpfGyRo3JEXJlcp7HQkAgOOK62Pcb8/eoLumzNTZTWtowlBKGwAQ/eJ2xP1a/jo98MZcpbaspVEDe6tKxbh9KwAAPhKXbTU5Z61+89Y8nd+mjrIG9FKlColeRwIAICRxV9zjvl2tR99ZoIvb19Xf+/dUUnlKGwDgH3FX3PsPF+vyTvX11/TuqliO0gYA+EvcFfcdF7dRSalTYoJ5HQUAgFMWl7PKKW0AgF/FZXEDAOBXFDcAAD5CcQMA4COeFLeZXWFmS8xsuZk95EUGAAD8KOLFbWaJkl6WdKWkTpL6mlmnSOcAAMCPvBhxp0ha7pxb6ZwrlDRV0nUe5AAAwHe8KO7GktYdcX99cNl/MbNMM8s3s/xt27ZFLBwAANHMi+I+1oeo3Q8WODfCOdfLOderbt26EYgFAED086K410tqesT9JpI2epADAADf8aK48yS1NbOWZlZBUh9J73iQAwAA34n4ucqdc8VmdqekDyUlShrtnFsQ6RwAAPiRJxcZcc79U9I/vdg2AAB+xpnTAADwEYobAAAfobgBAPARihsAAB+huAEA8BFz7gcnLYs6ZrZN0poyfMk6kraX4evFGt6fM8d7GDm815HB+xxZzZ1zxzxtqC+Ku6yZWb5zrpfXOaIV78+Z4z2MHN7ryOB9jh7sKgcAwEcobgAAfCRei3uE1wGiHO/PmeM9jBze68jgfY4ScXmMGwAAv4rXETcAAL5EcQMA4CNxV9xmdoWZLTGz5Wb2kNd5oomZjTazrWY23+ssfmVmTc3sMzNbZGYLzOwerzPFIjNLMrNcM5sTfJ8f9zpTLDOzRDObZWbveZ0FcVbcZpYo6WVJV0rqJKmvmXXyNlVUGSvpCq9D+FyxpF855zpKSpN0B//GwuKwpEucc90knS3pCjNL8zhTLLtH0iKvQyAgropbUoqk5c65lc65QklTJV3ncaao4Zz7UtJOr3P4mXNuk3NuZvD2PgV+2DX2NlXscQH7g3fLB/8w0zYMzKyJpKskjfQ6CwLirbgbS1p3xP314ocqwsTMWkjqLinH2ySxKbj7drakrZI+cs7xPofHC5IekFTqdRAExFtx2zGW8Vs6ypyZVZX0hqR7nXN7vc4Ti5xzJc65syU1kZRiZl28zhRrzOxqSVudczO8zoL/iLfiXi+p6RH3m0ja6FEWxCgzK69AaU9yzr3pdZ5Y55zbLelzMT8jHM6TdK2ZrVbg0OIlZjbR20iIt+LOk9TWzFqaWQVJfSS943EmxBAzM0mjJC1yzj3ndZ5YZWZ1zaxG8HYlSZdJWuxtqtjjnHvYOdfEOddCgZ+Xnzrn+nscK+7FVXE754ol3SnpQwUmDU13zi3wNlX0MPu/9u4gxKo6iuP496eCDAilRhBRQgQipGVGGyOCVtmugkGyWrQRAiGIqEgcl61cVAshsKIYN8JACDFRUgiaUg1TuBZxKRghugg5Le5/4DGMGTb1uPd9P/B475373r33/zbnnj/vf09mgTPA1iSXk7w+7nPqod3AK3SVyUJ77Bn3SQ3QfcCpJIt0F+TfVJVLlTQRvOWpJEk9MlEVtyRJfWfiliSpR0zckiT1iIlbkqQeMXFLktQjJm5pIJLcHFmCtnC77ndJ9id5dRWOezHJPf92P5L+GZeDSQOR5FpVbRjDcS8CT1TVlf/72NIksuKWBq5VxB+0/tXnkjzc4jNJ3mqvDyS5kGQxyfEW25RkrsXOJtnR4puTzLf+zEcZ6QGQZF87xkKSo60RyNoknyb5LcmvSd4cw88gDYaJWxqOqWVT5dMj2/6oqieBj+i6PS33DrCzqnYA+1vsMPBLi70HfN7ih4DTVbWT7pbBDwIk2QZMA7tb84+bwMt0/bLvr6pHqmo7cGwVxyxNnHXjPgFJq+ZGS5grmR15PrLC9kXgyyRzwFyLPQW8CFBV37VK+y7gaeCFFj+Z5Gr7/LPALuB8d8t2puhabn4FPJTkQ+AkMH/nQ5RkxS1NhrrF6yXPAx/TJd6fkqzj79vgrrSPAJ9V1WPtsbWqZqrqKvAoXQevN4BP7nAMkjBxS5NieuT5zOiGJGuAB6rqFPA2cDewAfiBbqqbJM8AV1pv8dH4c8DGtqtvgZeS3Nu2bUqypf3jfE1VnQAOAo//V4OUJoFT5dJwTCVZGHn/dVUtLQlbn+RHuov1vcu+txb4ok2DBzhSVb8nmQGOtQ5c14HX2ucPA7NJfga+By4BVNWFJO8D8+1i4E+6CvtG289SofDu6g1ZmjwuB5MGzuVa0rA4VS5JUo9YcUuS1CNW3JIk9YiJW5KkHjFxS5LUIyZuSZJ6xMQtSVKP/AXmL26stc5GUAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "interp.plot_rewards_over_episodes(cumulative=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\r", - "t: 0%| | 0/9 [00:00" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "interp.iplot_episode(episode=1, fps=1)\n", - "interp.current_animation.ipython_display(fps=1, loop=True, autoplay=True)" - ] - } - ], - "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.9" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/docs_src/rl.core.train.interpretation.ipynb b/docs_src/rl.core.train.interpretation.ipynb new file mode 100644 index 0000000..440f7c0 --- /dev/null +++ b/docs_src/rl.core.train.interpretation.ipynb @@ -0,0 +1,206 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "is_executing": true + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Can't import one of these: No module named 'pybulletgym.envs.mujoco.envs'\n", + "pygame 1.9.6\n", + "Hello from the pygame community. https://www.pygame.org/contribute.html\n" + ] + } + ], + "source": [ + "from fast_rl.agents.dqn import *\n", + "from fast_rl.agents.dqn_models import FixedTargetDQNModule\n", + "from fast_rl.core.agent_core import *\n", + "from fast_rl.core.data_block import *\n", + "from fast_rl.core.train import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "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", + "
epochtrain_lossvalid_losstime
00.189005#na#00:02
10.202970#na#00:03
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data = MDPDataBunch.from_env('maze-random-5x5-v0', render='rgb_array', bs=5, max_steps=50,\n", + " add_valid=False, feed_type=FEED_TYPE_STATE)\n", + "model = create_dqn_model(data, FixedTargetDQNModule, opt=torch.optim.RMSprop)\n", + "memory = ExperienceReplay(10000)\n", + "exploration_method = GreedyEpsilon(epsilon_start=1, epsilon_end=0.1, decay=0.001)\n", + "learner = dqn_learner(data=data, model=model, memory=memory, exploration_method=exploration_method)\n", + "learner.fit(2)\n", + "\n", + "interp = GymMazeInterpretation(learner, ds_type=DatasetType.Train)\n", + "for i in range(-1, 4): interp.plot_heat_map(action=i)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "q_interp = QValueInterpretation(learner, ds_type=DatasetType.Train)\n", + "q_interp.plot_q()" + ] + } + ], + "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.7.5" + }, + "pycharm": { + "stem_cell": { + "cell_type": "raw", + "metadata": { + "collapsed": false + }, + "source": [] + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/fast_rl/agents/DDPG.py b/fast_rl/agents/DDPG.py deleted file mode 100644 index ac523b1..0000000 --- a/fast_rl/agents/DDPG.py +++ /dev/null @@ -1,273 +0,0 @@ -from copy import deepcopy - -import numpy as np -import torch -from fastai.basic_train import LearnerCallback, Any, OptimWrapper, ifnone -from torch import nn -from torch.nn import MSELoss -from torch.optim import Adam - -from fast_rl.agents.BaseAgent import BaseAgent, get_conv, \ - Flatten -from fast_rl.core.MarkovDecisionProcess import MDPDataBunch, Action, State -from fast_rl.core.agent_core import ExperienceReplay, OrnsteinUhlenbeck - - -def get_action_ddpg_cnn(layers, action: Action, state: State, activation=nn.ReLU, kernel_size=5, stride=2): - module_layers, out_size = get_conv(state.s.shape, activation(), kernel_size=kernel_size, stride=stride, - n_conv_layers=3, layers=[]) - module_layers += [Flatten()] - layers.append(action.taken_action.shape[1]) - for i, layer in enumerate(layers): - module_layers += [nn.Linear(out_size, layer)] if i == 0 else [nn.Linear(layers[i - 1], layer)] - module_layers += [activation()] - - return nn.Sequential(*module_layers) - - -class BaseDDPGCallback(LearnerCallback): - def __init__(self, learn): - super().__init__(learn) - self.max_episodes = 0 - self.episode = 0 - self.iteration = 0 - self.copy_over_frequency = 3 - - def on_train_begin(self, n_epochs, **kwargs: Any): - self.max_episodes = n_epochs - - def on_epoch_begin(self, epoch, **kwargs: Any): - self.episode = epoch - self.iteration = 0 - - def on_loss_begin(self, **kwargs: Any): - """Performs memory updates, exploration updates, and model optimization.""" - if self.learn.model.training: - self.learn.model.memory.update(item=self.learn.data.x.items[-1]) - self.learn.model.exploration_strategy.update(episode=self.episode, max_episodes=self.max_episodes, - do_exploration=self.learn.model.training) - post_optimize = self.learn.model.optimize() - if self.learn.model.training: - self.learn.model.memory.refresh(post_optimize=post_optimize) - self.learn.model.target_copy_over() - self.iteration += 1 - - -class NNActor(nn.Module): - def __init__(self, layers, action: Action, state: State, activation=nn.ReLU, embed=False): - super().__init__() - layers += [action.taken_action.shape[1]] - module_layers = [] - - for i, layer in enumerate(layers): - module_layers.append(nn.Linear(state.s.shape[1] if i == 0 else layers[i - 1], layer)) - if i != len(layers) - 1: module_layers.append(activation()) - - module_layers += [nn.Tanh()] - self.model = nn.Sequential(*module_layers) - - def forward(self, x): - return self.model(x) - - -class CNNActor(nn.Module): - def __init__(self, layers, action: Action, state: State, activation=nn.ReLU): - super().__init__() - # This is still some complete overlap in nn builders, for here, the default function has everything we need - self.model = get_action_ddpg_cnn(layers, action, state, activation=activation, kernel_size=5, stride=2) - - def forward(self, x): - return self.model(x) - - -class NNCritic(nn.Module): - def __init__(self, layer_list: list, action: Action, state: State): - super().__init__() - self.action_size = action.taken_action.shape[1] - self.state_size = state.s.shape[1] - - self.fc1 = nn.Linear(self.state_size, layer_list[0]) - self.fc2 = nn.Linear(layer_list[0] + self.action_size, layer_list[1]) - self.fc3 = nn.Linear(layer_list[1], 1) - - def forward(self, x): - x, action = x - - x = nn.LeakyReLU()(self.fc1(x)) - x = nn.LeakyReLU()(self.fc2(torch.cat((x, action), 1))) - x = nn.LeakyReLU()(self.fc3(x)) - - return x - - -class CNNCritic(nn.Module): - def __init__(self, action: Action, state: State): - super().__init__() - self.action_size = action.taken_action.shape[1] - self.state_size = state.s.shape - - layers = [] - layers, input_size = get_conv(self.state_size, nn.LeakyReLU(), 8, 2, 3, layers) - layers += [Flatten()] - self.conv_layers = nn.Sequential(*layers) - - self.fc1 = nn.Linear(input_size + self.action_size, 200) - self.fc2 = nn.Linear(200, 1) - - def forward(self, x): - x, action = x - - x = nn.LeakyReLU()(self.conv_layers(x)) - x = nn.LeakyReLU()(self.fc1(torch.cat((x, action), 1))) - x = nn.LeakyReLU()(self.fc2(x)) - - return x - - -class DDPG(BaseAgent): - - def __init__(self, data: MDPDataBunch, memory=None, tau=1e-3, discount=0.99, - lr=1e-3, actor_lr=1e-4, exploration_strategy=None): - """ - Implementation of a discrete control algorithm using an actor/critic architecture. - - Notes: - Uses 4 networks, 2 actors, 2 critics. - All models use batch norm for feature invariance. - NNCritic simply predicts Q while the Actor proposes the actions to take given a s s. - - References: - [1] Lillicrap, Timothy P., et al. "Continuous control with deep reinforcement learning." - arXiv preprint arXiv:1509.02971 (2015). - - Args: - data: Primary data object to use. - memory: How big the memory buffer will be for offline training. - tau: Defines how "soft/hard" we will copy the target networks over to the primary networks. - discount: Determines the amount of discounting the existing Q reward. - lr: Rate that the opt will learn parameter gradients. - """ - super().__init__(data) - self.name = 'DDPG' - self.lr = lr - self.discount = discount - self.tau = 1 - self.warming_up = True - self.batch_size = data.train_ds.bs - self.memory = ifnone(memory, ExperienceReplay(10000)) - - self.action_model = self.initialize_action_model([400, 300], data) - self.critic_model = self.initialize_critic_model([400, 300], data) - - self.opt = OptimWrapper.create(Adam, lr=actor_lr, layer_groups=[self.action_model]) - self.critic_optimizer = OptimWrapper.create(Adam, lr=lr, layer_groups=[self.critic_model]) - - self.t_action_model = deepcopy(self.action_model) - self.t_critic_model = deepcopy(self.critic_model) - - self.target_copy_over() - self.tau = tau - - self.learner_callbacks = [BaseDDPGCallback] - - self.loss_func = MSELoss() - - self.exploration_strategy = ifnone(exploration_strategy, OrnsteinUhlenbeck(size=data.action.taken_action.shape, - epsilon_start=1, epsilon_end=0.1, - decay=0.001, - do_exploration=self.training)) - - def initialize_action_model(self, layers, data): - if len(data.state.s.shape) == 4 and data.state.s.shape[-1] < 4: - return CNNActor(layers, data.action, data.state) - else: - return NNActor(layers, data.action, data.state) - - def initialize_critic_model(self, layers, data): - """ Instead of s -> action, we are going s + action -> single expected reward. """ - if len(data.state.s.shape) == 4 and data.state.s.shape[-1] < 4: - return CNNCritic(data.action, data.state) - else: - return NNCritic(layers, data.action, data.state) - - def pick_action(self, x): - if self.training: self.action_model.eval() - with torch.no_grad(): - action = super(DDPG, self).pick_action(x) - if self.training: self.action_model.train() - return np.clip(action, -1, 1) - - def optimize(self): - r""" - Performs separate updates to the actor and critic models. - - Get the predicted yi for optimizing the actor: - - .. math:: - y_i = r_i + \lambda Q^'(s_{i+1}, \; \mu^'(s_{i+1} \;|\; \Theta^{\mu'}}\;|\; \Theta^{Q'}) - - On actor optimization, use the actor as the sample policy gradient. - - Returns: - - """ - if len(self.memory) > self.batch_size: - self.warming_up = False - # Perhaps have memory as another item list? Should investigate. - sampled = self.memory.sample(self.batch_size) - - with torch.no_grad(): - r = torch.cat([item.reward.float() for item in sampled]) - s_prime = torch.cat([item.s_prime.float() for item in sampled]) - s = torch.cat([item.s.float() for item in sampled]) - a = torch.cat([item.a.float() for item in sampled]) - # d = torch.cat([item.done.float() for item in sampled]) # Do we need a mask?? - - with torch.no_grad(): - y = r + self.discount * self.t_critic_model((s_prime, self.t_action_model(s_prime))) - - y_hat = self.critic_model((s, a)) - - critic_loss = self.loss_func(y_hat, y) - - if self.training: - # Optimize critic network - self.critic_optimizer.zero_grad() - critic_loss.backward() - self.critic_optimizer.step() - - actor_loss = -self.critic_model((s, self.action_model(s))).mean() - - self.loss = critic_loss.cpu().detach() - - if self.training: - # Optimize actor network - self.opt.zero_grad() - actor_loss.backward() - self.opt.step() - - with torch.no_grad(): - post_info = {'td_error': (y - y_hat).numpy()} - return post_info - - def forward(self, x): - x = super(DDPG, self).forward(x) - return self.action_model(x) - - def target_copy_over(self): - """ Soft target updates the actor and critic models..""" - self.soft_target_copy_over(self.t_action_model, self.action_model, self.tau) - self.soft_target_copy_over(self.t_critic_model, self.critic_model, self.tau) - - def soft_target_copy_over(self, t_m, f_m, tau): - for target_param, local_param in zip(t_m.parameters(), f_m.parameters()): - target_param.data.copy_(tau * local_param.data + (1.0 - tau) * target_param.data) - - def interpret_q(self, items): - with torch.no_grad(): - r = torch.from_numpy(np.array([item.reward for item in items])).float() - s_prime = torch.from_numpy(np.array([item.result_state for item in items])).float() - s = torch.from_numpy(np.array([item.current_state for item in items])).float() - a = torch.from_numpy(np.array([item.actions for item in items])).float() - - return self.critic_model(torch.cat((s, a), 1)) diff --git a/fast_rl/agents/DQN.py b/fast_rl/agents/DQN.py deleted file mode 100644 index c6edd2f..0000000 --- a/fast_rl/agents/DQN.py +++ /dev/null @@ -1,316 +0,0 @@ -from copy import deepcopy -from functools import partial -from typing import Tuple - -import torch -from fastai.basic_train import LearnerCallback, Any, F, OptimWrapper, ifnone -from torch import optim, nn - -from fast_rl.agents.BaseAgent import BaseAgent, ToLong, get_embedded, Flatten, get_conv -from fast_rl.core.MarkovDecisionProcess import MDPDataBunch, MDPDataset, State, Action -from fast_rl.core.agent_core import ExperienceReplay, GreedyEpsilon - - -class BaseDQNCallback(LearnerCallback): - def __init__(self, learn, max_episodes=None): - r"""Handles basic DQN end of step model optimization.""" - super().__init__(learn) - self.n_skipped = 0 - self._persist = max_episodes is not None - self.max_episodes = max_episodes - self.episode = -1 - self.iteration = 0 - # For the callback handler - self._order = 0 - self.previous_item = None - - def on_train_begin(self, n_epochs, **kwargs: Any): - self.max_episodes = n_epochs if not self._persist else self.max_episodes - - def on_epoch_begin(self, epoch, **kwargs: Any): - self.episode = epoch if not self._persist else self.episode + 1 - self.iteration = 0 - - def on_loss_begin(self, **kwargs: Any): - r"""Performs memory updates, exploration updates, and model optimization.""" - if self.learn.model.training: self.learn.model.memory.update(item=self.learn.data.train_ds.x.items[-1]) - self.learn.model.exploration_strategy.update(self.episode, max_episodes=self.max_episodes, - do_exploration=self.learn.model.training) - post_optimize = self.learn.model.optimize() - if self.learn.model.training: self.learn.model.memory.refresh(post_optimize=post_optimize) - self.iteration += 1 - - -class FixedTargetDQNCallback(LearnerCallback): - def __init__(self, learn, copy_over_frequency=3): - """Handles updating the target model in a fixed target DQN. - - Args: - learn: Basic Learner. - copy_over_frequency: Per how many episodes we want to update the target model. - """ - super().__init__(learn) - self._order = 1 - self.iteration = 0 - self.copy_over_frequency = copy_over_frequency - - def on_step_end(self, **kwargs: Any): - self.iteration += 1 - if self.iteration % self.copy_over_frequency == 0 and self.learn.model.training: - self.learn.model.target_copy_over() - - -def get_action_dqn_fully_conn(layers, action: Action, state: State, activation=nn.ReLU, embed=False): - module_layers = [] - for i, size in enumerate(layers): - if i == 0: - if embed: - embedded, out = get_embedded(state.s.shape[1], size, state.n_possible_values, 5) - module_layers += [ToLong(), embedded, Flatten(), nn.Linear(out, size)] - else: - module_layers.append(nn.Linear(state.s.shape[1], size)) - else: - module_layers.append(nn.Linear(layers[i - 1], size)) - module_layers.append(activation()) - - module_layers.append(nn.Linear(layers[-1], action.n_possible_values)) - return nn.Sequential(*module_layers) - - -def get_action_dqn_cnn(layers, action: Action, state: State, activation=nn.ReLU, kernel_size=5, stride=2): - module_layers, out_size = get_conv(state.s.shape, activation(), kernel_size=kernel_size, stride=stride, - n_conv_layers=3, layers=[]) - module_layers += [Flatten()] - layers.append(action.n_possible_values) - for i, layer in enumerate(layers): - module_layers += [nn.Linear(out_size, layer)] if i == 0 else [nn.Linear(layers[i - 1], layer)] - if i != len(layers) - 1: module_layers += [activation()] - - return nn.Sequential(*module_layers) - - -class DQN(BaseAgent): - def __init__(self, data: MDPDataBunch, memory=None, lr=0.01, discount=0.95, grad_clip=5, - max_episodes=None, exploration_strategy=None, use_embeddings=False, layers=None): - """Trains an Agent using the Q Learning method on a neural net. - - Notes: - This is not a true implementation of [1]. A true implementation uses a fixed target network. - - References: - [1] Mnih, Volodymyr, et al. "Playing atari with deep reinforcement learning." - arXiv preprint arXiv:1312.5602 (2013). - - Args: - data: Used for size input / output information. - """ - super().__init__(data) - # TODO add recommend cnn based on s size? - self.name = 'DQN' - self.use_embeddings = use_embeddings - self.batch_size = data.train_ds.bs - self.discount = discount - self.warming_up = True - self.lr = lr - self.gradient_clipping_norm = grad_clip - self.loss_func = F.mse_loss - self.memory = ifnone(memory, ExperienceReplay(10000)) - self.action_model = self.initialize_action_model(ifnone(layers, [24, 24]), data.train_ds) - self.opt = OptimWrapper.create(optim.Adam, lr=self.lr, layer_groups=[self.action_model]) - self.learner_callbacks += [partial(BaseDQNCallback, max_episodes=max_episodes)] + self.memory.callbacks - self.exploration_strategy = ifnone(exploration_strategy, GreedyEpsilon(epsilon_start=1, epsilon_end=0.1, - decay=0.001, - do_exploration=self.training)) - - def init_weights(self, m): - if type(m) == nn.Linear: - torch.nn.init.xavier_uniform_(m.weight) - m.bias.data.fill_(0.01) - - def initialize_action_model(self, layers, data): - if len(data.state.s.shape) == 4 and data.state.s.shape[-1] < 4: - model = get_action_dqn_cnn(deepcopy(layers), data.action, data.state, kernel_size=5, stride=2) - else: model = get_action_dqn_fully_conn(deepcopy(layers), data.action, data.state, embed=self.use_embeddings) - model.apply(self.init_weights) - return model - - def forward(self, x): - x = super(DQN, self).forward(x) - return self.action_model(x) - - def sample_mask(self) -> Tuple[torch.tensor, torch.tensor, torch.tensor, torch.tensor, torch.tensor, torch.tensor]: - self.warming_up = False - # Perhaps have memory as another itemlist? Should investigate. - sampled = self.memory.sample(self.batch_size) - with torch.no_grad(): - r = torch.cat([item.reward.float() for item in sampled]) - s_prime = torch.cat([item.s_prime.float() for item in sampled]) - s = torch.cat([item.s.float() for item in sampled]) - a = torch.cat([item.a.long() for item in sampled]) - d = torch.cat([item.done.float() for item in sampled]) - - masking = torch.sub(1.0, d) - return r, s_prime, s, a, d, masking - - def calc_y_hat(self, s, a): return self.action_model(s).gather(1, a) - - def calc_y(self, s_prime, masking, r, y_hat): - return self.discount * self.action_model(s_prime).max(axis=1)[0].unsqueeze(1) * masking + r.expand_as(y_hat) - - def optimize(self): - r"""Uses ER to optimize the Q-net (without fixed targets). - - Uses the equation: - - .. math:: - Q^{*}(s, a) = \mathbb{E}_{s'∼ \Big\epsilon} \Big[r + \lambda \displaystyle\max_{a'}(Q^{*}(s' , a')) - \;|\; s, a \Big] - - - Returns (dict): Optimization information - - """ - if len(self.memory) > self.batch_size: - r, s_prime, s, a, d, masking = self.sample_mask() - - # Traditional `maze-random-5x5-v0` with have a model output a Nx4 output. - # since r is just Nx1, we spread the reward into the actions. - y_hat = self.calc_y_hat(s, a) - y = self.calc_y(s_prime, masking, r, y_hat) - - loss = self.loss_func(y, y_hat) - - if self.training: - self.opt.zero_grad() - loss.backward() - torch.nn.utils.clip_grad_norm_(self.action_model.parameters(), self.gradient_clipping_norm) - for param in self.action_model.parameters(): - param.grad.data.clamp_(-1, 1) - self.opt.step() - - with torch.no_grad(): - self.loss = loss - post_info = {'td_error': (y - y_hat).numpy()} - return post_info - - def interpret_q(self, items): - with torch.no_grad(): - s = torch.cat([item.s.float() for item in items]) - a = torch.cat([item.a.long() for item in items]) - return self.action_model(s).gather(1, a) - - -class FixedTargetDQN(DQN): - def __init__(self, data: MDPDataBunch, memory=None, tau=0.01, copy_over_frequency=3, **kwargs): - r"""Trains an Agent using the Q Learning method on a 2 neural nets. - - Notes: - Unlike the base DQN, this is a true reflection of ref [1]. We use 2 models instead of one to allow for - training the action model more stably. - - Args: - data: Used for size input / output information. - - References: - [1] Mnih, Volodymyr, et al. "Playing atari with deep reinforcement learning." - arXiv preprint arXiv:1312.5602 (2013). - """ - super().__init__(data, memory, **kwargs) - self.name = 'DQN Fixed Targeting' - self.tau = tau - self.target_net = deepcopy(self.action_model) - self.learner_callbacks += [partial(FixedTargetDQNCallback, copy_over_frequency=copy_over_frequency)] - - def target_copy_over(self): - r""" Updates the target network from calls in the FixedTargetDQNCallback callback.""" - # self.target_net.load_state_dict(self.action_model.state_dict()) - for target_param, local_param in zip(self.target_net.parameters(), self.action_model.parameters()): - target_param.data.copy_(self.tau * local_param.data + (1.0 - self.tau) * target_param.data) - - def calc_y(self, s_prime, masking, r, y_hat): - r""" - Uses the equation: - - .. math:: - Q^{*}(s, a) = \mathbb{E}_{s'∼ \Big\epsilon} \Big[r + \lambda \displaystyle\max_{a'}(Q^{*}(s' , a')) - \;|\; s, a \Big] - - """ - return self.discount * self.target_net(s_prime).max(axis=1)[0].unsqueeze(1) * masking + r.expand_as(y_hat) - - -class DoubleDQN(FixedTargetDQN): - def __init__(self, data: MDPDataBunch, memory=None, copy_over_frequency=3, **kwargs): - r""" - Double DQN training. - - References: - [1] Van Hasselt, Hado, Arthur Guez, and David Silver. "Deep reinforcement learning with double q-learning." - Thirtieth AAAI conference on artificial intelligence. 2016. - - Args: - data: Used for size input / output information. - """ - super().__init__(data=data, memory=memory, copy_over_frequency=copy_over_frequency, **kwargs) - self.name = 'DDQN' - - def calc_y(self, s_prime, masking, r, y_hat): - return self.discount * self.target_net(s_prime).gather(1, self.action_model(s_prime).argmax(axis=1).unsqueeze( - 1)) * masking + r.expand_as(y_hat) - - -class DuelingDQNModule(nn.Module): - def __init__(self, action, stream_input_size): - super().__init__() - - self.val = nn.Linear(stream_input_size, 1) - self.adv = nn.Linear(stream_input_size, action.n_possible_values) - - def forward(self, x): - r"""Splits the base neural net output into 2 streams to evaluate the advantage and values of the s space and - corresponding actions. - - .. math:: - Q(s,a;\; \Theta, \\alpha, \\beta) = V(s;\; \Theta, \\beta) + A(s, a;\; \Theta, \\alpha) - \\frac{1}{|A|} - \\Big\\sum_{a'} A(s, a';\; \Theta, \\alpha) - - Args: - x: - - Returns: - """ - val, adv = self.val(x), self.adv(x) - x = val.expand_as(adv) + (adv - adv.mean()).squeeze(0) - return x - - -class DuelingDQN(FixedTargetDQN): - def __init__(self, data: MDPDataBunch, memory=None, **kwargs): - r"""Replaces the basic action model with a DuelingDQNModule which splits the basic model into 2 streams. - - References: - [1] Wang, Ziyu, et al. "Dueling network architectures for deep reinforcement learning." - arXiv preprint arXiv:1511.06581 (2015). - - Args: - data: - """ - super().__init__(data, memory, **kwargs) - self.name = 'Dueling DQN' - - def initialize_action_model(self, layers, data): - base = super().initialize_action_model(layers, data)[:-2] - dueling_head = DuelingDQNModule(action=data.action, stream_input_size=base[-1].out_features) - return nn.Sequential(base, dueling_head) - - -class DoubleDuelingDQN(DoubleDQN, DuelingDQN): - def __init__(self, data: MDPDataBunch, memory=None, **kwargs): - r""" - Combines both Dueling DQN and DDQN. - - Args: - data: Used for size input / output information. - """ - super().__init__(data, memory, **kwargs) - self.name = 'DDDQN' diff --git a/fast_rl/agents/BaseAgent.py b/fast_rl/agents/agents_base.py similarity index 55% rename from fast_rl/agents/BaseAgent.py rename to fast_rl/agents/agents_base.py index f577e7e..d995485 100644 --- a/fast_rl/agents/BaseAgent.py +++ b/fast_rl/agents/agents_base.py @@ -1,57 +1,52 @@ from math import floor -from typing import Collection -import numpy as np -import torch from fastai.basic_train import LearnerCallback -from fastai.layers import bn_drop_lin +from fastai.torch_core import * from gym.spaces import Discrete, Box -from torch import nn -from fast_rl.core.MarkovDecisionProcess import MDPDataBunch from fast_rl.core.agent_core import ExplorationStrategy - - -class BaseAgent(nn.Module): - """ - One of the basic differences between this model type and typical openai models is that this will have its - own learner_callbacks. This is due to the often strange and beautiful methods created for training RL agents. - - """ - def __init__(self, data: MDPDataBunch): - super().__init__() - self.data = data - self.name = '' - # Some definition of loss needs to be implemented - self.loss = None - self.out = None - self.opt = None - self.warming_up = False - self.learner_callbacks = [] # type: Collection[LearnerCallback] - # Root model that will be accessed for action decisions - self.action_model = None # type: nn.Module - self.exploration_strategy = ExplorationStrategy(self.training) - - def forward(self, x): - if isinstance(x, torch.Tensor): return x.float() - return x - - def pick_action(self, x): - x = self(x) - self.out = x - - with torch.no_grad(): - if len(x.shape) > 2: raise ValueError('The agent is outputting actions with more than 1 dimension...') - - if isinstance(self.data.train_ds.env.action_space, Discrete): action = x.argmax().numpy().item() - elif isinstance(self.data.train_ds.env.action_space, Box) and len(x.shape) != 1: action = x.squeeze(0).numpy() - - action = self.exploration_strategy.perturb(action, self.data.train_ds.env.action_space) - - return action - - def interpret_q(self, items): - raise NotImplementedError +from fast_rl.core.data_block import MDPDataBunch + + +# class BaseAgent(nn.Module): +# r""" +# One of the basic differences between this model type and typical Openai models is that this will have its +# own learner_callbacks. This is due to the often strange and beautiful methods created for training RL agents. +# """ +# def __init__(self, data: MDPDataBunch): +# super().__init__() +# self.data = data +# self.name = '' +# # Some definition of loss needs to be implemented +# self.loss = None +# self.out = None +# self.opt = None +# self.warming_up = False +# self.learner_callbacks = [] # type: Collection[LearnerCallback] +# # Root model that will be accessed for action decisions +# self.action_model = None # type: nn.Module +# self.exploration_strategy = ExplorationStrategy(self.training) +# +# def forward(self, x): +# if isinstance(x, torch.Tensor): return x.float() +# return x +# +# def pick_action(self, x): +# x = self(x) +# self.out = x +# +# with torch.no_grad(): +# if len(x.shape) > 2: raise ValueError('The agent is outputting actions with more than 1 dimension...') +# +# if isinstance(self.data.train_ds.env.action_space, Discrete): action = x.argmax().cpu().numpy().item() +# elif isinstance(self.data.train_ds.env.action_space, Box) and len(x.shape) != 1: action = x.squeeze(0).cpu().numpy() +# +# action = self.exploration_strategy.perturb(action, self.data.train_ds.env.action_space) +# +# return action +# +# def interpret_q(self, items): +# raise NotImplementedError def get_embedded(input_size, output_size, n_embeddings, n_extra_dims): diff --git a/fast_rl/agents/ddpg.py b/fast_rl/agents/ddpg.py new file mode 100644 index 0000000..de6f619 --- /dev/null +++ b/fast_rl/agents/ddpg.py @@ -0,0 +1,88 @@ +import numpy as np +import torch +from fastai.basic_train import LearnerCallback, Any, ifnone, listify, List +from fastai.tabular.data import emb_sz_rule + +from fast_rl.agents.ddpg_models import DDPGModule +from fast_rl.core.agent_core import ExperienceReplay, ExplorationStrategy, Experience +from fast_rl.core.basic_train import AgentLearner +from fast_rl.core.data_block import MDPDataBunch, MDPStep, FEED_TYPE_STATE, FEED_TYPE_IMAGE + + +class DDPGLearner(AgentLearner): + def __init__(self, data: MDPDataBunch, model, memory, exploration_method, trainers, + **kwargs): + self.memory: Experience = memory + self.exploration_method: ExplorationStrategy = exploration_method + super().__init__(data=data, model=model, **kwargs) + self.ddpg_trainers = listify(trainers) + for t in self.ddpg_trainers: self.callbacks.append(t(self)) + + def predict(self, element, **kwargs): + training = self.model.training + if element.shape[0] == 1: self.model.eval() + pred = self.model(element) + if training: self.model.train() + return self.exploration_method.perturb(pred.detach().cpu().numpy(), self.data.action.action_space) + + def interpret_q(self, item): + with torch.no_grad(): + return self.model.interpret_q(item).cpu().numpy().item() + + + +class BaseDDPGTrainer(LearnerCallback): + def __init__(self, learn): + super().__init__(learn) + self.max_episodes = 0 + self.episode = 0 + self.iteration = 0 + self.copy_over_frequency = 3 + + @property + def learn(self) -> DDPGLearner: + return self._learn() + + def on_train_begin(self, n_epochs, **kwargs: Any): + self.max_episodes = n_epochs + + def on_epoch_begin(self, epoch, **kwargs: Any): + self.episode = epoch + self.iteration = 0 + + def on_loss_begin(self, **kwargs: Any): + """Performs tree updates, exploration updates, and model optimization.""" + if self.learn.model.training: self.learn.memory.update(item=self.learn.data.x.items[-1], device=self.learn.data.device) + self.learn.exploration_method.update(self.episode, max_episodes=self.max_episodes, explore=self.learn.model.training) + if not self.learn.warming_up: + samples: List[MDPStep] = self.memory.sample(self.learn.data.bs) + post_optimize = self.learn.model.optimize(samples) + if self.learn.model.training: + self.learn.memory.refresh(post_optimize=post_optimize) + self.learn.model.target_copy_over() + self.iteration += 1 + + +def create_ddpg_model(data: MDPDataBunch, base_arch: DDPGModule, layers=None, ignore_embed=False, channels=None, + opt=torch.optim.RMSprop, loss_func=None, **kwargs): + bs, state, action = data.bs, data.state, data.action + nc, w, h, n_conv_blocks = -1, -1, -1, [] if state.mode == FEED_TYPE_STATE else ifnone(channels, [3, 3, 1]) + if state.mode == FEED_TYPE_IMAGE: nc, w, h = state.s.shape[3], state.s.shape[2], state.s.shape[1] + _layers = ifnone(layers, [400, 200] if len(n_conv_blocks) == 0 else [200, 200]) + if ignore_embed or np.any(state.n_possible_values == np.inf) or state.mode == FEED_TYPE_IMAGE: emb_szs = [] + else: emb_szs = [(d+1, int(emb_sz_rule(d))) for d in state.n_possible_values.reshape(-1, )] + ao = int(action.taken_action.shape[1]) + model = base_arch(ni=state.s.shape[1], ao=ao, layers=_layers, emb_szs=emb_szs, n_conv_blocks=n_conv_blocks, + nc=nc, w=w, h=h, opt=opt, loss_func=loss_func, **kwargs) + return model + + +ddpg_config = { + DDPGModule: BaseDDPGTrainer +} + + +def ddpg_learner(data: MDPDataBunch, model, memory: ExperienceReplay, exploration_method: ExplorationStrategy, + trainers=None, **kwargs): + trainers = ifnone(trainers, ddpg_config[model.__class__]) + return DDPGLearner(data, model, memory, exploration_method, trainers, **kwargs) diff --git a/fast_rl/agents/ddpg_models.py b/fast_rl/agents/ddpg_models.py new file mode 100644 index 0000000..77945bf --- /dev/null +++ b/fast_rl/agents/ddpg_models.py @@ -0,0 +1,239 @@ +from math import ceil + +from fastai.callback import OptimWrapper +from fastai.tabular import TabularModel +from fastai.vision import cnn_learner +from fastai.torch_core import * +from torch.nn import MSELoss +from torch.optim import Adam + +from fast_rl.agents.agents_base import Flatten +from fast_rl.agents.dqn_models import conv_bn_lrelu, ks_stride, FakeBatchNorm + + +class CriticTabularEmbedWrapper(Module): + def __init__(self, tabular_model: Module, exclude_cat): + super().__init__() + self.tabular_model = tabular_model + self.exclude_cat = exclude_cat + + def forward(self, args): + if not self.exclude_cat: return self.tabular_model(*args) + else: return self.tabular_model(0, torch.cat(args, axis=1)) + + +class ActorTabularEmbedWrapper(Module): + def __init__(self, tabular_model: Module): + super().__init__() + self.tabular_model = tabular_model + + def forward(self, xi: Tensor, *args): + return self.tabular_model(xi, xi) + + +class StateActionSplitter(Module): + def forward(self, s_a_tuple): + return s_a_tuple[0], s_a_tuple[1] + + +class StateActionPassThrough(nn.Module): + def __init__(self, layers): + super().__init__() + self.layers = layers + + def forward(self, state_action): + return (self.layers(state_action[0]), state_action[1]) + + +class ChannelTranspose(Module): + def forward(self, xi: Tensor): + return xi.transpose(3, 1).transpose(3, 2) + + +class CriticModule(nn.Sequential): + def __init__(self, ni: int, ao: int, layers: Collection[int], batch_norm=False, + n_conv_blocks: Collection[int] = 0, nc=3, emb_szs: ListSizes = None, + w=-1, h=-1, ks=None, stride=None, conv_kern_proportion=0.1, stride_proportion=0.1, pad=False): + super().__init__() + self.switched, self.batch_norm = False, batch_norm + self.ks, self.stride = ([], []) if len(n_conv_blocks) == 0 else ks_stride(ks, stride, w, h, n_conv_blocks, conv_kern_proportion, stride_proportion) + self.action_model = nn.Sequential() + _layers = [conv_bn_lrelu(nc, self.nf, ks=ks, stride=stride, pad=pad, bn=self.batch_norm) for self.nf, ks, stride in zip(n_conv_blocks, self.ks, self.stride)] + if _layers: ni = self.setup_conv_block(_layers=_layers, ni=ni, nc=nc, w=w, h=h) + self.setup_linear_block(_layers=_layers, ni=ni, nc=nc, w=w, h=h, emb_szs=emb_szs, layers=layers, ao=ao) + self.init_weights(self) + + def setup_conv_block(self, _layers, ni, nc, w, h): + self.add_module('conv_block', StateActionPassThrough(nn.Sequential(*(self.fix_switched_channels(ni, nc, _layers) + [Flatten()])))) + return int(self(torch.zeros((2, 1, w, h, nc) if self.switched else (2, 1, nc, w, h)))[0].view(-1, ).shape[0]) + + def setup_linear_block(self, _layers, ni, nc, w, h, emb_szs, layers, ao): + tabular_model = TabularModel(emb_szs=emb_szs, n_cont=ni+ao if not emb_szs else ao, layers=layers, out_sz=1, + use_bn=self.batch_norm) + if not emb_szs: tabular_model.embeds = None + if not self.batch_norm: tabular_model.bn_cont = FakeBatchNorm() + self.add_module('lin_block', CriticTabularEmbedWrapper(tabular_model, exclude_cat=not emb_szs)) + + def fix_switched_channels(self, current_channels, expected_channels, layers: list): + if current_channels == expected_channels: + return layers + else: + self.switched = True + return [ChannelTranspose()] + layers + + def init_weights(self, m): + if type(m) == nn.Linear: + torch.nn.init.xavier_uniform_(m.weight) + m.bias.data.fill_(0.01) + + +class ActorModule(nn.Sequential): + def __init__(self, ni: int, ao: int, layers: Collection[int],batch_norm = False, + n_conv_blocks: Collection[int] = 0, nc=3, emb_szs: ListSizes = None, + w=-1, h=-1, ks=None, stride=None, conv_kern_proportion=0.1, stride_proportion=0.1, pad=False): + super().__init__() + self.switched, self.batch_norm = False, batch_norm + self.ks, self.stride = ([], []) if len(n_conv_blocks) == 0 else ks_stride(ks, stride, w, h, n_conv_blocks, conv_kern_proportion, stride_proportion) + self.action_model = nn.Sequential() + _layers = [conv_bn_lrelu(nc, self.nf, ks=ks, stride=stride, pad=pad, bn=self.batch_norm) for self.nf, ks, stride in zip(n_conv_blocks, self.ks, self.stride)] + if _layers: ni = self.setup_conv_block(_layers=_layers, ni=ni, nc=nc, w=w, h=h) + self.setup_linear_block(_layers=_layers, ni=ni, nc=nc, w=w, h=h, emb_szs=emb_szs, layers=layers, ao=ao) + self.init_weights(self) + + def setup_conv_block(self, _layers, ni, nc, w, h): + self.add_module('conv_block', nn.Sequential(*(self.fix_switched_channels(ni, nc, _layers) + [Flatten()]))) + return int(self(torch.zeros((1, w, h, nc) if self.switched else (1, nc, w, h))).view(-1, ).shape[0]) + + def setup_linear_block(self, _layers, ni, nc, w, h, emb_szs, layers, ao): + tabular_model = TabularModel(emb_szs=emb_szs, n_cont=ni if not emb_szs else 0, layers=layers, out_sz=ao, use_bn=self.batch_norm) + + if not emb_szs: tabular_model.embeds = None + if not self.batch_norm: tabular_model.bn_cont = FakeBatchNorm() + self.add_module('lin_block', ActorTabularEmbedWrapper(tabular_model)) + + def fix_switched_channels(self, current_channels, expected_channels, layers: list): + if current_channels == expected_channels: + return layers + else: + self.switched = True + return [ChannelTranspose()] + layers + + def init_weights(self, m): + if type(m) == nn.Linear: + torch.nn.init.xavier_uniform_(m.weight) + m.bias.data.fill_(0.01) + +class DDPGModule(Module): + def __init__(self, ni: int, ao: int, layers: Collection[int], discount: float = 0.99, + n_conv_blocks: Collection[int] = 0, nc=3, opt=None, emb_szs: ListSizes = None, loss_func=None, + w=-1, h=-1, ks=None, stride=None, grad_clip=5, tau=1e-3, lr=1e-3, actor_lr=1e-4, + batch_norm=False, **kwargs): + r""" + Implementation of a discrete control algorithm using an actor/critic architecture. + + Notes: + Uses 4 networks, 2 actors, 2 critics. + All models use batch norm for feature invariance. + NNCritic simply predicts Q while the Actor proposes the actions to take given a s s. + + References: + [1] Lillicrap, Timothy P., et al. "Continuous control with deep reinforcement learning." + arXiv preprint arXiv:1509.02971 (2015). + + Args: + data: Primary data object to use. + memory: How big the tree buffer will be for offline training. + tau: Defines how "soft/hard" we will copy the target networks over to the primary networks. + discount: Determines the amount of discounting the existing Q reward. + lr: Rate that the opt will learn parameter gradients. + """ + super().__init__() + self.name = 'DDPG' + self.lr = lr + self.discount = discount + self.tau = tau + self.loss_func = None + self.loss = None + self.batch_norm = batch_norm + + self.action_model = ActorModule(ni=ni, ao=ao, layers=layers, nc=nc, emb_szs=emb_szs,batch_norm = batch_norm, + w=w, h=h, ks=ks, n_conv_blocks=n_conv_blocks, stride=stride) + self.critic_model = CriticModule(ni=ni, ao=ao, layers=layers, nc=nc, emb_szs=emb_szs, batch_norm = batch_norm, + w=w, h=h, ks=ks, n_conv_blocks=n_conv_blocks, stride=stride) + + self.opt = OptimWrapper.create(ifnone(opt, Adam), lr=actor_lr, layer_groups=[self.action_model]) + self.critic_optimizer = OptimWrapper.create(ifnone(opt, Adam), lr=lr, layer_groups=[self.critic_model]) + + self.t_action_model = deepcopy(self.action_model) + self.t_critic_model = deepcopy(self.critic_model) + + self.target_copy_over() + self.tau = tau + + def optimize(self, sampled): + r""" + Performs separate updates to the actor and critic models. + + Get the predicted yi for optimizing the actor: + + .. math:: + y_i = r_i + \lambda Q^'(s_{i+1}, \; \mu^'(s_{i+1} \;|\; \Theta^{\mu'}}\;|\; \Theta^{Q'}) + + On actor optimization, use the actor as the sample policy gradient. + + Returns: + + """ + with torch.no_grad(): + r = torch.cat([item.reward.float() for item in sampled])#.to(self.data.device) + s_prime = torch.cat([item.s_prime for item in sampled])#.to(self.data.device) + s = torch.cat([item.s for item in sampled])#.to(self.data.device) + a = torch.cat([item.a.float() for item in sampled])#.to(self.data.device) + # d = torch.cat([item.done.float() for item in sampled]) # Do we need a mask?? + + with torch.no_grad(): + y = r + self.discount * self.t_critic_model((s_prime, self.t_action_model(s_prime))) + + y_hat = self.critic_model((s, a)) + + critic_loss = self.loss_func(y_hat, y) + + if self.training: + # Optimize critic network + self.critic_optimizer.zero_grad() + critic_loss.backward() + self.critic_optimizer.step() + + actor_loss = -self.critic_model((s, self.action_model(s))).mean() + + self.loss = critic_loss.cpu().detach() + + if self.training: + # Optimize actor network + self.opt.zero_grad() + actor_loss.backward() + self.opt.step() + + with torch.no_grad(): + post_info = {'td_error': (y - y_hat).cpu().numpy()} + return post_info + + def forward(self, xi): + training = self.training + if xi.shape[0] == 1: self.eval() + pred = self.action_model(xi) + if training: self.train() + return pred + + def target_copy_over(self): + """ Soft target updates the actor and critic models..""" + self.soft_target_copy_over(self.t_action_model, self.action_model, self.tau) + self.soft_target_copy_over(self.t_critic_model, self.critic_model, self.tau) + + def soft_target_copy_over(self, t_m, f_m, tau): + for target_param, local_param in zip(t_m.parameters(), f_m.parameters()): + target_param.data.copy_(tau * local_param.data + (1.0 - tau) * target_param.data) + + def interpret_q(self, item): + with torch.no_grad(): + return self.critic_model(torch.cat((item.s, item.a), 1)) \ No newline at end of file diff --git a/fast_rl/agents/dqn.py b/fast_rl/agents/dqn.py new file mode 100644 index 0000000..3769897 --- /dev/null +++ b/fast_rl/agents/dqn.py @@ -0,0 +1,112 @@ +from fastai.basic_train import LearnerCallback +from fastai.tabular.data import emb_sz_rule + +from fast_rl.agents.dqn_models import * +from fast_rl.core.agent_core import ExperienceReplay, ExplorationStrategy, Experience +from fast_rl.core.basic_train import AgentLearner +from fast_rl.core.data_block import MDPDataBunch, FEED_TYPE_STATE, FEED_TYPE_IMAGE, MDPStep + + +class DQNLearner(AgentLearner): + def __init__(self, data: MDPDataBunch, model, memory, exploration_method, trainers, + **learn_kwargs): + self.memory: Experience = memory + self.exploration_method: ExplorationStrategy = exploration_method + super().__init__(data=data, model=model, **learn_kwargs) + self.dqn_trainers = listify(trainers) + for t in self.dqn_trainers: self.callbacks.append(t(self)) + + def predict(self, element, **kwargs): + training = self.model.training + if element.shape[0] == 1: self.model.eval() + pred = self.model(element) + if training: self.model.train() + return self.exploration_method.perturb(torch.argmax(pred, axis=1), self.data.action.action_space) + + def interpret_q(self, item): + with torch.no_grad(): + return torch.sum(self.model(item.s)).cpu().numpy().item() + + +class FixedTargetDQNTrainer(LearnerCallback): + def __init__(self, learn, copy_over_frequency=3): + r"""Handles updating the target model in a fixed target DQN. + + Args: + learn: Basic Learner. + copy_over_frequency: For every N iterations we want to update the target model. + """ + super().__init__(learn) + self._order = 1 + self.iteration = 0 + self.copy_over_frequency = copy_over_frequency + + def on_step_end(self, **kwargs: Any): + self.iteration += 1 + if self.iteration % self.copy_over_frequency == 0 and self.learn.model.training: + self.learn.model.target_copy_over() + + +class BaseDQNTrainer(LearnerCallback): + def __init__(self, learn: DQNLearner, max_episodes=None): + r"""Handles basic DQN end of step model optimization.""" + super().__init__(learn) + self.n_skipped = 0 + self._persist = max_episodes is not None + self.max_episodes = max_episodes + self.episode = -1 + self.iteration = 0 + # For the callback handler + self._order = 0 + self.previous_item = None + + @property + def learn(self) -> DQNLearner: + return self._learn() + + def on_train_begin(self, n_epochs, **kwargs: Any): + self.max_episodes = n_epochs if not self._persist else self.max_episodes + + def on_epoch_begin(self, epoch, **kwargs: Any): + self.episode = epoch if not self._persist else self.episode + 1 + self.iteration = 0 + + def on_loss_begin(self, **kwargs: Any): + r"""Performs tree updates, exploration updates, and model optimization.""" + if self.learn.model.training: self.learn.memory.update(item=self.learn.data.x.items[-1], device=self.learn.data.device) + self.learn.exploration_method.update(self.episode, max_episodes=self.max_episodes, explore=self.learn.model.training) + if not self.learn.warming_up: + samples: List[MDPStep] = self.memory.sample(self.learn.data.bs) + post_optimize = self.learn.model.optimize(samples) + if self.learn.model.training: self.learn.memory.refresh(post_optimize=post_optimize) + self.iteration += 1 + + +def create_dqn_model(data: MDPDataBunch, base_arch: DQNModule, layers=None, ignore_embed=False, channels=None, + opt=torch.optim.RMSprop, loss_func=None, lr=0.001, **kwargs): + bs, state, action = data.bs, data.state, data.action + nc, w, h, n_conv_blocks = -1, -1, -1, [] if state.mode == FEED_TYPE_STATE else ifnone(channels, [3, 3, 1]) + if state.mode == FEED_TYPE_IMAGE: nc, w, h = state.s.shape[3], state.s.shape[2], state.s.shape[1] + _layers = ifnone(layers, [64, 64]) + if ignore_embed or np.any(state.n_possible_values == np.inf) or state.mode == FEED_TYPE_IMAGE: emb_szs = [] + else: emb_szs = [(d+1, int(emb_sz_rule(d))) for d in state.n_possible_values.reshape(-1, )] + ao = int(action.n_possible_values[0]) + model = base_arch(ni=state.s.shape[1], ao=ao, layers=_layers, emb_szs=emb_szs, n_conv_blocks=n_conv_blocks, + nc=nc, w=w, h=h, opt=opt, loss_func=loss_func, lr=lr, **kwargs) + return model + + +dqn_config = { + DQNModule: [BaseDQNTrainer], + DoubleDQNModule: [BaseDQNTrainer, FixedTargetDQNTrainer], + DuelingDQNModule: [BaseDQNTrainer, FixedTargetDQNTrainer], + DoubleDuelingModule: [BaseDQNTrainer, FixedTargetDQNTrainer], + FixedTargetDQNModule: [BaseDQNTrainer, FixedTargetDQNTrainer] +} + + +def dqn_learner(data: MDPDataBunch, model: DQNModule, memory: ExperienceReplay, exploration_method: ExplorationStrategy, + trainers=None, copy_over_frequency=300, **kwargs): + trainers = ifnone(trainers, [c if c != FixedTargetDQNTrainer else partial(c, copy_over_frequency=copy_over_frequency) + for c in dqn_config[model.__class__]]) + return DQNLearner(data, model, memory, exploration_method, trainers, **kwargs) diff --git a/fast_rl/agents/dqn_models.py b/fast_rl/agents/dqn_models.py new file mode 100644 index 0000000..b0f9dcb --- /dev/null +++ b/fast_rl/agents/dqn_models.py @@ -0,0 +1,246 @@ +from math import ceil + +from fastai.layers import Flatten +from fastai.tabular import TabularModel, OptimWrapper +from fastai.torch_core import * + + +def init_cnn(mod): + if getattr(mod, 'bias', None) is not None: nn.init.constant_(mod.bias, 0) + if isinstance(mod, (nn.Conv2d, nn.Linear)): nn.init.kaiming_normal_(mod.weight) + for sub_mod in mod.children(): init_cnn(sub_mod) + + +def ks_stride(ks, stride, w, h, n_blocks, kern_proportion=.1, stride_proportion=0.3): + kernels, strides, max_dim = [], [], max((w, h)) + for i in range(len(n_blocks)): + kernels.append(max_dim * kern_proportion) + strides.append(kernels[-1] * stride_proportion) + max_dim = (max_dim - kernels[-1]) / strides[-1] + assert max_dim > 1 + + return ifnone(ks, map(ceil, kernels)), ifnone(stride, map(ceil, strides)) + + +class FakeBatchNorm(Module): + r""" If we want all the batch norm layers gone, then we will replace the tabular batch norm with this. """ + def forward(self, xi: Tensor, *args): + return xi + + +def conv_bn_lrelu(ni: int, nf: int, ks: int = 3, stride: int = 1, pad=True, bn=True) -> nn.Sequential: + r""" Create a sequence Conv2d->BatchNorm2d->LeakyReLu layer. (from darknet.py) """ + return nn.Sequential( + nn.Conv2d(ni, nf, kernel_size=ks, bias=False, stride=stride, padding=(ks // 2) if pad else 0), + nn.BatchNorm2d(nf) if bn else FakeBatchNorm(), + nn.LeakyReLU(negative_slope=0.1, inplace=True)) + + +class ChannelTranspose(Module): + def forward(self, xi: Tensor): + return xi.transpose(3, 1).transpose(3, 2) + + +class TabularEmbedWrapper(Module): + def __init__(self, tabular_model: Module): + super().__init__() + self.tabular_model = tabular_model + + def forward(self, xi: Tensor, *args): + return self.tabular_model(xi, xi) + + +class DQNModule(Module): + + def __init__(self, ni: int, ao: int, layers: Collection[int], discount: float = 0.99, lr=0.001, + n_conv_blocks: Collection[int] = 0, nc=3, opt=None, emb_szs: ListSizes = None, loss_func=None, + w=-1, h=-1, ks: Union[None, list]=None, stride: Union[None, list]=None, grad_clip=5, + conv_kern_proportion=0.1, stride_proportion=0.1, pad=False, batch_norm=False): + r""" + Basic DQN Module. + + Args: + ni: Number of inputs. Expecting a flat state `[1 x ni]` + ao: Number of actions to output. + layers: Number of layers where is determined per element. + n_conv_blocks: If `n_conv_blocks` is not 0, then convolutional blocks will be added + to the head on top of existing linear layers. + nc: Number of channels that will be expected by the convolutional blocks. + """ + super().__init__() + self.name = 'DQN' + self.loss = None + self.loss_func = loss_func + self.discount = discount + self.gradient_clipping_norm = grad_clip + self.lr = lr + self.batch_norm = batch_norm + self.switched = False + self.ks, self.stride = ([], []) if len(n_conv_blocks) == 0 else ks_stride(ks, stride, w, h, n_conv_blocks, conv_kern_proportion, stride_proportion) + self.action_model = nn.Sequential() + _layers = [conv_bn_lrelu(nc, self.nf, ks=ks, stride=stride, pad=pad, bn=self.batch_norm) for self.nf, ks, stride in zip(n_conv_blocks, self.ks, self.stride)] + + if _layers: ni = self.setup_conv_block(_layers=_layers, ni=ni, nc=nc, w=w, h=h) + self.setup_linear_block(_layers=_layers, ni=ni, nc=nc, w=w, h=h, emb_szs=emb_szs, layers=layers, ao=ao) + self.init_weights(self.action_model) + self.opt = OptimWrapper.create(ifnone(optim.Adam, opt), lr=self.lr, layer_groups=[self.action_model]) + + def setup_conv_block(self, _layers, ni, nc, w, h): + self.action_model.add_module('conv_block', nn.Sequential(*(self.fix_switched_channels(ni, nc, _layers) + [Flatten()]))) + training = self.action_model.training + self.action_model.eval() + ni = int(self.action_model(torch.zeros((1, w, h, nc) if self.switched else (1, nc, w, h))).view(-1, ).shape[0]) + self.action_model.train(training) + return ni + + def setup_linear_block(self, _layers, ni, nc, w, h, emb_szs, layers, ao): + tabular_model = TabularModel(emb_szs=emb_szs, n_cont=ni if not emb_szs else 0, layers=layers, out_sz=ao, use_bn=self.batch_norm) + if not emb_szs: tabular_model.embeds = None + if not self.batch_norm: tabular_model.bn_cont = FakeBatchNorm() + self.action_model.add_module('lin_block', TabularEmbedWrapper(tabular_model)) + + def fix_switched_channels(self, current_channels, expected_channels, layers: list): + if current_channels == expected_channels: + return layers + else: + self.switched = True + return [ChannelTranspose()] + layers + + def forward(self, xi: Tensor): + training = self.training + if xi.shape[0] == 1: self.eval() + pred = self.action_model(xi) + if training: self.train() + return pred + + def init_weights(self, m): + if type(m) == nn.Linear: + torch.nn.init.xavier_uniform_(m.weight) + m.bias.data.fill_(0.01) + + def sample_mask(self, d): + return torch.sub(1.0, d) + + def optimize(self, sampled): + r"""Uses ER to optimize the Q-net (without fixed targets). + + Uses the equation: + + .. math:: + Q^{*}(s, a) = \mathbb{E}_{s'∼ \Big\epsilon} \Big[r + \lambda \displaystyle\max_{a'}(Q^{*}(s' , a')) + \;|\; s, a \Big] + + + Returns (dict): Optimization information + + """ + with torch.no_grad(): + r = torch.cat([item.reward.float() for item in sampled])#.to(self.data.device) + s_prime = torch.cat([item.s_prime for item in sampled])#.to(self.data.device) + s = torch.cat([item.s for item in sampled])#.to(self.data.device) + a = torch.cat([item.a.long() for item in sampled])#.to(self.data.device) + d = torch.cat([item.done.float() for item in sampled])#.to(self.data.device) + masking = self.sample_mask(d) + + y_hat = self.y_hat(s, a) + y = self.y(s_prime, masking, r, y_hat) + + loss = self.loss_func(y, y_hat) + + if self.training: + self.opt.zero_grad() + loss.backward() + torch.nn.utils.clip_grad_norm_(self.action_model.parameters(), self.gradient_clipping_norm) + for param in self.action_model.parameters(): + if param.grad is not None: param.grad.data.clamp_(-1, 1) + self.opt.step() + + with torch.no_grad(): + self.loss = loss + post_info = {'td_error': to_detach(y - y_hat).cpu().numpy()} + return post_info + + def y_hat(self, s, a): + return self.action_model(s).gather(1, a) + + def y(self, s_prime, masking, r, y_hat): + return self.discount * self.action_model(s_prime).max(1)[0].unsqueeze(1) * masking + r.expand_as(y_hat) + + +class FixedTargetDQNModule(DQNModule): + def __init__(self, ni: int, ao: int, layers: Collection[int], tau=1, **kwargs): + super().__init__(ni, ao, layers, **kwargs) + self.name = 'Fixed Target DQN' + self.tau = tau + self.target_model = copy(self.action_model) + + def target_copy_over(self): + r""" Updates the target network from calls in the FixedTargetDQNTrainer callback.""" + # self.target_net.load_state_dict(self.action_model.state_dict()) + for target_param, local_param in zip(self.target_model.parameters(), self.action_model.parameters()): + target_param.data.copy_(self.tau * local_param.data + (1.0 - self.tau) * target_param.data) + + def y(self, s_prime, masking, r, y_hat): + r""" + Uses the equation: + + .. math:: + + Q^{*}(s, a) = \mathbb{E}_{s'∼ \Big\epsilon} \Big[r + \lambda \displaystyle\max_{a'}(Q^{*}(s' , a')) + \;|\; s, a \Big] + + """ + return self.discount * self.target_model(s_prime).max(1)[0].unsqueeze(1) * masking + r.expand_as(y_hat) + + +class DoubleDQNModule(FixedTargetDQNModule): + def __init__(self, ni: int, ao: int, layers: Collection[int], **kwargs): + super().__init__(ni, ao, layers, **kwargs) + self.name = 'DDQN' + + def calc_y(self, s_prime, masking, r, y_hat): + return self.discount * self.target_model(s_prime).gather(1, self.action_model(s_prime).argmax(1).unsqueeze( + 1)) * masking + r.expand_as(y_hat) + + +class DuelingBlock(nn.Module): + def __init__(self, ao, stream_input_size): + super().__init__() + + self.val = nn.Linear(stream_input_size, 1) + self.adv = nn.Linear(stream_input_size, ao) + + def forward(self, xi): + r"""Splits the base neural net output into 2 streams to evaluate the advantage and v of the s space and + corresponding actions. + + .. math:: + Q(s,a;\; \Theta, \\alpha, \\beta) = V(s;\; \Theta, \\beta) + A(s, a;\; \Theta, \\alpha) - \\frac{1}{|A|} + \\Big\\sum_{a'} A(s, a';\; \Theta, \\alpha) + + """ + val, adv = self.val(xi), self.adv(xi) + xi = val.expand_as(adv) + (adv - adv.mean()).squeeze(0) + return xi + + +class DuelingDQNModule(FixedTargetDQNModule): + def __init__(self, **kwargs): + super().__init__(**kwargs) + self.name = 'Dueling DQN' + + def setup_linear_block(self, _layers, ni, nc, w, h, emb_szs, layers, ao): + tabular_model = TabularModel(emb_szs=emb_szs, n_cont=ni if not emb_szs else 0, layers=layers, out_sz=ao, + use_bn=self.batch_norm) + if not emb_szs: tabular_model.embeds = None + if not self.batch_norm: tabular_model.bn_cont = FakeBatchNorm() + tabular_model.layers, removed_layer = split_model(tabular_model.layers, [last_layer(tabular_model)]) + ni = removed_layer[0].in_features + self.action_model.add_module('lin_block', TabularEmbedWrapper(tabular_model)) + self.action_model.add_module('dueling_block', DuelingBlock(ao, ni)) + + +class DoubleDuelingModule(DuelingDQNModule, DoubleDQNModule): + def __init__(self, **kwargs): + super().__init__(**kwargs) + self.name = 'DDDQN' diff --git a/fast_rl/core/Envs.py b/fast_rl/core/Envs.py deleted file mode 100644 index 79fbe07..0000000 --- a/fast_rl/core/Envs.py +++ /dev/null @@ -1,51 +0,0 @@ -from functools import partial - -import gym -# noinspection PyUnresolvedReferences -import pybulletgym.envs -# noinspection PyUnresolvedReferences -import gym_maze.envs -import numpy as np - - -class Envs: - @staticmethod - def _error_out(env, ban_list): - for key in ban_list: - if env.__contains__(key): - print(ban_list[key] % env) - return False - return True - - @staticmethod - def ban(envs: list): - banned_envs = { - 'Defender': 'Defender (%s) seems to load for an extremely long time. Skipping for now. Determine cause.', - 'Fetch': 'Fetch (%s) envs are not ready yet.', - 'Blackjack-v0': 'Blackjack (%s) does not have a render function... Skipping', - 'InvertedPendulumMuJoCoEnv': 'Mujoco Inverted Pendulum (%s) has a bug.', - # 'HopperMuJoCoEnv': '(%s) Does not pass azure pipeline tests', - # 'InvertedDoublePendulumMuJoCoEnv': '(%s) Does not pass azure pipeline tests', - # 'HalfCheetahMuJoCoEnv': '(%s) Does not pass azure pipeline tests', - # 'HumanoidMuJoCoEnv': '(%s) Does not pass azure pipeline tests', - # 'Walker2DMuJoCoEnv': '(%s) Does not pass azure pipeline tests', - # 'AntMuJoCoEnv': '(%s) Does not pass azure pipeline tests', - # 'AtlasPyBulletEnv': 'AtlasPyBulletEnv (%s) seems to load very slowly. Skipping for now.', - # 'MazeEnv': '(%s) Having a maze view issue.', - } - envs = np.array(envs)[list(map(partial(Envs._error_out, ban_list=banned_envs), envs))] - - return envs - - @staticmethod - def get_all_envs(key=None, exclude_key=None): - filter_env_names = [env.id for env in gym.envs.registry.all() - if (key is None or env.id.lower().__contains__(key)) and \ - (exclude_key is None or not env.id.lower().__contains__(exclude_key))] - return Envs.ban(filter_env_names) - - @staticmethod - def get_all_latest_envs(key=None, exclude_key=None): - all_envs = Envs.get_all_envs(key, exclude_key) - roots = list(set(map(lambda x: str(x).split('-v')[0], all_envs))) - return list(set([sorted([env for env in all_envs if env.split('-v')[0] == root])[-1] for root in roots])) diff --git a/fast_rl/core/Interpreter.py b/fast_rl/core/Interpreter.py index 59e7866..47058f0 100644 --- a/fast_rl/core/Interpreter.py +++ b/fast_rl/core/Interpreter.py @@ -17,7 +17,7 @@ from torch import nn from fast_rl.core import Learner -from fast_rl.core.MarkovDecisionProcess import MarkovDecisionProcessSliceAlpha, FEED_TYPE_IMAGE +from fast_rl.core.data_block import MarkovDecisionProcessSliceAlpha, FEED_TYPE_IMAGE class AgentInterpretationAlpha(Interpretation): @@ -204,7 +204,7 @@ def get_agent_accuracy_density(self, items, episode_num=None): def plot_agent_accuracy_density(self, episode_num=None): """ - Heat maps the density of actual vs estimated q values. Good reference for this is at [1]. + Heat maps the density of actual vs estimated q v. Good reference for this is at [1]. References: [1] "Simple Example Of 2D Density Plots In Python." Medium. N. p., 2019. Web. 31 Aug. 2019. @@ -241,7 +241,7 @@ def get_q_density(self, items, episode_num=None): def plot_q_density(self, episode_num=None): """ - Heat maps the density of actual vs estimated q values. Good reference for this is at [1]. + Heat maps the density of actual vs estimated q v. Good reference for this is at [1]. References: [1] "Simple Example Of 2D Density Plots In Python." Medium. N. p., 2019. Web. 31 Aug. 2019. @@ -355,9 +355,9 @@ def iplot_episode(self, episode, fps=30): def get_memory_samples(self, batch_size=None, key='reward'): samples = self.learn.model.memory.sample(self.learn.model.batch_size if batch_size is None else batch_size) - if not samples: raise IndexError('Your memory seems empty.') + if not samples: raise IndexError('Your tree seems empty.') if batch_size is not None and batch_size > len(self.learn.model.memory): - raise IndexError(f'Your batch size {batch_size} > the memory\'s batch size {len(self.learn.model.memory)}') + raise IndexError(f'Your batch size {batch_size} > the tree\'s batch size {len(self.learn.model.memory)}') if key not in samples[0].obj.keys(): raise ValueError(f'Key {key} not in {samples[0].obj.keys()}') return [s.obj[key] for s in samples] diff --git a/fast_rl/core/agent_core.py b/fast_rl/core/agent_core.py index cd9ffe2..edf29a1 100644 --- a/fast_rl/core/agent_core.py +++ b/fast_rl/core/agent_core.py @@ -1,231 +1,249 @@ import copy -import math -import random from collections import deque -from functools import partial from math import ceil -from typing import List import gym -import numpy as np -import torch from fastai.basic_train import * +from fastai.torch_core import * + from fast_rl.core.data_structures import SumTree class ExplorationStrategy: - def __init__(self, do_exploration: bool=True): - self.do_exploration = do_exploration + def __init__(self, explore: bool = True): + self.explore = explore - def perturb(self, action, action_space): - """ - Base method just returns the action. Subclass, and change to return randomly / augmented actions. + def perturb(self, action, action_space): + """ + Base method just returns the action. Subclass, and change to return randomly / augmented actions. - Should use `do_exploration` field. It is recommended that when you subclass / overload, you allow this field - to completely bypass these actions. + Should use `do_exploration` field. It is recommended that when you subclass / overload, you allow this field + to completely bypass these actions. - Args: - raw_action: - action: - action_space (gym.Space): The original gym space. Should contain information on the action type, and - possible convenience methods for random action selection. + Args: + action: + action_space (gym.Space): The original gym space. Should contain information on the action type, and + possible convenience methods for random action selection. - Returns: + Returns: - """ - _ = action_space - return action + """ + _ = action_space + return action - def update(self, max_episodes, do_exploration, **kwargs): - self.do_exploration = do_exploration + def update(self, max_episodes, explore, **kwargs): + self.explore = explore class GreedyEpsilon(ExplorationStrategy): - def __init__(self, epsilon_start, epsilon_end, decay, start_episode=0, end_episode=0, **kwargs): - super().__init__(**kwargs) - self.end_episode = end_episode - self.start_episode = start_episode - self.decay = decay - self.epsilon_end = epsilon_end - self.epsilon_start = epsilon_start - self.epsilon = self.epsilon_start - self.steps_done = 0 - - def perturb(self, action, action_space: gym.Space): - """ - TODO for now does random discrete selection. Move to discrete soon. - - Args: - action: - action_space: - - Returns: - """ - if np.random.random() < self.epsilon: - return action_space.sample() - else: - return action - - def update(self, episode, end_episode=0, **kwargs): - super(GreedyEpsilon, self).update(**kwargs) - if self.do_exploration: - self.end_episode = end_episode - self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \ - math.exp(-1. * (self.steps_done * self.decay)) - self.steps_done += 1 + def __init__(self, epsilon_start, epsilon_end, decay, start_episode=0, end_episode=0, **kwargs): + super().__init__(**kwargs) + self.end_episode = end_episode + self.start_episode = start_episode + self.decay = decay + self.epsilon_end = epsilon_end + self.epsilon_start = epsilon_start + self.epsilon = self.epsilon_start + self.steps_done = 0 + + def perturb(self, action, action_space: gym.Space): + """ + TODO for now does random discrete selection. Move to discrete soon. + + Args: + action: + action_space: + + Returns: + """ + if np.random.random() < self.epsilon and self.explore: + return action_space.sample() + else: + return action + + def update(self, episode, end_episode=0, **kwargs): + super(GreedyEpsilon, self).update(**kwargs) + if self.explore: + self.end_episode = end_episode + self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \ + math.exp(-1. * (self.steps_done * self.decay)) + self.steps_done += 1 class OrnsteinUhlenbeck(GreedyEpsilon): - def __init__(self, size, mu=0., theta=0.15, sigma=0.2, **kwargs): - """ - - References: - [1] From https://math.stackexchange.com/questions/1287634/implementing-ornstein-uhlenbeck-in-matlab - [2] Cumulatively based on - - Args: - epsilon_start: - epsilon_end: - decay: - **kwargs: - """ - super().__init__(**kwargs) - self.sigma = sigma - self.theta = theta - self.mu = mu - self.x = np.ones(size) - - def perturb(self, action, action_space): - if self.do_exploration: - dx = self.theta * (self.mu - self.x) + self.sigma * np.array([np.random.normal() for _ in range(len(self.x))]) - else: dx = np.zeros(self.x.shape) - - self.x += dx - return self.epsilon * self.x + action + def __init__(self, size, mu=0., theta=0.15, sigma=0.2, **kwargs): + """ + + References: + [1] From https://math.stackexchange.com/questions/1287634/implementing-ornstein-uhlenbeck-in-matlab + [2] Cumulatively based on + + Args: + epsilon_start: + epsilon_end: + decay: + **kwargs: + """ + super().__init__(**kwargs) + self.sigma = sigma + self.theta = theta + self.mu = mu + self.x = np.ones(size) + + def perturb(self, action, action_space): + if self.explore: + dx = self.theta * (self.mu - self.x) + self.sigma * np.array( + [np.random.normal() for _ in range(len(self.x))]) + else: + dx = np.zeros(self.x.shape) + + self.x += dx + return self.epsilon * self.x + action class Experience: - def __init__(self, memory_size, reduce_ram=False): - self.reduce_ram = reduce_ram - self.max_size = memory_size - self.callbacks = [] + def __init__(self, memory_size, reduce_ram=False): + self.reduce_ram = reduce_ram + self.max_size = memory_size + self.callbacks = [] + + @property + def memory(self): + return None - def sample(self, **kwargs): - pass + def sample(self, **kwargs): + pass - def update(self, **kwargs): - pass + def update(self, item, device, **kwargs): + item.to(device=device) - def refresh(self, **kwargs): - pass + def refresh(self, **kwargs): + pass class ExperienceReplay(Experience): - def __init__(self, memory_size, **kwargs): - r""" - Basic store-er of s space transitions for training agents. + def __init__(self, memory_size, **kwargs): + r""" + Basic store-er of s space transitions for training agents. + + References: + [1] Mnih, Volodymyr, et al. "Playing atari with deep reinforcement learning." + arXiv preprint arXiv:1312.5602 (2013). - References: - [1] Mnih, Volodymyr, et al. "Playing atari with deep reinforcement learning." - arXiv preprint arXiv:1312.5602 (2013). + Args: + memory_size (int): Max N samples to store + """ + super().__init__(memory_size, **kwargs) + self.max_size = memory_size + self._memory = deque(maxlen=memory_size) - Args: - memory_size (int): Max N samples to store - """ - super().__init__(memory_size, **kwargs) - self.max_size = memory_size - self.memory = deque(maxlen=memory_size) # type: List[MarkovDecisionProcessSliceAlpha] + @property + def memory(self): + return self._memory - def __len__(self): - return len(self.memory) + def __len__(self): + return len(self._memory) - def sample(self, batch, **kwargs): - if len(self.memory) < batch: return self.memory - return random.sample(self.memory, batch) + def sample(self, batch, **kwargs): + if len(self._memory) < batch: return self._memory + return random.sample(self.memory, batch) - def update(self, item, **kwargs): - if self.reduce_ram: item.clean() - self.memory.append(copy.deepcopy(item)) + def update(self, item, device, **kwargs): + super().update(item, device, **kwargs) + if self.reduce_ram: item.clean() + self._memory.append(deepcopy(item)) class PriorityExperienceReplayCallback(LearnerCallback): - def on_train_begin(self, **kwargs): - self.learn.model.loss_func = partial(self.learn.model.memory.handle_loss, - base_function=self.learn.model.loss_func) + def on_train_begin(self, **kwargs): + self.learn.model.loss_func = partial(self.learn.model.memory.handle_loss, + base_function=self.learn.model.loss_func, + device=self.learn.data.device) class PriorityExperienceReplay(Experience): - def handle_loss(self, y, y_hat, base_function): - return (base_function(y, y_hat) * torch.from_numpy(self.priority_weights).float()).mean().float() - - def __init__(self, memory_size, batch_size=64, epsilon=0.001, alpha=0.6, beta=0.5): - """ - Prioritizes sampling based on samples requiring the most learning. - - References: - [1] Schaul, Tom, et al. "Prioritized experience replay." arXiv preprint arXiv:1511.05952 (2015). - - Args: - batch_size (int): Size of sample, and thus size of expected index update. - alpha (float): Changes the sampling behavior 1 (non-uniform) -> 0 (uniform) - epsilon (float): Keeps the probabilities of items from being 0 - memory_size (int): Max N samples to store - """ - super().__init__(memory_size) - self.batch_size = batch_size - self.alpha = alpha - self.beta = beta - self.b_inc = -0.00001 - self.priority_weights = np.zeros(self.batch_size, dtype=float) - self.epsilon = epsilon - self.memory = SumTree(self.max_size) - self.callbacks = [PriorityExperienceReplayCallback] - # When sampled, store the sample indices for refresh. - self._indices = np.zeros(self.batch_size, dtype=int) - - def __len__(self): - return self.memory.n_entries - - def refresh(self, post_optimize, **kwargs): - if post_optimize is not None: - self.memory.update(self._indices.astype(int), np.abs(post_optimize['td_error']) + self.epsilon) - - def sample(self, batch, **kwargs): - self.beta = np.min([1., self.beta + self.b_inc]) - # ranges = np.linspace(0, self.memory.total(), num=ceil(self.memory.total() / self.batch_size)) - ranges = np.linspace(0, ceil(self.memory.total() / self.batch_size), num=self.batch_size + 1) - uniform_ranges = [np.random.uniform(ranges[i], ranges[i + 1]) for i in range(len(ranges) - 1)] - self._indices, weights, samples = self.memory.batch_get(uniform_ranges) - self.priority_weights = self.memory.anneal_weights(weights, self.beta) - return samples - - def update(self, item, **kwargs): - """ - Updates the memory of PER. - - Assigns maximal priority per [1] Alg:1, thus guaranteeing that sample being visited once. - - Args: - item: - - Returns: - - """ - maximal_priority = self.alpha - if self.reduce_ram: item.clean() - self.memory.add(np.abs(maximal_priority) + self.epsilon, item) + def handle_loss(self, y, y_hat, base_function, device): + return (base_function(y, y_hat) * torch.from_numpy(self.priority_weights).to(device=device).float()).mean() + + def __init__(self, memory_size, batch_size=64, epsilon=0.01, alpha=0.6, beta=0.4, b_inc=-0.001, **kwargs): + """ + Prioritizes sampling based on samples requiring the most learning. + + References: + [1] Schaul, Tom, et al. "Prioritized experience replay." arXiv preprint arXiv:1511.05952 (2015). + + Args: + batch_size (int): Size of sample, and thus size of expected index update. + alpha (float): Changes the sampling behavior 1 (non-uniform) -> 0 (uniform) + epsilon (float): Keeps the probabilities of items from being 0 + memory_size (int): Max N samples to store + """ + super().__init__(memory_size, **kwargs) + self.batch_size = batch_size + self.alpha = alpha + self.beta = beta + self.b_inc = b_inc + self.priority_weights = None # np.zeros(self.batch_size, dtype=float) + self.epsilon = epsilon + self.tree = SumTree(self.max_size) + self.callbacks = [PriorityExperienceReplayCallback] + # When sampled, store the sample indices for refresh. + self._indices = None # np.zeros(self.batch_size, dtype=int) + + @property + def memory(self): + return self.tree.data + + def __len__(self): + return self.tree.n_entries + + def refresh(self, post_optimize, **kwargs): + if post_optimize is not None: + self.tree.update(self._indices.astype(int), np.abs(post_optimize['td_error']) + self.epsilon) + + def sample(self, batch, **kwargs): + self.beta = np.min([1., self.beta + self.b_inc]) + # ranges = np.linspace(0, self.tree.total(), num=ceil(self.tree.total() / self.batch_size)) + ranges = np.linspace(0, ceil(self.tree.total() / batch), num=batch + 1) + uniform_ranges = [np.random.uniform(ranges[i], ranges[i + 1]) for i in range(len(ranges) - 1)] + try: + self._indices, weights, samples = self.tree.batch_get(uniform_ranges) + except ValueError: + warn('Too few values to unpack. Your batch size is too small, when PER queries tree, all 0 values get' + ' ignored. We will retry until we can return at least one sample.') + samples = self.sample(batch) + + self.priority_weights = self.tree.anneal_weights(weights, self.beta) + return samples + + def update(self, item, device, **kwargs): + """ + Updates the tree of PER. + + Assigns maximal priority per [1] Alg:1, thus guaranteeing that sample being visited once. + + Args: + item: + + Returns: + + """ + super().update(item, device, **kwargs) + maximal_priority = self.alpha + if self.reduce_ram: item.clean() + self.tree.add(np.abs(maximal_priority) + self.epsilon, item) class HindsightExperienceReplay(Experience): - def __init__(self, memory_size): - """ + def __init__(self, memory_size): + """ - References: - [1] Andrychowicz, Marcin, et al. "Hindsight experience replay." - Advances in Neural Information Processing Systems. 2017. + References: + [1] Andrychowicz, Marcin, et al. "Hindsight experience replay." + Advances in Neural Information Processing Systems. 2017. - Args: - memory_size: - """ - super().__init__(memory_size) + Args: + memory_size: + """ + super().__init__(memory_size) diff --git a/fast_rl/core/basic_train.py b/fast_rl/core/basic_train.py index 1a43d8c..37b69c8 100644 --- a/fast_rl/core/basic_train.py +++ b/fast_rl/core/basic_train.py @@ -1,4 +1,6 @@ -from fastai.basic_train import Learner +from multiprocessing.pool import Pool + +from fastai.basic_train import Learner, warn, ifnone, F, List class WrapperLossFunc(object): @@ -11,21 +13,36 @@ def __call__(self, *args, **kwargs): class AgentLearner(Learner): - def __post_init__(self) -> None: - super().__post_init__() - self._loss_func = WrapperLossFunc(self) + def __init__(self, data, loss_func=None, callback_fns=None, **kwargs): + super().__init__(data=data, callback_fns=ifnone(callback_fns, []) + data.callback, **kwargs) + self.model.loss_func = ifnone(loss_func, F.mse_loss) self.loss_func = None - self.callback_fns += self.model.learner_callbacks + self.data.train_ds.callback + self._loss_func = WrapperLossFunc(self) - def predict(self, element, **kwargs): - return self.model.pick_action(element) + @property + def warming_up(self): + return self.data.bs > len(self.data.x) def init_loss_func(self): r""" Initializes the loss function wrapper for logging loss. - Since most RL models have a period of warming up such as filling memory buffers, we cannot log any loss. + Since most RL models have a period of warming up such as filling tree buffers, we cannot log any loss. By default, the learner will have a `None` loss function, and so the fit function will not try to log that loss. """ self.loss_func = self._loss_func + + def interpret_q(self, xi): + raise NotImplemented + + +class PipeLine(object): + def __init__(self, n_threads, pipe_line_function): + warn(Warning('Currently not super useful. Seems to have issues with running a single env in multiple threads.')) + self.pipe_line_function = pipe_line_function + self.n_threads = n_threads + self.pool = Pool(self.n_threads) + + def start(self, n_runs): + return self.pool.map(self.pipe_line_function, range(n_runs)) \ No newline at end of file diff --git a/fast_rl/core/MarkovDecisionProcess.py b/fast_rl/core/data_block.py similarity index 73% rename from fast_rl/core/MarkovDecisionProcess.py rename to fast_rl/core/data_block.py index 3d7ce4f..405f41f 100644 --- a/fast_rl/core/MarkovDecisionProcess.py +++ b/fast_rl/core/data_block.py @@ -1,18 +1,93 @@ import gym from fastai.basic_train import LearnerCallback, DatasetType -from gym.spaces import Discrete, Box, MultiDiscrete +from fastai.tabular.data import def_emb_sz +from gym import Wrapper +from gym.spaces import Discrete, Box, MultiDiscrete, Dict +from fast_rl.core.basic_train import AgentLearner from fast_rl.util.exceptions import MaxEpisodeStepsMissingError +import os + +# Some imported libraries have env wrappers that can make compatibility less messy. +WRAP_ENV_FNS = [] +# Because concurrency errors happen from Open AI when there are multiple environments. +os.environ['KMP_DUPLICATE_LIB_OK'] = 'True' try: - # noinspection PyUnresolvedReferences + import pybullet import pybulletgym.envs + from pybulletgym.envs.mujoco.envs.env_bases import BaseBulletEnv as MujocoEnv + from pybulletgym.envs.roboschool.envs.env_bases import BaseBulletEnv as RoboschoolEnv + + class BulletWrapper(Wrapper): + def step(self, action): + r""" In the event of a random disconnect, retry the env """ + try: + result = super().step(action) + except pybullet.error as e: + self.__init__(env=gym.make(self.spec.id)) + super().reset() + result = super().step(action) + return result + + def pybullet_wrap(env, render): + if issubclass(env.unwrapped.__class__, (MujocoEnv, RoboschoolEnv)): + env = BulletWrapper(env=env) + if render == 'human': env.render() + return env + + WRAP_ENV_FNS.append(pybullet_wrap) except ModuleNotFoundError as e: print(f'Can\'t import one of these: {e}') try: # noinspection PyUnresolvedReferences import gym_maze + from gym_maze.envs.maze_env import MazeEnv + import pygame + # import importlib + + class GymMazeWrapper(Wrapper): + # pygame.init() + # + # def render(self, mode='human', **kwargs): + # try: + # return self.env.render(mode=mode, **kwargs) + # except pygame.error as e: + # original_id = self.env.spec.id + # del self.env + # pygame.init() + # self.env = gym.make(original_id) + # super().reset() + # return self.env.render(mode=mode, **kwargs) + + def close(self): + self.env.maze_view.quit_game() + self.env.unwrapped.enable_render = False + + + def gymmaze_wrap(env, render): + if issubclass(env.unwrapped.__class__, MazeEnv): + env = GymMazeWrapper(env=env) + return env + + WRAP_ENV_FNS.append(gymmaze_wrap) + +except ModuleNotFoundError as e: + print(f'Can\'t import one of these: {e}') +try: + # noinspection PyUnresolvedReferences + import gym_minigrid + # noinspection PyUnresolvedReferences + from gym_minigrid.minigrid import MiniGridEnv + # noinspection PyUnresolvedReferences + from gym_minigrid.wrappers import FlatObsWrapper + + def mini_grid_wrap(env, **kwargs): + if issubclass(env.__class__, MiniGridEnv): env = FlatObsWrapper(env) + return env + + WRAP_ENV_FNS.append(mini_grid_wrap) except ModuleNotFoundError as e: print(f'Can\'t import one of these: {e}') @@ -35,7 +110,7 @@ class Bounds(object): between (gym.Space): A convenience variable for determining the min and max bounds - discrete (bool): Whether the Bounds are discrete or not. Important for N possible values calc. + discrete (bool): Whether the Bounds are discrete or not. Important for N possible v calc. min (list): Correlated min for a given dimension @@ -57,19 +132,21 @@ def __len__(self): @property def n_possible_values(self): """ - Returns the maximum number of values that can be taken. + Returns the maximum number of v that can be taken. This is important for doing embeddings. """ if not self.discrete: return np.inf - else: return np.prod(np.subtract(self.max, self.min)) + else: return np.add(*np.abs((self.max, self.min))).reshape(1, -1) def __post_init__(self): """Sets min and max fields then validates them.""" self.min, self.max = ifnone(self.min, []), ifnone(self.max, []) # If a tuple has been passed, break it into correlated min max variables. if self.between is not None: - for b in (self.between if isinstance(self.between, gym.spaces.Tuple) else listify(self.between)): + between = list(self.between.spaces.values()) if isinstance(self.between, gym.spaces.Dict) else self.between + + for b in (between if isinstance(between, gym.spaces.Tuple) else listify(between)): if isinstance(b, (int, np.int64, np.int, float, np.float)): self.min, self.max = self.min + [0], self.max + [b] self.discrete = isinstance(b, (int, np.int, np.int64)) @@ -102,9 +179,9 @@ class Action(object): raw_action (np.array): Expected to always to be numpy arrays with shape (-1, 1). This is the raw model output such as neural net final layer output. Can be None. - action_space (gym.Space): Used for estimating the max number of values. This is important for embeddings. + action_space (gym.Space): Used for estimating the max number of v. This is important for embeddings. - bounds (tuple): Maximum and minimum values for each action dimension. + bounds (tuple): Maximum and minimum v for each action dimension. n_possible_values (int): An integer or inf value indicating the total number of possible actions there are. """ @@ -112,20 +189,27 @@ class Action(object): action_space: gym.Space raw_action: torch.tensor = None bounds: Bounds = None - n_possible_values: int = 0 + + def to(self, device): + self.taken_action = self.taken_action.to(device=device) + if self.raw_action is not None: self.raw_action = self.raw_action.to(device=device) + + @property + def n_possible_values(self): return self.bounds.n_possible_values def __post_init__(self): # Determine bounds self.bounds = Bounds(self.action_space) - self.n_possible_values = self.bounds.n_possible_values # Fix shapes - self.taken_action = torch.tensor(data=self.taken_action).reshape(1, -1) + if not isinstance(self.taken_action, torch.Tensor): + self.taken_action = torch.tensor(data=self.taken_action).view(1, -1) + else: self.taken_action = self.taken_action.view(1, -1) if self.raw_action is not None: self.raw_action = torch.tensor(data=self.raw_action).reshape(1, -1) def get_single_action(self): """ OpenAI envs do not like 1x1 arrays when they are expecting scalars, so we need to unwrap them. """ - a = self.taken_action.detach().numpy()[0] + a = self.taken_action.detach().cpu().numpy()[0] if len(self.bounds) == 1: a = a[0] if self.bounds.discrete and len(self.bounds) == 1: return int(a) elif self.bounds.discrete and len(self.bounds) != 1: return a.astype(int) @@ -158,9 +242,9 @@ class State(object): mode (int): Should be either FEED_TYPE_IMAGE or FEED_TYPE_STATE - observation_space (gym.Space): Used for estimating the max number of values. This is important for embeddings. + observation_space (gym.Space): Used for estimating the max number of v. This is important for embeddings. - bounds (Bounds): Maximum and minimum values for each state dimension. + bounds (Bounds): Maximum and minimum v for each state dimension. n_possible_values (int): An integer or inf value indicating the total number of possible actions there are. """ @@ -171,7 +255,17 @@ class State(object): observation_space: gym.Space mode: int = FEED_TYPE_STATE bounds: Bounds = None - n_possible_values: int = 0 + + def to(self, device): + self.s = self.s.to(device=device) + self.s_prime = self.s_prime.to(device=device) + + @property + def channels(self): + return self.s.shape[3] + + @property + def n_possible_values(self): return self.bounds.n_possible_values def __str__(self): out = copy(self.__dict__) @@ -192,6 +286,7 @@ def _fix_field(self, input_field): elif type(input_field) is torch.Tensor: input_field = input_field.clone().detach() else: input_field = torch.from_numpy(input_field) + input_field = input_field.long() if self.bounds.discrete and self.mode != FEED_TYPE_IMAGE else input_field.float() # If a non-image state missing the batch dim if len(input_field.shape) <= 1: return input_field.reshape(1, -1) # If a non-image 2+d state missing the batch dim @@ -213,7 +308,6 @@ def __post_init__(self): self.alt_s, self.alt_s_prime, self.s, self.s_prime = self.s, self.s_prime, self.alt_s, self.alt_s_prime # Determine bounds self.bounds = Bounds(self.observation_space) - self.n_possible_values = self.bounds.n_possible_values # Fix Shapes self.s, self.s_prime = self._fix_field(self.s), self._fix_field(self.s_prime) self.alt_s, self.alt_s_prime = self._fix_field(self.alt_s), self._fix_field(self.alt_s_prime) @@ -250,7 +344,14 @@ def __post_init__(self): self.reward = torch.tensor(data=self.reward).reshape(1, -1).float() self.done = torch.tensor(data=self.done).reshape(1, -1).float() - def __str__(self): return ', '.join([str(self.__dict__[el]) for el in self.__dict__]) + def to(self, device): + self.reward = self.reward.to(device=device) + self.done = self.done.to(device=device) + self.action.to(device=device) + self.state.to(device=device) + + def __str__(self): + return ', '.join([str(self.__dict__[el]) for el in self.__dict__]) def clean(self): r""" Removes fields that are generally unimportant (purely debugging) """ @@ -258,14 +359,12 @@ def clean(self): self.state.alt_s = None self.state.observation_space = None self.state.bounds = None - self.state.n_possible_values = None self.action.raw_action = None self.action.action_space = None self.action.bounds = None - self.action.n_possible_values = None @property - def data(self): return self.state.s_prime[0], self.state.alt_s_prime[0] + def data(self): return self.s_prime[0], self.alt_s_prime[0] if self.alt_s_prime is not None else None @property def obj(self): return self.__dict__ @property @@ -282,8 +381,13 @@ def d(self): class MDPCallback(LearnerCallback): + _order = -11 # Needs to happen before Recorder + + @property + def learn(self) -> AgentLearner: return self._learn() + def __init__(self, learn): - """ + r""" Handles action assignment, episode naming. Args: @@ -294,15 +398,16 @@ def __init__(self, learn): self.valid_ds: MDPDataset = None if learn.data.empty_val else learn.data.valid_ds def on_batch_begin(self, last_input, last_target, train, **kwargs: Any): - """ Set the Action of a dataset, determine if still warming up. """ + r""" Set the Action of a dataset, determine if still warming up. """ a = self.learn.predict(last_input) - if train: self.train_ds.action = Action(taken_action=a, action_space=self.train_ds.action.action_space) + if self.learn.model.training: + self.train_ds.action = Action(taken_action=a, action_space=self.train_ds.action.action_space) else: self.valid_ds.action = Action(taken_action=a, action_space=self.train_ds.action.action_space) - self.train_ds.is_warming_up = self.learn.model.warming_up - if self.valid_ds is not None: self.valid_ds.is_warming_up = self.learn.model.warming_up - if not self.learn.model.warming_up and self.learn.loss_func is None: + self.train_ds.is_warming_up = self.learn.warming_up + if self.valid_ds is not None: self.valid_ds.is_warming_up = self.learn.warming_up + if not self.learn.warming_up and self.learn.loss_func is None: self.learn.init_loss_func() - return {'skip_bwd': True} + return {'skip_bwd': True, 'train': not self.train_ds.is_warming_up and train} def on_backward_end(self, **kwargs: Any): return {'skip_step': True} @@ -314,10 +419,13 @@ def on_epoch_end(self, last_metrics, epoch, **kwargs: Any) -> None: """ Updates the most recent episode number in both datasets. """ self.train_ds.x.set_recent_run_episode(epoch) self.train_ds.episode = epoch - if last_metrics[0] is not None: + if last_metrics[0] is not None and self.valid_ds is not None: self.valid_ds.x.set_recent_run_episode(epoch) self.valid_ds.episode = epoch + # def on_train_end(self, **kwargs:Any) ->None: + # self.learn.data.close() + class MDPMemoryManager(LearnerCallback): def __init__(self, learn, strategy, k=1): @@ -349,7 +457,6 @@ def k_top(self, info: Dict[int, List[Tuple[float, bool]]]): return list(set([k for k in info if not info[k][1]]) - set(k_top)) - def on_epoch_end(self, **kwargs: Any): for ds_type in [DatasetType.Train] if self.learn.data.empty_val else [DatasetType.Train, DatasetType.Valid]: ds: MDPDataset = self.learn.dl(ds_type).dataset @@ -359,7 +466,8 @@ def on_epoch_end(self, **kwargs: Any): class MDPDataset(Dataset): - def __init__(self, env: gym.Env, memory_manager, bs, render='rgb_array', feed_type=FEED_TYPE_STATE, max_steps=None): + def __init__(self, env: gym.Env, memory_manager, bs, render='rgb_array', feed_type=FEED_TYPE_STATE, max_steps=None, + x=None): r""" Handles env execution and ItemList building. @@ -368,6 +476,7 @@ def __init__(self, env: gym.Env, memory_manager, bs, render='rgb_array', feed_ty memory_manager: Handles how the list size will be reduced sch as removing image data. bs: Size of a single batch for models and the dataset to use. """ + for wrapper_fn in WRAP_ENV_FNS: env = wrapper_fn(env, render=render) self.env = env self.render = render self.feed_type = feed_type @@ -378,15 +487,20 @@ def __init__(self, env: gym.Env, memory_manager, bs, render='rgb_array', feed_ty self.s_prime, self.alt_s_prime = None, None self.callback = [MDPCallback, memory_manager] # Tracking fields - self.episode = -1 + self.episode = -1 if x is None else max([i.episode + 1 for i in x.items]) self.counter = 0 + # While true, the dataset object with loop until the the number of loops is more than the batch size. + # This allows a model to fill its buffers before doing proper epoch iterating. self.is_warming_up = True # FastAI fields - self.x = MDPList([]) + self.x = ifnone(x, MDPList([])) self.item: Union[MDPStep, None] = None self.new(None) + def get_emb_szs(self): + return [def_emb_sz(0, 0,None)] + def aug_steps(self, steps): if self.is_warming_up and steps < self.bs: return self.bs return steps @@ -394,6 +508,8 @@ def aug_steps(self, steps): @property def max_steps(self): if self._max_steps is not None: return self._max_steps + if hasattr(self.env, 'max_steps'): return getattr(self.env, 'max_steps') + if hasattr(self.env.unwrapped, 'max_steps'): return getattr(self.env.unwrapped, 'max_steps') if hasattr(self.env, '_max_episode_steps'): return getattr(self.env, '_max_episode_steps') if self.env.spec.max_episode_steps is not None: return self.env.spec.max_episode_steps @@ -429,8 +545,11 @@ def stage_1_env_reset(self): """ if self.counter != 0 and self.item.d: self.counter = 0 - if not self.is_warming_up: raise StopIteration - if self.item is None or self.item.d: return self.env.reset(), self.image + if not self.is_warming_up: + self.env.reset() + raise StopIteration + if self.item is None or self.item.d: + return self.env.reset(), self.image return self.s_prime, self.alt_s_prime def stage_2_env_step(self) -> Tuple[np.array, float, bool, None, np.array]: @@ -471,14 +590,14 @@ def to_csv(self, root_path, name): def to_pickle(self, root_path, name): if not os.path.exists(root_path): os.makedirs(root_path) if not self.x: raise IOError('The dataset is empty, cannot pickle.') - pickle.dump(self.x, open(root_path / (name + ".pickle"), "wb"), pickle.HIGHEST_PROTOCOL) + pickle.dump(self.x, open(Path(root_path) / (name + ".pickle"), "wb"), pickle.HIGHEST_PROTOCOL) class MDPDataBunch(DataBunch): - def __del__(self): - if self.train_dl is not None: del self.train_dl.train_ds - if self.valid_dl is not None: del self.valid_dl.valid_ds + def close(self): + if self.train_dl is not None: self.train_dl.env.close() + if self.valid_dl is not None: self.valid_dl.env.close() @property def state_action_sample(self) -> Union[Tuple[State, Action], None]: @@ -488,48 +607,39 @@ def state_action_sample(self) -> Union[Tuple[State, Action], None]: @classmethod def from_env(cls, env_name='CartPole-v1', max_steps=None, render='rgb_array', bs: int = 64, feed_type=FEED_TYPE_STATE, num_workers: int = 0, memory_management_strategy='k_partitions_top', - split_env_init=True, device: torch.device = None, no_check: bool = False, + split_env_init=True, device: torch.device = None, no_check: bool = False, x=None, val_x=None, add_valid=True, **dl_kwargs): env = gym.make(env_name) memory_manager = partial(MDPMemoryManager, strategy=memory_management_strategy) train_list = MDPDataset(env, max_steps=max_steps, feed_type=feed_type, render=render, bs=bs, - memory_manager=memory_manager) + memory_manager=memory_manager, x=x) if add_valid: - valid_list = MDPDataset(env if split_env_init else gym.make(env_name), max_steps=max_steps, + valid_list = MDPDataset(env if split_env_init else gym.make(env_name), max_steps=max_steps, x=val_x, render=render, bs=bs, feed_type=feed_type, memory_manager=memory_manager) else: valid_list = None - path = './data/' + env_name.split('-v')[0].lower() + datetime.now().strftime('%Y%m%d%H%M%S') - return cls.create(train_list, valid_list, num_workers=num_workers, bs=1, device=device, **dl_kwargs) + path = './data/' + env_name + '_' + datetime.now().strftime('%Y%m%d%H%M%S') + return cls.create(train_list, valid_list, path=path, num_workers=num_workers, bs=1, device=device, **dl_kwargs) @classmethod - def from_pickle(cls, env_name='CartPole-v1', bs: int = 1, feed_type=FEED_TYPE_STATE, render='rgb_array', - max_steps=None, add_valid=True, num_workers: int = defaults.cpus, path: PathOrStr = None, - device: torch.device = None, **dl_kwargs): + def from_pickle(cls, env_name=None, path: PathOrStr = None, **dl_kwargs): if path is None: path = [_ for _ in os.listdir('./data/') if _.__contains__(env_name.split('-v')[0].lower())] if not path: raise IOError(f'There is no pickle dirs file found in ./data/ with the env name {env_name}') path = Path('./data/' + path[0]) - env = gym.make(env_name) - train_ls = pickle.load(open(path / 'train.pickle', 'rb')) - train_list = MDPDataset(env, max_steps=max_steps, render=render, bs=bs, x=train_ls) - - if add_valid: - valid_ls = pickle.load(open(path / 'valid.pickle', 'rb')) - valid_list = MDPDataset(env, max_steps=max_steps, render=render, bs=bs, x=valid_ls) - else: - valid_list = None + path = Path(path) - if path is None: path = './data/' + env_name.split('-v')[0].lower() + datetime.now().strftime('%Y%m%d%H%M%S') + train_x = pickle.load(open(path / 'train.pickle', 'rb')) if (path / 'train.pickle').exists() else None + val_x = pickle.load(open(path / 'valid.pickle', 'rb')) if (path / 'valid.pickle').exists() else None - return cls.create(train_list, valid_list, num_workers=num_workers, path=path, bs=bs, feed_type=feed_type, - val_bs=1, device=device, **dl_kwargs) + env_name = ifnone(env_name, Path(path).parts[-1].split('_')[0]) + return cls.from_env(env_name=env_name, x=train_x, val_x=val_x, **dl_kwargs) @classmethod - def create(cls, train_ds: MDPDataset, valid_ds: MDPDataset = None, bs: int = 1, + def create(cls, train_ds: MDPDataset, valid_ds: MDPDataset = None, bs: int = 1, path='.', num_workers: int = defaults.cpus, device: torch.device = None, **dl_kwargs) -> 'DataBunch': """Create a `DataBunch` from `train_ds`, `valid_ds` and maybe `test_ds` with a batch size of `bs`. Passes `**dl_kwargs` to `DataLoader()` @@ -539,7 +649,7 @@ def create(cls, train_ds: MDPDataset, valid_ds: MDPDataset = None, bs: int = 1, datasets = cls._init_ds(train_ds, valid_ds, None) dls = [DataLoader(d, b, shuffle=s, drop_last=s, num_workers=num_workers, **dl_kwargs) for d, b, s in zip(datasets, (bs, bs, bs, bs), (False, False, False, False)) if d is not None] - databunch = cls(*dls, **dl_kwargs) + databunch = cls(path=path, device=device, *dls, **dl_kwargs) if valid_ds is None: databunch.valid_dl = None return databunch @@ -547,9 +657,9 @@ def to_csv(self): if self.train_ds is not None: self.train_ds.to_csv(self.path, 'train') if self.valid_ds is not None: self.valid_ds.to_csv(self.path, 'valid') - def to_pickle(self): - if self.train_ds is not None: self.train_ds.to_pickle(self.path, 'train') - if self.valid_ds is not None: self.valid_ds.to_pickle(self.path, 'valid') + def to_pickle(self, path=None): + if self.train_ds is not None: self.train_ds.to_pickle(ifnone(path, self.path), 'train') + if self.valid_ds is not None: self.valid_ds.to_pickle(ifnone(path, self.path), 'valid') @staticmethod def _init_ds(train_ds: Dataset, valid_ds: Dataset, test_ds: Optional[Dataset] = None): @@ -566,8 +676,8 @@ def __init__(self, items: Iterator, **kwargs): Notes: Two important fields for you to be aware of: `items` and `x`. - `x` is just the values being used for directly being feed into the model. - `items` contains an ndarray of MarkovDecisionProcessSliceAlpha instances. These contain the the primary values + `x` is just the v being used for directly being feed into the model. + `items` contains an ndarray of MarkovDecisionProcessSliceAlpha instances. These contain the the primary v in x, but also the other important properties of a MDP. Args: @@ -575,6 +685,7 @@ def __init__(self, items: Iterator, **kwargs): feed_type: **kwargs: """ + # if items is not None: super().__init__(items, **kwargs) self.info = {} diff --git a/fast_rl/core/data_structures.py b/fast_rl/core/data_structures.py index 8d5529d..47a7276 100644 --- a/fast_rl/core/data_structures.py +++ b/fast_rl/core/data_structures.py @@ -102,7 +102,7 @@ def anneal_weights(self, priorities, beta): return is_weight.astype(float) def batch_get(self, ss): - return np.array(list(zip(*list([self.get(s) for s in ss])))) + return np.array(list(zip(*list([self.get(s) for s in ss if self.get(s)[2] != 0])))) def print_tree(tree: SumTree): @@ -129,7 +129,7 @@ def print_tree(tree: SumTree): display_indexes.append(local_list) for layer in display_indexes: - # Get the values contained in current layer d + # Get the v contained in current layer d if display_values is None: display_values = [[tree.tree[i] for i in layer]] else: diff --git a/fast_rl/core/metrics.py b/fast_rl/core/metrics.py index 8719a51..02d293b 100644 --- a/fast_rl/core/metrics.py +++ b/fast_rl/core/metrics.py @@ -1,5 +1,5 @@ import torch -from fastai.basic_train import LearnerCallback +from fastai.basic_train import LearnerCallback, Any from fastai.callback import Callback, is_listy, add_metrics @@ -9,15 +9,37 @@ class EpsilonMetric(LearnerCallback): def __init__(self, learn): super().__init__(learn) self.epsilon = 0 - if not hasattr(self.learn.model, 'exploration_strategy'): + if not hasattr(self.learn, 'exploration_method'): raise ValueError('Your model is not using an exploration strategy! Please use epsilon based exploration') - if not hasattr(self.learn.model.exploration_strategy, 'epsilon'): + if not hasattr(self.learn.exploration_method, 'epsilon'): raise ValueError('Please use epsilon based exploration (should have an epsilon field)') + # noinspection PyUnresolvedReferences def on_train_begin(self, **kwargs): self.learn.recorder.add_metric_names(['epsilon']) def on_epoch_end(self, last_metrics, **kwargs): - self.epsilon = self.learn.model.exploration_strategy.epsilon + self.epsilon = self.learn.exploration_method.epsilon if last_metrics and last_metrics[-1] is None: del last_metrics[-1] return add_metrics(last_metrics, [float(self.epsilon)]) + +class RewardMetric(LearnerCallback): + _order = -20 + + def __init__(self, learn): + super().__init__(learn) + self.train_reward, self.valid_reward = [], [] + + def on_epoch_begin(self, **kwargs:Any): + self.train_reward, self.valid_reward = [], [] + + def on_batch_end(self, **kwargs: Any): + if self.learn.model.training: self.train_reward.append(self.learn.data.train_ds.item.reward.cpu().numpy()[0][0]) + elif not self.learn.recorder.no_val: self.valid_reward.append(self.learn.data.valid_ds.item.reward.cpu().numpy()[0][0]) + + def on_train_begin(self, **kwargs): + metric_names = ['train_reward'] if self.learn.recorder.no_val else ['train_reward', 'valid_reward'] + self.learn.recorder.add_metric_names(metric_names) + + def on_epoch_end(self, last_metrics, **kwargs: Any): + return add_metrics(last_metrics, [sum(self.train_reward), sum(self.valid_reward)]) diff --git a/fast_rl/core/train.py b/fast_rl/core/train.py index b3e46ce..36bfe4a 100644 --- a/fast_rl/core/train.py +++ b/fast_rl/core/train.py @@ -1,7 +1,319 @@ -from fastai.train import Interpretation +import pickle +from copy import copy +from functools import partial +from pathlib import Path + +import scipy.stats as st +from torch.distributions import Normal +from dataclasses import dataclass, field +from fastai.basic_train import * +from fastai.sixel import plot_sixel +from fastai.train import Interpretation, torch, DatasetType, defaults, ifnone, warn +import matplotlib.pyplot as plt +from fastprogress.fastprogress import IN_NOTEBOOK +from matplotlib.axes import Axes +from matplotlib.figure import Figure +from typing import Tuple, Union, List +import pandas as pd +import numpy as np +import os +from matplotlib.ticker import MaxNLocator +from itertools import cycle, product, permutations, combinations, combinations_with_replacement, islice + +from fast_rl.core.data_block import MDPList + + +def array_flatten(array): + return [item for sublist in array for item in sublist] + + +def cumulate_squash(values: Union[list, List[list]], squash_episodes=False, cumulative=False): + if isinstance(values[0], list): + if squash_episodes: + if cumulative: + values = [np.max(np.cumsum(episode)) for episode in values] + else: + values = [np.max(episode) for episode in values] + else: + if cumulative: + values = [np.cumsum(episode) for episode in array_flatten(values)] + else: + values = array_flatten(values) + else: + if cumulative: values = np.cumsum(values) + return values + + +def group_by_episode(items: MDPList, episodes: list): + ils = [copy(items).filter_by_func(lambda x: x.episode in episodes and x.episode == ep) for ep in episodes] + return [il for il in ils if len(il.items) != 0] + + +def smooth(v, smoothing_const): return np.convolve(v, np.ones(smoothing_const), 'same') / smoothing_const + + +@dataclass +class GroupField: + values: list + model: str + meta: str + value_type: str + per_episode: bool + + @property + def analysis(self): + return { + 'average': np.average(self.values), + 'max': np.max(self.values), + 'min': np.min(self.values), + 'type': self.value_type + } + + @property + def unique_tuple(self): return self.model, self.meta, self.value_type + + def __eq__(self, other): + comp_tuple = other.unique_tuple if isinstance(other, GroupField) else other + return all([self.unique_tuple[i] == comp_tuple[i] for i in range(len(self.unique_tuple))]) + + def smooth(self, smooth_groups): self.values = smooth(self.values, smooth_groups) class AgentInterpretation(Interpretation): - def __init__(self): - raise NotImplementedError('Not implemented yet. Information about this will be provided in README. ' - 'Please use / test AgentInterpretationAlpha found in Interpreter.py.') + def __init__(self, learn: Learner, ds_type: DatasetType = DatasetType.Valid, close_env=True): + super().__init__(learn, None, None, None, ds_type=ds_type) + self.groups = [] + if close_env: self.ds.env.close() + + def get_values(self, il: MDPList, value_name, per_episode=False): + if per_episode: + return [self.get_values(i, value_name) for i in group_by_episode(il, list(il.info.keys()))] + return [i.obj[value_name] for i in il.items] + + def line_figure(self, values: Union[list, List[list]], figsize=(5, 5), cumulative=False, per_episode=False): + fig, ax = plt.subplots(1, 1, figsize=figsize) # type: Figure, Axes + ax.plot(values) + + ax.set_title(f'Rewards over {"episodes" if per_episode else "iterations"}') + ax.set_ylabel(f'{"Cumulative " if cumulative else ""}Rewards') + ax.set_xlabel("Episodes " if per_episode else "Iterations") + ax.xaxis.set_major_locator(MaxNLocator(integer=True)) + return fig + + def plot_rewards(self, per_episode=False, return_fig: bool = None, group_name=None, cumulative=False, no_show=False, + smooth_const: Union[None, float] = None, **kwargs): + values = self.get_values(self.ds.x, 'reward', per_episode) + processed_values = cumulate_squash(values, squash_episodes=per_episode, cumulative=cumulative, **kwargs) + if group_name: self.groups.append(GroupField(processed_values, self.learn.model.name, group_name, 'reward', + per_episode)) + if no_show: return + if smooth_const: processed_values = smooth(processed_values, smooth_const) + fig = self.line_figure(processed_values, per_episode=per_episode, cumulative=cumulative, **kwargs) + + if ifnone(return_fig, defaults.return_fig): return fig + if not IN_NOTEBOOK: plot_sixel(fig) + + def to_group_agent_interpretation(self): + interp = GroupAgentInterpretation() + interp.add_interpretation(self) + return interp + + +@dataclass +class GroupAgentInterpretation(object): + groups: List[GroupField] = field(default_factory=list) + in_notebook: bool = IN_NOTEBOOK + + @property + def analysis(self): + if not self.in_notebook: return [g.analysis for g in self.groups] + else: return pd.DataFrame([{'name': g.unique_tuple, **g.analysis} for g in self.groups]) + + def append_meta(self, post_fix): + r""" Useful before calling `to_pickle` if you want this set to be seen differently from future runs.""" + for g in self.groups: g.meta = g.meta + post_fix + return self + + def filter_by(self, per_episode, value_type): + return copy([g for g in self.groups if g.value_type == value_type and g.per_episode == per_episode]) + + def group_by(self, groups, unique_values): + for comp_tuple in unique_values: yield [g for g in groups if g == comp_tuple] + + def add_interpretation(self, interp): + self.groups += interp.groups + + def plot_reward_bounds(self, title=None, return_fig: bool = None, per_episode=False, + smooth_groups: Union[None, float] = None, figsize=(5, 5), show_average=False, + hide_edges=False): + groups = self.filter_by(per_episode, 'reward') + if smooth_groups is not None: [g.smooth(smooth_groups) for g in groups] + unique_values = list(set([g.unique_tuple for g in groups])) + colors = list(islice(cycle(plt.rcParams['axes.prop_cycle'].by_key()['color']), len(unique_values))) + fig, ax = plt.subplots(1, 1, figsize=figsize) # type: Figure, Axes + + for grouped, c in zip(self.group_by(groups, unique_values), colors): + min_len = min([len(v.values) for v in grouped]) + min_b = np.min([v.values[:min_len] for v in grouped], axis=0) + max_b = np.max([v.values[:min_len] for v in grouped], axis=0) + if show_average: + average = np.average([v.values[:min_len] for v in grouped], axis=0) + ax.plot(average, c=c, linestyle=':') + # TODO fit function sometimes does +1 more episodes... WHY? + overflow = [v.values for v in grouped if len(v.values) - min_len > 2] + + if not hide_edges: + ax.plot(min_b, c=c) + ax.plot(max_b, c=c) + for v in overflow: ax.plot(v, c=c) + + ax.fill_between(list(range(min_len)), min_b, max_b, where=max_b > min_b, color=c, alpha=0.3, + label=f'{grouped[0].meta} {grouped[0].model}') + ax.legend(loc='center left', bbox_to_anchor=(1, 0.5)) + + ax.xaxis.set_major_locator(MaxNLocator(integer=True)) + ax.set_title(ifnone(title, f'{"Per Episode" if per_episode else "Per Step"} Rewards')) + ax.set_ylabel('Rewards') + ax.set_xlabel(f'{"Episodes" if per_episode else "Steps"}') + + if ifnone(return_fig, defaults.return_fig): return fig + if not IN_NOTEBOOK: plot_sixel(fig) + + def to_pickle(self, root_path, name): + if not os.path.exists(root_path): os.makedirs(root_path) + pickle.dump(self, open(Path(root_path) / (name + ".pickle"), "wb"), pickle.HIGHEST_PROTOCOL) + + @classmethod + def from_pickle(cls, root_path, name) -> 'GroupAgentInterpretation': + return pickle.load(open(Path(root_path) / f'{name}.pickle', 'rb')) + + def merge(self, other): + return __class__(self.groups + other.groups) + + +class GymMazeInterpretation(AgentInterpretation): + def __init__(self, learn: Learner, **kwargs): + super().__init__(learn, **kwargs) + try: + from gym_maze.envs import MazeEnv + if not issubclass(self.learn.data.env.unwrapped.__class__, MazeEnv): + raise NotImplemented('This learner was trained on an environment that is not a gym maze env.') + except ImportError as e: + warn(f'Could not import gym maze. Do you have it installed? Full error: {e}') + self.bounds = self.learn.data.state.bounds + + def eval_action(self, action_raw, index=-1): + action_raw = action_raw[0] # Remove batch dim + return torch.max(action_raw).numpy().item() if index == -1 else action_raw[index].numpy().item() + + def heat_map(self, action): + action_eval_fn = partial(self.eval_action, index=action) + state_bounds = list(product(*(np.arange(r[0], r[1]) for r in zip(self.bounds.min, self.bounds.max)))) + # if min is -1, then it is an extra dimension, so multiply by -1 so that the dim in max + 1. + heat_map = np.zeros(shape=tuple(self.bounds.max + -1 * self.bounds.min)) + action_map = np.zeros(shape=tuple(self.bounds.max + -1 * self.bounds.min)) + for state in state_bounds: + with torch.no_grad(): + heat_map[state] = action_eval_fn(self.learn.model(torch.Tensor(data=state).unsqueeze(0).long())) + action_map[state] = self.learn.predict(torch.Tensor(data=state).unsqueeze(0).long()) + return heat_map, action_map + + def add_text_to_image(self, ax, action_map): + x_start, y_start, x_end, y_end, size = 0, 0, action_map.shape[0], action_map.shape[1], 1 + # Add the text + jump_x = size + jump_y = size + x_positions = np.linspace(start=x_start, stop=x_end, num=x_end, endpoint=False) - 1 + y_positions = np.linspace(start=y_start, stop=y_end, num=y_end, endpoint=False) - 1 + + for y_index, y in enumerate(y_positions): + for x_index, x in enumerate(x_positions): + label = action_map[y_index, x_index] + text_x = x + jump_x + text_y = y + jump_y + ax.text(text_x, text_y, int(label), color='black', ha='center', va='center') + + def plot_heat_map(self, action=-1, figsize=(7, 7), return_fig=None): + exploring = self.learn.exploration_method.explore + self.learn.exploration_method.explore = False + heat_map, chosen_actions = self.heat_map(action) + fig, ax = plt.subplots(1, 1, figsize=figsize) # type: Figure, Axes + im = ax.imshow(heat_map) + fig.colorbar(im) + title = f'Heat mapped values {"maximum" if action == -1 else "for action " + str(action)}' + title += '\nText: Chosen action for a given state' + ax.set_title(title) + self.add_text_to_image(ax, chosen_actions) + self.learn.exploration_method.explore = exploring + + if ifnone(return_fig, defaults.return_fig): return fig + if not IN_NOTEBOOK: plot_sixel(fig) + + +class QValueInterpretation(AgentInterpretation): + def __init__(self, learn: Learner, **kwargs): + super().__init__(learn, **kwargs) + self.items = self.learn.data.x if len(self.learn.data.x) != 0 else self.learn.memory.memory + + def normalize(self, item: np.array): + if np.max(item) - np.min(item) != 0: + return np.divide(item + np.min(item), np.max(item) - np.min(item)) + else: + item.fill(1) + return item + + def q(self, items): + actual, predicted = [], [] + episode_partition = [[i for i in items.items if i.episode == key] for key in items.info] + + for ei in episode_partition: + if not ei: continue + raw_actual = [ei[i].reward.cpu().numpy().item() for i in np.flip(np.arange(len(ei)))] + actual += np.flip([np.cumsum(raw_actual[i:])[-1] for i in range(len(raw_actual))]).reshape(-1,).tolist() + for item in ei: predicted.append(self.learn.interpret_q(item)) + + return self.normalize(actual), self.normalize(predicted) + + def plot_q(self, figsize=(8, 8), return_fig=None): + r""" + Heat maps the density of actual vs estimated q v. Good reference for this is at [1]. + + References: + [1] "Simple Example Of 2D Density Plots In Python." Medium. N. p., 2019. Web. 31 Aug. 2019. + https://towardsdatascience.com/simple-example-of-2d-density-plots-in-python-83b83b934f67 + + Returns: + + """ + q_action, q_predicted = self.q(self.items) + # Define the borders + deltaX = (np.max(q_action) - np.min(q_action)) / 10 + deltaY = (np.max(q_predicted) - np.min(q_predicted)) / 10 + xmin = np.min(q_action) - deltaX + xmax = np.max(q_action) + deltaX + ymin = np.min(q_predicted) - deltaY + ymax = np.max(q_predicted) + deltaY + # Create meshgrid + xx, yy = np.mgrid[xmin:xmax:100j, ymin:ymax:100j] + + positions = np.vstack([xx.ravel(), yy.ravel()]) + values = np.vstack([q_action, q_predicted]) + + kernel = st.gaussian_kde(values) + + f = np.reshape(kernel(positions).T, xx.shape) + + fig = plt.figure(figsize=figsize) + ax = fig.gca() + ax.set_xlim(xmin, xmax) + ax.set_ylim(ymin, ymax) + cfset = ax.contourf(xx, yy, f, cmap='coolwarm') + ax.imshow(np.rot90(f), cmap='coolwarm', extent=[xmin, xmax, ymin, ymax]) + cset = ax.contour(xx, yy, f, colors='k') + ax.clabel(cset, inline=1, fontsize=10) + ax.set_xlabel('Actual Returns') + ax.set_ylabel('Estimated Q') + ax.set_title('2D Gaussian Kernel Q Density Estimation') + + if ifnone(return_fig, defaults.return_fig): return fig + if not IN_NOTEBOOK: plot_sixel(fig) \ No newline at end of file diff --git a/fast_rl/notebooks/MarkovDecisionProcessDataBunch.ipynb b/fast_rl/notebooks/MarkovDecisionProcessDataBunch.ipynb deleted file mode 100644 index 8d1864c..0000000 --- a/fast_rl/notebooks/MarkovDecisionProcessDataBunch.ipynb +++ /dev/null @@ -1,210 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## MarkovDecisionProcessDataBunch\n", - "The first peice to the RL puzzle is finding an easy way to handle environments. Our goal is for it to be as easy to use as the `TabularDataBunch` and `ImageDatabunch`. \n", - "\n", - "This will be accomplished by getting all the env names and testing the DataBunch runs." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "pygame 2.0.0.dev3 (SDL 2.0.9, python 3.6.9)\n", - "Hello from the pygame community. https://www.pygame.org/contribute.html\n", - "Defender (Defender-v0) seems to load for an extremely long time. Skipping for now. Determine cause.\n", - "Defender (Defender-v4) seems to load for an extremely long time. Skipping for now. Determine cause.\n", - "Defender (DefenderDeterministic-v0) seems to load for an extremely long time. Skipping for now. Determine cause.\n", - "Defender (DefenderDeterministic-v4) seems to load for an extremely long time. Skipping for now. Determine cause.\n", - "Defender (DefenderNoFrameskip-v0) seems to load for an extremely long time. Skipping for now. Determine cause.\n", - "Defender (DefenderNoFrameskip-v4) seems to load for an extremely long time. Skipping for now. Determine cause.\n", - "Defender (Defender-ram-v0) seems to load for an extremely long time. Skipping for now. Determine cause.\n", - "Defender (Defender-ram-v4) seems to load for an extremely long time. Skipping for now. Determine cause.\n", - "Defender (Defender-ramDeterministic-v0) seems to load for an extremely long time. Skipping for now. Determine cause.\n", - "Defender (Defender-ramDeterministic-v4) seems to load for an extremely long time. Skipping for now. Determine cause.\n", - "Defender (Defender-ramNoFrameskip-v0) seems to load for an extremely long time. Skipping for now. Determine cause.\n", - "Defender (Defender-ramNoFrameskip-v4) seems to load for an extremely long time. Skipping for now. Determine cause.\n", - "Testing FrozenLake8x8-v0\n", - "Testing FrozenLake8x8-v0\n", - "Testing PongDeterministic-v4\n", - "Testing YarsRevengeDeterministic-v4\n", - "Testing JamesbondNoFrameskip-v4\n", - "Testing AsteroidsNoFrameskip-v4\n", - "Testing AsterixNoFrameskip-v4\n", - "Testing JourneyEscapeNoFrameskip-v4\n", - "Testing UpNDown-ramNoFrameskip-v4\n", - "Testing GravitarNoFrameskip-v4\n", - "Testing BipedalWalkerHardcore-v2\n", - "Testing IceHockeyNoFrameskip-v4\n", - "Testing DoubleDunkDeterministic-v4\n", - "Testing PongNoFrameskip-v4\n", - "Testing RoadRunnerNoFrameskip-v4\n", - "Testing HandManipulateBlockTouchSensorsDense-v1\n", - "Mujoco is not installed. Returning None\n", - "Testing VideoPinball-ramNoFrameskip-v4\n", - "Testing PitfallNoFrameskip-v4\n", - "Testing WizardOfWor-ramNoFrameskip-v4\n", - "Testing GravitarDeterministic-v4\n", - "Testing RoadRunnerNoFrameskip-v4\n", - "Testing EnduroNoFrameskip-v4\n", - "Testing FishingDerbyNoFrameskip-v4\n", - "Testing WizardOfWor-ramDeterministic-v4\n", - "Testing RoadRunnerDeterministic-v4\n", - "Testing Phoenix-ramNoFrameskip-v4\n", - "Testing HopperPyBulletEnv-v0\n", - "current_dir=/Users/jlaivins/anaconda3/envs/master36/lib/python3.6/site-packages/pybullet_envs/bullet\n", - "WalkerBase::__init__\n", - "options= \n", - "WalkerBase::__init__\n", - "options= \n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jlaivins/anaconda3/envs/master36/lib/python3.6/site-packages/gym/logger.py:30: UserWarning: \u001b[33mWARN: Environment '' has deprecated methods '_step' and '_reset' rather than 'step' and 'reset'. Compatibility code invoked. Set _gym_disable_underscore_compat = True to disable this behavior.\u001b[0m\n", - " warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing ElevatorAction-ramDeterministic-v4\n", - "Testing TimePilot-ramNoFrameskip-v4\n", - "Testing VideoPinballDeterministic-v4\n", - "Testing KellyCoinflipGeneralized-v0\n", - "Current wealth: 25.0 ; Rounds left: 364 ; True edge: 0.4810532165849047 ; True max wealth: 202.0 ; True stopping time: 364 ; Rounds left: 364\n", - "Current wealth: 25.0 ; Rounds left: 340 ; True edge: 0.8043568825826177 ; True max wealth: 38098.0 ; True stopping time: 340 ; Rounds left: 340\n", - "Current wealth: 50.0 ; Rounds left: 339 ; True edge: 0.8043568825826177 ; True max wealth: 38098.0 ; True stopping time: 340 ; Rounds left: 339\n", - "Current wealth: 12.78 ; Rounds left: 363 ; True edge: 0.4810532165849047 ; True max wealth: 202.0 ; True stopping time: 364 ; Rounds left: 363\n", - "Current wealth: 0.0 ; Rounds left: 362 ; True edge: 0.4810532165849047 ; True max wealth: 202.0 ; True stopping time: 364 ; Rounds left: 362\n", - "Current wealth: 100.0 ; Rounds left: 338 ; True edge: 0.8043568825826177 ; True max wealth: 38098.0 ; True stopping time: 340 ; Rounds left: 338\n", - "Current wealth: 200.0 ; Rounds left: 337 ; True edge: 0.8043568825826177 ; True max wealth: 38098.0 ; True stopping time: 340 ; Rounds left: 337\n", - "Current wealth: 400.0 ; Rounds left: 336 ; True edge: 0.8043568825826177 ; True max wealth: 38098.0 ; True stopping time: 340 ; Rounds left: 336\n", - "Current wealth: 800.0 ; Rounds left: 335 ; True edge: 0.8043568825826177 ; True max wealth: 38098.0 ; True stopping time: 340 ; Rounds left: 335\n", - "Current wealth: 1600.0 ; Rounds left: 334 ; True edge: 0.8043568825826177 ; True max wealth: 38098.0 ; True stopping time: 340 ; Rounds left: 334\n", - "Current wealth: 3200.0 ; Rounds left: 333 ; True edge: 0.8043568825826177 ; True max wealth: 38098.0 ; True stopping time: 340 ; Rounds left: 333\n", - "Current wealth: 6400.0 ; Rounds left: 332 ; True edge: 0.8043568825826177 ; True max wealth: 38098.0 ; True stopping time: 340 ; Rounds left: 332\n", - "Current wealth: 0.0 ; Rounds left: 331 ; True edge: 0.8043568825826177 ; True max wealth: 38098.0 ; True stopping time: 340 ; Rounds left: 331\n", - "Testing CubeCrashScreenBecomesBlack-v0\n", - "Testing FetchPushDense-v1\n", - "Mujoco is not installed. Returning None\n", - "Testing RepeatCopy-v0\n", - "Testing HandManipulateEggFullDense-v0\n", - "Mujoco is not installed. Returning None\n", - "Testing HandManipulateBlockFullDense-v0\n", - "Mujoco is not installed. Returning None\n", - "Testing FishingDerby-ramDeterministic-v4\n", - "Testing Amidar-ramNoFrameskip-v4\n", - "Testing HandManipulateEggRotateDense-v0\n", - "Mujoco is not installed. Returning None\n", - "Testing Asterix-ramNoFrameskip-v4\n", - "Testing Hero-ramNoFrameskip-v4\n", - "Testing BattleZoneNoFrameskip-v4\n", - "Testing HandManipulateBlockRotateParallelTouchSensorsDense-v1\n", - "Mujoco is not installed. Returning None\n", - "Testing FetchReachDense-v1\n", - "Mujoco is not installed. Returning None\n", - "Testing Adventure-ramNoFrameskip-v4\n", - "Testing Boxing-ramNoFrameskip-v4\n", - "Testing MontezumaRevengeDeterministic-v4\n", - "Testing SpaceInvaders-ramDeterministic-v4\n", - "Testing YarsRevengeNoFrameskip-v4\n", - "Testing ReversedAddition3-v0\n", - "Testing ZaxxonNoFrameskip-v4\n", - "Testing MsPacmanDeterministic-v4\n", - "Testing HandManipulatePenRotateTouchSensorsDense-v1\n", - "Mujoco is not installed. Returning None\n", - "Testing IceHockeyNoFrameskip-v4\n", - "Testing BowlingNoFrameskip-v4\n", - "Testing RepeatCopy-v0\n", - "Testing RoadRunner-ramDeterministic-v4\n", - "Testing Enduro-ramDeterministic-v4\n", - "Testing Pooyan-ramNoFrameskip-v4\n", - "Testing Zaxxon-ramDeterministic-v4\n", - "Testing AntPyBulletEnv-v0\n", - "WalkerBase::__init__\n", - "options= \n", - "WalkerBase::__init__\n", - "options= \n", - "Testing HotterColder-v0\n", - "Testing SeaquestNoFrameskip-v4\n", - "Testing ElevatorAction-ramNoFrameskip-v4\n", - "Testing PitfallNoFrameskip-v4\n", - "Testing FetchCutBlockNoKnifeTouchRewardEnv-v1\n", - "Setting Environment: Doing Reward Aug? False Doing joint locking? False\n", - "options= \n" - ] - }, - { - "ename": "error", - "evalue": "Cannot load URDF file.", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31merror\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0menv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menvs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'Testing {env}'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0menv_databunch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMarkovDecisionProcessDataBunch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_env\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_steps\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m50\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_workers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 8\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0menv_databunch\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mcontinue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/PycharmProjects/fast-reinforcement-learning/fast_rl/core/MarkovDecisionProcess.py\u001b[0m in \u001b[0;36mfrom_env\u001b[0;34m(cls, env_name, max_steps, test_ds, path, bs, feed_type, val_bs, num_workers, dl_tfms, device, collate_fn, no_check, **dl_kwargs)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 98\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 99\u001b[0;31m \u001b[0mtrain_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMarkovDecisionProcessDataset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgym\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_steps\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmax_steps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 100\u001b[0m \u001b[0mvalid_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMarkovDecisionProcessDataset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgym\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_steps\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmax_steps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 101\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0merror\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDependencyNotInstalled\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/PycharmProjects/fast-reinforcement-learning/fast_rl/core/MarkovDecisionProcess.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, env, feed_type, render, max_steps)\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv_specific_handle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcounter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 33\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/PycharmProjects/fast-reinforcement-learning/fast_rl/core/MarkovDecisionProcess.py\u001b[0m in \u001b[0;36mnew\u001b[0;34m(self, _)\u001b[0m\n\u001b[1;32m 48\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 49\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_done\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcounter\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax_steps\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 50\u001b[0;31m \u001b[0moutput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreward\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_done\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minfo\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 51\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcounter\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcounter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/master36/lib/python3.6/site-packages/gym/wrappers/time_limit.py\u001b[0m in \u001b[0;36mreset\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 23\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mreset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_elapsed_steps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 25\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/PycharmProjects/pybullet-gym/pybulletgym/envs/fetch_env/gym_locomotion_envs.py\u001b[0m in \u001b[0;36mreset\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 132\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscene\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcreate_single_player_scene\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_p\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscene\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiplayer\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mownsPhysicsClient\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 134\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscene\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mepisode_restart\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_p\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 135\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[0;31m# We want to clear the dynamic objects that might have been modified / added.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/PycharmProjects/pybullet-gym/pybulletgym/envs/fetch_env/scene_manipulators.py\u001b[0m in \u001b[0;36mepisode_restart\u001b[0;34m(self, bullet_client)\u001b[0m\n\u001b[1;32m 390\u001b[0m filename = os.path.join(os.path.dirname(__file__), \"..\", \"assets\", \"things\", \"table\",\n\u001b[1;32m 391\u001b[0m \"table.urdf\")\n\u001b[0;32m--> 392\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_p\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloadURDF\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m90\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m90\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 393\u001b[0m \u001b[0;31m# Load the plane\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 394\u001b[0m filename = os.path.join(os.path.dirname(__file__), \"..\", \"assets\", \"things\", \"plane\",\n", - "\u001b[0;31merror\u001b[0m: Cannot load URDF file." - ], - "output_type": "error" - } - ], - "source": [ - "from fast_rl.core.Envs import Envs\n", - "from fast_rl.core.MarkovDecisionProcess import MarkovDecisionProcessDataBunch\n", - "\n", - "envs = Envs.get_all_latest_envs()\n", - "for env in envs:\n", - " print(f'Testing {env}')\n", - " env_databunch = MarkovDecisionProcessDataBunch.from_env(env, max_steps=50, num_workers=0)\n", - " if env_databunch is None: continue\n", - "\n", - " epochs = 1 # Also known as episodes\n", - "\n", - " for epoch in range(epochs):\n", - " for element in env_databunch.train_dl:\n", - " env_databunch.train_ds.actions = env_databunch.train_ds.get_random_action()\n", - "\n", - " for element in env_databunch.valid_dl:\n", - " env_databunch.valid_ds.actions = env_databunch.valid_ds.get_random_action()" - ] - } - ], - "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.9" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/fast_rl/tests/test_DataBunch.py b/fast_rl/tests/test_DataBunch.py deleted file mode 100644 index 09cd915..0000000 --- a/fast_rl/tests/test_DataBunch.py +++ /dev/null @@ -1,25 +0,0 @@ -from fastai.vision import ImageDataBunch - -from fast_rl.util.file_handlers import get_absolute_path - - -# def test_ImageDataBunch_init(): -# """ -# For understanding various databunches. -# -# For example, ImageDataBunch in the from folder: -# -# Src is originally an ImageList, but the following code: -# -# `src = src.label_from_folder(classes=classes)` -# -# CHANGES THE CLASS TO A LABELLISTS?!?!? -# -# In other words, the ImageList is capable of turning into a dataset. -# -# :return: -# """ -# data = ImageDataBunch.from_folder(get_absolute_path('data'), valid_pct=0.5) -# -# for e in data.train_ds: -# print(e) \ No newline at end of file diff --git a/fast_rl/tests/test_Envs.py b/fast_rl/tests/test_Envs.py deleted file mode 100644 index 588ca46..0000000 --- a/fast_rl/tests/test_Envs.py +++ /dev/null @@ -1,48 +0,0 @@ -import gym -import numpy as np -import pytest -from fast_rl.core.Envs import Envs -# from fast_rl.core.MarkovDecisionProcess import MDPDataBunchAlpha - - - - -# def test_individual_env(): -# msg = 'the datasets in the dataloader seem to be different from the data bunches datasets...' - -# max_steps = 50 - -# env = 'CarRacing-v0' -# print(f'Testing {env}') -# mdp_databunch = MDPDataBunchAlpha.from_env(env, max_steps=max_steps, num_workers=0) -# epochs = 1 - -# assert max_steps == len(mdp_databunch.train_dl) -# assert max_steps == len(mdp_databunch.valid_dl) - -# for epoch in range(epochs): -# for _ in mdp_databunch.train_dl: -# mdp_databunch.train_ds.actions = mdp_databunch.train_ds.get_random_action() -# # print(f's {element.shape} action {mdp_databunch.train_dl.dl.dataset.actions}') -# assert np.sum( -# np.equal(mdp_databunch.train_dl.dl.dataset.actions, mdp_databunch.train_ds.actions)) == np.size( -# mdp_databunch.train_ds.actions), msg - -# for _ in mdp_databunch.valid_dl: -# mdp_databunch.valid_ds.actions = mdp_databunch.valid_ds.get_random_action() -# # print(f's {element.shape} action {mdp_databunch.valid_dl.dl.dataset.actions}') -# assert np.sum( -# np.equal(mdp_databunch.train_dl.dl.dataset.actions, mdp_databunch.train_ds.actions)) == np.size( -# mdp_databunch.train_ds.actions), msg - - -# def test_individual_env_no_dl(): -# """Just a nice place to do sanity testing on new / untested envs.""" -# env = gym.make('maze-random-10x10-plus-v0') -# for episode in range(2): -# done = False -# env.reset() -# while not done: -# output = env.step(env.action_space.sample()) -# done = output[2] -# env.render('human') diff --git a/fast_rl/tests/test_Interpretation.py b/fast_rl/tests/test_Interpretation.py deleted file mode 100644 index 139597f..0000000 --- a/fast_rl/tests/test_Interpretation.py +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/fast_rl/tests/test_agent_core.py b/fast_rl/tests/test_agent_core.py deleted file mode 100644 index c55c40e..0000000 --- a/fast_rl/tests/test_agent_core.py +++ /dev/null @@ -1,34 +0,0 @@ -import pytest - -from fast_rl.agents.DDPG import DDPG -from fast_rl.agents.DQN import DQN, FixedTargetDQN -from fast_rl.core.MarkovDecisionProcess import MDPDataBunch -from fast_rl.core.agent_core import PriorityExperienceReplay -from fast_rl.core.basic_train import AgentLearner - - -def test_priority_experience_replay(): - data = MDPDataBunch.from_env('maze-random-5x5-v0', render='human', max_steps=100, add_valid=False) - model = FixedTargetDQN(data, memory=PriorityExperienceReplay(1000)) - learn = AgentLearner(data, model) - learn.fit(3) - data.train_ds.env.close() - - -@pytest.mark.parametrize("env", sorted(['CartPole-v0'])) -def test_databunch_dqn_fit(env): - data = MDPDataBunch.from_env(env) - model = DQN(data) - learner = AgentLearner(data=data, model=model) - learner.fit(3) - data.valid_ds.env.close() - data.train_ds.env.close() - -def test_fit_function_ddpg(): - data = MDPDataBunch.from_env('Pendulum-v0', bs=4, render='human', max_steps=100, add_valid=False) - model = DDPG(data, memory=PriorityExperienceReplay(1000)) - learn = AgentLearner(data, model) - learn.fit(3) - data.train_ds.env.close() - - diff --git a/fast_rl/tests/test_ddpg_models.py b/fast_rl/tests/test_ddpg_models.py deleted file mode 100644 index b72a5c5..0000000 --- a/fast_rl/tests/test_ddpg_models.py +++ /dev/null @@ -1,28 +0,0 @@ -from collections import Collection -from functools import partial -from itertools import product - -import pytest -from fastai.basic_train import LearnerCallback - -from fast_rl.agents.DDPG import DDPG -from fast_rl.core.Envs import Envs -from fast_rl.core.MarkovDecisionProcess import FEED_TYPE_IMAGE, FEED_TYPE_STATE, MDPDataBunch -from fast_rl.core.agent_core import ExperienceReplay, OrnsteinUhlenbeck -from fast_rl.core.basic_train import AgentLearner - -params_dqn = [DDPG] -params_envs = ['Pendulum-v0', 'CarRacing-v0'] -params_state_format = [FEED_TYPE_STATE, FEED_TYPE_IMAGE] - - -@pytest.mark.parametrize(["env", "model", "s_format"], list(product(params_envs, params_dqn, params_state_format))) -def test_ddpg_models(env, model, s_format): - model = partial(model, memory=ExperienceReplay(memory_size=1000, reduce_ram=True)) - data = MDPDataBunch.from_env(env, render='rgb_array', max_steps=20, bs=4, add_valid=False, feed_type=s_format) - learn = AgentLearner(data, model(data)) - learn.fit(3) - data.train_ds.env.close() - del learn - del model - del data diff --git a/fast_rl/tests/test_dqn_models.py b/fast_rl/tests/test_dqn_models.py deleted file mode 100644 index 60a3689..0000000 --- a/fast_rl/tests/test_dqn_models.py +++ /dev/null @@ -1,32 +0,0 @@ -from functools import partial -from itertools import product - -import pytest - -from fast_rl.agents.DQN import DQN, FixedTargetDQN, DoubleDQN, DuelingDQN, DoubleDuelingDQN -from fast_rl.core.MarkovDecisionProcess import MDPDataBunch, FEED_TYPE_STATE, FEED_TYPE_IMAGE -from fast_rl.core.agent_core import ExperienceReplay -from fast_rl.core.basic_train import AgentLearner - - -params_dqn = [DuelingDQN, DoubleDQN, DQN, FixedTargetDQN, DoubleDuelingDQN] -params_envs = ['CartPole-v0', 'MountainCar-v0', 'Pong-v0'] -params_state_format = [FEED_TYPE_STATE, FEED_TYPE_IMAGE] - - -@pytest.mark.parametrize(["env", "model", "s_format"], list(product(params_envs, params_dqn, params_state_format))) -def test_dqn_models(env, model, s_format): - model = partial(model, memory=ExperienceReplay(memory_size=1000, reduce_ram=True)) - print('\n') - - data = MDPDataBunch.from_env(env, render='rgb_array', max_steps=20, bs=4, add_valid=False, - feed_type=s_format) - - learn = AgentLearner(data, model(data)) - - data.train_ds.env.close() - - learn.fit(3) - del learn - del model - del data diff --git a/fast_rl/tests/__init__.py b/fast_rl/util/__init__.py similarity index 100% rename from fast_rl/tests/__init__.py rename to fast_rl/util/__init__.py diff --git a/fast_rl/util/random_thingy.py b/fast_rl/util/random_thingy.py deleted file mode 100644 index a82e664..0000000 --- a/fast_rl/util/random_thingy.py +++ /dev/null @@ -1,16 +0,0 @@ -""" -from fast_rl.core.Interpreter import AgentInterpretationAlpha - -interp = AgentInterpretationAlpha(learn) -interp.plot_heatmapped_episode(-1) - -""" -from fast_rl.core.basic_train import AgentLearner -from fast_rl.agents.DQN import FixedTargetDQN -from fast_rl.core.MarkovDecisionProcess import MDPDataBunch -from fast_rl.core.agent_core import ExperienceReplay - -data = MDPDataBunch.from_env('Pong-v0', render='human', max_steps=100, add_valid=False) -model = FixedTargetDQN(data, memory=ExperienceReplay(memory_size=100000, reduce_ram=True)) -learn = AgentLearner(data, model) -learn.fit(450) \ No newline at end of file diff --git a/fast_rl/tests/test_metrics.py b/res/RELEASE_BLOG.md similarity index 100% rename from fast_rl/tests/test_metrics.py rename to res/RELEASE_BLOG.md diff --git a/setup.py b/setup.py index 88e7ef2..d38b357 100644 --- a/setup.py +++ b/setup.py @@ -3,7 +3,7 @@ with open("README.md", "r") as fh: long_description = fh.read() -VERSION = "0.7.0" +VERSION = "0.9.7" setup(name='fast_rl', version=VERSION, @@ -12,14 +12,19 @@ 'start, but also designed for testing new agents. ', url='https://github.com/josiahls/fast-reinforcement-learning', author='Josiah Laivins', - author_email='jokellum@northstate.net', - python_requires = '>=3.6', + author_email='jlaivins@uncc.edu', + python_requires='>=3.6', long_description=long_description, long_description_content_type="text/markdown", license='', packages=find_packages(), zip_safe=False, - install_requires=['fastai', 'gym[box2d, atari]', 'jupyter', 'moviepy'], + install_requires=['fastai>=1.0.59', 'gym[box2d, atari]', 'jupyter'], + extras_require={'all': [ + 'gym-minigrid', + # 'gym_maze @ git+https://github.com/MattChanTK/gym-maze.git', + # 'pybullet-gym @ git+https://github.com/benelot/pybullet-gym.git' + ]}, classifiers=[ "Development Status :: 3 - Alpha", "Programming Language :: Python :: 3", diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..7589bb1 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,17 @@ +import pytest + + +def pytest_addoption(parser): + parser.addoption("--include_performance_tests", action="store_true", + help="Will run the performance tests which do full model testing. This could take a few" + "days to fully accomplish.") + +@pytest.fixture() +def include_performance_tests(pytestconfig): + return pytestconfig.getoption("include_performance_tests") + + +@pytest.fixture() +def skip_performance_check(include_performance_tests): + if not include_performance_tests: + pytest.skip('Skipping due to performance argument not specified. Add --include_performance_tests to not skip') diff --git a/tests/data/cartpole_dqn/dqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle b/tests/data/cartpole_dqn/dqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle new file mode 100644 index 0000000..1135d85 Binary files /dev/null and b/tests/data/cartpole_dqn/dqn_PriorityExperienceReplay_FEED_TYPE_STATE.pickle differ diff --git a/fast_rl/tests/data/cat/cat1.jpeg b/tests/data/cat/cat1.jpeg similarity index 100% rename from fast_rl/tests/data/cat/cat1.jpeg rename to tests/data/cat/cat1.jpeg diff --git a/fast_rl/tests/data/cat/cat2.jpeg b/tests/data/cat/cat2.jpeg similarity index 100% rename from fast_rl/tests/data/cat/cat2.jpeg rename to tests/data/cat/cat2.jpeg diff --git a/fast_rl/tests/data/dog/dog1.jpeg b/tests/data/dog/dog1.jpeg similarity index 100% rename from fast_rl/tests/data/dog/dog1.jpeg rename to tests/data/dog/dog1.jpeg diff --git a/fast_rl/tests/data/dog/dog2.jpeg b/tests/data/dog/dog2.jpeg similarity index 100% rename from fast_rl/tests/data/dog/dog2.jpeg rename to tests/data/dog/dog2.jpeg diff --git a/tests/test_agent_core.py b/tests/test_agent_core.py new file mode 100644 index 0000000..09a169a --- /dev/null +++ b/tests/test_agent_core.py @@ -0,0 +1,8 @@ + +# import pytest +# +# from fast_rl.core.data_block import MDPDataBunch +# from fast_rl.core.agent_core import PriorityExperienceReplay +# from fast_rl.core.basic_train import AgentLearner +# + diff --git a/tests/test_basic_train.py b/tests/test_basic_train.py new file mode 100644 index 0000000..b30976e --- /dev/null +++ b/tests/test_basic_train.py @@ -0,0 +1,17 @@ + +# def pipeline_fn(_): +# group_interp = GroupAgentInterpretation() +# data = MDPDataBunch.from_env('CartPole-v1', max_steps=40, render='rgb_array', bs=5, device='cpu') +# model = DQN(data, tree=ExperienceReplay(memory_size=100, reduce_ram=True)) +# learn = AgentLearner(data, model) +# learn.fit(2) +# interp = AgentInterpretation(learn) +# interp.plot_rewards(cumulative=True, per_episode=True, group_name='run', no_show=True) +# group_interp.add_interpretation(interp) +# data.close() +# return group_interp.analysis +# +# +# def test_pipeline_init(): +# pl = PipeLine(2, pipeline_fn) +# print(pl.start(5)) diff --git a/fast_rl/tests/test_MDPDataBunch.py b/tests/test_data_block.py similarity index 81% rename from fast_rl/tests/test_MDPDataBunch.py rename to tests/test_data_block.py index 7b5bf3c..1d01458 100644 --- a/fast_rl/tests/test_MDPDataBunch.py +++ b/tests/test_data_block.py @@ -1,24 +1,5 @@ -from functools import partial - -import gym -import numpy as np import pytest -import torch from fastai.basic_train import ItemLists -from gym import error -from gym.envs.algorithmic.algorithmic_env import AlgorithmicEnv -from gym.envs.toy_text import discrete -from gym.wrappers import TimeLimit - -from fast_rl.agents.DQN import DQN -from fast_rl.core.Envs import Envs -from fast_rl.core.MarkovDecisionProcess import Action, Bounds, State, MDPDataset, MDPDataBunch, MDPMemoryManager -from fast_rl.core.basic_train import AgentLearner -from fast_rl.util.exceptions import MaxEpisodeStepsMissingError -from fast_rl.util.misc import list_in_str - -ENV_NAMES = Envs.get_all_latest_envs() - def validate_item_list(item_list: ItemLists): # Check items @@ -29,15 +10,51 @@ def validate_item_list(item_list: ItemLists): assert item.state.s_prime is not None, f'The item: {item}\'s state prime is None' -@pytest.mark.parametrize("env", sorted(['CartPole-v0'])) -def test_mdp_clean_callback(env): - data = MDPDataBunch.from_env(env, render='rgb_array') - model = DQN(data) - learner = AgentLearner(data, model) - learner.fit(15) - data.train_ds.env.close() - data.valid_ds.env.close() - del learner + +# @pytest.mark.parametrize("env", sorted(['CartPole-v0'])) +# def test_mdp_from_pickle(env): +# data = MDPDataBunch.from_env(env, render='rgb_array') +# model = DQN(data) +# learner = AgentLearner(data, model) +# learner.fit(2) +# data.to_pickle(path='data/CartPole-v0_testing') +# data = MDPDataBunch.from_pickle(path='data/CartPole-v0_testing') +# del data +# +# +# @pytest.mark.parametrize("env", sorted(['CartPole-v0'])) +# def test_mdp_to_csv(env): +# data = MDPDataBunch.from_env(env, render='rgb_array') +# model = DQN(data) +# learner = AgentLearner(data, model) +# learner.fit(2) +# data.to_csv() +# data.train_ds.env.close() +# data.valid_ds.env.close() +# del learner +# +# +# @pytest.mark.parametrize("env", sorted(['CartPole-v0'])) +# def test_mdp_to_pickle(env): +# data = MDPDataBunch.from_env(env, render='rgb_array') +# model = DQN(data) +# learner = AgentLearner(data, model) +# learner.fit(2) +# data.to_pickle() +# data.train_ds.env.close() +# data.valid_ds.env.close() +# del learner +# +# +# @pytest.mark.parametrize("env", sorted(['CartPole-v0'])) +# def test_mdp_clean_callback(env): +# data = MDPDataBunch.from_env(env, render='rgb_array') +# model = DQN(data) +# learner = AgentLearner(data, model) +# learner.fit(15) +# data.train_ds.env.close() +# data.valid_ds.env.close() +# del learner # # # @pytest.mark.parametrize("env", sorted(['CartPole-v0'])) @@ -107,9 +124,9 @@ def test_mdp_clean_callback(env): # # for bound in (Bounds(init_env.action_space), Bounds(init_env.observation_space)): # if env.lower().__contains__('continuous'): -# assert bound.n_possible_values == np.inf, f'Env {env} is continuous, should have inf values.' +# assert bound.n_possible_values == np.inf, f'Env {env} is continuous, should have inf v.' # if env.lower().__contains__('deterministic'): -# assert bound.n_possible_values != np.inf, f'Env {env} is deterministic, should have discrete values.' +# assert bound.n_possible_values != np.inf, f'Env {env} is deterministic, should have discrete v.' # init_env.close() # # @pytest.mark.parametrize("env", sorted(['CartPole-v0'])) diff --git a/fast_rl/tests/test_data_structures.py b/tests/test_data_structures.py similarity index 100% rename from fast_rl/tests/test_data_structures.py rename to tests/test_data_structures.py diff --git a/tests/test_ddpg.py b/tests/test_ddpg.py new file mode 100644 index 0000000..373f8b3 --- /dev/null +++ b/tests/test_ddpg.py @@ -0,0 +1,240 @@ +from functools import partial +from itertools import product + +import pytest +from fast_rl.agents.ddpg_models import DDPGModule +from fastai.basic_train import torch, DatasetType + +from fast_rl.agents.ddpg import create_ddpg_model, ddpg_learner +from fast_rl.core.agent_core import ExperienceReplay, PriorityExperienceReplay, OrnsteinUhlenbeck +from fast_rl.core.basic_train import AgentLearner +from fast_rl.core.data_block import FEED_TYPE_STATE, MDPDataBunch, FEED_TYPE_IMAGE +from fast_rl.core.metrics import RewardMetric, EpsilonMetric +from fast_rl.core.train import GroupAgentInterpretation, AgentInterpretation + + +p_model = [DDPGModule] +p_exp = [ExperienceReplay, PriorityExperienceReplay] +p_format = [FEED_TYPE_STATE]#, FEED_TYPE_IMAGE] +p_full_format = [FEED_TYPE_STATE] +p_envs = ['Walker2DPyBulletEnv-v0'] + +config_env_expectations = { + 'Walker2DPyBulletEnv-v0': {'action_shape': (1, 6), 'state_shape': (1, 22)} +} + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", "env"], list(product(p_model, p_format, p_envs))) +def test_ddpg_create_ddpg_model(model_cls, s_format, env): + data = MDPDataBunch.from_env(env, render='rgb_array', bs=32, add_valid=False, feed_type=s_format) + model = create_ddpg_model(data, model_cls) + model.eval() + model(data.state.s.float()) + + assert config_env_expectations[env]['action_shape'] == (1, data.action.taken_action.shape[1]) + if s_format == FEED_TYPE_STATE: + assert config_env_expectations[env]['state_shape'] == data.state.s.shape + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", "mem", "env"], list(product(p_model, p_format, p_exp, p_envs))) +def test_dddpg_ddpglearner(model_cls, s_format, mem, env): + data = MDPDataBunch.from_env(env, render='rgb_array', bs=32, add_valid=False, feed_type=s_format) + model = create_ddpg_model(data, model_cls) + memory = mem(memory_size=1000, reduce_ram=True) + exploration_method = OrnsteinUhlenbeck(size=data.action.taken_action.shape, epsilon_start=1, epsilon_end=0.1, decay=0.001) + ddpg_learner(data=data, model=model, memory=memory, exploration_method=exploration_method) + + assert config_env_expectations[env]['action_shape'] == (1, data.action.taken_action.shape[1]) + if s_format == FEED_TYPE_STATE: + assert config_env_expectations[env]['state_shape'] == data.state.s.shape + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", "mem", "env"], list(product(p_model, p_format, p_exp, p_envs))) +def test_ddpg_fit(model_cls, s_format, mem, env): + data = MDPDataBunch.from_env(env, render='rgb_array', bs=10, max_steps=20, add_valid=False, feed_type=s_format) + model = create_ddpg_model(data, model_cls, opt=torch.optim.RMSprop, layers=[20, 20]) + memory = mem(memory_size=100, reduce_ram=True) + exploration_method = OrnsteinUhlenbeck(size=data.action.taken_action.shape, epsilon_start=1, epsilon_end=0.1, decay=0.001) + learner = ddpg_learner(data=data, model=model, memory=memory, exploration_method=exploration_method, + callback_fns=[RewardMetric, EpsilonMetric]) + learner.fit(2) + + assert config_env_expectations[env]['action_shape'] == (1, data.action.taken_action.shape[1]) + if s_format == FEED_TYPE_STATE: + assert config_env_expectations[env]['state_shape'] == data.state.s.shape + + del data + del model + del learner + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", 'experience'], + list(product(p_model, p_format, p_exp))) +def test_ddpg_models_pendulum(model_cls, s_format, experience): + group_interp = GroupAgentInterpretation() + for i in range(5): + print('\n') + data = MDPDataBunch.from_env('Pendulum-v0', render='human', bs=64, add_valid=False, feed_type=s_format) + exploration_method = OrnsteinUhlenbeck(size=data.action.taken_action.shape, epsilon_start=1, epsilon_end=0.1, + decay=0.0001) + memory = experience(memory_size=1000000, reduce_ram=True) + model = create_ddpg_model(data=data, base_arch=model_cls) + learner = ddpg_learner(data=data, model=model, memory=memory, exploration_method=exploration_method, + callback_fns=[RewardMetric, EpsilonMetric]) + learner.fit(450) + + meta = f'{experience.__name__}_{"FEED_TYPE_STATE" if s_format == FEED_TYPE_STATE else "FEED_TYPE_IMAGE"}' + interp = AgentInterpretation(learner, ds_type=DatasetType.Train) + interp.plot_rewards(cumulative=True, per_episode=True, group_name=meta) + group_interp.add_interpretation(interp) + group_interp.to_pickle(f'../docs_src/data/pendulum_{model.name.lower()}/', f'{model.name.lower()}_{meta}') + + del learner + del model + del data + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", 'experience'], + list(product(p_model, p_full_format, p_exp))) +def test_ddpg_models_mountain_car_continuous(model_cls, s_format, experience): + group_interp = GroupAgentInterpretation() + for i in range(5): + print('\n') + data = MDPDataBunch.from_env('MountainCarContinuous-v0', render='human', bs=40, add_valid=False, feed_type=s_format) + exploration_method = OrnsteinUhlenbeck(size=data.action.taken_action.shape, epsilon_start=1, epsilon_end=0.1, + decay=0.0001) + memory = experience(memory_size=1000000, reduce_ram=True) + model = create_ddpg_model(data=data, base_arch=model_cls) + learner = ddpg_learner(data=data, model=model, memory=memory, exploration_method=exploration_method, + callback_fns=[RewardMetric, EpsilonMetric]) + learner.fit(450) + + meta = f'{experience.__name__}_{"FEED_TYPE_STATE" if s_format == FEED_TYPE_STATE else "FEED_TYPE_IMAGE"}' + interp = AgentInterpretation(learner, ds_type=DatasetType.Train) + interp.plot_rewards(cumulative=True, per_episode=True, group_name=meta) + group_interp.add_interpretation(interp) + group_interp.to_pickle(f'../docs_src/data/mountaincarcontinuous_{model.name.lower()}/', + f'{model.name.lower()}_{meta}') + + del learner + del model + del data + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", 'experience'], + list(product(p_model, p_full_format, p_exp))) +def test_ddpg_models_reach(model_cls, s_format, experience): + group_interp = GroupAgentInterpretation() + for i in range(5): + print('\n') + data = MDPDataBunch.from_env('ReacherPyBulletEnv-v0', render='human', bs=40, add_valid=False,feed_type=s_format) + exploration_method = OrnsteinUhlenbeck(size=data.action.taken_action.shape, epsilon_start=1, epsilon_end=0.1, + decay=0.0001) + memory = experience(memory_size=1000000, reduce_ram=True) + model = create_ddpg_model(data=data, base_arch=model_cls) + learner = ddpg_learner(data=data, model=model, memory=memory, exploration_method=exploration_method, + callback_fns=[RewardMetric, EpsilonMetric]) + learner.fit(450) + + meta = f'{experience.__name__}_{"FEED_TYPE_STATE" if s_format == FEED_TYPE_STATE else "FEED_TYPE_IMAGE"}' + interp = AgentInterpretation(learner, ds_type=DatasetType.Train) + interp.plot_rewards(cumulative=True, per_episode=True, group_name=meta) + group_interp.add_interpretation(interp) + group_interp.to_pickle(f'../docs_src/data/reacher_{model.name.lower()}/', + f'{model.name.lower()}_{meta}') + + del learner + del model + del data + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", 'experience'], + list(product(p_model, p_full_format, p_exp))) +def test_ddpg_models_walker(model_cls, s_format, experience): + group_interp = GroupAgentInterpretation() + for i in range(5): + print('\n') + data = MDPDataBunch.from_env('Walker2DPyBulletEnv-v0', render='human', bs=64, add_valid=False, + feed_type=s_format) + exploration_method = OrnsteinUhlenbeck(size=data.action.taken_action.shape, epsilon_start=1, epsilon_end=0.1, + decay=0.0001) + memory = experience(memory_size=1000000, reduce_ram=True) + model = create_ddpg_model(data=data, base_arch=model_cls) + learner = ddpg_learner(data=data, model=model, memory=memory, exploration_method=exploration_method, + callback_fns=[RewardMetric, EpsilonMetric]) + learner.fit(2000) + + meta = f'{experience.__name__}_{"FEED_TYPE_STATE" if s_format == FEED_TYPE_STATE else "FEED_TYPE_IMAGE"}' + interp = AgentInterpretation(learner, ds_type=DatasetType.Train) + interp.plot_rewards(cumulative=True, per_episode=True, group_name=meta) + group_interp.add_interpretation(interp) + group_interp.to_pickle(f'../docs_src/data/walker2d_{model.name.lower()}/', + f'{model.name.lower()}_{meta}') + + del learner + del model + del data + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", 'experience'], + list(product(p_model, p_full_format, p_exp))) +def test_ddpg_models_ant(model_cls, s_format, experience): + group_interp = GroupAgentInterpretation() + for i in range(5): + print('\n') + data = MDPDataBunch.from_env('AntPyBulletEnv-v0', render='human', bs=64, add_valid=False,feed_type=s_format) + exploration_method = OrnsteinUhlenbeck(size=data.action.taken_action.shape, epsilon_start=1, epsilon_end=0.1, + decay=0.00001) + memory = experience(memory_size=1000000, reduce_ram=True) + model = create_ddpg_model(data=data, base_arch=model_cls, lr=1e-3, actor_lr=1e-4,) + learner = ddpg_learner(data=data, model=model, memory=memory, exploration_method=exploration_method, + opt_func=torch.optim.Adam, callback_fns=[RewardMetric, EpsilonMetric]) + learner.fit(1000) + + meta = f'{experience.__name__}_{"FEED_TYPE_STATE" if s_format == FEED_TYPE_STATE else "FEED_TYPE_IMAGE"}' + interp = AgentInterpretation(learner, ds_type=DatasetType.Train) + interp.plot_rewards(cumulative=True, per_episode=True, group_name=meta) + group_interp.add_interpretation(interp) + group_interp.to_pickle(f'../docs_src/data/ant_{model.name.lower()}/', + f'{model.name.lower()}_{meta}') + + del learner + del model + del data + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", 'experience'], + list(product(p_model, p_full_format, p_exp))) +def test_ddpg_models_halfcheetah(model_cls, s_format, experience): + group_interp = GroupAgentInterpretation() + for i in range(5): + print('\n') + data = MDPDataBunch.from_env('HalfCheetahPyBulletEnv-v0', render='human', bs=64, add_valid=False, + feed_type=s_format) + exploration_method = OrnsteinUhlenbeck(size=data.action.taken_action.shape, epsilon_start=1, epsilon_end=0.1, + decay=0.0001) + memory = experience(memory_size=1000000, reduce_ram=True) + model = create_ddpg_model(data=data, base_arch=model_cls) + learner = ddpg_learner(data=data, model=model, memory=memory, exploration_method=exploration_method, + callback_fns=[RewardMetric, EpsilonMetric]) + learner.fit(2000) + + meta = f'{experience.__name__}_{"FEED_TYPE_STATE" if s_format == FEED_TYPE_STATE else "FEED_TYPE_IMAGE"}' + interp = AgentInterpretation(learner, ds_type=DatasetType.Train) + interp.plot_rewards(cumulative=True, per_episode=True, group_name=meta) + group_interp.add_interpretation(interp) + group_interp.to_pickle(f'../docs_src/data/halfcheetah_{model.name.lower()}/', + f'{model.name.lower()}_{meta}') + + del learner + del model + del data \ No newline at end of file diff --git a/tests/test_dqn.py b/tests/test_dqn.py new file mode 100644 index 0000000..be45740 --- /dev/null +++ b/tests/test_dqn.py @@ -0,0 +1,173 @@ +from itertools import product +from time import sleep + +import pytest +from fastai.basic_data import DatasetType + +from fast_rl.agents.dqn import create_dqn_model, dqn_learner +from fast_rl.agents.dqn_models import * +from fast_rl.core.agent_core import ExperienceReplay, PriorityExperienceReplay, GreedyEpsilon +from fast_rl.core.data_block import MDPDataBunch, FEED_TYPE_STATE, FEED_TYPE_IMAGE +from fast_rl.core.metrics import RewardMetric, EpsilonMetric +from fast_rl.core.train import GroupAgentInterpretation, AgentInterpretation +from torch import optim + +p_model = [FixedTargetDQNModule, DQNModule, DoubleDuelingModule, DuelingDQNModule, DoubleDQNModule] +p_exp = [ExperienceReplay, PriorityExperienceReplay] +p_format = [FEED_TYPE_STATE]#, FEED_TYPE_IMAGE] +p_envs = ['CartPole-v1'] + +config_env_expectations = { + 'CartPole-v1': {'action_shape': (1, 2), 'state_shape': (1, 4)}, + 'maze-random-5x5-v0': {'action_shape': (1, 4), 'state_shape': (1, 2)} +} + + +def trained_learner(model_cls, env, s_format, experience, bs, layers, memory_size=1000000, decay=0.001, + copy_over_frequency=300, lr=None, epochs=450): + if lr is None: lr = [0.001, 0.00025] + memory = experience(memory_size=memory_size, reduce_ram=True) + explore = GreedyEpsilon(epsilon_start=1, epsilon_end=0.1, decay=decay) + if type(lr) == list: lr = lr[0] if model_cls == DQNModule else lr[1] + data = MDPDataBunch.from_env(env, render='human', bs=bs, add_valid=False, feed_type=s_format) + if model_cls == DQNModule: model = create_dqn_model(data=data, base_arch=model_cls, lr=lr, layers=layers, opt=optim.RMSProp) + else: model = create_dqn_model(data=data, base_arch=model_cls, lr=lr, layers=layers) + learn = dqn_learner(data, model, memory=memory, exploration_method=explore, copy_over_frequency=copy_over_frequency, + callback_fns=[RewardMetric, EpsilonMetric]) + learn.fit(epochs) + return learn + +# @pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", "env"], list(product(p_model, p_format, p_envs))) +def test_dqn_create_dqn_model(model_cls, s_format, env): + data = MDPDataBunch.from_env(env, render='rgb_array', bs=32, add_valid=False, feed_type=s_format) + model = create_dqn_model(data, model_cls) + model.eval() + model(data.state.s) + + assert config_env_expectations[env]['action_shape'] == (1, data.action.n_possible_values.item()) + if s_format == FEED_TYPE_STATE: + assert config_env_expectations[env]['state_shape'] == data.state.s.shape + + +# @pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", "mem", "env"], list(product(p_model, p_format, p_exp, p_envs))) +def test_dqn_dqn_learner(model_cls, s_format, mem, env): + data = MDPDataBunch.from_env(env, render='rgb_array', bs=32, add_valid=False, feed_type=s_format) + model = create_dqn_model(data, model_cls) + memory = mem(memory_size=1000, reduce_ram=True) + exploration_method = GreedyEpsilon(epsilon_start=1, epsilon_end=0.1, decay=0.001) + dqn_learner(data=data, model=model, memory=memory, exploration_method=exploration_method) + + assert config_env_expectations[env]['action_shape'] == (1, data.action.n_possible_values.item()) + if s_format == FEED_TYPE_STATE: + assert config_env_expectations[env]['state_shape'] == data.state.s.shape + + +# @pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", "mem", "env"], list(product(p_model, p_format, p_exp, p_envs))) +def test_dqn_fit(model_cls, s_format, mem, env): + data = MDPDataBunch.from_env(env, render='rgb_array', bs=5, max_steps=20, add_valid=False, feed_type=s_format) + model = create_dqn_model(data, model_cls, opt=torch.optim.RMSprop) + memory = mem(memory_size=1000, reduce_ram=True) + exploration_method = GreedyEpsilon(epsilon_start=1, epsilon_end=0.1, decay=0.001) + learner = dqn_learner(data=data, model=model, memory=memory, exploration_method=exploration_method) + learner.fit(2) + + assert config_env_expectations[env]['action_shape'] == (1, data.action.n_possible_values.item()) + if s_format == FEED_TYPE_STATE: + assert config_env_expectations[env]['state_shape'] == data.state.s.shape + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", "mem"], list(product(p_model, p_format, p_exp))) +def test_dqn_fit_maze_env(model_cls, s_format, mem): + success = False + while not success: + try: + data = MDPDataBunch.from_env('maze-random-5x5-v0', render='rgb_array', bs=5, max_steps=20, + add_valid=False, feed_type=s_format) + model = create_dqn_model(data, model_cls, opt=torch.optim.RMSprop) + memory = ExperienceReplay(10000) + exploration_method = GreedyEpsilon(epsilon_start=1, epsilon_end=0.1, decay=0.001) + learner = dqn_learner(data=data, model=model, memory=memory, exploration_method=exploration_method, + callback_fns=[RewardMetric, EpsilonMetric]) + learner.fit(2) + + assert config_env_expectations['maze-random-5x5-v0']['action_shape'] == ( + 1, data.action.n_possible_values.item()) + if s_format == FEED_TYPE_STATE: + assert config_env_expectations['maze-random-5x5-v0']['state_shape'] == data.state.s.shape + sleep(1) + success = True + except Exception as e: + if not str(e).__contains__('Surface'): + raise Exception + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", 'experience'], list(product(p_model, p_format, p_exp))) +def test_dqn_models_minigrids(model_cls, s_format, experience): + group_interp = GroupAgentInterpretation() + for i in range(5): + learn = trained_learner(model_cls, 'MiniGrid-FourRooms-v0', s_format, experience, bs=32, layers=[64, 64], + memory_size=1000000, decay=0.00001, epochs=1000) + + meta = f'{experience.__name__}_{"FEED_TYPE_STATE" if s_format == FEED_TYPE_STATE else "FEED_TYPE_IMAGE"}' + interp = AgentInterpretation(learn, ds_type=DatasetType.Train) + interp.plot_rewards(cumulative=True, per_episode=True, group_name=meta) + group_interp.add_interpretation(interp) + filename = f'{learn.model.name.lower()}_{meta}' + group_interp.to_pickle(f'../docs_src/data/minigrid_{learn.model.name.lower()}/', filename) + del learn + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", 'experience'], + list(product(p_model, p_format, p_exp))) +def test_dqn_models_cartpole(model_cls, s_format, experience): + group_interp = GroupAgentInterpretation() + for i in range(5): + learn = trained_learner(model_cls, 'CartPole-v1', s_format, experience, bs=32, layers=[64, 64], + memory_size=1000000, decay=0.001) + + meta = f'{experience.__name__}_{"FEED_TYPE_STATE" if s_format == FEED_TYPE_STATE else "FEED_TYPE_IMAGE"}' + interp = AgentInterpretation(learn, ds_type=DatasetType.Train) + interp.plot_rewards(cumulative=True, per_episode=True, group_name=meta) + group_interp.add_interpretation(interp) + filename = f'{learn.model.name.lower()}_{meta}' + group_interp.to_pickle(f'../docs_src/data/cartpole_{learn.model.name.lower()}/', filename) + del learn + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", 'experience'], list(product(p_model, p_format, p_exp))) +def test_dqn_models_lunarlander(model_cls, s_format, experience): + group_interp = GroupAgentInterpretation() + for i in range(5): + learn = trained_learner(model_cls, 'LunarLander-v2', s_format, experience, bs=32, layers=[128, 64], + memory_size=1000000, decay=0.00001, copy_over_frequency=600, lr=[0.001, 0.00025]) + meta = f'{experience.__name__}_{"FEED_TYPE_STATE" if s_format == FEED_TYPE_STATE else "FEED_TYPE_IMAGE"}' + interp = AgentInterpretation(learn, ds_type=DatasetType.Train) + interp.plot_rewards(cumulative=True, per_episode=True, group_name=meta) + group_interp.add_interpretation(interp) + filename = f'{learn.model.name.lower()}_{meta}' + group_interp.to_pickle(f'../docs_src/data/lunarlander_{learn.model.name.lower()}/', filename) + del learn + + +@pytest.mark.usefixtures('skip_performance_check') +@pytest.mark.parametrize(["model_cls", "s_format", 'experience'], list(product(p_model, p_format, p_exp))) +def test_dqn_models_mountaincar(model_cls, s_format, experience): + group_interp = GroupAgentInterpretation() + for i in range(5): + learn = trained_learner(model_cls, 'MountainCar-v0', s_format, experience, bs=32, layers=[24, 12], + memory_size=1000000, decay=0.00001, copy_over_frequency=1000) + meta = f'{experience.__name__}_{"FEED_TYPE_STATE" if s_format == FEED_TYPE_STATE else "FEED_TYPE_IMAGE"}' + interp = AgentInterpretation(learn, ds_type=DatasetType.Train) + interp.plot_rewards(cumulative=True, per_episode=True, group_name=meta) + group_interp.add_interpretation(interp) + filename = f'{learn.model.name.lower()}_{meta}' + group_interp.to_pickle(f'../docs_src/data/mountaincar_{learn.model.name.lower()}/', filename) + + del learn diff --git a/tests/test_metrics.py b/tests/test_metrics.py new file mode 100644 index 0000000..50c23af --- /dev/null +++ b/tests/test_metrics.py @@ -0,0 +1,13 @@ + +# +# from fast_rl.core.agent_core import ExperienceReplay +# from fast_rl.core.basic_train import AgentLearner +# from fast_rl.core.data_block import MDPDataBunch +# from fast_rl.core.metrics import RewardMetric +# +# +# # def test_metrics_reward_init(): +# # data = MDPDataBunch.from_env('maze-random-5x5-v0', render='human', bs=4, max_steps=100) +# # model = FixedTargetDQN(data, tree=ExperienceReplay(1000, reduce_ram=True)) +# # learn = AgentLearner(data, model, callback_fns=[RewardMetric]) +# # learn.fit(3) diff --git a/tests/test_train.py b/tests/test_train.py new file mode 100644 index 0000000..3eea025 --- /dev/null +++ b/tests/test_train.py @@ -0,0 +1,100 @@ +# import pytest +# +# from fast_rl.agents.dqn import * +# from fast_rl.agents.dqn_models import FixedTargetDQNModule +# from fast_rl.core.agent_core import * +# from fast_rl.core.data_block import * +# from fast_rl.core.train import * +# +# p_model = [FixedTargetDQNModule] +# p_exp = [ExperienceReplay] +# p_format = [FEED_TYPE_STATE] +# +# config_env_expectations = { +# 'CartPole-v1': {'action_shape': (1, 2), 'state_shape': (1, 4)}, +# 'maze-random-5x5-v0': {'action_shape': (1, 4), 'state_shape': (1, 2)} +# } +# +# +# @pytest.mark.parametrize(["model_cls", "s_format", "mem"], list(product(p_model, p_format, p_exp))) +# def test_train_gym_maze_interpretation(model_cls, s_format, mem): +# success = False +# while not success: +# try: +# data = MDPDataBunch.from_env('maze-random-5x5-v0', render='rgb_array', bs=5, max_steps=50, +# add_valid=False, feed_type=s_format) +# model = create_dqn_model(data, model_cls, opt=torch.optim.RMSprop) +# memory = mem(10000) +# exploration_method = GreedyEpsilon(epsilon_start=1, epsilon_end=0.1, decay=0.001) +# learner = dqn_learner(data=data, model=model, memory=memory, exploration_method=exploration_method) +# learner.fit(1) +# +# interp = GymMazeInterpretation(learner, ds_type=DatasetType.Train) +# for i in range(-1, 4): interp.plot_heat_map(action=i) +# +# success = True +# except Exception as e: +# if not str(e).__contains__('Surface'): +# raise Exception +# +# +# @pytest.mark.parametrize(["model_cls", "s_format", "mem"], list(product(p_model, p_format, p_exp))) +# def test_train_q_value_interpretation(model_cls, s_format, mem): +# success = False +# while not success: +# try: +# data = MDPDataBunch.from_env('maze-random-5x5-v0', render='rgb_array', bs=5, max_steps=50, +# add_valid=False, feed_type=s_format) +# model = create_dqn_model(data, model_cls, opt=torch.optim.RMSprop) +# memory = mem(10000) +# exploration_method = GreedyEpsilon(epsilon_start=1, epsilon_end=0.1, decay=0.001) +# learner = dqn_learner(data=data, model=model, memory=memory, exploration_method=exploration_method) +# learner.fit(1) +# +# interp = QValueInterpretation(learner, ds_type=DatasetType.Train) +# interp.plot_q() +# +# success = True +# except Exception as e: +# if not str(e).__contains__('Surface'): +# raise Exception(e) +# +# # +# # def test_groupagentinterpretation_from_pickle(): +# # group_interp = GroupAgentInterpretation.from_pickle('./data/cartpole_dqn', +# # 'dqn_PriorityExperienceReplay_FEED_TYPE_STATE') +# # group_interp.plot_reward_bounds(return_fig=True, per_episode=True, smooth_groups=5).show() +# # +# # +# # def test_groupagentinterpretation_analysis(): +# # group_interp = GroupAgentInterpretation.from_pickle('./data/cartpole_dqn', +# # 'dqn_PriorityExperienceReplay_FEED_TYPE_STATE') +# # assert isinstance(group_interp.analysis, list) +# # group_interp.in_notebook = True +# # assert isinstance(group_interp.analysis, pd.DataFrame) +# +# +# +# +# # +# # def test_interpretation_reward_group_plot(): +# # group_interp = GroupAgentInterpretation() +# # group_interp2 = GroupAgentInterpretation() +# # +# # for i in range(2): +# # data = MDPDataBunch.from_env('CartPole-v0', render='rgb_array', bs=4, add_valid=False) +# # model = DQN(data) +# # learn = AgentLearner(data, model) +# # learn.fit(2) +# # +# # interp = AgentInterpretation(learn=learn, ds_type=DatasetType.Train) +# # interp.plot_rewards(cumulative=True, per_episode=True, group_name='run1') +# # group_interp.add_interpretation(interp) +# # group_interp2.add_interpretation(interp) +# # +# # group_interp.plot_reward_bounds(return_fig=True, per_episode=True).show() +# # group_interp2.plot_reward_bounds(return_fig=True, per_episode=True).show() +# # +# # new_interp = group_interp.merge(group_interp2) +# # assert len(new_interp.groups) == len(group_interp.groups) + len(group_interp2.groups), 'Lengths do not match' +# # new_interp.plot_reward_bounds(return_fig=True, per_episode=True).show()